refactor: remove redundant dispatchers

2026-06-02 00:29:08 +02:00 · 2025-12-25 22:57:21 -05:00
parent 0bf52ad378
commit af21a6a3cf
9 changed files with 66 additions and 149 deletions
@@ -2,7 +2,6 @@ package com.zaneschepke.wireguardautotunnel

 import android.app.Application
 import android.os.StrictMode
-import android.os.StrictMode.ThreadPolicy
 import com.zaneschepke.logcatter.LogReader
 import com.zaneschepke.wireguardautotunnel.core.notification.NotificationMonitor
 import com.zaneschepke.wireguardautotunnel.di.Dispatcher
@@ -56,13 +55,13 @@ class WireGuardAutoTunnel : Application(), KoinComponent {
        if (BuildConfig.DEBUG) {
            Timber.plant(Timber.DebugTree())
            StrictMode.setThreadPolicy(
-                ThreadPolicy.Builder()
-                    .detectDiskReads()
-                    .detectDiskWrites()
-                    .detectNetwork()
+                StrictMode.ThreadPolicy.Builder()
+                    .detectAll()
                    .penaltyLog()
+                    .penaltyFlashScreen()
                    .build()
            )
+            StrictMode.setVmPolicy(StrictMode.VmPolicy.Builder().detectAll().penaltyLog().build())
        } else {
            Timber.plant(ReleaseTree())
        }
@@ -6,25 +6,18 @@ import com.zaneschepke.wireguardautotunnel.data.mapper.toDomain
 import com.zaneschepke.wireguardautotunnel.data.mapper.toEntity
 import com.zaneschepke.wireguardautotunnel.domain.model.AutoTunnelSettings as Domain
 import com.zaneschepke.wireguardautotunnel.domain.repository.AutoTunnelSettingsRepository
-import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.flowOn
 import kotlinx.coroutines.flow.map

-class RoomAutoTunnelSettingsRepository(
-    private val autoTunnelSettingsDao: AutoTunnelSettingsDao,
-    private val ioDispatcher: CoroutineDispatcher,
-) : AutoTunnelSettingsRepository {
+class RoomAutoTunnelSettingsRepository(private val autoTunnelSettingsDao: AutoTunnelSettingsDao) :
+    AutoTunnelSettingsRepository {
    override suspend fun upsert(autoTunnelSettings: Domain) {
        autoTunnelSettingsDao.upsert(autoTunnelSettings.toEntity())
    }

    override val flow: Flow<Domain>
        get() =
-            autoTunnelSettingsDao
-                .getAutoTunnelSettingsFlow()
-                .map { (it ?: Entity()).toDomain() }
-                .flowOn(ioDispatcher)
+            autoTunnelSettingsDao.getAutoTunnelSettingsFlow().map { (it ?: Entity()).toDomain() }

    override suspend fun getAutoTunnelSettings(): Domain {
        return (autoTunnelSettingsDao.getAutoTunnelSettings() ?: Entity()).toDomain()
@@ -6,25 +6,17 @@ import com.zaneschepke.wireguardautotunnel.data.mapper.toDomain
 import com.zaneschepke.wireguardautotunnel.data.mapper.toEntity
 import com.zaneschepke.wireguardautotunnel.domain.model.DnsSettings as Domain
 import com.zaneschepke.wireguardautotunnel.domain.repository.DnsSettingsRepository
-import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.flowOn
 import kotlinx.coroutines.flow.map

-class RoomDnsSettingsRepository(
-    private val dnsSettingsDao: DnsSettingsDao,
-    private val ioDispatcher: CoroutineDispatcher,
-) : DnsSettingsRepository {
+class RoomDnsSettingsRepository(private val dnsSettingsDao: DnsSettingsDao) :
+    DnsSettingsRepository {
    override suspend fun upsert(dnsSettings: Domain) {
        dnsSettingsDao.upsert(dnsSettings.toEntity())
    }

    override val flow: Flow<Domain>
-        get() =
-            dnsSettingsDao
-                .getDnsSettingsFlow()
-                .map { (it ?: Entity()).toDomain() }
-                .flowOn(ioDispatcher)
+        get() = dnsSettingsDao.getDnsSettingsFlow().map { (it ?: Entity()).toDomain() }

    override suspend fun getDnsSettings(): Domain {
        return (dnsSettingsDao.getDnsSettings() ?: Entity()).toDomain()
@@ -6,28 +6,18 @@ import com.zaneschepke.wireguardautotunnel.data.mapper.toDomain
 import com.zaneschepke.wireguardautotunnel.data.mapper.toEntity
 import com.zaneschepke.wireguardautotunnel.domain.model.LockdownSettings as Domain
 import com.zaneschepke.wireguardautotunnel.domain.repository.LockdownSettingsRepository
-import kotlinx.coroutines.CoroutineDispatcher
-import kotlinx.coroutines.flow.flowOn
 import kotlinx.coroutines.flow.map
-import kotlinx.coroutines.withContext

-class RoomLockdownSettingsRepository(
-    private val lockdownSettingsDao: LockdownSettingsDao,
-    private val ioDispatcher: CoroutineDispatcher,
-) : LockdownSettingsRepository {
+class RoomLockdownSettingsRepository(private val lockdownSettingsDao: LockdownSettingsDao) :
+    LockdownSettingsRepository {
    override suspend fun upsert(lockdownSettings: Domain) {
-        withContext(ioDispatcher) { lockdownSettingsDao.upsert(lockdownSettings.toEntity()) }
+        lockdownSettingsDao.upsert(lockdownSettings.toEntity())
    }

    override val flow =
-        lockdownSettingsDao
-            .getLockdownSettingsFlow()
-            .map { (it ?: Entity()).toDomain() }
-            .flowOn(ioDispatcher)
+        lockdownSettingsDao.getLockdownSettingsFlow().map { (it ?: Entity()).toDomain() }

    override suspend fun getLockdownSettings(): Domain {
-        return withContext(ioDispatcher) {
-            (lockdownSettingsDao.getLockdownSettings() ?: Entity()).toDomain()
-        }
+        return (lockdownSettingsDao.getLockdownSettings() ?: Entity()).toDomain()
    }
 }
@@ -6,25 +6,18 @@ import com.zaneschepke.wireguardautotunnel.data.mapper.toDomain
 import com.zaneschepke.wireguardautotunnel.data.mapper.toEntity
 import com.zaneschepke.wireguardautotunnel.domain.model.MonitoringSettings as Domain
 import com.zaneschepke.wireguardautotunnel.domain.repository.MonitoringSettingsRepository
-import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.flowOn
 import kotlinx.coroutines.flow.map

-class RoomMonitoringSettingsRepository(
-    private val monitoringSettingsDao: MonitoringSettingsDao,
-    private val ioDispatcher: CoroutineDispatcher,
-) : MonitoringSettingsRepository {
+class RoomMonitoringSettingsRepository(private val monitoringSettingsDao: MonitoringSettingsDao) :
+    MonitoringSettingsRepository {
    override suspend fun upsert(monitoringSettings: Domain) {
        monitoringSettingsDao.upsert(monitoringSettings.toEntity())
    }

    override val flow: Flow<Domain>
        get() =
-            monitoringSettingsDao
-                .getMonitoringSettingsFlow()
-                .map { (it ?: Entity()).toDomain() }
-                .flowOn(ioDispatcher)
+            monitoringSettingsDao.getMonitoringSettingsFlow().map { (it ?: Entity()).toDomain() }

    override suspend fun getMonitoringSettings(): Domain {
        return (monitoringSettingsDao.getMonitoringSettings() ?: Entity()).toDomain()
@@ -6,29 +6,18 @@ import com.zaneschepke.wireguardautotunnel.data.mapper.toDomain
 import com.zaneschepke.wireguardautotunnel.data.mapper.toEntity
 import com.zaneschepke.wireguardautotunnel.domain.model.ProxySettings as Domain
 import com.zaneschepke.wireguardautotunnel.domain.repository.ProxySettingsRepository
-import kotlinx.coroutines.CoroutineDispatcher
-import kotlinx.coroutines.flow.flowOn
 import kotlinx.coroutines.flow.map
-import kotlinx.coroutines.withContext

-class RoomProxySettingsRepository(
-    private val proxySettingsDao: ProxySettingsDao,
-    private val ioDispatcher: CoroutineDispatcher,
-) : ProxySettingsRepository {
+class RoomProxySettingsRepository(private val proxySettingsDao: ProxySettingsDao) :
+    ProxySettingsRepository {

    override suspend fun upsert(proxySettings: Domain) {
-        withContext(ioDispatcher) { proxySettingsDao.upsert(proxySettings.toEntity()) }
+        proxySettingsDao.upsert(proxySettings.toEntity())
    }

-    override val flow =
-        proxySettingsDao
-            .getProxySettingsFlow()
-            .map { (it ?: Entity()).toDomain() }
-            .flowOn(ioDispatcher)
+    override val flow = proxySettingsDao.getProxySettingsFlow().map { (it ?: Entity()).toDomain() }

    override suspend fun getProxySettings(): Domain {
-        return withContext(ioDispatcher) {
-            (proxySettingsDao.getProxySettings() ?: Entity()).toDomain()
-        }
+        return (proxySettingsDao.getProxySettings() ?: Entity()).toDomain()
    }
 }
@@ -8,44 +8,33 @@ import com.zaneschepke.wireguardautotunnel.data.model.AppMode
 import com.zaneschepke.wireguardautotunnel.domain.model.GeneralSettings as Domain
 import com.zaneschepke.wireguardautotunnel.domain.repository.GeneralSettingRepository
 import com.zaneschepke.wireguardautotunnel.ui.theme.Theme
-import kotlinx.coroutines.CoroutineDispatcher
-import kotlinx.coroutines.flow.flowOn
 import kotlinx.coroutines.flow.map
-import kotlinx.coroutines.withContext

-class RoomSettingsRepository(
-    private val settingsDao: GeneralSettingsDao,
-    private val ioDispatcher: CoroutineDispatcher,
-) : GeneralSettingRepository {
+class RoomSettingsRepository(private val settingsDao: GeneralSettingsDao) :
+    GeneralSettingRepository {
    override suspend fun upsert(generalSettings: Domain) {
-        withContext(ioDispatcher) { settingsDao.upsert(generalSettings.toEntity()) }
+        settingsDao.upsert(generalSettings.toEntity())
    }

-    override val flow =
-        settingsDao
-            .getGeneralSettingsFlow()
-            .map { (it ?: Entity()).toDomain() }
-            .flowOn(ioDispatcher)
+    override val flow = settingsDao.getGeneralSettingsFlow().map { (it ?: Entity()).toDomain() }

    override suspend fun getGeneralSettings(): Domain {
-        return withContext(ioDispatcher) {
-            (settingsDao.getGeneralSettings() ?: Entity()).toDomain()
-        }
+        return (settingsDao.getGeneralSettings() ?: Entity()).toDomain()
    }

    override suspend fun updateTheme(theme: Theme) {
-        withContext(ioDispatcher) { settingsDao.updateTheme(theme.name) }
+        settingsDao.updateTheme(theme.name)
    }

    override suspend fun updateLocale(locale: String) {
-        withContext(ioDispatcher) { settingsDao.updateLocale(locale) }
+        settingsDao.updateLocale(locale)
    }

    override suspend fun updatePinLockEnabled(enabled: Boolean) {
-        withContext(ioDispatcher) { settingsDao.updatePinLockEnabled(enabled) }
+        settingsDao.updatePinLockEnabled(enabled)
    }

    override suspend fun updateAppMode(appMode: AppMode) {
-        withContext(ioDispatcher) { settingsDao.updateAppMode(appMode) }
+        settingsDao.updateAppMode(appMode)
    }
 }
@@ -5,116 +5,94 @@ import com.zaneschepke.wireguardautotunnel.data.mapper.toDomain
 import com.zaneschepke.wireguardautotunnel.data.mapper.toEntity
 import com.zaneschepke.wireguardautotunnel.domain.model.TunnelConfig as Domain
 import com.zaneschepke.wireguardautotunnel.domain.repository.TunnelRepository
-import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.flowOn
 import kotlinx.coroutines.flow.map
-import kotlinx.coroutines.withContext

-class RoomTunnelRepository(
-    private val tunnelConfigDao: TunnelConfigDao,
-    private val ioDispatcher: CoroutineDispatcher,
-) : TunnelRepository {
+class RoomTunnelRepository(private val tunnelConfigDao: TunnelConfigDao) : TunnelRepository {

    override val flow =
-        tunnelConfigDao.getAllFlow().flowOn(ioDispatcher).map {
-            it.map { tunnelConfig -> tunnelConfig.toDomain() }
-        }
+        tunnelConfigDao.getAllFlow().map { it.map { tunnelConfig -> tunnelConfig.toDomain() } }

    override val userTunnelsFlow =
-        tunnelConfigDao.getAllTunnelsExceptGlobal().flowOn(ioDispatcher).map {
+        tunnelConfigDao.getAllTunnelsExceptGlobal().map {
            it.map { tunnelConfig -> tunnelConfig.toDomain() }
        }

    override val globalTunnelFlow: Flow<Domain?> =
-        tunnelConfigDao.getGlobalTunnel().flowOn(ioDispatcher).map { it?.toDomain() }
+        tunnelConfigDao.getGlobalTunnel().map { it?.toDomain() }

    override suspend fun getAll(): List<Domain> {
-        return withContext(ioDispatcher) { tunnelConfigDao.getAll().map { it.toDomain() } }
+        return tunnelConfigDao.getAll().map { it.toDomain() }
    }

    override suspend fun save(tunnelConfig: Domain) {
-        withContext(ioDispatcher) { tunnelConfigDao.upsert(tunnelConfig.toEntity()) }
+        tunnelConfigDao.upsert(tunnelConfig.toEntity())
    }

    override suspend fun saveAll(tunnelConfigList: List<Domain>) {
-        withContext(ioDispatcher) {
-            tunnelConfigDao.saveAll(
-                tunnelConfigList.map { tunnelConfig -> tunnelConfig.toEntity() }
-            )
-        }
+        tunnelConfigDao.saveAll(tunnelConfigList.map { tunnelConfig -> tunnelConfig.toEntity() })
    }

    override suspend fun updatePrimaryTunnel(tunnelConfig: Domain?) {
-        withContext(ioDispatcher) {
-            tunnelConfigDao.resetPrimaryTunnel()
-            tunnelConfig?.let { save(it.copy(isPrimaryTunnel = true)) }
-        }
+        tunnelConfigDao.resetPrimaryTunnel()
+        tunnelConfig?.let { save(it.copy(isPrimaryTunnel = true)) }
    }

    override suspend fun resetActiveTunnels() {
-        withContext(ioDispatcher) { tunnelConfigDao.resetActiveTunnels() }
+        tunnelConfigDao.resetActiveTunnels()
    }

    override suspend fun updateMobileDataTunnel(tunnelConfig: Domain?) {
-        withContext(ioDispatcher) {
-            tunnelConfigDao.resetMobileDataTunnel()
-            tunnelConfig?.let { save(it.copy(isMobileDataTunnel = true)) }
-        }
+        tunnelConfigDao.resetMobileDataTunnel()
+        tunnelConfig?.let { save(it.copy(isMobileDataTunnel = true)) }
    }

    override suspend fun updateEthernetTunnel(tunnelConfig: Domain?) {
-        withContext(ioDispatcher) {
-            tunnelConfigDao.resetEthernetTunnel()
-            tunnelConfig?.let { save(it.copy(isEthernetTunnel = true)) }
-        }
+        tunnelConfigDao.resetEthernetTunnel()
+        tunnelConfig?.let { save(it.copy(isEthernetTunnel = true)) }
    }

    override suspend fun delete(tunnelConfig: Domain) {
-        withContext(ioDispatcher) { tunnelConfigDao.delete(tunnelConfig.toEntity()) }
+        tunnelConfigDao.delete(tunnelConfig.toEntity())
    }

    override suspend fun getById(id: Int): Domain? {
-        return withContext(ioDispatcher) { tunnelConfigDao.getById(id.toLong())?.toDomain() }
+        return tunnelConfigDao.getById(id.toLong())?.toDomain()
    }

    override suspend fun getActive(): List<Domain> {
-        return withContext(ioDispatcher) { tunnelConfigDao.getActive().map { it.toDomain() } }
+        return tunnelConfigDao.getActive().map { it.toDomain() }
    }

    override suspend fun getDefaultTunnel(): Domain? {
-        return withContext(ioDispatcher) { tunnelConfigDao.getDefaultTunnel()?.toDomain() }
+        return tunnelConfigDao.getDefaultTunnel()?.toDomain()
    }

    override suspend fun getStartTunnel(): Domain? {
-        return withContext(ioDispatcher) { tunnelConfigDao.getStartTunnel()?.toDomain() }
+        return tunnelConfigDao.getStartTunnel()?.toDomain()
    }

    override suspend fun count(): Int {
-        return withContext(ioDispatcher) { tunnelConfigDao.count().toInt() }
+        return tunnelConfigDao.count().toInt()
    }

    override suspend fun findByTunnelName(name: String): Domain? {
-        return withContext(ioDispatcher) { tunnelConfigDao.getByName(name)?.toDomain() }
+        return tunnelConfigDao.getByName(name)?.toDomain()
    }

    override suspend fun findByTunnelNetworksName(name: String): List<Domain> {
-        return withContext(ioDispatcher) {
-            tunnelConfigDao.findByTunnelNetworkName(name).map { it.toDomain() }
-        }
+        return tunnelConfigDao.findByTunnelNetworkName(name).map { it.toDomain() }
    }

    override suspend fun findByMobileDataTunnel(): List<Domain> {
-        return withContext(ioDispatcher) {
-            tunnelConfigDao.findByMobileDataTunnel().map { it.toDomain() }
-        }
+        return tunnelConfigDao.findByMobileDataTunnel().map { it.toDomain() }
    }

    override suspend fun findPrimary(): List<Domain> {
-        return withContext(ioDispatcher) { tunnelConfigDao.findByPrimary().map { it.toDomain() } }
+        return tunnelConfigDao.findByPrimary().map { it.toDomain() }
    }

    override suspend fun delete(tunnels: List<Domain>) {
-        withContext(ioDispatcher) { tunnelConfigDao.delete(tunnels.map { it.toEntity() }) }
+        tunnelConfigDao.delete(tunnels.map { it.toEntity() })
    }
 }
@@ -29,7 +29,9 @@ import com.zaneschepke.wireguardautotunnel.domain.repository.MonitoringSettingsR
 import com.zaneschepke.wireguardautotunnel.domain.repository.ProxySettingsRepository
 import com.zaneschepke.wireguardautotunnel.domain.repository.TunnelRepository
 import org.koin.android.ext.koin.androidContext
+import org.koin.core.module.dsl.singleOf
 import org.koin.core.qualifier.named
+import org.koin.dsl.bind
 import org.koin.dsl.module

 val databaseModule = module {
@@ -64,21 +66,13 @@ val databaseModule = module {
    single<AppStateRepository> {
        DataStoreAppStateRepository(get(), get(named(Scope.APPLICATION)), get(named(Dispatcher.IO)))
    }
-    single<AutoTunnelSettingsRepository> {
-        RoomAutoTunnelSettingsRepository(get(), get(named(Dispatcher.IO)))
-    }
-    single<DnsSettingsRepository> { RoomDnsSettingsRepository(get(), get(named(Dispatcher.IO))) }
-    single<LockdownSettingsRepository> {
-        RoomLockdownSettingsRepository(get(), get(named(Dispatcher.IO)))
-    }
-    single<MonitoringSettingsRepository> {
-        RoomMonitoringSettingsRepository(get(), get(named(Dispatcher.IO)))
-    }
-    single<ProxySettingsRepository> {
-        RoomProxySettingsRepository(get(), get(named(Dispatcher.IO)))
-    }
-    single<GeneralSettingRepository> { RoomSettingsRepository(get(), get(named(Dispatcher.IO))) }
-    single<TunnelRepository> { RoomTunnelRepository(get(), get(named(Dispatcher.IO))) }
+    singleOf(::RoomAutoTunnelSettingsRepository) bind AutoTunnelSettingsRepository::class
+    singleOf(::RoomDnsSettingsRepository) bind DnsSettingsRepository::class
+    singleOf(::RoomLockdownSettingsRepository) bind LockdownSettingsRepository::class
+    singleOf(::RoomMonitoringSettingsRepository) bind MonitoringSettingsRepository::class
+    singleOf(::RoomProxySettingsRepository) bind ProxySettingsRepository::class
+    singleOf(::RoomSettingsRepository) bind GeneralSettingRepository::class
+    singleOf(::RoomTunnelRepository) bind TunnelRepository::class
    single<InstalledPackageRepository> {
        InstalledAndroidPackageRepository(androidContext(), get(named(Dispatcher.IO)))
    }