react-native-nitro-location-tracking 0.1.0

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) 2026 alisherrahimov
+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/NitroLocationTracking.podspec

@@ -0,0 +1,29 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "NitroLocationTracking"
+  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/alisherrahimov/react-native-nitro-location-tracking.git", :tag => "#{s.version}" }
+
+  s.source_files = [
+    "ios/**/*.{swift}",
+    "ios/**/*.{m,mm}",
+    "cpp/**/*.{hpp,cpp}",
+  ]
+
+  s.dependency 'React-jsi'
+  s.dependency 'React-callinvoker'
+
+  load 'nitrogen/generated/ios/NitroLocationTracking+autolinking.rb'
+  add_nitrogen_files(s)
+
+  install_modules_dependencies(s)
+end

package/README.md

@@ -0,0 +1,39 @@
+# react-native-nitro-location-tracking
+
+   
+
+## Installation
+
+
+```sh
+npm install react-native-nitro-location-tracking react-native-nitro-modules
+
+> `react-native-nitro-modules` is required as this library relies on [Nitro Modules](https://nitro.margelo.com/).
+```
+
+
+## Usage
+
+
+```js
+import { multiply } from 'react-native-nitro-location-tracking';
+
+// ...
+
+const result = multiply(3, 7);
+```
+
+
+## Contributing
+
+- [Development workflow](CONTRIBUTING.md#development-workflow)
+- [Sending a pull request](CONTRIBUTING.md#sending-a-pull-request)
+- [Code of conduct](CODE_OF_CONDUCT.md)
+
+## License
+
+MIT
+
+---
+
+Made with [create-react-native-library](https://github.com/callstack/react-native-builder-bob)

package/android/CMakeLists.txt

@@ -0,0 +1,24 @@
+project(nitrolocationtracking)
+cmake_minimum_required(VERSION 3.9.0)
+
+set(PACKAGE_NAME nitrolocationtracking)
+set(CMAKE_VERBOSE_MAKEFILE ON)
+set(CMAKE_CXX_STANDARD 20)
+
+# Define C++ library and add all sources
+add_library(${PACKAGE_NAME} SHARED src/main/cpp/cpp-adapter.cpp)
+
+# Add Nitrogen specs :)
+include(${CMAKE_SOURCE_DIR}/../nitrogen/generated/android/nitrolocationtracking+autolinking.cmake)
+
+# Set up local includes
+include_directories("src/main/cpp" "../cpp")
+
+find_library(LOG_LIB log)
+
+# Link all libraries together
+target_link_libraries(
+        ${PACKAGE_NAME}
+        ${LOG_LIB}
+        android # <-- Android core
+)

package/android/build.gradle

@@ -0,0 +1,122 @@
+buildscript {
+  ext.NitroLocationTracking = [
+    kotlinVersion: "2.0.21",
+    minSdkVersion: 24,
+    compileSdkVersion: 36,
+    targetSdkVersion: 36
+  ]
+
+  ext.getExtOrDefault = { prop ->
+    if (rootProject.ext.has(prop)) {
+      return rootProject.ext.get(prop)
+    }
+
+    return NitroLocationTracking[prop]
+  }
+
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.7.2"
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${getExtOrDefault('kotlinVersion')}"
+  }
+}
+
+def reactNativeArchitectures() {
+  def value = rootProject.getProperties().get("reactNativeArchitectures")
+  return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
+}
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+apply from: '../nitrogen/generated/android/nitrolocationtracking+autolinking.gradle'
+
+apply plugin: "com.facebook.react"
+
+android {
+  namespace "com.margelo.nitro.nitrolocationtracking"
+
+  compileSdkVersion getExtOrDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrDefault("minSdkVersion")
+    targetSdkVersion getExtOrDefault("targetSdkVersion")
+
+    externalNativeBuild {
+      cmake {
+        cppFlags "-frtti -fexceptions -Wall -fstack-protector-all"
+        arguments "-DANDROID_STL=c++_shared", "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON"
+        abiFilters (*reactNativeArchitectures())
+
+        buildTypes {
+          debug {
+            cppFlags "-O1 -g"
+          }
+          release {
+            cppFlags "-O2"
+          }
+        }
+      }
+    }
+  }
+
+  externalNativeBuild {
+    cmake {
+      path "CMakeLists.txt"
+    }
+  }
+
+  packagingOptions {
+    excludes = [
+      "META-INF",
+      "META-INF/**",
+      "**/libc++_shared.so",
+      "**/libfbjni.so",
+      "**/libjsi.so",
+      "**/libfolly_json.so",
+      "**/libfolly_runtime.so",
+      "**/libglog.so",
+      "**/libhermes.so",
+      "**/libhermes-executor-debug.so",
+      "**/libhermes_executor.so",
+      "**/libreactnative.so",
+      "**/libreactnativejni.so",
+      "**/libturbomodulejsijni.so",
+      "**/libreact_nativemodule_core.so",
+      "**/libjscexecutor.so"
+    ]
+  }
+
+  buildFeatures {
+    buildConfig true
+    prefab true
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lint {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+}
+
+dependencies {
+  implementation "com.facebook.react:react-android"
+  implementation project(":react-native-nitro-modules")
+  implementation "com.google.android.gms:play-services-location:21.3.0"
+  implementation "com.squareup.okhttp3:okhttp:4.12.0"
+  implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.9.0"
+  implementation "androidx.core:core-ktx:1.15.0"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,18 @@
+<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.ACCESS_BACKGROUND_LOCATION" />
+  <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
+  <uses-permission android:name="android.permission.FOREGROUND_SERVICE_LOCATION" />
+  <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
+  <uses-permission android:name="android.permission.INTERNET" />
+  <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
+  <uses-permission android:name="android.permission.WAKE_LOCK" />
+
+  <application>
+    <service
+      android:name=".LocationForegroundService"
+      android:foregroundServiceType="location"
+      android:exported="false" />
+  </application>
+</manifest>

package/android/src/main/cpp/cpp-adapter.cpp

@@ -0,0 +1,6 @@
+#include <jni.h>
+#include "nitrolocationtrackingOnLoad.hpp"
+
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
+  return margelo::nitro::nitrolocationtracking::initialize(vm);
+}

package/android/src/main/java/com/margelo/nitro/nitrolocationtracking/ConnectionManager.kt

@@ -0,0 +1,137 @@
+package com.margelo.nitro.nitrolocationtracking
+
+import okhttp3.*
+import okhttp3.MediaType.Companion.toMediaType
+import okhttp3.RequestBody.Companion.toRequestBody
+import org.json.JSONArray
+import org.json.JSONObject
+import java.util.concurrent.TimeUnit
+
+class ConnectionManager {
+    private var client = OkHttpClient.Builder()
+        .readTimeout(0, TimeUnit.MILLISECONDS).build()
+    private var webSocket: WebSocket? = null
+    private var config: ConnectionConfig? = null
+    private var reconnectAttempts = 0
+    private var connected = false
+
+    var onStateChange: ((ConnectionState) -> Unit)? = null
+    var onMessage: ((String) -> Unit)? = null
+    var dbWriter: NativeDBWriter? = null
+
+    val isConnected: Boolean get() = connected
+
+    private val handler = android.os.Handler(android.os.Looper.getMainLooper())
+    private var syncRunnable: Runnable? = null
+
+    fun configure(config: ConnectionConfig) {
+        this.config = config
+    }
+
+    fun connect() {
+        val cfg = config ?: return
+        val request = Request.Builder().url(cfg.wsUrl)
+            .addHeader("Authorization", "Bearer ${cfg.authToken}").build()
+
+        webSocket = client.newWebSocket(request, object : WebSocketListener() {
+            override fun onOpen(ws: WebSocket, r: Response) {
+                connected = true
+                reconnectAttempts = 0
+                onStateChange?.invoke(ConnectionState.CONNECTED)
+                startSyncTimer()
+            }
+
+            override fun onMessage(ws: WebSocket, text: String) {
+                onMessage?.invoke(text)
+            }
+
+            override fun onFailure(ws: WebSocket, t: Throwable, r: Response?) {
+                handleDisconnect()
+            }
+
+            override fun onClosed(ws: WebSocket, code: Int, reason: String) {
+                connected = false
+                onStateChange?.invoke(ConnectionState.DISCONNECTED)
+            }
+        })
+    }
+
+    fun disconnect() {
+        syncRunnable?.let { handler.removeCallbacks(it) }
+        webSocket?.close(1000, "bye")
+        connected = false
+        onStateChange?.invoke(ConnectionState.DISCONNECTED)
+    }
+
+    fun send(msg: String) {
+        webSocket?.send(msg)
+    }
+
+    fun getState(): ConnectionState {
+        return if (connected) ConnectionState.CONNECTED else ConnectionState.DISCONNECTED
+    }
+
+    private fun handleDisconnect() {
+        val cfg = config ?: return
+        connected = false
+        onStateChange?.invoke(ConnectionState.RECONNECTING)
+        if (reconnectAttempts >= cfg.maxReconnectAttempts.toInt()) {
+            onStateChange?.invoke(ConnectionState.DISCONNECTED)
+            return
+        }
+        reconnectAttempts++
+        handler.postDelayed({ connect() }, cfg.reconnectIntervalMs.toLong())
+    }
+
+    private fun startSyncTimer() {
+        val cfg = config ?: return
+        syncRunnable = object : Runnable {
+            override fun run() {
+                flushQueue()
+                handler.postDelayed(this, cfg.syncIntervalMs.toLong())
+            }
+        }
+        handler.postDelayed(syncRunnable!!, cfg.syncIntervalMs.toLong())
+    }
+
+    fun flushQueue(): Boolean {
+        val cfg = config ?: return false
+        val db = dbWriter ?: return false
+        val queued = db.getUnsyncedBatch(cfg.batchSize.toInt())
+        if (queued.isEmpty()) return true
+
+        val ids = queued.map { it.first }
+        val arr = JSONArray()
+        for (pair in queued) {
+            val loc = pair.second
+            val obj = JSONObject()
+            obj.put("latitude", loc.latitude)
+            obj.put("longitude", loc.longitude)
+            obj.put("altitude", loc.altitude)
+            obj.put("speed", loc.speed)
+            obj.put("bearing", loc.bearing)
+            obj.put("accuracy", loc.accuracy)
+            obj.put("timestamp", loc.timestamp)
+            arr.put(obj)
+        }
+
+        if (connected) {
+            send(arr.toString())
+            db.markSynced(ids)
+        } else {
+            val body = arr.toString().toRequestBody("application/json".toMediaType())
+            val req = Request.Builder()
+                .url("${cfg.restUrl}/locations/batch")
+                .addHeader("Authorization", "Bearer ${cfg.authToken}")
+                .post(body).build()
+            client.newCall(req).enqueue(object : Callback {
+                override fun onResponse(call: Call, response: Response) {
+                    if (response.isSuccessful) db.markSynced(ids)
+                }
+
+                override fun onFailure(call: Call, e: java.io.IOException) {}
+            })
+        }
+        return true
+    }
+}

package/android/src/main/java/com/margelo/nitro/nitrolocationtracking/LocationEngine.kt

@@ -0,0 +1,93 @@
+package com.margelo.nitro.nitrolocationtracking
+
+import android.annotation.SuppressLint
+import android.content.Context
+import android.location.Location
+import android.os.Looper
+import com.google.android.gms.location.*
+import kotlin.coroutines.resume
+
+class LocationEngine(private val context: Context) {
+  private val fusedClient =
+    LocationServices.getFusedLocationProviderClient(context)
+  private var locationCallback: LocationCallback? = null
+
+  var onLocation: ((LocationData) -> Unit)? = null
+  var onMotionChange: ((Boolean) -> Unit)? = null
+  var dbWriter: NativeDBWriter? = null
+  var currentRideId: String? = null
+  private var lastSpeed = 0f
+  private var tracking = false
+
+  val isTracking: Boolean get() = tracking
+
+  @SuppressLint("MissingPermission")
+  fun start(config: LocationConfig) {
+    val priority = when (config.desiredAccuracy) {
+      AccuracyLevel.HIGH -> Priority.PRIORITY_HIGH_ACCURACY
+      AccuracyLevel.BALANCED -> Priority.PRIORITY_BALANCED_POWER_ACCURACY
+      AccuracyLevel.LOW -> Priority.PRIORITY_LOW_POWER
+    }
+    val request = LocationRequest.Builder(priority, config.intervalMs.toLong())
+      .setMinUpdateDistanceMeters(config.distanceFilter.toFloat())
+      .setMinUpdateIntervalMillis(config.fastestIntervalMs.toLong())
+      .build()
+
+    locationCallback = object : LocationCallback() {
+      override fun onLocationResult(result: LocationResult) {
+        result.lastLocation?.let { processLocation(it) }
+      }
+    }
+    fusedClient.requestLocationUpdates(
+      request, locationCallback!!, Looper.getMainLooper())
+    tracking = true
+  }
+
+  fun stop() {
+    locationCallback?.let { fusedClient.removeLocationUpdates(it) }
+    tracking = false
+  }
+
+  @SuppressLint("MissingPermission")
+  fun getCurrentLocation(callback: (LocationData?) -> Unit) {
+    fusedClient.lastLocation.addOnSuccessListener { location ->
+      if (location != null) {
+        callback(locationToData(location))
+      } else {
+        callback(null)
+      }
+    }.addOnFailureListener {
+      callback(null)
+    }
+  }
+
+  suspend fun getCurrentLocationSuspend(): LocationData? {
+    return kotlin.coroutines.suspendCoroutine { cont ->
+      getCurrentLocation { data ->
+        cont.resume(data)
+      }
+    }
+  }
+
+  private fun processLocation(location: Location) {
+    val data = locationToData(location)
+//    dbWriter?.insert(data, currentRideId)
+    onLocation?.invoke(data)
+
+    val isMoving = location.speed > 0.5f
+    if (isMoving != (lastSpeed > 0.5f)) onMotionChange?.invoke(isMoving)
+    lastSpeed = location.speed
+  }
+
+  private fun locationToData(location: Location): LocationData {
+    return LocationData(
+      latitude = location.latitude,
+      longitude = location.longitude,
+      altitude = location.altitude,
+      speed = location.speed.toDouble(),
+      bearing = location.bearing.toDouble(),
+      accuracy = location.accuracy.toDouble(),
+      timestamp = location.time.toDouble()
+    )
+  }
+}

package/android/src/main/java/com/margelo/nitro/nitrolocationtracking/LocationForegroundService.kt

@@ -0,0 +1,65 @@
+package com.margelo.nitro.nitrolocationtracking
+
+import android.app.*
+import android.content.Intent
+import android.os.IBinder
+import android.os.Build
+import androidx.core.app.NotificationCompat
+
+class LocationForegroundService : Service() {
+    companion object {
+        const val CHANNEL_ID = "nitro_location_channel"
+        const val NOTIFICATION_ID = 77001
+        const val ACTION_START = "com.nitrolocation.START"
+        const val ACTION_STOP = "com.nitrolocation.STOP"
+        const val ACTION_UPDATE = "com.nitrolocation.UPDATE"
+    }
+
+    override fun onCreate() {
+        super.onCreate()
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            val channel = NotificationChannel(
+                CHANNEL_ID,
+                "Location Tracking",
+                NotificationManager.IMPORTANCE_LOW
+            )
+            (getSystemService(NOTIFICATION_SERVICE) as NotificationManager)
+                .createNotificationChannel(channel)
+        }
+    }
+
+    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+        val title = intent?.getStringExtra("title") ?: "Location Active"
+        val text = intent?.getStringExtra("text") ?: "Tracking your location"
+        when (intent?.action) {
+            ACTION_START -> startForeground(
+                NOTIFICATION_ID, buildNotification(title, text))
+            ACTION_STOP -> {
+                stopForeground(STOP_FOREGROUND_REMOVE)
+                stopSelf()
+            }
+            ACTION_UPDATE -> (getSystemService(NOTIFICATION_SERVICE)
+                as NotificationManager).notify(
+                NOTIFICATION_ID, buildNotification(title, text))
+        }
+        return START_STICKY
+    }
+
+    private fun buildNotification(title: String, text: String): Notification {
+        val pi = PendingIntent.getActivity(
+            this, 0,
+            packageManager.getLaunchIntentForPackage(packageName),
+            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
+        )
+        return NotificationCompat.Builder(this, CHANNEL_ID)
+            .setContentTitle(title)
+            .setContentText(text)
+            .setSmallIcon(android.R.drawable.ic_menu_mylocation)
+            .setOngoing(true)
+            .setContentIntent(pi)
+            .setPriority(NotificationCompat.PRIORITY_LOW)
+            .build()
+    }
+
+    override fun onBind(intent: Intent?): IBinder? = null
+}

package/android/src/main/java/com/margelo/nitro/nitrolocationtracking/NativeDBWriter.kt

@@ -0,0 +1,80 @@
+package com.margelo.nitro.nitrolocationtracking
+
+import android.content.ContentValues
+import android.content.Context
+import android.database.sqlite.SQLiteDatabase
+import android.database.sqlite.SQLiteOpenHelper
+import java.util.UUID
+
+class NativeDBWriter(context: Context) :
+    SQLiteOpenHelper(context, "nitro_location.db", null, 1) {
+
+    override fun onCreate(db: SQLiteDatabase) {
+        db.execSQL("""
+            CREATE TABLE IF NOT EXISTS locations (
+                id TEXT PRIMARY KEY,
+                latitude REAL NOT NULL, longitude REAL NOT NULL,
+                altitude REAL, speed REAL, bearing REAL, accuracy REAL,
+                timestamp INTEGER NOT NULL, ride_id TEXT,
+                synced INTEGER DEFAULT 0, retry_count INTEGER DEFAULT 0,
+                created_at INTEGER DEFAULT (strftime('%s','now') * 1000)
+            )
+        """)
+        db.execSQL("CREATE INDEX IF NOT EXISTS idx_locations_synced ON locations(synced)")
+        db.execSQL("CREATE INDEX IF NOT EXISTS idx_locations_timestamp ON locations(timestamp)")
+        db.execSQL("CREATE INDEX IF NOT EXISTS idx_locations_ride_id ON locations(ride_id)")
+        db.execSQL("PRAGMA journal_mode = WAL")
+    }
+
+    override fun onUpgrade(db: SQLiteDatabase, old: Int, new: Int) {}
+
+    fun insert(location: LocationData, rideId: String? = null) {
+        writableDatabase.insert("locations", null, ContentValues().apply {
+            put("id", UUID.randomUUID().toString())
+            put("latitude", location.latitude)
+            put("longitude", location.longitude)
+            put("altitude", location.altitude)
+            put("speed", location.speed)
+            put("bearing", location.bearing)
+            put("accuracy", location.accuracy)
+            put("timestamp", location.timestamp.toLong())
+            put("ride_id", rideId)
+            put("synced", 0)
+        })
+    }
+
+    fun getUnsyncedBatch(limit: Int): List<Pair<String, LocationData>> {
+        val list = mutableListOf<Pair<String, LocationData>>()
+        readableDatabase.query("locations", null, "synced = 0",
+            null, null, null, "timestamp ASC", "$limit").use {
+            while (it.moveToNext()) {
+                val id = it.getString(it.getColumnIndexOrThrow("id"))
+                val data = LocationData(
+                    latitude = it.getDouble(it.getColumnIndexOrThrow("latitude")),
+                    longitude = it.getDouble(it.getColumnIndexOrThrow("longitude")),
+                    altitude = it.getDouble(it.getColumnIndexOrThrow("altitude")),
+                    speed = it.getDouble(it.getColumnIndexOrThrow("speed")),
+                    bearing = it.getDouble(it.getColumnIndexOrThrow("bearing")),
+                    accuracy = it.getDouble(it.getColumnIndexOrThrow("accuracy")),
+                    timestamp = it.getLong(it.getColumnIndexOrThrow("timestamp")).toDouble()
+                )
+                list.add(Pair(id, data))
+            }
+        }
+        return list
+    }
+
+    fun markSynced(ids: List<String>) {
+        val ph = ids.joinToString(",") { "?" }
+        writableDatabase.execSQL(
+            "UPDATE locations SET synced = 1 WHERE id IN ($ph)",
+            ids.toTypedArray())
+    }
+
+    fun clearOldSynced() {
+        writableDatabase.execSQL("""
+            DELETE FROM locations WHERE synced = 1
+            AND timestamp < (strftime('%s','now') * 1000 - 86400000)
+        """)
+    }
+}