Merge pull request #263 from theheraldproject/develop

Prepping release 2.2.0

Author: adamfowleruk

app/build.gradle

@@ -13,7 +13,7 @@ android {
         minSdkVersion 21
         targetSdkVersion 31
         versionCode 2
-        versionName "2.1.1"
+        versionName "2.2.0"
 
         testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
     }

herald/build.gradle

@@ -5,7 +5,7 @@ plugins {
 }
 
 group = 'io.heraldprox'
-version = '2.1.1'
+version = '2.2.0'
 
 apply plugin: 'com.android.library'
 
@@ -17,7 +17,7 @@ android {
         minSdkVersion 21
         targetSdkVersion 31
         versionCode 2
-        versionName "2.1.1"
+        versionName "2.2.0"
 
         testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
         consumerProguardFiles "consumer-rules.pro"

herald/src/main/java/io/heraldprox/herald/sensor/ble/BLESensorConfiguration.java

@@ -5,6 +5,7 @@
 package io.heraldprox.herald.sensor.ble;
 
 import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
 
 import io.heraldprox.herald.sensor.data.SensorLoggerLevel;
 import io.heraldprox.herald.sensor.datatype.Data;
@@ -32,7 +33,7 @@ public class BLESensorConfiguration {
      *  <br>- Switch to 16-bit UUID by setting the value xxxx in base UUID 0000xxxx-0000-1000-8000-00805F9B34FB
      */
     @NonNull
-    public static UUID legacyHeraldServiceUUID = UUID.fromString("428132af-4746-42d3-801e-4572d65bfd9b");
+    public final static UUID legacyHeraldServiceUUID = UUID.fromString("428132af-4746-42d3-801e-4572d65bfd9b");
     public static boolean legacyHeraldServiceDetectionEnabled = true;
 
     /**
@@ -47,7 +48,20 @@ public class BLESensorConfiguration {
      *  <br>- Switch to 16-bit UUID by setting the value xxxx in base UUID 0000xxxx-0000-1000-8000-00805F9B34FB
      */
     @NonNull
-    public static UUID linuxFoundationServiceUUID = UUID.fromString("0000FCF6-0000-1000-8000-00805F9B34FB");
+    public final static UUID linuxFoundationServiceUUID = UUID.fromString("0000FCF6-0000-1000-8000-00805F9B34FB");
+
+    /**
+     * Enables detection of the current standard Herald service UUID.
+     * Enabled by default
+     * @since v2.2 February 2023
+     */
+    public static boolean standardHeraldServiceDetectionEnabled = true;
+    /**
+     * Enables advertising of the current standard Herald service UUID.
+     * Enabled by default
+     * @since v2.2 February 2023
+     */
+    public static boolean standardHeraldServiceAdvertisingEnabled = true;
 
     /**
      * Signaling characteristic for controlling connection between peripheral and central, e.g. keep each other from suspend state
@@ -69,6 +83,52 @@ public class BLESensorConfiguration {
     @NonNull
     public final static UUID payloadCharacteristicUUID = UUID.fromString("3e98c0f8-8f05-4829-a121-43e38f8933e7");
 
+    // MARK:- Custom Service UUID interoperability - Since v2.2
+    /**
+     * A custom service UUID to use for a Herald service. Required for custom apps (without Herald interop).
+     *
+     * @since v2.2 February 2023
+     * @note Requires customHeraldServiceDetectionEnabled to be set to true to enable.
+     */
+    @Nullable
+    public static UUID customServiceUUID = null;
+    /**
+     * Whether to detect a custom service UUID. Disabled by default.
+     * Doesn't affect advertising.
+     * in preference to the default Linux Foundation Herald UUID if specified.
+     * Only takes effect if customServiceUUID is set to a valid non-null UUID.
+     *
+     * @since v2.2 February 2023
+     */
+    public static boolean customServiceDetectionEnabled = false;
+    /**
+     * Whether to advertise using the main customServiceUUID instead of the standard Herald
+     * Service UUID.
+     *
+     * @since v2.2 February 2023
+     */
+    public static boolean customServiceAdvertisingEnabled = false;
+    /**
+     * Additional UUIDs beyond just customServiceUUID to detect. Useful for 'legacy' custom
+     * application detections. You do not have to include customServiceUUID in this list.
+     *
+     * @since v2.2 February 2023
+     * @note Requires customHeraldServiceDetectionEnabled to be set to true to enable.
+     */
+    @Nullable
+    public static UUID[] customAdditionalServiceUUIDs = null;
+    /**
+     * The custom manufacturer ID to use. Note this MUST be a Bluetooth SIG registered ID to
+     * ensure there is no interference.
+     * Note that if this is not specified, then the default Linux Foundation Herald service
+     * manufacturer ID will be used.
+     *
+     * @since v2.2 February 2023
+     * @note Requires customHeraldServiceDetectionEnabled to be set to true to enable.
+     * @note Requires pseudoDeviceAddress to be enabled.
+     */
+    static int customManufacturerIdForSensor = 0;
+
     // MARK:- Interoperability with OpenTrace
 
     /**
@@ -254,7 +314,9 @@ public class BLESensorConfiguration {
      * This was introduced in v2.1.0-beta4 as a controllable flag. Prior to this the feature was
      * always enabled. Additional Pseudo mac logic and read logic on iOS was added in the v2.1.0
      * release such that this is only required on very old/misbehaving Android sets. It has been
-     * decided to DISABLE this from v2.1.0 onwards. If required, extra logic will be added to Herald
+     * decided to DISABLE this for v2.1.0 onwards. It was reenabled in V2.2.0 due to certain
+     * versions of iOS incorrectly raising existing Bluetooth devices as 'newly detected'.
+     * If required, extra logic will be added to Herald
      * to detect on an Android device when it is 'misbehaving' by rotating it's MAC too much, and
      * if this is the case, this flag will be dynamically enabled for just that device.
      * <br><br>
@@ -269,7 +331,7 @@ public class BLESensorConfiguration {
      *
      * @since v2.1.0-beta4
      */
-    public static boolean pseudoDeviceAddressEnabled = false;
+    public static boolean pseudoDeviceAddressEnabled = true;
 
     /**
      *  Interrogate standard Bluetooth services to obtain device make/model data

herald/src/main/java/io/heraldprox/herald/sensor/ble/BLETimer.java

@@ -77,7 +77,7 @@ public void run() {
                 try {
                     delegate.bleTimer(System.currentTimeMillis());
                 } catch (Throwable e) {
-                    logger.fault("delegate execution failed", e);
+                    logger.fault("delegate execution failed {}", e);
                 }
             }
         }

herald/src/main/java/io/heraldprox/herald/sensor/ble/ConcreteBLEDatabase.java

@@ -153,6 +153,12 @@ private PseudoDeviceAddress pseudoDeviceAddress(@NonNull final ScanResult scanRe
             if (null != data && data.length > 0) {
                 return new PseudoDeviceAddress(data);
             }
+        } else if (BLESensorConfiguration.customServiceDetectionEnabled &&
+                   0 != BLESensorConfiguration.customManufacturerIdForSensor) {
+            final byte[] data = scanRecord.getManufacturerSpecificData(BLESensorConfiguration.customManufacturerIdForSensor);
+            if (null != data && data.length > 0) {
+                return new PseudoDeviceAddress(data);
+            }
         }
         // Not found
         return null;

herald/src/main/java/io/heraldprox/herald/sensor/ble/ConcreteBLEReceiver.java

@@ -22,7 +22,6 @@
 import android.content.pm.PackageManager;
 import android.os.Build;
 import android.os.ParcelUuid;
-import android.util.Log;
 
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
@@ -431,11 +430,33 @@ private void scanForPeripherals(@NonNull final BluetoothLeScanner bluetoothLeSca
         // Scan for HERALD protocol service on iOS (background) devices
         filter.add(new ScanFilter.Builder().setManufacturerData(
                 BLESensorConfiguration.manufacturerIdForApple, new byte[0], new byte[0]).build());
-        // Scan for HERALD protocol service on Android or iOS (foreground) devices
-        filter.add(new ScanFilter.Builder().setServiceUuid(
-                        new ParcelUuid(BLESensorConfiguration.linuxFoundationServiceUUID),
-                        new ParcelUuid(new UUID(0xFFFFFFFFFFFFFFFFL, 0)))
-                .build());
+
+        // This logic added in v2.2 to enable disabling of standard herald device detection and
+        // detection of custom application IDs
+        if (BLESensorConfiguration.customServiceDetectionEnabled) {
+            if (null != BLESensorConfiguration.customServiceUUID) {
+                filter.add(new ScanFilter.Builder().setServiceUuid(
+                                new ParcelUuid(BLESensorConfiguration.customServiceUUID),
+                                new ParcelUuid(new UUID(0xFFFFFFFFFFFFFFFFL, 0)))
+                        .build());
+            }
+            if (null != BLESensorConfiguration.customAdditionalServiceUUIDs) {
+                for (int idx = 0;idx < BLESensorConfiguration.customAdditionalServiceUUIDs.length;idx++) {
+                    filter.add(new ScanFilter.Builder().setServiceUuid(
+                                    new ParcelUuid(BLESensorConfiguration.customAdditionalServiceUUIDs[idx]),
+                                    new ParcelUuid(new UUID(0xFFFFFFFFFFFFFFFFL, 0)))
+                            .build());
+                }
+            }
+        }
+        // This is useful for a custom application.
+        if (BLESensorConfiguration.standardHeraldServiceDetectionEnabled) {
+            // Scan for HERALD protocol service on Android or iOS (foreground) devices
+            filter.add(new ScanFilter.Builder().setServiceUuid(
+                            new ParcelUuid(BLESensorConfiguration.linuxFoundationServiceUUID),
+                            new ParcelUuid(new UUID(0xFFFFFFFFFFFFFFFFL, 0)))
+                    .build());
+        }
         // Scan for OpenTrace protocol service on iOS and Android devices
         if (BLESensorConfiguration.interopOpenTraceEnabled) {
             filter.add(new ScanFilter.Builder().setServiceUuid(
@@ -578,6 +599,13 @@ private List<BLEDevice> didDiscover() {
                     device.txPower(new BLE_TxPower(txPowerLevel));
                 }
             }
+            if (device.operatingSystem() == BLEDeviceOperatingSystem.ios ||
+                device.operatingSystem() == BLEDeviceOperatingSystem.ios_tbc ||
+                device.operatingSystem() == BLEDeviceOperatingSystem.android ||
+                device.operatingSystem() == BLEDeviceOperatingSystem.android_tbc) {
+                logger.debug("didDiscover, OS already known (device={})",device);
+                continue;
+            }
             // Identify operating system from scan record where possible
             // - Sensor service found + Manufacturer is Apple -> iOS (Foreground)
             // - Sensor service found + Manufacturer not Apple -> Android
@@ -645,7 +673,23 @@ private static boolean hasSensorService(@NonNull final ScanResult scanResult) {
             return false;
         }
         for (final ParcelUuid serviceUuid : serviceUuids) {
-            if (serviceUuid.getUuid().equals(BLESensorConfiguration.linuxFoundationServiceUUID)) {
+            // Since v2.2 try custom service UUID(s) first
+            if (BLESensorConfiguration.customServiceDetectionEnabled) {
+                if (null != BLESensorConfiguration.customServiceUUID &&
+                    serviceUuid.getUuid().equals(BLESensorConfiguration.customServiceUUID)) {
+                    return true;
+                }
+                if (null != BLESensorConfiguration.customAdditionalServiceUUIDs) {
+                    for (int idx = 0; idx < BLESensorConfiguration.customAdditionalServiceUUIDs.length;idx++) {
+                        if (serviceUuid.getUuid().equals(BLESensorConfiguration.customAdditionalServiceUUIDs[idx])) {
+                            return true;
+                        }
+                    }
+                }
+            }
+            // Extra if term added in v2.2 so a custom app doesn't accidentally detect normal standard Herald devices
+            if (BLESensorConfiguration.standardHeraldServiceDetectionEnabled &&
+                serviceUuid.getUuid().equals(BLESensorConfiguration.linuxFoundationServiceUUID)) {
                 return true;
             }
             if (BLESensorConfiguration.legacyHeraldServiceDetectionEnabled &&
@@ -1020,6 +1064,20 @@ public void onServicesDiscovered(@NonNull final BluetoothGatt gatt, final int st
 
         // Sensor characteristics
         BluetoothGattService service = gatt.getService(BLESensorConfiguration.linuxFoundationServiceUUID);
+        // Since v2.2 override if a custom UUID is specified
+        if (BLESensorConfiguration.customServiceDetectionEnabled) {
+            service = null; // Ensure we don't accidentally re-enable Herald detection
+            // Try the main custom one first (if not null)
+            if (null != BLESensorConfiguration.customServiceUUID) {
+                service = gatt.getService(BLESensorConfiguration.customServiceUUID);
+            }
+            if (null == service && null != BLESensorConfiguration.customAdditionalServiceUUIDs) {
+                // Now try any additional custom service UUIDs
+                for (int idx = 0;null == service && idx < BLESensorConfiguration.customAdditionalServiceUUIDs.length; idx++) {
+                    service = gatt.getService(BLESensorConfiguration.customAdditionalServiceUUIDs[idx]);
+                }
+            }
+        }
         if (null == service && BLESensorConfiguration.interopOpenTraceEnabled) {
             service = gatt.getService(BLESensorConfiguration.interopOpenTraceServiceUUID);
         }
@@ -1050,7 +1108,7 @@ public void onServicesDiscovered(@NonNull final BluetoothGatt gatt, final int st
                 // offering sensor services.
             }
         } else {
-            logger.debug("onServicesDiscovered, found sensor service (device={})", device);
+            logger.debug("onServicesDiscovered, found sensor service (device={},service={})", device,service.getUuid());
             device.invalidateCharacteristics();
             for (final BluetoothGattCharacteristic characteristic : service.getCharacteristics()) {
                 // Confirm operating system with signal characteristic
@@ -1142,6 +1200,7 @@ private BluetoothGattCharacteristic serviceCharacteristic(@NonNull final Bluetoo
      */
     @NonNull
     private NextTask nextTaskForDevice(@NonNull final BLEDevice device) {
+        logger.debug("nextTaskForDevice, called for device (device={})", device);
         // No task for devices marked as .ignore
         if (device.ignore()) {
             logger.debug("nextTaskForDevice, ignore (device={},ignoreExpiresIn={})", device, device.timeIntervalUntilIgnoreExpires());
@@ -1154,6 +1213,7 @@ private NextTask nextTaskForDevice(@NonNull final BLEDevice device) {
         }
         // No task for devices marked as receive only (no advert to connect to)
         if (device.receiveOnly()) {
+            logger.debug("nextTaskForDevice, receive only so next is nothing (device={})", device);
             return NextTask.nothing;
         }
         // Device introspection to resolve device model if enabled and possible
@@ -1169,13 +1229,15 @@ private NextTask nextTaskForDevice(@NonNull final BLEDevice device) {
         // Resolve or confirm operating system by reading payload which
         // triggers characteristic discovery to confirm the operating system
         if (device.operatingSystem() == BLEDeviceOperatingSystem.unknown ||
-                device.operatingSystem() == BLEDeviceOperatingSystem.ios_tbc) {
+            device.operatingSystem() == BLEDeviceOperatingSystem.ios_tbc ||
+            device.operatingSystem() == BLEDeviceOperatingSystem.android_tbc) {
             logger.debug("nextTaskForDevice (device={},task=readPayload|OS)", device);
             return NextTask.readPayload;
         }
         // Immediate send is supported only if service and characteristics
         // have been discovered, and operating system has been confirmed
         if (null != device.immediateSendData()) {
+            logger.debug("nextTaskForDevice (device={},task=immediateSend)", device);
             return NextTask.immediateSend;
         }
         // Get payload as top priority
@@ -1222,6 +1284,17 @@ private NextTask nextTaskForDevice(@NonNull final BLEDevice device) {
                 logger.debug("nextTaskForDevice (device={},task=writePayloadUpdate,elapsed={})", device, device.timeIntervalSinceLastWritePayload());
                 return NextTask.writePayload;
             }
+        } else {
+            // Since v2.2 - Write our payload to iOS if needed (i.e. if they haven't detected us)
+            if (device.operatingSystem() == BLEDeviceOperatingSystem.ios) {
+                final TimeInterval lastTime = device.timeIntervalSinceLastWritePayload();
+                logger.debug("nextTaskForDevice, timeSinceLastWrite (device={},task=writePayload,elapsed={})", device, lastTime);
+                    // Don't forget the = to part! Because both can be never
+                if (lastTime.value >= BLESensorConfiguration.payloadDataUpdateTimeInterval.value) {
+                    logger.debug("nextTaskForDevice (device={},task=writePayload,elapsed={})", device, device.timeIntervalSinceLastWritePayload());
+                    return NextTask.writePayload;
+                }
+            }
         }
         // Write payload sharing data to iOS
         if (device.operatingSystem() == BLEDeviceOperatingSystem.ios && !device.protocolIsOpenTrace()) {
@@ -1234,6 +1307,7 @@ private NextTask nextTaskForDevice(@NonNull final BLEDevice device) {
                 return NextTask.writePayloadSharing;
             }
         }
+        logger.debug("nextTaskForDevice (device={},task=nothing)",device);
         return NextTask.nothing;
     }
 
@@ -1413,6 +1487,12 @@ private void writeSignalCharacteristic(@NonNull final BluetoothGatt gatt, @NonNu
             } else {
                 logger.debug("writeSignalCharacteristic to iOS (task={},dataLength={},device={})", task, data.length, device);
                 // => onCharacteristicWrite
+                // Assume it succeeds without acknowledgement
+                if (task == NextTask.writePayload) {
+                    device.registerWritePayload();
+                } else if (task == NextTask.writePayloadSharing) {
+                    device.registerWritePayloadSharing();
+                }
             }
             return;
         }
@@ -1425,6 +1505,12 @@ private void writeSignalCharacteristic(@NonNull final BluetoothGatt gatt, @NonNu
             } else {
                 logger.debug("writeSignalCharacteristic to Android (task={},dataLength={},device={})", task, data.length, device);
                 // => onCharacteristicWrite
+                // Assume it succeeds without acknowledgement
+                if (task == NextTask.writePayload) {
+                    device.registerWritePayload();
+                } else if (task == NextTask.writePayloadSharing) {
+                    device.registerWritePayloadSharing();
+                }
             }
         }
     }