src/mdg.c

   1 /*
   2  * Copyright (c) 2018 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 <stdio.h>
  19 #include <unistd.h>
  20 #include <stdlib.h>
  21
  22 #include <dlog.h>
  23 #include <mdg.h>
  24 #include <mdg_util.h>
  25 #include <mdg_dbus.h>
  26 #include <mdg_debug.h>
  27 #include <mdg_gdbus.h>
  28 #include <mdg_private.h>
  29
  30 GSList *handle_list = NULL;
  31
  32 EXPORT_API int mdg_initialize(mdg_h *handle)
  33 {
  34         int ret = MDG_ERROR_NONE;
  35         struct mdg_manager_s *mdg_manager = NULL;
  36
  37         CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
  38
  39         mdg_check_null_ret_error("handle", handle, MDG_ERROR_INVALID_PARAMETER);
  40
  41         _BEGIN();
  42
  43         mdg_manager = calloc(1, sizeof(mdg_manager_s));
  44         if (NULL == mdg_manager) {
  45                 /* LCOV_EXCL_START */
  46                 _ERR("Failed to create handle");
  47                 return MDG_ERROR_OUT_OF_MEMORY;
  48                 /* LCOV_EXCL_STOP */
  49         }
  50         *handle = mdg_manager;
  51
  52         ret = gdbus_initialize(*handle);
  53
  54         handle_list = g_slist_prepend(handle_list, *handle);
  55
  56         _END();
  57
  58         return ret;
  59 }
  60
  61 EXPORT_API int mdg_deinitialize(mdg_h handle)
  62 {
  63         int ret = MDG_ERROR_NONE;
  64
  65         CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
  66         CHECK_HANDLE_IS_VALID(handle);
  67
  68         _BEGIN();
  69
  70         handle_list = g_slist_remove(handle_list, handle);
  71
  72         ret = gdbus_deinitialize(handle);
  73
  74         _END();
  75
  76         return ret;
  77 }
  78
  79 EXPORT_API int mdg_group_create(mdg_h handle, char *group_name)
  80 {
  81         int ret = MDG_ERROR_NONE;
  82         GError *error = NULL;
  83
  84         CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
  85
  86         mdg_manager_s *_handle = handle;
  87         mdg_check_null_ret_error("handle", handle, MDG_ERROR_INVALID_PARAMETER);
  88         CHECK_HANDLE_IS_VALID(handle);
  89
  90         /* create group to daemon using gdbus */
  91         group_call_create_sync(_handle->group_proxy, group_name, &ret, NULL, &error);
  92
  93         return ret;
  94 }
  95
  96 EXPORT_API void mdg_group_destroy(mdg_group_s *group)
  97 {
  98         CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
  99
 100         mdg_check_null_ret("group", group);
 101
 102         if (group->device_id) {
 103                 g_free(group->device_id);
 104                 group->device_id = NULL;
 105         }
 106         if (group->group_name) {
 107                 g_free(group->group_name);
 108                 group->group_name = NULL;
 109         }
 110
 111         g_free(group);
 112         group = NULL;
 113 }
 114
 115 EXPORT_API int mdg_group_find(mdg_h handle, int timeout,
 116         mdg_group_found_cb found_cb, mdg_group_find_finish_cb finish_cb,
 117         void *user_data)
 118 {
 119         int ret = MDG_ERROR_NONE;
 120         GError *error = NULL;
 121
 122         CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
 123
 124         mdg_manager_s *_handle = handle;
 125         mdg_check_null_ret_error("handle", handle, MDG_ERROR_INVALID_PARAMETER);
 126         CHECK_HANDLE_IS_VALID(handle);
 127
 128         _handle->group_found_cb.found_cb = found_cb;
 129         _handle->group_find_finish_cb.finish_cb = finish_cb;
 130         _handle->group_found_cb.user_data = user_data;
 131         _handle->group_find_finish_cb.user_data = user_data;
 132
 133         /* get groups from daemon using gdbus */
 134         group_call_find_sync(_handle->group_proxy, timeout, &ret, NULL, &error);
 135         if (error) {
 136                 _ERR("Failed DBus call [%s]", error->message);
 137                 g_error_free(error);
 138                 ret = MDG_ERROR_IO_ERROR;
 139         }
 140
 141         return ret;
 142 }
 143
 144 EXPORT_API int mdg_device_find(mdg_h handle, int timeout, bool is_invited,
 145         mdg_device_found_cb found_cb, mdg_device_find_finish_cb finish_cb,
 146         void *user_data)
 147 {
 148         int ret = MDG_ERROR_NONE;
 149         GError *error = NULL;
 150
 151         CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
 152
 153         mdg_manager_s *_handle = handle;
 154         mdg_check_null_ret_error("handle", handle, MDG_ERROR_INVALID_PARAMETER);
 155         CHECK_HANDLE_IS_VALID(handle);
 156
 157         _handle->device_found_cb.found_cb = found_cb;
 158         _handle->device_found_cb.user_data = user_data;
 159         _handle->device_find_finish_cb.finish_cb = finish_cb;
 160         _handle->device_find_finish_cb.user_data = user_data;
 161
 162         /* get groups from daemon using gdbus */
 163         group_call_find_device_sync(_handle->group_proxy, timeout, is_invited, &ret, NULL, &error);
 164         if (error) {
 165                 _ERR("Failed DBus call [%s]", error->message);
 166                 g_error_free(error);
 167                 ret = MDG_ERROR_IO_ERROR;
 168         }
 169
 170         return ret;
 171 }
 172
 173 /**
 174  * Companion Manager CAPI
 175  */
 176 int __add_channel_cb(mdg_manager_s *handle, char *channel_id, mdg_channel_cb channel_cb, void *user_data)
 177 {
 178         channel_cb_s *channel_s;
 179
 180         GSList *l1, *l2;
 181         for (l1 = handle_list; l1 != NULL; l1 = l1->next) {
 182                 mdg_manager_s *tmp_handle = (mdg_manager_s *)l1->data;
 183                 for (l2 = tmp_handle->channel_cb_list; l2 != NULL; l2 = l2->next) {
 184                         channel_cb_s *tmp_channel = (channel_cb_s *)l2->data;
 185                         if (g_strcmp0(tmp_channel->channel_id, channel_id) == 0)
 186                                 return MDG_ERROR_OPERATION_FAILED;
 187                 }
 188         }
 189
 190         channel_s = g_try_new0(channel_cb_s, 1);
 191         if (channel_s == NULL)
 192                 return MDG_ERROR_OUT_OF_MEMORY;
 193
 194         channel_s->channel_id = g_strdup(channel_id);
 195         channel_s->cb = channel_cb;
 196         channel_s->user_data = user_data;
 197
 198         handle->channel_cb_list = g_slist_prepend(handle->channel_cb_list, channel_s);
 199
 200         return 0;
 201 }
 202
 203 EXPORT_API int mdg_device_regist_channel(mdg_h handle, char *channel_id,
 204         mdg_channel_cb channel_cb, void *user_data)
 205 {
 206         int ret = MDG_ERROR_NONE;
 207         GError *error = NULL;
 208
 209         CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
 210
 211         mdg_manager_s *_handle = handle;
 212         mdg_check_null_ret_error("handle", handle, MDG_ERROR_INVALID_PARAMETER);
 213         CHECK_HANDLE_IS_VALID(_handle);
 214
 215         _BEGIN();
 216
 217         group_call_regist_channel_sync(_handle->group_proxy, channel_id, &ret, NULL, &error);
 218         if (error) {
 219                 _ERR("Failed DBus call [%s]", error->message);
 220                 g_error_free(error);
 221                 ret = MDG_ERROR_IO_ERROR;
 222         }
 223
 224         if (ret == MDG_ERROR_NONE)
 225                 ret = __add_channel_cb(handle, channel_id, channel_cb, user_data);
 226
 227         _END();
 228
 229         return ret;
 230 }
 231
 232 EXPORT_API int mdg_device_unregist_channel(mdg_h handle, char *channel_id)
 233 {
 234         int ret = MDG_ERROR_NONE;
 235         bool is_exist = false;
 236         GError *error = NULL;
 237
 238         CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
 239
 240         mdg_manager_s *_handle = handle;
 241         mdg_check_null_ret_error("handle", handle, MDG_ERROR_INVALID_PARAMETER);
 242         CHECK_HANDLE_IS_VALID(handle);
 243
 244         _BEGIN();
 245
 246         GSList *l;
 247         for (l = _handle->channel_cb_list; l != NULL; l = l->next) {
 248                 channel_cb_s *tmp_channel = (channel_cb_s *)l->data;
 249                 if (g_strcmp0(tmp_channel->channel_id, channel_id) == 0) {
 250                         g_free(tmp_channel->channel_id);
 251                         _handle->channel_cb_list = g_slist_remove_link(_handle->channel_cb_list, l);
 252                         is_exist = true;
 253                         break;
 254                 }
 255         }
 256
 257         if (is_exist == false)
 258                 ret = MDG_ERROR_OPERATION_FAILED;
 259
 260         if (ret == MDG_ERROR_NONE) {
 261                 group_call_unregist_channel_sync(_handle->group_proxy, channel_id, &ret, NULL, &error);
 262                 if (error) {
 263                         _ERR("Failed DBus call [%s]", error->message);
 264                         g_error_free(error);
 265                         ret = MDG_ERROR_IO_ERROR;
 266                 }
 267         }
 268
 269         _END();
 270
 271         return ret;
 272 }
 273
 274 EXPORT_API int mdg_device_send_data(mdg_h handle,
 275         mdg_device_h device, char *channel_id, unsigned char *data, int len,
 276         mdg_device_send_data_finish_cb finish_cb, void *user_data)
 277 {
 278         int ret = MDG_ERROR_NONE;
 279         unsigned char *buf = NULL;
 280         GVariantBuilder *bytearray_builder = NULL;
 281         int i;
 282         GVariant *params = NULL;
 283         GError *error = NULL;
 284
 285         CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
 286
 287         mdg_manager_s *_handle = handle;
 288         mdg_check_null_ret_error("handle", handle, MDG_ERROR_INVALID_PARAMETER);
 289         CHECK_HANDLE_IS_VALID(handle);
 290
 291         mdg_device_s *dev = (mdg_device_s *)device;
 292         mdg_check_null_ret_error("dev", dev, MDG_ERROR_INVALID_PARAMETER);
 293
 294         buf = g_try_malloc0(len + 1);
 295         if (NULL == buf) {
 296                 /* LCOV_EXCL_START */
 297                 _ERR("g_malloc0 is failed");
 298                 return MDG_ERROR_OUT_OF_MEMORY;
 299                 /* LCOV_EXCL_STOP */
 300         }
 301         memcpy(buf, data, len);
 302
 303         bytearray_builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
 304         for (i = 0; i < len; i++)
 305                 g_variant_builder_add(bytearray_builder, "y", buf[i]);
 306
 307         params = g_variant_new("(iay)", len, bytearray_builder);
 308         g_variant_builder_unref(bytearray_builder);
 309
 310         _handle->send_data_finish_cb.finish_cb = finish_cb;
 311         _handle->send_data_finish_cb.user_data = user_data;
 312
 313         group_call_send_data_sync(_handle->group_proxy, dev->device_id,
 314                 channel_id, params, &ret, NULL, &error);
 315         if (error) {
 316                 _ERR("Failed DBus call [%s]", error->message);
 317                 g_error_free(error);
 318                 ret = MDG_ERROR_IO_ERROR;
 319         }
 320
 321         g_free(buf);
 322         buf = NULL;
 323
 324         return ret;
 325 }
 326
 327 EXPORT_API int mdg_device_send_file(mdg_h handle, mdg_device_h device,
 328         char *file_path, mdg_send_file_progress_cb progress_cb, mdg_send_file_finish_cb finish_cb, void *user_data)
 329 {
 330         int ret = MDG_ERROR_NONE;
 331         GError *error = NULL;
 332
 333         CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
 334
 335         mdg_manager_s *_handle = handle;
 336         mdg_check_null_ret_error("handle", handle, MDG_ERROR_INVALID_PARAMETER);
 337         CHECK_HANDLE_IS_VALID(handle);
 338
 339         mdg_device_s *dev = (mdg_device_s *)device;
 340         mdg_check_null_ret_error("dev", dev, MDG_ERROR_INVALID_PARAMETER);
 341         mdg_check_null_ret_error("file_path", file_path, MDG_ERROR_INVALID_PARAMETER);
 342
 343         mdg_device_h cloned_device = NULL;
 344         mdg_device_info_clone(&cloned_device, device);
 345
 346         _handle->send_file_cb.finish_cb = finish_cb;
 347         _handle->send_file_cb.progress_cb = progress_cb;
 348         _handle->send_file_cb.device = cloned_device;
 349         _handle->send_file_cb.user_data = user_data;
 350
 351         group_call_send_file_sync(_handle->group_proxy, dev->device_id, file_path, &ret, NULL, &error);
 352         if (error) {
 353                 _ERR("Failed DBus call [%s]", error->message);
 354                 g_error_free(error);
 355                 ret = MDG_ERROR_IO_ERROR;
 356         }
 357
 358         return ret;
 359 }
 360
 361 EXPORT_API int mdg_set_receive_file_cb(mdg_h handle,
 362         mdg_receive_file_cb receive_cb, void *user_data)
 363 {
 364         int ret = MDG_ERROR_NONE;
 365
 366         CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
 367
 368         mdg_manager_s *_handle = handle;
 369         mdg_check_null_ret_error("handle", handle, MDG_ERROR_INVALID_PARAMETER);
 370         CHECK_HANDLE_IS_VALID(handle);
 371
 372         _handle->receive_file_cb.receive_cb = receive_cb;
 373         _handle->receive_file_cb.user_data = user_data;
 374
 375         return ret;
 376 }
 377
 378 EXPORT_API int mdg_unset_receive_file_cb(mdg_h handle)
 379 {
 380         int ret = MDG_ERROR_NONE;
 381
 382         CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
 383
 384         mdg_manager_s *_handle = handle;
 385         mdg_check_null_ret_error("handle", handle, MDG_ERROR_INVALID_PARAMETER);
 386         CHECK_HANDLE_IS_VALID(handle);
 387
 388         _handle->receive_file_cb.receive_cb = NULL;
 389         _handle->receive_file_cb.user_data = NULL;
 390
 391         return ret;
 392 }
 393
 394 EXPORT_API int mdg_device_get_local_device(mdg_h handle,
 395         mdg_device_h *device)
 396 {
 397         int ret = MDG_ERROR_NONE;
 398         GError *error = NULL;
 399         GVariant *va = NULL;
 400
 401         CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
 402
 403         mdg_manager_s *_handle = handle;
 404         mdg_check_null_ret_error("handle", handle, MDG_ERROR_INVALID_PARAMETER);
 405         CHECK_HANDLE_IS_VALID(handle);
 406
 407         group_call_get_local_device_sync(_handle->group_proxy, &va, NULL, &error);
 408         if (error) {
 409                 _ERR("Failed DBus call [%s]", error->message);
 410                 g_error_free(error);
 411                 ret = MDG_ERROR_IO_ERROR;
 412         }
 413
 414         *device = mdg_get_device_from_variant(va);
 415
 416         return ret;
 417 }
 418
 419 EXPORT_API int mdg_group_delete(mdg_h handle, mdg_group_h group)
 420 {
 421         int ret = MDG_ERROR_NONE;
 422         GError *error = NULL;
 423
 424         CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
 425
 426         mdg_manager_s *_handle = handle;
 427         mdg_check_null_ret_error("handle", handle, MDG_ERROR_INVALID_PARAMETER);
 428         CHECK_HANDLE_IS_VALID(handle);
 429
 430         mdg_group_s *grp = (mdg_group_s *)group;
 431         mdg_check_null_ret_error("grp", grp, MDG_ERROR_INVALID_PARAMETER);
 432
 433         /* create group to daemon using gdbus */
 434         group_call_delete_sync(_handle->group_proxy, grp->group_name, &ret, NULL, &error);
 435
 436         return ret;
 437 }
 438
 439 EXPORT_API int mdg_group_foreach_device(mdg_h handle, mdg_group_h group,
 440         mdg_group_foreach_cb foreach_cb, void *user_data)
 441 {
 442         int ret = MDG_ERROR_NONE;
 443         GError *error = NULL;
 444         GVariant *va = NULL;
 445         int count;
 446
 447         CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
 448
 449         mdg_manager_s *_handle = handle;
 450         mdg_check_null_ret_error("handle", handle, MDG_ERROR_INVALID_PARAMETER);
 451         CHECK_HANDLE_IS_VALID(handle);
 452
 453         mdg_group_s *grp = (mdg_group_s *)group;
 454         mdg_check_null_ret_error("grp", grp, MDG_ERROR_INVALID_PARAMETER);
 455
 456         group_call_foreach_device_sync(_handle->group_proxy, grp->group_name, &ret, &va, NULL, &error);
 457         count = g_variant_n_children(va);
 458
 459         if (count > 0) {
 460                 GVariantIter *iter = NULL;
 461                 GVariant *device_va = NULL;
 462                 int result;
 463
 464                 g_variant_get(va, "aa{sv}", &iter);
 465                 while ((device_va = g_variant_iter_next_value(iter)) != NULL) {
 466                         mdg_device_s *device;
 467
 468                         device = mdg_get_device_from_variant(device_va);
 469
 470                         result = foreach_cb((mdg_device_h)device, user_data);
 471                         if (result == false)
 472                                 break;
 473                 }
 474                 g_variant_iter_free(iter);
 475         }
 476
 477         g_variant_unref(va);
 478
 479         return ret;
 480 }
 481
 482 EXPORT_API int mdg_group_invite_device(mdg_h handle,
 483         mdg_group_h group, mdg_device_h device, char *PIN,
 484         mdg_group_invite_device_finish_cb finish_cb, void *user_data)
 485 {
 486         int ret = MDG_ERROR_NONE;
 487         GError *error = NULL;
 488         GVariant *va = NULL;
 489
 490         CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
 491
 492         mdg_manager_s *_handle = handle;
 493         mdg_check_null_ret_error("handle", handle, MDG_ERROR_INVALID_PARAMETER);
 494         CHECK_HANDLE_IS_VALID(handle);
 495
 496         mdg_group_s *grp = (mdg_group_s *)group;
 497         mdg_check_null_ret_error("grp", grp, MDG_ERROR_INVALID_PARAMETER);
 498
 499         mdg_device_s *dev = (mdg_device_s *)device;
 500         mdg_check_null_ret_error("dev", dev, MDG_ERROR_INVALID_PARAMETER);
 501
 502         mdg_device_h cloned_device = NULL;
 503         mdg_device_info_clone(&cloned_device, device);
 504
 505         va = mdg_create_variant_device(dev);
 506
 507         _handle->device_invite_finish_cb.finish_cb = finish_cb;
 508         _handle->device_invite_finish_cb.user_data = user_data;
 509         _handle->device_invite_finish_cb.device = cloned_device;
 510
 511         group_call_invite_device_sync(_handle->group_proxy, grp->group_name, va, PIN,
 512                 &ret, NULL, &error);
 513
 514         return ret;
 515 }
 516
 517 EXPORT_API int mdg_group_eject_device(mdg_h handle,
 518         mdg_group_h group, mdg_device_h device,
 519         mdg_group_eject_device_finish_cb finish_cb, void *user_data)
 520 {
 521         int ret = MDG_ERROR_NONE;
 522         GError *error = NULL;
 523
 524         CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
 525
 526         mdg_manager_s *_handle = handle;
 527         mdg_check_null_ret_error("handle", handle, MDG_ERROR_INVALID_PARAMETER);
 528         CHECK_HANDLE_IS_VALID(handle);
 529
 530         mdg_device_s *dev = (mdg_device_s *)device;
 531         mdg_check_null_ret_error("dev", dev, MDG_ERROR_INVALID_PARAMETER);
 532
 533         mdg_group_s *grp = (mdg_group_s *)group;
 534         mdg_check_null_ret_error("grp", grp, MDG_ERROR_INVALID_PARAMETER);
 535
 536         _handle->device_eject_finish_cb.finish_cb = finish_cb;
 537         _handle->device_eject_finish_cb.user_data = user_data;
 538
 539         group_call_eject_device_sync(_handle->group_proxy, grp->group_name, dev->device_id, &ret,
 540                 NULL, &error);
 541
 542         return ret;
 543 }
 544
 545 EXPORT_API int mdg_group_info_create(mdg_group_h* group)
 546 {
 547         int ret = MDG_ERROR_NONE;
 548
 549         CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
 550
 551         mdg_group_h _group = g_malloc0(sizeof(mdg_group_s));
 552         if (NULL == _group) {
 553                 /* LCOV_EXCL_START */
 554                 _ERR("Memory allocation Failed(%d)", errno);
 555                 return MDG_ERROR_OUT_OF_MEMORY;
 556                 /* LCOV_EXCL_STOP */
 557         }
 558         *group = _group;
 559
 560         return ret;
 561 }
 562
 563 EXPORT_API int mdg_group_info_clone(mdg_group_h *target,
 564         mdg_group_h source)
 565 {
 566         int ret = MDG_ERROR_NONE;
 567
 568         CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
 569
 570         mdg_group_s * src = (mdg_group_s *)source;
 571         mdg_check_null_ret_error("source", source, MDG_ERROR_INVALID_PARAMETER);
 572
 573         *target = (mdg_group_s *)g_malloc0(sizeof(mdg_group_s));
 574         mdg_check_null_ret_error("target", target, MDG_ERROR_INVALID_PARAMETER);
 575         mdg_group_s *dst = *target;
 576
 577         if (src->device_id)
 578                 dst->device_id = g_strdup(src->device_id);
 579
 580         if (src->group_name)
 581                 dst->group_name = g_strdup(src->group_name);
 582
 583         dst->type = src->type;
 584
 585         return ret;
 586 }
 587
 588 EXPORT_API int mdg_group_info_destroy(mdg_group_h data)
 589 {
 590         int ret = MDG_ERROR_NONE;
 591
 592         CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
 593
 594         mdg_group_s * group = (mdg_group_s *)data;
 595         mdg_check_null_ret_error("group", group, MDG_ERROR_INVALID_PARAMETER);
 596
 597         if (group->device_id) {
 598                 g_free(group->device_id);
 599                 group->device_id = NULL;
 600         }
 601         if (group->group_name) {
 602                 g_free(group->group_name);
 603                 group->group_name = NULL;
 604         }
 605
 606         g_free(group);
 607         group = NULL;
 608
 609         return ret;
 610 }
 611
 612 EXPORT_API int mdg_group_info_get_device_id(
 613         mdg_group_h group, char **device_id)
 614 {
 615         int ret = MDG_ERROR_NONE;
 616
 617         CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
 618
 619         *device_id = g_strdup(((mdg_group_s *)group)->device_id);
 620
 621         return ret;
 622 }
 623
 624 EXPORT_API int mdg_group_info_get_type(mdg_group_h group,
 625         mdg_group_type_e *type)
 626 {
 627         int ret = MDG_ERROR_NONE;
 628
 629         CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
 630
 631         *type = ((mdg_group_s *)group)->type;
 632
 633         return ret;
 634 }
 635
 636 EXPORT_API int mdg_group_info_get_name(
 637         mdg_group_h group, char **name)
 638 {
 639         int ret = MDG_ERROR_NONE;
 640
 641         CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
 642
 643         *name = g_strdup(((mdg_group_s *)group)->group_name);
 644
 645         return ret;
 646 }
 647
 648 EXPORT_API int mdg_device_info_clone(mdg_device_h *target,
 649         mdg_device_h source)
 650 {
 651         int ret = MDG_ERROR_NONE;
 652
 653         CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
 654
 655         mdg_device_s * src = (mdg_device_s *)source;
 656         mdg_check_null_ret_error("source", source, MDG_ERROR_INVALID_PARAMETER);
 657
 658         *target = (mdg_device_s *)g_malloc0(sizeof(mdg_device_s));
 659         mdg_check_null_ret_error("target", target, MDG_ERROR_INVALID_PARAMETER);
 660         mdg_device_s *dst = *target;
 661
 662         if (src->device_id)
 663                 dst->device_id = g_strdup(src->device_id);
 664
 665         if (src->model_name)
 666                 dst->model_name = g_strdup(src->model_name);
 667
 668         if (src->device_name)
 669                 dst->device_name = g_strdup(src->device_name);
 670
 671         if (src->platform_ver)
 672                 dst->platform_ver = g_strdup(src->platform_ver);
 673
 674         if (src->vendor_id)
 675                 dst->vendor_id = g_strdup(src->vendor_id);
 676
 677         if (src->profile)
 678                 dst->profile = g_strdup(src->profile);
 679
 680         dst->is_invited = src->is_invited;
 681         dst->type = src->type;
 682
 683         return ret;
 684 }
 685
 686 EXPORT_API int mdg_device_info_destroy(mdg_device_h data)
 687 {
 688         int ret = MDG_ERROR_NONE;
 689
 690         CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
 691
 692         mdg_device_s * device = (mdg_device_s *)data;
 693         mdg_check_null_ret_error("data", data, MDG_ERROR_INVALID_PARAMETER);
 694
 695         if (device->device_id) {
 696                 g_free(device->device_id);
 697                 device->device_id = NULL;
 698         }
 699
 700         if (device->model_name) {
 701                 g_free(device->model_name);
 702                 device->model_name = NULL;
 703         }
 704
 705         if (device->device_name) {
 706                 g_free(device->device_name);
 707                 device->device_name = NULL;
 708         }
 709
 710         if (device->platform_ver) {
 711                 g_free(device->platform_ver);
 712                 device->platform_ver = NULL;
 713         }
 714
 715         if (device->vendor_id) {
 716                 g_free(device->vendor_id);
 717                 device->vendor_id = NULL;
 718         }
 719
 720         if (device->profile) {
 721                 g_free(device->profile);
 722                 device->profile = NULL;
 723         }
 724
 725         g_free(device);
 726         device = NULL;
 727
 728         return ret;
 729 }
 730
 731 EXPORT_API int mdg_device_info_get_device_id(
 732         mdg_device_h device, char **device_id)
 733 {
 734         int ret = MDG_ERROR_NONE;
 735
 736         CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
 737
 738         *device_id = g_strdup(((mdg_device_s *)device)->device_id);
 739
 740         return ret;
 741 }
 742
 743 EXPORT_API int mdg_device_info_get_model_name(
 744         mdg_device_h device, char **model_name)
 745 {
 746         int ret = MDG_ERROR_NONE;
 747
 748         CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
 749
 750         *model_name = g_strdup(((mdg_device_s *)device)->model_name);
 751
 752         return ret;
 753 }
 754
 755 EXPORT_API int mdg_device_info_get_device_name(
 756         mdg_device_h device, char **device_name)
 757 {
 758         int ret = MDG_ERROR_NONE;
 759
 760         CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
 761
 762         *device_name = g_strdup(((mdg_device_s *)device)->device_name);
 763
 764         return ret;
 765 }
 766
 767 EXPORT_API int mdg_device_info_get_platform_ver(
 768         mdg_device_h device, char **platform_ver)
 769 {
 770         int ret = MDG_ERROR_NONE;
 771
 772         CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
 773
 774         *platform_ver = g_strdup(((mdg_device_s *)device)->platform_ver);
 775
 776         return ret;
 777 }
 778
 779 EXPORT_API int mdg_device_info_get_vendor_id(
 780         mdg_device_h device, char **vendor_id)
 781 {
 782         int ret = MDG_ERROR_NONE;
 783
 784         CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
 785
 786         *vendor_id = g_strdup(((mdg_device_s *)device)->vendor_id);
 787
 788         return ret;
 789 }
 790
 791 EXPORT_API int mdg_device_info_get_profile(
 792         mdg_device_h device, char **profile)
 793 {
 794         int ret = MDG_ERROR_NONE;
 795
 796         CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
 797
 798         *profile = g_strdup(((mdg_device_s *)device)->profile);
 799
 800         return ret;
 801 }
 802
 803 EXPORT_API int mdg_device_info_is_invited(
 804         mdg_device_h device, bool *is_invited)
 805 {
 806         int ret = MDG_ERROR_NONE;
 807
 808         CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
 809
 810         *is_invited = ((mdg_device_s *)device)->is_invited;
 811
 812         return ret;
 813 }
 814
 815 EXPORT_API int mdg_device_info_get_type(
 816         mdg_device_h device, mdg_device_type_e *type)
 817 {
 818         int ret = MDG_ERROR_NONE;
 819
 820         CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
 821
 822         *type = ((mdg_device_s *)device)->type;
 823
 824         return ret;
 825 }
 826
 827 EXPORT_API int mdg_request_create_group(mdg_h handle,
 828         mdg_device_h device, char *group_name, mdg_request_result_cb cb,
 829         void *user_data)
 830 {
 831         int ret = MDG_ERROR_NONE;
 832         GError *error = NULL;
 833
 834         NOTUSED(cb);
 835         NOTUSED(user_data);
 836
 837         CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
 838
 839         mdg_manager_s *_handle = handle;
 840         mdg_check_null_ret_error("handle", handle, MDG_ERROR_INVALID_PARAMETER);
 841         CHECK_HANDLE_IS_VALID(handle);
 842
 843         mdg_device_s *dev = (mdg_device_s *)device;
 844         mdg_check_null_ret_error("device", device, MDG_ERROR_INVALID_PARAMETER);
 845         mdg_check_null_ret_error("group_name", group_name,
 846                 MDG_ERROR_INVALID_PARAMETER);
 847
 848         _DBG("Device id : %s", dev->device_id);
 849
 850         group_call_request_create_group_sync(_handle->group_proxy, dev->device_id,
 851                 group_name, &ret, NULL, &error);
 852
 853         return ret;
 854 }
 855
 856 EXPORT_API int mdg_request_invite_device(mdg_h handle,
 857         mdg_group_h group, mdg_device_h device, char *PIN,
 858         mdg_request_result_cb cb, void *user_data)
 859 {
 860         int ret = MDG_ERROR_NONE;
 861         GError *error = NULL;
 862
 863         NOTUSED(cb);
 864         NOTUSED(user_data);
 865
 866         CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
 867
 868         mdg_manager_s *_handle = handle;
 869         mdg_check_null_ret_error("handle", handle, MDG_ERROR_INVALID_PARAMETER);
 870         CHECK_HANDLE_IS_VALID(handle);
 871
 872         mdg_group_s *grp = (mdg_group_s *)group;
 873         mdg_check_null_ret_error("group", group, MDG_ERROR_INVALID_PARAMETER);
 874
 875         mdg_device_s *dev = (mdg_device_s *)device;
 876         mdg_check_null_ret_error("device", device, MDG_ERROR_INVALID_PARAMETER);
 877
 878         _DBG("%s", grp->device_id);
 879         _DBG("%s", grp->group_name);
 880         _DBG("%s", dev->device_id);
 881
 882         group_call_request_invite(_handle->group_proxy, grp->device_id,
 883                 grp->group_name, dev->device_id, PIN, NULL, NULL, &error);
 884         if (error) {
 885                 _ERR("Failed DBus call [%s]", error->message);
 886                 g_error_free(error);
 887                 ret = MDG_ERROR_IO_ERROR;
 888         }
 889
 890         return ret;
 891 }
 892
 893 EXPORT_API int mdg_request_eject_device(mdg_h handle,
 894         mdg_group_h group, mdg_device_h device, mdg_request_result_cb cb,
 895         void *user_data)
 896 {
 897         int ret = MDG_ERROR_NONE;
 898         GError *error = NULL;
 899
 900         NOTUSED(cb);
 901         NOTUSED(user_data);
 902
 903         CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
 904
 905         mdg_manager_s *_handle = handle;
 906         mdg_check_null_ret_error("handle", handle, MDG_ERROR_INVALID_PARAMETER);
 907         CHECK_HANDLE_IS_VALID(handle);
 908
 909         mdg_group_s *grp = (mdg_group_s *)group;
 910         mdg_check_null_ret_error("group", group, MDG_ERROR_INVALID_PARAMETER);
 911
 912         mdg_device_s *dev = (mdg_device_s *)device;
 913         mdg_check_null_ret_error("device", device, MDG_ERROR_INVALID_PARAMETER);
 914
 915         _DBG("%s", grp->device_id);
 916         _DBG("%s", grp->group_name);
 917         _DBG("%s", dev->device_id);
 918
 919         group_call_request_eject(_handle->group_proxy, grp->device_id,
 920                 grp->group_name, dev->device_id, NULL, NULL, &error);
 921         if (error) {
 922                 _ERR("Failed DBus call [%s]", error->message);
 923                 g_error_free(error);
 924                 ret = MDG_ERROR_IO_ERROR;
 925         }
 926
 927         return ret;
 928 }
 929
 930 EXPORT_API int mdg_request_channel_list(mdg_h handle, mdg_device_h device,
 931         mdg_request_channel_list_finish_cb finish_cb, void *user_data)
 932 {
 933         int ret = MDG_ERROR_NONE;
 934         GError *error = NULL;
 935
 936         CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
 937
 938         mdg_manager_s *_handle = handle;
 939         mdg_check_null_ret_error("handle", handle, MDG_ERROR_INVALID_PARAMETER);
 940         CHECK_HANDLE_IS_VALID(handle);
 941
 942         mdg_device_s *dev = (mdg_device_s *)device;
 943         mdg_check_null_ret_error("device", device, MDG_ERROR_INVALID_PARAMETER);
 944         _handle->request_channel_list_finish_cb.finish_cb = finish_cb;
 945         _handle->request_channel_list_finish_cb.user_data = user_data;
 946
 947         _DBG("%s", dev->device_id);
 948
 949         group_call_request_channel_list(_handle->group_proxy, dev->device_id, NULL, NULL, &error);
 950         if (error) {
 951                 _ERR("Failed DBus call [%s]", error->message);
 952                 g_error_free(error);
 953                 ret = MDG_ERROR_IO_ERROR;
 954         }
 955
 956         return ret;
 957 }
 958
 959 EXPORT_API int mdg_request_result_callback(mdg_h handle,
 960         mdg_request_result_cb result_cb, void *user_data)
 961 {
 962         int ret = MDG_ERROR_NONE;
 963
 964         CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
 965
 966         mdg_manager_s *_handle = handle;
 967         mdg_check_null_ret_error("handle", handle, MDG_ERROR_INVALID_PARAMETER);
 968
 969         _handle->request_result_cb.result_cb = result_cb;
 970         _handle->request_result_cb.user_data = user_data;
 971
 972         return ret;
 973 }