1 /******************************************************************************
2 *
3 * Copyright 2004-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 functions for managing the SCO connection used in AG.
22 *
23 ******************************************************************************/
24
25 #include <base/functional/bind.h>
26 #include <bluetooth/log.h>
27 #include <com_android_bluetooth_flags.h>
28
29 #include <cstddef>
30 #include <cstdint>
31 #include <memory>
32 #include <unordered_map>
33
34 #include "audio_hal_interface/hfp_client_interface.h"
35 #include "bta/ag/bta_ag_int.h"
36 #include "bta/include/bta_ag_swb_aptx.h"
37 #include "bta_ag_api.h"
38 #include "bta_sys.h"
39 #include "btm_api_types.h"
40 #include "btm_status.h"
41 #include "device/include/esco_parameters.h"
42 #include "hardware/bt_hf.h"
43 #include "hci/controller_interface.h"
44 #include "hci/hci_packets.h"
45 #include "hci_error_code.h"
46 #include "hcidefs.h"
47 #include "internal/btm_api.h"
48 #include "internal_include/bt_target.h"
49 #include "main/shim/entry.h"
50 #include "osi/include/alarm.h"
51 #include "osi/include/properties.h"
52 #include "stack/btm/btm_int_types.h"
53 #include "stack/btm/btm_sco.h"
54 #include "stack/btm/btm_sco_hfp_hal.h"
55 #include "stack/include/btm_client_interface.h"
56 #include "stack/include/btm_status.h"
57 #include "stack/include/main_thread.h"
58 #include "types/raw_address.h"
59
60 extern tBTM_CB btm_cb;
61
62 using HfpInterface = bluetooth::audio::hfp::HfpClientInterface;
63 using namespace bluetooth;
64
65 /* Codec negotiation timeout */
66 #ifndef BTA_AG_CODEC_NEGOTIATION_TIMEOUT_MS
67 #define BTA_AG_CODEC_NEGOTIATION_TIMEOUT_MS (3 * 1000) /* 3 seconds */
68 #endif
69
70 #define BTM_VOICE_SETTING_CVSD \
71 ((uint16_t)(HCI_INP_CODING_LINEAR | HCI_INP_DATA_FMT_2S_COMPLEMENT | HCI_INP_SAMPLE_SIZE_16BIT | \
72 HCI_AIR_CODING_FORMAT_CVSD))
73
74 #define BTM_VOICE_SETTING_TRANS \
75 ((uint16_t)(HCI_INP_CODING_LINEAR | HCI_INP_DATA_FMT_2S_COMPLEMENT | HCI_INP_SAMPLE_SIZE_16BIT | \
76 HCI_AIR_CODING_FORMAT_TRANSPNT))
77
78 static bool sco_allowed = true;
79 static bool hfp_software_datapath_enabled = false;
80 static RawAddress active_device_addr = {};
81 static std::unique_ptr<HfpInterface> hfp_client_interface;
82 static std::unique_ptr<HfpInterface::Offload> hfp_offload_interface;
83 static std::unique_ptr<HfpInterface::Encode> hfp_encode_interface;
84 static std::unique_ptr<HfpInterface::Decode> hfp_decode_interface;
85 static std::unordered_map<tBTA_AG_UUID_CODEC, ::hfp::sco_config> sco_config_map;
86 static std::unordered_map<tBTA_AG_UUID_CODEC, esco_coding_format_t> codec_coding_format_map{
87 {tBTA_AG_UUID_CODEC::UUID_CODEC_LC3, ESCO_CODING_FORMAT_LC3},
88 {tBTA_AG_UUID_CODEC::UUID_CODEC_MSBC, ESCO_CODING_FORMAT_MSBC},
89 {tBTA_AG_UUID_CODEC::UUID_CODEC_CVSD, ESCO_CODING_FORMAT_CVSD},
90 };
91
92 /* sco events */
93 enum {
94 BTA_AG_SCO_LISTEN_E, /* listen request */
95 BTA_AG_SCO_OPEN_E, /* open request */
96 BTA_AG_SCO_XFER_E, /* transfer request */
97 BTA_AG_SCO_CN_DONE_E, /* codec negotiation done */
98 BTA_AG_SCO_REOPEN_E, /* Retry with other codec when failed */
99 BTA_AG_SCO_CLOSE_E, /* close request */
100 BTA_AG_SCO_SHUTDOWN_E, /* shutdown request */
101 BTA_AG_SCO_CONN_OPEN_E, /* sco open */
102 BTA_AG_SCO_CONN_CLOSE_E, /* sco closed */
103 };
104
105 #define CASE_RETURN_STR(const) \
106 case const: \
107 return #const;
108
bta_ag_sco_evt_str(uint8_t event)109 static const char* bta_ag_sco_evt_str(uint8_t event) {
110 switch (event) {
111 CASE_RETURN_STR(BTA_AG_SCO_LISTEN_E)
112 CASE_RETURN_STR(BTA_AG_SCO_OPEN_E)
113 CASE_RETURN_STR(BTA_AG_SCO_XFER_E)
114 CASE_RETURN_STR(BTA_AG_SCO_CN_DONE_E)
115 CASE_RETURN_STR(BTA_AG_SCO_REOPEN_E)
116 CASE_RETURN_STR(BTA_AG_SCO_CLOSE_E)
117 CASE_RETURN_STR(BTA_AG_SCO_SHUTDOWN_E)
118 CASE_RETURN_STR(BTA_AG_SCO_CONN_OPEN_E)
119 CASE_RETURN_STR(BTA_AG_SCO_CONN_CLOSE_E)
120 default:
121 return "Unknown SCO Event";
122 }
123 }
124
bta_ag_sco_state_str(uint8_t state)125 static const char* bta_ag_sco_state_str(uint8_t state) {
126 switch (state) {
127 CASE_RETURN_STR(BTA_AG_SCO_SHUTDOWN_ST)
128 CASE_RETURN_STR(BTA_AG_SCO_LISTEN_ST)
129 CASE_RETURN_STR(BTA_AG_SCO_CODEC_ST)
130 CASE_RETURN_STR(BTA_AG_SCO_OPENING_ST)
131 CASE_RETURN_STR(BTA_AG_SCO_OPEN_CL_ST)
132 CASE_RETURN_STR(BTA_AG_SCO_OPEN_XFER_ST)
133 CASE_RETURN_STR(BTA_AG_SCO_OPEN_ST)
134 CASE_RETURN_STR(BTA_AG_SCO_CLOSING_ST)
135 CASE_RETURN_STR(BTA_AG_SCO_CLOSE_OP_ST)
136 CASE_RETURN_STR(BTA_AG_SCO_CLOSE_XFER_ST)
137 CASE_RETURN_STR(BTA_AG_SCO_SHUTTING_ST)
138 default:
139 return "Unknown SCO State";
140 }
141 }
142
codec_uuid_to_sample_rate(tBTA_AG_UUID_CODEC codec)143 static int codec_uuid_to_sample_rate(tBTA_AG_UUID_CODEC codec) {
144 int sample_rate;
145 switch (codec) {
146 case tBTA_AG_UUID_CODEC::UUID_CODEC_LC3:
147 sample_rate = 32000;
148 break;
149 case tBTA_AG_UUID_CODEC::UUID_CODEC_MSBC:
150 sample_rate = 16000;
151 break;
152 case tBTA_AG_UUID_CODEC::UUID_CODEC_CVSD:
153 default:
154 sample_rate = 8000;
155 }
156 return sample_rate;
157 }
158
159 /**
160 * Check if bd_addr is the current active device.
161 *
162 * @param bd_addr target device address
163 * @return True if bd_addr is the current active device, False otherwise or if
164 * no active device is set (i.e. active_device_addr is empty)
165 */
bta_ag_sco_is_active_device(const RawAddress & bd_addr)166 bool bta_ag_sco_is_active_device(const RawAddress& bd_addr) {
167 return !active_device_addr.IsEmpty() && active_device_addr == bd_addr;
168 }
169
170 void updateCodecParametersFromProviderInfo(tBTA_AG_UUID_CODEC esco_codec,
171 enh_esco_params_t& params);
172
173 /*******************************************************************************
174 *
175 * Function bta_ag_sco_conn_cback
176 *
177 * Description BTM SCO connection callback.
178 *
179 *
180 * Returns void
181 *
182 ******************************************************************************/
bta_ag_sco_conn_cback(uint16_t sco_idx)183 static void bta_ag_sco_conn_cback(uint16_t sco_idx) {
184 uint16_t handle;
185 tBTA_AG_SCB* p_scb;
186
187 /* match callback to scb; first check current sco scb */
188 if (bta_ag_cb.sco.p_curr_scb != nullptr && bta_ag_cb.sco.p_curr_scb->in_use) {
189 handle = bta_ag_scb_to_idx(bta_ag_cb.sco.p_curr_scb);
190 } else {
191 /* then check for scb connected to this peer */
192 /* Check if SLC is up */
193 handle = bta_ag_idx_by_bdaddr(BTM_ReadScoBdAddr(sco_idx));
194 p_scb = bta_ag_scb_by_idx(handle);
195 if (p_scb && !p_scb->svc_conn) {
196 handle = 0;
197 }
198 }
199
200 if (handle != 0) {
201 do_in_main_thread(base::BindOnce(&bta_ag_sm_execute_by_handle, handle, BTA_AG_SCO_OPEN_EVT,
202 tBTA_AG_DATA::kEmpty));
203 } else {
204 /* no match found; disconnect sco, init sco variables */
205 bta_ag_cb.sco.p_curr_scb = nullptr;
206 bta_ag_cb.sco.state = BTA_AG_SCO_SHUTDOWN_ST;
207 if (get_btm_client_interface().sco.BTM_RemoveSco(sco_idx) != tBTM_STATUS::BTM_SUCCESS) {
208 log::warn("Unable to remove SCO idx:{}", sco_idx);
209 }
210 }
211 }
212
213 /*******************************************************************************
214 *
215 * Function bta_ag_sco_disc_cback
216 *
217 * Description BTM SCO disconnection callback.
218 *
219 *
220 * Returns void
221 *
222 ******************************************************************************/
bta_ag_sco_disc_cback(uint16_t sco_idx)223 static void bta_ag_sco_disc_cback(uint16_t sco_idx) {
224 uint16_t handle = 0;
225
226 log::debug("sco_idx: 0x{:x} sco.state:{}", sco_idx,
227 sco_state_text(static_cast<tSCO_STATE>(bta_ag_cb.sco.state)));
228 log::debug("scb[0] in_use:{} sco_idx: 0x{:x} ag state:{}", bta_ag_cb.scb[0].in_use,
229 bta_ag_cb.scb[0].sco_idx, bta_ag_state_str(bta_ag_cb.scb[0].state));
230 log::debug("scb[1] in_use:{} sco_idx:0x{:x} ag state:{}", bta_ag_cb.scb[1].in_use,
231 bta_ag_cb.scb[1].sco_idx, bta_ag_state_str(bta_ag_cb.scb[1].state));
232
233 /* match callback to scb */
234 if (bta_ag_cb.sco.p_curr_scb != nullptr && bta_ag_cb.sco.p_curr_scb->in_use) {
235 /* We only care about callbacks for the active SCO */
236 if (bta_ag_cb.sco.p_curr_scb->sco_idx != sco_idx) {
237 if (bta_ag_cb.sco.p_curr_scb->sco_idx != 0xFFFF) {
238 return;
239 }
240 }
241 handle = bta_ag_scb_to_idx(bta_ag_cb.sco.p_curr_scb);
242 }
243
244 if (handle != 0) {
245 const bool aptx_voice = is_hfp_aptx_voice_enabled() &&
246 (bta_ag_cb.sco.p_curr_scb->is_aptx_swb_codec == true) &&
247 (bta_ag_cb.sco.p_curr_scb->inuse_codec ==
248 tBTA_AG_UUID_CODEC::BTA_AG_SCO_APTX_SWB_SETTINGS_Q0);
249 log::verbose("aptx_voice={}, inuse_codec={}", aptx_voice,
250 bta_ag_uuid_codec_text(bta_ag_cb.sco.p_curr_scb->inuse_codec));
251
252 /* Restore settings */
253 if (bta_ag_cb.sco.p_curr_scb->inuse_codec == tBTA_AG_UUID_CODEC::UUID_CODEC_MSBC ||
254 bta_ag_cb.sco.p_curr_scb->inuse_codec == tBTA_AG_UUID_CODEC::UUID_CODEC_LC3 || aptx_voice ||
255 (com::android::bluetooth::flags::fix_hfp_qual_1_9() &&
256 bta_ag_cb.sco.p_curr_scb->inuse_codec == tBTA_AG_UUID_CODEC::UUID_CODEC_CVSD &&
257 bta_ag_cb.sco.p_curr_scb->codec_cvsd_settings != BTA_AG_SCO_CVSD_SETTINGS_S1)) {
258 /* Bypass vendor specific and voice settings if enhanced eSCO supported */
259 if (!(bluetooth::shim::GetController()->IsSupported(
260 bluetooth::hci::OpCode::ENHANCED_SETUP_SYNCHRONOUS_CONNECTION))) {
261 get_btm_client_interface().sco.BTM_WriteVoiceSettings(BTM_VOICE_SETTING_CVSD);
262 }
263
264 /* If SCO open was initiated by AG and failed for mSBC T2, try mSBC T1
265 * 'Safe setting' first. If T1 also fails, try CVSD
266 * same operations for LC3 settings */
267 if (bta_ag_sco_is_opening(bta_ag_cb.sco.p_curr_scb) &&
268 (!com::android::bluetooth::flags::fix_hfp_qual_1_9() || bta_ag_cb.sco.is_local)) {
269 /* Don't bother to edit |p_curr_scb->state| because it is in
270 * |BTA_AG_OPEN_ST|, which has the same value as |BTA_AG_SCO_CODEC_ST|
271 */
272 if (!com::android::bluetooth::flags::fix_hfp_qual_1_9()) {
273 bta_ag_cb.sco.p_curr_scb->state = (tBTA_AG_STATE)BTA_AG_SCO_CODEC_ST;
274 }
275 if (bta_ag_cb.sco.p_curr_scb->inuse_codec == tBTA_AG_UUID_CODEC::UUID_CODEC_LC3) {
276 if (bta_ag_cb.sco.p_curr_scb->codec_lc3_settings == BTA_AG_SCO_LC3_SETTINGS_T2) {
277 log::warn("eSCO/SCO failed to open, falling back to LC3 T1 settings");
278 bta_ag_cb.sco.p_curr_scb->codec_lc3_settings = BTA_AG_SCO_LC3_SETTINGS_T1;
279 } else {
280 log::warn("eSCO/SCO failed to open, falling back to CVSD settings");
281 bta_ag_cb.sco.p_curr_scb->inuse_codec = tBTA_AG_UUID_CODEC::UUID_CODEC_CVSD;
282 bta_ag_cb.sco.p_curr_scb->codec_fallback = true;
283 }
284 } else if (bta_ag_cb.sco.p_curr_scb->inuse_codec == tBTA_AG_UUID_CODEC::UUID_CODEC_MSBC ||
285 aptx_voice) {
286 if (bta_ag_cb.sco.p_curr_scb->codec_msbc_settings == BTA_AG_SCO_MSBC_SETTINGS_T2) {
287 log::warn("eSCO/SCO failed to open, falling back to mSBC T1 settings");
288 bta_ag_cb.sco.p_curr_scb->codec_msbc_settings = BTA_AG_SCO_MSBC_SETTINGS_T1;
289
290 } else {
291 log::warn("eSCO/SCO failed to open, falling back to CVSD");
292 bta_ag_cb.sco.p_curr_scb->inuse_codec = tBTA_AG_UUID_CODEC::UUID_CODEC_CVSD;
293 bta_ag_cb.sco.p_curr_scb->codec_fallback = true;
294 }
295 } else {
296 // Entering this block implies
297 // - |fix_hfp_qual_1_9| is enabled, AND
298 // - we just failed CVSD S2+.
299 log::warn("eSCO/SCO failed to open, falling back to CVSD S1 settings");
300 bta_ag_cb.sco.p_curr_scb->codec_cvsd_settings = BTA_AG_SCO_CVSD_SETTINGS_S1;
301 bta_ag_cb.sco.p_curr_scb->trying_cvsd_safe_settings = true;
302 }
303 }
304 } else if (bta_ag_sco_is_opening(bta_ag_cb.sco.p_curr_scb) &&
305 (!com::android::bluetooth::flags::fix_hfp_qual_1_9() || bta_ag_cb.sco.is_local)) {
306 if (com::android::bluetooth::flags::retry_esco_with_zero_retransmission_effort() &&
307 bta_ag_cb.sco.p_curr_scb->retransmission_effort_retries == 0) {
308 bta_ag_cb.sco.p_curr_scb->retransmission_effort_retries++;
309 if (!com::android::bluetooth::flags::fix_hfp_qual_1_9()) {
310 bta_ag_cb.sco.p_curr_scb->state = (tBTA_AG_STATE)BTA_AG_SCO_CODEC_ST;
311 }
312 log::warn("eSCO/SCO failed to open, retry with retransmission_effort");
313 } else {
314 log::error("eSCO/SCO failed to open, no more fall back");
315 if (bta_ag_is_sco_managed_by_audio()) {
316 if (hfp_software_datapath_enabled) {
317 if (hfp_encode_interface) {
318 hfp_encode_interface->CancelStreamingRequest();
319 hfp_decode_interface->CancelStreamingRequest();
320 }
321 } else {
322 hfp_offload_interface->CancelStreamingRequest();
323 }
324 }
325 }
326 }
327
328 bta_ag_cb.sco.p_curr_scb->inuse_codec = tBTA_AG_UUID_CODEC::UUID_CODEC_NONE;
329
330 do_in_main_thread(base::BindOnce(&bta_ag_sm_execute_by_handle, handle, BTA_AG_SCO_CLOSE_EVT,
331 tBTA_AG_DATA::kEmpty));
332 } else {
333 /* no match found */
334 log::verbose("no scb for ag_sco_disc_cback");
335
336 /* sco could be closed after scb dealloc'ed */
337 if (bta_ag_cb.sco.p_curr_scb != nullptr) {
338 bta_ag_cb.sco.p_curr_scb->sco_idx = BTM_INVALID_SCO_INDEX;
339 bta_ag_cb.sco.p_curr_scb = nullptr;
340 bta_ag_cb.sco.state = BTA_AG_SCO_SHUTDOWN_ST;
341 }
342 }
343 }
344
345 /*******************************************************************************
346 *
347 * Function bta_ag_remove_sco
348 *
349 * Description Removes the specified SCO from the system.
350 * If only_active is true, then SCO is only removed if
351 * connected
352 *
353 * Returns bool - true if SCO removal was started
354 *
355 ******************************************************************************/
bta_ag_remove_sco(tBTA_AG_SCB * p_scb,bool only_active)356 static bool bta_ag_remove_sco(tBTA_AG_SCB* p_scb, bool only_active) {
357 if (p_scb->sco_idx != BTM_INVALID_SCO_INDEX) {
358 if (!only_active || p_scb->sco_idx == bta_ag_cb.sco.cur_idx) {
359 tBTM_STATUS status = get_btm_client_interface().sco.BTM_RemoveSco(p_scb->sco_idx);
360 log::debug("Removed SCO index:0x{:04x} status:{}", p_scb->sco_idx, btm_status_text(status));
361 if (status == tBTM_STATUS::BTM_CMD_STARTED) {
362 /* SCO is connected; set current control block */
363 bta_ag_cb.sco.p_curr_scb = p_scb;
364 return true;
365 } else if ((status == tBTM_STATUS::BTM_SUCCESS) ||
366 (status == tBTM_STATUS::BTM_UNKNOWN_ADDR)) {
367 /* If no connection reset the SCO handle */
368 p_scb->sco_idx = BTM_INVALID_SCO_INDEX;
369 }
370 }
371 }
372 return false;
373 }
374
375 /*******************************************************************************
376 *
377 * Function bta_ag_esco_connreq_cback
378 *
379 * Description BTM eSCO connection requests and eSCO change requests
380 * Only the connection requests are processed by BTA.
381 *
382 * Returns void
383 *
384 ******************************************************************************/
bta_ag_esco_connreq_cback(tBTM_ESCO_EVT event,tBTM_ESCO_EVT_DATA * p_data)385 static void bta_ag_esco_connreq_cback(tBTM_ESCO_EVT event, tBTM_ESCO_EVT_DATA* p_data) {
386 /* Only process connection requests */
387 if (event == BTM_ESCO_CONN_REQ_EVT) {
388 uint16_t sco_inx = p_data->conn_evt.sco_inx;
389 const RawAddress* remote_bda = BTM_ReadScoBdAddr(sco_inx);
390 tBTA_AG_SCB* p_scb = bta_ag_scb_by_idx(bta_ag_idx_by_bdaddr(remote_bda));
391 if (remote_bda && bta_ag_sco_is_active_device(*remote_bda) && p_scb && p_scb->svc_conn) {
392 p_scb->sco_idx = sco_inx;
393
394 /* If no other SCO active, allow this one */
395 if (!bta_ag_cb.sco.p_curr_scb) {
396 log::verbose("Accept Conn Request (sco_inx 0x{:04x})", sco_inx);
397 bta_ag_sco_conn_rsp(p_scb, &p_data->conn_evt);
398
399 bta_ag_cb.sco.state = BTA_AG_SCO_OPENING_ST;
400 bta_ag_cb.sco.p_curr_scb = p_scb;
401 bta_ag_cb.sco.cur_idx = p_scb->sco_idx;
402 } else {
403 /* Begin a transfer: Close current SCO before responding */
404 log::verbose("bta_ag_esco_connreq_cback: Begin XFER");
405 bta_ag_cb.sco.p_xfer_scb = p_scb;
406 bta_ag_cb.sco.conn_data = p_data->conn_evt;
407 bta_ag_cb.sco.state = BTA_AG_SCO_OPEN_XFER_ST;
408
409 if (!bta_ag_remove_sco(bta_ag_cb.sco.p_curr_scb, true)) {
410 log::error("Nothing to remove,so accept Conn Request(sco_inx 0x{:04x})", sco_inx);
411 bta_ag_cb.sco.p_xfer_scb = nullptr;
412 bta_ag_cb.sco.state = BTA_AG_SCO_LISTEN_ST;
413
414 bta_ag_sco_conn_rsp(p_scb, &p_data->conn_evt);
415 }
416 }
417 } else {
418 log::warn("reject incoming SCO connection, remote_bda={}, active_bda={}, current_bda={}",
419 remote_bda ? *remote_bda : RawAddress::kEmpty, active_device_addr,
420 p_scb ? p_scb->peer_addr : RawAddress::kEmpty);
421 get_btm_client_interface().sco.BTM_EScoConnRsp(
422 p_data->conn_evt.sco_inx, HCI_ERR_HOST_REJECT_RESOURCES, (enh_esco_params_t*)nullptr);
423 }
424 }
425 }
426
427 /*******************************************************************************
428 *
429 * Function bta_ag_cback_sco
430 *
431 * Description Call application callback function with SCO event.
432 *
433 *
434 * Returns void
435 *
436 ******************************************************************************/
bta_ag_cback_sco(tBTA_AG_SCB * p_scb,tBTA_AG_EVT event)437 static void bta_ag_cback_sco(tBTA_AG_SCB* p_scb, tBTA_AG_EVT event) {
438 tBTA_AG_HDR sco = {};
439 sco.handle = bta_ag_scb_to_idx(p_scb);
440 sco.app_id = p_scb->app_id;
441 /* call close cback */
442 (*bta_ag_cb.p_cback)(static_cast<tBTA_AG_EVT>(event), (tBTA_AG*)&sco);
443 }
444
445 /*******************************************************************************
446 *
447 * Function bta_ag_create_sco
448 *
449 * Description Create a SCO connection for a given control block
450 * p_scb : Pointer to the target AG control block
451 * is_orig : Whether to initiate or listen for SCO connection
452 *
453 * Returns void
454 *
455 ******************************************************************************/
bta_ag_create_sco(tBTA_AG_SCB * p_scb,bool is_orig)456 void bta_ag_create_sco(tBTA_AG_SCB* p_scb, bool is_orig) {
457 log::debug("BEFORE {}", p_scb->ToString());
458 tBTA_AG_UUID_CODEC esco_codec = tBTA_AG_UUID_CODEC::UUID_CODEC_CVSD;
459
460 if (!bta_ag_sco_is_active_device(p_scb->peer_addr)) {
461 log::warn("device {} is not active, active_device={}", p_scb->peer_addr, active_device_addr);
462 if (bta_ag_cb.sco.p_curr_scb != nullptr && bta_ag_cb.sco.p_curr_scb->in_use &&
463 p_scb == bta_ag_cb.sco.p_curr_scb) {
464 do_in_main_thread(base::BindOnce(&bta_ag_sm_execute, p_scb, BTA_AG_SCO_CLOSE_EVT,
465 tBTA_AG_DATA::kEmpty));
466 }
467 return;
468 }
469 /* Make sure this SCO handle is not already in use */
470 if (p_scb->sco_idx != BTM_INVALID_SCO_INDEX) {
471 log::error("device {}, index 0x{:04x} already in use!", p_scb->peer_addr, p_scb->sco_idx);
472 return;
473 }
474
475 if ((p_scb->sco_codec == BTM_SCO_CODEC_MSBC) && !p_scb->codec_fallback &&
476 hfp_hal_interface::get_wbs_supported()) {
477 esco_codec = tBTA_AG_UUID_CODEC::UUID_CODEC_MSBC;
478 }
479
480 if (is_hfp_aptx_voice_enabled()) {
481 if ((p_scb->sco_codec == BTA_AG_SCO_APTX_SWB_SETTINGS_Q0) && !p_scb->codec_fallback) {
482 esco_codec = tBTA_AG_UUID_CODEC ::BTA_AG_SCO_APTX_SWB_SETTINGS_Q0;
483 }
484 }
485
486 if ((p_scb->sco_codec == BTM_SCO_CODEC_LC3) && !p_scb->codec_fallback &&
487 hfp_hal_interface::get_swb_supported()) {
488 esco_codec = tBTA_AG_UUID_CODEC::UUID_CODEC_LC3;
489 }
490
491 p_scb->trying_cvsd_safe_settings = false;
492
493 if (p_scb->codec_fallback) {
494 p_scb->codec_fallback = false;
495 /* Force AG to send +BCS for the next audio connection. */
496 p_scb->codec_updated = true;
497 /* reset to CVSD S4 settings as the preferred */
498 p_scb->codec_cvsd_settings = BTA_AG_SCO_CVSD_SETTINGS_S4;
499 /* Reset mSBC settings to T2 for the next audio connection */
500 p_scb->codec_msbc_settings = BTA_AG_SCO_MSBC_SETTINGS_T2;
501 /* Reset LC3 settings to T2 for the next audio connection */
502 p_scb->codec_lc3_settings = BTA_AG_SCO_LC3_SETTINGS_T2;
503 /* Reset SWB settings to Q3 for the next audio connection */
504 p_scb->codec_aptx_settings = BTA_AG_SCO_APTX_SWB_SETTINGS_Q0;
505 }
506
507 bool offload = hfp_hal_interface::get_offload_enabled();
508 /* Initialize eSCO parameters */
509 enh_esco_params_t params = {};
510 /* If SWB/WBS are excluded, use CVSD by default,
511 * index is 0 for CVSD by initialization.
512 * If eSCO codec is mSBC, index is T2 or T1.
513 * If eSCO coedc is LC3, index is T2 or T1. */
514 log::warn("esco_codec: {}", (int)esco_codec);
515 if (esco_codec == tBTA_AG_UUID_CODEC::UUID_CODEC_LC3) {
516 if (p_scb->codec_lc3_settings == BTA_AG_SCO_LC3_SETTINGS_T2) {
517 params = esco_parameters_for_codec(ESCO_CODEC_LC3_T2, offload);
518 } else {
519 params = esco_parameters_for_codec(ESCO_CODEC_LC3_T1, offload);
520 }
521 } else if (is_hfp_aptx_voice_enabled() &&
522 (p_scb->is_aptx_swb_codec == true && !p_scb->codec_updated)) {
523 if (p_scb->codec_aptx_settings == BTA_AG_SCO_APTX_SWB_SETTINGS_Q3) {
524 params = esco_parameters_for_codec(ESCO_CODEC_SWB_Q3, true);
525 } else if (p_scb->codec_aptx_settings == BTA_AG_SCO_APTX_SWB_SETTINGS_Q2) {
526 params = esco_parameters_for_codec(ESCO_CODEC_SWB_Q2, true);
527 } else if (p_scb->codec_aptx_settings == BTA_AG_SCO_APTX_SWB_SETTINGS_Q1) {
528 params = esco_parameters_for_codec(ESCO_CODEC_SWB_Q1, true);
529 } else if (p_scb->codec_aptx_settings == BTA_AG_SCO_APTX_SWB_SETTINGS_Q0) {
530 params = esco_parameters_for_codec(ESCO_CODEC_SWB_Q0, true);
531 }
532 } else if (esco_codec == tBTA_AG_UUID_CODEC::UUID_CODEC_MSBC) {
533 if (p_scb->codec_msbc_settings == BTA_AG_SCO_MSBC_SETTINGS_T2) {
534 params = esco_parameters_for_codec(ESCO_CODEC_MSBC_T2, offload);
535 } else {
536 params = esco_parameters_for_codec(ESCO_CODEC_MSBC_T1, offload);
537 }
538 } else {
539 if (com::android::bluetooth::flags::fix_hfp_qual_1_9() &&
540 p_scb->codec_cvsd_settings == BTA_AG_SCO_CVSD_SETTINGS_S1) {
541 params = esco_parameters_for_codec(ESCO_CODEC_CVSD_S1, offload);
542 } else {
543 if ((p_scb->features & BTA_AG_FEAT_ESCO_S4) &&
544 (p_scb->peer_features & BTA_AG_PEER_FEAT_ESCO_S4)) {
545 // HFP >=1.7 eSCO
546 params = esco_parameters_for_codec(ESCO_CODEC_CVSD_S4, offload);
547 } else {
548 // HFP <=1.6 eSCO
549 params = esco_parameters_for_codec(ESCO_CODEC_CVSD_S3, offload);
550 }
551 }
552 }
553
554 updateCodecParametersFromProviderInfo(esco_codec, params);
555
556 if (com::android::bluetooth::flags::retry_esco_with_zero_retransmission_effort() &&
557 p_scb->retransmission_effort_retries == 1) {
558 log::info("change retransmission_effort to 0, retry");
559 p_scb->retransmission_effort_retries++;
560 params.retransmission_effort = ESCO_RETRANSMISSION_OFF;
561 }
562
563 /* Configure input/output data path based on HAL settings. */
564 hfp_hal_interface::set_codec_datapath(esco_codec);
565 hfp_hal_interface::update_esco_parameters(¶ms);
566
567 /* If initiating, setup parameters to start SCO/eSCO connection */
568 if (is_orig) {
569 bta_ag_cb.sco.is_local = true;
570 /* Set eSCO Mode */
571 if (get_btm_client_interface().sco.BTM_SetEScoMode(¶ms) != tBTM_STATUS::BTM_SUCCESS) {
572 log::warn("Unable to set ESCO mode");
573 }
574 bta_ag_cb.sco.p_curr_scb = p_scb;
575 /* save the current codec as sco_codec can be updated while SCO is open. */
576 p_scb->inuse_codec = esco_codec;
577
578 /* tell sys to stop av if any */
579 bta_sys_sco_use(BTA_ID_AG, p_scb->app_id, p_scb->peer_addr);
580
581 bta_ag_cb.sco.cur_idx = p_scb->sco_idx;
582
583 /* Bypass voice settings if enhanced SCO setup command is supported */
584 if (!(bluetooth::shim::GetController()->IsSupported(
585 bluetooth::hci::OpCode::ENHANCED_SETUP_SYNCHRONOUS_CONNECTION))) {
586 if (esco_codec == tBTA_AG_UUID_CODEC::UUID_CODEC_MSBC ||
587 esco_codec == tBTA_AG_UUID_CODEC::UUID_CODEC_LC3) {
588 get_btm_client_interface().sco.BTM_WriteVoiceSettings(BTM_VOICE_SETTING_TRANS);
589 } else {
590 get_btm_client_interface().sco.BTM_WriteVoiceSettings(BTM_VOICE_SETTING_CVSD);
591 }
592 }
593
594 if (get_btm_client_interface().sco.BTM_CreateSco(
595 &p_scb->peer_addr, true, params.packet_types, &p_scb->sco_idx,
596 bta_ag_sco_conn_cback, bta_ag_sco_disc_cback) == tBTM_STATUS::BTM_CMD_STARTED) {
597 /* Initiating the connection, set the current sco handle */
598 bta_ag_cb.sco.cur_idx = p_scb->sco_idx;
599 /* Configure input/output data. */
600 hfp_hal_interface::set_codec_datapath(esco_codec);
601 log::verbose("initiated SCO connection");
602 }
603
604 log::debug("Initiating AG SCO inx 0x{:04x}, pkt types 0x{:04x}", p_scb->sco_idx,
605 params.packet_types);
606 } else {
607 /* Not initiating, go to listen mode */
608 tBTM_STATUS btm_status = get_btm_client_interface().sco.BTM_CreateSco(
609 &p_scb->peer_addr, false, params.packet_types, &p_scb->sco_idx, bta_ag_sco_conn_cback,
610 bta_ag_sco_disc_cback);
611 if (btm_status == tBTM_STATUS::BTM_CMD_STARTED) {
612 if (get_btm_client_interface().sco.BTM_RegForEScoEvts(
613 p_scb->sco_idx, bta_ag_esco_connreq_cback) != tBTM_STATUS::BTM_SUCCESS) {
614 log::warn("Unable to register for ESCO events");
615 }
616 }
617 log::debug("Listening AG SCO inx 0x{:04x} status:{} pkt types 0x{:04x}", p_scb->sco_idx,
618 btm_status_text(btm_status), params.packet_types);
619 }
620 log::debug("AFTER {}", p_scb->ToString());
621 }
622
updateCodecParametersFromProviderInfo(tBTA_AG_UUID_CODEC esco_codec,enh_esco_params_t & params)623 void updateCodecParametersFromProviderInfo(tBTA_AG_UUID_CODEC esco_codec,
624 enh_esco_params_t& params) {
625 if (bta_ag_is_sco_managed_by_audio() && !sco_config_map.empty()) {
626 auto sco_config_it = sco_config_map.find(esco_codec);
627 if (sco_config_it == sco_config_map.end()) {
628 log::error("cannot find sco config for esco_codec index={}",
629 bta_ag_uuid_codec_text(esco_codec));
630 return;
631 }
632 log::debug("use ProviderInfo to update (e)sco parameters");
633 params.input_data_path = sco_config_it->second.inputDataPath;
634 params.output_data_path = sco_config_it->second.outputDataPath;
635 if (!sco_config_it->second.useControllerCodec) {
636 log::debug("use DSP Codec instead of controller codec");
637
638 esco_coding_format_t codingFormat = codec_coding_format_map[esco_codec];
639 params.input_coding_format.coding_format = codingFormat;
640 params.output_coding_format.coding_format = codingFormat;
641 params.input_bandwidth = TXRX_64KBITS_RATE;
642 params.output_bandwidth = TXRX_64KBITS_RATE;
643 }
644 }
645 }
646
647 /*******************************************************************************
648 *
649 * Function bta_ag_codec_negotiation_timer_cback
650 *
651 * Description
652 *
653 *
654 * Returns void
655 *
656 ******************************************************************************/
bta_ag_codec_negotiation_timer_cback(void * data)657 static void bta_ag_codec_negotiation_timer_cback(void* data) {
658 log::warn("Codec negotiation timeout");
659 tBTA_AG_SCB* p_scb = (tBTA_AG_SCB*)data;
660
661 /* Announce that codec negotiation failed. */
662 bta_ag_sco_codec_nego(p_scb, false);
663
664 /* call app callback */
665 bta_ag_cback_sco(p_scb, BTA_AG_AUDIO_CLOSE_EVT);
666 }
667
668 /*******************************************************************************
669 *
670 * Function bta_ag_codec_negotiate
671 *
672 * Description Initiate codec negotiation by sending AT command.
673 * If not necessary, skip negotiation.
674 *
675 * Returns void
676 *
677 ******************************************************************************/
bta_ag_codec_negotiate(tBTA_AG_SCB * p_scb)678 void bta_ag_codec_negotiate(tBTA_AG_SCB* p_scb) {
679 bta_ag_cb.sco.p_curr_scb = p_scb;
680 uint8_t* p_rem_feat = get_btm_client_interface().peer.BTM_ReadRemoteFeatures(p_scb->peer_addr);
681 bool sdp_wbs_support = p_scb->peer_sdp_features & BTA_AG_FEAT_WBS_SUPPORT;
682 bool sdp_swb_support = p_scb->peer_sdp_features & BTA_AG_FEAT_SWB_SUPPORT;
683
684 if (p_rem_feat == nullptr) {
685 log::warn("Skip codec negotiation, failed to read remote features");
686 bta_ag_sco_codec_nego(p_scb, false);
687 return;
688 }
689
690 // Workaround for misbehaving HFs, which indicate which one is not support on
691 // Transparent Synchronous Data in Remote Supported Features, WBS and SWB in SDP
692 // and Codec Negotiation in BRSF. Fluoride will assume CVSD codec by default.
693 // In Sony XAV AX100 car kit and Sony MW600 Headset case, which indicate
694 // Transparent Synchronous Data and WBS support, but no codec negotiation
695 // support, using mSBC codec can result background noise or no audio.
696 // In Skullcandy JIB case, which indicate WBS and codec negotiation support,
697 // but no Transparent Synchronous Data support, using mSBC codec can result
698 // SCO setup fail by Firmware reject.
699 if (!HCI_LMP_TRANSPNT_SUPPORTED(p_rem_feat) ||
700 !(sdp_wbs_support ||
701 (com::android::bluetooth::flags::choose_wrong_hfp_codec_in_specific_config() &&
702 sdp_swb_support)) ||
703 !(p_scb->peer_features & BTA_AG_PEER_FEAT_CODEC)) {
704 log::info("Assume CVSD by default due to mask mismatch");
705 p_scb->sco_codec = BTM_SCO_CODEC_CVSD;
706 }
707 const bool aptx_voice = is_hfp_aptx_voice_enabled() &&
708 (get_swb_codec_status(bluetooth::headset::BTHF_SWB_CODEC_VENDOR_APTX,
709 &p_scb->peer_addr) ||
710 p_scb->is_aptx_swb_codec);
711 log::verbose("aptx_voice={}, is_aptx_swb_codec={}, Q0 codec supported={}", aptx_voice,
712 p_scb->is_aptx_swb_codec,
713 (p_scb->peer_codecs & BTA_AG_SCO_APTX_SWB_SETTINGS_Q0_MASK) != 0);
714
715 if (((p_scb->codec_updated || p_scb->codec_fallback) && (p_scb->features & BTA_AG_FEAT_CODEC) &&
716 (p_scb->peer_features & BTA_AG_PEER_FEAT_CODEC)) ||
717 (aptx_voice)) {
718 log::info("Starting codec negotiation");
719 /* Change the power mode to Active until SCO open is completed. */
720 bta_sys_busy(BTA_ID_AG, p_scb->app_id, p_scb->peer_addr);
721
722 if (get_swb_codec_status(bluetooth::headset::BTHF_SWB_CODEC_VENDOR_APTX, &p_scb->peer_addr) &&
723 (p_scb->peer_codecs & BTA_AG_SCO_APTX_SWB_SETTINGS_Q0_MASK)) {
724 if (p_scb->is_aptx_swb_codec == false) {
725 p_scb->sco_codec = BTA_AG_SCO_APTX_SWB_SETTINGS_Q0;
726 p_scb->is_aptx_swb_codec = true;
727 }
728 log::verbose("Sending +QCS, sco_codec={}, is_aptx_swb_codec={}", p_scb->sco_codec,
729 p_scb->is_aptx_swb_codec);
730 /* Send +QCS to the peer */
731 bta_ag_send_qcs(p_scb);
732 } else {
733 if (aptx_voice) {
734 p_scb->sco_codec = BTM_SCO_CODEC_MSBC;
735 p_scb->is_aptx_swb_codec = false;
736 }
737 log::verbose("Sending +BCS, sco_codec={}, is_aptx_swb_codec={}", p_scb->sco_codec,
738 p_scb->is_aptx_swb_codec);
739 /* Send +BCS to the peer */
740 bta_ag_send_bcs(p_scb);
741 }
742
743 /* Start timer to handle timeout */
744 alarm_set_on_mloop(p_scb->codec_negotiation_timer, BTA_AG_CODEC_NEGOTIATION_TIMEOUT_MS,
745 bta_ag_codec_negotiation_timer_cback, p_scb);
746 } else {
747 /* use same codec type as previous SCO connection, skip codec negotiation */
748 log::info("Skip codec negotiation, using the same codec");
749 bta_ag_sco_codec_nego(p_scb, true);
750 }
751 }
752
bta_ag_sco_event(tBTA_AG_SCB * p_scb,uint8_t event)753 static void bta_ag_sco_event(tBTA_AG_SCB* p_scb, uint8_t event) {
754 tBTA_AG_SCO_CB* p_sco = &bta_ag_cb.sco;
755 uint8_t previous_state = p_sco->state;
756 log::info("device:{} index:0x{:04x} state:{}[{}] event:{}[{}]", p_scb->peer_addr, p_scb->sco_idx,
757 bta_ag_sco_state_str(p_sco->state), p_sco->state, bta_ag_sco_evt_str(event), event);
758
759 switch (p_sco->state) {
760 case BTA_AG_SCO_SHUTDOWN_ST:
761 switch (event) {
762 case BTA_AG_SCO_LISTEN_E:
763 /* create sco listen connection */
764 bta_ag_create_sco(p_scb, false);
765 p_sco->state = BTA_AG_SCO_LISTEN_ST;
766 break;
767
768 default:
769 log::warn("BTA_AG_SCO_SHUTDOWN_ST: Ignoring event {}[{}]", bta_ag_sco_evt_str(event),
770 event);
771 break;
772 }
773 break;
774
775 case BTA_AG_SCO_LISTEN_ST:
776 switch (event) {
777 case BTA_AG_SCO_LISTEN_E:
778 /* create sco listen connection (Additional channel) */
779 bta_ag_create_sco(p_scb, false);
780 break;
781
782 case BTA_AG_SCO_OPEN_E:
783 /* remove listening connection */
784 bta_ag_remove_sco(p_scb, false);
785
786 /* start codec negotiation */
787 p_sco->state = BTA_AG_SCO_CODEC_ST;
788 bta_ag_codec_negotiate(p_scb);
789 break;
790
791 case BTA_AG_SCO_SHUTDOWN_E:
792 /* remove listening connection */
793 bta_ag_remove_sco(p_scb, false);
794
795 if (p_scb == p_sco->p_curr_scb) {
796 p_sco->p_curr_scb = nullptr;
797 }
798
799 /* If last SCO instance then finish shutting down */
800 if (!bta_ag_other_scb_open(p_scb)) {
801 p_sco->state = BTA_AG_SCO_SHUTDOWN_ST;
802 }
803 break;
804
805 case BTA_AG_SCO_CLOSE_E:
806 /* remove listening connection */
807 /* Ignore the event. Keep listening SCO for the active SLC */
808 log::warn("BTA_AG_SCO_LISTEN_ST: Ignoring event {}[{}]", bta_ag_sco_evt_str(event),
809 event);
810 break;
811
812 case BTA_AG_SCO_CONN_CLOSE_E:
813 /* sco failed; create sco listen connection */
814 bta_ag_create_sco(p_scb, false);
815 p_sco->state = BTA_AG_SCO_LISTEN_ST;
816 break;
817
818 default:
819 log::warn("BTA_AG_SCO_LISTEN_ST: Ignoring event {}[{}]", bta_ag_sco_evt_str(event),
820 event);
821 break;
822 }
823 break;
824
825 case BTA_AG_SCO_CODEC_ST:
826 switch (event) {
827 case BTA_AG_SCO_LISTEN_E:
828 /* create sco listen connection (Additional channel) */
829 bta_ag_create_sco(p_scb, false);
830 break;
831
832 case BTA_AG_SCO_CN_DONE_E:
833 /* create sco connection to peer */
834 bta_ag_create_sco(p_scb, true);
835 p_sco->state = BTA_AG_SCO_OPENING_ST;
836 break;
837
838 case BTA_AG_SCO_XFER_E:
839 /* save xfer scb */
840 p_sco->p_xfer_scb = p_scb;
841 p_sco->state = BTA_AG_SCO_CLOSE_XFER_ST;
842 break;
843
844 case BTA_AG_SCO_SHUTDOWN_E:
845 /* remove listening connection */
846 bta_ag_remove_sco(p_scb, false);
847
848 if (p_scb == p_sco->p_curr_scb) {
849 p_sco->p_curr_scb = nullptr;
850 }
851
852 /* If last SCO instance then finish shutting down */
853 if (!bta_ag_other_scb_open(p_scb)) {
854 p_sco->state = BTA_AG_SCO_SHUTDOWN_ST;
855 } else if (com::android::bluetooth::flags::
856 update_sco_state_correctly_on_rfcomm_disconnect_during_codec_nego()) {
857 /* just go back to listening */
858 p_sco->state = BTA_AG_SCO_LISTEN_ST;
859 }
860 break;
861
862 case BTA_AG_SCO_CLOSE_E:
863 /* sco open is not started yet. just go back to listening */
864 p_sco->state = BTA_AG_SCO_LISTEN_ST;
865 break;
866
867 case BTA_AG_SCO_CONN_CLOSE_E:
868 /* sco failed; create sco listen connection */
869 bta_ag_create_sco(p_scb, false);
870 p_sco->state = BTA_AG_SCO_LISTEN_ST;
871 break;
872
873 default:
874 log::warn("BTA_AG_SCO_CODEC_ST: Ignoring event {}[{}]", bta_ag_sco_evt_str(event), event);
875 break;
876 }
877 break;
878
879 case BTA_AG_SCO_OPENING_ST:
880 switch (event) {
881 case BTA_AG_SCO_LISTEN_E:
882 /* second headset has now joined */
883 /* create sco listen connection (Additional channel) */
884 if (p_scb != p_sco->p_curr_scb) {
885 bta_ag_create_sco(p_scb, false);
886 }
887 break;
888
889 case BTA_AG_SCO_REOPEN_E:
890 /* start codec negotiation */
891 p_sco->state = BTA_AG_SCO_CODEC_ST;
892 bta_ag_codec_negotiate(p_scb);
893 break;
894
895 case BTA_AG_SCO_XFER_E:
896 /* save xfer scb */
897 p_sco->p_xfer_scb = p_scb;
898 p_sco->state = BTA_AG_SCO_CLOSE_XFER_ST;
899 break;
900
901 case BTA_AG_SCO_CLOSE_E:
902 p_sco->state = BTA_AG_SCO_OPEN_CL_ST;
903 break;
904
905 case BTA_AG_SCO_SHUTDOWN_E:
906 /* If not opening scb, just close it */
907 if (p_scb != p_sco->p_curr_scb) {
908 /* remove listening connection */
909 bta_ag_remove_sco(p_scb, false);
910 } else {
911 p_sco->state = BTA_AG_SCO_SHUTTING_ST;
912 }
913
914 break;
915
916 case BTA_AG_SCO_CONN_OPEN_E:
917 p_sco->state = BTA_AG_SCO_OPEN_ST;
918 break;
919
920 case BTA_AG_SCO_CONN_CLOSE_E:
921 /* sco failed; create sco listen connection */
922 bta_ag_create_sco(p_scb, false);
923 p_sco->state = BTA_AG_SCO_LISTEN_ST;
924 break;
925
926 default:
927 log::warn("BTA_AG_SCO_OPENING_ST: Ignoring event {}[{}]", bta_ag_sco_evt_str(event),
928 event);
929 break;
930 }
931 break;
932
933 case BTA_AG_SCO_OPEN_CL_ST:
934 switch (event) {
935 case BTA_AG_SCO_XFER_E:
936 /* save xfer scb */
937 p_sco->p_xfer_scb = p_scb;
938
939 p_sco->state = BTA_AG_SCO_CLOSE_XFER_ST;
940 break;
941
942 case BTA_AG_SCO_OPEN_E:
943 p_sco->state = BTA_AG_SCO_OPENING_ST;
944 break;
945
946 case BTA_AG_SCO_SHUTDOWN_E:
947 /* If not opening scb, just close it */
948 if (p_scb != p_sco->p_curr_scb) {
949 /* remove listening connection */
950 bta_ag_remove_sco(p_scb, false);
951 } else {
952 p_sco->state = BTA_AG_SCO_SHUTTING_ST;
953 }
954
955 break;
956
957 case BTA_AG_SCO_CONN_OPEN_E:
958 /* close sco connection */
959 bta_ag_remove_sco(p_scb, true);
960
961 p_sco->state = BTA_AG_SCO_CLOSING_ST;
962 break;
963
964 case BTA_AG_SCO_CONN_CLOSE_E:
965 /* sco failed; create sco listen connection */
966
967 p_sco->state = BTA_AG_SCO_LISTEN_ST;
968 break;
969
970 default:
971 log::warn("BTA_AG_SCO_OPEN_CL_ST: Ignoring event {}[{}]", bta_ag_sco_evt_str(event),
972 event);
973 break;
974 }
975 break;
976
977 case BTA_AG_SCO_OPEN_XFER_ST:
978 switch (event) {
979 case BTA_AG_SCO_CLOSE_E:
980 /* close sco connection */
981 bta_ag_remove_sco(p_scb, true);
982
983 p_sco->state = BTA_AG_SCO_CLOSING_ST;
984 break;
985
986 case BTA_AG_SCO_SHUTDOWN_E:
987 /* remove all connection */
988 bta_ag_remove_sco(p_scb, false);
989 p_sco->state = BTA_AG_SCO_SHUTTING_ST;
990
991 break;
992
993 case BTA_AG_SCO_CONN_CLOSE_E:
994 /* closed sco; place in listen mode and
995 accept the transferred connection */
996 bta_ag_create_sco(p_scb, false); /* Back into listen mode */
997
998 /* Accept sco connection with xfer scb */
999 bta_ag_sco_conn_rsp(p_sco->p_xfer_scb, &p_sco->conn_data);
1000 p_sco->state = BTA_AG_SCO_OPENING_ST;
1001 p_sco->p_curr_scb = p_sco->p_xfer_scb;
1002 p_sco->cur_idx = p_sco->p_xfer_scb->sco_idx;
1003 p_sco->p_xfer_scb = nullptr;
1004 break;
1005
1006 default:
1007 log::warn("BTA_AG_SCO_OPEN_XFER_ST: Ignoring event {}[{}]", bta_ag_sco_evt_str(event),
1008 event);
1009 break;
1010 }
1011 break;
1012
1013 case BTA_AG_SCO_OPEN_ST:
1014 switch (event) {
1015 case BTA_AG_SCO_LISTEN_E:
1016 /* second headset has now joined */
1017 /* create sco listen connection (Additional channel) */
1018 if (p_scb != p_sco->p_curr_scb) {
1019 bta_ag_create_sco(p_scb, false);
1020 }
1021 break;
1022
1023 case BTA_AG_SCO_XFER_E:
1024 /* close current sco connection */
1025 bta_ag_remove_sco(p_sco->p_curr_scb, true);
1026
1027 /* save xfer scb */
1028 p_sco->p_xfer_scb = p_scb;
1029
1030 p_sco->state = BTA_AG_SCO_CLOSE_XFER_ST;
1031 break;
1032
1033 case BTA_AG_SCO_CLOSE_E:
1034 /* close sco connection if active */
1035 if (bta_ag_remove_sco(p_scb, true)) {
1036 p_sco->state = BTA_AG_SCO_CLOSING_ST;
1037 }
1038 break;
1039
1040 case BTA_AG_SCO_SHUTDOWN_E:
1041 /* remove all listening connections */
1042 bta_ag_remove_sco(p_scb, false);
1043
1044 /* If SCO was active on this scb, close it */
1045 if (p_scb == p_sco->p_curr_scb) {
1046 p_sco->state = BTA_AG_SCO_SHUTTING_ST;
1047 }
1048 break;
1049
1050 case BTA_AG_SCO_CONN_CLOSE_E:
1051 /* peer closed sco; create sco listen connection */
1052 bta_ag_create_sco(p_scb, false);
1053 p_sco->state = BTA_AG_SCO_LISTEN_ST;
1054 break;
1055
1056 default:
1057 log::warn("BTA_AG_SCO_OPEN_ST: Ignoring event {}[{}]", bta_ag_sco_evt_str(event), event);
1058 break;
1059 }
1060 break;
1061
1062 case BTA_AG_SCO_CLOSING_ST:
1063 switch (event) {
1064 case BTA_AG_SCO_LISTEN_E:
1065 /* create sco listen connection (Additional channel) */
1066 if (p_scb != p_sco->p_curr_scb) {
1067 bta_ag_create_sco(p_scb, false);
1068 }
1069 break;
1070
1071 case BTA_AG_SCO_OPEN_E:
1072 p_sco->state = BTA_AG_SCO_CLOSE_OP_ST;
1073 break;
1074
1075 case BTA_AG_SCO_XFER_E:
1076 /* save xfer scb */
1077 p_sco->p_xfer_scb = p_scb;
1078
1079 p_sco->state = BTA_AG_SCO_CLOSE_XFER_ST;
1080 break;
1081
1082 case BTA_AG_SCO_SHUTDOWN_E:
1083 /* If not closing scb, just close it */
1084 if (p_scb != p_sco->p_curr_scb) {
1085 /* remove listening connection */
1086 bta_ag_remove_sco(p_scb, false);
1087 } else {
1088 p_sco->state = BTA_AG_SCO_SHUTTING_ST;
1089 }
1090
1091 break;
1092
1093 case BTA_AG_SCO_CONN_CLOSE_E:
1094 /* peer closed sco; create sco listen connection */
1095 bta_ag_create_sco(p_scb, false);
1096
1097 p_sco->state = BTA_AG_SCO_LISTEN_ST;
1098 break;
1099
1100 default:
1101 log::warn("BTA_AG_SCO_CLOSING_ST: Ignoring event {}[{}]", bta_ag_sco_evt_str(event),
1102 event);
1103 break;
1104 }
1105 break;
1106
1107 case BTA_AG_SCO_CLOSE_OP_ST:
1108 switch (event) {
1109 case BTA_AG_SCO_CLOSE_E:
1110 p_sco->state = BTA_AG_SCO_CLOSING_ST;
1111 break;
1112
1113 case BTA_AG_SCO_SHUTDOWN_E:
1114 p_sco->state = BTA_AG_SCO_SHUTTING_ST;
1115 break;
1116
1117 case BTA_AG_SCO_CONN_CLOSE_E:
1118 /* start codec negotiation */
1119 p_sco->state = BTA_AG_SCO_CODEC_ST;
1120 bta_ag_codec_negotiate(p_scb);
1121 break;
1122
1123 case BTA_AG_SCO_LISTEN_E:
1124 /* create sco listen connection (Additional channel) */
1125 if (p_scb != p_sco->p_curr_scb) {
1126 bta_ag_create_sco(p_scb, false);
1127 }
1128 break;
1129
1130 default:
1131 log::warn("BTA_AG_SCO_CLOSE_OP_ST: Ignoring event {}[{}]", bta_ag_sco_evt_str(event),
1132 event);
1133 break;
1134 }
1135 break;
1136
1137 case BTA_AG_SCO_CLOSE_XFER_ST:
1138 switch (event) {
1139 case BTA_AG_SCO_CONN_OPEN_E:
1140 /* close sco connection so headset can be transferred
1141 Probably entered this state from "opening state" */
1142 bta_ag_remove_sco(p_scb, true);
1143 break;
1144
1145 case BTA_AG_SCO_CLOSE_E:
1146 /* clear xfer scb */
1147 p_sco->p_xfer_scb = nullptr;
1148
1149 p_sco->state = BTA_AG_SCO_CLOSING_ST;
1150 break;
1151
1152 case BTA_AG_SCO_SHUTDOWN_E:
1153 /* clear xfer scb */
1154 p_sco->p_xfer_scb = nullptr;
1155
1156 p_sco->state = BTA_AG_SCO_SHUTTING_ST;
1157 break;
1158
1159 case BTA_AG_SCO_CN_DONE_E:
1160 case BTA_AG_SCO_CONN_CLOSE_E: {
1161 /* closed sco; place old sco in listen mode,
1162 take current sco out of listen, and
1163 create originating sco for current */
1164 bta_ag_create_sco(p_scb, false);
1165 bta_ag_remove_sco(p_sco->p_xfer_scb, false);
1166
1167 /* start codec negotiation */
1168 p_sco->state = BTA_AG_SCO_CODEC_ST;
1169 tBTA_AG_SCB* p_cn_scb = p_sco->p_xfer_scb;
1170 p_sco->p_xfer_scb = nullptr;
1171 bta_ag_codec_negotiate(p_cn_scb);
1172 break;
1173 }
1174
1175 default:
1176 log::warn("BTA_AG_SCO_CLOSE_XFER_ST: Ignoring event {}[{}]", bta_ag_sco_evt_str(event),
1177 event);
1178 break;
1179 }
1180 break;
1181
1182 case BTA_AG_SCO_SHUTTING_ST:
1183 switch (event) {
1184 case BTA_AG_SCO_CONN_OPEN_E:
1185 /* close sco connection; wait for conn close event */
1186 bta_ag_remove_sco(p_scb, true);
1187 break;
1188
1189 case BTA_AG_SCO_CONN_CLOSE_E:
1190 /* If last SCO instance then finish shutting down */
1191 if (!bta_ag_other_scb_open(p_scb)) {
1192 p_sco->state = BTA_AG_SCO_SHUTDOWN_ST;
1193 bta_sys_sco_unuse(BTA_ID_AG, p_scb->app_id, p_scb->peer_addr);
1194 } else /* Other instance is still listening */
1195 {
1196 p_sco->state = BTA_AG_SCO_LISTEN_ST;
1197 }
1198
1199 /* If SCO closed for other HS which is not being disconnected,
1200 then create listen sco connection for it as scb still open */
1201 if (bta_ag_scb_open(p_scb)) {
1202 bta_ag_create_sco(p_scb, false);
1203 p_sco->state = BTA_AG_SCO_LISTEN_ST;
1204 }
1205
1206 if (p_scb == p_sco->p_curr_scb) {
1207 p_sco->p_curr_scb->sco_idx = BTM_INVALID_SCO_INDEX;
1208 p_sco->p_curr_scb = nullptr;
1209 }
1210 break;
1211
1212 case BTA_AG_SCO_LISTEN_E:
1213 /* create sco listen connection (Additional channel) */
1214 if (p_scb != p_sco->p_curr_scb) {
1215 bta_ag_create_sco(p_scb, false);
1216 }
1217 break;
1218
1219 case BTA_AG_SCO_SHUTDOWN_E:
1220 if (!bta_ag_other_scb_open(p_scb)) {
1221 p_sco->state = BTA_AG_SCO_SHUTDOWN_ST;
1222 } else /* Other instance is still listening */
1223 {
1224 p_sco->state = BTA_AG_SCO_LISTEN_ST;
1225 }
1226
1227 if (p_scb == p_sco->p_curr_scb) {
1228 p_sco->p_curr_scb->sco_idx = BTM_INVALID_SCO_INDEX;
1229 p_sco->p_curr_scb = nullptr;
1230 }
1231 break;
1232
1233 default:
1234 log::warn("BTA_AG_SCO_SHUTTING_ST: Ignoring event {}[{}]", bta_ag_sco_evt_str(event),
1235 event);
1236 break;
1237 }
1238 break;
1239
1240 default:
1241 break;
1242 }
1243 if (p_sco->state != previous_state) {
1244 log::warn(
1245 "SCO_state_change: [{}(0x{:02x})]->[{}(0x{:02x})] after event "
1246 "[{}(0x{:02x})]",
1247 bta_ag_sco_state_str(previous_state), previous_state,
1248 bta_ag_sco_state_str(p_sco->state), p_sco->state, bta_ag_sco_evt_str(event), event);
1249 }
1250 }
1251
1252 /*******************************************************************************
1253 *
1254 * Function bta_ag_sco_is_open
1255 *
1256 * Description Check if sco is open for this scb.
1257 *
1258 *
1259 * Returns true if sco open for this scb, false otherwise.
1260 *
1261 ******************************************************************************/
bta_ag_sco_is_open(tBTA_AG_SCB * p_scb)1262 bool bta_ag_sco_is_open(tBTA_AG_SCB* p_scb) {
1263 return (bta_ag_cb.sco.state == BTA_AG_SCO_OPEN_ST) && (bta_ag_cb.sco.p_curr_scb == p_scb);
1264 }
1265
1266 /*******************************************************************************
1267 *
1268 * Function bta_ag_sco_is_opening
1269 *
1270 * Description Check if sco is in Opening state.
1271 *
1272 *
1273 * Returns true if sco is in Opening state for this scb, false
1274 * otherwise.
1275 *
1276 ******************************************************************************/
bta_ag_sco_is_opening(tBTA_AG_SCB * p_scb)1277 bool bta_ag_sco_is_opening(tBTA_AG_SCB* p_scb) {
1278 return (bta_ag_cb.sco.state == BTA_AG_SCO_OPENING_ST) && (bta_ag_cb.sco.p_curr_scb == p_scb);
1279 }
1280
1281 /*******************************************************************************
1282 *
1283 * Function bta_ag_sco_listen
1284 *
1285 * Description
1286 *
1287 *
1288 * Returns void
1289 *
1290 ******************************************************************************/
bta_ag_sco_listen(tBTA_AG_SCB * p_scb,const tBTA_AG_DATA &)1291 void bta_ag_sco_listen(tBTA_AG_SCB* p_scb, const tBTA_AG_DATA& /* data */) {
1292 log::info("{}", p_scb->peer_addr);
1293 bta_ag_sco_event(p_scb, BTA_AG_SCO_LISTEN_E);
1294 }
1295
1296 /*******************************************************************************
1297 *
1298 * Function bta_ag_sco_open
1299 *
1300 * Description
1301 *
1302 *
1303 * Returns void
1304 *
1305 ******************************************************************************/
bta_ag_sco_open(tBTA_AG_SCB * p_scb,const tBTA_AG_DATA & data)1306 void bta_ag_sco_open(tBTA_AG_SCB* p_scb, const tBTA_AG_DATA& data) {
1307 if (!sco_allowed) {
1308 log::info("not opening sco, by policy");
1309 return;
1310 }
1311
1312 p_scb->disabled_codecs = data.api_audio_open.disabled_codecs;
1313 log::info("disabled_codecs = {}, sco_codec = {}", p_scb->disabled_codecs, p_scb->sco_codec);
1314
1315 if (p_scb->disabled_codecs & p_scb->sco_codec) {
1316 tBTA_AG_PEER_CODEC updated_codec = BTM_SCO_CODEC_NONE;
1317
1318 if (hfp_hal_interface::get_swb_supported() && (p_scb->peer_codecs & BTM_SCO_CODEC_LC3) &&
1319 !(p_scb->disabled_codecs & BTM_SCO_CODEC_LC3)) {
1320 updated_codec = BTM_SCO_CODEC_LC3;
1321 } else if ((p_scb->peer_codecs & BTM_SCO_CODEC_MSBC) &&
1322 !(p_scb->disabled_codecs & BTM_SCO_CODEC_MSBC)) {
1323 updated_codec = BTM_SCO_CODEC_MSBC;
1324 } else {
1325 updated_codec = BTM_SCO_CODEC_CVSD;
1326 }
1327
1328 p_scb->sco_codec = updated_codec;
1329 p_scb->codec_updated = true;
1330 }
1331
1332 /* if another scb using sco, this is a transfer */
1333 if (bta_ag_cb.sco.p_curr_scb && bta_ag_cb.sco.p_curr_scb != p_scb) {
1334 log::info("transfer {} -> {}", bta_ag_cb.sco.p_curr_scb->peer_addr, p_scb->peer_addr);
1335 bta_ag_sco_event(p_scb, BTA_AG_SCO_XFER_E);
1336 } else {
1337 /* else it is an open */
1338 log::info("open {}", p_scb->peer_addr);
1339 bta_ag_sco_event(p_scb, BTA_AG_SCO_OPEN_E);
1340 }
1341 }
1342
1343 /*******************************************************************************
1344 *
1345 * Function bta_ag_sco_close
1346 *
1347 * Description
1348 *
1349 *
1350 * Returns void
1351 *
1352 ******************************************************************************/
bta_ag_sco_close(tBTA_AG_SCB * p_scb,const tBTA_AG_DATA &)1353 void bta_ag_sco_close(tBTA_AG_SCB* p_scb, const tBTA_AG_DATA& /* data */) {
1354 /* if scb is in use */
1355 /* sco_idx is not allocated in SCO_CODEC_ST, still need to move to listen
1356 * state. */
1357 if ((p_scb->sco_idx != BTM_INVALID_SCO_INDEX) || (bta_ag_cb.sco.state == BTA_AG_SCO_CODEC_ST)) {
1358 log::verbose("bta_ag_sco_close: sco_inx = {}", p_scb->sco_idx);
1359 bta_ag_sco_event(p_scb, BTA_AG_SCO_CLOSE_E);
1360 }
1361 }
1362
1363 /*******************************************************************************
1364 *
1365 * Function bta_ag_sco_codec_nego
1366 *
1367 * Description Handles result of eSCO codec negotiation
1368 *
1369 *
1370 * Returns void
1371 *
1372 ******************************************************************************/
bta_ag_sco_codec_nego(tBTA_AG_SCB * p_scb,bool result)1373 void bta_ag_sco_codec_nego(tBTA_AG_SCB* p_scb, bool result) {
1374 if (result) {
1375 /* Subsequent SCO connection will skip codec negotiation */
1376 log::info("Succeeded for index 0x{:04x}, device {}", p_scb->sco_idx, p_scb->peer_addr);
1377 p_scb->codec_updated = false;
1378 bta_ag_sco_event(p_scb, BTA_AG_SCO_CN_DONE_E);
1379 } else {
1380 /* codec negotiation failed */
1381 log::info("Failed for index 0x{:04x}, device {}", p_scb->sco_idx, p_scb->peer_addr);
1382 bta_ag_sco_event(p_scb, BTA_AG_SCO_CLOSE_E);
1383 }
1384 }
1385
1386 /*******************************************************************************
1387 *
1388 * Function bta_ag_sco_shutdown
1389 *
1390 * Description
1391 *
1392 *
1393 * Returns void
1394 *
1395 ******************************************************************************/
bta_ag_sco_shutdown(tBTA_AG_SCB * p_scb,const tBTA_AG_DATA &)1396 void bta_ag_sco_shutdown(tBTA_AG_SCB* p_scb, const tBTA_AG_DATA& /* data */) {
1397 bta_ag_sco_event(p_scb, BTA_AG_SCO_SHUTDOWN_E);
1398 }
1399
1400 /*******************************************************************************
1401 *
1402 * Function bta_ag_sco_write
1403 *
1404 * Description Writes bytes to decoder interface
1405 *
1406 *
1407 * Returns Number of bytes written
1408 *
1409 ******************************************************************************/
bta_ag_sco_write(const uint8_t * p_buf,uint32_t len)1410 size_t bta_ag_sco_write(const uint8_t* p_buf, uint32_t len) {
1411 if (hfp_software_datapath_enabled && hfp_decode_interface) {
1412 return hfp_decode_interface->Write(p_buf, len);
1413 }
1414 return 0;
1415 }
1416
1417 /*******************************************************************************
1418 *
1419 * Function bta_ag_sco_read
1420 *
1421 * Description Reads bytes from encoder interface
1422 *
1423 *
1424 * Returns Number of bytes read
1425 *
1426 ******************************************************************************/
bta_ag_sco_read(uint8_t * p_buf,uint32_t len)1427 size_t bta_ag_sco_read(uint8_t* p_buf, uint32_t len) {
1428 if (hfp_software_datapath_enabled && hfp_encode_interface) {
1429 return hfp_encode_interface->Read(p_buf, len);
1430 }
1431 return 0;
1432 }
1433
1434 /*******************************************************************************
1435 *
1436 * Function bta_ag_sco_conn_open
1437 *
1438 * Description
1439 *
1440 *
1441 * Returns void
1442 *
1443 ******************************************************************************/
bta_ag_sco_conn_open(tBTA_AG_SCB * p_scb,const tBTA_AG_DATA &)1444 void bta_ag_sco_conn_open(tBTA_AG_SCB* p_scb, const tBTA_AG_DATA& /* data */) {
1445 bta_ag_sco_event(p_scb, BTA_AG_SCO_CONN_OPEN_E);
1446 bta_sys_sco_open(BTA_ID_AG, p_scb->app_id, p_scb->peer_addr);
1447
1448 if (bta_ag_is_sco_managed_by_audio()) {
1449 bool is_controller_codec = false;
1450 if (sco_config_map.find(p_scb->inuse_codec) == sco_config_map.end()) {
1451 log::error("sco_config_map does not have inuse_codec={}",
1452 bta_ag_uuid_codec_text(p_scb->inuse_codec));
1453 } else {
1454 is_controller_codec = sco_config_map[p_scb->inuse_codec].useControllerCodec;
1455 }
1456
1457 if (hfp_software_datapath_enabled) {
1458 if (hfp_encode_interface) {
1459 int sample_rate = codec_uuid_to_sample_rate(p_scb->inuse_codec);
1460 hfp::pcm_config config{.sample_rate_hz = sample_rate};
1461 hfp_encode_interface->UpdateAudioConfigToHal(config);
1462 hfp_decode_interface->UpdateAudioConfigToHal(config);
1463 }
1464 } else {
1465 hfp::offload_config config{
1466 .sco_codec = p_scb->inuse_codec,
1467 .connection_handle = p_scb->conn_handle,
1468 .is_controller_codec = is_controller_codec,
1469 .is_nrec = p_scb->nrec_enabled,
1470 };
1471
1472 hfp_offload_interface->UpdateAudioConfigToHal(config);
1473 }
1474
1475 // ConfirmStreamingRequest before sends callback to java layer
1476 if (hfp_software_datapath_enabled) {
1477 if (hfp_encode_interface) {
1478 hfp_encode_interface->ConfirmStreamingRequest();
1479 hfp_decode_interface->ConfirmStreamingRequest();
1480 }
1481 } else {
1482 hfp_offload_interface->ConfirmStreamingRequest();
1483 }
1484 }
1485
1486 /* call app callback */
1487 bta_ag_cback_sco(p_scb, BTA_AG_AUDIO_OPEN_EVT);
1488
1489 /* reset retransmission_effort_retries*/
1490 p_scb->retransmission_effort_retries = 0;
1491 /* reset to mSBC T2 settings as the preferred */
1492 p_scb->codec_msbc_settings = BTA_AG_SCO_MSBC_SETTINGS_T2;
1493 /* reset to LC3 T2 settings as the preferred */
1494 p_scb->codec_lc3_settings = BTA_AG_SCO_LC3_SETTINGS_T2;
1495 /* reset to SWB Q0 settings as the preferred */
1496 p_scb->codec_aptx_settings = BTA_AG_SCO_APTX_SWB_SETTINGS_Q0;
1497 }
1498
1499 /*******************************************************************************
1500 *
1501 * Function bta_ag_sco_conn_close
1502 *
1503 * Description
1504 *
1505 *
1506 * Returns void
1507 *
1508 ******************************************************************************/
bta_ag_sco_conn_close(tBTA_AG_SCB * p_scb,const tBTA_AG_DATA &)1509 void bta_ag_sco_conn_close(tBTA_AG_SCB* p_scb, const tBTA_AG_DATA& /* data */) {
1510 /* clear current scb */
1511 bta_ag_cb.sco.p_curr_scb = nullptr;
1512 p_scb->sco_idx = BTM_INVALID_SCO_INDEX;
1513 const bool aptx_voice = is_hfp_aptx_voice_enabled() && p_scb->codec_fallback &&
1514 (p_scb->sco_codec == BTA_AG_SCO_APTX_SWB_SETTINGS_Q0);
1515 log::verbose("aptx_voice={}, codec_fallback={:#x}, sco_codec={:#x}", aptx_voice,
1516 p_scb->codec_fallback, p_scb->sco_codec);
1517
1518 /* codec_fallback is set when AG is initiator and connection failed for mSBC.
1519 * OR if codec is msbc and T2 settings failed, then retry Safe T1 settings
1520 * same operations for LC3 settings */
1521 if (p_scb->svc_conn &&
1522 (p_scb->codec_fallback ||
1523 (p_scb->sco_codec == BTM_SCO_CODEC_MSBC &&
1524 p_scb->codec_msbc_settings == BTA_AG_SCO_MSBC_SETTINGS_T1) ||
1525 (p_scb->sco_codec == BTM_SCO_CODEC_LC3 &&
1526 p_scb->codec_lc3_settings == BTA_AG_SCO_LC3_SETTINGS_T1) ||
1527 (com::android::bluetooth::flags::retry_esco_with_zero_retransmission_effort() &&
1528 p_scb->retransmission_effort_retries == 1) ||
1529 aptx_voice ||
1530 (com::android::bluetooth::flags::fix_hfp_qual_1_9() &&
1531 p_scb->sco_codec == BTM_SCO_CODEC_CVSD &&
1532 p_scb->codec_cvsd_settings == BTA_AG_SCO_CVSD_SETTINGS_S1 &&
1533 p_scb->trying_cvsd_safe_settings))) {
1534 bta_ag_sco_event(p_scb, BTA_AG_SCO_REOPEN_E);
1535 } else {
1536 /* Indicate if the closing of audio is because of transfer */
1537 bta_ag_sco_event(p_scb, BTA_AG_SCO_CONN_CLOSE_E);
1538
1539 bta_sys_sco_close(BTA_ID_AG, p_scb->app_id, p_scb->peer_addr);
1540
1541 bta_ag_stream_suspended();
1542
1543 /* if av got suspended by this call, let it resume. */
1544 /* In case call stays alive regardless of sco, av should not be affected. */
1545 if (((p_scb->call_ind == BTA_AG_CALL_INACTIVE) &&
1546 (p_scb->callsetup_ind == BTA_AG_CALLSETUP_NONE)) ||
1547 (p_scb->post_sco == BTA_AG_POST_SCO_CALL_END)) {
1548 bta_sys_sco_unuse(BTA_ID_AG, p_scb->app_id, p_scb->peer_addr);
1549 }
1550
1551 /* call app callback */
1552 bta_ag_cback_sco(p_scb, BTA_AG_AUDIO_CLOSE_EVT);
1553 p_scb->codec_cvsd_settings = BTA_AG_SCO_CVSD_SETTINGS_S4;
1554 p_scb->codec_msbc_settings = BTA_AG_SCO_MSBC_SETTINGS_T2;
1555 p_scb->codec_lc3_settings = BTA_AG_SCO_LC3_SETTINGS_T2;
1556 p_scb->codec_aptx_settings = BTA_AG_SCO_APTX_SWB_SETTINGS_Q0;
1557 }
1558 }
1559
1560 /*******************************************************************************
1561 *
1562 * Function bta_ag_sco_conn_rsp
1563 *
1564 * Description Process the SCO connection request
1565 *
1566 *
1567 * Returns void
1568 *
1569 ******************************************************************************/
bta_ag_sco_conn_rsp(tBTA_AG_SCB * p_scb,tBTM_ESCO_CONN_REQ_EVT_DATA *)1570 void bta_ag_sco_conn_rsp(tBTA_AG_SCB* p_scb, tBTM_ESCO_CONN_REQ_EVT_DATA* /*p_data*/) {
1571 bta_ag_cb.sco.is_local = false;
1572
1573 log::verbose("eSCO {}, state {}",
1574 bluetooth::shim::GetController()->IsSupported(
1575 bluetooth::hci::OpCode::ENHANCED_SETUP_SYNCHRONOUS_CONNECTION),
1576 bta_ag_cb.sco.state);
1577
1578 if (bta_ag_cb.sco.state == BTA_AG_SCO_LISTEN_ST ||
1579 bta_ag_cb.sco.state == BTA_AG_SCO_CLOSE_XFER_ST ||
1580 bta_ag_cb.sco.state == BTA_AG_SCO_OPEN_XFER_ST) {
1581 /* tell sys to stop av if any */
1582 bta_sys_sco_use(BTA_ID_AG, p_scb->app_id, p_scb->peer_addr);
1583 /* When HS initiated SCO, it cannot be WBS. */
1584 }
1585
1586 /* If SCO open was initiated from HS, it must be CVSD */
1587 p_scb->inuse_codec = tBTA_AG_UUID_CODEC::UUID_CODEC_NONE;
1588 /* Send pending commands to create SCO connection to peer */
1589 enh_esco_params_t params = {};
1590 bool offload = hfp_hal_interface::get_offload_enabled();
1591 bta_ag_cb.sco.p_curr_scb = p_scb;
1592 bta_ag_cb.sco.cur_idx = p_scb->sco_idx;
1593
1594 // Local device accepted SCO connection from peer(HF)
1595 // Because HF devices usually do not send AT+BAC and +BCS command,
1596 // and there is no plan to implement corresponding command handlers,
1597 // so we only accept CVSD connection from HF no matter what's
1598 // requested.
1599 if ((p_scb->features & BTA_AG_FEAT_ESCO_S4) &&
1600 (p_scb->peer_features & BTA_AG_PEER_FEAT_ESCO_S4)) {
1601 // HFP >=1.7 eSCO
1602 params = esco_parameters_for_codec(ESCO_CODEC_CVSD_S4, offload);
1603 } else {
1604 // HFP <=1.6 eSCO
1605 params = esco_parameters_for_codec(ESCO_CODEC_CVSD_S3, offload);
1606 }
1607
1608 // HFP v1.8 5.7.3 CVSD coding
1609 tSCO_CONN* p_sco = NULL;
1610 if (p_scb->sco_idx < BTM_MAX_SCO_LINKS) {
1611 p_sco = &btm_cb.sco_cb.sco_db[p_scb->sco_idx];
1612 }
1613 if (p_sco && (p_sco->esco.data.link_type == BTM_LINK_TYPE_SCO ||
1614 !btm_peer_supports_esco_ev3(p_sco->esco.data.bd_addr))) {
1615 params = esco_parameters_for_codec(SCO_CODEC_CVSD_D1, offload);
1616 }
1617
1618 get_btm_client_interface().sco.BTM_EScoConnRsp(p_scb->sco_idx, HCI_SUCCESS, ¶ms);
1619 log::verbose("listening for SCO connection");
1620 }
1621
bta_ag_get_sco_offload_enabled()1622 bool bta_ag_get_sco_offload_enabled() { return hfp_hal_interface::get_offload_enabled(); }
1623
bta_ag_set_sco_offload_enabled(bool value)1624 void bta_ag_set_sco_offload_enabled(bool value) { hfp_hal_interface::enable_offload(value); }
1625
bta_ag_set_sco_allowed(bool value)1626 void bta_ag_set_sco_allowed(bool value) {
1627 sco_allowed = value;
1628 log::verbose("{}", sco_allowed ? "sco now allowed" : "sco now not allowed");
1629 }
1630
bta_ag_is_sco_managed_by_audio()1631 bool bta_ag_is_sco_managed_by_audio() {
1632 bool value = false;
1633 if (com::android::bluetooth::flags::is_sco_managed_by_audio()) {
1634 value = osi_property_get_bool("bluetooth.sco.managed_by_audio", false);
1635 log::verbose("is_sco_managed_by_audio enabled={}", value);
1636 }
1637 return value;
1638 }
1639
bta_ag_stream_suspended()1640 void bta_ag_stream_suspended() {
1641 if (bta_ag_is_sco_managed_by_audio()) {
1642 if (hfp_software_datapath_enabled) {
1643 if (hfp_encode_interface) {
1644 hfp_encode_interface->CancelStreamingRequest();
1645 hfp_decode_interface->CancelStreamingRequest();
1646 }
1647 } else {
1648 if (hfp_offload_interface) {
1649 hfp_offload_interface->CancelStreamingRequest();
1650 }
1651 }
1652 }
1653 }
1654
bta_ag_get_active_device()1655 const RawAddress& bta_ag_get_active_device() { return active_device_addr; }
1656
bta_clear_active_device()1657 void bta_clear_active_device() {
1658 log::debug("Set bta active device to null, current active device:{}", active_device_addr);
1659 if (bta_ag_is_sco_managed_by_audio()) {
1660 if (hfp_software_datapath_enabled) {
1661 if (hfp_encode_interface && !active_device_addr.IsEmpty()) {
1662 hfp_encode_interface->StopSession();
1663 hfp_decode_interface->StopSession();
1664 }
1665 } else {
1666 if (hfp_offload_interface && !active_device_addr.IsEmpty()) {
1667 hfp_offload_interface->StopSession();
1668 }
1669 }
1670 }
1671 active_device_addr = RawAddress::kEmpty;
1672 }
1673
bta_ag_api_set_active_device(const RawAddress & new_active_device)1674 void bta_ag_api_set_active_device(const RawAddress& new_active_device) {
1675 log::info("active_device_addr{}, new_active_device:{}", active_device_addr, new_active_device);
1676 if (new_active_device.IsEmpty()) {
1677 log::error("empty device");
1678 return;
1679 }
1680
1681 if (bta_ag_is_sco_managed_by_audio()) {
1682 // Initialize and start HFP software data path
1683 if (!hfp_client_interface) {
1684 hfp_client_interface = std::unique_ptr<HfpInterface>(HfpInterface::Get());
1685 if (!hfp_client_interface) {
1686 log::error("could not acquire audio source interface");
1687 }
1688 }
1689 hfp_software_datapath_enabled =
1690 osi_property_get_bool("bluetooth.hfp.software_datapath.enabled", false);
1691
1692 // Initialize and start HFP software datapath if enabled
1693 if (hfp_software_datapath_enabled) {
1694 if (hfp_client_interface && !hfp_encode_interface && !hfp_decode_interface) {
1695 hfp_encode_interface = std::unique_ptr<HfpInterface::Encode>(
1696 hfp_client_interface->GetEncode(get_main_thread()));
1697 hfp_decode_interface = std::unique_ptr<HfpInterface::Decode>(
1698 hfp_client_interface->GetDecode(get_main_thread()));
1699 if (!hfp_encode_interface || !hfp_decode_interface) {
1700 log::warn("could not get HFP SW interface");
1701 }
1702 }
1703
1704 if (hfp_encode_interface && hfp_decode_interface) {
1705 if (active_device_addr.IsEmpty()) {
1706 hfp_encode_interface->StartSession();
1707 hfp_decode_interface->StartSession();
1708 }
1709 }
1710 } else { // Initialize and start HFP offloading
1711 if (hfp_client_interface && !hfp_offload_interface) {
1712 hfp_offload_interface = std::unique_ptr<HfpInterface::Offload>(
1713 hfp_client_interface->GetOffload(get_main_thread()));
1714 if (!hfp_offload_interface) {
1715 log::warn("could not get offload interface");
1716 }
1717 }
1718
1719 if (hfp_offload_interface) {
1720 sco_config_map = hfp_offload_interface->GetHfpScoConfig();
1721 // start audio session if there was no previous active device
1722 if (active_device_addr.IsEmpty()) {
1723 hfp_offload_interface->StartSession();
1724 }
1725 }
1726 }
1727 }
1728 active_device_addr = new_active_device;
1729 }
1730