refactor(deps): inject CoroutineDispatchers (#4170)

Signed-off-by: James Rich <2199651+jamesarich@users.noreply.github.com>

core/data/src/main/kotlin/org/meshtastic/core/data/datasource/DeviceHardwareLocalDataSource.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2025 Meshtastic LLC
+ * Copyright (c) 2025-2026 Meshtastic LLC
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -14,27 +14,31 @@
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
-
 package org.meshtastic.core.data.datasource
 
 import dagger.Lazy
-import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
 import org.meshtastic.core.database.dao.DeviceHardwareDao
 import org.meshtastic.core.database.entity.DeviceHardwareEntity
 import org.meshtastic.core.database.entity.asEntity
+import org.meshtastic.core.di.CoroutineDispatchers
 import org.meshtastic.core.model.NetworkDeviceHardware
 import javax.inject.Inject
 
-class DeviceHardwareLocalDataSource @Inject constructor(private val deviceHardwareDaoLazy: Lazy<DeviceHardwareDao>) {
+class DeviceHardwareLocalDataSource
+@Inject
+constructor(
+    private val deviceHardwareDaoLazy: Lazy<DeviceHardwareDao>,
+    private val dispatchers: CoroutineDispatchers,
+) {
     private val deviceHardwareDao by lazy { deviceHardwareDaoLazy.get() }
 
-    suspend fun insertAllDeviceHardware(deviceHardware: List<NetworkDeviceHardware>) = withContext(Dispatchers.IO) {
+    suspend fun insertAllDeviceHardware(deviceHardware: List<NetworkDeviceHardware>) = withContext(dispatchers.io) {
         deviceHardware.forEach { deviceHardware -> deviceHardwareDao.insert(deviceHardware.asEntity()) }
     }
 
-    suspend fun deleteAllDeviceHardware() = withContext(Dispatchers.IO) { deviceHardwareDao.deleteAll() }
+    suspend fun deleteAllDeviceHardware() = withContext(dispatchers.io) { deviceHardwareDao.deleteAll() }
 
     suspend fun getByHwModel(hwModel: Int): DeviceHardwareEntity? =
-        withContext(Dispatchers.IO) { deviceHardwareDao.getByHwModel(hwModel) }
+        withContext(dispatchers.io) { deviceHardwareDao.getByHwModel(hwModel) }
 }

core/data/src/main/kotlin/org/meshtastic/core/data/datasource/FirmwareReleaseLocalDataSource.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2025 Meshtastic LLC
+ * Copyright (c) 2025-2026 Meshtastic LLC
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -14,36 +14,40 @@
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
-
 package org.meshtastic.core.data.datasource
 
 import dagger.Lazy
-import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
 import org.meshtastic.core.database.dao.FirmwareReleaseDao
 import org.meshtastic.core.database.entity.FirmwareReleaseEntity
 import org.meshtastic.core.database.entity.FirmwareReleaseType
 import org.meshtastic.core.database.entity.asDeviceVersion
 import org.meshtastic.core.database.entity.asEntity
+import org.meshtastic.core.di.CoroutineDispatchers
 import org.meshtastic.core.model.NetworkFirmwareRelease
 import javax.inject.Inject
 
-class FirmwareReleaseLocalDataSource @Inject constructor(private val firmwareReleaseDaoLazy: Lazy<FirmwareReleaseDao>) {
+class FirmwareReleaseLocalDataSource
+@Inject
+constructor(
+    private val firmwareReleaseDaoLazy: Lazy<FirmwareReleaseDao>,
+    private val dispatchers: CoroutineDispatchers,
+) {
     private val firmwareReleaseDao by lazy { firmwareReleaseDaoLazy.get() }
 
     suspend fun insertFirmwareReleases(
         firmwareReleases: List<NetworkFirmwareRelease>,
         releaseType: FirmwareReleaseType,
-    ) = withContext(Dispatchers.IO) {
+    ) = withContext(dispatchers.io) {
         firmwareReleases.forEach { firmwareRelease ->
             firmwareReleaseDao.insert(firmwareRelease.asEntity(releaseType))
         }
     }
 
-    suspend fun deleteAllFirmwareReleases() = withContext(Dispatchers.IO) { firmwareReleaseDao.deleteAll() }
+    suspend fun deleteAllFirmwareReleases() = withContext(dispatchers.io) { firmwareReleaseDao.deleteAll() }
 
     suspend fun getLatestRelease(releaseType: FirmwareReleaseType): FirmwareReleaseEntity? =
-        withContext(Dispatchers.IO) {
+        withContext(dispatchers.io) {
             val releases = firmwareReleaseDao.getReleasesByType(releaseType)
             if (releases.isEmpty()) {
                 return@withContext null

core/data/src/main/kotlin/org/meshtastic/core/data/repository/DeviceHardwareRepository.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2025 Meshtastic LLC
+ * Copyright (c) 2025-2026 Meshtastic LLC
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -14,17 +14,16 @@
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
-
 package org.meshtastic.core.data.repository
 
 import co.touchlab.kermit.Logger
-import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
 import org.meshtastic.core.data.datasource.BootloaderOtaQuirksJsonDataSource
 import org.meshtastic.core.data.datasource.DeviceHardwareJsonDataSource
 import org.meshtastic.core.data.datasource.DeviceHardwareLocalDataSource
 import org.meshtastic.core.database.entity.DeviceHardwareEntity
 import org.meshtastic.core.database.entity.asExternalModel
+import org.meshtastic.core.di.CoroutineDispatchers
 import org.meshtastic.core.model.BootloaderOtaQuirk
 import org.meshtastic.core.model.DeviceHardware
 import org.meshtastic.core.network.DeviceHardwareRemoteDataSource
@@ -41,6 +40,7 @@ constructor(
     private val localDataSource: DeviceHardwareLocalDataSource,
     private val jsonDataSource: DeviceHardwareJsonDataSource,
     private val bootloaderOtaQuirksJsonDataSource: BootloaderOtaQuirksJsonDataSource,
+    private val dispatchers: CoroutineDispatchers,
 ) {
 
     /**
@@ -58,7 +58,7 @@ constructor(
      */
     @Suppress("LongMethod")
     suspend fun getDeviceHardwareByModel(hwModel: Int, forceRefresh: Boolean = false): Result<DeviceHardware?> =
-        withContext(Dispatchers.IO) {
+        withContext(dispatchers.io) {
             Logger.d {
                 "DeviceHardwareRepository: getDeviceHardwareByModel(hwModel=$hwModel, forceRefresh=$forceRefresh)"
             }

core/data/src/main/kotlin/org/meshtastic/core/data/repository/LocationRepository.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2025 Meshtastic LLC
+ * Copyright (c) 2025-2026 Meshtastic LLC
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -14,7 +14,6 @@
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
-
 package org.meshtastic.core.data.repository
 
 import android.Manifest.permission.ACCESS_COARSE_LOCATION
@@ -28,13 +27,13 @@ import androidx.core.location.LocationManagerCompat
 import androidx.core.location.LocationRequestCompat
 import androidx.core.location.altitude.AltitudeConverterCompat
 import co.touchlab.kermit.Logger
-import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.asExecutor
 import kotlinx.coroutines.channels.awaitClose
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.callbackFlow
 import org.meshtastic.core.analytics.platform.PlatformAnalytics
+import org.meshtastic.core.di.CoroutineDispatchers
 import javax.inject.Inject
 import javax.inject.Singleton
 
@@ -45,6 +44,7 @@ constructor(
     private val context: Application,
     private val locationManager: dagger.Lazy<LocationManager>,
     private val analytics: PlatformAnalytics,
+    private val dispatchers: CoroutineDispatchers,
 ) {
 
     /** Status of whether the app is actively subscribed to location changes. */
@@ -97,7 +97,7 @@ constructor(
                     this@requestLocationUpdates,
                     provider,
                     locationRequest,
-                    Dispatchers.IO.asExecutor(),
+                    dispatchers.io.asExecutor(),
                     locationListener,
                 )
             }

core/database/build.gradle.kts

@@ -49,6 +49,7 @@ configure<LibraryExtension> {
 }
 
 dependencies {
+    implementation(projects.core.di)
     implementation(projects.core.model)
     implementation(projects.core.proto)
     implementation(projects.core.strings)

core/database/src/main/kotlin/org/meshtastic/core/database/DatabaseManager.kt

@@ -22,7 +22,6 @@ import android.content.SharedPreferences
 import androidx.room.Room
 import co.touchlab.kermit.Logger
 import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.SharingStarted
@@ -33,6 +32,7 @@ import kotlinx.coroutines.launch
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
 import kotlinx.coroutines.withContext
+import org.meshtastic.core.di.CoroutineDispatchers
 import java.io.File
 import java.security.MessageDigest
 import javax.inject.Inject
@@ -40,9 +40,9 @@ import javax.inject.Singleton
 
 /** Manages per-device Room database instances for node data, with LRU eviction. */
 @Singleton
-class DatabaseManager @Inject constructor(private val app: Application) {
+class DatabaseManager @Inject constructor(private val app: Application, private val dispatchers: CoroutineDispatchers) {
     val prefs: SharedPreferences = app.getSharedPreferences("db-manager-prefs", Context.MODE_PRIVATE)
-    private val managerScope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
+    private val managerScope = CoroutineScope(SupervisorJob() + dispatchers.default)
 
     private val mutex = Mutex()
 
@@ -72,25 +72,27 @@ class DatabaseManager @Inject constructor(private val app: Application) {
     private val dbCache = mutableMapOf<String, MeshtasticDatabase>() // key = dbName
 
     /** Initialize the active database for [address]. */
-    suspend fun init(address: String?) = switchActiveDatabase(address)
+    suspend fun init(address: String?) {
+        switchActiveDatabase(address)
+    }
 
     /** Switch active database to the one associated with [address]. Serialized via mutex. */
     suspend fun switchActiveDatabase(address: String?) = mutex.withLock {
         val dbName = buildDbName(address)
 
-        // Remember the previously active DB name (if any) so we can record its last-used time as well.
+        // Remember the previously active DB name (any) so we can record its last-used time as well.
         val previousDbName = _currentDb.value?.openHelper?.databaseName
 
         // Fast path: no-op if already on this address
         if (_currentAddress.value == address && _currentDb.value != null) {
             markLastUsed(dbName)
-            return
+            return@withLock
         }
 
         // Build/open Room DB off the main thread
         val db =
             dbCache[dbName]
-                ?: withContext(Dispatchers.IO) { buildRoomDb(app, dbName) }.also { dbCache[dbName] = it }
+                ?: withContext(dispatchers.io) { buildRoomDb(app, dbName) }.also { dbCache[dbName] = it }
 
         _currentDb.value = db
         _currentAddress.value = address
@@ -100,10 +102,10 @@ class DatabaseManager @Inject constructor(private val app: Application) {
         previousDbName?.let { markLastUsed(it) }
 
         // Defer LRU eviction so switch is not blocked by filesystem work
-        managerScope.launch(Dispatchers.IO) { enforceCacheLimit(activeDbName = dbName) }
+        managerScope.launch(dispatchers.io) { enforceCacheLimit(activeDbName = dbName) }
 
         // One-time cleanup: remove legacy DB if present and not active
-        managerScope.launch(Dispatchers.IO) { cleanupLegacyDbIfNeeded(activeDbName = dbName) }
+        managerScope.launch(dispatchers.io) { cleanupLegacyDbIfNeeded(activeDbName = dbName) }
 
         Logger.i { "Switched active DB to ${anonymizeDbName(dbName)} for address ${anonymizeAddress(address)}" }
     }
@@ -144,7 +146,7 @@ class DatabaseManager @Inject constructor(private val app: Application) {
                 anonymizeDbName(it)
             }}"
         }
-        if (deviceDbs.size <= limit) return
+        if (deviceDbs.size <= limit) return@withLock
         val usageSnapshot = deviceDbs.associateWith { lastUsed(it) }
         Logger.d {
             "LRU lastUsed(ms): ${usageSnapshot.entries.joinToString(", ") { (name, ts) ->
@@ -173,16 +175,16 @@ class DatabaseManager @Inject constructor(private val app: Application) {
         _cacheLimit.value = clamped
         // Enforce asynchronously with current active DB protected
         val active = _currentDb.value?.openHelper?.databaseName ?: defaultDbName()
-        managerScope.launch(Dispatchers.IO) { enforceCacheLimit(activeDbName = active) }
+        managerScope.launch(dispatchers.io) { enforceCacheLimit(activeDbName = active) }
     }
 
     private suspend fun cleanupLegacyDbIfNeeded(activeDbName: String) = mutex.withLock {
-        if (prefs.getBoolean(DatabaseConstants.LEGACY_DB_CLEANED_KEY, false)) return
+        if (prefs.getBoolean(DatabaseConstants.LEGACY_DB_CLEANED_KEY, false)) return@withLock
         val legacy = DatabaseConstants.LEGACY_DB_NAME
         if (legacy == activeDbName) {
             // Never delete the active DB; mark as cleaned to avoid repeated checks
             prefs.edit().putBoolean(DatabaseConstants.LEGACY_DB_CLEANED_KEY, true).apply()
-            return
+            return@withLock
         }
         val legacyFile = getDbFile(app, legacy)
         if (legacyFile != null) {

core/network/build.gradle.kts

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2025 Meshtastic LLC
+ * Copyright (c) 2025-2026 Meshtastic LLC
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -48,6 +48,7 @@ configure<LibraryExtension> {
 }
 
 dependencies {
+    implementation(projects.core.di)
     implementation(projects.core.model)
 
     implementation(libs.coil.network.core)

core/network/src/main/kotlin/org/meshtastic/core/network/DeviceHardwareRemoteDataSource.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2025 Meshtastic LLC
+ * Copyright (c) 2025-2026 Meshtastic LLC
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -14,16 +14,20 @@
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
-
 package org.meshtastic.core.network
 
-import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
+import org.meshtastic.core.di.CoroutineDispatchers
 import org.meshtastic.core.model.NetworkDeviceHardware
 import org.meshtastic.core.network.service.ApiService
 import javax.inject.Inject
 
-class DeviceHardwareRemoteDataSource @Inject constructor(private val apiService: ApiService) {
+class DeviceHardwareRemoteDataSource
+@Inject
+constructor(
+    private val apiService: ApiService,
+    private val dispatchers: CoroutineDispatchers,
+) {
     suspend fun getAllDeviceHardware(): List<NetworkDeviceHardware> =
-        withContext(Dispatchers.IO) { apiService.getDeviceHardware() }
+        withContext(dispatchers.io) { apiService.getDeviceHardware() }
 }

core/network/src/main/kotlin/org/meshtastic/core/network/FirmwareReleaseRemoteDataSource.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2025 Meshtastic LLC
+ * Copyright (c) 2025-2026 Meshtastic LLC
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -14,16 +14,20 @@
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
-
 package org.meshtastic.core.network
 
-import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
+import org.meshtastic.core.di.CoroutineDispatchers
 import org.meshtastic.core.model.NetworkFirmwareReleases
 import org.meshtastic.core.network.service.ApiService
 import javax.inject.Inject
 
-class FirmwareReleaseRemoteDataSource @Inject constructor(private val apiService: ApiService) {
+class FirmwareReleaseRemoteDataSource
+@Inject
+constructor(
+    private val apiService: ApiService,
+    private val dispatchers: CoroutineDispatchers,
+) {
     suspend fun getFirmwareReleases(): NetworkFirmwareReleases =
-        withContext(Dispatchers.IO) { apiService.getFirmwareReleases() }
+        withContext(dispatchers.io) { apiService.getFirmwareReleases() }
 }

core/strings/src/commonMain/composeResources/values/strings.xml

@@ -1086,5 +1086,4 @@
     <string name="compass_uncertainty">Estimated area: \u00b1%1$s (\u00b1%2$s)</string>
     <string name="compass_uncertainty_unknown">Estimated area: unknown accuracy</string>
     <string name="mark_as_read">Mark as read</string>
-    <string name="now">now</string>
 </resources>

core/ui/src/main/kotlin/org/meshtastic/core/ui/util/FormatAgo.kt

@@ -17,24 +17,16 @@
 package org.meshtastic.core.ui.util
 
 import android.text.format.DateUtils
-import com.meshtastic.core.strings.getString
-import org.meshtastic.core.strings.Res
-import org.meshtastic.core.strings.now
 
 @Suppress("MagicNumber")
 fun formatAgo(lastSeenUnix: Int, currentTimeMillis: Long = System.currentTimeMillis()): String {
     val timeInMillis = lastSeenUnix * 1000L
-    val diff = currentTimeMillis - timeInMillis
 
-    return if (diff < 60_000L) {
-        getString(Res.string.now)
-    } else {
-        DateUtils.getRelativeTimeSpanString(
-            timeInMillis,
-            currentTimeMillis,
-            DateUtils.MINUTE_IN_MILLIS,
-            DateUtils.FORMAT_ABBREV_RELATIVE,
-        )
-            .toString()
-    }
+    return DateUtils.getRelativeTimeSpanString(
+        timeInMillis,
+        currentTimeMillis,
+        DateUtils.SECOND_IN_MILLIS,
+        DateUtils.FORMAT_ABBREV_RELATIVE,
+    )
+        .toString()
 }