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 ERR("Failed adding type %d", err);
134 msg_release_struct(&folder_info);
138 err = msg_set_str_value(folder_info, MSG_FOLDER_INFO_NAME_STR,
139 "DELETED", MAX_FOLDER_NAME_SIZE);
140 if (err != MSG_SUCCESS) {
141 ERR("Failed adding str %d", err);
142 msg_release_struct(&folder_info);
146 err = msg_add_folder(g_msg_handle, folder_info);
147 if (err != MSG_SUCCESS) {
148 ERR("Failed adding folder %d", err);
149 msg_release_struct(&folder_info);
153 msg_release_struct(&folder_info);
157 static void __bluetooth_map_msg_incoming_status_cb(msg_handle_t handle,
168 if (is_mns_connected() == FALSE) {
169 INFO("MNS Client not connected");
173 ret = msg_get_int_value(msg, MSG_MESSAGE_TYPE_INT, &msg_type);
174 if (ret != MSG_SUCCESS)
177 if (msg_type != MSG_TYPE_SMS) {
182 ret = msg_get_int_value(msg, MSG_MESSAGE_ID_INT, &msg_id);
183 if (ret != MSG_SUCCESS)
186 uid = _bt_add_id(msg_id, BT_MAP_ID_SMS);
188 _bt_mns_client_event_notify("NewMessage", uid,
189 "TELECOM/MSG/INBOX", "",
195 static void __bluetooth_map_msg_sent_status_cb(msg_handle_t handle,
203 if (is_mns_connected() == FALSE) {
204 INFO("MNS Client not connected");
208 ret = msg_get_int_value(msg, MSG_SENT_STATUS_NETWORK_STATUS_INT,
210 if (ret != MSG_SUCCESS)
213 if (status == MSG_NETWORK_SEND_SUCCESS) {
214 INFO("MSG SENT SUCCESS !!! ");
215 _bt_mns_client_event_notify("MessageShift",
218 "TELECOM/MSG/OUTBOX",
221 _bt_mns_client_event_notify("SendingSuccess",
223 "TELECOM/MSG/SENT", "",
226 ERR("MSG SENT FAIL !!! [%d]", status);
227 _bt_mns_client_event_notify("SendingFailure",
229 "TELECOM/MSG/OUTBOX", "",
236 gboolean _bt_map_sms_get_supported_folders(gboolean folders[FOLDER_COUNT][MSG_TYPES])
239 char folder_name[BT_MAP_MSG_INFO_MAX] = {0,};
242 gboolean msg_ret = TRUE;
244 msg_struct_list_s folder_list = {0,};
245 msg_struct_t p_folder;
247 if (g_msg_handle == NULL) {
252 if (msg_get_folder_list(g_msg_handle, &folder_list) != MSG_SUCCESS) {
257 for (i = 0; i < folder_list.nCount; i++) {
258 p_folder = folder_list.msg_struct_info[i];
259 memset(folder_name, 0x00, BT_MAP_MSG_INFO_MAX);
261 ret = msg_get_str_value(p_folder, MSG_FOLDER_INFO_NAME_STR,
262 folder_name, BT_MAP_MSG_INFO_MAX);
263 if (ret != MSG_SUCCESS)
266 DBG("%d. %s", i, folder_name);
267 if (g_strstr_len(folder_name, -1, BT_MAP_MSG_TEMPLATE) ||
268 g_strstr_len(folder_name, -1, "CBMSGBOX") ||
269 g_strstr_len(folder_name, -1, "SPAMBOX"))
272 if (!g_ascii_strncasecmp(folder_name, BT_MAP_SENT_FOLDER_NAME,
273 strlen(BT_MAP_SENT_FOLDER_NAME))) {
274 memset(folder_name, 0, sizeof(folder_name));
275 g_strlcpy(folder_name, BT_MAP_SENT_FOLDER_NAME,
276 sizeof(folder_name));
277 folders[BT_MSG_SENT][BT_MSG_SOURCE_SMS] = TRUE;
279 } else if (!g_ascii_strcasecmp(folder_name, "INBOX")) {
280 folders[BT_MSG_INBOX][BT_MSG_SOURCE_SMS] = TRUE;
282 } else if (!g_ascii_strcasecmp(folder_name, "OUTBOX")) {
283 folders[BT_MSG_OUTBOX][BT_MSG_SOURCE_SMS] = TRUE;
285 } else if (!g_ascii_strcasecmp(folder_name, "DRAFT")) {
286 folders[BT_MSG_DRAFT][BT_MSG_SOURCE_SMS] = TRUE;
288 } else if (!g_ascii_strcasecmp(folder_name, "DELETED")) {
289 folders[BT_MSG_DELETED][BT_MSG_SOURCE_SMS] = TRUE;
296 if (folder_list.msg_struct_info)
297 msg_release_list_struct(&folder_list);
303 gboolean _bt_map_sms_set_read_status(int msg_id, gboolean read_status)
308 msg_err = msg_update_read_status(g_msg_handle, msg_id,
310 if (msg_err != MSG_SUCCESS) {
311 ERR("Failed to Set Read Status");
320 static gchar *__bt_get_sms_folder_name(int id)
326 gboolean path_found = FALSE;
327 char folder_name[BT_MAP_MSG_INFO_MAX] = {0,};
329 msg_struct_list_s folder_list = {0,};
330 msg_struct_t p_folder;
332 ret = msg_get_folder_list(g_msg_handle, &folder_list);
333 if (ret != MSG_SUCCESS)
334 return g_strdup("TELECOM/MSG");
336 if (folder_list.msg_struct_info == NULL)
337 return g_strdup("TELECOM/MSG");
339 for (i = 0; i < folder_list.nCount; i++) {
340 p_folder = folder_list.msg_struct_info[i];
342 ret = msg_get_int_value(p_folder,
343 MSG_FOLDER_INFO_ID_INT,
345 if (ret != MSG_SUCCESS)
347 DBG("folder_id %d, id = %d", folder_id, id);
348 if (folder_id == id) {
349 ret = msg_get_str_value(p_folder,
350 MSG_FOLDER_INFO_NAME_STR,
351 folder_name, BT_MAP_MSG_INFO_MAX);
352 if (ret != MSG_SUCCESS)
356 DBG_SECURE("folder_name %s", folder_name);
361 if (folder_list.msg_struct_info) {
362 ret = msg_release_list_struct(&folder_list);
367 if (path_found != TRUE)
368 return g_strdup("TELECOM/MSG");
370 return g_strdup_printf("TELECOM/MSG/%s", folder_name);
373 gboolean _bt_map_set_sms_delete_status(int msg_id, gboolean delete_status)
379 gchar *folder_name = NULL;
381 msg_struct_t msg = NULL;
382 msg_struct_t send_opt = NULL;
388 if (g_msg_handle == NULL)
391 msg = msg_create_struct(MSG_STRUCT_MESSAGE_INFO);
395 send_opt = msg_create_struct(MSG_STRUCT_SENDOPT);
396 if (send_opt == NULL)
399 err = msg_get_message(g_msg_handle,
400 (msg_message_id_t)msg_id,
402 if (err != MSG_SUCCESS)
405 err = msg_get_int_value(msg, MSG_MESSAGE_FOLDER_ID_INT,
407 if (err != MSG_SUCCESS)
410 folder_name = __bt_get_sms_folder_name(folder_id);
411 del_folder_id = __bt_get_sms_folder_id(BT_MAP_DELETED_FOLDER_NAME);
412 map_id = _bt_validate_uid(msg_id, BT_MAP_ID_SMS);
414 DBG("msg_id = %d, delete_status = %d\n", msg_id, delete_status);
416 if (del_folder_id == -1) {
417 ERR("Delete folder not present");
418 if (delete_status == TRUE) {
419 err = msg_delete_message(g_msg_handle, msg_id);
420 if (err != MSG_SUCCESS)
424 if (delete_status == TRUE) {
425 err = msg_move_msg_to_folder(g_msg_handle, msg_id, del_folder_id);
426 if (err == MSG_SUCCESS) {
427 _bt_mns_client_event_notify("MessageShift",
429 "TELECOM/MSG/DELETED",
434 if (folder_id != del_folder_id) {
435 DBG("Message not in delete folder");
439 err = msg_move_msg_to_folder(g_msg_handle, msg_id, MSG_INBOX_ID);
440 if (err == MSG_SUCCESS) {
441 _bt_mns_client_event_notify("MessageShift",
444 "TELECOM/MSG/DELETED",
451 msg_release_struct(&msg);
452 msg_release_struct(&send_opt);
460 msg_release_struct(&msg);
461 msg_release_struct(&send_opt);
463 ERR("Failed to Delete SMS");
467 static msg_error_t __bt_send_sms(int msg_id, msg_struct_t p_msg, msg_struct_t p_send_opt)
473 p_req = msg_create_struct(MSG_STRUCT_REQUEST_INFO);
475 msg_set_int_value(p_msg, MSG_MESSAGE_ID_INT, msg_id);
476 msg_set_struct_handle(p_req, MSG_REQUEST_MESSAGE_HND, p_msg);
477 msg_set_struct_handle(p_req, MSG_REQUEST_SENDOPT_HND, p_send_opt);
479 err = msg_sms_send_message(g_msg_handle, p_req);
480 if (err != MSG_SUCCESS)
481 ERR("Failed msg_sms_send_message %d", err);
483 msg_release_struct(&p_req);
488 static int __bt_push_sms(gboolean send, int folder_id, char *body,
489 GSList *recepients, msg_send_option_t *option)
492 msg_struct_t msg_info = NULL;
493 msg_struct_t send_opt = NULL;
498 msg_info = msg_create_struct(MSG_STRUCT_MESSAGE_INFO);
499 if (msg_info == NULL)
502 err = msg_set_int_value(msg_info, MSG_MESSAGE_TYPE_INT, MSG_TYPE_SMS);
503 if (err != MSG_SUCCESS)
507 err = msg_set_str_value(msg_info,
508 MSG_MESSAGE_SMS_DATA_STR,
510 if (err != MSG_SUCCESS)
513 err = msg_set_str_value(msg_info, MSG_MESSAGE_SMS_DATA_STR,
515 if (err != MSG_SUCCESS)
519 DBG("folder_id %d\n", folder_id);
520 err = msg_set_int_value(msg_info, MSG_MESSAGE_FOLDER_ID_INT,
522 if (err != MSG_SUCCESS)
526 msg_struct_t tmp_addr;
527 char *address = recepients->data;
528 if (address == NULL) {
529 ERR("[ERROR] address is value NULL, skip");
530 recepients = g_slist_next(recepients);
534 msg_list_add_item(msg_info,
535 MSG_MESSAGE_ADDR_LIST_HND, &tmp_addr);
537 msg_set_int_value(tmp_addr,
538 MSG_ADDRESS_INFO_RECIPIENT_TYPE_INT,
539 MSG_RECIPIENTS_TYPE_TO);
541 msg_set_str_value(tmp_addr,
542 MSG_ADDRESS_INFO_ADDRESS_VALUE_STR,
543 address, strlen(address));
545 recepients = g_slist_next(recepients);
548 send_opt = msg_create_struct(MSG_STRUCT_SENDOPT);
550 err = msg_set_bool_value(send_opt, MSG_SEND_OPT_SETTING_BOOL, true);
551 if (err != MSG_SUCCESS)
554 /* Do not keep a copy
555 err = msg_set_bool_value(send_opt, MSG_SEND_OPT_KEEPCOPY_BOOL,
558 err = msg_set_bool_value(send_opt, MSG_SEND_OPT_KEEPCOPY_BOOL,
560 if (err != MSG_SUCCESS)
563 msg_id = msg_add_message(g_msg_handle, msg_info, send_opt);
564 DBG("msg_id = %d\n", msg_id);
567 __bt_send_sms(msg_id, msg_info, send_opt);
571 msg_release_struct(&msg_info);
572 msg_release_struct(&send_opt);
577 gboolean _bt_map_push_sms_data(struct bmsg_data *bmsg_info,
578 msg_send_option_t *option, char *folder)
584 GSList *recepients = NULL;
585 gboolean send = FALSE;
587 DBG("Length of Folder String: %d", strlen(bmsg_info->folder));
588 if (strlen(bmsg_info->folder) == 0) {
589 DBG("No Folder Info. Default to OUTBOX");
590 bmsg_info->folder = g_strdup(folder);
593 folder_id = __bt_get_sms_folder_id(bmsg_info->folder);
597 if (folder_id == MSG_OUTBOX_ID)
600 body = bmsg_get_msg_body(bmsg_info, option->native);
604 recepients = bmsg_get_msg_recepients(bmsg_info, BT_MAP_ID_SMS);
606 id = __bt_push_sms(send, folder_id, body, recepients, option);
610 _bt_update_id(current_push_map_id, id, BT_MAP_ID_SMS);
614 g_slist_free(recepients);
626 static char *__bt_prepare_msg_bmseg(msg_struct_t msg_info, gboolean attach,
631 int m_type = MSG_TYPE_SMS;
636 bool read_status = false;
637 char msg_body[BT_MAP_MSG_BODY_MAX] = {0,};
638 char addr_value[MAX_ADDRESS_VAL_LEN] = {0,};
639 char name_value[MAX_DISPLAY_NAME_LEN] = {0,};
641 msg_list_handle_t addr_list = NULL;
642 msg_struct_t addr_info = NULL;
645 gchar *folder_path = NULL;
648 msg = g_string_new(BEGIN_BMSEG);
649 g_string_append(msg, BMSEG_VERSION);
651 ret = msg_get_bool_value(msg_info, MSG_MESSAGE_READ_BOOL, &read_status);
652 if (ret == MSG_SUCCESS)
653 INFO("read_status %d\n", read_status);
656 g_string_append_printf(msg, MSEG_STATUS, "READ");
658 g_string_append_printf(msg, MSEG_STATUS, "UNREAD");
660 ret = msg_get_int_value(msg_info, MSG_MESSAGE_TYPE_INT, &m_type);
661 if (ret == MSG_SUCCESS) {
662 INFO("m_type %d\n", m_type);
663 g_string_append_printf(msg, MSEG_TYPE, "SMS_GSM");
666 ret = msg_get_int_value(msg_info, MSG_MESSAGE_FOLDER_ID_INT,
668 if (ret == MSG_SUCCESS) {
669 DBG("folder_id %d\n", folder_id);
671 folder_path = __bt_get_sms_folder_name(folder_id);
672 g_string_append_printf(msg, FOLDER_PATH, folder_path);
675 ret = msg_get_list_handle(msg_info, MSG_MESSAGE_ADDR_LIST_HND,
676 (void **)&addr_list);
677 if (ret == MSG_SUCCESS) {
678 count = msg_list_length(addr_list);
679 DBG("count %d \n", count);
682 addr_info = (msg_struct_t)msg_list_nth_data(addr_list,
685 msg_get_str_value(addr_info,
686 MSG_ADDRESS_INFO_ADDRESS_VALUE_STR,
687 addr_value, MAX_ADDRESS_VAL_LEN);
688 DBG_SECURE("addr_value %s\n", addr_value);
689 msg_get_str_value(addr_info,
690 MSG_ADDRESS_INFO_DISPLAYNAME_STR,
691 name_value, MAX_DISPLAY_NAME_LEN);
692 if (!strlen(name_value))
693 g_stpcpy(name_value, addr_value);
695 DBG_SECURE("name_value %s\n", name_value);
697 g_string_append_printf(msg, VCARD, name_value,
702 g_string_append(msg, BEGIN_BENV);
703 g_string_append(msg, BEGIN_BBODY);
706 g_string_append_printf(msg, CHARSET, "UTF-8");
709 ret = msg_get_str_value(msg_info,
710 MSG_MESSAGE_SMS_DATA_STR,
711 msg_body, BT_MAP_MSG_BODY_MAX);
712 if (ret == MSG_SUCCESS) {
714 g_string_append_printf(msg, LENGTH, (int)(unsigned int)strlen(msg_body));
716 g_string_append_printf(msg, LENGTH, strlen(msg_body));
718 g_string_append_printf(msg, MSG_BODY, msg_body);
721 g_string_append_printf(msg, ENCODING, "G-7BIT");
722 g_string_append_printf(msg, CHARSET, "native");
724 msg_get_int_value(msg_info,
725 MSG_MESSAGE_DISPLAY_TIME_INT, &dptime);
727 ret = msg_get_str_value(msg_info, MSG_MESSAGE_SMS_DATA_STR,
728 msg_body, BT_MAP_MSG_BODY_MAX);
729 if (ret == MSG_SUCCESS) {
731 msg_pdu = __bt_get_sms_pdu_from_msg_data(addr_value,
735 DBG("msg_pdu_len = %d", msg_pdu_len);
737 g_string_append_printf(msg, LENGTH, msg_pdu_len);
738 g_string_append(msg, MSG_BODY_BEGIN);
739 for (j = 0; j < msg_pdu_len; j++)
740 g_string_append_printf(msg, "%02x",
743 g_string_append(msg, MSG_BODY_END);
749 g_string_append(msg, END_BBODY);
750 g_string_append(msg, END_BENV);
751 g_string_append(msg, END_BMSEG);
755 return g_string_free(msg, FALSE);
758 gboolean _bt_map_get_sms_message(int message_id, gboolean attach,
759 gboolean transcode, gboolean first_request, gchar **bmseg)
763 msg_struct_t msg = NULL;
764 msg_struct_t send_opt = NULL;
766 DBG("message_id %d \n", message_id);
767 DBG("attach %d \n", attach);
768 DBG("transcode %d \n", transcode);
769 DBG("first_request %d \n", first_request);
771 if (g_msg_handle == NULL)
774 msg = msg_create_struct(MSG_STRUCT_MESSAGE_INFO);
778 send_opt = msg_create_struct(MSG_STRUCT_SENDOPT);
782 msg_err = msg_get_message(g_msg_handle,
783 (msg_message_id_t)message_id,
785 if (msg_err != MSG_SUCCESS)
788 *bmseg = __bt_prepare_msg_bmseg(msg, attach, transcode);
789 msg_release_struct(&msg);
790 msg_release_struct(&send_opt);
798 msg_release_struct(&msg);
801 msg_release_struct(&send_opt);
803 ERR("Unable to Get SMS Message");
807 static char *__bt_get_truncated_utf8_string(char *src)
812 char dest[BT_MAP_SUBJECT_MAX_LEN] = {0,};
819 while (*p != '\0' && i < sizeof(dest)) {
820 next = g_utf8_next_char(p);
823 while (count > 0 && ((i + count) < sizeof(dest))) {
832 return g_strdup(dest);
836 static message_info_t *__bt_message_info_get(msg_struct_t msg_struct_handle,
840 message_info_t *msg_info = NULL;
850 bool protect_status = 0;
851 bool read_status = 0;
853 char msg_handle[BT_MAP_MSG_HANDLE_MAX] = {0,};
854 char msg_datetime[BT_MAP_TIMESTAMP_MAX_LEN] = {0,};
855 char msg_size[5] = {0,};
856 char msg_body[BT_MAP_MSG_BODY_MAX] = {0,};
857 char addr_value[MAX_ADDRESS_VAL_LEN] = {0,};
858 char name_value[MAX_DISPLAY_NAME_LEN] = {0,};
860 msg_info = g_new0(message_info_t, 1);
861 msg_info->text = FALSE;
862 msg_info->protect = FALSE;
863 msg_info->read = FALSE;
864 msg_info->priority = FALSE;
866 msg_struct_t msg = NULL;
867 msg_struct_t send_opt = NULL;
868 msg_list_handle_t addr_list = NULL;
869 msg_struct_t addr_info = NULL;
871 ret = msg_get_int_value(msg_struct_handle, MSG_MESSAGE_ID_INT, &msg_id);
872 if (ret != MSG_SUCCESS)
873 ERR("Could not get Message ID");
875 uid = _bt_add_id(msg_id, BT_MAP_ID_SMS);
877 snprintf(msg_handle, sizeof(msg_handle), "%lx", uid);
879 snprintf(msg_handle, sizeof(msg_handle), "%llx", uid);
881 DBG("HANDLE: %s, MAP Id: %d, MSG ID:%d", msg_handle, uid, msg_id);
882 msg_info->handle = g_strdup(msg_handle);
884 msg = msg_create_struct(MSG_STRUCT_MESSAGE_INFO);
888 send_opt = msg_create_struct(MSG_STRUCT_SENDOPT);
889 if (send_opt == NULL)
892 ret = msg_get_message(g_msg_handle,
893 (msg_message_id_t)msg_id,
895 if (ret != MSG_SUCCESS) {
896 DBG("ret = %d\n", ret);
900 ret = msg_get_list_handle(msg, MSG_MESSAGE_ADDR_LIST_HND,
901 (void **)&addr_list);
902 if (ret != MSG_SUCCESS) {
903 DBG("ret = %d\n", ret);
907 count = msg_list_length(addr_list);
910 addr_info = (msg_struct_t)msg_list_nth_data(addr_list, 0);
912 ret = msg_get_str_value(addr_info,
913 MSG_ADDRESS_INFO_ADDRESS_VALUE_STR,
914 addr_value, MAX_ADDRESS_VAL_LEN);
915 if (ret == MSG_SUCCESS)
916 DBG_SECURE("addr_value %s\n", addr_value);
918 ret = msg_get_str_value(addr_info,
919 MSG_ADDRESS_INFO_DISPLAYNAME_STR,
920 name_value, MAX_DISPLAY_NAME_LEN);
922 if (ret == MSG_SUCCESS)
923 DBG_SECURE("name_value %s\n", name_value);
925 if (!strlen(name_value))
926 g_stpcpy(name_value, addr_value);
928 DBG_SECURE("name_value %s\n", name_value);
931 ret = msg_get_int_value(msg, MSG_MESSAGE_DIRECTION_INT,
933 if (ret != MSG_SUCCESS)
936 if (direction_type == MSG_DIRECTION_TYPE_MT) {
937 msg_info->sender_name = g_strdup(name_value);
938 msg_info->sender_addressing = g_strdup(addr_value);
939 msg_info->recipient_name = g_strdup("Unknown");
940 msg_info->recipient_addressing = g_strdup("0000");
942 msg_info->sender_name = g_strdup("Unknown");
943 msg_info->sender_addressing = g_strdup("0000");
944 msg_info->recipient_name = g_strdup(name_value);
945 msg_info->recipient_addressing = g_strdup(addr_value);
949 msg_release_struct(&msg);
950 msg_release_struct(&send_opt);
952 ret = msg_get_int_value(msg_struct_handle,
953 MSG_MESSAGE_DISPLAY_TIME_INT, (int *)&dptime);
954 if (ret == MSG_SUCCESS)
955 _get_msg_timestamp(&dptime, msg_datetime);
957 DBG("Got date time: %s", msg_datetime);
959 msg_info->datetime = g_strdup(msg_datetime);
960 msg_info->time = dptime; // for sorting
962 ret = msg_get_int_value(msg_struct_handle, MSG_MESSAGE_TYPE_INT,
964 if (ret == MSG_SUCCESS)
965 DBG("m_type %d\n", m_type);
967 msg_info->type = g_strdup("SMS_GSM");
969 ret = msg_get_str_value(msg_struct_handle,
970 MSG_MESSAGE_SMS_DATA_STR, msg_body,
971 BT_MAP_MSG_BODY_MAX);
972 if (ret == MSG_SUCCESS) {
973 DBG_SECURE("SMS subject %s", msg_body);
974 if (strlen(msg_body)) {
976 msg_info->text = TRUE;
977 subject = __bt_get_truncated_utf8_string(msg_body);
978 msg_info->subject = g_strndup(subject, subject_len);
983 ret = msg_get_int_value(msg_struct_handle, MSG_MESSAGE_DATA_SIZE_INT,
985 if (ret == MSG_SUCCESS)
986 snprintf(msg_size, sizeof(msg_size), "%d", data_size);
988 msg_info->size = g_strdup(msg_size);
990 msg_info->reception_status = g_strdup("complete");
991 msg_info->attachment_size = g_strdup("0");
993 ret = msg_get_bool_value(msg_struct_handle, MSG_MESSAGE_PROTECTED_BOOL,
995 if (ret == MSG_SUCCESS) {
997 msg_info->protect = TRUE;
1000 ret = msg_get_bool_value(msg_struct_handle, MSG_MESSAGE_READ_BOOL,
1002 if (ret == MSG_SUCCESS) {
1004 msg_info->read = TRUE;
1007 ret = msg_get_int_value(msg_struct_handle, MSG_MESSAGE_PRIORITY_INT,
1009 if (ret == MSG_SUCCESS) {
1010 if (priority == MSG_MESSAGE_PRIORITY_HIGH)
1011 msg_info->priority = TRUE;
1018 gboolean _bt_map_get_sms_message_list(gchar *folder, guint16 max,
1019 guint8 subject_len, map_msg_filter_t *filter,
1020 GSList **sms_list, guint64 *count, gboolean *newmsg)
1026 guint64 local_count;
1029 msg_struct_list_s folder_list = {0,};
1030 msg_struct_list_s msg_list = {0,};
1031 msg_struct_t list_cond;
1032 GSList *list = NULL;
1035 DBG("Folder:%s Max:%d", folder, max);
1039 ret = msg_get_folder_list(g_msg_handle, &folder_list);
1040 if (ret != MSG_SUCCESS)
1043 for (i = 0; i < folder_list.nCount; i++) {
1044 char f_name[BT_MAP_MSG_INFO_MAX] = {0, };
1045 msg_struct_t p_folder = folder_list.msg_struct_info[i];
1047 ret = msg_get_str_value(p_folder, MSG_FOLDER_INFO_NAME_STR,
1048 f_name, BT_MAP_MSG_INFO_MAX);
1049 if (ret != MSG_SUCCESS)
1052 if (!g_ascii_strncasecmp(f_name, folder, strlen(folder))) {
1053 ret = msg_get_int_value(p_folder, MSG_FOLDER_INFO_ID_INT,
1055 if (ret != MSG_SUCCESS)
1058 DBG("folder_id %d \n", folder_id);
1064 if (folder_id == -1)
1067 list_cond = msg_create_struct(MSG_STRUCT_MSG_LIST_CONDITION);
1068 ret = msg_set_int_value(list_cond,
1069 MSG_LIST_CONDITION_FOLDER_ID_INT,
1071 if (ret != MSG_SUCCESS)
1074 ret = msg_set_int_value(list_cond,
1075 MSG_LIST_CONDITION_MSGTYPE_INT, MSG_TYPE_SMS);
1076 if (ret != MSG_SUCCESS)
1079 ret = msg_get_message_list2(g_msg_handle, list_cond, &msg_list);
1081 msg_release_struct(&list_cond);
1083 if (ret != MSG_SUCCESS)
1086 local_count = (guint64)msg_list.nCount;
1087 DBG("msg_list.nCount: %d, count:%d", msg_list.nCount, local_count);
1088 for (i = 0; i < local_count; i++) {
1089 msg_get_bool_value(msg_list.msg_struct_info[i],
1090 MSG_MESSAGE_READ_BOOL, &read);
1091 if (read == false) {
1097 DBG("count = %llx, newmsg = %d, max = %d", local_count, *newmsg, max);
1099 for (i = 0, msg_count = 0; i < local_count && msg_count < max; i++) {
1100 message_info_t *msg_info;
1102 msg_info = __bt_message_info_get(msg_list.msg_struct_info[i],
1105 if (!_bt_verify_read_status(msg_info, filter->read_status) ||
1106 !_bt_verify_receiver(msg_info, filter->recipient) ||
1107 !_bt_verify_sender(msg_info, filter->originator) ||
1108 !_bt_verify_time(msg_info, filter) ||
1109 !_bt_filter_priority(msg_info, filter->priority) ||
1110 !_bt_validate_msg_data(msg_info)) {
1111 _bt_message_info_free((gpointer)msg_info);
1115 list = g_slist_append(list, msg_info);
1119 if (folder_list.msg_struct_info)
1120 ret = msg_release_list_struct(&folder_list);
1122 if (msg_list.msg_struct_info)
1123 ret = msg_release_list_struct(&msg_list);
1125 *count = local_count;
1131 if (folder_list.msg_struct_info)
1132 ret = msg_release_list_struct(&folder_list);
1134 if (msg_list.msg_struct_info)
1135 ret = msg_release_list_struct(&msg_list);
1137 ERR("Getting SMS List Failed");
1141 void _bt_map_stop_sms_service(void)
1144 msg_error_t err = MSG_SUCCESS;
1147 folder_id = __bt_get_sms_folder_id(BT_MAP_DELETED_FOLDER_NAME);
1148 if (folder_id != -1) {
1149 err = msg_delete_folder(g_msg_handle, folder_id);
1150 if (err != MSG_SUCCESS)
1151 ERR("Delete folder failed");
1155 msg_close_msg_handle(&g_msg_handle);
1156 g_msg_handle = NULL;
1162 gboolean _bt_map_start_sms_service(void)
1167 err = msg_open_msg_handle(&g_msg_handle);
1168 if (err != MSG_SUCCESS) {
1169 ERR("msg_open_msg_handle error = %d\n", err);
1173 if (__bt_get_sms_folder_id(BT_MAP_DELETED_FOLDER_NAME) == -1)
1174 __bt_add_deleted_folder();
1176 err = msg_reg_sms_message_callback(g_msg_handle,
1177 __bluetooth_map_msg_incoming_status_cb,
1178 0, (void *)BT_MAP_MSG_CB);
1179 if (err != MSG_SUCCESS) {
1180 ERR("msg_reg_sms_message_callback error = %d\n", err);
1184 err = msg_reg_sent_status_callback(g_msg_handle,
1185 __bluetooth_map_msg_sent_status_cb,
1187 if (err != MSG_SUCCESS) {
1188 ERR("msg_reg_sent_status_callback error = %d\n", err);