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, dev->addr,
 314                                                           dev->secure_port, 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, dev->addr,
 352                                                                 dev->secure_port, file_path, &ret, NULL, &error);
 353         if (error) {
 354                 _ERR("Failed DBus call [%s]", error->message);
 355                 g_error_free(error);
 356                 ret = MDG_ERROR_IO_ERROR;
 357         }
 358
 359         return ret;
 360 }
 361
 362 EXPORT_API int mdg_device_get_local_device(mdg_h handle,
 363         mdg_device_h *device)
 364 {
 365         int ret = MDG_ERROR_NONE;
 366         GError *error = NULL;
 367         GVariant *va = NULL;
 368
 369         CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
 370
 371         mdg_manager_s *_handle = handle;
 372         mdg_check_null_ret_error("handle", handle, MDG_ERROR_INVALID_PARAMETER);
 373         CHECK_HANDLE_IS_VALID(handle);
 374
 375         group_call_get_local_device_sync(_handle->group_proxy, &va, NULL, &error);
 376         if (error) {
 377                 _ERR("Failed DBus call [%s]", error->message);
 378                 g_error_free(error);
 379                 ret = MDG_ERROR_IO_ERROR;
 380         }
 381
 382         *device = mdg_get_device_from_variant(va);
 383
 384         return ret;
 385 }
 386
 387 EXPORT_API int mdg_group_delete(mdg_h handle, mdg_group_h group)
 388 {
 389         int ret = MDG_ERROR_NONE;
 390         GError *error = NULL;
 391
 392         CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
 393
 394         mdg_manager_s *_handle = handle;
 395         mdg_check_null_ret_error("handle", handle, MDG_ERROR_INVALID_PARAMETER);
 396         CHECK_HANDLE_IS_VALID(handle);
 397
 398         mdg_group_s *grp = (mdg_group_s *)group;
 399         mdg_check_null_ret_error("grp", grp, MDG_ERROR_INVALID_PARAMETER);
 400
 401         /* create group to daemon using gdbus */
 402         group_call_delete_sync(_handle->group_proxy, grp->group_name, &ret, NULL, &error);
 403
 404         return ret;
 405 }
 406
 407 EXPORT_API int mdg_group_foreach_device(mdg_h handle, mdg_group_h group,
 408         mdg_group_foreach_cb foreach_cb, void *user_data)
 409 {
 410         int ret = MDG_ERROR_NONE;
 411         GError *error = NULL;
 412         GVariant *va = NULL;
 413         int count;
 414
 415         CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
 416
 417         mdg_manager_s *_handle = handle;
 418         mdg_check_null_ret_error("handle", handle, MDG_ERROR_INVALID_PARAMETER);
 419         CHECK_HANDLE_IS_VALID(handle);
 420
 421         mdg_group_s *grp = (mdg_group_s *)group;
 422         mdg_check_null_ret_error("grp", grp, MDG_ERROR_INVALID_PARAMETER);
 423
 424         group_call_foreach_device_sync(_handle->group_proxy, grp->group_name, &ret, &va, NULL, &error);
 425         count = g_variant_n_children(va);
 426
 427         if (count > 0) {
 428                 GVariantIter *iter = NULL;
 429                 GVariant *device_va = NULL;
 430                 int result;
 431
 432                 g_variant_get(va, "aa{sv}", &iter);
 433                 while ((device_va = g_variant_iter_next_value(iter)) != NULL) {
 434                         mdg_device_s *device;
 435
 436                         device = mdg_get_device_from_variant(device_va);
 437
 438                         result = foreach_cb((mdg_device_h)device, user_data);
 439                         if (result == false)
 440                                 break;
 441                 }
 442                 g_variant_iter_free(iter);
 443         }
 444
 445         g_variant_unref(va);
 446
 447         return ret;
 448 }
 449
 450 EXPORT_API int mdg_group_invite_device(mdg_h handle,
 451         mdg_group_h group, mdg_device_h device, char *PIN,
 452         mdg_group_invite_device_finish_cb finish_cb, void *user_data)
 453 {
 454         int ret = MDG_ERROR_NONE;
 455         GError *error = NULL;
 456         GVariant *va = NULL;
 457
 458         CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
 459
 460         mdg_manager_s *_handle = handle;
 461         mdg_check_null_ret_error("handle", handle, MDG_ERROR_INVALID_PARAMETER);
 462         CHECK_HANDLE_IS_VALID(handle);
 463
 464         mdg_group_s *grp = (mdg_group_s *)group;
 465         mdg_check_null_ret_error("grp", grp, MDG_ERROR_INVALID_PARAMETER);
 466
 467         mdg_device_s *dev = (mdg_device_s *)device;
 468         mdg_check_null_ret_error("dev", dev, MDG_ERROR_INVALID_PARAMETER);
 469
 470         mdg_device_h cloned_device = NULL;
 471         mdg_device_info_clone(&cloned_device, device);
 472
 473         va = mdg_create_variant_device(dev);
 474
 475         _handle->device_invite_finish_cb.finish_cb = finish_cb;
 476         _handle->device_invite_finish_cb.user_data = user_data;
 477         _handle->device_invite_finish_cb.device = cloned_device;
 478
 479         group_call_invite_device_sync(_handle->group_proxy, grp->group_name, va, PIN,
 480                 &ret, NULL, &error);
 481
 482         return ret;
 483 }
 484
 485 EXPORT_API int mdg_group_eject_device(mdg_h handle,
 486         mdg_group_h group, mdg_device_h device,
 487         mdg_group_eject_device_finish_cb finish_cb, void *user_data)
 488 {
 489         int ret = MDG_ERROR_NONE;
 490         GError *error = NULL;
 491
 492         CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
 493
 494         mdg_manager_s *_handle = handle;
 495         mdg_check_null_ret_error("handle", handle, MDG_ERROR_INVALID_PARAMETER);
 496         CHECK_HANDLE_IS_VALID(handle);
 497
 498         mdg_device_s *dev = (mdg_device_s *)device;
 499         mdg_check_null_ret_error("dev", dev, MDG_ERROR_INVALID_PARAMETER);
 500
 501         mdg_group_s *grp = (mdg_group_s *)group;
 502         mdg_check_null_ret_error("grp", grp, MDG_ERROR_INVALID_PARAMETER);
 503
 504         _handle->device_eject_finish_cb.finish_cb = finish_cb;
 505         _handle->device_eject_finish_cb.user_data = user_data;
 506
 507         group_call_eject_device_sync(_handle->group_proxy, grp->group_name, dev->device_id, &ret,
 508                 NULL, &error);
 509
 510         return ret;
 511 }
 512
 513 EXPORT_API int mdg_group_info_create(mdg_group_h* group)
 514 {
 515         int ret = MDG_ERROR_NONE;
 516
 517         CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
 518
 519         mdg_group_h _group = g_malloc0(sizeof(mdg_group_s));
 520         if (NULL == _group) {
 521                 /* LCOV_EXCL_START */
 522                 _ERR("Memory allocation Failed(%d)", errno);
 523                 return MDG_ERROR_OUT_OF_MEMORY;
 524                 /* LCOV_EXCL_STOP */
 525         }
 526         *group = _group;
 527
 528         return ret;
 529 }
 530
 531 EXPORT_API int mdg_group_info_clone(mdg_group_h *target,
 532         mdg_group_h source)
 533 {
 534         int ret = MDG_ERROR_NONE;
 535
 536         CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
 537
 538         mdg_group_s * src = (mdg_group_s *)source;
 539         mdg_check_null_ret_error("source", source, MDG_ERROR_INVALID_PARAMETER);
 540
 541         *target = (mdg_group_s *)g_malloc0(sizeof(mdg_group_s));
 542         mdg_check_null_ret_error("target", target, MDG_ERROR_INVALID_PARAMETER);
 543         mdg_group_s *dst = *target;
 544
 545         if (src->device_id)
 546                 dst->device_id = g_strdup(src->device_id);
 547
 548         if (src->host_addr)
 549                 dst->host_addr = g_strdup(src->host_addr);
 550
 551         if (src->group_name)
 552                 dst->group_name = g_strdup(src->group_name);
 553
 554         dst->type = src->type;
 555
 556         return ret;
 557 }
 558
 559 EXPORT_API int mdg_group_info_destroy(mdg_group_h data)
 560 {
 561         int ret = MDG_ERROR_NONE;
 562
 563         CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
 564
 565         mdg_group_s * group = (mdg_group_s *)data;
 566         mdg_check_null_ret_error("group", group, MDG_ERROR_INVALID_PARAMETER);
 567
 568         if (group->device_id) {
 569                 g_free(group->device_id);
 570                 group->device_id = NULL;
 571         }
 572         if (group->host_addr) {
 573                 g_free(group->host_addr);
 574                 group->host_addr = NULL;
 575         }
 576         if (group->group_name) {
 577                 g_free(group->group_name);
 578                 group->group_name = NULL;
 579         }
 580
 581         g_free(group);
 582         group = NULL;
 583
 584         return ret;
 585 }
 586
 587 EXPORT_API int mdg_group_info_get_device_id(
 588         mdg_group_h group, char **device_id)
 589 {
 590         int ret = MDG_ERROR_NONE;
 591
 592         CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
 593
 594         *device_id = g_strdup(((mdg_group_s *)group)->device_id);
 595
 596         return ret;
 597 }
 598
 599 EXPORT_API int mdg_group_info_get_host_addr(
 600         mdg_group_h group, char **host_addr)
 601 {
 602         int ret = MDG_ERROR_NONE;
 603
 604         CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
 605
 606         *host_addr = g_strdup(((mdg_group_s *)group)->host_addr);
 607
 608         return ret;
 609 }
 610
 611 EXPORT_API int mdg_group_info_get_type(mdg_group_h group,
 612         mdg_group_type_e *type)
 613 {
 614         int ret = MDG_ERROR_NONE;
 615
 616         CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
 617
 618         *type = ((mdg_group_s *)group)->type;
 619
 620         return ret;
 621 }
 622
 623 EXPORT_API int mdg_group_info_get_name(
 624         mdg_group_h group, char **name)
 625 {
 626         int ret = MDG_ERROR_NONE;
 627
 628         CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
 629
 630         *name = g_strdup(((mdg_group_s *)group)->group_name);
 631
 632         return ret;
 633 }
 634
 635 EXPORT_API int mdg_device_info_clone(mdg_device_h *target,
 636         mdg_device_h source)
 637 {
 638         int ret = MDG_ERROR_NONE;
 639
 640         CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
 641
 642         mdg_device_s * src = (mdg_device_s *)source;
 643         mdg_check_null_ret_error("source", source, MDG_ERROR_INVALID_PARAMETER);
 644
 645         *target = (mdg_device_s *)g_malloc0(sizeof(mdg_device_s));
 646         mdg_check_null_ret_error("target", target, MDG_ERROR_INVALID_PARAMETER);
 647         mdg_device_s *dst = *target;
 648
 649         if (src->device_id)
 650                 dst->device_id = g_strdup(src->device_id);
 651
 652         if (src->addr)
 653                 dst->addr = g_strdup(src->addr);
 654
 655         dst->port = src->port;
 656         dst->secure_port = src->secure_port;
 657         dst->conn_type = src->conn_type;
 658
 659         if (src->model_name)
 660                 dst->model_name = g_strdup(src->model_name);
 661
 662         if (src->device_name)
 663                 dst->device_name = g_strdup(src->device_name);
 664
 665         if (src->platform_ver)
 666                 dst->platform_ver = g_strdup(src->platform_ver);
 667
 668         if (src->vendor_id)
 669                 dst->vendor_id = g_strdup(src->vendor_id);
 670
 671         if (src->profile)
 672                 dst->profile = g_strdup(src->profile);
 673
 674         dst->is_invited = src->is_invited;
 675         dst->type = src->type;
 676
 677         return ret;
 678 }
 679
 680 EXPORT_API int mdg_device_info_destroy(mdg_device_h data)
 681 {
 682         int ret = MDG_ERROR_NONE;
 683
 684         CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
 685
 686         mdg_device_s * device = (mdg_device_s *)data;
 687         mdg_check_null_ret_error("data", data, MDG_ERROR_INVALID_PARAMETER);
 688
 689         if (device->device_id) {
 690                 g_free(device->device_id);
 691                 device->device_id = NULL;
 692         }
 693
 694         if (device->addr) {
 695                 g_free(device->addr);
 696                 device->addr = NULL;
 697         }
 698
 699         if (device->model_name) {
 700                 g_free(device->model_name);
 701                 device->model_name = NULL;
 702         }
 703
 704         if (device->device_name) {
 705                 g_free(device->device_name);
 706                 device->device_name = NULL;
 707         }
 708
 709         if (device->platform_ver) {
 710                 g_free(device->platform_ver);
 711                 device->platform_ver = NULL;
 712         }
 713
 714         if (device->vendor_id) {
 715                 g_free(device->vendor_id);
 716                 device->vendor_id = NULL;
 717         }
 718
 719         if (device->profile) {
 720                 g_free(device->profile);
 721                 device->profile = NULL;
 722         }
 723
 724         g_free(device);
 725         device = NULL;
 726
 727         return ret;
 728 }
 729
 730 EXPORT_API int mdg_device_info_get_device_id(
 731         mdg_device_h device, char **device_id)
 732 {
 733         int ret = MDG_ERROR_NONE;
 734
 735         CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
 736
 737         *device_id = g_strdup(((mdg_device_s *)device)->device_id);
 738
 739         return ret;
 740 }
 741
 742 EXPORT_API int mdg_device_info_get_addr(
 743         mdg_device_h device, char **addr)
 744 {
 745         int ret = MDG_ERROR_NONE;
 746
 747         CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
 748
 749         *addr = g_strdup(((mdg_device_s *)device)->addr);
 750
 751         return ret;
 752 }
 753
 754 EXPORT_API int mdg_device_info_get_port(
 755         mdg_device_h device, int *port)
 756 {
 757         int ret = MDG_ERROR_NONE;
 758
 759         CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
 760
 761         *port = (((mdg_device_s *)device)->port);
 762
 763         return ret;
 764 }
 765
 766 EXPORT_API int mdg_device_info_get_secure_port(
 767         mdg_device_h device, int *secure_port)
 768 {
 769         int ret = MDG_ERROR_NONE;
 770
 771         CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
 772
 773         *secure_port = (((mdg_device_s *)device)->secure_port);
 774
 775         return ret;
 776 }
 777
 778 EXPORT_API int mdg_device_info_get_model_name(
 779         mdg_device_h device, char **model_name)
 780 {
 781         int ret = MDG_ERROR_NONE;
 782
 783         CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
 784
 785         *model_name = g_strdup(((mdg_device_s *)device)->model_name);
 786
 787         return ret;
 788 }
 789
 790 EXPORT_API int mdg_device_info_get_device_name(
 791         mdg_device_h device, char **device_name)
 792 {
 793         int ret = MDG_ERROR_NONE;
 794
 795         CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
 796
 797         *device_name = g_strdup(((mdg_device_s *)device)->device_name);
 798
 799         return ret;
 800 }
 801
 802 EXPORT_API int mdg_device_info_get_platform_ver(
 803         mdg_device_h device, char **platform_ver)
 804 {
 805         int ret = MDG_ERROR_NONE;
 806
 807         CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
 808
 809         *platform_ver = g_strdup(((mdg_device_s *)device)->platform_ver);
 810
 811         return ret;
 812 }
 813
 814 EXPORT_API int mdg_device_info_get_vendor_id(
 815         mdg_device_h device, char **vendor_id)
 816 {
 817         int ret = MDG_ERROR_NONE;
 818
 819         CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
 820
 821         *vendor_id = g_strdup(((mdg_device_s *)device)->vendor_id);
 822
 823         return ret;
 824 }
 825
 826 EXPORT_API int mdg_device_info_get_profile(
 827         mdg_device_h device, char **profile)
 828 {
 829         int ret = MDG_ERROR_NONE;
 830
 831         CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
 832
 833         *profile = g_strdup(((mdg_device_s *)device)->profile);
 834
 835         return ret;
 836 }
 837
 838 EXPORT_API int mdg_device_info_is_invited(
 839         mdg_device_h device, bool *is_invited)
 840 {
 841         int ret = MDG_ERROR_NONE;
 842
 843         CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
 844
 845         *is_invited = ((mdg_device_s *)device)->is_invited;
 846
 847         return ret;
 848 }
 849
 850 EXPORT_API int mdg_device_info_get_type(
 851         mdg_device_h device, mdg_device_type_e *type)
 852 {
 853         int ret = MDG_ERROR_NONE;
 854
 855         CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
 856
 857         *type = ((mdg_device_s *)device)->type;
 858
 859         return ret;
 860 }
 861
 862 EXPORT_API int mdg_request_create_group(mdg_h handle,
 863         mdg_device_h device, char *group_name, mdg_request_result_cb cb,
 864         void *user_data)
 865 {
 866         int ret = MDG_ERROR_NONE;
 867         GError *error = NULL;
 868
 869         NOTUSED(cb);
 870         NOTUSED(user_data);
 871
 872         CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
 873
 874         mdg_manager_s *_handle = handle;
 875         mdg_check_null_ret_error("handle", handle, MDG_ERROR_INVALID_PARAMETER);
 876         CHECK_HANDLE_IS_VALID(handle);
 877
 878         mdg_device_s *dev = (mdg_device_s *)device;
 879         mdg_check_null_ret_error("device", device, MDG_ERROR_INVALID_PARAMETER);
 880         mdg_check_null_ret_error("group_name", group_name,
 881                 MDG_ERROR_INVALID_PARAMETER);
 882
 883         _DBG("Device id : %s", dev->device_id);
 884
 885         group_call_request_create_group_sync(_handle->group_proxy, dev->device_id, dev->addr,
 886                 dev->secure_port, group_name, &ret, NULL, &error);
 887
 888         return ret;
 889 }
 890
 891 EXPORT_API int mdg_request_invite_device(mdg_h handle,
 892         mdg_group_h group, mdg_device_h device, char *PIN,
 893         mdg_request_result_cb cb, void *user_data)
 894 {
 895         int ret = MDG_ERROR_NONE;
 896         GError *error = NULL;
 897
 898         NOTUSED(cb);
 899         NOTUSED(user_data);
 900
 901         CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
 902
 903         mdg_manager_s *_handle = handle;
 904         mdg_check_null_ret_error("handle", handle, MDG_ERROR_INVALID_PARAMETER);
 905         CHECK_HANDLE_IS_VALID(handle);
 906
 907         mdg_group_s *grp = (mdg_group_s *)group;
 908         mdg_check_null_ret_error("group", group, MDG_ERROR_INVALID_PARAMETER);
 909
 910         mdg_device_s *dev = (mdg_device_s *)device;
 911         mdg_check_null_ret_error("device", device, MDG_ERROR_INVALID_PARAMETER);
 912
 913         _DBG("%s", grp->device_id);
 914         _DBG("%s", grp->group_name);
 915         _DBG("%s", dev->device_id);
 916
 917         group_call_request_invite(_handle->group_proxy, grp->device_id, dev->addr,
 918                 dev->secure_port, grp->group_name, dev->device_id, PIN, NULL, NULL, &error);
 919         if (error) {
 920                 _ERR("Failed DBus call [%s]", error->message);
 921                 g_error_free(error);
 922                 ret = MDG_ERROR_IO_ERROR;
 923         }
 924
 925         return ret;
 926 }
 927
 928 EXPORT_API int mdg_request_eject_device(mdg_h handle,
 929         mdg_group_h group, mdg_device_h device, mdg_request_result_cb cb,
 930         void *user_data)
 931 {
 932         int ret = MDG_ERROR_NONE;
 933         GError *error = NULL;
 934
 935         NOTUSED(cb);
 936         NOTUSED(user_data);
 937
 938         CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
 939
 940         mdg_manager_s *_handle = handle;
 941         mdg_check_null_ret_error("handle", handle, MDG_ERROR_INVALID_PARAMETER);
 942         CHECK_HANDLE_IS_VALID(handle);
 943
 944         mdg_group_s *grp = (mdg_group_s *)group;
 945         mdg_check_null_ret_error("group", group, MDG_ERROR_INVALID_PARAMETER);
 946
 947         mdg_device_s *dev = (mdg_device_s *)device;
 948         mdg_check_null_ret_error("device", device, MDG_ERROR_INVALID_PARAMETER);
 949
 950         _DBG("%s", grp->device_id);
 951         _DBG("%s", grp->group_name);
 952         _DBG("%s", dev->device_id);
 953
 954         group_call_request_eject(_handle->group_proxy, grp->device_id, dev->addr,
 955                 dev->secure_port, grp->group_name, dev->device_id, NULL, NULL, &error);
 956         if (error) {
 957                 _ERR("Failed DBus call [%s]", error->message);
 958                 g_error_free(error);
 959                 ret = MDG_ERROR_IO_ERROR;
 960         }
 961
 962         return ret;
 963 }
 964
 965 EXPORT_API int mdg_request_channel_list(mdg_h handle, mdg_device_h device,
 966         mdg_request_channel_list_finish_cb finish_cb, void *user_data)
 967 {
 968         int ret = MDG_ERROR_NONE;
 969         GError *error = NULL;
 970
 971         CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
 972
 973         mdg_manager_s *_handle = handle;
 974         mdg_check_null_ret_error("handle", handle, MDG_ERROR_INVALID_PARAMETER);
 975         CHECK_HANDLE_IS_VALID(handle);
 976
 977         mdg_device_s *dev = (mdg_device_s *)device;
 978         mdg_check_null_ret_error("device", device, MDG_ERROR_INVALID_PARAMETER);
 979         _handle->request_channel_list_finish_cb.finish_cb = finish_cb;
 980         _handle->request_channel_list_finish_cb.user_data = user_data;
 981
 982         _DBG("%s", dev->device_id);
 983
 984         group_call_request_channel_list(_handle->group_proxy, dev->device_id, dev->addr,
 985                 dev->secure_port, NULL, NULL, &error);
 986         if (error) {
 987                 _ERR("Failed DBus call [%s]", error->message);
 988                 g_error_free(error);
 989                 ret = MDG_ERROR_IO_ERROR;
 990         }
 991
 992         return ret;
 993 }
 994
 995 EXPORT_API int mdg_request_result_callback(mdg_h handle,
 996         mdg_request_result_cb result_cb, void *user_data)
 997 {
 998         int ret = MDG_ERROR_NONE;
 999
1000         CHECK_FEATURE_SUPPORTED(MDG_FEATURE);
1001
1002         mdg_manager_s *_handle = handle;
1003         mdg_check_null_ret_error("handle", handle, MDG_ERROR_INVALID_PARAMETER);
1004
1005         _handle->request_result_cb.result_cb = result_cb;
1006         _handle->request_result_cb.user_data = user_data;
1007
1008         return ret;
1009 }