1 /* 2 * Copyright (C) 2014 BlueKitchen GmbH 3 * 4 * Redistribution and use in source and binary forms, with or without 5 * modification, are permitted provided that the following conditions 6 * are met: 7 * 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 3. Neither the name of the copyright holders nor the names of 14 * contributors may be used to endorse or promote products derived 15 * from this software without specific prior written permission. 16 * 4. Any redistribution, use, or modification is done solely for 17 * personal benefit and not for any commercial purpose or for 18 * monetary gain. 19 * 20 * THIS SOFTWARE IS PROVIDED BY BLUEKITCHEN GMBH AND CONTRIBUTORS 21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 22 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 23 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL MATTHIAS 24 * RINGWALD OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 25 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 26 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS 27 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 28 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 29 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF 30 * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 31 * SUCH DAMAGE. 32 * 33 * Please inquire about commercial licensing options at 34 * [email protected] 35 * 36 */ 37 38 #define BTSTACK_FILE__ "hfp.c" 39 40 41 #include "btstack_config.h" 42 43 #include <stdint.h> 44 #include <stdio.h> 45 #include <stdlib.h> 46 #include <string.h> 47 #include <inttypes.h> 48 49 #include "bluetooth_sdp.h" 50 #include "btstack_debug.h" 51 #include "btstack_event.h" 52 #include "btstack_memory.h" 53 #include "btstack_run_loop.h" 54 #include "classic/core.h" 55 #include "classic/sdp_client_rfcomm.h" 56 #include "classic/sdp_server.h" 57 #include "classic/sdp_util.h" 58 #include "hci.h" 59 #include "hci_cmd.h" 60 #include "hci_dump.h" 61 #include "l2cap.h" 62 63 #define HFP_HF_FEATURES_SIZE 10 64 #define HFP_AG_FEATURES_SIZE 12 65 66 67 static const char * hfp_hf_features[] = { 68 "EC and/or NR function", 69 "Three-way calling", 70 "CLI presentation capability", 71 "Voice recognition activation", 72 "Remote volume control", 73 74 "Enhanced call status", 75 "Enhanced call control", 76 77 "Codec negotiation", 78 79 "HF Indicators", 80 "eSCO S4 (and T2) Settings Supported", 81 "Reserved for future definition" 82 }; 83 84 static const char * hfp_ag_features[] = { 85 "Three-way calling", 86 "EC and/or NR function", 87 "Voice recognition function", 88 "In-band ring tone capability", 89 "Attach a number to a voice tag", 90 "Ability to reject a call", 91 "Enhanced call status", 92 "Enhanced call control", 93 "Extended Error Result Codes", 94 "Codec negotiation", 95 "HF Indicators", 96 "eSCO S4 (and T2) Settings Supported", 97 "Reserved for future definition" 98 }; 99 100 static const char * hfp_enhanced_call_dir[] = { 101 "outgoing", 102 "incoming" 103 }; 104 105 static const char * hfp_enhanced_call_status[] = { 106 "active", 107 "held", 108 "outgoing dialing", 109 "outgoing alerting", 110 "incoming", 111 "incoming waiting", 112 "call held by response and hold" 113 }; 114 115 static const char * hfp_enhanced_call_mode[] = { 116 "voice", 117 "data", 118 "fax" 119 }; 120 121 static const char * hfp_enhanced_call_mpty[] = { 122 "not a conference call", 123 "conference call" 124 }; 125 126 const char * hfp_enhanced_call_dir2str(uint16_t index){ 127 if (index <= HFP_ENHANCED_CALL_DIR_INCOMING) return hfp_enhanced_call_dir[index]; 128 return "not defined"; 129 } 130 131 const char * hfp_enhanced_call_status2str(uint16_t index){ 132 if (index <= HFP_ENHANCED_CALL_STATUS_CALL_HELD_BY_RESPONSE_AND_HOLD) return hfp_enhanced_call_status[index]; 133 return "not defined"; 134 } 135 136 const char * hfp_enhanced_call_mode2str(uint16_t index){ 137 if (index <= HFP_ENHANCED_CALL_MODE_FAX) return hfp_enhanced_call_mode[index]; 138 return "not defined"; 139 } 140 141 const char * hfp_enhanced_call_mpty2str(uint16_t index){ 142 if (index <= HFP_ENHANCED_CALL_MPTY_CONFERENCE_CALL) return hfp_enhanced_call_mpty[index]; 143 return "not defined"; 144 } 145 146 static void parse_sequence(hfp_connection_t * context); 147 148 static btstack_linked_list_t hfp_connections = NULL; 149 150 static btstack_packet_handler_t hfp_hf_callback; 151 static btstack_packet_handler_t hfp_ag_callback; 152 153 static btstack_packet_handler_t hfp_hf_rfcomm_packet_handler; 154 static btstack_packet_handler_t hfp_ag_rfcomm_packet_handler; 155 156 static void (*hfp_hf_run_for_context)(hfp_connection_t * hfp_connection); 157 158 static hfp_connection_t * sco_establishment_active; 159 160 const char * hfp_hf_feature(int index){ 161 if (index > HFP_HF_FEATURES_SIZE){ 162 return hfp_hf_features[HFP_HF_FEATURES_SIZE]; 163 } 164 return hfp_hf_features[index]; 165 } 166 167 const char * hfp_ag_feature(int index){ 168 if (index > HFP_AG_FEATURES_SIZE){ 169 return hfp_ag_features[HFP_AG_FEATURES_SIZE]; 170 } 171 return hfp_ag_features[index]; 172 } 173 174 int send_str_over_rfcomm(uint16_t cid, char * command){ 175 if (!rfcomm_can_send_packet_now(cid)) return 1; 176 log_info("HFP_TX %s", command); 177 int err = rfcomm_send(cid, (uint8_t*) command, strlen(command)); 178 if (err){ 179 log_error("rfcomm_send -> error 0x%02x \n", err); 180 } 181 return 1; 182 } 183 184 int hfp_supports_codec(uint8_t codec, int codecs_nr, uint8_t * codecs){ 185 186 // mSBC requires support for eSCO connections 187 if ((codec == HFP_CODEC_MSBC) && !hci_extended_sco_link_supported()) return 0; 188 189 int i; 190 for (i = 0; i < codecs_nr; i++){ 191 if (codecs[i] != codec) continue; 192 return 1; 193 } 194 return 0; 195 } 196 197 void hfp_hf_drop_mSBC_if_eSCO_not_supported(uint8_t * codecs, uint8_t * codecs_nr){ 198 if (hci_extended_sco_link_supported()) return; 199 uint8_t tmp_codecs[HFP_MAX_NUM_CODECS]; 200 int i; 201 int tmp_codec_nr = 0; 202 for (i=0; i < *codecs_nr; i++){ 203 if (codecs[i] == HFP_CODEC_MSBC) continue; 204 tmp_codecs[tmp_codec_nr++] = codecs[i]; 205 } 206 *codecs_nr = tmp_codec_nr; 207 memcpy(codecs, tmp_codecs, tmp_codec_nr); 208 } 209 210 // UTILS 211 int get_bit(uint16_t bitmap, int position){ 212 return (bitmap >> position) & 1; 213 } 214 215 int store_bit(uint32_t bitmap, int position, uint8_t value){ 216 if (value){ 217 bitmap |= 1 << position; 218 } else { 219 bitmap &= ~ (1 << position); 220 } 221 return bitmap; 222 } 223 224 int join(char * buffer, int buffer_size, uint8_t * values, int values_nr){ 225 if (buffer_size < (values_nr * 3)) return 0; 226 int i; 227 int offset = 0; 228 for (i = 0; i < (values_nr-1); i++) { 229 offset += snprintf(buffer+offset, buffer_size-offset, "%d,", values[i]); // puts string into buffer 230 } 231 if (i<values_nr){ 232 offset += snprintf(buffer+offset, buffer_size-offset, "%d", values[i]); 233 } 234 return offset; 235 } 236 237 int join_bitmap(char * buffer, int buffer_size, uint32_t values, int values_nr){ 238 if (buffer_size < (values_nr * 3)) return 0; 239 240 int i; 241 int offset = 0; 242 for (i = 0; i < (values_nr-1); i++) { 243 offset += snprintf(buffer+offset, buffer_size-offset, "%d,", get_bit(values,i)); // puts string into buffer 244 } 245 246 if (i<values_nr){ 247 offset += snprintf(buffer+offset, buffer_size-offset, "%d", get_bit(values,i)); 248 } 249 return offset; 250 } 251 252 static void hfp_emit_event_for_context(hfp_connection_t * hfp_connection, uint8_t * packet, uint16_t size){ 253 if (!hfp_connection) return; 254 btstack_packet_handler_t callback = NULL; 255 switch (hfp_connection->local_role){ 256 case HFP_ROLE_HF: 257 callback = hfp_hf_callback; 258 break; 259 case HFP_ROLE_AG: 260 callback = hfp_ag_callback; 261 break; 262 default: 263 return; 264 } 265 (*callback)(HCI_EVENT_PACKET, 0, packet, size); 266 } 267 268 void hfp_emit_simple_event(hfp_connection_t * hfp_connection, uint8_t event_subtype){ 269 uint8_t event[3]; 270 event[0] = HCI_EVENT_HFP_META; 271 event[1] = sizeof(event) - 2; 272 event[2] = event_subtype; 273 hfp_emit_event_for_context(hfp_connection, event, sizeof(event)); 274 } 275 276 void hfp_emit_event(hfp_connection_t * hfp_connection, uint8_t event_subtype, uint8_t value){ 277 uint8_t event[4]; 278 event[0] = HCI_EVENT_HFP_META; 279 event[1] = sizeof(event) - 2; 280 event[2] = event_subtype; 281 event[3] = value; // status 0 == OK 282 hfp_emit_event_for_context(hfp_connection, event, sizeof(event)); 283 } 284 285 void hfp_emit_slc_connection_event(hfp_connection_t * hfp_connection, uint8_t status, hci_con_handle_t con_handle, bd_addr_t addr){ 286 uint8_t event[12]; 287 int pos = 0; 288 event[pos++] = HCI_EVENT_HFP_META; 289 event[pos++] = sizeof(event) - 2; 290 event[pos++] = HFP_SUBEVENT_SERVICE_LEVEL_CONNECTION_ESTABLISHED; 291 event[pos++] = status; // status 0 == OK 292 little_endian_store_16(event, pos, con_handle); 293 pos += 2; 294 reverse_bd_addr(addr,&event[pos]); 295 pos += 6; 296 hfp_emit_event_for_context(hfp_connection, event, sizeof(event)); 297 } 298 299 static void hfp_emit_sco_event(hfp_connection_t * hfp_connection, uint8_t status, hci_con_handle_t con_handle, bd_addr_t addr, uint8_t negotiated_codec){ 300 uint8_t event[13]; 301 int pos = 0; 302 event[pos++] = HCI_EVENT_HFP_META; 303 event[pos++] = sizeof(event) - 2; 304 event[pos++] = HFP_SUBEVENT_AUDIO_CONNECTION_ESTABLISHED; 305 event[pos++] = status; // status 0 == OK 306 little_endian_store_16(event, pos, con_handle); 307 pos += 2; 308 reverse_bd_addr(addr,&event[pos]); 309 pos += 6; 310 event[pos++] = negotiated_codec; 311 hfp_emit_event_for_context(hfp_connection, event, sizeof(event)); 312 } 313 314 void hfp_emit_string_event(hfp_connection_t * hfp_connection, uint8_t event_subtype, const char * value){ 315 uint8_t event[40]; 316 event[0] = HCI_EVENT_HFP_META; 317 event[1] = sizeof(event) - 2; 318 event[2] = event_subtype; 319 uint16_t size = btstack_min(strlen(value), sizeof(event) - 4); 320 strncpy((char*)&event[3], value, size); 321 event[3 + size] = 0; 322 hfp_emit_event_for_context(hfp_connection, event, sizeof(event)); 323 } 324 325 btstack_linked_list_t * hfp_get_connections(void){ 326 return (btstack_linked_list_t *) &hfp_connections; 327 } 328 329 hfp_connection_t * get_hfp_connection_context_for_rfcomm_cid(uint16_t cid){ 330 btstack_linked_list_iterator_t it; 331 btstack_linked_list_iterator_init(&it, hfp_get_connections()); 332 while (btstack_linked_list_iterator_has_next(&it)){ 333 hfp_connection_t * hfp_connection = (hfp_connection_t *)btstack_linked_list_iterator_next(&it); 334 if (hfp_connection->rfcomm_cid == cid){ 335 return hfp_connection; 336 } 337 } 338 return NULL; 339 } 340 341 hfp_connection_t * get_hfp_connection_context_for_bd_addr(bd_addr_t bd_addr, hfp_role_t hfp_role){ 342 btstack_linked_list_iterator_t it; 343 btstack_linked_list_iterator_init(&it, hfp_get_connections()); 344 while (btstack_linked_list_iterator_has_next(&it)){ 345 hfp_connection_t * hfp_connection = (hfp_connection_t *)btstack_linked_list_iterator_next(&it); 346 if ((memcmp(hfp_connection->remote_addr, bd_addr, 6) == 0) && (hfp_connection->local_role == hfp_role)) { 347 return hfp_connection; 348 } 349 } 350 return NULL; 351 } 352 353 hfp_connection_t * get_hfp_connection_context_for_sco_handle(uint16_t handle, hfp_role_t hfp_role){ 354 btstack_linked_list_iterator_t it; 355 btstack_linked_list_iterator_init(&it, hfp_get_connections()); 356 while (btstack_linked_list_iterator_has_next(&it)){ 357 hfp_connection_t * hfp_connection = (hfp_connection_t *)btstack_linked_list_iterator_next(&it); 358 if ((hfp_connection->sco_handle == handle) && (hfp_connection->local_role == hfp_role)){ 359 return hfp_connection; 360 } 361 } 362 return NULL; 363 } 364 365 hfp_connection_t * get_hfp_connection_context_for_acl_handle(uint16_t handle, hfp_role_t hfp_role){ 366 btstack_linked_list_iterator_t it; 367 btstack_linked_list_iterator_init(&it, hfp_get_connections()); 368 while (btstack_linked_list_iterator_has_next(&it)){ 369 hfp_connection_t * hfp_connection = (hfp_connection_t *)btstack_linked_list_iterator_next(&it); 370 if ((hfp_connection->acl_handle == handle) && (hfp_connection->local_role == hfp_role)){ 371 return hfp_connection; 372 } 373 } 374 return NULL; 375 } 376 377 void hfp_reset_context_flags(hfp_connection_t * hfp_connection){ 378 if (!hfp_connection) return; 379 hfp_connection->ok_pending = 0; 380 hfp_connection->send_error = 0; 381 382 hfp_connection->keep_byte = 0; 383 384 hfp_connection->change_status_update_for_individual_ag_indicators = 0; 385 hfp_connection->operator_name_changed = 0; 386 387 hfp_connection->enable_extended_audio_gateway_error_report = 0; 388 hfp_connection->extended_audio_gateway_error = 0; 389 390 // establish codecs hfp_connection 391 hfp_connection->suggested_codec = 0; 392 hfp_connection->negotiated_codec = 0; 393 hfp_connection->codec_confirmed = 0; 394 395 hfp_connection->establish_audio_connection = 0; 396 hfp_connection->call_waiting_notification_enabled = 0; 397 hfp_connection->command = HFP_CMD_NONE; 398 hfp_connection->enable_status_update_for_ag_indicators = 0xFF; 399 } 400 401 static hfp_connection_t * create_hfp_connection_context(void){ 402 hfp_connection_t * hfp_connection = btstack_memory_hfp_connection_get(); 403 if (!hfp_connection) return NULL; 404 405 hfp_connection->state = HFP_IDLE; 406 hfp_connection->call_state = HFP_CALL_IDLE; 407 hfp_connection->codecs_state = HFP_CODECS_IDLE; 408 409 hfp_connection->parser_state = HFP_PARSER_CMD_HEADER; 410 hfp_connection->command = HFP_CMD_NONE; 411 412 hfp_connection->acl_handle = HCI_CON_HANDLE_INVALID; 413 hfp_connection->sco_handle = HCI_CON_HANDLE_INVALID; 414 415 hfp_reset_context_flags(hfp_connection); 416 417 btstack_linked_list_add(&hfp_connections, (btstack_linked_item_t*)hfp_connection); 418 return hfp_connection; 419 } 420 421 static void remove_hfp_connection_context(hfp_connection_t * hfp_connection){ 422 btstack_linked_list_remove(&hfp_connections, (btstack_linked_item_t*) hfp_connection); 423 btstack_memory_hfp_connection_free(hfp_connection); 424 } 425 426 static hfp_connection_t * provide_hfp_connection_context_for_bd_addr(bd_addr_t bd_addr, hfp_role_t local_role){ 427 hfp_connection_t * hfp_connection = get_hfp_connection_context_for_bd_addr(bd_addr, local_role); 428 if (hfp_connection) return hfp_connection; 429 hfp_connection = create_hfp_connection_context(); 430 memcpy(hfp_connection->remote_addr, bd_addr, 6); 431 hfp_connection->local_role = local_role; 432 log_info("Create HFP context %p: role %u, addr %s", hfp_connection, local_role, bd_addr_to_str(bd_addr)); 433 434 return hfp_connection; 435 } 436 437 /* @param network. 438 * 0 == no ability to reject a call. 439 * 1 == ability to reject a call. 440 */ 441 442 /* @param suported_features 443 * HF bit 0: EC and/or NR function (yes/no, 1 = yes, 0 = no) 444 * HF bit 1: Call waiting or three-way calling(yes/no, 1 = yes, 0 = no) 445 * HF bit 2: CLI presentation capability (yes/no, 1 = yes, 0 = no) 446 * HF bit 3: Voice recognition activation (yes/no, 1= yes, 0 = no) 447 * HF bit 4: Remote volume control (yes/no, 1 = yes, 0 = no) 448 * HF bit 5: Wide band speech (yes/no, 1 = yes, 0 = no) 449 */ 450 /* Bit position: 451 * AG bit 0: Three-way calling (yes/no, 1 = yes, 0 = no) 452 * AG bit 1: EC and/or NR function (yes/no, 1 = yes, 0 = no) 453 * AG bit 2: Voice recognition function (yes/no, 1 = yes, 0 = no) 454 * AG bit 3: In-band ring tone capability (yes/no, 1 = yes, 0 = no) 455 * AG bit 4: Attach a phone number to a voice tag (yes/no, 1 = yes, 0 = no) 456 * AG bit 5: Wide band speech (yes/no, 1 = yes, 0 = no) 457 */ 458 459 void hfp_create_sdp_record(uint8_t * service, uint32_t service_record_handle, uint16_t service_uuid, int rfcomm_channel_nr, const char * name){ 460 uint8_t* attribute; 461 de_create_sequence(service); 462 463 // 0x0000 "Service Record Handle" 464 de_add_number(service, DE_UINT, DE_SIZE_16, BLUETOOTH_ATTRIBUTE_SERVICE_RECORD_HANDLE); 465 de_add_number(service, DE_UINT, DE_SIZE_32, service_record_handle); 466 467 // 0x0001 "Service Class ID List" 468 de_add_number(service, DE_UINT, DE_SIZE_16, BLUETOOTH_ATTRIBUTE_SERVICE_CLASS_ID_LIST); 469 attribute = de_push_sequence(service); 470 { 471 // "UUID for Service" 472 de_add_number(attribute, DE_UUID, DE_SIZE_16, service_uuid); 473 de_add_number(attribute, DE_UUID, DE_SIZE_16, BLUETOOTH_SERVICE_CLASS_GENERIC_AUDIO); 474 } 475 de_pop_sequence(service, attribute); 476 477 // 0x0004 "Protocol Descriptor List" 478 de_add_number(service, DE_UINT, DE_SIZE_16, BLUETOOTH_ATTRIBUTE_PROTOCOL_DESCRIPTOR_LIST); 479 attribute = de_push_sequence(service); 480 { 481 uint8_t* l2cpProtocol = de_push_sequence(attribute); 482 { 483 de_add_number(l2cpProtocol, DE_UUID, DE_SIZE_16, BLUETOOTH_PROTOCOL_L2CAP); 484 } 485 de_pop_sequence(attribute, l2cpProtocol); 486 487 uint8_t* rfcomm = de_push_sequence(attribute); 488 { 489 de_add_number(rfcomm, DE_UUID, DE_SIZE_16, BLUETOOTH_PROTOCOL_RFCOMM); // rfcomm_service 490 de_add_number(rfcomm, DE_UINT, DE_SIZE_8, rfcomm_channel_nr); // rfcomm channel 491 } 492 de_pop_sequence(attribute, rfcomm); 493 } 494 de_pop_sequence(service, attribute); 495 496 497 // 0x0005 "Public Browse Group" 498 de_add_number(service, DE_UINT, DE_SIZE_16, BLUETOOTH_ATTRIBUTE_BROWSE_GROUP_LIST); // public browse group 499 attribute = de_push_sequence(service); 500 { 501 de_add_number(attribute, DE_UUID, DE_SIZE_16, BLUETOOTH_ATTRIBUTE_PUBLIC_BROWSE_ROOT); 502 } 503 de_pop_sequence(service, attribute); 504 505 // 0x0009 "Bluetooth Profile Descriptor List" 506 de_add_number(service, DE_UINT, DE_SIZE_16, BLUETOOTH_ATTRIBUTE_BLUETOOTH_PROFILE_DESCRIPTOR_LIST); 507 attribute = de_push_sequence(service); 508 { 509 uint8_t *sppProfile = de_push_sequence(attribute); 510 { 511 de_add_number(sppProfile, DE_UUID, DE_SIZE_16, BLUETOOTH_SERVICE_CLASS_HANDSFREE); 512 de_add_number(sppProfile, DE_UINT, DE_SIZE_16, 0x0107); // Verision 1.7 513 } 514 de_pop_sequence(attribute, sppProfile); 515 } 516 de_pop_sequence(service, attribute); 517 518 // 0x0100 "Service Name" 519 de_add_number(service, DE_UINT, DE_SIZE_16, 0x0100); 520 de_add_data(service, DE_STRING, strlen(name), (uint8_t *) name); 521 } 522 523 static hfp_connection_t * connection_doing_sdp_query = NULL; 524 525 static void handle_query_rfcomm_event(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){ 526 UNUSED(packet_type); // ok: handling own sdp events 527 UNUSED(channel); // ok: no channel 528 UNUSED(size); // ok: handling own sdp events 529 hfp_connection_t * hfp_connection = connection_doing_sdp_query; 530 if (!hfp_connection) { 531 log_error("handle_query_rfcomm_event, no connection"); 532 return; 533 } 534 535 switch (hci_event_packet_get_type(packet)){ 536 case SDP_EVENT_QUERY_RFCOMM_SERVICE: 537 hfp_connection->rfcomm_channel_nr = sdp_event_query_rfcomm_service_get_rfcomm_channel(packet); 538 break; 539 case SDP_EVENT_QUERY_COMPLETE: 540 connection_doing_sdp_query = NULL; 541 if (hfp_connection->rfcomm_channel_nr > 0){ 542 hfp_connection->state = HFP_W4_RFCOMM_CONNECTED; 543 log_info("HFP: SDP_EVENT_QUERY_COMPLETE context %p, addr %s, state %d", hfp_connection, bd_addr_to_str( hfp_connection->remote_addr), hfp_connection->state); 544 btstack_packet_handler_t packet_handler; 545 switch (hfp_connection->local_role){ 546 case HFP_ROLE_AG: 547 packet_handler = hfp_ag_rfcomm_packet_handler; 548 break; 549 case HFP_ROLE_HF: 550 packet_handler = hfp_hf_rfcomm_packet_handler; 551 break; 552 default: 553 log_error("Role %x", hfp_connection->local_role); 554 return; 555 } 556 rfcomm_create_channel(packet_handler, hfp_connection->remote_addr, hfp_connection->rfcomm_channel_nr, NULL); 557 break; 558 } 559 hfp_connection->state = HFP_IDLE; 560 hfp_emit_slc_connection_event(hfp_connection, sdp_event_query_complete_get_status(packet), HCI_CON_HANDLE_INVALID, hfp_connection->remote_addr); 561 log_info("rfcomm service not found, status %u.", sdp_event_query_complete_get_status(packet)); 562 break; 563 default: 564 break; 565 } 566 } 567 568 // returns 0 if unexpected error or no other link options remained, otherwise 1 569 static int hfp_handle_failed_sco_connection(uint8_t status){ 570 571 if (!sco_establishment_active){ 572 log_error("(e)SCO Connection failed but not started by us"); 573 return 0; 574 } 575 log_info("(e)SCO Connection failed status 0x%02x", status); 576 // invalid params / unspecified error 577 if ((status != 0x11) && (status != 0x1f) && (status != 0x0D)) return 0; 578 579 switch (sco_establishment_active->link_setting){ 580 case HFP_LINK_SETTINGS_D0: 581 return 0; // no other option left 582 case HFP_LINK_SETTINGS_D1: 583 sco_establishment_active->link_setting = HFP_LINK_SETTINGS_D0; 584 break; 585 case HFP_LINK_SETTINGS_S1: 586 sco_establishment_active->link_setting = HFP_LINK_SETTINGS_D1; 587 break; 588 case HFP_LINK_SETTINGS_S2: 589 sco_establishment_active->link_setting = HFP_LINK_SETTINGS_S1; 590 break; 591 case HFP_LINK_SETTINGS_S3: 592 sco_establishment_active->link_setting = HFP_LINK_SETTINGS_S2; 593 break; 594 case HFP_LINK_SETTINGS_S4: 595 sco_establishment_active->link_setting = HFP_LINK_SETTINGS_S3; 596 break; 597 case HFP_LINK_SETTINGS_T1: 598 log_info("T1 failed, fallback to CVSD - D1"); 599 sco_establishment_active->negotiated_codec = HFP_CODEC_CVSD; 600 sco_establishment_active->sco_for_msbc_failed = 1; 601 sco_establishment_active->command = HFP_CMD_AG_SEND_COMMON_CODEC; 602 sco_establishment_active->link_setting = HFP_LINK_SETTINGS_D1; 603 break; 604 case HFP_LINK_SETTINGS_T2: 605 sco_establishment_active->link_setting = HFP_LINK_SETTINGS_T1; 606 break; 607 } 608 log_info("e)SCO Connection: try new link_setting %d", sco_establishment_active->link_setting); 609 sco_establishment_active->establish_audio_connection = 1; 610 sco_establishment_active = NULL; 611 return 1; 612 } 613 614 615 void hfp_handle_hci_event(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size, hfp_role_t local_role){ 616 UNUSED(channel); // ok: no channel 617 618 bd_addr_t event_addr; 619 hci_con_handle_t handle; 620 hfp_connection_t * hfp_connection = NULL; 621 uint8_t status; 622 623 log_debug("HFP HCI event handler type %u, event type %x, size %u", packet_type, hci_event_packet_get_type(packet), size); 624 625 switch (hci_event_packet_get_type(packet)) { 626 627 case HCI_EVENT_CONNECTION_REQUEST: 628 switch(hci_event_connection_request_get_link_type(packet)){ 629 case 0: // SCO 630 case 2: // eSCO 631 hci_event_connection_request_get_bd_addr(packet, event_addr); 632 hfp_connection = get_hfp_connection_context_for_bd_addr(event_addr, local_role); 633 if (!hfp_connection) break; 634 log_info("hf accept sco\n"); 635 hfp_connection->hf_accept_sco = 1; 636 if (!hfp_hf_run_for_context) break; 637 (*hfp_hf_run_for_context)(hfp_connection); 638 break; 639 default: 640 break; 641 } 642 break; 643 644 case HCI_EVENT_COMMAND_STATUS: 645 if (hci_event_command_status_get_command_opcode(packet) == hci_setup_synchronous_connection.opcode) { 646 status = hci_event_command_status_get_status(packet); 647 if (status == ERROR_CODE_SUCCESS) break; 648 649 hfp_connection = sco_establishment_active; 650 if (hfp_handle_failed_sco_connection(status)) break; 651 hfp_connection->establish_audio_connection = 0; 652 hfp_connection->state = HFP_SERVICE_LEVEL_CONNECTION_ESTABLISHED; 653 hfp_emit_sco_event(hfp_connection, status, 0, hfp_connection->remote_addr, hfp_connection->negotiated_codec); 654 } 655 break; 656 657 case HCI_EVENT_SYNCHRONOUS_CONNECTION_COMPLETE:{ 658 hci_event_synchronous_connection_complete_get_bd_addr(packet, event_addr); 659 hfp_connection = get_hfp_connection_context_for_bd_addr(event_addr, local_role); 660 if (!hfp_connection) { 661 log_error("HFP: connection does not exist for remote with addr %s.", bd_addr_to_str(event_addr)); 662 return; 663 } 664 665 status = hci_event_synchronous_connection_complete_get_status(packet); 666 if (status != ERROR_CODE_SUCCESS){ 667 hfp_connection->hf_accept_sco = 0; 668 if (hfp_handle_failed_sco_connection(status)) break; 669 670 hfp_connection->establish_audio_connection = 0; 671 hfp_connection->state = HFP_SERVICE_LEVEL_CONNECTION_ESTABLISHED; 672 hfp_emit_sco_event(hfp_connection, status, 0, event_addr, hfp_connection->negotiated_codec); 673 break; 674 } 675 676 uint16_t sco_handle = hci_event_synchronous_connection_complete_get_handle(packet); 677 uint8_t link_type = hci_event_synchronous_connection_complete_get_link_type(packet); 678 uint8_t transmission_interval = hci_event_synchronous_connection_complete_get_transmission_interval(packet); // measured in slots 679 uint8_t retransmission_interval = hci_event_synchronous_connection_complete_get_retransmission_interval(packet);// measured in slots 680 uint16_t rx_packet_length = hci_event_synchronous_connection_complete_get_rx_packet_length(packet); // measured in bytes 681 uint16_t tx_packet_length = hci_event_synchronous_connection_complete_get_tx_packet_length(packet); // measured in bytes 682 uint8_t air_mode = hci_event_synchronous_connection_complete_get_air_mode(packet); 683 684 switch (link_type){ 685 case 0x00: 686 log_info("SCO Connection established."); 687 if (transmission_interval != 0) log_error("SCO Connection: transmission_interval not zero: %d.", transmission_interval); 688 if (retransmission_interval != 0) log_error("SCO Connection: retransmission_interval not zero: %d.", retransmission_interval); 689 if (rx_packet_length != 0) log_error("SCO Connection: rx_packet_length not zero: %d.", rx_packet_length); 690 if (tx_packet_length != 0) log_error("SCO Connection: tx_packet_length not zero: %d.", tx_packet_length); 691 break; 692 case 0x02: 693 log_info("eSCO Connection established. \n"); 694 break; 695 default: 696 log_error("(e)SCO reserved link_type 0x%2x", link_type); 697 break; 698 } 699 log_info("sco_handle 0x%2x, address %s, transmission_interval %u slots, retransmission_interval %u slots, " 700 " rx_packet_length %u bytes, tx_packet_length %u bytes, air_mode 0x%2x (0x02 == CVSD)\n", sco_handle, 701 bd_addr_to_str(event_addr), transmission_interval, retransmission_interval, rx_packet_length, tx_packet_length, air_mode); 702 703 // hfp_connection = get_hfp_connection_context_for_bd_addr(event_addr, local_role); 704 705 // if (!hfp_connection) { 706 // log_error("SCO link created, hfp_connection for address %s not found.", bd_addr_to_str(event_addr)); 707 // break; 708 // } 709 710 if (hfp_connection->state == HFP_W4_CONNECTION_ESTABLISHED_TO_SHUTDOWN){ 711 log_info("SCO about to disconnect: HFP_W4_CONNECTION_ESTABLISHED_TO_SHUTDOWN"); 712 hfp_connection->state = HFP_W2_DISCONNECT_SCO; 713 break; 714 } 715 hfp_connection->sco_handle = sco_handle; 716 hfp_connection->establish_audio_connection = 0; 717 hfp_connection->state = HFP_AUDIO_CONNECTION_ESTABLISHED; 718 hfp_emit_sco_event(hfp_connection, status, sco_handle, event_addr, hfp_connection->negotiated_codec); 719 break; 720 } 721 722 case HCI_EVENT_DISCONNECTION_COMPLETE: 723 handle = little_endian_read_16(packet,3); 724 hfp_connection = get_hfp_connection_context_for_sco_handle(handle, local_role); 725 726 if (!hfp_connection) break; 727 728 hfp_connection->sco_handle = HCI_CON_HANDLE_INVALID; 729 hfp_connection->release_audio_connection = 0; 730 hfp_connection->state = HFP_SERVICE_LEVEL_CONNECTION_ESTABLISHED; 731 hfp_emit_event(hfp_connection, HFP_SUBEVENT_AUDIO_CONNECTION_RELEASED, 0); 732 733 if (hfp_connection->release_slc_connection){ 734 hfp_connection->release_slc_connection = 0; 735 log_info("SCO disconnected, w2 disconnect RFCOMM\n"); 736 hfp_connection->state = HFP_W2_DISCONNECT_RFCOMM; 737 } 738 break; 739 740 default: 741 break; 742 } 743 } 744 745 void hfp_handle_rfcomm_event(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size, hfp_role_t local_role){ 746 UNUSED(channel); // ok: no channel 747 748 bd_addr_t event_addr; 749 uint16_t rfcomm_cid; 750 hfp_connection_t * hfp_connection = NULL; 751 uint8_t status; 752 753 log_debug("HFP packet_handler type %u, event type %x, size %u", packet_type, hci_event_packet_get_type(packet), size); 754 755 switch (hci_event_packet_get_type(packet)) { 756 757 case RFCOMM_EVENT_INCOMING_CONNECTION: 758 // data: event (8), len(8), address(48), channel (8), rfcomm_cid (16) 759 rfcomm_event_incoming_connection_get_bd_addr(packet, event_addr); 760 hfp_connection = provide_hfp_connection_context_for_bd_addr(event_addr, local_role); 761 if (!hfp_connection){ 762 log_info("hfp: no memory to accept incoming connection - decline"); 763 rfcomm_decline_connection(rfcomm_event_incoming_connection_get_rfcomm_cid(packet)); 764 return; 765 } 766 if (hfp_connection->state != HFP_IDLE) { 767 log_error("hfp: incoming connection but not idle, reject"); 768 rfcomm_decline_connection(rfcomm_event_incoming_connection_get_rfcomm_cid(packet)); 769 return; 770 } 771 772 hfp_connection->rfcomm_cid = rfcomm_event_incoming_connection_get_rfcomm_cid(packet); 773 hfp_connection->state = HFP_W4_RFCOMM_CONNECTED; 774 // printf("RFCOMM channel %u requested for %s\n", hfp_connection->rfcomm_cid, bd_addr_to_str(hfp_connection->remote_addr)); 775 rfcomm_accept_connection(hfp_connection->rfcomm_cid); 776 break; 777 778 case RFCOMM_EVENT_CHANNEL_OPENED: 779 // data: event(8), len(8), status (8), address (48), handle(16), server channel(8), rfcomm_cid(16), max frame size(16) 780 781 rfcomm_event_channel_opened_get_bd_addr(packet, event_addr); 782 status = rfcomm_event_channel_opened_get_status(packet); 783 784 hfp_connection = get_hfp_connection_context_for_bd_addr(event_addr, local_role); 785 if (!hfp_connection || (hfp_connection->state != HFP_W4_RFCOMM_CONNECTED)) return; 786 787 if (status) { 788 hfp_emit_slc_connection_event(hfp_connection, status, rfcomm_event_channel_opened_get_con_handle(packet), event_addr); 789 remove_hfp_connection_context(hfp_connection); 790 } else { 791 hfp_connection->acl_handle = rfcomm_event_channel_opened_get_con_handle(packet); 792 hfp_connection->rfcomm_cid = rfcomm_event_channel_opened_get_rfcomm_cid(packet); 793 bd_addr_copy(hfp_connection->remote_addr, event_addr); 794 // uint16_t mtu = rfcomm_event_channel_opened_get_max_frame_size(packet); 795 // printf("RFCOMM channel open succeeded. hfp_connection %p, RFCOMM Channel ID 0x%02x, max frame size %u\n", hfp_connection, hfp_connection->rfcomm_cid, mtu); 796 797 switch (hfp_connection->state){ 798 case HFP_W4_RFCOMM_CONNECTED: 799 hfp_connection->state = HFP_EXCHANGE_SUPPORTED_FEATURES; 800 break; 801 case HFP_W4_CONNECTION_ESTABLISHED_TO_SHUTDOWN: 802 hfp_connection->state = HFP_W2_DISCONNECT_RFCOMM; 803 // printf("Shutting down RFCOMM.\n"); 804 break; 805 default: 806 break; 807 } 808 rfcomm_request_can_send_now_event(hfp_connection->rfcomm_cid); 809 } 810 break; 811 812 case RFCOMM_EVENT_CHANNEL_CLOSED: 813 rfcomm_cid = little_endian_read_16(packet,2); 814 hfp_connection = get_hfp_connection_context_for_rfcomm_cid(rfcomm_cid); 815 if (!hfp_connection) break; 816 if (hfp_connection->state == HFP_W4_RFCOMM_DISCONNECTED_AND_RESTART){ 817 hfp_connection->state = HFP_IDLE; 818 hfp_establish_service_level_connection(hfp_connection->remote_addr, hfp_connection->service_uuid, local_role); 819 break; 820 } 821 822 hfp_emit_event(hfp_connection, HFP_SUBEVENT_SERVICE_LEVEL_CONNECTION_RELEASED, 0); 823 remove_hfp_connection_context(hfp_connection); 824 break; 825 826 default: 827 break; 828 } 829 } 830 // translates command string into hfp_command_t CMD 831 static hfp_command_t parse_command(const char * line_buffer, int isHandsFree){ 832 log_info("command '%s', handsfree %u", line_buffer, isHandsFree); 833 int offset = isHandsFree ? 0 : 2; 834 835 if (strncmp(line_buffer+offset, HFP_LIST_CURRENT_CALLS, strlen(HFP_LIST_CURRENT_CALLS)) == 0){ 836 return HFP_CMD_LIST_CURRENT_CALLS; 837 } 838 839 if (strncmp(line_buffer+offset, HFP_SUBSCRIBER_NUMBER_INFORMATION, strlen(HFP_SUBSCRIBER_NUMBER_INFORMATION)) == 0){ 840 return HFP_CMD_GET_SUBSCRIBER_NUMBER_INFORMATION; 841 } 842 843 if (strncmp(line_buffer+offset, HFP_PHONE_NUMBER_FOR_VOICE_TAG, strlen(HFP_PHONE_NUMBER_FOR_VOICE_TAG)) == 0){ 844 if (isHandsFree) return HFP_CMD_AG_SENT_PHONE_NUMBER; 845 return HFP_CMD_HF_REQUEST_PHONE_NUMBER; 846 } 847 848 if (strncmp(line_buffer+offset, HFP_TRANSMIT_DTMF_CODES, strlen(HFP_TRANSMIT_DTMF_CODES)) == 0){ 849 return HFP_CMD_TRANSMIT_DTMF_CODES; 850 } 851 852 if (strncmp(line_buffer+offset, HFP_SET_MICROPHONE_GAIN, strlen(HFP_SET_MICROPHONE_GAIN)) == 0){ 853 return HFP_CMD_SET_MICROPHONE_GAIN; 854 } 855 856 if (strncmp(line_buffer+offset, HFP_SET_SPEAKER_GAIN, strlen(HFP_SET_SPEAKER_GAIN)) == 0){ 857 return HFP_CMD_SET_SPEAKER_GAIN; 858 } 859 860 if (strncmp(line_buffer+offset, HFP_ACTIVATE_VOICE_RECOGNITION, strlen(HFP_ACTIVATE_VOICE_RECOGNITION)) == 0){ 861 if (isHandsFree) return HFP_CMD_AG_ACTIVATE_VOICE_RECOGNITION; 862 return HFP_CMD_HF_ACTIVATE_VOICE_RECOGNITION; 863 } 864 865 if (strncmp(line_buffer+offset, HFP_TURN_OFF_EC_AND_NR, strlen(HFP_TURN_OFF_EC_AND_NR)) == 0){ 866 return HFP_CMD_TURN_OFF_EC_AND_NR; 867 } 868 869 if (strncmp(line_buffer, HFP_ANSWER_CALL, strlen(HFP_ANSWER_CALL)) == 0){ 870 return HFP_CMD_CALL_ANSWERED; 871 } 872 873 if (strncmp(line_buffer, HFP_CALL_PHONE_NUMBER, strlen(HFP_CALL_PHONE_NUMBER)) == 0){ 874 return HFP_CMD_CALL_PHONE_NUMBER; 875 } 876 877 if (strncmp(line_buffer+offset, HFP_REDIAL_LAST_NUMBER, strlen(HFP_REDIAL_LAST_NUMBER)) == 0){ 878 return HFP_CMD_REDIAL_LAST_NUMBER; 879 } 880 881 if (strncmp(line_buffer+offset, HFP_CHANGE_IN_BAND_RING_TONE_SETTING, strlen(HFP_CHANGE_IN_BAND_RING_TONE_SETTING)) == 0){ 882 return HFP_CMD_CHANGE_IN_BAND_RING_TONE_SETTING; 883 } 884 885 if (strncmp(line_buffer+offset, HFP_HANG_UP_CALL, strlen(HFP_HANG_UP_CALL)) == 0){ 886 return HFP_CMD_HANG_UP_CALL; 887 } 888 889 if (strncmp(line_buffer+offset, HFP_ERROR, strlen(HFP_ERROR)) == 0){ 890 return HFP_CMD_ERROR; 891 } 892 893 if (strncmp(line_buffer+offset, HFP_RING, strlen(HFP_RING)) == 0){ 894 return HFP_CMD_RING; 895 } 896 897 if (isHandsFree && (strncmp(line_buffer+offset, HFP_OK, strlen(HFP_OK)) == 0)){ 898 return HFP_CMD_OK; 899 } 900 901 if (strncmp(line_buffer+offset, HFP_SUPPORTED_FEATURES, strlen(HFP_SUPPORTED_FEATURES)) == 0){ 902 return HFP_CMD_SUPPORTED_FEATURES; 903 } 904 905 if (strncmp(line_buffer+offset, HFP_TRANSFER_HF_INDICATOR_STATUS, strlen(HFP_TRANSFER_HF_INDICATOR_STATUS)) == 0){ 906 return HFP_CMD_HF_INDICATOR_STATUS; 907 } 908 909 if (strncmp(line_buffer+offset, HFP_RESPONSE_AND_HOLD, strlen(HFP_RESPONSE_AND_HOLD)) == 0){ 910 if (strncmp(line_buffer+strlen(HFP_RESPONSE_AND_HOLD)+offset, "?", 1) == 0){ 911 return HFP_CMD_RESPONSE_AND_HOLD_QUERY; 912 } 913 if (strncmp(line_buffer+strlen(HFP_RESPONSE_AND_HOLD)+offset, "=", 1) == 0){ 914 return HFP_CMD_RESPONSE_AND_HOLD_COMMAND; 915 } 916 return HFP_CMD_RESPONSE_AND_HOLD_STATUS; 917 } 918 919 if (strncmp(line_buffer+offset, HFP_INDICATOR, strlen(HFP_INDICATOR)) == 0){ 920 if (strncmp(line_buffer+strlen(HFP_INDICATOR)+offset, "?", 1) == 0){ 921 return HFP_CMD_RETRIEVE_AG_INDICATORS_STATUS; 922 } 923 924 if (strncmp(line_buffer+strlen(HFP_INDICATOR)+offset, "=?", 2) == 0){ 925 return HFP_CMD_RETRIEVE_AG_INDICATORS; 926 } 927 } 928 929 if (strncmp(line_buffer+offset, HFP_AVAILABLE_CODECS, strlen(HFP_AVAILABLE_CODECS)) == 0){ 930 return HFP_CMD_AVAILABLE_CODECS; 931 } 932 933 if (strncmp(line_buffer+offset, HFP_ENABLE_STATUS_UPDATE_FOR_AG_INDICATORS, strlen(HFP_ENABLE_STATUS_UPDATE_FOR_AG_INDICATORS)) == 0){ 934 return HFP_CMD_ENABLE_INDICATOR_STATUS_UPDATE; 935 } 936 937 if (strncmp(line_buffer+offset, HFP_ENABLE_CLIP, strlen(HFP_ENABLE_CLIP)) == 0){ 938 if (isHandsFree) return HFP_CMD_AG_SENT_CLIP_INFORMATION; 939 return HFP_CMD_ENABLE_CLIP; 940 } 941 942 if (strncmp(line_buffer+offset, HFP_ENABLE_CALL_WAITING_NOTIFICATION, strlen(HFP_ENABLE_CALL_WAITING_NOTIFICATION)) == 0){ 943 if (isHandsFree) return HFP_CMD_AG_SENT_CALL_WAITING_NOTIFICATION_UPDATE; 944 return HFP_CMD_ENABLE_CALL_WAITING_NOTIFICATION; 945 } 946 947 if (strncmp(line_buffer+offset, HFP_SUPPORT_CALL_HOLD_AND_MULTIPARTY_SERVICES, strlen(HFP_SUPPORT_CALL_HOLD_AND_MULTIPARTY_SERVICES)) == 0){ 948 949 if (isHandsFree) return HFP_CMD_SUPPORT_CALL_HOLD_AND_MULTIPARTY_SERVICES; 950 951 if (strncmp(line_buffer+strlen(HFP_SUPPORT_CALL_HOLD_AND_MULTIPARTY_SERVICES)+offset, "=?", 2) == 0){ 952 return HFP_CMD_SUPPORT_CALL_HOLD_AND_MULTIPARTY_SERVICES; 953 } 954 if (strncmp(line_buffer+strlen(HFP_SUPPORT_CALL_HOLD_AND_MULTIPARTY_SERVICES)+offset, "=", 1) == 0){ 955 return HFP_CMD_CALL_HOLD; 956 } 957 958 return HFP_CMD_UNKNOWN; 959 } 960 961 if (strncmp(line_buffer+offset, HFP_GENERIC_STATUS_INDICATOR, strlen(HFP_GENERIC_STATUS_INDICATOR)) == 0){ 962 if (isHandsFree) { 963 return HFP_CMD_SET_GENERIC_STATUS_INDICATOR_STATUS; 964 } 965 if (strncmp(line_buffer+strlen(HFP_GENERIC_STATUS_INDICATOR)+offset, "=?", 2) == 0){ 966 return HFP_CMD_RETRIEVE_GENERIC_STATUS_INDICATORS; 967 } 968 if (strncmp(line_buffer+strlen(HFP_GENERIC_STATUS_INDICATOR)+offset, "=", 1) == 0){ 969 return HFP_CMD_LIST_GENERIC_STATUS_INDICATORS; 970 } 971 return HFP_CMD_RETRIEVE_GENERIC_STATUS_INDICATORS_STATE; 972 } 973 974 if (strncmp(line_buffer+offset, HFP_UPDATE_ENABLE_STATUS_FOR_INDIVIDUAL_AG_INDICATORS, strlen(HFP_UPDATE_ENABLE_STATUS_FOR_INDIVIDUAL_AG_INDICATORS)) == 0){ 975 return HFP_CMD_ENABLE_INDIVIDUAL_AG_INDICATOR_STATUS_UPDATE; 976 } 977 978 979 if (strncmp(line_buffer+offset, HFP_QUERY_OPERATOR_SELECTION, strlen(HFP_QUERY_OPERATOR_SELECTION)) == 0){ 980 if (strncmp(line_buffer+strlen(HFP_QUERY_OPERATOR_SELECTION)+offset, "=", 1) == 0){ 981 return HFP_CMD_QUERY_OPERATOR_SELECTION_NAME_FORMAT; 982 } 983 return HFP_CMD_QUERY_OPERATOR_SELECTION_NAME; 984 } 985 986 if (strncmp(line_buffer+offset, HFP_TRANSFER_AG_INDICATOR_STATUS, strlen(HFP_TRANSFER_AG_INDICATOR_STATUS)) == 0){ 987 return HFP_CMD_TRANSFER_AG_INDICATOR_STATUS; 988 } 989 990 if (isHandsFree && (strncmp(line_buffer+offset, HFP_EXTENDED_AUDIO_GATEWAY_ERROR, strlen(HFP_EXTENDED_AUDIO_GATEWAY_ERROR)) == 0)){ 991 return HFP_CMD_EXTENDED_AUDIO_GATEWAY_ERROR; 992 } 993 994 if (!isHandsFree && (strncmp(line_buffer+offset, HFP_ENABLE_EXTENDED_AUDIO_GATEWAY_ERROR, strlen(HFP_ENABLE_EXTENDED_AUDIO_GATEWAY_ERROR)) == 0)){ 995 return HFP_CMD_ENABLE_EXTENDED_AUDIO_GATEWAY_ERROR; 996 } 997 998 if (strncmp(line_buffer+offset, HFP_TRIGGER_CODEC_CONNECTION_SETUP, strlen(HFP_TRIGGER_CODEC_CONNECTION_SETUP)) == 0){ 999 return HFP_CMD_TRIGGER_CODEC_CONNECTION_SETUP; 1000 } 1001 1002 if (strncmp(line_buffer+offset, HFP_CONFIRM_COMMON_CODEC, strlen(HFP_CONFIRM_COMMON_CODEC)) == 0){ 1003 if (isHandsFree){ 1004 return HFP_CMD_AG_SUGGESTED_CODEC; 1005 } else { 1006 return HFP_CMD_HF_CONFIRMED_CODEC; 1007 } 1008 } 1009 1010 if (strncmp(line_buffer+offset, "AT+", 3) == 0){ 1011 log_info("process unknown HF command %s \n", line_buffer); 1012 return HFP_CMD_UNKNOWN; 1013 } 1014 1015 if (strncmp(line_buffer+offset, "+", 1) == 0){ 1016 log_info(" process unknown AG command %s \n", line_buffer); 1017 return HFP_CMD_UNKNOWN; 1018 } 1019 1020 if (strncmp(line_buffer+offset, "NOP", 3) == 0){ 1021 return HFP_CMD_NONE; 1022 } 1023 1024 return HFP_CMD_NONE; 1025 } 1026 1027 static void hfp_parser_store_byte(hfp_connection_t * hfp_connection, uint8_t byte){ 1028 // printf("hfp_parser_store_byte %c at pos %u\n", (char) byte, context->line_size); 1029 // TODO: add limit 1030 hfp_connection->line_buffer[hfp_connection->line_size++] = byte; 1031 hfp_connection->line_buffer[hfp_connection->line_size] = 0; 1032 } 1033 static int hfp_parser_is_buffer_empty(hfp_connection_t * hfp_connection){ 1034 return hfp_connection->line_size == 0; 1035 } 1036 1037 static int hfp_parser_is_end_of_line(uint8_t byte){ 1038 return (byte == '\n') || (byte == '\r'); 1039 } 1040 1041 static int hfp_parser_is_end_of_header(uint8_t byte){ 1042 return hfp_parser_is_end_of_line(byte) || (byte == ':') || (byte == '?'); 1043 } 1044 1045 static int hfp_parser_found_separator(hfp_connection_t * hfp_connection, uint8_t byte){ 1046 if (hfp_connection->keep_byte == 1) return 1; 1047 1048 int found_separator = (byte == ',') || (byte == '\n')|| (byte == '\r')|| 1049 (byte == ')') || (byte == '(') || (byte == ':') || 1050 (byte == '-') || (byte == '"') || (byte == '?')|| (byte == '='); 1051 return found_separator; 1052 } 1053 static void hfp_parser_next_state(hfp_connection_t * hfp_connection, uint8_t byte){ 1054 hfp_connection->line_size = 0; 1055 if (hfp_parser_is_end_of_line(byte)){ 1056 hfp_connection->parser_item_index = 0; 1057 hfp_connection->parser_state = HFP_PARSER_CMD_HEADER; 1058 return; 1059 } 1060 switch (hfp_connection->parser_state){ 1061 case HFP_PARSER_CMD_HEADER: 1062 hfp_connection->parser_state = HFP_PARSER_CMD_SEQUENCE; 1063 if (hfp_connection->keep_byte == 1){ 1064 hfp_parser_store_byte(hfp_connection, byte); 1065 hfp_connection->keep_byte = 0; 1066 } 1067 break; 1068 case HFP_PARSER_CMD_SEQUENCE: 1069 switch (hfp_connection->command){ 1070 case HFP_CMD_AG_SENT_PHONE_NUMBER: 1071 case HFP_CMD_AG_SENT_CALL_WAITING_NOTIFICATION_UPDATE: 1072 case HFP_CMD_AG_SENT_CLIP_INFORMATION: 1073 case HFP_CMD_TRANSFER_AG_INDICATOR_STATUS: 1074 case HFP_CMD_QUERY_OPERATOR_SELECTION_NAME: 1075 case HFP_CMD_QUERY_OPERATOR_SELECTION_NAME_FORMAT: 1076 case HFP_CMD_RETRIEVE_AG_INDICATORS: 1077 case HFP_CMD_RETRIEVE_GENERIC_STATUS_INDICATORS_STATE: 1078 case HFP_CMD_HF_INDICATOR_STATUS: 1079 hfp_connection->parser_state = HFP_PARSER_SECOND_ITEM; 1080 break; 1081 default: 1082 break; 1083 } 1084 break; 1085 case HFP_PARSER_SECOND_ITEM: 1086 hfp_connection->parser_state = HFP_PARSER_THIRD_ITEM; 1087 break; 1088 case HFP_PARSER_THIRD_ITEM: 1089 if (hfp_connection->command == HFP_CMD_RETRIEVE_AG_INDICATORS){ 1090 hfp_connection->parser_state = HFP_PARSER_CMD_SEQUENCE; 1091 break; 1092 } 1093 hfp_connection->parser_state = HFP_PARSER_CMD_HEADER; 1094 break; 1095 } 1096 } 1097 1098 void hfp_parse(hfp_connection_t * hfp_connection, uint8_t byte, int isHandsFree){ 1099 // handle ATD<dial_string>; 1100 if (strncmp((const char*)hfp_connection->line_buffer, HFP_CALL_PHONE_NUMBER, strlen(HFP_CALL_PHONE_NUMBER)) == 0){ 1101 // check for end-of-line or ';' 1102 if ((byte == ';') || hfp_parser_is_end_of_line(byte)){ 1103 hfp_connection->line_buffer[hfp_connection->line_size] = 0; 1104 hfp_connection->line_size = 0; 1105 hfp_connection->command = HFP_CMD_CALL_PHONE_NUMBER; 1106 } else { 1107 hfp_connection->line_buffer[hfp_connection->line_size++] = byte; 1108 } 1109 return; 1110 } 1111 1112 // TODO: handle space inside word 1113 if ((byte == ' ') && (hfp_connection->parser_state > HFP_PARSER_CMD_HEADER)) return; 1114 1115 if ((byte == ',') && (hfp_connection->command == HFP_CMD_ENABLE_INDIVIDUAL_AG_INDICATOR_STATUS_UPDATE)){ 1116 if (hfp_connection->line_size == 0){ 1117 hfp_connection->line_buffer[0] = 0; 1118 hfp_connection->ignore_value = 1; 1119 parse_sequence(hfp_connection); 1120 return; 1121 } 1122 } 1123 1124 if (!hfp_parser_found_separator(hfp_connection, byte)){ 1125 hfp_parser_store_byte(hfp_connection, byte); 1126 return; 1127 } 1128 1129 if (hfp_parser_is_end_of_line(byte)) { 1130 if (hfp_parser_is_buffer_empty(hfp_connection)){ 1131 hfp_connection->parser_state = HFP_PARSER_CMD_HEADER; 1132 } 1133 } 1134 if (hfp_parser_is_buffer_empty(hfp_connection)) return; 1135 1136 switch (hfp_connection->parser_state){ 1137 case HFP_PARSER_CMD_HEADER: // header 1138 if (byte == '='){ 1139 hfp_connection->keep_byte = 1; 1140 hfp_parser_store_byte(hfp_connection, byte); 1141 return; 1142 } 1143 1144 if (byte == '?'){ 1145 hfp_connection->keep_byte = 0; 1146 hfp_parser_store_byte(hfp_connection, byte); 1147 return; 1148 } 1149 1150 if (byte == ','){ 1151 hfp_connection->resolve_byte = 1; 1152 } 1153 1154 // printf(" parse header 2 %s, keep separator $ %d\n", hfp_connection->line_buffer, hfp_connection->keep_byte); 1155 if (hfp_parser_is_end_of_header(byte) || (hfp_connection->keep_byte == 1)){ 1156 // printf(" parse header 3 %s, keep separator $ %d\n", hfp_connection->line_buffer, hfp_connection->keep_byte); 1157 char * line_buffer = (char *)hfp_connection->line_buffer; 1158 hfp_connection->command = parse_command(line_buffer, isHandsFree); 1159 1160 /* resolve command name according to hfp_connection */ 1161 if (hfp_connection->command == HFP_CMD_UNKNOWN){ 1162 switch(hfp_connection->state){ 1163 case HFP_W4_LIST_GENERIC_STATUS_INDICATORS: 1164 hfp_connection->command = HFP_CMD_LIST_GENERIC_STATUS_INDICATORS; 1165 break; 1166 case HFP_W4_RETRIEVE_GENERIC_STATUS_INDICATORS: 1167 hfp_connection->command = HFP_CMD_RETRIEVE_GENERIC_STATUS_INDICATORS; 1168 break; 1169 case HFP_W4_RETRIEVE_INITITAL_STATE_GENERIC_STATUS_INDICATORS: 1170 hfp_connection->command = HFP_CMD_RETRIEVE_GENERIC_STATUS_INDICATORS_STATE; 1171 break; 1172 case HFP_W4_RETRIEVE_INDICATORS_STATUS: 1173 hfp_connection->command = HFP_CMD_RETRIEVE_AG_INDICATORS_STATUS; 1174 break; 1175 case HFP_W4_RETRIEVE_INDICATORS: 1176 hfp_connection->send_ag_indicators_segment = 0; 1177 hfp_connection->command = HFP_CMD_RETRIEVE_AG_INDICATORS; 1178 break; 1179 default: 1180 break; 1181 } 1182 } 1183 } 1184 break; 1185 1186 case HFP_PARSER_CMD_SEQUENCE: 1187 parse_sequence(hfp_connection); 1188 break; 1189 case HFP_PARSER_SECOND_ITEM: 1190 switch (hfp_connection->command){ 1191 case HFP_CMD_QUERY_OPERATOR_SELECTION_NAME: 1192 log_info("format %s, ", hfp_connection->line_buffer); 1193 hfp_connection->network_operator.format = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1194 break; 1195 case HFP_CMD_QUERY_OPERATOR_SELECTION_NAME_FORMAT: 1196 log_info("format %s \n", hfp_connection->line_buffer); 1197 hfp_connection->network_operator.format = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1198 break; 1199 case HFP_CMD_LIST_GENERIC_STATUS_INDICATORS: 1200 case HFP_CMD_RETRIEVE_GENERIC_STATUS_INDICATORS: 1201 case HFP_CMD_RETRIEVE_GENERIC_STATUS_INDICATORS_STATE: 1202 hfp_connection->generic_status_indicators[hfp_connection->parser_item_index].state = (uint8_t)btstack_atoi((char*)hfp_connection->line_buffer); 1203 break; 1204 case HFP_CMD_TRANSFER_AG_INDICATOR_STATUS: 1205 hfp_connection->ag_indicators[hfp_connection->parser_item_index].status = (uint8_t)btstack_atoi((char*)hfp_connection->line_buffer); 1206 log_info("%d \n", hfp_connection->ag_indicators[hfp_connection->parser_item_index].status); 1207 hfp_connection->ag_indicators[hfp_connection->parser_item_index].status_changed = 1; 1208 break; 1209 case HFP_CMD_RETRIEVE_AG_INDICATORS: 1210 hfp_connection->ag_indicators[hfp_connection->parser_item_index].min_range = btstack_atoi((char *)hfp_connection->line_buffer); 1211 log_info("%s, ", hfp_connection->line_buffer); 1212 break; 1213 case HFP_CMD_AG_SENT_PHONE_NUMBER: 1214 case HFP_CMD_AG_SENT_CALL_WAITING_NOTIFICATION_UPDATE: 1215 case HFP_CMD_AG_SENT_CLIP_INFORMATION: 1216 hfp_connection->bnip_type = (uint8_t)btstack_atoi((char*)hfp_connection->line_buffer); 1217 break; 1218 default: 1219 break; 1220 } 1221 break; 1222 1223 case HFP_PARSER_THIRD_ITEM: 1224 switch (hfp_connection->command){ 1225 case HFP_CMD_QUERY_OPERATOR_SELECTION_NAME: 1226 strncpy(hfp_connection->network_operator.name, (char *)hfp_connection->line_buffer, HFP_MAX_NETWORK_OPERATOR_NAME_SIZE); 1227 hfp_connection->network_operator.name[HFP_MAX_NETWORK_OPERATOR_NAME_SIZE - 1] = 0; 1228 log_info("name %s\n", hfp_connection->line_buffer); 1229 break; 1230 case HFP_CMD_RETRIEVE_AG_INDICATORS: 1231 hfp_connection->ag_indicators[hfp_connection->parser_item_index].max_range = btstack_atoi((char *)hfp_connection->line_buffer); 1232 hfp_connection->parser_item_index++; 1233 hfp_connection->ag_indicators_nr++; 1234 log_info("%s)\n", hfp_connection->line_buffer); 1235 break; 1236 default: 1237 break; 1238 } 1239 break; 1240 } 1241 hfp_parser_next_state(hfp_connection, byte); 1242 1243 if (hfp_connection->resolve_byte && (hfp_connection->command == HFP_CMD_ENABLE_INDIVIDUAL_AG_INDICATOR_STATUS_UPDATE)){ 1244 hfp_connection->resolve_byte = 0; 1245 hfp_connection->ignore_value = 1; 1246 parse_sequence(hfp_connection); 1247 hfp_connection->line_buffer[0] = 0; 1248 hfp_connection->line_size = 0; 1249 } 1250 } 1251 1252 static void parse_sequence(hfp_connection_t * hfp_connection){ 1253 int value; 1254 switch (hfp_connection->command){ 1255 case HFP_CMD_SET_GENERIC_STATUS_INDICATOR_STATUS: 1256 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1257 int i; 1258 switch (hfp_connection->parser_item_index){ 1259 case 0: 1260 for (i=0;i<hfp_connection->generic_status_indicators_nr;i++){ 1261 if (hfp_connection->generic_status_indicators[i].uuid == value){ 1262 hfp_connection->parser_indicator_index = i; 1263 break; 1264 } 1265 } 1266 break; 1267 case 1: 1268 if (hfp_connection->parser_indicator_index <0) break; 1269 hfp_connection->generic_status_indicators[hfp_connection->parser_indicator_index].state = value; 1270 log_info("HFP_CMD_SET_GENERIC_STATUS_INDICATOR_STATUS set indicator at index %u, to %u\n", 1271 hfp_connection->parser_item_index, value); 1272 break; 1273 default: 1274 break; 1275 } 1276 hfp_connection->parser_item_index++; 1277 break; 1278 1279 case HFP_CMD_GET_SUBSCRIBER_NUMBER_INFORMATION: 1280 switch(hfp_connection->parser_item_index){ 1281 case 0: 1282 strncpy(hfp_connection->bnip_number, (char *)hfp_connection->line_buffer, sizeof(hfp_connection->bnip_number)); 1283 hfp_connection->bnip_number[sizeof(hfp_connection->bnip_number)-1] = 0; 1284 break; 1285 case 1: 1286 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1287 hfp_connection->bnip_type = value; 1288 break; 1289 default: 1290 break; 1291 } 1292 hfp_connection->parser_item_index++; 1293 break; 1294 case HFP_CMD_LIST_CURRENT_CALLS: 1295 switch(hfp_connection->parser_item_index){ 1296 case 0: 1297 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1298 hfp_connection->clcc_idx = value; 1299 break; 1300 case 1: 1301 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1302 hfp_connection->clcc_dir = value; 1303 break; 1304 case 2: 1305 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1306 hfp_connection->clcc_status = value; 1307 break; 1308 case 3: 1309 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1310 hfp_connection->clcc_mode = value; 1311 break; 1312 case 4: 1313 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1314 hfp_connection->clcc_mpty = value; 1315 break; 1316 case 5: 1317 strncpy(hfp_connection->bnip_number, (char *)hfp_connection->line_buffer, sizeof(hfp_connection->bnip_number)); 1318 hfp_connection->bnip_number[sizeof(hfp_connection->bnip_number)-1] = 0; 1319 break; 1320 case 6: 1321 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1322 hfp_connection->bnip_type = value; 1323 break; 1324 default: 1325 break; 1326 } 1327 hfp_connection->parser_item_index++; 1328 break; 1329 case HFP_CMD_SET_MICROPHONE_GAIN: 1330 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1331 hfp_connection->microphone_gain = value; 1332 log_info("hfp parse HFP_CMD_SET_MICROPHONE_GAIN %d\n", value); 1333 break; 1334 case HFP_CMD_SET_SPEAKER_GAIN: 1335 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1336 hfp_connection->speaker_gain = value; 1337 log_info("hfp parse HFP_CMD_SET_SPEAKER_GAIN %d\n", value); 1338 break; 1339 case HFP_CMD_HF_ACTIVATE_VOICE_RECOGNITION: 1340 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1341 hfp_connection->ag_activate_voice_recognition = value; 1342 log_info("hfp parse HFP_CMD_HF_ACTIVATE_VOICE_RECOGNITION %d\n", value); 1343 break; 1344 case HFP_CMD_TURN_OFF_EC_AND_NR: 1345 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1346 hfp_connection->ag_echo_and_noise_reduction = value; 1347 log_info("hfp parse HFP_CMD_TURN_OFF_EC_AND_NR %d\n", value); 1348 break; 1349 case HFP_CMD_CHANGE_IN_BAND_RING_TONE_SETTING: 1350 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1351 hfp_connection->remote_supported_features = store_bit(hfp_connection->remote_supported_features, HFP_AGSF_IN_BAND_RING_TONE, value); 1352 log_info("hfp parse HFP_CHANGE_IN_BAND_RING_TONE_SETTING %d\n", value); 1353 break; 1354 case HFP_CMD_HF_CONFIRMED_CODEC: 1355 hfp_connection->codec_confirmed = btstack_atoi((char*)hfp_connection->line_buffer); 1356 log_info("hfp parse HFP_CMD_HF_CONFIRMED_CODEC %d\n", hfp_connection->codec_confirmed); 1357 break; 1358 case HFP_CMD_AG_SUGGESTED_CODEC: 1359 hfp_connection->suggested_codec = btstack_atoi((char*)hfp_connection->line_buffer); 1360 log_info("hfp parse HFP_CMD_AG_SUGGESTED_CODEC %d\n", hfp_connection->suggested_codec); 1361 break; 1362 case HFP_CMD_SUPPORTED_FEATURES: 1363 hfp_connection->remote_supported_features = btstack_atoi((char*)hfp_connection->line_buffer); 1364 log_info("Parsed supported feature %d\n", (int) hfp_connection->remote_supported_features); 1365 break; 1366 case HFP_CMD_AVAILABLE_CODECS: 1367 log_info("Parsed codec %s\n", hfp_connection->line_buffer); 1368 hfp_connection->remote_codecs[hfp_connection->parser_item_index] = (uint16_t)btstack_atoi((char*)hfp_connection->line_buffer); 1369 hfp_connection->parser_item_index++; 1370 hfp_connection->remote_codecs_nr = hfp_connection->parser_item_index; 1371 break; 1372 case HFP_CMD_RETRIEVE_AG_INDICATORS: 1373 strncpy((char *)hfp_connection->ag_indicators[hfp_connection->parser_item_index].name, (char *)hfp_connection->line_buffer, HFP_MAX_INDICATOR_DESC_SIZE); 1374 hfp_connection->ag_indicators[hfp_connection->parser_item_index].name[HFP_MAX_INDICATOR_DESC_SIZE-1] = 0; 1375 hfp_connection->ag_indicators[hfp_connection->parser_item_index].index = hfp_connection->parser_item_index+1; 1376 log_info("Indicator %d: %s (", hfp_connection->ag_indicators_nr+1, hfp_connection->line_buffer); 1377 break; 1378 case HFP_CMD_RETRIEVE_AG_INDICATORS_STATUS: 1379 log_info("Parsed Indicator %d with status: %s\n", hfp_connection->parser_item_index+1, hfp_connection->line_buffer); 1380 hfp_connection->ag_indicators[hfp_connection->parser_item_index].status = btstack_atoi((char *) hfp_connection->line_buffer); 1381 hfp_connection->parser_item_index++; 1382 break; 1383 case HFP_CMD_ENABLE_INDICATOR_STATUS_UPDATE: 1384 hfp_connection->parser_item_index++; 1385 if (hfp_connection->parser_item_index != 4) break; 1386 log_info("Parsed Enable indicators: %s\n", hfp_connection->line_buffer); 1387 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1388 hfp_connection->enable_status_update_for_ag_indicators = (uint8_t) value; 1389 break; 1390 case HFP_CMD_SUPPORT_CALL_HOLD_AND_MULTIPARTY_SERVICES: 1391 log_info("Parsed Support call hold: %s\n", hfp_connection->line_buffer); 1392 if (hfp_connection->line_size > 2 ) break; 1393 strncpy((char *)hfp_connection->remote_call_services[hfp_connection->remote_call_services_nr].name, (char *)hfp_connection->line_buffer, HFP_CALL_SERVICE_SIZE); 1394 hfp_connection->remote_call_services[hfp_connection->remote_call_services_nr].name[HFP_CALL_SERVICE_SIZE - 1] = 0; 1395 hfp_connection->remote_call_services_nr++; 1396 break; 1397 case HFP_CMD_LIST_GENERIC_STATUS_INDICATORS: 1398 case HFP_CMD_RETRIEVE_GENERIC_STATUS_INDICATORS: 1399 log_info("Parsed Generic status indicator: %s\n", hfp_connection->line_buffer); 1400 hfp_connection->generic_status_indicators[hfp_connection->parser_item_index].uuid = (uint16_t)btstack_atoi((char*)hfp_connection->line_buffer); 1401 hfp_connection->parser_item_index++; 1402 hfp_connection->generic_status_indicators_nr = hfp_connection->parser_item_index; 1403 break; 1404 case HFP_CMD_RETRIEVE_GENERIC_STATUS_INDICATORS_STATE: 1405 // HF parses inital AG gen. ind. state 1406 log_info("Parsed List generic status indicator %s state: ", hfp_connection->line_buffer); 1407 hfp_connection->parser_item_index = (uint8_t)btstack_atoi((char*)hfp_connection->line_buffer); 1408 break; 1409 case HFP_CMD_HF_INDICATOR_STATUS: 1410 hfp_connection->parser_indicator_index = (uint8_t)btstack_atoi((char*)hfp_connection->line_buffer); 1411 log_info("Parsed HF indicator index %u", hfp_connection->parser_indicator_index); 1412 break; 1413 case HFP_CMD_ENABLE_INDIVIDUAL_AG_INDICATOR_STATUS_UPDATE: 1414 // AG parses new gen. ind. state 1415 if (hfp_connection->ignore_value){ 1416 hfp_connection->ignore_value = 0; 1417 log_info("Parsed Enable AG indicator pos %u('%s') - unchanged (stays %u)\n", hfp_connection->parser_item_index, 1418 hfp_connection->ag_indicators[hfp_connection->parser_item_index].name, hfp_connection->ag_indicators[hfp_connection->parser_item_index].enabled); 1419 } 1420 else if (hfp_connection->ag_indicators[hfp_connection->parser_item_index].mandatory){ 1421 log_info("Parsed Enable AG indicator pos %u('%s') - ignore (mandatory)\n", 1422 hfp_connection->parser_item_index, hfp_connection->ag_indicators[hfp_connection->parser_item_index].name); 1423 } else { 1424 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1425 hfp_connection->ag_indicators[hfp_connection->parser_item_index].enabled = value; 1426 log_info("Parsed Enable AG indicator pos %u('%s'): %u\n", hfp_connection->parser_item_index, 1427 hfp_connection->ag_indicators[hfp_connection->parser_item_index].name, value); 1428 } 1429 hfp_connection->parser_item_index++; 1430 break; 1431 case HFP_CMD_TRANSFER_AG_INDICATOR_STATUS: 1432 // indicators are indexed starting with 1 1433 hfp_connection->parser_item_index = btstack_atoi((char *)&hfp_connection->line_buffer[0]) - 1; 1434 log_info("Parsed status of the AG indicator %d, status ", hfp_connection->parser_item_index); 1435 break; 1436 case HFP_CMD_QUERY_OPERATOR_SELECTION_NAME: 1437 hfp_connection->network_operator.mode = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1438 log_info("Parsed network operator mode: %d, ", hfp_connection->network_operator.mode); 1439 break; 1440 case HFP_CMD_QUERY_OPERATOR_SELECTION_NAME_FORMAT: 1441 if (hfp_connection->line_buffer[0] == '3'){ 1442 log_info("Parsed Set network operator format : %s, ", hfp_connection->line_buffer); 1443 break; 1444 } 1445 // TODO emit ERROR, wrong format 1446 log_info("ERROR Set network operator format: index %s not supported\n", hfp_connection->line_buffer); 1447 break; 1448 case HFP_CMD_ERROR: 1449 break; 1450 case HFP_CMD_EXTENDED_AUDIO_GATEWAY_ERROR: 1451 hfp_connection->extended_audio_gateway_error = 1; 1452 hfp_connection->extended_audio_gateway_error_value = (uint8_t)btstack_atoi((char*)hfp_connection->line_buffer); 1453 break; 1454 case HFP_CMD_ENABLE_EXTENDED_AUDIO_GATEWAY_ERROR: 1455 hfp_connection->enable_extended_audio_gateway_error_report = (uint8_t)btstack_atoi((char*)hfp_connection->line_buffer); 1456 hfp_connection->ok_pending = 1; 1457 hfp_connection->extended_audio_gateway_error = 0; 1458 break; 1459 case HFP_CMD_AG_SENT_PHONE_NUMBER: 1460 case HFP_CMD_AG_SENT_CALL_WAITING_NOTIFICATION_UPDATE: 1461 case HFP_CMD_AG_SENT_CLIP_INFORMATION: 1462 strncpy(hfp_connection->bnip_number, (char *)hfp_connection->line_buffer, sizeof(hfp_connection->bnip_number)); 1463 hfp_connection->bnip_number[sizeof(hfp_connection->bnip_number)-1] = 0; 1464 break; 1465 default: 1466 break; 1467 } 1468 } 1469 1470 void hfp_establish_service_level_connection(bd_addr_t bd_addr, uint16_t service_uuid, hfp_role_t local_role){ 1471 hfp_connection_t * hfp_connection = provide_hfp_connection_context_for_bd_addr(bd_addr, local_role); 1472 log_info("hfp_connect %s, hfp_connection %p", bd_addr_to_str(bd_addr), hfp_connection); 1473 1474 if (!hfp_connection) { 1475 log_error("hfp_establish_service_level_connection for addr %s failed", bd_addr_to_str(bd_addr)); 1476 return; 1477 } 1478 switch (hfp_connection->state){ 1479 case HFP_W2_DISCONNECT_RFCOMM: 1480 hfp_connection->state = HFP_SERVICE_LEVEL_CONNECTION_ESTABLISHED; 1481 return; 1482 case HFP_W4_RFCOMM_DISCONNECTED: 1483 hfp_connection->state = HFP_W4_RFCOMM_DISCONNECTED_AND_RESTART; 1484 return; 1485 case HFP_IDLE: 1486 memcpy(hfp_connection->remote_addr, bd_addr, 6); 1487 hfp_connection->state = HFP_W4_SDP_QUERY_COMPLETE; 1488 connection_doing_sdp_query = hfp_connection; 1489 hfp_connection->service_uuid = service_uuid; 1490 sdp_client_query_rfcomm_channel_and_name_for_uuid(&handle_query_rfcomm_event, hfp_connection->remote_addr, service_uuid); 1491 break; 1492 default: 1493 break; 1494 } 1495 } 1496 1497 void hfp_release_service_level_connection(hfp_connection_t * hfp_connection){ 1498 if (!hfp_connection) return; 1499 hfp_release_audio_connection(hfp_connection); 1500 1501 if (hfp_connection->state < HFP_W4_RFCOMM_CONNECTED){ 1502 hfp_connection->state = HFP_IDLE; 1503 return; 1504 } 1505 1506 if (hfp_connection->state == HFP_W4_RFCOMM_CONNECTED){ 1507 hfp_connection->state = HFP_W4_CONNECTION_ESTABLISHED_TO_SHUTDOWN; 1508 return; 1509 } 1510 1511 if (hfp_connection->state < HFP_W4_SCO_CONNECTED){ 1512 hfp_connection->state = HFP_W2_DISCONNECT_RFCOMM; 1513 return; 1514 } 1515 1516 if (hfp_connection->state < HFP_W4_SCO_DISCONNECTED){ 1517 hfp_connection->state = HFP_W2_DISCONNECT_SCO; 1518 return; 1519 } 1520 1521 // HFP_W4_SCO_DISCONNECTED or later 1522 hfp_connection->release_slc_connection = 1; 1523 } 1524 1525 void hfp_release_audio_connection(hfp_connection_t * hfp_connection){ 1526 if (!hfp_connection) return; 1527 if (hfp_connection->state >= HFP_W2_DISCONNECT_SCO) return; 1528 hfp_connection->release_audio_connection = 1; 1529 } 1530 1531 static const struct link_settings { 1532 const uint16_t max_latency; 1533 const uint8_t retransmission_effort; 1534 const uint16_t packet_types; 1535 } hfp_link_settings [] = { 1536 { 0xffff, 0xff, 0x03c1 }, // HFP_LINK_SETTINGS_D0, HV1 1537 { 0xffff, 0xff, 0x03c4 }, // HFP_LINK_SETTINGS_D1, HV3 1538 { 0x0007, 0x01, 0x03c8 }, // HFP_LINK_SETTINGS_S1, EV3 1539 { 0x0007, 0x01, 0x0380 }, // HFP_LINK_SETTINGS_S2, 2-EV3 1540 { 0x000a, 0x01, 0x0380 }, // HFP_LINK_SETTINGS_S3, 2-EV3 1541 { 0x000c, 0x02, 0x0380 }, // HFP_LINK_SETTINGS_S4, 2-EV3 1542 { 0x0008, 0x02, 0x03c8 }, // HFP_LINK_SETTINGS_T1, EV3 1543 { 0x000d, 0x02, 0x0380 } // HFP_LINK_SETTINGS_T2, 2-EV3 1544 }; 1545 1546 void hfp_setup_synchronous_connection(hfp_connection_t * hfp_connection){ 1547 // all packet types, fixed bandwidth 1548 int setting = hfp_connection->link_setting; 1549 log_info("hfp_setup_synchronous_connection using setting nr %u", setting); 1550 sco_establishment_active = hfp_connection; 1551 uint16_t sco_voice_setting = hci_get_sco_voice_setting(); 1552 if (hfp_connection->negotiated_codec == HFP_CODEC_MSBC){ 1553 sco_voice_setting = 0x0043; // Transparent data 1554 } 1555 hci_send_cmd(&hci_setup_synchronous_connection, hfp_connection->acl_handle, 8000, 8000, hfp_link_settings[setting].max_latency, 1556 sco_voice_setting, hfp_link_settings[setting].retransmission_effort, hfp_link_settings[setting].packet_types); // all types 0x003f, only 2-ev3 0x380 1557 } 1558 1559 void hfp_set_hf_callback(btstack_packet_handler_t callback){ 1560 hfp_hf_callback = callback; 1561 } 1562 1563 void hfp_set_ag_callback(btstack_packet_handler_t callback){ 1564 hfp_ag_callback = callback; 1565 } 1566 1567 void hfp_set_ag_rfcomm_packet_handler(btstack_packet_handler_t handler){ 1568 hfp_ag_rfcomm_packet_handler = handler; 1569 } 1570 1571 void hfp_set_hf_rfcomm_packet_handler(btstack_packet_handler_t handler){ 1572 hfp_hf_rfcomm_packet_handler = handler; 1573 } 1574 1575 void hfp_set_hf_run_for_context(void (*callback)(hfp_connection_t * hfp_connection)){ 1576 hfp_hf_run_for_context = callback; 1577 } 1578 1579 void hfp_init(void){ 1580 } 1581 1582 void hfp_init_link_settings(hfp_connection_t * hfp_connection, uint8_t esco_s4_supported){ 1583 // determine highest possible link setting 1584 hfp_connection->link_setting = HFP_LINK_SETTINGS_D1; 1585 // anything else requires eSCO support on both sides 1586 if (hci_extended_sco_link_supported() && hci_remote_esco_supported(hfp_connection->acl_handle)){ 1587 switch (hfp_connection->negotiated_codec){ 1588 case HFP_CODEC_CVSD: 1589 hfp_connection->link_setting = HFP_LINK_SETTINGS_S3; 1590 if (esco_s4_supported){ 1591 hfp_connection->link_setting = HFP_LINK_SETTINGS_S4; 1592 } 1593 break; 1594 case HFP_CODEC_MSBC: 1595 hfp_connection->link_setting = HFP_LINK_SETTINGS_T2; 1596 break; 1597 default: 1598 break; 1599 } 1600 } 1601 log_info("hfp_init_link_settings: %u", hfp_connection->link_setting); 1602 } 1603 1604 #define HFP_HF_RX_DEBUG_PRINT_LINE 80 1605 1606 void hfp_log_rfcomm_message(const char * tag, uint8_t * packet, uint16_t size){ 1607 #ifdef ENABLE_LOG_INFO 1608 // encode \n\r 1609 char printable[HFP_HF_RX_DEBUG_PRINT_LINE+2]; 1610 int i = 0; 1611 int pos; 1612 for (pos=0 ; (pos < size) && (i < (HFP_HF_RX_DEBUG_PRINT_LINE - 3)) ; pos++){ 1613 switch (packet[pos]){ 1614 case '\n': 1615 printable[i++] = '\\'; 1616 printable[i++] = 'n'; 1617 break; 1618 case '\r': 1619 printable[i++] = '\\'; 1620 printable[i++] = 'r'; 1621 break; 1622 default: 1623 printable[i++] = packet[pos]; 1624 break; 1625 } 1626 } 1627 printable[i] = 0; 1628 log_info("%s: '%s'", tag, printable); 1629 #endif 1630 } 1631