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 #ifdef TIZEN_DPM_ENABLE
  28 #include "bt-dpm.h"
  29 #endif
  30
  31
  32 BT_EXPORT_API int bluetooth_media_player_init(media_cb_func_ptr callback_ptr,
  33                                                 void *user_data)
  34 {
  35         int ret;
  36
  37         /* Register AVRCP events */
  38         ret = _bt_register_event(BT_AVRCP_EVENT , (void *)callback_ptr, user_data);
  39
  40         if (ret != BLUETOOTH_ERROR_NONE &&
  41              ret != BLUETOOTH_ERROR_ALREADY_INITIALIZED) {
  42                 BT_ERR("Fail to init the event handler");
  43                 return ret;
  44         }
  45
  46         _bt_set_user_data(BT_AVRCP, (void *)callback_ptr, user_data);
  47
  48         return BLUETOOTH_ERROR_NONE;
  49 }
  50
  51 BT_EXPORT_API int bluetooth_media_player_deinit(void)
  52 {
  53         int ret;
  54
  55         ret = _bt_unregister_event(BT_AVRCP_EVENT);
  56
  57         if (ret != BLUETOOTH_ERROR_NONE) {
  58                 BT_ERR("Fail to deinit the event handler");
  59                 return ret;
  60         }
  61
  62         _bt_set_user_data(BT_AVRCP, NULL, NULL);
  63
  64         return BLUETOOTH_ERROR_NONE;
  65 }
  66
  67 BT_EXPORT_API int bluetooth_media_player_change_property(
  68                         media_player_property_type type,
  69                         unsigned int value)
  70 {
  71         int result;
  72
  73         BT_CHECK_ENABLED(return);
  74
  75 #ifdef TIZEN_DPM_ENABLE
  76         if (_bt_check_dpm(BT_DPM_AVRCP, NULL) == BT_DPM_RESTRICTED) {
  77                 BT_ERR("Not allow to use AVRCP profile");
  78                 return BLUETOOTH_ERROR_ACCESS_DENIED;
  79         }
  80 #endif
  81
  82         BT_INIT_PARAMS();
  83         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
  84
  85         g_array_append_vals(in_param1, &type, sizeof(int));
  86         g_array_append_vals(in_param2, &value, sizeof(unsigned int));
  87
  88         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_AVRCP_SET_PROPERTY,
  89                 in_param1, in_param2, in_param3, in_param4, &out_param);
  90
  91         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
  92
  93         return result;
  94 }
  95
  96 BT_EXPORT_API int bluetooth_media_player_set_properties(
  97                         media_player_settings_t *setting)
  98 {
  99         int result;
 100
 101         BT_CHECK_PARAMETER(setting, return);
 102         BT_CHECK_ENABLED(return);
 103
 104 #ifdef TIZEN_DPM_ENABLE
 105         if (_bt_check_dpm(BT_DPM_AVRCP, NULL) == BT_DPM_RESTRICTED) {
 106                 BT_ERR("Not allow to use AVRCP profile");
 107                 return BLUETOOTH_ERROR_ACCESS_DENIED;
 108         }
 109 #endif
 110
 111         BT_INIT_PARAMS();
 112         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 113
 114         g_array_append_vals(in_param1, setting, sizeof(media_player_settings_t));
 115
 116         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_AVRCP_SET_PROPERTIES,
 117                 in_param1, in_param2, in_param3, in_param4, &out_param);
 118
 119         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 120
 121         return result;
 122 }
 123
 124 BT_EXPORT_API int bluetooth_media_player_change_track(
 125                 media_metadata_attributes_t *metadata)
 126 {
 127         int result;
 128         media_metadata_t meta_data;
 129
 130         BT_CHECK_PARAMETER(metadata, return);
 131         BT_CHECK_ENABLED(return);
 132
 133 #ifdef TIZEN_DPM_ENABLE
 134         if (_bt_check_dpm(BT_DPM_AVRCP, NULL) == BT_DPM_RESTRICTED) {
 135                 BT_ERR("Not allow to use AVRCP profile");
 136                 return BLUETOOTH_ERROR_ACCESS_DENIED;
 137         }
 138 #endif
 139
 140         BT_INIT_PARAMS();
 141         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 142
 143         memset(&meta_data, 0x00, sizeof(media_metadata_t));
 144
 145         if (_bt_copy_utf8_string(meta_data.title, metadata->title, BT_META_DATA_MAX_LEN))
 146                 BT_ERR("Error in copying Title\n");
 147         if (_bt_copy_utf8_string(meta_data.artist, metadata->artist, BT_META_DATA_MAX_LEN))
 148                 BT_ERR("Error in copying Artist\n");
 149         if (_bt_copy_utf8_string(meta_data.album, metadata->album, BT_META_DATA_MAX_LEN))
 150                 BT_ERR("Error in copying Album\n");
 151         if (_bt_copy_utf8_string(meta_data.genre, metadata->genre, BT_META_DATA_MAX_LEN))
 152                 BT_ERR("Error in copying Genre\n");
 153
 154         if (_bt_utf8_validate(meta_data.title) == FALSE)
 155                 meta_data.title[0] = '\0';
 156
 157         if (_bt_utf8_validate(meta_data.artist) == FALSE)
 158                 meta_data.artist[0] = '\0';
 159
 160         if (_bt_utf8_validate(meta_data.album) == FALSE)
 161                 meta_data.album[0] = '\0';
 162
 163         if (_bt_utf8_validate(meta_data.genre) == FALSE)
 164                 meta_data.genre[0] = '\0';
 165
 166         meta_data.total_tracks = metadata->total_tracks;
 167         meta_data.number = metadata->number;
 168         meta_data.duration = metadata->duration;
 169
 170         g_array_append_vals(in_param1, &meta_data, sizeof(media_metadata_t));
 171
 172         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_AVRCP_SET_TRACK_INFO,
 173                 in_param1, in_param2, in_param3, in_param4, &out_param);
 174
 175         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 176
 177         return result;
 178 }
 179
 180 BT_EXPORT_API int bluetooth_media_control_init(media_cb_func_ptr callback_ptr,
 181                                                 void *user_data)
 182 {
 183         int ret;
 184
 185         /* Register AVRCP events */
 186         ret = _bt_register_event(BT_AVRCP_CONTROL_EVENT,
 187                                         (void *)callback_ptr, user_data);
 188
 189         if (ret != BLUETOOTH_ERROR_NONE &&
 190                         ret != BLUETOOTH_ERROR_ALREADY_INITIALIZED) {
 191                 BT_ERR("Fail to init the event handler");
 192                 return ret;
 193         }
 194
 195         _bt_set_user_data(BT_AVRCP, (void *)callback_ptr, user_data);
 196
 197         return BLUETOOTH_ERROR_NONE;
 198 }
 199
 200 BT_EXPORT_API int bluetooth_media_control_deinit(void)
 201 {
 202         int ret;
 203
 204         ret = _bt_unregister_event(BT_AVRCP_CONTROL_EVENT);
 205
 206         if (ret != BLUETOOTH_ERROR_NONE) {
 207                 BT_ERR("Fail to deinit the event handler");
 208                 return ret;
 209         }
 210
 211         _bt_set_user_data(BT_AVRCP, NULL, NULL);
 212
 213         return BLUETOOTH_ERROR_NONE;
 214 }
 215
 216 BT_EXPORT_API int bluetooth_media_control_connect(
 217                         bluetooth_device_address_t *remote_address)
 218 {
 219         int result;
 220         bt_user_info_t *user_info;
 221
 222         BT_CHECK_PARAMETER(remote_address, return);
 223         BT_CHECK_ENABLED(return);
 224
 225         if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_AVRCP_CONTROL_CONNECT)
 226                         == BLUETOOTH_ERROR_PERMISSION_DEINED) {
 227                 BT_ERR("Don't have a privilege to use this API");
 228                 return BLUETOOTH_ERROR_PERMISSION_DEINED;
 229         }
 230
 231 #ifdef TIZEN_DPM_ENABLE
 232         if (_bt_check_dpm(BT_DPM_ADDRESS, remote_address) == BT_DPM_RESTRICTED) {
 233                 BT_ERR("Blacklist device");
 234                 return BLUETOOTH_ERROR_ACCESS_DENIED;
 235         }
 236
 237         if (_bt_check_dpm(BT_DPM_AVRCP, NULL) == BT_DPM_RESTRICTED) {
 238                 BT_ERR("Not allow to use AVRCP profile");
 239                 return BLUETOOTH_ERROR_ACCESS_DENIED;
 240         }
 241 #endif
 242
 243         user_info = _bt_get_user_data(BT_AVRCP);
 244         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
 245
 246         BT_INIT_PARAMS();
 247         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 248
 249         g_array_append_vals(in_param1, remote_address,
 250                                         sizeof(bluetooth_device_address_t));
 251
 252         result = _bt_send_request_async(BT_BLUEZ_SERVICE,
 253                                 BT_AVRCP_CONTROL_CONNECT, in_param1,
 254                                 in_param2, in_param3, in_param4,
 255                                 user_info->cb, user_info->user_data);
 256
 257         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 258
 259         return result;
 260 }
 261
 262 BT_EXPORT_API int bluetooth_media_control_disconnect(
 263                         bluetooth_device_address_t *remote_address)
 264 {
 265         int result;
 266         bt_user_info_t *user_info;
 267
 268         BT_CHECK_PARAMETER(remote_address, return);
 269         BT_CHECK_ENABLED(return);
 270
 271         if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_AVRCP_CONTROL_DISCONNECT)
 272                                 == BLUETOOTH_ERROR_PERMISSION_DEINED) {
 273                 BT_ERR("Don't have a privilege to use this API");
 274                 return BLUETOOTH_ERROR_PERMISSION_DEINED;
 275         }
 276
 277         user_info = _bt_get_user_data(BT_AVRCP);
 278         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
 279
 280         BT_INIT_PARAMS();
 281         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 282
 283         g_array_append_vals(in_param1, remote_address,
 284                                         sizeof(bluetooth_device_address_t));
 285
 286         result = _bt_send_request_async(BT_BLUEZ_SERVICE,
 287                                 BT_AVRCP_CONTROL_DISCONNECT, in_param1,
 288                                 in_param2, in_param3, in_param4,
 289                                 user_info->cb, user_info->user_data);
 290
 291         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 292
 293         return result;
 294 }
 295
 296 BT_EXPORT_API int bluetooth_media_control_command(
 297                                                 media_player_control_cmd type)
 298 {
 299         int result;
 300
 301         BT_CHECK_ENABLED(return);
 302
 303 #ifdef TIZEN_DPM_ENABLE
 304         if (_bt_check_dpm(BT_DPM_AVRCP, NULL) == BT_DPM_RESTRICTED) {
 305                 BT_ERR("Not allow to use AVRCP profile");
 306                 return BLUETOOTH_ERROR_ACCESS_DENIED;
 307         }
 308 #endif
 309
 310         BT_INIT_PARAMS();
 311         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 312
 313         g_array_append_vals(in_param1, &type, sizeof(int));
 314
 315         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_AVRCP_HANDLE_CONTROL,
 316                 in_param1, in_param2, in_param3, in_param4, &out_param);
 317
 318         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 319
 320         return result;
 321 }
 322
 323 BT_EXPORT_API int bluetooth_media_control_set_property(
 324                                                 media_player_property_type type,
 325                                                 unsigned int value)
 326 {
 327         int result;
 328
 329         BT_CHECK_ENABLED(return);
 330
 331 #ifdef TIZEN_DPM_ENABLE
 332         if (_bt_check_dpm(BT_DPM_AVRCP, NULL) == BT_DPM_RESTRICTED) {
 333                 BT_ERR("Not allow to use AVRCP profile");
 334                 return BLUETOOTH_ERROR_ACCESS_DENIED;
 335         }
 336 #endif
 337
 338         BT_INIT_PARAMS();
 339         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 340
 341         g_array_append_vals(in_param1, &type, sizeof(int));
 342         g_array_append_vals(in_param2, &value, sizeof(unsigned int));
 343
 344         result = _bt_send_request(BT_BLUEZ_SERVICE,
 345                                 BT_AVRCP_CONTROL_SET_PROPERTY,
 346                                 in_param1, in_param2, in_param3,
 347                                 in_param4, &out_param);
 348
 349         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 350
 351         return result;
 352 }
 353
 354 BT_EXPORT_API int bluetooth_media_control_get_property(
 355                                         media_player_property_type type,
 356                                         unsigned int *value)
 357 {
 358         int result;
 359
 360         BT_CHECK_PARAMETER(value, return);
 361         BT_CHECK_ENABLED(return);
 362
 363 #ifdef TIZEN_DPM_ENABLE
 364         if (_bt_check_dpm(BT_DPM_AVRCP, NULL) == BT_DPM_RESTRICTED) {
 365                 BT_ERR("Not allow to use AVRCP profile");
 366                 return BLUETOOTH_ERROR_ACCESS_DENIED;
 367         }
 368 #endif
 369
 370         BT_INIT_PARAMS();
 371         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 372         g_array_append_vals(in_param1, &type, sizeof(int));
 373
 374         result = _bt_send_request(BT_BLUEZ_SERVICE,
 375                                 BT_AVRCP_CONTROL_GET_PROPERTY,
 376                                 in_param1, in_param2, in_param3,
 377                                 in_param4, &out_param);
 378
 379         if (result == BLUETOOTH_ERROR_NONE)
 380                 *value = g_array_index(out_param, int, 0);
 381
 382         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 383
 384         return result;
 385 }
 386
 387 BT_EXPORT_API int bluetooth_media_control_get_track_info(
 388                 media_metadata_attributes_t *metadata)
 389 {
 390         int result;
 391         media_metadata_t meta_data;
 392
 393         BT_CHECK_PARAMETER(metadata, return);
 394         BT_CHECK_ENABLED(return);
 395
 396 #ifdef TIZEN_DPM_ENABLE
 397         if (_bt_check_dpm(BT_DPM_AVRCP, NULL) == BT_DPM_RESTRICTED) {
 398                 BT_ERR("Not allow to use AVRCP profile");
 399                 return BLUETOOTH_ERROR_ACCESS_DENIED;
 400         }
 401 #endif
 402
 403         BT_INIT_PARAMS();
 404         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 405
 406         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_AVRCP_GET_TRACK_INFO,
 407                 in_param1, in_param2, in_param3, in_param4, &out_param);
 408
 409         memset(&meta_data, 0x00, sizeof(media_metadata_t));
 410
 411         meta_data = g_array_index(out_param, media_metadata_t, 0);
 412
 413         metadata->title = g_strdup(meta_data.title);
 414         metadata->artist = g_strdup(meta_data.artist);
 415         metadata->album = g_strdup(meta_data.album);
 416         metadata->genre = g_strdup(meta_data.genre);
 417         metadata->total_tracks = meta_data.total_tracks;
 418         metadata->number = meta_data.number;
 419         metadata->duration = (int64_t) meta_data.duration;
 420
 421         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 422
 423         return result;
 424 }