refactor: migrate from Hilt to Koin and expand KMP common modules (#4746)

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

app/src/google/kotlin/org/meshtastic/app/analytics/GooglePlatformAnalytics.kt

@@ -46,16 +46,15 @@ import com.google.firebase.analytics.analytics
 import com.google.firebase.crashlytics.crashlytics
 import com.google.firebase.crashlytics.setCustomKeys
 import com.google.firebase.initialize
-import dagger.hilt.android.qualifiers.ApplicationContext
 import io.opentelemetry.api.GlobalOpenTelemetry
 import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.flow.launchIn
 import kotlinx.coroutines.flow.onEach
+import org.koin.core.annotation.Single
 import org.meshtastic.app.BuildConfig
 import org.meshtastic.core.repository.AnalyticsPrefs
 import org.meshtastic.core.repository.DataPair
 import org.meshtastic.core.repository.PlatformAnalytics
-import javax.inject.Inject
 import co.touchlab.kermit.Logger as KermitLogger
 
 /**
@@ -65,12 +64,9 @@ import co.touchlab.kermit.Logger as KermitLogger
  * This implementation delays initialization of SDKs until user consent is granted to reduce tracking "noise" and
  * respect privacy-focused environments.
  */
-class GooglePlatformAnalytics
-@Inject
-constructor(
-    @ApplicationContext private val context: Context,
-    private val analyticsPrefs: AnalyticsPrefs,
-) : PlatformAnalytics {
+@Single
+class GooglePlatformAnalytics(private val context: Context, private val analyticsPrefs: AnalyticsPrefs) :
+    PlatformAnalytics {
 
     private val sampleRate = 100f.takeIf { BuildConfig.DEBUG } ?: 10f // For Datadog remote sample rate
 

app/src/google/kotlin/org/meshtastic/app/di/FlavorModule.kt

@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) 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
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * 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.app.di
+
+import org.koin.core.annotation.Module
+import org.meshtastic.app.map.prefs.di.GoogleMapsKoinModule
+
+@Module(includes = [GoogleNetworkModule::class, GoogleMapsKoinModule::class])
+class FlavorModule

app/src/google/kotlin/org/meshtastic/app/di/GoogleNetworkModule.kt

@@ -19,35 +19,24 @@ package org.meshtastic.app.di
 import android.content.Context
 import com.datadog.android.okhttp.DatadogEventListener
 import com.datadog.android.okhttp.DatadogInterceptor
-import dagger.Binds
-import dagger.Module
-import dagger.Provides
-import dagger.hilt.InstallIn
-import dagger.hilt.android.qualifiers.ApplicationContext
-import dagger.hilt.components.SingletonComponent
 import okhttp3.Cache
 import okhttp3.OkHttpClient
 import okhttp3.logging.HttpLoggingInterceptor
+import org.koin.core.annotation.Module
+import org.koin.core.annotation.Single
 import org.meshtastic.core.common.BuildConfigProvider
 import org.meshtastic.core.network.service.ApiService
 import org.meshtastic.core.network.service.ApiServiceImpl
 import java.io.File
-import javax.inject.Singleton
 
-@InstallIn(SingletonComponent::class)
 @Module
-interface GoogleNetworkModule {
+class GoogleNetworkModule {
 
-    @Binds @Singleton
-    fun bindApiService(apiServiceImpl: ApiServiceImpl): ApiService
+    @Single fun bindApiService(apiServiceImpl: ApiServiceImpl): ApiService = apiServiceImpl
 
-    companion object {
-        @Provides
-        @Singleton
-        fun provideOkHttpClient(
-            @ApplicationContext context: Context,
-            buildConfigProvider: BuildConfigProvider,
-        ): OkHttpClient = OkHttpClient.Builder()
+    @Single
+    fun provideOkHttpClient(context: Context, buildConfigProvider: BuildConfigProvider): OkHttpClient =
+        OkHttpClient.Builder()
             .cache(
                 cache =
                 Cache(
@@ -63,10 +52,7 @@ interface GoogleNetworkModule {
                     }
                 },
             )
-            .addInterceptor(
-                interceptor = DatadogInterceptor.Builder(tracedHosts = listOf("meshtastic.org")).build(),
-            )
+            .addInterceptor(interceptor = DatadogInterceptor.Builder(tracedHosts = listOf("meshtastic.org")).build())
             .eventListenerFactory(eventListenerFactory = DatadogEventListener.Factory())
             .build()
-    }
 }

app/src/google/kotlin/org/meshtastic/app/map/GoogleMapViewProvider.kt

@@ -18,9 +18,11 @@ package org.meshtastic.app.map
 
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
-import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModel
+import org.koin.compose.viewmodel.koinViewModel
+import org.koin.core.annotation.Single
 import org.meshtastic.core.ui.util.MapViewProvider
 
+@Single
 class GoogleMapViewProvider : MapViewProvider {
     @Composable
     override fun MapView(
@@ -33,7 +35,7 @@ class GoogleMapViewProvider : MapViewProvider {
         tracerouteNodePositions: Map<Int, Any>,
         onTracerouteMappableCountChanged: (Int, Int) -> Unit,
     ) {
-        val mapViewModel: MapViewModel = hiltViewModel()
+        val mapViewModel: MapViewModel = koinViewModel()
         org.meshtastic.app.map.MapView(
             modifier = modifier,
             mapViewModel = mapViewModel,

app/src/google/kotlin/org/meshtastic/app/map/MapView.kt

@@ -59,7 +59,6 @@ import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.unit.dp
 import androidx.core.graphics.createBitmap
-import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModel
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import co.touchlab.kermit.Logger
 import com.google.accompanist.permissions.ExperimentalPermissionsApi
@@ -95,6 +94,7 @@ import com.google.maps.android.data.kml.KmlLayer
 import kotlinx.coroutines.launch
 import org.jetbrains.compose.resources.stringResource
 import org.json.JSONObject
+import org.koin.compose.viewmodel.koinViewModel
 import org.meshtastic.app.map.component.ClusterItemsListDialog
 import org.meshtastic.app.map.component.CustomMapLayersSheet
 import org.meshtastic.app.map.component.CustomTileProviderManagerSheet
@@ -149,7 +149,7 @@ private const val TRACEROUTE_BOUNDS_PADDING_PX = 120
 @Composable
 fun MapView(
     modifier: Modifier = Modifier,
-    mapViewModel: MapViewModel = hiltViewModel(),
+    mapViewModel: MapViewModel = koinViewModel(),
     navigateToNodeDetails: (Int) -> Unit,
     focusedNodeNum: Int? = null,
     nodeTracks: List<Position>? = null,

app/src/google/kotlin/org/meshtastic/app/map/MapViewModel.kt

@@ -29,7 +29,6 @@ import com.google.android.gms.maps.model.TileProvider
 import com.google.android.gms.maps.model.UrlTileProvider
 import com.google.maps.android.compose.CameraPositionState
 import com.google.maps.android.compose.MapType
-import dagger.hilt.android.lifecycle.HiltViewModel
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.flow.MutableStateFlow
@@ -43,6 +42,7 @@ import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
 import kotlinx.serialization.Serializable
+import org.koin.core.annotation.KoinViewModel
 import org.meshtastic.app.map.model.CustomTileProviderConfig
 import org.meshtastic.app.map.prefs.map.GoogleMapsPrefs
 import org.meshtastic.app.map.repository.CustomTileProviderRepository
@@ -62,7 +62,6 @@ import java.io.IOException
 import java.io.InputStream
 import java.net.MalformedURLException
 import java.net.URL
-import javax.inject.Inject
 import kotlin.uuid.Uuid
 
 private const val TILE_SIZE = 256
@@ -77,10 +76,8 @@ data class MapCameraPosition(
 )
 
 @Suppress("TooManyFunctions", "LongParameterList")
-@HiltViewModel
-class MapViewModel
-@Inject
-constructor(
+@KoinViewModel
+class MapViewModel(
     private val application: Application,
     mapPrefs: MapPrefs,
     private val googleMapsPrefs: GoogleMapsPrefs,

app/src/google/kotlin/org/meshtastic/app/map/prefs/di/GoogleMapsKoinModule.kt

@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 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
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * 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.app.map.prefs.di
+
+import android.content.Context
+import androidx.datastore.core.DataStore
+import androidx.datastore.preferences.SharedPreferencesMigration
+import androidx.datastore.preferences.core.PreferenceDataStoreFactory
+import androidx.datastore.preferences.core.Preferences
+import androidx.datastore.preferences.preferencesDataStoreFile
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import org.koin.core.annotation.ComponentScan
+import org.koin.core.annotation.Module
+import org.koin.core.annotation.Named
+import org.koin.core.annotation.Single
+
+@Module
+@ComponentScan("org.meshtastic.app.map")
+class GoogleMapsKoinModule {
+
+    @Single
+    @Named("GoogleMapsDataStore")
+    fun provideGoogleMapsDataStore(context: Context): DataStore<Preferences> = PreferenceDataStoreFactory.create(
+        migrations = listOf(SharedPreferencesMigration(context, "google_maps_prefs")),
+        scope = CoroutineScope(Dispatchers.IO + SupervisorJob()),
+        produceFile = { context.preferencesDataStoreFile("google_maps_ds") },
+    )
+}

app/src/google/kotlin/org/meshtastic/app/map/prefs/di/GoogleMapsModule.kt

@@ -1,68 +0,0 @@
-/*
- * 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
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * 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.app.map.prefs.di
-
-import android.content.Context
-import androidx.datastore.core.DataStore
-import androidx.datastore.preferences.SharedPreferencesMigration
-import androidx.datastore.preferences.core.PreferenceDataStoreFactory
-import androidx.datastore.preferences.core.Preferences
-import androidx.datastore.preferences.preferencesDataStoreFile
-import dagger.Binds
-import dagger.Module
-import dagger.Provides
-import dagger.hilt.InstallIn
-import dagger.hilt.android.qualifiers.ApplicationContext
-import dagger.hilt.components.SingletonComponent
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.SupervisorJob
-import org.meshtastic.app.map.prefs.map.GoogleMapsPrefs
-import org.meshtastic.app.map.prefs.map.GoogleMapsPrefsImpl
-import org.meshtastic.app.map.repository.CustomTileProviderRepository
-import org.meshtastic.app.map.repository.CustomTileProviderRepositoryImpl
-import javax.inject.Qualifier
-import javax.inject.Singleton
-
-@Qualifier
-@Retention(AnnotationRetention.BINARY)
-annotation class GoogleMapsDataStore
-
-@InstallIn(SingletonComponent::class)
-@Module
-interface GoogleMapsModule {
-
-    @Binds fun bindGoogleMapsPrefs(googleMapsPrefsImpl: GoogleMapsPrefsImpl): GoogleMapsPrefs
-
-    @Binds
-    @Singleton
-    fun bindCustomTileProviderRepository(impl: CustomTileProviderRepositoryImpl): CustomTileProviderRepository
-
-    companion object {
-        private val scope = CoroutineScope(Dispatchers.IO + SupervisorJob())
-
-        @Provides
-        @Singleton
-        @GoogleMapsDataStore
-        fun provideGoogleMapsDataStore(@ApplicationContext context: Context): DataStore<Preferences> =
-            PreferenceDataStoreFactory.create(
-                migrations = listOf(SharedPreferencesMigration(context, "google_maps_prefs")),
-                scope = scope,
-                produceFile = { context.preferencesDataStoreFile("google_maps_ds") },
-            )
-    }
-}

app/src/google/kotlin/org/meshtastic/app/map/prefs/map/GoogleMapsPrefs.kt

@@ -31,10 +31,9 @@ import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.stateIn
 import kotlinx.coroutines.launch
-import org.meshtastic.app.map.prefs.di.GoogleMapsDataStore
+import org.koin.core.annotation.Named
+import org.koin.core.annotation.Single
 import org.meshtastic.core.di.CoroutineDispatchers
-import javax.inject.Inject
-import javax.inject.Singleton
 
 /** Interface for prefs specific to Google Maps. For general map prefs, see MapPrefs. */
 interface GoogleMapsPrefs {
@@ -75,11 +74,9 @@ interface GoogleMapsPrefs {
     fun setNetworkMapLayers(value: Set<String>)
 }
 
-@Singleton
-class GoogleMapsPrefsImpl
-@Inject
-constructor(
-    @GoogleMapsDataStore private val dataStore: DataStore<Preferences>,
+@Single
+class GoogleMapsPrefsImpl(
+    @Named("GoogleMapsDataStore") private val dataStore: DataStore<Preferences>,
     dispatchers: CoroutineDispatchers,
 ) : GoogleMapsPrefs {
     private val scope = CoroutineScope(SupervisorJob() + dispatchers.default)

app/src/google/kotlin/org/meshtastic/app/map/repository/CustomTileProviderRepository.kt

@@ -23,11 +23,10 @@ import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.withContext
 import kotlinx.serialization.SerializationException
 import kotlinx.serialization.json.Json
+import org.koin.core.annotation.Single
 import org.meshtastic.app.map.model.CustomTileProviderConfig
 import org.meshtastic.core.di.CoroutineDispatchers
 import org.meshtastic.core.repository.MapTileProviderPrefs
-import javax.inject.Inject
-import javax.inject.Singleton
 
 interface CustomTileProviderRepository {
     fun getCustomTileProviders(): Flow<List<CustomTileProviderConfig>>
@@ -41,10 +40,8 @@ interface CustomTileProviderRepository {
     suspend fun getCustomTileProviderById(configId: String): CustomTileProviderConfig?
 }
 
-@Singleton
-class CustomTileProviderRepositoryImpl
-@Inject
-constructor(
+@Single
+class CustomTileProviderRepositoryImpl(
     private val json: Json,
     private val dispatchers: CoroutineDispatchers,
     private val mapTileProviderPrefs: MapTileProviderPrefs,

app/src/google/kotlin/org/meshtastic/app/node/component/InlineMap.kt

@@ -0,0 +1,85 @@
+/*
+ * 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
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * 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.app.node.component
+
+import androidx.compose.foundation.isSystemInDarkTheme
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.key
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import com.google.android.gms.maps.model.CameraPosition
+import com.google.android.gms.maps.model.LatLng
+import com.google.maps.android.compose.Circle
+import com.google.maps.android.compose.ComposeMapColorScheme
+import com.google.maps.android.compose.GoogleMap
+import com.google.maps.android.compose.MapUiSettings
+import com.google.maps.android.compose.MapsComposeExperimentalApi
+import com.google.maps.android.compose.MarkerComposable
+import com.google.maps.android.compose.rememberCameraPositionState
+import com.google.maps.android.compose.rememberUpdatedMarkerState
+import org.meshtastic.core.model.Node
+import org.meshtastic.core.ui.component.NodeChip
+import org.meshtastic.core.ui.component.precisionBitsToMeters
+
+private const val DEFAULT_ZOOM = 15f
+
+@OptIn(MapsComposeExperimentalApi::class)
+@Composable
+fun InlineMap(node: Node, modifier: Modifier = Modifier) {
+    val dark = isSystemInDarkTheme()
+    val mapColorScheme =
+        when (dark) {
+            true -> ComposeMapColorScheme.DARK
+            else -> ComposeMapColorScheme.LIGHT
+        }
+    key(node.num) {
+        val location = LatLng(node.latitude, node.longitude)
+        val cameraState = rememberCameraPositionState {
+            position = CameraPosition.fromLatLngZoom(location, DEFAULT_ZOOM)
+        }
+
+        GoogleMap(
+            mapColorScheme = mapColorScheme,
+            modifier = modifier,
+            uiSettings =
+            MapUiSettings(
+                zoomControlsEnabled = true,
+                mapToolbarEnabled = false,
+                compassEnabled = false,
+                myLocationButtonEnabled = false,
+                rotationGesturesEnabled = false,
+                scrollGesturesEnabled = false,
+                tiltGesturesEnabled = false,
+                zoomGesturesEnabled = false,
+            ),
+            cameraPositionState = cameraState,
+        ) {
+            val precisionMeters = precisionBitsToMeters(node.position.precision_bits ?: 0)
+            val latLng = LatLng(node.latitude, node.longitude)
+            if (precisionMeters > 0) {
+                Circle(
+                    center = latLng,
+                    radius = precisionMeters,
+                    fillColor = Color(node.colors.second).copy(alpha = 0.2f),
+                    strokeColor = Color(node.colors.second),
+                    strokeWidth = 2f,
+                )
+            }
+            MarkerComposable(state = rememberUpdatedMarkerState(position = latLng)) { NodeChip(node = node) }
+        }
+    }
+}

app/src/google/kotlin/org/meshtastic/app/node/metrics/TracerouteMapOverlayInsets.kt

@@ -14,21 +14,15 @@
  * 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.app.di
+package org.meshtastic.app.node.metrics
 
-import dagger.Binds
-import dagger.Module
-import dagger.hilt.InstallIn
-import dagger.hilt.components.SingletonComponent
-import org.meshtastic.app.analytics.GooglePlatformAnalytics
-import org.meshtastic.core.repository.PlatformAnalytics
-import javax.inject.Singleton
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.unit.dp
+import org.meshtastic.core.ui.util.TracerouteMapOverlayInsets
 
-/** Hilt module to provide the [GooglePlatformAnalytics] for the google flavor. */
-@Module
-@InstallIn(SingletonComponent::class)
-abstract class GooglePlatformAnalyticsModule {
-
-    @Binds @Singleton
-    abstract fun bindPlatformHelper(googlePlatformHelper: GooglePlatformAnalytics): PlatformAnalytics
-}
+fun getTracerouteMapOverlayInsets(): TracerouteMapOverlayInsets = TracerouteMapOverlayInsets(
+    overlayAlignment = Alignment.BottomCenter,
+    overlayPadding = PaddingValues(bottom = 16.dp),
+    contentHorizontalAlignment = Alignment.CenterHorizontally,
+)