Modularize time limit rule list items

app/src/main/java/io/timelimit/android/ui/manage/category/timelimit_rules/Adapter.kt

@@ -33,7 +33,7 @@ class Adapter: RecyclerView.Adapter<ViewHolder>() {
         private const val TYPE_ADD = 2
     }
 
-    var data: List<TimeLimitRule>? by Delegates.observable(null as List<TimeLimitRule>?) { _, _, _ -> notifyDataSetChanged() }
+    var data: List<TimeLimitRuleItem> by Delegates.observable(emptyList()) { _, _, _ -> notifyDataSetChanged() }
     var usedTimes: List<Long>? by Delegates.observable(null as List<Long>?) { _, _, _ -> notifyDataSetChanged() }
     var handlers: Handlers? = null
 
@@ -41,28 +41,23 @@ class Adapter: RecyclerView.Adapter<ViewHolder>() {
         setHasStableIds(true)
     }
 
-    private fun getItem(position: Int): TimeLimitRule {
+    private fun getItem(position: Int): TimeLimitRuleItem = data[position]
-        return data!![position]
-    }
 
-    override fun getItemId(position: Int): Long = when {
+    override fun getItemId(position: Int): Long {
-        position == data!!.size -> 1
+        val item = getItem(position)
-        else -> getItem(position).id.hashCode().toLong()
-    }
 
-    override fun getItemCount(): Int {
+        return if (item is TimeLimitRuleRuleItem) {
-        val data = this.data
+            item.rule.id.hashCode()
-
-        if (data == null) {
-            return 0
         } else {
-            return data.size + 1
+            item.hashCode()
-        }
+        }.toLong()
     }
 
-    override fun getItemViewType(position: Int) = when {
+    override fun getItemCount(): Int = data.size
-        position == data!!.size -> TYPE_ADD
+
-        else -> TYPE_ITEM
+    override fun getItemViewType(position: Int) = when (getItem(position)) {
+        AddTimeLimitRuleItem -> TYPE_ADD
+        is TimeLimitRuleRuleItem -> TYPE_ITEM
     }
 
     override fun onCreateViewHolder(parent: ViewGroup, viewType: Int) = when (viewType) {
@@ -91,36 +86,41 @@ class Adapter: RecyclerView.Adapter<ViewHolder>() {
     }
 
     override fun onBindViewHolder(holder: ViewHolder, position: Int) {
-        if (position == data!!.size) {
-            // nothing to do
-        } else {
         val item = getItem(position)
+
+        when (item) {
+            AddTimeLimitRuleItem -> {
+                // nothing to do
+            }
+            is TimeLimitRuleRuleItem -> {
+                val rule = item.rule
                 val binding = (holder as ItemViewHolder).view
                 val dayNames = binding.root.resources.getStringArray(R.array.days_of_week_array)
                 val usedTime = usedTimes?.mapIndexed { index, value ->
-                if (item.dayMask.toInt() and (1 shl index) != 0) {
+                    if (rule.dayMask.toInt() and (1 shl index) != 0) {
                         value
                     } else {
                         0
                     }
                 }?.sum()?.toInt() ?: 0
 
-            binding.maxTimeString = TimeTextUtil.time(item.maximumTimeInMillis, binding.root.context)
+                binding.maxTimeString = TimeTextUtil.time(rule.maximumTimeInMillis, binding.root.context)
                 binding.usageAsText = TimeTextUtil.used(usedTime, binding.root.context)
-            binding.usageProgressInPercent = if (item.maximumTimeInMillis > 0)
+                binding.usageProgressInPercent = if (rule.maximumTimeInMillis > 0)
-                (usedTime * 100 / item.maximumTimeInMillis)
+                    (usedTime * 100 / rule.maximumTimeInMillis)
                 else
                     100
                 binding.daysString = JoinUtil.join(
-                    dayNames.filterIndexed { index, _ -> (item.dayMask.toInt() and (1 shl index)) != 0 },
+                        dayNames.filterIndexed { index, _ -> (rule.dayMask.toInt() and (1 shl index)) != 0 },
                         binding.root.context
                 )
-            binding.appliesToExtraTime = item.applyToExtraTimeUsage
+                binding.appliesToExtraTime = rule.applyToExtraTimeUsage
-            binding.card.setOnClickListener { handlers?.onTimeLimitRuleClicked(item) }
+                binding.card.setOnClickListener { handlers?.onTimeLimitRuleClicked(rule) }
 
                 binding.executePendingBindings()
             }
         }
+    }
 }
 
 open class ViewHolder(view: View): RecyclerView.ViewHolder(view)

app/src/main/java/io/timelimit/android/ui/manage/category/timelimit_rules/CategoryTimeLimitRulesFragment.kt

@@ -81,9 +81,11 @@ class CategoryTimeLimitRulesFragment : Fragment(), EditTimeLimitRuleDialogFragme
 
         rules
                 .map { rules ->
-                    rules.sortedBy { it.dayMask }
+                    rules.sortedBy { it.dayMask }.map { TimeLimitRuleRuleItem(it) }
                 }
-                .observe(this, Observer { adapter.data = it })
+                .observe(this, Observer {
+                    adapter.data = it + listOf(AddTimeLimitRuleItem)
+                })
 
         usedTimeItems.observe(this, Observer {
             usedTimes ->

app/src/main/java/io/timelimit/android/ui/manage/category/timelimit_rules/TimeLimitRuleItem.kt

@@ -0,0 +1,7 @@
+package io.timelimit.android.ui.manage.category.timelimit_rules
+
+import io.timelimit.android.data.model.TimeLimitRule
+
+sealed class TimeLimitRuleItem
+object AddTimeLimitRuleItem: TimeLimitRuleItem()
+data class TimeLimitRuleRuleItem(val rule: TimeLimitRule): TimeLimitRuleItem()