Fix regression after upgrading NRF 2.2.4 (#10)

* Fix regression after update NRF 2.2.4
* Bump library version
* Update changelog

Author: lenguyenthanh

CHANGELOG.md

@@ -1,4 +1,19 @@
-Version 0.1.0
+# CHANGELOG
+
+## Version 0.2.1
+
+    - Fix regression bugs for version 0.2.0
+
+## Version 0.2.0
+
+    - Update NRF BLE 2.2.4
+    - Update NRF Scanner 1.5.0
+
+## Version 0.1.3
+
+    - Update Arrow 0.13.2
+
+## Version 0.1.0
 
 Initial release
 

beckon/build.gradle

@@ -12,7 +12,7 @@ android {
         targetSdkVersion 30
         buildToolsVersion = "30.0.2"
         versionCode 1
-        versionName "0.1.2"
+        versionName "0.2.1"
 
         testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
 

beckon/src/main/java/com/technocreatives/beckon/BeckonClient.kt

@@ -46,7 +46,7 @@ interface BeckonClient {
     fun disconnectAllConnectedButNotSavedDevices(): Completable
 
     /**
-     * Search for all connected devices in the systems which satisfies ScannerSetting
+     * Search for all currently connected devices in the systems which satisfies ScannerSetting
      * If setting.useFilter == True, this function will ignore all connected and saved devices in Beckon
      */
     fun search(setting: ScannerSetting, descriptor: Descriptor): Observable<Either<ConnectionError, BeckonDevice>>

beckon/src/main/java/com/technocreatives/beckon/extension/BeckonClientEx.kt

@@ -56,6 +56,7 @@ fun BeckonClient.scanAndConnect(
 
     val searchStream =
         search(conditions, setting, descriptor).map { it.mapLeft { BeckonException(it) } }
+
     val scanStream = scan(conditions, setting)
         .flatMapSingleEither { safeConnect(it, descriptor) }
 

beckon/src/main/java/com/technocreatives/beckon/extension/BeckonDeviceEx.kt

@@ -11,7 +11,6 @@ import com.technocreatives.beckon.State
 import com.technocreatives.beckon.checkNotifyList
 import io.reactivex.Completable
 import io.reactivex.Observable
-import io.reactivex.functions.BiFunction
 import java.util.UUID
 
 data class BeckonState<State>(
@@ -29,7 +28,7 @@ fun BeckonDevice.deviceStates(): Observable<BeckonState<State>> {
     return Observable.combineLatest(
         states(),
         connectionStates(),
-        BiFunction<State, ConnectionState, BeckonState<State>> { t1, t2 ->
+        { t1, t2 ->
             BeckonState(metadata(), t2, t1)
         }
     )

beckon/src/main/java/com/technocreatives/beckon/internal/BeckonBleManager.kt

@@ -133,123 +133,12 @@ internal class BeckonBleManager(
         }
     }
 
-    private val gattCallback = object : BleManagerGattCallback() {
-
-        override fun initialize() {
-            Timber.d("initialize")
-            if (bluetoothGatt != null) {
-                val services = bluetoothGatt!!.services.map { it.uuid }
-                val characteristics = allCharacteristics(bluetoothGatt!!)
-                val detail = DeviceDetail(services, characteristics)
-
-                // TODO Fix disposable
-                val disposable =
-                    Observable.just(Unit).delay(1600, TimeUnit.MILLISECONDS).flatMapCompletable {
-                        subscribeBla(descriptor.subscribes, detail)
-                    }
-                        .andThen(readBla(descriptor.reads, detail).ignoreElements())
-                        .subscribe(
-                            {
-                                devicesSubject.onSuccess(detail.right())
-                            },
-                            {
-                                devicesSubject.onSuccess(
-                                    ConnectionError.GeneralError(
-                                        device.address,
-                                        it
-                                    ).left()
-                                )
-                            }
-                        )
-            } else {
-                devicesSubject.onSuccess(ConnectionError.BluetoothGattNull(device.address).left())
-            }
-        }
-
-        override fun onDeviceDisconnected() {
-            Timber.d("onDeviceDisconnected gattCallback")
-        }
-
-        override fun isRequiredServiceSupported(gatt: BluetoothGatt): Boolean {
-            Timber.d("isRequiredServiceSupported $gatt")
-            val services = gatt.services.map { it.uuid }
-            Timber.d("All discovered services $services")
-            bluetoothGatt = gatt
-
-            return true
-        }
-
-        private fun allCharacteristics(gatt: BluetoothGatt): List<CharacteristicSuccess> {
-            return gatt.services.flatMap { allCharacteristics(it) }
-        }
-
-        private fun allCharacteristics(service: BluetoothGattService): List<CharacteristicSuccess> {
-            return service.characteristics.flatMap {
-                allCharacteristics(service, it)
-            }
-        }
-
-        fun allCharacteristics(
-            service: BluetoothGattService,
-            char: BluetoothGattCharacteristic
-        ): List<CharacteristicSuccess> {
-            return Property.values().toList()
-                .map { findCharacteristic(service, char, it) }
-                .filterOption()
-        }
-
-        private fun findCharacteristic(
-            service: BluetoothGattService,
-            char: BluetoothGattCharacteristic,
-            type: Property
-        ): Option<CharacteristicSuccess> {
-            return when (type) {
-                Property.WRITE -> writeCharacteristic(service, char)
-                Property.READ -> readCharacteristic(service, char)
-                Property.NOTIFY -> notifyCharacteristic(service, char)
-            }
-        }
-
-        private fun notifyCharacteristic(
-            service: BluetoothGattService,
-            char: BluetoothGattCharacteristic
-        ): Option<CharacteristicSuccess.Notify> {
-            return if (char.properties and BluetoothGattCharacteristic.PROPERTY_NOTIFY > 0 &&
-                char.properties and BluetoothGattCharacteristic.PROPERTY_READ > 0
-            ) {
-                Option(CharacteristicSuccess.Notify(char.uuid, service.uuid, char))
-            } else {
-                None
-            }
-        }
-
-        private fun readCharacteristic(
-            service: BluetoothGattService,
-            char: BluetoothGattCharacteristic
-        ): Option<CharacteristicSuccess.Read> {
-            return if (char.properties and BluetoothGattCharacteristic.PROPERTY_READ > 0) {
-                Option(CharacteristicSuccess.Read(char.uuid, service.uuid, char))
-            } else {
-                None
-            }
-        }
-
-        private fun writeCharacteristic(
-            service: BluetoothGattService,
-            char: BluetoothGattCharacteristic
-        ): Option<CharacteristicSuccess.Write> {
-            return if (char.properties and BluetoothGattCharacteristic.PERMISSION_WRITE > 0) {
-                Option(CharacteristicSuccess.Write(char.uuid, service.uuid, char))
-            } else {
-                None
-            }
-        }
-    }
+    // private val gattCallback =
 
     fun doCreateBond(): Completable {
         bondSubject.onNext(BondState.CreatingBond)
         return Completable.create { emitter ->
-            ensureBond()
+            createBondInsecure()
                 .done { emitter.onComplete() }
                 .fail { device, status ->
                     emitter.onError(
@@ -281,7 +170,118 @@ internal class BeckonBleManager(
     }
 
     override fun getGattCallback(): BleManagerGattCallback {
-        return gattCallback
+        return object : BleManagerGattCallback() {
+
+            override fun initialize() {
+                Timber.d("initialize")
+                if (bluetoothGatt != null) {
+                    val services = bluetoothGatt!!.services.map { it.uuid }
+                    val characteristics = allCharacteristics(bluetoothGatt!!)
+                    val detail = DeviceDetail(services, characteristics)
+
+                    // TODO Fix disposable
+                    val disposable =
+                        Observable.just(Unit).delay(1600, TimeUnit.MILLISECONDS).flatMapCompletable {
+                            subscribeBla(descriptor.subscribes, detail)
+                        }
+                            .andThen(readBla(descriptor.reads, detail).ignoreElements())
+                            .subscribe(
+                                {
+                                    devicesSubject.onSuccess(detail.right())
+                                },
+                                {
+                                    devicesSubject.onSuccess(
+                                        ConnectionError.GeneralError(
+                                            device.address,
+                                            it
+                                        ).left()
+                                    )
+                                }
+                            )
+                } else {
+                    devicesSubject.onSuccess(ConnectionError.BluetoothGattNull(device.address).left())
+                }
+            }
+
+            override fun onDeviceDisconnected() {
+                Timber.d("onDeviceDisconnected gattCallback")
+            }
+
+            override fun isRequiredServiceSupported(gatt: BluetoothGatt): Boolean {
+                Timber.d("isRequiredServiceSupported $gatt")
+                val services = gatt.services.map { it.uuid }
+                Timber.d("All discovered services $services")
+                bluetoothGatt = gatt
+
+                return true
+            }
+
+            private fun allCharacteristics(gatt: BluetoothGatt): List<CharacteristicSuccess> {
+                return gatt.services.flatMap { allCharacteristics(it) }
+            }
+
+            private fun allCharacteristics(service: BluetoothGattService): List<CharacteristicSuccess> {
+                return service.characteristics.flatMap {
+                    allCharacteristics(service, it)
+                }
+            }
+
+            fun allCharacteristics(
+                service: BluetoothGattService,
+                char: BluetoothGattCharacteristic
+            ): List<CharacteristicSuccess> {
+                return Property.values().toList()
+                    .map { findCharacteristic(service, char, it) }
+                    .filterOption()
+            }
+
+            private fun findCharacteristic(
+                service: BluetoothGattService,
+                char: BluetoothGattCharacteristic,
+                type: Property
+            ): Option<CharacteristicSuccess> {
+                return when (type) {
+                    Property.WRITE -> writeCharacteristic(service, char)
+                    Property.READ -> readCharacteristic(service, char)
+                    Property.NOTIFY -> notifyCharacteristic(service, char)
+                }
+            }
+
+            private fun notifyCharacteristic(
+                service: BluetoothGattService,
+                char: BluetoothGattCharacteristic
+            ): Option<CharacteristicSuccess.Notify> {
+                return if (char.properties and BluetoothGattCharacteristic.PROPERTY_NOTIFY > 0 &&
+                    char.properties and BluetoothGattCharacteristic.PROPERTY_READ > 0
+                ) {
+                    Option(CharacteristicSuccess.Notify(char.uuid, service.uuid, char))
+                } else {
+                    None
+                }
+            }
+
+            private fun readCharacteristic(
+                service: BluetoothGattService,
+                char: BluetoothGattCharacteristic
+            ): Option<CharacteristicSuccess.Read> {
+                return if (char.properties and BluetoothGattCharacteristic.PROPERTY_READ > 0) {
+                    Option(CharacteristicSuccess.Read(char.uuid, service.uuid, char))
+                } else {
+                    None
+                }
+            }
+
+            private fun writeCharacteristic(
+                service: BluetoothGattService,
+                char: BluetoothGattCharacteristic
+            ): Option<CharacteristicSuccess.Write> {
+                return if (char.properties and BluetoothGattCharacteristic.PERMISSION_WRITE > 0) {
+                    Option(CharacteristicSuccess.Write(char.uuid, service.uuid, char))
+                } else {
+                    None
+                }
+            }
+        }
     }
 
     fun connectionState(): Observable<ConnectionState> {

beckon/src/main/java/com/technocreatives/beckon/internal/BeckonClientImpl.kt

@@ -94,8 +94,6 @@ internal class BeckonClientImpl(
         setting: ScannerSetting,
         descriptor: Descriptor
     ): Observable<Either<ConnectionError, BeckonDevice>> {
-        Timber.d("Search: $setting")
-
         Timber.d("Search: $setting")
         val connectedDevicesInSystem = context.bluetoothManager()
             .connectedDevices()
@@ -249,7 +247,7 @@ internal class BeckonClientImpl(
             .doFinally { beckonStore.dispatch(BeckonAction.RemoveConnectedDevice(device)) }
     }
 
-    // error can happen
+    // exception can happen
     override fun save(macAddress: String): Single<String> {
         return when (val device = beckonStore.currentState().findConnectedDevice(macAddress)) {
             is None -> Single.error(ConnectionError.ConnectedDeviceNotFound(macAddress).toException())