react-native-geo-activity-kit 1.0.0

package/GeoActivityKit.podspec

@@ -0,0 +1,20 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "GeoActivityKit"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => min_ios_version_supported }
+  s.source       = { :git => "https://github.com/kartikeycsjm/react-native-geo-activity-kit.git", :tag => "#{s.version}" }
+
+  s.source_files = "ios/**/*.{h,m,mm,swift,cpp}"
+  s.private_header_files = "ios/**/*.h"
+
+  install_modules_dependencies(s)
+end

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) 2025 Kartikey Mishra
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,15 @@
+# react-native-geo-activity-kit
+
+A battery-efficient background location tracker that uses the accelerometer to stop GPS when the device is stationary. It also includes a built-in notification engine for sticky services and alerts.
+
+## Features
+
+* **🔋 Battery Efficient:** Automatically toggles GPS off when the device stops moving.
+* **🏃 Motion Detection:** Exposes raw motion state ("MOVING" vs "STATIONARY").
+* **🔔 Native Notifications:** Built-in engine for local alerts and foreground services.
+* **📍 Fused Location:** Uses Google's FusedLocationProvider for high accuracy.
+
+## Installation
+
+```sh
+npm install react-native-geo-activity-kit

package/android/build.gradle

@@ -0,0 +1,78 @@
+buildscript {
+  ext.getExtOrDefault = {name ->
+    return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties['GeoActivityKit_' + name]
+  }
+
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.7.2"
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${getExtOrDefault('kotlinVersion')}"
+  }
+}
+
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+
+apply plugin: "com.facebook.react"
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["GeoActivityKit_" + name]).toInteger()
+}
+
+android {
+  namespace "com.rngeoactivitykit"
+
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+  }
+
+  buildFeatures {
+    buildConfig true
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+
+  sourceSets {
+    main {
+      java.srcDirs += [
+        "generated/java",
+        "generated/jni"
+      ]
+    }
+  }
+}
+
+repositories {
+  mavenCentral()
+  google()
+}
+
+def kotlin_version = getExtOrDefault("kotlinVersion")
+
+dependencies {
+  implementation "com.facebook.react:react-android"
+  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+  implementation "com.google.android.gms:play-services-location:21.3.0"
+}

package/android/gradle.properties

@@ -0,0 +1,5 @@
+GeoActivityKit_kotlinVersion=2.0.21
+GeoActivityKit_minSdkVersion=24
+GeoActivityKit_targetSdkVersion=34
+GeoActivityKit_compileSdkVersion=35
+GeoActivityKit_ndkVersion=27.1.12297006

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,13 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
+    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
+
+    <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
+
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_LOCATION" />
+
+    <uses-permission android:name="android.permission.WAKE_LOCK" />
+
+    </manifest>

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

@@ -0,0 +1,410 @@
+package com.rngeoactivitykit
+
+import android.Manifest
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.app.PendingIntent
+import android.content.pm.PackageManager
+import android.os.Build
+import androidx.core.app.NotificationCompat
+import androidx.core.content.ContextCompat
+import android.app.Notification
+import android.annotation.SuppressLint
+import android.content.Context
+import android.hardware.Sensor
+import android.hardware.SensorEvent
+import android.hardware.SensorEventListener
+import android.hardware.SensorManager
+import android.os.Looper
+import android.util.Log
+import com.facebook.react.bridge.*
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.google.android.gms.location.*
+import com.google.android.gms.location.LocationCallback
+import com.google.android.gms.location.LocationRequest
+import com.google.android.gms.location.LocationResult
+import java.util.Date
+import java.text.SimpleDateFormat
+import java.util.TimeZone
+import kotlin.math.sqrt
+
+class SensorModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext), SensorEventListener {
+    private val sensorManager: SensorManager = reactContext.getSystemService(Context.SENSOR_SERVICE) as SensorManager
+    private var accelerometer: Sensor? = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER)
+
+    private lateinit var fusedLocationClient: FusedLocationProviderClient
+    private var locationCallback: LocationCallback
+    private lateinit var locationRequest: LocationRequest
+    @Volatile private var locationInterval: Long = 90000 
+    private var isLocationClientRunning: Boolean = false
+
+    private val gravity = floatArrayOf(0f, 0f, 0f)
+    private val linearAcceleration = floatArrayOf(0f, 0f, 0f)
+    private val alpha: Float = 0.8f
+    @Volatile private var motionThreshold: Float = 0.8f
+    @Volatile private var currentState: String = "STATIONARY"
+    private var isMotionDetectorStarted: Boolean = false
+    @Volatile private var potentialState: String = "STATIONARY"
+    @Volatile private var consecutiveCount = 0
+
+    @Volatile private var startStabilityThreshold: Int = 20
+    @Volatile private var stopStabilityThreshold: Int = 3000
+    @Volatile private var samplingPeriodUs: Int = 100_000 
+
+    private val isoFormatter: SimpleDateFormat = SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'").apply {
+        timeZone = TimeZone.getTimeZone("UTC")
+    }
+
+    private val notificationManager: NotificationManager =
+        reactContext.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+    private val GEOFENCE_CHANNEL_ID = "geofence-channel-id"
+    private val GEOFENCE_OUT_ID = 101 
+    private val GEOFENCE_IN_ID = 102 
+    
+   
+    private val appIcon: Int = reactApplicationContext.applicationInfo.icon.let {
+        if (it != 0) it else android.R.drawable.ic_dialog_info 
+    }
+
+    init {
+        fusedLocationClient = LocationServices.getFusedLocationProviderClient(reactContext)
+        
+        updateLocationRequest()
+        locationCallback = object : LocationCallback() {
+            override fun onLocationResult(locationResult: LocationResult) {
+                locationResult.lastLocation ?: return
+                
+                val location = locationResult.lastLocation!!
+                val params = Arguments.createMap()
+                params.putDouble("latitude", location.latitude)
+                params.putDouble("longitude", location.longitude)
+                params.putString("timestamp", isoFormatter.format(Date(location.time)))
+                
+                emitEvent(reactApplicationContext, "onLocationLog", params)
+            }
+        }
+        
+        createNotificationChannel()
+    }
+
+    private fun createNotificationChannel() {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            val name = "Geofence Alerts" 
+            val descriptionText = "Notifications for geofence and work reminders."
+            val importance = NotificationManager.IMPORTANCE_HIGH
+            val channel = NotificationChannel(GEOFENCE_CHANNEL_ID, name, importance).apply {
+
+                description = descriptionText
+                lockscreenVisibility = Notification.VISIBILITY_PUBLIC
+                enableVibration(true)
+                vibrationPattern = longArrayOf(300, 500)
+            }
+            notificationManager.createNotificationChannel(channel)
+        }
+    }
+
+    private fun updateLocationRequest() {
+        locationRequest = LocationRequest.create().apply {
+            interval = locationInterval
+            fastestInterval = locationInterval
+            priority = Priority.PRIORITY_HIGH_ACCURACY
+        }
+    }
+    
+    override fun getName(): String = "RNSensorModule"
+
+
+    override fun onSensorChanged(event: SensorEvent?) {
+        event ?: return
+        if (event.sensor.type == Sensor.TYPE_ACCELEROMETER && isMotionDetectorStarted) {
+            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]
+            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
+                
+                if (currentState == "MOVING") {
+                    startLocationUpdates()
+                } else {
+                    stopLocationUpdates()
+                }
+                val params = Arguments.createMap()
+                params.putString("state", currentState)
+                emitEvent(reactApplicationContext, "onMotionStateChanged", params)
+            }
+        }
+    }
+
+    override fun onAccuracyChanged(sensor: Sensor?, accuracy: Int) {
+
+    }
+
+    private fun hasLocationPermission(): Boolean {
+        val finePermission = ContextCompat.checkSelfPermission(
+            reactApplicationContext,
+            Manifest.permission.ACCESS_FINE_LOCATION
+        )
+        val coarsePermission = ContextCompat.checkSelfPermission(
+            reactApplicationContext,
+            Manifest.permission.ACCESS_COARSE_LOCATION
+        )
+        return finePermission == PackageManager.PERMISSION_GRANTED || coarsePermission == PackageManager.PERMISSION_GRANTED
+    }
+
+
+    @ReactMethod
+    fun startMotionDetector(threshold: Double, promise: Promise) {
+        if (accelerometer == null) {
+            promise.reject("NO_SENSOR", "Accelerometer not available on this device")
+            return
+        }
+        motionThreshold = threshold.toFloat()
+        isMotionDetectorStarted = true
+        currentState = "STATIONARY" 
+        potentialState = "STATIONARY"
+        consecutiveCount = 0
+        sensorManager.registerListener(this, accelerometer, samplingPeriodUs)
+        
+        promise.resolve(true)
+    }
+
+    @ReactMethod
+    fun stopMotionDetector(promise: Promise) {
+        isMotionDetectorStarted = false
+        sensorManager.unregisterListener(this, accelerometer)
+        stopLocationUpdates()
+        
+        promise.resolve(true)
+    }
+
+    @ReactMethod
+    fun setLocationUpdateInterval(interval: Double, promise: Promise) {
+        locationInterval = interval.toLong()
+        updateLocationRequest()
+        
+        if (isLocationClientRunning) {
+            stopLocationUpdates()
+            startLocationUpdates()
+        }
+        promise.resolve(true)
+    }
+    
+    @ReactMethod
+    fun setStabilityThresholds(startThreshold: Int, stopThreshold: Int, promise: Promise) {
+        try {
+            startStabilityThreshold = startThreshold.coerceAtLeast(1)
+            stopStabilityThreshold = stopThreshold.coerceAtLeast(1)
+            promise.resolve(true)
+        } catch (e: Exception) {
+            promise.reject("CONFIG_ERROR", "Failed to set stability thresholds: ${e.message}")
+        }
+    }
+
+    @ReactMethod
+    fun setUpdateInterval(ms: Int, promise: Promise) {
+        samplingPeriodUs = ms.coerceAtLeast(100) * 1000 
+        
+        if (isMotionDetectorStarted) {
+            sensorManager.unregisterListener(this, accelerometer)
+            sensorManager.registerListener(this, accelerometer, samplingPeriodUs)
+        }
+        promise.resolve(true)
+    }
+    
+    @ReactMethod
+    fun isAvailable(promise: Promise) {
+        val map = Arguments.createMap()
+        map.putBoolean("accelerometer", accelerometer != null)
+        map.putBoolean("gyroscope", false) 
+        promise.resolve(map)
+    }
+    
+
+    @SuppressLint("MissingPermission")
+    private 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. Please request permission from the user.")
+            emitEvent(reactApplicationContext, "onLocationError", params)
+            Log.w("SensorModule", "Location permission denied.")
+            return
+        }
+        try {
+            fusedLocationClient.requestLocationUpdates(
+                locationRequest,
+                locationCallback,
+                Looper.getMainLooper()
+            )
+            isLocationClientRunning = true
+            Log.i("SensorModule", "Location updates started.")
+        } catch (e: Exception) {
+            Log.e("SensorModule", "Failed to start location updates: " + e.message)
+            val params = Arguments.createMap()
+            params.putString("error", "START_LOCATION_FAILED")
+            params.putString("message", "An unexpected error occurred while starting location updates: ${e.message}")
+            emitEvent(reactApplicationContext, "onLocationError", params)
+        }
+    }
+
+    private fun stopLocationUpdates() {
+        if (!isLocationClientRunning) {
+            return
+        }
+        try {
+            fusedLocationClient.removeLocationUpdates(locationCallback)
+            isLocationClientRunning = false
+            Log.i("SensorModule", "Location updates stopped.")
+        } catch (e: Exception) {
+            Log.e("SensorModule", "Failed to stop location updates: " + e.message)
+        }
+    }
+
+    private fun emitEvent(reactContext: ReactContext, eventName: String, params: WritableMap?) {
+       if (reactContext.hasActiveCatalystInstance()) {
+            reactContext
+                .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                .emit(eventName, params)
+        } else {
+            Log.w("SensorModule", "Catalyst instance not active for event $eventName")
+        }
+    }
+
+
+    private fun createPendingIntent(requestCode: Int): PendingIntent? {
+        val launchIntent = reactApplicationContext.packageManager.getLaunchIntentForPackage(reactApplicationContext.packageName)
+        val pendingIntentFlag = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+            PendingIntent.FLAG_IMMUTABLE
+        } else {
+            PendingIntent.FLAG_UPDATE_CURRENT
+        }
+        
+        return launchIntent?.let {
+            PendingIntent.getActivity(
+                reactApplicationContext,
+                requestCode,
+                it,
+                pendingIntentFlag
+            )
+        }
+    }
+
+
+    @ReactMethod
+    fun fireGeofenceAlert(type: String, userName: String, promise: Promise) {
+        try {
+            val pendingIntent = createPendingIntent(0) 
+
+            if (type == "OUT") {
+                val notification = NotificationCompat.Builder(reactApplicationContext, GEOFENCE_CHANNEL_ID)
+                    .setSmallIcon(appIcon) 
+                    .setContentTitle("Geofence Alert 🔔")
+                    .setContentText("$userName, you seem to have moved out of your designated work area.")
+                    .setPriority(NotificationCompat.PRIORITY_HIGH)
+                    .setCategory(NotificationCompat.CATEGORY_ALARM)
+                    .setContentIntent(pendingIntent)
+                    .setOngoing(true) 
+                    .setAutoCancel(false)
+                    .setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
+                    .build()
+                
+                notificationManager.notify(GEOFENCE_OUT_ID, notification)
+
+            } else if (type == "IN") {
+               
+                notificationManager.cancel(GEOFENCE_OUT_ID)
+
+                
+                val notification = NotificationCompat.Builder(reactApplicationContext, GEOFENCE_CHANNEL_ID)
+                    .setSmallIcon(appIcon) 
+                    .setContentTitle("You are in again ✅")
+                    .setContentText("$userName, you have moved back into your designated work area.")
+                    .setPriority(NotificationCompat.PRIORITY_DEFAULT)
+                    .setContentIntent(pendingIntent)
+                    .setAutoCancel(true) 
+                    .setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
+                    .build()
+                
+                notificationManager.notify(GEOFENCE_IN_ID, notification)
+            }
+            promise.resolve(true)
+        } catch (e: Exception) {
+            Log.e("SensorModule", "Failed to fire notification: " + e.message)
+            promise.reject("NOTIFY_FAILED", e.message)
+        }
+    }
+    
+    @ReactMethod
+    fun fireGenericAlert(title: String, body: String, id: Int, promise: Promise) {
+        try {
+            val pendingIntent = createPendingIntent(id) 
+
+            val notification = NotificationCompat.Builder(reactApplicationContext, GEOFENCE_CHANNEL_ID)
+                .setSmallIcon(appIcon) 
+                .setContentTitle(title)
+                .setContentText(body)
+                .setPriority(NotificationCompat.PRIORITY_HIGH)
+                .setCategory(NotificationCompat.CATEGORY_REMINDER)
+                .setContentIntent(pendingIntent)
+                .setAutoCancel(true) 
+                .setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
+                .build()
+            
+            notificationManager.notify(id, notification)
+            
+            promise.resolve(true)
+        } catch (e: Exception) {
+            Log.e("SensorModule", "Failed to fire generic notification: " + e.message)
+            promise.reject("NOTIFY_FAILED", e.message)
+        }
+    }
+
+
+    @ReactMethod
+    fun cancelGenericAlert(id: Int, promise: Promise) {
+        try {
+            notificationManager.cancel(id)
+            promise.resolve(true)
+        } catch (e: Exception) {
+            Log.e("SensorModule", "Failed to cancel generic notification: " + e.message)
+            promise.reject("CANCEL_FAILED", e.message)
+        }
+    }
+
+    @ReactMethod
+    fun addListener(eventName: String) {}
+    @ReactMethod
+    fun removeListeners(count: Int) {}
+
+    override fun onCatalystInstanceDestroy() {
+        super.onCatalystInstanceDestroy()
+        Log.w("SensorModule", "onCatalystInstanceDestroy called, but sensors are being kept alive.")
+    }
+}

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

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

package/ios/GeoActivityKit.h

@@ -0,0 +1,5 @@
+#import <GeoActivityKitSpec/GeoActivityKitSpec.h>
+
+@interface GeoActivityKit : NSObject <NativeGeoActivityKitSpec>
+
+@end

package/ios/GeoActivityKit.mm

@@ -0,0 +1,21 @@
+#import "GeoActivityKit.h"
+
+@implementation GeoActivityKit
+- (NSNumber *)multiply:(double)a b:(double)b {
+    NSNumber *result = @(a * b);
+
+    return result;
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params
+{
+    return std::make_shared<facebook::react::NativeGeoActivityKitSpecJSI>(params);
+}
+
++ (NSString *)moduleName
+{
+  return @"GeoActivityKit";
+}
+
+@end

package/lib/module/NativeGeoActivityKit.js

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

package/lib/module/NativeGeoActivityKit.js.map

@@ -0,0 +1 @@
+{"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/module/index.js

@@ -0,0 +1,34 @@
+"use strict";
+
+import { NativeModules, NativeEventEmitter, Platform } from 'react-native';
+const LINKING_ERROR = `The package 'react-native-geo-activity-kit' doesn't seem to be linked. Make sure: \n\n` + Platform.select({
+  ios: "- You have run 'pod install'\n",
+  default: ''
+}) + '- You rebuilt the app after installing the package\n' + '- You are not using Expo Go\n';
+
+// The name must match getName() in SensorModule.kt
+const RNSensorModule = NativeModules.RNSensorModule ? NativeModules.RNSensorModule : new Proxy({}, {
+  get() {
+    throw new Error(LINKING_ERROR);
+  }
+});
+const emitter = new NativeEventEmitter(RNSensorModule);
+export default {
+  startMotionDetector: (threshold = 0.8) => RNSensorModule.startMotionDetector(threshold),
+  stopMotionDetector: () => RNSensorModule.stopMotionDetector(),
+  setUpdateInterval: (ms = 100) => RNSensorModule.setUpdateInterval(ms),
+  setLocationUpdateInterval: (ms = 90000) => RNSensorModule.setLocationUpdateInterval(ms),
+  setStabilityThresholds: (startThreshold = 20, stopThreshold = 3000) => RNSensorModule.setStabilityThresholds(startThreshold, stopThreshold),
+  // Added types: string for text inputs
+  fireGeofenceAlert: (type, userName) => RNSensorModule.fireGeofenceAlert(type, userName),
+  // Added types: string for text, number for ID (assuming Android notification ID)
+  fireGenericAlert: (title, body, id) => RNSensorModule.fireGenericAlert(title, body, id),
+  // Added type: number to match the ID above
+  cancelGenericAlert: id => RNSensorModule.cancelGenericAlert(id),
+  isAvailable: () => RNSensorModule.isAvailable(),
+  // Added type: function that accepts an event (any)
+  addMotionListener: cb => emitter.addListener('onMotionStateChanged', cb),
+  addLocationLogListener: cb => emitter.addListener('onLocationLog', cb),
+  addLocationErrorListener: cb => emitter.addListener('onLocationError', cb)
+};
+//# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["NativeModules","NativeEventEmitter","Platform","LINKING_ERROR","select","ios","default","RNSensorModule","Proxy","get","Error","emitter","startMotionDetector","threshold","stopMotionDetector","setUpdateInterval","ms","setLocationUpdateInterval","setStabilityThresholds","startThreshold","stopThreshold","fireGeofenceAlert","type","userName","fireGenericAlert","title","body","id","cancelGenericAlert","isAvailable","addMotionListener","cb","addListener","addLocationLogListener","addLocationErrorListener"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":";;AAAA,SAASA,aAAa,EAAEC,kBAAkB,EAAEC,QAAQ,QAAQ,cAAc;AAE1E,MAAMC,aAAa,GACjB,wFAAwF,GACxFD,QAAQ,CAACE,MAAM,CAAC;EAAEC,GAAG,EAAE,gCAAgC;EAAEC,OAAO,EAAE;AAAG,CAAC,CAAC,GACvE,sDAAsD,GACtD,+BAA+B;;AAEjC;AACA,MAAMC,cAAc,GAAGP,aAAa,CAACO,cAAc,GAC/CP,aAAa,CAACO,cAAc,GAC5B,IAAIC,KAAK,CACP,CAAC,CAAC,EACF;EACEC,GAAGA,CAAA,EAAG;IACJ,MAAM,IAAIC,KAAK,CAACP,aAAa,CAAC;EAChC;AACF,CACF,CAAC;AAEL,MAAMQ,OAAO,GAAG,IAAIV,kBAAkB,CAACM,cAAc,CAAC;AAEtD,eAAe;EACbK,mBAAmB,EAAEA,CAACC,SAAiB,GAAG,GAAG,KAC3CN,cAAc,CAACK,mBAAmB,CAACC,SAAS,CAAC;EAE/CC,kBAAkB,EAAEA,CAAA,KAClBP,cAAc,CAACO,kBAAkB,CAAC,CAAC;EAErCC,iBAAiB,EAAEA,CAACC,EAAU,GAAG,GAAG,KAClCT,cAAc,CAACQ,iBAAiB,CAACC,EAAE,CAAC;EAEtCC,yBAAyB,EAAEA,CAACD,EAAU,GAAG,KAAK,KAC5CT,cAAc,CAACU,yBAAyB,CAACD,EAAE,CAAC;EAE9CE,sBAAsB,EAAEA,CAACC,cAAsB,GAAG,EAAE,EAAEC,aAAqB,GAAG,IAAI,KAChFb,cAAc,CAACW,sBAAsB,CAACC,cAAc,EAAEC,aAAa,CAAC;EAEtE;EACAC,iBAAiB,EAAEA,CAACC,IAAY,EAAEC,QAAgB,KAChDhB,cAAc,CAACc,iBAAiB,CAACC,IAAI,EAAEC,QAAQ,CAAC;EAElD;EACAC,gBAAgB,EAAEA,CAACC,KAAa,EAAEC,IAAY,EAAEC,EAAU,KACxDpB,cAAc,CAACiB,gBAAgB,CAACC,KAAK,EAAEC,IAAI,EAAEC,EAAE,CAAC;EAElD;EACAC,kBAAkB,EAAGD,EAAU,IAC7BpB,cAAc,CAACqB,kBAAkB,CAACD,EAAE,CAAC;EAEvCE,WAAW,EAAEA,CAAA,KACXtB,cAAc,CAACsB,WAAW,CAAC,CAAC;EAE9B;EACAC,iBAAiB,EAAGC,EAAwB,IAC1CpB,OAAO,CAACqB,WAAW,CAAC,sBAAsB,EAAED,EAAE,CAAC;EAEjDE,sBAAsB,EAAGF,EAAwB,IAC/CpB,OAAO,CAACqB,WAAW,CAAC,eAAe,EAAED,EAAE,CAAC;EAE1CG,wBAAwB,EAAGH,EAAwB,IACjDpB,OAAO,CAACqB,WAAW,CAAC,iBAAiB,EAAED,EAAE;AAC7C,CAAC","ignoreList":[]}

package/lib/module/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/typescript/package.json

@@ -0,0 +1 @@
+{"type":"module"}

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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1 @@
+{"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/lib/typescript/src/index.d.ts

@@ -0,0 +1,16 @@
+declare const _default: {
+    startMotionDetector: (threshold?: number) => any;
+    stopMotionDetector: () => any;
+    setUpdateInterval: (ms?: number) => any;
+    setLocationUpdateInterval: (ms?: number) => any;
+    setStabilityThresholds: (startThreshold?: number, stopThreshold?: number) => any;
+    fireGeofenceAlert: (type: string, userName: string) => any;
+    fireGenericAlert: (title: string, body: string, id: number) => any;
+    cancelGenericAlert: (id: number) => any;
+    isAvailable: () => any;
+    addMotionListener: (cb: (event: any) => void) => import("react-native").EventSubscription;
+    addLocationLogListener: (cb: (event: any) => void) => import("react-native").EventSubscription;
+    addLocationErrorListener: (cb: (event: any) => void) => import("react-native").EventSubscription;
+};
+export default _default;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.tsx"],"names":[],"mappings":";sCAuBmC,MAAM;;6BAMf,MAAM;qCAGE,MAAM;8CAGG,MAAM,kBAAsB,MAAM;8BAIjD,MAAM,YAAY,MAAM;8BAIxB,MAAM,QAAQ,MAAM,MAAM,MAAM;6BAIjC,MAAM;;4BAOP,CAAC,KAAK,EAAE,GAAG,KAAK,IAAI;iCAGf,CAAC,KAAK,EAAE,GAAG,KAAK,IAAI;mCAGlB,CAAC,KAAK,EAAE,GAAG,KAAK,IAAI;;AAtCrD,wBAwCE"}

package/package.json

@@ -0,0 +1,175 @@
+{
+  "name": "react-native-geo-activity-kit",
+  "version": "1.0.0",
+  "description": "Battery-efficient location tracking with motion detection and native notifications.",
+  "main": "./lib/module/index.js",
+  "types": "./lib/typescript/src/index.d.ts",
+  "exports": {
+    ".": {
+      "source": "./src/index.tsx",
+      "types": "./lib/typescript/src/index.d.ts",
+      "default": "./lib/module/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "src",
+    "lib",
+    "android",
+    "ios",
+    "cpp",
+    "*.podspec",
+    "react-native.config.js",
+    "!ios/build",
+    "!android/build",
+    "!android/gradle",
+    "!android/gradlew",
+    "!android/gradlew.bat",
+    "!android/local.properties",
+    "!**/__tests__",
+    "!**/__fixtures__",
+    "!**/__mocks__",
+    "!**/.*"
+  ],
+  "scripts": {
+    "example": "yarn workspace react-native-geo-activity-kit-example",
+    "clean": "del-cli android/build example/android/build example/android/app/build example/ios/build lib",
+    "prepare": "bob build",
+    "typecheck": "tsc",
+    "lint": "eslint \"**/*.{js,ts,tsx}\"",
+    "release": "release-it --only-version",
+    "test": "jest"
+  },
+  "keywords": [
+    "react-native",
+    "location",
+    "geofence",
+    "background-service",
+    "motion-detection",
+    "accelerometer",
+    "android",
+    "battery-efficient"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kartikeycsjm/react-native-geo-activity-kit.git"
+  },
+  "author": "Kartikey Mishra <kartikeymishracsjm@gmail.com> (https://github.com/kartikeycsjm)",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/kartikeycsjm/react-native-geo-activity-kit/issues"
+  },
+  "homepage": "https://github.com/kartikeycsjm/react-native-geo-activity-kit#readme",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  },
+  "devDependencies": {
+    "@commitlint/config-conventional": "^19.8.1",
+    "@eslint/compat": "^1.3.2",
+    "@eslint/eslintrc": "^3.3.1",
+    "@eslint/js": "^9.35.0",
+    "@react-native-community/cli": "20.0.1",
+    "@react-native/babel-preset": "0.81.1",
+    "@react-native/eslint-config": "^0.81.1",
+    "@release-it/conventional-changelog": "^10.0.1",
+    "@types/jest": "^29.5.14",
+    "@types/react": "^19.1.0",
+    "commitlint": "^19.8.1",
+    "del-cli": "^6.0.0",
+    "eslint": "^9.35.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-prettier": "^5.5.4",
+    "jest": "^29.7.0",
+    "lefthook": "^2.0.3",
+    "prettier": "^2.8.8",
+    "react": "19.1.0",
+    "react-native": "0.81.1",
+    "react-native-builder-bob": "^0.40.16",
+    "release-it": "^19.0.4",
+    "turbo": "^2.5.6",
+    "typescript": "^5.9.2"
+  },
+  "peerDependencies": {
+    "react": "*",
+    "react-native": "*"
+  },
+  "workspaces": [
+    "example"
+  ],
+  "packageManager": "yarn@4.11.0",
+  "react-native-builder-bob": {
+    "source": "src",
+    "output": "lib",
+    "targets": [
+      [
+        "module",
+        {
+          "esm": true
+        }
+      ],
+      [
+        "typescript",
+        {
+          "project": "tsconfig.build.json"
+        }
+      ]
+    ]
+  },
+  "codegenConfig": {
+    "name": "GeoActivityKitSpec",
+    "type": "modules",
+    "jsSrcsDir": "src",
+    "android": {
+      "javaPackageName": "com.geoactivitykit"
+    }
+  },
+  "prettier": {
+    "quoteProps": "consistent",
+    "singleQuote": true,
+    "tabWidth": 2,
+    "trailingComma": "es5",
+    "useTabs": false
+  },
+  "commitlint": {
+    "extends": [
+      "@commitlint/config-conventional"
+    ]
+  },
+  "release-it": {
+    "git": {
+      "commitMessage": "chore: release ${version}",
+      "tagName": "v${version}"
+    },
+    "npm": {
+      "publish": true
+    },
+    "github": {
+      "release": true
+    },
+    "plugins": {
+      "@release-it/conventional-changelog": {
+        "preset": {
+          "name": "angular"
+        }
+      }
+    }
+  },
+  "jest": {
+    "preset": "react-native",
+    "modulePathIgnorePatterns": [
+      "<rootDir>/example/node_modules",
+      "<rootDir>/lib/"
+    ]
+  },
+  "create-react-native-library": {
+    "languages": "kotlin-objc",
+    "type": "turbo-module",
+    "tools": [
+      "eslint",
+      "lefthook",
+      "release-it",
+      "jest"
+    ],
+    "version": "0.55.1"
+  }
+}

package/src/NativeGeoActivityKit.ts

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

package/src/index.tsx

@@ -0,0 +1,63 @@
+import { NativeModules, NativeEventEmitter, Platform } from 'react-native';
+
+const LINKING_ERROR =
+  `The package 'react-native-geo-activity-kit' doesn't seem to be linked. Make sure: \n\n` +
+  Platform.select({ ios: "- You have run 'pod install'\n", default: '' }) +
+  '- You rebuilt the app after installing the package\n' +
+  '- You are not using Expo Go\n';
+
+// The name must match getName() in SensorModule.kt
+const RNSensorModule = NativeModules.RNSensorModule
+  ? NativeModules.RNSensorModule
+  : new Proxy(
+      {},
+      {
+        get() {
+          throw new Error(LINKING_ERROR);
+        },
+      }
+    );
+
+const emitter = new NativeEventEmitter(RNSensorModule);
+
+export default {
+  startMotionDetector: (threshold: number = 0.8) => 
+    RNSensorModule.startMotionDetector(threshold),
+
+  stopMotionDetector: () => 
+    RNSensorModule.stopMotionDetector(),
+
+  setUpdateInterval: (ms: number = 100) => 
+    RNSensorModule.setUpdateInterval(ms),
+
+  setLocationUpdateInterval: (ms: number = 90000) =>
+    RNSensorModule.setLocationUpdateInterval(ms),
+
+  setStabilityThresholds: (startThreshold: number = 20, stopThreshold: number = 3000) =>
+    RNSensorModule.setStabilityThresholds(startThreshold, stopThreshold),
+  
+  // Added types: string for text inputs
+  fireGeofenceAlert: (type: string, userName: string) =>
+    RNSensorModule.fireGeofenceAlert(type, userName),
+  
+  // Added types: string for text, number for ID (assuming Android notification ID)
+  fireGenericAlert: (title: string, body: string, id: number) =>
+    RNSensorModule.fireGenericAlert(title, body, id),
+
+  // Added type: number to match the ID above
+  cancelGenericAlert: (id: number) =>
+    RNSensorModule.cancelGenericAlert(id),
+
+  isAvailable: () => 
+    RNSensorModule.isAvailable(),
+
+  // Added type: function that accepts an event (any)
+  addMotionListener: (cb: (event: any) => void) => 
+    emitter.addListener('onMotionStateChanged', cb),
+    
+  addLocationLogListener: (cb: (event: any) => void) =>
+    emitter.addListener('onLocationLog', cb),
+  
+  addLocationErrorListener: (cb: (event: any) => void) =>
+    emitter.addListener('onLocationError', cb),
+};