1 /* 2 * Copyright (C) 2023 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_cover_art_client.c" 39 40 #include <string.h> 41 42 #include "btstack_debug.h" 43 #include "btstack_event.h" 44 #include "classic/avrcp.h" 45 #include "classic/avrcp_cover_art_client.h" 46 #include "classic/obex.h" 47 #include "hci_event.h" 48 49 #ifdef ENABLE_AVRCP_COVER_ART 50 51 static const hci_event_t avrcp_cover_art_client_connected = { 52 .event_code = HCI_EVENT_AVRCP_META, 53 .subevent_code = AVRCP_SUBEVENT_COVER_ART_CONNECTION_ESTABLISHED, 54 .format = "1B22" 55 }; 56 57 static const hci_event_t avrcp_cover_art_client_disconnected = { 58 .event_code = HCI_EVENT_AVRCP_META, 59 .subevent_code = AVRCP_SUBEVENT_COVER_ART_CONNECTION_RELEASED, 60 .format = "2" 61 }; 62 63 static const hci_event_t avrcp_cover_art_client_operation_complete = { 64 .event_code = HCI_EVENT_AVRCP_META, 65 .subevent_code = AVRCP_SUBEVENT_COVER_ART_OPERATION_COMPLETE, 66 .format = "21" 67 }; 68 69 // 7163DD54-4A7E-11E2-B47C-0050C2490048 70 static const uint8_t avrcp_cover_art_uuid[] = { 0x71, 0x63, 0xDD, 0x54, 0x4A, 0x7E, 0x11, 0xE2, 0xB4, 0x7C, 0x00, 0x50, 0xC2, 0x49, 0x00, 0x48 }; 71 72 // OBEX types 73 const char * avrcp_cover_art_image_properties_type = "x-bt/img-properties"; 74 const char * avrcp_cover_art_image_type = "x-bt/img-img"; 75 const char * avrcp_cover_art_linked_thumbnail_type = "x-bt/img-thm"; 76 77 static btstack_linked_list_t avrcp_cover_art_client_connections; 78 79 static uint16_t avrcp_cover_art_client_next_cid(void) { 80 static uint16_t cid = 0; 81 cid++; 82 if (cid == 0){ 83 cid = 1; 84 } 85 return cid; 86 } 87 88 static avrcp_cover_art_client_t * avrcp_cover_art_client_for_goep_cid(uint16_t goep_cid){ 89 btstack_linked_list_iterator_t it; 90 btstack_linked_list_iterator_init(&it, (btstack_linked_list_t *) &avrcp_cover_art_client_connections); 91 while (btstack_linked_list_iterator_has_next(&it)){ 92 avrcp_cover_art_client_t * connection = (avrcp_cover_art_client_t *)btstack_linked_list_iterator_next(&it); 93 if (connection->goep_cid == goep_cid) { 94 return connection; 95 }; 96 } 97 return NULL; 98 } 99 100 static avrcp_cover_art_client_t * avrcp_cover_art_client_for_avrcp_cid(uint16_t avrcp_cid){ 101 btstack_linked_list_iterator_t it; 102 btstack_linked_list_iterator_init(&it, (btstack_linked_list_t *) &avrcp_cover_art_client_connections); 103 while (btstack_linked_list_iterator_has_next(&it)){ 104 avrcp_cover_art_client_t * connection = (avrcp_cover_art_client_t *)btstack_linked_list_iterator_next(&it); 105 if (connection->avrcp_cid == avrcp_cid) { 106 return connection; 107 }; 108 } 109 return NULL; 110 } 111 112 static avrcp_cover_art_client_t * avrcp_cover_art_client_for_cover_art_cid(uint16_t cover_art_cid){ 113 btstack_linked_list_iterator_t it; 114 btstack_linked_list_iterator_init(&it, (btstack_linked_list_t *) &avrcp_cover_art_client_connections); 115 while (btstack_linked_list_iterator_has_next(&it)){ 116 avrcp_cover_art_client_t * connection = (avrcp_cover_art_client_t *)btstack_linked_list_iterator_next(&it); 117 if (connection->cover_art_cid == cover_art_cid) { 118 return connection; 119 }; 120 } 121 return NULL; 122 } 123 124 static void avrcp_cover_art_client_emit_connection_established(btstack_packet_handler_t packet_handler, uint8_t status, 125 bd_addr_t addr, uint16_t avrcp_cid, 126 uint16_t cover_art_cid) { 127 uint8_t buffer[20]; 128 uint16_t size = hci_event_create_from_template_and_arguments(buffer, sizeof(buffer), &avrcp_cover_art_client_connected, status, addr, avrcp_cid, cover_art_cid); 129 (*packet_handler)(HCI_EVENT_PACKET, 0, buffer, size); 130 } 131 132 static void cover_art_client_emit_operation_complete_event(avrcp_cover_art_client_t * cover_art_client, uint8_t status) { 133 uint8_t buffer[20]; 134 uint16_t size = hci_event_create_from_template_and_arguments(buffer, sizeof(buffer), &avrcp_cover_art_client_operation_complete, cover_art_client->cover_art_cid, status); 135 (*cover_art_client->packet_handler)(HCI_EVENT_PACKET, 0, buffer, size); 136 } 137 138 static void avrcp_cover_art_client_emit_connection_released(btstack_packet_handler_t packet_handler, uint16_t cover_art_cid) { 139 uint8_t buffer[20]; 140 uint16_t size = hci_event_create_from_template_and_arguments(buffer, sizeof(buffer), &avrcp_cover_art_client_disconnected, cover_art_cid); 141 (*packet_handler)(HCI_EVENT_PACKET, 0, buffer, size); 142 } 143 144 static void avrcp_cover_art_finalize_connection(avrcp_cover_art_client_t *cover_art_client) { 145 btstack_assert(cover_art_client != NULL); 146 memset(cover_art_client, 0, sizeof(avrcp_cover_art_client_t)); 147 btstack_linked_list_remove(&avrcp_cover_art_client_connections, (btstack_linked_item_t *) cover_art_client); 148 } 149 150 static void avrcp_cover_art_client_parser_callback_connect(void * user_data, uint8_t header_id, uint16_t total_len, uint16_t data_offset, const uint8_t * data_buffer, uint16_t data_len){ 151 avrcp_cover_art_client_t * client = (avrcp_cover_art_client_t *) user_data; 152 switch (header_id){ 153 case OBEX_HEADER_CONNECTION_ID: 154 if (obex_parser_header_store(client->obex_header_buffer, sizeof(client->obex_header_buffer), total_len, data_offset, data_buffer, data_len) == OBEX_PARSER_HEADER_COMPLETE){ 155 goep_client_set_connection_id(client->goep_cid, big_endian_read_32(client->obex_header_buffer, 0)); 156 } 157 break; 158 default: 159 break; 160 } 161 } 162 163 static void avrcp_cover_art_client_prepare_srm_header(avrcp_cover_art_client_t * cover_art_client){ 164 if (cover_art_client->flow_control_enabled == false){ 165 obex_srm_client_prepare_header(&cover_art_client->obex_srm, cover_art_client->goep_cid); 166 } 167 } 168 169 static void avrcp_cover_art_client_parser_callback_get_operation(void * user_data, uint8_t header_id, uint16_t total_len, uint16_t data_offset, const uint8_t * data_buffer, uint16_t data_len){ 170 avrcp_cover_art_client_t *client = (avrcp_cover_art_client_t *) user_data; 171 switch (header_id) { 172 case OBEX_HEADER_SINGLE_RESPONSE_MODE: 173 obex_parser_header_store(&client->obex_srm.srm_value, 1, total_len, data_offset, data_buffer, data_len); 174 break; 175 case OBEX_HEADER_SINGLE_RESPONSE_MODE_PARAMETER: 176 obex_parser_header_store(&client->obex_srm.srmp_value, 1, total_len, data_offset, data_buffer, data_len); 177 break; 178 case OBEX_HEADER_BODY: 179 case OBEX_HEADER_END_OF_BODY: 180 switch(client->state){ 181 case AVRCP_COVER_ART_W4_OBJECT: 182 client->packet_handler(BIP_DATA_PACKET, client->cover_art_cid, (uint8_t *) data_buffer, data_len); 183 if (data_offset + data_len == total_len){ 184 client->flow_wait_for_user = true; 185 } 186 break; 187 default: 188 btstack_unreachable(); 189 break; 190 } 191 break; 192 default: 193 // ignore other headers 194 break; 195 } 196 } 197 198 static void avrcp_cover_art_client_prepare_get_operation(avrcp_cover_art_client_t * cover_art_client){ 199 obex_parser_init_for_response(&cover_art_client->obex_parser, OBEX_OPCODE_GET, avrcp_cover_art_client_parser_callback_get_operation, cover_art_client); 200 obex_srm_client_init(&cover_art_client->obex_srm); 201 cover_art_client->obex_parser_waiting_for_response = true; 202 } 203 204 static void avrcp_cover_art_client_handle_can_send_now(avrcp_cover_art_client_t * cover_art_client){ 205 switch (cover_art_client->state) { 206 case AVRCP_COVER_ART_W2_SEND_CONNECT_REQUEST: 207 // prepare request 208 goep_client_request_create_connect(cover_art_client->goep_cid, OBEX_VERSION, 0, OBEX_MAX_PACKETLEN_DEFAULT); 209 goep_client_header_add_target(cover_art_client->goep_cid, avrcp_cover_art_uuid, 16); 210 // state 211 cover_art_client->state = AVRCP_COVER_ART_W4_CONNECT_RESPONSE; 212 // prepare response 213 obex_parser_init_for_response(&cover_art_client->obex_parser, OBEX_OPCODE_CONNECT, 214 avrcp_cover_art_client_parser_callback_connect, cover_art_client); 215 obex_srm_client_init(&cover_art_client->obex_srm); 216 cover_art_client->obex_parser_waiting_for_response = true; 217 // send packet 218 goep_client_execute(cover_art_client->goep_cid); 219 break; 220 case AVRCP_COVER_ART_W2_SEND_GET_OBJECT: 221 goep_client_request_create_get(cover_art_client->goep_cid); 222 if (cover_art_client->first_request){ 223 cover_art_client->first_request = false; 224 avrcp_cover_art_client_prepare_srm_header(cover_art_client); 225 goep_client_header_add_type(cover_art_client->goep_cid, cover_art_client->object_type); 226 if (cover_art_client->image_descriptor != NULL){ 227 goep_client_header_add_variable(cover_art_client->goep_cid, OBEX_HEADER_IMG_DESCRIPTOR, (const uint8_t *) cover_art_client->image_descriptor, (uint16_t) strlen(cover_art_client->image_descriptor)); 228 } 229 uint8_t image_handle_len = btstack_max(7, (uint16_t) strlen(cover_art_client->image_handle)); 230 goep_client_header_add_unicode_prefix(cover_art_client->goep_cid, OBEX_HEADER_IMG_HANDLE, cover_art_client->image_handle, image_handle_len); 231 } 232 // state 233 cover_art_client->state = AVRCP_COVER_ART_W4_OBJECT; 234 cover_art_client->flow_next_triggered = 0; 235 cover_art_client->flow_wait_for_user = 0; 236 // prepare response 237 avrcp_cover_art_client_prepare_get_operation(cover_art_client); 238 // send packet 239 goep_client_execute(cover_art_client->goep_cid); 240 break; 241 case AVRCP_COVER_ART_W2_SEND_DISCONNECT_REQUEST: 242 // prepare request 243 goep_client_request_create_disconnect(cover_art_client->goep_cid); 244 // state 245 cover_art_client->state = AVRCP_COVER_ART_W4_DISCONNECT_RESPONSE; 246 // prepare response 247 obex_parser_init_for_response(&cover_art_client->obex_parser, OBEX_OPCODE_DISCONNECT, NULL, cover_art_client); 248 cover_art_client->obex_parser_waiting_for_response = true; 249 // send packet 250 goep_client_execute(cover_art_client->goep_cid); 251 return; 252 default: 253 break; 254 } 255 } 256 257 static void avrcp_cover_art_goep_event_handler(const uint8_t *packet, uint16_t size) { 258 UNUSED(size); 259 uint8_t status; 260 avrcp_cover_art_client_t * cover_art_client; 261 btstack_packet_handler_t packet_handler; 262 uint16_t cover_art_cid; 263 264 switch (hci_event_packet_get_type(packet)) { 265 case HCI_EVENT_GOEP_META: 266 switch (hci_event_goep_meta_get_subevent_code(packet)){ 267 case GOEP_SUBEVENT_CONNECTION_OPENED: 268 cover_art_client = avrcp_cover_art_client_for_goep_cid(goep_subevent_connection_opened_get_goep_cid(packet)); 269 btstack_assert(cover_art_client != NULL); 270 status = goep_subevent_connection_opened_get_status(packet); 271 if (status){ 272 log_info("connection failed %u", status); 273 avrcp_cover_art_finalize_connection(cover_art_client); 274 avrcp_cover_art_client_emit_connection_established(cover_art_client->packet_handler, status, 275 cover_art_client->addr, 276 cover_art_client->avrcp_cid, 277 cover_art_client->cover_art_cid); 278 } else { 279 log_info("connection established"); 280 cover_art_client->state = AVRCP_COVER_ART_W2_SEND_CONNECT_REQUEST; 281 goep_client_request_can_send_now(cover_art_client->goep_cid); 282 } 283 break; 284 case GOEP_SUBEVENT_CONNECTION_CLOSED: 285 cover_art_client = avrcp_cover_art_client_for_goep_cid(goep_subevent_connection_opened_get_goep_cid(packet)); 286 btstack_assert(cover_art_client != NULL); 287 if (cover_art_client->state > AVRCP_COVER_ART_CONNECTED){ 288 cover_art_client_emit_operation_complete_event(cover_art_client, OBEX_DISCONNECTED); 289 } 290 cover_art_cid = cover_art_client->cover_art_cid; 291 packet_handler = cover_art_client->packet_handler; 292 avrcp_cover_art_finalize_connection(cover_art_client); 293 avrcp_cover_art_client_emit_connection_released(packet_handler, cover_art_cid); 294 break; 295 case GOEP_SUBEVENT_CAN_SEND_NOW: 296 cover_art_client = avrcp_cover_art_client_for_goep_cid(goep_subevent_can_send_now_get_goep_cid(packet)); 297 btstack_assert(cover_art_client != NULL); 298 avrcp_cover_art_client_handle_can_send_now(cover_art_client); 299 break; 300 default: 301 break; 302 } 303 break; 304 default: 305 break; 306 } 307 } 308 309 static void avrcp_cover_art_client_goep_data_handler(avrcp_cover_art_client_t * cover_art_client, uint8_t *packet, uint16_t size){ 310 btstack_assert(cover_art_client->obex_parser_waiting_for_response); 311 312 obex_parser_object_state_t parser_state; 313 parser_state = obex_parser_process_data(&cover_art_client->obex_parser, packet, size); 314 if (parser_state == OBEX_PARSER_OBJECT_STATE_COMPLETE){ 315 cover_art_client->obex_parser_waiting_for_response = false; 316 obex_parser_operation_info_t op_info; 317 obex_parser_get_operation_info(&cover_art_client->obex_parser, &op_info); 318 switch (cover_art_client->state){ 319 case AVRCP_COVER_ART_W4_CONNECT_RESPONSE: 320 switch (op_info.response_code) { 321 case OBEX_RESP_SUCCESS: 322 cover_art_client->state = AVRCP_COVER_ART_CONNECTED; 323 avrcp_cover_art_client_emit_connection_established(cover_art_client->packet_handler, 324 ERROR_CODE_SUCCESS, 325 cover_art_client->addr, 326 cover_art_client->avrcp_cid, 327 cover_art_client->cover_art_cid); 328 break; 329 default: 330 log_info("pbap: obex connect failed, result 0x%02x", packet[0]); 331 cover_art_client->state = AVRCP_COVER_ART_INIT; 332 avrcp_cover_art_client_emit_connection_established(cover_art_client->packet_handler, 333 OBEX_CONNECT_FAILED, 334 cover_art_client->addr, 335 cover_art_client->avrcp_cid, 336 cover_art_client->cover_art_cid); 337 break; 338 } 339 break; 340 case AVRCP_COVER_ART_W4_OBJECT: 341 switch (op_info.response_code) { 342 case OBEX_RESP_CONTINUE: 343 obex_srm_client_handle_headers(&cover_art_client->obex_srm); 344 if (cover_art_client->obex_srm.srm_state == OBEX_SRM_CLIENT_STATE_ENABLED) { 345 // prepare response 346 avrcp_cover_art_client_prepare_get_operation(cover_art_client); 347 break; 348 } 349 cover_art_client->state = AVRCP_COVER_ART_W2_SEND_GET_OBJECT; 350 if (!cover_art_client->flow_control_enabled || !cover_art_client->flow_wait_for_user || 351 cover_art_client->flow_next_triggered) { 352 goep_client_request_can_send_now(cover_art_client->goep_cid); 353 } 354 break; 355 case OBEX_RESP_SUCCESS: 356 cover_art_client->state = AVRCP_COVER_ART_CONNECTED; 357 cover_art_client_emit_operation_complete_event(cover_art_client, ERROR_CODE_SUCCESS); 358 break; 359 default: 360 log_info("unexpected response 0x%02x", packet[0]); 361 cover_art_client->state = AVRCP_COVER_ART_CONNECTED; 362 cover_art_client_emit_operation_complete_event(cover_art_client, OBEX_UNKNOWN_ERROR); 363 break; 364 } 365 break; 366 case AVRCP_COVER_ART_W4_DISCONNECT_RESPONSE: 367 goep_client_disconnect(cover_art_client->goep_cid); 368 break; 369 default: 370 btstack_unreachable(); 371 break; 372 } 373 } 374 } 375 376 static void avrcp_cover_art_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){ 377 UNUSED(channel); // ok: there is no channel 378 UNUSED(size); // ok: handling own goep events 379 avrcp_cover_art_client_t * cover_art_client; 380 switch (packet_type){ 381 case HCI_EVENT_PACKET: 382 avrcp_cover_art_goep_event_handler(packet, size); 383 break; 384 case GOEP_DATA_PACKET: 385 cover_art_client = avrcp_cover_art_client_for_goep_cid(channel); 386 btstack_assert(cover_art_client != NULL); 387 avrcp_cover_art_client_goep_data_handler(cover_art_client, packet, size); 388 break; 389 default: 390 break; 391 } 392 } 393 394 static uint8_t avrcp_cover_art_client_setup_connection(avrcp_cover_art_client_t * cover_art_client, uint16_t l2cap_psm){ 395 cover_art_client->state = AVRCP_COVER_ART_W4_GOEP_CONNECTION; 396 return goep_client_connect_l2cap(&cover_art_client->goep_client, 397 (l2cap_ertm_config_t *) cover_art_client->ertm_config, 398 cover_art_client->ertm_buffer, 399 cover_art_client->ertm_buffer_size, 400 &avrcp_cover_art_packet_handler, 401 cover_art_client->addr, 402 l2cap_psm, 403 &cover_art_client->goep_cid); 404 } 405 406 static void avrcp_cover_art_handle_sdp_query_complete(avrcp_connection_t * connection, uint8_t status){ 407 avrcp_cover_art_client_t * cover_art_client = avrcp_cover_art_client_for_avrcp_cid(connection->avrcp_cid); 408 409 if (cover_art_client == NULL) { 410 return; 411 } 412 if (cover_art_client->state != AVRCP_COVER_ART_W4_SDP_QUERY_COMPLETE){ 413 return; 414 } 415 416 // l2cap available? 417 if (status == ERROR_CODE_SUCCESS){ 418 if (connection->cover_art_psm == 0){ 419 status = SDP_SERVICE_NOT_FOUND; 420 } 421 } 422 423 if (status == ERROR_CODE_SUCCESS) { 424 // ready to connect 425 cover_art_client->state = AVRCP_COVER_ART_W2_GOEP_CONNECT; 426 status = avrcp_cover_art_client_setup_connection(cover_art_client, connection->cover_art_psm); 427 } 428 429 if (status != ERROR_CODE_SUCCESS){ 430 btstack_packet_handler_t packet_handler = cover_art_client->packet_handler; 431 uint16_t cover_art_cid = cover_art_client->cover_art_cid; 432 uint16_t avrcp_cid = cover_art_client->avrcp_cid; 433 avrcp_cover_art_finalize_connection(cover_art_client); 434 avrcp_cover_art_client_emit_connection_established(packet_handler, status, connection->remote_addr, 435 avrcp_cid, cover_art_cid); 436 } 437 } 438 439 void avrcp_cover_art_client_init(void){ 440 avrcp_register_cover_art_sdp_query_complete_handler(&avrcp_cover_art_handle_sdp_query_complete); 441 } 442 443 uint8_t 444 avrcp_cover_art_client_connect(avrcp_cover_art_client_t *cover_art_client, btstack_packet_handler_t packet_handler, 445 bd_addr_t remote_addr, uint8_t *ertm_buffer, uint32_t ertm_buffer_size, 446 const l2cap_ertm_config_t *ertm_config, uint16_t *avrcp_cover_art_cid) { 447 448 avrcp_connection_t * connection_controller = avrcp_get_connection_for_bd_addr_for_role(AVRCP_CONTROLLER, remote_addr); 449 avrcp_connection_t * connection_target = avrcp_get_connection_for_bd_addr_for_role(AVRCP_TARGET, remote_addr); 450 if ((connection_target == NULL) || (connection_controller == NULL)){ 451 return ERROR_CODE_COMMAND_DISALLOWED; 452 } 453 454 cover_art_client->cover_art_cid = avrcp_cover_art_client_next_cid(); 455 memcpy(cover_art_client->addr, remote_addr, 6); 456 cover_art_client->avrcp_cid = connection_controller->avrcp_cid; 457 cover_art_client->packet_handler = packet_handler; 458 cover_art_client->flow_control_enabled = false; 459 460 // store ERTM config 461 cover_art_client->ertm_config = ertm_config; 462 cover_art_client->ertm_buffer = ertm_buffer; 463 cover_art_client->ertm_buffer_size = ertm_buffer_size; 464 465 if (avrcp_cover_art_cid != NULL){ 466 *avrcp_cover_art_cid = cover_art_client->cover_art_cid; 467 } 468 469 btstack_linked_list_add(&avrcp_cover_art_client_connections, (btstack_linked_item_t *) cover_art_client); 470 471 if (connection_controller->cover_art_psm == 0){ 472 cover_art_client->state = AVRCP_COVER_ART_W4_SDP_QUERY_COMPLETE; 473 avrcp_trigger_sdp_query(connection_controller, connection_controller); 474 return ERROR_CODE_SUCCESS; 475 } else { 476 return avrcp_cover_art_client_setup_connection(cover_art_client, connection_controller->cover_art_psm); 477 } 478 } 479 480 static uint8_t avrcp_cover_art_client_get_object(uint16_t avrcp_cover_art_cid, const char * object_type, const char * image_handle, const char * image_descriptor){ 481 avrcp_cover_art_client_t * cover_art_client = avrcp_cover_art_client_for_cover_art_cid(avrcp_cover_art_cid); 482 if (cover_art_client == NULL){ 483 return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER; 484 } 485 if (cover_art_client->state != AVRCP_COVER_ART_CONNECTED){ 486 return ERROR_CODE_COMMAND_DISALLOWED; 487 } 488 cover_art_client->state = AVRCP_COVER_ART_W2_SEND_GET_OBJECT; 489 cover_art_client->first_request = true; 490 cover_art_client->image_handle = image_handle; 491 cover_art_client->image_descriptor = image_descriptor; 492 cover_art_client->object_type = object_type; 493 goep_client_request_can_send_now(cover_art_client->goep_cid); 494 return ERROR_CODE_SUCCESS; 495 } 496 497 uint8_t avrcp_cover_art_client_get_linked_thumbnail(uint16_t avrcp_cover_art_cid, const char * image_handle){ 498 return avrcp_cover_art_client_get_object(avrcp_cover_art_cid, 499 avrcp_cover_art_linked_thumbnail_type, 500 image_handle, 501 NULL); 502 } 503 504 uint8_t avrcp_cover_art_client_get_image(uint16_t avrcp_cover_art_cid, const char * image_handle, const char * image_descriptor){ 505 return avrcp_cover_art_client_get_object(avrcp_cover_art_cid, 506 avrcp_cover_art_image_type, 507 image_handle, 508 image_descriptor); 509 } 510 511 uint8_t avrcp_cover_art_client_get_image_properties(uint16_t avrcp_cover_art_cid, const char * image_handle){ 512 return avrcp_cover_art_client_get_object(avrcp_cover_art_cid, 513 avrcp_cover_art_image_properties_type, 514 image_handle, 515 NULL); 516 } 517 518 uint8_t avrcp_cover_art_client_disconnect(uint16_t avrcp_cover_art_cid){ 519 avrcp_cover_art_client_t * cover_art_client = avrcp_cover_art_client_for_cover_art_cid(avrcp_cover_art_cid); 520 if (cover_art_client == NULL){ 521 return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER; 522 } 523 if (cover_art_client->state < AVRCP_COVER_ART_CONNECTED){ 524 return ERROR_CODE_COMMAND_DISALLOWED; 525 } 526 cover_art_client->state = AVRCP_COVER_ART_W2_SEND_DISCONNECT_REQUEST; 527 goep_client_request_can_send_now(cover_art_client->goep_cid); 528 return ERROR_CODE_SUCCESS; 529 } 530 531 void avrcp_cover_art_client_deinit(void){ 532 avrcp_cover_art_client_connections = NULL; 533 } 534 535 #endif /* ENABLE_AVRCP_COVER_ART */ 536