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 is the main implementation file for the BTA audio gateway.
22  *
23  ******************************************************************************/
24 
25 #include <bluetooth/log.h>
26 
27 #include <cstdint>
28 #include <string>
29 #include <vector>
30 
31 #include "bta/ag/bta_ag_int.h"
32 #include "bta/include/bta_hfp_api.h"
33 #include "bta_ag_api.h"
34 #include "bta_api.h"
35 #include "bta_sys.h"
36 #include "btm_api_types.h"
37 #include "internal_include/bt_target.h"
38 #include "macros.h"
39 #include "osi/include/alarm.h"
40 #include "osi/include/compat.h"
41 #include "stack/include/bt_hdr.h"
42 #include "stack/include/btm_client_interface.h"
43 #include "types/raw_address.h"
44 
45 using namespace bluetooth;
46 
47 /*****************************************************************************
48  * Constants and types
49  ****************************************************************************/
50 #define CASE_RETURN_STR(const) \
51   case const:                  \
52     return #const;
53 
bta_ag_res_str(tBTA_AG_RES result)54 static const char* bta_ag_res_str(tBTA_AG_RES result) {
55   switch (result) {
56     CASE_RETURN_STR(BTA_AG_SPK_RES)
57     CASE_RETURN_STR(BTA_AG_MIC_RES)
58     CASE_RETURN_STR(BTA_AG_INBAND_RING_RES)
59     CASE_RETURN_STR(BTA_AG_CIND_RES)
60     CASE_RETURN_STR(BTA_AG_BINP_RES)
61     CASE_RETURN_STR(BTA_AG_IND_RES)
62     CASE_RETURN_STR(BTA_AG_BVRA_RES)
63     CASE_RETURN_STR(BTA_AG_CNUM_RES)
64     CASE_RETURN_STR(BTA_AG_BTRH_RES)
65     CASE_RETURN_STR(BTA_AG_CLCC_RES)
66     CASE_RETURN_STR(BTA_AG_COPS_RES)
67     CASE_RETURN_STR(BTA_AG_IN_CALL_RES)
68     CASE_RETURN_STR(BTA_AG_IN_CALL_CONN_RES)
69     CASE_RETURN_STR(BTA_AG_CALL_WAIT_RES)
70     CASE_RETURN_STR(BTA_AG_OUT_CALL_ORIG_RES)
71     CASE_RETURN_STR(BTA_AG_OUT_CALL_ALERT_RES)
72     CASE_RETURN_STR(BTA_AG_OUT_CALL_CONN_RES)
73     CASE_RETURN_STR(BTA_AG_CALL_CANCEL_RES)
74     CASE_RETURN_STR(BTA_AG_END_CALL_RES)
75     CASE_RETURN_STR(BTA_AG_IN_CALL_HELD_RES)
76     CASE_RETURN_STR(BTA_AG_UNAT_RES)
77     CASE_RETURN_STR(BTA_AG_MULTI_CALL_RES)
78     CASE_RETURN_STR(BTA_AG_BIND_RES)
79     CASE_RETURN_STR(BTA_AG_IND_RES_ON_DEMAND)
80     default:
81       return "Unknown AG Result";
82   }
83 }
84 
bta_ag_evt_str(uint16_t event)85 static const char* bta_ag_evt_str(uint16_t event) {
86   switch (event) {
87     CASE_RETURN_STR(BTA_AG_API_REGISTER_EVT)
88     CASE_RETURN_STR(BTA_AG_API_DEREGISTER_EVT)
89     CASE_RETURN_STR(BTA_AG_API_OPEN_EVT)
90     CASE_RETURN_STR(BTA_AG_API_CLOSE_EVT)
91     CASE_RETURN_STR(BTA_AG_API_AUDIO_OPEN_EVT)
92     CASE_RETURN_STR(BTA_AG_API_AUDIO_CLOSE_EVT)
93     CASE_RETURN_STR(BTA_AG_API_RESULT_EVT)
94     CASE_RETURN_STR(BTA_AG_API_SETCODEC_EVT)
95     CASE_RETURN_STR(BTA_AG_RFC_OPEN_EVT)
96     CASE_RETURN_STR(BTA_AG_RFC_CLOSE_EVT)
97     CASE_RETURN_STR(BTA_AG_RFC_SRV_CLOSE_EVT)
98     CASE_RETURN_STR(BTA_AG_RFC_DATA_EVT)
99     CASE_RETURN_STR(BTA_AG_SCO_OPEN_EVT)
100     CASE_RETURN_STR(BTA_AG_SCO_CLOSE_EVT)
101     CASE_RETURN_STR(BTA_AG_DISC_ACP_RES_EVT)
102     CASE_RETURN_STR(BTA_AG_DISC_INT_RES_EVT)
103     CASE_RETURN_STR(BTA_AG_DISC_OK_EVT)
104     CASE_RETURN_STR(BTA_AG_DISC_FAIL_EVT)
105     CASE_RETURN_STR(BTA_AG_RING_TIMEOUT_EVT)
106     CASE_RETURN_STR(BTA_AG_SVC_TIMEOUT_EVT)
107     CASE_RETURN_STR(BTA_AG_COLLISION_EVT)
108     default:
109       return "Unknown AG Event";
110   }
111 }
112 
bta_ag_state_str(tBTA_AG_STATE state)113 const std::string bta_ag_state_str(tBTA_AG_STATE state) {
114   switch (state) {
115     CASE_RETURN_STRING(BTA_AG_INIT_ST);
116     CASE_RETURN_STRING(BTA_AG_OPENING_ST);
117     CASE_RETURN_STRING(BTA_AG_OPEN_ST);
118     CASE_RETURN_STRING(BTA_AG_CLOSING_ST);
119     default:
120       RETURN_UNKNOWN_TYPE_STRING(tBTA_AG_STATE, state);
121   }
122 }
123 
124 /*****************************************************************************
125  * Global data
126  ****************************************************************************/
127 
128 /* AG control block */
129 tBTA_AG_CB bta_ag_cb;
130 const tBTA_AG_DATA tBTA_AG_DATA::kEmpty = {};
131 
132 /*******************************************************************************
133  *
134  * Function         bta_ag_scb_alloc
135  *
136  * Description      Allocate an AG service control block.
137  *
138  *
139  * Returns          pointer to the scb, or NULL if none could be allocated.
140  *
141  ******************************************************************************/
bta_ag_scb_alloc(void)142 static tBTA_AG_SCB* bta_ag_scb_alloc(void) {
143   tBTA_AG_SCB* p_scb = &bta_ag_cb.scb[0];
144   int i;
145 
146   for (i = 0; i < BTA_AG_MAX_NUM_CLIENTS; i++, p_scb++) {
147     if (!p_scb->in_use) {
148       /* initialize variables */
149       p_scb->in_use = true;
150       p_scb->sco_idx = BTM_INVALID_SCO_INDEX;
151       p_scb->received_at_bac = false;
152       p_scb->codec_updated = false;
153       p_scb->codec_fallback = false;
154       p_scb->trying_cvsd_safe_settings = false;
155       p_scb->retransmission_effort_retries = 0;
156       p_scb->peer_codecs = BTM_SCO_CODEC_CVSD;
157       p_scb->sco_codec = BTM_SCO_CODEC_CVSD;
158       p_scb->peer_version = HFP_HSP_VERSION_UNKNOWN;
159       p_scb->hsp_version = HSP_VERSION_1_2;
160       p_scb->peer_sdp_features = 0;
161       /* set up timers */
162       p_scb->ring_timer = alarm_new("bta_ag.scb_ring_timer");
163       p_scb->collision_timer = alarm_new("bta_ag.scb_collision_timer");
164       p_scb->codec_negotiation_timer = alarm_new("bta_ag.scb_codec_negotiation_timer");
165       /* reset to CVSD S4 settings as the preferred */
166       p_scb->codec_cvsd_settings = BTA_AG_SCO_CVSD_SETTINGS_S4;
167       /* set eSCO mSBC setting to T2 as the preferred */
168       p_scb->codec_msbc_settings = BTA_AG_SCO_MSBC_SETTINGS_T2;
169       p_scb->codec_lc3_settings = BTA_AG_SCO_LC3_SETTINGS_T2;
170       /* set eSCO SWB setting to Q0 as the preferred */
171       p_scb->codec_aptx_settings = BTA_AG_SCO_APTX_SWB_SETTINGS_Q0;
172       p_scb->is_aptx_swb_codec = false;
173       log::verbose("bta_ag_scb_alloc {}", bta_ag_scb_to_idx(p_scb));
174       break;
175     }
176   }
177 
178   if (i == BTA_AG_MAX_NUM_CLIENTS) {
179     /* out of scbs */
180     p_scb = nullptr;
181     log::warn("Out of scbs");
182   }
183   return p_scb;
184 }
185 
186 /*******************************************************************************
187  *
188  * Function         bta_ag_scb_dealloc
189  *
190  * Description      Deallocate a service control block.
191  *
192  *
193  * Returns          void
194  *
195  ******************************************************************************/
bta_ag_scb_dealloc(tBTA_AG_SCB * p_scb)196 void bta_ag_scb_dealloc(tBTA_AG_SCB* p_scb) {
197   uint8_t idx;
198   bool allocated = false;
199 
200   log::verbose("bta_ag_scb_dealloc {}", bta_ag_scb_to_idx(p_scb));
201 
202   /* stop and free timers */
203   alarm_free(p_scb->ring_timer);
204   alarm_free(p_scb->codec_negotiation_timer);
205   alarm_free(p_scb->collision_timer);
206 
207   /* initialize control block */
208   *p_scb = {};
209   p_scb->sco_idx = BTM_INVALID_SCO_INDEX;
210 
211   /* If all scbs are deallocated, callback with disable event */
212   if (!bta_sys_is_register(BTA_ID_AG)) {
213     for (idx = 0; idx < BTA_AG_MAX_NUM_CLIENTS; idx++) {
214       if (bta_ag_cb.scb[idx].in_use) {
215         allocated = true;
216         break;
217       }
218     }
219 
220     if (!allocated) {
221       (*bta_ag_cb.p_cback)(BTA_AG_DISABLE_EVT, nullptr);
222     }
223   }
224 }
225 
226 /*******************************************************************************
227  *
228  * Function         bta_ag_scb_to_idx
229  *
230  * Description      Given a pointer to an scb, return its index.
231  *
232  *
233  * Returns          Index of scb starting from 1
234  *
235  ******************************************************************************/
bta_ag_scb_to_idx(tBTA_AG_SCB * p_scb)236 uint16_t bta_ag_scb_to_idx(tBTA_AG_SCB* p_scb) {
237   /* use array arithmetic to determine index */
238   return static_cast<uint16_t>(p_scb - bta_ag_cb.scb + 1);
239 }
240 
241 /*******************************************************************************
242  *
243  * Function         bta_ag_scb_by_idx
244  *
245  * Description      Given an scb index return pointer to scb.
246  *
247  *
248  * Returns          Pointer to scb or NULL if not allocated.
249  *
250  ******************************************************************************/
bta_ag_scb_by_idx(uint16_t idx)251 tBTA_AG_SCB* bta_ag_scb_by_idx(uint16_t idx) {
252   tBTA_AG_SCB* p_scb;
253 
254   /* verify index */
255   if (idx > 0 && idx <= BTA_AG_MAX_NUM_CLIENTS) {
256     p_scb = &bta_ag_cb.scb[idx - 1];
257     if (!p_scb->in_use) {
258       p_scb = nullptr;
259       log::warn("ag scb idx {} not allocated", idx);
260     }
261   } else {
262     p_scb = nullptr;
263     log::verbose("ag scb idx {} out of range", idx);
264   }
265   return p_scb;
266 }
267 
268 /*******************************************************************************
269  *
270  * Function         bta_ag_service_to_idx
271  *
272  * Description      Given a BTA service mask convert to profile index.
273  *
274  *
275  * Returns          Profile ndex of scb.
276  *
277  ******************************************************************************/
bta_ag_service_to_idx(tBTA_SERVICE_MASK services)278 uint8_t bta_ag_service_to_idx(tBTA_SERVICE_MASK services) {
279   if (services & BTA_HFP_SERVICE_MASK) {
280     return BTA_AG_HFP;
281   } else {
282     return BTA_AG_HSP;
283   }
284 }
285 
286 /*******************************************************************************
287  *
288  * Function         bta_ag_idx_by_bdaddr
289  *
290  * Description      Find SCB associated with peer BD address.
291  *
292  *
293  * Returns          Index of SCB or zero if none found.
294  *
295  ******************************************************************************/
bta_ag_idx_by_bdaddr(const RawAddress * peer_addr)296 uint16_t bta_ag_idx_by_bdaddr(const RawAddress* peer_addr) {
297   tBTA_AG_SCB* p_scb = &bta_ag_cb.scb[0];
298   if (peer_addr != nullptr) {
299     for (uint16_t i = 0; i < BTA_AG_MAX_NUM_CLIENTS; i++, p_scb++) {
300       if (p_scb->in_use && *peer_addr == p_scb->peer_addr) {
301         return i + 1;
302       }
303     }
304   }
305 
306   /* no scb found */
307   log::warn("No ag scb for peer addr");
308   return 0;
309 }
310 
311 /*******************************************************************************
312  *
313  * Function         bta_ag_other_scb_open
314  *
315  * Description      Check whether any other scb is in open state.
316  *
317  *
318  * Returns          true if another scb is in open state, false otherwise.
319  *
320  ******************************************************************************/
bta_ag_other_scb_open(tBTA_AG_SCB * p_curr_scb)321 bool bta_ag_other_scb_open(tBTA_AG_SCB* p_curr_scb) {
322   tBTA_AG_SCB* p_scb = &bta_ag_cb.scb[0];
323   for (int i = 0; i < BTA_AG_MAX_NUM_CLIENTS; i++, p_scb++) {
324     if (p_scb->in_use && p_scb != p_curr_scb && p_scb->state == BTA_AG_OPEN_ST) {
325       return true;
326     }
327   }
328   /* no other scb found */
329   log::debug("No other ag scb open");
330   return false;
331 }
332 
333 /*******************************************************************************
334  *
335  * Function         bta_ag_scb_open
336  *
337  * Description      Check whether given scb is in open state.
338  *
339  *
340  * Returns          true if scb is in open state, false otherwise.
341  *
342  ******************************************************************************/
bta_ag_scb_open(tBTA_AG_SCB * p_curr_scb)343 bool bta_ag_scb_open(tBTA_AG_SCB* p_curr_scb) {
344   return p_curr_scb && p_curr_scb->in_use && p_curr_scb->state == BTA_AG_OPEN_ST;
345 }
346 
347 /*******************************************************************************
348  *
349  * Function         bta_ag_collision_cback
350  *
351  * Description      Get notified about collision.
352  *
353  *
354  * Returns          void
355  *
356  ******************************************************************************/
bta_ag_collision_cback(tBTA_SYS_CONN_STATUS,tBTA_SYS_ID id,uint8_t,const RawAddress & peer_addr)357 void bta_ag_collision_cback(tBTA_SYS_CONN_STATUS /* status */, tBTA_SYS_ID id, uint8_t /* app_id */,
358                             const RawAddress& peer_addr) {
359   /* Check if we have opening scb for the peer device. */
360   uint16_t handle = bta_ag_idx_by_bdaddr(&peer_addr);
361   tBTA_AG_SCB* p_scb = bta_ag_scb_by_idx(handle);
362 
363   if (p_scb && (p_scb->state == BTA_AG_OPENING_ST)) {
364     if (id == BTA_ID_SYS) {
365       log::warn("AG found collision (ACL) for handle {} device {}", unsigned(handle), peer_addr);
366     } else if (id == BTA_ID_AG) {
367       log::warn("AG found collision (RFCOMM) for handle {} device {}", unsigned(handle), peer_addr);
368     } else {
369       log::warn("AG found collision (UNKNOWN) for handle {} device {}", unsigned(handle),
370                 peer_addr);
371     }
372     bta_ag_sm_execute(p_scb, BTA_AG_COLLISION_EVT, tBTA_AG_DATA::kEmpty);
373   }
374 }
375 
376 /*******************************************************************************
377  *
378  * Function         bta_ag_resume_open
379  *
380  * Description      Resume opening process.
381  *
382  *
383  * Returns          void
384  *
385  ******************************************************************************/
bta_ag_resume_open(tBTA_AG_SCB * p_scb)386 void bta_ag_resume_open(tBTA_AG_SCB* p_scb) {
387   if (p_scb->state == BTA_AG_INIT_ST) {
388     log::info("Resume connection to {}, handle{}", p_scb->peer_addr, bta_ag_scb_to_idx(p_scb));
389     tBTA_AG_DATA open_data = {.api_open = {.bd_addr = p_scb->peer_addr}};
390     bta_ag_sm_execute(p_scb, BTA_AG_API_OPEN_EVT, open_data);
391   } else {
392     log::verbose("device {} is already in state {}", p_scb->peer_addr,
393                  bta_ag_state_str(p_scb->state));
394   }
395 }
396 
397 /*******************************************************************************
398  *
399  * Function         bta_ag_api_enable
400  *
401  * Description      Handle an API enable event.
402  *
403  *
404  * Returns          void
405  *
406  ******************************************************************************/
bta_ag_api_enable(tBTA_AG_CBACK * p_cback)407 void bta_ag_api_enable(tBTA_AG_CBACK* p_cback) {
408   /* initialize control block */
409   log::info("AG api enable");
410   for (tBTA_AG_SCB& scb : bta_ag_cb.scb) {
411     alarm_free(scb.ring_timer);
412     alarm_free(scb.codec_negotiation_timer);
413     alarm_free(scb.collision_timer);
414     scb = {};
415   }
416 
417   /* store callback function */
418   bta_ag_cb.p_cback = p_cback;
419 
420   /* call init call-out */
421   get_btm_client_interface().sco.BTM_WriteVoiceSettings(AG_VOICE_SETTINGS);
422 
423   bta_sys_collision_register(BTA_ID_AG, bta_ag_collision_cback);
424 
425   /* call callback with enable event */
426   (*bta_ag_cb.p_cback)(BTA_AG_ENABLE_EVT, nullptr);
427 }
428 
429 /*******************************************************************************
430  *
431  * Function         bta_ag_api_disable
432  *
433  * Description      Handle an API disable event.
434  *
435  *
436  * Returns          void
437  *
438  ******************************************************************************/
bta_ag_api_disable()439 void bta_ag_api_disable() {
440   /* deregister all scbs in use */
441   tBTA_AG_SCB* p_scb = &bta_ag_cb.scb[0];
442   bool do_dereg = false;
443   int i;
444 
445   if (!bta_sys_is_register(BTA_ID_AG)) {
446     log::error("BTA AG is already disabled, ignoring ...");
447     return;
448   }
449 
450   /* De-register with BTA system manager */
451   bta_sys_deregister(BTA_ID_AG);
452 
453   for (i = 0; i < BTA_AG_MAX_NUM_CLIENTS; i++, p_scb++) {
454     if (p_scb->in_use) {
455       bta_ag_sm_execute(p_scb, BTA_AG_API_DEREGISTER_EVT, tBTA_AG_DATA::kEmpty);
456       do_dereg = true;
457     }
458   }
459 
460   if (bta_ag_is_sco_managed_by_audio()) {
461     // Stop session if not done
462     bta_clear_active_device();
463   }
464 
465   if (!do_dereg) {
466     /* Done, send callback evt to app */
467     (*bta_ag_cb.p_cback)(BTA_AG_DISABLE_EVT, nullptr);
468   }
469 
470   bta_sys_collision_register(BTA_ID_AG, nullptr);
471 }
472 
473 /*******************************************************************************
474  *
475  * Function         bta_ag_api_register
476  *
477  * Description      Handle an API event registers a new service.
478  *
479  *
480  * Returns          void
481  *
482  ******************************************************************************/
bta_ag_api_register(tBTA_SERVICE_MASK services,tBTA_AG_FEAT features,const std::vector<std::string> & service_names,uint8_t app_id)483 void bta_ag_api_register(tBTA_SERVICE_MASK services, tBTA_AG_FEAT features,
484                          const std::vector<std::string>& service_names, uint8_t app_id) {
485   tBTA_AG_SCB* p_scb = bta_ag_scb_alloc();
486   log::debug("bta_ag_api_register: p_scb allocation {}", p_scb == nullptr ? "failed" : "success");
487   if (p_scb) {
488     tBTA_AG_DATA data = {};
489     data.api_register.features = features;
490     data.api_register.services = services;
491     data.api_register.app_id = app_id;
492     for (int i = 0; i < BTA_AG_NUM_IDX; i++) {
493       if (!service_names[i].empty()) {
494         osi_strlcpy(data.api_register.p_name[i], service_names[i].c_str(), BTA_SERVICE_NAME_LEN);
495       } else {
496         data.api_register.p_name[i][0] = 0;
497       }
498     }
499     bta_ag_sm_execute(p_scb, BTA_AG_API_REGISTER_EVT, data);
500   } else {
501     tBTA_AG bta_ag = {};
502     bta_ag.reg.status = BTA_AG_FAIL_RESOURCES;
503     (*bta_ag_cb.p_cback)(BTA_AG_REGISTER_EVT, &bta_ag);
504   }
505 }
506 
507 /*******************************************************************************
508  *
509  * Function         bta_ag_api_result
510  *
511  * Description      Handle an API result event.
512  *
513  *
514  * Returns          void
515  *
516  ******************************************************************************/
bta_ag_api_result(uint16_t handle,tBTA_AG_RES result,const tBTA_AG_RES_DATA & result_data)517 void bta_ag_api_result(uint16_t handle, tBTA_AG_RES result, const tBTA_AG_RES_DATA& result_data) {
518   tBTA_AG_DATA event_data = {};
519   event_data.api_result.result = result;
520   event_data.api_result.data = result_data;
521   tBTA_AG_SCB* p_scb;
522   if (handle != BTA_AG_HANDLE_ALL) {
523     p_scb = bta_ag_scb_by_idx(handle);
524     if (p_scb) {
525       log::debug("Audio gateway event for one client handle:{} scb:{}", handle, p_scb->ToString());
526       bta_ag_sm_execute(p_scb, static_cast<uint16_t>(BTA_AG_API_RESULT_EVT), event_data);
527     } else {
528       log::warn("Received audio gateway event for unknown AG control block handle:{}", handle);
529     }
530   } else {
531     int i;
532     for (i = 0, p_scb = &bta_ag_cb.scb[0]; i < BTA_AG_MAX_NUM_CLIENTS; i++, p_scb++) {
533       if (p_scb->in_use && p_scb->svc_conn) {
534         log::debug("Audio gateway event for all clients scb:{}", p_scb->ToString());
535         bta_ag_sm_execute(p_scb, static_cast<uint16_t>(BTA_AG_API_RESULT_EVT), event_data);
536       }
537     }
538   }
539 }
540 
bta_ag_better_state_machine(tBTA_AG_SCB * p_scb,uint16_t event,const tBTA_AG_DATA & data)541 static void bta_ag_better_state_machine(tBTA_AG_SCB* p_scb, uint16_t event,
542                                         const tBTA_AG_DATA& data) {
543   switch (p_scb->state) {
544     case BTA_AG_INIT_ST:
545       switch (event) {
546         case BTA_AG_API_REGISTER_EVT:
547           bta_ag_register(p_scb, data);
548           break;
549         case BTA_AG_API_DEREGISTER_EVT:
550           bta_ag_deregister(p_scb, data);
551           break;
552         case BTA_AG_API_OPEN_EVT:
553           p_scb->state = BTA_AG_OPENING_ST;
554           bta_ag_start_open(p_scb, data);
555           break;
556         case BTA_AG_RFC_OPEN_EVT:
557           p_scb->state = BTA_AG_OPEN_ST;
558           bta_ag_rfc_acp_open(p_scb, data);
559           bta_ag_sco_listen(p_scb, data);
560           break;
561         case BTA_AG_SCO_OPEN_EVT:
562           log::info("Opening sco for EVT BTA_AG_SCO_OPEN_EVT");
563           bta_ag_sco_conn_open(p_scb, data);
564           break;
565         case BTA_AG_SCO_CLOSE_EVT:
566           bta_ag_sco_conn_close(p_scb, data);
567           break;
568         case BTA_AG_DISC_ACP_RES_EVT:
569           bta_ag_free_db(p_scb, data);
570           break;
571         default:
572           log::error("unknown event {} at state {}", event, bta_ag_state_str(p_scb->state));
573           break;
574       }
575       break;
576     case BTA_AG_OPENING_ST:
577       switch (event) {
578         case BTA_AG_API_DEREGISTER_EVT:
579           p_scb->state = BTA_AG_CLOSING_ST;
580           bta_ag_rfc_do_close(p_scb, data);
581           bta_ag_start_dereg(p_scb, data);
582           break;
583         case BTA_AG_API_OPEN_EVT:
584           bta_ag_open_fail(p_scb, data);
585           break;
586         case BTA_AG_API_CLOSE_EVT:
587           p_scb->state = BTA_AG_CLOSING_ST;
588           bta_ag_rfc_do_close(p_scb, data);
589           break;
590         case BTA_AG_RFC_OPEN_EVT:
591           p_scb->state = BTA_AG_OPEN_ST;
592           bta_ag_rfc_open(p_scb, data);
593           bta_ag_sco_listen(p_scb, data);
594           break;
595         case BTA_AG_RFC_CLOSE_EVT:
596           p_scb->state = BTA_AG_INIT_ST;
597           bta_ag_rfc_fail(p_scb, data);
598           break;
599         case BTA_AG_SCO_OPEN_EVT:
600           log::info("Opening sco for EVT BTA_AG_SCO_OPEN_EVT");
601           bta_ag_sco_conn_open(p_scb, data);
602           break;
603         case BTA_AG_SCO_CLOSE_EVT:
604           bta_ag_sco_conn_close(p_scb, data);
605           break;
606         case BTA_AG_DISC_INT_RES_EVT:
607           bta_ag_disc_int_res(p_scb, data);
608           break;
609         case BTA_AG_DISC_OK_EVT:
610           bta_ag_rfc_do_open(p_scb, data);
611           break;
612         case BTA_AG_DISC_FAIL_EVT:
613           p_scb->state = BTA_AG_INIT_ST;
614           bta_ag_disc_fail(p_scb, data);
615           break;
616         case BTA_AG_COLLISION_EVT:
617           p_scb->state = BTA_AG_INIT_ST;
618           bta_ag_handle_collision(p_scb, data);
619           break;
620         default:
621           log::error("unknown event {} at state {}", event, bta_ag_state_str(p_scb->state));
622           break;
623       }
624       break;
625     case BTA_AG_OPEN_ST:
626       switch (event) {
627         case BTA_AG_API_DEREGISTER_EVT:
628           p_scb->state = BTA_AG_CLOSING_ST;
629           bta_ag_start_close(p_scb, data);
630           bta_ag_start_dereg(p_scb, data);
631           break;
632         case BTA_AG_API_OPEN_EVT:
633           bta_ag_open_fail(p_scb, data);
634           break;
635         case BTA_AG_API_CLOSE_EVT:
636           p_scb->state = BTA_AG_CLOSING_ST;
637           bta_ag_start_close(p_scb, data);
638           break;
639         case BTA_AG_API_AUDIO_OPEN_EVT:
640           bta_ag_sco_open(p_scb, data);
641           break;
642         case BTA_AG_API_AUDIO_CLOSE_EVT:
643           bta_ag_sco_close(p_scb, data);
644           break;
645         case BTA_AG_API_RESULT_EVT:
646           bta_ag_result(p_scb, data);
647           break;
648         case BTA_AG_API_SETCODEC_EVT:
649           bta_ag_setcodec(p_scb, data);
650           break;
651         case BTA_AG_RFC_CLOSE_EVT:
652           p_scb->state = BTA_AG_INIT_ST;
653           bta_ag_rfc_close(p_scb, data);
654           break;
655         case BTA_AG_RFC_DATA_EVT:
656           bta_ag_rfc_data(p_scb, data);
657           break;
658         case BTA_AG_SCO_OPEN_EVT:
659           log::info("Opening sco for EVT BTA_AG_SCO_OPEN_EVT");
660           bta_ag_sco_conn_open(p_scb, data);
661           bta_ag_post_sco_open(p_scb, data);
662           break;
663         case BTA_AG_SCO_CLOSE_EVT:
664           bta_ag_sco_conn_close(p_scb, data);
665           bta_ag_post_sco_close(p_scb, data);
666           break;
667         case BTA_AG_DISC_ACP_RES_EVT:
668           bta_ag_disc_acp_res(p_scb, data);
669           break;
670         case BTA_AG_RING_TIMEOUT_EVT:
671           bta_ag_send_ring(p_scb, data);
672           break;
673         case BTA_AG_SVC_TIMEOUT_EVT:
674           p_scb->state = BTA_AG_CLOSING_ST;
675           bta_ag_start_close(p_scb, data);
676           break;
677         default:
678           log::error("unknown event {} at state {}", event, bta_ag_state_str(p_scb->state));
679           break;
680       }
681       break;
682     case BTA_AG_CLOSING_ST:
683       switch (event) {
684         case BTA_AG_API_DEREGISTER_EVT:
685           bta_ag_start_dereg(p_scb, data);
686           break;
687         case BTA_AG_API_OPEN_EVT:
688           bta_ag_open_fail(p_scb, data);
689           break;
690         case BTA_AG_RFC_CLOSE_EVT:
691           p_scb->state = BTA_AG_INIT_ST;
692           bta_ag_rfc_close(p_scb, data);
693           break;
694         case BTA_AG_SCO_OPEN_EVT:
695           log::info("Opening sco for EVT BTA_AG_SCO_OPEN_EVT");
696           bta_ag_sco_conn_open(p_scb, data);
697           break;
698         case BTA_AG_SCO_CLOSE_EVT:
699           bta_ag_sco_conn_close(p_scb, data);
700           bta_ag_post_sco_close(p_scb, data);
701           break;
702         case BTA_AG_DISC_ACP_RES_EVT:
703           bta_ag_free_db(p_scb, data);
704           break;
705         case BTA_AG_DISC_INT_RES_EVT:
706           p_scb->state = BTA_AG_INIT_ST;
707           bta_ag_free_db(p_scb, data);
708           break;
709         default:
710           log::error("unknown event {} at state {}", event, bta_ag_state_str(p_scb->state));
711           break;
712       }
713       break;
714   }
715 }
716 
717 /*******************************************************************************
718  *
719  * Function         bta_ag_sm_execute
720  *
721  * Description      State machine event handling function for AG
722  *
723  *
724  * Returns          void
725  *
726  ******************************************************************************/
bta_ag_sm_execute(tBTA_AG_SCB * p_scb,uint16_t event,const tBTA_AG_DATA & data)727 void bta_ag_sm_execute(tBTA_AG_SCB* p_scb, uint16_t event, const tBTA_AG_DATA& data) {
728   uint16_t previous_event = event;
729   tBTA_AG_STATE previous_state = p_scb->state;
730 
731   log::debug(
732           "Execute AG event handle:0x{:04x} bd_addr:{} state:{}[0x{:02x}] "
733           "event:{}[0x{:04x}] result:{}[0x{:02x}]",
734           bta_ag_scb_to_idx(p_scb), p_scb->peer_addr, bta_ag_state_str(p_scb->state),
735           static_cast<uint64_t>(p_scb->state), bta_ag_evt_str(event), event,
736           bta_ag_res_str(data.api_result.result), data.api_result.result);
737 
738   bta_ag_better_state_machine(p_scb, event, data);
739 
740   if (p_scb->state != previous_state) {
741     log::debug(
742             "State changed handle:0x{:04x} bd_addr:{} "
743             "state_change:{}[0x{:02x}]->{}[0x{:02x}] event:{}[0x{:04x}] "
744             "result:{}[0x{:02x}]",
745             bta_ag_scb_to_idx(p_scb), p_scb->peer_addr, bta_ag_state_str(previous_state),
746             static_cast<uint64_t>(previous_state), bta_ag_state_str(p_scb->state),
747             static_cast<uint64_t>(p_scb->state), bta_ag_evt_str(previous_event), previous_event,
748             bta_ag_res_str(data.api_result.result), data.api_result.result);
749   }
750 }
751 
bta_ag_sm_execute_by_handle(uint16_t handle,uint16_t event,const tBTA_AG_DATA & data)752 void bta_ag_sm_execute_by_handle(uint16_t handle, uint16_t event, const tBTA_AG_DATA& data) {
753   tBTA_AG_SCB* p_scb = bta_ag_scb_by_idx(handle);
754   if (p_scb) {
755     log::debug("AG state machine event:{}[0x{:04x}] handle:0x{:04x}", bta_ag_evt_str(event), event,
756                handle);
757     bta_ag_sm_execute(p_scb, event, data);
758   }
759 }
760 
761 /**
762  * Handles event from bta_sys_sendmsg(). It is here to support legacy alarm
763  * implementation that is mainly for timeouts.
764  *
765  * @param p_msg event message
766  * @return True to free p_msg, or False if p_msg is freed within this function
767  */
bta_ag_hdl_event(const BT_HDR_RIGID * p_msg)768 bool bta_ag_hdl_event(const BT_HDR_RIGID* p_msg) {
769   switch (p_msg->event) {
770     case BTA_AG_RING_TIMEOUT_EVT:
771     case BTA_AG_SVC_TIMEOUT_EVT:
772       bta_ag_sm_execute_by_handle(p_msg->layer_specific, p_msg->event, tBTA_AG_DATA::kEmpty);
773       break;
774     default:
775       log::fatal("bad event {} layer_specific={}", p_msg->event, p_msg->layer_specific);
776       break;
777   }
778   return true;
779 }
780