bt-api/bt-avrcp.c

   1 /*
   2  * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *              http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 #include <string.h>
  19
  20 #include "bluetooth-api.h"
  21 #include "bluetooth-media-control.h"
  22 #include "bt-internal-types.h"
  23
  24 #include "bt-common.h"
  25 #include "bt-request-sender.h"
  26 #include "bt-event-handler.h"
  27 #include "bt-dpm.h"
  28
  29 BT_EXPORT_API int bluetooth_media_player_init(media_cb_func_ptr callback_ptr,
  30                                                 void *user_data)
  31 {
  32         int ret;
  33
  34         /* Register AVRCP events */
  35         ret = _bt_register_event(BT_AVRCP_EVENT , (void *)callback_ptr, user_data);
  36
  37         if (ret != BLUETOOTH_ERROR_NONE &&
  38              ret != BLUETOOTH_ERROR_ALREADY_INITIALIZED) {
  39                 BT_ERR("Fail to init the event handler");
  40                 return ret;
  41         }
  42
  43         _bt_set_user_data(BT_AVRCP, (void *)callback_ptr, user_data);
  44
  45         return BLUETOOTH_ERROR_NONE;
  46 }
  47
  48 BT_EXPORT_API int bluetooth_media_player_deinit(void)
  49 {
  50         int ret;
  51
  52         ret = _bt_unregister_event(BT_AVRCP_EVENT);
  53
  54         if (ret != BLUETOOTH_ERROR_NONE) {
  55                 BT_ERR("Fail to deinit the event handler");
  56                 return ret;
  57         }
  58
  59         _bt_set_user_data(BT_AVRCP, NULL, NULL);
  60
  61         return BLUETOOTH_ERROR_NONE;
  62 }
  63
  64 BT_EXPORT_API int bluetooth_media_player_change_property(
  65                         media_player_property_type type,
  66                         unsigned int value)
  67 {
  68         int result;
  69
  70         BT_CHECK_ENABLED(return);
  71
  72         if (_bt_check_dpm(BT_DPM_AVRCP, NULL) == BT_DPM_RESTRICTED) {
  73                 BT_ERR("Not allow to use AVRCP profile");
  74                 return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
  75         }
  76
  77         BT_INIT_PARAMS();
  78         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
  79
  80         g_array_append_vals(in_param1, &type, sizeof(int));
  81         g_array_append_vals(in_param2, &value, sizeof(unsigned int));
  82
  83         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_AVRCP_SET_PROPERTY,
  84                 in_param1, in_param2, in_param3, in_param4, &out_param);
  85
  86         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
  87
  88         return result;
  89 }
  90
  91 BT_EXPORT_API int bluetooth_media_player_set_properties(
  92                         media_player_settings_t *setting)
  93 {
  94         int result;
  95
  96         BT_CHECK_PARAMETER(setting, return);
  97         BT_CHECK_ENABLED(return);
  98
  99         if (_bt_check_dpm(BT_DPM_AVRCP, NULL) == BT_DPM_RESTRICTED) {
 100                 BT_ERR("Not allow to use AVRCP profile");
 101                 return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
 102         }
 103
 104         BT_INIT_PARAMS();
 105         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 106
 107         g_array_append_vals(in_param1, setting, sizeof(media_player_settings_t));
 108
 109         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_AVRCP_SET_PROPERTIES,
 110                 in_param1, in_param2, in_param3, in_param4, &out_param);
 111
 112         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 113
 114         return result;
 115 }
 116
 117 BT_EXPORT_API int bluetooth_media_player_change_track(
 118                 media_metadata_attributes_t *metadata)
 119 {
 120         int result;
 121         media_metadata_t meta_data;
 122
 123         BT_CHECK_PARAMETER(metadata, return);
 124         BT_CHECK_ENABLED(return);
 125
 126         if (_bt_check_dpm(BT_DPM_AVRCP, NULL) == BT_DPM_RESTRICTED) {
 127                 BT_ERR("Not allow to use AVRCP profile");
 128                 return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
 129         }
 130
 131         BT_INIT_PARAMS();
 132         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 133
 134         memset(&meta_data, 0x00, sizeof(media_metadata_t));
 135
 136         if (_bt_copy_utf8_string(meta_data.title, metadata->title, BT_META_DATA_MAX_LEN))
 137                 BT_ERR("Error in copying Title\n");
 138         if (_bt_copy_utf8_string(meta_data.artist, metadata->artist, BT_META_DATA_MAX_LEN))
 139                 BT_ERR("Error in copying Artist\n");
 140         if (_bt_copy_utf8_string(meta_data.album, metadata->album, BT_META_DATA_MAX_LEN))
 141                 BT_ERR("Error in copying Album\n");
 142         if (_bt_copy_utf8_string(meta_data.genre, metadata->genre, BT_META_DATA_MAX_LEN))
 143                 BT_ERR("Error in copying Genre\n");
 144
 145         if (_bt_utf8_validate(meta_data.title) == FALSE)
 146                 meta_data.title[0] = '\0';
 147
 148         if (_bt_utf8_validate(meta_data.artist) == FALSE)
 149                 meta_data.artist[0] = '\0';
 150
 151         if (_bt_utf8_validate(meta_data.album) == FALSE)
 152                 meta_data.album[0] = '\0';
 153
 154         if (_bt_utf8_validate(meta_data.genre) == FALSE)
 155                 meta_data.genre[0] = '\0';
 156
 157         meta_data.total_tracks = metadata->total_tracks;
 158         meta_data.number = metadata->number;
 159         meta_data.duration = metadata->duration;
 160
 161         g_array_append_vals(in_param1, &meta_data, sizeof(media_metadata_t));
 162
 163         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_AVRCP_SET_TRACK_INFO,
 164                 in_param1, in_param2, in_param3, in_param4, &out_param);
 165
 166         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 167
 168         return result;
 169 }
 170
 171 BT_EXPORT_API int bluetooth_media_control_init(media_cb_func_ptr callback_ptr,
 172                                                 void *user_data)
 173 {
 174         int ret;
 175
 176         /* Register AVRCP events */
 177         ret = _bt_register_event(BT_AVRCP_CONTROL_EVENT,
 178                                         (void *)callback_ptr, user_data);
 179
 180         if (ret != BLUETOOTH_ERROR_NONE &&
 181                         ret != BLUETOOTH_ERROR_ALREADY_INITIALIZED) {
 182                 BT_ERR("Fail to init the event handler");
 183                 return ret;
 184         }
 185
 186         _bt_set_user_data(BT_AVRCP, (void *)callback_ptr, user_data);
 187
 188         return BLUETOOTH_ERROR_NONE;
 189 }
 190
 191 BT_EXPORT_API int bluetooth_media_control_deinit(void)
 192 {
 193         int ret;
 194
 195         ret = _bt_unregister_event(BT_AVRCP_CONTROL_EVENT);
 196
 197         if (ret != BLUETOOTH_ERROR_NONE) {
 198                 BT_ERR("Fail to deinit the event handler");
 199                 return ret;
 200         }
 201
 202         _bt_set_user_data(BT_AVRCP, NULL, NULL);
 203
 204         return BLUETOOTH_ERROR_NONE;
 205 }
 206
 207 BT_EXPORT_API int bluetooth_media_control_connect(
 208                         bluetooth_device_address_t *remote_address)
 209 {
 210         int result;
 211         bt_user_info_t *user_info;
 212
 213         BT_CHECK_PARAMETER(remote_address, return);
 214         BT_CHECK_ENABLED(return);
 215
 216         if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_AVRCP_CONTROL_CONNECT)
 217                         == BLUETOOTH_ERROR_PERMISSION_DEINED) {
 218                 BT_ERR("Don't have a privilege to use this API");
 219                 return BLUETOOTH_ERROR_PERMISSION_DEINED;
 220         }
 221
 222         if (_bt_check_dpm(BT_DPM_ADDRESS, remote_address) == BT_DPM_RESTRICTED) {
 223                 BT_ERR("Blacklist device");
 224                 return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
 225         }
 226
 227         if (_bt_check_dpm(BT_DPM_AVRCP, NULL) == BT_DPM_RESTRICTED) {
 228                 BT_ERR("Not allow to use AVRCP profile");
 229                 return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
 230         }
 231
 232         user_info = _bt_get_user_data(BT_AVRCP);
 233         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
 234
 235         BT_INIT_PARAMS();
 236         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 237
 238         g_array_append_vals(in_param1, remote_address,
 239                                         sizeof(bluetooth_device_address_t));
 240
 241         result = _bt_send_request_async(BT_BLUEZ_SERVICE,
 242                                 BT_AVRCP_CONTROL_CONNECT, in_param1,
 243                                 in_param2, in_param3, in_param4,
 244                                 user_info->cb, user_info->user_data);
 245
 246         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 247
 248         return result;
 249 }
 250
 251 BT_EXPORT_API int bluetooth_media_control_disconnect(
 252                         bluetooth_device_address_t *remote_address)
 253 {
 254         int result;
 255         bt_user_info_t *user_info;
 256
 257         BT_CHECK_PARAMETER(remote_address, return);
 258         BT_CHECK_ENABLED(return);
 259
 260         if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_AVRCP_CONTROL_DISCONNECT)
 261                                 == BLUETOOTH_ERROR_PERMISSION_DEINED) {
 262                 BT_ERR("Don't have a privilege to use this API");
 263                 return BLUETOOTH_ERROR_PERMISSION_DEINED;
 264         }
 265
 266         user_info = _bt_get_user_data(BT_AVRCP);
 267         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
 268
 269         BT_INIT_PARAMS();
 270         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 271
 272         g_array_append_vals(in_param1, remote_address,
 273                                         sizeof(bluetooth_device_address_t));
 274
 275         result = _bt_send_request_async(BT_BLUEZ_SERVICE,
 276                                 BT_AVRCP_CONTROL_DISCONNECT, in_param1,
 277                                 in_param2, in_param3, in_param4,
 278                                 user_info->cb, user_info->user_data);
 279
 280         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 281
 282         return result;
 283 }
 284
 285 BT_EXPORT_API int bluetooth_media_target_connect(
 286                         bluetooth_device_address_t *remote_address)
 287 {
 288         int result;
 289         bt_user_info_t *user_info;
 290
 291         BT_CHECK_PARAMETER(remote_address, return);
 292         BT_CHECK_ENABLED(return);
 293
 294         if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_AVRCP_TARGET_CONNECT)
 295                         == BLUETOOTH_ERROR_PERMISSION_DEINED) {
 296                 BT_ERR("Don't have a privilege to use this API");
 297                 return BLUETOOTH_ERROR_PERMISSION_DEINED;
 298         }
 299
 300         if (_bt_check_dpm(BT_DPM_AVRCP, NULL) == BT_DPM_RESTRICTED) {
 301                 BT_ERR("Not allow to use AVRCP profile");
 302                 return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
 303         }
 304
 305         user_info = _bt_get_user_data(BT_AVRCP);
 306         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
 307
 308         BT_INIT_PARAMS();
 309         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 310
 311         g_array_append_vals(in_param1, remote_address,
 312                                         sizeof(bluetooth_device_address_t));
 313
 314         result = _bt_send_request_async(BT_BLUEZ_SERVICE,
 315                                 BT_AVRCP_TARGET_CONNECT, in_param1,
 316                                 in_param2, in_param3, in_param4,
 317                                 user_info->cb, user_info->user_data);
 318
 319         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 320
 321         return result;
 322 }
 323
 324 BT_EXPORT_API int bluetooth_media_target_disconnect(
 325                         bluetooth_device_address_t *remote_address)
 326 {
 327         int result;
 328         bt_user_info_t *user_info;
 329
 330         BT_CHECK_PARAMETER(remote_address, return);
 331         BT_CHECK_ENABLED(return);
 332
 333         if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_AVRCP_TARGET_DISCONNECT)
 334                                 == BLUETOOTH_ERROR_PERMISSION_DEINED) {
 335                 BT_ERR("Don't have a privilege to use this API");
 336                 return BLUETOOTH_ERROR_PERMISSION_DEINED;
 337         }
 338
 339         user_info = _bt_get_user_data(BT_AVRCP);
 340         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
 341
 342         BT_INIT_PARAMS();
 343         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 344
 345         g_array_append_vals(in_param1, remote_address,
 346                                         sizeof(bluetooth_device_address_t));
 347
 348         result = _bt_send_request_async(BT_BLUEZ_SERVICE,
 349                                 BT_AVRCP_TARGET_DISCONNECT, in_param1,
 350                                 in_param2, in_param3, in_param4,
 351                                 user_info->cb, user_info->user_data);
 352
 353         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 354
 355         return result;
 356 }
 357
 358 BT_EXPORT_API int bluetooth_media_control_command(
 359                                                 media_player_control_cmd type)
 360 {
 361         int result;
 362
 363         BT_CHECK_ENABLED(return);
 364
 365         if (_bt_check_dpm(BT_DPM_AVRCP, NULL) == BT_DPM_RESTRICTED) {
 366                 BT_ERR("Not allow to use AVRCP profile");
 367                 return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
 368         }
 369
 370         BT_INIT_PARAMS();
 371         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 372
 373         g_array_append_vals(in_param1, &type, sizeof(int));
 374
 375         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_AVRCP_HANDLE_CONTROL,
 376                 in_param1, in_param2, in_param3, in_param4, &out_param);
 377
 378         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 379
 380         return result;
 381 }
 382
 383 BT_EXPORT_API int bluetooth_media_control_command_to_dest(
 384                                                 media_player_control_cmd type,
 385                                                 bluetooth_device_address_t *remote_address)
 386 {
 387         int result;
 388
 389         BT_CHECK_ENABLED(return);
 390
 391         if (_bt_check_dpm(BT_DPM_AVRCP, NULL) == BT_DPM_RESTRICTED) {
 392                 BT_ERR("Not allow to use AVRCP profile");
 393                 return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
 394         }
 395
 396         BT_INIT_PARAMS();
 397         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 398
 399         g_array_append_vals(in_param1, &type, sizeof(int));
 400         g_array_append_vals(in_param2, remote_address,
 401                                                 sizeof(bluetooth_device_address_t));
 402
 403         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_AVRCP_HANDLE_CONTROL_TO_DEST,
 404                 in_param1, in_param2, in_param3, in_param4, &out_param);
 405
 406         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 407
 408         return result;
 409 }
 410
 411 BT_EXPORT_API int bluetooth_media_control_set_property(
 412                                                 media_player_property_type type,
 413                                                 unsigned int value)
 414 {
 415         int result;
 416
 417         BT_CHECK_ENABLED(return);
 418
 419         if (_bt_check_dpm(BT_DPM_AVRCP, NULL) == BT_DPM_RESTRICTED) {
 420                 BT_ERR("Not allow to use AVRCP profile");
 421                 return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
 422         }
 423
 424         BT_INIT_PARAMS();
 425         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 426
 427         g_array_append_vals(in_param1, &type, sizeof(int));
 428         g_array_append_vals(in_param2, &value, sizeof(unsigned int));
 429
 430         result = _bt_send_request(BT_BLUEZ_SERVICE,
 431                                 BT_AVRCP_CONTROL_SET_PROPERTY,
 432                                 in_param1, in_param2, in_param3,
 433                                 in_param4, &out_param);
 434
 435         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 436
 437         return result;
 438 }
 439
 440 BT_EXPORT_API int bluetooth_media_control_get_property(
 441                                         media_player_property_type type,
 442                                         unsigned int *value)
 443 {
 444         int result;
 445
 446         BT_CHECK_PARAMETER(value, return);
 447         BT_CHECK_ENABLED(return);
 448
 449         if (_bt_check_dpm(BT_DPM_AVRCP, NULL) == BT_DPM_RESTRICTED) {
 450                 BT_ERR("Not allow to use AVRCP profile");
 451                 return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
 452         }
 453
 454         BT_INIT_PARAMS();
 455         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 456         g_array_append_vals(in_param1, &type, sizeof(int));
 457
 458         result = _bt_send_request(BT_BLUEZ_SERVICE,
 459                                 BT_AVRCP_CONTROL_GET_PROPERTY,
 460                                 in_param1, in_param2, in_param3,
 461                                 in_param4, &out_param);
 462
 463         if (result == BLUETOOTH_ERROR_NONE)
 464                 *value = g_array_index(out_param, int, 0);
 465
 466         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 467
 468         return result;
 469 }
 470
 471 BT_EXPORT_API int bluetooth_media_transport_set_property(
 472                                                 media_transport_property_type type,
 473                                                 unsigned int value)
 474 {
 475         int result;
 476
 477         BT_CHECK_ENABLED(return);
 478
 479         if (_bt_check_dpm(BT_DPM_AVRCP, NULL) == BT_DPM_RESTRICTED) {
 480                 BT_ERR("Not allow to use AVRCP profile");
 481                 return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
 482         }
 483
 484         BT_INIT_PARAMS();
 485         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 486
 487         g_array_append_vals(in_param1, &type, sizeof(int));
 488         g_array_append_vals(in_param2, &value, sizeof(unsigned int));
 489
 490         result = _bt_send_request(BT_BLUEZ_SERVICE,
 491                                 BT_AVRCP_TRANSPORT_SET_PROPERTY,
 492                                 in_param1, in_param2, in_param3,
 493                                 in_param4, &out_param);
 494
 495         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 496
 497         return result;
 498 }
 499
 500 BT_EXPORT_API int bluetooth_media_control_get_track_info(
 501                 media_metadata_attributes_t *metadata)
 502 {
 503         int result;
 504         media_metadata_t *meta_data;
 505
 506         BT_CHECK_PARAMETER(metadata, return);
 507         BT_CHECK_ENABLED(return);
 508
 509         if (_bt_check_dpm(BT_DPM_AVRCP, NULL) == BT_DPM_RESTRICTED) {
 510                 BT_ERR("Not allow to use AVRCP profile");
 511                 return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
 512         }
 513
 514         BT_INIT_PARAMS();
 515         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 516
 517         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_AVRCP_GET_TRACK_INFO,
 518                 in_param1, in_param2, in_param3, in_param4, &out_param);
 519
 520         meta_data = &g_array_index(out_param, media_metadata_t, 0);
 521
 522         metadata->title = g_strdup(meta_data->title);
 523         metadata->artist = g_strdup(meta_data->artist);
 524         metadata->album = g_strdup(meta_data->album);
 525         metadata->genre = g_strdup(meta_data->genre);
 526         metadata->total_tracks = meta_data->total_tracks;
 527         metadata->number = meta_data->number;
 528         metadata->duration = (int64_t) meta_data->duration;
 529
 530         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 531
 532         return result;
 533 }