profiles/audio/avrcp.c

   1 /*
   2  *
   3  *  BlueZ - Bluetooth protocol stack for Linux
   4  *
   5  *  Copyright (C) 2006-2010  Nokia Corporation
   6  *  Copyright (C) 2004-2010  Marcel Holtmann <marcel@holtmann.org>
   7  *  Copyright (C) 2011  Texas Instruments, Inc.
   8  *
   9  *
  10  *  This program is free software; you can redistribute it and/or modify
  11  *  it under the terms of the GNU General Public License as published by
  12  *  the Free Software Foundation; either version 2 of the License, or
  13  *  (at your option) any later version.
  14  *
  15  *  This program is distributed in the hope that it will be useful,
  16  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  *  GNU General Public License for more details.
  19  *
  20  *  You should have received a copy of the GNU General Public License
  21  *  along with this program; if not, write to the Free Software
  22  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  23  *
  24  */
  25
  26 #ifdef HAVE_CONFIG_H
  27 #include <config.h>
  28 #endif
  29
  30 #include <stdlib.h>
  31 #include <stdint.h>
  32 #include <inttypes.h>
  33 #include <stdbool.h>
  34 #include <errno.h>
  35 #include <unistd.h>
  36 #include <assert.h>
  37 #include <signal.h>
  38 #include <sys/types.h>
  39 #include <sys/stat.h>
  40 #include <fcntl.h>
  41
  42 #include <glib.h>
  43 #include <dbus/dbus.h>
  44
  45 #include "bluetooth/bluetooth.h"
  46 #include "bluetooth/sdp.h"
  47 #include "bluetooth/sdp_lib.h"
  48 #include "lib/uuid.h"
  49
  50 #include "gdbus/gdbus.h"
  51
  52 #include "src/plugin.h"
  53 #include "src/adapter.h"
  54 #include "src/device.h"
  55 #include "src/profile.h"
  56 #include "src/service.h"
  57 #include "src/log.h"
  58 #include "src/error.h"
  59 #include "src/sdpd.h"
  60 #include "src/dbus-common.h"
  61 #include "src/shared/util.h"
  62
  63 #include "avctp.h"
  64 #include "avrcp.h"
  65 #include "control.h"
  66 #include "player.h"
  67 #include "transport.h"
  68
  69 /* Company IDs for vendor dependent commands */
  70 #define IEEEID_BTSIG            0x001958
  71
  72 /* Status codes */
  73 #define AVRCP_STATUS_INVALID_COMMAND            0x00
  74 #define AVRCP_STATUS_INVALID_PARAM              0x01
  75 #define AVRCP_STATUS_PARAM_NOT_FOUND            0x02
  76 #define AVRCP_STATUS_INTERNAL_ERROR             0x03
  77 #define AVRCP_STATUS_SUCCESS                    0x04
  78 #define AVRCP_STATUS_OUT_OF_BOUNDS              0x0b
  79 #define AVRCP_STATUS_INVALID_PLAYER_ID          0x11
  80 #define AVRCP_STATUS_PLAYER_NOT_BROWSABLE       0x12
  81 #define AVRCP_STATUS_NO_AVAILABLE_PLAYERS       0x15
  82 #define AVRCP_STATUS_ADDRESSED_PLAYER_CHANGED   0x16
  83
  84 /* Packet types */
  85 #define AVRCP_PACKET_TYPE_SINGLE        0x00
  86 #define AVRCP_PACKET_TYPE_START         0x01
  87 #define AVRCP_PACKET_TYPE_CONTINUING    0x02
  88 #define AVRCP_PACKET_TYPE_END           0x03
  89
  90 /* PDU types for metadata transfer */
  91 #define AVRCP_GET_CAPABILITIES          0x10
  92 #define AVRCP_LIST_PLAYER_ATTRIBUTES    0X11
  93 #define AVRCP_LIST_PLAYER_VALUES        0x12
  94 #define AVRCP_GET_CURRENT_PLAYER_VALUE  0x13
  95 #define AVRCP_SET_PLAYER_VALUE          0x14
  96 #define AVRCP_GET_PLAYER_ATTRIBUTE_TEXT 0x15
  97 #define AVRCP_GET_PLAYER_VALUE_TEXT     0x16
  98 #define AVRCP_DISPLAYABLE_CHARSET       0x17
  99 #define AVRCP_CT_BATTERY_STATUS         0x18
 100 #define AVRCP_GET_ELEMENT_ATTRIBUTES    0x20
 101 #define AVRCP_GET_PLAY_STATUS           0x30
 102 #define AVRCP_REGISTER_NOTIFICATION     0x31
 103 #define AVRCP_REQUEST_CONTINUING        0x40
 104 #define AVRCP_ABORT_CONTINUING          0x41
 105 #define AVRCP_SET_ABSOLUTE_VOLUME       0x50
 106 #define AVRCP_SET_ADDRESSED_PLAYER      0x60
 107 #define AVRCP_SET_BROWSED_PLAYER        0x70
 108 #define AVRCP_GET_FOLDER_ITEMS          0x71
 109 #define AVRCP_CHANGE_PATH               0x72
 110 #define AVRCP_GET_ITEM_ATTRIBUTES       0x73
 111 #define AVRCP_PLAY_ITEM                 0x74
 112 #define AVRCP_GET_TOTAL_NUMBER_OF_ITEMS 0x75
 113 #define AVRCP_SEARCH                    0x80
 114 #define AVRCP_ADD_TO_NOW_PLAYING        0x90
 115 #define AVRCP_GENERAL_REJECT            0xA0
 116
 117 /* Capabilities for AVRCP_GET_CAPABILITIES pdu */
 118 #define CAP_COMPANY_ID          0x02
 119 #define CAP_EVENTS_SUPPORTED    0x03
 120
 121 #define AVRCP_REGISTER_NOTIFICATION_PARAM_LENGTH 5
 122 #define AVRCP_GET_CAPABILITIES_PARAM_LENGTH 1
 123
 124 #define AVRCP_FEATURE_CATEGORY_1        0x0001
 125 #define AVRCP_FEATURE_CATEGORY_2        0x0002
 126 #define AVRCP_FEATURE_CATEGORY_3        0x0004
 127 #define AVRCP_FEATURE_CATEGORY_4        0x0008
 128 #define AVRCP_FEATURE_PLAYER_SETTINGS   0x0010
 129 #define AVRCP_FEATURE_BROWSING                  0x0040
 130
 131 #define AVRCP_BATTERY_STATUS_NORMAL             0
 132 #define AVRCP_BATTERY_STATUS_WARNING            1
 133 #define AVRCP_BATTERY_STATUS_CRITICAL           2
 134 #define AVRCP_BATTERY_STATUS_EXTERNAL           3
 135 #define AVRCP_BATTERY_STATUS_FULL_CHARGE        4
 136
 137 #define AVRCP_CHARSET_UTF8              106
 138
 139 #define AVRCP_BROWSING_TIMEOUT          1
 140 #ifdef __TIZEN_PATCH__
 141 #define AVRCP_CT_VERSION                0x0103
 142 #define AVRCP_TG_VERSION                0x0103
 143 #else
 144 #define AVRCP_CT_VERSION                0x0106
 145 #define AVRCP_TG_VERSION                0x0105
 146 #endif
 147 #define AVRCP_SCOPE_MEDIA_PLAYER_LIST                   0x00
 148 #define AVRCP_SCOPE_MEDIA_PLAYER_VFS                    0x01
 149 #define AVRCP_SCOPE_SEARCH                              0x02
 150 #define AVRCP_SCOPE_NOW_PLAYING                 0x03
 151
 152 #if __BYTE_ORDER == __LITTLE_ENDIAN
 153
 154 struct avrcp_header {
 155         uint8_t company_id[3];
 156         uint8_t pdu_id;
 157         uint8_t packet_type:2;
 158         uint8_t rsvd:6;
 159         uint16_t params_len;
 160         uint8_t params[0];
 161 } __attribute__ ((packed));
 162 #define AVRCP_HEADER_LENGTH 7
 163
 164 #elif __BYTE_ORDER == __BIG_ENDIAN
 165
 166 struct avrcp_header {
 167         uint8_t company_id[3];
 168         uint8_t pdu_id;
 169         uint8_t rsvd:6;
 170         uint8_t packet_type:2;
 171         uint16_t params_len;
 172         uint8_t params[0];
 173 } __attribute__ ((packed));
 174 #define AVRCP_HEADER_LENGTH 7
 175
 176 #else
 177 #error "Unknown byte order"
 178 #endif
 179
 180 #define AVRCP_MTU       (AVC_MTU - AVC_HEADER_LENGTH)
 181 #define AVRCP_PDU_MTU   (AVRCP_MTU - AVRCP_HEADER_LENGTH)
 182
 183 struct avrcp_browsing_header {
 184         uint8_t pdu_id;
 185         uint16_t param_len;
 186         uint8_t params[0];
 187 } __attribute__ ((packed));
 188 #define AVRCP_BROWSING_HEADER_LENGTH 3
 189
 190 struct get_folder_items_rsp {
 191         uint8_t status;
 192         uint16_t uid_counter;
 193         uint16_t num_items;
 194         uint8_t data[0];
 195 } __attribute__ ((packed));
 196
 197 struct folder_item {
 198         uint8_t type;
 199         uint16_t len;
 200         uint8_t data[0];
 201 } __attribute__ ((packed));
 202
 203 struct player_item {
 204         uint16_t player_id;
 205         uint8_t type;
 206         uint32_t subtype;
 207         uint8_t status;
 208         uint8_t features[16];
 209         uint16_t charset;
 210         uint16_t namelen;
 211         char name[0];
 212 } __attribute__ ((packed));
 213
 214 struct avrcp_server {
 215         struct btd_adapter *adapter;
 216         uint32_t tg_record_id;
 217         uint32_t ct_record_id;
 218         GSList *players;
 219         GSList *sessions;
 220 };
 221
 222 struct pending_pdu {
 223         uint8_t pdu_id;
 224         GList *attr_ids;
 225         uint16_t offset;
 226 };
 227
 228 struct pending_list_items {
 229         GSList *items;
 230         uint32_t start;
 231         uint32_t end;
 232         uint64_t total;
 233 };
 234
 235 struct avrcp_player {
 236         struct avrcp_server *server;
 237         GSList *sessions;
 238         uint16_t id;
 239         uint8_t scope;
 240         uint64_t uid;
 241         uint16_t uid_counter;
 242         bool browsed;
 243         bool addressed;
 244         uint8_t *features;
 245         char *path;
 246         guint changed_id;
 247
 248         struct pending_list_items *p;
 249         char *change_path;
 250
 251         struct avrcp_player_cb *cb;
 252         void *user_data;
 253         GDestroyNotify destroy;
 254 };
 255
 256 struct avrcp_data {
 257         struct avrcp_player *player;
 258         uint16_t version;
 259         int features;
 260         GSList *players;
 261 };
 262
 263 struct avrcp {
 264         struct avrcp_server *server;
 265         struct avctp *conn;
 266         struct btd_device *dev;
 267         struct avrcp_data *target;
 268         struct avrcp_data *controller;
 269
 270         const struct passthrough_handler *passthrough_handlers;
 271         const struct control_pdu_handler *control_handlers;
 272
 273         unsigned int passthrough_id;
 274         unsigned int control_id;
 275         unsigned int browsing_id;
 276         unsigned int browsing_timer;
 277         uint16_t supported_events;
 278         uint16_t registered_events;
 279         uint8_t transaction;
 280         uint8_t transaction_events[AVRCP_EVENT_LAST + 1];
 281         struct pending_pdu *pending_pdu;
 282 #ifdef __TIZEN_PATCH__
 283         uint32_t playback_status_id;
 284 #endif
 285 };
 286
 287 struct passthrough_handler {
 288         uint8_t op;
 289         bool (*func) (struct avrcp *session);
 290 };
 291
 292 struct control_pdu_handler {
 293         uint8_t pdu_id;
 294         uint8_t code;
 295         uint8_t (*func) (struct avrcp *session, struct avrcp_header *pdu,
 296                                                         uint8_t transaction);
 297 };
 298
 299 static GSList *servers = NULL;
 300 static unsigned int avctp_id = 0;
 301
 302 #ifdef __TIZEN_PATCH__
 303 #ifdef SUPPORT_AVRCP_TARGET
 304 static uint16_t adapter_avrcp_tg_ver = 0;
 305 #endif
 306 #ifdef SUPPORT_AVRCP_CONTROL
 307 static uint16_t adapter_avrcp_ct_ver = 0;
 308 #endif
 309 #endif
 310
 311 /* Default feature bit mask for media player as per avctp.c:key_map */
 312 static const uint8_t features[16] = {
 313                                 0xF8, 0xBF, 0xFF, 0xBF, 0x1F,
 314                                 0xFB, 0x3F, 0x60, 0x00, 0x00,
 315                                 0x00, 0x00, 0x00, 0x00, 0x00,
 316                                 0x00 };
 317
 318 /* Company IDs supported by this device */
 319 static uint32_t company_ids[] = {
 320         IEEEID_BTSIG,
 321 };
 322
 323 static void avrcp_register_notification(struct avrcp *session, uint8_t event);
 324
 325 #ifdef __TIZEN_PATCH__
 326 static GList *player_list_settings(struct avrcp_player *player);
 327 void avrcp_stop_position_timer(void);
 328 unsigned int pos_timer_id = 0;
 329 #endif
 330
 331 #ifdef SUPPORT_AVRCP_CONTROL
 332 static sdp_record_t *avrcp_ct_record(void)
 333 {
 334         sdp_list_t *svclass_id, *pfseq, *apseq, *apseq1, *root;
 335         uuid_t root_uuid, l2cap, avctp, avrct, avrctr;
 336         sdp_profile_desc_t profile[1];
 337         sdp_list_t *aproto, *aproto1, *proto[2], *proto1[2];
 338         sdp_record_t *record;
 339         sdp_data_t *psm[2], *version, *features;
 340         uint16_t lp = AVCTP_CONTROL_PSM, ap = AVCTP_BROWSING_PSM;
 341 #ifdef __TIZEN_PATCH__
 342         uint16_t avctp_ver = 0x0104;
 343         uint16_t feat = 0;
 344 #ifdef ENABLE_AVRCP_CATEGORY1
 345         feat = AVRCP_FEATURE_CATEGORY_1;
 346 #endif
 347 #ifdef ENABLE_AVRCP_CATEGORY2
 348         feat = feat | AVRCP_FEATURE_CATEGORY_2;
 349 #endif
 350 #else
 351         uint16_t avctp_ver = 0x0103;
 352         uint16_t feat = ( AVRCP_FEATURE_CATEGORY_1 |
 353                                                 AVRCP_FEATURE_CATEGORY_2 |
 354                                                 AVRCP_FEATURE_CATEGORY_3 |
 355                                                 AVRCP_FEATURE_CATEGORY_4 |
 356                                                 AVRCP_FEATURE_BROWSING);
 357 #endif
 358
 359         record = sdp_record_alloc();
 360         if (!record)
 361                 return NULL;
 362
 363         sdp_uuid16_create(&root_uuid, PUBLIC_BROWSE_GROUP);
 364         root = sdp_list_append(NULL, &root_uuid);
 365         sdp_set_browse_groups(record, root);
 366
 367         /* Service Class ID List */
 368         sdp_uuid16_create(&avrct, AV_REMOTE_SVCLASS_ID);
 369         svclass_id = sdp_list_append(NULL, &avrct);
 370         sdp_uuid16_create(&avrctr, AV_REMOTE_CONTROLLER_SVCLASS_ID);
 371         svclass_id = sdp_list_append(svclass_id, &avrctr);
 372         sdp_set_service_classes(record, svclass_id);
 373
 374         /* Protocol Descriptor List */
 375         sdp_uuid16_create(&l2cap, L2CAP_UUID);
 376         proto[0] = sdp_list_append(NULL, &l2cap);
 377         psm[0] = sdp_data_alloc(SDP_UINT16, &lp);
 378         proto[0] = sdp_list_append(proto[0], psm[0]);
 379         apseq = sdp_list_append(NULL, proto[0]);
 380
 381         sdp_uuid16_create(&avctp, AVCTP_UUID);
 382         proto[1] = sdp_list_append(NULL, &avctp);
 383         version = sdp_data_alloc(SDP_UINT16, &avctp_ver);
 384         proto[1] = sdp_list_append(proto[1], version);
 385         apseq = sdp_list_append(apseq, proto[1]);
 386
 387         aproto = sdp_list_append(NULL, apseq);
 388         sdp_set_access_protos(record, aproto);
 389
 390         /* Additional Protocol Descriptor List */
 391         sdp_uuid16_create(&l2cap, L2CAP_UUID);
 392         proto1[0] = sdp_list_append(NULL, &l2cap);
 393         psm[1] = sdp_data_alloc(SDP_UINT16, &ap);
 394         proto1[0] = sdp_list_append(proto1[0], psm[1]);
 395         apseq1 = sdp_list_append(NULL, proto1[0]);
 396
 397         sdp_uuid16_create(&avctp, AVCTP_UUID);
 398         proto1[1] = sdp_list_append(NULL, &avctp);
 399         proto1[1] = sdp_list_append(proto1[1], version);
 400         apseq1 = sdp_list_append(apseq1, proto1[1]);
 401
 402         aproto1 = sdp_list_append(NULL, apseq1);
 403         sdp_set_add_access_protos(record, aproto1);
 404
 405         /* Bluetooth Profile Descriptor List */
 406         sdp_uuid16_create(&profile[0].uuid, AV_REMOTE_PROFILE_ID);
 407         profile[0].version = AVRCP_CT_VERSION;
 408 #ifdef __TIZEN_PATCH__
 409         adapter_avrcp_ct_ver = AVRCP_CT_VERSION;
 410 #endif
 411         pfseq = sdp_list_append(NULL, &profile[0]);
 412         sdp_set_profile_descs(record, pfseq);
 413
 414         features = sdp_data_alloc(SDP_UINT16, &feat);
 415         sdp_attr_add(record, SDP_ATTR_SUPPORTED_FEATURES, features);
 416
 417         sdp_set_info_attr(record, "AVRCP CT", NULL, NULL);
 418
 419         free(psm[0]);
 420         free(psm[1]);
 421         free(version);
 422         sdp_list_free(proto[0], NULL);
 423         sdp_list_free(proto[1], NULL);
 424         sdp_list_free(apseq, NULL);
 425         sdp_list_free(proto1[0], NULL);
 426         sdp_list_free(proto1[1], NULL);
 427         sdp_list_free(aproto1, NULL);
 428         sdp_list_free(apseq1, NULL);
 429         sdp_list_free(pfseq, NULL);
 430         sdp_list_free(aproto, NULL);
 431         sdp_list_free(root, NULL);
 432         sdp_list_free(svclass_id, NULL);
 433
 434         return record;
 435 }
 436 #endif
 437
 438 #ifdef SUPPORT_AVRCP_TARGET
 439 static sdp_record_t *avrcp_tg_record(void)
 440 {
 441         sdp_list_t *svclass_id, *pfseq, *apseq, *root, *apseq_browsing;
 442         uuid_t root_uuid, l2cap, avctp, avrtg;
 443         sdp_profile_desc_t profile[1];
 444         sdp_list_t *aproto_control, *proto_control[2];
 445         sdp_record_t *record;
 446         sdp_data_t *psm_control, *version, *features, *psm_browsing;
 447 #ifndef __TIZEN_PATCH__
 448         sdp_list_t *aproto_browsing;
 449 #endif
 450         sdp_list_t *proto_browsing[2] = {0};
 451         uint16_t lp = AVCTP_CONTROL_PSM;
 452         uint16_t lp_browsing = AVCTP_BROWSING_PSM;
 453 #ifdef __TIZEN_PATCH__
 454         uint16_t avctp_ver = 0x0104;
 455         uint16_t feat = 0;
 456 #ifdef ENABLE_AVRCP_CATEGORY1
 457         feat = AVRCP_FEATURE_CATEGORY_1 |
 458                 AVRCP_FEATURE_PLAYER_SETTINGS;
 459 #endif
 460 #ifdef ENABLE_AVRCP_CATEGORY2
 461         feat = feat | AVRCP_FEATURE_CATEGORY_2;
 462 #endif
 463 #else
 464         uint16_t avctp_ver = 0x0103;
 465         uint16_t feat = ( AVRCP_FEATURE_CATEGORY_1 |
 466                                         AVRCP_FEATURE_CATEGORY_2 |
 467                                         AVRCP_FEATURE_CATEGORY_3 |
 468                                         AVRCP_FEATURE_CATEGORY_4 |
 469                                         AVRCP_FEATURE_BROWSING |
 470                                         AVRCP_FEATURE_PLAYER_SETTINGS );
 471 #endif
 472         record = sdp_record_alloc();
 473         if (!record)
 474                 return NULL;
 475
 476         sdp_uuid16_create(&root_uuid, PUBLIC_BROWSE_GROUP);
 477         root = sdp_list_append(NULL, &root_uuid);
 478         sdp_set_browse_groups(record, root);
 479
 480         /* Service Class ID List */
 481         sdp_uuid16_create(&avrtg, AV_REMOTE_TARGET_SVCLASS_ID);
 482         svclass_id = sdp_list_append(NULL, &avrtg);
 483         sdp_set_service_classes(record, svclass_id);
 484
 485         /* Protocol Descriptor List */
 486         sdp_uuid16_create(&l2cap, L2CAP_UUID);
 487         proto_control[0] = sdp_list_append(NULL, &l2cap);
 488         psm_control = sdp_data_alloc(SDP_UINT16, &lp);
 489         proto_control[0] = sdp_list_append(proto_control[0], psm_control);
 490         apseq = sdp_list_append(NULL, proto_control[0]);
 491
 492         sdp_uuid16_create(&avctp, AVCTP_UUID);
 493         proto_control[1] = sdp_list_append(NULL, &avctp);
 494         version = sdp_data_alloc(SDP_UINT16, &avctp_ver);
 495         proto_control[1] = sdp_list_append(proto_control[1], version);
 496         apseq = sdp_list_append(apseq, proto_control[1]);
 497
 498         aproto_control = sdp_list_append(NULL, apseq);
 499         sdp_set_access_protos(record, aproto_control);
 500         proto_browsing[0] = sdp_list_append(NULL, &l2cap);
 501         psm_browsing = sdp_data_alloc(SDP_UINT16, &lp_browsing);
 502         proto_browsing[0] = sdp_list_append(proto_browsing[0], psm_browsing);
 503         apseq_browsing = sdp_list_append(NULL, proto_browsing[0]);
 504
 505         proto_browsing[1] = sdp_list_append(NULL, &avctp);
 506         proto_browsing[1] = sdp_list_append(proto_browsing[1], version);
 507         apseq_browsing = sdp_list_append(apseq_browsing, proto_browsing[1]);
 508
 509 #ifndef __TIZEN_PATCH__
 510         aproto_browsing = sdp_list_append(NULL, apseq_browsing);
 511         sdp_set_add_access_protos(record, aproto_browsing);
 512 #endif
 513
 514         /* Bluetooth Profile Descriptor List */
 515         sdp_uuid16_create(&profile[0].uuid, AV_REMOTE_PROFILE_ID);
 516         profile[0].version = AVRCP_TG_VERSION;
 517 #ifdef __TIZEN_PATCH__
 518         adapter_avrcp_tg_ver = AVRCP_TG_VERSION;
 519 #endif
 520         pfseq = sdp_list_append(NULL, &profile[0]);
 521         sdp_set_profile_descs(record, pfseq);
 522
 523         features = sdp_data_alloc(SDP_UINT16, &feat);
 524         sdp_attr_add(record, SDP_ATTR_SUPPORTED_FEATURES, features);
 525
 526         sdp_set_info_attr(record, "AVRCP TG", NULL, NULL);
 527
 528         free(psm_browsing);
 529         sdp_list_free(proto_browsing[0], NULL);
 530         sdp_list_free(proto_browsing[1], NULL);
 531         sdp_list_free(apseq_browsing, NULL);
 532 #ifndef __TIZEN_PATCH__
 533         sdp_list_free(aproto_browsing, NULL);
 534 #endif
 535
 536         free(psm_control);
 537         free(version);
 538         sdp_list_free(proto_control[0], NULL);
 539         sdp_list_free(proto_control[1], NULL);
 540         sdp_list_free(apseq, NULL);
 541         sdp_list_free(aproto_control, NULL);
 542         sdp_list_free(pfseq, NULL);
 543         sdp_list_free(root, NULL);
 544         sdp_list_free(svclass_id, NULL);
 545
 546         return record;
 547 }
 548 #endif
 549
 550 static unsigned int attr_get_max_val(uint8_t attr)
 551 {
 552         switch (attr) {
 553         case AVRCP_ATTRIBUTE_EQUALIZER:
 554                 return AVRCP_EQUALIZER_ON;
 555         case AVRCP_ATTRIBUTE_REPEAT_MODE:
 556 #ifdef __TIZEN_PATCH__
 557                 return AVRCP_REPEAT_MODE_ALL;
 558 #else
 559                 return AVRCP_REPEAT_MODE_GROUP;
 560 #endif
 561         case AVRCP_ATTRIBUTE_SHUFFLE:
 562 #ifdef __TIZEN_PATCH__
 563                 return AVRCP_SHUFFLE_ALL;
 564 #else
 565                 return AVRCP_SHUFFLE_GROUP;
 566 #endif
 567         case AVRCP_ATTRIBUTE_SCAN:
 568                 return AVRCP_SCAN_GROUP;
 569         }
 570
 571         return 0;
 572 }
 573
 574 static const char *battery_status_to_str(uint8_t status)
 575 {
 576         switch (status) {
 577         case AVRCP_BATTERY_STATUS_NORMAL:
 578                 return "normal";
 579         case AVRCP_BATTERY_STATUS_WARNING:
 580                 return "warning";
 581         case AVRCP_BATTERY_STATUS_CRITICAL:
 582                 return "critical";
 583         case AVRCP_BATTERY_STATUS_EXTERNAL:
 584                 return "external";
 585         case AVRCP_BATTERY_STATUS_FULL_CHARGE:
 586                 return "fullcharge";
 587         }
 588
 589         return NULL;
 590 }
 591
 592 /*
 593  * get_company_id:
 594  *
 595  * Get three-byte Company_ID from incoming AVRCP message
 596  */
 597 static uint32_t get_company_id(const uint8_t cid[3])
 598 {
 599         return cid[0] << 16 | cid[1] << 8 | cid[2];
 600 }
 601
 602 /*
 603  * set_company_id:
 604  *
 605  * Set three-byte Company_ID into outgoing AVRCP message
 606  */
 607 static void set_company_id(uint8_t cid[3], uint32_t cid_in)
 608 {
 609         cid[0] = (cid_in & 0xff0000) >> 16;
 610         cid[1] = (cid_in & 0x00ff00) >> 8;
 611         cid[2] = (cid_in & 0x0000ff);
 612 }
 613
 614 static const char *attr_to_str(uint8_t attr)
 615 {
 616         switch (attr) {
 617         case AVRCP_ATTRIBUTE_EQUALIZER:
 618                 return "Equalizer";
 619         case AVRCP_ATTRIBUTE_REPEAT_MODE:
 620                 return "Repeat";
 621         case AVRCP_ATTRIBUTE_SHUFFLE:
 622                 return "Shuffle";
 623         case AVRCP_ATTRIBUTE_SCAN:
 624                 return "Scan";
 625         }
 626
 627         return NULL;
 628 }
 629
 630 static int attrval_to_val(uint8_t attr, const char *value)
 631 {
 632         int ret;
 633
 634         switch (attr) {
 635         case AVRCP_ATTRIBUTE_EQUALIZER:
 636                 if (!strcmp(value, "off"))
 637                         ret = AVRCP_EQUALIZER_OFF;
 638                 else if (!strcmp(value, "on"))
 639                         ret = AVRCP_EQUALIZER_ON;
 640                 else
 641                         ret = -EINVAL;
 642
 643                 return ret;
 644         case AVRCP_ATTRIBUTE_REPEAT_MODE:
 645                 if (!strcmp(value, "off"))
 646                         ret = AVRCP_REPEAT_MODE_OFF;
 647                 else if (!strcmp(value, "singletrack"))
 648                         ret = AVRCP_REPEAT_MODE_SINGLE;
 649                 else if (!strcmp(value, "alltracks"))
 650                         ret = AVRCP_REPEAT_MODE_ALL;
 651                 else if (!strcmp(value, "group"))
 652                         ret = AVRCP_REPEAT_MODE_GROUP;
 653                 else
 654                         ret = -EINVAL;
 655
 656                 return ret;
 657         case AVRCP_ATTRIBUTE_SHUFFLE:
 658                 if (!strcmp(value, "off"))
 659                         ret = AVRCP_SHUFFLE_OFF;
 660                 else if (!strcmp(value, "alltracks"))
 661                         ret = AVRCP_SHUFFLE_ALL;
 662                 else if (!strcmp(value, "group"))
 663                         ret = AVRCP_SHUFFLE_GROUP;
 664                 else
 665                         ret = -EINVAL;
 666
 667                 return ret;
 668         case AVRCP_ATTRIBUTE_SCAN:
 669                 if (!strcmp(value, "off"))
 670                         ret = AVRCP_SCAN_OFF;
 671                 else if (!strcmp(value, "alltracks"))
 672                         ret = AVRCP_SCAN_ALL;
 673                 else if (!strcmp(value, "group"))
 674                         ret = AVRCP_SCAN_GROUP;
 675                 else
 676                         ret = -EINVAL;
 677
 678                 return ret;
 679         }
 680
 681         return -EINVAL;
 682 }
 683
 684 static int attr_to_val(const char *str)
 685 {
 686         if (!strcasecmp(str, "Equalizer"))
 687                 return AVRCP_ATTRIBUTE_EQUALIZER;
 688         else if (!strcasecmp(str, "Repeat"))
 689                 return AVRCP_ATTRIBUTE_REPEAT_MODE;
 690         else if (!strcasecmp(str, "Shuffle"))
 691                 return AVRCP_ATTRIBUTE_SHUFFLE;
 692         else if (!strcasecmp(str, "Scan"))
 693                 return AVRCP_ATTRIBUTE_SCAN;
 694
 695         return -EINVAL;
 696 }
 697
 698 static int player_get_setting(struct avrcp_player *player, uint8_t id)
 699 {
 700         const char *key;
 701         const char *value;
 702
 703         if (player == NULL)
 704                 return -ENOENT;
 705
 706         key = attr_to_str(id);
 707         if (key == NULL)
 708                 return -EINVAL;
 709
 710         value = player->cb->get_setting(key, player->user_data);
 711         if (value == NULL)
 712                 return -EINVAL;
 713
 714         return attrval_to_val(id, value);
 715 }
 716
 717 static int play_status_to_val(const char *status)
 718 {
 719         if (!strcasecmp(status, "stopped"))
 720                 return AVRCP_PLAY_STATUS_STOPPED;
 721         else if (!strcasecmp(status, "playing"))
 722                 return AVRCP_PLAY_STATUS_PLAYING;
 723         else if (!strcasecmp(status, "paused"))
 724                 return AVRCP_PLAY_STATUS_PAUSED;
 725         else if (!strcasecmp(status, "forward-seek"))
 726                 return AVRCP_PLAY_STATUS_FWD_SEEK;
 727         else if (!strcasecmp(status, "reverse-seek"))
 728                 return AVRCP_PLAY_STATUS_REV_SEEK;
 729         else if (!strcasecmp(status, "error"))
 730                 return AVRCP_PLAY_STATUS_ERROR;
 731
 732         return -EINVAL;
 733 }
 734
 735 void avrcp_player_event(struct avrcp_player *player, uint8_t id,
 736                                                         const void *data)
 737 {
 738         uint8_t buf[AVRCP_HEADER_LENGTH + 9];
 739         struct avrcp_header *pdu = (void *) buf;
 740         uint8_t code;
 741         uint16_t size;
 742         GSList *l;
 743         int attr;
 744         int val;
 745 #ifdef __TIZEN_PATCH__
 746         uint32_t *position_val = NULL;
 747         GList *settings;
 748 #endif
 749
 750         if (player->sessions == NULL)
 751                 return;
 752
 753         memset(buf, 0, sizeof(buf));
 754
 755         set_company_id(pdu->company_id, IEEEID_BTSIG);
 756
 757         pdu->pdu_id = AVRCP_REGISTER_NOTIFICATION;
 758
 759         DBG("id=%u", id);
 760
 761         if (id != AVRCP_EVENT_ADDRESSED_PLAYER_CHANGED && player->changed_id) {
 762                 code = AVC_CTYPE_REJECTED;
 763                 size = 1;
 764                 pdu->params[0] = AVRCP_STATUS_ADDRESSED_PLAYER_CHANGED;
 765                 goto done;
 766         }
 767
 768         code = AVC_CTYPE_CHANGED;
 769         pdu->params[0] = id;
 770
 771         switch (id) {
 772         case AVRCP_EVENT_STATUS_CHANGED:
 773                 size = 2;
 774                 pdu->params[1] = play_status_to_val(data);
 775
 776                 break;
 777         case AVRCP_EVENT_TRACK_CHANGED:
 778                 size = 9;
 779                 memcpy(&pdu->params[1], data, sizeof(uint64_t));
 780
 781                 break;
 782         case AVRCP_EVENT_TRACK_REACHED_END:
 783         case AVRCP_EVENT_TRACK_REACHED_START:
 784                 size = 1;
 785                 break;
 786         case AVRCP_EVENT_SETTINGS_CHANGED:
 787                 size = 2;
 788 #ifdef __TIZEN_PATCH__
 789                 settings = player_list_settings(player);
 790                 pdu->params[1] = g_list_length(settings);
 791                 for (; settings; settings = settings->next) {
 792                         const char *key = settings->data;
 793
 794                         attr = attr_to_val(key);
 795                         if (attr < 0)
 796                                 continue;
 797
 798                         val = player_get_setting(player, attr);
 799                         if (val < 0)
 800                                 continue;
 801
 802                         pdu->params[size++] = attr;
 803                         pdu->params[size++] = val;
 804                 }
 805 #else
 806                 pdu->params[1] = 1;
 807
 808                 attr = attr_to_val(data);
 809                 if (attr < 0)
 810                         return;
 811
 812                 val = player_get_setting(player, attr);
 813                 if (val < 0)
 814                         return;
 815
 816                 pdu->params[size++] = attr;
 817                 pdu->params[size++] = val;
 818 #endif /* __TIZEN__PATCH__ */
 819                 break;
 820 #ifdef __TIZEN_PATCH__
 821         case AVRCP_EVENT_PLAYBACK_POS_CHANGED:
 822                 size = 5;
 823                 position_val = (uint32_t *) data;
 824                 *position_val = (*position_val & 0x000000ff) << 24 |
 825                                  (*position_val & 0x0000ff00) << 8 |
 826                                  (*position_val & 0x00ff0000) >> 8 |
 827                                  (*position_val & 0xff000000) >> 24;
 828                 memcpy(&pdu->params[1], position_val, sizeof(uint32_t));
 829                 break;
 830 #endif
 831         case AVRCP_EVENT_ADDRESSED_PLAYER_CHANGED:
 832                 size = 5;
 833                 memcpy(&pdu->params[1], &player->id, sizeof(uint16_t));
 834                 memcpy(&pdu->params[3], &player->uid_counter, sizeof(uint16_t));
 835                 break;
 836         case AVRCP_EVENT_AVAILABLE_PLAYERS_CHANGED:
 837                 size = 1;
 838                 break;
 839         default:
 840                 error("Unknown event %u", id);
 841                 return;
 842         }
 843
 844 done:
 845         pdu->params_len = htons(size);
 846 #ifdef __TIZEN_PATCH__
 847         if (id == AVRCP_EVENT_PLAYBACK_POS_CHANGED &&
 848                         pos_timer_id > 0) {
 849                 /* Remove the timer function which was added for register notification.
 850                  * As we are sending changed event eariler then time interval.
 851                  */
 852                 DBG("Removing the timer function added by register notification");
 853                 g_source_remove(pos_timer_id);
 854                 pos_timer_id = 0;
 855         }
 856 #endif
 857
 858         for (l = player->sessions; l; l = l->next) {
 859                 struct avrcp *session = l->data;
 860                 int err;
 861
 862                 if (!(session->registered_events & (1 << id)))
 863                         continue;
 864
 865                 err = avctp_send_vendordep(session->conn,
 866                                         session->transaction_events[id],
 867                                         code, AVC_SUBUNIT_PANEL,
 868                                         buf, size + AVRCP_HEADER_LENGTH);
 869
 870                 if (err < 0)
 871                         continue;
 872
 873                 /* Unregister event as per AVRCP 1.3 spec, section 5.4.2 */
 874                 session->registered_events ^= 1 << id;
 875         }
 876
 877         return;
 878 }
 879
 880 static const char *metadata_to_str(uint32_t id)
 881 {
 882         switch (id) {
 883         case AVRCP_MEDIA_ATTRIBUTE_TITLE:
 884                 return "Title";
 885         case AVRCP_MEDIA_ATTRIBUTE_ARTIST:
 886                 return "Artist";
 887         case AVRCP_MEDIA_ATTRIBUTE_ALBUM:
 888                 return "Album";
 889         case AVRCP_MEDIA_ATTRIBUTE_GENRE:
 890                 return "Genre";
 891         case AVRCP_MEDIA_ATTRIBUTE_TRACK:
 892                 return "TrackNumber";
 893         case AVRCP_MEDIA_ATTRIBUTE_N_TRACKS:
 894                 return "NumberOfTracks";
 895         case AVRCP_MEDIA_ATTRIBUTE_DURATION:
 896                 return "Duration";
 897         }
 898
 899         return NULL;
 900 }
 901
 902 static const char *player_get_metadata(struct avrcp_player *player,
 903                                                                 uint32_t id)
 904 {
 905         const char *key;
 906
 907         key = metadata_to_str(id);
 908         if (key == NULL)
 909                 return NULL;
 910
 911         if (player != NULL)
 912                 return player->cb->get_metadata(key, player->user_data);
 913
 914         if (id == AVRCP_MEDIA_ATTRIBUTE_TITLE)
 915                 return "";
 916
 917         return NULL;
 918 }
 919
 920 static uint16_t player_write_media_attribute(struct avrcp_player *player,
 921                                                 uint32_t id, uint8_t *buf,
 922                                                 uint16_t *pos,
 923                                                 uint16_t *offset)
 924 {
 925         uint16_t len;
 926         uint16_t attr_len;
 927         const char *value = NULL;
 928
 929         DBG("%u", id);
 930
 931         value = player_get_metadata(player, id);
 932         if (value == NULL) {
 933                 *offset = 0;
 934                 return 0;
 935         }
 936
 937         attr_len = strlen(value);
 938         value = ((char *) value) + *offset;
 939         len = attr_len - *offset;
 940
 941         if (len > AVRCP_PDU_MTU - *pos) {
 942                 len = AVRCP_PDU_MTU - *pos;
 943                 *offset += len;
 944         } else {
 945                 *offset = 0;
 946         }
 947
 948         memcpy(&buf[*pos], value, len);
 949         *pos += len;
 950
 951         return attr_len;
 952 }
 953
 954 static GList *player_fill_media_attribute(struct avrcp_player *player,
 955                                         GList *attr_ids, uint8_t *buf,
 956                                         uint16_t *pos, uint16_t *offset)
 957 {
 958         struct media_attribute_header {
 959                 uint32_t id;
 960                 uint16_t charset;
 961                 uint16_t len;
 962         } *hdr = NULL;
 963         GList *l;
 964
 965         for (l = attr_ids; l != NULL; l = g_list_delete_link(l, l)) {
 966                 uint32_t attr = GPOINTER_TO_UINT(l->data);
 967                 uint16_t attr_len;
 968
 969                 if (*offset == 0) {
 970                         if (*pos + sizeof(*hdr) >= AVRCP_PDU_MTU)
 971                                 break;
 972
 973                         hdr = (void *) &buf[*pos];
 974                         hdr->id = htonl(attr);
 975                         /* Always use UTF-8 */
 976                         hdr->charset = htons(AVRCP_CHARSET_UTF8);
 977                         *pos += sizeof(*hdr);
 978                 }
 979
 980                 attr_len = player_write_media_attribute(player, attr, buf,
 981                                                                 pos, offset);
 982
 983                 if (hdr != NULL)
 984                         hdr->len = htons(attr_len);
 985
 986                 if (*offset > 0)
 987                         break;
 988         }
 989
 990         return l;
 991 }
 992
 993 static struct pending_pdu *pending_pdu_new(uint8_t pdu_id, GList *attr_ids,
 994                                                         unsigned int offset)
 995 {
 996         struct pending_pdu *pending = g_new(struct pending_pdu, 1);
 997
 998         pending->pdu_id = pdu_id;
 999         pending->attr_ids = attr_ids;
1000         pending->offset = offset;
1001
1002         return pending;
1003 }
1004
1005 static gboolean session_abort_pending_pdu(struct avrcp *session)
1006 {
1007         if (session->pending_pdu == NULL)
1008                 return FALSE;
1009
1010         g_list_free(session->pending_pdu->attr_ids);
1011         g_free(session->pending_pdu);
1012         session->pending_pdu = NULL;
1013
1014         return TRUE;
1015 }
1016
1017 static const char *attrval_to_str(uint8_t attr, uint8_t value)
1018 {
1019         switch (attr) {
1020         case AVRCP_ATTRIBUTE_EQUALIZER:
1021                 switch (value) {
1022                 case AVRCP_EQUALIZER_ON:
1023                         return "on";
1024                 case AVRCP_EQUALIZER_OFF:
1025                         return "off";
1026                 }
1027
1028                 break;
1029         case AVRCP_ATTRIBUTE_REPEAT_MODE:
1030                 switch (value) {
1031                 case AVRCP_REPEAT_MODE_OFF:
1032                         return "off";
1033                 case AVRCP_REPEAT_MODE_SINGLE:
1034                         return "singletrack";
1035                 case AVRCP_REPEAT_MODE_ALL:
1036                         return "alltracks";
1037 #ifndef __TIZEN_PATCH__
1038                 case AVRCP_REPEAT_MODE_GROUP:
1039                         return "group";
1040 #endif
1041                 }
1042
1043                 break;
1044         /* Shuffle and scan have the same values */
1045         case AVRCP_ATTRIBUTE_SHUFFLE:
1046         case AVRCP_ATTRIBUTE_SCAN:
1047                 switch (value) {
1048                 case AVRCP_SCAN_OFF:
1049                         return "off";
1050                 case AVRCP_SCAN_ALL:
1051                         return "alltracks";
1052 #ifndef __TIZEN_PATCH__
1053                 case AVRCP_SCAN_GROUP:
1054                         return "group";
1055 #endif
1056                 }
1057
1058                 break;
1059         }
1060
1061         return NULL;
1062 }
1063
1064 static int player_set_setting(struct avrcp_player *player, uint8_t id,
1065                                                                 uint8_t val)
1066 {
1067         const char *key, *value;
1068
1069         key = attr_to_str(id);
1070         if (key == NULL)
1071                 return -EINVAL;
1072
1073         value = attrval_to_str(id, val);
1074         if (value == NULL)
1075                 return -EINVAL;
1076
1077         if (player == NULL)
1078                 return -ENOENT;
1079
1080         return player->cb->set_setting(key, value, player->user_data);
1081 }
1082
1083 static uint8_t avrcp_handle_get_capabilities(struct avrcp *session,
1084                                                 struct avrcp_header *pdu,
1085                                                 uint8_t transaction)
1086 {
1087         uint16_t len = ntohs(pdu->params_len);
1088         unsigned int i;
1089
1090         if (len != 1)
1091                 goto err;
1092
1093         DBG("id=%u", pdu->params[0]);
1094
1095         switch (pdu->params[0]) {
1096         case CAP_COMPANY_ID:
1097                 for (i = 0; i < G_N_ELEMENTS(company_ids); i++) {
1098                         set_company_id(&pdu->params[2 + i * 3],
1099                                                         company_ids[i]);
1100                 }
1101
1102                 pdu->params_len = htons(2 + (3 * G_N_ELEMENTS(company_ids)));
1103                 pdu->params[1] = G_N_ELEMENTS(company_ids);
1104
1105                 return AVC_CTYPE_STABLE;
1106         case CAP_EVENTS_SUPPORTED:
1107                 pdu->params[1] = 0;
1108                 for (i = 1; i <= AVRCP_EVENT_LAST; i++) {
1109                         if (session->supported_events & (1 << i)) {
1110                                 pdu->params[1]++;
1111                                 pdu->params[pdu->params[1] + 1] = i;
1112                         }
1113                 }
1114
1115                 pdu->params_len = htons(2 + pdu->params[1]);
1116                 return AVC_CTYPE_STABLE;
1117         }
1118
1119 err:
1120         pdu->params_len = htons(1);
1121         pdu->params[0] = AVRCP_STATUS_INVALID_PARAM;
1122
1123         return AVC_CTYPE_REJECTED;
1124 }
1125
1126 static struct avrcp_player *target_get_player(struct avrcp *session)
1127 {
1128         if (!session->target)
1129                 return NULL;
1130
1131         return session->target->player;
1132 }
1133
1134 static uint8_t avrcp_handle_list_player_attributes(struct avrcp *session,
1135                                                 struct avrcp_header *pdu,
1136                                                 uint8_t transaction)
1137 {
1138         struct avrcp_player *player = target_get_player(session);
1139         uint16_t len = ntohs(pdu->params_len);
1140         unsigned int i;
1141
1142         if (len != 0) {
1143                 pdu->params_len = htons(1);
1144                 pdu->params[0] = AVRCP_STATUS_INVALID_PARAM;
1145                 return AVC_CTYPE_REJECTED;
1146         }
1147
1148         if (!player)
1149                 goto done;
1150
1151         for (i = 1; i <= AVRCP_ATTRIBUTE_SCAN; i++) {
1152                 if (player_get_setting(player, i) < 0)
1153                         continue;
1154
1155                 len++;
1156                 pdu->params[len] = i;
1157         }
1158
1159 done:
1160         pdu->params[0] = len;
1161         pdu->params_len = htons(len + 1);
1162
1163         return AVC_CTYPE_STABLE;
1164 }
1165
1166 static uint8_t avrcp_handle_list_player_values(struct avrcp *session,
1167                                                 struct avrcp_header *pdu,
1168                                                 uint8_t transaction)
1169 {
1170         struct avrcp_player *player = target_get_player(session);
1171         uint16_t len = ntohs(pdu->params_len);
1172         unsigned int i;
1173
1174         if (len != 1)
1175                 goto err;
1176
1177         if (player_get_setting(player, pdu->params[0]) < 0)
1178                 goto err;
1179
1180         len = attr_get_max_val(pdu->params[0]);
1181
1182         for (i = 1; i <= len; i++)
1183                 pdu->params[i] = i;
1184
1185         pdu->params[0] = len;
1186         pdu->params_len = htons(len + 1);
1187
1188         return AVC_CTYPE_STABLE;
1189
1190 err:
1191         pdu->params_len = htons(1);
1192         pdu->params[0] = AVRCP_STATUS_INVALID_PARAM;
1193         return AVC_CTYPE_REJECTED;
1194 }
1195
1196 static uint32_t str_to_metadata(const char *str)
1197 {
1198         if (strcasecmp(str, "Title") == 0)
1199                 return AVRCP_MEDIA_ATTRIBUTE_TITLE;
1200         else if (strcasecmp(str, "Artist") == 0)
1201                 return AVRCP_MEDIA_ATTRIBUTE_ARTIST;
1202         else if (strcasecmp(str, "Album") == 0)
1203                 return AVRCP_MEDIA_ATTRIBUTE_ALBUM;
1204         else if (strcasecmp(str, "Genre") == 0)
1205                 return AVRCP_MEDIA_ATTRIBUTE_GENRE;
1206         else if (strcasecmp(str, "TrackNumber") == 0)
1207                 return AVRCP_MEDIA_ATTRIBUTE_TRACK;
1208         else if (strcasecmp(str, "NumberOfTracks") == 0)
1209                 return AVRCP_MEDIA_ATTRIBUTE_N_TRACKS;
1210         else if (strcasecmp(str, "Duration") == 0)
1211                 return AVRCP_MEDIA_ATTRIBUTE_DURATION;
1212
1213         return 0;
1214 }
1215
1216 static GList *player_list_metadata(struct avrcp_player *player)
1217 {
1218         GList *l, *attrs = NULL;
1219
1220         if (player == NULL)
1221                 return g_list_prepend(NULL,
1222                                 GUINT_TO_POINTER(AVRCP_MEDIA_ATTRIBUTE_TITLE));
1223
1224         l = player->cb->list_metadata(player->user_data);
1225         for (; l; l = l->next) {
1226                 const char *key = l->data;
1227
1228                 attrs = g_list_append(attrs,
1229                                         GUINT_TO_POINTER(str_to_metadata(key)));
1230         }
1231
1232         return attrs;
1233 }
1234
1235 static uint8_t avrcp_handle_get_element_attributes(struct avrcp *session,
1236                                                 struct avrcp_header *pdu,
1237                                                 uint8_t transaction)
1238 {
1239         struct avrcp_player *player = target_get_player(session);
1240         uint16_t len = ntohs(pdu->params_len);
1241         uint64_t identifier = get_le64(&pdu->params[0]);
1242         uint16_t pos;
1243         uint8_t nattr;
1244         GList *attr_ids;
1245         uint16_t offset;
1246
1247         if (len < 9 || identifier != 0)
1248                 goto err;
1249
1250         nattr = pdu->params[8];
1251
1252         if (len < nattr * sizeof(uint32_t) + 1)
1253                 goto err;
1254
1255         if (!nattr) {
1256                 /*
1257                  * Return all available information, at least
1258                  * title must be returned if there's a track selected.
1259                  */
1260                 attr_ids = player_list_metadata(player);
1261                 len = g_list_length(attr_ids);
1262         } else {
1263                 unsigned int i;
1264                 for (i = 0, len = 0, attr_ids = NULL; i < nattr; i++) {
1265                         uint32_t id;
1266
1267                         id = get_be32(&pdu->params[9] + (i * sizeof(id)));
1268
1269                         /* Don't add invalid attributes */
1270                         if (id == AVRCP_MEDIA_ATTRIBUTE_ILLEGAL ||
1271                                         id > AVRCP_MEDIA_ATTRIBUTE_LAST)
1272                                 continue;
1273
1274                         len++;
1275                         attr_ids = g_list_prepend(attr_ids,
1276                                                         GUINT_TO_POINTER(id));
1277                 }
1278
1279                 attr_ids = g_list_reverse(attr_ids);
1280         }
1281
1282         if (!len)
1283                 goto err;
1284
1285         session_abort_pending_pdu(session);
1286         pos = 1;
1287         offset = 0;
1288         attr_ids = player_fill_media_attribute(player, attr_ids, pdu->params,
1289                                                                 &pos, &offset);
1290
1291         if (attr_ids != NULL) {
1292                 session->pending_pdu = pending_pdu_new(pdu->pdu_id, attr_ids,
1293                                                                 offset);
1294                 pdu->packet_type = AVRCP_PACKET_TYPE_START;
1295         }
1296
1297         pdu->params[0] = len;
1298         pdu->params_len = htons(pos);
1299
1300         return AVC_CTYPE_STABLE;
1301 err:
1302         pdu->params_len = htons(1);
1303         pdu->params[0] = AVRCP_STATUS_INVALID_PARAM;
1304         return AVC_CTYPE_REJECTED;
1305 }
1306
1307 static uint8_t avrcp_handle_get_current_player_value(struct avrcp *session,
1308                                                 struct avrcp_header *pdu,
1309                                                 uint8_t transaction)
1310 {
1311         struct avrcp_player *player = target_get_player(session);
1312         uint16_t len = ntohs(pdu->params_len);
1313         uint8_t *settings;
1314         unsigned int i;
1315
1316         if (len <= 1 || pdu->params[0] != len - 1)
1317                 goto err;
1318
1319         /*
1320          * Save a copy of requested settings because we can override them
1321          * while responding
1322          */
1323         settings = g_memdup(&pdu->params[1], pdu->params[0]);
1324         len = 0;
1325
1326         /*
1327          * From sec. 5.7 of AVRCP 1.3 spec, we should igore non-existent IDs
1328          * and send a response with the existent ones. Only if all IDs are
1329          * non-existent we should send an error.
1330          */
1331         for (i = 0; i < pdu->params[0]; i++) {
1332                 int val;
1333
1334                 if (settings[i] < AVRCP_ATTRIBUTE_EQUALIZER ||
1335                                         settings[i] > AVRCP_ATTRIBUTE_SCAN) {
1336                         DBG("Ignoring %u", settings[i]);
1337                         continue;
1338                 }
1339
1340                 val = player_get_setting(player, settings[i]);
1341                 if (val < 0)
1342                         continue;
1343
1344                 pdu->params[++len] = settings[i];
1345                 pdu->params[++len] = val;
1346         }
1347
1348         g_free(settings);
1349
1350         if (len) {
1351                 pdu->params[0] = len / 2;
1352                 pdu->params_len = htons(len + 1);
1353
1354                 return AVC_CTYPE_STABLE;
1355         }
1356
1357         error("No valid attributes in request");
1358
1359 err:
1360         pdu->params_len = htons(1);
1361         pdu->params[0] = AVRCP_STATUS_INVALID_PARAM;
1362
1363         return AVC_CTYPE_REJECTED;
1364 }
1365
1366 static uint8_t avrcp_handle_set_player_value(struct avrcp *session,
1367                                                 struct avrcp_header *pdu,
1368                                                 uint8_t transaction)
1369 {
1370         struct avrcp_player *player = target_get_player(session);
1371         uint16_t len = ntohs(pdu->params_len);
1372         unsigned int i;
1373         uint8_t *param;
1374
1375         if (len < 3 || len > 2 * pdu->params[0] + 1U || player == NULL)
1376                 goto err;
1377
1378         /*
1379          * From sec. 5.7 of AVRCP 1.3 spec, we should igore non-existent IDs
1380          * and set the existent ones. Sec. 5.2.4 is not clear however how to
1381          * indicate that a certain ID was not accepted. If at least one
1382          * attribute is valid, we respond with no parameters. Otherwise an
1383          * AVRCP_STATUS_INVALID_PARAM is sent.
1384          */
1385         for (len = 0, i = 0, param = &pdu->params[1]; i < pdu->params[0];
1386                                                         i++, param += 2) {
1387                 if (player_set_setting(player, param[0], param[1]) < 0)
1388                         continue;
1389
1390                 len++;
1391         }
1392
1393         if (len) {
1394                 pdu->params_len = 0;
1395
1396                 return AVC_CTYPE_ACCEPTED;
1397         }
1398
1399 err:
1400         pdu->params_len = htons(1);
1401         pdu->params[0] = AVRCP_STATUS_INVALID_PARAM;
1402         return AVC_CTYPE_REJECTED;
1403 }
1404
1405 static uint8_t avrcp_handle_displayable_charset(struct avrcp *session,
1406                                                 struct avrcp_header *pdu,
1407                                                 uint8_t transaction)
1408 {
1409         uint16_t len = ntohs(pdu->params_len);
1410
1411         if (len < 3) {
1412                 pdu->params_len = htons(1);
1413                 pdu->params[0] = AVRCP_STATUS_INVALID_PARAM;
1414                 return AVC_CTYPE_REJECTED;
1415         }
1416
1417         /*
1418          * We acknowledge the commands, but we always use UTF-8 for
1419          * encoding since CT is obliged to support it.
1420          */
1421         pdu->params_len = 0;
1422         return AVC_CTYPE_STABLE;
1423 }
1424
1425 static uint8_t avrcp_handle_ct_battery_status(struct avrcp *session,
1426                                                 struct avrcp_header *pdu,
1427                                                 uint8_t transaction)
1428 {
1429         uint16_t len = ntohs(pdu->params_len);
1430         const char *valstr;
1431
1432         if (len != 1)
1433                 goto err;
1434
1435         valstr = battery_status_to_str(pdu->params[0]);
1436         if (valstr == NULL)
1437                 goto err;
1438
1439         pdu->params_len = 0;
1440
1441         return AVC_CTYPE_STABLE;
1442
1443 err:
1444         pdu->params_len = htons(1);
1445         pdu->params[0] = AVRCP_STATUS_INVALID_PARAM;
1446         return AVC_CTYPE_REJECTED;
1447 }
1448
1449 static uint32_t player_get_position(struct avrcp_player *player)
1450 {
1451         if (player == NULL)
1452                 return 0;
1453
1454         return player->cb->get_position(player->user_data);
1455 }
1456
1457 static uint32_t player_get_duration(struct avrcp_player *player)
1458 {
1459         uint32_t num;
1460
1461         if (player == NULL)
1462                 return UINT32_MAX;
1463
1464         num = player->cb->get_duration(player->user_data);
1465         if (num == 0)
1466                 return UINT32_MAX;
1467
1468         return num;
1469 }
1470
1471 static uint8_t player_get_status(struct avrcp_player *player)
1472 {
1473         const char *value;
1474
1475         if (player == NULL)
1476                 return AVRCP_PLAY_STATUS_STOPPED;
1477
1478         value = player->cb->get_status(player->user_data);
1479         if (value == NULL)
1480                 return AVRCP_PLAY_STATUS_STOPPED;
1481
1482         return play_status_to_val(value);
1483 }
1484
1485 static uint16_t player_get_id(struct avrcp_player *player)
1486 {
1487         if (player == NULL)
1488                 return 0x0000;
1489
1490         return player->id;
1491 }
1492
1493 static uint16_t player_get_uid_counter(struct avrcp_player *player)
1494 {
1495         if (player == NULL)
1496                 return 0x0000;
1497
1498         return player->uid_counter;
1499 }
1500
1501 static uint8_t avrcp_handle_get_play_status(struct avrcp *session,
1502                                                 struct avrcp_header *pdu,
1503                                                 uint8_t transaction)
1504 {
1505         struct avrcp_player *player = target_get_player(session);
1506         uint16_t len = ntohs(pdu->params_len);
1507         uint32_t position;
1508         uint32_t duration;
1509
1510         if (len != 0) {
1511                 pdu->params_len = htons(1);
1512                 pdu->params[0] = AVRCP_STATUS_INVALID_PARAM;
1513                 return AVC_CTYPE_REJECTED;
1514         }
1515
1516         position = player_get_position(player);
1517         duration = player_get_duration(player);
1518
1519         position = htonl(position);
1520         duration = htonl(duration);
1521
1522         memcpy(&pdu->params[0], &duration, 4);
1523         memcpy(&pdu->params[4], &position, 4);
1524         pdu->params[8] = player_get_status(player);
1525
1526         pdu->params_len = htons(9);
1527
1528         return AVC_CTYPE_STABLE;
1529 }
1530
1531 static uint64_t player_get_uid(struct avrcp_player *player)
1532 {
1533         if (player == NULL)
1534                 return UINT64_MAX;
1535
1536         return player->cb->get_uid(player->user_data);
1537 }
1538
1539 static GList *player_list_settings(struct avrcp_player *player)
1540 {
1541         if (player == NULL)
1542                 return NULL;
1543
1544         return player->cb->list_settings(player->user_data);
1545 }
1546
1547 #ifdef __TIZEN_PATCH__
1548 static uint32_t player_get_playback_position(struct avrcp_player *player)
1549 {
1550         if (player == NULL)
1551                 return UINT32_MAX;
1552
1553         return player->cb->get_position(player->user_data);
1554 }
1555 #endif
1556
1557 static bool avrcp_handle_play(struct avrcp *session)
1558 {
1559         struct avrcp_player *player = target_get_player(session);
1560
1561         if (player == NULL)
1562                 return false;
1563
1564         return player->cb->play(player->user_data);
1565 }
1566
1567 static bool avrcp_handle_stop(struct avrcp *session)
1568 {
1569         struct avrcp_player *player = target_get_player(session);
1570
1571         if (player == NULL)
1572                 return false;
1573
1574         return player->cb->stop(player->user_data);
1575 }
1576
1577 static bool avrcp_handle_pause(struct avrcp *session)
1578 {
1579         struct avrcp_player *player = target_get_player(session);
1580
1581         if (player == NULL)
1582                 return false;
1583
1584         return player->cb->pause(player->user_data);
1585 }
1586
1587 static bool avrcp_handle_next(struct avrcp *session)
1588 {
1589         struct avrcp_player *player = target_get_player(session);
1590
1591         if (player == NULL)
1592                 return false;
1593
1594         return player->cb->next(player->user_data);
1595 }
1596
1597 static bool avrcp_handle_previous(struct avrcp *session)
1598 {
1599         struct avrcp_player *player = target_get_player(session);
1600
1601         if (player == NULL)
1602                 return false;
1603
1604         return player->cb->previous(player->user_data);
1605 }
1606
1607 static const struct passthrough_handler passthrough_handlers[] = {
1608                 { AVC_PLAY, avrcp_handle_play },
1609                 { AVC_STOP, avrcp_handle_stop },
1610                 { AVC_PAUSE, avrcp_handle_pause },
1611                 { AVC_FORWARD, avrcp_handle_next },
1612                 { AVC_BACKWARD, avrcp_handle_previous },
1613                 { },
1614 };
1615
1616 static bool handle_passthrough(struct avctp *conn, uint8_t op, bool pressed,
1617                                                         void *user_data)
1618 {
1619         struct avrcp *session = user_data;
1620         const struct passthrough_handler *handler;
1621
1622         for (handler = session->passthrough_handlers; handler->func;
1623                                                                 handler++) {
1624                 if (handler->op == op)
1625                         break;
1626         }
1627
1628         if (handler->func == NULL)
1629                 return false;
1630
1631         /* Do not trigger handler on release */
1632         if (!pressed)
1633                 return true;
1634
1635         return handler->func(session);
1636 }
1637
1638 #ifdef __TIZEN_PATCH__
1639 void avrcp_stop_position_timer(void)
1640 {
1641         if (pos_timer_id > 0) {
1642                 DBG("Removing position timer id");
1643                 g_source_remove(pos_timer_id);
1644                 pos_timer_id = 0;
1645         }
1646 }
1647 gboolean send_playback_position_event(gpointer user_data)
1648 {
1649         struct avrcp_player *player = user_data;
1650         uint32_t playback_position;
1651         uint8_t play_status;
1652
1653         play_status = player_get_status(player);
1654         if (play_status != AVRCP_PLAY_STATUS_PLAYING)
1655                 return FALSE;
1656
1657         playback_position = player_get_playback_position(player);
1658         pos_timer_id = 0;
1659         avrcp_player_event(player, AVRCP_EVENT_PLAYBACK_POS_CHANGED,
1660                                                 &playback_position);
1661         return FALSE;
1662 }
1663 #endif
1664
1665 static uint8_t avrcp_handle_register_notification(struct avrcp *session,
1666                                                 struct avrcp_header *pdu,
1667                                                 uint8_t transaction)
1668 {
1669         struct avrcp_player *player = target_get_player(session);
1670         struct btd_device *dev = session->dev;
1671         uint16_t len = ntohs(pdu->params_len);
1672         uint64_t uid;
1673 #ifdef __TIZEN_PATCH__
1674         uint32_t playback_interval;
1675         uint32_t playback_position;
1676         uint8_t play_status;
1677 #endif
1678         GList *settings;
1679
1680         /*
1681          * 1 byte for EventID, 4 bytes for Playback interval but the latest
1682          * one is applicable only for EVENT_PLAYBACK_POS_CHANGED. See AVRCP
1683          * 1.3 spec, section 5.4.2.
1684          */
1685         if (len != 5)
1686                 goto err;
1687
1688         /* Check if event is supported otherwise reject */
1689         if (!(session->supported_events & (1 << pdu->params[0])))
1690                 goto err;
1691
1692         switch (pdu->params[0]) {
1693         case AVRCP_EVENT_STATUS_CHANGED:
1694                 len = 2;
1695                 pdu->params[1] = player_get_status(player);
1696
1697                 break;
1698         case AVRCP_EVENT_TRACK_CHANGED:
1699                 len = 9;
1700                 uid = player_get_uid(player);
1701                 memcpy(&pdu->params[1], &uid, sizeof(uint64_t));
1702
1703                 break;
1704         case AVRCP_EVENT_TRACK_REACHED_END:
1705         case AVRCP_EVENT_TRACK_REACHED_START:
1706                 len = 1;
1707                 break;
1708         case AVRCP_EVENT_SETTINGS_CHANGED:
1709                 len = 1;
1710                 settings = player_list_settings(player);
1711
1712                 pdu->params[len++] = g_list_length(settings);
1713                 for (; settings; settings = settings->next) {
1714                         const char *key = settings->data;
1715                         int attr;
1716                         int val;
1717
1718                         attr = attr_to_val(key);
1719                         if (attr < 0)
1720                                 continue;
1721
1722                         val = player_get_setting(player, attr);
1723                         if (val < 0)
1724                                 continue;
1725
1726                         pdu->params[len++] = attr;
1727                         pdu->params[len++] = val;
1728                 }
1729
1730                 g_list_free(settings);
1731
1732                 break;
1733         case AVRCP_EVENT_ADDRESSED_PLAYER_CHANGED:
1734                 len = 5;
1735                 bt_put_be16(player_get_id(player), &pdu->params[1]);
1736                 bt_put_be16(player_get_uid_counter(player), &pdu->params[3]);
1737                 break;
1738         case AVRCP_EVENT_AVAILABLE_PLAYERS_CHANGED:
1739                 len = 1;
1740                 break;
1741         case AVRCP_EVENT_VOLUME_CHANGED:
1742                 pdu->params[1] = media_transport_get_device_volume(dev);
1743                 if (pdu->params[1] > 127)
1744                         goto err;
1745
1746                 len = 2;
1747
1748                 break;
1749 #ifdef __TIZEN_PATCH__
1750         case AVRCP_EVENT_PLAYBACK_POS_CHANGED:
1751                 len = 5;
1752
1753                 /* time interval in seconds at which the change in playback position
1754                 shall be notified */
1755                 memcpy(&playback_interval, &pdu->params[1], sizeof(uint32_t));
1756                 playback_interval = ((playback_interval>>24)&0xff) |
1757                                     ((playback_interval<<8)&0xff0000) |
1758                                     ((playback_interval>>8)&0xff00) |
1759                                     ((playback_interval<<24)&0xff000000);
1760
1761                 play_status = player_get_status(player);
1762
1763                 if (play_status != AVRCP_PLAY_STATUS_PLAYING) {
1764                         DBG("Play Pos Changed Event is skipped(%d)", play_status);
1765                 } else {
1766                         DBG("Playback interval : %d secs", playback_interval);
1767                         pos_timer_id = g_timeout_add_seconds(
1768                                         playback_interval,
1769                                         send_playback_position_event, player);
1770                 }
1771
1772                 /* retrieve current playback position for interim response */
1773                 playback_position = player_get_playback_position(player);
1774                 playback_position = (playback_position & 0x000000ff) << 24 |
1775                                     (playback_position & 0x0000ff00) << 8 |
1776                                     (playback_position & 0x00ff0000) >> 8 |
1777                                     (playback_position & 0xff000000) >> 24;
1778                 memcpy(&pdu->params[1], &playback_position, sizeof(uint32_t));
1779
1780                 break;
1781 #endif
1782
1783         default:
1784                 /* All other events are not supported yet */
1785                 goto err;
1786         }
1787
1788         /* Register event and save the transaction used */
1789         session->registered_events |= (1 << pdu->params[0]);
1790         session->transaction_events[pdu->params[0]] = transaction;
1791
1792         pdu->params_len = htons(len);
1793
1794         return AVC_CTYPE_INTERIM;
1795
1796 err:
1797         pdu->params_len = htons(1);
1798         pdu->params[0] = AVRCP_STATUS_INVALID_PARAM;
1799         return AVC_CTYPE_REJECTED;
1800 }
1801
1802 static uint8_t avrcp_handle_request_continuing(struct avrcp *session,
1803                                                 struct avrcp_header *pdu,
1804                                                 uint8_t transaction)
1805 {
1806         struct avrcp_player *player = target_get_player(session);
1807         uint16_t len = ntohs(pdu->params_len);
1808         struct pending_pdu *pending;
1809
1810         if (len != 1 || session->pending_pdu == NULL)
1811                 goto err;
1812
1813         pending = session->pending_pdu;
1814
1815         if (pending->pdu_id != pdu->params[0])
1816                 goto err;
1817
1818
1819         len = 0;
1820         pending->attr_ids = player_fill_media_attribute(player,
1821                                                         pending->attr_ids,
1822                                                         pdu->params, &len,
1823                                                         &pending->offset);
1824         pdu->pdu_id = pending->pdu_id;
1825
1826         if (pending->attr_ids == NULL) {
1827                 g_free(session->pending_pdu);
1828                 session->pending_pdu = NULL;
1829                 pdu->packet_type = AVRCP_PACKET_TYPE_END;
1830         } else {
1831                 pdu->packet_type = AVRCP_PACKET_TYPE_CONTINUING;
1832         }
1833
1834         pdu->params_len = htons(len);
1835
1836         return AVC_CTYPE_STABLE;
1837 err:
1838         pdu->params_len = htons(1);
1839         pdu->params[0] = AVRCP_STATUS_INVALID_PARAM;
1840         return AVC_CTYPE_REJECTED;
1841 }
1842
1843 static uint8_t avrcp_handle_abort_continuing(struct avrcp *session,
1844                                                 struct avrcp_header *pdu,
1845                                                 uint8_t transaction)
1846 {
1847         uint16_t len = ntohs(pdu->params_len);
1848         struct pending_pdu *pending;
1849
1850         if (len != 1 || session->pending_pdu == NULL)
1851                 goto err;
1852
1853         pending = session->pending_pdu;
1854
1855         if (pending->pdu_id != pdu->params[0])
1856                 goto err;
1857
1858         session_abort_pending_pdu(session);
1859         pdu->params_len = 0;
1860
1861         return AVC_CTYPE_ACCEPTED;
1862
1863 err:
1864         pdu->params_len = htons(1);
1865         pdu->params[0] = AVRCP_STATUS_INVALID_PARAM;
1866         return AVC_CTYPE_REJECTED;
1867 }
1868
1869 static uint8_t avrcp_handle_set_absolute_volume(struct avrcp *session,
1870                                                 struct avrcp_header *pdu,
1871                                                 uint8_t transaction)
1872 {
1873         uint16_t len = ntohs(pdu->params_len);
1874         uint8_t volume;
1875
1876         if (len != 1)
1877                 goto err;
1878
1879
1880         volume = pdu->params[0] & 0x7F;
1881
1882         media_transport_update_device_volume(session->dev, volume);
1883
1884         return AVC_CTYPE_ACCEPTED;
1885
1886 err:
1887         pdu->params_len = htons(1);
1888         pdu->params[0] = AVRCP_STATUS_INVALID_PARAM;
1889         return AVC_CTYPE_REJECTED;
1890 }
1891
1892 static struct avrcp_player *find_tg_player(struct avrcp *session, uint16_t id)
1893 {
1894         struct avrcp_server *server = session->server;
1895         GSList *l;
1896
1897         for (l = server->players; l; l = l->next) {
1898                 struct avrcp_player *player = l->data;
1899
1900                 if (player->id == id)
1901                         return player;
1902         }
1903
1904         return NULL;
1905 }
1906
1907 static gboolean notify_addressed_player_changed(gpointer user_data)
1908 {
1909         struct avrcp_player *player = user_data;
1910         uint8_t events[6] = { AVRCP_EVENT_STATUS_CHANGED,
1911                                         AVRCP_EVENT_TRACK_CHANGED,
1912                                         AVRCP_EVENT_TRACK_REACHED_START,
1913                                         AVRCP_EVENT_TRACK_REACHED_END,
1914                                         AVRCP_EVENT_SETTINGS_CHANGED,
1915                                         AVRCP_EVENT_PLAYBACK_POS_CHANGED
1916                                 };
1917         uint8_t i;
1918
1919         avrcp_player_event(player, AVRCP_EVENT_ADDRESSED_PLAYER_CHANGED, NULL);
1920
1921         /*
1922          * TG shall complete all player specific
1923          * notifications with AV/C C-Type REJECTED
1924          * with error code as Addressed Player Changed.
1925          */
1926         for (i = 0; i < sizeof(events); i++)
1927                 avrcp_player_event(player, events[i], NULL);
1928
1929         player->changed_id = 0;
1930
1931         return FALSE;
1932 }
1933
1934 static uint8_t avrcp_handle_set_addressed_player(struct avrcp *session,
1935                                                 struct avrcp_header *pdu,
1936                                                 uint8_t transaction)
1937 {
1938         struct avrcp_player *player;
1939         uint16_t len = ntohs(pdu->params_len);
1940         uint16_t player_id = 0;
1941         uint8_t status;
1942
1943         if (len < 1) {
1944                 status = AVRCP_STATUS_INVALID_PARAM;
1945                 goto err;
1946         }
1947
1948         player_id = bt_get_be16(&pdu->params[0]);
1949         player = find_tg_player(session, player_id);
1950         pdu->packet_type = AVRCP_PACKET_TYPE_SINGLE;
1951
1952         if (player) {
1953                 player->addressed = true;
1954                 status = AVRCP_STATUS_SUCCESS;
1955                 pdu->params_len = htons(len);
1956                 pdu->params[0] = status;
1957         } else {
1958                 status = AVRCP_STATUS_INVALID_PLAYER_ID;
1959                 goto err;
1960         }
1961
1962         /* Don't emit player changed immediately since PTS expect the
1963          * response of SetAddressedPlayer before the event.
1964          */
1965         player->changed_id = g_idle_add(notify_addressed_player_changed,
1966                                                                 player);
1967
1968         return AVC_CTYPE_ACCEPTED;
1969
1970 err:
1971         pdu->params_len = htons(sizeof(status));
1972         pdu->params[0] = status;
1973         return AVC_CTYPE_REJECTED;
1974 }
1975
1976 static const struct control_pdu_handler control_handlers[] = {
1977                 { AVRCP_GET_CAPABILITIES, AVC_CTYPE_STATUS,
1978                                         avrcp_handle_get_capabilities },
1979                 { AVRCP_LIST_PLAYER_ATTRIBUTES, AVC_CTYPE_STATUS,
1980                                         avrcp_handle_list_player_attributes },
1981                 { AVRCP_LIST_PLAYER_VALUES, AVC_CTYPE_STATUS,
1982                                         avrcp_handle_list_player_values },
1983                 { AVRCP_GET_ELEMENT_ATTRIBUTES, AVC_CTYPE_STATUS,
1984                                         avrcp_handle_get_element_attributes },
1985                 { AVRCP_GET_CURRENT_PLAYER_VALUE, AVC_CTYPE_STATUS,
1986                                         avrcp_handle_get_current_player_value },
1987                 { AVRCP_SET_PLAYER_VALUE, AVC_CTYPE_CONTROL,
1988                                         avrcp_handle_set_player_value },
1989                 { AVRCP_GET_PLAYER_ATTRIBUTE_TEXT, AVC_CTYPE_STATUS,
1990                                         NULL },
1991                 { AVRCP_GET_PLAYER_VALUE_TEXT, AVC_CTYPE_STATUS,
1992                                         NULL },
1993                 { AVRCP_DISPLAYABLE_CHARSET, AVC_CTYPE_STATUS,
1994                                         avrcp_handle_displayable_charset },
1995                 { AVRCP_CT_BATTERY_STATUS, AVC_CTYPE_STATUS,
1996                                         avrcp_handle_ct_battery_status },
1997                 { AVRCP_GET_PLAY_STATUS, AVC_CTYPE_STATUS,
1998                                         avrcp_handle_get_play_status },
1999                 { AVRCP_REGISTER_NOTIFICATION, AVC_CTYPE_NOTIFY,
2000                                         avrcp_handle_register_notification },
2001                 { AVRCP_SET_ABSOLUTE_VOLUME, AVC_CTYPE_CONTROL,
2002                                         avrcp_handle_set_absolute_volume },
2003                 { AVRCP_REQUEST_CONTINUING, AVC_CTYPE_CONTROL,
2004                                         avrcp_handle_request_continuing },
2005                 { AVRCP_ABORT_CONTINUING, AVC_CTYPE_CONTROL,
2006                                         avrcp_handle_abort_continuing },
2007                 { AVRCP_SET_ADDRESSED_PLAYER, AVC_CTYPE_CONTROL,
2008                                         avrcp_handle_set_addressed_player },
2009                 { },
2010 };
2011
2012 /* handle vendordep pdu inside an avctp packet */
2013 static size_t handle_vendordep_pdu(struct avctp *conn, uint8_t transaction,
2014                                         uint8_t *code, uint8_t *subunit,
2015                                         uint8_t *operands, size_t operand_count,
2016                                         void *user_data)
2017 {
2018         struct avrcp *session = user_data;
2019         const struct control_pdu_handler *handler;
2020         struct avrcp_header *pdu = (void *) operands;
2021         uint32_t company_id = get_company_id(pdu->company_id);
2022
2023         if (company_id != IEEEID_BTSIG) {
2024                 *code = AVC_CTYPE_NOT_IMPLEMENTED;
2025                 return 0;
2026         }
2027
2028         DBG("AVRCP PDU 0x%02X, company 0x%06X len 0x%04X",
2029                         pdu->pdu_id, company_id, ntohs(pdu->params_len));
2030
2031         pdu->packet_type = 0;
2032         pdu->rsvd = 0;
2033
2034         if (operand_count < AVRCP_HEADER_LENGTH) {
2035                 pdu->params[0] = AVRCP_STATUS_INVALID_COMMAND;
2036                 goto err_metadata;
2037         }
2038
2039         for (handler = session->control_handlers; handler->pdu_id; handler++) {
2040                 if (handler->pdu_id == pdu->pdu_id)
2041                         break;
2042         }
2043
2044         if (handler->pdu_id != pdu->pdu_id || handler->code != *code) {
2045                 pdu->params[0] = AVRCP_STATUS_INVALID_COMMAND;
2046                 goto err_metadata;
2047         }
2048
2049         if (!handler->func) {
2050                 pdu->params[0] = AVRCP_STATUS_INVALID_PARAM;
2051                 goto err_metadata;
2052         }
2053
2054         *code = handler->func(session, pdu, transaction);
2055
2056         if (*code != AVC_CTYPE_REJECTED &&
2057                                 pdu->pdu_id != AVRCP_GET_ELEMENT_ATTRIBUTES &&
2058                                 pdu->pdu_id != AVRCP_REQUEST_CONTINUING &&
2059                                 pdu->pdu_id != AVRCP_ABORT_CONTINUING)
2060                 session_abort_pending_pdu(session);
2061
2062         return AVRCP_HEADER_LENGTH + ntohs(pdu->params_len);
2063
2064 err_metadata:
2065         pdu->params_len = htons(1);
2066         *code = AVC_CTYPE_REJECTED;
2067
2068         return AVRCP_HEADER_LENGTH + 1;
2069 }
2070
2071 static void avrcp_handle_media_player_list(struct avrcp *session,
2072                                 struct avrcp_browsing_header *pdu,
2073                                 uint32_t start_item, uint32_t end_item)
2074 {
2075         struct avrcp_player *player = session->target->player;
2076         struct get_folder_items_rsp *rsp;
2077         const char *name = NULL;
2078         GSList *l;
2079
2080         rsp = (void *)pdu->params;
2081         rsp->status = AVRCP_STATUS_SUCCESS;
2082         rsp->uid_counter = htons(player_get_uid_counter(player));
2083         rsp->num_items = 0;
2084         pdu->param_len = sizeof(*rsp);
2085
2086         for (l = g_slist_nth(session->server->players, start_item);
2087                                         l; l = g_slist_next(l)) {
2088                 struct avrcp_player *player = l->data;
2089                 struct folder_item *folder;
2090                 struct player_item *item;
2091                 uint16_t namelen;
2092
2093                 if (rsp->num_items == (end_item - start_item) + 1)
2094                         break;
2095
2096                 folder = (void *)&pdu->params[pdu->param_len];
2097                 folder->type = 0x01; /* Media Player */
2098
2099                 pdu->param_len += sizeof(*folder);
2100
2101                 item = (void *)folder->data;
2102                 item->player_id = htons(player->id);
2103                 item->type = 0x01; /* Audio */
2104                 item->subtype = htonl(0x01); /* Audio Book */
2105                 item->status = player_get_status(player);
2106                 /* Assign Default Feature Bit Mask */
2107                 memcpy(&item->features, &features, sizeof(features));
2108
2109                 item->charset = htons(AVRCP_CHARSET_UTF8);
2110
2111                 name = player->cb->get_name(player->user_data);
2112                 namelen = strlen(name);
2113                 item->namelen = htons(namelen);
2114                 memcpy(item->name, name, namelen);
2115
2116                 folder->len = htons(sizeof(*item) + namelen);
2117                 pdu->param_len += sizeof(*item) + namelen;
2118                 rsp->num_items++;
2119         }
2120
2121         /* If no player could be found respond with an error */
2122         if (!rsp->num_items)
2123                 goto failed;
2124
2125         rsp->num_items = htons(rsp->num_items);
2126         pdu->param_len = htons(pdu->param_len);
2127
2128         return;
2129
2130 failed:
2131         pdu->params[0] = AVRCP_STATUS_OUT_OF_BOUNDS;
2132         pdu->param_len = htons(1);
2133 }
2134
2135 static void avrcp_handle_get_folder_items(struct avrcp *session,
2136                                 struct avrcp_browsing_header *pdu,
2137                                 uint8_t transaction)
2138 {
2139         uint32_t start_item = 0;
2140         uint32_t end_item = 0;
2141         uint8_t scope;
2142         uint8_t status = AVRCP_STATUS_SUCCESS;
2143
2144         if (ntohs(pdu->param_len) < 10) {
2145                 status = AVRCP_STATUS_INVALID_PARAM;
2146                 goto failed;
2147         }
2148
2149         scope = pdu->params[0];
2150         start_item = bt_get_be32(&pdu->params[1]);
2151         end_item = bt_get_be32(&pdu->params[5]);
2152
2153         DBG("scope 0x%02x start_item 0x%08x end_item 0x%08x", scope,
2154                                 start_item, end_item);
2155
2156         if (end_item < start_item) {
2157                 status = AVRCP_STATUS_INVALID_PARAM;
2158                 goto failed;
2159         }
2160
2161         switch (scope) {
2162         case AVRCP_SCOPE_MEDIA_PLAYER_LIST:
2163                 avrcp_handle_media_player_list(session, pdu,
2164                                                 start_item, end_item);
2165                 break;
2166         case AVRCP_SCOPE_MEDIA_PLAYER_VFS:
2167         case AVRCP_SCOPE_SEARCH:
2168         case AVRCP_SCOPE_NOW_PLAYING:
2169         default:
2170                 status = AVRCP_STATUS_INVALID_PARAM;
2171                 goto failed;
2172         }
2173
2174         return;
2175
2176 failed:
2177         pdu->params[0] = status;
2178         pdu->param_len = htons(1);
2179 }
2180
2181 static struct browsing_pdu_handler {
2182         uint8_t pdu_id;
2183         void (*func) (struct avrcp *session, struct avrcp_browsing_header *pdu,
2184                                                         uint8_t transaction);
2185 } browsing_handlers[] = {
2186                 { AVRCP_GET_FOLDER_ITEMS, avrcp_handle_get_folder_items },
2187                 { },
2188 };
2189
2190 size_t avrcp_browsing_general_reject(uint8_t *operands)
2191 {
2192         struct avrcp_browsing_header *pdu = (void *) operands;
2193         uint8_t status;
2194
2195         pdu->pdu_id = AVRCP_GENERAL_REJECT;
2196         status = AVRCP_STATUS_INVALID_COMMAND;
2197
2198         pdu->param_len = htons(sizeof(status));
2199         memcpy(pdu->params, &status, (sizeof(status)));
2200         return AVRCP_BROWSING_HEADER_LENGTH + sizeof(status);
2201 }
2202
2203 static size_t handle_browsing_pdu(struct avctp *conn,
2204                                         uint8_t transaction, uint8_t *operands,
2205                                         size_t operand_count, void *user_data)
2206 {
2207         struct avrcp *session = user_data;
2208         struct browsing_pdu_handler *handler;
2209         struct avrcp_browsing_header *pdu = (void *) operands;
2210
2211         DBG("AVRCP Browsing PDU 0x%02X, len 0x%04X", pdu->pdu_id,
2212                                                         ntohs(pdu->param_len));
2213
2214         for (handler = browsing_handlers; handler->pdu_id; handler++) {
2215                 if (handler->pdu_id == pdu->pdu_id)
2216                         goto done;
2217         }
2218
2219         return avrcp_browsing_general_reject(operands);
2220
2221 done:
2222         session->transaction = transaction;
2223         handler->func(session, pdu, transaction);
2224         return AVRCP_BROWSING_HEADER_LENGTH + ntohs(pdu->param_len);
2225 }
2226
2227 size_t avrcp_handle_vendor_reject(uint8_t *code, uint8_t *operands)
2228 {
2229         struct avrcp_header *pdu = (void *) operands;
2230         uint32_t company_id = get_company_id(pdu->company_id);
2231
2232         *code = AVC_CTYPE_REJECTED;
2233         pdu->params_len = htons(1);
2234         pdu->params[0] = AVRCP_STATUS_INTERNAL_ERROR;
2235
2236         DBG("rejecting AVRCP PDU 0x%02X, company 0x%06X len 0x%04X",
2237                         pdu->pdu_id, company_id, ntohs(pdu->params_len));
2238
2239         return AVRCP_HEADER_LENGTH + 1;
2240 }
2241
2242 static struct avrcp_server *find_server(GSList *list, struct btd_adapter *a)
2243 {
2244         for (; list; list = list->next) {
2245                 struct avrcp_server *server = list->data;
2246
2247                 if (server->adapter == a)
2248                         return server;
2249         }
2250
2251         return NULL;
2252 }
2253
2254 static const char *status_to_string(uint8_t status)
2255 {
2256         switch (status) {
2257         case AVRCP_PLAY_STATUS_STOPPED:
2258                 return "stopped";
2259         case AVRCP_PLAY_STATUS_PLAYING:
2260                 return "playing";
2261         case AVRCP_PLAY_STATUS_PAUSED:
2262                 return "paused";
2263         case AVRCP_PLAY_STATUS_FWD_SEEK:
2264                 return "forward-seek";
2265         case AVRCP_PLAY_STATUS_REV_SEEK:
2266                 return "reverse-seek";
2267         case AVRCP_PLAY_STATUS_ERROR:
2268                 return "error";
2269         default:
2270                 return NULL;
2271         }
2272 }
2273
2274 static gboolean avrcp_get_play_status_rsp(struct avctp *conn,
2275                                         uint8_t code, uint8_t subunit,
2276                                         uint8_t *operands, size_t operand_count,
2277                                         void *user_data)
2278 {
2279         struct avrcp *session = user_data;
2280         struct avrcp_player *player = session->controller->player;
2281         struct media_player *mp = player->user_data;
2282         struct avrcp_header *pdu = (void *) operands;
2283         uint32_t duration;
2284         uint32_t position;
2285         uint8_t status;
2286
2287         if (pdu == NULL || code == AVC_CTYPE_REJECTED ||
2288                                                 ntohs(pdu->params_len) != 9)
2289                 return FALSE;
2290
2291         memcpy(&duration, pdu->params, sizeof(uint32_t));
2292         duration = ntohl(duration);
2293         media_player_set_duration(mp, duration);
2294
2295         memcpy(&position, pdu->params + 4, sizeof(uint32_t));
2296         position = ntohl(position);
2297         media_player_set_position(mp, position);
2298
2299         memcpy(&status, pdu->params + 8, sizeof(uint8_t));
2300         media_player_set_status(mp, status_to_string(status));
2301
2302         return FALSE;
2303 }
2304
2305 static void avrcp_get_play_status(struct avrcp *session)
2306 {
2307         uint8_t buf[AVRCP_HEADER_LENGTH];
2308         struct avrcp_header *pdu = (void *) buf;
2309
2310         memset(buf, 0, sizeof(buf));
2311
2312         set_company_id(pdu->company_id, IEEEID_BTSIG);
2313         pdu->pdu_id = AVRCP_GET_PLAY_STATUS;
2314         pdu->packet_type = AVRCP_PACKET_TYPE_SINGLE;
2315
2316         avctp_send_vendordep_req(session->conn, AVC_CTYPE_STATUS,
2317                                         AVC_SUBUNIT_PANEL, buf, sizeof(buf),
2318                                         avrcp_get_play_status_rsp,
2319                                         session);
2320 }
2321
2322 static const char *status_to_str(uint8_t status)
2323 {
2324         switch (status) {
2325         case AVRCP_STATUS_INVALID_COMMAND:
2326                 return "Invalid Command";
2327         case AVRCP_STATUS_INVALID_PARAM:
2328                 return "Invalid Parameter";
2329         case AVRCP_STATUS_INTERNAL_ERROR:
2330                 return "Internal Error";
2331         case AVRCP_STATUS_SUCCESS:
2332                 return "Success";
2333         default:
2334                 return "Unknown";
2335         }
2336 }
2337
2338 static gboolean avrcp_player_value_rsp(struct avctp *conn,
2339                                         uint8_t code, uint8_t subunit,
2340                                         uint8_t *operands, size_t operand_count,
2341                                         void *user_data)
2342 {
2343         struct avrcp *session = user_data;
2344         struct avrcp_player *player = session->controller->player;
2345         struct media_player *mp = player->user_data;
2346         struct avrcp_header *pdu = (void *) operands;
2347         uint8_t count;
2348         int i;
2349
2350         if (pdu == NULL) {
2351                 media_player_set_setting(mp, "Error", "Timeout");
2352                 return FALSE;
2353         }
2354
2355         if (code == AVC_CTYPE_REJECTED) {
2356                 media_player_set_setting(mp, "Error",
2357                                         status_to_str(pdu->params[0]));
2358                 return FALSE;
2359         }
2360
2361         count = pdu->params[0];
2362
2363         if (pdu->params_len < count * 2)
2364                 return FALSE;
2365
2366         for (i = 1; count > 0; count--, i += 2) {
2367                 const char *key;
2368                 const char *value;
2369
2370                 key = attr_to_str(pdu->params[i]);
2371                 if (key == NULL)
2372                         continue;
2373
2374                 value = attrval_to_str(pdu->params[i], pdu->params[i + 1]);
2375                 if (value == NULL)
2376                         continue;
2377
2378                 media_player_set_setting(mp, key, value);
2379         }
2380
2381         return FALSE;
2382 }
2383
2384 static void avrcp_get_current_player_value(struct avrcp *session,
2385                                                 uint8_t *attrs, uint8_t count)
2386 {
2387         uint8_t buf[AVRCP_HEADER_LENGTH + AVRCP_ATTRIBUTE_LAST + 1];
2388         struct avrcp_header *pdu = (void *) buf;
2389         uint16_t length = AVRCP_HEADER_LENGTH + count + 1;
2390
2391         memset(buf, 0, sizeof(buf));
2392
2393         set_company_id(pdu->company_id, IEEEID_BTSIG);
2394         pdu->pdu_id = AVRCP_GET_CURRENT_PLAYER_VALUE;
2395         pdu->packet_type = AVRCP_PACKET_TYPE_SINGLE;
2396         pdu->params_len = htons(count + 1);
2397         pdu->params[0] = count;
2398
2399         memcpy(pdu->params + 1, attrs, count);
2400
2401         avctp_send_vendordep_req(session->conn, AVC_CTYPE_STATUS,
2402                                         AVC_SUBUNIT_PANEL, buf, length,
2403                                         avrcp_player_value_rsp, session);
2404 }
2405
2406 static gboolean avrcp_list_player_attributes_rsp(struct avctp *conn,
2407                                         uint8_t code, uint8_t subunit,
2408                                         uint8_t *operands, size_t operand_count,
2409                                         void *user_data)
2410 {
2411         uint8_t attrs[AVRCP_ATTRIBUTE_LAST];
2412         struct avrcp *session = user_data;
2413         struct avrcp_header *pdu = (void *) operands;
2414         uint8_t len, count = 0;
2415         int i;
2416
2417         if (code == AVC_CTYPE_REJECTED)
2418                 return FALSE;
2419
2420         len = pdu->params[0];
2421
2422         if (ntohs(pdu->params_len) < count) {
2423                 error("Invalid parameters");
2424                 return FALSE;
2425         }
2426
2427         for (i = 0; len > 0; len--, i++) {
2428                 /* Don't query invalid attributes */
2429                 if (pdu->params[i + 1] == AVRCP_ATTRIBUTE_ILEGAL ||
2430                                 pdu->params[i + 1] > AVRCP_ATTRIBUTE_LAST)
2431                         continue;
2432
2433                 attrs[count++] = pdu->params[i + 1];
2434         }
2435
2436         avrcp_get_current_player_value(session, attrs, count);
2437
2438         return FALSE;
2439 }
2440
2441 static void avrcp_list_player_attributes(struct avrcp *session)
2442 {
2443         uint8_t buf[AVRCP_HEADER_LENGTH];
2444         struct avrcp_header *pdu = (void *) buf;
2445
2446         memset(buf, 0, sizeof(buf));
2447
2448         set_company_id(pdu->company_id, IEEEID_BTSIG);
2449         pdu->pdu_id = AVRCP_LIST_PLAYER_ATTRIBUTES;
2450         pdu->packet_type = AVRCP_PACKET_TYPE_SINGLE;
2451
2452         avctp_send_vendordep_req(session->conn, AVC_CTYPE_STATUS,
2453                                         AVC_SUBUNIT_PANEL, buf, sizeof(buf),
2454                                         avrcp_list_player_attributes_rsp,
2455                                         session);
2456 }
2457
2458 static void avrcp_parse_attribute_list(struct avrcp_player *player,
2459                                         uint8_t *operands, uint8_t count)
2460 {
2461         struct media_player *mp = player->user_data;
2462         struct media_item *item;
2463         int i;
2464
2465         item = media_player_set_playlist_item(mp, player->uid);
2466
2467         for (i = 0; count > 0; count--) {
2468                 uint32_t id;
2469                 uint16_t charset, len;
2470
2471                 id = get_be32(&operands[i]);
2472                 i += sizeof(uint32_t);
2473
2474                 charset = get_be16(&operands[i]);
2475                 i += sizeof(uint16_t);
2476
2477                 len = get_be16(&operands[i]);
2478                 i += sizeof(uint16_t);
2479
2480                 if (charset == 106) {
2481                         const char *key = metadata_to_str(id);
2482
2483                         if (key != NULL)
2484                                 media_player_set_metadata(mp, item,
2485                                                         metadata_to_str(id),
2486                                                         &operands[i], len);
2487                 }
2488
2489                 i += len;
2490         }
2491 }
2492
2493 static gboolean avrcp_get_element_attributes_rsp(struct avctp *conn,
2494                                                 uint8_t code, uint8_t subunit,
2495                                                 uint8_t *operands,
2496                                                 size_t operand_count,
2497                                                 void *user_data)
2498 {
2499         struct avrcp *session = user_data;
2500         struct avrcp_player *player = session->controller->player;
2501         struct avrcp_header *pdu = (void *) operands;
2502         uint8_t count;
2503
2504         if (code == AVC_CTYPE_REJECTED)
2505                 return FALSE;
2506
2507         count = pdu->params[0];
2508
2509         if (ntohs(pdu->params_len) - 1 < count * 8) {
2510                 error("Invalid parameters");
2511                 return FALSE;
2512         }
2513
2514         avrcp_parse_attribute_list(player, &pdu->params[1], count);
2515
2516         avrcp_get_play_status(session);
2517
2518         return FALSE;
2519 }
2520
2521 static void avrcp_get_element_attributes(struct avrcp *session)
2522 {
2523         uint8_t buf[AVRCP_HEADER_LENGTH + 9];
2524         struct avrcp_header *pdu = (void *) buf;
2525         uint16_t length;
2526
2527         memset(buf, 0, sizeof(buf));
2528
2529         set_company_id(pdu->company_id, IEEEID_BTSIG);
2530         pdu->pdu_id = AVRCP_GET_ELEMENT_ATTRIBUTES;
2531         pdu->params_len = htons(9);
2532         pdu->packet_type = AVRCP_PACKET_TYPE_SINGLE;
2533
2534         length = AVRCP_HEADER_LENGTH + ntohs(pdu->params_len);
2535
2536         avctp_send_vendordep_req(session->conn, AVC_CTYPE_STATUS,
2537                                         AVC_SUBUNIT_PANEL, buf, length,
2538                                         avrcp_get_element_attributes_rsp,
2539                                         session);
2540 }
2541
2542 static const char *type_to_string(uint8_t type)
2543 {
2544         switch (type & 0x0F) {
2545         case 0x01:
2546                 return "Audio";
2547         case 0x02:
2548                 return "Video";
2549         case 0x03:
2550                 return "Audio, Video";
2551         case 0x04:
2552                 return "Audio Broadcasting";
2553         case 0x05:
2554                 return "Audio, Audio Broadcasting";
2555         case 0x06:
2556                 return "Video, Audio Broadcasting";
2557         case 0x07:
2558                 return "Audio, Video, Audio Broadcasting";
2559         case 0x08:
2560                 return "Video Broadcasting";
2561         case 0x09:
2562                 return "Audio, Video Broadcasting";
2563         case 0x0A:
2564                 return "Video, Video Broadcasting";
2565         case 0x0B:
2566                 return "Audio, Video, Video Broadcasting";
2567         case 0x0C:
2568                 return "Audio Broadcasting, Video Broadcasting";
2569         case 0x0D:
2570                 return "Audio, Audio Broadcasting, Video Broadcasting";
2571         case 0x0E:
2572                 return "Video, Audio Broadcasting, Video Broadcasting";
2573         case 0x0F:
2574                 return "Audio, Video, Audio Broadcasting, Video Broadcasting";
2575         }
2576
2577         return "None";
2578 }
2579
2580 static const char *subtype_to_string(uint32_t subtype)
2581 {
2582         switch (subtype & 0x03) {
2583         case 0x01:
2584                 return "Audio Book";
2585         case 0x02:
2586                 return "Podcast";
2587         case 0x03:
2588                 return "Audio Book, Podcast";
2589         }
2590
2591         return "None";
2592 }
2593
2594 static struct media_item *parse_media_element(struct avrcp *session,
2595                                         uint8_t *operands, uint16_t len)
2596 {
2597         struct avrcp_player *player;
2598         struct media_player *mp;
2599         struct media_item *item;
2600         uint16_t namelen;
2601         char name[255];
2602         uint64_t uid;
2603
2604         if (len < 13)
2605                 return NULL;
2606
2607         uid = get_be64(&operands[0]);
2608
2609         namelen = MIN(get_be16(&operands[11]), sizeof(name) - 1);
2610         if (namelen > 0) {
2611                 memcpy(name, &operands[13], namelen);
2612                 name[namelen] = '\0';
2613         }
2614
2615         player = session->controller->player;
2616         mp = player->user_data;
2617
2618         item = media_player_create_item(mp, name, PLAYER_ITEM_TYPE_AUDIO, uid);
2619         if (item == NULL)
2620                 return NULL;
2621
2622         media_item_set_playable(item, true);
2623
2624         return item;
2625 }
2626
2627 static struct media_item *parse_media_folder(struct avrcp *session,
2628                                         uint8_t *operands, uint16_t len)
2629 {
2630         struct avrcp_player *player = session->controller->player;
2631         struct media_player *mp = player->user_data;
2632         struct media_item *item;
2633         uint16_t namelen;
2634         char name[255];
2635         uint64_t uid;
2636         uint8_t type;
2637         uint8_t playable;
2638
2639         if (len < 12)
2640                 return NULL;
2641
2642         uid = get_be64(&operands[0]);
2643         type = operands[8];
2644         playable = operands[9];
2645
2646         namelen = MIN(get_be16(&operands[12]), sizeof(name) - 1);
2647         if (namelen > 0) {
2648                 memcpy(name, &operands[14], namelen);
2649                 name[namelen] = '\0';
2650         }
2651
2652         item = media_player_create_folder(mp, name, type, uid);
2653         if (!item)
2654                 return NULL;
2655
2656         media_item_set_playable(item, playable & 0x01);
2657
2658         return item;
2659 }
2660
2661 static void avrcp_list_items(struct avrcp *session, uint32_t start,
2662                                                                 uint32_t end);
2663 static gboolean avrcp_list_items_rsp(struct avctp *conn, uint8_t *operands,
2664                                         size_t operand_count, void *user_data)
2665 {
2666         struct avrcp_browsing_header *pdu = (void *) operands;
2667         struct avrcp *session = user_data;
2668         struct avrcp_player *player = session->controller->player;
2669         struct pending_list_items *p = player->p;
2670         uint16_t count;
2671         uint64_t items;
2672         size_t i;
2673         int err = 0;
2674
2675         if (pdu == NULL) {
2676                 err = -ETIMEDOUT;
2677                 goto done;
2678         }
2679
2680         /* AVRCP 1.5 - Page 76:
2681          * If the TG receives a GetFolderItems command for an empty folder then
2682          * the TG shall return the error (= Range Out of Bounds) in the status
2683          * field of the GetFolderItems response.
2684          */
2685         if (pdu->params[0] == AVRCP_STATUS_OUT_OF_BOUNDS)
2686                 goto done;
2687
2688         if (pdu->params[0] != AVRCP_STATUS_SUCCESS || operand_count < 5) {
2689                 err = -EINVAL;
2690                 goto done;
2691         }
2692
2693         count = get_be16(&operands[6]);
2694         if (count == 0)
2695                 goto done;
2696
2697         for (i = 8; count && i + 3 < operand_count; count--) {
2698                 struct media_item *item;
2699                 uint8_t type;
2700                 uint16_t len;
2701
2702                 type = operands[i++];
2703                 len = get_be16(&operands[i]);
2704                 i += 2;
2705
2706                 if (type != 0x03 && type != 0x02) {
2707                         i += len;
2708                         continue;
2709                 }
2710
2711                 if (i + len > operand_count) {
2712                         error("Invalid item length");
2713                         break;
2714                 }
2715
2716                 if (type == 0x03)
2717                         item = parse_media_element(session, &operands[i], len);
2718                 else
2719                         item = parse_media_folder(session, &operands[i], len);
2720
2721                 if (item) {
2722                         if (g_slist_find(p->items, item))
2723                                 goto done;
2724                         p->items = g_slist_append(p->items, item);
2725                 }
2726
2727                 i += len;
2728         }
2729
2730         items = g_slist_length(p->items);
2731
2732         DBG("start %u end %u items %" PRIu64 " total %" PRIu64 "", p->start,
2733                                                 p->end, items, p->total);
2734
2735         if (items < p->total) {
2736                 avrcp_list_items(session, p->start + items, p->end);
2737                 return FALSE;
2738         }
2739
2740 done:
2741         media_player_list_complete(player->user_data, p->items, err);
2742
2743         g_slist_free(p->items);
2744         g_free(p);
2745         player->p = NULL;
2746
2747         return FALSE;
2748 }
2749
2750 static void avrcp_list_items(struct avrcp *session, uint32_t start,
2751                                                                 uint32_t end)
2752 {
2753         uint8_t buf[AVRCP_BROWSING_HEADER_LENGTH + 10 +
2754                         AVRCP_MEDIA_ATTRIBUTE_LAST * sizeof(uint32_t)];
2755         struct avrcp_player *player = session->controller->player;
2756         struct avrcp_browsing_header *pdu = (void *) buf;
2757         uint16_t length = AVRCP_BROWSING_HEADER_LENGTH + 10;
2758         uint32_t attribute;
2759
2760         memset(buf, 0, sizeof(buf));
2761
2762         pdu->pdu_id = AVRCP_GET_FOLDER_ITEMS;
2763         pdu->param_len = htons(10 + sizeof(uint32_t));
2764
2765         pdu->params[0] = player->scope;
2766
2767         put_be32(start, &pdu->params[1]);
2768         put_be32(end, &pdu->params[5]);
2769
2770         pdu->params[9] = 1;
2771
2772         /* Only the title (0x01) is mandatory. This can be extended to
2773          * support AVRCP_MEDIA_ATTRIBUTE_* attributes */
2774         attribute = htonl(AVRCP_MEDIA_ATTRIBUTE_TITLE);
2775         memcpy(&pdu->params[10], &attribute, sizeof(uint32_t));
2776
2777         length += sizeof(uint32_t);
2778
2779         avctp_send_browsing_req(session->conn, buf, length,
2780                                         avrcp_list_items_rsp, session);
2781 }
2782
2783 static gboolean avrcp_change_path_rsp(struct avctp *conn,
2784                                         uint8_t *operands, size_t operand_count,
2785                                         void *user_data)
2786 {
2787         struct avrcp_browsing_header *pdu = (void *) operands;
2788         struct avrcp *session = user_data;
2789         struct avrcp_player *player = session->controller->player;
2790         struct media_player *mp = player->user_data;
2791         int ret;
2792
2793         if (pdu == NULL) {
2794                 ret = -ETIMEDOUT;
2795                 goto done;
2796         }
2797
2798         if (pdu->params[0] != AVRCP_STATUS_SUCCESS) {
2799                 ret = -EINVAL;
2800                 goto done;
2801         }
2802
2803         ret = get_be32(&pdu->params[1]);
2804
2805 done:
2806         if (ret < 0) {
2807                 g_free(player->change_path);
2808                 player->change_path = NULL;
2809         } else {
2810                 g_free(player->path);
2811                 player->path = player->change_path;
2812                 player->change_path = NULL;
2813         }
2814
2815         media_player_change_folder_complete(mp, player->path, ret);
2816
2817         return FALSE;
2818 }
2819
2820 static gboolean avrcp_set_browsed_player_rsp(struct avctp *conn,
2821                                                 uint8_t *operands,
2822                                                 size_t operand_count,
2823                                                 void *user_data)
2824 {
2825         struct avrcp *session = user_data;
2826         struct avrcp_player *player = session->controller->player;
2827         struct media_player *mp = player->user_data;
2828         struct avrcp_browsing_header *pdu = (void *) operands;
2829         uint32_t items;
2830         char **folders;
2831         uint8_t depth, count;
2832         size_t i;
2833
2834         if (pdu == NULL || pdu->params[0] != AVRCP_STATUS_SUCCESS ||
2835                                                         operand_count < 13)
2836                 return FALSE;
2837
2838         player->uid_counter = get_be16(&pdu->params[1]);
2839         player->browsed = true;
2840
2841         items = get_be32(&pdu->params[3]);
2842
2843         depth = pdu->params[9];
2844
2845         folders = g_new0(char *, depth + 2);
2846         folders[0] = g_strdup("/Filesystem");
2847
2848         for (i = 10, count = 1; count - 1 < depth && i < operand_count;
2849                                                                 count++) {
2850                 uint8_t len;
2851
2852                 len = pdu->params[i++];
2853
2854                 if (i + len > operand_count || len == 0) {
2855                         error("Invalid folder length");
2856                         break;
2857                 }
2858
2859                 folders[count] = g_memdup(&pdu->params[i], len);
2860                 i += len;
2861         }
2862
2863         player->path = g_build_pathv("/", folders);
2864         g_strfreev(folders);
2865
2866         media_player_set_folder(mp, player->path, items);
2867
2868         return FALSE;
2869 }
2870
2871 static void avrcp_set_browsed_player(struct avrcp *session,
2872                                                 struct avrcp_player *player)
2873 {
2874         uint8_t buf[AVRCP_BROWSING_HEADER_LENGTH + 2];
2875         struct avrcp_browsing_header *pdu = (void *) buf;
2876         uint16_t id;
2877
2878         memset(buf, 0, sizeof(buf));
2879
2880         pdu->pdu_id = AVRCP_SET_BROWSED_PLAYER;
2881         id = htons(player->id);
2882         memcpy(pdu->params, &id, 2);
2883         pdu->param_len = htons(2);
2884
2885         avctp_send_browsing_req(session->conn, buf, sizeof(buf),
2886                                 avrcp_set_browsed_player_rsp, session);
2887 }
2888
2889 static gboolean avrcp_get_item_attributes_rsp(struct avctp *conn,
2890                                                 uint8_t *operands,
2891                                                 size_t operand_count,
2892                                                 void *user_data)
2893 {
2894         struct avrcp *session = user_data;
2895         struct avrcp_player *player = session->controller->player;
2896         struct avrcp_browsing_header *pdu = (void *) operands;
2897         uint8_t count;
2898
2899         if (pdu == NULL) {
2900                 avrcp_get_element_attributes(session);
2901                 return FALSE;
2902         }
2903
2904         if (pdu->params[0] != AVRCP_STATUS_SUCCESS || operand_count < 4) {
2905                 avrcp_get_element_attributes(session);
2906                 return FALSE;
2907         }
2908
2909         count = pdu->params[1];
2910
2911         if (ntohs(pdu->param_len) - 1 < count * 8) {
2912                 error("Invalid parameters");
2913                 return FALSE;
2914         }
2915
2916         avrcp_parse_attribute_list(player, &pdu->params[2], count);
2917
2918         avrcp_get_play_status(session);
2919
2920         return FALSE;
2921 }
2922
2923 static void avrcp_get_item_attributes(struct avrcp *session, uint64_t uid)
2924 {
2925         struct avrcp_player *player = session->controller->player;
2926         uint8_t buf[AVRCP_BROWSING_HEADER_LENGTH + 12];
2927         struct avrcp_browsing_header *pdu = (void *) buf;
2928
2929         memset(buf, 0, sizeof(buf));
2930
2931         pdu->pdu_id = AVRCP_GET_ITEM_ATTRIBUTES;
2932         pdu->params[0] = 0x03;
2933         put_be64(uid, &pdu->params[1]);
2934         put_be16(player->uid_counter, &pdu->params[9]);
2935         pdu->param_len = htons(12);
2936
2937         avctp_send_browsing_req(session->conn, buf, sizeof(buf),
2938                                 avrcp_get_item_attributes_rsp, session);
2939 }
2940
2941 static void avrcp_player_parse_features(struct avrcp_player *player,
2942                                                         uint8_t *features)
2943 {
2944         struct media_player *mp = player->user_data;
2945
2946         player->features = g_memdup(features, 16);
2947
2948         if (features[7] & 0x08) {
2949                 media_player_set_browsable(mp, true);
2950                 media_player_create_folder(mp, "/Filesystem",
2951                                                 PLAYER_FOLDER_TYPE_MIXED, 0);
2952         }
2953
2954         if (features[7] & 0x10)
2955                 media_player_set_searchable(mp, true);
2956
2957         if (features[8] & 0x02) {
2958                 media_player_create_folder(mp, "/NowPlaying",
2959                                                 PLAYER_FOLDER_TYPE_MIXED, 0);
2960                 media_player_set_playlist(mp, "/NowPlaying");
2961         }
2962 }
2963
2964 static void avrcp_set_player_value(struct avrcp *session, uint8_t attr,
2965                                                                 uint8_t val)
2966 {
2967         uint8_t buf[AVRCP_HEADER_LENGTH + 3];
2968         struct avrcp_header *pdu = (void *) buf;
2969         uint8_t length;
2970
2971         memset(buf, 0, sizeof(buf));
2972
2973         set_company_id(pdu->company_id, IEEEID_BTSIG);
2974         pdu->pdu_id = AVRCP_SET_PLAYER_VALUE;
2975         pdu->packet_type = AVRCP_PACKET_TYPE_SINGLE;
2976         pdu->params[0] = 1;
2977         pdu->params[1] = attr;
2978         pdu->params[2] = val;
2979         pdu->params_len = htons(3);
2980
2981         length = AVRCP_HEADER_LENGTH + ntohs(pdu->params_len);
2982
2983         avctp_send_vendordep_req(session->conn, AVC_CTYPE_CONTROL,
2984                                         AVC_SUBUNIT_PANEL, buf, length,
2985                                         avrcp_player_value_rsp, session);
2986 }
2987
2988 static bool ct_set_setting(struct media_player *mp, const char *key,
2989                                         const char *value, void *user_data)
2990 {
2991         struct avrcp_player *player = user_data;
2992         int attr;
2993         int val;
2994         struct avrcp *session;
2995
2996         session = player->sessions->data;
2997         if (session == NULL)
2998                 return false;
2999
3000         if (session->controller->version < 0x0103)
3001                 return false;
3002
3003         attr = attr_to_val(key);
3004         if (attr < 0)
3005                 return false;
3006
3007         val = attrval_to_val(attr, value);
3008         if (val < 0)
3009                 return false;
3010
3011         avrcp_set_player_value(session, attr, val);
3012
3013         return true;
3014 }
3015
3016 static int ct_press(struct avrcp_player *player, uint8_t op)
3017 {
3018         int err;
3019         struct avrcp *session;
3020
3021         session = player->sessions->data;
3022         if (session == NULL)
3023                 return -ENOTCONN;
3024
3025         err = avctp_send_passthrough(session->conn, op);
3026         if (err < 0)
3027                 return err;
3028
3029         return 0;
3030 }
3031 #ifdef __TIZEN_PATCH__
3032 static int ct_release(struct avrcp_player *player, uint8_t op)
3033 {
3034         DBG("+");
3035         int err;
3036         struct avrcp *session;
3037
3038         session = player->sessions->data;
3039         if (session == NULL)
3040                 return -ENOTCONN;
3041
3042         err = avctp_send_release_passthrough(session->conn, op);
3043         if (err < 0)
3044                 return err;
3045
3046         DBG("-");
3047         return 0;
3048 }
3049 #endif
3050 static int ct_play(struct media_player *mp, void *user_data)
3051 {
3052         struct avrcp_player *player = user_data;
3053
3054         return ct_press(player, AVC_PLAY);
3055 }
3056
3057 static int ct_pause(struct media_player *mp, void *user_data)
3058 {
3059         struct avrcp_player *player = user_data;
3060
3061         return ct_press(player, AVC_PAUSE);
3062 }
3063
3064 static int ct_stop(struct media_player *mp, void *user_data)
3065 {
3066         struct avrcp_player *player = user_data;
3067
3068         return ct_press(player, AVC_STOP);
3069 }
3070
3071 static int ct_next(struct media_player *mp, void *user_data)
3072 {
3073         struct avrcp_player *player = user_data;
3074
3075         return ct_press(player, AVC_FORWARD);
3076 }
3077
3078 static int ct_previous(struct media_player *mp, void *user_data)
3079 {
3080         struct avrcp_player *player = user_data;
3081
3082         return ct_press(player, AVC_BACKWARD);
3083 }
3084 #ifdef __TIZEN_PATCH__
3085 static int ct_press_fast_forward(struct media_player *mp, void *user_data)
3086 {
3087         DBG("+");
3088         struct avrcp_player *player = user_data;
3089
3090         DBG("-");
3091         return ct_press(player, AVC_FAST_FORWARD);
3092 }
3093
3094 static int ct_release_fast_forward(struct media_player *mp, void *user_data)
3095 {
3096         DBG("+");
3097         struct avrcp_player *player = user_data;
3098
3099         DBG("-");
3100         return ct_release(player, AVC_FAST_FORWARD);
3101 }
3102
3103 static int ct_press_rewind(struct media_player *mp, void *user_data)
3104 {
3105         DBG("+");
3106         struct avrcp_player *player = user_data;
3107
3108         DBG("-");
3109         return ct_press(player, AVC_REWIND);
3110 }
3111
3112 static int ct_release_rewind(struct media_player *mp, void *user_data)
3113 {
3114         DBG("+");
3115         struct avrcp_player *player = user_data;
3116
3117         DBG("-");
3118         return ct_release(player, AVC_REWIND);
3119 }
3120 #else
3121 static int ct_fast_forward(struct media_player *mp, void *user_data)
3122 {
3123         struct avrcp_player *player = user_data;
3124
3125         return ct_press(player, AVC_FAST_FORWARD);
3126 }
3127
3128 static int ct_rewind(struct media_player *mp, void *user_data)
3129 {
3130         struct avrcp_player *player = user_data;
3131
3132         return ct_press(player, AVC_REWIND);
3133 }
3134 #endif
3135 static int ct_list_items(struct media_player *mp, const char *name,
3136                                 uint32_t start, uint32_t end, void *user_data)
3137 {
3138         struct avrcp_player *player = user_data;
3139         struct avrcp *session;
3140         struct pending_list_items *p;
3141
3142         if (player->p != NULL)
3143                 return -EBUSY;
3144
3145         session = player->sessions->data;
3146
3147         if (g_str_has_prefix(name, "/NowPlaying"))
3148                 player->scope = 0x03;
3149         else if (g_str_has_suffix(name, "/search"))
3150                 player->scope = 0x02;
3151         else
3152                 player->scope = 0x01;
3153
3154         avrcp_list_items(session, start, end);
3155
3156         p = g_new0(struct pending_list_items, 1);
3157         p->start = start;
3158         p->end = end;
3159         p->total = (uint64_t) (p->end - p->start) + 1;
3160         player->p = p;
3161
3162         return 0;
3163 }
3164
3165 static void avrcp_change_path(struct avrcp *session, uint8_t direction,
3166                                                                 uint64_t uid)
3167 {
3168         struct avrcp_player *player = session->controller->player;
3169         uint8_t buf[AVRCP_BROWSING_HEADER_LENGTH + 11];
3170         struct avrcp_browsing_header *pdu = (void *) buf;
3171
3172         memset(buf, 0, sizeof(buf));
3173         put_be16(player->uid_counter, &pdu->params[0]);
3174         pdu->params[2] = direction;
3175         put_be64(uid, &pdu->params[3]);
3176         pdu->pdu_id = AVRCP_CHANGE_PATH;
3177         pdu->param_len = htons(11);
3178
3179         avctp_send_browsing_req(session->conn, buf, sizeof(buf),
3180                                         avrcp_change_path_rsp, session);
3181 }
3182
3183 static int ct_change_folder(struct media_player *mp, const char *path,
3184                                         uint64_t uid, void *user_data)
3185 {
3186         struct avrcp_player *player = user_data;
3187         struct avrcp *session;
3188         uint8_t direction;
3189
3190         session = player->sessions->data;
3191         player->change_path = g_strdup(path);
3192
3193         direction = g_str_has_prefix(path, player->path) ? 0x01 : 0x00;
3194
3195         avrcp_change_path(session, direction, uid);
3196
3197         return 0;
3198 }
3199
3200 static gboolean avrcp_search_rsp(struct avctp *conn, uint8_t *operands,
3201                                         size_t operand_count, void *user_data)
3202 {
3203         struct avrcp_browsing_header *pdu = (void *) operands;
3204         struct avrcp *session = (void *) user_data;
3205         struct avrcp_player *player = session->controller->player;
3206         struct media_player *mp = player->user_data;
3207         int ret;
3208
3209         if (pdu == NULL) {
3210                 ret = -ETIMEDOUT;
3211                 goto done;
3212         }
3213
3214         if (pdu->params[0] != AVRCP_STATUS_SUCCESS || operand_count < 7) {
3215                 ret = -EINVAL;
3216                 goto done;
3217         }
3218
3219         player->uid_counter = get_be16(&pdu->params[1]);
3220         ret = get_be32(&pdu->params[3]);
3221
3222 done:
3223         media_player_search_complete(mp, ret);
3224
3225         return FALSE;
3226 }
3227
3228 static void avrcp_search(struct avrcp *session, const char *string)
3229 {
3230         uint8_t buf[AVRCP_BROWSING_HEADER_LENGTH + 255];
3231         struct avrcp_browsing_header *pdu = (void *) buf;
3232         uint16_t len, stringlen;
3233
3234         memset(buf, 0, sizeof(buf));
3235         len = AVRCP_BROWSING_HEADER_LENGTH + 4;
3236         stringlen = strnlen(string, sizeof(buf) - len);
3237         len += stringlen;
3238
3239         put_be16(AVRCP_CHARSET_UTF8, &pdu->params[0]);
3240         put_be16(stringlen, &pdu->params[2]);
3241         memcpy(&pdu->params[4], string, stringlen);
3242         pdu->pdu_id = AVRCP_SEARCH;
3243         pdu->param_len = htons(len - AVRCP_BROWSING_HEADER_LENGTH);
3244
3245         avctp_send_browsing_req(session->conn, buf, len, avrcp_search_rsp,
3246                                                                 session);
3247 }
3248
3249 static int ct_search(struct media_player *mp, const char *string,
3250                                                         void *user_data)
3251 {
3252         struct avrcp_player *player = user_data;
3253         struct avrcp *session;
3254
3255         session = player->sessions->data;
3256
3257         avrcp_search(session, string);
3258
3259         return 0;
3260 }
3261
3262 static void avrcp_play_item(struct avrcp *session, uint64_t uid)
3263 {
3264         uint8_t buf[AVRCP_HEADER_LENGTH + 11];
3265         struct avrcp_player *player = session->controller->player;
3266         struct avrcp_header *pdu = (void *) buf;
3267         uint16_t length;
3268
3269         memset(buf, 0, sizeof(buf));
3270
3271         set_company_id(pdu->company_id, IEEEID_BTSIG);
3272         pdu->pdu_id = AVRCP_PLAY_ITEM;
3273         pdu->params_len = htons(11);
3274         pdu->packet_type = AVRCP_PACKET_TYPE_SINGLE;
3275
3276         pdu->params[0] = player->scope;
3277         put_be64(uid, &pdu->params[1]);
3278         put_be16(player->uid_counter, &pdu->params[9]);
3279
3280         length = AVRCP_HEADER_LENGTH + ntohs(pdu->params_len);
3281
3282         avctp_send_vendordep_req(session->conn, AVC_CTYPE_CONTROL,
3283                                         AVC_SUBUNIT_PANEL, buf, length,
3284                                         NULL, session);
3285 }
3286
3287 static int ct_play_item(struct media_player *mp, const char *name,
3288                                                 uint64_t uid, void *user_data)
3289 {
3290         struct avrcp_player *player = user_data;
3291         struct avrcp *session;
3292
3293         if (player->p != NULL)
3294                 return -EBUSY;
3295
3296         session = player->sessions->data;
3297
3298         if (g_strrstr(name, "/NowPlaying"))
3299                 player->scope = 0x03;
3300         else
3301                 player->scope = 0x01;
3302
3303         avrcp_play_item(session, uid);
3304
3305         return 0;
3306 }
3307
3308 static void avrcp_add_to_nowplaying(struct avrcp *session, uint64_t uid)
3309 {
3310         uint8_t buf[AVRCP_HEADER_LENGTH + 11];
3311         struct avrcp_player *player = session->controller->player;
3312         struct avrcp_header *pdu = (void *) buf;
3313         uint16_t length;
3314
3315         memset(buf, 0, sizeof(buf));
3316
3317         set_company_id(pdu->company_id, IEEEID_BTSIG);
3318         pdu->pdu_id = AVRCP_ADD_TO_NOW_PLAYING;
3319         pdu->params_len = htons(11);
3320         pdu->packet_type = AVRCP_PACKET_TYPE_SINGLE;
3321
3322         pdu->params[0] = player->scope;
3323         put_be64(uid, &pdu->params[1]);
3324         put_be16(player->uid_counter, &pdu->params[9]);
3325
3326         length = AVRCP_HEADER_LENGTH + ntohs(pdu->params_len);
3327
3328         avctp_send_vendordep_req(session->conn, AVC_CTYPE_CONTROL,
3329                                         AVC_SUBUNIT_PANEL, buf, length,
3330                                         NULL, session);
3331 }
3332
3333 static int ct_add_to_nowplaying(struct media_player *mp, const char *name,
3334                                                 uint64_t uid, void *user_data)
3335 {
3336         struct avrcp_player *player = user_data;
3337         struct avrcp *session;
3338
3339         if (player->p != NULL)
3340                 return -EBUSY;
3341
3342         session = player->sessions->data;
3343
3344         if (g_strrstr(name, "/NowPlaying"))
3345                 player->scope = 0x03;
3346         else
3347                 player->scope = 0x01;
3348
3349         avrcp_add_to_nowplaying(session, uid);
3350
3351         return 0;
3352 }
3353
3354 static gboolean avrcp_get_total_numberofitems_rsp(struct avctp *conn,
3355                                         uint8_t *operands, size_t operand_count,
3356                                         void *user_data)
3357 {
3358         struct avrcp_browsing_header *pdu = (void *) operands;
3359         struct avrcp *session = user_data;
3360         struct avrcp_player *player = session->controller->player;
3361         struct media_player *mp = player->user_data;
3362         uint32_t num_of_items;
3363
3364         if (pdu == NULL)
3365                 return -ETIMEDOUT;
3366
3367         if (pdu->params[0] != AVRCP_STATUS_SUCCESS || operand_count < 7)
3368                 return -EINVAL;
3369
3370         if (pdu->params[0] == AVRCP_STATUS_OUT_OF_BOUNDS)
3371                 goto done;
3372
3373         player->uid_counter = get_be16(&pdu->params[1]);
3374         num_of_items = get_be32(&pdu->params[3]);
3375
3376         if (!num_of_items)
3377                 return -EINVAL;
3378
3379 done:
3380         media_player_total_items_complete(mp, num_of_items);
3381         return FALSE;
3382 }
3383
3384 static void avrcp_get_total_numberofitems(struct avrcp *session)
3385 {
3386         uint8_t buf[AVRCP_BROWSING_HEADER_LENGTH + 7];
3387         struct avrcp_player *player = session->controller->player;
3388         struct avrcp_browsing_header *pdu = (void *) buf;
3389
3390         memset(buf, 0, sizeof(buf));
3391
3392         pdu->pdu_id = AVRCP_GET_TOTAL_NUMBER_OF_ITEMS;
3393         pdu->param_len = htons(7 + sizeof(uint32_t));
3394
3395         pdu->params[0] = player->scope;
3396
3397         avctp_send_browsing_req(session->conn, buf, sizeof(buf),
3398                                 avrcp_get_total_numberofitems_rsp, session);
3399 }
3400
3401 static int ct_get_total_numberofitems(struct media_player *mp, const char *name,
3402                                                 void *user_data)
3403 {
3404         struct avrcp_player *player = user_data;
3405         struct avrcp *session;
3406
3407         session = player->sessions->data;
3408
3409         if (session->controller->version != 0x0106) {
3410                 error("version not supported");
3411                 return -1;
3412         }
3413
3414         if (g_str_has_prefix(name, "/NowPlaying"))
3415                 player->scope = 0x03;
3416         else if (g_str_has_suffix(name, "/search"))
3417                 player->scope = 0x02;
3418         else
3419                 player->scope = 0x01;
3420
3421         avrcp_get_total_numberofitems(session);
3422
3423         return 0;
3424 }
3425
3426 static const struct media_player_callback ct_cbs = {
3427         .set_setting    = ct_set_setting,
3428         .play           = ct_play,
3429         .pause          = ct_pause,
3430         .stop           = ct_stop,
3431         .next           = ct_next,
3432         .previous       = ct_previous,
3433 #ifdef __TIZEN_PATCH__
3434         .press_fast_forward     = ct_press_fast_forward,
3435         .release_fast_forward   = ct_release_fast_forward,
3436         .press_rewind           = ct_press_rewind,
3437         .release_rewind         = ct_release_rewind,
3438 #else
3439         .fast_forward   = ct_fast_forward,
3440         .rewind         = ct_rewind,
3441 #endif
3442         .list_items     = ct_list_items,
3443         .change_folder  = ct_change_folder,
3444         .search         = ct_search,
3445         .play_item      = ct_play_item,
3446         .add_to_nowplaying = ct_add_to_nowplaying,
3447         .total_items = ct_get_total_numberofitems,
3448 };
3449
3450 static void set_ct_player(struct avrcp *session, struct avrcp_player *player)
3451 {
3452         struct btd_service *service;
3453
3454         session->controller->player = player;
3455         service = btd_device_get_service(session->dev, AVRCP_TARGET_UUID);
3456         control_set_player(service, media_player_get_path(player->user_data));
3457 }
3458
3459 static struct avrcp_player *create_ct_player(struct avrcp *session,
3460                                                                 uint16_t id)
3461 {
3462         struct avrcp_player *player;
3463         struct media_player *mp;
3464         const char *path;
3465
3466         player = g_new0(struct avrcp_player, 1);
3467         player->sessions = g_slist_prepend(player->sessions, session);
3468
3469         path = device_get_path(session->dev);
3470
3471         mp = media_player_controller_create(path, id);
3472         if (mp == NULL)
3473                 return NULL;
3474
3475         media_player_set_callbacks(mp, &ct_cbs, player);
3476         player->user_data = mp;
3477         player->destroy = (GDestroyNotify) media_player_destroy;
3478
3479         if (session->controller->player == NULL)
3480                 set_ct_player(session, player);
3481
3482         session->controller->players = g_slist_prepend(
3483                                                 session->controller->players,
3484                                                 player);
3485
3486         return player;
3487 }
3488
3489 static struct avrcp_player *find_ct_player(struct avrcp *session, uint16_t id)
3490 {
3491         GSList *l;
3492
3493         for (l = session->controller->players; l; l = l->next) {
3494                 struct avrcp_player *player = l->data;
3495
3496                 if (player->id == 0) {
3497                         player->id = id;
3498                         return player;
3499                 }
3500
3501                 if (player->id == id)
3502                         return player;
3503         }
3504
3505         return NULL;
3506 }
3507
3508 static struct avrcp_player *
3509 avrcp_parse_media_player_item(struct avrcp *session, uint8_t *operands,
3510                                                         uint16_t len)
3511 {
3512         struct avrcp_player *player;
3513         struct media_player *mp;
3514         uint16_t id, namelen;
3515         uint32_t subtype;
3516         const char *curval, *strval;
3517         char name[255];
3518
3519         if (len < 28)
3520                 return NULL;
3521
3522         id = get_be16(&operands[0]);
3523
3524         player = find_ct_player(session, id);
3525         if (player == NULL) {
3526                 player = create_ct_player(session, id);
3527                 if (player == NULL)
3528                         return NULL;
3529         } else if (player->features != NULL)
3530                 return player;
3531
3532         mp = player->user_data;
3533
3534         media_player_set_type(mp, type_to_string(operands[2]));
3535
3536         subtype = get_be32(&operands[3]);
3537
3538         media_player_set_subtype(mp, subtype_to_string(subtype));
3539
3540         curval = media_player_get_status(mp);
3541         strval = status_to_string(operands[7]);
3542
3543         if (g_strcmp0(curval, strval) != 0) {
3544                 media_player_set_status(mp, strval);
3545                 avrcp_get_play_status(session);
3546         }
3547
3548         avrcp_player_parse_features(player, &operands[8]);
3549
3550         namelen = get_be16(&operands[26]);
3551         if (namelen > 0 && namelen + 28 == len) {
3552                 namelen = MIN(namelen, sizeof(name) - 1);
3553                 memcpy(name, &operands[28], namelen);
3554                 name[namelen] = '\0';
3555                 media_player_set_name(mp, name);
3556         }
3557
3558         if (session->controller->player == player && !player->browsed)
3559                 avrcp_set_browsed_player(session, player);
3560
3561         return player;
3562 }
3563
3564 static void player_destroy(gpointer data)
3565 {
3566         struct avrcp_player *player = data;
3567
3568         if (player->destroy)
3569                 player->destroy(player->user_data);
3570
3571 #ifdef __TIZEN_PATCH__
3572         avrcp_stop_position_timer();
3573 #endif
3574
3575         if (player->changed_id > 0)
3576                 g_source_remove(player->changed_id);
3577
3578         g_slist_free(player->sessions);
3579         g_free(player->path);
3580         g_free(player->change_path);
3581         g_free(player->features);
3582         g_free(player);
3583 }
3584
3585 static void player_remove(gpointer data)
3586 {
3587         struct avrcp_player *player = data;
3588         GSList *l;
3589
3590         for (l = player->sessions; l; l = l->next) {
3591                 struct avrcp *session = l->data;
3592                 struct avrcp_data *controller = session->controller;
3593
3594                 controller->players = g_slist_remove(controller->players,
3595                                                                 player);
3596
3597                 /* Check if current player is being removed */
3598                 if (controller->player == player)
3599                         set_ct_player(session, g_slist_nth_data(
3600                                                 controller->players, 0));
3601         }
3602
3603         player_destroy(player);
3604 }
3605
3606 static gboolean avrcp_get_media_player_list_rsp(struct avctp *conn,
3607                                                 uint8_t *operands,
3608                                                 size_t operand_count,
3609                                                 void *user_data)
3610 {
3611         struct avrcp_browsing_header *pdu = (void *) operands;
3612         struct avrcp *session = user_data;
3613         uint16_t count;
3614         size_t i;
3615         GSList *removed;
3616
3617         if (pdu == NULL || pdu->params[0] != AVRCP_STATUS_SUCCESS ||
3618                                                         operand_count < 5)
3619                 return FALSE;
3620
3621         removed = g_slist_copy(session->controller->players);
3622         count = get_be16(&operands[6]);
3623
3624         for (i = 8; count && i < operand_count; count--) {
3625                 struct avrcp_player *player;
3626                 uint8_t type;
3627                 uint16_t len;
3628
3629                 type = operands[i++];
3630                 len = get_be16(&operands[i]);
3631                 i += 2;
3632
3633                 if (type != 0x01) {
3634                         i += len;
3635                         continue;
3636                 }
3637
3638                 if (i + len > operand_count) {
3639                         error("Invalid player item length");
3640                         return FALSE;
3641                 }
3642
3643                 player = avrcp_parse_media_player_item(session, &operands[i],
3644                                                                         len);
3645                 if (player)
3646                         removed = g_slist_remove(removed, player);
3647
3648                 i += len;
3649         }
3650
3651         g_slist_free_full(removed, player_remove);
3652
3653         return FALSE;
3654 }
3655
3656 static void avrcp_get_media_player_list(struct avrcp *session)
3657 {
3658         uint8_t buf[AVRCP_BROWSING_HEADER_LENGTH + 10];
3659         struct avrcp_browsing_header *pdu = (void *) buf;
3660
3661         memset(buf, 0, sizeof(buf));
3662
3663         pdu->pdu_id = AVRCP_GET_FOLDER_ITEMS;
3664         put_be32(0, &pdu->params[1]);
3665         put_be32(UINT32_MAX, &pdu->params[5]);
3666         pdu->param_len = htons(10);
3667
3668         avctp_send_browsing_req(session->conn, buf, sizeof(buf),
3669                                 avrcp_get_media_player_list_rsp, session);
3670 }
3671
3672 static void avrcp_volume_changed(struct avrcp *session,
3673                                                 struct avrcp_header *pdu)
3674 {
3675         struct avrcp_player *player = target_get_player(session);
3676         uint8_t volume;
3677
3678         if (!player)
3679                 return;
3680
3681         volume = pdu->params[1] & 0x7F;
3682
3683         player->cb->set_volume(volume, session->dev, player->user_data);
3684 }
3685
3686 static void avrcp_status_changed(struct avrcp *session,
3687                                                 struct avrcp_header *pdu)
3688 {
3689         struct avrcp_player *player = session->controller->player;
3690         struct media_player *mp = player->user_data;
3691         uint8_t value;
3692         const char *curval, *strval;
3693
3694         value = pdu->params[1];
3695
3696         curval = media_player_get_status(mp);
3697         strval = status_to_string(value);
3698
3699         if (g_strcmp0(curval, strval) == 0)
3700                 return;
3701
3702         media_player_set_status(mp, strval);
3703         avrcp_get_play_status(session);
3704 }
3705
3706 static void avrcp_track_changed(struct avrcp *session,
3707                                                 struct avrcp_header *pdu)
3708 {
3709         if (session->browsing_id) {
3710                 struct avrcp_player *player = session->controller->player;
3711                 player->uid = get_be64(&pdu->params[1]);
3712                 avrcp_get_item_attributes(session, player->uid);
3713         } else
3714                 avrcp_get_element_attributes(session);
3715 }
3716
3717 static void avrcp_playback_pos_changed(struct avrcp *session,
3718                                                 struct avrcp_header *pdu)
3719 {
3720         struct avrcp_player *player = session->controller->player;
3721         struct media_player *mp = player->user_data;
3722         uint32_t position;
3723
3724         position = get_be32(&pdu->params[1]);
3725         media_player_set_position(mp, position);
3726 }
3727
3728 static void avrcp_setting_changed(struct avrcp *session,
3729                                                 struct avrcp_header *pdu)
3730 {
3731         struct avrcp_player *player = session->controller->player;
3732         struct media_player *mp = player->user_data;
3733         uint8_t count = pdu->params[1];
3734         int i;
3735
3736         for (i = 2; count > 0; count--, i += 2) {
3737                 const char *key;
3738                 const char *value;
3739
3740                 key = attr_to_str(pdu->params[i]);
3741                 if (key == NULL)
3742                         continue;
3743
3744                 value = attrval_to_str(pdu->params[i], pdu->params[i + 1]);
3745                 if (value == NULL)
3746                         continue;
3747
3748                 media_player_set_setting(mp, key, value);
3749         }
3750 }
3751
3752 static void avrcp_available_players_changed(struct avrcp *session,
3753                                                 struct avrcp_header *pdu)
3754 {
3755         avrcp_get_media_player_list(session);
3756 }
3757
3758 static void avrcp_addressed_player_changed(struct avrcp *session,
3759                                                 struct avrcp_header *pdu)
3760 {
3761         struct avrcp_player *player = session->controller->player;
3762         uint16_t id = get_be16(&pdu->params[1]);
3763
3764         if (player != NULL && player->id == id)
3765                 return;
3766
3767         player = find_ct_player(session, id);
3768         if (player == NULL) {
3769                 player = create_ct_player(session, id);
3770                 if (player == NULL)
3771                         return;
3772         }
3773
3774         player->uid_counter = get_be16(&pdu->params[3]);
3775         set_ct_player(session, player);
3776
3777         if (player->features != NULL)
3778                 return;
3779
3780         avrcp_get_media_player_list(session);
3781 }
3782
3783 static void avrcp_uids_changed(struct avrcp *session, struct avrcp_header *pdu)
3784 {
3785         struct avrcp_player *player = session->controller->player;
3786
3787         player->uid_counter = get_be16(&pdu->params[1]);
3788 }
3789
3790 static gboolean avrcp_handle_event(struct avctp *conn,
3791                                         uint8_t code, uint8_t subunit,
3792                                         uint8_t *operands, size_t operand_count,
3793                                         void *user_data)
3794 {
3795         struct avrcp *session = user_data;
3796         struct avrcp_header *pdu = (void *) operands;
3797         uint8_t event;
3798
3799         if ((code != AVC_CTYPE_INTERIM && code != AVC_CTYPE_CHANGED) ||
3800                                                                 pdu == NULL)
3801                 return FALSE;
3802
3803         event = pdu->params[0];
3804
3805         if (code == AVC_CTYPE_CHANGED) {
3806                 session->registered_events ^= (1 << event);
3807                 avrcp_register_notification(session, event);
3808                 return FALSE;
3809         }
3810
3811         switch (event) {
3812         case AVRCP_EVENT_VOLUME_CHANGED:
3813                 avrcp_volume_changed(session, pdu);
3814                 break;
3815         case AVRCP_EVENT_STATUS_CHANGED:
3816                 avrcp_status_changed(session, pdu);
3817                 break;
3818         case AVRCP_EVENT_TRACK_CHANGED:
3819                 avrcp_track_changed(session, pdu);
3820                 break;
3821         case AVRCP_EVENT_PLAYBACK_POS_CHANGED:
3822                 avrcp_playback_pos_changed(session, pdu);
3823                 break;
3824         case AVRCP_EVENT_SETTINGS_CHANGED:
3825                 avrcp_setting_changed(session, pdu);
3826                 break;
3827         case AVRCP_EVENT_AVAILABLE_PLAYERS_CHANGED:
3828                 avrcp_available_players_changed(session, pdu);
3829                 break;
3830         case AVRCP_EVENT_ADDRESSED_PLAYER_CHANGED:
3831                 avrcp_addressed_player_changed(session, pdu);
3832                 break;
3833         case AVRCP_EVENT_UIDS_CHANGED:
3834                 avrcp_uids_changed(session, pdu);
3835                 break;
3836         }
3837
3838         session->registered_events |= (1 << event);
3839
3840         return TRUE;
3841 }
3842
3843 static void avrcp_register_notification(struct avrcp *session, uint8_t event)
3844 {
3845         uint8_t buf[AVRCP_HEADER_LENGTH + AVRCP_REGISTER_NOTIFICATION_PARAM_LENGTH];
3846         struct avrcp_header *pdu = (void *) buf;
3847         uint8_t length;
3848
3849         memset(buf, 0, sizeof(buf));
3850
3851         set_company_id(pdu->company_id, IEEEID_BTSIG);
3852         pdu->pdu_id = AVRCP_REGISTER_NOTIFICATION;
3853         pdu->packet_type = AVRCP_PACKET_TYPE_SINGLE;
3854         pdu->params[0] = event;
3855
3856         /*
3857          * Set maximum interval possible for position changed as we only
3858          * use it to resync.
3859          */
3860         if (event == AVRCP_EVENT_PLAYBACK_POS_CHANGED)
3861                 bt_put_be32(UINT32_MAX / 1000, &pdu->params[1]);
3862
3863         pdu->params_len = htons(AVRCP_REGISTER_NOTIFICATION_PARAM_LENGTH);
3864
3865         length = AVRCP_HEADER_LENGTH + ntohs(pdu->params_len);
3866
3867         avctp_send_vendordep_req(session->conn, AVC_CTYPE_NOTIFY,
3868                                         AVC_SUBUNIT_PANEL, buf, length,
3869                                         avrcp_handle_event, session);
3870 }
3871
3872 #ifdef __TIZEN_PATCH__
3873 static char *avrcp_event_to_string(uint8_t event)
3874 {
3875
3876         switch (event) {
3877                 case AVRCP_EVENT_STATUS_CHANGED:
3878                         return "AVRCP EVENT STATUS CHANGED";
3879                 case AVRCP_EVENT_TRACK_CHANGED:
3880                         return "AVRCP EVENT TRACK CHANGED";
3881                 case AVRCP_EVENT_SETTINGS_CHANGED:
3882                         return "AVRCP EVENT SETTINGS CHANGED";
3883                 case AVRCP_EVENT_ADDRESSED_PLAYER_CHANGED:
3884                         return "AVRCP EVENT ADDRESSED PLAYER CHANGED";
3885                 case AVRCP_EVENT_UIDS_CHANGED:
3886                         return "AVRCP EVENT UIDS CHANGED";
3887                 case AVRCP_EVENT_AVAILABLE_PLAYERS_CHANGED:
3888                         return "AVRCP EVENT AVAILABLE PLAYERS CHANGED";
3889                 case AVRCP_EVENT_VOLUME_CHANGED:
3890                         return "AVRCP EVENT VOLUME CHANGED";
3891                 default:
3892                         return "Unknown Event";
3893                 }
3894 }
3895
3896 static gboolean avrcp_get_playback_status(struct avrcp *session)
3897 {
3898         avrcp_get_play_status(session);
3899         return TRUE;
3900 }
3901 #endif
3902
3903 static gboolean avrcp_get_capabilities_resp(struct avctp *conn,
3904                                         uint8_t code, uint8_t subunit,
3905                                         uint8_t *operands, size_t operand_count,
3906                                         void *user_data)
3907 {
3908         struct avrcp *session = user_data;
3909         struct avrcp_header *pdu = (void *) operands;
3910         uint16_t events = 0;
3911         uint8_t count;
3912
3913         if (code == AVC_CTYPE_REJECTED || code == AVC_CTYPE_NOT_IMPLEMENTED ||
3914                         pdu == NULL || pdu->params[0] != CAP_EVENTS_SUPPORTED)
3915                 return FALSE;
3916
3917         /* Connect browsing if pending */
3918         if (session->browsing_timer > 0) {
3919                 g_source_remove(session->browsing_timer);
3920                 session->browsing_timer = 0;
3921                 avctp_connect_browsing(session->conn);
3922         }
3923
3924         count = pdu->params[1];
3925
3926         for (; count > 0; count--) {
3927                 uint8_t event = pdu->params[1 + count];
3928
3929                 events |= (1 << event);
3930 #ifdef __TIZEN_PATCH__
3931                 DBG("Supported Event %s", avrcp_event_to_string(event));
3932 #endif
3933                 switch (event) {
3934                 case AVRCP_EVENT_STATUS_CHANGED:
3935                 case AVRCP_EVENT_TRACK_CHANGED:
3936                 case AVRCP_EVENT_PLAYBACK_POS_CHANGED:
3937                 case AVRCP_EVENT_SETTINGS_CHANGED:
3938 #ifndef __TIZEN_PATCH__
3939                 case AVRCP_EVENT_ADDRESSED_PLAYER_CHANGED:
3940                 case AVRCP_EVENT_UIDS_CHANGED:
3941                 case AVRCP_EVENT_AVAILABLE_PLAYERS_CHANGED:
3942                         /* These events above are controller specific */
3943                         if (!session->controller)
3944                                 break;
3945                 case AVRCP_EVENT_VOLUME_CHANGED:
3946 #endif
3947                         avrcp_register_notification(session, event);
3948                         break;
3949                 }
3950         }
3951
3952         if (!session->controller)
3953                 return FALSE;
3954
3955         if (!(events & (1 << AVRCP_EVENT_SETTINGS_CHANGED)))
3956                 avrcp_list_player_attributes(session);
3957
3958         if (!(events & (1 << AVRCP_EVENT_STATUS_CHANGED)))
3959                 avrcp_get_play_status(session);
3960
3961         if (!(events & (1 << AVRCP_EVENT_STATUS_CHANGED)))
3962                 avrcp_get_element_attributes(session);
3963 #ifdef __TIZEN_PATCH__
3964         if ((events & (1 << AVRCP_EVENT_STATUS_CHANGED)) == 0) {
3965                 session->playback_status_id = g_timeout_add_seconds(1,
3966                                 avrcp_get_playback_status, session);
3967         }
3968 #endif
3969         return FALSE;
3970 }
3971
3972 static void avrcp_get_capabilities(struct avrcp *session)
3973 {
3974         uint8_t buf[AVRCP_HEADER_LENGTH + AVRCP_GET_CAPABILITIES_PARAM_LENGTH];
3975         struct avrcp_header *pdu = (void *) buf;
3976         uint8_t length;
3977
3978         memset(buf, 0, sizeof(buf));
3979
3980         set_company_id(pdu->company_id, IEEEID_BTSIG);
3981         pdu->pdu_id = AVRCP_GET_CAPABILITIES;
3982         pdu->packet_type = AVRCP_PACKET_TYPE_SINGLE;
3983         pdu->params[0] = CAP_EVENTS_SUPPORTED;
3984         pdu->params_len = htons(AVRCP_GET_CAPABILITIES_PARAM_LENGTH);
3985
3986         length = AVRCP_HEADER_LENGTH + ntohs(pdu->params_len);
3987
3988         avctp_send_vendordep_req(session->conn, AVC_CTYPE_STATUS,
3989                                         AVC_SUBUNIT_PANEL, buf, length,
3990                                         avrcp_get_capabilities_resp,
3991                                         session);
3992 }
3993
3994 static struct avrcp *find_session(GSList *list, struct btd_device *dev)
3995 {
3996         for (; list; list = list->next) {
3997                 struct avrcp *session = list->data;
3998
3999                 if (session->dev == dev)
4000                         return session;
4001         }
4002
4003         return NULL;
4004 }
4005
4006 static void destroy_browsing(void *data)
4007 {
4008         struct avrcp *session = data;
4009
4010         session->browsing_id = 0;
4011 }
4012
4013 static void session_init_browsing(struct avrcp *session)
4014 {
4015         if (session->browsing_timer > 0) {
4016                 g_source_remove(session->browsing_timer);
4017                 session->browsing_timer = 0;
4018         }
4019
4020         session->browsing_id = avctp_register_browsing_pdu_handler(
4021                                                         session->conn,
4022                                                         handle_browsing_pdu,
4023                                                         session,
4024                                                         destroy_browsing);
4025 }
4026
4027 static struct avrcp_data *data_init(struct avrcp *session, const char *uuid)
4028 {
4029         struct avrcp_data *data;
4030         const sdp_record_t *rec;
4031         sdp_list_t *list;
4032         sdp_profile_desc_t *desc;
4033
4034         data = g_new0(struct avrcp_data, 1);
4035
4036         rec = btd_device_get_record(session->dev, uuid);
4037         if (rec == NULL)
4038                 return data;
4039
4040         if (sdp_get_profile_descs(rec, &list) == 0) {
4041                 desc = list->data;
4042                 data->version = desc->version;
4043         }
4044
4045         sdp_get_int_attr(rec, SDP_ATTR_SUPPORTED_FEATURES, &data->features);
4046         sdp_list_free(list, free);
4047
4048         return data;
4049 }
4050
4051 static gboolean connect_browsing(gpointer user_data)
4052 {
4053         struct avrcp *session = user_data;
4054
4055         session->browsing_timer = 0;
4056
4057         avctp_connect_browsing(session->conn);
4058
4059         return FALSE;
4060 }
4061
4062 static void avrcp_connect_browsing(struct avrcp *session)
4063 {
4064         /* Immediately connect browsing channel if initiator otherwise delay
4065          * it to avoid possible collisions
4066          */
4067         if (avctp_is_initiator(session->conn)) {
4068                 avctp_connect_browsing(session->conn);
4069                 return;
4070         }
4071
4072         if (session->browsing_timer > 0)
4073                 return;
4074
4075         session->browsing_timer = g_timeout_add_seconds(AVRCP_BROWSING_TIMEOUT,
4076                                                         connect_browsing,
4077                                                         session);
4078 }
4079
4080 #ifdef SUPPORT_AVRCP_TARGET
4081 static void target_init(struct avrcp *session)
4082 {
4083         struct avrcp_server *server = session->server;
4084         struct avrcp_data *target;
4085         struct avrcp_player *player;
4086         struct btd_service *service;
4087
4088         if (session->target != NULL)
4089                 return;
4090
4091         target = data_init(session, AVRCP_REMOTE_UUID);
4092         session->target = target;
4093
4094         DBG("%p version 0x%04x", target, target->version);
4095
4096         service = btd_device_get_service(session->dev, AVRCP_REMOTE_UUID);
4097         btd_service_connecting_complete(service, 0);
4098
4099         player = g_slist_nth_data(server->players, 0);
4100         if (player != NULL) {
4101                 target->player = player;
4102                 player->sessions = g_slist_prepend(player->sessions, session);
4103         }
4104
4105         session->supported_events |= (1 << AVRCP_EVENT_STATUS_CHANGED) |
4106                                 (1 << AVRCP_EVENT_TRACK_CHANGED) |
4107 #ifndef __TIZEN_PATCH__
4108                                 (1 << AVRCP_EVENT_TRACK_REACHED_START) |
4109                                 (1 << AVRCP_EVENT_TRACK_REACHED_END) |
4110 #endif
4111 #ifdef __TIZEN_PATCH__
4112                                 (1 << AVRCP_EVENT_PLAYBACK_POS_CHANGED) |
4113 #endif
4114                                 (1 << AVRCP_EVENT_SETTINGS_CHANGED);
4115
4116         if (target->version < 0x0104)
4117                 return;
4118
4119 #ifdef __TIZEN_PATCH__
4120         if (adapter_avrcp_tg_ver < 0x0104)
4121                 return;
4122 #endif
4123
4124         session->supported_events |=
4125                                 (1 << AVRCP_EVENT_ADDRESSED_PLAYER_CHANGED) |
4126                                 (1 << AVRCP_EVENT_AVAILABLE_PLAYERS_CHANGED) |
4127                                 (1 << AVRCP_EVENT_VOLUME_CHANGED);
4128
4129         /* Only check capabilities if controller is not supported */
4130         if (session->controller == NULL)
4131                 avrcp_get_capabilities(session);
4132
4133         if (!(target->features & AVRCP_FEATURE_BROWSING))
4134                 return;
4135
4136         avrcp_connect_browsing(session);
4137 }
4138 #endif
4139
4140 #ifdef SUPPORT_AVRCP_CONTROL
4141 static void controller_init(struct avrcp *session)
4142 {
4143         struct avrcp_player *player;
4144         struct btd_service *service;
4145         struct avrcp_data *controller;
4146
4147         if (session->controller != NULL)
4148                 return;
4149
4150         controller = data_init(session, AVRCP_TARGET_UUID);
4151         session->controller = controller;
4152
4153         DBG("%p version 0x%04x", controller, controller->version);
4154
4155 #ifdef __TIZEN_PATCH__
4156         if ((controller->version >= 0x0104) && (adapter_avrcp_ct_ver >= 0x0104))
4157                 session->supported_events |= (1 << AVRCP_EVENT_VOLUME_CHANGED);
4158 #endif
4159
4160         service = btd_device_get_service(session->dev, AVRCP_TARGET_UUID);
4161         btd_service_connecting_complete(service, 0);
4162
4163         /* Only create player if category 1 is supported */
4164         if (!(controller->features & AVRCP_FEATURE_CATEGORY_1))
4165                 return;
4166
4167         player = create_ct_player(session, 0);
4168         if (player == NULL)
4169                 return;
4170
4171         if (controller->version < 0x0103)
4172                 return;
4173
4174         avrcp_get_capabilities(session);
4175
4176         if (controller->version < 0x0104)
4177                 return;
4178
4179 #ifdef __TIZEN_PATCH__
4180         if (adapter_avrcp_ct_ver < 0x0104)
4181                 return;
4182 #endif
4183
4184         if (!(controller->features & AVRCP_FEATURE_BROWSING))
4185                 return;
4186
4187         avrcp_connect_browsing(session);
4188 }
4189 #endif
4190
4191 static void session_init_control(struct avrcp *session)
4192 {
4193         session->passthrough_id = avctp_register_passthrough_handler(
4194                                                         session->conn,
4195                                                         handle_passthrough,
4196                                                         session);
4197         session->passthrough_handlers = passthrough_handlers;
4198         session->control_id = avctp_register_pdu_handler(session->conn,
4199                                                         AVC_OP_VENDORDEP,
4200                                                         handle_vendordep_pdu,
4201                                                         session);
4202         session->control_handlers = control_handlers;
4203 #ifdef SUPPORT_AVRCP_CONTROL
4204         if (btd_device_get_service(session->dev, AVRCP_TARGET_UUID) != NULL)
4205                 controller_init(session);
4206 #endif
4207 #ifdef SUPPORT_AVRCP_TARGET
4208         if (btd_device_get_service(session->dev, AVRCP_REMOTE_UUID) != NULL)
4209                 target_init(session);
4210 #endif
4211 }
4212
4213 static void controller_destroy(struct avrcp *session)
4214 {
4215         struct avrcp_data *controller = session->controller;
4216
4217         DBG("%p", controller);
4218
4219         g_slist_free_full(controller->players, player_destroy);
4220
4221         g_free(controller);
4222 }
4223
4224 static void target_destroy(struct avrcp *session)
4225 {
4226         struct avrcp_data *target = session->target;
4227         struct avrcp_player *player = target->player;
4228
4229         DBG("%p", target);
4230
4231         if (player != NULL)
4232                 player->sessions = g_slist_remove(player->sessions, session);
4233
4234         g_free(target);
4235 }
4236
4237 static void session_destroy(struct avrcp *session, int err)
4238 {
4239         struct avrcp_server *server = session->server;
4240         struct btd_service *service;
4241
4242         server->sessions = g_slist_remove(server->sessions, session);
4243
4244 #ifdef __TIZEN_PATCH__
4245         if (session->playback_status_id > 0) {
4246                 DBG("Removing the timer for playback status polling");
4247                 g_source_remove(session->playback_status_id);
4248                 session->playback_status_id = 0;
4249         }
4250 #endif
4251
4252         session_abort_pending_pdu(session);
4253
4254         service = btd_device_get_service(session->dev, AVRCP_TARGET_UUID);
4255         if (service != NULL) {
4256                 if (session->control_id == 0)
4257                         btd_service_connecting_complete(service, err);
4258                 else
4259                         btd_service_disconnecting_complete(service, 0);
4260         }
4261
4262         service = btd_device_get_service(session->dev, AVRCP_REMOTE_UUID);
4263         if (service != NULL) {
4264                 if (session->control_id == 0)
4265                         btd_service_connecting_complete(service, err);
4266                 else
4267                         btd_service_disconnecting_complete(service, 0);
4268         }
4269
4270         if (session->browsing_timer > 0)
4271                 g_source_remove(session->browsing_timer);
4272
4273         if (session->controller != NULL)
4274                 controller_destroy(session);
4275
4276         if (session->target != NULL)
4277                 target_destroy(session);
4278
4279         if (session->passthrough_id > 0)
4280                 avctp_unregister_passthrough_handler(session->passthrough_id);
4281
4282         if (session->control_id > 0)
4283                 avctp_unregister_pdu_handler(session->control_id);
4284
4285         if (session->browsing_id > 0)
4286                 avctp_unregister_browsing_pdu_handler(session->browsing_id);
4287
4288         g_free(session);
4289 }
4290
4291 static struct avrcp *session_create(struct avrcp_server *server,
4292                                                 struct btd_device *device)
4293 {
4294         struct avrcp *session;
4295
4296         session = g_new0(struct avrcp, 1);
4297         session->server = server;
4298         session->conn = avctp_connect(device);
4299         session->dev = device;
4300
4301         server->sessions = g_slist_append(server->sessions, session);
4302
4303         return session;
4304 }
4305
4306 static void state_changed(struct btd_device *device, avctp_state_t old_state,
4307                                         avctp_state_t new_state, int err,
4308                                         void *user_data)
4309 {
4310         struct avrcp_server *server;
4311         struct avrcp *session;
4312
4313         server = find_server(servers, device_get_adapter(device));
4314         if (!server)
4315                 return;
4316
4317         session = find_session(server->sessions, device);
4318
4319         switch (new_state) {
4320         case AVCTP_STATE_DISCONNECTED:
4321                 if (session == NULL)
4322                         break;
4323
4324                 session_destroy(session, err);
4325
4326                 break;
4327         case AVCTP_STATE_CONNECTING:
4328                 if (session != NULL)
4329                         break;
4330
4331                 session_create(server, device);
4332
4333                 break;
4334         case AVCTP_STATE_CONNECTED:
4335                 if (session == NULL || session->control_id > 0)
4336                         break;
4337
4338                 session_init_control(session);
4339
4340                 break;
4341         case AVCTP_STATE_BROWSING_CONNECTED:
4342                 if (session == NULL || session->browsing_id > 0)
4343                         break;
4344
4345                 session_init_browsing(session);
4346
4347                 break;
4348         case AVCTP_STATE_BROWSING_CONNECTING:
4349         default:
4350                 return;
4351         }
4352 }
4353
4354 static struct avrcp_server *avrcp_server_register(struct btd_adapter *adapter)
4355 {
4356         struct avrcp_server *server;
4357
4358         if (avctp_register(adapter, TRUE) < 0)
4359                 return NULL;
4360
4361         server = g_new0(struct avrcp_server, 1);
4362         server->adapter = btd_adapter_ref(adapter);
4363
4364         servers = g_slist_append(servers, server);
4365
4366         if (!avctp_id)
4367                 avctp_id = avctp_add_state_cb(NULL, state_changed, NULL);
4368
4369         return server;
4370 }
4371
4372 static void avrcp_server_unregister(struct avrcp_server *server)
4373 {
4374         g_slist_free_full(server->sessions, g_free);
4375         g_slist_free_full(server->players, player_destroy);
4376
4377         servers = g_slist_remove(servers, server);
4378
4379         avctp_unregister(server->adapter);
4380         btd_adapter_unref(server->adapter);
4381         g_free(server);
4382
4383         if (servers)
4384                 return;
4385
4386         if (avctp_id) {
4387                 avctp_remove_state_cb(avctp_id);
4388                 avctp_id = 0;
4389         }
4390 }
4391
4392 struct avrcp_player *avrcp_register_player(struct btd_adapter *adapter,
4393                                                 struct avrcp_player_cb *cb,
4394                                                 void *user_data,
4395                                                 GDestroyNotify destroy)
4396 {
4397         struct avrcp_server *server;
4398         struct avrcp_player *player;
4399         GSList *l;
4400         static uint16_t id = 0;
4401
4402         server = find_server(servers, adapter);
4403         if (!server)
4404                 return NULL;
4405
4406         player = g_new0(struct avrcp_player, 1);
4407         player->id = ++id;
4408         player->server = server;
4409         player->cb = cb;
4410         player->user_data = user_data;
4411         player->destroy = destroy;
4412
4413         server->players = g_slist_append(server->players, player);
4414
4415         /* Assign player to session without current player */
4416         for (l = server->sessions; l; l = l->next) {
4417                 struct avrcp *session = l->data;
4418                 struct avrcp_data *target = session->target;
4419
4420                 if (target == NULL)
4421                         continue;
4422
4423                 if (target->player == NULL) {
4424                         target->player = player;
4425                         player->sessions = g_slist_append(player->sessions,
4426                                                                 session);
4427                 }
4428         }
4429
4430         avrcp_player_event(player,
4431                                 AVRCP_EVENT_AVAILABLE_PLAYERS_CHANGED, NULL);
4432
4433         return player;
4434 }
4435
4436 void avrcp_unregister_player(struct avrcp_player *player)
4437 {
4438         struct avrcp_server *server = player->server;
4439         GSList *l;
4440
4441         server->players = g_slist_remove(server->players, player);
4442
4443         /* Remove player from sessions using it */
4444         for (l = player->sessions; l; l = l->next) {
4445                 struct avrcp *session = l->data;
4446                 struct avrcp_data *target = session->target;
4447
4448                 if (target == NULL)
4449                         continue;
4450
4451                 if (target->player == player)
4452                         target->player = g_slist_nth_data(server->players, 0);
4453         }
4454
4455         avrcp_player_event(player,
4456                                 AVRCP_EVENT_AVAILABLE_PLAYERS_CHANGED, NULL);
4457
4458         player_destroy(player);
4459 }
4460
4461 static gboolean avrcp_handle_set_volume(struct avctp *conn,
4462                                         uint8_t code, uint8_t subunit,
4463                                         uint8_t *operands, size_t operand_count,
4464                                         void *user_data)
4465 {
4466         struct avrcp *session = user_data;
4467         struct avrcp_player *player = target_get_player(session);
4468         struct avrcp_header *pdu = (void *) operands;
4469         uint8_t volume;
4470
4471         if (code == AVC_CTYPE_REJECTED || code == AVC_CTYPE_NOT_IMPLEMENTED ||
4472                                                                 pdu == NULL)
4473                 return FALSE;
4474
4475         volume = pdu->params[0] & 0x7F;
4476
4477         if (player != NULL)
4478                 player->cb->set_volume(volume, session->dev, player->user_data);
4479
4480         return FALSE;
4481 }
4482
4483 static int avrcp_event(struct avrcp *session, uint8_t id, const void *data)
4484 {
4485         uint8_t buf[AVRCP_HEADER_LENGTH + 2];
4486         struct avrcp_header *pdu = (void *) buf;
4487         uint8_t code;
4488         uint16_t size;
4489         int err;
4490
4491         /* Verify that the event is registered */
4492         if (!(session->registered_events & (1 << id)))
4493                 return -ENOENT;
4494
4495         memset(buf, 0, sizeof(buf));
4496
4497         set_company_id(pdu->company_id, IEEEID_BTSIG);
4498         pdu->pdu_id = AVRCP_REGISTER_NOTIFICATION;
4499         code = AVC_CTYPE_CHANGED;
4500         pdu->params[0] = id;
4501
4502         DBG("id=%u", id);
4503
4504         switch (id) {
4505         case AVRCP_EVENT_VOLUME_CHANGED:
4506                 size = 2;
4507                 memcpy(&pdu->params[1], data, sizeof(uint8_t));
4508                 break;
4509         default:
4510                 error("Unknown event %u", id);
4511                 return -EINVAL;
4512         }
4513
4514         pdu->params_len = htons(size);
4515
4516         err = avctp_send_vendordep(session->conn,
4517                                         session->transaction_events[id],
4518                                         code, AVC_SUBUNIT_PANEL,
4519                                         buf, size + AVRCP_HEADER_LENGTH);
4520         if (err < 0)
4521                 return err;
4522
4523         /* Unregister event as per AVRCP 1.3 spec, section 5.4.2 */
4524         session->registered_events ^= 1 << id;
4525
4526         return err;
4527 }
4528
4529 int avrcp_set_volume(struct btd_device *dev, uint8_t volume, bool notify)
4530 {
4531         struct avrcp_server *server;
4532         struct avrcp *session;
4533         uint8_t buf[AVRCP_HEADER_LENGTH + 1];
4534         struct avrcp_header *pdu = (void *) buf;
4535
4536         server = find_server(servers, device_get_adapter(dev));
4537         if (server == NULL)
4538                 return -EINVAL;
4539
4540         session = find_session(server->sessions, dev);
4541         if (session == NULL)
4542                 return -ENOTCONN;
4543
4544         if (notify) {
4545                 if (!session->target)
4546                         return -ENOTSUP;
4547                 return avrcp_event(session, AVRCP_EVENT_VOLUME_CHANGED,
4548                                                                 &volume);
4549         }
4550
4551         if (!session->controller || session->controller->version < 0x0104)
4552                 return -ENOTSUP;
4553
4554         memset(buf, 0, sizeof(buf));
4555
4556         set_company_id(pdu->company_id, IEEEID_BTSIG);
4557
4558         pdu->pdu_id = AVRCP_SET_ABSOLUTE_VOLUME;
4559         pdu->params[0] = volume;
4560         pdu->params_len = htons(1);
4561
4562         return avctp_send_vendordep_req(session->conn,
4563                                         AVC_CTYPE_CONTROL, AVC_SUBUNIT_PANEL,
4564                                         buf, sizeof(buf),
4565                                         avrcp_handle_set_volume, session);
4566 }
4567
4568 static int avrcp_connect(struct btd_service *service)
4569 {
4570         struct btd_device *dev = btd_service_get_device(service);
4571         const char *path = device_get_path(dev);
4572 #ifdef __TIZEN_PATCH__
4573         char name[10];
4574 #endif
4575         DBG("path %s", path);
4576
4577 #ifdef __TIZEN_PATCH__
4578         device_get_name(dev, name, sizeof(name));
4579         DBG("name : %s", name);
4580         if (g_str_equal(name, "PLT_M50")) {
4581                 DBG("Don't initiate avrcp connection with this headset");
4582                 return -ENOTSUP;
4583         }
4584 #endif
4585         return control_connect(service);
4586 }
4587
4588 static int avrcp_disconnect(struct btd_service *service)
4589 {
4590         struct btd_device *dev = btd_service_get_device(service);
4591         const char *path = device_get_path(dev);
4592
4593         DBG("path %s", path);
4594
4595         return control_disconnect(service);
4596 }
4597
4598 static int avrcp_target_probe(struct btd_service *service)
4599 {
4600         struct btd_device *dev = btd_service_get_device(service);
4601
4602         DBG("path %s", device_get_path(dev));
4603
4604         return control_init_target(service);
4605 }
4606
4607 static void avrcp_target_remove(struct btd_service *service)
4608 {
4609         control_unregister(service);
4610 }
4611
4612 #ifdef SUPPORT_AVRCP_TARGET
4613 static void avrcp_target_server_remove(struct btd_profile *p,
4614                                                 struct btd_adapter *adapter)
4615 {
4616         struct avrcp_server *server;
4617
4618         DBG("path %s", adapter_get_path(adapter));
4619
4620         server = find_server(servers, adapter);
4621         if (!server)
4622                 return;
4623
4624         if (server->tg_record_id != 0) {
4625                 adapter_service_remove(adapter, server->tg_record_id);
4626                 server->tg_record_id = 0;
4627         }
4628
4629         if (server->ct_record_id == 0)
4630                 avrcp_server_unregister(server);
4631 }
4632 #endif
4633
4634 #ifdef SUPPORT_AVRCP_TARGET
4635 static int avrcp_target_server_probe(struct btd_profile *p,
4636                                                 struct btd_adapter *adapter)
4637 {
4638         sdp_record_t *record;
4639         struct avrcp_server *server;
4640
4641         DBG("path %s", adapter_get_path(adapter));
4642
4643         server = find_server(servers, adapter);
4644         if (server != NULL)
4645                 goto done;
4646
4647         server = avrcp_server_register(adapter);
4648         if (server == NULL)
4649                 return -EPROTONOSUPPORT;
4650
4651 done:
4652         record = avrcp_tg_record();
4653         if (!record) {
4654                 error("Unable to allocate new service record");
4655                 avrcp_target_server_remove(p, adapter);
4656                 return -1;
4657         }
4658
4659         if (adapter_service_add(adapter, record) < 0) {
4660                 error("Unable to register AVRCP target service record");
4661                 avrcp_target_server_remove(p, adapter);
4662                 sdp_record_free(record);
4663                 return -1;
4664         }
4665         server->tg_record_id = record->handle;
4666
4667         return 0;
4668 }
4669 #endif
4670
4671 static struct btd_profile avrcp_target_profile = {
4672         .name           = "audio-avrcp-target",
4673
4674         .remote_uuid    = AVRCP_TARGET_UUID,
4675         .device_probe   = avrcp_target_probe,
4676         .device_remove  = avrcp_target_remove,
4677
4678         .connect        = avrcp_connect,
4679         .disconnect     = avrcp_disconnect,
4680 #ifdef SUPPORT_AVRCP_TARGET
4681         .adapter_probe  = avrcp_target_server_probe,
4682         .adapter_remove = avrcp_target_server_remove,
4683 #endif
4684 };
4685
4686 static int avrcp_controller_probe(struct btd_service *service)
4687 {
4688         struct btd_device *dev = btd_service_get_device(service);
4689
4690         DBG("path %s", device_get_path(dev));
4691
4692         return control_init_remote(service);
4693 }
4694
4695 static void avrcp_controller_remove(struct btd_service *service)
4696 {
4697         control_unregister(service);
4698 }
4699
4700 #ifdef SUPPORT_AVRCP_CONTROL
4701 static void avrcp_controller_server_remove(struct btd_profile *p,
4702                                                 struct btd_adapter *adapter)
4703 {
4704         struct avrcp_server *server;
4705
4706         DBG("path %s", adapter_get_path(adapter));
4707
4708         server = find_server(servers, adapter);
4709         if (!server)
4710                 return;
4711
4712         if (server->ct_record_id != 0) {
4713                 adapter_service_remove(adapter, server->ct_record_id);
4714                 server->ct_record_id = 0;
4715         }
4716
4717         if (server->tg_record_id == 0)
4718                 avrcp_server_unregister(server);
4719 }
4720 #endif
4721
4722 #ifdef SUPPORT_AVRCP_CONTROL
4723 static int avrcp_controller_server_probe(struct btd_profile *p,
4724                                                 struct btd_adapter *adapter)
4725 {
4726         sdp_record_t *record;
4727         struct avrcp_server *server;
4728
4729         DBG("path %s", adapter_get_path(adapter));
4730
4731         server = find_server(servers, adapter);
4732         if (server != NULL)
4733                 goto done;
4734
4735         server = avrcp_server_register(adapter);
4736         if (server == NULL)
4737                 return -EPROTONOSUPPORT;
4738
4739 done:
4740         record = avrcp_ct_record();
4741         if (!record) {
4742                 error("Unable to allocate new service record");
4743                 avrcp_controller_server_remove(p, adapter);
4744                 return -1;
4745         }
4746
4747         if (adapter_service_add(adapter, record) < 0) {
4748                 error("Unable to register AVRCP service record");
4749                 avrcp_controller_server_remove(p, adapter);
4750                 sdp_record_free(record);
4751                 return -1;
4752         }
4753         server->ct_record_id = record->handle;
4754
4755         return 0;
4756 }
4757 #endif
4758
4759 static struct btd_profile avrcp_controller_profile = {
4760         .name           = "avrcp-controller",
4761
4762         .remote_uuid    = AVRCP_REMOTE_UUID,
4763         .device_probe   = avrcp_controller_probe,
4764         .device_remove  = avrcp_controller_remove,
4765
4766         .connect        = avrcp_connect,
4767         .disconnect     = avrcp_disconnect,
4768 #ifdef SUPPORT_AVRCP_CONTROL
4769         .adapter_probe  = avrcp_controller_server_probe,
4770         .adapter_remove = avrcp_controller_server_remove,
4771 #endif
4772 };
4773
4774 static int avrcp_init(void)
4775 {
4776         btd_profile_register(&avrcp_controller_profile);
4777         btd_profile_register(&avrcp_target_profile);
4778
4779         return 0;
4780 }
4781
4782 static void avrcp_exit(void)
4783 {
4784         btd_profile_unregister(&avrcp_controller_profile);
4785         btd_profile_unregister(&avrcp_target_profile);
4786 }
4787
4788 BLUETOOTH_PLUGIN_DEFINE(avrcp, VERSION, BLUETOOTH_PLUGIN_PRIORITY_DEFAULT,
4789                                                         avrcp_init, avrcp_exit)