* Note that this does not inherently fire a state change event, as the manual
* act seems to
* skip the StateChangeReceiver functionality.
*
* @param promise resolves true if Bluetooth is already enabled
* or when
* Bluetooth becomes enabled. Rejects if anything else
*/
@ReactMethod
@SuppressWarnings("unused")
public void requestBluetoothEnabled(Promise promise) {
if (checkBluetoothAdapter()) {
promise.resolve(true);
} else {
Activity activity = getCurrentActivity();
mEnabledPromise = promise;
if (activity != null) {
Intent intent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
activity.startActivityForResult(intent, BluetoothRequest.ENABLE_BLUETOOTH.code);
} else {
ActivityNotFoundException e = new ActivityNotFoundException();
mEnabledPromise.reject(e);
mEnabledPromise = null;
}
}
}
/**
* Determine whether Bluetooth is available. The promise is never rejected, only
* resolved with the
* appropriate boolean flag.
*
* @param promise resolve based on Bluetooth being available on the device.
*/
@ReactMethod
@SuppressWarnings("unused")
public void isBluetoothAvailable(Promise promise) {
promise.resolve(mAdapter != null);
}
/**
* Determine whether Bluetooth is enabled. The promise is never rejected, only
* resolved with the
* appropriate boolean flag.
*
* @param promise resolve based on Bluetooth status
*/
@ReactMethod
@SuppressWarnings("unused")
public void isBluetoothEnabled(Promise promise) {
promise.resolve(checkBluetoothAdapter());
}
/**
* Retrieves the currently bonded devices. Bonded devices may or may not be
* connected. This
* method was refactored from list as there was a bunch of
* confusion with bonded
* and connected devices.
*
* @param promise resolves the list of bonded devices.
*/
@ReactMethod
@SuppressWarnings("unused")
public void getBondedDevices(Promise promise) {
if (!checkBluetoothAdapter()) {
promise.reject(Exceptions.BLUETOOTH_NOT_ENABLED.name(),
Exceptions.BLUETOOTH_NOT_ENABLED.message());
} else {
WritableArray bonded = Arguments.createArray();
for (BluetoothDevice device : mAdapter.getBondedDevices()) {
NativeDevice nativeDevice = new NativeDevice(device);
bonded.pushMap(nativeDevice.map());
}
promise.resolve(bonded);
}
}
/**
* Lists all the currently connected devices. Provides a {@link WritableArray}
* of {@link BluetoothDevice}(s) which currently have an active/open connection.
* Please note
* that this does NOT list PAIRED devices, only those that are actually
* connected!
*
* @param promise resolves with the currently connected devices, may be empty.
*/
@ReactMethod
@SuppressWarnings("unused")
public void getConnectedDevices(Promise promise) {
WritableArray connected = Arguments.createArray();
for (DeviceConnection connection : mConnections.values()) {
connected.pushMap(new NativeDevice(connection.getDevice()).map());
}
Log.d(TAG, "getConnectedDevices: " + connected.toString());
promise.resolve(connected);
}
/**
* Registers a {@link DiscoveryReceiver} and starts discovery.
*
* @param promise resolve or reject the request to discoverDevices
*/
@ReactMethod
@SuppressWarnings("unused")
public void startDiscovery(final Promise promise) {
if (!checkBluetoothAdapter()) {
promise.reject(Exceptions.BLUETOOTH_NOT_ENABLED.name(),
Exceptions.BLUETOOTH_NOT_ENABLED.message());
} else if (mDiscoveryReceiver != null) {
promise.reject(Exceptions.BLUETOOTH_IN_DISCOVERY.name(),
Exceptions.BLUETOOTH_IN_DISCOVERY.message());
} else {
mDiscoveryReceiver = new DiscoveryReceiver(new DiscoveryReceiver.DiscoveryCallback() {
@Override
public void onDeviceDiscovered(NativeDevice device) {
// This wasn't previously an event, but now we can send out and request them
Log.d(TAG, String.format("Discovered device %s", device.getAddress()));
BluetoothDeviceEvent event = new BluetoothDeviceEvent(EventType.DEVICE_DISCOVERED, device);
sendEvent(EventType.DEVICE_DISCOVERED, event.map());
}
@Override
public void onDiscoveryFinished(Collection
* Note - the Discovery promise will be resolved with any devices that were
* found during the
* discovery period, so effectively cancelling resolves two promises.
*
* @param promise resolves cancel request
*/
@ReactMethod
@SuppressWarnings("unused")
public void cancelDiscovery(final Promise promise) {
if (!checkBluetoothAdapter()) {
promise.reject(Exceptions.BLUETOOTH_NOT_ENABLED.name(),
Exceptions.BLUETOOTH_NOT_ENABLED.message());
} else {
promise.resolve(mAdapter.cancelDiscovery());
}
}
/**
* Attempts to pair/bond with the device specified by address,
* {@link BluetoothDevice#createBond()}
* is only available after SDK v19.
*
* @param address the address of the BluetoothDevice to which we attempt pairing
* @param promise resolves when the BluetoothDevice is paired, rejects if the
* SDK version is
* less than 19, Bluetooth is not enabled, or an Exception
* occurs.
*/
@ReactMethod
@SuppressWarnings("unused")
public void pairDevice(String address, Promise promise) {
if (!checkBluetoothAdapter()) {
promise.reject(Exceptions.BLUETOOTH_NOT_ENABLED.name(),
Exceptions.BLUETOOTH_NOT_ENABLED.message());
} else if (Build.VERSION.SDK_INT < 19) {
promise.reject(Exceptions.BONDING_UNAVAILABLE_API.name(),
Exceptions.BONDING_UNAVAILABLE_API.message());
} else {
if (BuildConfig.DEBUG)
Log.d(TAG, String.format("Attempting to pair with device %s", address));
final PairingReceiver pr = new PairingReceiver(getReactApplicationContext(),
new PairingReceiver.PairingCallback() {
@Override
public void onPairingSuccess(NativeDevice device) {
promise.resolve(device.map());
}
@Override
public void onPairingFailure(Exception cause) {
promise.reject(new DevicePairingException(null, cause));
}
});
getReactApplicationContext().registerReceiver(pr, PairingReceiver.intentFilter());
try {
BluetoothDevice device = mAdapter.getRemoteDevice(address);
Method m = device.getClass().getMethod("createBond", (Class[]) null);
m.invoke(device, (Object[]) null);
} catch (IllegalAccessException e) {
getReactApplicationContext().unregisterReceiver(pr);
promise.reject(Exceptions.BONDING_UNAVAILABLE_API.name(),
Exceptions.BONDING_UNAVAILABLE_API.message());
} catch (InvocationTargetException e) {
getReactApplicationContext().unregisterReceiver(pr);
promise.reject(Exceptions.BONDING_UNAVAILABLE_API.name(),
Exceptions.BONDING_UNAVAILABLE_API.message());
} catch (NoSuchMethodException e) {
getReactApplicationContext().unregisterReceiver(pr);
promise.reject(Exceptions.BONDING_UNAVAILABLE_API.name(),
Exceptions.BONDING_UNAVAILABLE_API.message());
}
}
}
/**
* Request that a device be unpaired. The device Id is required - looked up
* using the
* BluetoothAdapter and unpaired.
*
* @param address the address of the BluetoothDevice to which we attempt pairing
* @param promise resolves when the BluetoothDevice is paired, rejects if there
* are any issues
*/
@ReactMethod
@SuppressWarnings("unused")
public void unpairDevice(String address, Promise promise) {
if (!checkBluetoothAdapter()) {
promise.reject(Exceptions.BLUETOOTH_NOT_ENABLED.name(),
Exceptions.BLUETOOTH_NOT_ENABLED.message());
} else if (Build.VERSION.SDK_INT < 19) {
promise.reject(Exceptions.BONDING_UNAVAILABLE_API.name(),
Exceptions.BONDING_UNAVAILABLE_API.message());
} else {
if (BuildConfig.DEBUG)
Log.d(TAG, String.format("Attempting to pair with device %s", address));
try {
BluetoothDevice device = mAdapter.getRemoteDevice(address);
Method m = device.getClass().getMethod("removeBond", (Class[]) null);
m.invoke(device, (Object[]) null);
IntentFilter intentFilter = new IntentFilter();
intentFilter.addAction(BluetoothDevice.ACTION_BOND_STATE_CHANGED);
PairingReceiver pr = new PairingReceiver(getReactApplicationContext(),
new PairingReceiver.PairingCallback() {
@Override
public void onPairingSuccess(NativeDevice device) {
promise.resolve(device.map());
}
@Override
public void onPairingFailure(Exception cause) {
promise.reject(new DevicePairingException(new NativeDevice(device), cause));
}
});
getReactApplicationContext().registerReceiver(pr, intentFilter);
} catch (IllegalAccessException e) {
promise.reject(Exceptions.BONDING_UNAVAILABLE_API.name(),
Exceptions.BONDING_UNAVAILABLE_API.message());
} catch (InvocationTargetException e) {
promise.reject(Exceptions.BONDING_UNAVAILABLE_API.name(),
Exceptions.BONDING_UNAVAILABLE_API.message());
} catch (NoSuchMethodException e) {
promise.reject(Exceptions.BONDING_UNAVAILABLE_API.name(),
Exceptions.BONDING_UNAVAILABLE_API.message());
}
}
}
/**
* Puts the {@link BluetoothAdapter} into an accept mode using the provided
* accept type
* configured on the module.
*
* @param promise resolve or reject the requested listening
*/
@ReactMethod
@SuppressWarnings("unused")
public void accept(ReadableMap parameters, Promise promise) {
if (!checkBluetoothAdapter()) {
promise.reject(Exceptions.BLUETOOTH_NOT_ENABLED.name(),
Exceptions.BLUETOOTH_NOT_ENABLED.message());
} else if (mAcceptor.get() != null) {
promise.reject(Exceptions.BLUETOOTH_IN_ACCEPTING.name(),
Exceptions.BLUETOOTH_IN_ACCEPTING.message());
} else {
Properties properties = Utilities.mapToProperties(parameters);
try {
String connectorType = StandardOption.ACCEPTOR_TYPE.get(properties);
if (!mAcceptorFactories.containsKey(connectorType))
throw new IllegalStateException(
String.format("No ConnectionAcceptorFactory configured for type %s", connectorType));
ConnectionAcceptorFactory acceptorFactory = mAcceptorFactories.get(connectorType);
ConnectionAcceptor acceptor = acceptorFactory.create(mAdapter, properties);
acceptor.addListener(new ConnectionAcceptor.AcceptorListener
* If the {@link BluetoothAdapter} is unavailable then the promise will be
* rejected with a
* Bluetooth not enabled message.
*
* Otherwise the promise will be resolved {@code true}. This was changed as
* previously an
* reject would also occur if the Device was not in accept mode. This has been
* changed as it
* made more sense to just let React Native app set {@code accepting: false}
* (kind of like a
* status check without {@code isAccepting} being required.
*
* @param promise the {@link Promise} resolved/rejected based on cancel success
*/
@ReactMethod
@SuppressWarnings("unused")
public void cancelAccept(Promise promise) {
if (!checkBluetoothAdapter()) {
promise.reject(Exceptions.BLUETOOTH_NOT_ENABLED.name(),
Exceptions.BLUETOOTH_NOT_ENABLED.message());
} else {
if (mAcceptor.get() != null) {
mAcceptor.get().cancel();
mAcceptor.set(null);
}
promise.resolve(true);
}
}
/**
* Attempts to connect to the device with the provided Id. While the connection
* request is
* active the Cancellable request will be found in the connecting map; once
* completed the
* connection will be moved to the connections map.
*
* The default client connection type will be used. If you've provided
* customized {@link DeviceConnection}(s) then it'll be used.
*
* @param address the address to which we want to connect
* @param parameters the parameters controlling the type of connection to make
* @param promise resolve or reject the requested connection
*/
@ReactMethod
@SuppressWarnings("unused")
public void connectToDevice(String address, ReadableMap parameters, Promise promise) {
if (!checkBluetoothAdapter()) {
promise.reject(Exceptions.BLUETOOTH_NOT_ENABLED.name(),
Exceptions.BLUETOOTH_NOT_ENABLED.message());
} else if (mConnecting.containsKey(address)) {
promise.reject(Exceptions.ALREADY_CONNECTING.name(),
Exceptions.ALREADY_CONNECTING.message(address));
} else if (mConnections.containsKey(address)) {
// If it's already connected just return the device now.
DeviceConnection connection = mConnections.get(address);
promise.resolve(new NativeDevice(connection.getDevice()).map());
} else {
final BluetoothDevice device = mAdapter.getRemoteDevice(address);
final NativeDevice nativeDevice = new NativeDevice(device);
try {
// Issue/84 just in case the React Native side gets circumvented somehow
// this matches the IOS side of a new parameters being added to a NSDictionary
Properties properties = parameters == null
? new Properties()
: Utilities.mapToProperties(parameters);
final String connectorType = StandardOption.CONNECTOR_TYPE.get(properties);
if (!mConnectorFactories.containsKey(connectorType)) {
promise.reject(Exceptions.INVALID_CONNECTOR_TYPE.name(),
Exceptions.INVALID_CONNECTOR_TYPE.message(connectorType));
return;
}
final String connectionType = StandardOption.CONNECTION_TYPE.get(properties);
if (!mConnectionFactories.containsKey(connectionType)) {
promise.reject(Exceptions.INVALID_CONNECTION_TYPE.name(),
Exceptions.INVALID_CONNECTION_TYPE.message(connectorType));
return;
}
ConnectionConnectorFactory connectorFactory = mConnectorFactories.get(connectorType);
ConnectionConnector connector = connectorFactory.create(device, properties);
connector.addListener(new ConnectionConnector.ConnectorListener
* Might be configurable to reject when there is no data, instead of resolve
* null.
*
* @param address device address to which we wish to read
* @param promise resolves with data, could be null or 0 length
*/
@ReactMethod
@SuppressWarnings("unused")
public void readFromDevice(String address, Promise promise) {
if (!checkBluetoothAdapter()) {
promise.reject(Exceptions.BLUETOOTH_NOT_ENABLED.name(),
Exceptions.BLUETOOTH_NOT_ENABLED.message());
} else if (!mConnections.containsKey(address)) {
promise.reject(Exceptions.NOT_CURRENTLY_CONNECTED.name(),
Exceptions.NOT_CURRENTLY_CONNECTED.message(address));
} else {
String message = mConnections.get(address).read();
promise.resolve(message);
}
}
/**
* Clears the buffer.
*
* @param address the address of the device whose buffer is to be cleared
* @param promise resolves true
*/
@ReactMethod
@SuppressWarnings("unused")
public void clearFromDevice(String address, Promise promise) {
if (!checkBluetoothAdapter()) {
promise.reject(Exceptions.BLUETOOTH_NOT_ENABLED.name(),
Exceptions.BLUETOOTH_NOT_ENABLED.message());
} else if (!mConnections.containsKey(address)) {
promise.reject(Exceptions.NOT_CURRENTLY_CONNECTED.name(),
Exceptions.NOT_CURRENTLY_CONNECTED.message(address));
} else {
mConnections.get(address).clear();
promise.resolve(true);
}
}
/**
* Gets the available information within the buffer. There is no concept of the
* delimiter in
* this request - which may need to be changed - since in most cases I can see a
* full message
* needing to be available.
*
* @param address device address for which the client wishes to read
* @param promise resolves with length of buffer, could be 0
*/
@ReactMethod
@SuppressWarnings("unused")
public void availableFromDevice(String address, Promise promise) {
if (!checkBluetoothAdapter()) {
promise.reject(Exceptions.BLUETOOTH_NOT_ENABLED.name(),
Exceptions.BLUETOOTH_NOT_ENABLED.message());
} else if (!mConnections.containsKey(address)) {
promise.reject(Exceptions.NOT_CURRENTLY_CONNECTED.name(),
Exceptions.NOT_CURRENTLY_CONNECTED.message(address));
} else {
promise.resolve(mConnections.get(address).available());
}
}
/**
* Attempts to set the BluetoothAdapter name.
*
* @param newName the name to which the mAdapter will be changed
* @param promise resolves true
* @deprecated unsure if this is really required from the application. Not a fan
* of having
* extra functionality in here that may never get called and isn't
* available on IOS
*/
@Deprecated
@ReactMethod
@SuppressWarnings("unused")
public void setBluetoothAdapterName(String newName, Promise promise) {
if (!checkBluetoothAdapter()) {
promise.reject(Exceptions.BLUETOOTH_NOT_ENABLED.name(),
Exceptions.BLUETOOTH_NOT_ENABLED.message());
} else {
mAdapter.setName(newName);
promise.resolve(true);
}
}
/**
* Registers the module wide {@link BroadcastReceiver}(s). These include:
*
* Listeners can be provided with or without a device context. A device context
* is applied
* by sending the event name followed by a device's address. An example of this
* would be
* {@code READ@12:34:56:78:90}.
*
* @param requestedEvent {@link EventType} name for which the client wishes to
* listen
*/
@ReactMethod
@SuppressWarnings({ "unused" })
public void addListener(String requestedEvent) {
String eventType = requestedEvent,
eventDevice = null;
if (requestedEvent.contains("@")) {
String[] context = requestedEvent.split("@");
eventType = context[0];
eventDevice = context[1];
}
if (!EventType.eventNames().hasKey(eventType)) {
throw new InvalidBluetoothEventException(requestedEvent);
}
EventType event = EventType.valueOf(eventType);
if (EventType.DEVICE_READ == event) {
if (!mConnections.containsKey(eventDevice)) {
throw new IllegalStateException(
String.format("Cannot read from %s, not currently connected", requestedEvent));
}
DeviceConnection connection = mConnections.get(eventDevice);
connection.onDataReceived(onReceivedData);
}
// Now we can increment the listener as appropriate
AtomicInteger listenerCount = mListenerCounts.get(requestedEvent);
if (listenerCount == null) {
listenerCount = new AtomicInteger(0);
if (mListenerCounts.containsKey(requestedEvent))
mListenerCounts.put(requestedEvent, listenerCount);
}
int currentCount = listenerCount.incrementAndGet();
Log.d(TAG, String.format("Adding listener to %s, currently have %d listeners",
requestedEvent, currentCount));
}
/**
* Removes the specified {@link EventType}. If this is a
* {@link EventType#DEVICE_READ}
* the device address must be supplied (separated by an @) in the same way as
* when the
* listener was applied.
*
* @param requestedEvent name of the {@link EventType} for which the client
* wishes to remove
* listener.
*/
@ReactMethod
@SuppressWarnings({ "unused" })
public void removeListener(String requestedEvent) {
String eventType = requestedEvent,
eventDevice = null;
if (requestedEvent.contains("@")) {
String[] context = requestedEvent.split("@");
eventType = context[0];
eventDevice = context[1];
}
if (!EventType.eventNames().hasKey(eventType)) {
return;
}
EventType event = EventType.valueOf(eventType);
if (EventType.DEVICE_READ == event && mConnections.containsKey(eventDevice)) {
// #139 Originally if there was no current connection (ie. the device had
// already been disconnected) this would
// throw an exception. At this point we don't really care, but if the connection
// does exist we need to
// remove it and clear it.
DeviceConnection connection = mConnections.get(eventDevice);
connection.clearOnDataReceived();
}
// Only remove the listener if it currently exists. If you're attemping to
// remove a listener
// which hasn't been added, just let it go.
if (mListenerCounts.containsKey(eventType)) {
AtomicInteger listenerCount = mListenerCounts.get(eventType);
int currentCount = listenerCount.decrementAndGet();
Log.d(TAG,
String.format("Removing listener to %s, currently have %d listeners",
eventType, currentCount));
}
}
/**
* Remove all the listeners for the provided eventName. Removing all listeners
* also has a
* context (prefixed with @) which will remove all the listeners for that
* specified device.
*
* @param requestedEvent for which all listeners will be removed
*/
@ReactMethod
@SuppressWarnings({ "unused" })
public void removeAllListeners(String requestedEvent) {
String eventType = requestedEvent,
eventDevice = null;
if (requestedEvent.contains("@")) {
String[] context = requestedEvent.split("@");
eventType = context[0];
eventDevice = context[1];
}
if (!EventType.eventNames().hasKey(eventType)) {
return;
}
EventType event = EventType.valueOf(eventType);
if (EventType.DEVICE_READ == event) {
if (!mConnections.containsKey(eventDevice)) {
throw new IllegalStateException(
String.format("Cannot read from %s, not currently connected", eventType));
}
DeviceConnection connection = mConnections.get(eventDevice);
connection.clearOnDataReceived();
}
// Only remove the listener if it currently exists. If you're attemping to
// remove a listener
// which hasn't been added, just let it go.
if (mListenerCounts.containsKey(eventType)) {
AtomicInteger listenerCount = mListenerCounts.get(eventType);
listenerCount.set(0);
Log.d(TAG,
String.format("Removing listener to %s, currently have %d listeners",
eventType, 0));
}
}
// endregion
/**
* Called from the {@link StateChangeReceiver} when the {@link BluetoothAdapter}
* state
* is changed. Fires the appropriate event to any listeners.
*
* @param newState the new {@link BluetoothState}
* @param oldState the previous {@link BluetoothState}
*/
@Deprecated
@Override
public void onStateChange(BluetoothState newState, BluetoothState oldState) {
Log.d(TAG, "onStateChange from " + oldState.name() + " to " + newState.name());
EventType event = (BluetoothState.ENABLED == newState)
? EventType.BLUETOOTH_ENABLED
: EventType.BLUETOOTH_DISABLED;
sendEvent(event, new BluetoothStateEvent(newState).map());
}
/**
* Not sure whether this provides any actual info.
*
* @param device the {@link NativeDevice} which just requested disconnect
*
* @deprecated may be removed at some point unless it is found useful (opposed
* to ACLDisconnected)
*/
@Deprecated
@Override
public void onACLDisconnectRequest(NativeDevice device) {
Log.d(TAG, "onACLDisconnectRequest to " + device.getAddress());
}
/**
* Called when we get an ACL level device disconnection. This happens when a
* socket is closed,
* for whatever reason. If there is a currently active connection (which there
* should be)
* it's disconnected, then a DEVICE_DISCONNECTED event is fired.
*
* This also sends an event to the {@code DEVICE_DISCONNECTED@address} making
* the Device more
* responsible for it's own connectivity.
*
* @param device the {@link NativeDevice} which was just disconnected
*/
@Override
public void onACLDisconnected(NativeDevice device) {
Log.d(TAG, "onACLDisconnected to " + device.getAddress());
mConnections.remove(device.getAddress());
BluetoothDeviceEvent event = new BluetoothDeviceEvent(EventType.DEVICE_DISCONNECTED, device);
sendEvent(EventType.DEVICE_DISCONNECTED, event.map());
}
/**
* Sends a {@link EventType} to the React Native JS module
* {@link com.facebook.react.modules.core.DeviceEventManagerModule.RCTDeviceEventEmitter}.
*
* Currently having no active {@link com.facebook.react.bridge.CatalystInstance}
* will not cause
* the application to crash, although I'm not sure if it should.
*
* @param event the {@link EventType} being sent
* @param body the content of the event
*/
private void sendEvent(EventType event, WritableMap body) {
ReactContext context = getReactApplicationContext();
if (context.hasActiveCatalystInstance()) {
context
.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
.emit(event.name(), body);
} else {
Log.e(TAG, "There is currently no active Catalyst instance");
}
}
/**
* Sends a {@link EventType} to the React Native JS module
* {@link com.facebook.react.modules.core.DeviceEventManagerModule.RCTDeviceEventEmitter}.
* This
* version allows for sending events do a specific Device (providing the address
* along side
* the event name separated by a semi-colon).
*
* This should generally only be used for {@link EventType#DEVICE_READ} events,
* but nothing
* stops it from providing other types.
*
* @param event the {@link EventType} being sent to React Native JS
* @param device the {@link NativeDevice} which caused/receiving the event
* @param body the event content
*/
synchronized private void sendEvent(EventType event, NativeDevice device, WritableMap body) {
ReactContext context = getReactApplicationContext();
if (context.hasActiveCatalystInstance()) {
context
.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
.emit(String.format("%s@%s", event.name(), device.getAddress()), body);
} else {
Log.e(TAG, "There is currently no active Catalyst instance");
}
}
}
*
*/
private void registerBluetoothReceivers() {
if (mStateChangeReceiver == null) {
mStateChangeReceiver = new StateChangeReceiver(this);
getReactApplicationContext()
.registerReceiver(mStateChangeReceiver, StateChangeReceiver.intentFilter());
}
if (mActionACLReceiver == null) {
mActionACLReceiver = new ActionACLReceiver(this);
getReactApplicationContext()
.registerReceiver(mActionACLReceiver, ActionACLReceiver.intentFilter());
}
}
/**
* Unregister receivers. "Global" receivers need to always be removed, they are
* not configured
* to be removed on their own.
*/
private void unregisterBluetoothReceivers() {
if (mStateChangeReceiver != null) {
getReactApplicationContext().unregisterReceiver(mStateChangeReceiver);
mStateChangeReceiver = null;
}
if (mActionACLReceiver != null) {
getReactApplicationContext().unregisterReceiver(mActionACLReceiver);
mActionACLReceiver = null;
}
if (mDiscoveryReceiver != null) {
if (mAdapter != null && hasBluetoothScanPermission()) {
try {
mAdapter.cancelDiscovery();
} catch (SecurityException e) {
Log.e(TAG, "Failed to cancel discovery due to missing permission: " + e.getMessage());
}
}
getReactApplicationContext().unregisterReceiver(mDiscoveryReceiver);
mDiscoveryReceiver = null;
}
}
private BiConsumer