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 (void)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->found_equal_sign = false; 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 (void)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(packet_type); 617 UNUSED(channel); // ok: no channel 618 UNUSED(size); 619 620 bd_addr_t event_addr; 621 hci_con_handle_t handle; 622 hfp_connection_t * hfp_connection = NULL; 623 uint8_t status; 624 625 log_debug("HFP HCI event handler type %u, event type %x, size %u", packet_type, hci_event_packet_get_type(packet), size); 626 627 switch (hci_event_packet_get_type(packet)) { 628 629 case HCI_EVENT_CONNECTION_REQUEST: 630 switch(hci_event_connection_request_get_link_type(packet)){ 631 case 0: // SCO 632 case 2: // eSCO 633 hci_event_connection_request_get_bd_addr(packet, event_addr); 634 hfp_connection = get_hfp_connection_context_for_bd_addr(event_addr, local_role); 635 if (!hfp_connection) break; 636 if (hci_event_connection_request_get_link_type(packet) == 2){ 637 hfp_connection->hf_accept_sco = 2; 638 } else { 639 hfp_connection->hf_accept_sco = 1; 640 } 641 log_info("hf accept sco %u\n", hfp_connection->hf_accept_sco); 642 if (!hfp_hf_run_for_context) break; 643 (*hfp_hf_run_for_context)(hfp_connection); 644 break; 645 default: 646 break; 647 } 648 break; 649 650 case HCI_EVENT_COMMAND_STATUS: 651 if (hci_event_command_status_get_command_opcode(packet) == hci_setup_synchronous_connection.opcode) { 652 status = hci_event_command_status_get_status(packet); 653 if (status == ERROR_CODE_SUCCESS) break; 654 655 hfp_connection = sco_establishment_active; 656 if (hfp_handle_failed_sco_connection(status)) break; 657 hfp_connection->establish_audio_connection = 0; 658 hfp_connection->state = HFP_SERVICE_LEVEL_CONNECTION_ESTABLISHED; 659 hfp_emit_sco_event(hfp_connection, status, 0, hfp_connection->remote_addr, hfp_connection->negotiated_codec); 660 } 661 break; 662 663 case HCI_EVENT_SYNCHRONOUS_CONNECTION_COMPLETE:{ 664 hci_event_synchronous_connection_complete_get_bd_addr(packet, event_addr); 665 hfp_connection = get_hfp_connection_context_for_bd_addr(event_addr, local_role); 666 if (!hfp_connection) { 667 log_error("HFP: connection does not exist for remote with addr %s.", bd_addr_to_str(event_addr)); 668 return; 669 } 670 671 status = hci_event_synchronous_connection_complete_get_status(packet); 672 if (status != ERROR_CODE_SUCCESS){ 673 hfp_connection->hf_accept_sco = 0; 674 if (hfp_handle_failed_sco_connection(status)) break; 675 676 hfp_connection->establish_audio_connection = 0; 677 hfp_connection->state = HFP_SERVICE_LEVEL_CONNECTION_ESTABLISHED; 678 hfp_emit_sco_event(hfp_connection, status, 0, event_addr, hfp_connection->negotiated_codec); 679 break; 680 } 681 682 uint16_t sco_handle = hci_event_synchronous_connection_complete_get_handle(packet); 683 uint8_t link_type = hci_event_synchronous_connection_complete_get_link_type(packet); 684 uint8_t transmission_interval = hci_event_synchronous_connection_complete_get_transmission_interval(packet); // measured in slots 685 uint8_t retransmission_interval = hci_event_synchronous_connection_complete_get_retransmission_interval(packet);// measured in slots 686 uint16_t rx_packet_length = hci_event_synchronous_connection_complete_get_rx_packet_length(packet); // measured in bytes 687 uint16_t tx_packet_length = hci_event_synchronous_connection_complete_get_tx_packet_length(packet); // measured in bytes 688 uint8_t air_mode = hci_event_synchronous_connection_complete_get_air_mode(packet); 689 690 switch (link_type){ 691 case 0x00: 692 log_info("SCO Connection established."); 693 if (transmission_interval != 0) log_error("SCO Connection: transmission_interval not zero: %d.", transmission_interval); 694 if (retransmission_interval != 0) log_error("SCO Connection: retransmission_interval not zero: %d.", retransmission_interval); 695 if (rx_packet_length != 0) log_error("SCO Connection: rx_packet_length not zero: %d.", rx_packet_length); 696 if (tx_packet_length != 0) log_error("SCO Connection: tx_packet_length not zero: %d.", tx_packet_length); 697 break; 698 case 0x02: 699 log_info("eSCO Connection established. \n"); 700 break; 701 default: 702 log_error("(e)SCO reserved link_type 0x%2x", link_type); 703 break; 704 } 705 log_info("sco_handle 0x%2x, address %s, transmission_interval %u slots, retransmission_interval %u slots, " 706 " rx_packet_length %u bytes, tx_packet_length %u bytes, air_mode 0x%2x (0x02 == CVSD)\n", sco_handle, 707 bd_addr_to_str(event_addr), transmission_interval, retransmission_interval, rx_packet_length, tx_packet_length, air_mode); 708 709 // hfp_connection = get_hfp_connection_context_for_bd_addr(event_addr, local_role); 710 711 // if (!hfp_connection) { 712 // log_error("SCO link created, hfp_connection for address %s not found.", bd_addr_to_str(event_addr)); 713 // break; 714 // } 715 716 if (hfp_connection->state == HFP_W4_CONNECTION_ESTABLISHED_TO_SHUTDOWN){ 717 log_info("SCO about to disconnect: HFP_W4_CONNECTION_ESTABLISHED_TO_SHUTDOWN"); 718 hfp_connection->state = HFP_W2_DISCONNECT_SCO; 719 break; 720 } 721 hfp_connection->sco_handle = sco_handle; 722 hfp_connection->establish_audio_connection = 0; 723 hfp_connection->state = HFP_AUDIO_CONNECTION_ESTABLISHED; 724 hfp_emit_sco_event(hfp_connection, status, sco_handle, event_addr, hfp_connection->negotiated_codec); 725 break; 726 } 727 728 case HCI_EVENT_DISCONNECTION_COMPLETE: 729 handle = little_endian_read_16(packet,3); 730 hfp_connection = get_hfp_connection_context_for_sco_handle(handle, local_role); 731 732 if (!hfp_connection) break; 733 734 hfp_connection->sco_handle = HCI_CON_HANDLE_INVALID; 735 hfp_connection->release_audio_connection = 0; 736 hfp_connection->state = HFP_SERVICE_LEVEL_CONNECTION_ESTABLISHED; 737 hfp_emit_event(hfp_connection, HFP_SUBEVENT_AUDIO_CONNECTION_RELEASED, 0); 738 739 if (hfp_connection->release_slc_connection){ 740 hfp_connection->release_slc_connection = 0; 741 log_info("SCO disconnected, w2 disconnect RFCOMM\n"); 742 hfp_connection->state = HFP_W2_DISCONNECT_RFCOMM; 743 } 744 break; 745 746 default: 747 break; 748 } 749 } 750 751 void hfp_handle_rfcomm_event(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size, hfp_role_t local_role){ 752 UNUSED(packet_type); 753 UNUSED(channel); // ok: no channel 754 UNUSED(size); 755 756 bd_addr_t event_addr; 757 uint16_t rfcomm_cid; 758 hfp_connection_t * hfp_connection = NULL; 759 uint8_t status; 760 761 log_debug("HFP packet_handler type %u, event type %x, size %u", packet_type, hci_event_packet_get_type(packet), size); 762 763 switch (hci_event_packet_get_type(packet)) { 764 765 case RFCOMM_EVENT_INCOMING_CONNECTION: 766 // data: event (8), len(8), address(48), channel (8), rfcomm_cid (16) 767 rfcomm_event_incoming_connection_get_bd_addr(packet, event_addr); 768 hfp_connection = provide_hfp_connection_context_for_bd_addr(event_addr, local_role); 769 if (!hfp_connection){ 770 log_info("hfp: no memory to accept incoming connection - decline"); 771 rfcomm_decline_connection(rfcomm_event_incoming_connection_get_rfcomm_cid(packet)); 772 return; 773 } 774 if (hfp_connection->state != HFP_IDLE) { 775 log_error("hfp: incoming connection but not idle, reject"); 776 rfcomm_decline_connection(rfcomm_event_incoming_connection_get_rfcomm_cid(packet)); 777 return; 778 } 779 780 hfp_connection->rfcomm_cid = rfcomm_event_incoming_connection_get_rfcomm_cid(packet); 781 hfp_connection->state = HFP_W4_RFCOMM_CONNECTED; 782 // printf("RFCOMM channel %u requested for %s\n", hfp_connection->rfcomm_cid, bd_addr_to_str(hfp_connection->remote_addr)); 783 rfcomm_accept_connection(hfp_connection->rfcomm_cid); 784 break; 785 786 case RFCOMM_EVENT_CHANNEL_OPENED: 787 // data: event(8), len(8), status (8), address (48), handle(16), server channel(8), rfcomm_cid(16), max frame size(16) 788 789 rfcomm_event_channel_opened_get_bd_addr(packet, event_addr); 790 status = rfcomm_event_channel_opened_get_status(packet); 791 792 hfp_connection = get_hfp_connection_context_for_bd_addr(event_addr, local_role); 793 if (!hfp_connection || (hfp_connection->state != HFP_W4_RFCOMM_CONNECTED)) return; 794 795 if (status) { 796 hfp_emit_slc_connection_event(hfp_connection, status, rfcomm_event_channel_opened_get_con_handle(packet), event_addr); 797 remove_hfp_connection_context(hfp_connection); 798 } else { 799 hfp_connection->acl_handle = rfcomm_event_channel_opened_get_con_handle(packet); 800 hfp_connection->rfcomm_cid = rfcomm_event_channel_opened_get_rfcomm_cid(packet); 801 bd_addr_copy(hfp_connection->remote_addr, event_addr); 802 // uint16_t mtu = rfcomm_event_channel_opened_get_max_frame_size(packet); 803 // 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); 804 805 switch (hfp_connection->state){ 806 case HFP_W4_RFCOMM_CONNECTED: 807 hfp_connection->state = HFP_EXCHANGE_SUPPORTED_FEATURES; 808 break; 809 case HFP_W4_CONNECTION_ESTABLISHED_TO_SHUTDOWN: 810 hfp_connection->state = HFP_W2_DISCONNECT_RFCOMM; 811 // printf("Shutting down RFCOMM.\n"); 812 break; 813 default: 814 break; 815 } 816 rfcomm_request_can_send_now_event(hfp_connection->rfcomm_cid); 817 } 818 break; 819 820 case RFCOMM_EVENT_CHANNEL_CLOSED: 821 rfcomm_cid = little_endian_read_16(packet,2); 822 hfp_connection = get_hfp_connection_context_for_rfcomm_cid(rfcomm_cid); 823 if (!hfp_connection) break; 824 if (hfp_connection->state == HFP_W4_RFCOMM_DISCONNECTED_AND_RESTART){ 825 hfp_connection->state = HFP_IDLE; 826 hfp_establish_service_level_connection(hfp_connection->remote_addr, hfp_connection->service_uuid, local_role); 827 break; 828 } 829 830 hfp_emit_event(hfp_connection, HFP_SUBEVENT_SERVICE_LEVEL_CONNECTION_RELEASED, 0); 831 remove_hfp_connection_context(hfp_connection); 832 break; 833 834 default: 835 break; 836 } 837 } 838 // translates command string into hfp_command_t CMD 839 840 typedef struct { 841 const char * command; 842 hfp_command_t command_id; 843 } hfp_command_entry_t; 844 845 static hfp_command_entry_t hfp_ag_commmand_table[] = { 846 { "AT+BIND=", HFP_CMD_LIST_GENERIC_STATUS_INDICATORS }, 847 { "AT+BIND=?", HFP_CMD_RETRIEVE_GENERIC_STATUS_INDICATORS }, 848 { "AT+BIND?", HFP_CMD_RETRIEVE_GENERIC_STATUS_INDICATORS_STATE }, 849 { "AT+BTRH=", HFP_CMD_RESPONSE_AND_HOLD_COMMAND}, 850 { "AT+BTRH?", HFP_CMD_RESPONSE_AND_HOLD_QUERY}, 851 { "AT+CHLD=", HFP_CMD_CALL_HOLD }, 852 { "AT+CHLD=?", HFP_CMD_SUPPORT_CALL_HOLD_AND_MULTIPARTY_SERVICES }, 853 { "AT+CIND=?", HFP_CMD_RETRIEVE_AG_INDICATORS}, 854 { "AT+CIND?", HFP_CMD_RETRIEVE_AG_INDICATORS_STATUS }, 855 { "AT+COPS=", HFP_CMD_QUERY_OPERATOR_SELECTION_NAME_FORMAT }, 856 { "AT+COPS?", HFP_CMD_QUERY_OPERATOR_SELECTION_NAME }, 857 { "ATA", HFP_CMD_CALL_ANSWERED }, 858 }; 859 860 static hfp_command_entry_t hfp_hf_commmand_table[] = { 861 { "+BIND:", HFP_CMD_SET_GENERIC_STATUS_INDICATOR_STATUS }, 862 { "+BTRH:", HFP_CMD_RESPONSE_AND_HOLD_STATUS }, 863 { "+CHLD:", HFP_CMD_SUPPORT_CALL_HOLD_AND_MULTIPARTY_SERVICES }, 864 { "+COPS:", HFP_CMD_QUERY_OPERATOR_SELECTION_NAME }, 865 { "+CIND:", HFP_CMD_RETRIEVE_AG_INDICATORS_GENERIC }, 866 }; 867 868 typedef struct { 869 const char * command; 870 hfp_command_t hf_command_id; 871 hfp_command_t ag_command_id; 872 } hfp_command_table_t; 873 874 static hfp_command_table_t hfp_command_table[] = { 875 { "+BAC", HFP_CMD_AVAILABLE_CODECS, HFP_CMD_AVAILABLE_CODECS}, 876 { "+BCC", HFP_CMD_TRIGGER_CODEC_CONNECTION_SETUP, HFP_CMD_TRIGGER_CODEC_CONNECTION_SETUP}, 877 { "+BCS", HFP_CMD_AG_SUGGESTED_CODEC, HFP_CMD_HF_CONFIRMED_CODEC}, 878 { "+BIA", HFP_CMD_ENABLE_INDIVIDUAL_AG_INDICATOR_STATUS_UPDATE, HFP_CMD_ENABLE_INDIVIDUAL_AG_INDICATOR_STATUS_UPDATE}, // +BIA:<enabled>,,<enabled>,,,<enabled> 879 { "+BIEV", HFP_CMD_HF_INDICATOR_STATUS, HFP_CMD_HF_INDICATOR_STATUS}, 880 { "+BINP", HFP_CMD_AG_SENT_PHONE_NUMBER, HFP_CMD_HF_REQUEST_PHONE_NUMBER}, 881 { "+BLDN", HFP_CMD_REDIAL_LAST_NUMBER, HFP_CMD_REDIAL_LAST_NUMBER}, 882 { "+BRSF", HFP_CMD_SUPPORTED_FEATURES, HFP_CMD_SUPPORTED_FEATURES}, 883 { "+BSIR", HFP_CMD_CHANGE_IN_BAND_RING_TONE_SETTING, HFP_CMD_CHANGE_IN_BAND_RING_TONE_SETTING}, 884 { "+BVRA", HFP_CMD_AG_ACTIVATE_VOICE_RECOGNITION, HFP_CMD_HF_ACTIVATE_VOICE_RECOGNITION }, // EC (Echo CAnceling), NR (Noise Reduction) 885 { "+CCWA", HFP_CMD_AG_SENT_CALL_WAITING_NOTIFICATION_UPDATE, HFP_CMD_ENABLE_CALL_WAITING_NOTIFICATION}, 886 { "+CHUP", HFP_CMD_HANG_UP_CALL, HFP_CMD_HANG_UP_CALL}, 887 { "+CIEV", HFP_CMD_TRANSFER_AG_INDICATOR_STATUS, HFP_CMD_TRANSFER_AG_INDICATOR_STATUS}, 888 { "+CLCC", HFP_CMD_LIST_CURRENT_CALLS, HFP_CMD_LIST_CURRENT_CALLS}, 889 { "+CLIP", HFP_CMD_AG_SENT_CLIP_INFORMATION, HFP_CMD_ENABLE_CLIP}, 890 { "+CME ERROR", HFP_CMD_EXTENDED_AUDIO_GATEWAY_ERROR, HFP_CMD_NONE}, 891 { "+CMEE", HFP_CMD_NONE, HFP_CMD_ENABLE_EXTENDED_AUDIO_GATEWAY_ERROR}, 892 { "+CMER", HFP_CMD_ENABLE_INDICATOR_STATUS_UPDATE, HFP_CMD_ENABLE_INDICATOR_STATUS_UPDATE}, 893 { "+CNUM", HFP_CMD_GET_SUBSCRIBER_NUMBER_INFORMATION, HFP_CMD_GET_SUBSCRIBER_NUMBER_INFORMATION}, 894 { "+NREC", HFP_CMD_TURN_OFF_EC_AND_NR, HFP_CMD_TURN_OFF_EC_AND_NR }, // EC (Echo CAnceling), NR (Noise Reduction)} 895 { "+VGM", HFP_CMD_SET_MICROPHONE_GAIN, HFP_CMD_SET_MICROPHONE_GAIN}, 896 { "+VGS", HFP_CMD_SET_SPEAKER_GAIN, HFP_CMD_SET_SPEAKER_GAIN}, 897 { "+VTS", HFP_CMD_TRANSMIT_DTMF_CODES, HFP_CMD_TRANSMIT_DTMF_CODES}, 898 { "ERROR", HFP_CMD_ERROR, HFP_CMD_ERROR}, 899 { "NOP", HFP_CMD_NONE, HFP_CMD_NONE}, // dummy commmand used by unit tests 900 { "OK", HFP_CMD_OK, HFP_CMD_NONE}, 901 { "RING", HFP_CMD_RING, HFP_CMD_RING}, 902 }; 903 904 static hfp_command_t parse_command(const char * line_buffer, int isHandsFree){ 905 906 // note: if parser in CMD_HEADER state would treats digits and maybe '+' as separator, match on "ATD" would work. 907 // prefix match on 'ATD', AG only 908 if ((isHandsFree == 0) && (strncmp(line_buffer, HFP_CALL_PHONE_NUMBER, strlen(HFP_CALL_PHONE_NUMBER)) == 0)){ 909 return HFP_CMD_CALL_PHONE_NUMBER; 910 } 911 912 uint16_t offset = isHandsFree ? 0 : 2; 913 914 uint16_t i; 915 uint16_t num_entries; 916 917 // role-based table lookup 918 hfp_command_entry_t * table; 919 if (isHandsFree == 0){ 920 table = hfp_ag_commmand_table; 921 num_entries = sizeof(hfp_ag_commmand_table) / sizeof(hfp_command_entry_t); 922 } else { 923 table = hfp_hf_commmand_table; 924 num_entries = sizeof(hfp_hf_commmand_table) / sizeof(hfp_command_entry_t); 925 } 926 for (i=0;i<num_entries;i++) { 927 hfp_command_entry_t *entry = &table[i]; 928 int match = strcmp(line_buffer, entry->command); 929 if (match == 0){ 930 return entry->command_id; 931 } 932 } 933 934 // combined table lookup 935 num_entries = sizeof(hfp_command_table) / sizeof(hfp_command_table_t); 936 for (i=0;i<num_entries;i++){ 937 hfp_command_table_t * entry = &hfp_command_table[i]; 938 bool match = strncmp(line_buffer+offset, entry->command, strlen(entry->command)) == 0; 939 if (match){ 940 if (isHandsFree == 1){ 941 if (entry->hf_command_id != HFP_CMD_NONE) return entry->hf_command_id; 942 } else { 943 if (entry->ag_command_id != HFP_CMD_NONE) return entry->ag_command_id; 944 } 945 } 946 } 947 948 if (strncmp(line_buffer+offset, "AT+", 3) == 0){ 949 return HFP_CMD_UNKNOWN; 950 } 951 952 if (strncmp(line_buffer+offset, "+", 1) == 0){ 953 return HFP_CMD_UNKNOWN; 954 } 955 956 return HFP_CMD_NONE; 957 } 958 959 static void hfp_parser_store_byte(hfp_connection_t * hfp_connection, uint8_t byte){ 960 if ((hfp_connection->line_size + 1 ) >= HFP_MAX_INDICATOR_DESC_SIZE) return; 961 hfp_connection->line_buffer[hfp_connection->line_size++] = byte; 962 hfp_connection->line_buffer[hfp_connection->line_size] = 0; 963 } 964 static int hfp_parser_is_buffer_empty(hfp_connection_t * hfp_connection){ 965 return hfp_connection->line_size == 0; 966 } 967 968 static int hfp_parser_is_end_of_line(uint8_t byte){ 969 return (byte == '\n') || (byte == '\r'); 970 } 971 972 static void hfp_parser_reset_line_buffer(hfp_connection_t *hfp_connection) { 973 hfp_connection->line_size = 0; 974 hfp_connection->line_buffer[0] = 0; 975 } 976 977 static void hfp_parser_store_if_token(hfp_connection_t * hfp_connection, uint8_t byte){ 978 switch (byte){ 979 case ',': 980 case ';': 981 case '(': 982 case ')': 983 case '\n': 984 case '\r': 985 break; 986 default: 987 hfp_parser_store_byte(hfp_connection, byte); 988 break; 989 } 990 } 991 992 static bool hfp_parser_is_separator( uint8_t byte){ 993 switch (byte){ 994 case ',': 995 case ';': 996 case '\n': 997 case '\r': 998 return true; 999 default: 1000 return false; 1001 } 1002 } 1003 1004 static bool hfp_parse_byte(hfp_connection_t * hfp_connection, uint8_t byte, int isHandsFree){ 1005 1006 // handle doubles quotes 1007 if (byte == '"'){ 1008 hfp_connection->parser_quoted = !hfp_connection->parser_quoted; 1009 return true; 1010 } 1011 if (hfp_connection->parser_quoted) { 1012 hfp_parser_store_byte(hfp_connection, byte); 1013 return true; 1014 } 1015 1016 // ignore spaces outside command or double quotes (required e.g. for '+CME ERROR:..") command 1017 if ((byte == ' ') && (hfp_connection->parser_state != HFP_PARSER_CMD_HEADER)) return true; 1018 1019 bool processed = true; 1020 1021 switch (hfp_connection->parser_state) { 1022 case HFP_PARSER_CMD_HEADER: 1023 switch (byte) { 1024 case '\n': 1025 case '\r': 1026 case ';': 1027 // ignore separator 1028 break; 1029 case ':': 1030 case '?': 1031 // store separator 1032 hfp_parser_store_byte(hfp_connection, byte); 1033 break; 1034 case '=': 1035 // equal sign: remember and wait for next char to decided between '=?' and '=\?' 1036 hfp_connection->found_equal_sign = true; 1037 hfp_parser_store_byte(hfp_connection, byte); 1038 return true; 1039 default: 1040 // store if not lookahead 1041 if (!hfp_connection->found_equal_sign) { 1042 hfp_parser_store_byte(hfp_connection, byte); 1043 return true; 1044 } 1045 // mark as lookahead 1046 processed = false; 1047 break; 1048 } 1049 1050 // ignore empty tokens 1051 if (hfp_parser_is_buffer_empty(hfp_connection)) return true; 1052 1053 // parse 1054 hfp_connection->command = parse_command((char *)hfp_connection->line_buffer, isHandsFree); 1055 1056 // pick +CIND version based on connection state: descriptions during SLC vs. states later 1057 if (hfp_connection->command == HFP_CMD_RETRIEVE_AG_INDICATORS_GENERIC){ 1058 switch(hfp_connection->state){ 1059 case HFP_W4_RETRIEVE_INDICATORS_STATUS: 1060 hfp_connection->command = HFP_CMD_RETRIEVE_AG_INDICATORS_STATUS; 1061 break; 1062 case HFP_W4_RETRIEVE_INDICATORS: 1063 hfp_connection->command = HFP_CMD_RETRIEVE_AG_INDICATORS; 1064 break; 1065 default: 1066 btstack_assert(false); 1067 hfp_connection->command = HFP_CMD_UNKNOWN; 1068 break; 1069 } 1070 } 1071 1072 log_info("command string '%s', handsfree %u -> cmd id %u", (char *)hfp_connection->line_buffer, isHandsFree, hfp_connection->command); 1073 1074 // next state 1075 hfp_connection->found_equal_sign = false; 1076 hfp_parser_reset_line_buffer(hfp_connection); 1077 hfp_connection->parser_state = HFP_PARSER_CMD_SEQUENCE; 1078 1079 return processed; 1080 1081 case HFP_PARSER_CMD_SEQUENCE: 1082 // handle empty fields 1083 if ((byte == ',' ) && (hfp_connection->line_size == 0)){ 1084 hfp_connection->line_buffer[0] = 0; 1085 hfp_connection->ignore_value = 1; 1086 parse_sequence(hfp_connection); 1087 return true; 1088 } 1089 1090 hfp_parser_store_if_token(hfp_connection, byte); 1091 if (!hfp_parser_is_separator(byte)) return true; 1092 1093 // ignore empty tokens 1094 if (hfp_parser_is_buffer_empty(hfp_connection) && (hfp_connection->ignore_value == 0)) return true; 1095 1096 parse_sequence(hfp_connection); 1097 1098 hfp_parser_reset_line_buffer(hfp_connection); 1099 1100 switch (hfp_connection->command){ 1101 case HFP_CMD_AG_SENT_PHONE_NUMBER: 1102 case HFP_CMD_AG_SENT_CALL_WAITING_NOTIFICATION_UPDATE: 1103 case HFP_CMD_AG_SENT_CLIP_INFORMATION: 1104 case HFP_CMD_TRANSFER_AG_INDICATOR_STATUS: 1105 case HFP_CMD_QUERY_OPERATOR_SELECTION_NAME: 1106 case HFP_CMD_QUERY_OPERATOR_SELECTION_NAME_FORMAT: 1107 case HFP_CMD_RETRIEVE_AG_INDICATORS: 1108 case HFP_CMD_RETRIEVE_GENERIC_STATUS_INDICATORS_STATE: 1109 case HFP_CMD_HF_INDICATOR_STATUS: 1110 hfp_connection->parser_state = HFP_PARSER_SECOND_ITEM; 1111 break; 1112 default: 1113 break; 1114 } 1115 return true; 1116 1117 case HFP_PARSER_SECOND_ITEM: 1118 1119 hfp_parser_store_if_token(hfp_connection, byte); 1120 if (!hfp_parser_is_separator(byte)) return true; 1121 1122 switch (hfp_connection->command){ 1123 case HFP_CMD_QUERY_OPERATOR_SELECTION_NAME: 1124 log_info("format %s, ", hfp_connection->line_buffer); 1125 hfp_connection->network_operator.format = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1126 break; 1127 case HFP_CMD_QUERY_OPERATOR_SELECTION_NAME_FORMAT: 1128 log_info("format %s \n", hfp_connection->line_buffer); 1129 hfp_connection->network_operator.format = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1130 break; 1131 case HFP_CMD_LIST_GENERIC_STATUS_INDICATORS: 1132 case HFP_CMD_RETRIEVE_GENERIC_STATUS_INDICATORS: 1133 case HFP_CMD_RETRIEVE_GENERIC_STATUS_INDICATORS_STATE: 1134 hfp_connection->generic_status_indicators[hfp_connection->parser_item_index].state = (uint8_t)btstack_atoi((char*)hfp_connection->line_buffer); 1135 break; 1136 case HFP_CMD_TRANSFER_AG_INDICATOR_STATUS: 1137 hfp_connection->ag_indicators[hfp_connection->parser_item_index].status = (uint8_t)btstack_atoi((char*)hfp_connection->line_buffer); 1138 log_info("%d \n", hfp_connection->ag_indicators[hfp_connection->parser_item_index].status); 1139 hfp_connection->ag_indicators[hfp_connection->parser_item_index].status_changed = 1; 1140 break; 1141 case HFP_CMD_RETRIEVE_AG_INDICATORS: 1142 hfp_connection->ag_indicators[hfp_connection->parser_item_index].min_range = btstack_atoi((char *)hfp_connection->line_buffer); 1143 log_info("%s, ", hfp_connection->line_buffer); 1144 break; 1145 case HFP_CMD_AG_SENT_PHONE_NUMBER: 1146 case HFP_CMD_AG_SENT_CALL_WAITING_NOTIFICATION_UPDATE: 1147 case HFP_CMD_AG_SENT_CLIP_INFORMATION: 1148 hfp_connection->bnip_type = (uint8_t)btstack_atoi((char*)hfp_connection->line_buffer); 1149 break; 1150 default: 1151 break; 1152 } 1153 1154 hfp_parser_reset_line_buffer(hfp_connection); 1155 1156 hfp_connection->parser_state = HFP_PARSER_THIRD_ITEM; 1157 1158 return true; 1159 1160 case HFP_PARSER_THIRD_ITEM: 1161 1162 hfp_parser_store_if_token(hfp_connection, byte); 1163 if (!hfp_parser_is_separator(byte)) return true; 1164 1165 switch (hfp_connection->command){ 1166 case HFP_CMD_QUERY_OPERATOR_SELECTION_NAME: 1167 strncpy(hfp_connection->network_operator.name, (char *)hfp_connection->line_buffer, HFP_MAX_NETWORK_OPERATOR_NAME_SIZE); 1168 hfp_connection->network_operator.name[HFP_MAX_NETWORK_OPERATOR_NAME_SIZE - 1] = 0; 1169 log_info("name %s\n", hfp_connection->line_buffer); 1170 break; 1171 case HFP_CMD_RETRIEVE_AG_INDICATORS: 1172 hfp_connection->ag_indicators[hfp_connection->parser_item_index].max_range = btstack_atoi((char *)hfp_connection->line_buffer); 1173 hfp_connection->parser_item_index++; 1174 hfp_connection->ag_indicators_nr++; 1175 log_info("%s)\n", hfp_connection->line_buffer); 1176 break; 1177 default: 1178 break; 1179 } 1180 1181 hfp_parser_reset_line_buffer(hfp_connection); 1182 1183 if (hfp_connection->command == HFP_CMD_RETRIEVE_AG_INDICATORS){ 1184 hfp_connection->parser_state = HFP_PARSER_CMD_SEQUENCE; 1185 } else { 1186 hfp_connection->parser_state = HFP_PARSER_CMD_HEADER; 1187 } 1188 return true; 1189 1190 default: 1191 btstack_assert(false); 1192 return true; 1193 } 1194 } 1195 1196 void hfp_parse(hfp_connection_t * hfp_connection, uint8_t byte, int isHandsFree){ 1197 bool processed = false; 1198 while (!processed){ 1199 processed = hfp_parse_byte(hfp_connection, byte, isHandsFree); 1200 } 1201 // reset parser state on end-of-line 1202 if (hfp_parser_is_end_of_line(byte)){ 1203 hfp_connection->parser_item_index = 0; 1204 hfp_connection->parser_state = HFP_PARSER_CMD_HEADER; 1205 } 1206 } 1207 1208 static void parse_sequence(hfp_connection_t * hfp_connection){ 1209 int value; 1210 switch (hfp_connection->command){ 1211 case HFP_CMD_SET_GENERIC_STATUS_INDICATOR_STATUS: 1212 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1213 int i; 1214 switch (hfp_connection->parser_item_index){ 1215 case 0: 1216 for (i=0;i<hfp_connection->generic_status_indicators_nr;i++){ 1217 if (hfp_connection->generic_status_indicators[i].uuid == value){ 1218 hfp_connection->parser_indicator_index = i; 1219 break; 1220 } 1221 } 1222 break; 1223 case 1: 1224 if (hfp_connection->parser_indicator_index <0) break; 1225 hfp_connection->generic_status_indicators[hfp_connection->parser_indicator_index].state = value; 1226 log_info("HFP_CMD_SET_GENERIC_STATUS_INDICATOR_STATUS set indicator at index %u, to %u\n", 1227 hfp_connection->parser_item_index, value); 1228 break; 1229 default: 1230 break; 1231 } 1232 hfp_connection->parser_item_index++; 1233 break; 1234 1235 case HFP_CMD_GET_SUBSCRIBER_NUMBER_INFORMATION: 1236 switch(hfp_connection->parser_item_index){ 1237 case 0: 1238 strncpy(hfp_connection->bnip_number, (char *)hfp_connection->line_buffer, sizeof(hfp_connection->bnip_number)); 1239 hfp_connection->bnip_number[sizeof(hfp_connection->bnip_number)-1] = 0; 1240 break; 1241 case 1: 1242 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1243 hfp_connection->bnip_type = value; 1244 break; 1245 default: 1246 break; 1247 } 1248 hfp_connection->parser_item_index++; 1249 break; 1250 case HFP_CMD_LIST_CURRENT_CALLS: 1251 switch(hfp_connection->parser_item_index){ 1252 case 0: 1253 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1254 hfp_connection->clcc_idx = value; 1255 break; 1256 case 1: 1257 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1258 hfp_connection->clcc_dir = value; 1259 break; 1260 case 2: 1261 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1262 hfp_connection->clcc_status = value; 1263 break; 1264 case 3: 1265 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1266 hfp_connection->clcc_mode = value; 1267 break; 1268 case 4: 1269 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1270 hfp_connection->clcc_mpty = value; 1271 break; 1272 case 5: 1273 strncpy(hfp_connection->bnip_number, (char *)hfp_connection->line_buffer, sizeof(hfp_connection->bnip_number)); 1274 hfp_connection->bnip_number[sizeof(hfp_connection->bnip_number)-1] = 0; 1275 break; 1276 case 6: 1277 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1278 hfp_connection->bnip_type = value; 1279 break; 1280 default: 1281 break; 1282 } 1283 hfp_connection->parser_item_index++; 1284 break; 1285 case HFP_CMD_SET_MICROPHONE_GAIN: 1286 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1287 hfp_connection->microphone_gain = value; 1288 log_info("hfp parse HFP_CMD_SET_MICROPHONE_GAIN %d\n", value); 1289 break; 1290 case HFP_CMD_SET_SPEAKER_GAIN: 1291 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1292 hfp_connection->speaker_gain = value; 1293 log_info("hfp parse HFP_CMD_SET_SPEAKER_GAIN %d\n", value); 1294 break; 1295 case HFP_CMD_HF_ACTIVATE_VOICE_RECOGNITION: 1296 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1297 hfp_connection->ag_activate_voice_recognition = value; 1298 log_info("hfp parse HFP_CMD_HF_ACTIVATE_VOICE_RECOGNITION %d\n", value); 1299 break; 1300 case HFP_CMD_TURN_OFF_EC_AND_NR: 1301 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1302 hfp_connection->ag_echo_and_noise_reduction = value; 1303 log_info("hfp parse HFP_CMD_TURN_OFF_EC_AND_NR %d\n", value); 1304 break; 1305 case HFP_CMD_CHANGE_IN_BAND_RING_TONE_SETTING: 1306 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1307 hfp_connection->remote_supported_features = store_bit(hfp_connection->remote_supported_features, HFP_AGSF_IN_BAND_RING_TONE, value); 1308 log_info("hfp parse HFP_CHANGE_IN_BAND_RING_TONE_SETTING %d\n", value); 1309 break; 1310 case HFP_CMD_HF_CONFIRMED_CODEC: 1311 hfp_connection->codec_confirmed = btstack_atoi((char*)hfp_connection->line_buffer); 1312 log_info("hfp parse HFP_CMD_HF_CONFIRMED_CODEC %d\n", hfp_connection->codec_confirmed); 1313 break; 1314 case HFP_CMD_AG_SUGGESTED_CODEC: 1315 hfp_connection->suggested_codec = btstack_atoi((char*)hfp_connection->line_buffer); 1316 log_info("hfp parse HFP_CMD_AG_SUGGESTED_CODEC %d\n", hfp_connection->suggested_codec); 1317 break; 1318 case HFP_CMD_SUPPORTED_FEATURES: 1319 hfp_connection->remote_supported_features = btstack_atoi((char*)hfp_connection->line_buffer); 1320 log_info("Parsed supported feature %d\n", (int) hfp_connection->remote_supported_features); 1321 break; 1322 case HFP_CMD_AVAILABLE_CODECS: 1323 log_info("Parsed codec %s\n", hfp_connection->line_buffer); 1324 hfp_connection->remote_codecs[hfp_connection->parser_item_index] = (uint16_t)btstack_atoi((char*)hfp_connection->line_buffer); 1325 hfp_connection->parser_item_index++; 1326 hfp_connection->remote_codecs_nr = hfp_connection->parser_item_index; 1327 break; 1328 case HFP_CMD_RETRIEVE_AG_INDICATORS: 1329 strncpy((char *)hfp_connection->ag_indicators[hfp_connection->parser_item_index].name, (char *)hfp_connection->line_buffer, HFP_MAX_INDICATOR_DESC_SIZE); 1330 hfp_connection->ag_indicators[hfp_connection->parser_item_index].name[HFP_MAX_INDICATOR_DESC_SIZE-1] = 0; 1331 hfp_connection->ag_indicators[hfp_connection->parser_item_index].index = hfp_connection->parser_item_index+1; 1332 log_info("Indicator %d: %s (", hfp_connection->ag_indicators_nr+1, hfp_connection->line_buffer); 1333 break; 1334 case HFP_CMD_RETRIEVE_AG_INDICATORS_STATUS: 1335 log_info("Parsed Indicator %d with status: %s\n", hfp_connection->parser_item_index+1, hfp_connection->line_buffer); 1336 hfp_connection->ag_indicators[hfp_connection->parser_item_index].status = btstack_atoi((char *) hfp_connection->line_buffer); 1337 hfp_connection->parser_item_index++; 1338 break; 1339 case HFP_CMD_ENABLE_INDICATOR_STATUS_UPDATE: 1340 hfp_connection->parser_item_index++; 1341 if (hfp_connection->parser_item_index != 4) break; 1342 log_info("Parsed Enable indicators: %s\n", hfp_connection->line_buffer); 1343 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1344 hfp_connection->enable_status_update_for_ag_indicators = (uint8_t) value; 1345 break; 1346 case HFP_CMD_SUPPORT_CALL_HOLD_AND_MULTIPARTY_SERVICES: 1347 log_info("Parsed Support call hold: %s\n", hfp_connection->line_buffer); 1348 if (hfp_connection->line_size > 2 ) break; 1349 strncpy((char *)hfp_connection->remote_call_services[hfp_connection->remote_call_services_nr].name, (char *)hfp_connection->line_buffer, HFP_CALL_SERVICE_SIZE); 1350 hfp_connection->remote_call_services[hfp_connection->remote_call_services_nr].name[HFP_CALL_SERVICE_SIZE - 1] = 0; 1351 hfp_connection->remote_call_services_nr++; 1352 break; 1353 case HFP_CMD_LIST_GENERIC_STATUS_INDICATORS: 1354 case HFP_CMD_RETRIEVE_GENERIC_STATUS_INDICATORS: 1355 log_info("Parsed Generic status indicator: %s\n", hfp_connection->line_buffer); 1356 hfp_connection->generic_status_indicators[hfp_connection->parser_item_index].uuid = (uint16_t)btstack_atoi((char*)hfp_connection->line_buffer); 1357 hfp_connection->parser_item_index++; 1358 hfp_connection->generic_status_indicators_nr = hfp_connection->parser_item_index; 1359 break; 1360 case HFP_CMD_RETRIEVE_GENERIC_STATUS_INDICATORS_STATE: 1361 // HF parses inital AG gen. ind. state 1362 log_info("Parsed List generic status indicator %s state: ", hfp_connection->line_buffer); 1363 hfp_connection->parser_item_index = (uint8_t)btstack_atoi((char*)hfp_connection->line_buffer); 1364 break; 1365 case HFP_CMD_HF_INDICATOR_STATUS: 1366 hfp_connection->parser_indicator_index = (uint8_t)btstack_atoi((char*)hfp_connection->line_buffer); 1367 log_info("Parsed HF indicator index %u", hfp_connection->parser_indicator_index); 1368 break; 1369 case HFP_CMD_ENABLE_INDIVIDUAL_AG_INDICATOR_STATUS_UPDATE: 1370 // AG parses new gen. ind. state 1371 if (hfp_connection->ignore_value){ 1372 hfp_connection->ignore_value = 0; 1373 log_info("Parsed Enable AG indicator pos %u('%s') - unchanged (stays %u)\n", hfp_connection->parser_item_index, 1374 hfp_connection->ag_indicators[hfp_connection->parser_item_index].name, hfp_connection->ag_indicators[hfp_connection->parser_item_index].enabled); 1375 } 1376 else if (hfp_connection->ag_indicators[hfp_connection->parser_item_index].mandatory){ 1377 log_info("Parsed Enable AG indicator pos %u('%s') - ignore (mandatory)\n", 1378 hfp_connection->parser_item_index, hfp_connection->ag_indicators[hfp_connection->parser_item_index].name); 1379 } else { 1380 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1381 hfp_connection->ag_indicators[hfp_connection->parser_item_index].enabled = value; 1382 log_info("Parsed Enable AG indicator pos %u('%s'): %u\n", hfp_connection->parser_item_index, 1383 hfp_connection->ag_indicators[hfp_connection->parser_item_index].name, value); 1384 } 1385 hfp_connection->parser_item_index++; 1386 break; 1387 case HFP_CMD_TRANSFER_AG_INDICATOR_STATUS: 1388 // indicators are indexed starting with 1 1389 hfp_connection->parser_item_index = btstack_atoi((char *)&hfp_connection->line_buffer[0]) - 1; 1390 log_info("Parsed status of the AG indicator %d, status ", hfp_connection->parser_item_index); 1391 break; 1392 case HFP_CMD_QUERY_OPERATOR_SELECTION_NAME: 1393 hfp_connection->network_operator.mode = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1394 log_info("Parsed network operator mode: %d, ", hfp_connection->network_operator.mode); 1395 break; 1396 case HFP_CMD_QUERY_OPERATOR_SELECTION_NAME_FORMAT: 1397 if (hfp_connection->line_buffer[0] == '3'){ 1398 log_info("Parsed Set network operator format : %s, ", hfp_connection->line_buffer); 1399 break; 1400 } 1401 // TODO emit ERROR, wrong format 1402 log_info("ERROR Set network operator format: index %s not supported\n", hfp_connection->line_buffer); 1403 break; 1404 case HFP_CMD_ERROR: 1405 break; 1406 case HFP_CMD_EXTENDED_AUDIO_GATEWAY_ERROR: 1407 hfp_connection->extended_audio_gateway_error = 1; 1408 hfp_connection->extended_audio_gateway_error_value = (uint8_t)btstack_atoi((char*)hfp_connection->line_buffer); 1409 break; 1410 case HFP_CMD_ENABLE_EXTENDED_AUDIO_GATEWAY_ERROR: 1411 hfp_connection->enable_extended_audio_gateway_error_report = (uint8_t)btstack_atoi((char*)hfp_connection->line_buffer); 1412 hfp_connection->ok_pending = 1; 1413 hfp_connection->extended_audio_gateway_error = 0; 1414 break; 1415 case HFP_CMD_AG_SENT_PHONE_NUMBER: 1416 case HFP_CMD_AG_SENT_CALL_WAITING_NOTIFICATION_UPDATE: 1417 case HFP_CMD_AG_SENT_CLIP_INFORMATION: 1418 strncpy(hfp_connection->bnip_number, (char *)hfp_connection->line_buffer, sizeof(hfp_connection->bnip_number)); 1419 hfp_connection->bnip_number[sizeof(hfp_connection->bnip_number)-1] = 0; 1420 break; 1421 default: 1422 break; 1423 } 1424 } 1425 1426 void hfp_establish_service_level_connection(bd_addr_t bd_addr, uint16_t service_uuid, hfp_role_t local_role){ 1427 hfp_connection_t * hfp_connection = provide_hfp_connection_context_for_bd_addr(bd_addr, local_role); 1428 log_info("hfp_connect %s, hfp_connection %p", bd_addr_to_str(bd_addr), hfp_connection); 1429 1430 if (!hfp_connection) { 1431 log_error("hfp_establish_service_level_connection for addr %s failed", bd_addr_to_str(bd_addr)); 1432 return; 1433 } 1434 switch (hfp_connection->state){ 1435 case HFP_W2_DISCONNECT_RFCOMM: 1436 hfp_connection->state = HFP_SERVICE_LEVEL_CONNECTION_ESTABLISHED; 1437 return; 1438 case HFP_W4_RFCOMM_DISCONNECTED: 1439 hfp_connection->state = HFP_W4_RFCOMM_DISCONNECTED_AND_RESTART; 1440 return; 1441 case HFP_IDLE: 1442 (void)memcpy(hfp_connection->remote_addr, bd_addr, 6); 1443 hfp_connection->state = HFP_W4_SDP_QUERY_COMPLETE; 1444 connection_doing_sdp_query = hfp_connection; 1445 hfp_connection->service_uuid = service_uuid; 1446 sdp_client_query_rfcomm_channel_and_name_for_uuid(&handle_query_rfcomm_event, hfp_connection->remote_addr, service_uuid); 1447 break; 1448 default: 1449 break; 1450 } 1451 } 1452 1453 void hfp_release_service_level_connection(hfp_connection_t * hfp_connection){ 1454 if (!hfp_connection) return; 1455 hfp_release_audio_connection(hfp_connection); 1456 1457 if (hfp_connection->state < HFP_W4_RFCOMM_CONNECTED){ 1458 hfp_connection->state = HFP_IDLE; 1459 return; 1460 } 1461 1462 if (hfp_connection->state == HFP_W4_RFCOMM_CONNECTED){ 1463 hfp_connection->state = HFP_W4_CONNECTION_ESTABLISHED_TO_SHUTDOWN; 1464 return; 1465 } 1466 1467 if (hfp_connection->state < HFP_W4_SCO_CONNECTED){ 1468 hfp_connection->state = HFP_W2_DISCONNECT_RFCOMM; 1469 return; 1470 } 1471 1472 if (hfp_connection->state < HFP_W4_SCO_DISCONNECTED){ 1473 hfp_connection->state = HFP_W2_DISCONNECT_SCO; 1474 return; 1475 } 1476 1477 // HFP_W4_SCO_DISCONNECTED or later 1478 hfp_connection->release_slc_connection = 1; 1479 } 1480 1481 void hfp_release_audio_connection(hfp_connection_t * hfp_connection){ 1482 if (!hfp_connection) return; 1483 if (hfp_connection->state >= HFP_W2_DISCONNECT_SCO) return; 1484 hfp_connection->release_audio_connection = 1; 1485 } 1486 1487 static const struct link_settings { 1488 const uint16_t max_latency; 1489 const uint8_t retransmission_effort; 1490 const uint16_t packet_types; 1491 } hfp_link_settings [] = { 1492 { 0xffff, 0xff, 0x03c1 }, // HFP_LINK_SETTINGS_D0, HV1 1493 { 0xffff, 0xff, 0x03c4 }, // HFP_LINK_SETTINGS_D1, HV3 1494 { 0x0007, 0x01, 0x03c8 }, // HFP_LINK_SETTINGS_S1, EV3 1495 { 0x0007, 0x01, 0x0380 }, // HFP_LINK_SETTINGS_S2, 2-EV3 1496 { 0x000a, 0x01, 0x0380 }, // HFP_LINK_SETTINGS_S3, 2-EV3 1497 { 0x000c, 0x02, 0x0380 }, // HFP_LINK_SETTINGS_S4, 2-EV3 1498 { 0x0008, 0x02, 0x03c8 }, // HFP_LINK_SETTINGS_T1, EV3 1499 { 0x000d, 0x02, 0x0380 } // HFP_LINK_SETTINGS_T2, 2-EV3 1500 }; 1501 1502 void hfp_setup_synchronous_connection(hfp_connection_t * hfp_connection){ 1503 // all packet types, fixed bandwidth 1504 int setting = hfp_connection->link_setting; 1505 log_info("hfp_setup_synchronous_connection using setting nr %u", setting); 1506 sco_establishment_active = hfp_connection; 1507 uint16_t sco_voice_setting = hci_get_sco_voice_setting(); 1508 if (hfp_connection->negotiated_codec == HFP_CODEC_MSBC){ 1509 sco_voice_setting = 0x0043; // Transparent data 1510 } 1511 hci_send_cmd(&hci_setup_synchronous_connection, hfp_connection->acl_handle, 8000, 8000, hfp_link_settings[setting].max_latency, 1512 sco_voice_setting, hfp_link_settings[setting].retransmission_effort, hfp_link_settings[setting].packet_types); // all types 0x003f, only 2-ev3 0x380 1513 } 1514 1515 void hfp_set_hf_callback(btstack_packet_handler_t callback){ 1516 hfp_hf_callback = callback; 1517 } 1518 1519 void hfp_set_ag_callback(btstack_packet_handler_t callback){ 1520 hfp_ag_callback = callback; 1521 } 1522 1523 void hfp_set_ag_rfcomm_packet_handler(btstack_packet_handler_t handler){ 1524 hfp_ag_rfcomm_packet_handler = handler; 1525 } 1526 1527 void hfp_set_hf_rfcomm_packet_handler(btstack_packet_handler_t handler){ 1528 hfp_hf_rfcomm_packet_handler = handler; 1529 } 1530 1531 void hfp_set_hf_run_for_context(void (*callback)(hfp_connection_t * hfp_connection)){ 1532 hfp_hf_run_for_context = callback; 1533 } 1534 1535 void hfp_init(void){ 1536 } 1537 1538 void hfp_init_link_settings(hfp_connection_t * hfp_connection, uint8_t esco_s4_supported){ 1539 // determine highest possible link setting 1540 hfp_connection->link_setting = HFP_LINK_SETTINGS_D1; 1541 // anything else requires eSCO support on both sides 1542 if (hci_extended_sco_link_supported() && hci_remote_esco_supported(hfp_connection->acl_handle)){ 1543 switch (hfp_connection->negotiated_codec){ 1544 case HFP_CODEC_CVSD: 1545 hfp_connection->link_setting = HFP_LINK_SETTINGS_S3; 1546 if (esco_s4_supported){ 1547 hfp_connection->link_setting = HFP_LINK_SETTINGS_S4; 1548 } 1549 break; 1550 case HFP_CODEC_MSBC: 1551 hfp_connection->link_setting = HFP_LINK_SETTINGS_T2; 1552 break; 1553 default: 1554 break; 1555 } 1556 } 1557 log_info("hfp_init_link_settings: %u", hfp_connection->link_setting); 1558 } 1559 1560 #define HFP_HF_RX_DEBUG_PRINT_LINE 80 1561 1562 void hfp_log_rfcomm_message(const char * tag, uint8_t * packet, uint16_t size){ 1563 #ifdef ENABLE_LOG_INFO 1564 // encode \n\r 1565 char printable[HFP_HF_RX_DEBUG_PRINT_LINE+2]; 1566 int i = 0; 1567 int pos; 1568 for (pos=0 ; (pos < size) && (i < (HFP_HF_RX_DEBUG_PRINT_LINE - 3)) ; pos++){ 1569 switch (packet[pos]){ 1570 case '\n': 1571 printable[i++] = '\\'; 1572 printable[i++] = 'n'; 1573 break; 1574 case '\r': 1575 printable[i++] = '\\'; 1576 printable[i++] = 'r'; 1577 break; 1578 default: 1579 printable[i++] = packet[pos]; 1580 break; 1581 } 1582 } 1583 printable[i] = 0; 1584 log_info("%s: '%s'", tag, printable); 1585 #endif 1586 } 1587