之前公司有个业务用到BLE蓝牙，记录总结一下，详细的可参考：
Android BLE学习笔记：http://www.jianshu.com/p/7d814c22a085

• 首先确定BLE支不支持，有没打开：

   //是否支持
  public static boolean isSupportBle(Context context) {
        if (context == null || !context.getPackageManager().hasSystemFeature(PackageManager.FEATURE_BLUETOOTH_LE)) {
            return false;
        }
        BluetoothManager manager = (BluetoothManager) context.getSystemService(Context.BLUETOOTH_SERVICE);
        return manager.getAdapter() != null;
  }
  //是否开启
  public static boolean isBleEnable(Context context) {
        if (!isSupportBle(context)) {
            return false;
        }
        BluetoothManager manager = (BluetoothManager) context.getSystemService(Context.BLUETOOTH_SERVICE);
        return manager.getAdapter().isEnabled();
  }
  //开启蓝牙
  public static void enableBluetooth(Activity activity, int requestCode) {
        Intent intent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
        activity.startActivityForResult(intent, requestCode);
  }
  

• 确认支持且开启，扫描：

  BluetoothManager bluetoothManager = (BluetoothManager) getSystemService(Context.BLUETOOTH_SERVICE); 
  BluetoothAdapter bluetoothAdapter = bluetoothManager.getAdapter();
  bluetoothAdapter.startLeScan(new BluetoothAdapter.LeScanCallback() { 
        @Override 
        public void onLeScan(BluetoothDevice device, int rssi, byte[] scanRecord) { 
      //对扫描到的设备进行处理，可以依据BluetoothDevice中的信息、信号强度rssi以及广播包和响应包组成的scanRecord字节数组进行分析 
        }
  });
  

• 扫描后连接：

  BluetoothGatt bluetoothGatt = device.connectGatt(mContext, true, mBluetoothGattCallback);
  BluetoothGattCallback mBluetoothGattCallback = new 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);
        //连接回调，status为0时连接成功
    }
  
    @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);
    }
  
    @Override
    public void onMtuChanged(BluetoothGatt gatt, int mtu, int status) {
        super.onMtuChanged(gatt, mtu, status);
    }
  };
  

• 连接成功后，通过BluetoothGatt拿到服务，这里服务需要通过UUID获取，而UUID是你连接的设备提供的，UUID有可读、可写、可通知、指示器四种，设置通知会在在上面的onDescriptorWrite回调：

   UUID uuid = UUID.fromString("xxxxxx-xxxx-xx-x-x-x-xx-x");
   BluetoothGattService service = gatt.getService(uuid);
   mWriteCharacteristic = service.getCharacteristic(UUID.fromString("xxxxxx-xxxx-xx-x-x-x-xx-x"));
   mNotifyCharacteristic = service.getCharacteristic(UUID.fromString("xxxxxx-xxxx-xx-x-x-x-xx-x"));
   gatt.setCharacteristicNotification(mNotifyCharacteristic, true);
   BluetoothGattDescriptor descriptor   //UUID固定的
                = mNotifyCharacteristic.getDescriptor(UUID.fromString("00002902-0000-1000-8000-00805f9b34fb"));
   if (descriptor != null) {
        //判断是否可指示
        if ((mNotifyCharacteristic.getProperties() & BluetoothGattCharacteristic.PROPERTY_NOTIFY) > 0) {
              descriptor.setValue(BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE);
        } else if ((mNotifyCharacteristic.getProperties() & BluetoothGattCharacteristic.PROPERTY_INDICATE) > 0) {
              descriptor.setValue(BluetoothGattDescriptor.ENABLE_INDICATION_VALUE);
        }
   }
   gatt.writeDescriptor(descriptor);
  

• 发送数据，由于数据不能超过20字节，所以超过20字节要分包处理：

  private Queue<byte[]> dataInfoQueue = new LinkedList<>();
  
  private void send(byte[] data) {
    if (dataInfoQueue != null) {
        dataInfoQueue.clear();
        dataInfoQueue = splitPacketFor20Byte(data);
        handler.post(runnable);
    }
  }
  
  private Queue<byte[]> splitPacketFor20Byte(byte[] data) {
    Queue<byte[]> dataInfoQueue = new LinkedList<>();
    if (data != null) {
        int index = 0;
        do {
            byte[] surplusData = new byte[data.length - index];
            byte[] currentData;
            System.arraycopy(data, index, surplusData, 0, data.length - index);
            if (surplusData.length <= 20) {
                currentData = new byte[surplusData.length];
                System.arraycopy(surplusData, 0, currentData, 0, surplusData.length);
                index += surplusData.length;
            } else {
                currentData = new byte[20];
                System.arraycopy(data, index, currentData, 0, 20);
                index += 20;
            }
            dataInfoQueue.offer(currentData);
        } while (index < data.length);
    }
    return dataInfoQueue;
  }
  //发送
   if (dataInfoQueue.peek() != null) {
       mWriteCharacteristic.setValue(dataInfoQueue.poll());    
   }
  

• 可能大家都会觉得，连接的回调接口那么多，虽然可以选择重写，但是发送数据new一个新的，设置通知服务new一个新的，这就很不爽，有没有体现接口隔离原则封装好的，当然有，具体用法不记录了，作者写很详细：
  Android BLE基础框架使用详解 http://www.jianshu.com/p/79df59537686