蓝牙

蓝牙

https://github.com/a-voyager/BluetoothHelper
+ 安卓蓝牙操作库

```

### BLE

`api 'com.inuker.bluetooth:library:1.4.0'`
    + `https://github.com/dingjikerbo/Android-BluetoothKit`

```java
public class ZBleManager {
    private static String TAG = ZBleManager.class.getSimpleName();
    private BluetoothClient mClient;
//    private BluetoothBondListener mBluetoothBondListener;

    // ---------------------------------------------------------------------------------------------
    // 单例模式
    private static ZBleManager INSTANCE = null;

    public static ZBleManager getInstance() {
        if (null == INSTANCE) {
            synchronized (ZBleManager.class) {
                if (null == INSTANCE) {
                    INSTANCE = new ZBleManager();
                }
            }
        }
        return INSTANCE;
    }

    private ZBleManager() {
    }

    // ---------------------------------------------------------------------------------------------
    // 初始化对象
    public void initBle(Context context) {
        if (null == mClient)
            mClient = new BluetoothClient(context);
        //配对监听
//        mBluetoothBondListener = new BluetoothBondListener() {
//            @Override
//            public void onBondStateChanged(String mac, int bondState) {
//            }
//        };
//        mClient.registerBluetoothBondListener(mBluetoothBondListener);
    }

    // ---------------------------------------------------------------------------------------------
    // 开关
    public boolean isSupportBle() {
        BluetoothAdapter adapter = BluetoothAdapter.getDefaultAdapter();
        return null != adapter;
    }

    public boolean isBlueOpen() {
        return mClient.isBluetoothOpened();
    }

    private IBleStateListener mIBleStateListener = null;
    private BluetoothStateListener mBluetoothStateListener = new BluetoothStateListener() {
        @SuppressLint("CheckResult")
        @Override
        public void onBluetoothStateChanged(boolean openOrClosed) {
            if (null != mClient)
                mClient.unregisterBluetoothStateListener(this);
            if (null != mIBleStateListener) {
                mIBleStateListener.onBleOpen(openOrClosed);
                mIBleStateListener = null;
            }
        }
    };

    public void openBluetooth(IBleStateListener listener) {
        if (null == mClient) return;
        if (null != listener) {
            mIBleStateListener = listener;
            // 注意该监听只支持监听状态发生变化情况
            // openBluetooth后，如果用户阻止了打开行为，该回调不生效
            // 弹窗会导致APP UI失去焦点，可以根据焦点状态判定用户是否已经选择，然后再检查用户选择结果
            mClient.registerBluetoothStateListener(mBluetoothStateListener);
        }
        mClient.openBluetooth();
    }

    public void closeBluetooth(IBleStateListener listener) {
        if (null == mClient) return;
        if (null != listener) {
            mIBleStateListener = listener;
            mClient.registerBluetoothStateListener(mBluetoothStateListener);
        }
        mClient.closeBluetooth();
    }

    // ---------------------------------------------------------------------------------------------
    // 扫描
    public void scan(final IBleScanListener listener) {
        if (null == mClient) return;
        SearchRequest request = new SearchRequest.Builder()
//                .searchBluetoothLeDevice(3000, 3)   // Start by scanning your BLE devices 3 times， every time 3s
//                .searchBluetoothClassicDevice(5000) // and scanning the traditional bluetooth devices 5s
                .searchBluetoothLeDevice(2000)      //and scanning BLE devices 2s
                .build();
        mClient.search(request, new SearchResponse() {
            @Override
            public void onSearchStarted() {
                if (listener != null) listener.onScanStarted();
            }

            @Override
            public void onDeviceFounded(SearchResult device) {
                if (listener != null) listener.onDeviceFounded(device);
            }

            @Override
            public void onSearchStopped() {
                if (listener != null) listener.onScanStop();
            }

            @Override
            public void onSearchCanceled() {
                if (listener != null) listener.onScanCanceled();
            }
        });
    }

    public void cancelScan() {
        if (null != mClient)
            mClient.stopSearch();
    }

    // ---------------------------------------------------------------------------------------------
    // 连接
    private Disposable mDisposable;
    private IBleConnectStatusListener mConnectListener;
    private boolean isConnected = false;

    public int getConnectStatus(String mac) {
        int code = mClient.getConnectStatus(mac);
        return code;
    }

    public boolean isConnected() {
        return isConnected;
    }

    @SuppressLint("CheckResult")
    public void connect(final String mac, IBleConnectStatusListener listener) {
        if (null == mClient) return;
        isConnected = false;
        this.mConnectListener = listener;
        mClient.registerConnectStatusListener(mac, mBleConnectStatusListener);
        mDisposable = Flowable.timer(100, TimeUnit.MILLISECONDS)
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<Long>() {
                    @Override
                    public void accept(Long aLong) throws Exception {
                        final BleConnectOptions options = new BleConnectOptions.Builder()
                                .setConnectRetry(3)   // Retry the connection 3 times if it fails
                                .setConnectTimeout(5000)   // Connect Timeout 5s
                                .setServiceDiscoverRetry(3)  // Retry service discovery 3 times if it fails
                                .setServiceDiscoverTimeout(5000)  // Discovery of service timeout 5s
                                .build();
                        if (mConnectListener != null)
                            mConnectListener.onStartConnect();
                        mClient.connect(mac, options, new BleConnectResponse() {
                            @Override
                            public void onResponse(int code, BleGattProfile data) {
                                if (code == REQUEST_SUCCESS) {
                                    isConnected = true;
                                    if (null != mConnectListener)
                                        mConnectListener.onConnectSuccess(code, data, mac);
                                } else {
                                    isConnected = false;
                                    if (null != mConnectListener)
                                        mConnectListener.onConnectFail();
                                }
                            }
                        });
                    }
                });
    }

    private BleConnectStatusListener mBleConnectStatusListener = new BleConnectStatusListener() {
        @Override
        public void onConnectStatusChanged(String mac, int status) {
            if (status == STATUS_CONNECTED) {
                isConnected = true;
            } else if (status == STATUS_DISCONNECTED) {
                mClient.unregisterConnectStatusListener(mac, mBleConnectStatusListener);
                if (!isConnected) {
                    // 未连接成功就反馈失败：蓝牙状态异常，stop掉
                    unIndicate();
                    for (int i = 0; i < 10; i++) {
                        mClient.disconnect(mac);
                    }
                    Log.e(TAG, "STATUS_DISCONNECTED: stop");
                    return;
                }
                Log.e(TAG, "STATUS_DISCONNECTED");
                if (null != mConnectListener) {
                    if (isConnected)
                        mConnectListener.onDisConnected(mac);
                    mConnectListener = null;
                }
                isConnected = false;
            }
        }
    };

    public void disConnectDevice(String mac) {
        unIndicate();
        if (null != mClient) {
            if (!mac.isEmpty()) {
                for (int i = 0; i < 10; i++) {
                    mClient.disconnect(mac);
                }
                mClient.clearRequest(mac, REQUEST_READ);
                mClient.clearRequest(mac, REQUEST_WRITE);
                mClient.clearRequest(mac, REQUEST_NOTIFY);
//                mClient.refreshCache(mac);
            }
        }
        if (null != mDisposable) {
            mDisposable.dispose();
            mDisposable = null;
        }
        isConnected = false;
    }

    // ---------------------------------------------------------------------------------------------
    // 蓝牙设备服务事件监听
    private String indicateMac;
    private String serviceUUID;
    private String characterUUID;

    public void indicate(String MAC, String serviceUUID, String characterUUID, final IBleIndicateListener callback) {
        if (null == mClient) return;
        indicateMac = MAC;
        this.serviceUUID = serviceUUID;
        this.characterUUID = characterUUID;
        mClient.notify(MAC, UUID.fromString(serviceUUID), UUID.fromString(characterUUID), new BleNotifyResponse() {
            @Override
            public void onNotify(UUID service, UUID character, byte[] value) {
                if (null != callback) callback.onCharacteristicChanged(value);
            }

            @Override
            public void onResponse(int code) {
                if (code == REQUEST_SUCCESS) {
                    if (null != callback) callback.onIndicateSuccess();
                } else if (REQUEST_FAILED == code) {
                    if (null != callback) callback.onIndicateFailure(code);
                }
            }
        });
    }

    public void unIndicate() {
        if (null == mClient) return;
        if (indicateMac == null || indicateMac.isEmpty()) return;
        if (serviceUUID == null || serviceUUID.isEmpty()) return;
        if (characterUUID == null || characterUUID.isEmpty()) return;
        Log.e(TAG, "unIndicate");
        mClient.unnotify(indicateMac, UUID.fromString(serviceUUID), UUID.fromString(characterUUID), new BleUnnotifyResponse() {
            @Override
            public void onResponse(int code) {
            }
        });
        indicateMac = "";
        serviceUUID = "";
        characterUUID = "";
    }

    // ---------------------------------------------------------------------------------------------
    // 读写
    private IBleWriteListener mIBleWriteListener;

    public void write(String MAC, String uuid_service, String uuid_write, final byte[] data, IBleWriteListener callback) {
        if (null == mClient) return;
        this.mIBleWriteListener = callback;
        mClient.write(MAC, UUID.fromString(uuid_service), UUID.fromString(uuid_write), data, new BleWriteResponse() {
            @Override
            public void onResponse(int code) {
                if (code == REQUEST_SUCCESS) {
                    if (null != mIBleWriteListener) mIBleWriteListener.onWriteSuccess();
                } else {
                    if (null != mIBleWriteListener) mIBleWriteListener.onWriteFailure(code);
                }
            }
        });
    }

    public void read(String MAC, String uuid_service, String uuid_write) {
        if (null == mClient) return;
        mClient.read(MAC, UUID.fromString(uuid_service), UUID.fromString(uuid_write), new BleReadResponse() {
            @Override
            public void onResponse(int code, byte[] data) {
            }
        });
    }

    // ---------------------------------------------------------------------------------------------
    // 释放
    public void destroy() {
        // Constants.REQUEST_READ，所有读请求
        // Constants.REQUEST_WRITE，所有写请求
        // Constants.REQUEST_NOTIFY，所有通知相关的请求
        // Constants.REQUEST_RSSI，所有读信号强度的请求
        cancelScan();
        disConnectDevice("");
        if (null != mClient) {
//            mClient.unregisterBluetoothBondListener(mBluetoothBondListener);
//            mClient.unregisterBluetoothStateListener(mBluetoothStateListener);
        }
//        if (null != mIBleStateListener) mIBleStateListener = null;
//        if (null != mBluetoothStateListener) mBluetoothStateListener = null;
        if (null != mBleConnectStatusListener) mBleConnectStatusListener = null;
//        if (null != mBluetoothBondListener) mBluetoothBondListener = null;
        if (mIBleWriteListener != null) mIBleWriteListener = null;
    }
}