react-native-ble-manager 11.5.6 → 12.0.0-rc.0

package/dist/esm/NativeBleManager.d.ts

@@ -0,0 +1,241 @@
+import { TurboModule } from 'react-native';
+import type { EventEmitter } from 'react-native/Libraries/Types/CodegenTypes';
+/**
+ * This represents the Turbo Module version of react-native-ble-manager.
+ * This adds the codegen definition to react-native generate the c++ bindings on compile time.
+ * That should work only on 0.75 and higher.
+ * Don't remove it! and please modify with caution! Knowing that can create wrong bindings into jsi and break at compile or execution time.
+ *  - Knowing that also every type needs to match the current Objective C++ and Java callbacks types and callbacks type definitions and be aware of the current differences between implementation in both platforms.
+ */
+export interface Spec extends TurboModule {
+    start(options: Object, callback: (error: CallbackError) => void): void;
+    scan(serviceUUIDStrings: string[], timeoutSeconds: number, allowDuplicates: boolean, scanningOptions: Object, callback: (error: CallbackError) => void): void;
+    stopScan(callback: (error: CallbackError) => void): void;
+    connect(peripheralUUID: string, options: Object, callback: (error: CallbackError) => void): void;
+    disconnect(peripheralUUID: string, force: boolean, callback: (error: CallbackError) => void): void;
+    retrieveServices(peripheralUUID: string, services: string[], callback: (error: CallbackError, peripheral: PeripheralInfo) => void): void;
+    readRSSI(peripheralUUID: string, callback: (error: string | null, rssi: number) => void): void;
+    readDescriptor(peripheralUUID: string, serviceUUID: string, characteristicUUID: string, descriptorUUID: string, callback: (error: string | null, data: number[]) => void): void;
+    writeDescriptor(peripheralUUID: string, serviceUUID: string, characteristicUUID: string, descriptorUUID: string, data: object[], callback: (error: string | null) => void): void;
+    getDiscoveredPeripherals(callback: (error: string | null, result: Peripheral[] | null) => void): void;
+    checkState(callback: (state: BleState) => void): void;
+    write(peripheralUUID: string, serviceUUID: string, characteristicUUID: string, message: object[], maxByteSize: number, callback: (error: string | null) => void): void;
+    writeWithoutResponse(peripheralUUID: string, serviceUUID: string, characteristicUUID: string, message: object[], maxByteSize: number, queueSleepTime: number, callback: (error: string | null) => void): void;
+    read(peripheralUUID: string, serviceUUID: string, characteristicUUID: string, callback: (error: string | null, data: number[]) => void): void;
+    startNotification(peripheralUUID: string, serviceUUID: string, characteristicUUID: string, callback: (error: string | null) => void): void;
+    stopNotification(peripheralUUID: string, serviceUUID: string, characteristicUUID: string, callback: (error: string | null) => void): void;
+    getConnectedPeripherals(serviceUUIDStrings: string[], callback: (error: string | null, result: Peripheral[] | null) => void): void;
+    isPeripheralConnected(peripheralUUID: string, callback: (error: Peripheral[]) => void): void;
+    isScanning(callback: (error: string | null, status: boolean) => void): void;
+    getMaximumWriteValueLengthForWithoutResponse(peripheralUUID: string, callback: (error: string | null, max: number) => void): void;
+    getMaximumWriteValueLengthForWithResponse(deviceUUID: string, callback: (error: string | null, max: number) => void): void;
+    enableBluetooth(callback: (error: string | null) => void): void;
+    getBondedPeripherals(callback: (error: string | null, result: Peripheral[] | null) => void): void;
+    createBond(peripheralUUID: string, devicePin: string, callback: (error: string | null) => void): void;
+    removeBond(peripheralUUID: string, callback: (error: string | null) => void): void;
+    removePeripheral(peripheralUUID: string, callback: (error: string | null) => void): void;
+    requestMTU(peripheralUUID: string, mtu: number, callback: (error: string | null, mtu: number) => void): void;
+    requestConnectionPriority(peripheralUUID: string, connectionPriority: number, callback: (error: string | null, status: boolean) => void): void;
+    refreshCache(peripheralUUID: string, callback: (error: string | null, result: boolean) => void): void;
+    setName(name: string): void;
+    getAssociatedPeripherals(callback: (error: string | null, peripherals: Peripheral[] | null) => void): void;
+    removeAssociatedPeripheral(peripheralUUID: string, callback: (error: string | null) => void): void;
+    supportsCompanion(callback: (supports: boolean) => void): void;
+    companionScan(serviceUUIDs: string[], option: Object, callback: (error: string | null, peripheral: Peripheral | null) => void): void;
+    /**
+     * Supported events.
+     */
+    readonly onDiscoverPeripheral: EventEmitter<Peripheral>;
+    readonly onStopScan: EventEmitter<EventStopScan>;
+    readonly onDidUpdateState: EventEmitter<EventDidUpdateState>;
+    readonly onDidUpdateValueForCharacteristic: EventEmitter<EventDidUpdateValueForCharacteristic>;
+    readonly onConnectPeripheral: EventEmitter<EventConnectPeripheral>;
+    readonly onDisconnectPeripheral: EventEmitter<EventDisconnectPeripheral>;
+    readonly onPeripheralDidBond: EventEmitter<EventPeripheralDidBond>;
+    readonly onCentralManagerWillRestoreState: EventEmitter<EventCentralManagerWillRestoreState>;
+    readonly onDidUpdateNotificationStateFor: EventEmitter<EventDidUpdateNotificationStateFor>;
+    readonly onCompanionPeripheral: EventEmitter<EventCompanionPeripheral>;
+    readonly onCompanionFailure: EventEmitter<EventCompanionFailure>;
+}
+declare const _default: Spec;
+export default _default;
+/** Turbo Module Type Definitions */
+export type BleScanCallbackType = number;
+export type BleScanMatchCount = number;
+export type BleScanMatchMode = number;
+export type BleScanMode = number;
+export type BleScanPhyMode = number;
+export type CallbackError = string | null;
+export type BleState = string;
+export type Peripheral = {
+    id: string;
+    rssi: number;
+    name: string | null;
+    advertising: {
+        isConnectable?: boolean;
+        localName?: string | null;
+        rawData?: {
+            CDVType: number[];
+            bytes: number[];
+            data: string;
+        };
+        manufacturerData?: {
+            CDVType: number[];
+            bytes: number[];
+            data: string;
+        }[] | null;
+        manufacturerRawData?: {
+            CDVType: number[];
+            bytes: number[];
+            data: string;
+        } | null;
+        serviceData?: {
+            CDVType: number[];
+            bytes: number[];
+            data: string;
+        }[] | null;
+        serviceUUIDs?: string[];
+        txPowerLevel?: number;
+    };
+};
+export type PeripheralInfo = {
+    id: string;
+    rssi: number;
+    name: string | null;
+    advertising: {
+        isConnectable?: boolean;
+        localName?: string | null;
+        rawData?: {
+            CDVType: number[];
+            bytes: number[];
+            data: string;
+        } | null;
+        manufacturerData?: {
+            CDVType: number[];
+            bytes: number[];
+            data: string;
+        }[] | null;
+        manufacturerRawData?: {
+            CDVType: number[];
+            bytes: number[];
+            data: string;
+        } | null;
+        serviceData?: {
+            CDVType: number[];
+            bytes: number[];
+            data: string;
+        }[] | null;
+        serviceUUIDs?: string[];
+        txPowerLevel?: number;
+    };
+    serviceUUIDs?: string[];
+    characteristics?: {
+        properties: {
+            Broadcast?: string;
+            Read?: string;
+            WriteWithoutResponse?: string;
+            Write?: string;
+            Notify?: string;
+            Indicate?: string;
+            AuthenticatedSignedWrites?: string;
+            ExtendedProperties?: string;
+            NotifyEncryptionRequired?: string;
+            IndicateEncryptionRequired?: string;
+        };
+        characteristic: string;
+        service: string;
+        descriptors?: {
+            value: string;
+            uuid: string;
+        }[];
+    }[];
+    services?: {
+        uuid: string;
+    }[];
+};
+export type EventStopScan = {
+    status: number;
+};
+export type EventDidUpdateState = {
+    state: string;
+};
+export type EventDiscoverPeripheral = {
+    id: string;
+    name: string;
+    rssi: number;
+    advertising: {
+        isConnectable: boolean;
+        serviceUUIDs: string[];
+        manufacturerData: number[];
+        serviceData: number[];
+        txPowerLevel: number;
+        rawData?: number | null;
+    };
+};
+export type EventDidUpdateValueForCharacteristic = {
+    value: number[];
+    peripheral: string;
+    characteristic: string;
+    service: string;
+};
+export type EventConnectPeripheral = {
+    peripheral: string;
+    status?: number | null;
+};
+export type EventDisconnectPeripheral = {
+    peripheral: string;
+    status?: number | null;
+    domain?: string | null;
+    code?: number | null;
+};
+export type EventPeripheralDidBond = {
+    id: string;
+    name: string;
+    rssi: number;
+    advertising: {
+        isConnectable: boolean;
+        serviceUUIDs: string[];
+        manufacturerData: number[];
+        serviceData: number[];
+        txPowerLevel: number;
+        rawData?: number | null;
+    };
+};
+export type EventCentralManagerWillRestoreState = {
+    peripherals: {
+        id: string;
+        name: string;
+        rssi: number;
+        advertising: {
+            isConnectable: boolean;
+            serviceUUIDs: string[];
+            manufacturerData: number[];
+            serviceData: number[];
+            txPowerLevel: number;
+            rawData?: number | null;
+        };
+    }[];
+};
+export type EventDidUpdateNotificationStateFor = {
+    peripheral: string;
+    characteristic: string;
+    isNotifying: boolean;
+    domain?: string | null;
+    code?: number | null;
+};
+export type EventCompanionPeripheral = {
+    id: string;
+    name: string;
+    rssi: number;
+    advertising: {
+        isConnectable: boolean;
+        serviceUUIDs: string[];
+        manufacturerData: number[];
+        serviceData: number[];
+        txPowerLevel: number;
+        rawData?: number | null;
+    };
+};
+export type EventCompanionFailure = {
+    error: string;
+};

package/dist/esm/NativeBleManager.js

@@ -0,0 +1,3 @@
+import { TurboModuleRegistry } from 'react-native';
+export default TurboModuleRegistry.get('BleManager');
+//# sourceMappingURL=NativeBleManager.js.map

package/dist/esm/NativeBleManager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"NativeBleManager.js","sourceRoot":"","sources":["../../src/NativeBleManager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,mBAAmB,EAAE,MAAM,cAAc,CAAC;AA8MhE,eAAe,mBAAmB,CAAC,GAAG,CAAO,YAAY,CAAS,CAAC"}

package/dist/esm/index.d.ts

@@ -1,6 +1,6 @@
-import { NativeEventEmitter } from "react-native";
-import { BleState, ConnectOptions, ConnectionPriority, CompanionScanOptions, Peripheral, PeripheralInfo, ScanOptions, StartOptions } from "./types";
-export * from "./types";
+import { EventSubscription, NativeEventEmitter } from 'react-native';
+import { BleState, ConnectOptions, ConnectionPriority, CompanionScanOptions, Peripheral, PeripheralInfo, ScanOptions, StartOptions } from './types';
+export * from './types';
 declare class BleManager extends NativeEventEmitter {
     constructor();
     /**
@@ -207,6 +207,18 @@ declare class BleManager extends NativeEventEmitter {
      * @returns
      */
     getMaximumWriteValueLengthForWithResponse(peripheralId: string): Promise<number>;
+    onDiscoverPeripheral(callback: any): EventSubscription;
+    onStopScan(callback: any): EventSubscription;
+    onDidUpdateState(callback: any): EventSubscription;
+    onCentralManagerDidUpdateState(callback: any): EventSubscription;
+    onConnectPeripheral(callback: any): EventSubscription;
+    onDisconnectPeripheral(callback: any): EventSubscription;
+    onDidUpdateValueForCharacteristic(callback: any): EventSubscription;
+    onPeripheralDidBond(callback: any): EventSubscription;
+    onCentralManagerWillRestoreState(callback: any): EventSubscription;
+    onDidUpdateNotificationStateFor(callback: any): EventSubscription;
+    onCompanionPeripheral(callback: any): EventSubscription;
+    onCompanionAvailability(callback: any): EventSubscription;
 }
 declare const _default: BleManager;
 export default _default;

package/dist/esm/index.js

@@ -1,10 +1,25 @@
-import { NativeEventEmitter, NativeModules } from "react-native";
-import { BleScanCallbackType, BleScanMatchCount, BleScanMatchMode, BleScanMode, } from "./types";
-export * from "./types";
-let bleManager = NativeModules.BleManager;
+import { NativeEventEmitter, NativeModules, } from 'react-native';
+import { BleScanCallbackType, BleScanMatchCount, BleScanMatchMode, BleScanMode, } from './types';
+export * from './types';
+// @ts-expect-error This applies the turbo module version only when turbo is enabled for backwards compatibility.
+const isTurboModuleEnabled = (global === null || global === void 0 ? void 0 : global.__turboModuleProxy) != null;
+if (isTurboModuleEnabled) {
+    // Warn users that this is a release candidate and should be used with caution.
+    console.warn(`
+    You're using a turbo module version of react-native-version!\n
+    If something is broken please feedback on "issues" https://github.com/innoveit/react-native-ble-manager\n
+    Please use with caution cause it's not quite stable yet.
+  `);
+}
+const BleManagerModule = isTurboModuleEnabled
+    ? require('./NativeBleManager').default
+    : NativeModules.BleManager;
 class BleManager extends NativeEventEmitter {
     constructor() {
-        super(bleManager);
+        if (!BleManagerModule) {
+            throw new Error('BleManagerModule not found');
+        }
+        super(BleManagerModule);
         this.isPeripheralConnected = this.isPeripheralConnected.bind(this);
     }
     /**
@@ -16,7 +31,7 @@ class BleManager extends NativeEventEmitter {
      */
     read(peripheralId, serviceUUID, characteristicUUID) {
         return new Promise((fulfill, reject) => {
-            bleManager.read(peripheralId, serviceUUID, characteristicUUID, (error, data) => {
+            BleManagerModule.read(peripheralId, serviceUUID, characteristicUUID, (error, data) => {
                 if (error) {
                     reject(error);
                 }
@@ -36,7 +51,7 @@ class BleManager extends NativeEventEmitter {
      */
     readDescriptor(peripheralId, serviceUUID, characteristicUUID, descriptorUUID) {
         return new Promise((fulfill, reject) => {
-            bleManager.readDescriptor(peripheralId, serviceUUID, characteristicUUID, descriptorUUID, (error, data) => {
+            BleManagerModule.readDescriptor(peripheralId, serviceUUID, characteristicUUID, descriptorUUID, (error, data) => {
                 if (error) {
                     reject(error);
                 }
@@ -57,7 +72,7 @@ class BleManager extends NativeEventEmitter {
      */
     writeDescriptor(peripheralId, serviceUUID, characteristicUUID, descriptorUUID, data) {
         return new Promise((fulfill, reject) => {
-            bleManager.writeDescriptor(peripheralId, serviceUUID, characteristicUUID, descriptorUUID, data, (error) => {
+            BleManagerModule.writeDescriptor(peripheralId, serviceUUID, characteristicUUID, descriptorUUID, data, (error) => {
                 if (error) {
                     reject(error);
                 }
@@ -74,7 +89,7 @@ class BleManager extends NativeEventEmitter {
      */
     readRSSI(peripheralId) {
         return new Promise((fulfill, reject) => {
-            bleManager.readRSSI(peripheralId, (error, rssi) => {
+            BleManagerModule.readRSSI(peripheralId, (error, rssi) => {
                 if (error) {
                     reject(error);
                 }
@@ -91,7 +106,7 @@ class BleManager extends NativeEventEmitter {
      */
     refreshCache(peripheralId) {
         return new Promise((fulfill, reject) => {
-            bleManager.refreshCache(peripheralId, (error, result) => {
+            BleManagerModule.refreshCache(peripheralId, (error, result) => {
                 if (error) {
                     reject(error);
                 }
@@ -109,7 +124,7 @@ class BleManager extends NativeEventEmitter {
      */
     retrieveServices(peripheralId, serviceUUIDs = []) {
         return new Promise((fulfill, reject) => {
-            bleManager.retrieveServices(peripheralId, serviceUUIDs, (error, peripheral) => {
+            BleManagerModule.retrieveServices(peripheralId, serviceUUIDs, (error, peripheral) => {
                 if (error) {
                     reject(error);
                 }
@@ -130,7 +145,7 @@ class BleManager extends NativeEventEmitter {
      */
     write(peripheralId, serviceUUID, characteristicUUID, data, maxByteSize = 20) {
         return new Promise((fulfill, reject) => {
-            bleManager.write(peripheralId, serviceUUID, characteristicUUID, data, maxByteSize, (error) => {
+            BleManagerModule.write(peripheralId, serviceUUID, characteristicUUID, data, maxByteSize, (error) => {
                 if (error) {
                     reject(error);
                 }
@@ -152,7 +167,7 @@ class BleManager extends NativeEventEmitter {
      */
     writeWithoutResponse(peripheralId, serviceUUID, characteristicUUID, data, maxByteSize = 20, queueSleepTime = 10) {
         return new Promise((fulfill, reject) => {
-            bleManager.writeWithoutResponse(peripheralId, serviceUUID, characteristicUUID, data, maxByteSize, queueSleepTime, (error) => {
+            BleManagerModule.writeWithoutResponse(peripheralId, serviceUUID, characteristicUUID, data, maxByteSize, queueSleepTime, (error) => {
                 if (error) {
                     reject(error);
                 }
@@ -167,7 +182,7 @@ class BleManager extends NativeEventEmitter {
             if (!options) {
                 options = {};
             }
-            bleManager.connect(peripheralId, options, (error) => {
+            BleManagerModule.connect(peripheralId, options, (error) => {
                 if (error) {
                     reject(error);
                 }
@@ -185,7 +200,7 @@ class BleManager extends NativeEventEmitter {
      */
     createBond(peripheralId, peripheralPin = null) {
         return new Promise((fulfill, reject) => {
-            bleManager.createBond(peripheralId, peripheralPin, (error) => {
+            BleManagerModule.createBond(peripheralId, peripheralPin, (error) => {
                 if (error) {
                     reject(error);
                 }
@@ -202,7 +217,7 @@ class BleManager extends NativeEventEmitter {
      */
     removeBond(peripheralId) {
         return new Promise((fulfill, reject) => {
-            bleManager.removeBond(peripheralId, (error) => {
+            BleManagerModule.removeBond(peripheralId, (error) => {
                 if (error) {
                     reject(error);
                 }
@@ -220,7 +235,7 @@ class BleManager extends NativeEventEmitter {
      */
     disconnect(peripheralId, force = true) {
         return new Promise((fulfill, reject) => {
-            bleManager.disconnect(peripheralId, force, (error) => {
+            BleManagerModule.disconnect(peripheralId, force, (error) => {
                 if (error) {
                     reject(error);
                 }
@@ -232,7 +247,7 @@ class BleManager extends NativeEventEmitter {
     }
     startNotification(peripheralId, serviceUUID, characteristicUUID) {
         return new Promise((fulfill, reject) => {
-            bleManager.startNotification(peripheralId, serviceUUID, characteristicUUID, (error) => {
+            BleManagerModule.startNotification(peripheralId, serviceUUID, characteristicUUID, (error) => {
                 if (error) {
                     reject(error);
                 }
@@ -252,7 +267,7 @@ class BleManager extends NativeEventEmitter {
      */
     startNotificationUseBuffer(peripheralId, serviceUUID, characteristicUUID, buffer) {
         return new Promise((fulfill, reject) => {
-            bleManager.startNotificationUseBuffer(peripheralId, serviceUUID, characteristicUUID, buffer, (error) => {
+            BleManagerModule.startNotificationUseBuffer(peripheralId, serviceUUID, characteristicUUID, buffer, (error) => {
                 if (error) {
                     reject(error);
                 }
@@ -264,7 +279,7 @@ class BleManager extends NativeEventEmitter {
     }
     stopNotification(peripheralId, serviceUUID, characteristicUUID) {
         return new Promise((fulfill, reject) => {
-            bleManager.stopNotification(peripheralId, serviceUUID, characteristicUUID, (error) => {
+            BleManagerModule.stopNotification(peripheralId, serviceUUID, characteristicUUID, (error) => {
                 if (error) {
                     reject(error);
                 }
@@ -276,7 +291,7 @@ class BleManager extends NativeEventEmitter {
     }
     checkState() {
         return new Promise((fulfill, _) => {
-            bleManager.checkState((state) => {
+            BleManagerModule.checkState((state) => {
                 fulfill(state);
             });
         });
@@ -286,7 +301,7 @@ class BleManager extends NativeEventEmitter {
             if (options == null) {
                 options = {};
             }
-            bleManager.start(options, (error) => {
+            BleManagerModule.start(options, (error) => {
                 if (error) {
                     reject(error);
                 }
@@ -339,13 +354,13 @@ class BleManager extends NativeEventEmitter {
                 delete scanningOptions.exactAdvertisingName;
             }
             else {
-                if (typeof scanningOptions.exactAdvertisingName === "string") {
+                if (typeof scanningOptions.exactAdvertisingName === 'string') {
                     scanningOptions.exactAdvertisingName = [
                         scanningOptions.exactAdvertisingName,
                     ];
                 }
             }
-            bleManager.scan(serviceUUIDs, seconds, allowDuplicates, scanningOptions, (error) => {
+            BleManagerModule.scan(serviceUUIDs, seconds, allowDuplicates, scanningOptions, (error) => {
                 if (error) {
                     reject(error);
                 }
@@ -357,7 +372,7 @@ class BleManager extends NativeEventEmitter {
     }
     stopScan() {
         return new Promise((fulfill, reject) => {
-            bleManager.stopScan((error) => {
+            BleManagerModule.stopScan((error) => {
                 if (error) {
                     reject(error);
                 }
@@ -373,7 +388,7 @@ class BleManager extends NativeEventEmitter {
      */
     enableBluetooth() {
         return new Promise((fulfill, reject) => {
-            bleManager.enableBluetooth((error) => {
+            BleManagerModule.enableBluetooth((error) => {
                 if (error) {
                     reject(error);
                 }
@@ -390,7 +405,7 @@ class BleManager extends NativeEventEmitter {
      */
     getConnectedPeripherals(serviceUUIDs = []) {
         return new Promise((fulfill, reject) => {
-            bleManager.getConnectedPeripherals(serviceUUIDs, (error, result) => {
+            BleManagerModule.getConnectedPeripherals(serviceUUIDs, (error, result) => {
                 if (error) {
                     reject(error);
                 }
@@ -411,7 +426,7 @@ class BleManager extends NativeEventEmitter {
      */
     getBondedPeripherals() {
         return new Promise((fulfill, reject) => {
-            bleManager.getBondedPeripherals((error, result) => {
+            BleManagerModule.getBondedPeripherals((error, result) => {
                 if (error) {
                     reject(error);
                 }
@@ -428,7 +443,7 @@ class BleManager extends NativeEventEmitter {
     }
     getDiscoveredPeripherals() {
         return new Promise((fulfill, reject) => {
-            bleManager.getDiscoveredPeripherals((error, result) => {
+            BleManagerModule.getDiscoveredPeripherals((error, result) => {
                 if (error) {
                     reject(error);
                 }
@@ -450,7 +465,7 @@ class BleManager extends NativeEventEmitter {
      */
     removePeripheral(peripheralId) {
         return new Promise((fulfill, reject) => {
-            bleManager.removePeripheral(peripheralId, (error) => {
+            BleManagerModule.removePeripheral(peripheralId, (error) => {
                 if (error) {
                     reject(error);
                 }
@@ -482,7 +497,7 @@ class BleManager extends NativeEventEmitter {
      */
     isScanning() {
         return new Promise((fulfill, reject) => {
-            bleManager.isScanning((error, status) => {
+            BleManagerModule.isScanning((error, status) => {
                 if (error) {
                     reject(error);
                 }
@@ -500,7 +515,7 @@ class BleManager extends NativeEventEmitter {
      */
     requestConnectionPriority(peripheralId, connectionPriority) {
         return new Promise((fulfill, reject) => {
-            bleManager.requestConnectionPriority(peripheralId, connectionPriority, (error, status) => {
+            BleManagerModule.requestConnectionPriority(peripheralId, connectionPriority, (error, status) => {
                 if (error) {
                     reject(error);
                 }
@@ -518,7 +533,7 @@ class BleManager extends NativeEventEmitter {
      */
     requestMTU(peripheralId, mtu) {
         return new Promise((fulfill, reject) => {
-            bleManager.requestMTU(peripheralId, mtu, (error, mtu) => {
+            BleManagerModule.requestMTU(peripheralId, mtu, (error, mtu) => {
                 if (error) {
                     reject(error);
                 }
@@ -535,7 +550,7 @@ class BleManager extends NativeEventEmitter {
      */
     getAssociatedPeripherals() {
         return new Promise((fulfill, reject) => {
-            bleManager.getAssociatedPeripherals((error, peripherals) => {
+            BleManagerModule.getAssociatedPeripherals((error, peripherals) => {
                 if (error) {
                     reject(error);
                 }
@@ -553,7 +568,7 @@ class BleManager extends NativeEventEmitter {
      */
     removeAssociatedPeripheral(peripheralId) {
         return new Promise((fulfill, reject) => {
-            bleManager.removeAssociatedPeripheral(peripheralId, (error) => {
+            BleManagerModule.removeAssociatedPeripheral(peripheralId, (error) => {
                 if (error !== null) {
                     reject(error);
                 }
@@ -571,8 +586,8 @@ class BleManager extends NativeEventEmitter {
      * @return Promise resolving to a boolean.
      */
     supportsCompanion() {
-        return new Promise(fulfill => {
-            bleManager.supportsCompanion((supports) => fulfill(supports));
+        return new Promise((fulfill) => {
+            BleManagerModule.supportsCompanion((supports) => fulfill(supports));
         });
     }
     /**
@@ -582,7 +597,7 @@ class BleManager extends NativeEventEmitter {
      */
     companionScan(serviceUUIDs, options = {}) {
         return new Promise((fulfill, reject) => {
-            bleManager.companionScan(serviceUUIDs, options, (error, peripheral) => {
+            BleManagerModule.companionScan(serviceUUIDs, options, (error, peripheral) => {
                 if (error) {
                     reject(error);
                 }
@@ -597,7 +612,7 @@ class BleManager extends NativeEventEmitter {
      * @param name
      */
     setName(name) {
-        bleManager.setName(name);
+        BleManagerModule.setName(name);
     }
     /**
      * [iOS only]
@@ -606,7 +621,7 @@ class BleManager extends NativeEventEmitter {
      */
     getMaximumWriteValueLengthForWithoutResponse(peripheralId) {
         return new Promise((fulfill, reject) => {
-            bleManager.getMaximumWriteValueLengthForWithoutResponse(peripheralId, (error, max) => {
+            BleManagerModule.getMaximumWriteValueLengthForWithoutResponse(peripheralId, (error, max) => {
                 if (error) {
                     reject(error);
                 }
@@ -623,7 +638,7 @@ class BleManager extends NativeEventEmitter {
      */
     getMaximumWriteValueLengthForWithResponse(peripheralId) {
         return new Promise((fulfill, reject) => {
-            bleManager.getMaximumWriteValueLengthForWithResponse(peripheralId, (error, max) => {
+            BleManagerModule.getMaximumWriteValueLengthForWithResponse(peripheralId, (error, max) => {
                 if (error) {
                     reject(error);
                 }
@@ -633,6 +648,42 @@ class BleManager extends NativeEventEmitter {
             });
         });
     }
+    onDiscoverPeripheral(callback) {
+        return BleManagerModule.onDiscoverPeripheral(callback);
+    }
+    onStopScan(callback) {
+        return BleManagerModule.onStopScan(callback);
+    }
+    onDidUpdateState(callback) {
+        return BleManagerModule.onStateChange(callback);
+    }
+    onCentralManagerDidUpdateState(callback) {
+        return BleManagerModule.onCentralManagerDidUpdateState(callback);
+    }
+    onConnectPeripheral(callback) {
+        return BleManagerModule.onConnectPeripheral(callback);
+    }
+    onDisconnectPeripheral(callback) {
+        return BleManagerModule.onDisconnectPeripheral(callback);
+    }
+    onDidUpdateValueForCharacteristic(callback) {
+        return BleManagerModule.onDidUpdateValueForCharacteristic(callback);
+    }
+    onPeripheralDidBond(callback) {
+        return BleManagerModule.onPeripheralDidBond(callback);
+    }
+    onCentralManagerWillRestoreState(callback) {
+        return BleManagerModule.onCentralManagerWillRestoreState(callback);
+    }
+    onDidUpdateNotificationStateFor(callback) {
+        return BleManagerModule.onDidUpdateNotificationStateFor(callback);
+    }
+    onCompanionPeripheral(callback) {
+        return BleManagerModule.onCompanionPeripheral(callback);
+    }
+    onCompanionAvailability(callback) {
+        return BleManagerModule.onCompanionAvailability(callback);
+    }
 }
 export default new BleManager();
 //# sourceMappingURL=index.js.map