Initial Commit

src/main/kotlin/com/looker/droidify/Common.kt

@@ -0,0 +1,13 @@
+package com.looker.droidify
+
+object Common {
+  const val NOTIFICATION_CHANNEL_SYNCING = "syncing"
+  const val NOTIFICATION_CHANNEL_UPDATES = "updates"
+  const val NOTIFICATION_CHANNEL_DOWNLOADING = "downloading"
+
+  const val NOTIFICATION_ID_SYNCING = 1
+  const val NOTIFICATION_ID_UPDATES = 2
+  const val NOTIFICATION_ID_DOWNLOADING = 3
+
+  const val JOB_ID_SYNC = 1
+}

src/main/kotlin/com/looker/droidify/MainActivity.kt

@@ -0,0 +1,21 @@
+package com.looker.droidify
+
+import android.content.Intent
+import com.looker.droidify.screen.ScreenActivity
+
+class MainActivity: ScreenActivity() {
+  companion object {
+    const val ACTION_UPDATES = "${BuildConfig.APPLICATION_ID}.intent.action.UPDATES"
+    const val ACTION_INSTALL = "${BuildConfig.APPLICATION_ID}.intent.action.INSTALL"
+    const val EXTRA_CACHE_FILE_NAME = "${BuildConfig.APPLICATION_ID}.intent.extra.CACHE_FILE_NAME"
+  }
+
+  override fun handleIntent(intent: Intent?) {
+    when (intent?.action) {
+      ACTION_UPDATES -> handleSpecialIntent(SpecialIntent.Updates)
+      ACTION_INSTALL -> handleSpecialIntent(SpecialIntent.Install(intent.packageName,
+        intent.getStringExtra(EXTRA_CACHE_FILE_NAME)))
+      else -> super.handleIntent(intent)
+    }
+  }
+}

src/main/kotlin/com/looker/droidify/MainApplication.kt

@@ -0,0 +1,187 @@
+package com.looker.droidify
+
+import android.annotation.SuppressLint
+import android.app.Application
+import android.app.job.JobInfo
+import android.app.job.JobScheduler
+import android.content.BroadcastReceiver
+import android.content.ComponentName
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.content.pm.PackageInfo
+import com.squareup.picasso.OkHttp3Downloader
+import com.squareup.picasso.Picasso
+import com.looker.droidify.content.Cache
+import com.looker.droidify.content.Preferences
+import com.looker.droidify.content.ProductPreferences
+import com.looker.droidify.database.Database
+import com.looker.droidify.entity.InstalledItem
+import com.looker.droidify.index.RepositoryUpdater
+import com.looker.droidify.network.Downloader
+import com.looker.droidify.network.PicassoDownloader
+import com.looker.droidify.service.Connection
+import com.looker.droidify.service.SyncService
+import com.looker.droidify.utility.Utils
+import com.looker.droidify.utility.extension.android.*
+import java.net.InetSocketAddress
+import java.net.Proxy
+
+@Suppress("unused")
+class MainApplication: Application() {
+  private fun PackageInfo.toInstalledItem(): InstalledItem {
+    val signatureString = singleSignature?.let(Utils::calculateHash).orEmpty()
+    return InstalledItem(packageName, versionName.orEmpty(), versionCodeCompat, signatureString)
+  }
+
+  override fun attachBaseContext(base: Context) {
+    super.attachBaseContext(Utils.configureLocale(base))
+  }
+
+  override fun onCreate() {
+    super.onCreate()
+
+    val databaseUpdated = Database.init(this)
+    Preferences.init(this)
+    ProductPreferences.init(this)
+    RepositoryUpdater.init(this)
+    listenApplications()
+    listenPreferences()
+
+    Picasso.setSingletonInstance(Picasso.Builder(this)
+      .downloader(OkHttp3Downloader(PicassoDownloader.Factory(Cache.getImagesDir(this)))).build())
+
+    if (databaseUpdated) {
+      forceSyncAll()
+    }
+
+    Cache.cleanup(this)
+    updateSyncJob(false)
+  }
+
+  private fun listenApplications() {
+    registerReceiver(object: BroadcastReceiver() {
+      override fun onReceive(context: Context, intent: Intent) {
+        val packageName = intent.data?.let { if (it.scheme == "package") it.schemeSpecificPart else null }
+        if (packageName != null) {
+          when (intent.action.orEmpty()) {
+            Intent.ACTION_PACKAGE_ADDED,
+            Intent.ACTION_PACKAGE_REMOVED -> {
+              val packageInfo = try {
+                packageManager.getPackageInfo(packageName, Android.PackageManager.signaturesFlag)
+              } catch (e: Exception) {
+                null
+              }
+              if (packageInfo != null) {
+                Database.InstalledAdapter.put(packageInfo.toInstalledItem())
+              } else {
+                Database.InstalledAdapter.delete(packageName)
+              }
+            }
+          }
+        }
+      }
+    }, IntentFilter().apply {
+      addAction(Intent.ACTION_PACKAGE_ADDED)
+      addAction(Intent.ACTION_PACKAGE_REMOVED)
+      addDataScheme("package")
+    })
+    val installedItems = packageManager.getInstalledPackages(Android.PackageManager.signaturesFlag)
+      .map { it.toInstalledItem() }
+    Database.InstalledAdapter.putAll(installedItems)
+  }
+
+  private fun listenPreferences() {
+    updateProxy()
+    var lastAutoSync = Preferences[Preferences.Key.AutoSync]
+    var lastUpdateUnstable = Preferences[Preferences.Key.UpdateUnstable]
+    Preferences.observable.subscribe {
+      if (it == Preferences.Key.ProxyType || it == Preferences.Key.ProxyHost || it == Preferences.Key.ProxyPort) {
+        updateProxy()
+      } else if (it == Preferences.Key.AutoSync) {
+        val autoSync = Preferences[Preferences.Key.AutoSync]
+        if (lastAutoSync != autoSync) {
+          lastAutoSync = autoSync
+          updateSyncJob(true)
+        }
+      } else if (it == Preferences.Key.UpdateUnstable) {
+        val updateUnstable = Preferences[Preferences.Key.UpdateUnstable]
+        if (lastUpdateUnstable != updateUnstable) {
+          lastUpdateUnstable = updateUnstable
+          forceSyncAll()
+        }
+      }
+    }
+  }
+
+  private fun updateSyncJob(force: Boolean) {
+    val jobScheduler = getSystemService(JOB_SCHEDULER_SERVICE) as JobScheduler
+    val reschedule = force || !jobScheduler.allPendingJobs.any { it.id == Common.JOB_ID_SYNC }
+    if (reschedule) {
+      val autoSync = Preferences[Preferences.Key.AutoSync]
+      when (autoSync) {
+        Preferences.AutoSync.Never -> {
+          jobScheduler.cancel(Common.JOB_ID_SYNC)
+        }
+        Preferences.AutoSync.Wifi, Preferences.AutoSync.Always -> {
+          val period = 12 * 60 * 60 * 1000L // 12 hours
+          val wifiOnly = autoSync == Preferences.AutoSync.Wifi
+          jobScheduler.schedule(JobInfo
+            .Builder(Common.JOB_ID_SYNC, ComponentName(this, SyncService.Job::class.java))
+            .setRequiredNetworkType(if (wifiOnly) JobInfo.NETWORK_TYPE_UNMETERED else JobInfo.NETWORK_TYPE_ANY)
+            .apply {
+              if (Android.sdk(26)) {
+                setRequiresBatteryNotLow(true)
+                setRequiresStorageNotLow(true)
+              }
+              if (Android.sdk(24)) {
+                setPeriodic(period, JobInfo.getMinFlexMillis())
+              } else {
+                setPeriodic(period)
+              }
+            }
+            .build())
+          Unit
+        }
+      }::class.java
+    }
+  }
+
+  private fun updateProxy() {
+    val type = Preferences[Preferences.Key.ProxyType].proxyType
+    val host = Preferences[Preferences.Key.ProxyHost]
+    val port = Preferences[Preferences.Key.ProxyPort]
+    val socketAddress = when (type) {
+      Proxy.Type.DIRECT -> {
+        null
+      }
+      Proxy.Type.HTTP, Proxy.Type.SOCKS -> {
+        try {
+          InetSocketAddress.createUnresolved(host, port)
+        } catch (e: Exception) {
+          e.printStackTrace()
+          null
+        }
+      }
+    }
+    val proxy = socketAddress?.let { Proxy(type, socketAddress) }
+    Downloader.proxy = proxy
+  }
+
+  private fun forceSyncAll() {
+    Database.RepositoryAdapter.getAll(null).forEach {
+      if (it.lastModified.isNotEmpty() || it.entityTag.isNotEmpty()) {
+        Database.RepositoryAdapter.put(it.copy(lastModified = "", entityTag = ""))
+      }
+    }
+    Connection(SyncService::class.java, onBind = { connection, binder ->
+      binder.sync(SyncService.SyncRequest.FORCE)
+      connection.unbind(this)
+    }).bind(this)
+  }
+
+  class BootReceiver: BroadcastReceiver() {
+    @SuppressLint("UnsafeProtectedBroadcastReceiver")
+    override fun onReceive(context: Context, intent: Intent) = Unit
+  }
+}

src/main/kotlin/com/looker/droidify/content/Cache.kt

@@ -0,0 +1,179 @@
+package com.looker.droidify.content
+
+import android.content.ContentProvider
+import android.content.ContentValues
+import android.content.Context
+import android.content.pm.PackageManager
+import android.database.Cursor
+import android.database.MatrixCursor
+import android.net.Uri
+import android.os.ParcelFileDescriptor
+import android.provider.OpenableColumns
+import android.system.Os
+import com.looker.droidify.utility.extension.android.*
+import java.io.File
+import java.util.UUID
+import kotlin.concurrent.thread
+
+object Cache {
+  private fun ensureCacheDir(context: Context, name: String): File {
+    return File(context.cacheDir, name).apply { isDirectory || mkdirs() || throw RuntimeException() }
+  }
+
+  private fun applyOrMode(file: File, mode: Int) {
+    val oldMode = Os.stat(file.path).st_mode and 0b111111111111
+    val newMode = oldMode or mode
+    if (newMode != oldMode) {
+      Os.chmod(file.path, newMode)
+    }
+  }
+
+  private fun subPath(dir: File, file: File): String {
+    val dirPath = "${dir.path}/"
+    val filePath = file.path
+    filePath.startsWith(dirPath) || throw RuntimeException()
+    return filePath.substring(dirPath.length)
+  }
+
+  fun getImagesDir(context: Context): File {
+    return ensureCacheDir(context, "images")
+  }
+
+  fun getPartialReleaseFile(context: Context, cacheFileName: String): File {
+    return File(ensureCacheDir(context, "partial"), cacheFileName)
+  }
+
+  fun getReleaseFile(context: Context, cacheFileName: String): File {
+    return File(ensureCacheDir(context, "releases"), cacheFileName).apply {
+      if (!Android.sdk(24)) {
+        // Make readable for package installer
+        val cacheDir = context.cacheDir.parentFile!!.parentFile!!
+        generateSequence(this) { it.parentFile!! }.takeWhile { it != cacheDir }.forEach {
+          when {
+            it.isDirectory -> applyOrMode(it, 0b001001001)
+            it.isFile -> applyOrMode(it, 0b100100100)
+          }
+        }
+      }
+    }
+  }
+
+  fun getReleaseUri(context: Context, cacheFileName: String): Uri {
+    val file = getReleaseFile(context, cacheFileName)
+    val packageInfo = context.packageManager.getPackageInfo(context.packageName, PackageManager.GET_PROVIDERS)
+    val authority = packageInfo.providers.find { it.name == Provider::class.java.name }!!.authority
+    return Uri.Builder().scheme("content").authority(authority)
+      .encodedPath(subPath(context.cacheDir, file)).build()
+  }
+
+  fun getTemporaryFile(context: Context): File {
+    return File(ensureCacheDir(context, "temporary"), UUID.randomUUID().toString())
+  }
+
+  fun cleanup(context: Context) {
+    thread { cleanup(context, Pair("images", 0), Pair("partial", 24), Pair("releases", 24), Pair("temporary", 1)) }
+  }
+
+  private fun cleanup(context: Context, vararg dirHours: Pair<String, Int>) {
+    val knownNames = dirHours.asSequence().map { it.first }.toSet()
+    val files = context.cacheDir.listFiles().orEmpty()
+    files.asSequence().filter { it.name !in knownNames }.forEach {
+      if (it.isDirectory) {
+        cleanupDir(it, 0)
+        it.delete()
+      } else {
+        it.delete()
+      }
+    }
+    dirHours.forEach { (name, hours) ->
+      if (hours > 0) {
+        val file = File(context.cacheDir, name)
+        if (file.exists()) {
+          if (file.isDirectory) {
+            cleanupDir(file, hours)
+          } else {
+            file.delete()
+          }
+        }
+      }
+    }
+  }
+
+  private fun cleanupDir(dir: File, hours: Int) {
+    dir.listFiles()?.forEach {
+      val older = hours <= 0 || run {
+        val olderThan = System.currentTimeMillis() / 1000L - hours * 60 * 60
+        try {
+          val stat = Os.lstat(it.path)
+          stat.st_atime < olderThan
+        } catch (e: Exception) {
+          false
+        }
+      }
+      if (older) {
+        if (it.isDirectory) {
+          cleanupDir(it, hours)
+          if (it.isDirectory) {
+            it.delete()
+          }
+        } else {
+          it.delete()
+        }
+      }
+    }
+  }
+
+  class Provider: ContentProvider() {
+    companion object {
+      private val defaultColumns = arrayOf(OpenableColumns.DISPLAY_NAME, OpenableColumns.SIZE)
+    }
+
+    private fun getFileAndTypeForUri(uri: Uri): Pair<File, String> {
+      return when (uri.pathSegments?.firstOrNull()) {
+        "releases" -> Pair(File(context!!.cacheDir, uri.encodedPath!!), "application/vnd.android.package-archive")
+        else -> throw SecurityException()
+      }
+    }
+
+    override fun onCreate(): Boolean = true
+
+    override fun query(uri: Uri, projection: Array<String>?,
+      selection: String?, selectionArgs: Array<out String>?, sortOrder: String?): Cursor? {
+      val file = getFileAndTypeForUri(uri).first
+      val columns = (projection ?: defaultColumns).mapNotNull {
+        when (it) {
+          OpenableColumns.DISPLAY_NAME -> Pair(it, file.name)
+          OpenableColumns.SIZE -> Pair(it, file.length())
+          else -> null
+        }
+      }.unzip()
+      return MatrixCursor(columns.first.toTypedArray()).apply { addRow(columns.second.toTypedArray()) }
+    }
+
+    override fun getType(uri: Uri): String? = getFileAndTypeForUri(uri).second
+
+    private val unsupported: Nothing
+      get() = throw UnsupportedOperationException()
+
+    override fun insert(uri: Uri, contentValues: ContentValues?): Uri? = unsupported
+    override fun delete(uri: Uri, selection: String?, selectionArgs: Array<out String>?): Int = unsupported
+    override fun update(uri: Uri, contentValues: ContentValues?,
+      selection: String?, selectionArgs: Array<out String>?): Int = unsupported
+
+    override fun openFile(uri: Uri, mode: String): ParcelFileDescriptor? {
+      val openMode = when (mode) {
+        "r" -> ParcelFileDescriptor.MODE_READ_ONLY
+        "w", "wt" -> ParcelFileDescriptor.MODE_WRITE_ONLY or ParcelFileDescriptor.MODE_CREATE or
+          ParcelFileDescriptor.MODE_TRUNCATE
+        "wa" -> ParcelFileDescriptor.MODE_WRITE_ONLY or ParcelFileDescriptor.MODE_CREATE or
+          ParcelFileDescriptor.MODE_APPEND
+        "rw" -> ParcelFileDescriptor.MODE_READ_WRITE or ParcelFileDescriptor.MODE_CREATE
+        "rwt" -> ParcelFileDescriptor.MODE_READ_WRITE or ParcelFileDescriptor.MODE_CREATE or
+          ParcelFileDescriptor.MODE_TRUNCATE
+        else -> throw IllegalArgumentException()
+      }
+      val file = getFileAndTypeForUri(uri).first
+      return ParcelFileDescriptor.open(file, openMode)
+    }
+  }
+}

src/main/kotlin/com/looker/droidify/content/Preferences.kt

@@ -0,0 +1,151 @@
+package com.looker.droidify.content
+
+import android.content.Context
+import android.content.SharedPreferences
+import android.content.res.Configuration
+import io.reactivex.rxjava3.core.Observable
+import io.reactivex.rxjava3.subjects.PublishSubject
+import com.looker.droidify.R
+import com.looker.droidify.entity.ProductItem
+import com.looker.droidify.utility.extension.android.*
+import java.net.Proxy
+
+object Preferences {
+  private lateinit var preferences: SharedPreferences
+
+  private val subject = PublishSubject.create<Key<*>>()
+
+  private val keys = sequenceOf(Key.AutoSync, Key.IncompatibleVersions, Key.ProxyHost, Key.ProxyPort, Key.ProxyType,
+    Key.SortOrder, Key.Theme, Key.UpdateNotify, Key.UpdateUnstable).map { Pair(it.name, it) }.toMap()
+
+  fun init(context: Context) {
+    preferences = context.getSharedPreferences("${context.packageName}_preferences", Context.MODE_PRIVATE)
+    preferences.registerOnSharedPreferenceChangeListener { _, keyString -> keys[keyString]?.let(subject::onNext) }
+  }
+
+  val observable: Observable<Key<*>>
+    get() = subject
+
+  sealed class Value<T> {
+    abstract val value: T
+
+    internal abstract fun get(preferences: SharedPreferences, key: String, defaultValue: Value<T>): T
+    internal abstract fun set(preferences: SharedPreferences, key: String, value: T)
+
+    class BooleanValue(override val value: Boolean): Value<Boolean>() {
+      override fun get(preferences: SharedPreferences, key: String, defaultValue: Value<Boolean>): Boolean {
+        return preferences.getBoolean(key, defaultValue.value)
+      }
+
+      override fun set(preferences: SharedPreferences, key: String, value: Boolean) {
+        preferences.edit().putBoolean(key, value).apply()
+      }
+    }
+
+    class IntValue(override val value: Int): Value<Int>() {
+      override fun get(preferences: SharedPreferences, key: String, defaultValue: Value<Int>): Int {
+        return preferences.getInt(key, defaultValue.value)
+      }
+
+      override fun set(preferences: SharedPreferences, key: String, value: Int) {
+        preferences.edit().putInt(key, value).apply()
+      }
+    }
+
+    class StringValue(override val value: String): Value<String>() {
+      override fun get(preferences: SharedPreferences, key: String, defaultValue: Value<String>): String {
+        return preferences.getString(key, defaultValue.value) ?: defaultValue.value
+      }
+
+      override fun set(preferences: SharedPreferences, key: String, value: String) {
+        preferences.edit().putString(key, value).apply()
+      }
+    }
+
+    class EnumerationValue<T: Enumeration<T>>(override val value: T): Value<T>() {
+      override fun get(preferences: SharedPreferences, key: String, defaultValue: Value<T>): T {
+        val value = preferences.getString(key, defaultValue.value.valueString)
+        return defaultValue.value.values.find { it.valueString == value } ?: defaultValue.value
+      }
+
+      override fun set(preferences: SharedPreferences, key: String, value: T) {
+        preferences.edit().putString(key, value.valueString).apply()
+      }
+    }
+  }
+
+  interface Enumeration<T> {
+    val values: List<T>
+    val valueString: String
+  }
+
+  sealed class Key<T>(val name: String, val default: Value<T>) {
+    object AutoSync: Key<Preferences.AutoSync>("auto_sync", Value.EnumerationValue(Preferences.AutoSync.Wifi))
+    object IncompatibleVersions: Key<Boolean>("incompatible_versions", Value.BooleanValue(false))
+    object ProxyHost: Key<String>("proxy_host", Value.StringValue("localhost"))
+    object ProxyPort: Key<Int>("proxy_port", Value.IntValue(9050))
+    object ProxyType: Key<Preferences.ProxyType>("proxy_type", Value.EnumerationValue(Preferences.ProxyType.Direct))
+    object SortOrder: Key<Preferences.SortOrder>("sort_order", Value.EnumerationValue(Preferences.SortOrder.Update))
+    object Theme: Key<Preferences.Theme>("theme", Value.EnumerationValue(if (Android.sdk(29))
+      Preferences.Theme.System else Preferences.Theme.Light))
+    object UpdateNotify: Key<Boolean>("update_notify", Value.BooleanValue(true))
+    object UpdateUnstable: Key<Boolean>("update_unstable", Value.BooleanValue(false))
+  }
+
+  sealed class AutoSync(override val valueString: String): Enumeration<AutoSync> {
+    override val values: List<AutoSync>
+      get() = listOf(Never, Wifi, Always)
+
+    object Never: AutoSync("never")
+    object Wifi: AutoSync("wifi")
+    object Always: AutoSync("always")
+  }
+
+  sealed class ProxyType(override val valueString: String, val proxyType: Proxy.Type): Enumeration<ProxyType> {
+    override val values: List<ProxyType>
+      get() = listOf(Direct, Http, Socks)
+
+    object Direct: ProxyType("direct", Proxy.Type.DIRECT)
+    object Http: ProxyType("http", Proxy.Type.HTTP)
+    object Socks: ProxyType("socks", Proxy.Type.SOCKS)
+  }
+
+  sealed class SortOrder(override val valueString: String, val order: ProductItem.Order): Enumeration<SortOrder> {
+    override val values: List<SortOrder>
+      get() = listOf(Name, Added, Update)
+
+    object Name: SortOrder("name", ProductItem.Order.NAME)
+    object Added: SortOrder("added", ProductItem.Order.DATE_ADDED)
+    object Update: SortOrder("update", ProductItem.Order.LAST_UPDATE)
+  }
+
+  sealed class Theme(override val valueString: String): Enumeration<Theme> {
+    override val values: List<Theme>
+      get() = if (Android.sdk(29)) listOf(System, Light, Dark) else listOf(Light, Dark)
+
+    abstract fun getResId(configuration: Configuration): Int
+
+    object System: Theme("system") {
+      override fun getResId(configuration: Configuration): Int {
+        return if ((configuration.uiMode and Configuration.UI_MODE_NIGHT_YES) != 0)
+          R.style.Theme_Main_Dark else R.style.Theme_Main_Light
+      }
+    }
+
+    object Light: Theme("light") {
+      override fun getResId(configuration: Configuration): Int = R.style.Theme_Main_Light
+    }
+
+    object Dark: Theme("dark") {
+      override fun getResId(configuration: Configuration): Int = R.style.Theme_Main_Dark
+    }
+  }
+
+  operator fun <T> get(key: Key<T>): T {
+    return key.default.get(preferences, key.name, key.default)
+  }
+
+  operator fun <T> set(key: Key<T>, value: T) {
+    key.default.set(preferences, key.name, value)
+  }
+}

src/main/kotlin/com/looker/droidify/content/ProductPreferences.kt

@@ -0,0 +1,64 @@
+package com.looker.droidify.content
+
+import android.content.Context
+import android.content.SharedPreferences
+import io.reactivex.rxjava3.schedulers.Schedulers
+import io.reactivex.rxjava3.subjects.PublishSubject
+import com.looker.droidify.database.Database
+import com.looker.droidify.entity.ProductPreference
+import com.looker.droidify.utility.extension.json.*
+import java.io.ByteArrayOutputStream
+import java.nio.charset.Charset
+
+object ProductPreferences {
+  private val defaultProductPreference = ProductPreference(false, 0L)
+  private lateinit var preferences: SharedPreferences
+  private val subject = PublishSubject.create<Pair<String, Long?>>()
+
+  fun init(context: Context) {
+    preferences = context.getSharedPreferences("product_preferences", Context.MODE_PRIVATE)
+    Database.LockAdapter.putAll(preferences.all.keys
+      .mapNotNull { packageName -> this[packageName].databaseVersionCode?.let { Pair(packageName, it) } })
+    subject
+      .observeOn(Schedulers.io())
+      .subscribe { (packageName, versionCode) ->
+        if (versionCode != null) {
+          Database.LockAdapter.put(Pair(packageName, versionCode))
+        } else {
+          Database.LockAdapter.delete(packageName)
+        }
+      }
+  }
+
+  private val ProductPreference.databaseVersionCode: Long?
+    get() = when {
+      ignoreUpdates -> 0L
+      ignoreVersionCode > 0L -> ignoreVersionCode
+      else -> null
+    }
+
+  operator fun get(packageName: String): ProductPreference {
+    return if (preferences.contains(packageName)) {
+      try {
+        Json.factory.createParser(preferences.getString(packageName, "{}"))
+          .use { it.parseDictionary(ProductPreference.Companion::deserialize) }
+      } catch (e: Exception) {
+        e.printStackTrace()
+        defaultProductPreference
+      }
+    } else {
+      defaultProductPreference
+    }
+  }
+
+  operator fun set(packageName: String, productPreference: ProductPreference) {
+    val oldProductPreference = this[packageName]
+    preferences.edit().putString(packageName, ByteArrayOutputStream()
+      .apply { Json.factory.createGenerator(this).use { it.writeDictionary(productPreference::serialize) } }
+      .toByteArray().toString(Charset.defaultCharset())).apply()
+    if (oldProductPreference.ignoreUpdates != productPreference.ignoreUpdates ||
+      oldProductPreference.ignoreVersionCode != productPreference.ignoreVersionCode) {
+      subject.onNext(Pair(packageName, productPreference.databaseVersionCode))
+    }
+  }
+}

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()
+    }
+  }
+}

src/main/kotlin/com/looker/droidify/entity/InstalledItem.kt

@@ -0,0 +1,3 @@
+package com.looker.droidify.entity
+
+class InstalledItem(val packageName: String, val version: String, val versionCode: Long, val signature: String)

src/main/kotlin/com/looker/droidify/entity/Product.kt

@@ -0,0 +1,227 @@
+package com.looker.droidify.entity
+
+import com.fasterxml.jackson.core.JsonGenerator
+import com.fasterxml.jackson.core.JsonParser
+import com.fasterxml.jackson.core.JsonToken
+import com.looker.droidify.utility.extension.json.*
+import com.looker.droidify.utility.extension.text.*
+
+data class Product(val repositoryId: Long, val packageName: String, val name: String, val summary: String,
+  val description: String, val whatsNew: String, val icon: String, val metadataIcon: String, val author: Author,
+  val source: String, val changelog: String, val web: String, val tracker: String,
+  val added: Long, val updated: Long, val suggestedVersionCode: Long,
+  val categories: List<String>, val antiFeatures: List<String>, val licenses: List<String>,
+  val donates: List<Donate>, val screenshots: List<Screenshot>, val releases: List<Release>) {
+  data class Author(val name: String, val email: String, val web: String)
+
+  sealed class Donate {
+    data class Regular(val url: String): Donate()
+    data class Bitcoin(val address: String): Donate()
+    data class Litecoin(val address: String): Donate()
+    data class Flattr(val id: String): Donate()
+    data class Liberapay(val id: String): Donate()
+    data class OpenCollective(val id: String): Donate()
+  }
+
+  class Screenshot(val locale: String, val type: Type, val path: String) {
+    enum class Type(val jsonName: String) {
+      PHONE("phone"),
+      SMALL_TABLET("smallTablet"),
+      LARGE_TABLET("largeTablet")
+    }
+
+    val identifier: String
+      get() = "$locale.${type.name}.$path"
+  }
+
+  // Same releases with different signatures
+  val selectedReleases: List<Release>
+    get() = releases.filter { it.selected }
+
+  val displayRelease: Release?
+    get() = selectedReleases.firstOrNull() ?: releases.firstOrNull()
+
+  val version: String
+    get() = displayRelease?.version.orEmpty()
+
+  val versionCode: Long
+    get() = selectedReleases.firstOrNull()?.versionCode ?: 0L
+
+  val compatible: Boolean
+    get() = selectedReleases.firstOrNull()?.incompatibilities?.isEmpty() == true
+
+  val signatures: List<String>
+    get() = selectedReleases.mapNotNull { it.signature.nullIfEmpty() }.distinct().toList()
+
+  fun item(): ProductItem {
+    return ProductItem(repositoryId, packageName, name, summary, icon, metadataIcon, version, "", compatible, false, 0)
+  }
+
+  fun canUpdate(installedItem: InstalledItem?): Boolean {
+    return installedItem != null && compatible && versionCode > installedItem.versionCode &&
+      installedItem.signature in signatures
+  }
+
+  fun serialize(generator: JsonGenerator) {
+    generator.writeNumberField("serialVersion", 1)
+    generator.writeStringField("packageName", packageName)
+    generator.writeStringField("name", name)
+    generator.writeStringField("summary", summary)
+    generator.writeStringField("whatsNew", whatsNew)
+    generator.writeStringField("icon", icon)
+    generator.writeStringField("metadataIcon", metadataIcon)
+    generator.writeStringField("authorName", author.name)
+    generator.writeStringField("authorEmail", author.email)
+    generator.writeStringField("authorWeb", author.web)
+    generator.writeStringField("source", source)
+    generator.writeStringField("changelog", changelog)
+    generator.writeStringField("web", web)
+    generator.writeStringField("tracker", tracker)
+    generator.writeNumberField("added", added)
+    generator.writeNumberField("updated", updated)
+    generator.writeNumberField("suggestedVersionCode", suggestedVersionCode)
+    generator.writeArray("categories") { categories.forEach(::writeString) }
+    generator.writeArray("antiFeatures") { antiFeatures.forEach(::writeString) }
+    generator.writeArray("licenses") { licenses.forEach(::writeString) }
+    generator.writeArray("donates") {
+      donates.forEach {
+        writeDictionary {
+          when (it) {
+            is Donate.Regular -> {
+              writeStringField("type", "")
+              writeStringField("url", it.url)
+            }
+            is Donate.Bitcoin -> {
+              writeStringField("type", "bitcoin")
+              writeStringField("address", it.address)
+            }
+            is Donate.Litecoin -> {
+              writeStringField("type", "litecoin")
+              writeStringField("address", it.address)
+            }
+            is Donate.Flattr -> {
+              writeStringField("type", "flattr")
+              writeStringField("id", it.id)
+            }
+            is Donate.Liberapay -> {
+              writeStringField("type", "liberapay")
+              writeStringField("id", it.id)
+            }
+            is Donate.OpenCollective -> {
+              writeStringField("type", "openCollective")
+              writeStringField("id", it.id)
+            }
+          }::class
+        }
+      }
+    }
+    generator.writeArray("screenshots") {
+      screenshots.forEach {
+        writeDictionary {
+          writeStringField("locale", it.locale)
+          writeStringField("type", it.type.jsonName)
+          writeStringField("path", it.path)
+        }
+      }
+    }
+    generator.writeArray("releases") { releases.forEach { writeDictionary { it.serialize(this) } } }
+  }
+
+  companion object {
+    fun <T> findSuggested(products: List<T>, installedItem: InstalledItem?, extract: (T) -> Product): T? {
+      return products.maxWith(compareBy({ extract(it).compatible &&
+        (installedItem == null || installedItem.signature in extract(it).signatures) }, { extract(it).versionCode }))
+    }
+
+    fun deserialize(repositoryId: Long, description: String, parser: JsonParser): Product {
+      var packageName = ""
+      var name = ""
+      var summary = ""
+      var whatsNew = ""
+      var icon = ""
+      var metadataIcon = ""
+      var authorName = ""
+      var authorEmail = ""
+      var authorWeb = ""
+      var source = ""
+      var changelog = ""
+      var web = ""
+      var tracker = ""
+      var added = 0L
+      var updated = 0L
+      var suggestedVersionCode = 0L
+      var categories = emptyList<String>()
+      var antiFeatures = emptyList<String>()
+      var licenses = emptyList<String>()
+      var donates = emptyList<Donate>()
+      var screenshots = emptyList<Screenshot>()
+      var releases = emptyList<Release>()
+      parser.forEachKey {
+        when {
+          it.string("packageName") -> packageName = valueAsString
+          it.string("name") -> name = valueAsString
+          it.string("summary") -> summary = valueAsString
+          it.string("whatsNew") -> whatsNew = valueAsString
+          it.string("icon") -> icon = valueAsString
+          it.string("metadataIcon") -> metadataIcon = valueAsString
+          it.string("authorName") -> authorName = valueAsString
+          it.string("authorEmail") -> authorEmail = valueAsString
+          it.string("authorWeb") -> authorWeb = valueAsString
+          it.string("source") -> source = valueAsString
+          it.string("changelog") -> changelog = valueAsString
+          it.string("web") -> web = valueAsString
+          it.string("tracker") -> tracker = valueAsString
+          it.number("added") -> added = valueAsLong
+          it.number("updated") -> updated = valueAsLong
+          it.number("suggestedVersionCode") -> suggestedVersionCode = valueAsLong
+          it.array("categories") -> categories = collectNotNullStrings()
+          it.array("antiFeatures") -> antiFeatures = collectNotNullStrings()
+          it.array("licenses") -> licenses = collectNotNullStrings()
+          it.array("donates") -> donates = collectNotNull(JsonToken.START_OBJECT) {
+            var type = ""
+            var url = ""
+            var address = ""
+            var id = ""
+            forEachKey {
+              when {
+                it.string("type") -> type = valueAsString
+                it.string("url") -> url = valueAsString
+                it.string("address") -> address = valueAsString
+                it.string("id") -> id = valueAsString
+                else -> skipChildren()
+              }
+            }
+            when (type) {
+              "" -> Donate.Regular(url)
+              "bitcoin" -> Donate.Bitcoin(address)
+              "litecoin" -> Donate.Litecoin(address)
+              "flattr" -> Donate.Flattr(id)
+              "liberapay" -> Donate.Liberapay(id)
+              "openCollective" -> Donate.OpenCollective(id)
+              else -> null
+            }
+          }
+          it.array("screenshots") -> screenshots = collectNotNull(JsonToken.START_OBJECT) {
+            var locale = ""
+            var type = ""
+            var path = ""
+            forEachKey {
+              when {
+                it.string("locale") -> locale = valueAsString
+                it.string("type") -> type = valueAsString
+                it.string("path") -> path = valueAsString
+                else -> skipChildren()
+              }
+            }
+            Screenshot.Type.values().find { it.jsonName == type }?.let { Screenshot(locale, it, path) }
+          }
+          it.array("releases") -> releases = collectNotNull(JsonToken.START_OBJECT, Release.Companion::deserialize)
+          else -> skipChildren()
+        }
+      }
+      return Product(repositoryId, packageName, name, summary, description, whatsNew, icon, metadataIcon,
+        Author(authorName, authorEmail, authorWeb), source, changelog, web, tracker, added, updated,
+        suggestedVersionCode, categories, antiFeatures, licenses, donates, screenshots, releases)
+    }
+  }
+}

src/main/kotlin/com/looker/droidify/entity/ProductItem.kt

@@ -0,0 +1,79 @@
+package com.looker.droidify.entity
+
+import android.os.Parcel
+import com.fasterxml.jackson.core.JsonGenerator
+import com.fasterxml.jackson.core.JsonParser
+import com.looker.droidify.R
+import com.looker.droidify.utility.KParcelable
+import com.looker.droidify.utility.extension.json.*
+
+data class ProductItem(val repositoryId: Long, val packageName: String, val name: String, val summary: String,
+  val icon: String, val metadataIcon: String, val version: String, val installedVersion: String,
+  val compatible: Boolean, val canUpdate: Boolean, val matchRank: Int) {
+  sealed class Section: KParcelable {
+    object All: Section() {
+      @Suppress("unused") @JvmField val CREATOR = KParcelable.creator { All }
+    }
+
+    data class Category(val name: String): Section() {
+      override fun writeToParcel(dest: Parcel, flags: Int) {
+        dest.writeString(name)
+      }
+
+      companion object {
+        @Suppress("unused") @JvmField val CREATOR = KParcelable.creator {
+          val name = it.readString()!!
+          Category(name)
+        }
+      }
+    }
+
+    data class Repository(val id: Long, val name: String): Section() {
+      override fun writeToParcel(dest: Parcel, flags: Int) {
+        dest.writeLong(id)
+        dest.writeString(name)
+      }
+
+      companion object {
+        @Suppress("unused") @JvmField val CREATOR = KParcelable.creator {
+          val id = it.readLong()
+          val name = it.readString()!!
+          Repository(id, name)
+        }
+      }
+    }
+  }
+
+  enum class Order(val titleResId: Int) {
+    NAME(R.string.name),
+    DATE_ADDED(R.string.date_added),
+    LAST_UPDATE(R.string.last_update)
+  }
+
+  fun serialize(generator: JsonGenerator) {
+    generator.writeNumberField("serialVersion", 1)
+    generator.writeStringField("icon", icon)
+    generator.writeStringField("metadataIcon", metadataIcon)
+    generator.writeStringField("version", version)
+  }
+
+  companion object {
+    fun deserialize(repositoryId: Long, packageName: String, name: String, summary: String,
+      installedVersion: String, compatible: Boolean, canUpdate: Boolean, matchRank: Int,
+      parser: JsonParser): ProductItem {
+      var icon = ""
+      var metadataIcon = ""
+      var version = ""
+      parser.forEachKey {
+        when {
+          it.string("icon") -> icon = valueAsString
+          it.string("metadataIcon") -> metadataIcon = valueAsString
+          it.string("version") -> version = valueAsString
+          else -> skipChildren()
+        }
+      }
+      return ProductItem(repositoryId, packageName, name, summary, icon, metadataIcon,
+        version, installedVersion, compatible, canUpdate, matchRank)
+    }
+  }
+}

src/main/kotlin/com/looker/droidify/entity/ProductPreference.kt

@@ -0,0 +1,31 @@
+package com.looker.droidify.entity
+
+import com.fasterxml.jackson.core.JsonGenerator
+import com.fasterxml.jackson.core.JsonParser
+import com.looker.droidify.utility.extension.json.*
+
+data class ProductPreference(val ignoreUpdates: Boolean, val ignoreVersionCode: Long) {
+  fun shouldIgnoreUpdate(versionCode: Long): Boolean {
+    return ignoreUpdates || ignoreVersionCode == versionCode
+  }
+
+  fun serialize(generator: JsonGenerator) {
+    generator.writeBooleanField("ignoreUpdates", ignoreUpdates)
+    generator.writeNumberField("ignoreVersionCode", ignoreVersionCode)
+  }
+
+  companion object {
+    fun deserialize(parser: JsonParser): ProductPreference {
+      var ignoreUpdates = false
+      var ignoreVersionCode = 0L
+      parser.forEachKey {
+        when {
+          it.boolean("ignoreUpdates") -> ignoreUpdates = valueAsBoolean
+          it.number("ignoreVersionCode") -> ignoreVersionCode = valueAsLong
+          else -> skipChildren()
+        }
+      }
+      return ProductPreference(ignoreUpdates, ignoreVersionCode)
+    }
+  }
+}

src/main/kotlin/com/looker/droidify/entity/Release.kt

@@ -0,0 +1,156 @@
+package com.looker.droidify.entity
+
+import android.net.Uri
+import com.fasterxml.jackson.core.JsonGenerator
+import com.fasterxml.jackson.core.JsonParser
+import com.fasterxml.jackson.core.JsonToken
+import com.looker.droidify.utility.extension.json.*
+
+data class Release(val selected: Boolean, val version: String, val versionCode: Long,
+  val added: Long, val size: Long, val minSdkVersion: Int, val targetSdkVersion: Int, val maxSdkVersion: Int,
+  val source: String, val release: String, val hash: String, val hashType: String, val signature: String,
+  val obbMain: String, val obbMainHash: String, val obbMainHashType: String,
+  val obbPatch: String, val obbPatchHash: String, val obbPatchHashType: String,
+  val permissions: List<String>, val features: List<String>, val platforms: List<String>,
+  val incompatibilities: List<Incompatibility>) {
+  sealed class Incompatibility {
+    object MinSdk: Incompatibility()
+    object MaxSdk: Incompatibility()
+    object Platform: Incompatibility()
+    data class Feature(val feature: String): Incompatibility()
+  }
+
+  val identifier: String
+    get() = "$versionCode.$hash"
+
+  fun getDownloadUrl(repository: Repository): String {
+    return Uri.parse(repository.address).buildUpon().appendPath(release).build().toString()
+  }
+
+  val cacheFileName: String
+    get() = "${hash.replace('/', '-')}.apk"
+
+  fun serialize(generator: JsonGenerator) {
+    generator.writeNumberField("serialVersion", 1)
+    generator.writeBooleanField("selected", selected)
+    generator.writeStringField("version", version)
+    generator.writeNumberField("versionCode", versionCode)
+    generator.writeNumberField("added", added)
+    generator.writeNumberField("size", size)
+    generator.writeNumberField("minSdkVersion", minSdkVersion)
+    generator.writeNumberField("targetSdkVersion", targetSdkVersion)
+    generator.writeNumberField("maxSdkVersion", maxSdkVersion)
+    generator.writeStringField("source", source)
+    generator.writeStringField("release", release)
+    generator.writeStringField("hash", hash)
+    generator.writeStringField("hashType", hashType)
+    generator.writeStringField("signature", signature)
+    generator.writeStringField("obbMain", obbMain)
+    generator.writeStringField("obbMainHash", obbMainHash)
+    generator.writeStringField("obbMainHashType", obbMainHashType)
+    generator.writeStringField("obbPatch", obbPatch)
+    generator.writeStringField("obbPatchHash", obbPatchHash)
+    generator.writeStringField("obbPatchHashType", obbPatchHashType)
+    generator.writeArray("permissions") { permissions.forEach { writeString(it) } }
+    generator.writeArray("features") { features.forEach { writeString(it) } }
+    generator.writeArray("platforms") { platforms.forEach { writeString(it) } }
+    generator.writeArray("incompatibilities") {
+      incompatibilities.forEach {
+        writeDictionary {
+          when (it) {
+            is Incompatibility.MinSdk -> {
+              writeStringField("type", "minSdk")
+            }
+            is Incompatibility.MaxSdk -> {
+              writeStringField("type", "maxSdk")
+            }
+            is Incompatibility.Platform -> {
+              writeStringField("type", "platform")
+            }
+            is Incompatibility.Feature -> {
+              writeStringField("type", "feature")
+              writeStringField("feature", it.feature)
+            }
+          }::class
+        }
+      }
+    }
+  }
+
+  companion object {
+    fun deserialize(parser: JsonParser): Release {
+      var selected = false
+      var version = ""
+      var versionCode = 0L
+      var added = 0L
+      var size = 0L
+      var minSdkVersion = 0
+      var targetSdkVersion = 0
+      var maxSdkVersion = 0
+      var source = ""
+      var release = ""
+      var hash = ""
+      var hashType = ""
+      var signature = ""
+      var obbMain = ""
+      var obbMainHash = ""
+      var obbMainHashType = ""
+      var obbPatch = ""
+      var obbPatchHash = ""
+      var obbPatchHashType = ""
+      var permissions = emptyList<String>()
+      var features = emptyList<String>()
+      var platforms = emptyList<String>()
+      var incompatibilities = emptyList<Incompatibility>()
+      parser.forEachKey {
+        when {
+          it.boolean("selected") -> selected = valueAsBoolean
+          it.string("version") -> version = valueAsString
+          it.number("versionCode") -> versionCode = valueAsLong
+          it.number("added") -> added = valueAsLong
+          it.number("size") -> size = valueAsLong
+          it.number("minSdkVersion") -> minSdkVersion = valueAsInt
+          it.number("targetSdkVersion") -> targetSdkVersion = valueAsInt
+          it.number("maxSdkVersion") -> maxSdkVersion = valueAsInt
+          it.string("source") -> source = valueAsString
+          it.string("release") -> release = valueAsString
+          it.string("hash") -> hash = valueAsString
+          it.string("hashType") -> hashType = valueAsString
+          it.string("signature") -> signature = valueAsString
+          it.string("obbMain") -> obbMain = valueAsString
+          it.string("obbMainHash") -> obbMainHash = valueAsString
+          it.string("obbMainHashType") -> obbMainHashType = valueAsString
+          it.string("obbPatch") -> obbPatch = valueAsString
+          it.string("obbPatchHash") -> obbPatchHash = valueAsString
+          it.string("obbPatchHashType") -> obbPatchHashType = valueAsString
+          it.array("permissions") -> permissions = collectNotNullStrings()
+          it.array("features") -> features = collectNotNullStrings()
+          it.array("platforms") -> platforms = collectNotNullStrings()
+          it.array("incompatibilities") -> incompatibilities = collectNotNull(JsonToken.START_OBJECT) {
+            var type = ""
+            var feature = ""
+            forEachKey {
+              when {
+                it.string("type") -> type = valueAsString
+                it.string("feature") -> feature = valueAsString
+                else -> skipChildren()
+              }
+            }
+            when (type) {
+              "minSdk" -> Incompatibility.MinSdk
+              "maxSdk" -> Incompatibility.MaxSdk
+              "platform" -> Incompatibility.Platform
+              "feature" -> Incompatibility.Feature(feature)
+              else -> null
+            }
+          }
+          else -> skipChildren()
+        }
+      }
+      return Release(selected, version, versionCode, added, size,
+        minSdkVersion, targetSdkVersion, maxSdkVersion, source, release, hash, hashType, signature,
+        obbMain, obbMainHash, obbMainHashType, obbPatch, obbPatchHash, obbPatchHashType,
+        permissions, features, platforms, incompatibilities)
+    }
+  }
+}

src/main/kotlin/com/looker/droidify/entity/Repository.kt

@@ -0,0 +1,124 @@
+package com.looker.droidify.entity
+
+import com.fasterxml.jackson.core.JsonGenerator
+import com.fasterxml.jackson.core.JsonParser
+import com.looker.droidify.utility.extension.json.*
+import java.net.URL
+
+data class Repository(val id: Long, val address: String, val mirrors: List<String>,
+  val name: String, val description: String, val version: Int, val enabled: Boolean,
+  val fingerprint: String, val lastModified: String, val entityTag: String,
+  val updated: Long, val timestamp: Long, val authentication: String) {
+  fun edit(address: String, fingerprint: String, authentication: String): Repository {
+    val addressChanged = this.address != address
+    val fingerprintChanged = this.fingerprint != fingerprint
+    val changed = addressChanged || fingerprintChanged
+    return copy(address = address, fingerprint = fingerprint, lastModified = if (changed) "" else lastModified,
+      entityTag = if (changed) "" else entityTag, authentication = authentication)
+  }
+
+  fun update(mirrors: List<String>, name: String, description: String, version: Int,
+    lastModified: String, entityTag: String, timestamp: Long): Repository {
+    return copy(mirrors = mirrors, name = name, description = description,
+      version = if (version >= 0) version else this.version, lastModified = lastModified,
+      entityTag = entityTag, updated = System.currentTimeMillis(), timestamp = timestamp)
+  }
+
+  fun enable(enabled: Boolean): Repository {
+    return copy(enabled = enabled, lastModified = "", entityTag = "")
+  }
+
+  fun serialize(generator: JsonGenerator) {
+    generator.writeNumberField("serialVersion", 1)
+    generator.writeStringField("address", address)
+    generator.writeArray("mirrors") { mirrors.forEach { writeString(it) } }
+    generator.writeStringField("name", name)
+    generator.writeStringField("description", description)
+    generator.writeNumberField("version", version)
+    generator.writeBooleanField("enabled", enabled)
+    generator.writeStringField("fingerprint", fingerprint)
+    generator.writeStringField("lastModified", lastModified)
+    generator.writeStringField("entityTag", entityTag)
+    generator.writeNumberField("updated", updated)
+    generator.writeNumberField("timestamp", timestamp)
+    generator.writeStringField("authentication", authentication)
+  }
+
+  companion object {
+    fun deserialize(id: Long, parser: JsonParser): Repository {
+      var address = ""
+      var mirrors = emptyList<String>()
+      var name = ""
+      var description = ""
+      var version = 0
+      var enabled = false
+      var fingerprint = ""
+      var lastModified = ""
+      var entityTag = ""
+      var updated = 0L
+      var timestamp = 0L
+      var authentication = ""
+      parser.forEachKey {
+        when {
+          it.string("address") -> address = valueAsString
+          it.array("mirrors") -> mirrors = collectNotNullStrings()
+          it.string("name") -> name = valueAsString
+          it.string("description") -> description = valueAsString
+          it.number("version") -> version = valueAsInt
+          it.boolean("enabled") -> enabled = valueAsBoolean
+          it.string("fingerprint") -> fingerprint = valueAsString
+          it.string("lastModified") -> lastModified = valueAsString
+          it.string("entityTag") -> entityTag = valueAsString
+          it.number("updated") -> updated = valueAsLong
+          it.number("timestamp") -> timestamp = valueAsLong
+          it.string("authentication") -> authentication = valueAsString
+          else -> skipChildren()
+        }
+      }
+      return Repository(id, address, mirrors, name, description, version, enabled, fingerprint,
+        lastModified, entityTag, updated, timestamp, authentication)
+    }
+
+    fun newRepository(address: String, fingerprint: String, authentication: String): Repository {
+      val name = try {
+        URL(address).let { "${it.host}${it.path}" }
+      } catch (e: Exception) {
+        address
+      }
+      return defaultRepository(address, name, "", 0, true, fingerprint, authentication)
+    }
+
+    private fun defaultRepository(address: String, name: String, description: String,
+      version: Int, enabled: Boolean, fingerprint: String, authentication: String): Repository {
+      return Repository(-1, address, emptyList(), name, description, version, enabled,
+        fingerprint, "", "", 0L, 0L, authentication)
+    }
+
+    val defaultRepositories = listOf(run {
+      defaultRepository("https://f-droid.org/repo", "F-Droid", "The official F-Droid Free Software repository. " +
+        "Everything in this repository is always built from the source code.",
+        21, true, "43238D512C1E5EB2D6569F4A3AFBF5523418B82E0A3ED1552770ABB9A9C9CCAB", "")
+    }, run {
+      defaultRepository("https://f-droid.org/archive", "F-Droid Archive", "The archive of the official F-Droid Free " +
+        "Software repository. Apps here are old and can contain known vulnerabilities and security issues!",
+        21, false, "43238D512C1E5EB2D6569F4A3AFBF5523418B82E0A3ED1552770ABB9A9C9CCAB", "")
+    }, run {
+      defaultRepository("https://guardianproject.info/fdroid/repo", "Guardian Project Official Releases", "The " +
+        "official repository of The Guardian Project apps for use with the F-Droid client. Applications in this " +
+        "repository are official binaries built by the original application developers and signed by the same key as " +
+        "the APKs that are released in the Google Play Store.",
+        21, false, "B7C2EEFD8DAC7806AF67DFCD92EB18126BC08312A7F2D6F3862E46013C7A6135", "")
+    }, run {
+      defaultRepository("https://guardianproject.info/fdroid/archive", "Guardian Project Archive", "The official " +
+        "repository of The Guardian Project apps for use with the F-Droid client. This contains older versions of " +
+        "applications from the main repository.", 21, false,
+        "B7C2EEFD8DAC7806AF67DFCD92EB18126BC08312A7F2D6F3862E46013C7A6135", "")
+    }, run {
+      defaultRepository("https://apt.izzysoft.de/fdroid/repo", "IzzyOnDroid F-Droid Repo", "This is a " +
+              "repository of apps to be used with F-Droid the original application developers, taken from the resp. " +
+              "repositories (mostly GitHub). At this moment I cannot give guarantees on regular updates for all of them, " +
+              "though most are checked multiple times a week ", 21, true,
+              "3BF0D6ABFEAE2F401707B6D966BE743BF0EEE49C2561B9BA39073711F628937A", "")
+    })
+  }
+}

src/main/kotlin/com/looker/droidify/graphics/DrawableWrapper.kt

@@ -0,0 +1,56 @@
+package com.looker.droidify.graphics
+
+import android.graphics.Canvas
+import android.graphics.ColorFilter
+import android.graphics.Rect
+import android.graphics.drawable.Drawable
+
+open class DrawableWrapper(val drawable: Drawable): Drawable() {
+  init {
+    drawable.callback = object: Callback {
+      override fun invalidateDrawable(who: Drawable) {
+        callback?.invalidateDrawable(who)
+      }
+
+      override fun scheduleDrawable(who: Drawable, what: Runnable, `when`: Long) {
+        callback?.scheduleDrawable(who, what, `when`)
+      }
+
+      override fun unscheduleDrawable(who: Drawable, what: Runnable) {
+        callback?.unscheduleDrawable(who, what)
+      }
+    }
+  }
+
+  override fun onBoundsChange(bounds: Rect) {
+    drawable.bounds = bounds
+  }
+
+  override fun getIntrinsicWidth(): Int = drawable.intrinsicWidth
+  override fun getIntrinsicHeight(): Int = drawable.intrinsicHeight
+  override fun getMinimumWidth(): Int = drawable.minimumWidth
+  override fun getMinimumHeight(): Int = drawable.minimumHeight
+
+  override fun draw(canvas: Canvas) {
+    drawable.draw(canvas)
+  }
+
+  override fun getAlpha(): Int {
+    return drawable.alpha
+  }
+
+  override fun setAlpha(alpha: Int) {
+    drawable.alpha = alpha
+  }
+
+  override fun getColorFilter(): ColorFilter? {
+    return drawable.colorFilter
+  }
+
+  override fun setColorFilter(colorFilter: ColorFilter?) {
+    drawable.colorFilter = colorFilter
+  }
+
+  @Suppress("DEPRECATION")
+  override fun getOpacity(): Int = drawable.opacity
+}

src/main/kotlin/com/looker/droidify/graphics/PaddingDrawable.kt

@@ -0,0 +1,19 @@
+package com.looker.droidify.graphics
+
+import android.graphics.Rect
+import android.graphics.drawable.Drawable
+import kotlin.math.*
+
+class PaddingDrawable(drawable: Drawable, private val factor: Float): DrawableWrapper(drawable) {
+  override fun getIntrinsicWidth(): Int = (factor * super.getIntrinsicWidth()).roundToInt()
+  override fun getIntrinsicHeight(): Int = (factor * super.getIntrinsicHeight()).roundToInt()
+
+  override fun onBoundsChange(bounds: Rect) {
+    val width = (bounds.width() / factor).roundToInt()
+    val height = (bounds.height() / factor).roundToInt()
+    val left = (bounds.width() - width) / 2
+    val top = (bounds.height() - height) / 2
+    drawable.setBounds(bounds.left + left, bounds.top + top,
+      bounds.left + left + width, bounds.top + top + height)
+  }
+}

src/main/kotlin/com/looker/droidify/index/IndexHandler.kt

@@ -0,0 +1,265 @@
+package com.looker.droidify.index
+
+import com.looker.droidify.entity.Product
+import com.looker.droidify.entity.Release
+import com.looker.droidify.utility.extension.android.*
+import org.xml.sax.Attributes
+import org.xml.sax.helpers.DefaultHandler
+import java.text.SimpleDateFormat
+import java.util.Locale
+import java.util.TimeZone
+
+class IndexHandler(private val repositoryId: Long, private val callback: Callback): DefaultHandler() {
+  companion object {
+    private val dateFormat = SimpleDateFormat("yyyy-MM-dd", Locale.US)
+      .apply { timeZone = TimeZone.getTimeZone("UTC") }
+
+    private fun String.parseDate(): Long {
+      return try {
+        dateFormat.parse(this)?.time ?: 0L
+      } catch (e: Exception) {
+        0L
+      }
+    }
+
+    internal fun validateIcon(icon: String): String {
+      return if (icon.endsWith(".xml")) "" else icon
+    }
+  }
+
+  interface Callback {
+    fun onRepository(mirrors: List<String>, name: String, description: String,
+      certificate: String, version: Int, timestamp: Long)
+    fun onProduct(product: Product)
+  }
+
+  internal object DonateComparator: Comparator<Product.Donate> {
+    private val classes = listOf(Product.Donate.Regular::class, Product.Donate.Bitcoin::class,
+      Product.Donate.Litecoin::class, Product.Donate.Flattr::class, Product.Donate.Liberapay::class,
+      Product.Donate.OpenCollective::class)
+
+    override fun compare(donate1: Product.Donate, donate2: Product.Donate): Int {
+      val index1 = classes.indexOf(donate1::class)
+      val index2 = classes.indexOf(donate2::class)
+      return when {
+        index1 >= 0 && index2 == -1 -> -1
+        index2 >= 0 && index1 == -1 -> 1
+        else -> index1.compareTo(index2)
+      }
+    }
+  }
+
+  private class RepositoryBuilder {
+    var address = ""
+    val mirrors = mutableListOf<String>()
+    var name = ""
+    var description = ""
+    var certificate = ""
+    var version = -1
+    var timestamp = 0L
+  }
+
+  private class ProductBuilder(val repositoryId: Long, val packageName: String) {
+    var name = ""
+    var summary = ""
+    var description = ""
+    var icon = ""
+    var authorName = ""
+    var authorEmail = ""
+    var source = ""
+    var changelog = ""
+    var web = ""
+    var tracker = ""
+    var added = 0L
+    var updated = 0L
+    var suggestedVersionCode = 0L
+    val categories = linkedSetOf<String>()
+    val antiFeatures = linkedSetOf<String>()
+    val licenses = mutableListOf<String>()
+    val donates = mutableListOf<Product.Donate>()
+    val releases = mutableListOf<Release>()
+
+    fun build(): Product {
+      return Product(repositoryId, packageName, name, summary, description, "", icon, "",
+        Product.Author(authorName, authorEmail, ""), source, changelog, web, tracker, added, updated,
+        suggestedVersionCode, categories.toList(), antiFeatures.toList(),
+        licenses, donates.sortedWith(DonateComparator), emptyList(), releases)
+    }
+  }
+
+  private class ReleaseBuilder {
+    var version = ""
+    var versionCode = 0L
+    var added = 0L
+    var size = 0L
+    var minSdkVersion = 0
+    var targetSdkVersion = 0
+    var maxSdkVersion = 0
+    var source = ""
+    var release = ""
+    var hash = ""
+    var hashType = ""
+    var signature = ""
+    var obbMain = ""
+    var obbMainHash = ""
+    var obbPatch = ""
+    var obbPatchHash = ""
+    val permissions = linkedSetOf<String>()
+    val features = linkedSetOf<String>()
+    val platforms = linkedSetOf<String>()
+
+    fun build(): Release {
+      val hashType = if (hash.isNotEmpty() && hashType.isEmpty()) "sha256" else hashType
+      val obbMainHashType = if (obbMainHash.isNotEmpty()) "sha256" else ""
+      val obbPatchHashType = if (obbPatchHash.isNotEmpty()) "sha256" else ""
+      return Release(false, version, versionCode, added, size,
+        minSdkVersion, targetSdkVersion, maxSdkVersion, source, release, hash, hashType, signature,
+        obbMain, obbMainHash, obbMainHashType, obbPatch, obbPatchHash, obbPatchHashType,
+        permissions.toList(), features.toList(), platforms.toList(), emptyList())
+    }
+  }
+
+  private val contentBuilder = StringBuilder()
+
+  private var repositoryBuilder: RepositoryBuilder? = RepositoryBuilder()
+  private var productBuilder: ProductBuilder? = null
+  private var releaseBuilder: ReleaseBuilder? = null
+
+  private fun Attributes.get(localName: String): String = getValue("", localName).orEmpty()
+  private fun String.cleanWhiteSpace(): String = replace("\\s".toRegex(), " ")
+
+  override fun startElement(uri: String, localName: String, qName: String, attributes: Attributes) {
+    super.startElement(uri, localName, qName, attributes)
+
+    val repositoryBuilder = repositoryBuilder
+    val productBuilder = productBuilder
+    val releaseBuilder = releaseBuilder
+    contentBuilder.setLength(0)
+
+    when {
+      localName == "repo" -> {
+        if (repositoryBuilder != null) {
+          repositoryBuilder.address = attributes.get("url").cleanWhiteSpace()
+          repositoryBuilder.name = attributes.get("name").cleanWhiteSpace()
+          repositoryBuilder.description = attributes.get("description").cleanWhiteSpace()
+          repositoryBuilder.certificate = attributes.get("pubkey")
+          repositoryBuilder.version = attributes.get("version").toIntOrNull() ?: 0
+          repositoryBuilder.timestamp = (attributes.get("timestamp").toLongOrNull() ?: 0L) * 1000L
+        }
+      }
+      localName == "application" && productBuilder == null -> {
+        this.productBuilder = ProductBuilder(repositoryId, attributes.get("id"))
+      }
+      localName == "package" && productBuilder != null && releaseBuilder == null -> {
+        this.releaseBuilder = ReleaseBuilder()
+      }
+      localName == "hash" && releaseBuilder != null -> {
+        releaseBuilder.hashType = attributes.get("type")
+      }
+      (localName == "uses-permission" || localName.startsWith("uses-permission-")) && releaseBuilder != null -> {
+        val minSdkVersion = if (localName != "uses-permission") {
+          "uses-permission-sdk-(\\d+)".toRegex().matchEntire(localName)
+            ?.destructured?.let { (version) -> version.toIntOrNull() }
+        } else {
+          null
+        } ?: 0
+        val maxSdkVersion = attributes.get("maxSdkVersion").toIntOrNull() ?: Int.MAX_VALUE
+        if (Android.sdk in minSdkVersion .. maxSdkVersion) {
+          releaseBuilder.permissions.add(attributes.get("name"))
+        } else {
+          releaseBuilder.permissions.remove(attributes.get("name"))
+        }
+      }
+    }
+  }
+
+  override fun endElement(uri: String, localName: String, qName: String) {
+    super.endElement(uri, localName, qName)
+
+    val repositoryBuilder = repositoryBuilder
+    val productBuilder = productBuilder
+    val releaseBuilder = releaseBuilder
+    val content = contentBuilder.toString()
+
+    when {
+      localName == "repo" -> {
+        if (repositoryBuilder != null) {
+          val mirrors = (listOf(repositoryBuilder.address) + repositoryBuilder.mirrors)
+            .filter { it.isNotEmpty() }.distinct()
+          callback.onRepository(mirrors, repositoryBuilder.name, repositoryBuilder.description,
+            repositoryBuilder.certificate, repositoryBuilder.version, repositoryBuilder.timestamp)
+          this.repositoryBuilder = null
+        }
+      }
+      localName == "application" && productBuilder != null -> {
+        val product = productBuilder.build()
+        this.productBuilder = null
+        callback.onProduct(product)
+      }
+      localName == "package" && productBuilder != null && releaseBuilder != null -> {
+        productBuilder.releases.add(releaseBuilder.build())
+        this.releaseBuilder = null
+      }
+      repositoryBuilder != null -> {
+        when (localName) {
+          "description" -> repositoryBuilder.description = content.cleanWhiteSpace()
+          "mirror" -> repositoryBuilder.mirrors += content
+        }
+      }
+      productBuilder != null && releaseBuilder != null -> {
+        when (localName) {
+          "version" -> releaseBuilder.version = content
+          "versioncode" -> releaseBuilder.versionCode = content.toLongOrNull() ?: 0L
+          "added" -> releaseBuilder.added = content.parseDate()
+          "size" -> releaseBuilder.size = content.toLongOrNull() ?: 0
+          "sdkver" -> releaseBuilder.minSdkVersion = content.toIntOrNull() ?: 0
+          "targetSdkVersion" -> releaseBuilder.targetSdkVersion = content.toIntOrNull() ?: 0
+          "maxsdkver" -> releaseBuilder.maxSdkVersion = content.toIntOrNull() ?: 0
+          "srcname" -> releaseBuilder.source = content
+          "apkname" -> releaseBuilder.release = content
+          "hash" -> releaseBuilder.hash = content
+          "sig" -> releaseBuilder.signature = content
+          "obbMainFile" -> releaseBuilder.obbMain = content
+          "obbMainFileSha256" -> releaseBuilder.obbMainHash = content
+          "obbPatchFile" -> releaseBuilder.obbPatch = content
+          "obbPatchFileSha256" -> releaseBuilder.obbPatchHash = content
+          "permissions" -> releaseBuilder.permissions += content.split(',').filter { it.isNotEmpty() }
+          "features" -> releaseBuilder.features += content.split(',').filter { it.isNotEmpty() }
+          "nativecode" -> releaseBuilder.platforms += content.split(',').filter { it.isNotEmpty() }
+        }
+      }
+      productBuilder != null -> {
+        when (localName) {
+          "name" -> productBuilder.name = content
+          "summary" -> productBuilder.summary = content
+          "description" -> productBuilder.description = "<p>$content</p>"
+          "desc" -> productBuilder.description = content.replace("\n", "<br/>")
+          "icon" -> productBuilder.icon = validateIcon(content)
+          "author" -> productBuilder.authorName = content
+          "email" -> productBuilder.authorEmail = content
+          "source" -> productBuilder.source = content
+          "changelog" -> productBuilder.changelog = content
+          "web" -> productBuilder.web = content
+          "tracker" -> productBuilder.tracker = content
+          "added" -> productBuilder.added = content.parseDate()
+          "lastupdated" -> productBuilder.updated = content.parseDate()
+          "marketvercode" -> productBuilder.suggestedVersionCode = content.toLongOrNull() ?: 0L
+          "categories" -> productBuilder.categories += content.split(',').filter { it.isNotEmpty() }
+          "antifeatures" -> productBuilder.antiFeatures += content.split(',').filter { it.isNotEmpty() }
+          "license" -> productBuilder.licenses += content.split(',').filter { it.isNotEmpty() }
+          "donate" -> productBuilder.donates += Product.Donate.Regular(content)
+          "bitcoin" -> productBuilder.donates += Product.Donate.Bitcoin(content)
+          "litecoin" -> productBuilder.donates += Product.Donate.Litecoin(content)
+          "flattr" -> productBuilder.donates += Product.Donate.Flattr(content)
+          "liberapay" -> productBuilder.donates += Product.Donate.Liberapay(content)
+          "openCollective" -> productBuilder.donates += Product.Donate.OpenCollective(content)
+        }
+      }
+    }
+  }
+
+  override fun characters(ch: CharArray, start: Int, length: Int) {
+    super.characters(ch, start, length)
+    contentBuilder.append(ch, start, length)
+  }
+}

src/main/kotlin/com/looker/droidify/index/IndexMerger.kt

@@ -0,0 +1,83 @@
+package com.looker.droidify.index
+
+import android.content.ContentValues
+import android.database.sqlite.SQLiteDatabase
+import com.fasterxml.jackson.core.JsonToken
+import com.looker.droidify.entity.Product
+import com.looker.droidify.entity.Release
+import com.looker.droidify.utility.extension.android.*
+import com.looker.droidify.utility.extension.json.*
+import java.io.ByteArrayOutputStream
+import java.io.Closeable
+import java.io.File
+
+class IndexMerger(file: File): Closeable {
+  private val db = SQLiteDatabase.openOrCreateDatabase(file, null)
+
+  init {
+    db.execWithResult("PRAGMA synchronous = OFF")
+    db.execWithResult("PRAGMA journal_mode = OFF")
+    db.execSQL("CREATE TABLE product (package_name TEXT PRIMARY KEY, description TEXT NOT NULL, data BLOB NOT NULL)")
+    db.execSQL("CREATE TABLE releases (package_name TEXT PRIMARY KEY, data BLOB NOT NULL)")
+    db.beginTransaction()
+  }
+
+  fun addProducts(products: List<Product>) {
+    for (product in products) {
+      val outputStream = ByteArrayOutputStream()
+      Json.factory.createGenerator(outputStream).use { it.writeDictionary(product::serialize) }
+      db.insert("product", null, ContentValues().apply {
+        put("package_name", product.packageName)
+        put("description", product.description)
+        put("data", outputStream.toByteArray())
+      })
+    }
+  }
+
+  fun addReleases(pairs: List<Pair<String, List<Release>>>) {
+    for (pair in pairs) {
+      val (packageName, releases) = pair
+      val outputStream = ByteArrayOutputStream()
+      Json.factory.createGenerator(outputStream).use {
+        it.writeStartArray()
+        for (release in releases) {
+          it.writeDictionary(release::serialize)
+        }
+        it.writeEndArray()
+      }
+      db.insert("releases", null, ContentValues().apply {
+        put("package_name", packageName)
+        put("data", outputStream.toByteArray())
+      })
+    }
+  }
+
+  private fun closeTransaction() {
+    if (db.inTransaction()) {
+      db.setTransactionSuccessful()
+      db.endTransaction()
+    }
+  }
+
+  fun forEach(repositoryId: Long, windowSize: Int, callback: (List<Product>, Int) -> Unit) {
+    closeTransaction()
+    db.rawQuery("""SELECT product.description, product.data AS pd, releases.data AS rd FROM product
+      LEFT JOIN releases ON product.package_name = releases.package_name""", null)
+      ?.use { it.asSequence().map {
+        val description = it.getString(0)
+        val product = Json.factory.createParser(it.getBlob(1)).use {
+          it.nextToken()
+          Product.deserialize(repositoryId, description, it)
+        }
+        val releases = it.getBlob(2)?.let { Json.factory.createParser(it).use {
+          it.nextToken()
+          it.collectNotNull(JsonToken.START_OBJECT, Release.Companion::deserialize)
+        } }.orEmpty()
+        product.copy(releases = releases)
+      }.windowed(windowSize, windowSize, true).forEach { products -> callback(products, it.count) } }
+  }
+
+  override fun close() {
+    db.use { closeTransaction() }
+  }
+}

src/main/kotlin/com/looker/droidify/index/IndexV1Parser.kt

@@ -0,0 +1,260 @@
+package com.looker.droidify.index
+
+import com.fasterxml.jackson.core.JsonParser
+import com.fasterxml.jackson.core.JsonToken
+import com.looker.droidify.entity.Product
+import com.looker.droidify.entity.Release
+import com.looker.droidify.utility.extension.android.*
+import com.looker.droidify.utility.extension.json.*
+import com.looker.droidify.utility.extension.text.*
+import java.io.InputStream
+
+object IndexV1Parser {
+  interface Callback {
+    fun onRepository(mirrors: List<String>, name: String, description: String, version: Int, timestamp: Long)
+    fun onProduct(product: Product)
+    fun onReleases(packageName: String, releases: List<Release>)
+  }
+
+  private class Screenshots(val phone: List<String>, val smallTablet: List<String>, val largeTablet: List<String>)
+  private class Localized(val name: String, val summary: String, val description: String,
+    val whatsNew: String, val metadataIcon: String, val screenshots: Screenshots?)
+
+  private fun <T> Map<String, Localized>.getAndCall(key: String, callback: (String, Localized) -> T?): T? {
+    return this[key]?.let { callback(key, it) }
+  }
+
+  private fun <T> Map<String, Localized>.find(callback: (String, Localized) -> T?): T? {
+    return getAndCall("en-US", callback) ?: getAndCall("en_US", callback) ?: getAndCall("en", callback)
+  }
+
+  private fun Map<String, Localized>.findString(fallback: String, callback: (Localized) -> String): String {
+    return (find { _, localized -> callback(localized).nullIfEmpty() } ?: fallback).trim()
+  }
+
+  fun parse(repositoryId: Long, inputStream: InputStream, callback: Callback) {
+    val jsonParser = Json.factory.createParser(inputStream)
+    if (jsonParser.nextToken() != JsonToken.START_OBJECT) {
+      jsonParser.illegal()
+    } else {
+      jsonParser.forEachKey {
+        when {
+          it.dictionary("repo") -> {
+            var address = ""
+            var mirrors = emptyList<String>()
+            var name = ""
+            var description = ""
+            var version = 0
+            var timestamp = 0L
+            forEachKey {
+              when {
+                it.string("address") -> address = valueAsString
+                it.array("mirrors") -> mirrors = collectDistinctNotEmptyStrings()
+                it.string("name") -> name = valueAsString
+                it.string("description") -> description = valueAsString
+                it.number("version") -> version = valueAsInt
+                it.number("timestamp") -> timestamp = valueAsLong
+                else -> skipChildren()
+              }
+            }
+            val realMirrors = ((if (address.isNotEmpty()) listOf(address) else emptyList()) + mirrors).distinct()
+            callback.onRepository(realMirrors, name, description, version, timestamp)
+          }
+          it.array("apps") -> forEach(JsonToken.START_OBJECT) {
+            val product = parseProduct(repositoryId)
+            callback.onProduct(product)
+          }
+          it.dictionary("packages") -> forEachKey {
+            if (it.token == JsonToken.START_ARRAY) {
+              val packageName = it.key
+              val releases = collectNotNull(JsonToken.START_OBJECT) { parseRelease() }
+              callback.onReleases(packageName, releases)
+            } else {
+              skipChildren()
+            }
+          }
+          else -> skipChildren()
+        }
+      }
+    }
+  }
+
+  private fun JsonParser.parseProduct(repositoryId: Long): Product {
+    var packageName = ""
+    var nameFallback = ""
+    var summaryFallback = ""
+    var descriptionFallback = ""
+    var icon = ""
+    var authorName = ""
+    var authorEmail = ""
+    var authorWeb = ""
+    var source = ""
+    var changelog = ""
+    var web = ""
+    var tracker = ""
+    var added = 0L
+    var updated = 0L
+    var suggestedVersionCode = 0L
+    var categories = emptyList<String>()
+    var antiFeatures = emptyList<String>()
+    val licenses = mutableListOf<String>()
+    val donates = mutableListOf<Product.Donate>()
+    val localizedMap = mutableMapOf<String, Localized>()
+    forEachKey {
+      when {
+        it.string("packageName") -> packageName = valueAsString
+        it.string("name") -> nameFallback = valueAsString
+        it.string("summary") -> summaryFallback = valueAsString
+        it.string("description") -> descriptionFallback = valueAsString
+        it.string("icon") -> icon = IndexHandler.validateIcon(valueAsString)
+        it.string("authorName") -> authorName = valueAsString
+        it.string("authorEmail") -> authorEmail = valueAsString
+        it.string("authorWebSite") -> authorWeb = valueAsString
+        it.string("sourceCode") -> source = valueAsString
+        it.string("changelog") -> changelog = valueAsString
+        it.string("webSite") -> web = valueAsString
+        it.string("issueTracker") -> tracker = valueAsString
+        it.number("added") -> added = valueAsLong
+        it.number("lastUpdated") -> updated = valueAsLong
+        it.string("suggestedVersionCode") -> suggestedVersionCode = valueAsString.toLongOrNull() ?: 0L
+        it.array("categories") -> categories = collectDistinctNotEmptyStrings()
+        it.array("antiFeatures") -> antiFeatures = collectDistinctNotEmptyStrings()
+        it.string("license") -> licenses += valueAsString.split(',').filter { it.isNotEmpty() }
+        it.string("donate") -> donates += Product.Donate.Regular(valueAsString)
+        it.string("bitcoin") -> donates += Product.Donate.Bitcoin(valueAsString)
+        it.string("flattrID") -> donates += Product.Donate.Flattr(valueAsString)
+        it.string("liberapayID") -> donates += Product.Donate.Liberapay(valueAsString)
+        it.string("openCollective") -> donates += Product.Donate.OpenCollective(valueAsString)
+        it.dictionary("localized") -> forEachKey {
+          if (it.token == JsonToken.START_OBJECT) {
+            val locale = it.key
+            var name = ""
+            var summary = ""
+            var description = ""
+            var whatsNew = ""
+            var metadataIcon = ""
+            var phone = emptyList<String>()
+            var smallTablet = emptyList<String>()
+            var largeTablet = emptyList<String>()
+            forEachKey {
+              when {
+                it.string("name") -> name = valueAsString
+                it.string("summary") -> summary = valueAsString
+                it.string("description") -> description = valueAsString
+                it.string("whatsNew") -> whatsNew = valueAsString
+                it.string("icon") -> metadataIcon = valueAsString
+                it.array("phoneScreenshots") -> phone = collectDistinctNotEmptyStrings()
+                it.array("sevenInchScreenshots") -> smallTablet = collectDistinctNotEmptyStrings()
+                it.array("tenInchScreenshots") -> largeTablet = collectDistinctNotEmptyStrings()
+                else -> skipChildren()
+              }
+            }
+            val screenshots = if (sequenceOf(phone, smallTablet, largeTablet).any { it.isNotEmpty() })
+              Screenshots(phone, smallTablet, largeTablet) else null
+            localizedMap[locale] = Localized(name, summary, description, whatsNew,
+              metadataIcon.nullIfEmpty()?.let { "$locale/$it" }.orEmpty(), screenshots)
+          } else {
+            skipChildren()
+          }
+        }
+        else -> skipChildren()
+      }
+    }
+    val name = localizedMap.findString(nameFallback) { it.name }
+    val summary = localizedMap.findString(summaryFallback) { it.summary }
+    val description = localizedMap.findString(descriptionFallback) { it.description }.replace("\n", "<br/>")
+    val whatsNew = localizedMap.findString("") { it.whatsNew }.replace("\n", "<br/>")
+    val metadataIcon = localizedMap.findString("") { it.metadataIcon }
+    val screenshotPairs = localizedMap.find { key, localized -> localized.screenshots?.let { Pair(key, it) } }
+    val screenshots = screenshotPairs
+      ?.let { (key, screenshots) -> screenshots.phone.asSequence()
+        .map { Product.Screenshot(key, Product.Screenshot.Type.PHONE, it) } +
+        screenshots.smallTablet.asSequence()
+          .map { Product.Screenshot(key, Product.Screenshot.Type.SMALL_TABLET, it) } +
+        screenshots.largeTablet.asSequence()
+          .map { Product.Screenshot(key, Product.Screenshot.Type.LARGE_TABLET, it) } }
+      .orEmpty().toList()
+    return Product(repositoryId, packageName, name, summary, description, whatsNew, icon, metadataIcon,
+      Product.Author(authorName, authorEmail, authorWeb), source, changelog, web, tracker, added, updated,
+      suggestedVersionCode, categories, antiFeatures, licenses,
+      donates.sortedWith(IndexHandler.DonateComparator), screenshots, emptyList())
+  }
+
+  private fun JsonParser.parseRelease(): Release {
+    var version = ""
+    var versionCode = 0L
+    var added = 0L
+    var size = 0L
+    var minSdkVersion = 0
+    var targetSdkVersion = 0
+    var maxSdkVersion = 0
+    var source = ""
+    var release = ""
+    var hash = ""
+    var hashTypeCandidate = ""
+    var signature = ""
+    var obbMain = ""
+    var obbMainHash = ""
+    var obbPatch = ""
+    var obbPatchHash = ""
+    val permissions = linkedSetOf<String>()
+    var features = emptyList<String>()
+    var platforms = emptyList<String>()
+    forEachKey {
+      when {
+        it.string("versionName") -> version = valueAsString
+        it.number("versionCode") -> versionCode = valueAsLong
+        it.number("added") -> added = valueAsLong
+        it.number("size") -> size = valueAsLong
+        it.number("minSdkVersion") -> minSdkVersion = valueAsInt
+        it.number("targetSdkVersion") -> targetSdkVersion = valueAsInt
+        it.number("maxSdkVersion") -> maxSdkVersion = valueAsInt
+        it.string("srcname") -> source = valueAsString
+        it.string("apkName") -> release = valueAsString
+        it.string("hash") -> hash = valueAsString
+        it.string("hashType") -> hashTypeCandidate = valueAsString
+        it.string("sig") -> signature = valueAsString
+        it.string("obbMainFile") -> obbMain = valueAsString
+        it.string("obbMainFileSha256") -> obbMainHash = valueAsString
+        it.string("obbPatchFile") -> obbPatch = valueAsString
+        it.string("obbPatchFileSha256") -> obbPatchHash = valueAsString
+        it.array("uses-permission") -> collectPermissions(permissions, 0)
+        it.array("uses-permission-sdk-23") -> collectPermissions(permissions, 23)
+        it.array("features") -> features = collectDistinctNotEmptyStrings()
+        it.array("nativecode") -> platforms = collectDistinctNotEmptyStrings()
+        else -> skipChildren()
+      }
+    }
+    val hashType = if (hash.isNotEmpty() && hashTypeCandidate.isEmpty()) "sha256" else hashTypeCandidate
+    val obbMainHashType = if (obbMainHash.isNotEmpty()) "sha256" else ""
+    val obbPatchHashType = if (obbPatchHash.isNotEmpty()) "sha256" else ""
+    return Release(false, version, versionCode, added, size,
+      minSdkVersion, targetSdkVersion, maxSdkVersion, source, release, hash, hashType, signature,
+      obbMain, obbMainHash, obbMainHashType, obbPatch, obbPatchHash, obbPatchHashType,
+      permissions.toList(), features, platforms, emptyList())
+  }
+
+  private fun JsonParser.collectPermissions(permissions: LinkedHashSet<String>, minSdk: Int) {
+    forEach(JsonToken.START_ARRAY) {
+      val firstToken = nextToken()
+      val permission = if (firstToken == JsonToken.VALUE_STRING) valueAsString else ""
+      if (firstToken != JsonToken.END_ARRAY) {
+        val secondToken = nextToken()
+        val maxSdk = if (secondToken == JsonToken.VALUE_NUMBER_INT) valueAsInt else 0
+        if (permission.isNotEmpty() && Android.sdk >= minSdk && (maxSdk <= 0 || Android.sdk <= maxSdk)) {
+          permissions.add(permission)
+        }
+        if (secondToken != JsonToken.END_ARRAY) {
+          while (true) {
+            val token = nextToken()
+            if (token == JsonToken.END_ARRAY) {
+              break
+            } else if (token.isStructStart) {
+              skipChildren()
+            }
+          }
+        }
+      }
+    }
+  }
+}

src/main/kotlin/com/looker/droidify/index/RepositoryUpdater.kt

@@ -0,0 +1,345 @@
+package com.looker.droidify.index
+
+import android.content.Context
+import android.net.Uri
+import io.reactivex.rxjava3.core.Observable
+import io.reactivex.rxjava3.core.Single
+import io.reactivex.rxjava3.schedulers.Schedulers
+import com.looker.droidify.content.Cache
+import com.looker.droidify.database.Database
+import com.looker.droidify.entity.Product
+import com.looker.droidify.entity.Release
+import com.looker.droidify.entity.Repository
+import com.looker.droidify.network.Downloader
+import com.looker.droidify.utility.ProgressInputStream
+import com.looker.droidify.utility.RxUtils
+import com.looker.droidify.utility.Utils
+import com.looker.droidify.utility.extension.android.*
+import com.looker.droidify.utility.extension.text.*
+import org.xml.sax.InputSource
+import java.io.File
+import java.security.cert.X509Certificate
+import java.util.Locale
+import java.util.jar.JarEntry
+import java.util.jar.JarFile
+import javax.xml.parsers.SAXParserFactory
+
+object RepositoryUpdater {
+  enum class Stage {
+    DOWNLOAD, PROCESS, MERGE, COMMIT
+  }
+
+  private enum class IndexType(val jarName: String, val contentName: String, val certificateFromIndex: Boolean) {
+    INDEX("index.jar", "index.xml", true),
+    INDEX_V1("index-v1.jar", "index-v1.json", false)
+  }
+
+  enum class ErrorType {
+    NETWORK, HTTP, VALIDATION, PARSING
+  }
+
+  class UpdateException: Exception {
+    val errorType: ErrorType
+
+    constructor(errorType: ErrorType, message: String): super(message) {
+      this.errorType = errorType
+    }
+
+    constructor(errorType: ErrorType, message: String, cause: Exception): super(message, cause) {
+      this.errorType = errorType
+    }
+  }
+
+  private lateinit var context: Context
+  private val updaterLock = Any()
+  private val cleanupLock = Any()
+
+  fun init(context: Context) {
+    this.context = context
+
+    var lastDisabled = setOf<Long>()
+    Observable.just(Unit)
+      .concatWith(Database.observable(Database.Subject.Repositories))
+      .observeOn(Schedulers.io())
+      .flatMapSingle { RxUtils.querySingle { Database.RepositoryAdapter.getAllDisabledDeleted(it) } }
+      .forEach {
+        val newDisabled = it.asSequence().filter { !it.second }.map { it.first }.toSet()
+        val disabled = newDisabled - lastDisabled
+        lastDisabled = newDisabled
+        val deleted = it.asSequence().filter { it.second }.map { it.first }.toSet()
+        if (disabled.isNotEmpty() || deleted.isNotEmpty()) {
+          val pairs = (disabled.asSequence().map { Pair(it, false) } +
+            deleted.asSequence().map { Pair(it, true) }).toSet()
+          synchronized(cleanupLock) { Database.RepositoryAdapter.cleanup(pairs) }
+        }
+      }
+  }
+
+  fun await() {
+    synchronized(updaterLock) { }
+  }
+
+  fun update(repository: Repository, unstable: Boolean,
+    callback: (Stage, Long, Long?) -> Unit): Single<Boolean> {
+    return update(repository, listOf(IndexType.INDEX_V1, IndexType.INDEX), unstable, callback)
+  }
+
+  private fun update(repository: Repository, indexTypes: List<IndexType>, unstable: Boolean,
+    callback: (Stage, Long, Long?) -> Unit): Single<Boolean> {
+    val indexType = indexTypes[0]
+    return downloadIndex(repository, indexType, callback)
+      .flatMap { (result, file) ->
+        when {
+          result.isNotChanged -> {
+            file.delete()
+            Single.just(false)
+          }
+          !result.success -> {
+            file.delete()
+            if (result.code == 404 && indexTypes.isNotEmpty()) {
+              update(repository, indexTypes.subList(1, indexTypes.size), unstable, callback)
+            } else {
+              Single.error(UpdateException(ErrorType.HTTP, "Invalid response: HTTP ${result.code}"))
+            }
+          }
+          else -> {
+            RxUtils.managedSingle { processFile(repository, indexType, unstable,
+              file, result.lastModified, result.entityTag, callback) }
+          }
+        }
+      }
+  }
+
+  private fun downloadIndex(repository: Repository, indexType: IndexType,
+    callback: (Stage, Long, Long?) -> Unit): Single<Pair<Downloader.Result, File>> {
+    return Single.just(Unit)
+      .map { Cache.getTemporaryFile(context) }
+      .flatMap { file -> Downloader
+        .download(Uri.parse(repository.address).buildUpon()
+          .appendPath(indexType.jarName).build().toString(), file, repository.lastModified, repository.entityTag,
+          repository.authentication) { read, total -> callback(Stage.DOWNLOAD, read, total) }
+        .subscribeOn(Schedulers.io())
+        .map { Pair(it, file) }
+        .onErrorResumeNext {
+          file.delete()
+          when (it) {
+            is InterruptedException, is RuntimeException, is Error -> Single.error(it)
+            is Exception -> Single.error(UpdateException(ErrorType.NETWORK, "Network error", it))
+            else -> Single.error(it)
+          }
+        } }
+  }
+
+  private fun processFile(repository: Repository, indexType: IndexType, unstable: Boolean,
+    file: File, lastModified: String, entityTag: String, callback: (Stage, Long, Long?) -> Unit): Boolean {
+    var rollback = true
+    return synchronized(updaterLock) {
+      try {
+        val jarFile = JarFile(file, true)
+        val indexEntry = jarFile.getEntry(indexType.contentName) as JarEntry
+        val total = indexEntry.size
+        Database.UpdaterAdapter.createTemporaryTable()
+        val features = context.packageManager.systemAvailableFeatures
+          .asSequence().map { it.name }.toSet() + setOf("android.hardware.touchscreen")
+
+        val (changedRepository, certificateFromIndex) = when (indexType) {
+          IndexType.INDEX -> {
+            val factory = SAXParserFactory.newInstance()
+            factory.isNamespaceAware = true
+            val parser = factory.newSAXParser()
+            val reader = parser.xmlReader
+            var changedRepository: Repository? = null
+            var certificateFromIndex: String? = null
+            val products = mutableListOf<Product>()
+
+            reader.contentHandler = IndexHandler(repository.id, object: IndexHandler.Callback {
+              override fun onRepository(mirrors: List<String>, name: String, description: String,
+                certificate: String, version: Int, timestamp: Long) {
+                changedRepository = repository.update(mirrors, name, description, version,
+                  lastModified, entityTag, timestamp)
+                certificateFromIndex = certificate.toLowerCase(Locale.US)
+              }
+
+              override fun onProduct(product: Product) {
+                if (Thread.interrupted()) {
+                  throw InterruptedException()
+                }
+                products += transformProduct(product, features, unstable)
+                if (products.size >= 50) {
+                  Database.UpdaterAdapter.putTemporary(products)
+                  products.clear()
+                }
+              }
+            })
+
+            ProgressInputStream(jarFile.getInputStream(indexEntry)) { callback(Stage.PROCESS, it, total) }
+              .use { reader.parse(InputSource(it)) }
+            if (Thread.interrupted()) {
+              throw InterruptedException()
+            }
+            if (products.isNotEmpty()) {
+              Database.UpdaterAdapter.putTemporary(products)
+              products.clear()
+            }
+            Pair(changedRepository, certificateFromIndex)
+          }
+          IndexType.INDEX_V1 -> {
+            var changedRepository: Repository? = null
+
+            val mergerFile = Cache.getTemporaryFile(context)
+            try {
+              val unmergedProducts = mutableListOf<Product>()
+              val unmergedReleases = mutableListOf<Pair<String, List<Release>>>()
+              IndexMerger(mergerFile).use { indexMerger ->
+                ProgressInputStream(jarFile.getInputStream(indexEntry)) { callback(Stage.PROCESS, it, total) }.use {
+                  IndexV1Parser.parse(repository.id, it, object: IndexV1Parser.Callback {
+                    override fun onRepository(mirrors: List<String>, name: String, description: String,
+                      version: Int, timestamp: Long) {
+                      changedRepository = repository.update(mirrors, name, description, version,
+                        lastModified, entityTag, timestamp)
+                    }
+
+                    override fun onProduct(product: Product) {
+                      if (Thread.interrupted()) {
+                        throw InterruptedException()
+                      }
+                      unmergedProducts += product
+                      if (unmergedProducts.size >= 50) {
+                        indexMerger.addProducts(unmergedProducts)
+                        unmergedProducts.clear()
+                      }
+                    }
+
+                    override fun onReleases(packageName: String, releases: List<Release>) {
+                      if (Thread.interrupted()) {
+                        throw InterruptedException()
+                      }
+                      unmergedReleases += Pair(packageName, releases)
+                      if (unmergedReleases.size >= 50) {
+                        indexMerger.addReleases(unmergedReleases)
+                        unmergedReleases.clear()
+                      }
+                    }
+                  })
+
+                  if (Thread.interrupted()) {
+                    throw InterruptedException()
+                  }
+                  if (unmergedProducts.isNotEmpty()) {
+                    indexMerger.addProducts(unmergedProducts)
+                    unmergedProducts.clear()
+                  }
+                  if (unmergedReleases.isNotEmpty()) {
+                    indexMerger.addReleases(unmergedReleases)
+                    unmergedReleases.clear()
+                  }
+                  var progress = 0
+                  indexMerger.forEach(repository.id, 50) { products, totalCount ->
+                    if (Thread.interrupted()) {
+                      throw InterruptedException()
+                    }
+                    progress += products.size
+                    callback(Stage.MERGE, progress.toLong(), totalCount.toLong())
+                    Database.UpdaterAdapter.putTemporary(products
+                      .map { transformProduct(it, features, unstable) })
+                  }
+                }
+              }
+            } finally {
+              mergerFile.delete()
+            }
+            Pair(changedRepository, null)
+          }
+        }
+
+        val workRepository = changedRepository ?: repository
+        if (workRepository.timestamp < repository.timestamp) {
+          throw UpdateException(ErrorType.VALIDATION, "New index is older than current index: " +
+            "${workRepository.timestamp} < ${repository.timestamp}")
+        } else {
+          val fingerprint = run {
+            val certificateFromJar = run {
+              val codeSigners = indexEntry.codeSigners
+              if (codeSigners == null || codeSigners.size != 1) {
+                throw UpdateException(ErrorType.VALIDATION, "index.jar must be signed by a single code signer")
+              } else {
+                val certificates = codeSigners[0].signerCertPath?.certificates.orEmpty()
+                if (certificates.size != 1) {
+                  throw UpdateException(ErrorType.VALIDATION, "index.jar code signer should have only one certificate")
+                } else {
+                  certificates[0] as X509Certificate
+                }
+              }
+            }
+            val fingerprintFromJar = Utils.calculateFingerprint(certificateFromJar)
+            if (indexType.certificateFromIndex) {
+              val fingerprintFromIndex = certificateFromIndex?.unhex()?.let(Utils::calculateFingerprint)
+              if (fingerprintFromIndex == null || fingerprintFromJar != fingerprintFromIndex) {
+                throw UpdateException(ErrorType.VALIDATION, "index.xml contains invalid public key")
+              }
+              fingerprintFromIndex
+            } else {
+              fingerprintFromJar
+            }
+          }
+
+          val commitRepository = if (workRepository.fingerprint != fingerprint) {
+            if (workRepository.fingerprint.isEmpty()) {
+              workRepository.copy(fingerprint = fingerprint)
+            } else {
+              throw UpdateException(ErrorType.VALIDATION, "Certificate fingerprints do not match")
+            }
+          } else {
+            workRepository
+          }
+          if (Thread.interrupted()) {
+            throw InterruptedException()
+          }
+          callback(Stage.COMMIT, 0, null)
+          synchronized(cleanupLock) { Database.UpdaterAdapter.finishTemporary(commitRepository, true) }
+          rollback = false
+          true
+        }
+      } catch (e: Exception) {
+        throw when (e) {
+          is UpdateException, is InterruptedException -> e
+          else -> UpdateException(ErrorType.PARSING, "Error parsing index", e)
+        }
+      } finally {
+        file.delete()
+        if (rollback) {
+          Database.UpdaterAdapter.finishTemporary(repository, false)
+        }
+      }
+    }
+  }
+
+  private fun transformProduct(product: Product, features: Set<String>, unstable: Boolean): Product {
+    val releasePairs = product.releases.distinctBy { it.identifier }.sortedByDescending { it.versionCode }.map {
+      val incompatibilities = mutableListOf<Release.Incompatibility>()
+      if (it.minSdkVersion > 0 && Android.sdk < it.minSdkVersion) {
+        incompatibilities += Release.Incompatibility.MinSdk
+      }
+      if (it.maxSdkVersion > 0 && Android.sdk > it.maxSdkVersion) {
+        incompatibilities += Release.Incompatibility.MaxSdk
+      }
+      if (it.platforms.isNotEmpty() && it.platforms.intersect(Android.platforms).isEmpty()) {
+        incompatibilities += Release.Incompatibility.Platform
+      }
+      incompatibilities += (it.features - features).sorted().map { Release.Incompatibility.Feature(it) }
+      Pair(it, incompatibilities as List<Release.Incompatibility>)
+    }.toMutableList()
+
+    val predicate: (Release) -> Boolean = { unstable || product.suggestedVersionCode <= 0 ||
+      it.versionCode <= product.suggestedVersionCode }
+    val firstCompatibleReleaseIndex = releasePairs.indexOfFirst { it.second.isEmpty() && predicate(it.first) }
+    val firstReleaseIndex = if (firstCompatibleReleaseIndex >= 0) firstCompatibleReleaseIndex else
+      releasePairs.indexOfFirst { predicate(it.first) }
+    val firstSelected = if (firstReleaseIndex >= 0) releasePairs[firstReleaseIndex] else null
+
+    val releases = releasePairs.map { (release, incompatibilities) -> release
+      .copy(incompatibilities = incompatibilities, selected = firstSelected
+        ?.let { it.first.versionCode == release.versionCode && it.second == incompatibilities } == true) }
+    return product.copy(releases = releases)
+  }
+}

src/main/kotlin/com/looker/droidify/network/Downloader.kt

@@ -0,0 +1,114 @@
+package com.looker.droidify.network
+
+import io.reactivex.rxjava3.core.Single
+import io.reactivex.rxjava3.schedulers.Schedulers
+import com.looker.droidify.utility.ProgressInputStream
+import com.looker.droidify.utility.RxUtils
+import okhttp3.Cache
+import okhttp3.Call
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import java.io.File
+import java.io.FileOutputStream
+import java.net.InetSocketAddress
+import java.net.Proxy
+import java.util.concurrent.TimeUnit
+
+object Downloader {
+  private data class ClientConfiguration(val cache: Cache?, val onion: Boolean)
+
+  private val clients = mutableMapOf<ClientConfiguration, OkHttpClient>()
+  private val onionProxy = Proxy(Proxy.Type.SOCKS, InetSocketAddress("127.0.0.1", 9050))
+
+  var proxy: Proxy? = null
+    set(value) {
+      if (field != value) {
+        synchronized(clients) {
+          field = value
+          clients.keys.removeAll { !it.onion }
+        }
+      }
+    }
+
+  private fun createClient(proxy: Proxy?, cache: Cache?): OkHttpClient {
+    return OkHttpClient.Builder()
+      .connectTimeout(30L, TimeUnit.SECONDS)
+      .readTimeout(15L, TimeUnit.SECONDS)
+      .writeTimeout(15L, TimeUnit.SECONDS)
+      .proxy(proxy).cache(cache).build()
+  }
+
+  class Result(val code: Int, val lastModified: String, val entityTag: String) {
+    val success: Boolean
+      get() = code == 200 || code == 206
+
+    val isNotChanged: Boolean
+      get() = code == 304
+  }
+
+  fun createCall(request: Request.Builder, authentication: String, cache: Cache?): Call {
+    val oldRequest = request.build()
+    val newRequest = if (authentication.isNotEmpty()) {
+      request.addHeader("Authorization", authentication).build()
+    } else {
+      request.build()
+    }
+    val onion = oldRequest.url.host.endsWith(".onion")
+    val client = synchronized(clients) {
+      val proxy = if (onion) onionProxy else proxy
+      val clientConfiguration = ClientConfiguration(cache, onion)
+      clients[clientConfiguration] ?: run {
+        val client = createClient(proxy, cache)
+        clients[clientConfiguration] = client
+        client
+      }
+    }
+    return client.newCall(newRequest)
+  }
+
+  fun download(url: String, target: File, lastModified: String, entityTag: String, authentication: String,
+    callback: ((read: Long, total: Long?) -> Unit)?): Single<Result> {
+    val start = if (target.exists()) target.length().let { if (it > 0L) it else null } else null
+    val request = Request.Builder().url(url)
+      .apply {
+        if (entityTag.isNotEmpty()) {
+          addHeader("If-None-Match", entityTag)
+        } else if (lastModified.isNotEmpty()) {
+          addHeader("If-Modified-Since", lastModified)
+        }
+        if (start != null) {
+          addHeader("Range", "bytes=$start-")
+        }
+      }
+
+    return RxUtils
+      .callSingle { createCall(request, authentication, null) }
+      .subscribeOn(Schedulers.io())
+      .flatMap { result -> RxUtils
+        .managedSingle { result.use {
+          if (result.code == 304) {
+            Result(it.code, lastModified, entityTag)
+          } else {
+            val body = it.body!!
+            val append = start != null && it.header("Content-Range") != null
+            val progressStart = if (append && start != null) start else 0L
+            val progressTotal = body.contentLength().let { if (it >= 0L) it else null }
+              ?.let { progressStart + it }
+            val inputStream = ProgressInputStream(body.byteStream()) {
+              if (Thread.interrupted()) {
+                throw InterruptedException()
+              }
+              callback?.invoke(progressStart + it, progressTotal)
+            }
+            inputStream.use { input ->
+              val outputStream = if (append) FileOutputStream(target, true) else FileOutputStream(target)
+              outputStream.use { output ->
+                input.copyTo(output)
+                output.fd.sync()
+              }
+            }
+            Result(it.code, it.header("Last-Modified").orEmpty(), it.header("ETag").orEmpty())
+          }
+        } } }
+  }
+}

src/main/kotlin/com/looker/droidify/network/PicassoDownloader.kt

@@ -0,0 +1,118 @@
+package com.looker.droidify.network
+
+import android.content.Context
+import android.net.Uri
+import android.view.View
+import com.looker.droidify.entity.Product
+import com.looker.droidify.entity.Repository
+import com.looker.droidify.utility.extension.text.*
+import okhttp3.Cache
+import okhttp3.Call
+import okhttp3.HttpUrl.Companion.toHttpUrl
+import java.io.File
+import kotlin.math.*
+
+object PicassoDownloader {
+  private const val HOST_ICON = "icon"
+  private const val HOST_SCREENSHOT = "screenshot"
+  private const val QUERY_ADDRESS = "address"
+  private const val QUERY_AUTHENTICATION = "authentication"
+  private const val QUERY_PACKAGE_NAME = "packageName"
+  private const val QUERY_ICON = "icon"
+  private const val QUERY_METADATA_ICON = "metadataIcon"
+  private const val QUERY_LOCALE = "locale"
+  private const val QUERY_DEVICE = "device"
+  private const val QUERY_SCREENSHOT = "screenshot"
+  private const val QUERY_DPI = "dpi"
+
+  private val supportedDpis = listOf(120, 160, 240, 320, 480, 640)
+
+  class Factory(cacheDir: File): Call.Factory {
+    private val cache = Cache(cacheDir, 50_000_000L)
+
+    override fun newCall(request: okhttp3.Request): Call {
+      return when (request.url.host) {
+        HOST_ICON -> {
+          val address = request.url.queryParameter(QUERY_ADDRESS)?.nullIfEmpty()
+          val authentication = request.url.queryParameter(QUERY_AUTHENTICATION)
+          val path = run {
+            val packageName = request.url.queryParameter(QUERY_PACKAGE_NAME)?.nullIfEmpty()
+            val icon = request.url.queryParameter(QUERY_ICON)?.nullIfEmpty()
+            val metadataIcon = request.url.queryParameter(QUERY_METADATA_ICON)?.nullIfEmpty()
+            val dpi = request.url.queryParameter(QUERY_DPI)?.nullIfEmpty()
+            when {
+              icon != null -> "${if (dpi != null) "icons-$dpi" else "icons"}/$icon"
+              packageName != null && metadataIcon != null -> "$packageName/$metadataIcon"
+              else -> null
+            }
+          }
+          if (address == null || path == null) {
+            Downloader.createCall(request.newBuilder(), "", null)
+          } else {
+            Downloader.createCall(request.newBuilder().url(address.toHttpUrl()
+              .newBuilder().addPathSegments(path).build()), authentication.orEmpty(), cache)
+          }
+        }
+        HOST_SCREENSHOT -> {
+          val address = request.url.queryParameter(QUERY_ADDRESS)
+          val authentication = request.url.queryParameter(QUERY_AUTHENTICATION)
+          val packageName = request.url.queryParameter(QUERY_PACKAGE_NAME)
+          val locale = request.url.queryParameter(QUERY_LOCALE)
+          val device = request.url.queryParameter(QUERY_DEVICE)
+          val screenshot = request.url.queryParameter(QUERY_SCREENSHOT)
+          if (screenshot.isNullOrEmpty() || address.isNullOrEmpty()) {
+            Downloader.createCall(request.newBuilder(), "", null)
+          } else {
+            Downloader.createCall(request.newBuilder().url(address.toHttpUrl()
+              .newBuilder().addPathSegment(packageName.orEmpty()).addPathSegment(locale.orEmpty())
+              .addPathSegment(device.orEmpty()).addPathSegment(screenshot.orEmpty()).build()),
+              authentication.orEmpty(), cache)
+          }
+        }
+        else -> {
+          Downloader.createCall(request.newBuilder(), "", null)
+        }
+      }
+    }
+  }
+
+  fun createScreenshotUri(repository: Repository, packageName: String, screenshot: Product.Screenshot): Uri {
+    return Uri.Builder().scheme("https").authority(HOST_SCREENSHOT)
+      .appendQueryParameter(QUERY_ADDRESS, repository.address)
+      .appendQueryParameter(QUERY_AUTHENTICATION, repository.authentication)
+      .appendQueryParameter(QUERY_PACKAGE_NAME, packageName)
+      .appendQueryParameter(QUERY_LOCALE, screenshot.locale)
+      .appendQueryParameter(QUERY_DEVICE, when (screenshot.type) {
+        Product.Screenshot.Type.PHONE -> "phoneScreenshots"
+        Product.Screenshot.Type.SMALL_TABLET -> "sevenInchScreenshots"
+        Product.Screenshot.Type.LARGE_TABLET -> "tenInchScreenshots"
+      })
+      .appendQueryParameter(QUERY_SCREENSHOT, screenshot.path)
+      .build()
+  }
+
+  fun createIconUri(view: View, packageName: String, icon: String, metadataIcon: String, repository: Repository): Uri {
+    val size = (view.layoutParams.let { min(it.width, it.height) } /
+      view.resources.displayMetrics.density).roundToInt()
+    return createIconUri(view.context, packageName, icon, metadataIcon, size, repository)
+  }
+
+  private fun createIconUri(context: Context, packageName: String, icon: String, metadataIcon: String,
+    targetSizeDp: Int, repository: Repository): Uri {
+    return Uri.Builder().scheme("https").authority(HOST_ICON)
+      .appendQueryParameter(QUERY_ADDRESS, repository.address)
+      .appendQueryParameter(QUERY_AUTHENTICATION, repository.authentication)
+      .appendQueryParameter(QUERY_PACKAGE_NAME, packageName)
+      .appendQueryParameter(QUERY_ICON, icon)
+      .appendQueryParameter(QUERY_METADATA_ICON, metadataIcon)
+      .apply {
+        if (repository.version >= 11) {
+          val displayDpi = context.resources.displayMetrics.densityDpi
+          val requiredDpi = displayDpi * targetSizeDp / 48
+          val iconDpi = supportedDpis.find { it >= requiredDpi } ?: supportedDpis.last()
+          appendQueryParameter(QUERY_DPI, iconDpi.toString())
+        }
+      }
+      .build()
+  }
+}

src/main/kotlin/com/looker/droidify/screen/EditRepositoryFragment.kt

@@ -0,0 +1,484 @@
+package com.looker.droidify.screen
+
+import android.app.AlertDialog
+import android.content.ClipboardManager
+import android.content.Context
+import android.graphics.PorterDuff
+import android.graphics.PorterDuffColorFilter
+import android.net.Uri
+import android.os.Bundle
+import android.text.Editable
+import android.text.Selection
+import android.text.TextWatcher
+import android.util.Base64
+import android.view.LayoutInflater
+import android.view.MenuItem
+import android.view.View
+import android.view.ViewGroup
+import android.widget.EditText
+import android.widget.FrameLayout
+import android.widget.TextView
+import android.widget.Toolbar
+import androidx.fragment.app.DialogFragment
+import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers
+import io.reactivex.rxjava3.core.Observable
+import io.reactivex.rxjava3.core.Single
+import io.reactivex.rxjava3.disposables.Disposable
+import io.reactivex.rxjava3.schedulers.Schedulers
+import com.looker.droidify.R
+import com.looker.droidify.database.Database
+import com.looker.droidify.entity.Repository
+import com.looker.droidify.network.Downloader
+import com.looker.droidify.service.Connection
+import com.looker.droidify.service.SyncService
+import com.looker.droidify.utility.RxUtils
+import com.looker.droidify.utility.Utils
+import com.looker.droidify.utility.extension.resources.*
+import com.looker.droidify.utility.extension.text.*
+import okhttp3.HttpUrl.Companion.toHttpUrl
+import okhttp3.Request
+import java.net.URI
+import java.net.URL
+import java.nio.charset.Charset
+import java.util.Locale
+import kotlin.math.*
+
+class EditRepositoryFragment(): ScreenFragment() {
+  companion object {
+    private const val EXTRA_REPOSITORY_ID = "repositoryId"
+
+    private val checkPaths = listOf("", "fdroid/repo", "repo")
+  }
+
+  constructor(repositoryId: Long?): this() {
+    arguments = Bundle().apply {
+      repositoryId?.let { putLong(EXTRA_REPOSITORY_ID, it) }
+    }
+  }
+
+  private class Layout(view: View) {
+    val address = view.findViewById<EditText>(R.id.address)!!
+    val addressMirror = view.findViewById<View>(R.id.address_mirror)!!
+    val addressError = view.findViewById<TextView>(R.id.address_error)!!
+    val fingerprint = view.findViewById<EditText>(R.id.fingerprint)!!
+    val fingerprintError = view.findViewById<TextView>(R.id.fingerprint_error)!!
+    val username = view.findViewById<EditText>(R.id.username)!!
+    val usernameError = view.findViewById<TextView>(R.id.username_error)!!
+    val password = view.findViewById<EditText>(R.id.password)!!
+    val passwordError = view.findViewById<TextView>(R.id.password_error)!!
+    val overlay = view.findViewById<View>(R.id.overlay)!!
+    val skip = view.findViewById<View>(R.id.skip)!!
+  }
+
+  private val repositoryId: Long?
+    get() = requireArguments().let { if (it.containsKey(EXTRA_REPOSITORY_ID))
+      it.getLong(EXTRA_REPOSITORY_ID) else null }
+
+  private lateinit var errorColorFilter: PorterDuffColorFilter
+
+  private var saveMenuItem: MenuItem? = null
+  private var layout: Layout? = null
+
+  private val syncConnection = Connection(SyncService::class.java)
+  private var repositoriesDisposable: Disposable? = null
+  private var checkDisposable: Disposable? = null
+
+  private var takenAddresses = emptySet<String>()
+
+  override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View {
+    return inflater.inflate(R.layout.fragment, container, false)
+  }
+
+  override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
+    super.onViewCreated(view, savedInstanceState)
+
+    syncConnection.bind(requireContext())
+
+    val toolbar = view.findViewById<Toolbar>(R.id.toolbar)!!
+    screenActivity.onToolbarCreated(toolbar)
+    if (repositoryId != null) {
+      toolbar.setTitle(R.string.edit_repository)
+    } else {
+      toolbar.setTitle(R.string.add_repository)
+    }
+
+    toolbar.menu.apply {
+      saveMenuItem = add(R.string.save)
+        .setIcon(Utils.getToolbarIcon(toolbar.context, R.drawable.ic_save))
+        .setEnabled(false)
+        .setShowAsActionFlags(MenuItem.SHOW_AS_ACTION_ALWAYS)
+        .setOnMenuItemClickListener {
+          onSaveRepositoryClick(true)
+          true
+        }
+    }
+
+    val content = view.findViewById<FrameLayout>(R.id.fragment_content)!!
+    errorColorFilter = PorterDuffColorFilter(content.context
+      .getColorFromAttr(R.attr.colorError).defaultColor, PorterDuff.Mode.SRC_IN)
+
+    content.addView(content.inflate(R.layout.edit_repository))
+    val layout = Layout(content)
+    this.layout = layout
+
+    layout.fingerprint.hint = generateSequence { "FF" }.take(32).joinToString(separator = " ")
+    layout.fingerprint.addTextChangedListener(object: TextWatcher {
+      override fun beforeTextChanged(s: CharSequence, start: Int, count: Int, after: Int) = Unit
+      override fun onTextChanged(s: CharSequence, start: Int, count: Int, after: Int) = Unit
+
+      private val validChar: (Char) -> Boolean = { it in '0' .. '9' || it in 'a' .. 'f' || it in 'A' .. 'F' }
+
+      private fun logicalPosition(s: String, position: Int): Int {
+        return if (position > 0) s.asSequence().take(position).count(validChar) else position
+      }
+
+      private fun realPosition(s: String, position: Int): Int {
+        return if (position > 0) {
+          var left = position
+          val index = s.indexOfFirst {
+            validChar(it) && run {
+              left -= 1
+              left <= 0
+            }
+          }
+          if (index >= 0) min(index + 1, s.length) else s.length
+        } else {
+          position
+        }
+      }
+
+      override fun afterTextChanged(s: Editable) {
+        val inputString = s.toString()
+        val outputString = inputString.toUpperCase(Locale.US)
+          .filter(validChar).windowed(2, 2, true).take(32).joinToString(separator = " ")
+        if (inputString != outputString) {
+          val inputStart = logicalPosition(inputString, Selection.getSelectionStart(s))
+          val inputEnd = logicalPosition(inputString, Selection.getSelectionEnd(s))
+          s.replace(0, s.length, outputString)
+          Selection.setSelection(s, realPosition(outputString, inputStart), realPosition(outputString, inputEnd))
+        }
+      }
+    })
+
+    if (savedInstanceState == null) {
+      val repository = repositoryId?.let(Database.RepositoryAdapter::get)
+      if (repository == null) {
+        val clipboardManager = requireContext().getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager
+        val text = clipboardManager.primaryClip
+          ?.let { if (it.itemCount > 0) it else null }
+          ?.getItemAt(0)?.text?.toString().orEmpty()
+        val (addressText, fingerprintText) = try {
+          val uri = Uri.parse(URL(text).toString())
+          val fingerprintText = uri.getQueryParameter("fingerprint")?.nullIfEmpty()
+            ?: uri.getQueryParameter("FINGERPRINT")?.nullIfEmpty()
+          Pair(uri.buildUpon().path(uri.path?.pathCropped)
+            .query(null).fragment(null).build().toString(), fingerprintText)
+        } catch (e: Exception) {
+          Pair(null, null)
+        }
+        layout.address.setText(addressText?.nullIfEmpty() ?: layout.address.hint)
+        layout.fingerprint.setText(fingerprintText)
+      } else {
+        layout.address.setText(repository.address)
+        val mirrors = repository.mirrors.map { it.withoutKnownPath }
+        if (mirrors.isNotEmpty()) {
+          layout.addressMirror.visibility = View.VISIBLE
+          layout.address.apply { setPaddingRelative(paddingStart, paddingTop,
+            paddingEnd + layout.addressMirror.layoutParams.width, paddingBottom) }
+          layout.addressMirror.setOnClickListener { SelectMirrorDialog(mirrors)
+            .show(childFragmentManager, SelectMirrorDialog::class.java.name) }
+        }
+        layout.fingerprint.setText(repository.fingerprint)
+        val (usernameText, passwordText) = repository.authentication.nullIfEmpty()
+          ?.let { if (it.startsWith("Basic ")) it.substring(6) else null }
+          ?.let {
+            try {
+              Base64.decode(it, Base64.NO_WRAP).toString(Charset.defaultCharset())
+            } catch (e: Exception) {
+              e.printStackTrace()
+              null
+            }
+          }
+          ?.let {
+            val index = it.indexOf(':')
+            if (index >= 0) Pair(it.substring(0, index), it.substring(index + 1)) else null
+          }
+          ?: Pair(null, null)
+        layout.username.setText(usernameText)
+        layout.password.setText(passwordText)
+      }
+    }
+
+    layout.address.addTextChangedListener(SimpleTextWatcher { invalidateAddress() })
+    layout.fingerprint.addTextChangedListener(SimpleTextWatcher { invalidateFingerprint() })
+    layout.username.addTextChangedListener(SimpleTextWatcher { invalidateUsernamePassword() })
+    layout.password.addTextChangedListener(SimpleTextWatcher { invalidateUsernamePassword() })
+
+    (layout.overlay.parent as ViewGroup).layoutTransition?.setDuration(200L)
+    layout.overlay.background!!.apply {
+      mutate()
+      alpha = 0xcc
+    }
+    layout.skip.setOnClickListener {
+      if (checkDisposable != null) {
+        checkDisposable?.dispose()
+        checkDisposable = null
+        onSaveRepositoryClick(false)
+      }
+    }
+
+    repositoriesDisposable = Observable.just(Unit)
+      .concatWith(Database.observable(Database.Subject.Repositories))
+      .observeOn(Schedulers.io())
+      .flatMapSingle { RxUtils.querySingle { Database.RepositoryAdapter.getAll(it) } }
+      .observeOn(AndroidSchedulers.mainThread())
+      .subscribe {
+        takenAddresses = it.asSequence().filter { it.id != repositoryId }
+          .flatMap { (it.mirrors + it.address).asSequence() }
+          .map { it.withoutKnownPath }.toSet()
+        invalidateAddress()
+      }
+  }
+
+  override fun onDestroyView() {
+    super.onDestroyView()
+
+    saveMenuItem = null
+    layout = null
+
+    syncConnection.unbind(requireContext())
+    repositoriesDisposable?.dispose()
+    repositoriesDisposable = null
+    checkDisposable?.dispose()
+    checkDisposable = null
+  }
+
+  override fun onActivityCreated(savedInstanceState: Bundle?) {
+    super.onActivityCreated(savedInstanceState)
+
+    invalidateAddress()
+    invalidateFingerprint()
+    invalidateUsernamePassword()
+  }
+
+  private var addressError = false
+  private var fingerprintError = false
+  private var usernamePasswordError = false
+
+  private fun invalidateAddress() {
+    invalidateAddress(layout!!.address.text.toString())
+  }
+
+  private fun invalidateAddress(addressText: String) {
+    val layout = layout!!
+    val normalizedAddress = normalizeAddress(addressText)
+    val addressErrorResId = if (normalizedAddress != null) {
+      if (normalizedAddress.withoutKnownPath in takenAddresses) {
+        R.string.already_exists
+      } else {
+        null
+      }
+    } else {
+      R.string.invalid_address
+    }
+    layout.address.setError(addressErrorResId != null)
+    layout.addressError.visibility = if (addressErrorResId != null) View.VISIBLE else View.GONE
+    if (addressErrorResId != null) {
+      layout.addressError.setText(addressErrorResId)
+    }
+    addressError = addressErrorResId != null
+    invalidateState()
+  }
+
+  private fun invalidateFingerprint() {
+    val layout = layout!!
+    val fingerprint = layout.fingerprint.text.toString().replace(" ", "")
+    val fingerprintInvalid = fingerprint.isNotEmpty() && fingerprint.length != 64
+    layout.fingerprintError.visibility = if (fingerprintInvalid) View.VISIBLE else View.GONE
+    if (fingerprintInvalid) {
+      layout.fingerprintError.setText(R.string.invalid_fingerprint_format)
+    }
+    layout.fingerprint.setError(fingerprintInvalid)
+    fingerprintError = fingerprintInvalid
+    invalidateState()
+  }
+
+  private fun invalidateUsernamePassword() {
+    val layout = layout!!
+    val username = layout.username.text.toString()
+    val password = layout.password.text.toString()
+    val usernameInvalid = username.contains(':')
+    val usernameEmpty = username.isEmpty() && password.isNotEmpty()
+    val passwordEmpty = username.isNotEmpty() && password.isEmpty()
+    layout.usernameError.visibility = if (usernameInvalid || usernameEmpty) View.VISIBLE else View.GONE
+    layout.passwordError.visibility = if (passwordEmpty) View.VISIBLE else View.GONE
+    if (usernameInvalid) {
+      layout.usernameError.setText(R.string.invalid_username_format)
+    } else if (usernameEmpty) {
+      layout.usernameError.setText(R.string.username_missing)
+    }
+    layout.username.setError(usernameEmpty)
+    if (passwordEmpty) {
+      layout.passwordError.setText(R.string.password_missing)
+    }
+    layout.password.setError(passwordEmpty)
+    usernamePasswordError = usernameInvalid || usernameEmpty || passwordEmpty
+    invalidateState()
+  }
+
+  private fun invalidateState() {
+    val layout = layout!!
+    saveMenuItem!!.isEnabled = !addressError && !fingerprintError &&
+      !usernamePasswordError && checkDisposable == null
+    layout.apply { sequenceOf(address, addressMirror, fingerprint, username, password)
+      .forEach { it.isEnabled = checkDisposable == null } }
+    layout.overlay.visibility = if (checkDisposable != null) View.VISIBLE else View.GONE
+  }
+
+  private val String.pathCropped: String
+    get() {
+      val index = indexOfLast { it != '/' }
+      return if (index >= 0 && index < length - 1) substring(0, index + 1) else this
+    }
+
+  private val String.withoutKnownPath: String
+    get() {
+      val cropped = pathCropped
+      val endsWith = checkPaths.asSequence().filter { it.isNotEmpty() }
+        .sortedByDescending { it.length }.find { cropped.endsWith("/$it") }
+      return if (endsWith != null) cropped.substring(0, cropped.length - endsWith.length - 1) else cropped
+    }
+
+  private fun normalizeAddress(address: String): String? {
+    val uri = try {
+      val uri = URI(address)
+      if (uri.isAbsolute) uri.normalize() else null
+    } catch (e: Exception) {
+      null
+    }
+    val path = uri?.path?.pathCropped
+    return if (uri != null && path != null) {
+      try {
+        URI(uri.scheme, uri.userInfo, uri.host, uri.port, path, uri.query, uri.fragment).toString()
+      } catch (e: Exception) {
+        null
+      }
+    } else {
+      null
+    }
+  }
+
+  private fun setMirror(address: String) {
+    layout?.address?.setText(address)
+  }
+
+  private fun EditText.setError(error: Boolean) {
+    val drawable = background.mutate()
+    drawable.colorFilter = if (error) errorColorFilter else null
+  }
+
+  private fun onSaveRepositoryClick(check: Boolean) {
+    if (checkDisposable == null) {
+      val layout = layout!!
+      val address = normalizeAddress(layout.address.text.toString())!!
+      val fingerprint = layout.fingerprint.text.toString().replace(" ", "")
+      val username = layout.username.text.toString().nullIfEmpty()
+      val password = layout.password.text.toString().nullIfEmpty()
+      val paths = sequenceOf("", "fdroid/repo", "repo")
+      val authentication = username?.let { u -> password
+        ?.let { p -> Base64.encodeToString("$u:$p".toByteArray(Charset.defaultCharset()), Base64.NO_WRAP) } }
+        ?.let { "Basic $it" }.orEmpty()
+
+      if (check) {
+        checkDisposable = paths
+          .fold(Single.just("")) { oldAddressSingle, checkPath -> oldAddressSingle
+            .flatMap { oldAddress ->
+              if (oldAddress.isEmpty()) {
+                val builder = Uri.parse(address).buildUpon()
+                  .let { if (checkPath.isEmpty()) it else it.appendEncodedPath(checkPath) }
+                val newAddress = builder.build()
+                val indexAddress = builder.appendPath("index.jar").build()
+                RxUtils
+                  .callSingle { Downloader
+                    .createCall(Request.Builder().method("HEAD", null)
+                      .url(indexAddress.toString().toHttpUrl()), authentication, null) }
+                  .subscribeOn(Schedulers.io())
+                  .map { if (it.code == 200) newAddress.toString() else "" }
+              } else {
+                Single.just(oldAddress)
+              }
+            }
+          }
+          .observeOn(AndroidSchedulers.mainThread())
+          .subscribe { result, throwable ->
+            checkDisposable = null
+            throwable?.printStackTrace()
+            val resultAddress = result?.let { if (it.isEmpty()) null else it } ?: address
+            val allow = resultAddress == address || run {
+              layout.address.setText(resultAddress)
+              invalidateAddress(resultAddress)
+              !addressError
+            }
+            if (allow) {
+              onSaveRepositoryProceedInvalidate(resultAddress, fingerprint, authentication)
+            } else {
+              invalidateState()
+            }
+          }
+        invalidateState()
+      } else {
+        onSaveRepositoryProceedInvalidate(address, fingerprint, authentication)
+      }
+    }
+  }
+
+  private fun onSaveRepositoryProceedInvalidate(address: String, fingerprint: String, authentication: String) {
+    val binder = syncConnection.binder
+    if (binder != null) {
+      val repositoryId = repositoryId
+      if (repositoryId != null && binder.isCurrentlySyncing(repositoryId)) {
+        MessageDialog(MessageDialog.Message.CantEditSyncing).show(childFragmentManager)
+        invalidateState()
+      } else {
+        val repository = repositoryId?.let(Database.RepositoryAdapter::get)
+          ?.edit(address, fingerprint, authentication)
+          ?: Repository.newRepository(address, fingerprint, authentication)
+        val changedRepository = Database.RepositoryAdapter.put(repository)
+        if (repositoryId == null && changedRepository.enabled) {
+          binder.sync(changedRepository)
+        }
+        requireActivity().onBackPressed()
+      }
+    } else {
+      invalidateState()
+    }
+  }
+
+  private class SimpleTextWatcher(private val callback: (Editable) -> Unit): TextWatcher {
+    override fun beforeTextChanged(s: CharSequence, start: Int, count: Int, after: Int) = Unit
+    override fun onTextChanged(s: CharSequence, start: Int, count: Int, after: Int) = Unit
+    override fun afterTextChanged(s: Editable) = callback(s)
+  }
+
+  class SelectMirrorDialog(): DialogFragment() {
+    companion object {
+      private const val EXTRA_MIRRORS = "mirrors"
+    }
+
+    constructor(mirrors: List<String>): this() {
+      arguments = Bundle().apply {
+        putStringArrayList(EXTRA_MIRRORS, ArrayList(mirrors))
+      }
+    }
+
+    override fun onCreateDialog(savedInstanceState: Bundle?): AlertDialog {
+      val mirrors = requireArguments().getStringArrayList(EXTRA_MIRRORS)!!
+      return AlertDialog.Builder(requireContext())
+        .setTitle(R.string.select_mirror)
+        .setItems(mirrors.toTypedArray()) { _, position -> (parentFragment as EditRepositoryFragment)
+          .setMirror(mirrors[position]) }
+        .setNegativeButton(R.string.cancel, null)
+        .create()
+    }
+  }
+}

src/main/kotlin/com/looker/droidify/screen/MessageDialog.kt

@@ -0,0 +1,231 @@
+package com.looker.droidify.screen
+
+import android.app.AlertDialog
+import android.content.ActivityNotFoundException
+import android.content.Intent
+import android.net.Uri
+import android.os.Bundle
+import android.os.Parcel
+import androidx.fragment.app.DialogFragment
+import androidx.fragment.app.FragmentManager
+import com.looker.droidify.R
+import com.looker.droidify.entity.Release
+import com.looker.droidify.utility.KParcelable
+import com.looker.droidify.utility.PackageItemResolver
+import com.looker.droidify.utility.extension.android.*
+import com.looker.droidify.utility.extension.text.*
+
+class MessageDialog(): DialogFragment() {
+  companion object {
+    private const val EXTRA_MESSAGE = "message"
+  }
+
+  sealed class Message: KParcelable {
+    object DeleteRepositoryConfirm: Message() {
+      @Suppress("unused") @JvmField val CREATOR = KParcelable.creator { DeleteRepositoryConfirm }
+    }
+
+    object CantEditSyncing: Message() {
+      @Suppress("unused") @JvmField val CREATOR = KParcelable.creator { CantEditSyncing }
+    }
+
+    class Link(val uri: Uri): Message() {
+      override fun writeToParcel(dest: Parcel, flags: Int) {
+        dest.writeString(uri.toString())
+      }
+
+      companion object {
+        @Suppress("unused") @JvmField val CREATOR = KParcelable.creator {
+          val uri = Uri.parse(it.readString()!!)
+          Link(uri)
+        }
+      }
+    }
+
+    class Permissions(val group: String?, val permissions: List<String>): Message() {
+      override fun writeToParcel(dest: Parcel, flags: Int) {
+        dest.writeString(group)
+        dest.writeStringList(permissions)
+      }
+
+      companion object {
+        @Suppress("unused") @JvmField val CREATOR = KParcelable.creator {
+          val group = it.readString()
+          val permissions = it.createStringArrayList()!!
+          Permissions(group, permissions)
+        }
+      }
+    }
+
+    class ReleaseIncompatible(val incompatibilities: List<Release.Incompatibility>,
+      val platforms: List<String>, val minSdkVersion: Int, val maxSdkVersion: Int): Message() {
+      override fun writeToParcel(dest: Parcel, flags: Int) {
+        dest.writeInt(incompatibilities.size)
+        for (incompatibility in incompatibilities) {
+          when (incompatibility) {
+            is Release.Incompatibility.MinSdk -> {
+              dest.writeInt(0)
+            }
+            is Release.Incompatibility.MaxSdk -> {
+              dest.writeInt(1)
+            }
+            is Release.Incompatibility.Platform -> {
+              dest.writeInt(2)
+            }
+            is Release.Incompatibility.Feature -> {
+              dest.writeInt(3)
+              dest.writeString(incompatibility.feature)
+            }
+          }::class
+        }
+        dest.writeStringList(platforms)
+        dest.writeInt(minSdkVersion)
+        dest.writeInt(maxSdkVersion)
+      }
+
+      companion object {
+        @Suppress("unused") @JvmField val CREATOR = KParcelable.creator {
+          val count = it.readInt()
+          val incompatibilities = generateSequence {
+            when (it.readInt()) {
+              0 -> Release.Incompatibility.MinSdk
+              1 -> Release.Incompatibility.MaxSdk
+              2 -> Release.Incompatibility.Platform
+              3 -> Release.Incompatibility.Feature(it.readString()!!)
+              else -> throw RuntimeException()
+            }
+          }.take(count).toList()
+          val platforms = it.createStringArrayList()!!
+          val minSdkVersion = it.readInt()
+          val maxSdkVersion = it.readInt()
+          ReleaseIncompatible(incompatibilities, platforms, minSdkVersion, maxSdkVersion)
+        }
+      }
+    }
+
+    object ReleaseOlder: Message() {
+      @Suppress("unused") @JvmField val CREATOR = KParcelable.creator { ReleaseOlder }
+    }
+
+    object ReleaseSignatureMismatch: Message() {
+      @Suppress("unused") @JvmField val CREATOR = KParcelable.creator { ReleaseSignatureMismatch }
+    }
+  }
+
+  constructor(message: Message): this() {
+    arguments = Bundle().apply {
+      putParcelable(EXTRA_MESSAGE, message)
+    }
+  }
+
+  fun show(fragmentManager: FragmentManager) {
+    show(fragmentManager, this::class.java.name)
+  }
+
+  override fun onCreateDialog(savedInstanceState: Bundle?): AlertDialog {
+    val dialog = AlertDialog.Builder(requireContext())
+    when (val message = requireArguments().getParcelable<Message>(EXTRA_MESSAGE)!!) {
+      is Message.DeleteRepositoryConfirm -> {
+        dialog.setTitle(R.string.confirmation)
+        dialog.setMessage(R.string.delete_repository_DESC)
+        dialog.setPositiveButton(R.string.delete) { _, _ -> (parentFragment as RepositoryFragment).onDeleteConfirm() }
+        dialog.setNegativeButton(R.string.cancel, null)
+      }
+      is Message.CantEditSyncing -> {
+        dialog.setTitle(R.string.action_failed)
+        dialog.setMessage(R.string.cant_edit_sync_DESC)
+        dialog.setPositiveButton(R.string.ok, null)
+      }
+      is Message.Link -> {
+        dialog.setTitle(R.string.confirmation)
+        dialog.setMessage(getString(R.string.open_DESC_FORMAT, message.uri.toString()))
+        dialog.setPositiveButton(R.string.ok) { _, _ ->
+          try {
+            startActivity(Intent(Intent.ACTION_VIEW, message.uri))
+          } catch (e: ActivityNotFoundException) {
+            e.printStackTrace()
+          }
+        }
+        dialog.setNegativeButton(R.string.cancel, null)
+      }
+      is Message.Permissions -> {
+        val packageManager = requireContext().packageManager
+        val builder = StringBuilder()
+        val localCache = PackageItemResolver.LocalCache()
+        val title = if (message.group != null) {
+          val name = try {
+            val permissionGroupInfo = packageManager.getPermissionGroupInfo(message.group, 0)
+            PackageItemResolver.loadLabel(requireContext(), localCache, permissionGroupInfo)
+              ?.nullIfEmpty()?.let { if (it == message.group) null else it }
+          } catch (e: Exception) {
+            null
+          }
+          name ?: getString(R.string.unknown)
+        } else {
+          getString(R.string.other)
+        }
+        for (permission in message.permissions) {
+          val description = try {
+            val permissionInfo = packageManager.getPermissionInfo(permission, 0)
+            PackageItemResolver.loadDescription(requireContext(), localCache, permissionInfo)
+              ?.nullIfEmpty()?.let { if (it == permission) null else it }
+          } catch (e: Exception) {
+            null
+          }
+          description?.let { builder.append(it).append("\n\n") }
+        }
+        if (builder.isNotEmpty()) {
+          builder.delete(builder.length - 2, builder.length)
+        } else {
+          builder.append(getString(R.string.no_description_available_DESC))
+        }
+        dialog.setTitle(title)
+        dialog.setMessage(builder)
+        dialog.setPositiveButton(R.string.ok, null)
+      }
+      is Message.ReleaseIncompatible -> {
+        val builder = StringBuilder()
+        val minSdkVersion = if (Release.Incompatibility.MinSdk in message.incompatibilities)
+          message.minSdkVersion else null
+        val maxSdkVersion = if (Release.Incompatibility.MaxSdk in message.incompatibilities)
+          message.maxSdkVersion else null
+        if (minSdkVersion != null || maxSdkVersion != null) {
+          val versionMessage = minSdkVersion?.let { getString(R.string.incompatible_api_min_DESC_FORMAT, it) }
+            ?: maxSdkVersion?.let { getString(R.string.incompatible_api_max_DESC_FORMAT, it) }
+          builder.append(getString(R.string.incompatible_api_DESC_FORMAT,
+            Android.name, Android.sdk, versionMessage.orEmpty())).append("\n\n")
+        }
+        if (Release.Incompatibility.Platform in message.incompatibilities) {
+          builder.append(getString(R.string.incompatible_platforms_DESC_FORMAT,
+            Android.primaryPlatform ?: getString(R.string.unknown),
+            message.platforms.joinToString(separator = ", "))).append("\n\n")
+        }
+        val features = message.incompatibilities.mapNotNull { it as? Release.Incompatibility.Feature }
+        if (features.isNotEmpty()) {
+          builder.append(getString(R.string.incompatible_features_DESC))
+          for (feature in features) {
+            builder.append("\n\u2022 ").append(feature.feature)
+          }
+          builder.append("\n\n")
+        }
+        if (builder.isNotEmpty()) {
+          builder.delete(builder.length - 2, builder.length)
+        }
+        dialog.setTitle(R.string.incompatible_version)
+        dialog.setMessage(builder)
+        dialog.setPositiveButton(R.string.ok, null)
+      }
+      is Message.ReleaseOlder -> {
+        dialog.setTitle(R.string.incompatible_version)
+        dialog.setMessage(R.string.incompatible_older_DESC)
+        dialog.setPositiveButton(R.string.ok, null)
+      }
+      is Message.ReleaseSignatureMismatch -> {
+        dialog.setTitle(R.string.incompatible_version)
+        dialog.setMessage(R.string.incompatible_signature_DESC)
+        dialog.setPositiveButton(R.string.ok, null)
+      }
+    }::class
+    return dialog.create()
+  }
+}

src/main/kotlin/com/looker/droidify/screen/PreferencesFragment.kt

@@ -0,0 +1,296 @@
+package com.looker.droidify.screen
+
+import android.app.AlertDialog
+import android.app.Dialog
+import android.content.Context
+import android.content.Intent
+import android.graphics.Typeface
+import android.net.Uri
+import android.os.Bundle
+import android.text.InputFilter
+import android.text.InputType
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import android.view.WindowManager
+import android.widget.*
+import androidx.fragment.app.DialogFragment
+import androidx.fragment.app.Fragment
+import com.looker.droidify.R
+import com.looker.droidify.content.Preferences
+import com.looker.droidify.utility.extension.resources.*
+import io.reactivex.rxjava3.disposables.Disposable
+
+
+class PreferencesFragment: ScreenFragment() {
+  private val preferences = mutableMapOf<Preferences.Key<*>, Preference<*>>()
+  private var disposable: Disposable? = null
+
+  override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View {
+    return inflater.inflate(R.layout.fragment, container, false)
+  }
+
+  override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
+    super.onViewCreated(view, savedInstanceState)
+
+    val toolbar = view.findViewById<Toolbar>(R.id.toolbar)!!
+    screenActivity.onToolbarCreated(toolbar)
+    toolbar.setTitle(R.string.preferences)
+
+    val content = view.findViewById<FrameLayout>(R.id.fragment_content)!!
+    val scroll = ScrollView(content.context)
+    scroll.id = R.id.preferences_list
+    scroll.isFillViewport = true
+    content.addView(scroll, ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT)
+    val scrollLayout = FrameLayout(content.context)
+    scroll.addView(scrollLayout, ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.WRAP_CONTENT)
+    val preferences = LinearLayout(scrollLayout.context)
+    preferences.orientation = LinearLayout.VERTICAL
+    scrollLayout.addView(preferences, ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.WRAP_CONTENT)
+
+    preferences.addCategory(getString(R.string.updates)) {
+      addEnumeration(Preferences.Key.AutoSync, getString(R.string.sync_repositories_automatically)) {
+        when (it) {
+          Preferences.AutoSync.Never -> getString(R.string.never)
+          Preferences.AutoSync.Wifi -> getString(R.string.only_on_wifi)
+          Preferences.AutoSync.Always -> getString(R.string.always)
+        }
+      }
+      addSwitch(Preferences.Key.UpdateNotify, getString(R.string.notify_about_updates),
+              getString(R.string.notify_about_updates_summary))
+      addSwitch(Preferences.Key.UpdateUnstable, getString(R.string.unstable_updates),
+              getString(R.string.unstable_updates_summary))
+    }
+    preferences.addCategory(getString(R.string.proxy)) {
+      addEnumeration(Preferences.Key.ProxyType, getString(R.string.proxy_type)) {
+        when (it) {
+          is Preferences.ProxyType.Direct -> getString(R.string.no_proxy)
+          is Preferences.ProxyType.Http -> getString(R.string.http_proxy)
+          is Preferences.ProxyType.Socks -> getString(R.string.socks_proxy)
+        }
+      }
+      addEditString(Preferences.Key.ProxyHost, getString(R.string.proxy_host))
+      addEditInt(Preferences.Key.ProxyPort, getString(R.string.proxy_port), 1..65535)
+    }
+    preferences.addCategory(getString(R.string.other)) {
+      addEnumeration(Preferences.Key.Theme, getString(R.string.theme)) {
+        when (it) {
+          is Preferences.Theme.System -> getString(R.string.system)
+          is Preferences.Theme.Light -> getString(R.string.light)
+          is Preferences.Theme.Dark -> getString(R.string.dark)
+        }
+      }
+      addSwitch(Preferences.Key.IncompatibleVersions, getString(R.string.incompatible_versions),
+              getString(R.string.incompatible_versions_summary))
+    }
+    // Adding Credits to Foxy
+    //TODO "Fix Linking"
+    var number = 0
+
+    preferences.addCategory("Credits") {
+      addText(title = "Based on an App by kitsunyan", summary = "FoxyDroid").also { setOnClickListener { number = 1 ; openURI(urlToSite = "https://github.com/kitsunyan/foxy-droid/") } }
+  }
+
+      // End Credits
+
+
+    disposable = Preferences.observable.subscribe(this::updatePreference)
+    updatePreference(null)
+  }
+
+  // Add Text for Credits
+
+  private fun LinearLayout.addText(title: String, summary: String){
+    val text = TextView(context)
+    val subText = TextView(context)
+    text.text = title
+    subText.text = summary
+    text.setTypeface(null, Typeface.BOLD)
+    resources.sizeScaled(16).let { text.setPadding(it, it, 5, 5) }
+    resources.sizeScaled(16).let { subText.setPadding(it, 5, 5, 5) }
+    addView(text, LinearLayout.LayoutParams.MATCH_PARENT, LinearLayout.LayoutParams.WRAP_CONTENT)
+    addView(subText, LinearLayout.LayoutParams.MATCH_PARENT, LinearLayout.LayoutParams.WRAP_CONTENT)
+  }
+
+  private fun openURI(urlToSite: String){
+    val browserIntent = Intent(Intent.ACTION_VIEW, Uri.parse(urlToSite))
+    startActivity(browserIntent)
+  }
+  // End Add Text for Credits
+
+  override fun onDestroyView() {
+    super.onDestroyView()
+
+    preferences.clear()
+    disposable?.dispose()
+    disposable = null
+  }
+
+  private fun updatePreference(key: Preferences.Key<*>?) {
+    if (key != null) {
+      preferences[key]?.update()
+    }
+    if (key == null || key == Preferences.Key.ProxyType) {
+      val enabled = when (Preferences[Preferences.Key.ProxyType]) {
+        is Preferences.ProxyType.Direct -> false
+        is Preferences.ProxyType.Http, is Preferences.ProxyType.Socks -> true
+      }
+      preferences[Preferences.Key.ProxyHost]?.setEnabled(enabled)
+      preferences[Preferences.Key.ProxyPort]?.setEnabled(enabled)
+    }
+    if (key == Preferences.Key.Theme) {
+      requireActivity().recreate()
+    }
+  }
+
+  private fun LinearLayout.addCategory(title: String, callback: LinearLayout.() -> Unit) {
+    val text = TextView(context)
+    text.typeface = TypefaceExtra.medium
+    text.setTextSizeScaled(14)
+    text.setTextColor(text.context.getColorFromAttr(android.R.attr.colorAccent))
+    text.text = title
+    resources.sizeScaled(16).let { text.setPadding(it, it, it, 0) }
+    addView(text, LinearLayout.LayoutParams.MATCH_PARENT, LinearLayout.LayoutParams.WRAP_CONTENT)
+    callback()
+  }
+
+  private fun <T> LinearLayout.addPreference(key: Preferences.Key<T>, title: String,
+                                             summaryProvider: () -> String, dialogProvider: ((Context) -> AlertDialog)?): Preference<T> {
+    val preference = Preference(key, this@PreferencesFragment, this, title, summaryProvider, dialogProvider)
+    preferences[key] = preference
+    return preference
+  }
+
+  private fun LinearLayout.addSwitch(key: Preferences.Key<Boolean>, title: String, summary: String) {
+    val preference = addPreference(key, title, { summary }, null)
+    preference.check.visibility = View.VISIBLE
+    preference.view.setOnClickListener { Preferences[key] = !Preferences[key] }
+    preference.setCallback { preference.check.isChecked = Preferences[key] }
+  }
+
+  private fun <T> LinearLayout.addEdit(key: Preferences.Key<T>, title: String, valueToString: (T) -> String,
+                                       stringToValue: (String) -> T?, configureEdit: (EditText) -> Unit) {
+    addPreference(key, title, { valueToString(Preferences[key]) }) {
+      val scroll = ScrollView(it)
+      scroll.resources.sizeScaled(20).let { scroll.setPadding(it, 0, it, 0) }
+      val edit = EditText(it)
+      configureEdit(edit)
+      edit.id = android.R.id.edit
+      edit.setTextSizeScaled(16)
+      edit.resources.sizeScaled(16).let { edit.setPadding(edit.paddingLeft, it, edit.paddingRight, it) }
+      edit.setText(valueToString(Preferences[key]))
+      edit.hint = edit.text.toString()
+      edit.setSelection(edit.text.length)
+      edit.requestFocus()
+      scroll.addView(edit, ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.WRAP_CONTENT)
+      AlertDialog.Builder(it)
+        .setTitle(title)
+        .setView(scroll)
+        .setPositiveButton(R.string.ok) { _, _ ->
+          val value = stringToValue(edit.text.toString()) ?: key.default.value
+          post { Preferences[key] = value }
+        }
+        .setNegativeButton(R.string.cancel, null)
+        .create()
+        .apply {
+          window!!.setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE)
+        }
+    }
+  }
+
+  private fun LinearLayout.addEditString(key: Preferences.Key<String>, title: String) {
+    addEdit(key, title, { it }, { it }, { })
+  }
+
+  private fun LinearLayout.addEditInt(key: Preferences.Key<Int>, title: String, range: IntRange?) {
+    addEdit(key, title, { it.toString() }, { it.toIntOrNull() }) {
+      it.inputType = InputType.TYPE_CLASS_NUMBER or InputType.TYPE_NUMBER_FLAG_DECIMAL
+      if (range != null) {
+        it.filters = arrayOf(InputFilter { source, start, end, dest, dstart, dend ->
+          val value = (dest.substring(0, dstart) + source.substring(start, end) +
+                  dest.substring(dend, dest.length)).toIntOrNull()
+          if (value != null && value in range) null else ""
+        })
+      }
+    }
+  }
+
+  private fun <T : Preferences.Enumeration<T>> LinearLayout
+    .addEnumeration(key: Preferences.Key<T>, title: String, valueToString: (T) -> String) {
+    addPreference(key, title, { valueToString(Preferences[key]) }) {
+      val values = key.default.value.values
+      AlertDialog.Builder(it)
+        .setTitle(title)
+        .setSingleChoiceItems(values.map(valueToString).toTypedArray(),
+                values.indexOf(Preferences[key])) { dialog, which ->
+          dialog.dismiss()
+          post { Preferences[key] = values[which] }
+        }
+        .setNegativeButton(R.string.cancel, null)
+        .create()
+    }
+  }
+
+  private class Preference<T>(private val key: Preferences.Key<T>,
+                              fragment: Fragment, parent: ViewGroup, titleText: String,
+                              private val summaryProvider: () -> String, private val dialogProvider: ((Context) -> AlertDialog)?) {
+    val view = parent.inflate(R.layout.preference_item)
+    val title = view.findViewById<TextView>(R.id.title)!!
+    val summary = view.findViewById<TextView>(R.id.summary)!!
+    val check = view.findViewById<Switch>(R.id.check)!!
+
+    private var callback: (() -> Unit)? = null
+
+    init {
+      title.text = titleText
+      parent.addView(view)
+      if (dialogProvider != null) {
+        view.setOnClickListener { PreferenceDialog(key.name)
+          .show(fragment.childFragmentManager, "${PreferenceDialog::class.java.name}.${key.name}") }
+      }
+      update()
+    }
+
+    fun setCallback(callback: () -> Unit) {
+      this.callback = callback
+      update()
+    }
+
+    fun setEnabled(enabled: Boolean) {
+      view.isEnabled = enabled
+      title.isEnabled = enabled
+      summary.isEnabled = enabled
+      check.isEnabled = enabled
+    }
+
+    fun update() {
+      summary.text = summaryProvider()
+      summary.visibility = if (summary.text.isNotEmpty()) View.VISIBLE else View.GONE
+      callback?.invoke()
+    }
+
+    fun createDialog(context: Context): AlertDialog {
+      return dialogProvider!!(context)
+    }
+  }
+
+  class PreferenceDialog(): DialogFragment() {
+    companion object {
+      private const val EXTRA_KEY = "key"
+    }
+
+    constructor(key: String): this() {
+      arguments = Bundle().apply {
+        putString(EXTRA_KEY, key)
+      }
+    }
+
+    override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
+      val preferences = (parentFragment as PreferencesFragment).preferences
+      val key = requireArguments().getString(EXTRA_KEY)!!
+        .let { name -> preferences.keys.find { it.name == name }!! }
+      val preference = preferences[key]!!
+      return preference.createDialog(requireContext())
+    }
+  }
+}

src/main/kotlin/com/looker/droidify/screen/ProductFragment.kt

@@ -0,0 +1,475 @@
+package com.looker.droidify.screen
+
+import android.app.AlertDialog
+import android.content.ActivityNotFoundException
+import android.content.ComponentName
+import android.content.Intent
+import android.content.pm.ApplicationInfo
+import android.net.Uri
+import android.os.Bundle
+import android.provider.Settings
+import android.view.LayoutInflater
+import android.view.MenuItem
+import android.view.View
+import android.view.ViewGroup
+import android.widget.FrameLayout
+import android.widget.Toolbar
+import androidx.fragment.app.DialogFragment
+import androidx.recyclerview.widget.GridLayoutManager
+import androidx.recyclerview.widget.LinearLayoutManager
+import androidx.recyclerview.widget.RecyclerView
+import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers
+import io.reactivex.rxjava3.core.Observable
+import io.reactivex.rxjava3.disposables.Disposable
+import io.reactivex.rxjava3.schedulers.Schedulers
+import com.looker.droidify.R
+import com.looker.droidify.content.ProductPreferences
+import com.looker.droidify.database.Database
+import com.looker.droidify.entity.InstalledItem
+import com.looker.droidify.entity.Product
+import com.looker.droidify.entity.ProductPreference
+import com.looker.droidify.entity.Release
+import com.looker.droidify.entity.Repository
+import com.looker.droidify.service.Connection
+import com.looker.droidify.service.DownloadService
+import com.looker.droidify.utility.RxUtils
+import com.looker.droidify.utility.Utils
+import com.looker.droidify.utility.extension.android.*
+import com.looker.droidify.widget.DividerItemDecoration
+
+class ProductFragment(): ScreenFragment(), ProductAdapter.Callbacks {
+  companion object {
+    private const val EXTRA_PACKAGE_NAME = "packageName"
+
+    private const val STATE_LAYOUT_MANAGER = "layoutManager"
+    private const val STATE_ADAPTER = "adapter"
+  }
+
+  constructor(packageName: String): this() {
+    arguments = Bundle().apply {
+      putString(EXTRA_PACKAGE_NAME, packageName)
+    }
+  }
+
+  private class Nullable<T>(val value: T?)
+
+  private enum class Action(val id: Int, val adapterAction: ProductAdapter.Action, val iconResId: Int) {
+    INSTALL(1, ProductAdapter.Action.INSTALL, R.drawable.ic_archive),
+    UPDATE(2, ProductAdapter.Action.UPDATE, R.drawable.ic_archive),
+    LAUNCH(3, ProductAdapter.Action.LAUNCH, R.drawable.ic_launch),
+    DETAILS(4, ProductAdapter.Action.DETAILS, R.drawable.ic_tune),
+    UNINSTALL(5, ProductAdapter.Action.UNINSTALL, R.drawable.ic_delete)
+  }
+
+  private class Installed(val installedItem: InstalledItem, val isSystem: Boolean,
+    val launcherActivities: List<Pair<String, String>>)
+
+  val packageName: String
+    get() = requireArguments().getString(EXTRA_PACKAGE_NAME)!!
+
+  private var layoutManagerState: LinearLayoutManager.SavedState? = null
+
+  private var actions = Pair(emptySet<Action>(), null as Action?)
+  private var products = emptyList<Pair<Product, Repository>>()
+  private var installed: Installed? = null
+  private var downloading = false
+
+  private var toolbar: Toolbar? = null
+  private var recyclerView: RecyclerView? = null
+
+  private var productDisposable: Disposable? = null
+  private var downloadDisposable: Disposable? = null
+  private val downloadConnection = Connection(DownloadService::class.java, onBind = { _, binder ->
+    updateDownloadState(binder.getState(packageName))
+    downloadDisposable = binder.events(packageName).subscribe { updateDownloadState(it) }
+  }, onUnbind = { _, _ ->
+    downloadDisposable?.dispose()
+    downloadDisposable = null
+  })
+
+  override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View? {
+    return inflater.inflate(R.layout.fragment, container, false)
+  }
+
+  override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
+    super.onViewCreated(view, savedInstanceState)
+
+    val toolbar = view.findViewById<Toolbar>(R.id.toolbar)!!
+    screenActivity.onToolbarCreated(toolbar)
+    toolbar.setTitle(R.string.application)
+    this.toolbar = toolbar
+
+    toolbar.menu.apply {
+      for (action in Action.values()) {
+        add(0, action.id, 0, action.adapterAction.titleResId)
+          .setIcon(Utils.getToolbarIcon(toolbar.context, action.iconResId))
+          .setVisible(false)
+          .setShowAsActionFlags(MenuItem.SHOW_AS_ACTION_ALWAYS)
+          .setOnMenuItemClickListener {
+            onActionClick(action.adapterAction)
+            true
+          }
+      }
+    }
+
+    val content = view.findViewById<FrameLayout>(R.id.fragment_content)!!
+    content.addView(RecyclerView(content.context).apply {
+      id = android.R.id.list
+      val columns = (resources.configuration.screenWidthDp / 120).coerceIn(3, 5)
+      val layoutManager = GridLayoutManager(context, columns)
+      this.layoutManager = layoutManager
+      isMotionEventSplittingEnabled = false
+      isVerticalScrollBarEnabled = false
+      val adapter = ProductAdapter(this@ProductFragment, columns)
+      this.adapter = adapter
+      layoutManager.spanSizeLookup = object: GridLayoutManager.SpanSizeLookup() {
+        override fun getSpanSize(position: Int): Int {
+          return if (adapter.requiresGrid(position)) 1 else layoutManager.spanCount
+        }
+      }
+      addOnScrollListener(scrollListener)
+      addItemDecoration(adapter.gridItemDecoration)
+      addItemDecoration(DividerItemDecoration(context, adapter::configureDivider))
+      savedInstanceState?.getParcelable<ProductAdapter.SavedState>(STATE_ADAPTER)?.let(adapter::restoreState)
+      layoutManagerState = savedInstanceState?.getParcelable(STATE_LAYOUT_MANAGER)
+      recyclerView = this
+    }, FrameLayout.LayoutParams.MATCH_PARENT, FrameLayout.LayoutParams.MATCH_PARENT)
+
+    var first = true
+    productDisposable = Observable.just(Unit)
+      .concatWith(Database.observable(Database.Subject.Products))
+      .observeOn(Schedulers.io())
+      .flatMapSingle { RxUtils.querySingle { Database.ProductAdapter.get(packageName, it) } }
+      .flatMapSingle { products -> RxUtils
+        .querySingle { Database.RepositoryAdapter.getAll(it) }
+        .map { it.asSequence().map { Pair(it.id, it) }.toMap()
+          .let { products.mapNotNull { product -> it[product.repositoryId]?.let { Pair(product, it) } } } } }
+      .flatMapSingle { products -> RxUtils
+        .querySingle { Nullable(Database.InstalledAdapter.get(packageName, it)) }
+        .map { Pair(products, it) } }
+      .observeOn(AndroidSchedulers.mainThread())
+      .subscribe {
+        val (products, installedItem) = it
+        val firstChanged = first
+        first = false
+        val productChanged = this.products != products
+        val installedItemChanged = this.installed?.installedItem != installedItem.value
+        if (firstChanged || productChanged || installedItemChanged) {
+          layoutManagerState?.let { recyclerView?.layoutManager!!.onRestoreInstanceState(it) }
+          layoutManagerState = null
+          if (firstChanged || productChanged) {
+            this.products = products
+          }
+          if (firstChanged || installedItemChanged) {
+            installed = installedItem.value?.let {
+              val isSystem = try {
+                ((requireContext().packageManager.getApplicationInfo(packageName, 0).flags)
+                  and ApplicationInfo.FLAG_SYSTEM) != 0
+              } catch (e: Exception) {
+                false
+              }
+              val launcherActivities = if (packageName == requireContext().packageName) {
+                // Don't allow to launch self
+                emptyList()
+              } else {
+                val packageManager = requireContext().packageManager
+                packageManager
+                  .queryIntentActivities(Intent(Intent.ACTION_MAIN).addCategory(Intent.CATEGORY_LAUNCHER), 0)
+                  .asSequence().mapNotNull { it.activityInfo }.filter { it.packageName == packageName }
+                  .mapNotNull { activityInfo ->
+                    val label = try {
+                      activityInfo.loadLabel(packageManager).toString()
+                    } catch (e: Exception) {
+                      e.printStackTrace()
+                      null
+                    }
+                    label?.let { Pair(activityInfo.name, it) }
+                  }
+                  .toList()
+              }
+              Installed(it, isSystem, launcherActivities)
+            }
+          }
+          val recyclerView = recyclerView!!
+          val adapter = recyclerView.adapter as ProductAdapter
+          if (firstChanged || productChanged || installedItemChanged) {
+            adapter.setProducts(recyclerView.context, packageName, products, installedItem.value)
+          }
+          updateButtons()
+        }
+      }
+
+    downloadConnection.bind(requireContext())
+  }
+
+  override fun onDestroyView() {
+    super.onDestroyView()
+
+    toolbar = null
+    recyclerView = null
+
+    productDisposable?.dispose()
+    productDisposable = null
+    downloadDisposable?.dispose()
+    downloadDisposable = null
+    downloadConnection.unbind(requireContext())
+  }
+
+  override fun onSaveInstanceState(outState: Bundle) {
+    super.onSaveInstanceState(outState)
+
+    val layoutManagerState = layoutManagerState ?: recyclerView?.layoutManager?.onSaveInstanceState()
+    layoutManagerState?.let { outState.putParcelable(STATE_LAYOUT_MANAGER, it) }
+    val adapterState = (recyclerView?.adapter as? ProductAdapter)?.saveState()
+    adapterState?.let { outState.putParcelable(STATE_ADAPTER, it) }
+  }
+
+  private fun updateButtons() {
+    updateButtons(ProductPreferences[packageName])
+  }
+
+  private fun updateButtons(preference: ProductPreference) {
+    val installed = installed
+    val product = Product.findSuggested(products, installed?.installedItem) { it.first }?.first
+    val compatible = product != null && product.selectedReleases.firstOrNull()
+      .let { it != null && it.incompatibilities.isEmpty() }
+    val canInstall = product != null && installed == null && compatible
+    val canUpdate = product != null && compatible && product.canUpdate(installed?.installedItem) &&
+      !preference.shouldIgnoreUpdate(product.versionCode)
+    val canUninstall = product != null && installed != null && !installed.isSystem
+    val canLaunch = product != null && installed != null && installed.launcherActivities.isNotEmpty()
+
+    val actions = mutableSetOf<Action>()
+    if (canInstall) {
+      actions += Action.INSTALL
+    }
+    if (canUpdate) {
+      actions += Action.UPDATE
+    }
+    if (canLaunch) {
+      actions += Action.LAUNCH
+    }
+    if (installed != null) {
+      actions += Action.DETAILS
+    }
+    if (canUninstall) {
+      actions += Action.UNINSTALL
+    }
+    val primaryAction = when {
+      canUpdate -> Action.UPDATE
+      canLaunch -> Action.LAUNCH
+      canInstall -> Action.INSTALL
+      installed != null -> Action.DETAILS
+      else -> null
+    }
+
+    val adapterAction = if (downloading) ProductAdapter.Action.CANCEL else primaryAction?.adapterAction
+    (recyclerView?.adapter as? ProductAdapter)?.setAction(adapterAction)
+
+    val toolbar = toolbar
+    if (toolbar != null) {
+      for (action in sequenceOf(Action.INSTALL, Action.UPDATE, Action.UNINSTALL)) {
+        toolbar.menu.findItem(action.id).isEnabled = !downloading
+      }
+    }
+    this.actions = Pair(actions, primaryAction)
+    updateToolbarButtons()
+  }
+
+  private fun updateToolbarButtons() {
+    val (actions, primaryAction) = actions
+    val showPrimaryAction = recyclerView
+      ?.let { (it.layoutManager as LinearLayoutManager).findFirstVisibleItemPosition() != 0 } == true
+    val displayActions = actions.toMutableSet()
+    if (!showPrimaryAction && primaryAction != null) {
+      displayActions -= primaryAction
+    }
+    if (displayActions.size >= 4 && resources.configuration.screenWidthDp < 400) {
+      displayActions -= Action.DETAILS
+    }
+    val toolbar = toolbar
+    if (toolbar != null) {
+      for (action in Action.values()) {
+        toolbar.menu.findItem(action.id).isVisible = action in displayActions
+      }
+    }
+  }
+
+  private fun updateDownloadState(state: DownloadService.State?) {
+    val status = when (state) {
+      is DownloadService.State.Pending -> ProductAdapter.Status.Pending
+      is DownloadService.State.Connecting -> ProductAdapter.Status.Connecting
+      is DownloadService.State.Downloading -> ProductAdapter.Status.Downloading(state.read, state.total)
+      is DownloadService.State.Success, is DownloadService.State.Error, is DownloadService.State.Cancel, null -> null
+    }
+    val downloading = status != null
+    if (this.downloading != downloading) {
+      this.downloading = downloading
+      updateButtons()
+    }
+    (recyclerView?.adapter as? ProductAdapter)?.setStatus(status)
+    if (state is DownloadService.State.Success && isResumed) {
+      state.consume()
+      screenActivity.startPackageInstaller(state.release.cacheFileName)
+    }
+  }
+
+  private val scrollListener = object: RecyclerView.OnScrollListener() {
+    private var lastPosition = -1
+
+    override fun onScrolled(recyclerView: RecyclerView, dx: Int, dy: Int) {
+      val position = (recyclerView.layoutManager as LinearLayoutManager).findFirstVisibleItemPosition()
+      val lastPosition = lastPosition
+      this.lastPosition = position
+      if ((lastPosition == 0) != (position == 0)) {
+        updateToolbarButtons()
+      }
+    }
+  }
+
+  override fun onActionClick(action: ProductAdapter.Action) {
+    when (action) {
+      ProductAdapter.Action.INSTALL,
+      ProductAdapter.Action.UPDATE -> {
+        val installedItem = installed?.installedItem
+        val productRepository = Product.findSuggested(products, installedItem) { it.first }
+        val compatibleReleases = productRepository?.first?.selectedReleases.orEmpty()
+          .filter { installedItem == null || installedItem.signature == it.signature }
+        val release = if (compatibleReleases.size >= 2) {
+          compatibleReleases
+            .filter { it.platforms.contains(Android.primaryPlatform) }
+            .minBy { it.platforms.size }
+            ?: compatibleReleases.minBy { it.platforms.size }
+            ?: compatibleReleases.firstOrNull()
+        } else {
+          compatibleReleases.firstOrNull()
+        }
+        val binder = downloadConnection.binder
+        if (productRepository != null && release != null && binder != null) {
+          binder.enqueue(packageName, productRepository.first.name, productRepository.second, release)
+        }
+        Unit
+      }
+      ProductAdapter.Action.LAUNCH -> {
+        val launcherActivities = installed?.launcherActivities.orEmpty()
+        if (launcherActivities.size >= 2) {
+          LaunchDialog(launcherActivities).show(childFragmentManager, LaunchDialog::class.java.name)
+        } else {
+          launcherActivities.firstOrNull()?.let { startLauncherActivity(it.first) }
+        }
+        Unit
+      }
+      ProductAdapter.Action.DETAILS -> {
+        startActivity(Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS)
+          .setData(Uri.parse("package:$packageName")))
+      }
+      ProductAdapter.Action.UNINSTALL -> {
+        // TODO Handle deprecation
+        @Suppress("DEPRECATION")
+        startActivity(Intent(Intent.ACTION_UNINSTALL_PACKAGE)
+          .setData(Uri.parse("package:$packageName")))
+      }
+      ProductAdapter.Action.CANCEL -> {
+        val binder = downloadConnection.binder
+        if (downloading && binder != null) {
+          binder.cancel(packageName)
+        }
+        Unit
+      }
+    }::class
+  }
+
+  private fun startLauncherActivity(name: String) {
+    try {
+      startActivity(Intent(Intent.ACTION_MAIN)
+        .addCategory(Intent.CATEGORY_LAUNCHER)
+        .setComponent(ComponentName(packageName, name))
+        .setFlags(Intent.FLAG_ACTIVITY_NEW_TASK))
+    } catch (e: Exception) {
+      e.printStackTrace()
+    }
+  }
+
+  override fun onPreferenceChanged(preference: ProductPreference) {
+    updateButtons(preference)
+  }
+
+  override fun onPermissionsClick(group: String?, permissions: List<String>) {
+    MessageDialog(MessageDialog.Message.Permissions(group, permissions)).show(childFragmentManager)
+  }
+
+  override fun onScreenshotClick(screenshot: Product.Screenshot) {
+    val pair = products.asSequence()
+      .map { Pair(it.second, it.first.screenshots.find { it === screenshot }?.identifier) }
+      .filter { it.second != null }.firstOrNull()
+    if (pair != null) {
+      val (repository, identifier) = pair
+      if (identifier != null) {
+        ScreenshotsFragment(packageName, repository.id, identifier).show(childFragmentManager)
+      }
+    }
+  }
+
+  override fun onReleaseClick(release: Release) {
+    val installedItem = installed?.installedItem
+    when {
+      release.incompatibilities.isNotEmpty() -> {
+        MessageDialog(MessageDialog.Message.ReleaseIncompatible(release.incompatibilities,
+          release.platforms, release.minSdkVersion, release.maxSdkVersion)).show(childFragmentManager)
+      }
+      installedItem != null && installedItem.versionCode > release.versionCode -> {
+        MessageDialog(MessageDialog.Message.ReleaseOlder).show(childFragmentManager)
+      }
+      installedItem != null && installedItem.signature != release.signature -> {
+        MessageDialog(MessageDialog.Message.ReleaseSignatureMismatch).show(childFragmentManager)
+      }
+      else -> {
+        val productRepository = products.asSequence().filter { it.first.releases.any { it === release } }.firstOrNull()
+        if (productRepository != null) {
+          downloadConnection.binder?.enqueue(packageName, productRepository.first.name,
+            productRepository.second, release)
+        }
+      }
+    }
+  }
+
+  override fun onUriClick(uri: Uri, shouldConfirm: Boolean): Boolean {
+    return if (shouldConfirm && (uri.scheme == "http" || uri.scheme == "https")) {
+      MessageDialog(MessageDialog.Message.Link(uri)).show(childFragmentManager)
+      true
+    } else {
+      try {
+        startActivity(Intent(Intent.ACTION_VIEW, uri))
+        true
+      } catch (e: ActivityNotFoundException) {
+        e.printStackTrace()
+        false
+      }
+    }
+  }
+
+  class LaunchDialog(): DialogFragment() {
+    companion object {
+      private const val EXTRA_NAMES = "names"
+      private const val EXTRA_LABELS = "labels"
+    }
+
+    constructor(launcherActivities: List<Pair<String, String>>): this() {
+      arguments = Bundle().apply {
+        putStringArrayList(EXTRA_NAMES, ArrayList(launcherActivities.map { it.first }))
+        putStringArrayList(EXTRA_LABELS, ArrayList(launcherActivities.map { it.second }))
+      }
+    }
+
+    override fun onCreateDialog(savedInstanceState: Bundle?): AlertDialog {
+      val names = requireArguments().getStringArrayList(EXTRA_NAMES)!!
+      val labels = requireArguments().getStringArrayList(EXTRA_LABELS)!!
+      return AlertDialog.Builder(requireContext())
+        .setTitle(R.string.launch)
+        .setItems(labels.toTypedArray()) { _, position -> (parentFragment as ProductFragment)
+          .startLauncherActivity(names[position]) }
+        .setNegativeButton(R.string.cancel, null)
+        .create()
+    }
+  }
+}

src/main/kotlin/com/looker/droidify/screen/ProductsAdapter.kt

@@ -0,0 +1,184 @@
+package com.looker.droidify.screen
+
+import android.content.Context
+import android.graphics.drawable.Drawable
+import android.graphics.drawable.GradientDrawable
+import android.view.Gravity
+import android.view.View
+import android.view.ViewGroup
+import android.widget.FrameLayout
+import android.widget.ImageView
+import android.widget.ProgressBar
+import android.widget.TextView
+import androidx.recyclerview.widget.RecyclerView
+import com.looker.droidify.R
+import com.looker.droidify.database.Database
+import com.looker.droidify.entity.ProductItem
+import com.looker.droidify.entity.Repository
+import com.looker.droidify.network.PicassoDownloader
+import com.looker.droidify.utility.Utils
+import com.looker.droidify.utility.extension.resources.*
+import com.looker.droidify.utility.extension.text.*
+import com.looker.droidify.widget.CursorRecyclerAdapter
+import com.looker.droidify.widget.DividerItemDecoration
+
+class ProductsAdapter(private val onClick: (ProductItem) -> Unit):
+  CursorRecyclerAdapter<ProductsAdapter.ViewType, RecyclerView.ViewHolder>() {
+  enum class ViewType { PRODUCT, LOADING, EMPTY }
+
+  private class ProductViewHolder(itemView: View): RecyclerView.ViewHolder(itemView) {
+    val name = itemView.findViewById<TextView>(R.id.name)!!
+    val status = itemView.findViewById<TextView>(R.id.status)!!
+    val summary = itemView.findViewById<TextView>(R.id.summary)!!
+    val icon = itemView.findViewById<ImageView>(R.id.icon)!!
+
+    val progressIcon: Drawable
+    val defaultIcon: Drawable
+
+    init {
+      val (progressIcon, defaultIcon) = Utils.getDefaultApplicationIcons(icon.context)
+      this.progressIcon = progressIcon
+      this.defaultIcon = defaultIcon
+    }
+  }
+
+  private class LoadingViewHolder(context: Context): RecyclerView.ViewHolder(FrameLayout(context)) {
+    init {
+      itemView as FrameLayout
+      val progressBar = ProgressBar(itemView.context)
+      itemView.addView(progressBar, FrameLayout.LayoutParams(FrameLayout.LayoutParams.WRAP_CONTENT,
+        FrameLayout.LayoutParams.WRAP_CONTENT).apply { gravity = Gravity.CENTER })
+      itemView.layoutParams = RecyclerView.LayoutParams(RecyclerView.LayoutParams.MATCH_PARENT,
+        RecyclerView.LayoutParams.MATCH_PARENT)
+    }
+  }
+
+  private class EmptyViewHolder(context: Context): RecyclerView.ViewHolder(TextView(context)) {
+    val text: TextView
+      get() = itemView as TextView
+
+    init {
+      itemView as TextView
+      itemView.gravity = Gravity.CENTER
+      itemView.resources.sizeScaled(20).let { itemView.setPadding(it, it, it, it) }
+      itemView.typeface = TypefaceExtra.light
+      itemView.setTextColor(context.getColorFromAttr(android.R.attr.textColorPrimary))
+      itemView.setTextSizeScaled(20)
+      itemView.layoutParams = RecyclerView.LayoutParams(RecyclerView.LayoutParams.MATCH_PARENT,
+        RecyclerView.LayoutParams.MATCH_PARENT)
+    }
+  }
+
+  fun configureDivider(context: Context, position: Int, configuration: DividerItemDecoration.Configuration) {
+    val currentItem = if (getItemEnumViewType(position) == ViewType.PRODUCT) getProductItem(position) else null
+    val nextItem = if (position + 1 < itemCount && getItemEnumViewType(position + 1) == ViewType.PRODUCT)
+      getProductItem(position + 1) else null
+    when {
+      currentItem != null && nextItem != null && currentItem.matchRank != nextItem.matchRank -> {
+        configuration.set(true, false, 0, 0)
+      }
+      else -> {
+        configuration.set(true, false, context.resources.sizeScaled(72), 0)
+      }
+    }
+  }
+
+  var repositories: Map<Long, Repository> = emptyMap()
+    set(value) {
+      field = value
+      notifyDataSetChanged()
+    }
+
+  var emptyText: String = ""
+    set(value) {
+      if (field != value) {
+        field = value
+        if (isEmpty) {
+          notifyDataSetChanged()
+        }
+      }
+    }
+
+  override val viewTypeClass: Class<ViewType>
+    get() = ViewType::class.java
+
+  private val isEmpty: Boolean
+    get() = super.getItemCount() == 0
+
+  override fun getItemCount(): Int = if (isEmpty) 1 else super.getItemCount()
+  override fun getItemId(position: Int): Long = if (isEmpty) -1 else super.getItemId(position)
+
+  override fun getItemEnumViewType(position: Int): ViewType {
+    return when {
+      !isEmpty -> ViewType.PRODUCT
+      cursor == null -> ViewType.LOADING
+      else -> ViewType.EMPTY
+    }
+  }
+
+  private fun getProductItem(position: Int): ProductItem {
+    return Database.ProductAdapter.transformItem(moveTo(position))
+  }
+
+  override fun onCreateViewHolder(parent: ViewGroup, viewType: ViewType): RecyclerView.ViewHolder {
+    return when (viewType) {
+      ViewType.PRODUCT -> ProductViewHolder(parent.inflate(R.layout.product_item)).apply {
+        itemView.setOnClickListener { onClick(getProductItem(adapterPosition)) }
+      }
+      ViewType.LOADING -> LoadingViewHolder(parent.context)
+      ViewType.EMPTY -> EmptyViewHolder(parent.context)
+    }
+  }
+
+  override fun onBindViewHolder(holder: RecyclerView.ViewHolder, position: Int) {
+    when (getItemEnumViewType(position)) {
+      ViewType.PRODUCT -> {
+        holder as ProductViewHolder
+        val productItem = getProductItem(position)
+        holder.name.text = productItem.name
+        holder.summary.text = if (productItem.name == productItem.summary) "" else productItem.summary
+        holder.summary.visibility = if (holder.summary.text.isNotEmpty()) View.VISIBLE else View.GONE
+        val repository: Repository? = repositories[productItem.repositoryId]
+        if ((productItem.icon.isNotEmpty() || productItem.metadataIcon.isNotEmpty()) && repository != null) {
+          holder.icon.load(PicassoDownloader.createIconUri(holder.icon, productItem.packageName,
+            productItem.icon, productItem.metadataIcon, repository)) {
+            placeholder(holder.progressIcon)
+            error(holder.defaultIcon)
+          }
+        } else {
+          holder.icon.clear()
+          holder.icon.setImageDrawable(holder.defaultIcon)
+        }
+        holder.status.apply {
+          if (productItem.canUpdate) {
+            text = productItem.version
+            if (background == null) {
+              resources.sizeScaled(4).let { setPadding(it, 0, it, 0) }
+              setTextColor(holder.status.context.getColorFromAttr(android.R.attr.colorBackground))
+              background = GradientDrawable(GradientDrawable.Orientation.TOP_BOTTOM, null).apply {
+                color = holder.status.context.getColorFromAttr(android.R.attr.colorAccent)
+                cornerRadius = holder.status.resources.sizeScaled(2).toFloat()
+              }
+            }
+          } else {
+            text = productItem.installedVersion.nullIfEmpty() ?: productItem.version
+            if (background != null) {
+              setPadding(0, 0, 0, 0)
+              setTextColor(holder.status.context.getColorFromAttr(android.R.attr.textColorPrimary))
+              background = null
+            }
+          }
+        }
+        val enabled = productItem.compatible || productItem.installedVersion.isNotEmpty()
+        sequenceOf(holder.name, holder.status, holder.summary).forEach { it.isEnabled = enabled }
+      }
+      ViewType.LOADING -> {
+        // Do nothing
+      }
+      ViewType.EMPTY -> {
+        holder as EmptyViewHolder
+        holder.text.text = emptyText
+      }
+    }::class
+  }
+}

src/main/kotlin/com/looker/droidify/screen/ProductsFragment.kt

@@ -0,0 +1,181 @@
+package com.looker.droidify.screen
+
+import android.database.Cursor
+import android.os.Bundle
+import android.os.Parcelable
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import androidx.recyclerview.widget.LinearLayoutManager
+import androidx.recyclerview.widget.RecyclerView
+import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers
+import io.reactivex.rxjava3.core.Observable
+import io.reactivex.rxjava3.disposables.Disposable
+import io.reactivex.rxjava3.schedulers.Schedulers
+import com.looker.droidify.R
+import com.looker.droidify.database.CursorOwner
+import com.looker.droidify.database.Database
+import com.looker.droidify.entity.ProductItem
+import com.looker.droidify.utility.RxUtils
+import com.looker.droidify.widget.DividerItemDecoration
+import com.looker.droidify.widget.RecyclerFastScroller
+
+class ProductsFragment(): ScreenFragment(), CursorOwner.Callback {
+  companion object {
+    private const val EXTRA_SOURCE = "source"
+
+    private const val STATE_CURRENT_SEARCH_QUERY = "currentSearchQuery"
+    private const val STATE_CURRENT_SECTION = "currentSection"
+    private const val STATE_CURRENT_ORDER = "currentOrder"
+    private const val STATE_LAYOUT_MANAGER = "layoutManager"
+  }
+
+  enum class Source(val titleResId: Int, val sections: Boolean, val order: Boolean) {
+    AVAILABLE(R.string.available, true, true),
+    INSTALLED(R.string.installed, false, false),
+    UPDATES(R.string.updates, false, false)
+  }
+
+  constructor(source: Source): this() {
+    arguments = Bundle().apply {
+      putString(EXTRA_SOURCE, source.name)
+    }
+  }
+
+  val source: Source
+    get() = requireArguments().getString(EXTRA_SOURCE)!!.let(Source::valueOf)
+
+  private var searchQuery = ""
+  private var section: ProductItem.Section = ProductItem.Section.All
+  private var order = ProductItem.Order.NAME
+
+  private var currentSearchQuery = ""
+  private var currentSection: ProductItem.Section = ProductItem.Section.All
+  private var currentOrder = ProductItem.Order.NAME
+  private var layoutManagerState: Parcelable? = null
+
+  private var recyclerView: RecyclerView? = null
+
+  private var repositoriesDisposable: Disposable? = null
+
+  private val request: CursorOwner.Request
+    get() {
+      val searchQuery = searchQuery
+      val section = if (source.sections) section else ProductItem.Section.All
+      val order = if (source.order) order else ProductItem.Order.NAME
+      return when (source) {
+        Source.AVAILABLE -> CursorOwner.Request.ProductsAvailable(searchQuery, section, order)
+        Source.INSTALLED -> CursorOwner.Request.ProductsInstalled(searchQuery, section, order)
+        Source.UPDATES -> CursorOwner.Request.ProductsUpdates(searchQuery, section, order)
+      }
+    }
+
+  override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View {
+    return RecyclerView(requireContext()).apply {
+      id = android.R.id.list
+      layoutManager = LinearLayoutManager(context)
+      isMotionEventSplittingEnabled = false
+      isVerticalScrollBarEnabled = false
+      setHasFixedSize(true)
+      recycledViewPool.setMaxRecycledViews(ProductsAdapter.ViewType.PRODUCT.ordinal, 30)
+      val adapter = ProductsAdapter { screenActivity.navigateProduct(it.packageName) }
+      this.adapter = adapter
+      addItemDecoration(DividerItemDecoration(context, adapter::configureDivider))
+      RecyclerFastScroller(this)
+      recyclerView = this
+    }
+  }
+
+  override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
+    super.onViewCreated(view, savedInstanceState)
+
+    currentSearchQuery = savedInstanceState?.getString(STATE_CURRENT_SEARCH_QUERY).orEmpty()
+    currentSection = savedInstanceState?.getParcelable(STATE_CURRENT_SECTION) ?: ProductItem.Section.All
+    currentOrder = savedInstanceState?.getString(STATE_CURRENT_ORDER)
+      ?.let(ProductItem.Order::valueOf) ?: ProductItem.Order.NAME
+    layoutManagerState = savedInstanceState?.getParcelable(STATE_LAYOUT_MANAGER)
+
+    screenActivity.cursorOwner.attach(this, request)
+    repositoriesDisposable = Observable.just(Unit)
+      .concatWith(Database.observable(Database.Subject.Repositories))
+      .observeOn(Schedulers.io())
+      .flatMapSingle { RxUtils.querySingle { Database.RepositoryAdapter.getAll(it) } }
+      .map { it.asSequence().map { Pair(it.id, it) }.toMap() }
+      .observeOn(AndroidSchedulers.mainThread())
+      .subscribe { (recyclerView?.adapter as? ProductsAdapter)?.repositories = it }
+  }
+
+  override fun onDestroyView() {
+    super.onDestroyView()
+
+    recyclerView = null
+
+    screenActivity.cursorOwner.detach(this)
+    repositoriesDisposable?.dispose()
+    repositoriesDisposable = null
+  }
+
+  override fun onSaveInstanceState(outState: Bundle) {
+    super.onSaveInstanceState(outState)
+
+    outState.putString(STATE_CURRENT_SEARCH_QUERY, currentSearchQuery)
+    outState.putParcelable(STATE_CURRENT_SECTION, currentSection)
+    outState.putString(STATE_CURRENT_ORDER, currentOrder.name)
+    (layoutManagerState ?: recyclerView?.layoutManager?.onSaveInstanceState())
+      ?.let { outState.putParcelable(STATE_LAYOUT_MANAGER, it) }
+  }
+
+  override fun onCursorData(request: CursorOwner.Request, cursor: Cursor?) {
+    (recyclerView?.adapter as? ProductsAdapter)?.apply {
+      this.cursor = cursor
+      emptyText = when {
+        cursor == null -> ""
+        searchQuery.isNotEmpty() -> getString(R.string.no_matching_applications_found)
+        else -> when (source) {
+          Source.AVAILABLE -> getString(R.string.no_applications_available)
+          Source.INSTALLED -> getString(R.string.no_applications_installed)
+          Source.UPDATES -> getString(R.string.all_applications_up_to_date)
+        }
+      }
+    }
+
+    layoutManagerState?.let {
+      layoutManagerState = null
+      recyclerView?.layoutManager?.onRestoreInstanceState(it)
+    }
+
+    if (currentSearchQuery != searchQuery || currentSection != section || currentOrder != order) {
+      currentSearchQuery = searchQuery
+      currentSection = section
+      currentOrder = order
+      recyclerView?.scrollToPosition(0)
+    }
+  }
+
+  internal fun setSearchQuery(searchQuery: String) {
+    if (this.searchQuery != searchQuery) {
+      this.searchQuery = searchQuery
+      if (view != null) {
+        screenActivity.cursorOwner.attach(this, request)
+      }
+    }
+  }
+
+  internal fun setSection(section: ProductItem.Section) {
+    if (this.section != section) {
+      this.section = section
+      if (view != null) {
+        screenActivity.cursorOwner.attach(this, request)
+      }
+    }
+  }
+
+  internal fun setOrder(order: ProductItem.Order) {
+    if (this.order != order) {
+      this.order = order
+      if (view != null) {
+        screenActivity.cursorOwner.attach(this, request)
+      }
+    }
+  }
+}

src/main/kotlin/com/looker/droidify/screen/RepositoriesAdapter.kt

@@ -0,0 +1,61 @@
+package com.looker.droidify.screen
+
+import android.view.View
+import android.view.ViewGroup
+import android.widget.Switch
+import android.widget.TextView
+import androidx.recyclerview.widget.RecyclerView
+import com.looker.droidify.R
+import com.looker.droidify.database.Database
+import com.looker.droidify.entity.Repository
+import com.looker.droidify.utility.extension.resources.*
+import com.looker.droidify.widget.CursorRecyclerAdapter
+
+class RepositoriesAdapter(private val onClick: (Repository) -> Unit,
+  private val onSwitch: (repository: Repository, isEnabled: Boolean) -> Boolean):
+  CursorRecyclerAdapter<RepositoriesAdapter.ViewType, RecyclerView.ViewHolder>() {
+  enum class ViewType { REPOSITORY }
+
+  private class ViewHolder(itemView: View): RecyclerView.ViewHolder(itemView) {
+    val name = itemView.findViewById<TextView>(R.id.name)!!
+    val enabled = itemView.findViewById<Switch>(R.id.enabled)!!
+
+    var listenSwitch = true
+  }
+
+  override val viewTypeClass: Class<ViewType>
+    get() = ViewType::class.java
+
+  override fun getItemEnumViewType(position: Int): ViewType {
+    return ViewType.REPOSITORY
+  }
+
+  private fun getRepository(position: Int): Repository {
+    return Database.RepositoryAdapter.transform(moveTo(position))
+  }
+
+  override fun onCreateViewHolder(parent: ViewGroup, viewType: ViewType): RecyclerView.ViewHolder {
+    return ViewHolder(parent.inflate(R.layout.repository_item)).apply {
+      itemView.setOnClickListener { onClick(getRepository(adapterPosition)) }
+      enabled.setOnCheckedChangeListener { _, isChecked ->
+        if (listenSwitch) {
+          if (!onSwitch(getRepository(adapterPosition), isChecked)) {
+            listenSwitch = false
+            enabled.isChecked = !isChecked
+            listenSwitch = true
+          }
+        }
+      }
+    }
+  }
+
+  override fun onBindViewHolder(holder: RecyclerView.ViewHolder, position: Int) {
+    holder as ViewHolder
+    val repository = getRepository(position)
+    val lastListenSwitch = holder.listenSwitch
+    holder.listenSwitch = false
+    holder.enabled.isChecked = repository.enabled
+    holder.listenSwitch = lastListenSwitch
+    holder.name.text = repository.name
+  }
+}

src/main/kotlin/com/looker/droidify/screen/RepositoriesFragment.kt

@@ -0,0 +1,73 @@
+package com.looker.droidify.screen
+
+import android.database.Cursor
+import android.os.Bundle
+import android.view.LayoutInflater
+import android.view.MenuItem
+import android.view.View
+import android.view.ViewGroup
+import android.widget.FrameLayout
+import android.widget.Toolbar
+import androidx.recyclerview.widget.LinearLayoutManager
+import androidx.recyclerview.widget.RecyclerView
+import com.looker.droidify.R
+import com.looker.droidify.database.CursorOwner
+import com.looker.droidify.service.Connection
+import com.looker.droidify.service.SyncService
+import com.looker.droidify.utility.Utils
+
+class RepositoriesFragment: ScreenFragment(), CursorOwner.Callback {
+  private var recyclerView: RecyclerView? = null
+
+  private val syncConnection = Connection(SyncService::class.java)
+
+  override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View {
+    return inflater.inflate(R.layout.fragment, container, false).apply {
+      val content = findViewById<FrameLayout>(R.id.fragment_content)!!
+      content.addView(RecyclerView(content.context).apply {
+        id = android.R.id.list
+        layoutManager = LinearLayoutManager(context)
+        isMotionEventSplittingEnabled = false
+        setHasFixedSize(true)
+        adapter = RepositoriesAdapter({ screenActivity.navigateRepository(it.id) },
+          { repository, isEnabled -> repository.enabled != isEnabled &&
+            syncConnection.binder?.setEnabled(repository, isEnabled) == true })
+        recyclerView = this
+      }, FrameLayout.LayoutParams.MATCH_PARENT, FrameLayout.LayoutParams.MATCH_PARENT)
+    }
+  }
+
+  override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
+    super.onViewCreated(view, savedInstanceState)
+
+    syncConnection.bind(requireContext())
+    screenActivity.cursorOwner.attach(this, CursorOwner.Request.Repositories)
+
+    val toolbar = view.findViewById<Toolbar>(R.id.toolbar)!!
+    screenActivity.onToolbarCreated(toolbar)
+    toolbar.setTitle(R.string.repositories)
+
+    toolbar.menu.apply {
+      add(R.string.add_repository)
+        .setIcon(Utils.getToolbarIcon(toolbar.context, R.drawable.ic_add))
+        .setShowAsActionFlags(MenuItem.SHOW_AS_ACTION_ALWAYS)
+        .setOnMenuItemClickListener {
+          view.post { screenActivity.navigateAddRepository() }
+          true
+        }
+    }
+  }
+
+  override fun onDestroyView() {
+    super.onDestroyView()
+
+    recyclerView = null
+
+    syncConnection.unbind(requireContext())
+    screenActivity.cursorOwner.detach(this)
+  }
+
+  override fun onCursorData(request: CursorOwner.Request, cursor: Cursor?) {
+    (recyclerView?.adapter as? RepositoriesAdapter)?.cursor = cursor
+  }
+}

src/main/kotlin/com/looker/droidify/screen/RepositoryFragment.kt

@@ -0,0 +1,166 @@
+package com.looker.droidify.screen
+
+import android.os.Bundle
+import android.text.SpannableStringBuilder
+import android.text.format.DateUtils
+import android.text.style.ForegroundColorSpan
+import android.text.style.TypefaceSpan
+import android.view.LayoutInflater
+import android.view.MenuItem
+import android.view.View
+import android.view.ViewGroup
+import android.widget.FrameLayout
+import android.widget.LinearLayout
+import android.widget.ScrollView
+import android.widget.TextView
+import android.widget.Toolbar
+import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers
+import io.reactivex.rxjava3.core.Observable
+import io.reactivex.rxjava3.disposables.Disposable
+import com.looker.droidify.R
+import com.looker.droidify.database.Database
+import com.looker.droidify.service.Connection
+import com.looker.droidify.service.SyncService
+import com.looker.droidify.utility.Utils
+import com.looker.droidify.utility.extension.resources.*
+import java.util.Date
+import java.util.Locale
+
+class RepositoryFragment(): ScreenFragment() {
+  companion object {
+    private const val EXTRA_REPOSITORY_ID = "repositoryId"
+  }
+
+  constructor(repositoryId: Long): this() {
+    arguments = Bundle().apply {
+      putLong(EXTRA_REPOSITORY_ID, repositoryId)
+    }
+  }
+
+  private val repositoryId: Long
+    get() = requireArguments().getLong(EXTRA_REPOSITORY_ID)
+
+  private var layout: LinearLayout? = null
+
+  private val syncConnection = Connection(SyncService::class.java)
+  private var repositoryDisposable: Disposable? = null
+
+  override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View {
+    return inflater.inflate(R.layout.fragment, container, false)
+  }
+
+  override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
+    super.onViewCreated(view, savedInstanceState)
+
+    syncConnection.bind(requireContext())
+    repositoryDisposable = Observable.just(Unit)
+      .concatWith(Database.observable(Database.Subject.Repository(repositoryId)))
+      .observeOn(AndroidSchedulers.mainThread())
+      .subscribe { updateRepositoryView() }
+
+    val toolbar = view.findViewById<Toolbar>(R.id.toolbar)!!
+    screenActivity.onToolbarCreated(toolbar)
+    toolbar.setTitle(R.string.repository)
+
+    toolbar.menu.apply {
+      add(R.string.edit_repository)
+        .setIcon(Utils.getToolbarIcon(toolbar.context, R.drawable.ic_edit))
+        .setShowAsActionFlags(MenuItem.SHOW_AS_ACTION_ALWAYS)
+        .setOnMenuItemClickListener {
+          view.post { screenActivity.navigateEditRepository(repositoryId) }
+          true
+        }
+
+      add(R.string.delete)
+        .setIcon(Utils.getToolbarIcon(toolbar.context, R.drawable.ic_delete))
+        .setShowAsActionFlags(MenuItem.SHOW_AS_ACTION_ALWAYS)
+        .setOnMenuItemClickListener {
+          MessageDialog(MessageDialog.Message.DeleteRepositoryConfirm).show(childFragmentManager)
+          true
+        }
+    }
+
+    val content = view.findViewById<FrameLayout>(R.id.fragment_content)!!
+    val scroll = ScrollView(content.context)
+    scroll.id = android.R.id.list
+    scroll.isFillViewport = true
+    content.addView(scroll, FrameLayout.LayoutParams.MATCH_PARENT, FrameLayout.LayoutParams.MATCH_PARENT)
+    val layout = LinearLayout(scroll.context)
+    layout.orientation = LinearLayout.VERTICAL
+    resources.sizeScaled(8).let { layout.setPadding(0, it, 0, it) }
+    this.layout = layout
+    scroll.addView(layout, ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.WRAP_CONTENT)
+  }
+
+  override fun onDestroyView() {
+    super.onDestroyView()
+
+    layout = null
+    syncConnection.unbind(requireContext())
+    repositoryDisposable?.dispose()
+    repositoryDisposable = null
+  }
+
+  private fun updateRepositoryView() {
+    val repository = Database.RepositoryAdapter.get(repositoryId)
+    val layout = layout!!
+    layout.removeAllViews()
+    if (repository == null) {
+      layout.addTitleText(R.string.address, getString(R.string.unknown))
+    } else {
+      layout.addTitleText(R.string.address, repository.address)
+      if (repository.updated > 0L) {
+        layout.addTitleText(R.string.name, repository.name)
+        layout.addTitleText(R.string.description, repository.description.replace('\n', ' '))
+        layout.addTitleText(R.string.last_update, run {
+          val lastUpdated = repository.updated
+          if (lastUpdated > 0L) {
+            val date = Date(repository.updated)
+            val format = if (DateUtils.isToday(date.time)) DateUtils.FORMAT_SHOW_TIME else
+              DateUtils.FORMAT_SHOW_TIME or DateUtils.FORMAT_SHOW_DATE
+            DateUtils.formatDateTime(layout.context, date.time, format)
+          } else {
+            getString(R.string.unknown)
+          }
+        })
+        if (repository.enabled && (repository.lastModified.isNotEmpty() || repository.entityTag.isNotEmpty())) {
+          layout.addTitleText(R.string.number_of_applications,
+            Database.ProductAdapter.getCount(repository.id).toString())
+        }
+      } else {
+        layout.addTitleText(R.string.description, getString(R.string.repository_not_used_DESC))
+      }
+      if (repository.fingerprint.isEmpty()) {
+        if (repository.updated > 0L) {
+          val builder = SpannableStringBuilder(getString(R.string.repository_unsigned_DESC))
+          builder.setSpan(ForegroundColorSpan(layout.context.getColorFromAttr(R.attr.colorError).defaultColor),
+            0, builder.length, SpannableStringBuilder.SPAN_EXCLUSIVE_EXCLUSIVE)
+          layout.addTitleText(R.string.fingerprint, builder)
+        }
+      } else {
+        val fingerprint = SpannableStringBuilder(repository.fingerprint.windowed(2, 2, false)
+          .take(32).joinToString(separator = " ") { it.toUpperCase(Locale.US) })
+        fingerprint.setSpan(TypefaceSpan("monospace"), 0, fingerprint.length,
+          SpannableStringBuilder.SPAN_EXCLUSIVE_EXCLUSIVE)
+        layout.addTitleText(R.string.fingerprint, fingerprint)
+      }
+    }
+  }
+
+  private fun LinearLayout.addTitleText(titleResId: Int, text: CharSequence) {
+    if (text.isNotEmpty()) {
+      val layout = inflate(R.layout.title_text_item)
+      val titleView = layout.findViewById<TextView>(R.id.title)!!
+      titleView.setText(titleResId)
+      val textView = layout.findViewById<TextView>(R.id.text)!!
+      textView.text = text
+      addView(layout)
+    }
+  }
+
+  internal fun onDeleteConfirm() {
+    if (syncConnection.binder?.deleteRepository(repositoryId) == true) {
+      requireActivity().onBackPressed()
+    }
+  }
+}

src/main/kotlin/com/looker/droidify/screen/ScreenActivity.kt

@@ -0,0 +1,250 @@
+package com.looker.droidify.screen
+
+import android.content.Context
+import android.content.Intent
+import android.net.Uri
+import android.os.Bundle
+import android.os.Parcel
+import android.view.View
+import android.view.ViewGroup
+import android.view.inputmethod.InputMethodManager
+import android.widget.FrameLayout
+import android.widget.Toolbar
+import androidx.fragment.app.Fragment
+import androidx.fragment.app.FragmentActivity
+import com.looker.droidify.R
+import com.looker.droidify.content.Cache
+import com.looker.droidify.content.Preferences
+import com.looker.droidify.database.CursorOwner
+import com.looker.droidify.utility.KParcelable
+import com.looker.droidify.utility.Utils
+import com.looker.droidify.utility.extension.android.*
+import com.looker.droidify.utility.extension.resources.*
+import com.looker.droidify.utility.extension.text.*
+
+abstract class ScreenActivity: FragmentActivity() {
+  companion object {
+    private const val STATE_FRAGMENT_STACK = "fragmentStack"
+  }
+
+  sealed class SpecialIntent {
+    object Updates: SpecialIntent()
+    class Install(val packageName: String?, val cacheFileName: String?): SpecialIntent()
+  }
+
+  private class FragmentStackItem(val className: String, val arguments: Bundle?,
+    val savedState: Fragment.SavedState?): KParcelable {
+    override fun writeToParcel(dest: Parcel, flags: Int) {
+      dest.writeString(className)
+      dest.writeByte(if (arguments != null) 1 else 0)
+      arguments?.writeToParcel(dest, flags)
+      dest.writeByte(if (savedState != null) 1 else 0)
+      savedState?.writeToParcel(dest, flags)
+    }
+
+    companion object {
+      @Suppress("unused") @JvmField val CREATOR = KParcelable.creator {
+        val className = it.readString()!!
+        val arguments = if (it.readByte().toInt() == 0) null else Bundle.CREATOR.createFromParcel(it)
+        arguments?.classLoader = ScreenActivity::class.java.classLoader
+        val savedState = if (it.readByte().toInt() == 0) null else Fragment.SavedState.CREATOR.createFromParcel(it)
+        FragmentStackItem(className, arguments, savedState)
+      }
+    }
+  }
+
+  lateinit var cursorOwner: CursorOwner
+    private set
+
+  private val fragmentStack = mutableListOf<FragmentStackItem>()
+
+  private val currentFragment: Fragment?
+    get() {
+      supportFragmentManager.executePendingTransactions()
+      return supportFragmentManager.findFragmentById(R.id.main_content)
+    }
+
+  override fun attachBaseContext(base: Context) {
+    super.attachBaseContext(Utils.configureLocale(base))
+  }
+
+  override fun onCreate(savedInstanceState: Bundle?) {
+    setTheme(Preferences[Preferences.Key.Theme].getResId(resources.configuration))
+    super.onCreate(savedInstanceState)
+
+    window.decorView.systemUiVisibility = window.decorView.systemUiVisibility or View.SYSTEM_UI_FLAG_LAYOUT_STABLE or
+      View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION or View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
+    addContentView(FrameLayout(this).apply { id = R.id.main_content },
+      ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT))
+
+    if (savedInstanceState == null) {
+      cursorOwner = CursorOwner()
+      supportFragmentManager.beginTransaction()
+        .add(cursorOwner, CursorOwner::class.java.name)
+        .commit()
+    } else {
+      cursorOwner = supportFragmentManager
+        .findFragmentByTag(CursorOwner::class.java.name) as CursorOwner
+    }
+
+    savedInstanceState?.getParcelableArrayList<FragmentStackItem>(STATE_FRAGMENT_STACK)
+      ?.let { fragmentStack += it }
+    if (savedInstanceState == null) {
+      replaceFragment(TabsFragment(), null)
+      if ((intent.flags and Intent.FLAG_ACTIVITY_LAUNCHED_FROM_HISTORY) == 0) {
+        handleIntent(intent)
+      }
+    }
+  }
+
+  override fun onSaveInstanceState(outState: Bundle) {
+    super.onSaveInstanceState(outState)
+    outState.putParcelableArrayList(STATE_FRAGMENT_STACK, ArrayList(fragmentStack))
+  }
+
+  override fun onBackPressed() {
+    val currentFragment = currentFragment
+    if (!(currentFragment is ScreenFragment && currentFragment.onBackPressed())) {
+      hideKeyboard()
+      if (!popFragment()) {
+        super.onBackPressed()
+      }
+    }
+  }
+
+  private fun replaceFragment(fragment: Fragment, open: Boolean?) {
+    if (open != null) {
+      currentFragment?.view?.translationZ = (if (open) Int.MIN_VALUE else Int.MAX_VALUE).toFloat()
+    }
+    supportFragmentManager
+      .beginTransaction()
+      .apply {
+        if (open != null) {
+          setCustomAnimations(if (open) R.animator.slide_in else 0,
+            if (open) R.animator.slide_in_keep else R.animator.slide_out)
+        }
+      }
+      .replace(R.id.main_content, fragment)
+      .commit()
+  }
+
+  private fun pushFragment(fragment: Fragment) {
+    currentFragment?.let { fragmentStack.add(FragmentStackItem(it::class.java.name, it.arguments,
+      supportFragmentManager.saveFragmentInstanceState(it))) }
+    replaceFragment(fragment, true)
+  }
+
+  private fun popFragment(): Boolean {
+    return fragmentStack.isNotEmpty() && run {
+      val stackItem = fragmentStack.removeAt(fragmentStack.size - 1)
+      val fragment = Class.forName(stackItem.className).newInstance() as Fragment
+      stackItem.arguments?.let(fragment::setArguments)
+      stackItem.savedState?.let(fragment::setInitialSavedState)
+      replaceFragment(fragment, false)
+      true
+    }
+  }
+
+  private fun hideKeyboard() {
+    (getSystemService(INPUT_METHOD_SERVICE) as? InputMethodManager)
+      ?.hideSoftInputFromWindow((currentFocus ?: window.decorView).windowToken, 0)
+  }
+
+  override fun onAttachFragment(fragment: Fragment) {
+    super.onAttachFragment(fragment)
+    hideKeyboard()
+  }
+
+  internal fun onToolbarCreated(toolbar: Toolbar) {
+    if (fragmentStack.isNotEmpty()) {
+      toolbar.navigationIcon = toolbar.context.getDrawableFromAttr(android.R.attr.homeAsUpIndicator)
+      toolbar.setNavigationOnClickListener { onBackPressed() }
+    }
+  }
+
+  override fun onNewIntent(intent: Intent?) {
+    super.onNewIntent(intent)
+    handleIntent(intent)
+  }
+
+  protected val Intent.packageName: String?
+    get() {
+      val uri = data
+      return when {
+        uri?.scheme == "package" || uri?.scheme == "fdroid.app" -> {
+          uri.schemeSpecificPart?.nullIfEmpty()
+        }
+        uri?.scheme == "market" && uri.host == "details" -> {
+          uri.getQueryParameter("id")?.nullIfEmpty()
+        }
+        uri != null && uri.scheme in setOf("http", "https") -> {
+          val host = uri.host.orEmpty()
+          if (host == "f-droid.org" || host.endsWith(".f-droid.org")) {
+            uri.lastPathSegment?.nullIfEmpty()
+          } else {
+            null
+          }
+        }
+        else -> {
+          null
+        }
+      }
+    }
+
+  protected fun handleSpecialIntent(specialIntent: SpecialIntent) {
+    when (specialIntent) {
+      is SpecialIntent.Updates -> {
+        if (currentFragment !is TabsFragment) {
+          fragmentStack.clear()
+          replaceFragment(TabsFragment(), true)
+        }
+        val tabsFragment = currentFragment as TabsFragment
+        tabsFragment.selectUpdates()
+      }
+      is SpecialIntent.Install -> {
+        val packageName = specialIntent.packageName
+        if (!packageName.isNullOrEmpty()) {
+          val fragment = currentFragment
+          if (fragment !is ProductFragment || fragment.packageName != packageName) {
+            pushFragment(ProductFragment(packageName))
+          }
+          specialIntent.cacheFileName?.let(::startPackageInstaller)
+        }
+        Unit
+      }
+    }::class
+  }
+
+  open fun handleIntent(intent: Intent?) {
+    when (intent?.action) {
+      Intent.ACTION_VIEW -> {
+        val packageName = intent.packageName
+        if (!packageName.isNullOrEmpty()) {
+          val fragment = currentFragment
+          if (fragment !is ProductFragment || fragment.packageName != packageName) {
+            pushFragment(ProductFragment(packageName))
+          }
+        }
+      }
+    }
+  }
+
+  internal fun startPackageInstaller(cacheFileName: String) {
+    val (uri, flags) = if (Android.sdk(24)) {
+      Pair(Cache.getReleaseUri(this, cacheFileName), Intent.FLAG_GRANT_READ_URI_PERMISSION)
+    } else {
+      Pair(Uri.fromFile(Cache.getReleaseFile(this, cacheFileName)), 0)
+    }
+    // TODO Handle deprecation
+    @Suppress("DEPRECATION")
+    startActivity(Intent(Intent.ACTION_INSTALL_PACKAGE)
+      .setDataAndType(uri, "application/vnd.android.package-archive").setFlags(flags))
+  }
+
+  internal fun navigateProduct(packageName: String) = pushFragment(ProductFragment(packageName))
+  internal fun navigateRepositories() = pushFragment(RepositoriesFragment())
+  internal fun navigatePreferences() = pushFragment(PreferencesFragment())
+  internal fun navigateAddRepository() = pushFragment(EditRepositoryFragment(null))
+  internal fun navigateRepository(repositoryId: Long) = pushFragment(RepositoryFragment(repositoryId))
+  internal fun navigateEditRepository(repositoryId: Long) = pushFragment(EditRepositoryFragment(repositoryId))
+}

src/main/kotlin/com/looker/droidify/screen/ScreenFragment.kt

@@ -0,0 +1,10 @@
+package com.looker.droidify.screen
+
+import androidx.fragment.app.Fragment
+
+open class ScreenFragment: Fragment() {
+  val screenActivity: ScreenActivity
+    get() = requireActivity() as ScreenActivity
+
+  open fun onBackPressed(): Boolean = false
+}

src/main/kotlin/com/looker/droidify/screen/ScreenshotsFragment.kt

@@ -0,0 +1,233 @@
+package com.looker.droidify.screen
+
+import android.app.Dialog
+import android.content.Context
+import android.graphics.PixelFormat
+import android.graphics.drawable.Drawable
+import android.os.Bundle
+import android.view.View
+import android.view.ViewGroup
+import android.view.WindowManager
+import android.widget.ImageView
+import androidx.core.graphics.ColorUtils
+import androidx.fragment.app.DialogFragment
+import androidx.fragment.app.FragmentManager
+import androidx.recyclerview.widget.RecyclerView
+import androidx.viewpager2.widget.MarginPageTransformer
+import androidx.viewpager2.widget.ViewPager2
+import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers
+import io.reactivex.rxjava3.core.Observable
+import io.reactivex.rxjava3.disposables.Disposable
+import io.reactivex.rxjava3.schedulers.Schedulers
+import com.looker.droidify.R
+import com.looker.droidify.database.Database
+import com.looker.droidify.entity.Product
+import com.looker.droidify.entity.Repository
+import com.looker.droidify.graphics.PaddingDrawable
+import com.looker.droidify.network.PicassoDownloader
+import com.looker.droidify.utility.RxUtils
+import com.looker.droidify.utility.extension.android.*
+import com.looker.droidify.utility.extension.resources.*
+import com.looker.droidify.widget.StableRecyclerAdapter
+
+class ScreenshotsFragment(): DialogFragment() {
+  companion object {
+    private const val EXTRA_PACKAGE_NAME = "packageName"
+    private const val EXTRA_REPOSITORY_ID = "repositoryId"
+    private const val EXTRA_IDENTIFIER = "identifier"
+
+    private const val STATE_IDENTIFIER = "identifier"
+  }
+
+  constructor(packageName: String, repositoryId: Long, identifier: String): this() {
+    arguments = Bundle().apply {
+      putString(EXTRA_PACKAGE_NAME, packageName)
+      putLong(EXTRA_REPOSITORY_ID, repositoryId)
+      putString(EXTRA_IDENTIFIER, identifier)
+    }
+  }
+
+  fun show(fragmentManager: FragmentManager) {
+    show(fragmentManager, this::class.java.name)
+  }
+
+  private var viewPager: ViewPager2? = null
+
+  private var productDisposable: Disposable? = null
+
+  override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
+    val packageName = requireArguments().getString(EXTRA_PACKAGE_NAME)!!
+    val repositoryId = requireArguments().getLong(EXTRA_REPOSITORY_ID)
+    val dialog = Dialog(requireContext(), R.style.Theme_Main_Dark)
+
+    val window = dialog.window!!
+    val decorView = window.decorView
+    val background = dialog.context.getColorFromAttr(android.R.attr.colorBackground).defaultColor
+    decorView.setBackgroundColor(background.let { ColorUtils.blendARGB(0x00ffffff and it, it, 0.9f) })
+    decorView.setPadding(0, 0, 0, 0)
+    background.let { ColorUtils.blendARGB(0x00ffffff and it, it, 0.8f) }.let {
+      window.statusBarColor = it
+      window.navigationBarColor = it
+    }
+    window.attributes = window.attributes.apply {
+      title = ScreenshotsFragment::class.java.name
+      format = PixelFormat.TRANSLUCENT
+      windowAnimations = run {
+        val typedArray = dialog.context.obtainStyledAttributes(null,
+          intArrayOf(android.R.attr.windowAnimationStyle), android.R.attr.dialogTheme, 0)
+        try {
+          typedArray.getResourceId(0, 0)
+        } finally {
+          typedArray.recycle()
+        }
+      }
+      if (Android.sdk(28)) {
+        layoutInDisplayCutoutMode = WindowManager.LayoutParams.LAYOUT_IN_DISPLAY_CUTOUT_MODE_SHORT_EDGES
+      }
+    }
+
+    val hideFlags = View.SYSTEM_UI_FLAG_HIDE_NAVIGATION or
+      View.SYSTEM_UI_FLAG_FULLSCREEN or View.SYSTEM_UI_FLAG_IMMERSIVE
+    decorView.systemUiVisibility = decorView.systemUiVisibility or View.SYSTEM_UI_FLAG_LAYOUT_STABLE or
+      View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION or View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
+    val applyHide = Runnable { decorView.systemUiVisibility = decorView.systemUiVisibility or hideFlags }
+    val handleClick = {
+      decorView.removeCallbacks(applyHide)
+      if ((decorView.systemUiVisibility and hideFlags) == hideFlags) {
+        decorView.systemUiVisibility = decorView.systemUiVisibility and hideFlags.inv()
+      } else {
+        decorView.systemUiVisibility = decorView.systemUiVisibility or hideFlags
+      }
+    }
+    decorView.postDelayed(applyHide, 2000L)
+    decorView.setOnClickListener { handleClick() }
+
+    val viewPager = ViewPager2(dialog.context)
+    viewPager.adapter = Adapter(packageName) { handleClick() }
+    viewPager.setPageTransformer(MarginPageTransformer(resources.sizeScaled(16)))
+    viewPager.viewTreeObserver.addOnGlobalLayoutListener {
+      (viewPager.adapter as Adapter).size = Pair(viewPager.width, viewPager.height)
+    }
+    dialog.addContentView(viewPager, ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT,
+      ViewGroup.LayoutParams.MATCH_PARENT))
+    this.viewPager = viewPager
+
+    var restored = false
+    productDisposable = Observable.just(Unit)
+      .concatWith(Database.observable(Database.Subject.Products))
+      .observeOn(Schedulers.io())
+      .flatMapSingle { RxUtils.querySingle { Database.ProductAdapter.get(packageName, it) } }
+      .map { Pair(it.find { it.repositoryId == repositoryId }, Database.RepositoryAdapter.get(repositoryId)) }
+      .observeOn(AndroidSchedulers.mainThread())
+      .subscribe {
+        val (product, repository) = it
+        val screenshots = product?.screenshots.orEmpty()
+        (viewPager.adapter as Adapter).update(repository, screenshots)
+        if (!restored) {
+          restored = true
+          val identifier = savedInstanceState?.getString(STATE_IDENTIFIER)
+            ?: requireArguments().getString(STATE_IDENTIFIER)
+          if (identifier != null) {
+            val index = screenshots.indexOfFirst { it.identifier == identifier }
+            if (index >= 0) {
+              viewPager.setCurrentItem(index, false)
+            }
+          }
+        }
+      }
+
+    return dialog
+  }
+
+  override fun onDestroyView() {
+    super.onDestroyView()
+
+    viewPager = null
+
+    productDisposable?.dispose()
+    productDisposable = null
+  }
+
+  override fun onSaveInstanceState(outState: Bundle) {
+    super.onSaveInstanceState(outState)
+
+    val viewPager = viewPager
+    if (viewPager != null) {
+      val identifier = (viewPager.adapter as Adapter).getCurrentIdentifier(viewPager)
+      identifier?.let { outState.putString(STATE_IDENTIFIER, it) }
+    }
+  }
+
+  private class Adapter(private val packageName: String, private val onClick: () -> Unit):
+    StableRecyclerAdapter<Adapter.ViewType, RecyclerView.ViewHolder>() {
+    enum class ViewType { SCREENSHOT }
+
+    private class ViewHolder(context: Context): RecyclerView.ViewHolder(ImageView(context)) {
+      val image: ImageView
+        get() = itemView as ImageView
+
+      val placeholder: Drawable
+
+      init {
+        itemView.layoutParams = RecyclerView.LayoutParams(RecyclerView.LayoutParams.MATCH_PARENT,
+          RecyclerView.LayoutParams.MATCH_PARENT)
+
+        val placeholder = itemView.context.getDrawableCompat(R.drawable.ic_photo_camera).mutate()
+        placeholder.setTint(itemView.context.getColorFromAttr(android.R.attr.textColorPrimary).defaultColor
+          .let { ColorUtils.blendARGB(0x00ffffff and it, it, 0.25f) })
+        this.placeholder = PaddingDrawable(placeholder, 4f)
+      }
+    }
+
+    private var repository: Repository? = null
+    private var screenshots = emptyList<Product.Screenshot>()
+
+    fun update(repository: Repository?, screenshots: List<Product.Screenshot>) {
+      this.repository = repository
+      this.screenshots = screenshots
+      notifyDataSetChanged()
+    }
+
+    var size = Pair(0, 0)
+      set(value) {
+        if (field != value) {
+          field = value
+          notifyDataSetChanged()
+        }
+      }
+
+    fun getCurrentIdentifier(viewPager: ViewPager2): String? {
+      val position = viewPager.currentItem
+      return screenshots.getOrNull(position)?.identifier
+    }
+
+    override val viewTypeClass: Class<ViewType>
+      get() = ViewType::class.java
+
+    override fun getItemCount(): Int = screenshots.size
+    override fun getItemDescriptor(position: Int): String = screenshots[position].identifier
+    override fun getItemEnumViewType(position: Int): ViewType = ViewType.SCREENSHOT
+
+    override fun onCreateViewHolder(parent: ViewGroup, viewType: ViewType): RecyclerView.ViewHolder {
+      return ViewHolder(parent.context).apply {
+        itemView.setOnClickListener { onClick() }
+      }
+    }
+
+    override fun onBindViewHolder(holder: RecyclerView.ViewHolder, position: Int) {
+      holder as ViewHolder
+      val screenshot = screenshots[position]
+      val (width, height) = size
+      if (width > 0 && height > 0) {
+        holder.image.load(PicassoDownloader.createScreenshotUri(repository!!, packageName, screenshot)) {
+          placeholder(holder.placeholder)
+          error(holder.placeholder)
+          resize(width, height)
+          centerInside()
+        }
+      } else {
+        holder.image.clear()
+      }
+    }
+  }
+}

src/main/kotlin/com/looker/droidify/screen/TabsFragment.kt

@@ -0,0 +1,612 @@
+package com.looker.droidify.screen
+
+import android.animation.ValueAnimator
+import android.content.Context
+import android.content.res.ColorStateList
+import android.graphics.Canvas
+import android.graphics.ColorFilter
+import android.graphics.Paint
+import android.graphics.PixelFormat
+import android.graphics.drawable.Drawable
+import android.os.Bundle
+import android.view.Gravity
+import android.view.LayoutInflater
+import android.view.MenuItem
+import android.view.View
+import android.view.ViewGroup
+import android.view.animation.AccelerateInterpolator
+import android.view.animation.DecelerateInterpolator
+import android.widget.FrameLayout
+import android.widget.ImageView
+import android.widget.LinearLayout
+import android.widget.SearchView
+import android.widget.TextView
+import android.widget.Toolbar
+import androidx.fragment.app.Fragment
+import androidx.recyclerview.widget.LinearLayoutManager
+import androidx.recyclerview.widget.RecyclerView
+import androidx.viewpager2.adapter.FragmentStateAdapter
+import androidx.viewpager2.widget.ViewPager2
+import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers
+import io.reactivex.rxjava3.core.Observable
+import io.reactivex.rxjava3.disposables.Disposable
+import io.reactivex.rxjava3.schedulers.Schedulers
+import com.looker.droidify.R
+import com.looker.droidify.content.Preferences
+import com.looker.droidify.database.Database
+import com.looker.droidify.entity.ProductItem
+import com.looker.droidify.service.Connection
+import com.looker.droidify.service.SyncService
+import com.looker.droidify.utility.RxUtils
+import com.looker.droidify.utility.Utils
+import com.looker.droidify.utility.extension.android.*
+import com.looker.droidify.utility.extension.resources.*
+import com.looker.droidify.widget.DividerItemDecoration
+import com.looker.droidify.widget.FocusSearchView
+import com.looker.droidify.widget.StableRecyclerAdapter
+import kotlin.math.*
+
+class TabsFragment: ScreenFragment() {
+  companion object {
+    private const val STATE_SEARCH_FOCUSED = "searchFocused"
+    private const val STATE_SEARCH_QUERY = "searchQuery"
+    private const val STATE_SHOW_SECTIONS = "showSections"
+    private const val STATE_SECTIONS = "sections"
+    private const val STATE_SECTION = "section"
+  }
+
+  private class Layout(view: View) {
+    val tabs = view.findViewById<LinearLayout>(R.id.tabs)!!
+    val sectionLayout = view.findViewById<ViewGroup>(R.id.section_layout)!!
+    val sectionChange = view.findViewById<View>(R.id.section_change)!!
+    val sectionName = view.findViewById<TextView>(R.id.section_name)!!
+    val sectionIcon = view.findViewById<ImageView>(R.id.section_icon)!!
+  }
+
+  private var searchMenuItem: MenuItem? = null
+  private var sortOrderMenu: Pair<MenuItem, List<MenuItem>>? = null
+  private var syncRepositoriesMenuItem: MenuItem? = null
+  private var layout: Layout? = null
+  private var sectionsList: RecyclerView? = null
+  private var viewPager: ViewPager2? = null
+
+  private var showSections = false
+    set(value) {
+      if (field != value) {
+        field = value
+        val layout = layout
+        layout?.tabs?.let { (0 until it.childCount)
+          .forEach { index -> it.getChildAt(index)!!.isEnabled = !value } }
+        layout?.sectionIcon?.scaleY = if (value) -1f else 1f
+        if ((sectionsList?.parent as? View)?.height ?: 0 > 0) {
+          animateSectionsList()
+        }
+      }
+    }
+
+  private var searchQuery = ""
+  private var sections = listOf<ProductItem.Section>(ProductItem.Section.All)
+  private var section: ProductItem.Section = ProductItem.Section.All
+
+  private val syncConnection = Connection(SyncService::class.java, onBind = { _, _ ->
+    viewPager?.let {
+      val source = ProductsFragment.Source.values()[it.currentItem]
+      updateUpdateNotificationBlocker(source)
+    }
+  })
+
+  private var sortOrderDisposable: Disposable? = null
+  private var categoriesDisposable: Disposable? = null
+  private var repositoriesDisposable: Disposable? = null
+  private var sectionsAnimator: ValueAnimator? = null
+
+  private var needSelectUpdates = false
+
+  private val productFragments: Sequence<ProductsFragment>
+    get() = if (host == null) emptySequence() else
+      childFragmentManager.fragments.asSequence().mapNotNull { it as? ProductsFragment }
+
+  override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View {
+    return inflater.inflate(R.layout.fragment, container, false)
+  }
+
+  override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
+    super.onViewCreated(view, savedInstanceState)
+
+    syncConnection.bind(requireContext())
+
+    val toolbar = view.findViewById<Toolbar>(R.id.toolbar)!!
+    screenActivity.onToolbarCreated(toolbar)
+    toolbar.setTitle(R.string.application_name)
+    // Move focus from SearchView to Toolbar
+    toolbar.isFocusableInTouchMode = true
+
+    val searchView = FocusSearchView(toolbar.context)
+    searchView.allowFocus = savedInstanceState?.getBoolean(STATE_SEARCH_FOCUSED) == true
+    searchView.maxWidth = Int.MAX_VALUE
+    searchView.queryHint = getString(R.string.search)
+    searchView.setOnQueryTextListener(object: SearchView.OnQueryTextListener {
+      override fun onQueryTextSubmit(query: String?): Boolean {
+        searchView.clearFocus()
+        return true
+      }
+
+      override fun onQueryTextChange(newText: String?): Boolean {
+        if (isResumed) {
+          searchQuery = newText.orEmpty()
+          productFragments.forEach { it.setSearchQuery(newText.orEmpty()) }
+        }
+        return true
+      }
+    })
+
+    toolbar.menu.apply {
+      if (Android.sdk(28) && !Android.Device.isHuaweiEmui) {
+        setGroupDividerEnabled(true)
+      }
+
+      searchMenuItem = add(0, R.id.toolbar_search, 0, R.string.search)
+        .setIcon(Utils.getToolbarIcon(toolbar.context, R.drawable.ic_search))
+        .setActionView(searchView)
+        .setShowAsActionFlags(MenuItem.SHOW_AS_ACTION_ALWAYS or MenuItem.SHOW_AS_ACTION_COLLAPSE_ACTION_VIEW)
+
+      sortOrderMenu = addSubMenu(0, 0, 0, R.string.sorting_order)
+        .setIcon(Utils.getToolbarIcon(toolbar.context, R.drawable.ic_sort))
+        .let { menu ->
+          menu.item.setShowAsActionFlags(MenuItem.SHOW_AS_ACTION_ALWAYS)
+          val items = Preferences.Key.SortOrder.default.value.values
+            .map { sortOrder -> menu
+              .add(sortOrder.order.titleResId)
+              .setOnMenuItemClickListener {
+                Preferences[Preferences.Key.SortOrder] = sortOrder
+                true
+              } }
+          menu.setGroupCheckable(0, true, true)
+          Pair(menu.item, items)
+        }
+
+      syncRepositoriesMenuItem = add(0, 0, 0, R.string.sync_repositories)
+        .setIcon(Utils.getToolbarIcon(toolbar.context, R.drawable.ic_sync))
+        .setOnMenuItemClickListener {
+          syncConnection.binder?.sync(SyncService.SyncRequest.MANUAL)
+          true
+        }
+
+      add(1, 0, 0, R.string.repositories)
+        .setOnMenuItemClickListener {
+          view.post { screenActivity.navigateRepositories() }
+          true
+        }
+
+      add(1, 0, 0, R.string.preferences)
+        .setOnMenuItemClickListener {
+          view.post { screenActivity.navigatePreferences() }
+          true
+        }
+    }
+
+    searchQuery = savedInstanceState?.getString(STATE_SEARCH_QUERY).orEmpty()
+    productFragments.forEach { it.setSearchQuery(searchQuery) }
+
+    val toolbarExtra = view.findViewById<FrameLayout>(R.id.toolbar_extra)!!
+    toolbarExtra.addView(toolbarExtra.inflate(R.layout.tabs_toolbar))
+    val layout = Layout(view)
+    this.layout = layout
+
+    layout.tabs.background = TabsBackgroundDrawable(layout.tabs.context,
+      layout.tabs.layoutDirection == View.LAYOUT_DIRECTION_RTL)
+    ProductsFragment.Source.values().forEach {
+      val tab = TextView(layout.tabs.context)
+      val selectedColor = tab.context.getColorFromAttr(android.R.attr.textColorPrimary).defaultColor
+      val normalColor = tab.context.getColorFromAttr(android.R.attr.textColorSecondary).defaultColor
+      tab.gravity = Gravity.CENTER
+      tab.typeface = TypefaceExtra.medium
+      tab.setTextColor(ColorStateList(arrayOf(intArrayOf(android.R.attr.state_selected), intArrayOf()),
+        intArrayOf(selectedColor, normalColor)))
+      tab.setTextSizeScaled(14)
+      tab.isAllCaps = true
+      tab.text = getString(it.titleResId)
+      tab.background = tab.context.getDrawableFromAttr(android.R.attr.selectableItemBackground)
+      tab.setOnClickListener { _ ->
+        setSelectedTab(it)
+        viewPager!!.setCurrentItem(it.ordinal, Utils.areAnimationsEnabled(tab.context))
+      }
+      layout.tabs.addView(tab, 0, LinearLayout.LayoutParams.MATCH_PARENT)
+      (tab.layoutParams as LinearLayout.LayoutParams).weight = 1f
+    }
+
+    showSections = savedInstanceState?.getByte(STATE_SHOW_SECTIONS)?.toInt() ?: 0 != 0
+    sections = savedInstanceState?.getParcelableArrayList<ProductItem.Section>(STATE_SECTIONS).orEmpty()
+    section = savedInstanceState?.getParcelable(STATE_SECTION) ?: ProductItem.Section.All
+    layout.sectionChange.setOnClickListener { showSections = sections
+      .any { it !is ProductItem.Section.All } && !showSections }
+
+    updateOrder()
+    sortOrderDisposable = Preferences.observable.subscribe {
+      if (it == Preferences.Key.SortOrder) {
+        updateOrder()
+      }
+    }
+
+    val content = view.findViewById<FrameLayout>(R.id.fragment_content)!!
+
+    viewPager = ViewPager2(content.context).apply {
+      id = R.id.fragment_pager
+      adapter = object: FragmentStateAdapter(this@TabsFragment) {
+        override fun getItemCount(): Int = ProductsFragment.Source.values().size
+        override fun createFragment(position: Int): Fragment = ProductsFragment(ProductsFragment
+          .Source.values()[position])
+      }
+      content.addView(this, FrameLayout.LayoutParams.MATCH_PARENT, FrameLayout.LayoutParams.MATCH_PARENT)
+      registerOnPageChangeCallback(pageChangeCallback)
+      offscreenPageLimit = 1
+    }
+
+    categoriesDisposable = Observable.just(Unit)
+      .concatWith(Database.observable(Database.Subject.Products))
+      .observeOn(Schedulers.io())
+      .flatMapSingle { RxUtils.querySingle { Database.CategoryAdapter.getAll(it) } }
+      .observeOn(AndroidSchedulers.mainThread())
+      .subscribe { setSectionsAndUpdate(it.asSequence().sorted()
+        .map(ProductItem.Section::Category).toList(), null) }
+    repositoriesDisposable = Observable.just(Unit)
+      .concatWith(Database.observable(Database.Subject.Repositories))
+      .observeOn(Schedulers.io())
+      .flatMapSingle { RxUtils.querySingle { Database.RepositoryAdapter.getAll(it) } }
+      .observeOn(AndroidSchedulers.mainThread())
+      .subscribe { setSectionsAndUpdate(null, it.asSequence().filter { it.enabled }
+        .map { ProductItem.Section.Repository(it.id, it.name) }.toList()) }
+    updateSection()
+
+    val sectionsList = RecyclerView(toolbar.context).apply {
+      id = R.id.sections_list
+      layoutManager = LinearLayoutManager(context)
+      isMotionEventSplittingEnabled = false
+      isVerticalScrollBarEnabled = false
+      setHasFixedSize(true)
+      val adapter = SectionsAdapter({ sections }) {
+        if (showSections) {
+          showSections = false
+          section = it
+          updateSection()
+        }
+      }
+      this.adapter = adapter
+      addItemDecoration(DividerItemDecoration(context, adapter::configureDivider))
+      setBackgroundColor(context.getColorFromAttr(android.R.attr.colorPrimaryDark).defaultColor)
+      elevation = resources.sizeScaled(4).toFloat()
+      content.addView(this, FrameLayout.LayoutParams.MATCH_PARENT, 0)
+      visibility = View.GONE
+    }
+    this.sectionsList = sectionsList
+
+    var lastContentHeight = -1
+    content.viewTreeObserver.addOnGlobalLayoutListener {
+      if (this.view != null) {
+        val initial = lastContentHeight <= 0
+        val contentHeight = content.height
+        if (lastContentHeight != contentHeight) {
+          lastContentHeight = contentHeight
+          if (initial) {
+            sectionsList.layoutParams.height = if (showSections) contentHeight else 0
+            sectionsList.visibility = if (showSections) View.VISIBLE else View.GONE
+            sectionsList.requestLayout()
+          } else {
+            animateSectionsList()
+          }
+        }
+      }
+    }
+  }
+
+  override fun onDestroyView() {
+    super.onDestroyView()
+
+    searchMenuItem = null
+    sortOrderMenu = null
+    syncRepositoriesMenuItem = null
+    layout = null
+    sectionsList = null
+    viewPager = null
+
+    syncConnection.unbind(requireContext())
+    sortOrderDisposable?.dispose()
+    sortOrderDisposable = null
+    categoriesDisposable?.dispose()
+    categoriesDisposable = null
+    repositoriesDisposable?.dispose()
+    repositoriesDisposable = null
+    sectionsAnimator?.cancel()
+    sectionsAnimator = null
+  }
+
+  override fun onSaveInstanceState(outState: Bundle) {
+    super.onSaveInstanceState(outState)
+
+    outState.putBoolean(STATE_SEARCH_FOCUSED, searchMenuItem?.actionView?.hasFocus() == true)
+    outState.putString(STATE_SEARCH_QUERY, searchQuery)
+    outState.putByte(STATE_SHOW_SECTIONS, if (showSections) 1 else 0)
+    outState.putParcelableArrayList(STATE_SECTIONS, ArrayList(sections))
+    outState.putParcelable(STATE_SECTION, section)
+  }
+
+  override fun onViewStateRestored(savedInstanceState: Bundle?) {
+    super.onViewStateRestored(savedInstanceState)
+
+    (searchMenuItem?.actionView as FocusSearchView).allowFocus = true
+    if (needSelectUpdates) {
+      needSelectUpdates = false
+      selectUpdatesInternal(false)
+    }
+  }
+
+  override fun onAttachFragment(childFragment: Fragment) {
+    super.onAttachFragment(childFragment)
+
+    if (view != null && childFragment is ProductsFragment) {
+      childFragment.setSearchQuery(searchQuery)
+      childFragment.setSection(section)
+      childFragment.setOrder(Preferences[Preferences.Key.SortOrder].order)
+    }
+  }
+
+  override fun onBackPressed(): Boolean {
+    return when {
+      searchMenuItem?.isActionViewExpanded == true -> {
+        searchMenuItem?.collapseActionView()
+        true
+      }
+      showSections -> {
+        showSections = false
+        true
+      }
+      else -> {
+        super.onBackPressed()
+      }
+    }
+  }
+
+  private fun setSelectedTab(source: ProductsFragment.Source) {
+    val layout = layout!!
+    (0 until layout.tabs.childCount).forEach { layout.tabs.getChildAt(it).isSelected = it == source.ordinal }
+  }
+
+  internal fun selectUpdates() = selectUpdatesInternal(true)
+
+  private fun selectUpdatesInternal(allowSmooth: Boolean) {
+    if (view != null) {
+      val viewPager = viewPager
+      viewPager?.setCurrentItem(ProductsFragment.Source.UPDATES.ordinal, allowSmooth && viewPager.isLaidOut)
+    } else {
+      needSelectUpdates = true
+    }
+  }
+
+  private fun updateUpdateNotificationBlocker(activeSource: ProductsFragment.Source) {
+    val blockerFragment = if (activeSource == ProductsFragment.Source.UPDATES) {
+      productFragments.find { it.source == activeSource }
+    } else {
+      null
+    }
+    syncConnection.binder?.setUpdateNotificationBlocker(blockerFragment)
+  }
+
+  private fun updateOrder() {
+    val order = Preferences[Preferences.Key.SortOrder].order
+    sortOrderMenu!!.second[order.ordinal].isChecked = true
+    productFragments.forEach { it.setOrder(order) }
+  }
+
+  private inline fun <reified T: ProductItem.Section> collectOldSections(list: List<T>?): List<T>? {
+    val oldList = sections.mapNotNull { it as? T }
+    return if (list == null || oldList == list) oldList else null
+  }
+
+  private fun setSectionsAndUpdate(categories: List<ProductItem.Section.Category>?,
+    repositories: List<ProductItem.Section.Repository>?) {
+    val oldCategories = collectOldSections(categories)
+    val oldRepositories = collectOldSections(repositories)
+    if (oldCategories == null || oldRepositories == null) {
+      sections = listOf(ProductItem.Section.All) +
+        (categories ?: oldCategories).orEmpty() +
+        (repositories ?: oldRepositories).orEmpty()
+      updateSection()
+    }
+  }
+
+  private fun updateSection() {
+    if (section !in sections) {
+      section = ProductItem.Section.All
+    }
+    layout?.sectionName?.text = when (val section = section) {
+      is ProductItem.Section.All -> getString(R.string.all_applications)
+      is ProductItem.Section.Category -> section.name
+      is ProductItem.Section.Repository -> section.name
+    }
+    layout?.sectionIcon?.visibility = if (sections.any { it !is ProductItem.Section.All }) View.VISIBLE else View.GONE
+    productFragments.forEach { it.setSection(section) }
+    sectionsList?.adapter?.notifyDataSetChanged()
+  }
+
+  private fun animateSectionsList() {
+    val sectionsList = sectionsList!!
+    val value = if (sectionsList.visibility != View.VISIBLE) 0f else
+      sectionsList.height.toFloat() / (sectionsList.parent as View).height
+    val target = if (showSections) 1f else 0f
+    sectionsAnimator?.cancel()
+    sectionsAnimator = null
+
+    if (value != target) {
+      sectionsAnimator = ValueAnimator.ofFloat(value, target).apply {
+        duration = (250 * abs(target - value)).toLong()
+        interpolator = if (target >= 1f) AccelerateInterpolator(2f) else DecelerateInterpolator(2f)
+        addUpdateListener {
+          val newValue = animatedValue as Float
+          sectionsList.apply {
+            val height = ((parent as View).height * newValue).toInt()
+            val visible = height > 0
+            if ((visibility == View.VISIBLE) != visible) {
+              visibility = if (visible) View.VISIBLE else View.GONE
+            }
+            if (layoutParams.height != height) {
+              layoutParams.height = height
+              requestLayout()
+            }
+          }
+          if (target <= 0f && newValue <= 0f || target >= 1f && newValue >= 1f) {
+            sectionsAnimator = null
+          }
+        }
+        start()
+      }
+    }
+  }
+
+  private val pageChangeCallback = object: ViewPager2.OnPageChangeCallback() {
+    override fun onPageScrolled(position: Int, positionOffset: Float, positionOffsetPixels: Int) {
+      val layout = layout!!
+      val fromSections = ProductsFragment.Source.values()[position].sections
+      val toSections = if (positionOffset <= 0f) fromSections else
+        ProductsFragment.Source.values()[position + 1].sections
+      val offset = if (fromSections != toSections) {
+        if (fromSections) 1f - positionOffset else positionOffset
+      } else {
+        if (fromSections) 1f else 0f
+      }
+      (layout.tabs.background as TabsBackgroundDrawable)
+        .update(position + positionOffset, layout.tabs.childCount)
+      assert(layout.sectionLayout.childCount == 1)
+      val child = layout.sectionLayout.getChildAt(0)
+      val height = child.layoutParams.height
+      assert(height > 0)
+      val currentHeight = (offset * height).roundToInt()
+      if (layout.sectionLayout.layoutParams.height != currentHeight) {
+        layout.sectionLayout.layoutParams.height = currentHeight
+        layout.sectionLayout.requestLayout()
+      }
+    }
+
+    override fun onPageSelected(position: Int) {
+      val source = ProductsFragment.Source.values()[position]
+      updateUpdateNotificationBlocker(source)
+      sortOrderMenu!!.first.isVisible = source.order
+      syncRepositoriesMenuItem!!.setShowAsActionFlags(if (!source.order ||
+        resources.configuration.screenWidthDp >= 400) MenuItem.SHOW_AS_ACTION_ALWAYS else 0)
+      setSelectedTab(source)
+      if (showSections && !source.sections) {
+        showSections = false
+      }
+    }
+
+    override fun onPageScrollStateChanged(state: Int) {
+      val source = ProductsFragment.Source.values()[viewPager!!.currentItem]
+      layout!!.sectionChange.isEnabled = state != ViewPager2.SCROLL_STATE_DRAGGING && source.sections
+      if (state == ViewPager2.SCROLL_STATE_IDLE) {
+        // onPageSelected can be called earlier than fragments created
+        updateUpdateNotificationBlocker(source)
+      }
+    }
+  }
+
+  private class TabsBackgroundDrawable(context: Context, private val rtl: Boolean): Drawable() {
+    private val height = context.resources.sizeScaled(2)
+    private val paint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
+      color = context.getColorFromAttr(android.R.attr.colorPrimary).defaultColor
+    }
+
+    private var position = 0f
+    private var total = 0
+
+    fun update(position: Float, total: Int) {
+      this.position = position
+      this.total = total
+      invalidateSelf()
+    }
+
+    override fun draw(canvas: Canvas) {
+      if (total > 0) {
+        val bounds = bounds
+        val width = bounds.width() / total.toFloat()
+        val x = width * position
+        if (rtl) {
+          canvas.drawRect(bounds.right - width - x, (bounds.bottom - height).toFloat(),
+            bounds.right - x, bounds.bottom.toFloat(), paint)
+        } else {
+          canvas.drawRect(bounds.left + x, (bounds.bottom - height).toFloat(),
+            bounds.left + x + width, bounds.bottom.toFloat(), paint)
+        }
+      }
+    }
+
+    override fun setAlpha(alpha: Int) = Unit
+    override fun setColorFilter(colorFilter: ColorFilter?) = Unit
+    override fun getOpacity(): Int = PixelFormat.TRANSLUCENT
+  }
+
+  private class SectionsAdapter(private val sections: () -> List<ProductItem.Section>,
+    private val onClick: (ProductItem.Section) -> Unit): StableRecyclerAdapter<SectionsAdapter.ViewType,
+    RecyclerView.ViewHolder>() {
+    enum class ViewType { SECTION }
+
+    private class SectionViewHolder(context: Context): RecyclerView.ViewHolder(TextView(context)) {
+      val title: TextView
+        get() = itemView as TextView
+
+      init {
+        itemView as TextView
+        itemView.gravity = Gravity.CENTER_VERTICAL
+        itemView.resources.sizeScaled(16).let { itemView.setPadding(it, 0, it, 0) }
+        itemView.setTextColor(context.getColorFromAttr(android.R.attr.textColorPrimary))
+        itemView.setTextSizeScaled(16)
+        itemView.background = context.getDrawableFromAttr(android.R.attr.selectableItemBackground)
+        itemView.layoutParams = RecyclerView.LayoutParams(RecyclerView.LayoutParams.MATCH_PARENT,
+          itemView.resources.sizeScaled(48))
+      }
+    }
+
+    fun configureDivider(context: Context, position: Int, configuration: DividerItemDecoration.Configuration) {
+      val currentSection = sections()[position]
+      val nextSection = sections().getOrNull(position + 1)
+      when {
+        nextSection != null && currentSection.javaClass != nextSection.javaClass -> {
+          val padding = context.resources.sizeScaled(16)
+          configuration.set(true, false, padding, padding)
+        }
+        else -> {
+          configuration.set(false, false, 0, 0)
+        }
+      }
+    }
+
+    override val viewTypeClass: Class<ViewType>
+      get() = ViewType::class.java
+
+    override fun getItemCount(): Int = sections().size
+    override fun getItemDescriptor(position: Int): String = sections()[position].toString()
+    override fun getItemEnumViewType(position: Int): ViewType = ViewType.SECTION
+
+    override fun onCreateViewHolder(parent: ViewGroup, viewType: ViewType): RecyclerView.ViewHolder {
+      return SectionViewHolder(parent.context).apply {
+        itemView.setOnClickListener { onClick(sections()[adapterPosition]) }
+      }
+    }
+
+    override fun onBindViewHolder(holder: RecyclerView.ViewHolder, position: Int) {
+      holder as SectionViewHolder
+      val section = sections()[position]
+      val previousSection = sections().getOrNull(position - 1)
+      val nextSection = sections().getOrNull(position + 1)
+      val margin = holder.itemView.resources.sizeScaled(8)
+      val layoutParams = holder.itemView.layoutParams as RecyclerView.LayoutParams
+      layoutParams.topMargin = if (previousSection == null ||
+        section.javaClass != previousSection.javaClass) margin else 0
+      layoutParams.bottomMargin = if (nextSection == null ||
+        section.javaClass != nextSection.javaClass) margin else 0
+      holder.title.text = when (section) {
+        is ProductItem.Section.All -> holder.itemView.resources.getString(R.string.all_applications)
+        is ProductItem.Section.Category -> section.name
+        is ProductItem.Section.Repository -> section.name
+      }
+    }
+  }
+}

src/main/kotlin/com/looker/droidify/service/Connection.kt

@@ -0,0 +1,41 @@
+package com.looker.droidify.service
+
+import android.content.ComponentName
+import android.content.Context
+import android.content.Intent
+import android.content.ServiceConnection
+import android.os.IBinder
+
+class Connection<B: IBinder, S: ConnectionService<B>>(private val serviceClass: Class<S>,
+  private val onBind: ((Connection<B, S>, B) -> Unit)? = null,
+  private val onUnbind: ((Connection<B, S>, B) -> Unit)? = null): ServiceConnection {
+  var binder: B? = null
+    private set
+
+  private fun handleUnbind() {
+    binder?.let {
+      binder = null
+      onUnbind?.invoke(this, it)
+    }
+  }
+
+  override fun onServiceConnected(componentName: ComponentName, binder: IBinder) {
+    @Suppress("UNCHECKED_CAST")
+    binder as B
+    this.binder = binder
+    onBind?.invoke(this, binder)
+  }
+
+  override fun onServiceDisconnected(componentName: ComponentName) {
+    handleUnbind()
+  }
+
+  fun bind(context: Context) {
+    context.bindService(Intent(context, serviceClass), this, Context.BIND_AUTO_CREATE)
+  }
+
+  fun unbind(context: Context) {
+    context.unbindService(this)
+    handleUnbind()
+  }
+}

src/main/kotlin/com/looker/droidify/service/ConnectionService.kt

@@ -0,0 +1,19 @@
+package com.looker.droidify.service
+
+import android.app.Service
+import android.content.Intent
+import android.os.IBinder
+import com.looker.droidify.utility.extension.android.*
+
+abstract class ConnectionService<T: IBinder>: Service() {
+  abstract override fun onBind(intent: Intent): T
+
+  fun startSelf() {
+    val intent = Intent(this, this::class.java)
+    if (Android.sdk(26)) {
+      startForegroundService(intent)
+    } else {
+      startService(intent)
+    }
+  }
+}

src/main/kotlin/com/looker/droidify/service/DownloadService.kt

@@ -0,0 +1,369 @@
+package com.looker.droidify.service
+
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.app.PendingIntent
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.net.Uri
+import android.view.ContextThemeWrapper
+import androidx.core.app.NotificationCompat
+import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers
+import io.reactivex.rxjava3.core.Observable
+import io.reactivex.rxjava3.disposables.Disposable
+import io.reactivex.rxjava3.subjects.PublishSubject
+import com.looker.droidify.BuildConfig
+import com.looker.droidify.Common
+import com.looker.droidify.MainActivity
+import com.looker.droidify.R
+import com.looker.droidify.content.Cache
+import com.looker.droidify.entity.Release
+import com.looker.droidify.entity.Repository
+import com.looker.droidify.network.Downloader
+import com.looker.droidify.utility.Utils
+import com.looker.droidify.utility.extension.android.*
+import com.looker.droidify.utility.extension.resources.*
+import com.looker.droidify.utility.extension.text.*
+import java.io.File
+import java.security.MessageDigest
+import java.util.concurrent.TimeUnit
+import kotlin.math.*
+
+class DownloadService: ConnectionService<DownloadService.Binder>() {
+  companion object {
+    private const val ACTION_OPEN = "${BuildConfig.APPLICATION_ID}.intent.action.OPEN"
+    private const val ACTION_INSTALL = "${BuildConfig.APPLICATION_ID}.intent.action.INSTALL"
+    private const val ACTION_CANCEL = "${BuildConfig.APPLICATION_ID}.intent.action.CANCEL"
+    private const val EXTRA_CACHE_FILE_NAME = "${BuildConfig.APPLICATION_ID}.intent.extra.CACHE_FILE_NAME"
+
+    private val downloadingSubject = PublishSubject.create<State.Downloading>()
+  }
+
+  class Receiver: BroadcastReceiver() {
+    override fun onReceive(context: Context, intent: Intent) {
+      val action = intent.action.orEmpty()
+      when {
+        action.startsWith("$ACTION_OPEN.") -> {
+          val packageName = action.substring(ACTION_OPEN.length + 1)
+          context.startActivity(Intent(context, MainActivity::class.java)
+            .setAction(Intent.ACTION_VIEW).setData(Uri.parse("package:$packageName"))
+            .setFlags(Intent.FLAG_ACTIVITY_NEW_TASK))
+        }
+        action.startsWith("$ACTION_INSTALL.") -> {
+          val packageName = action.substring(ACTION_INSTALL.length + 1)
+          val cacheFileName = intent.getStringExtra(EXTRA_CACHE_FILE_NAME)
+          context.startActivity(Intent(context, MainActivity::class.java)
+            .setAction(MainActivity.ACTION_INSTALL).setData(Uri.parse("package:$packageName"))
+            .putExtra(MainActivity.EXTRA_CACHE_FILE_NAME, cacheFileName)
+            .setFlags(Intent.FLAG_ACTIVITY_NEW_TASK))
+        }
+      }
+    }
+  }
+
+  sealed class State(val packageName: String, val name: String) {
+    class Pending(packageName: String, name: String): State(packageName, name)
+    class Connecting(packageName: String, name: String): State(packageName, name)
+    class Downloading(packageName: String, name: String, val read: Long, val total: Long?): State(packageName, name)
+    class Success(packageName: String, name: String, val release: Release,
+      val consume: () -> Unit): State(packageName, name)
+    class Error(packageName: String, name: String): State(packageName, name)
+    class Cancel(packageName: String, name: String): State(packageName, name)
+  }
+
+  private val stateSubject = PublishSubject.create<State>()
+
+  private class Task(val packageName: String, val name: String, val release: Release,
+    val url: String, val authentication: String) {
+    val notificationTag: String
+      get() = "download-$packageName"
+  }
+
+  private data class CurrentTask(val task: Task, val disposable: Disposable, val lastState: State)
+
+  private var started = false
+  private val tasks = mutableListOf<Task>()
+  private var currentTask: CurrentTask? = null
+
+  inner class Binder: android.os.Binder() {
+    fun events(packageName: String): Observable<State> {
+      return stateSubject.filter { it.packageName == packageName }
+    }
+
+    fun enqueue(packageName: String, name: String, repository: Repository, release: Release) {
+      val task = Task(packageName, name, release, release.getDownloadUrl(repository), repository.authentication)
+      if (Cache.getReleaseFile(this@DownloadService, release.cacheFileName).exists()) {
+        publishSuccess(task)
+      } else {
+        cancelTasks(packageName)
+        cancelCurrentTask(packageName)
+        notificationManager.cancel(task.notificationTag, Common.NOTIFICATION_ID_DOWNLOADING)
+        tasks += task
+        if (currentTask == null) {
+          handleDownload()
+        } else {
+          stateSubject.onNext(State.Pending(packageName, name))
+        }
+      }
+    }
+
+    fun cancel(packageName: String) {
+      cancelTasks(packageName)
+      cancelCurrentTask(packageName)
+      handleDownload()
+    }
+
+    fun getState(packageName: String): State? = currentTask
+      ?.let { if (it.task.packageName == packageName) it.lastState else null }
+      ?: tasks.find { it.packageName == packageName }?.let { State.Pending(it.packageName, it.name) }
+  }
+
+  private val binder = Binder()
+  override fun onBind(intent: Intent): Binder = binder
+
+  private var downloadingDisposable: Disposable? = null
+
+  override fun onCreate() {
+    super.onCreate()
+
+    if (Android.sdk(26)) {
+      NotificationChannel(Common.NOTIFICATION_CHANNEL_DOWNLOADING,
+        getString(R.string.downloading), NotificationManager.IMPORTANCE_LOW)
+        .apply { setShowBadge(false) }
+        .let(notificationManager::createNotificationChannel)
+    }
+
+    downloadingDisposable = downloadingSubject
+      .sample(500L, TimeUnit.MILLISECONDS, AndroidSchedulers.mainThread())
+      .subscribe { publishForegroundState(false, it) }
+  }
+
+  override fun onDestroy() {
+    super.onDestroy()
+
+    downloadingDisposable?.dispose()
+    downloadingDisposable = null
+    cancelTasks(null)
+    cancelCurrentTask(null)
+  }
+
+  override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+    if (intent?.action == ACTION_CANCEL) {
+      currentTask?.let { binder.cancel(it.task.packageName) }
+    }
+    return START_NOT_STICKY
+  }
+
+  private fun cancelTasks(packageName: String?) {
+    tasks.removeAll {
+      (packageName == null || it.packageName == packageName) && run {
+        stateSubject.onNext(State.Cancel(it.packageName, it.name))
+        true
+      }
+    }
+  }
+
+  private fun cancelCurrentTask(packageName: String?) {
+    currentTask?.let {
+      if (packageName == null || it.task.packageName == packageName) {
+        currentTask = null
+        stateSubject.onNext(State.Cancel(it.task.packageName, it.task.name))
+        it.disposable.dispose()
+      }
+    }
+  }
+
+  private enum class ValidationError { INTEGRITY, FORMAT, METADATA, SIGNATURE, PERMISSIONS }
+
+  private sealed class ErrorType {
+    object Network: ErrorType()
+    object Http: ErrorType()
+    class Validation(val validateError: ValidationError): ErrorType()
+  }
+
+  private fun showNotificationError(task: Task, errorType: ErrorType) {
+    notificationManager.notify(task.notificationTag, Common.NOTIFICATION_ID_DOWNLOADING, NotificationCompat
+      .Builder(this, Common.NOTIFICATION_CHANNEL_DOWNLOADING)
+      .setAutoCancel(true)
+      .setSmallIcon(android.R.drawable.stat_sys_warning)
+      .setColor(ContextThemeWrapper(this, R.style.Theme_Main_Light)
+        .getColorFromAttr(android.R.attr.colorAccent).defaultColor)
+      .setContentIntent(PendingIntent.getBroadcast(this, 0, Intent(this, Receiver::class.java)
+        .setAction("$ACTION_OPEN.${task.packageName}"), PendingIntent.FLAG_UPDATE_CURRENT))
+      .apply {
+        when (errorType) {
+          is ErrorType.Network -> {
+            setContentTitle(getString(R.string.could_not_download_FORMAT, task.name))
+            setContentText(getString(R.string.network_error_DESC))
+          }
+          is ErrorType.Http -> {
+            setContentTitle(getString(R.string.could_not_download_FORMAT, task.name))
+            setContentText(getString(R.string.http_error_DESC))
+          }
+          is ErrorType.Validation -> {
+            setContentTitle(getString(R.string.could_not_validate_FORMAT, task.name))
+            setContentText(getString(when (errorType.validateError) {
+              ValidationError.INTEGRITY -> R.string.integrity_check_error_DESC
+              ValidationError.FORMAT -> R.string.file_format_error_DESC
+              ValidationError.METADATA -> R.string.invalid_metadata_error_DESC
+              ValidationError.SIGNATURE -> R.string.invalid_signature_error_DESC
+              ValidationError.PERMISSIONS -> R.string.invalid_permissions_error_DESC
+            }))
+          }
+        }::class
+      }
+      .build())
+  }
+
+  private fun showNotificationInstall(task: Task) {
+    notificationManager.notify(task.notificationTag, Common.NOTIFICATION_ID_DOWNLOADING, NotificationCompat
+      .Builder(this, Common.NOTIFICATION_CHANNEL_DOWNLOADING)
+      .setAutoCancel(true)
+      .setSmallIcon(android.R.drawable.stat_sys_download_done)
+      .setColor(ContextThemeWrapper(this, R.style.Theme_Main_Light)
+        .getColorFromAttr(android.R.attr.colorAccent).defaultColor)
+      .setContentIntent(PendingIntent.getBroadcast(this, 0, Intent(this, Receiver::class.java)
+        .setAction("$ACTION_INSTALL.${task.packageName}")
+        .putExtra(EXTRA_CACHE_FILE_NAME, task.release.cacheFileName), PendingIntent.FLAG_UPDATE_CURRENT))
+      .setContentTitle(getString(R.string.downloaded_FORMAT, task.name))
+      .setContentText(getString(R.string.tap_to_install_DESC))
+      .build())
+  }
+
+  private fun publishSuccess(task: Task) {
+    var consumed = false
+    stateSubject.onNext(State.Success(task.packageName, task.name, task.release) { consumed = true })
+    if (!consumed) {
+      showNotificationInstall(task)
+    }
+  }
+
+  private fun validatePackage(task: Task, file: File): ValidationError? {
+    val hash = try {
+      val hashType = task.release.hashType.nullIfEmpty() ?: "SHA256"
+      val digest = MessageDigest.getInstance(hashType)
+      file.inputStream().use {
+        val bytes = ByteArray(8 * 1024)
+        generateSequence { it.read(bytes) }.takeWhile { it >= 0 }.forEach { digest.update(bytes, 0, it) }
+        digest.digest().hex()
+      }
+    } catch (e: Exception) {
+      ""
+    }
+    return if (hash.isEmpty() || hash != task.release.hash) {
+      ValidationError.INTEGRITY
+    } else {
+      val packageInfo = try {
+        packageManager.getPackageArchiveInfo(file.path, Android.PackageManager.signaturesFlag)
+      } catch (e: Exception) {
+        e.printStackTrace()
+        null
+      }
+      if (packageInfo == null) {
+        ValidationError.FORMAT
+      } else if (packageInfo.packageName != task.packageName ||
+        packageInfo.versionCodeCompat != task.release.versionCode) {
+        ValidationError.METADATA
+      } else {
+        val signature = packageInfo.singleSignature?.let(Utils::calculateHash).orEmpty()
+        if (signature.isEmpty() || signature != task.release.signature) {
+          ValidationError.SIGNATURE
+        } else {
+          val permissions = packageInfo.permissions?.asSequence().orEmpty().map { it.name }.toSet()
+          if (!task.release.permissions.containsAll(permissions)) {
+            ValidationError.PERMISSIONS
+          } else {
+            null
+          }
+        }
+      }
+    }
+  }
+
+  private val stateNotificationBuilder by lazy { NotificationCompat
+    .Builder(this, Common.NOTIFICATION_CHANNEL_DOWNLOADING)
+    .setSmallIcon(android.R.drawable.stat_sys_download)
+    .setColor(ContextThemeWrapper(this, R.style.Theme_Main_Light)
+      .getColorFromAttr(android.R.attr.colorAccent).defaultColor)
+    .addAction(0, getString(R.string.cancel), PendingIntent.getService(this, 0,
+      Intent(this, this::class.java).setAction(ACTION_CANCEL), PendingIntent.FLAG_UPDATE_CURRENT)) }
+
+  private fun publishForegroundState(force: Boolean, state: State) {
+    if (force || currentTask != null) {
+      currentTask = currentTask?.copy(lastState = state)
+      startForeground(Common.NOTIFICATION_ID_SYNCING, stateNotificationBuilder.apply {
+        when (state) {
+          is State.Connecting -> {
+            setContentTitle(getString(R.string.downloading_FORMAT, state.name))
+            setContentText(getString(R.string.connecting))
+            setProgress(1, 0, true)
+          }
+          is State.Downloading -> {
+            setContentTitle(getString(R.string.downloading_FORMAT, state.name))
+            if (state.total != null) {
+              setContentText("${state.read.formatSize()} / ${state.total.formatSize()}")
+              setProgress(100, (100f * state.read / state.total).roundToInt(), false)
+            } else {
+              setContentText(state.read.formatSize())
+              setProgress(0, 0, true)
+            }
+          }
+          is State.Pending, is State.Success, is State.Error, is State.Cancel -> {
+            throw IllegalStateException()
+          }
+        }::class
+      }.build())
+      stateSubject.onNext(state)
+    }
+  }
+
+  private fun handleDownload() {
+    if (currentTask == null) {
+      if (tasks.isNotEmpty()) {
+        val task = tasks.removeAt(0)
+        if (!started) {
+          started = true
+          startSelf()
+        }
+        val initialState = State.Connecting(task.packageName, task.name)
+        stateNotificationBuilder.setWhen(System.currentTimeMillis())
+        publishForegroundState(true, initialState)
+        val partialReleaseFile = Cache.getPartialReleaseFile(this, task.release.cacheFileName)
+        lateinit var disposable: Disposable
+        disposable = Downloader
+          .download(task.url, partialReleaseFile, "", "", task.authentication) { read, total ->
+            if (!disposable.isDisposed) {
+              downloadingSubject.onNext(State.Downloading(task.packageName, task.name, read, total))
+            }
+          }
+          .observeOn(AndroidSchedulers.mainThread())
+          .subscribe { result, throwable ->
+            currentTask = null
+            throwable?.printStackTrace()
+            if (result == null || !result.success) {
+              showNotificationError(task, if (result != null) ErrorType.Http else ErrorType.Network)
+              stateSubject.onNext(State.Error(task.packageName, task.name))
+            } else {
+              val validationError = validatePackage(task, partialReleaseFile)
+              if (validationError == null) {
+                val releaseFile = Cache.getReleaseFile(this, task.release.cacheFileName)
+                partialReleaseFile.renameTo(releaseFile)
+                publishSuccess(task)
+              } else {
+                partialReleaseFile.delete()
+                showNotificationError(task, ErrorType.Validation(validationError))
+                stateSubject.onNext(State.Error(task.packageName, task.name))
+              }
+            }
+            handleDownload()
+          }
+        currentTask = CurrentTask(task, disposable, initialState)
+      } else if (started) {
+        started = false
+        stopForeground(true)
+        stopSelf()
+      }
+    }
+  }
+}

src/main/kotlin/com/looker/droidify/service/SyncService.kt

@@ -0,0 +1,420 @@
+package com.looker.droidify.service
+
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.app.PendingIntent
+import android.app.job.JobParameters
+import android.app.job.JobService
+import android.content.Intent
+import android.graphics.Color
+import android.text.SpannableStringBuilder
+import android.text.style.ForegroundColorSpan
+import android.view.ContextThemeWrapper
+import androidx.core.app.NotificationCompat
+import androidx.fragment.app.Fragment
+import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers
+import io.reactivex.rxjava3.core.Observable
+import io.reactivex.rxjava3.disposables.Disposable
+import io.reactivex.rxjava3.schedulers.Schedulers
+import io.reactivex.rxjava3.subjects.PublishSubject
+import com.looker.droidify.BuildConfig
+import com.looker.droidify.Common
+import com.looker.droidify.MainActivity
+import com.looker.droidify.R
+import com.looker.droidify.content.Preferences
+import com.looker.droidify.database.Database
+import com.looker.droidify.entity.ProductItem
+import com.looker.droidify.entity.Repository
+import com.looker.droidify.index.RepositoryUpdater
+import com.looker.droidify.utility.RxUtils
+import com.looker.droidify.utility.extension.android.*
+import com.looker.droidify.utility.extension.resources.*
+import com.looker.droidify.utility.extension.text.*
+import java.lang.ref.WeakReference
+import java.util.concurrent.TimeUnit
+import kotlin.math.*
+
+class SyncService: ConnectionService<SyncService.Binder>() {
+  companion object {
+    private const val ACTION_CANCEL = "${BuildConfig.APPLICATION_ID}.intent.action.CANCEL"
+
+    private val stateSubject = PublishSubject.create<State>()
+    private val finishSubject = PublishSubject.create<Unit>()
+  }
+
+  private sealed class State {
+    data class Connecting(val name: String): State()
+    data class Syncing(val name: String, val stage: RepositoryUpdater.Stage,
+      val read: Long, val total: Long?): State()
+    object Finishing: State()
+  }
+
+  private class Task(val repositoryId: Long, val manual: Boolean)
+  private data class CurrentTask(val task: Task?, val disposable: Disposable,
+    val hasUpdates: Boolean, val lastState: State)
+  private enum class Started { NO, AUTO, MANUAL }
+
+  private var started = Started.NO
+  private val tasks = mutableListOf<Task>()
+  private var currentTask: CurrentTask? = null
+
+  private var updateNotificationBlockerFragment: WeakReference<Fragment>? = null
+
+  enum class SyncRequest { AUTO, MANUAL, FORCE }
+
+  inner class Binder: android.os.Binder() {
+    val finish: Observable<Unit>
+      get() = finishSubject
+
+    private fun sync(ids: List<Long>, request: SyncRequest) {
+      val cancelledTask = cancelCurrentTask { request == SyncRequest.FORCE && it.task?.repositoryId in ids }
+      cancelTasks { !it.manual && it.repositoryId in ids }
+      val currentIds = tasks.asSequence().map { it.repositoryId }.toSet()
+      val manual = request != SyncRequest.AUTO
+      tasks += ids.asSequence().filter { it !in currentIds &&
+        it != currentTask?.task?.repositoryId }.map { Task(it, manual) }
+      handleNextTask(cancelledTask?.hasUpdates == true)
+      if (request != SyncRequest.AUTO && started == Started.AUTO) {
+        started = Started.MANUAL
+        startSelf()
+        handleSetStarted()
+        currentTask?.lastState?.let { publishForegroundState(true, it) }
+      }
+    }
+
+    fun sync(request: SyncRequest) {
+      val ids = Database.RepositoryAdapter.getAll(null)
+        .asSequence().filter { it.enabled }.map { it.id }.toList()
+      sync(ids, request)
+    }
+
+    fun sync(repository: Repository) {
+      if (repository.enabled) {
+        sync(listOf(repository.id), SyncRequest.FORCE)
+      }
+    }
+
+    fun cancelAuto(): Boolean {
+      val removed = cancelTasks { !it.manual }
+      val currentTask = cancelCurrentTask { it.task?.manual == false }
+      handleNextTask(currentTask?.hasUpdates == true)
+      return removed || currentTask != null
+    }
+
+    fun setUpdateNotificationBlocker(fragment: Fragment?) {
+      updateNotificationBlockerFragment = fragment?.let(::WeakReference)
+      if (fragment != null) {
+        notificationManager.cancel(Common.NOTIFICATION_ID_UPDATES)
+      }
+    }
+
+    fun setEnabled(repository: Repository, enabled: Boolean): Boolean {
+      Database.RepositoryAdapter.put(repository.enable(enabled))
+      if (enabled) {
+        if (repository.id != currentTask?.task?.repositoryId && !tasks.any { it.repositoryId == repository.id }) {
+          tasks += Task(repository.id, true)
+          handleNextTask(false)
+        }
+      } else {
+        cancelTasks { it.repositoryId == repository.id }
+        val cancelledTask = cancelCurrentTask { it.task?.repositoryId == repository.id }
+        handleNextTask(cancelledTask?.hasUpdates == true)
+      }
+      return true
+    }
+
+    fun isCurrentlySyncing(repositoryId: Long): Boolean {
+      return currentTask?.task?.repositoryId == repositoryId
+    }
+
+    fun deleteRepository(repositoryId: Long): Boolean {
+      val repository = Database.RepositoryAdapter.get(repositoryId)
+      return repository != null && run {
+        setEnabled(repository, false)
+        Database.RepositoryAdapter.markAsDeleted(repository.id)
+        true
+      }
+    }
+  }
+
+  private val binder = Binder()
+  override fun onBind(intent: Intent): Binder = binder
+
+  private var stateDisposable: Disposable? = null
+
+  override fun onCreate() {
+    super.onCreate()
+
+    if (Android.sdk(26)) {
+      NotificationChannel(Common.NOTIFICATION_CHANNEL_SYNCING,
+        getString(R.string.syncing), NotificationManager.IMPORTANCE_LOW)
+        .apply { setShowBadge(false) }
+        .let(notificationManager::createNotificationChannel)
+      NotificationChannel(Common.NOTIFICATION_CHANNEL_UPDATES,
+        getString(R.string.updates), NotificationManager.IMPORTANCE_LOW)
+        .let(notificationManager::createNotificationChannel)
+    }
+
+    stateDisposable = stateSubject
+      .sample(500L, TimeUnit.MILLISECONDS, AndroidSchedulers.mainThread())
+      .subscribe { publishForegroundState(false, it) }
+  }
+
+  override fun onDestroy() {
+    super.onDestroy()
+
+    stateDisposable?.dispose()
+    stateDisposable = null
+    cancelTasks { true }
+    cancelCurrentTask { true }
+  }
+
+  override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+    if (intent?.action == ACTION_CANCEL) {
+      tasks.clear()
+      val cancelledTask = cancelCurrentTask { it.task != null }
+      handleNextTask(cancelledTask?.hasUpdates == true)
+    }
+    return START_NOT_STICKY
+  }
+
+  private fun cancelTasks(condition: (Task) -> Boolean): Boolean {
+    return tasks.removeAll(condition)
+  }
+
+  private fun cancelCurrentTask(condition: ((CurrentTask) -> Boolean)): CurrentTask? {
+    return currentTask?.let {
+      if (condition(it)) {
+        currentTask = null
+        it.disposable.dispose()
+        RepositoryUpdater.await()
+        it
+      } else {
+        null
+      }
+    }
+  }
+
+  private fun showNotificationError(repository: Repository, exception: Exception) {
+    notificationManager.notify("repository-${repository.id}", Common.NOTIFICATION_ID_SYNCING, NotificationCompat
+      .Builder(this, Common.NOTIFICATION_CHANNEL_SYNCING)
+      .setSmallIcon(android.R.drawable.stat_sys_warning)
+      .setColor(ContextThemeWrapper(this, R.style.Theme_Main_Light)
+        .getColorFromAttr(android.R.attr.colorAccent).defaultColor)
+      .setContentTitle(getString(R.string.could_not_sync_FORMAT, repository.name))
+      .setContentText(getString(when (exception) {
+        is RepositoryUpdater.UpdateException -> when (exception.errorType) {
+          RepositoryUpdater.ErrorType.NETWORK -> R.string.network_error_DESC
+          RepositoryUpdater.ErrorType.HTTP -> R.string.http_error_DESC
+          RepositoryUpdater.ErrorType.VALIDATION -> R.string.validation_index_error_DESC
+          RepositoryUpdater.ErrorType.PARSING -> R.string.parsing_index_error_DESC
+        }
+        else -> R.string.unknown_error_DESC
+      }))
+      .build())
+  }
+
+  private val stateNotificationBuilder by lazy { NotificationCompat
+    .Builder(this, Common.NOTIFICATION_CHANNEL_SYNCING)
+    .setSmallIcon(R.drawable.ic_sync)
+    .setColor(ContextThemeWrapper(this, R.style.Theme_Main_Light)
+      .getColorFromAttr(android.R.attr.colorAccent).defaultColor)
+    .addAction(0, getString(R.string.cancel), PendingIntent.getService(this, 0,
+      Intent(this, this::class.java).setAction(ACTION_CANCEL), PendingIntent.FLAG_UPDATE_CURRENT)) }
+
+  private fun publishForegroundState(force: Boolean, state: State) {
+    if (force || currentTask?.lastState != state) {
+      currentTask = currentTask?.copy(lastState = state)
+      if (started == Started.MANUAL) {
+        startForeground(Common.NOTIFICATION_ID_SYNCING, stateNotificationBuilder.apply {
+          when (state) {
+            is State.Connecting -> {
+              setContentTitle(getString(R.string.syncing_FORMAT, state.name))
+              setContentText(getString(R.string.connecting))
+              setProgress(0, 0, true)
+            }
+            is State.Syncing -> {
+              setContentTitle(getString(R.string.syncing_FORMAT, state.name))
+              when (state.stage) {
+                RepositoryUpdater.Stage.DOWNLOAD -> {
+                  if (state.total != null) {
+                    setContentText("${state.read.formatSize()} / ${state.total.formatSize()}")
+                    setProgress(100, (100f * state.read / state.total).roundToInt(), false)
+                  } else {
+                    setContentText(state.read.formatSize())
+                    setProgress(0, 0, true)
+                  }
+                }
+                RepositoryUpdater.Stage.PROCESS -> {
+                  val progress = state.total?.let { 100f * state.read / it }?.roundToInt()
+                  setContentText(getString(R.string.processing_FORMAT, "${progress ?: 0}%"))
+                  setProgress(100, progress ?: 0, progress == null)
+                }
+                RepositoryUpdater.Stage.MERGE -> {
+                  val progress = (100f * state.read / (state.total ?: state.read)).roundToInt()
+                  setContentText(getString(R.string.merging_FORMAT, "${state.read} / ${state.total ?: state.read}"))
+                  setProgress(100, progress, false)
+                }
+                RepositoryUpdater.Stage.COMMIT -> {
+                  setContentText(getString(R.string.saving_details))
+                  setProgress(0, 0, true)
+                }
+              }
+            }
+            is State.Finishing -> {
+              setContentTitle(getString(R.string.syncing))
+              setContentText(null)
+              setProgress(0, 0, true)
+            }
+          }::class
+        }.build())
+      }
+    }
+  }
+
+  private fun handleSetStarted() {
+    stateNotificationBuilder.setWhen(System.currentTimeMillis())
+  }
+
+  private fun handleNextTask(hasUpdates: Boolean) {
+    if (currentTask == null) {
+      if (tasks.isNotEmpty()) {
+        val task = tasks.removeAt(0)
+        val repository = Database.RepositoryAdapter.get(task.repositoryId)
+        if (repository != null && repository.enabled) {
+          val lastStarted = started
+          val newStarted = if (task.manual || lastStarted == Started.MANUAL) Started.MANUAL else Started.AUTO
+          started = newStarted
+          if (newStarted == Started.MANUAL && lastStarted != Started.MANUAL) {
+            startSelf()
+            handleSetStarted()
+          }
+          val initialState = State.Connecting(repository.name)
+          publishForegroundState(true, initialState)
+          val unstable = Preferences[Preferences.Key.UpdateUnstable]
+          lateinit var disposable: Disposable
+          disposable = RepositoryUpdater
+            .update(repository, unstable) { stage, progress, total ->
+              if (!disposable.isDisposed) {
+                stateSubject.onNext(State.Syncing(repository.name, stage, progress, total))
+              }
+            }
+            .observeOn(AndroidSchedulers.mainThread())
+            .subscribe { result, throwable ->
+              currentTask = null
+              throwable?.printStackTrace()
+              if (throwable != null && task.manual) {
+                showNotificationError(repository, throwable as Exception)
+              }
+              handleNextTask(result == true || hasUpdates)
+            }
+          currentTask = CurrentTask(task, disposable, hasUpdates, initialState)
+        } else {
+          handleNextTask(hasUpdates)
+        }
+      } else if (started != Started.NO) {
+        if (hasUpdates && Preferences[Preferences.Key.UpdateNotify]) {
+          val disposable = RxUtils
+            .querySingle { Database.ProductAdapter
+              .query(true, true, "", ProductItem.Section.All, ProductItem.Order.NAME, it)
+              .use { it.asSequence().map(Database.ProductAdapter::transformItem).toList() } }
+            .subscribeOn(Schedulers.io())
+            .observeOn(AndroidSchedulers.mainThread())
+            .subscribe { result, throwable ->
+              throwable?.printStackTrace()
+              currentTask = null
+              handleNextTask(false)
+              val blocked = updateNotificationBlockerFragment?.get()?.isAdded == true
+              if (!blocked && result != null && result.isNotEmpty()) {
+                displayUpdatesNotification(result)
+              }
+            }
+          currentTask = CurrentTask(null, disposable, true, State.Finishing)
+        } else {
+          finishSubject.onNext(Unit)
+          val needStop = started == Started.MANUAL
+          started = Started.NO
+          if (needStop) {
+            stopForeground(true)
+            stopSelf()
+          }
+        }
+      }
+    }
+  }
+
+  private fun displayUpdatesNotification(productItems: List<ProductItem>) {
+    val maxUpdates = 5
+    fun <T> T.applyHack(callback: T.() -> Unit): T = apply(callback)
+    notificationManager.notify(Common.NOTIFICATION_ID_UPDATES, NotificationCompat
+      .Builder(this, Common.NOTIFICATION_CHANNEL_UPDATES)
+      .setSmallIcon(R.drawable.ic_new_releases)
+      .setContentTitle(getString(R.string.new_updates_available))
+      .setContentText(resources.getQuantityString(R.plurals.new_updates_DESC_FORMAT,
+        productItems.size, productItems.size))
+      .setColor(ContextThemeWrapper(this, R.style.Theme_Main_Light)
+        .getColorFromAttr(android.R.attr.colorAccent).defaultColor)
+      .setContentIntent(PendingIntent.getActivity(this, 0, Intent(this, MainActivity::class.java)
+        .setAction(MainActivity.ACTION_UPDATES), PendingIntent.FLAG_UPDATE_CURRENT))
+      .setStyle(NotificationCompat.InboxStyle().applyHack {
+        for (productItem in productItems.take(maxUpdates)) {
+          val builder = SpannableStringBuilder(productItem.name)
+          builder.setSpan(ForegroundColorSpan(Color.BLACK), 0, builder.length,
+            SpannableStringBuilder.SPAN_EXCLUSIVE_EXCLUSIVE)
+          builder.append(' ').append(productItem.version)
+          addLine(builder)
+        }
+        if (productItems.size > maxUpdates) {
+          val summary = getString(R.string.plus_more_FORMAT, productItems.size - maxUpdates)
+          if (Android.sdk(24)) {
+            addLine(summary)
+          } else {
+            setSummaryText(summary)
+          }
+        }
+      })
+      .build())
+  }
+
+  class Job: JobService() {
+    private var syncParams: JobParameters? = null
+    private var syncDisposable: Disposable? = null
+    private val syncConnection = Connection(SyncService::class.java, onBind = { connection, binder ->
+      syncDisposable = binder.finish.subscribe {
+        val params = syncParams
+        if (params != null) {
+          syncParams = null
+          syncDisposable?.dispose()
+          syncDisposable = null
+          connection.unbind(this)
+          jobFinished(params, false)
+        }
+      }
+      binder.sync(SyncRequest.AUTO)
+    }, onUnbind = { _, binder ->
+      syncDisposable?.dispose()
+      syncDisposable = null
+      binder.cancelAuto()
+      val params = syncParams
+      if (params != null) {
+        syncParams = null
+        jobFinished(params, true)
+      }
+    })
+
+    override fun onStartJob(params: JobParameters): Boolean {
+      syncParams = params
+      syncConnection.bind(this)
+      return true
+    }
+
+    override fun onStopJob(params: JobParameters): Boolean {
+      syncParams = null
+      syncDisposable?.dispose()
+      syncDisposable = null
+      val reschedule = syncConnection.binder?.cancelAuto() == true
+      syncConnection.unbind(this)
+      return reschedule
+    }
+  }
+}

src/main/kotlin/com/looker/droidify/utility/KParcelable.kt

@@ -0,0 +1,18 @@
+package com.looker.droidify.utility
+
+import android.os.Parcel
+import android.os.Parcelable
+
+interface KParcelable: Parcelable {
+  override fun describeContents(): Int = 0
+  override fun writeToParcel(dest: Parcel, flags: Int) = Unit
+
+  companion object {
+    inline fun <reified T> creator(crossinline create: (source: Parcel) -> T): Parcelable.Creator<T> {
+      return object: Parcelable.Creator<T> {
+        override fun createFromParcel(source: Parcel): T = create(source)
+        override fun newArray(size: Int): Array<T?> = arrayOfNulls(size)
+      }
+    }
+  }
+}

src/main/kotlin/com/looker/droidify/utility/PackageItemResolver.kt

@@ -0,0 +1,122 @@
+package com.looker.droidify.utility
+
+import android.content.Context
+import android.content.pm.PackageItemInfo
+import android.content.pm.PermissionInfo
+import android.content.res.Resources
+import com.looker.droidify.utility.extension.android.*
+import java.util.Locale
+
+object PackageItemResolver {
+  class LocalCache {
+    internal val resources = mutableMapOf<String, Resources>()
+  }
+
+  private data class CacheKey(val locales: List<Locale>, val packageName: String, val resId: Int)
+
+  private val cache = mutableMapOf<CacheKey, String?>()
+
+  private fun load(context: Context, localCache: LocalCache, packageName: String,
+    nonLocalized: CharSequence?, resId: Int): CharSequence? {
+    return when {
+      nonLocalized != null -> {
+        nonLocalized
+      }
+      resId != 0 -> {
+        val locales = if (Android.sdk(24)) {
+          val localesList = context.resources.configuration.locales
+          (0 until localesList.size()).map(localesList::get)
+        } else {
+          @Suppress("DEPRECATION")
+          listOf(context.resources.configuration.locale)
+        }
+        val cacheKey = CacheKey(locales, packageName, resId)
+        if (cache.containsKey(cacheKey)) {
+          cache[cacheKey]
+        } else {
+          val resources = localCache.resources[packageName] ?: run {
+            val resources = try {
+              val resources = context.packageManager.getResourcesForApplication(packageName)
+              @Suppress("DEPRECATION")
+              resources.updateConfiguration(context.resources.configuration, null)
+              resources
+            } catch (e: Exception) {
+              null
+            }
+            resources?.let { localCache.resources[packageName] = it }
+            resources
+          }
+          val label = resources?.getString(resId)
+          cache[cacheKey] = label
+          label
+        }
+      }
+      else -> {
+        null
+      }
+    }
+  }
+
+  fun loadLabel(context: Context, localCache: LocalCache, packageItemInfo: PackageItemInfo): CharSequence? {
+    return load(context, localCache, packageItemInfo.packageName,
+      packageItemInfo.nonLocalizedLabel, packageItemInfo.labelRes)
+  }
+
+  fun loadDescription(context: Context, localCache: LocalCache, permissionInfo: PermissionInfo): CharSequence? {
+    return load(context, localCache, permissionInfo.packageName,
+      permissionInfo.nonLocalizedDescription, permissionInfo.descriptionRes)
+  }
+
+  fun getPermissionGroup(permissionInfo: PermissionInfo): String? {
+    return if (Android.sdk(29)) {
+      // Copied from package installer (Utils.java)
+      when (permissionInfo.name) {
+        android.Manifest.permission.READ_CONTACTS,
+        android.Manifest.permission.WRITE_CONTACTS,
+        android.Manifest.permission.GET_ACCOUNTS ->
+          android.Manifest.permission_group.CONTACTS
+        android.Manifest.permission.READ_CALENDAR,
+        android.Manifest.permission.WRITE_CALENDAR ->
+          android.Manifest.permission_group.CALENDAR
+        android.Manifest.permission.SEND_SMS,
+        android.Manifest.permission.RECEIVE_SMS,
+        android.Manifest.permission.READ_SMS,
+        android.Manifest.permission.RECEIVE_MMS,
+        android.Manifest.permission.RECEIVE_WAP_PUSH,
+        "android.permission.READ_CELL_BROADCASTS" ->
+          android.Manifest.permission_group.SMS
+        android.Manifest.permission.READ_EXTERNAL_STORAGE,
+        android.Manifest.permission.WRITE_EXTERNAL_STORAGE,
+        android.Manifest.permission.ACCESS_MEDIA_LOCATION ->
+          android.Manifest.permission_group.STORAGE
+        android.Manifest.permission.ACCESS_FINE_LOCATION,
+        android.Manifest.permission.ACCESS_COARSE_LOCATION,
+        android.Manifest.permission.ACCESS_BACKGROUND_LOCATION ->
+          android.Manifest.permission_group.LOCATION
+        android.Manifest.permission.READ_CALL_LOG,
+        android.Manifest.permission.WRITE_CALL_LOG,
+        @Suppress("DEPRECATION") android.Manifest.permission.PROCESS_OUTGOING_CALLS ->
+          android.Manifest.permission_group.CALL_LOG
+        android.Manifest.permission.READ_PHONE_STATE,
+        android.Manifest.permission.READ_PHONE_NUMBERS,
+        android.Manifest.permission.CALL_PHONE,
+        android.Manifest.permission.ADD_VOICEMAIL,
+        android.Manifest.permission.USE_SIP,
+        android.Manifest.permission.ANSWER_PHONE_CALLS,
+        android.Manifest.permission.ACCEPT_HANDOVER ->
+          android.Manifest.permission_group.PHONE
+        android.Manifest.permission.RECORD_AUDIO ->
+          android.Manifest.permission_group.MICROPHONE
+        android.Manifest.permission.ACTIVITY_RECOGNITION ->
+          android.Manifest.permission_group.ACTIVITY_RECOGNITION
+        android.Manifest.permission.CAMERA ->
+          android.Manifest.permission_group.CAMERA
+        android.Manifest.permission.BODY_SENSORS ->
+          android.Manifest.permission_group.SENSORS
+        else -> null
+      }
+    } else {
+      permissionInfo.group
+    }
+  }
+}

src/main/kotlin/com/looker/droidify/utility/ProgressInputStream.kt

@@ -0,0 +1,29 @@
+package com.looker.droidify.utility
+
+import java.io.InputStream
+
+class ProgressInputStream(private val inputStream: InputStream,
+  private val callback: (Long) -> Unit): InputStream() {
+  private var count = 0L
+
+  private inline fun <reified T: Number> notify(one: Boolean, read: () -> T): T {
+    val result = read()
+    count += if (one) 1L else result.toLong()
+    callback(count)
+    return result
+  }
+
+  override fun read(): Int = notify(true) { inputStream.read() }
+  override fun read(b: ByteArray): Int = notify(false) { inputStream.read(b) }
+  override fun read(b: ByteArray, off: Int, len: Int): Int = notify(false) { inputStream.read(b, off, len) }
+  override fun skip(n: Long): Long = notify(false) { inputStream.skip(n) }
+
+  override fun available(): Int {
+    return inputStream.available()
+  }
+
+  override fun close() {
+    inputStream.close()
+    super.close()
+  }
+}

src/main/kotlin/com/looker/droidify/utility/RxUtils.kt

@@ -0,0 +1,83 @@
+package com.looker.droidify.utility
+
+import android.os.CancellationSignal
+import android.os.OperationCanceledException
+import io.reactivex.rxjava3.core.Single
+import io.reactivex.rxjava3.disposables.Disposable
+import io.reactivex.rxjava3.exceptions.CompositeException
+import io.reactivex.rxjava3.exceptions.Exceptions
+import io.reactivex.rxjava3.plugins.RxJavaPlugins
+import okhttp3.Call
+import okhttp3.Response
+
+object RxUtils {
+  private class ManagedDisposable(private val cancel: () -> Unit): Disposable {
+    @Volatile var disposed = false
+    override fun isDisposed(): Boolean = disposed
+
+    override fun dispose() {
+      disposed = true
+      cancel()
+    }
+  }
+
+  private fun <T, R> managedSingle(create: () -> T, cancel: (T) -> Unit, execute: (T) -> R): Single<R> {
+    return Single.create {
+      val task = create()
+      val thread = Thread.currentThread()
+      val disposable = ManagedDisposable {
+        thread.interrupt()
+        cancel(task)
+      }
+      it.setDisposable(disposable)
+      if (!disposable.isDisposed) {
+        val result = try {
+          execute(task)
+        } catch (e: Throwable) {
+          Exceptions.throwIfFatal(e)
+          if (!disposable.isDisposed) {
+            try {
+              it.onError(e)
+            } catch (inner: Throwable) {
+              Exceptions.throwIfFatal(inner)
+              RxJavaPlugins.onError(CompositeException(e, inner))
+            }
+          }
+          null
+        }
+        if (result != null && !disposable.isDisposed) {
+          it.onSuccess(result)
+        }
+      }
+    }
+  }
+
+  fun <R> managedSingle(execute: () -> R): Single<R> {
+    return managedSingle({ Unit }, { }, { execute() })
+  }
+
+  fun callSingle(create: () -> Call): Single<Response> {
+    return managedSingle(create, Call::cancel, Call::execute)
+  }
+
+  fun <T> querySingle(query: (CancellationSignal) -> T): Single<T> {
+    return Single.create {
+      val cancellationSignal = CancellationSignal()
+      it.setCancellable {
+        try {
+          cancellationSignal.cancel()
+        } catch (e: OperationCanceledException) {
+          // Do nothing
+        }
+      }
+      val result = try {
+        query(cancellationSignal)
+      } catch (e: OperationCanceledException) {
+        null
+      }
+      if (result != null) {
+        it.onSuccess(result)
+      }
+    }
+  }
+}

src/main/kotlin/com/looker/droidify/utility/Utils.kt

@@ -0,0 +1,100 @@
+package com.looker.droidify.utility
+
+import android.animation.ValueAnimator
+import android.content.Context
+import android.content.pm.Signature
+import android.content.res.Configuration
+import android.graphics.drawable.Drawable
+import android.os.LocaleList
+import android.provider.Settings
+import com.looker.droidify.BuildConfig
+import com.looker.droidify.R
+import com.looker.droidify.utility.extension.android.*
+import com.looker.droidify.utility.extension.resources.*
+import com.looker.droidify.utility.extension.text.*
+import java.security.MessageDigest
+import java.security.cert.Certificate
+import java.security.cert.CertificateEncodingException
+import java.util.Locale
+
+object Utils {
+  private fun createDefaultApplicationIcon(context: Context, tintAttrResId: Int): Drawable {
+    return context.getDrawableCompat(R.drawable.ic_application_default).mutate()
+      .apply { setTintList(context.getColorFromAttr(tintAttrResId)) }
+  }
+
+  fun getDefaultApplicationIcons(context: Context): Pair<Drawable, Drawable> {
+    val progressIcon: Drawable = createDefaultApplicationIcon(context, android.R.attr.textColorSecondary)
+    val defaultIcon: Drawable = createDefaultApplicationIcon(context, android.R.attr.colorAccent)
+    return Pair(progressIcon, defaultIcon)
+  }
+
+  fun getToolbarIcon(context: Context, resId: Int): Drawable {
+    val drawable = context.getDrawableCompat(resId).mutate()
+    drawable.setTintList(context.getColorFromAttr(android.R.attr.textColorPrimary))
+    return drawable
+  }
+
+  fun calculateHash(signature: Signature): String? {
+    return MessageDigest.getInstance("MD5").digest(signature.toCharsString().toByteArray()).hex()
+  }
+
+  fun calculateFingerprint(certificate: Certificate): String {
+    val encoded = try {
+      certificate.encoded
+    } catch (e: CertificateEncodingException) {
+      null
+    }
+    return encoded?.let(::calculateFingerprint).orEmpty()
+  }
+
+  fun calculateFingerprint(key: ByteArray): String {
+    return if (key.size >= 256) {
+      try {
+        val fingerprint = MessageDigest.getInstance("SHA-256").digest(key)
+        val builder = StringBuilder()
+        for (byte in fingerprint) {
+          builder.append("%02X".format(Locale.US, byte.toInt() and 0xff))
+        }
+        builder.toString()
+      } catch (e: Exception) {
+        e.printStackTrace()
+        ""
+      }
+    } else {
+      ""
+    }
+  }
+
+  fun configureLocale(context: Context): Context {
+    val supportedLanguages = BuildConfig.LANGUAGES.toSet()
+    val configuration = context.resources.configuration
+    val currentLocales = if (Android.sdk(24)) {
+      val localesList = configuration.locales
+      (0 until localesList.size()).map(localesList::get)
+    } else {
+      @Suppress("DEPRECATION")
+      listOf(configuration.locale)
+    }
+    val compatibleLocales = currentLocales
+      .filter { it.language in supportedLanguages }
+      .let { if (it.isEmpty()) listOf(Locale.US) else it }
+    Locale.setDefault(compatibleLocales.first())
+    val newConfiguration = Configuration(configuration)
+    if (Android.sdk(24)) {
+      newConfiguration.setLocales(LocaleList(*compatibleLocales.toTypedArray()))
+    } else {
+      @Suppress("DEPRECATION")
+      newConfiguration.locale = compatibleLocales.first()
+    }
+    return context.createConfigurationContext(newConfiguration)
+  }
+
+  fun areAnimationsEnabled(context: Context): Boolean {
+    return if (Android.sdk(26)) {
+      ValueAnimator.areAnimatorsEnabled()
+    } else {
+      Settings.Global.getFloat(context.contentResolver, Settings.Global.ANIMATOR_DURATION_SCALE, 1f) != 0f
+    }
+  }
+}

src/main/kotlin/com/looker/droidify/utility/extension/Android.kt

@@ -0,0 +1,76 @@
+@file:Suppress("PackageDirectoryMismatch")
+package com.looker.droidify.utility.extension.android
+
+import android.app.NotificationManager
+import android.content.Context
+import android.content.pm.PackageInfo
+import android.content.pm.Signature
+import android.database.Cursor
+import android.database.sqlite.SQLiteDatabase
+import android.os.Build
+
+fun Cursor.asSequence(): Sequence<Cursor> {
+  return generateSequence { if (moveToNext()) this else null }
+}
+
+fun Cursor.firstOrNull(): Cursor? {
+  return if (moveToFirst()) this else null
+}
+
+fun SQLiteDatabase.execWithResult(sql: String) {
+  rawQuery(sql, null).use { it.count }
+}
+
+val Context.notificationManager: NotificationManager
+  get() = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+
+val PackageInfo.versionCodeCompat: Long
+  get() = if (Android.sdk(28)) longVersionCode else @Suppress("DEPRECATION") versionCode.toLong()
+
+val PackageInfo.singleSignature: Signature?
+  get() {
+    return if (Android.sdk(28)) {
+      val signingInfo = signingInfo
+      if (signingInfo?.hasMultipleSigners() == false) signingInfo.apkContentsSigners
+        ?.let { if (it.size == 1) it[0] else null } else null
+    } else {
+      @Suppress("DEPRECATION")
+      signatures?.let { if (it.size == 1) it[0] else null }
+    }
+  }
+
+object Android {
+  val sdk: Int
+    get() = Build.VERSION.SDK_INT
+
+  val name: String
+    get() = "Android ${Build.VERSION.RELEASE}"
+
+  val platforms = Build.SUPPORTED_ABIS.toSet()
+
+  val primaryPlatform: String?
+    get() = Build.SUPPORTED_64_BIT_ABIS?.firstOrNull() ?: Build.SUPPORTED_32_BIT_ABIS?.firstOrNull()
+
+  fun sdk(sdk: Int): Boolean {
+    return Build.VERSION.SDK_INT >= sdk
+  }
+
+  object PackageManager {
+    // GET_SIGNATURES should always present for getPackageArchiveInfo
+    val signaturesFlag: Int
+      get() = (if (sdk(28)) android.content.pm.PackageManager.GET_SIGNING_CERTIFICATES else 0) or
+        @Suppress("DEPRECATION") android.content.pm.PackageManager.GET_SIGNATURES
+  }
+
+  object Device {
+    val isHuaweiEmui: Boolean
+      get() {
+        return try {
+          Class.forName("com.huawei.android.os.BuildEx")
+          true
+        } catch (e: Exception) {
+          false
+        }
+      }
+  }
+}

src/main/kotlin/com/looker/droidify/utility/extension/Json.kt

@@ -0,0 +1,106 @@
+@file:Suppress("PackageDirectoryMismatch")
+package com.looker.droidify.utility.extension.json
+
+import com.fasterxml.jackson.core.JsonFactory
+import com.fasterxml.jackson.core.JsonGenerator
+import com.fasterxml.jackson.core.JsonParseException
+import com.fasterxml.jackson.core.JsonParser
+import com.fasterxml.jackson.core.JsonToken
+
+object Json {
+  val factory = JsonFactory()
+}
+
+fun JsonParser.illegal(): Nothing {
+  throw JsonParseException(this, "Illegal state")
+}
+
+interface KeyToken {
+  val key: String
+  val token: JsonToken
+
+  fun number(key: String): Boolean = this.key == key && this.token.isNumeric
+  fun string(key: String): Boolean = this.key == key && this.token == JsonToken.VALUE_STRING
+  fun boolean(key: String): Boolean = this.key == key && this.token.isBoolean
+  fun dictionary(key: String): Boolean = this.key == key && this.token == JsonToken.START_OBJECT
+  fun array(key: String): Boolean = this.key == key && this.token == JsonToken.START_ARRAY
+}
+
+inline fun JsonParser.forEachKey(callback: JsonParser.(KeyToken) -> Unit) {
+  var passKey = ""
+  var passToken = JsonToken.NOT_AVAILABLE
+  val keyToken = object: KeyToken {
+    override val key: String
+      get() = passKey
+    override val token: JsonToken
+      get() = passToken
+  }
+  while (true) {
+    val token = nextToken()
+    if (token == JsonToken.FIELD_NAME) {
+      passKey = currentName
+      passToken = nextToken()
+      callback(keyToken)
+    } else if (token == JsonToken.END_OBJECT) {
+      break
+    } else {
+      illegal()
+    }
+  }
+}
+
+fun JsonParser.forEach(requiredToken: JsonToken, callback: JsonParser.() -> Unit) {
+  while (true) {
+    val token = nextToken()
+    if (token == JsonToken.END_ARRAY) {
+      break
+    } else if (token == requiredToken) {
+      callback()
+    } else if (token.isStructStart) {
+      skipChildren()
+    }
+  }
+}
+
+fun <T> JsonParser.collectNotNull(requiredToken: JsonToken, callback: JsonParser.() -> T?): List<T> {
+  val list = mutableListOf<T>()
+  forEach(requiredToken) {
+    val result = callback()
+    if (result != null) {
+      list += result
+    }
+  }
+  return list
+}
+
+fun JsonParser.collectNotNullStrings(): List<String> {
+  return collectNotNull(JsonToken.VALUE_STRING) { valueAsString }
+}
+
+fun JsonParser.collectDistinctNotEmptyStrings(): List<String> {
+  return collectNotNullStrings().asSequence().filter { it.isNotEmpty() }.distinct().toList()
+}
+
+inline fun <T> JsonParser.parseDictionary(callback: JsonParser.() -> T): T {
+  if (nextToken() == JsonToken.START_OBJECT) {
+    val result = callback()
+    if (nextToken() != null) {
+      illegal()
+    }
+    return result
+  } else {
+    illegal()
+  }
+}
+
+inline fun JsonGenerator.writeDictionary(callback: JsonGenerator.() -> Unit) {
+  writeStartObject()
+  callback()
+  writeEndObject()
+}
+
+inline fun JsonGenerator.writeArray(fieldName: String, callback: JsonGenerator.() -> Unit) {
+  writeArrayFieldStart(fieldName)
+  callback()
+  writeEndArray()
+}

src/main/kotlin/com/looker/droidify/utility/extension/Resources.kt

@@ -0,0 +1,94 @@
+@file:Suppress("PackageDirectoryMismatch")
+package com.looker.droidify.utility.extension.resources
+
+import android.content.Context
+import android.content.res.ColorStateList
+import android.content.res.Resources
+import android.graphics.Typeface
+import android.graphics.drawable.Drawable
+import android.net.Uri
+import android.util.TypedValue
+import android.util.Xml
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import android.widget.ImageView
+import android.widget.TextView
+import androidx.core.content.ContextCompat
+import androidx.vectordrawable.graphics.drawable.VectorDrawableCompat
+import com.squareup.picasso.Picasso
+import com.squareup.picasso.RequestCreator
+import com.looker.droidify.utility.extension.android.*
+import org.xmlpull.v1.XmlPullParser
+import kotlin.math.*
+
+object TypefaceExtra {
+  val medium = Typeface.create("sans-serif-medium", Typeface.NORMAL)!!
+  val light = Typeface.create("sans-serif-light", Typeface.NORMAL)!!
+}
+
+fun Context.getDrawableCompat(resId: Int): Drawable {
+  val drawable = if (!Android.sdk(24)) {
+    val fileName = TypedValue().apply { resources.getValue(resId, this, true) }.string
+    if (fileName.endsWith(".xml")) {
+      resources.getXml(resId).use {
+        val eventType = generateSequence { it.next() }
+          .find { it == XmlPullParser.START_TAG || it == XmlPullParser.END_DOCUMENT }
+        if (eventType == XmlPullParser.START_TAG) {
+          when (it.name) {
+            "vector" -> VectorDrawableCompat.createFromXmlInner(resources, it, Xml.asAttributeSet(it), theme)
+            else -> null
+          }
+        } else {
+          null
+        }
+      }
+    } else {
+      null
+    }
+  } else {
+    null
+  }
+  return drawable ?: ContextCompat.getDrawable(this, resId)!!
+}
+
+fun Context.getColorFromAttr(attrResId: Int): ColorStateList {
+  val typedArray = obtainStyledAttributes(intArrayOf(attrResId))
+  val (colorStateList, resId) = try {
+    Pair(typedArray.getColorStateList(0), typedArray.getResourceId(0, 0))
+  } finally {
+    typedArray.recycle()
+  }
+  return colorStateList ?: ContextCompat.getColorStateList(this, resId)!!
+}
+
+fun Context.getDrawableFromAttr(attrResId: Int): Drawable {
+  val typedArray = obtainStyledAttributes(intArrayOf(attrResId))
+  val resId = try {
+    typedArray.getResourceId(0, 0)
+  } finally {
+    typedArray.recycle()
+  }
+  return getDrawableCompat(resId)
+}
+
+fun Resources.sizeScaled(size: Int): Int {
+  return (size * displayMetrics.density).roundToInt()
+}
+
+fun TextView.setTextSizeScaled(size: Int) {
+  val realSize = (size * resources.displayMetrics.scaledDensity).roundToInt()
+  setTextSize(TypedValue.COMPLEX_UNIT_PX, realSize.toFloat())
+}
+
+fun ViewGroup.inflate(layoutResId: Int): View {
+  return LayoutInflater.from(context).inflate(layoutResId, this, false)
+}
+
+fun ImageView.load(uri: Uri, builder: RequestCreator.() -> Unit) {
+  Picasso.get().load(uri).noFade().apply(builder).into(this)
+}
+
+fun ImageView.clear() {
+  Picasso.get().cancelRequest(this)
+}

src/main/kotlin/com/looker/droidify/utility/extension/Text.kt

@@ -0,0 +1,59 @@
+@file:Suppress("PackageDirectoryMismatch")
+package com.looker.droidify.utility.extension.text
+
+import android.util.Log
+import java.util.Locale
+
+fun <T: CharSequence> T.nullIfEmpty(): T? {
+  return if (isNullOrEmpty()) null else this
+}
+
+private val sizeFormats = listOf("%.0f B", "%.0f kB", "%.1f MB", "%.2f GB")
+
+fun Long.formatSize(): String {
+  val (size, index) = generateSequence(Pair(this.toFloat(), 0)) { (size, index) -> if (size >= 1000f)
+    Pair(size / 1000f, index + 1) else null }.take(sizeFormats.size).last()
+  return sizeFormats[index].format(Locale.US, size)
+}
+
+fun Char.halfByte(): Int {
+  return when (this) {
+    in '0' .. '9' -> this - '0'
+    in 'a' .. 'f' -> this - 'a' + 10
+    in 'A' .. 'F' -> this - 'A' + 10
+    else -> -1
+  }
+}
+
+fun CharSequence.unhex(): ByteArray? {
+  return if (length % 2 == 0) {
+    val ints = windowed(2, 2, false).map {
+      val high = it[0].halfByte()
+      val low = it[1].halfByte()
+      if (high >= 0 && low >= 0) {
+        (high shl 4) or low
+      } else {
+        -1
+      }
+    }
+    if (ints.any { it < 0 }) null else ints.map { it.toByte() }.toByteArray()
+  } else {
+    null
+  }
+}
+
+fun ByteArray.hex(): String {
+  val builder = StringBuilder()
+  for (byte in this) {
+    builder.append("%02x".format(Locale.US, byte.toInt() and 0xff))
+  }
+  return builder.toString()
+}
+
+fun Any.debug(message: String) {
+  val tag = this::class.java.name.let {
+    val index = it.lastIndexOf('.')
+    if (index >= 0) it.substring(index + 1) else it
+  }.replace('$', '.')
+  Log.d(tag, message)
+}

src/main/kotlin/com/looker/droidify/widget/ClickableMovementMethod.kt

@@ -0,0 +1,48 @@
+package com.looker.droidify.widget
+
+import android.text.Selection
+import android.text.Spannable
+import android.text.method.MovementMethod
+import android.text.style.ClickableSpan
+import android.view.KeyEvent
+import android.view.MotionEvent
+import android.widget.TextView
+
+object ClickableMovementMethod: MovementMethod {
+  override fun initialize(widget: TextView, text: Spannable) {
+    Selection.removeSelection(text)
+  }
+
+  override fun onTouchEvent(widget: TextView, text: Spannable, event: MotionEvent): Boolean {
+    val action = event.action
+    val down = action == MotionEvent.ACTION_DOWN
+    val up = action == MotionEvent.ACTION_UP
+    return (down || up) && run {
+      val x = event.x.toInt() - widget.totalPaddingLeft + widget.scrollX
+      val y = event.y.toInt() - widget.totalPaddingTop + widget.scrollY
+      val layout = widget.layout
+      val line = layout.getLineForVertical(y)
+      val offset = layout.getOffsetForHorizontal(line, x.toFloat())
+      val span = text.getSpans(offset, offset, ClickableSpan::class.java)?.firstOrNull()
+      if (span != null) {
+        if (down) {
+          Selection.setSelection(text, text.getSpanStart(span), text.getSpanEnd(span))
+        } else {
+          span.onClick(widget)
+        }
+        true
+      } else {
+        Selection.removeSelection(text)
+        false
+      }
+    }
+  }
+
+  override fun onKeyDown(widget: TextView, text: Spannable, keyCode: Int, event: KeyEvent): Boolean = false
+  override fun onKeyUp(widget: TextView, text: Spannable, keyCode: Int, event: KeyEvent): Boolean = false
+  override fun onKeyOther(view: TextView, text: Spannable, event: KeyEvent): Boolean = false
+  override fun onTakeFocus(widget: TextView, text: Spannable, direction: Int) = Unit
+  override fun onTrackballEvent(widget: TextView, text: Spannable, event: MotionEvent): Boolean = false
+  override fun onGenericMotionEvent(widget: TextView, text: Spannable, event: MotionEvent): Boolean = false
+  override fun canSelectArbitrarily(): Boolean = false
+}

src/main/kotlin/com/looker/droidify/widget/CursorRecyclerAdapter.kt

@@ -0,0 +1,35 @@
+package com.looker.droidify.widget
+
+import android.database.Cursor
+import androidx.recyclerview.widget.RecyclerView
+
+abstract class CursorRecyclerAdapter<VT: Enum<VT>, VH: RecyclerView.ViewHolder>: EnumRecyclerAdapter<VT, VH>() {
+  init {
+    super.setHasStableIds(true)
+  }
+
+  private var rowIdIndex = 0
+
+  var cursor: Cursor? = null
+    set(value) {
+      if (field != value) {
+        field?.close()
+        field = value
+        rowIdIndex = value?.getColumnIndexOrThrow("_id") ?: 0
+        notifyDataSetChanged()
+      }
+    }
+
+  final override fun setHasStableIds(hasStableIds: Boolean) {
+    throw UnsupportedOperationException()
+  }
+
+  override fun getItemCount(): Int = cursor?.count ?: 0
+  override fun getItemId(position: Int): Long = moveTo(position).getLong(rowIdIndex)
+
+  fun moveTo(position: Int): Cursor {
+    val cursor = cursor!!
+    cursor.moveToPosition(position)
+    return cursor
+  }
+}

src/main/kotlin/com/looker/droidify/widget/DividerItemDecoration.kt

@@ -0,0 +1,88 @@
+package com.looker.droidify.widget
+
+import android.content.Context
+import android.graphics.Canvas
+import android.graphics.Rect
+import android.view.View
+import androidx.recyclerview.widget.RecyclerView
+import com.looker.droidify.R
+import com.looker.droidify.utility.extension.resources.*
+import kotlin.math.*
+
+class DividerItemDecoration(context: Context, private val configure: (context: Context,
+  position: Int, configuration: Configuration) -> Unit): RecyclerView.ItemDecoration() {
+  interface Configuration {
+    fun set(needDivider: Boolean, toTop: Boolean, paddingStart: Int, paddingEnd: Int)
+  }
+
+  private class ConfigurationHolder: Configuration {
+    var needDivider = false
+    var toTop = false
+    var paddingStart = 0
+    var paddingEnd = 0
+
+    override fun set(needDivider: Boolean, toTop: Boolean, paddingStart: Int, paddingEnd: Int) {
+      this.needDivider = needDivider
+      this.toTop = toTop
+      this.paddingStart = paddingStart
+      this.paddingEnd = paddingEnd
+    }
+  }
+
+  private val View.configuration: ConfigurationHolder
+    get() = getTag(R.id.divider_configuration) as? ConfigurationHolder ?: run {
+      val configuration = ConfigurationHolder()
+      setTag(R.id.divider_configuration, configuration)
+      configuration
+    }
+
+  private val divider = context.getDrawableFromAttr(android.R.attr.listDivider)
+  private val bounds = Rect()
+
+  private fun draw(c: Canvas, configuration: ConfigurationHolder, view: View, top: Int, width: Int, rtl: Boolean) {
+    val divider = divider
+    val left = if (rtl) configuration.paddingEnd else configuration.paddingStart
+    val right = width - (if (rtl) configuration.paddingStart else configuration.paddingEnd)
+    val translatedTop = top + view.translationY.roundToInt()
+    divider.alpha = (view.alpha * 0xff).toInt()
+    divider.setBounds(left, translatedTop, right, translatedTop + divider.intrinsicHeight)
+    divider.draw(c)
+  }
+
+  override fun onDraw(c: Canvas, parent: RecyclerView, state: RecyclerView.State) {
+    val divider = divider
+    val bounds = bounds
+    val rtl = parent.layoutDirection == View.LAYOUT_DIRECTION_RTL
+    for (i in 0 until parent.childCount) {
+      val view = parent.getChildAt(i)
+      val configuration = view.configuration
+      if (configuration.needDivider) {
+        val position = parent.getChildAdapterPosition(view)
+        if (position == parent.adapter!!.itemCount - 1) {
+          parent.getDecoratedBoundsWithMargins(view, bounds)
+          draw(c, configuration, view, bounds.bottom, parent.width, rtl)
+        } else {
+          val toTopView = if (configuration.toTop && position >= 0)
+            parent.findViewHolderForAdapterPosition(position + 1)?.itemView else null
+          if (toTopView != null) {
+            parent.getDecoratedBoundsWithMargins(toTopView, bounds)
+            draw(c, configuration, toTopView, bounds.top - divider.intrinsicHeight, parent.width, rtl)
+          } else {
+            parent.getDecoratedBoundsWithMargins(view, bounds)
+            draw(c, configuration, view, bounds.bottom - divider.intrinsicHeight, parent.width, rtl)
+          }
+        }
+      }
+    }
+  }
+
+  override fun getItemOffsets(outRect: Rect, view: View, parent: RecyclerView, state: RecyclerView.State) {
+    val configuration = view.configuration
+    val position = parent.getChildAdapterPosition(view)
+    if (position >= 0) {
+      configure(view.context, position, configuration)
+    }
+    val needDivider = position < parent.adapter!!.itemCount - 1 && configuration.needDivider
+    outRect.set(0, 0, 0, if (needDivider) divider.intrinsicHeight else 0)
+  }
+}

src/main/kotlin/com/looker/droidify/widget/EnumRecyclerAdapter.kt

@@ -0,0 +1,28 @@
+package com.looker.droidify.widget
+
+import android.util.SparseArray
+import android.view.ViewGroup
+import androidx.recyclerview.widget.RecyclerView
+
+abstract class EnumRecyclerAdapter<VT: Enum<VT>, VH: RecyclerView.ViewHolder>: RecyclerView.Adapter<VH>() {
+  abstract val viewTypeClass: Class<VT>
+
+  private val names = SparseArray<String>()
+
+  private fun getViewType(viewType: Int): VT {
+    return java.lang.Enum.valueOf(viewTypeClass, names.get(viewType))
+  }
+
+  final override fun getItemViewType(position: Int): Int {
+    val enum = getItemEnumViewType(position)
+    names.put(enum.ordinal, enum.name)
+    return enum.ordinal
+  }
+
+  final override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): VH {
+    return onCreateViewHolder(parent, getViewType(viewType))
+  }
+
+  abstract fun getItemEnumViewType(position: Int): VT
+  abstract fun onCreateViewHolder(parent: ViewGroup, viewType: VT): VH
+}

src/main/kotlin/com/looker/droidify/widget/FocusSearchView.kt

@@ -0,0 +1,35 @@
+package com.looker.droidify.widget
+
+import android.content.Context
+import android.util.AttributeSet
+import android.view.KeyEvent
+import android.widget.SearchView
+
+class FocusSearchView: SearchView {
+  constructor(context: Context): super(context)
+  constructor(context: Context, attrs: AttributeSet?): super(context, attrs)
+  constructor(context: Context, attrs: AttributeSet?, defStyleAttr: Int): super(context, attrs, defStyleAttr)
+
+  var allowFocus = true
+
+  override fun dispatchKeyEventPreIme(event: KeyEvent): Boolean {
+    // Always clear focus on back press
+    return if (hasFocus() && event.keyCode == KeyEvent.KEYCODE_BACK) {
+      if (event.action == KeyEvent.ACTION_UP) {
+        clearFocus()
+      }
+      true
+    } else {
+      super.dispatchKeyEventPreIme(event)
+    }
+  }
+
+  override fun setIconified(iconify: Boolean) {
+    super.setIconified(iconify)
+
+    // Don't focus view and raise keyboard unless allowed
+    if (!iconify && !allowFocus) {
+      clearFocus()
+    }
+  }
+}

src/main/kotlin/com/looker/droidify/widget/FragmentLinearLayout.kt

@@ -0,0 +1,22 @@
+package com.looker.droidify.widget
+
+import android.content.Context
+import android.util.AttributeSet
+import android.widget.LinearLayout
+
+class FragmentLinearLayout: LinearLayout {
+  constructor(context: Context): super(context)
+  constructor(context: Context, attrs: AttributeSet?): super(context, attrs)
+  constructor(context: Context, attrs: AttributeSet?, defStyleAttr: Int): super(context, attrs, defStyleAttr)
+
+  init {
+    fitsSystemWindows = true
+  }
+
+  @Suppress("unused")
+  var percentTranslationY: Float
+    get() = height.let { if (it > 0) translationY / it else 0f }
+    set(value) {
+      translationY = value * height
+    }
+}

src/main/kotlin/com/looker/droidify/widget/RecyclerFastScroller.kt

@@ -0,0 +1,247 @@
+package com.looker.droidify.widget
+
+import android.annotation.SuppressLint
+import android.graphics.Canvas
+import android.graphics.Rect
+import android.os.SystemClock
+import android.view.MotionEvent
+import android.view.ViewGroup
+import androidx.recyclerview.widget.LinearLayoutManager
+import androidx.recyclerview.widget.RecyclerView
+import com.looker.droidify.utility.extension.resources.*
+import kotlin.math.*
+
+@SuppressLint("ClickableViewAccessibility")
+class RecyclerFastScroller(private val recyclerView: RecyclerView) {
+  companion object {
+    private const val TRANSITION_IN = 100L
+    private const val TRANSITION_OUT = 200L
+    private const val TRANSITION_OUT_DELAY = 1000L
+
+    private val stateNormal = intArrayOf()
+    private val statePressed = intArrayOf(android.R.attr.state_pressed)
+  }
+
+  private val thumbDrawable = recyclerView.context.getDrawableFromAttr(android.R.attr.fastScrollThumbDrawable)
+  private val trackDrawable = recyclerView.context.getDrawableFromAttr(android.R.attr.fastScrollTrackDrawable)
+  private val minTrackSize = recyclerView.resources.sizeScaled(16)
+
+  private data class FastScrolling(val startAtThumbOffset: Float?, val startY: Float, val currentY: Float)
+
+  private var scrolling = false
+  private var fastScrolling: FastScrolling? = null
+  private var display = Pair(0L, false)
+
+  private val invalidateTransition = Runnable(recyclerView::invalidate)
+
+  private fun updateState(scrolling: Boolean, fastScrolling: FastScrolling?) {
+    val oldDisplay = this.scrolling || this.fastScrolling != null
+    val newDisplay = scrolling || fastScrolling != null
+    this.scrolling = scrolling
+    this.fastScrolling = fastScrolling
+    if (oldDisplay != newDisplay) {
+      recyclerView.removeCallbacks(invalidateTransition)
+      val time = SystemClock.elapsedRealtime()
+      val passed = time - display.first
+      val start = if (newDisplay && passed < (TRANSITION_OUT + TRANSITION_OUT_DELAY)) {
+        if (passed <= TRANSITION_OUT_DELAY) {
+          0L
+        } else {
+          time - ((TRANSITION_OUT_DELAY + TRANSITION_OUT - passed).toFloat() /
+            TRANSITION_OUT * TRANSITION_IN).toLong()
+        }
+      } else if (!newDisplay && passed < TRANSITION_IN) {
+        time - ((TRANSITION_IN - passed).toFloat() / TRANSITION_IN *
+          TRANSITION_OUT).toLong() - TRANSITION_OUT_DELAY
+      } else {
+        if (!newDisplay) {
+          recyclerView.postDelayed(invalidateTransition, TRANSITION_OUT_DELAY)
+        }
+        time
+      }
+      display = Pair(start, newDisplay)
+      recyclerView.invalidate()
+    }
+  }
+
+  private val scrollListener = object: RecyclerView.OnScrollListener() {
+    override fun onScrollStateChanged(recyclerView: RecyclerView, newState: Int) {
+      updateState(newState != RecyclerView.SCROLL_STATE_IDLE, fastScrolling)
+    }
+
+    override fun onScrolled(recyclerView: RecyclerView, dx: Int, dy: Int) {
+      if (fastScrolling == null) {
+        recyclerView.invalidate()
+      }
+    }
+  }
+
+  private inline fun withScroll(callback: (itemHeight: Int, thumbHeight: Int, range: Int) -> Unit): Boolean {
+    val count = recyclerView.adapter?.itemCount ?: 0
+    return count > 0 && run {
+      val itemHeight = Rect().apply { recyclerView
+        .getDecoratedBoundsWithMargins(recyclerView.getChildAt(0), this) }.height()
+      val scrollCount = count - recyclerView.height / itemHeight
+      scrollCount > 0 && run {
+        val range = count * itemHeight
+        val thumbHeight = max(recyclerView.height * recyclerView.height / range, thumbDrawable.intrinsicHeight)
+        range >= recyclerView.height * 2 && run {
+          callback(itemHeight, thumbHeight, range)
+          true
+        }
+      }
+    }
+  }
+
+  private fun calculateOffset(thumbHeight: Int, fastScrolling: FastScrolling): Float {
+    return if (fastScrolling.startAtThumbOffset != null) {
+      (fastScrolling.startAtThumbOffset + (fastScrolling.currentY - fastScrolling.startY) /
+        (recyclerView.height - thumbHeight)).coerceIn(0f, 1f)
+    } else {
+      ((fastScrolling.currentY - thumbHeight / 2f) / (recyclerView.height - thumbHeight)).coerceIn(0f, 1f)
+    }
+  }
+
+  private fun currentOffset(itemHeight: Int, range: Int): Float {
+    val view = recyclerView.getChildAt(0)
+    val position = recyclerView.getChildAdapterPosition(view)
+    val positionOffset = -view.top
+    val scrollPosition = position * itemHeight + positionOffset
+    return scrollPosition.toFloat() / (range - recyclerView.height)
+  }
+
+  private fun scroll(itemHeight: Int, thumbHeight: Int, range: Int, fastScrolling: FastScrolling) {
+    val offset = calculateOffset(thumbHeight, fastScrolling)
+    val scrollPosition = ((range - recyclerView.height) * offset).roundToInt()
+    val position = scrollPosition / itemHeight
+    val positionOffset = scrollPosition - position * itemHeight
+    val layoutManager = recyclerView.layoutManager as LinearLayoutManager
+    layoutManager.scrollToPositionWithOffset(position, -positionOffset)
+  }
+
+  private val touchListener = object: RecyclerView.OnItemTouchListener {
+    private var disallowIntercept = false
+
+    private fun handleTouchEvent(event: MotionEvent, intercept: Boolean): Boolean {
+      val recyclerView = recyclerView
+      val lastFastScrolling = fastScrolling
+      return when {
+        intercept && disallowIntercept -> {
+          false
+        }
+        event.action == MotionEvent.ACTION_DOWN -> {
+          val rtl = recyclerView.layoutDirection == RecyclerView.LAYOUT_DIRECTION_RTL
+          val trackWidth = max(minTrackSize, max(thumbDrawable.intrinsicWidth, trackDrawable.intrinsicWidth))
+          val atThumbVertical = if (rtl) event.x <= trackWidth else event.x >= recyclerView.width - trackWidth
+          atThumbVertical && run {
+            withScroll { itemHeight, thumbHeight, range ->
+              (recyclerView.parent as? ViewGroup)?.requestDisallowInterceptTouchEvent(true)
+              val offset = currentOffset(itemHeight, range)
+              val thumbY = ((recyclerView.height - thumbHeight) * offset).roundToInt()
+              val atThumb = event.y >= thumbY && event.y <= thumbY + thumbHeight
+              val fastScrolling = FastScrolling(if (atThumb) offset else null, event.y, event.y)
+              scroll(itemHeight, thumbHeight, range, fastScrolling)
+              updateState(scrolling, fastScrolling)
+              recyclerView.invalidate()
+            }
+          }
+        }
+        else -> lastFastScrolling != null && run {
+          val success = withScroll { itemHeight, thumbHeight, range ->
+            val fastScrolling = lastFastScrolling.copy(currentY = event.y)
+            scroll(itemHeight, thumbHeight, range, fastScrolling)
+            updateState(scrolling, fastScrolling)
+            recyclerView.invalidate()
+          }
+          val cancel = event.action == MotionEvent.ACTION_UP || event.action == MotionEvent.ACTION_CANCEL
+          if (!success || cancel) {
+            (recyclerView.parent as? ViewGroup)?.requestDisallowInterceptTouchEvent(false)
+            updateState(scrolling, null)
+            recyclerView.invalidate()
+          }
+          true
+        }
+      }
+    }
+
+    override fun onInterceptTouchEvent(rv: RecyclerView, e: MotionEvent): Boolean {
+      return handleTouchEvent(e, true)
+    }
+
+    override fun onTouchEvent(rv: RecyclerView, e: MotionEvent) {
+      handleTouchEvent(e, false)
+    }
+
+    override fun onRequestDisallowInterceptTouchEvent(disallowIntercept: Boolean) {
+      this.disallowIntercept = disallowIntercept
+      if (disallowIntercept && fastScrolling != null) {
+        updateState(scrolling, null)
+        recyclerView.invalidate()
+      }
+    }
+  }
+
+  private fun handleDraw(canvas: Canvas) {
+    withScroll { itemHeight, thumbHeight, range ->
+      val display = display
+      val time = SystemClock.elapsedRealtime()
+      val passed = time - display.first
+      val shouldInvalidate = display.second && passed < TRANSITION_IN ||
+        !display.second && passed >= TRANSITION_OUT_DELAY && passed < TRANSITION_OUT_DELAY + TRANSITION_OUT
+      val stateValue = (if (display.second) {
+        passed.toFloat() / TRANSITION_IN
+      } else {
+        1f - (passed - TRANSITION_OUT_DELAY).toFloat() / TRANSITION_OUT
+      }).coerceIn(0f, 1f)
+
+      if (stateValue > 0f) {
+        val rtl = recyclerView.layoutDirection == RecyclerView.LAYOUT_DIRECTION_RTL
+        val thumbDrawable = thumbDrawable
+        val trackDrawable = trackDrawable
+        val maxWidth = max(thumbDrawable.intrinsicWidth, trackDrawable.intrinsicHeight)
+        val translateX = (maxWidth * (1f - stateValue)).roundToInt()
+        val fastScrolling = fastScrolling
+
+        val scrollValue = (if (fastScrolling != null) {
+          calculateOffset(thumbHeight, fastScrolling)
+        } else {
+          currentOffset(itemHeight, range)
+        }).coerceIn(0f, 1f)
+        val thumbY = ((recyclerView.height - thumbHeight) * scrollValue).roundToInt()
+
+        trackDrawable.state = if (fastScrolling != null) statePressed else stateNormal
+        val trackExtra = (maxWidth - trackDrawable.intrinsicWidth) / 2
+        if (rtl) {
+          trackDrawable.setBounds(trackExtra - translateX, 0,
+            trackExtra + trackDrawable.intrinsicWidth - translateX, recyclerView.height)
+        } else {
+          trackDrawable.setBounds(recyclerView.width - trackExtra - trackDrawable.intrinsicWidth + translateX,
+            0, recyclerView.width - trackExtra + translateX, recyclerView.height)
+        }
+        trackDrawable.draw(canvas)
+        val thumbExtra = (maxWidth - thumbDrawable.intrinsicWidth) / 2
+        thumbDrawable.state = if (fastScrolling != null) statePressed else stateNormal
+        if (rtl) {
+          thumbDrawable.setBounds(thumbExtra - translateX, thumbY,
+            thumbExtra + thumbDrawable.intrinsicWidth - translateX, thumbY + thumbHeight)
+        } else {
+          thumbDrawable.setBounds(recyclerView.width - thumbExtra - thumbDrawable.intrinsicWidth + translateX,
+            thumbY, recyclerView.width - thumbExtra + translateX, thumbY + thumbHeight)
+        }
+        thumbDrawable.draw(canvas)
+      }
+
+      if (shouldInvalidate) {
+        recyclerView.invalidate()
+      }
+    }
+  }
+
+  init {
+    recyclerView.addOnScrollListener(scrollListener)
+    recyclerView.addOnItemTouchListener(touchListener)
+    recyclerView.addItemDecoration(object: RecyclerView.ItemDecoration() {
+      override fun onDrawOver(c: Canvas, parent: RecyclerView, state: RecyclerView.State) = handleDraw(c)
+    })
+  }
+}

src/main/kotlin/com/looker/droidify/widget/StableRecyclerAdapter.kt

@@ -0,0 +1,27 @@
+package com.looker.droidify.widget
+
+import androidx.recyclerview.widget.RecyclerView
+
+abstract class StableRecyclerAdapter<VT: Enum<VT>, VH: RecyclerView.ViewHolder>: EnumRecyclerAdapter<VT, VH>() {
+  private var nextId = 1L
+  private val descriptorToId = mutableMapOf<String, Long>()
+
+  init {
+    super.setHasStableIds(true)
+  }
+
+  final override fun setHasStableIds(hasStableIds: Boolean) {
+    throw UnsupportedOperationException()
+  }
+
+  override fun getItemId(position: Int): Long {
+    val descriptor = getItemDescriptor(position)
+    return descriptorToId[descriptor] ?: run {
+      val id = nextId++
+      descriptorToId[descriptor] = id
+      id
+    }
+  }
+
+  abstract fun getItemDescriptor(position: Int): String
+}

src/main/kotlin/com/looker/droidify/widget/Toolbar.kt

@@ -0,0 +1,33 @@
+package com.looker.droidify.widget
+
+import android.content.Context
+import android.util.AttributeSet
+import android.widget.Toolbar
+
+class Toolbar: Toolbar {
+  constructor(context: Context): super(context)
+  constructor(context: Context, attrs: AttributeSet?): super(context, attrs)
+  constructor(context: Context, attrs: AttributeSet?, defStyleAttr: Int): super(context, attrs, defStyleAttr)
+  constructor(context: Context, attrs: AttributeSet?, defStyleAttr: Int,
+    defStyleRes: Int): super(context, attrs, defStyleAttr, defStyleRes)
+
+  private var initalized = false
+  private var layoutDirectionChanged: Int? = null
+
+  init {
+    initalized = true
+    val layoutDirection = layoutDirectionChanged
+    layoutDirectionChanged = null
+    if (layoutDirection != null) {
+      onRtlPropertiesChanged(layoutDirection)
+    }
+  }
+
+  override fun onRtlPropertiesChanged(layoutDirection: Int) {
+    if (initalized) {
+      super.onRtlPropertiesChanged(layoutDirection)
+    } else {
+      layoutDirectionChanged = layoutDirection
+    }
+  }
+}