iot_connect

iot_connect 组件调用 ble 接口的相关代码位于iot_connect/adapter/ble 目录下，ohos_lite 目录下为小系统，ohos_standard目录下为标准设备。
ble对接芯片适配层标准设备可以参考社区Rk3568的实现，小设备可以参考统一互联ws63的实现。

ws63适配示例：https://gitcode.com/ohos-oneconnect/communication_nearlink/tree/master/openharmony/device/soc/hisilicon/hi3863v100/hi3863_adapter/hals/communication/bluetooth/services

接口列表

需要实现的接口参考OpenHarmony bluetooth 仓foundation/communication/bluetooth/interfaces/inner_api/include/c_header目录下相关头文件。

下文中列出必须实现的接口，下列方法的返回值，规定 0 为成功，如果厂商协议栈规定非0为成功，需要自行转化。

InitBtStack

初始化蓝牙协议栈。可空实现

int InitBtStack(void) {
    // 调用蓝牙协议栈接口
    return OHOS_BT_STATUS_SUCCESS;
}

EnableBtStack

启用蓝牙协议栈。可空实现

int EnableBtStack(void) {
    // 调用蓝牙协议栈接口
    int ret = disable_ble();
    if (ret == SUCCESS) {
        return OHOS_BT_STATUS_SUCCESS;
    }
    return OHOS_BT_STATUS_FAIL;
}

DisableBtStack

禁用蓝牙协议栈。可空实现

int DisableBtStack(void) {
    // 调用蓝牙协议栈接口
    int ret = disable_ble();
    if (ret == SUCCESS) {
        return OHOS_BT_STATUS_SUCCESS;
    }
    return OHOS_BT_STATUS_FAIL;
}

SetDeviceName/SetLocalName

设置蓝牙设备名称

// 标准设备实现
bool SetLocalName(unsigned char *localName, unsigned char length) {
    // 调用蓝牙协议栈接口
    int ret = gap_ble_set_local_name(name, len);
    if (ret == SUCCESS) {
        return OHOS_BT_STATUS_SUCCESS;
    }
    return OHOS_BT_STATUS_FAIL;
}

// 小设备实现
int SetDeviceName(const char *name, unsigned int len) {
    // 调用蓝牙协议栈接口
    int ret = gap_ble_set_local_name(name, len);
    if (ret == SUCCESS) {
        return OHOS_BT_STATUS_SUCCESS;
    }
    return OHOS_BT_STATUS_FAIL;
}

ReadBtMacAddr

获取设备MAC地址。

int ReadBtMacAddr(unsigned char *mac, unsigned int len) {
    // 调用蓝牙协议栈接口
    int ret = gap_ble_get_local_addr(&mac);
    if (ret == SUCCESS) {
        return OHOS_BT_STATUS_SUCCESS;
    }
    return OHOS_BT_STATUS_FAIL;
}

BleStartAdvEx

设置广播数据开始广播
StartAdvRawData和BleAdvParams结构体参考ohos_bt_gatt.h 头文件中的定义

• 文件路径：foundation/communication/bluetooth/interfaces/inner_api/include/c_header/ohos_bt_gatt.h

int BleStartAdvEx(int *advId, const StartAdvRawData rawData, BleAdvParams advParam) {
    *advId = BLE_ADV_HANDLE_DEFAULT;
    // BleAdvParams 参数 转化为芯片 ble_adv_params结构体
    int ret = gap_ble_set_adv_param(advId, &advParams);
    if (ret != SUCCESS) {
        return OHOS_BT_STATUS_FAIL;
    }
    // StartAdvRawData 参数 转化为芯片 ble_config_adv_data结构体
    ret = gap_ble_set_adv_data(advId, &advData);
    if (ret == SUCCESS) {
        return OHOS_BT_STATUS_SUCCESS;
    }
    return OHOS_BT_STATUS_FAIL;
}

BleStopAdv

停止广播

int BleStopAdv(int advId)
{   int ret = gap_ble_stop_adv(advId);
    if (ret == SUCCESS) {
        return OHOS_BT_STATUS_SUCCESS;
    }
    return OHOS_BT_STATUS_FAIL;
}

BleGattsSetEncryption

设置GATT连接的加密类型。标准系统可不实现

int BleGattsSetEncryption(BdAddr bdAddr, BleSecAct secAct) {
    gap_ble_sec_params_t sec_params = {0};
    sec_params.bondable = 1;
    sec_params.io_capability = g_io_cap_mode;
    sec_params.sc_enable = 1;
    sec_params.sc_mode = secAct;
    // 调用蓝牙协议栈接口
    int ret = gap_ble_set_sec_param(&sec_params);
    if (ret == SUCCESS) {
        return OHOS_BT_STATUS_SUCCESS;
    }
    return OHOS_BT_STATUS_FAIL;
}

BleGattSecurityRsp

GATT 安全响应。可空实现

int BleGattSecurityRsp(BdAddr bdAddr, bool accept) {
    return OHOS_BT_STATUS_SUCCESS;
}

BleGattsRegisterCallbacks

注册 GATT server callbacks.
BtGattServerCallbacks结构体位于ohos_bt_gatt_server.h头文件

• 文件路径：foundation/communication/bluetooth/interfaces/inner_api/include/c_header/ohos_bt_gatt_server.h

// 小系统需实现
static BtGattServerCallbacks g_bleGattsCb = {
    .registerServerCb = RegisterServerCb,
    .connectServerCb = ConnectServerCb,
    .disconnectServerCb = DisconnectServerCb,
    .serviceStartCb = ServiceStartCb,
    .serviceStopCb = ServiceStopCb,
    .indicationSentCb = IndicationSendCb,
    .mtuChangeCb = MtuChangeCb,
};

// 标准系统需实现
static BtGattServerCallbacks g_bleGattsCb = {
    .registerServerCb = RegisterServerCb,
    .serviceAddCb = ServiceAddCb,
    .characteristicAddCb = CharacteristicAddCb,
    .descriptorAddCb = DescriptorAddCb,
    .connectServerCb = ConnectServerCb,
    .disconnectServerCb = DisconnectServerCb,
    .serviceStartCb = ServiceStartCb,
    .serviceStopCb = ServiceStopCb,
    .indicationSentCb = IndicationSendCb,
    .mtuChangeCb = MtuChangeCb,
    .requestReadCb = RequestReadCb,
    .requestWriteCb = RequestWriteCb,
};

static gatts_callbacks_t g_gattCallback = {
    .add_service_cb          = add_service_callback,
    .add_characteristic_cb   = add_characteristic_callback,
    .add_descriptor_cb       = add_descriptor_callback,
    .start_service_cb        = start_service_callback,
    .stop_service_cb         = stop_service_callback,
    .delete_service_cb       = delete_service_callback,
    .read_request_cb         = read_request_callback,
    .write_request_cb        = write_request_callback,
    .mtu_changed_cb          = mtu_changed_callback,
};

BtGattServerCallbacks *g_bleGattsCb = NULL;

static void add_service_callback(uint8_t server_id, bt_uuid_t *uuid, uint16_t handle, errcode_t status)
{
    uint8_t swapUuid[2];
    BtUuid bt_uuid = {uuid->uuid_len, uuid->uuid};
    if (uuid->uuid_len == 2) {
        swapUuid[1] = uuid->uuid[0];
        swapUuid[0] = uuid->uuid[1];
        bt_uuid.uuid = swapUuid;
    }
    if (g_bleGattsCb->serviceAddCb) {
        g_bleGattsCb->serviceAddCb(status, server_id, &bt_uuid, handle);
    }
}

int BleGattsRegisterCallbacks(BtGattServerCallbacks *func)
{   
    if (func == NULL) {
        return OHOS_BT_STATUS_FAIL;
    }
    // 适配层缓存Callbacks
    g_bleGattsCb = func;
    // 调用蓝牙协议栈接口
    int ret = gatts_register_callbacks(&g_gattCallback);
    if (ret == SUCCESS) {
        return OHOS_BT_STATUS_SUCCESS;
    }
    return OHOS_BT_STATUS_FAIL;
}

BleGattRegisterCallbacks

注册 GATT callbacks.
BleGattRegisterCallbacks结构体位于ohos_bt_gatt.h头文件

• 文件路径：foundation/communication/bluetooth/interfaces/inner_api/include/c_header/ohos_bt_gatt.h

  BtGattCallbacks 结构体中其他接口可选择性实现
  static BtGattCallbacks g_bleGattCb = {
    .advEnableCb = AdvStartCompleteCb,
    .advDisableCb = AdvStopCompleteCb,
    .securityRespondCb = SecurityRespondCb,
  };
  

BtGattCallbacks *g_bleGapCb = NULL;

gap_ble_callbacks_t g_gapCallback = {
    .set_adv_data_cb        = set_adv_data_callback,
    .start_adv_cb           = start_adv_callback,
    .stop_adv_cb            = stop_adv_callback,
    .conn_state_change_cb   = conn_state_change_callback,
};

void start_adv_callback(uint8_t adv_id, adv_status_t status)
{
    g_bleGapCb->advEnableCb(adv_id, status);
}

void stop_adv_callback(uint8_t adv_id, adv_status_t status)
{
    g_bleGapCb->advDisableCb(adv_id, status);
}

void conn_state_change_callback(uint16_t conn_id, bd_addr_t *addr,
    gap_ble_conn_state_t conn_state, gap_ble_pair_state_t pair_state, gap_ble_disc_reason_t disc_reason)
{
    if (conn_state == GAP_BLE_STATE_CONNECTED) {
        if (g_bleGattsCb->connectServerCb) {
            g_bleGattsCb->connectServerCb(conn_id, g_server_id, &bd_addr);
        }
    } else if (conn_state == GAP_BLE_STATE_DISCONNECTED) {
        if (g_bleGattsCb->disconnectServerCb) {
            g_bleGattsCb->disconnectServerCb(conn_id, g_server_id, &bd_addr);
        }
    }
}

int BleGattRegisterCallbacks(BtGattCallbacks *func)
{
    if (func == NULL) {
       return OHOS_BT_STATUS_FAIL;
    }
    g_bleGapCb = func;
    // 调用蓝牙协议栈接口
    int ret = gap_ble_register_callbacks(&g_gattCallback);
    if (ret == SUCCESS) {
        return OHOS_BT_STATUS_SUCCESS;
    }
    return OHOS_BT_STATUS_FAIL;
}

BleGattsDeleteService

删除 gatt 服务

int BleGattsDeleteService(int serverId, int srvcHandle) {
    // 调用蓝牙协议栈接口
    int ret = gatts_delete_services(serverId);
    if (ret == SUCCESS) {
        return OHOS_BT_STATUS_SUCCESS;
    }
    return OHOS_BT_STATUS_FAIL;
}

BleGattsSendIndication

向客户端发送通知

int BleGattsSendIndication(int serverId, GattsSendIndParam *param)
{
    gatts_ntf_ind_t ntfParam = {0};
    ntfParam.attr_handle   = param->attrHandle;
    ntfParam.value_len     = param->valueLen;
    ntfParam.value         = (uint8_t *)param->value;
    // 调用蓝牙协议栈接口
    int ret = gatts_notify_indicate(serverId, param->connectId, &ntfParam);
    if (g_bleGattsCb->indicationSentCb) {
        g_bleGattsCb->indicationSentCb(param->connectId, ret);
    }
    if (ret == SUCCESS) {
        return OHOS_BT_STATUS_SUCCESS;
    }
    return OHOS_BT_STATUS_FAIL;
}

BleGattsSendResponse

向收到读取或写入请求的客户端发送响应。该方法小系统可不实现

int BleGattsSendResponse(int serverId, GattsSendRspParam *param)
{   
    gatts_send_rsp_t rspParam = {0};
    rspParam.request_id = g_serverRequestId;
    rspParam.status = 0;
    rspParam.offset = 0;
    rspParam.value_len = param->valueLen;
    rspParam.value = (uint8_t *)param->value;
    // 调用蓝牙协议栈接口
    int ret = gatts_send_response(serverId, param->connectId, &rspParam);
    if (ret == SUCCESS) {
        return OHOS_BT_STATUS_SUCCESS;
    }
    return OHOS_BT_STATUS_FAIL;
}

BleGattsRegister

注册GATT服务。该方法小系统可不实现

int BleGattsRegister(BtUuid appUuid) {

}

BleGattsUnRegister

注销GATT服务

int BleGattsUnRegister(int serverId)
{   
    // 调用蓝牙协议栈接口
    int ret = gatts_unregister_server(serverId);
    if (ret == SUCCESS) {
        return OHOS_BT_STATUS_SUCCESS;
    }
    return OHOS_BT_STATUS_FAIL;
}

BleGattsDisconnect

断开GATT服务器与客户端的连接

int BleGattsDisconnect(int serverId, BdAddr bdAddr, int connId)
{
    bd_addr_t bd_addr = { 0 };
    bd_addr.type = BT_ADDRESS_TYPE_PUBLIC_DEVICE_ADDRESS;
    memcpy_s(bd_addr.addr, BD_ADDR_LEN, bdAddr.addr, BD_ADDR_LEN);
    // 调用蓝牙协议栈接口
    int ret = gap_ble_disconnect_remote_device(&bd_addr);
    if (ret == SUCCESS) {
        return OHOS_BT_STATUS_SUCCESS;
    }
    return OHOS_BT_STATUS_FAIL;
}