Initial Commit

src/main/kotlin/com/looker/droidify/database/CursorOwner.kt

@@ -0,0 +1,101 @@
+package com.looker.droidify.database
+
+import android.database.Cursor
+import android.os.Bundle
+import androidx.fragment.app.Fragment
+import androidx.loader.app.LoaderManager
+import androidx.loader.content.Loader
+import com.looker.droidify.entity.ProductItem
+
+class CursorOwner: Fragment(), LoaderManager.LoaderCallbacks<Cursor> {
+  sealed class Request {
+    internal abstract val id: Int
+
+    data class ProductsAvailable(val searchQuery: String, val section: ProductItem.Section,
+      val order: ProductItem.Order): Request() {
+      override val id: Int
+        get() = 1
+    }
+
+    data class ProductsInstalled(val searchQuery: String, val section: ProductItem.Section,
+      val order: ProductItem.Order): Request() {
+      override val id: Int
+        get() = 2
+    }
+
+    data class ProductsUpdates(val searchQuery: String, val section: ProductItem.Section,
+      val order: ProductItem.Order): Request() {
+      override val id: Int
+        get() = 3
+    }
+
+    object Repositories: Request() {
+      override val id: Int
+        get() = 4
+    }
+  }
+
+  interface Callback {
+    fun onCursorData(request: Request, cursor: Cursor?)
+  }
+
+  private data class ActiveRequest(val request: Request, val callback: Callback?, val cursor: Cursor?)
+
+  init {
+    retainInstance = true
+  }
+
+  private val activeRequests = mutableMapOf<Int, ActiveRequest>()
+
+  fun attach(callback: Callback, request: Request) {
+    val oldActiveRequest = activeRequests[request.id]
+    if (oldActiveRequest?.callback != null &&
+      oldActiveRequest.callback != callback && oldActiveRequest.cursor != null) {
+      oldActiveRequest.callback.onCursorData(oldActiveRequest.request, null)
+    }
+    val cursor = if (oldActiveRequest?.request == request && oldActiveRequest.cursor != null) {
+      callback.onCursorData(request, oldActiveRequest.cursor)
+      oldActiveRequest.cursor
+    } else {
+      null
+    }
+    activeRequests[request.id] = ActiveRequest(request, callback, cursor)
+    if (cursor == null) {
+      LoaderManager.getInstance(this).restartLoader(request.id, null, this)
+    }
+  }
+
+  fun detach(callback: Callback) {
+    for (id in activeRequests.keys) {
+      val activeRequest = activeRequests[id]!!
+      if (activeRequest.callback == callback) {
+        activeRequests[id] = activeRequest.copy(callback = null)
+      }
+    }
+  }
+
+  override fun onCreateLoader(id: Int, args: Bundle?): Loader<Cursor> {
+    val request = activeRequests[id]!!.request
+    return QueryLoader(requireContext()) {
+      when (request) {
+        is Request.ProductsAvailable -> Database.ProductAdapter
+          .query(false, false, request.searchQuery, request.section, request.order, it)
+        is Request.ProductsInstalled -> Database.ProductAdapter
+          .query(true, false, request.searchQuery, request.section, request.order, it)
+        is Request.ProductsUpdates -> Database.ProductAdapter
+          .query(true, true, request.searchQuery, request.section, request.order, it)
+        is Request.Repositories -> Database.RepositoryAdapter.query(it)
+      }
+    }
+  }
+
+  override fun onLoadFinished(loader: Loader<Cursor>, data: Cursor?) {
+    val activeRequest = activeRequests[loader.id]
+    if (activeRequest != null) {
+      activeRequests[loader.id] = activeRequest.copy(cursor = data)
+      activeRequest.callback?.onCursorData(activeRequest.request, data)
+    }
+  }
+
+  override fun onLoaderReset(loader: Loader<Cursor>) = onLoadFinished(loader, null)
+}

src/main/kotlin/com/looker/droidify/database/Database.kt

@@ -0,0 +1,659 @@
+package com.looker.droidify.database
+
+import android.content.ContentValues
+import android.content.Context
+import android.database.Cursor
+import android.database.sqlite.SQLiteDatabase
+import android.database.sqlite.SQLiteOpenHelper
+import android.os.CancellationSignal
+import com.fasterxml.jackson.core.JsonGenerator
+import com.fasterxml.jackson.core.JsonParser
+import io.reactivex.rxjava3.core.Observable
+import com.looker.droidify.entity.InstalledItem
+import com.looker.droidify.entity.Product
+import com.looker.droidify.entity.ProductItem
+import com.looker.droidify.entity.Repository
+import com.looker.droidify.utility.extension.android.*
+import com.looker.droidify.utility.extension.json.*
+import java.io.ByteArrayOutputStream
+
+object Database {
+  fun init(context: Context): Boolean {
+    val helper = Helper(context)
+    db = helper.writableDatabase
+    if (helper.created) {
+      for (repository in Repository.defaultRepositories) {
+        RepositoryAdapter.put(repository)
+      }
+    }
+    return helper.created || helper.updated
+  }
+
+  private lateinit var db: SQLiteDatabase
+
+  private interface Table {
+    val memory: Boolean
+    val innerName: String
+    val createTable: String
+    val createIndex: String?
+      get() = null
+
+    val databasePrefix: String
+      get() = if (memory) "memory." else ""
+
+    val name: String
+      get() = "$databasePrefix$innerName"
+
+    fun formatCreateTable(name: String): String {
+      return "CREATE TABLE $name (${QueryBuilder.trimQuery(createTable)})"
+    }
+
+    val createIndexPairFormatted: Pair<String, String>?
+      get() = createIndex?.let { Pair("CREATE INDEX ${innerName}_index ON $innerName ($it)",
+        "CREATE INDEX ${name}_index ON $innerName ($it)") }
+  }
+
+  private object Schema {
+    object Repository: Table {
+      const val ROW_ID = "_id"
+      const val ROW_ENABLED = "enabled"
+      const val ROW_DELETED = "deleted"
+      const val ROW_DATA = "data"
+
+      override val memory = false
+      override val innerName = "repository"
+      override val createTable = """
+        $ROW_ID INTEGER PRIMARY KEY AUTOINCREMENT,
+        $ROW_ENABLED INTEGER NOT NULL,
+        $ROW_DELETED INTEGER NOT NULL,
+        $ROW_DATA BLOB NOT NULL
+      """
+    }
+
+    object Product: Table {
+      const val ROW_REPOSITORY_ID = "repository_id"
+      const val ROW_PACKAGE_NAME = "package_name"
+      const val ROW_NAME = "name"
+      const val ROW_SUMMARY = "summary"
+      const val ROW_DESCRIPTION = "description"
+      const val ROW_ADDED = "added"
+      const val ROW_UPDATED = "updated"
+      const val ROW_VERSION_CODE = "version_code"
+      const val ROW_SIGNATURES = "signatures"
+      const val ROW_COMPATIBLE = "compatible"
+      const val ROW_DATA = "data"
+      const val ROW_DATA_ITEM = "data_item"
+
+      override val memory = false
+      override val innerName = "product"
+      override val createTable = """
+        $ROW_REPOSITORY_ID INTEGER NOT NULL,
+        $ROW_PACKAGE_NAME TEXT NOT NULL,
+        $ROW_NAME TEXT NOT NULL,
+        $ROW_SUMMARY TEXT NOT NULL,
+        $ROW_DESCRIPTION TEXT NOT NULL,
+        $ROW_ADDED INTEGER NOT NULL,
+        $ROW_UPDATED INTEGER NOT NULL,
+        $ROW_VERSION_CODE INTEGER NOT NULL,
+        $ROW_SIGNATURES TEXT NOT NULL,
+        $ROW_COMPATIBLE INTEGER NOT NULL,
+        $ROW_DATA BLOB NOT NULL,
+        $ROW_DATA_ITEM BLOB NOT NULL,
+        PRIMARY KEY ($ROW_REPOSITORY_ID, $ROW_PACKAGE_NAME)
+      """
+      override val createIndex = ROW_PACKAGE_NAME
+    }
+
+    object Category: Table {
+      const val ROW_REPOSITORY_ID = "repository_id"
+      const val ROW_PACKAGE_NAME = "package_name"
+      const val ROW_NAME = "name"
+
+      override val memory = false
+      override val innerName = "category"
+      override val createTable = """
+        $ROW_REPOSITORY_ID INTEGER NOT NULL,
+        $ROW_PACKAGE_NAME TEXT NOT NULL,
+        $ROW_NAME TEXT NOT NULL,
+        PRIMARY KEY ($ROW_REPOSITORY_ID, $ROW_PACKAGE_NAME, $ROW_NAME)
+      """
+      override val createIndex = "$ROW_PACKAGE_NAME, $ROW_NAME"
+    }
+
+    object Installed: Table {
+      const val ROW_PACKAGE_NAME = "package_name"
+      const val ROW_VERSION = "version"
+      const val ROW_VERSION_CODE = "version_code"
+      const val ROW_SIGNATURE = "signature"
+
+      override val memory = true
+      override val innerName = "installed"
+      override val createTable = """
+        $ROW_PACKAGE_NAME TEXT PRIMARY KEY,
+        $ROW_VERSION TEXT NOT NULL,
+        $ROW_VERSION_CODE INTEGER NOT NULL,
+        $ROW_SIGNATURE TEXT NOT NULL
+      """
+    }
+
+    object Lock: Table {
+      const val ROW_PACKAGE_NAME = "package_name"
+      const val ROW_VERSION_CODE = "version_code"
+
+      override val memory = true
+      override val innerName = "lock"
+      override val createTable = """
+        $ROW_PACKAGE_NAME TEXT PRIMARY KEY,
+        $ROW_VERSION_CODE INTEGER NOT NULL
+      """
+    }
+
+    object Synthetic {
+      const val ROW_CAN_UPDATE = "can_update"
+      const val ROW_MATCH_RANK = "match_rank"
+    }
+  }
+
+  private class Helper(context: Context): SQLiteOpenHelper(context, "droidify", null, 1) {
+    var created = false
+      private set
+    var updated = false
+      private set
+
+    override fun onCreate(db: SQLiteDatabase) = Unit
+    override fun onUpgrade(db: SQLiteDatabase, oldVersion: Int, newVersion: Int) = onVersionChange(db)
+    override fun onDowngrade(db: SQLiteDatabase, oldVersion: Int, newVersion: Int) = onVersionChange(db)
+
+    private fun onVersionChange(db: SQLiteDatabase) {
+      handleTables(db, true, Schema.Product, Schema.Category)
+      this.updated = true
+    }
+
+    override fun onOpen(db: SQLiteDatabase) {
+      val create = handleTables(db, false, Schema.Repository)
+      val updated = handleTables(db, create, Schema.Product, Schema.Category)
+      db.execSQL("ATTACH DATABASE ':memory:' AS memory")
+      handleTables(db, false, Schema.Installed, Schema.Lock)
+      handleIndexes(db, Schema.Repository, Schema.Product, Schema.Category, Schema.Installed, Schema.Lock)
+      dropOldTables(db, Schema.Repository, Schema.Product, Schema.Category)
+      this.created = this.created || create
+      this.updated = this.updated || create || updated
+    }
+  }
+
+  private fun handleTables(db: SQLiteDatabase, recreate: Boolean, vararg tables: Table): Boolean {
+    val shouldRecreate = recreate || tables.any {
+      val sql = db.query("${it.databasePrefix}sqlite_master", columns = arrayOf("sql"),
+        selection = Pair("type = ? AND name = ?", arrayOf("table", it.innerName)))
+        .use { it.firstOrNull()?.getString(0) }.orEmpty()
+      it.formatCreateTable(it.innerName) != sql
+    }
+    return shouldRecreate && run {
+      val shouldVacuum = tables.map {
+        db.execSQL("DROP TABLE IF EXISTS ${it.name}")
+        db.execSQL(it.formatCreateTable(it.name))
+        !it.memory
+      }
+      if (shouldVacuum.any { it } && !db.inTransaction()) {
+        db.execSQL("VACUUM")
+      }
+      true
+    }
+  }
+
+  private fun handleIndexes(db: SQLiteDatabase, vararg tables: Table) {
+    val shouldVacuum = tables.map {
+      val sqls = db.query("${it.databasePrefix}sqlite_master", columns = arrayOf("name", "sql"),
+        selection = Pair("type = ? AND tbl_name = ?", arrayOf("index", it.innerName)))
+        .use { it.asSequence().mapNotNull { it.getString(1)?.let { sql -> Pair(it.getString(0), sql) } }.toList() }
+        .filter { !it.first.startsWith("sqlite_") }
+      val createIndexes = it.createIndexPairFormatted?.let { listOf(it) }.orEmpty()
+      createIndexes.map { it.first } != sqls.map { it.second } && run {
+        for (name in sqls.map { it.first }) {
+          db.execSQL("DROP INDEX IF EXISTS $name")
+        }
+        for (createIndexPair in createIndexes) {
+          db.execSQL(createIndexPair.second)
+        }
+        !it.memory
+      }
+    }
+    if (shouldVacuum.any { it } && !db.inTransaction()) {
+      db.execSQL("VACUUM")
+    }
+  }
+
+  private fun dropOldTables(db: SQLiteDatabase, vararg neededTables: Table) {
+    val tables = db.query("sqlite_master", columns = arrayOf("name"),
+      selection = Pair("type = ?", arrayOf("table")))
+      .use { it.asSequence().mapNotNull { it.getString(0) }.toList() }
+      .filter { !it.startsWith("sqlite_") && !it.startsWith("android_") }
+      .toSet() - neededTables.mapNotNull { if (it.memory) null else it.name }
+    if (tables.isNotEmpty()) {
+      for (table in tables) {
+        db.execSQL("DROP TABLE IF EXISTS $table")
+      }
+      if (!db.inTransaction()) {
+        db.execSQL("VACUUM")
+      }
+    }
+  }
+
+  sealed class Subject {
+    object Repositories: Subject()
+    data class Repository(val id: Long): Subject()
+    object Products: Subject()
+  }
+
+  private val observers = mutableMapOf<Subject, MutableSet<() -> Unit>>()
+
+  private fun dataObservable(subject: Subject): (Boolean, () -> Unit) -> Unit = { register, observer ->
+    synchronized(observers) {
+      val set = observers[subject] ?: run {
+        val set = mutableSetOf<() -> Unit>()
+        observers[subject] = set
+        set
+      }
+      if (register) {
+        set += observer
+      } else {
+        set -= observer
+      }
+    }
+  }
+
+  fun observable(subject: Subject): Observable<Unit> {
+    return Observable.create {
+      val callback: () -> Unit = { it.onNext(Unit) }
+      val dataObservable = dataObservable(subject)
+      dataObservable(true, callback)
+      it.setCancellable { dataObservable(false, callback) }
+    }
+  }
+
+  private fun notifyChanged(vararg subjects: Subject) {
+    synchronized(observers) {
+      subjects.asSequence().mapNotNull { observers[it] }.flatten().forEach { it() }
+    }
+  }
+
+  private fun SQLiteDatabase.insertOrReplace(replace: Boolean, table: String, contentValues: ContentValues): Long {
+    return if (replace) replace(table, null, contentValues) else insert(table, null, contentValues)
+  }
+
+  private fun SQLiteDatabase.query(table: String, columns: Array<String>? = null,
+    selection: Pair<String, Array<String>>? = null, orderBy: String? = null,
+    signal: CancellationSignal? = null): Cursor {
+    return query(false, table, columns, selection?.first, selection?.second, null, null, orderBy, null, signal)
+  }
+
+  private fun Cursor.observable(subject: Subject): ObservableCursor {
+    return ObservableCursor(this, dataObservable(subject))
+  }
+
+  private fun <T> ByteArray.jsonParse(callback: (JsonParser) -> T): T {
+    return Json.factory.createParser(this).use { it.parseDictionary(callback) }
+  }
+
+  private fun jsonGenerate(callback: (JsonGenerator) -> Unit): ByteArray {
+    val outputStream = ByteArrayOutputStream()
+    Json.factory.createGenerator(outputStream).use { it.writeDictionary(callback) }
+    return outputStream.toByteArray()
+  }
+
+  object RepositoryAdapter {
+    internal fun putWithoutNotification(repository: Repository, shouldReplace: Boolean): Long {
+      return db.insertOrReplace(shouldReplace, Schema.Repository.name, ContentValues().apply {
+        if (shouldReplace) {
+          put(Schema.Repository.ROW_ID, repository.id)
+        }
+        put(Schema.Repository.ROW_ENABLED, if (repository.enabled) 1 else 0)
+        put(Schema.Repository.ROW_DELETED, 0)
+        put(Schema.Repository.ROW_DATA, jsonGenerate(repository::serialize))
+      })
+    }
+
+    fun put(repository: Repository): Repository {
+      val shouldReplace = repository.id >= 0L
+      val newId = putWithoutNotification(repository, shouldReplace)
+      val id = if (shouldReplace) repository.id else newId
+      notifyChanged(Subject.Repositories, Subject.Repository(id), Subject.Products)
+      return if (newId != repository.id) repository.copy(id = newId) else repository
+    }
+
+    fun get(id: Long): Repository? {
+      return db.query(Schema.Repository.name,
+        selection = Pair("${Schema.Repository.ROW_ID} = ? AND ${Schema.Repository.ROW_DELETED} == 0",
+          arrayOf(id.toString())))
+        .use { it.firstOrNull()?.let(::transform) }
+    }
+
+    fun getAll(signal: CancellationSignal?): List<Repository> {
+      return db.query(Schema.Repository.name,
+        selection = Pair("${Schema.Repository.ROW_DELETED} == 0", emptyArray()),
+        signal = signal).use { it.asSequence().map(::transform).toList() }
+    }
+
+    fun getAllDisabledDeleted(signal: CancellationSignal?): Set<Pair<Long, Boolean>> {
+      return db.query(Schema.Repository.name,
+        columns = arrayOf(Schema.Repository.ROW_ID, Schema.Repository.ROW_DELETED),
+        selection = Pair("${Schema.Repository.ROW_ENABLED} == 0 OR ${Schema.Repository.ROW_DELETED} != 0", emptyArray()),
+        signal = signal).use { it.asSequence().map { Pair(it.getLong(it.getColumnIndex(Schema.Repository.ROW_ID)),
+        it.getInt(it.getColumnIndex(Schema.Repository.ROW_DELETED)) != 0) }.toSet() }
+    }
+
+    fun markAsDeleted(id: Long) {
+      db.update(Schema.Repository.name, ContentValues().apply {
+        put(Schema.Repository.ROW_DELETED, 1)
+      }, "${Schema.Repository.ROW_ID} = ?", arrayOf(id.toString()))
+      notifyChanged(Subject.Repositories, Subject.Repository(id), Subject.Products)
+    }
+
+    fun cleanup(pairs: Set<Pair<Long, Boolean>>) {
+      val result = pairs.windowed(10, 10, true).map {
+        val idsString = it.joinToString(separator = ", ") { it.first.toString() }
+        val productsCount = db.delete(Schema.Product.name,
+          "${Schema.Product.ROW_REPOSITORY_ID} IN ($idsString)", null)
+        val categoriesCount = db.delete(Schema.Category.name,
+          "${Schema.Category.ROW_REPOSITORY_ID} IN ($idsString)", null)
+        val deleteIdsString = it.asSequence().filter { it.second }
+          .joinToString(separator = ", ") { it.first.toString() }
+        if (deleteIdsString.isNotEmpty()) {
+          db.delete(Schema.Repository.name, "${Schema.Repository.ROW_ID} IN ($deleteIdsString)", null)
+        }
+        productsCount != 0 || categoriesCount != 0
+      }
+      if (result.any { it }) {
+        notifyChanged(Subject.Products)
+      }
+    }
+
+    fun query(signal: CancellationSignal?): Cursor {
+      return db.query(Schema.Repository.name,
+        selection = Pair("${Schema.Repository.ROW_DELETED} == 0", emptyArray()),
+        signal = signal).observable(Subject.Repositories)
+    }
+
+    fun transform(cursor: Cursor): Repository {
+      return cursor.getBlob(cursor.getColumnIndex(Schema.Repository.ROW_DATA))
+        .jsonParse { Repository.deserialize(cursor.getLong(cursor.getColumnIndex(Schema.Repository.ROW_ID)), it) }
+    }
+  }
+
+  object ProductAdapter {
+    fun get(packageName: String, signal: CancellationSignal?): List<Product> {
+      return db.query(Schema.Product.name,
+        columns = arrayOf(Schema.Product.ROW_REPOSITORY_ID, Schema.Product.ROW_DESCRIPTION, Schema.Product.ROW_DATA),
+        selection = Pair("${Schema.Product.ROW_PACKAGE_NAME} = ?", arrayOf(packageName)),
+        signal = signal).use { it.asSequence().map(::transform).toList() }
+    }
+
+    fun getCount(repositoryId: Long): Int {
+      return db.query(Schema.Product.name, columns = arrayOf("COUNT (*)"),
+        selection = Pair("${Schema.Product.ROW_REPOSITORY_ID} = ?", arrayOf(repositoryId.toString())))
+        .use { it.firstOrNull()?.getInt(0) ?: 0 }
+    }
+
+    fun query(installed: Boolean, updates: Boolean, searchQuery: String,
+      section: ProductItem.Section, order: ProductItem.Order, signal: CancellationSignal?): Cursor {
+      val builder = QueryBuilder()
+
+      val signatureMatches = """installed.${Schema.Installed.ROW_SIGNATURE} IS NOT NULL AND
+        product.${Schema.Product.ROW_SIGNATURES} LIKE ('%.' || installed.${Schema.Installed.ROW_SIGNATURE} || '.%') AND
+        product.${Schema.Product.ROW_SIGNATURES} != ''"""
+
+      builder += """SELECT product.rowid AS _id, product.${Schema.Product.ROW_REPOSITORY_ID},
+        product.${Schema.Product.ROW_PACKAGE_NAME}, product.${Schema.Product.ROW_NAME},
+        product.${Schema.Product.ROW_SUMMARY}, installed.${Schema.Installed.ROW_VERSION},
+        (COALESCE(lock.${Schema.Lock.ROW_VERSION_CODE}, -1) NOT IN (0, product.${Schema.Product.ROW_VERSION_CODE}) AND
+        product.${Schema.Product.ROW_COMPATIBLE} != 0 AND product.${Schema.Product.ROW_VERSION_CODE} >
+        COALESCE(installed.${Schema.Installed.ROW_VERSION_CODE}, 0xffffffff) AND $signatureMatches)
+        AS ${Schema.Synthetic.ROW_CAN_UPDATE}, product.${Schema.Product.ROW_COMPATIBLE},
+        product.${Schema.Product.ROW_DATA_ITEM},"""
+
+      if (searchQuery.isNotEmpty()) {
+        builder += """(((product.${Schema.Product.ROW_NAME} LIKE ? OR
+          product.${Schema.Product.ROW_SUMMARY} LIKE ?) * 7) |
+          ((product.${Schema.Product.ROW_PACKAGE_NAME} LIKE ?) * 3) |
+          (product.${Schema.Product.ROW_DESCRIPTION} LIKE ?)) AS ${Schema.Synthetic.ROW_MATCH_RANK},"""
+        builder %= List(4) { "%$searchQuery%" }
+      } else {
+        builder += "0 AS ${Schema.Synthetic.ROW_MATCH_RANK},"
+      }
+
+      builder += """MAX((product.${Schema.Product.ROW_COMPATIBLE} AND
+        (installed.${Schema.Installed.ROW_SIGNATURE} IS NULL OR $signatureMatches)) ||
+        PRINTF('%016X', product.${Schema.Product.ROW_VERSION_CODE})) FROM ${Schema.Product.name} AS product"""
+
+      builder += """JOIN ${Schema.Repository.name} AS repository
+        ON product.${Schema.Product.ROW_REPOSITORY_ID} = repository.${Schema.Repository.ROW_ID}"""
+      builder += """LEFT JOIN ${Schema.Lock.name} AS lock
+        ON product.${Schema.Product.ROW_PACKAGE_NAME} = lock.${Schema.Lock.ROW_PACKAGE_NAME}"""
+      if (!installed && !updates) {
+        builder += "LEFT"
+      }
+      builder += """JOIN ${Schema.Installed.name} AS installed
+        ON product.${Schema.Product.ROW_PACKAGE_NAME} = installed.${Schema.Installed.ROW_PACKAGE_NAME}"""
+      if (section is ProductItem.Section.Category) {
+        builder += """JOIN ${Schema.Category.name} AS category
+          ON product.${Schema.Product.ROW_PACKAGE_NAME} = category.${Schema.Product.ROW_PACKAGE_NAME}"""
+      }
+
+      builder += """WHERE repository.${Schema.Repository.ROW_ENABLED} != 0 AND
+        repository.${Schema.Repository.ROW_DELETED} == 0"""
+      if (section is ProductItem.Section.Category) {
+        builder += "AND category.${Schema.Category.ROW_NAME} = ?"
+        builder %= section.name
+      } else if (section is ProductItem.Section.Repository) {
+        builder += "AND product.${Schema.Product.ROW_REPOSITORY_ID} = ?"
+        builder %= section.id.toString()
+      }
+      if (searchQuery.isNotEmpty()) {
+        builder += """AND ${Schema.Synthetic.ROW_MATCH_RANK} > 0"""
+      }
+
+      builder += "GROUP BY product.${Schema.Product.ROW_PACKAGE_NAME} HAVING 1"
+      if (updates) {
+        builder += "AND ${Schema.Synthetic.ROW_CAN_UPDATE}"
+      }
+      builder += "ORDER BY"
+      if (searchQuery.isNotEmpty()) {
+        builder += """${Schema.Synthetic.ROW_MATCH_RANK} DESC,"""
+      }
+      when (order) {
+        ProductItem.Order.NAME -> Unit
+        ProductItem.Order.DATE_ADDED -> builder += "product.${Schema.Product.ROW_ADDED} DESC,"
+        ProductItem.Order.LAST_UPDATE -> builder += "product.${Schema.Product.ROW_UPDATED} DESC,"
+      }::class
+      builder += "product.${Schema.Product.ROW_NAME} COLLATE LOCALIZED ASC"
+
+      return builder.query(db, signal).observable(Subject.Products)
+    }
+
+    private fun transform(cursor: Cursor): Product {
+      return cursor.getBlob(cursor.getColumnIndex(Schema.Product.ROW_DATA))
+        .jsonParse { Product.deserialize(cursor.getLong(cursor.getColumnIndex(Schema.Product.ROW_REPOSITORY_ID)),
+          cursor.getString(cursor.getColumnIndex(Schema.Product.ROW_DESCRIPTION)), it) }
+    }
+
+    fun transformItem(cursor: Cursor): ProductItem {
+      return cursor.getBlob(cursor.getColumnIndex(Schema.Product.ROW_DATA_ITEM))
+        .jsonParse { ProductItem.deserialize(cursor.getLong(cursor.getColumnIndex(Schema.Product.ROW_REPOSITORY_ID)),
+          cursor.getString(cursor.getColumnIndex(Schema.Product.ROW_PACKAGE_NAME)),
+          cursor.getString(cursor.getColumnIndex(Schema.Product.ROW_NAME)),
+          cursor.getString(cursor.getColumnIndex(Schema.Product.ROW_SUMMARY)),
+          cursor.getString(cursor.getColumnIndex(Schema.Installed.ROW_VERSION)).orEmpty(),
+          cursor.getInt(cursor.getColumnIndex(Schema.Product.ROW_COMPATIBLE)) != 0,
+          cursor.getInt(cursor.getColumnIndex(Schema.Synthetic.ROW_CAN_UPDATE)) != 0,
+          cursor.getInt(cursor.getColumnIndex(Schema.Synthetic.ROW_MATCH_RANK)), it) }
+    }
+  }
+
+  object CategoryAdapter {
+    fun getAll(signal: CancellationSignal?): Set<String> {
+      val builder = QueryBuilder()
+
+      builder += """SELECT DISTINCT category.${Schema.Category.ROW_NAME}
+        FROM ${Schema.Category.name} AS category
+        JOIN ${Schema.Repository.name} AS repository
+        ON category.${Schema.Category.ROW_REPOSITORY_ID} = repository.${Schema.Repository.ROW_ID}
+        WHERE repository.${Schema.Repository.ROW_ENABLED} != 0 AND
+        repository.${Schema.Repository.ROW_DELETED} == 0"""
+
+      return builder.query(db, signal).use { it.asSequence()
+        .map { it.getString(it.getColumnIndex(Schema.Category.ROW_NAME)) }.toSet() }
+    }
+  }
+
+  object InstalledAdapter {
+    fun get(packageName: String, signal: CancellationSignal?): InstalledItem? {
+      return db.query(Schema.Installed.name,
+        columns = arrayOf(Schema.Installed.ROW_PACKAGE_NAME, Schema.Installed.ROW_VERSION,
+          Schema.Installed.ROW_VERSION_CODE, Schema.Installed.ROW_SIGNATURE),
+        selection = Pair("${Schema.Installed.ROW_PACKAGE_NAME} = ?", arrayOf(packageName)),
+        signal = signal).use { it.firstOrNull()?.let(::transform) }
+    }
+
+    private fun put(installedItem: InstalledItem, notify: Boolean) {
+      db.insertOrReplace(true, Schema.Installed.name, ContentValues().apply {
+        put(Schema.Installed.ROW_PACKAGE_NAME, installedItem.packageName)
+        put(Schema.Installed.ROW_VERSION, installedItem.version)
+        put(Schema.Installed.ROW_VERSION_CODE, installedItem.versionCode)
+        put(Schema.Installed.ROW_SIGNATURE, installedItem.signature)
+      })
+      if (notify) {
+        notifyChanged(Subject.Products)
+      }
+    }
+
+    fun put(installedItem: InstalledItem) = put(installedItem, true)
+
+    fun putAll(installedItems: List<InstalledItem>) {
+      db.beginTransaction()
+      try {
+        db.delete(Schema.Installed.name, null, null)
+        installedItems.forEach { put(it, false) }
+        db.setTransactionSuccessful()
+      } finally {
+        db.endTransaction()
+      }
+    }
+
+    fun delete(packageName: String) {
+      val count = db.delete(Schema.Installed.name, "${Schema.Installed.ROW_PACKAGE_NAME} = ?", arrayOf(packageName))
+      if (count > 0) {
+        notifyChanged(Subject.Products)
+      }
+    }
+
+    private fun transform(cursor: Cursor): InstalledItem {
+      return InstalledItem(cursor.getString(cursor.getColumnIndex(Schema.Installed.ROW_PACKAGE_NAME)),
+        cursor.getString(cursor.getColumnIndex(Schema.Installed.ROW_VERSION)),
+        cursor.getLong(cursor.getColumnIndex(Schema.Installed.ROW_VERSION_CODE)),
+        cursor.getString(cursor.getColumnIndex(Schema.Installed.ROW_SIGNATURE)))
+    }
+  }
+
+  object LockAdapter {
+    private fun put(lock: Pair<String, Long>, notify: Boolean) {
+      db.insertOrReplace(true, Schema.Lock.name, ContentValues().apply {
+        put(Schema.Lock.ROW_PACKAGE_NAME, lock.first)
+        put(Schema.Lock.ROW_VERSION_CODE, lock.second)
+      })
+      if (notify) {
+        notifyChanged(Subject.Products)
+      }
+    }
+
+    fun put(lock: Pair<String, Long>) = put(lock, true)
+
+    fun putAll(locks: List<Pair<String, Long>>) {
+      db.beginTransaction()
+      try {
+        db.delete(Schema.Lock.name, null, null)
+        locks.forEach { put(it, false) }
+        db.setTransactionSuccessful()
+      } finally {
+        db.endTransaction()
+      }
+    }
+
+    fun delete(packageName: String) {
+      db.delete(Schema.Lock.name, "${Schema.Lock.ROW_PACKAGE_NAME} = ?", arrayOf(packageName))
+      notifyChanged(Subject.Products)
+    }
+  }
+
+  object UpdaterAdapter {
+    private val Table.temporaryName: String
+      get() = "${name}_temporary"
+
+    fun createTemporaryTable() {
+      db.execSQL("DROP TABLE IF EXISTS ${Schema.Product.temporaryName}")
+      db.execSQL("DROP TABLE IF EXISTS ${Schema.Category.temporaryName}")
+      db.execSQL(Schema.Product.formatCreateTable(Schema.Product.temporaryName))
+      db.execSQL(Schema.Category.formatCreateTable(Schema.Category.temporaryName))
+    }
+
+    fun putTemporary(products: List<Product>) {
+      db.beginTransaction()
+      try {
+        for (product in products) {
+          // Format signatures like ".signature1.signature2." for easier select
+          val signatures = product.signatures.joinToString { ".$it" }
+            .let { if (it.isNotEmpty()) "$it." else "" }
+          db.insertOrReplace(true, Schema.Product.temporaryName, ContentValues().apply {
+            put(Schema.Product.ROW_REPOSITORY_ID, product.repositoryId)
+            put(Schema.Product.ROW_PACKAGE_NAME, product.packageName)
+            put(Schema.Product.ROW_NAME, product.name)
+            put(Schema.Product.ROW_SUMMARY, product.summary)
+            put(Schema.Product.ROW_DESCRIPTION, product.description)
+            put(Schema.Product.ROW_ADDED, product.added)
+            put(Schema.Product.ROW_UPDATED, product.updated)
+            put(Schema.Product.ROW_VERSION_CODE, product.versionCode)
+            put(Schema.Product.ROW_SIGNATURES, signatures)
+            put(Schema.Product.ROW_COMPATIBLE, if (product.compatible) 1 else 0)
+            put(Schema.Product.ROW_DATA, jsonGenerate(product::serialize))
+            put(Schema.Product.ROW_DATA_ITEM, jsonGenerate(product.item()::serialize))
+          })
+          for (category in product.categories) {
+            db.insertOrReplace(true, Schema.Category.temporaryName, ContentValues().apply {
+              put(Schema.Category.ROW_REPOSITORY_ID, product.repositoryId)
+              put(Schema.Category.ROW_PACKAGE_NAME, product.packageName)
+              put(Schema.Category.ROW_NAME, category)
+            })
+          }
+        }
+        db.setTransactionSuccessful()
+      } finally {
+        db.endTransaction()
+      }
+    }
+
+    fun finishTemporary(repository: Repository, success: Boolean) {
+      if (success) {
+        db.beginTransaction()
+        try {
+          db.delete(Schema.Product.name, "${Schema.Product.ROW_REPOSITORY_ID} = ?",
+            arrayOf(repository.id.toString()))
+          db.delete(Schema.Category.name, "${Schema.Category.ROW_REPOSITORY_ID} = ?",
+            arrayOf(repository.id.toString()))
+          db.execSQL("INSERT INTO ${Schema.Product.name} SELECT * FROM ${Schema.Product.temporaryName}")
+          db.execSQL("INSERT INTO ${Schema.Category.name} SELECT * FROM ${Schema.Category.temporaryName}")
+          RepositoryAdapter.putWithoutNotification(repository, true)
+          db.execSQL("DROP TABLE IF EXISTS ${Schema.Product.temporaryName}")
+          db.execSQL("DROP TABLE IF EXISTS ${Schema.Category.temporaryName}")
+          db.setTransactionSuccessful()
+        } finally {
+          db.endTransaction()
+        }
+        if (success) {
+          notifyChanged(Subject.Repositories, Subject.Repository(repository.id), Subject.Products)
+        }
+      } else {
+        db.execSQL("DROP TABLE IF EXISTS ${Schema.Product.temporaryName}")
+        db.execSQL("DROP TABLE IF EXISTS ${Schema.Category.temporaryName}")
+      }
+    }
+  }
+}

src/main/kotlin/com/looker/droidify/database/ObservableCursor.kt

@@ -0,0 +1,57 @@
+package com.looker.droidify.database
+
+import android.database.ContentObservable
+import android.database.ContentObserver
+import android.database.Cursor
+import android.database.CursorWrapper
+
+class ObservableCursor(cursor: Cursor, private val observable: (register: Boolean,
+  observer: () -> Unit) -> Unit): CursorWrapper(cursor) {
+  private var registered = false
+  private val contentObservable = ContentObservable()
+
+  private val onChange: () -> Unit = {
+    contentObservable.dispatchChange(false, null)
+  }
+
+  init {
+    observable(true, onChange)
+    registered = true
+  }
+
+  override fun registerContentObserver(observer: ContentObserver) {
+    super.registerContentObserver(observer)
+    contentObservable.registerObserver(observer)
+  }
+
+  override fun unregisterContentObserver(observer: ContentObserver) {
+    super.unregisterContentObserver(observer)
+    contentObservable.unregisterObserver(observer)
+  }
+
+  @Suppress("DEPRECATION")
+  override fun requery(): Boolean {
+    if (!registered) {
+      observable(true, onChange)
+      registered = true
+    }
+    return super.requery()
+  }
+
+  @Suppress("DEPRECATION")
+  override fun deactivate() {
+    super.deactivate()
+    deactivateOrClose()
+  }
+
+  override fun close() {
+    super.close()
+    contentObservable.unregisterAll()
+    deactivateOrClose()
+  }
+
+  private fun deactivateOrClose() {
+    observable(false, onChange)
+    registered = false
+  }
+}

src/main/kotlin/com/looker/droidify/database/QueryBuilder.kt

@@ -0,0 +1,47 @@
+package com.looker.droidify.database
+
+import android.database.Cursor
+import android.database.sqlite.SQLiteDatabase
+import android.os.CancellationSignal
+import com.looker.droidify.BuildConfig
+import com.looker.droidify.utility.extension.android.*
+import com.looker.droidify.utility.extension.text.*
+
+class QueryBuilder {
+  companion object {
+    fun trimQuery(query: String): String {
+      return query.lines().map { it.trim() }.filter { it.isNotEmpty() }.joinToString(separator = " ")
+    }
+  }
+
+  private val builder = StringBuilder()
+  private val arguments = mutableListOf<String>()
+
+  operator fun plusAssign(query: String) {
+    if (builder.isNotEmpty()) {
+      builder.append(" ")
+    }
+    builder.append(trimQuery(query))
+  }
+
+  operator fun remAssign(argument: String) {
+    this.arguments += argument
+  }
+
+  operator fun remAssign(arguments: List<String>) {
+    this.arguments += arguments
+  }
+
+  fun query(db: SQLiteDatabase, signal: CancellationSignal?): Cursor {
+    val query = builder.toString()
+    val arguments = arguments.toTypedArray()
+    if (BuildConfig.DEBUG) {
+      synchronized(QueryBuilder::class.java) {
+        debug(query)
+        db.rawQuery("EXPLAIN QUERY PLAN $query", arguments).use { it.asSequence()
+          .forEach { debug(":: ${it.getString(it.getColumnIndex("detail"))}") } }
+      }
+    }
+    return db.rawQuery(query, arguments, signal)
+  }
+}

src/main/kotlin/com/looker/droidify/database/QueryLoader.kt

@@ -0,0 +1,94 @@
+package com.looker.droidify.database
+
+import android.content.Context
+import android.database.Cursor
+import android.os.CancellationSignal
+import android.os.OperationCanceledException
+import androidx.loader.content.AsyncTaskLoader
+
+class QueryLoader(context: Context, private val query: (CancellationSignal) -> Cursor?):
+  AsyncTaskLoader<Cursor>(context) {
+  private val observer = ForceLoadContentObserver()
+  private var cancellationSignal: CancellationSignal? = null
+  private var cursor: Cursor? = null
+
+  override fun loadInBackground(): Cursor? {
+    val cancellationSignal = synchronized(this) {
+      if (isLoadInBackgroundCanceled) {
+        throw OperationCanceledException()
+      }
+      val cancellationSignal = CancellationSignal()
+      this.cancellationSignal = cancellationSignal
+      cancellationSignal
+    }
+    try {
+      val cursor = query(cancellationSignal)
+      if (cursor != null) {
+        try {
+          cursor.count // Ensure the cursor window is filled
+          cursor.registerContentObserver(observer)
+        } catch (e: Exception) {
+          cursor.close()
+          throw e
+        }
+      }
+      return cursor
+    } finally {
+      synchronized(this) {
+        this.cancellationSignal = null
+      }
+    }
+  }
+
+  override fun cancelLoadInBackground() {
+    super.cancelLoadInBackground()
+
+    synchronized(this) {
+      cancellationSignal?.cancel()
+    }
+  }
+
+  override fun deliverResult(data: Cursor?) {
+    if (isReset) {
+      data?.close()
+    } else {
+      val oldCursor = cursor
+      cursor = data
+      if (isStarted) {
+        super.deliverResult(data)
+      }
+      if (oldCursor != data) {
+        oldCursor.closeIfNeeded()
+      }
+    }
+  }
+
+  override fun onStartLoading() {
+    cursor?.let(this::deliverResult)
+    if (takeContentChanged() || cursor == null) {
+      forceLoad()
+    }
+  }
+
+  override fun onStopLoading() {
+    cancelLoad()
+  }
+
+  override fun onCanceled(data: Cursor?) {
+    data.closeIfNeeded()
+  }
+
+  override fun onReset() {
+    super.onReset()
+
+    stopLoading()
+    cursor.closeIfNeeded()
+    cursor = null
+  }
+
+  private fun Cursor?.closeIfNeeded() {
+    if (this != null && !isClosed) {
+      close()
+    }
+  }
+}