1 /******************************************************************************
2 *
3 * Copyright (C) 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 <string.h>
26 #include <stdlib.h>
27 #include "bta_ag_int.h"
28 #include "bta/bta_api.h"
29 #include "bta/bta_sys.h"
30 #include "bta/bta_ag_api.h"
31 #include "bta/bta_ag_co.h"
32 #include "bta/utl.h"
33 #include "common/bt_defs.h"
34 #include "common/bt_trace.h"
35 #include "osi/allocator.h"
36
37 #if (BTA_AG_INCLUDED == TRUE)
38 /*****************************************************************************
39 ** Constants and types
40 *****************************************************************************/
41 #ifndef BTA_AG_DEBUG
42 #define BTA_AG_DEBUG TRUE
43 #endif
44
45 #if BTA_AG_DEBUG == TRUE
46 static char *bta_ag_evt_str(UINT16 event, tBTA_AG_RES result);
47 static char *bta_ag_state_str(UINT8 state);
48 #endif
49
50 /* state machine states */
51 enum
52 {
53 BTA_AG_INIT_ST,
54 BTA_AG_OPENING_ST,
55 BTA_AG_OPEN_ST,
56 BTA_AG_CLOSING_ST
57 };
58
59 /* state machine action enumeration list */
60 enum
61 {
62 BTA_AG_REGISTER,
63 BTA_AG_DEREGISTER,
64 BTA_AG_START_OPEN,
65 BTA_AG_RFC_DO_OPEN,
66 BTA_AG_RFC_DO_CLOSE,
67 BTA_AG_START_DEREG,
68 BTA_AG_START_CLOSE,
69 BTA_AG_RFC_OPEN,
70 BTA_AG_OPEN_FAIL,
71 BTA_AG_RFC_ACP_OPEN,
72 BTA_AG_RFC_CLOSE,
73 BTA_AG_RFC_FAIL,
74 BTA_AG_RFC_DATA,
75 BTA_AG_DISC_INT_RES,
76 BTA_AG_DISC_FAIL,
77 BTA_AG_DISC_ACP_RES,
78 BTA_AG_FREE_DB,
79 BTA_AG_SCO_CONN_OPEN,
80 BTA_AG_SCO_CONN_CLOSE,
81 BTA_AG_SCO_LISTEN,
82 BTA_AG_SCO_OPEN,
83 BTA_AG_SCO_CLOSE,
84 BTA_AG_SCO_SHUTDOWN,
85 BTA_AG_POST_SCO_OPEN,
86 BTA_AG_POST_SCO_CLOSE,
87 BTA_AG_SVC_CONN_OPEN,
88 BTA_AG_RESULT,
89 BTA_AG_SETCODEC,
90 BTA_AG_SEND_RING,
91 BTA_AG_CI_SCO_DATA,
92 BTA_AG_CI_RX_DATA,
93 BTA_AG_RCVD_SLC_READY,
94 BTA_AG_PKT_STAT_NUMS,
95 BTA_AG_NUM_ACTIONS
96 };
97
98 #define BTA_AG_IGNORE BTA_AG_NUM_ACTIONS
99
100 /* type for action functions */
101 typedef void (*tBTA_AG_ACTION) (tBTA_AG_SCB *p_scb, tBTA_AG_DATA *p_data);
102
103 /* action functions */
104 const tBTA_AG_ACTION bta_ag_action[] =
105 {
106 bta_ag_register,
107 bta_ag_deregister,
108 bta_ag_start_open,
109 bta_ag_rfc_do_open,
110 bta_ag_rfc_do_close,
111 bta_ag_start_dereg,
112 bta_ag_start_close,
113 bta_ag_rfc_open,
114 bta_ag_open_fail,
115 bta_ag_rfc_acp_open,
116 bta_ag_rfc_close,
117 bta_ag_rfc_fail,
118 bta_ag_rfc_data,
119 bta_ag_disc_int_res,
120 bta_ag_disc_fail,
121 bta_ag_disc_acp_res,
122 bta_ag_free_db,
123 bta_ag_sco_conn_open,
124 bta_ag_sco_conn_close,
125 bta_ag_sco_listen,
126 bta_ag_sco_open,
127 bta_ag_sco_close,
128 bta_ag_sco_shutdown,
129 bta_ag_post_sco_open,
130 bta_ag_post_sco_close,
131 bta_ag_svc_conn_open,
132 bta_ag_result,
133 bta_ag_setcodec,
134 bta_ag_send_ring,
135 bta_ag_ci_sco_data,
136 bta_ag_ci_rx_data,
137 bta_ag_rcvd_slc_ready,
138 bta_ag_pkt_stat_nums
139 };
140
141 /* state table information */
142 #define BTA_AG_ACTIONS 2 /* number of actions */
143 #define BTA_AG_NEXT_STATE 2 /* position of next state */
144 #define BTA_AG_NUM_COLS 3 /* number of columns in state tables */
145
146 /* state table for init state */
147 const UINT8 bta_ag_st_init[][BTA_AG_NUM_COLS] =
148 {
149 /* Event Action 1 Action 2 Next state */
150 /* API_REGISTER_EVT */ {BTA_AG_REGISTER, BTA_AG_IGNORE, BTA_AG_INIT_ST},
151 /* API_DEREGISTER_EVT */ {BTA_AG_DEREGISTER, BTA_AG_IGNORE, BTA_AG_INIT_ST},
152 /* API_OPEN_EVT */ {BTA_AG_START_OPEN, BTA_AG_IGNORE, BTA_AG_OPENING_ST},
153 /* API_CLOSE_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_INIT_ST},
154 /* API_AUDIO_OPEN_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_INIT_ST},
155 /* API_AUDIO_CLOSE_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_INIT_ST},
156 /* API_RESULT_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_INIT_ST},
157 /* API_SETCODEC_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_INIT_ST},
158 /* RFC_OPEN_EVT */ {BTA_AG_RFC_ACP_OPEN, BTA_AG_SCO_LISTEN, BTA_AG_OPEN_ST},
159 /* RFC_CLOSE_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_INIT_ST},
160 /* RFC_SRV_CLOSE_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_INIT_ST},
161 /* RFC_DATA_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_INIT_ST},
162 /* SCO_OPEN_EVT */ {BTA_AG_SCO_CONN_OPEN, BTA_AG_IGNORE, BTA_AG_INIT_ST},
163 /* SCO_CLOSE_EVT */ {BTA_AG_SCO_CONN_CLOSE, BTA_AG_IGNORE, BTA_AG_INIT_ST},
164 /* DISC_ACP_RES_EVT */ {BTA_AG_FREE_DB, BTA_AG_IGNORE, BTA_AG_INIT_ST},
165 /* DISC_INT_RES_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_INIT_ST},
166 /* DISC_OK_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_INIT_ST},
167 /* DISC_FAIL_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_INIT_ST},
168 /* CI_RX_WRITE_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_INIT_ST},
169 /* RING_TOUT_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_INIT_ST},
170 /* SVC_TOUT_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_INIT_ST},
171 /* CI_SCO_DATA_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_INIT_ST},
172 /* CI_SLC_READY_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_INIT_ST},
173 /* PKT_STAT_NUMS_GET_EVT */ {BTA_AG_PKT_STAT_NUMS, BTA_AG_IGNORE, BTA_AG_INIT_ST}
174 };
175
176 /* state table for opening state */
177 const UINT8 bta_ag_st_opening[][BTA_AG_NUM_COLS] =
178 {
179 /* Event Action 1 Action 2 Next state */
180 /* API_REGISTER_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_OPENING_ST},
181 /* API_DEREGISTER_EVT */ {BTA_AG_RFC_DO_CLOSE, BTA_AG_START_DEREG, BTA_AG_CLOSING_ST},
182 /* API_OPEN_EVT */ {BTA_AG_OPEN_FAIL, BTA_AG_IGNORE, BTA_AG_OPENING_ST},
183 /* API_CLOSE_EVT */ {BTA_AG_RFC_DO_CLOSE, BTA_AG_IGNORE, BTA_AG_CLOSING_ST},
184 /* API_AUDIO_OPEN_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_OPENING_ST},
185 /* API_AUDIO_CLOSE_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_OPENING_ST},
186 /* API_RESULT_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_OPENING_ST},
187 /* API_SETCODEC_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_OPENING_ST},
188 /* RFC_OPEN_EVT */ {BTA_AG_RFC_OPEN, BTA_AG_SCO_LISTEN, BTA_AG_OPEN_ST},
189 /* RFC_CLOSE_EVT */ {BTA_AG_RFC_FAIL, BTA_AG_IGNORE, BTA_AG_INIT_ST},
190 /* RFC_SRV_CLOSE_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_OPENING_ST},
191 /* RFC_DATA_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_OPENING_ST},
192 /* SCO_OPEN_EVT */ {BTA_AG_SCO_CONN_OPEN, BTA_AG_IGNORE, BTA_AG_OPENING_ST},
193 /* SCO_CLOSE_EVT */ {BTA_AG_SCO_CONN_CLOSE, BTA_AG_IGNORE, BTA_AG_OPENING_ST},
194 /* DISC_ACP_RES_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_OPENING_ST},
195 /* DISC_INT_RES_EVT */ {BTA_AG_DISC_INT_RES, BTA_AG_IGNORE, BTA_AG_OPENING_ST},
196 /* DISC_OK_EVT */ {BTA_AG_RFC_DO_OPEN, BTA_AG_IGNORE, BTA_AG_OPENING_ST},
197 /* DISC_FAIL_EVT */ {BTA_AG_DISC_FAIL, BTA_AG_IGNORE, BTA_AG_INIT_ST},
198 /* CI_RX_WRITE_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_OPENING_ST},
199 /* RING_TOUT_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_OPENING_ST},
200 /* SVC_TOUT_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_OPENING_ST},
201 /* CI_SCO_DATA_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_OPENING_ST},
202 /* CI_SLC_READY_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_OPENING_ST},
203 /* PKT_STAT_NUMS_GET_EVT */ {BTA_AG_PKT_STAT_NUMS, BTA_AG_IGNORE, BTA_AG_OPENING_ST}
204 };
205
206 /* state table for open state */
207 const UINT8 bta_ag_st_open[][BTA_AG_NUM_COLS] =
208 {
209 /* Event Action 1 Action 2 Next state */
210 /* API_REGISTER_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_OPEN_ST},
211 /* API_DEREGISTER_EVT */ {BTA_AG_START_CLOSE, BTA_AG_START_DEREG, BTA_AG_CLOSING_ST},
212 /* API_OPEN_EVT */ {BTA_AG_OPEN_FAIL, BTA_AG_IGNORE, BTA_AG_OPEN_ST},
213 /* API_CLOSE_EVT */ {BTA_AG_START_CLOSE, BTA_AG_IGNORE, BTA_AG_CLOSING_ST},
214 /* API_AUDIO_OPEN_EVT */ {BTA_AG_SCO_OPEN, BTA_AG_IGNORE, BTA_AG_OPEN_ST},
215 /* API_AUDIO_CLOSE_EVT */ {BTA_AG_SCO_CLOSE, BTA_AG_IGNORE, BTA_AG_OPEN_ST},
216 /* API_RESULT_EVT */ {BTA_AG_RESULT, BTA_AG_IGNORE, BTA_AG_OPEN_ST},
217 /* API_SETCODEC_EVT */ {BTA_AG_SETCODEC, BTA_AG_IGNORE, BTA_AG_OPEN_ST},
218 /* RFC_OPEN_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_OPEN_ST},
219 /* RFC_CLOSE_EVT */ {BTA_AG_RFC_CLOSE, BTA_AG_IGNORE, BTA_AG_INIT_ST},
220 /* RFC_SRV_CLOSE_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_OPEN_ST},
221 /* RFC_DATA_EVT */ {BTA_AG_RFC_DATA, BTA_AG_IGNORE, BTA_AG_OPEN_ST},
222 /* SCO_OPEN_EVT */ {BTA_AG_SCO_CONN_OPEN, BTA_AG_POST_SCO_OPEN, BTA_AG_OPEN_ST},
223 /* SCO_CLOSE_EVT */ {BTA_AG_SCO_CONN_CLOSE, BTA_AG_POST_SCO_CLOSE, BTA_AG_OPEN_ST},
224 /* DISC_ACP_RES_EVT */ {BTA_AG_DISC_ACP_RES, BTA_AG_IGNORE, BTA_AG_OPEN_ST},
225 /* DISC_INT_RES_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_OPEN_ST},
226 /* DISC_OK_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_OPEN_ST},
227 /* DISC_FAIL_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_OPEN_ST},
228 /* CI_RX_WRITE_EVT */ {BTA_AG_CI_RX_DATA, BTA_AG_IGNORE, BTA_AG_OPEN_ST},
229 /* RING_TOUT_EVT */ {BTA_AG_SEND_RING, BTA_AG_IGNORE, BTA_AG_OPEN_ST},
230 /* SVC_TOUT_EVT */ {BTA_AG_START_CLOSE, BTA_AG_IGNORE, BTA_AG_CLOSING_ST},
231 /* CI_SCO_DATA_EVT */ {BTA_AG_CI_SCO_DATA, BTA_AG_IGNORE, BTA_AG_OPEN_ST},
232 /* CI_SLC_READY_EVT */ {BTA_AG_RCVD_SLC_READY, BTA_AG_IGNORE, BTA_AG_OPEN_ST},
233 /* PKT_STAT_NUMS_GET_EVT */ {BTA_AG_PKT_STAT_NUMS, BTA_AG_IGNORE, BTA_AG_OPEN_ST}
234 };
235
236 /* state table for closing state */
237 const UINT8 bta_ag_st_closing[][BTA_AG_NUM_COLS] =
238 {
239 /* Event Action 1 Action 2 Next state */
240 /* API_REGISTER_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_CLOSING_ST},
241 /* API_DEREGISTER_EVT */ {BTA_AG_START_DEREG, BTA_AG_IGNORE, BTA_AG_CLOSING_ST},
242 /* API_OPEN_EVT */ {BTA_AG_OPEN_FAIL, BTA_AG_IGNORE, BTA_AG_CLOSING_ST},
243 /* API_CLOSE_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_CLOSING_ST},
244 /* API_AUDIO_OPEN_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_CLOSING_ST},
245 /* API_AUDIO_CLOSE_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_CLOSING_ST},
246 /* API_RESULT_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_CLOSING_ST},
247 /* API_SETCODEC_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_CLOSING_ST},
248 /* RFC_OPEN_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_CLOSING_ST},
249 /* RFC_CLOSE_EVT */ {BTA_AG_RFC_CLOSE, BTA_AG_IGNORE, BTA_AG_INIT_ST},
250 /* RFC_SRV_CLOSE_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_CLOSING_ST},
251 /* RFC_DATA_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_CLOSING_ST},
252 /* SCO_OPEN_EVT */ {BTA_AG_SCO_CONN_OPEN, BTA_AG_IGNORE, BTA_AG_CLOSING_ST},
253 /* SCO_CLOSE_EVT */ {BTA_AG_SCO_CONN_CLOSE, BTA_AG_POST_SCO_CLOSE, BTA_AG_CLOSING_ST},
254 /* DISC_ACP_RES_EVT */ {BTA_AG_FREE_DB, BTA_AG_IGNORE, BTA_AG_CLOSING_ST},
255 /* DISC_INT_RES_EVT */ {BTA_AG_FREE_DB, BTA_AG_IGNORE, BTA_AG_INIT_ST},
256 /* DISC_OK_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_CLOSING_ST},
257 /* DISC_FAIL_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_CLOSING_ST},
258 /* CI_RX_WRITE_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_CLOSING_ST},
259 /* RING_TOUT_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_CLOSING_ST},
260 /* SVC_TOUT_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_CLOSING_ST},
261 /* CI_SCO_DATA_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_CLOSING_ST},
262 /* CI_SLC_READY_EVT */ {BTA_AG_IGNORE, BTA_AG_IGNORE, BTA_AG_CLOSING_ST},
263 /* PKT_STAT_NUMS_GET_EVT */ {BTA_AG_PKT_STAT_NUMS, BTA_AG_IGNORE, BTA_AG_CLOSING_ST}
264 };
265
266 /* type for state table */
267 typedef const UINT8 (*tBTA_AG_ST_TBL)[BTA_AG_NUM_COLS];
268
269 /* state table */
270 const tBTA_AG_ST_TBL bta_ag_st_tbl[] =
271 {
272 bta_ag_st_init,
273 bta_ag_st_opening,
274 bta_ag_st_open,
275 bta_ag_st_closing
276 };
277
278 /*****************************************************************************
279 ** Global data
280 *****************************************************************************/
281 const uint16_t bta_ag_version = HFP_VERSION_1_8;
282 /* AG control block */
283 #if BTA_DYNAMIC_MEMORY == FALSE
284 tBTA_AG_CB bta_ag_cb;
285 #else
286 tBTA_AG_CB *bta_ag_cb_ptr;
287 #endif
288
289 #if BTA_AG_DEBUG == TRUE
bta_ag_evt_str(UINT16 event,tBTA_AG_RES result)290 static char *bta_ag_evt_str(UINT16 event, tBTA_AG_RES result)
291 {
292 switch (event)
293 {
294 case BTA_AG_API_REGISTER_EVT:
295 return "Register Request";
296 case BTA_AG_API_DEREGISTER_EVT:
297 return "Deregister Request";
298 case BTA_AG_API_OPEN_EVT:
299 return "Open SLC Request";
300 case BTA_AG_API_CLOSE_EVT:
301 return "Close SLC Request";
302 case BTA_AG_API_AUDIO_OPEN_EVT:
303 return "Open Audio Request";
304 case BTA_AG_API_AUDIO_CLOSE_EVT:
305 return "Close Audio Request";
306 case BTA_AG_API_RESULT_EVT:
307 switch (result) {
308 case BTA_AG_SPK_RES: return ("AT Result BTA_AG_SPK_RES");
309 case BTA_AG_MIC_RES: return ("AT Result BTA_AG_MIC_RES");
310 case BTA_AG_INBAND_RING_RES: return ("AT Result BTA_AG_INBAND_RING_RES");
311 case BTA_AG_CIND_RES: return ("AT Result BTA_AG_CIND_RES");
312 case BTA_AG_BINP_RES: return ("AT Result BTA_AG_BINP_RES");
313 case BTA_AG_IND_RES: return ("AT Result BTA_AG_IND_RES");
314 case BTA_AG_BVRA_RES: return ("AT Result BTA_AG_BVRA_RES");
315 case BTA_AG_CNUM_RES: return ("AT Result BTA_AG_CNUM_RES");
316 case BTA_AG_BTRH_RES: return ("AT Result BTA_AG_BTRH_RES");
317 case BTA_AG_CLCC_RES: return ("AT Result BTA_AG_CLCC_RES");
318 case BTA_AG_COPS_RES: return ("AT Result BTA_AG_COPS_RES");
319 case BTA_AG_IN_CALL_RES: return ("AT Result BTA_AG_IN_CALL_RES");
320 case BTA_AG_IN_CALL_CONN_RES: return ("AT Result BTA_AG_IN_CALL_CONN_RES");
321 case BTA_AG_CALL_WAIT_RES: return ("AT Result BTA_AG_CALL_WAIT_RES");
322 case BTA_AG_OUT_CALL_ORIG_RES: return ("AT Result BTA_AG_OUT_CALL_ORIG_RES");
323 case BTA_AG_OUT_CALL_ALERT_RES: return ("AT Result BTA_AG_OUT_CALL_ALERT_RES");
324 case BTA_AG_OUT_CALL_CONN_RES: return ("AT Result BTA_AG_OUT_CALL_CONN_RES");
325 case BTA_AG_CALL_CANCEL_RES: return ("AT Result BTA_AG_CALL_CANCEL_RES");
326 case BTA_AG_END_CALL_RES: return ("AT Result BTA_AG_END_CALL_RES");
327 case BTA_AG_UNAT_RES: return ("AT Result BTA_AG_UNAT_RES");
328 default: return ("Unknown AG Result");
329 }
330 case BTA_AG_API_SETCODEC_EVT:
331 return "Set Codec Request";
332 case BTA_AG_RFC_OPEN_EVT:
333 return "RFC Opened";
334 case BTA_AG_RFC_CLOSE_EVT:
335 return "RFC Closed";
336 case BTA_AG_RFC_SRV_CLOSE_EVT:
337 return "RFC SRV Closed";
338 case BTA_AG_RFC_DATA_EVT:
339 return "RFC Data";
340 case BTA_AG_SCO_OPEN_EVT:
341 return "Audio Opened";
342 case BTA_AG_SCO_CLOSE_EVT:
343 return "Audio Closed";
344 case BTA_AG_DISC_ACP_RES_EVT:
345 return "Discovery ACP Result";
346 case BTA_AG_DISC_INT_RES_EVT:
347 return "Discovery INT Result";
348 case BTA_AG_DISC_OK_EVT:
349 return "Discovery OK";
350 case BTA_AG_DISC_FAIL_EVT:
351 return "Discovery Failed";
352 case BTA_AG_CI_RX_WRITE_EVT:
353 return "CI RX Write";
354 case BTA_AG_RING_TOUT_EVT:
355 return "Ring Timeout";
356 case BTA_AG_SVC_TOUT_EVT:
357 return "Service Timeout";
358 case BTA_AG_API_ENABLE_EVT:
359 return "Enable AG";
360 case BTA_AG_API_DISABLE_EVT:
361 return "Disable AG";
362 case BTA_AG_CI_SCO_DATA_EVT:
363 return "SCO data Callin";
364 case BTA_AG_CI_SLC_READY_EVT:
365 return "SLC Ready Callin";
366 case BTA_AG_PKT_STAT_NUMS_GET_EVT:
367 return "Get Packet Nums";
368 default:
369 return "Unknown AG Event";
370 }
371 }
372
bta_ag_state_str(UINT8 state)373 static char *bta_ag_state_str(UINT8 state)
374 {
375 switch (state) {
376 case BTA_AG_INIT_ST:
377 return "Initial";
378 case BTA_AG_OPENING_ST:
379 return "Opening";
380 case BTA_AG_OPEN_ST:
381 return "Open";
382 case BTA_AG_CLOSING_ST:
383 return "Closing";
384 default:
385 return "Unknown AG State";
386 }
387 }
388
389 #endif
390
391 /*******************************************************************************
392 **
393 ** Function bta_ag_timer_cback
394 **
395 ** Description AG timer callback.
396 **
397 **
398 ** Returns void
399 **
400 *******************************************************************************/
bta_ag_timer_cback(void * p)401 static void bta_ag_timer_cback(void *p)
402 {
403 BT_HDR *p_buf;
404 TIMER_LIST_ENT *p_tle = (TIMER_LIST_ENT *) p;
405
406 if ((p_buf = (BT_HDR *) osi_malloc(sizeof(BT_HDR))) != NULL) {
407 p_buf->event = p_tle->event;
408 p_buf->layer_specific = bta_ag_scb_to_idx((tBTA_AG_SCB *) p_tle->param);
409 bta_sys_sendmsg(p_buf);
410 }
411 }
412
413 /*******************************************************************************
414 **
415 ** Function bta_ag_scb_alloc
416 **
417 ** Description Allocate an AG service control block.
418 **
419 **
420 ** Returns pointer to the scb, or NULL if none could be allocated.
421 **
422 *******************************************************************************/
bta_ag_scb_alloc(void)423 static tBTA_AG_SCB *bta_ag_scb_alloc(void)
424 {
425 tBTA_AG_SCB *p_scb = &bta_ag_cb.scb[0];
426 int i;
427
428 for (i = 0; i < BTA_AG_NUM_SCB; i++, p_scb++) {
429 if (!p_scb->in_use) {
430 /* initialize variables */
431 p_scb->in_use = TRUE;
432 p_scb->sco_idx = BTM_INVALID_SCO_INDEX;
433 #if (BTM_WBS_INCLUDED == TRUE)
434 p_scb->codec_updated = FALSE;
435 #endif
436 /* set up timers */
437 p_scb->act_timer.param = (UINT32) p_scb;
438 p_scb->act_timer.p_cback = bta_ag_timer_cback;
439 #if (BTM_WBS_INCLUDED == TRUE)
440 /* set eSCO mSBC setting to T2 as the preferred */
441 p_scb->codec_msbc_settings = BTA_AG_SCO_MSBC_SETTINGS_T2;
442 #endif
443 APPL_TRACE_DEBUG("bta_ag_scb_alloc %d", bta_ag_scb_to_idx(p_scb));
444 break;
445 }
446 }
447
448 if (i == BTA_AG_NUM_SCB) {
449 p_scb = NULL; /* out of scbs */
450 APPL_TRACE_WARNING("Out of ag scbs");
451 }
452 return p_scb;
453 }
454
455 /*******************************************************************************
456 **
457 ** Function bta_ag_scb_dealloc
458 **
459 ** Description Deallocate a service control block.
460 **
461 **
462 ** Returns void
463 **
464 *******************************************************************************/
bta_ag_scb_dealloc(tBTA_AG_SCB * p_scb)465 void bta_ag_scb_dealloc(tBTA_AG_SCB *p_scb)
466 {
467 UINT8 idx;
468 BOOLEAN allocated = FALSE;
469
470 APPL_TRACE_DEBUG("bta_ag_scb_dealloc %d", bta_ag_scb_to_idx(p_scb));
471 /* stop timers */
472 bta_sys_free_timer(&p_scb->act_timer);
473 #if (BTM_WBS_INCLUDED == TRUE)
474 bta_sys_free_timer(&p_scb->cn_timer);
475 #endif
476 bta_sys_free_timer(&p_scb->colli_timer);
477
478 /* initialize control block */
479 memset(p_scb, 0, sizeof(tBTA_AG_SCB));
480 p_scb->sco_idx = BTM_INVALID_SCO_INDEX;
481 /* If all scbs are deallocated, callback with disable event */
482 if (!bta_sys_is_register (BTA_ID_AG)) {
483 for (idx = 0; idx < BTA_AG_NUM_SCB; idx++) {
484 if (bta_ag_cb.scb[idx].in_use) {
485 allocated = TRUE;
486 break;
487 }
488 }
489 if (!allocated) {
490 (*bta_ag_cb.p_cback)(BTA_AG_DISABLE_EVT, NULL);
491 }
492 }
493 }
494
495 /*******************************************************************************
496 **
497 ** Function bta_ag_scb_to_idx
498 **
499 ** Description Given a pointer to an scb, return its index.
500 **
501 **
502 ** Returns Index of scb.
503 **
504 *******************************************************************************/
bta_ag_scb_to_idx(tBTA_AG_SCB * p_scb)505 UINT16 bta_ag_scb_to_idx(tBTA_AG_SCB *p_scb)
506 {
507 /* use array arithmetic to determine index */
508 return ((UINT16) (p_scb - bta_ag_cb.scb)) + 1;
509 }
510
511 /*******************************************************************************
512 **
513 ** Function bta_ag_scb_by_idx
514 **
515 ** Description Given an scb index return pointer to scb.
516 **
517 **
518 ** Returns Pointer to scb or NULL if not allocated.
519 **
520 *******************************************************************************/
bta_ag_scb_by_idx(UINT16 idx)521 tBTA_AG_SCB *bta_ag_scb_by_idx(UINT16 idx)
522 {
523 tBTA_AG_SCB *p_scb;
524 /* verify index */
525 if (idx > 0 && idx <= BTA_AG_NUM_SCB) {
526 p_scb = &bta_ag_cb.scb[idx - 1];
527 if (!p_scb->in_use) {
528 p_scb = NULL;
529 APPL_TRACE_WARNING("ag scb idx %d not allocated", idx);
530 }
531 } else {
532 p_scb = NULL;
533 APPL_TRACE_DEBUG("ag scb idx %d out of range", idx);
534 }
535 return p_scb;
536 }
537
538 /*******************************************************************************
539 **
540 ** Function bta_ag_service_to_idx
541 **
542 ** Description Given a BTA service mask convert to profile index.
543 **
544 **
545 ** Returns Profile ndex of scb.
546 **
547 *******************************************************************************/
bta_ag_service_to_idx(tBTA_SERVICE_MASK services)548 UINT8 bta_ag_service_to_idx(tBTA_SERVICE_MASK services)
549 {
550 if (services & BTA_HFP_SERVICE_MASK) {
551 return BTA_AG_HFP;
552 } else {
553 return BTA_AG_HSP;
554 }
555 }
556
557 /*******************************************************************************
558 **
559 ** Function bta_ag_idx_by_bdaddr
560 **
561 ** Description Find SCB associated with peer BD address.
562 **
563 **
564 ** Returns Index of SCB or zero if none found.
565 **
566 *******************************************************************************/
bta_ag_idx_by_bdaddr(BD_ADDR peer_addr)567 UINT16 bta_ag_idx_by_bdaddr(BD_ADDR peer_addr)
568 {
569 tBTA_AG_SCB *p_scb = &bta_ag_cb.scb[0];
570 UINT16 i;
571
572 if (peer_addr != NULL) {
573 for (i = 0; i < BTA_AG_NUM_SCB; i++, p_scb++) {
574 if (p_scb->in_use && !bdcmp(peer_addr, p_scb->peer_addr)) {
575 return (i + 1);
576 }
577 }
578 }
579 /* no scb found */
580 APPL_TRACE_WARNING("No ag scb for peer addr");
581 return 0;
582 }
583
584 /*******************************************************************************
585 **
586 ** Function bta_ag_other_scb_open
587 **
588 ** Description Check whether any other scb is in open state.
589 **
590 **
591 ** Returns TRUE if another scb is in open state, FALSE otherwise.
592 **
593 *******************************************************************************/
bta_ag_other_scb_open(tBTA_AG_SCB * p_curr_scb)594 BOOLEAN bta_ag_other_scb_open(tBTA_AG_SCB *p_curr_scb)
595 {
596 tBTA_AG_SCB *p_scb = &bta_ag_cb.scb[0];
597
598 for (int i = 0; i < BTA_AG_NUM_SCB; i++, p_scb++) {
599 if (p_scb->in_use && p_scb != p_curr_scb && p_scb->state == BTA_AG_OPEN_ST) {
600 return TRUE;
601 }
602 }
603 /* no other scb found */
604 APPL_TRACE_DEBUG("No other ag scb open");
605 return FALSE;
606 }
607
608 /*******************************************************************************
609 **
610 ** Function bta_ag_scb_open
611 **
612 ** Description Check whether given scb is in open state.
613 **
614 **
615 ** Returns TRUE if scb is in open state, FALSE otherwise.
616 **
617 *******************************************************************************/
bta_ag_scb_open(tBTA_AG_SCB * p_curr_scb)618 BOOLEAN bta_ag_scb_open(tBTA_AG_SCB *p_curr_scb)
619 {
620 if (p_curr_scb && p_curr_scb->in_use && p_curr_scb->state == BTA_AG_OPEN_ST) {
621 return TRUE;
622 }
623 return FALSE;
624 }
625
626 /*******************************************************************************
627 **
628 ** Function bta_ag_get_other_idle_scb
629 **
630 ** Description Return other scb if it is in INIT st.
631 **
632 **
633 ** Returns Pointer to other scb if INIT st, NULL otherwise.
634 **
635 *******************************************************************************/
bta_ag_get_other_idle_scb(tBTA_AG_SCB * p_curr_scb)636 tBTA_AG_SCB *bta_ag_get_other_idle_scb (tBTA_AG_SCB *p_curr_scb)
637 {
638 tBTA_AG_SCB *p_scb = &bta_ag_cb.scb[0];
639 UINT8 xx;
640
641 for (xx = 0; xx < BTA_AG_NUM_SCB; xx++, p_scb++) {
642 if (p_scb->in_use && (p_scb != p_curr_scb) && (p_scb->state == BTA_AG_INIT_ST)) {
643 return p_scb;
644 }
645 }
646 /* no other scb found */
647 APPL_TRACE_DEBUG("bta_ag_get_other_idle_scb: No idle AG scb");
648 return NULL;
649 }
650
651 /*******************************************************************************
652 **
653 ** Function bta_ag_colli_timer_cback
654 **
655 ** Description AG connection collision timer callback
656 **
657 **
658 ** Returns void
659 **
660 *******************************************************************************/
bta_ag_colli_timer_cback(TIMER_LIST_ENT * p_tle)661 static void bta_ag_colli_timer_cback (TIMER_LIST_ENT *p_tle)
662 {
663 tBTA_AG_SCB *p_scb;
664
665 APPL_TRACE_DEBUG ("bta_ag_colli_timer_cback");
666 if (p_tle) {
667 p_scb = (tBTA_AG_SCB *)p_tle->param;
668 if (p_scb) {
669 p_scb->colli_tmr_on = FALSE;
670 /* If the peer haven't opened AG connection */
671 /* we will restart opening process. */
672 bta_ag_resume_open (p_scb);
673 }
674 }
675 }
676
677 /*******************************************************************************
678 **
679 ** Function bta_ag_collision_cback
680 **
681 ** Description Get notified about collision.
682 **
683 **
684 ** Returns void
685 **
686 *******************************************************************************/
bta_ag_collision_cback(tBTA_SYS_CONN_STATUS status,UINT8 id,UINT8 app_id,BD_ADDR peer_addr)687 void bta_ag_collision_cback (tBTA_SYS_CONN_STATUS status, UINT8 id, UINT8 app_id, BD_ADDR peer_addr)
688 {
689 UINT16 handle;
690 tBTA_AG_SCB *p_scb;
691 UNUSED(status);
692 UNUSED(app_id);
693
694 /* Check if we have opening scb for the peer device. */
695 handle = bta_ag_idx_by_bdaddr (peer_addr);
696 p_scb = bta_ag_scb_by_idx (handle);
697
698 if (p_scb && (p_scb->state == BTA_AG_OPENING_ST)) {
699 if (id == BTA_ID_SYS) {
700 /* ACL collision */
701 APPL_TRACE_WARNING ("AG found collision (ACL) ...");
702 } else if (id == BTA_ID_AG) {
703 /* RFCOMM collision */
704 APPL_TRACE_WARNING ("AG found collision (RFCOMM) ...");
705 } else {
706 APPL_TRACE_WARNING ("AG found collision (\?\?\?) ...");
707 }
708 p_scb->state = BTA_AG_INIT_ST;
709 /* Cancel SDP if it had been started. */
710 if(p_scb->p_disc_db) {
711 (void)SDP_CancelServiceSearch (p_scb->p_disc_db);
712 bta_ag_free_db(p_scb, NULL);
713 }
714 /* reopen registered servers */
715 /* Collision may be detected before or after we close servers. */
716 if (bta_ag_is_server_closed (p_scb)) {
717 bta_ag_start_servers(p_scb, p_scb->reg_services);
718 }
719 /* Start timer to han */
720 p_scb->colli_timer.p_cback = (TIMER_CBACK*)&bta_ag_colli_timer_cback;
721 p_scb->colli_timer.param = (INT32)p_scb;
722 bta_sys_start_timer(&p_scb->colli_timer, 0, BTA_AG_COLLISION_TIMER);
723 p_scb->colli_tmr_on = TRUE;
724 }
725 }
726
727 /*******************************************************************************
728 **
729 ** Function bta_ag_resume_open
730 **
731 ** Description Resume opening process.
732 **
733 **
734 ** Returns void
735 **
736 *******************************************************************************/
bta_ag_resume_open(tBTA_AG_SCB * p_scb)737 void bta_ag_resume_open (tBTA_AG_SCB *p_scb)
738 {
739 if (p_scb) {
740 APPL_TRACE_DEBUG ("bta_ag_resume_open, Handle(%d)", bta_ag_scb_to_idx(p_scb));
741 /* resume opening process. */
742 if (p_scb->state == BTA_AG_INIT_ST) {
743 p_scb->state = BTA_AG_OPENING_ST;
744 bta_ag_start_open (p_scb, NULL);
745 }
746 } else {
747 APPL_TRACE_ERROR ("bta_ag_resume_open, Null p_scb");
748 }
749 }
750
751 /*******************************************************************************
752 **
753 ** Function bta_ag_api_enable
754 **
755 ** Description Handle an API enable event.
756 **
757 **
758 ** Returns void
759 **
760 *******************************************************************************/
bta_ag_api_enable(tBTA_AG_DATA * p_data)761 static void bta_ag_api_enable(tBTA_AG_DATA *p_data)
762 {
763 /* initialize control block */
764 memset(&bta_ag_cb, 0, sizeof(tBTA_AG_CB));
765 /* store callback function */
766 bta_ag_cb.p_cback = p_data->api_enable.p_cback;
767 bta_ag_cb.parse_mode = p_data->api_enable.parse_mode;
768 /* check if mSBC support enabled */
769 if (bta_ag_version >= HFP_VERSION_1_6) {
770 bta_ag_cb.msbc_enabled = TRUE;
771 bta_ag_cb.scb->negotiated_codec = BTM_SCO_CODEC_MSBC;
772 } else{
773 bta_ag_cb.msbc_enabled = FALSE;
774 bta_ag_cb.scb->negotiated_codec = BTM_SCO_CODEC_CVSD;
775 }
776
777 /* set deault setting for eSCO/SCO */
778 BTM_WriteVoiceSettings(AG_VOICE_SETTINGS);
779 bta_sys_collision_register (BTA_ID_AG, bta_ag_collision_cback);
780 /* call callback with enable event */
781 (*bta_ag_cb.p_cback)(BTA_AG_ENABLE_EVT, NULL);
782 }
783
784 /*******************************************************************************
785 **
786 ** Function bta_ag_api_disable
787 **
788 ** Description Handle an API disable event.
789 **
790 **
791 ** Returns void
792 **
793 *******************************************************************************/
bta_ag_api_disable(tBTA_AG_DATA * p_data)794 static void bta_ag_api_disable(tBTA_AG_DATA *p_data)
795 {
796 /* deregister all scbs in use */
797 tBTA_AG_SCB *p_scb = &bta_ag_cb.scb[0];
798 BOOLEAN do_dereg = FALSE;
799 int i;
800
801 if (!bta_sys_is_register (BTA_ID_AG)) {
802 APPL_TRACE_ERROR("BTA AG is already disabled, ignoring ...");
803 return;
804 }
805 /* De-register with BTA system manager */
806 bta_sys_deregister(BTA_ID_AG);
807
808 for (i = 0; i < BTA_AG_NUM_SCB; i++, p_scb++) {
809 if (p_scb->in_use) {
810 bta_ag_sm_execute(p_scb, BTA_AG_API_DEREGISTER_EVT, p_data);
811 do_dereg = TRUE;
812 }
813 }
814
815 if (!do_dereg) {
816 /* Done, send callback evt to app */
817 (*bta_ag_cb.p_cback)(BTA_AG_DISABLE_EVT, NULL);
818 }
819 bta_sys_collision_register (BTA_ID_AG, NULL);
820 }
821
822 /*******************************************************************************
823 **
824 ** Function bta_ag_api_register
825 **
826 ** Description Handle an API event registers a new service.
827 **
828 **
829 ** Returns void
830 **
831 *******************************************************************************/
bta_ag_api_register(tBTA_AG_DATA * p_data)832 static void bta_ag_api_register(tBTA_AG_DATA *p_data)
833 {
834 tBTA_AG_SCB *p_scb;
835 tBTA_AG_REGISTER reg;
836
837 /* allocate an scb */
838 if ((p_scb = bta_ag_scb_alloc()) != NULL) {
839 APPL_TRACE_DEBUG("bta_ag_api_register: p_scb 0x%08x ", (unsigned int)p_scb);
840 bta_ag_sm_execute(p_scb, p_data->hdr.event, p_data);
841 } else {
842 reg.hdr.status = BTA_AG_FAIL_RESOURCES;
843 (*bta_ag_cb.p_cback)(BTA_AG_REGISTER_EVT, (tBTA_AG *) ®);
844 }
845 }
846
847 /*******************************************************************************
848 **
849 ** Function bta_ag_api_result
850 **
851 ** Description Handle an API result event.
852 **
853 **
854 ** Returns void
855 **
856 *******************************************************************************/
bta_ag_api_result(tBTA_AG_DATA * p_data)857 static void bta_ag_api_result(tBTA_AG_DATA *p_data)
858 {
859 tBTA_AG_SCB *p_scb;
860 int i;
861
862 if (p_data->hdr.layer_specific != BTA_AG_HANDLE_ALL) {
863 if ((p_scb = bta_ag_scb_by_idx(p_data->hdr.layer_specific)) != NULL) {
864 APPL_TRACE_DEBUG("bta_ag_api_result: p_scb 0x%08x ", (unsigned int)p_scb);
865 bta_ag_sm_execute(p_scb, BTA_AG_API_RESULT_EVT, p_data);
866 }
867 } else {
868 for (i = 0, p_scb = &bta_ag_cb.scb[0]; i < BTA_AG_NUM_SCB; i++, p_scb++) {
869 if (p_scb->in_use && p_scb->svc_conn) {
870 APPL_TRACE_DEBUG("bta_ag_api_result p_scb 0x%08x ", (unsigned int)p_scb);
871 bta_ag_sm_execute(p_scb, BTA_AG_API_RESULT_EVT, p_data);
872 }
873 }
874 }
875 }
876
877 /*******************************************************************************
878 **
879 ** Function bta_ag_sm_execute
880 **
881 ** Description State machine event handling function for AG
882 **
883 **
884 ** Returns void
885 **
886 *******************************************************************************/
bta_ag_sm_execute(tBTA_AG_SCB * p_scb,UINT16 event,tBTA_AG_DATA * p_data)887 void bta_ag_sm_execute(tBTA_AG_SCB *p_scb, UINT16 event, tBTA_AG_DATA *p_data)
888 {
889 tBTA_AG_ST_TBL state_table;
890 UINT8 action;
891
892 #if BTA_AG_DEBUG == TRUE
893 UINT16 in_event = event;
894 UINT8 in_state = p_scb->state;
895 /* Ignore displaying of AT results when not connected (Ignored in state machine) */
896 if (in_event != BTA_AG_API_RESULT_EVT || p_scb->state == BTA_AG_OPEN_ST) {
897 APPL_TRACE_EVENT("AG evt (hdl 0x%04x): State %d (%s), Event 0x%04x (%s)",
898 bta_ag_scb_to_idx(p_scb),
899 p_scb->state, bta_ag_state_str(p_scb->state),
900 event, bta_ag_evt_str(event, p_data->api_result.result));
901 }
902 #else
903 APPL_TRACE_EVENT("AG evt (hdl 0x%04x): State %d, Event 0x%04x",
904 bta_ag_scb_to_idx(p_scb), p_scb->state, event);
905 #endif
906 event &= 0x00FF;
907 if (event >= (BTA_AG_MAX_EVT & 0x00FF)) {
908 APPL_TRACE_ERROR("AG evt out of range, ignoring...");
909 return;
910 }
911 /* look up the state table for the current state */
912 state_table = bta_ag_st_tbl[p_scb->state];
913 /* set next state */
914 p_scb->state = state_table[event][BTA_AG_NEXT_STATE];
915 /* execute action functions */
916 for (int i = 0; i < BTA_AG_ACTIONS; i++) {
917 if ((action = state_table[event][i]) != BTA_AG_IGNORE) {
918 (*bta_ag_action[action])(p_scb, p_data);
919 } else {
920 break;
921 }
922 }
923 #if BTA_AG_DEBUG == TRUE
924 if (p_scb->state != in_state) {
925 APPL_TRACE_EVENT("BTA AG State Change: [%s] -> [%s] after Event [%s]",
926 bta_ag_state_str(in_state),
927 bta_ag_state_str(p_scb->state),
928 bta_ag_evt_str(in_event, p_data->api_result.result));
929 }
930 #endif
931 }
932
933 /*******************************************************************************
934 **
935 ** Function bta_ag_hdl_event
936 **
937 ** Description Data gateway main event handling function.
938 **
939 **
940 ** Returns BOOLEAN
941 **
942 *******************************************************************************/
bta_ag_hdl_event(BT_HDR * p_msg)943 BOOLEAN bta_ag_hdl_event(BT_HDR *p_msg)
944 {
945 tBTA_AG_SCB *p_scb;
946 APPL_TRACE_DEBUG("bta_ag_hdl_event: Event 0x%04x ", p_msg->event);
947
948 switch (p_msg->event) {
949 /* handle enable event */
950 case BTA_AG_API_ENABLE_EVT:
951 bta_ag_api_enable((tBTA_AG_DATA *) p_msg);
952 break;
953
954 /* handle disable event */
955 case BTA_AG_API_DISABLE_EVT:
956 bta_ag_api_disable((tBTA_AG_DATA *) p_msg);
957 break;
958
959 /* handle register event */
960 case BTA_AG_API_REGISTER_EVT:
961 bta_ag_api_register((tBTA_AG_DATA *) p_msg);
962 break;
963
964 /* handle result event */
965 case BTA_AG_API_RESULT_EVT:
966 bta_ag_api_result((tBTA_AG_DATA *) p_msg);
967 break;
968
969 /* all others reference scb by handle */
970 default:
971 if ((p_scb = bta_ag_scb_by_idx(p_msg->layer_specific)) != NULL) {
972 APPL_TRACE_DEBUG("bta_ag_hdl_event: p_scb 0x%08x ", (unsigned int)p_scb);
973 bta_ag_sm_execute(p_scb, p_msg->event, (tBTA_AG_DATA *) p_msg);
974 }
975 break;
976 }
977 return TRUE;
978 }
979
980 #endif /* #if (BTA_AG_INCLUDED == TRUE) */
981
