1 /******************************************************************************
2 *
3 * Copyright 2003-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 file contains action functions for the audio gateway.
22 *
23 ******************************************************************************/
24
25 #include <bluetooth/log.h>
26 #include <com_android_bluetooth_flags.h>
27
28 #include <cstdint>
29 #include <cstring>
30
31 #include "ag/bta_ag_at.h"
32 #include "bta/ag/bta_ag_int.h"
33 #include "bta/include/bta_dm_api.h"
34 #include "bta/include/bta_hfp_api.h"
35 #include "bta_ag_api.h"
36 #include "bta_ag_swb_aptx.h"
37 #include "bta_api.h"
38 #include "bta_sys.h"
39 #include "btm_api_types.h"
40 #include "device/include/device_iot_conf_defs.h"
41 #include "osi/include/alarm.h"
42 #include "sdp_status.h"
43 #include "types/bt_transport.h"
44
45 #ifdef __ANDROID__
46 #endif
47
48 #include "btif/include/btif_config.h"
49 #include "device/include/device_iot_config.h"
50 #include "stack/include/bt_uuid16.h"
51 #include "stack/include/btm_sec_api_types.h"
52 #include "stack/include/l2cap_interface.h"
53 #include "stack/include/port_api.h"
54 #include "stack/include/sdp_api.h"
55 #include "storage/config_keys.h"
56 #include "types/raw_address.h"
57
58 using namespace bluetooth;
59 using namespace bluetooth::legacy::stack::sdp;
60
61 /*****************************************************************************
62 * Constants
63 ****************************************************************************/
64
65 /* maximum length of data to read from RFCOMM */
66 #define BTA_AG_RFC_READ_MAX 512
67
68 /* maximum AT command length */
69 #define BTA_AG_CMD_MAX 512
70
71 const uint16_t bta_ag_uuid[BTA_AG_NUM_IDX] = {UUID_SERVCLASS_HEADSET_AUDIO_GATEWAY,
72 UUID_SERVCLASS_AG_HANDSFREE};
73
74 const uint8_t bta_ag_sec_id[BTA_AG_NUM_IDX] = {BTM_SEC_SERVICE_HEADSET_AG,
75 BTM_SEC_SERVICE_AG_HANDSFREE};
76
77 const tBTA_SERVICE_ID bta_ag_svc_id[BTA_AG_NUM_IDX] = {BTA_HSP_SERVICE_ID, BTA_HFP_SERVICE_ID};
78
79 const tBTA_SERVICE_MASK bta_ag_svc_mask[BTA_AG_NUM_IDX] = {BTA_HSP_SERVICE_MASK,
80 BTA_HFP_SERVICE_MASK};
81
82 typedef void (*tBTA_AG_ATCMD_CBACK)(tBTA_AG_SCB* p_scb, uint16_t cmd, uint8_t arg_type, char* p_arg,
83 char* p_end, int16_t int_arg);
84
85 const tBTA_AG_ATCMD_CBACK bta_ag_at_cback_tbl[BTA_AG_NUM_IDX] = {bta_ag_at_hsp_cback,
86 bta_ag_at_hfp_cback};
87
88 /*******************************************************************************
89 *
90 * Function bta_ag_cback_open
91 *
92 * Description Send open callback event to application.
93 *
94 *
95 * Returns void
96 *
97 ******************************************************************************/
bta_ag_cback_open(tBTA_AG_SCB * p_scb,const RawAddress & bd_addr,tBTA_AG_STATUS status)98 static void bta_ag_cback_open(tBTA_AG_SCB* p_scb, const RawAddress& bd_addr,
99 tBTA_AG_STATUS status) {
100 tBTA_AG_OPEN open = {};
101
102 /* call app callback with open event */
103 open.hdr.handle = bta_ag_scb_to_idx(p_scb);
104 open.hdr.app_id = p_scb->app_id;
105 open.status = status;
106 open.service_id = bta_ag_svc_id[p_scb->conn_service];
107 open.bd_addr = bd_addr;
108
109 (*bta_ag_cb.p_cback)(BTA_AG_OPEN_EVT, (tBTA_AG*)&open);
110 }
111
112 /*******************************************************************************
113 *
114 * Function bta_ag_register
115 *
116 * Description This function initializes values of the AG cb and sets up
117 * the SDP record for the services.
118 *
119 *
120 * Returns void
121 *
122 ******************************************************************************/
bta_ag_register(tBTA_AG_SCB * p_scb,const tBTA_AG_DATA & data)123 void bta_ag_register(tBTA_AG_SCB* p_scb, const tBTA_AG_DATA& data) {
124 /* initialize control block */
125 p_scb->reg_services = data.api_register.services;
126 p_scb->features = data.api_register.features;
127 p_scb->masked_features = data.api_register.features;
128 p_scb->app_id = data.api_register.app_id;
129
130 /* create SDP records */
131 bta_ag_create_records(p_scb, data);
132
133 /* start RFCOMM servers */
134 bta_ag_start_servers(p_scb, p_scb->reg_services);
135
136 /* call app callback with register event */
137 tBTA_AG_REGISTER reg = {};
138 reg.hdr.handle = bta_ag_scb_to_idx(p_scb);
139 reg.hdr.app_id = p_scb->app_id;
140 reg.status = BTA_AG_SUCCESS;
141 (*bta_ag_cb.p_cback)(BTA_AG_REGISTER_EVT, (tBTA_AG*)®);
142 }
143
144 /*******************************************************************************
145 *
146 * Function bta_ag_deregister
147 *
148 * Description This function removes the sdp records, closes the RFCOMM
149 * servers, and deallocates the service control block.
150 *
151 *
152 * Returns void
153 *
154 ******************************************************************************/
bta_ag_deregister(tBTA_AG_SCB * p_scb,const tBTA_AG_DATA &)155 void bta_ag_deregister(tBTA_AG_SCB* p_scb, const tBTA_AG_DATA& /*data*/) {
156 /* set dealloc */
157 p_scb->dealloc = true;
158
159 /* remove sdp records */
160 bta_ag_del_records(p_scb);
161
162 /* remove rfcomm servers */
163 bta_ag_close_servers(p_scb, p_scb->reg_services);
164
165 /* dealloc */
166 bta_ag_scb_dealloc(p_scb);
167 }
168
169 /*******************************************************************************
170 *
171 * Function bta_ag_start_dereg
172 *
173 * Description Start a deregister event.
174 *
175 *
176 * Returns void
177 *
178 ******************************************************************************/
bta_ag_start_dereg(tBTA_AG_SCB * p_scb,const tBTA_AG_DATA &)179 void bta_ag_start_dereg(tBTA_AG_SCB* p_scb, const tBTA_AG_DATA& /*data*/) {
180 /* set dealloc */
181 p_scb->dealloc = true;
182
183 /* remove sdp records */
184 bta_ag_del_records(p_scb);
185 }
186
187 /*******************************************************************************
188 *
189 * Function bta_ag_start_open
190 *
191 * Description This starts an AG open.
192 *
193 *
194 * Returns void
195 *
196 ******************************************************************************/
bta_ag_start_open(tBTA_AG_SCB * p_scb,const tBTA_AG_DATA & data)197 void bta_ag_start_open(tBTA_AG_SCB* p_scb, const tBTA_AG_DATA& data) {
198 p_scb->peer_addr = data.api_open.bd_addr;
199 p_scb->open_services = p_scb->reg_services;
200
201 /* Check if RFCOMM has any incoming connection to avoid collision. */
202 if (PORT_IsCollisionDetected(p_scb->peer_addr)) {
203 /* Let the incoming connection go through. */
204 /* Issue collision for this scb for now. */
205 /* We will decide what to do when we find incoming connection later. */
206 bta_ag_collision_cback(BTA_SYS_CONN_OPEN, BTA_ID_AG, 0, p_scb->peer_addr);
207 return;
208 }
209
210 /* close servers */
211 bta_ag_close_servers(p_scb, p_scb->reg_services);
212
213 /* set role */
214 p_scb->role = BTA_AG_INT;
215
216 /* do service search */
217 bta_ag_do_disc(p_scb, p_scb->open_services);
218 }
219
220 /*******************************************************************************
221 *
222 * Function bta_ag_disc_int_res
223 *
224 * Description This function handles a discovery result when initiator.
225 *
226 *
227 * Returns void
228 *
229 ******************************************************************************/
bta_ag_disc_int_res(tBTA_AG_SCB * p_scb,const tBTA_AG_DATA & data)230 void bta_ag_disc_int_res(tBTA_AG_SCB* p_scb, const tBTA_AG_DATA& data) {
231 uint16_t event = BTA_AG_DISC_FAIL_EVT;
232
233 log::verbose("bta_ag_disc_int_res: Status: {}", data.disc_result.status);
234
235 /* if found service */
236 if (data.disc_result.status == tSDP_STATUS::SDP_SUCCESS ||
237 data.disc_result.status == tSDP_STATUS::SDP_DB_FULL) {
238 /* get attributes */
239 if (bta_ag_sdp_find_attr(p_scb, p_scb->open_services)) {
240 /* set connected service */
241 p_scb->conn_service = bta_ag_service_to_idx(p_scb->open_services);
242
243 /* send ourselves sdp ok event */
244 event = BTA_AG_DISC_OK_EVT;
245
246 DEVICE_IOT_CONFIG_ADDR_SET_HEX_IF_GREATER(p_scb->peer_addr, IOT_CONF_KEY_HFP_VERSION,
247 p_scb->peer_version, IOT_CONF_BYTE_NUM_2);
248 }
249 }
250
251 /* free discovery db */
252 bta_ag_free_db(p_scb, data);
253
254 /* if service not found check if we should search for other service */
255 if ((event == BTA_AG_DISC_FAIL_EVT) &&
256 (data.disc_result.status == tSDP_STATUS::SDP_SUCCESS ||
257 data.disc_result.status == tSDP_STATUS::SDP_DB_FULL ||
258 data.disc_result.status == tSDP_STATUS::SDP_NO_RECS_MATCH)) {
259 if ((p_scb->open_services & BTA_HFP_SERVICE_MASK) &&
260 (p_scb->open_services & BTA_HSP_SERVICE_MASK)) {
261 /* search for HSP */
262 p_scb->open_services &= ~BTA_HFP_SERVICE_MASK;
263 bta_ag_do_disc(p_scb, p_scb->open_services);
264 } else if ((p_scb->open_services & BTA_HSP_SERVICE_MASK) &&
265 (p_scb->hsp_version == HSP_VERSION_1_2)) {
266 /* search for UUID_SERVCLASS_HEADSET instead */
267 p_scb->hsp_version = HSP_VERSION_1_0;
268 bta_ag_do_disc(p_scb, p_scb->open_services);
269 } else {
270 /* send ourselves sdp ok/fail event */
271 bta_ag_sm_execute(p_scb, event, data);
272 }
273 } else {
274 /* send ourselves sdp ok/fail event */
275 bta_ag_sm_execute(p_scb, event, data);
276 }
277 }
278
279 /*******************************************************************************
280 *
281 * Function bta_ag_disc_acp_res
282 *
283 * Description This function handles a discovery result when acceptor.
284 *
285 *
286 * Returns void
287 *
288 ******************************************************************************/
bta_ag_disc_acp_res(tBTA_AG_SCB * p_scb,const tBTA_AG_DATA & data)289 void bta_ag_disc_acp_res(tBTA_AG_SCB* p_scb, const tBTA_AG_DATA& data) {
290 /* if found service */
291 if (data.disc_result.status == tSDP_STATUS::SDP_SUCCESS ||
292 data.disc_result.status == tSDP_STATUS::SDP_DB_FULL) {
293 /* get attributes */
294 bta_ag_sdp_find_attr(p_scb, bta_ag_svc_mask[p_scb->conn_service]);
295 DEVICE_IOT_CONFIG_ADDR_SET_HEX_IF_GREATER(p_scb->peer_addr, IOT_CONF_KEY_HFP_VERSION,
296 p_scb->peer_version, IOT_CONF_BYTE_NUM_2);
297 }
298
299 /* free discovery db */
300 bta_ag_free_db(p_scb, data);
301 }
302
303 /*******************************************************************************
304 *
305 * Function bta_ag_disc_fail
306 *
307 * Description This function handles a discovery failure.
308 *
309 *
310 * Returns void
311 *
312 ******************************************************************************/
bta_ag_disc_fail(tBTA_AG_SCB * p_scb,const tBTA_AG_DATA &)313 void bta_ag_disc_fail(tBTA_AG_SCB* p_scb, const tBTA_AG_DATA& /* data */) {
314 /* reopen registered servers */
315 bta_ag_start_servers(p_scb, p_scb->reg_services);
316
317 /* reinitialize stuff */
318
319 /* clear the remote BD address */
320 RawAddress peer_addr = p_scb->peer_addr;
321 p_scb->peer_addr = RawAddress::kEmpty;
322
323 /* call open cback w. failure */
324 bta_ag_cback_open(p_scb, peer_addr, BTA_AG_FAIL_SDP);
325 }
326
327 /*******************************************************************************
328 *
329 * Function bta_ag_open_fail
330 *
331 * Description open connection failed.
332 *
333 *
334 * Returns void
335 *
336 ******************************************************************************/
bta_ag_open_fail(tBTA_AG_SCB * p_scb,const tBTA_AG_DATA & data)337 void bta_ag_open_fail(tBTA_AG_SCB* p_scb, const tBTA_AG_DATA& data) {
338 /* call open cback w. failure */
339 log::debug("state {}", bta_ag_state_str(p_scb->state));
340 bta_ag_cback_open(p_scb, data.api_open.bd_addr, BTA_AG_FAIL_RESOURCES);
341 }
342
343 /*******************************************************************************
344 *
345 * Function bta_ag_rfc_fail
346 *
347 * Description RFCOMM connection failed.
348 *
349 *
350 * Returns void
351 *
352 ******************************************************************************/
bta_ag_rfc_fail(tBTA_AG_SCB * p_scb,const tBTA_AG_DATA &)353 void bta_ag_rfc_fail(tBTA_AG_SCB* p_scb, const tBTA_AG_DATA& /* data */) {
354 log::info("reset p_scb with index={}", bta_ag_scb_to_idx(p_scb));
355 RawAddress peer_addr = p_scb->peer_addr;
356 /* reinitialize stuff */
357 p_scb->state = BTA_AG_INIT_ST;
358 p_scb->conn_handle = 0;
359 p_scb->conn_service = 0;
360 p_scb->peer_features = 0;
361 p_scb->peer_codecs = BTM_SCO_CODEC_CVSD;
362 p_scb->sco_codec = BTM_SCO_CODEC_CVSD;
363 p_scb->is_aptx_swb_codec = false;
364 p_scb->role = 0;
365 p_scb->svc_conn = false;
366 p_scb->hsp_version = HSP_VERSION_1_2;
367 /*Clear the BD address*/
368 p_scb->peer_addr = RawAddress::kEmpty;
369
370 /* reopen registered servers */
371 bta_ag_start_servers(p_scb, p_scb->reg_services);
372
373 /* call open cback w. failure */
374 bta_ag_cback_open(p_scb, peer_addr, BTA_AG_FAIL_RFCOMM);
375 }
376
377 /*******************************************************************************
378 *
379 * Function bta_ag_rfc_close
380 *
381 * Description RFCOMM connection closed.
382 *
383 *
384 * Returns void
385 *
386 ******************************************************************************/
bta_ag_rfc_close(tBTA_AG_SCB * p_scb,const tBTA_AG_DATA &)387 void bta_ag_rfc_close(tBTA_AG_SCB* p_scb, const tBTA_AG_DATA& /* data */) {
388 tBTA_AG_CLOSE close = {};
389 tBTA_SERVICE_MASK services;
390 int i, num_active_conn = 0;
391
392 /* reinitialize stuff */
393 p_scb->clip[0] = 0;
394 p_scb->conn_service = 0;
395 p_scb->peer_features = 0;
396 p_scb->masked_features = p_scb->features;
397 p_scb->peer_codecs = BTM_SCO_CODEC_CVSD;
398 p_scb->sco_codec = BTM_SCO_CODEC_CVSD;
399 /* Clear these flags upon SLC teardown */
400 p_scb->codec_updated = false;
401 p_scb->codec_fallback = false;
402 p_scb->trying_cvsd_safe_settings = false;
403 p_scb->codec_msbc_settings = BTA_AG_SCO_MSBC_SETTINGS_T2;
404 p_scb->codec_cvsd_settings = BTA_AG_SCO_CVSD_SETTINGS_S4;
405 p_scb->codec_aptx_settings = BTA_AG_SCO_APTX_SWB_SETTINGS_Q0;
406 p_scb->is_aptx_swb_codec = false;
407 p_scb->codec_lc3_settings = BTA_AG_SCO_LC3_SETTINGS_T2;
408 p_scb->role = 0;
409 p_scb->svc_conn = false;
410 p_scb->hsp_version = HSP_VERSION_1_2;
411 bta_ag_at_reinit(&p_scb->at_cb);
412
413 for (auto& peer_hf_indicator : p_scb->peer_hf_indicators) {
414 peer_hf_indicator = {};
415 }
416 for (auto& local_hf_indicator : p_scb->local_hf_indicators) {
417 local_hf_indicator = {};
418 }
419
420 /* stop timers */
421 alarm_cancel(p_scb->ring_timer);
422 alarm_cancel(p_scb->codec_negotiation_timer);
423
424 close.hdr.handle = bta_ag_scb_to_idx(p_scb);
425 close.hdr.app_id = p_scb->app_id;
426 close.bd_addr = p_scb->peer_addr;
427
428 bta_sys_conn_close(BTA_ID_AG, p_scb->app_id, p_scb->peer_addr);
429
430 if (bta_ag_get_active_device() == p_scb->peer_addr) {
431 bta_clear_active_device();
432 }
433
434 /* call close cback */
435 (*bta_ag_cb.p_cback)(BTA_AG_CLOSE_EVT, (tBTA_AG*)&close);
436
437 /* if not deregistering (deallocating) reopen registered servers */
438 if (!p_scb->dealloc) {
439 /* Clear peer bd_addr so instance can be reused */
440 p_scb->peer_addr = RawAddress::kEmpty;
441
442 /* start only unopened server */
443 services = p_scb->reg_services;
444 for (i = 0; i < BTA_AG_NUM_IDX && services != 0; i++) {
445 if (p_scb->serv_handle[i]) {
446 services &= ~((tBTA_SERVICE_MASK)1 << (BTA_HSP_SERVICE_ID + i));
447 }
448 }
449 bta_ag_start_servers(p_scb, services);
450
451 p_scb->conn_handle = 0;
452
453 /* Make sure SCO state is BTA_AG_SCO_SHUTDOWN_ST */
454 bta_ag_sco_shutdown(p_scb, tBTA_AG_DATA::kEmpty);
455
456 /* Check if all the SLCs are down */
457 for (i = 0; i < BTA_AG_MAX_NUM_CLIENTS; i++) {
458 if (bta_ag_cb.scb[i].in_use && bta_ag_cb.scb[i].svc_conn) {
459 num_active_conn++;
460 }
461 }
462
463 if (!num_active_conn) {
464 bta_sys_sco_unuse(BTA_ID_AG, p_scb->app_id, p_scb->peer_addr);
465 }
466
467 /* else close port and deallocate scb */
468 } else {
469 if (RFCOMM_RemoveServer(p_scb->conn_handle) != PORT_SUCCESS) {
470 log::warn("Unable to remove RFCOMM server peer:{} handle:{}", p_scb->peer_addr,
471 p_scb->conn_handle);
472 }
473 bta_ag_scb_dealloc(p_scb);
474 }
475 }
476
477 /*******************************************************************************
478 *
479 * Function bta_ag_rfc_open
480 *
481 * Description Handle RFCOMM channel open.
482 *
483 *
484 * Returns void
485 *
486 ******************************************************************************/
bta_ag_rfc_open(tBTA_AG_SCB * p_scb,const tBTA_AG_DATA & data)487 void bta_ag_rfc_open(tBTA_AG_SCB* p_scb, const tBTA_AG_DATA& data) {
488 /* initialize AT feature variables */
489 p_scb->clip_enabled = false;
490 p_scb->ccwa_enabled = false;
491 p_scb->cmer_enabled = false;
492 p_scb->cmee_enabled = false;
493 p_scb->inband_enabled = ((p_scb->features & BTA_AG_FEAT_INBAND) == BTA_AG_FEAT_INBAND);
494 if (p_scb->conn_service == BTA_AG_HFP) {
495 size_t version_value_size = sizeof(p_scb->peer_version);
496 if (!btif_config_get_bin(p_scb->peer_addr.ToString(), BTIF_STORAGE_KEY_HFP_VERSION,
497 (uint8_t*)&p_scb->peer_version, &version_value_size)) {
498 log::warn("Failed read cached peer HFP version for {}", p_scb->peer_addr);
499 p_scb->peer_version = HFP_HSP_VERSION_UNKNOWN;
500 }
501 size_t sdp_features_size = sizeof(p_scb->peer_sdp_features);
502 if (btif_config_get_bin(p_scb->peer_addr.ToString(), BTIF_STORAGE_KEY_HFP_SDP_FEATURES,
503 (uint8_t*)&p_scb->peer_sdp_features, &sdp_features_size)) {
504 bool sdp_wbs_support = p_scb->peer_sdp_features & BTA_AG_FEAT_WBS_SUPPORT;
505 if (!p_scb->received_at_bac && sdp_wbs_support) {
506 p_scb->codec_updated = true;
507 p_scb->peer_codecs = BTM_SCO_CODEC_CVSD | BTM_SCO_CODEC_MSBC;
508 p_scb->sco_codec = BTM_SCO_CODEC_MSBC;
509 }
510 bool sdp_swb_support = p_scb->peer_sdp_features & BTA_AG_FEAT_SWB_SUPPORT;
511 if (!p_scb->received_at_bac && sdp_swb_support) {
512 p_scb->codec_updated = true;
513 p_scb->peer_codecs |= BTM_SCO_CODEC_LC3;
514 p_scb->sco_codec = BTM_SCO_CODEC_LC3;
515 }
516 } else {
517 log::warn("Failed read cached peer HFP SDP features for {}", p_scb->peer_addr);
518 }
519 }
520
521 /* set up AT command interpreter */
522 p_scb->at_cb.p_at_tbl = bta_ag_at_tbl[p_scb->conn_service];
523 p_scb->at_cb.p_cmd_cback = bta_ag_at_cback_tbl[p_scb->conn_service];
524 p_scb->at_cb.p_err_cback = bta_ag_at_err_cback;
525 p_scb->at_cb.p_user = p_scb;
526 p_scb->at_cb.cmd_max_len = BTA_AG_CMD_MAX;
527 bta_ag_at_init(&p_scb->at_cb);
528
529 bta_sys_conn_open(BTA_ID_AG, p_scb->app_id, p_scb->peer_addr);
530
531 bta_ag_cback_open(p_scb, p_scb->peer_addr, BTA_AG_SUCCESS);
532
533 if (p_scb->conn_service == BTA_AG_HFP) {
534 /* if hfp start timer for service level conn */
535 bta_sys_start_timer(p_scb->ring_timer, p_bta_ag_cfg->conn_tout, BTA_AG_SVC_TIMEOUT_EVT,
536 bta_ag_scb_to_idx(p_scb));
537 } else {
538 /* else service level conn is open */
539 bta_ag_svc_conn_open(p_scb, data);
540 }
541 }
542
543 /*******************************************************************************
544 *
545 * Function bta_ag_rfc_acp_open
546 *
547 * Description Handle RFCOMM channel open when accepting connection.
548 *
549 *
550 * Returns void
551 *
552 ******************************************************************************/
bta_ag_rfc_acp_open(tBTA_AG_SCB * p_scb,const tBTA_AG_DATA & data)553 void bta_ag_rfc_acp_open(tBTA_AG_SCB* p_scb, const tBTA_AG_DATA& data) {
554 log::verbose("serv_handle0 = {} serv_handle = {}", p_scb->serv_handle[0], p_scb->serv_handle[1]);
555 /* set role */
556 p_scb->role = BTA_AG_ACP;
557
558 /* get bd addr of peer */
559 uint16_t lcid = 0;
560 uint16_t hfp_version = 0;
561 RawAddress dev_addr = RawAddress::kEmpty;
562 int status = PORT_CheckConnection(data.rfc.port_handle, &dev_addr, &lcid);
563 if (status != PORT_SUCCESS) {
564 log::error("PORT_CheckConnection returned {}", status);
565 return;
566 }
567
568 /* Collision Handling */
569 for (tBTA_AG_SCB& ag_scb : bta_ag_cb.scb) {
570 // Cancel any pending collision timers
571 if (ag_scb.in_use && alarm_is_scheduled(ag_scb.collision_timer)) {
572 log::verbose("cancel collision alarm for {}", ag_scb.peer_addr);
573 alarm_cancel(ag_scb.collision_timer);
574 if (dev_addr != ag_scb.peer_addr && p_scb != &ag_scb) {
575 // Resume outgoing connection if incoming is not on the same device
576 bta_ag_resume_open(&ag_scb);
577 }
578 }
579 if (dev_addr == ag_scb.peer_addr && p_scb != &ag_scb) {
580 log::info("close outgoing connection before accepting {} with conn_handle={}",
581 ag_scb.peer_addr, ag_scb.conn_handle);
582
583 // If client port is opened, close it, state machine will handle rfcomm
584 // closed in opening state as failure and pass to upper layer
585 if (ag_scb.conn_handle > 0) {
586 status = RFCOMM_RemoveConnection(ag_scb.conn_handle);
587 if (status != PORT_SUCCESS) {
588 log::warn("RFCOMM_RemoveConnection failed for {}, handle {}, error {}", dev_addr,
589 ag_scb.conn_handle, status);
590 }
591 } else {
592 // As no existing outgoing rfcomm connection, then manual reset current
593 // state, and use the incoming one
594 bta_ag_rfc_fail(&ag_scb, tBTA_AG_DATA::kEmpty);
595 }
596 }
597 log::info("dev_addr={}, peer_addr={}, in_use={}, index={}", dev_addr, ag_scb.peer_addr,
598 ag_scb.in_use, bta_ag_scb_to_idx(p_scb));
599 }
600
601 p_scb->peer_addr = dev_addr;
602
603 /* determine connected service from port handle */
604 for (uint8_t i = 0; i < BTA_AG_NUM_IDX; i++) {
605 log::verbose("bta_ag_rfc_acp_open: i = {} serv_handle = {} port_handle = {}", i,
606 p_scb->serv_handle[i], data.rfc.port_handle);
607
608 if (p_scb->serv_handle[i] == data.rfc.port_handle) {
609 p_scb->conn_service = i;
610 p_scb->conn_handle = data.rfc.port_handle;
611 break;
612 }
613 }
614
615 log::verbose("bta_ag_rfc_acp_open: conn_service = {} conn_handle = {}", p_scb->conn_service,
616 p_scb->conn_handle);
617
618 /* close any unopened server */
619 bta_ag_close_servers(p_scb, (p_scb->reg_services & ~bta_ag_svc_mask[p_scb->conn_service]));
620
621 size_t version_value_size = sizeof(hfp_version);
622 bool get_version = btif_config_get_bin(p_scb->peer_addr.ToString(), BTIF_STORAGE_KEY_HFP_VERSION,
623 (uint8_t*)&hfp_version, &version_value_size);
624
625 if (p_scb->conn_service == BTA_AG_HFP && get_version) {
626 DEVICE_IOT_CONFIG_ADDR_SET_HEX_IF_GREATER(p_scb->peer_addr, IOT_CONF_KEY_HFP_VERSION,
627 hfp_version, IOT_CONF_BYTE_NUM_2);
628 }
629 /* do service discovery to get features */
630 bta_ag_do_disc(p_scb, bta_ag_svc_mask[p_scb->conn_service]);
631
632 /* continue with common open processing */
633 bta_ag_rfc_open(p_scb, data);
634 }
635
636 /*******************************************************************************
637 *
638 * Function bta_ag_rfc_data
639 *
640 * Description Read and process data from RFCOMM.
641 *
642 *
643 * Returns void
644 *
645 ******************************************************************************/
bta_ag_rfc_data(tBTA_AG_SCB * p_scb,const tBTA_AG_DATA &)646 void bta_ag_rfc_data(tBTA_AG_SCB* p_scb, const tBTA_AG_DATA& /* data */) {
647 uint16_t len;
648 char buf[BTA_AG_RFC_READ_MAX] = "";
649
650 log::verbose("");
651
652 /* do the following */
653 for (;;) {
654 /* read data from rfcomm; if bad status, we're done */
655 if (PORT_ReadData(p_scb->conn_handle, buf, BTA_AG_RFC_READ_MAX, &len) != PORT_SUCCESS) {
656 log::error("failed to read data {}", p_scb->peer_addr);
657 break;
658 }
659
660 /* if no data, we're done */
661 if (len == 0) {
662 log::warn("no data for {}", p_scb->peer_addr);
663 break;
664 }
665
666 /* run AT command interpreter on data */
667 bta_sys_busy(BTA_ID_AG, p_scb->app_id, p_scb->peer_addr);
668 bta_ag_at_parse(&p_scb->at_cb, buf, len);
669 if ((p_scb->sco_idx != BTM_INVALID_SCO_INDEX) && bta_ag_sco_is_open(p_scb)) {
670 log::verbose("change link policy for SCO");
671 bta_sys_sco_open(BTA_ID_AG, p_scb->app_id, p_scb->peer_addr);
672 } else {
673 bta_sys_idle(BTA_ID_AG, p_scb->app_id, p_scb->peer_addr);
674 }
675
676 /* no more data to read, we're done */
677 if (len < BTA_AG_RFC_READ_MAX) {
678 break;
679 }
680 }
681 }
682
683 /*******************************************************************************
684 *
685 * Function bta_ag_start_close
686 *
687 * Description Start the process of closing SCO and RFCOMM connection.
688 *
689 *
690 * Returns void
691 *
692 ******************************************************************************/
bta_ag_start_close(tBTA_AG_SCB * p_scb,const tBTA_AG_DATA & data)693 void bta_ag_start_close(tBTA_AG_SCB* p_scb, const tBTA_AG_DATA& data) {
694 /* Take the link out of sniff and set L2C idle time to 0 */
695 bta_dm_pm_active(p_scb->peer_addr);
696 if (!stack::l2cap::get_interface().L2CA_SetIdleTimeoutByBdAddr(p_scb->peer_addr, 0,
697 BT_TRANSPORT_BR_EDR)) {
698 log::warn("Unable to set idle timeout peer:{}", p_scb->peer_addr);
699 }
700
701 /* if SCO is open close SCO and wait on RFCOMM close */
702 if (bta_ag_sco_is_open(p_scb)) {
703 p_scb->post_sco = BTA_AG_POST_SCO_CLOSE_RFC;
704 } else {
705 p_scb->post_sco = BTA_AG_POST_SCO_NONE;
706 bta_ag_rfc_do_close(p_scb, data);
707 }
708
709 /* always do SCO shutdown to handle all SCO corner cases */
710 bta_ag_sco_shutdown(p_scb, data);
711 }
712
713 /*******************************************************************************
714 *
715 * Function bta_ag_post_sco_open
716 *
717 * Description Perform post-SCO open action, if any
718 *
719 *
720 * Returns void
721 *
722 ******************************************************************************/
bta_ag_post_sco_open(tBTA_AG_SCB * p_scb,const tBTA_AG_DATA & data)723 void bta_ag_post_sco_open(tBTA_AG_SCB* p_scb, const tBTA_AG_DATA& data) {
724 switch (p_scb->post_sco) {
725 case BTA_AG_POST_SCO_RING:
726 bta_ag_send_ring(p_scb, data);
727 p_scb->post_sco = BTA_AG_POST_SCO_NONE;
728 break;
729
730 case BTA_AG_POST_SCO_CALL_CONN:
731 bta_ag_send_call_inds(p_scb, BTA_AG_IN_CALL_CONN_RES);
732 p_scb->post_sco = BTA_AG_POST_SCO_NONE;
733 break;
734
735 default:
736 break;
737 }
738 }
739
740 /*******************************************************************************
741 *
742 * Function bta_ag_post_sco_close
743 *
744 * Description Perform post-SCO close action, if any
745 *
746 *
747 * Returns void
748 *
749 ******************************************************************************/
bta_ag_post_sco_close(tBTA_AG_SCB * p_scb,const tBTA_AG_DATA & data)750 void bta_ag_post_sco_close(tBTA_AG_SCB* p_scb, const tBTA_AG_DATA& data) {
751 switch (p_scb->post_sco) {
752 case BTA_AG_POST_SCO_CLOSE_RFC:
753 bta_ag_rfc_do_close(p_scb, data);
754 p_scb->post_sco = BTA_AG_POST_SCO_NONE;
755 break;
756
757 case BTA_AG_POST_SCO_CALL_CONN:
758 bta_ag_send_call_inds(p_scb, BTA_AG_IN_CALL_CONN_RES);
759 p_scb->post_sco = BTA_AG_POST_SCO_NONE;
760 break;
761
762 case BTA_AG_POST_SCO_CALL_ORIG:
763 bta_ag_send_call_inds(p_scb, BTA_AG_OUT_CALL_ORIG_RES);
764 p_scb->post_sco = BTA_AG_POST_SCO_NONE;
765 break;
766
767 case BTA_AG_POST_SCO_CALL_END:
768 bta_ag_send_call_inds(p_scb, BTA_AG_END_CALL_RES);
769 p_scb->post_sco = BTA_AG_POST_SCO_NONE;
770 break;
771
772 case BTA_AG_POST_SCO_CALL_END_INCALL:
773 bta_ag_send_call_inds(p_scb, BTA_AG_END_CALL_RES);
774
775 /* Sending callsetup IND and Ring were deferred to after SCO close. */
776 bta_ag_send_call_inds(p_scb, BTA_AG_IN_CALL_RES);
777
778 if (bta_ag_inband_enabled(p_scb) && !(p_scb->features & BTA_AG_FEAT_NOSCO)) {
779 p_scb->post_sco = BTA_AG_POST_SCO_RING;
780 if (!bta_ag_is_sco_open_allowed(p_scb, "BTA_AG_POST_SCO_CALL_END_INCALL")) {
781 break;
782 }
783 if (bta_ag_is_sco_managed_by_audio()) {
784 // let Audio HAL open the SCO
785 break;
786 }
787 bta_ag_sco_open(p_scb, data);
788 } else {
789 p_scb->post_sco = BTA_AG_POST_SCO_NONE;
790 bta_ag_send_ring(p_scb, data);
791 }
792 break;
793
794 default:
795 break;
796 }
797 }
798
799 /*******************************************************************************
800 *
801 * Function bta_ag_svc_conn_open
802 *
803 * Description Service level connection opened
804 *
805 *
806 * Returns void
807 *
808 ******************************************************************************/
bta_ag_svc_conn_open(tBTA_AG_SCB * p_scb,const tBTA_AG_DATA &)809 void bta_ag_svc_conn_open(tBTA_AG_SCB* p_scb, const tBTA_AG_DATA& /* data */) {
810 tBTA_AG_CONN evt = {};
811
812 if (!p_scb->svc_conn) {
813 /* set state variable */
814 p_scb->svc_conn = true;
815
816 /* Clear AT+BIA mask from previous SLC if any. */
817 p_scb->bia_masked_out = 0;
818
819 alarm_cancel(p_scb->ring_timer);
820
821 /* call callback */
822 evt.hdr.handle = bta_ag_scb_to_idx(p_scb);
823 evt.hdr.app_id = p_scb->app_id;
824 evt.peer_feat = p_scb->peer_features;
825 evt.bd_addr = p_scb->peer_addr;
826 evt.peer_codec = p_scb->peer_codecs;
827
828 if ((p_scb->call_ind != BTA_AG_CALL_INACTIVE) ||
829 (p_scb->callsetup_ind != BTA_AG_CALLSETUP_NONE)) {
830 bta_sys_sco_use(BTA_ID_AG, p_scb->app_id, p_scb->peer_addr);
831 }
832 if (bta_ag_get_active_device().IsEmpty()) {
833 bta_ag_api_set_active_device(p_scb->peer_addr);
834 }
835 (*bta_ag_cb.p_cback)(BTA_AG_CONN_EVT, (tBTA_AG*)&evt);
836 }
837 }
838
839 /*******************************************************************************
840 *
841 * Function bta_ag_setcodec
842 *
843 * Description Handle API SetCodec
844 *
845 *
846 * Returns void
847 *
848 ******************************************************************************/
bta_ag_setcodec(tBTA_AG_SCB * p_scb,const tBTA_AG_DATA & data)849 void bta_ag_setcodec(tBTA_AG_SCB* p_scb, const tBTA_AG_DATA& data) {
850 tBTA_AG_PEER_CODEC codec_type = data.api_setcodec.codec;
851 tBTA_AG_VAL val = {};
852 const bool aptx_voice =
853 is_hfp_aptx_voice_enabled() && (codec_type == BTA_AG_SCO_APTX_SWB_SETTINGS_Q0);
854 log::verbose("aptx_voice={}, codec_type={:#x}", aptx_voice, codec_type);
855
856 val.hdr.handle = bta_ag_scb_to_idx(p_scb);
857
858 /* Check if the requested codec type is valid */
859 if ((codec_type != BTM_SCO_CODEC_NONE) && (codec_type != BTM_SCO_CODEC_CVSD) &&
860 (codec_type != BTM_SCO_CODEC_MSBC) && (codec_type != BTM_SCO_CODEC_LC3) && !aptx_voice) {
861 val.num = codec_type;
862 val.hdr.status = BTA_AG_FAIL_RESOURCES;
863 log::error("bta_ag_setcodec error: unsupported codec type {}", codec_type);
864 (*bta_ag_cb.p_cback)(BTA_AG_CODEC_EVT, (tBTA_AG*)&val);
865 return;
866 }
867
868 if ((p_scb->peer_codecs & codec_type) || (codec_type == BTM_SCO_CODEC_NONE) ||
869 (codec_type == BTM_SCO_CODEC_CVSD)) {
870 p_scb->sco_codec = codec_type;
871 p_scb->codec_updated = true;
872 val.num = codec_type;
873 val.hdr.status = BTA_AG_SUCCESS;
874 log::verbose("bta_ag_setcodec: Updated codec type {}", codec_type);
875 } else {
876 val.num = codec_type;
877 val.hdr.status = BTA_AG_FAIL_RESOURCES;
878 log::error("bta_ag_setcodec error: unsupported codec type {}", codec_type);
879 }
880
881 (*bta_ag_cb.p_cback)(BTA_AG_CODEC_EVT, (tBTA_AG*)&val);
882 }
883
bta_ag_collision_timer_cback(void * data)884 static void bta_ag_collision_timer_cback(void* data) {
885 if (data == nullptr) {
886 log::error("data should never be null in a timer callback");
887 return;
888 }
889 /* If the peer haven't opened AG connection */
890 /* we will restart opening process. */
891 bta_ag_resume_open(static_cast<tBTA_AG_SCB*>(data));
892 }
893
bta_ag_handle_collision(tBTA_AG_SCB * p_scb,const tBTA_AG_DATA &)894 void bta_ag_handle_collision(tBTA_AG_SCB* p_scb, const tBTA_AG_DATA& /* data */) {
895 /* Cancel SDP if it had been started. */
896 if (p_scb->p_disc_db) {
897 if (!get_legacy_stack_sdp_api()->service.SDP_CancelServiceSearch(p_scb->p_disc_db)) {
898 log::warn("Unable to cancel SDP service discovery search peer:{}", p_scb->peer_addr);
899 }
900 bta_ag_free_db(p_scb, tBTA_AG_DATA::kEmpty);
901 }
902
903 /* reopen registered servers */
904 /* Collision may be detected before or after we close servers. */
905 if (bta_ag_is_server_closed(p_scb)) {
906 bta_ag_start_servers(p_scb, p_scb->reg_services);
907 }
908
909 /* Start timer to han */
910 alarm_set_on_mloop(p_scb->collision_timer, BTA_AG_COLLISION_TIMEOUT_MS,
911 bta_ag_collision_timer_cback, p_scb);
912 }
913