react-native-nitro-location-tracking 0.1.0

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

@@ -0,0 +1,180 @@
+package com.margelo.nitro.nitrolocationtracking
+
+import android.util.Log
+import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.NitroModules
+import com.margelo.nitro.core.Promise
+import kotlin.coroutines.resume
+import kotlin.coroutines.resumeWithException
+import kotlin.coroutines.suspendCoroutine
+
+@DoNotStrip
+class NitroLocationTracking : HybridNitroLocationTrackingSpec() {
+
+    companion object {
+        private const val TAG = "NitroLocationTracking"
+    }
+
+    private var locationEngine: LocationEngine? = null
+    private var connectionManager = ConnectionManager()
+    private var dbWriter: NativeDBWriter? = null
+    private var notificationService: NotificationService? = null
+
+    private var locationCallback: ((LocationData) -> Unit)? = null
+    private var motionCallback: ((Boolean) -> Unit)? = null
+    private var connectionStateCallback: ((ConnectionState) -> Unit)? = null
+    private var messageCallback: ((String) -> Unit)? = null
+
+    private var locationConfig: LocationConfig? = null
+
+    private fun ensureInitialized(): Boolean {
+        if (locationEngine != null) return true
+        val context = NitroModules.applicationContext
+        if (context == null) {
+            Log.e(TAG, "NitroModules.applicationContext is null — cannot initialize")
+            return false
+        }
+        locationEngine = LocationEngine(context)
+        dbWriter = NativeDBWriter(context)
+        notificationService = NotificationService(context)
+        locationEngine?.dbWriter = dbWriter
+        connectionManager.dbWriter = dbWriter
+        Log.d(TAG, "Components initialized successfully")
+        return true
+    }
+
+    // === Location Engine ===
+
+    override fun configure(config: LocationConfig) {
+        locationConfig = config
+        ensureInitialized()
+    }
+
+    override fun startTracking() {
+        val config = locationConfig ?: run {
+            Log.w(TAG, "startTracking called but no config set — call configure() first")
+            return
+        }
+        if (!ensureInitialized()) {
+            Log.e(TAG, "startTracking failed — could not initialize components")
+            return
+        }
+        val engine = locationEngine ?: return
+        engine.onLocation = { data ->
+            locationCallback?.invoke(data)
+        }
+        engine.onMotionChange = { isMoving ->
+            motionCallback?.invoke(isMoving)
+        }
+        engine.start(config)
+
+        try {
+            notificationService?.startForegroundService(
+                config.foregroundNotificationTitle,
+                config.foregroundNotificationText
+            )
+        } catch (e: SecurityException) {
+            Log.w(TAG, "Could not start foreground service — missing runtime permissions: ${e.message}")
+        }
+    }
+
+    override fun stopTracking() {
+        locationEngine?.stop()
+        notificationService?.stopForegroundService()
+    }
+
+    override fun getCurrentLocation(): Promise<LocationData> {
+        return Promise.async {
+            suspendCoroutine { cont ->
+                if (!ensureInitialized()) {
+                    cont.resumeWithException(Exception("Location engine not initialized — context unavailable"))
+                    return@suspendCoroutine
+                }
+                val engine = locationEngine!!
+                engine.getCurrentLocation { data ->
+                    if (data != null) {
+                        cont.resume(data)
+                    } else {
+                        cont.resumeWithException(Exception("Failed to get location"))
+                    }
+                }
+            }
+        }
+    }
+
+    override fun isTracking(): Boolean {
+        return locationEngine?.isTracking ?: false
+    }
+
+    override fun onLocation(callback: (location: LocationData) -> Unit) {
+        locationCallback = callback
+    }
+
+    override fun onMotionChange(callback: (isMoving: Boolean) -> Unit) {
+        motionCallback = callback
+    }
+
+    // === Connection Manager ===
+
+    override fun configureConnection(config: ConnectionConfig) {
+        connectionManager.configure(config)
+    }
+
+    override fun connectWebSocket() {
+        connectionManager.onStateChange = { state ->
+            connectionStateCallback?.invoke(state)
+        }
+        connectionManager.onMessage = { message ->
+            messageCallback?.invoke(message)
+        }
+        connectionManager.connect()
+    }
+
+    override fun disconnectWebSocket() {
+        connectionManager.disconnect()
+    }
+
+    override fun sendMessage(message: String) {
+        connectionManager.send(message)
+    }
+
+    override fun getConnectionState(): ConnectionState {
+        return connectionManager.getState()
+    }
+
+    override fun onConnectionStateChange(callback: (state: ConnectionState) -> Unit) {
+        connectionStateCallback = callback
+    }
+
+    override fun onMessage(callback: (message: String) -> Unit) {
+        messageCallback = callback
+    }
+
+    // === Sync Control ===
+
+    override fun forceSync(): Promise<Boolean> {
+        return Promise.async {
+            connectionManager.flushQueue()
+        }
+    }
+
+    // === Notifications ===
+
+    override fun showLocalNotification(title: String, body: String) {
+        ensureInitialized()
+        notificationService?.showLocalNotification(title, body)
+    }
+
+    override fun updateForegroundNotification(title: String, body: String) {
+        ensureInitialized()
+        notificationService?.updateForegroundNotification(title, body)
+    }
+
+    // === Lifecycle ===
+
+    override fun destroy() {
+        locationEngine?.stop()
+        connectionManager.disconnect()
+        notificationService?.stopForegroundService()
+    }
+}

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

@@ -0,0 +1,22 @@
+package com.margelo.nitro.nitrolocationtracking
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfoProvider
+
+class NitroLocationTrackingPackage : BaseReactPackage() {
+    override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+        return null
+    }
+
+    override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+        return ReactModuleInfoProvider { HashMap() }
+    }
+
+    companion object {
+        init {
+            System.loadLibrary("nitrolocationtracking")
+        }
+    }
+}

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

@@ -0,0 +1,75 @@
+package com.margelo.nitro.nitrolocationtracking
+
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.content.Context
+import android.content.Intent
+import android.os.Build
+import androidx.core.app.NotificationCompat
+import androidx.core.app.NotificationManagerCompat
+
+class NotificationService(private val context: Context) {
+
+    companion object {
+        const val LOCAL_CHANNEL_ID = "nitro_location_local"
+        private var notificationCounter = 0
+    }
+
+    init {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            val channel = NotificationChannel(
+                LOCAL_CHANNEL_ID,
+                "Location Notifications",
+                NotificationManager.IMPORTANCE_HIGH
+            )
+            (context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager)
+                .createNotificationChannel(channel)
+        }
+    }
+
+    fun showLocalNotification(title: String, body: String) {
+        val notification = NotificationCompat.Builder(context, LOCAL_CHANNEL_ID)
+            .setContentTitle(title)
+            .setContentText(body)
+            .setSmallIcon(android.R.drawable.ic_menu_mylocation)
+            .setPriority(NotificationCompat.PRIORITY_HIGH)
+            .setAutoCancel(true)
+            .build()
+
+        try {
+            NotificationManagerCompat.from(context)
+                .notify(++notificationCounter, notification)
+        } catch (_: SecurityException) {
+            // Permission not granted
+        }
+    }
+
+    fun updateForegroundNotification(title: String, body: String) {
+        val intent = Intent(context, LocationForegroundService::class.java).apply {
+            action = LocationForegroundService.ACTION_UPDATE
+            putExtra("title", title)
+            putExtra("text", body)
+        }
+        context.startService(intent)
+    }
+
+    fun startForegroundService(title: String, text: String) {
+        val intent = Intent(context, LocationForegroundService::class.java).apply {
+            action = LocationForegroundService.ACTION_START
+            putExtra("title", title)
+            putExtra("text", text)
+        }
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            context.startForegroundService(intent)
+        } else {
+            context.startService(intent)
+        }
+    }
+
+    fun stopForegroundService() {
+        val intent = Intent(context, LocationForegroundService::class.java).apply {
+            action = LocationForegroundService.ACTION_STOP
+        }
+        context.startService(intent)
+    }
+}

package/ios/ConnectionManager.swift

@@ -0,0 +1,144 @@
+import Foundation
+
+class ConnectionManager: NSObject, URLSessionWebSocketDelegate {
+    private var webSocket: URLSessionWebSocketTask?
+    private var session: URLSession?
+    private var config: ConnectionConfig?
+    private var reconnectAttempts = 0
+    private var connected = false
+    private var syncTimer: Timer?
+
+    var onStateChange: ((ConnectionState) -> Void)?
+    var onMessage: ((String) -> Void)?
+    var dbWriter: NativeDBWriter?
+
+    var isConnected: Bool { connected }
+
+    func configure(_ config: ConnectionConfig) {
+        self.config = config
+        session = URLSession(configuration: .default,
+                             delegate: self, delegateQueue: OperationQueue())
+    }
+
+    func connect() {
+        guard let config = config,
+              let url = URL(string: config.wsUrl) else { return }
+        var request = URLRequest(url: url)
+        request.setValue("Bearer \(config.authToken)",
+                         forHTTPHeaderField: "Authorization")
+        webSocket = session?.webSocketTask(with: request)
+        webSocket?.resume()
+        startListening()
+        startSyncTimer()
+        connected = true
+        reconnectAttempts = 0
+        onStateChange?(.connected)
+    }
+
+    func disconnect() {
+        syncTimer?.invalidate()
+        webSocket?.cancel(with: .normalClosure, reason: nil)
+        connected = false
+        onStateChange?(.disconnected)
+    }
+
+    func send(_ message: String) {
+        webSocket?.send(.string(message)) { [weak self] error in
+            if error != nil { self?.handleDisconnect() }
+        }
+    }
+
+    func getState() -> ConnectionState {
+        return connected ? .connected : .disconnected
+    }
+
+    private func startListening() {
+        webSocket?.receive { [weak self] result in
+            switch result {
+            case .success(let msg):
+                if case .string(let text) = msg {
+                    self?.onMessage?(text)
+                }
+                self?.startListening()
+            case .failure(_):
+                self?.handleDisconnect()
+            }
+        }
+    }
+
+    private func handleDisconnect() {
+        guard let config = config else { return }
+        connected = false
+        onStateChange?(.reconnecting)
+        guard reconnectAttempts < Int(config.maxReconnectAttempts) else {
+            onStateChange?(.disconnected)
+            return
+        }
+        reconnectAttempts += 1
+        let delay = config.reconnectIntervalMs / 1000.0
+        DispatchQueue.global().asyncAfter(deadline: .now() + delay) {
+            [weak self] in self?.connect()
+        }
+    }
+
+    private func startSyncTimer() {
+        guard let config = config else { return }
+        DispatchQueue.main.async {
+            self.syncTimer = Timer.scheduledTimer(
+                withTimeInterval: config.syncIntervalMs / 1000.0,
+                repeats: true
+            ) { [weak self] _ in self?.flushQueue() }
+        }
+    }
+
+    func flushQueue() -> Bool {
+        guard let config = config, let dbWriter = dbWriter else { return false }
+        let queued = dbWriter.getUnsyncedBatch(limit: Int(config.batchSize))
+        guard !queued.isEmpty else { return true }
+
+        let ids = queued.map { $0.id }
+        let payload: [[String: Any]] = queued.map { item in
+            [
+                "latitude": item.data.latitude,
+                "longitude": item.data.longitude,
+                "altitude": item.data.altitude,
+                "speed": item.data.speed,
+                "bearing": item.data.bearing,
+                "accuracy": item.data.accuracy,
+                "timestamp": item.data.timestamp
+            ]
+        }
+
+        if connected {
+            if let json = try? JSONSerialization.data(withJSONObject: payload),
+               let str = String(data: json, encoding: .utf8) {
+                send(str)
+                dbWriter.markSynced(ids)
+                return true
+            }
+        } else {
+            sendBatchHTTP(payload, ids: ids)
+        }
+        return true
+    }
+
+    private func sendBatchHTTP(_ locations: [[String: Any]], ids: [String]) {
+        guard let config = config,
+              let url = URL(string: "\(config.restUrl)/locations/batch")
+        else { return }
+
+        var request = URLRequest(url: url)
+        request.httpMethod = "POST"
+        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+        request.setValue("Bearer \(config.authToken)",
+                         forHTTPHeaderField: "Authorization")
+        request.httpBody = try? JSONSerialization.data(withJSONObject: locations)
+
+        URLSession.shared.dataTask(with: request) { [weak self] _, response, error in
+            let http = response as? HTTPURLResponse
+            if error == nil && http?.statusCode == 200 {
+                self?.dbWriter?.markSynced(ids)
+            }
+        }.resume()
+    }
+}

package/ios/LocationEngine.swift

@@ -0,0 +1,146 @@
+import CoreLocation
+
+class LocationEngine: NSObject, CLLocationManagerDelegate {
+    private let locationManager = CLLocationManager()
+    private var tracking = false
+
+    var onLocation: ((LocationData) -> Void)?
+    var onMotionChange: ((Bool) -> Void)?
+    var dbWriter: NativeDBWriter?
+    var currentRideId: String?
+
+    override init() {
+        super.init()
+        locationManager.delegate = self
+    }
+
+    func configure(_ config: LocationConfig) {
+        switch config.desiredAccuracy {
+        case .high:
+            locationManager.desiredAccuracy = kCLLocationAccuracyBest
+        case .balanced:
+            locationManager.desiredAccuracy = kCLLocationAccuracyHundredMeters
+        default:
+            locationManager.desiredAccuracy = kCLLocationAccuracyKilometer
+        }
+
+        locationManager.distanceFilter = config.distanceFilter
+        locationManager.allowsBackgroundLocationUpdates = true
+        locationManager.showsBackgroundLocationIndicator = true
+        locationManager.pausesLocationUpdatesAutomatically = false
+    }
+
+    func start() {
+        guard CLLocationManager.authorizationStatus() == .authorizedAlways ||
+              CLLocationManager.authorizationStatus() == .authorizedWhenInUse else {
+            locationManager.requestAlwaysAuthorization()
+            return
+        }
+        locationManager.startUpdatingLocation()
+        tracking = true
+    }
+
+    func stop() {
+        locationManager.stopUpdatingLocation()
+        tracking = false
+    }
+
+    var isTracking: Bool { tracking }
+
+    func getCurrentLocation(completion: @escaping (LocationData?) -> Void) {
+        locationManager.requestLocation()
+        // Store completion for delegate callback
+        pendingLocationCompletion = completion
+    }
+
+    private var pendingLocationCompletion: ((LocationData?) -> Void)?
+
+    func locationManager(_ manager: CLLocationManager,
+                         didUpdateLocations locations: [CLLocation]) {
+        guard let location = locations.last else { return }
+
+        let data = LocationData(
+            latitude: location.coordinate.latitude,
+            longitude: location.coordinate.longitude,
+            altitude: location.altitude,
+            speed: max(location.speed, 0),
+            bearing: max(location.course, 0),
+            accuracy: location.horizontalAccuracy,
+            timestamp: location.timestamp.timeIntervalSince1970 * 1000
+        )
+      
+      
+        print(data,"dataaas")
+
+        // Handle pending one-shot request
+        if let completion = pendingLocationCompletion {
+            completion(data)
+            pendingLocationCompletion = nil
+        }
+
+        // Save to SQLite immediately (offline-first)
+        dbWriter?.insert(data, rideId: currentRideId)
+
+        // Notify JS via Nitro callback
+        onLocation?(data)
+
+        // Motion detection
+        onMotionChange?(location.speed >= 0.5)
+    }
+
+    func locationManager(_ manager: CLLocationManager,
+                         didFailWithError error: Error) {
+        if let completion = pendingLocationCompletion {
+            completion(nil)
+            pendingLocationCompletion = nil
+        }
+    }
+}
+
+//// Simple struct to pass location data between components
+//struct LocationData {
+//    let latitude: Double
+//    let longitude: Double
+//    let altitude: Double
+//    let speed: Double
+//    let bearing: Double
+//    let accuracy: Double
+//    let timestamp: Double
+//
+//    var id: String = ""
+//
+//    func toJSON() -> [String: Any] {
+//        return [
+//            "latitude": latitude,
+//            "longitude": longitude,
+//            "altitude": altitude,
+//            "speed": speed,
+//            "bearing": bearing,
+//            "accuracy": accuracy,
+//            "timestamp": timestamp
+//        ]
+//    }
+//}
+//
+//// Config structs
+//struct LocationConfig {
+//    let desiredAccuracy: String
+//    let distanceFilter: Double
+//    let intervalMs: Double
+//    let fastestIntervalMs: Double
+//    let stopTimeout: Double
+//    let stopOnTerminate: Bool
+//    let startOnBoot: Bool
+//    let foregroundNotificationTitle: String
+//    let foregroundNotificationText: String
+//}
+//
+//struct ConnectionConfig {
+//    let wsUrl: String
+//    let restUrl: String
+//    let authToken: String
+//    let reconnectIntervalMs: Double
+//    let maxReconnectAttempts: Double
+//    let batchSize: Double
+//    let syncIntervalMs: Double
+//}

package/ios/NativeDBWriter.swift

@@ -0,0 +1,121 @@
+import SQLite3
+
+class NativeDBWriter {
+    private var db: OpaquePointer?
+
+    init() {
+        let documentsDir = FileManager.default.urls(
+            for: .documentDirectory, in: .userDomainMask).first!
+        let dbPath = documentsDir
+            .appendingPathComponent("nitro_location.db").path
+        sqlite3_open(dbPath, &db)
+        sqlite3_exec(db, "PRAGMA journal_mode = WAL", nil, nil, nil)
+        createTables()
+    }
+
+    private func createTables() {
+        let sql = """
+        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)
+        );
+        CREATE INDEX IF NOT EXISTS idx_locations_synced ON locations(synced);
+        CREATE INDEX IF NOT EXISTS idx_locations_timestamp ON locations(timestamp);
+        CREATE INDEX IF NOT EXISTS idx_locations_ride_id ON locations(ride_id);
+        """
+        sqlite3_exec(db, sql, nil, nil, nil)
+    }
+
+    func insert(_ location: LocationData, rideId: String? = nil) {
+        let sql = """
+        INSERT INTO locations
+            (id, latitude, longitude, altitude, speed,
+             bearing, accuracy, timestamp, ride_id, synced)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 0)
+        """
+        var stmt: OpaquePointer?
+        if sqlite3_prepare_v2(db, sql, -1, &stmt, nil) == SQLITE_OK {
+            let id = UUID().uuidString
+            sqlite3_bind_text(stmt, 1, (id as NSString).utf8String, -1, nil)
+            sqlite3_bind_double(stmt, 2, location.latitude)
+            sqlite3_bind_double(stmt, 3, location.longitude)
+            sqlite3_bind_double(stmt, 4, location.altitude)
+            sqlite3_bind_double(stmt, 5, location.speed)
+            sqlite3_bind_double(stmt, 6, location.bearing)
+            sqlite3_bind_double(stmt, 7, location.accuracy)
+            sqlite3_bind_int64(stmt, 8, Int64(location.timestamp))
+            if let rideId = rideId {
+                sqlite3_bind_text(stmt, 9,
+                    (rideId as NSString).utf8String, -1, nil)
+            } else {
+                sqlite3_bind_null(stmt, 9)
+            }
+            sqlite3_step(stmt)
+        }
+        sqlite3_finalize(stmt)
+    }
+
+    func getUnsyncedBatch(limit: Int) -> [(id: String, data: LocationData)] {
+        let sql = """
+        SELECT id, latitude, longitude, altitude, speed,
+               bearing, accuracy, timestamp
+        FROM locations WHERE synced = 0
+        ORDER BY timestamp ASC LIMIT ?
+        """
+        var results: [(id: String, data: LocationData)] = []
+        var stmt: OpaquePointer?
+        if sqlite3_prepare_v2(db, sql, -1, &stmt, nil) == SQLITE_OK {
+            sqlite3_bind_int(stmt, 1, Int32(limit))
+            while sqlite3_step(stmt) == SQLITE_ROW {
+                let id = String(cString: sqlite3_column_text(stmt, 0))
+                let data = LocationData(
+                    latitude: sqlite3_column_double(stmt, 1),
+                    longitude: sqlite3_column_double(stmt, 2),
+                    altitude: sqlite3_column_double(stmt, 3),
+                    speed: sqlite3_column_double(stmt, 4),
+                    bearing: sqlite3_column_double(stmt, 5),
+                    accuracy: sqlite3_column_double(stmt, 6),
+                    timestamp: Double(sqlite3_column_int64(stmt, 7))
+                )
+                results.append((id: id, data: data))
+            }
+        }
+        sqlite3_finalize(stmt)
+        return results
+    }
+
+    func markSynced(_ ids: [String]) {
+        let placeholders = ids.map { _ in "?" }.joined(separator: ",")
+        let sql = "UPDATE locations SET synced = 1 WHERE id IN (\(placeholders))"
+        var stmt: OpaquePointer?
+        if sqlite3_prepare_v2(db, sql, -1, &stmt, nil) == SQLITE_OK {
+            for (i, id) in ids.enumerated() {
+                sqlite3_bind_text(stmt, Int32(i + 1),
+                    (id as NSString).utf8String, -1, nil)
+            }
+            sqlite3_step(stmt)
+        }
+        sqlite3_finalize(stmt)
+    }
+
+    func clearOldSynced() {
+        sqlite3_exec(db, """
+            DELETE FROM locations WHERE synced = 1
+            AND timestamp < (strftime('%s','now') * 1000 - 86400000)
+        """, nil, nil, nil)
+    }
+
+    deinit {
+        sqlite3_close(db)
+    }
+}