（本文观点纯属个人观点，并非具有权威参考价值，如有错误，望看客指出。）

简介

开发之前，首先来了解一下蓝牙BLE和传统蓝牙有何区别，这将会有助于后面的开发。

• 在过去的蓝牙开发项目当中，我们曾经使用过BLUETOOTHSOCKET和BLUETOOTHSERVERSOCKET的方式来在手机与蓝牙外设之间进行通信，这种方式与TCP/IP通信有点像，手机与蓝牙外设只能其中一个作为SERVER角色，另外一个作为CLIENT角色，一般来说，谁优先发起链接请求的，谁就是CLIENT，另外一个就作为SERVER。在通过BLUETOOTHSOCKET或BLUETOOTHSERVERSOCKET相关API获得蓝牙通道（RFCOMM）后，方可利用此通道进行双端通信。

• 在BLE开发当中，同样存在两个角色，一个是中心角色（CENTRAL），一个是外设角色（PERIPHERAL）；蓝牙设备或手机都可以单独作为CENTRAL或PERIPHERAL角色（较旧的版本当中手机无法作为外设提供数据）。外设角色的作用是为中心角色提供各种数据，中心角色可以扫描并接收多个外设角色数据，数据以服务（SERVICE）和特征（CHARACTERISTIC）的形式呈现。一个服务可以包含多个特征，如何更好的理解服务和特征？大家可以把服务当成一个包裹，特征当成包裹里面的物品，包裹有包裹的名字，物品有物品的名字，一个包裹可以包含多个物品，或为空。如此一来，服务和特征的特性关系应该更加清晰，我们的目标就是用手机来获取外设的服务，取的其中的特征来获得数据。

在非常简单的介绍过后，接下来我们来看看在BLE开发当中各种主要类和其作用。

• BluetoothDeivce：蓝牙设备，代表一个具体的蓝牙外设。
• BluetoothAdapter：蓝牙适配器，每一台支持蓝牙功能的手机都有一个蓝牙适配器，一般来说，只有一个。
• BluetoothManager：蓝牙管理器，主要用于获取蓝牙适配器和管理所有和蓝牙相关的东西。
• BluetoothGatt：通用属性协议， 定义了BLE通讯的基本规则，就是通过把数据包装成服务和特征的约定过程。
• BluetoothGattCallback：一个回调类，非常重要而且会频繁使用，用于回调GATT通信的各种状态和结果，后面会详细解释。
• BluetoothGattCharacteristic：特征，里面包含了一组或多组数据，是GATT通信中的最小数据单元。
• BluetoothGattService：服务，描述了一个BLE设备的一项基本功能，由零或多个特征组构成。
• BluetoothGattDescriptor：特征描述符，对特征的额外描述，包括但不仅限于特征的单位，属性等。
• BluetoothLeScanner：蓝牙适配器里面的扫描器，用于扫描BLE外设。

以上就是在BLE开发中一定会用到的一些基础类，实际使用当中，可能还会用到例如AdvertiseData，AdvertiseSettings，AdvertiseCallback等等，会在后续陆续更新。接下来需要先简单梳理各种类和角色之间是什么关系。

• 中心与外设角色：任何设备都可以单独作为中心或外设角色。一个没有被链接的外设角色，会向外界发出广播，这个时候可以被多个中心角色发现，一旦外设角色被某个中心角色链接后，外设角色就会停止广播，其他中心角色就无法在链接到这个外设角色。中心角色可以扫描外设角色，可以监听接收广播或主动链接，一个中心角色可以与多个外设同时链接。
• 协议，服务与特征：一份协议由一个或多个服务构成，一个服务由零个或多个特征构成，一个特征可以包含一组或多组值，可以包含零个或多个描述符。每一个服务与特征都有一个UUID作为唯一识别符，识别符有通用的，也可以自定义，也可以随机生成，固定格式00000000-0000-0000-0000-000000000000（8-4-4-4-12），一般来说自定义的UUID只有前8位有变化，后面的基本是固定的0000-1000-8000-00805f9b34fb，所以一个自定义的UUID一般看起来就像这样 “0000????-0000-1000-8000-00805f9b34fb” ????就表示4个16进制数。每一个特征都有其属性和权限（READ | WRITE | NOTIFY | INDICATE），特征根据属性可读可写。
• 适配器，扫描器，设备：每一台支持蓝牙的手机中都会有一个蓝牙适配器，由蓝牙管理器管理着，从其中获得蓝牙适配器。适配器中自带扫描器，使用扫描器可以扫描周边的蓝牙设备。

到这里，大体上已经对BLE相关基础内容有了初步印象，接下来会用代码方式演示如何通过协议与外设通信。

协议

首先我们来看看一个简单的BLE协议是怎么样定义的。在BLE开发过程中，硬件开发与软件开发之间需要互相协商定义一个双方都认可的BLE通信协议，包括所有服务，特征等的UUID，数据格式，和数据包定义等。先模拟一个简单的协议，名字叫XXXX服务：

XXXX Service

由表中看出，XXXX服务的服务UUID是018f (完整的表示 ：0000018f – 0000-1000-8000-00805f9b34fb， 在IOS中，可以直接使用018f)，其中包含2个特征，一个UUID是2a19，属性为READ可读，另外一个是4e17，属性为NOTIFY通知 。如何用代码表示一个已知的UUID？如下：

private UUID xxxxServiceUUID = UUID.fromString("0000018f-0000-1000-8000-00805f9b34fb");

需要注意的是，这里用的String字符串一定是完整的32位的，安卓中不能单独使用018f，否则会报错。如此一来，一个服务UUID就表示完毕了，特征也是一样。
在蓝牙设备与中心通信的数据交互中，一次传输最大只能传20个byte，超过20个byte，就需要进行分包处理了，那么协议中如何定义这20个byte当中包含的信息呢？举个例子，现在我们定义：
byte0-byte1分别表示总包号，分包号；
byte2-byte5表示UCT时间；

最后，我们会收到一条数据：00 01 18 62 6e 80 00 00 00 00 00 00 00 00 00 00 00 00 00 00
当然，不一定需要使用20个byte，如果6个就可以解决问题，那么我们为什么不用 00 01 18 62 6e 80 呢？
在中心接收到这条收据后，我们就可以知道这些数据表示：总包号为0，分包号为1，UCT时间为0x18626e80秒，得到这些原始数据后，我们就可以根据具体情况，转换或解析每一个数据表示什么，后面会讲到这些，现在只是举例说明协议是如何定义的。
这里只是举例了一个服务，一个设备是可以包含很多个服务的，所以，你最后大概会需要分析一大堆UUID和这些byte数组。
到此为止，我们已经非常简单的定义了一个可用的BLE协议了。

代码

在Androidmanifest.xml中添加相关权限。

<uses-permission android:name="android.permission.BLUETOOTH" />
<uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />

<uses-feature android:name="android.hardware.bluetooth_le" android:required="false"/>
<!--当android:required为true的时候，app只能强制运行在支持BLE功能的设备商，为false的时候，可以运行在所有设备上，-->
<!--但某些方法需要手动检测，否则可能存在隐性BUG-->

新建一个服务类例如BleService继承于Service，在服务里完成对蓝牙的所有操作。

public class BleService extends Service {
    private BleBinder mBleBinder;
    private Handler mBleHandler = new Handler(){
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
        }
    };
    
    @Override
    public IBinder onBind(Intent intent) {
        return mBleBinder;
    }
    
    public class BleBinder extends Binder {
        //在此提供对外部的调用方法，当某活动绑定此服务后，获得返回mBleBinder对象，外部活动通过操作mBleBinder的方法来控制蓝牙设备。
        public void startScan(){
        //开始扫描......
        }

        public void stopScan(){
        //停止扫描........
        }
        //更多方法........需要注意的是，某些方法为耗时操作，有必要时应该开启子线程去执行。
        //而且蓝牙很多时候都是异步操作，需要使用许多回调方法。
        //如果此服务为独立进程服务，并为其他app提供数据，需要注意方法同步。
    }
}

判断设备上的蓝牙是否可用，是否开启。

//适配器与蓝牙管理器的成员变量。
private BluetoothAdapter mBluetoothAdapter;
private BluetoothManager mBluetoothManager;

//检查设备是否支持BLE功能。
private boolean checkIfSupportBle(){
    return getPackageManager().hasSystemFeature(PackageManager.FEATURE_BLUETOOTH_LE);
}

//如果设备支持BLE，那么就可以获取蓝牙适配器。
private BluetoothAdapter getAdapter(){
    if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.JELLY_BEAN_MR2) {
            mBluetoothManager = (BluetoothManager) getSystemService(Context.BLUETOOTH_SERVICE);
            mBluetoothAdapter = mBluetoothManager.getAdapter();
        } else {
            mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
        }
    return mBluetoothAdapter;
}

//获取完适配器后，需要检测是否已经打开蓝牙功能，如果没有，就需要开启。
//开启蓝牙功能需要一小段时间，具体涉及的线程操作或同步对象不在此讨论，视实际情况按需编写。
private void enableBluetooth(){
    if (mBluetoothAdapter == null || !mBluetoothAdapter.isEnabled()) {
        Intent enableBtIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
        startActivityForResult(enableBtIntent, REQUEST_ENABLE_BT);
    }
}

//此方法用于获取在手机中已经获取并绑定了的设备
private void getBoundDevices(){
    Set<BluetoothDevice> boundDevices = mBluetoothAdapter.getBondedDevices();
    for(BluetoothDevice device : boundDevices){
        //对device进行其他操作，比如连接等。
    }
}

扫描的3种方法

//设备列表成员变量
private List<BluetoothDevice> mDevices;

//startDiscover() 和 startLeScan()，startBleScan() 都可以发现设备，但是startLeScan() 和startScan()只会发现那些支持BLE的设备。

//第一种方法
//startDiscover() 是通用扫描方法
private void startDiscover(){
    mBluetoothAdapter.startDiscover();
    //此过程大概持续10秒，当扫描到蓝牙设备后，会发出广播，只要在需要的地方注册接收广播，就可以获得扫描结果。
    //这种方法可以扫描出所有蓝牙设备，包括BLE，但貌似不同手机有不同体验，各位实践出真知吧，扫不扫得到，看具体设备。
}
//注册此广播，监听BluetoothDevice.ACTION_FOUND，以接收系统消息取得扫描结果
private class DeviceReceiver extends BroadcastReceiver {
    @Override
    public void onReceive(Context context, Intent intent) {
        String action = intent.getAction();
        if(BluetoothDevice.ACTION_FOUND.equals(action)){
            BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);  //这个就是所获得的蓝牙设备。
            mDevices.add(device );
        }
    }
}

//第二种方法
//startLeScan是一个已经被声明过时的方法，但此方法依然可用，而且很多设备上运行的还是这个方法。
//开始扫描
private void startLeScan() {
    mBluetoothAdapter.startLeScan(mLeScanCallback)；
}
//停止扫描
private void stopScan() {
    mBluetoothAdapter.stopLeScan(mLeScanCallback);
}
//LeScanCallback 是蓝牙扫描返回结果的回调，可以通过回调获取扫描结果。
private BluetoothAdapter.LeScanCallback mLeScanCallback= new BluetoothAdapter.LeScanCallback(){
    @Override
    public void onLeScan(BluetoothDevice device, int rssi, byte[] scanRecord) {
        mDevices.add(bluetoothDevice);
        //成功扫描到设备后，在这里获得bluetoothDevice。可以放进设备列表成员变量当中方便后续操作。
        //也可以发广播通知activity发现了新设备，更新活动设备列表的显示等。
        //这里需要注意一点，在onLeScan当中不能执行耗时操作，不宜执行复杂运算操作，切记，
        //下面即将提到的onScanResult，onBatchScanResults同理。
    }
};

//第三种方法
//代替已过时的startLeScan()方法的方法，但貌有时候扫不出目标设备。此方法API21以上可用。
//开始扫描
private void startBleScan(){
    mBluetoothAdapter.getBluetoothLeScanner().startScan(mScanCallback);
}
//停止扫描
private void stopBleScan(){
    mBluetoothAdapter.getBluetoothLeScanner().stopScan(mScanCallback);
}
//ScanCallback 是蓝牙扫描返回结果的回调，可以通过回调获取扫描结果。
private ScanCallback mScanCallback = new ScanCallback() {
    @Override
    public void onScanResult(int callbackType, ScanResult result) {
        super.onScanResult(callbackType, result);
        //当发现一个外设时回调此方法，但本人在实际使用过程当中发现一些问题，
        //此方法在一次扫描过程当中只会返回一台设备，也就是如果scan有结果返回后，
        //就会一直返回被第一次扫描到的那个设备，无论等多久都一样，所以本人怀疑
        //如果要使用此方法的话，可能需要间歇性多次调用startScan才能发现多个设备。
        //但是不是这样，各位可以自己去试一试，因为本人在开发过程中依然使用了
        //上面第二种过时的方法。ScanResult 可以获得扫描到的设备，可以保存到设备列表成员变量当中方便后续操作。
    }

    @Override
    public void onBatchScanResults(List<ScanResult> results) {
        super.onBatchScanResults(results);
        //在此返回一个包含所有扫描结果的列表集，包括以往扫描到的结果。
    }

    @Override
    public void onScanFailed(int errorCode) {
        super.onScanFailed(errorCode);
        //扫描失败后的处理。
    }
};

//这个方法意在告诉大家获取得到设备后，我们能获得什么信息，非主要函数，可以忽略。
private void showDetailOfDevice(){
    //获得设备名称，多个设备可以有同一个名称。
    String deviceName = mTargetDevice.getName();//获得设备名称，多个设备可以有同一个名称。
    //获取设备物理地址，一个设备只能有一个物理地址，每个设备都有每个设备的物理地址，无法相同。
    String deviceMacAddress = mTargetDevice.getAddress();
    //绑定设备
    mTargetDevice.createBond();
    //更多的信息....
}

另外再补充一点，对于安卓6.0以上的基带，需要获取动态权限，具体如下

//android 6.0 以上的扫描结果获取动态权限的方法
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_attach_device);

    //再onCreate方法当中加入以下代码，判断系统是否需要动态获取权限。
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
        if (this.checkSelfPermission(Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
            requestPermissions(new String[]{Manifest.permission.ACCESS_COARSE_LOCATION}, 1);
        }
    }
}

//然后加入onRequestPermissionsResult这个方法，如果只是需要获取权限，那么如下就可以了。
//至于获取到权限后各位还有什么其他用处，就自由发挥吧。
@Override
public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
    super.onRequestPermissionsResult(requestCode, permissions, grantResults);
}

利用以上方法，可以扫描到所需要的蓝牙设备，需要注意的是，同一时间只能有一种扫描方法起作用，不能在使用方法1的同时再使用方法2或3。可以把扫描结果存储在一个成员列表里，以便后续操作。还有一点需要注意，LeScanCallback和ScanCallback是两个不同的类，注意不要用混淆了。所有扫描方法都会一定程度影响主线程的流畅性，因此可以考虑把扫描操作放置子线程执行。

连接BLE蓝牙设备

//手机链接蓝牙设备，就需要获取与之相关的GATT链接，首先声明gatt
private BluetoothGatt mBluetoothGatt;
private BluetoothDevice mTargetDevice;//从扫描到的设备列表里选出目标设备。

//mBluetoothGattCallback 为所有蓝牙数据回调的处理者，也是整个蓝牙操作当中最为核心的一部分
private BluetoothGattCallback mBluetoothGattCallback = new BluetoothGattCallback() {
    //BluetoothGattCallback 里面有很多方法，但并非所有都需要在开发当中用到。
    //这里列出来只是作为部分解析，需要哪个方法，就重写哪个方法，不需要的，直接去掉。
    @Override
    public void onConnectionStateChange(BluetoothGatt gatt, int status, int newState) {
        super.onConnectionStateChange(gatt, status, newState);
        //当设备与中心连接状态发生改变时。
    }

    @Override
    public void onServicesDiscovered(BluetoothGatt gatt, int status) {
        super.onServicesDiscovered(gatt, status);
        //当发现设备服务时，会回调到此处。
    }

    @Override
    public void onCharacteristicRead(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {
        super.onCharacteristicRead(gatt, characteristic, status);
        //读取特征后回调到此处。
    }

    @Override
    public void onCharacteristicWrite(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {
        super.onCharacteristicWrite(gatt, characteristic, status);
        //写入特征后回调到此处。
    }

    @Override
    public void onCharacteristicChanged(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic) {
        super.onCharacteristicChanged(gatt, characteristic);
        //当特征（值）发生变法时回调到此处。
    }

    @Override
    public void onDescriptorRead(BluetoothGatt gatt, BluetoothGattDescriptor descriptor, int status) {
        super.onDescriptorRead(gatt, descriptor, status);
        //读取描述符后回调到此处。
    }

    @Override
    public void onDescriptorWrite(BluetoothGatt gatt, BluetoothGattDescriptor descriptor, int status) {
        super.onDescriptorWrite(gatt, descriptor, status);
        //写入描述符后回调到此处
    }

    @Override
    public void onReliableWriteCompleted(BluetoothGatt gatt, int status) {
        super.onReliableWriteCompleted(gatt, status);
        //暂时没有用过。
    }

    @Override
    public void onReadRemoteRssi(BluetoothGatt gatt, int rssi, int status) {
        super.onReadRemoteRssi(gatt, rssi, status);
        //Rssi表示设备与中心的信号强度，发生变化时回调到此处。
    }

    @Override
    public void onMtuChanged(BluetoothGatt gatt, int mtu, int status) {
        super.onMtuChanged(gatt, mtu, status);
        //暂时没有用过。
    }
};

private void openGatt(){
    mBluetoothGatt = mTargetDevice.connectGatt(BluetoothLeService.this, false, mBluetoothGattCallback);
    //通过之前扫描所得设备，打开Gatt链接。
    //连接可能需要等待。
    //第一个参数是传Context，这个很好理解。
    //第二个参数是控制是否自动链接，为true的时候，当设备进入中心范围，会进行自动连接，为false反之。
    //第三个参数就是上面那个GattCallback了。
    //此步骤执行之后，所有结果都会回调到GattCallback当中，接下来我们就需要对其进行操作了。
}

GattCallback有什么作用？

//特征列表集
private List<BluetoothGattCharacteristic > mCharacteristics;

//在connectGatt()这个方法执行完毕后，GattCallback当中便会出现回调结果。
//首先在onConnectionStateChange()这个方法当中会，我们判断设备是否成功连接
@Override
public void onConnectionStateChange(BluetoothGatt gatt, int status, int newState) {
    super.onConnectionStateChange(gatt, status, newState);
    switch (newState) {//newState顾名思义，表示当前最新状态。status可以获取之前的状态。
    case BluetoothProfile.STATE_CONNECTED:
        //这里表示已经成功连接，如果成功连接，我们就会执行discoverServices()方法去发现设备所包含的服务
        onStateConnected(gatt);
        break;
    case BluetoothProfile.STATE_DISCONNECTED:
        //表示gatt连接已经断开。
        onStateDisconnected(gatt);
        break;
    }
}

private void onStateConnected(BluetoothGatt gatt) {
    gatt.discoverServices();
    Log.i("Ble Connection", "Start to discover services.");
}

private void onStateDisconnected(BluetoothGatt gatt) {
    Log.i("Ble Connection", "Connection is broken.");
    gatt.close();
}

//接下来，在执行discoverServices()后，外设就会告诉我们它能够为中心提供哪些服务
@Override
public void onServicesDiscovered(BluetoothGatt gatt, int status) {
    super.onServicesDiscovered(gatt, status);
    if (status == BluetoothGatt.GATT_SUCCESS) {
        //gatt.getServices()可以获得外设的所有服务。
        for (BluetoothGattService service : gatt.getServices()) {//接下来遍历所有服务
            //每发现一个服务，我们再次遍历服务当中所包含的特征，service.getCharacteristics()可以获得当前服务所包含的所有特征
            for (BluetoothGattCharacteristic characteristic : service.getCharacteristics()) {
                mCharacteristics.add(characteristic);//通常可以把所发现的特征放进一个列表当中以便后续操作。
                Log.i("", characteristic.getUuid().toString());//打印特征的UUID。
            }
        }
    }
    //当方法执行完后，我们就获取了设备所有的特征了。
    //如果你想知道每个特征都包含哪些描述符，很简单，再用一个循环去遍历每一个特征的getDescriptor()方法。
}

//当我们执行了readCharacteristic()方法后，结果会回调在此。
@Override
public void onCharacteristicRead(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {
    super.onCharacteristicRead(gatt, characteristic, status);
    if(status == BluetoothGatt.GATT_SUCCESS) {
        //如果程序执行到这里，证明特征的读取已经完成，我们可以在回调当中取出特征的值。
        //特征所包含的值包含在一个byte数组内，我们可以定义一个临时变量来获取。

        byte[] characteristicValueBytes = characteristic.getValue();
        //如果这个特征返回的是一串字符串，那么可以直接获得其值
        String bytesToString = new String(characteristicValueBytes );

        //如果只需要取得其中的几个byte，可以直接指定获取特定的数组位置的byte值.
        //例如协议当中定义了这串数据当中前2个byte表示特定一个数值，那么获取这个值，可以直接写成
        byte[] aValueBytes = new byte[]{ 
            characteristic.getValue()[0], characteristic.getValue()[1]
        }
        Log.i("c-u", "" + Integer.parseInt(UUIDS.bytesToHexString(characteristic.getValue()), 16));
        //至于这个值时表示什么，十进制数值？或是一个字符串？还是翻开协议慢慢找吧。
        //到这里为止，我们已经成功采用读的方式，获得了存在于特征当中的值。
        //characteristic还能为我们提供什么东西呢？属性，权限等是比较常用的。
    }
}

//当我们执行了gatt.setCharacteristicNotification或写入特征的时候，结果会回调在此
@Override
public void onCharacteristicChanged(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic) {
    super.onCharacteristicChanged(gatt, characteristic);
    //当我们决定用通知的方式获取外设特征值的时候，每当特征值发生变化，程序就会回调到此处。
    //在一个gatt链接当中，可以同时存在多个notify的回调，全部值都会回调到这里，那么我们如何区分这些值的来源？
    //这个时候，我们就需要去判断回调回来的特征的UUID，因为UUID是唯一的，所以我们可以用UUID
    //来确定，这些数据来自哪个特征。
    //假设我们已经在BleService当中定了多个我们想要使用的静态UUID，前面已经说过如何表达一个UUID
    //那么我们需要做的就是对比这些UUID，根据不同的UUID来分类这些数据，究竟应该交由哪个方法来处理
    
    //所以，这么一来我们便会发现其实上面的onCharacteristicRead也会出现这种情况，
    //因为我们不可能只读取一个特征，除非这个外设也只有这一个特征，
    //究竟是谁在读取，读取的值来自于哪个特征等，都需要进行判断。
    
    if(mUUID_ONE.equals(characteristic.getUuid())){
        //do something.
    } else if (mUUID_TWO.equals(characteristic.getUuid())){
        //do something.
    }
    //我们会有更好的写法，我们应该抽象这些方法，这样一来我们可能会减少很多代码量。
}

/*从onCharacteristicChanged当中我们发现了一个问题，就是无论什么时候，我们都需要去判断一个回调特征
从哪里来到哪里去，因此我们应该采用一种方法来统一这种读取的操作*/
private void updateCharacteristic(BluetoothGattCharacteristic characteristic) {
    //在onCharacteristicChanged和onCharacteristicRead方法中直接把characteristic交给updateCharacteristic处理。
    //这样一来，程序可读性就会更加好了，思路也会更加清晰。
    //这里处理所有的特征取值
    if(mUUID_ONE.equals(characteristic.getUuid())){
        handlerCharacteristic_One();
    } else if (mUUID_TWO.equals(characteristic.getUuid())){
        handlerCharacteristic_Two();
    }
}

private void handlerCharacteristic_One(){
    //相应解析方案
}

private void handlerCharacteristic_Two(){
    //相应解析方案

}

/*在官方的写法中，采用了Broadcast的方式来让Service向其他组件发送蓝牙回调数据，
  这么做当然是可以的，但是如果一个蓝牙设备包含了很多个服务而且服务当中存在大量
  Notify方式读取的数据，那么Service收到这些数据后，又用Broadcast的方式广播数据，
  系统中就会存在大量广播而导致app性能下降，如何解决这种问题，我们可以使用回调
  的方式的方式来触发外部activity或fragment等组件取得数据更新UI或其他操作，例如我们
  可以这么写：
*/

/*我们先定义一个回调接口，让外部Activity或Fragment实现，又或直接新建一个类实现。
  我们在Activity绑定Service后获得Binder对象时，把实现了ICallback的回调接口类通过
  setter方式传入到Service当中作为Service的成员变量，例如可在Service的内部Binder类
  写一个方法setFragments或setActivities之类的。至于回调的工作方式，这里不做详尽介绍了。
*/
public interface ICallback {
    //这就是我们定义的接口，让需要获得characteristic更新数据的外部组件实现回调接口。
    void updateCharacteristic(BluetoothGattCharacteristic characteristic);
}

//在Service的GattCallback对象中，加入一个方法，如下：
public void onCharacteristicChanged(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic) {
    super.onCharacteristicChanged(gatt, characteristic);
    updateCharacteristic('这里传入实现了ICallback接口的对象', characteristic);
}

private void updateCharacteristic(ICallback callback, BluetoothGattCharacteristic characteristic) {
    callback.updateCharacteristic(characteristic);
}

//在外部activity或fragment等组件当中收到回调
@Override
public void updateCharacteristic(final BluetoothGattCharacteristic characteristic) {
    /*这里已经回到Activity或Fragement了，我们可以获取characteristic进行我们想要的任何操作了，
      但这里需要注意的是，回调执行的线程可能并非UI线程或不是对该Activity或Fragement当中的
      view拥有操作权，可能会异常，我们需要使用activity或fragment当中的handler对象来处理*/
    mHandler.post(new Runable(){
        @Override
        public void run(){
            //在这里我们就可以放心执行UI更新，例如对characteristic进行getValue之类的。
        }
    });
}

/*采用回调的方式可以更加高效快捷地处理蓝牙发送过来的数据，让系统中少了一大堆广播，逻辑也更加
  清晰了。另外也可以通过观察者模式来实现Service与外部组件交换数据，让Serviec作为一个可以被订阅
  的对象（或拥有一个可被订阅的对象），让想获得特征更新的外部组件成为订阅者，这么做也是可以的，
  但依然需要注意线程和使用handler机制。*/

上面介绍了最常用的2种获取外设特征值的回调函数，read方式与notify方式，一个相当于主动获取，一个相当于被动接收。上文中还列出来GattCallback的其他回调函数，根据实际需要自行添加即可（有时间会逐一补全）。

下面介绍如何进行对特征的读写操作， 要进行特征读写，首先需要知道该特征是否可以读，或是否可写。

//判断特征可读
private boolean ifCharacteristicReadable(BluetoothGattCharacteristic characteristic){
    return ((characteristic.getProperties() & BluetoothGattCharacteristic.PROPERTY_READ) > 0);
}

//判断特征可写
private boolean ifCharacteristicWritable(BluetoothGattCharacteristic characteristic){
    return ((characteristic.getProperties() & BluetoothGattCharacteristic.PROPERTY_WRITE) > 0 ||
            (characteristic.getProperties() & BluetoothGattCharacteristic.PROPERTY_WRITE_NO_RESPONSE) > 0));
}

//判断特征是否具备通知属性
private boolean ifCharacteristicNotifiable (BluetoothGattCharacteristic characteristic){
    return ((characteristic.getProperties() & BluetoothGattCharacteristic.PROPERTY_NOTIFY) > 0 || 
            (characteristic.getProperties() & BluetoothGattCharacteristic.PROPERTY_INDICATE) > 0));
}

//当然，这只是在不知道此特征的读写性的情况下，才需要做判断，一般来说，协议中会明确指出特征的读写性，
//如果万一真的忘记写，我们也可以自己判断。

在知道了各个特征的读写性后，我们终于可以进行读写交互的动作了。

//读取特征，相当简单，一句话带过，读取结果会回调到mGattCallback中的onCharacteristicRead。
private void readCharacteristic(BluetoothGattCharacteristic characteristic){
    mBluetoothGatt.readCharacteristic(characteristic);
}

//写入特征，也相当简单，一句话带过，读取结果会回调到mGattCallback中的onCharacteristicWrite
private void readCharacteristic(BluetoothGattCharacteristic characteristic){
    characteristic.setValue(?);//参数可以是byte数组，字符串等。
    mBluetoothGatt.writeCharacteristic(characteristic);
}

//设置通知，读取结果会回调到mGattCallback中的onCharacteristicChanged
private void setCharacteristicNotification(BluetoothGattCharacteristic characteristic, boolean enable){
    mBluetoothGatt.setCharacteristicNotification(characteristic, enable);
    //以下的几句代码有人问可不可省略，这里建议写上。
    //在明确知道当前特征的描述符前提下，可以直接使用描述符，不需要做判断，
    //但如果不知道此特征是否具有描述符的情况下，没有以下几行代码可能会导致设置通知失败的情况发生。
    List<BluetoothGattDescriptor> descriptorList = characteristic.getDescriptors();
    if (descriptorList != null) {
        for (BluetoothGattDescriptor descriptor : descriptorList) {
            byte[] value = enable ? BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE : BluetoothGattDescriptor.DISABLE_NOTIFICATION_VALUE;
            descriptor.setValue(value);
            mBluetoothGatt.writeDescriptor(descriptor);
        }
    }
}

到这里为止，基本上BLE的扫描，连接，读写都做了一番简单介绍了，这里提几点要点

• 第一：蓝牙的通信不能进行无间隔读写发送操作，如何理解？比如我要连续设置2个CharacteristicNotification为true，当代码这么写的时候：

//
private void method(){
    setCharacteristicNotification(characteristicOne, true);
    setCharacteristicNotification(characteristicTwo, true);
}

生效的只有characteristicTwo。那么如何解决这种问题？我们可以使用Hanlder的机制，采用PostDeley一个一个设置，也可以在onCharateristicNotify，onCharateristicRead等等Gatt回调后在回掉函数中用handler发message，再在handler中处理（可以把这些任务抽象成Runnable或Callable，在Gatt收到回调后再用handler的post方法执行下一个任务，可以考虑把Runnable或Callable放在Queue中，经实际应用后，个人比较推荐后者，就是在Gatt中收到回调后再执行下一个蓝牙写操作，而不是通过handler的PostDeley），么一来，我们就有充分时间让上一个设置生效后，我们再执行下一个设置。

• 第二：鉴于一台手机设备当中，对Gatt连接的资源做了限制的设定，一定要注意当程序不需要用到连接的时候，就需要关闭gatt的连接，让系统进行资源回收。

//断开连接
private void closeGatt(){
    if(mBluetoothGatt != null){
        mBluetoothGatt .disconnect();
    }
}

在GattCallBack的onConnectionStateChange当中，关闭连接

......
case BluetoothProfile.STATE_DISCONNECTED:
    mBluetoothGatt.close();
    mBluetoothGatt = null;
    break;

• 第三：蓝牙的相关操作，就以个人使用经历来说，还是放在子线程中执行比较稳妥，尤其是扫描，当然，蓝牙的读写，链接放在UI线程并无不妥。本人目前并没有阅读过BLE API的源码，不知道内部是如何处理线程的，但为保证UI线程的顺畅，最好还是把蓝牙操作放到子线程中执行。如日后有时间阅读BLE API的源码后确认再更新此说法。

好了到这里为止，我们的BleService服务基本完工，但这只是一个非常简洁的介绍，实际开发当中一定还会存在各种问题，希望大家可以开发顺利。

2017-1-11 15：30
2017-3-10 09：54 更新