本文只讲述实际开发中的最基本的概念、用法及代码，不过多深入概念及源码。

什么是周边设备

• BLE（蓝牙4.0+） 有两种状态模式：中心（center）及peripheral（周边）。
• 大多数中心设备的扮演者是手机、电脑等能主动去连接别人的设备，而大多数周边设备就等着这些中心设备连接，如手环、血糖仪等。
• Android从 Lolipop 开始支持了BLE Peripheral（周边设备）开发。
• 如果你希望使Android设备开启为周边设备模式，请往下看。

配置

在 AndroidManifest.xml 中 添加以下权限：

    <uses-permission android:name="android.permission.BLUETOOTH" />
    <uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />
    <!-- 6.0之后蓝牙还需要地理位置权限 -->
    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />

    <!-- 只扫描ble设备 -->
    <uses-feature
        android:name="android.hardware.bluetooth_le"
        android:required="true" />

开启蓝牙

// 是否支持ble
if (!mContext.getPackageManager().hasSystemFeature(PackageManager.FEATURE_BLUETOOTH_LE)) {
    Toast.makeText(mContext, "hasSystemFeature == false", Toast.LENGTH_SHORT).show();
    return false;
}
// 是否能获取到蓝牙服务
mBluetoothManager = (BluetoothManager) mContext.getSystemService(Context.BLUETOOTH_SERVICE);
if (mBluetoothManager == null) {
    Toast.makeText(mContext, "mBluetoothManager == null", Toast.LENGTH_LONG).show();
    return false;
}
// 获取蓝牙适配器
mBluetoothAdapter = mBluetoothManager.getAdapter();
if (mBluetoothAdapter == null) {
    Toast.makeText(mContext, "BluetoothAdapter == null", Toast.LENGTH_LONG).show();
    return false;
}
// 蓝牙是否打开
if (!mBluetoothAdapter.isEnabled()) {
    Toast.makeText(mContext, "BluetoothAdapter.isEnabled == false", Toast.LENGTH_LONG).show();
    return false;
}
// 获取广播者
mBluetoothLeAdvertiser = mBluetoothAdapter.getBluetoothLeAdvertiser();
    if (mBluetoothLeAdvertiser == null) {
    Toast.makeText(mContext, "BluetoothLeAdvertiser == null ", Toast.LENGTH_LONG).show();
    return false;
}

到这里如果 mBluetoothLeAdvertiser 为空，请换设备再继续（国内部分机型不支持）

建立服务

// 给个风骚的广播名称，默认是手机设置里蓝牙的名称
mBluetoothAdapter.setName("Bleoo");
// 这个Callback 是设备广播成功后所有状态的回调，包括读写等
mGattServerCallback = new PeriServerCallBack();
// 打开GattServer
mGattServer = mBluetoothManager.openGattServer(mContext, mGattServerCallback);
// 创建一个特征通道用来写
mWriteCharacter = new BluetoothGattCharacteristic(
        UUID.fromString(Constants.CHARACTERISTIC_WRITEABLE),
        BluetoothGattCharacteristic.PROPERTY_WRITE | BluetoothGattCharacteristic.PROPERTY_READ,
        BluetoothGattCharacteristic.PERMISSION_WRITE | BluetoothGattCharacteristic.PERMISSION_READ);
// 创建一个特征通道用来读
mReadCharacter = new BluetoothGattCharacteristic(
        UUID.fromString(Constants.CHARACTERISTIC_READABLE),
        BluetoothGattCharacteristic.PROPERTY_WRITE | BluetoothGattCharacteristic.PROPERTY_READ,
        BluetoothGattCharacteristic.PERMISSION_WRITE | BluetoothGattCharacteristic.PERMISSION_READ);
// 创建一个Gatt服务
mGattService = new BluetoothGattService(
        UUID.fromString(Constants.GATT_SERVICE_PRIMARY),
        BluetoothGattService.SERVICE_TYPE_PRIMARY);
// 添加读写通道
mGattService.addCharacteristic(mWriteCharacter);
mGattService.addCharacteristic(mReadCharacter);
// 添加服务
if (mGattServer != null && mGattService != null)
    mGattServer.addService(mGattService);

开启广播

成功开启广播后，中心设备能够扫描到你的设备，当然前提是中心设备支持ble设备，并且在扫描ble设备。
中心设备能获取到你ble设备的所有信息，包括 GattService 及其 BluetoothGattCharacteristic。

public void startAdvertising() {
    // 这里的Callback是是否开启成功的回调
    mBluetoothLeAdvertiser.startAdvertising(createAdvSettings(true, 0), createAdvertiseData(), mAdvCallback);
}
private AdvertiseSettings createAdvSettings(boolean connectable, int timeoutMillis) {
    AdvertiseSettings.Builder builder = new AdvertiseSettings.Builder();
    //设置广播的模式,跟功耗相关
    builder.setAdvertiseMode(AdvertiseSettings.ADVERTISE_MODE_BALANCED);
    builder.setTxPowerLevel(AdvertiseSettings.ADVERTISE_TX_POWER_HIGH);
    builder.setConnectable(connectable);
    builder.setTimeout(timeoutMillis);
    return builder.build();
}
//设置广播数据（可以携带广播数据，这里没有携带）
private AdvertiseData createAdvertiseData() {
    AdvertiseData.Builder builder = new AdvertiseData.Builder();
    builder.setIncludeDeviceName(true);
    return builder.build();
}

广播回调

    //发送广播的回调
    private AdvertiseCallback mAdvCallback = new AdvertiseCallback() {
        public void onStartSuccess(AdvertiseSettings settingsInEffect) {
            mOnCallBackListener.advertisingStatus(true);
            if (settingsInEffect != null) {
                LogUtil.e("onStartSuccess TxPowerLv=" + settingsInEffect.getTxPowerLevel()
                        + " mode=" + settingsInEffect.getMode() + " timeout=" + settingsInEffect.getTimeout());
            } else {
                LogUtil.e("onStartSuccess, settingInEffect is null");
            }
        }

        public void onStartFailure(int errorCode) {
            mOnCallBackListener.advertisingStatus(false);
            LogUtil.e("onStartFailure errorCode=" + errorCode);
        }
    };

Gatt服务回调

private class PeriServerCallBack extends BluetoothGattServerCallback {

    //当添加一个GattService成功后会回调改接口。
    @Override
    public void onServiceAdded(int status, BluetoothGattService service) {
        if (status == BluetoothGatt.GATT_SUCCESS) {
            LogUtil.e("onServiceAdded status=GATT_SUCCESS service=" + service.getUuid().toString());
        } else {
            LogUtil.e("onServiceAdded status!=GATT_SUCCESS");
        }
    }
    
    //BLE连接状态改变后回调的接口
    @Override
    public void onConnectionStateChange(android.bluetooth.BluetoothDevice device, int status, int newState) {
        mClientDevice = device;
        LogUtil.e("BLE连接状态改变 status=" + status + "->" + newState + " ==== Address: " + device.getAddress());
    }
    
    //当有客户端来读数据时回调的接口
    @Override
    public void onCharacteristicReadRequest(android.bluetooth.BluetoothDevice device,
                int requestId, int offset, BluetoothGattCharacteristic characteristic) {
        mClientDevice = device;
        LogUtil.e("客户端读数据 requestId=" + requestId + " offset=" + offset);
        mGattServer.sendResponse(device, requestId, BluetoothGatt.GATT_SUCCESS, offset, characteristic.getValue());
    }
    
    //当有客户端来写数据时回调的接口
    @Override
    public void onCharacteristicWriteRequest(android.bluetooth.BluetoothDevice device, int requestId,
                BluetoothGattCharacteristic characteristic, boolean preparedWrite,
                boolean responseNeeded, int offset, byte[] value) {
        mClientDevice = device;
        try {
            String msg = new String(value, "UTF-8");
            mOnCallBackListener.writeRequest(msg);
            LogUtil.e("客户端写数据 + message= " + msg + " requestId= " + requestId + " offset= " + offset);
            } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        // 必须sendResponse用于响应（具体原因也不清楚，似乎是为了保持连接）
        mGattServer.sendResponse(device, requestId, BluetoothGatt.GATT_SUCCESS, offset, null);
    }
    //当有客户端来写Descriptor时回调的接口
    @Override
    public void onDescriptorWriteRequest(BluetoothDevice device, int requestId, BluetoothGattDescriptor descriptor,
                boolean preparedWrite, boolean responseNeeded, int offset, byte[] value) {
        mClientDevice = device;
        LogUtil.e("onDescriptorWriteRequest === ");
        // now tell the connected device that this was all successfull
        mGattServer.sendResponse(device, requestId, BluetoothGatt.GATT_SUCCESS, offset, value);
    }
}

写出数据

与中心设备的写出方法不同，周边设备通过 notifyCharacteristicChanged 方法，类似通知的方法写出数据。
当然，sendResponse 也能用于返回数据。

    public boolean write(byte[] value) {
        if (mWriteCharacter == null)
            return false;
        if (mGattServer == null)
            return false;
        mWriteCharacter.setValue(value);
        return mGattServer.notifyCharacteristicChanged(mClientDevice, mWriteCharacter, false);
    }