2 * Copyright (c) 2014 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.
20 #include <tr1/unordered_set>
24 #include <boost/filesystem.hpp>
25 #include <boost/chrono/detail/system.hpp>
28 #include "MsgUtilFile.h"
29 #include "MsgContact.h"
30 #include "MsgCppTypes.h"
31 #include "MsgGconfWrapper.h"
32 #include "MsgUtilFunction.h"
33 #include "MsgUtilStorage.h"
34 #include "MsgException.h"
37 static int msgCntLimit[MSG_COUNT_LIMIT_MAILBOX_TYPE_MAX][MSG_COUNT_LIMIT_MSG_TYPE_MAX] = {{10, 10, 0, 10, 10}, {5, 10, 0, 0, 0}, {10, 10, 0, 0, 0}, {10, 10, 0, 0, 0}, {0, 0, 10, 0, 0}};
41 #define CHECK_SIZE 1 * 1024 * 1024 * 1024
42 #define RESERVE 100 * 1024 * 1024
43 #define RESERVE_LITE 5 * 1024 * 1024
45 /*==================================================================================================
46 FUNCTION IMPLEMENTATION
47 ==================================================================================================*/
49 unsigned int MsgStoAddMessageTable(MsgDbHandler *pDbHandle, const MSG_MESSAGE_INFO_S *pMsgInfo)
53 msg_error_t err = MSG_SUCCESS;
55 msg_message_id_t msgId = 0;
57 err = pDbHandle->getRowId(MSGFW_MESSAGE_TABLE_NAME, &msgId);
59 if (err != MSG_SUCCESS)
64 char* pFileData = NULL;
65 unique_ptr<char*, void(*)(char**)> buf(&pFileData, unique_ptr_deleter);
68 if (pMsgInfo->bTextSms == false) {
69 if (MsgOpenAndReadFile(pMsgInfo->msgData, &pFileData, &fileSize) == false)
72 MSG_DEBUG("file size [%d]", fileSize);
75 char keyName[MAX_VCONFKEY_NAME_LEN];
76 memset(keyName, 0x00, sizeof(keyName));
77 snprintf(keyName, sizeof(keyName), "%s/%d", MSG_SIM_SUBS_ID, pMsgInfo->sim_idx);
80 if (MsgSettingGetString(keyName, &imsi) != MSG_SUCCESS) {
81 MSG_INFO("MsgSettingGetString() is failed");
85 char sqlQuery[MAX_QUERY_LEN+1];
87 memset(sqlQuery, 0x00, sizeof(sqlQuery));
88 snprintf(sqlQuery, sizeof(sqlQuery), "INSERT INTO %s VALUES (%d, %d, %d, %d, %d, %d, %lu, %zu, %d, %d, %d, %d, %d, %d, %d, ?, '', '', ?, 0, %d, '%s', %d);",
89 MSGFW_MESSAGE_TABLE_NAME, msgId, pMsgInfo->threadId, pMsgInfo->folderId, pMsgInfo->storageId, pMsgInfo->msgType.mainType,
90 pMsgInfo->msgType.subType, pMsgInfo->displayTime, pMsgInfo->dataSize, pMsgInfo->networkStatus, pMsgInfo->bRead, pMsgInfo->bProtected,
91 pMsgInfo->priority, pMsgInfo->direction, 0, pMsgInfo->bBackup, pMsgInfo->sim_idx, imsi, pMsgInfo->bRestricted);
93 MSG_DEBUG("QUERY : %s", sqlQuery);
98 if (pDbHandle->prepareQuery(sqlQuery) != MSG_SUCCESS)
101 pDbHandle->bindText(pMsgInfo->subject, 1);
103 if (pMsgInfo->msgType.subType == MSG_NOTIFICATIONIND_MMS) {
104 pDbHandle->bindText("", 2);
106 if (pMsgInfo->bTextSms == false)
107 pDbHandle->bindText(pFileData, 2);
109 pDbHandle->bindText(pMsgInfo->msgText, 2);
112 if (pDbHandle->stepQuery() != MSG_ERR_DB_DONE) {
113 pDbHandle->finalizeQuery();
117 pDbHandle->finalizeQuery();
123 msg_error_t MsgStoSetReadStatus(MsgDbHandler *pDbHandle, msg_message_id_t msgId, bool bRead)
125 char sqlQuery[MAX_QUERY_LEN+1];
127 memset(sqlQuery, 0x00, sizeof(sqlQuery));
128 snprintf(sqlQuery, sizeof(sqlQuery), "UPDATE %s SET READ_STATUS = %d WHERE MSG_ID = %d;",
129 MSGFW_MESSAGE_TABLE_NAME, (int)bRead, msgId);
131 if (pDbHandle->execQuery(sqlQuery) != MSG_SUCCESS)
132 return MSG_ERR_DB_EXEC;
134 /* Get MAIN_TYPE, SUB_TYPE, STORAGE_ID */
135 memset(sqlQuery, 0x00, sizeof(sqlQuery));
136 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT A.MAIN_TYPE, A.SUB_TYPE, B.CONV_ID \
137 FROM %s A, %s B WHERE A.MSG_ID = %d AND A.CONV_ID = B.CONV_ID;",
138 MSGFW_MESSAGE_TABLE_NAME, MSGFW_CONVERSATION_TABLE_NAME, msgId);
140 if (pDbHandle->prepareQuery(sqlQuery) != MSG_SUCCESS)
141 return MSG_ERR_DB_PREPARE;
143 MSG_MESSAGE_TYPE_S msgType;
144 msg_thread_id_t convId;
146 if (pDbHandle->stepQuery() == MSG_ERR_DB_ROW) {
147 msgType.mainType = pDbHandle->columnInt(0);
148 msgType.subType = pDbHandle->columnInt(1);
149 convId = pDbHandle->columnInt(2);
151 pDbHandle->finalizeQuery();
152 return MSG_ERR_DB_STEP;
155 pDbHandle->finalizeQuery();
157 MSG_DEBUG("Main Type:[%d] SubType:[%d] ConvId:[%d]", msgType.mainType, msgType.subType, convId);
159 if (MsgStoUpdateConversation(pDbHandle, convId) != MSG_SUCCESS) {
160 MSG_DEBUG("MsgStoUpdateConversation() Error");
161 return MSG_ERR_STORAGE_ERROR;
168 msg_error_t MsgStoGetOldestMessage(MsgDbHandler *pDbHandle, const MSG_MESSAGE_INFO_S *pMsgInfo, msg_message_id_t *pMsgId)
170 char sqlQuery[MAX_QUERY_LEN+1];
172 memset(sqlQuery, 0x00, sizeof(sqlQuery));
174 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT MSG_ID FROM %s \
175 WHERE SUB_TYPE = %d AND FOLDER_ID = %d AND STORAGE_ID = %d AND PROTECTED = 0 \
176 ORDER BY DISPLAY_TIME ASC",
177 MSGFW_MESSAGE_TABLE_NAME, pMsgInfo->msgType.subType, pMsgInfo->folderId, MSG_STORAGE_PHONE);
179 if (pDbHandle->prepareQuery(sqlQuery) != MSG_SUCCESS)
180 return MSG_ERR_DB_PREPARE;
182 if (pDbHandle->stepQuery() == MSG_ERR_DB_ROW) {
183 *pMsgId = pDbHandle->columnInt(0);
185 pDbHandle->finalizeQuery();
186 return MSG_ERR_DB_STEP;
189 pDbHandle->finalizeQuery();
195 msg_error_t MsgStoCheckMsgCntFull(MsgDbHandler *pDbHandle, const MSG_MESSAGE_TYPE_S* pMsgType, msg_folder_id_t folderId)
199 msg_error_t err = MSG_SUCCESS;
201 boost::system::error_code ec;
202 boost::filesystem::space_info si = boost::filesystem::space(TZ_SYS_HOME_PATH, ec);
203 long long int available = 0;
206 MSG_ERR("Failed to get space info [%s]", ec.message().c_str());
207 return MSG_ERR_STORAGE_ERROR;
209 if (si.capacity < CHECK_SIZE)
210 available = si.available - RESERVE_LITE;
212 available = si.available - RESERVE;
217 MSG_DEBUG("Free space of storage is [%llu] Bytes.", available);
219 if (available < SMS_MINIMUM_SPACE && pMsgType->mainType == MSG_SMS_TYPE)
220 err = MSG_ERR_MESSAGE_COUNT_FULL;
221 else if (available < MMS_MINIMUM_SPACE && pMsgType->mainType == MSG_MMS_TYPE)
222 err = MSG_ERR_MESSAGE_COUNT_FULL;
231 msg_error_t MsgStoCountMsgByLimitCategory(MsgDbHandler *pDbHandle, const MSG_MESSAGE_TYPE_S *pMsgType, int *pMsgCount, msg_folder_id_t folderId)
233 if (pMsgType == NULL) {
234 MSG_DEBUG("pMsgType is NULL");
235 return MSG_ERR_NULL_POINTER;
240 char sqlQuery[MAX_QUERY_LEN+1];
241 memset(sqlQuery, 0x00, sizeof(sqlQuery));
243 if ((pMsgType->mainType == MSG_SMS_TYPE) && (pMsgType->subType == MSG_WAP_SI_SMS ||pMsgType->subType == MSG_WAP_SL_SMS)) { /* PUSH */
244 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT COUNT(MSG_ID) FROM %s WHERE MAIN_TYPE = %d AND SUB_TYPE IN (%d, %d) AND FOLDER_ID = %d;",
245 MSGFW_MESSAGE_TABLE_NAME, pMsgType->mainType, MSG_WAP_SI_SMS, MSG_WAP_SL_SMS, MSG_INBOX_ID);
246 } else if ((pMsgType->mainType == MSG_SMS_TYPE) && (pMsgType->subType == MSG_CB_SMS)) { /* CB */
247 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT COUNT(MSG_ID) FROM %s WHERE MAIN_TYPE = %d AND SUB_TYPE IN (%d) AND FOLDER_ID = %d;",
248 MSGFW_MESSAGE_TABLE_NAME, pMsgType->mainType, MSG_CB_SMS, MSG_CBMSGBOX_ID);
249 } else if ((pMsgType->mainType == MSG_SMS_TYPE) && (pMsgType->subType == MSG_SYNCML_CP)) { /* Provision */
250 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT COUNT(MSG_ID) FROM %s WHERE MAIN_TYPE = %d AND SUB_TYPE IN (%d) AND FOLDER_ID = %d;",
251 MSGFW_MESSAGE_TABLE_NAME, pMsgType->mainType, MSG_SYNCML_CP, MSG_INBOX_ID);
252 } else if ((pMsgType->mainType == MSG_SMS_TYPE)) { /* SMS */
253 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT COUNT(MSG_ID) FROM %s WHERE MAIN_TYPE = %d AND SUB_TYPE NOT IN (%d, %d, %d, %d) AND FOLDER_ID = %d;",
254 MSGFW_MESSAGE_TABLE_NAME, pMsgType->mainType, MSG_WAP_SI_SMS, MSG_WAP_SL_SMS, MSG_CB_SMS, MSG_SYNCML_CP, MSG_INBOX_ID); /* etc SMS */
255 } else if ((pMsgType->mainType == MSG_MMS_TYPE) &&
256 (pMsgType->subType == MSG_SENDREQ_MMS || pMsgType->subType == MSG_SENDCONF_MMS || pMsgType->subType == MSG_RETRIEVE_AUTOCONF_MMS ||
257 pMsgType->subType == MSG_RETRIEVE_MANUALCONF_MMS || pMsgType->subType == MSG_NOTIFICATIONIND_MMS)) { /* MMS */
258 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT COUNT(MSG_ID) FROM %s WHERE MAIN_TYPE = %d AND SUB_TYPE IN (%d, %d, %d, %d, %d) AND FOLDER_ID = %d;",
259 MSGFW_MESSAGE_TABLE_NAME, pMsgType->mainType, MSG_SENDREQ_MMS, MSG_SENDCONF_MMS, MSG_RETRIEVE_AUTOCONF_MMS, MSG_RETRIEVE_MANUALCONF_MMS, MSG_NOTIFICATIONIND_MMS, folderId);
261 return MSG_ERR_INVALID_PARAMETER;
264 if (pDbHandle->prepareQuery(sqlQuery) != MSG_SUCCESS)
265 return MSG_ERR_DB_PREPARE;
267 if (pDbHandle->stepQuery() == MSG_ERR_DB_ROW) {
268 *pMsgCount = pDbHandle->columnInt(0);
270 pDbHandle->finalizeQuery();
271 return MSG_ERR_DB_STEP;
274 pDbHandle->finalizeQuery();
280 int MsgStoCheckMsgCntLimit(const MSG_MESSAGE_TYPE_S* pMsgType, msg_folder_id_t folderId)
287 msgboxType = MSG_COUNT_LIMIT_INBOX_TYPE;
291 msgboxType = MSG_COUNT_LIMIT_OUTBOX_TYPE;
294 case MSG_SENTBOX_ID :
295 msgboxType = MSG_COUNT_LIMIT_SENTBOX_TYPE;
299 msgboxType = MSG_COUNT_LIMIT_DRAFTBOX_TYPE;
302 case MSG_CBMSGBOX_ID :
303 msgboxType = MSG_COUNT_LIMIT_CBMSGBOX_TYPE;
307 MSG_DEBUG("Unknown mailbox Type [%d]", folderId);
311 switch (pMsgType->subType) {
313 case MSG_REPLACE_TYPE1_SMS:
314 case MSG_REPLACE_TYPE2_SMS:
315 case MSG_REPLACE_TYPE3_SMS:
316 case MSG_REPLACE_TYPE4_SMS:
317 case MSG_REPLACE_TYPE5_SMS:
318 case MSG_REPLACE_TYPE6_SMS:
319 case MSG_REPLACE_TYPE7_SMS:
320 case MSG_MWI_VOICE_SMS:
321 case MSG_MWI_FAX_SMS:
322 case MSG_MWI_EMAIL_SMS:
323 case MSG_MWI_OTHER_SMS:
324 case MSG_STATUS_REPORT_SMS:
325 msgType = MSG_COUNT_LIMIT_SMS_TYPE;
329 msgType = MSG_COUNT_LIMIT_CB_TYPE;
334 msgType = MSG_COUNT_LIMIT_WAPPUSH_TYPE;
338 msgType = MSG_COUNT_LIMIT_PROVISION_TYPE;
341 case MSG_SENDREQ_MMS:
342 case MSG_SENDCONF_MMS:
343 case MSG_NOTIFICATIONIND_MMS:
344 case MSG_RETRIEVE_AUTOCONF_MMS:
345 case MSG_RETRIEVE_MANUALCONF_MMS:
346 msgType = MSG_COUNT_LIMIT_MMS_TYPE;
350 MSG_DEBUG("Unknown Message Type [%d]", pMsgType->subType);
354 return msgCntLimit[msgboxType][msgType];
358 msg_error_t MsgStocheckMemoryStatus()
360 msg_error_t err = MSG_SUCCESS;
361 boost::system::error_code ec;
362 boost::filesystem::space_info si = boost::filesystem::space(TZ_SYS_HOME_PATH, ec);
363 long long int available = 0;
366 MSG_ERR("Failed to get space info [%s]", ec.message().c_str());
367 return MSG_ERR_STORAGE_ERROR;
370 if (si.capacity < CHECK_SIZE)
371 available = si.available - RESERVE_LITE;
373 available = si.available - RESERVE;
378 MSG_DEBUG("Free space of storage is [%llu] Bytes.", available);
380 if (available < SMS_MINIMUM_SPACE)
381 err = MSG_ERR_MESSAGE_COUNT_FULL;
383 MSG_DEBUG("Memory status =[%d]", err);
389 msg_error_t MsgStoAddAddress(MsgDbHandler *pDbHandle, const MSG_MESSAGE_INFO_S *pMsg, msg_thread_id_t *pConvId)
391 msg_error_t err = MSG_SUCCESS;
393 char sqlQuery[MAX_QUERY_LEN+1];
395 /* Check if new address or not */
396 if (MsgExistAddress(pDbHandle, pMsg, pConvId) == true) {
397 MSG_DEBUG("The address already exists. Conversation ID : [%d]", *pConvId);
398 MsgStoUpdateAddress(pDbHandle, pMsg, *pConvId);
403 *pConvId = pMsg->threadId;
405 /* conversation insert */
406 err = MsgStoAddConversation(pDbHandle, pConvId);
407 if (err != MSG_SUCCESS) {
408 MSG_DEBUG("MsgStoAddConversation() fail [%d]", err);
412 /* insert address in loop */
413 for (int i = 0; i < pMsg->nAddressCnt; i++) {
415 MSG_CONTACT_INFO_S contactInfo;
416 memset(&contactInfo, 0x00, sizeof(MSG_CONTACT_INFO_S));
418 /* Get Contact Info */
420 if (MsgGetContactInfo(&(pMsg->addressList[i]), &contactInfo) != MSG_SUCCESS) {
421 MSG_DEBUG("MsgGetContactInfo() fail.");
425 err = pDbHandle->getRowId(MSGFW_ADDRESS_TABLE_NAME, &addrId);
426 if (err != MSG_SUCCESS) {
427 MSG_DEBUG("pDbHandle->getRowId fail. [%d]", err);
432 memset(sqlQuery, 0x00, sizeof(sqlQuery));
433 snprintf(sqlQuery, sizeof(sqlQuery), "INSERT INTO %s VALUES (%d, %d, %d, %d, '%s', %d, %d, ?, ?, ?, ?, ?, '%s', 0);",
434 MSGFW_ADDRESS_TABLE_NAME, addrId, *pConvId, pMsg->addressList[i].addressType, pMsg->addressList[i].recipientType, pMsg->addressList[i].addressVal,
435 contactInfo.contactId, contactInfo.addrbookId, contactInfo.imagePath);
437 MSG_SEC_DEBUG("Add Address Info. [%s]", sqlQuery);
439 if (pDbHandle->prepareQuery(sqlQuery) != MSG_SUCCESS)
440 return MSG_ERR_DB_PREPARE;
442 pDbHandle->bindText(contactInfo.firstName, 1);
443 pDbHandle->bindText(contactInfo.lastName, 2);
444 pDbHandle->bindText(contactInfo.middleName, 3);
445 pDbHandle->bindText(contactInfo.prefix, 4);
446 pDbHandle->bindText(contactInfo.suffix, 5);
448 if (pDbHandle->stepQuery() != MSG_ERR_DB_DONE) {
449 pDbHandle->finalizeQuery();
450 return MSG_ERR_DB_STEP;
453 pDbHandle->finalizeQuery();
457 /* set conversation display name by conv id */
458 MsgStoSetConversationDisplayName(pDbHandle, *pConvId);
463 msg_error_t MsgStoGetAddressByMsgId(MsgDbHandler *pDbHandle, msg_message_id_t msgId, int *nAddressCnt, MSG_ADDRESS_INFO_S **pAddress)
465 char sqlQuery[MAX_QUERY_LEN+1];
466 int rowCnt = 0, index = 0;
470 memset(sqlQuery, 0x00, sizeof(sqlQuery));
471 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT "
476 "WHERE A.CONV_ID = B.CONV_ID "
477 "AND B.MSG_ID = %d;",
478 MSGFW_ADDRESS_TABLE_NAME, MSGFW_MESSAGE_TABLE_NAME,
481 msg_error_t err = pDbHandle->getTable(sqlQuery, &rowCnt, &index);
483 if (err == MSG_ERR_DB_NORECORD) {
484 pDbHandle->freeTable();
486 } else if (err != MSG_SUCCESS) {
487 MSG_DEBUG("Fail to getTable().");
488 pDbHandle->freeTable();
492 *nAddressCnt = rowCnt;
494 MSG_DEBUG("*nAddressCnt [%d]", *nAddressCnt);
496 MSG_ADDRESS_INFO_S *tmpAddressList = (MSG_ADDRESS_INFO_S *)new char[sizeof(MSG_ADDRESS_INFO_S) * rowCnt];
497 memset(tmpAddressList, 0x00, sizeof(MSG_ADDRESS_INFO_S) * rowCnt);
498 *pAddress = tmpAddressList;
500 for (int i = 0; i < rowCnt; i++) {
501 tmpAddressList[i].addressType = pDbHandle->getColumnToInt(index++);
502 tmpAddressList[i].recipientType = pDbHandle->getColumnToInt(index++);
503 pDbHandle->getColumnToString(index++, MAX_ADDRESS_VAL_LEN, tmpAddressList[i].addressVal);
505 strncpy(tmpAddressList[i].displayName, tmpAddressList[i].addressVal, MAX_DISPLAY_NAME_LEN);
507 pDbHandle->freeTable();
512 msg_error_t MsgStoGetAddressByMsgId(MsgDbHandler *pDbHandle, msg_message_id_t msgId, msg_struct_list_s *pAddress)
514 char sqlQuery[MAX_QUERY_LEN+1];
516 int rowCnt = 0, index = 0;
518 pAddress->nCount = 0;
519 pAddress->msg_struct_info = NULL;
521 msg_struct_s *pTmp = NULL;
522 MSG_ADDRESS_INFO_S *pAddr = NULL;
524 pAddress->msg_struct_info = (msg_struct_t *)calloc(MAX_TO_ADDRESS_CNT, sizeof(msg_struct_t));
525 if (pAddress->msg_struct_info == NULL)
526 return MSG_ERR_MEMORY_ERROR;
528 for (int i = 0; i < MAX_TO_ADDRESS_CNT; i++) {
529 pAddress->msg_struct_info[i] = (msg_struct_t)new msg_struct_s;
530 pTmp = (msg_struct_s *)pAddress->msg_struct_info[i];
531 pTmp->type = MSG_STRUCT_ADDRESS_INFO;
532 pTmp->data = new MSG_ADDRESS_INFO_S;
533 memset(pTmp->data, 0x00, sizeof(MSG_ADDRESS_INFO_S));
536 memset(sqlQuery, 0x00, sizeof(sqlQuery));
537 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT "
542 "WHERE A.CONV_ID = B.CONV_ID "
543 "AND B.MSG_ID = %d;",
544 MSGFW_ADDRESS_TABLE_NAME, MSGFW_MESSAGE_TABLE_NAME,
547 msg_error_t err = pDbHandle->getTable(sqlQuery, &rowCnt, &index);
549 if (err == MSG_ERR_DB_NORECORD) {
550 pDbHandle->freeTable();
552 } else if (err != MSG_SUCCESS) {
553 MSG_DEBUG("Fail to getTable().");
554 pDbHandle->freeTable();
558 rowCnt = (rowCnt > 10)? MAX_TO_ADDRESS_CNT: rowCnt;
559 pAddress->nCount = rowCnt;
561 for (int i = 0; i < rowCnt; i++) {
562 pTmp = (msg_struct_s *)pAddress->msg_struct_info[i];
563 pAddr = (MSG_ADDRESS_INFO_S *)pTmp->data;
565 pAddr->addressType = pDbHandle->getColumnToInt(index++);
566 pAddr->recipientType = pDbHandle->getColumnToInt(index++);
568 pDbHandle->getColumnToString(index++, MAX_ADDRESS_VAL_LEN, pAddr->addressVal);
570 strncpy(pAddr->displayName, pAddr->addressVal, MAX_DISPLAY_NAME_LEN);
573 pDbHandle->freeTable();
579 msg_error_t MsgStoGetRecipientsByMsgId(MsgDbHandler *pDbHandle, msg_message_id_t msgId, int *nAddressCnt, MSG_ADDRESS_INFO_S **pAddress)
581 char sqlQuery[MAX_QUERY_LEN+1];
582 int rowCnt = 0, index = 0;
586 memset(sqlQuery, 0x00, sizeof(sqlQuery));
587 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT ADDRESS_TYPE, RECIPIENT_TYPE, ADDRESS_VAL FROM %s WHERE MSG_ID = %d;",
588 MSGFW_MMS_RECIPIENTS_TABLE_NAME, msgId);
590 msg_error_t err = pDbHandle->getTable(sqlQuery, &rowCnt, &index);
592 if (err == MSG_ERR_DB_NORECORD) {
593 pDbHandle->freeTable();
595 } else if (err != MSG_SUCCESS) {
596 MSG_DEBUG("Fail to getTable().");
597 pDbHandle->freeTable();
601 *nAddressCnt = rowCnt;
603 MSG_DEBUG("*nAddressCnt [%d]", *nAddressCnt);
605 MSG_ADDRESS_INFO_S *tmpAddressList = (MSG_ADDRESS_INFO_S *)new char[sizeof(MSG_ADDRESS_INFO_S) * rowCnt];
606 memset(tmpAddressList, 0x00, sizeof(MSG_ADDRESS_INFO_S) * rowCnt);
607 *pAddress = tmpAddressList;
609 for (int i = 0; i < rowCnt; i++) {
610 tmpAddressList[i].addressType = pDbHandle->getColumnToInt(index++);
611 tmpAddressList[i].recipientType = pDbHandle->getColumnToInt(index++);
612 pDbHandle->getColumnToString(index++, MAX_ADDRESS_VAL_LEN, tmpAddressList[i].addressVal);
613 strncpy(tmpAddressList[i].displayName, tmpAddressList[i].addressVal, MAX_DISPLAY_NAME_LEN);
615 pDbHandle->freeTable();
621 msg_error_t MsgStoGetAddressByConvId(MsgDbHandler *pDbHandle, msg_thread_id_t convId, msg_struct_list_s *pAddrlist)
623 char sqlQuery[MAX_QUERY_LEN+1];
625 int rowCnt = 0, index = 0;
627 pAddrlist->nCount = 0;
628 pAddrlist->msg_struct_info = NULL;
630 memset(sqlQuery, 0x00, sizeof(sqlQuery));
631 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT "
635 "FROM %s WHERE CONV_ID = %d;",
636 MSGFW_ADDRESS_TABLE_NAME, convId);
638 msg_error_t err = pDbHandle->getTable(sqlQuery, &rowCnt, &index);
640 if (err == MSG_ERR_DB_NORECORD) {
641 pDbHandle->freeTable();
643 } else if (err != MSG_SUCCESS) {
644 MSG_DEBUG("Fail to getTable().");
645 pDbHandle->freeTable();
649 pAddrlist->nCount = rowCnt;
651 MSG_DEBUG("pAddrlist->nCount [%d]", pAddrlist->nCount);
653 msg_struct_s *pTmp = NULL;
654 MSG_ADDRESS_INFO_S *pAddr = NULL;
656 pAddrlist->msg_struct_info = (msg_struct_t *)calloc(rowCnt, sizeof(msg_struct_t));
658 for (int i = 0; i < rowCnt; i++) {
659 pAddrlist->msg_struct_info[i] = (msg_struct_t)new msg_struct_s;
660 pTmp = (msg_struct_s *)pAddrlist->msg_struct_info[i];
661 pTmp->type = MSG_STRUCT_ADDRESS_INFO;
662 pTmp->data = new MSG_ADDRESS_INFO_S;
663 memset(pTmp->data, 0x00, sizeof(MSG_ADDRESS_INFO_S));
666 /* rowCnt = (rowCnt > 10)? MAX_TO_ADDRESS_CNT: rowCnt; */
668 for (int i = 0; i < rowCnt; i++) {
669 pTmp = (msg_struct_s *)pAddrlist->msg_struct_info[i];
670 pAddr = (MSG_ADDRESS_INFO_S *)pTmp->data;
672 pAddr->addressType = pDbHandle->getColumnToInt(index++);
673 pAddr->recipientType = pDbHandle->getColumnToInt(index++);
674 pDbHandle->getColumnToString(index++, MAX_ADDRESS_VAL_LEN, pAddr->addressVal);
676 strncpy(pAddr->displayName, pAddr->addressVal, MAX_DISPLAY_NAME_LEN);
678 pDbHandle->freeTable();
683 /* Have to use trigger for this function. */
684 msg_error_t MsgStoUpdateConversation(MsgDbHandler *pDbHandle, msg_thread_id_t convId)
688 char sqlQuery[MAX_QUERY_LEN];
689 unsigned int tmpSize = 0;
691 #ifdef MSG_NOTI_INTEGRATION
692 memset(sqlQuery, 0x00, MAX_QUERY_LEN);
693 snprintf(sqlQuery, sizeof(sqlQuery),
696 "WHERE CONV_ID = %d "
697 "AND FOLDER_ID > %d AND FOLDER_ID < %d "
698 "AND STORAGE_ID = %d;",
699 MSGFW_MESSAGE_TABLE_NAME,
701 MSG_ALLBOX_ID, MSG_SPAMBOX_ID,
704 memset(sqlQuery, 0x00, MAX_QUERY_LEN);
705 snprintf(sqlQuery, sizeof(sqlQuery),
708 "WHERE CONV_ID = %d "
709 "AND FOLDER_ID > %d AND FOLDER_ID < %d "
710 "AND STORAGE_ID = %d;",
711 MSGFW_MESSAGE_TABLE_NAME,
713 MSG_ALLBOX_ID, MSG_CBMSGBOX_ID,
717 msg_error_t err = pDbHandle->prepareQuery(sqlQuery);
718 if (err != MSG_SUCCESS) {
719 MSG_DEBUG("Fail to prepareQuery().");
720 pDbHandle->finalizeQuery();
724 if (pDbHandle->stepQuery() == MSG_ERR_DB_ROW) {
725 pDbHandle->finalizeQuery();
727 memset(sqlQuery, 0x00, MAX_QUERY_LEN);
728 snprintf(sqlQuery, sizeof(sqlQuery),
729 "SELECT MAIN_TYPE, SUB_TYPE, MSG_DIRECTION, MSG_ID, DISPLAY_TIME, LENGTH(SUBJECT), SUBJECT, MSG_TEXT, DPM_RESTRICTED "
731 "WHERE CONV_ID = %d AND FOLDER_ID > %d AND FOLDER_ID < %d AND STORAGE_ID = %d AND SCHEDULED_TIME = 0 ORDER BY DISPLAY_TIME DESC;",
732 MSGFW_MESSAGE_TABLE_NAME,
733 convId, MSG_ALLBOX_ID, MSG_SPAMBOX_ID, MSG_STORAGE_PHONE);
735 err = pDbHandle->prepareQuery(sqlQuery);
736 if (err != MSG_SUCCESS) {
737 MSG_DEBUG("Fail to prepareQuery().");
741 err = pDbHandle->stepQuery();
742 if (err != MSG_ERR_DB_ROW) {
743 MSG_DEBUG("Fail to stepQuery().");
744 pDbHandle->finalizeQuery();
748 int main_type = pDbHandle->columnInt(0);
749 int sub_type = pDbHandle->columnInt(1);
750 int msg_direction = pDbHandle->columnInt(2);
751 int last_msg_id = pDbHandle->columnInt(3);
752 time_t disp_time = (time_t)pDbHandle->columnInt(4);
753 int subject_length = pDbHandle->columnInt(5);
754 bool dpm_restricted = pDbHandle->columnInt(8);
755 char subject[MAX_SUBJECT_LEN+1] = {0, };
756 char msg_text[MAX_MSG_TEXT_LEN+1] = {0, };
757 if (!dpm_restricted) {
758 snprintf(subject, sizeof(subject), "%s", pDbHandle->columnText(6));
759 snprintf(msg_text, sizeof(msg_text), "%s", pDbHandle->columnText(7));
761 snprintf(subject, sizeof(subject), "restricted message");
762 snprintf(msg_text, sizeof(msg_text), "restricted message");
765 pDbHandle->finalizeQuery();
766 memset(sqlQuery, 0x00, MAX_QUERY_LEN);
767 snprintf(sqlQuery, sizeof(sqlQuery),
769 MSGFW_CONVERSATION_TABLE_NAME);
771 tmpSize = strlen(sqlQuery);
772 #ifdef MSG_NOTI_INTEGRATION
773 snprintf(sqlQuery+tmpSize, MAX_QUERY_LEN-tmpSize,
774 "UNREAD_CNT = (SELECT COUNT(MSG_ID) FROM %s WHERE CONV_ID = %d AND (FOLDER_ID = %d OR FOLDER_ID = %d) AND STORAGE_ID = %d AND READ_STATUS = 0), ",
775 MSGFW_MESSAGE_TABLE_NAME, convId, MSG_INBOX_ID, MSG_CBMSGBOX_ID, MSG_STORAGE_PHONE);
777 snprintf(sqlQuery+tmpSize, MAX_QUERY_LEN-tmpSize,
778 "UNREAD_CNT = (SELECT COUNT(MSG_ID) FROM %s WHERE CONV_ID = %d AND FOLDER_ID = %d AND STORAGE_ID = %d AND READ_STATUS = 0), ",
779 MSGFW_MESSAGE_TABLE_NAME, convId, MSG_INBOX_ID, MSG_STORAGE_PHONE);
782 tmpSize = strlen(sqlQuery);
783 #ifdef MSG_NOTI_INTEGRATION
784 snprintf(sqlQuery+tmpSize, MAX_QUERY_LEN-tmpSize,
785 "SMS_CNT = (SELECT COUNT(MSG_ID) FROM %s WHERE CONV_ID = %d AND MAIN_TYPE = %d AND FOLDER_ID > %d AND FOLDER_ID < %d AND STORAGE_ID = %d), ",
786 MSGFW_MESSAGE_TABLE_NAME, convId, MSG_SMS_TYPE, MSG_ALLBOX_ID, MSG_SPAMBOX_ID, MSG_STORAGE_PHONE);
788 snprintf(sqlQuery+tmpSize, MAX_QUERY_LEN-tmpSize,
789 "SMS_CNT = (SELECT COUNT(MSG_ID) FROM %s WHERE CONV_ID = %d AND MAIN_TYPE = %d AND FOLDER_ID > %d AND FOLDER_ID < %d AND STORAGE_ID = %d), ",
790 MSGFW_MESSAGE_TABLE_NAME, convId, MSG_SMS_TYPE, MSG_ALLBOX_ID, MSG_CBMSGBOX_ID, MSG_STORAGE_PHONE);
793 tmpSize = strlen(sqlQuery);
794 snprintf(sqlQuery+tmpSize, MAX_QUERY_LEN-tmpSize,
795 "MMS_CNT = (SELECT COUNT(MSG_ID) FROM %s WHERE CONV_ID = %d AND MAIN_TYPE = %d AND SUB_TYPE NOT IN (%d, %d, %d) AND FOLDER_ID > %d AND FOLDER_ID < %d AND STORAGE_ID = %d), ",
796 MSGFW_MESSAGE_TABLE_NAME, convId, MSG_MMS_TYPE, MSG_DELIVERYIND_MMS, MSG_READRECIND_MMS, MSG_READORGIND_MMS, MSG_ALLBOX_ID, MSG_CBMSGBOX_ID, MSG_STORAGE_PHONE);
799 tmpSize = strlen(sqlQuery);
800 snprintf(sqlQuery+tmpSize, MAX_QUERY_LEN-tmpSize,
801 "MAIN_TYPE = (SELECT MAIN_TYPE FROM %s WHERE CONV_ID = %d AND FOLDER_ID > %d AND FOLDER_ID < %d AND STORAGE_ID = %d ORDER BY DISPLAY_TIME DESC), ",
802 MSGFW_MESSAGE_TABLE_NAME, convId, MSG_ALLBOX_ID, MSG_SPAMBOX_ID, MSG_STORAGE_PHONE);
804 tmpSize = strlen(sqlQuery);
805 snprintf(sqlQuery+tmpSize, MAX_QUERY_LEN-tmpSize,
806 "SUB_TYPE = (SELECT SUB_TYPE FROM %s WHERE CONV_ID = %d AND FOLDER_ID > %d AND FOLDER_ID < %d AND STORAGE_ID = %d ORDER BY DISPLAY_TIME DESC), ",
807 MSGFW_MESSAGE_TABLE_NAME, convId, MSG_ALLBOX_ID, MSG_SPAMBOX_ID, MSG_STORAGE_PHONE);
809 tmpSize = strlen(sqlQuery);
810 snprintf(sqlQuery+tmpSize, MAX_QUERY_LEN-tmpSize,
811 "MSG_DIRECTION = (SELECT MSG_DIRECTION FROM %s WHERE CONV_ID = %d AND FOLDER_ID > %d AND FOLDER_ID < %d AND STORAGE_ID = %d ORDER BY DISPLAY_TIME DESC), ",
812 MSGFW_MESSAGE_TABLE_NAME, convId, MSG_ALLBOX_ID, MSG_SPAMBOX_ID, MSG_STORAGE_PHONE);
814 tmpSize = strlen(sqlQuery);
816 snprintf(sqlQuery+tmpSize, MAX_QUERY_LEN-tmpSize,
817 "DISPLAY_TIME = CASE "
818 "WHEN (SELECT COUNT(MSG_ID) FROM %s WHERE CONV_ID = %d AND FOLDER_ID > %d AND FOLDER_ID < %d AND STORAGE_ID = %d AND SCHEDULED_TIME = 0 ORDER BY DISPLAY_TIME DESC) > 0 "
819 "THEN (SELECT DISPLAY_TIME FROM %s WHERE CONV_ID = %d AND FOLDER_ID > %d AND FOLDER_ID < %d AND STORAGE_ID = %d AND SCHEDULED_TIME = 0 ORDER BY DISPLAY_TIME DESC) "
822 MSGFW_MESSAGE_TABLE_NAME, convId, MSG_ALLBOX_ID, MSG_SPAMBOX_ID, MSG_STORAGE_PHONE,
823 MSGFW_MESSAGE_TABLE_NAME, convId, MSG_ALLBOX_ID, MSG_SPAMBOX_ID, MSG_STORAGE_PHONE);
825 snprintf(sqlQuery+tmpSize, MAX_QUERY_LEN-tmpSize,
826 "DISPLAY_TIME = CASE "
827 "WHEN (SELECT COUNT(MSG_ID) FROM %s WHERE CONV_ID = %d AND FOLDER_ID = %d AND STORAGE_ID = %d AND READ_STATUS = 0) > 0 "
828 "THEN (SELECT DISPLAY_TIME FROM %s WHERE CONV_ID = %d AND FOLDER_ID = %d AND STORAGE_ID = %d AND READ_STATUS = 0 ORDER BY DISPLAY_TIME DESC) "
829 "WHEN (SELECT COUNT(MSG_ID) FROM %s WHERE CONV_ID = %d AND FOLDER_ID = %d AND STORAGE_ID = %d) > 0 "
830 "THEN (SELECT DISPLAY_TIME FROM %s WHERE CONV_ID = %d AND FOLDER_ID = %d AND STORAGE_ID = %d ORDER BY DISPLAY_TIME DESC) "
831 "WHEN (SELECT COUNT(MSG_ID) FROM %s WHERE CONV_ID = %d AND FOLDER_ID = %d AND STORAGE_ID = %d AND NETWORK_STATUS = %d) > 0 "
832 "THEN (SELECT DISPLAY_TIME FROM %s WHERE CONV_ID = %d AND FOLDER_ID = %d AND STORAGE_ID = %d AND NETWORK_STATUS = %d ORDER BY DISPLAY_TIME DESC) "
833 "ELSE (SELECT DISPLAY_TIME FROM %s WHERE CONV_ID = %d AND FOLDER_ID > %d AND FOLDER_ID < %d AND STORAGE_ID = %d ORDER BY DISPLAY_TIME DESC) "
835 MSGFW_MESSAGE_TABLE_NAME, convId, MSG_INBOX_ID, MSG_STORAGE_PHONE,
836 MSGFW_MESSAGE_TABLE_NAME, convId, MSG_INBOX_ID, MSG_STORAGE_PHONE,
837 MSGFW_MESSAGE_TABLE_NAME, convId, MSG_DRAFT_ID, MSG_STORAGE_PHONE,
838 MSGFW_MESSAGE_TABLE_NAME, convId, MSG_DRAFT_ID, MSG_STORAGE_PHONE,
839 MSGFW_MESSAGE_TABLE_NAME, convId, MSG_OUTBOX_ID, MSG_STORAGE_PHONE, MSG_NETWORK_SEND_FAIL,
840 MSGFW_MESSAGE_TABLE_NAME, convId, MSG_OUTBOX_ID, MSG_STORAGE_PHONE, MSG_NETWORK_SEND_FAIL,
841 MSGFW_MESSAGE_TABLE_NAME, convId, MSG_ALLBOX_ID, MSG_SPAMBOX_ID, MSG_STORAGE_PHONE);
845 tmpSize = strlen(sqlQuery);
846 snprintf(sqlQuery+tmpSize, MAX_QUERY_LEN-tmpSize,
848 "WHEN %d > 0 THEN ? ELSE ? "
852 snprintf(sqlQuery+tmpSize, MAX_QUERY_LEN-tmpSize,
854 "WHEN (SELECT COUNT(MSG_ID) FROM %s WHERE CONV_ID = %d AND FOLDER_ID > %d AND FOLDER_ID < %d AND STORAGE_ID = %d AND SCHEDULED_TIME = 0 ORDER BY DISPLAY_TIME DESC) > 0 "
856 "WHEN (SELECT LENGTH(SUBJECT) FROM %s WHERE CONV_ID = %d AND FOLDER_ID > %d AND FOLDER_ID < %d AND STORAGE_ID = %d AND SCHEDULED_TIME = 0 ORDER BY DISPLAY_TIME DESC) > 0 "
857 "THEN (SELECT SUBJECT FROM %s WHERE CONV_ID = %d AND FOLDER_ID > %d AND FOLDER_ID < %d AND STORAGE_ID = %d AND SCHEDULED_TIME = 0 ORDER BY DISPLAY_TIME DESC) "
858 "ELSE (SELECT MSG_TEXT FROM %s WHERE CONV_ID = %d AND FOLDER_ID > %d AND FOLDER_ID < %d AND STORAGE_ID = %d AND SCHEDULED_TIME = 0 ORDER BY DISPLAY_TIME DESC) "
861 MSGFW_MESSAGE_TABLE_NAME, convId, MSG_ALLBOX_ID, MSG_SPAMBOX_ID, MSG_STORAGE_PHONE,
862 MSGFW_MESSAGE_TABLE_NAME, convId, MSG_ALLBOX_ID, MSG_SPAMBOX_ID, MSG_STORAGE_PHONE,
863 MSGFW_MESSAGE_TABLE_NAME, convId, MSG_ALLBOX_ID, MSG_SPAMBOX_ID, MSG_STORAGE_PHONE,
864 MSGFW_MESSAGE_TABLE_NAME, convId, MSG_ALLBOX_ID, MSG_SPAMBOX_ID, MSG_STORAGE_PHONE);
866 tmpSize = strlen(sqlQuery);
867 snprintf(sqlQuery+tmpSize, MAX_QUERY_LEN-tmpSize,
868 "MAIN_TYPE = %d, SUB_TYPE = %d, MSG_DIRECTION = %d, DISPLAY_TIME = %lu, LAST_MSG_ID = %d ",
869 main_type, sub_type, msg_direction, disp_time, last_msg_id);
871 tmpSize = strlen(sqlQuery);
872 snprintf(sqlQuery+tmpSize, MAX_QUERY_LEN-tmpSize,
873 "WHERE CONV_ID = %d;",
875 if (pDbHandle->prepareQuery(sqlQuery) != MSG_SUCCESS) {
876 MSG_DEBUG("Query Failed [%s]", sqlQuery);
877 return MSG_ERR_DB_PREPARE;
880 pDbHandle->bindText(subject, 1);
881 pDbHandle->bindText(msg_text, 2);
883 if (pDbHandle->stepQuery() != MSG_ERR_DB_DONE) {
884 MSG_DEBUG("stepQuery() Failed");
885 pDbHandle->finalizeQuery();
886 return MSG_ERR_DB_STEP;
889 pDbHandle->finalizeQuery();
891 pDbHandle->finalizeQuery();
893 memset(sqlQuery, 0x00, MAX_QUERY_LEN);
894 snprintf(sqlQuery, sizeof(sqlQuery),
895 "UPDATE %s SET UNREAD_CNT = 0, SMS_CNT = 0, MMS_CNT = 0, MAIN_TYPE = 0, SUB_TYPE = 0, MSG_DIRECTION = 0, DISPLAY_TIME = 0, MSG_TEXT = '' "
896 "WHERE CONV_ID = %d;",
897 MSGFW_CONVERSATION_TABLE_NAME, convId);
899 if (pDbHandle->execQuery(sqlQuery) != MSG_SUCCESS) {
900 MSG_DEBUG("Query Failed [%s]", sqlQuery);
901 return MSG_ERR_DB_EXEC;
911 /* consider to replcae this function to trigger. */
912 msg_error_t MsgStoClearConversationTable(MsgDbHandler *pDbHandle)
914 msg_error_t err = MSG_SUCCESS;
916 char sqlQuery[MAX_QUERY_LEN+1];
918 memset(sqlQuery, 0x00, sizeof(sqlQuery));
920 snprintf(sqlQuery, sizeof(sqlQuery), "DELETE FROM %s "
921 "WHERE CONV_ID NOT IN (SELECT CONV_ID FROM %s) AND CONV_ID <> 0;",
922 MSGFW_CONVERSATION_TABLE_NAME, MSGFW_MESSAGE_TABLE_NAME);
924 err = pDbHandle->execQuery(sqlQuery);
926 snprintf(sqlQuery, sizeof(sqlQuery), "DELETE FROM %s WHERE CONV_ID NOT IN (SELECT CONV_ID FROM %s);",
927 MSGFW_ADDRESS_TABLE_NAME, MSGFW_CONVERSATION_TABLE_NAME);
929 err = pDbHandle->execQuery(sqlQuery);
935 msg_thread_id_t MsgGetThreadId(MsgDbHandler *pDbHandle, msg_message_id_t msgId)
937 msg_thread_id_t conv_id = 0;
939 char sqlQuery[MAX_QUERY_LEN+1];
940 memset(sqlQuery, 0x00, sizeof(sqlQuery));
941 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT CONV_ID FROM %s WHERE MSG_ID = %d;",
942 MSGFW_MESSAGE_TABLE_NAME, msgId);
944 if (pDbHandle->prepareQuery(sqlQuery) != MSG_SUCCESS)
947 if (pDbHandle->stepQuery() == MSG_ERR_DB_ROW) {
948 conv_id = pDbHandle->columnInt(0);
951 pDbHandle->finalizeQuery();
956 /* Change the function name to conversation related. */
957 bool MsgExistAddress(MsgDbHandler *pDbHandle, const MSG_MESSAGE_INFO_S *pMsg, msg_thread_id_t *pConvId)
959 msg_error_t err = MSG_SUCCESS;
961 char sqlQuery[MAX_QUERY_LEN+1];
962 unsigned int tmpSize = 0;
966 memset(sqlQuery, 0x00, sizeof(sqlQuery));
967 snprintf(sqlQuery, sizeof(sqlQuery),
968 "SELECT CONV_ID FROM ( SELECT CONV_ID FROM %s WHERE ( ",
969 MSGFW_ADDRESS_TABLE_NAME);
971 for (int i = 0; i < pMsg->nAddressCnt; i++) {
972 if (strlen(pMsg->addressList[i].addressVal) >= (unsigned int)MsgContactGetMinMatchDigit()
973 && pMsg->addressList[i].addressType != MSG_ADDRESS_TYPE_EMAIL
974 && MsgIsNumber(pMsg->addressList[i].addressVal)) {
975 int addrSize = strlen(pMsg->addressList[i].addressVal);
976 char newPhoneNum[addrSize+1];
977 memset(newPhoneNum, 0x00, sizeof(newPhoneNum));
978 MsgConvertNumber(pMsg->addressList[i].addressVal, newPhoneNum, addrSize);
980 tmpSize = strlen(sqlQuery);
981 snprintf(sqlQuery+tmpSize, MAX_QUERY_LEN-tmpSize,
982 "ADDRESS_VAL LIKE '%%%%%s' ",
985 if ((pMsg->nAddressCnt-1) == i) break;
987 tmpSize = strlen(sqlQuery);
988 snprintf(sqlQuery+tmpSize, MAX_QUERY_LEN-tmpSize, " OR ");
991 tmpSize = strlen(sqlQuery);
992 snprintf(sqlQuery+tmpSize, MAX_QUERY_LEN-tmpSize,
993 "ADDRESS_VAL LIKE '%s' ",
994 pMsg->addressList[i].addressVal);
996 if ((pMsg->nAddressCnt-1) == i) break;
998 tmpSize = strlen(sqlQuery);
999 snprintf(sqlQuery+tmpSize, MAX_QUERY_LEN-tmpSize, " OR ");
1003 tmpSize = strlen(sqlQuery);
1004 snprintf(sqlQuery+tmpSize, MAX_QUERY_LEN-tmpSize,
1005 ") AND CONV_ID IN (SELECT CONV_ID FROM %s GROUP BY CONV_ID HAVING COUNT(CONV_ID)=%d) ",
1006 MSGFW_ADDRESS_TABLE_NAME, pMsg->nAddressCnt);
1009 tmpSize = strlen(sqlQuery);
1010 snprintf(sqlQuery+tmpSize, MAX_QUERY_LEN-tmpSize,
1011 ") GROUP BY CONV_ID HAVING COUNT(CONV_ID)=%d;",
1017 err = pDbHandle->getTable(sqlQuery, &rowCnt, NULL);
1019 /* No record or other error */
1020 if (err != MSG_SUCCESS) {
1021 MSG_DEBUG("Fail to getTable().");
1022 pDbHandle->freeTable();
1026 convId = pDbHandle->getColumnToInt(1);
1029 MSG_DEBUG("Success to get convId [%d]", convId);
1031 pDbHandle->freeTable();
1035 pDbHandle->freeTable();
1041 int MsgStoGetUnreadCnt(MsgDbHandler *pDbHandle, MSG_MAIN_TYPE_T msgType)
1045 char sqlQuery[MAX_QUERY_LEN+1];
1047 memset(sqlQuery, 0x00, sizeof(sqlQuery));
1049 if (msgType == MSG_SMS_TYPE) {
1050 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT COUNT(MSG_ID) FROM %s "
1051 "WHERE MAIN_TYPE = %d "
1052 "AND (SUB_TYPE IN (%d, %d, %d, %d, %d, %d, %d) OR (SUB_TYPE >= %d AND SUB_TYPE <= %d)) "
1053 "AND FOLDER_ID = %d AND READ_STATUS = 0 AND STORAGE_ID = %d;",
1054 MSGFW_MESSAGE_TABLE_NAME,
1056 MSG_NORMAL_SMS, MSG_STATUS_REPORT_SMS, MSG_CONCAT_SIM_SMS, MSG_WAP_SI_SMS, MSG_WAP_SL_SMS, MSG_MWI_VOICE_SMS, MSG_SYNCML_CP,
1057 MSG_REPLACE_TYPE1_SMS, MSG_REPLACE_TYPE7_SMS,
1058 MSG_INBOX_ID, MSG_STORAGE_PHONE);
1059 } else if (msgType == MSG_MMS_TYPE) {
1060 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT COUNT(MSG_ID) FROM %s "
1061 "WHERE MAIN_TYPE = %d AND SUB_TYPE IN (%d, %d, %d) "
1062 "AND FOLDER_ID = %d AND READ_STATUS = 0 AND STORAGE_ID = %d;",
1063 MSGFW_MESSAGE_TABLE_NAME,
1065 MSG_RETRIEVE_AUTOCONF_MMS, MSG_RETRIEVE_MANUALCONF_MMS, MSG_NOTIFICATIONIND_MMS,
1066 MSG_INBOX_ID, MSG_STORAGE_PHONE);
1069 if (pDbHandle->prepareQuery(sqlQuery) != MSG_SUCCESS)
1072 if (pDbHandle->stepQuery() == MSG_ERR_DB_ROW) {
1073 msgCnt = pDbHandle->columnInt(0);
1075 pDbHandle->finalizeQuery();
1079 pDbHandle->finalizeQuery();
1085 msg_error_t MsgStoGetMmsRawFilePath(MsgDbHandler *pDbHandle, msg_message_id_t msgId, char *pFilePath)
1087 char sqlQuery[MAX_QUERY_LEN+1];
1089 memset(sqlQuery, 0x00, sizeof(sqlQuery));
1091 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT A.FILE_PATH FROM %s A, %s B \
1092 WHERE A.MSG_ID = B.MSG_ID AND B.MSG_ID = %d;",
1093 MMS_PLUGIN_MESSAGE_TABLE_NAME, MSGFW_MESSAGE_TABLE_NAME, msgId);
1095 if (pDbHandle->prepareQuery(sqlQuery) != MSG_SUCCESS)
1096 return MSG_ERR_DB_PREPARE;
1098 if (pDbHandle->stepQuery() == MSG_ERR_DB_ROW) {
1099 if (pDbHandle->columnText(0) != NULL)
1100 strncpy(pFilePath, (char*)pDbHandle->columnText(0), MSG_FILEPATH_LEN_MAX);
1102 pDbHandle->finalizeQuery();
1103 return MSG_ERR_DB_STEP;
1106 pDbHandle->finalizeQuery();
1112 bool MsgStoCheckReadReportRequested(MsgDbHandler *pDbHandle, msg_message_id_t msgId)
1114 msg_error_t err = MSG_SUCCESS;
1116 char sqlQuery[MAX_QUERY_LEN+1];
1118 bool bReadReportRequested = false;
1120 memset(sqlQuery, 0x00, sizeof(sqlQuery));
1122 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT A.ASK_READ_REPLY FROM %s A, %s B \
1123 WHERE A.MSG_ID = B.MSG_ID AND B.MSG_ID = %d;",
1124 MMS_PLUGIN_MESSAGE_TABLE_NAME, MSGFW_MESSAGE_TABLE_NAME, msgId);
1126 err = pDbHandle->getTable(sqlQuery, &rowCnt, NULL);
1128 if (err != MSG_SUCCESS && err != MSG_ERR_DB_NORECORD) {
1129 pDbHandle->freeTable();
1130 MSG_DEBUG("[Error]Failed to Get Table");
1131 return bReadReportRequested;
1135 pDbHandle->freeTable();
1136 MSG_DEBUG("[Error]MSG_ERR_DB_NORECORD");
1137 return bReadReportRequested;
1140 bReadReportRequested = pDbHandle->getColumnToInt(1);
1142 pDbHandle->freeTable();
1144 return bReadReportRequested;
1148 bool MsgStoCheckReadReportIsSent(MsgDbHandler *pDbHandle, msg_message_id_t msgId)
1150 msg_error_t err = MSG_SUCCESS;
1152 char sqlQuery[MAX_QUERY_LEN+1];
1155 bool bReadReportIsSent = true;
1157 memset(sqlQuery, 0x00, sizeof(sqlQuery));
1159 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT A.READ_REPORT_SENT FROM %s A, %s B \
1160 WHERE A.MSG_ID = B.MSG_ID AND B.MSG_ID = %d;",
1161 MMS_PLUGIN_MESSAGE_TABLE_NAME, MSGFW_MESSAGE_TABLE_NAME, msgId);
1163 err = pDbHandle->getTable(sqlQuery, &rowCnt, NULL);
1165 if (err != MSG_SUCCESS && err != MSG_ERR_DB_NORECORD) {
1166 pDbHandle->freeTable();
1167 MSG_DEBUG("[Error]Failed to Get Table");
1168 return bReadReportIsSent;
1172 pDbHandle->freeTable();
1173 MSG_DEBUG("[Error]MSG_ERR_DB_NORECORD");
1174 return bReadReportIsSent;
1177 bReadReportIsSent = (bool)pDbHandle->getColumnToInt(1);
1179 pDbHandle->freeTable();
1181 return bReadReportIsSent;
1185 msg_error_t MsgStoAddConversation(MsgDbHandler *pDbHandle, msg_thread_id_t *pConvId)
1187 char sqlQuery[MAX_QUERY_LEN+1];
1190 if (pDbHandle->getRowId(MSGFW_CONVERSATION_TABLE_NAME, pConvId) != MSG_SUCCESS) {
1191 return MSG_ERR_DB_EXEC;
1194 /* Add Conversation */
1195 memset(sqlQuery, 0x00, sizeof(sqlQuery));
1196 snprintf(sqlQuery, sizeof(sqlQuery), "INSERT INTO %s VALUES (%d, 0, 0, 0, 0, 0, 0, 0, '', '', 0);",
1197 MSGFW_CONVERSATION_TABLE_NAME, *pConvId);
1199 if (pDbHandle->execQuery(sqlQuery) != MSG_SUCCESS) {
1200 MSG_DEBUG("Query Failed. [%s]", sqlQuery);
1201 return MSG_ERR_DB_EXEC;
1208 msg_error_t MsgStoSetConversationDisplayName(MsgDbHandler *pDbHandle, int contactId)
1210 msg_error_t err = MSG_SUCCESS;
1212 char displayName[MAX_DISPLAY_NAME_LEN+1];
1213 char sqlQuery[MAX_QUERY_LEN+1];
1215 MSG_DEBUG("contactId [%d]", contactId);
1217 memset(sqlQuery, 0x00, sizeof(sqlQuery));
1218 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT DISTINCT(CONV_ID) FROM %s WHERE CONTACT_ID = %d;",
1219 MSGFW_ADDRESS_TABLE_NAME, contactId);
1221 err = pDbHandle->getTable(sqlQuery, &rowCnt, NULL);
1223 if (err != MSG_SUCCESS && err != MSG_ERR_DB_NORECORD) {
1224 pDbHandle->freeTable();
1225 MSG_DEBUG("Fail to getTable().");
1229 msg_struct_s *pAddrInfo = NULL;
1230 MSG_ADDRESS_INFO_S *address = NULL;
1232 for (int i = 1; i <= rowCnt; i++) {
1233 memset(displayName, 0x00, sizeof(displayName));
1234 MsgDbHandler tmpDbHandle;
1235 msg_struct_list_s addressList = {0, };
1236 MsgStoGetAddressByConvId(&tmpDbHandle, (msg_thread_id_t)pDbHandle->getColumnToInt(i), &addressList);
1238 for (int j = 0; j < addressList.nCount; j++) {
1240 strncat(displayName, ", ", MAX_DISPLAY_NAME_LEN-strlen(displayName));
1242 pAddrInfo = (msg_struct_s *)addressList.msg_struct_info[j];
1243 address = (MSG_ADDRESS_INFO_S *)pAddrInfo->data;
1245 if (address->displayName[0] == '\0')
1246 strncat(displayName, address->addressVal, MAX_DISPLAY_NAME_LEN-strlen(displayName));
1248 strncat(displayName, address->displayName, MAX_DISPLAY_NAME_LEN-strlen(displayName));
1251 memset(sqlQuery, 0x00, sizeof(sqlQuery));
1252 snprintf(sqlQuery, sizeof(sqlQuery), "UPDATE %s SET DISPLAY_NAME = ? WHERE CONV_ID = %d;",
1253 MSGFW_CONVERSATION_TABLE_NAME, pDbHandle->getColumnToInt(i));
1255 if (pDbHandle->prepareQuery(sqlQuery) != MSG_SUCCESS) {
1256 pDbHandle->freeTable();
1257 MSG_DEBUG("Query Failed [%s]", sqlQuery);
1258 return MSG_ERR_DB_PREPARE;
1261 pDbHandle->bindText(displayName, 1);
1263 if (pDbHandle->stepQuery() != MSG_ERR_DB_DONE) {
1264 pDbHandle->freeTable();
1265 pDbHandle->finalizeQuery();
1266 MSG_SEC_DEBUG("Update Conversation disply name. Fail [%s]", sqlQuery);
1267 return MSG_ERR_DB_STEP;
1270 pDbHandle->finalizeQuery();
1272 /* free address list */
1273 for (int j = 0; j < addressList.nCount; j++) {
1274 msg_struct_s *pStruct = (msg_struct_s *)addressList.msg_struct_info[j];
1275 delete (MSG_ADDRESS_INFO_S *)pStruct->data;
1276 delete (msg_struct_s *)pStruct;
1279 if (addressList.msg_struct_info != NULL) {
1280 g_free((msg_struct_t *)addressList.msg_struct_info);
1284 pDbHandle->freeTable();
1290 msg_error_t MsgStoSetConversationDisplayName(MsgDbHandler *pDbHandle, msg_thread_id_t convId)
1292 msg_error_t err = MSG_SUCCESS;
1294 char displayName[MAX_DISPLAY_NAME_LEN+1];
1295 char sqlQuery[MAX_QUERY_LEN+1];
1297 msg_struct_list_s addressList = {0, };
1299 msg_struct_s *pAddrInfo = NULL;
1300 MSG_ADDRESS_INFO_S *address = NULL;
1302 memset(displayName, 0x00, sizeof(displayName));
1304 MsgStoGetAddressByConvId(pDbHandle, convId, &addressList);
1306 for (int j = 0; j < addressList.nCount; j++) {
1308 strncat(displayName, ", ", MAX_DISPLAY_NAME_LEN-strlen(displayName));
1310 pAddrInfo = (msg_struct_s *)addressList.msg_struct_info[j];
1311 address = (MSG_ADDRESS_INFO_S *)pAddrInfo->data;
1313 if (address->displayName[0] == '\0')
1314 strncat(displayName, address->addressVal, MAX_DISPLAY_NAME_LEN-strlen(displayName));
1316 strncat(displayName, address->displayName, MAX_DISPLAY_NAME_LEN-strlen(displayName));
1319 memset(sqlQuery, 0x00, sizeof(sqlQuery));
1320 snprintf(sqlQuery, sizeof(sqlQuery), "UPDATE %s SET DISPLAY_NAME = ? WHERE CONV_ID = %d;",
1321 MSGFW_CONVERSATION_TABLE_NAME, convId);
1323 if (pDbHandle->prepareQuery(sqlQuery) != MSG_SUCCESS) {
1324 MSG_DEBUG("Query Failed [%s]", sqlQuery);
1325 return MSG_ERR_DB_PREPARE;
1328 pDbHandle->bindText(displayName, 1);
1330 if (pDbHandle->stepQuery() != MSG_ERR_DB_DONE) {
1331 pDbHandle->finalizeQuery();
1332 MSG_SEC_DEBUG("Update Conversation disply name. Fail [%s]", sqlQuery);
1333 return MSG_ERR_DB_STEP;
1336 pDbHandle->finalizeQuery();
1338 for (int j = 0; j < addressList.nCount; j++) {
1339 msg_struct_s *pStruct = (msg_struct_s *)addressList.msg_struct_info[j];
1340 delete (MSG_ADDRESS_INFO_S *)pStruct->data;
1341 delete (msg_struct_s *)pStruct;
1344 if (addressList.msg_struct_info != NULL) {
1345 g_free((msg_struct_t *)addressList.msg_struct_info);
1351 msg_error_t MsgStoUpdateNetworkStatus(MsgDbHandler *pDbHandle, MSG_MESSAGE_INFO_S *pMsgInfo, msg_network_status_t status)
1353 msg_error_t err = MSG_SUCCESS;
1355 char sqlQuery[MAX_QUERY_LEN+1];
1357 memset(sqlQuery, 0x00, sizeof(sqlQuery));
1359 snprintf(sqlQuery, sizeof(sqlQuery), "UPDATE %s SET NETWORK_STATUS = %d WHERE MSG_ID = %d;",
1360 MSGFW_MESSAGE_TABLE_NAME, status, pMsgInfo->msgId);
1362 if (pDbHandle->execQuery(sqlQuery) != MSG_SUCCESS)
1363 err = MSG_ERR_DB_EXEC;
1365 pDbHandle->finalizeQuery();
1370 bool MsgExistConversation(MsgDbHandler *pDbHandle, msg_thread_id_t convId)
1372 msg_error_t err = MSG_SUCCESS;
1374 char sqlQuery[MAX_QUERY_LEN+1];
1378 memset(sqlQuery, 0x00, sizeof(sqlQuery));
1380 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT CONV_ID FROM %s WHERE CONV_ID = %d;",
1381 MSGFW_CONVERSATION_TABLE_NAME, convId);
1383 err = pDbHandle->getTable(sqlQuery, &rowCnt, NULL);
1385 if (err == MSG_ERR_DB_NORECORD) {
1386 pDbHandle->freeTable();
1388 } else if (err != MSG_SUCCESS) {
1389 pDbHandle->freeTable();
1392 pDbHandle->freeTable();
1397 bool MsgExistInThreadViewList(MsgDbHandler *pDbHandle, msg_thread_id_t convId)
1399 msg_error_t err = MSG_SUCCESS;
1401 char sqlQuery[MAX_QUERY_LEN+1];
1405 memset(sqlQuery, 0x00, sizeof(sqlQuery));
1407 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT MSG_ID FROM %s WHERE CONV_ID = %d AND FOLDER_ID > %d AND FOLDER_ID < %d AND STORAGE_ID = %d;",
1408 MSGFW_MESSAGE_TABLE_NAME, convId, MSG_ALLBOX_ID, MSG_SPAMBOX_ID, MSG_STORAGE_PHONE);
1410 err = pDbHandle->getTable(sqlQuery, &rowCnt, NULL);
1412 if (err == MSG_ERR_DB_NORECORD) {
1413 pDbHandle->freeTable();
1415 } else if (err != MSG_SUCCESS) {
1416 pDbHandle->freeTable();
1419 pDbHandle->freeTable();
1424 bool MsgExistMessage(MsgDbHandler *pDbHandle, MSG_MESSAGE_INFO_S *pMsg)
1426 msg_error_t err = MSG_SUCCESS;
1428 char sqlQuery[MAX_QUERY_LEN+1];
1433 memset(sqlQuery, 0x00, sizeof(sqlQuery));
1435 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT MSG_ID FROM %s WHERE CONV_ID = %ud AND DISPLAY_TIME = %ud;",
1436 MSGFW_MESSAGE_TABLE_NAME, pMsg->threadId, (int)pMsg->displayTime);
1438 err = pDbHandle->getTable(sqlQuery, &rowCnt, NULL);
1441 if (err != MSG_SUCCESS) {
1442 pDbHandle->freeTable();
1447 pMsg->msgId = pDbHandle->getColumnToInt(1);
1449 pDbHandle->freeTable();
1455 bool MsgExistAddress(MsgDbHandler *pDbHandle, MSG_MESSAGE_INFO_S *pMsg, msg_thread_id_t convId, int index)
1457 msg_error_t err = MSG_SUCCESS;
1459 char sqlQuery[MAX_QUERY_LEN+1];
1464 memset(sqlQuery, 0x00, sizeof(sqlQuery));
1466 if (strlen(pMsg->addressList[index].addressVal) > (unsigned int)MsgContactGetMinMatchDigit()) {
1467 int addrSize = strlen(pMsg->addressList[index].addressVal);
1468 char newPhoneNum[addrSize+1];
1469 memset(newPhoneNum, 0x00, sizeof(newPhoneNum));
1470 MsgConvertNumber(pMsg->addressList[index].addressVal, newPhoneNum, addrSize);
1472 snprintf(sqlQuery, sizeof(sqlQuery),
1473 "SELECT ADDRESS_ID FROM %s WHERE ADDRESS_VAL LIKE '%%%%%s' AND CONV_ID= %d;",
1474 MSGFW_ADDRESS_TABLE_NAME, newPhoneNum, convId);
1476 snprintf(sqlQuery, sizeof(sqlQuery),
1477 "SELECT ADDRESS_ID FROM %s WHERE ADDRESS_VAL = '%s' AND CONV_ID= %d;",
1478 MSGFW_ADDRESS_TABLE_NAME, pMsg->addressList[index].addressVal, convId);
1481 err = pDbHandle->getTable(sqlQuery, &rowCnt, NULL);
1483 if (err == MSG_ERR_DB_NORECORD) {
1484 pDbHandle->freeTable();
1486 } else if (err != MSG_SUCCESS) {
1487 pDbHandle->freeTable();
1490 pDbHandle->freeTable();
1496 void MsgStoUpdateAddress(MsgDbHandler *pDbHandle, const MSG_MESSAGE_INFO_S *pMsg, msg_thread_id_t convId)
1499 msg_error_t err = MSG_SUCCESS;
1501 char sqlQuery[MAX_QUERY_LEN+1];
1503 for (int i = 0; i < pMsg->nAddressCnt; i++) {
1504 if (strlen(pMsg->addressList[i].addressVal) > (unsigned int)MsgContactGetMinMatchDigit() && pMsg->addressList[i].addressType == MSG_ADDRESS_TYPE_PLMN) {
1505 int addrSize = strlen(pMsg->addressList[i].addressVal);
1506 char newPhoneNum[addrSize+1];
1507 memset(newPhoneNum, 0x00, sizeof(newPhoneNum));
1508 MsgConvertNumber(pMsg->addressList[i].addressVal, newPhoneNum, addrSize);
1510 memset(sqlQuery, 0x00, sizeof(sqlQuery));
1511 snprintf(sqlQuery, sizeof(sqlQuery),
1513 "ADDRESS_VAL = '%s', "
1514 "ADDRESS_TYPE = %d, "
1515 "RECIPIENT_TYPE = %d "
1516 "WHERE CONV_ID = %d "
1517 "AND ADDRESS_VAL LIKE '%%%%%s';",
1518 MSGFW_ADDRESS_TABLE_NAME, pMsg->addressList[i].addressVal,
1519 pMsg->addressList[i].addressType, pMsg->addressList[i].recipientType, convId, newPhoneNum);
1521 err = pDbHandle->execQuery(sqlQuery);
1522 if (err != MSG_SUCCESS) MSG_DEBUG("Fail to execQuery(). [%s]", sqlQuery);
1524 pDbHandle->finalizeQuery();
1531 msg_error_t MsgStoAddCBChannelInfo(MsgDbHandler *pDbHandle, MSG_CB_CHANNEL_S *pCBChannel, msg_sim_slot_id_t simIndex)
1533 #ifndef FEATURE_SMS_CDMA
1536 char sqlQuery[MAX_QUERY_LEN] = {0, };
1538 pDbHandle->beginTrans();
1540 memset(sqlQuery, 0x00, sizeof(sqlQuery));
1541 snprintf(sqlQuery, sizeof(sqlQuery), "DELETE FROM %s WHERE SIM_INDEX = %d;", MSGFW_CB_CHANNEL_INFO_TABLE_NAME, simIndex);
1543 if (pDbHandle->execQuery(sqlQuery) != MSG_SUCCESS) {
1544 pDbHandle->endTrans(false);
1545 return MSG_ERR_DB_EXEC;
1548 for (int i = 0; i < pCBChannel->channelCnt; i++) {
1550 memset(sqlQuery, 0x00, sizeof(sqlQuery));
1551 snprintf(sqlQuery, sizeof(sqlQuery), "INSERT INTO %s(CHANNEL_ACTIVATION, CHANNEL_FROM, CHANNEL_TO, CHANNEL_NAME, SIM_INDEX) VALUES (?, ?, ?, ?, ?);",
1552 MSGFW_CB_CHANNEL_INFO_TABLE_NAME);
1554 if (pDbHandle->prepareQuery(sqlQuery) != MSG_SUCCESS) {
1555 pDbHandle->endTrans(false);
1556 return MSG_ERR_DB_PREPARE;
1558 pDbHandle->bindInt(pCBChannel->channelInfo[i].bActivate, index++);
1559 pDbHandle->bindInt(pCBChannel->channelInfo[i].from, index++);
1560 pDbHandle->bindInt(pCBChannel->channelInfo[i].to, index++);
1561 pDbHandle->bindText(pCBChannel->channelInfo[i].name, index++);
1562 pDbHandle->bindInt(simIndex, index++);
1564 if (pDbHandle->stepQuery() != MSG_ERR_DB_DONE) {
1565 pDbHandle->finalizeQuery();
1566 pDbHandle->endTrans(false);
1567 return MSG_ERR_DB_STEP;
1570 pDbHandle->finalizeQuery();
1573 pDbHandle->endTrans(true);
1578 #else /* TODO: Add multisim for CDMA */
1581 char sqlQuery[MAX_QUERY_LEN] = {0, };
1583 pDbHandle->beginTrans();
1585 memset(sqlQuery, 0x00, sizeof(sqlQuery));
1586 snprintf(sqlQuery, sizeof(sqlQuery), "DELETE FROM %s;", MSGFW_CDMA_CB_CHANNEL_INFO_TABLE_NAME);
1588 if (pDbHandle->execQuery(sqlQuery) != MSG_SUCCESS) {
1589 pDbHandle->endTrans(false);
1590 return MSG_ERR_DB_EXEC;
1593 for (int i = 0; i < pCBChannel->channelCnt; i++) {
1594 memset(sqlQuery, 0x00, sizeof(sqlQuery));
1595 snprintf(sqlQuery, sizeof(sqlQuery), "INSERT INTO %s VALUES (%d, %d, %d, %d, '%s');", MSGFW_CDMA_CB_CHANNEL_INFO_TABLE_NAME,
1596 i, pCBChannel->channelInfo[i].bActivate, pCBChannel->channelInfo[i].ctg,
1597 pCBChannel->channelInfo[i].lang, pCBChannel->channelInfo[i].name);
1599 if (pDbHandle->execQuery(sqlQuery) != MSG_SUCCESS) {
1600 pDbHandle->endTrans(false);
1601 return MSG_ERR_DB_EXEC;
1605 pDbHandle->endTrans(true);
1614 msg_error_t MsgStoGetCBChannelInfo(MsgDbHandler *pDbHandle, MSG_CB_CHANNEL_S *pCBChannel, msg_sim_slot_id_t simIndex)
1616 #ifndef FEATURE_SMS_CDMA
1619 int rowCnt = 0, index = 0;
1621 char sqlQuery[MAX_QUERY_LEN] = {0, };
1623 memset(sqlQuery, 0x00, sizeof(sqlQuery));
1624 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT CHANNEL_ACTIVATION, CHANNEL_FROM, CHANNEL_TO, CHANNEL_NAME FROM %s WHERE SIM_INDEX = %d;", MSGFW_CB_CHANNEL_INFO_TABLE_NAME, simIndex);
1626 msg_error_t err = pDbHandle->getTable(sqlQuery, &rowCnt, &index);
1628 pCBChannel->channelCnt = rowCnt;
1630 if (err == MSG_ERR_DB_NORECORD) {
1631 pDbHandle->freeTable();
1632 return MSG_ERR_DB_NORECORD;
1633 } else if (err != MSG_SUCCESS) {
1634 MSG_DEBUG("Fail to getTable().");
1635 pDbHandle->freeTable();
1636 return MSG_ERR_DB_GETTABLE;
1639 for (int i = 0; i < rowCnt; i++) {
1640 pCBChannel->channelInfo[i].bActivate = pDbHandle->getColumnToInt(index++);
1641 pCBChannel->channelInfo[i].from = pDbHandle->getColumnToInt(index++);
1642 pCBChannel->channelInfo[i].to = pDbHandle->getColumnToInt(index++);
1643 pDbHandle->getColumnToString(index++, CB_CHANNEL_NAME_MAX, pCBChannel->channelInfo[i].name);
1645 MSG_DEBUG("CH_ACT = %d", pCBChannel->channelInfo[i].bActivate);
1646 MSG_DEBUG("CH_FROM = %d", pCBChannel->channelInfo[i].from);
1647 MSG_DEBUG("CH_TO = %d", pCBChannel->channelInfo[i].to);
1648 MSG_DEBUG("CH_NAME = %s", pCBChannel->channelInfo[i].name);
1651 pDbHandle->freeTable();
1656 #else /* TODO: Add multisim for CDMA */
1659 int rowCnt = 0, index = 0;
1661 char sqlQuery[MAX_QUERY_LEN] = {0, };
1663 memset(sqlQuery, 0x00, sizeof(sqlQuery));
1664 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT CHANNEL_ACTIVATION, CHANNEL_CATEGORY, CHANNEL_LANGUAGE, CHANNEL_NAME FROM %s;", MSGFW_CDMA_CB_CHANNEL_INFO_TABLE_NAME);
1666 msg_error_t err = pDbHandle->getTable(sqlQuery, &rowCnt, &index);
1668 pCBChannel->channelCnt = rowCnt;
1670 if (err == MSG_ERR_DB_NORECORD) {
1671 pDbHandle->freeTable();
1672 return MSG_ERR_DB_NORECORD;
1673 } else if (err != MSG_SUCCESS) {
1674 MSG_DEBUG("Fail to getTable().");
1675 pDbHandle->freeTable();
1676 return MSG_ERR_DB_GETTABLE;
1679 for (int i = 0; i < rowCnt; i++) {
1680 pCBChannel->channelInfo[i].bActivate = pDbHandle->getColumnToInt(index++);
1681 pCBChannel->channelInfo[i].ctg = pDbHandle->getColumnToInt(index++);
1682 pCBChannel->channelInfo[i].lang = pDbHandle->getColumnToInt(index++);
1683 pDbHandle->getColumnToString(index++, CB_CHANNEL_NAME_MAX, pCBChannel->channelInfo[i].name);
1685 MSG_DEBUG("CH_ACT = %d", pCBChannel->channelInfo[i].bActivate);
1686 MSG_DEBUG("CH_CTG = %d", pCBChannel->channelInfo[i].ctg);
1687 MSG_DEBUG("CH_LANG = %d", pCBChannel->channelInfo[i].lang);
1688 MSG_DEBUG("CH_NAME = %s", pCBChannel->channelInfo[i].name);
1691 pDbHandle->freeTable();
1699 msg_error_t MsgStoGetThreadViewList(const MSG_SORT_RULE_S *pSortRule, msg_struct_list_s *pThreadViewList)
1701 MsgDbHandler *dbHandle = getDbHandle();
1702 dbHandle->connectReadOnly();
1704 pThreadViewList->nCount = 0;
1705 pThreadViewList->msg_struct_info = NULL;
1707 int rowCnt = 0, index = 0;
1709 char sqlQuery[MAX_QUERY_LEN+1];
1710 memset(sqlQuery, 0x00, sizeof(sqlQuery));
1712 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT A.CONV_ID, A.UNREAD_CNT, A.SMS_CNT, A.MMS_CNT, A.MAIN_TYPE, A.SUB_TYPE, "
1713 "A.MSG_DIRECTION, A.DISPLAY_TIME, A.DISPLAY_NAME, A.MSG_TEXT, "
1714 "(SELECT COUNT(MSG_ID) FROM %s M WHERE M.CONV_ID = A.CONV_ID AND M.PROTECTED = 1) AS PROTECTED, "
1715 "(CASE WHEN B.FOLDER_ID = %d THEN 1 END) AS DRAFT, "
1716 "(CASE WHEN B.NETWORK_STATUS = %d THEN 1 END) AS FAILED, "
1717 "(CASE WHEN B.NETWORK_STATUS = %d THEN 1 END) AS SENDING "
1720 "%s B ON A.LAST_MSG_ID = B.MSG_ID "
1721 "WHERE A.SMS_CNT + A.MMS_CNT > 0 "
1722 "GROUP BY A.CONV_ID ORDER BY A.DISPLAY_TIME DESC;",
1723 MSGFW_MESSAGE_TABLE_NAME,
1725 MSG_NETWORK_SEND_FAIL,
1726 MSG_NETWORK_SENDING,
1727 MSGFW_CONVERSATION_TABLE_NAME,
1728 MSGFW_MESSAGE_TABLE_NAME);
1730 msg_error_t err = dbHandle->getTable(sqlQuery, &rowCnt, &index);
1732 if (err == MSG_ERR_DB_NORECORD) {
1733 dbHandle->freeTable();
1735 } else if (err != MSG_SUCCESS) {
1736 MSG_DEBUG("Fail to getTable().");
1737 dbHandle->freeTable();
1742 MSG_DEBUG("rowCnt is %d", rowCnt);
1743 dbHandle->freeTable();
1747 pThreadViewList->nCount = rowCnt;
1749 MSG_DEBUG("pThreadViewList->nCount [%d]", pThreadViewList->nCount);
1751 pThreadViewList->msg_struct_info = (msg_struct_t *)calloc(rowCnt, sizeof(msg_struct_t));
1753 MSG_THREAD_VIEW_S *pTmp = NULL;
1754 msg_struct_s *thread_t = NULL;
1756 for (int i = 0; i < rowCnt; i++) {
1757 thread_t = (msg_struct_s *)new msg_struct_s;
1758 pThreadViewList->msg_struct_info[i] = (msg_struct_t)thread_t;
1760 thread_t->type = MSG_STRUCT_THREAD_INFO;
1761 thread_t->data = new MSG_THREAD_VIEW_S;
1763 pTmp = (MSG_THREAD_VIEW_S *)thread_t->data;
1764 memset(pTmp, 0x00, sizeof(MSG_THREAD_VIEW_S));
1766 pTmp->threadId = dbHandle->getColumnToInt(index++);
1768 pTmp->unreadCnt = dbHandle->getColumnToInt(index++);
1769 pTmp->smsCnt = dbHandle->getColumnToInt(index++);
1770 pTmp->mmsCnt = dbHandle->getColumnToInt(index++);
1772 pTmp->mainType = dbHandle->getColumnToInt(index++);
1773 pTmp->subType = dbHandle->getColumnToInt(index++);
1775 pTmp->direction = dbHandle->getColumnToInt(index++);
1776 pTmp->threadTime = (time_t)dbHandle->getColumnToInt(index++);
1778 memset(pTmp->threadName, 0x00, sizeof(pTmp->threadName));
1779 dbHandle->getColumnToString(index++, MAX_THREAD_NAME_LEN, pTmp->threadName);
1781 memset(pTmp->threadData, 0x00, sizeof(pTmp->threadData));
1782 dbHandle->getColumnToString(index++, MAX_THREAD_DATA_LEN, pTmp->threadData);
1784 pTmp->bProtected = dbHandle->getColumnToInt(index++);
1785 pTmp->bDraft = dbHandle->getColumnToInt(index++);
1786 pTmp->bSendFailed = dbHandle->getColumnToInt(index++);
1787 pTmp->bSending = dbHandle->getColumnToInt(index++);
1790 dbHandle->freeTable();
1796 msg_error_t MsgStoGetConversationPreview(MsgDbHandler *pDbHandle, MSG_CONVERSATION_VIEW_S *pConv)
1798 char sqlQuery[MAX_QUERY_LEN + 1];
1799 int rowCnt = 0, index = 0;
1800 memset(sqlQuery, 0x00, sizeof(sqlQuery));
1803 return MSG_ERR_NULL_POINTER;
1805 pConv->tcs_bc_level = -1; /* init */
1807 /*(MSG_ID INTEGER, TYPE INTEGER, VALUE TEXT, COUNT INTEGER) */
1808 snprintf(sqlQuery, sizeof(sqlQuery),
1809 "SELECT TYPE, VALUE, COUNT "
1810 "FROM %s WHERE MSG_ID=%d;",
1811 MSGFW_MMS_PREVIEW_TABLE_NAME, pConv->msgId);
1813 msg_error_t err = pDbHandle->getTable(sqlQuery, &rowCnt, &index);
1814 if (err == MSG_SUCCESS) {
1815 for (int i = 0; i < rowCnt; i++) {
1816 int type = pDbHandle->getColumnToInt(index++);
1817 if (type == MSG_MMS_ITEM_TYPE_IMG) {
1818 pDbHandle->getColumnToString(index++, MSG_FILEPATH_LEN_MAX, pConv->imageThumbPath);
1819 pDbHandle->getColumnToInt(index++);
1820 } else if (type == MSG_MMS_ITEM_TYPE_VIDEO) {
1821 pDbHandle->getColumnToString(index++, MSG_FILEPATH_LEN_MAX, pConv->videoThumbPath);
1822 pDbHandle->getColumnToInt(index++);
1823 } else if (type == MSG_MMS_ITEM_TYPE_AUDIO) {
1824 pDbHandle->getColumnToString(index++, MSG_FILENAME_LEN_MAX, pConv->audioFileName);
1825 pDbHandle->getColumnToInt(index++);
1826 } else if (type == MSG_MMS_ITEM_TYPE_ATTACH) {
1827 pDbHandle->getColumnToString(index++, MSG_FILENAME_LEN_MAX, pConv->attachFileName);
1828 pConv->attachCount = pDbHandle->getColumnToInt(index++);
1829 } else if (type == MSG_MMS_ITEM_TYPE_PAGE) {
1831 pConv->pageCount = pDbHandle->getColumnToInt(index++);
1832 } else if (type == MSG_MMS_ITEM_TYPE_MALWARE) {
1834 pConv->tcs_bc_level = pDbHandle->getColumnToInt(index++);
1835 } else if (type == MSG_MMS_ITEM_TYPE_1ST_MEDIA) {
1836 pDbHandle->getColumnToString(index++, MSG_FILEPATH_LEN_MAX, pConv->firstMediaPath);
1837 pDbHandle->getColumnToInt(index++);
1839 MSG_DEBUG("Unknown item type [%d]", type);
1845 pDbHandle->freeTable();
1849 msg_error_t MsgStoGetConversationMultipart(MsgDbHandler *pDbHandle, MSG_CONVERSATION_VIEW_S *pConv)
1851 char sqlQuery[MAX_QUERY_LEN + 1];
1852 int rowCnt = 0, index = 0;
1853 memset(sqlQuery, 0x00, sizeof(sqlQuery));
1856 return MSG_ERR_NULL_POINTER;
1858 snprintf(sqlQuery, sizeof(sqlQuery),
1859 "SELECT CONTENT_TYPE, NAME, FILE_PATH, CONTENT_ID, CONTENT_LOCATION, TCS_LEVEL, MALWARE_ALLOW, THUMB_FILE_PATH "
1860 "FROM %s WHERE MSG_ID=%d;",
1861 MSGFW_MMS_MULTIPART_TABLE_NAME, pConv->msgId);
1863 msg_error_t err = pDbHandle->getTable(sqlQuery, &rowCnt, &index);
1864 if (err == MSG_SUCCESS) {
1865 GList *multipart_list = NULL;
1866 for (int i = 0; i < rowCnt; i++) {
1867 msg_struct_s *multipart_struct_s = new msg_struct_s;
1868 multipart_struct_s->type = MSG_STRUCT_MULTIPART_INFO;
1869 multipart_struct_s->data = new MMS_MULTIPART_DATA_S;
1870 memset(multipart_struct_s->data, 0x00, sizeof(MMS_MULTIPART_DATA_S));
1872 MMS_MULTIPART_DATA_S *multipart = (MMS_MULTIPART_DATA_S *)multipart_struct_s->data;
1874 pDbHandle->getColumnToString(index++, sizeof(multipart->szContentType), multipart->szContentType);
1875 pDbHandle->getColumnToString(index++, sizeof(multipart->szFileName), multipart->szFileName);
1876 pDbHandle->getColumnToString(index++, sizeof(multipart->szFilePath), multipart->szFilePath);
1877 pDbHandle->getColumnToString(index++, sizeof(multipart->szContentID), multipart->szContentID);
1878 pDbHandle->getColumnToString(index++, sizeof(multipart->szContentLocation), multipart->szContentLocation);
1880 multipart->tcs_bc_level = pDbHandle->getColumnToInt(index++);
1881 multipart->malware_allow = pDbHandle->getColumnToInt(index++);
1882 pDbHandle->getColumnToString(index++, sizeof(multipart->szThumbFilePath), multipart->szThumbFilePath);
1884 multipart_list = g_list_append(multipart_list, multipart_struct_s);
1886 pConv->multipart_list = (msg_list_handle_t)multipart_list;
1889 pDbHandle->freeTable();
1893 msg_error_t MsgStoGetConversationViewItem(msg_message_id_t msgId, MSG_CONVERSATION_VIEW_S *pConv)
1895 MsgDbHandler *dbHandle = getDbHandle();
1896 dbHandle->connectReadOnly();
1898 int rowCnt = 0, index = 0;
1900 char sqlQuery[MAX_QUERY_LEN+1];
1902 memset(sqlQuery, 0x00, sizeof(sqlQuery));
1904 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT MSG_ID, CONV_ID, FOLDER_ID, STORAGE_ID, MAIN_TYPE, SUB_TYPE, \
1905 DISPLAY_TIME, DATA_SIZE, NETWORK_STATUS, READ_STATUS, PROTECTED, \
1906 MSG_DIRECTION, DPM_RESTRICTED, SCHEDULED_TIME, SUBJECT, MSG_TEXT, ATTACHMENT_COUNT, SIM_INDEX\
1907 FROM %s WHERE MSG_ID = %d;",
1908 MSGFW_MESSAGE_TABLE_NAME, msgId);
1910 msg_error_t err = dbHandle->getTable(sqlQuery, &rowCnt, &index);
1912 if (err == MSG_ERR_DB_NORECORD) {
1913 dbHandle->freeTable();
1915 } else if (err != MSG_SUCCESS) {
1916 MSG_DEBUG("Fail to getTable().");
1917 dbHandle->freeTable();
1921 memset(pConv, 0x00, sizeof(MSG_CONVERSATION_VIEW_S));
1922 pConv->pText = NULL;
1924 pConv->msgId = dbHandle->getColumnToInt(index++);
1925 pConv->threadId = dbHandle->getColumnToInt(index++);
1926 pConv->folderId = dbHandle->getColumnToInt(index++);
1927 pConv->storageId = dbHandle->getColumnToInt(index++);
1928 pConv->mainType = dbHandle->getColumnToInt(index++);
1929 pConv->subType = dbHandle->getColumnToInt(index++);
1930 pConv->displayTime = (time_t)dbHandle->getColumnToInt(index++);
1931 pConv->textSize = dbHandle->getColumnToInt(index++);
1932 pConv->networkStatus = dbHandle->getColumnToInt(index++);
1933 pConv->bRead = dbHandle->getColumnToInt(index++);
1934 pConv->bProtected = dbHandle->getColumnToInt(index++);
1935 pConv->direction = dbHandle->getColumnToInt(index++);
1936 pConv->bRestricted = dbHandle->getColumnToInt(index++);
1937 pConv->scheduledTime = (time_t)dbHandle->getColumnToInt(index++);
1939 dbHandle->getColumnToString(index++, MAX_SUBJECT_LEN, pConv->subject);
1940 char *tmpText = g_strdup(dbHandle->getColumnToString(index++));
1942 /*It does Not need to Get attach count in MSG_MESSAGE_TABLE. see MsgStoGetConversationPreview */
1943 /*pConv->attachCount = dbHandle->getColumnToInt(index++); */
1945 if (pConv->bRestricted == true) {
1946 pConv->textSize = 0;
1947 memset(pConv->subject, 0x00, sizeof(pConv->subject));
1951 pConv->simIndex = dbHandle->getColumnToInt(index++);
1953 dbHandle->freeTable();
1955 if (pConv->mainType == MSG_MMS_TYPE &&
1956 (pConv->networkStatus == MSG_NETWORK_RETRIEVING || pConv->networkStatus == MSG_NETWORK_RETRIEVE_FAIL || pConv->subType == MSG_NOTIFICATIONIND_MMS)) {
1957 pConv->pText = NULL;
1958 pConv->textSize = 0;
1960 if (pConv->mainType == MSG_SMS_TYPE) {
1961 pConv->pText = new char[pConv->textSize+2];
1962 memset(pConv->pText, 0x00, pConv->textSize+2);
1963 snprintf(pConv->pText, pConv->textSize+1, "%s", tmpText);
1964 } else if (pConv->mainType == MSG_MMS_TYPE) {
1966 pConv->textSize = strlen(tmpText);
1968 pConv->pText = new char[pConv->textSize+1];
1969 memset(pConv->pText, 0x00, pConv->textSize+1);
1971 strncpy(pConv->pText, tmpText, pConv->textSize);
1974 MsgStoGetConversationPreview(dbHandle, pConv);
1975 MsgStoGetConversationMultipart(dbHandle, pConv);
1990 msg_error_t MsgStoGetConversationViewList(msg_thread_id_t threadId, msg_struct_list_s *pConvViewList)
1994 MsgDbHandler *dbHandle = getDbHandle();
1995 dbHandle->connectReadOnly();
1997 pConvViewList->nCount = 0;
1998 pConvViewList->msg_struct_info = NULL;
2000 int rowCnt = 0, index = 0;
2002 char sqlQuery[MAX_QUERY_LEN+1];
2004 memset(sqlQuery, 0x00, sizeof(sqlQuery));
2006 #ifdef MSG_NOTI_INTEGRATION
2007 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT MSG_ID, CONV_ID, FOLDER_ID, STORAGE_ID, MAIN_TYPE, SUB_TYPE, \
2008 DISPLAY_TIME, DATA_SIZE, NETWORK_STATUS, READ_STATUS, PROTECTED, \
2009 MSG_DIRECTION, DPM_RESTRICTED, SCHEDULED_TIME, SUBJECT, MSG_TEXT, ATTACHMENT_COUNT, SIM_INDEX \
2010 FROM %s WHERE CONV_ID = %d AND FOLDER_ID > %d AND FOLDER_ID < %d AND STORAGE_ID = %d ORDER BY DISPLAY_TIME, MSG_ID ASC;",
2011 MSGFW_MESSAGE_TABLE_NAME, threadId, MSG_ALLBOX_ID, MSG_SPAMBOX_ID, MSG_STORAGE_PHONE);
2013 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT MSG_ID, CONV_ID, FOLDER_ID, STORAGE_ID, MAIN_TYPE, SUB_TYPE, \
2014 DISPLAY_TIME, DATA_SIZE, NETWORK_STATUS, READ_STATUS, PROTECTED, \
2015 MSG_DIRECTION, DPM_RESTRICTED, SCHEDULED_TIME, SUBJECT, MSG_TEXT, ATTACHMENT_COUNT \
2016 FROM %s WHERE CONV_ID = %d AND FOLDER_ID > %d AND FOLDER_ID < %d AND STORAGE_ID = %d ORDER BY DISPLAY_TIME, MSG_ID ASC;",
2017 MSGFW_MESSAGE_TABLE_NAME, threadId, MSG_ALLBOX_ID, MSG_CBMSGBOX_ID, MSG_STORAGE_PHONE);
2020 msg_error_t err = dbHandle->getTable(sqlQuery, &rowCnt, &index);
2022 if (err == MSG_ERR_DB_NORECORD) {
2023 dbHandle->freeTable();
2025 } else if (err != MSG_SUCCESS) {
2026 MSG_DEBUG("Fail to getTable().");
2027 dbHandle->freeTable();
2031 pConvViewList->nCount = rowCnt;
2032 char *tmpText[rowCnt] = {NULL};
2034 MSG_DEBUG("pConvViewList->nCount [%d]", pConvViewList->nCount);
2036 pConvViewList->msg_struct_info = (msg_struct_t *)calloc(rowCnt, sizeof(msg_struct_t));
2037 memset(pConvViewList->msg_struct_info, 0x00, sizeof(msg_struct_t) * rowCnt);
2039 msg_struct_s *conv = NULL;
2040 MSG_CONVERSATION_VIEW_S *pTmp = NULL;
2042 for (int i = 0; i < rowCnt; i++) {
2043 pConvViewList->msg_struct_info[i] = (msg_struct_t)new msg_struct_s;
2044 memset(pConvViewList->msg_struct_info[i], 0x00, sizeof(msg_struct_s));
2046 conv = (msg_struct_s *)pConvViewList->msg_struct_info[i];
2048 conv->type = MSG_STRUCT_CONV_INFO;
2049 conv->data = new MSG_CONVERSATION_VIEW_S;
2050 memset(conv->data, 0x00, sizeof(MSG_CONVERSATION_VIEW_S));
2052 pTmp = (MSG_CONVERSATION_VIEW_S *)conv->data;
2056 pTmp->msgId = dbHandle->getColumnToInt(index++);
2057 pTmp->threadId = dbHandle->getColumnToInt(index++);
2058 pTmp->folderId = dbHandle->getColumnToInt(index++);
2059 pTmp->storageId = dbHandle->getColumnToInt(index++);
2060 pTmp->mainType = dbHandle->getColumnToInt(index++);
2061 pTmp->subType = dbHandle->getColumnToInt(index++);
2062 pTmp->displayTime = (time_t)dbHandle->getColumnToInt(index++);
2063 pTmp->textSize = dbHandle->getColumnToInt(index++);
2064 pTmp->networkStatus = dbHandle->getColumnToInt(index++);
2065 pTmp->bRead = dbHandle->getColumnToInt(index++);
2066 pTmp->bProtected = dbHandle->getColumnToInt(index++);
2067 pTmp->direction = dbHandle->getColumnToInt(index++);
2068 pTmp->bRestricted = dbHandle->getColumnToInt(index++);
2069 index++; /* This field is reserved. */
2071 dbHandle->getColumnToString(index++, MAX_SUBJECT_LEN, pTmp->subject);
2072 tmpText[i] = g_strdup(dbHandle->getColumnToString(index++));
2074 /*It does Not need to Get attach count in MSG_MESSAGE_TABLE. see MsgStoGetConversationPreview */
2075 /*pTmp->attachCount = dbHandle->getColumnToInt(index++); */
2078 if (pTmp->bRestricted == true) {
2080 memset(pTmp->subject, 0x00, sizeof(pTmp->subject));
2081 tmpText[i][0] = '\0';
2083 pTmp->simIndex = dbHandle->getColumnToInt(index++);
2085 dbHandle->freeTable();
2087 for (int i = 0; i < pConvViewList->nCount; i++) {
2088 conv = (msg_struct_s *)pConvViewList->msg_struct_info[i];
2089 pTmp = (MSG_CONVERSATION_VIEW_S *)conv->data;
2091 if (pTmp->mainType == MSG_MMS_TYPE &&
2092 (pTmp->networkStatus == MSG_NETWORK_RETRIEVING || pTmp->networkStatus == MSG_NETWORK_RETRIEVE_FAIL || pTmp->subType == MSG_NOTIFICATIONIND_MMS)) {
2096 if (pTmp->mainType == MSG_SMS_TYPE) {
2097 pTmp->pText = new char[pTmp->textSize+2];
2098 memset(pTmp->pText, 0x00, pTmp->textSize+2);
2099 snprintf(pTmp->pText, pTmp->textSize+1, "%s", tmpText[i]);
2100 } else if (pTmp->mainType == MSG_MMS_TYPE) {
2102 pTmp->textSize = strlen(tmpText[i]);
2104 pTmp->pText = new char[pTmp->textSize+1];
2105 memset(pTmp->pText, 0x00, pTmp->textSize+1);
2107 strncpy(pTmp->pText, tmpText[i], pTmp->textSize);
2110 MsgStoGetConversationPreview(dbHandle, pTmp);
2111 MsgStoGetConversationMultipart(dbHandle, pTmp);
2126 msg_error_t MsgStoSearchMessage(const char *pSearchString, msg_struct_list_s *pThreadViewList, int contactCount)
2129 return MSG_ERR_NULL_POINTER;
2131 MsgDbHandler *dbHandle = getDbHandle();
2132 dbHandle->connectReadOnly();
2133 char *escapeAddressStr = NULL;
2135 /* Clear Out Parameter */
2136 pThreadViewList->nCount = 0;
2137 pThreadViewList->msg_struct_info = NULL;
2139 tr1::unordered_set<msg_thread_id_t> IdList;
2140 queue<MSG_THREAD_VIEW_S> searchList;
2142 MSG_THREAD_VIEW_S threadView;
2144 char sqlQuery[MAX_QUERY_LEN+1];
2146 /* Search - Address, Name */
2147 memset(sqlQuery, 0x00, MAX_QUERY_LEN+1);
2148 snprintf(sqlQuery, MAX_QUERY_LEN, "SELECT A.CONV_ID, A.UNREAD_CNT, A.SMS_CNT, A.MMS_CNT, A.DISPLAY_NAME, "
2149 "A.MAIN_TYPE, A.SUB_TYPE, A.MSG_DIRECTION, A.DISPLAY_TIME, A.MSG_TEXT, "
2150 "(SELECT COUNT(*) FROM %s B WHERE B.CONV_ID = A.CONV_ID AND B.PROTECTED = 1) AS PROTECTED, "
2151 "(SELECT COUNT(*) FROM %s B WHERE B.MSG_ID = A.LAST_MSG_ID AND B.FOLDER_ID = %d) AS DRAFT, "
2152 "(SELECT COUNT(*) FROM %s B WHERE B.MSG_ID = A.LAST_MSG_ID AND B.NETWORK_STATUS = %d) AS FAILED, "
2153 "(SELECT COUNT(*) FROM %s B WHERE B.MSG_ID = A.LAST_MSG_ID AND B.NETWORK_STATUS = %d) AS SENDING "
2154 "FROM %s A WHERE (A.SMS_CNT > 0 OR A.MMS_CNT > 0) "
2156 "(SELECT DISTINCT(CONV_ID) FROM %s WHERE "
2157 "ADDRESS_VAL LIKE ? ESCAPE '%c' ",
2158 MSGFW_MESSAGE_TABLE_NAME,
2159 MSGFW_MESSAGE_TABLE_NAME, MSG_DRAFT_ID,
2160 MSGFW_MESSAGE_TABLE_NAME, MSG_NETWORK_SEND_FAIL,
2161 MSGFW_MESSAGE_TABLE_NAME, MSG_NETWORK_SENDING,
2162 MSGFW_CONVERSATION_TABLE_NAME,
2163 MSGFW_ADDRESS_TABLE_NAME,
2164 MSGFW_DB_ESCAPE_CHAR);
2166 unsigned int tmpSize = 0;
2167 if (contactCount > 0) {
2168 tmpSize = strlen(sqlQuery);
2169 snprintf(sqlQuery+tmpSize, MAX_QUERY_LEN-tmpSize,
2170 "OR ADDRESS_VAL IN (SELECT C.ADDRESS_VAL FROM %s C JOIN %s D ON (C.ADDRESS_VAL LIKE D.ADDRESS_VAL))"
2171 , MSGFW_ADDRESS_TABLE_NAME, MSGFW_ADDRESS_TEMP_TABLE_NAME);
2174 tmpSize = strlen(sqlQuery);
2175 snprintf(sqlQuery+tmpSize, MAX_QUERY_LEN-tmpSize,
2176 ") ORDER BY A.DISPLAY_TIME DESC;");
2178 MSG_DEBUG("sqlQuery=[%s]", sqlQuery);
2180 if (dbHandle->prepareQuery(sqlQuery) != MSG_SUCCESS) {
2181 MSG_DEBUG("Prepare query fail.");
2182 return MSG_ERR_DB_PREPARE;
2185 MsgConvertStrWithEscape(pSearchString, &escapeAddressStr);
2186 MSG_DEBUG("escapeAddressStr [%s]", escapeAddressStr);
2187 dbHandle->bindText(escapeAddressStr, 1);
2188 /*dbHandle->bindText(escapeAddressStr, 2); */
2189 /*dbHandle->bindText(escapeAddressStr, 3); */
2190 /*dbHandle->bindText(escapeAddressStr, 4); */
2192 while (dbHandle->stepQuery() == MSG_ERR_DB_ROW) {
2193 memset(&threadView, 0x00, sizeof(threadView));
2195 threadView.threadId = dbHandle->columnInt(0);
2196 threadView.unreadCnt = dbHandle->columnInt(1);
2197 threadView.smsCnt = dbHandle->columnInt(2);
2198 threadView.mmsCnt = dbHandle->columnInt(3);
2200 if (dbHandle->columnText(4))
2201 strncpy(threadView.threadName, (char *)dbHandle->columnText(4), MAX_THREAD_NAME_LEN);
2203 threadView.mainType = dbHandle->columnInt(5);
2204 threadView.subType = dbHandle->columnInt(6);
2206 threadView.direction = dbHandle->columnInt(7);
2207 threadView.threadTime = (time_t)dbHandle->columnInt(8);
2209 if (dbHandle->columnText(9))
2210 strncpy(threadView.threadData, (char *)dbHandle->columnText(9), MAX_THREAD_DATA_LEN);
2212 int protectedCnt = dbHandle->columnInt(10);
2213 if (protectedCnt > 0)
2214 threadView.bProtected = true;
2216 int draftCnt = dbHandle->columnInt(11);
2218 threadView.bDraft = true;
2220 int failedCnt = dbHandle->columnInt(12);
2222 threadView.bSendFailed = true;
2224 int sendingCnt = dbHandle->columnInt(13);
2226 threadView.bSending = true;
2228 tr1::unordered_set<msg_thread_id_t>::iterator it;
2230 it = IdList.find(threadView.threadId);
2232 if (it == IdList.end()) {
2233 IdList.insert(threadView.threadId);
2234 searchList.push(threadView);
2238 dbHandle->finalizeQuery();
2240 if (escapeAddressStr) {
2241 free(escapeAddressStr);
2242 escapeAddressStr = NULL;
2246 /* Add data to Out Parameter */
2247 pThreadViewList->nCount = searchList.size();
2248 pThreadViewList->msg_struct_info = (msg_struct_t *)calloc(searchList.size(), sizeof(msg_struct_t));
2249 if (pThreadViewList->msg_struct_info == NULL)
2250 return MSG_ERR_MEMORY_ERROR;
2252 MSG_THREAD_VIEW_S *pTmp = NULL;
2253 msg_struct_s *thread_t = NULL;
2257 while (!searchList.empty()) {
2258 thread_t = (msg_struct_s *)new msg_struct_s;
2259 pThreadViewList->msg_struct_info[index] = (msg_struct_t)thread_t;
2261 thread_t->type = MSG_STRUCT_THREAD_INFO;
2262 thread_t->data = new MSG_THREAD_VIEW_S;
2264 pTmp = (MSG_THREAD_VIEW_S *)thread_t->data;
2265 memset(pTmp, 0x00, sizeof(MSG_THREAD_VIEW_S));
2267 memcpy(pTmp, &(searchList.front()), sizeof(MSG_THREAD_VIEW_S));
2278 msg_error_t MsgStoGetRejectMsgList(const char *pNumber, msg_struct_list_s *pRejectMsgList)
2280 MsgDbHandler *dbHandle = getDbHandle();
2281 dbHandle->connectReadOnly();
2283 /* Clear Out Parameter */
2284 pRejectMsgList->nCount = 0;
2285 pRejectMsgList->msg_struct_info = NULL;
2287 int rowCnt = 0, index = 0;
2289 char sqlQuery[MAX_QUERY_LEN+1];
2291 /* Search Reject Msg */
2292 memset(sqlQuery, 0x00, sizeof(sqlQuery));
2294 if (pNumber != NULL) {
2295 int addrSize = strlen(pNumber);
2296 char phoneNumber[addrSize+1];
2297 memset(phoneNumber, 0x00, sizeof(phoneNumber));
2299 if (addrSize > MsgContactGetMinMatchDigit())
2300 MsgConvertNumber(pNumber, phoneNumber, addrSize);
2302 strncpy(phoneNumber, pNumber, addrSize);
2304 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT "
2309 "WHERE A.CONV_ID = B.CONV_ID "
2310 "AND B.MAIN_TYPE = %d "
2311 "AND B.SUB_TYPE = %d "
2312 "AND A.ADDRESS_VAL LIKE '%%%s' "
2313 "ORDER BY B.DISPLAY_TIME DESC;",
2314 MSGFW_ADDRESS_TABLE_NAME, MSGFW_MESSAGE_TABLE_NAME,
2319 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT "
2324 "WHERE A.CONV_ID = B.CONV_ID "
2325 "AND B.MAIN_TYPE = %d "
2326 "AND B.SUB_TYPE = %d "
2327 "ORDER BY B.DISPLAY_TIME DESC;",
2328 MSGFW_ADDRESS_TABLE_NAME, MSGFW_MESSAGE_TABLE_NAME,
2333 msg_error_t err = dbHandle->getTable(sqlQuery, &rowCnt, &index);
2335 if (err != MSG_SUCCESS) {
2336 MSG_DEBUG("Fail to getTable().");
2337 dbHandle->freeTable();
2341 pRejectMsgList->nCount = rowCnt;
2343 MSG_DEBUG("pRejectMsgList->nCount [%d]", pRejectMsgList->nCount);
2345 pRejectMsgList->msg_struct_info = (msg_struct_t *)calloc(rowCnt, sizeof(MSG_REJECT_MSG_INFO_S *));
2347 msg_struct_s* pTmp = NULL;
2349 for (int i = 0; i < rowCnt; i++) {
2350 pRejectMsgList->msg_struct_info[i] = (msg_struct_t)new msg_struct_s;
2352 pTmp = (msg_struct_s *)pRejectMsgList->msg_struct_info[i];
2353 pTmp->type = MSG_STRUCT_REJECT_MSG_INFO;
2354 pTmp->data = new MSG_REJECT_MSG_INFO_S;
2355 MSG_REJECT_MSG_INFO_S * pMsg = (MSG_REJECT_MSG_INFO_S *)pTmp->data;
2356 memset(pMsg, 0x00, sizeof(MSG_REJECT_MSG_INFO_S));
2358 pMsg->msgId = dbHandle->getColumnToInt(index++);
2359 memset(pMsg->msgText, 0x00, sizeof(pMsg->msgText));
2360 dbHandle->getColumnToString(index++, MAX_MSG_TEXT_LEN, pMsg->msgText);
2362 pMsg->displayTime = (time_t)dbHandle->getColumnToInt(index++);
2365 dbHandle->freeTable();
2371 msg_error_t MsgStoGetAddressList(const msg_thread_id_t threadId, msg_struct_list_s *pAddrList)
2373 MsgDbHandler *dbHandle = getDbHandle();
2374 dbHandle->connectReadOnly();
2376 msg_error_t err = MSG_SUCCESS;
2378 err = MsgStoGetAddressByConvId(dbHandle, threadId, pAddrList);
2384 msg_error_t MsgStoGetMessageList(const MSG_LIST_CONDITION_S *pListCond, msg_struct_list_s *pMsgList, int contactCount)
2386 MsgDbHandler *dbHandle = getDbHandle();
2387 dbHandle->connectReadOnly();
2389 /* Clear Out Parameter */
2390 pMsgList->nCount = 0;
2391 pMsgList->msg_struct_info = NULL;
2394 int multipartCnt = 0;
2396 char sqlQuery[MAX_QUERY_LEN+1];
2397 char sqlQuerySubset[(MAX_QUERY_LEN/5)+1];
2399 memset(sqlQuery, 0x00, sizeof(sqlQuery));
2400 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT COUNT(*) FROM %s;", MSGFW_MMS_MULTIPART_TABLE_NAME);
2402 if (dbHandle->prepareQuery(sqlQuery) != MSG_SUCCESS)
2403 return MSG_ERR_DB_PREPARE;
2405 if (dbHandle->stepQuery() == MSG_ERR_DB_ROW) {
2406 multipartCnt = dbHandle->columnInt(0);
2408 dbHandle->finalizeQuery();
2409 return MSG_ERR_DB_STEP;
2412 dbHandle->finalizeQuery();
2414 memset(sqlQuery, 0x00, sizeof(sqlQuery));
2415 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT DISTINCT "
2424 "A.NETWORK_STATUS, "
2430 "A.SCHEDULED_TIME, "
2433 "A.ATTACHMENT_COUNT, "
2437 "B.RECIPIENT_TYPE, "
2440 if (pListCond->pTextVal != NULL && multipartCnt > 0) {
2441 memset(sqlQuerySubset, 0x00, sizeof(sqlQuerySubset));
2442 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "FROM %s C, %s B, %s A WHERE A.CONV_ID > 0 AND A.CONV_ID = B.CONV_ID ",
2443 MSGFW_MMS_MULTIPART_TABLE_NAME, MSGFW_ADDRESS_TABLE_NAME, MSGFW_MESSAGE_TABLE_NAME);
2445 memset(sqlQuerySubset, 0x00, sizeof(sqlQuerySubset));
2446 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "FROM %s B, %s A WHERE A.CONV_ID > 0 AND A.CONV_ID = B.CONV_ID ",
2447 MSGFW_ADDRESS_TABLE_NAME, MSGFW_MESSAGE_TABLE_NAME);
2450 strncat(sqlQuery, sqlQuerySubset, MAX_QUERY_LEN-strlen(sqlQuery));
2452 memset(sqlQuerySubset, 0x00, sizeof(sqlQuerySubset));
2453 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "AND A.DPM_RESTRICTED = 0 ");
2454 strncat(sqlQuery, sqlQuerySubset, MAX_QUERY_LEN-strlen(sqlQuery));
2457 memset(sqlQuerySubset, 0x00, sizeof(sqlQuerySubset));
2459 if (pListCond->folderId == MSG_ALLBOX_ID)
2460 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "AND A.FOLDER_ID > 0 AND A.FOLDER_ID < %d ", MSG_SPAMBOX_ID);
2461 else if (pListCond->folderId == MSG_IOSBOX_ID)
2462 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "AND A.FOLDER_ID > 0 AND A.FOLDER_ID < %d ", MSG_DRAFT_ID);
2464 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "AND A.FOLDER_ID = %d ", pListCond->folderId);
2466 strncat(sqlQuery, sqlQuerySubset, MAX_QUERY_LEN-strlen(sqlQuery));
2470 if (pListCond->threadId > 0) {
2471 memset(sqlQuerySubset, 0x00, sizeof(sqlQuerySubset));
2472 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "AND A.CONV_ID = %d ", pListCond->threadId);
2473 strncat(sqlQuery, sqlQuerySubset, MAX_QUERY_LEN-strlen(sqlQuery));
2478 memset(sqlQuerySubset, 0x00, sizeof(sqlQuerySubset));
2480 switch (pListCond->msgType) {
2482 if (pListCond->pAddressVal == NULL)
2483 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "AND A.MAIN_TYPE = %d ", MSG_SMS_TYPE);
2485 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "AND A.MAIN_TYPE = %d AND A.SUB_TYPE = %d ", MSG_SMS_TYPE, MSG_NORMAL_SMS);
2489 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "AND A.MAIN_TYPE = %d ", MSG_MMS_TYPE);
2492 case MSG_TYPE_MMS_JAVA:
2493 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "AND A.MAIN_TYPE = %d AND A.SUB_TYPE = %d ", MSG_MMS_TYPE, MSG_SENDREQ_JAVA_MMS);
2496 case MSG_TYPE_SMS_SYNCML:
2497 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "AND A.MAIN_TYPE = %d AND A.SUB_TYPE = %d ", MSG_SMS_TYPE, MSG_SYNCML_CP);
2499 case MSG_TYPE_SMS_REJECT:
2500 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "AND A.MAIN_TYPE = %d AND A.SUB_TYPE = %d ", MSG_SMS_TYPE, MSG_REJECT_SMS);
2504 MSG_DEBUG("msg type is not set.");
2508 strncat(sqlQuery, sqlQuerySubset, MAX_QUERY_LEN-strlen(sqlQuery));
2512 if (pListCond->storageId > MSG_STORAGE_UNKNOWN) {
2513 memset(sqlQuerySubset, 0x00, sizeof(sqlQuerySubset));
2514 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "AND A.STORAGE_ID = %d ", pListCond->storageId);
2515 strncat(sqlQuery, sqlQuerySubset, MAX_QUERY_LEN-strlen(sqlQuery));
2520 if (pListCond->bProtected) {
2521 memset(sqlQuerySubset, 0x00, sizeof(sqlQuerySubset));
2522 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "AND A.PROTECTED = %d ", pListCond->bProtected);
2523 strncat(sqlQuery, sqlQuerySubset, MAX_QUERY_LEN-strlen(sqlQuery));
2528 if (pListCond->bScheduled) {
2529 memset(sqlQuerySubset, 0x00, sizeof(sqlQuerySubset));
2530 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "AND A.SCHEDULED_TIME > 0 ");
2531 strncat(sqlQuery, sqlQuerySubset, MAX_QUERY_LEN-strlen(sqlQuery));
2536 if (pListCond->simIndex > 0) {
2537 memset(sqlQuerySubset, 0x00, sizeof(sqlQuerySubset));
2538 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "AND A.SIM_INDEX = %d ", pListCond->simIndex);
2539 strncat(sqlQuery, sqlQuerySubset, MAX_QUERY_LEN-strlen(sqlQuery));
2544 if (pListCond->fromTime > 0) {
2545 memset(sqlQuerySubset, 0x00, sizeof(sqlQuerySubset));
2546 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "AND A.DISPLAY_TIME >= %u ", (unsigned int)pListCond->fromTime);
2547 strncat(sqlQuery, sqlQuerySubset, MAX_QUERY_LEN-strlen(sqlQuery));
2550 if (pListCond->toTime > 0) {
2551 memset(sqlQuerySubset, 0x00, sizeof(sqlQuerySubset));
2552 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "AND A.DISPLAY_TIME <= %u ", (unsigned int)pListCond->toTime);
2553 strncat(sqlQuery, sqlQuerySubset, MAX_QUERY_LEN-strlen(sqlQuery));
2556 if (pListCond->pAddressVal == NULL) {
2558 if (pListCond->pTextVal != NULL) {
2559 memset(sqlQuerySubset, 0x00, sizeof(sqlQuerySubset));
2560 if (multipartCnt > 0) {
2561 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset),
2562 "AND ((A.MSG_TEXT LIKE ? ESCAPE '%c' OR A.SUBJECT LIKE ? ESCAPE '%c' OR (C.TEXT LIKE ? ESCAPE '%c' AND A.MSG_ID = C.MSG_ID AND C.CONTENT_TYPE = 'text/plain'))) ",
2563 MSGFW_DB_ESCAPE_CHAR, MSGFW_DB_ESCAPE_CHAR, MSGFW_DB_ESCAPE_CHAR);
2565 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset),
2566 "AND ((A.MSG_TEXT LIKE ? ESCAPE '%c' OR A.SUBJECT LIKE ? ESCAPE '%c')) ",
2567 MSGFW_DB_ESCAPE_CHAR, MSGFW_DB_ESCAPE_CHAR);
2569 strncat(sqlQuery, sqlQuerySubset, MAX_QUERY_LEN-strlen(sqlQuery));
2573 if (pListCond->pTextVal != NULL) {
2574 memset(sqlQuerySubset, 0x00, sizeof(sqlQuerySubset));
2575 if (multipartCnt > 0) {
2576 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset),
2577 "AND ((A.MSG_TEXT LIKE ? ESCAPE '%c' OR A.SUBJECT LIKE ? ESCAPE '%c' OR (C.TEXT LIKE ? ESCAPE '%c' AND A.MSG_ID = C.MSG_ID AND C.CONTENT_TYPE = 'text/plain')) ",
2578 MSGFW_DB_ESCAPE_CHAR, MSGFW_DB_ESCAPE_CHAR, MSGFW_DB_ESCAPE_CHAR);
2580 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset),
2581 "AND ((A.MSG_TEXT LIKE ? ESCAPE '%c' OR A.SUBJECT LIKE ? ESCAPE '%c') ",
2582 MSGFW_DB_ESCAPE_CHAR, MSGFW_DB_ESCAPE_CHAR);
2584 strncat(sqlQuery, sqlQuerySubset, MAX_QUERY_LEN-strlen(sqlQuery));
2586 memset(sqlQuerySubset, 0x00, sizeof(sqlQuerySubset));
2587 if (pListCond->bAnd) {
2588 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "AND ");
2590 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "OR ");
2592 strncat(sqlQuery, sqlQuerySubset, MAX_QUERY_LEN-strlen(sqlQuery));
2595 memset(sqlQuerySubset, 0x00, sizeof(sqlQuerySubset));
2596 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset),
2597 "(B.ADDRESS_VAL LIKE ? ESCAPE '%c' ", MSGFW_DB_ESCAPE_CHAR);
2598 strncat(sqlQuery, sqlQuerySubset, MAX_QUERY_LEN-strlen(sqlQuery));
2600 if (contactCount > 0) {
2601 memset(sqlQuerySubset, 0x00, sizeof(sqlQuerySubset));
2602 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset),
2603 "OR B.ADDRESS_VAL IN (SELECT D.ADDRESS_VAL FROM %s D JOIN %s E ON (D.ADDRESS_VAL LIKE E.ADDRESS_VAL)) "
2604 , MSGFW_ADDRESS_TABLE_NAME, MSGFW_ADDRESS_TEMP_TABLE_NAME);
2605 strncat(sqlQuery, sqlQuerySubset, MAX_QUERY_LEN-strlen(sqlQuery));
2608 memset(sqlQuerySubset, 0x00, sizeof(sqlQuerySubset));
2609 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), ")) ");
2610 strncat(sqlQuery, sqlQuerySubset, MAX_QUERY_LEN-strlen(sqlQuery));
2613 memset(sqlQuerySubset, 0x00, sizeof(sqlQuerySubset));
2614 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset),
2615 "AND (B.ADDRESS_VAL LIKE ? ESCAPE '%c' ", MSGFW_DB_ESCAPE_CHAR);
2616 strncat(sqlQuery, sqlQuerySubset, MAX_QUERY_LEN-strlen(sqlQuery));
2618 if (contactCount > 0) {
2619 memset(sqlQuerySubset, 0x00, sizeof(sqlQuerySubset));
2620 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset),
2621 "OR B.ADDRESS_VAL IN (SELECT D.ADDRESS_VAL FROM %s D JOIN %s E ON (D.ADDRESS_VAL LIKE E.ADDRESS_VAL)) "
2622 , MSGFW_ADDRESS_TABLE_NAME, MSGFW_ADDRESS_TEMP_TABLE_NAME);
2623 strncat(sqlQuery, sqlQuerySubset, MAX_QUERY_LEN-strlen(sqlQuery));
2626 memset(sqlQuerySubset, 0x00, sizeof(sqlQuerySubset));
2627 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), ") ");
2628 strncat(sqlQuery, sqlQuerySubset, MAX_QUERY_LEN-strlen(sqlQuery));
2632 msg_struct_s *pSortRule = (msg_struct_s *)pListCond->sortRule;
2634 if (pSortRule->type != MSG_STRUCT_SORT_RULE) {
2636 memset(sqlQuerySubset, 0x00, sizeof(sqlQuerySubset));
2637 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "ORDER BY A.DISPLAY_TIME ");
2639 strncat(sqlQuery, sqlQuerySubset, MAX_QUERY_LEN-strlen(sqlQuery));
2642 memset(sqlQuerySubset, 0x00, sizeof(sqlQuerySubset));
2643 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "DESC ");
2645 strncat(sqlQuery, sqlQuerySubset, MAX_QUERY_LEN-strlen(sqlQuery));
2647 MSG_SORT_RULE_S *pTmp = (MSG_SORT_RULE_S *)pSortRule->data;
2648 /* order : TODO: have to finish this */
2649 memset(sqlQuerySubset, 0x00, sizeof(sqlQuerySubset));
2650 switch (pTmp->sortType) {
2651 case MSG_SORT_BY_MSG_TYPE:
2652 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "ORDER BY A.MAIN_TYPE ");
2654 case MSG_SORT_BY_READ_STATUS:
2655 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "ORDER BY A.READ_STATUS ");
2657 case MSG_SORT_BY_STORAGE_TYPE:
2658 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "ORDER BY A.STORAGE_ID ");
2661 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "ORDER BY A.DISPLAY_TIME ");
2664 strncat(sqlQuery, sqlQuerySubset, MAX_QUERY_LEN-strlen(sqlQuery));
2667 memset(sqlQuerySubset, 0x00, sizeof(sqlQuerySubset));
2668 if (pTmp->bAscending)
2669 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "ASC ");
2671 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "DESC ");
2673 strncat(sqlQuery, sqlQuerySubset, MAX_QUERY_LEN-strlen(sqlQuery));
2676 /* offset & limit */
2677 memset(sqlQuerySubset, 0x00, sizeof(sqlQuerySubset));
2678 if (pListCond->offset >= 0 && pListCond->limit > 0)
2679 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "LIMIT %d OFFSET %d;", pListCond->limit, pListCond->offset);
2681 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), ";");
2683 strncat(sqlQuery, sqlQuerySubset, MAX_QUERY_LEN-strlen(sqlQuery));
2686 /* 'til here sqlQuery is complete. */
2688 queue<MSG_MESSAGE_HIDDEN_S*> searchList;
2690 MSG_DEBUG("[%s]", sqlQuery);
2692 if (dbHandle->prepareQuery(sqlQuery) != MSG_SUCCESS) {
2693 MSG_DEBUG("Prepare query fail.");
2694 return MSG_ERR_DB_PREPARE;
2697 char *escapeTextStr = NULL;
2698 char *escapeAddressStr = NULL;
2700 if (pListCond->pAddressVal == NULL) {
2702 if (pListCond->pTextVal != NULL) {
2703 MsgConvertStrWithEscape(pListCond->pTextVal, &escapeTextStr);
2704 MSG_DEBUG("escapeTextStr [%s]", escapeTextStr);
2705 dbHandle->bindText(escapeTextStr, 1);
2706 dbHandle->bindText(escapeTextStr, 2);
2707 if (multipartCnt > 0) dbHandle->bindText(escapeTextStr, 3);
2711 if (pListCond->pTextVal != NULL) {
2712 MsgConvertStrWithEscape(pListCond->pTextVal, &escapeTextStr);
2713 MSG_DEBUG("escapeTestStr [%s]", escapeTextStr);
2716 MsgConvertStrWithEscape(pListCond->pAddressVal, &escapeAddressStr);
2717 MSG_DEBUG("escapeAddressStr [%s]", escapeAddressStr);
2719 dbHandle->bindText(escapeTextStr, 1);
2720 dbHandle->bindText(escapeTextStr, 2);
2721 if (multipartCnt > 0) {
2722 dbHandle->bindText(escapeTextStr, 3);
2723 dbHandle->bindText(escapeAddressStr, 4);
2725 dbHandle->bindText(escapeAddressStr, 3);
2730 MsgConvertStrWithEscape(pListCond->pAddressVal, &escapeAddressStr);
2731 MSG_DEBUG("escapeAddressStr [%s]", escapeAddressStr);
2732 dbHandle->bindText(escapeAddressStr, 1);
2737 MSG_MESSAGE_HIDDEN_S *pTmp = NULL;
2738 int lastMsgId = 0; /* for comparing same msg id. */
2740 while (dbHandle->stepQuery() == MSG_ERR_DB_ROW) {
2743 int msgid = dbHandle->columnInt(index++);
2744 MSG_DEBUG("msgid [%d]", msgid);
2746 if (lastMsgId != msgid) {
2747 MSG_DEBUG("lastMsgId != msgid");
2751 pTmp = new MSG_MESSAGE_HIDDEN_S;
2754 memset(pTmp, 0x00, sizeof(MSG_MESSAGE_HIDDEN_S));
2757 pTmp->pMmsData = NULL;
2758 pTmp->addressList = NULL;
2760 pTmp->msgId = msgid;
2762 pTmp->threadId = dbHandle->columnInt(index++);
2763 pTmp->folderId = dbHandle->columnInt(index++);
2764 pTmp->storageId = dbHandle->columnInt(index++);
2765 pTmp->mainType = dbHandle->columnInt(index++);
2766 pTmp->subType = dbHandle->columnInt(index++);
2767 pTmp->displayTime = (time_t)dbHandle->columnInt(index++);
2768 pTmp->dataSize = dbHandle->columnInt(index++);
2769 pTmp->networkStatus = dbHandle->columnInt(index++);
2770 pTmp->bRead = dbHandle->columnInt(index++);
2771 pTmp->bProtected = dbHandle->columnInt(index++);
2772 pTmp->bBackup = dbHandle->columnInt(index++);
2773 pTmp->priority = dbHandle->columnInt(index++);
2774 pTmp->direction = dbHandle->columnInt(index++);
2775 index++; /* This field is reserved. */
2777 strncpy(pTmp->subject, (char *)dbHandle->columnText(index++), MAX_SUBJECT_LEN);
2779 if (pTmp->mainType == MSG_MMS_TYPE &&
2780 (pTmp->networkStatus == MSG_NETWORK_RETRIEVING || pTmp->networkStatus == MSG_NETWORK_RETRIEVE_FAIL || pTmp->subType == MSG_NOTIFICATIONIND_MMS)) {
2784 pTmp->pData = (void *)new char[pTmp->dataSize+2];
2785 memset(pTmp->pData, 0x00, pTmp->dataSize+2);
2787 strncpy((char *)pTmp->pData, (char *)dbHandle->columnText(index++), pTmp->dataSize+1);
2790 pTmp->attachCount = dbHandle->columnInt(index++);
2792 strncpy(pTmp->thumbPath, (char *)dbHandle->columnText(index++), MSG_FILEPATH_LEN_MAX);
2794 pTmp->simIndex = dbHandle->columnInt(index++);
2796 pTmp->addr_list = (msg_struct_list_s *)new msg_struct_list_s;
2797 pTmp->addr_list->nCount = 0;
2798 pTmp->addr_list->msg_struct_info = (msg_struct_t *)calloc(MAX_TO_ADDRESS_CNT, sizeof(msg_struct_t));
2799 for (int i = 0; i < MAX_TO_ADDRESS_CNT; i++) {
2800 pTmp->addr_list->msg_struct_info[i] = (msg_struct_t)new msg_struct_s;
2801 memset(pTmp->addr_list->msg_struct_info[i], 0x00, sizeof(msg_struct_s));
2804 searchList.push(pTmp);
2808 MSG_DEBUG("lastMsgId == msgid");
2813 MSG_ADDRESS_INFO_S *pAddr = new MSG_ADDRESS_INFO_S;
2814 memset(pAddr, 0x00, sizeof(MSG_ADDRESS_INFO_S));
2816 pAddr->addressType = dbHandle->columnInt(index++);
2817 pAddr->recipientType = dbHandle->columnInt(index++);
2819 strncpy(pAddr->addressVal, (char *)dbHandle->columnText(index++), MAX_ADDRESS_VAL_LEN);
2821 strncpy(pAddr->displayName, pAddr->addressVal, MAX_DISPLAY_NAME_LEN);
2823 /* For GList *addressList */
2824 msg_struct_s *addr_info_s = new msg_struct_s;
2825 memset(addr_info_s, 0x00, sizeof(msg_struct_s));
2826 addr_info_s->type = MSG_STRUCT_ADDRESS_INFO;
2827 addr_info_s->data = new MSG_ADDRESS_INFO_S;
2828 memset(addr_info_s->data, 0x00, sizeof(MSG_ADDRESS_INFO_S));
2829 MSG_ADDRESS_INFO_S *addr_info = (MSG_ADDRESS_INFO_S *)addr_info_s->data;
2830 addr_info->addressType = pAddr->addressType;
2831 addr_info->recipientType = pAddr->recipientType;
2832 addr_info->contactId = pAddr->contactId;
2833 strncpy(addr_info->addressVal, pAddr->addressVal, MAX_ADDRESS_VAL_LEN);
2834 strncpy(addr_info->displayName, pAddr->displayName, MAX_DISPLAY_NAME_LEN);
2835 addr_info->displayName[MAX_DISPLAY_NAME_LEN] = '\0';
2837 pTmp->addressList = g_list_append(pTmp->addressList, addr_info_s);
2839 if (pTmp->addr_list->nCount >= MAX_TO_ADDRESS_CNT) {
2843 msg_struct_s *pStruct = (msg_struct_s *)pTmp->addr_list->msg_struct_info[pTmp->addr_list->nCount];
2844 pTmp->addr_list->nCount++;
2845 pStruct->type = MSG_STRUCT_ADDRESS_INFO;
2846 pStruct->data = pAddr;
2851 dbHandle->finalizeQuery();
2853 pMsgList->nCount = searchList.size();
2854 MSG_DEBUG("pMsgList->nCount [%d]", pMsgList->nCount);
2856 pMsgList->msg_struct_info = (msg_struct_t *)calloc(pMsgList->nCount, sizeof(msg_struct_t));
2857 if (pMsgList->msg_struct_info == NULL)
2858 return MSG_ERR_MEMORY_ERROR;
2861 while (!searchList.empty()) {
2862 msg_struct_s *msg = new msg_struct_s;
2864 pMsgList->msg_struct_info[offset++] = (msg_struct_t)msg;
2866 msg->type = MSG_STRUCT_MESSAGE_INFO;
2867 msg->data = searchList.front();
2874 free(escapeTextStr);
2876 if (escapeAddressStr)
2877 free(escapeAddressStr);
2883 msg_error_t MsgStoGetMediaList(const msg_thread_id_t threadId, msg_list_handle_t *pMediaList)
2886 msg_error_t err = MSG_SUCCESS;
2887 MsgDbHandler *dbHandle = getDbHandle();
2888 dbHandle->connectReadOnly();
2889 char sqlQuery[MAX_QUERY_LEN+1];
2892 memset(sqlQuery, 0x00, sizeof(sqlQuery));
2893 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT MSG_ID FROM %s WHERE MAIN_TYPE = %d AND DPM_RESTRICTED = 0 AND CONV_ID = %d;",
2894 MSGFW_MESSAGE_TABLE_NAME, MSG_MMS_TYPE, threadId);
2896 MSG_DEBUG("sqlQuery = [%s]", sqlQuery);
2898 err = dbHandle->getTable(sqlQuery, &msgIdCnt, NULL);
2899 if (err != MSG_SUCCESS && err != MSG_ERR_DB_NORECORD) {
2900 dbHandle->freeTable();
2902 } else if (err == MSG_ERR_DB_NORECORD) {
2903 dbHandle->freeTable();
2907 msg_message_id_t msgIds[msgIdCnt];
2909 for (int i = 1; i <= msgIdCnt; i++) {
2910 msgIds[i-1] = dbHandle->getColumnToInt(i);
2913 dbHandle->freeTable();
2915 GList *media_list = NULL;
2917 for (int i = 0; i < msgIdCnt; i++) {
2918 memset(sqlQuery, 0x00, sizeof(sqlQuery));
2919 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT MSG_ID, CONTENT_TYPE, FILE_PATH, THUMB_FILE_PATH "
2920 "FROM %s WHERE MSG_ID = %d AND SEQ <> -1 AND (TCS_LEVEL = -1 OR MALWARE_ALLOW = 1);",
2921 MSGFW_MMS_MULTIPART_TABLE_NAME, msgIds[i]);
2923 int rowCnt = 0, msg_id = 0, index = 0;
2925 err = dbHandle->getTable(sqlQuery, &rowCnt, &index);
2927 if (err != MSG_SUCCESS && err != MSG_ERR_DB_NORECORD) {
2928 dbHandle->freeTable();
2932 MSG_MEDIA_INFO_S *pMedia = NULL;
2933 char mime_type[MAX_MIME_TYPE_LEN+1], media_item[MSG_FILEPATH_LEN_MAX+1], thumb_path[MSG_FILEPATH_LEN_MAX+1];
2935 for (int j = 0; j < rowCnt; j++) {
2936 msg_id = dbHandle->getColumnToInt(index++);
2937 memset(mime_type, 0x00, sizeof(mime_type));
2938 dbHandle->getColumnToString(index++, MAX_MIME_TYPE_LEN, mime_type);
2939 memset(media_item, 0x00, sizeof(media_item));
2940 dbHandle->getColumnToString(index++, MSG_FILEPATH_LEN_MAX, media_item);
2941 memset(thumb_path, 0x00, sizeof(thumb_path));
2942 dbHandle->getColumnToString(index++, MSG_FILEPATH_LEN_MAX, thumb_path);
2944 if (strstr(mime_type, "image") || strstr(mime_type, "video")) {
2945 msg_struct_s *media_struct_s = new msg_struct_s;
2946 media_struct_s->type = MSG_STRUCT_MEDIA_INFO;
2947 media_struct_s->data = new MSG_MEDIA_INFO_S;
2948 memset(media_struct_s->data, 0x00, sizeof(MSG_MEDIA_INFO_S));
2950 pMedia = (MSG_MEDIA_INFO_S *)media_struct_s->data;
2952 pMedia->msg_id = msg_id;
2953 snprintf(pMedia->mime_type, MAX_MIME_TYPE_LEN, "%s", mime_type);
2954 snprintf(pMedia->media_item, MSG_FILEPATH_LEN_MAX, "%s", media_item);
2955 snprintf(pMedia->thumb_path, MSG_FILEPATH_LEN_MAX, "%s", thumb_path);
2957 media_list = g_list_append(media_list, media_struct_s);
2961 dbHandle->freeTable();
2963 *pMediaList = (msg_list_handle_t)media_list;
2971 msg_error_t MsgStoDbSelectWithQuery(const char *szQuery, char ***db_res, int *row_count, int *col_count)
2975 msg_error_t err = MSG_SUCCESS;
2977 MsgDbHandler *dbHandle = getDbHandle();
2978 err = dbHandle->connectReadOnly();
2979 if (err != MSG_SUCCESS) {
2980 MSG_ERR("db connect (read only) is failed [%d]", err);
2984 char *zSQL = sqlite3_mprintf("SELECT %q;", szQuery);
2987 err = dbHandle->getTableWithResult((const char *)zSQL, db_res, row_count, col_count);
2991 THROW(MsgException::INVALID_RESULT, "sqlite3_mprintf() is failed");
2994 MSG_DEBUG("getTableWithResult :: row_count=[%d], col_count=[%d]", *row_count, *col_count);
2996 if (err == MSG_ERR_DB_NORECORD) {
2997 dbHandle->freeTable(*db_res);
3000 } else if (err != MSG_SUCCESS) {
3001 MSG_DEBUG("Fail to getTable().");
3002 dbHandle->freeTable(*db_res);
3010 void MsgStoDbFree(char **db_res)
3012 MsgDbHandler *dbHandle = getDbHandle();
3013 dbHandle->freeTable(db_res);
3017 #ifdef FEATURE_SMS_CDMA
3018 msg_error_t MsgStoClearUniquenessTable()
3022 msg_error_t err = MSG_SUCCESS;
3024 MsgDbHandler *dbHandle = getDbHandle();
3026 char sqlQuery[MAX_QUERY_LEN+1] = {0, };
3027 snprintf(sqlQuery, sizeof(sqlQuery), "DELETE FROM %s WHERE MSG_ID = 0", MSGFW_UNIQUENESS_INFO_TABLE_NAME);
3029 err = dbHandle->execQuery(sqlQuery);