implementation 'com.ikangtai.buletoothsdk:ScBuletoothLib:1.2.0'

        android {
            repositories {
                flatDir {
                dirs 'libs'
                }
            }
        }

        dependencies {
            implementation(name: 'scbluetoothlib-release-v1.2.0', ext: 'aar')
        }

<manifest ……>
<uses-permission android:name="android.permission.BLUETOOTH" />
<uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION"/>
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
<application ……>

    ScPeripheralManager.getInstance().init(getContext());

    if (!checkBleFeatures()) {
        return;
    }
    scPeripheralManager.startScan(new ScanResultListener() {
        /**
     	  * When scanning nearby devices, call back the device list through this method.
          * The method call will be triggered once per second until called the stopScanDevice method.
     	  * @param deviceList
     	  */
        public void onScannerResult(List<ScPeripheral> deviceList) {

        }
    });

   private boolean checkBleFeatures() {
        //Check Bluetooth Location Service
        if (!BleTools.isLocationEnable(getContext())) {
            Intent locationIntent = new Intent(Settings.ACTION_LOCATION_SOURCE_SETTINGS);
            startActivityForResult(locationIntent, REQUEST_LOCATION_SETTINGS);
            return false;
        }
        //Check Bluetooth location permission
        if (!BleTools.checkBlePermission(getContext())) {
            XXPermissions.with(getActivity())
                    .permission(Permission.Group.LOCATION)
                    .request(callback);
            return false;
        }
        //Check the Bluetooth switch
        if (!BleTools.checkBleEnable()) {
            Intent intent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
            startActivityForResult(intent, REQUEST_BLE_SETTINGS_CODE);
            return false;
        }
        return true;
    }

  ReceiveDataListenerAdapter receiveDataListenerAdapter = new ReceiveDataListenerAdapter() {
        /**
         *
         * @param macAddress
         * @param Scan to the device list, return the latest device list every second
         */
        public void onReceiveData(String macAddress, List<ScPeripheralData> scPeripheralDataList) {
            appendConsoleContent("New data received " + macAddress);
        }
        /**
          * The method called when there is an error in the connected device.
          *
          * @param macAddress
          * @param code errorCode ,see{@link com.ikangtai.bluetoothsdk.util.BleCode}
          * @param msg errorMsg
          */
        public void onReceiveError(String macAddress, int code, String msg) {
            LogUtils.d("onReceiveError:" + code + "  " + msg);
        }

        /**
          * This method will be called when the status of the connected device changes.
          *
          * @param macAddress
          * @param state connect state
          */
        public void onConnectionStateChange(String macAddress, int state) {
            if (state == BluetoothProfile.STATE_CONNECTED) {

            } else if (state == BluetoothProfile.STATE_DISCONNECTED) {

            }
        }

        /**
          *
          * @param macAddress
          * @param command type，type see {@link com.ikangtai.bluetoothsdk.BleCommand}
          * @param The status returned by the execution command will return true or false.
          * @param The result value returned by executing the command.
          */
        public void onReceiveCommandData(String macAddress, int type, boolean state, String value) {
            LogUtils.d("onReceiveCommandData:" + type + "  " + state + " " + value);
        }

        /**
          *
          * @param macAddress
          * @param command type，type see {@link com.ikangtai.bluetoothsdk.BleCommand}
          * @param The status returned by the execution command will return true or false.
          * @param The result value byte[]data returned by executing the command,data stream from fetal heart rate monitoring.
          */
        public void onReceiveCommandData(String macAddress, int type, boolean state, byte[] value) {
            LogUtils.d("onReceiveCommandData:" + type + "  " + resultCode + " " + BleUtils.byte2hex(value));
        }
    };
  scPeripheralManager.connectPeripheral(macAddress, receiveDataListenerAdapter);

    scPeripheralManager.stopScan();
    scPeripheralManager.disconnectPeripheral();

  scPeripheralManager.sendPeripheralCommand(macAddress, BleCommand.GET_DEVICE_DATA);

  scPeripheralManager.sendPeripheralCommand(macAddress, BleCommand.SYNC_TIME);

  scPeripheralManager.sendPeripheralCommand(macAddress, BleCommand.SYNC_THERMOMETER_UNIT_C);

  scPeripheralManager.sendPeripheralCommand(macAddress, BleCommand.SYNC_THERMOMETER_UNIT_F);

{SEND_TEMP_ACK, SYNC_THERMOMETER_UNIT_C, SYNC_THERMOMETER_UNIT_F, SYNC_TIME, GET_FIRMWARE_VERSION, GET_DEVICE_DATA, SYNC_THERMOMETER_UNIT, GET_POWER, GET_THERMOMETER_OAD_IMG_TYPE, THERMOMETER_OAD_UPGRADE};

{GET_EWQ_FIRMWARE_VERSION, GET_EWQ_DEVICE_DATA}

{SEND_TEMP_ACK, SYNC_TIME, GET_TIME, GET_FIRMWARE_VERSION, GET_DEVICE_DATA, SET_THERMOMETER_MODE, GET_THERMOMETER_MODE, GET_THERMOMETER_MEASURE_TIME, SET_THERMOMETER_MEASURE_TIME1, SET_THERMOMETER_MEASURE_TIME2, CLEAR_THERMOMETER_DATA, GET_DEVICE_HISTORY_DATA, SYNC_THERMOMETER_UNIT, GET_THERMOMETER_UNIT, GET_POWER,THERMOMETER_OTA_UPGRADE};

{SEND_TEMP_ACK, SYNC_TIME, GET_TIME, GET_FIRMWARE_VERSION, GET_DEVICE_DATA, GET_THERMOMETER_MEASURE_TIME, SET_THERMOMETER_MEASURE_TIME1, SET_THERMOMETER_MEASURE_TIME2, CLEAR_THERMOMETER_DATA, GET_DEVICE_HISTORY_DATA, SYNC_THERMOMETER_UNIT, GET_THERMOMETER_UNIT, GET_POWER, THERMOMETER_OTA_UPGRADE};

{SYNC_TIME, GET_FIRMWARE_VERSION, GET_DEVICE_DATA, GET_POWER, IFEVER_DEVICE_VERIFY};

    -dontwarn  com.ikangtai.bluetoothsdk.**
    -keep class com.ikangtai.bluetoothsdk.** {*;}

    /**
     * There are two ways to configure log
     * 1. {@link Config.Builder#logWriter(Writer)}
     * 2. {@link Config.Builder#logFilePath(String)}
     */
    LogUtils.LOG_SWITCH=true;
    Config config = new Config.Builder().logWriter(logWriter).build();
    //Config config = new Config.Builder().logFilePath(logFilePath).build();
    scPeripheralManager.init(getContext(), config);

public class ScPeripheralManager {

    /**
     * Start scanning nearby devices and call back the device list through this {@link ScanResultListener#onScannerResult(List)}.
     * The method call will be triggered once per second until called the {@link #stopScan()} method.
     *
     * @param scanResultListener
     */
    public void startScan(ScanResultListener scanResultListener) {
        BleManager.getInstance().startScanAllDevice(scanResultListener);
    }

    /**
     * Stop scan device
     */
    public void stopScan() {
        BleManager.getInstance().stopScanDevice();
    }

    /**
     * Add listeners to a set of listeners that will send events during device connection.
     * When you want to disconnect the device, you need to actively call {@link ScPeripheralManager#removeReceiveDataListener(ReceiveDataListener)}
     *
     * @param receiveDataListener the listener to be added to the current set of listeners for {@link com.ikangtai.bluetoothsdk.BleManager}.
     */
    public void addReceiveDataListener(ReceiveDataListener receiveDataListener) {
        BleManager.getInstance().addReceiveDataListener(receiveDataListener);
    }

    /**
     * Removes a listener from the set listening to data updates for {@link com.ikangtai.bluetoothsdk.BleManager}.
     *
     * @param receiveDataListener ,the listener to be removed from the current set of update listeners for {@link com.ikangtai.bluetoothsdk.BleManager}.
     *
     */
    public void removeReceiveDataListener(ReceiveDataListener receiveDataListener) {
        BleManager.getInstance().removeReceiveDataListener(receiveDataListener);
    }

    /**
     * Connect the device,need set global listeners {@link #addReceiveDataListener(ReceiveDataListener)} listening to data updates.
     *
     * @param macAddress
     */
    public void connectPeripheral(String macAddress) {
        BleManager.getInstance().startConnectDevice(macAddress, null);
    }

    /**
     * Connect the device,adds a listener to the set of listeners
     * that are sent data update events for {@link com.ikangtai.bluetoothsdk.BleManager}.
     *
     * @param macAddress
     * @param receiveDataListener
     */

    public void connectPeripheral(String macAddress, ReceiveDataListener receiveDataListener) {
        BleManager.getInstance().startConnectDevice(macAddress, receiveDataListener);
    }

    /**
     * Send device command
     *
     * @param type
     */
    public void sendPeripheraleCommand(String macAddress, int type) {
        BleManager.getInstance().sendDeviceCommand(macAddress, type);
    }

    /**
     * Get device connection state.
     *
     * @param macAddress
     * @return either one of state {@link android.bluetooth.BluetoothProfile }
     */
    public int getConnectState(String macAddress) {
        return BleManager.getInstance().getConnectState(macAddress);
    }

    /**
     * Disconnect the device
     *
     * @param macAddress
     */
    public void disconnectPeripheral(String macAddress) {
        BleManager.getInstance().disconnect(macAddress);
    }

    public void disconnectPeripheral(String macAddress, ReceiveDataListener receiveDataListener) {
        BleManager.getInstance().disconnect(macAddress, receiveDataListener);
    }

    /**
     * Disconnect all devices
     */
    public void disconnectPeripheral() {
        BleManager.getInstance().disconnect();
    }
}