2 * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
21 #include <mime_type.h>
26 #include "bluetooth-api.h"
27 #include "bt-internal-types.h"
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"
36 #define DBUS_TIMEOUT 20 * 1000 /* 20 Seconds */
38 enum bt_map_transfer_type {
39 BT_MAP_TRANSFER_GET_MESSAGE = 0,
40 BT_MAP_TRANSFER_PUSH_MESSAGE
44 enum bt_map_transfer_type transfer_type;
47 } bt_map_callback_data_t;
49 static GSList *transfer_list = NULL;
51 bt_session_info_t *session_info;
53 static void __bt_free_session_info(bt_session_info_t *info)
57 /* TODO: MAP bt_session_info_t, see bt-service-opp-client.c */
59 g_free(info->address);
63 static void __bt_free_session_data(gpointer data)
65 bt_session_data_t *info = data;
69 _bt_delete_request_id(info->request_id);
71 /* TODO: MAP bt_session_data_t, see bt-service-opp-client.c */
73 g_free(info->address);
77 static void __bt_session_release_cb(GDBusProxy *proxy,
78 GAsyncResult *res, gpointer user_data)
81 ret_if(session_info == NULL);
84 int result = BLUETOOTH_ERROR_NONE;
85 GVariant *param = NULL;
86 g_dbus_proxy_call_finish(proxy, res, &error);
88 g_object_unref(proxy);
91 BT_ERR("%s", error->message);
94 result = BLUETOOTH_ERROR_INTERNAL;
96 BT_DBG("Session Removed");
99 session_info->result = result;
100 param = g_variant_new("(isi)", session_info->result,
101 session_info->address,
102 session_info->request_id);
103 /* Send the event in only error none case */
104 _bt_send_event(BT_OPP_CLIENT_EVENT,
105 BLUETOOTH_EVENT_OPC_DISCONNECTED,
108 __bt_free_session_info(session_info);
111 _bt_map_client_event_deinit();
113 /* Operate remain works */
124 static int _bt_remove_session()
126 GDBusConnection *g_conn;
127 GDBusProxy *session_proxy;
130 g_conn = _bt_gdbus_get_session_gconn();
131 retv_if(g_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
132 retv_if(session_info->session_path == NULL, BLUETOOTH_ERROR_INVALID_PARAM);
134 session_proxy = g_dbus_proxy_new_sync(g_conn, G_DBUS_PROXY_FLAGS_NONE,
135 NULL, BT_OBEXD_DBUS_NAME,
137 BT_OBEX_CLIENT_INTERFACE,
140 retv_if(session_proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
142 g_dbus_proxy_call(session_proxy, "RemoveSession",
143 g_variant_new("(o)", session_info->session_path),
144 G_DBUS_CALL_FLAGS_NONE,
146 (GAsyncReadyCallback)__bt_session_release_cb,
149 return BLUETOOTH_ERROR_NONE;
152 void _bt_map_disconnected(const char *session_path)
155 GVariant *param = NULL;
156 ret_if(session_info == NULL);
158 if (g_strcmp0(session_info->session_path,
159 session_path) != 0) {
160 BT_INFO("Path mismatch, previous transfer failed! Returning");
164 param = g_variant_new("(isi)", session_info->result,
165 session_info->address,
166 session_info->request_id);
167 _bt_send_event(BT_MAP_CLIENT_EVENT,
168 BLUETOOTH_EVENT_MAP_DISCONNECTED,
171 __bt_free_session_info(session_info);
177 static void __bt_create_session_cb(GDBusProxy *proxy,
178 GAsyncResult *res, gpointer user_data)
182 GError *error = NULL;
184 int result = BLUETOOTH_ERROR_NONE;
185 char *session_path = NULL;
186 GVariant *param = NULL;
188 value = g_dbus_proxy_call_finish(proxy, res, &error);
190 g_variant_get(value, "(o)", &session_path);
191 g_variant_unref(value);
195 BT_ERR("%s", error->message);
196 g_clear_error(&error);
198 result = BLUETOOTH_ERROR_INTERNAL;
200 BT_DBG("Session created");
201 if (session_info != NULL)
202 session_info->session_path = g_strdup(session_path);
204 g_free(session_path);
205 g_object_unref(proxy);
206 ret_if(session_info == NULL);
208 session_info->result = result;
209 param = g_variant_new("(isi)", result,
210 session_info->address,
211 session_info->request_id);
212 /* Send the event in only error none case */
213 _bt_send_event(BT_MAP_CLIENT_EVENT,
214 BLUETOOTH_EVENT_MAP_CONNECTED,
217 if (result != BLUETOOTH_ERROR_NONE) {
218 BT_ERR("Calling __bt_session_release");
219 gboolean ret = __bt_session_release();
221 __bt_free_session_info(session_info);
225 BT_DBG("ReleaseSession Not called");
226 /* Operate remain works */
240 static int __bt_opp_client_start_XXXXXXXXXX(int request_id, char *address
241 /* parameters................... */)
246 int _bt_create_session_sync(const char* address, char** session_id)
248 BT_DBG("Entered SERVICE create session");
249 GDBusConnection *g_conn;
250 GDBusProxy *session_proxy;
252 const char *session_path;
254 retv_if(address == NULL, BLUETOOTH_ERROR_INVALID_PARAM);
256 g_conn = _bt_gdbus_get_session_gconn();
257 retv_if(g_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
259 session_proxy = g_dbus_proxy_new_sync(g_conn, G_DBUS_PROXY_FLAGS_NONE,
260 NULL, BT_OBEX_SERVICE_NAME,
262 BT_OBEX_CLIENT_INTERFACE,
265 BT_ERR("Unable to create session_proxy: %s", err->message);
267 return BLUETOOTH_ERROR_INTERNAL;
269 retv_if(session_proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
271 GVariantBuilder* builder = g_variant_builder_new (G_VARIANT_TYPE_ARRAY);
272 g_variant_builder_add(builder, "{sv}", "Target",
273 g_variant_new("s", "map"));
274 GVariant *args = g_variant_builder_end(builder);
275 g_variant_builder_unref (builder);
276 GVariant *param = g_variant_new("(s@a{sv})", address, args);
278 char* string = g_variant_print (param, true);
280 GVariant *value = g_dbus_proxy_call_sync(session_proxy, "CreateSession", param,
281 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &err);
283 BT_ERR("Could not create session: %s\n", err->message);
285 return BLUETOOTH_ERROR_INTERNAL;
288 BT_ERR("create session returned value is null\n");
289 return BLUETOOTH_ERROR_INTERNAL;
291 BT_DBG("create session succeed\n");
295 g_variant_get(value, "(&o)", session_id);
296 BT_DBG("session_id = \"%s\"\n", *session_id);
298 return BLUETOOTH_ERROR_NONE;
301 int _bt_destroy_session_sync(const char* session_id)
303 BT_DBG("Entered SERVICE destroy session with id: \"%s\"", session_id);
304 GDBusConnection *g_conn;
305 GDBusProxy *session_proxy;
308 retv_if(session_id == NULL, BLUETOOTH_ERROR_INVALID_PARAM);
310 g_conn = _bt_gdbus_get_session_gconn();
311 retv_if(g_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
313 session_proxy = g_dbus_proxy_new_sync(g_conn, G_DBUS_PROXY_FLAGS_NONE,
314 NULL, BT_OBEX_SERVICE_NAME,
316 BT_OBEX_CLIENT_INTERFACE,
319 BT_ERR("Unable to create session_proxy: %s", err->message);
321 return BLUETOOTH_ERROR_INTERNAL;
323 retv_if(session_proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
325 GVariant *param = g_variant_new("(o)", session_id);
327 GVariant *value = g_dbus_proxy_call_sync(session_proxy, "RemoveSession", param,
328 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &err);
330 BT_ERR("Could not remove session: %s\n", err->message);
332 return BLUETOOTH_ERROR_INTERNAL;
334 BT_DBG("remove session succeed\n");
337 return BLUETOOTH_ERROR_NONE;
340 int _bt_map_client_set_folder(const char* session_id, const char* name)
345 GDBusConnection *g_conn;
346 GDBusProxy *message_proxy;
347 GVariant *ret = NULL;
349 g_conn = _bt_gdbus_get_session_gconn();
350 ret_if(g_conn == NULL);
352 GVariant *param = g_variant_new("(o)", session_id);
354 message_proxy = g_dbus_proxy_new_sync(g_conn,
355 G_DBUS_PROXY_FLAGS_NONE, NULL,
356 BT_OBEX_SERVICE_NAME, session_id,
357 BT_OBEX_MESSAGE_INTERFACE, NULL, &err);
359 retv_if(message_proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
361 ret = g_dbus_proxy_call_sync(message_proxy,
362 "SetFolder", g_variant_new("(s)", name),
363 G_DBUS_CALL_FLAGS_NONE, DBUS_TIMEOUT,
368 BT_ERR("SetFolder Error: %s\n", err->message);
372 g_variant_unref(ret);
375 g_object_unref(message_proxy);
379 return BLUETOOTH_ERROR_NONE;
382 static void __bt_list_folders_cb(GDBusProxy *proxy,
383 GAsyncResult *res, gpointer user_data)
387 GError *error = NULL;
388 GVariant *value, *in_param, *param;
390 int result = BLUETOOTH_ERROR_NONE;
394 in_param = (GVariant*) user_data;
395 g_variant_get(in_param, "(i)", &request_id);
397 value = g_dbus_proxy_call_finish(proxy, res, &error);
400 BT_ERR("%s", error->message);
401 g_clear_error(&error);
402 result = BLUETOOTH_ERROR_INTERNAL;
405 param = g_variant_new("(iiv)", result, request_id, value);
406 BT_DBG("RequestID[%d]", request_id);
407 result = _bt_send_event(BT_MAP_CLIENT_EVENT,
408 BLUETOOTH_EVENT_MAP_LIST_FOLDERS_COMPLETE, param);
410 g_variant_unref(value);
411 g_variant_unref(in_param);
416 int _bt_map_client_list_folders(
418 GDBusMethodInvocation *context,
419 const char* session_id,
420 const char* filter_serialized)
422 BT_DBG("Entered _bt_map_list_folders with session id: \"%s\"", session_id);
423 GDBusConnection *g_conn;
424 GDBusProxy *message_access_proxy;
425 GError *error = NULL;
426 int result = BLUETOOTH_ERROR_NONE;
428 retv_if(session_id == NULL, BLUETOOTH_ERROR_INVALID_PARAM);
430 g_conn = _bt_gdbus_get_session_gconn();
431 retv_if(g_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
433 GVariant *out_param1 = g_variant_new_from_data((const GVariantType *)"ay",
434 &request_id, sizeof(int),
436 g_dbus_method_invocation_return_value(context,
437 g_variant_new("(iv)", result, out_param1));
439 // create message access proxy
440 g_clear_error(&error);
441 message_access_proxy = g_dbus_proxy_new_sync(g_conn, G_DBUS_PROXY_FLAGS_NONE, NULL,
442 BT_OBEX_SERVICE_NAME, session_id, "org.bluez.obex.MessageAccess1",
445 BT_ERR("Could not create message access proxy: %s\n", error->message);
446 result = BLUETOOTH_ERROR_INTERNAL;
448 if (!message_access_proxy) {
449 BT_ERR("message proxy handle is null\n");
450 result = BLUETOOTH_ERROR_INTERNAL;
452 BT_DBG("message proxy set");
454 GVariant *filter_variant = g_variant_parse(NULL, filter_serialized, NULL, NULL, NULL);
456 GVariant *params = g_variant_new("(@a{sv})", filter_variant);
457 GVariant *param = g_variant_new("(i)", request_id);
459 g_dbus_proxy_call(message_access_proxy,
460 "ListFolders", params,
461 G_DBUS_CALL_FLAGS_NONE, -1,
463 (GAsyncReadyCallback)__bt_list_folders_cb,
468 g_object_unref(message_access_proxy);
474 static void __bt_list_filter_fields_cb(GDBusProxy *proxy,
475 GAsyncResult *res, gpointer user_data)
479 GError *error = NULL;
480 GVariant *value, *in_param, *param;
482 int result = BLUETOOTH_ERROR_NONE;
484 char** fields = NULL;
487 in_param = (GVariant*) user_data;
488 g_variant_get(in_param, "(i)", &request_id);
490 value = g_dbus_proxy_call_finish(proxy, res, &error);
493 BT_ERR("%s", error->message);
494 g_clear_error(&error);
495 result = BLUETOOTH_ERROR_INTERNAL;
498 param = g_variant_new("(ivi)", result, value, request_id);
500 _bt_send_event(BT_MAP_CLIENT_EVENT, BLUETOOTH_EVENT_MAP_LIST_FILTER_FIELD_COMPLETE,
503 g_variant_unref(value);
504 g_variant_unref(in_param);
509 int _bt_map_client_list_filter_fields(int request_id, GDBusMethodInvocation *context, const char* session_id)
514 GDBusConnection *g_conn;
515 GDBusProxy *message_proxy;
516 GVariant *ret = NULL;
517 int result = BLUETOOTH_ERROR_NONE;
519 retv_if(session_id == NULL, BLUETOOTH_ERROR_INVALID_PARAM);
521 g_conn = _bt_gdbus_get_session_gconn();
522 retv_if(g_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
524 GVariant *out_param = g_variant_new_from_data((const GVariantType *)"ay",
525 &request_id, sizeof(int),
528 g_dbus_method_invocation_return_value(context,
529 g_variant_new("(iv)", result, out_param));
532 message_proxy = g_dbus_proxy_new_sync(g_conn,
533 G_DBUS_PROXY_FLAGS_NONE, NULL,
534 BT_OBEX_SERVICE_NAME, session_id,
535 BT_OBEX_MESSAGE_INTERFACE, NULL, &err);
537 retv_if(message_proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
539 GVariant *param = g_variant_new("(i)", request_id);
541 g_dbus_proxy_call(message_proxy,
542 "ListFilterFields", g_variant_new("()"),
543 G_DBUS_CALL_FLAGS_NONE, -1,
545 (GAsyncReadyCallback)__bt_list_filter_fields_cb,
548 g_object_unref(message_proxy);
552 return BLUETOOTH_ERROR_NONE;
555 static void __bt_list_messages_cb(
556 GDBusProxy *proxy, GAsyncResult *res, gpointer user_data)
560 GError *error = NULL;
561 GVariant *value, *in_param, *param;
563 int result = BLUETOOTH_ERROR_NONE;
567 in_param = (GVariant*) user_data;
568 g_variant_get(in_param, "(i)", &request_id);
570 value = g_dbus_proxy_call_finish(proxy, res, &error);
573 BT_ERR("%s", error->message);
574 g_clear_error(&error);
575 result = BLUETOOTH_ERROR_INTERNAL;
578 param = g_variant_new("(iiv)", result, request_id, value);
579 BT_DBG("RequestID[%d]", request_id);
580 result = _bt_send_event(BT_MAP_CLIENT_EVENT,
581 BLUETOOTH_EVENT_MAP_LIST_MESSAGES_COMPLETE, param);
583 g_variant_unref(value);
584 g_variant_unref(in_param);
589 int _bt_map_client_list_messages(
591 GDBusMethodInvocation *context,
592 const char* session_id,
594 const char* filter_serialized)
596 BT_DBG("Entered _bt_map_client_list_messages with session id: \"%s\"", session_id);
597 BT_DBG("Entered folder: %s", folder);
598 GDBusConnection *g_conn;
599 GDBusProxy *message_access_proxy;
600 GError *error = NULL;
601 int result = BLUETOOTH_ERROR_NONE;
603 retv_if(session_id == NULL, BLUETOOTH_ERROR_INVALID_PARAM);
605 g_conn = _bt_gdbus_get_session_gconn();
606 retv_if(g_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
608 GVariant *out_param1 = g_variant_new_from_data((const GVariantType *)"ay",
609 &request_id, sizeof(int),
611 g_dbus_method_invocation_return_value(context,
612 g_variant_new("(iv)", result, out_param1));
614 // create message access proxy
615 g_clear_error(&error);
616 message_access_proxy = g_dbus_proxy_new_sync(g_conn, G_DBUS_PROXY_FLAGS_NONE, NULL,
617 BT_OBEX_SERVICE_NAME, session_id, "org.bluez.obex.MessageAccess1",
620 BT_ERR("Could not create message access proxy: %s\n", error->message);
621 result = BLUETOOTH_ERROR_INTERNAL;
623 if (!message_access_proxy) {
624 BT_ERR("message proxy handle is null\n");
625 result = BLUETOOTH_ERROR_INTERNAL;
627 BT_DBG("message proxy set");
629 GVariant *filter_variant = g_variant_parse(NULL, filter_serialized, NULL, NULL, NULL);
631 GVariant *params = g_variant_new("(s@a{sv})", folder, filter_variant);
632 GVariant *param = g_variant_new("(i)", request_id);
634 g_dbus_proxy_call(message_access_proxy,
635 "ListMessages", params,
636 G_DBUS_CALL_FLAGS_NONE, -1,
638 (GAsyncReadyCallback)__bt_list_messages_cb,
643 g_object_unref(message_access_proxy);
649 int _bt_map_client_update_inbox(const char* session_id)
654 GDBusConnection *g_conn;
655 GDBusProxy *message_proxy;
656 GVariant *ret = NULL;
658 g_conn = _bt_gdbus_get_session_gconn();
659 ret_if(g_conn == NULL);
661 GVariant *param = g_variant_new("(o)", session_id);
663 message_proxy = g_dbus_proxy_new_sync(g_conn,
664 G_DBUS_PROXY_FLAGS_NONE, NULL,
665 BT_OBEX_SERVICE_NAME, session_id,
666 BT_OBEX_MESSAGE_INTERFACE, NULL, &err);
668 retv_if(message_proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
670 ret = g_dbus_proxy_call_sync(message_proxy,
671 "UpdateInbox", g_variant_new("()"),
672 G_DBUS_CALL_FLAGS_NONE, -1,
677 BT_ERR("UpdateInbox Error: %s\n", err->message);
681 g_variant_unref(ret);
684 g_object_unref(message_proxy);
688 return BLUETOOTH_ERROR_NONE;
691 void _bt_map_on_transfer_finished(const char* transfer_object_path, const int error) {
692 BT_DBG("Entered _bt_map_on_transfer_finished");
693 BT_DBG("Looking for transfer %s id", transfer_object_path);
695 bt_map_callback_data_t *callback_data = NULL;
696 GSList* transfer = NULL;
697 for (transfer = transfer_list; transfer != NULL; transfer = g_slist_next(transfer)) {
698 callback_data = transfer->data;
699 if (NULL == callback_data) {
703 if (0 == strcmp(transfer_object_path, callback_data->transfer_path)) {
704 BT_DBG("request id FOUND - triggering event");
706 GVariant *param = g_variant_new("(ii)", error, callback_data->request_id);
709 switch (callback_data->transfer_type) {
710 case BT_MAP_TRANSFER_GET_MESSAGE:
711 event = BLUETOOTH_EVENT_MAP_GET_MESSAGE_COMPLETE;
713 case BT_MAP_TRANSFER_PUSH_MESSAGE:
714 event = BLUETOOTH_EVENT_MAP_PUSH_MESSAGE_COMPLETE;
718 _bt_send_event(BT_MAP_CLIENT_EVENT, event, param);
720 // remove callback data from list
721 g_slist_remove(transfer_list, transfer);
723 //free memory and break loop
724 free(callback_data->transfer_path);
725 callback_data->transfer_path = NULL;
733 static void __bt_push_message_cb(GDBusProxy *proxy,
734 GAsyncResult *res, gpointer user_data)
738 GError *error = NULL;
739 GVariant *value, *in_param, *param;
741 char *transfer_object_path = NULL;
742 GVariantIter *iter = NULL;
744 int result = BLUETOOTH_ERROR_NONE;
748 in_param = (GVariant*) user_data;
749 g_variant_get(in_param, "(i)", &request_id);
751 value = g_dbus_proxy_call_finish(proxy, res, &error);
753 BT_ERR("%s", error->message);
754 g_clear_error(&error);
755 result = BLUETOOTH_ERROR_INTERNAL;
759 g_variant_get(value, "(oa{sv})", &transfer_object_path, &iter);
760 g_variant_unref(value);
763 BT_DBG("transfer object path: [%s]", transfer_object_path);
765 BT_DBG("Adding request id %d - transfer [%s]", request_id, transfer_object_path);
766 bt_map_callback_data_t* callback_data = malloc(sizeof(*callback_data));
767 callback_data->transfer_type = BT_MAP_TRANSFER_PUSH_MESSAGE;
768 callback_data->request_id = request_id;
769 callback_data->transfer_path = transfer_object_path;
771 transfer_list = g_slist_append(transfer_list, callback_data);
773 g_variant_unref(value);
774 g_variant_unref(in_param);
779 int _bt_map_client_push_message(
781 GDBusMethodInvocation *context,
782 const char* session_id,
783 const char* source_file,
785 const char* args_serialized)
787 BT_DBG("Entered _bt_map_client_push_message with session id: \"%s\"", session_id);
788 BT_DBG("Entered source_file: %s", source_file);
789 BT_DBG("Entered folder: %s", folder);
791 GDBusConnection *g_conn;
792 GDBusProxy *message_access_proxy;
793 GError *error = NULL;
794 int result = BLUETOOTH_ERROR_NONE;
796 retv_if(session_id == NULL, BLUETOOTH_ERROR_INVALID_PARAM);
798 // TODO event listeners registration on first call, where should it be unregistered??
799 _bt_map_client_event_init();
801 g_conn = _bt_gdbus_get_session_gconn();
802 retv_if(g_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
804 GVariant *out_param1 = g_variant_new_from_data((const GVariantType *)"ay",
805 &request_id, sizeof(int),
807 g_dbus_method_invocation_return_value(context, g_variant_new("(iv)", result, out_param1));
809 // create message access proxy
810 g_clear_error(&error);
811 message_access_proxy = g_dbus_proxy_new_sync(g_conn, G_DBUS_PROXY_FLAGS_NONE, NULL,
812 BT_OBEX_SERVICE_NAME, session_id, BT_OBEX_MESSAGE_INTERFACE,
815 BT_ERR("Could not create message access proxy: %s\n", error->message);
816 result = BLUETOOTH_ERROR_INTERNAL;
818 if (!message_access_proxy) {
819 BT_ERR("message proxy handle is null\n");
820 result = BLUETOOTH_ERROR_INTERNAL;
822 BT_DBG("message proxy set");
824 GVariant *args_variant = g_variant_parse(NULL, args_serialized, NULL, NULL, NULL);
826 GVariant *params = g_variant_new("(ss@a{sv})", source_file, folder, args_variant);
827 GVariant *req_id = g_variant_new("(i)", request_id);
829 g_dbus_proxy_call(message_access_proxy,
830 "PushMessage", params,
831 G_DBUS_CALL_FLAGS_NONE, -1,
832 NULL, (GAsyncReadyCallback)__bt_push_message_cb,
837 g_object_unref(message_access_proxy);
843 static void __bt_get_message_cb(GDBusProxy *proxy,
844 GAsyncResult *res, gpointer user_data)
848 GError *error = NULL;
849 GVariant *value, *in_param, *param;
851 char *transfer_object_path = NULL;
852 GVariantIter *iter = NULL;
854 int result = BLUETOOTH_ERROR_NONE;
858 in_param = (GVariant*) user_data;
859 g_variant_get(in_param, "(i)", &request_id);
861 value = g_dbus_proxy_call_finish(proxy, res, &error);
863 BT_ERR("%s", error->message);
864 g_clear_error(&error);
865 result = BLUETOOTH_ERROR_INTERNAL;
869 g_variant_get(value, "(oa{sv})", &transfer_object_path, &iter);
870 g_variant_unref(value);
873 BT_DBG("transfer object path: [%s]", transfer_object_path);
875 BT_DBG("Adding request id %d - transfer [%s]", request_id, transfer_object_path);
876 bt_map_callback_data_t* callback_data = malloc(sizeof(*callback_data));
877 callback_data->transfer_type = BT_MAP_TRANSFER_GET_MESSAGE;
878 callback_data->request_id = request_id;
879 callback_data->transfer_path = transfer_object_path;
881 transfer_list = g_slist_append(transfer_list, callback_data);
883 g_variant_unref(value);
884 g_variant_unref(in_param);
889 int _bt_map_client_get_message(
891 GDBusMethodInvocation *context,
892 const char* message_object,
893 const char* target_file,
896 BT_DBG("Entered _bt_map_client_get_message");
898 GDBusConnection *g_conn;
899 GDBusProxy *message_proxy;
900 GError *error = NULL;
901 int result = BLUETOOTH_ERROR_NONE;
903 retv_if(message_object == NULL, BLUETOOTH_ERROR_INVALID_PARAM);
905 // TODO event listeners registration on first call, where should it be unregistered??
906 _bt_map_client_event_init();
908 g_conn = _bt_gdbus_get_session_gconn();
909 retv_if(g_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
911 GVariant *out_param1 = g_variant_new_from_data((const GVariantType *)"ay",
912 &request_id, sizeof(int),
914 g_dbus_method_invocation_return_value(context, g_variant_new("(iv)", result, out_param1));
916 // create message proxy
917 g_clear_error(&error);
918 message_proxy = g_dbus_proxy_new_sync(g_conn, G_DBUS_PROXY_FLAGS_NONE, NULL,
919 BT_OBEX_SERVICE_NAME, message_object, "org.bluez.obex.Message1",
922 BT_ERR("Could not create message proxy: %s\n", error->message);
923 result = BLUETOOTH_ERROR_INTERNAL;
925 if (!message_proxy) {
926 BT_ERR("message proxy handle is null\n");
927 result = BLUETOOTH_ERROR_INTERNAL;
929 BT_DBG("message proxy set");
930 GVariant *params = g_variant_new("(sb)", target_file, attachment);
931 GVariant *req_id = g_variant_new("(i)", request_id);
933 g_dbus_proxy_call(message_proxy, "Get", params, G_DBUS_CALL_FLAGS_NONE, -1,
934 NULL, (GAsyncReadyCallback)__bt_get_message_cb, (void*)req_id);
938 g_object_unref(message_proxy);