framework/storage-handler/MsgStorageMessage.cpp

   1 /*
   2 * Copyright 2012-2013  Samsung Electronics Co., Ltd
   3 *
   4 * Licensed under the Flora License, Version 1.1 (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://floralicense.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 <stdio.h>
  18 #include <string.h>
  19 #include <stdlib.h>
  20 #include <tr1/unordered_set>
  21 #include <queue>
  22 #include <locale>
  23 #include <glib.h>
  24
  25 #include "MsgDebug.h"
  26 #include "MsgCppTypes.h"
  27 #include "MsgContact.h"
  28 #include "MsgUtilFile.h"
  29 #include "MsgMutex.h"
  30 #include "MsgUtilStorage.h"
  31 #include "MsgSoundPlayer.h"
  32 #include "MsgGconfWrapper.h"
  33 #include "MsgSqliteWrapper.h"
  34 #include "MsgPluginManager.h"
  35 #include "MsgStorageHandler.h"
  36 #include "MsgNotificationWrapper.h"
  37 #include "MsgMmsMessage.h"
  38
  39 using namespace std;
  40
  41
  42 /*==================================================================================================
  43                                      VARIABLES
  44 ==================================================================================================*/
  45 extern MsgDbHandler dbHandle;
  46
  47 Mutex delNotiMx;
  48 CndVar delNoticv;
  49 bool delNotiRunning = false;
  50
  51 Mutex delLogMx;
  52 CndVar delLogcv;
  53 bool delLogRunning = false;
  54
  55
  56 /*==================================================================================================
  57                                      FUNCTION FOR THREAD
  58 ==================================================================================================*/
  59 static gboolean updateUnreadMsgCount(void *pVoid)
  60 {
  61         MSG_BEGIN();
  62
  63         int smsCnt = 0;
  64         int mmsCnt = 0;
  65
  66         smsCnt = MsgStoGetUnreadCnt(&dbHandle, MSG_SMS_TYPE);
  67         mmsCnt = MsgStoGetUnreadCnt(&dbHandle, MSG_MMS_TYPE);
  68
  69         MsgSettingSetIndicator(smsCnt, mmsCnt);
  70
  71         MSG_END();
  72
  73         return FALSE;
  74 }
  75
  76
  77 /*==================================================================================================
  78                                      FUNCTION IMPLEMENTATION
  79 ==================================================================================================*/
  80 msg_error_t MsgStoAddMessage(MSG_MESSAGE_INFO_S *pMsg, MSG_SENDINGOPT_INFO_S *pSendOptInfo)
  81 {
  82         MSG_BEGIN();
  83
  84         msg_error_t err = MSG_SUCCESS;
  85
  86         unsigned int rowId = 0;
  87         msg_thread_id_t convId = 0;
  88
  89         char sqlQuery[MAX_QUERY_LEN+1];
  90
  91         dbHandle.beginTrans();
  92
  93         if (pMsg->nAddressCnt > 0) {
  94                 err = MsgStoAddAddress(&dbHandle, pMsg, &convId);
  95
  96                 if (err != MSG_SUCCESS) {
  97                         dbHandle.endTrans(false);
  98                         return err;
  99                 }
 100
 101                 pMsg->threadId = convId;
 102         }
 103
 104         err = dbHandle.getRowId(MSGFW_MESSAGE_TABLE_NAME, &rowId);
 105
 106         if (err != MSG_SUCCESS) {
 107                 dbHandle.endTrans(false);
 108                 return err;
 109         }
 110
 111         pMsg->msgId = (msg_message_id_t)rowId;
 112
 113         int fileSize = 0;
 114
 115         char *pFileData = NULL;
 116         AutoPtr<char> buf(&pFileData);
 117
 118         // Get File Data
 119         if (pMsg->bTextSms == false) {
 120                 if (MsgOpenAndReadFile(pMsg->msgData, &pFileData, &fileSize) == false) {
 121                         dbHandle.endTrans(false);
 122                         return MSG_ERR_STORAGE_ERROR;
 123                 }
 124                 MSG_DEBUG("file size [%d]", fileSize);
 125         }
 126
 127         // Add Message
 128         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 129
 130         snprintf(sqlQuery, sizeof(sqlQuery), "INSERT INTO %s VALUES (%d, %d, %d, %d, %d, %d, %ld, %d, %d, %d, %d, %d, %d, %ld, %d, ?, ?, ?, ?, 0);",
 131                         MSGFW_MESSAGE_TABLE_NAME, rowId, convId, pMsg->folderId, pMsg->storageId, pMsg->msgType.mainType, pMsg->msgType.subType,
 132                         pMsg->displayTime, pMsg->dataSize, pMsg->networkStatus, pMsg->bRead, pMsg->bProtected, pMsg->priority, pMsg->direction,
 133                         0, pMsg->bBackup);
 134
 135         MSG_DEBUG("QUERY : %s", sqlQuery);
 136
 137         if (dbHandle.prepareQuery(sqlQuery) != MSG_SUCCESS) {
 138                 dbHandle.endTrans(false);
 139                 return MSG_ERR_DB_EXEC;
 140         }
 141
 142         dbHandle.bindText(pMsg->subject, 1);
 143
 144         dbHandle.bindText(pMsg->msgData, 2);
 145
 146         dbHandle.bindText(pMsg->thumbPath, 3);
 147
 148         if (pMsg->bTextSms == false)
 149                 dbHandle.bindText(pFileData, 4);
 150         else
 151                 dbHandle.bindText(pMsg->msgText, 4);
 152
 153         if (dbHandle.stepQuery() != MSG_ERR_DB_DONE) {
 154                 dbHandle.finalizeQuery();
 155                 dbHandle.endTrans(false);
 156                 return MSG_ERR_DB_EXEC;
 157         }
 158
 159         dbHandle.finalizeQuery();
 160
 161         if (pMsg->msgType.subType != MSG_SENDREQ_MMS) {
 162                 err = MsgStoUpdateConversation(&dbHandle, convId);
 163
 164                 if (err != MSG_SUCCESS) {
 165                         dbHandle.endTrans(false);
 166                         return err;
 167                 }
 168         }
 169
 170         dbHandle.endTrans(true);
 171
 172         /* In the case of MMS Message, load the MMS plugin to save MMS PDU */
 173         if (pMsg->msgType.mainType == MSG_MMS_TYPE) {
 174                 MMS_MESSAGE_DATA_S mmsMsg;
 175                 memset(&mmsMsg, 0x00, sizeof(MMS_MESSAGE_DATA_S));
 176
 177                 if (pMsg->msgType.subType != MSG_DELIVERYIND_MMS && pMsg->msgType.subType != MSG_READORGIND_MMS) {
 178                         MsgPlugin *plg = MsgPluginManager::instance()->getPlugin(MSG_MMS_TYPE);
 179
 180                         err = plg->addMessage(pMsg, pSendOptInfo, pFileData);
 181
 182                         if (err != MSG_SUCCESS)
 183                                 return MSG_ERR_STORAGE_ERROR;
 184
 185                         if (pMsg->msgType.subType == MSG_SENDREQ_MMS) {
 186                                 MSG_DEBUG("pMsg->msgText: %s, pMsg->thumbPath: %s ", pMsg->msgText, pMsg->thumbPath);
 187
 188                                 err = MsgStoUpdateMMSMessage(pMsg);
 189
 190                                 if (err != MSG_SUCCESS)
 191                                         return MSG_ERR_STORAGE_ERROR;
 192
 193                         }
 194                 }
 195         }
 196
 197         MSG_END();
 198
 199         return MSG_SUCCESS;
 200 }
 201
 202
 203 msg_error_t MsgStoUpdateMessage(MSG_MESSAGE_INFO_S *pMsg, MSG_SENDINGOPT_INFO_S *pSendOptInfo)
 204 {
 205         msg_error_t err = MSG_SUCCESS;
 206
 207         char sqlQuery[MAX_QUERY_LEN+1];
 208
 209         msg_thread_id_t convId = 0;
 210
 211         dbHandle.beginTrans();
 212
 213         MSG_MAIN_TYPE_T prevType;
 214         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 215         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT MAIN_TYPE FROM %s WHERE MSG_ID = %d;",
 216                         MSGFW_MESSAGE_TABLE_NAME, pMsg->msgId);
 217
 218         MSG_DEBUG("QUERY : %s", sqlQuery);
 219
 220         if (dbHandle.prepareQuery(sqlQuery) != MSG_SUCCESS) {
 221                 dbHandle.endTrans(false);
 222                 return MSG_ERR_DB_PREPARE;
 223         }
 224
 225         if (dbHandle.stepQuery() != MSG_ERR_DB_ROW) {
 226                 dbHandle.finalizeQuery();
 227                 dbHandle.endTrans(false);
 228                 return MSG_ERR_STORAGE_ERROR;
 229         }
 230
 231         prevType = dbHandle.columnInt(0);
 232         dbHandle.finalizeQuery();
 233
 234         //check msg type with previous type
 235         if (prevType != pMsg->msgType.mainType) {
 236                 MSG_DEBUG("different msg type to update [prev : %d], [current : %d]", prevType, pMsg->msgType.mainType);
 237
 238                 err = MsgStoDeleteMessage(pMsg->msgId, false);
 239                 if (err != MSG_SUCCESS) {
 240                         dbHandle.endTrans(false);
 241                         return err;
 242                 }
 243
 244                 err = MsgStoAddMessage(pMsg, pSendOptInfo);
 245                 if (err != MSG_SUCCESS) {
 246                         dbHandle.endTrans(false);
 247                         return err;
 248                 }
 249
 250                 dbHandle.endTrans(false);
 251                 return err;
 252         }
 253
 254         if (pMsg->nAddressCnt > 0) {
 255                 err = MsgStoAddAddress(&dbHandle, pMsg, &convId);
 256
 257                 if (err != MSG_SUCCESS) {
 258                         dbHandle.endTrans(false);
 259                         return err;
 260                 }
 261         }
 262
 263         int fileSize = 0;
 264
 265         char *pFileData = NULL;
 266         AutoPtr<char> buf(&pFileData);
 267
 268         // Get File Data
 269         if (pMsg->bTextSms == false) {
 270                 if (MsgOpenAndReadFile(pMsg->msgData, &pFileData, &fileSize) == false) {
 271                         dbHandle.endTrans(false);
 272                         return MSG_ERR_STORAGE_ERROR;
 273                 }
 274         }
 275
 276         if (pSendOptInfo != NULL) {
 277                 // Get Global setting value if bSetting == false
 278                 if (pSendOptInfo->bSetting == false) {
 279                         MsgSettingGetBool(MSG_KEEP_COPY, &pSendOptInfo->bKeepCopy);
 280
 281                         if (pMsg->msgType.mainType == MSG_SMS_TYPE) {
 282                                 MsgSettingGetBool(SMS_SEND_DELIVERY_REPORT, &pSendOptInfo->bDeliverReq);
 283                                 MsgSettingGetBool(SMS_SEND_REPLY_PATH, &pSendOptInfo->option.smsSendOptInfo.bReplyPath);
 284                         } else if (pMsg->msgType.mainType == MSG_MMS_TYPE) {
 285                                 MsgSettingGetBool(MMS_SEND_DELIVERY_REPORT, &pSendOptInfo->bDeliverReq);
 286                                 MsgSettingGetBool(MMS_SEND_READ_REPLY, &pSendOptInfo->option.mmsSendOptInfo.bReadReq);
 287                                 pSendOptInfo->option.mmsSendOptInfo.expiryTime.time = (unsigned int)MsgSettingGetInt(MMS_SEND_EXPIRY_TIME);
 288
 289                                 MSG_MMS_DELIVERY_TIME_T deliveryTime = (MSG_MMS_DELIVERY_TIME_T)MsgSettingGetInt(MMS_SEND_DELIVERY_TIME);
 290
 291                                 if (deliveryTime == MSG_DELIVERY_TIME_CUSTOM) {
 292                                         pSendOptInfo->option.mmsSendOptInfo.bUseDeliveryCustomTime = true;
 293                                         pSendOptInfo->option.mmsSendOptInfo.deliveryTime.time = (unsigned int)MsgSettingGetInt(MMS_SEND_CUSTOM_DELIVERY);
 294                                 } else {
 295                                         pSendOptInfo->option.mmsSendOptInfo.bUseDeliveryCustomTime = false;
 296                                         pSendOptInfo->option.mmsSendOptInfo.deliveryTime.time = (unsigned int)deliveryTime;
 297                                 }
 298
 299                                 pSendOptInfo->option.mmsSendOptInfo.priority = (msg_priority_type_t)MsgSettingGetInt(MMS_SEND_PRIORITY);
 300                         }
 301                 }
 302         }
 303
 304         // Update Message
 305         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 306
 307         snprintf(sqlQuery, sizeof(sqlQuery), "UPDATE %s SET CONV_ID = %d, FOLDER_ID = %d, STORAGE_ID = %d, MAIN_TYPE = %d, SUB_TYPE = %d, \
 308                         DISPLAY_TIME = %lu, DATA_SIZE = %d, NETWORK_STATUS = %d, READ_STATUS = %d, PROTECTED = %d, PRIORITY = %d, MSG_DIRECTION = %d, \
 309                         BACKUP = %d, SUBJECT = ?, MSG_DATA = ?, THUMB_PATH = ?, MSG_TEXT = ? \
 310                         WHERE MSG_ID = %d;",
 311                         MSGFW_MESSAGE_TABLE_NAME, convId, pMsg->folderId, pMsg->storageId, pMsg->msgType.mainType, pMsg->msgType.subType, pMsg->displayTime, pMsg->dataSize,
 312                         pMsg->networkStatus, pMsg->bRead, pMsg->bProtected, pMsg->priority, pMsg->direction, pMsg->bBackup, pMsg->msgId);
 313
 314         if (dbHandle.prepareQuery(sqlQuery) != MSG_SUCCESS) {
 315                 dbHandle.endTrans(false);
 316                 return MSG_ERR_DB_EXEC;
 317         }
 318
 319         dbHandle.bindText(pMsg->subject, 1);
 320
 321         dbHandle.bindText(pMsg->msgData, 2);
 322
 323         dbHandle.bindText(pMsg->thumbPath, 3);
 324
 325         if (pMsg->msgType.mainType == MSG_SMS_TYPE && pMsg->bTextSms == false)
 326                 dbHandle.bindText(pFileData, 4);
 327         else
 328                 dbHandle.bindText(pMsg->msgText, 4);
 329
 330         MSG_DEBUG("%s", sqlQuery);
 331
 332         if (dbHandle.stepQuery() != MSG_ERR_DB_DONE) {
 333                 dbHandle.finalizeQuery();
 334                 dbHandle.endTrans(false);
 335                 return MSG_ERR_DB_EXEC;
 336         }
 337
 338         dbHandle.finalizeQuery();
 339
 340         if (pMsg->msgType.mainType == MSG_SMS_TYPE && pSendOptInfo != NULL) {
 341                 if (pSendOptInfo->bSetting == true) {
 342                         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 343                         snprintf(sqlQuery, sizeof(sqlQuery), "UPDATE %s SET \
 344                                         DELREP_REQ = %d, KEEP_COPY = %d, REPLY_PATH = %d \
 345                                         WHERE MSG_ID = %d;",
 346                                         MSGFW_SMS_SENDOPT_TABLE_NAME, pSendOptInfo->bDeliverReq,
 347                                         pSendOptInfo->bKeepCopy, pSendOptInfo->option.smsSendOptInfo.bReplyPath, pMsg->msgId);
 348
 349                         if (dbHandle.execQuery(sqlQuery) != MSG_SUCCESS) {
 350                                 dbHandle.endTrans(false);
 351                                 return MSG_ERR_DB_EXEC;
 352                         }
 353                 }
 354         } else if (pMsg->msgType.mainType == MSG_MMS_TYPE) {
 355                 MsgPlugin *plg = MsgPluginManager::instance()->getPlugin(MSG_MMS_TYPE);
 356
 357                 err = plg->updateMessage(pMsg, pSendOptInfo, pFileData);
 358
 359                 if (err != MSG_SUCCESS) {
 360                         dbHandle.endTrans(false);
 361                         return MSG_ERR_STORAGE_ERROR;
 362                 }
 363
 364                 if (pMsg->msgType.subType == MSG_SENDREQ_MMS) {
 365                         MSG_DEBUG("pMsg->msgText: %s, pMsg->thumbPath: %s ", pMsg->msgText, pMsg->thumbPath);
 366
 367                         err = MsgStoUpdateMMSMessage(pMsg);
 368
 369                         if (err != MSG_SUCCESS) {
 370                                 return MSG_ERR_STORAGE_ERROR;
 371                         }
 372                 }
 373         }
 374
 375         err = MsgStoUpdateConversation(&dbHandle, convId);
 376
 377         if (err != MSG_SUCCESS) {
 378                 dbHandle.endTrans(false);
 379                 return MSG_ERR_STORAGE_ERROR;
 380         }
 381
 382         err = MsgStoClearConversationTable(&dbHandle);
 383
 384         if (err != MSG_SUCCESS) {
 385                 dbHandle.endTrans(false);
 386                 return MSG_ERR_STORAGE_ERROR;
 387         }
 388
 389         dbHandle.endTrans(true);
 390
 391         return MSG_SUCCESS;
 392 }
 393
 394
 395 msg_error_t MsgStoUpdateReadStatus(msg_message_id_t msgId, bool bRead)
 396 {
 397         char sqlQuery[MAX_QUERY_LEN+1];
 398
 399         msg_storage_id_t storageId;
 400
 401         if (MsgStoSetReadStatus(&dbHandle, msgId, bRead) != MSG_SUCCESS) {
 402                 MSG_DEBUG("MsgStoSetReadStatus() Error");
 403                 return MSG_ERR_STORAGE_ERROR;
 404         }
 405
 406         // Get STORAGE_ID
 407         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 408         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT STORAGE_ID FROM %s WHERE MSG_ID = %d;",
 409                         MSGFW_MESSAGE_TABLE_NAME, msgId);
 410
 411         if (dbHandle.prepareQuery(sqlQuery) != MSG_SUCCESS)
 412                 return MSG_ERR_DB_PREPARE;
 413
 414         if (dbHandle.stepQuery() == MSG_ERR_DB_ROW) {
 415                 storageId = dbHandle.columnInt(0);
 416         } else {
 417                 dbHandle.finalizeQuery();
 418                 return MSG_ERR_DB_STEP;
 419         }
 420
 421         dbHandle.finalizeQuery();
 422
 423         MSG_DEBUG("StorageId:[%d]", storageId);
 424
 425         // Update Read Status for SIM Msg
 426         if (storageId == MSG_STORAGE_SIM) {
 427                 MsgPlugin *plg = MsgPluginManager::instance()->getPlugin(MSG_SMS_TYPE);
 428
 429                 if (plg == NULL) {
 430                         MSG_DEBUG("SMS Plug-in is NULL");
 431                         return MSG_ERR_NULL_POINTER;
 432                 }
 433
 434                 // Get SIM Msg ID
 435                 memset(sqlQuery, 0x00, sizeof(sqlQuery));
 436                 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT SIM_ID FROM %s WHERE MSG_ID = %d;",
 437                                 MSGFW_SIM_MSG_TABLE_NAME, msgId);
 438
 439                 if (dbHandle.prepareQuery(sqlQuery) != MSG_SUCCESS)
 440                         return MSG_ERR_DB_PREPARE;
 441
 442                 msg_sim_id_t simId;
 443
 444                 while (dbHandle.stepQuery() == MSG_ERR_DB_ROW) {
 445                         simId = dbHandle.columnInt(0);
 446
 447                         if (plg->setReadStatus(simId) != MSG_SUCCESS) {
 448                                 MSG_DEBUG("Fail to Set Read Status for SIM SMS");
 449                                 continue;
 450                         }
 451                 }
 452
 453                 dbHandle.finalizeQuery();
 454         }
 455
 456         return MSG_SUCCESS;
 457 }
 458
 459
 460 msg_error_t MsgStoUpdateThreadReadStatus(msg_thread_id_t threadId)
 461 {
 462         MSG_BEGIN();
 463
 464         msg_error_t err = MSG_SUCCESS;
 465
 466         int rowCnt = 0;
 467         char sqlQuery[MAX_QUERY_LEN+1];
 468
 469         // Get sim MSG_ID
 470         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 471         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT MSG_ID FROM %s A \
 472                         WHERE CONV_ID = %d AND READ_STATUS = 0 AND STORAGE_ID = %d;",
 473                         MSGFW_MESSAGE_TABLE_NAME, threadId, MSG_STORAGE_SIM);
 474
 475         rowCnt = 0;
 476         err = dbHandle.getTable(sqlQuery, &rowCnt);
 477
 478         if (err != MSG_SUCCESS && err != MSG_ERR_DB_NORECORD) {
 479                 dbHandle.freeTable();
 480                 return err;
 481         }
 482
 483         for (int i = 1; i <= rowCnt; i++) {
 484                 MsgStoUpdateReadStatus(dbHandle.getColumnToInt(i), true);
 485         }
 486
 487         dbHandle.freeTable();
 488
 489         // set read status
 490         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 491         snprintf(sqlQuery, sizeof(sqlQuery), "UPDATE %s SET READ_STATUS = %d \
 492                         WHERE CONV_ID = %d AND READ_STATUS = 0;",
 493                         MSGFW_MESSAGE_TABLE_NAME, 1, threadId);
 494
 495         if (dbHandle.execQuery(sqlQuery) != MSG_SUCCESS)
 496                 return MSG_ERR_DB_EXEC;
 497
 498
 499         if (MsgStoUpdateConversation(&dbHandle, threadId) != MSG_SUCCESS) {
 500                 MSG_DEBUG("MsgStoUpdateConversation() Error");
 501                 return MSG_ERR_STORAGE_ERROR;
 502         }
 503
 504         if (g_idle_add(updateUnreadMsgCount, NULL) == 0) {
 505                 MSG_DEBUG("updateUnreadMsgCount() Error");
 506         }
 507
 508         MsgRefreshNoti(false);
 509
 510         MSG_END();
 511
 512         return MSG_SUCCESS;
 513 }
 514
 515
 516 msg_error_t MsgStoUpdateProtectedStatus(msg_message_id_t msgId, bool bProtected)
 517 {
 518         char sqlQuery[MAX_QUERY_LEN+1];
 519
 520         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 521         snprintf(sqlQuery, sizeof(sqlQuery), "UPDATE %s SET PROTECTED = %d WHERE MSG_ID = %d;",
 522                         MSGFW_MESSAGE_TABLE_NAME, (int)bProtected, msgId);
 523
 524         if (dbHandle.execQuery(sqlQuery) != MSG_SUCCESS)
 525                 return MSG_ERR_DB_EXEC;
 526
 527         return MSG_SUCCESS;
 528 }
 529
 530
 531 msg_error_t MsgStoDeleteMessage(msg_message_id_t msgId, bool bCheckIndication)
 532 {
 533         MSG_BEGIN();
 534
 535         MSG_DEBUG("Msg Id : %d", msgId);
 536
 537         msg_error_t err = MSG_SUCCESS;
 538
 539         char sqlQuery[MAX_QUERY_LEN+1];
 540
 541         // Get SUB_TYPE, STORAGE_ID
 542         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 543         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT MAIN_TYPE, SUB_TYPE, FOLDER_ID, STORAGE_ID, READ_STATUS, CONV_ID \
 544                         FROM %s WHERE MSG_ID = %d;", MSGFW_MESSAGE_TABLE_NAME, msgId);
 545
 546         if (dbHandle.prepareQuery(sqlQuery) != MSG_SUCCESS) {
 547                 MSG_DEBUG("Query Failed [%s]", sqlQuery);
 548                 return MSG_ERR_DB_PREPARE;
 549         }
 550
 551         MSG_MESSAGE_TYPE_S msgType;
 552         msg_folder_id_t folderId;
 553         msg_storage_id_t storageId;
 554         msg_thread_id_t convId;
 555         bool bRead;
 556
 557         if (dbHandle.stepQuery() == MSG_ERR_DB_ROW) {
 558                 msgType.mainType = dbHandle.columnInt(0);
 559                 msgType.subType = dbHandle.columnInt(1);
 560                 folderId = dbHandle.columnInt(2);
 561                 storageId = dbHandle.columnInt(3);
 562                 bRead = dbHandle.columnInt(4);
 563                 convId = dbHandle.columnInt(5);
 564
 565                 MSG_DEBUG("Main Type:[%d] SubType:[%d] FolderId:[%d] StorageId:[%d] ConversationId:[%d]", msgType.mainType, msgType.subType, folderId, storageId, convId);
 566         } else {
 567                 MSG_DEBUG("MsgStepQuery() Error [%s]", sqlQuery);
 568
 569                 dbHandle.finalizeQuery();
 570
 571                 return MSG_ERR_DB_STEP;
 572         }
 573
 574         dbHandle.finalizeQuery();
 575
 576         MsgPlugin *plg = MsgPluginManager::instance()->getPlugin(MSG_SMS_TYPE);
 577
 578         if (plg == NULL) {
 579                 MSG_DEBUG("SMS Plug-in is NULL");
 580
 581                 return MSG_ERR_NULL_POINTER;
 582         }
 583
 584         dbHandle.beginTrans();
 585
 586         // Check sim message
 587         if (storageId == MSG_STORAGE_SIM) {
 588                 // get sim message id
 589                 memset(sqlQuery, 0x00, sizeof(sqlQuery));
 590                 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT SIM_ID FROM %s WHERE MSG_ID = %d;",
 591                                 MSGFW_SIM_MSG_TABLE_NAME, msgId);
 592
 593                 MSG_DEBUG("sqlQuery is [%s]", sqlQuery);
 594
 595                 msg_sim_id_t simMsgId;
 596
 597                 if (dbHandle.prepareQuery(sqlQuery) != MSG_SUCCESS) {
 598                         dbHandle.endTrans(false);
 599                         return MSG_ERR_DB_PREPARE;
 600                 }
 601
 602                 while (dbHandle.stepQuery() == MSG_ERR_DB_ROW) {
 603                         simMsgId = dbHandle.columnInt(0);
 604
 605                         MSG_DEBUG("SIM Msg Id : [%d]", simMsgId);
 606
 607                         err = plg->deleteSimMessage(simMsgId);
 608
 609                         if (err != MSG_SUCCESS) {
 610                                 dbHandle.finalizeQuery();
 611                                 dbHandle.endTrans(false);
 612                                 return err;
 613                         }
 614
 615                         //Sim message delete in db table
 616                         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 617                         snprintf(sqlQuery, sizeof(sqlQuery), "DELETE FROM %s WHERE SIM_ID = %d;", MSGFW_SIM_MSG_TABLE_NAME, simMsgId);
 618
 619                         if (dbHandle.execQuery(sqlQuery) != MSG_SUCCESS) {
 620                                 dbHandle.finalizeQuery();
 621                                 dbHandle.endTrans(false);
 622                                 return MSG_ERR_DB_EXEC;
 623                         }
 624                 }
 625
 626                 dbHandle.finalizeQuery();
 627         }
 628
 629         /* each type has to be handled in plug in ? */
 630         if (msgType.mainType == MSG_SMS_TYPE) {
 631                 memset(sqlQuery, 0x00, sizeof(sqlQuery));
 632                 snprintf(sqlQuery, sizeof(sqlQuery), "DELETE FROM %s WHERE MSG_ID = %d;",
 633                                 MSGFW_SMS_SENDOPT_TABLE_NAME, msgId);
 634
 635                 // Delete SMS Send Option
 636                 if (dbHandle.execQuery(sqlQuery) != MSG_SUCCESS) {
 637                         dbHandle.endTrans(false);
 638                         return MSG_ERR_DB_EXEC;
 639                 }
 640
 641                 if (msgType.subType == MSG_CB_SMS || msgType.subType == MSG_JAVACB_SMS) {
 642                         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 643                         snprintf(sqlQuery, sizeof(sqlQuery), "DELETE FROM %s WHERE MSG_ID = %d;",
 644                                         MSGFW_CB_MSG_TABLE_NAME, msgId);
 645
 646                         // Delete Push Message from push table
 647                         if (dbHandle.execQuery(sqlQuery) != MSG_SUCCESS) {
 648                                 dbHandle.endTrans(false);
 649                                 return MSG_ERR_DB_EXEC;
 650                         }
 651                 } else if (msgType.subType >= MSG_WAP_SI_SMS && msgType.subType <= MSG_WAP_CO_SMS) {
 652                         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 653                         snprintf(sqlQuery, sizeof(sqlQuery), "DELETE FROM %s WHERE MSG_ID = %d;",
 654                                         MSGFW_PUSH_MSG_TABLE_NAME, msgId);
 655
 656                         // Delete Push Message from push table
 657                         if (dbHandle.execQuery(sqlQuery) != MSG_SUCCESS) {
 658                                 dbHandle.endTrans(false);
 659                                 return MSG_ERR_DB_EXEC;
 660                         }
 661                 } else if (msgType.subType == MSG_SYNCML_CP) {
 662                         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 663                         snprintf(sqlQuery, sizeof(sqlQuery), "DELETE FROM %s WHERE MSG_ID = %d;",
 664                                         MSGFW_SYNCML_MSG_TABLE_NAME, msgId);
 665
 666                         // Delete SyncML Message from syncML table
 667                         if (dbHandle.execQuery(sqlQuery) != MSG_SUCCESS) {
 668                                 dbHandle.endTrans(false);
 669                                 return MSG_ERR_DB_EXEC;
 670                         }
 671                 }
 672         } else if (msgType.mainType == MSG_MMS_TYPE) {
 673
 674                 char filePath[MSG_FILEPATH_LEN_MAX] = {0,};
 675                 char dirPath[MSG_FILEPATH_LEN_MAX]= {0,};
 676
 677                 memset(sqlQuery, 0x00, sizeof(sqlQuery));
 678                 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT FILE_PATH FROM %s WHERE MSG_ID = %d;",
 679                                 MMS_PLUGIN_MESSAGE_TABLE_NAME, msgId);
 680
 681                 if (dbHandle.prepareQuery(sqlQuery) != MSG_SUCCESS) {
 682                         dbHandle.endTrans(false);
 683                         return MSG_ERR_DB_PREPARE;
 684                 }
 685
 686                 if (dbHandle.stepQuery() == MSG_ERR_DB_ROW) {
 687                         strncpy(filePath, (char *)dbHandle.columnText(0), MSG_FILEPATH_LEN_MAX);
 688
 689                         snprintf(dirPath, MSG_FILEPATH_LEN_MAX, "%s.dir", filePath);
 690
 691                         if (remove(filePath) == -1)
 692                                 MSG_DEBUG("Fail to delete file [%s]", filePath);
 693                         else
 694                                 MSG_DEBUG("Success to delete file [%s]", filePath);
 695
 696                         MsgRmRf(dirPath);
 697
 698                         rmdir(dirPath);
 699
 700                 } else {
 701                         MSG_DEBUG("MsgStepQuery() Error [%s]", sqlQuery);
 702                         dbHandle.finalizeQuery();
 703                         dbHandle.endTrans(false);
 704                         return MSG_ERR_DB_STEP;
 705                 }
 706
 707                 dbHandle.finalizeQuery();
 708
 709                 // remove thumbnail file
 710                 memset(sqlQuery, 0x00, sizeof(sqlQuery));
 711                 snprintf(sqlQuery, sizeof(sqlQuery),
 712                                 "SELECT VALUE FROM %s "
 713                                 "WHERE MSG_ID = %d AND (TYPE=%d OR TYPE=%d);",
 714                                 MSGFW_MMS_PREVIEW_TABLE_NAME, msgId, MSG_MMS_ITEM_TYPE_IMG, MSG_MMS_ITEM_TYPE_VIDEO);
 715
 716                 if (dbHandle.prepareQuery(sqlQuery) != MSG_SUCCESS) {
 717                         dbHandle.endTrans(false);
 718                         return MSG_ERR_DB_PREPARE;
 719                 }
 720
 721                 while (dbHandle.stepQuery() == MSG_ERR_DB_ROW) {
 722                         memset(filePath, 0x00, sizeof(filePath));
 723                         strncpy(filePath, (char *)dbHandle.columnText(0), MSG_FILEPATH_LEN_MAX);
 724                         if (remove(filePath) == -1)
 725                                 MSG_DEBUG("Fail to delete file [%s]", filePath);
 726                         else
 727                                 MSG_DEBUG("Success to delete file [%s]", filePath);
 728                 }
 729
 730                 dbHandle.finalizeQuery();
 731
 732                 memset(sqlQuery, 0x00, sizeof(sqlQuery));
 733                 snprintf(sqlQuery, sizeof(sqlQuery), "DELETE FROM %s WHERE MSG_ID = %d;",
 734                                 MSGFW_MMS_PREVIEW_TABLE_NAME, msgId);
 735
 736                 if (dbHandle.execQuery(sqlQuery) != MSG_SUCCESS) {
 737                         dbHandle.endTrans(false);
 738                         return MSG_ERR_DB_EXEC;
 739                 }
 740
 741                 memset(sqlQuery, 0x00, sizeof(sqlQuery));
 742                 snprintf(sqlQuery, sizeof(sqlQuery), "DELETE FROM %s WHERE MSG_ID = %d;",
 743                                 MMS_PLUGIN_MESSAGE_TABLE_NAME, msgId);
 744
 745                 // Delete Data from MMS table
 746                 if (dbHandle.execQuery(sqlQuery) != MSG_SUCCESS) {
 747                         dbHandle.endTrans(false);
 748                         return MSG_ERR_DB_EXEC;
 749                 }
 750
 751                 memset(sqlQuery, 0x00, sizeof(sqlQuery));
 752                 snprintf(sqlQuery, sizeof(sqlQuery), "DELETE FROM %s WHERE MSG_ID = %d;",
 753                                 MSGFW_REPORT_TABLE_NAME, msgId);
 754
 755                 // Delete Data from MMS STATUS table
 756                 if (dbHandle.execQuery(sqlQuery) != MSG_SUCCESS) {
 757                         dbHandle.endTrans(false);
 758                         return MSG_ERR_DB_EXEC;
 759                 }
 760         }
 761
 762         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 763         snprintf(sqlQuery, sizeof(sqlQuery), "DELETE FROM %s WHERE MSG_ID = %d;", MSGFW_MESSAGE_TABLE_NAME, msgId);
 764
 765         // Delete Message from msg table
 766         if (dbHandle.execQuery(sqlQuery) != MSG_SUCCESS) {
 767                 dbHandle.endTrans(false);
 768                 return MSG_ERR_DB_EXEC;
 769         }
 770
 771         if (convId > 0) {
 772                 // Clear Conversation table
 773                 if (MsgStoClearConversationTable(&dbHandle) != MSG_SUCCESS) {
 774                         dbHandle.endTrans(false);
 775                         return MSG_ERR_DB_EXEC;
 776                 }
 777
 778                 // Update conversation table.
 779                 if (MsgStoUpdateConversation(&dbHandle, convId) != MSG_SUCCESS) {
 780                         dbHandle.endTrans(false);
 781                         return MSG_ERR_STORAGE_ERROR;
 782                 }
 783         }
 784         dbHandle.endTrans(true);
 785
 786         if (msgType.mainType == MSG_SMS_TYPE && folderId == MSG_INBOX_ID) {
 787                 msgType.classType = MSG_CLASS_NONE;
 788
 789                 // Set memory status in SIM
 790                 if (MsgStoCheckMsgCntFull(&dbHandle, &msgType, folderId) == MSG_SUCCESS) {
 791                         MSG_DEBUG("Set Memory Status");
 792
 793                         plg->setMemoryStatus(MSG_SUCCESS);
 794                 }
 795         }
 796
 797         if (bCheckIndication == true) {
 798                 MSG_DEBUG("bCheckIndication is true.");
 799
 800                 int smsCnt = 0;
 801                 int mmsCnt = 0;
 802
 803                 smsCnt = MsgStoGetUnreadCnt(&dbHandle, MSG_SMS_TYPE);
 804                 mmsCnt = MsgStoGetUnreadCnt(&dbHandle, MSG_MMS_TYPE);
 805
 806                 MsgSettingSetIndicator(smsCnt, mmsCnt);
 807
 808                 MsgRefreshNoti(false);
 809         }
 810
 811         return MSG_SUCCESS;
 812 }
 813
 814
 815 msg_error_t MsgStoDeleteAllMessageInFolder(msg_folder_id_t folderId, bool bOnlyDB, msg_id_list_s *pMsgIdList)
 816 {
 817         msg_error_t err = MSG_SUCCESS;
 818
 819         char sqlQuery[MAX_QUERY_LEN+1];
 820
 821         queue<msg_thread_id_t> threadList;
 822
 823         const char *tableList[] = {MSGFW_PUSH_MSG_TABLE_NAME, MSGFW_CB_MSG_TABLE_NAME,
 824                                                 MSGFW_SYNCML_MSG_TABLE_NAME, MSGFW_SMS_SENDOPT_TABLE_NAME,
 825                                                 MMS_PLUGIN_MESSAGE_TABLE_NAME, MSGFW_MMS_PREVIEW_TABLE_NAME,
 826                                                 MSGFW_REPORT_TABLE_NAME, MSGFW_MESSAGE_TABLE_NAME};
 827
 828         int listCnt = sizeof(tableList)/sizeof(char *);
 829         int rowCnt = 0;
 830
 831         // Get conversation ID from Folder
 832         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 833
 834         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT DISTINCT(CONV_ID) FROM %s WHERE FOLDER_ID = %d",
 835                         MSGFW_MESSAGE_TABLE_NAME, folderId);
 836
 837         err = dbHandle.getTable(sqlQuery, &rowCnt);
 838
 839         if (err != MSG_SUCCESS && err != MSG_ERR_DB_NORECORD) {
 840                 MSG_DEBUG("sql query is %s.", sqlQuery);
 841
 842                 dbHandle.freeTable();
 843                 return err;
 844         }
 845
 846         if (rowCnt <= 0) {
 847                 dbHandle.freeTable();
 848
 849                 return MSG_SUCCESS;
 850         }
 851
 852         for (int i = 1; i <= rowCnt; i++) {
 853                 MSG_DEBUG("thread ID : %d", dbHandle.getColumnToInt(i));
 854                 threadList.push((msg_thread_id_t)dbHandle.getColumnToInt(i));
 855         }
 856
 857         dbHandle.freeTable();
 858
 859         /*** Get msg id list **/
 860         msg_id_list_s *pToDeleteMsgIdList = NULL;
 861         pToDeleteMsgIdList = (msg_id_list_s *)new char[sizeof(msg_id_list_s)];
 862         if (pToDeleteMsgIdList == NULL) {
 863                 MSG_DEBUG("pToDeleteMsgIdList is NULL.");
 864                 return MSG_ERR_NULL_POINTER;
 865         }
 866         memset(pToDeleteMsgIdList, 0x00, sizeof(msg_id_list_s));
 867
 868         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 869         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT MSG_ID FROM %s WHERE FOLDER_ID = %d",
 870                         MSGFW_MESSAGE_TABLE_NAME, folderId);
 871
 872         rowCnt = 0;
 873         int index = 1;
 874
 875         err = dbHandle.getTable(sqlQuery, &rowCnt);
 876
 877         if (err != MSG_SUCCESS && err != MSG_ERR_DB_NORECORD) {
 878                 MSG_DEBUG("sqlQuery [%s]", sqlQuery);
 879
 880                 dbHandle.freeTable();
 881
 882                 goto FREE_MEMORY;
 883         }
 884
 885         if (rowCnt <= 0) {
 886                 dbHandle.freeTable();
 887                 err = MSG_SUCCESS;
 888
 889                 goto FREE_MEMORY;
 890         }
 891
 892         pToDeleteMsgIdList->nCount = rowCnt;
 893
 894         MSG_DEBUG("pToDeleteMsgIdList->nCount [%d]", pToDeleteMsgIdList->nCount);
 895
 896         pToDeleteMsgIdList->msgIdList = (msg_message_id_t *)new char[sizeof(msg_message_id_t) * rowCnt];
 897
 898         for (int i = 0; i < rowCnt; i++)
 899                 pToDeleteMsgIdList->msgIdList[i] = dbHandle.getColumnToInt(index++);
 900
 901         dbHandle.freeTable();
 902         /*** **/
 903
 904         /*** Delete Sim Message In Folder **/
 905         if (folderId >= MSG_INBOX_ID) {
 906                 memset(sqlQuery, 0x00, sizeof(sqlQuery));
 907
 908                 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT MSG_ID FROM %s WHERE FOLDER_ID = %d AND STORAGE_ID = %d",
 909                                 MSGFW_MESSAGE_TABLE_NAME, folderId, MSG_STORAGE_SIM);
 910
 911                 MSG_DEBUG("sql query is %s.", sqlQuery);
 912
 913                 rowCnt = 0;
 914
 915                 err = dbHandle.getTable(sqlQuery, &rowCnt);
 916
 917                 if (err != MSG_SUCCESS && err != MSG_ERR_DB_NORECORD) {
 918                         dbHandle.freeTable();
 919
 920                         goto FREE_MEMORY;
 921                 }
 922
 923                 for (int i = 1; i <= rowCnt; i++) {
 924                         err = MsgStoDeleteMessage(dbHandle.getColumnToInt(i), false);
 925
 926                         if (err != MSG_SUCCESS) {
 927                                 MSG_DEBUG("MsgStoDeleteMessage() Error!!!");
 928
 929                                 dbHandle.freeTable();
 930
 931                                 goto FREE_MEMORY;
 932                         }
 933
 934                         //Delete phone log
 935 //                      MsgDeletePhoneLog(dbHandle.getColumnToInt(i));
 936                 }
 937
 938                 dbHandle.freeTable();
 939         }
 940
 941         dbHandle.beginTrans();
 942
 943         for (int i = 0; i < listCnt; i++) {
 944                 if (!strcmp(tableList[i], MMS_PLUGIN_MESSAGE_TABLE_NAME)) {
 945
 946                         int rowCnt = 0;
 947
 948                         char filePath[MSG_FILEPATH_LEN_MAX] = {0,};
 949                         char dirPath[MSG_FILEPATH_LEN_MAX] = {0,};
 950
 951                         //get mms msg id list
 952                         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 953                         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT B.FILE_PATH FROM %s A, %s B \
 954                                         WHERE A.FOLDER_ID = %d AND A.MAIN_TYPE = %d AND A.MSG_ID = B.MSG_ID",
 955                                         MSGFW_MESSAGE_TABLE_NAME, MMS_PLUGIN_MESSAGE_TABLE_NAME, folderId, MSG_MMS_TYPE);
 956
 957                         MSG_DEBUG("sqlQuery [%s]", sqlQuery);
 958
 959                         err = dbHandle.getTable(sqlQuery, &rowCnt);
 960                         MSG_DEBUG("rowCnt %d", rowCnt);
 961
 962                         if (err != MSG_SUCCESS && err != MSG_ERR_DB_NORECORD) {
 963                                 MSG_DEBUG("sqlQuery [%s]", sqlQuery);
 964
 965                                 dbHandle.freeTable();
 966                                 dbHandle.endTrans(false);
 967
 968                                 goto FREE_MEMORY;
 969                         }
 970
 971                         for (int i = 1; i <= rowCnt; i++) {
 972
 973                                 memset(filePath, 0x00, sizeof(filePath));
 974                                 dbHandle.getColumnToString(i, MSG_FILEPATH_LEN_MAX, filePath);
 975
 976                                 MSG_DEBUG("filePath [%s]", filePath);
 977
 978                                 //delete raw file
 979                                 snprintf(dirPath, sizeof(dirPath), "%s.dir", filePath);
 980
 981                                 if (remove(filePath) == -1)
 982                                         MSG_DEBUG("Fail to delete file [%s]", filePath);
 983                                 else
 984                                         MSG_DEBUG("Success to delete file [%s]", filePath);
 985
 986                                 MsgRmRf(dirPath);
 987
 988                                 rmdir(dirPath);
 989
 990                         }
 991
 992                         dbHandle.freeTable();
 993                 }
 994
 995                 // delete thumbnail
 996                 char filePath[MSG_FILEPATH_LEN_MAX] = {0,};
 997                 memset(sqlQuery, 0x00, sizeof(sqlQuery));
 998                 snprintf(sqlQuery, sizeof(sqlQuery),
 999                                 "SELECT VALUE FROM %s "
1000                                 "WHERE (TYPE=%d OR TYPE=%d) "
1001                                 "AND (MSG_ID IN (SELECT MSG_ID FROM %s WHERE FOLDER_ID = %d));",
1002                                 MSGFW_MMS_PREVIEW_TABLE_NAME, MSG_MMS_ITEM_TYPE_IMG, MSG_MMS_ITEM_TYPE_VIDEO, MSGFW_MESSAGE_TABLE_NAME, folderId);
1003
1004                 if (dbHandle.prepareQuery(sqlQuery) != MSG_SUCCESS) {
1005                         dbHandle.endTrans(false);
1006                         return MSG_ERR_DB_PREPARE;
1007                 }
1008
1009                 while (dbHandle.stepQuery() == MSG_ERR_DB_ROW) {
1010                         memset(filePath, 0x00, sizeof(filePath));
1011                         strncpy(filePath, (char *)dbHandle.columnText(0), MSG_FILEPATH_LEN_MAX);
1012                         if (remove(filePath) == -1)
1013                                 MSG_DEBUG("Fail to delete file [%s]", filePath);
1014                         else
1015                                 MSG_DEBUG("Success to delete file [%s]", filePath);
1016                 }
1017
1018                 dbHandle.finalizeQuery();
1019
1020                 memset(sqlQuery, 0x00, sizeof(sqlQuery));
1021
1022                 snprintf(sqlQuery, sizeof(sqlQuery), "DELETE FROM %s WHERE MSG_ID IN \
1023                                 (SELECT MSG_ID FROM %s WHERE FOLDER_ID = %d);",
1024                                 tableList[i], MSGFW_MESSAGE_TABLE_NAME, folderId);
1025
1026                 // Delete Message in specific folder from table
1027                 if (dbHandle.execQuery(sqlQuery) != MSG_SUCCESS) {
1028                         MSG_DEBUG("sqlQuery [%s]", sqlQuery);
1029                         dbHandle.endTrans(false);
1030                         err = MSG_ERR_DB_EXEC;
1031
1032                         goto FREE_MEMORY;
1033                 }
1034         }
1035
1036         // Clear Conversation table
1037         if (MsgStoClearConversationTable(&dbHandle) != MSG_SUCCESS) {
1038                 dbHandle.endTrans(false);
1039                 err = MSG_ERR_DB_EXEC;
1040
1041                 goto FREE_MEMORY;
1042         }
1043
1044         // Update Address
1045         while (!threadList.empty()) {
1046                 err = MsgStoUpdateConversation(&dbHandle, threadList.front());
1047
1048                 threadList.pop();
1049
1050                 if (err != MSG_SUCCESS) {
1051                         dbHandle.endTrans(false);
1052
1053                         goto FREE_MEMORY;
1054                 }
1055         }
1056
1057         dbHandle.endTrans(true);
1058
1059         if (folderId == MSG_INBOX_ID) {
1060                 int smsCnt = 0;
1061                 int mmsCnt = 0;
1062
1063                 smsCnt = MsgStoGetUnreadCnt(&dbHandle, MSG_SMS_TYPE);
1064                 mmsCnt = MsgStoGetUnreadCnt(&dbHandle, MSG_MMS_TYPE);
1065
1066                 MsgSettingSetIndicator(smsCnt, mmsCnt);
1067         }
1068
1069 /*** Set pMsgIdList **/
1070         if (pMsgIdList != NULL && pToDeleteMsgIdList->nCount > 0) {
1071                 pMsgIdList->nCount = pToDeleteMsgIdList->nCount;
1072
1073                 pMsgIdList->msgIdList = (msg_message_id_t *)new char[sizeof(msg_message_id_t)*pToDeleteMsgIdList->nCount];
1074                 memcpy(pMsgIdList->msgIdList, pToDeleteMsgIdList->msgIdList, sizeof(msg_message_id_t)*pToDeleteMsgIdList->nCount);
1075         }
1076 /*** **/
1077
1078 /*** Create thread  for noti and phone log delete. **/
1079         if (!bOnlyDB) {
1080                 if (pToDeleteMsgIdList->nCount > 0) {
1081 //                      if (g_idle_add(startToDeletePhoneLog, (void *)pToDeleteMsgIdList) == 0) {
1082 //                              MSG_DEBUG("startToDeletePhoneLog not invoked: %s", strerror(errno));
1083                                 // memory free
1084                                 if (pToDeleteMsgIdList != NULL) {
1085                                         //free peer info list
1086                                         if (pToDeleteMsgIdList->msgIdList != NULL)
1087                                                 delete [] pToDeleteMsgIdList->msgIdList;
1088
1089                                         delete [] pToDeleteMsgIdList;
1090                                 }
1091 //                              err = MSG_ERR_UNKNOWN;
1092 //                      }
1093
1094                         MsgRefreshNoti(false);
1095                 }
1096         }
1097 /*** **/
1098
1099         return MSG_SUCCESS;
1100
1101 FREE_MEMORY:
1102         MSG_DEBUG("Error case Free Memory");
1103
1104         while (!threadList.empty()) {
1105                 threadList.front();
1106                 threadList.pop();
1107         }
1108
1109         // memory free
1110         if (pToDeleteMsgIdList != NULL) {
1111                 //free peer info list
1112                 if (pToDeleteMsgIdList->msgIdList != NULL)
1113                         delete [] pToDeleteMsgIdList->msgIdList;
1114
1115                 delete [] pToDeleteMsgIdList;
1116         }
1117
1118         return err;
1119
1120 }
1121
1122
1123 msg_error_t MsgStoDeleteMessageByList(msg_id_list_s *pMsgIdList)
1124 {
1125         MSG_BEGIN();
1126         msg_error_t err = MSG_SUCCESS;
1127
1128         char sqlQuery[MAX_QUERY_LEN+1];
1129         char whereQuery[MAX_QUERY_LEN+1];
1130         char sqlQuerySubset[(MAX_QUERY_LEN/5)+1];
1131
1132         queue<msg_thread_id_t> threadList;
1133
1134         const char *tableList[] = {MSGFW_PUSH_MSG_TABLE_NAME, MSGFW_CB_MSG_TABLE_NAME,
1135                                                 MSGFW_SYNCML_MSG_TABLE_NAME, MSGFW_SMS_SENDOPT_TABLE_NAME,
1136                                                 MSGFW_MMS_PREVIEW_TABLE_NAME, MSGFW_REPORT_TABLE_NAME,
1137                                                 MMS_PLUGIN_MESSAGE_TABLE_NAME,  MSGFW_MESSAGE_TABLE_NAME};
1138
1139         int listCnt = sizeof(tableList)/sizeof(char *);
1140         int rowCnt = 0;
1141
1142         memset(whereQuery, 0x00, sizeof(whereQuery));
1143
1144         if (pMsgIdList->nCount < 1) {
1145                 return MSG_SUCCESS;
1146         } else {
1147                 for (int i=0; i < pMsgIdList->nCount; i++) {
1148                         memset(sqlQuerySubset, 0x00, sizeof(sqlQuerySubset));
1149                         if (i==0)
1150                                 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "(MSG_ID = %d ", pMsgIdList->msgIdList[i]);
1151                         else
1152                                 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "OR MSG_ID = %d ", pMsgIdList->msgIdList[i]);
1153                         strncat(whereQuery, sqlQuerySubset, MAX_QUERY_LEN-strlen(whereQuery));
1154                 }
1155         }
1156         strncat(whereQuery, ");", MAX_QUERY_LEN-strlen(whereQuery));
1157
1158         // Get conversation ID from Folder
1159         memset(sqlQuery, 0x00, sizeof(sqlQuery));
1160         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT DISTINCT(CONV_ID) FROM %s WHERE ", MSGFW_MESSAGE_TABLE_NAME);
1161         strncat(sqlQuery, whereQuery, MAX_QUERY_LEN-strlen(sqlQuery));
1162
1163         err = dbHandle.getTable(sqlQuery, &rowCnt);
1164
1165         if (err != MSG_SUCCESS && err != MSG_ERR_DB_NORECORD) {
1166                 MSG_DEBUG("sql query is %s.", sqlQuery);
1167                 dbHandle.freeTable();
1168                 return err;
1169         }
1170
1171         if (rowCnt <= 0) {
1172                 dbHandle.freeTable();
1173                 return MSG_SUCCESS;
1174         }
1175
1176         for (int i = 1; i <= rowCnt; i++) {
1177                 MSG_DEBUG("thread ID : %d", dbHandle.getColumnToInt(i));
1178                 threadList.push((msg_thread_id_t)dbHandle.getColumnToInt(i));
1179         }
1180
1181         dbHandle.freeTable();
1182
1183         /*** Delete Sim Message In Folder **/
1184         memset(sqlQuery, 0x00, sizeof(sqlQuery));
1185         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT MSG_ID FROM %s WHERE STORAGE_ID = %d AND ", MSGFW_MESSAGE_TABLE_NAME, MSG_STORAGE_SIM);
1186         strncat(sqlQuery, whereQuery, MAX_QUERY_LEN-strlen(sqlQuery));
1187
1188         rowCnt = 0;
1189
1190         err = dbHandle.getTable(sqlQuery, &rowCnt);
1191
1192         if (err != MSG_SUCCESS && err != MSG_ERR_DB_NORECORD) {
1193                 MSG_DEBUG("sql query is %s.", sqlQuery);
1194                 dbHandle.freeTable();
1195                 return err;
1196         }
1197
1198         for (int i = 1; i <= rowCnt; i++) {
1199                 err = MsgStoDeleteMessage(dbHandle.getColumnToInt(i), false);
1200
1201                 if (err != MSG_SUCCESS) {
1202                         MSG_DEBUG("MsgStoDeleteMessage() Error!!!");
1203                         dbHandle.freeTable();
1204                         return err;
1205                 }
1206         }
1207
1208         dbHandle.freeTable();
1209         /*** **/
1210
1211         dbHandle.beginTrans();
1212
1213         for (int i = 0; i < listCnt; i++) {
1214                 if (!strcmp(tableList[i], MMS_PLUGIN_MESSAGE_TABLE_NAME)) {
1215
1216                         int rowCnt = 0;
1217
1218                         char filePath[MSG_FILEPATH_LEN_MAX] = {0,};
1219                         char dirPath[MSG_FILEPATH_LEN_MAX] = {0,};
1220 //                      char thumbnailPath[MSG_FILEPATH_LEN_MAX] = {0,};
1221
1222                         //get mms msg id list
1223                         memset(sqlQuery, 0x00, sizeof(sqlQuery));
1224                         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT FILE_PATH FROM %s WHERE ", MMS_PLUGIN_MESSAGE_TABLE_NAME);
1225                         strncat(sqlQuery, whereQuery, MAX_QUERY_LEN-strlen(sqlQuery));
1226
1227                         err = dbHandle.getTable(sqlQuery, &rowCnt);
1228                         MSG_DEBUG("rowCnt %d", rowCnt);
1229
1230                         if (err != MSG_SUCCESS && err != MSG_ERR_DB_NORECORD) {
1231                                 MSG_DEBUG("sqlQuery [%s]", sqlQuery);
1232                                 dbHandle.freeTable();
1233                                 dbHandle.endTrans(false);
1234                                 return err;
1235                         }
1236
1237                         for (int i = 1; i <= rowCnt; i++) {
1238                                 memset(filePath, 0x00, sizeof(filePath));
1239                                 dbHandle.getColumnToString(i, MSG_FILEPATH_LEN_MAX, filePath);
1240
1241                                 MSG_DEBUG("filePath [%s]", filePath);
1242
1243                                 //delete raw file
1244                                 snprintf(dirPath, sizeof(dirPath), "%s.dir", filePath);
1245
1246                                 if (remove(filePath) == -1)
1247                                         MSG_DEBUG("Fail to delete file [%s]", filePath);
1248                                 else
1249                                         MSG_DEBUG("Success to delete file [%s]", filePath);
1250
1251                                 MsgRmRf(dirPath);
1252
1253                                 rmdir(dirPath);
1254                         }
1255
1256                         dbHandle.freeTable();
1257                 } else if (!strcmp(tableList[i], MSGFW_MMS_PREVIEW_TABLE_NAME)) {
1258                         char filePath[MSG_FILEPATH_LEN_MAX] = {0,};
1259                         memset(sqlQuery, 0x00, sizeof(sqlQuery));
1260                         snprintf(sqlQuery, sizeof(sqlQuery),
1261                                         "SELECT VALUE FROM %s "
1262                                         "WHERE (TYPE=%d OR TYPE=%d) "
1263                                         "AND ",
1264                                         MSGFW_MMS_PREVIEW_TABLE_NAME, MSG_MMS_ITEM_TYPE_IMG, MSG_MMS_ITEM_TYPE_VIDEO);
1265
1266                         strncat(sqlQuery, whereQuery, MAX_QUERY_LEN-strlen(sqlQuery));
1267
1268                         if (dbHandle.prepareQuery(sqlQuery) != MSG_SUCCESS) {
1269                                 dbHandle.endTrans(false);
1270                                 return MSG_ERR_DB_PREPARE;
1271                         }
1272
1273                         while (dbHandle.stepQuery() == MSG_ERR_DB_ROW) {
1274                                 memset(filePath, 0x00, sizeof(filePath));
1275
1276                                 strncpy(filePath, (char *)dbHandle.columnText(0), MSG_FILEPATH_LEN_MAX);
1277                                 if (remove(filePath) == -1)
1278                                         MSG_DEBUG("Fail to delete file [%s]", filePath);
1279                                 else
1280                                         MSG_DEBUG("Success to delete file [%s]", filePath);
1281                         }
1282
1283                         dbHandle.finalizeQuery();
1284                 }
1285
1286                 memset(sqlQuery, 0x00, sizeof(sqlQuery));
1287
1288                 snprintf(sqlQuery, sizeof(sqlQuery), "DELETE FROM %s WHERE ", tableList[i]);
1289                 strncat(sqlQuery, whereQuery, MAX_QUERY_LEN-strlen(sqlQuery));
1290
1291                 // Delete Message in specific folder from table
1292                 err = dbHandle.execQuery(sqlQuery);
1293                 if (err != MSG_SUCCESS) {
1294                         MSG_DEBUG("sqlQuery [%s]", sqlQuery);
1295                         dbHandle.endTrans(false);
1296                         return err;
1297                 }
1298         }
1299
1300         // Clear Conversation table
1301         err = MsgStoClearConversationTable(&dbHandle);
1302         if (err != MSG_SUCCESS) {
1303                 dbHandle.endTrans(false);
1304                 return err;
1305         }
1306
1307         // Update Address
1308         while (!threadList.empty()) {
1309                 err = MsgStoUpdateConversation(&dbHandle, threadList.front());
1310
1311                 threadList.pop();
1312
1313                 if (err != MSG_SUCCESS) {
1314                         dbHandle.endTrans(false);
1315                         return err;
1316                 }
1317         }
1318
1319         dbHandle.endTrans(true);
1320
1321         int smsCnt = 0;
1322         int mmsCnt = 0;
1323
1324         smsCnt = MsgStoGetUnreadCnt(&dbHandle, MSG_SMS_TYPE);
1325         mmsCnt = MsgStoGetUnreadCnt(&dbHandle, MSG_MMS_TYPE);
1326
1327         MsgSettingSetIndicator(smsCnt, mmsCnt);
1328
1329 #if 0
1330 /*** Create thread  for noti and phone log delete. **/
1331         if (pMsgIdList->nCount > 0) {
1332                 msg_id_list_s *pToDeleteMsgIdListCpy = NULL;
1333                 pToDeleteMsgIdListCpy = (msg_id_list_s *)new char[sizeof(msg_id_list_s)];
1334                 memset(pToDeleteMsgIdListCpy, 0x00, sizeof(msg_id_list_s));
1335                 pToDeleteMsgIdListCpy->nCount = pMsgIdList->nCount;
1336                 pToDeleteMsgIdListCpy->msgIdList = (msg_message_id_t *)new char[sizeof(msg_message_id_t)*pMsgIdList->nCount];
1337                 memcpy(pToDeleteMsgIdListCpy->msgIdList, pMsgIdList->msgIdList, sizeof(msg_message_id_t)*pMsgIdList->nCount);
1338
1339                 if (g_idle_add(startToDeletePhoneLog, (void *)pToDeleteMsgIdListCpy) == 0) {
1340                         MSG_DEBUG("startToDeletePhoneLog not invoked: %s", strerror(errno));
1341                         // memory free
1342                         if (pToDeleteMsgIdListCpy != NULL) {
1343                                 //free peer info list
1344                                 if (pToDeleteMsgIdListCpy->msgIdList != NULL)
1345                                         delete [] pToDeleteMsgIdListCpy->msgIdList;
1346
1347                                 delete [] pToDeleteMsgIdListCpy;
1348                         }
1349                         err = MSG_ERR_UNKNOWN;
1350                 }
1351         }
1352 /*** **/
1353 #endif
1354
1355         MsgRefreshNoti(false);
1356
1357         MSG_END();
1358         return MSG_SUCCESS;
1359 }
1360
1361
1362 msg_error_t MsgStoMoveMessageToFolder(msg_message_id_t msgId, msg_folder_id_t destFolderId)
1363 {
1364         msg_error_t err = MSG_SUCCESS;
1365         MSG_MESSAGE_TYPE_S msgType;
1366         msg_thread_id_t convId = 0;
1367
1368         MsgStoGetMsgType(msgId, &msgType);
1369
1370         char sqlQuery[MAX_QUERY_LEN+1];
1371
1372         memset(sqlQuery, 0x00, sizeof(sqlQuery));
1373
1374         if (msgType.mainType == MSG_SMS_TYPE)
1375                 snprintf(sqlQuery, sizeof(sqlQuery), "UPDATE %s SET FOLDER_ID = %d WHERE MSG_ID = %d;", MSGFW_MESSAGE_TABLE_NAME, destFolderId, msgId);
1376         else
1377                 snprintf(sqlQuery, sizeof(sqlQuery), "UPDATE %s SET FOLDER_ID = %d WHERE MSG_ID = %d;", MSGFW_MESSAGE_TABLE_NAME, destFolderId, msgId);
1378
1379         if (dbHandle.execQuery(sqlQuery) != MSG_SUCCESS)
1380                 return MSG_ERR_DB_EXEC;
1381
1382         /* get conversation id */
1383         memset(sqlQuery, 0x00, sizeof(sqlQuery));
1384
1385         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT CONV_ID FROM %s WHERE MSG_ID = %d;",
1386                                                         MSGFW_MESSAGE_TABLE_NAME, msgId);
1387
1388         if (dbHandle.prepareQuery(sqlQuery) != MSG_SUCCESS)
1389                 return MSG_ERR_DB_PREPARE;
1390
1391         if (dbHandle.stepQuery() == MSG_ERR_DB_ROW)
1392                 convId = dbHandle.columnInt(0);
1393
1394         MSG_DEBUG("convId : %d",  convId);
1395
1396         dbHandle.finalizeQuery();
1397
1398         /* update conversation table */
1399         err = MsgStoUpdateConversation(&dbHandle, convId);
1400
1401         return err;
1402 }
1403
1404
1405 msg_error_t MsgStoMoveMessageToStorage(msg_message_id_t msgId, msg_storage_id_t destStorageId)
1406 {
1407         MSG_BEGIN();
1408
1409         msg_error_t err = MSG_SUCCESS;
1410
1411         char sqlQuery[MAX_QUERY_LEN+1];
1412
1413         MSG_DEBUG("msgId : %d, destStorageId : %d", msgId, destStorageId);
1414
1415         switch (destStorageId) {
1416         case MSG_STORAGE_SIM : // Move message to sim card
1417                 {
1418                         MSG_MESSAGE_INFO_S msgInfo;
1419                         SMS_SIM_ID_LIST_S simIdList;
1420
1421                         memset(&msgInfo, 0x00, sizeof(MSG_MESSAGE_INFO_S));
1422                         memset(&simIdList, 0x00, sizeof(SMS_SIM_ID_LIST_S));
1423
1424                         if ((err = MsgStoGetMessage(msgId, &msgInfo, NULL)) != MSG_SUCCESS)
1425                                 return err;
1426
1427                         MsgPlugin *plg = MsgPluginManager::instance()->getPlugin(MSG_SMS_TYPE);
1428
1429                         if ((err = plg->saveSimMessage(&msgInfo, &simIdList)) != MSG_SUCCESS)
1430                                 return err;
1431
1432                         dbHandle.beginTrans();
1433
1434                         memset(sqlQuery, 0x00, sizeof(sqlQuery));
1435                         snprintf(sqlQuery, sizeof(sqlQuery), "UPDATE %s SET STORAGE_ID = %d WHERE MSG_ID = %d;",
1436                                         MSGFW_MESSAGE_TABLE_NAME, destStorageId, msgId);
1437
1438                         if (dbHandle.execQuery(sqlQuery) != MSG_SUCCESS) {
1439                                 dbHandle.endTrans(false);
1440                                 return MSG_ERR_DB_EXEC;
1441                         }
1442
1443                         for (unsigned int i = 0; i < simIdList.count; i++) {
1444                                 memset(sqlQuery, 0x00, sizeof(sqlQuery));
1445                                 snprintf(sqlQuery, sizeof(sqlQuery), "INSERT INTO %s VALUES (%d, %d);",
1446                                                 MSGFW_SIM_MSG_TABLE_NAME, msgId, simIdList.simId[i]);
1447
1448                                 if (dbHandle.execQuery(sqlQuery) != MSG_SUCCESS) {
1449                                         dbHandle.endTrans(false);
1450                                         return MSG_ERR_DB_EXEC;
1451                                 }
1452                         }
1453
1454                         dbHandle.endTrans(true);
1455                 }
1456         break;
1457
1458         default: //Moving message to memory (when destination storage id is MSG_STORAGE_PHONE)
1459                 {
1460                         bool bSimMsg = false;
1461                         int rowCnt = 0;
1462
1463                         memset(sqlQuery, 0x00, sizeof(sqlQuery));
1464                         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT STORAGE_ID FROM %s WHERE MSG_ID = %d;",
1465                                         MSGFW_MESSAGE_TABLE_NAME, msgId);
1466
1467                         err = dbHandle.getTable(sqlQuery, &rowCnt);
1468
1469                         if (err != MSG_SUCCESS) {
1470                                 dbHandle.freeTable();
1471                                 return err;
1472                         }
1473
1474                         if (dbHandle.getColumnToInt(1) == MSG_STORAGE_SIM) {
1475                                 MSG_DEBUG("It is SIM Message");
1476                                 bSimMsg = true;
1477                         }
1478
1479                         dbHandle.freeTable();
1480
1481                         if (bSimMsg == true) {
1482                                 msg_sim_id_t simMsgId;
1483
1484                                 // get sim message id
1485                                 memset(sqlQuery, 0x00, sizeof(sqlQuery));
1486
1487                                 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT SIM_ID FROM %s WHERE MSG_ID = %d;",
1488                                                 MSGFW_SIM_MSG_TABLE_NAME, msgId);
1489
1490                                 MSG_DEBUG("sqlQuery is %s.", sqlQuery);
1491
1492                                 err = dbHandle.getTable(sqlQuery, &rowCnt);
1493
1494                                 if (err != MSG_SUCCESS) {
1495                                         dbHandle.freeTable();
1496                                         return err;
1497                                 }
1498
1499                                 //Delete messages in sim card
1500                                 MsgPlugin *plg = MsgPluginManager::instance()->getPlugin(MSG_SMS_TYPE);
1501
1502                                 for (int i = 0; i < rowCnt; i++) {
1503                                         simMsgId = dbHandle.getColumnToInt(i+1);
1504
1505                                         MSG_DEBUG("simMsgId is %d.", simMsgId);
1506
1507                                         if ((err = plg->deleteSimMessage(simMsgId)) != MSG_SUCCESS) {
1508                                                 dbHandle.freeTable();
1509                                                 return err;
1510                                         }
1511                                 }
1512
1513                                 dbHandle.freeTable();
1514
1515                                 dbHandle.beginTrans();
1516
1517                                 //Delete Messages in SIM Msg table
1518                                 memset(sqlQuery, 0x00, sizeof(sqlQuery));
1519                                 snprintf(sqlQuery, sizeof(sqlQuery), "DELETE FROM %s WHERE MSG_ID = %d;",
1520                                                 MSGFW_SIM_MSG_TABLE_NAME, msgId);
1521
1522                                 MSG_DEBUG("sqlQuery is %s.", sqlQuery);
1523
1524                                 if (dbHandle.execQuery(sqlQuery) != MSG_SUCCESS) {
1525                                         dbHandle.endTrans(false);
1526                                         return MSG_ERR_DB_EXEC;
1527                                 }
1528
1529                                 //Move storage id
1530                                 memset(sqlQuery, 0x00, sizeof(sqlQuery));
1531                                 snprintf(sqlQuery, sizeof(sqlQuery), "UPDATE %s SET STORAGE_ID = %d WHERE MSG_ID = %d;",
1532                                                 MSGFW_MESSAGE_TABLE_NAME, destStorageId, msgId);
1533
1534                                 if (dbHandle.execQuery(sqlQuery) != MSG_SUCCESS) {
1535                                         dbHandle.endTrans(false);
1536                                         return MSG_ERR_DB_EXEC;
1537                                 }
1538
1539                                 dbHandle.endTrans(true);
1540                         }
1541                 }
1542         }
1543
1544         return MSG_SUCCESS;
1545 }
1546
1547
1548 msg_error_t MsgStoCountMessage(msg_folder_id_t folderId, MSG_COUNT_INFO_S *pCountInfo)
1549 {
1550         if (pCountInfo == NULL) {
1551                 MSG_DEBUG("pCountInfo is NULL");
1552                 return MSG_ERR_NULL_POINTER;
1553         }
1554
1555         char sqlQuery[MAX_QUERY_LEN+1];
1556
1557         memset(sqlQuery, 0x00, sizeof(sqlQuery));
1558         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT COUNT(MSG_ID) FROM %s WHERE FOLDER_ID = %d AND READ_STATUS = 1 \
1559                         UNION ALL SELECT COUNT(MSG_ID) FROM %s WHERE FOLDER_ID = %d AND READ_STATUS = 0 \
1560                         UNION ALL SELECT COUNT(MSG_ID) FROM %s WHERE FOLDER_ID = %d AND MAIN_TYPE = %d \
1561                         UNION ALL SELECT COUNT(MSG_ID) FROM %s WHERE FOLDER_ID = %d AND MAIN_TYPE = %d;",
1562                         MSGFW_MESSAGE_TABLE_NAME, folderId,
1563                         MSGFW_MESSAGE_TABLE_NAME, folderId,
1564                         MSGFW_MESSAGE_TABLE_NAME, folderId, MSG_SMS_TYPE,
1565                         MSGFW_MESSAGE_TABLE_NAME, folderId, MSG_MMS_TYPE);
1566
1567         if (dbHandle.prepareQuery(sqlQuery) != MSG_SUCCESS)
1568                 return MSG_ERR_DB_PREPARE;
1569
1570         if (dbHandle.stepQuery() == MSG_ERR_DB_ROW) {
1571                 pCountInfo->nReadCnt = dbHandle.columnInt(0);
1572         } else {
1573                 dbHandle.finalizeQuery();
1574                 return MSG_ERR_DB_STEP;
1575         }
1576
1577         if (dbHandle.stepQuery() == MSG_ERR_DB_ROW) {
1578                 pCountInfo->nUnreadCnt = dbHandle.columnInt(0);
1579         } else {
1580                 dbHandle.finalizeQuery();
1581                 return MSG_ERR_DB_STEP;
1582         }
1583
1584         if (dbHandle.stepQuery() == MSG_ERR_DB_ROW) {
1585                 pCountInfo->nSms = dbHandle.columnInt(0);
1586         } else {
1587                 dbHandle.finalizeQuery();
1588                 return MSG_ERR_DB_STEP;
1589         }
1590
1591         if (dbHandle.stepQuery() == MSG_ERR_DB_ROW) {
1592                 pCountInfo->nMms = dbHandle.columnInt(0);
1593         } else {
1594                 dbHandle.finalizeQuery();
1595                 return MSG_ERR_DB_STEP;
1596         }
1597
1598         dbHandle.finalizeQuery();
1599
1600         return MSG_SUCCESS;
1601 }
1602
1603
1604 msg_error_t MsgStoCountMsgByType(const MSG_MESSAGE_TYPE_S *pMsgType, int *pMsgCount)
1605 {
1606         if (pMsgType == NULL) {
1607                 MSG_DEBUG("pMsgType is NULL");
1608                 return MSG_ERR_NULL_POINTER;
1609         }
1610
1611         *pMsgCount = 0;
1612
1613         char sqlQuery[MAX_QUERY_LEN+1];
1614         memset(sqlQuery, 0x00, sizeof(sqlQuery));
1615
1616         // SMS
1617         if ((pMsgType->mainType == MSG_SMS_TYPE) &&
1618                         (pMsgType->subType == MSG_NORMAL_SMS || pMsgType->subType == MSG_STATUS_REPORT_SMS || pMsgType->subType == MSG_CONCAT_SIM_SMS)) {
1619                 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT COUNT(MSG_ID) FROM %s WHERE MAIN_TYPE = %d AND SUB_TYPE IN (%d, %d, %d);",
1620                                 MSGFW_MESSAGE_TABLE_NAME, pMsgType->mainType, MSG_NORMAL_SMS, MSG_STATUS_REPORT_SMS, MSG_CONCAT_SIM_SMS);
1621         } else if ((pMsgType->mainType == MSG_SMS_TYPE) &&
1622                         (pMsgType->subType == MSG_WAP_SI_SMS || pMsgType->subType == MSG_WAP_SL_SMS)) {
1623                 // PUSH
1624                 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT COUNT(MSG_ID) FROM %s WHERE MAIN_TYPE = %d AND SUB_TYPE IN (%d, %d);",
1625                                 MSGFW_MESSAGE_TABLE_NAME, pMsgType->mainType, MSG_WAP_SI_SMS, MSG_WAP_SL_SMS);
1626         } else if ((pMsgType->mainType == MSG_MMS_TYPE) &&
1627                         (pMsgType->subType == MSG_SENDREQ_MMS || pMsgType->subType == MSG_SENDCONF_MMS || pMsgType->subType == MSG_RETRIEVE_AUTOCONF_MMS || pMsgType->subType == MSG_RETRIEVE_MANUALCONF_MMS)) {
1628                 // MMS
1629                 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT COUNT(MSG_ID) FROM %s WHERE MAIN_TYPE = %d AND SUB_TYPE IN (%d, %d, %d, %d);",
1630                                 MSGFW_MESSAGE_TABLE_NAME, pMsgType->mainType, MSG_SENDREQ_MMS, MSG_SENDCONF_MMS, MSG_RETRIEVE_AUTOCONF_MMS, MSG_RETRIEVE_MANUALCONF_MMS);
1631         } else {
1632                 return MSG_ERR_INVALID_PARAMETER;
1633         }
1634
1635         if (dbHandle.prepareQuery(sqlQuery) != MSG_SUCCESS)
1636                 return MSG_ERR_DB_PREPARE;
1637
1638         if (dbHandle.stepQuery() == MSG_ERR_DB_ROW) {
1639                 *pMsgCount = dbHandle.columnInt(0);
1640         } else {
1641                 dbHandle.finalizeQuery();
1642                 return MSG_ERR_DB_STEP;
1643         }
1644
1645         dbHandle.finalizeQuery();
1646
1647         return MSG_SUCCESS;
1648 }
1649
1650
1651 msg_error_t MsgStoGetMessage(msg_message_id_t msgId, MSG_MESSAGE_INFO_S *pMsg, MSG_SENDINGOPT_INFO_S *pSendOptInfo)
1652 {
1653         char sqlQuery[MAX_QUERY_LEN+1];
1654
1655         int order = MsgGetContactNameOrder();
1656
1657         memset(sqlQuery, 0x00, sizeof(sqlQuery));
1658         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT MSG_ID, CONV_ID, FOLDER_ID, STORAGE_ID, MAIN_TYPE, \
1659                         SUB_TYPE, DISPLAY_TIME, DATA_SIZE, NETWORK_STATUS, READ_STATUS, PROTECTED, \
1660                         BACKUP, PRIORITY, MSG_DIRECTION, SCHEDULED_TIME, SUBJECT, MSG_TEXT, THUMB_PATH \
1661                         FROM %s WHERE MSG_ID = %d;",
1662                         MSGFW_MESSAGE_TABLE_NAME, msgId);
1663
1664         if (dbHandle.prepareQuery(sqlQuery) != MSG_SUCCESS)
1665                 return MSG_ERR_DB_PREPARE;
1666
1667         if (dbHandle.stepQuery() == MSG_ERR_DB_ROW) {
1668                 pMsg->msgId = dbHandle.columnInt(0);
1669                 pMsg->threadId = dbHandle.columnInt(1);
1670                 pMsg->folderId = dbHandle.columnInt(2);
1671                 pMsg->storageId = dbHandle.columnInt(3);
1672                 pMsg->msgType.mainType = dbHandle.columnInt(4);
1673                 pMsg->msgType.subType = dbHandle.columnInt(5);
1674                 pMsg->displayTime = (time_t)dbHandle.columnInt(6);
1675                 pMsg->dataSize = dbHandle.columnInt(7);
1676                 pMsg->networkStatus = dbHandle.columnInt(8);
1677                 pMsg->bRead = dbHandle.columnInt(9);
1678                 pMsg->bProtected = dbHandle.columnInt(10);
1679                 pMsg->bBackup = dbHandle.columnInt(11);
1680                 pMsg->priority = dbHandle.columnInt(12);
1681                 pMsg->direction= dbHandle.columnInt(13);
1682
1683                 strncpy(pMsg->subject, (char *)dbHandle.columnText(15), MAX_SUBJECT_LEN);
1684
1685                 /* Temp_File_Handling */
1686                 if (pMsg->msgType.mainType == MSG_SMS_TYPE || pMsg->msgType.subType == MSG_NOTIFICATIONIND_MMS) {
1687                         if (pMsg->dataSize > MAX_MSG_TEXT_LEN) {
1688                                 char msgData[pMsg->dataSize+1];
1689                                 memset(msgData, 0x00, sizeof(msgData));
1690
1691                                 strncpy(msgData, (char *)dbHandle.columnText(16), pMsg->dataSize);
1692
1693                                 // Save Message Data into File
1694                                 char fileName[MSG_FILENAME_LEN_MAX+1];
1695                                 memset(fileName, 0x00, sizeof(fileName));
1696
1697                                 if (MsgCreateFileName(fileName) == false) {
1698                                         dbHandle.finalizeQuery();
1699                                         return MSG_ERR_STORAGE_ERROR;
1700                                 }
1701
1702                                 MSG_DEBUG("Save Message Data into file : size[%d] name[%s]\n", pMsg->dataSize, fileName);
1703
1704                                 if (MsgWriteIpcFile(fileName, msgData, pMsg->dataSize) == false) {
1705                                         dbHandle.finalizeQuery();
1706                                         return MSG_ERR_STORAGE_ERROR;
1707                                 }
1708
1709                                 strncpy(pMsg->msgData, fileName, MAX_MSG_DATA_LEN);
1710
1711                                 pMsg->bTextSms = false;
1712                         } else {
1713                                 memset(pMsg->msgText, 0x00, sizeof(pMsg->msgText));
1714                                 strncpy(pMsg->msgText, (char *)dbHandle.columnText(16), pMsg->dataSize);
1715
1716                                 // For WAP PUSH SI Message
1717                                 if (pMsg->msgType.subType == MSG_WAP_SI_SMS) {
1718                                         strncat(pMsg->msgText, "\n", MAX_MSG_TEXT_LEN-strlen(pMsg->msgText));
1719                                         strncat(pMsg->msgText, pMsg->subject, MAX_MSG_TEXT_LEN-strlen(pMsg->msgText));
1720                                         MSG_DEBUG("pMsg->msgText : [%s]", pMsg->msgText);
1721                                         pMsg->dataSize = sizeof(pMsg->msgText);
1722                                 }
1723
1724                                 pMsg->bTextSms = true;
1725                         }
1726                 } else {
1727                         if (dbHandle.columnText(16) != NULL)
1728                                 strncpy(pMsg->msgText, (char *)dbHandle.columnText(16), MAX_MSG_TEXT_LEN);
1729                 }
1730
1731                 // thumbnail path
1732                 if (dbHandle.columnText(17)!=NULL && ((char *)dbHandle.columnText(17))[0] != '\0') {
1733                         strncpy(pMsg->thumbPath, (char *)dbHandle.columnText(17), MSG_FILEPATH_LEN_MAX);
1734                         MSG_DEBUG("pMsg->thumbPath : [%s]", pMsg->thumbPath);
1735                 }
1736         } else {
1737                 dbHandle.finalizeQuery();
1738                 MSG_DEBUG("%s", sqlQuery);
1739                 return MSG_ERR_DB_STEP;
1740         }
1741
1742         dbHandle.finalizeQuery();
1743
1744
1745         // get address information.
1746         MsgStoGetAddressByMsgId(&dbHandle, pMsg->msgId, order, &pMsg->nAddressCnt, pMsg->addressList);
1747
1748         // Get MMS body if it is MMS.
1749         if ((pMsg->networkStatus == MSG_NETWORK_RETRIEVE_SUCCESS &&
1750                         (pMsg->msgType.subType == MSG_RETRIEVE_AUTOCONF_MMS || pMsg->msgType.subType == MSG_RETRIEVE_MANUALCONF_MMS)) ||
1751                         pMsg->msgType.subType == MSG_SENDREQ_MMS || pMsg->msgType.subType == MSG_SENDCONF_MMS) {
1752                 msg_error_t err = MSG_SUCCESS;
1753                 MMS_MESSAGE_DATA_S      mmsMsg;
1754                 char *pDestMsg = NULL;
1755                 int temp_size = pMsg->dataSize;//save raw file size;
1756                 // call mms plugin to get mms specific message data
1757                 MsgPlugin *plg = MsgPluginManager::instance()->getPlugin(pMsg->msgType.mainType);
1758                 memset(&mmsMsg, 0, sizeof(MMS_MESSAGE_DATA_S));
1759                 err =  plg->getMmsMessage(pMsg, pSendOptInfo, &mmsMsg, &pDestMsg);
1760
1761                 if (err != MSG_SUCCESS) {
1762                         if (pDestMsg) {
1763                                 free(pDestMsg);
1764                                 pDestMsg = NULL;
1765                         }
1766                         return MSG_ERR_STORAGE_ERROR;
1767                 }
1768
1769                 memset(pMsg->msgData, 0, MAX_MSG_DATA_LEN+1);
1770
1771                 // Encode MMS specific data to MMS_MESSAGE_DATA_S
1772                 if (pMsg->dataSize > MAX_MSG_DATA_LEN) {
1773                         // Save Message Data into File
1774                         char tempFileName[MSG_FILENAME_LEN_MAX+1];
1775                         memset(tempFileName, 0x00, sizeof(tempFileName));
1776
1777                         if (MsgCreateFileName(tempFileName) == false) {
1778                                 if(pDestMsg) {
1779                                         free (pDestMsg);
1780                                         pDestMsg = NULL;
1781                                 }
1782                                 return MSG_ERR_STORAGE_ERROR;
1783                         }
1784                         MSG_DEBUG("Save Message Data into file : size[%d] name[%s]\n", pMsg->dataSize, tempFileName);
1785
1786                         if (MsgWriteIpcFile(tempFileName, pDestMsg, pMsg->dataSize) == false) {
1787                                 if(pDestMsg) {
1788                                         free (pDestMsg);
1789                                         pDestMsg = NULL;
1790                                 }
1791                                 return MSG_ERR_STORAGE_ERROR;
1792                         }
1793                         strncpy(pMsg->msgData, tempFileName, MAX_MSG_DATA_LEN);
1794                         pMsg->bTextSms = false;
1795                 } else {
1796                         strncpy(pMsg->msgData, pDestMsg, pMsg->dataSize);
1797                         pMsg->bTextSms = true;
1798                 }
1799
1800                 pMsg->dataSize = temp_size;//raw file size;
1801
1802                 if (pDestMsg) {
1803                         free(pDestMsg);
1804                         pDestMsg = NULL;
1805                 }
1806         }
1807
1808         // Get SMS Sending Options
1809         if (pMsg->msgType.mainType == MSG_SMS_TYPE && pSendOptInfo != NULL)
1810                 MsgStoGetSmsSendOpt(pMsg->msgId, pSendOptInfo);
1811
1812         return MSG_SUCCESS;
1813 }
1814
1815
1816 msg_error_t MsgStoGetFolderViewList(msg_folder_id_t folderId, const MSG_SORT_RULE_S *pSortRule, msg_struct_list_s *pMsgFolderViewList)
1817 {
1818         if (pMsgFolderViewList == NULL) {
1819                 MSG_DEBUG("pMsgFolderViewList is NULL");
1820                 return MSG_ERR_NULL_POINTER;
1821         }
1822
1823         int rowCnt = 0;
1824         int index = 19; // numbers of index
1825
1826
1827         char sqlQuery[MAX_QUERY_LEN+1];
1828         char sqlSort[64];
1829
1830         // Get Name Order
1831         int order = MsgGetContactNameOrder();
1832
1833         // Get Message In Folder
1834         memset(sqlQuery, 0x00, sizeof(sqlQuery));
1835
1836         if (folderId == MSG_ALLBOX_ID) {
1837                 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT MSG_ID, CONV_ID, FOLDER_ID, STORAGE_ID, MAIN_TYPE, SUB_TYPE, \
1838                                 DISPLAY_TIME, DATA_SIZE, NETWORK_STATUS, READ_STATUS, PROTECTED, BACKUP, PRIORITY, \
1839                                 MSG_DIRECTION, SCHEDULED_TIME, SUBJECT, MSG_TEXT, ATTACHMENT_COUNT, THUMB_PATH \
1840                                 FROM %s WHERE FOLDER_ID < %d ",
1841                                 MSGFW_MESSAGE_TABLE_NAME, MSG_SPAMBOX_ID);
1842         } else {
1843                 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT MSG_ID, CONV_ID, FOLDER_ID, STORAGE_ID, MAIN_TYPE, SUB_TYPE, \
1844                                 DISPLAY_TIME, DATA_SIZE, NETWORK_STATUS, READ_STATUS, PROTECTED, BACKUP, PRIORITY, \
1845                                 MSG_DIRECTION, SCHEDULED_TIME, SUBJECT, MSG_TEXT, ATTACHMENT_COUNT, THUMB_PATH \
1846                                 FROM %s WHERE FOLDER_ID = %d ",
1847                                 MSGFW_MESSAGE_TABLE_NAME, folderId);
1848         }
1849
1850         memset(sqlSort, 0x00, sizeof(sqlSort));
1851         MsgMakeSortRule(pSortRule, sqlSort);
1852         strncat(sqlQuery, sqlSort, strlen(sqlSort));
1853
1854         msg_error_t  err = dbHandle.getTable(sqlQuery, &rowCnt);
1855
1856         if (err == MSG_ERR_DB_NORECORD) {
1857                 pMsgFolderViewList->nCount = 0;
1858                 pMsgFolderViewList->msg_struct_info = NULL;
1859
1860                 dbHandle.freeTable();
1861
1862                 return MSG_SUCCESS;
1863         } else if (err != MSG_SUCCESS) {
1864                 MSG_DEBUG("sqlQuery is - %s", sqlQuery);
1865                 dbHandle.freeTable();
1866                 return err;
1867         }
1868
1869         pMsgFolderViewList->nCount = rowCnt;
1870
1871         MSG_DEBUG("pMsgCommInfoList->nCount [%d]", pMsgFolderViewList->nCount);
1872
1873         pMsgFolderViewList->msg_struct_info = (msg_struct_t *)new char[sizeof(msg_struct_t) * rowCnt];
1874
1875         msg_struct_s *msg = NULL;
1876         MSG_MESSAGE_HIDDEN_S *pTmp = NULL;
1877
1878         for (int i = 0; i < rowCnt; i++) {
1879                 pMsgFolderViewList->msg_struct_info[i] = (msg_struct_t)new char[sizeof(msg_struct_s)];;
1880
1881                 msg = (msg_struct_s *)pMsgFolderViewList->msg_struct_info[i];
1882
1883                 msg->type = MSG_STRUCT_MESSAGE_INFO;
1884                 msg->data = new char[sizeof(MSG_MESSAGE_HIDDEN_S)];
1885
1886                 pTmp = (MSG_MESSAGE_HIDDEN_S *)msg->data;
1887
1888                 pTmp->pData = NULL;
1889                 pTmp->pMmsData = NULL;
1890
1891                 pTmp->msgId = dbHandle.getColumnToInt(index++);
1892                 pTmp->threadId = dbHandle.getColumnToInt(index++);
1893                 pTmp->folderId = dbHandle.getColumnToInt(index++);
1894                 pTmp->storageId = dbHandle.getColumnToInt(index++);
1895                 pTmp->mainType = dbHandle.getColumnToInt(index++);
1896                 pTmp->subType = dbHandle.getColumnToInt(index++);
1897                 pTmp->displayTime = (time_t)dbHandle.getColumnToInt(index++);
1898                 pTmp->dataSize = dbHandle.getColumnToInt(index++);
1899                 pTmp->networkStatus = dbHandle.getColumnToInt(index++);
1900                 pTmp->bRead = dbHandle.getColumnToInt(index++);
1901                 pTmp->bProtected = dbHandle.getColumnToInt(index++);
1902                 pTmp->bBackup = dbHandle.getColumnToInt(index++);
1903                 pTmp->priority = dbHandle.getColumnToInt(index++);
1904                 pTmp->direction= dbHandle.getColumnToInt(index++);
1905                 index++; // This field is reserved.
1906
1907                 dbHandle.getColumnToString(index++, MAX_SUBJECT_LEN, pTmp->subject);
1908
1909                 if (pTmp->mainType == MSG_MMS_TYPE &&
1910                         (pTmp->networkStatus == MSG_NETWORK_RETRIEVING || pTmp->networkStatus == MSG_NETWORK_RETRIEVE_FAIL || pTmp->subType == MSG_NOTIFICATIONIND_MMS)) {
1911                         pTmp->pData = NULL;
1912                         index++;
1913                 } else {
1914                         pTmp->pData = (void *)new char[pTmp->dataSize + 2];
1915                         memset(pTmp->pData, 0x00, pTmp->dataSize + 2);
1916
1917                         dbHandle.getColumnToString(index++, pTmp->dataSize+1, (char *)pTmp->pData);
1918                 }
1919
1920                 // get address information from db.
1921                 msg_struct_list_s *addr_list = (msg_struct_list_s *)new msg_struct_list_s;
1922
1923                 MsgStoGetAddressByMsgId(&dbHandle, pTmp->msgId, order, addr_list);
1924
1925                 pTmp->addr_list = addr_list;
1926
1927                 pTmp->attachCount = dbHandle.getColumnToInt(index++);
1928
1929                 dbHandle.getColumnToString(index++, MSG_FILEPATH_LEN_MAX, pTmp->thumbPath);
1930         }
1931
1932         dbHandle.freeTable();
1933
1934         return MSG_SUCCESS;
1935 }
1936
1937
1938 msg_error_t MsgStoAddSyncMLMessage(MSG_MESSAGE_INFO_S *pMsgInfo, int extId, int pinCode)
1939 {
1940         MSG_BEGIN();
1941
1942         msg_error_t err = MSG_SUCCESS;
1943
1944         char sqlQuery[MAX_QUERY_LEN+1];
1945
1946         unsigned int rowId = 0;
1947         msg_thread_id_t convId = 0;
1948
1949         dbHandle.beginTrans();
1950
1951         if (pMsgInfo->nAddressCnt > 0) {
1952                 err = MsgStoAddAddress(&dbHandle, pMsgInfo, &convId);
1953
1954                 if (err != MSG_SUCCESS) {
1955                         dbHandle.endTrans(false);
1956                         return err;
1957                 }
1958         }
1959
1960         // Add Message Table
1961         pMsgInfo->threadId = convId;
1962         rowId = MsgStoAddMessageTable(&dbHandle, pMsgInfo);
1963
1964         if (rowId <= 0) {
1965                 dbHandle.endTrans(false);
1966                 return MSG_ERR_DB_ROW;
1967         }
1968
1969         memset(sqlQuery, 0x00, sizeof(sqlQuery));
1970         snprintf(sqlQuery, sizeof(sqlQuery), "INSERT INTO %s VALUES (%d, %d, %d);",
1971                         MSGFW_SYNCML_MSG_TABLE_NAME, rowId, extId, pinCode);
1972
1973         if (dbHandle.execQuery(sqlQuery) != MSG_SUCCESS) {
1974                 dbHandle.endTrans(false);
1975                 return MSG_ERR_DB_EXEC;
1976         }
1977
1978         if (MsgStoUpdateConversation(&dbHandle, convId) != MSG_SUCCESS) {
1979                 dbHandle.endTrans(false);
1980                 return MSG_ERR_STORAGE_ERROR;
1981         }
1982
1983         dbHandle.endTrans(true);
1984
1985         pMsgInfo->msgId = (msg_message_id_t)rowId;
1986
1987         MsgSoundPlayStart(false);
1988
1989         int smsCnt = 0;
1990         int mmsCnt = 0;
1991
1992         smsCnt = MsgStoGetUnreadCnt(&dbHandle, MSG_SMS_TYPE);
1993         mmsCnt = MsgStoGetUnreadCnt(&dbHandle, MSG_MMS_TYPE);
1994
1995         MsgSettingHandleNewMsg(smsCnt, mmsCnt);
1996
1997         MsgInsertNoti(pMsgInfo);
1998
1999         MSG_END();
2000
2001         return MSG_SUCCESS;
2002 }
2003
2004
2005 msg_error_t MsgStoGetMsgType(msg_message_id_t msgId, MSG_MESSAGE_TYPE_S *pMsgType)
2006 {
2007         char sqlQuery[MAX_QUERY_LEN+1];
2008
2009         memset(sqlQuery, 0x00, sizeof(sqlQuery));
2010
2011         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT MAIN_TYPE, SUB_TYPE FROM %s WHERE MSG_ID = %d;",
2012                         MSGFW_MESSAGE_TABLE_NAME, msgId);
2013
2014         if (dbHandle.prepareQuery(sqlQuery) != MSG_SUCCESS)
2015                 return MSG_ERR_DB_PREPARE;
2016
2017         if (dbHandle.stepQuery() == MSG_ERR_DB_ROW) {
2018                 pMsgType->mainType = dbHandle.columnInt(0);
2019                 pMsgType->subType = dbHandle.columnInt(1);
2020         }
2021
2022         dbHandle.finalizeQuery();
2023
2024         return MSG_SUCCESS;
2025 }
2026
2027
2028 msg_error_t MsgStoGetQuickPanelData(msg_quickpanel_type_t QPtype, MSG_MESSAGE_INFO_S *pMsg)
2029 {
2030         msg_error_t     err = MSG_SUCCESS;
2031
2032         char sqlQuery[MAX_QUERY_LEN+1];
2033
2034         memset(sqlQuery, 0x00, sizeof(sqlQuery));
2035
2036         if (QPtype == MSG_QUICKPANEL_SMS) {
2037                 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT MSG_ID FROM %s WHERE FOLDER_ID = %d AND MAIN_TYPE = %d AND SUB_TYPE = %d AND READ_STATUS = 0 ORDER BY DISPLAY_TIME DESC;",
2038                                 MSGFW_MESSAGE_TABLE_NAME, MSG_INBOX_ID, MSG_SMS_TYPE, MSG_NORMAL_SMS);
2039         } else if (QPtype == MSG_QUICKPANEL_MMS) {
2040                 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT MSG_ID FROM %s WHERE FOLDER_ID = %d AND MAIN_TYPE = %d AND SUB_TYPE IN (%d, %d) AND READ_STATUS = 0 ORDER BY DISPLAY_TIME DESC;",
2041                                 MSGFW_MESSAGE_TABLE_NAME, MSG_INBOX_ID, MSG_MMS_TYPE, MSG_RETRIEVE_AUTOCONF_MMS, MSG_RETRIEVE_MANUALCONF_MMS);
2042         } else if (QPtype == MSG_QUICKPANEL_DELIVER_REP) {
2043                 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT MSG_ID FROM %s WHERE SUB_TYPE IN (%d, %d) AND READ_STATUS = 0 ORDER BY DISPLAY_TIME DESC;",
2044                                 MSGFW_MESSAGE_TABLE_NAME, MSG_STATUS_REPORT_SMS, MSG_DELIVERYIND_MMS);
2045         } else if (QPtype == MSG_QUICKPANEL_READ_REP) {
2046                 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT MSG_ID FROM %s WHERE MAIN_TYPE = %d AND SUB_TYPE = %d AND READ_STATUS = 0 ORDER BY DISPLAY_TIME DESC;",
2047                                 MSGFW_MESSAGE_TABLE_NAME, MSG_MMS_TYPE, MSG_READORGIND_MMS);
2048         } else if (QPtype == MSG_QUICKPANEL_VOICEMAIL) {
2049                 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT MSG_ID FROM %s WHERE FOLDER_ID = %d AND MAIN_TYPE = %d AND SUB_TYPE = %d AND READ_STATUS = 0 ORDER BY DISPLAY_TIME DESC;",
2050                                 MSGFW_MESSAGE_TABLE_NAME, MSG_INBOX_ID, MSG_SMS_TYPE, MSG_MWI_VOICE_SMS);
2051         } else if (QPtype == MSG_QUICKPANEL_MMS_NOTI) {
2052                 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT MSG_ID FROM %s WHERE FOLDER_ID = %d AND MAIN_TYPE = %d AND SUB_TYPE = %d AND READ_STATUS = 0 ORDER BY DISPLAY_TIME DESC;",
2053                                 MSGFW_MESSAGE_TABLE_NAME, MSG_INBOX_ID, MSG_MMS_TYPE, MSG_NOTIFICATIONIND_MMS);
2054         }
2055
2056         // Get Message ID
2057         msg_message_id_t msgId;
2058
2059         if (dbHandle.prepareQuery(sqlQuery) != MSG_SUCCESS)
2060                 return MSG_ERR_DB_PREPARE;
2061
2062         if (dbHandle.stepQuery() == MSG_ERR_DB_ROW) {
2063                 msgId = dbHandle.columnInt(0);
2064         } else {
2065                 dbHandle.finalizeQuery();
2066                 return MSG_ERR_DB_STEP;
2067         }
2068
2069         dbHandle.finalizeQuery();
2070
2071         // Get Message Info
2072         err = MsgStoGetMessage(msgId, pMsg, NULL);
2073
2074         return err;
2075 }
2076
2077
2078 msg_error_t MsgStoGetThreadViewList(const MSG_SORT_RULE_S *pSortRule, msg_struct_list_s *pThreadViewList)
2079 {
2080         pThreadViewList->nCount = 0;
2081         pThreadViewList->msg_struct_info = NULL;
2082
2083         int rowCnt = 0;
2084         int index = 11; // numbers of index
2085
2086         char sqlQuery[MAX_QUERY_LEN+1];
2087         memset(sqlQuery, 0x00, sizeof(sqlQuery));
2088
2089         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT A.CONV_ID, A.UNREAD_CNT, A.SMS_CNT, A.MMS_CNT, \
2090                         A.MAIN_TYPE, A.SUB_TYPE, A.MSG_DIRECTION, A.DISPLAY_TIME, A.DISPLAY_NAME, A.MSG_TEXT, \
2091                         (SELECT COUNT(*) FROM %s B WHERE B.CONV_ID = A.CONV_ID AND B.PROTECTED = 1) AS PROTECTED \
2092                         FROM %s A WHERE A.SMS_CNT > 0 OR A.MMS_CNT > 0 ORDER BY A.DISPLAY_TIME DESC;",
2093                         MSGFW_MESSAGE_TABLE_NAME, MSGFW_CONVERSATION_TABLE_NAME);
2094
2095         msg_error_t  err = dbHandle.getTable(sqlQuery, &rowCnt);
2096
2097         if (err == MSG_ERR_DB_NORECORD) {
2098                 dbHandle.freeTable();
2099                 return MSG_SUCCESS;
2100         } else if (err != MSG_SUCCESS) {
2101                 MSG_DEBUG("%s", sqlQuery);
2102                 dbHandle.freeTable();
2103                 return err;
2104         }
2105
2106         if (rowCnt < 1) {
2107                 MSG_DEBUG("rowCnt is %d", rowCnt);
2108                 dbHandle.freeTable();
2109                 return err;
2110         }
2111
2112         pThreadViewList->nCount = rowCnt;
2113
2114         MSG_DEBUG("pThreadViewList->nCount [%d]", pThreadViewList->nCount);
2115
2116         pThreadViewList->msg_struct_info = (msg_struct_t *)new char[sizeof(msg_struct_t)*rowCnt];
2117
2118         MSG_THREAD_VIEW_S *pTmp = NULL;
2119         msg_struct_s *thread_t = NULL;
2120
2121         for (int i = 0; i < rowCnt; i++) {
2122                 thread_t = (msg_struct_s *)new msg_struct_s;
2123                 pThreadViewList->msg_struct_info[i] = (msg_struct_t)thread_t;
2124
2125                 thread_t->type = MSG_STRUCT_THREAD_INFO;
2126                 thread_t->data = new MSG_THREAD_VIEW_S;
2127
2128                 pTmp = (MSG_THREAD_VIEW_S *)thread_t->data;
2129                 memset(pTmp, 0x00, sizeof(MSG_THREAD_VIEW_S));
2130
2131                 pTmp->threadId = dbHandle.getColumnToInt(index++);
2132
2133                 pTmp->unreadCnt = dbHandle.getColumnToInt(index++);
2134                 pTmp->smsCnt = dbHandle.getColumnToInt(index++);
2135                 pTmp->mmsCnt = dbHandle.getColumnToInt(index++);
2136
2137                 pTmp->mainType = dbHandle.getColumnToInt(index++);
2138                 pTmp->subType = dbHandle.getColumnToInt(index++);
2139
2140                 pTmp->direction = dbHandle.getColumnToInt(index++);
2141                 pTmp->threadTime = (time_t)dbHandle.getColumnToInt(index++);
2142
2143                 memset(pTmp->threadName, 0x00, sizeof(pTmp->threadName));
2144                 dbHandle.getColumnToString(index++, MAX_THREAD_NAME_LEN, pTmp->threadName);
2145
2146                 memset(pTmp->threadData, 0x00, sizeof(pTmp->threadData));
2147                 dbHandle.getColumnToString(index++, MAX_THREAD_DATA_LEN, pTmp->threadData);
2148
2149                 int protectedCnt = dbHandle.getColumnToInt(index++);
2150                 if (protectedCnt > 0)
2151                         pTmp->bProtected = true;
2152         }
2153
2154         dbHandle.freeTable();
2155
2156         return MSG_SUCCESS;
2157 }
2158
2159 msg_error_t MsgStoGetConversationPreview(MSG_CONVERSATION_VIEW_S *pConv)
2160 {
2161         MsgDbHandler dbHandleForInner;
2162         char sqlQuery[MAX_QUERY_LEN + 1];
2163         int rowCnt;
2164         int index = 3;
2165         memset(sqlQuery, 0x00, sizeof(sqlQuery));
2166
2167         if (pConv == NULL)
2168                 return MSG_ERR_NULL_POINTER;
2169
2170         //(MSG_ID INTEGER, TYPE INTEGER, VALUE TEXT, COUNT INTEGER)
2171         snprintf(sqlQuery, sizeof(sqlQuery),
2172                         "SELECT TYPE, VALUE, COUNT "
2173                         "FROM %s WHERE MSG_ID=%d;",
2174                         MSGFW_MMS_PREVIEW_TABLE_NAME, pConv->msgId);
2175
2176         MSG_DEBUG("QUERY : [%s]", sqlQuery);
2177
2178         msg_error_t err = dbHandleForInner.getTable(sqlQuery, &rowCnt);
2179         if (err == MSG_SUCCESS) {
2180                 for (int i = 0; i < rowCnt; i++) {
2181                         int type = dbHandleForInner.getColumnToInt(index++);
2182                         if (type == MSG_MMS_ITEM_TYPE_IMG) {
2183                                 dbHandleForInner.getColumnToString(index++, MSG_FILEPATH_LEN_MAX, pConv->imageThumbPath);
2184                                 dbHandleForInner.getColumnToInt(index++);
2185                         } else if (type == MSG_MMS_ITEM_TYPE_VIDEO) {
2186                                 dbHandleForInner.getColumnToString(index++, MSG_FILEPATH_LEN_MAX, pConv->videoThumbPath);
2187                                 dbHandleForInner.getColumnToInt(index++);
2188                         } else if (type == MSG_MMS_ITEM_TYPE_AUDIO) {
2189                                 dbHandleForInner.getColumnToString(index++, MSG_FILENAME_LEN_MAX, pConv->audioFileName);
2190                                 dbHandleForInner.getColumnToInt(index++);
2191                         } else if (type == MSG_MMS_ITEM_TYPE_ATTACH) {
2192                                 dbHandleForInner.getColumnToString(index++, MSG_FILENAME_LEN_MAX, pConv->attachFileName);
2193                                 dbHandleForInner.getColumnToInt(index++);
2194                         } else if (type == MSG_MMS_ITEM_TYPE_PAGE) {
2195                                 index++;
2196                                 pConv->pageCount = dbHandleForInner.getColumnToInt(index++);
2197                         } else {
2198                                 MSG_DEBUG("Unknown item type [%d]", type);
2199                                 index+=2;
2200                         }
2201                 }
2202         }
2203
2204         dbHandleForInner.freeTable();
2205         return MSG_SUCCESS;
2206 }
2207
2208 msg_error_t MsgStoGetConversationViewItem(msg_message_id_t msgId, MSG_CONVERSATION_VIEW_S *pConv)
2209 {
2210         int rowCnt = 0;
2211         int index = 16; /** numbers of index */
2212         char sqlQuery[MAX_QUERY_LEN+1];
2213
2214         memset(sqlQuery, 0x00, sizeof(sqlQuery));
2215
2216         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT MSG_ID, CONV_ID, FOLDER_ID, STORAGE_ID, MAIN_TYPE, SUB_TYPE, \
2217                         DISPLAY_TIME, DATA_SIZE, NETWORK_STATUS, READ_STATUS, PROTECTED, \
2218                         MSG_DIRECTION, SCHEDULED_TIME, SUBJECT, MSG_TEXT, ATTACHMENT_COUNT \
2219                         FROM %s WHERE MSG_ID=%d;",
2220                         MSGFW_MESSAGE_TABLE_NAME, msgId);
2221
2222         msg_error_t err = dbHandle.getTable(sqlQuery, &rowCnt);
2223
2224         if (err == MSG_ERR_DB_NORECORD) {
2225                 dbHandle.freeTable();
2226                 return MSG_SUCCESS;
2227         } else if (err != MSG_SUCCESS) {
2228                 MSG_DEBUG("%s", sqlQuery);
2229                 dbHandle.freeTable();
2230                 return err;
2231         }
2232
2233         memset(pConv, 0x00, sizeof(MSG_CONVERSATION_VIEW_S));
2234         pConv->pText = NULL;
2235
2236         pConv->msgId = dbHandle.getColumnToInt(index++);
2237         pConv->threadId = dbHandle.getColumnToInt(index++);
2238         pConv->folderId = dbHandle.getColumnToInt(index++);
2239         pConv->storageId = dbHandle.getColumnToInt(index++);
2240         pConv->mainType = dbHandle.getColumnToInt(index++);
2241         pConv->subType = dbHandle.getColumnToInt(index++);
2242         pConv->displayTime = (time_t)dbHandle.getColumnToInt(index++);
2243         pConv->textSize = dbHandle.getColumnToInt(index++);
2244         pConv->networkStatus = dbHandle.getColumnToInt(index++);
2245         pConv->bRead = dbHandle.getColumnToInt(index++);
2246         pConv->bProtected = dbHandle.getColumnToInt(index++);
2247         pConv->direction = dbHandle.getColumnToInt(index++);
2248         pConv->scheduledTime = (time_t)dbHandle.getColumnToInt(index++);
2249
2250         dbHandle.getColumnToString(index++, MAX_SUBJECT_LEN, pConv->subject);
2251
2252         if (pConv->mainType == MSG_MMS_TYPE &&
2253                 (pConv->networkStatus == MSG_NETWORK_RETRIEVING || pConv->networkStatus == MSG_NETWORK_RETRIEVE_FAIL || pConv->subType == MSG_NOTIFICATIONIND_MMS)) {
2254                 pConv->pText = NULL;
2255                 pConv->textSize = 0;
2256                 index++;
2257         } else {
2258                 if (pConv->mainType == MSG_SMS_TYPE) {
2259                         pConv->pText = new char[pConv->textSize+2];
2260                         memset(pConv->pText, 0x00, pConv->textSize+2);
2261                         dbHandle.getColumnToString(index++, pConv->textSize+1, pConv->pText);
2262                 } else {
2263                         char tmpMmsText[MAX_MMS_TEXT_LEN+1];
2264                         memset(tmpMmsText, 0x00, MAX_MMS_TEXT_LEN+1);
2265
2266                         dbHandle.getColumnToString(index++, MAX_MMS_TEXT_LEN, tmpMmsText);
2267
2268                         pConv->textSize = strlen(tmpMmsText);
2269
2270                         pConv->pText = new char[pConv->textSize+2];
2271                         memset(pConv->pText, 0x00, pConv->textSize+2);
2272
2273                         strncpy(pConv->pText, tmpMmsText, pConv->textSize+1);
2274
2275                         MsgStoGetConversationPreview(pConv);
2276                 }
2277         }
2278
2279         pConv->attachCount = dbHandle.getColumnToInt(index++);
2280
2281         MSG_END();
2282
2283         return MSG_SUCCESS;
2284 }
2285
2286 msg_error_t MsgStoGetConversationViewList(msg_thread_id_t threadId, msg_struct_list_s *pConvViewList)
2287 {
2288         MSG_BEGIN();
2289
2290         pConvViewList->nCount = 0;
2291         pConvViewList->msg_struct_info = NULL;
2292
2293         int rowCnt = 0;
2294         int index = 16; /** numbers of index */
2295         char sqlQuery[MAX_QUERY_LEN+1];
2296
2297         memset(sqlQuery, 0x00, sizeof(sqlQuery));
2298
2299         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT MSG_ID, CONV_ID, FOLDER_ID, STORAGE_ID, MAIN_TYPE, SUB_TYPE, \
2300                         DISPLAY_TIME, DATA_SIZE, NETWORK_STATUS, READ_STATUS, PROTECTED, \
2301                         MSG_DIRECTION, SCHEDULED_TIME, SUBJECT, MSG_TEXT, ATTACHMENT_COUNT \
2302                         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;",
2303                         MSGFW_MESSAGE_TABLE_NAME, threadId, MSG_ALLBOX_ID, MSG_CBMSGBOX_ID, MSG_STORAGE_PHONE);
2304
2305         msg_error_t err = dbHandle.getTable(sqlQuery, &rowCnt);
2306
2307         if (err == MSG_ERR_DB_NORECORD) {
2308                 dbHandle.freeTable();
2309                 return MSG_SUCCESS;
2310         } else if (err != MSG_SUCCESS) {
2311                 MSG_DEBUG("%s", sqlQuery);
2312                 dbHandle.freeTable();
2313                 return err;
2314         }
2315
2316         pConvViewList->nCount = rowCnt;
2317
2318         MSG_DEBUG("pConvViewList->nCount [%d]", pConvViewList->nCount);
2319
2320         pConvViewList->msg_struct_info = (msg_struct_t *)new char[sizeof(msg_struct_t) * rowCnt];
2321         memset(pConvViewList->msg_struct_info, 0x00, sizeof(msg_struct_t) * rowCnt);
2322
2323         msg_struct_s *conv = NULL;
2324         MSG_CONVERSATION_VIEW_S *pTmp = NULL;
2325
2326         for (int i = 0; i < rowCnt; i++) {
2327                 pConvViewList->msg_struct_info[i] = (msg_struct_t)new char[sizeof(msg_struct_s)];;
2328                 memset(pConvViewList->msg_struct_info[i], 0x00, sizeof(msg_struct_s));
2329
2330                 conv = (msg_struct_s *)pConvViewList->msg_struct_info[i];
2331
2332                 conv->type = MSG_STRUCT_CONV_INFO;
2333                 conv->data = new char[sizeof(MSG_CONVERSATION_VIEW_S)];
2334                 memset(conv->data, 0x00, sizeof(MSG_CONVERSATION_VIEW_S));
2335
2336                 pTmp = (MSG_CONVERSATION_VIEW_S *)conv->data;
2337
2338                 pTmp->pText = NULL;
2339
2340                 pTmp->msgId = dbHandle.getColumnToInt(index++);
2341                 pTmp->threadId = dbHandle.getColumnToInt(index++);
2342                 pTmp->folderId = dbHandle.getColumnToInt(index++);
2343                 pTmp->storageId = dbHandle.getColumnToInt(index++);
2344                 pTmp->mainType = dbHandle.getColumnToInt(index++);
2345                 pTmp->subType = dbHandle.getColumnToInt(index++);
2346                 pTmp->displayTime = (time_t)dbHandle.getColumnToInt(index++);
2347                 pTmp->textSize = dbHandle.getColumnToInt(index++);
2348                 pTmp->networkStatus = dbHandle.getColumnToInt(index++);
2349                 pTmp->bRead = dbHandle.getColumnToInt(index++);
2350                 pTmp->bProtected = dbHandle.getColumnToInt(index++);
2351                 pTmp->direction = dbHandle.getColumnToInt(index++);
2352                 index++; // This field is reserved.
2353
2354                 dbHandle.getColumnToString(index++, MAX_SUBJECT_LEN, pTmp->subject);
2355
2356                 if (pTmp->mainType == MSG_MMS_TYPE &&
2357                         (pTmp->networkStatus == MSG_NETWORK_RETRIEVING || pTmp->networkStatus == MSG_NETWORK_RETRIEVE_FAIL || pTmp->subType == MSG_NOTIFICATIONIND_MMS)) {
2358                         pTmp->pText = NULL;
2359                         pTmp->textSize = 0;
2360                         index++;
2361                 } else {
2362                         if (pTmp->mainType == MSG_SMS_TYPE) {
2363                                 pTmp->pText = new char[pTmp->textSize+2];
2364                                 memset(pTmp->pText, 0x00, pTmp->textSize+2);
2365                                 dbHandle.getColumnToString(index++, pTmp->textSize+1, pTmp->pText);
2366                         } else {
2367                                 char tmpMmsText[MAX_MMS_TEXT_LEN+1];
2368                                 memset(tmpMmsText, 0x00, MAX_MMS_TEXT_LEN+1);
2369
2370                                 dbHandle.getColumnToString(index++, MAX_MMS_TEXT_LEN, tmpMmsText);
2371
2372                                 pTmp->textSize = strlen(tmpMmsText);
2373
2374                                 pTmp->pText = new char[pTmp->textSize+2];
2375                                 memset(pTmp->pText, 0x00, pTmp->textSize+2);
2376
2377                                 strncpy(pTmp->pText, tmpMmsText, pTmp->textSize+1);
2378                         }
2379                 }
2380
2381                 pTmp->attachCount = dbHandle.getColumnToInt(index++);
2382
2383                 MsgStoGetConversationPreview(pTmp);
2384         }
2385
2386         dbHandle.freeTable();
2387
2388         MSG_END();
2389
2390         return MSG_SUCCESS;
2391 }
2392
2393
2394 msg_error_t MsgStoDeleteThreadMessageList(msg_thread_id_t threadId, bool bIncludeProtect, msg_id_list_s *pMsgIdList)
2395 {
2396         msg_error_t err = MSG_SUCCESS;
2397
2398         char sqlQuery[MAX_QUERY_LEN+1];
2399
2400         /*** Get msg id list **/
2401         int rowCnt = 0;
2402         int index = 1;
2403
2404         memset(sqlQuery, 0x00, sizeof(sqlQuery));
2405
2406         if (bIncludeProtect) {
2407                 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT MSG_ID FROM %s WHERE \
2408                                 CONV_ID = %d AND FOLDER_ID > %d AND FOLDER_ID < %d AND STORAGE_ID = %d;",
2409                                 MSGFW_MESSAGE_TABLE_NAME, threadId, MSG_ALLBOX_ID, MSG_CBMSGBOX_ID, MSG_STORAGE_PHONE);
2410         } else {
2411                 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT MSG_ID FROM %s WHERE \
2412                                 CONV_ID = %d AND FOLDER_ID > %d AND FOLDER_ID < %d AND STORAGE_ID = %d AND PROTECTED = 0;",
2413                                 MSGFW_MESSAGE_TABLE_NAME, threadId, MSG_ALLBOX_ID, MSG_CBMSGBOX_ID, MSG_STORAGE_PHONE);
2414         }
2415
2416         err = dbHandle.getTable(sqlQuery, &rowCnt);
2417
2418         if (err != MSG_SUCCESS && err != MSG_ERR_DB_NORECORD) {
2419                 MSG_DEBUG("sqlQuery [%s]", sqlQuery);
2420                 dbHandle.freeTable();
2421         }
2422
2423         if (rowCnt <= 0) {
2424                 dbHandle.freeTable();
2425                 err = MSG_SUCCESS;
2426         }
2427
2428         pMsgIdList->nCount = rowCnt;
2429
2430         MSG_DEBUG("pMsgIdList->nCount [%d]", pMsgIdList->nCount);
2431
2432         pMsgIdList->msgIdList = (msg_message_id_t *)new char[sizeof(msg_message_id_t) * rowCnt];
2433
2434         for (int i = 0; i < rowCnt; i++)
2435                 pMsgIdList->msgIdList[i] = dbHandle.getColumnToInt(index++);
2436
2437         dbHandle.freeTable();
2438         /*** **/
2439
2440         err = MsgStoDeleteMessageByList(pMsgIdList);
2441
2442         return err;
2443 }
2444
2445
2446 msg_error_t MsgStoCountMsgByContact(const MSG_THREAD_LIST_INDEX_S *pAddrInfo, MSG_THREAD_COUNT_INFO_S *pThreadCountInfo)
2447 {
2448         char sqlQuery[MAX_QUERY_LEN+1];
2449
2450         memset(sqlQuery, 0x00, sizeof(sqlQuery));
2451
2452         if (pAddrInfo->contactId > 0) {
2453                 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT COUNT(*) AS TOTAL, \
2454                                 SUM(CASE WHEN READ_STATUS=0 AND FOLDER_ID=%d THEN 1 ELSE 0 END), \
2455                                 SUM(CASE WHEN MAIN_TYPE=%d THEN 1 ELSE 0 END), \
2456                                 SUM(CASE WHEN MAIN_TYPE=%d THEN 1 ELSE 0 END) \
2457                                 FROM (SELECT * FROM %s A  JOIN %s B ON A.ADDRESS_ID = B.ADDRESS_ID WHERE B.CONTACT_ID = %d)",
2458                                 MSG_INBOX_ID, MSG_SMS_TYPE, MSG_MMS_TYPE, MSGFW_MESSAGE_TABLE_NAME, MSGFW_ADDRESS_TABLE_NAME, pAddrInfo->contactId);
2459         } else {
2460                 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT COUNT(*) AS TOTAL, \
2461                                 SUM(CASE WHEN READ_STATUS=0 AND FOLDER_ID=%d THEN 1 ELSE 0 END), \
2462                                 SUM(CASE WHEN MAIN_TYPE=%d THEN 1 ELSE 0 END), \
2463                                 SUM(CASE WHEN MAIN_TYPE=%d THEN 1 ELSE 0 END) \
2464                                 FROM (SELECT * FROM %s A  JOIN %s B ON A.ADDRESS_ID = B.ADDRESS_ID WHERE B.ADDRESS_VAL = '%s')",
2465                                 MSG_INBOX_ID, MSG_SMS_TYPE, MSG_MMS_TYPE, MSGFW_MESSAGE_TABLE_NAME, MSGFW_ADDRESS_TABLE_NAME, pAddrInfo->msgAddrInfo.addressVal);
2466         }
2467
2468         if (dbHandle.prepareQuery(sqlQuery) != MSG_SUCCESS)
2469                 return MSG_ERR_DB_PREPARE;
2470
2471         if (dbHandle.stepQuery() == MSG_ERR_DB_ROW) {
2472                 pThreadCountInfo->totalCount = dbHandle.columnInt(0);
2473                 pThreadCountInfo->unReadCount = dbHandle.columnInt(1);
2474                 pThreadCountInfo->smsMsgCount = dbHandle.columnInt(2);
2475                 pThreadCountInfo->mmsMsgCount = dbHandle.columnInt(3);
2476         } else {
2477                 dbHandle.finalizeQuery();
2478                 return MSG_ERR_DB_STEP;
2479         }
2480
2481         dbHandle.finalizeQuery();
2482
2483         return MSG_SUCCESS;
2484 }
2485
2486
2487 msg_error_t MsgStoSearchMessage(const char *pSearchString, msg_struct_list_s *pThreadViewList)
2488 {
2489         if (!pSearchString)
2490                 return MSG_ERR_NULL_POINTER;
2491
2492         // Clear Out Parameter
2493         pThreadViewList->nCount = 0;
2494         pThreadViewList->msg_struct_info = NULL;
2495
2496         tr1::unordered_set<msg_thread_id_t> IdList;
2497         queue<MSG_THREAD_VIEW_S> searchList;
2498
2499         MSG_THREAD_VIEW_S threadView;
2500
2501         char sqlQuery[MAX_QUERY_LEN+1];
2502
2503         // Replace string for '%' and '_' character
2504         char *ext1_str = NULL;
2505         char *ext2_str = NULL;
2506
2507         ext1_str = MsgStoReplaceString(pSearchString, "_", "\\_");
2508         ext2_str = MsgStoReplaceString(ext1_str, "%", "\\%");
2509
2510         // Search - Address, Name
2511         memset(sqlQuery, 0x00, sizeof(sqlQuery));
2512
2513         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT CONV_ID, UNREAD_CNT, SMS_CNT, MMS_CNT, DISPLAY_NAME, \
2514                         MAIN_TYPE, SUB_TYPE, MSG_DIRECTION, DISPLAY_TIME, MSG_TEXT \
2515                         FROM %s WHERE DISPLAY_NAME LIKE '%%%s%%' ESCAPE '\\' ORDER BY DISPLAY_TIME DESC;",
2516                         MSGFW_CONVERSATION_TABLE_NAME, ext2_str);
2517
2518         if (ext1_str) {
2519                 free(ext1_str);
2520                 ext1_str = NULL;
2521         }
2522
2523         if (ext2_str) {
2524                 free(ext2_str);
2525                 ext2_str = NULL;
2526         }
2527
2528         MSG_DEBUG("[%s]", sqlQuery);
2529
2530         if (dbHandle.prepareQuery(sqlQuery) != MSG_SUCCESS) {
2531                 MSG_DEBUG("Prepare query fail. [%s]", sqlQuery);
2532                 return MSG_ERR_DB_PREPARE;
2533         }
2534
2535         while (dbHandle.stepQuery() == MSG_ERR_DB_ROW) {
2536                 memset(&threadView, 0x00, sizeof(threadView));
2537
2538                 threadView.threadId = dbHandle.columnInt(0);
2539                 threadView.unreadCnt = dbHandle.columnInt(1);
2540                 threadView.smsCnt = dbHandle.columnInt(2);
2541                 threadView.mmsCnt = dbHandle.columnInt(3);
2542
2543                 strncpy(threadView.threadName, (char *)dbHandle.columnText(4), MAX_THREAD_NAME_LEN);
2544
2545                 threadView.mainType = dbHandle.columnInt(5);
2546                 threadView.subType = dbHandle.columnInt(6);
2547
2548                 threadView.direction = dbHandle.columnInt(7);
2549                 threadView.threadTime = (time_t)dbHandle.columnInt(8);
2550
2551                 strncpy(threadView.threadData, (char *)dbHandle.columnText(9), MAX_THREAD_DATA_LEN);
2552
2553                 tr1::unordered_set<msg_thread_id_t>::iterator it;
2554
2555                 it = IdList.find(threadView.threadId);
2556
2557                 if (it == IdList.end()) {
2558                         IdList.insert(threadView.threadId);
2559                         searchList.push(threadView);
2560                 }
2561
2562         }
2563
2564         dbHandle.finalizeQuery();
2565
2566         // Add data to Out Parameter
2567         pThreadViewList->nCount = searchList.size();
2568         pThreadViewList->msg_struct_info = (msg_struct_t *)new char[sizeof(msg_struct_t) * searchList.size()];
2569
2570         MSG_THREAD_VIEW_S *pTmp = NULL;
2571         msg_struct_s *thread_t = NULL;
2572
2573         int index = 0;
2574
2575         while (!searchList.empty()) {
2576                 thread_t = (msg_struct_s *)new msg_struct_s;
2577                 pThreadViewList->msg_struct_info[index] = (msg_struct_t)thread_t;
2578
2579                 thread_t->type = MSG_STRUCT_THREAD_INFO;
2580                 thread_t->data = new MSG_THREAD_VIEW_S;
2581
2582                 pTmp = (MSG_THREAD_VIEW_S *)thread_t->data;
2583                 memset(pTmp, 0x00, sizeof(MSG_THREAD_VIEW_S));
2584
2585                 memcpy(pTmp, &(searchList.front()), sizeof(MSG_THREAD_VIEW_S));
2586
2587                 searchList.pop();
2588
2589                 index++;
2590         }
2591
2592         return MSG_SUCCESS;
2593 }
2594
2595
2596 msg_error_t MsgStoSearchMessage(const MSG_SEARCH_CONDITION_S *pSearchCon, int offset, int limit, msg_struct_list_s *pMsgList)
2597 {
2598         // Clear Out Parameter
2599         pMsgList->nCount = 0;
2600         pMsgList->msg_struct_info = NULL;
2601
2602         int rowCnt = 0;
2603         int index = 26; // numbers of index
2604
2605         char sqlQuery[MAX_QUERY_LEN+1];
2606         char sqlQuerySubset[(MAX_QUERY_LEN/5)+1];
2607
2608         char firstName[MAX_DISPLAY_NAME_LEN+1], lastName[MAX_DISPLAY_NAME_LEN+1];
2609         char displayName[MAX_DISPLAY_NAME_LEN+1];
2610
2611         char *ext1_str = NULL;
2612         char *ext2_str = NULL;
2613
2614         // Get Name Order
2615         int order = MsgGetContactNameOrder();
2616
2617         memset(sqlQuery, 0x00, sizeof(sqlQuery));
2618
2619         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT A.MSG_ID, A.CONV_ID, A.FOLDER_ID, A.STORAGE_ID, A.MAIN_TYPE, A.SUB_TYPE, "
2620                         "A.DISPLAY_TIME, A.DATA_SIZE, A.NETWORK_STATUS, A.READ_STATUS, A.PROTECTED, A.BACKUP, A.PRIORITY, "
2621                         "A.MSG_DIRECTION, A.SCHEDULED_TIME, A.SUBJECT, A.MSG_TEXT, B.ADDRESS_TYPE, B.RECIPIENT_TYPE, "
2622                         "B.CONTACT_ID, B.ADDRESS_VAL, B.DISPLAY_NAME, B.FIRST_NAME, B.LAST_NAME, A.ATTACHMENT_COUNT, A.THUMB_PATH "
2623                         "FROM %s A, %s B WHERE A.CONV_ID = B.CONV_ID AND B.ADDRESS_ID <> 0 ",
2624                         MSGFW_MESSAGE_TABLE_NAME, MSGFW_ADDRESS_TABLE_NAME);
2625
2626         //// folder
2627         memset(sqlQuerySubset, 0x00, sizeof(sqlQuerySubset));
2628
2629         if (pSearchCon->folderId == MSG_ALLBOX_ID)
2630                 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "AND A.FOLDER_ID > 0 AND A.FOLDER_ID < %d ", MSG_CBMSGBOX_ID);
2631         else if (pSearchCon->folderId == MSG_IOSBOX_ID)
2632                 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "AND A.FOLDER_ID > 0 AND A.FOLDER_ID < %d ", MSG_DRAFT_ID);
2633         else
2634                 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "AND A.FOLDER_ID = %d ", pSearchCon->folderId);
2635
2636         strncat(sqlQuery, sqlQuerySubset, MAX_QUERY_LEN-strlen(sqlQuery));
2637
2638
2639         //// msg type
2640         memset(sqlQuerySubset, 0x00, sizeof(sqlQuerySubset));
2641
2642         switch (pSearchCon->msgType) {
2643                 case MSG_TYPE_SMS:
2644                         snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "AND A.MAIN_TYPE = %d AND A.SUB_TYPE = %d ", MSG_SMS_TYPE, MSG_NORMAL_SMS);
2645                         break;
2646
2647                 case MSG_TYPE_MMS:
2648                         snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "AND A.MAIN_TYPE = %d ", MSG_MMS_TYPE);
2649                         break;
2650
2651                 case MSG_TYPE_MMS_JAVA:
2652                         snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "AND A.MAIN_TYPE = %d AND A.SUB_TYPE = %d ", MSG_MMS_TYPE, MSG_SENDREQ_JAVA_MMS);
2653                         break;
2654
2655                 case MSG_TYPE_SMS_SYNCML:
2656                         snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "AND A.MAIN_TYPE = %d AND A.SUB_TYPE = %d ", MSG_SMS_TYPE, MSG_SYNCML_CP);
2657                         break;
2658
2659                 case MSG_TYPE_SMS_REJECT:
2660                         snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "AND A.MAIN_TYPE = %d AND A.SUB_TYPE = %d ", MSG_SMS_TYPE, MSG_REJECT_SMS);
2661                         break;
2662
2663                 default:
2664                         MSG_DEBUG("msg type is not set.");
2665                         break;
2666         }
2667
2668         strncat(sqlQuery, sqlQuerySubset, MAX_QUERY_LEN-strlen(sqlQuery));
2669
2670         /// string
2671         if (pSearchCon->pSearchVal != NULL) {
2672
2673                 // Replace string for '%' and '_' character
2674                 ext1_str = MsgStoReplaceString(pSearchCon->pSearchVal, "_", "\\_");
2675                 ext2_str = MsgStoReplaceString(ext1_str, "%", "\\%");
2676
2677                 memset(sqlQuerySubset, 0x00, sizeof(sqlQuerySubset));
2678                 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset),
2679                                 "AND ( A.MSG_TEXT LIKE '%%%s%%' ESCAPE '\\' "
2680                                 "OR A.SUBJECT LIKE '%%%s%%' ESCAPE '\\' "
2681                                 "OR B.ADDRESS_VAL LIKE '%%%s%%' ESCAPE '\\' "
2682                                 "OR B.DISPLAY_NAME LIKE '%%%s%%' ESCAPE '\\' "
2683                                 "OR B.FIRST_NAME LIKE '%%%s%%' ESCAPE '\\' "
2684                                 "OR B.LAST_NAME LIKE '%%%s%%' ESCAPE '\\') ",
2685                                 ext2_str, ext2_str, ext2_str, ext2_str, ext2_str, ext2_str);
2686                 strncat(sqlQuery, sqlQuerySubset, MAX_QUERY_LEN-strlen(sqlQuery));
2687
2688                 if (ext1_str) {
2689                         free(ext1_str);
2690                         ext1_str = NULL;
2691                 }
2692
2693                 if (ext2_str) {
2694                         free(ext2_str);
2695                         ext2_str = NULL;
2696                 }
2697         }
2698
2699         /// address
2700         if (pSearchCon->pAddressVal != NULL) {
2701
2702                 // Replace string for '%' and '_' character
2703                 ext1_str = MsgStoReplaceString(pSearchCon->pAddressVal, "_", "\\_");
2704                 ext2_str = MsgStoReplaceString(ext1_str, "%", "\\%");
2705
2706                 memset(sqlQuerySubset, 0x00, sizeof(sqlQuerySubset));
2707                 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "AND B.ADDRESS_VAL LIKE '%%%s%%' ESCAPE '\\' ", ext2_str);
2708                 strncat(sqlQuery, sqlQuerySubset, MAX_QUERY_LEN-strlen(sqlQuery));
2709
2710                 if (ext1_str) {
2711                         free(ext1_str);
2712                         ext1_str = NULL;
2713                 }
2714
2715                 if (ext2_str) {
2716                         free(ext2_str);
2717                         ext2_str = NULL;
2718                 }
2719         }
2720
2721         /// limit, offset
2722         memset(sqlQuerySubset, 0x00, sizeof(sqlQuerySubset));
2723
2724         if (offset >= 0 && limit > 0)
2725                 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "GROUP BY A.MSG_ID ORDER BY A.DISPLAY_TIME DESC LIMIT %d OFFSET %d;", limit, offset);
2726         else
2727                 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "GROUP BY A.MSG_ID ORDER BY A.DISPLAY_TIME DESC;");
2728
2729         strncat(sqlQuery, sqlQuerySubset, MAX_QUERY_LEN-strlen(sqlQuery));
2730
2731         msg_error_t err = dbHandle.getTable(sqlQuery, &rowCnt);
2732
2733         if (err == MSG_ERR_DB_NORECORD) {
2734                 dbHandle.freeTable();
2735
2736                 return MSG_SUCCESS;
2737         } else if (err != MSG_SUCCESS) {
2738                 MSG_DEBUG("Get table fail. [%s]", sqlQuery);
2739
2740                 dbHandle.freeTable();
2741
2742                 return err;
2743         }
2744
2745         pMsgList->nCount = rowCnt;
2746
2747         MSG_DEBUG("pMsgList->nCount [%d]", pMsgList->nCount);
2748
2749         pMsgList->msg_struct_info = (msg_struct_t *)new char[sizeof(msg_struct_t) * rowCnt];
2750
2751         MSG_MESSAGE_HIDDEN_S *pTmp = NULL;
2752         msg_struct_s *msg = NULL;
2753
2754         for (int i = 0; i < rowCnt; i++) {
2755                 pMsgList->msg_struct_info[i] = (msg_struct_t)new msg_struct_s;
2756
2757                 msg = (msg_struct_s *)pMsgList->msg_struct_info[i];
2758
2759                 msg->type = MSG_STRUCT_MESSAGE_INFO;
2760                 msg->data = (int *)new char[sizeof(MSG_MESSAGE_HIDDEN_S)];
2761
2762                 pTmp = (MSG_MESSAGE_HIDDEN_S *)msg->data;
2763
2764                 memset(pTmp, 0x00, sizeof(MSG_MESSAGE_HIDDEN_S));
2765
2766                 pTmp->pData = NULL;
2767                 pTmp->pMmsData = NULL;
2768
2769                 pTmp->msgId = dbHandle.getColumnToInt(index++);
2770                 pTmp->threadId = dbHandle.getColumnToInt(index++);
2771                 pTmp->folderId = dbHandle.getColumnToInt(index++);
2772                 pTmp->storageId = dbHandle.getColumnToInt(index++);
2773                 pTmp->mainType = dbHandle.getColumnToInt(index++);
2774                 pTmp->subType = dbHandle.getColumnToInt(index++);
2775                 pTmp->displayTime = (time_t)dbHandle.getColumnToInt(index++);
2776                 pTmp->dataSize = dbHandle.getColumnToInt(index++);
2777                 pTmp->networkStatus = dbHandle.getColumnToInt(index++);
2778                 pTmp->bRead = dbHandle.getColumnToInt(index++);
2779                 pTmp->bProtected = dbHandle.getColumnToInt(index++);
2780                 pTmp->bBackup = dbHandle.getColumnToInt(index++);
2781                 pTmp->priority = dbHandle.getColumnToInt(index++);
2782                 pTmp->direction= dbHandle.getColumnToInt(index++);
2783                 index++; // This field is reserved.
2784
2785                 dbHandle.getColumnToString(index++, MAX_SUBJECT_LEN, pTmp->subject);
2786
2787                 if (pTmp->mainType == MSG_MMS_TYPE &&
2788                         (pTmp->networkStatus == MSG_NETWORK_RETRIEVING || pTmp->networkStatus == MSG_NETWORK_RETRIEVE_FAIL || pTmp->subType == MSG_NOTIFICATIONIND_MMS)) {
2789                         pTmp->pData = NULL;
2790                         index++;
2791                 } else {
2792                         MSG_DEBUG("pTmp->dataSize [%d]", pTmp->dataSize);
2793                         pTmp->pData = (void *)new char[pTmp->dataSize + 2];
2794                         memset(pTmp->pData, 0x00, pTmp->dataSize + 2);
2795
2796                         dbHandle.getColumnToString(index++, pTmp->dataSize+1, (char *)pTmp->pData);
2797                 }
2798
2799                 msg_struct_list_s *addr_list = (msg_struct_list_s *)new msg_struct_list_s;
2800                 msg_struct_s *addr_info = NULL;
2801                 MSG_ADDRESS_INFO_S *address = NULL;
2802
2803                 addr_list->nCount = 1;
2804                 addr_list->msg_struct_info = (msg_struct_t *)new char[sizeof(msg_struct_t *)*MAX_TO_ADDRESS_CNT];
2805
2806                 msg_struct_s *pTmpAddr = NULL;
2807
2808                 for (int i = 0; i < MAX_TO_ADDRESS_CNT; i++) {
2809                         addr_list->msg_struct_info[i] = (msg_struct_t)new char[sizeof(msg_struct_s)];
2810                         pTmpAddr = (msg_struct_s *)addr_list->msg_struct_info[i];
2811                         pTmpAddr->type = MSG_STRUCT_ADDRESS_INFO;
2812                         pTmpAddr->data = new MSG_ADDRESS_INFO_S;
2813                         memset(pTmpAddr->data, 0x00, sizeof(MSG_ADDRESS_INFO_S));
2814
2815                         addr_list->msg_struct_info[i] = (msg_struct_t)pTmpAddr;
2816                 }
2817
2818                 addr_info = (msg_struct_s *)addr_list->msg_struct_info[0];
2819                 address = (MSG_ADDRESS_INFO_S *)addr_info->data;
2820                 address->addressType = dbHandle.getColumnToInt(index++);
2821                 address->recipientType = dbHandle.getColumnToInt(index++);
2822                 address->contactId = dbHandle.getColumnToInt(index++);
2823
2824                 dbHandle.getColumnToString(index++, MAX_ADDRESS_VAL_LEN, address->addressVal);
2825
2826                 memset(displayName, 0x00, sizeof(displayName));
2827                 dbHandle.getColumnToString(index++, MAX_DISPLAY_NAME_LEN, displayName);
2828
2829                 memset(firstName, 0x00, sizeof(firstName));
2830                 dbHandle.getColumnToString(index++, MAX_DISPLAY_NAME_LEN, firstName);
2831
2832                 memset(lastName, 0x00, sizeof(lastName));
2833                 dbHandle.getColumnToString(index++, MAX_DISPLAY_NAME_LEN, lastName);
2834
2835                 if (strlen(displayName) <= 0) {
2836                         if (order == 0) {
2837                                 if (firstName[0] != '\0') {
2838                                         strncpy(displayName, firstName, MAX_DISPLAY_NAME_LEN);
2839                                 }
2840
2841                                 if (lastName[0] != '\0') {
2842                                         strncat(displayName, " ", MAX_DISPLAY_NAME_LEN-strlen(displayName));
2843                                         strncat(displayName, lastName, MAX_DISPLAY_NAME_LEN-strlen(displayName));
2844                                 }
2845                         } else if (order == 1) {
2846                                 if (lastName[0] != '\0') {
2847                                         strncpy(displayName, lastName, MAX_DISPLAY_NAME_LEN);
2848                                         strncat(displayName, " ", MAX_DISPLAY_NAME_LEN-strlen(displayName));
2849                                 }
2850
2851                                 if (firstName[0] != '\0') {
2852                                         strncat(displayName, firstName, MAX_DISPLAY_NAME_LEN-strlen(displayName));
2853                                 }
2854                         }
2855                 }
2856
2857                 strncpy(address->displayName, displayName, MAX_DISPLAY_NAME_LEN);
2858
2859                 pTmp->addr_list = addr_list;
2860
2861                 pTmp->attachCount = dbHandle.getColumnToInt(index++);
2862
2863                 dbHandle.getColumnToString(index++, MSG_FILEPATH_LEN_MAX, pTmp->thumbPath);
2864
2865         }
2866         dbHandle.freeTable();
2867
2868         return MSG_SUCCESS;
2869 }
2870
2871
2872 void MsgConvertNumber(const char *pSrcNum, char *pDestNum)
2873 {
2874         int overLen = 0;
2875         int i = 0;
2876
2877         overLen = strlen(pSrcNum) - MAX_PRECONFIG_NUM;
2878
2879         for (i = 0; i < MAX_PRECONFIG_NUM; i++)
2880                 pDestNum[i] = pSrcNum[i+overLen];
2881
2882         pDestNum[i] = '\0';
2883 }
2884
2885
2886 msg_error_t MsgStoGetRejectMsgList(const char *pNumber, msg_struct_list_s *pRejectMsgList)
2887 {
2888         // Clear Out Parameter
2889         pRejectMsgList->nCount = 0;
2890         pRejectMsgList->msg_struct_info = NULL;
2891
2892         int rowCnt = 0;
2893         int index = 3; // numbers of index
2894
2895         char sqlQuery[MAX_QUERY_LEN+1];
2896
2897         // Search Reject Msg
2898         memset(sqlQuery, 0x00, sizeof(sqlQuery));
2899
2900         if (pNumber != NULL) {
2901                 char phoneNumber[MAX_PRECONFIG_NUM+1];
2902                 memset(phoneNumber, 0x00, sizeof(phoneNumber));
2903
2904                 if (strlen(pNumber) > MAX_PRECONFIG_NUM)
2905                         MsgConvertNumber(pNumber, phoneNumber);
2906                 else
2907                         strncpy(phoneNumber, pNumber, MAX_PRECONFIG_NUM);
2908
2909                 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT B.MSG_ID, B.MSG_TEXT, B.DISPLAY_TIME \
2910                                 FROM %s A, %s B \
2911                                 WHERE A.CONV_ID = B.CONV_ID AND B.MAIN_TYPE = %d \
2912                                 AND B.SUB_TYPE = %d AND A.ADDRESS_VAL LIKE '%%%s' \
2913                                 ORDER BY B.DISPLAY_TIME DESC;",
2914                                 MSGFW_ADDRESS_TABLE_NAME, MSGFW_MESSAGE_TABLE_NAME,
2915                                 MSG_SMS_TYPE, MSG_REJECT_SMS, phoneNumber);
2916         } else {
2917                 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT B.MSG_ID, B.MSG_TEXT, B.DISPLAY_TIME \
2918                                 FROM %s A, %s B \
2919                                 WHERE A.CONV_ID = B.CONV_ID AND B.MAIN_TYPE = %d AND B.SUB_TYPE = %d \
2920                                 ORDER BY B.DISPLAY_TIME DESC;",
2921                                 MSGFW_ADDRESS_TABLE_NAME, MSGFW_MESSAGE_TABLE_NAME,
2922                                 MSG_SMS_TYPE, MSG_REJECT_SMS);
2923         }
2924
2925         msg_error_t  err = dbHandle.getTable(sqlQuery, &rowCnt);
2926
2927         if (err != MSG_SUCCESS) {
2928                 MSG_DEBUG("%s", sqlQuery);
2929
2930                 dbHandle.freeTable();
2931
2932                 return err;
2933         }
2934
2935         pRejectMsgList->nCount = rowCnt;
2936
2937         MSG_DEBUG("pRejectMsgList->nCount [%d]", pRejectMsgList->nCount);
2938
2939         pRejectMsgList->msg_struct_info = (msg_struct_t *)new char[sizeof(MSG_REJECT_MSG_INFO_S *)*rowCnt];
2940
2941         msg_struct_s* pTmp = NULL;
2942
2943         for (int i = 0; i < rowCnt; i++) {
2944                 pRejectMsgList->msg_struct_info[i] = (msg_struct_t)new char[sizeof(msg_struct_s)];
2945
2946                 pTmp = (msg_struct_s *)pRejectMsgList->msg_struct_info[i];
2947                 pTmp->type = MSG_STRUCT_REJECT_MSG_INFO;
2948                 pTmp->data = new char[sizeof(MSG_FOLDER_INFO_S)];
2949                 MSG_REJECT_MSG_INFO_S * pMsg = (MSG_REJECT_MSG_INFO_S *)pTmp->data;
2950                 memset(pMsg, 0x00, sizeof(MSG_REJECT_MSG_INFO_S));
2951
2952                 pMsg->msgId = dbHandle.getColumnToInt(index++);
2953                 memset(pMsg->msgText, 0x00, sizeof(pMsg->msgText));
2954                 dbHandle.getColumnToString(index++, MAX_MSG_TEXT_LEN, pMsg->msgText);
2955
2956                 pMsg->displayTime = (time_t)dbHandle.getColumnToInt(index++);
2957         }
2958
2959         dbHandle.freeTable();
2960
2961         return MSG_SUCCESS;
2962 }
2963
2964
2965 msg_error_t MsgStoGetSyncMLExtId(msg_message_id_t msgId, int *extId)
2966 {
2967         char sqlQuery[MAX_QUERY_LEN+1];
2968
2969         memset(sqlQuery, 0x00, sizeof(sqlQuery));
2970
2971         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT EXT_ID FROM %s WHERE MSG_ID = %d;",
2972                         MSGFW_SYNCML_MSG_TABLE_NAME, msgId);
2973
2974         if (dbHandle.prepareQuery(sqlQuery) != MSG_SUCCESS)
2975                 return MSG_ERR_DB_PREPARE;
2976
2977         if (dbHandle.stepQuery() == MSG_ERR_DB_ROW) {
2978                 *extId = dbHandle.columnInt(0);
2979         } else {
2980                 dbHandle.finalizeQuery();
2981                 return MSG_ERR_DB_STEP;
2982         }
2983
2984         dbHandle.finalizeQuery();
2985
2986         return MSG_SUCCESS;
2987 }
2988
2989 msg_error_t MsgStoGetReportStatus(msg_message_id_t msgId, int *count, MSG_REPORT_STATUS_INFO_S **pReportStatus)
2990 {
2991         char sqlQuery[MAX_QUERY_LEN+1];
2992
2993         memset(sqlQuery, 0x00, sizeof(sqlQuery));
2994         //MSG_ID INTEGER , ADDRESS_VAL TEXT , STATUS_TYPE INTEGER , STATUS INTEGER DEFAULT 0 , TIME DATETIME)
2995         //select * from MSG_REPORT_TABLE where MSG_ID=38 order by ADDRESS_VAL DESC, STATUS_TYPE ASC;
2996         snprintf(sqlQuery, sizeof(sqlQuery),
2997                         "SELECT ADDRESS_VAL, STATUS_TYPE, STATUS, TIME "
2998                         "FROM %s "
2999                         "WHERE MSG_ID = %d "
3000                         "order by ADDRESS_VAL DESC, STATUS_TYPE ASC;"
3001                         , MSGFW_REPORT_TABLE_NAME, msgId);
3002
3003         int rowCnt;
3004         msg_error_t  err = dbHandle.getTable(sqlQuery, &rowCnt);
3005         if (err != MSG_SUCCESS) {
3006                 MSG_DEBUG("%s", sqlQuery);
3007                 dbHandle.freeTable();
3008                 return err;
3009         }
3010
3011         int index = 4;
3012
3013         *count =  rowCnt;
3014         MSG_REPORT_STATUS_INFO_S *report_status = (MSG_REPORT_STATUS_INFO_S*)new char[sizeof(MSG_REPORT_STATUS_INFO_S)*rowCnt];
3015         memset(report_status, 0x00, sizeof(MSG_REPORT_STATUS_INFO_S)*rowCnt);
3016
3017         for (int i = 0; i < rowCnt; i++) {
3018                 dbHandle.getColumnToString(index++, MAX_ADDRESS_VAL_LEN, report_status[i].addressVal);
3019                 report_status[i].type = dbHandle.getColumnToInt(index++);
3020                 report_status[i].status = dbHandle.getColumnToInt(index++);
3021                 report_status[i].statusTime = (time_t)dbHandle.getColumnToInt(index++);
3022
3023                 MSG_DEBUG("(%d/%d) addr = %s, report_type = %d, report_status = %d, report_time = %d", i, rowCnt, report_status[i].addressVal, report_status[i].type, report_status[i].status, report_status[i].statusTime );
3024         }
3025
3026         *pReportStatus = report_status;
3027
3028         return MSG_SUCCESS;
3029 }
3030
3031
3032 msg_error_t MsgStoGetThreadIdByAddress(const MSG_MESSAGE_INFO_S *pMsg, msg_thread_id_t *pThreadId)
3033 {
3034         if(pMsg->nAddressCnt > 0) {
3035                 if (MsgExistAddress(&dbHandle, pMsg, pThreadId) == true) {
3036                         MSG_DEBUG("Conversation ID : [%d]", *pThreadId);
3037                 } else {
3038                         *pThreadId = 0;
3039                         return MSG_ERR_STORAGE_ERROR;
3040                 }
3041         } else {
3042                 *pThreadId = 0;
3043         }
3044         return MSG_SUCCESS;
3045 }
3046
3047
3048 msg_error_t MsgStoGetThreadUnreadCnt(msg_thread_id_t threadId, int *cnt)
3049 {
3050         MSG_BEGIN();
3051
3052         int msgCnt = 0;
3053         *cnt = 0;
3054
3055         char sqlQuery[MAX_QUERY_LEN+1];
3056
3057         memset(sqlQuery, 0x00, sizeof(sqlQuery));
3058
3059         // Get MSG_ID
3060         memset(sqlQuery, 0x00, sizeof(sqlQuery));
3061         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT COUNT(MSG_ID) FROM %s A \
3062                         WHERE CONV_ID = %d AND READ_STATUS = 0;", MSGFW_MESSAGE_TABLE_NAME, threadId);
3063
3064         if (dbHandle.prepareQuery(sqlQuery) != MSG_SUCCESS)
3065                 return MSG_ERR_DB_PREPARE;
3066
3067         if (dbHandle.stepQuery() == MSG_ERR_DB_ROW) {
3068                 msgCnt = dbHandle.columnInt(0);
3069         }
3070
3071         dbHandle.finalizeQuery();
3072
3073         *cnt = msgCnt;
3074
3075         MSG_END();
3076
3077         return MSG_SUCCESS;
3078 }
3079
3080
3081 msg_error_t MsgStoGetAddressList(const msg_thread_id_t threadId, msg_struct_list_s *pAddrList)
3082 {
3083         msg_error_t err = MSG_SUCCESS;
3084
3085         int order = MsgGetContactNameOrder();
3086
3087         err = MsgStoGetAddressByConvId(&dbHandle, threadId, order, pAddrList);
3088
3089         return err;
3090 }
3091
3092
3093 msg_error_t MsgStoGetThreadInfo(msg_thread_id_t threadId, MSG_THREAD_VIEW_S *pThreadInfo)
3094 {
3095         MSG_BEGIN();
3096
3097         int rowCnt;
3098         int index = 11; // numbers of index
3099
3100         char sqlQuery[MAX_QUERY_LEN+1];
3101         memset(sqlQuery, 0x00, sizeof(sqlQuery));
3102
3103         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT A.CONV_ID, A.UNREAD_CNT, A.SMS_CNT, A.MMS_CNT, \
3104                         A.MAIN_TYPE, A.SUB_TYPE, A.MSG_DIRECTION, A.DISPLAY_TIME, A.DISPLAY_NAME, A.MSG_TEXT, \
3105                         (SELECT COUNT(*) FROM %s B WHERE B.CONV_ID = A.CONV_ID AND B.PROTECTED = 1) AS PROTECTED \
3106                         FROM %s A WHERE A.CONV_ID = %d;",
3107                         MSGFW_MESSAGE_TABLE_NAME, MSGFW_CONVERSATION_TABLE_NAME, threadId);
3108
3109         msg_error_t  err = dbHandle.getTable(sqlQuery, &rowCnt);
3110
3111         if (err == MSG_ERR_DB_NORECORD) {
3112                 dbHandle.freeTable();
3113                 return MSG_SUCCESS;
3114         } else if (err != MSG_SUCCESS) {
3115                 MSG_DEBUG("%s", sqlQuery);
3116                 dbHandle.freeTable();
3117                 return err;
3118         }
3119
3120         if (rowCnt < 1) {
3121                 MSG_DEBUG("rowCnt is %d", rowCnt);
3122                 dbHandle.freeTable();
3123                 return err;
3124         } else {
3125                 pThreadInfo->threadId = dbHandle.getColumnToInt(index++);
3126
3127                 pThreadInfo->unreadCnt = dbHandle.getColumnToInt(index++);
3128                 pThreadInfo->smsCnt = dbHandle.getColumnToInt(index++);
3129                 pThreadInfo->mmsCnt = dbHandle.getColumnToInt(index++);
3130
3131                 pThreadInfo->mainType = dbHandle.getColumnToInt(index++);
3132                 pThreadInfo->subType = dbHandle.getColumnToInt(index++);
3133
3134                 pThreadInfo->direction = dbHandle.getColumnToInt(index++);
3135                 pThreadInfo->threadTime = (time_t)dbHandle.getColumnToInt(index++);
3136
3137                 memset(pThreadInfo->threadName, 0x00, sizeof(pThreadInfo->threadName));
3138                 dbHandle.getColumnToString(index++, MAX_THREAD_NAME_LEN, pThreadInfo->threadName);
3139
3140                 memset(pThreadInfo->threadData, 0x00, sizeof(pThreadInfo->threadData));
3141                 dbHandle.getColumnToString(index++, MAX_THREAD_DATA_LEN, pThreadInfo->threadData);
3142
3143                 int protectedCnt = dbHandle.getColumnToInt(index++);
3144                 if (protectedCnt > 0)
3145                         pThreadInfo->bProtected = true;
3146         }
3147
3148         dbHandle.freeTable();
3149
3150         MSG_END();
3151
3152         return MSG_SUCCESS;
3153 }
3154
3155
3156 msg_error_t MsgStoGetMessageList(msg_folder_id_t folderId, msg_thread_id_t threadId, msg_message_type_t msgType, msg_storage_id_t storageId, msg_struct_list_s *pMsgList)
3157 {
3158         // Clear Out Parameter
3159         pMsgList->nCount = 0;
3160         pMsgList->msg_struct_info = NULL;
3161
3162         int rowCnt = 0;
3163         int index = 19; // numbers of index
3164
3165         char sqlQuery[MAX_QUERY_LEN+1];
3166         char sqlQuerySubset[(MAX_QUERY_LEN/5)+1];
3167
3168         // Get Name Order
3169         int order = MsgGetContactNameOrder();
3170
3171         memset(sqlQuery, 0x00, sizeof(sqlQuery));
3172
3173         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT MSG_ID, CONV_ID, FOLDER_ID, STORAGE_ID, MAIN_TYPE, SUB_TYPE, \
3174                         DISPLAY_TIME, DATA_SIZE, NETWORK_STATUS, READ_STATUS, PROTECTED, BACKUP, PRIORITY, \
3175                         MSG_DIRECTION, SCHEDULED_TIME, SUBJECT, MSG_TEXT, ATTACHMENT_COUNT, THUMB_PATH \
3176                         FROM %s WHERE ", MSGFW_MESSAGE_TABLE_NAME);
3177
3178
3179         //// folder
3180         memset(sqlQuerySubset, 0x00, sizeof(sqlQuerySubset));
3181
3182         if (folderId == MSG_ALLBOX_ID)
3183                 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "FOLDER_ID > 0 AND FOLDER_ID < %d ", MSG_CBMSGBOX_ID);
3184         else if (folderId == MSG_IOSBOX_ID)
3185                 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "FOLDER_ID > 0 AND FOLDER_ID < %d ", MSG_DRAFT_ID);
3186         else
3187                 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "FOLDER_ID = %d ", folderId);
3188
3189         strncat(sqlQuery, sqlQuerySubset, MAX_QUERY_LEN-strlen(sqlQuery));
3190
3191
3192         //// thread
3193         memset(sqlQuerySubset, 0x00, sizeof(sqlQuerySubset));
3194
3195         if (threadId > 0)
3196                 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "AND CONV_ID = %d ", threadId);
3197
3198         strncat(sqlQuery, sqlQuerySubset, MAX_QUERY_LEN-strlen(sqlQuery));
3199
3200
3201         //// msg type
3202         memset(sqlQuerySubset, 0x00, sizeof(sqlQuerySubset));
3203
3204         switch (msgType) {
3205                 case MSG_TYPE_SMS:
3206                         snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "AND MAIN_TYPE = %d AND SUB_TYPE = %d ", MSG_SMS_TYPE, MSG_NORMAL_SMS);
3207                         break;
3208
3209                 case MSG_TYPE_MMS:
3210                         snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "AND MAIN_TYPE = %d ", MSG_MMS_TYPE);
3211                         break;
3212
3213                 case MSG_TYPE_MMS_JAVA:
3214                         snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "AND MAIN_TYPE = %d AND SUB_TYPE = %d ", MSG_MMS_TYPE, MSG_SENDREQ_JAVA_MMS);
3215                         break;
3216
3217                 case MSG_TYPE_SMS_SYNCML:
3218                         snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "AND MAIN_TYPE = %d AND SUB_TYPE = %d ", MSG_SMS_TYPE, MSG_SYNCML_CP);
3219                         break;
3220
3221                 case MSG_TYPE_SMS_REJECT:
3222                         snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "AND MAIN_TYPE = %d AND SUB_TYPE = %d ", MSG_SMS_TYPE, MSG_REJECT_SMS);
3223                         break;
3224
3225                 default:
3226                         MSG_DEBUG("msg type is not set.");
3227         }
3228
3229         strncat(sqlQuery, sqlQuerySubset, MAX_QUERY_LEN-strlen(sqlQuery));
3230
3231         //// storage
3232         memset(sqlQuerySubset, 0x00, sizeof(sqlQuerySubset));
3233
3234         if (storageId > MSG_STORAGE_UNKNOWN)
3235                 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "AND STORAGE_ID = %d ", storageId);
3236
3237         strncat(sqlQuery, sqlQuerySubset, MAX_QUERY_LEN-strlen(sqlQuery));
3238
3239
3240         /// order
3241         memset(sqlQuerySubset, 0x00, sizeof(sqlQuerySubset));
3242         snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "ORDER BY DISPLAY_TIME DESC;");
3243
3244         strncat(sqlQuery, sqlQuerySubset, MAX_QUERY_LEN-strlen(sqlQuery));
3245
3246         msg_error_t err = dbHandle.getTable(sqlQuery, &rowCnt);
3247
3248         if (err == MSG_ERR_DB_NORECORD) {
3249                 dbHandle.freeTable();
3250
3251                 return MSG_SUCCESS;
3252         } else if (err != MSG_SUCCESS) {
3253                 MSG_DEBUG("Get table fail. [%s]", sqlQuery);
3254
3255                 dbHandle.freeTable();
3256
3257                 return err;
3258         }
3259
3260         pMsgList->nCount = rowCnt;
3261
3262         MSG_DEBUG("pMsgList->nCount [%d]", pMsgList->nCount);
3263
3264         pMsgList->msg_struct_info = (msg_struct_t *)new char[sizeof(msg_struct_t) * rowCnt];
3265
3266         MSG_MESSAGE_HIDDEN_S *pTmp = NULL;
3267         msg_struct_s *msg = NULL;
3268
3269         for (int i = 0; i < rowCnt; i++) {
3270                 pMsgList->msg_struct_info[i] = (msg_struct_t)new msg_struct_s;
3271
3272                 msg = (msg_struct_s *)pMsgList->msg_struct_info[i];
3273
3274                 msg->type = MSG_STRUCT_MESSAGE_INFO;
3275                 msg->data = (int *)new char[sizeof(MSG_MESSAGE_HIDDEN_S)];
3276
3277                 pTmp = (MSG_MESSAGE_HIDDEN_S *)msg->data;
3278
3279                 memset(pTmp, 0x00, sizeof(MSG_MESSAGE_HIDDEN_S));
3280
3281                 pTmp->pData = NULL;
3282                 pTmp->pMmsData = NULL;
3283
3284                 pTmp->msgId = dbHandle.getColumnToInt(index++);
3285                 pTmp->threadId = dbHandle.getColumnToInt(index++);
3286                 pTmp->folderId = dbHandle.getColumnToInt(index++);
3287                 pTmp->storageId = dbHandle.getColumnToInt(index++);
3288                 pTmp->mainType = dbHandle.getColumnToInt(index++);
3289                 pTmp->subType = dbHandle.getColumnToInt(index++);
3290                 pTmp->displayTime = (time_t)dbHandle.getColumnToInt(index++);
3291                 pTmp->dataSize = dbHandle.getColumnToInt(index++);
3292                 pTmp->networkStatus = dbHandle.getColumnToInt(index++);
3293                 pTmp->bRead = dbHandle.getColumnToInt(index++);
3294                 pTmp->bProtected = dbHandle.getColumnToInt(index++);
3295                 pTmp->bBackup = dbHandle.getColumnToInt(index++);
3296                 pTmp->priority = dbHandle.getColumnToInt(index++);
3297                 pTmp->direction = dbHandle.getColumnToInt(index++);
3298                 index++; // This field is reserved.
3299
3300                 dbHandle.getColumnToString(index++, MAX_SUBJECT_LEN, pTmp->subject);
3301
3302                 if (pTmp->mainType == MSG_MMS_TYPE &&
3303                         (pTmp->networkStatus == MSG_NETWORK_RETRIEVING || pTmp->networkStatus == MSG_NETWORK_RETRIEVE_FAIL || pTmp->subType == MSG_NOTIFICATIONIND_MMS)) {
3304                         pTmp->pData = NULL;
3305                         index++;
3306                 } else {
3307                         pTmp->pData = (void *)new char[pTmp->dataSize+2];
3308                         memset(pTmp->pData, 0x00, pTmp->dataSize+2);
3309
3310                         dbHandle.getColumnToString(index++, pTmp->dataSize+1, (char *)pTmp->pData);
3311                 }
3312
3313                 pTmp->attachCount = dbHandle.getColumnToInt(index++);
3314
3315                 dbHandle.getColumnToString(index++, MSG_FILEPATH_LEN_MAX, pTmp->thumbPath);
3316
3317                 // add address information.
3318                 order = MsgGetContactNameOrder();
3319
3320                 msg_struct_list_s *addr_list = (msg_struct_list_s *)new msg_struct_list_s;
3321                 MsgStoGetAddressByMsgId(&dbHandle, pTmp->msgId, order, addr_list);
3322
3323                 pTmp->addr_list = addr_list;
3324         }
3325         dbHandle.freeTable();
3326
3327         return MSG_SUCCESS;
3328 }