bt-service/bt-service-map-client.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 <glib.h>
  19 #include <dlog.h>
  20 #include <string.h>
  21 #include <mime_type.h>
  22 #include <aul.h>
  23 #include <glib.h>
  24 #include <gio/gio.h>
  25
  26 #include "bluetooth-api.h"
  27 #include "bt-internal-types.h"
  28
  29 #include "bt-service-common.h"
  30 #include "bt-service-event.h"
  31 #include "bt-service-util.h"
  32 #include "bt-service-map-client.h"
  33 #include "bt-service-obex-agent.h"
  34 #include "bt-service-adapter.h"
  35
  36 #define DBUS_TIMEOUT 20 * 1000  /* 20 Seconds */
  37
  38
  39 typedef struct {
  40         char *transfer_path;
  41         int request_id;
  42 } bt_callback_data_t;
  43
  44
  45 static GSList *transfer_list = NULL;
  46
  47 bt_session_info_t *session_info;
  48
  49 static void __bt_free_session_info(bt_session_info_t *info)
  50 {
  51         ret_if(info == NULL);
  52
  53         /* TODO: MAP bt_session_info_t, see bt-service-opp-client.c */
  54
  55         g_free(info->address);
  56         g_free(info);
  57 }
  58
  59 static void __bt_free_session_data(gpointer data)
  60 {
  61         bt_session_data_t *info = data;
  62
  63         ret_if(info == NULL);
  64
  65         _bt_delete_request_id(info->request_id);
  66
  67         /* TODO: MAP bt_session_data_t, see bt-service-opp-client.c */
  68
  69         g_free(info->address);
  70         g_free(info);
  71 }
  72
  73 static void __bt_session_release_cb(GDBusProxy *proxy,
  74                                 GAsyncResult *res, gpointer user_data)
  75 {
  76         BT_DBG("+");
  77         ret_if(session_info == NULL);
  78
  79         GError *error = NULL;
  80         int result = BLUETOOTH_ERROR_NONE;
  81         GVariant *param = NULL;
  82         g_dbus_proxy_call_finish(proxy, res, &error);
  83         if (proxy)
  84                 g_object_unref(proxy);
  85
  86         if (error) {
  87                 BT_ERR("%s", error->message);
  88                 g_error_free(error);
  89
  90                 result = BLUETOOTH_ERROR_INTERNAL;
  91         } else {
  92                 BT_DBG("Session Removed");
  93         }
  94
  95         session_info->result = result;
  96         param = g_variant_new("(isi)", session_info->result,
  97                                 session_info->address,
  98                                 session_info->request_id);
  99         /* Send the event in only error none case */
 100         _bt_send_event(BT_OPP_CLIENT_EVENT,
 101                         BLUETOOTH_EVENT_OPC_DISCONNECTED,
 102                         param);
 103
 104         __bt_free_session_info(session_info);
 105         session_info = NULL;
 106
 107         _bt_map_client_event_deinit();
 108
 109         /* Operate remain works */
 110         /* TODO: MAP */
 111
 112         return;
 113 fail:
 114
 115         BT_DBG("-");
 116
 117         return;
 118 }
 119
 120 static int _bt_remove_session()
 121 {
 122         GDBusConnection *g_conn;
 123         GDBusProxy *session_proxy;
 124         GError *err = NULL;
 125
 126         g_conn = _bt_gdbus_get_session_gconn();
 127         retv_if(g_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
 128         retv_if(session_info->session_path == NULL, BLUETOOTH_ERROR_INVALID_PARAM);
 129
 130         session_proxy = g_dbus_proxy_new_sync(g_conn, G_DBUS_PROXY_FLAGS_NONE,
 131                                                 NULL, BT_OBEXD_DBUS_NAME,
 132                                                 BT_OBEX_CLIENT_PATH,
 133                                                 BT_OBEX_CLIENT_INTERFACE,
 134                                                 NULL, &err);
 135
 136         retv_if(session_proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
 137
 138         g_dbus_proxy_call(session_proxy, "RemoveSession",
 139                 g_variant_new("(o)", session_info->session_path),
 140                 G_DBUS_CALL_FLAGS_NONE,
 141                 DBUS_TIMEOUT, NULL,
 142                 (GAsyncReadyCallback)__bt_session_release_cb,
 143                 NULL);
 144
 145         return BLUETOOTH_ERROR_NONE;
 146 }
 147
 148 void _bt_map_disconnected(const char *session_path)
 149 {
 150         BT_DBG("+");
 151         GVariant *param = NULL;
 152         ret_if(session_info == NULL);
 153
 154         if (g_strcmp0(session_info->session_path,
 155                         session_path) != 0) {
 156                 BT_INFO("Path mismatch, previous transfer failed! Returning");
 157                 return;
 158         }
 159
 160         param = g_variant_new("(isi)", session_info->result,
 161                                 session_info->address,
 162                                 session_info->request_id);
 163         _bt_send_event(BT_MAP_CLIENT_EVENT,
 164                         BLUETOOTH_EVENT_MAP_DISCONNECTED,
 165                         param);
 166
 167         __bt_free_session_info(session_info);
 168         session_info = NULL;
 169
 170         BT_DBG("-");
 171 }
 172
 173 static void __bt_create_session_cb(GDBusProxy *proxy,
 174                                 GAsyncResult *res, gpointer user_data)
 175 {
 176         BT_DBG("+");
 177
 178         GError *error = NULL;
 179         GVariant *value;
 180         int result = BLUETOOTH_ERROR_NONE;
 181         char *session_path = NULL;
 182         GVariant *param = NULL;
 183
 184         value = g_dbus_proxy_call_finish(proxy, res, &error);
 185         if (value) {
 186                 g_variant_get(value, "(o)", &session_path);
 187                 g_variant_unref(value);
 188         }
 189         if (error) {
 190
 191                 BT_ERR("%s", error->message);
 192                 g_clear_error(&error);
 193
 194                 result = BLUETOOTH_ERROR_INTERNAL;
 195         } else {
 196                 BT_DBG("Session created");
 197                 if (session_info != NULL)
 198                         session_info->session_path = g_strdup(session_path);
 199         }
 200         g_free(session_path);
 201         g_object_unref(proxy);
 202         ret_if(session_info == NULL);
 203
 204         session_info->result = result;
 205         param = g_variant_new("(isi)", result,
 206                                 session_info->address,
 207                                 session_info->request_id);
 208         /* Send the event in only error none case */
 209         _bt_send_event(BT_MAP_CLIENT_EVENT,
 210                         BLUETOOTH_EVENT_MAP_CONNECTED,
 211                         param);
 212
 213         if (result != BLUETOOTH_ERROR_NONE) {
 214                 BT_ERR("Calling __bt_session_release");
 215                 gboolean ret = __bt_session_release();
 216
 217                 __bt_free_session_info(session_info);
 218                 session_info = NULL;
 219
 220                 if (ret == FALSE) {
 221                         BT_DBG("ReleaseSession Not called");
 222                         /* Operate remain works */
 223
 224                         /* TODO: MAP */
 225
 226                 }
 227         } else {
 228
 229                 /* TODO: MAP */
 230
 231         }
 232         BT_DBG("-");
 233
 234 }
 235
 236 static int __bt_opp_client_start_XXXXXXXXXX(int request_id, char *address
 237                                         /* parameters................... */)
 238 {
 239         /* TODO: MAP */
 240 }
 241
 242 int _bt_create_session_sync(const char* address, char** session_id)
 243 {
 244         BT_DBG("Entered SERVICE create session");
 245         GDBusConnection *g_conn;
 246         GDBusProxy *session_proxy;
 247         GError *err = NULL;
 248         const char *session_path;
 249
 250         retv_if(address == NULL, BLUETOOTH_ERROR_INVALID_PARAM);
 251
 252         g_conn = _bt_gdbus_get_session_gconn();
 253         retv_if(g_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
 254
 255         session_proxy = g_dbus_proxy_new_sync(g_conn, G_DBUS_PROXY_FLAGS_NONE,
 256                                                 NULL, BT_OBEX_SERVICE_NAME,
 257                                                 BT_OBEX_CLIENT_PATH,
 258                                                 BT_OBEX_CLIENT_INTERFACE,
 259                                                 NULL, &err);
 260         if (err) {
 261                 BT_ERR("Unable to create session_proxy: %s", err->message);
 262                 g_clear_error(&err);
 263                 return BLUETOOTH_ERROR_INTERNAL;
 264         }
 265         retv_if(session_proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
 266
 267         GVariantBuilder* builder = g_variant_builder_new (G_VARIANT_TYPE_ARRAY);
 268         g_variant_builder_add(builder, "{sv}", "Target",
 269                         g_variant_new("s", "map"));
 270         GVariant *args = g_variant_builder_end(builder);
 271         g_variant_builder_unref (builder);
 272         GVariant *param = g_variant_new("(s@a{sv})", address, args);
 273
 274         char* string = g_variant_print (param, true);
 275
 276         GVariant *value = g_dbus_proxy_call_sync(session_proxy, "CreateSession", param,
 277                         G_DBUS_CALL_FLAGS_NONE, -1, NULL, &err);
 278         if (err != NULL) {
 279                 BT_ERR("Could not create session: %s\n", err->message);
 280                 g_error_free(err);
 281                 return BLUETOOTH_ERROR_INTERNAL;
 282         } else {
 283                 if (NULL == value) {
 284                         BT_ERR("create session returned value is null\n");
 285                         return BLUETOOTH_ERROR_INTERNAL;
 286                 } else {
 287                         BT_DBG("create session succeed\n");
 288                 }
 289         }
 290
 291         g_variant_get(value, "(&o)", session_id);
 292         BT_DBG("session_id = \"%s\"\n", *session_id);
 293
 294         return BLUETOOTH_ERROR_NONE;
 295 }
 296
 297 int _bt_destroy_session_sync(const char* session_id)
 298 {
 299         BT_DBG("Entered SERVICE destroy session with id: \"%s\"", session_id);
 300         GDBusConnection *g_conn;
 301         GDBusProxy *session_proxy;
 302         GError *err = NULL;
 303
 304         retv_if(session_id == NULL, BLUETOOTH_ERROR_INVALID_PARAM);
 305
 306         g_conn = _bt_gdbus_get_session_gconn();
 307         retv_if(g_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
 308
 309         session_proxy = g_dbus_proxy_new_sync(g_conn, G_DBUS_PROXY_FLAGS_NONE,
 310                                                 NULL, BT_OBEX_SERVICE_NAME,
 311                                                 BT_OBEX_CLIENT_PATH,
 312                                                 BT_OBEX_CLIENT_INTERFACE,
 313                                                 NULL, &err);
 314         if (err) {
 315                 BT_ERR("Unable to create session_proxy: %s", err->message);
 316                 g_clear_error(&err);
 317                 return BLUETOOTH_ERROR_INTERNAL;
 318         }
 319         retv_if(session_proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
 320
 321         GVariant *param = g_variant_new("(o)", session_id);
 322
 323         GVariant *value = g_dbus_proxy_call_sync(session_proxy, "RemoveSession", param,
 324                         G_DBUS_CALL_FLAGS_NONE, -1, NULL, &err);
 325         if (err != NULL) {
 326                 BT_ERR("Could not remove session: %s\n", err->message);
 327                 g_error_free(err);
 328                 return BLUETOOTH_ERROR_INTERNAL;
 329         } else {
 330                 BT_DBG("remove session succeed\n");
 331         }
 332
 333         return BLUETOOTH_ERROR_NONE;
 334 }
 335
 336 int _bt_map_client_set_folder(const char* session_id, const char* name)
 337 {
 338         BT_DBG("+");
 339
 340         GError *err = NULL;
 341         GDBusConnection *g_conn;
 342         GDBusProxy *message_proxy;
 343         GVariant *ret = NULL;
 344
 345         g_conn = _bt_gdbus_get_session_gconn();
 346         ret_if(g_conn == NULL);
 347
 348         GVariant *param = g_variant_new("(o)", session_id);
 349
 350         message_proxy = g_dbus_proxy_new_sync(g_conn,
 351                 G_DBUS_PROXY_FLAGS_NONE, NULL,
 352                 BT_OBEX_SERVICE_NAME, session_id,
 353                 BT_OBEX_MESSAGE_INTERFACE, NULL, &err);
 354
 355         retv_if(message_proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
 356
 357         ret = g_dbus_proxy_call_sync(message_proxy,
 358                                 "SetFolder", g_variant_new("(s)", name),
 359                                 G_DBUS_CALL_FLAGS_NONE, DBUS_TIMEOUT,
 360                                 NULL, &err);
 361
 362         if (ret == NULL) {
 363                 if (err != NULL) {
 364                         BT_ERR("SetFolder Error: %s\n", err->message);
 365                         g_error_free(err);
 366                 }
 367         } else {
 368                 g_variant_unref(ret);
 369         }
 370
 371         g_object_unref(message_proxy);
 372
 373         BT_DBG("-");
 374
 375         return BLUETOOTH_ERROR_NONE;
 376 }
 377
 378 static void __bt_list_folders_cb(GDBusProxy *proxy,
 379                                 GAsyncResult *res, gpointer user_data)
 380 {
 381         BT_DBG("+");
 382
 383         GError *error = NULL;
 384         GVariant *value, *in_param, *param;
 385
 386         int result = BLUETOOTH_ERROR_NONE;
 387         int request_id;
 388         int size = 0;
 389
 390         in_param = (GVariant*) user_data;
 391         g_variant_get(in_param, "(i)", &request_id);
 392
 393         value = g_dbus_proxy_call_finish(proxy, res, &error);
 394
 395         if (error) {
 396                 BT_ERR("%s", error->message);
 397                 g_clear_error(&error);
 398                 result = BLUETOOTH_ERROR_INTERNAL;
 399         }
 400
 401         param = g_variant_new("(iiv)", result, request_id, value);
 402         BT_DBG("RequestID[%d]", request_id);
 403         result = _bt_send_event(BT_MAP_CLIENT_EVENT,
 404                         BLUETOOTH_EVENT_MAP_LIST_FOLDERS_COMPLETE, param);
 405
 406         g_variant_unref(value);
 407         g_variant_unref(in_param);
 408
 409         BT_DBG("-");
 410 }
 411
 412 int _bt_map_client_list_folders(
 413         int request_id,
 414         GDBusMethodInvocation *context,
 415         const char* session_id,
 416         const char* filter_serialized)
 417 {
 418         BT_DBG("Entered _bt_map_list_folders with session id: \"%s\"", session_id);
 419         GDBusConnection *g_conn;
 420         GDBusProxy *message_access_proxy;
 421         GError *error = NULL;
 422         int result = BLUETOOTH_ERROR_NONE;
 423
 424         retv_if(session_id == NULL, BLUETOOTH_ERROR_INVALID_PARAM);
 425
 426         g_conn = _bt_gdbus_get_session_gconn();
 427         retv_if(g_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
 428
 429         GVariant *out_param1 = g_variant_new_from_data((const GVariantType *)"ay",
 430                         &request_id, sizeof(int),
 431                         TRUE, NULL, NULL);
 432         g_dbus_method_invocation_return_value(context,
 433                         g_variant_new("(iv)", result, out_param1));
 434
 435         // create message access proxy
 436         g_clear_error(&error);
 437         message_access_proxy = g_dbus_proxy_new_sync(g_conn, G_DBUS_PROXY_FLAGS_NONE, NULL,
 438                         BT_OBEX_SERVICE_NAME, session_id, "org.bluez.obex.MessageAccess1",
 439                         NULL, &error);
 440         if (error != NULL) {
 441                 BT_ERR("Could not create message access proxy: %s\n", error->message);
 442                 result = BLUETOOTH_ERROR_INTERNAL;
 443         } else {
 444                 if (!message_access_proxy) {
 445                         BT_ERR("message proxy handle is null\n");
 446                         result = BLUETOOTH_ERROR_INTERNAL;
 447                 } else {
 448                         BT_DBG("message proxy set");
 449
 450                         GVariant *filter_variant = g_variant_parse(NULL, filter_serialized, NULL, NULL, NULL);
 451
 452                         GVariant *params = g_variant_new("(@a{sv})", filter_variant);
 453                         GVariant *param = g_variant_new("(i)", request_id);
 454
 455                         g_dbus_proxy_call(message_access_proxy,
 456                                 "ListFolders", params,
 457                                 G_DBUS_CALL_FLAGS_NONE, -1,
 458                                 NULL,
 459                                 (GAsyncReadyCallback)__bt_list_folders_cb,
 460                                 (void*)param);
 461                 }
 462         }
 463
 464         g_object_unref(message_access_proxy);
 465         BT_DBG("-");
 466
 467         return result;
 468 }
 469
 470 static void __bt_list_filter_fields_cb(GDBusProxy *proxy,
 471                                 GAsyncResult *res, gpointer user_data)
 472 {
 473         BT_DBG("+");
 474
 475         GError *error = NULL;
 476         GVariant *value, *in_param, *param;
 477
 478         int result = BLUETOOTH_ERROR_NONE;
 479         int request_id;
 480         char** fields = NULL;
 481         int size = 0;
 482
 483         in_param = (GVariant*) user_data;
 484         g_variant_get(in_param, "(i)", &request_id);
 485
 486         value = g_dbus_proxy_call_finish(proxy, res, &error);
 487
 488         if (error) {
 489                 BT_ERR("%s", error->message);
 490                 g_clear_error(&error);
 491                 result = BLUETOOTH_ERROR_INTERNAL;
 492         }
 493
 494         param = g_variant_new("(ivi)", result, value, request_id);
 495
 496         _bt_send_event(BT_MAP_CLIENT_EVENT, BLUETOOTH_EVENT_MAP_LIST_FILTER_FIELD_COMPLETE,
 497                         param);
 498
 499         g_variant_unref(value);
 500         g_variant_unref(in_param);
 501
 502         BT_DBG("-");
 503 }
 504
 505 int _bt_map_client_list_filter_fields(int request_id, GDBusMethodInvocation *context, const char* session_id)
 506 {
 507         BT_DBG("+");
 508
 509         GError *err = NULL;
 510         GDBusConnection *g_conn;
 511         GDBusProxy *message_proxy;
 512         GVariant *ret = NULL;
 513         int result = BLUETOOTH_ERROR_NONE;
 514
 515         retv_if(session_id == NULL, BLUETOOTH_ERROR_INVALID_PARAM);
 516
 517         g_conn = _bt_gdbus_get_session_gconn();
 518         retv_if(g_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
 519
 520         GVariant *out_param = g_variant_new_from_data((const GVariantType *)"ay",
 521                                                         &request_id, sizeof(int),
 522                                                         TRUE, NULL, NULL);
 523
 524         g_dbus_method_invocation_return_value(context,
 525                         g_variant_new("(iv)", result, out_param));
 526
 527
 528         message_proxy = g_dbus_proxy_new_sync(g_conn,
 529                 G_DBUS_PROXY_FLAGS_NONE, NULL,
 530                 BT_OBEX_SERVICE_NAME, session_id,
 531                 BT_OBEX_MESSAGE_INTERFACE, NULL, &err);
 532
 533         retv_if(message_proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
 534
 535         GVariant *param = g_variant_new("(i)", request_id);
 536
 537         g_dbus_proxy_call(message_proxy,
 538                         "ListFilterFields", g_variant_new("()"),
 539                         G_DBUS_CALL_FLAGS_NONE, -1,
 540                         NULL,
 541                         (GAsyncReadyCallback)__bt_list_filter_fields_cb,
 542                         (void*)param);
 543
 544         g_object_unref(message_proxy);
 545
 546         BT_DBG("-");
 547
 548         return BLUETOOTH_ERROR_NONE;
 549 }
 550
 551 static void __bt_list_messages_cb(
 552         GDBusProxy *proxy, GAsyncResult *res, gpointer user_data)
 553 {
 554         BT_DBG("+");
 555
 556         GError *error = NULL;
 557         GVariant *value, *in_param, *param;
 558
 559         int result = BLUETOOTH_ERROR_NONE;
 560         int request_id;
 561         int size = 0;
 562
 563         in_param = (GVariant*) user_data;
 564         g_variant_get(in_param, "(i)", &request_id);
 565
 566         value = g_dbus_proxy_call_finish(proxy, res, &error);
 567
 568         if (error) {
 569                 BT_ERR("%s", error->message);
 570                 g_clear_error(&error);
 571                 result = BLUETOOTH_ERROR_INTERNAL;
 572         }
 573
 574         param = g_variant_new("(iiv)", result, request_id, value);
 575         BT_DBG("RequestID[%d]", request_id);
 576         result = _bt_send_event(BT_MAP_CLIENT_EVENT,
 577                         BLUETOOTH_EVENT_MAP_LIST_MESSAGES_COMPLETE, param);
 578
 579         g_variant_unref(value);
 580         g_variant_unref(in_param);
 581
 582         BT_DBG("-");
 583 }
 584
 585 int _bt_map_client_list_messages(
 586                 int request_id,
 587                 GDBusMethodInvocation *context,
 588                 const char* session_id,
 589                 const char* folder,
 590                 const char* filter_serialized)
 591 {
 592         BT_DBG("Entered _bt_map_client_list_messages with session id: \"%s\"", session_id);
 593         BT_DBG("Entered folder: %s", folder);
 594         GDBusConnection *g_conn;
 595         GDBusProxy *message_access_proxy;
 596         GError *error = NULL;
 597         int result = BLUETOOTH_ERROR_NONE;
 598
 599         retv_if(session_id == NULL, BLUETOOTH_ERROR_INVALID_PARAM);
 600
 601         g_conn = _bt_gdbus_get_session_gconn();
 602         retv_if(g_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
 603
 604         GVariant *out_param1 = g_variant_new_from_data((const GVariantType *)"ay",
 605                         &request_id, sizeof(int),
 606                         TRUE, NULL, NULL);
 607         g_dbus_method_invocation_return_value(context,
 608                         g_variant_new("(iv)", result, out_param1));
 609
 610         // create message access proxy
 611         g_clear_error(&error);
 612         message_access_proxy = g_dbus_proxy_new_sync(g_conn, G_DBUS_PROXY_FLAGS_NONE, NULL,
 613                         BT_OBEX_SERVICE_NAME, session_id, "org.bluez.obex.MessageAccess1",
 614                         NULL, &error);
 615         if (error != NULL) {
 616                 BT_ERR("Could not create message access proxy: %s\n", error->message);
 617                 result = BLUETOOTH_ERROR_INTERNAL;
 618         } else {
 619                 if (!message_access_proxy) {
 620                         BT_ERR("message proxy handle is null\n");
 621                         result = BLUETOOTH_ERROR_INTERNAL;
 622                 } else {
 623                         BT_DBG("message proxy set");
 624
 625                         GVariant *filter_variant = g_variant_parse(NULL, filter_serialized, NULL, NULL, NULL);
 626
 627                         GVariant *params = g_variant_new("(s@a{sv})", folder, filter_variant);
 628                         GVariant *param = g_variant_new("(i)", request_id);
 629
 630                         g_dbus_proxy_call(message_access_proxy,
 631                                 "ListMessages", params,
 632                                 G_DBUS_CALL_FLAGS_NONE, -1,
 633                                 NULL,
 634                                 (GAsyncReadyCallback)__bt_list_messages_cb,
 635                                 (void*)param);
 636                 }
 637         }
 638
 639         g_object_unref(message_access_proxy);
 640         BT_DBG("-");
 641
 642         return result;
 643 }
 644
 645 int _bt_map_client_update_inbox(const char* session_id)
 646 {
 647         BT_DBG("+");
 648
 649         GError *err = NULL;
 650         GDBusConnection *g_conn;
 651         GDBusProxy *message_proxy;
 652         GVariant *ret = NULL;
 653
 654         g_conn = _bt_gdbus_get_session_gconn();
 655         ret_if(g_conn == NULL);
 656
 657         GVariant *param = g_variant_new("(o)", session_id);
 658
 659         message_proxy = g_dbus_proxy_new_sync(g_conn,
 660                 G_DBUS_PROXY_FLAGS_NONE, NULL,
 661                 BT_OBEX_SERVICE_NAME, session_id,
 662                 BT_OBEX_MESSAGE_INTERFACE, NULL, &err);
 663
 664         retv_if(message_proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
 665
 666         ret = g_dbus_proxy_call_sync(message_proxy,
 667                                 "UpdateInbox", g_variant_new("()"),
 668                                 G_DBUS_CALL_FLAGS_NONE, -1,
 669                                 NULL, &err);
 670
 671         if (ret == NULL) {
 672                 if (err != NULL) {
 673                         BT_ERR("UpdateInbox Error: %s\n", err->message);
 674                         g_error_free(err);
 675                 }
 676         } else {
 677                 g_variant_unref(ret);
 678         }
 679
 680         g_object_unref(message_proxy);
 681
 682         BT_DBG("-");
 683
 684         return BLUETOOTH_ERROR_NONE;
 685 }
 686
 687 int _bt_map_client_push_message(
 688                 const char* session_id,
 689                 const char* source_file,
 690                 const char* folder,
 691                 const char* args_serialized)
 692 {
 693         BT_DBG("+");
 694
 695         /* TODO: MAP */
 696
 697         BT_DBG("-");
 698
 699         return BLUETOOTH_ERROR_NONE;
 700 }
 701
 702 void _bt_on_get_message_finished(const char* transfer_object_path) {
 703         BT_DBG("Entered _bt_on_get_message_finished");
 704         BT_DBG("Looking for transfer %s id", transfer_object_path);
 705
 706
 707         bt_callback_data_t *callback_data = NULL;
 708         GSList* transfer = NULL;
 709         for (transfer = transfer_list; transfer != NULL; transfer = g_slist_next(transfer)) {
 710                 callback_data = transfer->data;
 711                 if (NULL == callback_data) {
 712                         continue;
 713                 }
 714
 715                 if (0 == strcmp(transfer_object_path, callback_data->transfer_path)) {
 716                         BT_DBG("request id FOUND - triggering event");
 717
 718                         GVariant *param = g_variant_new("(ii)", BLUETOOTH_ERROR_NONE, callback_data->request_id);
 719                         _bt_send_event(BT_MAP_CLIENT_EVENT, BLUETOOTH_EVENT_MAP_GET_MESSAGE_COMPLETE, param);
 720
 721                         // remove callback data from list
 722                         g_slist_remove(transfer_list, transfer);
 723
 724                         //free memory and break loop
 725                         free(callback_data->transfer_path);
 726                         callback_data->transfer_path = NULL;
 727                         free(callback_data);
 728                         break;
 729                 }
 730
 731         }
 732 }
 733
 734 static void __bt_get_message_cb(GDBusProxy *proxy,
 735                                 GAsyncResult *res, gpointer user_data)
 736 {
 737         BT_DBG("+");
 738
 739         GError *error = NULL;
 740         GVariant *value, *in_param, *param;
 741
 742         char *transfer_object_path = NULL;
 743         GVariantIter *iter = NULL;
 744
 745         int result = BLUETOOTH_ERROR_NONE;
 746         int request_id;
 747         int size = 0;
 748
 749         in_param = (GVariant*) user_data;
 750         g_variant_get(in_param, "(i)", &request_id);
 751
 752         value = g_dbus_proxy_call_finish(proxy, res, &error);
 753         if (error) {
 754                 BT_ERR("%s", error->message);
 755                 g_clear_error(&error);
 756                 result = BLUETOOTH_ERROR_INTERNAL;
 757         }
 758
 759         if (value) {
 760                 g_variant_get(value, "(oa{sv})", &transfer_object_path, &iter);
 761                 g_variant_unref(value);
 762         }
 763
 764         BT_DBG("transfer object path: [%s]", transfer_object_path);
 765
 766         BT_DBG("Adding request id %d - transfer [%s]", request_id, transfer_object_path);
 767         bt_callback_data_t* callback_data = malloc(sizeof(*callback_data));
 768         callback_data->request_id = request_id;
 769         callback_data->transfer_path = transfer_object_path;
 770
 771         transfer_list = g_slist_append(transfer_list, callback_data);
 772
 773         g_variant_unref(value);
 774         g_variant_unref(in_param);
 775
 776         BT_DBG("-");
 777 }
 778
 779 int _bt_map_client_get_message(
 780                 int request_id,
 781                 GDBusMethodInvocation *context,
 782                 const char* message_object,
 783                 const char* target_file,
 784                 bool attachment)
 785 {
 786         BT_DBG("Entered _bt_map_client_get_message");
 787
 788         GDBusConnection *g_conn;
 789         GDBusProxy *message_proxy;
 790         GError *error = NULL;
 791         int result = BLUETOOTH_ERROR_NONE;
 792
 793         retv_if(message_object == NULL, BLUETOOTH_ERROR_INVALID_PARAM);
 794
 795         // TODO event listeners registration on first call, where should it be unregistered??
 796         _bt_map_client_event_init();
 797
 798         g_conn = _bt_gdbus_get_session_gconn();
 799         retv_if(g_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
 800
 801         GVariant *out_param1 = g_variant_new_from_data((const GVariantType *)"ay",
 802                         &request_id, sizeof(int),
 803                         TRUE, NULL, NULL);
 804         g_dbus_method_invocation_return_value(context, g_variant_new("(iv)", result, out_param1));
 805
 806         // create message proxy
 807         g_clear_error(&error);
 808         message_proxy = g_dbus_proxy_new_sync(g_conn, G_DBUS_PROXY_FLAGS_NONE, NULL,
 809                         BT_OBEX_SERVICE_NAME, message_object, "org.bluez.obex.Message1",
 810                         NULL, &error);
 811         if (error != NULL) {
 812                 BT_ERR("Could not create message proxy: %s\n", error->message);
 813                 result = BLUETOOTH_ERROR_INTERNAL;
 814         } else {
 815                 if (!message_proxy) {
 816                         BT_ERR("message proxy handle is null\n");
 817                         result = BLUETOOTH_ERROR_INTERNAL;
 818                 } else {
 819                         BT_DBG("message proxy set");
 820                         GVariant *params = g_variant_new("(sb)", target_file, attachment);
 821                         GVariant *req_id = g_variant_new("(i)", request_id);
 822
 823                         g_dbus_proxy_call(message_proxy, "Get", params, G_DBUS_CALL_FLAGS_NONE, -1,
 824                                 NULL, (GAsyncReadyCallback)__bt_get_message_cb, (void*)req_id);
 825                 }
 826         }
 827
 828         g_object_unref(message_proxy);
 829         BT_DBG("-");
 830
 831         return result;
 832 }