utils/MsgUtilStorage.cpp

   1 /*
   2 * Copyright 2012  Samsung Electronics Co., Ltd
   3 *
   4 * Licensed under the Flora License, Version 1.0 (the "License");
   5 * you may not use this file except in compliance with the License.
   6 * You may obtain a copy of the License at
   7 *
   8 *    http://www.tizenopensource.org/license
   9 *
  10 * Unless required by applicable law or agreed to in writing, software
  11 * distributed under the License is distributed on an "AS IS" BASIS,
  12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 * See the License for the specific language governing permissions and
  14 * limitations under the License.
  15 */
  16
  17 #include "MsgDebug.h"
  18 #include "MsgUtilFile.h"
  19 #include "MsgContact.h"
  20 #include "MsgCppTypes.h"
  21 #include "MsgGconfWrapper.h"
  22 #include "MsgNotificationWrapper.h"
  23 #include "MsgUtilStorage.h"
  24
  25 #include <sys/stat.h>
  26 #include <sys/vfs.h>
  27
  28
  29 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}};
  30
  31
  32 /*==================================================================================================
  33                                      FUNCTION IMPLEMENTATION
  34 ==================================================================================================*/
  35 unsigned int MsgStoAddMessageTable(MsgDbHandler *pDbHandle, const MSG_MESSAGE_INFO_S *pMsgInfo)
  36 {
  37         MSG_BEGIN();
  38
  39         msg_error_t err = MSG_SUCCESS;
  40
  41         msg_message_id_t msgId = 0;
  42
  43         err = pDbHandle->getRowId(MSGFW_MESSAGE_TABLE_NAME, &msgId);
  44
  45         if (err != MSG_SUCCESS)
  46                 return 0;
  47
  48         int fileSize = 0;
  49
  50         char* pFileData = NULL;
  51         AutoPtr<char> buf(&pFileData);
  52
  53         // Get File Data
  54         if (pMsgInfo->bTextSms == false) {
  55                 if (MsgOpenAndReadFile(pMsgInfo->msgData, &pFileData, &fileSize) == false)
  56                         return 0;
  57
  58                 MSG_DEBUG("file size [%d]", fileSize);
  59         }
  60
  61         // Add Message
  62         char sqlQuery[MAX_QUERY_LEN+1];
  63
  64         memset(sqlQuery, 0x00, sizeof(sqlQuery));
  65
  66         snprintf(sqlQuery, sizeof(sqlQuery), "INSERT INTO %s VALUES (%d, %d, %d, %d, %d, %d, %ld, %d, %d, %d, %d, %d, %d, %ld, %d, ?, ?, ?, ?, 0);",
  67                         MSGFW_MESSAGE_TABLE_NAME, msgId, pMsgInfo->threadId, pMsgInfo->folderId, pMsgInfo->storageId, pMsgInfo->msgType.mainType,
  68                         pMsgInfo->msgType.subType, pMsgInfo->displayTime, pMsgInfo->dataSize, pMsgInfo->networkStatus, pMsgInfo->bRead, pMsgInfo->bProtected,
  69                         pMsgInfo->priority, pMsgInfo->direction, 0, pMsgInfo->bBackup);
  70
  71         MSG_DEBUG("QUERY : %s", sqlQuery);
  72
  73         if (pDbHandle->prepareQuery(sqlQuery) != MSG_SUCCESS)
  74                 return 0;
  75
  76         pDbHandle->bindText(pMsgInfo->subject, 1);
  77
  78         pDbHandle->bindText(pMsgInfo->msgData, 2);
  79
  80         pDbHandle->bindText(pMsgInfo->thumbPath, 3);
  81
  82         if (pMsgInfo->bTextSms == false)
  83                 pDbHandle->bindText(pFileData, 4);
  84         else
  85                 pDbHandle->bindText(pMsgInfo->msgText, 4);
  86
  87         if (pDbHandle->stepQuery() != MSG_ERR_DB_DONE) {
  88                 pDbHandle->finalizeQuery();
  89                 return 0;
  90         }
  91
  92         pDbHandle->finalizeQuery();
  93
  94         return msgId;
  95 }
  96
  97
  98 msg_error_t MsgStoSetReadStatus(MsgDbHandler *pDbHandle, msg_message_id_t msgId, bool bRead)
  99 {
 100         char sqlQuery[MAX_QUERY_LEN+1];
 101
 102         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 103         snprintf(sqlQuery, sizeof(sqlQuery), "UPDATE %s SET READ_STATUS = %d WHERE MSG_ID = %d;",
 104                         MSGFW_MESSAGE_TABLE_NAME, (int)bRead, msgId);
 105
 106         if (pDbHandle->execQuery(sqlQuery) != MSG_SUCCESS)
 107                 return MSG_ERR_DB_EXEC;
 108
 109         // Get MAIN_TYPE, SUB_TYPE, STORAGE_ID
 110         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 111         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT A.MAIN_TYPE, A.SUB_TYPE, B.CONV_ID \
 112                         FROM %s A, %s B WHERE A.MSG_ID = %d AND A.CONV_ID = B.CONV_ID;",
 113                         MSGFW_MESSAGE_TABLE_NAME, MSGFW_CONVERSATION_TABLE_NAME, msgId);
 114
 115         if (pDbHandle->prepareQuery(sqlQuery) != MSG_SUCCESS)
 116                 return MSG_ERR_DB_PREPARE;
 117
 118         MSG_MESSAGE_TYPE_S msgType;
 119         msg_thread_id_t convId;
 120
 121         if (pDbHandle->stepQuery() == MSG_ERR_DB_ROW) {
 122                 msgType.mainType = pDbHandle->columnInt(0);
 123                 msgType.subType = pDbHandle->columnInt(1);
 124                 convId = pDbHandle->columnInt(2);
 125         } else {
 126                 pDbHandle->finalizeQuery();
 127                 return MSG_ERR_DB_STEP;
 128         }
 129
 130         pDbHandle->finalizeQuery();
 131
 132         MSG_DEBUG("Main Type:[%d] SubType:[%d] ConvId:[%d]", msgType.mainType, msgType.subType, convId);
 133
 134         if (MsgStoUpdateConversation(pDbHandle, convId) != MSG_SUCCESS) {
 135                 MSG_DEBUG("MsgStoUpdateConversation() Error");
 136                 return MSG_ERR_STORAGE_ERROR;
 137         }
 138
 139         int smsCnt = 0, mmsCnt = 0;
 140
 141         smsCnt = MsgStoGetUnreadCnt(pDbHandle, MSG_SMS_TYPE);
 142         mmsCnt = MsgStoGetUnreadCnt(pDbHandle, MSG_MMS_TYPE);
 143
 144         MsgSettingSetIndicator(smsCnt, mmsCnt);
 145
 146 //      MsgDeleteNotiByMsgId(msgId);
 147         MsgRefreshNoti();
 148
 149         return MSG_SUCCESS;
 150 }
 151
 152
 153 msg_error_t MsgStoGetOldestMessage(MsgDbHandler *pDbHandle, const MSG_MESSAGE_INFO_S *pMsgInfo, msg_message_id_t *pMsgId)
 154 {
 155         char sqlQuery[MAX_QUERY_LEN+1];
 156
 157         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 158
 159         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT MSG_ID FROM %s \
 160                         WHERE SUB_TYPE = %d AND FOLDER_ID = %d AND STORAGE_ID = %d AND PROTECTED = 0 \
 161                         ORDER BY DISPLAY_TIME ASC",
 162                         MSGFW_MESSAGE_TABLE_NAME, pMsgInfo->msgType.subType, pMsgInfo->folderId, MSG_STORAGE_PHONE);
 163
 164         if (pDbHandle->prepareQuery(sqlQuery) != MSG_SUCCESS)
 165                 return MSG_ERR_DB_PREPARE;
 166
 167         if (pDbHandle->stepQuery() == MSG_ERR_DB_ROW) {
 168                 *pMsgId = pDbHandle->columnInt(0);
 169         } else {
 170                 pDbHandle->finalizeQuery();
 171                 return MSG_ERR_DB_STEP;
 172         }
 173
 174         pDbHandle->finalizeQuery();
 175
 176         return MSG_SUCCESS;
 177 }
 178
 179
 180 msg_error_t MsgStoCheckMsgCntFull(MsgDbHandler *pDbHandle, const MSG_MESSAGE_TYPE_S* pMsgType, msg_folder_id_t folderId)
 181 {
 182         MSG_BEGIN();
 183
 184         msg_error_t err = MSG_SUCCESS;
 185                 struct statfs buf = {0};
 186
 187                 if (statfs(MSG_DATA_ROOT_PATH, &buf) == -1) {
 188                         MSG_DEBUG("statfs(\"%s\") failed - %d", MSG_DATA_ROOT_PATH);
 189                         return MSG_ERR_STORAGE_ERROR;
 190                 }
 191
 192                 unsigned long freeSpace = (buf.f_bfree * buf.f_bsize);
 193
 194                 MSG_DEBUG("f_bfree [%d] f_bsize [%d]", buf.f_bfree, buf.f_bsize);
 195                 MSG_DEBUG("Free space of storage is [%ul] MB.", freeSpace);
 196
 197                 if (freeSpace < SMS_MINIMUM_SPACE && pMsgType->mainType == MSG_SMS_TYPE)
 198                         err = MSG_ERR_MESSAGE_COUNT_FULL;
 199                 else if(freeSpace < MMS_MINIMUM_SPACE && pMsgType->mainType == MSG_MMS_TYPE)
 200                         err = MSG_ERR_MESSAGE_COUNT_FULL;
 201
 202         MSG_END();
 203
 204         return err;
 205 }
 206
 207
 208 msg_error_t MsgStoCountMsgByLimitCategory(MsgDbHandler *pDbHandle, const MSG_MESSAGE_TYPE_S *pMsgType, int *pMsgCount, msg_folder_id_t folderId)
 209 {
 210         if (pMsgType == NULL) {
 211                 MSG_DEBUG("pMsgType is NULL");
 212                 return MSG_ERR_NULL_POINTER;
 213         }
 214
 215         *pMsgCount = 0;
 216
 217         char sqlQuery[MAX_QUERY_LEN+1];
 218         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 219
 220         if ((pMsgType->mainType == MSG_SMS_TYPE) && (pMsgType->subType == MSG_WAP_SI_SMS ||pMsgType->subType == MSG_WAP_SL_SMS)) { // PUSH
 221                 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT COUNT(MSG_ID) FROM %s WHERE MAIN_TYPE = %d AND SUB_TYPE IN (%d, %d) AND FOLDER_ID = %d;",
 222                                 MSGFW_MESSAGE_TABLE_NAME, pMsgType->mainType, MSG_WAP_SI_SMS, MSG_WAP_SL_SMS, MSG_INBOX_ID);
 223         } else if ((pMsgType->mainType == MSG_SMS_TYPE) && (pMsgType->subType == MSG_CB_SMS)) { // CB
 224                 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT COUNT(MSG_ID) FROM %s WHERE MAIN_TYPE = %d AND SUB_TYPE IN (%d) AND FOLDER_ID = %d;",
 225                                 MSGFW_MESSAGE_TABLE_NAME, pMsgType->mainType, MSG_CB_SMS, MSG_CBMSGBOX_ID);
 226         } else if ((pMsgType->mainType == MSG_SMS_TYPE) && (pMsgType->subType == MSG_SYNCML_CP)) { // Provision
 227                 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT COUNT(MSG_ID) FROM %s WHERE MAIN_TYPE = %d AND SUB_TYPE IN (%d) AND FOLDER_ID = %d;",
 228                                 MSGFW_MESSAGE_TABLE_NAME, pMsgType->mainType, MSG_SYNCML_CP, MSG_INBOX_ID);
 229         } else if ((pMsgType->mainType == MSG_SMS_TYPE)) { // SMS
 230                 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;",
 231                                 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
 232         } else if ((pMsgType->mainType == MSG_MMS_TYPE) &&
 233                         (pMsgType->subType == MSG_SENDREQ_MMS || pMsgType->subType == MSG_SENDCONF_MMS || pMsgType->subType == MSG_RETRIEVE_AUTOCONF_MMS ||
 234                                         pMsgType->subType == MSG_RETRIEVE_MANUALCONF_MMS || pMsgType->subType == MSG_NOTIFICATIONIND_MMS)) { // MMS
 235                 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;",
 236                                 MSGFW_MESSAGE_TABLE_NAME, pMsgType->mainType, MSG_SENDREQ_MMS, MSG_SENDCONF_MMS, MSG_RETRIEVE_AUTOCONF_MMS, MSG_RETRIEVE_MANUALCONF_MMS, MSG_NOTIFICATIONIND_MMS, folderId);
 237         } else {
 238                 return MSG_ERR_INVALID_PARAMETER;
 239         }
 240
 241         if (pDbHandle->prepareQuery(sqlQuery) != MSG_SUCCESS)
 242                 return MSG_ERR_DB_PREPARE;
 243
 244         if (pDbHandle->stepQuery() == MSG_ERR_DB_ROW) {
 245                 *pMsgCount = pDbHandle->columnInt(0);
 246         } else {
 247                 pDbHandle->finalizeQuery();
 248                 return MSG_ERR_DB_STEP;
 249         }
 250
 251         pDbHandle->finalizeQuery();
 252
 253         return MSG_SUCCESS;
 254 }
 255
 256
 257 int MsgStoCheckMsgCntLimit(const MSG_MESSAGE_TYPE_S* pMsgType, msg_folder_id_t folderId)
 258 {
 259         int msgboxType = -1;
 260         int msgType= -1;
 261
 262         switch (folderId)
 263         {
 264                 case MSG_INBOX_ID :
 265                         msgboxType = MSG_COUNT_LIMIT_INBOX_TYPE;
 266                 break;
 267
 268                 case MSG_OUTBOX_ID :
 269                         msgboxType = MSG_COUNT_LIMIT_OUTBOX_TYPE;
 270                 break;
 271
 272                 case MSG_SENTBOX_ID :
 273                         msgboxType = MSG_COUNT_LIMIT_SENTBOX_TYPE;
 274                 break;
 275
 276                 case MSG_DRAFT_ID :
 277                         msgboxType = MSG_COUNT_LIMIT_DRAFTBOX_TYPE;
 278                 break;
 279
 280                 case MSG_CBMSGBOX_ID :
 281                         msgboxType = MSG_COUNT_LIMIT_CBMSGBOX_TYPE;
 282                 break;
 283
 284                 default:
 285                         MSG_DEBUG("Unknown mailbox Type [%d]", folderId);
 286                 return -1;
 287         }
 288
 289         switch (pMsgType->subType)
 290         {
 291                 case MSG_NORMAL_SMS:
 292                 case MSG_REPLACE_TYPE1_SMS:
 293                 case MSG_REPLACE_TYPE2_SMS:
 294                 case MSG_REPLACE_TYPE3_SMS:
 295                 case MSG_REPLACE_TYPE4_SMS:
 296                 case MSG_REPLACE_TYPE5_SMS:
 297                 case MSG_REPLACE_TYPE6_SMS:
 298                 case MSG_REPLACE_TYPE7_SMS:
 299                 case MSG_MWI_VOICE_SMS:
 300                 case MSG_MWI_FAX_SMS:
 301                 case MSG_MWI_EMAIL_SMS:
 302                 case MSG_MWI_OTHER_SMS:
 303                 case MSG_STATUS_REPORT_SMS:
 304                         msgType = MSG_COUNT_LIMIT_SMS_TYPE;
 305                 break;
 306
 307                 case MSG_CB_SMS:
 308                         msgType = MSG_COUNT_LIMIT_CB_TYPE;
 309                 break;
 310
 311                 case MSG_WAP_SI_SMS:
 312                 case MSG_WAP_SL_SMS:
 313                         msgType = MSG_COUNT_LIMIT_WAPPUSH_TYPE;
 314                 break;
 315
 316                 case MSG_SYNCML_CP:
 317                         msgType = MSG_COUNT_LIMIT_PROVISION_TYPE;
 318                 break;
 319
 320                 case MSG_SENDREQ_MMS:
 321                 case MSG_SENDCONF_MMS:
 322                 case MSG_NOTIFICATIONIND_MMS:
 323                 case MSG_RETRIEVE_AUTOCONF_MMS:
 324                 case MSG_RETRIEVE_MANUALCONF_MMS:
 325                         msgType = MSG_COUNT_LIMIT_MMS_TYPE;
 326                 break;
 327
 328                 default:
 329                         MSG_DEBUG("Unknown Message Type [%d]", pMsgType->subType);
 330                 return -1;
 331         }
 332
 333         return msgCntLimit[msgboxType][msgType];
 334 }
 335
 336
 337 msg_error_t MsgStoAddAddress(MsgDbHandler *pDbHandle, const MSG_MESSAGE_INFO_S *pMsg, msg_thread_id_t *pConvId)
 338 {
 339         msg_error_t err = MSG_SUCCESS;
 340
 341         char sqlQuery[MAX_QUERY_LEN+1];
 342
 343         // Check if new address or not
 344         if (MsgExistAddress(pDbHandle, pMsg, pConvId) == true) {
 345                 MSG_DEBUG("The address already exists. Conversation ID : [%d]", *pConvId);
 346                 return err;
 347         }
 348
 349         MSG_DEBUG("Conversation ID : [%d]", *pConvId);
 350
 351         /* conversation insert */
 352         err = MsgStoAddConversation(pDbHandle, pConvId);
 353         if (err != MSG_SUCCESS) {
 354                 MSG_DEBUG("MsgStoAddConversation() fail [%d]", err);
 355                 return err;
 356         }
 357
 358         /* insert address in loop */
 359         for (int i=0; i<pMsg->nAddressCnt; i++) {
 360
 361                 unsigned int addrId;
 362                 MSG_CONTACT_INFO_S contactInfo = {0};
 363
 364                 // Get Contact Info
 365                 err = MsgGetContactInfo(&(pMsg->addressList[i]), &contactInfo);
 366
 367                 if (err != MSG_SUCCESS) {
 368                         MSG_DEBUG("MsgGetContactInfo() fail [%d]", err);
 369                         return err;
 370                 }
 371
 372                 if (pDbHandle->getRowId(MSGFW_ADDRESS_TABLE_NAME, &addrId) != MSG_SUCCESS) {
 373                         return err;
 374                 }
 375
 376                 // Add Address
 377                 memset(sqlQuery, 0x00, sizeof(sqlQuery));
 378                 snprintf(sqlQuery, sizeof(sqlQuery), "INSERT INTO %s VALUES (%d, %d, %d, %d, '%s', %d, '', ?, ?, '%s', 0);",
 379                                         MSGFW_ADDRESS_TABLE_NAME, addrId, *pConvId, pMsg->addressList[i].addressType, pMsg->addressList[i].recipientType, pMsg->addressList[i].addressVal,
 380                                         contactInfo.contactId, contactInfo.imagePath);
 381
 382                 MSG_DEBUG("Add Address Info. [%s]", sqlQuery);
 383
 384                 if (pDbHandle->prepareQuery(sqlQuery) != MSG_SUCCESS)
 385                         return MSG_ERR_DB_PREPARE;
 386
 387                 pDbHandle->bindText(contactInfo.firstName, 1);
 388                 pDbHandle->bindText(contactInfo.lastName, 2);
 389
 390                 if (pDbHandle->stepQuery() != MSG_ERR_DB_DONE) {
 391                         pDbHandle->finalizeQuery();
 392                         return MSG_ERR_DB_STEP;
 393                 }
 394
 395                 pDbHandle->finalizeQuery();
 396
 397                 // set conversation display name by conv id
 398                 MsgStoSetConversationDisplayName(pDbHandle, *pConvId);
 399
 400         }
 401
 402         return err;
 403 }
 404
 405 msg_error_t MsgStoGetAddressByMsgId(MsgDbHandler *pDbHandle, msg_message_id_t msgId, int contactNameOrder, int *nAddressCnt, MSG_ADDRESS_INFO_S *pAddress)
 406 {
 407         char sqlQuery[MAX_QUERY_LEN+1];
 408         char firstName[MAX_DISPLAY_NAME_LEN+1];
 409         char lastName[MAX_DISPLAY_NAME_LEN+1];
 410
 411         *nAddressCnt = 0;
 412
 413         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 414         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT A.ADDRESS_TYPE, A.RECIPIENT_TYPE, \
 415                                 A.CONTACT_ID, A.ADDRESS_VAL, A.DISPLAY_NAME, A.FIRST_NAME, A.LAST_NAME \
 416                                 FROM %s A, %s B WHERE A.CONV_ID = B.CONV_ID AND B.MSG_ID = %d;",
 417                                 MSGFW_ADDRESS_TABLE_NAME, MSGFW_MESSAGE_TABLE_NAME, msgId);
 418
 419         if (pDbHandle->prepareQuery(sqlQuery) != MSG_SUCCESS) {
 420                 MSG_DEBUG("Query Failed [%s]", sqlQuery);
 421                 return MSG_ERR_DB_PREPARE;
 422         }
 423
 424         while (pDbHandle->stepQuery() == MSG_ERR_DB_ROW) {
 425                 memset(firstName, 0x00, sizeof(firstName));
 426                 memset(lastName, 0x00, sizeof(lastName));
 427
 428                 pAddress[*nAddressCnt].addressType = pDbHandle->columnInt(0);
 429                 pAddress[*nAddressCnt].recipientType = pDbHandle->columnInt(1);
 430                 pAddress[*nAddressCnt].contactId = pDbHandle->columnInt(2);
 431
 432                 if (pDbHandle->columnText(3) != NULL)
 433                         strncpy(pAddress[*nAddressCnt].addressVal, (char *)pDbHandle->columnText(3), MAX_ADDRESS_VAL_LEN);
 434
 435                 if (pDbHandle->columnText(4) != NULL && ((char *)pDbHandle->columnText(4))[0]!='\0') {
 436                         MSG_DEBUG("displayName  : [%s]", pDbHandle->columnText(4));
 437                         strncpy(pAddress[*nAddressCnt].displayName, (char *)pDbHandle->columnText(4), MAX_DISPLAY_NAME_LEN);
 438                 } else {
 439                         if (pDbHandle->columnText(5) != NULL)
 440                                         strncpy(firstName, (char *)pDbHandle->columnText(5), MAX_DISPLAY_NAME_LEN);
 441
 442                         if (pDbHandle->columnText(6) != NULL)
 443                                         strncpy(lastName, (char *)pDbHandle->columnText(6), MAX_DISPLAY_NAME_LEN);
 444
 445                         if (contactNameOrder == 0) {
 446                                 if (strlen(firstName) > 0) {
 447                                         strncpy(pAddress[*nAddressCnt].displayName, firstName, MAX_DISPLAY_NAME_LEN);
 448                                 }
 449                                 if (strlen(lastName) > 0) {
 450                                         strncat(pAddress[*nAddressCnt].displayName, " ", MAX_DISPLAY_NAME_LEN-strlen(pAddress[*nAddressCnt].displayName));
 451                                         strncat(pAddress[*nAddressCnt].displayName, lastName, MAX_DISPLAY_NAME_LEN-strlen(pAddress[*nAddressCnt].displayName));
 452                                 }
 453                         } else if (contactNameOrder == 1) {
 454                                 if (strlen(lastName) > 0) {
 455                                         strncpy(pAddress[*nAddressCnt].displayName, lastName, MAX_DISPLAY_NAME_LEN);
 456                                         strncat(pAddress[*nAddressCnt].displayName, " ", MAX_DISPLAY_NAME_LEN-strlen(pAddress[*nAddressCnt].displayName));
 457                                 }
 458
 459                                 if (strlen(firstName) > 0) {
 460                                         strncat(pAddress[*nAddressCnt].displayName, firstName, MAX_DISPLAY_NAME_LEN-strlen(pAddress[*nAddressCnt].displayName));
 461                                 }
 462                         }
 463                 }
 464
 465                 (*nAddressCnt)++;
 466         }
 467
 468         pDbHandle->finalizeQuery();
 469
 470         return MSG_SUCCESS;
 471 }
 472
 473 msg_error_t MsgStoGetAddressByMsgId(MsgDbHandler *pDbHandle, msg_message_id_t msgId, int contactNameOrder, msg_struct_list_s *pAddress)
 474 {
 475         char sqlQuery[MAX_QUERY_LEN+1];
 476         char firstName[MAX_DISPLAY_NAME_LEN+1];
 477         char lastName[MAX_DISPLAY_NAME_LEN+1];
 478
 479         pAddress->nCount = 0;
 480         pAddress->msg_struct_info = NULL;
 481
 482         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 483         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT A.ADDRESS_TYPE, A.RECIPIENT_TYPE, \
 484                         A.CONTACT_ID, A.ADDRESS_VAL, A.DISPLAY_NAME, A.FIRST_NAME, A.LAST_NAME \
 485                         FROM %s A, %s B WHERE A.CONV_ID = B.CONV_ID AND B.MSG_ID = %d;",
 486                         MSGFW_ADDRESS_TABLE_NAME, MSGFW_MESSAGE_TABLE_NAME, msgId);
 487
 488         if (pDbHandle->prepareQuery(sqlQuery) != MSG_SUCCESS) {
 489                 MSG_DEBUG("Query Failed [%s]", sqlQuery);
 490                 return MSG_ERR_DB_PREPARE;
 491         }
 492
 493         msg_struct_s *pTmp = NULL;
 494         MSG_ADDRESS_INFO_S *pAddr = NULL;
 495
 496         pAddress->msg_struct_info = (msg_struct_t *)new char[sizeof(msg_struct_t) * MAX_TO_ADDRESS_CNT];
 497
 498         for (int i = 0; i < MAX_TO_ADDRESS_CNT; i++) {
 499                 pAddress->msg_struct_info[i] = (msg_struct_t)new char[sizeof(msg_struct_s)];
 500                 pTmp = (msg_struct_s *)pAddress->msg_struct_info[i];
 501                 pTmp->type = MSG_STRUCT_ADDRESS_INFO;
 502                 pTmp->data = new char[sizeof(MSG_ADDRESS_INFO_S)];
 503                 memset(pTmp->data, 0x00, sizeof(MSG_ADDRESS_INFO_S));
 504         }
 505
 506
 507         while (pDbHandle->stepQuery() == MSG_ERR_DB_ROW) {
 508                 memset(firstName, 0x00, sizeof(firstName));
 509                 memset(lastName, 0x00, sizeof(lastName));
 510
 511                 pTmp = (msg_struct_s *)pAddress->msg_struct_info[pAddress->nCount];
 512                 pAddr = (MSG_ADDRESS_INFO_S *)pTmp->data;
 513
 514                 pAddr->addressType = pDbHandle->columnInt(0);
 515                 pAddr->recipientType = pDbHandle->columnInt(1);
 516                 pAddr->contactId = pDbHandle->columnInt(2);
 517
 518                 if (pDbHandle->columnText(3) != NULL)
 519                                         strncpy(pAddr->addressVal, (char *)pDbHandle->columnText(3), MAX_ADDRESS_VAL_LEN);
 520
 521                 if (pDbHandle->columnText(4) != NULL && ((char *)pDbHandle->columnText(4))[0]!='\0') {
 522                                         MSG_DEBUG("displayName  : [%s]", pDbHandle->columnText(4));
 523                                         strncpy(pAddr->displayName, (char *)pDbHandle->columnText(4), MAX_DISPLAY_NAME_LEN);
 524                 } else {
 525                         if (pDbHandle->columnText(5) != NULL)
 526                                 strncpy(firstName, (char *)pDbHandle->columnText(5), MAX_DISPLAY_NAME_LEN);
 527
 528                         if (pDbHandle->columnText(6) != NULL)
 529                                 strncpy(lastName, (char *)pDbHandle->columnText(6), MAX_DISPLAY_NAME_LEN);
 530
 531                         if (contactNameOrder == 0) {
 532                                 if (strlen(firstName) > 0) {
 533                                         strncpy(pAddr->displayName, firstName, MAX_DISPLAY_NAME_LEN);
 534                                 }
 535
 536                                 if (strlen(lastName) > 0) {
 537                                         strncat(pAddr->displayName, " ", MAX_DISPLAY_NAME_LEN-strlen(pAddr->displayName));
 538                                         strncat(pAddr->displayName, lastName, MAX_DISPLAY_NAME_LEN-strlen(pAddr->displayName));
 539                                 }
 540                         } else if (contactNameOrder == 1) {
 541                                 if (strlen(lastName) > 0) {
 542                                         strncpy(pAddr->displayName, lastName, MAX_DISPLAY_NAME_LEN);
 543                                         strncat(pAddr->displayName, " ", MAX_DISPLAY_NAME_LEN-strlen(pAddr->displayName));
 544                                 }
 545
 546                                 if (strlen(firstName) > 0) {
 547                                         strncat(pAddr->displayName, firstName, MAX_DISPLAY_NAME_LEN-strlen(pAddr->displayName));
 548                                 }
 549                         }
 550                 }
 551
 552                 pAddress->nCount++;
 553         }
 554
 555         pDbHandle->finalizeQuery();
 556
 557         return MSG_SUCCESS;
 558 }
 559
 560
 561 msg_error_t MsgStoGetAddressByConvId(MsgDbHandler *pDbHandle, msg_thread_id_t convId, int contactNameOrder, msg_struct_list_s *pAddrlist)
 562 {
 563         char sqlQuery[MAX_QUERY_LEN+1];
 564         char firstName[MAX_DISPLAY_NAME_LEN+1];
 565         char lastName[MAX_DISPLAY_NAME_LEN+1];
 566         int index = 7;
 567         int rowCnt = 0;
 568
 569         pAddrlist->nCount = 0;
 570         pAddrlist->msg_struct_info = NULL;
 571
 572         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 573         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT ADDRESS_TYPE, RECIPIENT_TYPE, \
 574                         CONTACT_ID, ADDRESS_VAL, DISPLAY_NAME, FIRST_NAME, LAST_NAME \
 575                         FROM %s WHERE CONV_ID  = %d;",
 576                         MSGFW_ADDRESS_TABLE_NAME, convId);
 577
 578         msg_error_t  err = pDbHandle->getTable(sqlQuery, &rowCnt);
 579
 580         if (err == MSG_ERR_DB_NORECORD) {
 581                 pDbHandle->freeTable();
 582                 return MSG_SUCCESS;
 583         } else if (err != MSG_SUCCESS) {
 584                 MSG_DEBUG("sqlQuery is - %s", sqlQuery);
 585                 pDbHandle->freeTable();
 586                 return err;
 587         }
 588
 589         pAddrlist->nCount = rowCnt;
 590
 591         MSG_DEBUG("pAddrlist->nCount [%d]", pAddrlist->nCount);
 592
 593         msg_struct_s *pTmp = NULL;
 594         MSG_ADDRESS_INFO_S *pAddr = NULL;
 595
 596         pAddrlist->msg_struct_info = (msg_struct_t *)new char[sizeof(msg_struct_t) * MAX_TO_ADDRESS_CNT];
 597
 598         for (int i = 0; i < MAX_TO_ADDRESS_CNT; i++) {
 599                 pAddrlist->msg_struct_info[i] = (msg_struct_t)new char[sizeof(msg_struct_s)];
 600                 pTmp = (msg_struct_s *)pAddrlist->msg_struct_info[i];
 601                 pTmp->type = MSG_STRUCT_ADDRESS_INFO;
 602                 pTmp->data = new char[sizeof(MSG_ADDRESS_INFO_S)];
 603                 memset(pTmp->data, 0x00, sizeof(MSG_ADDRESS_INFO_S));
 604         }
 605
 606         for (int i = 0; i < rowCnt; i++) {
 607                 pTmp = (msg_struct_s *)pAddrlist->msg_struct_info[i];
 608                 pAddr = (MSG_ADDRESS_INFO_S *)pTmp->data;
 609
 610                 pAddr->addressType = pDbHandle->getColumnToInt(index++);
 611                 pAddr->recipientType = pDbHandle->getColumnToInt(index++);
 612                 pAddr->contactId = pDbHandle->getColumnToInt(index++);
 613                 pDbHandle->getColumnToString(index++, MAX_ADDRESS_VAL_LEN, pAddr->addressVal);
 614                 pDbHandle->getColumnToString(index++, MAX_DISPLAY_NAME_LEN, pAddr->displayName);
 615                 if(!strlen(pAddr->displayName))
 616                 {
 617                         pDbHandle->getColumnToString(index++,MAX_DISPLAY_NAME_LEN, firstName);
 618                         pDbHandle->getColumnToString(index++,MAX_DISPLAY_NAME_LEN, lastName);
 619
 620                         if (contactNameOrder == 0) {
 621                                 if (strlen(firstName) > 0) {
 622                                         strncpy(pAddr->displayName, firstName, MAX_DISPLAY_NAME_LEN);
 623                                 }
 624
 625                                 if (strlen(lastName) > 0) {
 626                                         strncat(pAddr->displayName, " ", MAX_DISPLAY_NAME_LEN-strlen(pAddr->displayName));
 627                                         strncat(pAddr->displayName, lastName, MAX_DISPLAY_NAME_LEN-strlen(pAddr->displayName));
 628                                 }
 629                         } else if (contactNameOrder == 1) {
 630                                 if (strlen(lastName) > 0) {
 631                                         strncpy(pAddr->displayName, lastName, MAX_DISPLAY_NAME_LEN);
 632                                         strncat(pAddr->displayName, " ", MAX_DISPLAY_NAME_LEN-strlen(pAddr->displayName));
 633                                 }
 634
 635                                 if (strlen(firstName) > 0) {
 636                                         strncat(pAddr->displayName, firstName, MAX_DISPLAY_NAME_LEN-strlen(pAddr->displayName));
 637                                 }
 638                         }
 639                 }
 640
 641         }
 642         pDbHandle->freeTable();
 643
 644         return MSG_SUCCESS;
 645 }
 646
 647
 648 /* Have to use trigger for this function. */
 649 msg_error_t MsgStoUpdateConversation(MsgDbHandler *pDbHandle, msg_thread_id_t convId)
 650 {
 651         MSG_BEGIN();
 652
 653         msg_error_t err = MSG_SUCCESS;
 654
 655         int unreadCnt = 0;
 656         int smsCnt = 0;
 657         int mmsCnt = 0;
 658
 659         char msgText[MAX_THREAD_DATA_LEN+1];
 660         char sqlQuery[MAX_QUERY_LEN+1];
 661
 662         memset(msgText, 0x00, sizeof(msgText));
 663
 664         // Get Unread Count
 665         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 666
 667         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT COUNT(MSG_ID) FROM %s WHERE CONV_ID = %d AND FOLDER_ID = %d AND STORAGE_ID = %d AND READ_STATUS = 0;",
 668                         MSGFW_MESSAGE_TABLE_NAME, convId, MSG_INBOX_ID, MSG_STORAGE_PHONE);
 669
 670         if (pDbHandle->prepareQuery(sqlQuery) != MSG_SUCCESS)
 671                 return MSG_ERR_DB_PREPARE;
 672
 673         err = pDbHandle->stepQuery();
 674
 675         if (err == MSG_ERR_DB_ROW) {
 676                 unreadCnt = pDbHandle->columnInt(0);
 677         } else if (err != MSG_ERR_DB_DONE) {
 678                 pDbHandle->finalizeQuery();
 679                 return MSG_ERR_DB_STEP;
 680         }
 681
 682         pDbHandle->finalizeQuery();
 683
 684         // Get SMS Count
 685         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 686
 687         snprintf(sqlQuery, sizeof(sqlQuery), "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;",
 688                         MSGFW_MESSAGE_TABLE_NAME, convId, MSG_SMS_TYPE, MSG_ALLBOX_ID, MSG_CBMSGBOX_ID, MSG_STORAGE_PHONE);
 689
 690         if (pDbHandle->prepareQuery(sqlQuery) != MSG_SUCCESS)
 691                 return MSG_ERR_DB_PREPARE;
 692
 693         err = pDbHandle->stepQuery();
 694
 695         if (err == MSG_ERR_DB_ROW) {
 696                 smsCnt = pDbHandle->columnInt(0);
 697         }
 698         else if (err != MSG_ERR_DB_DONE) {
 699                 pDbHandle->finalizeQuery();
 700                 return MSG_ERR_DB_STEP;
 701         }
 702
 703         pDbHandle->finalizeQuery();
 704
 705         // Get MMS Count
 706         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 707
 708         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT COUNT(MSG_ID) FROM %s \
 709                         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;",
 710                         MSGFW_MESSAGE_TABLE_NAME, convId, MSG_MMS_TYPE, MSG_DELIVERYIND_MMS, MSG_READRECIND_MMS, MSG_READORGIND_MMS,
 711                         MSG_ALLBOX_ID, MSG_CBMSGBOX_ID, MSG_STORAGE_PHONE);
 712
 713         if (pDbHandle->prepareQuery(sqlQuery) != MSG_SUCCESS)
 714                 return MSG_ERR_DB_PREPARE;
 715
 716         err = pDbHandle->stepQuery();
 717
 718         if (err == MSG_ERR_DB_ROW) {
 719                 mmsCnt = pDbHandle->columnInt(0);
 720         } else if (err != MSG_ERR_DB_DONE) {
 721                 pDbHandle->finalizeQuery();
 722                 return MSG_ERR_DB_STEP;
 723         }
 724
 725         pDbHandle->finalizeQuery();
 726
 727         // Get Latest Msg Data
 728         MSG_MAIN_TYPE_T mainType = MSG_UNKNOWN_TYPE;
 729         MSG_SUB_TYPE_T subType = MSG_NORMAL_SMS;
 730         msg_direction_type_t direction = MSG_DIRECTION_TYPE_MO;
 731         time_t msgTime = 0;
 732
 733         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 734
 735         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT MAIN_TYPE, SUB_TYPE, MSG_DIRECTION, DISPLAY_TIME, SUBJECT, MSG_TEXT FROM %s \
 736                         WHERE CONV_ID = %d AND FOLDER_ID > %d AND FOLDER_ID < %d AND STORAGE_ID = %d ORDER BY DISPLAY_TIME DESC;",
 737                         MSGFW_MESSAGE_TABLE_NAME, convId, MSG_ALLBOX_ID, MSG_SPAMBOX_ID, MSG_STORAGE_PHONE);
 738
 739         if (pDbHandle->prepareQuery(sqlQuery) != MSG_SUCCESS)
 740                 return MSG_ERR_DB_PREPARE;
 741
 742         err = pDbHandle->stepQuery();
 743
 744         if (err == MSG_ERR_DB_ROW) {
 745                 mainType = pDbHandle->columnInt(0);
 746                 subType = pDbHandle->columnInt(1);
 747                 direction = pDbHandle->columnInt(2);
 748
 749                 msgTime = (time_t)pDbHandle->columnInt(3);
 750
 751                 memset(msgText, 0x00, sizeof(msgText));
 752
 753                 if (mainType == MSG_SMS_TYPE) {
 754                         if (pDbHandle->columnText(5) != NULL)
 755                                 strncpy(msgText, (char*)pDbHandle->columnText(5), MAX_THREAD_DATA_LEN);
 756                 } else if (mainType == MSG_MMS_TYPE) {
 757                         if (pDbHandle->columnText(4) != NULL) {
 758                                 strncpy(msgText, (char*)pDbHandle->columnText(4), MAX_THREAD_DATA_LEN);
 759                         }
 760
 761                         if ((strlen(msgText) <= 0) && (pDbHandle->columnText(5) != NULL) && (subType != MSG_NOTIFICATIONIND_MMS)) {
 762                                 memset(msgText, 0x00, sizeof(msgText));
 763                                 strncpy(msgText, (char*)pDbHandle->columnText(5), MAX_THREAD_DATA_LEN);
 764                         }
 765                 }
 766         } else if (err != MSG_ERR_DB_DONE) {
 767                 pDbHandle->finalizeQuery();
 768                 return MSG_ERR_DB_STEP;
 769         }
 770
 771         pDbHandle->finalizeQuery();
 772
 773         // Update Address Table
 774         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 775
 776         snprintf(sqlQuery, sizeof(sqlQuery), "UPDATE %s SET \
 777                         UNREAD_CNT = %d, SMS_CNT = %d, MMS_CNT = %d, MAIN_TYPE = %d, SUB_TYPE = %d, MSG_DIRECTION = %d, DISPLAY_TIME = %ld, MSG_TEXT = ? \
 778                         WHERE CONV_ID = %d;", MSGFW_CONVERSATION_TABLE_NAME, unreadCnt, smsCnt, mmsCnt, mainType, subType, direction, msgTime, convId);
 779
 780         if (pDbHandle->prepareQuery(sqlQuery) != MSG_SUCCESS) {
 781                 MSG_DEBUG("Query Failed [%s]", sqlQuery);
 782                 return MSG_ERR_DB_PREPARE;
 783         }
 784
 785         pDbHandle->bindText(msgText, 1);
 786
 787         if (pDbHandle->stepQuery() != MSG_ERR_DB_DONE) {
 788                 pDbHandle->finalizeQuery();
 789                 MSG_DEBUG("Update Address Info. Fail [%d] [%s]", err, sqlQuery);
 790                 return MSG_ERR_DB_STEP;
 791         }
 792
 793         pDbHandle->finalizeQuery();
 794
 795         MSG_END();
 796
 797         return MSG_SUCCESS;
 798 }
 799
 800
 801 /* consider to replcae this function to trigger. */
 802 msg_error_t MsgStoClearConversationTable(MsgDbHandler *pDbHandle)
 803 {
 804         msg_error_t err = MSG_SUCCESS;
 805
 806         char sqlQuery[MAX_QUERY_LEN+1];
 807
 808         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 809
 810         snprintf(sqlQuery, sizeof(sqlQuery), "DELETE FROM %s \
 811                         WHERE CONV_ID NOT IN (SELECT CONV_ID FROM %s) AND CONV_ID <> 0;",
 812                         MSGFW_CONVERSATION_TABLE_NAME, MSGFW_MESSAGE_TABLE_NAME);
 813
 814         err = pDbHandle->execQuery(sqlQuery);
 815
 816         snprintf(sqlQuery, sizeof(sqlQuery), "DELETE FROM %s WHERE CONV_ID NOT IN (SELECT CONV_ID FROM %s);",
 817                         MSGFW_ADDRESS_TABLE_NAME, MSGFW_CONVERSATION_TABLE_NAME);
 818
 819         err = pDbHandle->execQuery(sqlQuery);
 820
 821         return err;
 822 }
 823
 824
 825 void MsgConvertNumber(const char* pSrcNum, char* pDestNum)
 826 {
 827         int overLen = 0;
 828         int i = 0;
 829
 830         overLen = strlen(pSrcNum) - MAX_PRECONFIG_NUM;
 831
 832         for (i = 0; i < MAX_PRECONFIG_NUM; i++)
 833                 pDestNum[i] = pSrcNum[i+overLen];
 834
 835         pDestNum[i] = '\0';
 836 }
 837
 838 /* Change the function name to conversation related. */
 839 bool MsgExistAddress(MsgDbHandler *pDbHandle, const MSG_MESSAGE_INFO_S *pMsg, msg_thread_id_t *pConvId)
 840 {
 841         msg_error_t err = MSG_SUCCESS;
 842
 843         char sqlQuery[MAX_QUERY_LEN+1];
 844
 845         *pConvId = 0;
 846
 847         if(pMsg->nAddressCnt == 1) {
 848                 if (strlen(pMsg->addressList[0].addressVal) > MAX_PRECONFIG_NUM) {
 849                         char newPhoneNum[MAX_PRECONFIG_NUM+1];
 850
 851                         memset(newPhoneNum, 0x00, sizeof(newPhoneNum));
 852
 853                         MsgConvertNumber(pMsg->addressList[0].addressVal, newPhoneNum);
 854
 855                         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 856
 857                         snprintf(sqlQuery, sizeof(sqlQuery),
 858                                         "SELECT CONV_ID FROM (SELECT B.CONV_ID FROM %s A, %s B WHERE A.ADDRESS_VAL LIKE '%%%%%s' AND A.CONV_ID=B.CONV_ID) GROUP BY CONV_ID HAVING COUNT(CONV_ID)=1;",
 859                                         MSGFW_ADDRESS_TABLE_NAME, MSGFW_ADDRESS_TABLE_NAME, newPhoneNum);
 860                 } else {
 861                         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 862
 863                         snprintf(sqlQuery, sizeof(sqlQuery),
 864                                         "SELECT CONV_ID FROM (SELECT B.CONV_ID FROM %s A, %s B WHERE A.ADDRESS_VAL = '%s' AND A.CONV_ID=B.CONV_ID) GROUP BY CONV_ID HAVING COUNT(CONV_ID)=1;",
 865                                         MSGFW_ADDRESS_TABLE_NAME, MSGFW_ADDRESS_TABLE_NAME, pMsg->addressList[0].addressVal);
 866                 }
 867
 868                 int rowCnt = 0;
 869                 msg_thread_id_t convId = 0;
 870                 err = pDbHandle->getTable(sqlQuery, &rowCnt);
 871
 872                 /* No record or other error */
 873                 if (err != MSG_SUCCESS) {
 874                         MSG_DEBUG("Query Failed [%s]", sqlQuery);
 875                         pDbHandle->freeTable();
 876                         return false;
 877                 }
 878
 879                 if(rowCnt > 0) {
 880                         convId = pDbHandle->getColumnToInt(1);
 881
 882                         MSG_DEBUG("CONV_ID : [%d]", convId);
 883
 884                         if (convId > 0) {
 885                                 *pConvId = convId;
 886                                 pDbHandle->freeTable();
 887                                 return true;
 888                         } else {
 889                                 pDbHandle->freeTable();
 890                                 return false;
 891                         }
 892                 }
 893
 894         } else { /* multiple address */
 895                 if (strlen(pMsg->addressList[0].addressVal) > MAX_PRECONFIG_NUM) {
 896                         char newPhoneNum[MAX_PRECONFIG_NUM+1];
 897
 898                         memset(newPhoneNum, 0x00, sizeof(newPhoneNum));
 899
 900                         MsgConvertNumber(pMsg->addressList[0].addressVal, newPhoneNum);
 901
 902                         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 903
 904                         snprintf(sqlQuery, sizeof(sqlQuery),
 905                                         "SELECT CONV_ID FROM (SELECT B.CONV_ID FROM %s A, %s B WHERE A.ADDRESS_VAL LIKE '%%%%%s' AND A.CONV_ID=B.CONV_ID) GROUP BY CONV_ID HAVING COUNT(CONV_ID)=%d;",
 906                                         MSGFW_ADDRESS_TABLE_NAME, MSGFW_ADDRESS_TABLE_NAME, newPhoneNum, pMsg->nAddressCnt);
 907                 } else {
 908                         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 909
 910                         snprintf(sqlQuery, sizeof(sqlQuery),
 911                                         "SELECT CONV_ID FROM (SELECT B.CONV_ID FROM %s A, %s B WHERE A.ADDRESS_VAL = '%s' AND A.CONV_ID=B.CONV_ID) GROUP BY CONV_ID HAVING COUNT(CONV_ID)=%d;",
 912                                         MSGFW_ADDRESS_TABLE_NAME, MSGFW_ADDRESS_TABLE_NAME, pMsg->addressList[0].addressVal, pMsg->nAddressCnt);
 913                 }
 914
 915                 int rowCnt = 0;
 916                 int convId = 0;
 917
 918                 MSG_DEBUG("Query [%s]", sqlQuery);
 919
 920                 err = pDbHandle->getTable(sqlQuery, &rowCnt);
 921
 922                 /* No record or other error */
 923                 if (err != MSG_SUCCESS) {
 924                         MSG_DEBUG("Query Failed [%s]", sqlQuery);
 925                         pDbHandle->freeTable();
 926                         return false;
 927                 }
 928
 929                 for (int i = 1; i <= rowCnt; i++) {
 930                         convId = pDbHandle->getColumnToInt(i);
 931
 932                         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 933
 934                         snprintf(sqlQuery, sizeof(sqlQuery),
 935                                         "SELECT COUNT(*) FROM %s WHERE CONV_ID=%d AND (",
 936                                         MSGFW_ADDRESS_TABLE_NAME, convId);
 937
 938                         for (int j = 0; j<(pMsg->nAddressCnt); j++ ) {
 939
 940                                 if (j!=0)
 941                                         strncat(sqlQuery, "OR ", MAX_QUERY_LEN-strlen(sqlQuery));
 942
 943                                 if (strlen(pMsg->addressList[j].addressVal) > MAX_PRECONFIG_NUM) {
 944
 945                                         strncat(sqlQuery, "ADDRESS_VAL LIKE '%%%%", MAX_QUERY_LEN-strlen(sqlQuery));
 946
 947                                         char newPhoneNum[MAX_PRECONFIG_NUM+1];
 948                                         memset(newPhoneNum, 0x00, sizeof(newPhoneNum));
 949                                         MsgConvertNumber(pMsg->addressList[j].addressVal, newPhoneNum);
 950
 951                                         strncat(sqlQuery, newPhoneNum, MAX_QUERY_LEN-strlen(sqlQuery));
 952
 953                                         strncat(sqlQuery, "' ", MAX_QUERY_LEN-strlen(sqlQuery));
 954                                 } else {
 955                                         strncat(sqlQuery, "ADDRESS_VAL = '", MAX_QUERY_LEN-strlen(sqlQuery));
 956
 957                                         strncat(sqlQuery, pMsg->addressList[j].addressVal, MAX_QUERY_LEN-strlen(sqlQuery));
 958
 959                                         strncat(sqlQuery, "' ", MAX_QUERY_LEN-strlen(sqlQuery));
 960                                 }
 961                         }
 962                         strncat(sqlQuery, ");", MAX_QUERY_LEN-strlen(sqlQuery));
 963                         MSG_DEBUG("Query [%s]", sqlQuery);
 964                         if (pDbHandle->prepareQuery(sqlQuery) != MSG_SUCCESS) {
 965                                 MSG_DEBUG("Query Failed [%s]", sqlQuery);
 966                                 pDbHandle->freeTable();
 967                                 pDbHandle->finalizeQuery();
 968                                 return false;
 969                         }
 970
 971                         if (pDbHandle->stepQuery() == MSG_ERR_DB_ROW) {
 972                                 if (pMsg->nAddressCnt == pDbHandle->columnInt(0)) {
 973                                         *pConvId = convId;
 974                                         pDbHandle->finalizeQuery();
 975                                         pDbHandle->freeTable();
 976                                         return true;
 977                                 }
 978                         }
 979                         pDbHandle->finalizeQuery();
 980                 }
 981                 pDbHandle->freeTable();
 982         }
 983
 984         return false;
 985 }
 986
 987
 988 int MsgStoGetUnreadCnt(MsgDbHandler *pDbHandle, MSG_MAIN_TYPE_T msgType)
 989 {
 990         int msgCnt = 0;
 991
 992         char sqlQuery[MAX_QUERY_LEN+1];
 993
 994         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 995
 996         if (msgType == MSG_SMS_TYPE) {
 997                 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT COUNT(MSG_ID) FROM %s \
 998                                 WHERE MAIN_TYPE = %d AND SUB_TYPE IN (%d, %d, %d, %d, %d, %d, %d) AND FOLDER_ID = %d AND READ_STATUS = 0;",
 999                                 MSGFW_MESSAGE_TABLE_NAME, MSG_SMS_TYPE, 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, MSG_INBOX_ID);
1000         } else if (msgType == MSG_MMS_TYPE) {
1001                 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT COUNT(MSG_ID) FROM %s \
1002                                 WHERE MAIN_TYPE = %d AND SUB_TYPE IN (%d, %d, %d) AND FOLDER_ID = %d AND READ_STATUS = 0;",
1003                                 MSGFW_MESSAGE_TABLE_NAME, MSG_MMS_TYPE, MSG_RETRIEVE_AUTOCONF_MMS, MSG_RETRIEVE_MANUALCONF_MMS, MSG_NOTIFICATIONIND_MMS, MSG_INBOX_ID);
1004         }
1005
1006         if (pDbHandle->prepareQuery(sqlQuery) != MSG_SUCCESS)
1007                 return 0;
1008
1009         if (pDbHandle->stepQuery() == MSG_ERR_DB_ROW) {
1010                 msgCnt = pDbHandle->columnInt(0);
1011         } else {
1012                 pDbHandle->finalizeQuery();
1013                 return 0;
1014         }
1015
1016         pDbHandle->finalizeQuery();
1017
1018         return msgCnt;
1019 }
1020
1021
1022 msg_error_t MsgStoAddContactInfo(MsgDbHandler *pDbHandle, MSG_CONTACT_INFO_S *pContactInfo, const char *pNumber)
1023 {
1024         char newPhoneNum[MAX_PRECONFIG_NUM+1];
1025         char sqlQuery[MAX_QUERY_LEN+1];
1026
1027         if (strlen(pNumber) > MAX_PRECONFIG_NUM) {
1028                 memset(newPhoneNum, 0x00, sizeof(newPhoneNum));
1029                 MsgConvertNumber(pNumber, newPhoneNum);
1030
1031                 MSG_DEBUG("Phone Number to Compare : [%s]", newPhoneNum);
1032
1033                 memset(sqlQuery, 0x00, sizeof(sqlQuery));
1034                 snprintf(sqlQuery, sizeof(sqlQuery), "UPDATE %s SET \
1035                                 CONTACT_ID = %d, FIRST_NAME = ?, LAST_NAME = ?, IMAGE_PATH = '%s' \
1036                                 WHERE ADDRESS_VAL LIKE '%%%%%s';",
1037                                 MSGFW_ADDRESS_TABLE_NAME, pContactInfo->contactId, pContactInfo->imagePath, newPhoneNum);
1038         } else {
1039                 memset(sqlQuery, 0x00, sizeof(sqlQuery));
1040                 snprintf(sqlQuery, sizeof(sqlQuery), "UPDATE %s SET \
1041                                 CONTACT_ID = %d, FIRST_NAME = ?, LAST_NAME = ?, IMAGE_PATH = '%s' \
1042                                 WHERE ADDRESS_VAL = '%s';",
1043                                 MSGFW_ADDRESS_TABLE_NAME, pContactInfo->contactId, pContactInfo->imagePath, pNumber);
1044         }
1045
1046         if (pDbHandle->prepareQuery(sqlQuery) != MSG_SUCCESS) {
1047                 MSG_DEBUG("sqlQuery [%s]", sqlQuery);
1048                 return MSG_ERR_DB_PREPARE;
1049         }
1050
1051         pDbHandle->bindText(pContactInfo->firstName, 1);
1052
1053         pDbHandle->bindText(pContactInfo->lastName, 2);
1054
1055         if (pDbHandle->stepQuery() != MSG_ERR_DB_DONE) {
1056                 pDbHandle->finalizeQuery();
1057                 MSG_DEBUG("Update contact Info. Fail [%s]", sqlQuery);
1058                 return MSG_ERR_DB_STEP;
1059         }
1060
1061         pDbHandle->finalizeQuery();
1062
1063         return MSG_SUCCESS;
1064 }
1065
1066
1067 msg_error_t MsgStoClearContactInfo(MsgDbHandler *pDbHandle, int contactId)
1068 {
1069         msg_error_t err = MSG_SUCCESS;
1070
1071         char sqlQuery[MAX_QUERY_LEN+1];
1072         int rowCnt = 0;
1073
1074         memset(sqlQuery, 0x00, sizeof(sqlQuery));
1075
1076         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT DISTINCT(CONV_ID) FROM %s WHERE CONTACT_ID = %d;",
1077                         MSGFW_ADDRESS_TABLE_NAME, contactId);
1078
1079         err = pDbHandle->getTable(sqlQuery, &rowCnt);
1080
1081         if (err != MSG_SUCCESS) {
1082                 pDbHandle->freeTable();
1083                 MSG_DEBUG("[Error]Failed to Get Table");
1084                 return err;
1085         }
1086
1087         memset(sqlQuery, 0x00, sizeof(sqlQuery));
1088         snprintf(sqlQuery, sizeof(sqlQuery), "UPDATE %s SET \
1089                         CONTACT_ID = 0, DISPLAY_NAME = '', FIRST_NAME = '', LAST_NAME = '', IMAGE_PATH = '' \
1090                         WHERE CONTACT_ID = %d;",
1091                         MSGFW_ADDRESS_TABLE_NAME, contactId);
1092
1093         if (pDbHandle->execQuery(sqlQuery) != MSG_SUCCESS) {
1094                 MSG_DEBUG("Fail to execute query");
1095                 return MSG_ERR_DB_EXEC;
1096         }
1097
1098         MsgDbHandler tmpDbHandle;
1099         for (int i=1; i<=rowCnt; i++)
1100                 MsgStoSetConversationDisplayName(&tmpDbHandle, (msg_thread_id_t)pDbHandle->getColumnToInt(i));
1101
1102         pDbHandle->freeTable();
1103
1104         return err;
1105 }
1106
1107
1108 msg_error_t MsgStoClearContactInfo(MsgDbHandler *pDbHandle, int contactId, const char *pNumber)
1109 {
1110         char newPhoneNum[MAX_PRECONFIG_NUM+1];
1111         char sqlQuery[MAX_QUERY_LEN+1];
1112
1113         memset(newPhoneNum, 0x00, sizeof(newPhoneNum));
1114         memset(sqlQuery, 0x00, sizeof(sqlQuery));
1115
1116         if (strlen(pNumber) > MAX_PRECONFIG_NUM) {
1117                 MsgConvertNumber(pNumber, newPhoneNum);
1118
1119                 MSG_DEBUG("Phone Number to Compare : [%s]", newPhoneNum);
1120
1121                 snprintf(sqlQuery, sizeof(sqlQuery), "UPDATE %s SET \
1122                                 CONTACT_ID = 0, DISPLAY_NAME = '', FIRST_NAME = '', LAST_NAME = '', IMAGE_PATH = '' \
1123                                 WHERE CONTACT_ID = %d AND ADDRESS_VAL NOT LIKE '%%%s';",
1124                                 MSGFW_ADDRESS_TABLE_NAME, contactId, newPhoneNum);
1125         } else {
1126                 snprintf(sqlQuery, sizeof(sqlQuery), "UPDATE %s SET \
1127                                 CONTACT_ID = 0, DISPLAY_NAME = '', FIRST_NAME = '', LAST_NAME = '', IMAGE_PATH = '' \
1128                                 WHERE CONTACT_ID = %d AND ADDRESS_VAL <> '%s';",
1129                                 MSGFW_ADDRESS_TABLE_NAME, contactId, pNumber);
1130         }
1131
1132         if (pDbHandle->execQuery(sqlQuery) != MSG_SUCCESS) {
1133                 MSG_DEBUG("Fail to execute query");
1134                 return MSG_ERR_DB_EXEC;
1135         }
1136
1137         return MSG_SUCCESS;
1138 }
1139
1140
1141 msg_error_t MsgStoGetMmsRawFilePath(MsgDbHandler *pDbHandle, msg_message_id_t msgId, char *pFilePath)
1142 {
1143         char sqlQuery[MAX_QUERY_LEN+1];
1144
1145         memset(sqlQuery, 0x00, sizeof(sqlQuery));
1146
1147         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT A.FILE_PATH FROM %s A, %s B \
1148                         WHERE A.MSG_ID = B.MSG_ID AND B.MSG_ID = %d;",
1149                         MMS_PLUGIN_MESSAGE_TABLE_NAME, MSGFW_MESSAGE_TABLE_NAME, msgId);
1150
1151         if (pDbHandle->prepareQuery(sqlQuery) != MSG_SUCCESS)
1152                 return MSG_ERR_DB_PREPARE;
1153
1154         if (pDbHandle->stepQuery() == MSG_ERR_DB_ROW) {
1155                 if (pDbHandle->columnText(0) != NULL)
1156                         strncpy(pFilePath, (char*)pDbHandle->columnText(0), MSG_FILEPATH_LEN_MAX);
1157         } else {
1158                 pDbHandle->finalizeQuery();
1159                 return MSG_ERR_DB_STEP;
1160         }
1161
1162         pDbHandle->finalizeQuery();
1163
1164         return MSG_SUCCESS;
1165 }
1166
1167
1168 bool MsgStoCheckReadReportRequested(MsgDbHandler *pDbHandle, msg_message_id_t msgId)
1169 {
1170         msg_error_t err = MSG_SUCCESS;
1171
1172         char sqlQuery[MAX_QUERY_LEN+1];
1173         int rowCnt = 0;
1174         bool bReadReportRequested = false;
1175
1176         memset(sqlQuery, 0x00, sizeof(sqlQuery));
1177
1178         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT A.ASK_READ_REPLY FROM %s A, %s B \
1179                         WHERE A.MSG_ID = B.MSG_ID AND B.MSG_ID = %d;",
1180                         MMS_PLUGIN_MESSAGE_TABLE_NAME, MSGFW_MESSAGE_TABLE_NAME, msgId);
1181
1182         err = pDbHandle->getTable(sqlQuery, &rowCnt);
1183
1184         if (err != MSG_SUCCESS && err != MSG_ERR_DB_NORECORD) {
1185                 pDbHandle->freeTable();
1186                 MSG_DEBUG("[Error]Failed to Get Table");
1187                 return bReadReportRequested;
1188         }
1189
1190         if (rowCnt != 1) {
1191                 pDbHandle->freeTable();
1192                 MSG_DEBUG("[Error]MSG_ERR_DB_NORECORD");
1193                 return bReadReportRequested;
1194         }
1195
1196         bReadReportRequested = pDbHandle->getColumnToInt(1);
1197
1198         pDbHandle->freeTable();
1199
1200         return bReadReportRequested;
1201 }
1202
1203
1204 bool MsgStoCheckReadReportIsSent(MsgDbHandler *pDbHandle, msg_message_id_t msgId)
1205 {
1206         msg_error_t err = MSG_SUCCESS;
1207
1208         char sqlQuery[MAX_QUERY_LEN+1];
1209
1210         int rowCnt = 0;
1211         bool bReadReportIsSent = true;
1212
1213         memset(sqlQuery, 0x00, sizeof(sqlQuery));
1214
1215         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT A.READ_REPORT_SENT FROM %s A, %s B \
1216                         WHERE A.MSG_ID = B.MSG_ID AND B.MSG_ID = %d;",
1217                         MMS_PLUGIN_MESSAGE_TABLE_NAME, MSGFW_MESSAGE_TABLE_NAME, msgId);
1218
1219         err = pDbHandle->getTable(sqlQuery, &rowCnt);
1220
1221         if (err != MSG_SUCCESS && err != MSG_ERR_DB_NORECORD) {
1222                 pDbHandle->freeTable();
1223                 MSG_DEBUG("[Error]Failed to Get Table");
1224                 return bReadReportIsSent;
1225         }
1226
1227         if (rowCnt != 1) {
1228                 pDbHandle->freeTable();
1229                 MSG_DEBUG("[Error]MSG_ERR_DB_NORECORD");
1230                 return bReadReportIsSent;
1231         }
1232
1233         bReadReportIsSent = (bool)pDbHandle->getColumnToInt(1);
1234
1235         pDbHandle->freeTable();
1236
1237         return bReadReportIsSent;
1238 }
1239
1240
1241 msg_error_t MsgStoAddConversation(MsgDbHandler *pDbHandle, msg_thread_id_t *pConvId)
1242 {
1243         char sqlQuery[MAX_QUERY_LEN+1];
1244
1245         if (pDbHandle->getRowId(MSGFW_CONVERSATION_TABLE_NAME, pConvId) != MSG_SUCCESS) {
1246                 return MSG_ERR_DB_EXEC;
1247         }
1248
1249         // Add Conversation
1250         memset(sqlQuery, 0x00, sizeof(sqlQuery));
1251         snprintf(sqlQuery, sizeof(sqlQuery), "INSERT INTO %s VALUES (%d, 0, 0, 0, 0, 0, 0, 0, '', '');",
1252                         MSGFW_CONVERSATION_TABLE_NAME, *pConvId);
1253
1254         if (pDbHandle->execQuery(sqlQuery) != MSG_SUCCESS) {
1255                 MSG_DEBUG("Query Failed. [%s]", sqlQuery);
1256                 return MSG_ERR_DB_EXEC;
1257         }
1258
1259         return MSG_SUCCESS;
1260 }
1261
1262
1263 msg_error_t MsgStoSetConversationDisplayName(MsgDbHandler *pDbHandle, int contactId)
1264 {
1265         msg_error_t err = MSG_SUCCESS;
1266         int rowCnt = 0;
1267         char displayName[MAX_DISPLAY_NAME_LEN+1];
1268         char sqlQuery[MAX_QUERY_LEN+1];
1269
1270         MSG_DEBUG("contactId [%d]", contactId);
1271
1272         memset(sqlQuery, 0x00, sizeof(sqlQuery));
1273         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT DISTINCT(CONV_ID) FROM %s WHERE CONTACT_ID = %d;",
1274                         MSGFW_ADDRESS_TABLE_NAME, contactId);
1275
1276         err = pDbHandle->getTable(sqlQuery, &rowCnt);
1277
1278         if (err != MSG_SUCCESS && err != MSG_ERR_DB_NORECORD) {
1279                 pDbHandle->freeTable();
1280                 MSG_DEBUG("Query Failed [%s]", sqlQuery);
1281                 return err;
1282         }
1283
1284         int order = MsgGetContactNameOrder();
1285         msg_struct_s *pAddrInfo = NULL;
1286         MSG_ADDRESS_INFO_S *address = NULL;
1287
1288         for (int i = 1; i <= rowCnt; i++)
1289         {
1290                 memset(displayName, 0x00, sizeof(displayName));
1291                 MsgDbHandler tmpDbHandle;
1292                 msg_struct_list_s addressList = {0,};
1293                 MsgStoGetAddressByConvId(&tmpDbHandle, (msg_thread_id_t)pDbHandle->getColumnToInt(i), order, &addressList);
1294
1295                 for (int j = 0; j < addressList.nCount; j++)
1296                 {
1297                         if (j >0)
1298                                 strncat(displayName, ", ", MAX_DISPLAY_NAME_LEN-strlen(displayName));
1299
1300                         pAddrInfo = (msg_struct_s *)addressList.msg_struct_info[j];
1301                         address = (MSG_ADDRESS_INFO_S *)pAddrInfo->data;
1302
1303                         if (address->displayName[0] == '\0')
1304                                 strncat(displayName, address->addressVal, MAX_DISPLAY_NAME_LEN-strlen(displayName));
1305                         else
1306                                 strncat(displayName, address->displayName, MAX_DISPLAY_NAME_LEN-strlen(displayName));
1307                 }
1308
1309                 memset(sqlQuery, 0x00, sizeof(sqlQuery));
1310                 snprintf(sqlQuery, sizeof(sqlQuery), "UPDATE %s SET DISPLAY_NAME = ? WHERE CONV_ID = %d;",
1311                                 MSGFW_CONVERSATION_TABLE_NAME, pDbHandle->getColumnToInt(i));
1312
1313                 if (pDbHandle->prepareQuery(sqlQuery) != MSG_SUCCESS) {
1314                         MSG_DEBUG("Query Failed [%s]", sqlQuery);
1315                         return MSG_ERR_DB_PREPARE;
1316                 }
1317
1318                 pDbHandle->bindText(displayName, 1);
1319
1320                 if (pDbHandle->stepQuery() != MSG_ERR_DB_DONE) {
1321                         pDbHandle->finalizeQuery();
1322                         MSG_DEBUG("Update Conversation disply name. Fail [%s]", sqlQuery);
1323                         return MSG_ERR_DB_STEP;
1324                 }
1325
1326                 pDbHandle->finalizeQuery();
1327
1328                 // free address list
1329                 for(int j = 0; j < MAX_TO_ADDRESS_CNT; j++){
1330                         msg_struct_s *pStruct = (msg_struct_s *)addressList.msg_struct_info[j];
1331                         delete [] (MSG_ADDRESS_INFO_S *)pStruct->data;
1332                         delete [] (msg_struct_s *)pStruct;
1333                 }
1334         }
1335
1336         pDbHandle->freeTable();
1337
1338         return err;
1339 }
1340
1341
1342 msg_error_t MsgStoSetConversationDisplayName(MsgDbHandler *pDbHandle, msg_thread_id_t convId)
1343 {
1344         msg_error_t err = MSG_SUCCESS;
1345
1346         char displayName[MAX_DISPLAY_NAME_LEN+1];
1347         char sqlQuery[MAX_QUERY_LEN+1];
1348
1349         msg_struct_list_s addressList = {0,};
1350
1351         int order = MsgGetContactNameOrder();
1352         msg_struct_s *pAddrInfo = NULL;
1353         MSG_ADDRESS_INFO_S *address = NULL;
1354
1355         memset(displayName, 0x00, sizeof(displayName));
1356
1357         MsgStoGetAddressByConvId(pDbHandle, convId, order, &addressList);
1358
1359         for (int j = 0; j < addressList.nCount; j++)
1360         {
1361                 if (j >0)
1362                         strncat(displayName, ", ", MAX_DISPLAY_NAME_LEN-strlen(displayName));
1363
1364                 pAddrInfo = (msg_struct_s *)addressList.msg_struct_info[j];
1365                 address = (MSG_ADDRESS_INFO_S *)pAddrInfo->data;
1366
1367                 if (address->displayName[0] == '\0')
1368                         strncat(displayName, address->addressVal, MAX_DISPLAY_NAME_LEN-strlen(displayName));
1369                 else
1370                         strncat(displayName, address->displayName, MAX_DISPLAY_NAME_LEN-strlen(displayName));
1371         }
1372
1373         memset(sqlQuery, 0x00, sizeof(sqlQuery));
1374         snprintf(sqlQuery, sizeof(sqlQuery), "UPDATE %s SET DISPLAY_NAME = ? WHERE CONV_ID = %d;",
1375                         MSGFW_CONVERSATION_TABLE_NAME, convId);
1376
1377         if (pDbHandle->prepareQuery(sqlQuery) != MSG_SUCCESS) {
1378                 MSG_DEBUG("Query Failed [%s]", sqlQuery);
1379                 return MSG_ERR_DB_PREPARE;
1380         }
1381
1382         pDbHandle->bindText(displayName, 1);
1383
1384         if (pDbHandle->stepQuery() != MSG_ERR_DB_DONE) {
1385                 pDbHandle->finalizeQuery();
1386                 MSG_DEBUG("Update Conversation disply name. Fail [%s]", sqlQuery);
1387                 return MSG_ERR_DB_STEP;
1388         }
1389
1390         pDbHandle->finalizeQuery();
1391
1392         for(int j = 0; j < MAX_TO_ADDRESS_CNT; j++){
1393                 msg_struct_s *pStruct = (msg_struct_s *)addressList.msg_struct_info[j];
1394                 delete [] (MSG_ADDRESS_INFO_S *)pStruct->data;
1395                 delete [] (msg_struct_s *)pStruct;
1396         }
1397
1398         return err;
1399 }
1400
1401 msg_error_t MsgStoUpdateNetworkStatus(MsgDbHandler *pDbHandle, MSG_MESSAGE_INFO_S *pMsgInfo, msg_network_status_t status)
1402 {
1403         msg_error_t err = MSG_SUCCESS;
1404
1405         char sqlQuery[MAX_QUERY_LEN+1];
1406
1407         memset(sqlQuery, 0x00, sizeof(sqlQuery));
1408
1409         snprintf(sqlQuery, sizeof(sqlQuery), "UPDATE %s SET NETWORK_STATUS = %d WHERE MSG_ID = %d;",
1410                         MSGFW_MESSAGE_TABLE_NAME, status, pMsgInfo->msgId);
1411
1412         if (pDbHandle->execQuery(sqlQuery) != MSG_SUCCESS)
1413                 err = MSG_ERR_DB_EXEC;
1414
1415         return err;
1416 }
1417
1418 char *MsgStoReplaceString(const char *origStr, const char *oldStr, const char *newStr)
1419 {
1420         if (origStr == NULL)
1421                 return NULL;
1422
1423         char *replaceStr = NULL;
1424         char *pTemp = NULL;
1425         int i = 0;
1426         int matchedCnt = 0;
1427         int oldStrLen = 0;
1428         int newStrLen = 0;
1429
1430         if (g_strcmp0(oldStr, newStr) != 0) {
1431                 oldStrLen = strlen(oldStr);
1432                 newStrLen = strlen(newStr);
1433
1434                 for (i = 0; origStr[i] != '\0';) {
1435                         if (memcmp(&origStr[i], oldStr, oldStrLen) == 0) {
1436                                 matchedCnt++;
1437                                 i += oldStrLen;
1438                         } else {
1439                                 i++;
1440                         }
1441                 }
1442         } else {
1443                 return g_strdup(origStr);
1444         }
1445
1446         replaceStr = (char *)calloc(1, i + sizeof(char) * (matchedCnt * (newStrLen - oldStrLen) + 1));
1447         if (replaceStr == NULL)
1448                 return NULL;
1449
1450         pTemp = replaceStr;
1451
1452         while (*origStr) {
1453                 if (memcmp(origStr, oldStr, oldStrLen) == 0) {
1454                         memcpy(pTemp, newStr, newStrLen);
1455                         pTemp += newStrLen;
1456                         origStr += oldStrLen;
1457                 } else {
1458                         *pTemp++ = *origStr++;
1459                 }
1460         }
1461
1462         return replaceStr;
1463 }