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_browsing_target.c" 39 40 #include <stdint.h> 41 #include <stdio.h> 42 #include <stdlib.h> 43 #include <string.h> 44 #include <inttypes.h> 45 #include "btstack.h" 46 #include "classic/avrcp.h" 47 #include "classic/avrcp_browsing_target.h" 48 49 #define PSM_AVCTP_BROWSING 0x001b 50 51 static void avrcp_browser_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size, avrcp_context_t * context); 52 static void avrcp_browsing_target_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size); 53 54 static void avrcp_browsing_target_request_can_send_now(avrcp_browsing_connection_t * connection, uint16_t l2cap_cid){ 55 connection->wait_to_send = 1; 56 l2cap_request_can_send_now_event(l2cap_cid); 57 } 58 59 static int avrcp_browsing_target_handle_can_send_now(avrcp_browsing_connection_t * connection){ 60 int pos = 0; 61 // printf("avrcp_browsing_target_handle_can_send_now, cmd_operands_length %d\n", connection->cmd_operands_length); 62 // printf_hexdump(connection->cmd_operands, connection->cmd_operands_length); 63 64 // l2cap_reserve_packet_buffer(); 65 // uint8_t * packet = l2cap_get_outgoing_buffer(); 66 uint8_t packet[300]; 67 connection->packet_type = AVRCP_SINGLE_PACKET; 68 69 packet[pos++] = (connection->transaction_label << 4) | (connection->packet_type << 2) | (AVRCP_RESPONSE_FRAME << 1) | 0; 70 // Profile IDentifier (PID) 71 packet[pos++] = BLUETOOTH_SERVICE_CLASS_AV_REMOTE_CONTROL >> 8; 72 packet[pos++] = BLUETOOTH_SERVICE_CLASS_AV_REMOTE_CONTROL & 0x00FF; 73 (void)memcpy(packet + pos, connection->cmd_operands, 74 connection->cmd_operands_length); 75 76 pos += connection->cmd_operands_length; 77 connection->wait_to_send = 0; 78 // return l2cap_send_prepared(connection->l2cap_browsing_cid, pos); 79 return l2cap_send(connection->l2cap_browsing_cid, packet, pos); 80 } 81 82 83 static uint8_t avrcp_browsing_target_response_general_reject(avrcp_browsing_connection_t * connection, avrcp_status_code_t status){ 84 // AVRCP_CTYPE_RESPONSE_REJECTED 85 int pos = 0; 86 connection->cmd_operands[pos++] = AVRCP_PDU_ID_GENERAL_REJECT; 87 // connection->cmd_operands[pos++] = 0; 88 // param length 89 big_endian_store_16(connection->cmd_operands, pos, 1); 90 pos += 2; 91 connection->cmd_operands[pos++] = status; 92 connection->cmd_operands_length = 4; 93 connection->state = AVCTP_W2_SEND_RESPONSE; 94 avrcp_browsing_target_request_can_send_now(connection, connection->l2cap_browsing_cid); 95 return ERROR_CODE_SUCCESS; 96 } 97 98 static void avrcp_browsing_target_emit_get_folder_items(btstack_packet_handler_t callback, uint16_t browsing_cid, avrcp_browsing_connection_t * connection){ 99 btstack_assert(callback != NULL); 100 101 uint8_t event[10]; 102 int pos = 0; 103 event[pos++] = HCI_EVENT_AVRCP_META; 104 event[pos++] = sizeof(event) - 2; 105 event[pos++] = AVRCP_SUBEVENT_BROWSING_GET_FOLDER_ITEMS; 106 little_endian_store_16(event, pos, browsing_cid); 107 pos += 2; 108 event[pos++] = connection->scope; 109 big_endian_store_32(event, pos, connection->attr_bitmap); 110 pos += 4; 111 (*callback)(HCI_EVENT_PACKET, 0, event, sizeof(event)); 112 } 113 114 static void avrcp_browsing_target_emit_get_total_num_items(btstack_packet_handler_t callback, uint16_t browsing_cid, avrcp_browsing_connection_t * connection){ 115 btstack_assert(callback != NULL); 116 117 uint8_t event[10]; 118 int pos = 0; 119 event[pos++] = HCI_EVENT_AVRCP_META; 120 event[pos++] = sizeof(event) - 2; 121 event[pos++] = AVRCP_SUBEVENT_BROWSING_GET_TOTAL_NUM_ITEMS; 122 little_endian_store_16(event, pos, browsing_cid); 123 pos += 2; 124 event[pos++] = connection->scope; 125 (*callback)(HCI_EVENT_PACKET, 0, event, sizeof(event)); 126 } 127 128 static void avrcp_emit_browsing_connection_established(btstack_packet_handler_t callback, uint16_t browsing_cid, bd_addr_t addr, uint8_t status){ 129 btstack_assert(callback != NULL); 130 131 uint8_t event[12]; 132 int pos = 0; 133 event[pos++] = HCI_EVENT_AVRCP_META; 134 event[pos++] = sizeof(event) - 2; 135 event[pos++] = AVRCP_SUBEVENT_BROWSING_CONNECTION_ESTABLISHED; 136 event[pos++] = status; 137 reverse_bd_addr(addr,&event[pos]); 138 pos += 6; 139 little_endian_store_16(event, pos, browsing_cid); 140 pos += 2; 141 (*callback)(HCI_EVENT_PACKET, 0, event, sizeof(event)); 142 } 143 144 static void avrcp_emit_incoming_browsing_connection(btstack_packet_handler_t callback, uint16_t browsing_cid, bd_addr_t addr){ 145 btstack_assert(callback != NULL); 146 147 uint8_t event[11]; 148 int pos = 0; 149 event[pos++] = HCI_EVENT_AVRCP_META; 150 event[pos++] = sizeof(event) - 2; 151 event[pos++] = AVRCP_SUBEVENT_INCOMING_BROWSING_CONNECTION; 152 reverse_bd_addr(addr,&event[pos]); 153 pos += 6; 154 little_endian_store_16(event, pos, browsing_cid); 155 pos += 2; 156 (*callback)(HCI_EVENT_PACKET, 0, event, sizeof(event)); 157 } 158 159 static void avrcp_emit_browsing_connection_closed(btstack_packet_handler_t callback, uint16_t browsing_cid){ 160 btstack_assert(callback != NULL); 161 162 uint8_t event[5]; 163 int pos = 0; 164 event[pos++] = HCI_EVENT_AVRCP_META; 165 event[pos++] = sizeof(event) - 2; 166 event[pos++] = AVRCP_SUBEVENT_BROWSING_CONNECTION_RELEASED; 167 little_endian_store_16(event, pos, browsing_cid); 168 pos += 2; 169 (*callback)(HCI_EVENT_PACKET, 0, event, sizeof(event)); 170 } 171 172 static avrcp_browsing_connection_t * avrcp_browsing_create_connection(avrcp_connection_t * avrcp_connection){ 173 avrcp_browsing_connection_t * connection = btstack_memory_avrcp_browsing_connection_get(); 174 connection->state = AVCTP_CONNECTION_IDLE; 175 connection->transaction_label = 0xFF; 176 avrcp_connection->avrcp_browsing_cid = avrcp_get_next_cid(avrcp_connection->role); 177 avrcp_connection->browsing_connection = connection; 178 return connection; 179 } 180 181 static uint8_t avrcp_browsing_connect(bd_addr_t remote_addr, avrcp_context_t * context, uint8_t * ertm_buffer, uint32_t size, l2cap_ertm_config_t * ertm_config, uint16_t * browsing_cid){ 182 avrcp_connection_t * avrcp_connection = get_avrcp_connection_for_bd_addr_for_role(context->role, remote_addr); 183 184 if (!avrcp_connection){ 185 log_error("avrcp: there is no previously established AVRCP controller connection."); 186 return ERROR_CODE_COMMAND_DISALLOWED; 187 } 188 189 avrcp_browsing_connection_t * connection = avrcp_connection->browsing_connection; 190 if (connection){ 191 log_error(" avrcp_browsing_connect connection exists."); 192 return ERROR_CODE_SUCCESS; 193 } 194 195 connection = avrcp_browsing_create_connection(avrcp_connection); 196 if (!connection){ 197 log_error("avrcp: could not allocate connection struct."); 198 return BTSTACK_MEMORY_ALLOC_FAILED; 199 } 200 201 if (browsing_cid){ 202 *browsing_cid = avrcp_connection->avrcp_browsing_cid; 203 } 204 205 connection->ertm_buffer = ertm_buffer; 206 connection->ertm_buffer_size = size; 207 avrcp_connection->browsing_connection = connection; 208 209 (void)memcpy(&connection->ertm_config, ertm_config, 210 sizeof(l2cap_ertm_config_t)); 211 212 return l2cap_create_ertm_channel(avrcp_browsing_target_packet_handler, remote_addr, avrcp_connection->browsing_l2cap_psm, 213 &connection->ertm_config, connection->ertm_buffer, connection->ertm_buffer_size, NULL); 214 215 } 216 217 static void avrcp_browser_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size, avrcp_context_t * context){ 218 UNUSED(channel); 219 UNUSED(size); 220 bd_addr_t event_addr; 221 uint16_t local_cid; 222 uint8_t status; 223 avrcp_browsing_connection_t * browsing_connection = NULL; 224 avrcp_connection_t * avrcp_connection = NULL; 225 226 if (packet_type != HCI_EVENT_PACKET) return; 227 228 switch (hci_event_packet_get_type(packet)) { 229 case HCI_EVENT_DISCONNECTION_COMPLETE: 230 avrcp_emit_browsing_connection_closed(context->browsing_avrcp_callback, 0); 231 break; 232 case L2CAP_EVENT_INCOMING_CONNECTION: 233 l2cap_event_incoming_connection_get_address(packet, event_addr); 234 local_cid = l2cap_event_incoming_connection_get_local_cid(packet); 235 avrcp_connection = get_avrcp_connection_for_bd_addr_for_role(context->role, event_addr); 236 if (!avrcp_connection) { 237 log_error("No previously created AVRCP controller connections"); 238 l2cap_decline_connection(local_cid); 239 break; 240 } 241 browsing_connection = avrcp_browsing_create_connection(avrcp_connection); 242 browsing_connection->l2cap_browsing_cid = local_cid; 243 browsing_connection->state = AVCTP_CONNECTION_W4_ERTM_CONFIGURATION; 244 log_info("Emit AVRCP_SUBEVENT_INCOMING_BROWSING_CONNECTION browsing_cid 0x%02x, l2cap_signaling_cid 0x%02x\n", avrcp_connection->avrcp_browsing_cid, browsing_connection->l2cap_browsing_cid); 245 avrcp_emit_incoming_browsing_connection(context->browsing_avrcp_callback, avrcp_connection->avrcp_browsing_cid, event_addr); 246 break; 247 248 case L2CAP_EVENT_CHANNEL_OPENED: 249 l2cap_event_channel_opened_get_address(packet, event_addr); 250 status = l2cap_event_channel_opened_get_status(packet); 251 local_cid = l2cap_event_channel_opened_get_local_cid(packet); 252 253 avrcp_connection = get_avrcp_connection_for_bd_addr_for_role(context->role, event_addr); 254 if (!avrcp_connection){ 255 log_error("Failed to find AVRCP connection for bd_addr %s", bd_addr_to_str(event_addr)); 256 avrcp_emit_browsing_connection_established(context->browsing_avrcp_callback, local_cid, event_addr, L2CAP_LOCAL_CID_DOES_NOT_EXIST); 257 l2cap_disconnect(local_cid, 0); // reason isn't used 258 break; 259 } 260 261 browsing_connection = avrcp_connection->browsing_connection; 262 if (status != ERROR_CODE_SUCCESS){ 263 log_info("L2CAP connection to connection %s failed. status code 0x%02x", bd_addr_to_str(event_addr), status); 264 avrcp_emit_browsing_connection_established(context->browsing_avrcp_callback, avrcp_connection->avrcp_browsing_cid, event_addr, status); 265 btstack_memory_avrcp_browsing_connection_free(browsing_connection); 266 avrcp_connection->browsing_connection = NULL; 267 break; 268 } 269 if (browsing_connection->state != AVCTP_CONNECTION_W4_L2CAP_CONNECTED) break; 270 271 browsing_connection->l2cap_browsing_cid = local_cid; 272 273 log_info("L2CAP_EVENT_CHANNEL_OPENED browsing cid 0x%02x, l2cap cid 0x%02x", avrcp_connection->avrcp_browsing_cid, browsing_connection->l2cap_browsing_cid); 274 browsing_connection->state = AVCTP_CONNECTION_OPENED; 275 avrcp_emit_browsing_connection_established(context->browsing_avrcp_callback, avrcp_connection->avrcp_browsing_cid, event_addr, ERROR_CODE_SUCCESS); 276 break; 277 278 case L2CAP_EVENT_CHANNEL_CLOSED: 279 local_cid = l2cap_event_channel_closed_get_local_cid(packet); 280 avrcp_connection = get_avrcp_connection_for_browsing_l2cap_cid_for_role(context->role, local_cid); 281 282 if (avrcp_connection && avrcp_connection->browsing_connection){ 283 avrcp_emit_browsing_connection_closed(context->browsing_avrcp_callback, avrcp_connection->avrcp_browsing_cid); 284 // free connection 285 btstack_memory_avrcp_browsing_connection_free(avrcp_connection->browsing_connection); 286 avrcp_connection->browsing_connection = NULL; 287 break; 288 } 289 break; 290 default: 291 break; 292 } 293 } 294 295 296 static void avrcp_browsing_target_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){ 297 avrcp_browsing_connection_t * browsing_connection; 298 299 switch (packet_type) { 300 case L2CAP_DATA_PACKET:{ 301 browsing_connection = get_avrcp_browsing_connection_for_l2cap_cid_for_role(AVRCP_TARGET, channel); 302 if (!browsing_connection) break; 303 int pos = 0; 304 uint8_t transport_header = packet[pos++]; 305 // Transaction label | Packet_type | C/R | IPID (1 == invalid profile identifier) 306 browsing_connection->transaction_label = transport_header >> 4; 307 avrcp_packet_type_t avctp_packet_type = (transport_header & 0x0F) >> 2; 308 switch (avctp_packet_type){ 309 case AVRCP_SINGLE_PACKET: 310 case AVRCP_START_PACKET: 311 browsing_connection->subunit_type = packet[pos++] >> 2; 312 browsing_connection->subunit_id = 0; 313 browsing_connection->command_opcode = packet[pos++]; 314 browsing_connection->num_packets = 1; 315 if (avctp_packet_type == AVRCP_START_PACKET){ 316 browsing_connection->num_packets = packet[pos++]; 317 } 318 browsing_connection->pdu_id = packet[pos++]; 319 break; 320 default: 321 break; 322 } 323 switch (avctp_packet_type){ 324 case AVRCP_SINGLE_PACKET: 325 case AVRCP_END_PACKET: 326 switch(browsing_connection->pdu_id){ 327 case AVRCP_PDU_ID_GET_FOLDER_ITEMS: 328 printf("\n"); 329 browsing_connection->scope = packet[pos++]; 330 browsing_connection->start_item = big_endian_read_32(packet, pos); 331 pos += 4; 332 browsing_connection->end_item = big_endian_read_32(packet, pos); 333 pos += 4; 334 uint8_t attr_count = packet[pos++]; 335 336 while (attr_count){ 337 uint32_t attr_id = big_endian_read_32(packet, pos); 338 pos += 4; 339 browsing_connection->attr_bitmap |= (1 << attr_id); 340 attr_count--; 341 } 342 avrcp_browsing_target_emit_get_folder_items(avrcp_target_context.browsing_avrcp_callback, channel, browsing_connection); 343 break; 344 case AVRCP_PDU_ID_GET_TOTAL_NUMBER_OF_ITEMS:{ 345 // send total num items 346 browsing_connection->scope = packet[pos++]; 347 avrcp_browsing_target_emit_get_total_num_items(avrcp_target_context.browsing_avrcp_callback, channel, browsing_connection); 348 break; 349 } 350 default: 351 avrcp_browsing_target_response_general_reject(browsing_connection, AVRCP_STATUS_INVALID_COMMAND); 352 log_info(" not parsed pdu ID 0x%02x", browsing_connection->pdu_id); 353 break; 354 } 355 browsing_connection->state = AVCTP_CONNECTION_OPENED; 356 break; 357 default: 358 break; 359 } 360 break; 361 } 362 363 case HCI_EVENT_PACKET: 364 switch (hci_event_packet_get_type(packet)){ 365 case L2CAP_EVENT_CAN_SEND_NOW: 366 browsing_connection = get_avrcp_browsing_connection_for_l2cap_cid_for_role(AVRCP_TARGET, channel); 367 if (!browsing_connection) break; 368 if (browsing_connection->state != AVCTP_W2_SEND_RESPONSE) return; 369 browsing_connection->state = AVCTP_CONNECTION_OPENED; 370 avrcp_browsing_target_handle_can_send_now(browsing_connection); 371 break; 372 default: 373 avrcp_browser_packet_handler(packet_type, channel, packet, size, &avrcp_target_context); 374 break; 375 } 376 break; 377 378 default: 379 break; 380 } 381 } 382 383 void avrcp_browsing_target_init(void){ 384 avrcp_target_context.browsing_packet_handler = avrcp_browsing_target_packet_handler; 385 l2cap_register_service(&avrcp_browsing_target_packet_handler, PSM_AVCTP_BROWSING, 0xffff, gap_get_security_level()); 386 } 387 388 void avrcp_browsing_target_register_packet_handler(btstack_packet_handler_t callback){ 389 btstack_assert(callback != NULL); 390 avrcp_target_context.browsing_avrcp_callback = callback; 391 } 392 393 uint8_t avrcp_browsing_target_connect(bd_addr_t bd_addr, uint8_t * ertm_buffer, uint32_t size, l2cap_ertm_config_t * ertm_config, uint16_t * avrcp_browsing_cid){ 394 return avrcp_browsing_connect(bd_addr, &avrcp_target_context, ertm_buffer, size, ertm_config, avrcp_browsing_cid); 395 } 396 397 uint8_t avrcp_browsing_target_disconnect(uint16_t avrcp_browsing_cid){ 398 avrcp_connection_t * avrcp_connection = get_avrcp_connection_for_browsing_cid_for_role(AVRCP_TARGET, avrcp_browsing_cid); 399 if (!avrcp_connection){ 400 log_error("avrcp_browsing_target_disconnect: could not find a connection."); 401 return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER; 402 } 403 if (avrcp_connection->browsing_connection->state != AVCTP_CONNECTION_OPENED) return ERROR_CODE_COMMAND_DISALLOWED; 404 405 l2cap_disconnect(avrcp_connection->browsing_connection->l2cap_browsing_cid, 0); 406 return ERROR_CODE_SUCCESS; 407 } 408 409 uint8_t avrcp_browsing_target_configure_incoming_connection(uint16_t avrcp_browsing_cid, uint8_t * ertm_buffer, uint32_t size, l2cap_ertm_config_t * ertm_config){ 410 avrcp_connection_t * avrcp_connection = get_avrcp_connection_for_browsing_cid_for_role(AVRCP_TARGET, avrcp_browsing_cid); 411 if (!avrcp_connection){ 412 log_error("avrcp_browsing_decline_incoming_connection: could not find a connection."); 413 return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER; 414 } 415 if (!avrcp_connection->browsing_connection){ 416 log_error("avrcp_browsing_decline_incoming_connection: no browsing connection."); 417 return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER; 418 } 419 420 if (avrcp_connection->browsing_connection->state != AVCTP_CONNECTION_W4_ERTM_CONFIGURATION){ 421 log_error("avrcp_browsing_decline_incoming_connection: browsing connection in a wrong state."); 422 return ERROR_CODE_COMMAND_DISALLOWED; 423 } 424 425 avrcp_connection->browsing_connection->state = AVCTP_CONNECTION_W4_L2CAP_CONNECTED; 426 avrcp_connection->browsing_connection->ertm_buffer = ertm_buffer; 427 avrcp_connection->browsing_connection->ertm_buffer_size = size; 428 (void)memcpy(&avrcp_connection->browsing_connection->ertm_config, 429 ertm_config, sizeof(l2cap_ertm_config_t)); 430 l2cap_accept_ertm_connection(avrcp_connection->browsing_connection->l2cap_browsing_cid, &avrcp_connection->browsing_connection->ertm_config, avrcp_connection->browsing_connection->ertm_buffer, avrcp_connection->browsing_connection->ertm_buffer_size); 431 return ERROR_CODE_SUCCESS; 432 } 433 434 uint8_t avrcp_browsing_target_decline_incoming_connection(uint16_t avrcp_browsing_cid){ 435 avrcp_connection_t * avrcp_connection = get_avrcp_connection_for_browsing_cid_for_role(AVRCP_TARGET, avrcp_browsing_cid); 436 if (!avrcp_connection){ 437 log_error("avrcp_browsing_decline_incoming_connection: could not find a connection."); 438 return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER; 439 } 440 if (!avrcp_connection->browsing_connection) return ERROR_CODE_SUCCESS; 441 if (avrcp_connection->browsing_connection->state > AVCTP_CONNECTION_W4_ERTM_CONFIGURATION) return ERROR_CODE_COMMAND_DISALLOWED; 442 443 l2cap_decline_connection(avrcp_connection->browsing_connection->l2cap_browsing_cid); 444 // free connection 445 btstack_memory_avrcp_browsing_connection_free(avrcp_connection->browsing_connection); 446 avrcp_connection->browsing_connection = NULL; 447 return ERROR_CODE_SUCCESS; 448 } 449 450 uint8_t avrcp_subevent_browsing_get_folder_items_response(uint16_t avrcp_browsing_cid, uint16_t uid_counter, uint8_t * attr_list, uint16_t attr_list_size){ 451 avrcp_connection_t * avrcp_connection = get_avrcp_connection_for_browsing_cid_for_role(AVRCP_TARGET, avrcp_browsing_cid); 452 if (!avrcp_connection){ 453 log_error("avrcp_browsing_controller_disconnect: could not find a connection."); 454 return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER; 455 } 456 457 avrcp_browsing_connection_t * connection = avrcp_connection->browsing_connection; 458 if (!connection){ 459 log_info("avrcp_subevent_browsing_get_folder_items_response: could not find a connection."); 460 return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER; 461 } 462 if (connection->state != AVCTP_CONNECTION_OPENED) return ERROR_CODE_COMMAND_DISALLOWED; 463 464 if (connection->state != AVCTP_CONNECTION_OPENED) { 465 log_info("avrcp_subevent_browsing_get_folder_items_response: wrong state."); 466 return ERROR_CODE_COMMAND_DISALLOWED; 467 } 468 int pos = 0; 469 470 connection->cmd_operands[pos++] = AVRCP_PDU_ID_GET_FOLDER_ITEMS; 471 big_endian_store_16(connection->cmd_operands, pos, attr_list_size); 472 pos += 2; 473 474 connection->cmd_operands[pos++] = AVRCP_STATUS_SUCCESS; 475 big_endian_store_16(connection->cmd_operands, pos, uid_counter); 476 pos += 2; 477 478 // TODO: fragmentation 479 if (attr_list_size > sizeof(connection->cmd_operands)){ 480 connection->attr_list = attr_list; 481 connection->attr_list_size = attr_list_size; 482 log_info(" todo: list too big, invoke fragmentation"); 483 return 1; 484 } 485 (void)memcpy(&connection->cmd_operands[pos], attr_list, attr_list_size); 486 pos += attr_list_size; 487 connection->cmd_operands_length = pos; 488 // printf_hexdump(connection->cmd_operands, connection->cmd_operands_length); 489 490 connection->state = AVCTP_W2_SEND_RESPONSE; 491 avrcp_browsing_target_request_can_send_now(connection, connection->l2cap_browsing_cid); 492 return ERROR_CODE_SUCCESS; 493 } 494 495 496 uint8_t avrcp_subevent_browsing_get_total_num_items_response(uint16_t avrcp_browsing_cid, uint16_t uid_counter, uint32_t total_num_items){ 497 avrcp_connection_t * avrcp_connection = get_avrcp_connection_for_browsing_cid_for_role(AVRCP_TARGET, avrcp_browsing_cid); 498 if (!avrcp_connection){ 499 log_error("avrcp_browsing_controller_disconnect: could not find a connection."); 500 return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER; 501 } 502 503 avrcp_browsing_connection_t * connection = avrcp_connection->browsing_connection; 504 if (!connection){ 505 log_info("avrcp_subevent_browsing_get_folder_items_response: could not find a connection."); 506 return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER; 507 } 508 if (connection->state != AVCTP_CONNECTION_OPENED) return ERROR_CODE_COMMAND_DISALLOWED; 509 510 if (connection->state != AVCTP_CONNECTION_OPENED) { 511 log_info("avrcp_subevent_browsing_get_folder_items_response: wrong state."); 512 return ERROR_CODE_COMMAND_DISALLOWED; 513 } 514 515 int pos = 0; 516 connection->cmd_operands[pos++] = AVRCP_PDU_ID_GET_TOTAL_NUMBER_OF_ITEMS; 517 big_endian_store_16(connection->cmd_operands, pos, 7); 518 pos += 2; 519 connection->cmd_operands[pos++] = AVRCP_STATUS_SUCCESS; 520 big_endian_store_16(connection->cmd_operands, pos, uid_counter); 521 pos += 2; 522 big_endian_store_32(connection->cmd_operands, pos, total_num_items); 523 pos += 4; 524 connection->cmd_operands_length = pos; 525 526 connection->state = AVCTP_W2_SEND_RESPONSE; 527 avrcp_browsing_target_request_can_send_now(connection, connection->l2cap_browsing_cid); 528 return ERROR_CODE_SUCCESS; 529 } 530 531