1 /****************************************************************************** 2 * 3 * Copyright 2006-2012 Broadcom Corporation 4 * 5 * Licensed under the Apache License, Version 2.0 (the "License"); 6 * you may not use this file except in compliance with the License. 7 * You may obtain a copy of the License at: 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 * 17 ******************************************************************************/ 18 19 /****************************************************************************** 20 * 21 * This is the public interface file the BTA Java I/F 22 * 23 ******************************************************************************/ 24 #ifndef BTA_JV_API_H 25 #define BTA_JV_API_H 26 27 #include "bt_target.h" 28 #include "bt_types.h" 29 #include "bta_api.h" 30 #include "btm_api.h" 31 #include "l2c_api.h" 32 33 /***************************************************************************** 34 * Constants and data types 35 ****************************************************************************/ 36 /* status values */ 37 #define BTA_JV_SUCCESS 0 /* Successful operation. */ 38 #define BTA_JV_FAILURE 1 /* Generic failure. */ 39 #define BTA_JV_BUSY 2 /* Temporarily can not handle this request. */ 40 #define BTA_JV_NO_DATA 3 /* no data. */ 41 #define BTA_JV_NO_RESOURCE 4 /* No more set pm control block */ 42 43 typedef uint8_t tBTA_JV_STATUS; 44 #define BTA_JV_INTERNAL_ERR (-1) /* internal error. */ 45 46 #define BTA_JV_MAX_UUIDS SDP_MAX_UUID_FILTERS 47 #define BTA_JV_MAX_ATTRS SDP_MAX_ATTR_FILTERS 48 #define BTA_JV_MAX_SDP_REC SDP_MAX_RECORDS 49 #define BTA_JV_MAX_L2C_CONN \ 50 GAP_MAX_CONNECTIONS /* GAP handle is used as index, hence do not change this \ 51 value */ 52 #define BTA_JV_MAX_SCN \ 53 PORT_MAX_RFC_PORTS /* same as BTM_MAX_SCN (in btm_int.h) */ 54 #define BTA_JV_MAX_RFC_CONN MAX_RFC_PORTS 55 56 #ifndef BTA_JV_DEF_RFC_MTU 57 #define BTA_JV_DEF_RFC_MTU (3 * 330) 58 #endif 59 60 #ifndef BTA_JV_MAX_RFC_SR_SESSION 61 #define BTA_JV_MAX_RFC_SR_SESSION MAX_BD_CONNECTIONS 62 #endif 63 64 /* BTA_JV_MAX_RFC_SR_SESSION can not be bigger than MAX_BD_CONNECTIONS */ 65 #if (BTA_JV_MAX_RFC_SR_SESSION > MAX_BD_CONNECTIONS) 66 #undef BTA_JV_MAX_RFC_SR_SESSION 67 #define BTA_JV_MAX_RFC_SR_SESSION MAX_BD_CONNECTIONS 68 #endif 69 70 #define BTA_JV_FIRST_SERVICE_ID BTA_FIRST_JV_SERVICE_ID 71 #define BTA_JV_LAST_SERVICE_ID BTA_LAST_JV_SERVICE_ID 72 #define BTA_JV_NUM_SERVICE_ID \ 73 (BTA_LAST_JV_SERVICE_ID - BTA_FIRST_JV_SERVICE_ID + 1) 74 75 /* Discoverable modes */ 76 enum { BTA_JV_DISC_NONE, BTA_JV_DISC_LIMITED, BTA_JV_DISC_GENERAL }; 77 typedef uint16_t tBTA_JV_DISC; 78 79 #define BTA_JV_ROLE_SLAVE BTM_ROLE_SLAVE 80 #define BTA_JV_ROLE_MASTER BTM_ROLE_MASTER 81 typedef uint32_t tBTA_JV_ROLE; 82 83 #define BTA_JV_SERVICE_LMTD_DISCOVER \ 84 BTM_COD_SERVICE_LMTD_DISCOVER /* 0x0020 \ 85 */ 86 #define BTA_JV_SERVICE_POSITIONING BTM_COD_SERVICE_POSITIONING /* 0x0100 */ 87 #define BTA_JV_SERVICE_NETWORKING BTM_COD_SERVICE_NETWORKING /* 0x0200 */ 88 #define BTA_JV_SERVICE_RENDERING BTM_COD_SERVICE_RENDERING /* 0x0400 */ 89 #define BTA_JV_SERVICE_CAPTURING BTM_COD_SERVICE_CAPTURING /* 0x0800 */ 90 #define BTA_JV_SERVICE_OBJ_TRANSFER BTM_COD_SERVICE_OBJ_TRANSFER /* 0x1000 */ 91 #define BTA_JV_SERVICE_AUDIO BTM_COD_SERVICE_AUDIO /* 0x2000 */ 92 #define BTA_JV_SERVICE_TELEPHONY BTM_COD_SERVICE_TELEPHONY /* 0x4000 */ 93 #define BTA_JV_SERVICE_INFORMATION BTM_COD_SERVICE_INFORMATION /* 0x8000 */ 94 95 /* JV ID type */ 96 #define BTA_JV_PM_ID_1 1 /* PM example profile 1 */ 97 #define BTA_JV_PM_ID_2 2 /* PM example profile 2 */ 98 #define BTA_JV_PM_ID_CLEAR 0 /* Special JV ID used to clear PM profile */ 99 #define BTA_JV_PM_ALL 0xFF /* Generic match all id, see bta_dm_cfg.c */ 100 typedef uint8_t tBTA_JV_PM_ID; 101 102 #define BTA_JV_PM_HANDLE_CLEAR \ 103 0xFF /* Special JV ID used to clear PM profile */ 104 105 /* define maximum number of registered PM entities. should be in sync with bta 106 * pm! */ 107 #ifndef BTA_JV_PM_MAX_NUM 108 #define BTA_JV_PM_MAX_NUM 5 109 #endif 110 111 /* JV pm connection states */ 112 enum { 113 BTA_JV_CONN_OPEN = 0, /* Connection opened state */ 114 BTA_JV_CONN_CLOSE, /* Connection closed state */ 115 BTA_JV_APP_OPEN, /* JV Application opened state */ 116 BTA_JV_APP_CLOSE, /* JV Application closed state */ 117 BTA_JV_SCO_OPEN, /* SCO connection opened state */ 118 BTA_JV_SCO_CLOSE, /* SCO connection opened state */ 119 BTA_JV_CONN_IDLE, /* Connection idle state */ 120 BTA_JV_CONN_BUSY, /* Connection busy state */ 121 BTA_JV_MAX_CONN_STATE /* Max number of connection state */ 122 }; 123 typedef uint8_t tBTA_JV_CONN_STATE; 124 125 /* JV Connection types */ 126 #define BTA_JV_CONN_TYPE_RFCOMM 0 127 #define BTA_JV_CONN_TYPE_L2CAP 1 128 #define BTA_JV_CONN_TYPE_L2CAP_LE 2 129 130 /* Java I/F callback events */ 131 /* events received by tBTA_JV_DM_CBACK */ 132 #define BTA_JV_ENABLE_EVT 0 /* JV enabled */ 133 #define BTA_JV_GET_SCN_EVT 6 /* Reserved an SCN */ 134 #define BTA_JV_GET_PSM_EVT 7 /* Reserved a PSM */ 135 #define BTA_JV_DISCOVERY_COMP_EVT 8 /* SDP discovery complete */ 136 #define BTA_JV_CREATE_RECORD_EVT 11 /* the result for BTA_JvCreateRecord */ 137 /* events received by tBTA_JV_L2CAP_CBACK */ 138 #define BTA_JV_L2CAP_OPEN_EVT 16 /* open status of L2CAP connection */ 139 #define BTA_JV_L2CAP_CLOSE_EVT 17 /* L2CAP connection closed */ 140 #define BTA_JV_L2CAP_START_EVT 18 /* L2CAP server started */ 141 #define BTA_JV_L2CAP_CL_INIT_EVT 19 /* L2CAP client initiated a connection */ 142 #define BTA_JV_L2CAP_DATA_IND_EVT 20 /* L2CAP connection received data */ 143 #define BTA_JV_L2CAP_CONG_EVT \ 144 21 /* L2CAP connection congestion status changed */ 145 #define BTA_JV_L2CAP_READ_EVT 22 /* the result for BTA_JvL2capRead */ 146 #define BTA_JV_L2CAP_WRITE_EVT 24 /* the result for BTA_JvL2capWrite*/ 147 #define BTA_JV_L2CAP_WRITE_FIXED_EVT \ 148 25 /* the result for BTA_JvL2capWriteFixed */ 149 150 /* events received by tBTA_JV_RFCOMM_CBACK */ 151 #define BTA_JV_RFCOMM_OPEN_EVT \ 152 26 /* open status of RFCOMM Client connection \ 153 */ 154 #define BTA_JV_RFCOMM_CLOSE_EVT 27 /* RFCOMM connection closed */ 155 #define BTA_JV_RFCOMM_START_EVT 28 /* RFCOMM server started */ 156 #define BTA_JV_RFCOMM_CL_INIT_EVT \ 157 29 /* RFCOMM client initiated a connection \ 158 */ 159 #define BTA_JV_RFCOMM_DATA_IND_EVT 30 /* RFCOMM connection received data */ 160 #define BTA_JV_RFCOMM_CONG_EVT \ 161 31 /* RFCOMM connection congestion status changed */ 162 #define BTA_JV_RFCOMM_WRITE_EVT 33 /* the result for BTA_JvRfcommWrite*/ 163 #define BTA_JV_RFCOMM_SRV_OPEN_EVT \ 164 34 /* open status of Server RFCOMM connection */ 165 #define BTA_JV_MAX_EVT 35 /* max number of JV events */ 166 167 typedef uint16_t tBTA_JV_EVT; 168 169 /* data associated with BTA_JV_SET_DISCOVER_EVT */ 170 typedef struct { 171 tBTA_JV_STATUS status; /* Whether the operation succeeded or failed. */ 172 tBTA_JV_DISC disc_mode; /* The current discoverable mode */ 173 } tBTA_JV_SET_DISCOVER; 174 175 /* data associated with BTA_JV_DISCOVERY_COMP_EVT_ */ 176 typedef struct { 177 tBTA_JV_STATUS status; /* Whether the operation succeeded or failed. */ 178 int scn; /* channel # */ 179 } tBTA_JV_DISCOVERY_COMP; 180 181 /* data associated with BTA_JV_CREATE_RECORD_EVT */ 182 typedef struct { 183 tBTA_JV_STATUS status; /* Whether the operation succeeded or failed. */ 184 } tBTA_JV_CREATE_RECORD; 185 186 /* data associated with BTA_JV_L2CAP_OPEN_EVT */ 187 typedef struct { 188 tBTA_JV_STATUS status; /* Whether the operation succeeded or failed. */ 189 uint32_t handle; /* The connection handle */ 190 RawAddress rem_bda; /* The peer address */ 191 int32_t tx_mtu; /* The transmit MTU */ 192 } tBTA_JV_L2CAP_OPEN; 193 194 /* data associated with BTA_JV_L2CAP_OPEN_EVT for LE sockets */ 195 typedef struct { 196 tBTA_JV_STATUS status; /* Whether the operation succeeded or failed. */ 197 uint32_t handle; /* The connection handle */ 198 RawAddress rem_bda; /* The peer address */ 199 int32_t tx_mtu; /* The transmit MTU */ 200 void** p_p_cback; /* set them for new socket */ 201 void** p_user_data; /* set them for new socket */ 202 203 } tBTA_JV_L2CAP_LE_OPEN; 204 205 /* data associated with BTA_JV_L2CAP_CLOSE_EVT */ 206 typedef struct { 207 tBTA_JV_STATUS status; /* Whether the operation succeeded or failed. */ 208 uint32_t handle; /* The connection handle */ 209 bool async; /* false, if local initiates disconnect */ 210 } tBTA_JV_L2CAP_CLOSE; 211 212 /* data associated with BTA_JV_L2CAP_START_EVT */ 213 typedef struct { 214 tBTA_JV_STATUS status; /* Whether the operation succeeded or failed. */ 215 uint32_t handle; /* The connection handle */ 216 uint8_t sec_id; /* security ID used by this server */ 217 } tBTA_JV_L2CAP_START; 218 219 /* data associated with BTA_JV_L2CAP_CL_INIT_EVT */ 220 typedef struct { 221 tBTA_JV_STATUS status; /* Whether the operation succeeded or failed. */ 222 uint32_t handle; /* The connection handle */ 223 uint8_t sec_id; /* security ID used by this client */ 224 } tBTA_JV_L2CAP_CL_INIT; 225 226 /* data associated with BTA_JV_L2CAP_CONG_EVT */ 227 typedef struct { 228 tBTA_JV_STATUS status; /* Whether the operation succeeded or failed. */ 229 uint32_t handle; /* The connection handle */ 230 bool cong; /* true, congested. false, uncongested */ 231 } tBTA_JV_L2CAP_CONG; 232 233 /* data associated with BTA_JV_L2CAP_READ_EVT */ 234 typedef struct { 235 tBTA_JV_STATUS status; /* Whether the operation succeeded or failed. */ 236 uint32_t handle; /* The connection handle */ 237 uint32_t req_id; /* The req_id in the associated BTA_JvL2capRead() */ 238 uint8_t* p_data; /* This points the same location as the p_data 239 * parameter in BTA_JvL2capRead () */ 240 uint16_t len; /* The length of the data read. */ 241 } tBTA_JV_L2CAP_READ; 242 243 /* data associated with BTA_JV_L2CAP_WRITE_EVT */ 244 typedef struct { 245 tBTA_JV_STATUS status; /* Whether the operation succeeded or failed. */ 246 uint32_t handle; /* The connection handle */ 247 uint32_t req_id; /* The req_id in the associated BTA_JvL2capWrite() */ 248 uint16_t len; /* The length of the data written. */ 249 bool cong; /* congestion status */ 250 } tBTA_JV_L2CAP_WRITE; 251 252 /* data associated with BTA_JV_L2CAP_WRITE_FIXED_EVT */ 253 typedef struct { 254 tBTA_JV_STATUS status; /* Whether the operation succeeded or failed. */ 255 uint16_t channel; /* The connection channel */ 256 RawAddress addr; /* The peer address */ 257 uint32_t req_id; /* The req_id in the associated BTA_JvL2capWrite() */ 258 uint16_t len; /* The length of the data written. */ 259 bool cong; /* congestion status */ 260 } tBTA_JV_L2CAP_WRITE_FIXED; 261 262 /* data associated with BTA_JV_RFCOMM_OPEN_EVT */ 263 typedef struct { 264 tBTA_JV_STATUS status; /* Whether the operation succeeded or failed. */ 265 uint32_t handle; /* The connection handle */ 266 RawAddress rem_bda; /* The peer address */ 267 } tBTA_JV_RFCOMM_OPEN; 268 /* data associated with BTA_JV_RFCOMM_SRV_OPEN_EVT */ 269 typedef struct { 270 tBTA_JV_STATUS status; /* Whether the operation succeeded or failed. */ 271 uint32_t handle; /* The connection handle */ 272 uint32_t new_listen_handle; /* The new listen handle */ 273 RawAddress rem_bda; /* The peer address */ 274 } tBTA_JV_RFCOMM_SRV_OPEN; 275 276 /* data associated with BTA_JV_RFCOMM_CLOSE_EVT */ 277 typedef struct { 278 tBTA_JV_STATUS status; /* Whether the operation succeeded or failed. */ 279 uint32_t port_status; /* PORT status */ 280 uint32_t handle; /* The connection handle */ 281 bool async; /* false, if local initiates disconnect */ 282 } tBTA_JV_RFCOMM_CLOSE; 283 284 /* data associated with BTA_JV_RFCOMM_START_EVT */ 285 typedef struct { 286 tBTA_JV_STATUS status; /* Whether the operation succeeded or failed. */ 287 uint32_t handle; /* The connection handle */ 288 uint8_t sec_id; /* security ID used by this server */ 289 bool use_co; /* true to use co_rfc_data */ 290 } tBTA_JV_RFCOMM_START; 291 292 /* data associated with BTA_JV_RFCOMM_CL_INIT_EVT */ 293 typedef struct { 294 tBTA_JV_STATUS status; /* Whether the operation succeeded or failed. */ 295 uint32_t handle; /* The connection handle */ 296 uint8_t sec_id; /* security ID used by this client */ 297 bool use_co; /* true to use co_rfc_data */ 298 } tBTA_JV_RFCOMM_CL_INIT; 299 /*data associated with BTA_JV_L2CAP_DATA_IND_EVT & BTA_JV_RFCOMM_DATA_IND_EVT */ 300 typedef struct { 301 uint32_t handle; /* The connection handle */ 302 } tBTA_JV_DATA_IND; 303 304 /*data associated with BTA_JV_L2CAP_DATA_IND_EVT if used for LE */ 305 typedef struct { 306 uint32_t handle; /* The connection handle */ 307 BT_HDR* p_buf; /* The incoming data */ 308 } tBTA_JV_LE_DATA_IND; 309 310 /* data associated with BTA_JV_RFCOMM_CONG_EVT */ 311 typedef struct { 312 tBTA_JV_STATUS status; /* Whether the operation succeeded or failed. */ 313 uint32_t handle; /* The connection handle */ 314 bool cong; /* true, congested. false, uncongested */ 315 } tBTA_JV_RFCOMM_CONG; 316 317 /* data associated with BTA_JV_RFCOMM_WRITE_EVT */ 318 typedef struct { 319 tBTA_JV_STATUS status; /* Whether the operation succeeded or failed. */ 320 uint32_t handle; /* The connection handle */ 321 uint32_t req_id; /* The req_id in the associated BTA_JvRfcommWrite() */ 322 int len; /* The length of the data written. */ 323 bool cong; /* congestion status */ 324 } tBTA_JV_RFCOMM_WRITE; 325 326 /* data associated with BTA_JV_API_SET_PM_PROFILE_EVT */ 327 typedef struct { 328 tBTA_JV_STATUS status; /* Status of the operation */ 329 uint32_t handle; /* Connection handle */ 330 tBTA_JV_PM_ID app_id; /* JV app ID */ 331 } tBTA_JV_SET_PM_PROFILE; 332 333 /* data associated with BTA_JV_API_NOTIFY_PM_STATE_CHANGE_EVT */ 334 typedef struct { 335 uint32_t handle; /* Connection handle */ 336 tBTA_JV_CONN_STATE state; /* JV connection stata */ 337 } tBTA_JV_NOTIFY_PM_STATE_CHANGE; 338 339 /* union of data associated with JV callback */ 340 typedef union { 341 tBTA_JV_STATUS status; /* BTA_JV_ENABLE_EVT */ 342 tBTA_JV_DISCOVERY_COMP disc_comp; /* BTA_JV_DISCOVERY_COMP_EVT */ 343 tBTA_JV_SET_DISCOVER set_discover; /* BTA_JV_SET_DISCOVER_EVT */ 344 uint8_t scn; /* BTA_JV_GET_SCN_EVT */ 345 uint16_t psm; /* BTA_JV_GET_PSM_EVT */ 346 tBTA_JV_CREATE_RECORD create_rec; /* BTA_JV_CREATE_RECORD_EVT */ 347 tBTA_JV_L2CAP_OPEN l2c_open; /* BTA_JV_L2CAP_OPEN_EVT */ 348 tBTA_JV_L2CAP_CLOSE l2c_close; /* BTA_JV_L2CAP_CLOSE_EVT */ 349 tBTA_JV_L2CAP_START l2c_start; /* BTA_JV_L2CAP_START_EVT */ 350 tBTA_JV_L2CAP_CL_INIT l2c_cl_init; /* BTA_JV_L2CAP_CL_INIT_EVT */ 351 tBTA_JV_L2CAP_CONG l2c_cong; /* BTA_JV_L2CAP_CONG_EVT */ 352 tBTA_JV_L2CAP_READ l2c_read; /* BTA_JV_L2CAP_READ_EVT */ 353 tBTA_JV_L2CAP_WRITE l2c_write; /* BTA_JV_L2CAP_WRITE_EVT */ 354 tBTA_JV_RFCOMM_OPEN rfc_open; /* BTA_JV_RFCOMM_OPEN_EVT */ 355 tBTA_JV_RFCOMM_SRV_OPEN rfc_srv_open; /* BTA_JV_RFCOMM_SRV_OPEN_EVT */ 356 tBTA_JV_RFCOMM_CLOSE rfc_close; /* BTA_JV_RFCOMM_CLOSE_EVT */ 357 tBTA_JV_RFCOMM_START rfc_start; /* BTA_JV_RFCOMM_START_EVT */ 358 tBTA_JV_RFCOMM_CL_INIT rfc_cl_init; /* BTA_JV_RFCOMM_CL_INIT_EVT */ 359 tBTA_JV_RFCOMM_CONG rfc_cong; /* BTA_JV_RFCOMM_CONG_EVT */ 360 tBTA_JV_RFCOMM_WRITE rfc_write; /* BTA_JV_RFCOMM_WRITE_EVT */ 361 tBTA_JV_DATA_IND data_ind; /* BTA_JV_L2CAP_DATA_IND_EVT 362 BTA_JV_RFCOMM_DATA_IND_EVT */ 363 tBTA_JV_LE_DATA_IND le_data_ind; /* BTA_JV_L2CAP_LE_DATA_IND_EVT */ 364 tBTA_JV_L2CAP_LE_OPEN l2c_le_open; /* BTA_JV_L2CAP_OPEN_EVT */ 365 tBTA_JV_L2CAP_WRITE_FIXED l2c_write_fixed; /* BTA_JV_L2CAP_WRITE_FIXED_EVT */ 366 } tBTA_JV; 367 368 /* JAVA DM Interface callback */ 369 typedef void(tBTA_JV_DM_CBACK)(tBTA_JV_EVT event, tBTA_JV* p_data, uint32_t id); 370 371 /* JAVA RFCOMM interface callback */ 372 typedef uint32_t(tBTA_JV_RFCOMM_CBACK)(tBTA_JV_EVT event, tBTA_JV* p_data, 373 uint32_t rfcomm_slot_id); 374 375 /* JAVA L2CAP interface callback */ 376 typedef void(tBTA_JV_L2CAP_CBACK)(tBTA_JV_EVT event, tBTA_JV* p_data, 377 uint32_t l2cap_socket_id); 378 379 /* JV configuration structure */ 380 typedef struct { 381 uint16_t sdp_raw_size; /* The size of p_sdp_raw_data */ 382 uint16_t sdp_db_size; /* The size of p_sdp_db */ 383 uint8_t* p_sdp_raw_data; /* The data buffer to keep raw data */ 384 tSDP_DISCOVERY_DB* p_sdp_db; /* The data buffer to keep SDP database */ 385 } tBTA_JV_CFG; 386 387 /******************************************************************************* 388 * 389 * Function BTA_JvEnable 390 * 391 * Description Enable the Java I/F service. When the enable 392 * operation is complete the callback function will be 393 * called with a BTA_JV_ENABLE_EVT. This function must 394 * be called before other functions in the JV API are 395 * called. 396 * 397 * Returns BTA_JV_SUCCESS if successful. 398 * BTA_JV_FAIL if internal failure. 399 * 400 ******************************************************************************/ 401 tBTA_JV_STATUS BTA_JvEnable(tBTA_JV_DM_CBACK* p_cback); 402 403 /******************************************************************************* 404 * 405 * Function BTA_JvDisable 406 * 407 * Description Disable the Java I/F 408 * 409 * Returns void 410 * 411 ******************************************************************************/ 412 void BTA_JvDisable(void); 413 414 /******************************************************************************* 415 * 416 * Function BTA_JvIsEncrypted 417 * 418 * Description This function checks if the link to peer device is encrypted 419 * 420 * Returns true if encrypted. 421 * false if not. 422 * 423 ******************************************************************************/ 424 bool BTA_JvIsEncrypted(const RawAddress& bd_addr); 425 426 /******************************************************************************* 427 * 428 * Function BTA_JvGetChannelId 429 * 430 * Description This function reserves a SCN/PSM for applications running 431 * over RFCOMM or L2CAP. It is primarily called by 432 * server profiles/applications to register their SCN/PSM into 433 * the SDP database. The SCN is reported by the 434 * tBTA_JV_DM_CBACK callback with a BTA_JV_GET_SCN_EVT. 435 * If the SCN/PSM reported is 0, that means all SCN resources 436 * are exhausted. 437 * The channel parameter can be used to request a specific 438 * channel. If the request on the specific channel fails, the 439 * SCN/PSM returned in the EVT will be 0 - no attempt to 440 * request a new channel will be made. set channel to <= 0 to 441 * automatically assign an channel ID. 442 * 443 * Returns void 444 * 445 ******************************************************************************/ 446 void BTA_JvGetChannelId(int conn_type, uint32_t id, int32_t channel); 447 448 /******************************************************************************* 449 * 450 * Function BTA_JvFreeChannel 451 * 452 * Description This function frees a SCN/PSM that was used 453 * by an application running over RFCOMM or L2CAP. 454 * 455 * Returns BTA_JV_SUCCESS, if the request is being processed. 456 * BTA_JV_FAILURE, otherwise. 457 * 458 ******************************************************************************/ 459 tBTA_JV_STATUS BTA_JvFreeChannel(uint16_t channel, int conn_type); 460 461 /******************************************************************************* 462 * 463 * Function BTA_JvStartDiscovery 464 * 465 * Description This function performs service discovery for the services 466 * provided by the given peer device. When the operation is 467 * complete the tBTA_JV_DM_CBACK callback function will be 468 * called with a BTA_JV_DISCOVERY_COMP_EVT. 469 * 470 * Returns BTA_JV_SUCCESS, if the request is being processed. 471 * BTA_JV_FAILURE, otherwise. 472 * 473 ******************************************************************************/ 474 tBTA_JV_STATUS BTA_JvStartDiscovery(const RawAddress& bd_addr, 475 uint16_t num_uuid, 476 const bluetooth::Uuid* p_uuid_list, 477 uint32_t rfcomm_slot_id); 478 479 /******************************************************************************* 480 * 481 * Function BTA_JvCreateRecordByUser 482 * 483 * Description Create a service record in the local SDP database by user in 484 * tBTA_JV_DM_CBACK callback with a BTA_JV_CREATE_RECORD_EVT. 485 * 486 * Returns BTA_JV_SUCCESS, if the request is being processed. 487 * BTA_JV_FAILURE, otherwise. 488 * 489 ******************************************************************************/ 490 tBTA_JV_STATUS BTA_JvCreateRecordByUser(uint32_t rfcomm_slot_id); 491 492 /******************************************************************************* 493 * 494 * Function BTA_JvDeleteRecord 495 * 496 * Description Delete a service record in the local SDP database. 497 * 498 * Returns BTA_JV_SUCCESS, if the request is being processed. 499 * BTA_JV_FAILURE, otherwise. 500 * 501 ******************************************************************************/ 502 tBTA_JV_STATUS BTA_JvDeleteRecord(uint32_t handle); 503 504 /******************************************************************************* 505 * 506 * Function BTA_JvL2capConnectLE 507 * 508 * Description Initiate a connection as an LE L2CAP client to the given BD 509 * Address. 510 * When the connection is initiated or failed to initiate, 511 * tBTA_JV_L2CAP_CBACK is called with BTA_JV_L2CAP_CL_INIT_EVT 512 * When the connection is established or failed, 513 * tBTA_JV_L2CAP_CBACK is called with BTA_JV_L2CAP_OPEN_EVT 514 * 515 ******************************************************************************/ 516 void BTA_JvL2capConnectLE(uint16_t remote_chan, const RawAddress& peer_bd_addr, 517 tBTA_JV_L2CAP_CBACK* p_cback, 518 uint32_t l2cap_socket_id); 519 520 /******************************************************************************* 521 * 522 * Function BTA_JvL2capConnect 523 * 524 * Description Initiate a connection as a L2CAP client to the given BD 525 * Address. 526 * When the connection is initiated or failed to initiate, 527 * tBTA_JV_L2CAP_CBACK is called with BTA_JV_L2CAP_CL_INIT_EVT 528 * When the connection is established or failed, 529 * tBTA_JV_L2CAP_CBACK is called with BTA_JV_L2CAP_OPEN_EVT 530 * 531 ******************************************************************************/ 532 void BTA_JvL2capConnect(int conn_type, tBTA_SEC sec_mask, tBTA_JV_ROLE role, 533 std::unique_ptr<tL2CAP_ERTM_INFO> ertm_info, 534 uint16_t remote_psm, uint16_t rx_mtu, 535 std::unique_ptr<tL2CAP_CFG_INFO> cfg, 536 const RawAddress& peer_bd_addr, 537 tBTA_JV_L2CAP_CBACK* p_cback, uint32_t l2cap_socket_id); 538 539 /******************************************************************************* 540 * 541 * Function BTA_JvL2capClose 542 * 543 * Description This function closes an L2CAP client connection 544 * 545 * Returns BTA_JV_SUCCESS, if the request is being processed. 546 * BTA_JV_FAILURE, otherwise. 547 * 548 ******************************************************************************/ 549 tBTA_JV_STATUS BTA_JvL2capClose(uint32_t handle); 550 551 /******************************************************************************* 552 * 553 * Function BTA_JvL2capCloseLE 554 * 555 * Description This function closes an L2CAP client connection for Fixed 556 * Channels Function is idempotent and no callbacks are called! 557 * 558 * Returns BTA_JV_SUCCESS, if the request is being processed. 559 * BTA_JV_FAILURE, otherwise. 560 * 561 ******************************************************************************/ 562 tBTA_JV_STATUS BTA_JvL2capCloseLE(uint32_t handle); 563 564 /******************************************************************************* 565 * 566 * Function BTA_JvL2capStartServer 567 * 568 * Description This function starts an L2CAP server and listens for an 569 * L2CAP connection from a remote Bluetooth device. When the 570 * server is started successfully, tBTA_JV_L2CAP_CBACK is 571 * called with BTA_JV_L2CAP_START_EVT. When the connection is 572 * established, tBTA_JV_L2CAP_CBACK is called with 573 * BTA_JV_L2CAP_OPEN_EVT. 574 * 575 * Returns void 576 * 577 ******************************************************************************/ 578 void BTA_JvL2capStartServer(int conn_type, tBTA_SEC sec_mask, tBTA_JV_ROLE role, 579 std::unique_ptr<tL2CAP_ERTM_INFO> ertm_info, 580 uint16_t local_psm, uint16_t rx_mtu, 581 std::unique_ptr<tL2CAP_CFG_INFO> cfg, 582 tBTA_JV_L2CAP_CBACK* p_cback, 583 uint32_t l2cap_socket_id); 584 585 /******************************************************************************* 586 * 587 * Function BTA_JvL2capStartServerLE 588 * 589 * Description This function starts an LE L2CAP server and listens for an 590 * L2CAP connection from a remote Bluetooth device on a fixed 591 * channel over an LE link. When the server 592 * is started successfully, tBTA_JV_L2CAP_CBACK is called with 593 * BTA_JV_L2CAP_START_EVT. When the connection is established, 594 * tBTA_JV_L2CAP_CBACK is called with BTA_JV_L2CAP_OPEN_EVT. 595 * 596 * Returns void 597 * 598 ******************************************************************************/ 599 void BTA_JvL2capStartServerLE(uint16_t local_chan, tBTA_JV_L2CAP_CBACK* p_cback, 600 uint32_t l2cap_socket_id); 601 602 /******************************************************************************* 603 * 604 * Function BTA_JvL2capStopServerLE 605 * 606 * Description This function stops the LE L2CAP server. If the server has 607 * an active connection, it would be closed. 608 * 609 * Returns BTA_JV_SUCCESS, if the request is being processed. 610 * BTA_JV_FAILURE, otherwise. 611 * 612 ******************************************************************************/ 613 tBTA_JV_STATUS BTA_JvL2capStopServerLE(uint16_t local_chan, 614 uint32_t l2cap_socket_id); 615 616 /******************************************************************************* 617 * 618 * Function BTA_JvL2capStopServer 619 * 620 * Description This function stops the L2CAP server. If the server has 621 * an active connection, it would be closed. 622 * 623 * Returns BTA_JV_SUCCESS, if the request is being processed. 624 * BTA_JV_FAILURE, otherwise. 625 * 626 ******************************************************************************/ 627 tBTA_JV_STATUS BTA_JvL2capStopServer(uint16_t local_psm, 628 uint32_t l2cap_socket_id); 629 630 /******************************************************************************* 631 * 632 * Function BTA_JvL2capRead 633 * 634 * Description This function reads data from an L2CAP connection 635 * When the operation is complete, tBTA_JV_L2CAP_CBACK is 636 * called with BTA_JV_L2CAP_READ_EVT. 637 * 638 * Returns BTA_JV_SUCCESS, if the request is being processed. 639 * BTA_JV_FAILURE, otherwise. 640 * 641 ******************************************************************************/ 642 tBTA_JV_STATUS BTA_JvL2capRead(uint32_t handle, uint32_t req_id, 643 uint8_t* p_data, uint16_t len); 644 645 /******************************************************************************* 646 * 647 * Function BTA_JvL2capReady 648 * 649 * Description This function determined if there is data to read from 650 * an L2CAP connection 651 * 652 * Returns BTA_JV_SUCCESS, if data queue size is in *p_data_size. 653 * BTA_JV_FAILURE, if error. 654 * 655 ******************************************************************************/ 656 tBTA_JV_STATUS BTA_JvL2capReady(uint32_t handle, uint32_t* p_data_size); 657 658 /******************************************************************************* 659 * 660 * Function BTA_JvL2capWrite 661 * 662 * Description This function writes data to an L2CAP connection 663 * When the operation is complete, tBTA_JV_L2CAP_CBACK is 664 * called with BTA_JV_L2CAP_WRITE_EVT. Works for 665 * PSM-based connections 666 * 667 * Returns BTA_JV_SUCCESS, if the request is being processed. 668 * BTA_JV_FAILURE, otherwise. 669 * 670 ******************************************************************************/ 671 tBTA_JV_STATUS BTA_JvL2capWrite(uint32_t handle, uint32_t req_id, BT_HDR* msg, 672 uint32_t user_id); 673 674 /******************************************************************************* 675 * 676 * Function BTA_JvL2capWriteFixed 677 * 678 * Description This function writes data to an L2CAP connection 679 * When the operation is complete, tBTA_JV_L2CAP_CBACK is 680 * called with BTA_JV_L2CAP_WRITE_FIXED_EVT. Works for 681 * fixed-channel connections 682 * 683 ******************************************************************************/ 684 void BTA_JvL2capWriteFixed(uint16_t channel, const RawAddress& addr, 685 uint32_t req_id, tBTA_JV_L2CAP_CBACK* p_cback, 686 BT_HDR* msg, uint32_t user_id); 687 688 /******************************************************************************* 689 * 690 * Function BTA_JvRfcommConnect 691 * 692 * Description This function makes an RFCOMM conection to a remote BD 693 * Address. 694 * When the connection is initiated or failed to initiate, 695 * tBTA_JV_RFCOMM_CBACK is called with 696 * BTA_JV_RFCOMM_CL_INIT_EVT 697 * When the connection is established or failed, 698 * tBTA_JV_RFCOMM_CBACK is called with BTA_JV_RFCOMM_OPEN_EVT 699 * 700 * Returns BTA_JV_SUCCESS, if the request is being processed. 701 * BTA_JV_FAILURE, otherwise. 702 * 703 ******************************************************************************/ 704 tBTA_JV_STATUS BTA_JvRfcommConnect(tBTA_SEC sec_mask, tBTA_JV_ROLE role, 705 uint8_t remote_scn, 706 const RawAddress& peer_bd_addr, 707 tBTA_JV_RFCOMM_CBACK* p_cback, 708 uint32_t rfcomm_slot_id); 709 710 /******************************************************************************* 711 * 712 * Function BTA_JvRfcommClose 713 * 714 * Description This function closes an RFCOMM connection 715 * 716 * Returns BTA_JV_SUCCESS, if the request is being processed. 717 * BTA_JV_FAILURE, otherwise. 718 * 719 ******************************************************************************/ 720 tBTA_JV_STATUS BTA_JvRfcommClose(uint32_t handle, uint32_t rfcomm_slot_id); 721 722 /******************************************************************************* 723 * 724 * Function BTA_JvRfcommStartServer 725 * 726 * Description This function starts listening for an RFCOMM connection 727 * request from a remote Bluetooth device. When the server is 728 * started successfully, tBTA_JV_RFCOMM_CBACK is called 729 * with BTA_JV_RFCOMM_START_EVT. 730 * When the connection is established, tBTA_JV_RFCOMM_CBACK 731 * is called with BTA_JV_RFCOMM_OPEN_EVT. 732 * 733 * Returns BTA_JV_SUCCESS, if the request is being processed. 734 * BTA_JV_FAILURE, otherwise. 735 * 736 ******************************************************************************/ 737 tBTA_JV_STATUS BTA_JvRfcommStartServer(tBTA_SEC sec_mask, tBTA_JV_ROLE role, 738 uint8_t local_scn, uint8_t max_session, 739 tBTA_JV_RFCOMM_CBACK* p_cback, 740 uint32_t rfcomm_slot_id); 741 742 /******************************************************************************* 743 * 744 * Function BTA_JvRfcommStopServer 745 * 746 * Description This function stops the RFCOMM server. If the server has an 747 * active connection, it would be closed. 748 * 749 * Returns BTA_JV_SUCCESS, if the request is being processed. 750 * BTA_JV_FAILURE, otherwise. 751 * 752 ******************************************************************************/ 753 tBTA_JV_STATUS BTA_JvRfcommStopServer(uint32_t handle, uint32_t rfcomm_slot_id); 754 755 /******************************************************************************* 756 * 757 * Function BTA_JvRfcommWrite 758 * 759 * Description This function writes data to an RFCOMM connection 760 * When the operation is complete, tBTA_JV_RFCOMM_CBACK is 761 * called with BTA_JV_RFCOMM_WRITE_EVT. 762 * 763 * Returns BTA_JV_SUCCESS, if the request is being processed. 764 * BTA_JV_FAILURE, otherwise. 765 * 766 ******************************************************************************/ 767 tBTA_JV_STATUS BTA_JvRfcommWrite(uint32_t handle, uint32_t req_id); 768 769 /******************************************************************************* 770 * 771 * Function BTA_JVSetPmProfile 772 * 773 * Description This function set or free power mode profile for different JV 774 * application 775 * 776 * Parameters: handle, JV handle from RFCOMM or L2CAP 777 * app_id: app specific pm ID, can be BTA_JV_PM_ALL, see 778 * bta_dm_cfg.c for details 779 * BTA_JV_PM_ID_CLEAR: removes pm management on the handle. init_st 780 * is ignored and BTA_JV_CONN_CLOSE is called 781 * implicitly 782 * init_st: state after calling this API. typically it should be 783 * BTA_JV_CONN_OPEN 784 * 785 * Returns BTA_JV_SUCCESS, if the request is being processed. 786 * BTA_JV_FAILURE, otherwise. 787 * 788 * NOTE: BTA_JV_PM_ID_CLEAR: In general no need to be called as jv pm 789 * calls automatically 790 * BTA_JV_CONN_CLOSE to remove in case of connection close! 791 * 792 ******************************************************************************/ 793 tBTA_JV_STATUS BTA_JvSetPmProfile(uint32_t handle, tBTA_JV_PM_ID app_id, 794 tBTA_JV_CONN_STATE init_st); 795 796 /******************************************************************************* 797 * 798 * Function BTA_JvRfcommGetPortHdl 799 * 800 * Description This function fetches the rfcomm port handle 801 * 802 * Returns BTA_JV_SUCCESS, if the request is being processed. 803 * BTA_JV_FAILURE, otherwise. 804 * 805 ******************************************************************************/ 806 uint16_t BTA_JvRfcommGetPortHdl(uint32_t handle); 807 808 #endif /* BTA_JV_API_H */ 809