@kafitra/react-native-live-tracking 0.1.0

package/android/src/main/java/com/livetracking/LiveTrackingPackage.kt

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

package/android/src/main/java/com/livetracking/location/LocationEngine.kt

@@ -0,0 +1,93 @@
+package com.livetracking.location
+
+import android.content.Context
+import android.location.Location
+import android.os.Looper
+import com.google.android.gms.location.FusedLocationProviderClient
+import com.google.android.gms.location.LocationCallback
+import com.google.android.gms.location.LocationRequest
+import com.google.android.gms.location.LocationResult
+import com.google.android.gms.location.LocationServices
+import com.google.android.gms.location.Priority
+
+/**
+ * Android Location Engine that wraps FusedLocationProviderClient.
+ * Provides high-accuracy location updates for live tracking.
+ *
+ * Requirements: 2.2
+ */
+class LocationEngine(context: Context) {
+
+    /**
+     * Listener interface for receiving location updates from the engine.
+     */
+    interface LocationUpdateListener {
+        fun onLocationReceived(location: Location)
+    }
+
+    private val fusedLocationClient: FusedLocationProviderClient =
+        LocationServices.getFusedLocationProviderClient(context)
+
+    private var locationListener: LocationUpdateListener? = null
+
+    private val locationCallback = object : LocationCallback() {
+        override fun onLocationResult(locationResult: LocationResult) {
+            val location = locationResult.lastLocation ?: return
+            locationListener?.onLocationReceived(location)
+        }
+    }
+
+    /**
+     * Set the listener that will receive location updates.
+     *
+     * @param listener The listener to receive location callbacks
+     */
+    fun setLocationListener(listener: LocationUpdateListener) {
+        this.locationListener = listener
+    }
+
+    /**
+     * Start receiving location updates with the specified interval and distance filter.
+     * Uses PRIORITY_HIGH_ACCURACY for best possible location accuracy.
+     *
+     * @param intervalMs The desired interval for location updates in milliseconds
+     * @param distanceFilter The minimum distance between updates in meters
+     * @throws SecurityException if location permissions are not granted
+     */
+    @Throws(SecurityException::class)
+    fun startLocationUpdates(intervalMs: Long, distanceFilter: Float) {
+        startLocationUpdates(intervalMs, distanceFilter, Priority.PRIORITY_HIGH_ACCURACY)
+    }
+
+    /**
+     * Start receiving location updates with the specified interval, distance filter, and priority.
+     *
+     * @param intervalMs The desired interval for location updates in milliseconds
+     * @param distanceFilter The minimum distance between updates in meters
+     * @param priority The location request priority (e.g., Priority.PRIORITY_HIGH_ACCURACY or Priority.PRIORITY_LOW_POWER)
+     * @throws SecurityException if location permissions are not granted
+     */
+    @Throws(SecurityException::class)
+    fun startLocationUpdates(intervalMs: Long, distanceFilter: Float, priority: Int) {
+        // When distanceFilter is 0 or negative, disable distance filtering entirely
+        // so FusedLocationProvider delivers updates purely on interval
+        val effectiveDistanceFilter = if (distanceFilter <= 0f) 0f else distanceFilter
+        val locationRequest = LocationRequest.Builder(priority, intervalMs)
+            .setMinUpdateDistanceMeters(effectiveDistanceFilter)
+            .setWaitForAccurateLocation(false)
+            .build()
+
+        fusedLocationClient.requestLocationUpdates(
+            locationRequest,
+            locationCallback,
+            Looper.getMainLooper()
+        )
+    }
+
+    /**
+     * Stop receiving location updates and remove the location callback.
+     */
+    fun stopLocationUpdates() {
+        fusedLocationClient.removeLocationUpdates(locationCallback)
+    }
+}

package/android/src/main/java/com/livetracking/network/NetworkListener.kt

@@ -0,0 +1,127 @@
+package com.livetracking.network
+
+import android.content.Context
+import android.net.ConnectivityManager
+import android.net.Network
+import android.net.NetworkCapabilities
+import android.os.Build
+import androidx.annotation.RequiresApi
+
+/**
+ * Listener interface for network state changes.
+ * Implementations receive callbacks when connectivity is gained or lost.
+ */
+interface NetworkStateListener {
+    /**
+     * Called when network connectivity is restored.
+     * Use this to trigger queue flush for pending location data.
+     */
+    fun onNetworkAvailable()
+
+    /**
+     * Called when network connectivity is lost.
+     */
+    fun onNetworkLost()
+}
+
+/**
+ * NetworkListener monitors device network connectivity using ConnectivityManager.
+ * When connectivity is restored after being offline, it notifies the registered listener
+ * so that pending queued locations can be flushed to Firebase.
+ *
+ * Requires API 24+ for registerDefaultNetworkCallback.
+ *
+ * Usage:
+ * ```
+ * val listener = NetworkListener(context)
+ * listener.setNetworkStateListener(object : NetworkStateListener {
+ *     override fun onNetworkAvailable() { /* flush queue */ }
+ *     override fun onNetworkLost() { /* mark offline */ }
+ * })
+ * listener.startListening()
+ * // ...
+ * listener.stopListening()
+ * ```
+ */
+class NetworkListener(private val context: Context) {
+
+    private val connectivityManager: ConnectivityManager =
+        context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
+
+    private var networkStateListener: NetworkStateListener? = null
+    private var isListening = false
+    private var currentlyOnline = false
+
+    private val networkCallback = object : ConnectivityManager.NetworkCallback() {
+        override fun onAvailable(network: Network) {
+            currentlyOnline = true
+            networkStateListener?.onNetworkAvailable()
+        }
+
+        override fun onLost(network: Network) {
+            currentlyOnline = false
+            networkStateListener?.onNetworkLost()
+        }
+    }
+
+    init {
+        // Initialize current connectivity state
+        currentlyOnline = checkCurrentConnectivity()
+    }
+
+    /**
+     * Set the listener that will receive network state change callbacks.
+     *
+     * @param listener The NetworkStateListener implementation to notify
+     */
+    fun setNetworkStateListener(listener: NetworkStateListener) {
+        this.networkStateListener = listener
+    }
+
+    /**
+     * Start listening for network connectivity changes.
+     * Registers a default network callback with ConnectivityManager (API 24+).
+     * If already listening, this is a no-op.
+     */
+    @RequiresApi(Build.VERSION_CODES.N)
+    fun startListening() {
+        if (isListening) return
+        connectivityManager.registerDefaultNetworkCallback(networkCallback)
+        isListening = true
+    }
+
+    /**
+     * Stop listening for network connectivity changes.
+     * Unregisters the network callback from ConnectivityManager.
+     * If not currently listening, this is a no-op.
+     */
+    fun stopListening() {
+        if (!isListening) return
+        try {
+            connectivityManager.unregisterNetworkCallback(networkCallback)
+        } catch (e: IllegalArgumentException) {
+            // Callback was not registered, ignore
+        }
+        isListening = false
+    }
+
+    /**
+     * Returns the current network connectivity state.
+     *
+     * @return true if the device currently has network connectivity, false otherwise
+     */
+    fun isOnline(): Boolean {
+        return currentlyOnline
+    }
+
+    /**
+     * Check current connectivity state using ConnectivityManager.
+     * Uses NetworkCapabilities for API 23+ for accurate detection.
+     */
+    private fun checkCurrentConnectivity(): Boolean {
+        val activeNetwork = connectivityManager.activeNetwork ?: return false
+        val capabilities = connectivityManager.getNetworkCapabilities(activeNetwork) ?: return false
+        return capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET) &&
+                capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED)
+    }
+}

package/android/src/main/java/com/livetracking/optimizer/ActivityRecognitionHandler.kt

@@ -0,0 +1,248 @@
+package com.livetracking.optimizer
+
+import android.app.PendingIntent
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.os.Build
+import android.os.SystemClock
+import com.google.android.gms.location.ActivityRecognition
+import com.google.android.gms.location.ActivityRecognitionClient
+import com.google.android.gms.location.ActivityRecognitionResult
+import com.google.android.gms.location.DetectedActivity
+
+/**
+ * Android Activity Recognition Handler that wraps ActivityRecognitionClient.
+ * Detects user activity (STILL, ON_FOOT, IN_VEHICLE) and tracks STILL duration
+ * to support Motion Sleep Mode for battery optimization.
+ *
+ * Requirements: 8.1, 8.3
+ */
+class ActivityRecognitionHandler(private val context: Context) {
+
+    companion object {
+        private const val ACTION_ACTIVITY_RECOGNIZED =
+            "com.livetracking.ACTION_ACTIVITY_RECOGNIZED"
+
+        /** Default detection interval in milliseconds */
+        private const val DETECTION_INTERVAL_MS = 10_000L
+
+        /** Minimum confidence level to accept an activity detection */
+        private const val MIN_CONFIDENCE = 50
+    }
+
+    /**
+     * Activity types recognized by the handler.
+     */
+    enum class ActivityType {
+        STILL,
+        ON_FOOT,
+        IN_VEHICLE,
+        UNKNOWN
+    }
+
+    /**
+     * Listener interface for receiving activity state changes.
+     */
+    interface ActivityStateListener {
+        /**
+         * Called when the detected activity type changes.
+         *
+         * @param activity The new detected activity type
+         */
+        fun onActivityChanged(activity: ActivityType)
+
+        /**
+         * Called when the STILL duration exceeds the configured threshold.
+         *
+         * @param durationMs The duration in milliseconds that the device has been still
+         */
+        fun onStillDurationExceeded(durationMs: Long)
+    }
+
+    private val activityRecognitionClient: ActivityRecognitionClient =
+        ActivityRecognition.getClient(context)
+
+    private var listener: ActivityStateListener? = null
+    private var currentActivity: ActivityType = ActivityType.UNKNOWN
+    private var stillStartTimeMs: Long = 0L
+    private var isStill: Boolean = false
+    private var isRunning: Boolean = false
+
+    /** Threshold in milliseconds for STILL duration notification (default: 3 minutes) */
+    var stillThresholdMs: Long = 180_000L
+
+    private var stillDurationExceededNotified: Boolean = false
+
+    private val activityReceiver = object : BroadcastReceiver() {
+        override fun onReceive(context: Context?, intent: Intent?) {
+            if (intent == null) return
+            if (ActivityRecognitionResult.hasResult(intent)) {
+                val result = ActivityRecognitionResult.extractResult(intent) ?: return
+                handleActivityResult(result)
+            }
+        }
+    }
+
+    /**
+     * Set the listener that will receive activity state changes.
+     *
+     * @param listener The listener to receive activity callbacks
+     */
+    fun setActivityStateListener(listener: ActivityStateListener) {
+        this.listener = listener
+    }
+
+    /**
+     * Start activity recognition updates.
+     * Registers a BroadcastReceiver and requests periodic activity detection
+     * from the ActivityRecognitionClient.
+     *
+     * @throws SecurityException if ACTIVITY_RECOGNITION permission is not granted
+     */
+    @Throws(SecurityException::class)
+    fun startActivityRecognition() {
+        if (isRunning) return
+
+        registerReceiver()
+
+        val pendingIntent = createPendingIntent()
+        activityRecognitionClient.requestActivityUpdates(
+            DETECTION_INTERVAL_MS,
+            pendingIntent
+        )
+
+        isRunning = true
+    }
+
+    /**
+     * Stop activity recognition updates.
+     * Unregisters the BroadcastReceiver and removes activity detection requests.
+     */
+    fun stopActivityRecognition() {
+        if (!isRunning) return
+
+        val pendingIntent = createPendingIntent()
+        activityRecognitionClient.removeActivityUpdates(pendingIntent)
+
+        unregisterReceiver()
+
+        // Reset state
+        isRunning = false
+        isStill = false
+        stillStartTimeMs = 0L
+        stillDurationExceededNotified = false
+        currentActivity = ActivityType.UNKNOWN
+    }
+
+    /**
+     * Get the current detected activity type.
+     *
+     * @return The current activity type
+     */
+    fun getCurrentActivity(): ActivityType = currentActivity
+
+    /**
+     * Get the current STILL duration in milliseconds.
+     * Returns 0 if the device is not currently still.
+     *
+     * @return Duration in milliseconds that the device has been still, or 0
+     */
+    fun getStillDurationMs(): Long {
+        if (!isStill || stillStartTimeMs == 0L) return 0L
+        return SystemClock.elapsedRealtime() - stillStartTimeMs
+    }
+
+    /**
+     * Check if the device is currently in STILL state.
+     *
+     * @return true if the device is detected as still
+     */
+    fun isDeviceStill(): Boolean = isStill
+
+    private fun handleActivityResult(result: ActivityRecognitionResult) {
+        val mostProbableActivity = result.mostProbableActivity
+        if (mostProbableActivity.confidence < MIN_CONFIDENCE) return
+
+        val newActivity = mapToActivityType(mostProbableActivity.type)
+        val previousActivity = currentActivity
+        currentActivity = newActivity
+
+        if (newActivity != previousActivity) {
+            listener?.onActivityChanged(newActivity)
+        }
+
+        when (newActivity) {
+            ActivityType.STILL -> handleStillState()
+            else -> handleMovingState()
+        }
+    }
+
+    private fun handleStillState() {
+        if (!isStill) {
+            // Transition to STILL - start tracking duration
+            isStill = true
+            stillStartTimeMs = SystemClock.elapsedRealtime()
+            stillDurationExceededNotified = false
+        } else {
+            // Already still - check if threshold exceeded
+            val duration = SystemClock.elapsedRealtime() - stillStartTimeMs
+            if (duration >= stillThresholdMs && !stillDurationExceededNotified) {
+                stillDurationExceededNotified = true
+                listener?.onStillDurationExceeded(duration)
+            }
+        }
+    }
+
+    private fun handleMovingState() {
+        if (isStill) {
+            // Transition from STILL to moving
+            isStill = false
+            stillStartTimeMs = 0L
+            stillDurationExceededNotified = false
+        }
+    }
+
+    private fun mapToActivityType(detectedActivityType: Int): ActivityType {
+        return when (detectedActivityType) {
+            DetectedActivity.STILL -> ActivityType.STILL
+            DetectedActivity.ON_FOOT,
+            DetectedActivity.WALKING,
+            DetectedActivity.RUNNING -> ActivityType.ON_FOOT
+            DetectedActivity.IN_VEHICLE -> ActivityType.IN_VEHICLE
+            DetectedActivity.ON_BICYCLE -> ActivityType.IN_VEHICLE
+            else -> ActivityType.UNKNOWN
+        }
+    }
+
+    private fun createPendingIntent(): PendingIntent {
+        val intent = Intent(ACTION_ACTIVITY_RECOGNIZED)
+        intent.setPackage(context.packageName)
+
+        val flags = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_MUTABLE
+        } else {
+            PendingIntent.FLAG_UPDATE_CURRENT
+        }
+
+        return PendingIntent.getBroadcast(context, 0, intent, flags)
+    }
+
+    private fun registerReceiver() {
+        val intentFilter = IntentFilter(ACTION_ACTIVITY_RECOGNIZED)
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+            context.registerReceiver(activityReceiver, intentFilter, Context.RECEIVER_NOT_EXPORTED)
+        } else {
+            context.registerReceiver(activityReceiver, intentFilter)
+        }
+    }
+
+    private fun unregisterReceiver() {
+        try {
+            context.unregisterReceiver(activityReceiver)
+        } catch (e: IllegalArgumentException) {
+            // Receiver was not registered, ignore
+        }
+    }
+}

package/android/src/main/java/com/livetracking/optimizer/MotionSleepManager.kt

@@ -0,0 +1,130 @@
+package com.livetracking.optimizer
+
+import android.os.SystemClock
+import com.google.android.gms.location.DetectedActivity
+import com.google.android.gms.location.Priority
+import com.livetracking.location.LocationEngine
+
+/**
+ * Manages Motion Sleep Mode for battery optimization.
+ *
+ * When the device is detected as STILL for more than 3 minutes and `stopWhenStill` is enabled,
+ * this manager switches location updates to low-power mode. When movement is detected again,
+ * it restores high-accuracy location updates.
+ *
+ * Requirements: 8.1, 8.2, 8.4
+ */
+class MotionSleepManager(
+    private val locationEngine: LocationEngine,
+    private val stopWhenStill: Boolean,
+    private val intervalMs: Long,
+    private val distanceFilter: Float
+) {
+
+    /**
+     * Listener interface for motion sleep mode state changes.
+     */
+    interface MotionSleepListener {
+        fun onSleepModeActivated()
+        fun onSleepModeDeactivated()
+    }
+
+    companion object {
+        /**
+         * Duration threshold in milliseconds before entering sleep mode.
+         * Device must be STILL for more than 3 minutes (180,000 ms).
+         */
+        const val STILL_THRESHOLD_MS = 180_000L
+    }
+
+    private var listener: MotionSleepListener? = null
+    private var inSleepMode: Boolean = false
+    private var stillStartTime: Long = 0L
+    private var isStill: Boolean = false
+
+    /**
+     * Set the listener that will receive sleep mode state change callbacks.
+     *
+     * @param listener The listener to receive callbacks, or null to remove
+     */
+    fun setListener(listener: MotionSleepListener?) {
+        this.listener = listener
+    }
+
+    /**
+     * Called when an activity detection update is received.
+     *
+     * If `stopWhenStill` is false, this method is a no-op.
+     *
+     * Behavior:
+     * - STILL detected: starts tracking still duration. If still > 3 minutes, enters sleep mode.
+     * - ON_FOOT or IN_VEHICLE detected: exits sleep mode if active, resets still tracking.
+     *
+     * @param activityType The detected activity type from ActivityRecognitionClient
+     *                     (e.g., DetectedActivity.STILL, DetectedActivity.ON_FOOT)
+     */
+    fun onActivityDetected(activityType: Int) {
+        if (!stopWhenStill) {
+            return
+        }
+
+        when (activityType) {
+            DetectedActivity.STILL -> {
+                if (!isStill) {
+                    // Start tracking still duration
+                    isStill = true
+                    stillStartTime = SystemClock.elapsedRealtime()
+                } else {
+                    // Already still, check if threshold exceeded
+                    val stillDuration = SystemClock.elapsedRealtime() - stillStartTime
+                    if (stillDuration > STILL_THRESHOLD_MS && !inSleepMode) {
+                        enterSleepMode()
+                    }
+                }
+            }
+
+            DetectedActivity.ON_FOOT,
+            DetectedActivity.WALKING,
+            DetectedActivity.RUNNING,
+            DetectedActivity.IN_VEHICLE,
+            DetectedActivity.ON_BICYCLE -> {
+                isStill = false
+                stillStartTime = 0L
+                if (inSleepMode) {
+                    exitSleepMode()
+                }
+            }
+        }
+    }
+
+    /**
+     * Returns whether the manager is currently in sleep mode (low-power location).
+     *
+     * @return true if sleep mode is active, false otherwise
+     */
+    fun isInSleepMode(): Boolean {
+        return inSleepMode
+    }
+
+    /**
+     * Enter sleep mode: stop current location updates and restart with low-power priority.
+     * This reduces GPS usage when the device is stationary.
+     */
+    private fun enterSleepMode() {
+        inSleepMode = true
+        locationEngine.stopLocationUpdates()
+        locationEngine.startLocationUpdates(intervalMs * 5, distanceFilter, Priority.PRIORITY_LOW_POWER)
+        listener?.onSleepModeActivated()
+    }
+
+    /**
+     * Exit sleep mode: stop current location updates and restart with high-accuracy priority.
+     * This restores full GPS accuracy when movement is detected.
+     */
+    private fun exitSleepMode() {
+        inSleepMode = false
+        locationEngine.stopLocationUpdates()
+        locationEngine.startLocationUpdates(intervalMs, distanceFilter, Priority.PRIORITY_HIGH_ACCURACY)
+        listener?.onSleepModeDeactivated()
+    }
+}