xref: /btstack/src/classic/avrcp_controller.c (revision 88410903bf893a8f58023ed8b1a98abcc6c9708c)
1 /*
2  * Copyright (C) 2016 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__ "avrcp_controller.c"
39 
40 #include <stdint.h>
41 #include <string.h>
42 #include <inttypes.h>
43 
44 #include "classic/avrcp.h"
45 #include "classic/avrcp_controller.h"
46 
47 #include "bluetooth_sdp.h"
48 #include "btstack_debug.h"
49 #include "btstack_event.h"
50 
51 static const char * avrcp_default_controller_service_name = "AVRCP Controller";
52 static const char * avrcp_default_controller_service_provider_name = "BlueKitchen";
53 
54 // made public in avrcp_controller.h
55 avrcp_context_t avrcp_controller_context;
56 
57 static uint8_t avrcp_controller_calc_next_transaction_label(uint8_t current_transaction_label){
58     current_transaction_label++;
59     if (current_transaction_label == 16){
60         current_transaction_label = 1;
61     }
62     return current_transaction_label;
63 }
64 
65 static uint8_t avrcp_controller_get_next_transaction_label(avrcp_connection_t * connection){
66     connection->transaction_id_counter = avrcp_controller_calc_next_transaction_label(connection->transaction_id_counter);
67     return connection->transaction_id_counter;
68 }
69 
70 static bool avrcp_controller_is_transaction_id_valid(avrcp_connection_t * connection, uint8_t transaction_id){
71     uint8_t delta = ((int8_t) transaction_id - connection->controller_last_confirmed_transaction_id) & 0x0f;
72     return delta < 15;
73 }
74 
75 static void avrcp_controller_custom_command_data_init(avrcp_connection_t * connection,
76                                                       avrcp_command_opcode_t opcode, avrcp_command_type_t command_type,
77                                                       avrcp_subunit_type_t subunit_type, avrcp_subunit_id_t subunit_id,
78                                                       avrcp_pdu_id_t pdu_id, uint32_t company_id){
79 
80     connection->transaction_id = avrcp_controller_get_next_transaction_label(connection);
81     connection->command_opcode = opcode;
82     connection->command_type = command_type;
83     connection->subunit_type = subunit_type;
84     connection->subunit_id = subunit_id;
85     connection->company_id = company_id;
86     connection->pdu_id = pdu_id;
87     connection->data = NULL;
88     connection->data_offset = 0;
89     connection->data_len = 0;
90 }
91 
92 static void avrcp_controller_vendor_dependent_command_data_init(avrcp_connection_t * connection, avrcp_command_type_t command_type, avrcp_pdu_id_t pdu_id, bool get_next_transaction_label){
93     if (get_next_transaction_label){
94         connection->transaction_id = avrcp_controller_get_next_transaction_label(connection);
95     }
96     connection->command_opcode = AVRCP_CMD_OPCODE_VENDOR_DEPENDENT;
97     connection->subunit_type = AVRCP_SUBUNIT_TYPE_PANEL;
98     connection->subunit_id = AVRCP_SUBUNIT_ID;
99     connection->company_id = BT_SIG_COMPANY_ID;
100 
101     connection->command_type = command_type;
102     connection->pdu_id = pdu_id;
103     connection->data = connection->message_body;
104     connection->data_offset = 0;
105     connection->data_len = 0;
106 }
107 
108 static void avrcp_controller_pass_through_command_data_init(avrcp_connection_t * connection, avrcp_operation_id_t opid){
109     connection->transaction_id = avrcp_controller_get_next_transaction_label(connection);
110     connection->command_opcode =  AVRCP_CMD_OPCODE_PASS_THROUGH;
111     connection->command_type = AVRCP_CTYPE_CONTROL;
112     connection->subunit_type = AVRCP_SUBUNIT_TYPE_PANEL;
113     connection->subunit_id =   AVRCP_SUBUNIT_ID;
114 
115     connection->company_id = 0;
116     connection->pdu_id = AVRCP_PDU_ID_UNDEFINED;
117     connection->operation_id = opid;
118 
119     connection->data = connection->message_body;
120     connection->data_offset = 0;
121     connection->data_len = 0;
122 }
123 
124 static int avrcp_controller_supports_browsing(uint16_t controller_supported_features){
125     return controller_supported_features & AVRCP_FEATURE_MASK_BROWSING;
126 }
127 
128 static void avrcp_controller_prepare_custom_command_response(avrcp_connection_t * connection, uint16_t response_len, uint8_t * in_place_buffer){
129     uint8_t pos = 0;
130     in_place_buffer[pos++] = HCI_EVENT_AVRCP_META;
131     // skip len
132     pos++;
133     in_place_buffer[pos++] = AVRCP_SUBEVENT_CUSTOM_COMMAND_RESPONSE;
134     little_endian_store_16(in_place_buffer, pos, connection->avrcp_cid);
135     pos += 2;
136     in_place_buffer[pos++] = (uint8_t)connection->command_type;
137     in_place_buffer[pos++] = (uint8_t)connection->pdu_id;
138     little_endian_store_16(in_place_buffer, pos, response_len);
139     pos += 2;
140     in_place_buffer[1] = pos + response_len - 2;
141 }
142 
143 static void avrcp_controller_emit_notification_complete(avrcp_connection_t * connection, uint8_t status, uint8_t event_id, bool enabled){
144     uint8_t event[8];
145     uint8_t pos = 0;
146     event[pos++] = HCI_EVENT_AVRCP_META;
147     event[pos++] = sizeof(event) - 2;
148     event[pos++] = AVRCP_SUBEVENT_NOTIFICATION_STATE;
149     little_endian_store_16(event, pos, connection->avrcp_cid);
150     pos += 2;
151     event[pos++] = status;
152     event[pos++] = enabled ? 1 : 0;
153     event[pos++] = event_id;
154     UNUSED(pos);
155     (*avrcp_controller_context.avrcp_callback)(HCI_EVENT_PACKET, 0, event, sizeof(event));
156 }
157 
158 static void avrcp_controller_emit_supported_events(avrcp_connection_t * connection){
159     uint8_t ctype = (uint8_t) AVRCP_CTYPE_RESPONSE_CHANGED_STABLE;
160     uint8_t event_id;
161 
162     for (event_id = (uint8_t) AVRCP_NOTIFICATION_EVENT_FIRST_INDEX; event_id < (uint8_t) AVRCP_NOTIFICATION_EVENT_LAST_INDEX; event_id++){
163         if ((connection->notifications_supported_by_target & (1 << event_id)) == 0){
164             continue;
165         }
166         uint8_t event[8];
167         uint8_t pos = 0;
168         event[pos++] = HCI_EVENT_AVRCP_META;
169         event[pos++] = sizeof(event) - 2;
170         event[pos++] = AVRCP_SUBEVENT_GET_CAPABILITY_EVENT_ID;
171         little_endian_store_16(event, pos, connection->avrcp_cid);
172         pos += 2;
173         event[pos++] = ctype;
174         event[pos++] = 0;
175         event[pos++] = event_id;
176         UNUSED(pos);
177         (*avrcp_controller_context.avrcp_callback)(HCI_EVENT_PACKET, 0, event, sizeof(event));
178     }
179 
180     uint8_t event[7];
181     uint8_t pos = 0;
182     event[pos++] = HCI_EVENT_AVRCP_META;
183     event[pos++] = sizeof(event) - 2;
184     event[pos++] = AVRCP_SUBEVENT_GET_CAPABILITY_EVENT_ID_DONE;
185     little_endian_store_16(event, pos, connection->avrcp_cid);
186     pos += 2;
187     event[pos++] = ctype;
188     event[pos++] = 0;
189     UNUSED(pos);
190     (*avrcp_controller_context.avrcp_callback)(HCI_EVENT_PACKET, 0, event, sizeof(event));
191 }
192 
193 static void avrcp_controller_emit_notification_for_event_id(uint16_t avrcp_cid, avrcp_notification_event_id_t event_id,
194                                                             avrcp_command_type_t ctype, const uint8_t *payload,
195                                                             uint16_t size) {
196     switch (event_id){
197         case AVRCP_NOTIFICATION_EVENT_PLAYBACK_POS_CHANGED:{
198             if (size < 4) break;
199             uint32_t song_position = big_endian_read_32(payload, 0);
200             uint16_t offset = 0;
201             uint8_t event[10];
202             event[offset++] = HCI_EVENT_AVRCP_META;
203             event[offset++] = sizeof(event) - 2;
204             event[offset++] = AVRCP_SUBEVENT_NOTIFICATION_PLAYBACK_POS_CHANGED;
205             little_endian_store_16(event, offset, avrcp_cid);
206             offset += 2;
207             event[offset++] = ctype;
208             little_endian_store_32(event, offset, song_position);
209             offset += 4;
210             (*avrcp_controller_context.avrcp_callback)(HCI_EVENT_PACKET, 0, event, offset);
211             break;
212         }
213         case AVRCP_NOTIFICATION_EVENT_PLAYBACK_STATUS_CHANGED:{
214             if (size < 1) break;
215             uint16_t offset = 0;
216             uint8_t event[7];
217             event[offset++] = HCI_EVENT_AVRCP_META;
218             event[offset++] = sizeof(event) - 2;
219             event[offset++] = AVRCP_SUBEVENT_NOTIFICATION_PLAYBACK_STATUS_CHANGED;
220             little_endian_store_16(event, offset, avrcp_cid);
221             offset += 2;
222             event[offset++] = ctype;
223             event[offset++] = payload[0];
224             (*avrcp_controller_context.avrcp_callback)(HCI_EVENT_PACKET, 0, event, offset);
225             break;
226         }
227         case AVRCP_NOTIFICATION_EVENT_TRACK_CHANGED:{
228             uint16_t offset = 0;
229             uint8_t event[6];
230             event[offset++] = HCI_EVENT_AVRCP_META;
231             event[offset++] = sizeof(event) - 2;
232             event[offset++] = AVRCP_SUBEVENT_NOTIFICATION_TRACK_CHANGED;
233             little_endian_store_16(event, offset, avrcp_cid);
234             offset += 2;
235             event[offset++] = ctype;
236             (*avrcp_controller_context.avrcp_callback)(HCI_EVENT_PACKET, 0, event, offset);
237             break;
238         }
239         case AVRCP_NOTIFICATION_EVENT_NOW_PLAYING_CONTENT_CHANGED:{
240             uint16_t offset = 0;
241             uint8_t event[6];
242             event[offset++] = HCI_EVENT_AVRCP_META;
243             event[offset++] = sizeof(event) - 2;
244             event[offset++] = AVRCP_SUBEVENT_NOTIFICATION_NOW_PLAYING_CONTENT_CHANGED;
245             little_endian_store_16(event, offset, avrcp_cid);
246             offset += 2;
247             event[offset++] = ctype;
248             (*avrcp_controller_context.avrcp_callback)(HCI_EVENT_PACKET, 0, event, offset);
249             break;
250         }
251         case AVRCP_NOTIFICATION_EVENT_AVAILABLE_PLAYERS_CHANGED:{
252             uint16_t offset = 0;
253             uint8_t event[6];
254             event[offset++] = HCI_EVENT_AVRCP_META;
255             event[offset++] = sizeof(event) - 2;
256             event[offset++] = AVRCP_SUBEVENT_NOTIFICATION_AVAILABLE_PLAYERS_CHANGED;
257             little_endian_store_16(event, offset, avrcp_cid);
258             offset += 2;
259             event[offset++] = ctype;
260             (*avrcp_controller_context.avrcp_callback)(HCI_EVENT_PACKET, 0, event, offset);
261             break;
262         }
263         case AVRCP_NOTIFICATION_EVENT_VOLUME_CHANGED:{
264             if (size < 1) break;
265             uint16_t offset = 0;
266             uint8_t event[7];
267             event[offset++] = HCI_EVENT_AVRCP_META;
268             event[offset++] = sizeof(event) - 2;
269             event[offset++] = AVRCP_SUBEVENT_NOTIFICATION_VOLUME_CHANGED;
270             little_endian_store_16(event, offset, avrcp_cid);
271             offset += 2;
272             event[offset++] = ctype;
273             event[offset++] = payload[0] & 0x7F;
274             (*avrcp_controller_context.avrcp_callback)(HCI_EVENT_PACKET, 0, event, offset);
275             break;
276         }
277         case AVRCP_NOTIFICATION_EVENT_UIDS_CHANGED:{
278             if (size < 2) break;
279             uint8_t event[8];
280             uint16_t offset = 0;
281             uint16_t uuid = big_endian_read_16(payload, 0);
282             event[offset++] = HCI_EVENT_AVRCP_META;
283             event[offset++] = sizeof(event) - 2;
284             event[offset++] = AVRCP_SUBEVENT_NOTIFICATION_EVENT_UIDS_CHANGED;
285             little_endian_store_16(event, offset, avrcp_cid);
286             offset += 2;
287             event[offset++] = ctype;
288             little_endian_store_16(event, offset, uuid);
289             offset += 2;
290             (*avrcp_controller_context.avrcp_callback)(HCI_EVENT_PACKET, 0, event, offset);
291             break;
292         }
293 
294         case AVRCP_NOTIFICATION_EVENT_TRACK_REACHED_END:{
295             uint16_t offset = 0;
296             uint8_t event[6];
297             event[offset++] = HCI_EVENT_AVRCP_META;
298             event[offset++] = sizeof(event) - 2;
299             event[offset++] = AVRCP_SUBEVENT_NOTIFICATION_EVENT_TRACK_REACHED_END;
300             little_endian_store_16(event, offset, avrcp_cid);
301             offset += 2;
302             event[offset++] = ctype;
303             (*avrcp_controller_context.avrcp_callback)(HCI_EVENT_PACKET, 0, event, offset);
304             break;
305         }
306         case AVRCP_NOTIFICATION_EVENT_TRACK_REACHED_START:{
307             uint16_t offset = 0;
308             uint8_t event[6];
309             event[offset++] = HCI_EVENT_AVRCP_META;
310             event[offset++] = sizeof(event) - 2;
311             event[offset++] = AVRCP_SUBEVENT_NOTIFICATION_EVENT_TRACK_REACHED_START;
312             little_endian_store_16(event, offset, avrcp_cid);
313             offset += 2;
314             event[offset++] = ctype;
315             (*avrcp_controller_context.avrcp_callback)(HCI_EVENT_PACKET, 0, event, offset);
316             break;
317         }
318         case AVRCP_NOTIFICATION_EVENT_BATT_STATUS_CHANGED:{
319             if (size < 1) break;
320             uint16_t offset = 0;
321             uint8_t event[7];
322             event[offset++] = HCI_EVENT_AVRCP_META;
323             event[offset++] = sizeof(event) - 2;
324             event[offset++] = AVRCP_SUBEVENT_NOTIFICATION_EVENT_BATT_STATUS_CHANGED;
325             little_endian_store_16(event, offset, avrcp_cid);
326             offset += 2;
327             event[offset++] = ctype;
328             event[offset++] = payload[0];
329             (*avrcp_controller_context.avrcp_callback)(HCI_EVENT_PACKET, 0, event, offset);
330             break;
331         }
332 
333         case AVRCP_NOTIFICATION_EVENT_SYSTEM_STATUS_CHANGED:{
334             if (size < 1) break;
335             uint16_t offset = 0;
336             uint8_t event[7];
337             event[offset++] = HCI_EVENT_AVRCP_META;
338             event[offset++] = sizeof(event) - 2;
339             event[offset++] = AVRCP_SUBEVENT_NOTIFICATION_EVENT_SYSTEM_STATUS_CHANGED;
340             little_endian_store_16(event, offset, avrcp_cid);
341             offset += 2;
342             event[offset++] = ctype;
343             event[offset++] = payload[0];
344             (*avrcp_controller_context.avrcp_callback)(HCI_EVENT_PACKET, 0, event, offset);
345             break;
346         }
347 
348         case AVRCP_NOTIFICATION_EVENT_PLAYER_APPLICATION_SETTING_CHANGED:
349         default:
350             log_info("avrcp: not implemented");
351             break;
352     }
353 }
354 
355 static void avrcp_controller_emit_repeat_and_shuffle_mode(btstack_packet_handler_t callback, uint16_t avrcp_cid, uint8_t ctype, avrcp_repeat_mode_t repeat_mode, avrcp_shuffle_mode_t shuffle_mode){
356     btstack_assert(callback != NULL);
357 
358     uint8_t event[8];
359     int pos = 0;
360     event[pos++] = HCI_EVENT_AVRCP_META;
361     event[pos++] = sizeof(event) - 2;
362     event[pos++] = AVRCP_SUBEVENT_SHUFFLE_AND_REPEAT_MODE;
363     little_endian_store_16(event, pos, avrcp_cid);
364     pos += 2;
365     event[pos++] = ctype;
366     event[pos++] = repeat_mode;
367     event[pos++] = shuffle_mode;
368     (*callback)(HCI_EVENT_PACKET, 0, event, sizeof(event));
369 }
370 
371 static void avrcp_controller_emit_now_playing_info_event_done(btstack_packet_handler_t callback, uint16_t avrcp_cid, uint8_t ctype, uint8_t status){
372     uint8_t event[7];
373     int pos = 0;
374     event[pos++] = HCI_EVENT_AVRCP_META;
375     event[pos++] = sizeof(event) - 2;
376     event[pos++] = AVRCP_SUBEVENT_NOW_PLAYING_INFO_DONE;
377     little_endian_store_16(event, pos, avrcp_cid);
378     pos += 2;
379     event[pos++] = ctype;
380     event[pos++] = status;
381     (*callback)(HCI_EVENT_PACKET, 0, event, pos);
382 }
383 
384 static void avrcp_controller_emit_now_playing_info_event(btstack_packet_handler_t callback, uint16_t avrcp_cid, uint8_t ctype, avrcp_media_attribute_id_t attr_id, uint8_t * value, uint16_t value_len){
385     uint8_t event[HCI_EVENT_BUFFER_SIZE];
386     uint16_t pos = 0;
387     event[pos++] = HCI_EVENT_AVRCP_META;
388     // reserve one byte for subevent type and data len
389 	uint16_t data_len_pos = pos;
390     pos++;
391 	uint16_t subevent_type_pos = pos;
392     pos++;
393     little_endian_store_16(event, pos, avrcp_cid);
394     pos += 2;
395     event[pos++] = ctype;
396 
397     switch (attr_id){
398         case AVRCP_MEDIA_ATTR_TITLE:
399             event[subevent_type_pos] = AVRCP_SUBEVENT_NOW_PLAYING_TITLE_INFO;
400 			btstack_assert(value_len <= 255);
401             event[pos++] = (uint8_t) value_len;
402             (void)memcpy(event + pos, value, value_len);
403             break;
404         case AVRCP_MEDIA_ATTR_ARTIST:
405             event[subevent_type_pos] = AVRCP_SUBEVENT_NOW_PLAYING_ARTIST_INFO;
406 			btstack_assert(value_len <= 255);
407 			event[pos++] = (uint8_t) value_len;
408             (void)memcpy(event + pos, value, value_len);
409             break;
410         case AVRCP_MEDIA_ATTR_ALBUM:
411             event[subevent_type_pos] = AVRCP_SUBEVENT_NOW_PLAYING_ALBUM_INFO;
412 			btstack_assert(value_len <= 255);
413 			event[pos++] = (uint8_t) value_len;
414             (void)memcpy(event + pos, value, value_len);
415             break;
416         case AVRCP_MEDIA_ATTR_GENRE:
417             event[subevent_type_pos] = AVRCP_SUBEVENT_NOW_PLAYING_GENRE_INFO;
418 			btstack_assert(value_len <= 255);
419 			event[pos++] = (uint8_t) value_len;
420             (void)memcpy(event + pos, value, value_len);
421             break;
422 #ifdef ENABLE_AVRCP_COVER_ART
423         case AVRCP_MEDIA_ATTR_DEFAULT_COVER_ART:
424             event[subevent_type_pos] = AVRCP_SUBEVENT_NOW_PLAYING_COVER_ART_INFO;
425             btstack_assert(value_len <= 255);
426             event[pos++] = (uint8_t) value_len;
427             (void)memcpy(event + pos, value, value_len);
428             break;
429 #endif
430         case AVRCP_MEDIA_ATTR_SONG_LENGTH_MS:
431             event[subevent_type_pos] = AVRCP_SUBEVENT_NOW_PLAYING_SONG_LENGTH_MS_INFO;
432             if (value){
433                 little_endian_store_32(event, pos, btstack_atoi((char *)value));
434             } else {
435                 little_endian_store_32(event, pos, 0);
436             }
437             pos += 4;
438             break;
439         case AVRCP_MEDIA_ATTR_TRACK:
440             event[subevent_type_pos] = AVRCP_SUBEVENT_NOW_PLAYING_TRACK_INFO;
441             if (value){
442                 event[pos++] = btstack_atoi((char *)value);
443             } else {
444                 event[pos++] = 0;
445             }
446             break;
447         case AVRCP_MEDIA_ATTR_TOTAL_NUM_ITEMS:
448             event[subevent_type_pos] = AVRCP_SUBEVENT_NOW_PLAYING_TOTAL_TRACKS_INFO;
449             if (value){
450                 event[pos++] = btstack_atoi((char *)value);
451             } else {
452                 event[pos++] = 0;
453             }
454             break;
455         default:
456             break;
457     }
458     event[data_len_pos] = pos - 2;
459     (*callback)(HCI_EVENT_PACKET, 0, event, pos);
460 }
461 
462 static void avrcp_controller_emit_operation_status(btstack_packet_handler_t callback, uint8_t subevent, uint16_t avrcp_cid, uint8_t ctype, uint8_t operation_id){
463     btstack_assert(callback != NULL);
464 
465     uint8_t event[7];
466     int pos = 0;
467     event[pos++] = HCI_EVENT_AVRCP_META;
468     event[pos++] = sizeof(event) - 2;
469     event[pos++] = subevent;
470     little_endian_store_16(event, pos, avrcp_cid);
471     pos += 2;
472     event[pos++] = ctype;
473     event[pos++] = operation_id;
474     (*callback)(HCI_EVENT_PACKET, 0, event, sizeof(event));
475 }
476 
477 static void avrcp_parser_reset(avrcp_connection_t * connection){
478     connection->list_offset = 0;
479     connection->parser_attribute_header_pos = 0;
480     connection->controller_num_received_fragments = 0;
481     connection->parser_state = AVRCP_PARSER_GET_ATTRIBUTE_HEADER;
482 }
483 
484 static void avrcp_parser_process_byte(uint8_t byte, avrcp_connection_t * connection, avrcp_command_type_t ctype){
485     uint16_t attribute_total_value_len;
486     uint32_t attribute_id;
487     switch(connection->parser_state){
488         case AVRCP_PARSER_GET_ATTRIBUTE_HEADER:
489             connection->parser_attribute_header[connection->parser_attribute_header_pos++] = byte;
490             connection->list_offset++;
491 
492             if (connection->parser_attribute_header_pos < AVRCP_ATTRIBUTE_HEADER_LEN) return;
493 
494             attribute_total_value_len = big_endian_read_16(connection->parser_attribute_header, 6);
495             connection->attribute_value_len = btstack_min(attribute_total_value_len, AVRCP_MAX_ATTRIBUTE_SIZE);
496             if (connection->attribute_value_len > 0){
497                 // get ready for attribute value
498                 connection->parser_state = AVRCP_PARSER_GET_ATTRIBUTE_VALUE;
499                 return;
500             }
501 
502             // emit empty attribute
503             attribute_id = big_endian_read_32(connection->parser_attribute_header, 0);
504             avrcp_controller_emit_now_playing_info_event(avrcp_controller_context.avrcp_callback, connection->avrcp_cid, ctype, (avrcp_media_attribute_id_t) attribute_id, connection->attribute_value, connection->attribute_value_len);
505 
506             // done, see below
507             break;
508 
509         case AVRCP_PARSER_GET_ATTRIBUTE_VALUE:
510             connection->attribute_value[connection->attribute_value_offset++] = byte;
511             connection->list_offset++;
512 
513             if (connection->attribute_value_offset < connection->attribute_value_len) return;
514 
515             // emit (potentially partial) attribute
516             attribute_id = big_endian_read_32(connection->parser_attribute_header, 0);
517             avrcp_controller_emit_now_playing_info_event(avrcp_controller_context.avrcp_callback, connection->avrcp_cid, ctype, (avrcp_media_attribute_id_t) attribute_id, connection->attribute_value, connection->attribute_value_len);
518 
519             attribute_total_value_len = big_endian_read_16(connection->parser_attribute_header, 6);
520             if (connection->attribute_value_offset < attribute_total_value_len){
521                 // ignore rest of attribute
522                 connection->parser_state = AVRCP_PARSER_IGNORE_REST_OF_ATTRIBUTE_VALUE;
523                 return;
524             }
525 
526             // done, see below
527             break;
528 
529         case AVRCP_PARSER_IGNORE_REST_OF_ATTRIBUTE_VALUE:
530             connection->attribute_value_offset++;
531             connection->list_offset++;
532 
533             attribute_total_value_len = big_endian_read_16(connection->parser_attribute_header, 6);
534             if (connection->attribute_value_offset < attribute_total_value_len) return;
535 
536             // done, see below
537             break;
538 
539         default:
540             return;
541     }
542 
543     // attribute fully read, check if more to come
544     if (connection->list_offset < connection->list_size){
545         // more to come, reset parser
546         connection->parser_state = AVRCP_PARSER_GET_ATTRIBUTE_HEADER;
547         connection->parser_attribute_header_pos = 0;
548         connection->attribute_value_offset = 0;
549     } else {
550         // fully done
551         avrcp_parser_reset(connection);
552         avrcp_controller_emit_now_playing_info_event_done(avrcp_controller_context.avrcp_callback, connection->avrcp_cid, ctype, 0);
553     }
554 }
555 
556 static void avrcp_controller_parse_and_emit_element_attrs(uint8_t * packet, uint16_t num_bytes_to_read, avrcp_connection_t * connection, avrcp_command_type_t ctype){
557     int i;
558     for (i=0;i<num_bytes_to_read;i++){
559         avrcp_parser_process_byte(packet[i], connection, ctype);
560     }
561 }
562 
563 static void avrcp_send_cmd_with_avctp_fragmentation(avrcp_connection_t * connection){
564     l2cap_reserve_packet_buffer();
565     uint8_t * packet = l2cap_get_outgoing_buffer();
566 
567     uint16_t max_payload_size;
568     connection->avctp_packet_type = avctp_get_packet_type(connection, &max_payload_size);
569     connection->avrcp_packet_type = avrcp_get_packet_type(connection);
570 
571     // non-fragmented: transport header (1) + PID (2)
572     // fragmented:     transport header (1) + num packets (1) + PID (2)
573 
574     uint16_t param_len = connection->data_len;
575     // AVCTP header
576     // transport header : transaction label | Packet_type | C/R | IPID (1 == invalid profile identifier)
577     uint16_t pos = 0;
578     packet[pos++] = (connection->transaction_id << 4) | (connection->avctp_packet_type << 2) | (AVRCP_COMMAND_FRAME << 1) | 0;
579 
580     if (connection->avctp_packet_type == AVCTP_START_PACKET){
581         uint16_t max_frame_size = btstack_min(connection->l2cap_mtu, AVRCP_MAX_AV_C_MESSAGE_FRAME_SIZE);
582         // first packet: max_payload_size
583         // rest packets
584         uint16_t num_payload_bytes = param_len - max_payload_size;
585         uint16_t frame_size_for_continue_packet = max_frame_size - avctp_get_num_bytes_for_header(AVCTP_CONTINUE_PACKET);
586         uint16_t num_avctp_packets = (num_payload_bytes + frame_size_for_continue_packet - 1)/frame_size_for_continue_packet + 1;
587 		btstack_assert(num_avctp_packets <= 255);
588         packet[pos++] = (uint8_t) num_avctp_packets;
589     }
590 
591     switch (connection->avctp_packet_type){
592         case AVCTP_SINGLE_PACKET:
593         case AVCTP_START_PACKET:
594             connection->data_offset = 0;
595             // Profile IDentifier (PID)
596             packet[pos++] = BLUETOOTH_SERVICE_CLASS_AV_REMOTE_CONTROL >> 8;
597             packet[pos++] = BLUETOOTH_SERVICE_CLASS_AV_REMOTE_CONTROL & 0x00FF;
598 
599             // command_type
600             packet[pos++] = connection->command_type;
601             // subunit_type | subunit ID
602             packet[pos++] = (connection->subunit_type << 3) | connection->subunit_id;
603             // opcode
604             packet[pos++] = (uint8_t)connection->command_opcode;
605 
606             switch (connection->command_opcode){
607                 case AVRCP_CMD_OPCODE_VENDOR_DEPENDENT:
608                     big_endian_store_24(packet, pos, connection->company_id);
609                     pos += 3;
610                     packet[pos++] = connection->pdu_id;
611                     packet[pos++] = connection->avrcp_packet_type;              // reserved(upper 6) | AVRCP packet_type
612                     big_endian_store_16(packet, pos, connection->data_len);     // parameter length
613                     pos += 2;
614                     break;
615                 case AVRCP_CMD_OPCODE_PASS_THROUGH:
616                     packet[pos++] = connection->operation_id;
617                     packet[pos++] = (uint8_t)connection->data_len;     // parameter length
618                     break;
619                 case AVRCP_CMD_OPCODE_UNIT_INFO:
620                 case AVRCP_CMD_OPCODE_SUBUNIT_INFO:
621                     break;
622                 default:
623                     btstack_assert(false);
624                     return;
625             }
626             break;
627         case AVCTP_CONTINUE_PACKET:
628         case AVCTP_END_PACKET:
629             break;
630         default:
631             btstack_assert(false);
632             return;
633     }
634     // compare number of bytes to store with the remaining buffer size
635     uint16_t bytes_to_copy = btstack_min(connection->data_len - connection->data_offset, max_payload_size - pos);
636 
637     (void)memcpy(packet + pos, &connection->data[connection->data_offset], bytes_to_copy);
638     pos += bytes_to_copy;
639     connection->data_offset += bytes_to_copy;
640 
641     l2cap_send_prepared(connection->l2cap_signaling_cid, pos);
642 }
643 
644 static int avrcp_send_register_notification(avrcp_connection_t * connection, uint8_t event_id){
645     uint8_t command[18];
646     uint16_t pos = 0;
647     // transport header : transaction label | Packet_type | C/R | IPID (1 == invalid profile identifier)
648     connection->transaction_id = avrcp_controller_get_next_transaction_label(connection);
649     command[pos++] = (connection->transaction_id << 4) | (AVRCP_SINGLE_PACKET << 2) | (AVRCP_COMMAND_FRAME << 1) | 0;
650 
651     command[pos++] = BLUETOOTH_SERVICE_CLASS_AV_REMOTE_CONTROL >> 8;
652     command[pos++] = BLUETOOTH_SERVICE_CLASS_AV_REMOTE_CONTROL & 0x00FF;
653     command[pos++] = AVRCP_CTYPE_NOTIFY;
654     command[pos++] = (AVRCP_SUBUNIT_TYPE_PANEL << 3) | AVRCP_SUBUNIT_ID;
655     command[pos++] = AVRCP_CMD_OPCODE_VENDOR_DEPENDENT;
656 
657     big_endian_store_24(command, pos, BT_SIG_COMPANY_ID);
658     pos += 3;
659     command[pos++] = AVRCP_PDU_ID_REGISTER_NOTIFICATION;
660     command[pos++] = 0;                       // reserved(upper 6) | packet_type -> 0
661     big_endian_store_16(command, pos, 5);     // parameter length
662     pos += 2;
663     command[pos++] = event_id;
664     big_endian_store_32(command, pos, 1);     // send notification on playback position every second, for other notifications it is ignored
665     pos += 4;
666     return l2cap_send(connection->l2cap_signaling_cid, command, pos);
667 }
668 
669 static void avrcp_press_and_hold_timeout_handler(btstack_timer_source_t * timer){
670     UNUSED(timer);
671     avrcp_connection_t * connection = (avrcp_connection_t*) btstack_run_loop_get_timer_context(timer);
672     btstack_run_loop_set_timer(&connection->controller_press_and_hold_cmd_timer, 2000); // 2 seconds timeout
673     btstack_run_loop_add_timer(&connection->controller_press_and_hold_cmd_timer);
674     connection->state = AVCTP_W2_SEND_PRESS_COMMAND;
675     avrcp_request_can_send_now(connection, connection->l2cap_signaling_cid);
676 }
677 
678 static void avrcp_press_and_hold_timer_start(avrcp_connection_t * connection){
679     btstack_run_loop_remove_timer(&connection->controller_press_and_hold_cmd_timer);
680     btstack_run_loop_set_timer_handler(&connection->controller_press_and_hold_cmd_timer, avrcp_press_and_hold_timeout_handler);
681     btstack_run_loop_set_timer_context(&connection->controller_press_and_hold_cmd_timer, connection);
682     btstack_run_loop_set_timer(&connection->controller_press_and_hold_cmd_timer, 2000); // 2 seconds timeout
683     btstack_run_loop_add_timer(&connection->controller_press_and_hold_cmd_timer);
684 }
685 
686 static void avrcp_press_and_hold_timer_stop(avrcp_connection_t * connection){
687     connection->controller_press_and_hold_cmd_active = false;
688     btstack_run_loop_remove_timer(&connection->controller_press_and_hold_cmd_timer);
689 }
690 
691 
692 static uint8_t avrcp_controller_request_pass_through_release_control_cmd(avrcp_connection_t * connection){
693     connection->state = AVCTP_W2_SEND_RELEASE_COMMAND;
694     if (connection->controller_press_and_hold_cmd_active){
695         avrcp_press_and_hold_timer_stop(connection);
696     }
697     connection->operation_id = (avrcp_operation_id_t)(0x80 | connection->operation_id);
698     connection->transaction_id = avrcp_controller_get_next_transaction_label(connection);
699     avrcp_request_can_send_now(connection, connection->l2cap_signaling_cid);
700     return ERROR_CODE_SUCCESS;
701 }
702 
703 static uint8_t avrcp_controller_request_pass_through_press_control_cmd(uint16_t avrcp_cid, avrcp_operation_id_t opid, uint16_t playback_speed, bool continuous_cmd){
704 	UNUSED(playback_speed);
705 
706 	log_info("Send command %d", opid);
707     avrcp_connection_t * connection = avrcp_get_connection_for_avrcp_cid_for_role(AVRCP_CONTROLLER, avrcp_cid);
708     if (!connection){
709         return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
710     }
711 
712     if (connection->state != AVCTP_CONNECTION_OPENED){
713         log_error("Connection in wrong state %d, expected %d. avrcp cid 0x%02x", connection->state, AVCTP_CONNECTION_OPENED, avrcp_cid);
714         return ERROR_CODE_COMMAND_DISALLOWED;
715     }
716     connection->state = AVCTP_W2_SEND_PRESS_COMMAND;
717     avrcp_controller_pass_through_command_data_init(connection, opid);
718 
719     connection->controller_press_and_hold_cmd_active = continuous_cmd;
720     if (connection->controller_press_and_hold_cmd_active){
721         avrcp_press_and_hold_timer_start(connection);
722     }
723 
724     avrcp_request_can_send_now(connection, connection->l2cap_signaling_cid);
725     return ERROR_CODE_SUCCESS;
726 }
727 
728 static uint8_t request_single_pass_through_press_control_cmd(uint16_t avrcp_cid, avrcp_operation_id_t opid, uint16_t playback_speed){
729     return avrcp_controller_request_pass_through_press_control_cmd(avrcp_cid, opid, playback_speed, false);
730 }
731 
732 static uint8_t request_continuous_pass_through_press_control_cmd(uint16_t avrcp_cid, avrcp_operation_id_t opid, uint16_t playback_speed){
733     return avrcp_controller_request_pass_through_press_control_cmd(avrcp_cid, opid, playback_speed, true);
734 }
735 
736 static void avrcp_controller_get_capabilities_for_connection(avrcp_connection_t * connection, uint8_t capability_id){
737     connection->state = AVCTP_W2_SEND_COMMAND;
738     avrcp_controller_vendor_dependent_command_data_init(connection, AVRCP_CTYPE_STATUS, AVRCP_PDU_ID_GET_CAPABILITIES, true);
739 
740     // Parameter Length
741     connection->data_len = 1;
742     connection->data[0] = capability_id;  // capability ID
743 
744     avrcp_request_can_send_now(connection, connection->l2cap_signaling_cid);
745 }
746 
747 static uint8_t avrcp_controller_register_notification(avrcp_connection_t * connection, avrcp_notification_event_id_t event_id){
748     if ((connection->remote_capabilities_state == AVRCP_REMOTE_CAPABILITIES_KNOWN) && (connection->notifications_supported_by_target & (1 << event_id)) == 0){
749         return ERROR_CODE_UNSUPPORTED_FEATURE_OR_PARAMETER_VALUE;
750     }
751     if ((connection->controller_notifications_to_deregister & (1 << event_id)) != 0){
752         return ERROR_CODE_COMMAND_DISALLOWED;
753     }
754     if ( (connection->notifications_enabled & (1 << event_id)) != 0){
755         return ERROR_CODE_SUCCESS;
756     }
757     connection->controller_notifications_to_register |= (1 << event_id);
758 
759     switch (connection->remote_capabilities_state){
760         case AVRCP_REMOTE_CAPABILITIES_NONE:
761             connection->remote_capabilities_state = AVRCP_REMOTE_CAPABILITIES_W4_QUERY_RESULT;
762             connection->controller_notifications_supported_by_target_suppress_emit_result = true;
763             avrcp_controller_get_capabilities_for_connection(connection, AVRCP_CAPABILITY_ID_EVENT);
764             break;
765         case AVRCP_REMOTE_CAPABILITIES_KNOWN:
766             avrcp_request_can_send_now(connection, connection->l2cap_signaling_cid);
767             break;
768         default:
769             break;
770     }
771     return ERROR_CODE_SUCCESS;
772 }
773 
774 static uint8_t avrcp_controller_request_continuation(avrcp_connection_t * connection, avrcp_pdu_id_t pdu_id){
775     connection->state = AVCTP_W2_SEND_COMMAND;
776     avrcp_controller_vendor_dependent_command_data_init(connection, AVRCP_CTYPE_CONTROL, pdu_id, false);
777 
778     // Parameter Length
779     connection->data_len = 3;
780     big_endian_store_16(connection->data, 0, 1);
781     connection->data[2] = AVRCP_PDU_ID_GET_ELEMENT_ATTRIBUTES;
782 
783     avrcp_request_can_send_now(connection, connection->l2cap_signaling_cid);
784     return ERROR_CODE_SUCCESS;
785 }
786 
787 static uint8_t avrcp_controller_request_abort_continuation(avrcp_connection_t * connection){
788     return avrcp_controller_request_continuation(connection, AVRCP_PDU_ID_REQUEST_ABORT_CONTINUING_RESPONSE);
789 }
790 
791 static uint8_t avrcp_controller_request_continue_response(avrcp_connection_t * connection){
792     return avrcp_controller_request_continuation(connection, AVRCP_PDU_ID_REQUEST_CONTINUING_RESPONSE);
793 }
794 
795 static void avrcp_controller_handle_notification(avrcp_connection_t *connection, avrcp_command_type_t ctype, uint8_t *payload, uint16_t size) {
796     if (size < 1) return;
797     uint16_t pos = 0;
798     avrcp_notification_event_id_t event_id = (avrcp_notification_event_id_t) payload[pos++];
799     if ( (event_id < AVRCP_NOTIFICATION_EVENT_FIRST_INDEX) || (event_id > AVRCP_NOTIFICATION_EVENT_LAST_INDEX)){
800         return;
801     }
802 
803     uint16_t event_mask = (1 << event_id);
804     uint16_t reset_event_mask = ~event_mask;
805 
806     switch (ctype){
807         case AVRCP_CTYPE_RESPONSE_REJECTED:
808             connection->controller_notifications_to_deregister &= reset_event_mask;
809             connection->controller_notifications_to_register   &= reset_event_mask;
810             connection->controller_initial_status_reported     &= reset_event_mask;
811             avrcp_controller_emit_notification_complete(connection, ERROR_CODE_UNSUPPORTED_FEATURE_OR_PARAMETER_VALUE, event_id, false);
812             return;
813 
814         case AVRCP_CTYPE_RESPONSE_INTERIM:
815             // register as enabled
816             connection->notifications_enabled |= event_mask;
817 
818             // check if initial value is already sent
819             if ((connection->controller_initial_status_reported & event_mask) != 0 ){
820                 return;
821             }
822             // emit event only once, initially
823             avrcp_controller_emit_notification_complete(connection, ERROR_CODE_SUCCESS, event_id, true);
824             connection->controller_initial_status_reported |= event_mask;
825             // emit initial value after this switch
826             break;
827 
828         case AVRCP_CTYPE_RESPONSE_CHANGED_STABLE:
829             // received change, event is considered de-registered
830             // we are re-enabling it automatically, if it is not
831             // explicitly disabled
832             connection->notifications_enabled &= reset_event_mask;
833             if ((connection->controller_notifications_to_deregister & event_mask) == 0){
834                 avrcp_controller_register_notification(connection, event_id);
835             } else {
836                 connection->controller_notifications_to_deregister &= reset_event_mask;
837                 connection->controller_notifications_to_register   &= reset_event_mask;
838                 connection->controller_initial_status_reported     &= reset_event_mask;
839                 avrcp_controller_emit_notification_complete(connection, ERROR_CODE_SUCCESS, event_id, false);
840             }
841             break;
842 
843         default:
844             return;
845     }
846 
847     avrcp_controller_emit_notification_for_event_id(connection->avrcp_cid, event_id, ctype, payload + pos, size - pos);
848 }
849 
850 #ifdef ENABLE_AVCTP_FRAGMENTATION
851 static void avctp_reassemble_message(avrcp_connection_t * connection, avctp_packet_type_t packet_type, uint8_t *packet, uint16_t size){
852     // after header (transaction label and packet type)
853     uint16_t pos;
854     uint16_t bytes_to_store;
855 
856     switch (packet_type){
857         case AVCTP_START_PACKET:
858             if (size < 2) return;
859 
860             // store header
861             pos = 0;
862             connection->avctp_reassembly_buffer[pos] = packet[pos];
863             pos++;
864             connection->avctp_reassembly_size = pos;
865 
866             // NOTE: num packets not needed for reassembly, ignoring it does not pose security risk -> no need to store it
867             pos++;
868 
869             // PID in reassembled packet is at offset 1, it will be read later after the avctp_reassemble_message with AVCTP_END_PACKET is called
870 
871             bytes_to_store = btstack_min(size - pos, sizeof(connection->avctp_reassembly_buffer) - connection->avctp_reassembly_size);
872             memcpy(&connection->avctp_reassembly_buffer[connection->avctp_reassembly_size], &packet[pos], bytes_to_store);
873             connection->avctp_reassembly_size += bytes_to_store;
874             break;
875 
876         case AVCTP_CONTINUE_PACKET:
877         case AVCTP_END_PACKET:
878             if (size < 1) return;
879 
880             // store remaining data, ignore header
881             pos = 1;
882             bytes_to_store = btstack_min(size - pos, sizeof(connection->avctp_reassembly_buffer) - connection->avctp_reassembly_size);
883             memcpy(&connection->avctp_reassembly_buffer[connection->avctp_reassembly_size], &packet[pos], bytes_to_store);
884             connection->avctp_reassembly_size += bytes_to_store;
885             break;
886 
887         default:
888             return;
889     }
890 }
891 #endif
892 
893 static void avrcp_handle_l2cap_data_packet_for_signaling_connection(avrcp_connection_t * connection, uint8_t *packet, uint16_t size){
894     if (size < 6u) return;
895     uint8_t  pdu_id;
896     avrcp_packet_type_t  vendor_dependent_avrcp_packet_type;
897 
898     uint16_t pos = 0;
899     connection->controller_last_confirmed_transaction_id = packet[pos] >> 4;
900     avrcp_frame_type_t  frame_type =  (avrcp_frame_type_t)((packet[pos] >> 1) & 0x01);
901     avctp_packet_type_t packet_type = (avctp_packet_type_t)((packet[pos] >> 2) & 0x03);
902     pos++;
903 
904     if (frame_type != AVRCP_RESPONSE_FRAME) return;
905 
906     switch (packet_type){
907         case AVCTP_SINGLE_PACKET:
908             break;
909 
910 #ifdef ENABLE_AVCTP_FRAGMENTATION
911         case AVCTP_START_PACKET:
912         case AVCTP_CONTINUE_PACKET:
913             avctp_reassemble_message(connection, packet_type, packet, size);
914             return;
915 
916         case AVCTP_END_PACKET:
917             avctp_reassemble_message(connection, packet_type, packet, size);
918 
919             packet = connection->avctp_reassembly_buffer;
920             size   = connection->avctp_reassembly_size;
921             break;
922 #endif
923 
924         default:
925             return;
926     }
927 
928     pos += 2; // PID
929 
930     avrcp_command_type_t ctype = (avrcp_command_type_t) packet[pos++];
931 
932 #ifdef ENABLE_LOG_INFO
933     uint8_t byte_value = packet[pos];
934     avrcp_subunit_type_t subunit_type = (avrcp_subunit_type_t) (byte_value >> 3);
935     avrcp_subunit_type_t subunit_id   = (avrcp_subunit_type_t) (byte_value & 0x07);
936 #endif
937     pos++;
938 
939     uint8_t opcode = packet[pos++];
940     uint16_t param_length;
941 
942     switch (opcode){
943         case AVRCP_CMD_OPCODE_SUBUNIT_INFO:{
944             if (connection->state != AVCTP_W2_RECEIVE_RESPONSE) return;
945             connection->state = AVCTP_CONNECTION_OPENED;
946 
947 #ifdef ENABLE_LOG_INFO
948             // page, extension code (1)
949             pos++;
950             uint8_t unit_type = packet[pos] >> 3;
951             uint8_t max_subunit_ID = packet[pos] & 0x07;
952             log_info("SUBUNIT INFO response: ctype 0x%02x (0C), subunit_type 0x%02x (1F), subunit_id 0x%02x (07), opcode 0x%02x (30), target_unit_type 0x%02x, max_subunit_ID %d", ctype, subunit_type, subunit_id, opcode, unit_type, max_subunit_ID);
953 #endif
954             break;
955         }
956         case AVRCP_CMD_OPCODE_UNIT_INFO:{
957             if (connection->state != AVCTP_W2_RECEIVE_RESPONSE) return;
958             connection->state = AVCTP_CONNECTION_OPENED;
959 
960 #ifdef ENABLE_LOG_INFO
961             // byte value 7 (1)
962             pos++;
963             uint8_t unit_type = packet[pos] >> 3;
964             uint8_t unit = packet[pos] & 0x07;
965             pos++;
966             uint32_t company_id = big_endian_read_24(packet, pos);
967             log_info("UNIT INFO response: ctype 0x%02x (0C), subunit_type 0x%02x (1F), subunit_id 0x%02x (07), opcode 0x%02x (30), target_unit_type 0x%02x, unit %d, company_id 0x%06" PRIx32,
968                 ctype, subunit_type, subunit_id, opcode, unit_type, unit, company_id);
969 #endif
970             break;
971         }
972         case AVRCP_CMD_OPCODE_VENDOR_DEPENDENT:
973             if ((size - pos) < 7){
974                 return;
975             }
976             // Company ID (3)
977             pos += 3;
978             // PDU ID (1)
979             pdu_id = packet[pos++];
980             // Packet Type (1)
981             vendor_dependent_avrcp_packet_type = (avrcp_packet_type_t)(packet[pos++] & 0x03);
982             // Param Length (2)
983             param_length = big_endian_read_16(packet, pos);
984             pos += 2;
985 
986             if ((size - pos) < param_length) {
987                 return;
988             }
989 
990             // handle asynchronous notifications, without changing state
991             if (pdu_id == AVRCP_PDU_ID_REGISTER_NOTIFICATION){
992                 avrcp_controller_handle_notification(connection, ctype, packet + pos, size - pos);
993                 break;
994             }
995             if (connection->state != AVCTP_W2_RECEIVE_RESPONSE) return;
996             connection->state = AVCTP_CONNECTION_OPENED;
997 
998             log_info("VENDOR DEPENDENT response: pdu id 0x%02x, param_length %d, status %s", pdu_id, param_length, avrcp_ctype2str(ctype));
999             switch (pdu_id){
1000                 case AVRCP_PDU_ID_GET_CURRENT_PLAYER_APPLICATION_SETTING_VALUE:{
1001                     uint8_t num_attributes = packet[pos++];
1002                     int i;
1003                     avrcp_repeat_mode_t  repeat_mode =  AVRCP_REPEAT_MODE_INVALID;
1004                     avrcp_shuffle_mode_t shuffle_mode = AVRCP_SHUFFLE_MODE_INVALID;
1005                     for (i = 0; i < num_attributes; i++){
1006                         avrcp_player_application_setting_attribute_id_t attribute_id = (avrcp_player_application_setting_attribute_id_t)packet[pos++];
1007                         uint8_t value = packet[pos++];
1008                         switch (attribute_id){
1009                             case AVRCP_PLAYER_APPLICATION_SETTING_ATTRIBUTE_ID_REPEAT_MODE_STATUS:
1010                                 repeat_mode = (avrcp_repeat_mode_t) value;
1011                                 break;
1012                             case AVRCP_PLAYER_APPLICATION_SETTING_ATTRIBUTE_ID_SHUFFLE_STATUS:
1013                                 shuffle_mode = (avrcp_shuffle_mode_t) value;
1014                                 break;
1015                             default:
1016                                 break;
1017                         }
1018                     }
1019                     avrcp_controller_emit_repeat_and_shuffle_mode(avrcp_controller_context.avrcp_callback, connection->avrcp_cid, ctype, repeat_mode, shuffle_mode);
1020                     break;
1021                 }
1022 
1023                 case AVRCP_PDU_ID_LIST_PLAYER_APPLICATION_SETTING_ATTRIBUTES:{
1024                     uint8_t num_attributes = packet[pos++];
1025                     int i;
1026                     for (i = 0; i < num_attributes; i++){
1027                         avrcp_player_application_setting_attribute_id_t attribute_id = (avrcp_player_application_setting_attribute_id_t)packet[pos++];
1028                         log_info("TODO send event: attribute_id %d", attribute_id);
1029                     }
1030                     break;
1031                 }
1032 
1033                 case AVRCP_PDU_ID_LIST_PLAYER_APPLICATION_SETTING_VALUES:{
1034                     uint8_t num_setting_values = packet[pos++];
1035                     int i;
1036                     for (i = 0; i < num_setting_values; i++){
1037                         uint8_t value = packet[pos++];
1038                         log_info("TODO send event: value %d", value);
1039                     }
1040                     break;
1041                 }
1042 
1043                 case AVRCP_PDU_ID_GET_PLAYER_APPLICATION_SETTING_ATTRIBUTE_TEXT:{
1044                     uint8_t num_attributes = packet[pos++];
1045 
1046                     int i;
1047                     avrcp_repeat_mode_t  repeat_mode =  AVRCP_REPEAT_MODE_INVALID;
1048                     avrcp_shuffle_mode_t shuffle_mode = AVRCP_SHUFFLE_MODE_INVALID;
1049                     for (i = 0; i < num_attributes; i++){
1050                         avrcp_player_application_setting_attribute_id_t attribute_id = (avrcp_player_application_setting_attribute_id_t)packet[pos++];
1051                         uint8_t character_set_id = little_endian_read_16(packet, pos);
1052                         pos += 2;
1053                         uint8_t value_len = packet[pos++];
1054                         char * value = (char *)&packet[pos];
1055                         pos += value_len;
1056 
1057                         log_info("TODO send event: attribute_id %d, value_len %d, value %s", attribute_id, value_len, value);
1058                         switch (attribute_id){
1059                             case AVRCP_PLAYER_APPLICATION_SETTING_ATTRIBUTE_ID_REPEAT_MODE_STATUS:
1060                                 break;
1061                             case AVRCP_PLAYER_APPLICATION_SETTING_ATTRIBUTE_ID_SHUFFLE_STATUS:
1062                                 break;
1063                             default:
1064                                 break;
1065                         }
1066                     }
1067                     break;
1068                 }
1069 
1070                 case AVRCP_PDU_ID_GET_PLAYER_APPLICATION_SETTING_VALUE_TEXT:{
1071                     uint8_t num_setting_values = packet[pos++];
1072                     int i;
1073                     for (i = 0; i < num_setting_values; i++){
1074                         uint8_t value = packet[pos++];
1075                         log_info("TODO send event: value %d", value);
1076                     }
1077                     break;
1078                 }
1079 
1080                 case AVRCP_PDU_ID_INFORM_DISPLAYABLE_CHARACTERSET:
1081                 case AVRCP_PDU_ID_INFORM_BATTERY_STATUS_OF_CT:
1082                     break;
1083 
1084                 case AVRCP_PDU_ID_SET_PLAYER_APPLICATION_SETTING_VALUE:{
1085                     uint16_t offset = 0;
1086                     uint8_t event[6];
1087                     event[offset++] = HCI_EVENT_AVRCP_META;
1088                     event[offset++] = sizeof(event) - 2;
1089                     event[offset++] = AVRCP_SUBEVENT_PLAYER_APPLICATION_VALUE_RESPONSE;
1090                     little_endian_store_16(event, offset, connection->avrcp_cid);
1091                     offset += 2;
1092                     event[offset++] = ctype;
1093                     (*avrcp_controller_context.avrcp_callback)(HCI_EVENT_PACKET, 0, event, sizeof(event));
1094                     break;
1095                 }
1096 
1097                 case AVRCP_PDU_ID_SET_ABSOLUTE_VOLUME:{
1098                     uint16_t offset = 0;
1099                     uint8_t event[7];
1100                     event[offset++] = HCI_EVENT_AVRCP_META;
1101                     event[offset++] = sizeof(event) - 2;
1102                     event[offset++] = AVRCP_SUBEVENT_SET_ABSOLUTE_VOLUME_RESPONSE;
1103                     little_endian_store_16(event, offset, connection->avrcp_cid);
1104                     offset += 2;
1105                     event[offset++] = ctype;
1106                     event[offset++] = packet[pos++];
1107                     (*avrcp_controller_context.avrcp_callback)(HCI_EVENT_PACKET, 0, event, sizeof(event));
1108                     break;
1109                 }
1110 
1111                 case AVRCP_PDU_ID_GET_CAPABILITIES:{
1112                     avrcp_capability_id_t capability_id = (avrcp_capability_id_t) packet[pos++];
1113                     uint8_t capability_count = 0;
1114                     if (param_length > 1){
1115                         capability_count = packet[pos++];
1116                     }
1117                     uint16_t i;
1118                     uint16_t offset;
1119                     uint8_t event[10];
1120 
1121                     switch (capability_id){
1122 
1123                         case AVRCP_CAPABILITY_ID_COMPANY:
1124                             for (i = 0; (i < capability_count) && ((size - pos) >= 3); i++){
1125                                 uint32_t company_id = big_endian_read_24(packet, pos);
1126                                 pos += 3;
1127                                 log_info("  0x%06" PRIx32 ", ", company_id);
1128 
1129                                 offset = 0;
1130                                 event[offset++] = HCI_EVENT_AVRCP_META;
1131                                 event[offset++] = sizeof(event) - 2;
1132                                 event[offset++] = AVRCP_SUBEVENT_GET_CAPABILITY_COMPANY_ID;
1133                                 little_endian_store_16(event, offset, connection->avrcp_cid);
1134                                 offset += 2;
1135                                 event[offset++] = ctype;
1136                                 event[offset++] = 0;
1137                                 little_endian_store_24(event, offset, company_id);
1138                                 offset += 3;
1139                                 (*avrcp_controller_context.avrcp_callback)(HCI_EVENT_PACKET, 0, event, offset);
1140                             }
1141 
1142                             offset = 0;
1143                             event[offset++] = HCI_EVENT_AVRCP_META;
1144                             event[offset++] = sizeof(event) - 2;
1145                             event[offset++] = AVRCP_SUBEVENT_GET_CAPABILITY_COMPANY_ID_DONE;
1146                             little_endian_store_16(event, offset, connection->avrcp_cid);
1147                             offset += 2;
1148                             event[offset++] = ctype;
1149                             event[offset++] = 0;
1150                             (*avrcp_controller_context.avrcp_callback)(HCI_EVENT_PACKET, 0, event, offset);
1151                             break;
1152 
1153                         case AVRCP_CAPABILITY_ID_EVENT:
1154                             for (i = 0; (i < capability_count) && ((size - pos) >= 1); i++){
1155                                 uint8_t event_id = packet[pos++];
1156                                 connection->notifications_supported_by_target |= (1 << event_id);
1157                             }
1158 
1159                             connection->remote_capabilities_state = AVRCP_REMOTE_CAPABILITIES_KNOWN;
1160 
1161                             // if the get supported events query is triggered by avrcp_controller_enable_notification call,
1162                             // avrcp_controller_emit_supported_events should be suppressed
1163                             if (connection->controller_notifications_supported_by_target_suppress_emit_result){
1164                                 connection->controller_notifications_supported_by_target_suppress_emit_result = false;
1165                                 // also, notification might not be supported
1166                                 // if so, emit AVRCP_SUBEVENT_ENABLE_NOTIFICATION_COMPLETE event to app,
1167                                 // and update controller_notifications_to_register bitmap
1168                                 for (i = (uint8_t)AVRCP_NOTIFICATION_EVENT_FIRST_INDEX; i < (uint8_t) AVRCP_NOTIFICATION_EVENT_LAST_INDEX; i++){
1169                                     if ((connection->controller_notifications_to_register & (1 << i)) != 0){
1170                                         if ((connection->notifications_supported_by_target & (1 << i)) == 0){
1171                                             avrcp_controller_emit_notification_complete(connection, ERROR_CODE_UNSUPPORTED_FEATURE_OR_PARAMETER_VALUE, (uint8_t) i, false);
1172                                             connection->controller_notifications_to_register &= ~(1 << i);
1173                                         }
1174                                     }
1175                                 }
1176                                 break;
1177                             }
1178                             // supported events are emitted only if the get supported events query
1179                             // is triggered by avrcp_controller_get_supported_events call
1180                             avrcp_controller_emit_supported_events(connection);
1181                             break;
1182 
1183                         default:
1184                             // ignore
1185                             break;
1186                     }
1187                     break;
1188                 }
1189 
1190                 case AVRCP_PDU_ID_GET_PLAY_STATUS:{
1191                     uint32_t song_length = big_endian_read_32(packet, pos);
1192                     pos += 4;
1193                     uint32_t song_position = big_endian_read_32(packet, pos);
1194                     pos += 4;
1195                     uint8_t play_status = packet[pos];
1196 
1197                     uint8_t event[15];
1198                     int offset = 0;
1199                     event[offset++] = HCI_EVENT_AVRCP_META;
1200                     event[offset++] = sizeof(event) - 2;
1201                     event[offset++] = AVRCP_SUBEVENT_PLAY_STATUS;
1202                     little_endian_store_16(event, offset, connection->avrcp_cid);
1203                     offset += 2;
1204                     event[offset++] = ctype;
1205                     little_endian_store_32(event, offset, song_length);
1206                     offset += 4;
1207                     little_endian_store_32(event, offset, song_position);
1208                     offset += 4;
1209                     event[offset++] = play_status;
1210                     (*avrcp_controller_context.avrcp_callback)(HCI_EVENT_PACKET, 0, event, sizeof(event));
1211                     break;
1212                 }
1213 
1214                 case AVRCP_PDU_ID_GET_ELEMENT_ATTRIBUTES:
1215                     switch (vendor_dependent_avrcp_packet_type){
1216                         case AVRCP_START_PACKET:
1217                         case AVRCP_SINGLE_PACKET:
1218                             avrcp_parser_reset(connection);
1219                             connection->list_size = param_length;
1220                             // num_attributes
1221                             pos++;
1222 
1223                             avrcp_controller_parse_and_emit_element_attrs(packet+pos, size-pos, connection, ctype);
1224                             if (vendor_dependent_avrcp_packet_type == AVRCP_START_PACKET){
1225                                 avrcp_controller_request_continue_response(connection);
1226                                 return;
1227                             }
1228                             break;
1229                         case AVRCP_CONTINUE_PACKET:
1230                         case AVRCP_END_PACKET:
1231                             connection->controller_num_received_fragments++;
1232 
1233                             if (connection->controller_num_received_fragments < connection->controller_max_num_fragments){
1234                                 avrcp_controller_parse_and_emit_element_attrs(packet+pos, size-pos, connection, ctype);
1235 
1236                                 if (vendor_dependent_avrcp_packet_type == AVRCP_CONTINUE_PACKET){
1237                                     avrcp_controller_request_continue_response(connection);
1238                                     return;
1239                                 }
1240                             } else {
1241                                 avrcp_controller_emit_now_playing_info_event_done(avrcp_controller_context.avrcp_callback, connection->avrcp_cid, ctype, 1);
1242                                 avrcp_parser_reset(connection);
1243                                 avrcp_controller_request_abort_continuation(connection);
1244                                 return;
1245                             }
1246                             break;
1247                         default:
1248                             btstack_assert(false);
1249                             break;
1250                     }
1251                     break;
1252 
1253                 default:
1254                     // custom command response comes here
1255                     switch (pdu_id){
1256                         case AVRCP_PDU_ID_REQUEST_ABORT_CONTINUING_RESPONSE:
1257                             avrcp_controller_emit_now_playing_info_event_done(avrcp_controller_context.avrcp_callback, connection->avrcp_cid, ctype, 0);
1258                             break;
1259                         default:
1260                             if (pdu_id != connection->pdu_id) {
1261                                 break;
1262                             }
1263                             uint8_t *in_place_buffer = packet + pos - 9;
1264                             avrcp_controller_prepare_custom_command_response(connection, param_length,
1265                                                                              in_place_buffer);
1266                             (*avrcp_controller_context.avrcp_callback)(HCI_EVENT_PACKET, 0, in_place_buffer,
1267                                                                        param_length + 9);
1268 
1269                             break;
1270                     }
1271                     break;
1272             }
1273             break;
1274         case AVRCP_CMD_OPCODE_PASS_THROUGH:{
1275             if ((size - pos) < 1) return;
1276             uint8_t operation_id = packet[pos++];
1277             UNUSED(pos);
1278             switch (connection->state){
1279                 case AVCTP_W2_RECEIVE_PRESS_RESPONSE:
1280                     // trigger release for simple command:
1281                     if (!connection->controller_press_and_hold_cmd_active){
1282                         connection->state = AVCTP_W2_SEND_RELEASE_COMMAND;
1283                         break;
1284                     }
1285                     // for press and hold, send release if it just has been requested, otherwise, wait for next repeat
1286                     if (connection->controller_press_and_hold_cmd_release){
1287                         connection->controller_press_and_hold_cmd_release = false;
1288                         connection->state = AVCTP_W2_SEND_RELEASE_COMMAND;
1289                     } else {
1290                         connection->state = AVCTP_W4_STOP;
1291                     }
1292                     break;
1293                 case AVCTP_W2_RECEIVE_RESPONSE:
1294                     connection->state = AVCTP_CONNECTION_OPENED;
1295                     break;
1296                 default:
1297                     break;
1298             }
1299             if (connection->state == AVCTP_W4_STOP){
1300                 avrcp_controller_emit_operation_status(avrcp_controller_context.avrcp_callback, AVRCP_SUBEVENT_OPERATION_START, connection->avrcp_cid, ctype, operation_id);
1301             }
1302             if (connection->state == AVCTP_CONNECTION_OPENED) {
1303                 // RELEASE response
1304                 operation_id = operation_id & 0x7F;
1305                 avrcp_controller_emit_operation_status(avrcp_controller_context.avrcp_callback, AVRCP_SUBEVENT_OPERATION_COMPLETE, connection->avrcp_cid, ctype, operation_id);
1306             }
1307             if (connection->state == AVCTP_W2_SEND_RELEASE_COMMAND){
1308                 // PRESS response
1309                 avrcp_controller_request_pass_through_release_control_cmd(connection);
1310             }
1311             break;
1312         }
1313         default:
1314             break;
1315     }
1316 
1317     // trigger pending notification reqistrations
1318     if ((connection->state == AVCTP_CONNECTION_OPENED) && connection->controller_notifications_to_register){
1319         avrcp_request_can_send_now(connection, connection->l2cap_signaling_cid);
1320     }
1321 }
1322 
1323 static void avrcp_controller_handle_can_send_now(avrcp_connection_t * connection){
1324     // identifier (9) + num attributes (1) + attributes (4 * num attributes)
1325     uint8_t get_element_attributes_command[9+8*((AVRCP_MEDIA_ATTR_RESERVED-AVRCP_MEDIA_ATTR_TITLE) + 1)];
1326     uint16_t pos;
1327     uint16_t num_attributes_index;
1328     uint8_t i;
1329 
1330     switch (connection->state){
1331         case AVCTP_W2_SEND_PRESS_COMMAND:
1332             avrcp_send_cmd_with_avctp_fragmentation(connection);
1333             connection->state = AVCTP_W2_RECEIVE_PRESS_RESPONSE;
1334             return;
1335 
1336         case AVCTP_W2_SEND_RELEASE_COMMAND:
1337             avrcp_send_cmd_with_avctp_fragmentation(connection);
1338             connection->state = AVCTP_W2_RECEIVE_RESPONSE;
1339             return;
1340 
1341         case AVCTP_W2_SEND_COMMAND:
1342             avrcp_send_cmd_with_avctp_fragmentation(connection);
1343             if (connection->data_offset < connection->data_len){
1344                 // continue AVCTP fragmentation
1345                 avrcp_request_can_send_now(connection, connection->l2cap_signaling_cid);
1346                 return;
1347             }
1348             connection->state = AVCTP_W2_RECEIVE_RESPONSE;
1349             return;
1350         case AVCTP_W2_SEND_GET_ELEMENT_ATTRIBUTES_REQUEST:
1351             // build command in local buffer
1352             pos = 0;
1353             connection->data = get_element_attributes_command;
1354             // write identifier
1355             memset(connection->data, 0, 8);
1356             pos += 8;
1357             num_attributes_index = pos;
1358             // If num_attributes is set to zero, all attribute information shall be returned,
1359             // and the AttributeID field is omitted
1360             connection->data[num_attributes_index] = 0;
1361             pos++;
1362             for (i = 0; i < (uint8_t)AVRCP_MEDIA_ATTR_RESERVED - (uint8_t)AVRCP_MEDIA_ATTR_TITLE; i++){
1363                 if ((connection->controller_element_attributes & (1<<i)) != 0){
1364                     // every attribute is 4 bytes long
1365                     big_endian_store_32(connection->data, pos, AVRCP_MEDIA_ATTR_TITLE + i);
1366                     pos += 4;
1367                     connection->data[num_attributes_index]++;
1368                 }
1369             }
1370 
1371             // Parameter Length
1372             connection->data_len = pos;
1373 
1374             log_info("AVCTP_W2_SEND_GET_ELEMENT_ATTRIBUTES_REQUEST, len %u", connection->data_len);
1375 
1376             // send data - assume it will fit into one packet
1377             avrcp_send_cmd_with_avctp_fragmentation(connection);
1378             connection->state = AVCTP_W2_RECEIVE_RESPONSE;
1379             return;
1380         default:
1381             break;
1382     }
1383 
1384     // send register notification if queued,
1385     // avrcp_handle_l2cap_data_packet_for_signaling_connection will trigger next one
1386     if (connection->controller_notifications_to_register != 0){
1387         uint8_t event_id;
1388         for (event_id = (uint8_t)AVRCP_NOTIFICATION_EVENT_FIRST_INDEX; event_id < (uint8_t)AVRCP_NOTIFICATION_EVENT_LAST_INDEX; event_id++){
1389             if (connection->controller_notifications_to_register & (1 << event_id)){
1390                 connection->controller_notifications_to_register &= ~ (1 << event_id);
1391                 avrcp_send_register_notification(connection, event_id);
1392                 return;
1393             }
1394         }
1395     }
1396 }
1397 
1398 static void avrcp_controller_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){
1399     avrcp_connection_t * connection;
1400 
1401     switch (packet_type) {
1402         case L2CAP_DATA_PACKET:
1403             connection = avrcp_get_connection_for_l2cap_signaling_cid_for_role(AVRCP_CONTROLLER, channel);
1404             avrcp_handle_l2cap_data_packet_for_signaling_connection(connection, packet, size);
1405             break;
1406 
1407         case HCI_EVENT_PACKET:
1408             switch (hci_event_packet_get_type(packet)){
1409                 case L2CAP_EVENT_CAN_SEND_NOW:
1410                     connection = avrcp_get_connection_for_l2cap_signaling_cid_for_role(AVRCP_CONTROLLER, channel);
1411                     avrcp_controller_handle_can_send_now(connection);
1412                     break;
1413             default:
1414                 break;
1415         }
1416         default:
1417             break;
1418     }
1419 }
1420 
1421 void avrcp_controller_create_sdp_record(uint8_t * service, uint32_t service_record_handle, uint16_t supported_features, const char * service_name, const char * service_provider_name){
1422     if (service_name == NULL){
1423         service_name = avrcp_default_controller_service_name;
1424     }
1425     if (service_provider_name == NULL){
1426         service_provider_name = avrcp_default_controller_service_provider_name;
1427     }
1428     avrcp_create_sdp_record(true, service, service_record_handle, avrcp_controller_supports_browsing(supported_features), supported_features, service_name, service_provider_name);
1429 }
1430 
1431 void avrcp_controller_init(void){
1432     avrcp_controller_context.role = AVRCP_CONTROLLER;
1433     avrcp_controller_context.packet_handler = avrcp_controller_packet_handler;
1434     avrcp_register_controller_packet_handler(&avrcp_controller_packet_handler);
1435 }
1436 
1437 void avrcp_controller_deinit(void){
1438     memset(&avrcp_controller_context, 0, sizeof(avrcp_context_t));
1439 }
1440 
1441 void avrcp_controller_register_packet_handler(btstack_packet_handler_t callback){
1442     btstack_assert(callback != NULL);
1443     avrcp_controller_context.avrcp_callback = callback;
1444 }
1445 
1446 
1447 uint8_t avrcp_controller_play(uint16_t avrcp_cid){
1448     return request_single_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_PLAY, 0);
1449 }
1450 
1451 uint8_t avrcp_controller_stop(uint16_t avrcp_cid){
1452     return request_single_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_STOP, 0);
1453 }
1454 
1455 uint8_t avrcp_controller_pause(uint16_t avrcp_cid){
1456     return request_single_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_PAUSE, 0);
1457 }
1458 
1459 uint8_t avrcp_controller_forward(uint16_t avrcp_cid){
1460     return request_single_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_FORWARD, 0);
1461 }
1462 
1463 uint8_t avrcp_controller_backward(uint16_t avrcp_cid){
1464     return request_single_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_BACKWARD, 0);
1465 }
1466 
1467 uint8_t avrcp_controller_volume_up(uint16_t avrcp_cid){
1468     return request_single_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_VOLUME_UP, 0);
1469 }
1470 
1471 uint8_t avrcp_controller_volume_down(uint16_t avrcp_cid){
1472     return request_single_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_VOLUME_DOWN, 0);
1473 }
1474 
1475 uint8_t avrcp_controller_mute(uint16_t avrcp_cid){
1476     return request_single_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_MUTE, 0);
1477 }
1478 
1479 uint8_t avrcp_controller_skip(uint16_t avrcp_cid){
1480     return request_single_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_SKIP, 0);
1481 }
1482 
1483 uint8_t avrcp_controller_fast_forward(uint16_t avrcp_cid){
1484     return request_single_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_FAST_FORWARD, 0);
1485 }
1486 
1487 uint8_t avrcp_controller_rewind(uint16_t avrcp_cid){
1488     return request_single_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_REWIND, 0);
1489 }
1490 
1491 /* start continuous cmds */
1492 
1493 uint8_t avrcp_controller_start_press_and_hold_cmd(uint16_t avrcp_cid, avrcp_operation_id_t operation_id){
1494     return request_continuous_pass_through_press_control_cmd(avrcp_cid, operation_id, 0);
1495 }
1496 
1497 uint8_t avrcp_controller_press_and_hold_play(uint16_t avrcp_cid){
1498     return request_continuous_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_PLAY, 0);
1499 }
1500 uint8_t avrcp_controller_press_and_hold_stop(uint16_t avrcp_cid){
1501     return request_continuous_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_STOP, 0);
1502 }
1503 uint8_t avrcp_controller_press_and_hold_pause(uint16_t avrcp_cid){
1504     return request_continuous_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_PAUSE, 0);
1505 }
1506 uint8_t avrcp_controller_press_and_hold_forward(uint16_t avrcp_cid){
1507     return request_continuous_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_FORWARD, 0);
1508 }
1509 uint8_t avrcp_controller_press_and_hold_backward(uint16_t avrcp_cid){
1510     return request_continuous_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_BACKWARD, 0);
1511 }
1512 uint8_t avrcp_controller_press_and_hold_fast_forward(uint16_t avrcp_cid){
1513     return request_continuous_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_FAST_FORWARD, 0);
1514 }
1515 uint8_t avrcp_controller_press_and_hold_rewind(uint16_t avrcp_cid){
1516     return request_continuous_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_REWIND, 0);
1517 }
1518 uint8_t avrcp_controller_press_and_hold_volume_up(uint16_t avrcp_cid){
1519     return request_continuous_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_VOLUME_UP, 0);
1520 }
1521 uint8_t avrcp_controller_press_and_hold_volume_down(uint16_t avrcp_cid){
1522     return request_continuous_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_VOLUME_DOWN, 0);
1523 }
1524 uint8_t avrcp_controller_press_and_hold_mute(uint16_t avrcp_cid){
1525     return request_continuous_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_MUTE, 0);
1526 }
1527 
1528 uint8_t avrcp_controller_0(uint16_t avrcp_cid){
1529     return request_single_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_0, 0);
1530 }
1531 uint8_t avrcp_controller_1(uint16_t avrcp_cid){
1532     return request_single_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_1, 0);
1533 }
1534 uint8_t avrcp_controller_2(uint16_t avrcp_cid){
1535     return request_single_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_2, 0);
1536 }
1537 uint8_t avrcp_controller_3(uint16_t avrcp_cid){
1538     return request_single_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_3, 0);
1539 }
1540 uint8_t avrcp_controller_4(uint16_t avrcp_cid){
1541     return request_single_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_4, 0);
1542 }
1543 uint8_t avrcp_controller_5(uint16_t avrcp_cid){
1544     return request_single_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_5, 0);
1545 }
1546 uint8_t avrcp_controller_6(uint16_t avrcp_cid){
1547     return request_single_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_6, 0);
1548 }
1549 uint8_t avrcp_controller_7(uint16_t avrcp_cid){
1550     return request_single_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_7, 0);
1551 }
1552 uint8_t avrcp_controller_8(uint16_t avrcp_cid){
1553     return request_single_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_8, 0);
1554 }
1555 uint8_t avrcp_controller_9(uint16_t avrcp_cid){
1556     return request_single_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_9, 0);
1557 }
1558 uint8_t avrcp_controller_dot(uint16_t avrcp_cid){
1559     return request_single_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_DOT, 0);
1560 }
1561 uint8_t avrcp_controller_enter(uint16_t avrcp_cid){
1562     return request_single_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_ENTER, 0);
1563 }
1564 uint8_t avrcp_controller_clear(uint16_t avrcp_cid){
1565     return request_single_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_CLEAR, 0);
1566 }
1567 uint8_t avrcp_controller_channel_up(uint16_t avrcp_cid){
1568     return request_single_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_CHANNEL_UP, 0);
1569 }
1570 uint8_t avrcp_controller_channel_down(uint16_t avrcp_cid){
1571     return request_single_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_CHANNEL_DOWN, 0);
1572 }
1573 uint8_t avrcp_controller_previous_channel(uint16_t avrcp_cid){
1574     return request_single_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_PREVIOUS_CHANNEL, 0);
1575 }
1576 uint8_t avrcp_controller_sound_select(uint16_t avrcp_cid){
1577     return request_single_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_SOUND_SELECT, 0);
1578 }
1579 uint8_t avrcp_controller_input_select(uint16_t avrcp_cid){
1580     return request_single_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_INPUT_SELECT, 0);
1581 }
1582 uint8_t avrcp_controller_display_information(uint16_t avrcp_cid){
1583     return request_single_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_DISPLAY_INFORMATION, 0);
1584 }
1585 uint8_t avrcp_controller_help(uint16_t avrcp_cid){
1586     return request_single_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_HELP, 0);
1587 }
1588 uint8_t avrcp_controller_power(uint16_t avrcp_cid){
1589     return request_single_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_POWER, 0);
1590 }
1591 uint8_t avrcp_controller_angle(uint16_t avrcp_cid){
1592     return request_single_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_ANGLE, 0);
1593 }
1594 uint8_t avrcp_controller_subpicture(uint16_t avrcp_cid){
1595     return request_single_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_SUBPICTURE, 0);
1596 }
1597 uint8_t avrcp_controller_F1(uint16_t avrcp_cid){
1598     return request_single_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_F1, 0);
1599 }
1600 uint8_t avrcp_controller_F2(uint16_t avrcp_cid){
1601     return request_single_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_F2, 0);
1602 }
1603 uint8_t avrcp_controller_F3(uint16_t avrcp_cid){
1604     return request_single_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_F3, 0);
1605 }
1606 uint8_t avrcp_controller_F4(uint16_t avrcp_cid){
1607     return request_single_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_F4, 0);
1608 }
1609 uint8_t avrcp_controller_F5(uint16_t avrcp_cid){
1610     return request_single_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_F5, 0);
1611 }
1612 
1613 uint8_t avrcp_controller_select(uint16_t avrcp_cid){
1614     return request_single_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_SELECT, 0);
1615 }
1616 uint8_t avrcp_controller_up(uint16_t avrcp_cid){
1617     return request_single_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_UP, 0);
1618 }
1619 uint8_t avrcp_controller_down(uint16_t avrcp_cid){
1620     return request_single_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_DOWN, 0);
1621 }
1622 uint8_t avrcp_controller_left(uint16_t avrcp_cid){
1623     return request_single_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_LEFT, 0);
1624 }
1625 uint8_t avrcp_controller_right(uint16_t avrcp_cid){
1626     return request_single_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_RIGHT, 0);
1627 }
1628 uint8_t avrcp_controller_right_up(uint16_t avrcp_cid){
1629     return request_single_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_RIGHT_UP, 0);
1630 }
1631 uint8_t avrcp_controller_right_down(uint16_t avrcp_cid){
1632     return request_single_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_RIGHT_DOWN, 0);
1633 }
1634 uint8_t avrcp_controller_left_up(uint16_t avrcp_cid){
1635     return request_single_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_LEFT_UP, 0);
1636 }
1637 uint8_t avrcp_controller_left_down(uint16_t avrcp_cid){
1638     return request_single_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_LEFT_DOWN, 0);
1639 }
1640 uint8_t avrcp_controller_root_menu(uint16_t avrcp_cid){
1641     return request_single_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_ROOT_MENU, 0);
1642 }
1643 uint8_t avrcp_controller_setup_menu(uint16_t avrcp_cid){
1644     return request_single_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_SETUP_MENU, 0);
1645 }
1646 uint8_t avrcp_controller_contents_menu(uint16_t avrcp_cid){
1647     return request_single_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_CONTENTS_MENU, 0);
1648 }
1649 uint8_t avrcp_controller_favorite_menu(uint16_t avrcp_cid){
1650     return request_single_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_FAVORITE_MENU, 0);
1651 }
1652 uint8_t avrcp_controller_exit(uint16_t avrcp_cid){
1653     return request_single_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_EXIT, 0);
1654 }
1655 uint8_t avrcp_controller_page_up(uint16_t avrcp_cid){
1656     return request_single_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_PAGE_UP, 0);
1657 }
1658 uint8_t avrcp_controller_page_down(uint16_t avrcp_cid){
1659     return request_single_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_PAGE_DOWN, 0);
1660 }
1661 
1662 static uint8_t avrcp_controller_request_group_pass_through_press_control_cmd(uint16_t avrcp_cid, avrcp_group_operation_id_t opid){
1663     log_info("Send group command %d", opid);
1664     avrcp_connection_t * connection = avrcp_get_connection_for_avrcp_cid_for_role(AVRCP_CONTROLLER, avrcp_cid);
1665     if (!connection){
1666         return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
1667     }
1668 
1669     if (connection->state != AVCTP_CONNECTION_OPENED){
1670         log_error("Connection in wrong state %d, expected %d. avrcp cid 0x%02x", connection->state, AVCTP_CONNECTION_OPENED, avrcp_cid);
1671         return ERROR_CODE_COMMAND_DISALLOWED;
1672     }
1673     connection->state = AVCTP_W2_SEND_PRESS_COMMAND;
1674     avrcp_controller_pass_through_command_data_init(connection, AVRCP_OPERATION_ID_VENDOR_UNIQUE);
1675     connection->company_id = BT_SIG_COMPANY_ID;
1676     connection->data_len = 5;
1677     big_endian_store_24(connection->data, 0, BT_SIG_COMPANY_ID);
1678     big_endian_store_16(connection->data, 3, opid);
1679 
1680     avrcp_request_can_send_now(connection, connection->l2cap_signaling_cid);
1681     return ERROR_CODE_SUCCESS;
1682 }
1683 
1684 uint8_t avrcp_controller_next_group(uint16_t avrcp_cid){
1685     return avrcp_controller_request_group_pass_through_press_control_cmd(avrcp_cid, AVRCP_GROUP_OPERATION_ID_GOTO_NEXT);
1686 }
1687 
1688 uint8_t avrcp_controller_previous_group(uint16_t avrcp_cid){
1689     return avrcp_controller_request_group_pass_through_press_control_cmd(avrcp_cid, AVRCP_GROUP_OPERATION_ID_GOTO_PREVIOUS);
1690 }
1691 
1692 
1693 /* stop continuous cmds */
1694 uint8_t avrcp_controller_release_press_and_hold_cmd(uint16_t avrcp_cid){
1695     avrcp_connection_t * connection = avrcp_get_connection_for_avrcp_cid_for_role(AVRCP_CONTROLLER, avrcp_cid);
1696     if (!connection){
1697         return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
1698     }
1699 
1700     switch (connection->state){
1701         // respond when we receive response for (repeated) press command
1702         case AVCTP_W2_RECEIVE_PRESS_RESPONSE:
1703             connection->controller_press_and_hold_cmd_release = true;
1704             break;
1705 
1706         // release already sent or on the way, nothing to do
1707         case AVCTP_W2_RECEIVE_RESPONSE:
1708         case AVCTP_W2_SEND_RELEASE_COMMAND:
1709             break;
1710 
1711         // about to send next repeated press command or wait for it -> release right away
1712         case AVCTP_W2_SEND_PRESS_COMMAND:
1713         case AVCTP_W4_STOP:
1714             return avrcp_controller_request_pass_through_release_control_cmd(connection);
1715 
1716         // otherwise reject request
1717         default:
1718             return ERROR_CODE_COMMAND_DISALLOWED;
1719     }
1720     return ERROR_CODE_SUCCESS;
1721 }
1722 
1723 uint8_t avrcp_controller_enable_notification(uint16_t avrcp_cid, avrcp_notification_event_id_t event_id){
1724     avrcp_connection_t * connection = avrcp_get_connection_for_avrcp_cid_for_role(AVRCP_CONTROLLER, avrcp_cid);
1725     if (!connection){
1726         return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
1727     }
1728     return avrcp_controller_register_notification(connection, event_id);
1729 }
1730 
1731 uint8_t avrcp_controller_disable_notification(uint16_t avrcp_cid, avrcp_notification_event_id_t event_id){
1732     avrcp_connection_t * connection = avrcp_get_connection_for_avrcp_cid_for_role(AVRCP_CONTROLLER, avrcp_cid);
1733     if (!connection){
1734         return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
1735     }
1736     if (connection->remote_capabilities_state != AVRCP_REMOTE_CAPABILITIES_KNOWN){
1737         return ERROR_CODE_COMMAND_DISALLOWED;
1738     }
1739 
1740     if ((connection->notifications_supported_by_target & (1 << event_id)) == 0){
1741         return ERROR_CODE_UNSUPPORTED_FEATURE_OR_PARAMETER_VALUE;
1742     }
1743 
1744     if ((connection->notifications_enabled & (1 << event_id)) == 0){
1745         return ERROR_CODE_SUCCESS;
1746     }
1747 
1748     connection->controller_notifications_to_deregister |= (1 << event_id);
1749     return ERROR_CODE_SUCCESS;
1750 }
1751 
1752 uint8_t avrcp_controller_unit_info(uint16_t avrcp_cid){
1753     avrcp_connection_t * connection = avrcp_get_connection_for_avrcp_cid_for_role(AVRCP_CONTROLLER, avrcp_cid);
1754     if (!connection){
1755         return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
1756     }
1757     if (connection->state != AVCTP_CONNECTION_OPENED) return ERROR_CODE_COMMAND_DISALLOWED;
1758 
1759     connection->state = AVCTP_W2_SEND_COMMAND;
1760     avrcp_controller_custom_command_data_init(connection, AVRCP_CMD_OPCODE_UNIT_INFO, AVRCP_CTYPE_STATUS,
1761                                               AVRCP_SUBUNIT_TYPE_UNIT, AVRCP_SUBUNIT_ID_IGNORE, AVRCP_PDU_ID_UNDEFINED,
1762                                               0);
1763 
1764     connection->data = connection->message_body;
1765     memset(connection->data, 0xFF, 5);
1766     connection->data_len = 5;
1767     avrcp_request_can_send_now(connection, connection->l2cap_signaling_cid);
1768     return ERROR_CODE_SUCCESS;
1769 }
1770 
1771 uint8_t avrcp_controller_subunit_info(uint16_t avrcp_cid){
1772     avrcp_connection_t * connection = avrcp_get_connection_for_avrcp_cid_for_role(AVRCP_CONTROLLER, avrcp_cid);
1773     if (!connection){
1774         return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
1775     }
1776     if (connection->state != AVCTP_CONNECTION_OPENED) return ERROR_CODE_COMMAND_DISALLOWED;
1777 
1778     connection->state = AVCTP_W2_SEND_COMMAND;
1779     avrcp_controller_custom_command_data_init(connection, AVRCP_CMD_OPCODE_SUBUNIT_INFO, AVRCP_CTYPE_STATUS,
1780                                               AVRCP_SUBUNIT_TYPE_UNIT, AVRCP_SUBUNIT_ID_IGNORE, AVRCP_PDU_ID_UNDEFINED,
1781                                               0);
1782 
1783     connection->data = connection->message_body;
1784     memset(connection->data, 0xFF, 5);
1785     connection->data[0] = 7; // page: 0, extension_code: 7
1786     connection->data_len = 5;
1787     avrcp_request_can_send_now(connection, connection->l2cap_signaling_cid);
1788     return ERROR_CODE_SUCCESS;
1789 }
1790 
1791 uint8_t avrcp_controller_get_supported_company_ids(uint16_t avrcp_cid){
1792     avrcp_connection_t * connection = avrcp_get_connection_for_avrcp_cid_for_role(AVRCP_CONTROLLER, avrcp_cid);
1793     if (!connection){
1794         return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
1795     }
1796     if (connection->state != AVCTP_CONNECTION_OPENED){
1797         return ERROR_CODE_COMMAND_DISALLOWED;
1798     }
1799     avrcp_controller_get_capabilities_for_connection(connection, AVRCP_CAPABILITY_ID_COMPANY);
1800     return ERROR_CODE_SUCCESS;
1801 }
1802 
1803 uint8_t avrcp_controller_get_supported_events(uint16_t avrcp_cid){
1804     avrcp_connection_t * connection = avrcp_get_connection_for_avrcp_cid_for_role(AVRCP_CONTROLLER, avrcp_cid);
1805     if (!connection){
1806         return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
1807     }
1808     if (connection->state != AVCTP_CONNECTION_OPENED){
1809         return ERROR_CODE_COMMAND_DISALLOWED;
1810     }
1811 
1812     switch (connection->remote_capabilities_state){
1813         case AVRCP_REMOTE_CAPABILITIES_NONE:
1814             connection->remote_capabilities_state = AVRCP_REMOTE_CAPABILITIES_W4_QUERY_RESULT;
1815             avrcp_controller_get_capabilities_for_connection(connection, AVRCP_CAPABILITY_ID_EVENT);
1816             break;
1817         case AVRCP_REMOTE_CAPABILITIES_KNOWN:
1818             avrcp_controller_emit_supported_events(connection);
1819             break;
1820         default:
1821             break;
1822     }
1823     return ERROR_CODE_SUCCESS;
1824 }
1825 
1826 uint8_t avrcp_controller_get_play_status(uint16_t avrcp_cid){
1827     avrcp_connection_t * connection = avrcp_get_connection_for_avrcp_cid_for_role(AVRCP_CONTROLLER, avrcp_cid);
1828     if (!connection){
1829         return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
1830     }
1831     if (connection->state != AVCTP_CONNECTION_OPENED) return ERROR_CODE_COMMAND_DISALLOWED;
1832 
1833     connection->state = AVCTP_W2_SEND_COMMAND;
1834     avrcp_controller_vendor_dependent_command_data_init(connection, AVRCP_CTYPE_STATUS, AVRCP_PDU_ID_GET_PLAY_STATUS, true);
1835 
1836     connection->data_len = 0;
1837     avrcp_request_can_send_now(connection, connection->l2cap_signaling_cid);
1838     return ERROR_CODE_SUCCESS;
1839 }
1840 
1841 uint8_t avrcp_controller_set_addressed_player(uint16_t avrcp_cid, uint16_t addressed_player_id){
1842     avrcp_connection_t * connection = avrcp_get_connection_for_avrcp_cid_for_role(AVRCP_CONTROLLER, avrcp_cid);
1843     if (!connection){
1844         return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
1845     }
1846     if (connection->state != AVCTP_CONNECTION_OPENED) return ERROR_CODE_COMMAND_DISALLOWED;
1847 
1848     connection->state = AVCTP_W2_SEND_COMMAND;
1849     avrcp_controller_vendor_dependent_command_data_init(connection, AVRCP_CTYPE_CONTROL, AVRCP_PDU_ID_SET_ADDRESSED_PLAYER, true);
1850 
1851     connection->data_len = 2;
1852     big_endian_store_16(connection->data, 0, addressed_player_id);
1853 
1854     avrcp_request_can_send_now(connection, connection->l2cap_signaling_cid);
1855     return ERROR_CODE_SUCCESS;
1856 }
1857 
1858 uint8_t avrcp_controller_get_element_attributes(uint16_t avrcp_cid, uint8_t num_attributes, avrcp_media_attribute_id_t * attributes){
1859     avrcp_connection_t * connection = avrcp_get_connection_for_avrcp_cid_for_role(AVRCP_CONTROLLER, avrcp_cid);
1860     if (!connection){
1861         return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
1862     }
1863 
1864     if (connection->state != AVCTP_CONNECTION_OPENED) return ERROR_CODE_COMMAND_DISALLOWED;
1865 
1866     if (num_attributes >= AVRCP_MEDIA_ATTR_RESERVED) {
1867         return ERROR_CODE_INVALID_HCI_COMMAND_PARAMETERS;
1868     }
1869 
1870     connection->state = AVCTP_W2_SEND_GET_ELEMENT_ATTRIBUTES_REQUEST;
1871     avrcp_controller_vendor_dependent_command_data_init(connection, AVRCP_CTYPE_STATUS, AVRCP_PDU_ID_GET_ELEMENT_ATTRIBUTES, true);
1872 
1873     // collect element attributes
1874     uint8_t i;
1875     uint16_t attributes_set = 0;
1876     for (i = 0; i < num_attributes; i++){
1877         // ignore invalid attribute ID and "get all attributes"
1878         if (AVRCP_MEDIA_ATTR_ALL < attributes[i] && attributes[i] < AVRCP_MEDIA_ATTR_RESERVED){
1879             attributes_set |= 1 << (attributes[i] - AVRCP_MEDIA_ATTR_TITLE);
1880         }
1881     }
1882     connection->controller_element_attributes = attributes_set;
1883 
1884     avrcp_request_can_send_now(connection, connection->l2cap_signaling_cid);
1885     return ERROR_CODE_SUCCESS;
1886 }
1887 
1888 uint8_t avrcp_controller_get_now_playing_info(uint16_t avrcp_cid){
1889     return avrcp_controller_get_element_attributes(avrcp_cid, 0, NULL);
1890 }
1891 
1892 uint8_t avrcp_controller_get_now_playing_info_for_media_attribute_id(uint16_t avrcp_cid, avrcp_media_attribute_id_t media_attribute_id){
1893     if (media_attribute_id == AVRCP_MEDIA_ATTR_ALL){
1894         return avrcp_controller_get_now_playing_info(avrcp_cid);
1895     }
1896     avrcp_media_attribute_id_t media_attrs[1];
1897     media_attrs[0] = media_attribute_id;
1898     return avrcp_controller_get_element_attributes(avrcp_cid, 1, media_attrs);
1899 }
1900 
1901 uint8_t avrcp_controller_set_absolute_volume(uint16_t avrcp_cid, uint8_t volume){
1902      avrcp_connection_t * connection = avrcp_get_connection_for_avrcp_cid_for_role(AVRCP_CONTROLLER, avrcp_cid);
1903     if (!connection){
1904         return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
1905     }
1906 
1907     //
1908     // allow sending of multiple set abs volume commands without waiting for response
1909     //
1910     uint8_t status = ERROR_CODE_COMMAND_DISALLOWED;
1911     switch (connection->state){
1912         case AVCTP_CONNECTION_OPENED:
1913             status = ERROR_CODE_SUCCESS;
1914             break;
1915         case AVCTP_W2_RECEIVE_RESPONSE:
1916             // - is pending response also set abs volume
1917             if (connection->command_opcode  != AVRCP_CMD_OPCODE_VENDOR_DEPENDENT) break;
1918             if (connection->command_type    != AVRCP_CTYPE_CONTROL)               break;
1919             if (connection->subunit_type    != AVRCP_SUBUNIT_TYPE_PANEL)          break;
1920             if (connection->subunit_id      != AVRCP_SUBUNIT_ID)                  break;
1921             if (connection->pdu_id          != AVRCP_PDU_ID_SET_ABSOLUTE_VOLUME)  break;
1922             // - is next transaction id valid in window
1923             if (avrcp_controller_is_transaction_id_valid(connection, avrcp_controller_calc_next_transaction_label(connection->transaction_id_counter)) == false) break;
1924             status = ERROR_CODE_SUCCESS;
1925             break;
1926         default:
1927             break;
1928     }
1929     if (status != ERROR_CODE_SUCCESS) return status;
1930 
1931     connection->state = AVCTP_W2_SEND_COMMAND;
1932     avrcp_controller_vendor_dependent_command_data_init(connection, AVRCP_CTYPE_CONTROL, AVRCP_PDU_ID_SET_ABSOLUTE_VOLUME, true);
1933 
1934     // Parameter Length
1935     connection->data_len = 1;
1936     connection->data[0] = volume;
1937 
1938     avrcp_request_can_send_now(connection, connection->l2cap_signaling_cid);
1939     return ERROR_CODE_SUCCESS;
1940 }
1941 
1942 uint8_t avrcp_controller_query_player_application_setting_attributes(uint16_t avrcp_cid){
1943     avrcp_connection_t * connection = avrcp_get_connection_for_avrcp_cid_for_role(AVRCP_CONTROLLER, avrcp_cid);
1944     if (!connection){
1945         return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
1946     }
1947     if (connection->state != AVCTP_CONNECTION_OPENED) return ERROR_CODE_COMMAND_DISALLOWED;
1948 
1949     connection->state = AVCTP_W2_SEND_COMMAND;
1950     avrcp_controller_vendor_dependent_command_data_init(connection, AVRCP_CTYPE_STATUS, AVRCP_PDU_ID_LIST_PLAYER_APPLICATION_SETTING_ATTRIBUTES, true);
1951 
1952     connection->data_len = 0;
1953 
1954     avrcp_request_can_send_now(connection, connection->l2cap_signaling_cid);
1955     return ERROR_CODE_SUCCESS;
1956 }
1957 
1958 uint8_t avrcp_controller_query_player_application_setting_values(uint16_t avrcp_cid, avrcp_player_application_setting_attribute_id_t attribute_id){
1959     avrcp_connection_t * connection = avrcp_get_connection_for_avrcp_cid_for_role(AVRCP_CONTROLLER, avrcp_cid);
1960     if (!connection){
1961         return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
1962     }
1963     if (connection->state != AVCTP_CONNECTION_OPENED) return ERROR_CODE_COMMAND_DISALLOWED;
1964 
1965     connection->state = AVCTP_W2_SEND_COMMAND;
1966     avrcp_controller_vendor_dependent_command_data_init(connection, AVRCP_CTYPE_STATUS, AVRCP_PDU_ID_LIST_PLAYER_APPLICATION_SETTING_VALUES, true);
1967 
1968     connection->data_len = 1;
1969     connection->data[0] = attribute_id;
1970 
1971     avrcp_request_can_send_now(connection, connection->l2cap_signaling_cid);
1972     return ERROR_CODE_SUCCESS;
1973 }
1974 
1975 uint8_t avrcp_controller_query_shuffle_and_repeat_modes(uint16_t avrcp_cid){
1976     avrcp_connection_t * connection = avrcp_get_connection_for_avrcp_cid_for_role(AVRCP_CONTROLLER, avrcp_cid);
1977     if (!connection){
1978         return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
1979     }
1980     if (connection->state != AVCTP_CONNECTION_OPENED) return ERROR_CODE_COMMAND_DISALLOWED;
1981 
1982     connection->state = AVCTP_W2_SEND_COMMAND;
1983     avrcp_controller_vendor_dependent_command_data_init(connection, AVRCP_CTYPE_STATUS, AVRCP_PDU_ID_GET_CURRENT_PLAYER_APPLICATION_SETTING_VALUE, true);
1984 
1985     connection->data_len = 5;
1986     connection->data[0] = 4;                     // NumPlayerApplicationSettingAttributeID
1987     // PlayerApplicationSettingAttributeID1 AVRCP Spec, Appendix F, 133
1988     connection->data[1] = 0x01;   // equalizer  (1-OFF, 2-ON)
1989     connection->data[2] = 0x02;   // repeat     (1-off, 2-single track, 3-all tracks, 4-group repeat)
1990     connection->data[3] = 0x03;   // shuffle    (1-off, 2-all tracks, 3-group shuffle)
1991     connection->data[4] = 0x04;   // scan       (1-off, 2-all tracks, 3-group scan)
1992 
1993     avrcp_request_can_send_now(connection, connection->l2cap_signaling_cid);
1994     return ERROR_CODE_SUCCESS;
1995 }
1996 
1997 static uint8_t avrcp_controller_set_current_player_application_setting_value(uint16_t avrcp_cid, uint8_t attr_id, uint8_t attr_value){
1998     avrcp_connection_t * connection = avrcp_get_connection_for_avrcp_cid_for_role(AVRCP_CONTROLLER, avrcp_cid);
1999     if (!connection){
2000         return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
2001     }
2002     if (connection->state != AVCTP_CONNECTION_OPENED) return ERROR_CODE_COMMAND_DISALLOWED;
2003 
2004     connection->state = AVCTP_W2_SEND_COMMAND;
2005     avrcp_controller_vendor_dependent_command_data_init(connection, AVRCP_CTYPE_CONTROL, AVRCP_PDU_ID_SET_PLAYER_APPLICATION_SETTING_VALUE, true);
2006 
2007     // Parameter Length
2008     connection->data_len = 3;
2009     connection->data[0]  = 2;
2010     connection->data[1]  = attr_id;
2011     connection->data[2]  = attr_value;
2012 
2013     avrcp_request_can_send_now(connection, connection->l2cap_signaling_cid);
2014     return ERROR_CODE_SUCCESS;
2015 }
2016 
2017 uint8_t avrcp_controller_query_player_application_setting_attribute_text(uint16_t avrcp_cid){
2018     avrcp_connection_t * connection = avrcp_get_connection_for_avrcp_cid_for_role(AVRCP_CONTROLLER, avrcp_cid);
2019     if (!connection){
2020         return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
2021     }
2022     if (connection->state != AVCTP_CONNECTION_OPENED) return ERROR_CODE_COMMAND_DISALLOWED;
2023 
2024     connection->state = AVCTP_W2_SEND_COMMAND;
2025     avrcp_controller_vendor_dependent_command_data_init(connection, AVRCP_CTYPE_STATUS, AVRCP_PDU_ID_GET_PLAYER_APPLICATION_SETTING_ATTRIBUTE_TEXT, true);
2026 
2027     connection->data_len = 5;
2028     connection->data[0] = 4;                     // NumPlayerApplicationSettingAttributeID
2029     // PlayerApplicationSettingAttributeID1 AVRCP Spec, Appendix F, 133
2030     connection->data[1] = 0x01;   // equalizer  (1-OFF, 2-ON)
2031     connection->data[2] = 0x02;   // repeat     (1-off, 2-single track, 3-all tracks, 4-group repeat)
2032     connection->data[3] = 0x03;   // shuffle    (1-off, 2-all tracks, 3-group shuffle)
2033     connection->data[4] = 0x04;   // scan       (1-off, 2-all tracks, 3-group scan)
2034 
2035     avrcp_request_can_send_now(connection, connection->l2cap_signaling_cid);
2036     return ERROR_CODE_SUCCESS;
2037 }
2038 
2039 uint8_t avrcp_controller_query_player_application_setting_value_text(uint16_t avrcp_cid){
2040     avrcp_connection_t * connection = avrcp_get_connection_for_avrcp_cid_for_role(AVRCP_CONTROLLER, avrcp_cid);
2041     if (!connection){
2042         return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
2043     }
2044     if (connection->state != AVCTP_CONNECTION_OPENED) return ERROR_CODE_COMMAND_DISALLOWED;
2045 
2046     connection->state = AVCTP_W2_SEND_COMMAND;
2047     avrcp_controller_vendor_dependent_command_data_init(connection, AVRCP_CTYPE_STATUS, AVRCP_PDU_ID_GET_PLAYER_APPLICATION_SETTING_VALUE_TEXT, true);
2048 
2049     connection->data_len = 5;
2050     connection->data[0] = 4;                     // NumPlayerApplicationSettingAttributeID
2051     // PlayerApplicationSettingAttributeID1 AVRCP Spec, Appendix F, 133
2052     connection->data[1] = 0x01;   // equalizer  (1-OFF, 2-ON)
2053     connection->data[2] = 0x02;   // repeat     (1-off, 2-single track, 3-all tracks, 4-group repeat)
2054     connection->data[3] = 0x03;   // shuffle    (1-off, 2-all tracks, 3-group shuffle)
2055     connection->data[4] = 0x04;   // scan       (1-off, 2-all tracks, 3-group scan)
2056 
2057     avrcp_request_can_send_now(connection, connection->l2cap_signaling_cid);
2058     return ERROR_CODE_SUCCESS;
2059 }
2060 
2061 uint8_t avrcp_controller_inform_displayable_characterset(uint16_t avrcp_cid, uint8_t character_set_num, uint16_t * character_set){
2062     btstack_assert(character_set_num > 4);
2063 
2064     avrcp_connection_t * connection = avrcp_get_connection_for_avrcp_cid_for_role(AVRCP_CONTROLLER, avrcp_cid);
2065     if (!connection){
2066         return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
2067     }
2068     if (connection->state != AVCTP_CONNECTION_OPENED) return ERROR_CODE_COMMAND_DISALLOWED;
2069 
2070     connection->state = AVCTP_W2_SEND_COMMAND;
2071     avrcp_controller_vendor_dependent_command_data_init(connection, AVRCP_CTYPE_CONTROL, AVRCP_PDU_ID_INFORM_DISPLAYABLE_CHARACTERSET, true);
2072 
2073     // Parameter Length
2074     connection->data_len = character_set_num * 2;
2075     uint8_t pos = 0;
2076 
2077     connection->data[pos++] = character_set_num;
2078     uint8_t i;
2079     for (i = 0; i < character_set_num; i++){
2080         little_endian_store_16(connection->data, pos, character_set[i]);
2081         pos += i * 2;
2082     }
2083 
2084     avrcp_request_can_send_now(connection, connection->l2cap_signaling_cid);
2085     return ERROR_CODE_SUCCESS;
2086 }
2087 
2088 uint8_t avrcp_controller_inform_battery_status(uint16_t avrcp_cid, avrcp_battery_status_t battery_status){
2089     avrcp_connection_t * connection = avrcp_get_connection_for_avrcp_cid_for_role(AVRCP_CONTROLLER, avrcp_cid);
2090     if (!connection){
2091         return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
2092     }
2093     if (connection->state != AVCTP_CONNECTION_OPENED) return ERROR_CODE_COMMAND_DISALLOWED;
2094 
2095     connection->state = AVCTP_W2_SEND_COMMAND;
2096     avrcp_controller_vendor_dependent_command_data_init(connection, AVRCP_CTYPE_CONTROL, AVRCP_PDU_ID_INFORM_BATTERY_STATUS_OF_CT, true);
2097 
2098     // Parameter Length
2099     connection->data_len = 1;
2100     connection->data[0]  = battery_status;
2101 
2102     avrcp_request_can_send_now(connection, connection->l2cap_signaling_cid);
2103     return ERROR_CODE_SUCCESS;
2104 }
2105 
2106 uint8_t avrcp_controller_set_shuffle_mode(uint16_t avrcp_cid, avrcp_shuffle_mode_t mode){
2107     if ((mode < AVRCP_SHUFFLE_MODE_OFF) || (mode > AVRCP_SHUFFLE_MODE_GROUP)) return ERROR_CODE_UNSUPPORTED_FEATURE_OR_PARAMETER_VALUE;
2108     return avrcp_controller_set_current_player_application_setting_value(avrcp_cid, 0x03, mode);
2109 }
2110 
2111 uint8_t avrcp_controller_set_repeat_mode(uint16_t avrcp_cid, avrcp_repeat_mode_t mode){
2112     if ((mode < AVRCP_REPEAT_MODE_OFF) || (mode > AVRCP_REPEAT_MODE_GROUP)) return ERROR_CODE_UNSUPPORTED_FEATURE_OR_PARAMETER_VALUE;
2113     return avrcp_controller_set_current_player_application_setting_value(avrcp_cid, 0x02, mode);
2114 }
2115 
2116 uint8_t avrcp_controller_play_item_for_scope(uint16_t avrcp_cid, uint8_t * uid, uint16_t uid_counter, avrcp_browsing_scope_t scope){
2117     avrcp_connection_t * connection = avrcp_get_connection_for_avrcp_cid_for_role(AVRCP_CONTROLLER, avrcp_cid);
2118     if (!connection){
2119         return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
2120     }
2121     if (connection->state != AVCTP_CONNECTION_OPENED){
2122         log_error("Connection in wrong state, expected %d, received %d", AVCTP_CONNECTION_OPENED, connection->state);
2123         return ERROR_CODE_COMMAND_DISALLOWED;
2124     }
2125     connection->state = AVCTP_W2_SEND_COMMAND;
2126     avrcp_controller_vendor_dependent_command_data_init(connection, AVRCP_CTYPE_CONTROL, AVRCP_PDU_ID_PLAY_ITEM, true);
2127 
2128     // Parameter Length
2129     connection->data_len = 11;
2130     connection->data[0]  = scope;
2131     memset(&connection->data[1], 0, 8);
2132     if (uid){
2133         (void)memcpy(&connection->data[1], uid, 8);
2134     }
2135     big_endian_store_16(connection->data, 9, uid_counter);
2136 
2137     avrcp_request_can_send_now(connection, connection->l2cap_signaling_cid);
2138     return ERROR_CODE_SUCCESS;
2139 }
2140 
2141 uint8_t avrcp_controller_add_item_from_scope_to_now_playing_list(uint16_t avrcp_cid, uint8_t * uid, uint16_t uid_counter, avrcp_browsing_scope_t scope){
2142     avrcp_connection_t * connection = avrcp_get_connection_for_avrcp_cid_for_role(AVRCP_CONTROLLER, avrcp_cid);
2143     if (!connection){
2144         return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
2145     }
2146     if (connection->state != AVCTP_CONNECTION_OPENED){
2147         log_error("Connection in wrong state, expected %d, received %d", AVCTP_CONNECTION_OPENED, connection->state);
2148         return ERROR_CODE_COMMAND_DISALLOWED;
2149     }
2150 
2151     connection->state = AVCTP_W2_SEND_COMMAND;
2152     avrcp_controller_vendor_dependent_command_data_init(connection, AVRCP_CTYPE_CONTROL, AVRCP_PDU_ID_ADD_TO_NOW_PLAYING, true);
2153 
2154     // Parameter Length
2155     connection->data_len = 11;
2156     connection->data[0]  = scope;
2157     memset(&connection->data[1], 0, 8);
2158     if (uid){
2159         (void)memcpy(&connection->data[1], uid, 8);
2160     }
2161     big_endian_store_16(connection->data, 9, uid_counter);
2162 
2163     avrcp_request_can_send_now(connection, connection->l2cap_signaling_cid);
2164     return ERROR_CODE_SUCCESS;
2165 }
2166 
2167 uint8_t avrcp_controller_set_max_num_fragments(uint16_t avrcp_cid, uint8_t max_num_fragments){
2168     avrcp_connection_t * connection = avrcp_get_connection_for_avrcp_cid_for_role(AVRCP_CONTROLLER, avrcp_cid);
2169     if (!connection){
2170         return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
2171     }
2172     connection->controller_max_num_fragments = max_num_fragments;
2173     return ERROR_CODE_SUCCESS;
2174 }
2175 
2176 
2177 uint8_t avrcp_controller_send_custom_command(uint16_t avrcp_cid,
2178     avrcp_command_type_t command_type,
2179     avrcp_subunit_type_t subunit_type, avrcp_subunit_id_t subunit_id,
2180     avrcp_pdu_id_t pdu_id, uint32_t company_id,
2181     const uint8_t * data, uint16_t data_len){
2182 
2183     avrcp_connection_t * connection = avrcp_get_connection_for_avrcp_cid_for_role(AVRCP_CONTROLLER, avrcp_cid);
2184     if (!connection){
2185         return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
2186     }
2187     if (connection->state != AVCTP_CONNECTION_OPENED) return ERROR_CODE_COMMAND_DISALLOWED;
2188 
2189     connection->state = AVCTP_W2_SEND_COMMAND;
2190     avrcp_controller_custom_command_data_init(connection, AVRCP_CMD_OPCODE_VENDOR_DEPENDENT, command_type, subunit_type,
2191                                               subunit_id, pdu_id, company_id);
2192 
2193     connection->data = (uint8_t *)data;
2194     connection->data_len = data_len;
2195 
2196     avrcp_request_can_send_now(connection, connection->l2cap_signaling_cid);
2197     return ERROR_CODE_SUCCESS;
2198 }
2199 
2200 uint8_t avrcp_controller_force_send_press_cmd(uint16_t avrcp_cid, avrcp_operation_id_t opid){
2201     avrcp_connection_t * connection = avrcp_get_connection_for_avrcp_cid_for_role(AVRCP_CONTROLLER, avrcp_cid);
2202     if (!connection){
2203         return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
2204     }
2205     if (connection->state < AVCTP_CONNECTION_OPENED){
2206         return ERROR_CODE_COMMAND_DISALLOWED;
2207     }
2208 
2209     connection->state = AVCTP_W2_SEND_COMMAND;
2210     avrcp_controller_pass_through_command_data_init(connection, opid);
2211     avrcp_request_can_send_now(connection, connection->l2cap_signaling_cid);
2212     return ERROR_CODE_SUCCESS;
2213 }