Android topics — 12: Favorite שנשמר גם אחרי סגירת האפליקציה

package com.example.topics;

import androidx.room.Entity;
import androidx.room.PrimaryKey;

/** Version 1: one row means this book ID is a favorite. */
@Entity(tableName = "favorites")
public final class FavoriteEntity {
    @PrimaryKey
    public int bookId;

    /**
     * Creates a version-1 favorite row; row presence means this ID is saved.
     *
     * @param bookId stable book identity used as the primary key
     */
    public FavoriteEntity(int bookId) {
        this.bookId = bookId;
    }
}

package com.example.topics;

import androidx.room.Dao;
import androidx.room.Insert;
import androidx.room.Query;
import androidx.room.Transaction;

import java.util.List;

/** Queries and one atomic read-then-write action. */
@Dao
public abstract class FavoriteDao {
    /**
     * Reads stored favorite identities on a worker thread.
     *
     * @return identities whose rows exist, with no ordering guarantee
     */
    @Query("SELECT bookId FROM favorites")
    public abstract List<Integer> loadIds();

    /**
     * Checks row presence within the transaction that decides a toggle.
     *
     * @param id stable book identity
     * @return whether this identity is currently stored
     */
    @Query("SELECT EXISTS(SELECT 1 FROM favorites WHERE bookId = :id)")
    protected abstract boolean contains(int id);

    /**
     * Inserts one favorite row; duplicate primary keys are rejected.
     *
     * @param favorite row to persist
     */
    @Insert
    protected abstract void insert(FavoriteEntity favorite);

    /**
     * Deletes only the row for the requested identity.
     *
     * @param id stable identity to unsave
     */
    @Query("DELETE FROM favorites WHERE bookId = :id")
    protected abstract void delete(int id);

    /**
     * Atomically reads and reverses row presence within one Room transaction.
     *
     * @param id stable book identity
     * @return true when now saved, false when now removed
     */
    @Transaction
    public boolean toggle(int id) {
        if (contains(id)) {
            delete(id);
            return false;
        }
        insert(new FavoriteEntity(id));
        return true;
    }
}

package com.example.topics;

import androidx.room.Database;
import androidx.room.RoomDatabase;

/** First schema checkpoint. */
@Database(entities = {FavoriteEntity.class}, version = 1, exportSchema = true)
public abstract class TopicsDatabase extends RoomDatabase {
    /**
     * Provides Room's generated DAO implementation for this database.
     *
     * @return DAO that must be called off the UI thread
     */
    public abstract FavoriteDao favoriteDao();
}

package com.example.topics;

import android.app.Application;
import android.os.Handler;
import android.os.Looper;
import androidx.room.Room;
import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/** Runs Room work off main and delivers snapshots on main. */
public final class FavoritesRepository {
    public interface Listener {
        /**
         * Receives a database-confirmed snapshot on the main thread.
         *
         * @param ids stored favorite identities, independent of previous callbacks
         */
        void onFavorites(Set<Integer> ids);
    }

    private final TopicsDatabase database;
    private final ExecutorService io = Executors.newSingleThreadExecutor();
    private final Handler main = new Handler(Looper.getMainLooper());
    private volatile boolean closed;

    /**
     * Owns a database and serial I/O queue using a context independent of any Activity.
     *
     * @param application long-lived application context for opening the private database
     */
    public FavoritesRepository(Application application) {
        database = Room.databaseBuilder(application, TopicsDatabase.class,
                "favorites.db").build();
    }

    /**
     * Queues a read of stored identities without blocking the screen.
     *
     * @param listener recipient of the snapshot delivered on main
     */
    public void load(Listener listener) {
        io.execute(() -> deliver(listener));
    }

    /**
     * Queues the transaction and then reads the resulting identities on the same worker.
     *
     * @param id stable identity to toggle
     * @param listener recipient of the confirmed snapshot on main
     */
    public void toggle(int id, Listener listener) {
        io.execute(() -> {
            database.favoriteDao().toggle(id);
            deliver(listener);
        });
    }

    /**
     * Reads current identities on I/O and posts their snapshot to main if still open.
     *
     * @param listener receiver of the database-confirmed state
     */
    private void deliver(Listener listener) {
        Set<Integer> snapshot = new HashSet<>(database.favoriteDao().loadIds());
        main.post(() -> {
            if (!closed) listener.onFavorites(snapshot);
        });
    }

    /**
     * Suppresses late callbacks and queues database close after accepted I/O work.
     */
    public void close() {
        closed = true;
        // A serial queue closes only after operations already accepted have finished.
        io.execute(database::close);
        io.shutdown();
    }
}

/**
 * Requests a persisted change; the confirmed snapshot determines the displayed star.
 *
 * @param id stable identity of the clicked book
 */
public void toggleFavorite(int id) {
    BooksUiState current = state.getValue();
    if (current == null || current.kind != BooksUiState.Kind.SUCCESS) return;
    favorites.toggle(id, this::showFavorites);
}

/**
 * Replaces in-memory projection from a database-confirmed snapshot on main.
 *
 * @param ids all currently stored favorite identities
 */
private void showFavorites(Set<Integer> ids) {
    favoriteIds.clear();
    favoriteIds.addAll(ids);
    BooksUiState current = state.getValue();
    if (current == null || current.kind != BooksUiState.Kind.SUCCESS) return;
    Book[] books = current.getBooks();
    for (int index = 0; index < books.length; index++) {
        books[index] = books[index].withFavorite(
                favoriteIds.contains(books[index].id));
    }
    state.setValue(BooksUiState.success(books));
}

public static final Migration MIGRATION_1_2 = new Migration(1, 2) {
    /**
     * Adds a non-null note without deleting existing favorite rows.
     *
     * @param db version-1 database to upgrade in Room's migration transaction
     */
    @Override
    public void migrate(@NonNull SupportSQLiteDatabase db) {
        db.execSQL("ALTER TABLE favorites ADD COLUMN note TEXT NOT NULL DEFAULT ''");
    }
};

package com.example.topics;

import android.database.Cursor;
import androidx.room.Room;
import androidx.room.testing.MigrationTestHelper;
import androidx.sqlite.db.SupportSQLiteDatabase;
import androidx.test.ext.junit.runners.AndroidJUnit4;
import androidx.test.platform.app.InstrumentationRegistry;
import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import java.io.IOException;
import static org.junit.Assert.*;

@RunWith(AndroidJUnit4.class)
public final class RoomMigrationTest {
    private static final String TEST_DB = "migration-test.db";

    @Rule public MigrationTestHelper helper = new MigrationTestHelper(
            InstrumentationRegistry.getInstrumentation(), TopicsDatabase.class);

    /**
     * Upgrades a database containing an old row and validates both schema and values.
     *
     * @throws IOException if the test database cannot be created or upgraded
     */
    @Test
    public void migrationKeepsFavoriteAndAddsDefaultNote() throws IOException {
        SupportSQLiteDatabase old = helper.createDatabase(TEST_DB, 1);
        old.execSQL("INSERT INTO favorites (bookId) VALUES (7)");
        old.close();

        SupportSQLiteDatabase upgraded = helper.runMigrationsAndValidate(
                TEST_DB, 2, true, TopicsDatabase.MIGRATION_1_2);
        try (Cursor rows = upgraded.query("SELECT bookId, note FROM favorites")) {
            assertTrue(rows.moveToFirst());
            assertEquals(7, rows.getInt(0));
            assertEquals("", rows.getString(1));
            assertFalse(rows.moveToNext());
        }
        upgraded.close();
    }

    /**
     * Exercises the real generated DAO: first toggle inserts, second removes.
     */
    @Test
    public void toggleTransactionChangesExactlyOneRow() {
        TopicsDatabase database = Room.inMemoryDatabaseBuilder(
                InstrumentationRegistry.getInstrumentation().getTargetContext(),
                TopicsDatabase.class).build();
        try {
            FavoriteDao dao = database.favoriteDao();
            assertTrue(dao.toggle(7));
            assertEquals(1, dao.loadIds().size());
            assertFalse(dao.toggle(7));
            assertTrue(dao.loadIds().isEmpty());
        } finally {
            database.close();
        }
    }
}