Editor performance, a data-loss fix, and fixes from a full-app review

app/src/main/AndroidManifest.xml

@@ -141,7 +141,6 @@
                 <category android:name="android.intent.category.DEFAULT" />
 
                 <data android:scheme="content" />
-                <data android:scheme="file" />
                 <data android:mimeType="text/plain" />
             </intent-filter>
             <intent-filter android:label="@string/save_to_notes">

app/src/main/java/com/pasich/mynotes/data/AppDataManager.java

@@ -296,6 +296,11 @@ public Completable updateNote(Note note) {
         return dbHelper.updateNote(note);
     }
 
+    @Override
+    public Completable reviveNote(Note note) {
+        return dbHelper.reviveNote(note);
+    }
+
     @Override
     public Completable moveToNotes(List<Note> notes) {
         return dbHelper.moveToNotes(notes);
@@ -402,6 +407,11 @@ public Completable updateTask(Task task) {
         return dbHelper.updateTask(task);
     }
 
+    @Override
+    public Completable updateTasks(List<Task> tasks) {
+        return dbHelper.updateTasks(tasks);
+    }
+
     @Override
     public Completable deleteTask(Task task) {
         return dbHelper.deleteTask(task);

app/src/main/java/com/pasich/mynotes/data/database/AppDbHelper.java

@@ -196,7 +196,17 @@ public Completable deleteNote(ArrayList<Note> notes) {
 
     @Override
     public Completable updateNote(Note note) {
-        return Completable.fromAction(() -> syncMutationCoordinator.updateNoteContent(note));
+        return Completable.fromAction(() -> {
+            // A note deleted meanwhile must not read as saved: every later edit would be lost.
+            if (!syncMutationCoordinator.updateNoteContent(note)) {
+                throw new NoteDeletedException(note.getId());
+            }
+        });
+    }
+
+    @Override
+    public Completable reviveNote(Note note) {
+        return Completable.fromAction(() -> syncMutationCoordinator.reviveNote(note));
     }
 
     @Override
@@ -306,6 +316,15 @@ public Completable updateTask(Task task) {
         return Completable.fromAction(() -> syncMutationCoordinator.updateTask(task));
     }
 
+    @Override
+    public Completable updateTasks(List<Task> tasks) {
+        // One transaction, so the task lists are reloaded once rather than once per task.
+        return Completable.fromAction(() ->
+                appDatabase.runInTransaction(() -> {
+                    for (Task task : tasks) syncMutationCoordinator.updateTask(task);
+                }));
+    }
+
     @Override
     public Completable deleteTask(Task task) {
         return Completable.fromAction(() -> syncMutationCoordinator.deleteTask(task));

app/src/main/java/com/pasich/mynotes/data/database/NoteDeletedException.java

@@ -0,0 +1,12 @@
+package com.pasich.mynotes.data.database;
+
+/**
+ * A note's content could not be written because the note no longer exists, for instance because a
+ * sync applied another device's delete while it was open. Nothing was written.
+ */
+public class NoteDeletedException extends RuntimeException {
+
+    public NoteDeletedException(long noteId) {
+        super("Note " + noteId + " no longer exists");
+    }
+}

app/src/main/java/com/pasich/mynotes/data/database/dao/SyncConflictDao.java

@@ -26,11 +26,21 @@ public interface SyncConflictDao {
     @Query("SELECT COUNT(*) FROM sync_conflicts WHERE resolved = 0")
     int getUnresolvedCount();
 
-    /** Both sides of every settled conflict; neither version may be offered again. */
+    /**
+     * Both sides of every settled conflict, most recently settled first; neither version may be
+     * offered again.
+     *
+     * <p>The order matters: the bundle carries only a bounded number of these, and the plain UNION
+     * this used to be returned them in whatever order SQLite's de-duplication left them, so the cap
+     * dropped arbitrary — often the newest — settlements and offered them again.
+     */
     @Query(
-            "SELECT winnerVersionId FROM sync_conflicts WHERE resolved = 1 AND winnerVersionId != ''"
-                    + " UNION SELECT loserVersionId FROM sync_conflicts WHERE resolved = 1 AND"
-                    + " loserVersionId != ''")
+            "SELECT versionId FROM ("
+                    + "SELECT winnerVersionId AS versionId, resolvedAt, id FROM sync_conflicts"
+                    + " WHERE resolved = 1 AND winnerVersionId != ''"
+                    + " UNION ALL SELECT loserVersionId AS versionId, resolvedAt, id"
+                    + " FROM sync_conflicts WHERE resolved = 1 AND loserVersionId != '')"
+                    + " GROUP BY versionId ORDER BY MAX(resolvedAt) DESC, MAX(id) DESC")
     List<String> getResolvedVersionIds();
 
     @Query("SELECT * FROM sync_conflicts WHERE id = :id LIMIT 1")
@@ -51,6 +61,18 @@ public interface SyncConflictDao {
                     + "AND stableId = :stableId AND winnerVersionId != :winnerVersionId")
     void deleteSupersededUnresolved(String recordType, String stableId, String winnerVersionId);
 
+    /**
+     * Deletes every settled conflict but the {@code keep} most recently settled ones.
+     *
+     * <p>Settled rows only exist to stop a version being offered again, and only the newest ones
+     * are ever published; without this they accumulated for the life of the install.
+     */
+    @Query(
+            "DELETE FROM sync_conflicts WHERE resolved = 1 AND id NOT IN ("
+                    + "SELECT id FROM sync_conflicts WHERE resolved = 1"
+                    + " ORDER BY resolvedAt DESC, id DESC LIMIT :keep)")
+    int deleteResolvedBeyond(int keep);
+
     @Query(
             "UPDATE sync_conflicts SET resolution = :resolution, resolved = 1, resolvedAt = :resolvedAt WHERE id = :id")
     void markResolved(long id, String resolution, long resolvedAt);

app/src/main/java/com/pasich/mynotes/data/database/dao/SyncMetadataDao.java

@@ -40,6 +40,12 @@ public interface SyncMetadataDao {
                     + "WHERE recordType = :recordType AND localId IN (:localIds)")
     List<Long> getExistingLocalIds(String recordType, List<Long> localIds);
 
+    /** The rows of {@code localIds} that exist; the caller chunks the list. */
+    @Query(
+            "SELECT * FROM sync_metadata "
+                    + "WHERE recordType = :recordType AND localId IN (:localIds)")
+    List<SyncMetadataEntity> getByLocalIds(String recordType, List<Long> localIds);
+
     @Query(
             "SELECT * FROM sync_metadata WHERE recordType = :recordType AND stableId = :stableId LIMIT 1")
     SyncMetadataEntity getByStableId(String recordType, String stableId);
@@ -64,7 +70,13 @@ public interface SyncMetadataDao {
                     + "WHERE recordType = :recordType AND localId = :localId")
     void touch(String recordType, long localId, long nowMillis);
 
-    /** Retains the metadata row and records a monotonic tombstone timestamp. */
+    /**
+     * Retains the metadata row and records a monotonic tombstone timestamp.
+     *
+     * <p>Tombstone rows are never deleted. Old ones stop being published (see {@code
+     * SyncService.forPublication}), and the row kept here is what lets this device answer a stale
+     * live copy republished by a device that never saw the deletion.
+     */
     @Query(
             "UPDATE sync_metadata SET "
                     + "updatedAt = CASE WHEN updatedAt >= :nowMillis THEN updatedAt + 1 ELSE :nowMillis END, "

app/src/main/java/com/pasich/mynotes/data/database/helpers/DbNotesHelper.java

@@ -32,6 +32,12 @@ public interface DbNotesHelper {
 
     Completable updateNote(Note note);
 
+    /**
+     * Stores a note's content, putting the note back under its own id when it was deleted
+     * meanwhile.
+     */
+    Completable reviveNote(Note note);
+
     Completable moveToNotes(List<Note> notes);
 
     Completable setTagNote(String nameTag, int idNote);

app/src/main/java/com/pasich/mynotes/data/database/helpers/DbTasksHelper.java

@@ -18,6 +18,9 @@ public interface DbTasksHelper {
 
     Completable updateTask(Task task);
 
+    /** Updates several tasks in one transaction, e.g. their positions after a drag. */
+    Completable updateTasks(List<Task> tasks);
+
     Completable deleteTask(Task task);
 
     Completable toggleTask(int taskId, boolean isDone);

app/src/main/java/com/pasich/mynotes/data/sync/GoogleDriveSyncBackend.java

@@ -116,6 +116,16 @@ public final class GoogleDriveSyncBackend implements SyncBackend {
      */
     private final Map<String, Long> verifiedAttachments = new HashMap<>();
 
+    /**
+     * Candidate listings already made during this sync, keyed by root and hash.
+     *
+     * <p>The service asks whether a blob exists and then whether it is verified, and each question
+     * listed the root again: two Drive listings per attachment per sync, for every attachment in
+     * the library. The answer the first one got is the one the second needs. Anything this backend
+     * uploads drops the listing for its root and hash, so a fresh copy is always seen.
+     */
+    private final Map<String, List<AttachmentCandidate>> candidateListings = new HashMap<>();
+
     public GoogleDriveSyncBackend(@NonNull String accessToken) {
         this(accessToken, DEFAULT_API, DEFAULT_UPLOAD, Clock.systemUTC(), new SyncBundleCodec());
     }
@@ -667,6 +677,11 @@ private AttachmentCandidate(
     @NonNull
     private List<AttachmentCandidate> listAttachmentCandidates(
             @NonNull String folderId, @NonNull String sha256) throws IOException {
+        String listingKey = memoKey(folderId, sha256);
+        List<AttachmentCandidate> listed = candidateListings.get(listingKey);
+        if (listed != null) {
+            return listed;
+        }
         JsonArray files =
                 listFiles(
                         ownedFilesQuery(folderId, PROPERTY_ATTACHMENT_SHA256, sha256),
@@ -684,7 +699,9 @@ private List<AttachmentCandidate> listAttachmentCandidates(
         // same hash are byte-identical and either one will do. Rejecting them used to break every
         // subsequent sync permanently.
         candidates.sort(Comparator.comparing(candidate -> candidate.id));
-        return candidates;
+        List<AttachmentCandidate> result = Collections.unmodifiableList(candidates);
+        candidateListings.put(listingKey, result);
+        return result;
     }
 
     /**
@@ -1148,6 +1165,11 @@ private void uploadAttachmentOrConfirm(
         if (sizeBytes < 0L) {
             throw new IllegalArgumentException("An attachment upload needs a declared size");
         }
+        // Whatever happens next, the remembered listing no longer describes this root. It is
+        // dropped once, up front: the upload itself never lists, and every caller holds this
+        // backend's lock, so nothing can remember a listing again before the upload ends. The
+        // discovery below lists afresh, and what it remembers includes what the upload created.
+        candidateListings.remove(memoKey(folderId, sha256));
         try {
             uploadStream(folderId, sha256, MIME_BINARY, content, sizeBytes);
         } catch (IOException uploadFailure) {