4 * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
6 * Contact: Hocheol Seo <hocheol.seo@samsung.com>
7 * Syam Sidhardhan <s.syam@samsung.com>
8 * Chanyeol Park <chanyeol.park@samsung.com>
10 * Licensed under the Apache License, Version 2.0 (the "License");
11 * you may not use this file except in compliance with the License.
12 * You may obtain a copy of the License at
14 * http://www.apache.org/licenses/LICENSE-2.0
16 * Unless required by applicable law or agreed to in writing, software
17 * distributed under the License is distributed on an "AS IS" BASIS,
18 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
19 * See the License for the specific language governing permissions and
20 * limitations under the License.
24 #include <bluetooth_map_agent.h>
25 #include <map_bmessage.h>
27 /*Messaging Header Files*/
29 #include "msg_storage.h"
30 #include "msg_storage_types.h"
31 #include "msg_transport.h"
32 #include "msg_transport_types.h"
33 #include "msg_types.h"
37 #define BT_MAP_STATUS_CB "sent status callback"
38 #define BT_MAP_MSG_CB "sms message callback"
39 #define BT_MAP_DELETED_FOLDER_NAME "DELETED"
40 #define BT_MAP_SENT_FOLDER_NAME "SENT"
41 #define BT_MAP_MSG_TEMPLATE "TEMPLATE"
43 #define BT_MAP_MSG_INFO_MAX 256
44 #define BT_MAP_MSG_HANDLE_MAX 21
45 #define BT_MAP_TIMESTAMP_MAX_LEN 16
46 #define BT_MAP_MSG_BODY_MAX 1024
48 #define BEGIN_BMSEG "BEGIN:BMSG\r\n"
49 #define END_BMSEG "END:BMSG\r\n"
50 #define BMSEG_VERSION "VERSION:1.0\r\n"
51 #define MSEG_STATUS "STATUS:%s\r\n"
52 #define MSEG_TYPE "TYPE:%s\r\n"
53 #define FOLDER_PATH "FOLDER:%s\r\n"
54 #define VCARD "BEGIN:VCARD\r\nVERSION:2.1\r\nN:%s\r\nTEL:%s\r\nEND:VCARD\r\n"
55 #define BEGIN_BENV "BEGIN:BENV\r\n"
56 #define END_BENV "END:BENV\r\n"
57 #define BEGIN_BBODY "BEGIN:BBODY\r\n"
58 #define END_BBODY "END:BBODY\r\n"
59 #define ENCODING "ENCODING:%s\r\n"
60 #define CHARSET "CHARSET:%s\r\n"
61 #define LANGUAGE "LANGUAGE:%s\r\n"
62 #define LENGTH "LENGTH:%d\r\n"
63 #define MSG_BODY "BEGIN:MSG\r\n%s\r\nEND:MSG\r\n"
64 #define MSG_BODY_BEGIN "BEGIN:MSG\r\n"
65 #define MSG_BODY_END "\r\nEND:MSG\r\n"
67 static msg_handle_t g_msg_handle = NULL;
68 extern guint64 current_push_map_id;
70 static int __bt_get_sms_folder_id(char *folder_path)
76 msg_struct_list_s folder_list = {0,};
78 msg_struct_t p_folder;
79 DBG_SECURE("folder_path %s\n", folder_path);
81 folder = strrchr(folder_path, '/');
87 err = msg_get_folder_list(g_msg_handle, &folder_list);
88 if (err != MSG_SUCCESS)
91 for (i = 0; i < folder_list.nCount; i++) {
92 char folder_name[BT_MAP_MSG_INFO_MAX] = {0, };
94 p_folder = folder_list.msg_struct_info[i];
96 err = msg_get_str_value(p_folder, MSG_FOLDER_INFO_NAME_STR,
97 folder_name, BT_MAP_MSG_INFO_MAX);
98 if (err != MSG_SUCCESS)
101 DBG_SECURE("folder_name %s\n", folder_name);
102 if (!g_ascii_strncasecmp(folder_name, folder, strlen(folder))) {
103 err = msg_get_int_value(p_folder,
104 MSG_FOLDER_INFO_ID_INT,
106 if (err != MSG_SUCCESS)
109 DBG("folder_id %d", folder_id);
115 if (folder_list.msg_struct_info)
116 msg_release_list_struct(&folder_list);
124 static void __bt_add_deleted_folder(void)
128 msg_struct_t folder_info = msg_create_struct(MSG_STRUCT_FOLDER_INFO);
130 err = msg_set_int_value(folder_info, MSG_FOLDER_INFO_TYPE_INT,
131 MSG_FOLDER_TYPE_USER_DEF);
132 if (err != MSG_SUCCESS) {
133 /* LCOV_EXCL_START */
134 ERR("Failed adding type %d", err);
135 msg_release_struct(&folder_info);
140 err = msg_set_str_value(folder_info, MSG_FOLDER_INFO_NAME_STR,
141 "DELETED", MAX_FOLDER_NAME_SIZE);
142 if (err != MSG_SUCCESS) {
143 /* LCOV_EXCL_START */
144 ERR("Failed adding str %d", err);
145 msg_release_struct(&folder_info);
150 err = msg_add_folder(g_msg_handle, folder_info);
151 if (err != MSG_SUCCESS) {
152 /* LCOV_EXCL_START */
153 ERR("Failed adding folder %d", err);
154 msg_release_struct(&folder_info);
159 msg_release_struct(&folder_info);
163 /* LCOV_EXCL_START */
164 static void __bluetooth_map_msg_incoming_status_cb(msg_handle_t handle,
175 if (is_mns_connected() == FALSE) {
176 INFO("MNS Client not connected");
180 ret = msg_get_int_value(msg, MSG_MESSAGE_TYPE_INT, &msg_type);
181 if (ret != MSG_SUCCESS)
184 if (msg_type != MSG_TYPE_SMS) {
189 ret = msg_get_int_value(msg, MSG_MESSAGE_ID_INT, &msg_id);
190 if (ret != MSG_SUCCESS)
193 uid = _bt_add_id(msg_id, BT_MAP_ID_SMS);
195 _bt_mns_client_event_notify("NewMessage", uid,
196 "TELECOM/MSG/INBOX", "",
202 static void __bluetooth_map_msg_sent_status_cb(msg_handle_t handle,
210 if (is_mns_connected() == FALSE) {
211 INFO("MNS Client not connected");
215 ret = msg_get_int_value(msg, MSG_SENT_STATUS_NETWORK_STATUS_INT,
217 if (ret != MSG_SUCCESS)
220 if (status == MSG_NETWORK_SEND_SUCCESS) {
221 INFO("MSG SENT SUCCESS !!! ");
222 _bt_mns_client_event_notify("MessageShift",
225 "TELECOM/MSG/OUTBOX",
228 _bt_mns_client_event_notify("SendingSuccess",
230 "TELECOM/MSG/SENT", "",
233 ERR("MSG SENT FAIL !!! [%d]", status);
234 _bt_mns_client_event_notify("SendingFailure",
236 "TELECOM/MSG/OUTBOX", "",
244 gboolean _bt_map_sms_get_supported_folders(gboolean folders[FOLDER_COUNT][MSG_TYPES])
247 char folder_name[BT_MAP_MSG_INFO_MAX] = {0,};
250 gboolean msg_ret = TRUE;
252 msg_struct_list_s folder_list = {0,};
253 msg_struct_t p_folder;
255 if (g_msg_handle == NULL) {
260 /* LCOV_EXCL_START */
261 if (msg_get_folder_list(g_msg_handle, &folder_list) != MSG_SUCCESS) {
266 for (i = 0; i < folder_list.nCount; i++) {
267 p_folder = folder_list.msg_struct_info[i];
268 memset(folder_name, 0x00, BT_MAP_MSG_INFO_MAX);
270 ret = msg_get_str_value(p_folder, MSG_FOLDER_INFO_NAME_STR,
271 folder_name, BT_MAP_MSG_INFO_MAX);
272 if (ret != MSG_SUCCESS)
275 DBG("%d. %s", i, folder_name);
276 if (g_strstr_len(folder_name, -1, BT_MAP_MSG_TEMPLATE) ||
277 g_strstr_len(folder_name, -1, "CBMSGBOX") ||
278 g_strstr_len(folder_name, -1, "SPAMBOX"))
281 if (!g_ascii_strncasecmp(folder_name, BT_MAP_SENT_FOLDER_NAME,
282 strlen(BT_MAP_SENT_FOLDER_NAME))) {
283 memset(folder_name, 0, sizeof(folder_name));
284 g_strlcpy(folder_name, BT_MAP_SENT_FOLDER_NAME,
285 sizeof(folder_name));
286 folders[BT_MSG_SENT][BT_MSG_SOURCE_SMS] = TRUE;
288 } else if (!g_ascii_strcasecmp(folder_name, "INBOX")) {
289 folders[BT_MSG_INBOX][BT_MSG_SOURCE_SMS] = TRUE;
291 } else if (!g_ascii_strcasecmp(folder_name, "OUTBOX")) {
292 folders[BT_MSG_OUTBOX][BT_MSG_SOURCE_SMS] = TRUE;
294 } else if (!g_ascii_strcasecmp(folder_name, "DRAFT")) {
295 folders[BT_MSG_DRAFT][BT_MSG_SOURCE_SMS] = TRUE;
297 } else if (!g_ascii_strcasecmp(folder_name, "DELETED")) {
298 folders[BT_MSG_DELETED][BT_MSG_SOURCE_SMS] = TRUE;
306 if (folder_list.msg_struct_info)
307 msg_release_list_struct(&folder_list); /* LCOV_EXCL_LINE */
313 gboolean _bt_map_sms_set_read_status(int msg_id, gboolean read_status)
318 msg_err = msg_update_read_status(g_msg_handle, msg_id,
320 if (msg_err != MSG_SUCCESS) {
321 ERR("Failed to Set Read Status");
329 /* LCOV_EXCL_START */
330 static gchar *__bt_get_sms_folder_name(int id)
336 gboolean path_found = FALSE;
337 char folder_name[BT_MAP_MSG_INFO_MAX] = {0,};
339 msg_struct_list_s folder_list = {0,};
340 msg_struct_t p_folder;
342 ret = msg_get_folder_list(g_msg_handle, &folder_list);
343 if (ret != MSG_SUCCESS)
344 return g_strdup("TELECOM/MSG");
346 if (folder_list.msg_struct_info == NULL)
347 return g_strdup("TELECOM/MSG");
349 for (i = 0; i < folder_list.nCount; i++) {
350 p_folder = folder_list.msg_struct_info[i];
352 ret = msg_get_int_value(p_folder,
353 MSG_FOLDER_INFO_ID_INT,
355 if (ret != MSG_SUCCESS)
357 DBG("folder_id %d, id = %d", folder_id, id);
358 if (folder_id == id) {
359 ret = msg_get_str_value(p_folder,
360 MSG_FOLDER_INFO_NAME_STR,
361 folder_name, BT_MAP_MSG_INFO_MAX);
362 if (ret != MSG_SUCCESS)
366 DBG_SECURE("folder_name %s", folder_name);
371 if (folder_list.msg_struct_info) {
372 ret = msg_release_list_struct(&folder_list);
377 if (path_found != TRUE)
378 return g_strdup("TELECOM/MSG");
380 return g_strdup_printf("TELECOM/MSG/%s", folder_name);
384 gboolean _bt_map_set_sms_delete_status(int msg_id, gboolean delete_status)
390 gchar *folder_name = NULL;
392 msg_struct_t msg = NULL;
393 msg_struct_t send_opt = NULL;
399 /* LCOV_EXCL_START */
400 if (g_msg_handle == NULL)
403 msg = msg_create_struct(MSG_STRUCT_MESSAGE_INFO);
407 send_opt = msg_create_struct(MSG_STRUCT_SENDOPT);
408 if (send_opt == NULL)
411 err = msg_get_message(g_msg_handle,
412 (msg_message_id_t)msg_id,
414 if (err != MSG_SUCCESS)
417 err = msg_get_int_value(msg, MSG_MESSAGE_FOLDER_ID_INT,
419 if (err != MSG_SUCCESS)
422 folder_name = __bt_get_sms_folder_name(folder_id);
423 del_folder_id = __bt_get_sms_folder_id(BT_MAP_DELETED_FOLDER_NAME);
424 map_id = _bt_validate_uid(msg_id, BT_MAP_ID_SMS);
426 DBG("msg_id = %d, delete_status = %d\n", msg_id, delete_status);
428 if (del_folder_id == -1) {
429 ERR("Delete folder not present");
430 if (delete_status == TRUE) {
431 err = msg_delete_message(g_msg_handle, msg_id);
432 if (err != MSG_SUCCESS)
436 if (delete_status == TRUE) {
437 err = msg_move_msg_to_folder(g_msg_handle, msg_id, del_folder_id);
438 if (err == MSG_SUCCESS) {
439 _bt_mns_client_event_notify("MessageShift",
441 "TELECOM/MSG/DELETED",
446 if (folder_id != del_folder_id) {
447 DBG("Message not in delete folder");
451 err = msg_move_msg_to_folder(g_msg_handle, msg_id, MSG_INBOX_ID);
452 if (err == MSG_SUCCESS) {
453 _bt_mns_client_event_notify("MessageShift",
456 "TELECOM/MSG/DELETED",
463 msg_release_struct(&msg);
464 msg_release_struct(&send_opt);
473 msg_release_struct(&msg);
474 msg_release_struct(&send_opt);
476 ERR("Failed to Delete SMS");
480 /* LCOV_EXCL_START */
481 static msg_error_t __bt_send_sms(int msg_id, msg_struct_t p_msg, msg_struct_t p_send_opt)
487 p_req = msg_create_struct(MSG_STRUCT_REQUEST_INFO);
489 msg_set_int_value(p_msg, MSG_MESSAGE_ID_INT, msg_id);
490 msg_set_struct_handle(p_req, MSG_REQUEST_MESSAGE_HND, p_msg);
491 msg_set_struct_handle(p_req, MSG_REQUEST_SENDOPT_HND, p_send_opt);
493 err = msg_sms_send_message(g_msg_handle, p_req);
494 if (err != MSG_SUCCESS)
495 ERR("Failed msg_sms_send_message %d", err);
497 msg_release_struct(&p_req);
502 static int __bt_push_sms(gboolean send, int folder_id, char *body,
503 GSList *recepients, msg_send_option_t *option)
506 msg_struct_t msg_info = NULL;
507 msg_struct_t send_opt = NULL;
512 msg_info = msg_create_struct(MSG_STRUCT_MESSAGE_INFO);
513 if (msg_info == NULL)
516 err = msg_set_int_value(msg_info, MSG_MESSAGE_TYPE_INT, MSG_TYPE_SMS);
517 if (err != MSG_SUCCESS)
521 err = msg_set_str_value(msg_info,
522 MSG_MESSAGE_SMS_DATA_STR,
524 if (err != MSG_SUCCESS)
527 err = msg_set_str_value(msg_info, MSG_MESSAGE_SMS_DATA_STR,
529 if (err != MSG_SUCCESS)
533 DBG("folder_id %d\n", folder_id);
534 err = msg_set_int_value(msg_info, MSG_MESSAGE_FOLDER_ID_INT,
536 if (err != MSG_SUCCESS)
540 msg_struct_t tmp_addr;
541 char *address = recepients->data;
542 if (address == NULL) {
543 ERR("[ERROR] address is value NULL, skip");
544 recepients = g_slist_next(recepients);
548 msg_list_add_item(msg_info,
549 MSG_MESSAGE_ADDR_LIST_HND, &tmp_addr);
551 msg_set_int_value(tmp_addr,
552 MSG_ADDRESS_INFO_RECIPIENT_TYPE_INT,
553 MSG_RECIPIENTS_TYPE_TO);
555 msg_set_str_value(tmp_addr,
556 MSG_ADDRESS_INFO_ADDRESS_VALUE_STR,
557 address, strlen(address));
559 recepients = g_slist_next(recepients);
562 send_opt = msg_create_struct(MSG_STRUCT_SENDOPT);
564 err = msg_set_bool_value(send_opt, MSG_SEND_OPT_SETTING_BOOL, true);
565 if (err != MSG_SUCCESS)
568 /* Do not keep a copy
569 err = msg_set_bool_value(send_opt, MSG_SEND_OPT_KEEPCOPY_BOOL,
572 err = msg_set_bool_value(send_opt, MSG_SEND_OPT_KEEPCOPY_BOOL,
574 if (err != MSG_SUCCESS)
577 msg_id = msg_add_message(g_msg_handle, msg_info, send_opt);
578 DBG("msg_id = %d\n", msg_id);
581 __bt_send_sms(msg_id, msg_info, send_opt);
585 msg_release_struct(&msg_info);
586 msg_release_struct(&send_opt);
591 gboolean _bt_map_push_sms_data(struct bmsg_data *bmsg_info,
592 msg_send_option_t *option, char *folder)
598 GSList *recepients = NULL;
599 gboolean send = FALSE;
601 DBG("Length of Folder String: %d", strlen(bmsg_info->folder));
602 if (strlen(bmsg_info->folder) == 0) {
603 DBG("No Folder Info. Default to OUTBOX");
604 bmsg_info->folder = g_strdup(folder);
607 folder_id = __bt_get_sms_folder_id(bmsg_info->folder);
611 if (folder_id == MSG_OUTBOX_ID)
614 body = bmsg_get_msg_body(bmsg_info, option->native);
618 recepients = bmsg_get_msg_recepients(bmsg_info, BT_MAP_ID_SMS);
620 id = __bt_push_sms(send, folder_id, body, recepients, option);
624 _bt_update_id(current_push_map_id, id, BT_MAP_ID_SMS);
628 g_slist_free(recepients);
640 static char *__bt_prepare_msg_bmseg(msg_struct_t msg_info, gboolean attach,
645 int m_type = MSG_TYPE_SMS;
650 bool read_status = false;
651 char msg_body[BT_MAP_MSG_BODY_MAX] = {0,};
652 char addr_value[MAX_ADDRESS_VAL_LEN] = {0,};
653 char name_value[MAX_DISPLAY_NAME_LEN] = {0,};
655 msg_list_handle_t addr_list = NULL;
656 msg_struct_t addr_info = NULL;
659 gchar *folder_path = NULL;
662 msg = g_string_new(BEGIN_BMSEG);
663 g_string_append(msg, BMSEG_VERSION);
665 ret = msg_get_bool_value(msg_info, MSG_MESSAGE_READ_BOOL, &read_status);
666 if (ret == MSG_SUCCESS)
667 INFO("read_status %d\n", read_status);
670 g_string_append_printf(msg, MSEG_STATUS, "READ");
672 g_string_append_printf(msg, MSEG_STATUS, "UNREAD");
674 ret = msg_get_int_value(msg_info, MSG_MESSAGE_TYPE_INT, &m_type);
675 if (ret == MSG_SUCCESS) {
676 INFO("m_type %d\n", m_type);
677 g_string_append_printf(msg, MSEG_TYPE, "SMS_GSM");
680 ret = msg_get_int_value(msg_info, MSG_MESSAGE_FOLDER_ID_INT,
682 if (ret == MSG_SUCCESS) {
683 DBG("folder_id %d\n", folder_id);
685 folder_path = __bt_get_sms_folder_name(folder_id);
686 g_string_append_printf(msg, FOLDER_PATH, folder_path);
689 ret = msg_get_list_handle(msg_info, MSG_MESSAGE_ADDR_LIST_HND,
690 (void **)&addr_list);
691 if (ret == MSG_SUCCESS) {
692 count = msg_list_length(addr_list);
693 DBG("count %d \n", count);
696 addr_info = (msg_struct_t)msg_list_nth_data(addr_list,
699 msg_get_str_value(addr_info,
700 MSG_ADDRESS_INFO_ADDRESS_VALUE_STR,
701 addr_value, MAX_ADDRESS_VAL_LEN);
702 DBG_SECURE("addr_value %s\n", addr_value);
703 msg_get_str_value(addr_info,
704 MSG_ADDRESS_INFO_DISPLAYNAME_STR,
705 name_value, MAX_DISPLAY_NAME_LEN);
706 if (!strlen(name_value))
707 g_stpcpy(name_value, addr_value);
709 DBG_SECURE("name_value %s\n", name_value);
711 g_string_append_printf(msg, VCARD, name_value,
716 g_string_append(msg, BEGIN_BENV);
717 g_string_append(msg, BEGIN_BBODY);
720 g_string_append_printf(msg, CHARSET, "UTF-8");
723 ret = msg_get_str_value(msg_info,
724 MSG_MESSAGE_SMS_DATA_STR,
725 msg_body, BT_MAP_MSG_BODY_MAX);
726 if (ret == MSG_SUCCESS) {
728 g_string_append_printf(msg, LENGTH, (int)(unsigned int)strlen(msg_body));
730 g_string_append_printf(msg, LENGTH, strlen(msg_body));
732 g_string_append_printf(msg, MSG_BODY, msg_body);
735 g_string_append_printf(msg, ENCODING, "G-7BIT");
736 g_string_append_printf(msg, CHARSET, "native");
738 msg_get_int_value(msg_info,
739 MSG_MESSAGE_DISPLAY_TIME_INT, &dptime);
741 ret = msg_get_str_value(msg_info, MSG_MESSAGE_SMS_DATA_STR,
742 msg_body, BT_MAP_MSG_BODY_MAX);
743 if (ret == MSG_SUCCESS) {
745 msg_pdu = _bt_get_sms_pdu_from_msg_data(addr_value,
749 DBG("msg_pdu_len = %d", msg_pdu_len);
751 g_string_append_printf(msg, LENGTH, msg_pdu_len);
752 g_string_append(msg, MSG_BODY_BEGIN);
753 for (j = 0; j < msg_pdu_len; j++)
754 g_string_append_printf(msg, "%02x",
757 g_string_append(msg, MSG_BODY_END);
763 g_string_append(msg, END_BBODY);
764 g_string_append(msg, END_BENV);
765 g_string_append(msg, END_BMSEG);
769 return g_string_free(msg, FALSE);
773 gboolean _bt_map_get_sms_message(int message_id, gboolean attach,
774 gboolean transcode, gboolean first_request, gchar **bmseg)
778 msg_struct_t msg = NULL;
779 msg_struct_t send_opt = NULL;
781 DBG("message_id %d \n", message_id);
782 DBG("attach %d \n", attach);
783 DBG("transcode %d \n", transcode);
784 DBG("first_request %d \n", first_request);
786 if (g_msg_handle == NULL)
789 msg = msg_create_struct(MSG_STRUCT_MESSAGE_INFO);
793 /* LCOV_EXCL_START */
794 send_opt = msg_create_struct(MSG_STRUCT_SENDOPT);
798 msg_err = msg_get_message(g_msg_handle,
799 (msg_message_id_t)message_id,
801 if (msg_err != MSG_SUCCESS)
804 *bmseg = __bt_prepare_msg_bmseg(msg, attach, transcode);
805 msg_release_struct(&msg);
806 msg_release_struct(&send_opt);
815 msg_release_struct(&msg); /* LCOV_EXCL_LINE */
818 msg_release_struct(&send_opt); /* LCOV_EXCL_LINE */
820 ERR("Unable to Get SMS Message");
824 /* LCOV_EXCL_START */
825 static char *__bt_get_truncated_utf8_string(char *src)
830 char dest[BT_MAP_SUBJECT_MAX_LEN] = {0,};
837 while (*p != '\0' && i < sizeof(dest)) {
838 next = g_utf8_next_char(p);
841 while (count > 0 && ((i + count) < sizeof(dest))) {
850 return g_strdup(dest);
854 static message_info_t *__bt_message_info_get(msg_struct_t msg_struct_handle,
858 message_info_t *msg_info = NULL;
868 bool protect_status = 0;
869 bool read_status = 0;
871 char msg_handle[BT_MAP_MSG_HANDLE_MAX] = {0,};
872 char msg_datetime[BT_MAP_TIMESTAMP_MAX_LEN] = {0,};
873 char msg_size[5] = {0,};
874 char msg_body[BT_MAP_MSG_BODY_MAX] = {0,};
875 char addr_value[MAX_ADDRESS_VAL_LEN] = {0,};
876 char name_value[MAX_DISPLAY_NAME_LEN] = {0,};
878 msg_info = g_new0(message_info_t, 1);
879 msg_info->text = FALSE;
880 msg_info->protect = FALSE;
881 msg_info->read = FALSE;
882 msg_info->priority = FALSE;
884 msg_struct_t msg = NULL;
885 msg_struct_t send_opt = NULL;
886 msg_list_handle_t addr_list = NULL;
887 msg_struct_t addr_info = NULL;
889 ret = msg_get_int_value(msg_struct_handle, MSG_MESSAGE_ID_INT, &msg_id);
890 if (ret != MSG_SUCCESS)
891 ERR("Could not get Message ID");
893 uid = _bt_add_id(msg_id, BT_MAP_ID_SMS);
895 snprintf(msg_handle, sizeof(msg_handle), "%lx", uid);
897 snprintf(msg_handle, sizeof(msg_handle), "%llx", uid);
899 DBG("HANDLE: %s, MAP Id: %d, MSG ID:%d", msg_handle, uid, msg_id);
900 msg_info->handle = g_strdup(msg_handle);
902 msg = msg_create_struct(MSG_STRUCT_MESSAGE_INFO);
906 send_opt = msg_create_struct(MSG_STRUCT_SENDOPT);
907 if (send_opt == NULL)
910 ret = msg_get_message(g_msg_handle,
911 (msg_message_id_t)msg_id,
913 if (ret != MSG_SUCCESS) {
914 DBG("ret = %d\n", ret);
918 ret = msg_get_list_handle(msg, MSG_MESSAGE_ADDR_LIST_HND,
919 (void **)&addr_list);
920 if (ret != MSG_SUCCESS) {
921 DBG("ret = %d\n", ret);
925 count = msg_list_length(addr_list);
928 addr_info = (msg_struct_t)msg_list_nth_data(addr_list, 0);
930 ret = msg_get_str_value(addr_info,
931 MSG_ADDRESS_INFO_ADDRESS_VALUE_STR,
932 addr_value, MAX_ADDRESS_VAL_LEN);
933 if (ret == MSG_SUCCESS)
934 DBG_SECURE("addr_value %s\n", addr_value);
936 ret = msg_get_str_value(addr_info,
937 MSG_ADDRESS_INFO_DISPLAYNAME_STR,
938 name_value, MAX_DISPLAY_NAME_LEN);
940 if (ret == MSG_SUCCESS)
941 DBG_SECURE("name_value %s\n", name_value);
943 if (!strlen(name_value))
944 g_stpcpy(name_value, addr_value);
946 DBG_SECURE("name_value %s\n", name_value);
949 ret = msg_get_int_value(msg, MSG_MESSAGE_DIRECTION_INT,
951 if (ret != MSG_SUCCESS)
954 if (direction_type == MSG_DIRECTION_TYPE_MT) {
955 msg_info->sender_name = g_strdup(name_value);
956 msg_info->sender_addressing = g_strdup(addr_value);
957 msg_info->recipient_name = g_strdup("Unknown");
958 msg_info->recipient_addressing = g_strdup("0000");
960 msg_info->sender_name = g_strdup("Unknown");
961 msg_info->sender_addressing = g_strdup("0000");
962 msg_info->recipient_name = g_strdup(name_value);
963 msg_info->recipient_addressing = g_strdup(addr_value);
967 msg_release_struct(&msg);
968 msg_release_struct(&send_opt);
970 ret = msg_get_int_value(msg_struct_handle,
971 MSG_MESSAGE_DISPLAY_TIME_INT, (int *)&dptime);
972 if (ret == MSG_SUCCESS)
973 _get_msg_timestamp(&dptime, msg_datetime);
975 DBG("Got date time: %s", msg_datetime);
977 msg_info->datetime = g_strdup(msg_datetime);
978 msg_info->time = dptime; // for sorting
980 ret = msg_get_int_value(msg_struct_handle, MSG_MESSAGE_TYPE_INT,
982 if (ret == MSG_SUCCESS)
983 DBG("m_type %d\n", m_type);
985 msg_info->type = g_strdup("SMS_GSM");
987 ret = msg_get_str_value(msg_struct_handle,
988 MSG_MESSAGE_SMS_DATA_STR, msg_body,
989 BT_MAP_MSG_BODY_MAX);
990 if (ret == MSG_SUCCESS) {
991 DBG_SECURE("SMS subject %s", msg_body);
992 if (strlen(msg_body)) {
994 msg_info->text = TRUE;
995 subject = __bt_get_truncated_utf8_string(msg_body);
996 msg_info->subject = g_strndup(subject, subject_len);
1001 ret = msg_get_int_value(msg_struct_handle, MSG_MESSAGE_DATA_SIZE_INT,
1003 if (ret == MSG_SUCCESS)
1004 snprintf(msg_size, sizeof(msg_size), "%d", data_size);
1006 msg_info->size = g_strdup(msg_size);
1008 msg_info->reception_status = g_strdup("complete");
1009 msg_info->attachment_size = g_strdup("0");
1011 ret = msg_get_bool_value(msg_struct_handle, MSG_MESSAGE_PROTECTED_BOOL,
1013 if (ret == MSG_SUCCESS) {
1015 msg_info->protect = TRUE;
1018 ret = msg_get_bool_value(msg_struct_handle, MSG_MESSAGE_READ_BOOL,
1020 if (ret == MSG_SUCCESS) {
1022 msg_info->read = TRUE;
1025 ret = msg_get_int_value(msg_struct_handle, MSG_MESSAGE_PRIORITY_INT,
1027 if (ret == MSG_SUCCESS) {
1028 if (priority == MSG_MESSAGE_PRIORITY_HIGH)
1029 msg_info->priority = TRUE;
1036 gboolean _bt_map_get_sms_message_list(gchar *folder, guint16 max,
1037 guint8 subject_len, map_msg_filter_t *filter,
1038 GSList **sms_list, guint64 *count, gboolean *newmsg)
1044 guint64 local_count;
1047 msg_struct_list_s folder_list = {0,};
1048 msg_struct_list_s msg_list = {0,};
1049 msg_struct_t list_cond;
1050 GSList *list = NULL;
1053 DBG("Folder:%s Max:%d", folder, max);
1057 ret = msg_get_folder_list(g_msg_handle, &folder_list);
1058 if (ret != MSG_SUCCESS)
1061 for (i = 0; i < folder_list.nCount; i++) {
1062 char f_name[BT_MAP_MSG_INFO_MAX] = {0, };
1063 msg_struct_t p_folder = folder_list.msg_struct_info[i];
1065 ret = msg_get_str_value(p_folder, MSG_FOLDER_INFO_NAME_STR,
1066 f_name, BT_MAP_MSG_INFO_MAX);
1067 if (ret != MSG_SUCCESS)
1070 if (!g_ascii_strncasecmp(f_name, folder, strlen(folder))) {
1071 ret = msg_get_int_value(p_folder, MSG_FOLDER_INFO_ID_INT,
1073 if (ret != MSG_SUCCESS)
1076 DBG("folder_id %d \n", folder_id);
1082 if (folder_id == -1)
1085 list_cond = msg_create_struct(MSG_STRUCT_MSG_LIST_CONDITION);
1086 ret = msg_set_int_value(list_cond,
1087 MSG_LIST_CONDITION_FOLDER_ID_INT,
1089 if (ret != MSG_SUCCESS)
1092 ret = msg_set_int_value(list_cond,
1093 MSG_LIST_CONDITION_MSGTYPE_INT, MSG_TYPE_SMS);
1094 if (ret != MSG_SUCCESS)
1097 ret = msg_get_message_list2(g_msg_handle, list_cond, &msg_list);
1099 msg_release_struct(&list_cond);
1101 if (ret != MSG_SUCCESS)
1104 local_count = (guint64)msg_list.nCount;
1105 DBG("msg_list.nCount: %d, count:%d", msg_list.nCount, local_count);
1106 for (i = 0; i < local_count; i++) {
1107 msg_get_bool_value(msg_list.msg_struct_info[i],
1108 MSG_MESSAGE_READ_BOOL, &read);
1109 if (read == false) {
1115 DBG("count = %llx, newmsg = %d, max = %d", local_count, *newmsg, max);
1117 for (i = 0, msg_count = 0; i < local_count && msg_count < max; i++) {
1118 message_info_t *msg_info;
1120 msg_info = __bt_message_info_get(msg_list.msg_struct_info[i],
1123 if (!_bt_verify_read_status(msg_info, filter->read_status) ||
1124 !_bt_verify_receiver(msg_info, filter->recipient) ||
1125 !_bt_verify_sender(msg_info, filter->originator) ||
1126 !_bt_verify_time(msg_info, filter) ||
1127 !_bt_filter_priority(msg_info, filter->priority) ||
1128 !_bt_validate_msg_data(msg_info)) {
1129 _bt_message_info_free((gpointer)msg_info);
1133 list = g_slist_append(list, msg_info);
1137 if (folder_list.msg_struct_info)
1138 ret = msg_release_list_struct(&folder_list);
1140 if (msg_list.msg_struct_info)
1141 ret = msg_release_list_struct(&msg_list);
1143 *count = local_count;
1149 if (folder_list.msg_struct_info)
1150 ret = msg_release_list_struct(&folder_list);
1152 if (msg_list.msg_struct_info)
1153 ret = msg_release_list_struct(&msg_list);
1155 ERR("Getting SMS List Failed");
1158 /* LCOV_EXCL_STOP */
1160 void _bt_map_stop_sms_service(void)
1163 msg_error_t err = MSG_SUCCESS;
1166 folder_id = __bt_get_sms_folder_id(BT_MAP_DELETED_FOLDER_NAME);
1167 if (folder_id != -1) {
1168 err = msg_delete_folder(g_msg_handle, folder_id);
1169 if (err != MSG_SUCCESS)
1170 ERR("Delete folder failed"); /* LCOV_EXCL_LINE */
1174 msg_close_msg_handle(&g_msg_handle);
1175 g_msg_handle = NULL;
1181 gboolean _bt_map_start_sms_service(void)
1186 err = msg_open_msg_handle(&g_msg_handle);
1187 if (err != MSG_SUCCESS) {
1188 /* LCOV_EXCL_START */
1189 ERR("msg_open_msg_handle error = %d\n", err);
1191 /* LCOV_EXCL_STOP */
1194 if (__bt_get_sms_folder_id(BT_MAP_DELETED_FOLDER_NAME) == -1)
1195 __bt_add_deleted_folder();
1197 err = msg_reg_sms_message_callback(g_msg_handle,
1198 __bluetooth_map_msg_incoming_status_cb,
1199 0, (void *)BT_MAP_MSG_CB);
1200 if (err != MSG_SUCCESS) {
1201 /* LCOV_EXCL_START */
1202 ERR("msg_reg_sms_message_callback error = %d\n", err);
1204 /* LCOV_EXCL_STOP */
1207 err = msg_reg_sent_status_callback(g_msg_handle,
1208 __bluetooth_map_msg_sent_status_cb,
1210 if (err != MSG_SUCCESS) {
1211 /* LCOV_EXCL_START */
1212 ERR("msg_reg_sent_status_callback error = %d\n", err);
1214 /* LCOV_EXCL_STOP */