1 /******************************************************************************
2  *
3  *  Copyright (c) 2014 The Android Open Source Project
4  *  Copyright (C) 2003-2012 Broadcom Corporation
5  *
6  *  Licensed under the Apache License, Version 2.0 (the "License");
7  *  you may not use this file except in compliance with the License.
8  *  You may obtain a copy of the License at:
9  *
10  *  http://www.apache.org/licenses/LICENSE-2.0
11  *
12  *  Unless required by applicable law or agreed to in writing, software
13  *  distributed under the License is distributed on an "AS IS" BASIS,
14  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15  *  See the License for the specific language governing permissions and
16  *  limitations under the License.
17  *
18  ******************************************************************************/
19 
20 #include <string.h>
21 #include <stdlib.h>
22 #include "common/bt_defs.h"
23 #include "bta/bta_api.h"
24 #include "bta/bta_sys.h"
25 #include "bta/bta_hf_client_api.h"
26 #include "bta_hf_client_int.h"
27 
28 #if BT_HF_CLIENT_BQB_INCLUDED
29 static BOOLEAN s_bta_hf_client_bqb_clip_flag = TRUE;
30 #endif /* BT_HF_CLIENT_BQB_INCLUDED */
31 
32 #if (BTA_HF_INCLUDED == TRUE)
33 /* uncomment to enable extra debug */
34 /* #define BTA_HF_CLIENT_DEBUG TRUE */
35 
36 #ifndef BTA_HF_CLIENT_DEBUG
37 #define BTA_HF_CLIENT_DEBUG FALSE
38 #endif
39 
40 #if BTA_HF_CLIENT_DEBUG == TRUE
41 static char *bta_hf_client_evt_str(UINT16 event);
42 static char *bta_hf_client_state_str(UINT8 state);
43 #endif
44 
45 /* state machine states */
46 enum {
47     BTA_HF_CLIENT_INIT_ST,
48     BTA_HF_CLIENT_OPENING_ST,
49     BTA_HF_CLIENT_OPEN_ST,
50     BTA_HF_CLIENT_CLOSING_ST
51 };
52 
53 /* state machine action enumeration list */
54 enum {
55     BTA_HF_CLIENT_REGISTER,
56     BTA_HF_CLIENT_DEREGISTER,
57     BTA_HF_CLIENT_START_DEREG,
58     BTA_HF_CLIENT_RFC_DO_CLOSE,
59     BTA_HF_CLIENT_START_CLOSE,
60     BTA_HF_CLIENT_START_OPEN,
61     BTA_HF_CLIENT_RFC_ACP_OPEN,
62     BTA_HF_CLIENT_SCO_LISTEN,
63     BTA_HF_CLIENT_SCO_CONN_OPEN,
64     BTA_HF_CLIENT_SCO_CONN_CLOSE,
65     BTA_HF_CLIENT_SCO_OPEN,
66     BTA_HF_CLIENT_SCO_CLOSE,
67     BTA_HF_CLIENT_SCO_SHUTDOWN,
68     BTA_HF_CLIENT_FREE_DB,
69     BTA_HF_CLIENT_OPEN_FAIL,
70     BTA_HF_CLIENT_RFC_OPEN,
71     BTA_HF_CLIENT_RFC_FAIL,
72     BTA_HF_CLIENT_DISC_INT_RES,
73     BTA_HF_CLIENT_RFC_DO_OPEN,
74     BTA_HF_CLIENT_DISC_FAIL,
75     BTA_HF_CLIENT_RFC_CLOSE,
76     BTA_HF_CLIENT_RFC_DATA,
77     BTA_HF_CLIENT_DISC_ACP_RES,
78     BTA_HF_CLIENT_SVC_CONN_OPEN,
79     BTA_HF_CLIENT_SEND_AT_CMD,
80 #if (BTM_SCO_HCI_INCLUDED == TRUE)
81     BTA_HF_CLIENT_CI_SCO_DATA,
82     BTA_HF_CLIENT_PKT_STAT_NUMS,
83 #endif
84     BTA_HF_CLIENT_NUM_ACTIONS,
85 };
86 
87 #define BTA_HF_CLIENT_IGNORE BTA_HF_CLIENT_NUM_ACTIONS
88 
89 /* type for action functions */
90 typedef void (*tBTA_HF_CLIENT_ACTION)(tBTA_HF_CLIENT_DATA *p_data);
91 
92 /* action functions table, indexed with action enum */
93 const tBTA_HF_CLIENT_ACTION bta_hf_client_action[] = {
94     /* BTA_HF_CLIENT_REGISTER */      bta_hf_client_register,
95     /* BTA_HF_CLIENT_DEREGISTER */    bta_hf_client_deregister,
96     /* BTA_HF_CLIENT_START_DEREG */   bta_hf_client_start_dereg,
97     /* BTA_HF_CLIENT_RFC_DO_CLOSE */  bta_hf_client_rfc_do_close,
98     /* BTA_HF_CLIENT_START_CLOSE */   bta_hf_client_start_close,
99     /* BTA_HF_CLIENT_START_OPEN */    bta_hf_client_start_open,
100     /* BTA_HF_CLIENT_RFC_ACP_OPEN */  bta_hf_client_rfc_acp_open,
101     /* BTA_HF_CLIENT_SCO_LISTEN */    bta_hf_client_sco_listen,
102     /* BTA_HF_CLIENT_SCO_CONN_OPEN */ bta_hf_client_sco_conn_open,
103     /* BTA_HF_CLIENT_SCO_CONN_CLOSE*/ bta_hf_client_sco_conn_close,
104     /* BTA_HF_CLIENT_SCO_OPEN */      bta_hf_client_sco_open,
105     /* BTA_HF_CLIENT_SCO_CLOSE */     bta_hf_client_sco_close,
106     /* BTA_HF_CLIENT_SCO_SHUTDOWN */  bta_hf_client_sco_shutdown,
107     /* BTA_HF_CLIENT_FREE_DB */       bta_hf_client_free_db,
108     /* BTA_HF_CLIENT_OPEN_FAIL */     bta_hf_client_open_fail,
109     /* BTA_HF_CLIENT_RFC_OPEN */      bta_hf_client_rfc_open,
110     /* BTA_HF_CLIENT_RFC_FAIL */      bta_hf_client_rfc_fail,
111     /* BTA_HF_CLIENT_DISC_INT_RES */  bta_hf_client_disc_int_res,
112     /* BTA_HF_CLIENT_RFC_DO_OPEN */   bta_hf_client_rfc_do_open,
113     /* BTA_HF_CLIENT_DISC_FAIL */     bta_hf_client_disc_fail,
114     /* BTA_HF_CLIENT_RFC_CLOSE */     bta_hf_client_rfc_close,
115     /* BTA_HF_CLIENT_RFC_DATA */      bta_hf_client_rfc_data,
116     /* BTA_HF_CLIENT_DISC_ACP_RES */  bta_hf_client_disc_acp_res,
117     /* BTA_HF_CLIENT_SVC_CONN_OPEN */ bta_hf_client_svc_conn_open,
118     /* BTA_HF_CLIENT_SEND_AT_CMD */   bta_hf_client_send_at_cmd,
119 #if (BTM_SCO_HCI_INCLUDED == TRUE)
120     /* BTA_HF_CLIENT_CI_SCO_DATA */   bta_hf_client_ci_sco_data,
121     /* BTA_HF_CLIENT_PKT_STAT_NUMS */ bta_hf_client_pkt_stat_nums,
122 #endif /* (BTM_SCO_HCI_INCLUDED == TRUE ) */
123 };
124 
125 /* state table information */
126 #define BTA_HF_CLIENT_ACTIONS              2       /* number of actions */
127 #define BTA_HF_CLIENT_NEXT_STATE           2       /* position of next state */
128 #define BTA_HF_CLIENT_NUM_COLS             3       /* number of columns in state tables */
129 
130 /* state table for init state */
131 const UINT8 bta_hf_client_st_init[][BTA_HF_CLIENT_NUM_COLS] = {
132     /* Event                    Action 1                       Action 2                       Next state */
133     /* API_REGISTER_EVT */      {BTA_HF_CLIENT_REGISTER,       BTA_HF_CLIENT_IGNORE,          BTA_HF_CLIENT_INIT_ST},
134     /* API_DEREGISTER_EVT */    {BTA_HF_CLIENT_DEREGISTER,     BTA_HF_CLIENT_IGNORE,          BTA_HF_CLIENT_INIT_ST},
135     /* API_OPEN_EVT */          {BTA_HF_CLIENT_START_OPEN,     BTA_HF_CLIENT_IGNORE,          BTA_HF_CLIENT_OPENING_ST},
136     /* API_CLOSE_EVT */         {BTA_HF_CLIENT_IGNORE,         BTA_HF_CLIENT_IGNORE,          BTA_HF_CLIENT_INIT_ST},
137     /* API_AUDIO_OPEN_EVT */    {BTA_HF_CLIENT_IGNORE,         BTA_HF_CLIENT_IGNORE,          BTA_HF_CLIENT_INIT_ST},
138     /* API_AUDIO_CLOSE_EVT */   {BTA_HF_CLIENT_IGNORE,         BTA_HF_CLIENT_IGNORE,          BTA_HF_CLIENT_INIT_ST},
139     /* RFC_OPEN_EVT */          {BTA_HF_CLIENT_RFC_ACP_OPEN,   BTA_HF_CLIENT_SCO_LISTEN,      BTA_HF_CLIENT_OPEN_ST},
140     /* RFC_CLOSE_EVT */         {BTA_HF_CLIENT_IGNORE,         BTA_HF_CLIENT_IGNORE,          BTA_HF_CLIENT_INIT_ST},
141     /* RFC_SRV_CLOSE_EVT */     {BTA_HF_CLIENT_IGNORE,         BTA_HF_CLIENT_IGNORE,          BTA_HF_CLIENT_INIT_ST},
142     /* RFC_DATA_EVT */          {BTA_HF_CLIENT_IGNORE,         BTA_HF_CLIENT_IGNORE,          BTA_HF_CLIENT_INIT_ST},
143     /* DISC_ACP_RES_EVT */      {BTA_HF_CLIENT_FREE_DB,        BTA_HF_CLIENT_IGNORE,          BTA_HF_CLIENT_INIT_ST},
144     /* DISC_INT_RES_EVT */      {BTA_HF_CLIENT_IGNORE,         BTA_HF_CLIENT_IGNORE,          BTA_HF_CLIENT_INIT_ST},
145     /* DISC_OK_EVT */           {BTA_HF_CLIENT_IGNORE,         BTA_HF_CLIENT_IGNORE,          BTA_HF_CLIENT_INIT_ST},
146     /* DISC_FAIL_EVT */         {BTA_HF_CLIENT_IGNORE,         BTA_HF_CLIENT_IGNORE,          BTA_HF_CLIENT_INIT_ST},
147     /* SCO_OPEN_EVT */          {BTA_HF_CLIENT_IGNORE,         BTA_HF_CLIENT_IGNORE,          BTA_HF_CLIENT_INIT_ST},
148     /* SCO_CLOSE_EVT */         {BTA_HF_CLIENT_IGNORE,         BTA_HF_CLIENT_IGNORE,          BTA_HF_CLIENT_INIT_ST},
149     /* SEND_AT_CMD_EVT */       {BTA_HF_CLIENT_IGNORE,         BTA_HF_CLIENT_IGNORE,          BTA_HF_CLIENT_INIT_ST},
150 #if (BTM_SCO_HCI_INCLUDED == TRUE )
151     /* CI_SCO_DATA_EVT */       {BTA_HF_CLIENT_IGNORE,         BTA_HF_CLIENT_IGNORE,          BTA_HF_CLIENT_INIT_ST},
152     /* PKT_STAT_NUMS_GET_EVT */ {BTA_HF_CLIENT_PKT_STAT_NUMS,  BTA_HF_CLIENT_IGNORE,          BTA_HF_CLIENT_INIT_ST},
153 #endif /* (BTM_SCO_HCI_INCLUDED == TRUE ) */
154 };
155 
156 /* state table for opening state */
157 const UINT8 bta_hf_client_st_opening[][BTA_HF_CLIENT_NUM_COLS] = {
158     /* Event                    Action 1                       Action 2                       Next state */
159     /* API_REGISTER_EVT */      {BTA_HF_CLIENT_IGNORE,         BTA_HF_CLIENT_IGNORE,          BTA_HF_CLIENT_OPENING_ST},
160     /* API_DEREGISTER_EVT */    {BTA_HF_CLIENT_RFC_DO_CLOSE,   BTA_HF_CLIENT_START_DEREG,     BTA_HF_CLIENT_CLOSING_ST},
161     /* API_OPEN_EVT */          {BTA_HF_CLIENT_OPEN_FAIL,      BTA_HF_CLIENT_IGNORE,          BTA_HF_CLIENT_OPENING_ST},
162     /* API_CLOSE_EVT */         {BTA_HF_CLIENT_RFC_DO_CLOSE,   BTA_HF_CLIENT_IGNORE,          BTA_HF_CLIENT_CLOSING_ST},
163     /* API_AUDIO_OPEN_EVT */    {BTA_HF_CLIENT_IGNORE,         BTA_HF_CLIENT_IGNORE,          BTA_HF_CLIENT_OPENING_ST},
164     /* API_AUDIO_CLOSE_EVT */   {BTA_HF_CLIENT_IGNORE,         BTA_HF_CLIENT_IGNORE,          BTA_HF_CLIENT_OPENING_ST},
165     /* RFC_OPEN_EVT */          {BTA_HF_CLIENT_RFC_OPEN,       BTA_HF_CLIENT_SCO_LISTEN,      BTA_HF_CLIENT_OPEN_ST},
166     /* RFC_CLOSE_EVT */         {BTA_HF_CLIENT_RFC_FAIL,       BTA_HF_CLIENT_IGNORE,          BTA_HF_CLIENT_INIT_ST},
167     /* RFC_SRV_CLOSE_EVT */     {BTA_HF_CLIENT_IGNORE,         BTA_HF_CLIENT_IGNORE,          BTA_HF_CLIENT_OPENING_ST},
168     /* RFC_DATA_EVT */          {BTA_HF_CLIENT_IGNORE,         BTA_HF_CLIENT_IGNORE,          BTA_HF_CLIENT_OPENING_ST},
169     /* DISC_ACP_RES_EVT */      {BTA_HF_CLIENT_IGNORE,         BTA_HF_CLIENT_IGNORE,          BTA_HF_CLIENT_OPENING_ST},
170     /* DISC_INT_RES_EVT */      {BTA_HF_CLIENT_DISC_INT_RES,   BTA_HF_CLIENT_IGNORE,          BTA_HF_CLIENT_OPENING_ST},
171     /* DISC_OK_EVT */           {BTA_HF_CLIENT_RFC_DO_OPEN,    BTA_HF_CLIENT_IGNORE,          BTA_HF_CLIENT_OPENING_ST},
172     /* DISC_FAIL_EVT */         {BTA_HF_CLIENT_DISC_FAIL,      BTA_HF_CLIENT_IGNORE,          BTA_HF_CLIENT_INIT_ST},
173     /* SCO_OPEN_EVT */          {BTA_HF_CLIENT_IGNORE,         BTA_HF_CLIENT_IGNORE,          BTA_HF_CLIENT_OPENING_ST},
174     /* SCO_CLOSE_EVT */         {BTA_HF_CLIENT_IGNORE,         BTA_HF_CLIENT_IGNORE,          BTA_HF_CLIENT_OPENING_ST},
175     /* SEND_AT_CMD_EVT */       {BTA_HF_CLIENT_IGNORE,         BTA_HF_CLIENT_IGNORE,          BTA_HF_CLIENT_OPENING_ST},
176 #if (BTM_SCO_HCI_INCLUDED == TRUE)
177     /* CI_SCO_DATA_EVT */       {BTA_HF_CLIENT_IGNORE,         BTA_HF_CLIENT_IGNORE,          BTA_HF_CLIENT_OPENING_ST},
178     /* PKT_STAT_NUMS_GET_EVT */ {BTA_HF_CLIENT_PKT_STAT_NUMS,  BTA_HF_CLIENT_IGNORE,          BTA_HF_CLIENT_OPENING_ST},
179 #endif /* (BTM_SCO_HCI_INCLUDED == TRUE ) */
180 };
181 
182 /* state table for open state */
183 const UINT8 bta_hf_client_st_open[][BTA_HF_CLIENT_NUM_COLS] = {
184     /* Event                    Action 1                       Action 2                       Next state */
185     /* API_REGISTER_EVT */      {BTA_HF_CLIENT_IGNORE,         BTA_HF_CLIENT_IGNORE,          BTA_HF_CLIENT_OPEN_ST},
186     /* API_DEREGISTER_EVT */    {BTA_HF_CLIENT_START_CLOSE,    BTA_HF_CLIENT_START_DEREG,     BTA_HF_CLIENT_CLOSING_ST},
187     /* API_OPEN_EVT */          {BTA_HF_CLIENT_OPEN_FAIL,      BTA_HF_CLIENT_IGNORE,          BTA_HF_CLIENT_OPEN_ST},
188     /* API_CLOSE_EVT */         {BTA_HF_CLIENT_START_CLOSE,    BTA_HF_CLIENT_IGNORE,          BTA_HF_CLIENT_CLOSING_ST},
189     /* API_AUDIO_OPEN_EVT */    {BTA_HF_CLIENT_SCO_OPEN,       BTA_HF_CLIENT_IGNORE,          BTA_HF_CLIENT_OPEN_ST},
190     /* API_AUDIO_CLOSE_EVT */   {BTA_HF_CLIENT_SCO_CLOSE,      BTA_HF_CLIENT_IGNORE,          BTA_HF_CLIENT_OPEN_ST},
191     /* RFC_OPEN_EVT */          {BTA_HF_CLIENT_IGNORE,         BTA_HF_CLIENT_IGNORE,          BTA_HF_CLIENT_OPEN_ST},
192     /* RFC_CLOSE_EVT */         {BTA_HF_CLIENT_RFC_CLOSE,      BTA_HF_CLIENT_IGNORE,          BTA_HF_CLIENT_INIT_ST},
193     /* RFC_SRV_CLOSE_EVT */     {BTA_HF_CLIENT_IGNORE,         BTA_HF_CLIENT_IGNORE,          BTA_HF_CLIENT_OPEN_ST},
194     /* RFC_DATA_EVT */          {BTA_HF_CLIENT_RFC_DATA,       BTA_HF_CLIENT_IGNORE,          BTA_HF_CLIENT_OPEN_ST},
195     /* DISC_ACP_RES_EVT */      {BTA_HF_CLIENT_DISC_ACP_RES,   BTA_HF_CLIENT_IGNORE,          BTA_HF_CLIENT_OPEN_ST},
196     /* DISC_INT_RES_EVT */      {BTA_HF_CLIENT_IGNORE,         BTA_HF_CLIENT_IGNORE,          BTA_HF_CLIENT_OPEN_ST},
197     /* DISC_OK_EVT */           {BTA_HF_CLIENT_IGNORE,         BTA_HF_CLIENT_IGNORE,          BTA_HF_CLIENT_OPEN_ST},
198     /* DISC_FAIL_EVT */         {BTA_HF_CLIENT_IGNORE,         BTA_HF_CLIENT_IGNORE,          BTA_HF_CLIENT_OPEN_ST},
199     /* SCO_OPEN_EVT */          {BTA_HF_CLIENT_SCO_CONN_OPEN,  BTA_HF_CLIENT_IGNORE,          BTA_HF_CLIENT_OPEN_ST},
200     /* SCO_CLOSE_EVT */         {BTA_HF_CLIENT_SCO_CONN_CLOSE, BTA_HF_CLIENT_IGNORE,          BTA_HF_CLIENT_OPEN_ST},
201     /* SEND_AT_CMD_EVT */       {BTA_HF_CLIENT_SEND_AT_CMD,    BTA_HF_CLIENT_IGNORE,          BTA_HF_CLIENT_OPEN_ST},
202 #if (BTM_SCO_HCI_INCLUDED == TRUE )
203     /* CI_SCO_DATA_EVT */       {BTA_HF_CLIENT_CI_SCO_DATA,    BTA_HF_CLIENT_IGNORE,          BTA_HF_CLIENT_OPEN_ST},
204     /* PKT_STAT_NUMS_GET_EVT */ {BTA_HF_CLIENT_PKT_STAT_NUMS,  BTA_HF_CLIENT_IGNORE,          BTA_HF_CLIENT_OPEN_ST},
205 #endif /* (BTM_SCO_HCI_INCLUDED == TRUE ) */
206 };
207 
208 /* state table for closing state */
209 const UINT8 bta_hf_client_st_closing[][BTA_HF_CLIENT_NUM_COLS] = {
210     /* Event                    Action 1                       Action 2                       Next state */
211     /* API_REGISTER_EVT */      {BTA_HF_CLIENT_IGNORE,         BTA_HF_CLIENT_IGNORE,          BTA_HF_CLIENT_CLOSING_ST},
212     /* API_DEREGISTER_EVT */    {BTA_HF_CLIENT_START_DEREG,    BTA_HF_CLIENT_IGNORE,          BTA_HF_CLIENT_CLOSING_ST},
213     /* API_OPEN_EVT */          {BTA_HF_CLIENT_OPEN_FAIL,      BTA_HF_CLIENT_IGNORE,          BTA_HF_CLIENT_CLOSING_ST},
214     /* API_CLOSE_EVT */         {BTA_HF_CLIENT_IGNORE,         BTA_HF_CLIENT_IGNORE,          BTA_HF_CLIENT_CLOSING_ST},
215     /* API_AUDIO_OPEN_EVT */    {BTA_HF_CLIENT_IGNORE,         BTA_HF_CLIENT_IGNORE,          BTA_HF_CLIENT_CLOSING_ST},
216     /* API_AUDIO_CLOSE_EVT */   {BTA_HF_CLIENT_IGNORE,         BTA_HF_CLIENT_IGNORE,          BTA_HF_CLIENT_CLOSING_ST},
217     /* RFC_OPEN_EVT */          {BTA_HF_CLIENT_IGNORE,         BTA_HF_CLIENT_IGNORE,          BTA_HF_CLIENT_CLOSING_ST},
218     /* RFC_CLOSE_EVT */         {BTA_HF_CLIENT_RFC_CLOSE,      BTA_HF_CLIENT_IGNORE,          BTA_HF_CLIENT_INIT_ST},
219     /* RFC_SRV_CLOSE_EVT */     {BTA_HF_CLIENT_IGNORE,         BTA_HF_CLIENT_IGNORE,          BTA_HF_CLIENT_CLOSING_ST},
220     /* RFC_DATA_EVT */          {BTA_HF_CLIENT_IGNORE,         BTA_HF_CLIENT_IGNORE,          BTA_HF_CLIENT_CLOSING_ST},
221     /* DISC_ACP_RES_EVT */      {BTA_HF_CLIENT_FREE_DB,        BTA_HF_CLIENT_IGNORE,          BTA_HF_CLIENT_CLOSING_ST},
222     /* DISC_INT_RES_EVT */      {BTA_HF_CLIENT_FREE_DB,        BTA_HF_CLIENT_IGNORE,          BTA_HF_CLIENT_INIT_ST},
223     /* DISC_OK_EVT */           {BTA_HF_CLIENT_IGNORE,         BTA_HF_CLIENT_IGNORE,          BTA_HF_CLIENT_CLOSING_ST},
224     /* DISC_FAIL_EVT */         {BTA_HF_CLIENT_IGNORE,         BTA_HF_CLIENT_IGNORE,          BTA_HF_CLIENT_CLOSING_ST},
225     /* SCO_OPEN_EVT */          {BTA_HF_CLIENT_IGNORE,         BTA_HF_CLIENT_IGNORE,          BTA_HF_CLIENT_CLOSING_ST},
226     /* SCO_CLOSE_EVT */         {BTA_HF_CLIENT_SCO_CONN_CLOSE, BTA_HF_CLIENT_IGNORE,          BTA_HF_CLIENT_CLOSING_ST},
227     /* SEND_AT_CMD_EVT */       {BTA_HF_CLIENT_IGNORE,         BTA_HF_CLIENT_IGNORE,          BTA_HF_CLIENT_CLOSING_ST},
228 #if (BTM_SCO_HCI_INCLUDED == TRUE )
229     /* CI_SCO_DATA_EVT */       {BTA_HF_CLIENT_IGNORE,         BTA_HF_CLIENT_IGNORE,          BTA_HF_CLIENT_CLOSING_ST},
230     /* PKT_STAT_NUMS_GET_EVT */ {BTA_HF_CLIENT_PKT_STAT_NUMS,  BTA_HF_CLIENT_IGNORE,          BTA_HF_CLIENT_CLOSING_ST},
231 #endif /* (BTM_SCO_HCI_INCLUDED == TRUE ) */
232 };
233 
234 /* type for state table */
235 typedef const UINT8 (*tBTA_HF_CLIENT_ST_TBL)[BTA_HF_CLIENT_NUM_COLS];
236 
237 /* state table */
238 const tBTA_HF_CLIENT_ST_TBL bta_hf_client_st_tbl[] = {
239     bta_hf_client_st_init,
240     bta_hf_client_st_opening,
241     bta_hf_client_st_open,
242     bta_hf_client_st_closing
243 };
244 
245 const int bta_hf_client_version = HFP_HF_VERSION_1_7;
246 
247 /* HF Client control block */
248 #if BTA_DYNAMIC_MEMORY == FALSE
249 tBTA_HF_CLIENT_CB  bta_hf_client_cb;
250 #else
251 tBTA_HF_CLIENT_CB  *bta_hf_client_cb_ptr;
252 #endif
253 
254 /*******************************************************************************
255 **
256 ** Function     bta_hf_client_bqb_clip_ctrl
257 **
258 ** Description  Control if send the command AT+CLIP for BQB test
259 **
260 ** Returns      void
261 **
262 *******************************************************************************/
263 #if BT_HF_CLIENT_BQB_INCLUDED
bta_hf_client_bqb_clip_ctrl(BOOLEAN enable)264 void bta_hf_client_bqb_clip_ctrl(BOOLEAN enable)
265 {
266     s_bta_hf_client_bqb_clip_flag = enable;
267 }
268 #endif /* BT_HF_CLIENT_BQB_INCLUDED */
269 
270 /*******************************************************************************
271 **
272 ** Function         bta_hf_client_scb_init
273 **
274 ** Description      Initialize an HF_Client service control block.
275 **
276 **
277 ** Returns          void
278 **
279 *******************************************************************************/
bta_hf_client_scb_init(void)280 void bta_hf_client_scb_init(void)
281 {
282     APPL_TRACE_DEBUG("%s", __FUNCTION__);
283 
284     memset(&bta_hf_client_cb.scb, 0, sizeof(tBTA_HF_CLIENT_SCB));
285     bta_hf_client_cb.scb.sco_idx = BTM_INVALID_SCO_INDEX;
286     bta_hf_client_cb.scb.negotiated_codec = BTM_SCO_CODEC_CVSD;
287 }
288 
289 /*******************************************************************************
290 **
291 ** Function         bta_hf_client_scb_disable
292 **
293 ** Description      Disable a service control block.
294 **
295 **
296 ** Returns          void
297 **
298 *******************************************************************************/
bta_hf_client_scb_disable(void)299 void bta_hf_client_scb_disable(void)
300 {
301     APPL_TRACE_DEBUG("%s", __FUNCTION__);
302 
303     bta_hf_client_scb_init();
304 
305     (*bta_hf_client_cb.p_cback)(BTA_HF_CLIENT_DISABLE_EVT, NULL);
306 }
307 
308 /*******************************************************************************
309 **
310 ** Function         bta_hf_client_resume_open
311 **
312 ** Description      Resume opening process.
313 **
314 **
315 ** Returns          void
316 **
317 *******************************************************************************/
bta_hf_client_resume_open(void)318 void bta_hf_client_resume_open (void)
319 {
320     APPL_TRACE_DEBUG ("%s", __FUNCTION__);
321 
322     /* resume opening process.  */
323     if (bta_hf_client_cb.scb.state == BTA_HF_CLIENT_INIT_ST) {
324         bta_hf_client_cb.scb.state = BTA_HF_CLIENT_OPENING_ST;
325         bta_hf_client_start_open (NULL);
326     }
327 }
328 
329 /*******************************************************************************
330 **
331 ** Function         bta_hf_client_colli_timer_cback
332 **
333 ** Description      HF Client connection collision timer callback
334 **
335 **
336 ** Returns          void
337 **
338 *******************************************************************************/
bta_hf_client_colli_timer_cback(TIMER_LIST_ENT * p_tle)339 static void bta_hf_client_colli_timer_cback (TIMER_LIST_ENT *p_tle)
340 {
341     APPL_TRACE_DEBUG("%s", __FUNCTION__);
342 
343     if (p_tle) {
344         bta_hf_client_cb.scb.colli_tmr_on = FALSE;
345 
346         /* If the peer haven't opened connection, restart opening process */
347         bta_hf_client_resume_open ();
348     }
349 }
350 
351 /*******************************************************************************
352 **
353 ** Function         bta_hf_client_collision_cback
354 **
355 ** Description      Get notified about collision.
356 **
357 **
358 ** Returns          void
359 **
360 *******************************************************************************/
bta_hf_client_collision_cback(tBTA_SYS_CONN_STATUS status,UINT8 id,UINT8 app_id,BD_ADDR peer_addr)361 void bta_hf_client_collision_cback (tBTA_SYS_CONN_STATUS status, UINT8 id,
362                                     UINT8 app_id, BD_ADDR peer_addr)
363 {
364     UNUSED(status);
365     UNUSED(app_id);
366     UNUSED(peer_addr);
367 
368     if (bta_hf_client_cb.scb.state == BTA_HF_CLIENT_OPENING_ST) {
369         if (id == BTA_ID_SYS) { /* ACL collision */
370             APPL_TRACE_WARNING ("HF Client found collision (ACL) ...");
371         } else if (id == BTA_ID_HS) { /* RFCOMM collision */
372             APPL_TRACE_WARNING ("HF Client found collision (RFCOMM) ...");
373         } else {
374             APPL_TRACE_WARNING ("HF Client found collision (\?\?\?) ...");
375         }
376 
377         bta_hf_client_cb.scb.state = BTA_HF_CLIENT_INIT_ST;
378 
379         /* Cancel SDP if it had been started. */
380         if (bta_hf_client_cb.scb.p_disc_db) {
381             (void)SDP_CancelServiceSearch (bta_hf_client_cb.scb.p_disc_db);
382             bta_hf_client_free_db(NULL);
383         }
384 
385         /* reopen registered server */
386         /* Collision may be detected before or after we close servers. */
387         bta_hf_client_start_server();
388 
389         /* Start timer to handle connection opening restart */
390         bta_hf_client_cb.scb.colli_timer.p_cback = (TIMER_CBACK *)&bta_hf_client_colli_timer_cback;
391         bta_sys_start_timer(&bta_hf_client_cb.scb.colli_timer, 0, BTA_HF_CLIENT_COLLISION_TIMER);
392         bta_hf_client_cb.scb.colli_tmr_on = TRUE;
393     }
394 }
395 
396 /*******************************************************************************
397 **
398 ** Function         bta_hf_client_api_enable
399 **
400 ** Description      Handle an API enable event.
401 **
402 **
403 ** Returns          void
404 **
405 *******************************************************************************/
bta_hf_client_api_enable(tBTA_HF_CLIENT_DATA * p_data)406 static void bta_hf_client_api_enable(tBTA_HF_CLIENT_DATA *p_data)
407 {
408     /* initialize control block */
409     memset(&bta_hf_client_cb, 0, sizeof(tBTA_HF_CLIENT_CB));
410 
411     /* store callback function */
412     bta_hf_client_cb.p_cback = p_data->api_enable.p_cback;
413 
414     /* check if mSBC support enabled */
415     if (bta_hf_client_version >= HFP_HF_VERSION_1_6) {
416 #if (BTM_WBS_INCLUDED == TRUE)
417         bta_hf_client_cb.msbc_enabled = TRUE;
418 #else
419         bta_hf_client_cb.msbc_enabled = FALSE;
420 #endif
421     } else{
422         bta_hf_client_cb.msbc_enabled = FALSE;
423     }
424 
425     bta_hf_client_cb.scb.negotiated_codec = BTM_SCO_CODEC_CVSD;
426 
427     /* set same setting as AG does */
428     BTM_WriteVoiceSettings(AG_VOICE_SETTINGS);
429 
430     bta_sys_collision_register (BTA_ID_HS, bta_hf_client_collision_cback);
431 
432     /* call callback with enable event */
433     (*bta_hf_client_cb.p_cback)(BTA_HF_CLIENT_ENABLE_EVT, NULL);
434 }
435 
436 /*******************************************************************************
437 **
438 ** Function         bta_hf_client_api_disable
439 **
440 ** Description      Handle an API disable event.
441 **
442 **
443 ** Returns          void
444 **
445 *******************************************************************************/
bta_hf_client_api_disable(tBTA_HF_CLIENT_DATA * p_data)446 static void bta_hf_client_api_disable(tBTA_HF_CLIENT_DATA *p_data)
447 {
448     if (!bta_sys_is_register (BTA_ID_HS)) {
449         APPL_TRACE_ERROR("BTA HF Client is already disabled, ignoring ...");
450         return;
451     }
452 
453     /* De-register with BTA system manager */
454     bta_sys_deregister(BTA_ID_HS);
455 
456     bta_hf_client_sm_execute(BTA_HF_CLIENT_API_DEREGISTER_EVT, p_data);
457 
458     bta_sys_collision_register (BTA_ID_HS, NULL);
459 }
460 
461 /*******************************************************************************
462 **
463 ** Function         bta_hf_client_hdl_event
464 **
465 ** Description      Data HF Client main event handling function.
466 **
467 **
468 ** Returns          BOOLEAN
469 **
470 *******************************************************************************/
bta_hf_client_hdl_event(BT_HDR * p_msg)471 BOOLEAN bta_hf_client_hdl_event(BT_HDR *p_msg)
472 {
473 #if BTA_HF_CLIENT_DEBUG == TRUE
474     APPL_TRACE_DEBUG("bta_hf_client_hdl_event %s (0x%x)", bta_hf_client_evt_str(p_msg->event), p_msg->event);
475 #endif
476 
477     switch (p_msg->event) {
478     /* handle enable event */
479     case BTA_HF_CLIENT_API_ENABLE_EVT:
480         bta_hf_client_api_enable((tBTA_HF_CLIENT_DATA *) p_msg);
481         break;
482 
483     /* handle disable event */
484     case BTA_HF_CLIENT_API_DISABLE_EVT:
485         bta_hf_client_api_disable((tBTA_HF_CLIENT_DATA *) p_msg);
486         break;
487 
488     default:
489         bta_hf_client_sm_execute(p_msg->event, (tBTA_HF_CLIENT_DATA *) p_msg);
490         break;
491     }
492     return TRUE;
493 }
494 
495 /*******************************************************************************
496 **
497 ** Function         bta_hf_client_sm_execute
498 **
499 ** Description      State machine event handling function for HF Client
500 **
501 **
502 ** Returns          void
503 **
504 *******************************************************************************/
bta_hf_client_sm_execute(UINT16 event,tBTA_HF_CLIENT_DATA * p_data)505 void bta_hf_client_sm_execute(UINT16 event, tBTA_HF_CLIENT_DATA *p_data)
506 {
507     tBTA_HF_CLIENT_ST_TBL      state_table;
508     UINT8               action;
509     int                 i;
510 
511 #if BTA_HF_CLIENT_DEBUG == TRUE
512     UINT16  in_event = event;
513     UINT8 in_state =  bta_hf_client_cb.scb.state;
514 
515     /* Ignore displaying of AT results when not connected (Ignored in state machine) */
516     if (bta_hf_client_cb.scb.state == BTA_HF_CLIENT_OPEN_ST) {
517         APPL_TRACE_EVENT("HF Client evt : State %d (%s), Event 0x%04x (%s)",
518                          bta_hf_client_cb.scb.state,
519                          bta_hf_client_state_str(bta_hf_client_cb.scb.state),
520                          event, bta_hf_client_evt_str(event));
521     }
522 #endif
523 
524     event &= 0x00FF;
525     if (event >= (BTA_HF_CLIENT_MAX_EVT & 0x00FF)) {
526         APPL_TRACE_ERROR("HF Client evt out of range, ignoring...");
527         return;
528     }
529 
530     /* look up the state table for the current state */
531     state_table = bta_hf_client_st_tbl[bta_hf_client_cb.scb.state];
532 
533     /* set next state */
534     bta_hf_client_cb.scb.state = state_table[event][BTA_HF_CLIENT_NEXT_STATE];
535 
536     /* execute action functions */
537     for (i = 0; i < BTA_HF_CLIENT_ACTIONS; i++) {
538         if ((action = state_table[event][i]) != BTA_HF_CLIENT_IGNORE) {
539             (*bta_hf_client_action[action])(p_data);
540         } else {
541             break;
542         }
543     }
544 
545 #if BTA_HF_CLIENT_DEBUG == TRUE
546     if (bta_hf_client_cb.scb.state != in_state) {
547         APPL_TRACE_EVENT("BTA HF Client State Change: [%s] -> [%s] after Event [%s]",
548                          bta_hf_client_state_str(in_state),
549                          bta_hf_client_state_str(bta_hf_client_cb.scb.state),
550                          bta_hf_client_evt_str(in_event));
551     }
552 #endif
553 }
554 
send_post_slc_cmd(void)555 static void send_post_slc_cmd(void)
556 {
557     bta_hf_client_cb.scb.at_cb.current_cmd = BTA_HF_CLIENT_AT_NONE;
558 
559     bta_hf_client_send_at_bia();
560     bta_hf_client_send_at_ccwa(TRUE);
561     bta_hf_client_send_at_cmee(TRUE);
562     bta_hf_client_send_at_cops(FALSE);
563     bta_hf_client_send_at_btrh(TRUE, 0);
564 
565 #if BT_HF_CLIENT_BQB_INCLUDED
566     if (s_bta_hf_client_bqb_clip_flag == TRUE) {
567         bta_hf_client_send_at_clip(TRUE);
568     }
569 #else
570     bta_hf_client_send_at_clip(TRUE);
571 #endif /* BT_HF_CLIENT_BQB_INCLUDED */
572 }
573 
574 /*******************************************************************************
575 **
576 ** Function         bta_hf_client_slc_seq
577 **
578 ** Description      Handles AT commands sequence required for SLC creation
579 **
580 **
581 ** Returns          void
582 **
583 *******************************************************************************/
bta_hf_client_slc_seq(BOOLEAN error)584 void bta_hf_client_slc_seq(BOOLEAN error)
585 {
586     APPL_TRACE_DEBUG("bta_hf_client_slc_seq cmd: %u", bta_hf_client_cb.scb.at_cb.current_cmd);
587 
588     if (error) {
589         /* SLC establishment error, sent close rfcomm event */
590         APPL_TRACE_ERROR("HFPClient: Failed to create SLC due to AT error, disconnecting (%u)",
591                          bta_hf_client_cb.scb.at_cb.current_cmd);
592 
593         bta_hf_client_sm_execute(BTA_HF_CLIENT_API_CLOSE_EVT, NULL);
594         return;
595     }
596 
597     if (bta_hf_client_cb.scb.svc_conn) {
598         return;
599     }
600 
601     switch (bta_hf_client_cb.scb.at_cb.current_cmd) {
602     case BTA_HF_CLIENT_AT_NONE:
603         bta_hf_client_send_at_brsf();
604         break;
605 
606     case BTA_HF_CLIENT_AT_BRSF:
607         if (bta_hf_client_cb.scb.peer_features & BTA_HF_CLIENT_PEER_CODEC) {
608             bta_hf_client_send_at_bac();
609             break;
610         }
611 
612         bta_hf_client_send_at_cind(FALSE);
613         break;
614 
615     case BTA_HF_CLIENT_AT_BAC:
616         bta_hf_client_send_at_cind(FALSE);
617         break;
618 
619     case BTA_HF_CLIENT_AT_CIND:
620         bta_hf_client_send_at_cind(TRUE);
621         break;
622 
623     case BTA_HF_CLIENT_AT_CIND_STATUS:
624         bta_hf_client_send_at_cmer(TRUE);
625         break;
626 
627     case BTA_HF_CLIENT_AT_CMER:
628         if (bta_hf_client_cb.scb.peer_features & BTA_HF_CLIENT_PEER_FEAT_3WAY) {
629             bta_hf_client_send_at_chld('?', 0);
630         } else {
631             bta_hf_client_svc_conn_open(NULL);
632             send_post_slc_cmd();
633         }
634         break;
635 
636     case BTA_HF_CLIENT_AT_CHLD:
637         bta_hf_client_svc_conn_open(NULL);
638         send_post_slc_cmd();
639         break;
640 
641     default:
642         /* If happen there is a bug in SLC creation procedure... */
643         APPL_TRACE_ERROR("HFPClient: Failed to create SLCdue to unexpected AT command, disconnecting (%u)",
644                          bta_hf_client_cb.scb.at_cb.current_cmd);
645 
646         bta_hf_client_sm_execute(BTA_HF_CLIENT_API_CLOSE_EVT, NULL);
647         break;
648     }
649 }
650 
651 #if BTA_HF_CLIENT_DEBUG == TRUE
652 
653 #ifndef CASE_RETURN_STR
654 #define CASE_RETURN_STR(const) case const: return #const;
655 #endif
656 
bta_hf_client_evt_str(UINT16 event)657 static char *bta_hf_client_evt_str(UINT16 event)
658 {
659     switch (event) {
660         CASE_RETURN_STR(BTA_HF_CLIENT_API_REGISTER_EVT)
661         CASE_RETURN_STR(BTA_HF_CLIENT_API_DEREGISTER_EVT)
662         CASE_RETURN_STR(BTA_HF_CLIENT_API_OPEN_EVT)
663         CASE_RETURN_STR(BTA_HF_CLIENT_API_CLOSE_EVT)
664         CASE_RETURN_STR(BTA_HF_CLIENT_API_AUDIO_OPEN_EVT)
665         CASE_RETURN_STR(BTA_HF_CLIENT_API_AUDIO_CLOSE_EVT)
666         CASE_RETURN_STR(BTA_HF_CLIENT_RFC_OPEN_EVT)
667         CASE_RETURN_STR(BTA_HF_CLIENT_RFC_CLOSE_EVT)
668         CASE_RETURN_STR(BTA_HF_CLIENT_RFC_SRV_CLOSE_EVT)
669         CASE_RETURN_STR(BTA_HF_CLIENT_RFC_DATA_EVT)
670         CASE_RETURN_STR(BTA_HF_CLIENT_DISC_ACP_RES_EVT)
671         CASE_RETURN_STR(BTA_HF_CLIENT_DISC_INT_RES_EVT)
672         CASE_RETURN_STR(BTA_HF_CLIENT_DISC_OK_EVT)
673         CASE_RETURN_STR(BTA_HF_CLIENT_DISC_FAIL_EVT)
674         CASE_RETURN_STR(BTA_HF_CLIENT_API_ENABLE_EVT)
675         CASE_RETURN_STR(BTA_HF_CLIENT_API_DISABLE_EVT)
676         CASE_RETURN_STR(BTA_HF_CLIENT_SCO_OPEN_EVT)
677         CASE_RETURN_STR(BTA_HF_CLIENT_SCO_CLOSE_EVT)
678         CASE_RETURN_STR(BTA_HF_CLIENT_SEND_AT_CMD_EVT)
679         CASE_RETURN_STR(BTA_HF_CLIENT_PKT_NUMS_GET_EVT)
680     default:
681         return "Unknown HF Client Event";
682     }
683 }
684 
bta_hf_client_state_str(UINT8 state)685 static char *bta_hf_client_state_str(UINT8 state)
686 {
687     switch (state) {
688         CASE_RETURN_STR(BTA_HF_CLIENT_INIT_ST)
689         CASE_RETURN_STR(BTA_HF_CLIENT_OPENING_ST)
690         CASE_RETURN_STR(BTA_HF_CLIENT_OPEN_ST)
691         CASE_RETURN_STR(BTA_HF_CLIENT_CLOSING_ST)
692     default:
693         return "Unknown HF Client State";
694     }
695 }
696 #endif
697 #endif /* #if (BTA_HF_INCLUDED == TRUE) */
698