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 BLUEKITCHEN 24 * GMBH 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_ag.c" 39 40 // ***************************************************************************** 41 // 42 // HFP Audio Gateway (AG) unit 43 // 44 // ***************************************************************************** 45 46 #include "btstack_config.h" 47 48 #include <stdint.h> 49 #include <stdio.h> 50 #include <string.h> 51 52 #include "hci_cmd.h" 53 #include "btstack_run_loop.h" 54 55 #include "bluetooth_sdp.h" 56 #include "hci.h" 57 #include "btstack_memory.h" 58 #include "hci_dump.h" 59 #include "l2cap.h" 60 #include "btstack_debug.h" 61 #include "btstack_event.h" 62 #include "classic/core.h" 63 #include "classic/hfp.h" 64 #include "classic/hfp_ag.h" 65 #include "classic/hfp_gsm_model.h" 66 #include "classic/sdp_client_rfcomm.h" 67 #include "classic/sdp_server.h" 68 #include "classic/sdp_util.h" 69 70 // private prototypes 71 static void hfp_ag_run_for_context(hfp_connection_t *hfp_connection); 72 static void hfp_ag_hf_start_ringing_incoming(hfp_connection_t * hfp_connection); 73 static void hfp_ag_hf_start_ringing_outgoing(hfp_connection_t * hfp_connection); 74 static uint8_t hfp_ag_setup_audio_connection(hfp_connection_t * hfp_connection); 75 76 // public prototypes 77 hfp_generic_status_indicator_t * get_hfp_generic_status_indicators(void); 78 int get_hfp_generic_status_indicators_nr(void); 79 void set_hfp_generic_status_indicators(hfp_generic_status_indicator_t * indicators, int indicator_nr); 80 void set_hfp_ag_indicators(hfp_ag_indicator_t * indicators, int indicator_nr); 81 int get_hfp_ag_indicators_nr(hfp_connection_t * context); 82 hfp_ag_indicator_t * get_hfp_ag_indicators(hfp_connection_t * context); 83 84 #define HFP_SUBEVENT_INVALID 0xFFFF 85 86 // const 87 static const char hfp_ag_default_service_name[] = "Voice gateway"; 88 89 // globals 90 91 // higher layer callbacks 92 static btstack_packet_handler_t hfp_ag_callback; 93 94 static bool (*hfp_ag_custom_call_sm_handler)(hfp_ag_call_event_t event); 95 96 static btstack_packet_callback_registration_t hfp_ag_hci_event_callback_registration; 97 98 static uint16_t hfp_ag_supported_features; 99 100 // codecs 101 static uint8_t hfp_ag_codecs_nr; 102 static uint8_t hfp_ag_codecs[HFP_MAX_NUM_CODECS]; 103 104 // AG indicators 105 static int hfp_ag_indicators_nr; 106 static hfp_ag_indicator_t hfp_ag_indicators[HFP_MAX_NUM_INDICATORS]; 107 108 // generic status indicators 109 static int hfp_ag_generic_status_indicators_nr; 110 static hfp_generic_status_indicator_t hfp_ag_generic_status_indicators[HFP_MAX_NUM_INDICATORS]; 111 112 static int hfp_ag_call_hold_services_nr; 113 static char * hfp_ag_call_hold_services[6]; 114 115 static hfp_response_and_hold_state_t hfp_ag_response_and_hold_state; 116 static bool hfp_ag_response_and_hold_active = false; 117 118 // Subscriber information entries 119 static hfp_phone_number_t * hfp_ag_subscriber_numbers; 120 static int hfp_ag_subscriber_numbers_count; 121 122 // call state 123 static btstack_timer_source_t hfp_ag_ring_timeout; 124 125 // code 126 static int hfp_ag_get_ag_indicators_nr(hfp_connection_t * hfp_connection){ 127 if (hfp_connection->ag_indicators_nr != hfp_ag_indicators_nr){ 128 hfp_connection->ag_indicators_nr = hfp_ag_indicators_nr; 129 (void)memcpy(hfp_connection->ag_indicators, hfp_ag_indicators, 130 hfp_ag_indicators_nr * sizeof(hfp_ag_indicator_t)); 131 } 132 return hfp_connection->ag_indicators_nr; 133 } 134 135 hfp_ag_indicator_t * hfp_ag_get_ag_indicators(hfp_connection_t * hfp_connection){ 136 // TODO: save only value, and value changed in the hfp_connection? 137 if (hfp_connection->ag_indicators_nr != hfp_ag_indicators_nr){ 138 hfp_connection->ag_indicators_nr = hfp_ag_indicators_nr; 139 (void)memcpy(hfp_connection->ag_indicators, hfp_ag_indicators, 140 hfp_ag_indicators_nr * sizeof(hfp_ag_indicator_t)); 141 } 142 return (hfp_ag_indicator_t *)&(hfp_connection->ag_indicators); 143 } 144 145 static hfp_ag_indicator_t * get_ag_indicator_for_name(const char * name){ 146 int i; 147 for (i = 0; i < hfp_ag_indicators_nr; i++){ 148 if (strcmp(hfp_ag_indicators[i].name, name) == 0){ 149 return &hfp_ag_indicators[i]; 150 } 151 } 152 return NULL; 153 } 154 155 static int get_ag_indicator_index_for_name(const char * name){ 156 int i; 157 for (i = 0; i < hfp_ag_indicators_nr; i++){ 158 if (strcmp(hfp_ag_indicators[i].name, name) == 0){ 159 return i; 160 } 161 } 162 return -1; 163 } 164 165 static hfp_connection_t * get_hfp_ag_connection_context_for_acl_handle(uint16_t handle){ 166 btstack_linked_list_iterator_t it; 167 btstack_linked_list_iterator_init(&it, hfp_get_connections()); 168 while (btstack_linked_list_iterator_has_next(&it)){ 169 hfp_connection_t * hfp_connection = (hfp_connection_t *)btstack_linked_list_iterator_next(&it); 170 if (hfp_connection->acl_handle != handle) continue; 171 if (hfp_connection->local_role != HFP_ROLE_AG) continue; 172 return hfp_connection; 173 } 174 return NULL; 175 } 176 177 static int use_in_band_tone(void){ 178 return get_bit(hfp_ag_supported_features, HFP_AGSF_IN_BAND_RING_TONE); 179 } 180 181 static int has_codec_negotiation_feature(hfp_connection_t * hfp_connection){ 182 int hf = get_bit(hfp_connection->remote_supported_features, HFP_HFSF_CODEC_NEGOTIATION); 183 int ag = get_bit(hfp_ag_supported_features, HFP_AGSF_CODEC_NEGOTIATION); 184 return hf && ag; 185 } 186 187 static int has_call_waiting_and_3way_calling_feature(hfp_connection_t * hfp_connection){ 188 int hf = get_bit(hfp_connection->remote_supported_features, HFP_HFSF_THREE_WAY_CALLING); 189 int ag = get_bit(hfp_ag_supported_features, HFP_AGSF_THREE_WAY_CALLING); 190 return hf && ag; 191 } 192 193 static int has_hf_indicators_feature(hfp_connection_t * hfp_connection){ 194 int hf = get_bit(hfp_connection->remote_supported_features, HFP_HFSF_HF_INDICATORS); 195 int ag = get_bit(hfp_ag_supported_features, HFP_AGSF_HF_INDICATORS); 196 return hf && ag; 197 } 198 199 /* unsolicited responses */ 200 201 static int hfp_ag_send_change_in_band_ring_tone_setting_cmd(uint16_t cid){ 202 char buffer[20]; 203 snprintf(buffer, sizeof(buffer), "\r\n%s: %d\r\n", 204 HFP_CHANGE_IN_BAND_RING_TONE_SETTING, use_in_band_tone()); 205 buffer[sizeof(buffer) - 1] = 0; 206 return send_str_over_rfcomm(cid, buffer); 207 } 208 209 static int hfp_ag_exchange_supported_features_cmd(uint16_t cid){ 210 char buffer[40]; 211 snprintf(buffer, sizeof(buffer), "\r\n%s:%d\r\n\r\nOK\r\n", 212 HFP_SUPPORTED_FEATURES, hfp_ag_supported_features); 213 buffer[sizeof(buffer) - 1] = 0; 214 return send_str_over_rfcomm(cid, buffer); 215 } 216 217 static int hfp_ag_send_ok(uint16_t cid){ 218 char buffer[10]; 219 snprintf(buffer, sizeof(buffer), "\r\nOK\r\n"); 220 buffer[sizeof(buffer) - 1] = 0; 221 return send_str_over_rfcomm(cid, buffer); 222 } 223 224 static int hfp_ag_send_ring(uint16_t cid){ 225 return send_str_over_rfcomm(cid, (char *) "\r\nRING\r\n"); 226 } 227 228 static int hfp_ag_send_no_carrier(uint16_t cid){ 229 char buffer[15]; 230 snprintf(buffer, sizeof(buffer), "\r\nNO CARRIER\r\n"); 231 buffer[sizeof(buffer) - 1] = 0; 232 return send_str_over_rfcomm(cid, buffer); 233 } 234 235 static int hfp_ag_send_clip(uint16_t cid){ 236 char buffer[50]; 237 snprintf(buffer, sizeof(buffer), "\r\n%s: \"%s\",%u\r\n", HFP_ENABLE_CLIP, 238 hfp_gsm_clip_number(), hfp_gsm_clip_type()); 239 buffer[sizeof(buffer) - 1] = 0; 240 return send_str_over_rfcomm(cid, buffer); 241 } 242 243 static int hfp_send_subscriber_number_cmd(uint16_t cid, uint8_t type, const char * number){ 244 char buffer[50]; 245 snprintf(buffer, sizeof(buffer), "\r\n%s: ,\"%s\",%u, , \r\n", 246 HFP_SUBSCRIBER_NUMBER_INFORMATION, number, type); 247 buffer[sizeof(buffer) - 1] = 0; 248 return send_str_over_rfcomm(cid, buffer); 249 } 250 251 static int hfp_ag_send_phone_number_for_voice_tag_cmd(uint16_t cid){ 252 char buffer[50]; 253 snprintf(buffer, sizeof(buffer), "\r\n%s: %s\r\n", 254 HFP_PHONE_NUMBER_FOR_VOICE_TAG, hfp_gsm_clip_number()); 255 buffer[sizeof(buffer) - 1] = 0; 256 return send_str_over_rfcomm(cid, buffer); 257 } 258 259 static int hfp_ag_send_call_waiting_notification(uint16_t cid){ 260 char buffer[50]; 261 snprintf(buffer, sizeof(buffer), "\r\n%s: \"%s\",%u\r\n", 262 HFP_ENABLE_CALL_WAITING_NOTIFICATION, hfp_gsm_clip_number(), 263 hfp_gsm_clip_type()); 264 buffer[sizeof(buffer) - 1] = 0; 265 return send_str_over_rfcomm(cid, buffer); 266 } 267 268 static int hfp_ag_send_error(uint16_t cid){ 269 char buffer[10]; 270 snprintf(buffer, sizeof(buffer), "\r\nERROR\r\n"); 271 buffer[sizeof(buffer) - 1] = 0; 272 return send_str_over_rfcomm(cid, buffer); 273 } 274 275 static int hfp_ag_send_report_extended_audio_gateway_error(uint16_t cid, uint8_t error){ 276 char buffer[20]; 277 snprintf(buffer, sizeof(buffer), "\r\n%s=%d\r\n", 278 HFP_EXTENDED_AUDIO_GATEWAY_ERROR, error); 279 buffer[sizeof(buffer) - 1] = 0; 280 return send_str_over_rfcomm(cid, buffer); 281 } 282 283 // get size for indicator string 284 static int hfp_ag_indicators_string_size(hfp_connection_t * hfp_connection, int i){ 285 // template: ("$NAME",($MIN,$MAX)) 286 return 8 + (int) strlen(hfp_ag_get_ag_indicators(hfp_connection)[i].name) 287 + string_len_for_uint32(hfp_ag_get_ag_indicators(hfp_connection)[i].min_range) 288 + string_len_for_uint32(hfp_ag_get_ag_indicators(hfp_connection)[i].min_range); 289 } 290 291 // store indicator 292 static void hfp_ag_indicators_string_store(hfp_connection_t * hfp_connection, int i, uint8_t * buffer, uint16_t buffer_size){ 293 snprintf((char *)buffer, buffer_size, "(\"%s\",(%d,%d)),", 294 hfp_ag_get_ag_indicators(hfp_connection)[i].name, 295 hfp_ag_get_ag_indicators(hfp_connection)[i].min_range, 296 hfp_ag_get_ag_indicators(hfp_connection)[i].max_range); 297 ((char *)buffer)[buffer_size - 1] = 0; 298 } 299 300 // structure: header [indicator [comma indicator]] footer 301 static int hfp_ag_indicators_cmd_generator_num_segments(hfp_connection_t * hfp_connection){ 302 int num_indicators = hfp_ag_get_ag_indicators_nr(hfp_connection); 303 if (!num_indicators) return 2; 304 return 3 + ((num_indicators-1) * 2); 305 } 306 307 // get size of individual segment for hfp_ag_retrieve_indicators_cmd 308 static int hfp_ag_indicators_cmd_generator_get_segment_len(hfp_connection_t * hfp_connection, int index){ 309 if (index == 0) { 310 return (uint16_t) strlen(HFP_INDICATOR) + 3; // "\n\r%s:"" 311 } 312 index--; 313 int num_indicators = hfp_ag_get_ag_indicators_nr(hfp_connection); 314 int indicator_index = index >> 1; 315 if ((index & 1) == 0){ 316 return hfp_ag_indicators_string_size(hfp_connection, indicator_index); 317 } 318 if (indicator_index == (num_indicators - 1)){ 319 return 8; // "\r\n\r\nOK\r\n" 320 } 321 return 1; // comma 322 } 323 324 static void hfp_ag_indicators_cmd_generator_store_segment(hfp_connection_t * hfp_connection, int index, uint8_t * buffer, uint16_t buffer_size){ 325 if (index == 0){ 326 *buffer++ = '\r'; 327 *buffer++ = '\n'; 328 int len = (uint16_t) strlen(HFP_INDICATOR); 329 (void)memcpy(buffer, HFP_INDICATOR, len); 330 buffer += len; 331 *buffer++ = ':'; 332 return; 333 } 334 index--; 335 int num_indicators = hfp_ag_get_ag_indicators_nr(hfp_connection); 336 int indicator_index = index >> 1; 337 if ((index & 1) == 0){ 338 hfp_ag_indicators_string_store(hfp_connection, indicator_index, buffer, buffer_size); 339 return; 340 } 341 if (indicator_index == (num_indicators-1)){ 342 (void)memcpy(buffer, "\r\n\r\nOK\r\n", 8); 343 return; 344 } 345 *buffer = ','; 346 } 347 348 static int hfp_ag_generic_indicators_join(char * buffer, int buffer_size){ 349 if (buffer_size < (hfp_ag_indicators_nr * 3)) return 0; 350 int i; 351 int offset = 0; 352 for (i = 0; i < (hfp_ag_generic_status_indicators_nr - 1); i++) { 353 offset += snprintf(buffer+offset, buffer_size-offset, "%d,", hfp_ag_generic_status_indicators[i].uuid); 354 } 355 if (i < hfp_ag_generic_status_indicators_nr){ 356 offset += snprintf(buffer+offset, buffer_size-offset, "%d", hfp_ag_generic_status_indicators[i].uuid); 357 } 358 return offset; 359 } 360 361 static int hfp_ag_generic_indicators_initial_status_join(char * buffer, int buffer_size){ 362 if (buffer_size < (hfp_ag_generic_status_indicators_nr * 3)) return 0; 363 int i; 364 int offset = 0; 365 for (i = 0; i < hfp_ag_generic_status_indicators_nr; i++) { 366 offset += snprintf(buffer+offset, buffer_size-offset, "\r\n%s:%d,%d\r\n", HFP_GENERIC_STATUS_INDICATOR, hfp_ag_generic_status_indicators[i].uuid, hfp_ag_generic_status_indicators[i].state); 367 } 368 return offset; 369 } 370 371 static int hfp_ag_indicators_status_join(char * buffer, int buffer_size){ 372 if (buffer_size < (hfp_ag_indicators_nr * 3)) return 0; 373 int i; 374 int offset = 0; 375 for (i = 0; i < (hfp_ag_indicators_nr-1); i++) { 376 offset += snprintf(buffer+offset, buffer_size-offset, "%d,", hfp_ag_indicators[i].status); 377 } 378 if (i<hfp_ag_indicators_nr){ 379 offset += snprintf(buffer+offset, buffer_size-offset, "%d", hfp_ag_indicators[i].status); 380 } 381 return offset; 382 } 383 384 static int hfp_ag_call_services_join(char * buffer, int buffer_size){ 385 if (buffer_size < (hfp_ag_call_hold_services_nr * 3)) return 0; 386 int i; 387 int offset = snprintf(buffer, buffer_size, "("); 388 for (i = 0; i < (hfp_ag_call_hold_services_nr-1); i++) { 389 offset += snprintf(buffer+offset, buffer_size-offset, "%s,", hfp_ag_call_hold_services[i]); 390 } 391 if (i<hfp_ag_call_hold_services_nr){ 392 offset += snprintf(buffer+offset, buffer_size-offset, "%s)", hfp_ag_call_hold_services[i]); 393 } 394 return offset; 395 } 396 397 static int hfp_ag_send_cmd_via_generator(uint16_t cid, hfp_connection_t * hfp_connection, 398 int start_segment, int num_segments, 399 int (*get_segment_len)(hfp_connection_t * hfp_connection, int segment), 400 void (*store_segment) (hfp_connection_t * hfp_connection, int segment, uint8_t * buffer, uint16_t buffer_size)){ 401 402 // assumes: can send now == true 403 // assumes: num segments > 0 404 // assumes: individual segments are smaller than MTU 405 rfcomm_reserve_packet_buffer(); 406 int mtu = rfcomm_get_max_frame_size(cid); 407 uint8_t * data = rfcomm_get_outgoing_buffer(); 408 int offset = 0; 409 int segment = start_segment; 410 while (segment < num_segments){ 411 int segment_len = get_segment_len(hfp_connection, segment); 412 if ((offset + segment_len + 1) > mtu) break; 413 // append segment. As it appends a '\0', we provide a buffer one byte larger 414 store_segment(hfp_connection, segment, data+offset, segment_len + 1); 415 offset += segment_len; 416 segment++; 417 } 418 rfcomm_send_prepared(cid, offset); 419 #ifdef ENABLE_HFP_AT_MESSAGES 420 hfp_emit_string_event(hfp_connection, HFP_SUBEVENT_AT_MESSAGE_SENT, (char *) data); 421 #endif 422 return segment; 423 } 424 425 // returns next segment to store 426 static int hfp_ag_send_retrieve_indicators_cmd_via_generator(uint16_t cid, hfp_connection_t * hfp_connection, int start_segment){ 427 int num_segments = hfp_ag_indicators_cmd_generator_num_segments(hfp_connection); 428 return hfp_ag_send_cmd_via_generator(cid, hfp_connection, start_segment, num_segments, 429 hfp_ag_indicators_cmd_generator_get_segment_len, 430 hfp_ag_indicators_cmd_generator_store_segment); 431 } 432 433 static int hfp_ag_send_retrieve_indicators_status_cmd(uint16_t cid){ 434 char buffer[40]; 435 const int size = sizeof(buffer); 436 int offset = snprintf(buffer, size, "\r\n%s:", HFP_INDICATOR); 437 offset += hfp_ag_indicators_status_join(buffer+offset, size-offset-9); 438 offset += snprintf(buffer+offset, size-offset, "\r\n\r\nOK\r\n"); 439 return send_str_over_rfcomm(cid, buffer); 440 } 441 442 static int hfp_ag_send_retrieve_can_hold_call_cmd(uint16_t cid){ 443 char buffer[40]; 444 const int size = sizeof(buffer); 445 int offset = snprintf(buffer, size, "\r\n%s:", HFP_SUPPORT_CALL_HOLD_AND_MULTIPARTY_SERVICES); 446 offset += hfp_ag_call_services_join(buffer+offset, size-offset-9); 447 offset += snprintf(buffer+offset, size-offset, "\r\n\r\nOK\r\n"); 448 return send_str_over_rfcomm(cid, buffer); 449 } 450 451 452 static int hfp_ag_send_list_supported_generic_status_indicators_cmd(uint16_t cid){ 453 return hfp_ag_send_ok(cid); 454 } 455 456 static int hfp_ag_send_retrieve_supported_generic_status_indicators_cmd(uint16_t cid){ 457 char buffer[40]; 458 const int size = sizeof(buffer); 459 int offset = snprintf(buffer, size, "\r\n%s:(", HFP_GENERIC_STATUS_INDICATOR); 460 offset += hfp_ag_generic_indicators_join(buffer + offset, size - offset - 10); 461 offset += snprintf(buffer+offset, size-offset, ")\r\n\r\nOK\r\n"); 462 return send_str_over_rfcomm(cid, buffer); 463 } 464 465 static int hfp_ag_send_retrieve_initital_supported_generic_status_indicators_cmd(uint16_t cid){ 466 char buffer[40]; 467 int offset = hfp_ag_generic_indicators_initial_status_join(buffer, sizeof(buffer) - 7); 468 snprintf(buffer+offset, sizeof(buffer)-offset, "\r\nOK\r\n"); 469 return send_str_over_rfcomm(cid, buffer); 470 } 471 472 static int hfp_ag_send_transfer_ag_indicators_status_cmd(uint16_t cid, hfp_ag_indicator_t * indicator){ 473 char buffer[20]; 474 snprintf(buffer, sizeof(buffer), "\r\n%s:%d,%d\r\n", 475 HFP_TRANSFER_AG_INDICATOR_STATUS, indicator->index, 476 indicator->status); 477 buffer[sizeof(buffer) - 1] = 0; 478 return send_str_over_rfcomm(cid, buffer); 479 } 480 481 static int hfp_ag_send_report_network_operator_name_cmd(uint16_t cid, hfp_network_opearator_t op){ 482 char buffer[41]; 483 if (strlen(op.name) == 0){ 484 snprintf(buffer, sizeof(buffer), "\r\n%s:%d,,\r\n\r\nOK\r\n", HFP_QUERY_OPERATOR_SELECTION, op.mode); 485 } else { 486 int offset = snprintf(buffer, sizeof(buffer), "\r\n%s:%d,%d,", HFP_QUERY_OPERATOR_SELECTION, op.mode, op.format); 487 offset += snprintf(buffer+offset, 16, "%s", op.name); 488 snprintf(buffer+offset, sizeof(buffer)-offset, "\r\n\r\nOK\r\n"); 489 } 490 return send_str_over_rfcomm(cid, buffer); 491 } 492 493 static inline int hfp_ag_send_cmd_with_space_and_int(uint16_t cid, const char * cmd, uint8_t value){ 494 char buffer[30]; 495 snprintf(buffer, sizeof(buffer), "\r\n%s: %d\r\n", cmd, value); 496 return send_str_over_rfcomm(cid, buffer); 497 } 498 499 500 static inline int hfp_ag_send_cmd_with_int(uint16_t cid, const char * cmd, uint8_t value){ 501 char buffer[30]; 502 snprintf(buffer, sizeof(buffer), "\r\n%s:%d\r\n", cmd, value); 503 return send_str_over_rfcomm(cid, buffer); 504 } 505 506 static int hfp_ag_send_suggest_codec_cmd(uint16_t cid, uint8_t codec){ 507 return hfp_ag_send_cmd_with_int(cid, HFP_CONFIRM_COMMON_CODEC, codec); 508 } 509 510 static int hfp_ag_send_set_speaker_gain_cmd(uint16_t cid, uint8_t gain){ 511 return hfp_ag_send_cmd_with_int(cid, HFP_SET_SPEAKER_GAIN, gain); 512 } 513 514 static int hfp_ag_send_set_microphone_gain_cmd(uint16_t cid, uint8_t gain){ 515 return hfp_ag_send_cmd_with_int(cid, HFP_SET_MICROPHONE_GAIN, gain); 516 } 517 518 static int hfp_ag_send_set_response_and_hold(uint16_t cid, int state){ 519 return hfp_ag_send_cmd_with_space_and_int(cid, HFP_RESPONSE_AND_HOLD, state); 520 } 521 522 static int hfp_ag_send_enhanced_voice_recognition_state_cmd(hfp_connection_t * hfp_connection){ 523 char buffer[30]; 524 uint8_t evra_enabled = hfp_connection->enhanced_voice_recognition_enabled ? 1 : 0; 525 snprintf(buffer, sizeof(buffer), "\r\n%s: %d,%d\r\n", HFP_ACTIVATE_VOICE_RECOGNITION, evra_enabled, hfp_connection->ag_vra_state); 526 return send_str_over_rfcomm(hfp_connection->rfcomm_cid, buffer); 527 } 528 529 static int hfp_ag_send_voice_recognition_cmd(hfp_connection_t * hfp_connection, uint8_t activate_voice_recognition){ 530 char buffer[30]; 531 if (hfp_connection->enhanced_voice_recognition_enabled){ 532 snprintf(buffer, sizeof(buffer), "\r\n%s: %d,%d\r\n", HFP_ACTIVATE_VOICE_RECOGNITION, activate_voice_recognition, hfp_connection->ag_vra_state); 533 } else { 534 snprintf(buffer, sizeof(buffer), "\r\n%s: %d\r\n", HFP_ACTIVATE_VOICE_RECOGNITION, activate_voice_recognition); 535 } 536 return send_str_over_rfcomm(hfp_connection->rfcomm_cid, buffer); 537 } 538 539 static int hfp_ag_send_enhanced_voice_recognition_msg_cmd(hfp_connection_t * hfp_connection){ 540 char buffer[HFP_VR_TEXT_HEADER_SIZE + HFP_MAX_VR_TEXT_SIZE]; 541 snprintf(buffer, sizeof(buffer), "\r\n%s: 1,%d,%X,%d,%d,\"%s\"\r\n", HFP_ACTIVATE_VOICE_RECOGNITION, 542 hfp_connection->ag_vra_state, 543 hfp_connection->ag_msg.text_id, 544 hfp_connection->ag_msg.text_type, 545 hfp_connection->ag_msg.text_operation, 546 hfp_connection->ag_msg.text); 547 return send_str_over_rfcomm(hfp_connection->rfcomm_cid, buffer); 548 } 549 550 static uint8_t hfp_ag_suggest_codec(hfp_connection_t *hfp_connection){ 551 if (hfp_connection->sco_for_msbc_failed) return HFP_CODEC_CVSD; 552 553 if (hfp_supports_codec(HFP_CODEC_MSBC, hfp_ag_codecs_nr, hfp_ag_codecs)){ 554 if (hfp_supports_codec(HFP_CODEC_MSBC, hfp_connection->remote_codecs_nr, hfp_connection->remote_codecs)){ 555 return HFP_CODEC_MSBC; 556 } 557 } 558 return HFP_CODEC_CVSD; 559 } 560 561 /* state machines */ 562 563 static uint8_t hfp_ag_esco_s4_supported(hfp_connection_t * hfp_connection){ 564 return (hfp_connection->remote_supported_features & (1<<HFP_HFSF_ESCO_S4)) && (hfp_ag_supported_features & (1 << HFP_AGSF_ESCO_S4)); 565 } 566 567 static int codecs_exchange_state_machine(hfp_connection_t * hfp_connection){ 568 /* events ( == commands): 569 HFP_CMD_AVAILABLE_CODECS == received AT+BAC with list of codecs 570 HFP_CMD_TRIGGER_CODEC_CONNECTION_SETUP: 571 hf_trigger_codec_connection_setup == received BCC 572 ag_trigger_codec_connection_setup == received from AG to send BCS 573 HFP_CMD_HF_CONFIRMED_CODEC == received AT+BCS 574 */ 575 switch (hfp_connection->codecs_state){ 576 case HFP_CODECS_EXCHANGED: 577 if (hfp_connection->command == HFP_CMD_AVAILABLE_CODECS){ 578 hfp_ag_send_ok(hfp_connection->rfcomm_cid); 579 return 1; 580 } 581 break; 582 583 case HFP_CODECS_RECEIVED_TRIGGER_CODEC_EXCHANGE: 584 case HFP_CODECS_AG_RESEND_COMMON_CODEC: 585 hfp_connection->ag_send_common_codec = true; 586 break; 587 default: 588 break; 589 } 590 591 if (hfp_connection->ag_send_common_codec){ 592 hfp_connection->ag_send_common_codec = false; 593 hfp_connection->codecs_state = HFP_CODECS_AG_SENT_COMMON_CODEC; 594 hfp_connection->suggested_codec = hfp_ag_suggest_codec(hfp_connection); 595 hfp_ag_send_suggest_codec_cmd(hfp_connection->rfcomm_cid, hfp_connection->suggested_codec); 596 return 1; 597 } 598 599 switch (hfp_connection->command){ 600 case HFP_CMD_AVAILABLE_CODECS: 601 if (hfp_connection->state < HFP_SERVICE_LEVEL_CONNECTION_ESTABLISHED){ 602 hfp_connection->codecs_state = HFP_CODECS_RECEIVED_LIST; 603 hfp_ag_send_ok(hfp_connection->rfcomm_cid); 604 return 1; 605 } 606 607 switch (hfp_connection->codecs_state){ 608 case HFP_CODECS_AG_SENT_COMMON_CODEC: 609 hfp_connection->codecs_state = HFP_CODECS_AG_RESEND_COMMON_CODEC; 610 break; 611 default: 612 break; 613 } 614 hfp_ag_send_ok(hfp_connection->rfcomm_cid); 615 return 1; 616 617 case HFP_CMD_TRIGGER_CODEC_CONNECTION_SETUP: 618 hfp_connection->codecs_state = HFP_CODECS_RECEIVED_TRIGGER_CODEC_EXCHANGE; 619 hfp_connection->establish_audio_connection = 1; 620 hfp_ag_send_ok(hfp_connection->rfcomm_cid); 621 return 1; 622 623 case HFP_CMD_HF_CONFIRMED_CODEC: 624 if (hfp_connection->codec_confirmed != hfp_connection->suggested_codec){ 625 hfp_connection->codecs_state = HFP_CODECS_ERROR; 626 hfp_ag_send_error(hfp_connection->rfcomm_cid); 627 return 1; 628 } 629 hfp_connection->negotiated_codec = hfp_connection->codec_confirmed; 630 hfp_connection->codecs_state = HFP_CODECS_EXCHANGED; 631 log_info("hfp: codec confirmed: %s", (hfp_connection->negotiated_codec == HFP_CODEC_MSBC) ? "mSBC" : "CVSD"); 632 hfp_ag_send_ok(hfp_connection->rfcomm_cid); 633 // now, pick link settings 634 hfp_init_link_settings(hfp_connection, hfp_ag_esco_s4_supported(hfp_connection)); 635 #ifdef ENABLE_CC256X_ASSISTED_HFP 636 hfp_cc256x_prepare_for_sco(hfp_connection); 637 #endif 638 #ifdef ENABLE_RTK_PCM_WBS 639 hfp_connection->rtk_send_sco_config = true; 640 #endif 641 return 1; 642 default: 643 break; 644 } 645 return 0; 646 } 647 648 static void hfp_ag_slc_established(hfp_connection_t * hfp_connection){ 649 hfp_connection->state = HFP_SERVICE_LEVEL_CONNECTION_ESTABLISHED; 650 hfp_emit_slc_connection_event(hfp_connection->local_role, 0, hfp_connection->acl_handle, hfp_connection->remote_addr); 651 652 // HFP 4.35: "When [...] a new Service Level Connection is established all indicators are activated by default." 653 uint16_t i; 654 for (i=0;i<hfp_connection->ag_indicators_nr;i++){ 655 hfp_connection->ag_indicators[i].enabled = 1; 656 } 657 658 // if active call exist, set per-hfp_connection state active, too (when audio is on) 659 if (hfp_gsm_call_status() == HFP_CALL_STATUS_ACTIVE_OR_HELD_CALL_IS_PRESENT){ 660 hfp_connection->call_state = HFP_CALL_W4_AUDIO_CONNECTION_FOR_ACTIVE; 661 } 662 // if AG is ringing, also start ringing on the HF 663 if (hfp_gsm_call_status() == HFP_CALL_STATUS_NO_HELD_OR_ACTIVE_CALLS){ 664 switch (hfp_gsm_callsetup_status()){ 665 case HFP_CALLSETUP_STATUS_INCOMING_CALL_SETUP_IN_PROGRESS: 666 hfp_ag_hf_start_ringing_incoming(hfp_connection); 667 break; 668 case HFP_CALLSETUP_STATUS_OUTGOING_CALL_SETUP_IN_ALERTING_STATE: 669 hfp_ag_hf_start_ringing_outgoing(hfp_connection); 670 break; 671 default: 672 break; 673 } 674 } 675 } 676 677 static int hfp_ag_run_for_context_service_level_connection(hfp_connection_t * hfp_connection){ 678 // log_info("hfp_ag_run_for_context_service_level_connection state %u, command %u", hfp_connection->state, hfp_connection->command); 679 if (hfp_connection->state >= HFP_SERVICE_LEVEL_CONNECTION_ESTABLISHED) return 0; 680 int sent = 0; 681 switch(hfp_connection->command){ 682 case HFP_CMD_SUPPORTED_FEATURES: 683 switch(hfp_connection->state){ 684 case HFP_W4_EXCHANGE_SUPPORTED_FEATURES: 685 case HFP_EXCHANGE_SUPPORTED_FEATURES: 686 hfp_hf_drop_mSBC_if_eSCO_not_supported(hfp_ag_codecs, &hfp_ag_codecs_nr); 687 if (has_codec_negotiation_feature(hfp_connection)){ 688 hfp_connection->state = HFP_W4_NOTIFY_ON_CODECS; 689 } else { 690 hfp_connection->state = HFP_W4_RETRIEVE_INDICATORS; 691 } 692 hfp_ag_exchange_supported_features_cmd(hfp_connection->rfcomm_cid); 693 return 1; 694 default: 695 break; 696 } 697 break; 698 case HFP_CMD_AVAILABLE_CODECS: 699 sent = codecs_exchange_state_machine(hfp_connection); 700 if (hfp_connection->codecs_state == HFP_CODECS_RECEIVED_LIST){ 701 hfp_connection->state = HFP_W4_RETRIEVE_INDICATORS; 702 } 703 return sent; 704 705 case HFP_CMD_RETRIEVE_AG_INDICATORS: 706 if (hfp_connection->state == HFP_W4_RETRIEVE_INDICATORS) { 707 // HF requested AG Indicators and we did expect it 708 hfp_connection->send_ag_indicators_segment = 0; 709 hfp_connection->state = HFP_RETRIEVE_INDICATORS; 710 // continue below in state switch 711 } 712 break; 713 714 case HFP_CMD_RETRIEVE_AG_INDICATORS_STATUS: 715 if (hfp_connection->state != HFP_W4_RETRIEVE_INDICATORS_STATUS) break; 716 hfp_connection->state = HFP_W4_ENABLE_INDICATORS_STATUS_UPDATE; 717 hfp_ag_send_retrieve_indicators_status_cmd(hfp_connection->rfcomm_cid); 718 return 1; 719 720 case HFP_CMD_ENABLE_INDICATOR_STATUS_UPDATE: 721 if (hfp_connection->state != HFP_W4_ENABLE_INDICATORS_STATUS_UPDATE) break; 722 if (has_call_waiting_and_3way_calling_feature(hfp_connection)){ 723 hfp_connection->state = HFP_W4_RETRIEVE_CAN_HOLD_CALL; 724 } else if (has_hf_indicators_feature(hfp_connection)){ 725 hfp_connection->state = HFP_W4_LIST_GENERIC_STATUS_INDICATORS; 726 } else { 727 hfp_ag_slc_established(hfp_connection); 728 } 729 hfp_ag_send_ok(hfp_connection->rfcomm_cid); 730 return 1; 731 732 case HFP_CMD_SUPPORT_CALL_HOLD_AND_MULTIPARTY_SERVICES: 733 if (hfp_connection->state != HFP_W4_RETRIEVE_CAN_HOLD_CALL) break; 734 if (has_hf_indicators_feature(hfp_connection)){ 735 hfp_connection->state = HFP_W4_LIST_GENERIC_STATUS_INDICATORS; 736 } 737 hfp_ag_send_retrieve_can_hold_call_cmd(hfp_connection->rfcomm_cid); 738 if (!has_hf_indicators_feature(hfp_connection)){ 739 hfp_ag_slc_established(hfp_connection); 740 } 741 return 1; 742 743 case HFP_CMD_LIST_GENERIC_STATUS_INDICATORS: 744 if (hfp_connection->state != HFP_W4_LIST_GENERIC_STATUS_INDICATORS) break; 745 hfp_connection->state = HFP_W4_RETRIEVE_GENERIC_STATUS_INDICATORS; 746 hfp_ag_send_list_supported_generic_status_indicators_cmd(hfp_connection->rfcomm_cid); 747 return 1; 748 749 case HFP_CMD_RETRIEVE_GENERIC_STATUS_INDICATORS: 750 if (hfp_connection->state != HFP_W4_RETRIEVE_GENERIC_STATUS_INDICATORS) break; 751 hfp_connection->state = HFP_W4_RETRIEVE_INITITAL_STATE_GENERIC_STATUS_INDICATORS; 752 hfp_ag_send_retrieve_supported_generic_status_indicators_cmd(hfp_connection->rfcomm_cid); 753 return 1; 754 755 case HFP_CMD_RETRIEVE_GENERIC_STATUS_INDICATORS_STATE: 756 if (hfp_connection->state != HFP_W4_RETRIEVE_INITITAL_STATE_GENERIC_STATUS_INDICATORS) break; 757 hfp_ag_slc_established(hfp_connection); 758 hfp_ag_send_retrieve_initital_supported_generic_status_indicators_cmd(hfp_connection->rfcomm_cid); 759 return 1; 760 default: 761 break; 762 } 763 764 switch (hfp_connection->state){ 765 case HFP_RETRIEVE_INDICATORS: { 766 int next_segment = hfp_ag_send_retrieve_indicators_cmd_via_generator(hfp_connection->rfcomm_cid, hfp_connection, hfp_connection->send_ag_indicators_segment); 767 int num_segments = hfp_ag_indicators_cmd_generator_num_segments(hfp_connection); 768 log_info("HFP_CMD_RETRIEVE_AG_INDICATORS next segment %u, num_segments %u", next_segment, num_segments); 769 if (next_segment < num_segments){ 770 // prepare sending of next segment 771 hfp_connection->send_ag_indicators_segment = next_segment; 772 log_info("HFP_CMD_RETRIEVE_AG_INDICATORS more. command %u, next seg %u", hfp_connection->command, next_segment); 773 } else { 774 // done, go to next state 775 hfp_connection->send_ag_indicators_segment = 0; 776 hfp_connection->state = HFP_W4_RETRIEVE_INDICATORS_STATUS; 777 } 778 return 1; 779 } 780 default: 781 break; 782 } 783 return 0; 784 } 785 786 static bool hfp_ag_vra_flag_supported(hfp_connection_t * hfp_connection){ 787 int ag = get_bit(hfp_ag_supported_features, HFP_AGSF_VOICE_RECOGNITION_FUNCTION); 788 int hf = get_bit(hfp_connection->remote_supported_features, HFP_HFSF_VOICE_RECOGNITION_FUNCTION); 789 return hf && ag; 790 } 791 792 static bool hfp_ag_enhanced_vra_flag_supported(hfp_connection_t * hfp_connection){ 793 int ag = get_bit(hfp_ag_supported_features, HFP_AGSF_ENHANCED_VOICE_RECOGNITION_STATUS); 794 int hf = get_bit(hfp_connection->remote_supported_features, HFP_HFSF_ENHANCED_VOICE_RECOGNITION_STATUS); 795 return hf && ag; 796 } 797 798 static bool hfp_ag_can_send_enhanced_vra_message_flag_supported(hfp_connection_t * hfp_connection){ 799 int ag = get_bit(hfp_ag_supported_features, HFP_AGSF_VOICE_RECOGNITION_TEXT); 800 int hf = get_bit(hfp_connection->remote_supported_features, HFP_HFSF_VOICE_RECOGNITION_TEXT); 801 return hf && ag; 802 } 803 804 static bool hfp_ag_can_activate_voice_recognition(hfp_connection_t * hfp_connection){ 805 if (hfp_connection->state < HFP_SERVICE_LEVEL_CONNECTION_ESTABLISHED || hfp_connection->state > HFP_AUDIO_CONNECTION_ESTABLISHED){ 806 return false; 807 } 808 if (hfp_connection->vra_state != HFP_VRA_VOICE_RECOGNITION_OFF){ 809 return false; 810 } 811 if (hfp_connection->ag_vra_send_command){ 812 return false; 813 } 814 return true; 815 } 816 817 static bool hfp_ag_voice_recognition_session_active(hfp_connection_t * hfp_connection){ 818 if (hfp_connection->state < HFP_SERVICE_LEVEL_CONNECTION_ESTABLISHED || hfp_connection->state > HFP_AUDIO_CONNECTION_ESTABLISHED){ 819 return false; 820 } 821 if (hfp_connection->vra_state != HFP_VRA_VOICE_RECOGNITION_ACTIVATED){ 822 if (hfp_connection->vra_state == HFP_VRA_ENHANCED_VOICE_RECOGNITION_READY_FOR_AUDIO){ 823 return true; 824 } 825 return false; 826 } 827 return true; 828 } 829 830 static bool hfp_ag_is_audio_connection_active(hfp_connection_t * hfp_connection){ 831 switch (hfp_connection->state){ 832 case HFP_W2_CONNECT_SCO: 833 case HFP_W4_SCO_CONNECTED: 834 case HFP_AUDIO_CONNECTION_ESTABLISHED: 835 return true; 836 default: 837 return false; 838 } 839 } 840 841 static void hfp_ag_emit_enhanced_voice_recognition_msg_sent_event(hfp_connection_t * hfp_connection, uint8_t status){ 842 hci_con_handle_t acl_handle = (hfp_connection != NULL) ? hfp_connection->acl_handle : HCI_CON_HANDLE_INVALID; 843 844 uint8_t event[6]; 845 event[0] = HCI_EVENT_HFP_META; 846 event[1] = sizeof(event) - 2; 847 event[2] = HFP_SUBEVENT_ENHANCED_VOICE_RECOGNITION_AG_MESSAGE_SENT; 848 little_endian_store_16(event, 3, acl_handle); 849 event[5] = status; 850 (*hfp_ag_callback)(HCI_EVENT_PACKET, 0, event, sizeof(event)); 851 } 852 853 854 static void hfp_ag_emit_hf_indicator_value(hfp_connection_t * hfp_connection, uint16_t uuid, uint8_t value){ 855 hci_con_handle_t acl_handle = (hfp_connection != NULL) ? hfp_connection->acl_handle : HCI_CON_HANDLE_INVALID; 856 857 uint8_t event[8]; 858 event[0] = HCI_EVENT_HFP_META; 859 event[1] = sizeof(event) - 2; 860 event[2] = HFP_SUBEVENT_HF_INDICATOR; 861 little_endian_store_16(event, 3, acl_handle); 862 little_endian_store_16(event, 5, uuid); 863 event[7] = value; 864 (*hfp_ag_callback)(HCI_EVENT_PACKET, 0, event, sizeof(event)); 865 } 866 867 static void hfp_ag_emit_general_simple_event(uint8_t event_subtype){ 868 if (!hfp_ag_callback) return; 869 870 uint8_t event[5]; 871 event[0] = HCI_EVENT_HFP_META; 872 event[1] = sizeof(event) - 2; 873 event[2] = event_subtype; 874 little_endian_store_16(event, 3, HCI_CON_HANDLE_INVALID); 875 (*hfp_ag_callback)(HCI_EVENT_PACKET, 0, event, sizeof(event)); 876 } 877 878 static void hfp_ag_emit_custom_command_event(hfp_connection_t * hfp_connection){ 879 btstack_assert(sizeof(hfp_connection->line_buffer) < (255-5)); 880 881 uint16_t line_len = strlen((const char*)hfp_connection->line_buffer) + 1; 882 uint8_t event[7 + sizeof(hfp_connection->line_buffer)]; 883 event[0] = HCI_EVENT_HFP_META; 884 event[1] = 5 + line_len; 885 event[2] = HFP_SUBEVENT_CUSTOM_AT_COMMAND; 886 little_endian_store_16(event, 3, hfp_connection->acl_handle); 887 little_endian_store_16(event, 5, hfp_connection->ag_custom_at_command_id); 888 memcpy(&event[7], hfp_connection->line_buffer, line_len); 889 (*hfp_ag_callback)(HCI_EVENT_PACKET, 0, event, 7 + line_len); 890 } 891 892 // @return status 893 static uint8_t hfp_ag_vra_state_machine_two(hfp_connection_t * hfp_connection){ 894 uint8_t status = ERROR_CODE_SUCCESS; 895 switch (hfp_connection->vra_state_requested){ 896 case HFP_VRA_W2_SEND_ENHANCED_VOICE_RECOGNITION_READY_FOR_AUDIO: 897 if (!hfp_ag_is_audio_connection_active(hfp_connection)){ 898 status = hfp_ag_setup_audio_connection(hfp_connection); 899 if (status != ERROR_CODE_SUCCESS){ 900 hfp_connection->vra_state_requested = hfp_connection->vra_state; 901 hfp_emit_voice_recognition_enabled(hfp_connection, status); 902 break; 903 } 904 } 905 hfp_connection->enhanced_voice_recognition_enabled = true; 906 hfp_connection->vra_state = HFP_VRA_ENHANCED_VOICE_RECOGNITION_READY_FOR_AUDIO; 907 hfp_connection->vra_state_requested = hfp_connection->vra_state; 908 hfp_emit_enhanced_voice_recognition_hf_ready_for_audio_event(hfp_connection, ERROR_CODE_SUCCESS); 909 break; 910 911 case HFP_VRA_W2_SEND_VOICE_RECOGNITION_OFF: 912 hfp_connection->vra_state = HFP_VRA_VOICE_RECOGNITION_OFF; 913 hfp_connection->vra_state_requested = hfp_connection->vra_state; 914 915 // release audio connection only if it was opened after audio VR activated 916 if (hfp_ag_is_audio_connection_active(hfp_connection) && !hfp_connection->ag_audio_connection_opened_before_vra){ 917 hfp_trigger_release_audio_connection(hfp_connection); 918 } 919 920 hfp_emit_voice_recognition_disabled(hfp_connection, ERROR_CODE_SUCCESS); 921 break; 922 923 case HFP_VRA_W2_SEND_VOICE_RECOGNITION_ACTIVATED: 924 // open only if audio connection does not already exist 925 if (!hfp_ag_is_audio_connection_active(hfp_connection)){ 926 status = hfp_ag_setup_audio_connection(hfp_connection); 927 if (status != ERROR_CODE_SUCCESS){ 928 hfp_connection->vra_state_requested = hfp_connection->vra_state; 929 hfp_emit_voice_recognition_enabled(hfp_connection, status); 930 break; 931 } 932 } 933 934 hfp_connection->vra_state = HFP_VRA_VOICE_RECOGNITION_ACTIVATED; 935 hfp_connection->vra_state_requested = hfp_connection->vra_state; 936 hfp_connection->enhanced_voice_recognition_enabled = hfp_ag_enhanced_vra_flag_supported(hfp_connection); 937 938 if (hfp_connection->state == HFP_AUDIO_CONNECTION_ESTABLISHED){ 939 hfp_emit_voice_recognition_enabled(hfp_connection, ERROR_CODE_SUCCESS); 940 } else { 941 hfp_connection->emit_vra_enabled_after_audio_established = true; 942 } 943 break; 944 945 default: 946 break; 947 } 948 return status; 949 } 950 951 static uint8_t hfp_ag_vra_send_command(hfp_connection_t * hfp_connection){ 952 uint8_t done = 0; 953 uint8_t status; 954 955 switch (hfp_connection->vra_state_requested){ 956 case HFP_VRA_W2_SEND_ENHANCED_VOICE_RECOGNITION_MSG: 957 done = hfp_ag_send_enhanced_voice_recognition_msg_cmd(hfp_connection); 958 if (done == 0){ 959 hfp_ag_emit_enhanced_voice_recognition_msg_sent_event(hfp_connection, ERROR_CODE_UNSPECIFIED_ERROR); 960 } else { 961 hfp_ag_emit_enhanced_voice_recognition_msg_sent_event(hfp_connection, ERROR_CODE_SUCCESS); 962 } 963 hfp_connection->vra_state_requested = hfp_connection->vra_state; 964 return done; 965 966 case HFP_VRA_W2_SEND_ENHANCED_VOICE_RECOGNITION_STATUS: 967 done = hfp_ag_send_enhanced_voice_recognition_state_cmd(hfp_connection); 968 if (done == 0){ 969 hfp_emit_enhanced_voice_recognition_state_event(hfp_connection, ERROR_CODE_UNSPECIFIED_ERROR); 970 } else { 971 hfp_emit_enhanced_voice_recognition_state_event(hfp_connection, ERROR_CODE_SUCCESS); 972 } 973 hfp_connection->vra_state_requested = hfp_connection->vra_state; 974 return done; 975 976 case HFP_VRA_W2_SEND_VOICE_RECOGNITION_ACTIVATED: 977 case HFP_VRA_W2_SEND_VOICE_RECOGNITION_OFF: 978 done = hfp_ag_send_voice_recognition_cmd(hfp_connection, hfp_connection->ag_activate_voice_recognition_value); 979 if (done == 0){ 980 hfp_connection->vra_state_requested = hfp_connection->vra_state; 981 982 if (hfp_connection->ag_activate_voice_recognition_value == 1){ 983 hfp_emit_voice_recognition_enabled(hfp_connection, done); 984 } else { 985 hfp_emit_voice_recognition_disabled(hfp_connection, done); 986 } 987 return 0; 988 } 989 status = hfp_ag_vra_state_machine_two(hfp_connection); 990 return (status == ERROR_CODE_SUCCESS) ? 1 : 0; 991 992 default: 993 log_error("state %u", hfp_connection->vra_state_requested); 994 btstack_assert(false); 995 return 0; 996 } 997 } 998 999 static int hfp_ag_voice_recognition_state_machine(hfp_connection_t * hfp_connection){ 1000 if (hfp_connection->state < HFP_SERVICE_LEVEL_CONNECTION_ESTABLISHED) { 1001 return 0; 1002 } 1003 int done = 0; 1004 uint8_t status; 1005 1006 // VRA action initiated by AG 1007 if (hfp_connection->ag_vra_send_command){ 1008 hfp_connection->ag_vra_send_command = false; 1009 return hfp_ag_vra_send_command(hfp_connection); 1010 } 1011 1012 if (hfp_connection->ag_vra_requested_by_hf){ 1013 hfp_connection->ag_vra_requested_by_hf = false; 1014 1015 // HF initiatied voice recognition, parser extracted activation value 1016 switch (hfp_connection->ag_activate_voice_recognition_value){ 1017 case 0: 1018 if (hfp_ag_voice_recognition_session_active(hfp_connection)){ 1019 hfp_connection->vra_state_requested = HFP_VRA_W2_SEND_VOICE_RECOGNITION_OFF; 1020 done = hfp_ag_send_ok(hfp_connection->rfcomm_cid); 1021 } 1022 break; 1023 1024 case 1: 1025 if (hfp_ag_can_activate_voice_recognition(hfp_connection)){ 1026 hfp_connection->vra_state_requested = HFP_VRA_W2_SEND_VOICE_RECOGNITION_ACTIVATED; 1027 done = hfp_ag_send_ok(hfp_connection->rfcomm_cid); 1028 } 1029 break; 1030 1031 case 2: 1032 if (hfp_ag_voice_recognition_session_active(hfp_connection)){ 1033 hfp_connection->vra_state_requested = HFP_VRA_W2_SEND_ENHANCED_VOICE_RECOGNITION_READY_FOR_AUDIO; 1034 done = hfp_ag_send_ok(hfp_connection->rfcomm_cid); 1035 } 1036 break; 1037 default: 1038 break; 1039 } 1040 if (done == 0){ 1041 hfp_connection->vra_state_requested = hfp_connection->vra_state; 1042 done = hfp_ag_send_error(hfp_connection->rfcomm_cid); 1043 return 1; 1044 } 1045 1046 status = hfp_ag_vra_state_machine_two(hfp_connection); 1047 return (status == ERROR_CODE_SUCCESS) ? 1 : 0; 1048 } 1049 1050 return 0; 1051 } 1052 1053 static int hfp_ag_run_for_context_service_level_connection_queries(hfp_connection_t * hfp_connection){ 1054 int sent = codecs_exchange_state_machine(hfp_connection); 1055 if (sent) return 1; 1056 1057 if (hfp_connection->ag_send_in_band_ring_tone_setting){ 1058 hfp_connection->ag_send_in_band_ring_tone_setting = false; 1059 hfp_ag_send_change_in_band_ring_tone_setting_cmd(hfp_connection->rfcomm_cid); 1060 return 1; 1061 } 1062 1063 switch(hfp_connection->command){ 1064 case HFP_CMD_QUERY_OPERATOR_SELECTION_NAME: 1065 hfp_ag_send_report_network_operator_name_cmd(hfp_connection->rfcomm_cid, hfp_connection->network_operator); 1066 return 1; 1067 case HFP_CMD_QUERY_OPERATOR_SELECTION_NAME_FORMAT: 1068 if (hfp_connection->network_operator.format != 0){ 1069 hfp_ag_send_error(hfp_connection->rfcomm_cid); 1070 } else { 1071 hfp_ag_send_ok(hfp_connection->rfcomm_cid); 1072 } 1073 return 1; 1074 case HFP_CMD_ENABLE_INDIVIDUAL_AG_INDICATOR_STATUS_UPDATE: 1075 hfp_ag_send_ok(hfp_connection->rfcomm_cid); 1076 return 1; 1077 case HFP_CMD_ENABLE_EXTENDED_AUDIO_GATEWAY_ERROR: 1078 if (hfp_connection->extended_audio_gateway_error){ 1079 hfp_connection->extended_audio_gateway_error = 0; 1080 hfp_ag_send_report_extended_audio_gateway_error(hfp_connection->rfcomm_cid, hfp_connection->extended_audio_gateway_error_value); 1081 return 1; 1082 } 1083 break; 1084 case HFP_CMD_ENABLE_INDICATOR_STATUS_UPDATE: 1085 hfp_ag_send_ok(hfp_connection->rfcomm_cid); 1086 return 1; 1087 default: 1088 break; 1089 } 1090 return 0; 1091 } 1092 1093 static int hfp_ag_run_for_audio_connection(hfp_connection_t * hfp_connection){ 1094 if ((hfp_connection->state < HFP_SERVICE_LEVEL_CONNECTION_ESTABLISHED) || 1095 (hfp_connection->state > HFP_W2_DISCONNECT_SCO)) return 0; 1096 1097 if (hfp_connection->state == HFP_AUDIO_CONNECTION_ESTABLISHED) return 0; 1098 1099 if (hfp_connection->release_audio_connection){ 1100 hfp_connection->state = HFP_W4_SCO_DISCONNECTED; 1101 hfp_connection->release_audio_connection = 0; 1102 gap_disconnect(hfp_connection->sco_handle); 1103 return 1; 1104 } 1105 1106 // accept incoming audio connection (codec negotiation is not used) 1107 if (hfp_connection->accept_sco){ 1108 // notify about codec selection if not done already 1109 if (hfp_connection->negotiated_codec == 0){ 1110 hfp_connection->negotiated_codec = HFP_CODEC_CVSD; 1111 } 1112 // 1113 bool incoming_eSCO = hfp_connection->accept_sco == 2; 1114 hfp_connection->accept_sco = 0; 1115 hfp_connection->state = HFP_W4_SCO_CONNECTED; 1116 hfp_accept_synchronous_connection(hfp_connection, incoming_eSCO); 1117 return 1; 1118 } 1119 1120 // run codecs exchange 1121 int sent = codecs_exchange_state_machine(hfp_connection); 1122 if (sent) return 1; 1123 1124 if (hfp_connection->codecs_state != HFP_CODECS_EXCHANGED) return 0; 1125 if (hfp_connection->establish_audio_connection){ 1126 hfp_connection->state = HFP_W4_SCO_CONNECTED; 1127 hfp_connection->establish_audio_connection = 0; 1128 hfp_setup_synchronous_connection(hfp_connection); 1129 return 1; 1130 } 1131 return 0; 1132 } 1133 1134 static void hfp_ag_set_callsetup_indicator(void){ 1135 hfp_ag_indicator_t * indicator = get_ag_indicator_for_name("callsetup"); 1136 if (!indicator){ 1137 log_error("hfp_ag_set_callsetup_indicator: callsetup indicator is missing"); 1138 return; 1139 }; 1140 indicator->status = hfp_gsm_callsetup_status(); 1141 } 1142 1143 static void hfp_ag_set_callheld_indicator(void){ 1144 hfp_ag_indicator_t * indicator = get_ag_indicator_for_name("callheld"); 1145 if (!indicator){ 1146 log_error("hfp_ag_set_callheld_state: callheld indicator is missing"); 1147 return; 1148 }; 1149 indicator->status = hfp_gsm_callheld_status(); 1150 } 1151 1152 // 1153 // transition implementations for hfp_ag_call_state_machine 1154 // 1155 1156 static void hfp_ag_hf_start_ringing_incoming(hfp_connection_t * hfp_connection){ 1157 if (use_in_band_tone()){ 1158 hfp_connection->call_state = HFP_CALL_W4_AUDIO_CONNECTION_FOR_IN_BAND_RING; 1159 hfp_ag_establish_audio_connection(hfp_connection->acl_handle); 1160 } else { 1161 hfp_connection->call_state = HFP_CALL_INCOMING_RINGING; 1162 } 1163 } 1164 1165 static void hfp_ag_hf_start_ringing_outgoing(hfp_connection_t * hfp_connection){ 1166 hfp_connection->call_state = HFP_CALL_OUTGOING_RINGING; 1167 } 1168 1169 static void hfp_ag_hf_stop_ringing(hfp_connection_t * hfp_connection){ 1170 hfp_connection->ag_ring = 0; 1171 hfp_connection->ag_send_clip = 0; 1172 } 1173 1174 1175 static void hfp_ag_trigger_incoming_call_during_active_one(void){ 1176 btstack_linked_list_iterator_t it; 1177 btstack_linked_list_iterator_init(&it, hfp_get_connections()); 1178 while (btstack_linked_list_iterator_has_next(&it)){ 1179 hfp_connection_t * hfp_connection = (hfp_connection_t *)btstack_linked_list_iterator_next(&it); 1180 if (hfp_connection->local_role != HFP_ROLE_AG) continue; 1181 if (hfp_connection->call_state != HFP_CALL_ACTIVE) continue; 1182 1183 hfp_connection->call_state = HFP_CALL_W2_SEND_CALL_WAITING; 1184 hfp_ag_run_for_context(hfp_connection); 1185 } 1186 } 1187 1188 static void hfp_ag_trigger_ring_and_clip(void) { 1189 btstack_linked_list_iterator_t it; 1190 btstack_linked_list_iterator_init(&it, hfp_get_connections()); 1191 while (btstack_linked_list_iterator_has_next(&it)){ 1192 hfp_connection_t * hfp_connection = (hfp_connection_t *)btstack_linked_list_iterator_next(&it); 1193 if (hfp_connection->local_role != HFP_ROLE_AG) continue; 1194 switch (hfp_connection->call_state){ 1195 case HFP_CALL_INCOMING_RINGING: 1196 case HFP_CALL_OUTGOING_RINGING: 1197 case HFP_CALL_W4_AUDIO_CONNECTION_FOR_IN_BAND_RING: 1198 // Queue RING on this connection 1199 hfp_connection->ag_ring = 1; 1200 1201 // HFP v1.8, 4.23 Calling Line Identification (CLI) Notification 1202 // "If the calling subscriber number information is available from the network, the AG shall issue the 1203 // +CLIP unsolicited result code just after every RING indication when the HF is alerted in an incoming call." 1204 hfp_connection->ag_send_clip = hfp_gsm_clip_type() && hfp_connection->clip_enabled; 1205 1206 // trigger next message 1207 rfcomm_request_can_send_now_event(hfp_connection->rfcomm_cid); 1208 break; 1209 default: 1210 break; 1211 } 1212 } 1213 } 1214 1215 // trigger RING and CLIP messages on connections that are ringing 1216 static void hfp_ag_ring_timeout_handler(btstack_timer_source_t * timer){ 1217 hfp_ag_trigger_ring_and_clip(); 1218 1219 btstack_run_loop_set_timer(timer, HFP_RING_PERIOD_MS); // 2 seconds timeout 1220 btstack_run_loop_add_timer(timer); 1221 } 1222 1223 static void hfp_ag_ring_timeout_stop(void){ 1224 btstack_run_loop_remove_timer(&hfp_ag_ring_timeout); 1225 } 1226 1227 static void hfp_ag_start_ringing(void){ 1228 // setup ring timer 1229 btstack_run_loop_remove_timer(&hfp_ag_ring_timeout); 1230 btstack_run_loop_set_timer_handler(&hfp_ag_ring_timeout, hfp_ag_ring_timeout_handler); 1231 btstack_run_loop_set_timer(&hfp_ag_ring_timeout, HFP_RING_PERIOD_MS); // 2 seconds timeout 1232 btstack_run_loop_add_timer(&hfp_ag_ring_timeout); 1233 1234 // emit start ringing 1235 hfp_ag_emit_general_simple_event(HFP_SUBEVENT_START_RINGING); 1236 1237 // send initial RING + CLIP 1238 hfp_ag_trigger_ring_and_clip(); 1239 } 1240 1241 static void hfp_ag_stop_ringing(void){ 1242 hfp_ag_ring_timeout_stop(); 1243 hfp_ag_emit_general_simple_event(HFP_SUBEVENT_STOP_RINGING); 1244 1245 btstack_linked_list_iterator_t it; 1246 btstack_linked_list_iterator_init(&it, hfp_get_connections()); 1247 while (btstack_linked_list_iterator_has_next(&it)){ 1248 hfp_connection_t * hfp_connection = (hfp_connection_t *)btstack_linked_list_iterator_next(&it); 1249 if (hfp_connection->local_role != HFP_ROLE_AG) continue; 1250 if ((hfp_connection->call_state != HFP_CALL_INCOMING_RINGING) && 1251 (hfp_connection->call_state != HFP_CALL_W4_AUDIO_CONNECTION_FOR_IN_BAND_RING)) continue; 1252 hfp_ag_hf_stop_ringing(hfp_connection); 1253 } 1254 } 1255 1256 static void hfp_ag_trigger_incoming_call_idle(void){ 1257 int indicator_index = get_ag_indicator_index_for_name("callsetup"); 1258 if (indicator_index < 0) return; 1259 1260 // update callsetup state in connections 1261 btstack_linked_list_iterator_t it; 1262 btstack_linked_list_iterator_init(&it, hfp_get_connections()); 1263 while (btstack_linked_list_iterator_has_next(&it)){ 1264 hfp_connection_t * hfp_connection = (hfp_connection_t *)btstack_linked_list_iterator_next(&it); 1265 if (hfp_connection->local_role != HFP_ROLE_AG) continue; 1266 if (hfp_connection->call_state != HFP_CALL_IDLE) continue; 1267 1268 hfp_connection->ag_indicators_status_update_bitmap = store_bit(hfp_connection->ag_indicators_status_update_bitmap, indicator_index, 1); 1269 1270 hfp_ag_hf_start_ringing_incoming(hfp_connection); 1271 1272 hfp_ag_run_for_context(hfp_connection); 1273 } 1274 1275 // start local ringing - started after connection state has been updated 1276 hfp_ag_start_ringing(); 1277 } 1278 1279 static void hfp_ag_trigger_outgoing_call(void){ 1280 btstack_linked_list_iterator_t it; 1281 btstack_linked_list_iterator_init(&it, hfp_get_connections()); 1282 while (btstack_linked_list_iterator_has_next(&it)){ 1283 hfp_connection_t * hfp_connection = (hfp_connection_t *)btstack_linked_list_iterator_next(&it); 1284 if (hfp_connection->local_role != HFP_ROLE_AG) continue; 1285 hfp_ag_establish_service_level_connection(hfp_connection->remote_addr); 1286 if (hfp_connection->call_state == HFP_CALL_IDLE){ 1287 hfp_connection->call_state = HFP_CALL_OUTGOING_INITIATED; 1288 } 1289 } 1290 } 1291 1292 static void hfp_ag_handle_outgoing_call_accepted(hfp_connection_t * hfp_connection){ 1293 hfp_connection->call_state = HFP_CALL_OUTGOING_DIALING; 1294 1295 // trigger callsetup to be 1296 int put_call_on_hold = hfp_gsm_call_status() == HFP_CALL_STATUS_ACTIVE_OR_HELD_CALL_IS_PRESENT; 1297 hfp_gsm_handler(HFP_AG_OUTGOING_CALL_ACCEPTED, 0, 0, NULL); 1298 1299 int indicator_index ; 1300 1301 hfp_ag_set_callsetup_indicator(); 1302 indicator_index = get_ag_indicator_index_for_name("callsetup"); 1303 hfp_connection->ag_indicators_status_update_bitmap = store_bit(hfp_connection->ag_indicators_status_update_bitmap, indicator_index, 1); 1304 1305 // put current call on hold if active 1306 if (put_call_on_hold){ 1307 log_info("AG putting current call on hold for new outgoing call"); 1308 hfp_ag_set_callheld_indicator(); 1309 indicator_index = get_ag_indicator_index_for_name("callheld"); 1310 hfp_ag_send_transfer_ag_indicators_status_cmd(hfp_connection->rfcomm_cid, &hfp_ag_indicators[indicator_index]); 1311 } 1312 1313 // start audio if needed 1314 hfp_ag_establish_audio_connection(hfp_connection->acl_handle); 1315 } 1316 1317 static void hfp_ag_transfer_indicator(const char * name){ 1318 int indicator_index = get_ag_indicator_index_for_name(name); 1319 if (indicator_index < 0) return; 1320 1321 btstack_linked_list_iterator_t it; 1322 btstack_linked_list_iterator_init(&it, hfp_get_connections()); 1323 while (btstack_linked_list_iterator_has_next(&it)){ 1324 hfp_connection_t * hfp_connection = (hfp_connection_t *)btstack_linked_list_iterator_next(&it); 1325 if (hfp_connection->local_role != HFP_ROLE_AG) continue; 1326 hfp_ag_establish_service_level_connection(hfp_connection->remote_addr); 1327 hfp_connection->ag_indicators_status_update_bitmap = store_bit(hfp_connection->ag_indicators_status_update_bitmap, indicator_index, 1); 1328 hfp_ag_run_for_context(hfp_connection); 1329 } 1330 } 1331 1332 static void hfp_ag_transfer_callsetup_state(void){ 1333 hfp_ag_transfer_indicator("callsetup"); 1334 } 1335 1336 static void hfp_ag_transfer_call_state(void){ 1337 hfp_ag_transfer_indicator("call"); 1338 } 1339 1340 static void hfp_ag_transfer_callheld_state(void){ 1341 hfp_ag_transfer_indicator("callheld"); 1342 } 1343 1344 static void hfp_ag_hf_accept_call(hfp_connection_t * source){ 1345 int call_indicator_index = get_ag_indicator_index_for_name("call"); 1346 int callsetup_indicator_index = get_ag_indicator_index_for_name("callsetup"); 1347 1348 hfp_ag_stop_ringing(); 1349 1350 btstack_linked_list_iterator_t it; 1351 btstack_linked_list_iterator_init(&it, hfp_get_connections()); 1352 while (btstack_linked_list_iterator_has_next(&it)){ 1353 hfp_connection_t * hfp_connection = (hfp_connection_t *)btstack_linked_list_iterator_next(&it); 1354 if (hfp_connection->local_role != HFP_ROLE_AG) continue; 1355 if ((hfp_connection->call_state != HFP_CALL_INCOMING_RINGING) && 1356 (hfp_connection->call_state != HFP_CALL_W4_AUDIO_CONNECTION_FOR_IN_BAND_RING)) continue; 1357 1358 if (hfp_connection == source){ 1359 1360 if (use_in_band_tone()){ 1361 hfp_connection->call_state = HFP_CALL_ACTIVE; 1362 } else { 1363 hfp_connection->call_state = HFP_CALL_W4_AUDIO_CONNECTION_FOR_ACTIVE; 1364 hfp_ag_establish_audio_connection(hfp_connection->acl_handle); 1365 } 1366 1367 hfp_connection->ag_indicators_status_update_bitmap = store_bit(hfp_connection->ag_indicators_status_update_bitmap, call_indicator_index, 1); 1368 hfp_connection->ag_indicators_status_update_bitmap = store_bit(hfp_connection->ag_indicators_status_update_bitmap, callsetup_indicator_index, 1); 1369 1370 } else { 1371 hfp_connection->call_state = HFP_CALL_IDLE; 1372 } 1373 hfp_ag_run_for_context(hfp_connection); 1374 } 1375 } 1376 1377 static void hfp_ag_ag_accept_call(void){ 1378 int call_indicator_index = get_ag_indicator_index_for_name("call"); 1379 int callsetup_indicator_index = get_ag_indicator_index_for_name("callsetup"); 1380 1381 hfp_ag_stop_ringing(); 1382 1383 btstack_linked_list_iterator_t it; 1384 btstack_linked_list_iterator_init(&it, hfp_get_connections()); 1385 while (btstack_linked_list_iterator_has_next(&it)){ 1386 hfp_connection_t * hfp_connection = (hfp_connection_t *)btstack_linked_list_iterator_next(&it); 1387 if (hfp_connection->local_role != HFP_ROLE_AG) continue; 1388 if ((hfp_connection->call_state != HFP_CALL_INCOMING_RINGING) && 1389 (hfp_connection->call_state != HFP_CALL_W4_AUDIO_CONNECTION_FOR_IN_BAND_RING)) continue; 1390 1391 hfp_connection->call_state = HFP_CALL_TRIGGER_AUDIO_CONNECTION; 1392 1393 hfp_connection->ag_indicators_status_update_bitmap = store_bit(hfp_connection->ag_indicators_status_update_bitmap, call_indicator_index, 1); 1394 hfp_connection->ag_indicators_status_update_bitmap = store_bit(hfp_connection->ag_indicators_status_update_bitmap, callsetup_indicator_index, 1); 1395 1396 hfp_ag_run_for_context(hfp_connection); 1397 break; // only single 1398 } 1399 } 1400 1401 static void hfp_ag_trigger_reject_call(void){ 1402 int callsetup_indicator_index = get_ag_indicator_index_for_name("callsetup"); 1403 1404 hfp_ag_stop_ringing(); 1405 1406 btstack_linked_list_iterator_t it; 1407 btstack_linked_list_iterator_init(&it, hfp_get_connections()); 1408 while (btstack_linked_list_iterator_has_next(&it)){ 1409 hfp_connection_t * connection = (hfp_connection_t *)btstack_linked_list_iterator_next(&it); 1410 if (connection->local_role != HFP_ROLE_AG) continue; 1411 1412 switch (connection->call_state){ 1413 case HFP_CALL_INCOMING_RINGING: 1414 case HFP_CALL_W4_AUDIO_CONNECTION_FOR_IN_BAND_RING: 1415 case HFP_CALL_OUTGOING_RINGING: 1416 case HFP_CALL_OUTGOING_INITIATED: 1417 case HFP_CALL_OUTGOING_DIALING: 1418 break; 1419 default: 1420 continue; 1421 } 1422 1423 connection->call_state = HFP_CALL_IDLE; 1424 connection->ag_indicators_status_update_bitmap = store_bit(connection->ag_indicators_status_update_bitmap, callsetup_indicator_index, 1); 1425 1426 if (connection->state == HFP_AUDIO_CONNECTION_ESTABLISHED){ 1427 connection->release_audio_connection = 1; 1428 } 1429 hfp_emit_simple_event(connection, HFP_SUBEVENT_CALL_TERMINATED); 1430 hfp_ag_run_for_context(connection); 1431 rfcomm_request_can_send_now_event(connection->rfcomm_cid); 1432 } 1433 } 1434 1435 static void hfp_ag_trigger_terminate_call(void){ 1436 int call_indicator_index = get_ag_indicator_index_for_name("call"); 1437 1438 // no ringing during call 1439 1440 btstack_linked_list_iterator_t it; 1441 btstack_linked_list_iterator_init(&it, hfp_get_connections()); 1442 while (btstack_linked_list_iterator_has_next(&it)){ 1443 hfp_connection_t * hfp_connection = (hfp_connection_t *)btstack_linked_list_iterator_next(&it); 1444 if (hfp_connection->local_role != HFP_ROLE_AG) continue; 1445 if (hfp_connection->call_state == HFP_CALL_IDLE) continue; 1446 1447 hfp_connection->call_state = HFP_CALL_IDLE; 1448 hfp_connection->ag_indicators_status_update_bitmap = store_bit(hfp_connection->ag_indicators_status_update_bitmap, call_indicator_index, 1); 1449 1450 if (hfp_connection->state == HFP_AUDIO_CONNECTION_ESTABLISHED){ 1451 hfp_connection->release_audio_connection = 1; 1452 } 1453 1454 hfp_emit_simple_event(hfp_connection, HFP_SUBEVENT_CALL_TERMINATED); 1455 hfp_ag_run_for_context(hfp_connection); 1456 rfcomm_request_can_send_now_event(hfp_connection->rfcomm_cid); 1457 } 1458 } 1459 1460 static void hfp_ag_set_call_indicator(void){ 1461 hfp_ag_indicator_t * indicator = get_ag_indicator_for_name("call"); 1462 if (!indicator){ 1463 log_error("hfp_ag_set_call_state: call indicator is missing"); 1464 return; 1465 }; 1466 indicator->status = hfp_gsm_call_status(); 1467 } 1468 1469 static hfp_connection_t * hfp_ag_connection_for_call_state(hfp_call_state_t call_state){ 1470 btstack_linked_list_iterator_t it; 1471 btstack_linked_list_iterator_init(&it, hfp_get_connections()); 1472 while (btstack_linked_list_iterator_has_next(&it)){ 1473 hfp_connection_t * hfp_connection = (hfp_connection_t *)btstack_linked_list_iterator_next(&it); 1474 if (hfp_connection->local_role != HFP_ROLE_AG) continue; 1475 if (hfp_connection->call_state == call_state) return hfp_connection; 1476 } 1477 return NULL; 1478 } 1479 1480 static void hfp_ag_send_response_and_hold_state(hfp_response_and_hold_state_t state){ 1481 btstack_linked_list_iterator_t it; 1482 btstack_linked_list_iterator_init(&it, hfp_get_connections()); 1483 while (btstack_linked_list_iterator_has_next(&it)){ 1484 hfp_connection_t * hfp_connection = (hfp_connection_t *)btstack_linked_list_iterator_next(&it); 1485 if (hfp_connection->local_role != HFP_ROLE_AG) continue; 1486 hfp_connection->send_response_and_hold_status = state + 1; 1487 } 1488 } 1489 1490 static int call_setup_state_machine(hfp_connection_t * hfp_connection){ 1491 int indicator_index; 1492 switch (hfp_connection->call_state){ 1493 case HFP_CALL_W4_AUDIO_CONNECTION_FOR_IN_BAND_RING: 1494 if (hfp_connection->state != HFP_AUDIO_CONNECTION_ESTABLISHED) return 0; 1495 // we got event: audio hfp_connection established 1496 hfp_connection->call_state = HFP_CALL_INCOMING_RINGING; 1497 break; 1498 case HFP_CALL_W4_AUDIO_CONNECTION_FOR_ACTIVE: 1499 if (hfp_connection->state != HFP_AUDIO_CONNECTION_ESTABLISHED) return 0; 1500 // we got event: audio hfp_connection established 1501 hfp_connection->call_state = HFP_CALL_ACTIVE; 1502 break; 1503 case HFP_CALL_W2_SEND_CALL_WAITING: 1504 hfp_connection->call_state = HFP_CALL_W4_CHLD; 1505 hfp_ag_send_call_waiting_notification(hfp_connection->rfcomm_cid); 1506 indicator_index = get_ag_indicator_index_for_name("callsetup"); 1507 hfp_connection->ag_indicators_status_update_bitmap = store_bit(hfp_connection->ag_indicators_status_update_bitmap, indicator_index, 1); 1508 break; 1509 default: 1510 break; 1511 } 1512 return 0; 1513 } 1514 1515 // functions extracted from hfp_ag_call_sm below 1516 static void hfp_ag_handle_reject_outgoing_call(void){ 1517 hfp_connection_t * hfp_connection = hfp_ag_connection_for_call_state(HFP_CALL_OUTGOING_INITIATED); 1518 if (!hfp_connection){ 1519 log_info("hfp_ag_call_sm: did not find outgoing hfp_connection in initiated state"); 1520 return; 1521 } 1522 1523 hfp_gsm_handler(HFP_AG_OUTGOING_CALL_REJECTED, 0, 0, NULL); 1524 hfp_connection->call_state = HFP_CALL_IDLE; 1525 hfp_connection->send_error = 1; 1526 hfp_ag_run_for_context(hfp_connection); 1527 } 1528 1529 // hfp_connection is used to identify originating HF 1530 static void hfp_ag_call_sm(hfp_ag_call_event_t event, hfp_connection_t * hfp_connection){ 1531 1532 // allow to intercept call statemachine events 1533 if (hfp_ag_custom_call_sm_handler != NULL){ 1534 bool handle_event = (*hfp_ag_custom_call_sm_handler)(event); 1535 if (!handle_event) return; 1536 } 1537 1538 int callsetup_indicator_index = get_ag_indicator_index_for_name("callsetup"); 1539 int callheld_indicator_index = get_ag_indicator_index_for_name("callheld"); 1540 int call_indicator_index = get_ag_indicator_index_for_name("call"); 1541 1542 switch (event){ 1543 case HFP_AG_INCOMING_CALL: 1544 switch (hfp_gsm_call_status()){ 1545 case HFP_CALL_STATUS_NO_HELD_OR_ACTIVE_CALLS: 1546 switch (hfp_gsm_callsetup_status()){ 1547 case HFP_CALLSETUP_STATUS_NO_CALL_SETUP_IN_PROGRESS: 1548 hfp_gsm_handler(HFP_AG_INCOMING_CALL, 0, 0, NULL); 1549 hfp_ag_set_callsetup_indicator(); 1550 hfp_ag_trigger_incoming_call_idle(); 1551 log_info("AG rings"); 1552 break; 1553 default: 1554 break; 1555 } 1556 break; 1557 case HFP_CALL_STATUS_ACTIVE_OR_HELD_CALL_IS_PRESENT: 1558 switch (hfp_gsm_callsetup_status()){ 1559 case HFP_CALLSETUP_STATUS_NO_CALL_SETUP_IN_PROGRESS: 1560 hfp_gsm_handler(HFP_AG_INCOMING_CALL, 0, 0, NULL); 1561 hfp_ag_set_callsetup_indicator(); 1562 hfp_ag_trigger_incoming_call_during_active_one(); 1563 log_info("AG call waiting"); 1564 break; 1565 default: 1566 break; 1567 } 1568 break; 1569 default: 1570 break; 1571 } 1572 break; 1573 case HFP_AG_INCOMING_CALL_ACCEPTED_BY_AG: 1574 switch (hfp_gsm_call_status()){ 1575 case HFP_CALL_STATUS_NO_HELD_OR_ACTIVE_CALLS: 1576 switch (hfp_gsm_callsetup_status()){ 1577 case HFP_CALLSETUP_STATUS_INCOMING_CALL_SETUP_IN_PROGRESS: 1578 hfp_gsm_handler(HFP_AG_INCOMING_CALL_ACCEPTED_BY_AG, 0, 0, NULL); 1579 hfp_ag_set_call_indicator(); 1580 hfp_ag_set_callsetup_indicator(); 1581 hfp_ag_ag_accept_call(); 1582 log_info("AG answers call, accept call by GSM"); 1583 break; 1584 default: 1585 break; 1586 } 1587 break; 1588 case HFP_CALL_STATUS_ACTIVE_OR_HELD_CALL_IS_PRESENT: 1589 switch (hfp_gsm_callsetup_status()){ 1590 case HFP_CALLSETUP_STATUS_INCOMING_CALL_SETUP_IN_PROGRESS: 1591 log_info("AG: current call is placed on hold, incoming call gets active"); 1592 hfp_gsm_handler(HFP_AG_INCOMING_CALL_ACCEPTED_BY_AG, 0, 0, NULL); 1593 hfp_ag_set_callsetup_indicator(); 1594 hfp_ag_set_callheld_indicator(); 1595 hfp_ag_transfer_callsetup_state(); 1596 hfp_ag_transfer_callheld_state(); 1597 break; 1598 default: 1599 break; 1600 } 1601 break; 1602 default: 1603 break; 1604 } 1605 break; 1606 1607 case HFP_AG_HELD_CALL_JOINED_BY_AG: 1608 switch (hfp_gsm_call_status()){ 1609 case HFP_CALL_STATUS_ACTIVE_OR_HELD_CALL_IS_PRESENT: 1610 switch (hfp_gsm_callheld_status()){ 1611 case HFP_CALLHELD_STATUS_CALL_ON_HOLD_OR_SWAPPED: 1612 log_info("AG: joining held call with active call"); 1613 hfp_gsm_handler(HFP_AG_HELD_CALL_JOINED_BY_AG, 0, 0, NULL); 1614 hfp_ag_set_callheld_indicator(); 1615 hfp_ag_transfer_callheld_state(); 1616 hfp_emit_simple_event(hfp_connection, HFP_SUBEVENT_CONFERENCE_CALL); 1617 break; 1618 default: 1619 break; 1620 } 1621 break; 1622 default: 1623 break; 1624 } 1625 break; 1626 1627 case HFP_AG_INCOMING_CALL_ACCEPTED_BY_HF: 1628 switch (hfp_gsm_call_status()){ 1629 case HFP_CALL_STATUS_NO_HELD_OR_ACTIVE_CALLS: 1630 switch (hfp_gsm_callsetup_status()){ 1631 case HFP_CALLSETUP_STATUS_INCOMING_CALL_SETUP_IN_PROGRESS: 1632 hfp_gsm_handler(HFP_AG_INCOMING_CALL_ACCEPTED_BY_HF, 0, 0, NULL); 1633 hfp_ag_set_callsetup_indicator(); 1634 hfp_ag_set_call_indicator(); 1635 hfp_ag_hf_accept_call(hfp_connection); 1636 hfp_connection->ok_pending = 1; 1637 log_info("HF answers call, accept call by GSM"); 1638 hfp_emit_simple_event(hfp_connection, HFP_SUBEVENT_CALL_ANSWERED); 1639 break; 1640 default: 1641 break; 1642 } 1643 break; 1644 default: 1645 break; 1646 } 1647 break; 1648 1649 case HFP_AG_RESPONSE_AND_HOLD_ACCEPT_INCOMING_CALL_BY_AG: 1650 switch (hfp_gsm_call_status()){ 1651 case HFP_CALL_STATUS_NO_HELD_OR_ACTIVE_CALLS: 1652 switch (hfp_gsm_callsetup_status()){ 1653 case HFP_CALLSETUP_STATUS_INCOMING_CALL_SETUP_IN_PROGRESS: 1654 hfp_gsm_handler(HFP_AG_RESPONSE_AND_HOLD_ACCEPT_INCOMING_CALL_BY_AG, 0, 0, NULL); 1655 hfp_ag_response_and_hold_active = true; 1656 hfp_ag_response_and_hold_state = HFP_RESPONSE_AND_HOLD_INCOMING_ON_HOLD; 1657 hfp_ag_send_response_and_hold_state(hfp_ag_response_and_hold_state); 1658 // as with regular call 1659 hfp_ag_set_call_indicator(); 1660 hfp_ag_set_callsetup_indicator(); 1661 hfp_ag_ag_accept_call(); 1662 log_info("AG response and hold - hold by AG"); 1663 break; 1664 default: 1665 break; 1666 } 1667 break; 1668 default: 1669 break; 1670 } 1671 break; 1672 1673 case HFP_AG_RESPONSE_AND_HOLD_ACCEPT_INCOMING_CALL_BY_HF: 1674 switch (hfp_gsm_call_status()){ 1675 case HFP_CALL_STATUS_NO_HELD_OR_ACTIVE_CALLS: 1676 switch (hfp_gsm_callsetup_status()){ 1677 case HFP_CALLSETUP_STATUS_INCOMING_CALL_SETUP_IN_PROGRESS: 1678 hfp_gsm_handler(HFP_AG_RESPONSE_AND_HOLD_ACCEPT_INCOMING_CALL_BY_HF, 0, 0, NULL); 1679 hfp_ag_response_and_hold_active = true; 1680 hfp_ag_response_and_hold_state = HFP_RESPONSE_AND_HOLD_INCOMING_ON_HOLD; 1681 hfp_ag_send_response_and_hold_state(hfp_ag_response_and_hold_state); 1682 // as with regular call 1683 hfp_ag_set_call_indicator(); 1684 hfp_ag_set_callsetup_indicator(); 1685 hfp_ag_hf_accept_call(hfp_connection); 1686 log_info("AG response and hold - hold by HF"); 1687 break; 1688 default: 1689 break; 1690 } 1691 break; 1692 default: 1693 break; 1694 } 1695 break; 1696 1697 case HFP_AG_RESPONSE_AND_HOLD_ACCEPT_HELD_CALL_BY_AG: 1698 case HFP_AG_RESPONSE_AND_HOLD_ACCEPT_HELD_CALL_BY_HF: 1699 if (!hfp_ag_response_and_hold_active) break; 1700 if (hfp_ag_response_and_hold_state != HFP_RESPONSE_AND_HOLD_INCOMING_ON_HOLD) break; 1701 hfp_gsm_handler(HFP_AG_RESPONSE_AND_HOLD_ACCEPT_HELD_CALL_BY_AG, 0, 0, NULL); 1702 hfp_ag_response_and_hold_active = false; 1703 hfp_ag_response_and_hold_state = HFP_RESPONSE_AND_HOLD_HELD_INCOMING_ACCEPTED; 1704 hfp_ag_send_response_and_hold_state(hfp_ag_response_and_hold_state); 1705 log_info("Held Call accepted and active"); 1706 break; 1707 1708 case HFP_AG_RESPONSE_AND_HOLD_REJECT_HELD_CALL_BY_AG: 1709 case HFP_AG_RESPONSE_AND_HOLD_REJECT_HELD_CALL_BY_HF: 1710 if (!hfp_ag_response_and_hold_active) break; 1711 if (hfp_ag_response_and_hold_state != HFP_RESPONSE_AND_HOLD_INCOMING_ON_HOLD) break; 1712 hfp_gsm_handler(HFP_AG_RESPONSE_AND_HOLD_REJECT_HELD_CALL_BY_AG, 0, 0, NULL); 1713 hfp_ag_response_and_hold_active = false; 1714 hfp_ag_response_and_hold_state = HFP_RESPONSE_AND_HOLD_HELD_INCOMING_REJECTED; 1715 hfp_ag_send_response_and_hold_state(hfp_ag_response_and_hold_state); 1716 // from terminate by ag 1717 hfp_ag_set_call_indicator(); 1718 hfp_ag_trigger_terminate_call(); 1719 break; 1720 1721 case HFP_AG_TERMINATE_CALL_BY_HF: 1722 switch (hfp_gsm_call_status()){ 1723 case HFP_CALL_STATUS_NO_HELD_OR_ACTIVE_CALLS: 1724 switch (hfp_gsm_callsetup_status()){ 1725 case HFP_CALLSETUP_STATUS_INCOMING_CALL_SETUP_IN_PROGRESS: 1726 case HFP_CALLSETUP_STATUS_OUTGOING_CALL_SETUP_IN_ALERTING_STATE: 1727 case HFP_CALLSETUP_STATUS_OUTGOING_CALL_SETUP_IN_DIALING_STATE: 1728 hfp_gsm_handler(HFP_AG_TERMINATE_CALL_BY_HF, 0, 0, NULL); 1729 hfp_ag_set_callsetup_indicator(); 1730 hfp_ag_transfer_callsetup_state(); 1731 hfp_ag_trigger_reject_call(); 1732 log_info("HF Rejected Incoming call, AG terminate call"); 1733 break; 1734 default: 1735 break; 1736 } 1737 break; 1738 case HFP_CALL_STATUS_ACTIVE_OR_HELD_CALL_IS_PRESENT: 1739 hfp_gsm_handler(HFP_AG_TERMINATE_CALL_BY_HF, 0, 0, NULL); 1740 hfp_ag_set_callsetup_indicator(); 1741 hfp_ag_set_call_indicator(); 1742 hfp_ag_trigger_terminate_call(); 1743 log_info("AG terminate call"); 1744 break; 1745 default: 1746 break; 1747 } 1748 break; 1749 1750 case HFP_AG_TERMINATE_CALL_BY_AG: 1751 switch (hfp_gsm_call_status()){ 1752 case HFP_CALL_STATUS_NO_HELD_OR_ACTIVE_CALLS: 1753 switch (hfp_gsm_callsetup_status()){ 1754 case HFP_CALLSETUP_STATUS_NO_CALL_SETUP_IN_PROGRESS: 1755 case HFP_CALLSETUP_STATUS_OUTGOING_CALL_SETUP_IN_DIALING_STATE: 1756 case HFP_CALLSETUP_STATUS_OUTGOING_CALL_SETUP_IN_ALERTING_STATE: 1757 case HFP_CALLSETUP_STATUS_INCOMING_CALL_SETUP_IN_PROGRESS: 1758 hfp_gsm_handler(HFP_AG_TERMINATE_CALL_BY_AG, 0, 0, NULL); 1759 hfp_ag_set_callsetup_indicator(); 1760 hfp_ag_trigger_reject_call(); 1761 log_info("AG Rejected Incoming call, AG terminate call"); 1762 break; 1763 default: 1764 break; 1765 } 1766 break; 1767 case HFP_CALL_STATUS_ACTIVE_OR_HELD_CALL_IS_PRESENT: 1768 hfp_gsm_handler(HFP_AG_TERMINATE_CALL_BY_AG, 0, 0, NULL); 1769 hfp_ag_set_callsetup_indicator(); 1770 hfp_ag_set_call_indicator(); 1771 hfp_ag_trigger_terminate_call(); 1772 log_info("AG terminate call"); 1773 break; 1774 default: 1775 break; 1776 } 1777 break; 1778 case HFP_AG_CALL_DROPPED: 1779 switch (hfp_gsm_call_status()){ 1780 case HFP_CALL_STATUS_NO_HELD_OR_ACTIVE_CALLS: 1781 switch (hfp_gsm_callsetup_status()){ 1782 case HFP_CALLSETUP_STATUS_INCOMING_CALL_SETUP_IN_PROGRESS: 1783 case HFP_CALLSETUP_STATUS_OUTGOING_CALL_SETUP_IN_ALERTING_STATE: 1784 hfp_ag_stop_ringing(); 1785 break; 1786 case HFP_CALLSETUP_STATUS_OUTGOING_CALL_SETUP_IN_DIALING_STATE: 1787 log_info("Outgoing call interrupted\n"); 1788 break; 1789 default: 1790 break; 1791 } 1792 hfp_gsm_handler(HFP_AG_CALL_DROPPED, 0, 0, NULL); 1793 hfp_ag_set_callsetup_indicator(); 1794 hfp_ag_transfer_callsetup_state(); 1795 hfp_ag_trigger_terminate_call(); 1796 break; 1797 case HFP_CALL_STATUS_ACTIVE_OR_HELD_CALL_IS_PRESENT: 1798 if (hfp_ag_response_and_hold_active) { 1799 hfp_gsm_handler(HFP_AG_CALL_DROPPED, 0, 0, NULL); 1800 hfp_ag_response_and_hold_state = HFP_RESPONSE_AND_HOLD_HELD_INCOMING_REJECTED; 1801 hfp_ag_send_response_and_hold_state(hfp_ag_response_and_hold_state); 1802 } 1803 hfp_gsm_handler(HFP_AG_CALL_DROPPED, 0, 0, NULL); 1804 hfp_ag_set_callsetup_indicator(); 1805 hfp_ag_set_call_indicator(); 1806 hfp_ag_trigger_terminate_call(); 1807 log_info("AG notify call dropped"); 1808 break; 1809 default: 1810 break; 1811 } 1812 break; 1813 1814 case HFP_AG_OUTGOING_CALL_INITIATED_BY_HF: 1815 // directly reject call if number of free slots is exceeded 1816 if (!hfp_gsm_call_possible()){ 1817 hfp_connection->send_error = 1; 1818 hfp_ag_run_for_context(hfp_connection); 1819 break; 1820 } 1821 1822 // note: number not used currently 1823 hfp_gsm_handler(HFP_AG_OUTGOING_CALL_INITIATED_BY_HF, 0, 0, (const char *) &hfp_connection->line_buffer[3]); 1824 1825 hfp_connection->call_state = HFP_CALL_OUTGOING_INITIATED; 1826 1827 hfp_emit_string_event(hfp_connection, HFP_SUBEVENT_PLACE_CALL_WITH_NUMBER, (const char *) &hfp_connection->line_buffer[3]); 1828 break; 1829 1830 case HFP_AG_OUTGOING_CALL_INITIATED_BY_AG: 1831 // directly reject call if number of free slots is exceeded 1832 if (!hfp_gsm_call_possible()) { 1833 // TODO: no error for user 1834 break; 1835 } 1836 switch (hfp_gsm_call_status()) { 1837 case HFP_CALL_STATUS_NO_HELD_OR_ACTIVE_CALLS: 1838 switch (hfp_gsm_callsetup_status()) { 1839 case HFP_CALLSETUP_STATUS_NO_CALL_SETUP_IN_PROGRESS: 1840 // note: number not used currently 1841 hfp_gsm_handler(HFP_AG_OUTGOING_CALL_INITIATED_BY_AG, 0, 0, "1234567"); 1842 // init call state for all connections 1843 hfp_ag_trigger_outgoing_call(); 1844 // get first one and accept call 1845 hfp_connection = hfp_ag_connection_for_call_state(HFP_CALL_OUTGOING_INITIATED); 1846 if (hfp_connection) { 1847 hfp_ag_handle_outgoing_call_accepted(hfp_connection); 1848 } 1849 break; 1850 default: 1851 // TODO: no error for user 1852 break; 1853 } 1854 break; 1855 default: 1856 // TODO: no error for user 1857 break; 1858 } 1859 break; 1860 case HFP_AG_OUTGOING_REDIAL_INITIATED:{ 1861 // directly reject call if number of free slots is exceeded 1862 if (!hfp_gsm_call_possible()){ 1863 hfp_connection->send_error = 1; 1864 hfp_ag_run_for_context(hfp_connection); 1865 break; 1866 } 1867 1868 hfp_gsm_handler(HFP_AG_OUTGOING_REDIAL_INITIATED, 0, 0, NULL); 1869 hfp_connection->call_state = HFP_CALL_OUTGOING_INITIATED; 1870 1871 log_info("Redial last number"); 1872 char * last_dialed_number = hfp_gsm_last_dialed_number(); 1873 1874 if (strlen(last_dialed_number) > 0){ 1875 log_info("Last number exists: accept call"); 1876 hfp_emit_string_event(hfp_connection, HFP_SUBEVENT_PLACE_CALL_WITH_NUMBER, last_dialed_number); 1877 } else { 1878 log_info("log_infoLast number missing: reject call"); 1879 hfp_ag_handle_reject_outgoing_call(); 1880 } 1881 break; 1882 } 1883 case HFP_AG_OUTGOING_CALL_REJECTED: 1884 hfp_ag_handle_reject_outgoing_call(); 1885 break; 1886 1887 case HFP_AG_OUTGOING_CALL_ACCEPTED:{ 1888 hfp_connection = hfp_ag_connection_for_call_state(HFP_CALL_OUTGOING_INITIATED); 1889 if (!hfp_connection){ 1890 log_info("hfp_ag_call_sm: did not find outgoing hfp_connection in initiated state"); 1891 break; 1892 } 1893 1894 hfp_connection->ok_pending = 1; 1895 hfp_ag_handle_outgoing_call_accepted(hfp_connection); 1896 break; 1897 } 1898 case HFP_AG_OUTGOING_CALL_RINGING: 1899 hfp_connection = hfp_ag_connection_for_call_state(HFP_CALL_OUTGOING_DIALING); 1900 if (!hfp_connection){ 1901 log_info("hfp_ag_call_sm: did not find outgoing hfp_connection in dialing state"); 1902 break; 1903 } 1904 1905 hfp_gsm_handler(HFP_AG_OUTGOING_CALL_RINGING, 0, 0, NULL); 1906 hfp_connection->call_state = HFP_CALL_OUTGOING_RINGING; 1907 hfp_ag_set_callsetup_indicator(); 1908 hfp_ag_transfer_callsetup_state(); 1909 hfp_ag_hf_start_ringing_outgoing(hfp_connection); 1910 break; 1911 1912 case HFP_AG_OUTGOING_CALL_ESTABLISHED:{ 1913 // get outgoing call 1914 hfp_connection = hfp_ag_connection_for_call_state(HFP_CALL_OUTGOING_RINGING); 1915 if (!hfp_connection){ 1916 hfp_connection = hfp_ag_connection_for_call_state(HFP_CALL_OUTGOING_DIALING); 1917 } 1918 if (!hfp_connection){ 1919 log_info("hfp_ag_call_sm: did not find outgoing hfp_connection"); 1920 break; 1921 } 1922 1923 bool callheld_status_call_on_hold_and_no_active_calls = hfp_gsm_callheld_status() == HFP_CALLHELD_STATUS_CALL_ON_HOLD_AND_NO_ACTIVE_CALLS; 1924 hfp_gsm_handler(HFP_AG_OUTGOING_CALL_ESTABLISHED, 0, 0, NULL); 1925 hfp_connection->call_state = HFP_CALL_ACTIVE; 1926 hfp_ag_set_callsetup_indicator(); 1927 hfp_ag_set_call_indicator(); 1928 hfp_ag_transfer_call_state(); 1929 hfp_ag_transfer_callsetup_state(); 1930 if (callheld_status_call_on_hold_and_no_active_calls){ 1931 hfp_ag_set_callheld_indicator(); 1932 hfp_ag_transfer_callheld_state(); 1933 } 1934 hfp_ag_hf_stop_ringing(hfp_connection); 1935 hfp_emit_simple_event(hfp_connection, HFP_SUBEVENT_CALL_ANSWERED); 1936 break; 1937 } 1938 1939 case HFP_AG_CALL_HOLD_USER_BUSY: 1940 hfp_gsm_handler(HFP_AG_CALL_HOLD_USER_BUSY, 0, 0, NULL); 1941 hfp_ag_set_callsetup_indicator(); 1942 hfp_connection->ag_indicators_status_update_bitmap = store_bit(hfp_connection->ag_indicators_status_update_bitmap, callsetup_indicator_index, 1); 1943 hfp_connection->call_state = HFP_CALL_ACTIVE; 1944 log_info("AG: Call Waiting, User Busy"); 1945 break; 1946 1947 case HFP_AG_CALL_HOLD_RELEASE_ACTIVE_ACCEPT_HELD_OR_WAITING_CALL:{ 1948 int call_setup_in_progress = hfp_gsm_callsetup_status() != HFP_CALLSETUP_STATUS_NO_CALL_SETUP_IN_PROGRESS; 1949 int call_held = hfp_gsm_callheld_status() != HFP_CALLHELD_STATUS_NO_CALLS_HELD; 1950 1951 // Releases all active calls (if any exist) and accepts the other (held or waiting) call. 1952 if (call_held || call_setup_in_progress){ 1953 hfp_gsm_handler(HFP_AG_CALL_HOLD_RELEASE_ACTIVE_ACCEPT_HELD_OR_WAITING_CALL, hfp_connection->call_index, 1954 0, NULL); 1955 1956 } 1957 1958 if (call_setup_in_progress){ 1959 log_info("AG: Call Dropped, Accept new call"); 1960 hfp_ag_set_callsetup_indicator(); 1961 hfp_connection->ag_indicators_status_update_bitmap = store_bit(hfp_connection->ag_indicators_status_update_bitmap, callsetup_indicator_index, 1); 1962 } else { 1963 log_info("AG: Call Dropped, Resume held call"); 1964 } 1965 if (call_held){ 1966 hfp_ag_set_callheld_indicator(); 1967 hfp_connection->ag_indicators_status_update_bitmap = store_bit(hfp_connection->ag_indicators_status_update_bitmap, callheld_indicator_index, 1); 1968 } 1969 1970 hfp_connection->call_state = HFP_CALL_ACTIVE; 1971 break; 1972 } 1973 1974 case HFP_AG_CALL_HOLD_PARK_ACTIVE_ACCEPT_HELD_OR_WAITING_CALL:{ 1975 // Places all active calls (if any exist) on hold and accepts the other (held or waiting) call. 1976 // only update if callsetup changed 1977 int call_setup_in_progress = hfp_gsm_callsetup_status() != HFP_CALLSETUP_STATUS_NO_CALL_SETUP_IN_PROGRESS; 1978 hfp_gsm_handler(HFP_AG_CALL_HOLD_PARK_ACTIVE_ACCEPT_HELD_OR_WAITING_CALL, hfp_connection->call_index, 0, 1979 NULL); 1980 1981 if (call_setup_in_progress){ 1982 log_info("AG: Call on Hold, Accept new call"); 1983 hfp_ag_set_callsetup_indicator(); 1984 hfp_connection->ag_indicators_status_update_bitmap = store_bit(hfp_connection->ag_indicators_status_update_bitmap, callsetup_indicator_index, 1); 1985 } else { 1986 log_info("AG: Swap calls"); 1987 } 1988 1989 hfp_ag_set_callheld_indicator(); 1990 // hfp_ag_set_callheld_state(HFP_CALLHELD_STATUS_CALL_ON_HOLD_OR_SWAPPED); 1991 hfp_connection->ag_indicators_status_update_bitmap = store_bit(hfp_connection->ag_indicators_status_update_bitmap, callheld_indicator_index, 1); 1992 hfp_connection->call_state = HFP_CALL_ACTIVE; 1993 break; 1994 } 1995 1996 case HFP_AG_CALL_HOLD_ADD_HELD_CALL: 1997 // Adds a held call to the conversation. 1998 if (hfp_gsm_callheld_status() != HFP_CALLHELD_STATUS_NO_CALLS_HELD){ 1999 log_info("AG: Join 3-way-call"); 2000 hfp_gsm_handler(HFP_AG_CALL_HOLD_ADD_HELD_CALL, 0, 0, NULL); 2001 hfp_ag_set_callheld_indicator(); 2002 hfp_connection->ag_indicators_status_update_bitmap = store_bit(hfp_connection->ag_indicators_status_update_bitmap, callheld_indicator_index, 1); 2003 hfp_emit_simple_event(hfp_connection, HFP_SUBEVENT_CONFERENCE_CALL); 2004 } 2005 hfp_connection->call_state = HFP_CALL_ACTIVE; 2006 break; 2007 case HFP_AG_CALL_HOLD_EXIT_AND_JOIN_CALLS: 2008 // Connects the two calls and disconnects the subscriber from both calls (Explicit Call Transfer) 2009 hfp_gsm_handler(HFP_AG_CALL_HOLD_EXIT_AND_JOIN_CALLS, 0, 0, NULL); 2010 log_info("AG: Transfer call -> Connect two calls and disconnect"); 2011 hfp_ag_set_call_indicator(); 2012 hfp_ag_set_callheld_indicator(); 2013 hfp_connection->ag_indicators_status_update_bitmap = store_bit(hfp_connection->ag_indicators_status_update_bitmap, call_indicator_index, 1); 2014 hfp_connection->ag_indicators_status_update_bitmap = store_bit(hfp_connection->ag_indicators_status_update_bitmap, callheld_indicator_index, 1); 2015 hfp_connection->call_state = HFP_CALL_IDLE; 2016 break; 2017 2018 default: 2019 break; 2020 } 2021 2022 2023 } 2024 2025 2026 static void hfp_ag_send_call_status(hfp_connection_t * hfp_connection, int call_index){ 2027 hfp_gsm_call_t * active_call = hfp_gsm_call(call_index); 2028 if (!active_call) return; 2029 2030 int idx = active_call->index; 2031 hfp_enhanced_call_dir_t dir = active_call->direction; 2032 hfp_enhanced_call_status_t status = active_call->enhanced_status; 2033 hfp_enhanced_call_mode_t mode = active_call->mode; 2034 hfp_enhanced_call_mpty_t mpty = active_call->mpty; 2035 uint8_t type = active_call->clip_type; 2036 char * number = active_call->clip_number; 2037 2038 char buffer[100]; 2039 // TODO: check length of a buffer, to fit the MTU 2040 int offset = snprintf(buffer, sizeof(buffer), "\r\n%s: %d,%d,%d,%d,%d", HFP_LIST_CURRENT_CALLS, idx, dir, status, mode, mpty); 2041 if (number){ 2042 offset += snprintf(buffer+offset, sizeof(buffer)-offset-3, ", \"%s\",%u", number, type); 2043 } 2044 snprintf(buffer+offset, sizeof(buffer)-offset, "\r\n"); 2045 log_info("hfp_ag_send_current_call_status 000 index %d, dir %d, status %d, mode %d, mpty %d, type %d, number %s", idx, dir, status, 2046 mode, mpty, type, number); 2047 send_str_over_rfcomm(hfp_connection->rfcomm_cid, buffer); 2048 } 2049 2050 // sends pending command, returns if command was sent 2051 static int hfp_ag_send_commands(hfp_connection_t *hfp_connection){ 2052 if (hfp_connection->send_status_of_current_calls){ 2053 hfp_connection->ok_pending = 0; 2054 if (hfp_connection->next_call_index < hfp_gsm_get_number_of_calls()){ 2055 hfp_connection->next_call_index++; 2056 hfp_ag_send_call_status(hfp_connection, hfp_connection->next_call_index); 2057 return 1; 2058 } else { 2059 // TODO: this code should be removed. check a) before setting send_status_of_current_calls, or b) right before hfp_ag_send_call_status above 2060 hfp_connection->next_call_index = 0; 2061 hfp_connection->ok_pending = 1; 2062 hfp_connection->send_status_of_current_calls = 0; 2063 } 2064 } 2065 2066 if (hfp_connection->ag_notify_incoming_call_waiting){ 2067 hfp_connection->ag_notify_incoming_call_waiting = 0; 2068 hfp_ag_send_call_waiting_notification(hfp_connection->rfcomm_cid); 2069 return 1; 2070 } 2071 2072 if (hfp_connection->send_error){ 2073 hfp_connection->send_error = 0; 2074 hfp_connection->command = HFP_CMD_NONE; 2075 hfp_ag_send_error(hfp_connection->rfcomm_cid); 2076 return 1; 2077 } 2078 2079 // note: before update AG indicators and ok_pending 2080 if (hfp_connection->send_response_and_hold_status){ 2081 int status = hfp_connection->send_response_and_hold_status - 1; 2082 hfp_connection->send_response_and_hold_status = 0; 2083 hfp_ag_send_set_response_and_hold(hfp_connection->rfcomm_cid, status); 2084 return 1; 2085 } 2086 2087 // note: before ok_pending and send_error to allow for unsolicited result on custom command 2088 if (hfp_connection->send_custom_message != NULL){ 2089 const char * message = hfp_connection->send_custom_message; 2090 hfp_connection->send_custom_message = NULL; 2091 send_str_over_rfcomm(hfp_connection->rfcomm_cid, message); 2092 hfp_emit_event(hfp_connection, HFP_SUBEVENT_COMPLETE, ERROR_CODE_SUCCESS); 2093 return 1; 2094 } 2095 2096 if (hfp_connection->ok_pending){ 2097 hfp_connection->ok_pending = 0; 2098 hfp_connection->command = HFP_CMD_NONE; 2099 hfp_ag_send_ok(hfp_connection->rfcomm_cid); 2100 return 1; 2101 } 2102 2103 // update AG indicators only if enabled by AT+CMER=3,0,0,1 2104 if ((hfp_connection->enable_status_update_for_ag_indicators == 1) && (hfp_connection->ag_indicators_status_update_bitmap != 0)){ 2105 uint16_t i; 2106 for (i=0;i<hfp_connection->ag_indicators_nr;i++){ 2107 if (get_bit(hfp_connection->ag_indicators_status_update_bitmap, i)){ 2108 hfp_connection->ag_indicators_status_update_bitmap = store_bit(hfp_connection->ag_indicators_status_update_bitmap, i, 0); 2109 hfp_ag_send_transfer_ag_indicators_status_cmd(hfp_connection->rfcomm_cid, &hfp_ag_indicators[i]); 2110 return 1; 2111 } 2112 } 2113 } 2114 2115 if (hfp_connection->ag_send_no_carrier){ 2116 hfp_connection->ag_send_no_carrier = false; 2117 hfp_ag_send_no_carrier(hfp_connection->rfcomm_cid); 2118 return 1; 2119 } 2120 2121 if (hfp_connection->send_phone_number_for_voice_tag){ 2122 hfp_connection->send_phone_number_for_voice_tag = 0; 2123 hfp_connection->command = HFP_CMD_NONE; 2124 hfp_connection->ok_pending = 1; 2125 hfp_ag_send_phone_number_for_voice_tag_cmd(hfp_connection->rfcomm_cid); 2126 return 1; 2127 } 2128 2129 if (hfp_connection->send_subscriber_number){ 2130 if (hfp_connection->next_subscriber_number_to_send < hfp_ag_subscriber_numbers_count){ 2131 hfp_phone_number_t phone = hfp_ag_subscriber_numbers[hfp_connection->next_subscriber_number_to_send++]; 2132 hfp_send_subscriber_number_cmd(hfp_connection->rfcomm_cid, phone.type, phone.number); 2133 } else { 2134 hfp_connection->send_subscriber_number = 0; 2135 hfp_connection->next_subscriber_number_to_send = 0; 2136 hfp_ag_send_ok(hfp_connection->rfcomm_cid); 2137 } 2138 hfp_connection->command = HFP_CMD_NONE; 2139 return 1; 2140 } 2141 2142 if (hfp_connection->send_microphone_gain){ 2143 hfp_connection->send_microphone_gain = 0; 2144 hfp_connection->command = HFP_CMD_NONE; 2145 hfp_ag_send_set_microphone_gain_cmd(hfp_connection->rfcomm_cid, hfp_connection->microphone_gain); 2146 return 1; 2147 } 2148 2149 if (hfp_connection->send_speaker_gain){ 2150 hfp_connection->send_speaker_gain = 0; 2151 hfp_connection->command = HFP_CMD_NONE; 2152 hfp_ag_send_set_speaker_gain_cmd(hfp_connection->rfcomm_cid, hfp_connection->speaker_gain); 2153 return 1; 2154 } 2155 2156 if (hfp_connection->send_ag_status_indicators){ 2157 hfp_connection->send_ag_status_indicators = 0; 2158 hfp_ag_send_retrieve_indicators_status_cmd(hfp_connection->rfcomm_cid); 2159 return 1; 2160 } 2161 2162 return 0; 2163 } 2164 2165 // sends pending command, returns if command was sent 2166 static int hfp_ag_run_ring_and_clip(hfp_connection_t *hfp_connection){ 2167 // delay RING/CLIP until audio connection has been established for incoming calls 2168 // hfp_ag_hf_trigger_ring_and_clip is called in call_setup_state_machine 2169 if (hfp_connection->call_state != HFP_CALL_W4_AUDIO_CONNECTION_FOR_IN_BAND_RING){ 2170 if (hfp_connection->ag_ring){ 2171 hfp_connection->ag_ring = 0; 2172 hfp_connection->command = HFP_CMD_NONE; 2173 hfp_emit_simple_event(hfp_connection, HFP_SUBEVENT_RING); 2174 hfp_ag_send_ring(hfp_connection->rfcomm_cid); 2175 return 1; 2176 } 2177 2178 if (hfp_connection->ag_send_clip){ 2179 hfp_connection->ag_send_clip = 0; 2180 hfp_connection->command = HFP_CMD_NONE; 2181 hfp_ag_send_clip(hfp_connection->rfcomm_cid); 2182 return 1; 2183 } 2184 } 2185 return 0; 2186 } 2187 2188 static void hfp_ag_run_for_context(hfp_connection_t *hfp_connection){ 2189 2190 btstack_assert(hfp_connection != NULL); 2191 btstack_assert(hfp_connection->local_role == HFP_ROLE_AG); 2192 2193 // during SDP query, RFCOMM CID is not set 2194 if (hfp_connection->rfcomm_cid == 0) return; 2195 2196 if (hfp_connection->state == HFP_AUDIO_CONNECTION_ESTABLISHED && hfp_connection->emit_vra_enabled_after_audio_established){ 2197 hfp_connection->emit_vra_enabled_after_audio_established = false; 2198 hfp_emit_voice_recognition_enabled(hfp_connection, ERROR_CODE_SUCCESS); 2199 } 2200 2201 if ((hfp_connection->state == HFP_AUDIO_CONNECTION_ESTABLISHED) && hfp_connection->release_audio_connection){ 2202 hfp_connection->state = HFP_W4_SCO_DISCONNECTED; 2203 hfp_connection->release_audio_connection = 0; 2204 gap_disconnect(hfp_connection->sco_handle); 2205 return; 2206 } 2207 2208 // configure NBS/WBS if needed using vendor-specific HCI commands 2209 if (hci_can_send_command_packet_now()) { 2210 #ifdef ENABLE_CC256X_ASSISTED_HFP 2211 // WBS Disassociate 2212 if (hfp_connection->cc256x_send_wbs_disassociate){ 2213 hfp_connection->cc256x_send_wbs_disassociate = false; 2214 hci_send_cmd(&hci_ti_wbs_disassociate); 2215 return; 2216 } 2217 // Write Codec Config 2218 if (hfp_connection->cc256x_send_write_codec_config){ 2219 hfp_connection->cc256x_send_write_codec_config = false; 2220 hfp_cc256x_write_codec_config(hfp_connection); 2221 return; 2222 } 2223 // WBS Associate 2224 if (hfp_connection->cc256x_send_wbs_associate){ 2225 hfp_connection->cc256x_send_wbs_associate = false; 2226 hci_send_cmd(&hci_ti_wbs_associate, hfp_connection->acl_handle); 2227 return; 2228 } 2229 #endif 2230 #ifdef ENABLE_BCM_PCM_WBS 2231 // Enable WBS 2232 if (hfp_connection->bcm_send_enable_wbs){ 2233 hfp_connection->bcm_send_enable_wbs = false; 2234 hci_send_cmd(&hci_bcm_enable_wbs, 1, 2); 2235 return; 2236 } 2237 // Write I2S/PCM params 2238 if (hfp_connection->bcm_send_write_i2spcm_interface_param){ 2239 hfp_connection->bcm_send_write_i2spcm_interface_param = false; 2240 hfp_bcm_write_i2spcm_interface_param(hfp_connection); 2241 return; 2242 } 2243 // Disable WBS 2244 if (hfp_connection->bcm_send_disable_wbs){ 2245 hfp_connection->bcm_send_disable_wbs = false; 2246 hci_send_cmd(&hci_bcm_enable_wbs, 0, 2); 2247 return; 2248 } 2249 #endif 2250 #ifdef ENABLE_RTK_PCM_WBS 2251 // Configure CVSD vs. mSBC 2252 if (hfp_connection->rtk_send_sco_config){ 2253 hfp_connection->rtk_send_sco_config = false; 2254 if (hfp_connection->negotiated_codec == HFP_CODEC_MSBC){ 2255 log_info("RTK SCO: 16k + mSBC"); 2256 hci_send_cmd(&hci_rtk_configure_sco_routing, 0x81, 0x90, 0x00, 0x00, 0x1a, 0x0c, 0x00, 0x00, 0x41); 2257 } else { 2258 log_info("RTK SCO: 16k + CVSD"); 2259 hci_send_cmd(&hci_rtk_configure_sco_routing, 0x81, 0x90, 0x00, 0x00, 0x1a, 0x0c, 0x0c, 0x00, 0x01); 2260 } 2261 return; 2262 } 2263 #endif 2264 } 2265 2266 #if defined (ENABLE_CC256X_ASSISTED_HFP) || defined (ENABLE_BCM_PCM_WBS) 2267 if (hfp_connection->state == HFP_W4_WBS_SHUTDOWN){ 2268 hfp_finalize_connection_context(hfp_connection); 2269 return; 2270 } 2271 #endif 2272 2273 if (!rfcomm_can_send_packet_now(hfp_connection->rfcomm_cid)) { 2274 log_info("hfp_ag_run_for_context: request can send for 0x%02x", hfp_connection->rfcomm_cid); 2275 rfcomm_request_can_send_now_event(hfp_connection->rfcomm_cid); 2276 return; 2277 } 2278 2279 int cmd_sent = hfp_ag_send_commands(hfp_connection); 2280 2281 if (!cmd_sent){ 2282 cmd_sent = hfp_ag_run_for_context_service_level_connection(hfp_connection); 2283 } 2284 2285 if (!cmd_sent){ 2286 cmd_sent = hfp_ag_run_for_context_service_level_connection_queries(hfp_connection); 2287 } 2288 2289 if (!cmd_sent){ 2290 cmd_sent = call_setup_state_machine(hfp_connection); 2291 } 2292 2293 if (!cmd_sent){ 2294 cmd_sent = hfp_ag_run_for_audio_connection(hfp_connection); 2295 } 2296 2297 if (!cmd_sent){ 2298 cmd_sent = hfp_ag_run_ring_and_clip(hfp_connection); 2299 } 2300 2301 if (!cmd_sent){ 2302 cmd_sent = hfp_ag_voice_recognition_state_machine(hfp_connection); 2303 } 2304 2305 // disconnect 2306 if (!cmd_sent && (hfp_connection->command == HFP_CMD_NONE) && (hfp_connection->state == HFP_W2_DISCONNECT_RFCOMM)){ 2307 hfp_connection->state = HFP_W4_RFCOMM_DISCONNECTED; 2308 rfcomm_disconnect(hfp_connection->rfcomm_cid); 2309 } 2310 2311 if (cmd_sent){ 2312 hfp_connection->command = HFP_CMD_NONE; 2313 rfcomm_request_can_send_now_event(hfp_connection->rfcomm_cid); 2314 } 2315 } 2316 2317 static int hfp_parser_is_end_of_line(uint8_t byte){ 2318 return (byte == '\n') || (byte == '\r'); 2319 } 2320 2321 static void hfp_ag_handle_rfcomm_data(hfp_connection_t * hfp_connection, uint8_t *packet, uint16_t size){ 2322 // assertion: size >= 1 as rfcomm.c does not deliver empty packets 2323 if (size < 1) return; 2324 uint8_t status = ERROR_CODE_SUCCESS; 2325 2326 hfp_log_rfcomm_message("HFP_AG_RX", packet, size); 2327 #ifdef ENABLE_HFP_AT_MESSAGES 2328 hfp_emit_string_event(hfp_connection, HFP_SUBEVENT_AT_MESSAGE_RECEIVED, (char *) packet); 2329 #endif 2330 2331 // process messages byte-wise 2332 int pos; 2333 for (pos = 0; pos < size ; pos++){ 2334 hfp_parse(hfp_connection, packet[pos], 0); 2335 2336 // parse until end of line 2337 if (!hfp_parser_is_end_of_line(packet[pos])) continue; 2338 2339 hfp_generic_status_indicator_t * indicator; 2340 switch(hfp_connection->command){ 2341 case HFP_CMD_HF_ACTIVATE_VOICE_RECOGNITION: 2342 hfp_connection->command = HFP_CMD_NONE; 2343 hfp_connection->ag_vra_requested_by_hf = true; 2344 break; 2345 case HFP_CMD_RESPONSE_AND_HOLD_QUERY: 2346 hfp_connection->command = HFP_CMD_NONE; 2347 if (hfp_ag_response_and_hold_active){ 2348 hfp_connection->send_response_and_hold_status = HFP_RESPONSE_AND_HOLD_INCOMING_ON_HOLD + 1; 2349 } 2350 hfp_connection->ok_pending = 1; 2351 break; 2352 case HFP_CMD_RESPONSE_AND_HOLD_COMMAND: 2353 hfp_connection->command = HFP_CMD_NONE; 2354 switch(hfp_connection->ag_response_and_hold_action){ 2355 case HFP_RESPONSE_AND_HOLD_INCOMING_ON_HOLD: 2356 hfp_ag_call_sm(HFP_AG_RESPONSE_AND_HOLD_ACCEPT_INCOMING_CALL_BY_HF, hfp_connection); 2357 break; 2358 case HFP_RESPONSE_AND_HOLD_HELD_INCOMING_ACCEPTED: 2359 hfp_ag_call_sm(HFP_AG_RESPONSE_AND_HOLD_ACCEPT_HELD_CALL_BY_HF, hfp_connection); 2360 break; 2361 case HFP_RESPONSE_AND_HOLD_HELD_INCOMING_REJECTED: 2362 hfp_ag_call_sm(HFP_AG_RESPONSE_AND_HOLD_REJECT_HELD_CALL_BY_HF, hfp_connection); 2363 break; 2364 default: 2365 break; 2366 } 2367 hfp_connection->ok_pending = 1; 2368 break; 2369 case HFP_CMD_HF_INDICATOR_STATUS: 2370 hfp_connection->command = HFP_CMD_NONE; 2371 2372 if (hfp_connection->parser_indicator_index < hfp_ag_generic_status_indicators_nr){ 2373 indicator = &hfp_ag_generic_status_indicators[hfp_connection->parser_indicator_index]; 2374 switch (indicator->uuid){ 2375 case HFP_HF_INDICATOR_UUID_ENHANCED_SAFETY: 2376 if (hfp_connection->parser_indicator_value > 1) { 2377 hfp_connection->send_error = 1; 2378 break; 2379 } 2380 hfp_connection->ok_pending = 1; 2381 hfp_ag_emit_hf_indicator_value(hfp_connection, indicator->uuid, hfp_connection->parser_indicator_value); 2382 break; 2383 case HFP_HF_INDICATOR_UUID_BATTERY_LEVEL: 2384 if (hfp_connection->parser_indicator_value > 100){ 2385 hfp_connection->send_error = 1; 2386 break; 2387 } 2388 hfp_connection->ok_pending = 1; 2389 hfp_ag_emit_hf_indicator_value(hfp_connection, indicator->uuid, hfp_connection->parser_indicator_value); 2390 break; 2391 default: 2392 hfp_connection->send_error = 1; 2393 break; 2394 } 2395 } else { 2396 hfp_connection->send_error = 1; 2397 } 2398 break; 2399 case HFP_CMD_RETRIEVE_AG_INDICATORS_STATUS: 2400 // expected by SLC state machine 2401 if (hfp_connection->state < HFP_SERVICE_LEVEL_CONNECTION_ESTABLISHED) break; 2402 hfp_connection->send_ag_indicators_segment = 0; 2403 hfp_connection->send_ag_status_indicators = 1; 2404 break; 2405 case HFP_CMD_LIST_CURRENT_CALLS: 2406 hfp_connection->command = HFP_CMD_NONE; 2407 hfp_connection->next_call_index = 0; 2408 hfp_connection->send_status_of_current_calls = 1; 2409 break; 2410 case HFP_CMD_GET_SUBSCRIBER_NUMBER_INFORMATION: 2411 hfp_connection->command = HFP_CMD_NONE; 2412 if (hfp_ag_subscriber_numbers_count == 0){ 2413 hfp_ag_send_ok(hfp_connection->rfcomm_cid); 2414 break; 2415 } 2416 hfp_connection->next_subscriber_number_to_send = 0; 2417 hfp_connection->send_subscriber_number = 1; 2418 break; 2419 case HFP_CMD_TRANSMIT_DTMF_CODES: 2420 { 2421 hfp_connection->command = HFP_CMD_NONE; 2422 char buffer[2]; 2423 buffer[0] = (char) hfp_connection->ag_dtmf_code; 2424 buffer[1] = 0; 2425 hfp_emit_string_event(hfp_connection, HFP_SUBEVENT_TRANSMIT_DTMF_CODES, buffer); 2426 break; 2427 } 2428 case HFP_CMD_HF_REQUEST_PHONE_NUMBER: 2429 hfp_connection->command = HFP_CMD_NONE; 2430 hfp_emit_simple_event(hfp_connection, HFP_SUBEVENT_ATTACH_NUMBER_TO_VOICE_TAG); 2431 break; 2432 case HFP_CMD_TURN_OFF_EC_AND_NR: 2433 hfp_connection->command = HFP_CMD_NONE; 2434 2435 if (get_bit(hfp_ag_supported_features, HFP_AGSF_EC_NR_FUNCTION)){ 2436 hfp_connection->ok_pending = 1; 2437 hfp_ag_supported_features = store_bit(hfp_ag_supported_features, HFP_AGSF_EC_NR_FUNCTION, hfp_connection->ag_echo_and_noise_reduction); 2438 status = ERROR_CODE_SUCCESS; 2439 } else { 2440 hfp_connection->send_error = 1; 2441 status = ERROR_CODE_UNSUPPORTED_FEATURE_OR_PARAMETER_VALUE; 2442 } 2443 hfp_emit_event(hfp_connection, HFP_SUBEVENT_ECHO_CANCELING_AND_NOISE_REDUCTION_DEACTIVATE, status); 2444 break; 2445 case HFP_CMD_CALL_ANSWERED: 2446 hfp_connection->command = HFP_CMD_NONE; 2447 log_info("HFP: ATA"); 2448 hfp_ag_call_sm(HFP_AG_INCOMING_CALL_ACCEPTED_BY_HF, hfp_connection); 2449 break; 2450 case HFP_CMD_HANG_UP_CALL: 2451 hfp_connection->command = HFP_CMD_NONE; 2452 hfp_connection->ok_pending = 1; 2453 hfp_ag_call_sm(HFP_AG_TERMINATE_CALL_BY_HF, hfp_connection); 2454 break; 2455 case HFP_CMD_CALL_HOLD: { 2456 hfp_connection->command = HFP_CMD_NONE; 2457 hfp_connection->ok_pending = 1; 2458 2459 switch (hfp_connection->ag_call_hold_action){ 2460 case 0: 2461 // Releases all held calls or sets User Determined User Busy (UDUB) for a waiting call. 2462 hfp_ag_call_sm(HFP_AG_CALL_HOLD_USER_BUSY, hfp_connection); 2463 break; 2464 case 1: 2465 // Releases all active calls (if any exist) and accepts the other (held or waiting) call. 2466 // Where both a held and a waiting call exist, the above procedures shall apply to the 2467 // waiting call (i.e., not to the held call) in conflicting situation. 2468 hfp_ag_call_sm(HFP_AG_CALL_HOLD_RELEASE_ACTIVE_ACCEPT_HELD_OR_WAITING_CALL, hfp_connection); 2469 break; 2470 case 2: 2471 // Places all active calls (if any exist) on hold and accepts the other (held or waiting) call. 2472 // Where both a held and a waiting call exist, the above procedures shall apply to the 2473 // waiting call (i.e., not to the held call) in conflicting situation. 2474 hfp_ag_call_sm(HFP_AG_CALL_HOLD_PARK_ACTIVE_ACCEPT_HELD_OR_WAITING_CALL, hfp_connection); 2475 break; 2476 case 3: 2477 // Adds a held call to the conversation. 2478 hfp_ag_call_sm(HFP_AG_CALL_HOLD_ADD_HELD_CALL, hfp_connection); 2479 break; 2480 case 4: 2481 // Connects the two calls and disconnects the subscriber from both calls (Explicit Call Transfer). 2482 hfp_ag_call_sm(HFP_AG_CALL_HOLD_EXIT_AND_JOIN_CALLS, hfp_connection); 2483 break; 2484 default: 2485 break; 2486 } 2487 hfp_connection->call_index = 0; 2488 break; 2489 } 2490 case HFP_CMD_CALL_PHONE_NUMBER: 2491 hfp_connection->command = HFP_CMD_NONE; 2492 hfp_ag_call_sm(HFP_AG_OUTGOING_CALL_INITIATED_BY_HF, hfp_connection); 2493 break; 2494 case HFP_CMD_REDIAL_LAST_NUMBER: 2495 hfp_connection->command = HFP_CMD_NONE; 2496 hfp_ag_call_sm(HFP_AG_OUTGOING_REDIAL_INITIATED, hfp_connection); 2497 break; 2498 case HFP_CMD_ENABLE_CLIP: 2499 hfp_connection->command = HFP_CMD_NONE; 2500 log_info("hfp: clip set, now: %u", hfp_connection->clip_enabled); 2501 hfp_connection->ok_pending = 1; 2502 break; 2503 case HFP_CMD_ENABLE_CALL_WAITING_NOTIFICATION: 2504 hfp_connection->command = HFP_CMD_NONE; 2505 log_info("hfp: call waiting notification set, now: %u", hfp_connection->call_waiting_notification_enabled); 2506 hfp_connection->ok_pending = 1; 2507 break; 2508 case HFP_CMD_SET_SPEAKER_GAIN: 2509 hfp_connection->command = HFP_CMD_NONE; 2510 hfp_connection->ok_pending = 1; 2511 log_info("HF speaker gain = %u", hfp_connection->speaker_gain); 2512 hfp_emit_event(hfp_connection, HFP_SUBEVENT_SPEAKER_VOLUME, hfp_connection->speaker_gain); 2513 break; 2514 case HFP_CMD_SET_MICROPHONE_GAIN: 2515 hfp_connection->command = HFP_CMD_NONE; 2516 hfp_connection->ok_pending = 1; 2517 log_info("HF microphone gain = %u", hfp_connection->microphone_gain); 2518 hfp_emit_event(hfp_connection, HFP_SUBEVENT_MICROPHONE_VOLUME, hfp_connection->microphone_gain); 2519 break; 2520 case HFP_CMD_CUSTOM_MESSAGE: 2521 hfp_connection->command = HFP_CMD_NONE; 2522 hfp_parser_reset_line_buffer(hfp_connection); 2523 log_info("Custom AT Command ID 0x%04x", hfp_connection->ag_custom_at_command_id); 2524 hfp_ag_emit_custom_command_event(hfp_connection); 2525 break; 2526 case HFP_CMD_UNKNOWN: 2527 hfp_connection->command = HFP_CMD_NONE; 2528 hfp_connection->send_error = 1; 2529 break; 2530 default: 2531 break; 2532 } 2533 } 2534 } 2535 2536 static void hfp_ag_run(void){ 2537 btstack_linked_list_iterator_t it; 2538 btstack_linked_list_iterator_init(&it, hfp_get_connections()); 2539 while (btstack_linked_list_iterator_has_next(&it)){ 2540 hfp_connection_t * hfp_connection = (hfp_connection_t *)btstack_linked_list_iterator_next(&it); 2541 if (hfp_connection->local_role != HFP_ROLE_AG) continue; 2542 hfp_ag_run_for_context(hfp_connection); 2543 } 2544 } 2545 2546 static void hfp_ag_rfcomm_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){ 2547 hfp_connection_t * hfp_connection = NULL; 2548 switch (packet_type){ 2549 case RFCOMM_DATA_PACKET: 2550 hfp_connection = get_hfp_connection_context_for_rfcomm_cid(channel); 2551 btstack_assert(hfp_connection != NULL); 2552 2553 hfp_ag_handle_rfcomm_data(hfp_connection, packet, size); 2554 hfp_ag_run_for_context(hfp_connection); 2555 return; 2556 case HCI_EVENT_PACKET: 2557 if (packet[0] == RFCOMM_EVENT_CAN_SEND_NOW){ 2558 uint16_t rfcomm_cid = rfcomm_event_can_send_now_get_rfcomm_cid(packet); 2559 hfp_connection = get_hfp_connection_context_for_rfcomm_cid(rfcomm_cid); 2560 btstack_assert(hfp_connection != NULL); 2561 2562 hfp_ag_run_for_context(hfp_connection); 2563 return; 2564 } 2565 hfp_handle_rfcomm_event(packet_type, channel, packet, size, HFP_ROLE_AG); 2566 break; 2567 default: 2568 break; 2569 } 2570 2571 hfp_ag_run(); 2572 } 2573 2574 static void hfp_ag_hci_event_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){ 2575 hfp_handle_hci_event(packet_type, channel, packet, size, HFP_ROLE_AG); 2576 hfp_ag_run(); 2577 } 2578 2579 void hfp_ag_init_codecs(int codecs_nr, const uint8_t * codecs){ 2580 if (codecs_nr > HFP_MAX_NUM_CODECS){ 2581 log_error("hfp_init: codecs_nr (%d) > HFP_MAX_NUM_CODECS (%d)", codecs_nr, HFP_MAX_NUM_CODECS); 2582 return; 2583 } 2584 int i; 2585 hfp_ag_codecs_nr = codecs_nr; 2586 for (i=0; i < codecs_nr; i++){ 2587 hfp_ag_codecs[i] = codecs[i]; 2588 } 2589 } 2590 2591 void hfp_ag_init_supported_features(uint32_t supported_features){ 2592 hfp_ag_supported_features = supported_features; 2593 } 2594 2595 void hfp_ag_init_ag_indicators(int ag_indicators_nr, const hfp_ag_indicator_t * ag_indicators){ 2596 hfp_ag_indicators_nr = ag_indicators_nr; 2597 (void)memcpy(hfp_ag_indicators, ag_indicators, 2598 ag_indicators_nr * sizeof(hfp_ag_indicator_t)); 2599 } 2600 2601 void hfp_ag_init_hf_indicators(int hf_indicators_nr, const hfp_generic_status_indicator_t * hf_indicators){ 2602 if (hf_indicators_nr > HFP_MAX_NUM_INDICATORS) return; 2603 hfp_ag_generic_status_indicators_nr = hf_indicators_nr; 2604 (void)memcpy(hfp_ag_generic_status_indicators, hf_indicators, 2605 hf_indicators_nr * sizeof(hfp_generic_status_indicator_t)); 2606 } 2607 2608 void hfp_ag_init_call_hold_services(int call_hold_services_nr, const char * call_hold_services[]){ 2609 hfp_ag_call_hold_services_nr = call_hold_services_nr; 2610 (void)memcpy(hfp_ag_call_hold_services, call_hold_services, 2611 call_hold_services_nr * sizeof(char *)); 2612 } 2613 2614 2615 void hfp_ag_init(uint8_t rfcomm_channel_nr){ 2616 2617 hfp_init(); 2618 hfp_ag_call_hold_services_nr = 0; 2619 hfp_ag_response_and_hold_active = false; 2620 hfp_ag_indicators_nr = 0; 2621 hfp_ag_codecs_nr = 0; 2622 hfp_ag_supported_features = HFP_DEFAULT_AG_SUPPORTED_FEATURES; 2623 hfp_ag_subscriber_numbers = NULL; 2624 hfp_ag_subscriber_numbers_count = 0; 2625 2626 hfp_ag_hci_event_callback_registration.callback = &hfp_ag_hci_event_packet_handler; 2627 hci_add_event_handler(&hfp_ag_hci_event_callback_registration); 2628 2629 rfcomm_register_service(&hfp_ag_rfcomm_packet_handler, rfcomm_channel_nr, 0xffff); 2630 2631 // used to set packet handler for outgoing rfcomm connections - could be handled by emitting an event to us 2632 hfp_set_ag_rfcomm_packet_handler(&hfp_ag_rfcomm_packet_handler); 2633 2634 hfp_gsm_init(); 2635 } 2636 2637 void hfp_ag_deinit(void){ 2638 hfp_deinit(); 2639 hfp_gsm_deinit(); 2640 2641 hfp_ag_callback = NULL; 2642 hfp_ag_supported_features = 0; 2643 hfp_ag_codecs_nr = 0; 2644 hfp_ag_indicators_nr = 0; 2645 hfp_ag_call_hold_services_nr = 0; 2646 (void) memset(&hfp_ag_call_hold_services, 0, sizeof(hfp_ag_call_hold_services)); 2647 hfp_ag_response_and_hold_state = HFP_RESPONSE_AND_HOLD_INCOMING_ON_HOLD; 2648 (void) memset(&hfp_ag_response_and_hold_state, 0, sizeof(hfp_response_and_hold_state_t)); 2649 hfp_ag_subscriber_numbers = NULL; 2650 (void) memset(&hfp_ag_hci_event_callback_registration, 0, sizeof(btstack_packet_callback_registration_t)); 2651 hfp_ag_custom_call_sm_handler = NULL; 2652 } 2653 2654 uint8_t hfp_ag_establish_service_level_connection(bd_addr_t bd_addr){ 2655 return hfp_establish_service_level_connection(bd_addr, BLUETOOTH_SERVICE_CLASS_HANDSFREE, HFP_ROLE_AG); 2656 } 2657 2658 uint8_t hfp_ag_release_service_level_connection(hci_con_handle_t acl_handle){ 2659 hfp_connection_t * hfp_connection = get_hfp_ag_connection_context_for_acl_handle(acl_handle); 2660 if (!hfp_connection){ 2661 return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER; 2662 } 2663 2664 hfp_trigger_release_service_level_connection(hfp_connection); 2665 hfp_ag_run_for_context(hfp_connection); 2666 return ERROR_CODE_SUCCESS; 2667 } 2668 2669 uint8_t hfp_ag_report_extended_audio_gateway_error_result_code(hci_con_handle_t acl_handle, hfp_cme_error_t error){ 2670 hfp_connection_t * hfp_connection = get_hfp_ag_connection_context_for_acl_handle(acl_handle); 2671 if (!hfp_connection){ 2672 return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER; 2673 } 2674 2675 hfp_connection->extended_audio_gateway_error = 0; 2676 if (!hfp_connection->enable_extended_audio_gateway_error_report){ 2677 return ERROR_CODE_COMMAND_DISALLOWED; 2678 } 2679 2680 hfp_connection->extended_audio_gateway_error = error; 2681 hfp_ag_run_for_context(hfp_connection); 2682 return ERROR_CODE_SUCCESS; 2683 } 2684 2685 static uint8_t hfp_ag_setup_audio_connection(hfp_connection_t * hfp_connection){ 2686 if (hfp_connection->state == HFP_AUDIO_CONNECTION_ESTABLISHED){ 2687 return ERROR_CODE_COMMAND_DISALLOWED; 2688 } 2689 if (hfp_connection->state >= HFP_W2_DISCONNECT_SCO){ 2690 return ERROR_CODE_COMMAND_DISALLOWED; 2691 } 2692 2693 hfp_connection->establish_audio_connection = 1; 2694 if (!has_codec_negotiation_feature(hfp_connection)){ 2695 log_info("hfp_ag_establish_audio_connection - no codec negotiation feature, using CVSD"); 2696 hfp_connection->negotiated_codec = HFP_CODEC_CVSD; 2697 hfp_connection->codecs_state = HFP_CODECS_EXCHANGED; 2698 // now, pick link settings 2699 hfp_init_link_settings(hfp_connection, hfp_ag_esco_s4_supported(hfp_connection)); 2700 #ifdef ENABLE_CC256X_ASSISTED_HFP 2701 hfp_cc256x_prepare_for_sco(hfp_connection); 2702 #endif 2703 return ERROR_CODE_SUCCESS; 2704 } 2705 2706 uint8_t i; 2707 bool codec_was_in_use = false; 2708 bool better_codec_can_be_used = false; 2709 2710 for (i = 0; i<hfp_connection->remote_codecs_nr; i++){ 2711 if (hfp_connection->negotiated_codec == hfp_connection->remote_codecs[i]){ 2712 codec_was_in_use = true; 2713 } else if (hfp_connection->negotiated_codec < hfp_connection->remote_codecs[i]){ 2714 better_codec_can_be_used = true; 2715 } 2716 } 2717 2718 if (!codec_was_in_use || better_codec_can_be_used){ 2719 hfp_connection->ag_send_common_codec = true; 2720 hfp_connection->codecs_state = HFP_CODECS_IDLE; 2721 } 2722 return ERROR_CODE_SUCCESS; 2723 } 2724 2725 uint8_t hfp_ag_establish_audio_connection(hci_con_handle_t acl_handle){ 2726 hfp_connection_t * hfp_connection = get_hfp_ag_connection_context_for_acl_handle(acl_handle); 2727 if (!hfp_connection){ 2728 return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER; 2729 } 2730 uint8_t status = hfp_ag_setup_audio_connection(hfp_connection); 2731 if (status != ERROR_CODE_SUCCESS){ 2732 return status; 2733 } 2734 hfp_ag_run_for_context(hfp_connection); 2735 return ERROR_CODE_SUCCESS; 2736 } 2737 2738 uint8_t hfp_ag_release_audio_connection(hci_con_handle_t acl_handle){ 2739 hfp_connection_t * hfp_connection = get_hfp_ag_connection_context_for_acl_handle(acl_handle); 2740 if (!hfp_connection){ 2741 return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER; 2742 } 2743 2744 if (hfp_connection->vra_state == HFP_VRA_VOICE_RECOGNITION_ACTIVATED){ 2745 return ERROR_CODE_COMMAND_DISALLOWED; 2746 } 2747 2748 uint8_t status = hfp_trigger_release_audio_connection(hfp_connection); 2749 if (status == ERROR_CODE_SUCCESS){ 2750 hfp_ag_run_for_context(hfp_connection); 2751 } 2752 return status; 2753 } 2754 2755 /** 2756 * @brief Enable in-band ring tone 2757 */ 2758 void hfp_ag_set_use_in_band_ring_tone(int use_in_band_ring_tone){ 2759 if (get_bit(hfp_ag_supported_features, HFP_AGSF_IN_BAND_RING_TONE) == use_in_band_ring_tone){ 2760 return; 2761 } 2762 2763 hfp_ag_supported_features = store_bit(hfp_ag_supported_features, HFP_AGSF_IN_BAND_RING_TONE, use_in_band_ring_tone); 2764 2765 btstack_linked_list_iterator_t it; 2766 btstack_linked_list_iterator_init(&it, hfp_get_connections()); 2767 while (btstack_linked_list_iterator_has_next(&it)){ 2768 hfp_connection_t * hfp_connection = (hfp_connection_t *)btstack_linked_list_iterator_next(&it); 2769 if (hfp_connection->local_role != HFP_ROLE_AG) continue; 2770 hfp_connection->ag_send_in_band_ring_tone_setting = true; 2771 hfp_ag_run_for_context(hfp_connection); 2772 } 2773 } 2774 2775 /** 2776 * @brief Called from GSM 2777 */ 2778 void hfp_ag_incoming_call(void){ 2779 hfp_ag_call_sm(HFP_AG_INCOMING_CALL, NULL); 2780 } 2781 2782 void hfp_ag_outgoing_call_initiated(void) { 2783 hfp_ag_call_sm(HFP_AG_OUTGOING_CALL_INITIATED_BY_AG, NULL); 2784 } 2785 2786 /** 2787 * @brief number is stored. 2788 */ 2789 void hfp_ag_set_clip(uint8_t type, const char * number){ 2790 hfp_gsm_handler(HFP_AG_SET_CLIP, 0, type, number); 2791 } 2792 2793 void hfp_ag_call_dropped(void){ 2794 hfp_ag_call_sm(HFP_AG_CALL_DROPPED, NULL); 2795 } 2796 2797 // call from AG UI 2798 void hfp_ag_answer_incoming_call(void){ 2799 hfp_ag_call_sm(HFP_AG_INCOMING_CALL_ACCEPTED_BY_AG, NULL); 2800 } 2801 2802 void hfp_ag_join_held_call(void){ 2803 hfp_ag_call_sm(HFP_AG_HELD_CALL_JOINED_BY_AG, NULL); 2804 } 2805 2806 void hfp_ag_terminate_call(void){ 2807 hfp_ag_call_sm(HFP_AG_TERMINATE_CALL_BY_AG, NULL); 2808 } 2809 2810 void hfp_ag_outgoing_call_ringing(void){ 2811 hfp_ag_call_sm(HFP_AG_OUTGOING_CALL_RINGING, NULL); 2812 } 2813 2814 void hfp_ag_outgoing_call_established(void){ 2815 hfp_ag_call_sm(HFP_AG_OUTGOING_CALL_ESTABLISHED, NULL); 2816 } 2817 2818 void hfp_ag_outgoing_call_rejected(void){ 2819 hfp_ag_call_sm(HFP_AG_OUTGOING_CALL_REJECTED, NULL); 2820 } 2821 2822 void hfp_ag_outgoing_call_accepted(void){ 2823 hfp_ag_call_sm(HFP_AG_OUTGOING_CALL_ACCEPTED, NULL); 2824 } 2825 2826 void hfp_ag_hold_incoming_call(void){ 2827 hfp_ag_call_sm(HFP_AG_RESPONSE_AND_HOLD_ACCEPT_INCOMING_CALL_BY_AG, NULL); 2828 } 2829 2830 void hfp_ag_accept_held_incoming_call(void) { 2831 hfp_ag_call_sm(HFP_AG_RESPONSE_AND_HOLD_ACCEPT_HELD_CALL_BY_AG, NULL); 2832 } 2833 2834 void hfp_ag_reject_held_incoming_call(void){ 2835 hfp_ag_call_sm(HFP_AG_RESPONSE_AND_HOLD_REJECT_HELD_CALL_BY_AG, NULL); 2836 } 2837 2838 static void hfp_ag_set_ag_indicator(const char * name, int value){ 2839 int indicator_index = get_ag_indicator_index_for_name(name); 2840 if (indicator_index < 0) return; 2841 hfp_ag_indicators[indicator_index].status = value; 2842 2843 btstack_linked_list_iterator_t it; 2844 btstack_linked_list_iterator_init(&it, hfp_get_connections()); 2845 while (btstack_linked_list_iterator_has_next(&it)){ 2846 hfp_connection_t * hfp_connection = (hfp_connection_t *)btstack_linked_list_iterator_next(&it); 2847 if (hfp_connection->local_role != HFP_ROLE_AG) continue; 2848 if (!hfp_connection->ag_indicators[indicator_index].enabled) { 2849 log_info("Requested AG indicator '%s' update to %u, but it is not enabled", hfp_ag_indicators[indicator_index].name, value); 2850 continue; 2851 } 2852 log_info("AG indicator '%s' changed to %u, request transfer status", hfp_ag_indicators[indicator_index].name, value); 2853 hfp_connection->ag_indicators_status_update_bitmap = store_bit(hfp_connection->ag_indicators_status_update_bitmap, indicator_index, 1); 2854 hfp_ag_run_for_context(hfp_connection); 2855 } 2856 } 2857 2858 uint8_t hfp_ag_set_registration_status(int registration_status){ 2859 if ((registration_status < 0) || (registration_status > 1)){ 2860 return ERROR_CODE_COMMAND_DISALLOWED; 2861 } 2862 2863 if ( (registration_status == 0) && (hfp_gsm_call_status() == HFP_CALL_STATUS_ACTIVE_OR_HELD_CALL_IS_PRESENT)){ 2864 2865 // if network goes away wihle a call is active: 2866 // - the call gets dropped 2867 // - we send NO CARRIER 2868 // NOTE: the CALL=0 has to be sent before NO CARRIER 2869 2870 hfp_ag_call_sm(HFP_AG_CALL_DROPPED, NULL); 2871 2872 btstack_linked_list_iterator_t it; 2873 btstack_linked_list_iterator_init(&it, hfp_get_connections()); 2874 while (btstack_linked_list_iterator_has_next(&it)){ 2875 hfp_connection_t * hfp_connection = (hfp_connection_t *)btstack_linked_list_iterator_next(&it); 2876 hfp_connection->ag_send_no_carrier = true; 2877 } 2878 } 2879 hfp_ag_set_ag_indicator("service", registration_status); 2880 return ERROR_CODE_SUCCESS; 2881 } 2882 2883 uint8_t hfp_ag_set_signal_strength(int signal_strength){ 2884 if ((signal_strength < 0) || (signal_strength > 5)){ 2885 return ERROR_CODE_COMMAND_DISALLOWED; 2886 } 2887 2888 hfp_ag_set_ag_indicator("signal", signal_strength); 2889 return ERROR_CODE_SUCCESS; 2890 } 2891 2892 uint8_t hfp_ag_set_roaming_status(int roaming_status){ 2893 if ((roaming_status < 0) || (roaming_status > 1)){ 2894 return ERROR_CODE_COMMAND_DISALLOWED; 2895 } 2896 2897 hfp_ag_set_ag_indicator("roam", roaming_status); 2898 return ERROR_CODE_SUCCESS; 2899 } 2900 2901 uint8_t hfp_ag_set_battery_level(int battery_level){ 2902 if ((battery_level < 0) || (battery_level > 5)){ 2903 return ERROR_CODE_COMMAND_DISALLOWED; 2904 } 2905 hfp_ag_set_ag_indicator("battchg", battery_level); 2906 return ERROR_CODE_SUCCESS; 2907 } 2908 2909 uint8_t hfp_ag_activate_voice_recognition(hci_con_handle_t acl_handle){ 2910 hfp_connection_t * hfp_connection = get_hfp_ag_connection_context_for_acl_handle(acl_handle); 2911 if (!hfp_connection){ 2912 return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER; 2913 } 2914 2915 if (hfp_connection->emit_vra_enabled_after_audio_established){ 2916 return ERROR_CODE_COMMAND_DISALLOWED; 2917 } 2918 2919 bool enhanced_vra_supported = hfp_ag_enhanced_vra_flag_supported(hfp_connection); 2920 bool legacy_vra_supported = hfp_ag_vra_flag_supported(hfp_connection); 2921 if (!enhanced_vra_supported && !legacy_vra_supported){ 2922 return ERROR_CODE_UNSUPPORTED_FEATURE_OR_PARAMETER_VALUE; 2923 } 2924 2925 if (!hfp_ag_can_activate_voice_recognition(hfp_connection)){ 2926 return ERROR_CODE_COMMAND_DISALLOWED; 2927 } 2928 2929 hfp_connection->ag_activate_voice_recognition_value = 1; 2930 hfp_connection->vra_state_requested = HFP_VRA_W2_SEND_VOICE_RECOGNITION_ACTIVATED; 2931 hfp_connection->enhanced_voice_recognition_enabled = enhanced_vra_supported; 2932 hfp_connection->ag_audio_connection_opened_before_vra = hfp_ag_is_audio_connection_active(hfp_connection); 2933 hfp_connection->ag_vra_state = HFP_VOICE_RECOGNITION_STATE_AG_READY; 2934 hfp_connection->ag_vra_send_command = true; 2935 hfp_ag_run_for_context(hfp_connection); 2936 return ERROR_CODE_SUCCESS; 2937 } 2938 2939 uint8_t hfp_ag_deactivate_voice_recognition(hci_con_handle_t acl_handle){ 2940 hfp_connection_t * hfp_connection = get_hfp_ag_connection_context_for_acl_handle(acl_handle); 2941 if (!hfp_connection){ 2942 return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER; 2943 } 2944 2945 if (hfp_connection->emit_vra_enabled_after_audio_established){ 2946 return ERROR_CODE_COMMAND_DISALLOWED; 2947 } 2948 2949 bool enhanced_vra_supported = hfp_ag_enhanced_vra_flag_supported(hfp_connection); 2950 bool legacy_vra_supported = hfp_ag_vra_flag_supported(hfp_connection); 2951 2952 if (!enhanced_vra_supported && !legacy_vra_supported){ 2953 return ERROR_CODE_UNSUPPORTED_FEATURE_OR_PARAMETER_VALUE; 2954 } 2955 2956 if (!hfp_ag_voice_recognition_session_active(hfp_connection)){ 2957 return ERROR_CODE_COMMAND_DISALLOWED; 2958 } 2959 2960 hfp_connection->ag_activate_voice_recognition_value = 0; 2961 hfp_connection->vra_state_requested = HFP_VRA_W2_SEND_VOICE_RECOGNITION_OFF; 2962 hfp_connection->ag_vra_state = HFP_VOICE_RECOGNITION_STATE_AG_READY; 2963 hfp_connection->ag_vra_send_command = true; 2964 hfp_ag_run_for_context(hfp_connection); 2965 return ERROR_CODE_SUCCESS; 2966 } 2967 2968 static uint8_t hfp_ag_enhanced_voice_recognition_send_state(hci_con_handle_t acl_handle, hfp_voice_recognition_state_t state){ 2969 hfp_connection_t * hfp_connection = get_hfp_ag_connection_context_for_acl_handle(acl_handle); 2970 if (!hfp_connection){ 2971 return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER; 2972 } 2973 2974 if (hfp_connection->emit_vra_enabled_after_audio_established){ 2975 return ERROR_CODE_COMMAND_DISALLOWED; 2976 } 2977 2978 if (hfp_connection->state != HFP_AUDIO_CONNECTION_ESTABLISHED){ 2979 return ERROR_CODE_COMMAND_DISALLOWED; 2980 } 2981 2982 if (hfp_connection->vra_state != HFP_VRA_ENHANCED_VOICE_RECOGNITION_READY_FOR_AUDIO){ 2983 return ERROR_CODE_COMMAND_DISALLOWED; 2984 } 2985 2986 bool enhanced_vra_supported = hfp_ag_enhanced_vra_flag_supported(hfp_connection); 2987 if (!enhanced_vra_supported ){ 2988 return ERROR_CODE_UNSUPPORTED_FEATURE_OR_PARAMETER_VALUE; 2989 } 2990 2991 2992 hfp_connection->ag_vra_state = state; 2993 hfp_connection->vra_state_requested = HFP_VRA_W2_SEND_ENHANCED_VOICE_RECOGNITION_STATUS; 2994 hfp_connection->ag_vra_send_command = true; 2995 hfp_ag_run_for_context(hfp_connection); 2996 return ERROR_CODE_SUCCESS; 2997 } 2998 2999 uint8_t hfp_ag_enhanced_voice_recognition_report_sending_audio(hci_con_handle_t acl_handle){ 3000 return hfp_ag_enhanced_voice_recognition_send_state(acl_handle, HFP_VOICE_RECOGNITION_STATE_AG_IS_STARTING_SOUND); 3001 } 3002 uint8_t hfp_ag_enhanced_voice_recognition_report_ready_for_audio(hci_con_handle_t acl_handle){ 3003 return hfp_ag_enhanced_voice_recognition_send_state(acl_handle, HFP_VOICE_RECOGNITION_STATE_AG_READY_TO_ACCEPT_AUDIO_INPUT); 3004 } 3005 uint8_t hfp_ag_enhanced_voice_recognition_report_processing_input(hci_con_handle_t acl_handle){ 3006 return hfp_ag_enhanced_voice_recognition_send_state(acl_handle, HFP_VOICE_RECOGNITION_STATE_AG_IS_PROCESSING_AUDIO_INPUT); 3007 } 3008 3009 3010 uint8_t hfp_ag_enhanced_voice_recognition_send_message(hci_con_handle_t acl_handle, hfp_voice_recognition_state_t state, hfp_voice_recognition_message_t msg){ 3011 hfp_connection_t * hfp_connection = get_hfp_ag_connection_context_for_acl_handle(acl_handle); 3012 if (!hfp_connection){ 3013 return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER; 3014 } 3015 3016 if (hfp_connection->emit_vra_enabled_after_audio_established){ 3017 return ERROR_CODE_COMMAND_DISALLOWED; 3018 } 3019 3020 if (hfp_connection->state != HFP_AUDIO_CONNECTION_ESTABLISHED){ 3021 return ERROR_CODE_COMMAND_DISALLOWED; 3022 } 3023 3024 if (hfp_connection->vra_state != HFP_VRA_ENHANCED_VOICE_RECOGNITION_READY_FOR_AUDIO){ 3025 return ERROR_CODE_COMMAND_DISALLOWED; 3026 } 3027 3028 bool enhanced_vra_supported = hfp_ag_enhanced_vra_flag_supported(hfp_connection); 3029 if (!enhanced_vra_supported ){ 3030 return ERROR_CODE_UNSUPPORTED_FEATURE_OR_PARAMETER_VALUE; 3031 } 3032 3033 bool enhanced_vra_msg_supported = hfp_ag_can_send_enhanced_vra_message_flag_supported(hfp_connection); 3034 if (!enhanced_vra_msg_supported ){ 3035 return ERROR_CODE_UNSUPPORTED_FEATURE_OR_PARAMETER_VALUE; 3036 } 3037 3038 uint16_t message_len = (uint16_t) strlen(msg.text); 3039 3040 if (message_len > HFP_MAX_VR_TEXT_SIZE){ 3041 return ERROR_CODE_UNSUPPORTED_FEATURE_OR_PARAMETER_VALUE; 3042 } 3043 3044 if ((HFP_VR_TEXT_HEADER_SIZE + message_len) > hfp_connection->rfcomm_mtu){ 3045 return ERROR_CODE_UNSUPPORTED_FEATURE_OR_PARAMETER_VALUE; 3046 } 3047 3048 hfp_connection->vra_state_requested = HFP_VRA_W2_SEND_ENHANCED_VOICE_RECOGNITION_MSG; 3049 hfp_connection->ag_msg = msg; 3050 hfp_connection->ag_vra_state = state; 3051 hfp_connection->ag_vra_send_command = true; 3052 hfp_ag_run_for_context(hfp_connection); 3053 3054 return ERROR_CODE_SUCCESS; 3055 } 3056 3057 3058 uint8_t hfp_ag_set_microphone_gain(hci_con_handle_t acl_handle, int gain){ 3059 hfp_connection_t * hfp_connection = get_hfp_ag_connection_context_for_acl_handle(acl_handle); 3060 if (!hfp_connection){ 3061 return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER; 3062 } 3063 3064 if ((gain < 0) || (gain > 15)){ 3065 log_info("Valid range for a gain is [0..15]. Currently sent: %d", gain); 3066 return ERROR_CODE_COMMAND_DISALLOWED; 3067 } 3068 3069 if (hfp_connection->microphone_gain != gain){ 3070 hfp_connection->microphone_gain = gain; 3071 hfp_connection->send_microphone_gain = 1; 3072 } 3073 hfp_ag_run_for_context(hfp_connection); 3074 return ERROR_CODE_SUCCESS; 3075 } 3076 3077 uint8_t hfp_ag_set_speaker_gain(hci_con_handle_t acl_handle, int gain){ 3078 hfp_connection_t * hfp_connection = get_hfp_ag_connection_context_for_acl_handle(acl_handle); 3079 if (!hfp_connection){ 3080 return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER; 3081 } 3082 3083 if ((gain < 0) || (gain > 15)){ 3084 log_info("Valid range for a gain is [0..15]. Currently sent: %d", gain); 3085 return ERROR_CODE_COMMAND_DISALLOWED; 3086 } 3087 3088 if (hfp_connection->speaker_gain != gain){ 3089 hfp_connection->speaker_gain = gain; 3090 hfp_connection->send_speaker_gain = 1; 3091 } 3092 hfp_ag_run_for_context(hfp_connection); 3093 return ERROR_CODE_SUCCESS; 3094 } 3095 3096 uint8_t hfp_ag_send_phone_number_for_voice_tag(hci_con_handle_t acl_handle, const char * number){ 3097 hfp_connection_t * hfp_connection = get_hfp_ag_connection_context_for_acl_handle(acl_handle); 3098 if (!hfp_connection){ 3099 return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER; 3100 } 3101 3102 hfp_ag_set_clip(0, number); 3103 hfp_connection->send_phone_number_for_voice_tag = 1; 3104 return ERROR_CODE_SUCCESS; 3105 } 3106 3107 uint8_t hfp_ag_reject_phone_number_for_voice_tag(hci_con_handle_t acl_handle){ 3108 hfp_connection_t * hfp_connection = get_hfp_ag_connection_context_for_acl_handle(acl_handle); 3109 if (!hfp_connection){ 3110 return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER; 3111 } 3112 3113 hfp_connection->send_error = 1; 3114 return ERROR_CODE_SUCCESS; 3115 } 3116 3117 uint8_t hfp_ag_send_dtmf_code_done(hci_con_handle_t acl_handle){ 3118 hfp_connection_t * hfp_connection = get_hfp_ag_connection_context_for_acl_handle(acl_handle); 3119 if (!hfp_connection){ 3120 return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER; 3121 } 3122 3123 hfp_connection->ok_pending = 1; 3124 return ERROR_CODE_SUCCESS; 3125 } 3126 3127 uint8_t hfp_ag_send_unsolicited_result_code(hci_con_handle_t acl_handle, const char * unsolicited_result_code){ 3128 hfp_connection_t * hfp_connection = get_hfp_ag_connection_context_for_acl_handle(acl_handle); 3129 if (!hfp_connection){ 3130 return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER; 3131 } 3132 if (hfp_connection->send_custom_message != NULL){ 3133 return ERROR_CODE_COMMAND_DISALLOWED; 3134 } 3135 hfp_connection->send_custom_message = unsolicited_result_code; 3136 hfp_ag_run_for_context(hfp_connection); 3137 return ERROR_CODE_SUCCESS; 3138 } 3139 3140 uint8_t hfp_ag_send_command_result_code(hci_con_handle_t acl_handle, bool ok){ 3141 hfp_connection_t * hfp_connection = get_hfp_ag_connection_context_for_acl_handle(acl_handle); 3142 if (!hfp_connection){ 3143 return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER; 3144 } 3145 if (ok){ 3146 hfp_connection->ok_pending = 1; 3147 } else { 3148 hfp_connection->send_error = 1; 3149 } 3150 hfp_ag_run_for_context(hfp_connection); 3151 return ERROR_CODE_SUCCESS; 3152 } 3153 3154 void hfp_ag_set_subcriber_number_information(hfp_phone_number_t * numbers, int numbers_count){ 3155 hfp_ag_subscriber_numbers = numbers; 3156 hfp_ag_subscriber_numbers_count = numbers_count; 3157 } 3158 3159 void hfp_ag_clear_last_dialed_number(void){ 3160 hfp_gsm_clear_last_dialed_number(); 3161 } 3162 3163 void hfp_ag_set_last_dialed_number(const char * number){ 3164 hfp_gsm_set_last_dialed_number(number); 3165 } 3166 3167 uint8_t hfp_ag_notify_incoming_call_waiting(hci_con_handle_t acl_handle){ 3168 hfp_connection_t * hfp_connection = get_hfp_ag_connection_context_for_acl_handle(acl_handle); 3169 if (!hfp_connection){ 3170 return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER; 3171 } 3172 3173 if (!hfp_connection->call_waiting_notification_enabled){ 3174 return ERROR_CODE_COMMAND_DISALLOWED; 3175 } 3176 3177 hfp_connection->ag_notify_incoming_call_waiting = 1; 3178 hfp_ag_run_for_context(hfp_connection); 3179 return ERROR_CODE_SUCCESS; 3180 } 3181 3182 void hfp_ag_create_sdp_record(uint8_t * service, uint32_t service_record_handle, int rfcomm_channel_nr, const char * name, uint8_t ability_to_reject_call, uint16_t supported_features, int wide_band_speech){ 3183 if (!name){ 3184 name = hfp_ag_default_service_name; 3185 } 3186 hfp_create_sdp_record(service, service_record_handle, BLUETOOTH_SERVICE_CLASS_HANDSFREE_AUDIO_GATEWAY, rfcomm_channel_nr, name); 3187 3188 /* 3189 * 0x01 – Ability to reject a call 3190 * 0x00 – No ability to reject a call 3191 */ 3192 de_add_number(service, DE_UINT, DE_SIZE_16, 0x0301); // Hands-Free Profile - Network 3193 de_add_number(service, DE_UINT, DE_SIZE_8, ability_to_reject_call); 3194 3195 // Construct SupportedFeatures for SDP bitmap: 3196 // 3197 // "The values of the “SupportedFeatures” bitmap given in Table 5.4 shall be the same as the values 3198 // of the Bits 0 to 4 of the unsolicited result code +BRSF" 3199 // 3200 // Wide band speech (bit 5) requires Codec negotiation 3201 // 3202 uint16_t sdp_features = supported_features & 0x1f; 3203 if ( (wide_band_speech == 1) && (supported_features & (1 << HFP_AGSF_CODEC_NEGOTIATION))){ 3204 sdp_features |= 1 << 5; 3205 } 3206 3207 if (supported_features & (1 << HFP_AGSF_ENHANCED_VOICE_RECOGNITION_STATUS)){ 3208 sdp_features |= 1 << 6; 3209 } 3210 3211 if (supported_features & (1 << HFP_AGSF_VOICE_RECOGNITION_TEXT)){ 3212 sdp_features |= 1 << 7; 3213 } 3214 3215 de_add_number(service, DE_UINT, DE_SIZE_16, 0x0311); // Hands-Free Profile - SupportedFeatures 3216 de_add_number(service, DE_UINT, DE_SIZE_16, sdp_features); 3217 } 3218 3219 void hfp_ag_register_packet_handler(btstack_packet_handler_t callback){ 3220 btstack_assert(callback != NULL); 3221 3222 hfp_ag_callback = callback; 3223 hfp_set_ag_callback(callback); 3224 } 3225 3226 void hfp_ag_register_custom_call_sm_handler(bool (*handler)(hfp_ag_call_event_t event)){ 3227 hfp_ag_custom_call_sm_handler = handler; 3228 } 3229 3230 void hfp_ag_register_custom_at_command(hfp_custom_at_command_t * custom_at_command){ 3231 hfp_register_custom_ag_command(custom_at_command); 3232 } 3233