leeo-react-native-sdk 0.1.0

package/LeeoSdk.podspec

@@ -0,0 +1,24 @@
+require 'json'
+pkg = JSON.parse(File.read(File.join(__dir__, 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name         = "LeeoSdk"
+  s.version      = pkg["version"]
+  s.summary      = pkg["description"]
+  s.homepage     = pkg["repository"]["url"] rescue ""
+  s.license      = pkg["license"] rescue "UNLICENSED"
+  s.author       = pkg["author"] rescue ""
+  s.source       = { :git => "", :tag => "#{s.version}" }
+  s.platforms    = { :ios => "13.0" }
+  s.source_files = "ios/*.{m,mm,swift,h}"
+  s.pod_target_xcconfig = {
+    "DEFINES_MODULE" => "YES",
+    "SWIFT_OBJC_BRIDGING_HEADER" => "$(PODS_TARGET_SRCROOT)/ios/LeeoSdk-Bridging-Header.h"
+  }
+  s.requires_arc = true
+  s.dependency "React-Core"
+  # Leeo iOS SDK (same code as SPM). Install with: npm install leeo-ios-sdk (or add to your app).
+  leeo_ios_path = File.directory?(File.join(__dir__, "node_modules/leeo-ios-sdk")) ? "node_modules/leeo-ios-sdk" : "../leeo-ios-sdk"
+  s.dependency "LeeoSDK", :path => leeo_ios_path
+  s.swift_version = "5.0"
+end

package/README.md

@@ -0,0 +1,34 @@
+# Leeo React Native SDK
+
+React Native bridge for Leeo trip tracking and incident reporting. Same flow as the native [Android](../leeo-android-sdk) and [iOS](../leeo-ios-sdk) SDKs: setup (fleet-service + DriveKit), manual trip (startTrip/stopTrip), shift (startShift/stopShift), incident reporting.
+
+- **Test the demo app:** Create a new RN app, add this package (and `leeo-ios-sdk` for iOS), link Android/iOS, copy [example/App.tsx](example/App.tsx), then run. Full steps in [INSTALL_AND_TEST.md](INSTALL_AND_TEST.md).
+- **Clients:** Install via npm or Git, then same link + permissions steps; see [INSTALL_AND_TEST.md](INSTALL_AND_TEST.md) for install and API usage.
+
+## Installation
+
+- **Android:** Add `LeeoSdkPackage` to your app. Configure fleet-service base URL (or omit for production). DriveKit is initialized automatically when `setup()` succeeds with a DriveQuant key.
+- **iOS:** Same code as the native [Leeo iOS SDK](https://github.com/leeoinsurance/leeo-ios-sdk): the RN module is a thin bridge that calls the iOS SDK. Install the iOS SDK so the pod can resolve: `npm install leeo-ios-sdk` (or add it as a dependency; the RN package lists it as optional). Run `pod install` in `ios/`. The iOS SDK is built as a CocoaPods pod (same sources as SPM) and depends on `DriveKitTripAnalysis`.
+
+## Android permissions (required for trip recording)
+
+Your app must declare and request these at runtime so DriveKit can record trips and run in the background:
+
+1. **AndroidManifest.xml** (in your app’s `android/app/src/main/`):
+   - `android.permission.ACCESS_FINE_LOCATION`
+   - `android.permission.ACCESS_COARSE_LOCATION`
+   - `android.permission.POST_NOTIFICATIONS` (Android 13+)
+   - `android.permission.ACTIVITY_RECOGNITION` (Android 10+; “Physical activity”)
+
+2. **Runtime requests** (before calling Setup or Start Trip): request **POST_NOTIFICATIONS** on Android 13+ and **ACTIVITY_RECOGNITION** on Android 10+, e.g. in your root component or MainActivity using `PermissionsAndroid` or a library like `react-native-permissions`. If the user denies notifications or physical activity, trip recording may not work. See the [example README](example/README.md) for a minimal setup.
+
+## API
+
+- **Config:** `baseUrl` is optional; defaults to `DEFAULT_BASE_URL` (`https://api.leeoinsurance.com`). Import `DEFAULT_BASE_URL` from the package.
+- `Leeo.setup(config, tripNotification)` – POST fleet-service /fleet/v1/sdk/setup; on success configures DriveKit when telematics_provider returns a DriveQuant key. Same logic as Android/iOS (with 8s connection timeout if DriveKit doesn’t connect).
+- `Leeo.startTrip(trackingId)` / `Leeo.stopTrip()` – manual trip (DriveKit).
+- `Leeo.startShift(shiftId?)` / `Leeo.stopShift()` – shift/auto trip (DriveKit).
+- `Leeo.teardown()` / `Leeo.wipeOut()` – clear state and tear down DriveKit.
+- `Leeo.openIncidentReportingWebPage()` / `Leeo.getIncidentReportingURL()`
+
+See [LEEO_SDK_DESIGN.md](../LEEO_SDK_DESIGN.md).

package/android/build.gradle

@@ -0,0 +1,20 @@
+apply plugin: 'com.android.library'
+apply plugin: 'kotlin-android'
+
+android {
+    namespace "com.leeo.sdk"
+    compileSdk 34
+    defaultConfig {
+        minSdk 26
+        targetSdk 34
+    }
+}
+
+dependencies {
+    implementation "com.facebook.react:react-native:+"
+    implementation "org.jetbrains.kotlin:kotlin-stdlib:1.9.25"
+    implementation "com.squareup.okhttp3:okhttp:4.12.0"
+    implementation "com.google.code.gson:gson:2.10.1"
+    implementation "com.drivequant.drivekit:drivekit-core:2.26.0"
+    implementation "com.drivequant.drivekit:drivekit-trip-analysis:2.26.0"
+}

package/android/src/main/java/com/leeo/sdk/LeeoApi.kt

@@ -0,0 +1,105 @@
+package com.leeo.sdk
+
+import com.google.gson.Gson
+import com.google.gson.annotations.SerializedName
+import okhttp3.MediaType.Companion.toMediaType
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.RequestBody.Companion.toRequestBody
+import java.util.concurrent.TimeUnit
+
+internal object LeeoApi {
+    private const val SETUP_PATH = "/fleet/v1/sdk/setup"
+    private const val INCIDENT_AUTH_PATH = "/fleet/v1/sdk/incident-auth-url"
+    private const val HEADER_DRIVER_TOKEN = "x-driver-token"
+    private val gson = Gson()
+    private val jsonMediaType = "application/json; charset=utf-8".toMediaType()
+    private val client = OkHttpClient.Builder()
+        .connectTimeout(30, TimeUnit.SECONDS)
+        .readTimeout(30, TimeUnit.SECONDS)
+        .build()
+
+    fun postSetup(baseUrl: String, sdkKey: String, driverId: String, firstName: String, lastName: String, email: String, phoneNumber: String): Pair<Int, String?> {
+        val url = baseUrl.trimEnd('/') + SETUP_PATH
+        val body = mapOf(
+            "sdk_key" to sdkKey,
+            "driver_id" to driverId,
+            "first_name" to firstName,
+            "last_name" to lastName,
+            "email" to email,
+            "phone_number" to phoneNumber,
+            "sdk_family" to "leeo"
+        )
+        val request = Request.Builder()
+            .url(url)
+            .post(gson.toJson(body).toRequestBody(jsonMediaType))
+            .addHeader("Content-Type", "application/json")
+            .build()
+        return runCatching {
+            val response = client.newCall(request).execute()
+            response.code to response.body?.string()
+        }.getOrElse { -1 to null }
+    }
+
+    fun getIncidentAuthUrl(baseUrl: String, loginToken: String, platform: String = "android"): Pair<Int, String?> {
+        val url = baseUrl.trimEnd('/') + INCIDENT_AUTH_PATH + "?platform=$platform&source=fm_sdk&version=1"
+        val request = Request.Builder()
+            .url(url)
+            .get()
+            .addHeader(HEADER_DRIVER_TOKEN, loginToken)
+            .build()
+        return runCatching {
+            val response = client.newCall(request).execute()
+            val bodyStr = response.body?.string() ?: return@runCatching response.code to null
+            if (!response.isSuccessful) return@runCatching response.code to null
+            val json = gson.fromJson(bodyStr, IncidentAuthResponse::class.java)
+            val urlFromData = (json?.data as? Map<*, *>)?.get("claims_incident_auth_url") as? String
+            response.code to urlFromData
+        }.getOrElse { -1 to null }
+    }
+
+    private class IncidentAuthResponse(val data: Any?)
+}
+
+internal object LeeoSetupState {
+    @Volatile var loginToken: String? = null
+    @Volatile var lastBaseUrl: String? = null
+    @Volatile var driveQuantSdkKey: String? = null
+    @Volatile var isSetup: Boolean = false
+
+    fun setFromResponse(json: String, baseUrl: String): Boolean {
+        return try {
+            // Backend returns { "success": true, "data": { "user_info", "telematics_provider", ... } }
+            val response = gson.fromJson(json, SetupResponse::class.java)
+            val data = response.data
+            if (response.success == true && data?.userInfo?.loginToken != null) {
+                loginToken = data.userInfo.loginToken
+                lastBaseUrl = baseUrl
+                driveQuantSdkKey = data.telematicsProvider?.driveQuant?.sdkKey
+                isSetup = true
+                true
+            } else false
+        } catch (_: Exception) {
+            false
+        }
+    }
+
+    fun clear() {
+        loginToken = null
+        lastBaseUrl = null
+        driveQuantSdkKey = null
+        isSetup = false
+    }
+
+    private data class SetupResponse(
+        val success: Boolean?,
+        val data: SetupData?
+    )
+    private data class SetupData(
+        @SerializedName("user_info") val userInfo: UserInfo?,
+        @SerializedName("telematics_provider") val telematicsProvider: TelematicsProvider?
+    )
+    private data class UserInfo(@SerializedName("login_token") val loginToken: String?)
+    private data class TelematicsProvider(@SerializedName("drive_quant") val driveQuant: DriveQuant?)
+    private data class DriveQuant(@SerializedName("sdk_key") val sdkKey: String?)
+}

package/android/src/main/java/com/leeo/sdk/LeeoDriveKitBridge.kt

@@ -0,0 +1,122 @@
+package com.leeo.sdk
+
+import android.app.Application
+import android.content.Context
+import android.os.Handler
+import android.os.Looper
+import com.drivequant.drivekit.core.DriveKit
+import com.drivequant.drivekit.core.driver.UpdateUserIdStatus
+import com.drivequant.drivekit.core.driver.deletion.DeleteAccountStatus
+import com.drivequant.drivekit.core.networking.*
+import com.drivequant.drivekit.tripanalysis.DriveKitTripAnalysis
+import com.drivequant.drivekit.tripanalysis.entity.TripNotification
+
+/**
+ * Bridges Leeo React Native module to DriveKit. Call [ensureInitialized] before [onSetupSuccess].
+ */
+internal object LeeoDriveKitBridge : DriveKitListener {
+
+    private val mainHandler = Handler(Looper.getMainLooper())
+
+    /** Initialize DriveKit from app context. Call from setup before configuring key. Returns true if initialized. */
+    fun ensureInitialized(context: Context): Boolean {
+        val app = context.applicationContext as? Application ?: return false
+        if (!DriveKit.isInitialized()) {
+            DriveKit.initialize(app)
+            DriveKitTripAnalysis.initialize(TripNotification("Trip", "Recording...", 0))
+        }
+        return true
+    }
+
+    @Volatile
+    private var pendingSetupCallback: ((Boolean, String?) -> Unit)? = null
+
+    private var setupTimeoutRunnable: Runnable? = null
+
+    /** Timeout (ms) after which we call callback(true) if DriveKit hasn't connected (e.g. in emulator). */
+    private const val SETUP_CONNECTION_TIMEOUT_MS = 8_000L
+
+    fun onSetupSuccess(
+        driveQuantSdkKey: String,
+        driverId: String,
+        callback: (Boolean, String?) -> Unit,
+    ) {
+        if (!DriveKit.isInitialized()) {
+            mainHandler.post { callback(false, "DriveKit not initialized. Call LeeoSdk.initialize() at app startup.") }
+            return
+        }
+        pendingSetupCallback = callback
+        DriveKit.addDriveKitListener(this)
+        DriveKit.setApiKey(driveQuantSdkKey)
+        DriveKitTripAnalysis.setStopTimeOut(Int.MAX_VALUE)
+        DriveKit.setUserId(driverId)
+        val timeoutRunnable = Runnable {
+            val cb = pendingSetupCallback
+            if (cb != null) {
+                pendingSetupCallback = null
+                setupTimeoutRunnable = null
+                DriveKit.removeDriveKitListener(this)
+                cb(true, null)
+            }
+        }
+        setupTimeoutRunnable = timeoutRunnable
+        mainHandler.postDelayed(timeoutRunnable, SETUP_CONNECTION_TIMEOUT_MS)
+    }
+
+    override fun onConnected() {
+        mainHandler.post {
+            setupTimeoutRunnable?.let { mainHandler.removeCallbacks(it) }
+            setupTimeoutRunnable = null
+            DriveKit.removeDriveKitListener(this)
+            pendingSetupCallback?.invoke(true, null)
+            pendingSetupCallback = null
+        }
+    }
+
+    override fun onDisconnected() {}
+
+    override fun onAuthenticationError(errorType: RequestError) {}
+
+    override fun userIdUpdateStatus(status: UpdateUserIdStatus, userId: String?) {}
+
+    override fun onAccountDeleted(status: DeleteAccountStatus) {}
+
+    fun tearDown(callback: () -> Unit) {
+        if (!DriveKit.isInitialized()) {
+            mainHandler.post(callback)
+            return
+        }
+        if (DriveKitTripAnalysis.isTripRunning()) {
+            DriveKitTripAnalysis.stopTrip()
+            DriveKitTripAnalysis.activateAutoStart(false)
+        }
+        DriveKit.reset()
+        mainHandler.post(callback)
+    }
+
+    fun startTrip(trackingId: String): Boolean {
+        if (!DriveKit.isInitialized() || !DriveKit.isUserConnected()) return false
+        DriveKitTripAnalysis.updateTripMetaData("tracking_id", trackingId)
+        DriveKitTripAnalysis.startTrip()
+        return true
+    }
+
+    fun stopTrip(): Boolean {
+        if (!DriveKit.isInitialized()) return false
+        DriveKitTripAnalysis.stopTrip()
+        return true
+    }
+
+    fun startShift(): Boolean {
+        if (!DriveKit.isInitialized() || !DriveKit.isUserConnected()) return false
+        DriveKitTripAnalysis.activateAutoStart(true)
+        return true
+    }
+
+    fun stopShift(): Boolean {
+        if (!DriveKit.isInitialized()) return false
+        if (DriveKitTripAnalysis.isTripRunning()) DriveKitTripAnalysis.stopTrip()
+        DriveKitTripAnalysis.activateAutoStart(false)
+        return true
+    }
+}

package/android/src/main/java/com/leeo/sdk/LeeoSdkModule.kt

@@ -0,0 +1,182 @@
+package com.leeo.sdk
+
+import android.content.Intent
+import android.net.Uri
+import com.facebook.react.bridge.*
+import java.util.concurrent.Executors
+
+class LeeoSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
+
+    private val executor = Executors.newSingleThreadExecutor()
+
+    override fun getName(): String = "LeeoSdk"
+
+    @ReactMethod
+    fun setup(config: ReadableMap, tripNotification: ReadableMap, promise: Promise) {
+        val baseUrl = config.getString("baseUrl") ?: run {
+            promise.resolve(errorMap("INVALID_DRIVER_ID", "baseUrl is required"))
+            return
+        }
+        val sdkKey = config.getString("sdkKey") ?: ""
+        val driverId = config.getString("driverId") ?: ""
+        val attrs = config.getMap("driverAttributes") ?: run {
+            promise.resolve(errorMap("INVALID_DRIVER_ID", "driverAttributes required"))
+            return
+        }
+        val firstName = (attrs.getString("firstName") ?: "").trim()
+        val lastName = (attrs.getString("lastName") ?: "").trim()
+        if (firstName.isBlank() || lastName.isBlank()) {
+            promise.resolve(errorMap("INVALID_DRIVER_ID", "first_name and last_name required"))
+            return
+        }
+        val email = attrs.getString("email") ?: ""
+        val phoneNumber = attrs.getString("phoneNumber") ?: ""
+        executor.execute {
+            val (code, body) = LeeoApi.postSetup(baseUrl, sdkKey, driverId, firstName, lastName, email, phoneNumber)
+            runOnReactQueue {
+                when {
+                    code in 200..299 && body != null && LeeoSetupState.setFromResponse(body, baseUrl) -> {
+                        val dqKey = LeeoSetupState.driveQuantSdkKey
+                        if (!dqKey.isNullOrBlank()) {
+                            if (!LeeoDriveKitBridge.ensureInitialized(reactApplicationContext)) {
+                                promise.resolve(errorMap("LEEO_SDK_ERROR", "DriveKit could not be initialized"))
+                                return@runOnReactQueue
+                            }
+                            LeeoDriveKitBridge.onSetupSuccess(dqKey, driverId) { success, errorMsg ->
+                                runOnReactQueue {
+                                    if (success) promise.resolve(Arguments.createMap().apply { putBoolean("success", true) })
+                                    else promise.resolve(errorMap("LEEO_SDK_ERROR", errorMsg ?: "DriveKit setup failed"))
+                                }
+                            }
+                        } else {
+                            promise.resolve(Arguments.createMap().apply { putBoolean("success", true) })
+                        }
+                    }
+                    code == 404 -> {
+                        val msg = body ?: "Not found"
+                        val isDriverNotFound = msg.contains("Driver", ignoreCase = true) && msg.contains("not found", ignoreCase = true)
+                        val codeStr = if (isDriverNotFound) "DRIVER_NOT_FOUND" else "INVALID_OR_NOT_FOUND_SDK_KEY"
+                        promise.resolve(errorMap(codeStr, msg))
+                    }
+                    code == 400 -> promise.resolve(errorMap("INVALID_DRIVER_ID", body ?: "Bad request"))
+                    else -> promise.resolve(errorMap("NETWORK_NOT_AVAILABLE", body ?: "Setup failed (code $code)"))
+                }
+            }
+        }
+    }
+
+    private fun errorMap(code: String, message: String): WritableMap =
+        Arguments.createMap().apply { putBoolean("success", false); putString("errorCode", code); putString("message", message) }
+
+    private fun runOnReactQueue(r: () -> Unit) {
+        reactApplicationContext.runOnUiQueueThread(r)
+    }
+
+    @ReactMethod
+    fun teardown(promise: Promise) {
+        LeeoDriveKitBridge.tearDown {
+            runOnReactQueue {
+                LeeoSetupState.clear()
+                promise.resolve(Arguments.createMap().apply { putBoolean("success", true) })
+            }
+        }
+    }
+
+    @ReactMethod
+    fun startTrip(trackingId: String, promise: Promise) {
+        if (!LeeoSetupState.isSetup) {
+            promise.resolve(errorMap("SDK_NOT_SETUP", "Call setup first"))
+            return
+        }
+        val ok = LeeoDriveKitBridge.startTrip(trackingId)
+        if (ok) promise.resolve(Arguments.createMap().apply { putBoolean("success", true) })
+        else promise.resolve(errorMap("LEEO_SDK_ERROR", "DriveKit not ready"))
+    }
+
+    @ReactMethod
+    fun stopTrip(promise: Promise) {
+        val ok = LeeoDriveKitBridge.stopTrip()
+        promise.resolve(if (ok) Arguments.createMap().apply { putBoolean("success", true) } else errorMap("LEEO_SDK_ERROR", "DriveKit not initialized"))
+    }
+
+    @ReactMethod
+    fun startShift(shiftId: String?, promise: Promise) {
+        if (!LeeoSetupState.isSetup) {
+            promise.resolve(errorMap("SDK_NOT_SETUP", "Call setup first"))
+            return
+        }
+        val ok = LeeoDriveKitBridge.startShift()
+        if (ok) promise.resolve(Arguments.createMap().apply { putBoolean("success", true) })
+        else promise.resolve(errorMap("LEEO_SDK_ERROR", "DriveKit not ready"))
+    }
+
+    @ReactMethod
+    fun stopShift(promise: Promise) {
+        val ok = LeeoDriveKitBridge.stopShift()
+        promise.resolve(if (ok) Arguments.createMap().apply { putBoolean("success", true) } else errorMap("LEEO_SDK_ERROR", "DriveKit not initialized"))
+    }
+
+    @ReactMethod
+    fun wipeOut(promise: Promise) {
+        LeeoDriveKitBridge.tearDown {
+            runOnReactQueue {
+                LeeoSetupState.clear()
+                promise.resolve(Arguments.createMap().apply { putBoolean("success", true) })
+            }
+        }
+    }
+
+    @ReactMethod
+    fun getBuildVersion(promise: Promise) {
+        promise.resolve("0.1.0")
+    }
+
+    @ReactMethod
+    fun openIncidentReportingWebPage(promise: Promise) {
+        val loginToken = LeeoSetupState.loginToken
+        val baseUrl = LeeoSetupState.lastBaseUrl
+        if (loginToken == null || baseUrl == null) {
+            promise.resolve(errorMap("SDK_NOT_SETUP", "Call setup first"))
+            return
+        }
+        executor.execute {
+            val (code, url) = LeeoApi.getIncidentAuthUrl(baseUrl, loginToken)
+            runOnReactQueue {
+                when {
+                    code == 200 && !url.isNullOrBlank() -> {
+                        try {
+                            currentActivity?.startActivity(Intent(Intent.ACTION_VIEW, Uri.parse(url)))
+                            promise.resolve(Arguments.createMap().apply { putBoolean("success", true) })
+                        } catch (e: Exception) {
+                            promise.resolve(errorMap("LEEO_SDK_ERROR", e.message ?: "Could not open browser"))
+                        }
+                    }
+                    code == 404 -> promise.resolve(errorMap("INVALID_OR_NOT_FOUND_SDK_KEY", "Driver not found"))
+                    else -> promise.resolve(errorMap("NETWORK_NOT_AVAILABLE", "Failed to get incident URL"))
+                }
+            }
+        }
+    }
+
+    @ReactMethod
+    fun getIncidentReportingURL(promise: Promise) {
+        val loginToken = LeeoSetupState.loginToken
+        val baseUrl = LeeoSetupState.lastBaseUrl
+        if (loginToken == null || baseUrl == null) {
+            promise.resolve(Arguments.createMap().apply { putBoolean("success", false); putString("errorCode", "SDK_NOT_SETUP") })
+            return
+        }
+        executor.execute {
+            val (code, url) = LeeoApi.getIncidentAuthUrl(baseUrl, loginToken)
+            runOnReactQueue {
+                if (code == 200 && url != null) {
+                    promise.resolve(url)
+                } else if (code == 404) {
+                    promise.resolve(Arguments.createMap().apply { putBoolean("success", false); putString("errorCode", "INVALID_OR_NOT_FOUND_SDK_KEY") })
+                } else {
+                    promise.resolve(Arguments.createMap().apply { putBoolean("success", false); putString("errorCode", "NETWORK_NOT_AVAILABLE") })
+                }
+            }
+        }
+    }
+}

package/android/src/main/java/com/leeo/sdk/LeeoSdkPackage.kt

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

package/ios/LeeoSdk-Bridging-Header.h

@@ -0,0 +1 @@
+#import <React/RCTBridgeModule.h>

package/ios/LeeoSdk.mm

@@ -0,0 +1,44 @@
+#import <React/RCTBridgeModule.h>
+
+@interface RCT_EXTERN_MODULE(LeeoSdk, NSObject)
+
+RCT_EXTERN_METHOD(setup:(NSDictionary *)config
+                  tripNotification:(NSDictionary *)tripNotification
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(teardown:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(startTrip:(NSString *)trackingId
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(stopTrip:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(startShift:(NSString *)shiftId
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(stopShift:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(wipeOut:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(getBuildVersion:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(openIncidentReportingWebPage:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(getIncidentReportingURL:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
++ (BOOL)requiresMainQueueSetup
+{
+  return NO;
+}
+
+@end

package/ios/LeeoSdk.swift

@@ -0,0 +1,169 @@
+//
+// Leeo React Native SDK – iOS thin bridge to LeeoSDK (same as native iOS SDK).
+// Depends on LeeoSDK pod (CocoaPods build of leeo-ios-sdk).
+//
+
+import Foundation
+import UIKit
+import LeeoSDK
+
+@objc(LeeoSdk)
+class LeeoSdk: NSObject {
+
+  @objc static func requiresMainQueueSetup() -> Bool { false }
+
+  private static func success() -> [String: Any] { ["success": true] }
+  private static func error(_ code: String, _ message: String) -> [String: Any] {
+    ["success": false, "errorCode": code, "message": message]
+  }
+
+  private static func config(from configDict: NSDictionary, tripNotificationDict: NSDictionary) -> (LeeoConfiguration, LeeoTripNotification)? {
+    guard let baseUrl = configDict["baseUrl"] as? String, !baseUrl.isEmpty,
+          let sdkKey = configDict["sdkKey"] as? String,
+          let driverId = configDict["driverId"] as? String,
+          let attrs = configDict["driverAttributes"] as? NSDictionary,
+          let firstName = (attrs["firstName"] as? String)?.trimmingCharacters(in: .whitespaces),
+          let lastName = (attrs["lastName"] as? String)?.trimmingCharacters(in: .whitespaces),
+          !firstName.isEmpty, !lastName.isEmpty else { return nil }
+    let email = attrs["email"] as? String ?? ""
+    let phoneNumber = attrs["phoneNumber"] as? String ?? ""
+    let configuration = LeeoConfiguration(
+      baseUrl: baseUrl,
+      sdkKey: sdkKey,
+      driverId: driverId,
+      driverAttributes: LeeoDriverAttributes(
+        firstName: firstName,
+        lastName: lastName,
+        email: email,
+        phoneNumber: phoneNumber
+      )
+    )
+    let title = (tripNotificationDict["title"] as? String) ?? "Trip"
+    let content = (tripNotificationDict["content"] as? String) ?? "Recording..."
+    let iconId = (tripNotificationDict["iconId"] as? NSNumber)?.intValue ?? 0
+    let notification = LeeoTripNotification(title: title, content: content, iconId: iconId)
+    return (configuration, notification)
+  }
+
+  private static func errorCode(from error: Error?) -> (String, String) {
+    guard let e = error else { return ("LEEO_SDK_ERROR", "Unknown error") }
+    if let leeoError = e as? LeeoError {
+      switch leeoError {
+      case .sdkNotSetup: return ("SDK_NOT_SETUP", "Call setup first")
+      case .invalidOrNotFoundSdkKey: return ("INVALID_OR_NOT_FOUND_SDK_KEY", e.localizedDescription)
+      case .invalidDriverId: return ("INVALID_DRIVER_ID", e.localizedDescription)
+      case .networkNotAvailable: return ("NETWORK_NOT_AVAILABLE", e.localizedDescription)
+      case .leeoSDKError(let msg): return ("LEEO_SDK_ERROR", msg)
+      default: return ("LEEO_SDK_ERROR", e.localizedDescription)
+      }
+    }
+    return ("LEEO_SDK_ERROR", e.localizedDescription)
+  }
+
+  @objc func setup(
+    _ config: NSDictionary,
+    tripNotification: NSDictionary,
+    resolver resolve: @escaping RCTPromiseResolveBlock,
+    rejecter _: RCTPromiseRejectBlock
+  ) {
+    guard let (configuration, notification) = Self.config(from: config, tripNotificationDict: tripNotification) else {
+      resolve(Self.error("INVALID_DRIVER_ID", "baseUrl, driverAttributes (firstName, lastName) required"))
+      return
+    }
+    Leeo.setup(configuration: configuration, tripNotification: notification) { success, error in
+      DispatchQueue.main.async {
+        if success { resolve(Self.success()) }
+        else {
+          let (code, msg) = Self.errorCode(from: error)
+          resolve(Self.error(code, msg))
+        }
+      }
+    }
+  }
+
+  @objc func teardown(_ resolve: @escaping RCTPromiseResolveBlock, rejecter _: RCTPromiseRejectBlock) {
+    Leeo.teardown { DispatchQueue.main.async { resolve(Self.success()) } }
+  }
+
+  @objc func startTrip(_ trackingId: String?, resolver resolve: @escaping RCTPromiseResolveBlock, rejecter _: RCTPromiseRejectBlock) {
+    Leeo.startTrip(trackingId: trackingId ?? "") { success, error in
+      DispatchQueue.main.async {
+        if success { resolve(Self.success()) }
+        else {
+          let (code, msg) = Self.errorCode(from: error)
+          resolve(Self.error(code, msg))
+        }
+      }
+    }
+  }
+
+  @objc func stopTrip(_ resolve: @escaping RCTPromiseResolveBlock, rejecter _: RCTPromiseRejectBlock) {
+    Leeo.stopTrip { success, error in
+      DispatchQueue.main.async {
+        if success { resolve(Self.success()) }
+        else {
+          let (code, msg) = Self.errorCode(from: error)
+          resolve(Self.error(code, msg))
+        }
+      }
+    }
+  }
+
+  @objc func startShift(_ shiftId: String?, resolver resolve: @escaping RCTPromiseResolveBlock, rejecter _: RCTPromiseRejectBlock) {
+    Leeo.startShift(shiftId: shiftId) { success, error in
+      DispatchQueue.main.async {
+        if success { resolve(Self.success()) }
+        else {
+          let (code, msg) = Self.errorCode(from: error)
+          resolve(Self.error(code, msg))
+        }
+      }
+    }
+  }
+
+  @objc func stopShift(_ resolve: @escaping RCTPromiseResolveBlock, rejecter _: RCTPromiseRejectBlock) {
+    Leeo.stopShift { success, error in
+      DispatchQueue.main.async {
+        if success { resolve(Self.success()) }
+        else {
+          let (code, msg) = Self.errorCode(from: error)
+          resolve(Self.error(code, msg))
+        }
+      }
+    }
+  }
+
+  @objc func wipeOut(_ resolve: @escaping RCTPromiseResolveBlock, rejecter _: RCTPromiseRejectBlock) {
+    Leeo.wipeOut { _ in DispatchQueue.main.async { resolve(Self.success()) } }
+  }
+
+  @objc func getBuildVersion(_ resolve: RCTPromiseResolveBlock, rejecter _: RCTPromiseRejectBlock) {
+    resolve(Leeo.buildVersion)
+  }
+
+  @objc func openIncidentReportingWebPage(_ resolve: @escaping RCTPromiseResolveBlock, rejecter _: RCTPromiseRejectBlock) {
+    Leeo.openIncidentReportingWebPage { error in
+      DispatchQueue.main.async {
+        if error == nil { resolve(Self.success()) }
+        else {
+          let (code, msg) = Self.errorCode(from: error)
+          resolve(Self.error(code, msg))
+        }
+      }
+    }
+  }
+
+  @objc func getIncidentReportingURL(_ resolve: @escaping RCTPromiseResolveBlock, rejecter _: RCTPromiseRejectBlock) {
+    Leeo.getIncidentReportingURL { url, error in
+      DispatchQueue.main.async {
+        if let url = url { resolve(url) }
+        else if let error = error {
+          let (code, _) = Self.errorCode(from: error)
+          resolve(["success": false, "errorCode": code])
+        } else {
+          resolve(["success": false, "errorCode": "SDK_NOT_SETUP"])
+        }
+      }
+    }
+  }
+}

package/lib/typescript/index.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Leeo React Native SDK
+ *
+ * Two flows: Manual (startTrip/stopTrip) and Shift (startShift/stopShift).
+ * Setup calls fleet-service: POST /fleet/v1/sdk/setup with sdk_key in body.
+ */
+/** Production API base URL. Omit or leave empty in config to use this. */
+export declare const DEFAULT_BASE_URL = "https://api.leeoinsurance.com";
+export interface LeeoConfiguration {
+    /** Fleet-service base URL. Defaults to [DEFAULT_BASE_URL]. No trailing slash. */
+    baseUrl?: string;
+    sdkKey: string;
+    driverId: string;
+    driverAttributes: {
+        firstName: string;
+        lastName: string;
+        email: string;
+        phoneNumber: string;
+    };
+}
+export interface LeeoTripNotification {
+    title: string;
+    content: string;
+    iconId?: number;
+}
+export type LeeoOperationResult = {
+    success: true;
+} | {
+    success: false;
+    errorCode: string;
+    message: string;
+};
+export declare const Leeo: {
+    setup(config: LeeoConfiguration, tripNotification: LeeoTripNotification): Promise<LeeoOperationResult>;
+    teardown(): Promise<LeeoOperationResult>;
+    startTrip(trackingId: string): Promise<LeeoOperationResult>;
+    stopTrip(): Promise<LeeoOperationResult>;
+    startShift(shiftId?: string): Promise<LeeoOperationResult>;
+    stopShift(): Promise<LeeoOperationResult>;
+    wipeOut(): Promise<LeeoOperationResult>;
+    getBuildVersion(): string;
+    openIncidentReportingWebPage(): Promise<LeeoOperationResult>;
+    getIncidentReportingURL(): Promise<string | {
+        success: false;
+        errorCode: string;
+    }>;
+};

package/lib/typescript/index.js

@@ -0,0 +1,53 @@
+"use strict";
+/**
+ * Leeo React Native SDK
+ *
+ * Two flows: Manual (startTrip/stopTrip) and Shift (startShift/stopShift).
+ * Setup calls fleet-service: POST /fleet/v1/sdk/setup with sdk_key in body.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Leeo = exports.DEFAULT_BASE_URL = void 0;
+const react_native_1 = require("react-native");
+const { LeeoSdk } = react_native_1.NativeModules;
+/** Production API base URL. Omit or leave empty in config to use this. */
+exports.DEFAULT_BASE_URL = 'https://api.leeoinsurance.com';
+function normalizeConfig(config) {
+    const baseUrl = (config.baseUrl ?? '').trim();
+    return {
+        ...config,
+        baseUrl: baseUrl || exports.DEFAULT_BASE_URL,
+    };
+}
+exports.Leeo = {
+    setup(config, tripNotification) {
+        const normalized = normalizeConfig(config);
+        return LeeoSdk?.setup?.(normalized, tripNotification) ?? Promise.resolve({ success: false, errorCode: 'NOT_IMPLEMENTED', message: 'Native module not linked' });
+    },
+    teardown() {
+        return LeeoSdk?.teardown?.() ?? Promise.resolve({ success: true });
+    },
+    startTrip(trackingId) {
+        return LeeoSdk?.startTrip?.(trackingId) ?? Promise.resolve({ success: false, errorCode: 'NOT_IMPLEMENTED', message: 'Not implemented' });
+    },
+    stopTrip() {
+        return LeeoSdk?.stopTrip?.() ?? Promise.resolve({ success: true });
+    },
+    startShift(shiftId) {
+        return LeeoSdk?.startShift?.(shiftId) ?? Promise.resolve({ success: false, errorCode: 'NOT_IMPLEMENTED', message: 'Not implemented' });
+    },
+    stopShift() {
+        return LeeoSdk?.stopShift?.() ?? Promise.resolve({ success: true });
+    },
+    wipeOut() {
+        return LeeoSdk?.wipeOut?.() ?? Promise.resolve({ success: true });
+    },
+    getBuildVersion() {
+        return LeeoSdk?.getBuildVersion?.() ?? '0.1.0';
+    },
+    openIncidentReportingWebPage() {
+        return LeeoSdk?.openIncidentReportingWebPage?.() ?? Promise.resolve({ success: false, errorCode: 'NOT_IMPLEMENTED', message: 'Not implemented' });
+    },
+    getIncidentReportingURL() {
+        return LeeoSdk?.getIncidentReportingURL?.() ?? Promise.resolve({ success: false, errorCode: 'NOT_IMPLEMENTED' });
+    },
+};

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "leeo-react-native-sdk",
+  "version": "0.1.0",
+  "description": "Leeo SDK for React Native – trip tracking and incident reporting",
+  "main": "lib/commonjs/index.js",
+  "module": "lib/module/index.js",
+  "types": "lib/typescript/index.d.ts",
+  "react-native": "src/index.ts",
+  "source": "src/index.ts",
+  "scripts": {
+    "build": "npx tsc",
+    "prepare": "npm run build"
+  },
+  "keywords": ["react-native", "leeo", "trip", "drivequant"],
+  "repository": { "type": "git", "url": "" },
+  "author": "",
+  "license": "UNLICENSED",
+  "devDependencies": {
+    "react-native": "*",
+    "typescript": "^5.0.0"
+  },
+  "peerDependencies": {
+    "react-native": "*"
+  },
+  "optionalDependencies": {
+    "leeo-ios-sdk": "*"
+  },
+  "files": [
+    "src",
+    "ios",
+    "android",
+    "LeeoSdk.podspec",
+    "lib"
+  ]
+}

package/src/index.ts

@@ -0,0 +1,88 @@
+/**
+ * Leeo React Native SDK
+ *
+ * Two flows: Manual (startTrip/stopTrip) and Shift (startShift/stopShift).
+ * Setup calls fleet-service: POST /fleet/v1/sdk/setup with sdk_key in body.
+ */
+
+import { NativeModules } from 'react-native';
+
+const { LeeoSdk } = NativeModules;
+
+/** Production API base URL. Omit or leave empty in config to use this. */
+export const DEFAULT_BASE_URL = 'https://api.leeoinsurance.com';
+
+export interface LeeoConfiguration {
+  /** Fleet-service base URL. Defaults to [DEFAULT_BASE_URL]. No trailing slash. */
+  baseUrl?: string;
+  sdkKey: string;
+  driverId: string;
+  driverAttributes: {
+    firstName: string;
+    lastName: string;
+    email: string;
+    phoneNumber: string;
+  };
+}
+
+export interface LeeoTripNotification {
+  title: string;
+  content: string;
+  iconId?: number;
+}
+
+export type LeeoOperationResult = { success: true } | { success: false; errorCode: string; message: string };
+
+function normalizeConfig(config: LeeoConfiguration): LeeoConfiguration & { baseUrl: string } {
+  const baseUrl = (config.baseUrl ?? '').trim();
+  return {
+    ...config,
+    baseUrl: baseUrl || DEFAULT_BASE_URL,
+  };
+}
+
+export const Leeo = {
+  setup(
+    config: LeeoConfiguration,
+    tripNotification: LeeoTripNotification
+  ): Promise<LeeoOperationResult> {
+    const normalized = normalizeConfig(config);
+    return LeeoSdk?.setup?.(normalized, tripNotification) ?? Promise.resolve({ success: false, errorCode: 'NOT_IMPLEMENTED', message: 'Native module not linked' });
+  },
+
+  teardown(): Promise<LeeoOperationResult> {
+    return LeeoSdk?.teardown?.() ?? Promise.resolve({ success: true });
+  },
+
+  startTrip(trackingId: string): Promise<LeeoOperationResult> {
+    return LeeoSdk?.startTrip?.(trackingId) ?? Promise.resolve({ success: false, errorCode: 'NOT_IMPLEMENTED', message: 'Not implemented' });
+  },
+
+  stopTrip(): Promise<LeeoOperationResult> {
+    return LeeoSdk?.stopTrip?.() ?? Promise.resolve({ success: true });
+  },
+
+  startShift(shiftId?: string): Promise<LeeoOperationResult> {
+    return LeeoSdk?.startShift?.(shiftId) ?? Promise.resolve({ success: false, errorCode: 'NOT_IMPLEMENTED', message: 'Not implemented' });
+  },
+
+  stopShift(): Promise<LeeoOperationResult> {
+    return LeeoSdk?.stopShift?.() ?? Promise.resolve({ success: true });
+  },
+
+  wipeOut(): Promise<LeeoOperationResult> {
+    return LeeoSdk?.wipeOut?.() ?? Promise.resolve({ success: true });
+  },
+
+  getBuildVersion(): string {
+    return LeeoSdk?.getBuildVersion?.() ?? '0.1.0';
+  },
+
+  openIncidentReportingWebPage(): Promise<LeeoOperationResult> {
+    return LeeoSdk?.openIncidentReportingWebPage?.() ?? Promise.resolve({ success: false, errorCode: 'NOT_IMPLEMENTED', message: 'Not implemented' });
+  },
+
+  getIncidentReportingURL(): Promise<string | { success: false; errorCode: string }> {
+    return LeeoSdk?.getIncidentReportingURL?.() ?? Promise.resolve({ success: false, errorCode: 'NOT_IMPLEMENTED' });
+  },
+};