@iotize/device-com-ble.cordova 3.5.1 → 3.6.0

package/esm2015/lib/definitions.js.map

@@ -1 +1 @@
-{"version":3,"file":"definitions.js","sourceRoot":"","sources":["../../../../../src/lib/definitions.ts"],"names":[],"mappings":"","sourcesContent":["import { CharacteristicProperties } from \"@iotize/tap/protocol/ble/common\";\n\nexport interface CordovaBLEScanResult {\n  name: string;\n  address: string;\n  rssi?: number;\n}\n\n/**\n * @deprecated\n * use CordovaBLEScanResult instead\n */\nexport type DiscoveredDeviceType = CordovaBLEScanResult;\n\nexport interface RequestDeviceOptions {\n  filters: BluetoothLEScanFilter[];\n  // optionalServices?: BluetoothServiceUUID[] | undefined;\n  // optionalManufacturerData?: number[] | undefined;\n}\n\ninterface BluetoothLEScanFilter {\n  // readonly name?: string | undefined;\n  // readonly namePrefix?: string | undefined;\n  readonly services?: BluetoothServiceUUID[] | undefined;\n  // readonly manufacturerData?: BluetoothManufacturerDataFilter[] | undefined;\n  // readonly serviceData?: BluetoothServiceDataFilter[] | undefined;\n}\n\ntype BluetoothServiceUUID = string;\n\ntype BluetoothCharacteristicUUID = string;\n\ntype BluetoothDescriptorUUID = string;\n\nexport interface ServiceDescription {\n  uuid: BluetoothServiceUUID;\n  characteristics?: CharacteristicList;\n  [key: string]: any;\n}\n\nexport type ServiceList = ServiceDescription[];\n\nexport interface CharacteristicDescription {\n  uuid: BluetoothCharacteristicUUID;\n  descriptors?: DescriptorList;\n  properties: CharacteristicProperties;\n  [key: string]: any;\n}\n\nexport type CharacteristicList = CharacteristicDescription[];\n\nexport interface DescriptorDescription {\n  uuid: BluetoothDescriptorUUID;\n  [key: string]: any;\n}\n\nexport type DescriptorList = DescriptorDescription[];\n"]}
+{"version":3,"file":"definitions.js","sourceRoot":"","sources":["../../../../../src/lib/definitions.ts"],"names":[],"mappings":"","sourcesContent":["import { CharacteristicProperties } from '@iotize/tap/protocol/ble/common';\n\nexport interface CordovaBLEScanResult {\n  name: string;\n  address: string;\n  rssi?: number;\n  txPower?: number;\n  scanRecord?: number[];\n}\n\n/**\n * @deprecated\n * use CordovaBLEScanResult instead\n */\nexport type DiscoveredDeviceType = CordovaBLEScanResult;\n\nexport interface RequestDeviceOptions {\n  filters: BluetoothLEScanFilter[];\n  // optionalServices?: BluetoothServiceUUID[] | undefined;\n  // optionalManufacturerData?: number[] | undefined;\n}\n\ninterface BluetoothLEScanFilter {\n  // readonly name?: string | undefined;\n  // readonly namePrefix?: string | undefined;\n  readonly services?: BluetoothServiceUUID[] | undefined;\n  // readonly manufacturerData?: BluetoothManufacturerDataFilter[] | undefined;\n  // readonly serviceData?: BluetoothServiceDataFilter[] | undefined;\n}\n\ntype BluetoothServiceUUID = string;\n\ntype BluetoothCharacteristicUUID = string;\n\ntype BluetoothDescriptorUUID = string;\n\nexport interface ServiceDescription {\n  uuid: BluetoothServiceUUID;\n  characteristics?: CharacteristicList;\n  [key: string]: any;\n}\n\nexport type ServiceList = ServiceDescription[];\n\nexport interface CharacteristicDescription {\n  uuid: BluetoothCharacteristicUUID;\n  descriptors?: DescriptorList;\n  properties: CharacteristicProperties;\n  [key: string]: any;\n}\n\nexport type CharacteristicList = CharacteristicDescription[];\n\nexport interface DescriptorDescription {\n  uuid: BluetoothDescriptorUUID;\n  [key: string]: any;\n}\n\nexport type DescriptorList = DescriptorDescription[];\n"]}

package/lib/definitions.d.ts

@@ -1,8 +1,10 @@
-import { CharacteristicProperties } from "@iotize/tap/protocol/ble/common";
+import { CharacteristicProperties } from '@iotize/tap/protocol/ble/common';
 export interface CordovaBLEScanResult {
     name: string;
     address: string;
     rssi?: number;
+    txPower?: number;
+    scanRecord?: number[];
 }
 /**
  * @deprecated

package/package.json

@@ -2,7 +2,7 @@
   "author": "IoTize <contact@iotize.com>",
   "license": "MIT",
   "name": "@iotize/device-com-ble.cordova",
-  "version": "3.5.1",
+  "version": "3.6.0",
   "cordova": {
     "id": "@iotize/device-com-ble.cordova",
     "platforms": [

package/plugin.xml

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<plugin xmlns="http://apache.org/cordova/ns/plugins/1.0" id="@iotize/device-com-ble.cordova" version="2.0.0">
+<plugin xmlns="http://apache.org/cordova/ns/plugins/1.0" id="@iotize/device-com-ble.cordova" version="3.5.3">
 
   <name>@iotize/device-com-ble.cordova</name>
   <description>Bluetooth Low Energy (BLE) Plugin for IoTize devices</description>

package/src/android/src/ble/BLECom.java

@@ -35,7 +35,6 @@ import com.iotize.android.communication.protocol.ble.exception.CannotWriteCharac
 import com.iotize.android.communication.protocol.ble.exception.CharacteristicNotAvailableException;
 import com.iotize.android.communication.protocol.ble.exception.ServiceNotAvailableException;
 import com.iotize.android.communication.protocol.ble.exception.WritePacketIsTooBigException;
-import com.iotize.android.communication.protocol.ble.scanner.BLEScanner;
 import com.iotize.android.core.util.Helper;
 import com.iotize.android.device.api.device.scanner.IOnDeviceDiscovered;
 import com.iotize.plugin.cordova.ble.models.RequestDeviceOptions;
@@ -311,7 +310,7 @@ public class BLECom extends CordovaPlugin {
         if (options != null) {
             this.scanner = new BLEScanner(cordova.getContext(), BluetoothAdapter.getDefaultAdapter(), options.getScanFilters());
         } else {
-            this.scanner = new BLEScanner(cordova.getContext(), BluetoothAdapter.getDefaultAdapter());
+            this.scanner = new BLEScanner(cordova.getContext(), BluetoothAdapter.getDefaultAdapter(), TapUtility.createTapFilter());
         }
 
         if (onDeviceDiscoveredCallback == null) {

package/src/android/src/ble/BLEComError.java

@@ -6,6 +6,16 @@
 //
 package com.iotize.plugin.cordova.ble;
 
+import android.bluetooth.le.ScanFilter;
+import android.os.Build;
+import android.os.ParcelUuid;
+
+import com.iotize.android.communication.protocol.ble.Constants;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
 public class BLEComError extends Exception {
 
     private final String code;
@@ -105,4 +115,5 @@ public class BLEComError extends Exception {
         String NOT_CONNECTED_ERROR = "NotConnectedError";
         String BLE_STATUS_CODE_ERROR = "StatusCodeError";
     }
+
 }

package/src/android/src/ble/BLEScanner.java

@@ -0,0 +1,284 @@
+package com.iotize.plugin.cordova.ble;
+
+
+import static android.os.Build.VERSION_CODES.LOLLIPOP;
+
+import android.bluetooth.BluetoothAdapter;
+import android.bluetooth.BluetoothDevice;
+import android.bluetooth.le.BluetoothLeScanner;
+import android.bluetooth.le.ScanCallback;
+import android.bluetooth.le.ScanFilter;
+import android.bluetooth.le.ScanRecord;
+import android.bluetooth.le.ScanResult;
+import android.bluetooth.le.ScanSettings;
+import android.content.Context;
+import android.content.pm.PackageManager;
+import android.os.Build;
+import android.util.Log;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.RequiresApi;
+
+import com.iotize.android.device.api.device.scanner.IDeviceScanner;
+import com.iotize.android.device.api.device.scanner.IOnDeviceDiscovered;
+
+import java.util.List;
+
+/**
+ *
+ */
+@RequiresApi(api = Build.VERSION_CODES.JELLY_BEAN_MR2)
+public class BLEScanner implements IDeviceScanner<BLEScanner.BLEScanData> {
+
+    private static final String TAG = "BLEScanner";
+
+    @NonNull
+    private final BluetoothAdapter mBluetoothAdapter;
+    @NonNull
+    private final Context mContext;
+    @NonNull
+    private final List<ScanFilter> filters;
+
+    // Device scan callback.
+    protected BLE_Callback mLeScanCallback;
+    protected BLE_Callback_API21 mLeScanCallback_API21;
+    private BluetoothLeScanner mBluetoothScanner;
+    private IOnDeviceDiscovered<BLEScanData> onDeviceDiscovered;
+    private boolean mRunning;
+
+    public BLEScanner(@NonNull Context context,
+                      @NonNull BluetoothAdapter bluetoothAdapter,
+                      @NonNull List<ScanFilter> filters) {
+        this.mBluetoothAdapter = bluetoothAdapter;
+        if (Build.VERSION.SDK_INT < LOLLIPOP)
+            mLeScanCallback = new BLE_Callback();
+        else {
+            mLeScanCallback_API21 = new BLE_Callback_API21();
+        }
+        this.mContext = context;
+        this.filters = filters;
+    }
+
+    public void setOnDeviceDiscoveredCallback(IOnDeviceDiscovered<BLEScanData> onDeviceDiscovered) {
+        this.onDeviceDiscovered = onDeviceDiscovered;
+    }
+
+    public void start() {
+        if (mRunning) {
+            Log.w(TAG, "Scan is already running... ignoring this call");
+            return;
+        }
+        mRunning = true;
+        if (Build.VERSION.SDK_INT < LOLLIPOP) {
+            Log.i(TAG, "Starting Bluetooth scan...");
+            mBluetoothAdapter.startLeScan(mLeScanCallback);
+        } else {
+            Log.i(TAG, "Starting Bluetooth Low Energy scan...");
+            try {
+                ScanSettings.Builder buildSettings = new ScanSettings.Builder();
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+                    buildSettings.setCallbackType(ScanSettings.CALLBACK_TYPE_ALL_MATCHES);
+                }
+                buildSettings.setScanMode(ScanSettings.SCAN_MODE_LOW_LATENCY);
+                buildSettings.setReportDelay(0);    // we want the result immediately
+                ScanSettings settings = buildSettings.build();
+                mBluetoothScanner = mBluetoothAdapter.getBluetoothLeScanner();
+                mBluetoothScanner.startScan(this.filters, settings, mLeScanCallback_API21);
+            } catch (Exception e) {
+                Log.e(TAG, "Cannot run bluetooth scan: " + e.getMessage(), e);
+                stop();
+            }
+        }
+    }
+
+    @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
+    public void stop() {
+        try {
+            if (mBluetoothAdapter != null && mBluetoothAdapter.isEnabled()) {
+                if (mBluetoothScanner != null) {
+                    mBluetoothScanner.stopScan(mLeScanCallback_API21);
+                }
+                mBluetoothAdapter.cancelDiscovery();
+            }
+        } catch (Throwable e) {
+            Log.e(TAG, "Error while stopping ble scan: " + e.getMessage(), e);
+        } finally {
+            mRunning = false;
+        }
+    }
+
+    protected void onDeviceDiscovered(BLEScanData device) {
+        Log.v(TAG, "onDeviceDiscovered() " + device.getDevice().getName());
+
+        if (this.onDeviceDiscovered != null) {
+            this.onDeviceDiscovered.onDeviceDiscovered(device);
+        }
+    }
+
+    /**
+     * @return true if device has bluetooth feature
+     */
+    public boolean isAvailable() {
+        PackageManager pm = mContext.getPackageManager();
+        return pm.hasSystemFeature(PackageManager.FEATURE_BLUETOOTH);
+    }
+
+    /**
+     * @return true if device bluetooth is enabled
+     */
+    public boolean isEnabled() {
+        return mBluetoothAdapter != null && mBluetoothAdapter.isEnabled();
+    }
+
+
+    @RequiresApi(api = Build.VERSION_CODES.JELLY_BEAN_MR2)
+    class BLE_Callback implements BluetoothAdapter.LeScanCallback {
+        @Override
+        public void onLeScan(final BluetoothDevice device, int rssi, final byte[] scanRecord) {
+            Log.v(TAG, "Scan result: " + device + " RSSI: " + rssi);
+            onDeviceDiscovered(new BluetoothDeviceAdpaterBeforeLollipop(device, rssi, scanRecord));
+        }
+
+    }
+
+    //YRT170410    @TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR2)
+    @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
+    private class BLE_Callback_API21 extends ScanCallback {
+        @Override
+        public void onScanResult(int callbackType, android.bluetooth.le.ScanResult result) {
+            super.onScanResult(callbackType, result);
+            Log.v(TAG, "Scan result: " + result);
+            //if (callbackType == ScanSettings.CALLBACK_TYPE_ALL_MATCHES) {
+            BluetoothDevice device = result.getDevice();
+            onDeviceDiscovered(new BluetoothDeviceAdpaterFromLollipop(result));
+            //}
+        }
+
+        @Override
+        public void onScanFailed(int errorCode) {
+            Log.e(TAG, "Scan failed with error code: " + errorCode);
+            BLEScanner.this.onScanFailed(errorCode);
+        }
+    }
+
+    private void onScanFailed(int errorCode) {
+        if (this.onDeviceDiscovered != null) {
+            this.onDeviceDiscovered.onScanFailed(
+                    new BleScanError(errorCode)
+            );
+        }
+    }
+
+
+    public interface BLEScanData {
+
+        int getRssi();
+
+        int getTxPower();
+
+        BluetoothDevice getDevice();
+
+        byte[] getScanRecordBytes();
+
+    }
+
+    @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
+    public class BluetoothDeviceAdpaterFromLollipop implements BLEScanner.BLEScanData {
+        private final ScanResult result;
+
+        public BluetoothDeviceAdpaterFromLollipop(ScanResult result) {
+            this.result = result;
+        }
+
+        @Override
+        public int getRssi() {
+            return this.result.getRssi();
+        }
+
+        @Override
+        public int getTxPower() {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                return this.result.getTxPower();
+            }
+            else {
+                return 0;
+            }
+        }
+
+        @Override
+        public BluetoothDevice getDevice() {
+            return this.result.getDevice();
+        }
+        @Override
+        public byte[] getScanRecordBytes() {
+            final ScanRecord scanRecord = this.result.getScanRecord();
+            if (scanRecord == null) {
+                return new byte[0];
+            }
+            return scanRecord.getBytes();
+        }
+
+        @Override
+        public boolean equals(Object obj) {
+            if (obj == null) {
+                return this.getDevice() == null;
+            }
+            if (!(obj instanceof BLEScanner.BLEScanData)) {
+                return false;
+            }
+            return this.result.getDevice().equals(((BLEScanner.BLEScanData) obj).getDevice());
+        }
+    }
+
+    public class BluetoothDeviceAdpaterBeforeLollipop implements BLEScanner.BLEScanData {
+
+        private final BluetoothDevice device;
+        private final int rssi;
+        private final byte[] scanRecord;
+
+        public BluetoothDeviceAdpaterBeforeLollipop(BluetoothDevice device, int rssi, final byte[] scanRecord) {
+            this.device = device;
+            this.rssi = rssi;
+            this.scanRecord = scanRecord;
+        }
+
+        @Override
+        public int getRssi() {
+            return this.rssi;
+        }
+
+        @Override
+        public int getTxPower() {
+            return 0;
+        }
+
+        @Override
+        public BluetoothDevice getDevice() {
+            return this.device;
+        }
+
+        @Override
+        public byte[] getScanRecordBytes() {
+            return this.scanRecord;
+        }
+
+        @Override
+        public boolean equals(Object obj) {
+            if (obj == null) {
+                return this.getDevice() == null;
+            }
+            if (!(obj instanceof BLEScanner.BLEScanData)) {
+                return false;
+            }
+            return this.device.equals(((BLEScanner.BLEScanData) obj).getDevice());
+        }
+    }
+
+    class BleScanError extends Exception {
+        public BleScanError(int errorCode) {
+            super("BLE scan failed (error code: " + errorCode + ")");
+        }
+    }
+
+
+}

package/src/android/src/ble/JSONBuilder.java

@@ -13,9 +13,9 @@ import android.util.Log;
 
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
-import com.iotize.android.communication.protocol.ble.scanner.BLEScanner;
 import com.iotize.plugin.cordova.ble.models.ServiceDescription;
 
+import org.json.JSONArray;
 import org.json.JSONException;
 import org.json.JSONObject;
 
@@ -39,6 +39,8 @@ public class JSONBuilder {
             json.put("address", bluetoothDevice.getAddress());
             // json.put("type", bluetoothDevice.getType());
             json.put("rssi", device.getRssi());
+            json.put("txPower", device.getTxPower());
+            json.put("scanRecord", JSONBuilder.toJSONObject(device.getScanRecordBytes()));
 
             return json;
         } catch (JSONException e) {
@@ -61,6 +63,15 @@ public class JSONBuilder {
         }
     }
 
+    static JSONArray toJSONObject(byte[] bytes) {
+        JSONArray json = new JSONArray();
+        for (byte aByte : bytes) {
+            json.put(aByte);
+        }
+        return json;
+    }
+
+
     public static ArrayList<ServiceDescription> toServicesDescription(List<BluetoothGattService> services) {
         ArrayList<ServiceDescription> result = new ArrayList<>();
         for (BluetoothGattService service : services) {

package/src/android/src/ble/TapUtility.java

@@ -0,0 +1,27 @@
+package com.iotize.plugin.cordova.ble;
+
+import android.bluetooth.le.ScanFilter;
+import android.os.Build;
+import android.os.ParcelUuid;
+
+import com.iotize.android.communication.protocol.ble.Constants;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public  class TapUtility {
+
+    static List<ScanFilter> createTapFilter() {
+        if (Build.VERSION.SDK_INT >= 21) {
+            List<ScanFilter> filters = new ArrayList();
+            ScanFilter.Builder buildFilterTapService = new ScanFilter.Builder();
+            buildFilterTapService.setServiceUuid(new ParcelUuid(Constants.SERVICE_SPP_OVER_LE));
+            filters.add(buildFilterTapService.build());
+            return filters;
+        } else {
+            return Collections.emptyList();
+        }
+    }
+
+}

package/src/ios/BLECom.swift

@@ -13,7 +13,7 @@ import CoreBluetooth
 public func printBLE(_ object: Any...) {
     #if true
     for item in object {
-        Swift.print("BLE:", object)
+        Swift.print("BLE:", item)
     }
     #endif
 }

package/src/ios/BLEManager.swift

@@ -213,14 +213,14 @@ class BLEManager: NSObject, CBCentralManagerDelegate
         if ( connectionChangeCompletion != nil){
             
             if (useBLETapPeripheral) {
-                bleTapPeripheral?.connect(device: peripheral, manager: self)
+                bleTapPeripheral?.connect(device: peripheral, manager: self, connectionChangeCompletion: connectionChangeCompletion)
             } else {
                 bleGenericPeripheral?.connect(device: peripheral, manager: self)
             }
 
             //callback without error
         
-                connectionChangeCompletion!("CONNECTED", nil)
+            //    connectionChangeCompletion!("CONNECTED", nil) callback moved to didDiscoverCharacteristics
 //                connectionChangeCompletion = nil
                     
         }
@@ -254,10 +254,9 @@ class BLEManager: NSObject, CBCentralManagerDelegate
         //callback without error, if we have requested this disconnection
         if ( disconnectionCompletion != nil){
             disconnectionCompletion!(nil)
-            disconnectionCompletion = nil
-            connectionChangeCompletion = nil
-            return
         }
+        disconnectionCompletion = nil
+        connectionChangeCompletion = nil
 
         if (bleGenericPeripheral != nil) {
             bleGenericPeripheral!.connectedDevice = nil
@@ -265,7 +264,8 @@ class BLEManager: NSObject, CBCentralManagerDelegate
         }
         if (bleTapPeripheral != nil) {
             bleTapPeripheral!.bleDevice = nil
-        }    }
+        }    
+    }
     
     func checkConnection(completion: @escaping Completion){
         if (useBLETapPeripheral) {

package/src/ios/BLETapPeripheral.swift

@@ -66,6 +66,12 @@ class BLETapPeripheral:  NSObject, CBPeripheralDelegate{
     private static var LEN_PACKET = 19         // MTU = 23 - 3 - 1 num packet
     private let requestQueueManagementDelay = 0.002
     
+    var connectionStateCompletion: CompletionWithResponse?
+    
+    init(connectionState: CompletionWithResponse?) {
+        connectionStateCompletion = connectionState
+    }
+    
     override init(){
         super.init()
         DispatchQueue.global(qos: .background).async {
@@ -73,11 +79,12 @@ class BLETapPeripheral:  NSObject, CBPeripheralDelegate{
         }
     }
     
-    func connect( device: CBPeripheral, manager: BLEManager){
+    func connect( device: CBPeripheral, manager: BLEManager, connectionChangeCompletion: CompletionWithResponse?){
         bleManager = manager
         lastError = nil
         bleDevice = device
         bleDevice.delegate = self
+        connectionStateCompletion = connectionChangeCompletion
         bleDevice.discoverServices([UUID_UPGRADE_SERVICE, SPPoverLE_SERVICE_UUID, SPPoverLE_SERVICE_UUID_FAST])
     }
     
@@ -155,6 +162,7 @@ class BLETapPeripheral:  NSObject, CBPeripheralDelegate{
             lastError = IoTizeBleError.CharacteristicSPPNotFound(peripheral: peripheral)
         } else {
             self.isReady = true
+            connectionStateCompletion?("CONNECTED", nil)
         }
     }