react-native-background-live-tracking 1.0.0

package/android/src/main/java/com/reactnativebackgroundlivetracking/LocationNetworkClient.kt

@@ -0,0 +1,197 @@
+package com.reactnativebackgroundlivetracking
+
+import android.content.Context
+import android.net.ConnectivityManager
+import android.net.NetworkCapabilities
+import java.net.URI
+import java.util.concurrent.TimeUnit
+import okhttp3.Headers
+import okhttp3.MediaType.Companion.toMediaType
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.RequestBody.Companion.toRequestBody
+import okhttp3.Response
+import okhttp3.WebSocket
+import okhttp3.WebSocketListener
+import org.json.JSONObject
+import io.socket.client.IO
+import io.socket.client.Socket
+
+internal class LocationNetworkClient(
+  private val appContext: Context,
+  private val prefs: TrackingPreferences,
+  private val queue: LocationQueueStore,
+) {
+  private val jsonMedia = "application/json; charset=utf-8".toMediaType()
+  private val client =
+    OkHttpClient.Builder()
+      .connectTimeout(25, TimeUnit.SECONDS)
+      .readTimeout(25, TimeUnit.SECONDS)
+      .writeTimeout(25, TimeUnit.SECONDS)
+      .retryOnConnectionFailure(true)
+      .build()
+
+  @Volatile private var webSocket: WebSocket? = null
+  @Volatile private var socketIo: Socket? = null
+
+  fun connectSocketsIfNeeded() {
+    val url = prefs.socketUrl ?: return
+    when (prefs.socketTransport) {
+      "websocket" -> connectWebSocket(url)
+      "socket.io" -> connectSocketIo(url)
+    }
+  }
+
+  fun disconnectSockets() {
+    try {
+      webSocket?.close(1000, "stop")
+    } catch (_: Exception) {
+    }
+    webSocket = null
+    try {
+      socketIo?.disconnect()
+      socketIo?.off()
+    } catch (_: Exception) {
+    }
+    socketIo = null
+  }
+
+  fun sendLocationJson(jsonBody: String): Boolean {
+    val online = isOnline()
+    if (!online) {
+      queue.enqueue(jsonBody)
+      return false
+    }
+    connectSocketsIfNeeded()
+    val restOk = postRestWithRetry(jsonBody)
+    sendOverRealtime(jsonBody)
+    if (!restOk) {
+      queue.enqueue(jsonBody)
+    }
+    return restOk
+  }
+
+  fun flushQueue(): Int {
+    if (!isOnline()) return 0
+    connectSocketsIfNeeded()
+    return queue.drain { line ->
+      val ok = postRestWithRetry(line)
+      if (ok) {
+        sendOverRealtime(line)
+      }
+      ok
+    }
+  }
+
+  private fun sendOverRealtime(jsonBody: String) {
+    try {
+      webSocket?.send(jsonBody)
+      socketIo?.emit("location", JSONObject(jsonBody))
+    } catch (_: Exception) {
+    }
+  }
+
+  private fun postRestWithRetry(body: String): Boolean {
+    repeat(3) { attempt ->
+      try {
+        if (postRestOnce(body)) return true
+      } catch (_: Exception) {
+      }
+      try {
+        Thread.sleep((300L * (attempt + 1)).coerceAtMost(2000L))
+      } catch (_: InterruptedException) {
+        return false
+      }
+    }
+    return false
+  }
+
+  private fun postRestOnce(body: String): Boolean {
+    val url = prefs.serverUrl
+    if (url.isBlank()) return false
+    val headersBuilder = Headers.Builder()
+    try {
+      val headersJson = JSONObject(prefs.restHeadersJson)
+      val keys = headersJson.keys()
+      while (keys.hasNext()) {
+        val k = keys.next()
+        headersBuilder.add(k, headersJson.optString(k))
+      }
+    } catch (_: Exception) {
+    }
+    val request =
+      Request.Builder()
+        .url(url)
+        .headers(headersBuilder.build())
+        .post(body.toRequestBody(jsonMedia))
+        .build()
+    client.newCall(request).execute().use { response ->
+      return response.isSuccessful
+    }
+  }
+
+  private fun connectWebSocket(rawUrl: String) {
+    if (webSocket != null) return
+    val wsUrl =
+      when {
+        rawUrl.startsWith("https://") -> "wss://" + rawUrl.removePrefix("https://")
+        rawUrl.startsWith("http://") -> "ws://" + rawUrl.removePrefix("http://")
+        else -> rawUrl
+      }
+    val request = Request.Builder().url(wsUrl).build()
+    webSocket =
+      client.newWebSocket(
+        request,
+        object : WebSocketListener() {
+          override fun onFailure(
+            webSocket: WebSocket,
+            t: Throwable,
+            response: Response?,
+          ) {
+            this@LocationNetworkClient.webSocket = null
+          }
+
+          override fun onClosed(
+            webSocket: WebSocket,
+            code: Int,
+            reason: String,
+          ) {
+            this@LocationNetworkClient.webSocket = null
+          }
+        },
+      )
+  }
+
+  private fun connectSocketIo(rawUrl: String) {
+    if (socketIo?.connected() == true) return
+    try {
+      socketIo?.disconnect()
+      socketIo?.off()
+    } catch (_: Exception) {
+    }
+    try {
+      val uri = URI.create(toHttpScheme(rawUrl))
+      val opts = IO.Options()
+      opts.reconnection = true
+      socketIo = IO.socket(uri, opts)
+      socketIo?.connect()
+    } catch (_: Exception) {
+      socketIo = null
+    }
+  }
+
+  private fun toHttpScheme(url: String): String {
+    return when {
+      url.startsWith("wss://") -> "https://" + url.removePrefix("wss://")
+      url.startsWith("ws://") -> "http://" + url.removePrefix("ws://")
+      else -> url
+    }
+  }
+
+  private fun isOnline(): Boolean {
+    val cm = appContext.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
+    val network = cm.activeNetwork ?: return false
+    val caps = cm.getNetworkCapabilities(network) ?: return false
+    return caps.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
+  }
+}

package/android/src/main/java/com/reactnativebackgroundlivetracking/LocationQueueStore.kt

@@ -0,0 +1,53 @@
+package com.reactnativebackgroundlivetracking
+
+import android.content.Context
+import java.io.File
+import java.util.concurrent.locks.ReentrantLock
+import kotlin.concurrent.withLock
+
+internal class LocationQueueStore(context: Context) {
+  private val file = File(context.filesDir, "rn_blt_location_queue.jsonl")
+  private val lock = ReentrantLock()
+  private val maxLines = 2000
+
+  fun enqueue(line: String) {
+    lock.withLock {
+      if (!file.exists()) {
+        file.createNewFile()
+      }
+      val lines = file.readLines().toMutableList()
+      lines.add(line)
+      while (lines.size > maxLines) {
+        lines.removeAt(0)
+      }
+      file.writeText(lines.joinToString("\n") + if (lines.isNotEmpty()) "\n" else "")
+    }
+  }
+
+  /**
+   * Attempts to process queued payloads. [processor] returns true if the entry was delivered.
+   */
+  fun drain(processor: (String) -> Boolean): Int {
+    lock.withLock {
+      if (!file.exists() || file.length() == 0L) return 0
+      val lines = file.readLines()
+      if (lines.isEmpty()) return 0
+      val remaining = mutableListOf<String>()
+      var sent = 0
+      for (line in lines) {
+        if (line.isBlank()) continue
+        if (processor(line)) {
+          sent++
+        } else {
+          remaining.add(line)
+        }
+      }
+      if (remaining.isEmpty()) {
+        file.delete()
+      } else {
+        file.writeText(remaining.joinToString("\n") + "\n")
+      }
+      return sent
+    }
+  }
+}

package/android/src/main/java/com/reactnativebackgroundlivetracking/StaticMapFetcher.kt

@@ -0,0 +1,56 @@
+package com.reactnativebackgroundlivetracking
+
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import java.util.concurrent.TimeUnit
+import okhttp3.HttpUrl.Companion.toHttpUrl
+import okhttp3.OkHttpClient
+import okhttp3.Request
+
+/** Fetches a map bitmap via Google Static Maps API (not an interactive MapView). */
+internal object StaticMapFetcher {
+  private val client =
+    OkHttpClient.Builder()
+      .connectTimeout(18, TimeUnit.SECONDS)
+      .readTimeout(18, TimeUnit.SECONDS)
+      .build()
+
+  fun fetch(
+    driverLat: Double,
+    driverLng: Double,
+    pickupLat: Double?,
+    pickupLng: Double?,
+    apiKey: String,
+  ): Bitmap? {
+    if (apiKey.isBlank()) return null
+    val urlBuilder =
+      "https://maps.googleapis.com/maps/api/staticmap".toHttpUrl().newBuilder()
+        .addQueryParameter("center", "$driverLat,$driverLng")
+        .addQueryParameter("zoom", "15")
+        .addQueryParameter("size", "480x240")
+        .addQueryParameter("scale", "2")
+        .addQueryParameter("maptype", "roadmap")
+        .addQueryParameter(
+          "markers",
+          "color:0x4285F4|size:mid|$driverLat,$driverLng",
+        )
+        .addQueryParameter("key", apiKey)
+
+    if (pickupLat != null && pickupLng != null) {
+      urlBuilder.addQueryParameter(
+        "markers",
+        "color:0x0F9D58|label:P|size:mid|$pickupLat,$pickupLng",
+      )
+    }
+
+    val request = Request.Builder().url(urlBuilder.build()).get().build()
+    return try {
+      client.newCall(request).execute().use { response ->
+        if (!response.isSuccessful) return null
+        response.body?.byteStream()?.use { BitmapFactory.decodeStream(it) }
+      }
+    } catch (_: Exception) {
+      null
+    }
+  }
+}

package/android/src/main/java/com/reactnativebackgroundlivetracking/TrackingEventBridge.kt

@@ -0,0 +1,58 @@
+package com.reactnativebackgroundlivetracking
+
+import android.os.Handler
+import android.os.Looper
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.modules.core.DeviceEventManagerModule
+
+internal object TrackingEventBridge {
+  @Volatile
+  var reactContext: ReactApplicationContext? = null
+
+  private val mainHandler = Handler(Looper.getMainLooper())
+
+  fun emitLocation(
+    latitude: Double,
+    longitude: Double,
+    timestamp: Long,
+    driverId: String,
+    accuracy: Float,
+    speed: Float,
+    bearing: Float,
+  ) {
+    val ctx = reactContext ?: return
+    val map =
+      Arguments.createMap().apply {
+        putDouble("latitude", latitude)
+        putDouble("longitude", longitude)
+        putDouble("timestamp", timestamp.toDouble())
+        putString("driverId", driverId)
+        putDouble("accuracy", accuracy.toDouble())
+        putDouble("speed", speed.toDouble())
+        putDouble("bearing", bearing.toDouble())
+      }
+    mainHandler.post {
+      try {
+        ctx
+          .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+          .emit("RNBackgroundLiveTracking_location", map)
+      } catch (_: Exception) {
+        // Bridge may be torn down
+      }
+    }
+  }
+
+  fun emitStatus(active: Boolean) {
+    val ctx = reactContext ?: return
+    val map = Arguments.createMap().apply { putBoolean("active", active) }
+    mainHandler.post {
+      try {
+        ctx
+          .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+          .emit("RNBackgroundLiveTracking_status", map)
+      } catch (_: Exception) {
+      }
+    }
+  }
+}

package/android/src/main/java/com/reactnativebackgroundlivetracking/TrackingModule.kt

@@ -0,0 +1,203 @@
+package com.reactnativebackgroundlivetracking
+
+import android.Manifest
+import android.content.Intent
+import android.content.pm.PackageManager
+import android.net.Uri
+import android.os.Build
+import android.provider.Settings
+import androidx.core.content.ContextCompat
+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.module.annotations.ReactModule
+import org.json.JSONObject
+
+@ReactModule(name = RNBackgroundLiveTrackingModule.NAME)
+class RNBackgroundLiveTrackingModule(
+  private val reactContext: ReactApplicationContext,
+) : ReactContextBaseJavaModule(reactContext) {
+
+  override fun getName(): String = NAME
+
+  override fun initialize() {
+    super.initialize()
+    TrackingEventBridge.reactContext = reactContext
+  }
+
+  override fun invalidate() {
+    TrackingEventBridge.reactContext = null
+    super.invalidate()
+  }
+
+  @ReactMethod
+  fun startTracking(configJson: String, promise: Promise) {
+    try {
+      if (!hasFineLocation()) {
+        promise.reject(
+          "E_PERMISSION",
+          "ACCESS_FINE_LOCATION is required. Request it from JavaScript before starting.",
+        )
+        return
+      }
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q && !hasBackgroundLocation()) {
+        promise.reject(
+          "E_PERMISSION",
+          "ACCESS_BACKGROUND_LOCATION is required for tracking when the app is killed (Android 10+).",
+        )
+        return
+      }
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU && !hasPostNotifications()) {
+        promise.reject(
+          "E_PERMISSION",
+          "POST_NOTIFICATIONS is required to show the foreground service notification (Android 13+).",
+        )
+        return
+      }
+
+      val json = JSONObject(configJson)
+      val driverId = json.getString("driverId")
+      val intervalMs = json.getLong("intervalMs")
+      val serverUrl = json.getString("serverUrl")
+      val socketUrl =
+        when {
+          !json.has("socketUrl") || json.isNull("socketUrl") -> null
+          else -> json.getString("socketUrl").takeIf { it.isNotBlank() }
+        }
+      val socketTransportJs =
+        when {
+          !json.has("socketTransport") || json.isNull("socketTransport") -> null
+          else -> json.getString("socketTransport").takeIf { it.isNotBlank() }
+        }
+      val notificationTitle = json.getString("notificationTitle")
+      val notificationBody = json.getString("notificationBody")
+      val autoStartOnBoot = json.optBoolean("autoStartOnBoot", true)
+      val restHeaders =
+        if (json.has("restHeaders")) json.getJSONObject("restHeaders").toString() else "{}"
+
+      val notificationMapPreview = json.optBoolean("notificationMapPreview", false)
+      val staticMapsApiKey =
+        if (json.has("googleStaticMapsApiKey")) {
+          json.optString("googleStaticMapsApiKey", "")
+        } else {
+          ""
+        }
+
+      val prefs = TrackingPreferences(reactContext)
+      prefs.driverId = driverId
+      prefs.intervalMs = intervalMs.coerceAtLeast(1000L)
+      prefs.serverUrl = serverUrl
+      prefs.socketUrl = socketUrl
+      prefs.socketTransport = resolveTransport(socketUrl, socketTransportJs)
+      prefs.notificationTitle = notificationTitle
+      prefs.notificationBody = notificationBody
+      prefs.autoStartOnBoot = autoStartOnBoot
+      prefs.restHeadersJson = restHeaders
+      prefs.notificationMapPreview = notificationMapPreview
+      prefs.staticMapsApiKey = staticMapsApiKey
+      if (json.has("pickup") && !json.isNull("pickup")) {
+        val pu = json.getJSONObject("pickup")
+        prefs.pickupLatitude = pu.getDouble("latitude")
+        prefs.pickupLongitude = pu.getDouble("longitude")
+        prefs.hasPickup = true
+      } else {
+        prefs.hasPickup = false
+      }
+      prefs.isTrackingActive = true
+
+      LocationForegroundService.start(reactContext.applicationContext)
+      TrackingEventBridge.emitStatus(true)
+      promise.resolve(null)
+    } catch (e: Exception) {
+      promise.reject("E_START", e.message, e)
+    }
+  }
+
+  @ReactMethod
+  fun stopTracking(promise: Promise) {
+    try {
+      val prefs = TrackingPreferences(reactContext)
+      prefs.clearTrackingFlag()
+      LocationForegroundService.stop(reactContext.applicationContext)
+      TrackingEventBridge.emitStatus(false)
+      promise.resolve(null)
+    } catch (e: Exception) {
+      promise.reject("E_STOP", e.message, e)
+    }
+  }
+
+  @ReactMethod
+  fun isTracking(promise: Promise) {
+    promise.resolve(TrackingPreferences(reactContext).isTrackingActive)
+  }
+
+  @ReactMethod
+  fun openBatteryOptimizationSettings(promise: Promise) {
+    try {
+      val intent =
+        Intent(Settings.ACTION_REQUEST_IGNORE_BATTERY_OPTIMIZATIONS).apply {
+          data = Uri.parse("package:${reactContext.packageName}")
+          addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+        }
+      reactContext.startActivity(intent)
+      promise.resolve(null)
+    } catch (e: Exception) {
+      try {
+        val fallback =
+          Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS).apply {
+            data = Uri.fromParts("package", reactContext.packageName, null)
+            addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+          }
+        reactContext.startActivity(fallback)
+        promise.resolve(null)
+      } catch (e2: Exception) {
+        promise.reject("E_BATTERY", e2.message, e2)
+      }
+    }
+  }
+
+  private fun resolveTransport(socketUrl: String?, jsTransport: String?): String {
+    if (socketUrl.isNullOrBlank()) return "rest"
+    if (!jsTransport.isNullOrBlank()) {
+      return when (jsTransport.lowercase()) {
+        "socket.io" -> "socket.io"
+        "websocket" -> "websocket"
+        else -> "websocket"
+      }
+    }
+    return if (
+      socketUrl.contains("/socket.io", ignoreCase = true) ||
+        socketUrl.contains("socket.io", ignoreCase = true)
+    ) {
+      "socket.io"
+    } else {
+      "websocket"
+    }
+  }
+
+  private fun hasFineLocation(): Boolean {
+    return ContextCompat.checkSelfPermission(
+      reactContext,
+      Manifest.permission.ACCESS_FINE_LOCATION,
+    ) == PackageManager.PERMISSION_GRANTED
+  }
+
+  private fun hasBackgroundLocation(): Boolean {
+    return ContextCompat.checkSelfPermission(
+      reactContext,
+      Manifest.permission.ACCESS_BACKGROUND_LOCATION,
+    ) == PackageManager.PERMISSION_GRANTED
+  }
+
+  private fun hasPostNotifications(): Boolean {
+    return ContextCompat.checkSelfPermission(
+      reactContext,
+      Manifest.permission.POST_NOTIFICATIONS,
+    ) == PackageManager.PERMISSION_GRANTED
+  }
+
+  companion object {
+    const val NAME = "RNBackgroundLiveTracking"
+  }
+}

package/android/src/main/java/com/reactnativebackgroundlivetracking/TrackingPackage.kt

@@ -0,0 +1,16 @@
+package com.reactnativebackgroundlivetracking
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+class TrackingPackage : ReactPackage {
+  override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+    return listOf(RNBackgroundLiveTrackingModule(reactContext))
+  }
+
+  override fun createViewManagers(
+    reactContext: ReactApplicationContext,
+  ): List<ViewManager<*, *>> = emptyList()
+}

package/android/src/main/java/com/reactnativebackgroundlivetracking/TrackingPreferences.kt

@@ -0,0 +1,100 @@
+package com.reactnativebackgroundlivetracking
+
+import android.content.Context
+
+internal class TrackingPreferences(context: Context) {
+  private val p = context.getSharedPreferences(PREFS, Context.MODE_PRIVATE)
+
+  var isTrackingActive: Boolean
+    get() = p.getBoolean(KEY_ACTIVE, false)
+    set(value) = p.edit().putBoolean(KEY_ACTIVE, value).apply()
+
+  var autoStartOnBoot: Boolean
+    get() = p.getBoolean(KEY_AUTO_BOOT, true)
+    set(value) = p.edit().putBoolean(KEY_AUTO_BOOT, value).apply()
+
+  var driverId: String
+    get() = p.getString(KEY_DRIVER_ID, "") ?: ""
+    set(value) = p.edit().putString(KEY_DRIVER_ID, value).apply()
+
+  var intervalMs: Long
+    get() = p.getLong(KEY_INTERVAL_MS, 5000L)
+    set(value) = p.edit().putLong(KEY_INTERVAL_MS, value).apply()
+
+  var serverUrl: String
+    get() = p.getString(KEY_SERVER_URL, "") ?: ""
+    set(value) = p.edit().putString(KEY_SERVER_URL, value).apply()
+
+  var socketUrl: String?
+    get() = p.getString(KEY_SOCKET_URL, null)
+    set(value) = p.edit().putString(KEY_SOCKET_URL, value).apply()
+
+  /** rest | websocket | socket.io */
+  var socketTransport: String
+    get() = p.getString(KEY_SOCKET_TRANSPORT, "rest") ?: "rest"
+    set(value) = p.edit().putString(KEY_SOCKET_TRANSPORT, value).apply()
+
+  var notificationTitle: String
+    get() = p.getString(KEY_NOTIF_TITLE, "Driver tracking") ?: "Driver tracking"
+    set(value) = p.edit().putString(KEY_NOTIF_TITLE, value).apply()
+
+  var notificationBody: String
+    get() = p.getString(KEY_NOTIF_BODY, "") ?: ""
+    set(value) = p.edit().putString(KEY_NOTIF_BODY, value).apply()
+
+  var restHeadersJson: String
+    get() = p.getString(KEY_REST_HEADERS, "{}") ?: "{}"
+    set(value) = p.edit().putString(KEY_REST_HEADERS, value).apply()
+
+  /** When true, notification expanded view shows a Static Maps image (requires API key). */
+  var notificationMapPreview: Boolean
+    get() = p.getBoolean(KEY_MAP_PREVIEW, false)
+    set(value) = p.edit().putBoolean(KEY_MAP_PREVIEW, value).apply()
+
+  var staticMapsApiKey: String
+    get() = p.getString(KEY_STATIC_MAP_KEY, "") ?: ""
+    set(value) = p.edit().putString(KEY_STATIC_MAP_KEY, value).apply()
+
+  var hasPickup: Boolean
+    get() = p.getBoolean(KEY_HAS_PICKUP, false)
+    set(value) = p.edit().putBoolean(KEY_HAS_PICKUP, value).apply()
+
+  var pickupLatitude: Double
+    get() =
+      java.lang.Double.longBitsToDouble(
+        p.getLong(KEY_PICKUP_LAT_BITS, 0L),
+      )
+    set(value) =
+      p.edit().putLong(KEY_PICKUP_LAT_BITS, java.lang.Double.doubleToRawLongBits(value)).apply()
+
+  var pickupLongitude: Double
+    get() =
+      java.lang.Double.longBitsToDouble(
+        p.getLong(KEY_PICKUP_LNG_BITS, 0L),
+      )
+    set(value) =
+      p.edit().putLong(KEY_PICKUP_LNG_BITS, java.lang.Double.doubleToRawLongBits(value)).apply()
+
+  fun clearTrackingFlag() {
+    p.edit().putBoolean(KEY_ACTIVE, false).apply()
+  }
+
+  companion object {
+    private const val PREFS = "rn_blt_prefs"
+    private const val KEY_ACTIVE = "tracking_active"
+    private const val KEY_AUTO_BOOT = "auto_boot"
+    private const val KEY_DRIVER_ID = "driver_id"
+    private const val KEY_INTERVAL_MS = "interval_ms"
+    private const val KEY_SERVER_URL = "server_url"
+    private const val KEY_SOCKET_URL = "socket_url"
+    private const val KEY_SOCKET_TRANSPORT = "socket_transport"
+    private const val KEY_NOTIF_TITLE = "notif_title"
+    private const val KEY_NOTIF_BODY = "notif_body"
+    private const val KEY_REST_HEADERS = "rest_headers_json"
+    private const val KEY_MAP_PREVIEW = "map_preview"
+    private const val KEY_STATIC_MAP_KEY = "static_maps_api_key"
+    private const val KEY_HAS_PICKUP = "has_pickup"
+    private const val KEY_PICKUP_LAT_BITS = "pickup_lat_bits"
+    private const val KEY_PICKUP_LNG_BITS = "pickup_lng_bits"
+  }
+}

package/android/src/main/res/values/strings.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+  <string name="rn_blt_channel_id">rn_background_live_tracking</string>
+  <string name="rn_blt_channel_name">Live location tracking</string>
+  <string name="rn_blt_channel_id_map">rn_background_live_tracking_map</string>
+  <string name="rn_blt_channel_name_map">Live location (map preview)</string>
+</resources>