bounding box

Author: alexdremov

app/src/main/java/com/alexdremov/notate/data/CanvasRepository.kt

@@ -43,6 +43,7 @@ class CanvasRepository(
         val savedPath: String,
         val newLastModified: Long,
         val newSize: Long,
+        val isConflict: Boolean = false,
     )
 
     private val sessionsDir: File by lazy {
@@ -632,6 +633,7 @@ class CanvasRepository(
                         }
                     }
 
+                    val isConflict = targetPath != path
                     atomicStorage.pack(session.sessionDir, targetPath)
 
                     val savedFile = File(targetPath)
@@ -648,7 +650,7 @@ class CanvasRepository(
                         Logger.e("CanvasRepository", "Failed to update origin_info.txt after save", e)
                     }
 
-                    SaveResult(targetPath, newLastModified, newSize)
+                    SaveResult(targetPath, newLastModified, newSize, isConflict)
                 }
             } catch (e: Exception) {
                 Logger.e("CanvasRepository", "Failed to save session", e, showToUser = true)

app/src/main/java/com/alexdremov/notate/data/StorageProvider.kt

@@ -80,6 +80,45 @@ internal object StorageUtils {
             "$originalName Copy"
         }
 
+    fun getOriginInfo(
+        context: Context,
+        path: String,
+    ): Pair<Long, Long> {
+        if (path.startsWith("content://")) {
+            val uri = android.net.Uri.parse(path)
+            return try {
+                context.contentResolver
+                    .query(
+                        uri,
+                        arrayOf(
+                            android.provider.DocumentsContract.Document.COLUMN_LAST_MODIFIED,
+                            android.provider.OpenableColumns.SIZE,
+                        ),
+                        null,
+                        null,
+                        null,
+                    )?.use { cursor ->
+                        if (cursor.moveToFirst()) {
+                            val lastMod = cursor.getLong(0)
+                            val size = cursor.getLong(1)
+                            Pair(lastMod, size)
+                        } else {
+                            Pair(0L, 0L)
+                        }
+                    } ?: Pair(0L, 0L)
+            } catch (e: Exception) {
+                Pair(0L, 0L)
+            }
+        } else {
+            val file = File(path)
+            return if (file.exists()) {
+                Pair(file.lastModified(), file.length())
+            } else {
+                Pair(0L, 0L)
+            }
+        }
+    }
+
     fun injectUuidIntoJson(
         inputStream: InputStream,
         outputStream: OutputStream,

app/src/main/java/com/alexdremov/notate/ui/input/PenInputHandler.kt

@@ -602,7 +602,7 @@ class PenInputHandler(
                                         segmentPath.moveTo(newTouchPoints[0].x, newTouchPoints[0].y)
                                         for (i in 1 until newTouchPoints.size) {
                                             segmentPath.lineTo(
-                                                newTouchPoints[i].size,
+                                                newTouchPoints[i].x,
                                                 newTouchPoints[i].y,
                                             )
                                         }

app/src/main/java/com/alexdremov/notate/vm/DrawingViewModel.kt

@@ -11,8 +11,10 @@ import com.alexdremov.notate.model.ToolType
 import com.alexdremov.notate.model.ToolbarItem
 import com.alexdremov.notate.util.Logger
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asSharedFlow
 import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.sync.withLock
@@ -26,6 +28,16 @@ class DrawingViewModel
             com.alexdremov.notate.data
                 .CanvasRepository(application),
     ) : AndroidViewModel(application) {
+        sealed class SaveEvent {
+            data class Conflict(
+                val originalPath: String,
+                val conflictPath: String,
+            ) : SaveEvent()
+        }
+
+        private val _saveEvents = MutableSharedFlow<SaveEvent>()
+        val saveEvents = _saveEvents.asSharedFlow()
+
         // Session State
         private val _currentSession = MutableStateFlow<com.alexdremov.notate.data.CanvasSession?>(null)
         val currentSession: StateFlow<com.alexdremov.notate.data.CanvasSession?> = _currentSession.asStateFlow()
@@ -140,6 +152,11 @@ class DrawingViewModel
                         // Update origin timestamps in-place
                         session.updateOrigin(result.newLastModified, result.newSize)
 
+                        if (result.isConflict) {
+                            Logger.w("DrawingViewModel", "Conflict detected! Saved as copy: ${result.savedPath}")
+                            _saveEvents.emit(SaveEvent.Conflict(path, result.savedPath))
+                        }
+
                         if (commit) {
                             Logger.i("DrawingViewModel", "Full Save complete: ${result.savedPath}")
                         }

app/src/test/java/com/alexdremov/notate/data/CanvasRepositoryCachingTest.kt

@@ -31,16 +31,16 @@ class CanvasRepositoryCachingTest {
     fun `test active session caching - same file should return same instance`() =
         runBlocking {
             val path = File(testDir, "cache_test.notate").absolutePath
-            
+
             // 1. Open session first time
             val session1 = repository.openCanvasSession(path)!!
-            
+
             // 2. Open session second time without releasing first
             val session2 = repository.openCanvasSession(path)!!
-            
+
             // 3. They MUST be the exact same instance (cached)
             assertSame("Should return the exact same session instance from cache", session1, session2)
-            
+
             repository.releaseCanvasSession(session1)
             repository.releaseCanvasSession(session2)
         }
@@ -49,37 +49,37 @@ class CanvasRepositoryCachingTest {
     fun `test session caching after release - should return same instance if not closed`() =
         runBlocking {
             val path = File(testDir, "hot_handoff_test.notate").absolutePath
-            
+
             val session1 = repository.openCanvasSession(path)!!
-            
+
             // Release session1, but it might still be in activeSessions if no close was triggered
             // Actually, release returns if it was the last client.
             repository.releaseCanvasSession(session1)
-            
+
             // Since it was the only client, it should have been closed and removed from cache.
             // Let's verify that a NEW open returns a DIFFERENT instance (reloaded)
             val session2 = repository.openCanvasSession(path)!!
             assertNotSame("Should return a new instance after full release/close", session1, session2)
-            
+
             repository.releaseCanvasSession(session2)
         }
 
     @Test
     fun `test session persistence - cold re-open should return different instance but same state`() =
         runBlocking {
             val path = File(testDir, "persistence_test.notate").absolutePath
-            
+
             val session1 = repository.openCanvasSession(path)!!
             session1.updateMetadata(session1.metadata.copy(offsetX = 999f))
             repository.saveCanvasSession(path, session1)
             repository.releaseCanvasSession(session1)
-            
+
             // Cold re-open (new instance, but reuses session directory if valid)
             val session2 = repository.openCanvasSession(path)!!
-            
+
             assertNotSame("Should be a different instance", session1, session2)
             assertEquals("Should have persisted state", 999f, session2.metadata.offsetX)
-            
+
             repository.releaseCanvasSession(session2)
         }
 }