From baf9944dc94c46076d667899ea9f66c2241d0d48 Mon Sep 17 00:00:00 2001
From: Mohit <mohit2002ss@gmail.com>
Date: Tue, 8 Jun 2021 21:35:46 +0530
Subject: [PATCH] - Screenshots are Expanded by Default - Reformatted Code -
 Added background to Show More Button - Shortened Tab Indicator...

---
 .../looker/droidify/screen/ProductAdapter.kt  | 2634 +++++++++--------
 .../looker/droidify/screen/ProductFragment.kt |  960 +++---
 .../looker/droidify/screen/ProductsAdapter.kt |  311 +-
 .../droidify/screen/ProductsFragment.kt       |    2 -
 .../looker/droidify/screen/TabsFragment.kt    | 1130 +++----
 5 files changed, 2719 insertions(+), 2318 deletions(-)

diff --git a/src/main/kotlin/com/looker/droidify/screen/ProductAdapter.kt b/src/main/kotlin/com/looker/droidify/screen/ProductAdapter.kt
index 11010d7d..af211e64 100644
--- a/src/main/kotlin/com/looker/droidify/screen/ProductAdapter.kt
+++ b/src/main/kotlin/com/looker/droidify/screen/ProductAdapter.kt
@@ -16,25 +16,13 @@ import android.net.Uri
 import android.os.Parcel
 import android.text.SpannableStringBuilder
 import android.text.format.DateFormat
-import android.text.style.BulletSpan
-import android.text.style.ClickableSpan
-import android.text.style.RelativeSizeSpan
-import android.text.style.ReplacementSpan
-import android.text.style.TypefaceSpan
-import android.text.style.URLSpan
+import android.text.style.*
 import android.text.util.Linkify
 import android.view.Gravity
 import android.view.MotionEvent
 import android.view.View
 import android.view.ViewGroup
-import android.widget.Button
-import android.widget.FrameLayout
-import android.widget.ImageView
-import android.widget.LinearLayout
-import android.widget.ProgressBar
-import android.widget.Switch
-import android.widget.TextView
-import android.widget.Toast
+import android.widget.*
 import androidx.core.graphics.ColorUtils
 import androidx.core.text.HtmlCompat
 import androidx.core.text.util.LinkifyCompat
@@ -42,11 +30,7 @@ import androidx.recyclerview.widget.RecyclerView
 import com.looker.droidify.R
 import com.looker.droidify.content.Preferences
 import com.looker.droidify.content.ProductPreferences
-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.entity.*
 import com.looker.droidify.graphics.PaddingDrawable
 import com.looker.droidify.network.PicassoDownloader
 import com.looker.droidify.utility.KParcelable
@@ -56,1250 +40,1508 @@ import com.looker.droidify.utility.extension.android.*
 import com.looker.droidify.utility.extension.resources.*
 import com.looker.droidify.utility.extension.text.*
 import com.looker.droidify.widget.ClickableMovementMethod
-import com.looker.droidify.widget.DividerItemDecoration
 import com.looker.droidify.widget.StableRecyclerAdapter
 import java.lang.ref.WeakReference
-import java.util.Locale
+import java.util.*
 import kotlin.math.*
 
-class ProductAdapter(private val callbacks: Callbacks, private val columns: Int):
-  StableRecyclerAdapter<ProductAdapter.ViewType, RecyclerView.ViewHolder>() {
-  companion object {
-    private const val GRID_SPACING_OUTER_DP = 16
-    private const val GRID_SPACING_INNER_DP = 4
-  }
-
-  interface Callbacks {
-    fun onActionClick(action: Action)
-    fun onPreferenceChanged(preference: ProductPreference)
-    fun onPermissionsClick(group: String?, permissions: List<String>)
-    fun onScreenshotClick(screenshot: Product.Screenshot)
-    fun onReleaseClick(release: Release)
-    fun onUriClick(uri: Uri, shouldConfirm: Boolean): Boolean
-  }
-
-  enum class Action(val titleResId: Int) {
-    INSTALL(R.string.install),
-    UPDATE(R.string.update),
-    LAUNCH(R.string.launch),
-    DETAILS(R.string.details),
-    UNINSTALL(R.string.uninstall),
-    CANCEL(R.string.cancel)
-  }
-
-  sealed class Status {
-    object Pending: Status()
-    object Connecting: Status()
-    data class Downloading(val read: Long, val total: Long?): Status()
-  }
-
-  enum class ViewType { HEADER, SWITCH, SECTION, EXPAND, TEXT, LINK, PERMISSIONS, SCREENSHOT, RELEASE, EMPTY }
-
-  private enum class SwitchType(val titleResId: Int) {
-    IGNORE_ALL_UPDATES(R.string.ignore_all_updates),
-    IGNORE_THIS_UPDATE(R.string.ignore_this_update)
-  }
-
-  private enum class SectionType(val titleResId: Int, val colorAttrResId: Int) {
-    ANTI_FEATURES(R.string.anti_features, R.attr.colorError),
-    CHANGES(R.string.changes, android.R.attr.colorAccent),
-    LINKS(R.string.links, android.R.attr.colorAccent),
-    DONATE(R.string.donate, android.R.attr.colorAccent),
-    PERMISSIONS(R.string.permissions, android.R.attr.colorAccent),
-    SCREENSHOTS(R.string.screenshots, android.R.attr.colorAccent),
-    VERSIONS(R.string.versions, android.R.attr.colorAccent)
-  }
-
-  internal enum class ExpandType { NOTHING, DESCRIPTION, CHANGES,
-    LINKS, DONATES, PERMISSIONS, SCREENSHOTS, VERSIONS }
-  private enum class TextType { DESCRIPTION, ANTI_FEATURES, CHANGES }
-
-  private enum class LinkType(val iconResId: Int, val titleResId: Int,
-    val format: ((Context, String) -> String)? = null) {
-    AUTHOR(R.drawable.ic_person, R.string.author_website),
-    EMAIL(R.drawable.ic_email, R.string.author_email),
-    LICENSE(R.drawable.ic_copyright, R.string.license,
-      format = { context, text -> context.getString(R.string.license_FORMAT, text) }),
-    SOURCE(R.drawable.ic_code, R.string.source_code),
-    TRACKER(R.drawable.ic_bug_report, R.string.bug_tracker),
-    CHANGELOG(R.drawable.ic_history, R.string.changelog),
-    WEB(R.drawable.ic_public, R.string.project_website)
-  }
-
-  private sealed class Item {
-    abstract val descriptor: String
-    abstract val viewType: ViewType
-
-    class HeaderItem(val repository: Repository, val product: Product): Item() {
-      override val descriptor: String
-        get() = "header"
-
-      override val viewType: ViewType
-        get() = ViewType.HEADER
-    }
-
-    class SwitchItem(val switchType: SwitchType, val packageName: String, val versionCode: Long): Item() {
-      override val descriptor: String
-        get() = "switch.${switchType.name}"
-
-      override val viewType: ViewType
-        get() = ViewType.SWITCH
-    }
-
-    class SectionItem(val sectionType: SectionType, val expandType: ExpandType,
-      val items: List<Item>, val collapseCount: Int): Item() {
-      constructor(sectionType: SectionType): this(sectionType, ExpandType.NOTHING, emptyList(), 0)
-
-      override val descriptor: String
-        get() = "section.${sectionType.name}"
-
-      override val viewType: ViewType
-        get() = ViewType.SECTION
-    }
-
-    class ExpandItem(val expandType: ExpandType, val replace: Boolean, val items: List<Item>): Item() {
-      override val descriptor: String
-        get() = "expand.${expandType.name}"
-
-      override val viewType: ViewType
-        get() = ViewType.EXPAND
-    }
-
-    class TextItem(val textType: TextType, val text: CharSequence): Item() {
-      override val descriptor: String
-        get() = "text.${textType.name}"
-
-      override val viewType: ViewType
-        get() = ViewType.TEXT
-    }
-
-    sealed class LinkItem: Item() {
-      override val viewType: ViewType
-        get() = ViewType.LINK
-
-      abstract val iconResId: Int
-      abstract fun getTitle(context: Context): String
-      abstract val uri: Uri?
-
-      val displayLink: String?
-        get() = uri?.schemeSpecificPart?.nullIfEmpty()
-          ?.let { if (it.startsWith("//")) null else it } ?: uri?.toString()
-
-      class Typed(val linkType: LinkType, val text: String, override val uri: Uri?): LinkItem() {
-        override val descriptor: String
-          get() = "link.typed.${linkType.name}"
-
-        override val iconResId: Int
-          get() = linkType.iconResId
-
-        override fun getTitle(context: Context): String {
-          return text.nullIfEmpty()?.let { linkType.format?.invoke(context, it) ?: it }
-            ?: context.getString(linkType.titleResId)
-        }
-      }
-
-      class Donate(val donate: Product.Donate): LinkItem() {
-        override val descriptor: String
-          get() = "link.donate.$donate"
-
-        override val iconResId: Int
-          get() = when (donate) {
-            is Product.Donate.Regular -> R.drawable.ic_public
-            is Product.Donate.Bitcoin -> R.drawable.ic_donate_bitcoin
-            is Product.Donate.Litecoin -> R.drawable.ic_donate_litecoin
-            is Product.Donate.Flattr -> R.drawable.ic_donate_flattr
-            is Product.Donate.Liberapay -> R.drawable.ic_donate_liberapay
-            is Product.Donate.OpenCollective -> R.drawable.ic_donate_opencollective
-          }
-
-        override fun getTitle(context: Context): String = when (donate) {
-          is Product.Donate.Regular -> context.getString(R.string.website)
-          is Product.Donate.Bitcoin -> "Bitcoin"
-          is Product.Donate.Litecoin -> "Litecoin"
-          is Product.Donate.Flattr -> "Flattr"
-          is Product.Donate.Liberapay -> "Liberapay"
-          is Product.Donate.OpenCollective -> "Open Collective"
-        }
-
-        override val uri: Uri? = when (donate) {
-          is Product.Donate.Regular -> Uri.parse(donate.url)
-          is Product.Donate.Bitcoin -> Uri.parse("bitcoin:${donate.address}")
-          is Product.Donate.Litecoin -> Uri.parse("litecoin:${donate.address}")
-          is Product.Donate.Flattr -> Uri.parse("https://flattr.com/thing/${donate.id}")
-          is Product.Donate.Liberapay -> Uri.parse("https://liberapay.com/~${donate.id}")
-          is Product.Donate.OpenCollective -> Uri.parse("https://opencollective.com/${donate.id}")
-        }
-      }
-    }
-
-    class PermissionsItem(val group: PermissionGroupInfo?, val permissions: List<PermissionInfo>): Item() {
-      override val descriptor: String
-        get() = "permissions.${group?.name}.${permissions.joinToString(separator = ".") { it.name }}"
-
-      override val viewType: ViewType
-        get() = ViewType.PERMISSIONS
-    }
-
-    class ScreenshotItem(val repository: Repository, val packageName: String,
-      val screenshot: Product.Screenshot): Item() {
-      override val descriptor: String
-        get() = "screenshot.${repository.id}.${screenshot.identifier}"
-
-      override val viewType: ViewType
-        get() = ViewType.SCREENSHOT
-    }
-
-    class ReleaseItem(val repository: Repository, val release: Release, val selectedRepository: Boolean,
-      val showSignature: Boolean): Item() {
-      override val descriptor: String
-        get() = "release.${repository.id}.${release.identifier}"
-
-      override val viewType: ViewType
-        get() = ViewType.RELEASE
-    }
-
-    class EmptyItem(val packageName: String): Item() {
-      override val descriptor: String
-        get() = "empty"
-
-      override val viewType: ViewType
-        get() = ViewType.EMPTY
-    }
-  }
-
-  private class Measurement<T: Any> {
-    private var density = 0f
-    private var scaledDensity = 0f
-    private lateinit var metric: T
-
-    fun measure(view: View) {
-      View.MeasureSpec.makeMeasureSpec(0, View.MeasureSpec.UNSPECIFIED).let { view.measure(it, it) }
-    }
-
-    fun invalidate(resources: Resources, callback: () -> T): T {
-      val (density, scaledDensity) = resources.displayMetrics.let { Pair(it.density, it.scaledDensity) }
-      if (this.density != density || this.scaledDensity != scaledDensity) {
-        this.density = density
-        this.scaledDensity = scaledDensity
-        metric = callback()
-      }
-      return metric
-    }
-  }
-
-  private enum class Payload { REFRESH, STATUS }
-
-  private class HeaderViewHolder(itemView: View): RecyclerView.ViewHolder(itemView) {
-    val icon = itemView.findViewById<ImageView>(R.id.icon)!!
-    val name = itemView.findViewById<TextView>(R.id.name)!!
-    val version = itemView.findViewById<TextView>(R.id.version)!!
-    val packageName = itemView.findViewById<TextView>(R.id.package_name)!!
-    val action = itemView.findViewById<Button>(R.id.action)!!
-    val statusLayout = itemView.findViewById<View>(R.id.status_layout)!!
-    val status = itemView.findViewById<TextView>(R.id.status)!!
-    val progress = itemView.findViewById<ProgressBar>(R.id.progress)!!
-
-    val progressIcon: Drawable
-    val defaultIcon: Drawable
-
-    val actionTintNormal = action.context.getColorFromAttr(android.R.attr.colorPrimary)
-    val actionTintCancel = action.context.getColorFromAttr(R.attr.colorError)
-
-    init {
-      if (Android.sdk(22)) {
-        action.setTextColor(action.context.getColorFromAttr(android.R.attr.colorBackground))
-      }
-      val (progressIcon, defaultIcon) = Utils.getDefaultApplicationIcons(icon.context)
-      this.progressIcon = progressIcon
-      this.defaultIcon = defaultIcon
-    }
-  }
-
-  private class SwitchViewHolder(itemView: View): RecyclerView.ViewHolder(itemView) {
-    val title = itemView.findViewById<TextView>(R.id.title)!!
-    val enabled = itemView.findViewById<Switch>(R.id.enabled)!!
-
-    val statefulViews: Sequence<View>
-      get() = sequenceOf(itemView, title, enabled)
-  }
-
-  private class SectionViewHolder(itemView: View): RecyclerView.ViewHolder(itemView) {
-    val title = itemView.findViewById<TextView>(R.id.title)!!
-    val icon = itemView.findViewById<ImageView>(R.id.icon)!!
-  }
-
-  private class ExpandViewHolder(context: Context): RecyclerView.ViewHolder(TextView(context)) {
-    val text: TextView
-      get() = itemView as TextView
-
-    init {
-      itemView as TextView
-      itemView.typeface = TypefaceExtra.medium
-      itemView.setTextSizeScaled(14)
-      itemView.setTextColor(itemView.context.getColorFromAttr(android.R.attr.colorAccent))
-      itemView.background = itemView.context.getDrawableFromAttr(android.R.attr.selectableItemBackground)
-      itemView.gravity = Gravity.CENTER
-      itemView.isAllCaps = true
-      itemView.layoutParams = RecyclerView.LayoutParams(RecyclerView.LayoutParams.MATCH_PARENT,
-        itemView.resources.sizeScaled(48)).apply { topMargin = -itemView.resources.sizeScaled(16) }
-    }
-  }
-
-  private class TextViewHolder(context: Context): RecyclerView.ViewHolder(TextView(context)) {
-    val text: TextView
-      get() = itemView as TextView
-
-    init {
-      itemView as TextView
-      itemView.setTextSizeScaled(14)
-      itemView.setTextColor(itemView.context.getColorFromAttr(android.R.attr.textColorPrimary))
-      itemView.resources.sizeScaled(16).let { itemView.setPadding(it, it, it, it) }
-      itemView.movementMethod = ClickableMovementMethod
-      itemView.layoutParams = RecyclerView.LayoutParams(RecyclerView.LayoutParams.MATCH_PARENT,
-        RecyclerView.LayoutParams.WRAP_CONTENT)
-    }
-  }
-
-  private open class OverlappingViewHolder(itemView: View): RecyclerView.ViewHolder(itemView) {
-    init {
-      // Block touch events if touched above negative margin
-      itemView.setOnTouchListener { _, event ->
-        event.action == MotionEvent.ACTION_DOWN && run {
-          val top = (itemView.layoutParams as ViewGroup.MarginLayoutParams).topMargin
-          top < 0 && event.y < -top
-        }
-      }
-    }
-  }
-
-  private class LinkViewHolder(itemView: View): OverlappingViewHolder(itemView) {
+class ProductAdapter(private val callbacks: Callbacks, private val columns: Int) :
+    StableRecyclerAdapter<ProductAdapter.ViewType, RecyclerView.ViewHolder>() {
     companion object {
-      private val measurement = Measurement<Int>()
+        private const val GRID_SPACING_OUTER_DP = 16
+        private const val GRID_SPACING_INNER_DP = 4
     }
 
-    val icon = itemView.findViewById<ImageView>(R.id.icon)!!
-    val text = itemView.findViewById<TextView>(R.id.text)!!
-    val link = itemView.findViewById<TextView>(R.id.link)!!
-
-    init {
-      val margin = measurement.invalidate(itemView.resources) {
-        @SuppressLint("SetTextI18n")
-        text.text = "measure"
-        link.visibility = View.GONE
-        measurement.measure(itemView)
-        ((itemView.measuredHeight - icon.measuredHeight) / 2f).roundToInt()
-      }
-      (icon.layoutParams as ViewGroup.MarginLayoutParams).apply {
-        topMargin += margin
-        bottomMargin += margin
-      }
-    }
-  }
-
-  private class PermissionsViewHolder(itemView: View): OverlappingViewHolder(itemView) {
-    companion object {
-      private val measurement = Measurement<Int>()
+    interface Callbacks {
+        fun onActionClick(action: Action)
+        fun onPreferenceChanged(preference: ProductPreference)
+        fun onPermissionsClick(group: String?, permissions: List<String>)
+        fun onScreenshotClick(screenshot: Product.Screenshot)
+        fun onReleaseClick(release: Release)
+        fun onUriClick(uri: Uri, shouldConfirm: Boolean): Boolean
     }
 
-    val icon = itemView.findViewById<ImageView>(R.id.icon)!!
-    val text = itemView.findViewById<TextView>(R.id.text)!!
-
-    init {
-      val margin = measurement.invalidate(itemView.resources) {
-        @SuppressLint("SetTextI18n")
-        text.text = "measure"
-        measurement.measure(itemView)
-        ((itemView.measuredHeight - icon.measuredHeight) / 2f).roundToInt()
-      }
-      (icon.layoutParams as ViewGroup.MarginLayoutParams).apply {
-        topMargin += margin
-        bottomMargin += margin
-      }
-    }
-  }
-
-  private class ScreenshotViewHolder(context: Context): RecyclerView.ViewHolder(FrameLayout(context)) {
-    val image: ImageView
-
-    val placeholder: Drawable
-
-    var gridPosition = -1
-    var gridCount = -1
-
-    init {
-      itemView as FrameLayout
-      itemView.foreground = itemView.context.getDrawableFromAttr(android.R.attr.selectableItemBackground)
-      val backgroundColor = itemView.context.getColorFromAttr(android.R.attr.colorBackground).defaultColor
-      val accentColor = itemView.context.getColorFromAttr(android.R.attr.colorAccent).defaultColor
-      val primaryColor = itemView.context.getColorFromAttr(android.R.attr.textColorPrimary).defaultColor
-
-      image = object: ImageView(context) {
-        override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
-          super.onMeasure(widthMeasureSpec, heightMeasureSpec)
-          setMeasuredDimension(measuredWidth, measuredWidth)
-        }
-      }
-      image.scaleType = ImageView.ScaleType.CENTER_CROP
-      image.setBackgroundColor(ColorUtils.blendARGB(backgroundColor, accentColor, 0.1f))
-      itemView.addView(image, FrameLayout.LayoutParams.MATCH_PARENT, FrameLayout.LayoutParams.WRAP_CONTENT)
-      itemView.layoutParams = RecyclerView.LayoutParams(RecyclerView.LayoutParams.MATCH_PARENT,
-        RecyclerView.LayoutParams.WRAP_CONTENT)
-
-      val placeholder = image.context.getDrawableCompat(R.drawable.ic_photo_camera).mutate()
-      placeholder.setTint(ColorUtils.blendARGB(primaryColor, accentColor, 0.5f)
-        .let { ColorUtils.blendARGB(0x00ffffff and it, it, 0.2f) })
-      this.placeholder = PaddingDrawable(placeholder, 2f)
-    }
-  }
-
-  private class ReleaseViewHolder(itemView: View): RecyclerView.ViewHolder(itemView) {
-    val dateFormat = DateFormat.getDateFormat(itemView.context)!!
-
-    val version = itemView.findViewById<TextView>(R.id.version)!!
-    val status = itemView.findViewById<TextView>(R.id.status)!!
-    val source = itemView.findViewById<TextView>(R.id.source)!!
-    val added = itemView.findViewById<TextView>(R.id.added)!!
-    val size = itemView.findViewById<TextView>(R.id.size)!!
-    val signature = itemView.findViewById<TextView>(R.id.signature)!!
-    val compatibility = itemView.findViewById<TextView>(R.id.compatibility)!!
-
-    val statefulViews: Sequence<View>
-      get() = sequenceOf(itemView, version, status, source, added, size, signature, compatibility)
-
-    val setStatusActive: (Boolean) -> Unit
-
-    init {
-      status.background = GradientDrawable(GradientDrawable.Orientation.TOP_BOTTOM, null).apply {
-        setStatusActive = { active -> color = itemView.context.getColorFromAttr(if (active)
-          android.R.attr.colorAccent else android.R.attr.textColorSecondary) }
-        cornerRadius = itemView.resources.sizeScaled(2).toFloat()
-      }
-    }
-  }
-
-  private class EmptyViewHolder(context: Context): RecyclerView.ViewHolder(LinearLayout(context)) {
-    val packageName: TextView
-
-    init {
-      itemView as LinearLayout
-      itemView.orientation = LinearLayout.VERTICAL
-      itemView.gravity = Gravity.CENTER
-      itemView.resources.sizeScaled(20).let { itemView.setPadding(it, it, it, it) }
-      val title = TextView(itemView.context)
-      title.gravity = Gravity.CENTER
-      title.typeface = TypefaceExtra.light
-      title.setTextColor(context.getColorFromAttr(android.R.attr.textColorPrimary))
-      title.setTextSizeScaled(20)
-      title.setText(R.string.application_not_found)
-      itemView.addView(title, LinearLayout.LayoutParams.MATCH_PARENT, LinearLayout.LayoutParams.WRAP_CONTENT)
-      val packageName = TextView(itemView.context)
-      packageName.gravity = Gravity.CENTER
-      packageName.setTextColor(context.getColorFromAttr(android.R.attr.textColorPrimary))
-      packageName.setTextSizeScaled(16)
-      itemView.addView(packageName, LinearLayout.LayoutParams.MATCH_PARENT, LinearLayout.LayoutParams.WRAP_CONTENT)
-      itemView.layoutParams = RecyclerView.LayoutParams(RecyclerView.LayoutParams.MATCH_PARENT,
-        RecyclerView.LayoutParams.MATCH_PARENT)
-      this.packageName = packageName
-    }
-  }
-
-  val gridItemDecoration = object: RecyclerView.ItemDecoration() {
-    private fun decorateScreenshot(outRect: Rect, parent: RecyclerView, position: Int, count: Int) {
-      val column = position % columns
-      val rows = (count + columns - 1) / columns
-      val row = position / columns
-      val outer = parent.resources.sizeScaled(GRID_SPACING_OUTER_DP)
-      val inner = parent.resources.sizeScaled(GRID_SPACING_INNER_DP)
-      val total = 2 * outer + (columns - 1) * inner
-      // Each column should have this spacing
-      val average = total / columns
-      // Start spacing is in the range from [outer] to [average - outer]
-      // Interpolate between these values
-      val start = (outer - ((2 * outer - average) * (column.toFloat() / (columns - 1)))).roundToInt()
-      val end = average - start
-      val bottom = if (row + 1 >= rows) outer else 0
-      val rtl = parent.layoutDirection == View.LAYOUT_DIRECTION_RTL
-      if (rtl) {
-        outRect.set(end, inner, start, bottom)
-      } else {
-        outRect.set(start, inner, end, bottom)
-      }
+    enum class Action(val titleResId: Int) {
+        INSTALL(R.string.install),
+        UPDATE(R.string.update),
+        LAUNCH(R.string.launch),
+        DETAILS(R.string.details),
+        UNINSTALL(R.string.uninstall),
+        CANCEL(R.string.cancel)
     }
 
-    override fun getItemOffsets(outRect: Rect, view: View, parent: RecyclerView, state: RecyclerView.State) {
-      val holder = parent.getChildViewHolder(view)
-      if (holder is ScreenshotViewHolder) {
-        val position = holder.adapterPosition
-        if (position >= 0) {
-          val first = items.subList(0, position).indexOfLast { it !is Item.ScreenshotItem } + 1
-          val gridCount = items.subList(first, items.size).indexOfFirst { it !is Item.ScreenshotItem }
-            .let { if (it < 0) items.size - first else it }
-          val gridPosition = position - first
-          decorateScreenshot(outRect, parent, gridPosition, gridCount)
-          holder.gridPosition = gridPosition
-          holder.gridCount = gridCount
-        } else if (position == -1 && holder.gridPosition >= 0 && holder.gridCount >= 0) {
-          decorateScreenshot(outRect, parent, holder.gridPosition, holder.gridCount)
-        }
-      }
+    sealed class Status {
+        object Pending : Status()
+        object Connecting : Status()
+        data class Downloading(val read: Long, val total: Long?) : Status()
     }
-  }
 
-  fun requiresGrid(position: Int): Boolean {
-    return items[position] is Item.ScreenshotItem
-  }
+    enum class ViewType { HEADER, SWITCH, SECTION, EXPAND, TEXT, LINK, PERMISSIONS, SCREENSHOT, RELEASE, EMPTY }
 
-  fun configureDivider(context: Context, position: Int, configuration: DividerItemDecoration.Configuration) {
-    val currentItem = items[position]
-    val nextItem = items.getOrNull(position + 1)
-    when {
-      nextItem == null || currentItem is Item.HeaderItem ||
-        nextItem is Item.TextItem && nextItem.textType == TextType.DESCRIPTION -> {
-        configuration.set(true, false, 0, 0)
-      }
-      nextItem is Item.SectionItem -> {
-        configuration.set(true, true, 0, 0)
-      }
-      currentItem is Item.LinkItem && nextItem is Item.LinkItem ||
-        currentItem is Item.PermissionsItem && nextItem is Item.PermissionsItem -> {
-        configuration.set(true, false, context.resources.sizeScaled(72), 0)
-      }
-      currentItem is Item.SwitchItem && nextItem is Item.SwitchItem ||
-        currentItem is Item.ReleaseItem && nextItem is Item.ReleaseItem -> {
-        configuration.set(true, false, context.resources.sizeScaled(16), 0)
-      }
-      else -> {
-        configuration.set(false, false, 0, 0)
-      }
+    private enum class SwitchType(val titleResId: Int) {
+        IGNORE_ALL_UPDATES(R.string.ignore_all_updates),
+        IGNORE_THIS_UPDATE(R.string.ignore_this_update)
     }
-  }
 
-  private val items = mutableListOf<Item>()
-  private val expanded = mutableSetOf<ExpandType>()
-  private var product: Product? = null
-  private var installedItem: InstalledItem? = null
+    private enum class SectionType(val titleResId: Int, val colorAttrResId: Int) {
+        ANTI_FEATURES(R.string.anti_features, R.attr.colorError),
+        CHANGES(R.string.changes, android.R.attr.colorAccent),
+        LINKS(R.string.links, android.R.attr.colorAccent),
+        DONATE(R.string.donate, android.R.attr.colorAccent),
+        PERMISSIONS(R.string.permissions, android.R.attr.colorAccent),
+        SCREENSHOTS(R.string.screenshots, android.R.attr.colorAccent),
+        VERSIONS(R.string.versions, android.R.attr.colorAccent)
+    }
 
-  fun setProducts(context: Context, packageName: String,
-    products: List<Pair<Product, Repository>>, installedItem: InstalledItem?) {
-    val productRepository = Product.findSuggested(products, installedItem) { it.first }
-    items.clear()
+    internal enum class ExpandType {
+        NOTHING, DESCRIPTION, CHANGES,
+        LINKS, DONATES, PERMISSIONS, SCREENSHOTS, VERSIONS
+    }
 
-    if (productRepository != null) {
-      items += Item.HeaderItem(productRepository.second, productRepository.first)
+    private enum class TextType { DESCRIPTION, ANTI_FEATURES, CHANGES }
 
-      if (installedItem != null) {
-        items.add(Item.SwitchItem(SwitchType.IGNORE_ALL_UPDATES, packageName, productRepository.first.versionCode))
-        if (productRepository.first.canUpdate(installedItem)) {
-          items.add(Item.SwitchItem(SwitchType.IGNORE_THIS_UPDATE, packageName, productRepository.first.versionCode))
+    private enum class LinkType(
+        val iconResId: Int, val titleResId: Int,
+        val format: ((Context, String) -> String)? = null
+    ) {
+        AUTHOR(R.drawable.ic_person, R.string.author_website),
+        EMAIL(R.drawable.ic_email, R.string.author_email),
+        LICENSE(R.drawable.ic_copyright, R.string.license,
+            format = { context, text -> context.getString(R.string.license_FORMAT, text) }),
+        SOURCE(R.drawable.ic_code, R.string.source_code),
+        TRACKER(R.drawable.ic_bug_report, R.string.bug_tracker),
+        CHANGELOG(R.drawable.ic_history, R.string.changelog),
+        WEB(R.drawable.ic_public, R.string.project_website)
+    }
+
+    private sealed class Item {
+        abstract val descriptor: String
+        abstract val viewType: ViewType
+
+        class HeaderItem(val repository: Repository, val product: Product) : Item() {
+            override val descriptor: String
+                get() = "header"
+
+            override val viewType: ViewType
+                get() = ViewType.HEADER
         }
-      }
 
-      val textViewHolder = TextViewHolder(context)
-      val textViewWidthSpec = context.resources.displayMetrics.widthPixels
-        .let { View.MeasureSpec.makeMeasureSpec(it, View.MeasureSpec.EXACTLY) }
-      val textViewHeightSpec = View.MeasureSpec.makeMeasureSpec(0, View.MeasureSpec.UNSPECIFIED)
+        class SwitchItem(
+            val switchType: SwitchType,
+            val packageName: String,
+            val versionCode: Long
+        ) : Item() {
+            override val descriptor: String
+                get() = "switch.${switchType.name}"
 
-      fun CharSequence.lineCropped(maxLines: Int, cropLines: Int): CharSequence? {
-        assert(cropLines <= maxLines)
-        textViewHolder.text.text = this
-        textViewHolder.itemView.measure(textViewWidthSpec, textViewHeightSpec)
-        textViewHolder.itemView.layout(0, 0, textViewHolder.itemView.measuredWidth,
-          textViewHolder.itemView.measuredHeight)
-        val layout = textViewHolder.text.layout
-        val cropLineOffset = if (layout.lineCount <= maxLines) -1 else layout.getLineEnd(cropLines - 1)
-        val paragraphEndIndex = if (cropLineOffset < 0) -1 else
-          indexOf("\n\n", cropLineOffset).let { if (it >= 0) it else length }
-        val paragraphEndLine = if (paragraphEndIndex < 0) -1 else
-          layout.getLineForOffset(paragraphEndIndex).apply { assert(this >= 0) }
-        val end = when {
-          cropLineOffset < 0 -> -1
-          paragraphEndLine >= 0 && paragraphEndLine - (cropLines - 1) <= 3 ->
-            if (paragraphEndIndex < length) paragraphEndIndex else -1
-          else -> cropLineOffset
+            override val viewType: ViewType
+                get() = ViewType.SWITCH
         }
-        val length = if (end < 0) -1 else asSequence().take(end)
-          .indexOfLast { it != '\n' }.let { if (it >= 0) it + 1 else end }
-        return if (length >= 0) subSequence(0, length) else null
-      }
 
-      val description = formatHtml(productRepository.first.description).apply {
-        if (productRepository.first.let { it.summary.isNotEmpty() && it.name != it.summary }) {
-          if (isNotEmpty()) {
-            insert(0, "\n\n")
-          }
-          insert(0, productRepository.first.summary)
-          if (isNotEmpty()) {
-            setSpan(TypefaceSpan("sans-serif-medium"), 0, productRepository.first.summary.length,
-              SpannableStringBuilder.SPAN_EXCLUSIVE_EXCLUSIVE)
-          }
-        }
-      }
-      if (description.isNotEmpty()) {
-        val cropped = if (ExpandType.DESCRIPTION !in expanded) description.lineCropped(12, 10) else null
-        val item = Item.TextItem(TextType.DESCRIPTION, description)
-        if (cropped != null) {
-          items += listOf(Item.TextItem(TextType.DESCRIPTION, cropped),
-            Item.ExpandItem(ExpandType.DESCRIPTION, true, listOf(item)))
-        } else {
-          items += item
-        }
-      }
+        class SectionItem(
+            val sectionType: SectionType, val expandType: ExpandType,
+            val items: List<Item>, val collapseCount: Int
+        ) : Item() {
+            constructor(sectionType: SectionType) : this(
+                sectionType,
+                ExpandType.NOTHING,
+                emptyList(),
+                0
+            )
 
-      val antiFeatures = productRepository.first.antiFeatures.map {
-        when (it) {
-          "Ads" -> context.getString(R.string.has_advertising)
-          "ApplicationDebuggable" -> context.getString(R.string.compiled_for_debugging)
-          "DisabledAlgorithm" -> context.getString(R.string.signed_using_unsafe_algorithm)
-          "KnownVuln" -> context.getString(R.string.has_security_vulnerabilities)
-          "NoSourceSince" -> context.getString(R.string.source_code_no_longer_available)
-          "NonFreeAdd" -> context.getString(R.string.promotes_non_free_software)
-          "NonFreeAssets" -> context.getString(R.string.contains_non_free_media)
-          "NonFreeDep" -> context.getString(R.string.has_non_free_dependencies)
-          "NonFreeNet" -> context.getString(R.string.promotes_non_free_network_services)
-          "Tracking" -> context.getString(R.string.tracks_or_reports_your_activity)
-          "UpstreamNonFree" -> context.getString(R.string.upstream_source_code_is_not_free)
-          else -> context.getString(R.string.unknown_FORMAT, it)
-        }
-      }.joinToString(separator = "\n") { "\u2022 $it" }
-      if (antiFeatures.isNotEmpty()) {
-        items += Item.SectionItem(SectionType.ANTI_FEATURES)
-        items += Item.TextItem(TextType.ANTI_FEATURES, antiFeatures)
-      }
+            override val descriptor: String
+                get() = "section.${sectionType.name}"
 
-      val changes = formatHtml(productRepository.first.whatsNew)
-      if (changes.isNotEmpty()) {
-        items += Item.SectionItem(SectionType.CHANGES)
-        val cropped = if (ExpandType.CHANGES !in expanded) changes.lineCropped(12, 10) else null
-        val item = Item.TextItem(TextType.CHANGES, changes)
-        if (cropped != null) {
-          items += listOf(Item.TextItem(TextType.CHANGES, cropped),
-            Item.ExpandItem(ExpandType.CHANGES, true, listOf(item)))
-        } else {
-          items += item
+            override val viewType: ViewType
+                get() = ViewType.SECTION
         }
-      }
 
-      val linkItems = mutableListOf<Item>()
-      productRepository.first.apply {
-        if (author.name.isNotEmpty() || author.web.isNotEmpty()) {
-          linkItems += Item.LinkItem.Typed(LinkType.AUTHOR, author.name, author.web.nullIfEmpty()?.let(Uri::parse))
-        }
-        author.email.nullIfEmpty()?.let { linkItems += Item.LinkItem
-          .Typed(LinkType.EMAIL, "", Uri.parse("mailto:$it")) }
-        linkItems += licenses.asSequence().map { Item.LinkItem.Typed(LinkType.LICENSE, it,
-          Uri.parse("https://spdx.org/licenses/$it.html")) }
-        source.nullIfEmpty()?.let { linkItems += Item.LinkItem.Typed(LinkType.SOURCE, "", Uri.parse(it)) }
-        tracker.nullIfEmpty()?.let { linkItems += Item.LinkItem.Typed(LinkType.TRACKER, "", Uri.parse(it)) }
-        changelog.nullIfEmpty()?.let { linkItems += Item.LinkItem.Typed(LinkType.CHANGELOG, "", Uri.parse(it)) }
-        web.nullIfEmpty()?.let { linkItems += Item.LinkItem.Typed(LinkType.WEB, "", Uri.parse(it)) }
-      }
-      if (linkItems.isNotEmpty()) {
-        if (ExpandType.LINKS in expanded) {
-          items += Item.SectionItem(SectionType.LINKS, ExpandType.LINKS, emptyList(), linkItems.size)
-          items += linkItems
-        } else {
-          items += Item.SectionItem(SectionType.LINKS, ExpandType.LINKS, linkItems, 0)
-        }
-      }
+        class ExpandItem(val expandType: ExpandType, val replace: Boolean, val items: List<Item>) :
+            Item() {
+            override val descriptor: String
+                get() = "expand.${expandType.name}"
 
-      val donateItems = productRepository.first.donates.map(Item.LinkItem::Donate)
-      if (donateItems.isNotEmpty()) {
-        if (ExpandType.DONATES in expanded) {
-          items += Item.SectionItem(SectionType.DONATE, ExpandType.DONATES, emptyList(), donateItems.size)
-          items += donateItems
-        } else {
-          items += Item.SectionItem(SectionType.DONATE, ExpandType.DONATES, donateItems, 0)
+            override val viewType: ViewType
+                get() = ViewType.EXPAND
         }
-      }
 
-      val release = productRepository.first.displayRelease
-      if (release != null) {
-        val packageManager = context.packageManager
-        val permissions = release.permissions
-          .asSequence().mapNotNull {
-            try {
-              packageManager.getPermissionInfo(it, 0)
-            } catch (e: Exception) {
-              null
+        class TextItem(val textType: TextType, val text: CharSequence) : Item() {
+            override val descriptor: String
+                get() = "text.${textType.name}"
+
+            override val viewType: ViewType
+                get() = ViewType.TEXT
+        }
+
+        sealed class LinkItem : Item() {
+            override val viewType: ViewType
+                get() = ViewType.LINK
+
+            abstract val iconResId: Int
+            abstract fun getTitle(context: Context): String
+            abstract val uri: Uri?
+
+            val displayLink: String?
+                get() = uri?.schemeSpecificPart?.nullIfEmpty()
+                    ?.let { if (it.startsWith("//")) null else it } ?: uri?.toString()
+
+            class Typed(val linkType: LinkType, val text: String, override val uri: Uri?) :
+                LinkItem() {
+                override val descriptor: String
+                    get() = "link.typed.${linkType.name}"
+
+                override val iconResId: Int
+                    get() = linkType.iconResId
+
+                override fun getTitle(context: Context): String {
+                    return text.nullIfEmpty()?.let { linkType.format?.invoke(context, it) ?: it }
+                        ?: context.getString(linkType.titleResId)
+                }
             }
-          }
-          .groupBy(PackageItemResolver::getPermissionGroup)
-          .asSequence().map { (group, permissionInfo) ->
-            val permissionGroupInfo = try {
-              group?.let { packageManager.getPermissionGroupInfo(it, 0) }
-            } catch (e: Exception) {
-              null
-            }
-            Pair(permissionGroupInfo, permissionInfo)
-          }
-          .groupBy({ it.first }, { it.second })
-        if (permissions.isNotEmpty()) {
-          val permissionsItems = mutableListOf<Item>()
-          permissionsItems += permissions.asSequence().filter { it.key != null }
-            .map { Item.PermissionsItem(it.key, it.value.flatten()) }
-          permissions.asSequence().find { it.key == null }
-            ?.let { permissionsItems += Item.PermissionsItem(null, it.value.flatten()) }
-          if (ExpandType.PERMISSIONS in expanded) {
-            items += Item.SectionItem(SectionType.PERMISSIONS, ExpandType.PERMISSIONS,
-              emptyList(), permissionsItems.size)
-            items += permissionsItems
-          } else {
-            items += Item.SectionItem(SectionType.PERMISSIONS, ExpandType.PERMISSIONS, permissionsItems, 0)
-          }
-        }
-      }
 
-      val screenshotItems = productRepository.first.screenshots
-        .map { Item.ScreenshotItem(productRepository.second, packageName, it) }
-      if (screenshotItems.isNotEmpty()) {
-        if (ExpandType.SCREENSHOTS in expanded) {
-          items += Item.SectionItem(SectionType.SCREENSHOTS, ExpandType.SCREENSHOTS, emptyList(), screenshotItems.size)
-          items += screenshotItems
-        } else {
-          items += Item.SectionItem(SectionType.SCREENSHOTS, ExpandType.SCREENSHOTS, screenshotItems, 0)
+            class Donate(val donate: Product.Donate) : LinkItem() {
+                override val descriptor: String
+                    get() = "link.donate.$donate"
+
+                override val iconResId: Int
+                    get() = when (donate) {
+                        is Product.Donate.Regular -> R.drawable.ic_public
+                        is Product.Donate.Bitcoin -> R.drawable.ic_donate_bitcoin
+                        is Product.Donate.Litecoin -> R.drawable.ic_donate_litecoin
+                        is Product.Donate.Flattr -> R.drawable.ic_donate_flattr
+                        is Product.Donate.Liberapay -> R.drawable.ic_donate_liberapay
+                        is Product.Donate.OpenCollective -> R.drawable.ic_donate_opencollective
+                    }
+
+                override fun getTitle(context: Context): String = when (donate) {
+                    is Product.Donate.Regular -> context.getString(R.string.website)
+                    is Product.Donate.Bitcoin -> "Bitcoin"
+                    is Product.Donate.Litecoin -> "Litecoin"
+                    is Product.Donate.Flattr -> "Flattr"
+                    is Product.Donate.Liberapay -> "Liberapay"
+                    is Product.Donate.OpenCollective -> "Open Collective"
+                }
+
+                override val uri: Uri? = when (donate) {
+                    is Product.Donate.Regular -> Uri.parse(donate.url)
+                    is Product.Donate.Bitcoin -> Uri.parse("bitcoin:${donate.address}")
+                    is Product.Donate.Litecoin -> Uri.parse("litecoin:${donate.address}")
+                    is Product.Donate.Flattr -> Uri.parse("https://flattr.com/thing/${donate.id}")
+                    is Product.Donate.Liberapay -> Uri.parse("https://liberapay.com/~${donate.id}")
+                    is Product.Donate.OpenCollective -> Uri.parse("https://opencollective.com/${donate.id}")
+                }
+            }
+        }
+
+        class PermissionsItem(
+            val group: PermissionGroupInfo?,
+            val permissions: List<PermissionInfo>
+        ) : Item() {
+            override val descriptor: String
+                get() = "permissions.${group?.name}.${permissions.joinToString(separator = ".") { it.name }}"
+
+            override val viewType: ViewType
+                get() = ViewType.PERMISSIONS
+        }
+
+        class ScreenshotItem(
+            val repository: Repository, val packageName: String,
+            val screenshot: Product.Screenshot
+        ) : Item() {
+            override val descriptor: String
+                get() = "screenshot.${repository.id}.${screenshot.identifier}"
+
+            override val viewType: ViewType
+                get() = ViewType.SCREENSHOT
+        }
+
+        class ReleaseItem(
+            val repository: Repository, val release: Release, val selectedRepository: Boolean,
+            val showSignature: Boolean
+        ) : Item() {
+            override val descriptor: String
+                get() = "release.${repository.id}.${release.identifier}"
+
+            override val viewType: ViewType
+                get() = ViewType.RELEASE
+        }
+
+        class EmptyItem(val packageName: String) : Item() {
+            override val descriptor: String
+                get() = "empty"
+
+            override val viewType: ViewType
+                get() = ViewType.EMPTY
         }
-      }
     }
 
-    val incompatible = Preferences[Preferences.Key.IncompatibleVersions]
-    val compatibleReleasePairs = products.asSequence()
-      .flatMap { (product, repository) -> product.releases.asSequence()
-        .filter { incompatible || it.incompatibilities.isEmpty() }
-        .map { Pair(it, repository) } }
-      .toList()
-    val signaturesForVersionCode = compatibleReleasePairs.asSequence()
-      .mapNotNull { (release, _) -> if (release.signature.isEmpty()) null else
-        Pair(release.versionCode, release.signature) }
-      .distinct().groupBy { it.first }.toMap()
-    val releaseItems = compatibleReleasePairs.asSequence()
-      .map { (release, repository) -> Item.ReleaseItem(repository, release,
-        repository.id == productRepository?.second?.id,
-        signaturesForVersionCode[release.versionCode].orEmpty().size >= 2) }
-      .sortedByDescending { it.release.versionCode }
-      .toList()
-    if (releaseItems.isNotEmpty()) {
-      items += Item.SectionItem(SectionType.VERSIONS)
-      val maxReleases = 5
-      if (releaseItems.size > maxReleases && ExpandType.VERSIONS !in expanded) {
-        items += releaseItems.take(maxReleases)
-        items += Item.ExpandItem(ExpandType.VERSIONS, false, releaseItems.takeLast(releaseItems.size - maxReleases))
-      } else {
-        items += releaseItems
-      }
+    private class Measurement<T : Any> {
+        private var density = 0f
+        private var scaledDensity = 0f
+        private lateinit var metric: T
+
+        fun measure(view: View) {
+            View.MeasureSpec.makeMeasureSpec(0, View.MeasureSpec.UNSPECIFIED)
+                .let { view.measure(it, it) }
+        }
+
+        fun invalidate(resources: Resources, callback: () -> T): T {
+            val (density, scaledDensity) = resources.displayMetrics.let {
+                Pair(
+                    it.density,
+                    it.scaledDensity
+                )
+            }
+            if (this.density != density || this.scaledDensity != scaledDensity) {
+                this.density = density
+                this.scaledDensity = scaledDensity
+                metric = callback()
+            }
+            return metric
+        }
     }
 
-    if (items.isEmpty()) {
-      items += Item.EmptyItem(packageName)
+    private enum class Payload { REFRESH, STATUS }
+
+    private class HeaderViewHolder(itemView: View) : RecyclerView.ViewHolder(itemView) {
+        val icon = itemView.findViewById<ImageView>(R.id.icon)!!
+        val name = itemView.findViewById<TextView>(R.id.name)!!
+        val version = itemView.findViewById<TextView>(R.id.version)!!
+        val packageName = itemView.findViewById<TextView>(R.id.package_name)!!
+        val action = itemView.findViewById<Button>(R.id.action)!!
+        val statusLayout = itemView.findViewById<View>(R.id.status_layout)!!
+        val status = itemView.findViewById<TextView>(R.id.status)!!
+        val progress = itemView.findViewById<ProgressBar>(R.id.progress)!!
+
+        val progressIcon: Drawable
+        val defaultIcon: Drawable
+
+        val actionTintNormal = action.context.getColorFromAttr(android.R.attr.colorPrimary)
+        val actionTintCancel = action.context.getColorFromAttr(R.attr.colorError)
+
+        init {
+            if (Android.sdk(22)) {
+                action.setTextColor(action.context.getColorFromAttr(android.R.attr.textColor))
+            }
+            val (progressIcon, defaultIcon) = Utils.getDefaultApplicationIcons(icon.context)
+            this.progressIcon = progressIcon
+            this.defaultIcon = defaultIcon
+        }
     }
-    this.product = productRepository?.first
-    this.installedItem = installedItem
-    notifyDataSetChanged()
-  }
 
-  private var action: Action? = null
+    private class SwitchViewHolder(itemView: View) : RecyclerView.ViewHolder(itemView) {
+        val title = itemView.findViewById<TextView>(R.id.title)!!
+        val enabled = itemView.findViewById<Switch>(R.id.enabled)!!
 
-  fun setAction(action: Action?) {
-    if (this.action != action) {
-      val translate = this.action == null || action == null ||
-        this.action == Action.CANCEL || action == Action.CANCEL
-      this.action = action
-      val index = items.indexOfFirst { it is Item.HeaderItem }
-      if (index >= 0) {
-        if (translate) {
-          notifyItemChanged(index)
-        } else {
-          notifyItemChanged(index, Payload.REFRESH)
-        }
-      }
+        val statefulViews: Sequence<View>
+            get() = sequenceOf(itemView, title, enabled)
     }
-  }
 
-  private var status: Status? = null
-
-  fun setStatus(status: Status?) {
-    val translate = (this.status == null) != (status == null)
-    if (this.status != status) {
-      this.status = status
-      val index = items.indexOfFirst { it is Item.HeaderItem }
-      if (index >= 0) {
-        if (translate) {
-          notifyItemChanged(index)
-          val from = items.indexOfFirst { it is Item.ReleaseItem }
-          val to = items.indexOfLast { it is Item.ReleaseItem }
-          if (from in 0 .. to) {
-            notifyItemRangeChanged(from, to - from + 1)
-          }
-        } else {
-          notifyItemChanged(index, Payload.STATUS)
-        }
-      }
+    private class SectionViewHolder(itemView: View) : RecyclerView.ViewHolder(itemView) {
+        val title = itemView.findViewById<TextView>(R.id.title)!!
+        val icon = itemView.findViewById<ImageView>(R.id.icon)!!
     }
-  }
 
-  override val viewTypeClass: Class<ViewType>
-    get() = ViewType::class.java
+    private class ExpandViewHolder(context: Context) : RecyclerView.ViewHolder(TextView(context)) {
+        val text: TextView
+            get() = itemView as TextView
 
-  override fun getItemCount(): Int = items.size
-  override fun getItemDescriptor(position: Int): String = items[position].descriptor
-  override fun getItemEnumViewType(position: Int): ViewType = items[position].viewType
-
-  override fun onCreateViewHolder(parent: ViewGroup, viewType: ViewType): RecyclerView.ViewHolder {
-    return when (viewType) {
-      ViewType.HEADER -> HeaderViewHolder(parent.inflate(R.layout.product_header_item)).apply {
-        action.setOnClickListener { this@ProductAdapter.action?.let(callbacks::onActionClick) }
-      }
-      ViewType.SWITCH -> SwitchViewHolder(parent.inflate(R.layout.switch_item)).apply {
-        itemView.setOnClickListener {
-          val switchItem = items[adapterPosition] as Item.SwitchItem
-          val productPreference = when (switchItem.switchType) {
-            SwitchType.IGNORE_ALL_UPDATES -> {
-              ProductPreferences[switchItem.packageName].let { it.copy(ignoreUpdates = !it.ignoreUpdates) }
+        init {
+            itemView as TextView
+            itemView.typeface = TypefaceExtra.medium
+            itemView.setTextSizeScaled(14)
+            itemView.setTextColor(itemView.context.getColorFromAttr(android.R.attr.textColor))
+            itemView.background =
+                itemView.resources.getDrawable(R.drawable.background_border, context.theme)
+            itemView.gravity = Gravity.CENTER
+            itemView.isAllCaps = true
+            itemView.layoutParams = RecyclerView.LayoutParams(
+                RecyclerView.LayoutParams.MATCH_PARENT,
+                itemView.resources.sizeScaled(48)
+            ).apply {
+                topMargin = itemView.resources.sizeScaled(16)
+                leftMargin = itemView.resources.sizeScaled(30)
+                rightMargin = itemView.resources.sizeScaled(30)
             }
-            SwitchType.IGNORE_THIS_UPDATE -> {
-              ProductPreferences[switchItem.packageName].let { it.copy(ignoreVersionCode =
-                if (it.ignoreVersionCode == switchItem.versionCode) 0 else switchItem.versionCode) }
-            }
-          }
-          ProductPreferences[switchItem.packageName] = productPreference
-          items.asSequence().mapIndexedNotNull { index, item -> if (item is Item.HeaderItem ||
-            item is Item.SectionItem) index else null }.forEach { notifyItemChanged(it, Payload.REFRESH) }
-          callbacks.onPreferenceChanged(productPreference)
         }
-      }
-      ViewType.SECTION -> SectionViewHolder(parent.inflate(R.layout.section_item)).apply {
-        itemView.setOnClickListener {
-          val position = adapterPosition
-          val sectionItem = items[position] as Item.SectionItem
-          if (sectionItem.items.isNotEmpty()) {
-            expanded += sectionItem.expandType
-            items[position] = Item.SectionItem(sectionItem.sectionType, sectionItem.expandType, emptyList(),
-              sectionItem.items.size + sectionItem.collapseCount)
-            notifyItemChanged(adapterPosition, Payload.REFRESH)
-            items.addAll(position + 1, sectionItem.items)
-            notifyItemRangeInserted(position + 1, sectionItem.items.size)
-          } else if (sectionItem.collapseCount > 0) {
-            expanded -= sectionItem.expandType
-            items[position] = Item.SectionItem(sectionItem.sectionType, sectionItem.expandType,
-              items.subList(position + 1, position + 1 + sectionItem.collapseCount).toList(), 0)
-            notifyItemChanged(adapterPosition, Payload.REFRESH)
-            repeat(sectionItem.collapseCount) { items.removeAt(position + 1) }
-            notifyItemRangeRemoved(position + 1, sectionItem.collapseCount)
-          }
-        }
-      }
-      ViewType.EXPAND -> ExpandViewHolder(parent.context).apply {
-        itemView.setOnClickListener {
-          val position = adapterPosition
-          val expandItem = items[position] as Item.ExpandItem
-          items.removeAt(position)
-          expanded += expandItem.expandType
-          if (expandItem.replace) {
-            expandItem.items.forEachIndexed { index, item ->
-              items[position - expandItem.items.size + index] = item
-            }
-            notifyItemRangeChanged(position - expandItem.items.size, expandItem.items.size)
-            notifyItemRemoved(position)
-          } else {
-            items.addAll(position, expandItem.items)
-            if (position > 0) {
-              // Update decorations
-              notifyItemChanged(position - 1, Payload.REFRESH)
-            }
-            notifyItemRemoved(position)
-            notifyItemRangeInserted(position, expandItem.items.size)
-          }
-        }
-      }
-      ViewType.TEXT -> TextViewHolder(parent.context)
-      ViewType.LINK -> LinkViewHolder(parent.inflate(R.layout.link_item)).apply {
-        itemView.setOnClickListener {
-          val linkItem = items[adapterPosition] as Item.LinkItem
-          if (linkItem.uri?.let { callbacks.onUriClick(it, false) } != true) {
-            linkItem.displayLink?.let { copyLinkToClipboard(itemView.context, it) }
-          }
-        }
-        itemView.setOnLongClickListener {
-          val linkItem = items[adapterPosition] as Item.LinkItem
-          linkItem.displayLink?.let { copyLinkToClipboard(itemView.context, it) }
-          true
-        }
-      }
-      ViewType.PERMISSIONS -> PermissionsViewHolder(parent.inflate(R.layout.permissions_item)).apply {
-        itemView.setOnClickListener {
-          val permissionsItem = items[adapterPosition] as Item.PermissionsItem
-          callbacks.onPermissionsClick(permissionsItem.group?.name, permissionsItem.permissions.map { it.name })
-        }
-      }
-      ViewType.SCREENSHOT -> ScreenshotViewHolder(parent.context).apply {
-        itemView.setOnClickListener {
-          val screenshotItem = items[adapterPosition] as Item.ScreenshotItem
-          callbacks.onScreenshotClick(screenshotItem.screenshot)
-        }
-      }
-      ViewType.RELEASE -> ReleaseViewHolder(parent.inflate(R.layout.release_item)).apply {
-        itemView.setOnClickListener {
-          val releaseItem = items[adapterPosition] as Item.ReleaseItem
-          callbacks.onReleaseClick(releaseItem.release)
-        }
-      }
-      ViewType.EMPTY -> EmptyViewHolder(parent.context)
     }
-  }
 
-  override fun onBindViewHolder(holder: RecyclerView.ViewHolder, position: Int) {
-    onBindViewHolder(holder, position, emptyList())
-  }
+    private class TextViewHolder(context: Context) : RecyclerView.ViewHolder(TextView(context)) {
+        val text: TextView
+            get() = itemView as TextView
 
-  override fun onBindViewHolder(holder: RecyclerView.ViewHolder, position: Int, payloads: List<Any>) {
-    val context = holder.itemView.context
-    val item = items[position]
-    when (getItemEnumViewType(position)) {
-      ViewType.HEADER -> {
-        holder as HeaderViewHolder
-        item as Item.HeaderItem
-        val installedItem = installedItem
-        val updateStatus = Payload.STATUS in payloads
-        val updateAll = !updateStatus
-        if (updateAll) {
-          if (item.product.icon.isNotEmpty() || item.product.metadataIcon.isNotEmpty()) {
-            holder.icon.load(PicassoDownloader.createIconUri(holder.icon, item.product.packageName,
-              item.product.icon, item.product.metadataIcon, item.repository)) {
-              placeholder(holder.progressIcon)
-              error(holder.defaultIcon)
-            }
-          } else {
-            holder.icon.clear()
-            holder.icon.setImageDrawable(holder.defaultIcon)
-          }
-          holder.name.text = item.product.name
-          val canUpdate = item.product.canUpdate(installedItem) &&
-            !ProductPreferences[item.product.packageName].shouldIgnoreUpdate(item.product.versionCode)
-          val version = (if (canUpdate) item.product.version else installedItem?.version)?.nullIfEmpty()
-            ?: item.product.version.nullIfEmpty()
-          holder.version.text = version?.let { context.getString(R.string.version_FORMAT, it) }
-            ?: context.getString(R.string.unknown)
-          holder.packageName.text = item.product.packageName
-          val action = action
-          holder.action.visibility = if (action == null) View.GONE else View.VISIBLE
-          if (action != null) {
-            holder.action.setText(action.titleResId)
-          }
-          if (Android.sdk(22)) {
-            holder.action.backgroundTintList = if (action == Action.CANCEL)
-              holder.actionTintCancel else holder.actionTintNormal
-          }
+        init {
+            itemView as TextView
+            itemView.setTextSizeScaled(14)
+            itemView.setTextColor(itemView.context.getColorFromAttr(android.R.attr.textColor))
+            itemView.resources.sizeScaled(16).let { itemView.setPadding(it, it, it, it) }
+            itemView.movementMethod = ClickableMovementMethod
+            itemView.layoutParams = RecyclerView.LayoutParams(
+                RecyclerView.LayoutParams.MATCH_PARENT,
+                RecyclerView.LayoutParams.WRAP_CONTENT
+            )
         }
-        if (updateAll || updateStatus) {
-          val status = status
-          holder.statusLayout.visibility = if (status != null) View.VISIBLE else View.GONE
-          if (status != null) {
-            when (status) {
-              is Status.Pending -> {
-                holder.status.setText(R.string.waiting_to_start_download)
-                holder.progress.isIndeterminate = true
-              }
-              is Status.Connecting -> {
-                holder.status.setText(R.string.connecting)
-                holder.progress.isIndeterminate = true
-              }
-              is Status.Downloading -> {
-                holder.status.text = context.getString(R.string.downloading_FORMAT, if (status.total == null)
-                  status.read.formatSize() else "${status.read.formatSize()} / ${status.total.formatSize()}")
-                holder.progress.isIndeterminate = status.total == null
-                if (status.total != null) {
-                  holder.progress.progress = (holder.progress.max.toFloat() * status.read / status.total).roundToInt()
+    }
+
+    private open class OverlappingViewHolder(itemView: View) : RecyclerView.ViewHolder(itemView) {
+        init {
+            // Block touch events if touched above negative margin
+            itemView.setOnTouchListener { _, event ->
+                event.action == MotionEvent.ACTION_DOWN && run {
+                    val top = (itemView.layoutParams as ViewGroup.MarginLayoutParams).topMargin
+                    top < 0 && event.y < -top
+                }
+            }
+        }
+    }
+
+    private class LinkViewHolder(itemView: View) : OverlappingViewHolder(itemView) {
+        companion object {
+            private val measurement = Measurement<Int>()
+        }
+
+        val icon = itemView.findViewById<ImageView>(R.id.icon)!!
+        val text = itemView.findViewById<TextView>(R.id.text)!!
+        val link = itemView.findViewById<TextView>(R.id.link)!!
+
+        init {
+            val margin = measurement.invalidate(itemView.resources) {
+                @SuppressLint("SetTextI18n")
+                text.text = "measure"
+                link.visibility = View.GONE
+                measurement.measure(itemView)
+                ((itemView.measuredHeight - icon.measuredHeight) / 2f).roundToInt()
+            }
+            (icon.layoutParams as ViewGroup.MarginLayoutParams).apply {
+                topMargin += margin
+                bottomMargin += margin
+            }
+        }
+    }
+
+    private class PermissionsViewHolder(itemView: View) : OverlappingViewHolder(itemView) {
+        companion object {
+            private val measurement = Measurement<Int>()
+        }
+
+        val icon = itemView.findViewById<ImageView>(R.id.icon)!!
+        val text = itemView.findViewById<TextView>(R.id.text)!!
+
+        init {
+            val margin = measurement.invalidate(itemView.resources) {
+                @SuppressLint("SetTextI18n")
+                text.text = "measure"
+                measurement.measure(itemView)
+                ((itemView.measuredHeight - icon.measuredHeight) / 2f).roundToInt()
+            }
+            (icon.layoutParams as ViewGroup.MarginLayoutParams).apply {
+                topMargin += margin
+                bottomMargin += margin
+            }
+        }
+    }
+
+    private class ScreenshotViewHolder(context: Context) :
+        RecyclerView.ViewHolder(FrameLayout(context)) {
+        val image: ImageView
+
+        val placeholder: Drawable
+
+        var gridPosition = -1
+        var gridCount = -1
+
+        init {
+            itemView as FrameLayout
+            itemView.foreground =
+                itemView.context.getDrawableFromAttr(android.R.attr.selectableItemBackground)
+            val backgroundColor =
+                itemView.context.getColorFromAttr(android.R.attr.colorBackground).defaultColor
+            val accentColor =
+                itemView.context.getColorFromAttr(android.R.attr.colorAccent).defaultColor
+            val primaryColor =
+                itemView.context.getColorFromAttr(android.R.attr.textColor).defaultColor
+
+            image = object : ImageView(context) {
+                override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
+                    super.onMeasure(widthMeasureSpec, heightMeasureSpec)
+                    setMeasuredDimension(measuredWidth, measuredWidth)
+                }
+            }
+            image.scaleType = ImageView.ScaleType.CENTER_CROP
+            image.setBackgroundColor(ColorUtils.blendARGB(backgroundColor, accentColor, 0.1f))
+            itemView.addView(
+                image,
+                FrameLayout.LayoutParams.MATCH_PARENT,
+                FrameLayout.LayoutParams.WRAP_CONTENT
+            )
+            itemView.layoutParams = RecyclerView.LayoutParams(
+                RecyclerView.LayoutParams.MATCH_PARENT,
+                RecyclerView.LayoutParams.WRAP_CONTENT
+            )
+
+            val placeholder = image.context.getDrawableCompat(R.drawable.ic_photo_camera).mutate()
+            placeholder.setTint(ColorUtils.blendARGB(primaryColor, accentColor, 0.5f)
+                .let { ColorUtils.blendARGB(0x00ffffff and it, it, 0.2f) })
+            this.placeholder = PaddingDrawable(placeholder, 2f)
+        }
+    }
+
+    private class ReleaseViewHolder(itemView: View) : RecyclerView.ViewHolder(itemView) {
+        val dateFormat = DateFormat.getDateFormat(itemView.context)!!
+
+        val version = itemView.findViewById<TextView>(R.id.version)!!
+        val status = itemView.findViewById<TextView>(R.id.status)!!
+        val source = itemView.findViewById<TextView>(R.id.source)!!
+        val added = itemView.findViewById<TextView>(R.id.added)!!
+        val size = itemView.findViewById<TextView>(R.id.size)!!
+        val signature = itemView.findViewById<TextView>(R.id.signature)!!
+        val compatibility = itemView.findViewById<TextView>(R.id.compatibility)!!
+
+        val statefulViews: Sequence<View>
+            get() = sequenceOf(
+                itemView,
+                version,
+                status,
+                source,
+                added,
+                size,
+                signature,
+                compatibility
+            )
+
+        val setStatusActive: (Boolean) -> Unit
+
+        init {
+            status.background =
+                GradientDrawable(GradientDrawable.Orientation.TOP_BOTTOM, null).apply {
+                    setStatusActive = { active ->
+                        color = itemView.context.getColorFromAttr(
+                            if (active)
+                                android.R.attr.colorAccent else android.R.attr.textColorSecondary
+                        )
+                    }
+                    cornerRadius = itemView.resources.sizeScaled(2).toFloat()
+                }
+        }
+    }
+
+    private class EmptyViewHolder(context: Context) :
+        RecyclerView.ViewHolder(LinearLayout(context)) {
+        val packageName: TextView
+
+        init {
+            itemView as LinearLayout
+            itemView.orientation = LinearLayout.VERTICAL
+            itemView.gravity = Gravity.CENTER
+            itemView.resources.sizeScaled(20).let { itemView.setPadding(it, it, it, it) }
+            val title = TextView(itemView.context)
+            title.gravity = Gravity.CENTER
+            title.typeface = TypefaceExtra.light
+            title.setTextColor(context.getColorFromAttr(android.R.attr.textColorPrimary))
+            title.setTextSizeScaled(20)
+            title.setText(R.string.application_not_found)
+            itemView.addView(
+                title,
+                LinearLayout.LayoutParams.MATCH_PARENT,
+                LinearLayout.LayoutParams.WRAP_CONTENT
+            )
+            val packageName = TextView(itemView.context)
+            packageName.gravity = Gravity.CENTER
+            packageName.setTextColor(context.getColorFromAttr(android.R.attr.textColorPrimary))
+            packageName.setTextSizeScaled(16)
+            itemView.addView(
+                packageName,
+                LinearLayout.LayoutParams.MATCH_PARENT,
+                LinearLayout.LayoutParams.WRAP_CONTENT
+            )
+            itemView.layoutParams = RecyclerView.LayoutParams(
+                RecyclerView.LayoutParams.MATCH_PARENT,
+                RecyclerView.LayoutParams.MATCH_PARENT
+            )
+            this.packageName = packageName
+        }
+    }
+
+    val gridItemDecoration = object : RecyclerView.ItemDecoration() {
+        private fun decorateScreenshot(
+            outRect: Rect,
+            parent: RecyclerView,
+            position: Int,
+            count: Int
+        ) {
+            val column = position % columns
+            val rows = (count + columns - 1) / columns
+            val row = position / columns
+            val outer = parent.resources.sizeScaled(GRID_SPACING_OUTER_DP)
+            val inner = parent.resources.sizeScaled(GRID_SPACING_INNER_DP)
+            val total = 2 * outer + (columns - 1) * inner
+            // Each column should have this spacing
+            val average = total / columns
+            // Start spacing is in the range from [outer] to [average - outer]
+            // Interpolate between these values
+            val start =
+                (outer - ((2 * outer - average) * (column.toFloat() / (columns - 1)))).roundToInt()
+            val end = average - start
+            val bottom = if (row + 1 >= rows) outer else 0
+            val rtl = parent.layoutDirection == View.LAYOUT_DIRECTION_RTL
+            if (rtl) {
+                outRect.set(end, inner, start, bottom)
+            } else {
+                outRect.set(start, inner, end, bottom)
+            }
+        }
+
+        override fun getItemOffsets(
+            outRect: Rect,
+            view: View,
+            parent: RecyclerView,
+            state: RecyclerView.State
+        ) {
+            val holder = parent.getChildViewHolder(view)
+            if (holder is ScreenshotViewHolder) {
+                val position = holder.adapterPosition
+                if (position >= 0) {
+                    val first =
+                        items.subList(0, position).indexOfLast { it !is Item.ScreenshotItem } + 1
+                    val gridCount =
+                        items.subList(first, items.size).indexOfFirst { it !is Item.ScreenshotItem }
+                            .let { if (it < 0) items.size - first else it }
+                    val gridPosition = position - first
+                    decorateScreenshot(outRect, parent, gridPosition, gridCount)
+                    holder.gridPosition = gridPosition
+                    holder.gridCount = gridCount
+                } else if (position == -1 && holder.gridPosition >= 0 && holder.gridCount >= 0) {
+                    decorateScreenshot(outRect, parent, holder.gridPosition, holder.gridCount)
+                }
+            }
+        }
+    }
+
+    fun requiresGrid(position: Int): Boolean {
+        return items[position] is Item.ScreenshotItem
+    }
+
+    private val items = mutableListOf<Item>()
+    private val expanded = mutableSetOf<ExpandType>()
+    private var product: Product? = null
+    private var installedItem: InstalledItem? = null
+
+    fun setProducts(
+        context: Context, packageName: String,
+        products: List<Pair<Product, Repository>>, installedItem: InstalledItem?
+    ) {
+        val productRepository = Product.findSuggested(products, installedItem) { it.first }
+        items.clear()
+
+        if (productRepository != null) {
+            items += Item.HeaderItem(productRepository.second, productRepository.first)
+
+            if (installedItem != null) {
+                items.add(
+                    Item.SwitchItem(
+                        SwitchType.IGNORE_ALL_UPDATES,
+                        packageName,
+                        productRepository.first.versionCode
+                    )
+                )
+                if (productRepository.first.canUpdate(installedItem)) {
+                    items.add(
+                        Item.SwitchItem(
+                            SwitchType.IGNORE_THIS_UPDATE,
+                            packageName,
+                            productRepository.first.versionCode
+                        )
+                    )
+                }
+            }
+
+            val textViewHolder = TextViewHolder(context)
+            val textViewWidthSpec = context.resources.displayMetrics.widthPixels
+                .let { View.MeasureSpec.makeMeasureSpec(it, View.MeasureSpec.EXACTLY) }
+            val textViewHeightSpec =
+                View.MeasureSpec.makeMeasureSpec(0, View.MeasureSpec.UNSPECIFIED)
+
+            fun CharSequence.lineCropped(maxLines: Int, cropLines: Int): CharSequence? {
+                assert(cropLines <= maxLines)
+                textViewHolder.text.text = this
+                textViewHolder.itemView.measure(textViewWidthSpec, textViewHeightSpec)
+                textViewHolder.itemView.layout(
+                    0, 0, textViewHolder.itemView.measuredWidth,
+                    textViewHolder.itemView.measuredHeight
+                )
+                val layout = textViewHolder.text.layout
+                val cropLineOffset =
+                    if (layout.lineCount <= maxLines) -1 else layout.getLineEnd(cropLines - 1)
+                val paragraphEndIndex = if (cropLineOffset < 0) -1 else
+                    indexOf("\n\n", cropLineOffset).let { if (it >= 0) it else length }
+                val paragraphEndLine = if (paragraphEndIndex < 0) -1 else
+                    layout.getLineForOffset(paragraphEndIndex).apply { assert(this >= 0) }
+                val end = when {
+                    cropLineOffset < 0 -> -1
+                    paragraphEndLine >= 0 && paragraphEndLine - (cropLines - 1) <= 3 ->
+                        if (paragraphEndIndex < length) paragraphEndIndex else -1
+                    else -> cropLineOffset
+                }
+                val length = if (end < 0) -1 else asSequence().take(end)
+                    .indexOfLast { it != '\n' }.let { if (it >= 0) it + 1 else end }
+                return if (length >= 0) subSequence(0, length) else null
+            }
+
+            val description = formatHtml(productRepository.first.description).apply {
+                if (productRepository.first.let { it.summary.isNotEmpty() && it.name != it.summary }) {
+                    if (isNotEmpty()) {
+                        insert(0, "\n\n")
+                    }
+                    insert(0, productRepository.first.summary)
+                    if (isNotEmpty()) {
+                        setSpan(
+                            TypefaceSpan("sans-serif-medium"),
+                            0,
+                            productRepository.first.summary.length,
+                            SpannableStringBuilder.SPAN_EXCLUSIVE_EXCLUSIVE
+                        )
+                    }
+                }
+            }
+            if (description.isNotEmpty()) {
+                val cropped = if (ExpandType.DESCRIPTION !in expanded) description.lineCropped(
+                    12,
+                    10
+                ) else null
+                val item = Item.TextItem(TextType.DESCRIPTION, description)
+                if (cropped != null) {
+                    items += listOf(
+                        Item.TextItem(TextType.DESCRIPTION, cropped),
+                        Item.ExpandItem(ExpandType.DESCRIPTION, true, listOf(item))
+                    )
+                } else {
+                    items += item
+                }
+            }
+
+            val antiFeatures = productRepository.first.antiFeatures.map {
+                when (it) {
+                    "Ads" -> context.getString(R.string.has_advertising)
+                    "ApplicationDebuggable" -> context.getString(R.string.compiled_for_debugging)
+                    "DisabledAlgorithm" -> context.getString(R.string.signed_using_unsafe_algorithm)
+                    "KnownVuln" -> context.getString(R.string.has_security_vulnerabilities)
+                    "NoSourceSince" -> context.getString(R.string.source_code_no_longer_available)
+                    "NonFreeAdd" -> context.getString(R.string.promotes_non_free_software)
+                    "NonFreeAssets" -> context.getString(R.string.contains_non_free_media)
+                    "NonFreeDep" -> context.getString(R.string.has_non_free_dependencies)
+                    "NonFreeNet" -> context.getString(R.string.promotes_non_free_network_services)
+                    "Tracking" -> context.getString(R.string.tracks_or_reports_your_activity)
+                    "UpstreamNonFree" -> context.getString(R.string.upstream_source_code_is_not_free)
+                    else -> context.getString(R.string.unknown_FORMAT, it)
+                }
+            }.joinToString(separator = "\n") { "\u2022 $it" }
+            if (antiFeatures.isNotEmpty()) {
+                items += Item.SectionItem(SectionType.ANTI_FEATURES)
+                items += Item.TextItem(TextType.ANTI_FEATURES, antiFeatures)
+            }
+
+            val changes = formatHtml(productRepository.first.whatsNew)
+            if (changes.isNotEmpty()) {
+                items += Item.SectionItem(SectionType.CHANGES)
+                val cropped =
+                    if (ExpandType.CHANGES !in expanded) changes.lineCropped(12, 10) else null
+                val item = Item.TextItem(TextType.CHANGES, changes)
+                if (cropped != null) {
+                    items += listOf(
+                        Item.TextItem(TextType.CHANGES, cropped),
+                        Item.ExpandItem(ExpandType.CHANGES, true, listOf(item))
+                    )
+                } else {
+                    items += item
+                }
+            }
+
+            val linkItems = mutableListOf<Item>()
+            productRepository.first.apply {
+                if (author.name.isNotEmpty() || author.web.isNotEmpty()) {
+                    linkItems += Item.LinkItem.Typed(
+                        LinkType.AUTHOR,
+                        author.name,
+                        author.web.nullIfEmpty()?.let(Uri::parse)
+                    )
+                }
+                author.email.nullIfEmpty()?.let {
+                    linkItems += Item.LinkItem
+                        .Typed(LinkType.EMAIL, "", Uri.parse("mailto:$it"))
+                }
+                linkItems += licenses.asSequence().map {
+                    Item.LinkItem.Typed(
+                        LinkType.LICENSE, it,
+                        Uri.parse("https://spdx.org/licenses/$it.html")
+                    )
+                }
+                source.nullIfEmpty()
+                    ?.let { linkItems += Item.LinkItem.Typed(LinkType.SOURCE, "", Uri.parse(it)) }
+                tracker.nullIfEmpty()
+                    ?.let { linkItems += Item.LinkItem.Typed(LinkType.TRACKER, "", Uri.parse(it)) }
+                changelog.nullIfEmpty()?.let {
+                    linkItems += Item.LinkItem.Typed(
+                        LinkType.CHANGELOG,
+                        "",
+                        Uri.parse(it)
+                    )
+                }
+                web.nullIfEmpty()
+                    ?.let { linkItems += Item.LinkItem.Typed(LinkType.WEB, "", Uri.parse(it)) }
+            }
+            if (linkItems.isNotEmpty()) {
+                if (ExpandType.LINKS in expanded) {
+                    items += Item.SectionItem(
+                        SectionType.LINKS,
+                        ExpandType.LINKS,
+                        emptyList(),
+                        linkItems.size
+                    )
+                    items += linkItems
+                } else {
+                    items += Item.SectionItem(SectionType.LINKS, ExpandType.LINKS, linkItems, 0)
+                }
+            }
+
+            val donateItems = productRepository.first.donates.map(Item.LinkItem::Donate)
+            if (donateItems.isNotEmpty()) {
+                if (ExpandType.DONATES in expanded) {
+                    items += Item.SectionItem(
+                        SectionType.DONATE,
+                        ExpandType.DONATES,
+                        emptyList(),
+                        donateItems.size
+                    )
+                    items += donateItems
+                } else {
+                    items += Item.SectionItem(
+                        SectionType.DONATE,
+                        ExpandType.DONATES,
+                        donateItems,
+                        0
+                    )
+                }
+            }
+
+            val release = productRepository.first.displayRelease
+            if (release != null) {
+                val packageManager = context.packageManager
+                val permissions = release.permissions
+                    .asSequence().mapNotNull {
+                        try {
+                            packageManager.getPermissionInfo(it, 0)
+                        } catch (e: Exception) {
+                            null
+                        }
+                    }
+                    .groupBy(PackageItemResolver::getPermissionGroup)
+                    .asSequence().map { (group, permissionInfo) ->
+                        val permissionGroupInfo = try {
+                            group?.let { packageManager.getPermissionGroupInfo(it, 0) }
+                        } catch (e: Exception) {
+                            null
+                        }
+                        Pair(permissionGroupInfo, permissionInfo)
+                    }
+                    .groupBy({ it.first }, { it.second })
+                if (permissions.isNotEmpty()) {
+                    val permissionsItems = mutableListOf<Item>()
+                    permissionsItems += permissions.asSequence().filter { it.key != null }
+                        .map { Item.PermissionsItem(it.key, it.value.flatten()) }
+                    permissions.asSequence().find { it.key == null }
+                        ?.let { permissionsItems += Item.PermissionsItem(null, it.value.flatten()) }
+                    if (ExpandType.PERMISSIONS in expanded) {
+                        items += Item.SectionItem(
+                            SectionType.PERMISSIONS, ExpandType.PERMISSIONS,
+                            emptyList(), permissionsItems.size
+                        )
+                        items += permissionsItems
+                    } else {
+                        items += Item.SectionItem(
+                            SectionType.PERMISSIONS,
+                            ExpandType.PERMISSIONS,
+                            permissionsItems,
+                            0
+                        )
+                    }
+                }
+            }
+
+            val screenshotItems = productRepository.first.screenshots
+                .map { Item.ScreenshotItem(productRepository.second, packageName, it) }
+            if (screenshotItems.isNotEmpty()) {
+                items += Item.SectionItem(
+                    SectionType.SCREENSHOTS,
+                    ExpandType.SCREENSHOTS,
+                    emptyList(),
+                    screenshotItems.size
+                )
+                items += screenshotItems
+
+            }
+        }
+
+        val incompatible = Preferences[Preferences.Key.IncompatibleVersions]
+        val compatibleReleasePairs = products.asSequence()
+            .flatMap { (product, repository) ->
+                product.releases.asSequence()
+                    .filter { incompatible || it.incompatibilities.isEmpty() }
+                    .map { Pair(it, repository) }
+            }
+            .toList()
+        val signaturesForVersionCode = compatibleReleasePairs.asSequence()
+            .mapNotNull { (release, _) ->
+                if (release.signature.isEmpty()) null else
+                    Pair(release.versionCode, release.signature)
+            }
+            .distinct().groupBy { it.first }.toMap()
+        val releaseItems = compatibleReleasePairs.asSequence()
+            .map { (release, repository) ->
+                Item.ReleaseItem(
+                    repository, release,
+                    repository.id == productRepository?.second?.id,
+                    signaturesForVersionCode[release.versionCode].orEmpty().size >= 2
+                )
+            }
+            .sortedByDescending { it.release.versionCode }
+            .toList()
+        if (releaseItems.isNotEmpty()) {
+            items += Item.SectionItem(SectionType.VERSIONS)
+            val maxReleases = 5
+            if (releaseItems.size > maxReleases && ExpandType.VERSIONS !in expanded) {
+                items += releaseItems.take(maxReleases)
+                items += Item.ExpandItem(
+                    ExpandType.VERSIONS,
+                    false,
+                    releaseItems.takeLast(releaseItems.size - maxReleases)
+                )
+            } else {
+                items += releaseItems
+            }
+        }
+
+        if (items.isEmpty()) {
+            items += Item.EmptyItem(packageName)
+        }
+        this.product = productRepository?.first
+        this.installedItem = installedItem
+        notifyDataSetChanged()
+    }
+
+    private var action: Action? = null
+
+    fun setAction(action: Action?) {
+        if (this.action != action) {
+            val translate = this.action == null || action == null ||
+                    this.action == Action.CANCEL || action == Action.CANCEL
+            this.action = action
+            val index = items.indexOfFirst { it is Item.HeaderItem }
+            if (index >= 0) {
+                if (translate) {
+                    notifyItemChanged(index)
+                } else {
+                    notifyItemChanged(index, Payload.REFRESH)
+                }
+            }
+        }
+    }
+
+    private var status: Status? = null
+
+    fun setStatus(status: Status?) {
+        val translate = (this.status == null) != (status == null)
+        if (this.status != status) {
+            this.status = status
+            val index = items.indexOfFirst { it is Item.HeaderItem }
+            if (index >= 0) {
+                if (translate) {
+                    notifyItemChanged(index)
+                    val from = items.indexOfFirst { it is Item.ReleaseItem }
+                    val to = items.indexOfLast { it is Item.ReleaseItem }
+                    if (from in 0..to) {
+                        notifyItemRangeChanged(from, to - from + 1)
+                    }
+                } else {
+                    notifyItemChanged(index, Payload.STATUS)
+                }
+            }
+        }
+    }
+
+    override val viewTypeClass: Class<ViewType>
+        get() = ViewType::class.java
+
+    override fun getItemCount(): Int = items.size
+    override fun getItemDescriptor(position: Int): String = items[position].descriptor
+    override fun getItemEnumViewType(position: Int): ViewType = items[position].viewType
+
+    override fun onCreateViewHolder(
+        parent: ViewGroup,
+        viewType: ViewType
+    ): RecyclerView.ViewHolder {
+        return when (viewType) {
+            ViewType.HEADER -> HeaderViewHolder(parent.inflate(R.layout.product_header_item)).apply {
+                action.setOnClickListener { this@ProductAdapter.action?.let(callbacks::onActionClick) }
+            }
+            ViewType.SWITCH -> SwitchViewHolder(parent.inflate(R.layout.switch_item)).apply {
+                itemView.setOnClickListener {
+                    val switchItem = items[adapterPosition] as Item.SwitchItem
+                    val productPreference = when (switchItem.switchType) {
+                        SwitchType.IGNORE_ALL_UPDATES -> {
+                            ProductPreferences[switchItem.packageName].let { it.copy(ignoreUpdates = !it.ignoreUpdates) }
+                        }
+                        SwitchType.IGNORE_THIS_UPDATE -> {
+                            ProductPreferences[switchItem.packageName].let {
+                                it.copy(
+                                    ignoreVersionCode =
+                                    if (it.ignoreVersionCode == switchItem.versionCode) 0 else switchItem.versionCode
+                                )
+                            }
+                        }
+                    }
+                    ProductPreferences[switchItem.packageName] = productPreference
+                    items.asSequence().mapIndexedNotNull { index, item ->
+                        if (item is Item.HeaderItem ||
+                            item is Item.SectionItem
+                        ) index else null
+                    }.forEach { notifyItemChanged(it, Payload.REFRESH) }
+                    callbacks.onPreferenceChanged(productPreference)
+                }
+            }
+            ViewType.SECTION -> SectionViewHolder(parent.inflate(R.layout.section_item)).apply {
+                itemView.setOnClickListener {
+                    val position = adapterPosition
+                    val sectionItem = items[position] as Item.SectionItem
+                    if (sectionItem.items.isNotEmpty()) {
+                        expanded += sectionItem.expandType
+                        items[position] = Item.SectionItem(
+                            sectionItem.sectionType, sectionItem.expandType, emptyList(),
+                            sectionItem.items.size + sectionItem.collapseCount
+                        )
+                        notifyItemChanged(adapterPosition, Payload.REFRESH)
+                        items.addAll(position + 1, sectionItem.items)
+                        notifyItemRangeInserted(position + 1, sectionItem.items.size)
+                    } else if (sectionItem.collapseCount > 0) {
+                        expanded -= sectionItem.expandType
+                        items[position] = Item.SectionItem(
+                            sectionItem.sectionType, sectionItem.expandType,
+                            items.subList(position + 1, position + 1 + sectionItem.collapseCount)
+                                .toList(), 0
+                        )
+                        notifyItemChanged(adapterPosition, Payload.REFRESH)
+                        repeat(sectionItem.collapseCount) { items.removeAt(position + 1) }
+                        notifyItemRangeRemoved(position + 1, sectionItem.collapseCount)
+                    }
+                }
+            }
+            ViewType.EXPAND -> ExpandViewHolder(parent.context).apply {
+                itemView.setOnClickListener {
+                    val position = adapterPosition
+                    val expandItem = items[position] as Item.ExpandItem
+                    items.removeAt(position)
+                    expanded += expandItem.expandType
+                    if (expandItem.replace) {
+                        expandItem.items.forEachIndexed { index, item ->
+                            items[position - expandItem.items.size + index] = item
+                        }
+                        notifyItemRangeChanged(
+                            position - expandItem.items.size,
+                            expandItem.items.size
+                        )
+                        notifyItemRemoved(position)
+                    } else {
+                        items.addAll(position, expandItem.items)
+                        if (position > 0) {
+                            // Update decorations
+                            notifyItemChanged(position - 1, Payload.REFRESH)
+                        }
+                        notifyItemRemoved(position)
+                        notifyItemRangeInserted(position, expandItem.items.size)
+                    }
+                }
+            }
+            ViewType.TEXT -> TextViewHolder(parent.context)
+            ViewType.LINK -> LinkViewHolder(parent.inflate(R.layout.link_item)).apply {
+                itemView.setOnClickListener {
+                    val linkItem = items[adapterPosition] as Item.LinkItem
+                    if (linkItem.uri?.let { callbacks.onUriClick(it, false) } != true) {
+                        linkItem.displayLink?.let { copyLinkToClipboard(itemView.context, it) }
+                    }
+                }
+                itemView.setOnLongClickListener {
+                    val linkItem = items[adapterPosition] as Item.LinkItem
+                    linkItem.displayLink?.let { copyLinkToClipboard(itemView.context, it) }
+                    true
+                }
+            }
+            ViewType.PERMISSIONS -> PermissionsViewHolder(parent.inflate(R.layout.permissions_item)).apply {
+                itemView.setOnClickListener {
+                    val permissionsItem = items[adapterPosition] as Item.PermissionsItem
+                    callbacks.onPermissionsClick(
+                        permissionsItem.group?.name,
+                        permissionsItem.permissions.map { it.name })
+                }
+            }
+            ViewType.SCREENSHOT -> ScreenshotViewHolder(parent.context).apply {
+                itemView.setOnClickListener {
+                    val screenshotItem = items[adapterPosition] as Item.ScreenshotItem
+                    callbacks.onScreenshotClick(screenshotItem.screenshot)
+                }
+            }
+            ViewType.RELEASE -> ReleaseViewHolder(parent.inflate(R.layout.release_item)).apply {
+                itemView.setOnClickListener {
+                    val releaseItem = items[adapterPosition] as Item.ReleaseItem
+                    callbacks.onReleaseClick(releaseItem.release)
+                }
+            }
+            ViewType.EMPTY -> EmptyViewHolder(parent.context)
+        }
+    }
+
+    override fun onBindViewHolder(holder: RecyclerView.ViewHolder, position: Int) {
+        onBindViewHolder(holder, position, emptyList())
+    }
+
+    override fun onBindViewHolder(
+        holder: RecyclerView.ViewHolder,
+        position: Int,
+        payloads: List<Any>
+    ) {
+        val context = holder.itemView.context
+        val item = items[position]
+        when (getItemEnumViewType(position)) {
+            ViewType.HEADER -> {
+                holder as HeaderViewHolder
+                item as Item.HeaderItem
+                val installedItem = installedItem
+                val updateStatus = Payload.STATUS in payloads
+                val updateAll = !updateStatus
+                if (updateAll) {
+                    if (item.product.icon.isNotEmpty() || item.product.metadataIcon.isNotEmpty()) {
+                        holder.icon.load(
+                            PicassoDownloader.createIconUri(
+                                holder.icon, item.product.packageName,
+                                item.product.icon, item.product.metadataIcon, item.repository
+                            )
+                        ) {
+                            placeholder(holder.progressIcon)
+                            error(holder.defaultIcon)
+                        }
+                    } else {
+                        holder.icon.clear()
+                        holder.icon.setImageDrawable(holder.defaultIcon)
+                    }
+                    holder.name.text = item.product.name
+                    val canUpdate = item.product.canUpdate(installedItem) &&
+                            !ProductPreferences[item.product.packageName].shouldIgnoreUpdate(item.product.versionCode)
+                    val version =
+                        (if (canUpdate) item.product.version else installedItem?.version)?.nullIfEmpty()
+                            ?: item.product.version.nullIfEmpty()
+                    holder.version.text =
+                        version?.let { context.getString(R.string.version_FORMAT, it) }
+                            ?: context.getString(R.string.unknown)
+                    holder.packageName.text = item.product.packageName
+                    val action = action
+                    holder.action.visibility = if (action == null) View.GONE else View.VISIBLE
+                    if (action != null) {
+                        holder.action.setText(action.titleResId)
+                    }
+                    if (Android.sdk(22)) {
+                        holder.action.backgroundTintList = if (action == Action.CANCEL)
+                            holder.actionTintCancel else holder.actionTintNormal
+                    }
+                }
+                if (updateAll || updateStatus) {
+                    val status = status
+                    holder.statusLayout.visibility = if (status != null) View.VISIBLE else View.GONE
+                    if (status != null) {
+                        when (status) {
+                            is Status.Pending -> {
+                                holder.status.setText(R.string.waiting_to_start_download)
+                                holder.progress.isIndeterminate = true
+                            }
+                            is Status.Connecting -> {
+                                holder.status.setText(R.string.connecting)
+                                holder.progress.isIndeterminate = true
+                            }
+                            is Status.Downloading -> {
+                                holder.status.text = context.getString(
+                                    R.string.downloading_FORMAT, if (status.total == null)
+                                        status.read.formatSize() else "${status.read.formatSize()} / ${status.total.formatSize()}"
+                                )
+                                holder.progress.isIndeterminate = status.total == null
+                                if (status.total != null) {
+                                    holder.progress.progress =
+                                        (holder.progress.max.toFloat() * status.read / status.total).roundToInt()
+                                }
+                                Unit
+                            }
+                        }::class
+                    }
                 }
                 Unit
-              }
-            }::class
-          }
-        }
-        Unit
-      }
-      ViewType.SWITCH -> {
-        holder as SwitchViewHolder
-        item as Item.SwitchItem
-        holder.title.setText(item.switchType.titleResId)
-        val (checked, enabled) = when (item.switchType) {
-          SwitchType.IGNORE_ALL_UPDATES -> {
-            val productPreference = ProductPreferences[item.packageName]
-            Pair(productPreference.ignoreUpdates, true)
-          }
-          SwitchType.IGNORE_THIS_UPDATE -> {
-            val productPreference = ProductPreferences[item.packageName]
-            Pair(productPreference.ignoreUpdates || productPreference.ignoreVersionCode == item.versionCode,
-              !productPreference.ignoreUpdates)
-          }
-        }
-        holder.enabled.isChecked = checked
-        holder.statefulViews.forEach { it.isEnabled = enabled }
-      }
-      ViewType.SECTION -> {
-        holder as SectionViewHolder
-        item as Item.SectionItem
-        val expandable = item.items.isNotEmpty() || item.collapseCount > 0
-        holder.itemView.isEnabled = expandable
-        holder.itemView.let { it.setPadding(it.paddingLeft, it.paddingTop, it.paddingRight,
-          if (expandable) it.paddingTop else 0) }
-        val color = context.getColorFromAttr(item.sectionType.colorAttrResId)
-        holder.title.setTextColor(color)
-        holder.title.text = context.getString(item.sectionType.titleResId)
-        holder.icon.visibility = if (expandable) View.VISIBLE else View.GONE
-        holder.icon.scaleY = if (item.collapseCount > 0) -1f else 1f
-        holder.icon.imageTintList = color
-      }
-      ViewType.EXPAND -> {
-        holder as ExpandViewHolder
-        item as Item.ExpandItem
-        holder.text.setText(when (item.expandType) {
-          ExpandType.VERSIONS -> R.string.show_older_versions
-          else -> R.string.show_more
-        })
-      }
-      ViewType.TEXT -> {
-        holder as TextViewHolder
-        item as Item.TextItem
-        holder.text.text = item.text
-      }
-      ViewType.LINK -> {
-        holder as LinkViewHolder
-        item as Item.LinkItem
-        val layoutParams = holder.itemView.layoutParams as RecyclerView.LayoutParams
-        layoutParams.topMargin = if (position > 0 && items[position - 1] !is Item.LinkItem)
-          -context.resources.sizeScaled(8) else 0
-        holder.itemView.isEnabled = item.uri != null
-        holder.icon.setImageDrawable(holder.icon.context.getDrawableCompat(item.iconResId))
-        holder.text.text = item.getTitle(context)
-        holder.link.visibility = if (item.uri != null) View.VISIBLE else View.GONE
-        holder.link.text = item.displayLink
-      }
-      ViewType.PERMISSIONS -> {
-        holder as PermissionsViewHolder
-        item as Item.PermissionsItem
-        val layoutParams = holder.itemView.layoutParams as RecyclerView.LayoutParams
-        layoutParams.topMargin = if (position > 0 && items[position - 1] !is Item.PermissionsItem)
-          -context.resources.sizeScaled(8) else 0
-        val packageManager = context.packageManager
-        holder.icon.setImageDrawable(if (item.group != null && item.group.icon != 0) {
-          if (Android.sdk(22)) {
-            item.group.loadUnbadgedIcon(packageManager)
-          } else {
-            item.group.loadIcon(packageManager)
-          }
-        } else {
-          null
-        } ?: context.getDrawableCompat(R.drawable.ic_perm_device_information))
-        val localCache = PackageItemResolver.LocalCache()
-        val labels = item.permissions.map { permission ->
-          val labelFromPackage = PackageItemResolver.loadLabel(context, localCache, permission)
-          val label = labelFromPackage ?: run {
-            val prefixes = listOf("android.permission.", "com.android.browser.permission.")
-            prefixes.find { permission.name.startsWith(it) }?.let {
-              val transform = permission.name.substring(it.length)
-              if (transform.matches("[A-Z_]+".toRegex())) {
-                transform.split("_").joinToString(separator = " ") { it.toLowerCase(Locale.US) }
-              } else {
-                null
-              }
             }
-          }
-          if (label == null) {
-            Pair(false, permission.name)
-          } else {
-            Pair(true, label.first().toUpperCase() + label.substring(1, label.length))
-          }
+            ViewType.SWITCH -> {
+                holder as SwitchViewHolder
+                item as Item.SwitchItem
+                holder.title.setText(item.switchType.titleResId)
+                val (checked, enabled) = when (item.switchType) {
+                    SwitchType.IGNORE_ALL_UPDATES -> {
+                        val productPreference = ProductPreferences[item.packageName]
+                        Pair(productPreference.ignoreUpdates, true)
+                    }
+                    SwitchType.IGNORE_THIS_UPDATE -> {
+                        val productPreference = ProductPreferences[item.packageName]
+                        Pair(
+                            productPreference.ignoreUpdates || productPreference.ignoreVersionCode == item.versionCode,
+                            !productPreference.ignoreUpdates
+                        )
+                    }
+                }
+                holder.enabled.isChecked = checked
+                holder.statefulViews.forEach { it.isEnabled = enabled }
+            }
+            ViewType.SECTION -> {
+                holder as SectionViewHolder
+                item as Item.SectionItem
+                val expandable = item.items.isNotEmpty() || item.collapseCount > 0
+                holder.itemView.isEnabled = expandable
+                holder.itemView.let {
+                    it.setPadding(
+                        it.paddingLeft, it.paddingTop, it.paddingRight,
+                        if (expandable) it.paddingTop else 0
+                    )
+                }
+                val color = context.getColorFromAttr(item.sectionType.colorAttrResId)
+                holder.title.setTextColor(color)
+                holder.title.text = context.getString(item.sectionType.titleResId)
+                holder.icon.visibility = if (expandable) View.VISIBLE else View.GONE
+                holder.icon.scaleY = if (item.collapseCount > 0) -1f else 1f
+                holder.icon.imageTintList = color
+            }
+            ViewType.EXPAND -> {
+                holder as ExpandViewHolder
+                item as Item.ExpandItem
+                holder.text.setText(
+                    when (item.expandType) {
+                        ExpandType.VERSIONS -> R.string.show_older_versions
+                        else -> R.string.show_more
+                    }
+                )
+            }
+            ViewType.TEXT -> {
+                holder as TextViewHolder
+                item as Item.TextItem
+                holder.text.text = item.text
+            }
+            ViewType.LINK -> {
+                holder as LinkViewHolder
+                item as Item.LinkItem
+                val layoutParams = holder.itemView.layoutParams as RecyclerView.LayoutParams
+                layoutParams.topMargin = if (position > 0 && items[position - 1] !is Item.LinkItem)
+                    -context.resources.sizeScaled(8) else 0
+                holder.itemView.isEnabled = item.uri != null
+                holder.icon.setImageDrawable(holder.icon.context.getDrawableCompat(item.iconResId))
+                holder.text.text = item.getTitle(context)
+                holder.link.visibility = if (item.uri != null) View.VISIBLE else View.GONE
+                holder.link.text = item.displayLink
+            }
+            ViewType.PERMISSIONS -> {
+                holder as PermissionsViewHolder
+                item as Item.PermissionsItem
+                val layoutParams = holder.itemView.layoutParams as RecyclerView.LayoutParams
+                layoutParams.topMargin =
+                    if (position > 0 && items[position - 1] !is Item.PermissionsItem)
+                        -context.resources.sizeScaled(8) else 0
+                val packageManager = context.packageManager
+                holder.icon.setImageDrawable(
+                    if (item.group != null && item.group.icon != 0) {
+                        if (Android.sdk(22)) {
+                            item.group.loadUnbadgedIcon(packageManager)
+                        } else {
+                            item.group.loadIcon(packageManager)
+                        }
+                    } else {
+                        null
+                    } ?: context.getDrawableCompat(R.drawable.ic_perm_device_information)
+                )
+                val localCache = PackageItemResolver.LocalCache()
+                val labels = item.permissions.map { permission ->
+                    val labelFromPackage =
+                        PackageItemResolver.loadLabel(context, localCache, permission)
+                    val label = labelFromPackage ?: run {
+                        val prefixes =
+                            listOf("android.permission.", "com.android.browser.permission.")
+                        prefixes.find { permission.name.startsWith(it) }?.let { it ->
+                            val transform = permission.name.substring(it.length)
+                            if (transform.matches("[A-Z_]+".toRegex())) {
+                                transform.split("_")
+                                    .joinToString(separator = " ") { it.lowercase(Locale.US) }
+                            } else {
+                                null
+                            }
+                        }
+                    }
+                    if (label == null) {
+                        Pair(false, permission.name)
+                    } else {
+                        Pair(true, label.first().uppercaseChar() + label.substring(1, label.length))
+                    }
+                }
+                val builder = SpannableStringBuilder()
+                (labels.asSequence().filter { it.first } + labels.asSequence()
+                    .filter { !it.first }).forEach {
+                    if (builder.isNotEmpty()) {
+                        builder.append("\n\n")
+                        builder.setSpan(
+                            RelativeSizeSpan(1f / 3f), builder.length - 2, builder.length,
+                            SpannableStringBuilder.SPAN_EXCLUSIVE_EXCLUSIVE
+                        )
+                    }
+                    builder.append(it.second)
+                    if (!it.first) {
+                        // Replace dots with spans to enable word wrap
+                        it.second.asSequence()
+                            .mapIndexedNotNull { index, c -> if (c == '.') index else null }
+                            .map { index -> index + builder.length - it.second.length }
+                            .forEach { index ->
+                                builder.setSpan(
+                                    DotSpan(), index, index + 1,
+                                    SpannableStringBuilder.SPAN_EXCLUSIVE_EXCLUSIVE
+                                )
+                            }
+                    }
+                }
+                holder.text.text = builder
+            }
+            ViewType.SCREENSHOT -> {
+                holder as ScreenshotViewHolder
+                item as Item.ScreenshotItem
+                val screenWidth = context.resources.displayMetrics.widthPixels
+                val outer = context.resources.sizeScaled(GRID_SPACING_OUTER_DP)
+                val inner = context.resources.sizeScaled(GRID_SPACING_INNER_DP)
+                val cellSize = (screenWidth - 2 * outer - (columns - 1) * inner) / columns
+                holder.image.load(
+                    PicassoDownloader.createScreenshotUri(
+                        item.repository,
+                        item.packageName,
+                        item.screenshot
+                    )
+                ) {
+                    placeholder(holder.placeholder)
+                    error(holder.placeholder)
+                    resize(cellSize, cellSize)
+                    centerCrop()
+                }
+            }
+            ViewType.RELEASE -> {
+                holder as ReleaseViewHolder
+                item as Item.ReleaseItem
+                val incompatibility = item.release.incompatibilities.firstOrNull()
+                val singlePlatform =
+                    if (item.release.platforms.size == 1) item.release.platforms.first() else null
+                val installed = installedItem?.versionCode == item.release.versionCode &&
+                        installedItem?.signature == item.release.signature
+                val suggested =
+                    incompatibility == null && item.release.selected && item.selectedRepository
+                val olderOrSignature = installedItem?.let {
+                    it.versionCode > item.release.versionCode ||
+                            it.signature != item.release.signature
+                } == true
+                val grayOut = incompatibility != null || olderOrSignature
+                val primarySecondaryColor = context.getColorFromAttr(
+                    if (grayOut)
+                        android.R.attr.textColorSecondary else android.R.attr.textColor
+                )
+                holder.version.text =
+                    context.getString(R.string.version_FORMAT, item.release.version)
+                holder.version.setTextColor(primarySecondaryColor)
+                holder.setStatusActive(!grayOut)
+                holder.status.visibility = if (installed || suggested) View.VISIBLE else View.GONE
+                holder.status.setText(
+                    when {
+                        installed -> R.string.installed
+                        suggested -> R.string.suggested
+                        else -> R.string.unknown
+                    }
+                )
+                holder.source.text =
+                    context.getString(R.string.provided_by_FORMAT, item.repository.name)
+                holder.added.text = holder.dateFormat.format(item.release.added)
+                holder.added.setTextColor(primarySecondaryColor)
+                holder.size.text = item.release.size.formatSize()
+                holder.signature.visibility =
+                    if (item.showSignature && item.release.signature.isNotEmpty())
+                        View.VISIBLE else View.GONE
+                if (item.showSignature && item.release.signature.isNotEmpty()) {
+                    val bytes =
+                        item.release.signature.uppercase(Locale.US).windowed(2, 2, false).take(8)
+                    val signature = bytes.joinToString(separator = " ")
+                    val builder = SpannableStringBuilder(
+                        context.getString(
+                            R.string.signature_FORMAT,
+                            signature
+                        )
+                    )
+                    val index = builder.indexOf(signature)
+                    if (index >= 0) {
+                        bytes.forEachIndexed { i, _ ->
+                            builder.setSpan(
+                                TypefaceSpan("monospace"),
+                                index + 3 * i,
+                                index + 3 * i + 2,
+                                SpannableStringBuilder.SPAN_EXCLUSIVE_EXCLUSIVE
+                            )
+                        }
+                    }
+                    holder.signature.text = builder
+                }
+                holder.compatibility.visibility =
+                    if (incompatibility != null || singlePlatform != null)
+                        View.VISIBLE else View.GONE
+                if (incompatibility != null) {
+                    holder.compatibility.setTextColor(context.getColorFromAttr(R.attr.colorError))
+                    holder.compatibility.text = when (incompatibility) {
+                        is Release.Incompatibility.MinSdk,
+                        is Release.Incompatibility.MaxSdk -> context.getString(
+                            R.string.incompatible_with_FORMAT,
+                            Android.name
+                        )
+                        is Release.Incompatibility.Platform -> context.getString(
+                            R.string.incompatible_with_FORMAT,
+                            Android.primaryPlatform ?: context.getString(R.string.unknown)
+                        )
+                        is Release.Incompatibility.Feature -> context.getString(
+                            R.string.requires_FORMAT,
+                            incompatibility.feature
+                        )
+                    }
+                } else if (singlePlatform != null) {
+                    holder.compatibility.setTextColor(context.getColorFromAttr(android.R.attr.textColorSecondary))
+                    holder.compatibility.text =
+                        context.getString(R.string.only_compatible_with_FORMAT, singlePlatform)
+                }
+                val enabled = status == null
+                holder.statefulViews.forEach { it.isEnabled = enabled }
+            }
+            ViewType.EMPTY -> {
+                holder as EmptyViewHolder
+                item as Item.EmptyItem
+                holder.packageName.text = item.packageName
+            }
+        }::class
+    }
+
+    private fun formatHtml(text: String): SpannableStringBuilder {
+        val html = HtmlCompat.fromHtml(text, HtmlCompat.FROM_HTML_MODE_LEGACY)
+        val builder = run {
+            val builder = SpannableStringBuilder(html)
+            val last = builder.indexOfLast { it != '\n' }
+            val first = builder.indexOfFirst { it != '\n' }
+            if (last >= 0) {
+                builder.delete(last + 1, builder.length)
+            }
+            if (first in 1 until last) {
+                builder.delete(0, first - 1)
+            }
+            generateSequence(builder) {
+                val index = it.indexOf("\n\n\n")
+                if (index >= 0) it.delete(index, index + 1) else null
+            }.last()
         }
-        val builder = SpannableStringBuilder()
-        (labels.asSequence().filter { it.first } + labels.asSequence().filter { !it.first }).forEach {
-          if (builder.isNotEmpty()) {
-            builder.append("\n\n")
-            builder.setSpan(RelativeSizeSpan(1f / 3f), builder.length - 2, builder.length,
-              SpannableStringBuilder.SPAN_EXCLUSIVE_EXCLUSIVE)
-          }
-          builder.append(it.second)
-          if (!it.first) {
-            // Replace dots with spans to enable word wrap
-            it.second.asSequence()
-              .mapIndexedNotNull { index, c -> if (c == '.') index else null }
-              .map { index -> index + builder.length - it.second.length }
-              .forEach { index -> builder.setSpan(DotSpan(), index, index + 1,
-                SpannableStringBuilder.SPAN_EXCLUSIVE_EXCLUSIVE) }
-          }
+        LinkifyCompat.addLinks(builder, Linkify.WEB_URLS or Linkify.EMAIL_ADDRESSES)
+        val urlSpans = builder.getSpans(0, builder.length, URLSpan::class.java).orEmpty()
+        for (span in urlSpans) {
+            val start = builder.getSpanStart(span)
+            val end = builder.getSpanEnd(span)
+            val flags = builder.getSpanFlags(span)
+            builder.removeSpan(span)
+            builder.setSpan(LinkSpan(span.url, this), start, end, flags)
         }
-        holder.text.text = builder
-      }
-      ViewType.SCREENSHOT -> {
-        holder as ScreenshotViewHolder
-        item as Item.ScreenshotItem
-        val screenWidth = context.resources.displayMetrics.widthPixels
-        val outer = context.resources.sizeScaled(GRID_SPACING_OUTER_DP)
-        val inner = context.resources.sizeScaled(GRID_SPACING_INNER_DP)
-        val cellSize = (screenWidth - 2 * outer - (columns - 1) * inner) / columns
-        holder.image.load(PicassoDownloader.createScreenshotUri(item.repository, item.packageName, item.screenshot)) {
-          placeholder(holder.placeholder)
-          error(holder.placeholder)
-          resize(cellSize, cellSize)
-          centerCrop()
+        val bulletSpans = builder.getSpans(0, builder.length, BulletSpan::class.java).orEmpty()
+            .asSequence().map { Pair(it, builder.getSpanStart(it)) }
+            .sortedByDescending { it.second }
+        for (spanPair in bulletSpans) {
+            val (span, start) = spanPair
+            builder.removeSpan(span)
+            builder.insert(start, "\u2022 ")
         }
-      }
-      ViewType.RELEASE -> {
-        holder as ReleaseViewHolder
-        item as Item.ReleaseItem
-        val incompatibility = item.release.incompatibilities.firstOrNull()
-        val singlePlatform = if (item.release.platforms.size == 1) item.release.platforms.first() else null
-        val installed = installedItem?.versionCode == item.release.versionCode &&
-          installedItem?.signature == item.release.signature
-        val suggested = incompatibility == null && item.release.selected && item.selectedRepository
-        val olderOrSignature = installedItem?.let { it.versionCode > item.release.versionCode ||
-          it.signature != item.release.signature } == true
-        val grayOut = incompatibility != null || olderOrSignature
-        val primarySecondaryColor = context.getColorFromAttr(if (grayOut)
-          android.R.attr.textColorSecondary else android.R.attr.textColorPrimary)
-        holder.version.text = context.getString(R.string.version_FORMAT, item.release.version)
-        holder.version.setTextColor(primarySecondaryColor)
-        holder.setStatusActive(!grayOut)
-        holder.status.visibility = if (installed || suggested) View.VISIBLE else View.GONE
-        holder.status.setText(when {
-          installed -> R.string.installed
-          suggested -> R.string.suggested
-          else -> R.string.unknown
-        })
-        holder.source.text = context.getString(R.string.provided_by_FORMAT, item.repository.name)
-        holder.added.text = holder.dateFormat.format(item.release.added)
-        holder.added.setTextColor(primarySecondaryColor)
-        holder.size.text = item.release.size.formatSize()
-        holder.signature.visibility = if (item.showSignature && item.release.signature.isNotEmpty())
-          View.VISIBLE else View.GONE
-        if (item.showSignature && item.release.signature.isNotEmpty()) {
-          val bytes = item.release.signature.toUpperCase(Locale.US).windowed(2, 2, false).take(8)
-          val signature = bytes.joinToString(separator = " ")
-          val builder = SpannableStringBuilder(context.getString(R.string.signature_FORMAT, signature))
-          val index = builder.indexOf(signature)
-          if (index >= 0) {
-            bytes.forEachIndexed { i, _ -> builder.setSpan(TypefaceSpan("monospace"),
-              index + 3 * i, index + 3 * i + 2, SpannableStringBuilder.SPAN_EXCLUSIVE_EXCLUSIVE) }
-          }
-          holder.signature.text = builder
+        return builder
+    }
+
+    private fun copyLinkToClipboard(context: Context, link: String) {
+        val clipboardManager =
+            context.getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager
+        clipboardManager.setPrimaryClip(ClipData.newPlainText(null, link))
+        Toast.makeText(
+            context,
+            context.getString(R.string.link_copied_to_clipboard),
+            Toast.LENGTH_SHORT
+        ).show()
+    }
+
+    private class LinkSpan(private val url: String, productAdapter: ProductAdapter) :
+        ClickableSpan() {
+        private val productAdapterReference = WeakReference(productAdapter)
+
+        override fun onClick(view: View) {
+            val productAdapter = productAdapterReference.get()
+            val uri = try {
+                Uri.parse(url)
+            } catch (e: Exception) {
+                e.printStackTrace()
+                null
+            }
+            if (productAdapter != null && uri != null) {
+                productAdapter.callbacks.onUriClick(uri, true)
+            }
         }
-        holder.compatibility.visibility = if (incompatibility != null || singlePlatform != null)
-          View.VISIBLE else View.GONE
-        if (incompatibility != null) {
-          holder.compatibility.setTextColor(context.getColorFromAttr(R.attr.colorError))
-          holder.compatibility.text = when (incompatibility) {
-            is Release.Incompatibility.MinSdk,
-            is Release.Incompatibility.MaxSdk -> context.getString(R.string.incompatible_with_FORMAT, Android.name)
-            is Release.Incompatibility.Platform -> context.getString(R.string.incompatible_with_FORMAT,
-              Android.primaryPlatform ?: context.getString(R.string.unknown))
-            is Release.Incompatibility.Feature -> context.getString(R.string.requires_FORMAT, incompatibility.feature)
-          }
-        } else if (singlePlatform != null) {
-          holder.compatibility.setTextColor(context.getColorFromAttr(android.R.attr.textColorSecondary))
-          holder.compatibility.text = context.getString(R.string.only_compatible_with_FORMAT, singlePlatform)
+    }
+
+    private class DotSpan : ReplacementSpan() {
+        override fun getSize(
+            paint: Paint,
+            text: CharSequence?,
+            start: Int,
+            end: Int,
+            fm: Paint.FontMetricsInt?
+        ): Int {
+            return paint.measureText(".").roundToInt()
         }
-        val enabled = status == null
-        holder.statefulViews.forEach { it.isEnabled = enabled }
-      }
-      ViewType.EMPTY -> {
-        holder as EmptyViewHolder
-        item as Item.EmptyItem
-        holder.packageName.text = item.packageName
-      }
-    }::class
-  }
 
-  private fun formatHtml(text: String): SpannableStringBuilder {
-    val html = HtmlCompat.fromHtml(text, HtmlCompat.FROM_HTML_MODE_LEGACY)
-    val builder = run {
-      val builder = SpannableStringBuilder(html)
-      val last = builder.indexOfLast { it != '\n' }
-      val first = builder.indexOfFirst { it != '\n' }
-      if (last >= 0) {
-        builder.delete(last + 1, builder.length)
-      }
-      if (first in 1 until last) {
-        builder.delete(0, first - 1)
-      }
-      generateSequence(builder) {
-        val index = it.indexOf("\n\n\n")
-        if (index >= 0) it.delete(index, index + 1) else null
-      }.last()
-    }
-    LinkifyCompat.addLinks(builder, Linkify.WEB_URLS or Linkify.EMAIL_ADDRESSES)
-    val urlSpans = builder.getSpans(0, builder.length, URLSpan::class.java).orEmpty()
-    for (span in urlSpans) {
-      val start = builder.getSpanStart(span)
-      val end = builder.getSpanEnd(span)
-      val flags = builder.getSpanFlags(span)
-      builder.removeSpan(span)
-      builder.setSpan(LinkSpan(span.url, this), start, end, flags)
-    }
-    val bulletSpans = builder.getSpans(0, builder.length, BulletSpan::class.java).orEmpty()
-      .asSequence().map { Pair(it, builder.getSpanStart(it)) }.sortedByDescending { it.second }
-    for (spanPair in bulletSpans) {
-      val (span, start) = spanPair
-      builder.removeSpan(span)
-      builder.insert(start, "\u2022 ")
-    }
-    return builder
-  }
-
-  private fun copyLinkToClipboard(context: Context, link: String) {
-    val clipboardManager = context.getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager
-    clipboardManager.setPrimaryClip(ClipData.newPlainText(null, link))
-    Toast.makeText(context, context.getString(R.string.link_copied_to_clipboard), Toast.LENGTH_SHORT).show()
-  }
-
-  private class LinkSpan(private val url: String, productAdapter: ProductAdapter): ClickableSpan() {
-    private val productAdapterReference = WeakReference(productAdapter)
-
-    override fun onClick(view: View) {
-      val productAdapter = productAdapterReference.get()
-      val uri = try {
-        Uri.parse(url)
-      } catch (e: Exception) {
-        e.printStackTrace()
-        null
-      }
-      if (productAdapter != null && uri != null) {
-        productAdapter.callbacks.onUriClick(uri, true)
-      }
-    }
-  }
-
-  private class DotSpan: ReplacementSpan() {
-    override fun getSize(paint: Paint, text: CharSequence?, start: Int, end: Int, fm: Paint.FontMetricsInt?): Int {
-      return paint.measureText(".").roundToInt()
+        override fun draw(
+            canvas: Canvas, text: CharSequence?, start: Int, end: Int,
+            x: Float, top: Int, y: Int, bottom: Int, paint: Paint
+        ) {
+            canvas.drawText(".", x, y.toFloat(), paint)
+        }
     }
 
-    override fun draw(canvas: Canvas, text: CharSequence?, start: Int, end: Int,
-      x: Float, top: Int, y: Int, bottom: Int, paint: Paint) {
-      canvas.drawText(".", x, y.toFloat(), paint)
-    }
-  }
+    class SavedState internal constructor(internal val expanded: Set<ExpandType>) : KParcelable {
+        override fun writeToParcel(dest: Parcel, flags: Int) {
+            dest.writeStringList(expanded.map { it.name }.toList())
+        }
 
-  class SavedState internal constructor(internal val expanded: Set<ExpandType>): KParcelable {
-    override fun writeToParcel(dest: Parcel, flags: Int) {
-      dest.writeStringList(expanded.map { it.name }.toList())
+        companion object {
+            @Suppress("unused")
+            @JvmField
+            val CREATOR = KParcelable.creator {
+                val expanded = it.createStringArrayList()!!.map(ExpandType::valueOf).toSet()
+                SavedState(expanded)
+            }
+        }
     }
 
-    companion object {
-      @Suppress("unused") @JvmField val CREATOR = KParcelable.creator {
-        val expanded = it.createStringArrayList()!!.map(ExpandType::valueOf).toSet()
-        SavedState(expanded)
-      }
+    fun saveState(): SavedState? {
+        return if (expanded.isNotEmpty()) {
+            SavedState(expanded)
+        } else {
+            null
+        }
     }
-  }
 
-  fun saveState(): SavedState? {
-    return if (expanded.isNotEmpty()) {
-      SavedState(expanded)
-    } else {
-      null
+    fun restoreState(savedState: SavedState) {
+        expanded.clear()
+        expanded += savedState.expanded
     }
-  }
-
-  fun restoreState(savedState: SavedState) {
-    expanded.clear()
-    expanded += savedState.expanded
-  }
 }
diff --git a/src/main/kotlin/com/looker/droidify/screen/ProductFragment.kt b/src/main/kotlin/com/looker/droidify/screen/ProductFragment.kt
index 91952076..067d896e 100644
--- a/src/main/kotlin/com/looker/droidify/screen/ProductFragment.kt
+++ b/src/main/kotlin/com/looker/droidify/screen/ProductFragment.kt
@@ -18,458 +18,540 @@ 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.entity.*
 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
+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
 
-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() {
+class ProductFragment() : ScreenFragment(), ProductAdapter.Callbacks {
     companion object {
-      private const val EXTRA_NAMES = "names"
-      private const val EXTRA_LABELS = "labels"
+        private const val EXTRA_PACKAGE_NAME = "packageName"
+
+        private const val STATE_LAYOUT_MANAGER = "layoutManager"
+        private const val STATE_ADAPTER = "adapter"
     }
 
-    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 }))
-      }
+    constructor(packageName: String) : this() {
+        arguments = Bundle().apply {
+            putString(EXTRA_PACKAGE_NAME, packageName)
+        }
     }
 
-    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()
+    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 ->
+                        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 { it ->
+                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) }
+                        .minByOrNull { it.platforms.size }
+                        ?: compatibleReleases.minByOrNull { 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 { it ->
+                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 -> 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()
+        }
     }
-  }
 }
diff --git a/src/main/kotlin/com/looker/droidify/screen/ProductsAdapter.kt b/src/main/kotlin/com/looker/droidify/screen/ProductsAdapter.kt
index 3b692a29..63b67e53 100644
--- a/src/main/kotlin/com/looker/droidify/screen/ProductsAdapter.kt
+++ b/src/main/kotlin/com/looker/droidify/screen/ProductsAdapter.kt
@@ -18,167 +18,174 @@ 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.utility.extension.text.nullIfEmpty
 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 }
+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)!!
+    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
+        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()
+        init {
+            val (progressIcon, defaultIcon) = Utils.getDefaultApplicationIcons(icon.context)
+            this.progressIcon = progressIcon
+            this.defaultIcon = defaultIcon
         }
-      }
     }
 
-  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)
+    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
+            )
         }
-        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()
-              }
+    }
+
+    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
+            )
+        }
+    }
+
+    var repositories: Map<Long, Repository> = emptyMap()
+        set(value) {
+            field = value
+            notifyDataSetChanged()
+        }
+
+    var emptyText: String = ""
+        set(value) {
+            if (field != value) {
+                field = value
+                if (isEmpty) {
+                    notifyDataSetChanged()
+                }
             }
-          } 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
-  }
+
+    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
+    }
 }
diff --git a/src/main/kotlin/com/looker/droidify/screen/ProductsFragment.kt b/src/main/kotlin/com/looker/droidify/screen/ProductsFragment.kt
index 9978670a..8b65f108 100644
--- a/src/main/kotlin/com/looker/droidify/screen/ProductsFragment.kt
+++ b/src/main/kotlin/com/looker/droidify/screen/ProductsFragment.kt
@@ -17,7 +17,6 @@ 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 {
@@ -80,7 +79,6 @@ class ProductsFragment(): ScreenFragment(), CursorOwner.Callback {
       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
     }
diff --git a/src/main/kotlin/com/looker/droidify/screen/TabsFragment.kt b/src/main/kotlin/com/looker/droidify/screen/TabsFragment.kt
index d8c96e6d..c8868213 100644
--- a/src/main/kotlin/com/looker/droidify/screen/TabsFragment.kt
+++ b/src/main/kotlin/com/looker/droidify/screen/TabsFragment.kt
@@ -9,28 +9,15 @@ 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.*
 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 android.widget.*
 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
@@ -44,139 +31,151 @@ 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 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 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()
-        }
-      }
+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 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 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 sortOrderDisposable: Disposable? = null
-  private var categoriesDisposable: Disposable? = null
-  private var repositoriesDisposable: Disposable? = null
-  private var sectionsAnimator: ValueAnimator? = null
+    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 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()) }
+    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)
         }
-        return true
-      }
     })
 
-    toolbar.menu.apply {
-      if (Android.sdk(28) && !Android.Device.isHuaweiEmui) {
-        setGroupDividerEnabled(true)
-      }
+    private var sortOrderDisposable: Disposable? = null
+    private var categoriesDisposable: Disposable? = null
+    private var repositoriesDisposable: Disposable? = null
+    private var sectionsAnimator: ValueAnimator? = null
 
-      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)
+    private var needSelectUpdates = false
 
-      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)
-        }
+    private val productFragments: Sequence<ProductsFragment>
+        get() = if (host == null) emptySequence() else
+            childFragmentManager.fragments.asSequence().mapNotNull { it as? ProductsFragment }
 
-      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
-        }
+    override fun onCreateView(
+        inflater: LayoutInflater,
+        container: ViewGroup?,
+        savedInstanceState: Bundle?
+    ): View {
+        return inflater.inflate(R.layout.fragment, container, false)
+    }
 
-      add(1, 0, 0, R.string.repositories)
-        .setOnMenuItemClickListener {
-          view.post { screenActivity.navigateRepositories() }
-          true
-        }
+    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.settings)
                 .setOnMenuItemClickListener {
@@ -185,428 +184,501 @@ class TabsFragment: ScreenFragment() {
                 }
         }
 
-    searchQuery = savedInstanceState?.getString(STATE_SEARCH_QUERY).orEmpty()
-    productFragments.forEach { it.setSearchQuery(searchQuery) }
+        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
+        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
-    }
+        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 }
+        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
+        sortOrderDisposable = Preferences.observable.subscribe {
+            if (it == Preferences.Key.SortOrder) {
+                updateOrder()
             }
-            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()
-      }
+        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 { it ->
+                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))
+            setBackgroundResource(R.drawable.background_border)
+            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 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 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 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)
-      }
-    }
-  }
+    override fun onSaveInstanceState(outState: Bundle) {
+        super.onSaveInstanceState(outState)
 
-  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
+        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)
     }
 
-    private var position = 0f
-    private var total = 0
+    override fun onViewStateRestored(savedInstanceState: Bundle?) {
+        super.onViewStateRestored(savedInstanceState)
 
-    fun update(position: Float, total: Int) {
-      this.position = position
-      this.total = total
-      invalidateSelf()
+        (searchMenuItem?.actionView as FocusSearchView).allowFocus = true
+        if (needSelectUpdates) {
+            needSelectUpdates = false
+            selectUpdatesInternal(false)
+        }
     }
 
-    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)
+    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 {
-          canvas.drawRect(bounds.left + x, (bounds.bottom - height).toFloat(),
-            bounds.left + x + width, bounds.bottom.toFloat(), paint)
+            needSelectUpdates = true
         }
-      }
     }
 
-    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)
+    private fun updateUpdateNotificationBlocker(activeSource: ProductsFragment.Source) {
+        val blockerFragment = if (activeSource == ProductsFragment.Source.UPDATES) {
+            productFragments.find { it.source == activeSource }
+        } else {
+            null
         }
-        else -> {
-          configuration.set(false, false, 0, 0)
+        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()
         }
-      }
     }
 
-    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]) }
-      }
+    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()
     }
 
-    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
-      }
+    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.textColor).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 + width / 4, // + width/4 from start
+                        (bounds.bottom - height).toFloat(),
+                        bounds.left + x + width - width / 4, // - width/4 from end
+                        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.textColor))
+                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(
+                        needDivider = true,
+                        toTop = false,
+                        paddingStart = padding,
+                        paddingEnd = padding
+                    )
+                }
+                else -> {
+                    configuration.set(
+                        needDivider = false,
+                        toTop = false,
+                        paddingStart = 0,
+                        paddingEnd = 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
+            }
+        }
     }
-  }
 }