Improve memory and temperature tiile states

WSTxda · WSTxda · commit 3b0a39505c60 · 2025-12-06T19:57:12.000-03:00
diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml
@@ -260,7 +260,7 @@
                 <action android:name="android.service.quicksettings.action.QS_TILE" />
             </intent-filter>
             <meta-data
-                android:name="android.service.quicksettings.TOGGLEABLE_TILE"
+                android:name="android.service.quicksettings.INACTIVE_TILE"
                 android:value="true" />
         </service>
 
@@ -318,14 +318,14 @@
         <service
             android:name=".tiles.temperature.TemperatureTileService"
             android:exported="true"
-            android:icon="@drawable/ic_temperature_off"
+            android:icon="@drawable/ic_temperature"
             android:label="@string/temperature_tile"
             android:permission="android.permission.BIND_QUICK_SETTINGS_TILE">
             <intent-filter>
                 <action android:name="android.service.quicksettings.action.QS_TILE" />
             </intent-filter>
             <meta-data
-                android:name="android.service.quicksettings.TOGGLEABLE_TILE"
+                android:name="android.service.quicksettings.INACTIVE_TILE"
                 android:value="true" />
         </service>
     </application>
diff --git a/app/src/main/java/com/wstxda/toolkit/manager/memory/MemoryManager.kt b/app/src/main/java/com/wstxda/toolkit/manager/memory/MemoryManager.kt
@@ -27,7 +27,10 @@ class MemoryManager(context: Context) {
     private val appContext = context.applicationContext
     private val managerScope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
 
-    private val _currentState = MutableStateFlow(MemoryState.DISABLED)
+    private val activityManager = appContext.getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager
+    private val memoryInfo = ActivityManager.MemoryInfo()
+
+    private val _currentState = MutableStateFlow(MemoryState.RAM)
     val currentState = _currentState.asStateFlow()
 
     private val _usedValue = MutableStateFlow("")
@@ -44,51 +47,39 @@ class MemoryManager(context: Context) {
 
     init {
         val prefs = appContext.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
-        val savedState = prefs.getString(KEY_STATE, MemoryState.DISABLED.name)
-        _currentState.value = runCatching {
-            MemoryState.valueOf(savedState!!)
-        }.getOrDefault(MemoryState.DISABLED)
+        val savedStateName = prefs.getString(KEY_STATE, MemoryState.RAM.name)
+        val savedState = runCatching { MemoryState.valueOf(savedStateName!!) }.getOrNull()
+        _currentState.value = savedState ?: MemoryState.RAM
     }
 
     fun toggle() {
-        val nextState = when (_currentState.value) {
-            MemoryState.DISABLED -> MemoryState.RAM
-            MemoryState.RAM -> MemoryState.STORAGE
-            MemoryState.STORAGE -> MemoryState.DISABLED
-        }
-
+        val nextState =
+            if (_currentState.value == MemoryState.RAM) MemoryState.STORAGE else MemoryState.RAM
         _currentState.value = nextState
-
         appContext.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE).edit {
             putString(KEY_STATE, nextState.name)
         }
 
-        if (nextState != MemoryState.DISABLED) {
-            updateData()
-        } else {
-            clearData()
-        }
-
-        updatePollingState()
+        updateData()
     }
 
     fun setListening(listening: Boolean) {
+        if (isPanelOpen == listening) return
         isPanelOpen = listening
         updatePollingState()
     }
 
     private fun updatePollingState() {
-        val shouldPoll = _currentState.value != MemoryState.DISABLED && isPanelOpen
-
-        if (shouldPoll) {
-            if (pollingJob?.isActive != true) startPolling()
+        if (isPanelOpen) {
+            startPolling()
         } else {
             stopPolling()
         }
     }
 
     private fun startPolling() {
-        pollingJob?.cancel()
+        if (pollingJob?.isActive == true) return
+
         pollingJob = managerScope.launch {
             updateData()
             while (isActive) {
@@ -103,48 +94,39 @@ class MemoryManager(context: Context) {
         pollingJob = null
     }
 
-    private fun clearData() {
-        _usedValue.value = ""
-        _totalValue.value = ""
-        _detailValue.value = ""
-    }
-
     private fun updateData() {
-        when (_currentState.value) {
-            MemoryState.RAM -> updateRamInfo()
-            MemoryState.STORAGE -> updateStorageInfo()
-            MemoryState.DISABLED -> {}
+        try {
+            when (_currentState.value) {
+                MemoryState.RAM -> updateRamInfo()
+                MemoryState.STORAGE -> updateStorageInfo()
+            }
+        } catch (e: Exception) {
+            e.printStackTrace()
         }
     }
 
     private fun updateRamInfo() {
-        val am = appContext.getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager
-        val memInfo = ActivityManager.MemoryInfo()
-        am.getMemoryInfo(memInfo)
+        activityManager.getMemoryInfo(memoryInfo)
 
-        val usedBytes = memInfo.totalMem - memInfo.availMem
-        val totalBytes = memInfo.totalMem
-        val percent = (usedBytes.toDouble() / totalBytes.toDouble() * 100).toInt()
+        val totalBytes = memoryInfo.totalMem
+        val usedBytes = totalBytes - memoryInfo.availMem
+        val percent = ((usedBytes * 100) / totalBytes).toInt()
 
         _usedValue.value = Formatter.formatShortFileSize(appContext, usedBytes)
         _totalValue.value = Formatter.formatShortFileSize(appContext, totalBytes)
         _detailValue.value = "$percent%"
     }
 
     private fun updateStorageInfo() {
-        try {
-            val path = Environment.getDataDirectory()
-            val stat = StatFs(path.path)
-
-            val totalBytes = stat.blockCountLong * stat.blockSizeLong
-            val freeBytes = stat.availableBlocksLong * stat.blockSizeLong
-            val usedBytes = totalBytes - freeBytes
-
-            _usedValue.value = Formatter.formatShortFileSize(appContext, usedBytes)
-            _totalValue.value = Formatter.formatShortFileSize(appContext, totalBytes)
-            _detailValue.value = Formatter.formatShortFileSize(appContext, freeBytes)
-        } catch (_: Exception) {
-            clearData()
-        }
+        val path = Environment.getDataDirectory()
+        val stat = StatFs(path.path)
+
+        val totalBytes = stat.blockCountLong * stat.blockSizeLong
+        val freeBytes = stat.availableBlocksLong * stat.blockSizeLong
+        val usedBytes = totalBytes - freeBytes
+
+        _usedValue.value = Formatter.formatShortFileSize(appContext, usedBytes)
+        _totalValue.value = Formatter.formatShortFileSize(appContext, totalBytes)
+        _detailValue.value = Formatter.formatShortFileSize(appContext, freeBytes)
     }
 }
diff --git a/app/src/main/java/com/wstxda/toolkit/manager/memory/MemoryState.kt b/app/src/main/java/com/wstxda/toolkit/manager/memory/MemoryState.kt
@@ -1,5 +1,5 @@
 package com.wstxda.toolkit.manager.memory
 
 enum class MemoryState {
-    DISABLED, RAM, STORAGE
+    RAM, STORAGE
 }
diff --git a/app/src/main/java/com/wstxda/toolkit/manager/temperature/TemperatureManager.kt b/app/src/main/java/com/wstxda/toolkit/manager/temperature/TemperatureManager.kt
@@ -22,43 +22,21 @@ class TemperatureManager(context: Context) {
 
     private val appContext = context.applicationContext
     private val managerScope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
-
-    private val _isActive = MutableStateFlow(false)
-    val isActive = _isActive.asStateFlow()
-
     private val _temperature = MutableStateFlow(0f)
     val temperature = _temperature.asStateFlow()
-
     private var pollingJob: Job? = null
-    private var isPanelOpen = false
-
-    fun toggle() {
-        _isActive.value = !_isActive.value
-
-        if (_isActive.value) {
-            updateData()
-        }
-
-        updatePollingState()
-    }
 
     fun setListening(listening: Boolean) {
-        isPanelOpen = listening
-        updatePollingState()
-    }
-
-    private fun updatePollingState() {
-        val shouldPoll = _isActive.value && isPanelOpen
-
-        if (shouldPoll) {
-            if (pollingJob?.isActive != true) startPolling()
+        if (listening) {
+            startPolling()
         } else {
             stopPolling()
         }
     }
 
     private fun startPolling() {
-        pollingJob?.cancel()
+        if (pollingJob?.isActive == true) return
+
         pollingJob = managerScope.launch {
             updateData()
             while (isActive) {
diff --git a/app/src/main/java/com/wstxda/toolkit/tiles/memory/MemoryTileService.kt b/app/src/main/java/com/wstxda/toolkit/tiles/memory/MemoryTileService.kt
@@ -4,7 +4,6 @@ import android.service.quicksettings.Tile
 import com.wstxda.toolkit.base.BaseTileService
 import com.wstxda.toolkit.manager.memory.MemoryManager
 import com.wstxda.toolkit.manager.memory.MemoryModule
-import com.wstxda.toolkit.manager.memory.MemoryState
 import com.wstxda.toolkit.ui.icon.MemoryIconProvider
 import com.wstxda.toolkit.ui.label.MemoryLabelProvider
 import kotlinx.coroutines.flow.Flow
@@ -45,9 +44,9 @@ class MemoryTileService : BaseTileService() {
         val detail = memoryManager.detailValue.value
 
         setTileState(
-            state = if (state == MemoryState.DISABLED) Tile.STATE_INACTIVE else Tile.STATE_ACTIVE,
+            state = Tile.STATE_INACTIVE,
             label = memoryLabelProvider.getLabel(state, detail),
-            subtitle = memoryLabelProvider.getSubtitle(state, used, total),
+            subtitle = memoryLabelProvider.getSubtitle(used, total),
             icon = memoryIconProvider.getIcon(state)
         )
     }
diff --git a/app/src/main/java/com/wstxda/toolkit/tiles/temperature/TemperatureTileService.kt b/app/src/main/java/com/wstxda/toolkit/tiles/temperature/TemperatureTileService.kt
@@ -2,15 +2,14 @@ package com.wstxda.toolkit.tiles.temperature
 
 import android.service.quicksettings.Tile
 import com.wstxda.toolkit.base.BaseTileService
-import com.wstxda.toolkit.manager.temperature.TemperatureManager
 import com.wstxda.toolkit.manager.temperature.TemperatureModule
 import com.wstxda.toolkit.ui.icon.TemperatureIconProvider
 import com.wstxda.toolkit.ui.label.TemperatureLabelProvider
 import kotlinx.coroutines.flow.Flow
 
 class TemperatureTileService : BaseTileService() {
 
-    private val temperatureManager: TemperatureManager by lazy { TemperatureModule.getInstance(applicationContext) }
+    private val temperatureManager by lazy { TemperatureModule.getInstance(applicationContext) }
     private val temperatureLabelProvider by lazy { TemperatureLabelProvider(applicationContext) }
     private val temperatureIconProvider by lazy { TemperatureIconProvider(applicationContext) }
 
@@ -25,24 +24,20 @@ class TemperatureTileService : BaseTileService() {
     }
 
     override fun onClick() {
-        temperatureManager.toggle()
     }
 
     override fun flowsToCollect(): List<Flow<*>> {
-        return listOf(
-            temperatureManager.isActive, temperatureManager.temperature
-        )
+        return listOf(temperatureManager.temperature)
     }
 
     override fun updateTile() {
-        val isActive = temperatureManager.isActive.value
         val temp = temperatureManager.temperature.value
 
         setTileState(
-            state = if (isActive) Tile.STATE_ACTIVE else Tile.STATE_INACTIVE,
-            label = temperatureLabelProvider.getLabel(isActive, temp),
-            subtitle = temperatureLabelProvider.getSubtitle(isActive),
-            icon = temperatureIconProvider.getIcon(isActive)
+            state = Tile.STATE_INACTIVE,
+            label = temperatureLabelProvider.getLabel(temp),
+            subtitle = temperatureLabelProvider.getSubtitle(),
+            icon = temperatureIconProvider.getIcon()
         )
     }
 }
diff --git a/app/src/main/java/com/wstxda/toolkit/ui/icon/MemoryIconProvider.kt b/app/src/main/java/com/wstxda/toolkit/ui/icon/MemoryIconProvider.kt
@@ -9,7 +9,6 @@ class MemoryIconProvider(private val context: Context) {
 
     fun getIcon(state: MemoryState): Icon {
         val resId = when (state) {
-            MemoryState.DISABLED -> R.drawable.ic_memory
             MemoryState.RAM -> R.drawable.ic_ram
             MemoryState.STORAGE -> R.drawable.ic_storage
         }
diff --git a/app/src/main/java/com/wstxda/toolkit/ui/icon/TemperatureIconProvider.kt b/app/src/main/java/com/wstxda/toolkit/ui/icon/TemperatureIconProvider.kt
@@ -6,12 +6,7 @@ import com.wstxda.toolkit.R
 
 class TemperatureIconProvider(private val context: Context) {
 
-    fun getIcon(isActive: Boolean): Icon {
-        val iconRes = if (isActive) {
-            R.drawable.ic_temperature_on
-        } else {
-            R.drawable.ic_temperature_off
-        }
-        return Icon.createWithResource(context, iconRes)
+    fun getIcon(): Icon {
+        return Icon.createWithResource(context, R.drawable.ic_temperature)
     }
 }
diff --git a/app/src/main/java/com/wstxda/toolkit/ui/label/MemoryLabelProvider.kt b/app/src/main/java/com/wstxda/toolkit/ui/label/MemoryLabelProvider.kt
@@ -7,29 +7,16 @@ import com.wstxda.toolkit.manager.memory.MemoryState
 class MemoryLabelProvider(private val context: Context) {
 
     fun getLabel(state: MemoryState, detail: String): CharSequence {
-        return when (state) {
-            MemoryState.DISABLED -> context.getString(R.string.memory_tile)
-
-            MemoryState.RAM -> {
-                if (detail.isBlank()) return context.getString(R.string.memory_tile_empty)
-                context.getString(R.string.memory_tile_ram, detail)
-            }
+        if (detail.isBlank()) return context.getString(R.string.memory_tile)
 
-            MemoryState.STORAGE -> {
-                if (detail.isBlank()) return context.getString(R.string.memory_tile_empty)
-                context.getString(R.string.memory_tile_storage, detail)
-            }
+        return when (state) {
+            MemoryState.RAM -> context.getString(R.string.memory_tile_ram, detail)
+            MemoryState.STORAGE -> context.getString(R.string.memory_tile_storage, detail)
         }
     }
 
-    fun getSubtitle(state: MemoryState, used: String, total: String): CharSequence? {
-        return when (state) {
-            MemoryState.DISABLED -> context.getString(R.string.tile_switch)
-
-            MemoryState.RAM, MemoryState.STORAGE -> {
-                if (used.isBlank() || total.isBlank()) return null
-                context.getString(R.string.memory_tile_format, used, total)
-            }
-        }
+    fun getSubtitle(used: String, total: String): CharSequence? {
+        if (used.isBlank() || total.isBlank()) return null
+        return context.getString(R.string.memory_tile_format, used, total)
     }
 }
diff --git a/app/src/main/java/com/wstxda/toolkit/ui/label/TemperatureLabelProvider.kt b/app/src/main/java/com/wstxda/toolkit/ui/label/TemperatureLabelProvider.kt
@@ -6,19 +6,11 @@ import java.util.Locale
 
 class TemperatureLabelProvider(private val context: Context) {
 
-    fun getLabel(isActive: Boolean, temp: Float): CharSequence {
-        return if (isActive) {
-            String.format(Locale.US, context.getString(R.string.temperature_tile_format), temp)
-        } else {
-            context.getString(R.string.temperature_tile)
-        }
+    fun getLabel(temp: Float): CharSequence {
+        return String.format(Locale.US, context.getString(R.string.temperature_tile_format), temp)
     }
 
-    fun getSubtitle(isActive: Boolean): CharSequence? {
-        return if (isActive) {
-            context.getString(R.string.temperature_tile_source)
-        } else {
-            context.getString(R.string.tile_off)
-        }
+    fun getSubtitle(): CharSequence? {
+        return context.getString(R.string.temperature_tile)
     }
 }
diff --git a/app/src/main/res/drawable/ic_temperature.xml b/app/src/main/res/drawable/ic_temperature.xml
diff --git a/app/src/main/res/drawable/ic_temperature_off.xml b/app/src/main/res/drawable/ic_temperature_off.xml
diff --git a/app/src/main/res/values-pt-rBR/strings.xml b/app/src/main/res/values-pt-rBR/strings.xml
diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`package com.wstxda.toolkit.manager.memory`
`2`	`2`
`3`	`3`	`enum class MemoryState {`
`4`		`- DISABLED, RAM, STORAGE`
	`4`	`+ RAM, STORAGE`
`5`	`5`	`}`
Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,6 @@ class MemoryIconProvider(private val context: Context) {`
`9`	`9`
`10`	`10`	`fun getIcon(state: MemoryState): Icon {`
`11`	`11`	`val resId = when (state) {`
`12`		`- MemoryState.DISABLED -> R.drawable.ic_memory`
`13`	`12`	`MemoryState.RAM -> R.drawable.ic_ram`
`14`	`13`	`MemoryState.STORAGE -> R.drawable.ic_storage`
`15`	`14`	`}`
Original file line number	Diff line number	Diff line change
`@@ -6,12 +6,7 @@ import com.wstxda.toolkit.R`
`6`	`6`
`7`	`7`	`class TemperatureIconProvider(private val context: Context) {`
`8`	`8`
`9`		`- fun getIcon(isActive: Boolean): Icon {`
`10`		`- val iconRes = if (isActive) {`
`11`		`- R.drawable.ic_temperature_on`
`12`		`- } else {`
`13`		`- R.drawable.ic_temperature_off`
`14`		`- }`
`15`		`- return Icon.createWithResource(context, iconRes)`
	`9`	`+ fun getIcon(): Icon {`
	`10`	`+ return Icon.createWithResource(context, R.drawable.ic_temperature)`
`16`	`11`	`}`
`17`	`12`	`}`