feat: network module (#1905)

app/src/main/java/com/geeksville/mesh/repository/api/DeviceHardwareJsonDataSource.kt

@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2025 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 com.geeksville.mesh.repository.api
+
+import android.app.Application
+import com.geeksville.mesh.network.model.NetworkDeviceHardware
+import kotlinx.serialization.ExperimentalSerializationApi
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.decodeFromStream
+import javax.inject.Inject
+
+class DeviceHardwareJsonDataSource @Inject constructor(
+    private val application: Application,
+) {
+    @OptIn(ExperimentalSerializationApi::class)
+    fun loadDeviceHardwareFromJsonAsset(): List<NetworkDeviceHardware> {
+        val inputStream = application.assets.open("device_hardware.json")
+        return Json.decodeFromStream<List<NetworkDeviceHardware>>(inputStream)
+    }
+}

app/src/main/java/com/geeksville/mesh/repository/api/DeviceHardwareLocalDataSource.kt

@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2025 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 com.geeksville.mesh.repository.api
+
+import com.geeksville.mesh.database.dao.DeviceHardwareDao
+import com.geeksville.mesh.database.entity.DeviceHardwareEntity
+import com.geeksville.mesh.database.entity.asEntity
+import com.geeksville.mesh.network.model.NetworkDeviceHardware
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import javax.inject.Inject
+
+class DeviceHardwareLocalDataSource @Inject constructor(
+    private val deviceHardwareDaoLazy: dagger.Lazy<DeviceHardwareDao>
+) {
+    private val deviceHardwareDao by lazy {
+        deviceHardwareDaoLazy.get()
+    }
+
+    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 getByHwModel(hwModel: Int): DeviceHardwareEntity? = withContext(Dispatchers.IO) {
+        deviceHardwareDao.getByHwModel(hwModel)
+    }
+}

app/src/main/java/com/geeksville/mesh/repository/api/DeviceHardwareRepository.kt

@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) 2025 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 com.geeksville.mesh.repository.api
+
+import com.geeksville.mesh.android.BuildUtils.debug
+import com.geeksville.mesh.android.BuildUtils.warn
+import com.geeksville.mesh.database.entity.asExternalModel
+import com.geeksville.mesh.model.DeviceHardware
+import com.geeksville.mesh.network.DeviceHardwareRemoteDataSource
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import java.io.IOException
+import javax.inject.Inject
+
+class DeviceHardwareRepository @Inject constructor(
+    private val apiDataSource: DeviceHardwareRemoteDataSource,
+    private val localDataSource: DeviceHardwareLocalDataSource,
+    private val jsonDataSource: DeviceHardwareJsonDataSource,
+) {
+
+    companion object {
+        // 1 day
+        private const val CACHE_EXPIRATION_TIME_MS = 24 * 60 * 60 * 1000L
+    }
+
+    suspend fun getDeviceHardwareByModel(hwModel: Int, refresh: Boolean = false): DeviceHardware? {
+        return withContext(Dispatchers.IO) {
+            if (refresh) {
+                invalidateCache()
+            } else {
+                val cachedHardware = localDataSource.getByHwModel(hwModel)
+                if (cachedHardware != null && !isCacheExpired(cachedHardware.lastUpdated)) {
+                    debug("Using recent cached device hardware")
+                    val externalModel = cachedHardware.asExternalModel()
+                    return@withContext externalModel
+                }
+            }
+            try {
+                debug("Fetching device hardware from server")
+                localDataSource.insertAllDeviceHardware(apiDataSource.getAllDeviceHardware())
+                val cachedHardware = localDataSource.getByHwModel(hwModel)
+                val externalModel = cachedHardware?.asExternalModel()
+                return@withContext externalModel
+            } catch (e: IOException) {
+                warn("Failed to fetch device hardware from server: ${e.message}")
+                var cachedHardware = localDataSource.getByHwModel(hwModel)
+                if (cachedHardware != null) {
+                    debug("Using stale cached device hardware")
+                    return@withContext cachedHardware.asExternalModel()
+                }
+                debug("Loading and caching device hardware from local JSON asset")
+                localDataSource.insertAllDeviceHardware(jsonDataSource.loadDeviceHardwareFromJsonAsset())
+                cachedHardware = localDataSource.getByHwModel(hwModel)
+                val externalModel = cachedHardware?.asExternalModel()
+                return@withContext externalModel
+            }
+        }
+    }
+
+    suspend fun invalidateCache() {
+        localDataSource.deleteAllDeviceHardware()
+    }
+
+    /**
+     * Check if the cache is expired
+     */
+    private fun isCacheExpired(lastUpdated: Long): Boolean {
+        return System.currentTimeMillis() - lastUpdated > CACHE_EXPIRATION_TIME_MS
+    }
+}

app/src/main/java/com/geeksville/mesh/repository/api/FirmwareReleaseJsonDataSource.kt

@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2025 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 com.geeksville.mesh.repository.api
+
+import android.app.Application
+import com.geeksville.mesh.network.model.NetworkFirmwareReleases
+import kotlinx.serialization.ExperimentalSerializationApi
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.decodeFromStream
+import javax.inject.Inject
+
+class FirmwareReleaseJsonDataSource @Inject constructor(
+    private val application: Application,
+) {
+    @OptIn(ExperimentalSerializationApi::class)
+    fun loadFirmwareReleaseFromJsonAsset(): NetworkFirmwareReleases {
+        val inputStream = application.assets.open("firmware_releases.json")
+        val result = inputStream.use {
+            Json.decodeFromStream<NetworkFirmwareReleases>(inputStream)
+        }
+        return result
+    }
+}

app/src/main/java/com/geeksville/mesh/repository/api/FirmwareReleaseLocalDataSource.kt

@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2025 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 com.geeksville.mesh.repository.api
+
+import com.geeksville.mesh.database.dao.FirmwareReleaseDao
+import com.geeksville.mesh.database.entity.FirmwareReleaseEntity
+import com.geeksville.mesh.database.entity.FirmwareReleaseType
+import com.geeksville.mesh.database.entity.asEntity
+import com.geeksville.mesh.network.model.NetworkFirmwareRelease
+import dagger.Lazy
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import javax.inject.Inject
+
+class FirmwareReleaseLocalDataSource @Inject constructor(
+    private val firmwareReleaseDaoLazy: Lazy<FirmwareReleaseDao>
+) {
+    private val firmwareReleaseDao by lazy {
+        firmwareReleaseDaoLazy.get()
+    }
+
+    suspend fun insertFirmwareReleases(
+        firmwareReleases: List<NetworkFirmwareRelease>,
+        releaseType: FirmwareReleaseType
+    ) =
+        withContext(Dispatchers.IO) {
+            firmwareReleases.forEach { firmwareRelease ->
+                firmwareReleaseDao.insert(firmwareRelease.asEntity(releaseType))
+            }
+        }
+
+    suspend fun deleteAllFirmwareReleases() = withContext(Dispatchers.IO) {
+        firmwareReleaseDao.deleteAll()
+    }
+
+    suspend fun getLatestRelease(releaseType: FirmwareReleaseType): FirmwareReleaseEntity? =
+        withContext(Dispatchers.IO) {
+            val releases = firmwareReleaseDao.getReleasesByType(releaseType)
+            val latestRelease =
+                releases?.firstOrNull()
+            return@withContext latestRelease
+        }
+}

app/src/main/java/com/geeksville/mesh/repository/api/FirmwareReleaseRepository.kt

@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) 2025 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 com.geeksville.mesh.repository.api
+
+import com.geeksville.mesh.android.BuildUtils.debug
+import com.geeksville.mesh.android.BuildUtils.warn
+import com.geeksville.mesh.database.entity.FirmwareRelease
+import com.geeksville.mesh.database.entity.FirmwareReleaseType
+import com.geeksville.mesh.database.entity.asExternalModel
+import com.geeksville.mesh.network.FirmwareReleaseRemoteDataSource
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.flow
+import java.io.IOException
+import javax.inject.Inject
+
+class FirmwareReleaseRepository @Inject constructor(
+    private val apiDataSource: FirmwareReleaseRemoteDataSource,
+    private val localDataSource: FirmwareReleaseLocalDataSource,
+    private val jsonDataSource: FirmwareReleaseJsonDataSource,
+) {
+
+    companion object {
+        // 1 hour
+        private const val CACHE_EXPIRATION_TIME_MS = 60 * 60 * 1000L
+    }
+
+    val stableRelease: Flow<FirmwareRelease?> = getLatestFirmware(FirmwareReleaseType.STABLE)
+
+    val alphaRelease: Flow<FirmwareRelease?> = getLatestFirmware(FirmwareReleaseType.ALPHA)
+
+    private fun getLatestFirmware(
+        releaseType: FirmwareReleaseType,
+        refresh: Boolean = false
+    ): Flow<FirmwareRelease?> = flow {
+        if (refresh) {
+            invalidateCache()
+        } else {
+            val cachedRelease = localDataSource.getLatestRelease(releaseType)
+            if (cachedRelease != null && !isCacheExpired(cachedRelease.lastUpdated)) {
+                debug("Using recent cached firmware release")
+                val externalModel = cachedRelease.asExternalModel()
+                emit(externalModel)
+                return@flow
+            }
+        }
+        try {
+            debug("Fetching firmware releases from server")
+            val networkFirmwareReleases = apiDataSource.getFirmwareReleases()
+            val releases = when (releaseType) {
+                FirmwareReleaseType.STABLE -> networkFirmwareReleases.releases.stable
+                FirmwareReleaseType.ALPHA -> networkFirmwareReleases.releases.alpha
+            }
+            localDataSource.insertFirmwareReleases(
+                releases,
+                releaseType
+            )
+            val cachedRelease = localDataSource.getLatestRelease(releaseType)
+            val externalModel = cachedRelease?.asExternalModel()
+            emit(externalModel)
+        } catch (e: IOException) {
+            warn("Failed to fetch firmware releases from server: ${e.message}")
+            val jsonFirmwareReleases = jsonDataSource.loadFirmwareReleaseFromJsonAsset()
+            val releases = when (releaseType) {
+                FirmwareReleaseType.STABLE -> jsonFirmwareReleases.releases.stable
+                FirmwareReleaseType.ALPHA -> jsonFirmwareReleases.releases.alpha
+            }
+            localDataSource.insertFirmwareReleases(
+                releases,
+                releaseType
+            )
+            val cachedRelease = localDataSource.getLatestRelease(releaseType)
+            val externalModel = cachedRelease?.asExternalModel()
+            emit(externalModel)
+        }
+    }
+
+    suspend fun invalidateCache() {
+        localDataSource.deleteAllFirmwareReleases()
+    }
+
+    /**
+     * Check if the cache is expired
+     */
+    private fun isCacheExpired(lastUpdated: Long): Boolean {
+        return System.currentTimeMillis() - lastUpdated > CACHE_EXPIRATION_TIME_MS
+    }
+}