Improve managers to use instances and improve context handling

Author: WSTxda

app/src/main/java/com/wstxda/toolkit/base/BaseTileService.kt

@@ -5,6 +5,7 @@ import android.app.PendingIntent
 import android.content.Intent
 import android.os.Build
 import android.service.quicksettings.TileService
+import androidx.annotation.CallSuper
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
@@ -14,11 +15,13 @@ abstract class BaseTileService : TileService() {
 
     protected val serviceScope = CoroutineScope(SupervisorJob() + Dispatchers.Main)
 
+    @CallSuper
     override fun onStartListening() {
         super.onStartListening()
         updateTile()
     }
 
+    @CallSuper
     override fun onDestroy() {
         super.onDestroy()
         serviceScope.cancel()

app/src/main/java/com/wstxda/toolkit/manager/audio/SoundModeManager.kt

@@ -7,71 +7,77 @@ import android.content.Intent
 import android.content.IntentFilter
 import android.media.AudioManager
 import android.os.Build
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.channels.awaitClose
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.callbackFlow
+import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.launch
 
-object SoundModeManager {
+class SoundModeManager(private val context: Context) {
 
-    private lateinit var audioManager: AudioManager
-    private lateinit var notificationManager: NotificationManager
+    private val audioManager = context.getSystemService(Context.AUDIO_SERVICE) as AudioManager
+    private val notificationManager =
+        context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+    private val managerScope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
 
-    private val _currentMode = MutableStateFlow(SoundMode.NORMAL)
-    val currentMode = _currentMode.asStateFlow()
+    val currentModeFlow: Flow<SoundMode> = callbackFlow {
+        trySend(getCurrentModeInternal())
 
-    private val ringerModeReceiver = object : BroadcastReceiver() {
-        override fun onReceive(context: Context, intent: Intent) {
-            if (intent.action == AudioManager.RINGER_MODE_CHANGED_ACTION) {
-                _currentMode.value = getCurrentModeInternal()
+        val receiver = object : BroadcastReceiver() {
+            override fun onReceive(context: Context, intent: Intent) {
+                if (intent.action == AudioManager.RINGER_MODE_CHANGED_ACTION) {
+                    trySend(getCurrentModeInternal())
+                }
             }
         }
-    }
-
-    fun init(context: Context) {
-        audioManager = context.getSystemService(Context.AUDIO_SERVICE) as AudioManager
-        notificationManager =
-            context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
-
-        _currentMode.value = getCurrentModeInternal()
 
         context.registerReceiver(
-            ringerModeReceiver,
+            receiver,
             IntentFilter(AudioManager.RINGER_MODE_CHANGED_ACTION),
             if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
                 Context.RECEIVER_NOT_EXPORTED
             } else 0
         )
-    }
+
+        awaitClose {
+            try {
+                context.unregisterReceiver(receiver)
+            } catch (_: IllegalArgumentException) {
+            }
+        }
+    }.distinctUntilChanged()
 
     fun hasPermission(): Boolean {
-        return if (::notificationManager.isInitialized) {
-            notificationManager.isNotificationPolicyAccessGranted
-        } else false
+        return notificationManager.isNotificationPolicyAccessGranted
     }
 
     fun cycleMode() {
         if (!hasPermission()) return
 
-        val newMode = when (_currentMode.value) {
-            SoundMode.NORMAL -> SoundMode.VIBRATE
-            SoundMode.VIBRATE -> SoundMode.SILENT
-            SoundMode.SILENT -> SoundMode.NORMAL
+        managerScope.launch {
+            val current = getCurrentModeInternal()
+            val newMode = when (current) {
+                SoundMode.NORMAL -> SoundMode.VIBRATE
+                SoundMode.VIBRATE -> SoundMode.SILENT
+                SoundMode.SILENT -> SoundMode.NORMAL
+            }
+            audioManager.ringerMode = newMode.ringerMode
         }
-        audioManager.ringerMode = newMode.ringerMode
     }
 
-    private fun getCurrentModeInternal(): SoundMode {
-        if (!::audioManager.isInitialized) return SoundMode.NORMAL
+    fun cleanup() {
+        managerScope.cancel()
+    }
+
+    fun getCurrentModeInternal(): SoundMode {
         return when (audioManager.ringerMode) {
             AudioManager.RINGER_MODE_VIBRATE -> SoundMode.VIBRATE
             AudioManager.RINGER_MODE_SILENT -> SoundMode.SILENT
             else -> SoundMode.NORMAL
         }
     }
-
-    fun unregisterReceiver(context: Context) {
-        try {
-            context.unregisterReceiver(ringerModeReceiver)
-        } catch (_: IllegalArgumentException) {
-        }
-    }
 }

app/src/main/java/com/wstxda/toolkit/manager/counter/CounterManager.kt

@@ -7,33 +7,39 @@ import androidx.core.content.edit
 import com.wstxda.toolkit.tiles.counter.CounterAddTileService
 import com.wstxda.toolkit.tiles.counter.CounterRemoveTileService
 import com.wstxda.toolkit.tiles.counter.CounterResetTileService
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.launch
 
-object CounterManager {
+class CounterManager(context: Context) {
 
-    private const val PREFS_NAME = "counter_prefs"
-    private const val KEY_COUNT = "count"
-    private const val KEY_ACTION = "last_action"
+    companion object {
+        private const val PREFS_NAME = "counter_prefs"
+        private const val KEY_COUNT = "count"
+        private const val KEY_ACTION = "last_action"
+    }
 
-    private lateinit var appContext: Context
+    private val appContext = context.applicationContext
+    private val managerScope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
 
     private val _count = MutableStateFlow(0)
     val count = _count.asStateFlow()
 
     private val _lastAction = MutableStateFlow(CounterAction.NONE)
     val lastAction = _lastAction.asStateFlow()
 
-    fun initialize(context: Context) {
-        if (::appContext.isInitialized) return
-        appContext = context.applicationContext
-
-        val prefs = getPrefs()
-        _count.value = prefs.getInt(KEY_COUNT, 0)
+    init {
+        managerScope.launch {
+            val prefs = getPrefs()
+            _count.value = prefs.getInt(KEY_COUNT, 0)
 
-        val actionString = prefs.getString(KEY_ACTION, CounterAction.NONE.name)
-        _lastAction.value =
-            runCatching { CounterAction.valueOf(actionString!!) }.getOrDefault(CounterAction.NONE)
+            val actionString = prefs.getString(KEY_ACTION, CounterAction.NONE.name)
+            _lastAction.value =
+                runCatching { CounterAction.valueOf(actionString!!) }.getOrDefault(CounterAction.NONE)
+        }
     }
 
     fun increment() {
@@ -55,15 +61,15 @@ object CounterManager {
         _count.value = newValue
         _lastAction.value = action
 
-        getPrefs().edit {
-            putInt(KEY_COUNT, newValue)
-            putString(KEY_ACTION, action.name)
+        managerScope.launch {
+            getPrefs().edit {
+                putInt(KEY_COUNT, newValue)
+                putString(KEY_ACTION, action.name)
+            }
         }
     }
 
     private fun refreshAllTiles() {
-        if (!::appContext.isInitialized) return
-
         val classes = listOf(
             CounterAddTileService::class.java,
             CounterRemoveTileService::class.java,

app/src/main/java/com/wstxda/toolkit/manager/counter/CounterModule.kt

@@ -0,0 +1,14 @@
+package com.wstxda.toolkit.manager.counter
+
+import android.content.Context
+
+object CounterModule {
+    @Volatile
+    private var instance: CounterManager? = null
+
+    fun getInstance(context: Context): CounterManager {
+        return instance ?: synchronized(this) {
+            instance ?: CounterManager(context.applicationContext).also { instance = it }
+        }
+    }
+}

app/src/main/java/com/wstxda/toolkit/manager/games/CoinFlipManager.kt

@@ -2,7 +2,7 @@ package com.wstxda.toolkit.manager.games
 
 import kotlin.random.Random
 
-object CoinFlipManager {
+class CoinFlipManager() {
 
     var headsCount = 0
         private set

app/src/main/java/com/wstxda/toolkit/manager/games/DiceRollManager.kt

@@ -2,7 +2,7 @@ package com.wstxda.toolkit.manager.games
 
 import kotlin.random.Random
 
-object DiceRollManager {
+class DiceRollManager() {
 
     fun roll(): Int {
         return Random.nextInt(1, 7)