@movexgeo/react-native-movex 0.1.0

package/android/src/main/java/movex/geo/rn/MovexGeoModule.kt

@@ -0,0 +1,500 @@
+package movex.geo.rn
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.ReadableMapKeySetIterator
+import com.facebook.react.bridge.ReadableType
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import movex.geo.BatteryOptimization
+import movex.geo.Endpoints
+import movex.geo.LocationFix
+import movex.geo.MovexGeo
+import movex.geo.MovexGeoError
+import movex.geo.MovexGeoEvent
+import movex.geo.NotificationConfig
+import movex.geo.ProjectInfo
+import movex.geo.TrackingPreset
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.launch
+
+private fun ReadableMap.optString(key: String): String? =
+    if (hasKey(key) && !isNull(key)) getString(key) else null
+
+// Iter 2 — wires the bridge to movex.geo.MovexGeo (the Android SDK
+// singleton). When iter 2/3 stabilise the Codegen toolchain we'll
+// switch this to extend the generated NativeMovexGeoSpec for compile-
+// time type checking; for now the legacy ReactContextBaseJavaModule
+// shape works against both old and new architectures.
+class MovexGeoModule(reactContext: ReactApplicationContext) :
+    ReactContextBaseJavaModule(reactContext) {
+
+    private val ctx: ReactApplicationContext = reactContext
+    private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
+
+    /// Holds the underlying MovexGeo.onEvents subscription. We keep
+    /// one subscription alive whenever any JS listener exists, and
+    /// fan out via DeviceEventEmitter — RN's NativeEventEmitter tears
+    /// down on the JS side based on `addListener` / `removeListeners`
+    /// reference counts.
+    private var nativeSub: MovexGeo.Subscription? = null
+    private var nativeLocationSub: MovexGeo.Subscription? = null
+    private var listenerRefCount: Int = 0
+
+    override fun getName(): String = NAME
+
+    // ---------- configuration ----------
+
+    @ReactMethod
+    fun initialize(publishableKey: String, endpoints: ReadableMap?, promise: Promise) {
+        scope.launch {
+            try {
+                val ep = endpointsFromMap(endpoints)
+                MovexGeo.initialize(ctx.applicationContext, publishableKey, ep)
+                promise.resolve(null)
+            } catch (t: Throwable) {
+                promise.reject(errCode(t), t.message ?: "initialize failed", t)
+            }
+        }
+    }
+
+    @ReactMethod
+    fun setUserId(userId: String?, promise: Promise) {
+        scope.launch {
+            try {
+                MovexGeo.setUserId(userId)
+                promise.resolve(null)
+            } catch (t: Throwable) {
+                promise.reject(errCode(t), t.message ?: "setUserId failed", t)
+            }
+        }
+    }
+
+    @ReactMethod
+    fun getDeviceId(promise: Promise) {
+        scope.launch {
+            try {
+                promise.resolve(MovexGeo.deviceId())
+            } catch (t: Throwable) {
+                promise.reject(errCode(t), t.message ?: "getDeviceId failed", t)
+            }
+        }
+    }
+
+    // ---------- network ----------
+
+    @ReactMethod
+    fun verify(promise: Promise) {
+        scope.launch {
+            try {
+                MovexGeo.verify()
+                    .onSuccess { info -> promise.resolve(projectInfoToMap(info)) }
+                    .onFailure { promise.reject(errCode(it), it.message ?: "verify failed", it) }
+            } catch (t: Throwable) {
+                promise.reject(errCode(t), t.message ?: "verify failed", t)
+            }
+        }
+    }
+
+    @ReactMethod
+    fun trackOnce(lat: Double, lng: Double, accuracyM: Double, promise: Promise) {
+        // Note: Android's MovexGeo.trackOnce() takes no args and uses a
+        // fresh GPS fix from LocationProviderFactory (GMS / HMS / AOSP,
+        // selected at runtime). The lat/lng/accuracyM passed from JS are
+        // ignored on Android; iter 4 aligns the public TS API to match
+        // (drops the args) once iOS also moves to a no-arg +
+        // last-known fallback.
+        scope.launch {
+            try {
+                MovexGeo.trackOnce()
+                    .onSuccess {
+                        // Android's trackOnce returns Result<Unit>. The JS
+                        // layer expects { accepted, nearby_fences }; until
+                        // we surface the underlying response, hand back a
+                        // bare-minimum success shape.
+                        val map = Arguments.createMap()
+                        map.putBoolean("accepted", true)
+                        promise.resolve(map)
+                    }
+                    .onFailure { promise.reject(errCode(it), it.message ?: "trackOnce failed", it) }
+            } catch (t: Throwable) {
+                promise.reject(errCode(t), t.message ?: "trackOnce failed", t)
+            }
+        }
+    }
+
+    // ---------- continuous tracking ----------
+
+    @ReactMethod
+    fun startTracking(preset: String, promise: Promise) {
+        scope.launch {
+            try {
+                MovexGeo.startTracking(presetFrom(preset))
+                promise.resolve(null)
+            } catch (t: Throwable) {
+                promise.reject(errCode(t), t.message ?: "startTracking failed", t)
+            }
+        }
+    }
+
+    @ReactMethod
+    fun stopTracking(promise: Promise) {
+        scope.launch {
+            try {
+                MovexGeo.stopTracking()
+                promise.resolve(null)
+            } catch (t: Throwable) {
+                promise.reject(errCode(t), t.message ?: "stopTracking failed", t)
+            }
+        }
+    }
+
+    /**
+     * Dev-mode override — lowers the per-preset min-distance triggers so
+     * emulator + stationary desk testing emits fixes. Production builds
+     * should leave this off. Forwarded to MovexGeo.setDevMode().
+     */
+    @ReactMethod
+    fun setDevMode(enabled: Boolean, promise: Promise) {
+        scope.launch {
+            try {
+                MovexGeo.setDevMode(enabled)
+                promise.resolve(null)
+            } catch (t: Throwable) {
+                promise.reject(errCode(t), t.message ?: "setDevMode failed", t)
+            }
+        }
+    }
+
+    // ---------- foreground-service notification ----------
+
+    /**
+     * Customise the foreground-service notification (white-label support).
+     * Pass null fields to fall back to SDK defaults. `iconResName` is the
+     * drawable resource NAME (e.g. "ic_stat_tracking") — resolved against
+     * the host app's package so the SDK never has to ship icons.
+     */
+    @ReactMethod
+    fun setNotificationConfig(config: ReadableMap?, promise: Promise) {
+        scope.launch {
+            try {
+                val title = config?.optString("title")
+                val text = config?.optString("text")
+                val channelId = config?.optString("channelId")
+                val channelName = config?.optString("channelName")
+                val iconResName = config?.optString("iconResName")
+                val iconRes = iconResName?.let {
+                    val pkg = ctx.applicationContext.packageName
+                    ctx.applicationContext.resources.getIdentifier(it, "drawable", pkg).takeIf { id -> id != 0 }
+                        ?: ctx.applicationContext.resources.getIdentifier(it, "mipmap", pkg).takeIf { id -> id != 0 }
+                }
+                MovexGeo.setNotificationConfig(
+                    NotificationConfig(
+                        title = title,
+                        text = text,
+                        channelId = channelId,
+                        channelName = channelName,
+                        smallIconRes = iconRes,
+                    )
+                )
+                promise.resolve(null)
+            } catch (t: Throwable) {
+                promise.reject(errCode(t), t.message ?: "setNotificationConfig failed", t)
+            }
+        }
+    }
+
+    // ---------- boot autostart ----------
+
+    @ReactMethod
+    fun setAutostartOnBoot(enabled: Boolean, promise: Promise) {
+        scope.launch {
+            try {
+                MovexGeo.setAutostartOnBoot(enabled)
+                promise.resolve(null)
+            } catch (t: Throwable) {
+                promise.reject(errCode(t), t.message ?: "setAutostartOnBoot failed", t)
+            }
+        }
+    }
+
+    // ---------- battery optimization ----------
+
+    @ReactMethod
+    fun isIgnoringBatteryOptimizations(promise: Promise) {
+        scope.launch {
+            try {
+                promise.resolve(BatteryOptimization.isIgnoringBatteryOptimizations(ctx.applicationContext))
+            } catch (t: Throwable) {
+                promise.reject(errCode(t), t.message ?: "isIgnoringBatteryOptimizations failed", t)
+            }
+        }
+    }
+
+    @ReactMethod
+    fun requestIgnoreBatteryOptimizations(promise: Promise) {
+        scope.launch {
+            try {
+                promise.resolve(BatteryOptimization.requestIgnoreBatteryOptimizations(ctx.applicationContext))
+            } catch (t: Throwable) {
+                promise.reject(errCode(t), t.message ?: "requestIgnoreBatteryOptimizations failed", t)
+            }
+        }
+    }
+
+    @ReactMethod
+    fun hasOemSettings(promise: Promise) {
+        scope.launch {
+            try {
+                promise.resolve(BatteryOptimization.hasOemSettings(ctx.applicationContext))
+            } catch (t: Throwable) {
+                promise.reject(errCode(t), t.message ?: "hasOemSettings failed", t)
+            }
+        }
+    }
+
+    @ReactMethod
+    fun openOemSettings(promise: Promise) {
+        scope.launch {
+            try {
+                promise.resolve(BatteryOptimization.openOemSettings(ctx.applicationContext))
+            } catch (t: Throwable) {
+                promise.reject(errCode(t), t.message ?: "openOemSettings failed", t)
+            }
+        }
+    }
+
+    // ---------- offline buffer ----------
+
+    @ReactMethod
+    fun bufferedCount(promise: Promise) {
+        scope.launch {
+            try {
+                promise.resolve(MovexGeo.bufferedCount())
+            } catch (t: Throwable) {
+                promise.reject(errCode(t), t.message ?: "bufferedCount failed", t)
+            }
+        }
+    }
+
+    @ReactMethod
+    fun drainBuffer(promise: Promise) {
+        scope.launch {
+            try {
+                MovexGeo.drainBuffer()
+                promise.resolve(null)
+            } catch (t: Throwable) {
+                promise.reject(errCode(t), t.message ?: "drainBuffer failed", t)
+            }
+        }
+    }
+
+    @ReactMethod
+    fun close(promise: Promise) {
+        scope.launch {
+            try {
+                detachListenerLocked()
+                detachLocationListenerLocked()
+                MovexGeo.close()
+                promise.resolve(null)
+            } catch (t: Throwable) {
+                promise.reject(errCode(t), t.message ?: "close failed", t)
+            }
+        }
+    }
+
+    // ---------- NativeEventEmitter plumbing ----------
+
+    @ReactMethod
+    fun addListener(eventName: String) {
+        synchronized(this) {
+            listenerRefCount++
+            if (listenerRefCount > 0) {
+                if (nativeSub == null) attachListenerLocked()
+                if (nativeLocationSub == null) attachLocationListenerLocked()
+            }
+        }
+    }
+
+    @ReactMethod
+    fun removeListeners(count: Int) {
+        synchronized(this) {
+            listenerRefCount = (listenerRefCount - count).coerceAtLeast(0)
+            if (listenerRefCount == 0) {
+                detachListenerLocked()
+                detachLocationListenerLocked()
+            }
+        }
+    }
+
+    /// Subscribe to MovexGeo.onEvents and forward each event as a
+    /// one-element array so the JS handler signature `events: Event[]`
+    /// stays stable.
+    private fun attachListenerLocked() {
+        nativeSub = MovexGeo.onEvents { event ->
+            val arr: WritableArray = Arguments.createArray()
+            arr.pushMap(eventToMap(event))
+            // RN 0.65+ bridgeless-safe path. getJSModule(RCTDeviceEventEmitter) is a
+            // no-op stub under the new arch; ctx.emitDeviceEvent routes correctly.
+            ctx.emitDeviceEvent(EVENTS_TOPIC, arr)
+        }
+    }
+
+    private fun detachListenerLocked() {
+        nativeSub?.remove()
+        nativeSub = null
+    }
+
+    /// Subscribe to MovexGeo.onLocations and forward each fix via the
+    /// LOCATIONS_TOPIC. The JS handler receives a single LocationFix dict.
+    private fun attachLocationListenerLocked() {
+        android.util.Log.i("MovexGeoBridge", "attachLocationListenerLocked: subscribing to MovexGeo.onLocations")
+        nativeLocationSub = MovexGeo.onLocations { fix ->
+            try {
+                android.util.Log.i(
+                    "MovexGeoBridge",
+                    "emit($LOCATIONS_TOPIC) lat=${fix.lat} lng=${fix.lng}",
+                )
+                ctx.emitDeviceEvent(LOCATIONS_TOPIC, locationFixToMap(fix))
+                android.util.Log.i("MovexGeoBridge", "emit OK")
+            } catch (t: Throwable) {
+                android.util.Log.e("MovexGeoBridge", "emit FAILED", t)
+            }
+        }
+    }
+
+    private fun detachLocationListenerLocked() {
+        nativeLocationSub?.remove()
+        nativeLocationSub = null
+    }
+
+    // ---------- conversion helpers ----------
+
+    /**
+     * Build an [Endpoints] from a JS object passed across the bridge.
+     *
+     * Supported forms:
+     *   `{ preset: 'production' }`           → [Endpoints.production()]
+     *   `{ preset: 'localDev' }`             → [Endpoints] (loopback defaults)
+     *   `{ ingest: '…', auth: '…', events: '…' }` → explicit URLs
+     *   `{ preset: 'production', events: '…' }` → preset base, events overridden
+     *
+     * Explicit URL fields always override the preset base when both are present.
+     */
+    private fun endpointsFromMap(map: ReadableMap?): Endpoints {
+        if (map == null) return Endpoints()
+
+        // Resolve the preset base first; explicit fields win over it below.
+        val preset = if (map.hasKey("preset") && !map.isNull("preset")) map.getString("preset") else null
+        val base: Endpoints = when (preset?.lowercase()) {
+            "production" -> Endpoints.production()
+            "localdev"   -> Endpoints()
+            else         -> Endpoints() // no preset or unrecognised → loopback defaults
+        }
+
+        val ingest  = if (map.hasKey("ingest")  && !map.isNull("ingest"))  map.getString("ingest")!!  else base.ingest
+        val auth    = if (map.hasKey("auth")     && !map.isNull("auth"))    map.getString("auth")!!    else base.auth
+        val events  = if (map.hasKey("events")   && !map.isNull("events"))  map.getString("events")!!  else base.events
+        val pinnedHosts: Map<String, List<String>> =
+            if (map.hasKey("pinnedHosts") && !map.isNull("pinnedHosts")) {
+                pinnedHostsFromMap(map.getMap("pinnedHosts"))
+            } else base.pinnedHosts
+
+        return Endpoints(ingest = ingest, auth = auth, events = events, pinnedHosts = pinnedHosts)
+    }
+
+    private fun pinnedHostsFromMap(map: ReadableMap?): Map<String, List<String>> {
+        if (map == null) return emptyMap()
+        val out = HashMap<String, List<String>>()
+        val it: ReadableMapKeySetIterator = map.keySetIterator()
+        while (it.hasNextKey()) {
+            val key = it.nextKey()
+            val type = map.getType(key)
+            if (type != ReadableType.Array) continue
+            val arr = map.getArray(key) ?: continue
+            val pins = ArrayList<String>(arr.size())
+            for (i in 0 until arr.size()) {
+                val v = arr.getString(i) ?: continue
+                pins.add(v)
+            }
+            if (pins.isNotEmpty()) out[key] = pins
+        }
+        return out
+    }
+
+    private fun presetFrom(s: String): TrackingPreset = when (s.lowercase()) {
+        "efficient"  -> TrackingPreset.EFFICIENT
+        "responsive" -> TrackingPreset.RESPONSIVE
+        "continuous" -> TrackingPreset.CONTINUOUS
+        else         -> TrackingPreset.RESPONSIVE
+    }
+
+    private fun projectInfoToMap(info: ProjectInfo): WritableMap = Arguments.createMap().apply {
+        putString("project_id", info.projectId)
+        putString("org_id", info.orgId)
+        putString("tier", info.tier)
+        putString("key_type", info.keyType)
+        val scopes: WritableArray = Arguments.createArray()
+        info.scopes.forEach { scopes.pushString(it) }
+        putArray("scopes", scopes)
+        if (info.rateLimitPerMin != 0) putInt("rate_limit_per_min", info.rateLimitPerMin)
+        val features: WritableArray = Arguments.createArray()
+        info.features.forEach { features.pushString(it) }
+        putArray("features", features)
+        putString("data_region", info.dataRegion)
+    }
+
+    private fun eventToMap(e: MovexGeoEvent): WritableMap = Arguments.createMap().apply {
+        putString("event_id", e.eventId)
+        putString("event_type", e.eventType)
+        putString("project_id", e.projectId)
+        putString("device_id", e.deviceId)
+        e.userExternalId?.let { putString("user_external_id", it) }
+        e.geofenceId?.let { putString("geofence_id", it) }
+        if (e.lat != 0.0 || e.lng != 0.0) {
+            putDouble("lat", e.lat)
+            putDouble("lng", e.lng)
+        }
+        if (e.accuracyM != 0.0) putDouble("accuracy_m", e.accuracyM)
+        if (e.confidence != 0) putInt("confidence", e.confidence)
+        putString("ts_event", e.tsEvent)
+        putString("ts_received", e.tsReceived)
+    }
+
+    /// Map MovexGeoError variants to the same string codes the backend
+    /// uses on its 4xx envelopes. Lets JS write `if (err.code ===
+    /// 'invalid_key') ...` regardless of which platform raised it.
+    private fun errCode(t: Throwable): String = when (t) {
+        is MovexGeoError.Auth.Invalid    -> "invalid_key"
+        is MovexGeoError.Auth.Revoked    -> "key_revoked"
+        is MovexGeoError.Auth.Suspended  -> "project_suspended"
+        is MovexGeoError.BadRequest      -> t.code
+        is MovexGeoError.PermissionDenied -> "permission_denied"
+        is MovexGeoError.Network         -> "network_error"
+        else                              -> "internal_error"
+    }
+
+    private fun locationFixToMap(fix: LocationFix): WritableMap = Arguments.createMap().apply {
+        putDouble("lat", fix.lat)
+        putDouble("lng", fix.lng)
+        putDouble("accuracy_m", fix.accuracyM)
+        putString("ts_event", fix.tsEvent)
+        putString("source", fix.source)
+        fix.speedMps?.let  { putDouble("speed_mps", it) }
+        fix.headingDeg?.let { putDouble("heading_deg", it) }
+    }
+
+    companion object {
+        const val NAME = "MovexGeo"
+        const val EVENTS_TOPIC    = "movex.events"
+        const val LOCATIONS_TOPIC = "movex.locations"
+    }
+}

package/android/src/main/java/movex/geo/rn/MovexGeoPackage.kt

@@ -0,0 +1,21 @@
+package movex.geo.rn
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+/**
+ * RN auto-linking entry point. Registered in the consumer app's
+ * generated `MainApplicationReactNativeHost.kt` via the
+ * `react-native-link` flow (RN ≥ 0.60 picks this up automatically).
+ *
+ * No view managers — the SDK is pure native module.
+ */
+class MovexGeoPackage : ReactPackage {
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> =
+        listOf(MovexGeoModule(reactContext))
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> =
+        emptyList()
+}

package/ios/MovexGeoModule.h

@@ -0,0 +1,11 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+
+// Obj-C++ side of the bridge. Subclassing RCTEventEmitter so the
+// `onEvents` long-poll batches can ride the existing
+// NativeEventEmitter pipe; method bodies live in the .mm.
+//
+// The RCT_EXTERN_MODULE forwarding to MovexGeoModule.swift happens in
+// the .mm file — this header is only the consumer-side declaration.
+@interface MovexGeoModule : RCTEventEmitter <RCTBridgeModule>
+@end

package/ios/MovexGeoModule.mm

@@ -0,0 +1,54 @@
+#import "MovexGeoModule.h"
+
+// RCT_EXTERN_MODULE forwards JS calls to the matching method on the
+// generated Swift class (MovexGeoSwiftBridge in Pods-Swift.h). We
+// keep the type+arg signatures minimal — Codegen will generate a
+// stricter spec in iter 2 once the Codegen toolchain is wired into
+// the consumer build.
+@implementation MovexGeoModule
+RCT_EXPORT_MODULE(MovexGeo)
+
++ (BOOL)requiresMainQueueSetup { return NO; }
+
+- (NSArray<NSString *> *)supportedEvents {
+    return @[@"movex.events"];
+}
+
+RCT_EXTERN_METHOD(initialize:(NSString *)publishableKey
+                  endpoints:(NSDictionary *)endpoints
+                  resolver:(RCTPromiseResolveBlock)resolver
+                  rejecter:(RCTPromiseRejectBlock)rejecter)
+
+RCT_EXTERN_METHOD(setUserId:(NSString *)userId
+                  resolver:(RCTPromiseResolveBlock)resolver
+                  rejecter:(RCTPromiseRejectBlock)rejecter)
+
+RCT_EXTERN_METHOD(getDeviceId:(RCTPromiseResolveBlock)resolver
+                  rejecter:(RCTPromiseRejectBlock)rejecter)
+
+RCT_EXTERN_METHOD(verify:(RCTPromiseResolveBlock)resolver
+                  rejecter:(RCTPromiseRejectBlock)rejecter)
+
+RCT_EXTERN_METHOD(trackOnce:(double)lat
+                  lng:(double)lng
+                  accuracyM:(double)accuracyM
+                  resolver:(RCTPromiseResolveBlock)resolver
+                  rejecter:(RCTPromiseRejectBlock)rejecter)
+
+RCT_EXTERN_METHOD(startTracking:(NSString *)preset
+                  resolver:(RCTPromiseResolveBlock)resolver
+                  rejecter:(RCTPromiseRejectBlock)rejecter)
+
+RCT_EXTERN_METHOD(stopTracking:(RCTPromiseResolveBlock)resolver
+                  rejecter:(RCTPromiseRejectBlock)rejecter)
+
+RCT_EXTERN_METHOD(bufferedCount:(RCTPromiseResolveBlock)resolver
+                  rejecter:(RCTPromiseRejectBlock)rejecter)
+
+RCT_EXTERN_METHOD(drainBuffer:(RCTPromiseResolveBlock)resolver
+                  rejecter:(RCTPromiseRejectBlock)rejecter)
+
+RCT_EXTERN_METHOD(close:(RCTPromiseResolveBlock)resolver
+                  rejecter:(RCTPromiseRejectBlock)rejecter)
+
+@end