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,34 +86,39 @@ class Adapter: RecyclerView.Adapter<ViewHolder>() {
     }
 
     override fun onBindViewHolder(holder: ViewHolder, position: Int) {
-        if (position == data!!.size) {
+        val item = getItem(position)
-            // nothing to do
-        } else {
-            val item = getItem(position)
-            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) {
-                    value
-                } else {
-                    0
-                }
-            }?.sum()?.toInt() ?: 0
 
-            binding.maxTimeString = TimeTextUtil.time(item.maximumTimeInMillis, binding.root.context)
+        when (item) {
-            binding.usageAsText = TimeTextUtil.used(usedTime, binding.root.context)
+            AddTimeLimitRuleItem -> {
-            binding.usageProgressInPercent = if (item.maximumTimeInMillis > 0)
+                // nothing to do
-                (usedTime * 100 / item.maximumTimeInMillis)
+            }
-            else
+            is TimeLimitRuleRuleItem -> {
-                100
+                val rule = item.rule
-            binding.daysString = JoinUtil.join(
+                val binding = (holder as ItemViewHolder).view
-                    dayNames.filterIndexed { index, _ -> (item.dayMask.toInt() and (1 shl index)) != 0 },
+                val dayNames = binding.root.resources.getStringArray(R.array.days_of_week_array)
-                    binding.root.context
+                val usedTime = usedTimes?.mapIndexed { index, value ->
-            )
+                    if (rule.dayMask.toInt() and (1 shl index) != 0) {
-            binding.appliesToExtraTime = item.applyToExtraTimeUsage
+                        value
-            binding.card.setOnClickListener { handlers?.onTimeLimitRuleClicked(item) }
+                    } else {
+                        0
+                    }
+                }?.sum()?.toInt() ?: 0
 
-            binding.executePendingBindings()
+                binding.maxTimeString = TimeTextUtil.time(rule.maximumTimeInMillis, binding.root.context)
+                binding.usageAsText = TimeTextUtil.used(usedTime, binding.root.context)
+                binding.usageProgressInPercent = if (rule.maximumTimeInMillis > 0)
+                    (usedTime * 100 / rule.maximumTimeInMillis)
+                else
+                    100
+                binding.daysString = JoinUtil.join(
+                        dayNames.filterIndexed { index, _ -> (rule.dayMask.toInt() and (1 shl index)) != 0 },
+                        binding.root.context
+                )
+                binding.appliesToExtraTime = rule.applyToExtraTimeUsage
+                binding.card.setOnClickListener { handlers?.onTimeLimitRuleClicked(rule) }
+
+                binding.executePendingBindings()
+            }
         }
     }
 }

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