bt-api/bt-avrcp.c

   1 /*
   2  * Bluetooth-frwk
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact:  Hocheol Seo <hocheol.seo@samsung.com>
   7  *               Girishashok Joshi <girish.joshi@samsung.com>
   8  *               Chanyeol Park <chanyeol.park@samsung.com>
   9  *
  10  * Licensed under the Apache License, Version 2.0 (the "License");
  11  * you may not use this file except in compliance with the License.
  12  * You may obtain a copy of the License at
  13  *
  14  *              http://www.apache.org/licenses/LICENSE-2.0
  15  *
  16  * Unless required by applicable law or agreed to in writing, software
  17  * distributed under the License is distributed on an "AS IS" BASIS,
  18  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  19  * See the License for the specific language governing permissions and
  20  * limitations under the License.
  21  *
  22  */
  23
  24 #include <string.h>
  25
  26 #include "bluetooth-api.h"
  27 #include "bluetooth-media-control.h"
  28 #include "bt-internal-types.h"
  29
  30 #include "bt-common.h"
  31 #include "bt-request-sender.h"
  32 #include "bt-event-handler.h"
  33
  34 BT_EXPORT_API int bluetooth_media_player_init(media_cb_func_ptr callback_ptr,
  35                                                 void *user_data)
  36 {
  37         int ret;
  38
  39         /* Register AVRCP events */
  40         ret = _bt_register_event(BT_AVRCP_EVENT , (void *)callback_ptr, user_data);
  41
  42         if (ret != BLUETOOTH_ERROR_NONE &&
  43              ret != BLUETOOTH_ERROR_ALREADY_INITIALIZED) {
  44                 BT_ERR("Fail to init the event handler");
  45                 return ret;
  46         }
  47
  48         _bt_set_user_data(BT_AVRCP, (void *)callback_ptr, user_data);
  49
  50         return BLUETOOTH_ERROR_NONE;
  51 }
  52
  53 BT_EXPORT_API int bluetooth_media_player_deinit(void)
  54 {
  55         int ret;
  56
  57         ret = _bt_unregister_event(BT_AVRCP_EVENT);
  58
  59         if (ret != BLUETOOTH_ERROR_NONE) {
  60                 BT_ERR("Fail to deinit the event handler");
  61                 return ret;
  62         }
  63
  64         _bt_set_user_data(BT_AVRCP, NULL, NULL);
  65
  66         return BLUETOOTH_ERROR_NONE;
  67 }
  68
  69 BT_EXPORT_API int bluetooth_media_player_change_property(
  70                         media_player_property_type type,
  71                         unsigned int value)
  72 {
  73         int result;
  74
  75         BT_CHECK_ENABLED(return);
  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         BT_INIT_PARAMS();
 100         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 101
 102         g_array_append_vals(in_param1, setting, sizeof(media_player_settings_t));
 103
 104         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_AVRCP_SET_PROPERTIES,
 105                 in_param1, in_param2, in_param3, in_param4, &out_param);
 106
 107         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 108
 109         return result;
 110 }
 111
 112 BT_EXPORT_API int bluetooth_media_player_change_track(
 113                 media_metadata_attributes_t *metadata)
 114 {
 115         int result;
 116         media_metadata_t meta_data;
 117
 118         BT_CHECK_PARAMETER(metadata, return);
 119         BT_CHECK_ENABLED(return);
 120
 121         BT_INIT_PARAMS();
 122         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 123
 124         memset(&meta_data, 0x00, sizeof(media_metadata_t));
 125
 126         if (_bt_copy_utf8_string(meta_data.title, metadata->title, BT_META_DATA_MAX_LEN))
 127                 BT_ERR("Error in copying Title\n");
 128         if (_bt_copy_utf8_string(meta_data.artist, metadata->artist, BT_META_DATA_MAX_LEN))
 129                 BT_ERR("Error in copying Artist\n");
 130         if (_bt_copy_utf8_string(meta_data.album, metadata->album, BT_META_DATA_MAX_LEN))
 131                 BT_ERR("Error in copying Album\n");
 132         if (_bt_copy_utf8_string(meta_data.genre, metadata->genre, BT_META_DATA_MAX_LEN))
 133                 BT_ERR("Error in copying Genre\n");
 134
 135         if (_bt_utf8_validate(meta_data.title) == FALSE)
 136                 meta_data.title[0] = '\0';
 137
 138         if (_bt_utf8_validate(meta_data.artist) == FALSE)
 139                 meta_data.artist[0] = '\0';
 140
 141         if (_bt_utf8_validate(meta_data.album) == FALSE)
 142                 meta_data.album[0] = '\0';
 143
 144         if (_bt_utf8_validate(meta_data.genre) == FALSE)
 145                 meta_data.genre[0] = '\0';
 146
 147         meta_data.total_tracks = metadata->total_tracks;
 148         meta_data.number = metadata->number;
 149         meta_data.duration = metadata->duration;
 150
 151         g_array_append_vals(in_param1, &meta_data, sizeof(media_metadata_t));
 152
 153         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_AVRCP_SET_TRACK_INFO,
 154                 in_param1, in_param2, in_param3, in_param4, &out_param);
 155
 156         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 157
 158         return result;
 159 }
 160
 161 BT_EXPORT_API int bluetooth_media_control_init(media_cb_func_ptr callback_ptr,
 162                                                 void *user_data)
 163 {
 164         int ret;
 165
 166         /* Register AVRCP events */
 167         ret = _bt_register_event(BT_AVRCP_CONTROL_EVENT,
 168                                         (void *)callback_ptr, user_data);
 169
 170         if (ret != BLUETOOTH_ERROR_NONE &&
 171                         ret != BLUETOOTH_ERROR_ALREADY_INITIALIZED) {
 172                 BT_ERR("Fail to init the event handler");
 173                 return ret;
 174         }
 175
 176         _bt_set_user_data(BT_AVRCP, (void *)callback_ptr, user_data);
 177
 178         return BLUETOOTH_ERROR_NONE;
 179 }
 180
 181 BT_EXPORT_API int bluetooth_media_control_deinit(void)
 182 {
 183         int ret;
 184
 185         ret = _bt_unregister_event(BT_AVRCP_CONTROL_EVENT);
 186
 187         if (ret != BLUETOOTH_ERROR_NONE) {
 188                 BT_ERR("Fail to deinit the event handler");
 189                 return ret;
 190         }
 191
 192         _bt_set_user_data(BT_AVRCP, NULL, NULL);
 193
 194         return BLUETOOTH_ERROR_NONE;
 195 }
 196
 197 BT_EXPORT_API int bluetooth_media_control_connect(
 198                         bluetooth_device_address_t *remote_address)
 199 {
 200         int result;
 201         bt_user_info_t *user_info;
 202
 203         BT_CHECK_PARAMETER(remote_address, return);
 204         BT_CHECK_ENABLED(return);
 205
 206         if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_AVRCP_CONTROL_CONNECT)
 207                         == BLUETOOTH_ERROR_PERMISSION_DEINED) {
 208                 BT_ERR("Don't have a privilege to use this API");
 209                 return BLUETOOTH_ERROR_PERMISSION_DEINED;
 210         }
 211
 212         user_info = _bt_get_user_data(BT_AVRCP);
 213         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
 214
 215         BT_INIT_PARAMS();
 216         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 217
 218         g_array_append_vals(in_param1, remote_address,
 219                                         sizeof(bluetooth_device_address_t));
 220
 221         result = _bt_send_request_async(BT_BLUEZ_SERVICE,
 222                                 BT_AVRCP_CONTROL_CONNECT, in_param1,
 223                                 in_param2, in_param3, in_param4,
 224                                 user_info->cb, user_info->user_data);
 225
 226         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 227
 228         return result;
 229 }
 230
 231 BT_EXPORT_API int bluetooth_media_control_disconnect(
 232                         bluetooth_device_address_t *remote_address)
 233 {
 234         int result;
 235         bt_user_info_t *user_info;
 236
 237         BT_CHECK_PARAMETER(remote_address, return);
 238         BT_CHECK_ENABLED(return);
 239
 240         if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_AVRCP_CONTROL_DISCONNECT)
 241                                 == BLUETOOTH_ERROR_PERMISSION_DEINED) {
 242                 BT_ERR("Don't have a privilege to use this API");
 243                 return BLUETOOTH_ERROR_PERMISSION_DEINED;
 244         }
 245
 246         user_info = _bt_get_user_data(BT_AVRCP);
 247         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
 248
 249         BT_INIT_PARAMS();
 250         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 251
 252         g_array_append_vals(in_param1, remote_address,
 253                                         sizeof(bluetooth_device_address_t));
 254
 255         result = _bt_send_request_async(BT_BLUEZ_SERVICE,
 256                                 BT_AVRCP_CONTROL_DISCONNECT, in_param1,
 257                                 in_param2, in_param3, in_param4,
 258                                 user_info->cb, user_info->user_data);
 259
 260         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 261
 262         return result;
 263 }
 264
 265 BT_EXPORT_API int bluetooth_media_control_command(
 266                                                 media_player_control_cmd type)
 267 {
 268         int result;
 269
 270         BT_CHECK_ENABLED(return);
 271
 272         BT_INIT_PARAMS();
 273         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 274
 275         g_array_append_vals(in_param1, &type, sizeof(int));
 276
 277         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_AVRCP_HANDLE_CONTROL,
 278                 in_param1, in_param2, in_param3, in_param4, &out_param);
 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_control_set_property(
 286                                                 media_player_property_type type,
 287                                                 unsigned int value)
 288 {
 289         int result;
 290
 291         BT_CHECK_ENABLED(return);
 292
 293         BT_INIT_PARAMS();
 294         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 295
 296         g_array_append_vals(in_param1, &type, sizeof(int));
 297         g_array_append_vals(in_param2, &value, sizeof(unsigned int));
 298
 299         result = _bt_send_request(BT_BLUEZ_SERVICE,
 300                                 BT_AVRCP_CONTROL_SET_PROPERTY,
 301                                 in_param1, in_param2, in_param3,
 302                                 in_param4, &out_param);
 303
 304         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 305
 306         return result;
 307 }
 308
 309 BT_EXPORT_API int bluetooth_media_control_get_property(
 310                                         media_player_property_type type,
 311                                         unsigned int *value)
 312 {
 313         int result;
 314
 315         BT_CHECK_PARAMETER(value, return);
 316         BT_CHECK_ENABLED(return);
 317
 318         BT_INIT_PARAMS();
 319         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 320         g_array_append_vals(in_param1, &type, sizeof(int));
 321
 322         result = _bt_send_request(BT_BLUEZ_SERVICE,
 323                                 BT_AVRCP_CONTROL_GET_PROPERTY,
 324                                 in_param1, in_param2, in_param3,
 325                                 in_param4, &out_param);
 326
 327         if (result == BLUETOOTH_ERROR_NONE)
 328                 *value = g_array_index(out_param, int, 0);
 329
 330         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 331
 332         return result;
 333 }
 334
 335 BT_EXPORT_API int bluetooth_media_control_get_track_info(
 336                 media_metadata_attributes_t *metadata)
 337 {
 338         int result;
 339         media_metadata_t meta_data;
 340
 341         BT_CHECK_PARAMETER(metadata, return);
 342         BT_CHECK_ENABLED(return);
 343
 344         BT_INIT_PARAMS();
 345         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 346
 347         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_AVRCP_GET_TRACK_INFO,
 348                 in_param1, in_param2, in_param3, in_param4, &out_param);
 349
 350         memset(&meta_data, 0x00, sizeof(media_metadata_t));
 351
 352         meta_data = g_array_index(out_param, media_metadata_t, 0);
 353
 354         metadata->title = g_strdup(meta_data.title);
 355         metadata->artist = g_strdup(meta_data.artist);
 356         metadata->album = g_strdup(meta_data.album);
 357         metadata->genre = g_strdup(meta_data.genre);
 358         metadata->total_tracks = meta_data.total_tracks;
 359         metadata->number = meta_data.number;
 360         metadata->duration = (int64_t) meta_data.duration;
 361
 362         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 363
 364         return result;
 365 }