| /****************************************************************************** |
| * |
| * Copyright 1999-2012 Broadcom Corporation |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at: |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| ******************************************************************************/ |
| #ifndef GATT_API_H |
| #define GATT_API_H |
| |
| #include <base/strings/stringprintf.h> |
| |
| #include <cstdint> |
| #include <string> |
| |
| #include "bt_target.h" |
| #include "btm_ble_api.h" |
| #include "gattdefs.h" |
| #include "types/bluetooth/uuid.h" |
| #include "types/bt_transport.h" |
| #include "types/raw_address.h" |
| |
| /***************************************************************************** |
| * Constants |
| ****************************************************************************/ |
| /* Success code and error codes */ |
| typedef enum GattStatus : uint8_t { |
| GATT_SUCCESS = 0x00, |
| GATT_INVALID_HANDLE = 0x01, |
| GATT_READ_NOT_PERMIT = 0x02, |
| GATT_WRITE_NOT_PERMIT = 0x03, |
| GATT_INVALID_PDU = 0x04, |
| GATT_INSUF_AUTHENTICATION = 0x05, |
| GATT_REQ_NOT_SUPPORTED = 0x06, |
| GATT_INVALID_OFFSET = 0x07, |
| GATT_INSUF_AUTHORIZATION = 0x08, |
| GATT_PREPARE_Q_FULL = 0x09, |
| GATT_NOT_FOUND = 0x0a, |
| GATT_NOT_LONG = 0x0b, |
| GATT_INSUF_KEY_SIZE = 0x0c, |
| GATT_INVALID_ATTR_LEN = 0x0d, |
| GATT_ERR_UNLIKELY = 0x0e, |
| GATT_INSUF_ENCRYPTION = 0x0f, |
| GATT_UNSUPPORT_GRP_TYPE = 0x10, |
| GATT_INSUF_RESOURCE = 0x11, |
| GATT_DATABASE_OUT_OF_SYNC = 0x12, |
| GATT_VALUE_NOT_ALLOWED = 0x13, |
| GATT_ILLEGAL_PARAMETER = 0x87, |
| GATT_TOO_SHORT = 0x7f, |
| GATT_NO_RESOURCES = 0x80, |
| GATT_INTERNAL_ERROR = 0x81, |
| GATT_WRONG_STATE = 0x82, |
| GATT_DB_FULL = 0x83, |
| GATT_BUSY = 0x84, |
| GATT_ERROR = 0x85, |
| GATT_CMD_STARTED = 0x86, |
| GATT_PENDING = 0x88, |
| GATT_AUTH_FAIL = 0x89, |
| GATT_MORE = 0x8a, |
| GATT_INVALID_CFG = 0x8b, |
| GATT_SERVICE_STARTED = 0x8c, |
| GATT_ENCRYPED_MITM = GATT_SUCCESS, |
| GATT_ENCRYPED_NO_MITM = 0x8d, |
| GATT_NOT_ENCRYPTED = 0x8e, |
| GATT_CONGESTED = 0x8f, |
| GATT_DUP_REG = 0x90, /* 0x90 */ |
| GATT_ALREADY_OPEN = 0x91, /* 0x91 */ |
| GATT_CANCEL = 0x92, /* 0x92 */ |
| /* = 0xE0 ~ 0xFC reserved for future use */ |
| |
| /* Client Characteristic Configuration Descriptor Improperly Configured */ |
| GATT_CCC_CFG_ERR = 0xFD, |
| /* Procedure Already in progress */ |
| GATT_PRC_IN_PROGRESS = 0xFE, |
| /* Attribute value out of range */ |
| GATT_OUT_OF_RANGE = 0xFF, |
| } tGATT_STATUS; |
| |
| typedef enum : uint8_t { |
| GATT_RSP_ERROR = 0x01, |
| GATT_REQ_MTU = 0x02, |
| GATT_RSP_MTU = 0x03, |
| GATT_REQ_FIND_INFO = 0x04, |
| GATT_RSP_FIND_INFO = 0x05, |
| GATT_REQ_FIND_TYPE_VALUE = 0x06, |
| GATT_RSP_FIND_TYPE_VALUE = 0x07, |
| GATT_REQ_READ_BY_TYPE = 0x08, |
| GATT_RSP_READ_BY_TYPE = 0x09, |
| GATT_REQ_READ = 0x0A, |
| GATT_RSP_READ = 0x0B, |
| GATT_REQ_READ_BLOB = 0x0C, |
| GATT_RSP_READ_BLOB = 0x0D, |
| GATT_REQ_READ_MULTI = 0x0E, |
| GATT_RSP_READ_MULTI = 0x0F, |
| GATT_REQ_READ_BY_GRP_TYPE = 0x10, |
| GATT_RSP_READ_BY_GRP_TYPE = 0x11, |
| /* 0001-0010 (write)*/ |
| GATT_REQ_WRITE = 0x12, |
| GATT_RSP_WRITE = 0x13, |
| /* changed in V4.0 01001-0010(write cmd)*/ |
| GATT_CMD_WRITE = 0x52, |
| GATT_REQ_PREPARE_WRITE = 0x16, |
| GATT_RSP_PREPARE_WRITE = 0x17, |
| GATT_REQ_EXEC_WRITE = 0x18, |
| GATT_RSP_EXEC_WRITE = 0x19, |
| GATT_HANDLE_VALUE_NOTIF = 0x1B, |
| GATT_HANDLE_VALUE_IND = 0x1D, |
| GATT_HANDLE_VALUE_CONF = 0x1E, |
| |
| GATT_REQ_READ_MULTI_VAR = 0x20, |
| GATT_RSP_READ_MULTI_VAR = 0x21, |
| GATT_HANDLE_MULTI_VALUE_NOTIF = 0x23, |
| |
| /* changed in V4.0 1101-0010 (signed write) see write cmd above*/ |
| GATT_SIGN_CMD_WRITE = 0xD2, |
| /* 0x1E = 30 + 1 = 31*/ |
| GATT_OP_CODE_MAX = (GATT_HANDLE_MULTI_VALUE_NOTIF + 1), |
| } tGATT_OP_CODE; |
| |
| inline std::string gatt_op_code_text(const tGATT_OP_CODE& op_code) { |
| switch (op_code) { |
| case GATT_RSP_ERROR: |
| return std::string("GATT_RSP_ERROR"); |
| case GATT_REQ_MTU: |
| return std::string("GATT_REQ_MTU"); |
| case GATT_RSP_MTU: |
| return std::string("GATT_RSP_MTU"); |
| case GATT_REQ_FIND_INFO: |
| return std::string("GATT_REQ_FIND_INFO"); |
| case GATT_RSP_FIND_INFO: |
| return std::string("GATT_RSP_FIND_INFO"); |
| case GATT_REQ_FIND_TYPE_VALUE: |
| return std::string("GATT_REQ_FIND_TYPE_VALUE"); |
| case GATT_RSP_FIND_TYPE_VALUE: |
| return std::string("GATT_RSP_FIND_TYPE_VALUE"); |
| case GATT_REQ_READ_BY_TYPE: |
| return std::string("GATT_REQ_READ_BY_TYPE"); |
| case GATT_RSP_READ_BY_TYPE: |
| return std::string("GATT_RSP_READ_BY_TYPE"); |
| case GATT_REQ_READ: |
| return std::string("GATT_REQ_READ"); |
| case GATT_RSP_READ: |
| return std::string("GATT_RSP_READ"); |
| case GATT_REQ_READ_BLOB: |
| return std::string("GATT_REQ_READ_BLOB"); |
| case GATT_RSP_READ_BLOB: |
| return std::string("GATT_RSP_READ_BLOB"); |
| case GATT_REQ_READ_MULTI: |
| return std::string("GATT_REQ_READ_MULTI"); |
| case GATT_RSP_READ_MULTI: |
| return std::string("GATT_RSP_READ_MULTI"); |
| case GATT_REQ_READ_BY_GRP_TYPE: |
| return std::string("GATT_REQ_READ_BY_GRP_TYPE"); |
| case GATT_RSP_READ_BY_GRP_TYPE: |
| return std::string("GATT_RSP_READ_BY_GRP_TYPE"); |
| case GATT_REQ_WRITE: |
| return std::string("GATT_REQ_WRITE"); |
| case GATT_RSP_WRITE: |
| return std::string("GATT_RSP_WRITE"); |
| case GATT_CMD_WRITE: |
| return std::string("GATT_CMD_WRITE"); |
| case GATT_REQ_PREPARE_WRITE: |
| return std::string("GATT_REQ_PREPARE_WRITE"); |
| case GATT_RSP_PREPARE_WRITE: |
| return std::string("GATT_RSP_PREPARE_WRITE"); |
| case GATT_REQ_EXEC_WRITE: |
| return std::string("GATT_REQ_EXEC_WRITE"); |
| case GATT_RSP_EXEC_WRITE: |
| return std::string("GATT_RSP_EXEC_WRITE"); |
| case GATT_HANDLE_VALUE_NOTIF: |
| return std::string("GATT_HANDLE_VALUE_NOTIF"); |
| case GATT_HANDLE_VALUE_IND: |
| return std::string("GATT_HANDLE_VALUE_IND"); |
| case GATT_HANDLE_VALUE_CONF: |
| return std::string("GATT_HANDLE_VALUE_CONF"); |
| case GATT_REQ_READ_MULTI_VAR: |
| return std::string("GATT_REQ_READ_MULTI_VAR"); |
| case GATT_RSP_READ_MULTI_VAR: |
| return std::string("GATT_RSP_READ_MULTI_VAR"); |
| case GATT_HANDLE_MULTI_VALUE_NOTIF: |
| return std::string("GATT_HANDLE_MULTI_VALUE_NOTIF"); |
| case GATT_SIGN_CMD_WRITE: |
| return std::string("GATT_SIGN_CMD_WRITE"); |
| case GATT_OP_CODE_MAX: |
| return std::string("GATT_OP_CODE_MAX"); |
| }; |
| } |
| |
| #define GATT_HANDLE_IS_VALID(x) ((x) != 0) |
| |
| typedef enum : uint16_t { |
| GATT_CONN_OK = 0, |
| /* general L2cap failure */ |
| GATT_CONN_L2C_FAILURE = 1, |
| /* 0x08 connection timeout */ |
| GATT_CONN_TIMEOUT = HCI_ERR_CONNECTION_TOUT, |
| /* 0x13 connection terminate by peer user */ |
| GATT_CONN_TERMINATE_PEER_USER = HCI_ERR_PEER_USER, |
| /* 0x16 connectionterminated by local host */ |
| GATT_CONN_TERMINATE_LOCAL_HOST = HCI_ERR_CONN_CAUSE_LOCAL_HOST, |
| /* 0x22 connection fail for LMP response tout */ |
| GATT_CONN_LMP_TIMEOUT = HCI_ERR_LMP_RESPONSE_TIMEOUT, |
| |
| GATT_CONN_FAILED_ESTABLISHMENT = HCI_ERR_CONN_FAILED_ESTABLISHMENT, |
| |
| BTA_GATT_CONN_NONE = 0x0101, /* 0x0101 no connection to cancel */ |
| |
| } tGATT_DISCONN_REASON; |
| |
| #define CASE_RETURN_TEXT(code) \ |
| case code: \ |
| return #code |
| |
| inline std::string gatt_disconnection_reason_text( |
| const tGATT_DISCONN_REASON& reason) { |
| switch (reason) { |
| CASE_RETURN_TEXT(GATT_CONN_OK); |
| CASE_RETURN_TEXT(GATT_CONN_L2C_FAILURE); |
| CASE_RETURN_TEXT(GATT_CONN_TIMEOUT); |
| CASE_RETURN_TEXT(GATT_CONN_TERMINATE_PEER_USER); |
| CASE_RETURN_TEXT(GATT_CONN_TERMINATE_LOCAL_HOST); |
| CASE_RETURN_TEXT(GATT_CONN_LMP_TIMEOUT); |
| CASE_RETURN_TEXT(GATT_CONN_FAILED_ESTABLISHMENT); |
| CASE_RETURN_TEXT(BTA_GATT_CONN_NONE); |
| default: |
| return base::StringPrintf("UNKNOWN[%hu]", reason); |
| } |
| } |
| #undef CASE_RETURN_TEXT |
| |
| /* MAX GATT MTU size |
| */ |
| #ifndef GATT_MAX_MTU_SIZE |
| #define GATT_MAX_MTU_SIZE 517 |
| #endif |
| |
| /* max legth of an attribute value |
| */ |
| #ifndef GATT_MAX_ATTR_LEN |
| #define GATT_MAX_ATTR_LEN 600 |
| #endif |
| |
| /* default GATT MTU size over LE link |
| */ |
| #define GATT_DEF_BLE_MTU_SIZE 23 |
| |
| /* invalid connection ID |
| */ |
| #define GATT_INVALID_CONN_ID 0xFFFF |
| |
| #ifndef GATT_CL_MAX_LCB |
| #define GATT_CL_MAX_LCB 22 |
| #endif |
| |
| /* GATT notification caching timer, default to be three seconds |
| */ |
| #ifndef GATTC_NOTIF_TIMEOUT |
| #define GATTC_NOTIF_TIMEOUT 3 |
| #endif |
| |
| /***************************************************************************** |
| * GATT Structure Definition |
| ****************************************************************************/ |
| |
| /* Attribute permissions |
| */ |
| #define GATT_PERM_READ (1 << 0) /* bit 0 */ |
| #define GATT_PERM_READ_ENCRYPTED (1 << 1) /* bit 1 */ |
| #define GATT_PERM_READ_ENC_MITM (1 << 2) /* bit 2 */ |
| #define GATT_PERM_WRITE (1 << 4) /* bit 4 */ |
| #define GATT_PERM_WRITE_ENCRYPTED (1 << 5) /* bit 5 */ |
| #define GATT_PERM_WRITE_ENC_MITM (1 << 6) /* bit 6 */ |
| #define GATT_PERM_WRITE_SIGNED (1 << 7) /* bit 7 */ |
| #define GATT_PERM_WRITE_SIGNED_MITM (1 << 8) /* bit 8 */ |
| typedef uint16_t tGATT_PERM; |
| |
| /* the MS nibble of tGATT_PERM; key size 7=0; size 16=9 */ |
| #define GATT_ENCRYPT_KEY_SIZE_MASK (0xF000) |
| |
| #define GATT_READ_ALLOWED \ |
| (GATT_PERM_READ | GATT_PERM_READ_ENCRYPTED | GATT_PERM_READ_ENC_MITM) |
| #define GATT_READ_AUTH_REQUIRED (GATT_PERM_READ_ENCRYPTED) |
| #define GATT_READ_MITM_REQUIRED (GATT_PERM_READ_ENC_MITM) |
| #define GATT_READ_ENCRYPTED_REQUIRED \ |
| (GATT_PERM_READ_ENCRYPTED | GATT_PERM_READ_ENC_MITM) |
| |
| #define GATT_WRITE_ALLOWED \ |
| (GATT_PERM_WRITE | GATT_PERM_WRITE_ENCRYPTED | GATT_PERM_WRITE_ENC_MITM | \ |
| GATT_PERM_WRITE_SIGNED | GATT_PERM_WRITE_SIGNED_MITM) |
| |
| #define GATT_WRITE_AUTH_REQUIRED \ |
| (GATT_PERM_WRITE_ENCRYPTED | GATT_PERM_WRITE_SIGNED) |
| |
| #define GATT_WRITE_MITM_REQUIRED \ |
| (GATT_PERM_WRITE_ENC_MITM | GATT_PERM_WRITE_SIGNED_MITM) |
| |
| #define GATT_WRITE_ENCRYPTED_PERM \ |
| (GATT_PERM_WRITE_ENCRYPTED | GATT_PERM_WRITE_ENC_MITM) |
| |
| #define GATT_WRITE_SIGNED_PERM \ |
| (GATT_PERM_WRITE_SIGNED | GATT_PERM_WRITE_SIGNED_MITM) |
| |
| /* Characteristic properties |
| */ |
| #define GATT_CHAR_PROP_BIT_BROADCAST (1 << 0) |
| #define GATT_CHAR_PROP_BIT_READ (1 << 1) |
| #define GATT_CHAR_PROP_BIT_WRITE_NR (1 << 2) |
| #define GATT_CHAR_PROP_BIT_WRITE (1 << 3) |
| #define GATT_CHAR_PROP_BIT_NOTIFY (1 << 4) |
| #define GATT_CHAR_PROP_BIT_INDICATE (1 << 5) |
| #define GATT_CHAR_PROP_BIT_AUTH (1 << 6) |
| #define GATT_CHAR_PROP_BIT_EXT_PROP (1 << 7) |
| typedef uint8_t tGATT_CHAR_PROP; |
| |
| /* Format of the value of a characteristic. enumeration type |
| */ |
| enum { |
| GATT_FORMAT_RES, /* rfu */ |
| GATT_FORMAT_BOOL, /* 0x01 boolean */ |
| GATT_FORMAT_2BITS, /* 0x02 2 bit */ |
| GATT_FORMAT_NIBBLE, /* 0x03 nibble */ |
| GATT_FORMAT_UINT8, /* 0x04 uint8 */ |
| GATT_FORMAT_UINT12, /* 0x05 uint12 */ |
| GATT_FORMAT_UINT16, /* 0x06 uint16 */ |
| GATT_FORMAT_UINT24, /* 0x07 uint24 */ |
| GATT_FORMAT_UINT32, /* 0x08 uint32 */ |
| GATT_FORMAT_UINT48, /* 0x09 uint48 */ |
| GATT_FORMAT_UINT64, /* 0x0a uint64 */ |
| GATT_FORMAT_UINT128, /* 0x0B uint128 */ |
| GATT_FORMAT_SINT8, /* 0x0C signed 8 bit integer */ |
| GATT_FORMAT_SINT12, /* 0x0D signed 12 bit integer */ |
| GATT_FORMAT_SINT16, /* 0x0E signed 16 bit integer */ |
| GATT_FORMAT_SINT24, /* 0x0F signed 24 bit integer */ |
| GATT_FORMAT_SINT32, /* 0x10 signed 32 bit integer */ |
| GATT_FORMAT_SINT48, /* 0x11 signed 48 bit integer */ |
| GATT_FORMAT_SINT64, /* 0x12 signed 64 bit integer */ |
| GATT_FORMAT_SINT128, /* 0x13 signed 128 bit integer */ |
| GATT_FORMAT_FLOAT32, /* 0x14 float 32 */ |
| GATT_FORMAT_FLOAT64, /* 0x15 float 64*/ |
| GATT_FORMAT_SFLOAT, /* 0x16 IEEE-11073 16 bit SFLOAT */ |
| GATT_FORMAT_FLOAT, /* 0x17 IEEE-11073 32 bit SFLOAT */ |
| GATT_FORMAT_DUINT16, /* 0x18 IEEE-20601 format */ |
| GATT_FORMAT_UTF8S, /* 0x19 UTF-8 string */ |
| GATT_FORMAT_UTF16S, /* 0x1a UTF-16 string */ |
| GATT_FORMAT_STRUCT, /* 0x1b Opaque structure*/ |
| GATT_FORMAT_MAX /* 0x1c or above reserved */ |
| }; |
| typedef uint8_t tGATT_FORMAT; |
| |
| /* Characteristic Presentation Format Descriptor value |
| */ |
| typedef struct { |
| uint16_t unit; /* as UUIUD defined by SIG */ |
| uint16_t descr; /* as UUID as defined by SIG */ |
| tGATT_FORMAT format; |
| int8_t exp; |
| uint8_t name_spc; /* The name space of the description */ |
| } tGATT_CHAR_PRES; |
| |
| /* Characteristic Report reference Descriptor format |
| */ |
| typedef struct { |
| uint8_t rpt_id; /* report ID */ |
| uint8_t rpt_type; /* report type */ |
| } tGATT_CHAR_RPT_REF; |
| |
| #define GATT_VALID_RANGE_MAX_SIZE 16 |
| typedef struct { |
| uint8_t format; |
| uint16_t len; |
| uint8_t lower_range[GATT_VALID_RANGE_MAX_SIZE]; /* in little endian format */ |
| uint8_t upper_range[GATT_VALID_RANGE_MAX_SIZE]; |
| } tGATT_VALID_RANGE; |
| |
| /* Characteristic Aggregate Format attribute value |
| */ |
| #define GATT_AGGR_HANDLE_NUM_MAX 10 |
| typedef struct { |
| uint8_t num_handle; |
| uint16_t handle_list[GATT_AGGR_HANDLE_NUM_MAX]; |
| } tGATT_CHAR_AGGRE; |
| |
| /* Characteristic descriptor: Extended Properties value |
| */ |
| /* permits reliable writes of the Characteristic Value */ |
| #define GATT_CHAR_BIT_REL_WRITE 0x0001 |
| /* permits writes to the characteristic descriptor */ |
| #define GATT_CHAR_BIT_WRITE_AUX 0x0002 |
| |
| /* characteristic descriptor: client configuration value |
| */ |
| #define GATT_CLT_CONFIG_NONE 0x0000 |
| #define GATT_CLT_CONFIG_NOTIFICATION 0x0001 |
| #define GATT_CLT_CONFIG_INDICATION 0x0002 |
| |
| /* characteristic descriptor: server configuration value |
| */ |
| #define GATT_SVR_CONFIG_NONE 0x0000 |
| #define GATT_SVR_CONFIG_BROADCAST 0x0001 |
| typedef uint16_t tGATT_SVR_CHAR_CONFIG; |
| |
| /* Characteristic descriptor: Extended Properties value |
| */ |
| /* permits reliable writes of the Characteristic Value */ |
| #define GATT_CHAR_BIT_REL_WRITE 0x0001 |
| /* permits writes to the characteristic descriptor */ |
| #define GATT_CHAR_BIT_WRITE_AUX 0x0002 |
| |
| /* authentication requirement |
| */ |
| #define GATT_AUTH_REQ_NONE 0 |
| #define GATT_AUTH_REQ_NO_MITM 1 /* unauthenticated encryption */ |
| #define GATT_AUTH_REQ_MITM 2 /* authenticated encryption */ |
| #define GATT_AUTH_REQ_SIGNED_NO_MITM 3 |
| #define GATT_AUTH_REQ_SIGNED_MITM 4 |
| typedef uint8_t tGATT_AUTH_REQ; |
| |
| /* Attribute Value structure |
| */ |
| typedef struct { |
| uint16_t conn_id; |
| uint16_t handle; /* attribute handle */ |
| uint16_t offset; /* attribute value offset, if no offfset is needed for the |
| command, ignore it */ |
| uint16_t len; /* length of attribute value */ |
| tGATT_AUTH_REQ auth_req; /* authentication request */ |
| uint8_t value[GATT_MAX_ATTR_LEN]; /* the actual attribute value */ |
| } tGATT_VALUE; |
| |
| /* Union of the event data which is used in the server respond API to carry the |
| * server response information |
| */ |
| typedef union { |
| /* data type member event */ |
| tGATT_VALUE attr_value; /* READ, HANDLE_VALUE_IND, PREPARE_WRITE */ |
| /* READ_BLOB, READ_BY_TYPE */ |
| uint16_t handle; /* WRITE, WRITE_BLOB */ |
| |
| } tGATTS_RSP; |
| |
| #define GATT_PREP_WRITE_CANCEL 0x00 |
| #define GATT_PREP_WRITE_EXEC 0x01 |
| typedef uint8_t tGATT_EXEC_FLAG; |
| |
| /* read request always based on UUID */ |
| typedef struct { |
| uint16_t handle; |
| uint16_t offset; |
| bool is_long; |
| bt_gatt_db_attribute_type_t |
| gatt_type; /* are we writing characteristic or descriptor */ |
| } tGATT_READ_REQ; |
| |
| /* write request data */ |
| typedef struct { |
| uint16_t handle; /* attribute handle */ |
| uint16_t offset; /* attribute value offset, if no offfset is needed for the |
| command, ignore it */ |
| uint16_t len; /* length of attribute value */ |
| uint8_t value[GATT_MAX_ATTR_LEN]; /* the actual attribute value */ |
| bool need_rsp; /* need write response */ |
| bool is_prep; /* is prepare write */ |
| bt_gatt_db_attribute_type_t |
| gatt_type; /* are we writing characteristic or descriptor */ |
| } tGATT_WRITE_REQ; |
| |
| /* callback data for server access request from client */ |
| typedef union { |
| tGATT_READ_REQ read_req; /* read request, read by Type, read blob */ |
| |
| tGATT_WRITE_REQ write_req; /* write */ |
| /* prepare write */ |
| /* write blob */ |
| uint16_t handle; /* handle value confirmation */ |
| uint16_t mtu; /* MTU exchange request */ |
| tGATT_EXEC_FLAG exec_write; /* execute write */ |
| } tGATTS_DATA; |
| |
| typedef uint8_t tGATT_SERV_IF; /* GATT Service Interface */ |
| |
| enum { |
| GATTS_REQ_TYPE_READ_CHARACTERISTIC = 1, /* Char read request */ |
| GATTS_REQ_TYPE_READ_DESCRIPTOR, /* Desc read request */ |
| GATTS_REQ_TYPE_WRITE_CHARACTERISTIC, /* Char write request */ |
| GATTS_REQ_TYPE_WRITE_DESCRIPTOR, /* Desc write request */ |
| GATTS_REQ_TYPE_WRITE_EXEC, /* Execute write */ |
| GATTS_REQ_TYPE_MTU, /* MTU exchange information */ |
| GATTS_REQ_TYPE_CONF /* handle value confirmation */ |
| }; |
| typedef uint8_t tGATTS_REQ_TYPE; |
| |
| /* Client Used Data Structure |
| */ |
| /* definition of different discovery types */ |
| typedef enum : uint8_t { |
| GATT_DISC_SRVC_ALL = 1, /* discover all services */ |
| GATT_DISC_SRVC_BY_UUID, /* discover service of a special type */ |
| GATT_DISC_INC_SRVC, /* discover the included service within a service */ |
| GATT_DISC_CHAR, /* discover characteristics of a service with/without type |
| requirement */ |
| GATT_DISC_CHAR_DSCPT, /* discover characteristic descriptors of a character */ |
| GATT_DISC_MAX /* maximnun discover type */ |
| } tGATT_DISC_TYPE; |
| |
| /* GATT read type enumeration |
| */ |
| enum { |
| GATT_READ_BY_TYPE = 1, |
| GATT_READ_BY_HANDLE, |
| GATT_READ_MULTIPLE, |
| GATT_READ_CHAR_VALUE, |
| GATT_READ_PARTIAL, |
| GATT_READ_MAX |
| }; |
| typedef uint8_t tGATT_READ_TYPE; |
| |
| /* Read By Type Request (GATT_READ_BY_TYPE) Data |
| */ |
| typedef struct { |
| tGATT_AUTH_REQ auth_req; |
| uint16_t s_handle; |
| uint16_t e_handle; |
| bluetooth::Uuid uuid; |
| } tGATT_READ_BY_TYPE; |
| |
| /* GATT_READ_MULTIPLE request data |
| */ |
| #define GATT_MAX_READ_MULTI_HANDLES \ |
| 10 /* Max attributes to read in one request */ |
| typedef struct { |
| tGATT_AUTH_REQ auth_req; |
| uint16_t num_handles; /* number of handles to read */ |
| uint16_t handles[GATT_MAX_READ_MULTI_HANDLES]; /* handles list to be read */ |
| bool variable_len; |
| } tGATT_READ_MULTI; |
| |
| /* Read By Handle Request (GATT_READ_BY_HANDLE) data */ |
| typedef struct { |
| tGATT_AUTH_REQ auth_req; |
| uint16_t handle; |
| } tGATT_READ_BY_HANDLE; |
| |
| /* READ_BT_HANDLE_Request data */ |
| typedef struct { |
| tGATT_AUTH_REQ auth_req; |
| uint16_t handle; |
| uint16_t offset; |
| } tGATT_READ_PARTIAL; |
| |
| /* Read Request Data |
| */ |
| typedef union { |
| tGATT_READ_BY_TYPE service; |
| tGATT_READ_BY_TYPE char_type; /* characterisitc type */ |
| tGATT_READ_MULTI read_multiple; |
| tGATT_READ_BY_HANDLE by_handle; |
| tGATT_READ_PARTIAL partial; |
| } tGATT_READ_PARAM; |
| |
| /* GATT write type enumeration */ |
| enum { GATT_WRITE_NO_RSP = 1, GATT_WRITE, GATT_WRITE_PREPARE }; |
| typedef uint8_t tGATT_WRITE_TYPE; |
| |
| /* Client Operation Complete Callback Data |
| */ |
| typedef union { |
| tGATT_VALUE att_value; |
| uint16_t mtu; |
| uint16_t handle; |
| uint16_t cid; |
| } tGATT_CL_COMPLETE; |
| |
| /* GATT client operation type, used in client callback function |
| */ |
| typedef enum : uint8_t { |
| GATTC_OPTYPE_NONE = 0, |
| GATTC_OPTYPE_DISCOVERY = 1, |
| GATTC_OPTYPE_READ = 2, |
| GATTC_OPTYPE_WRITE = 3, |
| GATTC_OPTYPE_EXE_WRITE = 4, |
| GATTC_OPTYPE_CONFIG = 5, |
| GATTC_OPTYPE_NOTIFICATION = 6, |
| GATTC_OPTYPE_INDICATION = 7, |
| } tGATTC_OPTYPE; |
| |
| /* characteristic declaration |
| */ |
| typedef struct { |
| tGATT_CHAR_PROP char_prop; /* characterisitc properties */ |
| uint16_t val_handle; /* characteristic value attribute handle */ |
| bluetooth::Uuid char_uuid; /* characteristic UUID type */ |
| } tGATT_CHAR_DCLR_VAL; |
| |
| /* primary service group data |
| */ |
| typedef struct { |
| uint16_t e_handle; /* ending handle of the group */ |
| bluetooth::Uuid service_type; /* group type */ |
| } tGATT_GROUP_VALUE; |
| |
| /* included service attribute value |
| */ |
| typedef struct { |
| bluetooth::Uuid service_type; /* included service UUID */ |
| uint16_t s_handle; /* starting handle */ |
| uint16_t e_handle; /* ending handle */ |
| } tGATT_INCL_SRVC; |
| |
| typedef union { |
| tGATT_INCL_SRVC incl_service; /* include service value */ |
| tGATT_GROUP_VALUE group_value; /* Service UUID type. |
| This field is used with GATT_DISC_SRVC_ALL |
| or GATT_DISC_SRVC_BY_UUID |
| type of discovery result callback. */ |
| |
| uint16_t handle; /* When used with GATT_DISC_INC_SRVC type discovery result, |
| it is the included service starting handle.*/ |
| |
| tGATT_CHAR_DCLR_VAL |
| dclr_value; /* Characteristic declaration value. |
| This field is used with GATT_DISC_CHAR type discovery.*/ |
| } tGATT_DISC_VALUE; |
| |
| /* discover result record |
| */ |
| typedef struct { |
| bluetooth::Uuid type; |
| uint16_t handle; |
| tGATT_DISC_VALUE value; |
| } tGATT_DISC_RES; |
| |
| #define GATT_LINK_IDLE_TIMEOUT_WHEN_NO_APP \ |
| 1 /* start a idle timer for this duration \ |
| when no application need to use the link */ |
| |
| #define GATT_LINK_NO_IDLE_TIMEOUT 0xFFFF |
| |
| #define GATT_INVALID_ACL_HANDLE 0xFFFF |
| /* discover result callback function */ |
| typedef void(tGATT_DISC_RES_CB)(uint16_t conn_id, tGATT_DISC_TYPE disc_type, |
| tGATT_DISC_RES* p_data); |
| |
| /* discover complete callback function */ |
| typedef void(tGATT_DISC_CMPL_CB)(uint16_t conn_id, tGATT_DISC_TYPE disc_type, |
| tGATT_STATUS status); |
| |
| /* Define a callback function for when read/write/disc/config operation is |
| * completed. */ |
| typedef void(tGATT_CMPL_CBACK)(uint16_t conn_id, tGATTC_OPTYPE op, |
| tGATT_STATUS status, tGATT_CL_COMPLETE* p_data); |
| |
| /* Define a callback function when an initialized connection is established. */ |
| typedef void(tGATT_CONN_CBACK)(tGATT_IF gatt_if, const RawAddress& bda, |
| uint16_t conn_id, bool connected, |
| tGATT_DISCONN_REASON reason, |
| tBT_TRANSPORT transport); |
| |
| /* attribute request callback for ATT server */ |
| typedef void(tGATT_REQ_CBACK)(uint16_t conn_id, uint32_t trans_id, |
| tGATTS_REQ_TYPE type, tGATTS_DATA* p_data); |
| |
| /* channel congestion/uncongestion callback */ |
| typedef void(tGATT_CONGESTION_CBACK)(uint16_t conn_id, bool congested); |
| |
| /* Define a callback function when encryption is established. */ |
| typedef void(tGATT_ENC_CMPL_CB)(tGATT_IF gatt_if, const RawAddress& bda); |
| |
| /* Define a callback function when phy is updated. */ |
| typedef void(tGATT_PHY_UPDATE_CB)(tGATT_IF gatt_if, uint16_t conn_id, |
| uint8_t tx_phy, uint8_t rx_phy, |
| tGATT_STATUS status); |
| |
| /* Define a callback function when connection parameters are updated */ |
| typedef void(tGATT_CONN_UPDATE_CB)(tGATT_IF gatt_if, uint16_t conn_id, |
| uint16_t interval, uint16_t latency, |
| uint16_t timeout, tGATT_STATUS status); |
| |
| /* Define the structure that applications use to register with |
| * GATT. This structure includes callback functions. All functions |
| * MUST be provided. |
| */ |
| typedef struct { |
| tGATT_CONN_CBACK* p_conn_cb{nullptr}; |
| tGATT_CMPL_CBACK* p_cmpl_cb{nullptr}; |
| tGATT_DISC_RES_CB* p_disc_res_cb{nullptr}; |
| tGATT_DISC_CMPL_CB* p_disc_cmpl_cb{nullptr}; |
| tGATT_REQ_CBACK* p_req_cb{nullptr}; |
| tGATT_ENC_CMPL_CB* p_enc_cmpl_cb{nullptr}; |
| tGATT_CONGESTION_CBACK* p_congestion_cb{nullptr}; |
| tGATT_PHY_UPDATE_CB* p_phy_update_cb{nullptr}; |
| tGATT_CONN_UPDATE_CB* p_conn_update_cb{nullptr}; |
| } tGATT_CBACK; |
| |
| /***************** Start Handle Management Definitions *********************/ |
| |
| typedef struct { |
| bluetooth::Uuid app_uuid128; |
| bluetooth::Uuid svc_uuid; |
| uint16_t s_handle; |
| uint16_t e_handle; |
| bool is_primary; /* primary service or secondary */ |
| } tGATTS_HNDL_RANGE; |
| |
| #define GATTS_SRV_CHG_CMD_ADD_CLIENT 1 |
| #define GATTS_SRV_CHG_CMD_UPDATE_CLIENT 2 |
| #define GATTS_SRV_CHG_CMD_REMOVE_CLIENT 3 |
| #define GATTS_SRV_CHG_CMD_READ_NUM_CLENTS 4 |
| #define GATTS_SRV_CHG_CMD_READ_CLENT 5 |
| typedef uint8_t tGATTS_SRV_CHG_CMD; |
| |
| typedef struct { |
| RawAddress bda; |
| bool srv_changed; |
| } tGATTS_SRV_CHG; |
| |
| typedef union { |
| tGATTS_SRV_CHG srv_chg; |
| uint8_t client_read_index; /* only used for sequential reading client srv chg |
| info */ |
| } tGATTS_SRV_CHG_REQ; |
| |
| typedef union { |
| tGATTS_SRV_CHG srv_chg; |
| uint8_t num_clients; |
| } tGATTS_SRV_CHG_RSP; |
| |
| /* Attibute server handle ranges NV storage callback functions |
| */ |
| typedef void(tGATTS_NV_SAVE_CBACK)(bool is_saved, |
| tGATTS_HNDL_RANGE* p_hndl_range); |
| typedef bool(tGATTS_NV_SRV_CHG_CBACK)(tGATTS_SRV_CHG_CMD cmd, |
| tGATTS_SRV_CHG_REQ* p_req, |
| tGATTS_SRV_CHG_RSP* p_rsp); |
| |
| typedef struct { |
| tGATTS_NV_SAVE_CBACK* p_nv_save_callback; |
| tGATTS_NV_SRV_CHG_CBACK* p_srv_chg_callback; |
| } tGATT_APPL_INFO; |
| |
| /******************** End Handle Management Definitions ********************/ |
| |
| /******************************************************************************* |
| * External Function Declarations |
| ******************************************************************************/ |
| |
| /******************************************************************************/ |
| /* GATT Profile API Functions */ |
| /******************************************************************************/ |
| /* GATT Profile Server Functions */ |
| /******************************************************************************/ |
| |
| /******************************************************************************* |
| * |
| * Function GATTS_NVRegister |
| * |
| * Description Application manager calls this function to register for |
| * NV save callback function. There can be one and only one |
| * NV save callback function. |
| * |
| * Parameter p_cb_info : callback informaiton |
| * |
| * Returns true if registered OK, else false |
| * |
| ******************************************************************************/ |
| extern bool GATTS_NVRegister(tGATT_APPL_INFO* p_cb_info); |
| |
| /******************************************************************************* |
| * |
| * Function BTA_GATTS_AddService |
| * |
| * Description Add a service. When service is ready, a callback |
| * event BTA_GATTS_ADD_SRVC_EVT is called to report status |
| * and handles to the profile. |
| * |
| * Parameters server_if: server interface. |
| * service: pointer array describing service. |
| * count: number of elements in service array. |
| * |
| * Returns on success GATT_SERVICE_STARTED is returned, and |
| * attribute_handle field inside service elements are filled. |
| * on error error status is returned. |
| * |
| ******************************************************************************/ |
| extern tGATT_STATUS GATTS_AddService(tGATT_IF gatt_if, |
| btgatt_db_element_t* service, int count); |
| |
| /******************************************************************************* |
| * |
| * Function GATTS_DeleteService |
| * |
| * Description This function is called to delete a service. |
| * |
| * Parameter gatt_if : application interface |
| * p_svc_uuid : service UUID |
| * svc_inst : instance of the service inside the |
| * application |
| * |
| * Returns true if operation succeed, else false |
| * |
| ******************************************************************************/ |
| extern bool GATTS_DeleteService(tGATT_IF gatt_if, bluetooth::Uuid* p_svc_uuid, |
| uint16_t svc_inst); |
| |
| /******************************************************************************* |
| * |
| * Function GATTS_StopService |
| * |
| * Description This function is called to stop a service |
| * |
| * Parameter service_handle : this is the start handle of a service |
| * |
| * Returns None. |
| * |
| ******************************************************************************/ |
| extern void GATTS_StopService(uint16_t service_handle); |
| |
| /******************************************************************************* |
| * |
| * Function GATTs_HandleValueIndication |
| * |
| * Description This function sends a handle value indication to a client. |
| * |
| * Parameter conn_id: connection identifier. |
| * attr_handle: Attribute handle of this handle value |
| * indication. |
| * val_len: Length of the indicated attribute value. |
| * p_val: Pointer to the indicated attribute value data. |
| * |
| * Returns GATT_SUCCESS if sucessfully sent or queued; otherwise error |
| * code. |
| * |
| ******************************************************************************/ |
| extern tGATT_STATUS GATTS_HandleValueIndication(uint16_t conn_id, |
| uint16_t attr_handle, |
| uint16_t val_len, |
| uint8_t* p_val); |
| |
| /******************************************************************************* |
| * |
| * Function GATTS_HandleValueNotification |
| * |
| * Description This function sends a handle value notification to a client. |
| * |
| * Parameter conn_id: connection identifier. |
| * attr_handle: Attribute handle of this handle value |
| * indication. |
| * val_len: Length of the indicated attribute value. |
| * p_val: Pointer to the indicated attribute value data. |
| * |
| * Returns GATT_SUCCESS if sucessfully sent; otherwise error code. |
| * |
| ******************************************************************************/ |
| extern tGATT_STATUS GATTS_HandleValueNotification(uint16_t conn_id, |
| uint16_t attr_handle, |
| uint16_t val_len, |
| uint8_t* p_val); |
| |
| /******************************************************************************* |
| * |
| * Function GATTS_SendRsp |
| * |
| * Description This function sends the server response to client. |
| * |
| * Parameter conn_id: connection identifier. |
| * trans_id: transaction id |
| * status: response status |
| * p_msg: pointer to message parameters structure. |
| * |
| * Returns GATT_SUCCESS if sucessfully sent; otherwise error code. |
| * |
| ******************************************************************************/ |
| extern tGATT_STATUS GATTS_SendRsp(uint16_t conn_id, uint32_t trans_id, |
| tGATT_STATUS status, tGATTS_RSP* p_msg); |
| |
| /******************************************************************************/ |
| /* GATT Profile Client Functions */ |
| /******************************************************************************/ |
| |
| /******************************************************************************* |
| * |
| * Function GATTC_ConfigureMTU |
| * |
| * Description This function is called to configure the ATT MTU size for |
| * a connection on an LE transport. |
| * |
| * Parameters conn_id: connection identifier. |
| * mtu - attribute MTU size.. |
| * |
| * Returns GATT_SUCCESS if command started successfully. |
| * |
| ******************************************************************************/ |
| extern tGATT_STATUS GATTC_ConfigureMTU(uint16_t conn_id, uint16_t mtu); |
| |
| /******************************************************************************* |
| * |
| * Function GATTC_Discover |
| * |
| * Description This function is called to do a discovery procedure on ATT |
| * server. |
| * |
| * Parameters conn_id: connection identifier. |
| * disc_type:discovery type. |
| * start_handle and end_handle: range of handles for discovery |
| * uuid: uuid to discovery. set to Uuid::kEmpty for requests |
| * that don't need it |
| * |
| * Returns GATT_SUCCESS if command received/sent successfully. |
| * |
| ******************************************************************************/ |
| extern tGATT_STATUS GATTC_Discover(uint16_t conn_id, tGATT_DISC_TYPE disc_type, |
| uint16_t start_handle, uint16_t end_handle, |
| const bluetooth::Uuid& uuid); |
| extern tGATT_STATUS GATTC_Discover(uint16_t conn_id, tGATT_DISC_TYPE disc_type, |
| uint16_t start_handle, uint16_t end_handle); |
| |
| /******************************************************************************* |
| * |
| * Function GATTC_Read |
| * |
| * Description This function is called to read the value of an attribute |
| * from the server. |
| * |
| * Parameters conn_id: connection identifier. |
| * type - attribute read type. |
| * p_read - read operation parameters. |
| * |
| * Returns GATT_SUCCESS if command started successfully. |
| * |
| ******************************************************************************/ |
| extern tGATT_STATUS GATTC_Read(uint16_t conn_id, tGATT_READ_TYPE type, |
| tGATT_READ_PARAM* p_read); |
| |
| /******************************************************************************* |
| * |
| * Function GATTC_Write |
| * |
| * Description This function is called to read the value of an attribute |
| * from the server. |
| * |
| * Parameters conn_id: connection identifier. |
| * type - attribute write type. |
| * p_write - write operation parameters. |
| * |
| * Returns GATT_SUCCESS if command started successfully. |
| * |
| ******************************************************************************/ |
| extern tGATT_STATUS GATTC_Write(uint16_t conn_id, tGATT_WRITE_TYPE type, |
| tGATT_VALUE* p_write); |
| |
| /******************************************************************************* |
| * |
| * Function GATTC_ExecuteWrite |
| * |
| * Description This function is called to send an Execute write request to |
| * the server. |
| * |
| * Parameters conn_id: connection identifier. |
| * is_execute - to execute or cancel the prepare write |
| * request(s) |
| * |
| * Returns GATT_SUCCESS if command started successfully. |
| * |
| ******************************************************************************/ |
| extern tGATT_STATUS GATTC_ExecuteWrite(uint16_t conn_id, bool is_execute); |
| |
| /******************************************************************************* |
| * |
| * Function GATTC_SendHandleValueConfirm |
| * |
| * Description This function is called to send a handle value confirmation |
| * as response to a handle value notification from server. |
| * |
| * Parameters conn_id: connection identifier. |
| * handle: the handle of the attribute confirmation. |
| * |
| * Returns GATT_SUCCESS if command started successfully. |
| * |
| ******************************************************************************/ |
| extern tGATT_STATUS GATTC_SendHandleValueConfirm(uint16_t conn_id, |
| uint16_t handle); |
| |
| /******************************************************************************* |
| * |
| * Function GATT_SetIdleTimeout |
| * |
| * Description This function (common to both client and server) sets the |
| * idle timeout for a tansport connection |
| * |
| * Parameter bd_addr: target device bd address. |
| * idle_tout: timeout value in seconds. |
| * transport: trasnport option. |
| * |
| * Returns void |
| * |
| ******************************************************************************/ |
| extern void GATT_SetIdleTimeout(const RawAddress& bd_addr, uint16_t idle_tout, |
| tBT_TRANSPORT transport); |
| |
| /******************************************************************************* |
| * |
| * Function GATT_Register |
| * |
| * Description This function is called to register an application |
| * with GATT |
| * |
| * Parameter p_app_uuid128: Application UUID |
| * p_cb_info: callback functions. |
| * eatt_support: set support for eatt |
| * |
| * Returns 0 for error, otherwise the index of the client registered |
| * with GATT |
| * |
| ******************************************************************************/ |
| extern tGATT_IF GATT_Register(const bluetooth::Uuid& p_app_uuid128, |
| const std::string name, tGATT_CBACK* p_cb_info, |
| bool eatt_support); |
| |
| /******************************************************************************* |
| * |
| * Function GATT_Deregister |
| * |
| * Description This function deregistered the application from GATT. |
| * |
| * Parameters gatt_if: applicaiton interface. |
| * |
| * Returns None. |
| * |
| ******************************************************************************/ |
| extern void GATT_Deregister(tGATT_IF gatt_if); |
| |
| /******************************************************************************* |
| * |
| * Function GATT_StartIf |
| * |
| * Description This function is called after registration to start |
| * receiving callbacks for registered interface. Function may |
| * call back with connection status and queued notifications |
| * |
| * Parameter gatt_if: applicaiton interface. |
| * |
| * Returns None |
| * |
| ******************************************************************************/ |
| extern void GATT_StartIf(tGATT_IF gatt_if); |
| |
| /******************************************************************************* |
| * |
| * Function GATT_Connect |
| * |
| * Description This function initiate a connecttion to a remote device on |
| * GATT channel. |
| * |
| * Parameters gatt_if: applicaiton interface |
| * bd_addr: peer device address. |
| * is_direct: is a direct connection or a background auto |
| * connection |
| * transport : Physical transport for GATT connection |
| * (BR/EDR or LE) |
| * opportunistic: will not keep device connected if other apps |
| * disconnect, will not update connected apps counter, when |
| * disconnected won't cause physical disconnection. |
| * |
| * Returns true if connection started; else false |
| * |
| ******************************************************************************/ |
| extern bool GATT_Connect(tGATT_IF gatt_if, const RawAddress& bd_addr, |
| bool is_direct, tBT_TRANSPORT transport, |
| bool opportunistic); |
| extern bool GATT_Connect(tGATT_IF gatt_if, const RawAddress& bd_addr, |
| bool is_direct, tBT_TRANSPORT transport, |
| bool opportunistic, uint8_t initiating_phys); |
| |
| /******************************************************************************* |
| * |
| * Function GATT_CancelConnect |
| * |
| * Description Terminate the connection initiation to a remote device on a |
| * GATT channel. |
| * |
| * Parameters gatt_if: client interface. If 0 used as unconditionally |
| * disconnect, typically used for direct connection |
| * cancellation. |
| * bd_addr: peer device address. |
| * is_direct: is a direct conenection or a background auto |
| * connection |
| * |
| * Returns true if connection started; else false |
| * |
| ******************************************************************************/ |
| extern bool GATT_CancelConnect(tGATT_IF gatt_if, const RawAddress& bd_addr, |
| bool is_direct); |
| |
| /******************************************************************************* |
| * |
| * Function GATT_Disconnect |
| * |
| * Description Disconnect the GATT channel for this registered application. |
| * |
| * Parameters conn_id: connection identifier. |
| * |
| * Returns GATT_SUCCESS if disconnected. |
| * |
| ******************************************************************************/ |
| extern tGATT_STATUS GATT_Disconnect(uint16_t conn_id); |
| |
| /******************************************************************************* |
| * |
| * Function GATT_GetConnectionInfor |
| * |
| * Description Use conn_id to find its associated BD address and |
| * application interface |
| * |
| * Parameters conn_id: connection id (input) |
| * p_gatt_if: applicaiton interface (output) |
| * bd_addr: peer device address. (output) |
| * transport : physical transport of the GATT connection |
| * (BR/EDR or LE) |
| * |
| * Returns true the ligical link information is found for conn_id |
| * |
| ******************************************************************************/ |
| extern bool GATT_GetConnectionInfor(uint16_t conn_id, tGATT_IF* p_gatt_if, |
| RawAddress& bd_addr, |
| tBT_TRANSPORT* p_transport); |
| |
| /******************************************************************************* |
| * |
| * Function GATT_GetConnIdIfConnected |
| * |
| * Description Find the conn_id if the logical link for a BD address |
| * and application interface is connected |
| * |
| * Parameters gatt_if: applicaiton interface (input) |
| * bd_addr: peer device address. (input) |
| * p_conn_id: connection id (output) |
| * transport : physical transport of the GATT connection |
| * (BR/EDR or LE) |
| * |
| * Returns true the ligical link is connected |
| * |
| ******************************************************************************/ |
| extern bool GATT_GetConnIdIfConnected(tGATT_IF gatt_if, |
| const RawAddress& bd_addr, |
| uint16_t* p_conn_id, |
| tBT_TRANSPORT transport); |
| |
| /******************************************************************************* |
| * |
| * Function GATT_ConfigServiceChangeCCC |
| * |
| * Description Configure service change indication on remote device |
| * |
| * Returns None. |
| * |
| ******************************************************************************/ |
| extern void GATT_ConfigServiceChangeCCC(const RawAddress& remote_bda, |
| bool enable, tBT_TRANSPORT transport); |
| |
| // Enables the GATT profile on the device. |
| // It clears out the control blocks, and registers with L2CAP. |
| extern void gatt_init(void); |
| |
| // Frees resources used by the GATT profile. |
| extern void gatt_free(void); |
| |
| // Link encryption complete notification for all encryption process |
| // initiated outside GATT. |
| extern void gatt_notify_enc_cmpl(const RawAddress& bd_addr); |
| |
| /** Reset bg device list. If called after controller reset, set |after_reset| to |
| * true, as there is no need to wipe controller acceptlist in this case. */ |
| extern void gatt_reset_bgdev_list(bool after_reset); |
| |
| #endif /* GATT_API_H */ |
