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