Address some issues regarding missed alarms

app/src/main/kotlin/org/fossify/clock/activities/MainActivity.kt

@@ -15,6 +15,7 @@ import org.fossify.clock.adapters.ViewPagerAdapter
 import org.fossify.clock.databinding.ActivityMainBinding
 import org.fossify.clock.extensions.config
 import org.fossify.clock.extensions.getEnabledAlarms
+import org.fossify.clock.extensions.handleFullScreenNotificationsPermission
 import org.fossify.clock.extensions.rescheduleEnabledAlarms
 import org.fossify.clock.extensions.updateWidgets
 import org.fossify.clock.helpers.*
@@ -44,11 +45,16 @@ class MainActivity : SimpleActivity() {
         setupTabs()
         updateWidgets()
         migrateFirstDayOfWeek()
+        ensureBackgroundThread {
+            rescheduleEnabledAlarms()
+        }
 
         getEnabledAlarms { enabledAlarms ->
-            if (enabledAlarms.isNullOrEmpty()) {
-                ensureBackgroundThread {
-                    rescheduleEnabledAlarms()
+            if (!enabledAlarms.isNullOrEmpty()) {
+                handleFullScreenNotificationsPermission {
+                    if (!it) {
+                        toast(org.fossify.commons.R.string.notifications_disabled)
+                    }
                 }
             }
         }
@@ -87,10 +93,10 @@ class MainActivity : SimpleActivity() {
     private fun checkShortcuts() {
         val appIconColor = config.appIconColor
         if (isNougatMR1Plus() && config.lastHandledShortcutColor != appIconColor) {
-            val launchDialpad = getLaunchStopwatchShortcut(appIconColor)
+            val stopWatchShortcutInfo = getLaunchStopwatchShortcut(appIconColor)
 
             try {
-                shortcutManager.dynamicShortcuts = listOf(launchDialpad)
+                shortcutManager.dynamicShortcuts = listOf(stopWatchShortcutInfo)
                 config.lastHandledShortcutColor = appIconColor
             } catch (ignored: Exception) {
             }

app/src/main/kotlin/org/fossify/clock/activities/ReminderActivity.kt

@@ -20,10 +20,10 @@ import org.fossify.clock.databinding.ActivityReminderBinding
 import org.fossify.clock.extensions.cancelAlarmClock
 import org.fossify.clock.extensions.config
 import org.fossify.clock.extensions.dbHelper
+import org.fossify.clock.extensions.disableExpiredAlarm
 import org.fossify.clock.extensions.getFormattedTime
 import org.fossify.clock.extensions.scheduleNextAlarm
 import org.fossify.clock.extensions.setupAlarmClock
-import org.fossify.clock.extensions.updateWidgets
 import org.fossify.clock.helpers.ALARM_ID
 import org.fossify.clock.helpers.ALARM_NOTIF_ID
 import org.fossify.clock.helpers.getPassedSeconds
@@ -363,15 +363,8 @@ class ReminderActivity : SimpleActivity() {
             if (alarm!!.days > 0) {
                 scheduleNextAlarm(alarm!!, false)
             }
-            if (alarm!!.days < 0) {
-                if (alarm!!.oneShot) {
-                    alarm!!.isEnabled = false
-                    dbHelper.deleteAlarms(arrayListOf(alarm!!))
-                } else {
-                    dbHelper.updateAlarmEnabledState(alarm!!.id, false)
-                }
-                updateWidgets()
-            }
+
+            disableExpiredAlarm(alarm!!)
         }
 
         finished = true

app/src/main/kotlin/org/fossify/clock/adapters/AlarmsAdapter.kt

@@ -33,8 +33,8 @@ import org.fossify.commons.views.MyRecyclerView
 
 class AlarmsAdapter(
     activity: SimpleActivity,
-    var alarms: ArrayList<Alarm>,
-    val toggleAlarmInterface: ToggleAlarmInterface,
+    private var alarms: ArrayList<Alarm>,
+    private val toggleAlarmInterface: ToggleAlarmInterface,
     recyclerView: MyRecyclerView,
     itemClick: (Any) -> Unit,
 ) : MyRecyclerViewAdapter(activity, recyclerView, itemClick), ItemTouchHelperContract {

app/src/main/kotlin/org/fossify/clock/extensions/Context.kt

@@ -56,6 +56,7 @@ import org.fossify.clock.helpers.getPassedSeconds
 import org.fossify.clock.helpers.getTimeOfNextAlarm
 import org.fossify.clock.interfaces.TimerDao
 import org.fossify.clock.models.Alarm
+import org.fossify.clock.models.AlarmEvent
 import org.fossify.clock.models.MyTimeZone
 import org.fossify.clock.models.Timer
 import org.fossify.clock.models.TimerState
@@ -87,6 +88,7 @@ import org.fossify.commons.helpers.TUESDAY_BIT
 import org.fossify.commons.helpers.WEDNESDAY_BIT
 import org.fossify.commons.helpers.ensureBackgroundThread
 import org.fossify.commons.helpers.isOreoPlus
+import org.greenrobot.eventbus.EventBus
 import java.text.SimpleDateFormat
 import java.util.Calendar
 import java.util.Locale
@@ -600,3 +602,17 @@ fun Context.firstDayOrder(bitMask: Int): Int {
 
     return bitMask
 }
+
+fun Context.disableExpiredAlarm(alarm: Alarm) {
+    if (alarm.days < 0) {
+        if (alarm.oneShot) {
+            alarm.isEnabled = false
+            dbHelper.deleteAlarms(arrayListOf(alarm))
+        } else {
+            dbHelper.updateAlarmEnabledState(alarm.id, false)
+        }
+
+        updateWidgets()
+        EventBus.getDefault().post(AlarmEvent.Refresh)
+    }
+}

app/src/main/kotlin/org/fossify/clock/fragments/AlarmFragment.kt

@@ -11,8 +11,18 @@ import org.fossify.clock.adapters.AlarmsAdapter
 import org.fossify.clock.databinding.FragmentAlarmBinding
 import org.fossify.clock.dialogs.ChangeAlarmSortDialog
 import org.fossify.clock.dialogs.EditAlarmDialog
-import org.fossify.clock.extensions.*
-import org.fossify.clock.helpers.*
+import org.fossify.clock.extensions.cancelAlarmClock
+import org.fossify.clock.extensions.config
+import org.fossify.clock.extensions.createNewAlarm
+import org.fossify.clock.extensions.dbHelper
+import org.fossify.clock.extensions.firstDayOrder
+import org.fossify.clock.extensions.handleFullScreenNotificationsPermission
+import org.fossify.clock.extensions.scheduleNextAlarm
+import org.fossify.clock.extensions.updateWidgets
+import org.fossify.clock.helpers.DEFAULT_ALARM_MINUTES
+import org.fossify.clock.helpers.SORT_BY_ALARM_TIME
+import org.fossify.clock.helpers.SORT_BY_DATE_AND_TIME
+import org.fossify.clock.helpers.getTomorrowBit
 import org.fossify.clock.interfaces.ToggleAlarmInterface
 import org.fossify.clock.models.Alarm
 import org.fossify.clock.models.AlarmEvent
@@ -34,7 +44,11 @@ class AlarmFragment : Fragment(), ToggleAlarmInterface {
 
     private lateinit var binding: FragmentAlarmBinding
 
-    override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View {
+    override fun onCreateView(
+        inflater: LayoutInflater,
+        container: ViewGroup?,
+        savedInstanceState: Bundle?,
+    ): View {
         binding = FragmentAlarmBinding.inflate(inflater, container, false)
         return binding.root
     }
@@ -74,71 +88,76 @@ class AlarmFragment : Fragment(), ToggleAlarmInterface {
         setupAlarms()
     }
 
-    private fun setupAlarms() {
-        alarms = context?.dbHelper?.getAlarms() ?: return
-
-        when (requireContext().config.alarmSort) {
-            SORT_BY_ALARM_TIME -> alarms.sortBy { it.timeInMinutes }
-            SORT_BY_DATE_CREATED -> alarms.sortBy { it.id }
-            SORT_BY_DATE_AND_TIME -> alarms.sortWith(compareBy<Alarm> {
-                requireContext().firstDayOrder(it.days)
-            }.thenBy {
-                it.timeInMinutes
-            })
-
-            SORT_BY_CUSTOM -> {
-                val customAlarmsSortOrderString = activity?.config?.alarmsCustomSorting
-                if (customAlarmsSortOrderString == "") {
-                    alarms.sortBy { it.id }
-                } else {
-                    val customAlarmsSortOrder: List<Int> = customAlarmsSortOrderString?.split(", ")?.map { it.toInt() }!!
-                    val alarmsIdValueMap = alarms.associateBy { it.id }
-
-                    val sortedAlarms: ArrayList<Alarm> = ArrayList()
-                    customAlarmsSortOrder.map { id ->
-                        if (alarmsIdValueMap[id] != null) {
-                            sortedAlarms.add(alarmsIdValueMap[id] as Alarm)
-                        }
-                    }
-
-                    alarms = (sortedAlarms + alarms.filter { it !in sortedAlarms }) as ArrayList<Alarm>
+    private fun getSortedAlarms(callback: (alarms: ArrayList<Alarm>) -> Unit) {
+        val safeContext = context ?: return
+        ensureBackgroundThread {
+            var newAlarms = context?.dbHelper?.getAlarms()
+            if (newAlarms == null) {
+                activity?.runOnUiThread {
+                    callback(arrayListOf())
                 }
+                return@ensureBackgroundThread
             }
-        }
-        context?.getEnabledAlarms { enabledAlarms ->
-            if (enabledAlarms.isNullOrEmpty()) {
-                val removedAlarms = mutableListOf<Alarm>()
-                alarms.forEach {
-                    if (it.days == TODAY_BIT && it.isEnabled && it.timeInMinutes <= getCurrentDayMinutes()) {
-                        it.isEnabled = false
-                        ensureBackgroundThread {
-                            if (it.oneShot) {
-                                it.isEnabled = false
-                                context?.dbHelper?.deleteAlarms(arrayListOf(it))
-                                removedAlarms.add(it)
-                            } else {
-                                context?.dbHelper?.updateAlarmEnabledState(it.id, false)
+
+            when (safeContext.config.alarmSort) {
+                SORT_BY_ALARM_TIME -> newAlarms.sortBy { it.timeInMinutes }
+                SORT_BY_DATE_CREATED -> newAlarms.sortBy { it.id }
+                SORT_BY_DATE_AND_TIME -> newAlarms.sortWith(compareBy<Alarm> {
+                    safeContext.firstDayOrder(it.days)
+                }.thenBy {
+                    it.timeInMinutes
+                })
+
+                SORT_BY_CUSTOM -> {
+                    val customAlarmsSortOrderString = activity?.config?.alarmsCustomSorting
+                    if (customAlarmsSortOrderString == "") {
+                        newAlarms.sortBy { it.id }
+                    } else {
+                        val customAlarmsSortOrder: List<Int> =
+                            customAlarmsSortOrderString?.split(", ")?.map { it.toInt() }!!
+                        val alarmsIdValueMap = newAlarms.associateBy { it.id }
+
+                        val sortedAlarms: ArrayList<Alarm> = ArrayList()
+                        customAlarmsSortOrder.map { id ->
+                            if (alarmsIdValueMap[id] != null) {
+                                sortedAlarms.add(alarmsIdValueMap[id] as Alarm)
                             }
                         }
+
+                        newAlarms =
+                            (sortedAlarms + newAlarms.filter { it !in sortedAlarms }) as ArrayList<Alarm>
                     }
                 }
-                alarms.removeAll(removedAlarms)
             }
-        }
 
-        val currAdapter = binding.alarmsList.adapter
-        if (currAdapter == null) {
-            AlarmsAdapter(activity as SimpleActivity, alarms, this, binding.alarmsList) {
-                openEditAlarm(it as Alarm)
-            }.apply {
-                binding.alarmsList.adapter = this
+            activity?.runOnUiThread {
+                callback(newAlarms)
             }
-        } else {
-            (currAdapter as AlarmsAdapter).apply {
-                updatePrimaryColor()
-                updateBackgroundColor(requireContext().getProperBackgroundColor())
-                updateTextColor(requireContext().getProperTextColor())
-                updateItems([email protected])
+        }
+    }
+
+    private fun setupAlarms() {
+        getSortedAlarms { sortedAlarms ->
+            alarms = sortedAlarms
+            var currAdapter = binding.alarmsList.adapter as? AlarmsAdapter
+            if (currAdapter == null) {
+                currAdapter = AlarmsAdapter(
+                    activity = activity as SimpleActivity,
+                    alarms = alarms,
+                    toggleAlarmInterface = this,
+                    recyclerView = binding.alarmsList
+                ) {
+                    openEditAlarm(it as Alarm)
+                }.apply {
+                    binding.alarmsList.adapter = this
+                }
+            } else {
+                currAdapter.apply {
+                    updatePrimaryColor()
+                    updateBackgroundColor(requireContext().getProperBackgroundColor())
+                    updateTextColor(requireContext().getProperTextColor())
+                    updateItems(alarms)
+                }
             }
         }
     }
@@ -156,7 +175,8 @@ class AlarmFragment : Fragment(), ToggleAlarmInterface {
         (activity as SimpleActivity).handleFullScreenNotificationsPermission { granted ->
             if (granted) {
                 if (requireContext().dbHelper.updateAlarmEnabledState(id, isEnabled)) {
-                    val alarm = alarms.firstOrNull { it.id == id } ?: return@handleFullScreenNotificationsPermission
+                    val alarm = alarms.firstOrNull { it.id == id }
+                        ?: return@handleFullScreenNotificationsPermission
                     alarm.isEnabled = isEnabled
                     checkAlarmState(alarm)
                     if (!alarm.isEnabled && alarm.oneShot) {