xref: /btstack/src/classic/avrcp_controller.c (revision 0e3c5f83e6f4e6c0d8a8a265ca563fce966e98db)
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 = packet[pos++];
979             vendor_dependent_avrcp_packet_type = (avrcp_packet_type_t)(packet[pos++] & 0x03);
980             param_length = big_endian_read_16(packet, pos);
981             pos += 2;
982 
983             if ((size - pos) < param_length) {
984                 return;
985             }
986 
987             // handle asynchronous notifications, without changing state
988             if (pdu_id == AVRCP_PDU_ID_REGISTER_NOTIFICATION){
989                 avrcp_controller_handle_notification(connection, ctype, packet + pos, size - pos);
990                 break;
991             }
992             if (connection->state != AVCTP_W2_RECEIVE_RESPONSE) return;
993             connection->state = AVCTP_CONNECTION_OPENED;
994 
995             log_info("VENDOR DEPENDENT response: pdu id 0x%02x, param_length %d, status %s", pdu_id, param_length, avrcp_ctype2str(ctype));
996             switch (pdu_id){
997                 case AVRCP_PDU_ID_GET_CURRENT_PLAYER_APPLICATION_SETTING_VALUE:{
998                     uint8_t num_attributes = packet[pos++];
999                     int i;
1000                     avrcp_repeat_mode_t  repeat_mode =  AVRCP_REPEAT_MODE_INVALID;
1001                     avrcp_shuffle_mode_t shuffle_mode = AVRCP_SHUFFLE_MODE_INVALID;
1002                     for (i = 0; i < num_attributes; i++){
1003                         uint8_t attribute_id    = packet[pos++];
1004                         uint8_t value = packet[pos++];
1005                         switch (attribute_id){
1006                             case 0x02:
1007                                 repeat_mode = (avrcp_repeat_mode_t) value;
1008                                 break;
1009                             case 0x03:
1010                                 shuffle_mode = (avrcp_shuffle_mode_t) value;
1011                                 break;
1012                             default:
1013                                 break;
1014                         }
1015                     }
1016                     avrcp_controller_emit_repeat_and_shuffle_mode(avrcp_controller_context.avrcp_callback, connection->avrcp_cid, ctype, repeat_mode, shuffle_mode);
1017                     break;
1018                 }
1019 
1020                 case AVRCP_PDU_ID_SET_PLAYER_APPLICATION_SETTING_VALUE:{
1021                     uint16_t offset = 0;
1022                     uint8_t event[6];
1023                     event[offset++] = HCI_EVENT_AVRCP_META;
1024                     event[offset++] = sizeof(event) - 2;
1025                     event[offset++] = AVRCP_SUBEVENT_PLAYER_APPLICATION_VALUE_RESPONSE;
1026                     little_endian_store_16(event, offset, connection->avrcp_cid);
1027                     offset += 2;
1028                     event[offset++] = ctype;
1029                     (*avrcp_controller_context.avrcp_callback)(HCI_EVENT_PACKET, 0, event, sizeof(event));
1030                     break;
1031                 }
1032 
1033                 case AVRCP_PDU_ID_SET_ABSOLUTE_VOLUME:{
1034                     uint16_t offset = 0;
1035                     uint8_t event[7];
1036                     event[offset++] = HCI_EVENT_AVRCP_META;
1037                     event[offset++] = sizeof(event) - 2;
1038                     event[offset++] = AVRCP_SUBEVENT_SET_ABSOLUTE_VOLUME_RESPONSE;
1039                     little_endian_store_16(event, offset, connection->avrcp_cid);
1040                     offset += 2;
1041                     event[offset++] = ctype;
1042                     event[offset++] = packet[pos++];
1043                     (*avrcp_controller_context.avrcp_callback)(HCI_EVENT_PACKET, 0, event, sizeof(event));
1044                     break;
1045                 }
1046 
1047                 case AVRCP_PDU_ID_GET_CAPABILITIES:{
1048                     avrcp_capability_id_t capability_id = (avrcp_capability_id_t) packet[pos++];
1049                     uint8_t capability_count = 0;
1050                     if (param_length > 1){
1051                         capability_count = packet[pos++];
1052                     }
1053                     uint16_t i;
1054                     uint16_t offset;
1055                     uint8_t event[10];
1056 
1057                     switch (capability_id){
1058 
1059                         case AVRCP_CAPABILITY_ID_COMPANY:
1060                             for (i = 0; (i < capability_count) && ((size - pos) >= 3); i++){
1061                                 uint32_t company_id = big_endian_read_24(packet, pos);
1062                                 pos += 3;
1063                                 log_info("  0x%06" PRIx32 ", ", company_id);
1064 
1065                                 offset = 0;
1066                                 event[offset++] = HCI_EVENT_AVRCP_META;
1067                                 event[offset++] = sizeof(event) - 2;
1068                                 event[offset++] = AVRCP_SUBEVENT_GET_CAPABILITY_COMPANY_ID;
1069                                 little_endian_store_16(event, offset, connection->avrcp_cid);
1070                                 offset += 2;
1071                                 event[offset++] = ctype;
1072                                 event[offset++] = 0;
1073                                 little_endian_store_24(event, offset, company_id);
1074                                 offset += 3;
1075                                 (*avrcp_controller_context.avrcp_callback)(HCI_EVENT_PACKET, 0, event, offset);
1076                             }
1077 
1078                             offset = 0;
1079                             event[offset++] = HCI_EVENT_AVRCP_META;
1080                             event[offset++] = sizeof(event) - 2;
1081                             event[offset++] = AVRCP_SUBEVENT_GET_CAPABILITY_COMPANY_ID_DONE;
1082                             little_endian_store_16(event, offset, connection->avrcp_cid);
1083                             offset += 2;
1084                             event[offset++] = ctype;
1085                             event[offset++] = 0;
1086                             (*avrcp_controller_context.avrcp_callback)(HCI_EVENT_PACKET, 0, event, offset);
1087                             break;
1088 
1089                         case AVRCP_CAPABILITY_ID_EVENT:
1090                             for (i = 0; (i < capability_count) && ((size - pos) >= 1); i++){
1091                                 uint8_t event_id = packet[pos++];
1092                                 connection->notifications_supported_by_target |= (1 << event_id);
1093                             }
1094 
1095                             connection->remote_capabilities_state = AVRCP_REMOTE_CAPABILITIES_KNOWN;
1096 
1097                             // if the get supported events query is triggered by avrcp_controller_enable_notification call,
1098                             // avrcp_controller_emit_supported_events should be suppressed
1099                             if (connection->controller_notifications_supported_by_target_suppress_emit_result){
1100                                 connection->controller_notifications_supported_by_target_suppress_emit_result = false;
1101                                 // also, notification might not be supported
1102                                 // if so, emit AVRCP_SUBEVENT_ENABLE_NOTIFICATION_COMPLETE event to app,
1103                                 // and update controller_notifications_to_register bitmap
1104                                 for (i = (uint8_t)AVRCP_NOTIFICATION_EVENT_FIRST_INDEX; i < (uint8_t) AVRCP_NOTIFICATION_EVENT_LAST_INDEX; i++){
1105                                     if ((connection->controller_notifications_to_register & (1 << i)) != 0){
1106                                         if ((connection->notifications_supported_by_target & (1 << i)) == 0){
1107                                             avrcp_controller_emit_notification_complete(connection, ERROR_CODE_UNSUPPORTED_FEATURE_OR_PARAMETER_VALUE, (uint8_t) i, false);
1108                                             connection->controller_notifications_to_register &= ~(1 << i);
1109                                         }
1110                                     }
1111                                 }
1112                                 break;
1113                             }
1114                             // supported events are emitted only if the get supported events query
1115                             // is triggered by avrcp_controller_get_supported_events call
1116                             avrcp_controller_emit_supported_events(connection);
1117                             break;
1118 
1119                         default:
1120                             // ignore
1121                             break;
1122                     }
1123                     break;
1124                 }
1125 
1126                 case AVRCP_PDU_ID_GET_PLAY_STATUS:{
1127                     uint32_t song_length = big_endian_read_32(packet, pos);
1128                     pos += 4;
1129                     uint32_t song_position = big_endian_read_32(packet, pos);
1130                     pos += 4;
1131                     uint8_t play_status = packet[pos];
1132 
1133                     uint8_t event[15];
1134                     int offset = 0;
1135                     event[offset++] = HCI_EVENT_AVRCP_META;
1136                     event[offset++] = sizeof(event) - 2;
1137                     event[offset++] = AVRCP_SUBEVENT_PLAY_STATUS;
1138                     little_endian_store_16(event, offset, connection->avrcp_cid);
1139                     offset += 2;
1140                     event[offset++] = ctype;
1141                     little_endian_store_32(event, offset, song_length);
1142                     offset += 4;
1143                     little_endian_store_32(event, offset, song_position);
1144                     offset += 4;
1145                     event[offset++] = play_status;
1146                     (*avrcp_controller_context.avrcp_callback)(HCI_EVENT_PACKET, 0, event, sizeof(event));
1147                     break;
1148                 }
1149 
1150                 case AVRCP_PDU_ID_GET_ELEMENT_ATTRIBUTES:
1151                     switch (vendor_dependent_avrcp_packet_type){
1152                         case AVRCP_START_PACKET:
1153                         case AVRCP_SINGLE_PACKET:
1154                             avrcp_parser_reset(connection);
1155                             connection->list_size = param_length;
1156                             // num_attributes
1157                             pos++;
1158 
1159                             avrcp_controller_parse_and_emit_element_attrs(packet+pos, size-pos, connection, ctype);
1160                             if (vendor_dependent_avrcp_packet_type == AVRCP_START_PACKET){
1161                                 avrcp_controller_request_continue_response(connection);
1162                                 return;
1163                             }
1164                             break;
1165                         case AVRCP_CONTINUE_PACKET:
1166                         case AVRCP_END_PACKET:
1167                             connection->controller_num_received_fragments++;
1168 
1169                             if (connection->controller_num_received_fragments < connection->controller_max_num_fragments){
1170                                 avrcp_controller_parse_and_emit_element_attrs(packet+pos, size-pos, connection, ctype);
1171 
1172                                 if (vendor_dependent_avrcp_packet_type == AVRCP_CONTINUE_PACKET){
1173                                     avrcp_controller_request_continue_response(connection);
1174                                     return;
1175                                 }
1176                             } else {
1177                                 avrcp_controller_emit_now_playing_info_event_done(avrcp_controller_context.avrcp_callback, connection->avrcp_cid, ctype, 1);
1178                                 avrcp_parser_reset(connection);
1179                                 avrcp_controller_request_abort_continuation(connection);
1180                                 return;
1181                             }
1182                             break;
1183                         default:
1184                             btstack_assert(false);
1185                             break;
1186                     }
1187                     break;
1188 
1189                 default:
1190                     // custom command response comes here
1191                     switch (pdu_id){
1192                         case AVRCP_PDU_ID_REQUEST_ABORT_CONTINUING_RESPONSE:
1193                             avrcp_controller_emit_now_playing_info_event_done(avrcp_controller_context.avrcp_callback, connection->avrcp_cid, ctype, 0);
1194                             break;
1195                         default:
1196                             if (pdu_id != connection->pdu_id) {
1197                                 break;
1198                             }
1199                             uint8_t *in_place_buffer = packet + pos - 9;
1200                             avrcp_controller_prepare_custom_command_response(connection, param_length,
1201                                                                              in_place_buffer);
1202                             (*avrcp_controller_context.avrcp_callback)(HCI_EVENT_PACKET, 0, in_place_buffer,
1203                                                                        param_length + 9);
1204 
1205                             break;
1206                     }
1207                     break;
1208             }
1209             break;
1210         case AVRCP_CMD_OPCODE_PASS_THROUGH:{
1211             if ((size - pos) < 1) return;
1212             uint8_t operation_id = packet[pos++];
1213             UNUSED(pos);
1214             switch (connection->state){
1215                 case AVCTP_W2_RECEIVE_PRESS_RESPONSE:
1216                     // trigger release for simple command:
1217                     if (!connection->controller_press_and_hold_cmd_active){
1218                         connection->state = AVCTP_W2_SEND_RELEASE_COMMAND;
1219                         break;
1220                     }
1221                     // for press and hold, send release if it just has been requested, otherwise, wait for next repeat
1222                     if (connection->controller_press_and_hold_cmd_release){
1223                         connection->controller_press_and_hold_cmd_release = false;
1224                         connection->state = AVCTP_W2_SEND_RELEASE_COMMAND;
1225                     } else {
1226                         connection->state = AVCTP_W4_STOP;
1227                     }
1228                     break;
1229                 case AVCTP_W2_RECEIVE_RESPONSE:
1230                     connection->state = AVCTP_CONNECTION_OPENED;
1231                     break;
1232                 default:
1233                     break;
1234             }
1235             if (connection->state == AVCTP_W4_STOP){
1236                 avrcp_controller_emit_operation_status(avrcp_controller_context.avrcp_callback, AVRCP_SUBEVENT_OPERATION_START, connection->avrcp_cid, ctype, operation_id);
1237             }
1238             if (connection->state == AVCTP_CONNECTION_OPENED) {
1239                 // RELEASE response
1240                 operation_id = operation_id & 0x7F;
1241                 avrcp_controller_emit_operation_status(avrcp_controller_context.avrcp_callback, AVRCP_SUBEVENT_OPERATION_COMPLETE, connection->avrcp_cid, ctype, operation_id);
1242             }
1243             if (connection->state == AVCTP_W2_SEND_RELEASE_COMMAND){
1244                 // PRESS response
1245                 avrcp_controller_request_pass_through_release_control_cmd(connection);
1246             }
1247             break;
1248         }
1249         default:
1250             break;
1251     }
1252 
1253     // trigger pending notification reqistrations
1254     if ((connection->state == AVCTP_CONNECTION_OPENED) && connection->controller_notifications_to_register){
1255         avrcp_request_can_send_now(connection, connection->l2cap_signaling_cid);
1256     }
1257 }
1258 
1259 static void avrcp_controller_handle_can_send_now(avrcp_connection_t * connection){
1260     // identifier (9) + num attributes (1) + attributes (4 * num attributes)
1261     uint8_t get_element_attributes_command[9+8*((AVRCP_MEDIA_ATTR_RESERVED-AVRCP_MEDIA_ATTR_TITLE) + 1)];
1262     uint16_t pos;
1263     uint16_t num_attributes_index;
1264     uint8_t i;
1265 
1266     switch (connection->state){
1267         case AVCTP_W2_SEND_PRESS_COMMAND:
1268             avrcp_send_cmd_with_avctp_fragmentation(connection);
1269             connection->state = AVCTP_W2_RECEIVE_PRESS_RESPONSE;
1270             return;
1271 
1272         case AVCTP_W2_SEND_RELEASE_COMMAND:
1273             avrcp_send_cmd_with_avctp_fragmentation(connection);
1274             connection->state = AVCTP_W2_RECEIVE_RESPONSE;
1275             return;
1276 
1277         case AVCTP_W2_SEND_COMMAND:
1278             avrcp_send_cmd_with_avctp_fragmentation(connection);
1279             if (connection->data_offset < connection->data_len){
1280                 // continue AVCTP fragmentation
1281                 avrcp_request_can_send_now(connection, connection->l2cap_signaling_cid);
1282                 return;
1283             }
1284             connection->state = AVCTP_W2_RECEIVE_RESPONSE;
1285             return;
1286         case AVCTP_W2_SEND_GET_ELEMENT_ATTRIBUTES_REQUEST:
1287             // build command in local buffer
1288             pos = 0;
1289             connection->data = get_element_attributes_command;
1290             // write identifier
1291             memset(connection->data, 0, 8);
1292             pos += 8;
1293             num_attributes_index = pos;
1294             // If num_attributes is set to zero, all attribute information shall be returned,
1295             // and the AttributeID field is omitted
1296             connection->data[num_attributes_index] = 0;
1297             pos++;
1298             for (i = 0; i < (uint8_t)AVRCP_MEDIA_ATTR_RESERVED - (uint8_t)AVRCP_MEDIA_ATTR_TITLE; i++){
1299                 if ((connection->controller_element_attributes & (1<<i)) != 0){
1300                     // every attribute is 4 bytes long
1301                     big_endian_store_32(connection->data, pos, AVRCP_MEDIA_ATTR_TITLE + i);
1302                     pos += 4;
1303                     connection->data[num_attributes_index]++;
1304                 }
1305             }
1306 
1307             // Parameter Length
1308             connection->data_len = pos;
1309 
1310             log_info("AVCTP_W2_SEND_GET_ELEMENT_ATTRIBUTES_REQUEST, len %u", connection->data_len);
1311 
1312             // send data - assume it will fit into one packet
1313             avrcp_send_cmd_with_avctp_fragmentation(connection);
1314             connection->state = AVCTP_W2_RECEIVE_RESPONSE;
1315             return;
1316         default:
1317             break;
1318     }
1319 
1320     // send register notification if queued,
1321     // avrcp_handle_l2cap_data_packet_for_signaling_connection will trigger next one
1322     if (connection->controller_notifications_to_register != 0){
1323         uint8_t event_id;
1324         for (event_id = (uint8_t)AVRCP_NOTIFICATION_EVENT_FIRST_INDEX; event_id < (uint8_t)AVRCP_NOTIFICATION_EVENT_LAST_INDEX; event_id++){
1325             if (connection->controller_notifications_to_register & (1 << event_id)){
1326                 connection->controller_notifications_to_register &= ~ (1 << event_id);
1327                 avrcp_send_register_notification(connection, event_id);
1328                 return;
1329             }
1330         }
1331     }
1332 }
1333 
1334 static void avrcp_controller_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){
1335     avrcp_connection_t * connection;
1336 
1337     switch (packet_type) {
1338         case L2CAP_DATA_PACKET:
1339             connection = avrcp_get_connection_for_l2cap_signaling_cid_for_role(AVRCP_CONTROLLER, channel);
1340             avrcp_handle_l2cap_data_packet_for_signaling_connection(connection, packet, size);
1341             break;
1342 
1343         case HCI_EVENT_PACKET:
1344             switch (hci_event_packet_get_type(packet)){
1345                 case L2CAP_EVENT_CAN_SEND_NOW:
1346                     connection = avrcp_get_connection_for_l2cap_signaling_cid_for_role(AVRCP_CONTROLLER, channel);
1347                     avrcp_controller_handle_can_send_now(connection);
1348                     break;
1349             default:
1350                 break;
1351         }
1352         default:
1353             break;
1354     }
1355 }
1356 
1357 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){
1358     if (service_name == NULL){
1359         service_name = avrcp_default_controller_service_name;
1360     }
1361     if (service_provider_name == NULL){
1362         service_provider_name = avrcp_default_controller_service_provider_name;
1363     }
1364     avrcp_create_sdp_record(true, service, service_record_handle, avrcp_controller_supports_browsing(supported_features), supported_features, service_name, service_provider_name);
1365 }
1366 
1367 void avrcp_controller_init(void){
1368     avrcp_controller_context.role = AVRCP_CONTROLLER;
1369     avrcp_controller_context.packet_handler = avrcp_controller_packet_handler;
1370     avrcp_register_controller_packet_handler(&avrcp_controller_packet_handler);
1371 }
1372 
1373 void avrcp_controller_deinit(void){
1374     memset(&avrcp_controller_context, 0, sizeof(avrcp_context_t));
1375 }
1376 
1377 void avrcp_controller_register_packet_handler(btstack_packet_handler_t callback){
1378     btstack_assert(callback != NULL);
1379     avrcp_controller_context.avrcp_callback = callback;
1380 }
1381 
1382 
1383 uint8_t avrcp_controller_play(uint16_t avrcp_cid){
1384     return request_single_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_PLAY, 0);
1385 }
1386 
1387 uint8_t avrcp_controller_stop(uint16_t avrcp_cid){
1388     return request_single_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_STOP, 0);
1389 }
1390 
1391 uint8_t avrcp_controller_pause(uint16_t avrcp_cid){
1392     return request_single_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_PAUSE, 0);
1393 }
1394 
1395 uint8_t avrcp_controller_forward(uint16_t avrcp_cid){
1396     return request_single_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_FORWARD, 0);
1397 }
1398 
1399 uint8_t avrcp_controller_backward(uint16_t avrcp_cid){
1400     return request_single_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_BACKWARD, 0);
1401 }
1402 
1403 uint8_t avrcp_controller_volume_up(uint16_t avrcp_cid){
1404     return request_single_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_VOLUME_UP, 0);
1405 }
1406 
1407 uint8_t avrcp_controller_volume_down(uint16_t avrcp_cid){
1408     return request_single_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_VOLUME_DOWN, 0);
1409 }
1410 
1411 uint8_t avrcp_controller_mute(uint16_t avrcp_cid){
1412     return request_single_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_MUTE, 0);
1413 }
1414 
1415 uint8_t avrcp_controller_skip(uint16_t avrcp_cid){
1416     return request_single_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_SKIP, 0);
1417 }
1418 
1419 uint8_t avrcp_controller_fast_forward(uint16_t avrcp_cid){
1420     return request_single_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_FAST_FORWARD, 0);
1421 }
1422 
1423 uint8_t avrcp_controller_rewind(uint16_t avrcp_cid){
1424     return request_single_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_REWIND, 0);
1425 }
1426 
1427 /* start continuous cmds */
1428 
1429 uint8_t avrcp_controller_start_press_and_hold_cmd(uint16_t avrcp_cid, avrcp_operation_id_t operation_id){
1430     return request_continuous_pass_through_press_control_cmd(avrcp_cid, operation_id, 0);
1431 }
1432 
1433 uint8_t avrcp_controller_press_and_hold_play(uint16_t avrcp_cid){
1434     return request_continuous_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_PLAY, 0);
1435 }
1436 uint8_t avrcp_controller_press_and_hold_stop(uint16_t avrcp_cid){
1437     return request_continuous_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_STOP, 0);
1438 }
1439 uint8_t avrcp_controller_press_and_hold_pause(uint16_t avrcp_cid){
1440     return request_continuous_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_PAUSE, 0);
1441 }
1442 uint8_t avrcp_controller_press_and_hold_forward(uint16_t avrcp_cid){
1443     return request_continuous_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_FORWARD, 0);
1444 }
1445 uint8_t avrcp_controller_press_and_hold_backward(uint16_t avrcp_cid){
1446     return request_continuous_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_BACKWARD, 0);
1447 }
1448 uint8_t avrcp_controller_press_and_hold_fast_forward(uint16_t avrcp_cid){
1449     return request_continuous_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_FAST_FORWARD, 0);
1450 }
1451 uint8_t avrcp_controller_press_and_hold_rewind(uint16_t avrcp_cid){
1452     return request_continuous_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_REWIND, 0);
1453 }
1454 uint8_t avrcp_controller_press_and_hold_volume_up(uint16_t avrcp_cid){
1455     return request_continuous_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_VOLUME_UP, 0);
1456 }
1457 uint8_t avrcp_controller_press_and_hold_volume_down(uint16_t avrcp_cid){
1458     return request_continuous_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_VOLUME_DOWN, 0);
1459 }
1460 uint8_t avrcp_controller_press_and_hold_mute(uint16_t avrcp_cid){
1461     return request_continuous_pass_through_press_control_cmd(avrcp_cid, AVRCP_OPERATION_ID_MUTE, 0);
1462 }
1463 
1464 static uint8_t avrcp_controller_request_group_pass_through_press_control_cmd(uint16_t avrcp_cid, avrcp_group_operation_id_t opid){
1465     log_info("Send group command %d", opid);
1466     avrcp_connection_t * connection = avrcp_get_connection_for_avrcp_cid_for_role(AVRCP_CONTROLLER, avrcp_cid);
1467     if (!connection){
1468         return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
1469     }
1470 
1471     if (connection->state != AVCTP_CONNECTION_OPENED){
1472         log_error("Connection in wrong state %d, expected %d. avrcp cid 0x%02x", connection->state, AVCTP_CONNECTION_OPENED, avrcp_cid);
1473         return ERROR_CODE_COMMAND_DISALLOWED;
1474     }
1475     connection->state = AVCTP_W2_SEND_PRESS_COMMAND;
1476     avrcp_controller_pass_through_command_data_init(connection, AVRCP_OPERATION_ID_VENDOR_UNIQUE);
1477     connection->company_id = BT_SIG_COMPANY_ID;
1478     connection->data_len = 5;
1479     big_endian_store_24(connection->data, 0, BT_SIG_COMPANY_ID);
1480     big_endian_store_16(connection->data, 3, opid);
1481 
1482     avrcp_request_can_send_now(connection, connection->l2cap_signaling_cid);
1483     return ERROR_CODE_SUCCESS;
1484 }
1485 
1486 uint8_t avrcp_controller_next_group(uint16_t avrcp_cid){
1487     return avrcp_controller_request_group_pass_through_press_control_cmd(avrcp_cid, AVRCP_GROUP_OPERATION_ID_GOTO_NEXT);
1488 }
1489 
1490 uint8_t avrcp_controller_previous_group(uint16_t avrcp_cid){
1491     return avrcp_controller_request_group_pass_through_press_control_cmd(avrcp_cid, AVRCP_GROUP_OPERATION_ID_GOTO_PREVIOUS);
1492 }
1493 
1494 
1495 /* stop continuous cmds */
1496 uint8_t avrcp_controller_release_press_and_hold_cmd(uint16_t avrcp_cid){
1497     avrcp_connection_t * connection = avrcp_get_connection_for_avrcp_cid_for_role(AVRCP_CONTROLLER, avrcp_cid);
1498     if (!connection){
1499         return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
1500     }
1501 
1502     switch (connection->state){
1503         // respond when we receive response for (repeated) press command
1504         case AVCTP_W2_RECEIVE_PRESS_RESPONSE:
1505             connection->controller_press_and_hold_cmd_release = true;
1506             break;
1507 
1508         // release already sent or on the way, nothing to do
1509         case AVCTP_W2_RECEIVE_RESPONSE:
1510         case AVCTP_W2_SEND_RELEASE_COMMAND:
1511             break;
1512 
1513         // about to send next repeated press command or wait for it -> release right away
1514         case AVCTP_W2_SEND_PRESS_COMMAND:
1515         case AVCTP_W4_STOP:
1516             return avrcp_controller_request_pass_through_release_control_cmd(connection);
1517 
1518         // otherwise reject request
1519         default:
1520             return ERROR_CODE_COMMAND_DISALLOWED;
1521     }
1522     return ERROR_CODE_SUCCESS;
1523 }
1524 
1525 uint8_t avrcp_controller_enable_notification(uint16_t avrcp_cid, avrcp_notification_event_id_t event_id){
1526     avrcp_connection_t * connection = avrcp_get_connection_for_avrcp_cid_for_role(AVRCP_CONTROLLER, avrcp_cid);
1527     if (!connection){
1528         return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
1529     }
1530     return avrcp_controller_register_notification(connection, event_id);
1531 }
1532 
1533 uint8_t avrcp_controller_disable_notification(uint16_t avrcp_cid, avrcp_notification_event_id_t event_id){
1534     avrcp_connection_t * connection = avrcp_get_connection_for_avrcp_cid_for_role(AVRCP_CONTROLLER, avrcp_cid);
1535     if (!connection){
1536         return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
1537     }
1538     if (connection->remote_capabilities_state != AVRCP_REMOTE_CAPABILITIES_KNOWN){
1539         return ERROR_CODE_COMMAND_DISALLOWED;
1540     }
1541 
1542     if ((connection->notifications_supported_by_target & (1 << event_id)) == 0){
1543         return ERROR_CODE_UNSUPPORTED_FEATURE_OR_PARAMETER_VALUE;
1544     }
1545 
1546     if ((connection->notifications_enabled & (1 << event_id)) == 0){
1547         return ERROR_CODE_SUCCESS;
1548     }
1549 
1550     connection->controller_notifications_to_deregister |= (1 << event_id);
1551     return ERROR_CODE_SUCCESS;
1552 }
1553 
1554 uint8_t avrcp_controller_unit_info(uint16_t avrcp_cid){
1555     avrcp_connection_t * connection = avrcp_get_connection_for_avrcp_cid_for_role(AVRCP_CONTROLLER, avrcp_cid);
1556     if (!connection){
1557         return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
1558     }
1559     if (connection->state != AVCTP_CONNECTION_OPENED) return ERROR_CODE_COMMAND_DISALLOWED;
1560 
1561     connection->state = AVCTP_W2_SEND_COMMAND;
1562     avrcp_controller_custom_command_data_init(connection, AVRCP_CMD_OPCODE_UNIT_INFO, AVRCP_CTYPE_STATUS,
1563                                               AVRCP_SUBUNIT_TYPE_UNIT, AVRCP_SUBUNIT_ID_IGNORE, AVRCP_PDU_ID_UNDEFINED,
1564                                               0);
1565 
1566     connection->data = connection->message_body;
1567     memset(connection->data, 0xFF, 5);
1568     connection->data_len = 5;
1569     avrcp_request_can_send_now(connection, connection->l2cap_signaling_cid);
1570     return ERROR_CODE_SUCCESS;
1571 }
1572 
1573 uint8_t avrcp_controller_subunit_info(uint16_t avrcp_cid){
1574     avrcp_connection_t * connection = avrcp_get_connection_for_avrcp_cid_for_role(AVRCP_CONTROLLER, avrcp_cid);
1575     if (!connection){
1576         return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
1577     }
1578     if (connection->state != AVCTP_CONNECTION_OPENED) return ERROR_CODE_COMMAND_DISALLOWED;
1579 
1580     connection->state = AVCTP_W2_SEND_COMMAND;
1581     avrcp_controller_custom_command_data_init(connection, AVRCP_CMD_OPCODE_SUBUNIT_INFO, AVRCP_CTYPE_STATUS,
1582                                               AVRCP_SUBUNIT_TYPE_UNIT, AVRCP_SUBUNIT_ID_IGNORE, AVRCP_PDU_ID_UNDEFINED,
1583                                               0);
1584 
1585     connection->data = connection->message_body;
1586     memset(connection->data, 0xFF, 5);
1587     connection->data[0] = 7; // page: 0, extension_code: 7
1588     connection->data_len = 5;
1589     avrcp_request_can_send_now(connection, connection->l2cap_signaling_cid);
1590     return ERROR_CODE_SUCCESS;
1591 }
1592 
1593 uint8_t avrcp_controller_get_supported_company_ids(uint16_t avrcp_cid){
1594     avrcp_connection_t * connection = avrcp_get_connection_for_avrcp_cid_for_role(AVRCP_CONTROLLER, avrcp_cid);
1595     if (!connection){
1596         return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
1597     }
1598     if (connection->state != AVCTP_CONNECTION_OPENED){
1599         return ERROR_CODE_COMMAND_DISALLOWED;
1600     }
1601     avrcp_controller_get_capabilities_for_connection(connection, AVRCP_CAPABILITY_ID_COMPANY);
1602     return ERROR_CODE_SUCCESS;
1603 }
1604 
1605 uint8_t avrcp_controller_get_supported_events(uint16_t avrcp_cid){
1606     avrcp_connection_t * connection = avrcp_get_connection_for_avrcp_cid_for_role(AVRCP_CONTROLLER, avrcp_cid);
1607     if (!connection){
1608         return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
1609     }
1610     if (connection->state != AVCTP_CONNECTION_OPENED){
1611         return ERROR_CODE_COMMAND_DISALLOWED;
1612     }
1613 
1614     switch (connection->remote_capabilities_state){
1615         case AVRCP_REMOTE_CAPABILITIES_NONE:
1616             connection->remote_capabilities_state = AVRCP_REMOTE_CAPABILITIES_W4_QUERY_RESULT;
1617             avrcp_controller_get_capabilities_for_connection(connection, AVRCP_CAPABILITY_ID_EVENT);
1618             break;
1619         case AVRCP_REMOTE_CAPABILITIES_KNOWN:
1620             avrcp_controller_emit_supported_events(connection);
1621             break;
1622         default:
1623             break;
1624     }
1625     return ERROR_CODE_SUCCESS;
1626 }
1627 
1628 uint8_t avrcp_controller_get_play_status(uint16_t avrcp_cid){
1629     avrcp_connection_t * connection = avrcp_get_connection_for_avrcp_cid_for_role(AVRCP_CONTROLLER, avrcp_cid);
1630     if (!connection){
1631         return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
1632     }
1633     if (connection->state != AVCTP_CONNECTION_OPENED) return ERROR_CODE_COMMAND_DISALLOWED;
1634 
1635     connection->state = AVCTP_W2_SEND_COMMAND;
1636     avrcp_controller_vendor_dependent_command_data_init(connection, AVRCP_CTYPE_STATUS, AVRCP_PDU_ID_GET_PLAY_STATUS, true);
1637 
1638     connection->data_len = 0;
1639     avrcp_request_can_send_now(connection, connection->l2cap_signaling_cid);
1640     return ERROR_CODE_SUCCESS;
1641 }
1642 
1643 uint8_t avrcp_controller_set_addressed_player(uint16_t avrcp_cid, uint16_t addressed_player_id){
1644     avrcp_connection_t * connection = avrcp_get_connection_for_avrcp_cid_for_role(AVRCP_CONTROLLER, avrcp_cid);
1645     if (!connection){
1646         return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
1647     }
1648     if (connection->state != AVCTP_CONNECTION_OPENED) return ERROR_CODE_COMMAND_DISALLOWED;
1649 
1650     connection->state = AVCTP_W2_SEND_COMMAND;
1651     avrcp_controller_vendor_dependent_command_data_init(connection, AVRCP_CTYPE_CONTROL, AVRCP_PDU_ID_SET_ADDRESSED_PLAYER, true);
1652 
1653     connection->data_len = 2;
1654     big_endian_store_16(connection->data, 0, addressed_player_id);
1655 
1656     avrcp_request_can_send_now(connection, connection->l2cap_signaling_cid);
1657     return ERROR_CODE_SUCCESS;
1658 }
1659 
1660 uint8_t avrcp_controller_get_element_attributes(uint16_t avrcp_cid, uint8_t num_attributes, avrcp_media_attribute_id_t * attributes){
1661     avrcp_connection_t * connection = avrcp_get_connection_for_avrcp_cid_for_role(AVRCP_CONTROLLER, avrcp_cid);
1662     if (!connection){
1663         return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
1664     }
1665 
1666     if (connection->state != AVCTP_CONNECTION_OPENED) return ERROR_CODE_COMMAND_DISALLOWED;
1667 
1668     if (num_attributes >= AVRCP_MEDIA_ATTR_RESERVED) {
1669         return ERROR_CODE_INVALID_HCI_COMMAND_PARAMETERS;
1670     }
1671 
1672     connection->state = AVCTP_W2_SEND_GET_ELEMENT_ATTRIBUTES_REQUEST;
1673     avrcp_controller_vendor_dependent_command_data_init(connection, AVRCP_CTYPE_STATUS, AVRCP_PDU_ID_GET_ELEMENT_ATTRIBUTES, true);
1674 
1675     // collect element attributes
1676     uint8_t i;
1677     uint16_t attributes_set = 0;
1678     for (i = 0; i < num_attributes; i++){
1679         // ignore invalid attribute ID and "get all attributes"
1680         if (AVRCP_MEDIA_ATTR_ALL < attributes[i] && attributes[i] < AVRCP_MEDIA_ATTR_RESERVED){
1681             attributes_set |= 1 << (attributes[i] - AVRCP_MEDIA_ATTR_TITLE);
1682         }
1683     }
1684     connection->controller_element_attributes = attributes_set;
1685 
1686     avrcp_request_can_send_now(connection, connection->l2cap_signaling_cid);
1687     return ERROR_CODE_SUCCESS;
1688 }
1689 
1690 uint8_t avrcp_controller_get_now_playing_info(uint16_t avrcp_cid){
1691     return avrcp_controller_get_element_attributes(avrcp_cid, 0, NULL);
1692 }
1693 
1694 uint8_t avrcp_controller_get_now_playing_info_for_media_attribute_id(uint16_t avrcp_cid, avrcp_media_attribute_id_t media_attribute_id){
1695     if (media_attribute_id == AVRCP_MEDIA_ATTR_ALL){
1696         return avrcp_controller_get_now_playing_info(avrcp_cid);
1697     }
1698     avrcp_media_attribute_id_t media_attrs[1];
1699     media_attrs[0] = media_attribute_id;
1700     return avrcp_controller_get_element_attributes(avrcp_cid, 1, media_attrs);
1701 }
1702 
1703 uint8_t avrcp_controller_set_absolute_volume(uint16_t avrcp_cid, uint8_t volume){
1704      avrcp_connection_t * connection = avrcp_get_connection_for_avrcp_cid_for_role(AVRCP_CONTROLLER, avrcp_cid);
1705     if (!connection){
1706         return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
1707     }
1708 
1709     //
1710     // allow sending of multiple set abs volume commands without waiting for response
1711     //
1712     uint8_t status = ERROR_CODE_COMMAND_DISALLOWED;
1713     switch (connection->state){
1714         case AVCTP_CONNECTION_OPENED:
1715             status = ERROR_CODE_SUCCESS;
1716             break;
1717         case AVCTP_W2_RECEIVE_RESPONSE:
1718             // - is pending response also set abs volume
1719             if (connection->command_opcode  != AVRCP_CMD_OPCODE_VENDOR_DEPENDENT) break;
1720             if (connection->command_type    != AVRCP_CTYPE_CONTROL)               break;
1721             if (connection->subunit_type    != AVRCP_SUBUNIT_TYPE_PANEL)          break;
1722             if (connection->subunit_id      != AVRCP_SUBUNIT_ID)                  break;
1723             if (connection->pdu_id          != AVRCP_PDU_ID_SET_ABSOLUTE_VOLUME)  break;
1724             // - is next transaction id valid in window
1725             if (avrcp_controller_is_transaction_id_valid(connection, avrcp_controller_calc_next_transaction_label(connection->transaction_id_counter)) == false) break;
1726             status = ERROR_CODE_SUCCESS;
1727             break;
1728         default:
1729             break;
1730     }
1731     if (status != ERROR_CODE_SUCCESS) return status;
1732 
1733     connection->state = AVCTP_W2_SEND_COMMAND;
1734     avrcp_controller_vendor_dependent_command_data_init(connection, AVRCP_CTYPE_CONTROL, AVRCP_PDU_ID_SET_ABSOLUTE_VOLUME, true);
1735 
1736     // Parameter Length
1737     connection->data_len = 1;
1738     connection->data[0] = volume;
1739 
1740     avrcp_request_can_send_now(connection, connection->l2cap_signaling_cid);
1741     return ERROR_CODE_SUCCESS;
1742 }
1743 
1744 uint8_t avrcp_controller_query_shuffle_and_repeat_modes(uint16_t avrcp_cid){
1745     avrcp_connection_t * connection = avrcp_get_connection_for_avrcp_cid_for_role(AVRCP_CONTROLLER, avrcp_cid);
1746     if (!connection){
1747         return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
1748     }
1749     if (connection->state != AVCTP_CONNECTION_OPENED) return ERROR_CODE_COMMAND_DISALLOWED;
1750 
1751     connection->state = AVCTP_W2_SEND_COMMAND;
1752     avrcp_controller_vendor_dependent_command_data_init(connection, AVRCP_CTYPE_STATUS, AVRCP_PDU_ID_GET_CURRENT_PLAYER_APPLICATION_SETTING_VALUE, true);
1753 
1754     connection->data_len = 5;
1755     connection->data[0] = 4;                     // NumPlayerApplicationSettingAttributeID
1756     // PlayerApplicationSettingAttributeID1 AVRCP Spec, Appendix F, 133
1757     connection->data[1] = 0x01;   // equalizer  (1-OFF, 2-ON)
1758     connection->data[2] = 0x02;   // repeat     (1-off, 2-single track, 3-all tracks, 4-group repeat)
1759     connection->data[3] = 0x03;   // shuffle    (1-off, 2-all tracks, 3-group shuffle)
1760     connection->data[4] = 0x04;   // scan       (1-off, 2-all tracks, 3-group scan)
1761 
1762     avrcp_request_can_send_now(connection, connection->l2cap_signaling_cid);
1763     return ERROR_CODE_SUCCESS;
1764 }
1765 
1766 static uint8_t avrcp_controller_set_current_player_application_setting_value(uint16_t avrcp_cid, uint8_t attr_id, uint8_t attr_value){
1767     avrcp_connection_t * connection = avrcp_get_connection_for_avrcp_cid_for_role(AVRCP_CONTROLLER, avrcp_cid);
1768     if (!connection){
1769         return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
1770     }
1771     if (connection->state != AVCTP_CONNECTION_OPENED) return ERROR_CODE_COMMAND_DISALLOWED;
1772 
1773     connection->state = AVCTP_W2_SEND_COMMAND;
1774     avrcp_controller_vendor_dependent_command_data_init(connection, AVRCP_CTYPE_CONTROL, AVRCP_PDU_ID_SET_PLAYER_APPLICATION_SETTING_VALUE, true);
1775 
1776     // Parameter Length
1777     connection->data_len = 3;
1778     connection->data[0]  = 2;
1779     connection->data[1]  = attr_id;
1780     connection->data[2]  = attr_value;
1781 
1782     avrcp_request_can_send_now(connection, connection->l2cap_signaling_cid);
1783     return ERROR_CODE_SUCCESS;
1784 }
1785 
1786 uint8_t avrcp_controller_set_shuffle_mode(uint16_t avrcp_cid, avrcp_shuffle_mode_t mode){
1787     if ((mode < AVRCP_SHUFFLE_MODE_OFF) || (mode > AVRCP_SHUFFLE_MODE_GROUP)) return ERROR_CODE_UNSUPPORTED_FEATURE_OR_PARAMETER_VALUE;
1788     return avrcp_controller_set_current_player_application_setting_value(avrcp_cid, 0x03, mode);
1789 }
1790 
1791 uint8_t avrcp_controller_set_repeat_mode(uint16_t avrcp_cid, avrcp_repeat_mode_t mode){
1792     if ((mode < AVRCP_REPEAT_MODE_OFF) || (mode > AVRCP_REPEAT_MODE_GROUP)) return ERROR_CODE_UNSUPPORTED_FEATURE_OR_PARAMETER_VALUE;
1793     return avrcp_controller_set_current_player_application_setting_value(avrcp_cid, 0x02, mode);
1794 }
1795 
1796 uint8_t avrcp_controller_play_item_for_scope(uint16_t avrcp_cid, uint8_t * uid, uint16_t uid_counter, avrcp_browsing_scope_t scope){
1797     avrcp_connection_t * connection = avrcp_get_connection_for_avrcp_cid_for_role(AVRCP_CONTROLLER, avrcp_cid);
1798     if (!connection){
1799         return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
1800     }
1801     if (connection->state != AVCTP_CONNECTION_OPENED){
1802         log_error("Connection in wrong state, expected %d, received %d", AVCTP_CONNECTION_OPENED, connection->state);
1803         return ERROR_CODE_COMMAND_DISALLOWED;
1804     }
1805     connection->state = AVCTP_W2_SEND_COMMAND;
1806     avrcp_controller_vendor_dependent_command_data_init(connection, AVRCP_CTYPE_CONTROL, AVRCP_PDU_ID_PLAY_ITEM, true);
1807 
1808     // Parameter Length
1809     connection->data_len = 11;
1810     connection->data[0]  = scope;
1811     memset(&connection->data[1], 0, 8);
1812     if (uid){
1813         (void)memcpy(&connection->data[1], uid, 8);
1814     }
1815     big_endian_store_16(connection->data, 9, uid_counter);
1816 
1817     avrcp_request_can_send_now(connection, connection->l2cap_signaling_cid);
1818     return ERROR_CODE_SUCCESS;
1819 }
1820 
1821 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){
1822     avrcp_connection_t * connection = avrcp_get_connection_for_avrcp_cid_for_role(AVRCP_CONTROLLER, avrcp_cid);
1823     if (!connection){
1824         return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
1825     }
1826     if (connection->state != AVCTP_CONNECTION_OPENED){
1827         log_error("Connection in wrong state, expected %d, received %d", AVCTP_CONNECTION_OPENED, connection->state);
1828         return ERROR_CODE_COMMAND_DISALLOWED;
1829     }
1830 
1831     connection->state = AVCTP_W2_SEND_COMMAND;
1832     avrcp_controller_vendor_dependent_command_data_init(connection, AVRCP_CTYPE_CONTROL, AVRCP_PDU_ID_ADD_TO_NOW_PLAYING, true);
1833 
1834     // Parameter Length
1835     connection->data_len = 11;
1836     connection->data[0]  = scope;
1837     memset(&connection->data[1], 0, 8);
1838     if (uid){
1839         (void)memcpy(&connection->data[1], uid, 8);
1840     }
1841     big_endian_store_16(connection->data, 9, uid_counter);
1842 
1843     avrcp_request_can_send_now(connection, connection->l2cap_signaling_cid);
1844     return ERROR_CODE_SUCCESS;
1845 }
1846 
1847 uint8_t avrcp_controller_set_max_num_fragments(uint16_t avrcp_cid, uint8_t max_num_fragments){
1848     avrcp_connection_t * connection = avrcp_get_connection_for_avrcp_cid_for_role(AVRCP_CONTROLLER, avrcp_cid);
1849     if (!connection){
1850         return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
1851     }
1852     connection->controller_max_num_fragments = max_num_fragments;
1853     return ERROR_CODE_SUCCESS;
1854 }
1855 
1856 
1857 uint8_t avrcp_controller_send_custom_command(uint16_t avrcp_cid,
1858     avrcp_command_type_t command_type,
1859     avrcp_subunit_type_t subunit_type, avrcp_subunit_id_t subunit_id,
1860     avrcp_pdu_id_t pdu_id, uint32_t company_id,
1861     const uint8_t * data, uint16_t data_len){
1862 
1863     avrcp_connection_t * connection = avrcp_get_connection_for_avrcp_cid_for_role(AVRCP_CONTROLLER, avrcp_cid);
1864     if (!connection){
1865         return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
1866     }
1867     if (connection->state != AVCTP_CONNECTION_OPENED) return ERROR_CODE_COMMAND_DISALLOWED;
1868 
1869     connection->state = AVCTP_W2_SEND_COMMAND;
1870     avrcp_controller_custom_command_data_init(connection, AVRCP_CMD_OPCODE_VENDOR_DEPENDENT, command_type, subunit_type,
1871                                               subunit_id, pdu_id, company_id);
1872 
1873     connection->data = (uint8_t *)data;
1874     connection->data_len = data_len;
1875 
1876     avrcp_request_can_send_now(connection, connection->l2cap_signaling_cid);
1877     return ERROR_CODE_SUCCESS;
1878 }
1879 
1880 uint8_t avrcp_controller_force_send_press_cmd(uint16_t avrcp_cid, avrcp_operation_id_t opid){
1881     avrcp_connection_t * connection = avrcp_get_connection_for_avrcp_cid_for_role(AVRCP_CONTROLLER, avrcp_cid);
1882     if (!connection){
1883         return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
1884     }
1885     if (connection->state < AVCTP_CONNECTION_OPENED){
1886         return ERROR_CODE_COMMAND_DISALLOWED;
1887     }
1888 
1889     connection->state = AVCTP_W2_SEND_COMMAND;
1890     avrcp_controller_pass_through_command_data_init(connection, opid);
1891     avrcp_request_can_send_now(connection, connection->l2cap_signaling_cid);
1892     return ERROR_CODE_SUCCESS;
1893 }