react-native-move-sdk 2.4.2 → 2.4.3

package/android/src/main/java/in/dolph/move/sdk/NativeMoveSdkWrapper.kt

@@ -5,14 +5,19 @@ import android.content.Context
 import android.util.Log
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReadableArray
-import io.dolphin.move.MoveAssistanceCallStatus
+import com.facebook.react.bridge.ReadableMap
+import com.google.gson.Gson
+import io.dolphin.move.DeviceDiscovery
 import io.dolphin.move.DrivingService
+import io.dolphin.move.MoveAssistanceCallStatus
 import io.dolphin.move.MoveAuth
 import io.dolphin.move.MoveAuthState
 import io.dolphin.move.MoveConfig
 import io.dolphin.move.MoveConfigurationError
 import io.dolphin.move.MoveDetectionService
+import io.dolphin.move.MoveDevice
 import io.dolphin.move.MoveOptions
+import io.dolphin.move.MoveScanResult
 import io.dolphin.move.MoveSdk
 import io.dolphin.move.MoveSdkState
 import io.dolphin.move.MoveServiceFailure
@@ -20,11 +25,16 @@ import io.dolphin.move.MoveServiceWarning
 import io.dolphin.move.MoveShutdownResult
 import io.dolphin.move.MoveTripState
 import io.dolphin.move.WalkingService
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
 
 @SuppressLint("StaticFieldLeak", "MissingPermission")
 class NativeMoveSdkWrapper(private val context: Context) : MoveSdk.StateListener,
   MoveSdk.InitializeListener, MoveSdk.TripStateListener, MoveSdk.AuthStateUpdateListener,
-  MoveSdk.MoveLogCallback, MoveSdk.MoveErrorListener, MoveSdk.MoveWarningListener {
+  MoveSdk.MoveLogCallback, MoveSdk.MoveErrorListener, MoveSdk.MoveWarningListener,
+  MoveSdk.DeviceDiscoveryListener {
 
   companion object {
 
@@ -40,8 +50,12 @@ class NativeMoveSdkWrapper(private val context: Context) : MoveSdk.StateListener
   }
 
   private val configRepository = MoveSdkConfigRepository(context)
+  private val deviceScanner = DeviceScanner(context)
 
   private var delegate: MoveSdkModule? = null
+  private val mainScope = CoroutineScope(Dispatchers.Main)
+  private val ioContext = Dispatchers.IO
+  private val gson = Gson()
 
   fun init(context: Context) {
     val moveSdk = MoveSdk.init(context.applicationContext)
@@ -55,6 +69,8 @@ class NativeMoveSdkWrapper(private val context: Context) : MoveSdk.StateListener
     moveSdk.setServiceErrorListener(this)
     moveSdk.setServiceWarningListener(this)
 
+    moveSdk.deviceDiscoveryListener(this)
+
     // Initialize notifications by default (might be overwritten by setup)
     val config: MoveSdkConfig = configRepository.loadConfig()
     try {
@@ -87,7 +103,7 @@ class NativeMoveSdkWrapper(private val context: Context) : MoveSdk.StateListener
     timelineDetectionServices: ReadableArray,
     drivingServices: ReadableArray,
     walkingServices: ReadableArray,
-    options: ReadableArray,
+    options: ReadableMap?,
     // Platform config
     recognitionNotificationTitle: String,
     recognitionNotificationText: String,
@@ -149,7 +165,27 @@ class NativeMoveSdkWrapper(private val context: Context) : MoveSdk.StateListener
     // TODO - just use recognition notification for now
     val walkingNotification = recognitionNotification
 
-    val featureOptions = options.toArrayList().map { it.toString().snakeToUpperCamelCaseParam() }
+    val featureOptions = options?.toHashMap()
+    val moveOptions = try {
+      val motionPermissionMandatory = featureOptions?.get("motionPermissionMandatory") as? Boolean
+      val deviceDiscovery = featureOptions?.get("deviceDiscovery") as? Map<String, Any>
+      val startDelay = deviceDiscovery?.get("startDelay") as? Double
+      val duration = deviceDiscovery?.get("duration") as? Double
+      val interval = deviceDiscovery?.get("interval") as? Double
+      val stopScanOnFirstDiscovered = deviceDiscovery?.get("stopScanOnFirstDiscovered") as? Boolean
+      MoveOptions(
+        motionPermissionRequired = motionPermissionMandatory ?: false,
+        deviceDiscovery = DeviceDiscovery(
+          startDelay = startDelay?.toLong(),
+          duration = duration?.toLong(),
+          interval = interval?.toLong(),
+          stopScanOnFirstDiscovered = stopScanOnFirstDiscovered ?: false,
+        ),
+      )
+    } catch (e: Exception) {
+      Log.e(MoveSdkModule.LOG_TAG, "setup: ${e.message}", e)
+      null
+    }
 
     try {
       Log.d(MoveSdkModule.LOG_TAG, "MOVE SDK Version " + MoveSdk.version)
@@ -166,11 +202,6 @@ class NativeMoveSdkWrapper(private val context: Context) : MoveSdk.StateListener
         it.walkingLocationNotification(walkingNotification.toAndroidNotification(context))
       }
       val moveConfig = MoveConfig(timelineDetectionServicesToUse)
-      val moveOptions = MoveOptions(
-        motionPermissionRequired = featureOptions.contains(
-          MoveOptions::class.java.declaredFields[0].name
-        ),
-      )
       MoveSdk.setup(
         auth = moveAuth,
         config = moveConfig,
@@ -212,7 +243,7 @@ class NativeMoveSdkWrapper(private val context: Context) : MoveSdk.StateListener
     configRepository.clear()
 
     MoveSdk.get()?.shutdown(force) { result ->
-      when(result) {
+      when (result) {
         MoveShutdownResult.SUCCESS -> promise?.resolve(result.name.toSnakeCase())
         MoveShutdownResult.NETWORK_ERROR,
         MoveShutdownResult.UNINITIALIZED -> promise?.reject(Exception(result.name.toSnakeCase()))
@@ -387,7 +418,11 @@ class NativeMoveSdkWrapper(private val context: Context) : MoveSdk.StateListener
     delegate?.emitDeviceEvent(eventName, eventData)
   }
 
-  private fun emitDeviceEvent(eventName: String, eventData: Array<Any>) {
+  fun emitDeviceEvent(eventName: String, eventData: Array<Any>) {
+    delegate?.emitDeviceEvent(eventName, eventData)
+  }
+
+  fun emitDeviceEvent(eventName: String, eventData: String) {
     delegate?.emitDeviceEvent(eventName, eventData)
   }
 
@@ -411,12 +446,66 @@ class NativeMoveSdkWrapper(private val context: Context) : MoveSdk.StateListener
   }
 
   fun getDeviceQualifier(): String? {
-    return  MoveSdk.get()?.getDeviceQualifier()
+    return MoveSdk.get()?.getDeviceQualifier()
   }
 
   fun isAuthValid(): Boolean {
     return MoveSdk.get()?.getAuthState() is MoveAuthState.VALID
   }
+
+  override fun onScanResult(results: List<MoveScanResult>) {
+    emitDeviceEvent(EVENT_MOVE_SCAN_RESULT, results.toScanResultArray())
+  }
+
+  fun registerDevices(rawData: ArrayList<Map<String, String>>?) {
+    val devices = rawData?.mapNotNull {
+      try {
+        gson.fromJson(it["data"], MoveDevice::class.java)
+      } catch (e: Exception) {
+        null
+      }
+    }.orEmpty()
+    MoveSdk.get()?.registerDevices(devices)
+  }
+
+  fun unregisterDevices(rawData: ArrayList<Map<String, String>>?) {
+    val devices = rawData?.mapNotNull {
+      try {
+        gson.fromJson(it["data"], MoveDevice::class.java)
+      } catch (e: Exception) {
+        null
+      }
+    }.orEmpty()
+    MoveSdk.get()?.unregisterDevices(devices)
+  }
+
+  fun getRegisteredDevices(promise: Promise) {
+    mainScope.launch {
+      val devices = mutableListOf<MoveDevice>()
+      withContext(ioContext) {
+        MoveSdk.get()?.getRegisteredDevices()?.let(devices::addAll)
+      }
+      promise.resolve(devices.toMoveDeviceTypedArray().toWritableArray())
+    }
+  }
+
+  fun startScanningDevices(filters: List<String>, manufacturerId: Int?, uuid: String?) {
+    deviceScanner.startScanning(
+      filters,
+      manufacturerId.takeIf { it != -1 },
+      uuid,
+      onNewDevices = {
+        emitDeviceEvent(EVENT_MOVE_DEVICES, it.toMoveDeviceTypedArray())
+      },
+      onNewEvent = { eventName, value ->
+        emitDeviceEvent(EVENT_MOVE_SDK_APP, "$eventName ${value ?: ""}".trim())
+      },
+    )
+  }
+
+  fun stopScanningDevices() {
+    deviceScanner.stopScanning()
+  }
 }
 
 fun List<MoveServiceFailure>.failuresToArray(): Array<Any> {

package/ios/NativeModule/MoveSdk.h

@@ -20,7 +20,7 @@ RCT_EXTERN_METHOD(setup: (NSString *)contractId
 				  timelineDetectionServices: (NSArray<NSString> *)timelineDetectionServices
                   drivingServices: (NSArray<NSString> *)drivingServices
                   walkingServices: (NSArray<NSString> *)walkingServices
-				  options: (NSArray<NSString> *)options
+				  options: (id)options
                   resolve: (RCTPromiseResolveBlock)resolve
                   reject: (RCTPromiseRejectBlock)reject)
 				  
@@ -62,6 +62,19 @@ RCT_EXTERN_METHOD(ignoreCurrentTrip)
 
 RCT_EXTERN_METHOD(finishCurrentTrip)
 
+RCT_EXTERN_METHOD(startScanningDevices: (NSArray*) filter
+				  uuid: (NSString*) uuid
+				  manufacturerId: (id)manufacturerId)
+
+RCT_EXTERN_METHOD(stopScanningDevices)
+
+RCT_EXTERN_METHOD(registerDevices: (NSArray*>)devices)
+
+RCT_EXTERN_METHOD(unregisterDevices: (NSArray*>)devices)
+
+RCT_EXTERN_METHOD(getRegisteredDevices: (RCTPromiseResolveBlock)resolve
+				  rejecter: (RCTPromiseRejectBlock)reject)
+
 RCT_EXTERN_METHOD(getAuthState: (RCTPromiseResolveBlock)resolve
                   rejecter: (RCTPromiseRejectBlock)reject)
 

package/ios/NativeModule/MoveSdk.swift

@@ -3,7 +3,7 @@ import Foundation
 import DolphinMoveSDK
 
 internal protocol MoveSDKLauncherDelegate: AnyObject {
-	func send(event: MoveSDKLauncher.Event, data: [String: Any])
+	func send(event: MoveSDKLauncher.Event, data: Any)
 }
 
 typealias MoveSDKErrorListItem = [String:Any]
@@ -33,6 +33,7 @@ class RCTMoveSdk: RCTEventEmitter {
 	}
 
 	let motionManager = CMMotionActivityManager()
+	var scanner: MoveSdkDeviceScanner?
 
 	override func startObserving() {
 		MoveSDKLauncher.shared.delegate = self
@@ -46,7 +47,7 @@ class RCTMoveSdk: RCTEventEmitter {
 			   timelineDetectionServices: Array<String>,
 			   drivingServices: Array<String>,
 			   walkingServices: Array<String>,
-			   options: Array<String>,
+			   options: Any,
 			   resolve: @escaping RCTPromiseResolveBlock,
 			   reject: @escaping RCTPromiseRejectBlock) {
 
@@ -94,10 +95,7 @@ class RCTMoveSdk: RCTEventEmitter {
 			// TODO: Fix wrapper and add config option from RN for walking services (actually only 1 now)
 			let sdkConfig = MoveConfig(detectionService: transformedDetectionServices)
 			let auth = MoveAuth(userToken: accessToken, refreshToken: refreshToken, userID: contractId, projectID: productId)
-			var moveOptions = MoveOptions()
-			if options.contains("MOTION_PERMISSION_REQUIRE") {
-				moveOptions.insert(.motionPermissionMandatory)
-			}
+			let moveOptions = convert(options: options)
 
 			MoveSDKLauncher.shared.setup(auth: auth, config: sdkConfig, options: moveOptions)
 			resolve("OK")
@@ -106,6 +104,36 @@ class RCTMoveSdk: RCTEventEmitter {
 		}
 	}
 
+	private func convert(options: Any) -> MoveOptions {
+		let moveOptions = MoveOptions()
+
+		if let opts = options as? [String: Any] {
+			if let value = opts["motionPermissionMandatory"] as? Bool {
+				moveOptions.motionPermissionMandatory = value
+			}
+
+			if let deviceDiscovery = opts["deviceDiscovery"] as? [String: Any] {
+				if let value = deviceDiscovery["startDelay"] as? Double {
+					moveOptions.deviceDiscovery.startDelay = value
+				}
+
+				if let value = deviceDiscovery["duration"] as? Double {
+					moveOptions.deviceDiscovery.duration = value
+				}
+
+				if let value = deviceDiscovery["interval"] as? Double {
+					moveOptions.deviceDiscovery.interval = value
+				}
+
+				if let value = deviceDiscovery["stopScanOnFirstDiscovered"] as? Bool {
+					moveOptions.deviceDiscovery.stopScanOnFirstDiscovered = value
+				}
+			}
+		}
+
+		return moveOptions
+	}
+
 	@objc
 	func getState(
 		_ resolve: RCTPromiseResolveBlock,
@@ -124,12 +152,26 @@ class RCTMoveSdk: RCTEventEmitter {
 		resolve(value)
 	}
 
+	@objc
+	func getRegisteredDevices(
+		_ resolve: RCTPromiseResolveBlock,
+		rejecter reject: RCTPromiseRejectBlock
+	) {
+		let value = MoveSDKLauncher.shared.convert(devices: MoveSDK.shared.getRegisteredDevices())
+		resolve(value)
+	}
+
 	@objc
 	func isAuthValid(
 		_ resolve: RCTPromiseResolveBlock,
 		rejecter reject: RCTPromiseRejectBlock
 	) {
-		resolve(MoveSDK.shared.getAuthState() != .expired)
+		switch MoveSDK.shared.getAuthState() {
+			case .invalid, .expired:
+				resolve(false)
+			default:
+				resolve(true)
+		}
 	}
 
 	@objc 
@@ -283,6 +325,32 @@ class RCTMoveSdk: RCTEventEmitter {
 		MoveSDKLauncher.shared.sdk.finishCurrentTrip()
 	}
 
+	@objc
+	func startScanningDevices(_ filter: [String], uuid: String?, manufacturerId: Any?) {
+		if scanner == nil {
+			scanner = MoveSdkDeviceScanner()
+		}
+		scanner?.delegate = self
+		scanner?.startScanning(filter: filter, uuid: uuid)
+	}
+
+	@objc
+	func registerDevices(_ devices: [Any]) {
+		let devices = MoveSDKLauncher.shared.convert(devices: devices)
+		MoveSDKLauncher.shared.sdk.register(devices: devices)
+	}
+
+	@objc
+	func unregisterDevices(_ devices: [Any]) {
+		let devices = MoveSDKLauncher.shared.convert(devices: devices)
+		MoveSDKLauncher.shared.sdk.unregister(devices: devices)
+	}
+
+	@objc
+	func stopScanningDevices() {
+		scanner?.stopScanning()
+	}
+
 	@objc
 	func resolveError() {
 		MoveSDKLauncher.shared.sdk.resolveSDKStateError()
@@ -322,8 +390,14 @@ class RCTMoveSdk: RCTEventEmitter {
 	}
 }
 
+extension RCTMoveSdk: MoveSdkDeviceScannerDelegate {
+	func didDiscover(devices: [MoveSdkDeviceScanner.DeviceEntry]) {
+		send(event: .devices, data: MoveSDKLauncher.shared.convert(devices: devices))
+	}
+}
+
 extension RCTMoveSdk: MoveSDKLauncherDelegate {
-	func send(event: MoveSDKLauncher.Event, data: [String: Any]) {
+	func send(event: MoveSDKLauncher.Event, data: Any) {
 		sendEvent(withName: event.rawValue, body: data)
 	}
 }
@@ -336,6 +410,8 @@ internal class MoveSDKLauncher {
 		case authState = "MOVE_SDK_AUTH_STATE"
 		case warning = "MOVE_SDK_WARNINGS"
 		case failure = "MOVE_SDK_ERRORS"
+		case devices = "MOVE_SDK_DEVICES"
+		case scanResult = "MOVE_SDK_SCAN_RESULT"
 	}
 
 	private enum DefaultsKey: String {
@@ -375,6 +451,11 @@ internal class MoveSDKLauncher {
 			let data: [String: Any] = ["warnings": self.convert(warnings: warnings)]
 			self.delegate?.send(event: .warning, data: data)
 		}
+
+		sdk.setDeviceDiscoveryListener { scanResults in
+			let data = self.convert(scanResults: scanResults)
+			self.delegate?.send(event: .scanResult, data: data)
+		}
 	}
 
 	func getServiceWarnings() -> [MoveSDKErrorListItem] {
@@ -385,6 +466,58 @@ internal class MoveSDKLauncher {
 		return convert(failures: sdk.getServiceFailures())
 	}
 
+	func convert(devices: [Any]) -> [MoveDevice] {
+		return devices.compactMap { values in
+			guard let values = values as? [String: String] else { return nil }
+//			let name: String = values["name"] ?? ""
+			let encoded: String = values["data"] ?? ""
+
+			let decoder = JSONDecoder()
+			guard let data = encoded.data(using: .utf8) else { return nil }
+			do {
+				let device = try decoder.decode(MoveDevice.self, from: data)
+				/* keep device name from info */
+				return device
+			} catch {
+				return nil
+			}
+		}
+	}
+
+	func convert(devices: [MoveSdkDeviceScanner.DeviceEntry]) -> [[String:String]] {
+		var deviceList: [[String: String]] = []
+		for device in devices {
+			let encoder = JSONEncoder()
+			do {
+				let data = try encoder.encode(device.device)
+				let str = String(data: data, encoding: .utf8) ?? ""
+				let info: [String: String] = ["name":device.name, "data": str]
+				deviceList.append(info)
+			} catch {
+				print(error.localizedDescription)
+			}
+		}
+
+		return deviceList
+	}
+
+	func convert(scanResults: [MoveScanResult]) -> [[String:Any]] {
+		var deviceList: [[String: Any]] = []
+		for result in scanResults {
+			let encoder = JSONEncoder()
+			do {
+				let data = try encoder.encode(result.device)
+				let str = String(data: data, encoding: .utf8) ?? ""
+				let info: [String: Any] = ["name":result.device.name, "device": str, "isDiscovered": result.isDiscovered]
+				deviceList.append(info)
+			} catch {
+				print(error.localizedDescription)
+			}
+		}
+
+		return deviceList
+	}
+
 	func convert(service: DolphinMoveSDK.MoveConfig.DetectionService) -> String {
 		return service.debugDescription
 //		switch service {
@@ -428,8 +561,6 @@ internal class MoveSDKLauncher {
 				reasons = content
 			case .unauthorized:
 				reasons = ["Unauthorized"]
-			@unknown default:
-				break
 			}
 			converted.append(["service": convert(service: failure.service), "reasons": reasons])
 		}
@@ -446,8 +577,6 @@ internal class MoveSDKLauncher {
 			case let .missingPermission(permissions):
 				let content: [String] = permissions.map { self.permissionString($0) }
 				reasons = content
-			@unknown default:
-				break
 			}
 			converted.append(["service": convert(service: warning.service), "reasons": reasons])
 		}

package/ios/NativeModule/MoveSdkDeviceScanner.swift

@@ -0,0 +1,127 @@
+import AVFoundation
+import CoreLocation
+import Foundation
+import DolphinMoveSDK
+
+internal protocol MoveSdkDeviceScannerDelegate: AnyObject {
+	func didDiscover(devices: [MoveSdkDeviceScanner.DeviceEntry])
+}
+
+internal class MoveSdkDeviceScanner: NSObject {
+	struct DeviceEntry {
+		let device: MoveDevice
+		let name: String
+	}
+
+	private let allowedPorts: [AVAudioSession.Port] = [.bluetoothA2DP, .bluetoothHFP, .bluetoothLE, .carAudio]
+
+	private let session = AVAudioSession.sharedInstance()
+	private let locationManager = CLLocationManager()
+	private var devices: [DeviceEntry] = []
+	private var timer: Timer?
+	private var beaconRegion: CLBeaconRegion?
+	internal var delegate: MoveSdkDeviceScannerDelegate?
+
+	override init() {
+		super.init()
+		locationManager.delegate = self
+		do {
+			try session.setCategory(.playAndRecord, options: [.allowAirPlay, .allowBluetoothA2DP, .allowBluetooth])
+		} catch {
+			print("\(error)")
+		}
+	}
+
+	func scanAudioPorts() {
+		let devices: [DeviceEntry] = (session.availableInputs ?? []).compactMap {
+			if !allowedPorts.contains($0.portType) { return nil }
+			let device = MoveDevice(name: $0.uid, id: $0.uid)
+			return DeviceEntry(device: device, name: "\($0.portName)")
+		}
+
+		add(devices: devices)
+	}
+
+	func scanBeacons(uuid: UUID) {
+		let beaconRegion = CLBeaconRegion(proximityUUID: uuid, identifier: "beacons [\(uuid)]")
+		locationManager.startRangingBeacons(in: beaconRegion)
+		locationManager.requestState(for: beaconRegion)
+		self.beaconRegion = beaconRegion
+	}
+
+	func add(devices: [DeviceEntry]) {
+		let devices = devices.filter { device in
+			!self.devices.contains { $0.device == device.device }
+		}
+
+		if !devices.isEmpty {
+			self.devices += devices
+			delegate?.didDiscover(devices: devices)
+		}
+	}
+
+	func startScanning(filter: [String], uuid uuidString: String? = nil) {
+		devices = []
+
+		if filter.contains("paired") {
+			self.scanAudioPorts()
+
+			let timer = Timer(timeInterval: 1.0, repeats: true) { _ in
+				self.scanAudioPorts()
+			}
+
+			self.timer = timer
+
+			RunLoop.main.add(timer, forMode: .default)
+		}
+
+		if filter.contains("beacon"), let uuidString = uuidString, let uuid = UUID(uuidString: uuidString) {
+			scanBeacons(uuid: uuid)
+		}
+	}
+
+	func stopScanning() {
+		if let beaconRegion = self.beaconRegion {
+			locationManager.stopRangingBeacons(in: beaconRegion)
+		}
+		timer?.invalidate()
+		timer = nil
+	}
+}
+
+extension MoveSdkDeviceScanner: CLLocationManagerDelegate {
+	func locationManager(_ manager: CLLocationManager, didRangeBeacons beacons: [CLBeacon], in region: CLBeaconRegion) {
+
+		let devices = beacons.map {
+			let name = "Beacon \($0.major):\($0.minor)"
+			let device = MoveDevice(name: name, proximityUUID: $0.proximityUUID, major: UInt16(truncating: $0.major), minor: UInt16(truncating: $0.minor))
+			return DeviceEntry(device: device, name: name)
+		}
+
+		add(devices: devices)
+	}
+
+	func locationManager(_ manager: CLLocationManager, rangingBeaconsDidFailFor region: CLBeaconRegion, withError error: Error) {
+		print("rangingBeaconsDidFailFor: \(region)")
+	}
+
+	func locationManager(_ manager: CLLocationManager, didFailWithError error: Error) {
+		print("fail: \(error)")
+	}
+
+	func locationManager(_ manager: CLLocationManager, monitoringDidFailFor region: CLRegion?, withError error: Error) {
+		print("monitoringDidFailFor: \(String(describing: region)) \(error)")
+	}
+
+	func locationManager(_ manager: CLLocationManager, didEnterRegion region: CLRegion) {
+		print("didEnterRegion: \(region)")
+	}
+
+	func locationManager(_ manager: CLLocationManager, didExitRegion region: CLRegion) {
+		print("didExitRegion: \(region)")
+	}
+
+	func locationManager(_ manager: CLLocationManager, didDetermineState state: CLRegionState, for region: CLRegion) {
+		print("didDetermineState: \(region) : \(state)")
+	}
+}

package/lib/commonjs/index.js

@@ -70,7 +70,7 @@ class MoveSdk {
     }
 
     return await NativeMoveSdk.setup(userId, accessToken, refreshToken, projectId, // Config
-    timelineDetectionServices, drivingServices, walkingServices, options || [], // Platform config
+    timelineDetectionServices, drivingServices, walkingServices, options, // Platform config
     ...platformParams);
   }
 
@@ -262,6 +262,42 @@ class MoveSdk {
   } // **** PERMISSIONS MODULE END *****
 
 
+  static startScanningDevices(sdkDevicesDetected) {
+    let filter = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ["paired"];
+    let uuid = arguments.length > 2 ? arguments[2] : undefined;
+    let manufacturerId = arguments.length > 3 ? arguments[3] : undefined;
+    const subscription = eventEmitter.addListener('MOVE_SDK_DEVICES', devices => {
+      sdkDevicesDetected(devices);
+    });
+    const subscriptionRemove = subscription.remove;
+
+    subscription.remove = () => {
+      NativeMoveSdk.stopScanningDevices();
+      subscriptionRemove();
+    };
+
+    NativeMoveSdk.startScanningDevices(filter, uuid, manufacturerId !== null && manufacturerId !== void 0 ? manufacturerId : -1);
+    return subscription;
+  }
+
+  static async getRegisteredDevices() {
+    return await NativeMoveSdk.getRegisteredDevices();
+  }
+
+  static registerDevices(devices) {
+    NativeMoveSdk.registerDevices(devices);
+  }
+
+  static unregisterDevices(devices) {
+    NativeMoveSdk.registerDevices(devices);
+  }
+
+  static addDeviceDiscoveryListener(onScanResult) {
+    return eventEmitter.addListener('MOVE_SDK_SCAN_RESULT', results => {
+      onScanResult(results);
+    });
+  }
+
 }
 
 exports.default = MoveSdk;