@mapvina-com/mapvina-react-native 1.0.0

package/android/src/main/java/io/github/mapvina/reactnative/modules/MLRNOfflineModule.kt

@@ -0,0 +1,661 @@
+package io.github.mapvina.reactnative.modules
+
+import android.content.Context
+import android.os.Handler
+import android.os.Looper
+import android.util.Log
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.bridge.WritableNativeMap
+import org.json.JSONException
+import org.json.JSONObject
+import io.github.mapvina.android.geometry.LatLngBounds
+import io.github.mapvina.android.offline.OfflineManager
+import io.github.mapvina.android.offline.OfflineRegion
+import io.github.mapvina.android.offline.OfflineRegionError
+import io.github.mapvina.android.offline.OfflineRegionStatus
+import io.github.mapvina.android.offline.OfflineTilePyramidRegionDefinition
+import io.github.mapvina.android.storage.FileSource
+import io.github.mapvina.reactnative.NativeOfflineModuleSpec
+import io.github.mapvina.reactnative.utils.GeoJSONUtils
+import java.util.UUID
+
+class MLRNOfflineModule(
+    reactContext: ReactApplicationContext,
+) : NativeOfflineModuleSpec(reactContext) {
+    companion object {
+        const val NAME = "MLRNOfflineModule"
+
+        const val MIGRATION_KEY = "migrationVersion"
+        const val MIGRATION_VERSION = 1
+    }
+
+    private val context: Context = reactContext.applicationContext
+    private var progressEventThrottle = 300.0
+
+    private val regions = HashMap<String, OfflineRegion>()
+
+    override fun initialize() {
+        Handler(Looper.getMainLooper()).post {
+            runMigrations()
+        }
+    }
+
+    override fun getName(): String = NAME
+
+    override fun createPack(
+        options: ReadableMap,
+        promise: Promise,
+    ) {
+        val offlineManager = OfflineManager.getInstance(context)
+
+        val packId = UUID.randomUUID().toString()
+        val latLngBounds = getBoundsFromOptions(options)
+        val definition = makeDefinition(latLngBounds, options)
+
+        val metadataJson = JSONObject()
+        metadataJson.put(MIGRATION_KEY, MIGRATION_VERSION)
+        metadataJson.put("id", packId)
+
+        val metadataString = options.getString("metadata")
+        if (metadataString != null && metadataString.isNotEmpty()) {
+            metadataJson.put("metadata", metadataString)
+        } else {
+            metadataJson.put("metadata", "{}")
+        }
+
+        val metadataBytes = metadataJson.toString().toByteArray(Charsets.UTF_8)
+
+        offlineManager.createOfflineRegion(
+            definition,
+            metadataBytes,
+            object : OfflineManager.CreateOfflineRegionCallback {
+                override fun onCreate(offlineRegion: OfflineRegion) {
+                    regions[packId] = offlineRegion
+                    val pack = fromOfflineRegion(offlineRegion)
+                    promise.resolve(pack)
+                    setOfflineRegionObserver(packId, offlineRegion)
+                }
+
+                override fun onError(error: String) {
+                    promise.reject("createPack", error)
+                    emitOnError(makeErrorPayload(packId, error))
+                    Log.e(NAME, "createPack error: $error")
+                }
+            },
+        )
+    }
+
+    override fun getPacks(promise: Promise) {
+        activateFileSource()
+
+        val offlineManager = OfflineManager.getInstance(context)
+
+        offlineManager.listOfflineRegions(
+            object : OfflineManager.ListOfflineRegionsCallback {
+                override fun onList(offlineRegions: Array<OfflineRegion>?) {
+                    val payload = Arguments.createArray()
+                    offlineRegions?.forEach { region ->
+                        payload.pushMap(fromOfflineRegion(region))
+                    }
+                    promise.resolve(payload)
+                }
+
+                override fun onError(error: String) {
+                    promise.reject("getRegions", error)
+                }
+            },
+        )
+    }
+
+    override fun invalidateAmbientCache(promise: Promise) {
+        activateFileSource()
+        val offlineManager = OfflineManager.getInstance(context)
+        offlineManager.invalidateAmbientCache(
+            object : OfflineManager.FileSourceCallback {
+                override fun onSuccess() {
+                    promise.resolve(null)
+                }
+
+                override fun onError(message: String) {
+                    promise.reject("invalidateAmbientCache", message)
+                }
+            },
+        )
+    }
+
+    override fun clearAmbientCache(promise: Promise) {
+        activateFileSource()
+        val offlineManager = OfflineManager.getInstance(context)
+        offlineManager.clearAmbientCache(
+            object : OfflineManager.FileSourceCallback {
+                override fun onSuccess() {
+                    promise.resolve(null)
+                }
+
+                override fun onError(message: String) {
+                    promise.reject("clearAmbientCache", message)
+                }
+            },
+        )
+    }
+
+    override fun setMaximumAmbientCacheSize(
+        size: Double,
+        promise: Promise,
+    ) {
+        activateFileSource()
+        val offlineManager = OfflineManager.getInstance(context)
+        offlineManager.setMaximumAmbientCacheSize(
+            size.toLong(),
+            object : OfflineManager.FileSourceCallback {
+                override fun onSuccess() {
+                    promise.resolve(null)
+                }
+
+                override fun onError(message: String) {
+                    promise.reject("setMaximumAmbientCacheSize", message)
+                }
+            },
+        )
+    }
+
+    override fun resetDatabase(promise: Promise) {
+        activateFileSource()
+        val offlineManager = OfflineManager.getInstance(context)
+        offlineManager.resetDatabase(
+            object : OfflineManager.FileSourceCallback {
+                override fun onSuccess() {
+                    clearRegions()
+                    promise.resolve(null)
+                }
+
+                override fun onError(message: String) {
+                    promise.reject("resetDatabase", message)
+                }
+            },
+        )
+    }
+
+    override fun getPackStatus(
+        id: String,
+        promise: Promise,
+    ) {
+        activateFileSource()
+        val offlineManager = OfflineManager.getInstance(context)
+
+        offlineManager.listOfflineRegions(
+            object : OfflineManager.ListOfflineRegionsCallback {
+                override fun onList(offlineRegions: Array<OfflineRegion>?) {
+                    val region = getRegionById(id, offlineRegions)
+
+                    if (region == null) {
+                        promise.resolve(null)
+                        Log.w(NAME, "getPackStatus - Unknown offline region")
+                        return
+                    }
+
+                    region.getStatus(
+                        object : OfflineRegion.OfflineRegionStatusCallback {
+                            override fun onStatus(status: OfflineRegionStatus?) {
+                                if (status != null) {
+                                    promise.resolve(makeRegionStatus(id, status))
+                                } else {
+                                    promise.reject("getPackStatus", "Status is null")
+                                }
+                            }
+
+                            override fun onError(error: String?) {
+                                promise.reject("getPackStatus", error ?: "Unknown error")
+                            }
+                        },
+                    )
+                }
+
+                override fun onError(error: String) {
+                    promise.reject("getPackStatus", error)
+                }
+            },
+        )
+    }
+
+    override fun setPackObserver(
+        id: String,
+        promise: Promise,
+    ) {
+        activateFileSource()
+        val offlineManager = OfflineManager.getInstance(context)
+
+        offlineManager.listOfflineRegions(
+            object : OfflineManager.ListOfflineRegionsCallback {
+                override fun onList(offlineRegions: Array<OfflineRegion>?) {
+                    val region = getRegionById(id, offlineRegions)
+                    val hasRegion = region != null
+
+                    if (hasRegion) {
+                        regions[id] = region
+                        setOfflineRegionObserver(id, region)
+                    }
+
+                    promise.resolve(hasRegion)
+                }
+
+                override fun onError(error: String) {
+                    promise.reject("setPackObserver", error)
+                }
+            },
+        )
+    }
+
+    override fun invalidatePack(
+        id: String,
+        promise: Promise,
+    ) {
+        activateFileSource()
+        val offlineManager = OfflineManager.getInstance(context)
+
+        offlineManager.listOfflineRegions(
+            object : OfflineManager.ListOfflineRegionsCallback {
+                override fun onList(offlineRegions: Array<OfflineRegion>?) {
+                    val region = regions[id] ?: getRegionById(id, offlineRegions)
+
+                    if (region == null) {
+                        promise.resolve(null)
+                        Log.w(NAME, "invalidateRegion - Unknown offline region")
+                        return
+                    }
+
+                    region.invalidate(
+                        object : OfflineRegion.OfflineRegionInvalidateCallback {
+                            override fun onInvalidate() {
+                                promise.resolve(null)
+                            }
+
+                            override fun onError(error: String) {
+                                promise.reject("invalidateRegion", error)
+                            }
+                        },
+                    )
+                }
+
+                override fun onError(error: String) {
+                    promise.reject("invalidateRegion", error)
+                }
+            },
+        )
+    }
+
+    override fun deletePack(
+        id: String,
+        promise: Promise,
+    ) {
+        activateFileSource()
+        val offlineManager = OfflineManager.getInstance(context)
+
+        offlineManager.listOfflineRegions(
+            object : OfflineManager.ListOfflineRegionsCallback {
+                override fun onList(offlineRegions: Array<OfflineRegion>?) {
+                    val region = regions[id] ?: getRegionById(id, offlineRegions)
+
+                    if (region == null) {
+                        promise.resolve(null)
+                        Log.w(NAME, "deleteRegion - Unknown offline region")
+                        return
+                    }
+
+                    region.setDownloadState(OfflineRegion.STATE_INACTIVE)
+                    region.delete(
+                        object : OfflineRegion.OfflineRegionDeleteCallback {
+                            override fun onDelete() {
+                                regions.remove(id)
+                                promise.resolve(null)
+                            }
+
+                            override fun onError(error: String) {
+                                promise.reject("deleteRegion", error)
+                            }
+                        },
+                    )
+                }
+
+                override fun onError(error: String) {
+                    promise.reject("deleteRegion", error)
+                }
+            },
+        )
+    }
+
+    override fun pausePackDownload(
+        id: String,
+        promise: Promise,
+    ) {
+        activateFileSource()
+        val offlineManager = OfflineManager.getInstance(context)
+
+        offlineManager.listOfflineRegions(
+            object : OfflineManager.ListOfflineRegionsCallback {
+                override fun onList(offlineRegions: Array<OfflineRegion>?) {
+                    val offlineRegion = regions[id] ?: getRegionById(id, offlineRegions)
+
+                    if (offlineRegion == null) {
+                        promise.reject("pauseRegionDownload", "Unknown offline region")
+                        return
+                    }
+
+                    Handler(Looper.getMainLooper()).post {
+                        offlineRegion.setDownloadState(OfflineRegion.STATE_INACTIVE)
+                        promise.resolve(null)
+                    }
+                }
+
+                override fun onError(error: String) {
+                    promise.reject("pauseRegionDownload", error)
+                }
+            },
+        )
+    }
+
+    override fun resumePackDownload(
+        id: String,
+        promise: Promise,
+    ) {
+        activateFileSource()
+        val offlineManager = OfflineManager.getInstance(context)
+
+        offlineManager.listOfflineRegions(
+            object : OfflineManager.ListOfflineRegionsCallback {
+                override fun onList(offlineRegions: Array<OfflineRegion>?) {
+                    val offlineRegion =
+                        regions[id] ?: getRegionById(id, offlineRegions)?.also { regions[id] = it }
+
+                    if (offlineRegion == null) {
+                        promise.reject("resumeRegionDownload", "Unknown offline region")
+                        return
+                    }
+
+                    offlineRegion.setDownloadState(OfflineRegion.STATE_ACTIVE)
+                    promise.resolve(null)
+                }
+
+                override fun onError(error: String) {
+                    promise.reject("resumeRegionDownload", error)
+                }
+            },
+        )
+    }
+
+    override fun mergeOfflineRegions(
+        path: String,
+        promise: Promise,
+    ) {
+        activateFileSource()
+        val offlineManager = OfflineManager.getInstance(context)
+
+        offlineManager.mergeOfflineRegions(
+            path,
+            object : OfflineManager.MergeOfflineRegionsCallback {
+                override fun onMerge(offlineRegions: Array<OfflineRegion>?) {
+                    promise.resolve(null)
+                }
+
+                override fun onError(error: String) {
+                    promise.reject("mergeOfflineRegions", error)
+                }
+            },
+        )
+    }
+
+    override fun setTileCountLimit(limit: Double) {
+        val offlineManager = OfflineManager.getInstance(context)
+        offlineManager.setOfflineMapboxTileCountLimit(limit.toLong())
+    }
+
+    override fun setProgressEventThrottle(throttleValue: Double) {
+        progressEventThrottle = throttleValue
+    }
+
+    private fun makeDefinition(
+        latLngBounds: LatLngBounds,
+        options: ReadableMap,
+    ): OfflineTilePyramidRegionDefinition =
+        OfflineTilePyramidRegionDefinition(
+            options.getString("mapStyle"),
+            latLngBounds,
+            options.getDouble("minZoom"),
+            options.getDouble("maxZoom"),
+            context.resources.displayMetrics.density,
+        )
+
+    private fun parseRegionMetadata(region: OfflineRegion): JSONObject =
+        try {
+            JSONObject(String(region.metadata))
+        } catch (e: JSONException) {
+            Log.w(NAME, "Failed to parse pack metadata: ${e.localizedMessage}")
+            JSONObject()
+        }
+
+    private fun runMigrations() {
+        activateFileSource()
+        val offlineManager = OfflineManager.getInstance(context)
+
+        offlineManager.listOfflineRegions(
+            object : OfflineManager.ListOfflineRegionsCallback {
+                override fun onList(offlineRegions: Array<OfflineRegion>?) {
+                    if (offlineRegions == null) {
+                        Log.e(NAME, "No packs found for migration")
+
+                        return
+                    }
+
+                    val regionsToMigrate = mutableListOf<OfflineRegion>()
+                    for (region in offlineRegions) {
+                        val metadata = parseRegionMetadata(region)
+                        if (!metadata.has(MIGRATION_KEY) || metadata.getInt(MIGRATION_KEY) != MIGRATION_VERSION) {
+                            regionsToMigrate.add(region)
+                        }
+                    }
+
+                    if (regionsToMigrate.isEmpty()) {
+                        Log.d(NAME, "No packs need migration")
+
+                        return
+                    }
+
+                    Log.d(NAME, "Migrating ${regionsToMigrate.size} pack(s)")
+
+                    for (region in regionsToMigrate) {
+                        migrateRegion(region)
+                    }
+                }
+
+                override fun onError(error: String) {
+                    Log.e(NAME, "Failed to list packs for migration: $error")
+                }
+            },
+        )
+    }
+
+    private fun migrateRegion(region: OfflineRegion) {
+        val oldMetadata = parseRegionMetadata(region)
+
+        val newMetadata = JSONObject()
+        newMetadata.put(MIGRATION_KEY, MIGRATION_VERSION)
+        newMetadata.put("id", UUID.randomUUID().toString())
+        newMetadata.put("metadata", oldMetadata.toString())
+
+        region.updateMetadata(
+            newMetadata.toString().toByteArray(Charsets.UTF_8),
+            object : OfflineRegion.OfflineRegionUpdateMetadataCallback {
+                override fun onUpdate(metadata: ByteArray) {
+                    val id = newMetadata.optString("id", "unknown")
+                    Log.d(NAME, "Successfully migrated pack: $id")
+                }
+
+                override fun onError(error: String) {
+                    Log.e(NAME, "Failed to migrate pack: $error")
+                }
+            },
+        )
+    }
+
+    private fun setOfflineRegionObserver(
+        id: String,
+        region: OfflineRegion,
+    ) {
+        region.setObserver(
+            object : OfflineRegion.OfflineRegionObserver {
+                var prevStatus: OfflineRegionStatus? = null
+                var timestamp = System.currentTimeMillis()
+
+                override fun onStatusChanged(status: OfflineRegionStatus) {
+                    if (shouldSendUpdate(System.currentTimeMillis(), status)) {
+                        emitOnProgress(makeRegionStatus(id, status))
+                        timestamp = System.currentTimeMillis()
+                    }
+                    prevStatus = status
+                }
+
+                override fun onError(error: OfflineRegionError) {
+                    emitOnError(makeErrorPayload(id, error.message))
+                }
+
+                override fun mapboxTileCountLimitExceeded(limit: Long) {
+                    val message = "Mapbox tile limit exceeded $limit"
+                    emitOnError(makeErrorPayload(id, message))
+                }
+
+                private fun shouldSendUpdate(
+                    currentTimestamp: Long,
+                    curStatus: OfflineRegionStatus,
+                ): Boolean {
+                    val prev = prevStatus ?: return false
+
+                    if (prev.downloadState != curStatus.downloadState) {
+                        return true
+                    }
+
+                    if (currentTimestamp - timestamp > progressEventThrottle) {
+                        return true
+                    }
+
+                    return false
+                }
+            },
+        )
+
+        region.setDownloadState(OfflineRegion.STATE_ACTIVE)
+    }
+
+    private fun makeErrorPayload(
+        id: String,
+        message: String,
+    ): WritableMap {
+        val payload = WritableNativeMap()
+        payload.putString("id", id)
+        payload.putString("message", message)
+
+        return payload
+    }
+
+    private fun makeRegionStatus(
+        id: String,
+        status: OfflineRegionStatus,
+    ): WritableMap {
+        val map = Arguments.createMap()
+
+        var state = "inactive"
+        var percentage: Double
+
+        if (status.isComplete) {
+            state = "complete"
+            percentage = 100.0
+        } else {
+            percentage =
+                if (status.requiredResourceCount >= 0) {
+                    100.0 * status.completedResourceCount / status.requiredResourceCount
+                } else {
+                    0.0
+                }
+
+            if (status.downloadState == OfflineRegion.STATE_ACTIVE) {
+                state = "active"
+            }
+        }
+
+        map.putString("id", id)
+        map.putString("state", state)
+        map.putDouble("percentage", percentage)
+        map.putInt("completedResourceCount", status.completedResourceCount.toInt())
+        map.putInt("completedResourceSize", status.completedResourceSize.toInt())
+        map.putInt("completedTileSize", status.completedTileSize.toInt())
+        map.putInt("completedTileCount", status.completedTileCount.toInt())
+        map.putInt("requiredResourceCount", status.requiredResourceCount.toInt())
+
+        return map
+    }
+
+    private fun getBoundsFromOptions(options: ReadableMap): LatLngBounds {
+        val boundsArray = options.getArray("bounds")
+        val bounds =
+            GeoJSONUtils.toLatLngBounds(boundsArray)
+                ?: throw IllegalArgumentException("bounds must be an array of 4 numbers [west, south, east, north]")
+
+        return bounds
+    }
+
+    private fun fromOfflineRegion(region: OfflineRegion): WritableMap {
+        val map = Arguments.createMap()
+
+        val metadata = parseRegionMetadata(region)
+
+        map.putString("id", metadata.optString("id", ""))
+        map.putString("metadata", metadata.optString("metadata", "{}"))
+
+        region.definition.bounds?.let { bounds ->
+            map.putArray("bounds", GeoJSONUtils.fromLatLngBounds(bounds))
+        }
+
+        return map
+    }
+
+    private fun getRegionById(
+        id: String?,
+        offlineRegions: Array<OfflineRegion>?,
+    ): OfflineRegion? {
+        if (id.isNullOrEmpty() || offlineRegions == null) {
+            return null
+        }
+
+        for (region in offlineRegions) {
+            val metadata = parseRegionMetadata(region)
+            if (metadata.has("id") && id == metadata.optString("id")) {
+                return region
+            }
+        }
+
+        return null
+    }
+
+    override fun invalidate() {
+        Handler(Looper.getMainLooper()).post {
+            clearRegions()
+        }
+        super.invalidate()
+    }
+
+    private fun activateFileSource() {
+        val fileSource = FileSource.getInstance(context)
+        fileSource.activate()
+    }
+
+    private fun clearRegions() {
+        for (region in regions.values) {
+            region.setDownloadState(OfflineRegion.STATE_INACTIVE)
+            region.setObserver(null)
+        }
+        regions.clear()
+    }
+}