react-native-geo-activity-kit 1.2.4 → 1.2.5

package/android/src/main/AndroidManifest.xml

@@ -7,12 +7,25 @@
     <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
     <uses-permission android:name="android.permission.WAKE_LOCK" />
 
+    <uses-permission android:name="android.permission.ACTIVITY_RECOGNITION" />
+    <uses-permission android:name="com.google.android.gms.permission.ACTIVITY_RECOGNITION" />
+
     <application>
         <service
             android:name=".TrackingService"
             android:enabled="true"
             android:exported="false"
             android:foregroundServiceType="location" />
+        
+        <receiver
+            android:name=".ActivityTransitionReceiver"
+            android:enabled="true"
+            android:exported="false"
+            android:permission="com.google.android.gms.permission.ACTIVITY_RECOGNITION">
+            <intent-filter>
+                <action android:name="com.rngeoactivitykit.ACTION_PROCESS_ACTIVITY_TRANSITIONS" />
+            </intent-filter>
+        </receiver>
     </application>
 
 </manifest>

package/android/src/main/java/com/rngeoactivitykit/ActivityTransitionReceiver.kt

@@ -0,0 +1,88 @@
+package com.rngeoactivitykit
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.util.Log
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.google.android.gms.location.ActivityTransitionResult
+import com.google.android.gms.location.DetectedActivity
+
+class ActivityTransitionReceiver : BroadcastReceiver() {
+
+    override fun onReceive(context: Context, intent: Intent) {
+        if (ActivityTransitionResult.hasResult(intent)) {
+            val result = ActivityTransitionResult.extractResult(intent) ?: return
+            
+            for (event in result.transitionEvents) {
+                val activityType = toActivityString(event.activityType)
+                val transitionType = toTransitionString(event.transitionType)
+                
+                Log.d("ActivityReceiver", "🏃 Motion Event: $activityType ($transitionType)")
+
+                val isMoving = when(event.activityType) {
+                    DetectedActivity.WALKING, 
+                    DetectedActivity.RUNNING, 
+                    DetectedActivity.ON_BICYCLE, 
+                    DetectedActivity.IN_VEHICLE -> true
+                    else -> false 
+                }
+
+                // --- NEW: DIRECT NATIVE CONTROL (No JS required) ---
+                try {
+                    if (isMoving) {
+                         // Fast Updates (30s) when moving
+                         LocationHelper.shared?.setLocationUpdateInterval(30000)
+                    } else {
+                         // Slow Updates (5 mins) when STILL - BATTERY SAVER
+                         LocationHelper.shared?.setLocationUpdateInterval(5 * 60 * 1000)
+                    }
+                } catch (e: Exception) {
+                    Log.e("ActivityReceiver", "Failed to update location interval directly")
+                }
+                // ---------------------------------------------------
+
+                try {
+                    val reactContext = context.applicationContext as? ReactApplicationContext
+                        ?: TrackingService.instance?.application as? ReactApplicationContext
+
+                    if (reactContext != null && reactContext.hasActiveCatalystInstance()) {
+                        val params = Arguments.createMap()
+                        params.putString("activity", activityType)
+                        params.putString("transition", transitionType)
+                        params.putBoolean("isMoving", isMoving)
+                        params.putString("state", if (isMoving) "MOVING" else "STATIONARY")
+                        
+                        reactContext
+                            .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                            .emit("onMotionStateChanged", params)
+                    }
+                } catch (e: Exception) {
+                    Log.e("ActivityReceiver", "JS Bridge Error: ${e.message}")
+                }
+            }
+        }
+    }
+
+    private fun toActivityString(type: Int): String {
+        return when (type) {
+            DetectedActivity.STILL -> "STILL"
+            DetectedActivity.WALKING -> "WALKING"
+            DetectedActivity.RUNNING -> "RUNNING"
+            DetectedActivity.ON_BICYCLE -> "ON_BICYCLE"
+            DetectedActivity.IN_VEHICLE -> "IN_VEHICLE"
+            DetectedActivity.TILTING -> "TILTING"
+            else -> "UNKNOWN"
+        }
+    }
+
+    private fun toTransitionString(type: Int): String {
+        return when (type) {
+            com.google.android.gms.location.ActivityTransition.ACTIVITY_TRANSITION_ENTER -> "ENTER"
+            com.google.android.gms.location.ActivityTransition.ACTIVITY_TRANSITION_EXIT -> "EXIT"
+            else -> "UNKNOWN"
+        }
+    }
+}

package/android/src/main/java/com/rngeoactivitykit/LocationHelper.kt

@@ -16,6 +16,13 @@ import java.util.TimeZone
 
 class LocationHelper(private val context: ReactApplicationContext) {
 
+    // --- ADDED THIS BLOCK (Singleton Pattern) ---
+    companion object {
+        @SuppressLint("StaticFieldLeak")
+        var shared: LocationHelper? = null
+    }
+    // --------------------------------------------
+
     private val fusedLocationClient: FusedLocationProviderClient = LocationServices.getFusedLocationProviderClient(context)
     private var locationCallback: LocationCallback
     private var locationRequest: LocationRequest
@@ -28,6 +35,10 @@ class LocationHelper(private val context: ReactApplicationContext) {
     }
 
     init {
+        // --- ADDED THIS LINE ---
+        shared = this 
+        // -----------------------
+        
         locationRequest = LocationRequest.create().apply {
             interval = 30000
             fastestInterval = 30000
@@ -39,21 +50,38 @@ class LocationHelper(private val context: ReactApplicationContext) {
                 locationResult.lastLocation ?: return
                 val location = locationResult.lastLocation!!
                 
+                Log.d("LocationHelper", "📍 New Location: ${location.latitude}, ${location.longitude} (Acc: ${location.accuracy}m)")
+
+                var isMock = false
+                if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.S) {
+                    isMock = location.isMock
+                } else {
+                    isMock = location.isFromMockProvider
+                }
+
                 val params = Arguments.createMap()
                 params.putDouble("latitude", location.latitude)
                 params.putDouble("longitude", location.longitude)
                 params.putString("timestamp", isoFormatter.format(Date(location.time)))
                 params.putDouble("accuracy", location.accuracy.toDouble())
+                params.putBoolean("is_mock", isMock) 
 
                 sendEvent("onLocationLog", params)
             }
         }
     }
 
-    fun updateLocationRequest(priority: Int, intervalMs: Long) {
-        if (locationRequest.priority == priority && locationRequest.interval == intervalMs) return
+    fun setLocationUpdateInterval(intervalMs: Long) {
+        val newPriority = if (intervalMs < 10000) {
+            Priority.PRIORITY_HIGH_ACCURACY
+        } else {
+            Priority.PRIORITY_BALANCED_POWER_ACCURACY
+        }
+        updateLocationRequest(newPriority, intervalMs)
+    }
 
-        Log.i("LocationHelper", "Switching Mode -> Priority: $priority, Interval: $intervalMs")
+    fun updateLocationRequest(priority: Int, intervalMs: Long) {
+        Log.d("LocationHelper", "🔄 Updating Request: Priority=$priority, Interval=${intervalMs}ms")
 
         locationRequest = LocationRequest.create().apply {
             this.interval = intervalMs
@@ -61,10 +89,11 @@ class LocationHelper(private val context: ReactApplicationContext) {
             this.priority = priority
         }
         
-        // Restart if running to apply changes
         if (isLocationClientRunning) {
             stopLocationUpdates()
             startLocationUpdates()
+        } else {
+            startLocationUpdates()
         }
     }
 
@@ -72,21 +101,15 @@ class LocationHelper(private val context: ReactApplicationContext) {
     fun startLocationUpdates() {
         if (isLocationClientRunning) return
         if (!hasLocationPermission()) {
-            val params = Arguments.createMap()
-            params.putString("error", "LOCATION_PERMISSION_DENIED")
-            params.putString("message", "Location permission is not granted.")
-            sendEvent("onLocationError", params)
+            Log.e("LocationHelper", "Permission Missing")
             return
         }
         try {
             fusedLocationClient.requestLocationUpdates(locationRequest, locationCallback, Looper.getMainLooper())
             isLocationClientRunning = true
-            Log.i("LocationHelper", "Location updates started.")
+            Log.d("LocationHelper", "✅ Location Updates STARTED.")
         } catch (e: Exception) {
-            val params = Arguments.createMap()
-            params.putString("error", "START_LOCATION_FAILED")
-            params.putString("message", "Error starting location: ${e.message}")
-            sendEvent("onLocationError", params)
+            Log.e("LocationHelper", "Error starting location: ${e.message}")
         }
     }
 
@@ -95,9 +118,9 @@ class LocationHelper(private val context: ReactApplicationContext) {
         try {
             fusedLocationClient.removeLocationUpdates(locationCallback)
             isLocationClientRunning = false
-            Log.i("LocationHelper", "Location updates stopped.")
+            Log.d("LocationHelper", "🛑 Location Updates STOPPED.")
         } catch (e: Exception) {
-            Log.e("LocationHelper", "Failed to stop location updates: " + e.message)
+            Log.e("LocationHelper", "Failed to stop: " + e.message)
         }
     }
 
@@ -108,8 +131,12 @@ class LocationHelper(private val context: ReactApplicationContext) {
     }
 
     private fun sendEvent(eventName: String, params: Any?) {
-        if (context.hasActiveCatalystInstance()) {
-            context.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java).emit(eventName, params)
+        try {
+            if (context.hasActiveCatalystInstance()) {
+                context.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java).emit(eventName, params)
+            }
+        } catch (e: Exception) {
+            Log.e("LocationHelper", "JS Error: ${e.message}")
         }
     }
 }

package/android/src/main/java/com/rngeoactivitykit/MotionDetector.kt

@@ -1,115 +1,88 @@
 package com.rngeoactivitykit
 
-import android.content.Context
-import android.hardware.Sensor
-import android.hardware.SensorEvent
-import android.hardware.SensorEventListener
-import android.hardware.SensorManager
-import com.facebook.react.bridge.Arguments
+import android.Manifest
+import android.annotation.SuppressLint
+import android.app.PendingIntent
+import android.content.Intent
+import android.content.pm.PackageManager
+import android.os.Build
+import androidx.core.content.ContextCompat
 import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.modules.core.DeviceEventManagerModule
-import kotlin.math.sqrt
-
-class MotionDetector(private val context: ReactApplicationContext, private val onStateChange: (String) -> Unit) : SensorEventListener {
-
-    private val sensorManager: SensorManager = context.getSystemService(Context.SENSOR_SERVICE) as SensorManager
-    private var accelerometer: Sensor? = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER)
+import com.google.android.gms.location.ActivityRecognition
+import com.google.android.gms.location.ActivityTransition
+import com.google.android.gms.location.ActivityTransitionRequest
+import com.google.android.gms.location.DetectedActivity
+
+class MotionDetector(private val context: ReactApplicationContext) {
+
+    private val activityClient = ActivityRecognition.getClient(context)
+    private var pendingIntent: PendingIntent? = null
+
+    // We define which activities trigger a wake-up
+    private val transitions = listOf(
+        // Detect when user STOPS moving
+        ActivityTransition.Builder()
+            .setActivityType(DetectedActivity.STILL)
+            .setActivityTransition(ActivityTransition.ACTIVITY_TRANSITION_ENTER)
+            .build(),
+        
+        // Detect when user STARTS Walking
+        ActivityTransition.Builder()
+            .setActivityType(DetectedActivity.WALKING)
+            .setActivityTransition(ActivityTransition.ACTIVITY_TRANSITION_ENTER)
+            .build(),
+
+        // Detect when user STARTS Driving
+        ActivityTransition.Builder()
+            .setActivityType(DetectedActivity.IN_VEHICLE)
+            .setActivityTransition(ActivityTransition.ACTIVITY_TRANSITION_ENTER)
+            .build()
+    )
+
+    @SuppressLint("MissingPermission") // Checked in start()
+    fun start(): Boolean {
+        if (!hasPermission()) {
+            return false
+        }
 
-    private val gravity = floatArrayOf(0f, 0f, 0f)
-    private val linearAcceleration = floatArrayOf(0f, 0f, 0f)
-    private val alpha: Float = 0.8f
+        val request = ActivityTransitionRequest(transitions)
+        val intent = Intent(context, ActivityTransitionReceiver::class.java)
+        intent.action = "com.rngeoactivitykit.ACTION_PROCESS_ACTIVITY_TRANSITIONS"
 
-    var motionThreshold: Float = 0.8f
-    var startStabilityThreshold: Int = 20
-    var stopStabilityThreshold: Int = 3000
-    var samplingPeriodUs: Int = 100_000
+        val flags = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_MUTABLE
+        } else {
+            PendingIntent.FLAG_UPDATE_CURRENT
+        }
 
-    private var currentState: String = "STATIONARY"
-    private var potentialState: String = "STATIONARY"
-    private var consecutiveCount = 0
-    private var isStarted = false
+        pendingIntent = PendingIntent.getBroadcast(context, 0, intent, flags)
 
-    fun start(threshold: Double): Boolean {
-        if (accelerometer == null) return false
-        
-        motionThreshold = threshold.toFloat()
-        currentState = "STATIONARY"
-        potentialState = "STATIONARY"
-        consecutiveCount = 0
-        isStarted = true
+        activityClient.requestActivityTransitionUpdates(request, pendingIntent!!)
+            .addOnSuccessListener {
+                // Success
+            }
+            .addOnFailureListener { e ->
+                e.printStackTrace()
+            }
 
-        sensorManager.registerListener(this, accelerometer, samplingPeriodUs)
         return true
     }
 
     fun stop() {
-        isStarted = false
-        sensorManager.unregisterListener(this)
-    }
-    
-    fun setUpdateInterval(ms: Int) {
-        samplingPeriodUs = ms * 1000
-        if (isStarted) {
-            stop()
-            sensorManager.registerListener(this, accelerometer, samplingPeriodUs)
-            isStarted = true
+        pendingIntent?.let {
+            activityClient.removeActivityTransitionUpdates(it)
+            pendingIntent = null
         }
     }
 
-    fun isSensorAvailable(): Boolean = accelerometer != null
-
-    override fun onSensorChanged(event: SensorEvent?) {
-        event ?: return
-        if (event.sensor.type == Sensor.TYPE_ACCELEROMETER) {
-            
-            // Isolate Gravity
-            gravity[0] = alpha * gravity[0] + (1 - alpha) * event.values[0]
-            gravity[1] = alpha * gravity[1] + (1 - alpha) * event.values[1]
-            gravity[2] = alpha * gravity[2] + (1 - alpha) * event.values[2]
-
-            // Remove Gravity
-            linearAcceleration[0] = event.values[0] - gravity[0]
-            linearAcceleration[1] = event.values[1] - gravity[1]
-            linearAcceleration[2] = event.values[2] - gravity[2]
-
-            val magnitude = sqrt(
-                (linearAcceleration[0] * linearAcceleration[0] +
-                 linearAcceleration[1] * linearAcceleration[1] +
-                 linearAcceleration[2] * linearAcceleration[2]).toDouble()
-            ).toFloat()
-
-            val newState = if (magnitude > motionThreshold) "MOVING" else "STATIONARY"
-
-            if (newState == potentialState) {
-                consecutiveCount++
-            } else {
-                potentialState = newState
-                consecutiveCount = 1
-            }
-
-            var stabilityMet = false
-            if (potentialState == "MOVING" && consecutiveCount >= startStabilityThreshold) {
-                stabilityMet = true
-            } else if (potentialState == "STATIONARY" && consecutiveCount >= stopStabilityThreshold) {
-                stabilityMet = true
-            }
-
-            if (stabilityMet && potentialState != currentState) {
-                currentState = potentialState
-                
-                // Notify Listener (SensorModule)
-                onStateChange(currentState)
-
-                // Emit to JS
-                val params = Arguments.createMap()
-                params.putString("state", currentState)
-                if (context.hasActiveCatalystInstance()) {
-                    context.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
-                        .emit("onMotionStateChanged", params)
-                }
-            }
+    private fun hasPermission(): Boolean {
+        return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            ContextCompat.checkSelfPermission(
+                context,
+                Manifest.permission.ACTIVITY_RECOGNITION
+            ) == PackageManager.PERMISSION_GRANTED
+        } else {
+            true // Not required at runtime below Android 10
         }
     }
-
-    override fun onAccuracyChanged(sensor: Sensor?, accuracy: Int) {}
 }

package/android/src/main/java/com/rngeoactivitykit/SensorModule.kt

@@ -8,66 +8,46 @@ import android.location.LocationManager
 import android.os.Build
 import com.facebook.react.bridge.*
 import com.facebook.react.modules.core.DeviceEventManagerModule
-import com.google.android.gms.location.Priority
 
 class SensorModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
 
     private val notificationHelper = NotificationHelper(reactContext)
     private val locationHelper = LocationHelper(reactContext)
     
-    private val motionDetector = MotionDetector(reactContext) { newState ->
-        onMotionStateChanged(newState)
-    }
-
-    private var locationInterval: Long = 30000
+    // NEW: MotionDetector no longer needs a callback because 
+    // the ActivityTransitionReceiver handles the events.
+    private val motionDetector = MotionDetector(reactContext)
 
-    // --- NEW: Hardware GPS Toggle Receiver ---
+    // --- GPS STATUS RECEIVER (Detects if user turns off Location Toggle) ---
     private val gpsStatusReceiver = object : BroadcastReceiver() {
         override fun onReceive(context: Context?, intent: Intent?) {
             if (intent?.action == LocationManager.PROVIDERS_CHANGED_ACTION) {
-                val locationManager = context?.getSystemService(Context.LOCATION_SERVICE) as LocationManager
-                val isGpsEnabled = locationManager.isProviderEnabled(LocationManager.GPS_PROVIDER)
-                
-                val params = Arguments.createMap()
-                params.putBoolean("enabled", isGpsEnabled)
-                
-                // Emit event to React Native
-                sendEvent("onGpsStatusChanged", params)
+                try {
+                    val locationManager = context?.getSystemService(Context.LOCATION_SERVICE) as LocationManager
+                    val isGpsEnabled = locationManager.isProviderEnabled(LocationManager.GPS_PROVIDER)
+                    
+                    val params = Arguments.createMap()
+                    params.putBoolean("enabled", isGpsEnabled)
+                    
+                    sendEvent("onGpsStatusChanged", params)
+                } catch (e: Exception) {
+                    e.printStackTrace()
+                }
             }
         }
     }
 
-    override fun getName(): String = "RNSensorModule"
-
-    private fun sendEvent(eventName: String, params: WritableMap) {
-        if (reactApplicationContext.hasActiveCatalystInstance()) {
-            reactApplicationContext
-                .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
-                .emit(eventName, params)
-        }
+    override fun getName(): String {
+        return "RNSensorModule"
     }
 
-    private fun onMotionStateChanged(state: String) {
-        if (state == "MOVING") {
-            locationHelper.updateLocationRequest(Priority.PRIORITY_HIGH_ACCURACY, locationInterval)
-            locationHelper.startLocationUpdates()
-        } else {
-            locationHelper.updateLocationRequest(Priority.PRIORITY_BALANCED_POWER_ACCURACY, 180000)
-            locationHelper.startLocationUpdates()
-        }
+    init {
+        // Register GPS Status Receiver
+        val filter = IntentFilter(LocationManager.PROVIDERS_CHANGED_ACTION)
+        reactContext.registerReceiver(gpsStatusReceiver, filter)
     }
 
-    // --- NEW: Native Method to Start GPS Listener ---
-    @ReactMethod
-    fun registerGpsListener(promise: Promise) {
-        try {
-            val filter = IntentFilter(LocationManager.PROVIDERS_CHANGED_ACTION)
-            reactApplicationContext.registerReceiver(gpsStatusReceiver, filter)
-            promise.resolve(true)
-        } catch (e: Exception) {
-            promise.reject("REGISTER_FAILED", e.message)
-        }
-    }
+    // --- SERVICE CONTROL ---
 
     @ReactMethod
     fun startForegroundService(title: String, body: String, promise: Promise) {
@@ -84,7 +64,7 @@ class SensorModule(reactContext: ReactApplicationContext) : ReactContextBaseJava
             }
             promise.resolve(true)
         } catch (e: Exception) {
-            promise.reject("START_FAILED", e.message)
+            promise.reject("START_SERVICE_FAILED", e.message)
         }
     }
 
@@ -93,83 +73,82 @@ class SensorModule(reactContext: ReactApplicationContext) : ReactContextBaseJava
         try {
             val intent = Intent(reactApplicationContext, TrackingService::class.java)
             intent.action = TrackingService.ACTION_STOP
-            reactApplicationContext.startService(intent)
+            reactApplicationContext.startService(intent) // Triggers stop logic in Service
             promise.resolve(true)
         } catch (e: Exception) {
-            promise.reject("STOP_FAILED", e.message)
+            promise.reject("STOP_SERVICE_FAILED", e.message)
         }
     }
 
     @ReactMethod
     fun updateServiceNotification(title: String, body: String, promise: Promise) {
         try {
-            if (TrackingService.instance != null) {
-                val intent = Intent(reactApplicationContext, TrackingService::class.java)
-                intent.action = TrackingService.ACTION_UPDATE
-                intent.putExtra("title", title)
-                intent.putExtra("body", body)
-                reactApplicationContext.startService(intent)
-                promise.resolve(true)
+            val intent = Intent(reactApplicationContext, TrackingService::class.java)
+            intent.action = TrackingService.ACTION_UPDATE
+            intent.putExtra("title", title)
+            intent.putExtra("body", body)
+            
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                reactApplicationContext.startForegroundService(intent)
             } else {
-                promise.resolve(false)
+                reactApplicationContext.startService(intent)
             }
+            promise.resolve(true)
         } catch (e: Exception) {
             promise.reject("UPDATE_FAILED", e.message)
         }
     }
 
+    // --- MOTION DETECTOR (Updated for Activity Recognition) ---
+
     @ReactMethod
     fun startMotionDetector(threshold: Double, promise: Promise) {
-        val success = motionDetector.start(threshold)
-        if (!success) {
-            promise.reject("NO_SENSOR", "Accelerometer not available")
-            return
+        // NOTE: 'threshold' is ignored now because Activity Recognition 
+        // handles sensitivity automatically using Machine Learning.
+        try {
+            val success = motionDetector.start()
+            if (success) {
+                promise.resolve(true)
+            } else {
+                // This usually means Permissions are missing
+                promise.reject("PERMISSION_DENIED", "ACTIVITY_RECOGNITION permission is required")
+            }
+        } catch (e: Exception) {
+            promise.reject("START_MOTION_FAILED", e.message)
         }
-        locationHelper.updateLocationRequest(Priority.PRIORITY_BALANCED_POWER_ACCURACY, 180000)
-        locationHelper.startLocationUpdates()
-        promise.resolve(true)
     }
 
     @ReactMethod
     fun stopMotionDetector(promise: Promise) {
-        motionDetector.stop()
-        locationHelper.stopLocationUpdates()
-        promise.resolve(true)
-    }
-
-    @ReactMethod
-    fun setLocationUpdateInterval(interval: Double, promise: Promise) {
-        locationInterval = interval.toLong()
-        promise.resolve(true)
-    }
-
-    @ReactMethod
-    fun setStabilityThresholds(startThreshold: Int, stopThreshold: Int, promise: Promise) {
-        motionDetector.startStabilityThreshold = startThreshold
-        motionDetector.stopStabilityThreshold = stopThreshold
-        promise.resolve(true)
+        try {
+            motionDetector.stop()
+            promise.resolve(true)
+        } catch (e: Exception) {
+            promise.reject("STOP_MOTION_FAILED", e.message)
+        }
     }
 
-    @ReactMethod
-    fun setUpdateInterval(ms: Int, promise: Promise) {
-        motionDetector.setUpdateInterval(ms)
-        promise.resolve(true)
-    }
+    // --- LOCATION CONTROL ---
 
     @ReactMethod
-    fun isAvailable(promise: Promise) {
-        val map = Arguments.createMap()
-        map.putBoolean("accelerometer", motionDetector.isSensorAvailable())
-        map.putBoolean("gyroscope", false)
-        promise.resolve(map)
+    fun setLocationUpdateInterval(intervalMs: Int) {
+        try {
+            locationHelper.setLocationUpdateInterval(intervalMs.toLong())
+        } catch (e: Exception) {
+            e.printStackTrace()
+        }
     }
+    
+    // --- ALERTS & NOTIFICATIONS ---
 
     @ReactMethod
     fun fireGeofenceAlert(type: String, userName: String, promise: Promise) {
         try {
             notificationHelper.fireGeofenceAlert(type, userName)
             promise.resolve(true)
-        } catch (e: Exception) { promise.reject("NOTIFY_FAILED", e.message) }
+        } catch (e: Exception) { 
+            promise.reject("NOTIFY_FAILED", e.message) 
+        }
     }
 
     @ReactMethod
@@ -177,7 +156,9 @@ class SensorModule(reactContext: ReactApplicationContext) : ReactContextBaseJava
         try {
             notificationHelper.fireGenericAlert(title, body, id)
             promise.resolve(true)
-        } catch (e: Exception) { promise.reject("NOTIFY_FAILED", e.message) }
+        } catch (e: Exception) { 
+            promise.reject("NOTIFY_FAILED", e.message) 
+        }
     }
 
     @ReactMethod
@@ -185,23 +166,65 @@ class SensorModule(reactContext: ReactApplicationContext) : ReactContextBaseJava
         try {
             notificationHelper.cancelGenericAlert(id)
             promise.resolve(true)
-        } catch (e: Exception) { promise.reject("CANCEL_FAILED", e.message) }
+        } catch (e: Exception) { 
+            promise.reject("CANCEL_FAILED", e.message) 
+        }
     }
 
-    @ReactMethod fun addListener(eventName: String) {}
-    @ReactMethod fun removeListeners(count: Int) {}
+    @ReactMethod
+    fun registerGpsListener(promise: Promise) {
+        // Already registered in init, just checking permission state
+        try {
+            val locationManager = reactApplicationContext.getSystemService(Context.LOCATION_SERVICE) as LocationManager
+            val isEnabled = locationManager.isProviderEnabled(LocationManager.GPS_PROVIDER)
+            promise.resolve(isEnabled)
+        } catch (e: Exception) {
+            promise.reject("GPS_CHECK_FAILED", e.message)
+        }
+    }
+
+    // --- EVENT EMITTER BOILERPLATE ---
+
+    @ReactMethod
+    fun addListener(eventName: String) {
+        // Required for NativeEventEmitter
+    }
+
+    @ReactMethod
+    fun removeListeners(count: Int) {
+        // Required for NativeEventEmitter
+    }
+
+    private fun sendEvent(eventName: String, params: Any?) {
+        try {
+            if (reactApplicationContext.hasActiveCatalystInstance()) {
+                reactApplicationContext
+                    .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                    .emit(eventName, params)
+            }
+        } catch (e: Exception) {
+            e.printStackTrace()
+        }
+    }
+
+    // --- CLEANUP ---
 
     override fun onCatalystInstanceDestroy() {
+        super.onCatalystInstanceDestroy()
         try {
+            // 1. Unregister Receivers
             reactApplicationContext.unregisterReceiver(gpsStatusReceiver)
-        } catch (e: Exception) {}
-        
-        super.onCatalystInstanceDestroy()
-        motionDetector.stop()
-        locationHelper.stopLocationUpdates()
-        
-        val intent = Intent(reactApplicationContext, TrackingService::class.java)
-        intent.action = TrackingService.ACTION_STOP
-        reactApplicationContext.startService(intent)
+            
+            // 2. Stop Sensors
+            motionDetector.stop()
+            locationHelper.stopLocationUpdates()
+            
+            // 3. Stop Service (Optional: Depending on whether you want it to persist after app kill)
+            // Ideally, we DO NOT stop the service here if we want it running in background.
+            // But we do clean up listeners.
+            
+        } catch (e: Exception) {
+            e.printStackTrace()
+        }
     }
 }

package/android/src/main/java/com/rngeoactivitykit/TrackingService.kt

@@ -11,6 +11,7 @@ import android.content.pm.ServiceInfo
 import android.os.Build
 import android.os.IBinder
 import android.os.PowerManager
+import android.util.Log
 import androidx.core.app.NotificationCompat
 
 class TrackingService : Service() {
@@ -19,7 +20,6 @@ class TrackingService : Service() {
         var instance: TrackingService? = null
         const val NOTIFICATION_ID = 9991
         const val CHANNEL_ID = "geo_activity_kit_channel"
-        
         const val ACTION_START = "ACTION_START"
         const val ACTION_STOP = "ACTION_STOP"
         const val ACTION_UPDATE = "ACTION_UPDATE"
@@ -32,15 +32,16 @@ class TrackingService : Service() {
     override fun onCreate() {
         super.onCreate()
         instance = this
+        Log.d("TrackingService", "✅ Service Created")
         createNotificationChannel()
         
-        // Acquire WakeLock to keep CPU running
         try {
             val powerManager = getSystemService(POWER_SERVICE) as PowerManager
             wakeLock = powerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "GeoKit::TrackingLock")
-            wakeLock?.acquire(10 * 60 * 1000L /* 10 minutes timeout safety */) 
+            wakeLock?.acquire()
+            Log.d("TrackingService", "🔒 WakeLock Acquired (Permanent)")
         } catch (e: Exception) {
-            e.printStackTrace()
+            Log.e("TrackingService", "❌ Failed to acquire WakeLock: ${e.message}")
         }
     }
 
@@ -49,11 +50,13 @@ class TrackingService : Service() {
         
         when (intent.action) {
             ACTION_START -> {
+                Log.d("TrackingService", "➡️ Action: START")
                 val title = intent.getStringExtra("title") ?: "Location Active"
                 val body = intent.getStringExtra("body") ?: "Monitoring in background..."
                 startForegroundService(title, body)
             }
             ACTION_STOP -> {
+                Log.d("TrackingService", "⏹️ Action: STOP")
                 stopForegroundService()
             }
             ACTION_UPDATE -> {
@@ -67,11 +70,14 @@ class TrackingService : Service() {
 
     private fun startForegroundService(title: String, body: String) {
         val notification = buildNotification(title, body)
-        
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
-            startForeground(NOTIFICATION_ID, notification, ServiceInfo.FOREGROUND_SERVICE_TYPE_LOCATION)
-        } else {
-            startForeground(NOTIFICATION_ID, notification)
+        try {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+                startForeground(NOTIFICATION_ID, notification, ServiceInfo.FOREGROUND_SERVICE_TYPE_LOCATION)
+            } else {
+                startForeground(NOTIFICATION_ID, notification)
+            }
+        } catch (e: Exception) {
+            Log.e("TrackingService", "Error starting foreground: ${e.message}")
         }
     }
 
@@ -127,6 +133,7 @@ class TrackingService : Service() {
 
     override fun onDestroy() {
         super.onDestroy()
+        Log.d("TrackingService", "❌ Service Destroyed")
         instance = null
         if (wakeLock?.isHeld == true) {
             try { wakeLock?.release() } catch (_: Exception) {}

package/lib/module/index.js

@@ -9,26 +9,43 @@ const RNSensorModule = NativeModules.RNSensorModule ? NativeModules.RNSensorModu
 });
 const emitter = new NativeEventEmitter(RNSensorModule);
 export default {
-  // Service Control
+  // --- SERVICE CONTROL ---
   startForegroundService: (title, body) => RNSensorModule.startForegroundService(title, body),
   stopForegroundService: () => RNSensorModule.stopForegroundService(),
   updateServiceNotification: (title, body) => RNSensorModule.updateServiceNotification(title, body),
-  // Sensors & Configuration
+  // --- MOTION DETECTION (ACTIVITY RECOGNITION) ---
+  // Note: Threshold is ignored by the new native engine, but kept for compatibility
   startMotionDetector: (threshold = 0.8) => RNSensorModule.startMotionDetector(threshold),
   stopMotionDetector: () => RNSensorModule.stopMotionDetector(),
-  setUpdateInterval: (ms = 100) => RNSensorModule.setUpdateInterval(ms),
+  // --- LOCATION CONTROL ---
   setLocationUpdateInterval: (ms = 90000) => RNSensorModule.setLocationUpdateInterval(ms),
-  setStabilityThresholds: (start = 20, stop = 3000) => RNSensorModule.setStabilityThresholds(start, stop),
-  // Alerts
+  // --- ALERTS ---
   fireGeofenceAlert: (type, userName) => RNSensorModule.fireGeofenceAlert(type, userName),
   fireGenericAlert: (title, body, id) => RNSensorModule.fireGenericAlert(title, body, id),
   cancelGenericAlert: id => RNSensorModule.cancelGenericAlert(id),
-  isAvailable: () => RNSensorModule.isAvailable(),
-  // --- NEW GPS HARDWARE METHODS ---
+  // --- GPS STATUS ---
   registerGpsListener: () => RNSensorModule.registerGpsListener(),
   addGpsStatusListener: cb => emitter.addListener('onGpsStatusChanged', event => cb(event)),
-  // Listeners
+  // --- EVENT LISTENERS ---
+
+  /**
+   * Returns: 
+   * { 
+   * activity: "WALKING" | "STILL" | "IN_VEHICLE" ...,
+   * isMoving: boolean,
+   * state: "MOVING" | "STATIONARY" (Legacy support)
+   * }
+   */
   addMotionListener: cb => emitter.addListener('onMotionStateChanged', cb),
+  /**
+   * Returns:
+   * {
+   * latitude: number,
+   * longitude: number,
+   * accuracy: number,
+   * is_mock: boolean (NEW: Detects Fake GPS)
+   * }
+   */
   addLocationLogListener: cb => emitter.addListener('onLocationLog', cb),
   addLocationErrorListener: cb => emitter.addListener('onLocationError', cb)
 };

package/lib/module/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["NativeModules","NativeEventEmitter","LINKING_ERROR","RNSensorModule","Proxy","get","Error","emitter","startForegroundService","title","body","stopForegroundService","updateServiceNotification","startMotionDetector","threshold","stopMotionDetector","setUpdateInterval","ms","setLocationUpdateInterval","setStabilityThresholds","start","stop","fireGeofenceAlert","type","userName","fireGenericAlert","id","cancelGenericAlert","isAvailable","registerGpsListener","addGpsStatusListener","cb","addListener","event","addMotionListener","addLocationLogListener","addLocationErrorListener"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":";;AAAA,SAASA,aAAa,EAAEC,kBAAkB,QAAQ,cAAc;AAEhE,MAAMC,aAAa,GACjB,wFAAwF,GACxF,sDAAsD,GACtD,+BAA+B;AAEjC,MAAMC,cAAc,GAAGH,aAAa,CAACG,cAAc,GAC/CH,aAAa,CAACG,cAAc,GAC5B,IAAIC,KAAK,CACP,CAAC,CAAC,EACF;EACEC,GAAGA,CAAA,EAAG;IACJ,MAAM,IAAIC,KAAK,CAACJ,aAAa,CAAC;EAChC;AACF,CACF,CAAC;AAEL,MAAMK,OAAO,GAAG,IAAIN,kBAAkB,CAACE,cAAc,CAAC;AAEtD,eAAe;EACb;EACAK,sBAAsB,EAAEA,CAACC,KAAa,EAAEC,IAAY,KAClDP,cAAc,CAACK,sBAAsB,CAACC,KAAK,EAAEC,IAAI,CAAC;EAEpDC,qBAAqB,EAAEA,CAAA,KACrBR,cAAc,CAACQ,qBAAqB,CAAC,CAAC;EAExCC,yBAAyB,EAAEA,CAACH,KAAa,EAAEC,IAAY,KACrDP,cAAc,CAACS,yBAAyB,CAACH,KAAK,EAAEC,IAAI,CAAC;EAEvD;EACAG,mBAAmB,EAAEA,CAACC,SAAiB,GAAG,GAAG,KAC3CX,cAAc,CAACU,mBAAmB,CAACC,SAAS,CAAC;EAE/CC,kBAAkB,EAAEA,CAAA,KAAMZ,cAAc,CAACY,kBAAkB,CAAC,CAAC;EAE7DC,iBAAiB,EAAEA,CAACC,EAAU,GAAG,GAAG,KAAKd,cAAc,CAACa,iBAAiB,CAACC,EAAE,CAAC;EAE7EC,yBAAyB,EAAEA,CAACD,EAAU,GAAG,KAAK,KAC5Cd,cAAc,CAACe,yBAAyB,CAACD,EAAE,CAAC;EAE9CE,sBAAsB,EAAEA,CAACC,KAAa,GAAG,EAAE,EAAEC,IAAY,GAAG,IAAI,KAC9DlB,cAAc,CAACgB,sBAAsB,CAACC,KAAK,EAAEC,IAAI,CAAC;EAEpD;EACAC,iBAAiB,EAAEA,CAACC,IAAY,EAAEC,QAAgB,KAChDrB,cAAc,CAACmB,iBAAiB,CAACC,IAAI,EAAEC,QAAQ,CAAC;EAElDC,gBAAgB,EAAEA,CAAChB,KAAa,EAAEC,IAAY,EAAEgB,EAAU,KACxDvB,cAAc,CAACsB,gBAAgB,CAAChB,KAAK,EAAEC,IAAI,EAAEgB,EAAE,CAAC;EAElDC,kBAAkB,EAAGD,EAAU,IAAKvB,cAAc,CAACwB,kBAAkB,CAACD,EAAE,CAAC;EAEzEE,WAAW,EAAEA,CAAA,KAAMzB,cAAc,CAACyB,WAAW,CAAC,CAAC;EAE/C;EACAC,mBAAmB,EAAEA,CAAA,KACnB1B,cAAc,CAAC0B,mBAAmB,CAAC,CAAC;EAEtCC,oBAAoB,EAAGC,EAAyC,IAC9DxB,OAAO,CAACyB,WAAW,CAAC,oBAAoB,EAAGC,KAAU,IAAKF,EAAE,CAACE,KAAK,CAAC,CAAC;EAEtE;EACAC,iBAAiB,EAAGH,EAAwB,IAC1CxB,OAAO,CAACyB,WAAW,CAAC,sBAAsB,EAAED,EAAE,CAAC;EAEjDI,sBAAsB,EAAGJ,EAAwB,IAC/CxB,OAAO,CAACyB,WAAW,CAAC,eAAe,EAAED,EAAE,CAAC;EAE1CK,wBAAwB,EAAGL,EAAwB,IACjDxB,OAAO,CAACyB,WAAW,CAAC,iBAAiB,EAAED,EAAE;AAC7C,CAAC","ignoreList":[]}
+{"version":3,"names":["NativeModules","NativeEventEmitter","LINKING_ERROR","RNSensorModule","Proxy","get","Error","emitter","startForegroundService","title","body","stopForegroundService","updateServiceNotification","startMotionDetector","threshold","stopMotionDetector","setLocationUpdateInterval","ms","fireGeofenceAlert","type","userName","fireGenericAlert","id","cancelGenericAlert","registerGpsListener","addGpsStatusListener","cb","addListener","event","addMotionListener","addLocationLogListener","addLocationErrorListener"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":";;AAAA,SAASA,aAAa,EAAEC,kBAAkB,QAAQ,cAAc;AAEhE,MAAMC,aAAa,GACjB,wFAAwF,GACxF,sDAAsD,GACtD,+BAA+B;AAEjC,MAAMC,cAAc,GAAGH,aAAa,CAACG,cAAc,GAC/CH,aAAa,CAACG,cAAc,GAC5B,IAAIC,KAAK,CACP,CAAC,CAAC,EACF;EACEC,GAAGA,CAAA,EAAG;IACJ,MAAM,IAAIC,KAAK,CAACJ,aAAa,CAAC;EAChC;AACF,CACF,CAAC;AAEL,MAAMK,OAAO,GAAG,IAAIN,kBAAkB,CAACE,cAAc,CAAC;AAEtD,eAAe;EACb;EACAK,sBAAsB,EAAEA,CAACC,KAAa,EAAEC,IAAY,KAClDP,cAAc,CAACK,sBAAsB,CAACC,KAAK,EAAEC,IAAI,CAAC;EAEpDC,qBAAqB,EAAEA,CAAA,KACrBR,cAAc,CAACQ,qBAAqB,CAAC,CAAC;EAExCC,yBAAyB,EAAEA,CAACH,KAAa,EAAEC,IAAY,KACrDP,cAAc,CAACS,yBAAyB,CAACH,KAAK,EAAEC,IAAI,CAAC;EAEvD;EACA;EACAG,mBAAmB,EAAEA,CAACC,SAAiB,GAAG,GAAG,KAC3CX,cAAc,CAACU,mBAAmB,CAACC,SAAS,CAAC;EAE/CC,kBAAkB,EAAEA,CAAA,KAClBZ,cAAc,CAACY,kBAAkB,CAAC,CAAC;EAErC;EACAC,yBAAyB,EAAEA,CAACC,EAAU,GAAG,KAAK,KAC5Cd,cAAc,CAACa,yBAAyB,CAACC,EAAE,CAAC;EAE9C;EACAC,iBAAiB,EAAEA,CAACC,IAAY,EAAEC,QAAgB,KAChDjB,cAAc,CAACe,iBAAiB,CAACC,IAAI,EAAEC,QAAQ,CAAC;EAElDC,gBAAgB,EAAEA,CAACZ,KAAa,EAAEC,IAAY,EAAEY,EAAU,KACxDnB,cAAc,CAACkB,gBAAgB,CAACZ,KAAK,EAAEC,IAAI,EAAEY,EAAE,CAAC;EAElDC,kBAAkB,EAAGD,EAAU,IAC7BnB,cAAc,CAACoB,kBAAkB,CAACD,EAAE,CAAC;EAEvC;EACAE,mBAAmB,EAAEA,CAAA,KACnBrB,cAAc,CAACqB,mBAAmB,CAAC,CAAC;EAEtCC,oBAAoB,EAAGC,EAAyC,IAC9DnB,OAAO,CAACoB,WAAW,CAAC,oBAAoB,EAAGC,KAAU,IAAKF,EAAE,CAACE,KAAK,CAAC,CAAC;EAEtE;;EAEA;AACF;AACA;AACA;AACA;AACA;AACA;AACA;EACEC,iBAAiB,EAAGH,EAAwB,IAC1CnB,OAAO,CAACoB,WAAW,CAAC,sBAAsB,EAAED,EAAE,CAAC;EAEjD;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACEI,sBAAsB,EAAGJ,EAAwB,IAC/CnB,OAAO,CAACoB,WAAW,CAAC,eAAe,EAAED,EAAE,CAAC;EAE1CK,wBAAwB,EAAGL,EAAwB,IACjDnB,OAAO,CAACoB,WAAW,CAAC,iBAAiB,EAAED,EAAE;AAC7C,CAAC","ignoreList":[]}

package/lib/typescript/src/index.d.ts

@@ -2,20 +2,34 @@ declare const _default: {
     startForegroundService: (title: string, body: string) => Promise<boolean>;
     stopForegroundService: () => Promise<boolean>;
     updateServiceNotification: (title: string, body: string) => Promise<boolean>;
-    startMotionDetector: (threshold?: number) => any;
-    stopMotionDetector: () => any;
-    setUpdateInterval: (ms?: number) => any;
+    startMotionDetector: (threshold?: number) => Promise<boolean>;
+    stopMotionDetector: () => Promise<boolean>;
     setLocationUpdateInterval: (ms?: number) => any;
-    setStabilityThresholds: (start?: number, stop?: number) => any;
-    fireGeofenceAlert: (type: string, userName: string) => any;
-    fireGenericAlert: (title: string, body: string, id: number) => any;
-    cancelGenericAlert: (id: number) => any;
-    isAvailable: () => any;
+    fireGeofenceAlert: (type: string, userName: string) => Promise<boolean>;
+    fireGenericAlert: (title: string, body: string, id: number) => Promise<boolean>;
+    cancelGenericAlert: (id: number) => Promise<boolean>;
     registerGpsListener: () => Promise<boolean>;
     addGpsStatusListener: (cb: (event: {
         enabled: boolean;
     }) => void) => import("react-native").EventSubscription;
+    /**
+     * Returns:
+     * {
+     * activity: "WALKING" | "STILL" | "IN_VEHICLE" ...,
+     * isMoving: boolean,
+     * state: "MOVING" | "STATIONARY" (Legacy support)
+     * }
+     */
     addMotionListener: (cb: (event: any) => void) => import("react-native").EventSubscription;
+    /**
+     * Returns:
+     * {
+     * latitude: number,
+     * longitude: number,
+     * accuracy: number,
+     * is_mock: boolean (NEW: Detects Fake GPS)
+     * }
+     */
     addLocationLogListener: (cb: (event: any) => void) => import("react-native").EventSubscription;
     addLocationErrorListener: (cb: (event: any) => void) => import("react-native").EventSubscription;
 };

package/lib/typescript/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.tsx"],"names":[],"mappings":";oCAsBkC,MAAM,QAAQ,MAAM,KAAG,OAAO,CAAC,OAAO,CAAC;iCAG5C,OAAO,CAAC,OAAO,CAAC;uCAGR,MAAM,QAAQ,MAAM,KAAG,OAAO,CAAC,OAAO,CAAC;sCAIzC,MAAM;;6BAKf,MAAM;qCAEE,MAAM;qCAGN,MAAM,SAAa,MAAM;8BAI/B,MAAM,YAAY,MAAM;8BAGxB,MAAM,QAAQ,MAAM,MAAM,MAAM;6BAGjC,MAAM;;+BAKN,OAAO,CAAC,OAAO,CAAC;+BAGd,CAAC,KAAK,EAAE;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,KAAK,IAAI;4BAIxC,CAAC,KAAK,EAAE,GAAG,KAAK,IAAI;iCAGf,CAAC,KAAK,EAAE,GAAG,KAAK,IAAI;mCAGlB,CAAC,KAAK,EAAE,GAAG,KAAK,IAAI;;AAlDrD,wBAoDE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.tsx"],"names":[],"mappings":";oCAsBkC,MAAM,QAAQ,MAAM,KAAG,OAAO,CAAC,OAAO,CAAC;iCAG5C,OAAO,CAAC,OAAO,CAAC;uCAGR,MAAM,QAAQ,MAAM,KAAG,OAAO,CAAC,OAAO,CAAC;sCAKzC,MAAM,KAAS,OAAO,CAAC,OAAO,CAAC;8BAGxC,OAAO,CAAC,OAAO,CAAC;qCAIR,MAAM;8BAIZ,MAAM,YAAY,MAAM,KAAG,OAAO,CAAC,OAAO,CAAC;8BAG3C,MAAM,QAAQ,MAAM,MAAM,MAAM,KAAG,OAAO,CAAC,OAAO,CAAC;6BAGpD,MAAM,KAAG,OAAO,CAAC,OAAO,CAAC;+BAIzB,OAAO,CAAC,OAAO,CAAC;+BAGd,CAAC,KAAK,EAAE;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,KAAK,IAAI;IAKhE;;;;;;;OAOG;4BACqB,CAAC,KAAK,EAAE,GAAG,KAAK,IAAI;IAG5C;;;;;;;;OAQG;iCAC0B,CAAC,KAAK,EAAE,GAAG,KAAK,IAAI;mCAGlB,CAAC,KAAK,EAAE,GAAG,KAAK,IAAI;;AAjErD,wBAmEE"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-geo-activity-kit",
-  "version": "1.2.4",
+  "version": "1.2.5",
   "description": "Battery-efficient location tracking with motion detection and native notifications.",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",

package/src/index.tsx

@@ -19,7 +19,7 @@ const RNSensorModule = NativeModules.RNSensorModule
 const emitter = new NativeEventEmitter(RNSensorModule);
 
 export default {
-  // Service Control
+  // --- SERVICE CONTROL ---
   startForegroundService: (title: string, body: string): Promise<boolean> =>
     RNSensorModule.startForegroundService(title, body),
 
@@ -29,45 +29,60 @@ export default {
   updateServiceNotification: (title: string, body: string): Promise<boolean> =>
     RNSensorModule.updateServiceNotification(title, body),
 
-  // Sensors & Configuration
-  startMotionDetector: (threshold: number = 0.8) =>
+  // --- MOTION DETECTION (ACTIVITY RECOGNITION) ---
+  // Note: Threshold is ignored by the new native engine, but kept for compatibility
+  startMotionDetector: (threshold: number = 0.8): Promise<boolean> =>
     RNSensorModule.startMotionDetector(threshold),
 
-  stopMotionDetector: () => RNSensorModule.stopMotionDetector(),
-
-  setUpdateInterval: (ms: number = 100) => RNSensorModule.setUpdateInterval(ms),
+  stopMotionDetector: (): Promise<boolean> => 
+    RNSensorModule.stopMotionDetector(),
 
+  // --- LOCATION CONTROL ---
   setLocationUpdateInterval: (ms: number = 90000) =>
     RNSensorModule.setLocationUpdateInterval(ms),
 
-  setStabilityThresholds: (start: number = 20, stop: number = 3000) =>
-    RNSensorModule.setStabilityThresholds(start, stop),
-
-  // Alerts
-  fireGeofenceAlert: (type: string, userName: string) =>
+  // --- ALERTS ---
+  fireGeofenceAlert: (type: string, userName: string): Promise<boolean> =>
     RNSensorModule.fireGeofenceAlert(type, userName),
 
-  fireGenericAlert: (title: string, body: string, id: number) =>
+  fireGenericAlert: (title: string, body: string, id: number): Promise<boolean> =>
     RNSensorModule.fireGenericAlert(title, body, id),
 
-  cancelGenericAlert: (id: number) => RNSensorModule.cancelGenericAlert(id),
-
-  isAvailable: () => RNSensorModule.isAvailable(),
+  cancelGenericAlert: (id: number): Promise<boolean> => 
+    RNSensorModule.cancelGenericAlert(id),
 
-  // --- NEW GPS HARDWARE METHODS ---
+  // --- GPS STATUS ---
   registerGpsListener: (): Promise<boolean> =>
     RNSensorModule.registerGpsListener(),
 
   addGpsStatusListener: (cb: (event: { enabled: boolean }) => void) =>
     emitter.addListener('onGpsStatusChanged', (event: any) => cb(event)),
 
-  // Listeners
+  // --- EVENT LISTENERS ---
+  
+  /**
+   * Returns: 
+   * { 
+   * activity: "WALKING" | "STILL" | "IN_VEHICLE" ...,
+   * isMoving: boolean,
+   * state: "MOVING" | "STATIONARY" (Legacy support)
+   * }
+   */
   addMotionListener: (cb: (event: any) => void) =>
     emitter.addListener('onMotionStateChanged', cb),
 
+  /**
+   * Returns:
+   * {
+   * latitude: number,
+   * longitude: number,
+   * accuracy: number,
+   * is_mock: boolean (NEW: Detects Fake GPS)
+   * }
+   */
   addLocationLogListener: (cb: (event: any) => void) =>
     emitter.addListener('onLocationLog', cb),
 
   addLocationErrorListener: (cb: (event: any) => void) =>
     emitter.addListener('onLocationError', cb),
-};
+};

package/lib/module/NativeGeoActivityKit.js

@@ -1,5 +0,0 @@
-"use strict";
-
-import { TurboModuleRegistry } from 'react-native';
-export default TurboModuleRegistry.getEnforcing('GeoActivityKit');
-//# sourceMappingURL=NativeGeoActivityKit.js.map

package/lib/module/NativeGeoActivityKit.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["TurboModuleRegistry","getEnforcing"],"sourceRoot":"../../src","sources":["NativeGeoActivityKit.ts"],"mappings":";;AAAA,SAASA,mBAAmB,QAA0B,cAAc;AAMpE,eAAeA,mBAAmB,CAACC,YAAY,CAAO,gBAAgB,CAAC","ignoreList":[]}

package/lib/typescript/src/NativeGeoActivityKit.d.ts

@@ -1,7 +0,0 @@
-import { type TurboModule } from 'react-native';
-export interface Spec extends TurboModule {
-    multiply(a: number, b: number): number;
-}
-declare const _default: Spec;
-export default _default;
-//# sourceMappingURL=NativeGeoActivityKit.d.ts.map

package/lib/typescript/src/NativeGeoActivityKit.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"NativeGeoActivityKit.d.ts","sourceRoot":"","sources":["../../../src/NativeGeoActivityKit.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuB,KAAK,WAAW,EAAE,MAAM,cAAc,CAAC;AAErE,MAAM,WAAW,IAAK,SAAQ,WAAW;IACvC,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;CACxC;;AAED,wBAAwE"}

package/src/NativeGeoActivityKit.ts

@@ -1,7 +0,0 @@
-import { TurboModuleRegistry, type TurboModule } from 'react-native';
-
-export interface Spec extends TurboModule {
-  multiply(a: number, b: number): number;
-}
-
-export default TurboModuleRegistry.getEnforcing<Spec>('GeoActivityKit');