react-native-background-live-tracking 1.0.1 → 1.0.3

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

@@ -194,6 +194,13 @@ class LocationForegroundService : Service() {
         locationCallback!!,
         Looper.getMainLooper(),
       )
+      fused
+        .getLastLocation()
+        .addOnSuccessListener { loc ->
+          if (loc != null) {
+            maybeRefreshMapNotification(loc, prefs)
+          }
+        }
     } catch (_: SecurityException) {
       stopSelf()
     }
@@ -234,7 +241,8 @@ class LocationForegroundService : Service() {
     if (!prefs.notificationMapPreview || prefs.staticMapsApiKey.isBlank()) return
     staticMapExecutor.execute {
       val now = System.currentTimeMillis()
-      if (now - lastStaticMapFetchMs < STATIC_MAP_MIN_INTERVAL_MS) return@execute
+      val minGap = prefs.notificationMapRefreshIntervalMs.coerceIn(3_000L, 600_000L)
+      if (now - lastStaticMapFetchMs < minGap) return@execute
       val plat = if (prefs.hasPickup) prefs.pickupLatitude else null
       val plng = if (prefs.hasPickup) prefs.pickupLongitude else null
       val bmp =
@@ -244,6 +252,8 @@ class LocationForegroundService : Service() {
           plat,
           plng,
           prefs.staticMapsApiKey,
+          prefs.driverMarkerIconUrl,
+          prefs.pickupMarkerIconUrl,
         )
           ?: return@execute
       lastStaticMapFetchMs = System.currentTimeMillis()
@@ -267,8 +277,6 @@ class LocationForegroundService : Service() {
   companion object {
     private const val NOTIFICATION_ID = 90421
     private const val QUEUE_FLUSH_INTERVAL_MS = 30_000L
-    /** Limits Static Maps quota / network; expanded notification still updates on this cadence. */
-    private const val STATIC_MAP_MIN_INTERVAL_MS = 45_000L
     const val ACTION_STOP = "com.reactnativebackgroundlivetracking.action.STOP"
 
     fun start(context: Context) {

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

@@ -2,6 +2,7 @@ package com.reactnativebackgroundlivetracking
 
 import android.graphics.Bitmap
 import android.graphics.BitmapFactory
+import android.util.Log
 import java.util.concurrent.TimeUnit
 import okhttp3.HttpUrl.Companion.toHttpUrl
 import okhttp3.OkHttpClient
@@ -9,6 +10,8 @@ import okhttp3.Request
 
 /** Fetches a map bitmap via Google Static Maps API (not an interactive MapView). */
 internal object StaticMapFetcher {
+  private const val TAG = "RNBackgroundLiveTracking"
+
   private val client =
     OkHttpClient.Builder()
       .connectTimeout(18, TimeUnit.SECONDS)
@@ -21,6 +24,8 @@ internal object StaticMapFetcher {
     pickupLat: Double?,
     pickupLng: Double?,
     apiKey: String,
+    driverIconUrl: String,
+    pickupIconUrl: String,
   ): Bitmap? {
     if (apiKey.isBlank()) return null
     val urlBuilder =
@@ -30,26 +35,42 @@ internal object StaticMapFetcher {
         .addQueryParameter("size", "480x240")
         .addQueryParameter("scale", "2")
         .addQueryParameter("maptype", "roadmap")
-        .addQueryParameter(
-          "markers",
-          "color:0x4285F4|size:mid|$driverLat,$driverLng",
-        )
-        .addQueryParameter("key", apiKey)
+
+    val driverMarker =
+      if (driverIconUrl.isNotBlank()) {
+        "icon:$driverIconUrl|$driverLat,$driverLng"
+      } else {
+        "color:0x4285F4|size:mid|$driverLat,$driverLng"
+      }
+    urlBuilder.addQueryParameter("markers", driverMarker)
 
     if (pickupLat != null && pickupLng != null) {
-      urlBuilder.addQueryParameter(
-        "markers",
-        "color:0x0F9D58|label:P|size:mid|$pickupLat,$pickupLng",
-      )
+      val pickupMarker =
+        if (pickupIconUrl.isNotBlank()) {
+          "icon:$pickupIconUrl|$pickupLat,$pickupLng"
+        } else {
+          "color:0x0F9D58|label:P|size:mid|$pickupLat,$pickupLng"
+        }
+      urlBuilder.addQueryParameter("markers", pickupMarker)
     }
 
+    urlBuilder.addQueryParameter("key", apiKey)
+
     val request = Request.Builder().url(urlBuilder.build()).get().build()
     return try {
       client.newCall(request).execute().use { response ->
-        if (!response.isSuccessful) return null
+        if (!response.isSuccessful) {
+          val snippet = response.body?.string()?.take(280)?.replace("\n", " ")
+          Log.w(
+            TAG,
+            "Static Maps request failed: HTTP ${response.code}${if (snippet != null) " — $snippet" else ""}",
+          )
+          return null
+        }
         response.body?.byteStream()?.use { BitmapFactory.decodeStream(it) }
       }
-    } catch (_: Exception) {
+    } catch (e: Exception) {
+      Log.w(TAG, "Static Maps request error", e)
       null
     }
   }

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

@@ -96,6 +96,16 @@ class RNBackgroundLiveTrackingModule(
       prefs.restHeadersJson = restHeaders
       prefs.notificationMapPreview = notificationMapPreview
       prefs.staticMapsApiKey = staticMapsApiKey
+      val mapRefresh =
+        when {
+          !json.has("notificationMapRefreshIntervalMs") || json.isNull("notificationMapRefreshIntervalMs") ->
+            45_000L
+          else ->
+            json.optLong("notificationMapRefreshIntervalMs", 45_000L).coerceIn(3_000L, 600_000L)
+        }
+      prefs.notificationMapRefreshIntervalMs = mapRefresh
+      prefs.driverMarkerIconUrl = json.optString("driverMarkerIconUrl", "")
+      prefs.pickupMarkerIconUrl = json.optString("pickupMarkerIconUrl", "")
       if (json.has("pickup") && !json.isNull("pickup")) {
         val pu = json.getJSONObject("pickup")
         prefs.pickupLatitude = pu.getDouble("latitude")

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

@@ -55,6 +55,11 @@ internal class TrackingPreferences(context: Context) {
     get() = p.getString(KEY_STATIC_MAP_KEY, "") ?: ""
     set(value) = p.edit().putString(KEY_STATIC_MAP_KEY, value).apply()
 
+  /** Min time between Static Maps fetches for the notification bitmap. */
+  var notificationMapRefreshIntervalMs: Long
+    get() = p.getLong(KEY_MAP_REFRESH_MS, 45_000L)
+    set(value) = p.edit().putLong(KEY_MAP_REFRESH_MS, value).apply()
+
   var hasPickup: Boolean
     get() = p.getBoolean(KEY_HAS_PICKUP, false)
     set(value) = p.edit().putBoolean(KEY_HAS_PICKUP, value).apply()
@@ -75,6 +80,16 @@ internal class TrackingPreferences(context: Context) {
     set(value) =
       p.edit().putLong(KEY_PICKUP_LNG_BITS, java.lang.Double.doubleToRawLongBits(value)).apply()
 
+  /** HTTPS URL for Static Maps custom driver marker; empty = default blue pin. */
+  var driverMarkerIconUrl: String
+    get() = p.getString(KEY_DRIVER_MARKER_ICON, "") ?: ""
+    set(value) = p.edit().putString(KEY_DRIVER_MARKER_ICON, value).apply()
+
+  /** HTTPS URL for pickup/destination marker; empty = default green “P” pin. */
+  var pickupMarkerIconUrl: String
+    get() = p.getString(KEY_PICKUP_MARKER_ICON, "") ?: ""
+    set(value) = p.edit().putString(KEY_PICKUP_MARKER_ICON, value).apply()
+
   fun clearTrackingFlag() {
     p.edit().putBoolean(KEY_ACTIVE, false).apply()
   }
@@ -93,8 +108,11 @@ internal class TrackingPreferences(context: Context) {
     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_MAP_REFRESH_MS = "map_refresh_interval_ms"
     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"
+    private const val KEY_DRIVER_MARKER_ICON = "driver_marker_icon_url"
+    private const val KEY_PICKUP_MARKER_ICON = "pickup_marker_icon_url"
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-background-live-tracking",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "Production-ready Android background GPS tracking with REST/WebSocket, offline queue, and foreground service.",
   "main": "src/index.ts",
   "module": "src/index.ts",
@@ -12,10 +12,10 @@
   "homepage": "https://www.npmjs.com/package/react-native-background-live-tracking",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/your-username/react-native-background-live-tracking.git"
+    "url": "git+https://github.com/Rahul6694/react-native-background-live-tracking.git"
   },
   "bugs": {
-    "url": "https://github.com/your-username/react-native-background-live-tracking/issues"
+    "url": "https://github.com/Rahul6694/react-native-background-live-tracking/issues"
   },
   "keywords": [
     "react-native",

package/src/index.ts

@@ -29,7 +29,11 @@ export const Tracking = {
       restHeaders,
       notificationMapPreview,
       googleStaticMapsApiKey,
+      notificationMapRefreshIntervalMs,
       pickup,
+      destination,
+      driverMarkerIconUrl,
+      pickupMarkerIconUrl,
     } = options;
     if (!driverId || !serverUrl || !interval || interval < 1000) {
       throw new Error(
@@ -49,7 +53,13 @@ export const Tracking = {
       restHeaders: restHeaders ?? {},
       notificationMapPreview: notificationMapPreview === true,
       googleStaticMapsApiKey: googleStaticMapsApiKey ?? '',
-      pickup: pickup ?? null,
+      notificationMapRefreshIntervalMs:
+        notificationMapRefreshIntervalMs != null
+          ? Math.floor(notificationMapRefreshIntervalMs)
+          : null,
+      pickup: pickup ?? destination ?? null,
+      driverMarkerIconUrl: driverMarkerIconUrl ?? '',
+      pickupMarkerIconUrl: pickupMarkerIconUrl ?? '',
     };
     await Native.startTracking(JSON.stringify(payload));
   },

package/src/types.ts

@@ -16,14 +16,34 @@ export type TrackingStartOptions = {
   /** Extra headers for REST POST (JSON string map). */
   restHeaders?: Record<string, string>;
   /**
-   * Show a map image in the expanded notification (Android only). This is **not** a live MapView:
-   * it uses the Google Static Maps API, so you need a key and it refreshes on an interval (see README).
+   * Show a map image in the expanded notification (Android only). Android cannot embed a real
+   * interactive MapView in the shade—only a **bitmap** that we refresh. Use
+   * `notificationMapRefreshIntervalMs` (e.g. same as `interval`) so the map tracks your location
+   * as often as GPS updates; higher frequency uses more Static Maps quota.
    */
   notificationMapPreview?: boolean;
   /** Google Cloud API key with Static Maps API enabled (billing). */
   googleStaticMapsApiKey?: string;
-  /** Optional green “pickup” marker on the static map preview. */
+  /**
+   * How often to fetch a new Static Maps image for the notification (milliseconds). Default 45000.
+   * Set close to `interval` (e.g. 5000) for “near live” snapshots; minimum enforced on native side.
+   */
+  notificationMapRefreshIntervalMs?: number;
+  /**
+   * Optional second marker (e.g. destination). Same as `destination` if you prefer that name.
+   */
   pickup?: { latitude: number; longitude: number };
+  /** Alias for `pickup` (destination / drop-off coordinates). */
+  destination?: { latitude: number; longitude: number };
+  /**
+   * Public HTTPS URL of a small PNG (or GIF/JPEG) for the driver marker. Passed to Static Maps as a custom icon.
+   * @see https://developers.google.com/maps/documentation/maps-static/start#Markers
+   */
+  driverMarkerIconUrl?: string;
+  /**
+   * Public HTTPS URL for the pickup/destination marker when `pickup` or `destination` is set.
+   */
+  pickupMarkerIconUrl?: string;
 };
 
 export type TrackingStatus = {