• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /******************************************************************************
2  *
3  *  Copyright (C) 2009-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  *  Filename:      btif_hf.c
22  *
23  *  Description:   Handsfree Profile Bluetooth Interface
24  *
25  *
26  ***********************************************************************************/
27 
28 #include <hardware/bluetooth.h>
29 #include <hardware/bt_hf.h>
30 #include <stdlib.h>
31 
32 #define LOG_TAG "BTIF_HF"
33 #include "btif_common.h"
34 #include "btif_util.h"
35 #include "btif_profile_queue.h"
36 
37 #include "bd.h"
38 #include "bta_ag_api.h"
39 
40 /************************************************************************************
41 **  Constants & Macros
42 ************************************************************************************/
43 #ifndef BTIF_HSAG_SERVICE_NAME
44 #define BTIF_HSAG_SERVICE_NAME ("Headset Gateway")
45 #endif
46 
47 #ifndef BTIF_HFAG_SERVICE_NAME
48 #define BTIF_HFAG_SERVICE_NAME ("Handsfree Gateway")
49 #endif
50 
51 #ifndef BTIF_HF_SERVICES
52 #define BTIF_HF_SERVICES    (BTA_HSP_SERVICE_MASK | BTA_HFP_SERVICE_MASK )
53 #endif
54 
55 #ifndef BTIF_HF_SERVICE_NAMES
56 #define BTIF_HF_SERVICE_NAMES {BTIF_HSAG_SERVICE_NAME , BTIF_HFAG_SERVICE_NAME}
57 #endif
58 
59 #ifndef BTIF_HF_SECURITY
60 #define BTIF_HF_SECURITY    (BTA_SEC_AUTHENTICATE | BTA_SEC_ENCRYPT)
61 #endif
62 
63 #if (BTM_WBS_INCLUDED == TRUE )
64 #ifndef BTIF_HF_FEATURES
65 #define BTIF_HF_FEATURES   ( BTA_AG_FEAT_3WAY | \
66                              BTA_AG_FEAT_ECNR   | \
67                              BTA_AG_FEAT_REJECT | \
68                              BTA_AG_FEAT_ECS    | \
69                              BTA_AG_FEAT_EXTERR | \
70                              BTA_AG_FEAT_BTRH   | \
71                              BTA_AG_FEAT_VREC   | \
72                              BTA_AG_FEAT_CODEC |\
73                              BTA_AG_FEAT_UNAT)
74 #endif
75 #else
76 #ifndef BTIF_HF_FEATURES
77 #define BTIF_HF_FEATURES   ( BTA_AG_FEAT_3WAY | \
78                              BTA_AG_FEAT_ECNR   | \
79                              BTA_AG_FEAT_REJECT | \
80                              BTA_AG_FEAT_ECS    | \
81                              BTA_AG_FEAT_EXTERR | \
82                              BTA_AG_FEAT_BTRH   | \
83                              BTA_AG_FEAT_VREC   | \
84                              BTA_AG_FEAT_UNAT)
85 #endif
86 #endif
87 
88 #define BTIF_HF_CALL_END_TIMEOUT       6
89 
90 #define BTIF_HF_INVALID_IDX       -1
91 
92 /* Number of BTIF-HF control blocks */
93 #define BTIF_HF_NUM_CB       2
94 
95 /* Max HF clients supported from App */
96 UINT16 btif_max_hf_clients = -1;
97 
98 /* HF app ids for service registration */
99 typedef enum {
100     BTIF_HF_ID_1 = 0,
101     BTIF_HF_ID_2,
102 #if (BTIF_HF_NUM_CB == 3)
103     BTIF_HF_ID_3
104 #endif
105 } bthf_hf_id_t;
106 
107 UINT16 bthf_hf_id[BTIF_HF_NUM_CB] = {BTIF_HF_ID_1, BTIF_HF_ID_2,
108                                     #if (BTIF_HF_NUM_CB == 3)
109                                         BTIF_HF_ID_3
110                                     #endif
111                                     };
112 
113 /************************************************************************************
114 **  Local type definitions
115 ************************************************************************************/
116 
117 /************************************************************************************
118 **  Static variables
119 ************************************************************************************/
120 static bthf_callbacks_t *bt_hf_callbacks = NULL;
121 static int hf_idx = BTIF_HF_INVALID_IDX;
122 
123 #define CHECK_BTHF_INIT() if (bt_hf_callbacks == NULL)\
124     {\
125         BTIF_TRACE_WARNING("BTHF: %s: BTHF not initialized", __FUNCTION__);\
126         return BT_STATUS_NOT_READY;\
127     }\
128     else\
129     {\
130         BTIF_TRACE_EVENT("BTHF: %s", __FUNCTION__);\
131     }
132 
133 #define CHECK_BTHF_SLC_CONNECTED() if (bt_hf_callbacks == NULL)\
134     {\
135         BTIF_TRACE_WARNING("BTHF: %s: BTHF not initialized", __FUNCTION__);\
136         return BT_STATUS_NOT_READY;\
137     }\
138     else if (btif_hf_cb.state != BTHF_CONNECTION_STATE_SLC_CONNECTED)\
139     {\
140         BTIF_TRACE_WARNING("BTHF: %s: SLC connection not up. state=%s", __FUNCTION__, dump_hf_conn_state(btif_hf_cb.state));\
141         return BT_STATUS_NOT_READY;\
142     }\
143     else\
144     {\
145         BTIF_TRACE_EVENT("BTHF: %s", __FUNCTION__);\
146     }
147 
148 /* BTIF-HF control block to map bdaddr to BTA handle */
149 typedef struct _btif_hf_cb
150 {
151     UINT16                  handle;
152     bt_bdaddr_t             connected_bda;
153     bthf_connection_state_t state;
154     bthf_vr_state_t         vr_state;
155     tBTA_AG_PEER_FEAT       peer_feat;
156     int                     num_active;
157     int                     num_held;
158     struct timespec         call_end_timestamp;
159     struct timespec         connected_timestamp;
160     bthf_call_state_t       call_setup_state;
161 } btif_hf_cb_t;
162 
163 static btif_hf_cb_t btif_hf_cb[BTIF_HF_NUM_CB];
164 
165 
166 /************************************************************************************
167 **  Static functions
168 ************************************************************************************/
169 
170 /************************************************************************************
171 **  Externs
172 ************************************************************************************/
173 /* By default, even though codec negotiation is enabled, we will not use WBS as the default
174 * codec unless this variable is set to TRUE.
175 */
176 #ifndef BTIF_HF_WBS_PREFERRED
177 #define BTIF_HF_WBS_PREFERRED   FALSE
178 #endif
179 
180 BOOLEAN btif_conf_hf_force_wbs = BTIF_HF_WBS_PREFERRED;
181 
182 /************************************************************************************
183 **  Functions
184 ************************************************************************************/
185 
186 /*******************************************************************************
187 **
188 ** Function         is_connected
189 **
190 ** Description      Internal function to check if HF is connected
191 **
192 ** Returns          TRUE if connected
193 **
194 *******************************************************************************/
is_connected(bt_bdaddr_t * bd_addr)195 static BOOLEAN is_connected(bt_bdaddr_t *bd_addr)
196 {
197         int i;
198         for (i = 0; i < btif_max_hf_clients; ++i)
199         {
200             if (((btif_hf_cb[i].state == BTHF_CONNECTION_STATE_CONNECTED) ||
201                  (btif_hf_cb[i].state == BTHF_CONNECTION_STATE_SLC_CONNECTED)) &&
202                  ((bd_addr == NULL) || (bdcmp(bd_addr->address,
203                                      btif_hf_cb[i].connected_bda.address) == 0)))
204                 return TRUE;
205         }
206         return FALSE;
207 }
208 
209 /*******************************************************************************
210 **
211 ** Function         btif_hf_idx_by_bdaddr
212 **
213 ** Description      Internal function to get idx by bdaddr
214 **
215 ** Returns          idx
216 **
217 *******************************************************************************/
btif_hf_idx_by_bdaddr(bt_bdaddr_t * bd_addr)218 static int btif_hf_idx_by_bdaddr(bt_bdaddr_t *bd_addr)
219 {
220         int i;
221         for (i = 0; i < btif_max_hf_clients; ++i)
222         {
223             if ((bdcmp(bd_addr->address,
224                                   btif_hf_cb[i].connected_bda.address) == 0))
225                 return i;
226         }
227         return BTIF_HF_INVALID_IDX;
228 }
229 
230 /*******************************************************************************
231 **
232 ** Function         callstate_to_callsetup
233 **
234 ** Description      Converts HAL call state to BTA call setup indicator value
235 **
236 ** Returns          BTA call indicator value
237 **
238 *******************************************************************************/
callstate_to_callsetup(bthf_call_state_t call_state)239 static UINT8 callstate_to_callsetup(bthf_call_state_t call_state)
240 {
241     UINT8 call_setup = 0;
242     if (call_state == BTHF_CALL_STATE_INCOMING)
243         call_setup = 1;
244     if (call_state == BTHF_CALL_STATE_DIALING)
245         call_setup = 2;
246     if (call_state == BTHF_CALL_STATE_ALERTING)
247         call_setup = 3;
248 
249     return call_setup;
250 }
251 
252 /*******************************************************************************
253 **
254 ** Function         send_at_result
255 **
256 ** Description      Send AT result code (OK/ERROR)
257 **
258 ** Returns          void
259 **
260 *******************************************************************************/
send_at_result(UINT8 ok_flag,UINT16 errcode,int idx)261 static void send_at_result(UINT8 ok_flag, UINT16 errcode, int idx)
262 {
263     tBTA_AG_RES_DATA    ag_res;
264     memset (&ag_res, 0, sizeof (ag_res));
265 
266     ag_res.ok_flag = ok_flag;
267     if (ok_flag == BTA_AG_OK_ERROR)
268     {
269         ag_res.errcode = errcode;
270     }
271 
272     BTA_AgResult (btif_hf_cb[idx].handle, BTA_AG_UNAT_RES, &ag_res);
273 }
274 
275 /*******************************************************************************
276 **
277 ** Function         send_indicator_update
278 **
279 ** Description      Send indicator update (CIEV)
280 **
281 ** Returns          void
282 **
283 *******************************************************************************/
send_indicator_update(UINT16 indicator,UINT16 value)284 static void send_indicator_update (UINT16 indicator, UINT16 value)
285 {
286     tBTA_AG_RES_DATA ag_res;
287 
288     memset(&ag_res, 0, sizeof(tBTA_AG_RES_DATA));
289     ag_res.ind.id = indicator;
290     ag_res.ind.value = value;
291 
292     BTA_AgResult(BTA_AG_HANDLE_ALL, BTA_AG_IND_RES, &ag_res);
293 }
294 
clear_phone_state_multihf(int idx)295 void clear_phone_state_multihf(int idx)
296 {
297     btif_hf_cb[idx].call_setup_state = BTHF_CALL_STATE_IDLE;
298     btif_hf_cb[idx].num_active = btif_hf_cb[idx].num_held = 0;
299 }
300 
301 /*******************************************************************************
302 **
303 ** Function         btif_hf_latest_connected_idx
304 **
305 ** Description      Returns idx for latest connected HF
306 **
307 ** Returns          int
308 **
309 *******************************************************************************/
btif_hf_latest_connected_idx()310 static int btif_hf_latest_connected_idx()
311 {
312       struct timespec         now, conn_time_delta;
313       int latest_conn_idx = BTIF_HF_INVALID_IDX, i;
314 
315       clock_gettime(CLOCK_MONOTONIC, &now);
316       conn_time_delta.tv_sec = now.tv_sec;
317 
318       for (i = 0; i < btif_max_hf_clients; i++)
319       {
320           if (btif_hf_cb[i].state == BTHF_CONNECTION_STATE_SLC_CONNECTED)
321           {
322               if ((now.tv_sec - btif_hf_cb[i].connected_timestamp.tv_sec)
323                                             < conn_time_delta.tv_sec)
324               {
325                   conn_time_delta.tv_sec =
326                        now.tv_sec - btif_hf_cb[i].connected_timestamp.tv_sec;
327                   latest_conn_idx = i;
328               }
329           }
330       }
331       return latest_conn_idx;
332 }
333 
334 /*******************************************************************************
335 **
336 ** Function         btif_hf_check_if_slc_connected
337 **
338 ** Description      Returns BT_STATUS_SUCCESS if SLC is up for any HF
339 **
340 ** Returns          bt_status_t
341 **
342 *******************************************************************************/
btif_hf_check_if_slc_connected()343 static bt_status_t btif_hf_check_if_slc_connected()
344 {
345     if (bt_hf_callbacks == NULL)
346     {
347         BTIF_TRACE_WARNING("BTHF: %s: BTHF not initialized", __FUNCTION__);
348         return BT_STATUS_NOT_READY;
349     }
350     else
351     {
352         int i;
353         for (i = 0; i < btif_max_hf_clients; i++)
354         {
355             if ((btif_hf_cb[i].state == BTHF_CONNECTION_STATE_SLC_CONNECTED))
356             {
357                 BTIF_TRACE_EVENT("BTHF: %s: slc connected for idx = %d",
358                                          __FUNCTION__, i);
359                 return BT_STATUS_SUCCESS;
360             }
361         }
362         BTIF_TRACE_WARNING("BTHF: %s: No SLC connection up", __FUNCTION__);
363         return BT_STATUS_NOT_READY;
364     }
365 }
366 
367 /*****************************************************************************
368 **   Section name (Group of functions)
369 *****************************************************************************/
370 
371 /*****************************************************************************
372 **
373 **   btif hf api functions (no context switch)
374 **
375 *****************************************************************************/
376 
377 
378 /*******************************************************************************
379 **
380 ** Function         btif_hf_upstreams_evt
381 **
382 ** Description      Executes HF UPSTREAMS events in btif context
383 **
384 ** Returns          void
385 **
386 *******************************************************************************/
btif_hf_upstreams_evt(UINT16 event,char * p_param)387 static void btif_hf_upstreams_evt(UINT16 event, char* p_param)
388 {
389     tBTA_AG *p_data = (tBTA_AG *)p_param;
390     bdstr_t bdstr;
391     bt_bdaddr_t addr;
392     int idx = p_data->hdr.handle - 1;
393 
394     BTIF_TRACE_DEBUG("%s: event=%s", __FUNCTION__, dump_hf_event(event));
395 
396     switch (event)
397     {
398         case BTA_AG_ENABLE_EVT:
399         case BTA_AG_DISABLE_EVT:
400             break;
401 
402         case BTA_AG_REGISTER_EVT:
403             btif_hf_cb[idx].handle = p_data->reg.hdr.handle;
404             BTIF_TRACE_DEBUG("%s: BTA_AG_REGISTER_EVT,"
405               "btif_hf_cb.handle = %d", __FUNCTION__, btif_hf_cb[idx].handle);
406             break;
407 
408         case BTA_AG_OPEN_EVT:
409             if (p_data->open.status == BTA_AG_SUCCESS)
410             {
411                 bdcpy(btif_hf_cb[idx].connected_bda.address,
412                                   p_data->open.bd_addr);
413                 btif_hf_cb[idx].state = BTHF_CONNECTION_STATE_CONNECTED;
414                 btif_hf_cb[idx].peer_feat = 0;
415                 clear_phone_state_multihf(idx);
416             }
417             else if (btif_hf_cb[idx].state == BTHF_CONNECTION_STATE_CONNECTING)
418             {
419                 btif_hf_cb[idx].state = BTHF_CONNECTION_STATE_DISCONNECTED;
420             }
421             else
422             {
423                 BTIF_TRACE_WARNING("%s: AG open failed, but another device connected. status=%d state=%d connected device=%s",
424                         __FUNCTION__, p_data->open.status, btif_hf_cb[idx].state,
425                                  bd2str(&btif_hf_cb[idx].connected_bda, &bdstr));
426                 break;
427             }
428 
429             HAL_CBACK(bt_hf_callbacks, connection_state_cb, btif_hf_cb[idx].state,
430                                                         &btif_hf_cb[idx].connected_bda);
431 
432             if (btif_hf_cb[idx].state == BTHF_CONNECTION_STATE_DISCONNECTED)
433                 bdsetany(btif_hf_cb[idx].connected_bda.address);
434 
435             if (p_data->open.status != BTA_AG_SUCCESS)
436                 btif_queue_advance();
437             break;
438 
439         case BTA_AG_CLOSE_EVT:
440             btif_hf_cb[idx].connected_timestamp.tv_sec = 0;
441             btif_hf_cb[idx].state = BTHF_CONNECTION_STATE_DISCONNECTED;
442             BTIF_TRACE_DEBUG("%s: BTA_AG_CLOSE_EVT,"
443                  "idx = %d, btif_hf_cb.handle = %d", __FUNCTION__, idx,
444                           btif_hf_cb[idx].handle);
445             HAL_CBACK(bt_hf_callbacks, connection_state_cb, btif_hf_cb[idx].state,
446                                                         &btif_hf_cb[idx].connected_bda);
447             bdsetany(btif_hf_cb[idx].connected_bda.address);
448             btif_hf_cb[idx].peer_feat = 0;
449             clear_phone_state_multihf(idx);
450             hf_idx = btif_hf_latest_connected_idx();
451             /* If AG_OPEN was received but SLC was not setup in a specified time (10 seconds),
452             ** then AG_CLOSE may be received. We need to advance the queue here
453             */
454             btif_queue_advance();
455             break;
456 
457         case BTA_AG_CONN_EVT:
458             clock_gettime(CLOCK_MONOTONIC,
459                             &btif_hf_cb[idx].connected_timestamp);
460             BTIF_TRACE_DEBUG("%s: BTA_AG_CONN_EVT, idx = %d ",
461                                                 __FUNCTION__, idx);
462             btif_hf_cb[idx].peer_feat = p_data->conn.peer_feat;
463             btif_hf_cb[idx].state = BTHF_CONNECTION_STATE_SLC_CONNECTED;
464             hf_idx = btif_hf_latest_connected_idx();
465 
466             HAL_CBACK(bt_hf_callbacks, connection_state_cb, btif_hf_cb[idx].state,
467                              &btif_hf_cb[idx].connected_bda);
468             btif_queue_advance();
469             break;
470 
471         case BTA_AG_AUDIO_OPEN_EVT:
472             hf_idx = idx;
473             HAL_CBACK(bt_hf_callbacks, audio_state_cb, BTHF_AUDIO_STATE_CONNECTED,
474                                                         &btif_hf_cb[idx].connected_bda);
475             break;
476 
477         case BTA_AG_AUDIO_CLOSE_EVT:
478             HAL_CBACK(bt_hf_callbacks, audio_state_cb, BTHF_AUDIO_STATE_DISCONNECTED,
479                                                            &btif_hf_cb[idx].connected_bda);
480             break;
481 
482         /* BTA auto-responds, silently discard */
483         case BTA_AG_SPK_EVT:
484         case BTA_AG_MIC_EVT:
485             HAL_CBACK(bt_hf_callbacks, volume_cmd_cb,
486                 (event == BTA_AG_SPK_EVT) ? BTHF_VOLUME_TYPE_SPK :
487                       BTHF_VOLUME_TYPE_MIC, p_data->val.num,
488                               &btif_hf_cb[idx].connected_bda);
489             break;
490 
491         case BTA_AG_AT_A_EVT:
492             if ((btif_hf_cb[0].num_held + btif_hf_cb[0].num_active) == 0)
493                 hf_idx = idx;
494             else
495                 BTIF_TRACE_DEBUG("Donot set hf_idx for ATA since already in a call");
496 
497             HAL_CBACK(bt_hf_callbacks, answer_call_cmd_cb,
498                               &btif_hf_cb[idx].connected_bda);
499             break;
500 
501         /* Java needs to send OK/ERROR for these commands */
502         case BTA_AG_AT_BLDN_EVT:
503         case BTA_AG_AT_D_EVT:
504             if ((btif_hf_cb[0].num_held + btif_hf_cb[0].num_active) == 0)
505                 hf_idx = idx;
506             else
507                 BTIF_TRACE_DEBUG("Donot set hf_idx for BLDN/D since already in a call");
508 
509             HAL_CBACK(bt_hf_callbacks, dial_call_cmd_cb,
510                 (event == BTA_AG_AT_D_EVT) ? p_data->val.str : NULL,
511                               &btif_hf_cb[idx].connected_bda);
512             break;
513 
514         case BTA_AG_AT_CHUP_EVT:
515             HAL_CBACK(bt_hf_callbacks, hangup_call_cmd_cb,
516                               &btif_hf_cb[idx].connected_bda);
517             break;
518 
519         case BTA_AG_AT_CIND_EVT:
520             HAL_CBACK(bt_hf_callbacks, cind_cmd_cb,
521                               &btif_hf_cb[idx].connected_bda);
522             break;
523 
524         case BTA_AG_AT_VTS_EVT:
525             HAL_CBACK(bt_hf_callbacks, dtmf_cmd_cb, p_data->val.str[0],
526                               &btif_hf_cb[idx].connected_bda);
527             break;
528 
529         case BTA_AG_AT_BVRA_EVT:
530             HAL_CBACK(bt_hf_callbacks, vr_cmd_cb,
531                 (p_data->val.num == 1) ? BTHF_VR_STATE_STARTED :
532                       BTHF_VR_STATE_STOPPED, &btif_hf_cb[idx].connected_bda);
533             break;
534 
535         case BTA_AG_AT_NREC_EVT:
536             HAL_CBACK(bt_hf_callbacks, nrec_cmd_cb,
537                 (p_data->val.num == 1) ? BTHF_NREC_START : BTHF_NREC_STOP,
538                                              &btif_hf_cb[idx].connected_bda);
539             break;
540 
541         /* TODO: Add a callback for CBC */
542         case BTA_AG_AT_CBC_EVT:
543             break;
544 
545         case BTA_AG_AT_CKPD_EVT:
546             HAL_CBACK(bt_hf_callbacks, key_pressed_cmd_cb,
547                               &btif_hf_cb[idx].connected_bda);
548             break;
549 
550 #if (BTM_WBS_INCLUDED == TRUE )
551         case BTA_AG_WBS_EVT:
552             BTIF_TRACE_DEBUG("BTA_AG_WBS_EVT Set codec status %d codec %d 1=CVSD 2=MSBC", \
553                                p_data->val.hdr.status, p_data->val.num);
554             if(p_data->val.num == BTA_AG_CODEC_CVSD)
555              { HAL_CBACK(bt_hf_callbacks, wbs_cb, BTHF_WBS_NO, &btif_hf_cb[idx].connected_bda);}
556             else if(p_data->val.num == BTA_AG_CODEC_MSBC)
557              {HAL_CBACK(bt_hf_callbacks, wbs_cb, BTHF_WBS_YES, &btif_hf_cb[idx].connected_bda);}
558             else
559              {HAL_CBACK(bt_hf_callbacks, wbs_cb, BTHF_WBS_NONE, &btif_hf_cb[idx].connected_bda);}
560             break;
561 #endif
562         /* Java needs to send OK/ERROR for these commands */
563         case BTA_AG_AT_CHLD_EVT:
564             HAL_CBACK(bt_hf_callbacks, chld_cmd_cb, atoi(p_data->val.str),
565                               &btif_hf_cb[idx].connected_bda);
566             break;
567 
568         case BTA_AG_AT_CLCC_EVT:
569             HAL_CBACK(bt_hf_callbacks, clcc_cmd_cb,
570                               &btif_hf_cb[idx].connected_bda);
571             break;
572 
573         case BTA_AG_AT_COPS_EVT:
574             HAL_CBACK(bt_hf_callbacks, cops_cmd_cb,
575                               &btif_hf_cb[idx].connected_bda);
576             break;
577 
578         case BTA_AG_AT_UNAT_EVT:
579             HAL_CBACK(bt_hf_callbacks, unknown_at_cmd_cb, p_data->val.str,
580                               &btif_hf_cb[idx].connected_bda);
581             break;
582 
583         case BTA_AG_AT_CNUM_EVT:
584             HAL_CBACK(bt_hf_callbacks, cnum_cmd_cb,
585                               &btif_hf_cb[idx].connected_bda);
586             break;
587 
588         /* TODO: Some of these commands may need to be sent to app. For now respond with error */
589         case BTA_AG_AT_BINP_EVT:
590         case BTA_AG_AT_BTRH_EVT:
591             send_at_result(BTA_AG_OK_ERROR, BTA_AG_ERR_OP_NOT_SUPPORTED, idx);
592             break;
593         case BTA_AG_AT_BAC_EVT:
594             BTIF_TRACE_DEBUG("AG Bitmap of peer-codecs %d", p_data->val.num);
595 #if (BTM_WBS_INCLUDED == TRUE )
596             /* If the peer supports mSBC and the BTIF prefferred codec is also mSBC, then
597             we should set the BTA AG Codec to mSBC. This would trigger a +BCS to mSBC at the time
598             of SCO connection establishment */
599             if ((btif_conf_hf_force_wbs == TRUE) && (p_data->val.num & BTA_AG_CODEC_MSBC))
600             {
601                   BTIF_TRACE_EVENT("%s btif_hf override-Preferred Codec to MSBC", __FUNCTION__);
602                   BTA_AgSetCodec(btif_hf_cb[idx].handle,BTA_AG_CODEC_MSBC);
603             }
604             else
605             {
606                   BTIF_TRACE_EVENT("%s btif_hf override-Preferred Codec to CVSD", __FUNCTION__);
607                   BTA_AgSetCodec(btif_hf_cb[idx].handle,BTA_AG_CODEC_CVSD);
608             }
609 #endif
610             break;
611         case BTA_AG_AT_BCS_EVT:
612             BTIF_TRACE_DEBUG("AG final seleded codec is %d 1=CVSD 2=MSBC", p_data->val.num);
613             /*  no BTHF_WBS_NONE case, becuase HF1.6 supported device can send BCS */
614             HAL_CBACK(bt_hf_callbacks, wbs_cb,(p_data->val.num == BTA_AG_CODEC_MSBC) ? \
615                         BTHF_WBS_YES : BTHF_WBS_NO, &btif_hf_cb[idx].connected_bda);
616             break;
617 
618         default:
619             BTIF_TRACE_WARNING("%s: Unhandled event: %d", __FUNCTION__, event);
620             break;
621     }
622 }
623 
624 /*******************************************************************************
625 **
626 ** Function         bte_hf_evt
627 **
628 ** Description      Switches context from BTE to BTIF for all HF events
629 **
630 ** Returns          void
631 **
632 *******************************************************************************/
633 
bte_hf_evt(tBTA_AG_EVT event,tBTA_AG * p_data)634 static void bte_hf_evt(tBTA_AG_EVT event, tBTA_AG *p_data)
635 {
636     bt_status_t status;
637     int param_len = 0;
638 
639     /* TODO: BTA sends the union members and not tBTA_AG. If using param_len=sizeof(tBTA_AG), we get a crash on memcpy */
640     if (BTA_AG_REGISTER_EVT == event)
641         param_len = sizeof(tBTA_AG_REGISTER);
642     else if (BTA_AG_OPEN_EVT == event)
643         param_len = sizeof(tBTA_AG_OPEN);
644     else if (BTA_AG_CONN_EVT == event)
645         param_len = sizeof(tBTA_AG_CONN);
646     else if ( (BTA_AG_CLOSE_EVT == event) || (BTA_AG_AUDIO_OPEN_EVT == event) || (BTA_AG_AUDIO_CLOSE_EVT == event))
647         param_len = sizeof(tBTA_AG_HDR);
648     else if (p_data)
649         param_len = sizeof(tBTA_AG_VAL);
650 
651     /* switch context to btif task context (copy full union size for convenience) */
652     status = btif_transfer_context(btif_hf_upstreams_evt, (uint16_t)event, (void*)p_data, param_len, NULL);
653 
654     /* catch any failed context transfers */
655     ASSERTC(status == BT_STATUS_SUCCESS, "context transfer failed", status);
656 }
657 
658 
659 /*******************************************************************************
660 **
661 ** Function         btif_in_hf_generic_evt
662 **
663 ** Description     Processes generic events to be sent to JNI that are not triggered from the BTA.
664 **                      Always runs in BTIF context
665 **
666 ** Returns          void
667 **
668 *******************************************************************************/
btif_in_hf_generic_evt(UINT16 event,char * p_param)669 static void btif_in_hf_generic_evt(UINT16 event, char *p_param)
670 {
671     int idx = btif_hf_idx_by_bdaddr((bt_bdaddr_t *)p_param);
672 
673     BTIF_TRACE_EVENT("%s: event=%d", __FUNCTION__, event);
674     switch (event) {
675         case BTIF_HFP_CB_AUDIO_CONNECTING:
676         {
677             HAL_CBACK(bt_hf_callbacks, audio_state_cb, BTHF_AUDIO_STATE_CONNECTING,
678                       &btif_hf_cb[idx].connected_bda);
679         } break;
680         default:
681         {
682             BTIF_TRACE_WARNING("%s : Unknown event 0x%x", __FUNCTION__, event);
683         }
684         break;
685     }
686 }
687 
688 
689 /*******************************************************************************
690 **
691 ** Function         btif_hf_init
692 **
693 ** Description     initializes the hf interface
694 **
695 ** Returns         bt_status_t
696 **
697 *******************************************************************************/
init(bthf_callbacks_t * callbacks,int max_hf_clients)698 static bt_status_t init( bthf_callbacks_t* callbacks, int max_hf_clients)
699 {
700     BTIF_TRACE_EVENT("%s", __FUNCTION__);
701     int i;
702 
703     bt_hf_callbacks = callbacks;
704 
705     /* Invoke the enable service API to the core to set the appropriate service_id
706      * Internally, the HSP_SERVICE_ID shall also be enabled if HFP is enabled (phone)
707      * othwerwise only HSP is enabled (tablet)
708     */
709 #if (defined(BTIF_HF_SERVICES) && (BTIF_HF_SERVICES & BTA_HFP_SERVICE_MASK))
710     btif_enable_service(BTA_HFP_SERVICE_ID);
711 #else
712     btif_enable_service(BTA_HSP_SERVICE_ID);
713 #endif
714 
715     memset(&btif_hf_cb, 0, sizeof(btif_hf_cb));
716     btif_max_hf_clients = max_hf_clients;
717     BTIF_TRACE_DEBUG("btif_max_hf_clients = %d", btif_max_hf_clients);
718     for (i = 0; i < btif_max_hf_clients; i++)
719     {
720         clear_phone_state_multihf(i);
721     }
722 
723     return BT_STATUS_SUCCESS;
724 }
725 
726 /*******************************************************************************
727 **
728 ** Function         connect
729 **
730 ** Description     connect to headset
731 **
732 ** Returns         bt_status_t
733 **
734 *******************************************************************************/
connect_int(bt_bdaddr_t * bd_addr,uint16_t uuid)735 static bt_status_t connect_int(bt_bdaddr_t *bd_addr, uint16_t uuid)
736 {
737     CHECK_BTHF_INIT();
738     int i;
739     for (i = 0; i < btif_max_hf_clients;)
740     {
741        if (((btif_hf_cb[i].state == BTHF_CONNECTION_STATE_CONNECTED) ||
742               (btif_hf_cb[i].state == BTHF_CONNECTION_STATE_SLC_CONNECTED)))
743            i++;
744        else
745            break;
746     }
747 
748     if (i == btif_max_hf_clients)
749         return BT_STATUS_BUSY;
750 
751     if (!is_connected(bd_addr))
752     {
753         btif_hf_cb[i].state = BTHF_CONNECTION_STATE_CONNECTING;
754         bdcpy(btif_hf_cb[i].connected_bda.address, bd_addr->address);
755 
756         BTA_AgOpen(btif_hf_cb[i].handle, btif_hf_cb[i].connected_bda.address,
757                    BTIF_HF_SECURITY, BTIF_HF_SERVICES);
758         return BT_STATUS_SUCCESS;
759     }
760 
761     return BT_STATUS_BUSY;
762 }
763 
connect(bt_bdaddr_t * bd_addr)764 static bt_status_t connect( bt_bdaddr_t *bd_addr )
765 {
766     CHECK_BTHF_INIT();
767     return btif_queue_connect(UUID_SERVCLASS_AG_HANDSFREE, bd_addr, connect_int);
768 }
769 
770 /*******************************************************************************
771 **
772 ** Function         disconnect
773 **
774 ** Description      disconnect from headset
775 **
776 ** Returns         bt_status_t
777 **
778 *******************************************************************************/
disconnect(bt_bdaddr_t * bd_addr)779 static bt_status_t disconnect( bt_bdaddr_t *bd_addr )
780 {
781     CHECK_BTHF_INIT();
782 
783     int idx = btif_hf_idx_by_bdaddr(bd_addr);
784 
785     if (is_connected(bd_addr) && (idx != BTIF_HF_INVALID_IDX))
786     {
787         BTA_AgClose(btif_hf_cb[idx].handle);
788         return BT_STATUS_SUCCESS;
789     }
790 
791     return BT_STATUS_FAIL;
792 }
793 
794 /*******************************************************************************
795 **
796 ** Function         connect_audio
797 **
798 ** Description     create an audio connection
799 **
800 ** Returns         bt_status_t
801 **
802 *******************************************************************************/
connect_audio(bt_bdaddr_t * bd_addr)803 static bt_status_t connect_audio( bt_bdaddr_t *bd_addr )
804 {
805     CHECK_BTHF_INIT();
806 
807     int idx = btif_hf_idx_by_bdaddr(bd_addr);
808 
809     if (is_connected(bd_addr) && (idx != BTIF_HF_INVALID_IDX))
810     {
811         BTA_AgAudioOpen(btif_hf_cb[idx].handle);
812 
813         /* Inform the application that the audio connection has been initiated successfully */
814         btif_transfer_context(btif_in_hf_generic_evt, BTIF_HFP_CB_AUDIO_CONNECTING,
815                               (char *)bd_addr, sizeof(bt_bdaddr_t), NULL);
816         return BT_STATUS_SUCCESS;
817     }
818 
819     return BT_STATUS_FAIL;
820 }
821 
822 /*******************************************************************************
823 **
824 ** Function         disconnect_audio
825 **
826 ** Description      close the audio connection
827 **
828 ** Returns         bt_status_t
829 **
830 *******************************************************************************/
disconnect_audio(bt_bdaddr_t * bd_addr)831 static bt_status_t disconnect_audio( bt_bdaddr_t *bd_addr )
832 {
833     CHECK_BTHF_INIT();
834 
835     int idx = btif_hf_idx_by_bdaddr(bd_addr);
836 
837     if (is_connected(bd_addr) && (idx != BTIF_HF_INVALID_IDX))
838     {
839         BTA_AgAudioClose(btif_hf_cb[idx].handle);
840         return BT_STATUS_SUCCESS;
841     }
842 
843     return BT_STATUS_FAIL;
844 }
845 
846 /*******************************************************************************
847 **
848 ** Function         start_voice_recognition
849 **
850 ** Description      start voice recognition
851 **
852 ** Returns          bt_status_t
853 **
854 *******************************************************************************/
start_voice_recognition(bt_bdaddr_t * bd_addr)855 static bt_status_t start_voice_recognition(bt_bdaddr_t *bd_addr)
856 {
857     CHECK_BTHF_INIT();
858 
859     int idx = btif_hf_idx_by_bdaddr(bd_addr);
860 
861     if (is_connected(bd_addr) && (idx != BTIF_HF_INVALID_IDX))
862     {
863         if (btif_hf_cb[idx].peer_feat & BTA_AG_PEER_FEAT_VREC)
864         {
865             tBTA_AG_RES_DATA ag_res;
866             memset(&ag_res, 0, sizeof(ag_res));
867             ag_res.state = 1;
868             BTA_AgResult (btif_hf_cb[idx].handle, BTA_AG_BVRA_RES, &ag_res);
869 
870             return BT_STATUS_SUCCESS;
871         }
872         else
873         {
874             return BT_STATUS_UNSUPPORTED;
875         }
876     }
877 
878     return BT_STATUS_NOT_READY;
879 }
880 
881 /*******************************************************************************
882 **
883 ** Function         stop_voice_recognition
884 **
885 ** Description      stop voice recognition
886 **
887 ** Returns          bt_status_t
888 **
889 *******************************************************************************/
stop_voice_recognition(bt_bdaddr_t * bd_addr)890 static bt_status_t stop_voice_recognition(bt_bdaddr_t *bd_addr)
891 {
892     CHECK_BTHF_INIT();
893 
894     int idx = btif_hf_idx_by_bdaddr(bd_addr);
895 
896     if (is_connected(bd_addr) && (idx != BTIF_HF_INVALID_IDX))
897     {
898         if (btif_hf_cb[idx].peer_feat & BTA_AG_PEER_FEAT_VREC)
899         {
900             tBTA_AG_RES_DATA ag_res;
901             memset(&ag_res, 0, sizeof(ag_res));
902             ag_res.state = 0;
903             BTA_AgResult (btif_hf_cb[idx].handle, BTA_AG_BVRA_RES, &ag_res);
904 
905             return BT_STATUS_SUCCESS;
906         }
907         else
908         {
909             return BT_STATUS_UNSUPPORTED;
910         }
911     }
912 
913     return BT_STATUS_NOT_READY;
914 }
915 
916 /*******************************************************************************
917 **
918 ** Function         volume_control
919 **
920 ** Description      volume control
921 **
922 ** Returns          bt_status_t
923 **
924 *******************************************************************************/
volume_control(bthf_volume_type_t type,int volume,bt_bdaddr_t * bd_addr)925 static bt_status_t volume_control(bthf_volume_type_t type, int volume,
926                                                        bt_bdaddr_t *bd_addr)
927 {
928     CHECK_BTHF_INIT();
929 
930     int idx = btif_hf_idx_by_bdaddr(bd_addr);
931 
932     tBTA_AG_RES_DATA ag_res;
933     memset(&ag_res, 0, sizeof(tBTA_AG_RES_DATA));
934     if (is_connected(bd_addr) && (idx != BTIF_HF_INVALID_IDX))
935     {
936         ag_res.num = volume;
937         BTA_AgResult(btif_hf_cb[idx].handle,
938                      (type == BTHF_VOLUME_TYPE_SPK) ? BTA_AG_SPK_RES : BTA_AG_MIC_RES,
939                      &ag_res);
940         return BT_STATUS_SUCCESS;
941     }
942 
943     return BT_STATUS_FAIL;
944 }
945 
946 /*******************************************************************************
947 **
948 ** Function         device_status_notification
949 **
950 ** Description      Combined device status change notification
951 **
952 ** Returns          bt_status_t
953 **
954 *******************************************************************************/
device_status_notification(bthf_network_state_t ntk_state,bthf_service_type_t svc_type,int signal,int batt_chg)955 static bt_status_t device_status_notification(bthf_network_state_t ntk_state,
956                           bthf_service_type_t svc_type, int signal, int batt_chg)
957 {
958     CHECK_BTHF_INIT();
959 
960     if (is_connected(NULL))
961     {
962         /* send all indicators to BTA.
963         ** BTA will make sure no duplicates are sent out
964         */
965         send_indicator_update(BTA_AG_IND_SERVICE,
966                               (ntk_state == BTHF_NETWORK_STATE_AVAILABLE) ? 1 : 0);
967         send_indicator_update(BTA_AG_IND_ROAM,
968                              (svc_type == BTHF_SERVICE_TYPE_HOME) ? 0 : 1);
969         send_indicator_update(BTA_AG_IND_SIGNAL, signal);
970         send_indicator_update(BTA_AG_IND_BATTCHG, batt_chg);
971         return BT_STATUS_SUCCESS;
972     }
973 
974     return BT_STATUS_SUCCESS;
975 }
976 
977 /*******************************************************************************
978 **
979 ** Function         cops_response
980 **
981 ** Description      Response for COPS command
982 **
983 ** Returns          bt_status_t
984 **
985 *******************************************************************************/
cops_response(const char * cops,bt_bdaddr_t * bd_addr)986 static bt_status_t cops_response(const char *cops, bt_bdaddr_t *bd_addr)
987 {
988     CHECK_BTHF_INIT();
989 
990     int idx = btif_hf_idx_by_bdaddr(bd_addr);
991 
992     if (is_connected(bd_addr) && (idx != BTIF_HF_INVALID_IDX))
993     {
994         tBTA_AG_RES_DATA    ag_res;
995 
996         /* Format the response */
997         sprintf (ag_res.str, "0,0,\"%s\"", cops);
998         ag_res.ok_flag = BTA_AG_OK_DONE;
999 
1000         BTA_AgResult (btif_hf_cb[idx].handle, BTA_AG_COPS_RES, &ag_res);
1001         return BT_STATUS_SUCCESS;
1002     }
1003     return BT_STATUS_FAIL;
1004 }
1005 
1006 /*******************************************************************************
1007 **
1008 ** Function         cind_response
1009 **
1010 ** Description      Response for CIND command
1011 **
1012 ** Returns          bt_status_t
1013 **
1014 *******************************************************************************/
cind_response(int svc,int num_active,int num_held,bthf_call_state_t call_setup_state,int signal,int roam,int batt_chg,bt_bdaddr_t * bd_addr)1015 static bt_status_t cind_response(int svc, int num_active, int num_held,
1016                                      bthf_call_state_t call_setup_state,
1017                                      int signal, int roam, int batt_chg,
1018                                                     bt_bdaddr_t *bd_addr)
1019 {
1020     CHECK_BTHF_INIT();
1021 
1022     int idx = btif_hf_idx_by_bdaddr(bd_addr);
1023 
1024     if (is_connected(bd_addr) && (idx != BTIF_HF_INVALID_IDX))
1025     {
1026         tBTA_AG_RES_DATA    ag_res;
1027 
1028         memset (&ag_res, 0, sizeof (ag_res));
1029         /* per the errata 2043, call=1 implies atleast one call is in progress (active/held)
1030         ** https://www.bluetooth.org/errata/errata_view.cfm?errata_id=2043
1031         **/
1032         sprintf (ag_res.str, "%d,%d,%d,%d,%d,%d,%d",
1033                 (num_active + num_held) ? 1 : 0,                       /* Call state */
1034                 callstate_to_callsetup(call_setup_state),              /* Callsetup state */
1035                 svc,                                                   /* network service */
1036                 signal,                                                /* Signal strength */
1037                 roam,                                                  /* Roaming indicator */
1038                 batt_chg,                                              /* Battery level */
1039                 ((num_held == 0) ? 0 : ((num_active == 0) ? 2 : 1))); /* Call held */
1040 
1041         BTA_AgResult (btif_hf_cb[idx].handle, BTA_AG_CIND_RES, &ag_res);
1042 
1043         return BT_STATUS_SUCCESS;
1044     }
1045 
1046     return BT_STATUS_FAIL;
1047 }
1048 
1049 /*******************************************************************************
1050 **
1051 ** Function         formatted_at_response
1052 **
1053 ** Description      Pre-formatted AT response, typically in response to unknown AT cmd
1054 **
1055 ** Returns          bt_status_t
1056 **
1057 *******************************************************************************/
formatted_at_response(const char * rsp,bt_bdaddr_t * bd_addr)1058 static bt_status_t formatted_at_response(const char *rsp, bt_bdaddr_t *bd_addr)
1059 {
1060     CHECK_BTHF_INIT();
1061     tBTA_AG_RES_DATA    ag_res;
1062     int idx = btif_hf_idx_by_bdaddr(bd_addr);
1063 
1064     if (is_connected(bd_addr) && (idx != BTIF_HF_INVALID_IDX))
1065     {
1066         /* Format the response and send */
1067         memset (&ag_res, 0, sizeof (ag_res));
1068         strncpy(ag_res.str, rsp, BTA_AG_AT_MAX_LEN);
1069         BTA_AgResult (btif_hf_cb[idx].handle, BTA_AG_UNAT_RES, &ag_res);
1070 
1071         return BT_STATUS_SUCCESS;
1072     }
1073 
1074     return BT_STATUS_FAIL;
1075 }
1076 
1077 /*******************************************************************************
1078 **
1079 ** Function         at_response
1080 **
1081 ** Description      ok/error response
1082 **
1083 ** Returns          bt_status_t
1084 **
1085 *******************************************************************************/
at_response(bthf_at_response_t response_code,int error_code,bt_bdaddr_t * bd_addr)1086 static bt_status_t at_response(bthf_at_response_t response_code,
1087                                     int error_code, bt_bdaddr_t *bd_addr)
1088 {
1089     CHECK_BTHF_INIT();
1090 
1091     int idx = btif_hf_idx_by_bdaddr(bd_addr);
1092 
1093     if (is_connected(bd_addr) && (idx != BTIF_HF_INVALID_IDX))
1094     {
1095         send_at_result((response_code == BTHF_AT_RESPONSE_OK) ? BTA_AG_OK_DONE
1096                         : BTA_AG_OK_ERROR, error_code, idx);
1097         return BT_STATUS_SUCCESS;
1098     }
1099 
1100 
1101     return BT_STATUS_FAIL;
1102 }
1103 
1104 /*******************************************************************************
1105 **
1106 ** Function         clcc_response
1107 **
1108 ** Description      response for CLCC command
1109 **                  Can be iteratively called for each call index. Call index
1110 **                  of 0 will be treated as NULL termination (Completes response)
1111 **
1112 ** Returns          bt_status_t
1113 **
1114 *******************************************************************************/
clcc_response(int index,bthf_call_direction_t dir,bthf_call_state_t state,bthf_call_mode_t mode,bthf_call_mpty_type_t mpty,const char * number,bthf_call_addrtype_t type,bt_bdaddr_t * bd_addr)1115 static bt_status_t clcc_response(int index, bthf_call_direction_t dir,
1116                                bthf_call_state_t state, bthf_call_mode_t mode,
1117                                bthf_call_mpty_type_t mpty, const char *number,
1118                                bthf_call_addrtype_t type, bt_bdaddr_t *bd_addr)
1119 {
1120     CHECK_BTHF_INIT();
1121 
1122     int idx = btif_hf_idx_by_bdaddr(bd_addr);
1123 
1124     if (is_connected(bd_addr) && (idx != BTIF_HF_INVALID_IDX))
1125     {
1126         tBTA_AG_RES_DATA    ag_res;
1127         int                 xx;
1128 
1129         memset (&ag_res, 0, sizeof (ag_res));
1130 
1131         /* Format the response */
1132         if (index == 0)
1133         {
1134             ag_res.ok_flag = BTA_AG_OK_DONE;
1135         }
1136         else
1137         {
1138             BTIF_TRACE_EVENT("clcc_response: [%d] dir %d state %d mode %d number = %s type = %d",
1139                           index, dir, state, mode, number, type);
1140             xx = sprintf (ag_res.str, "%d,%d,%d,%d,%d",
1141                          index, dir, state, mode, mpty);
1142 
1143             if (number)
1144             {
1145                 if ((type == BTHF_CALL_ADDRTYPE_INTERNATIONAL) && (*number != '+'))
1146                     sprintf (&ag_res.str[xx], ",\"+%s\",%d", number, type);
1147                 else
1148                     sprintf (&ag_res.str[xx], ",\"%s\",%d", number, type);
1149             }
1150         }
1151         BTA_AgResult (btif_hf_cb[idx].handle, BTA_AG_CLCC_RES, &ag_res);
1152 
1153         return BT_STATUS_SUCCESS;
1154     }
1155 
1156     return BT_STATUS_FAIL;
1157 }
1158 
1159 /*******************************************************************************
1160 **
1161 ** Function         phone_state_change
1162 **
1163 ** Description      notify of a call state change
1164 **                  number & type: valid only for incoming & waiting call
1165 **
1166 ** Returns          bt_status_t
1167 **
1168 *******************************************************************************/
1169 
phone_state_change(int num_active,int num_held,bthf_call_state_t call_setup_state,const char * number,bthf_call_addrtype_t type)1170 static bt_status_t phone_state_change(int num_active, int num_held, bthf_call_state_t call_setup_state,
1171                                             const char *number, bthf_call_addrtype_t type)
1172 {
1173     tBTA_AG_RES res = 0xff;
1174     tBTA_AG_RES_DATA ag_res;
1175     bt_status_t status = BT_STATUS_SUCCESS;
1176     BOOLEAN activeCallUpdated = FALSE;
1177     int idx, i;
1178 
1179     /* hf_idx is index of connected HS that sent ATA/BLDN,
1180             otherwise index of latest connected HS */
1181     if (hf_idx != BTIF_HF_INVALID_IDX)
1182         idx = hf_idx;
1183     else
1184         idx = btif_hf_latest_connected_idx();
1185 
1186     BTIF_TRACE_DEBUG("phone_state_change: idx = %d", idx);
1187 
1188     /* Check if SLC is connected */
1189     if (btif_hf_check_if_slc_connected() != BT_STATUS_SUCCESS)
1190         return BT_STATUS_NOT_READY;
1191 
1192     BTIF_TRACE_DEBUG("phone_state_change: num_active=%d [prev: %d]  num_held=%d[prev: %d]"
1193                       " call_setup=%s [prev: %s]", num_active, btif_hf_cb[idx].num_active,
1194                        num_held, btif_hf_cb[idx].num_held, dump_hf_call_state(call_setup_state),
1195                        dump_hf_call_state(btif_hf_cb[idx].call_setup_state));
1196 
1197     /* if all indicators are 0, send end call and return */
1198     if (num_active == 0 && num_held == 0 && call_setup_state == BTHF_CALL_STATE_IDLE)
1199     {
1200         BTIF_TRACE_DEBUG("%s: Phone on hook", __FUNCTION__);
1201 
1202         /* record call termination timestamp  if  there was an active/held call  or
1203                    callsetup state > BTHF_CALL_STATE_IDLE */
1204         if ((btif_hf_cb[idx].call_setup_state != BTHF_CALL_STATE_IDLE ) ||
1205                  (btif_hf_cb[idx].num_active) ||(btif_hf_cb[idx].num_held))
1206         {
1207             BTIF_TRACE_DEBUG("%s: Record call termination timestamp", __FUNCTION__);
1208             clock_gettime(CLOCK_MONOTONIC, &btif_hf_cb[0].call_end_timestamp);
1209         }
1210         BTA_AgResult (BTA_AG_HANDLE_ALL, BTA_AG_END_CALL_RES, NULL);
1211         hf_idx = BTIF_HF_INVALID_IDX;
1212 
1213         /* if held call was present, reset that as well */
1214         if (btif_hf_cb[idx].num_held)
1215             send_indicator_update(BTA_AG_IND_CALLHELD, 0);
1216 
1217         goto update_call_states;
1218     }
1219 
1220     /* active state can change when:
1221     ** 1. an outgoing/incoming call was answered
1222     ** 2. an held was resumed
1223     ** 3. without callsetup notifications, call became active
1224     ** (3) can happen if call is active and a headset connects to us
1225     **
1226     ** In the case of (3), we will have to notify the stack of an active
1227     ** call, instead of sending an indicator update. This will also
1228     ** force the SCO to be setup. Handle this special case here prior to
1229     ** call setup handling
1230     */
1231     if ( (num_active == 1) && (btif_hf_cb[idx].num_active == 0) && (btif_hf_cb[idx].num_held == 0)
1232          && (btif_hf_cb[idx].call_setup_state == BTHF_CALL_STATE_IDLE) )
1233     {
1234         BTIF_TRACE_DEBUG("%s: Active call notification received without call setup update",
1235                           __FUNCTION__);
1236 
1237         memset(&ag_res, 0, sizeof(tBTA_AG_RES_DATA));
1238         ag_res.audio_handle = btif_hf_cb[idx].handle;
1239         res = BTA_AG_OUT_CALL_CONN_RES;
1240         BTA_AgResult(BTA_AG_HANDLE_ALL, res, &ag_res);
1241         activeCallUpdated = TRUE;
1242     }
1243 
1244     /* Ringing call changed? */
1245     if (call_setup_state != btif_hf_cb[idx].call_setup_state)
1246     {
1247         BTIF_TRACE_DEBUG("%s: Call setup states changed. old: %s new: %s",
1248             __FUNCTION__, dump_hf_call_state(btif_hf_cb[idx].call_setup_state),
1249             dump_hf_call_state(call_setup_state));
1250         memset(&ag_res, 0, sizeof(tBTA_AG_RES_DATA));
1251 
1252         switch (call_setup_state)
1253         {
1254             case BTHF_CALL_STATE_IDLE:
1255             {
1256                 switch (btif_hf_cb[idx].call_setup_state)
1257                 {
1258                     case BTHF_CALL_STATE_INCOMING:
1259                         if (num_active > btif_hf_cb[idx].num_active)
1260                         {
1261                             res = BTA_AG_IN_CALL_CONN_RES;
1262                             ag_res.audio_handle = btif_hf_cb[idx].handle;
1263                         }
1264                         else if (num_held > btif_hf_cb[idx].num_held)
1265                             res = BTA_AG_IN_CALL_HELD_RES;
1266                         else
1267                             res = BTA_AG_CALL_CANCEL_RES;
1268                         break;
1269                     case BTHF_CALL_STATE_DIALING:
1270                     case BTHF_CALL_STATE_ALERTING:
1271                         if (num_active > btif_hf_cb[idx].num_active)
1272                         {
1273                             ag_res.audio_handle = BTA_AG_HANDLE_SCO_NO_CHANGE;
1274                             res = BTA_AG_OUT_CALL_CONN_RES;
1275                         }
1276                         else
1277                             res = BTA_AG_CALL_CANCEL_RES;
1278                         break;
1279                     default:
1280                         BTIF_TRACE_ERROR("%s: Incorrect Call setup state transition", __FUNCTION__);
1281                         status = BT_STATUS_PARM_INVALID;
1282                         break;
1283                 }
1284             } break;
1285 
1286             case BTHF_CALL_STATE_INCOMING:
1287                 if (num_active || num_held)
1288                     res = BTA_AG_CALL_WAIT_RES;
1289                 else
1290                     res = BTA_AG_IN_CALL_RES;
1291                 if (number)
1292                 {
1293                     int xx = 0;
1294                     if ((type == BTHF_CALL_ADDRTYPE_INTERNATIONAL) && (*number != '+'))
1295                         xx = sprintf (ag_res.str, "\"+%s\"", number);
1296                     else
1297                         xx = sprintf (ag_res.str, "\"%s\"", number);
1298                     ag_res.num = type;
1299 
1300                     if (res == BTA_AG_CALL_WAIT_RES)
1301                         sprintf(&ag_res.str[xx], ",%d", type);
1302                 }
1303                 break;
1304             case BTHF_CALL_STATE_DIALING:
1305                 ag_res.audio_handle = btif_hf_cb[idx].handle;
1306                 res = BTA_AG_OUT_CALL_ORIG_RES;
1307                 break;
1308             case BTHF_CALL_STATE_ALERTING:
1309                 /* if we went from idle->alert, force SCO setup here. dialing usually triggers it */
1310                 if (btif_hf_cb[idx].call_setup_state == BTHF_CALL_STATE_IDLE)
1311                 ag_res.audio_handle = btif_hf_cb[idx].handle;
1312                 res = BTA_AG_OUT_CALL_ALERT_RES;
1313                 break;
1314             default:
1315                 BTIF_TRACE_ERROR("%s: Incorrect new ringing call state", __FUNCTION__);
1316                 status = BT_STATUS_PARM_INVALID;
1317                 break;
1318         }
1319         BTIF_TRACE_DEBUG("%s: Call setup state changed. res=%d, audio_handle=%d", __FUNCTION__, res, ag_res.audio_handle);
1320 
1321         if (res)
1322             BTA_AgResult(BTA_AG_HANDLE_ALL, res, &ag_res);
1323 
1324         /* if call setup is idle, we have already updated call indicator, jump out */
1325         if (call_setup_state == BTHF_CALL_STATE_IDLE)
1326         {
1327             /* check & update callheld */
1328             if ((num_held > 0) && (num_active > 0))
1329                 send_indicator_update(BTA_AG_IND_CALLHELD, 1);
1330             goto update_call_states;
1331         }
1332     }
1333 
1334     memset(&ag_res, 0, sizeof(tBTA_AG_RES_DATA));
1335 
1336     /* per the errata 2043, call=1 implies atleast one call is in progress (active/held)
1337     ** https://www.bluetooth.org/errata/errata_view.cfm?errata_id=2043
1338     ** Handle call indicator change
1339     **/
1340     if (!activeCallUpdated && ((num_active + num_held) !=
1341                  (btif_hf_cb[idx].num_active + btif_hf_cb[idx].num_held)) )
1342     {
1343         BTIF_TRACE_DEBUG("%s: Active call states changed. old: %d new: %d", __FUNCTION__, btif_hf_cb[idx].num_active, num_active);
1344         send_indicator_update(BTA_AG_IND_CALL, ((num_active + num_held) > 0) ? 1 : 0);
1345     }
1346 
1347     /* Held Changed? */
1348     if (num_held != btif_hf_cb[idx].num_held)
1349     {
1350         BTIF_TRACE_DEBUG("%s: Held call states changed. old: %d new: %d",
1351                         __FUNCTION__, btif_hf_cb[idx].num_held, num_held);
1352         send_indicator_update(BTA_AG_IND_CALLHELD, ((num_held == 0) ? 0 : ((num_active == 0) ? 2 : 1)));
1353     }
1354 
1355     /* Calls Swapped? */
1356     if ( (call_setup_state == btif_hf_cb[idx].call_setup_state) &&
1357          (num_active && num_held) &&
1358          (num_active == btif_hf_cb[idx].num_active) &&
1359          (num_held == btif_hf_cb[idx].num_held) )
1360     {
1361         BTIF_TRACE_DEBUG("%s: Calls swapped", __FUNCTION__);
1362         send_indicator_update(BTA_AG_IND_CALLHELD, 1);
1363     }
1364 
1365 update_call_states:
1366     for (i = 0; i < btif_max_hf_clients; i++)
1367     {
1368         btif_hf_cb[i].num_active = num_active;
1369         btif_hf_cb[i].num_held = num_held;
1370         btif_hf_cb[i].call_setup_state = call_setup_state;
1371     }
1372     return status;
1373 }
1374 
1375 
1376 /*******************************************************************************
1377 **
1378 ** Function         btif_hf_call_terminated_recently
1379 **
1380 ** Description      Checks if a call has been terminated
1381 **
1382 ** Returns          bt_status_t
1383 **
1384 *******************************************************************************/
btif_hf_call_terminated_recently()1385 BOOLEAN btif_hf_call_terminated_recently()
1386 {
1387       struct timespec         now;
1388 
1389       clock_gettime(CLOCK_MONOTONIC, &now);
1390       if (now.tv_sec < btif_hf_cb[0].call_end_timestamp.tv_sec +
1391                                   BTIF_HF_CALL_END_TIMEOUT)
1392       {
1393           return TRUE;
1394       }
1395       else
1396       {
1397           btif_hf_cb[0].call_end_timestamp.tv_sec = 0;
1398           return FALSE;
1399       }
1400 }
1401 
1402 /*******************************************************************************
1403 **
1404 ** Function         cleanup
1405 **
1406 ** Description      Closes the HF interface
1407 **
1408 ** Returns          bt_status_t
1409 **
1410 *******************************************************************************/
cleanup(void)1411 static void  cleanup( void )
1412 {
1413     BTIF_TRACE_EVENT("%s", __FUNCTION__);
1414 
1415     if (bt_hf_callbacks)
1416     {
1417         btif_disable_service(BTA_HFP_SERVICE_ID);
1418         bt_hf_callbacks = NULL;
1419     }
1420 }
1421 
1422 /*******************************************************************************
1423 **
1424 ** Function         configure_wbs
1425 **
1426 ** Description      set to over-ride the current WBS configuration.
1427 **                  It will not send codec setting cmd to the controller now.
1428 **                  It just change the configure.
1429 **
1430 ** Returns          bt_status_t
1431 **
1432 *******************************************************************************/
configure_wbs(bt_bdaddr_t * bd_addr,bthf_wbs_config_t config)1433 static bt_status_t  configure_wbs( bt_bdaddr_t *bd_addr , bthf_wbs_config_t config )
1434 {
1435     CHECK_BTHF_INIT();
1436 
1437     int idx = btif_hf_idx_by_bdaddr(bd_addr);
1438 
1439     BTIF_TRACE_EVENT("%s config is %d", __FUNCTION__,config);
1440     if (config == BTHF_WBS_YES)
1441         BTA_AgSetCodec(btif_hf_cb[idx].handle,BTA_AG_CODEC_MSBC);
1442     else if(config == BTHF_WBS_NO)
1443         BTA_AgSetCodec(btif_hf_cb[idx].handle,BTA_AG_CODEC_CVSD);
1444     else
1445         BTA_AgSetCodec(btif_hf_cb[idx].handle,BTA_AG_CODEC_NONE);
1446 
1447     return BT_STATUS_SUCCESS;
1448 }
1449 
1450 static const bthf_interface_t bthfInterface = {
1451     sizeof(bthfInterface),
1452     init,
1453     connect,
1454     disconnect,
1455     connect_audio,
1456     disconnect_audio,
1457     start_voice_recognition,
1458     stop_voice_recognition,
1459     volume_control,
1460     device_status_notification,
1461     cops_response,
1462     cind_response,
1463     formatted_at_response,
1464     at_response,
1465     clcc_response,
1466     phone_state_change,
1467     cleanup,
1468     configure_wbs,
1469 };
1470 
1471 /*******************************************************************************
1472 **
1473 ** Function         btif_hf_execute_service
1474 **
1475 ** Description      Initializes/Shuts down the service
1476 **
1477 ** Returns          BT_STATUS_SUCCESS on success, BT_STATUS_FAIL otherwise
1478 **
1479 *******************************************************************************/
btif_hf_execute_service(BOOLEAN b_enable)1480 bt_status_t btif_hf_execute_service(BOOLEAN b_enable)
1481 {
1482      char * p_service_names[] = BTIF_HF_SERVICE_NAMES;
1483      int i;
1484      if (b_enable)
1485      {
1486           /* Enable and register with BTA-AG */
1487           BTA_AgEnable (BTA_AG_PARSE, bte_hf_evt);
1488               for (i = 0; i < btif_max_hf_clients; i++)
1489               {
1490                   BTA_AgRegister(BTIF_HF_SERVICES, BTIF_HF_SECURITY,
1491                       BTIF_HF_FEATURES, p_service_names, bthf_hf_id[i]);
1492               }
1493      }
1494      else {
1495          /* De-register AG */
1496          for (i = 0; i < btif_max_hf_clients; i++)
1497          {
1498              BTA_AgDeregister(btif_hf_cb[i].handle);
1499          }
1500          /* Disable AG */
1501          BTA_AgDisable();
1502      }
1503      return BT_STATUS_SUCCESS;
1504 }
1505 
1506 /*******************************************************************************
1507 **
1508 ** Function         btif_hf_get_interface
1509 **
1510 ** Description      Get the hf callback interface
1511 **
1512 ** Returns          bthf_interface_t
1513 **
1514 *******************************************************************************/
btif_hf_get_interface()1515 const bthf_interface_t *btif_hf_get_interface()
1516 {
1517     BTIF_TRACE_EVENT("%s", __FUNCTION__);
1518     return &bthfInterface;
1519 }
1520