unified-ble-manager 4.0.0-alpha.0

package/android/src/main/java/com/sfourdrinier/unifiedblemanager/BlePlxPackage.java

@@ -0,0 +1,60 @@
+package com.sfourdrinier.unifiedblemanager;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.facebook.react.BaseReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.module.model.ReactModuleInfo;
+import com.facebook.react.module.model.ReactModuleInfoProvider;
+import com.sfourdrinier.unifiedblemanager.protocol.UnifiedBleProtocolControlModule;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class BlePlxPackage extends BaseReactPackage {
+  @Nullable
+  @Override
+  public NativeModule getModule(String name, ReactApplicationContext reactContext) {
+    if (BlePlxModule.NAME.equals(name)) {
+      return new BlePlxModule(reactContext);
+    }
+    if (UnifiedBleProtocolControlModule.NAME.equals(name)) {
+      return new UnifiedBleProtocolControlModule(reactContext);
+    }
+
+    return null;
+  }
+
+  @NonNull
+  @Override
+  public ReactModuleInfoProvider getReactModuleInfoProvider() {
+    return () -> {
+      final Map<String, ReactModuleInfo> moduleInfos = new HashMap<>();
+      moduleInfos.put(
+        BlePlxModule.NAME,
+        new ReactModuleInfo(
+          BlePlxModule.NAME,
+          BlePlxModule.class.getName(),
+          false,
+          false,
+          false,
+          true
+        )
+      );
+      moduleInfos.put(
+        UnifiedBleProtocolControlModule.NAME,
+        new ReactModuleInfo(
+          UnifiedBleProtocolControlModule.NAME,
+          UnifiedBleProtocolControlModule.class.getName(),
+          false,
+          false,
+          false,
+          true
+        )
+      );
+      return moduleInfos;
+    };
+  }
+}

package/android/src/main/java/com/sfourdrinier/unifiedblemanager/Event.java

@@ -0,0 +1,18 @@
+package com.sfourdrinier.unifiedblemanager;
+
+public enum Event {
+
+  ScanEvent("ScanEvent"),
+  ReadEvent("ReadEvent"),
+  StateChangeEvent("StateChangeEvent"),
+  RestoreStateEvent("RestoreStateEvent"),
+  DisconnectionEvent("DisconnectionEvent"),
+  /** GATT DB out of sync — API 31+ BluetoothGattCallback.onServiceChanged */
+  ServicesChangedEvent("ServicesChangedEvent");
+
+  public String name;
+
+  Event(String name) {
+    this.name = name;
+  }
+}

package/android/src/main/java/com/sfourdrinier/unifiedblemanager/adapter/AdvertisementData.java

@@ -0,0 +1,251 @@
+package com.sfourdrinier.unifiedblemanager.adapter;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.charset.Charset;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.UUID;
+
+public class AdvertisementData {
+
+  private byte[] manufacturerData;
+  private Map<UUID, byte[]> serviceData;
+  private List<UUID> serviceUUIDs;
+  private String localName;
+  private Integer txPowerLevel;
+  private List<UUID> solicitedServiceUUIDs;
+  private byte[] rawScanRecord;
+
+  private static final long BLUETOOTH_BASE_UUID_LSB = 0x800000805F9B34FBL;
+  private static final int BLUETOOTH_BASE_UUID_MSB = 0x00001000;
+
+  public String getLocalName() {
+    return localName;
+  }
+
+  public byte[] getManufacturerData() {
+    return manufacturerData;
+  }
+
+  public Map<UUID, byte[]> getServiceData() {
+    return serviceData;
+  }
+
+  public List<UUID> getServiceUUIDs() {
+    return serviceUUIDs;
+  }
+
+  public Integer getTxPowerLevel() {
+    return txPowerLevel;
+  }
+
+  public List<UUID> getSolicitedServiceUUIDs() {
+    return solicitedServiceUUIDs;
+  }
+
+  public byte[] getRawScanRecord() {
+    return rawScanRecord;
+  }
+
+  private AdvertisementData() {
+  }
+
+  public AdvertisementData(byte[] manufacturerData,
+                           Map<UUID, byte[]> serviceData,
+                           List<UUID> serviceUUIDs,
+                           String localName,
+                           Integer txPowerLevel,
+                           List<UUID> solicitedServiceUUIDs) {
+    this.manufacturerData = manufacturerData;
+    this.serviceData = serviceData;
+    this.serviceUUIDs = serviceUUIDs;
+    this.localName = localName;
+    this.txPowerLevel = txPowerLevel;
+    this.solicitedServiceUUIDs = solicitedServiceUUIDs;
+  }
+
+  public static AdvertisementData parseScanResponseData(byte[] advertisement) {
+    AdvertisementData advData = new AdvertisementData();
+    advData.rawScanRecord = advertisement;
+
+    ByteBuffer rawData = ByteBuffer.wrap(advertisement).order(ByteOrder.LITTLE_ENDIAN);
+    while (rawData.remaining() >= 2) {
+      int adLength = rawData.get() & 0xFF;
+      if (adLength == 0) break;
+      adLength -= 1;
+      int adType = rawData.get() & 0xFF;
+      if (rawData.remaining() < adLength) break;
+      parseAdvertisementData(advData, adType, adLength, rawData.slice().order(ByteOrder.LITTLE_ENDIAN));
+      rawData.position(rawData.position() + adLength);
+    }
+    return advData;
+  }
+
+  private static void parseAdvertisementData(AdvertisementData advData, int adType, int adLength, ByteBuffer data) {
+    switch (adType) {
+      case 0xFF:
+        parseManufacturerData(advData, adLength, data);
+        break;
+
+      case 0x02:
+      case 0x03:
+        parseServiceUUIDs(advData, adLength, data, 2);
+        break;
+      case 0x04:
+      case 0x05:
+        parseServiceUUIDs(advData, adLength, data, 4);
+        break;
+      case 0x06:
+      case 0x07:
+        parseServiceUUIDs(advData, adLength, data, 16);
+        break;
+
+      case 0x08:
+      case 0x09:
+        parseLocalName(advData, adType, adLength, data);
+        break;
+
+      case 0x0A:
+        parseTxPowerLevel(advData, adLength, data);
+        break;
+
+      case 0x14:
+        parseSolicitedServiceUUIDs(advData, adLength, data, 2);
+        break;
+      case 0x1F:
+        parseSolicitedServiceUUIDs(advData, adLength, data, 4);
+        break;
+      case 0x15:
+        parseSolicitedServiceUUIDs(advData, adLength, data, 16);
+        break;
+
+      case 0x16:
+        parseServiceData(advData, adLength, data, 2);
+        break;
+      case 0x20:
+        parseServiceData(advData, adLength, data, 4);
+        break;
+      case 0x21:
+        parseServiceData(advData, adLength, data, 16);
+        break;
+    }
+  }
+
+  private static void parseLocalName(AdvertisementData advData, int adType, int adLength, ByteBuffer data) {
+    // Complete local name is preferred over short local name.
+    if (advData.localName == null || adType == 0x09) {
+      byte[] bytes = new byte[adLength];
+      data.get(bytes, 0, adLength);
+      advData.localName = new String(bytes, Charset.forName("UTF-8"));
+    }
+  }
+
+  private static UUID parseUUID(ByteBuffer data, int uuidLength) {
+    long lsb;
+    long msb;
+    switch (uuidLength) {
+      case 2:
+        msb = (((long) data.getShort() & 0xFFFF) << 32) + BLUETOOTH_BASE_UUID_MSB;
+        lsb = BLUETOOTH_BASE_UUID_LSB;
+        break;
+      case 4:
+        msb = ((long) data.getInt() << 32) + BLUETOOTH_BASE_UUID_MSB;
+        lsb = BLUETOOTH_BASE_UUID_LSB;
+        break;
+      case 16:
+        lsb = data.getLong();
+        msb = data.getLong();
+        break;
+      default:
+        data.position(data.position() + uuidLength);
+        return null;
+    }
+    return new UUID(msb, lsb);
+  }
+
+  private static void parseSolicitedServiceUUIDs(AdvertisementData advData, int adLength, ByteBuffer data, int uuidLength) {
+    if (advData.solicitedServiceUUIDs == null) advData.solicitedServiceUUIDs = new ArrayList<>();
+    while (data.remaining() >= uuidLength && data.position() < adLength) {
+      advData.solicitedServiceUUIDs.add(parseUUID(data, uuidLength));
+    }
+  }
+
+  private static void parseServiceUUIDs(AdvertisementData advData, int adLength, ByteBuffer data, int uuidLength) {
+    if (advData.serviceUUIDs == null) advData.serviceUUIDs = new ArrayList<>();
+    while (data.remaining() >= uuidLength && data.position() < adLength) {
+      advData.serviceUUIDs.add(parseUUID(data, uuidLength));
+    }
+  }
+
+  private static void parseServiceData(AdvertisementData advData, int adLength, ByteBuffer data, int uuidLength) {
+    if (adLength < uuidLength) return;
+    if (advData.serviceData == null) advData.serviceData = new HashMap<>();
+    UUID serviceUUID = parseUUID(data, uuidLength);
+    int serviceDataLength = adLength - uuidLength;
+    byte[] serviceData = new byte[serviceDataLength];
+    data.get(serviceData, 0, serviceDataLength);
+    advData.serviceData.put(serviceUUID, serviceData);
+  }
+
+  private static void parseTxPowerLevel(AdvertisementData advData, int adLength, ByteBuffer data) {
+    if (adLength != 1) return;
+    advData.txPowerLevel = (int) data.get();
+  }
+
+  private static void parseManufacturerData(AdvertisementData advData, int adLength, ByteBuffer data) {
+    if (adLength < 2) return;
+    advData.manufacturerData = new byte[adLength];
+    data.get(advData.manufacturerData, 0, adLength);
+  }
+
+  @Override
+  public String toString() {
+    return "AdvertisementData{" +
+      "manufacturerData=" + Arrays.toString(manufacturerData) +
+      ", serviceData=" + serviceData +
+      ", serviceUUIDs=" + serviceUUIDs +
+      ", localName='" + localName + '\'' +
+      ", txPowerLevel=" + txPowerLevel +
+      ", solicitedServiceUUIDs=" + solicitedServiceUUIDs +
+      ", rawScanRecord=" + Arrays.toString(rawScanRecord) +
+      '}';
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) return true;
+    if (o == null || getClass() != o.getClass()) return false;
+
+    AdvertisementData that = (AdvertisementData) o;
+
+    if (!Arrays.equals(manufacturerData, that.manufacturerData)) return false;
+    if (!Objects.equals(serviceData, that.serviceData))
+      return false;
+    if (!Objects.equals(serviceUUIDs, that.serviceUUIDs))
+      return false;
+    if (!Objects.equals(localName, that.localName))
+      return false;
+    if (!Objects.equals(txPowerLevel, that.txPowerLevel))
+      return false;
+    if (!Objects.equals(solicitedServiceUUIDs, that.solicitedServiceUUIDs))
+      return false;
+    return Arrays.equals(rawScanRecord, that.rawScanRecord);
+  }
+
+  @Override
+  public int hashCode() {
+    int result = Arrays.hashCode(manufacturerData);
+    result = 31 * result + (serviceData != null ? serviceData.hashCode() : 0);
+    result = 31 * result + (serviceUUIDs != null ? serviceUUIDs.hashCode() : 0);
+    result = 31 * result + (localName != null ? localName.hashCode() : 0);
+    result = 31 * result + (txPowerLevel != null ? txPowerLevel.hashCode() : 0);
+    result = 31 * result + (solicitedServiceUUIDs != null ? solicitedServiceUUIDs.hashCode() : 0);
+    result = 31 * result + Arrays.hashCode(rawScanRecord);
+    return result;
+  }
+}

package/android/src/main/java/com/sfourdrinier/unifiedblemanager/adapter/BleAdapter.java

@@ -0,0 +1,269 @@
+package com.sfourdrinier.unifiedblemanager.adapter;
+
+import com.sfourdrinier.unifiedblemanager.adapter.errors.BleError;
+
+import java.util.List;
+
+public interface BleAdapter {
+
+  void createClient(String restoreStateIdentifier,
+                    OnEventCallback<String> onAdapterStateChangeCallback,
+                    OnEventCallback<Integer> onStateRestored);
+
+  void destroyClient();
+
+  String getCurrentState();
+
+  void startDeviceScan(
+    String[] filteredUUIDs,
+    int scanMode,
+    int callbackType,
+    boolean legacyScan,
+    OnEventCallback<ScanResult> onEventCallback,
+    OnErrorCallback onErrorCallback);
+
+  void stopDeviceScan();
+
+  void requestConnectionPriorityForDevice(
+    String deviceIdentifier,
+    int connectionPriority,
+    String transactionId,
+    OnSuccessCallback<Device> onSuccessCallback,
+    OnErrorCallback onErrorCallback);
+
+  void readRSSIForDevice(
+    String deviceIdentifier,
+    String transactionId,
+    OnSuccessCallback<Device> onSuccessCallback,
+    OnErrorCallback onErrorCallback);
+
+  void requestMTUForDevice(
+    String deviceIdentifier,
+    int mtu,
+    String transactionId,
+    OnSuccessCallback<Device> onSuccessCallback,
+    OnErrorCallback onErrorCallback);
+
+  void getKnownDevices(
+    String[] deviceIdentifiers,
+    OnSuccessCallback<Device[]> onSuccessCallback,
+    OnErrorCallback onErrorCallback);
+
+  void getConnectedDevices(
+    String[] serviceUUIDs,
+    OnSuccessCallback<Device[]> onSuccessCallback,
+    OnErrorCallback onErrorCallback);
+
+  void connectToDevice(
+    String deviceIdentifier,
+    ConnectionOptions connectionOptions,
+    OnSuccessCallback<Device> onSuccessCallback,
+    OnEventCallback<ConnectionState> onConnectionStateChangedCallback,
+    OnErrorCallback onErrorCallback);
+
+  void cancelDeviceConnection(
+    String deviceIdentifier,
+    OnSuccessCallback<Device> onSuccessCallback,
+    OnErrorCallback onErrorCallback);
+
+  void isDeviceConnected(
+    String deviceIdentifier,
+    OnSuccessCallback<Boolean> onSuccessCallback,
+    OnErrorCallback onErrorCallback);
+
+  /** Create a bond (pair) with device. Android only. */
+  void createBond(
+    String deviceIdentifier,
+    OnSuccessCallback<Void> onSuccessCallback,
+    OnErrorCallback onErrorCallback);
+
+  /** Remove bond. Android only. */
+  void removeBond(
+    String deviceIdentifier,
+    OnSuccessCallback<Void> onSuccessCallback,
+    OnErrorCallback onErrorCallback);
+
+  /** Bond state: "none" | "bonding" | "bonded". */
+  void getBondState(
+    String deviceIdentifier,
+    OnSuccessCallback<String> onSuccessCallback,
+    OnErrorCallback onErrorCallback);
+
+  /**
+   * List currently bonded (paired) devices known to the OS adapter. Android only.
+   */
+  void bondedDevices(
+    OnSuccessCallback<Device[]> onSuccessCallback,
+    OnErrorCallback onErrorCallback);
+
+  void discoverAllServicesAndCharacteristicsForDevice(
+    String deviceIdentifier,
+    String transactionId,
+    OnSuccessCallback<Device> onSuccessCallback,
+    OnErrorCallback onErrorCallback);
+
+  List<Service> getServicesForDevice(
+    String deviceIdentifier) throws BleError;
+
+  List<Characteristic> getCharacteristicsForDevice(
+    String deviceIdentifier,
+    String serviceUUID) throws BleError;
+
+  List<Characteristic> getCharacteristicsForService(
+    int serviceIdentifier) throws BleError;
+
+  List<Descriptor> descriptorsForDevice(
+    String deviceIdentifier,
+    String serviceUUID,
+    String characteristicUUID) throws BleError;
+
+  List<Descriptor> descriptorsForService(
+    int serviceIdentifier,
+    String characteristicUUID) throws BleError;
+
+  List<Descriptor> descriptorsForCharacteristic(
+    int characteristicIdentifier) throws BleError;
+
+
+  void readCharacteristicForDevice(
+    String deviceIdentifier,
+    String serviceUUID,
+    String characteristicUUID,
+    String transactionId,
+    OnSuccessCallback<Characteristic> onSuccessCallback,
+    OnErrorCallback onErrorCallback);
+
+  void readCharacteristicForService(
+    int serviceIdentifier,
+    String characteristicUUID,
+    String transactionId,
+    OnSuccessCallback<Characteristic> onSuccessCallback,
+    OnErrorCallback onErrorCallback);
+
+  void readCharacteristic(
+    int characteristicIdentifer,
+    String transactionId,
+    OnSuccessCallback<Characteristic> onSuccessCallback,
+    OnErrorCallback onErrorCallback);
+
+  void writeCharacteristicForDevice(
+    String deviceIdentifier,
+    String serviceUUID,
+    String characteristicUUID,
+    String valueBase64,
+    boolean withResponse,
+    String transactionId,
+    OnSuccessCallback<Characteristic> onSuccessCallback,
+    OnErrorCallback onErrorCallback);
+
+  void writeCharacteristicForService(
+    int serviceIdentifier,
+    String characteristicUUID,
+    String valueBase64,
+    boolean withResponse,
+    String transactionId,
+    OnSuccessCallback<Characteristic> onSuccessCallback,
+    OnErrorCallback onErrorCallback);
+
+  void writeCharacteristic(
+    int characteristicIdentifier,
+    String valueBase64,
+    boolean withResponse,
+    String transactionId,
+    OnSuccessCallback<Characteristic> onSuccessCallback,
+    OnErrorCallback onErrorCallback);
+
+  void monitorCharacteristicForDevice(
+    String deviceIdentifier,
+    String serviceUUID,
+    String characteristicUUID,
+    String transactionId,
+    String subscriptionType,
+    OnEventCallback<Characteristic> onEventCallback,
+    OnErrorCallback onErrorCallback);
+
+  void monitorCharacteristicForService(
+    int serviceIdentifier,
+    String characteristicUUID,
+    String transactionId,
+    String subscriptionType,
+    OnEventCallback<Characteristic> onEventCallback,
+    OnErrorCallback onErrorCallback);
+
+  void monitorCharacteristic(
+    int characteristicIdentifier,
+    String transactionId,
+    String subscriptionType,
+    OnEventCallback<Characteristic> onEventCallback,
+    OnErrorCallback onErrorCallback);
+
+  void readDescriptorForDevice(
+    final String deviceId,
+    final String serviceUUID,
+    final String characteristicUUID,
+    final String descriptorUUID,
+    final String transactionId,
+    OnSuccessCallback<Descriptor> successCallback,
+    OnErrorCallback errorCallback);
+
+  void readDescriptorForService(
+    final int serviceIdentifier,
+    final String characteristicUUID,
+    final String descriptorUUID,
+    final String transactionId,
+    OnSuccessCallback<Descriptor> successCallback,
+    OnErrorCallback errorCallback);
+
+  void readDescriptorForCharacteristic(
+    final int characteristicIdentifier,
+    final String descriptorUUID,
+    final String transactionId,
+    OnSuccessCallback<Descriptor> successCallback,
+    OnErrorCallback errorCallback);
+
+  void readDescriptor(
+    final int descriptorIdentifier,
+    final String transactionId,
+    OnSuccessCallback<Descriptor> onSuccessCallback,
+    OnErrorCallback onErrorCallback);
+
+  void writeDescriptorForDevice(
+    final String deviceId,
+    final String serviceUUID,
+    final String characteristicUUID,
+    final String descriptorUUID,
+    final String valueBase64,
+    final String transactionId,
+    OnSuccessCallback<Descriptor> successCallback,
+    OnErrorCallback errorCallback);
+
+  void writeDescriptorForService(
+    final int serviceIdentifier,
+    final String characteristicUUID,
+    final String descriptorUUID,
+    final String valueBase64,
+    final String transactionId,
+    OnSuccessCallback<Descriptor> successCallback,
+    OnErrorCallback errorCallback);
+
+  void writeDescriptorForCharacteristic(
+    final int characteristicIdentifier,
+    final String descriptorUUID,
+    final String valueBase64,
+    final String transactionId,
+    OnSuccessCallback<Descriptor> successCallback,
+    OnErrorCallback errorCallback);
+
+  void writeDescriptor(
+    final int descriptorIdentifier,
+    final String valueBase64,
+    final String transactionId,
+    OnSuccessCallback<Descriptor> successCallback,
+    OnErrorCallback errorCallback);
+
+  void cancelTransaction(String transactionId);
+
+  void setLogLevel(String logLevel);
+
+  String getLogLevel();
+}

package/android/src/main/java/com/sfourdrinier/unifiedblemanager/adapter/BleAdapterCreator.java

@@ -0,0 +1,7 @@
+package com.sfourdrinier.unifiedblemanager.adapter;
+
+import android.content.Context;
+
+public interface BleAdapterCreator {
+  BleAdapter createAdapter(Context context);
+}

package/android/src/main/java/com/sfourdrinier/unifiedblemanager/adapter/BleAdapterFactory.java

@@ -0,0 +1,22 @@
+package com.sfourdrinier.unifiedblemanager.adapter;
+
+import android.content.Context;
+
+public class BleAdapterFactory {
+
+  private static BleAdapterCreator bleAdapterCreator = new BleAdapterCreator() {
+    @Override
+    public BleAdapter createAdapter(Context context) {
+      // 4.0 GA default: owned pure-Kotlin Android GATT radio (no RxAndroidBle).
+      return new com.sfourdrinier.unifiedblemanager.radio.OwnedBleAdapter(context);
+    }
+  };
+
+  public static BleAdapter getNewAdapter(Context context) {
+    return bleAdapterCreator.createAdapter(context);
+  }
+
+  public static void setBleAdapterCreator(BleAdapterCreator bleAdapterCreator) {
+    BleAdapterFactory.bleAdapterCreator = bleAdapterCreator;
+  }
+}