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 MATTHIAS 24 * RINGWALD OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 25 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 26 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS 27 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 28 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 29 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF 30 * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 31 * SUCH DAMAGE. 32 * 33 * Please inquire about commercial licensing options at 34 * [email protected] 35 * 36 */ 37 38 #define __BTSTACK_FILE__ "avrcp_target.c" 39 40 #include <stdint.h> 41 #include <stdio.h> 42 #include <stdlib.h> 43 #include <string.h> 44 #include <inttypes.h> 45 46 #include "btstack.h" 47 #include "classic/avrcp.h" 48 49 #define AVRCP_ATTR_HEADER_LEN 8 50 51 static const uint8_t AVRCP_NOTIFICATION_TRACK_SELECTED[] = {0,0,0,0,0,0,0,0}; 52 static const uint8_t AVRCP_NOTIFICATION_TRACK_NOT_SELECTED[] = {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF}; 53 54 avrcp_context_t avrcp_target_context; 55 56 void avrcp_target_create_sdp_record(uint8_t * service, uint32_t service_record_handle, uint8_t browsing, uint16_t supported_features, const char * service_name, const char * service_provider_name){ 57 avrcp_create_sdp_record(0, service, service_record_handle, browsing, supported_features, service_name, service_provider_name); 58 } 59 60 static void avrcp_target_emit_operation(btstack_packet_handler_t callback, uint16_t avrcp_cid, avrcp_operation_id_t operation_id, uint8_t operands_length, uint8_t operand){ 61 if (!callback) return; 62 uint8_t event[8]; 63 int pos = 0; 64 event[pos++] = HCI_EVENT_AVRCP_META; 65 event[pos++] = sizeof(event) - 2; 66 event[pos++] = AVRCP_SUBEVENT_OPERATION; 67 little_endian_store_16(event, pos, avrcp_cid); 68 pos += 2; 69 event[pos++] = operation_id; 70 event[pos++] = operands_length; 71 event[pos++] = operand; 72 (*callback)(HCI_EVENT_PACKET, 0, event, sizeof(event)); 73 } 74 75 static void avrcp_target_emit_respond_vendor_dependent_query(btstack_packet_handler_t callback, uint16_t avrcp_cid, uint8_t subevent_id){ 76 if (!callback) return; 77 uint8_t event[5]; 78 int pos = 0; 79 event[pos++] = HCI_EVENT_AVRCP_META; 80 event[pos++] = sizeof(event) - 2; 81 event[pos++] = subevent_id; 82 little_endian_store_16(event, pos, avrcp_cid); 83 (*callback)(HCI_EVENT_PACKET, 0, event, sizeof(event)); 84 } 85 86 static uint16_t avrcp_target_pack_single_element_attribute_number(uint8_t * packet, uint16_t pos, avrcp_media_attribute_id_t attr_id, uint32_t value){ 87 if ((attr_id < 1) || (attr_id > AVRCP_MEDIA_ATTR_COUNT)) return 0; 88 uint16_t attr_value_length = sprintf((char *)(packet+pos+8), "%0" PRIu32, value); 89 big_endian_store_32(packet, pos, attr_id); 90 pos += 4; 91 big_endian_store_16(packet, pos, RFC2978_CHARSET_MIB_UTF8); 92 pos += 2; 93 big_endian_store_16(packet, pos, attr_value_length); 94 pos += 2; 95 return 8 + attr_value_length; 96 } 97 98 static uint16_t avrcp_target_pack_single_element_attribute_string(uint8_t * packet, uint16_t pos, rfc2978_charset_mib_enumid_t mib_enumid, avrcp_media_attribute_id_t attr_id, uint8_t * attr_value, uint16_t attr_value_to_copy, uint16_t attr_value_size, uint8_t header){ 99 if (attr_value_size == 0) return 0; 100 if ((attr_id < 1) || (attr_id > AVRCP_MEDIA_ATTR_COUNT)) return 0; 101 if (header){ 102 big_endian_store_32(packet, pos, attr_id); 103 pos += 4; 104 big_endian_store_16(packet, pos, mib_enumid); 105 pos += 2; 106 big_endian_store_16(packet, pos, attr_value_size); 107 pos += 2; 108 } 109 memcpy(packet+pos, attr_value, attr_value_to_copy); 110 pos += attr_value_size; 111 return header * 8 + attr_value_size; 112 } 113 114 static int avrcp_target_abort_continue_response(uint16_t cid, avrcp_connection_t * connection){ 115 uint16_t pos = 0; 116 l2cap_reserve_packet_buffer(); 117 uint8_t * packet = l2cap_get_outgoing_buffer(); 118 119 connection->command_opcode = AVRCP_CMD_OPCODE_VENDOR_DEPENDENT; 120 connection->command_type = AVRCP_CTYPE_RESPONSE_ACCEPTED; 121 connection->subunit_type = AVRCP_SUBUNIT_TYPE_PANEL; 122 connection->subunit_id = AVRCP_SUBUNIT_ID; 123 124 packet[pos++] = (connection->transaction_label << 4) | (AVRCP_SINGLE_PACKET << 2) | (AVRCP_RESPONSE_FRAME << 1) | 0; 125 // Profile IDentifier (PID) 126 packet[pos++] = BLUETOOTH_SERVICE_CLASS_AV_REMOTE_CONTROL >> 8; 127 packet[pos++] = BLUETOOTH_SERVICE_CLASS_AV_REMOTE_CONTROL & 0x00FF; 128 129 // command_type 130 packet[pos++] = connection->command_type; 131 // subunit_type | subunit ID 132 packet[pos++] = (connection->subunit_type << 3) | connection->subunit_id; 133 // opcode 134 packet[pos++] = (uint8_t)connection->command_opcode; 135 136 // company id is 3 bytes long 137 big_endian_store_24(packet, pos, BT_SIG_COMPANY_ID); 138 pos += 3; 139 140 packet[pos++] = AVRCP_PDU_ID_REQUEST_ABORT_CONTINUING_RESPONSE; 141 142 // reserve byte for packet type 143 packet[pos++] = AVRCP_SINGLE_PACKET; 144 big_endian_store_16(packet, pos, 0); 145 pos += 2; 146 return l2cap_send_prepared(cid, pos); 147 } 148 149 static int avrcp_target_send_now_playing_info(uint16_t cid, avrcp_connection_t * connection){ 150 uint16_t pos = 0; 151 l2cap_reserve_packet_buffer(); 152 uint8_t * packet = l2cap_get_outgoing_buffer(); 153 uint16_t size = l2cap_get_remote_mtu_for_local_cid(connection->l2cap_signaling_cid); 154 155 packet[pos++] = (connection->transaction_label << 4) | (AVRCP_SINGLE_PACKET << 2) | (AVRCP_RESPONSE_FRAME << 1) | 0; 156 // Profile IDentifier (PID) 157 packet[pos++] = BLUETOOTH_SERVICE_CLASS_AV_REMOTE_CONTROL >> 8; 158 packet[pos++] = BLUETOOTH_SERVICE_CLASS_AV_REMOTE_CONTROL & 0x00FF; 159 160 // command_type 161 packet[pos++] = connection->command_type; 162 // subunit_type | subunit ID 163 packet[pos++] = (connection->subunit_type << 3) | connection->subunit_id; 164 // opcode 165 packet[pos++] = (uint8_t)connection->command_opcode; 166 167 // company id is 3 bytes long 168 big_endian_store_24(packet, pos, BT_SIG_COMPANY_ID); 169 pos += 3; 170 171 packet[pos++] = AVRCP_PDU_ID_GET_ELEMENT_ATTRIBUTES; 172 173 // reserve byte for packet type 174 uint8_t pos_packet_type = pos; 175 pos++; 176 177 uint16_t playing_info_buffer_len_position = pos; 178 pos += 2; 179 // printf("connection->next_attr_id %d \n", connection->next_attr_id); 180 if (connection->next_attr_id == AVRCP_MEDIA_ATTR_NONE){ 181 packet[pos_packet_type] = AVRCP_SINGLE_PACKET; 182 connection->packet_type = AVRCP_SINGLE_PACKET; 183 packet[pos++] = count_set_bits_uint32(connection->now_playing_info_attr_bitmap); 184 connection->next_attr_id++; 185 } 186 // printf("updated connection->next_attr_id %d, connection->attribute_value_offset %d \n", connection->next_attr_id, connection->attribute_value_offset); 187 188 uint8_t fragmented = 0; 189 int num_free_bytes = size - pos - 2; 190 uint8_t MAX_NUMBER_ATTR_LEN = 10; 191 192 while (!fragmented && num_free_bytes > 0 && connection->next_attr_id <= AVRCP_MEDIA_ATTR_SONG_LENGTH_MS){ 193 avrcp_media_attribute_id_t attr_id = connection->next_attr_id; 194 int attr_index = attr_id - 1; 195 196 if (connection->now_playing_info_attr_bitmap & (1 << attr_id)){ 197 int num_written_bytes = 0; 198 int num_bytes_to_write = 0; 199 switch (attr_id){ 200 case AVRCP_MEDIA_ATTR_ALL: 201 case AVRCP_MEDIA_ATTR_NONE: 202 break; 203 case AVRCP_MEDIA_ATTR_TRACK: 204 num_bytes_to_write = AVRCP_ATTR_HEADER_LEN + MAX_NUMBER_ATTR_LEN; 205 if (num_free_bytes >= num_bytes_to_write){ 206 num_written_bytes = avrcp_target_pack_single_element_attribute_number(packet, pos, attr_id, connection->track_nr); 207 break; 208 } 209 fragmented = 1; 210 connection->attribute_value_offset = 0; 211 break; 212 case AVRCP_MEDIA_ATTR_TOTAL_NUM_ITEMS: 213 num_bytes_to_write = AVRCP_ATTR_HEADER_LEN + MAX_NUMBER_ATTR_LEN; 214 if (num_free_bytes >= num_bytes_to_write){ 215 num_written_bytes = avrcp_target_pack_single_element_attribute_number(packet, pos, attr_id, connection->total_tracks); 216 break; 217 } 218 fragmented = 1; 219 connection->attribute_value_offset = 0; 220 break; 221 case AVRCP_MEDIA_ATTR_SONG_LENGTH_MS: 222 num_bytes_to_write = AVRCP_ATTR_HEADER_LEN + MAX_NUMBER_ATTR_LEN; 223 if (num_free_bytes >= num_bytes_to_write){ 224 num_written_bytes = avrcp_target_pack_single_element_attribute_number(packet, pos, attr_id, connection->song_length_ms); 225 break; 226 } 227 fragmented = 1; 228 connection->attribute_value_offset = 0; 229 break; 230 default:{ 231 uint8_t header = (connection->attribute_value_offset == 0); 232 uint8_t * attr_value = (uint8_t *) (connection->now_playing_info[attr_index].value + connection->attribute_value_offset); 233 uint16_t attr_value_len = connection->now_playing_info[attr_index].len - connection->attribute_value_offset; 234 235 num_bytes_to_write = attr_value_len + header * AVRCP_ATTR_HEADER_LEN; 236 if (num_bytes_to_write <= num_free_bytes){ 237 connection->attribute_value_offset = 0; 238 num_written_bytes = num_bytes_to_write; 239 avrcp_target_pack_single_element_attribute_string(packet, pos, RFC2978_CHARSET_MIB_UTF8, attr_id, attr_value, attr_value_len, connection->now_playing_info[attr_index].len, header); 240 break; 241 } 242 fragmented = 1; 243 num_written_bytes = num_free_bytes; 244 attr_value_len = num_free_bytes - header * AVRCP_ATTR_HEADER_LEN; 245 avrcp_target_pack_single_element_attribute_string(packet, pos, RFC2978_CHARSET_MIB_UTF8, attr_id, attr_value, attr_value_len, connection->now_playing_info[attr_index].len, header); 246 connection->attribute_value_offset += attr_value_len; 247 break; 248 } 249 } 250 pos += num_written_bytes; 251 num_free_bytes -= num_written_bytes; 252 } 253 if (!fragmented){ 254 connection->next_attr_id++; 255 } 256 } 257 258 if (fragmented){ 259 switch (connection->packet_type){ 260 case AVRCP_SINGLE_PACKET: 261 connection->packet_type = AVRCP_START_PACKET; 262 break; 263 default: 264 connection->packet_type = AVRCP_CONTINUE_PACKET; 265 break; 266 } 267 } else { 268 if (connection->next_attr_id >= AVRCP_MEDIA_ATTR_SONG_LENGTH_MS){ // DONE 269 if (connection->packet_type != AVRCP_SINGLE_PACKET){ 270 connection->packet_type = AVRCP_END_PACKET; 271 } 272 } 273 } 274 packet[pos_packet_type] = connection->packet_type; 275 // store attr value length 276 big_endian_store_16(packet, playing_info_buffer_len_position, pos - playing_info_buffer_len_position - 2); 277 return l2cap_send_prepared(cid, size); 278 } 279 280 281 282 static int avrcp_target_send_response(uint16_t cid, avrcp_connection_t * connection){ 283 int pos = 0; 284 l2cap_reserve_packet_buffer(); 285 uint8_t * packet = l2cap_get_outgoing_buffer(); 286 287 // transport header 288 // Transaction label | Packet_type | C/R | IPID (1 == invalid profile identifier) 289 290 // TODO: check for fragmentation 291 connection->packet_type = AVRCP_SINGLE_PACKET; 292 293 packet[pos++] = (connection->transaction_label << 4) | (connection->packet_type << 2) | (AVRCP_RESPONSE_FRAME << 1) | 0; 294 // Profile IDentifier (PID) 295 packet[pos++] = BLUETOOTH_SERVICE_CLASS_AV_REMOTE_CONTROL >> 8; 296 packet[pos++] = BLUETOOTH_SERVICE_CLASS_AV_REMOTE_CONTROL & 0x00FF; 297 // command_type 298 packet[pos++] = connection->command_type; 299 // subunit_type | subunit ID 300 packet[pos++] = (connection->subunit_type << 3) | connection->subunit_id; 301 // opcode 302 packet[pos++] = (uint8_t)connection->command_opcode; 303 // operands 304 memcpy(packet+pos, connection->cmd_operands, connection->cmd_operands_length); 305 // printf_hexdump(packet+pos, connection->cmd_operands_length); 306 307 pos += connection->cmd_operands_length; 308 connection->wait_to_send = 0; 309 return l2cap_send_prepared(cid, pos); 310 } 311 312 static uint8_t avrcp_target_response_accept(avrcp_connection_t * connection, avrcp_subunit_type_t subunit_type, avrcp_subunit_id_t subunit_id, avrcp_command_opcode_t opcode, avrcp_pdu_id_t pdu_id, avrcp_status_code_t status){ 313 // AVRCP_CTYPE_RESPONSE_REJECTED 314 connection->command_type = AVRCP_CTYPE_RESPONSE_ACCEPTED; 315 connection->subunit_type = subunit_type; 316 connection->subunit_id = subunit_id; 317 connection->command_opcode = opcode; 318 // company id is 3 bytes long 319 int pos = connection->cmd_operands_length; 320 connection->cmd_operands[pos++] = pdu_id; 321 connection->cmd_operands[pos++] = 0; 322 // param length 323 big_endian_store_16(connection->cmd_operands, pos, 1); 324 pos += 2; 325 connection->cmd_operands[pos++] = status; 326 connection->cmd_operands_length = pos; 327 connection->state = AVCTP_W2_SEND_RESPONSE; 328 avrcp_request_can_send_now(connection, connection->l2cap_signaling_cid); 329 return ERROR_CODE_SUCCESS; 330 } 331 332 static uint8_t avrcp_target_response_reject(avrcp_connection_t * connection, avrcp_subunit_type_t subunit_type, avrcp_subunit_id_t subunit_id, avrcp_command_opcode_t opcode, avrcp_pdu_id_t pdu_id, avrcp_status_code_t status){ 333 // AVRCP_CTYPE_RESPONSE_REJECTED 334 connection->command_type = AVRCP_CTYPE_RESPONSE_REJECTED; 335 connection->subunit_type = subunit_type; 336 connection->subunit_id = subunit_id; 337 connection->command_opcode = opcode; 338 // company id is 3 bytes long 339 int pos = connection->cmd_operands_length; 340 connection->cmd_operands[pos++] = pdu_id; 341 connection->cmd_operands[pos++] = 0; 342 // param length 343 big_endian_store_16(connection->cmd_operands, pos, 1); 344 pos += 2; 345 connection->cmd_operands[pos++] = status; 346 connection->cmd_operands_length = pos; 347 connection->state = AVCTP_W2_SEND_RESPONSE; 348 avrcp_request_can_send_now(connection, connection->l2cap_signaling_cid); 349 return ERROR_CODE_SUCCESS; 350 } 351 352 static uint8_t avrcp_target_response_not_implemented(avrcp_connection_t * connection, avrcp_subunit_type_t subunit_type, avrcp_subunit_id_t subunit_id, avrcp_command_opcode_t opcode, avrcp_pdu_id_t pdu_id, uint8_t event_id){ 353 connection->command_type = AVRCP_CTYPE_RESPONSE_NOT_IMPLEMENTED; 354 connection->subunit_type = subunit_type; 355 connection->subunit_id = subunit_id; 356 connection->command_opcode = opcode; 357 358 // company id is 3 bytes long 359 int pos = connection->cmd_operands_length; 360 connection->cmd_operands[pos++] = pdu_id; 361 connection->cmd_operands[pos++] = 0; 362 // param length 363 big_endian_store_16(connection->cmd_operands, pos, 1); 364 pos += 2; 365 connection->cmd_operands[pos++] = event_id; 366 connection->cmd_operands_length = pos; 367 368 connection->state = AVCTP_W2_SEND_RESPONSE; 369 avrcp_request_can_send_now(connection, connection->l2cap_signaling_cid); 370 return ERROR_CODE_SUCCESS; 371 } 372 373 static uint8_t avrcp_target_response_vendor_dependent_interim(avrcp_connection_t * connection, avrcp_subunit_type_t subunit_type, avrcp_subunit_id_t subunit_id, avrcp_command_opcode_t opcode, avrcp_pdu_id_t pdu_id, uint8_t event_id, const uint8_t * value, uint16_t value_len){ 374 connection->command_type = AVRCP_CTYPE_RESPONSE_INTERIM; 375 connection->subunit_type = subunit_type; 376 connection->subunit_id = subunit_id; 377 connection->command_opcode = opcode; 378 379 // company id is 3 bytes long 380 int pos = connection->cmd_operands_length; 381 connection->cmd_operands[pos++] = pdu_id; 382 connection->cmd_operands[pos++] = 0; 383 // param length 384 big_endian_store_16(connection->cmd_operands, pos, 1 + value_len); 385 pos += 2; 386 connection->cmd_operands[pos++] = event_id; 387 if (value && value_len > 0){ 388 memcpy(connection->cmd_operands + pos, value, value_len); 389 pos += value_len; 390 } 391 connection->cmd_operands_length = pos; 392 393 connection->state = AVCTP_W2_SEND_RESPONSE; 394 avrcp_request_can_send_now(connection, connection->l2cap_signaling_cid); 395 return ERROR_CODE_SUCCESS; 396 } 397 398 static uint8_t avrcp_target_response_addressed_player_changed_interim(avrcp_connection_t * connection, avrcp_subunit_type_t subunit_type, avrcp_subunit_id_t subunit_id, avrcp_command_opcode_t opcode, avrcp_pdu_id_t pdu_id){ 399 connection->command_type = AVRCP_CTYPE_RESPONSE_INTERIM; 400 connection->subunit_type = subunit_type; 401 connection->subunit_id = subunit_id; 402 connection->command_opcode = opcode; 403 printf("avrcp_target_response_addressed_player_changed_interim \n"); 404 // company id is 3 bytes long 405 int pos = connection->cmd_operands_length; 406 connection->cmd_operands[pos++] = pdu_id; 407 connection->cmd_operands[pos++] = 0; 408 // param length 409 big_endian_store_16(connection->cmd_operands, pos, 5); 410 pos += 2; 411 connection->cmd_operands[pos++] = AVRCP_NOTIFICATION_EVENT_ADDRESSED_PLAYER_CHANGED; 412 big_endian_read_16( &connection->cmd_operands[pos], connection->addressed_player_id); 413 pos += 2; 414 big_endian_read_16( &connection->cmd_operands[pos], connection->uid_counter); 415 pos += 2; 416 417 connection->cmd_operands_length = pos; 418 connection->state = AVCTP_W2_SEND_RESPONSE; 419 avrcp_request_can_send_now(connection, connection->l2cap_signaling_cid); 420 return ERROR_CODE_SUCCESS; 421 } 422 423 424 // static uint8_t avrcp_target_response_vendor_dependent_changed(avrcp_connection_t * connection, avrcp_pdu_id_t pdu_id, uint8_t event_id){ 425 // connection->command_opcode = AVRCP_CMD_OPCODE_VENDOR_DEPENDENT; 426 // connection->command_type = AVRCP_CTYPE_RESPONSE_CHANGED_STABLE; 427 // connection->subunit_type = AVRCP_SUBUNIT_TYPE_PANEL; 428 // connection->subunit_id = AVRCP_SUBUNIT_ID; 429 430 // // company id is 3 bytes long 431 // int pos = connection->cmd_operands_length; 432 // connection->cmd_operands[pos++] = pdu_id; 433 // connection->cmd_operands[pos++] = 0; 434 // // param length 435 // big_endian_store_16(connection->cmd_operands, pos, 1); 436 // pos += 2; 437 // connection->cmd_operands[pos++] = event_id; 438 // connection->cmd_operands_length = pos; 439 440 // connection->state = AVCTP_W2_SEND_RESPONSE; 441 // avrcp_request_can_send_now(connection, connection->l2cap_signaling_cid); 442 // return ERROR_CODE_SUCCESS; 443 // } 444 445 static uint8_t avrcp_target_pass_through_response(uint16_t avrcp_cid, avrcp_command_type_t cmd_type, avrcp_operation_id_t opid, uint8_t operands_length, uint8_t operand){ 446 avrcp_connection_t * connection = get_avrcp_connection_for_avrcp_cid(avrcp_cid, &avrcp_target_context); 447 if (!connection){ 448 log_error("Could not find a connection."); 449 return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER; 450 } 451 connection->command_type = cmd_type; 452 connection->subunit_type = AVRCP_SUBUNIT_TYPE_PANEL; 453 connection->subunit_id = AVRCP_SUBUNIT_ID; 454 connection->command_opcode = AVRCP_CMD_OPCODE_PASS_THROUGH; 455 456 int pos = 0; 457 connection->cmd_operands[pos++] = opid; 458 connection->cmd_operands[pos++] = operands_length; 459 if (operands_length == 1){ 460 connection->cmd_operands[pos++] = operand; 461 } 462 connection->cmd_operands_length = pos; 463 464 connection->state = AVCTP_W2_SEND_RESPONSE; 465 avrcp_request_can_send_now(connection, connection->l2cap_signaling_cid); 466 return ERROR_CODE_SUCCESS; 467 } 468 469 uint8_t avrcp_target_operation_rejected(uint16_t avrcp_cid, avrcp_operation_id_t opid, uint8_t operands_length, uint8_t operand){ 470 return avrcp_target_pass_through_response(avrcp_cid, AVRCP_CTYPE_RESPONSE_REJECTED, opid, operands_length, operand); 471 } 472 473 uint8_t avrcp_target_operation_accepted(uint16_t avrcp_cid, avrcp_operation_id_t opid, uint8_t operands_length, uint8_t operand){ 474 return avrcp_target_pass_through_response(avrcp_cid, AVRCP_CTYPE_RESPONSE_ACCEPTED, opid, operands_length, operand); 475 } 476 477 uint8_t avrcp_target_operation_not_implemented(uint16_t avrcp_cid, avrcp_operation_id_t opid, uint8_t operands_length, uint8_t operand){ 478 return avrcp_target_pass_through_response(avrcp_cid, AVRCP_CTYPE_RESPONSE_ACCEPTED, opid, operands_length, operand); 479 } 480 481 void avrcp_target_set_unit_info(uint16_t avrcp_cid, avrcp_subunit_type_t unit_type, uint32_t company_id){ 482 avrcp_connection_t * connection = get_avrcp_connection_for_avrcp_cid(avrcp_cid, &avrcp_target_context); 483 if (!connection){ 484 log_error("avrcp_target_operation_reject: could not find a connection."); 485 return; 486 } 487 connection->unit_type = unit_type; 488 connection->company_id = company_id; 489 } 490 491 void avrcp_target_set_subunit_info(uint16_t avrcp_cid, avrcp_subunit_type_t subunit_type, const uint8_t * subunit_info_data, uint16_t subunit_info_data_size){ 492 avrcp_connection_t * connection = get_avrcp_connection_for_avrcp_cid(avrcp_cid, &avrcp_target_context); 493 if (!connection){ 494 log_error("avrcp_target_operation_reject: could not find a connection."); 495 return; 496 } 497 connection->subunit_info_type = subunit_type; 498 connection->subunit_info_data = subunit_info_data; 499 connection->subunit_info_data_size = subunit_info_data_size; 500 } 501 502 static uint8_t avrcp_target_unit_info(avrcp_connection_t * connection){ 503 if (connection->state != AVCTP_CONNECTION_OPENED) return ERROR_CODE_COMMAND_DISALLOWED; 504 505 uint8_t unit = 0; 506 connection->command_type = AVRCP_CTYPE_RESPONSE_IMPLEMENTED_STABLE; 507 connection->subunit_type = AVRCP_SUBUNIT_TYPE_UNIT; //vendor unique 508 connection->subunit_id = AVRCP_SUBUNIT_ID_IGNORE; 509 connection->command_opcode = AVRCP_CMD_OPCODE_UNIT_INFO; 510 511 connection->cmd_operands_length = 5; 512 connection->cmd_operands[0] = 0x07; 513 connection->cmd_operands[1] = (connection->unit_type << 4) | unit; 514 // company id is 3 bytes long 515 big_endian_store_32(connection->cmd_operands, 2, connection->company_id); 516 517 connection->state = AVCTP_W2_SEND_RESPONSE; 518 avrcp_request_can_send_now(connection, connection->l2cap_signaling_cid); 519 return ERROR_CODE_SUCCESS; 520 } 521 522 static uint8_t avrcp_target_subunit_info(avrcp_connection_t * connection, uint8_t offset){ 523 if (connection->state != AVCTP_CONNECTION_OPENED) return ERROR_CODE_COMMAND_DISALLOWED; 524 if (offset - 4 > connection->subunit_info_data_size) return AVRCP_STATUS_INVALID_PARAMETER; 525 526 connection->command_opcode = AVRCP_CMD_OPCODE_SUBUNIT_INFO; 527 connection->command_type = AVRCP_CTYPE_RESPONSE_IMPLEMENTED_STABLE; 528 connection->subunit_type = AVRCP_SUBUNIT_TYPE_UNIT; //vendor unique 529 connection->subunit_id = AVRCP_SUBUNIT_ID_IGNORE; 530 // printf("avrcp_target_subunit_info subunit_type %d\n", connection->subunit_type); 531 532 uint8_t page = offset / 4; 533 uint8_t extension_code = 7; 534 connection->cmd_operands_length = 5; 535 connection->cmd_operands[0] = (page << 4) | extension_code; 536 537 memcpy(connection->cmd_operands+1, connection->subunit_info_data + offset, 4); 538 539 connection->state = AVCTP_W2_SEND_RESPONSE; 540 avrcp_request_can_send_now(connection, connection->l2cap_signaling_cid); 541 return ERROR_CODE_SUCCESS; 542 } 543 544 static inline uint8_t avrcp_prepare_vendor_dependent_response(uint16_t avrcp_cid, avrcp_connection_t ** out_connection, avrcp_pdu_id_t pdu_id, uint16_t param_length){ 545 *out_connection = get_avrcp_connection_for_avrcp_cid(avrcp_cid, &avrcp_target_context); 546 if (!*out_connection){ 547 log_error("avrcp tartget: could not find a connection."); 548 return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER; 549 } 550 551 if ((*out_connection)->state != AVCTP_CONNECTION_OPENED) return ERROR_CODE_COMMAND_DISALLOWED; 552 (*out_connection)->command_opcode = AVRCP_CMD_OPCODE_VENDOR_DEPENDENT; 553 (*out_connection)->command_type = AVRCP_CTYPE_RESPONSE_IMPLEMENTED_STABLE; 554 (*out_connection)->subunit_type = AVRCP_SUBUNIT_TYPE_PANEL; 555 (*out_connection)->subunit_id = AVRCP_SUBUNIT_ID; 556 557 (*out_connection)->cmd_operands[(*out_connection)->cmd_operands_length++] = pdu_id; 558 // reserved 559 (*out_connection)->cmd_operands[(*out_connection)->cmd_operands_length++] = 0; 560 // param length 561 big_endian_store_16((*out_connection)->cmd_operands, (*out_connection)->cmd_operands_length, param_length); 562 (*out_connection)->cmd_operands_length += 2; 563 return ERROR_CODE_SUCCESS; 564 } 565 566 static uint8_t avrcp_target_capability(uint16_t avrcp_cid, avrcp_capability_id_t capability_id, uint8_t capabilities_num, uint8_t * capabilities, uint8_t size){ 567 avrcp_connection_t * connection = NULL; 568 uint8_t status = avrcp_prepare_vendor_dependent_response(avrcp_cid, &connection, AVRCP_PDU_ID_GET_CAPABILITIES, 2+size); 569 if (status != ERROR_CODE_SUCCESS) return status; 570 571 connection->cmd_operands[connection->cmd_operands_length++] = capability_id; 572 connection->cmd_operands[connection->cmd_operands_length++] = capabilities_num; 573 memcpy(connection->cmd_operands+connection->cmd_operands_length, capabilities, size); 574 connection->cmd_operands_length += size; 575 576 connection->state = AVCTP_W2_SEND_RESPONSE; 577 avrcp_request_can_send_now(connection, connection->l2cap_signaling_cid); 578 return ERROR_CODE_SUCCESS; 579 } 580 581 uint8_t avrcp_target_supported_events(uint16_t avrcp_cid, uint8_t capabilities_num, uint8_t * capabilities, uint8_t size){ 582 return avrcp_target_capability(avrcp_cid, AVRCP_CAPABILITY_ID_EVENT, capabilities_num, capabilities, size); 583 } 584 585 uint8_t avrcp_target_supported_companies(uint16_t avrcp_cid, uint8_t capabilities_num, uint8_t * capabilities, uint8_t size ){ 586 return avrcp_target_capability(avrcp_cid, AVRCP_CAPABILITY_ID_COMPANY, capabilities_num, capabilities, size); 587 } 588 589 uint8_t avrcp_target_play_status(uint16_t avrcp_cid, uint32_t song_length_ms, uint32_t song_position_ms, avrcp_playback_status_t play_status){ 590 avrcp_connection_t * connection = NULL; 591 uint8_t status = avrcp_prepare_vendor_dependent_response(avrcp_cid, &connection, AVRCP_PDU_ID_GET_PLAY_STATUS, 11); 592 if (status != ERROR_CODE_SUCCESS) return status; 593 594 big_endian_store_32(connection->cmd_operands, connection->cmd_operands_length, song_length_ms); 595 connection->cmd_operands_length += 4; 596 big_endian_store_32(connection->cmd_operands, connection->cmd_operands_length, song_position_ms); 597 connection->cmd_operands_length += 4; 598 connection->cmd_operands[connection->cmd_operands_length++] = play_status; 599 600 connection->state = AVCTP_W2_SEND_RESPONSE; 601 avrcp_request_can_send_now(connection, connection->l2cap_signaling_cid); 602 return ERROR_CODE_SUCCESS; 603 } 604 605 static uint8_t avrcp_target_now_playing_info(avrcp_connection_t * connection){ 606 connection->now_playing_info_response = 1; 607 if (connection->state != AVCTP_CONNECTION_OPENED) return ERROR_CODE_COMMAND_DISALLOWED; 608 connection->command_opcode = AVRCP_CMD_OPCODE_VENDOR_DEPENDENT; 609 connection->command_type = AVRCP_CTYPE_RESPONSE_IMPLEMENTED_STABLE; 610 connection->subunit_type = AVRCP_SUBUNIT_TYPE_PANEL; 611 connection->subunit_id = AVRCP_SUBUNIT_ID; 612 613 connection->state = AVCTP_W2_SEND_RESPONSE; 614 avrcp_request_can_send_now(connection, connection->l2cap_signaling_cid); 615 return ERROR_CODE_SUCCESS; 616 } 617 618 static uint8_t avrcp_target_store_media_attr(avrcp_connection_t * connection, avrcp_media_attribute_id_t attr_id, const char * value){ 619 int index = attr_id - 1; 620 if (!value) return AVRCP_STATUS_INVALID_PARAMETER; 621 connection->now_playing_info[index].value = (uint8_t*)value; 622 connection->now_playing_info[index].len = strlen(value); 623 // printf("store %lu bytes, %s\n", strlen(value), value); 624 return ERROR_CODE_SUCCESS; 625 } 626 627 uint8_t avrcp_target_set_playback_status(uint16_t avrcp_cid, avrcp_playback_status_t playback_status){ 628 avrcp_connection_t * connection = get_avrcp_connection_for_avrcp_cid(avrcp_cid, &avrcp_target_context); 629 if (!connection){ 630 log_error("avrcp_unit_info: could not find a connection."); 631 return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER; 632 } 633 if (connection->playback_status == playback_status) return ERROR_CODE_SUCCESS; 634 635 connection->playback_status = playback_status; 636 connection->playback_status_changed = 1; 637 avrcp_request_can_send_now(connection, connection->l2cap_signaling_cid); 638 return ERROR_CODE_SUCCESS; 639 } 640 641 void avrcp_target_set_now_playing_info(uint16_t avrcp_cid, const avrcp_track_t * current_track, uint16_t total_tracks){ 642 avrcp_connection_t * connection = get_avrcp_connection_for_avrcp_cid(avrcp_cid, &avrcp_target_context); 643 if (!connection){ 644 log_error("avrcp_unit_info: could not find a connection. cid 0x%02x\n", avrcp_cid); 645 return; 646 } 647 if (!current_track){ 648 connection->track_selected = 0; 649 connection->playback_status = AVRCP_PLAYBACK_STATUS_ERROR; 650 return; 651 } 652 memcpy(connection->track_id, current_track->track_id, 8); 653 connection->song_length_ms = current_track->song_length_ms; 654 connection->track_nr = current_track->track_nr; 655 connection->total_tracks = total_tracks; 656 avrcp_target_store_media_attr(connection, AVRCP_MEDIA_ATTR_TITLE, current_track->title); 657 avrcp_target_store_media_attr(connection, AVRCP_MEDIA_ATTR_ARTIST, current_track->artist); 658 avrcp_target_store_media_attr(connection, AVRCP_MEDIA_ATTR_ALBUM, current_track->album); 659 avrcp_target_store_media_attr(connection, AVRCP_MEDIA_ATTR_GENRE, current_track->genre); 660 connection->track_selected = 1; 661 662 if (connection->notifications_enabled & (1 << AVRCP_NOTIFICATION_EVENT_TRACK_CHANGED)) { 663 connection->track_changed = 1; 664 avrcp_request_can_send_now(connection, connection->l2cap_signaling_cid); 665 } 666 return; 667 } 668 669 uint8_t avrcp_target_track_changed(uint16_t avrcp_cid, uint8_t * track_id){ 670 avrcp_connection_t * connection = get_avrcp_connection_for_avrcp_cid(avrcp_cid, &avrcp_target_context); 671 if (!connection){ 672 log_error("avrcp_target_track_changed: could not find connection."); 673 return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER; 674 } 675 if (!track_id) return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER; 676 677 if (connection->notifications_enabled & (1 << AVRCP_NOTIFICATION_EVENT_TRACK_CHANGED)) { 678 connection->track_changed = 1; 679 memcpy(connection->track_id, track_id, 8); 680 avrcp_request_can_send_now(connection, connection->l2cap_signaling_cid); 681 } 682 return ERROR_CODE_SUCCESS; 683 } 684 685 uint8_t avrcp_target_playing_content_changed(uint16_t avrcp_cid){ 686 avrcp_connection_t * connection = get_avrcp_connection_for_avrcp_cid(avrcp_cid, &avrcp_target_context); 687 if (!connection){ 688 log_error("avrcp_target_playing_content_changed: could not find a connection."); 689 return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER; 690 } 691 if (connection->notifications_enabled & (1 << AVRCP_NOTIFICATION_EVENT_NOW_PLAYING_CONTENT_CHANGED)) { 692 connection->playing_content_changed = 1; 693 avrcp_request_can_send_now(connection, connection->l2cap_signaling_cid); 694 } 695 return ERROR_CODE_SUCCESS; 696 } 697 698 uint8_t avrcp_target_addressed_player_changed(uint16_t avrcp_cid, uint16_t player_id, uint16_t uid_counter){ 699 avrcp_connection_t * connection = get_avrcp_connection_for_avrcp_cid(avrcp_cid, &avrcp_target_context); 700 if (!connection){ 701 log_error("avrcp_unit_info: could not find a connection."); 702 return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER; 703 } 704 if (connection->notifications_enabled & (1 << AVRCP_NOTIFICATION_EVENT_ADDRESSED_PLAYER_CHANGED)) { 705 printf("send AVRCP_NOTIFICATION_EVENT_ADDRESSED_PLAYER_CHANGED\n"); 706 // connection->addressed_player_changed = 1; 707 // connection->uid_counter = uid_counter; 708 // connection->addressed_player_id = player_id; 709 // avrcp_request_can_send_now(connection, connection->l2cap_signaling_cid); 710 } 711 return ERROR_CODE_SUCCESS; 712 } 713 714 uint8_t avrcp_target_battery_status_changed(uint16_t avrcp_cid, avrcp_battery_status_t battery_status){ 715 avrcp_connection_t * connection = get_avrcp_connection_for_avrcp_cid(avrcp_cid, &avrcp_target_context); 716 if (!connection){ 717 log_error("avrcp_unit_info: could not find a connection."); 718 return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER; 719 } 720 if (connection->battery_status == battery_status) return ERROR_CODE_SUCCESS; 721 if (connection->notifications_enabled & (1 << AVRCP_NOTIFICATION_EVENT_BATT_STATUS_CHANGED)) { 722 connection->battery_status = battery_status; 723 connection->battery_status_changed = 1; 724 avrcp_request_can_send_now(connection, connection->l2cap_signaling_cid); 725 } 726 return ERROR_CODE_SUCCESS; 727 } 728 729 uint8_t avrcp_target_volume_changed(uint16_t avrcp_cid, uint8_t volume_percentage){ 730 avrcp_connection_t * connection = get_avrcp_connection_for_avrcp_cid(avrcp_cid, &avrcp_target_context); 731 if (!connection){ 732 log_error("avrcp_unit_info: could not find a connection."); 733 return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER; 734 } 735 if (connection->volume_percentage == volume_percentage) return ERROR_CODE_SUCCESS; 736 if (connection->notifications_enabled & (1 << AVRCP_NOTIFICATION_EVENT_VOLUME_CHANGED )) { 737 connection->volume_percentage = volume_percentage; 738 connection->volume_percentage_changed = 1; 739 avrcp_request_can_send_now(connection, connection->l2cap_signaling_cid); 740 } 741 return ERROR_CODE_SUCCESS; 742 } 743 744 745 static uint8_t * avrcp_get_company_id(uint8_t *packet, uint16_t size){ 746 UNUSED(size); 747 return packet + 6; 748 } 749 750 static uint8_t * avrcp_get_pdu(uint8_t *packet, uint16_t size){ 751 UNUSED(size); 752 return packet + 9; 753 } 754 755 static uint8_t avrcp_is_receive_pass_through_cmd(uint8_t operation_id){ 756 return operation_id & 0x80; 757 } 758 759 static void avrcp_handle_l2cap_data_packet_for_signaling_connection(avrcp_connection_t * connection, uint8_t *packet, uint16_t size){ 760 UNUSED(connection); 761 UNUSED(packet); 762 UNUSED(size); 763 764 // uint8_t opcode; 765 766 uint8_t transport_header = packet[0]; 767 connection->transaction_label = transport_header >> 4; 768 // uint8_t packet_type = (transport_header & 0x0F) >> 2; 769 // uint8_t frame_type = (transport_header & 0x03) >> 1; 770 // uint8_t ipid = transport_header & 0x01; 771 // uint8_t byte_value = packet[2]; 772 // uint16_t pid = (byte_value << 8) | packet[2]; 773 // avrcp_command_type_t ctype = (avrcp_command_type_t) packet[3]; 774 // uint8_t byte_value = packet[4]; 775 avrcp_subunit_type_t subunit_type = (avrcp_subunit_type_t) (packet[4] >> 3); 776 avrcp_subunit_id_t subunit_id = (avrcp_subunit_id_t) (packet[4] & 0x07); 777 // opcode = packet[pos++]; 778 779 // printf(" Transport header 0x%02x (transaction_label %d, packet_type %d, frame_type %d, ipid %d), pid 0x%4x\n", 780 // transport_header, transaction_label, packet_type, frame_type, ipid, pid); 781 // printf_hexdump(packet+pos, size-pos); 782 783 avrcp_command_opcode_t opcode = avrcp_cmd_opcode(packet,size); 784 uint8_t * company_id = avrcp_get_company_id(packet, size); 785 uint8_t * pdu = avrcp_get_pdu(packet, size); 786 // uint16_t param_length = big_endian_read_16(pdu, 2); 787 788 int pos = 4; 789 uint8_t pdu_id; 790 connection->cmd_operands_length = 0; 791 792 switch (opcode){ 793 case AVRCP_CMD_OPCODE_UNIT_INFO: 794 avrcp_target_unit_info(connection); 795 break; 796 case AVRCP_CMD_OPCODE_SUBUNIT_INFO:{ 797 uint8_t offset = 4 * (packet[pos+2]>>4); 798 avrcp_target_subunit_info(connection, offset); 799 break; 800 } 801 case AVRCP_CMD_OPCODE_PASS_THROUGH:{ 802 log_info("AVRCP_OPERATION_ID 0x%02x, operands length %d, operand %d", packet[6], packet[7], packet[8]); 803 avrcp_operation_id_t operation_id = packet[6]; 804 805 if (avrcp_is_receive_pass_through_cmd(operation_id)){ 806 operation_id = packet[6] & 0x7F; 807 avrcp_target_operation_accepted(connection->avrcp_cid, packet[6], packet[7], packet[8]); 808 break; 809 } 810 811 switch (operation_id){ 812 case AVRCP_OPERATION_ID_PLAY: 813 case AVRCP_OPERATION_ID_PAUSE: 814 case AVRCP_OPERATION_ID_STOP: 815 case AVRCP_OPERATION_ID_VOLUME_UP: 816 case AVRCP_OPERATION_ID_VOLUME_DOWN: 817 case AVRCP_OPERATION_ID_REWIND: 818 case AVRCP_OPERATION_ID_FAST_FORWARD: 819 case AVRCP_OPERATION_ID_FORWARD: 820 case AVRCP_OPERATION_ID_BACKWARD: 821 case AVRCP_OPERATION_ID_SKIP: 822 case AVRCP_OPERATION_ID_MUTE: 823 case AVRCP_OPERATION_ID_CHANNEL_UP: 824 case AVRCP_OPERATION_ID_CHANNEL_DOWN: 825 case AVRCP_OPERATION_ID_SELECT: 826 case AVRCP_OPERATION_ID_UP: 827 case AVRCP_OPERATION_ID_DOWN: 828 case AVRCP_OPERATION_ID_LEFT: 829 case AVRCP_OPERATION_ID_RIGHT: 830 case AVRCP_OPERATION_ID_ROOT_MENU: 831 printf("received op 0x%02x\n", operation_id); 832 avrcp_target_operation_accepted(connection->avrcp_cid, packet[6], packet[7], packet[8]); 833 avrcp_target_emit_operation(avrcp_target_context.avrcp_callback, connection->avrcp_cid, operation_id, packet[7], packet[8]); 834 break; 835 case AVRCP_OPERATION_ID_UNDEFINED: 836 avrcp_target_operation_not_implemented(connection->avrcp_cid, packet[6], packet[7], packet[8]); 837 return; 838 default: 839 avrcp_target_operation_not_implemented(connection->avrcp_cid, packet[6], packet[7], packet[8]); 840 return; 841 } 842 break; 843 } 844 845 case AVRCP_CMD_OPCODE_VENDOR_DEPENDENT: 846 pdu_id = pdu[0]; 847 // 1 - reserved 848 // 2-3 param length, 849 printf_hexdump(packet, size); 850 851 uint16_t length = big_endian_read_16(pdu, 1); 852 memcpy(connection->cmd_operands, company_id, 3); 853 connection->cmd_operands_length = 3; 854 switch (pdu_id){ 855 case AVRCP_PDU_ID_SET_ADDRESSED_PLAYER:{ 856 if (length == 0){ 857 printf(" reject id\n"); 858 avrcp_target_response_reject(connection, subunit_type, subunit_id, opcode, pdu_id, AVRCP_STATUS_INVALID_PLAYER_ID); 859 break; 860 } 861 avrcp_target_response_accept(connection, subunit_type, subunit_id, opcode, pdu_id, AVRCP_STATUS_SUCCESS); 862 break; 863 } 864 case AVRCP_PDU_ID_GET_CAPABILITIES:{ 865 avrcp_capability_id_t capability_id = (avrcp_capability_id_t) pdu[pos]; 866 switch (capability_id){ 867 case AVRCP_CAPABILITY_ID_EVENT: 868 avrcp_target_emit_respond_vendor_dependent_query(avrcp_target_context.avrcp_callback, connection->avrcp_cid, AVRCP_SUBEVENT_EVENT_IDS_QUERY); 869 break; 870 case AVRCP_CAPABILITY_ID_COMPANY: 871 avrcp_target_emit_respond_vendor_dependent_query(avrcp_target_context.avrcp_callback, connection->avrcp_cid, AVRCP_SUBEVENT_COMPANY_IDS_QUERY); 872 break; 873 default: 874 avrcp_target_response_reject(connection, subunit_type, subunit_id, opcode, pdu_id, AVRCP_STATUS_INVALID_PARAMETER); 875 break; 876 } 877 break; 878 } 879 case AVRCP_PDU_ID_GET_PLAY_STATUS: 880 avrcp_target_emit_respond_vendor_dependent_query(avrcp_target_context.avrcp_callback, connection->avrcp_cid, AVRCP_SUBEVENT_PLAY_STATUS_QUERY); 881 break; 882 case AVRCP_PDU_ID_REQUEST_ABORT_CONTINUING_RESPONSE: 883 connection->cmd_operands[0] = pdu[4]; 884 connection->abort_continue_response = 1; 885 avrcp_request_can_send_now(connection, connection->l2cap_signaling_cid); 886 break; 887 case AVRCP_PDU_ID_REQUEST_CONTINUING_RESPONSE: 888 if (pdu[4] != AVRCP_PDU_ID_GET_ELEMENT_ATTRIBUTES){ 889 avrcp_target_response_reject(connection, subunit_type, subunit_id, opcode, pdu_id, AVRCP_STATUS_INVALID_COMMAND); 890 return; 891 } 892 connection->now_playing_info_response = 1; 893 avrcp_request_can_send_now(connection, connection->l2cap_signaling_cid); 894 break; 895 case AVRCP_PDU_ID_GET_ELEMENT_ATTRIBUTES:{ 896 uint8_t play_identifier[8]; 897 memset(play_identifier, 0, 8); 898 if (memcmp(pdu+pos, play_identifier, 8) != 0) { 899 avrcp_target_response_reject(connection, subunit_type, subunit_id, opcode, pdu_id, AVRCP_STATUS_INVALID_PARAMETER); 900 return; 901 } 902 pos += 8; 903 uint8_t attribute_count = pdu[pos++]; 904 // printf("AVRCP_PDU_ID_GET_ELEMENT_ATTRIBUTES attribute count %d\n", attribute_count); 905 connection->next_attr_id = AVRCP_MEDIA_ATTR_NONE; 906 if (!attribute_count){ 907 connection->now_playing_info_attr_bitmap = 0xFE; 908 } else { 909 int i; 910 connection->now_playing_info_attr_bitmap = 0; 911 for (i=0; i < attribute_count; i++){ 912 uint16_t attr_id = big_endian_read_16(pdu, pos); 913 pos += 2; 914 connection->now_playing_info_attr_bitmap |= (1 << attr_id); 915 } 916 } 917 log_info("now_playing_info_attr_bitmap 0x%02x", connection->now_playing_info_attr_bitmap); 918 avrcp_target_now_playing_info(connection); 919 break; 920 } 921 case AVRCP_PDU_ID_REGISTER_NOTIFICATION:{ 922 // 0 - pdu id 923 // 1 - reserved 924 // 2-3 param length 925 avrcp_notification_event_id_t event_id = (avrcp_notification_event_id_t) pdu[4]; 926 uint16_t event_mask = (1 << event_id); 927 928 switch (event_id){ 929 case AVRCP_NOTIFICATION_EVENT_TRACK_CHANGED: 930 connection->notifications_enabled |= event_mask; 931 if (connection->track_selected){ 932 avrcp_target_response_vendor_dependent_interim(connection, subunit_type, subunit_id, opcode, pdu_id, event_id, AVRCP_NOTIFICATION_TRACK_SELECTED, 8); 933 } else { 934 avrcp_target_response_vendor_dependent_interim(connection, subunit_type, subunit_id, opcode, pdu_id, event_id, AVRCP_NOTIFICATION_TRACK_NOT_SELECTED, 8); 935 } 936 break; 937 case AVRCP_NOTIFICATION_EVENT_PLAYBACK_STATUS_CHANGED: 938 connection->notifications_enabled |= event_mask; 939 avrcp_target_response_vendor_dependent_interim(connection, subunit_type, subunit_id, opcode, pdu_id, event_id, (const uint8_t *)&connection->playback_status, 1); 940 break; 941 case AVRCP_NOTIFICATION_EVENT_NOW_PLAYING_CONTENT_CHANGED: 942 connection->notifications_enabled |= event_mask; 943 avrcp_target_response_vendor_dependent_interim(connection, subunit_type, subunit_id, opcode, pdu_id, event_id, NULL, 0); 944 break; 945 case AVRCP_NOTIFICATION_EVENT_VOLUME_CHANGED: 946 connection->notifications_enabled |= event_mask; 947 avrcp_target_response_vendor_dependent_interim(connection, subunit_type, subunit_id, opcode, pdu_id, event_id, (const uint8_t *)&connection->volume_percentage, 1); 948 break; 949 case AVRCP_NOTIFICATION_EVENT_BATT_STATUS_CHANGED: 950 connection->notifications_enabled |= event_mask; 951 avrcp_target_response_vendor_dependent_interim(connection, subunit_type, subunit_id, opcode, pdu_id, event_id, (const uint8_t *)&connection->battery_status, 1); 952 break; 953 case AVRCP_NOTIFICATION_EVENT_AVAILABLE_PLAYERS_CHANGED: 954 case AVRCP_NOTIFICATION_EVENT_PLAYER_APPLICATION_SETTING_CHANGED: 955 case AVRCP_NOTIFICATION_EVENT_UIDS_CHANGED: 956 avrcp_target_response_not_implemented(connection, subunit_type, subunit_id, opcode, pdu_id, event_id); 957 return; 958 case AVRCP_NOTIFICATION_EVENT_ADDRESSED_PLAYER_CHANGED: 959 connection->notifications_enabled |= event_mask; 960 printf("respond with interim AVRCP_NOTIFICATION_EVENT_ADDRESSED_PLAYER_CHANGED\n"); 961 avrcp_target_response_addressed_player_changed_interim(connection, subunit_type, subunit_id, opcode, pdu_id); 962 return; 963 default: 964 avrcp_target_response_reject(connection, subunit_type, subunit_id, opcode, pdu_id, AVRCP_STATUS_INVALID_PARAMETER); 965 return; 966 } 967 break; 968 } 969 case AVRCP_PDU_ID_SET_ABSOLUTE_VOLUME: { 970 uint16_t param_length = big_endian_read_16(pdu,2); 971 if (param_length != 1){ 972 avrcp_target_response_reject(connection, subunit_type, subunit_id, opcode, pdu_id, AVRCP_STATUS_INVALID_COMMAND); 973 printf("param_length is %d != 1 \n", param_length); 974 break; 975 } 976 977 uint8_t absolute_volume = pdu[4]; 978 if (absolute_volume > 0x7F){ 979 avrcp_target_response_reject(connection, subunit_type, subunit_id, opcode, pdu_id, AVRCP_STATUS_INVALID_COMMAND); 980 printf("absolute_volume %d > 127 \n", absolute_volume); 981 break; 982 } 983 connection->volume_percentage = absolute_volume; 984 avrcp_target_response_accept(connection, subunit_type, subunit_id, opcode, pdu_id, absolute_volume); 985 break; 986 } 987 default: 988 log_info("AVRCP target: unhandled pdu id 0x%02x", pdu_id); 989 avrcp_target_response_reject(connection, subunit_type, subunit_id, opcode, pdu_id, AVRCP_STATUS_INVALID_COMMAND); 990 break; 991 } 992 break; 993 default: 994 log_info("AVRCP target: opcode 0x%02x not implemented", avrcp_cmd_opcode(packet,size)); 995 break; 996 } 997 } 998 999 static int avrcp_target_send_addressed_player_changed_notification(uint16_t cid, avrcp_connection_t * connection, uint16_t uid, uint16_t uid_counter){ 1000 if (!connection){ 1001 log_error("avrcp tartget: could not find a connection."); 1002 return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER; 1003 } 1004 printf("avrcp_target_send_addressed_player_changed_notification \n"); 1005 connection->command_opcode = AVRCP_CMD_OPCODE_VENDOR_DEPENDENT; 1006 connection->command_type = AVRCP_CTYPE_RESPONSE_CHANGED_STABLE; 1007 connection->subunit_type = AVRCP_SUBUNIT_TYPE_PANEL; 1008 connection->subunit_id = AVRCP_SUBUNIT_ID; 1009 1010 uint16_t pos = 0; 1011 l2cap_reserve_packet_buffer(); 1012 uint8_t * packet = l2cap_get_outgoing_buffer(); 1013 1014 connection->packet_type = AVRCP_SINGLE_PACKET; 1015 packet[pos++] = (connection->transaction_label << 4) | (connection->packet_type << 2) | (AVRCP_RESPONSE_FRAME << 1) | 0; 1016 // Profile IDentifier (PID) 1017 packet[pos++] = BLUETOOTH_SERVICE_CLASS_AV_REMOTE_CONTROL >> 8; 1018 packet[pos++] = BLUETOOTH_SERVICE_CLASS_AV_REMOTE_CONTROL & 0x00FF; 1019 1020 // command_type 1021 packet[pos++] = connection->command_type; 1022 // subunit_type | subunit ID 1023 packet[pos++] = (connection->subunit_type << 3) | connection->subunit_id; 1024 // opcode 1025 packet[pos++] = (uint8_t)connection->command_opcode; 1026 1027 // company id is 3 bytes long 1028 big_endian_store_24(packet, pos, BT_SIG_COMPANY_ID); 1029 pos += 3; 1030 1031 packet[pos++] = AVRCP_PDU_ID_REGISTER_NOTIFICATION; 1032 packet[pos++] = 0; 1033 big_endian_store_16(packet, pos, 5); 1034 pos += 2; 1035 packet[pos++] = AVRCP_NOTIFICATION_EVENT_ADDRESSED_PLAYER_CHANGED; 1036 big_endian_store_16(packet, pos, uid); 1037 pos += 2; 1038 big_endian_store_16(packet, pos, uid_counter); 1039 pos += 2; 1040 1041 connection->wait_to_send = 0; 1042 return l2cap_send_prepared(cid, pos); 1043 } 1044 1045 1046 static int avrcp_target_send_notification(uint16_t cid, avrcp_connection_t * connection, uint8_t notification_id, uint8_t * value, uint16_t value_len){ 1047 if (!connection){ 1048 log_error("avrcp tartget: could not find a connection."); 1049 return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER; 1050 } 1051 1052 connection->command_opcode = AVRCP_CMD_OPCODE_VENDOR_DEPENDENT; 1053 connection->command_type = AVRCP_CTYPE_RESPONSE_CHANGED_STABLE; 1054 connection->subunit_type = AVRCP_SUBUNIT_TYPE_PANEL; 1055 connection->subunit_id = AVRCP_SUBUNIT_ID; 1056 1057 uint16_t pos = 0; 1058 l2cap_reserve_packet_buffer(); 1059 uint8_t * packet = l2cap_get_outgoing_buffer(); 1060 uint16_t size = l2cap_get_remote_mtu_for_local_cid(connection->l2cap_signaling_cid); 1061 1062 connection->packet_type = AVRCP_SINGLE_PACKET; 1063 packet[pos++] = (connection->transaction_label << 4) | (connection->packet_type << 2) | (AVRCP_RESPONSE_FRAME << 1) | 0; 1064 // Profile IDentifier (PID) 1065 packet[pos++] = BLUETOOTH_SERVICE_CLASS_AV_REMOTE_CONTROL >> 8; 1066 packet[pos++] = BLUETOOTH_SERVICE_CLASS_AV_REMOTE_CONTROL & 0x00FF; 1067 1068 // command_type 1069 packet[pos++] = connection->command_type; 1070 // subunit_type | subunit ID 1071 packet[pos++] = (connection->subunit_type << 3) | connection->subunit_id; 1072 // opcode 1073 packet[pos++] = (uint8_t)connection->command_opcode; 1074 1075 // company id is 3 bytes long 1076 big_endian_store_24(packet, pos, BT_SIG_COMPANY_ID); 1077 pos += 3; 1078 1079 packet[pos++] = AVRCP_PDU_ID_REGISTER_NOTIFICATION; 1080 packet[pos++] = 0; 1081 uint16_t remainig_outgoing_buffer_size = size > (value_len + 2 + 1) ? size - (value_len + 2 + 1): 0; 1082 uint16_t caped_value_len = value_len > remainig_outgoing_buffer_size ? remainig_outgoing_buffer_size : value_len; 1083 big_endian_store_16(packet, pos, caped_value_len); 1084 pos += 2; 1085 packet[pos++] = notification_id; 1086 1087 memcpy(packet+pos, value, caped_value_len); 1088 pos += caped_value_len; 1089 connection->wait_to_send = 0; 1090 return l2cap_send_prepared(cid, pos); 1091 } 1092 1093 static void avrcp_target_reset_notification(avrcp_connection_t * connection, uint8_t notification_id){ 1094 if (!connection){ 1095 log_error("avrcp tartget: could not find a connection."); 1096 return; 1097 } 1098 printf("reset notification\n"); 1099 connection->notifications_enabled &= ~(1 << notification_id); 1100 connection->command_opcode = AVRCP_CMD_OPCODE_VENDOR_DEPENDENT; 1101 1102 } 1103 1104 static void avrcp_target_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){ 1105 avrcp_connection_t * connection; 1106 switch (packet_type) { 1107 case L2CAP_DATA_PACKET: 1108 connection = get_avrcp_connection_for_l2cap_signaling_cid(channel, &avrcp_target_context); 1109 if (!connection) break; 1110 avrcp_handle_l2cap_data_packet_for_signaling_connection(connection, packet, size); 1111 break; 1112 case HCI_EVENT_PACKET: 1113 switch (hci_event_packet_get_type(packet)){ 1114 case L2CAP_EVENT_CAN_SEND_NOW:{ 1115 connection = get_avrcp_connection_for_l2cap_signaling_cid(channel, &avrcp_target_context); 1116 if (!connection) { 1117 log_error("Connection not found\n"); 1118 break; 1119 } 1120 1121 if (connection->abort_continue_response){ 1122 connection->abort_continue_response = 0; 1123 connection->now_playing_info_response = 0; 1124 avrcp_target_abort_continue_response(connection->l2cap_signaling_cid, connection); 1125 break; 1126 } 1127 1128 if (connection->now_playing_info_response){ 1129 connection->now_playing_info_response = 0; 1130 avrcp_target_send_now_playing_info(connection->l2cap_signaling_cid, connection); 1131 break; 1132 } 1133 1134 if (connection->track_changed){ 1135 connection->track_changed = 0; 1136 avrcp_target_send_notification(connection->l2cap_signaling_cid, connection, AVRCP_NOTIFICATION_EVENT_TRACK_CHANGED, connection->track_id, 8); 1137 avrcp_target_reset_notification(connection, AVRCP_NOTIFICATION_EVENT_TRACK_CHANGED); 1138 avrcp_request_can_send_now(connection, connection->l2cap_signaling_cid); 1139 break; 1140 } 1141 1142 if (connection->playback_status_changed){ 1143 connection->playback_status_changed = 0; 1144 avrcp_target_send_notification(connection->l2cap_signaling_cid, connection, AVRCP_NOTIFICATION_EVENT_PLAYBACK_STATUS_CHANGED, &connection->playback_status_changed, 1); 1145 avrcp_target_reset_notification(connection, AVRCP_NOTIFICATION_EVENT_PLAYBACK_STATUS_CHANGED); 1146 avrcp_request_can_send_now(connection, connection->l2cap_signaling_cid); 1147 break; 1148 } 1149 1150 // if (connection->addressed_player_changed){ 1151 // connection->playback_status_changed = 0; 1152 // avrcp_target_send_addressed_player_changed_notification(connection->l2cap_signaling_cid, connection, connection->addressed_player_id, connection->uid_counter); 1153 // avrcp_target_reset_notification(connection, AVRCP_NOTIFICATION_EVENT_ADDRESSED_PLAYER_CHANGED); 1154 // avrcp_request_can_send_now(connection, connection->l2cap_signaling_cid); 1155 // break; 1156 // } 1157 1158 if (connection->playing_content_changed){ 1159 connection->playing_content_changed = 0; 1160 avrcp_target_send_notification(connection->l2cap_signaling_cid, connection, AVRCP_NOTIFICATION_EVENT_NOW_PLAYING_CONTENT_CHANGED, NULL, 0); 1161 avrcp_target_reset_notification(connection, AVRCP_NOTIFICATION_EVENT_NOW_PLAYING_CONTENT_CHANGED); 1162 avrcp_request_can_send_now(connection, connection->l2cap_signaling_cid); 1163 break; 1164 } 1165 1166 if (connection->battery_status_changed){ 1167 connection->battery_status_changed = 0; 1168 avrcp_target_send_notification(connection->l2cap_signaling_cid, connection, AVRCP_NOTIFICATION_EVENT_BATT_STATUS_CHANGED, (uint8_t *)&connection->battery_status, 1); 1169 avrcp_target_reset_notification(connection, AVRCP_NOTIFICATION_EVENT_BATT_STATUS_CHANGED); 1170 avrcp_request_can_send_now(connection, connection->l2cap_signaling_cid); 1171 break; 1172 } 1173 1174 if (connection->volume_percentage_changed){ 1175 connection->volume_percentage_changed = 0; 1176 avrcp_target_send_notification(connection->l2cap_signaling_cid, connection, AVRCP_NOTIFICATION_EVENT_VOLUME_CHANGED, &connection->volume_percentage, 1); 1177 avrcp_target_reset_notification(connection, AVRCP_NOTIFICATION_EVENT_VOLUME_CHANGED); 1178 avrcp_request_can_send_now(connection, connection->l2cap_signaling_cid); 1179 break; 1180 } 1181 1182 switch (connection->state){ 1183 case AVCTP_W2_SEND_RESPONSE: 1184 connection->state = AVCTP_CONNECTION_OPENED; 1185 // if (connection->now_playing_info_response){ 1186 // connection->now_playing_info_response = 0; 1187 // avrcp_target_send_now_playing_info(connection->l2cap_signaling_cid, connection); 1188 // break; 1189 // } 1190 avrcp_target_send_response(connection->l2cap_signaling_cid, connection); 1191 break; 1192 default: 1193 return; 1194 } 1195 break; 1196 } 1197 default: 1198 avrcp_packet_handler(packet_type, channel, packet, size, &avrcp_target_context); 1199 break; 1200 } 1201 default: 1202 break; 1203 } 1204 } 1205 1206 void avrcp_target_init(void){ 1207 avrcp_target_context.role = AVRCP_TARGET; 1208 avrcp_target_context.connections = NULL; 1209 avrcp_target_context.packet_handler = avrcp_target_packet_handler; 1210 l2cap_register_service(&avrcp_target_packet_handler, BLUETOOTH_PROTOCOL_AVCTP, 0xffff, LEVEL_0); 1211 } 1212 1213 void avrcp_target_register_packet_handler(btstack_packet_handler_t callback){ 1214 if (callback == NULL){ 1215 log_error("avrcp_register_packet_handler called with NULL callback"); 1216 return; 1217 } 1218 avrcp_target_context.avrcp_callback = callback; 1219 } 1220 1221 uint8_t avrcp_target_connect(bd_addr_t bd_addr, uint16_t * avrcp_cid){ 1222 return avrcp_connect(bd_addr, &avrcp_target_context, avrcp_cid); 1223 } 1224 1225 uint8_t avrcp_target_disconnect(uint16_t avrcp_cid){ 1226 avrcp_connection_t * connection = get_avrcp_connection_for_avrcp_cid(avrcp_cid, &avrcp_target_context); 1227 if (!connection){ 1228 log_error("avrcp_get_capabilities: could not find a connection."); 1229 return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER; 1230 } 1231 if (connection->state != AVCTP_CONNECTION_OPENED) return ERROR_CODE_COMMAND_DISALLOWED; 1232 l2cap_disconnect(connection->l2cap_signaling_cid, 0); 1233 return ERROR_CODE_SUCCESS; 1234 } 1235 1236