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