bta/hf_client/bta_hf_client_at.c

   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 #define LOG_TAG "bt_hf_client"
  21
  22 #include <errno.h>
  23 #include <string.h>
  24 #include <stdio.h>
  25
  26 #include "osi/include/osi.h"
  27 #include "bta_hf_client_api.h"
  28 #include "bta_hf_client_int.h"
  29 #include "osi/include/log.h"
  30 #include "port_api.h"
  31
  32 /* Uncomment to enable AT traffic dumping */
  33 /* #define BTA_HF_CLIENT_AT_DUMP 1 */
  34
  35 /* minimum length of AT event */
  36 #define BTA_HF_CLIENT_AT_EVENT_MIN_LEN 3
  37
  38 /* timeout (in milliseconds) for AT response */
  39 #define BTA_HF_CLIENT_AT_TIMEOUT 29989
  40
  41 /* timeout (in milliseconds) for AT hold timer */
  42 #define BTA_HF_CLIENT_AT_HOLD_TIMEOUT 41
  43
  44 /******************************************************************************
  45 **
  46 **          DATA TYPES AND CONTAINERS
  47 **
  48 *******************************************************************************/
  49 /* BRSF: store received values here */
  50 extern tBTA_HF_CLIENT_CB  bta_hf_client_cb;
  51
  52 extern fixed_queue_t *btu_bta_alarm_queue;
  53
  54 /******************************************************************************
  55 **       SUPPORTED EVENT MESSAGES
  56 *******************************************************************************/
  57
  58 /* CIND: supported indicator names */
  59 #define BTA_HF_CLIENT_INDICATOR_BATTERYCHG  "battchg"
  60 #define BTA_HF_CLIENT_INDICATOR_SIGNAL      "signal"
  61 #define BTA_HF_CLIENT_INDICATOR_SERVICE     "service"
  62 #define BTA_HF_CLIENT_INDICATOR_CALL        "call"
  63 #define BTA_HF_CLIENT_INDICATOR_ROAM        "roam"
  64 #define BTA_HF_CLIENT_INDICATOR_CALLSETUP   "callsetup"
  65 #define BTA_HF_CLIENT_INDICATOR_CALLHELD    "callheld"
  66
  67 #define MIN(a, b) \
  68     ({ __typeof__(a) _a = (a); __typeof__(b) _b = (b); (_a < _b) ? _a : _b; })
  69
  70 /* CIND: represents each indicators boundaries */
  71 typedef struct
  72 {
  73     char* name;
  74     UINT8 min;
  75     UINT8 max;
  76     UINT8 namelen;
  77 } tBTA_HF_CLIENT_INDICATOR;
  78
  79 #define BTA_HF_CLIENT_AT_SUPPORTED_INDICATOR_COUNT 7
  80
  81 /* CIND: storage room for indicators value range and their statuses */
  82 static const tBTA_HF_CLIENT_INDICATOR bta_hf_client_indicators[BTA_HF_CLIENT_AT_SUPPORTED_INDICATOR_COUNT] =
  83 {
  84     /* name                                | min | max | name length - used by parser */
  85      {BTA_HF_CLIENT_INDICATOR_BATTERYCHG,     0,   5,    sizeof(BTA_HF_CLIENT_INDICATOR_BATTERYCHG)},
  86      {BTA_HF_CLIENT_INDICATOR_SIGNAL,         0,   5,    sizeof(BTA_HF_CLIENT_INDICATOR_SIGNAL)},
  87      {BTA_HF_CLIENT_INDICATOR_SERVICE,        0,   1,    sizeof(BTA_HF_CLIENT_INDICATOR_SERVICE)},
  88      {BTA_HF_CLIENT_INDICATOR_CALL,           0,   1,    sizeof(BTA_HF_CLIENT_INDICATOR_CALL)},
  89      {BTA_HF_CLIENT_INDICATOR_ROAM,           0,   1,    sizeof(BTA_HF_CLIENT_INDICATOR_ROAM)},
  90      {BTA_HF_CLIENT_INDICATOR_CALLSETUP,      0,   3,    sizeof(BTA_HF_CLIENT_INDICATOR_CALLSETUP)},
  91      {BTA_HF_CLIENT_INDICATOR_CALLHELD,       0,   2,    sizeof(BTA_HF_CLIENT_INDICATOR_CALLHELD)}
  92 };
  93
  94 /* +VGM/+VGS - gain min/max values  */
  95 #define BTA_HF_CLIENT_VGS_MIN   0
  96 #define BTA_HF_CLIENT_VGS_MAX  15
  97 #define BTA_HF_CLIENT_VGM_MIN   0
  98 #define BTA_HF_CLIENT_VGM_MAX  15
  99
 100 UINT32 service_index = 0;
 101 BOOLEAN service_availability = TRUE;
 102 /* helper functions for handling AT commands queueing */
 103
 104 static void bta_hf_client_handle_ok();
 105
 106 static void bta_hf_client_clear_queued_at(void)
 107 {
 108     tBTA_HF_CLIENT_AT_QCMD *cur = bta_hf_client_cb.scb.at_cb.queued_cmd;
 109     tBTA_HF_CLIENT_AT_QCMD *next;
 110
 111     while (cur != NULL) {
 112         next = cur->next;
 113         osi_free(cur);
 114         cur = next;
 115     }
 116
 117     bta_hf_client_cb.scb.at_cb.queued_cmd = NULL;
 118 }
 119
 120 static void bta_hf_client_queue_at(tBTA_HF_CLIENT_AT_CMD cmd, const char *buf, UINT16 buf_len)
 121 {
 122     tBTA_HF_CLIENT_AT_QCMD *new_cmd =
 123         (tBTA_HF_CLIENT_AT_QCMD *)osi_malloc(sizeof(tBTA_HF_CLIENT_AT_QCMD));
 124
 125     APPL_TRACE_DEBUG("%s", __func__);
 126
 127     new_cmd->cmd = cmd;
 128     new_cmd->buf_len = buf_len;
 129     new_cmd->next = NULL;
 130     memcpy(new_cmd->buf, buf, buf_len);
 131
 132     if (bta_hf_client_cb.scb.at_cb.queued_cmd != NULL) {
 133         tBTA_HF_CLIENT_AT_QCMD *qcmd = bta_hf_client_cb.scb.at_cb.queued_cmd;
 134
 135         while (qcmd->next != NULL)
 136             qcmd = qcmd->next;
 137
 138         qcmd->next = new_cmd;
 139     } else {
 140         bta_hf_client_cb.scb.at_cb.queued_cmd = new_cmd;
 141     }
 142 }
 143
 144 static void bta_hf_client_at_resp_timer_cback(UNUSED_ATTR void *data)
 145 {
 146   if (bta_hf_client_cb.scb.at_cb.current_cmd == BTA_HF_CLIENT_AT_CNUM) {
 147     LOG_INFO(LOG_TAG, "%s timed out waiting for AT+CNUM response; spoofing OK.", __func__);
 148     bta_hf_client_handle_ok();
 149   } else {
 150     APPL_TRACE_ERROR("HFPClient: AT response timeout, disconnecting");
 151     bta_hf_client_sm_execute(BTA_HF_CLIENT_API_CLOSE_EVT, NULL);
 152   }
 153 }
 154
 155 static void bta_hf_client_start_at_resp_timer(void)
 156 {
 157     alarm_set_on_queue(bta_hf_client_cb.scb.at_cb.resp_timer,
 158                        BTA_HF_CLIENT_AT_TIMEOUT,
 159                        bta_hf_client_at_resp_timer_cback,
 160                        NULL,
 161                        btu_bta_alarm_queue);
 162 }
 163
 164 static void bta_hf_client_stop_at_resp_timer(void)
 165 {
 166     alarm_cancel(bta_hf_client_cb.scb.at_cb.resp_timer);
 167 }
 168
 169 static void bta_hf_client_send_at(tBTA_HF_CLIENT_AT_CMD cmd, char *buf, UINT16 buf_len)
 170 {
 171     if ((bta_hf_client_cb.scb.at_cb.current_cmd == BTA_HF_CLIENT_AT_NONE ||
 172             bta_hf_client_cb.scb.svc_conn == FALSE) &&
 173             !alarm_is_scheduled(bta_hf_client_cb.scb.at_cb.hold_timer))
 174     {
 175         UINT16  len;
 176
 177 #ifdef BTA_HF_CLIENT_AT_DUMP
 178         APPL_TRACE_DEBUG("%s %.*s", __FUNCTION__, buf_len - 1, buf);
 179 #endif
 180
 181         bta_hf_client_cb.scb.at_cb.current_cmd = cmd;
 182         /* Generate fake responses for these because they won't reliably work */
 183         if (!service_availability &&
 184                 (cmd == BTA_HF_CLIENT_AT_CNUM || cmd == BTA_HF_CLIENT_AT_COPS))
 185         {
 186             APPL_TRACE_WARNING("%s: No service, skipping %d command", __FUNCTION__, cmd);
 187             bta_hf_client_handle_ok();
 188             return;
 189         }
 190
 191         PORT_WriteData(bta_hf_client_cb.scb.conn_handle, buf, buf_len, &len);
 192
 193         bta_hf_client_start_at_resp_timer();
 194
 195         return;
 196     }
 197
 198     bta_hf_client_queue_at(cmd, buf, buf_len);
 199 }
 200
 201 static void bta_hf_client_send_queued_at(void)
 202 {
 203     tBTA_HF_CLIENT_AT_QCMD *cur = bta_hf_client_cb.scb.at_cb.queued_cmd;
 204
 205     APPL_TRACE_DEBUG("%s", __FUNCTION__);
 206
 207     if (cur != NULL)
 208     {
 209         bta_hf_client_cb.scb.at_cb.queued_cmd = cur->next;
 210
 211         bta_hf_client_send_at(cur->cmd, cur->buf, cur->buf_len);
 212
 213         osi_free(cur);
 214     }
 215 }
 216
 217 static void bta_hf_client_at_hold_timer_cback(UNUSED_ATTR void *data)
 218 {
 219     APPL_TRACE_DEBUG("%s", __FUNCTION__);
 220     bta_hf_client_send_queued_at();
 221 }
 222
 223 static void bta_hf_client_stop_at_hold_timer(void)
 224 {
 225     APPL_TRACE_DEBUG("%s", __FUNCTION__);
 226     alarm_cancel(bta_hf_client_cb.scb.at_cb.hold_timer);
 227 }
 228
 229 static void bta_hf_client_start_at_hold_timer(void)
 230 {
 231     APPL_TRACE_DEBUG("%s", __FUNCTION__);
 232     alarm_set_on_queue(bta_hf_client_cb.scb.at_cb.hold_timer,
 233                        BTA_HF_CLIENT_AT_HOLD_TIMEOUT,
 234                        bta_hf_client_at_hold_timer_cback,
 235                        NULL,
 236                        btu_bta_alarm_queue);
 237 }
 238
 239 /******************************************************************************
 240 **
 241 **          COMMON AT EVENT HANDLING FUNCTIONS
 242 **
 243 **   Receives data (strings, ints, etc.) from the parser and processes this data.
 244 **   No buffer parsing is being done here.
 245 *******************************************************************************/
 246
 247 static void bta_hf_client_handle_ok()
 248 {
 249     APPL_TRACE_DEBUG("%s", __FUNCTION__);
 250
 251     bta_hf_client_stop_at_resp_timer();
 252
 253     if (!bta_hf_client_cb.scb.svc_conn)
 254     {
 255         bta_hf_client_slc_seq(FALSE);
 256         return;
 257     }
 258
 259     switch(bta_hf_client_cb.scb.at_cb.current_cmd)
 260     {
 261         case BTA_HF_CLIENT_AT_BIA:
 262         case BTA_HF_CLIENT_AT_BCC:
 263             break;
 264         case BTA_HF_CLIENT_AT_BCS:
 265             bta_hf_client_start_at_hold_timer();
 266             bta_hf_client_cb.scb.at_cb.current_cmd = BTA_HF_CLIENT_AT_NONE;
 267             return;
 268         case BTA_HF_CLIENT_AT_CLIP: //last cmd is post slc seq
 269             if (bta_hf_client_cb.scb.send_at_reply == FALSE)
 270             {
 271                 bta_hf_client_cb.scb.send_at_reply = TRUE;
 272             }
 273             break;
 274         case BTA_HF_CLIENT_AT_NONE:
 275             bta_hf_client_stop_at_hold_timer();
 276             break;
 277         default:
 278             if (bta_hf_client_cb.scb.send_at_reply)
 279             {
 280                 bta_hf_client_at_result(BTA_HF_CLIENT_AT_RESULT_OK, 0);
 281             }
 282             break;
 283     }
 284
 285     bta_hf_client_cb.scb.at_cb.current_cmd = BTA_HF_CLIENT_AT_NONE;
 286
 287     bta_hf_client_send_queued_at();
 288 }
 289
 290 static void bta_hf_client_handle_error(tBTA_HF_CLIENT_AT_RESULT_TYPE type, UINT16 cme)
 291 {
 292     APPL_TRACE_DEBUG("%s %u %u", __FUNCTION__, type, cme);
 293
 294     bta_hf_client_stop_at_resp_timer();
 295
 296     if (!bta_hf_client_cb.scb.svc_conn)
 297     {
 298         bta_hf_client_slc_seq(TRUE);
 299         return;
 300     }
 301
 302     switch(bta_hf_client_cb.scb.at_cb.current_cmd)
 303     {
 304         case BTA_HF_CLIENT_AT_BIA:
 305             break;
 306         case BTA_HF_CLIENT_AT_BCC:
 307         case BTA_HF_CLIENT_AT_BCS:
 308             bta_hf_client_cback_sco(BTA_HF_CLIENT_AUDIO_CLOSE_EVT);
 309             break;
 310         case BTA_HF_CLIENT_AT_CLIP: //last cmd is post slc seq
 311             if (bta_hf_client_cb.scb.send_at_reply == FALSE)
 312             {
 313                 bta_hf_client_cb.scb.send_at_reply = TRUE;
 314             }
 315             break;
 316         default:
 317             if (bta_hf_client_cb.scb.send_at_reply)
 318             {
 319                 bta_hf_client_at_result(type, cme);
 320             }
 321             break;
 322     }
 323
 324     bta_hf_client_cb.scb.at_cb.current_cmd = BTA_HF_CLIENT_AT_NONE;
 325
 326     bta_hf_client_send_queued_at();
 327 }
 328
 329 static void bta_hf_client_handle_ring()
 330 {
 331     APPL_TRACE_DEBUG("%s", __FUNCTION__);
 332     bta_hf_client_evt_val(BTA_HF_CLIENT_RING_INDICATION,0);
 333 }
 334
 335 static void bta_hf_client_handle_brsf(UINT32 value)
 336 {
 337     APPL_TRACE_DEBUG("%s 0x%x", __FUNCTION__, value);
 338     bta_hf_client_cb.scb.peer_features = value;
 339 }
 340
 341 /* handles a single indicator descriptor - registers it for value changing events */
 342 static void bta_hf_client_handle_cind_list_item(char *name, UINT32 min, UINT32 max, UINT32 index)
 343 {
 344
 345     UINT8 i = 0;
 346
 347     APPL_TRACE_DEBUG("%s %lu.%s <%lu:%lu>", __FUNCTION__, index, name, min, max);
 348
 349     /* look for a matching indicator on list of supported ones */
 350     for(i = 0; i < BTA_HF_CLIENT_AT_SUPPORTED_INDICATOR_COUNT; i++)
 351     {
 352         if (strcmp(name,BTA_HF_CLIENT_INDICATOR_SERVICE) == 0)
 353         {
 354             service_index = index;
 355         }
 356         /* look for a match - search one sign further than indicators name to check for string end */
 357         /* It will distinguish 'callheld' which could be matched by strncmp as 'call'.               */
 358         if (strncmp(name, bta_hf_client_indicators[i].name, bta_hf_client_indicators[i].namelen) != 0)
 359             continue;
 360
 361         /* index - enumerates value position in the incoming sequence                      */
 362         /* if name matches one of the known indicators, add its incoming position          */
 363         /* to lookup table for easy value->indicator matching later, when only values come  */
 364         bta_hf_client_cb.scb.at_cb.indicator_lookup[index] = i;
 365
 366         return;
 367     }
 368 }
 369
 370 static void bta_hf_client_handle_cind_value(UINT32 index, UINT32 value)
 371 {
 372     APPL_TRACE_DEBUG("%s index: %u value: %u", __FUNCTION__, index, value);
 373
 374     if (index >= BTA_HF_CLIENT_AT_INDICATOR_COUNT)
 375     {
 376         return;
 377     }
 378
 379     if (service_index == index)
 380     {
 381         if (value == 0)
 382         {
 383             service_availability = FALSE;
 384         }
 385         else
 386         {
 387             service_availability = TRUE;
 388         }
 389     }
 390     if (bta_hf_client_cb.scb.at_cb.indicator_lookup[index] == -1)
 391     {
 392         return;
 393     }
 394
 395     /* get the real array index from lookup table */
 396     index = bta_hf_client_cb.scb.at_cb.indicator_lookup[index];
 397
 398     /* Ignore out of range values */
 399     if(value > bta_hf_client_indicators[index].max ||
 400        value < bta_hf_client_indicators[index].min)
 401     {
 402         return;
 403     }
 404
 405     /* tBTA_HF_CLIENT_IND_TYPE match index in bta_hf_client_indicators */
 406     bta_hf_client_ind(index, value);
 407 }
 408
 409 static void bta_hf_client_handle_chld(UINT32 mask)
 410 {
 411     APPL_TRACE_DEBUG("%s 0x%x", __FUNCTION__, mask);
 412
 413     bta_hf_client_cb.scb.chld_features |= mask;
 414 }
 415
 416 static void bta_hf_client_handle_ciev(UINT32 index, UINT32 value)
 417 {
 418     INT8 realind = -1;
 419
 420     APPL_TRACE_DEBUG("%s index: %u value: %u", __FUNCTION__, index, value);
 421
 422     if(index == 0 || index > BTA_HF_CLIENT_AT_INDICATOR_COUNT)
 423     {
 424         return;
 425     }
 426
 427     if (service_index == index - 1)
 428     {
 429         service_availability = value == 0 ? FALSE : TRUE;
 430     }
 431
 432     realind = bta_hf_client_cb.scb.at_cb.indicator_lookup[index - 1];
 433
 434     if(realind >= 0 && realind < BTA_HF_CLIENT_AT_SUPPORTED_INDICATOR_COUNT)
 435     {
 436         /* get the real in-array index from lookup table by index it comes at */
 437         /* if there is no bug it should automatically be correctly calculated    */
 438         if(value > bta_hf_client_indicators[realind].max || value < bta_hf_client_indicators[realind].min)
 439         {
 440             return;
 441         }
 442
 443         /* update service availability on +ciev from AG. */
 444         if (service_index == (index - 1))
 445         {
 446             if (value == 1)
 447             {
 448                 service_availability = TRUE;
 449             }
 450             else
 451             {
 452                 service_availability = FALSE;
 453             }
 454         }
 455
 456         /* tBTA_HF_CLIENT_IND_TYPE match index in bta_hf_client_indicators */
 457         bta_hf_client_ind(realind, value);
 458     }
 459 }
 460
 461 static void bta_hf_client_handle_bcs(UINT32 codec)
 462 {
 463     APPL_TRACE_DEBUG("%s %u", __FUNCTION__, codec);
 464
 465     if (codec == BTM_SCO_CODEC_CVSD ||
 466             (codec == BTM_SCO_CODEC_MSBC && bta_hf_client_cb.msbc_enabled == TRUE))
 467     {
 468         bta_hf_client_cb.scb.negotiated_codec = codec;
 469         bta_hf_client_send_at_bcs(codec);
 470     }
 471     else
 472     {
 473         bta_hf_client_cb.scb.negotiated_codec = BTM_SCO_CODEC_CVSD;
 474         bta_hf_client_send_at_bac();
 475     }
 476 }
 477
 478 static void bta_hf_client_handle_bsir(UINT32 provided)
 479 {
 480     APPL_TRACE_DEBUG("%s %u", __FUNCTION__, provided);
 481
 482     bta_hf_client_evt_val(BTA_HF_CLIENT_BSIR_EVT, provided);
 483 }
 484
 485 static void bta_hf_client_handle_cmeerror(UINT32 code)
 486 {
 487     bta_hf_client_handle_error(BTA_HF_CLIENT_AT_RESULT_CME, code);
 488 }
 489
 490 static void bta_hf_client_handle_vgm(UINT32 value)
 491 {
 492     APPL_TRACE_DEBUG("%s %lu", __FUNCTION__, value);
 493
 494     if(value <= BTA_HF_CLIENT_VGM_MAX)
 495     {
 496         bta_hf_client_evt_val(BTA_HF_CLIENT_MIC_EVT, value);
 497     }
 498 }
 499
 500 static void bta_hf_client_handle_vgs(UINT32 value)
 501 {
 502     APPL_TRACE_DEBUG("%s %lu", __FUNCTION__, value);
 503
 504     if(value <= BTA_HF_CLIENT_VGS_MAX)
 505     {
 506         bta_hf_client_evt_val(BTA_HF_CLIENT_SPK_EVT, value);
 507     }
 508 }
 509
 510 static void bta_hf_client_handle_bvra(UINT32 value)
 511 {
 512     APPL_TRACE_DEBUG("%s %lu", __FUNCTION__, value);
 513
 514     if (value > 1)
 515     {
 516         return;
 517     }
 518
 519     bta_hf_client_evt_val(BTA_HF_CLIENT_VOICE_REC_EVT, value);
 520 }
 521
 522 static void bta_hf_client_handle_clip(char *numstr, UINT32 type)
 523 {
 524     APPL_TRACE_DEBUG("%s %u %s", __FUNCTION__, type, numstr);
 525
 526     bta_hf_client_clip(numstr);
 527 }
 528
 529 static void bta_hf_client_handle_ccwa(char *numstr, UINT32 type)
 530 {
 531     APPL_TRACE_DEBUG("%s %u %s", __FUNCTION__, type, numstr);
 532
 533     bta_hf_client_ccwa(numstr);
 534 }
 535
 536 static void bta_hf_client_handle_cops(char *opstr, UINT32 mode)
 537 {
 538     APPL_TRACE_DEBUG("%s %u %s", __FUNCTION__, mode, opstr);
 539
 540     bta_hf_client_operator_name(opstr);
 541 }
 542
 543 static void bta_hf_client_handle_binp(char *numstr)
 544 {
 545     APPL_TRACE_DEBUG("%s %s", __FUNCTION__, numstr);
 546
 547     bta_hf_client_binp(numstr);
 548 }
 549
 550 static void bta_hf_client_handle_clcc(UINT16 idx, UINT16 dir, UINT16 status, UINT16 mode, UINT16 mpty, char *numstr, UINT16 type)
 551 {
 552     APPL_TRACE_DEBUG("%s idx: %u dir: %u status: %u mode: %u mpty: %u",
 553                         __FUNCTION__, idx, dir, status, mode, mpty);
 554
 555     if (numstr)
 556     {
 557         APPL_TRACE_DEBUG("%s number: %s  type: %u", __FUNCTION__, numstr, type);
 558     }
 559
 560     bta_hf_client_clcc(idx, dir, status, mpty, numstr);
 561 }
 562
 563 static void bta_hf_client_handle_cnum( char *numstr, UINT16 type, UINT16 service)
 564 {
 565     APPL_TRACE_DEBUG("%s number: %s type: %u service: %u", __FUNCTION__, numstr, type, service);
 566
 567     /* TODO: should number be modified according to type? */
 568     bta_hf_client_cnum(numstr, service);
 569 }
 570
 571 static void bta_hf_client_handle_btrh( UINT16 code)
 572 {
 573     APPL_TRACE_DEBUG("%s %lu", __FUNCTION__, code);
 574
 575     bta_hf_client_evt_val(BTA_HF_CLIENT_BTRH_EVT, code);
 576 }
 577
 578 /******************************************************************************
 579 **
 580 **          COMMON AT EVENTS PARSING FUNCTIONS
 581 **
 582 *******************************************************************************/
 583
 584 /* Check if prefix match and skip spaces if any */
 585 #define AT_CHECK_EVENT(buf, event) \
 586     if (strncmp("\r\n"event, buf,sizeof("\r\n"event) - 1) != 0) return buf; \
 587     buf += sizeof("\r\n"event) - 1; \
 588     while (*buf == ' ') buf++;
 589
 590 /* check for <cr><lf> and forward buffer if match */
 591 #define AT_CHECK_RN(buf) \
 592     if (strncmp("\r\n", buf, sizeof("\r\n") - 1) != 0) { \
 593         APPL_TRACE_DEBUG("%s missing end <cr><lf>", __FUNCTION__); \
 594         return NULL;} \
 595     buf += sizeof("\r\n") - 1;
 596
 597 /* skip rest of AT string up to <cr> */
 598 #define AT_SKIP_REST(buf) while(*buf != '\r') buf++;
 599
 600 static char *bta_hf_client_parse_ok(char *buffer)
 601 {
 602     AT_CHECK_EVENT(buffer, "OK");
 603     AT_CHECK_RN(buffer);
 604
 605     bta_hf_client_handle_ok();
 606
 607     return buffer;
 608 }
 609
 610 static char *bta_hf_client_parse_error(char *buffer)
 611 {
 612     AT_CHECK_EVENT(buffer, "ERROR");
 613     AT_CHECK_RN(buffer);
 614
 615     bta_hf_client_handle_error(BTA_HF_CLIENT_AT_RESULT_ERROR, 0);
 616
 617     return buffer;
 618 }
 619
 620 static char *bta_hf_client_parse_ring(char *buffer)
 621 {
 622     AT_CHECK_EVENT(buffer, "RING");
 623     AT_CHECK_RN(buffer);
 624
 625     bta_hf_client_handle_ring();
 626
 627     return buffer;
 628 }
 629
 630 /* generic uint32 parser */
 631 static char *bta_hf_client_parse_uint32(char *buffer, void (*handler_callback)(UINT32))
 632 {
 633     UINT32 value;
 634     int res;
 635     int offset;
 636
 637     res = sscanf(buffer, "%u%n", &value, &offset);
 638     if (res < 1)
 639     {
 640         return NULL;
 641     }
 642
 643     buffer += offset;
 644
 645     AT_CHECK_RN(buffer);
 646
 647     handler_callback(value);
 648     return buffer;
 649 }
 650
 651 static char *bta_hf_client_parse_brsf(char *buffer)
 652 {
 653     AT_CHECK_EVENT(buffer, "+BRSF:");
 654
 655     return bta_hf_client_parse_uint32(buffer, bta_hf_client_handle_brsf);
 656 }
 657
 658 static char *bta_hf_client_parse_cind_values(char *buffer)
 659 {
 660     /* value and its position */
 661     UINT16 index = 0;
 662     UINT32 value = 0;
 663
 664     int offset;
 665     int res;
 666
 667     while((res = sscanf(buffer, "%u%n", &value, &offset)) > 0)
 668     {
 669         /* decides if its valid index and value, if yes stores it */
 670         bta_hf_client_handle_cind_value(index, value);
 671
 672         buffer += offset;
 673
 674         /* check if more values are present */
 675         if (*buffer != ',')
 676         {
 677             break;
 678         }
 679
 680         index++;
 681         buffer++;
 682     }
 683
 684     if (res > 0)
 685     {
 686         AT_CHECK_RN(buffer);
 687         return buffer;
 688     }
 689
 690     return NULL;
 691 }
 692
 693 static char *bta_hf_client_parse_cind_list(char *buffer)
 694 {
 695     int offset = 0;
 696     char name[129];
 697     UINT32 min, max;
 698     UINT32 index = 0;
 699     int res;
 700
 701     while ((res = sscanf(buffer, "(\"%128[^\"]\",(%u%*[-,]%u))%n", name, &min, &max, &offset)) > 2)
 702     {
 703         bta_hf_client_handle_cind_list_item(name, min, max, index);
 704         if (offset == 0)
 705         {
 706             APPL_TRACE_ERROR("%s: Format Error %s", __func__, buffer);
 707             return NULL;
 708         }
 709
 710         buffer += offset;
 711         index++;
 712
 713         if (*buffer != ',')
 714         {
 715             break;
 716         }
 717
 718         buffer++;
 719     }
 720
 721     if (res > 2)
 722     {
 723         AT_CHECK_RN(buffer);
 724         return buffer;
 725     }
 726
 727     return NULL;
 728 }
 729
 730 static char *bta_hf_client_parse_cind(char *buffer)
 731 {
 732     AT_CHECK_EVENT(buffer, "+CIND:");
 733
 734     if(*buffer == '(')
 735         return bta_hf_client_parse_cind_list(buffer);
 736
 737     return bta_hf_client_parse_cind_values(buffer);
 738 }
 739
 740 static char *bta_hf_client_parse_chld(char *buffer)
 741 {
 742     AT_CHECK_EVENT(buffer, "+CHLD:");
 743
 744     if (*buffer != '(')
 745     {
 746         return NULL;
 747     }
 748
 749     buffer++;
 750
 751     while(*buffer != '\0')
 752     {
 753         if(strncmp("0",buffer, 1) == 0)
 754         {
 755             bta_hf_client_handle_chld(BTA_HF_CLIENT_CHLD_REL);
 756             buffer++;
 757         }
 758         else if(strncmp("1x",buffer, 2) == 0)
 759         {
 760             bta_hf_client_handle_chld(BTA_HF_CLIENT_CHLD_REL_X);
 761             buffer += 2;
 762         }
 763         else if(strncmp("1",buffer, 1) == 0)
 764         {
 765             bta_hf_client_handle_chld(BTA_HF_CLIENT_CHLD_REL_ACC);
 766             buffer++;
 767         }
 768         else if(strncmp("2x",buffer, 2) == 0)
 769         {
 770             bta_hf_client_handle_chld(BTA_HF_CLIENT_CHLD_PRIV_X);
 771             buffer += 2;
 772         }
 773         else if(strncmp("2",buffer, 1) == 0)
 774         {
 775             bta_hf_client_handle_chld(BTA_HF_CLIENT_CHLD_HOLD_ACC);
 776             buffer++;
 777         }
 778         else if(strncmp("3",buffer, 1) == 0)
 779         {
 780             bta_hf_client_handle_chld(BTA_HF_CLIENT_CHLD_MERGE);
 781             buffer++;
 782         }
 783         else if(strncmp("4",buffer, 1) == 0)
 784         {
 785             bta_hf_client_handle_chld(BTA_HF_CLIENT_CHLD_MERGE_DETACH);
 786             buffer++;
 787         }
 788         else
 789         {
 790             return NULL;
 791         }
 792
 793         if (*buffer == ',')
 794         {
 795             buffer++;
 796             continue;
 797         }
 798
 799         if (*buffer == ')')
 800         {
 801             buffer++;
 802             break;
 803         }
 804
 805         return NULL;
 806     }
 807
 808     AT_CHECK_RN(buffer);
 809
 810     return buffer;
 811 }
 812
 813 static char *bta_hf_client_parse_ciev(char *buffer)
 814 {
 815     UINT32 index, value;
 816     int res;
 817     int offset = 0;
 818
 819     AT_CHECK_EVENT(buffer, "+CIEV:");
 820
 821     res = sscanf(buffer, "%u,%u%n", &index, &value, &offset);
 822     if(res < 2)
 823     {
 824         return NULL;
 825     }
 826
 827     if (offset == 0)
 828     {
 829         APPL_TRACE_ERROR("%s: Format Error %s", __func__, buffer);
 830         return NULL;
 831     }
 832
 833     buffer += offset;
 834
 835     AT_CHECK_RN(buffer);
 836
 837     bta_hf_client_handle_ciev(index, value);
 838     return buffer;
 839 }
 840
 841 static char *bta_hf_client_parse_bcs(char *buffer)
 842 {
 843     AT_CHECK_EVENT(buffer, "+BCS:");
 844
 845     return bta_hf_client_parse_uint32(buffer, bta_hf_client_handle_bcs);
 846 }
 847
 848 static char *bta_hf_client_parse_bsir(char *buffer)
 849 {
 850     AT_CHECK_EVENT(buffer, "+BSIR:");
 851
 852     return bta_hf_client_parse_uint32(buffer, bta_hf_client_handle_bsir);
 853 }
 854
 855 static char *bta_hf_client_parse_cmeerror(char *buffer)
 856 {
 857     AT_CHECK_EVENT(buffer, "+CME ERROR:");
 858
 859     return bta_hf_client_parse_uint32(buffer, bta_hf_client_handle_cmeerror);
 860 }
 861
 862 static char *bta_hf_client_parse_vgm(char *buffer)
 863 {
 864     AT_CHECK_EVENT(buffer, "+VGM:");
 865
 866     return bta_hf_client_parse_uint32(buffer, bta_hf_client_handle_vgm);
 867 }
 868
 869 static char *bta_hf_client_parse_vgme(char *buffer)
 870 {
 871     AT_CHECK_EVENT(buffer, "+VGM=");
 872
 873     return bta_hf_client_parse_uint32(buffer, bta_hf_client_handle_vgm);
 874 }
 875
 876 static char *bta_hf_client_parse_vgs(char *buffer)
 877 {
 878     AT_CHECK_EVENT(buffer, "+VGS:");
 879
 880     return bta_hf_client_parse_uint32(buffer, bta_hf_client_handle_vgs);
 881 }
 882
 883 static char *bta_hf_client_parse_vgse(char *buffer)
 884 {
 885     AT_CHECK_EVENT(buffer, "+VGS=");
 886
 887     return bta_hf_client_parse_uint32(buffer, bta_hf_client_handle_vgs);
 888 }
 889
 890 static char *bta_hf_client_parse_bvra(char *buffer)
 891 {
 892     AT_CHECK_EVENT(buffer, "+BVRA:");
 893
 894     return bta_hf_client_parse_uint32(buffer, bta_hf_client_handle_bvra);
 895 }
 896
 897 static char *bta_hf_client_parse_clip(char *buffer)
 898 {
 899     /* spec forces 32 chars, plus \0 here */
 900     char number[33];
 901     UINT32 type = 0;
 902     int res;
 903     int offset = 0;
 904
 905     AT_CHECK_EVENT(buffer, "+CLIP:");
 906
 907     /* there might be something more after %lu but HFP doesn't care */
 908     res = sscanf(buffer, "\"%32[^\"]\",%u%n", number, &type, &offset);
 909     if(res < 2)
 910     {
 911         return NULL;
 912     }
 913
 914     if (offset == 0)
 915     {
 916         APPL_TRACE_ERROR("%s: Format Error %s", __func__, buffer);
 917         return NULL;
 918     }
 919
 920     buffer += offset;
 921
 922     AT_SKIP_REST(buffer);
 923
 924     AT_CHECK_RN(buffer);
 925
 926     bta_hf_client_handle_clip(number, type);
 927     return buffer;
 928 }
 929
 930 /* in HFP context there is no difference between ccwa and clip */
 931 static char *bta_hf_client_parse_ccwa(char *buffer)
 932 {
 933     /* ac to spec 32 chars max, plus \0 here */
 934     char number[33];
 935     UINT32 type = 0;
 936     int res ;
 937     int offset = 0;
 938
 939     AT_CHECK_EVENT(buffer, "+CCWA:");
 940
 941     /* there might be something more after %lu but HFP doesn't care */
 942     res = sscanf(buffer, "\"%32[^\"]\",%u%n", number, &type, &offset);
 943     if(res < 2)
 944     {
 945         return NULL;
 946     }
 947
 948     if (offset == 0)
 949     {
 950         APPL_TRACE_ERROR("%s: Format Error %s", __func__, buffer);
 951         return NULL;
 952     }
 953
 954     buffer += offset;
 955
 956     AT_SKIP_REST(buffer);
 957
 958     AT_CHECK_RN(buffer);
 959
 960     bta_hf_client_handle_ccwa(number, type);
 961     return buffer;
 962 }
 963
 964 static char *bta_hf_client_parse_cops(char *buffer)
 965 {
 966     UINT8 mode;
 967     /* spec forces 16 chars max, plus \0 here */
 968     char opstr[17];
 969     int res;
 970     int offset = 0;
 971
 972     AT_CHECK_EVENT(buffer, "+COPS:");
 973
 974     /* TODO: Not sure if operator string actually can contain escaped " char inside */
 975     res = sscanf(buffer, "%hhi,0,\"%16[^\"]\"%n", &mode, opstr, &offset);
 976     if(res < 2)
 977     {
 978         return NULL;
 979     }
 980     /* Abort in case offset not set because of format error */
 981     if (offset == 0)
 982     {
 983         APPL_TRACE_ERROR("%s: Format Error %s", __func__, buffer);
 984         return NULL;
 985     }
 986
 987     buffer += offset;
 988
 989     AT_SKIP_REST(buffer);
 990
 991     AT_CHECK_RN(buffer);
 992
 993     bta_hf_client_handle_cops(opstr, mode);
 994     // check for OK Response in end
 995     AT_CHECK_EVENT(buffer, "OK");
 996     AT_CHECK_RN(buffer);
 997
 998     bta_hf_client_handle_ok();
 999
1000     return buffer;
1001 }
1002
1003 static char *bta_hf_client_parse_binp(char *buffer)
1004 {
1005     /* HFP only supports phone number as BINP data */
1006     /* phone number is 32 chars plus one for \0*/
1007     char numstr[33];
1008     int res;
1009     int offset = 0;
1010
1011     AT_CHECK_EVENT(buffer, "+BINP:");
1012
1013     res = sscanf(buffer, "\"%32[^\"]\"\r\n%n", numstr, &offset);
1014     if(res < 1)
1015     {
1016         return NULL;
1017     }
1018
1019     /* Abort in case offset not set because of format error */
1020     if (offset == 0)
1021     {
1022         APPL_TRACE_ERROR("%s: Format Error %s", __func__, buffer);
1023         return NULL;
1024     }
1025
1026     buffer += offset;
1027
1028     /* some phones might sent type as well, just skip it */
1029     AT_SKIP_REST(buffer);
1030
1031     AT_CHECK_RN(buffer);
1032
1033     bta_hf_client_handle_binp(numstr);
1034
1035     // check for OK response in end
1036     AT_CHECK_EVENT(buffer, "OK");
1037     AT_CHECK_RN(buffer);
1038
1039     bta_hf_client_handle_ok();
1040
1041     return buffer;
1042 }
1043
1044 static char *bta_hf_client_parse_clcc(char *buffer)
1045 {
1046     UINT16 idx, dir, status, mode, mpty;
1047     char numstr[33];     /* spec forces 32 chars, plus one for \0*/
1048     UINT16 type;
1049     int res;
1050     int offset = 0;
1051
1052     AT_CHECK_EVENT(buffer, "+CLCC:");
1053
1054     res = sscanf(buffer, "%hu,%hu,%hu,%hu,%hu%n",
1055                     &idx, &dir, &status, &mode, &mpty, &offset);
1056     if (res < 5)
1057     {
1058         return NULL;
1059     }
1060
1061     /* Abort in case offset not set because of format error */
1062     if (offset == 0)
1063     {
1064         APPL_TRACE_ERROR("%s: Format Error %s", __func__, buffer);
1065         return NULL;
1066     }
1067
1068     buffer += offset;
1069     offset = 0;
1070
1071     /* check optional part */
1072     if (*buffer == ',')
1073     {
1074         int res2 = sscanf(buffer, ",\"%32[^\"]\",%hu%n", numstr, &type, &offset);
1075         if (res2 < 0)
1076             return NULL;
1077
1078         if (res2 == 0)
1079         {
1080             res2 = sscanf(buffer, ",\"\",%hu%n", &type, &offset);
1081             if (res < 0)
1082                 return NULL;
1083
1084             /* numstr is not matched in second attempt, correct this */
1085             res2++;
1086             numstr[0] = '\0';
1087         }
1088
1089         if (res2 >= 2)
1090         {
1091             res += res2;
1092             /* Abort in case offset not set because of format error */
1093             if (offset == 0)
1094             {
1095                 APPL_TRACE_ERROR("%s: Format Error %s", __func__, buffer);
1096                 return NULL;
1097             }
1098
1099             buffer += offset;
1100         }
1101     }
1102
1103     /* Skip any remaing param,as they are not defined by BT HFP spec */
1104     AT_SKIP_REST(buffer);
1105     AT_CHECK_RN(buffer);
1106
1107     if (res > 6)
1108     {
1109         /* we also have last two optional parameters */
1110         bta_hf_client_handle_clcc(idx, dir, status, mode, mpty, numstr, type);
1111     }
1112     else
1113     {
1114         /* we didn't get the last two parameters */
1115         bta_hf_client_handle_clcc(idx, dir, status, mode, mpty, NULL, 0);
1116     }
1117
1118     // check for OK response in end
1119     AT_CHECK_EVENT(buffer, "OK");
1120     AT_CHECK_RN(buffer);
1121
1122     bta_hf_client_handle_ok();
1123     return buffer;
1124 }
1125
1126 static char *bta_hf_client_parse_cnum(char *buffer)
1127 {
1128     char numstr[33];     /* spec forces 32 chars, plus one for \0*/
1129     UINT16 type;
1130     UINT16 service = 0; /* 0 in case this optional parameter is not being sent */
1131     int res;
1132     int offset = 0;
1133
1134     AT_CHECK_EVENT(buffer, "+CNUM:");
1135
1136     res = sscanf(buffer, ",\"%32[^\"]\",%hu,,%hu%n", numstr, &type, &service, &offset);
1137     if(res < 0)
1138     {
1139         return NULL;
1140     }
1141
1142     if (res == 0)
1143     {
1144         res = sscanf(buffer, ",\"\",%hu,,%hu%n", &type, &service, &offset);
1145         if (res < 0)
1146         {
1147             return NULL;
1148         }
1149
1150         /* numstr is not matched in second attempt, correct this */
1151         res++;
1152         numstr[0] = '\0';
1153     }
1154
1155     if (res < 3)
1156     {
1157         return NULL;
1158     }
1159
1160     /* Abort in case offset not set because of format error */
1161     if (offset == 0)
1162     {
1163         APPL_TRACE_ERROR("%s: Format Error %s", __func__, buffer);
1164         return NULL;
1165     }
1166
1167     buffer += offset;
1168
1169     AT_CHECK_RN(buffer);
1170
1171     /* service is optional */
1172     if(res == 2)
1173     {
1174         bta_hf_client_handle_cnum(numstr, type, service);
1175         return buffer;
1176     }
1177
1178     if (service != 4 && service != 5)
1179     {
1180         return NULL;
1181     }
1182
1183     bta_hf_client_handle_cnum(numstr, type, service);
1184
1185     // check for OK response in end
1186     AT_CHECK_EVENT(buffer, "OK");
1187     AT_CHECK_RN(buffer);
1188
1189     bta_hf_client_handle_ok();
1190     return buffer;
1191 }
1192
1193 static char *bta_hf_client_parse_btrh(char *buffer)
1194 {
1195     UINT16 code = 0;
1196     int res;
1197     int offset;
1198
1199     AT_CHECK_EVENT(buffer, "+BTRH:");
1200
1201     res = sscanf(buffer, "%hu%n", &code, &offset);
1202     if(res < 1)
1203     {
1204         return NULL;
1205     }
1206
1207     buffer += offset;
1208
1209     AT_CHECK_RN(buffer);
1210
1211     bta_hf_client_handle_btrh(code);
1212     return buffer;
1213 }
1214
1215 static char *bta_hf_client_parse_busy(char *buffer)
1216 {
1217     AT_CHECK_EVENT(buffer, "BUSY");
1218     AT_CHECK_RN(buffer);
1219
1220     bta_hf_client_handle_error(BTA_HF_CLIENT_AT_RESULT_BUSY, 0);
1221
1222     return buffer;
1223 }
1224
1225 static char *bta_hf_client_parse_delayed(char *buffer)
1226 {
1227     AT_CHECK_EVENT(buffer, "DELAYED");
1228     AT_CHECK_RN(buffer);
1229
1230     bta_hf_client_handle_error(BTA_HF_CLIENT_AT_RESULT_DELAY, 0);
1231
1232     return buffer;
1233 }
1234
1235 static char *bta_hf_client_parse_no_carrier(char *buffer)
1236 {
1237     AT_CHECK_EVENT(buffer, "NO CARRIER");
1238     AT_CHECK_RN(buffer);
1239
1240     bta_hf_client_handle_error(BTA_HF_CLIENT_AT_RESULT_NO_CARRIER, 0);
1241
1242     return buffer;
1243 }
1244
1245 static char *bta_hf_client_parse_no_answer(char *buffer)
1246 {
1247     AT_CHECK_EVENT(buffer, "NO ANSWER");
1248     AT_CHECK_RN(buffer);
1249
1250     bta_hf_client_handle_error(BTA_HF_CLIENT_AT_RESULT_NO_ANSWER, 0);
1251
1252     return buffer;
1253 }
1254
1255 static char *bta_hf_client_parse_blacklisted(char *buffer)
1256 {
1257     AT_CHECK_EVENT(buffer, "BLACKLISTED");
1258     AT_CHECK_RN(buffer);
1259
1260     bta_hf_client_handle_error(BTA_HF_CLIENT_AT_RESULT_BLACKLISTED, 0);
1261
1262     return buffer;
1263 }
1264
1265 static char *bta_hf_client_skip_unknown(char *buffer)
1266 {
1267     char *start;
1268     char *tmp;
1269
1270     tmp = strstr(buffer, "\r\n");
1271     if (tmp == NULL)
1272     {
1273         return NULL;
1274     }
1275
1276     buffer += 2;
1277     start = buffer;
1278
1279     tmp = strstr(buffer, "\r\n");
1280     if (tmp == NULL)
1281     {
1282         return NULL;
1283     }
1284
1285     buffer = tmp + 2;
1286
1287     APPL_TRACE_DEBUG("%s %.*s", __FUNCTION__, buffer - start - 2, start);
1288
1289     return buffer;
1290 }
1291
1292
1293 /******************************************************************************
1294 **       SUPPORTED EVENT MESSAGES
1295 *******************************************************************************/
1296
1297 /* returned values are as follow:
1298  * != NULL && != buf  : match and parsed ok
1299  * == NULL            : match but parse failed
1300  * != NULL && == buf  : no match
1301  */
1302 typedef char* (*tBTA_HF_CLIENT_PARSER_CALLBACK)(char*);
1303
1304 static const tBTA_HF_CLIENT_PARSER_CALLBACK bta_hf_client_parser_cb[] =
1305 {
1306     bta_hf_client_parse_ok,
1307     bta_hf_client_parse_error,
1308     bta_hf_client_parse_ring,
1309     bta_hf_client_parse_brsf,
1310     bta_hf_client_parse_cind,
1311     bta_hf_client_parse_ciev,
1312     bta_hf_client_parse_chld,
1313     bta_hf_client_parse_bcs,
1314     bta_hf_client_parse_bsir,
1315     bta_hf_client_parse_cmeerror,
1316     bta_hf_client_parse_vgm,
1317     bta_hf_client_parse_vgme,
1318     bta_hf_client_parse_vgs,
1319     bta_hf_client_parse_vgse,
1320     bta_hf_client_parse_bvra,
1321     bta_hf_client_parse_clip,
1322     bta_hf_client_parse_ccwa,
1323     bta_hf_client_parse_cops,
1324     bta_hf_client_parse_binp,
1325     bta_hf_client_parse_clcc,
1326     bta_hf_client_parse_cnum,
1327     bta_hf_client_parse_btrh,
1328     bta_hf_client_parse_busy,
1329     bta_hf_client_parse_delayed,
1330     bta_hf_client_parse_no_carrier,
1331     bta_hf_client_parse_no_answer,
1332     bta_hf_client_parse_blacklisted,
1333     bta_hf_client_skip_unknown
1334 };
1335
1336 /* calculate supported event list length */
1337 static const UINT16 bta_hf_client_psraser_cb_count =
1338         sizeof(bta_hf_client_parser_cb) / sizeof(bta_hf_client_parser_cb[0]);
1339
1340 #ifdef BTA_HF_CLIENT_AT_DUMP
1341 static void bta_hf_client_dump_at(void)
1342 {
1343     char dump[(4 * BTA_HF_CLIENT_AT_PARSER_MAX_LEN) + 1];
1344     char *p1, *p2;
1345
1346     p1 = bta_hf_client_cb.scb.at_cb.buf;
1347     p2 = dump;
1348
1349     while (*p1 != '\0')
1350     {
1351         if (*p1 == '\r')
1352         {
1353             strlcpy(p2, "<cr>", 4);
1354             p2 += 4;
1355         }
1356         else if (*p1 == '\n')
1357         {
1358             strlcpy(p2, "<lf>", 4);
1359             p2 += 4;
1360         }
1361         else
1362         {
1363             *p2 = *p1;
1364             p2++;
1365         }
1366         p1++;
1367     }
1368
1369     *p2 = '\0';
1370
1371     APPL_TRACE_DEBUG("%s %s", __FUNCTION__, dump);
1372 }
1373 #endif
1374
1375 static void bta_hf_client_at_parse_start(void)
1376 {
1377     char *buf = bta_hf_client_cb.scb.at_cb.buf;
1378
1379     APPL_TRACE_DEBUG("%s", __FUNCTION__);
1380
1381 #ifdef BTA_HF_CLIENT_AT_DUMP
1382     bta_hf_client_dump_at();
1383 #endif
1384
1385     while(*buf != '\0')
1386     {
1387         int i;
1388         char *tmp = NULL;
1389
1390         for(i = 0; i < bta_hf_client_psraser_cb_count; i++)
1391         {
1392             tmp = bta_hf_client_parser_cb[i](buf);
1393             if (tmp == NULL)
1394             {
1395                 APPL_TRACE_ERROR("HFPCient: AT event/reply parsing failed, skipping");
1396                 tmp = bta_hf_client_skip_unknown(buf);
1397                 break;
1398             }
1399
1400             /* matched or unknown skipped, if unknown failed tmp is NULL so
1401                this is also handled */
1402             if (tmp != buf)
1403             {
1404                 buf = tmp;
1405                 break;
1406             }
1407         }
1408
1409         /* could not skip unknown (received garbage?)... disconnect */
1410         if (tmp == NULL)
1411         {
1412             APPL_TRACE_ERROR("HFPCient: could not skip unknown AT event, disconnecting");
1413             bta_hf_client_at_reset();
1414             bta_hf_client_sm_execute(BTA_HF_CLIENT_API_CLOSE_EVT, NULL);
1415             return;
1416         }
1417
1418         buf = tmp;
1419     }
1420 }
1421
1422 static BOOLEAN bta_hf_client_check_at_complete(void)
1423 {
1424     BOOLEAN ret = FALSE;
1425     tBTA_HF_CLIENT_AT_CB *at_cb = &bta_hf_client_cb.scb.at_cb;
1426
1427     if (at_cb->offset >= BTA_HF_CLIENT_AT_EVENT_MIN_LEN)
1428     {
1429         if (at_cb->buf[at_cb->offset - 2] == '\r' && at_cb->buf[at_cb->offset - 1] == '\n')
1430         {
1431             ret = TRUE;
1432         }
1433     }
1434
1435     APPL_TRACE_DEBUG("%s %d", __FUNCTION__, ret);
1436
1437     return ret;
1438 }
1439
1440 static void bta_hf_client_at_clear_buf(void)
1441 {
1442     memset(bta_hf_client_cb.scb.at_cb.buf, 0, sizeof(bta_hf_client_cb.scb.at_cb.buf));
1443     bta_hf_client_cb.scb.at_cb.offset = 0;
1444 }
1445
1446 /******************************************************************************
1447 **
1448 **          MAIN PARSING FUNCTION
1449 **
1450 **
1451 *******************************************************************************/
1452 void bta_hf_client_at_parse(char *buf, unsigned int len)
1453 {
1454     APPL_TRACE_DEBUG("%s offset: %u len: %u", __FUNCTION__, bta_hf_client_cb.scb.at_cb.offset, len);
1455
1456     if (len + bta_hf_client_cb.scb.at_cb.offset > BTA_HF_CLIENT_AT_PARSER_MAX_LEN)
1457     {
1458         char tmp_buff[BTA_HF_CLIENT_AT_PARSER_MAX_LEN];
1459         unsigned int tmp = bta_hf_client_cb.scb.at_cb.offset;
1460         unsigned int space_left = BTA_HF_CLIENT_AT_PARSER_MAX_LEN - bta_hf_client_cb.scb.at_cb.offset;
1461
1462         APPL_TRACE_DEBUG("%s overrun, trying to recover", __FUNCTION__);
1463
1464         /* fill up parser buffer */
1465         memcpy(bta_hf_client_cb.scb.at_cb.buf + bta_hf_client_cb.scb.at_cb.offset, buf, space_left);
1466         len -= space_left;
1467         buf += space_left;
1468         bta_hf_client_cb.scb.at_cb.offset += space_left;
1469
1470         /* find end of last complete command before proceeding */
1471         while(bta_hf_client_check_at_complete() == FALSE)
1472         {
1473             if (bta_hf_client_cb.scb.at_cb.offset == 0) {
1474                 APPL_TRACE_ERROR("HFPClient: AT parser buffer overrun, disconnecting");
1475
1476                 bta_hf_client_at_reset();
1477                 bta_hf_client_sm_execute(BTA_HF_CLIENT_API_CLOSE_EVT, NULL);
1478                 return;
1479             }
1480
1481             bta_hf_client_cb.scb.at_cb.offset--;
1482         }
1483
1484         /* cut buffer to complete AT event and keep cut data */
1485         tmp += space_left - bta_hf_client_cb.scb.at_cb.offset;
1486         memcpy(tmp_buff, bta_hf_client_cb.scb.at_cb.buf + bta_hf_client_cb.scb.at_cb.offset, tmp);
1487         bta_hf_client_cb.scb.at_cb.buf[bta_hf_client_cb.scb.at_cb.offset] = '\0';
1488
1489         /* parse */
1490         bta_hf_client_at_parse_start();
1491         bta_hf_client_at_clear_buf();
1492
1493         /* recover cut data */
1494         memcpy(bta_hf_client_cb.scb.at_cb.buf, tmp_buff, tmp);
1495         bta_hf_client_cb.scb.at_cb.offset += tmp;
1496     }
1497
1498     memcpy(bta_hf_client_cb.scb.at_cb.buf + bta_hf_client_cb.scb.at_cb.offset, buf, len);
1499     bta_hf_client_cb.scb.at_cb.offset += len;
1500
1501     /* If last event is complete, parsing can be started */
1502     if (bta_hf_client_check_at_complete() == TRUE)
1503     {
1504         bta_hf_client_at_parse_start();
1505         bta_hf_client_at_clear_buf();
1506     }
1507 }
1508
1509 void bta_hf_client_send_at_brsf(void)
1510 {
1511     char buf[BTA_HF_CLIENT_AT_MAX_LEN];
1512     int at_len;
1513
1514     APPL_TRACE_DEBUG("%s", __FUNCTION__);
1515
1516     at_len = snprintf(buf, sizeof(buf), "AT+BRSF=%u\r", bta_hf_client_cb.scb.features);
1517     if (at_len < 0)
1518     {
1519         APPL_TRACE_ERROR("%s: AT command Framing error", __func__);
1520         return;
1521     }
1522
1523     bta_hf_client_send_at(BTA_HF_CLIENT_AT_BRSF , buf, at_len);
1524 }
1525
1526 void bta_hf_client_send_at_bac(void)
1527 {
1528     char *buf;
1529
1530     APPL_TRACE_DEBUG("%s", __FUNCTION__);
1531
1532     if (bta_hf_client_cb.msbc_enabled)
1533     {
1534         buf = "AT+BAC=1,2\r";
1535     }
1536     else
1537     {
1538         buf = "AT+BAC=1\r";
1539     }
1540
1541     bta_hf_client_send_at(BTA_HF_CLIENT_AT_BAC, buf, strlen(buf));
1542 }
1543
1544 void bta_hf_client_send_at_bcs(UINT32 codec)
1545 {
1546     char buf[BTA_HF_CLIENT_AT_MAX_LEN];
1547     int at_len;
1548
1549     APPL_TRACE_DEBUG("%s", __FUNCTION__);
1550
1551     at_len = snprintf(buf, sizeof(buf), "AT+BCS=%u\r", codec);
1552     if (at_len < 0)
1553     {
1554         APPL_TRACE_ERROR("%s: AT command Framing error", __func__);
1555         return;
1556     }
1557
1558     bta_hf_client_send_at(BTA_HF_CLIENT_AT_BCS, buf, at_len);
1559 }
1560
1561 void bta_hf_client_send_at_cind(BOOLEAN status)
1562 {
1563     char *buf;
1564     tBTA_HF_CLIENT_AT_CMD cmd;
1565
1566     APPL_TRACE_DEBUG("%s", __FUNCTION__);
1567
1568     if (status)
1569     {
1570         buf = "AT+CIND?\r";
1571         cmd = BTA_HF_CLIENT_AT_CIND_STATUS;
1572     }
1573     else
1574     {
1575         buf = "AT+CIND=?\r";
1576         cmd = BTA_HF_CLIENT_AT_CIND;
1577     }
1578
1579     bta_hf_client_send_at(cmd, buf, strlen(buf));
1580 }
1581
1582 void bta_hf_client_send_at_cmer(BOOLEAN activate)
1583 {
1584     char *buf;
1585
1586     APPL_TRACE_DEBUG("%s", __FUNCTION__);
1587
1588     if (activate)
1589         buf = "AT+CMER=3,0,0,1\r";
1590     else
1591         buf = "AT+CMER=3,0,0,0\r";
1592
1593     bta_hf_client_send_at(BTA_HF_CLIENT_AT_CMER, buf, strlen(buf));
1594 }
1595
1596 void bta_hf_client_send_at_chld(char cmd, UINT32 idx)
1597 {
1598     char buf[BTA_HF_CLIENT_AT_MAX_LEN];
1599     int at_len;
1600
1601     APPL_TRACE_DEBUG("%s", __FUNCTION__);
1602
1603     if (idx > 0)
1604         at_len = snprintf(buf, sizeof(buf), "AT+CHLD=%c%u\r", cmd, idx);
1605     else
1606         at_len = snprintf(buf, sizeof(buf), "AT+CHLD=%c\r", cmd);
1607
1608     if (at_len < 0)
1609     {
1610         APPL_TRACE_ERROR("%s: AT command Framing error", __func__);
1611         return;
1612     }
1613
1614     bta_hf_client_send_at(BTA_HF_CLIENT_AT_CHLD, buf, at_len);
1615 }
1616
1617 void bta_hf_client_send_at_clip(BOOLEAN activate)
1618 {
1619     char *buf;
1620
1621     APPL_TRACE_DEBUG("%s", __FUNCTION__);
1622
1623     if (activate)
1624         buf = "AT+CLIP=1\r";
1625     else
1626         buf = "AT+CLIP=0\r";
1627
1628     bta_hf_client_send_at(BTA_HF_CLIENT_AT_CLIP, buf, strlen(buf));
1629 }
1630
1631 void bta_hf_client_send_at_ccwa(BOOLEAN activate)
1632 {
1633     char *buf;
1634
1635     APPL_TRACE_DEBUG("%s", __FUNCTION__);
1636
1637     if (activate)
1638         buf = "AT+CCWA=1\r";
1639     else
1640         buf = "AT+CCWA=0\r";
1641
1642     bta_hf_client_send_at(BTA_HF_CLIENT_AT_CCWA, buf, strlen(buf));
1643 }
1644
1645
1646 void bta_hf_client_send_at_cmee(BOOLEAN activate)
1647 {
1648     char *buf;
1649
1650     APPL_TRACE_DEBUG("%s", __FUNCTION__);
1651
1652     if (activate)
1653         buf = "AT+CMEE=1\r";
1654     else
1655         buf = "AT+CMEE=0\r";
1656
1657     bta_hf_client_send_at(BTA_HF_CLIENT_AT_CMEE, buf, strlen(buf));
1658 }
1659
1660 void bta_hf_client_send_at_cops(BOOLEAN query)
1661 {
1662     char *buf;
1663
1664     APPL_TRACE_DEBUG("%s", __FUNCTION__);
1665
1666     if (query)
1667         buf = "AT+COPS?\r";
1668     else
1669         buf = "AT+COPS=3,0\r";
1670
1671     bta_hf_client_send_at(BTA_HF_CLIENT_AT_COPS, buf, strlen(buf));
1672 }
1673
1674 void bta_hf_client_send_at_clcc(void)
1675 {
1676     char *buf;
1677
1678     APPL_TRACE_DEBUG("%s", __FUNCTION__);
1679
1680     buf = "AT+CLCC\r";
1681
1682     bta_hf_client_send_at(BTA_HF_CLIENT_AT_CLCC, buf, strlen(buf));
1683 }
1684
1685 void bta_hf_client_send_at_bvra(BOOLEAN enable)
1686 {
1687     char *buf;
1688
1689     APPL_TRACE_DEBUG("%s", __FUNCTION__);
1690
1691     if (enable)
1692         buf = "AT+BVRA=1\r";
1693     else
1694         buf = "AT+BVRA=0\r";
1695
1696     bta_hf_client_send_at(BTA_HF_CLIENT_AT_BVRA, buf, strlen(buf));
1697 }
1698
1699 void bta_hf_client_send_at_vgs(UINT32 volume)
1700 {
1701     char buf[BTA_HF_CLIENT_AT_MAX_LEN];
1702     int at_len;
1703
1704     APPL_TRACE_DEBUG("%s", __FUNCTION__);
1705
1706     at_len = snprintf(buf, sizeof(buf), "AT+VGS=%u\r", volume);
1707     if (at_len < 0)
1708     {
1709         APPL_TRACE_ERROR("%s: AT command Framing error", __func__);
1710         return;
1711     }
1712
1713     bta_hf_client_send_at(BTA_HF_CLIENT_AT_VGS, buf, at_len);
1714 }
1715
1716 void bta_hf_client_send_at_vgm(UINT32 volume)
1717 {
1718     char buf[BTA_HF_CLIENT_AT_MAX_LEN];
1719     int at_len;
1720
1721     APPL_TRACE_DEBUG("%s", __FUNCTION__);
1722
1723     at_len = snprintf(buf, sizeof(buf), "AT+VGM=%u\r", volume);
1724     if (at_len < 0)
1725     {
1726         APPL_TRACE_ERROR("%s: AT command Framing error", __func__);
1727         return;
1728     }
1729
1730     bta_hf_client_send_at(BTA_HF_CLIENT_AT_VGM, buf, at_len);
1731 }
1732
1733 void bta_hf_client_send_at_atd(char *number, UINT32 memory)
1734 {
1735     char buf[BTA_HF_CLIENT_AT_MAX_LEN];
1736     int at_len;
1737
1738     APPL_TRACE_DEBUG("%s", __FUNCTION__);
1739
1740     if (number[0] != '\0') {
1741         at_len = snprintf(buf, sizeof(buf), "ATD%s;\r", number);
1742     } else {
1743         at_len = snprintf(buf, sizeof(buf), "ATD>%u;\r", memory);
1744     }
1745
1746     if (at_len < 0) {
1747         APPL_TRACE_ERROR("%s: error preparing ATD command", __func__);
1748         return;
1749     }
1750
1751     at_len = MIN((size_t)at_len, sizeof(buf));
1752
1753     if (at_len < 0)
1754     {
1755         APPL_TRACE_ERROR("%s: AT command Framing error", __func__);
1756         return;
1757     }
1758     bta_hf_client_send_at(BTA_HF_CLIENT_AT_ATD, buf, at_len);
1759 }
1760
1761 void bta_hf_client_send_at_bldn(void)
1762 {
1763     char *buf;
1764
1765     APPL_TRACE_DEBUG("%s", __FUNCTION__);
1766
1767     buf = "AT+BLDN\r";
1768
1769     bta_hf_client_send_at(BTA_HF_CLIENT_AT_BLDN, buf, strlen(buf));
1770 }
1771
1772 void bta_hf_client_send_at_ata(void)
1773 {
1774     char *buf;
1775
1776     APPL_TRACE_DEBUG("%s", __FUNCTION__);
1777
1778     buf = "ATA\r";
1779
1780     bta_hf_client_send_at(BTA_HF_CLIENT_AT_ATA, buf, strlen(buf));
1781 }
1782
1783 void bta_hf_client_send_at_chup(void)
1784 {
1785     char *buf;
1786
1787     APPL_TRACE_DEBUG("%s", __FUNCTION__);
1788
1789     buf = "AT+CHUP\r";
1790
1791     bta_hf_client_send_at(BTA_HF_CLIENT_AT_CHUP, buf, strlen(buf));
1792 }
1793
1794 void bta_hf_client_send_at_btrh(BOOLEAN query, UINT32 val)
1795 {
1796     char buf[BTA_HF_CLIENT_AT_MAX_LEN];
1797     int at_len;
1798
1799     APPL_TRACE_DEBUG("%s", __FUNCTION__);
1800
1801     if (query == TRUE)
1802     {
1803         at_len = snprintf(buf, sizeof(buf), "AT+BTRH?\r");
1804     }
1805     else
1806     {
1807         at_len = snprintf(buf, sizeof(buf), "AT+BTRH=%u\r", val);
1808     }
1809
1810     if (at_len < 0)
1811     {
1812         APPL_TRACE_ERROR("%s: AT command Framing error", __func__);
1813         return;
1814     }
1815
1816     bta_hf_client_send_at(BTA_HF_CLIENT_AT_BTRH, buf, at_len);
1817 }
1818
1819 void bta_hf_client_send_at_vts(char code)
1820 {
1821     char buf[BTA_HF_CLIENT_AT_MAX_LEN];
1822     int at_len;
1823
1824     APPL_TRACE_DEBUG("%s", __FUNCTION__);
1825
1826     at_len = snprintf(buf, sizeof(buf), "AT+VTS=%c\r", code);
1827
1828     if (at_len < 0)
1829     {
1830         APPL_TRACE_ERROR("%s: AT command Framing error", __func__);
1831         return;
1832     }
1833
1834     bta_hf_client_send_at(BTA_HF_CLIENT_AT_VTS, buf, at_len);
1835 }
1836
1837 void bta_hf_client_send_at_bcc(void)
1838 {
1839     char *buf;
1840
1841     APPL_TRACE_DEBUG("%s", __FUNCTION__);
1842
1843     buf = "AT+BCC\r";
1844
1845     bta_hf_client_send_at(BTA_HF_CLIENT_AT_BCC, buf, strlen(buf));
1846 }
1847
1848 void bta_hf_client_send_at_cnum(void)
1849 {
1850     char *buf;
1851
1852     APPL_TRACE_DEBUG("%s", __FUNCTION__);
1853
1854     buf = "AT+CNUM\r";
1855
1856     bta_hf_client_send_at(BTA_HF_CLIENT_AT_CNUM, buf, strlen(buf));
1857 }
1858
1859 void bta_hf_client_send_at_nrec(void)
1860 {
1861     char *buf;
1862
1863     APPL_TRACE_DEBUG("%s", __FUNCTION__);
1864
1865     if (!(bta_hf_client_cb.scb.peer_features & BTA_HF_CLIENT_PEER_FEAT_ECNR))
1866     {
1867         APPL_TRACE_ERROR("%s: Remote does not support NREC.", __FUNCTION__);
1868         return;
1869     }
1870
1871     buf = "AT+NREC=0\r";
1872
1873     bta_hf_client_send_at(BTA_HF_CLIENT_AT_NREC, buf, strlen(buf));
1874 }
1875
1876 void bta_hf_client_send_at_binp(UINT32 action)
1877 {
1878     char buf[BTA_HF_CLIENT_AT_MAX_LEN];
1879     int at_len;
1880
1881     APPL_TRACE_DEBUG("%s", __FUNCTION__);
1882
1883     at_len = snprintf(buf, sizeof(buf), "AT+BINP=%u\r", action);
1884
1885     if (at_len < 0)
1886     {
1887         APPL_TRACE_ERROR("%s: AT command Framing error", __func__);
1888         return;
1889     }
1890
1891     bta_hf_client_send_at(BTA_HF_CLIENT_AT_BINP, buf, at_len);
1892 }
1893
1894 void bta_hf_client_send_at_bia(void)
1895 {
1896     char buf[BTA_HF_CLIENT_AT_MAX_LEN];
1897     int at_len;
1898     int i;
1899
1900     APPL_TRACE_DEBUG("%s", __FUNCTION__);
1901     if (bta_hf_client_cb.scb.peer_version < HFP_VERSION_1_6)
1902     {
1903         APPL_TRACE_DEBUG("Remote does not Support AT+BIA");
1904         return;
1905     }
1906
1907     at_len = snprintf(buf, sizeof(buf), "AT+BIA=");
1908
1909     for(i = 0; i < BTA_HF_CLIENT_AT_INDICATOR_COUNT; i++)
1910     {
1911         int sup = bta_hf_client_cb.scb.at_cb.indicator_lookup[i] == -1 ? 0 : 1;
1912
1913         at_len += snprintf(buf + at_len, sizeof(buf) - at_len, "%u,", sup);
1914     }
1915
1916     buf[at_len - 1] = '\r';
1917
1918     if (at_len < 0)
1919     {
1920         APPL_TRACE_ERROR("%s: AT command Framing error", __func__);
1921         return;
1922     }
1923
1924     bta_hf_client_send_at(BTA_HF_CLIENT_AT_BIA, buf, at_len);
1925 }
1926
1927 void bta_hf_client_at_init(void)
1928 {
1929     alarm_free(bta_hf_client_cb.scb.at_cb.resp_timer);
1930     alarm_free(bta_hf_client_cb.scb.at_cb.hold_timer);
1931     memset(&bta_hf_client_cb.scb.at_cb, 0, sizeof(tBTA_HF_CLIENT_AT_CB));
1932     bta_hf_client_cb.scb.at_cb.resp_timer =
1933       alarm_new("bta_hf_client.scb_at_resp_timer");
1934     bta_hf_client_cb.scb.at_cb.hold_timer =
1935       alarm_new("bta_hf_client.scb_at_hold_timer");
1936     bta_hf_client_at_reset();
1937 }
1938
1939 void bta_hf_client_at_reset(void)
1940 {
1941     int i;
1942
1943     bta_hf_client_stop_at_resp_timer();
1944     bta_hf_client_stop_at_hold_timer();
1945
1946     bta_hf_client_clear_queued_at();
1947
1948     bta_hf_client_at_clear_buf();
1949
1950     for (i = 0; i < BTA_HF_CLIENT_AT_INDICATOR_COUNT; i++)
1951     {
1952         bta_hf_client_cb.scb.at_cb.indicator_lookup[i] = -1;
1953     }
1954
1955     bta_hf_client_cb.scb.at_cb.current_cmd = BTA_HF_CLIENT_AT_NONE;
1956 }