1 /****************************************************************************** 2 * 3 * Copyright (C) 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 uint8_t* p_data; /* The buffer where data is held */ 250 bool cong; /* congestion status */ 251 } tBTA_JV_L2CAP_WRITE; 252 253 /* data associated with BTA_JV_L2CAP_WRITE_FIXED_EVT */ 254 typedef struct { 255 tBTA_JV_STATUS status; /* Whether the operation succeeded or failed. */ 256 uint16_t channel; /* The connection channel */ 257 RawAddress addr; /* The peer address */ 258 uint32_t req_id; /* The req_id in the associated BTA_JvL2capWrite() */ 259 uint8_t* p_data; /* The buffer where data is held */ 260 uint16_t len; /* The length of the data written. */ 261 bool cong; /* congestion status */ 262 } tBTA_JV_L2CAP_WRITE_FIXED; 263 264 /* data associated with BTA_JV_RFCOMM_OPEN_EVT */ 265 typedef struct { 266 tBTA_JV_STATUS status; /* Whether the operation succeeded or failed. */ 267 uint32_t handle; /* The connection handle */ 268 RawAddress rem_bda; /* The peer address */ 269 } tBTA_JV_RFCOMM_OPEN; 270 /* data associated with BTA_JV_RFCOMM_SRV_OPEN_EVT */ 271 typedef struct { 272 tBTA_JV_STATUS status; /* Whether the operation succeeded or failed. */ 273 uint32_t handle; /* The connection handle */ 274 uint32_t new_listen_handle; /* The new listen handle */ 275 RawAddress rem_bda; /* The peer address */ 276 } tBTA_JV_RFCOMM_SRV_OPEN; 277 278 /* data associated with BTA_JV_RFCOMM_CLOSE_EVT */ 279 typedef struct { 280 tBTA_JV_STATUS status; /* Whether the operation succeeded or failed. */ 281 uint32_t port_status; /* PORT status */ 282 uint32_t handle; /* The connection handle */ 283 bool async; /* false, if local initiates disconnect */ 284 } tBTA_JV_RFCOMM_CLOSE; 285 286 /* data associated with BTA_JV_RFCOMM_START_EVT */ 287 typedef struct { 288 tBTA_JV_STATUS status; /* Whether the operation succeeded or failed. */ 289 uint32_t handle; /* The connection handle */ 290 uint8_t sec_id; /* security ID used by this server */ 291 bool use_co; /* true to use co_rfc_data */ 292 } tBTA_JV_RFCOMM_START; 293 294 /* data associated with BTA_JV_RFCOMM_CL_INIT_EVT */ 295 typedef struct { 296 tBTA_JV_STATUS status; /* Whether the operation succeeded or failed. */ 297 uint32_t handle; /* The connection handle */ 298 uint8_t sec_id; /* security ID used by this client */ 299 bool use_co; /* true to use co_rfc_data */ 300 } tBTA_JV_RFCOMM_CL_INIT; 301 /*data associated with BTA_JV_L2CAP_DATA_IND_EVT & BTA_JV_RFCOMM_DATA_IND_EVT */ 302 typedef struct { 303 uint32_t handle; /* The connection handle */ 304 } tBTA_JV_DATA_IND; 305 306 /*data associated with BTA_JV_L2CAP_DATA_IND_EVT if used for LE */ 307 typedef struct { 308 uint32_t handle; /* The connection handle */ 309 BT_HDR* p_buf; /* The incoming data */ 310 } tBTA_JV_LE_DATA_IND; 311 312 /* data associated with BTA_JV_RFCOMM_CONG_EVT */ 313 typedef struct { 314 tBTA_JV_STATUS status; /* Whether the operation succeeded or failed. */ 315 uint32_t handle; /* The connection handle */ 316 bool cong; /* true, congested. false, uncongested */ 317 } tBTA_JV_RFCOMM_CONG; 318 319 /* data associated with BTA_JV_RFCOMM_WRITE_EVT */ 320 typedef struct { 321 tBTA_JV_STATUS status; /* Whether the operation succeeded or failed. */ 322 uint32_t handle; /* The connection handle */ 323 uint32_t req_id; /* The req_id in the associated BTA_JvRfcommWrite() */ 324 int len; /* The length of the data written. */ 325 bool cong; /* congestion status */ 326 } tBTA_JV_RFCOMM_WRITE; 327 328 /* data associated with BTA_JV_API_SET_PM_PROFILE_EVT */ 329 typedef struct { 330 tBTA_JV_STATUS status; /* Status of the operation */ 331 uint32_t handle; /* Connection handle */ 332 tBTA_JV_PM_ID app_id; /* JV app ID */ 333 } tBTA_JV_SET_PM_PROFILE; 334 335 /* data associated with BTA_JV_API_NOTIFY_PM_STATE_CHANGE_EVT */ 336 typedef struct { 337 uint32_t handle; /* Connection handle */ 338 tBTA_JV_CONN_STATE state; /* JV connection stata */ 339 } tBTA_JV_NOTIFY_PM_STATE_CHANGE; 340 341 /* union of data associated with JV callback */ 342 typedef union { 343 tBTA_JV_STATUS status; /* BTA_JV_ENABLE_EVT */ 344 tBTA_JV_DISCOVERY_COMP disc_comp; /* BTA_JV_DISCOVERY_COMP_EVT */ 345 tBTA_JV_SET_DISCOVER set_discover; /* BTA_JV_SET_DISCOVER_EVT */ 346 uint8_t scn; /* BTA_JV_GET_SCN_EVT */ 347 uint16_t psm; /* BTA_JV_GET_PSM_EVT */ 348 tBTA_JV_CREATE_RECORD create_rec; /* BTA_JV_CREATE_RECORD_EVT */ 349 tBTA_JV_L2CAP_OPEN l2c_open; /* BTA_JV_L2CAP_OPEN_EVT */ 350 tBTA_JV_L2CAP_CLOSE l2c_close; /* BTA_JV_L2CAP_CLOSE_EVT */ 351 tBTA_JV_L2CAP_START l2c_start; /* BTA_JV_L2CAP_START_EVT */ 352 tBTA_JV_L2CAP_CL_INIT l2c_cl_init; /* BTA_JV_L2CAP_CL_INIT_EVT */ 353 tBTA_JV_L2CAP_CONG l2c_cong; /* BTA_JV_L2CAP_CONG_EVT */ 354 tBTA_JV_L2CAP_READ l2c_read; /* BTA_JV_L2CAP_READ_EVT */ 355 tBTA_JV_L2CAP_WRITE l2c_write; /* BTA_JV_L2CAP_WRITE_EVT */ 356 tBTA_JV_RFCOMM_OPEN rfc_open; /* BTA_JV_RFCOMM_OPEN_EVT */ 357 tBTA_JV_RFCOMM_SRV_OPEN rfc_srv_open; /* BTA_JV_RFCOMM_SRV_OPEN_EVT */ 358 tBTA_JV_RFCOMM_CLOSE rfc_close; /* BTA_JV_RFCOMM_CLOSE_EVT */ 359 tBTA_JV_RFCOMM_START rfc_start; /* BTA_JV_RFCOMM_START_EVT */ 360 tBTA_JV_RFCOMM_CL_INIT rfc_cl_init; /* BTA_JV_RFCOMM_CL_INIT_EVT */ 361 tBTA_JV_RFCOMM_CONG rfc_cong; /* BTA_JV_RFCOMM_CONG_EVT */ 362 tBTA_JV_RFCOMM_WRITE rfc_write; /* BTA_JV_RFCOMM_WRITE_EVT */ 363 tBTA_JV_DATA_IND data_ind; /* BTA_JV_L2CAP_DATA_IND_EVT 364 BTA_JV_RFCOMM_DATA_IND_EVT */ 365 tBTA_JV_LE_DATA_IND le_data_ind; /* BTA_JV_L2CAP_LE_DATA_IND_EVT */ 366 tBTA_JV_L2CAP_LE_OPEN l2c_le_open; /* BTA_JV_L2CAP_OPEN_EVT */ 367 tBTA_JV_L2CAP_WRITE_FIXED l2c_write_fixed; /* BTA_JV_L2CAP_WRITE_FIXED_EVT */ 368 } tBTA_JV; 369 370 /* JAVA DM Interface callback */ 371 typedef void(tBTA_JV_DM_CBACK)(tBTA_JV_EVT event, tBTA_JV* p_data, uint32_t id); 372 373 /* JAVA RFCOMM interface callback */ 374 typedef uint32_t(tBTA_JV_RFCOMM_CBACK)(tBTA_JV_EVT event, tBTA_JV* p_data, 375 uint32_t rfcomm_slot_id); 376 377 /* JAVA L2CAP interface callback */ 378 typedef void(tBTA_JV_L2CAP_CBACK)(tBTA_JV_EVT event, tBTA_JV* p_data, 379 uint32_t l2cap_socket_id); 380 381 /* JV configuration structure */ 382 typedef struct { 383 uint16_t sdp_raw_size; /* The size of p_sdp_raw_data */ 384 uint16_t sdp_db_size; /* The size of p_sdp_db */ 385 uint8_t* p_sdp_raw_data; /* The data buffer to keep raw data */ 386 tSDP_DISCOVERY_DB* p_sdp_db; /* The data buffer to keep SDP database */ 387 } tBTA_JV_CFG; 388 389 /******************************************************************************* 390 * 391 * Function BTA_JvEnable 392 * 393 * Description Enable the Java I/F service. When the enable 394 * operation is complete the callback function will be 395 * called with a BTA_JV_ENABLE_EVT. This function must 396 * be called before other functions in the JV API are 397 * called. 398 * 399 * Returns BTA_JV_SUCCESS if successful. 400 * BTA_JV_FAIL if internal failure. 401 * 402 ******************************************************************************/ 403 tBTA_JV_STATUS BTA_JvEnable(tBTA_JV_DM_CBACK* p_cback); 404 405 /******************************************************************************* 406 * 407 * Function BTA_JvDisable 408 * 409 * Description Disable the Java I/F 410 * 411 * Returns void 412 * 413 ******************************************************************************/ 414 void BTA_JvDisable(void); 415 416 /******************************************************************************* 417 * 418 * Function BTA_JvIsEncrypted 419 * 420 * Description This function checks if the link to peer device is encrypted 421 * 422 * Returns true if encrypted. 423 * false if not. 424 * 425 ******************************************************************************/ 426 bool BTA_JvIsEncrypted(const RawAddress& bd_addr); 427 428 /******************************************************************************* 429 * 430 * Function BTA_JvGetChannelId 431 * 432 * Description This function reserves a SCN/PSM for applications running 433 * over RFCOMM or L2CAP. It is primarily called by 434 * server profiles/applications to register their SCN/PSM into 435 * the SDP database. The SCN is reported by the 436 * tBTA_JV_DM_CBACK callback with a BTA_JV_GET_SCN_EVT. 437 * If the SCN/PSM reported is 0, that means all SCN resources 438 * are exhausted. 439 * The channel parameter can be used to request a specific 440 * channel. If the request on the specific channel fails, the 441 * SCN/PSM returned in the EVT will be 0 - no attempt to 442 * request a new channel will be made. set channel to <= 0 to 443 * automatically assign an channel ID. 444 * 445 * Returns BTA_JV_SUCCESS, if the request is being processed. 446 * BTA_JV_FAILURE, otherwise. 447 * 448 ******************************************************************************/ 449 tBTA_JV_STATUS BTA_JvGetChannelId(int conn_type, uint32_t id, int32_t channel); 450 451 /******************************************************************************* 452 * 453 * Function BTA_JvFreeChannel 454 * 455 * Description This function frees a SCN/PSM that was used 456 * by an application running over RFCOMM or L2CAP. 457 * 458 * Returns BTA_JV_SUCCESS, if the request is being processed. 459 * BTA_JV_FAILURE, otherwise. 460 * 461 ******************************************************************************/ 462 tBTA_JV_STATUS BTA_JvFreeChannel(uint16_t channel, int conn_type); 463 464 /******************************************************************************* 465 * 466 * Function BTA_JvStartDiscovery 467 * 468 * Description This function performs service discovery for the services 469 * provided by the given peer device. When the operation is 470 * complete the tBTA_JV_DM_CBACK callback function will be 471 * called with a BTA_JV_DISCOVERY_COMP_EVT. 472 * 473 * Returns BTA_JV_SUCCESS, if the request is being processed. 474 * BTA_JV_FAILURE, otherwise. 475 * 476 ******************************************************************************/ 477 tBTA_JV_STATUS BTA_JvStartDiscovery(const RawAddress& bd_addr, 478 uint16_t num_uuid, tSDP_UUID* p_uuid_list, 479 uint32_t rfcomm_slot_id); 480 481 /******************************************************************************* 482 * 483 * Function BTA_JvCreateRecordByUser 484 * 485 * Description Create a service record in the local SDP database by user in 486 * tBTA_JV_DM_CBACK callback with a BTA_JV_CREATE_RECORD_EVT. 487 * 488 * Returns BTA_JV_SUCCESS, if the request is being processed. 489 * BTA_JV_FAILURE, otherwise. 490 * 491 ******************************************************************************/ 492 tBTA_JV_STATUS BTA_JvCreateRecordByUser(uint32_t rfcomm_slot_id); 493 494 /******************************************************************************* 495 * 496 * Function BTA_JvDeleteRecord 497 * 498 * Description Delete a service record in the local SDP database. 499 * 500 * Returns BTA_JV_SUCCESS, if the request is being processed. 501 * BTA_JV_FAILURE, otherwise. 502 * 503 ******************************************************************************/ 504 tBTA_JV_STATUS BTA_JvDeleteRecord(uint32_t handle); 505 506 /******************************************************************************* 507 * 508 * Function BTA_JvL2capConnectLE 509 * 510 * Description Initiate a connection as an LE L2CAP client to the given BD 511 * Address. 512 * When the connection is initiated or failed to initiate, 513 * tBTA_JV_L2CAP_CBACK is called with BTA_JV_L2CAP_CL_INIT_EVT 514 * When the connection is established or failed, 515 * tBTA_JV_L2CAP_CBACK is called with BTA_JV_L2CAP_OPEN_EVT 516 * 517 * Returns BTA_JV_SUCCESS, if the request is being processed. 518 * BTA_JV_FAILURE, otherwise. 519 * 520 ******************************************************************************/ 521 tBTA_JV_STATUS BTA_JvL2capConnectLE(tBTA_SEC sec_mask, tBTA_JV_ROLE role, 522 const tL2CAP_ERTM_INFO* ertm_info, 523 uint16_t remote_chan, uint16_t rx_mtu, 524 tL2CAP_CFG_INFO* cfg, 525 const RawAddress& peer_bd_addr, 526 tBTA_JV_L2CAP_CBACK* p_cback, 527 uint32_t l2cap_socket_id); 528 529 /******************************************************************************* 530 * 531 * Function BTA_JvL2capConnect 532 * 533 * Description Initiate a connection as a L2CAP client to the given BD 534 * Address. 535 * When the connection is initiated or failed to initiate, 536 * tBTA_JV_L2CAP_CBACK is called with BTA_JV_L2CAP_CL_INIT_EVT 537 * When the connection is established or failed, 538 * tBTA_JV_L2CAP_CBACK is called with BTA_JV_L2CAP_OPEN_EVT 539 * 540 * Returns BTA_JV_SUCCESS, if the request is being processed. 541 * BTA_JV_FAILURE, otherwise. 542 * 543 ******************************************************************************/ 544 tBTA_JV_STATUS BTA_JvL2capConnect( 545 int conn_type, tBTA_SEC sec_mask, tBTA_JV_ROLE role, 546 const tL2CAP_ERTM_INFO* ertm_info, uint16_t remote_psm, uint16_t rx_mtu, 547 tL2CAP_CFG_INFO* cfg, const RawAddress& peer_bd_addr, 548 tBTA_JV_L2CAP_CBACK* p_cback, uint32_t l2cap_socket_id); 549 550 /******************************************************************************* 551 * 552 * Function BTA_JvL2capClose 553 * 554 * Description This function closes an L2CAP client connection 555 * 556 * Returns BTA_JV_SUCCESS, if the request is being processed. 557 * BTA_JV_FAILURE, otherwise. 558 * 559 ******************************************************************************/ 560 tBTA_JV_STATUS BTA_JvL2capClose(uint32_t handle); 561 562 /******************************************************************************* 563 * 564 * Function BTA_JvL2capCloseLE 565 * 566 * Description This function closes an L2CAP client connection for Fixed 567 * Channels Function is idempotent and no callbacks are called! 568 * 569 * Returns BTA_JV_SUCCESS, if the request is being processed. 570 * BTA_JV_FAILURE, otherwise. 571 * 572 ******************************************************************************/ 573 tBTA_JV_STATUS BTA_JvL2capCloseLE(uint32_t handle); 574 575 /******************************************************************************* 576 * 577 * Function BTA_JvL2capStartServer 578 * 579 * Description This function starts an L2CAP server and listens for an 580 * L2CAP connection from a remote Bluetooth device. When the 581 * server is started successfully, tBTA_JV_L2CAP_CBACK is 582 * called with BTA_JV_L2CAP_START_EVT. When the connection is 583 * established, tBTA_JV_L2CAP_CBACK is called with 584 * BTA_JV_L2CAP_OPEN_EVT. 585 * 586 * Returns BTA_JV_SUCCESS, if the request is being processed. 587 * BTA_JV_FAILURE, otherwise. 588 * 589 ******************************************************************************/ 590 tBTA_JV_STATUS BTA_JvL2capStartServer(int conn_type, tBTA_SEC sec_mask, 591 tBTA_JV_ROLE role, 592 const tL2CAP_ERTM_INFO* ertm_info, 593 uint16_t local_psm, uint16_t rx_mtu, 594 tL2CAP_CFG_INFO* cfg, 595 tBTA_JV_L2CAP_CBACK* p_cback, 596 uint32_t l2cap_socket_id); 597 598 /******************************************************************************* 599 * 600 * Function BTA_JvL2capStartServerLE 601 * 602 * Description This function starts an LE L2CAP server and listens for an 603 * L2CAP connection from a remote Bluetooth device on a fixed 604 * channel over an LE link. When the server 605 * is started successfully, tBTA_JV_L2CAP_CBACK is called with 606 * BTA_JV_L2CAP_START_EVT. When the connection is established, 607 * tBTA_JV_L2CAP_CBACK is called with BTA_JV_L2CAP_OPEN_EVT. 608 * 609 * Returns BTA_JV_SUCCESS, if the request is being processed. 610 * BTA_JV_FAILURE, otherwise. 611 * 612 ******************************************************************************/ 613 tBTA_JV_STATUS BTA_JvL2capStartServerLE(tBTA_SEC sec_mask, tBTA_JV_ROLE role, 614 const tL2CAP_ERTM_INFO* ertm_info, 615 uint16_t local_chan, uint16_t rx_mtu, 616 tL2CAP_CFG_INFO* cfg, 617 tBTA_JV_L2CAP_CBACK* p_cback, 618 uint32_t l2cap_socket_id); 619 620 /******************************************************************************* 621 * 622 * Function BTA_JvL2capStopServerLE 623 * 624 * Description This function stops the LE L2CAP server. If the server has 625 * an active connection, it would be closed. 626 * 627 * Returns BTA_JV_SUCCESS, if the request is being processed. 628 * BTA_JV_FAILURE, otherwise. 629 * 630 ******************************************************************************/ 631 tBTA_JV_STATUS BTA_JvL2capStopServerLE(uint16_t local_chan, 632 uint32_t l2cap_socket_id); 633 634 /******************************************************************************* 635 * 636 * Function BTA_JvL2capStopServer 637 * 638 * Description This function stops the L2CAP server. If the server has 639 * an active connection, it would be closed. 640 * 641 * Returns BTA_JV_SUCCESS, if the request is being processed. 642 * BTA_JV_FAILURE, otherwise. 643 * 644 ******************************************************************************/ 645 tBTA_JV_STATUS BTA_JvL2capStopServer(uint16_t local_psm, 646 uint32_t l2cap_socket_id); 647 648 /******************************************************************************* 649 * 650 * Function BTA_JvL2capRead 651 * 652 * Description This function reads data from an L2CAP connection 653 * When the operation is complete, tBTA_JV_L2CAP_CBACK is 654 * called with BTA_JV_L2CAP_READ_EVT. 655 * 656 * Returns BTA_JV_SUCCESS, if the request is being processed. 657 * BTA_JV_FAILURE, otherwise. 658 * 659 ******************************************************************************/ 660 tBTA_JV_STATUS BTA_JvL2capRead(uint32_t handle, uint32_t req_id, 661 uint8_t* p_data, uint16_t len); 662 663 /******************************************************************************* 664 * 665 * Function BTA_JvL2capReady 666 * 667 * Description This function determined if there is data to read from 668 * an L2CAP connection 669 * 670 * Returns BTA_JV_SUCCESS, if data queue size is in *p_data_size. 671 * BTA_JV_FAILURE, if error. 672 * 673 ******************************************************************************/ 674 tBTA_JV_STATUS BTA_JvL2capReady(uint32_t handle, uint32_t* p_data_size); 675 676 /******************************************************************************* 677 * 678 * Function BTA_JvL2capWrite 679 * 680 * Description This function writes data to an L2CAP connection 681 * When the operation is complete, tBTA_JV_L2CAP_CBACK is 682 * called with BTA_JV_L2CAP_WRITE_EVT. Works for 683 * PSM-based connections 684 * 685 * Returns BTA_JV_SUCCESS, if the request is being processed. 686 * BTA_JV_FAILURE, otherwise. 687 * 688 ******************************************************************************/ 689 tBTA_JV_STATUS BTA_JvL2capWrite(uint32_t handle, uint32_t req_id, 690 uint8_t* p_data, uint16_t len, 691 uint32_t user_id); 692 693 /******************************************************************************* 694 * 695 * Function BTA_JvL2capWriteFixed 696 * 697 * Description This function writes data to an L2CAP connection 698 * When the operation is complete, tBTA_JV_L2CAP_CBACK is 699 * called with BTA_JV_L2CAP_WRITE_FIXED_EVT. Works for 700 * fixed-channel connections 701 * 702 * Returns BTA_JV_SUCCESS, if the request is being processed. 703 * BTA_JV_FAILURE, otherwise. 704 * 705 ******************************************************************************/ 706 tBTA_JV_STATUS BTA_JvL2capWriteFixed(uint16_t channel, const RawAddress& addr, 707 uint32_t req_id, 708 tBTA_JV_L2CAP_CBACK* p_cback, 709 uint8_t* p_data, uint16_t len, 710 uint32_t user_id); 711 712 /******************************************************************************* 713 * 714 * Function BTA_JvRfcommConnect 715 * 716 * Description This function makes an RFCOMM conection to a remote BD 717 * Address. 718 * When the connection is initiated or failed to initiate, 719 * tBTA_JV_RFCOMM_CBACK is called with 720 * BTA_JV_RFCOMM_CL_INIT_EVT 721 * When the connection is established or failed, 722 * tBTA_JV_RFCOMM_CBACK is called with BTA_JV_RFCOMM_OPEN_EVT 723 * 724 * Returns BTA_JV_SUCCESS, if the request is being processed. 725 * BTA_JV_FAILURE, otherwise. 726 * 727 ******************************************************************************/ 728 tBTA_JV_STATUS BTA_JvRfcommConnect(tBTA_SEC sec_mask, tBTA_JV_ROLE role, 729 uint8_t remote_scn, 730 const RawAddress& peer_bd_addr, 731 tBTA_JV_RFCOMM_CBACK* p_cback, 732 uint32_t rfcomm_slot_id); 733 734 /******************************************************************************* 735 * 736 * Function BTA_JvRfcommClose 737 * 738 * Description This function closes an RFCOMM connection 739 * 740 * Returns BTA_JV_SUCCESS, if the request is being processed. 741 * BTA_JV_FAILURE, otherwise. 742 * 743 ******************************************************************************/ 744 tBTA_JV_STATUS BTA_JvRfcommClose(uint32_t handle, uint32_t rfcomm_slot_id); 745 746 /******************************************************************************* 747 * 748 * Function BTA_JvRfcommStartServer 749 * 750 * Description This function starts listening for an RFCOMM connection 751 * request from a remote Bluetooth device. When the server is 752 * started successfully, tBTA_JV_RFCOMM_CBACK is called 753 * with BTA_JV_RFCOMM_START_EVT. 754 * When the connection is established, tBTA_JV_RFCOMM_CBACK 755 * is called with BTA_JV_RFCOMM_OPEN_EVT. 756 * 757 * Returns BTA_JV_SUCCESS, if the request is being processed. 758 * BTA_JV_FAILURE, otherwise. 759 * 760 ******************************************************************************/ 761 tBTA_JV_STATUS BTA_JvRfcommStartServer(tBTA_SEC sec_mask, tBTA_JV_ROLE role, 762 uint8_t local_scn, uint8_t max_session, 763 tBTA_JV_RFCOMM_CBACK* p_cback, 764 uint32_t rfcomm_slot_id); 765 766 /******************************************************************************* 767 * 768 * Function BTA_JvRfcommStopServer 769 * 770 * Description This function stops the RFCOMM server. If the server has an 771 * active connection, it would be closed. 772 * 773 * Returns BTA_JV_SUCCESS, if the request is being processed. 774 * BTA_JV_FAILURE, otherwise. 775 * 776 ******************************************************************************/ 777 tBTA_JV_STATUS BTA_JvRfcommStopServer(uint32_t handle, uint32_t rfcomm_slot_id); 778 779 /******************************************************************************* 780 * 781 * Function BTA_JvRfcommWrite 782 * 783 * Description This function writes data to an RFCOMM connection 784 * When the operation is complete, tBTA_JV_RFCOMM_CBACK is 785 * called with BTA_JV_RFCOMM_WRITE_EVT. 786 * 787 * Returns BTA_JV_SUCCESS, if the request is being processed. 788 * BTA_JV_FAILURE, otherwise. 789 * 790 ******************************************************************************/ 791 tBTA_JV_STATUS BTA_JvRfcommWrite(uint32_t handle, uint32_t req_id); 792 793 /******************************************************************************* 794 * 795 * Function BTA_JVSetPmProfile 796 * 797 * Description This function set or free power mode profile for different JV 798 * application 799 * 800 * Parameters: handle, JV handle from RFCOMM or L2CAP 801 * app_id: app specific pm ID, can be BTA_JV_PM_ALL, see 802 * bta_dm_cfg.c for details 803 * BTA_JV_PM_ID_CLEAR: removes pm management on the handle. init_st 804 * is ignored and BTA_JV_CONN_CLOSE is called 805 * implicitly 806 * init_st: state after calling this API. typically it should be 807 * BTA_JV_CONN_OPEN 808 * 809 * Returns BTA_JV_SUCCESS, if the request is being processed. 810 * BTA_JV_FAILURE, otherwise. 811 * 812 * NOTE: BTA_JV_PM_ID_CLEAR: In general no need to be called as jv pm 813 * calls automatically 814 * BTA_JV_CONN_CLOSE to remove in case of connection close! 815 * 816 ******************************************************************************/ 817 tBTA_JV_STATUS BTA_JvSetPmProfile(uint32_t handle, tBTA_JV_PM_ID app_id, 818 tBTA_JV_CONN_STATE init_st); 819 820 /******************************************************************************* 821 * 822 * Function BTA_JvRfcommGetPortHdl 823 * 824 * Description This function fetches the rfcomm port handle 825 * 826 * Returns BTA_JV_SUCCESS, if the request is being processed. 827 * BTA_JV_FAILURE, otherwise. 828 * 829 ******************************************************************************/ 830 uint16_t BTA_JvRfcommGetPortHdl(uint32_t handle); 831 832 #endif /* BTA_JV_API_H */ 833