wiliot-sdk-rn 1.0.0

package/GatewaySdk.podspec

@@ -0,0 +1,27 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name         = "GatewaySdk"
+  s.version      = package['version']
+  s.summary      = package['description']
+  s.homepage     = "https://github.com/example/gateway-sdk"
+  s.license      = package['license']
+  s.authors      = { "Gateway SDK" => "sdk@example.com" }
+  s.platforms    = { :ios => "13.0" }
+  s.source       = { :git => "https://github.com/example/gateway-sdk.git", :tag => "v#{s.version}" }
+
+  s.source_files = "ios/**/*.{h,m,mm,swift}"
+  s.exclude_files = "ios/Pods/**/*"
+
+  s.dependency "React-Core"
+
+  # Enable Swift
+  s.swift_version = "5.0"
+
+  # Info.plist settings documentation
+  s.info_plist = {
+    'UIBackgroundModes' => ['bluetooth-central']
+  }
+end

package/README.md

@@ -0,0 +1,99 @@
+# wiliot-sdk-rn
+
+Wiliot SDK for React Native - BLE scanning, MQTT, bridges, pixels, and IoT device management.
+
+## Installation
+
+```bash
+npm install wiliot-sdk-rn react-native-ble-manager sp-react-native-mqtt @react-native-async-storage/async-storage
+cd ios && pod install
+```
+
+## Quick Start
+
+```tsx
+import { SdkProvider, useSdk, useSdkState } from 'wiliot-sdk-rn';
+
+// 1. Wrap your app (in App.tsx)
+export default function App() {
+  return (
+    <SdkProvider
+      config={{
+        apiBaseUrl: 'https://api.wiliot.com',
+        mqttBrokerUrl: 'mqtts://mqtt.wiliot.com:8883',
+        ownerId: 'YOUR_OWNER_ID',
+        apiKey: 'YOUR_API_KEY',
+      }}
+      autoInitialize
+    >
+      <YourApp />
+    </SdkProvider>
+  );
+}
+
+// 2. Use anywhere in your app
+function ScanScreen() {
+  const { startScan, stopScan } = useSdk();
+  const { isScanning, connectionState, devices } = useSdkState();
+
+  return (
+    <View>
+      <Text>Status: {connectionState}</Text>
+      <Button title={isScanning ? 'Stop' : 'Scan'} onPress={() => isScanning ? stopScan() : startScan()} />
+      <FlatList data={Object.values(devices)} renderItem={({ item }) => <Text>{item.id}</Text>} />
+    </View>
+  );
+}
+```
+
+## Platform Setup
+
+### iOS (Info.plist)
+```xml
+<key>NSBluetoothAlwaysUsageDescription</key>
+<string>Required for BLE scanning</string>
+<key>UIBackgroundModes</key>
+<array><string>bluetooth-central</string></array>
+```
+
+### Android
+No additional setup needed - permissions are included automatically.
+
+## Hooks
+
+| Hook | Returns |
+|------|---------|
+| `useSdk()` | `{ sdk, initialize, startScan, stopScan, connect, disconnect, shutdown }` |
+| `useSdkState()` | `{ initialized, isScanning, connectionState, packetsForwarded, devices, ... }` |
+| `useSdkReady()` | `boolean` - true when initialized and connected |
+| `useDevices()` | `BleDevice[]` - discovered devices |
+| `useConnectionState()` | `'disconnected' \| 'connecting' \| 'connected' \| 'error'` |
+| `useIsScanning()` | `boolean` |
+
+## Background Scanning
+
+```tsx
+// Enable background scanning (foreground service on Android)
+const { startScan } = useSdk();
+await startScan(true); // true = background enabled
+```
+
+## Advanced: Direct SDK Access
+
+```tsx
+import { createGatewaySDK } from 'wiliot-sdk-rn';
+
+const sdk = createGatewaySDK({
+  apiBaseUrl: 'https://api.wiliot.com',
+  mqttBrokerUrl: 'mqtts://mqtt.wiliot.com:8883',
+  ownerId: 'YOUR_OWNER_ID',
+  apiKey: 'YOUR_API_KEY',
+});
+
+await sdk.initialize();
+await sdk.startScan();
+```
+
+## License
+
+MIT

package/android/build.gradle

@@ -0,0 +1,72 @@
+buildscript {
+    ext.safeExtGet = {prop, fallback ->
+        rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+    }
+    repositories {
+        google()
+        mavenCentral()
+    }
+    dependencies {
+        classpath("com.android.tools.build:gradle:8.1.0")
+        classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:${safeExtGet('kotlinVersion', '1.9.22')}")
+    }
+}
+
+plugins {
+    id 'com.android.library'
+    id 'kotlin-android'
+}
+
+def safeExtGet(prop, fallback) {
+    return rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+}
+
+android {
+    namespace "com.gatewaysdk"
+    compileSdkVersion safeExtGet('compileSdkVersion', 34)
+
+    defaultConfig {
+        minSdkVersion safeExtGet('minSdkVersion', 24)
+        targetSdkVersion safeExtGet('targetSdkVersion', 34)
+    }
+
+    buildTypes {
+        release {
+            minifyEnabled false
+        }
+    }
+
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_17
+        targetCompatibility JavaVersion.VERSION_17
+    }
+
+    kotlinOptions {
+        jvmTarget = '17'
+    }
+
+    sourceSets {
+        main {
+            java.srcDirs = ['src/main/java']
+        }
+    }
+}
+
+repositories {
+    maven {
+        url "$projectDir/../node_modules/react-native/android"
+    }
+    mavenCentral()
+    google()
+}
+
+dependencies {
+    implementation "com.facebook.react:react-android:+"
+    implementation "org.jetbrains.kotlin:kotlin-stdlib:${safeExtGet('kotlinVersion', '1.9.22')}"
+
+    // Coroutines for async operations
+    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3"
+
+    // BLE support (optional, for native-level scanning)
+    implementation "no.nordicsemi.android:ble:2.7.0"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="com.gatewaysdk">
+
+    <!-- BLE Permissions -->
+    <uses-permission android:name="android.permission.BLUETOOTH" android:maxSdkVersion="30"/>
+    <uses-permission android:name="android.permission.BLUETOOTH_ADMIN" android:maxSdkVersion="30"/>
+    <uses-permission android:name="android.permission.BLUETOOTH_SCAN" android:usesPermissionFlags="neverForLocation"/>
+    <uses-permission android:name="android.permission.BLUETOOTH_CONNECT"/>
+    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION"/>
+    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION"/>
+
+    <!-- Background Service Permissions -->
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE"/>
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_CONNECTED_DEVICE"/>
+    <uses-permission android:name="android.permission.WAKE_LOCK"/>
+    <uses-permission android:name="android.permission.REQUEST_IGNORE_BATTERY_OPTIMIZATIONS"/>
+    <uses-permission android:name="android.permission.POST_NOTIFICATIONS"/>
+
+    <!-- BLE Feature -->
+    <uses-feature android:name="android.hardware.bluetooth_le" android:required="true"/>
+
+    <application>
+        <!-- Background Scan Service -->
+        <service
+            android:name=".GatewayScanService"
+            android:enabled="true"
+            android:exported="false"
+            android:foregroundServiceType="connectedDevice"/>
+    </application>
+
+</manifest>

package/android/src/main/java/com/gatewaysdk/GatewayScanModule.kt

@@ -0,0 +1,392 @@
+package com.gatewaysdk
+
+import android.Manifest
+import android.annotation.SuppressLint
+import android.bluetooth.BluetoothAdapter
+import android.bluetooth.BluetoothManager
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.content.pm.PackageManager
+import android.net.Uri
+import android.os.Build
+import android.os.PowerManager
+import android.provider.Settings
+import androidx.core.content.ContextCompat
+import com.facebook.react.bridge.*
+import com.facebook.react.modules.core.DeviceEventManagerModule
+
+/**
+ * Gateway SDK Native Scan Module
+ *
+ * Provides native Android functionality for BLE background scanning:
+ * - Foreground service management
+ * - Battery optimization handling
+ * - Permission checking
+ * - Bluetooth state monitoring
+ */
+class GatewayScanModule(private val reactContext: ReactApplicationContext) :
+    ReactContextBaseJavaModule(reactContext) {
+
+    companion object {
+        const val NAME = "GatewayScanModule"
+
+        // Broadcast actions
+        const val ACTION_SCAN_RESTART = "com.gatewaysdk.SCAN_RESTART"
+        const val ACTION_BUFFERED_RESULTS = "com.gatewaysdk.BUFFERED_SCAN_RESULTS"
+        const val ACTION_DOZE_MODE_CHANGED = "com.gatewaysdk.DOZE_MODE_CHANGED"
+    }
+
+    private val bluetoothManager: BluetoothManager? by lazy {
+        reactContext.getSystemService(Context.BLUETOOTH_SERVICE) as? BluetoothManager
+    }
+
+    private val bluetoothAdapter: BluetoothAdapter? by lazy {
+        bluetoothManager?.adapter
+    }
+
+    private val powerManager: PowerManager? by lazy {
+        reactContext.getSystemService(Context.POWER_SERVICE) as? PowerManager
+    }
+
+    // Broadcast receivers
+    private var bluetoothReceiver: BroadcastReceiver? = null
+    private var scanRestartReceiver: BroadcastReceiver? = null
+    private var bufferedResultsReceiver: BroadcastReceiver? = null
+    private var dozeModeReceiver: BroadcastReceiver? = null
+
+    init {
+        registerReceivers()
+    }
+
+    override fun getName(): String = NAME
+
+    override fun getConstants(): Map<String, Any> {
+        return mapOf(
+            "moduleName" to NAME,
+            "supportedEvents" to listOf(
+                "BluetoothStateChanged",
+                "ScanRestartRequired",
+                "BufferedScanResults",
+                "DozeModeChanged"
+            )
+        )
+    }
+
+    // ========================================================================
+    // Background Scan Service Control
+    // ========================================================================
+
+    @ReactMethod
+    fun startBackgroundScan(promise: Promise) {
+        try {
+            val intent = Intent(reactContext, GatewayScanService::class.java).apply {
+                action = GatewayScanService.ACTION_START
+            }
+
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                reactContext.startForegroundService(intent)
+            } else {
+                reactContext.startService(intent)
+            }
+
+            promise.resolve(true)
+        } catch (e: Exception) {
+            promise.reject("START_ERROR", "Failed to start background scan: ${e.message}", e)
+        }
+    }
+
+    @ReactMethod
+    fun stopBackgroundScan(promise: Promise) {
+        try {
+            val intent = Intent(reactContext, GatewayScanService::class.java).apply {
+                action = GatewayScanService.ACTION_STOP
+            }
+            reactContext.stopService(intent)
+            promise.resolve(true)
+        } catch (e: Exception) {
+            promise.reject("STOP_ERROR", "Failed to stop background scan: ${e.message}", e)
+        }
+    }
+
+    @ReactMethod
+    fun isBackgroundScanSupported(promise: Promise) {
+        // Background scanning is supported on Android 8.0+
+        promise.resolve(Build.VERSION.SDK_INT >= Build.VERSION_CODES.O)
+    }
+
+    @ReactMethod
+    fun isServiceRunning(promise: Promise) {
+        promise.resolve(GatewayScanService.isRunning)
+    }
+
+    // ========================================================================
+    // Permission Checking
+    // ========================================================================
+
+    @ReactMethod
+    fun hasPermissions(promise: Promise) {
+        val permissions = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+            listOf(
+                Manifest.permission.BLUETOOTH_SCAN,
+                Manifest.permission.BLUETOOTH_CONNECT,
+                Manifest.permission.ACCESS_FINE_LOCATION
+            )
+        } else {
+            listOf(Manifest.permission.ACCESS_FINE_LOCATION)
+        }
+
+        val allGranted = permissions.all { permission ->
+            ContextCompat.checkSelfPermission(reactContext, permission) == PackageManager.PERMISSION_GRANTED
+        }
+
+        promise.resolve(allGranted)
+    }
+
+    @ReactMethod
+    fun hasNotificationPermission(promise: Promise) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+            val granted = ContextCompat.checkSelfPermission(
+                reactContext,
+                Manifest.permission.POST_NOTIFICATIONS
+            ) == PackageManager.PERMISSION_GRANTED
+            promise.resolve(granted)
+        } else {
+            promise.resolve(true)
+        }
+    }
+
+    // ========================================================================
+    // Battery Optimization
+    // ========================================================================
+
+    @ReactMethod
+    fun isBatteryOptimizationDisabled(promise: Promise) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+            val isIgnoring = powerManager?.isIgnoringBatteryOptimizations(reactContext.packageName) ?: false
+            promise.resolve(isIgnoring)
+        } else {
+            promise.resolve(true)
+        }
+    }
+
+    @SuppressLint("BatteryLife")
+    @ReactMethod
+    fun requestBatteryOptimizationExemption(promise: Promise) {
+        try {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+                val intent = Intent(Settings.ACTION_REQUEST_IGNORE_BATTERY_OPTIMIZATIONS).apply {
+                    data = Uri.parse("package:${reactContext.packageName}")
+                    addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+                }
+                reactContext.startActivity(intent)
+            }
+            promise.resolve(true)
+        } catch (e: Exception) {
+            promise.reject("BATTERY_OPT_ERROR", "Failed to request exemption: ${e.message}", e)
+        }
+    }
+
+    @ReactMethod
+    fun openBatteryOptimizationSettings(promise: Promise) {
+        try {
+            val intent = Intent(Settings.ACTION_IGNORE_BATTERY_OPTIMIZATION_SETTINGS).apply {
+                addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+            }
+            reactContext.startActivity(intent)
+            promise.resolve(true)
+        } catch (e: Exception) {
+            promise.reject("SETTINGS_ERROR", "Failed to open settings: ${e.message}", e)
+        }
+    }
+
+    // ========================================================================
+    // Bluetooth State
+    // ========================================================================
+
+    @ReactMethod
+    fun isBluetoothEnabled(promise: Promise) {
+        promise.resolve(bluetoothAdapter?.isEnabled ?: false)
+    }
+
+    @ReactMethod
+    fun openBluetoothSettings(promise: Promise) {
+        try {
+            val intent = Intent(Settings.ACTION_BLUETOOTH_SETTINGS).apply {
+                addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+            }
+            reactContext.startActivity(intent)
+            promise.resolve(true)
+        } catch (e: Exception) {
+            promise.reject("SETTINGS_ERROR", "Failed to open Bluetooth settings: ${e.message}", e)
+        }
+    }
+
+    // ========================================================================
+    // Device Info
+    // ========================================================================
+
+    @ReactMethod
+    fun getDeviceManufacturer(promise: Promise) {
+        promise.resolve(Build.MANUFACTURER)
+    }
+
+    @ReactMethod
+    fun isSamsungDevice(promise: Promise) {
+        promise.resolve(Build.MANUFACTURER.lowercase() == "samsung")
+    }
+
+    @ReactMethod
+    fun isDeviceInDozeMode(promise: Promise) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+            promise.resolve(powerManager?.isDeviceIdleMode ?: false)
+        } else {
+            promise.resolve(false)
+        }
+    }
+
+    @ReactMethod
+    fun getPowerStateInfo(promise: Promise) {
+        val info = Arguments.createMap().apply {
+            putBoolean("isIgnoringBatteryOptimizations",
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M)
+                    powerManager?.isIgnoringBatteryOptimizations(reactContext.packageName) ?: false
+                else true
+            )
+            putBoolean("isDeviceIdleMode",
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M)
+                    powerManager?.isDeviceIdleMode ?: false
+                else false
+            )
+            putBoolean("isPowerSaveMode",
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP)
+                    powerManager?.isPowerSaveMode ?: false
+                else false
+            )
+            putBoolean("isInteractive", powerManager?.isInteractive ?: true)
+        }
+        promise.resolve(info)
+    }
+
+    // ========================================================================
+    // Event Emitting
+    // ========================================================================
+
+    private fun sendEvent(eventName: String, params: WritableMap?) {
+        reactContext
+            .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            .emit(eventName, params)
+    }
+
+    @ReactMethod
+    fun addListener(eventName: String) {
+        // Required for RN 0.65+
+    }
+
+    @ReactMethod
+    fun removeListeners(count: Int) {
+        // Required for RN 0.65+
+    }
+
+    // ========================================================================
+    // Broadcast Receivers
+    // ========================================================================
+
+    private fun registerReceivers() {
+        // Bluetooth state receiver
+        bluetoothReceiver = object : BroadcastReceiver() {
+            override fun onReceive(context: Context?, intent: Intent?) {
+                if (intent?.action == BluetoothAdapter.ACTION_STATE_CHANGED) {
+                    val state = intent.getIntExtra(BluetoothAdapter.EXTRA_STATE, BluetoothAdapter.ERROR)
+                    val enabled = state == BluetoothAdapter.STATE_ON
+
+                    val params = Arguments.createMap().apply {
+                        putBoolean("enabled", enabled)
+                    }
+                    sendEvent("BluetoothStateChanged", params)
+                }
+            }
+        }
+
+        val bluetoothFilter = IntentFilter(BluetoothAdapter.ACTION_STATE_CHANGED)
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+            reactContext.registerReceiver(bluetoothReceiver, bluetoothFilter, Context.RECEIVER_NOT_EXPORTED)
+        } else {
+            reactContext.registerReceiver(bluetoothReceiver, bluetoothFilter)
+        }
+
+        // Scan restart receiver
+        scanRestartReceiver = object : BroadcastReceiver() {
+            override fun onReceive(context: Context?, intent: Intent?) {
+                val params = Arguments.createMap().apply {
+                    putDouble("timestamp", System.currentTimeMillis().toDouble())
+                }
+                sendEvent("ScanRestartRequired", params)
+            }
+        }
+
+        val restartFilter = IntentFilter(ACTION_SCAN_RESTART)
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+            reactContext.registerReceiver(scanRestartReceiver, restartFilter, Context.RECEIVER_NOT_EXPORTED)
+        } else {
+            reactContext.registerReceiver(scanRestartReceiver, restartFilter)
+        }
+
+        // Buffered results receiver
+        bufferedResultsReceiver = object : BroadcastReceiver() {
+            override fun onReceive(context: Context?, intent: Intent?) {
+                val results = intent?.getStringExtra("results") ?: "[]"
+                val count = intent?.getIntExtra("count", 0) ?: 0
+
+                val params = Arguments.createMap().apply {
+                    putString("results", results)
+                    putInt("count", count)
+                    putDouble("timestamp", System.currentTimeMillis().toDouble())
+                }
+                sendEvent("BufferedScanResults", params)
+            }
+        }
+
+        val bufferedFilter = IntentFilter(ACTION_BUFFERED_RESULTS)
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+            reactContext.registerReceiver(bufferedResultsReceiver, bufferedFilter, Context.RECEIVER_NOT_EXPORTED)
+        } else {
+            reactContext.registerReceiver(bufferedResultsReceiver, bufferedFilter)
+        }
+
+        // Doze mode receiver
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+            dozeModeReceiver = object : BroadcastReceiver() {
+                override fun onReceive(context: Context?, intent: Intent?) {
+                    val isDozeMode = powerManager?.isDeviceIdleMode ?: false
+                    val isBatteryOptExempt = powerManager?.isIgnoringBatteryOptimizations(
+                        reactContext.packageName
+                    ) ?: false
+
+                    val params = Arguments.createMap().apply {
+                        putBoolean("isDozeMode", isDozeMode)
+                        putBoolean("isBatteryOptExempt", isBatteryOptExempt)
+                        putDouble("timestamp", System.currentTimeMillis().toDouble())
+                    }
+                    sendEvent("DozeModeChanged", params)
+                }
+            }
+
+            val dozeFilter = IntentFilter(PowerManager.ACTION_DEVICE_IDLE_MODE_CHANGED)
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+                reactContext.registerReceiver(dozeModeReceiver, dozeFilter, Context.RECEIVER_NOT_EXPORTED)
+            } else {
+                reactContext.registerReceiver(dozeModeReceiver, dozeFilter)
+            }
+        }
+    }
+
+    override fun invalidate() {
+        super.invalidate()
+        bluetoothReceiver?.let { reactContext.unregisterReceiver(it) }
+        scanRestartReceiver?.let { reactContext.unregisterReceiver(it) }
+        bufferedResultsReceiver?.let { reactContext.unregisterReceiver(it) }
+        dozeModeReceiver?.let { reactContext.unregisterReceiver(it) }
+    }
+}