react-native-ble-nitro 1.0.0-beta.17 → 1.0.0-beta.18

package/ios/BleNitroBleManager.swift

@@ -15,46 +15,64 @@ import NitroModules
 public class BleNitroBleManager: HybridBleManagerSpec {
     
     public var memorySize: Int {
-        return MemorySize.MemorySize_estimate(self)
+        return MemoryHelper.getSizeOf(self)
     }
     
     // MARK: - HybridBleManagerSpec Implementation (Stubs)
     
     public func destroy() throws -> Promise<Void> {
-        return Promise.resolve(withResult: ())
+        return Promise { resolve, reject in
+            resolve(())
+        }
     }
     
     public func initialize(options: BleManagerNitroOptions) throws -> Promise<Void> {
-        print("BleNitro: iOS implementation not yet complete")
-        return Promise.resolve(withResult: ())
+        return Promise { resolve, reject in
+            print("BleNitro: iOS implementation not yet complete")
+            resolve(())
+        }
     }
     
     public func getRestoredState() throws -> Promise<BleRestoredState?> {
-        return Promise.resolve(withResult: nil)
+        return Promise { resolve, reject in
+            resolve(nil)
+        }
     }
     
     public func setLogLevel(logLevel: BleLogLevel) throws -> Promise<BleLogLevel> {
-        return Promise.resolve(withResult: logLevel)
+        return Promise { resolve, reject in
+            resolve(logLevel)
+        }
     }
     
     public func logLevel() throws -> Promise<BleLogLevel> {
-        return Promise.resolve(withResult: .none)
+        return Promise { resolve, reject in
+            resolve(.none)
+        }
     }
     
     public func cancelTransaction(transactionId: String) throws -> Promise<Void> {
-        return Promise.resolve(withResult: ())
+        return Promise { resolve, reject in
+            resolve(())
+        }
     }
     
     public func enable(transactionId: String?) throws -> Promise<Void> {
-        return Promise.reject(error: BleError.notImplemented("enable not implemented on iOS yet"))
+        return Promise { resolve, reject in
+            reject(BleError.notImplemented("enable not implemented on iOS yet"))
+        }
     }
     
     public func disable(transactionId: String?) throws -> Promise<Void> {
-        return Promise.reject(error: BleError.notImplemented("disable not implemented on iOS yet"))
+        return Promise { resolve, reject in
+            reject(BleError.notImplemented("disable not implemented on iOS yet"))
+        }
     }
     
     public func state() throws -> Promise<State> {
-        return Promise.resolve(withResult: .unknown)
+        return Promise { resolve, reject in
+            resolve(.unknown)
+        }
     }
     
     public func onStateChange(listener: @escaping (State) -> Void, emitCurrentState: Bool?) throws -> Subscription {
@@ -62,39 +80,57 @@ public class BleNitroBleManager: HybridBleManagerSpec {
     }
     
     public func startDeviceScan(uuids: [String]?, options: ScanOptions?, listener: @escaping (NativeBleError?, NativeDevice?) -> Void) throws -> Promise<Void> {
-        return Promise.reject(error: BleError.notImplemented("startDeviceScan not implemented on iOS yet"))
+        return Promise { resolve, reject in
+            reject(BleError.notImplemented("startDeviceScan not implemented on iOS yet"))
+        }
     }
     
     public func stopDeviceScan() throws -> Promise<Void> {
-        return Promise.resolve(withResult: ())
+        return Promise { resolve, reject in
+            resolve(())
+        }
     }
     
     public func requestConnectionPriorityForDevice(deviceIdentifier: String, connectionPriority: ConnectionPriority, transactionId: String?) throws -> Promise<NativeDevice> {
-        return Promise.reject(error: BleError.notImplemented("requestConnectionPriorityForDevice not implemented on iOS yet"))
+        return Promise { resolve, reject in
+            reject(BleError.notImplemented("requestConnectionPriorityForDevice not implemented on iOS yet"))
+        }
     }
     
     public func readRSSIForDevice(deviceIdentifier: String, transactionId: String?) throws -> Promise<NativeDevice> {
-        return Promise.reject(error: BleError.notImplemented("readRSSIForDevice not implemented on iOS yet"))
+        return Promise { resolve, reject in
+            reject(BleError.notImplemented("readRSSIForDevice not implemented on iOS yet"))
+        }
     }
     
     public func requestMTUForDevice(deviceIdentifier: String, mtu: Double, transactionId: String?) throws -> Promise<NativeDevice> {
-        return Promise.reject(error: BleError.notImplemented("requestMTUForDevice not implemented on iOS yet"))
+        return Promise { resolve, reject in
+            reject(BleError.notImplemented("requestMTUForDevice not implemented on iOS yet"))
+        }
     }
     
     public func devices(deviceIdentifiers: [String]) throws -> Promise<[NativeDevice]> {
-        return Promise.resolve(withResult: [])
+        return Promise { resolve, reject in
+            resolve([])
+        }
     }
     
     public func connectedDevices(serviceUUIDs: [String]) throws -> Promise<[NativeDevice]> {
-        return Promise.resolve(withResult: [])
+        return Promise { resolve, reject in
+            resolve([])
+        }
     }
     
     public func connectToDevice(deviceIdentifier: String, options: ConnectionOptions?) throws -> Promise<NativeDevice> {
-        return Promise.reject(error: BleError.notImplemented("connectToDevice not implemented on iOS yet"))
+        return Promise { resolve, reject in
+            reject(BleError.notImplemented("connectToDevice not implemented on iOS yet"))
+        }
     }
     
     public func cancelDeviceConnection(deviceIdentifier: String) throws -> Promise<NativeDevice> {
-        return Promise.reject(error: BleError.notImplemented("cancelDeviceConnection not implemented on iOS yet"))
+        return Promise { resolve, reject in
+            reject(BleError.notImplemented("cancelDeviceConnection not implemented on iOS yet"))
+        }
     }
     
     public func onDeviceDisconnected(deviceIdentifier: String, listener: @escaping (NativeBleError?, NativeDevice?) -> Void) throws -> Subscription {
@@ -102,31 +138,45 @@ public class BleNitroBleManager: HybridBleManagerSpec {
     }
     
     public func isDeviceConnected(deviceIdentifier: String) throws -> Promise<Bool> {
-        return Promise.resolve(withResult: false)
+        return Promise { resolve, reject in
+            resolve(false)
+        }
     }
     
     public func discoverAllServicesAndCharacteristicsForDevice(deviceIdentifier: String, transactionId: String?) throws -> Promise<NativeDevice> {
-        return Promise.reject(error: BleError.notImplemented("discoverAllServicesAndCharacteristicsForDevice not implemented on iOS yet"))
+        return Promise { resolve, reject in
+            reject(BleError.notImplemented("discoverAllServicesAndCharacteristicsForDevice not implemented on iOS yet"))
+        }
     }
     
     public func servicesForDevice(deviceIdentifier: String) throws -> Promise<[NativeService]> {
-        return Promise.resolve(withResult: [])
+        return Promise { resolve, reject in
+            resolve([])
+        }
     }
     
     public func characteristicsForDevice(deviceIdentifier: String, serviceUUID: String) throws -> Promise<[NativeCharacteristic]> {
-        return Promise.resolve(withResult: [])
+        return Promise { resolve, reject in
+            resolve([])
+        }
     }
     
     public func readCharacteristicForDevice(deviceIdentifier: String, serviceUUID: String, characteristicUUID: String, transactionId: String?) throws -> Promise<NativeCharacteristic> {
-        return Promise.reject(error: BleError.notImplemented("readCharacteristicForDevice not implemented on iOS yet"))
+        return Promise { resolve, reject in
+            reject(BleError.notImplemented("readCharacteristicForDevice not implemented on iOS yet"))
+        }
     }
     
     public func writeCharacteristicWithResponseForDevice(deviceIdentifier: String, serviceUUID: String, characteristicUUID: String, base64Value: String, transactionId: String?) throws -> Promise<NativeCharacteristic> {
-        return Promise.reject(error: BleError.notImplemented("writeCharacteristicWithResponseForDevice not implemented on iOS yet"))
+        return Promise { resolve, reject in
+            reject(BleError.notImplemented("writeCharacteristicWithResponseForDevice not implemented on iOS yet"))
+        }
     }
     
     public func writeCharacteristicWithoutResponseForDevice(deviceIdentifier: String, serviceUUID: String, characteristicUUID: String, base64Value: String, transactionId: String?) throws -> Promise<NativeCharacteristic> {
-        return Promise.reject(error: BleError.notImplemented("writeCharacteristicWithoutResponseForDevice not implemented on iOS yet"))
+        return Promise { resolve, reject in
+            reject(BleError.notImplemented("writeCharacteristicWithoutResponseForDevice not implemented on iOS yet"))
+        }
     }
     
     public func monitorCharacteristicForDevice(deviceIdentifier: String, serviceUUID: String, characteristicUUID: String, listener: @escaping (NativeBleError?, NativeCharacteristic?) -> Void, transactionId: String?, subscriptionType: CharacteristicSubscriptionType?) throws -> Subscription {
@@ -134,15 +184,21 @@ public class BleNitroBleManager: HybridBleManagerSpec {
     }
     
     public func descriptorsForDevice(deviceIdentifier: String, serviceUUID: String, characteristicUUID: String) throws -> Promise<[NativeDescriptor]> {
-        return Promise.resolve(withResult: [])
+        return Promise { resolve, reject in
+            resolve([])
+        }
     }
     
     public func readDescriptorForDevice(deviceIdentifier: String, serviceUUID: String, characteristicUUID: String, descriptorUUID: String, transactionId: String?) throws -> Promise<NativeDescriptor> {
-        return Promise.reject(error: BleError.notImplemented("readDescriptorForDevice not implemented on iOS yet"))
+        return Promise { resolve, reject in
+            reject(BleError.notImplemented("readDescriptorForDevice not implemented on iOS yet"))
+        }
     }
     
     public func writeDescriptorForDevice(deviceIdentifier: String, serviceUUID: String, characteristicUUID: String, descriptorUUID: String, valueBase64: String, transactionId: String?) throws -> Promise<NativeDescriptor> {
-        return Promise.reject(error: BleError.notImplemented("writeDescriptorForDevice not implemented on iOS yet"))
+        return Promise { resolve, reject in
+            reject(BleError.notImplemented("writeDescriptorForDevice not implemented on iOS yet"))
+        }
     }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-ble-nitro",
-  "version": "1.0.0-beta.17",
+  "version": "1.0.0-beta.18",
   "description": "High-performance React Native BLE library built on Nitro Modules - drop-in replacement for react-native-ble-plx",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",