src/Messaging/Messaging.cpp

   1 //
   2 // Tizen Web Device API
   3 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Apache License, Version 2.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 // http://www.apache.org/licenses/LICENSE-2.0
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an "AS IS" BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17
  18 #include <email-types.h>
  19 #include <email-api.h>
  20
  21 #include <Commons/Exception.h>
  22 #include <Commons/StringUtils.h>
  23 #include <dpl/scoped_free.h>
  24 #include "Messaging.h"
  25 #include "Sms.h"
  26 #include "Mms.h"
  27 #include "BinarySms.h"
  28 #include "Email.h"
  29 #include "EmailConverter.h"
  30 #include "log.h"
  31 #include "StorageChangesMessageFilterValidatorFactory.h"
  32 #include "StorageChangesConversationFilterValidatorFactory.h"
  33 #include "StorageChangesFolderFilterValidatorFactory.h"
  34 #include "MessageQueryGenerator.h"
  35 #include "ConversationQueryGenerator.h"
  36 #include "FolderQueryGenerator.h"
  37 #include "messageDB/MessageStorageReader.h"
  38
  39 extern "C" {
  40 #include <msg_storage.h>
  41 #include <msg.h>
  42 #include <msg_transport.h>
  43 }
  44
  45 #include <Commons/ThreadPool.h>
  46 #include "Conversation.h"
  47 #include "MessageFolder.h"
  48 #include <dpl/singleton_safe_impl.h>
  49 #include <Logger.h>
  50
  51 IMPLEMENT_SAFE_SINGLETON(DeviceAPI::Messaging::MsgServiceHandle)
  52
  53
  54 #define LOG_ENTER LoggerD("---> ENTER");
  55 #define LOG_EXIT LoggerD("---> EXIT");
  56
  57
  58 using namespace std;
  59 using namespace DeviceAPI::Tizen;
  60 using namespace WrtDeviceApis::Commons;
  61
  62 namespace {
  63 const char* DBUS_INTERFACE_EMAIL_RECEIVED = "User.Email.StorageChange";
  64 const char* DBUS_FILTER_EMAIL_RECEIVED =
  65     "type='signal',interface='User.Email.StorageChange'";
  66
  67 const int MESSAGE_FIND_LIMIT = 100;
  68 }
  69
  70 namespace DeviceAPI {
  71 namespace Messaging {
  72
  73 int Messaging::m_currentEmailAccountId = 0;
  74 DPL::Atomic Messaging::m_objCounter;
  75
  76 Messaging& Messaging::getInstance()
  77 {
  78     static Messaging instance;
  79     return instance;
  80 }
  81
  82 Messaging::Messaging() :
  83     m_onMessageReceivedHandleMgr(NULL),
  84     m_dbusConnection(new DBus::Connection()),
  85     m_dbusWorkerThread(new DPL::Thread())
  86 {
  87     Try
  88     {
  89         const vector<EmailAccountInfo> accounts = getEmailAccounts();
  90         LoggerD("Number of emails account=" << accounts.size());
  91         if (accounts.size() > 0) {
  92             // set default email account - first from the list
  93             setCurrentEmailAccount(accounts[0]);
  94         } else {
  95             LoggerE("no default email account set");
  96         }
  97     }
  98
  99     Catch(WrtDeviceApis::Commons::PlatformException) {
 100         LoggerE("No email accounts available");
 101     }
 102
 103     Catch(WrtDeviceApis::Commons::InvalidArgumentException) {
 104         LoggerE("No email accounts available");
 105         //current email not configured, skipped
 106     }
 107
 108     Catch(WrtDeviceApis::Commons::UnknownException) {
 109         LoggerE("unknown error");
 110     }
 111
 112     // Begin service for email management ?? pmi question if it should be added before email actions
 113     if (0 == m_objCounter) {
 114         int error = email_service_begin();
 115         if (EMAIL_ERROR_NONE != error) {
 116             LoggerE("email_service_begin() returned error " << error);
 117         } else {
 118             LoggerI("email_service_begin() executed without error");
 119         }
 120     }
 121     ++m_objCounter;
 122
 123     m_dbusWorkerThread->Run();
 124     m_dbusConnection->setWorkerThread(m_dbusWorkerThread);
 125     m_dbusConnection->addFilter(DBUS_FILTER_EMAIL_RECEIVED);
 126     m_dbusConnection->AddListener(this);
 127 }
 128
 129 Messaging::~Messaging()
 130 {
 131     // Endservice for email management
 132     m_dbusConnection->RemoveListener(this);
 133 //    m_dbusConnection->setWorkerThread(NULL);
 134     m_dbusWorkerThread->Quit();
 135     delete m_dbusWorkerThread;
 136
 137     if (!--m_objCounter) {
 138         int error = email_service_end();
 139         if (EMAIL_ERROR_NONE != error) {
 140             LoggerE("email_service_end() returned error " << error);
 141         } else {
 142             LoggerD("email_service_end() executed without error");
 143         }
 144     }
 145 }
 146
 147 /*
 148 void Messaging::getNumberOfMessages(MessageType msgType,
 149         FolderType folder,
 150         int* readed,
 151         int* unReaded)
 152 {
 153     if (NULL == readed ||
 154         NULL == unReaded) {
 155         LoggerE("output pointers are NULL");
 156         Throw(WrtDeviceApis::Commons::InvalidArgumentException);
 157     }
 158     *readed = 0;
 159     *unReaded = 0;
 160     if (SMS == msgType) {
 161         getNumberOfSms(folder, readed, unReaded);
 162     } else if (MMS == msgType) {
 163         getNumberOfMms(folder, readed, unReaded);
 164     } else if (EMAIL == msgType) {
 165         getNumberOfEmails(folder, readed, unReaded);
 166     } else {
 167         LoggerE("wrong message type");
 168         Throw(WrtDeviceApis::Commons::PlatformException);
 169     }
 170 }
 171
 172 vector<IMessagePtr> Messaging::findMessages(const vector<MessageType>& msgTypes,
 173         const string &folder,
 174         const DeviceAPI::Tizen::FilterPtr& filter)
 175 {
 176     LoggerD("enter");
 177     vector<IMessagePtr> retVal;
 178     back_insert_iterator< vector<IMessagePtr> > biit(retVal);
 179     vector<MessageType>::const_iterator it = msgTypes.begin();
 180     for (; it != msgTypes.end(); ++it) {
 181         LoggerD("Finding messages (" << *it << ")  in folder: " << folder);
 182         vector<IMessagePtr> result;
 183
 184         switch (*it) {
 185         case SMS:
 186         {
 187             FolderType folderEnum = Sms::toFolder(folder);
 188             result = findSms(folderEnum, filter);
 189             break;
 190         }
 191         case MMS:
 192         {
 193             FolderType folderEnum = Mms::toFolder(folder);
 194             result = findMms(folderEnum, filter);
 195             break;
 196         }
 197         case EMAIL:
 198         {
 199             result = findEmail(folder, filter);
 200             break;
 201         }
 202         default:
 203             LoggerE("message type unknown");
 204             Throw(WrtDeviceApis::Commons::PlatformException);
 205         }
 206         LoggerD("Found: " << result.size());
 207         copy(result.begin(), result.end(), biit);
 208     }
 209
 210     return retVal;
 211 }
 212 */
 213 std::string Messaging::generateFilterSql(const DeviceAPI::Tizen::FilterPtr& filter){
 214         LoggerD("<<<");
 215         std::string filterSql;
 216
 217         MessageQueryGeneratorPtr queryGenerator(new MessageQueryGenerator());
 218         IFilterVisitorPtr filterVisitor = DPL::StaticPointerCast<IFilterVisitor>(queryGenerator);
 219         filter->travel(filterVisitor, 0);
 220         filterSql = queryGenerator->getQuery();
 221
 222         LoggerD(">>> filterSql:[" << filterSql << "]");
 223         return filterSql;
 224 }
 225
 226 /*
 227         vector<IMessagePtr> Messaging::findMessages(const vector<MessageType>& msgTypes, FolderType folder,
 228                         const DeviceAPI::Tizen::FilterPtr& filter)
 229 {
 230         LoggerD("enter");
 231         vector<IMessagePtr> retVal;
 232         back_insert_iterator< vector<IMessagePtr> > biit(retVal);
 233
 234         std::string filterSql = generateFilterSql(filter);
 235
 236
 237
 238         vector<MessageType>::const_iterator it = msgTypes.begin();
 239         for (; it != msgTypes.end(); ++it) {
 240                 LoggerD("Finding messages (" << *it << ")  in folder: " << folder);
 241                 vector<IMessagePtr>(Messaging::*findFnPtr)(FolderType folder, const DeviceAPI::Tizen::FilterPtr& filter) = NULL;
 242
 243                 switch (*it) {
 244                         case SMS:
 245                         {
 246                                 findFnPtr = &Messaging::findSms;
 247                                 break;
 248                         }
 249                         case MMS:
 250                         {
 251                                 findFnPtr = &Messaging::findMms;
 252                                 break;
 253                         }
 254                         case EMAIL:
 255                         {
 256                                 findFnPtr = &Messaging::findEmail;
 257                                 break;
 258                         }
 259                         default:
 260                         LoggerE("message type unknown");
 261                         Throw(WrtDeviceApis::Commons::PlatformException);
 262                 }
 263
 264                 vector<IMessagePtr> result = (this->*findFnPtr)(folder, filter);
 265                 LoggerD("Found: " << result.size());
 266                 copy(result.begin(), result.end(), biit);
 267         }
 268
 269         return retVal;
 270 }
 271 */
 272         void Messaging::printErrorMessage(int errorCode){
 273                 switch(errorCode){
 274                         case EMAIL_ERROR_MAIL_NOT_FOUND:{
 275                                 LoggerD("EMAIL_ERROR_MAIL_NOT_FOUND");
 276                                 break;
 277                         }
 278                         case EMAIL_ERROR_DB_FAILURE:{
 279                                 LoggerD("EMAIL_ERROR_DB_FAILURE");
 280                                 break;
 281                         }
 282                         default:{
 283                                 LoggerD("other error message:" << errorCode);
 284                 }
 285         }
 286         }
 287
 288         vector<IMessagePtr> Messaging::createVectorFromeMessageList(const msg_struct_list_s &message_list){
 289 //      vector<IMessagePtr> Messaging::createVectorFromeMessageList(const msg_struct_list_s message_list){
 290                 LoggerD("<<<");
 291
 292                 vector<IMessagePtr> retVal;
 293                 int tempInt;
 294 //              int l_msgId = 0;
 295                 MessageType webApiMsgType;
 296
 297                 LoggerD("message_list.nCount:" << message_list.nCount);
 298                 for (int i = 0; i < message_list.nCount; i++) {
 299                         int err = msg_get_int_value(message_list.msg_struct_info[i], MSG_MESSAGE_TYPE_INT, &tempInt);
 300                         if(err != MSG_SUCCESS)
 301                         {
 302                                 ThrowMsg(WrtDeviceApis::Commons::UnknownException, "get message type fail");
 303                         }
 304                         LoggerD("Message type : " << tempInt);
 305
 306                         switch(tempInt){
 307                                 case MSG_TYPE_SMS:{
 308                                         webApiMsgType = SMS;
 309                                         break;
 310                                 }
 311                                 case MSG_TYPE_MMS:{
 312                                         webApiMsgType = MMS;
 313                                         break;
 314                                 }
 315                                 default:{
 316                                         LoggerE("[ERROR]invalid message type:" << tempInt);
 317                                         continue;
 318                                 }
 319                         }
 320
 321 //                      int l_msgId = msg_get_message_id(message_list.msgInfo[i]);
 322                         err = msg_get_int_value(message_list.msg_struct_info[i], MSG_MESSAGE_ID_INT, &tempInt);
 323                         LoggerD("Message Id : " << tempInt);
 324                         if(err != MSG_SUCCESS)
 325                         {
 326                                 ThrowMsg(WrtDeviceApis::Commons::UnknownException, "get message id fail");
 327                         }
 328
 329                         IMessagePtr msg;
 330                         msg = MessageFactory::createMessage(webApiMsgType, tempInt);
 331                         retVal.push_back(msg);
 332                 }       //for
 333
 334                 LoggerD(">>>");
 335                 return retVal;
 336         }
 337
 338         std::vector<IConversationPtr> Messaging::createVectorFromeThreadViewList(const msg_struct_list_s& threadViewList){
 339                 vector<IConversationPtr> recVec;
 340
 341                 if (threadViewList.nCount <= 0) {
 342                         LoggerD("Empty...");
 343                 }       else    {
 344                         for (int i = 0; i < threadViewList.nCount; i++)         {
 345 //                              IConversationPtr convPtr(new Conversation(i));
 346                                 IConversationPtr convPtr(new Conversation(threadViewList.msg_struct_info[i]));
 347
 348                                 recVec.push_back(convPtr);
 349                         }
 350                 }
 351
 352                 return recVec;
 353         }
 354
 355         vector<IMessagePtr> Messaging::querySmsMmsMessages(const std::string& queryString){
 356                 LoggerD("<<< queryString:[" << queryString <<"]");
 357
 358                 vector<IMessagePtr> retVal;
 359                 std::string tempString = "";
 360 //              MSG_LIST_S message_list = {0, NULL};
 361                 msg_struct_list_s message_list = {0,};
 362                 MessageStorageReader reader;
 363
 364                 Try{
 365                         msg_error_t res = MSG_ERR_UNKNOWN;
 366
 367                         reader.MsgStoConnectDB();
 368                         res = reader.queryMessage(queryString, tempString, &message_list);
 369
 370                         if (MSG_SUCCESS != res) {
 371                                 LoggerE("msg_get_folder_view_list failed " << res);
 372                                 Throw(WrtDeviceApis::Commons::PlatformException);
 373                         }
 374                         reader.MsgStoDisconnectDB();
 375
 376                         retVal = createVectorFromeMessageList(message_list);
 377                         reader.msg_release_list_struct_private(&message_list);
 378                 }Catch(WrtDeviceApis::Commons::PlatformException) {
 379                         LoggerE("Problem with message creation, cleaning");
 380                         if (message_list.nCount) {
 381                                 reader.msg_release_list_struct_private(&message_list);
 382                         }
 383                         throw;
 384                 }       //Catch
 385
 386                 LoggerD(">>>");
 387                 return retVal;
 388         }
 389
 390         vector<IMessagePtr> Messaging::querySmsMmsMessages(const std::string& queryString, const std::string& orderLimitString){
 391                 LoggerD("<<< queryString:[" << queryString <<"]");
 392                 LoggerD("<<< orderLimitString:[" << orderLimitString <<"]");
 393
 394                 vector<IMessagePtr> retVal;
 395 //              MSG_LIST_S message_list = {0, NULL};
 396                 msg_struct_list_s message_list = {0,};
 397                 MessageStorageReader reader;
 398
 399                 Try{
 400                         msg_error_t res = MSG_ERR_UNKNOWN;
 401
 402                         reader.MsgStoConnectDB();
 403                         res = reader.queryMessage(queryString, orderLimitString, &message_list);
 404
 405                         if (MSG_SUCCESS != res) {
 406                                 LoggerE("msg_get_folder_view_list failed " << res);
 407                                 Throw(WrtDeviceApis::Commons::PlatformException);
 408                         }
 409                         reader.MsgStoDisconnectDB();
 410
 411                         retVal = createVectorFromeMessageList(message_list);
 412                         LoggerD("<<< message_list.nCount:[" << message_list.nCount <<"]");
 413
 414                         reader.msg_release_list_struct_private(&message_list);
 415                 }Catch(WrtDeviceApis::Commons::PlatformException) {
 416                         LoggerE("Problem with message creation, cleaning");
 417                         if (message_list.nCount) {
 418                                 reader.msg_release_list_struct_private(&message_list);
 419                         }
 420                         throw;
 421                 }       //Catch
 422
 423                 LoggerD(">>>");
 424                 return retVal;
 425         }
 426
 427 vector<IConversationPtr> Messaging::querySmsMmsConversation(const std::string& sqlWhereClause, const std::string& orderLimitString){
 428         LoggerD("sqlWhereClause:[" << sqlWhereClause << "]");
 429         LoggerD("<<< orderLimitString:[" << orderLimitString <<"]");
 430
 431         std::vector<IConversationPtr> recVec;
 432 //      MSG_THREAD_VIEW_LIST_S threadViewList;
 433         msg_struct_list_s threadViewList;
 434
 435         msg_error_t res = MSG_ERR_UNKNOWN;
 436
 437         MessageStorageReader reader;
 438         reader.MsgStoConnectDB();
 439         res = reader.queryConversation(sqlWhereClause, orderLimitString, &threadViewList);
 440
 441         if (MSG_SUCCESS != res) {
 442                 LoggerE("queryConversation failed:" << res);
 443                 Throw(WrtDeviceApis::Commons::PlatformException);
 444         }
 445         reader.MsgStoDisconnectDB();
 446
 447         recVec = createVectorFromeThreadViewList(threadViewList);
 448
 449         reader.msg_release_list_struct_private(&threadViewList);
 450
 451         LoggerD(">>>");
 452         return recVec;
 453 }
 454
 455 vector<IConversationPtr> Messaging::queryEmailConversation(const std::string& sqlWhereClause){
 456         LoggerD("sqlWhereClause:[" << sqlWhereClause << "]");
 457
 458         std::vector<IConversationPtr> emailResultVector;
 459         email_mail_list_item_t* mailList = NULL;
 460         int mailListCount = 0;
 461         int errCode = 0;
 462         errCode = email_query_mail_list(const_cast<char*>(sqlWhereClause.c_str()), &mailList, &mailListCount);
 463
 464         if(errCode != EMAIL_ERROR_NONE){
 465                 LoggerE("[ERROR]email_query_mail_list failed:" << errCode);
 466                 printErrorMessage(errCode);
 467         }else{
 468                 LoggerD("message found mailListCount:" << mailListCount);
 469                 std::map<int, int> checkUnique;
 470
 471                 for(int i=0; i<mailListCount; i++){
 472                         if (checkUnique.find(mailList[i].thread_id) == checkUnique.end()){
 473                                 checkUnique[mailList[i].thread_id] = mailList[i].thread_id;
 474                                 IConversationPtr convPtr(new Conversation(mailList[i].thread_id, EMAIL));
 475
 476                                 //TODO for debug
 477                                 LoggerD("mailList[i].thread_id:[" << mailList[i].thread_id << "]");
 478                                 LoggerD("mailList[i].full_address_from:[" << mailList[i].full_address_from << "]");
 479                                 LoggerD("mailList[i].email_address_sender : [" << mailList[i].email_address_sender <<"]");
 480                                 LoggerD("mailList[i].subject:[" << mailList[i].subject << "]");
 481                                 LoggerD("mailList[i].preview_text:[" << mailList[i].preview_text << "]");
 482                                 LoggerD("mailList[i].flags_seen_field:[" << mailList[i].flags_seen_field << "]");
 483                                 LoggerD("mailList[i].priority:[" << mailList[i].priority<< "]");
 484
 485                                 if (convPtr->getResult() == true)
 486                                 {
 487                                         emailResultVector.push_back(convPtr);
 488                                 }
 489                         }       //if
 490                 }//for
 491         }//if
 492
 493         if (mailList != NULL){
 494                 free(mailList);
 495         }
 496
 497         LoggerD(">>>");
 498         return emailResultVector;
 499 }
 500
 501 vector<IMessagePtr> Messaging::queryEmailMessage(const std::string& sqlWhereClause){
 502         LoggerD("sqlWhereClause:[" << sqlWhereClause << "]");
 503
 504         vector<IMessagePtr> emailResultVector;
 505
 506         email_mail_list_item_t* mailList = NULL;
 507         int mailListCount = 0;
 508         int errCode = 0;
 509         errCode = email_query_mail_list(const_cast<char*>(sqlWhereClause.c_str()), &mailList, &mailListCount);
 510
 511         if(errCode != EMAIL_ERROR_NONE){
 512                 LoggerE("[ERROR]email_query_mail_list failed:" << errCode);
 513                 printErrorMessage(errCode);
 514         }else{
 515                 LoggerD("message found mailListCount:" << mailListCount);
 516
 517                 for(int i=0; i<mailListCount; i++){
 518                         //IMessagePtr msg = MessageFactory::createMessage(EMAIL, mailList[i].mail_id);
 519                         IMessagePtr msg = MessageFactory::createEmailMessage(mailList[i].account_id, mailList[i].mail_id);
 520
 521                         //TODO for debug
 522                         LoggerD("mailList[i].full_address_from:[" << mailList[i].full_address_from << "]");
 523                         LoggerD("mailList[i].email_address_sender : [" << mailList[i].email_address_sender <<"]");
 524                         //LoggerD("mailList[i].datetime:[" << mailList[i].datetime << "]");
 525                         LoggerD("mailList[i].subject:[" << mailList[i].subject << "]");
 526 //                      LoggerD("mailList[i].mailbox_name:[" << mailList[i].mailbox_name << "]");
 527                         LoggerD("mailList[i].preview_text:[" << mailList[i].preview_text << "]");
 528                         LoggerD("mailList[i].flags_seen_field:[" << mailList[i].flags_seen_field << "]");
 529                         LoggerD("mailList[i].priority:[" << mailList[i].priority<< "]");
 530
 531                         emailResultVector.push_back(msg);
 532                 }//for
 533         }//if
 534
 535         if (mailList != NULL)           {
 536                 free(mailList);
 537         }
 538
 539         LoggerD(">>>");
 540         return emailResultVector;
 541 }
 542 /*
 543 vector<IMessagePtr> Messaging::findMessages(const DeviceAPI::Tizen::FilterPtr& filter){
 544         LoggerD("<<<");
 545
 546         vector<IMessagePtr> retVal;
 547         std::string filterSql;
 548
 549         MessageQueryGeneratorPtr queryGenerator(new MessageQueryGenerator());
 550
 551         IFilterVisitorPtr filterVisitor = DPL::StaticPointerCast<IFilterVisitor>(queryGenerator);
 552         filter->travel(filterVisitor, 0);
 553         filterSql = queryGenerator->getQuery();
 554         LoggerD("filterSql:[" << filterSql <<"]");
 555
 556         int messageType = queryGenerator->getMessageType();
 557         switch(messageType){
 558                 case EMAIL:
 559                         LoggerD("message type is EMAIL:[" << messageType <<"]");
 560                         retVal = queryEmailMessage(filterSql);
 561                         break;
 562
 563                 case SMS:
 564                 case MMS:
 565                         LoggerD("message type is SMS or MMS:[" << messageType <<"]");
 566                         queryGenerator->reset(MessageQueryGenerator::MODE_SMS_MMS);
 567                         filterVisitor = DPL::StaticPointerCast<IFilterVisitor>(queryGenerator);
 568                         filter->travel(filterVisitor);
 569                         filterSql = queryGenerator->getQuery();
 570                         retVal = querySmsMmsMessages(filterSql);
 571                         break;
 572
 573                 default:
 574                         LoggerE("[ERROR] >>> invlid message type:[" << messageType <<"]");
 575                         return retVal;
 576         }
 577
 578         LoggerD(">>>");
 579         return retVal;
 580 }
 581 */
 582 /*
 583 //TODO refactoring
 584 vector<IMessagePtr> Messaging::findMessages(const DeviceAPI::Tizen::FilterPtr& filter, const DeviceAPI::Tizen::SortModePtr& sortMode, const long limit, const long offset)
 585 {
 586         LoggerD("<<<");
 587
 588         vector<IMessagePtr> retVal;
 589         std::string filterSql;
 590
 591         MessageQueryGeneratorPtr queryGenerator(new MessageQueryGenerator(sortMode, limit, offset));
 592
 593         IFilterVisitorPtr filterVisitor = DPL::StaticPointerCast<IFilterVisitor>(queryGenerator);
 594         filter->travel(filterVisitor, 0);
 595         filterSql = queryGenerator->getQuery();
 596         LoggerD("filterSql:[" << filterSql <<"]");
 597
 598         int messageType = queryGenerator->getMessageType();
 599         switch(messageType){
 600                 case EMAIL:
 601                         LoggerD("message type is EMAIL:[" << messageType <<"]");
 602                         retVal = queryEmailMessage(filterSql);
 603                         break;
 604
 605                 case SMS:
 606                 case MMS:
 607                         LoggerD("message type is SMS or MMS:[" << messageType <<"]");
 608                         queryGenerator->reset(MessageQueryGenerator::MODE_SMS_MMS);
 609                         filterVisitor = DPL::StaticPointerCast<IFilterVisitor>(queryGenerator);
 610                         filter->travel(filterVisitor);
 611                         filterSql = queryGenerator->getQuery();
 612                         retVal = querySmsMmsMessages(filterSql);
 613                         break;
 614
 615                 default:
 616                         MsgLoggerE("[ERROR] >>> invlid message type:[" << messageType <<"]");
 617                         return retVal;
 618         }
 619
 620         LoggerD(">>>");
 621         return retVal;
 622 }
 623 */
 624 vector<IMessagePtr> Messaging::findMessages(const DeviceAPI::Tizen::FilterPtr& filter, const DeviceAPI::Tizen::SortModePtr& sortMode, const long limit, const long offset, const int type)
 625 {
 626         LoggerD("<<<");
 627
 628         vector<IMessagePtr> retVal;
 629         std::string filterSql;
 630         std::string orderLimitSql ="";
 631         std::string emailFilterSql;
 632         std::string typeAndString = "AND A.MAIN_TYPE=";
 633         std::string typeString = "A.MAIN_TYPE=";
 634
 635         MessageQueryGeneratorPtr queryGenerator(new MessageQueryGenerator(sortMode, limit, offset, type));
 636
 637         IFilterVisitorPtr filterVisitor = DPL::StaticPointerCast<IFilterVisitor>(queryGenerator);
 638         filter->travel(filterVisitor, 0);
 639         filterSql = queryGenerator->getQuery();
 640         orderLimitSql = queryGenerator->getOrderLimit();
 641         LoggerD("filterSql:[" << filterSql <<"]");
 642         LoggerD("orderLimitSql:[" << orderLimitSql <<"]");
 643
 644         int messageType = queryGenerator->getMessageType();
 645         if(messageType != -1)
 646         {
 647                 if(messageType != type)
 648                 {
 649                         LoggerD("filter messageType and service msg type is diff");
 650                         ThrowMsg(WrtDeviceApis::Commons::InvalidArgumentException, "invalid Fiilter Type");
 651                 }
 652         }
 653         switch(type){
 654                 case EMAIL:
 655                         LoggerD("message type is EMAIL:[" << messageType <<"]");
 656                         emailFilterSql = filterSql + orderLimitSql;
 657                         LoggerD("filterSql:[" << emailFilterSql <<"]");
 658                         retVal = queryEmailMessage(emailFilterSql);
 659                         break;
 660
 661                 case SMS:
 662                         LoggerD("message type is SMS :[" << messageType <<"]");
 663                         typeString.append("1");
 664                         typeAndString.append("1");
 665                         if(filterSql.length() == 0)
 666                         {
 667                                 filterSql.append(typeString);
 668                                 LoggerD("filterSql:[" << filterSql <<"]");
 669                         }
 670                         else
 671                         {
 672                                 filterSql.append(typeAndString);
 673                                 LoggerD("filterSql:[" << filterSql <<"]");
 674                         }
 675                         LoggerD("filterSql:[" << filterSql <<"]");
 676                         LoggerD("orderLimitSql.length():[" << orderLimitSql.length() <<"]");
 677                         retVal = querySmsMmsMessages(filterSql, orderLimitSql);
 678                         LoggerD("filterSql:[" << filterSql <<"]");
 679                         break;
 680                 case MMS:
 681                         LoggerD("message type is MMS:[" << messageType <<"]");
 682                         typeString.append("2");
 683                         typeAndString.append("2");
 684                         if(filterSql.length() == 0)
 685                         {
 686                                 filterSql.append(typeString);
 687                                 LoggerD("filterSql:[" << filterSql <<"]");
 688                         }
 689                         else
 690                         {
 691                                 filterSql.append(typeAndString);
 692                                 LoggerD("filterSql:[" << filterSql <<"]");
 693                         }
 694                         LoggerD("filterSql:[" << filterSql <<"]");
 695                         LoggerD("orderLimitSql.length():[" << orderLimitSql.length() <<"]");
 696                         retVal = querySmsMmsMessages(filterSql, orderLimitSql);
 697                         LoggerD("filterSql:[" << filterSql <<"]");
 698                         break;
 699
 700                 default:
 701                         MsgLoggerE("[ERROR] >>> invlid message type:[" << messageType <<"]");
 702                         return retVal;
 703         }
 704
 705         LoggerD(">>>");
 706         return retVal;
 707 }
 708
 709 /*
 710 vector<string> Messaging::getMessageIds(MessageType msgType,
 711         FolderType folder)
 712 {
 713     switch (msgType) {
 714     case SMS:
 715         return getSmsIds(folder);
 716     case MMS:
 717         return getMmsIds(folder);
 718     case EMAIL:
 719         return getEmailIds(folder);
 720     default:
 721         LoggerE("not supported message type");
 722         Throw(WrtDeviceApis::Commons::InvalidArgumentException);
 723     }
 724 }
 725
 726 vector<string> Messaging::getSmsIds(FolderType folder)
 727 {
 728     vector<string> retVal;
 729     msg_message_t msg = msg_new_message();
 730     MSG_LIST_S folder_list_view = { 0, NULL };
 731
 732     Try
 733     {
 734         const MSG_SORT_RULE_S sort_rules = { MSG_SORT_BY_DISPLAY_TIME, true };
 735         msg_error_t res = MSG_ERR_UNKNOWN;
 736         const msg_folder_id_t platformFolder = convertFolderToPlatform(folder);
 737         res = msg_get_folder_view_list(
 738                 MsgGetCommonHandle(), platformFolder, &sort_rules,
 739                 &folder_list_view);
 740
 741         if (MSG_SUCCESS != res) {
 742             LoggerE("msg_Get_folder_view_list failed" << res);
 743             Throw(WrtDeviceApis::Commons::PlatformException);
 744         }
 745
 746         for (int i = 0; i < folder_list_view.nCount; i++) {
 747             if (MSG_TYPE_SMS ==
 748                                 msg_get_message_type(folder_list_view.
 749                                                      msgInfo[i])) {
 750                                 int l_msgId = msg_get_message_id(
 751                         folder_list_view.msgInfo[i]);
 752                 ostringstream stream;
 753                 stream << l_msgId;
 754                 retVal.push_back(stream.str());
 755             }
 756         }
 757
 758                 msg_release_list_struct(&folder_list_view);
 759     }
 760
 761     Catch(WrtDeviceApis::Commons::PlatformException) {
 762         LoggerE("Problem with message creation, cleaning");
 763         if (folder_list_view.nCount) {
 764                         msg_release_list_struct(&folder_list_view);
 765         }
 766         if (msg) {
 767             msg_release_message(&msg);
 768         }
 769         throw;
 770     }
 771
 772     return retVal;
 773 }
 774
 775 vector<string> Messaging::getMmsIds(FolderType folder)
 776 {
 777     vector<string> retVal;
 778     msg_message_t msg = msg_new_message();
 779     MSG_LIST_S folder_list_view = { 0, NULL };
 780
 781     Try
 782     {
 783         const MSG_SORT_RULE_S sort_rules = { MSG_SORT_BY_DISPLAY_TIME, true };
 784         msg_error_t res = MSG_ERR_UNKNOWN;
 785         const msg_folder_id_t platformFolder = convertFolderToPlatform(folder);
 786         res = msg_get_folder_view_list(
 787                 MsgGetCommonHandle(), platformFolder, &sort_rules,
 788                 &folder_list_view);
 789
 790         if (MSG_SUCCESS != res) {
 791             LoggerE("msg_Get_folder_view_list failed" << res);
 792             Throw(WrtDeviceApis::Commons::PlatformException);
 793         }
 794
 795         for (int i = 0; i < folder_list_view.nCount; i++) {
 796             if (MSG_TYPE_MMS ==
 797                                 msg_get_message_type(folder_list_view.
 798                                                      msgInfo[i])) {
 799                                 int l_msgId = msg_get_message_id(
 800                         folder_list_view.msgInfo[i]);
 801                 ostringstream stream;
 802                 stream << l_msgId;
 803                 retVal.push_back(stream.str());
 804             }
 805         }
 806
 807                 msg_release_list_struct(&folder_list_view);
 808     }
 809
 810     Catch(WrtDeviceApis::Commons::PlatformException) {
 811         LoggerE("Problem with message creation, cleaning");
 812         if (folder_list_view.nCount) {
 813                         msg_release_list_struct(&folder_list_view);
 814         }
 815         if (msg) {
 816             msg_release_message(&msg);
 817         }
 818         throw;
 819     }
 820
 821     return retVal;
 822 }
 823
 824 vector<string> Messaging::getEmailIds(FolderType folder)
 825 {
 826     vector<string> retVal;
 827
 828     //TODO
 829     LoggerE("TODO");
 830     Throw(WrtDeviceApis::Commons::UnknownException);
 831
 832     return retVal;
 833 }
 834 */
 835 vector<EmailAccountInfo> Messaging::getEmailAccounts() const
 836 {
 837         LoggerE("enter");
 838         email_account_t* accounts = NULL;
 839         int count = 0;
 840         Try {
 841                 if (!email_get_account_list(&accounts, &count)) {
 842                         ThrowMsg(WrtDeviceApis::Commons::PlatformException, "Couldn't get e-mail accounts.");
 843                 }
 844
 845                 LoggerE(        "count : " << count);
 846
 847                 if (0 == count) {
 848                         ThrowMsg(WrtDeviceApis::Commons::PlatformException, "No e-mail account found.");
 849                 }
 850
 851                 vector<EmailAccountInfo> result;
 852                 for (int i = 0; i < count; ++i)
 853                 {
 854                         if(accounts[i].incoming_server_user_name  !=  NULL)
 855                         {
 856                                 LoggerE("server user name is NULL");
 857                                 EmailAccountInfo account(accounts[i].account_id,
 858                                                                                         accounts[i].incoming_server_user_name,
 859                                                                                         accounts[i].user_email_address);
 860                                 result.push_back(account);
 861                         }
 862                         else
 863                         {
 864                                 LoggerE("normal case");
 865                                 std::string Unknown = "UNKNOWN";
 866                                 EmailAccountInfo account(accounts[i].account_id,
 867                                                                                         Unknown,
 868                                                                                         accounts[i].user_email_address);
 869                                 result.push_back(account);
 870                         }
 871                 }
 872
 873                 if (accounts != NULL) {
 874                         email_free_account(&accounts, count);
 875                 }
 876                 LoggerE("end");
 877                 return result;
 878         }
 879         Catch(WrtDeviceApis::Commons::PlatformException) {
 880                 if (accounts != NULL) {
 881                         email_free_account(&accounts, count);
 882                 }
 883                 LoggerE("PlatformException");
 884                 ThrowMsg(WrtDeviceApis::Commons::PlatformException, "No e-mail account found.");
 885         }
 886         Catch(WrtDeviceApis::Commons::UnknownException) {
 887                 if (accounts != NULL) {
 888                         email_free_account(&accounts, count);
 889                 }
 890                 LoggerE("UnknownException");
 891                 ThrowMsg(WrtDeviceApis::Commons::PlatformException, "Couldn't convert e-mail account id");
 892         }
 893 }
 894
 895 int Messaging::getEmailAccountId(const std::string& account)
 896 {
 897     int retVal = 0;
 898     string tmpAccount = account;
 899     email_account_t *pAccountArray = NULL;
 900     int iCount = 0;
 901
 902     Try
 903     {
 904         if (account.empty()) {
 905             tmpAccount = getCurrentEmailAccount().getAddress();
 906             if (tmpAccount.empty()) {
 907                 LoggerE(
 908                     "current email account is not set, possible that no account created");
 909                 Throw(WrtDeviceApis::Commons::PlatformException);
 910             }
 911         }
 912
 913         if (!email_get_account_list(&pAccountArray, &iCount)) {
 914             LoggerE("email_get_account_list error");
 915             Throw(WrtDeviceApis::Commons::PlatformException);
 916         }
 917
 918         if (0 == iCount) {
 919             LoggerE("no email account exist");
 920             Throw(WrtDeviceApis::Commons::PlatformException);
 921         }
 922
 923         for (int i = 0; i < iCount; i++) {
 924             string tmp = pAccountArray[i].user_email_address;
 925             if (tmp == tmpAccount) {
 926                 m_currentEmailAccountId = pAccountArray[i].account_id;
 927                 retVal = m_currentEmailAccountId;
 928                 break;
 929             }
 930         }
 931
 932         if (0 == m_currentEmailAccountId) {
 933             LoggerE("wrong email account ID");
 934             Throw(WrtDeviceApis::Commons::PlatformException);
 935         }
 936
 937         if (pAccountArray != NULL) {
 938             LoggerD("free account, ptr=" << pAccountArray);
 939             email_free_account(&pAccountArray, iCount);
 940         }
 941
 942         if (0 == retVal) {
 943             LoggerE("no email account created");
 944             Throw(WrtDeviceApis::Commons::PlatformException);
 945         }
 946     }
 947
 948     Catch(WrtDeviceApis::Commons::PlatformException) {
 949         LoggerE("exception catch, platform exception");
 950         if (pAccountArray != NULL) {
 951             email_free_account(&pAccountArray, iCount);
 952         }
 953         throw;
 954     }
 955
 956     return retVal;
 957 }
 958
 959 void Messaging::fetchEmailHeaders()
 960 {
 961 /*
 962         email_mailbox_t *mailbox = NULL;
 963         int handle = 0;
 964         int error = 0;
 965         mailbox = static_cast<email_mailbox_t*>(calloc(sizeof (email_mailbox_t), 1));
 966         if (!mailbox) {
 967                 LoggerE("calloc failed");
 968                 return;
 969         }
 970         mailbox->account_id = m_currentEmailAccountId;
 971         mailbox->mailbox_name = strdup(EMAIL_INBOX_NAME);
 972         //    if (EMAIL_ERROR_NONE != email_sync_header(mailbox, &handle)) {
 973         if (EMAIL_ERROR_NONE != email_sync_header(mailbox->account_id, 0, &handle)) {
 974                 LoggerE("email_sync_header failed");
 975         }
 976         error = email_free_mailbox(&mailbox, 1);
 977         LoggerE("email_free_mailbox : " << error);
 978 */
 979 }
 980
 981 int Messaging::convertFolderToPlatform(const FolderType folder)
 982 {
 983     msg_folder_id_t platfromFolderId;
 984     switch (folder) {
 985     case INBOX:
 986         platfromFolderId = MSG_INBOX_ID;
 987         break;
 988     case DRAFTBOX:
 989         platfromFolderId = MSG_DRAFT_ID;
 990         break;
 991     case OUTBOX:
 992         platfromFolderId = MSG_OUTBOX_ID;
 993         break;
 994     case SENTBOX:
 995         platfromFolderId = MSG_SENTBOX_ID;
 996         break;
 997     case SPAMBOX:
 998     // intentionally not break in platform is no spambox
 999     default:
1000         LoggerE("Invalid folder: " << folder);
1001         Throw(WrtDeviceApis::Commons::PlatformException);
1002     }
1003
1004     return platfromFolderId;
1005 }
1006
1007 int Messaging::convertFolderToPlatform(const std::string &folder)
1008 {
1009 //    MSG_FOLDER_LIST_S folderList = { 0, NULL };
1010
1011     int result = 0;
1012 /*
1013     Try
1014     {
1015         if (MSG_SUCCESS !=
1016             msg_get_folder_list(MsgGetCommonHandle(), &folderList)) {
1017             LoggerE("msg_get_folder_list error");
1018             Throw(WrtDeviceApis::Commons::PlatformException);
1019         }
1020         for (int i = 0; i < folderList.nCount; ++i) {
1021             if (MSG_FOLDER_TYPE_USER_DEF ==
1022                 folderList.folderInfo[i].folderType &&
1023                 NULL != folderList.folderInfo[i].folderName &&
1024                 folder == folderList.folderInfo[i].folderName) {
1025                 result = folderList.folderInfo[i].folderId;
1026                 break;
1027             }
1028         }
1029     }
1030     Catch(WrtDeviceApis::Commons::PlatformException) {
1031         if (folderList.nCount) {
1032             msg_release_folder_list(&folderList);
1033         }
1034         throw;
1035     }
1036     if (folderList.nCount) {
1037         msg_release_folder_list(&folderList);
1038     }
1039 */
1040     return result;
1041 }
1042
1043 void Messaging::addOnMessageReceived(
1044         const EmitterMessageReceivedPtr& emitter, const DeviceAPI::Tizen::FilterPtr& filter, int funtionIndex)
1045 {
1046     LoggerD("ENTER");
1047
1048     if(filter != NULL)
1049     {
1050         Try
1051         {
1052             LoggerD("funtionIndex = " << funtionIndex);
1053             bool isValidFilter = validateFilter(filter, funtionIndex);
1054             if(isValidFilter == false){
1055                 LoggerE("[ERROR]this filter is invalid");
1056                 Throw(WrtDeviceApis::Commons::InvalidArgumentException);
1057             }
1058         }
1059         Catch(WrtDeviceApis::Commons::PlatformException) {
1060             throw;
1061         }
1062     }else
1063     {
1064         LoggerD("filter is NULL");
1065     }
1066
1067
1068     m_onMessageReceived.attach(emitter);
1069     EmittersMessageReceived::LockType lock = m_onMessageReceived.getLock();
1070     if ((m_onMessageReceived.size() == 1)&&((m_onConversationReceived.size() + m_onFolderReceived.size()) == 0)) {
1071         m_onMessageReceivedHandleMgr = MsgServiceHandleMgrPtr(
1072                 new MsgServiceHandleMgr());
1073         int err;
1074         Try{
1075             err = msg_reg_storage_change_callback(
1076             m_onMessageReceivedHandleMgr->getHandle(),
1077             onMessageStorageChanged,
1078             this);
1079         }
1080         Catch(WrtDeviceApis::Commons::PlatformException){
1081             LoggerD("addOnMessageReceived failed");
1082             Throw(WrtDeviceApis::Commons::PlatformException);
1083         }
1084
1085         if (err != MSG_SUCCESS) {
1086             LoggerE("Couldn't register on MMS received callback, err=" << err);
1087         }
1088
1089         m_dbusConnection->open(DBUS_BUS_SYSTEM);
1090     }
1091 }
1092
1093 void Messaging::addOnMessageReceived(
1094         const EmitterConversationReceivedPtr& emitter, const DeviceAPI::Tizen::FilterPtr& filter, int funtionIndex)
1095 {
1096     LoggerD("ENTER");
1097
1098     if(filter != NULL)
1099     {
1100         Try
1101         {
1102             LoggerD("funtionIndex = " << funtionIndex);
1103             bool isValidFilter = validateFilter(filter, funtionIndex);
1104             if(isValidFilter == false){
1105                 LoggerE("[ERROR]this filter is invalid");
1106                 Throw(WrtDeviceApis::Commons::InvalidArgumentException);
1107             }
1108         }
1109         Catch(WrtDeviceApis::Commons::PlatformException) {
1110             throw;
1111         }
1112     }else
1113     {
1114         LoggerD("filter is NULL");
1115     }
1116
1117
1118     m_onConversationReceived.attach(emitter);
1119     EmittersConversationReceived::LockType lock = m_onConversationReceived.getLock();
1120     if ((m_onConversationReceived.size() == 1)&&((m_onMessageReceived.size() + m_onFolderReceived.size()) == 0)) {
1121         m_onMessageReceivedHandleMgr = MsgServiceHandleMgrPtr(
1122                 new MsgServiceHandleMgr());
1123         int err;
1124         Try{
1125             err = msg_reg_storage_change_callback(
1126             m_onMessageReceivedHandleMgr->getHandle(),
1127             onMessageStorageChanged,
1128             this);
1129         }
1130         Catch(WrtDeviceApis::Commons::PlatformException){
1131             LoggerD("addOnMessageReceived failed");
1132             Throw(WrtDeviceApis::Commons::PlatformException);
1133         }
1134
1135         if (err != MSG_SUCCESS) {
1136             LoggerE("Couldn't register on MMS received callback, err=" << err);
1137         }
1138
1139         m_dbusConnection->open(DBUS_BUS_SYSTEM);
1140     }
1141 }
1142
1143 void Messaging::addOnMessageReceived(
1144         const EmitterFolderReceivedPtr& emitter, const DeviceAPI::Tizen::FilterPtr& filter, int funtionIndex)
1145 {
1146     LoggerD("ENTER");
1147
1148     if(filter != NULL)
1149     {
1150         Try
1151         {
1152             LoggerD("funtionIndex = " << funtionIndex);
1153             bool isValidFilter = validateFilter(filter, funtionIndex);
1154             if(isValidFilter == false){
1155                 LoggerE("[ERROR]this filter is invalid");
1156                 Throw(WrtDeviceApis::Commons::InvalidArgumentException);
1157             }
1158         }
1159         Catch(WrtDeviceApis::Commons::PlatformException) {
1160             throw;
1161         }
1162     }else
1163     {
1164         LoggerD("filter is NULL");
1165     }
1166
1167
1168     m_onFolderReceived.attach(emitter);
1169     EmittersFolderReceived::LockType lock = m_onFolderReceived.getLock();
1170     if ((m_onFolderReceived.size() == 1)&&((m_onMessageReceived.size() + m_onConversationReceived.size()) == 0)) {
1171         m_onMessageReceivedHandleMgr = MsgServiceHandleMgrPtr(
1172                 new MsgServiceHandleMgr());
1173         int err;
1174
1175         Try
1176         {
1177             err = msg_reg_storage_change_callback(
1178             m_onMessageReceivedHandleMgr->getHandle(),
1179             onMessageStorageChanged,
1180             this);
1181         }
1182         Catch(WrtDeviceApis::Commons::PlatformException){
1183             LoggerD("addOnMessageReceived failed");
1184             Throw(WrtDeviceApis::Commons::PlatformException);
1185         }
1186
1187         if (err != MSG_SUCCESS) {
1188             LoggerE("Couldn't register on MMS received callback, err=" << err);
1189 //              Throw(WrtDeviceApis::Commons::UnknownException);
1190         }
1191
1192         m_dbusConnection->open(DBUS_BUS_SYSTEM);
1193     }
1194 }
1195
1196 bool Messaging::validateFilter(const DeviceAPI::Tizen::FilterPtr& filter, const int funtionIndex){
1197         LoggerD("<<<");
1198
1199         bool retBool = false;
1200         LoggerD("funtionIndex = " << funtionIndex);
1201
1202         if(filter != NULL){
1203                 if(funtionIndex == 0)
1204                 {
1205                         StorageChangesMessageFilterValidatorPtr validatorMsg =
1206                                         StorageChangesMessageFilterValidatorFactory::getStorageChangesMessageFilterValidator();
1207
1208                         FilterValidatorPtr filterValidatorMsg = DPL::StaticPointerCast<FilterValidator>(validatorMsg);
1209                         retBool = filter->validate(filterValidatorMsg);
1210                 }else if(funtionIndex == 1)
1211                 {
1212                         StorageChangesConversationFilterValidatorPtr validatorConv =
1213                                         StorageChangesConversationFilterValidatorFactory::getStorageChangesConversationFilterValidator();
1214
1215                         FilterValidatorPtr filterValidatorConv = DPL::StaticPointerCast<FilterValidator>(validatorConv);
1216                         retBool = filter->validate(filterValidatorConv);
1217                 }else if(funtionIndex == 2)
1218                 {
1219                         StorageChangesFolderFilterValidatorPtr validatorFolder =
1220                                         StorageChangesFolderFilterValidatorFactory::getStorageChangesFolderFilterValidator();
1221
1222                         FilterValidatorPtr filterValidatorFolder = DPL::StaticPointerCast<FilterValidator>(validatorFolder);
1223                         retBool = filter->validate(filterValidatorFolder);
1224                 }
1225
1226                 if(retBool == false){
1227                         Throw(WrtDeviceApis::Commons::InvalidArgumentException);
1228                 }
1229         }else{
1230                 LoggerD("filter is NULL");
1231                 retBool = false;
1232         }
1233
1234         LoggerD(">>> retBool:" << retBool);
1235         return retBool;
1236
1237 }
1238
1239
1240 void Messaging::removeOnMessageMsgReceived(EmitterMessageReceived::IdType id)
1241 {
1242     LoggerD("ENTER");
1243     m_onMessageReceived.detach(id);
1244     EmittersMessageReceived::LockType lock = m_onMessageReceived.getLock();
1245     if ((m_onMessageReceived.size()+m_onConversationReceived.size()+m_onFolderReceived.size()) == 0) {
1246         m_onMessageReceivedHandleMgr = MsgServiceHandleMgrPtr(NULL);
1247         m_dbusConnection->close();
1248     }
1249 }
1250
1251 void Messaging::removeOnMessageConvReceived(EmitterConversationReceived::IdType id)
1252 {
1253     LoggerD("ENTER");
1254     m_onConversationReceived.detach(id);
1255     EmittersConversationReceived::LockType lock = m_onConversationReceived.getLock();
1256     if ((m_onMessageReceived.size()+m_onConversationReceived.size()+m_onFolderReceived.size()) == 0) {
1257         m_onMessageReceivedHandleMgr = MsgServiceHandleMgrPtr(NULL);
1258         m_dbusConnection->close();
1259     }
1260 }
1261
1262 void Messaging::removeOnMessageFolderReceived(EmitterFolderReceived::IdType id)
1263 {
1264     LoggerD("ENTER");
1265     m_onFolderReceived.detach(id);
1266     EmittersFolderReceived::LockType lock = m_onFolderReceived.getLock();
1267     if ((m_onMessageReceived.size()+m_onConversationReceived.size()+m_onFolderReceived.size()) == 0) {
1268         m_onMessageReceivedHandleMgr = MsgServiceHandleMgrPtr(NULL);
1269         m_dbusConnection->close();
1270     }
1271 }
1272
1273 void Messaging::OnEventReceived(const DBus::MessageEvent& event)
1274 {
1275         LoggerD("ENTER");
1276         EventMessageReceivedPtr jsEvent(new EventMessageReceived());
1277         DBus::MessagePtr message = event.GetArg0();
1278
1279         if (!message)
1280         {
1281                 jsEvent->setExceptionCode(WrtDeviceApis::Commons::ExceptionCodes::PlatformException);
1282                 m_onMessageReceived.emit(jsEvent);
1283         }
1284         else
1285         {
1286                 if (message->getInterface() == DBUS_INTERFACE_EMAIL_RECEIVED)
1287                 {
1288                         int account_id = 0, mail_id = 0, thread_id = 0, status = 0;
1289                         std::string name;
1290                         email_mailbox_t m_mailboxes;
1291
1292                         DBus::Message::ReadIterator it = message->getReadIterator();
1293                         for (int i = 0; it->isValid(); it->next(), ++i)
1294                         {
1295                                 if ((i == 0) && (it->getArgType() == DBUS_TYPE_INT32))
1296                                 {
1297                                         status = it->getInt();
1298                                         LoggerI("status: " << status);
1299                                 }
1300                                 else if ((i == 1) && (it->getArgType() == DBUS_TYPE_INT32))
1301                                 {
1302                                         account_id = it->getInt();
1303                                         LoggerI("account_id: " << account_id);
1304                                 }
1305                                 else if ((i == 2) && (it->getArgType() == DBUS_TYPE_INT32))
1306                                 {
1307                                         mail_id = it->getInt();
1308                                         LoggerI("mail_id: " << mail_id);
1309                                 }
1310                                 else if ((i == 3) && (it->getArgType() == DBUS_TYPE_STRING))
1311                                 {
1312                                         name = it->getString();
1313                                         LoggerI("name: " << name);
1314                                 }
1315                                 else if ((i == 4) && (it->getArgType() == DBUS_TYPE_INT32))
1316                                 {
1317                                         thread_id = it->getInt();
1318                                         LoggerI("thread_id: " << thread_id);
1319                                 }
1320                         }
1321
1322                         if ((mail_id > 0) && (NOTI_MAIL_ADD == status))
1323                         { // TODO also RECEIVE_THREAD_ITEM?
1324                                 LoggerI("Email received. mail_id: " << mail_id);
1325
1326                                 IMessagePtr msg = MessageFactory::createMessage(EMAIL, mail_id);
1327                                 IConversationPtr conversation(new Conversation(thread_id, EMAIL));
1328
1329                                 // TODO Temporary fix: ignore messages from OUTBOX, SENTBOX & DRAFTBOX -> most probably we added them
1330                                 FolderType folder = msg->getCurrentFolder();
1331                                 jsEvent->setMsg_Event_Type(EventMessageReceived::MSG_ADDED);
1332
1333                                 LoggerI("Added message is in folder: " << folder);
1334
1335                                 jsEvent->setMessage(msg);
1336                                 jsEvent->setConversation(conversation);
1337
1338                                 if(m_onMessageReceived.size() > 0){
1339                                         m_onMessageReceived.emit(jsEvent);
1340                                 }
1341
1342                                 if(m_onConversationReceived.size() > 0){
1343                                 m_onConversationReceived.emit(jsEvent);
1344                                 }
1345 /*
1346                                 if (OUTBOX != folder && SENTBOX != folder && DRAFTBOX != folder)
1347                                 {
1348                                         jsEvent->setMessage(msg);
1349                                         jsEvent->setConversation(conversation);
1350
1351                                         if(m_onMessageReceived.size() > 0){
1352                                                 m_onMessageReceived.emit(jsEvent);
1353                                         }
1354
1355                                         if(m_onConversationReceived.size() > 0){
1356                                         m_onConversationReceived.emit(jsEvent);
1357                                         }
1358
1359                                 } else {
1360                                         LoggerW("New email message in ignored folder: " << folder);
1361                                 }
1362 */
1363                         }
1364                         else if ((mail_id > 0) && (NOTI_MAIL_DELETE == status))
1365                         { // TODO also RECEIVE_THREAD_ITEM?
1366                                 LoggerI("Email received. delete type: " << mail_id);
1367
1368                                 std::vector<std::string> strIds = String::split(name, ',');
1369
1370                                 std::stringstream stream;
1371                                 for (std::vector<std::string>::iterator it = strIds.begin(); it != strIds.end(); ++it)
1372                                 {
1373                                         LoggerD("ID is :" << *it);
1374
1375                                         if ( (*it).length() > 0 ) //vaild id
1376                                         {
1377                                                 stream<< *it;
1378                                                 int id;
1379                                                 stream >> id;
1380
1381                                                 IMessagePtr msg = MessageFactory::createMessage(EMPTY_MESSAGE, id);
1382                                                 IConversationPtr conversation(new Conversation());
1383
1384                                                 FolderType folder = msg->getCurrentFolder();
1385                                                 jsEvent->setMsg_Event_Type(EventMessageReceived::MSG_DELETED);
1386
1387                                                 if (true) { // if (OUTBOX != folder && SENTBOX != folder && DRAFTBOX != folder)
1388                                                         jsEvent->setMessage(msg);
1389                                                         jsEvent->setConversation(conversation);
1390                                                         if(m_onMessageReceived.size() > 0){
1391                                                                 m_onMessageReceived.emit(jsEvent);
1392                                                         }
1393                                                 }
1394                                                 else {
1395                                                         LoggerW("New email message in ignored folder: " << folder);
1396                                                 }
1397                                         }
1398
1399                                         stream.clear();
1400                                 } //for
1401
1402                         }
1403                         else if ((mail_id > 0) && (NOTI_MAIL_UPDATE == status))
1404                         { // TODO also RECEIVE_THREAD_ITEM?
1405                                 LoggerI("Email received. mail_id: " << mail_id);
1406
1407                                 IMessagePtr msg = MessageFactory::createMessage(EMAIL, mail_id);
1408                                 IConversationPtr conversation(new Conversation(thread_id, EMAIL));
1409
1410                                 FolderType folder = msg->getCurrentFolder();
1411                                 jsEvent->setMsg_Event_Type(EventMessageReceived::MSG_UPDATED);
1412
1413                                 if (true) { // if (OUTBOX != folder && SENTBOX != folder && DRAFTBOX != folder)
1414                                         jsEvent->setMessage(msg);
1415                                         jsEvent->setConversation(conversation);
1416                                         if(m_onMessageReceived.size() > 0)
1417                                                 m_onMessageReceived.emit(jsEvent);
1418                                         if(m_onConversationReceived.size() > 0)
1419                                                 m_onConversationReceived.emit(jsEvent);
1420                                 } else {
1421                                         LoggerW("New email message in ignored folder: " << folder);
1422                                 }
1423                         }
1424                         else if ((mail_id > 0) && (NOTI_THREAD_DELETE == status))
1425                         { // TODO also RECEIVE_THREAD_ITEM?
1426                                 LoggerI("Email received. delete thread Id : " << mail_id);
1427
1428                                 IConversationPtr conversation(new Conversation());
1429                                 conversation->setConvId(mail_id);
1430                                 jsEvent->setMsg_Event_Type(EventMessageReceived::MSG_DELETED);
1431                                 jsEvent->setConversation(conversation);
1432
1433                                 if(m_onConversationReceived.size() > 0){
1434                                         m_onConversationReceived.emit(jsEvent);
1435                                 }
1436                         }
1437                         else if (NOTI_MAILBOX_ADD == status)
1438                         {
1439                                 LoggerI("Emailbox received. account Id: " << account_id);
1440                                 LoggerI("name Id: " << name);
1441                                 LoggerI("mailBox Id: " << mail_id);
1442
1443                                 email_mailbox_t* mail_box = NULL;
1444
1445                                 if (EMAIL_ERROR_NONE != email_get_mailbox_by_mailbox_id(mail_id, &mail_box)) {
1446                                         LoggerE("Couldn't retrieve message or it has been malformed.");
1447                                 }
1448
1449                                 if(mail_box != NULL)
1450                                 {
1451                                         m_mailboxes = *mail_box;
1452                                         IMessageFolderPtr folderPtr(new MessageFolder(m_mailboxes));
1453                                         jsEvent->setMessageFolder(folderPtr);
1454                                         jsEvent->setMsg_Event_Type(EventMessageReceived::MSG_ADDED);
1455                                         if(m_onFolderReceived.size() > 0)
1456                                         {
1457                                                 m_onFolderReceived.emit(jsEvent);
1458                                         }
1459
1460                                 }
1461
1462                                 if ( mail_box )
1463                                 {
1464                                         if(  EMAIL_ERROR_NONE != email_free_mailbox( &mail_box , 1) )
1465                                                 LoggerD("fail to email_free_mailbox - err ");
1466                                 }
1467
1468                         }
1469                         else if (NOTI_MAILBOX_UPDATE == status)
1470                         {
1471                                 LoggerI("Emailbox received. account Id: " << account_id);
1472                                 LoggerI("name Id: " << name);
1473                                 LoggerI("mailBox Id: " << mail_id);
1474
1475                                 email_mailbox_t* mail_box = NULL;
1476
1477                                 if (EMAIL_ERROR_NONE != email_get_mailbox_by_mailbox_id(mail_id, &mail_box)) {
1478                                         LoggerE("Couldn't retrieve message or it has been malformed.");
1479                                 }
1480
1481                                 if(mail_box != NULL)
1482                                 {
1483                                         m_mailboxes = *mail_box;
1484
1485                                         IMessageFolderPtr folderPtr(new MessageFolder(m_mailboxes));
1486                                         jsEvent->setMessageFolder(folderPtr);
1487                                         jsEvent->setMsg_Event_Type(EventMessageReceived::MSG_UPDATED);
1488
1489                                         if(m_onFolderReceived.size() > 0)
1490                                         {
1491                                                 m_onFolderReceived.emit(jsEvent);
1492                                         }
1493                                 }
1494
1495                                 if ( mail_box )
1496                                 {
1497                                         if(  EMAIL_ERROR_NONE != email_free_mailbox( &mail_box , 1) )
1498                                                 LoggerD("fail to email_free_mailbox - err ");
1499                                 }
1500                         }
1501                         else if (NOTI_MAILBOX_DELETE == status)
1502                         {
1503                                 LoggerI("Emailbox received. account Id: " << account_id);
1504                                 LoggerI("name Id: " << name);
1505                                 LoggerI("mailBox Id: " << mail_id);
1506
1507                                 // make empty mailbox
1508                                 m_mailboxes.mailbox_id = mail_id;
1509                                 m_mailboxes.account_id = account_id;
1510                                 m_mailboxes.alias = (char *)"";
1511                                 m_mailboxes.mailbox_name = (char *)"";
1512
1513                                 IMessageFolderPtr folderPtr(new MessageFolder(m_mailboxes));
1514                                 jsEvent->setMessageFolder(folderPtr);
1515                                 jsEvent->setMsg_Event_Type(EventMessageReceived::MSG_DELETED);
1516
1517                                 if(m_onFolderReceived.size() > 0)
1518                                 {
1519                                         m_onFolderReceived.emit(jsEvent);
1520                                 }
1521                         }
1522                         else
1523                         {
1524                                 LoggerE("Couldn't retrieve message or it has been malformed.");
1525                         }
1526                 }
1527                 else // DBUS_INTERFACE_EMAIL_RECEIVED
1528                 {
1529                         LoggerD("Wrong DBus interface, skipping it.");
1530                 }
1531         }
1532 }
1533
1534 void Messaging::onMessageStorageChanged(msg_handle_t handle,
1535         msg_storage_change_type_t storageChangeType,
1536         msg_id_list_s *pMsgIdList,
1537         void* data)
1538 {
1539
1540     LoggerD("ENTER");
1541
1542     msg_error_t err = MSG_SUCCESS;
1543
1544     if(storageChangeType == MSG_STORAGE_CHANGE_CONTACT)
1545     {
1546         LoggerD("storageChangeType is MSG_STORAGE_CHANGE_CONTACT");
1547         return;
1548     }
1549
1550     Messaging* this_ = static_cast<Messaging*>(data);
1551     if (this_)
1552     {
1553         Try {
1554             int msgCount = pMsgIdList->nCount;
1555             LoggerD("msgCount = "<< msgCount);
1556
1557             for(int index = 0; index < msgCount; index++)
1558             {
1559
1560             LoggerD("storageChangeType = "<< storageChangeType);
1561
1562                 if(storageChangeType == MSG_STORAGE_CHANGE_DELETE)
1563                 {
1564                     IMessagePtr message = MessageFactory::createMessage(EMPTY_MESSAGE, pMsgIdList->msgIdList[index]);
1565                     IConversationPtr conversation(new Conversation());
1566                     EventMessageReceivedPtr event(new EventMessageReceived());
1567                     event->setMessage(message);
1568                     event->setConversation(conversation);
1569                     event->setMsg_Event_Type(EventMessageReceived::MSG_DELETED);
1570
1571                     if(this_->m_onMessageReceived.size() > 0){
1572                         this_->m_onMessageReceived.emit(event);
1573                     }
1574                     if(this_->m_onConversationReceived.size() > 0){
1575                         this_->m_onConversationReceived.emit(event);
1576                     }
1577                 }
1578                 else
1579                 {
1580                     msg_struct_t msg = NULL;
1581                     msg_struct_t sendOpt = NULL;
1582                     msg = msg_create_struct(MSG_STRUCT_MESSAGE_INFO);
1583                     sendOpt = msg_create_struct(MSG_STRUCT_SENDOPT);
1584
1585                     err = msg_get_message(handle, pMsgIdList->msgIdList[index], msg, sendOpt);
1586
1587                     if (err != MSG_SUCCESS)
1588                     {
1589                         LoggerD("Get Message Failed!");
1590                         LoggerD("err" << err);
1591                         msg_release_struct(&msg);
1592                         msg_release_struct(&sendOpt);
1593                         msg = NULL;
1594                         sendOpt = NULL;
1595                         return;
1596                     }
1597                     int msgType = 0;
1598                     msg_get_int_value(msg, MSG_MESSAGE_TYPE_INT, &msgType);
1599                    LoggerD("msgType : " << msgType);
1600                     if((msgType > MSG_TYPE_INVALID) && ( msgType <= MSG_TYPE_SMS_REJECT))
1601                     {
1602                         if(msgType  != MSG_TYPE_MMS_NOTI)
1603                         {
1604                             int msgId = 0;
1605                             msg_get_int_value(msg, MSG_MESSAGE_ID_INT, &msgId);
1606                             IMessagePtr message = MessageFactory::createMessage(
1607                                                                                 SMS,
1608                                                                                 msgId,
1609                                                                                 msg
1610                                                                                 );
1611                             ISmsPtr sms = MessageFactory::convertToSms(message);
1612                             IConversationPtr conversation(new Conversation(message->getId(), SMS));
1613                             EventMessageReceivedPtr event(new EventMessageReceived());
1614                             event->setMessage(message);
1615                             event->setConversation(conversation);
1616
1617                             if(storageChangeType == MSG_STORAGE_CHANGE_INSERT)
1618                             {
1619                                 LoggerD("MSG_STORAGE_CHANGE_INSERT");
1620                                 event->setMsg_Event_Type(EventMessageReceived::MSG_ADDED);
1621                             }
1622                             else if(storageChangeType == MSG_STORAGE_CHANGE_UPDATE)
1623                             {
1624                                 LoggerD("MSG_STORAGE_CHANGE_UPDATE");
1625                                 event->setMsg_Event_Type(EventMessageReceived::MSG_UPDATED);
1626                             }
1627
1628                             if(this_->m_onMessageReceived.size() > 0){
1629                                 this_->m_onMessageReceived.emit(event);
1630                             }
1631                             if(this_->m_onConversationReceived.size() > 0){
1632                                 this_->m_onConversationReceived.emit(event);
1633                             }
1634                         }
1635                         else
1636                         {
1637                             LoggerE("Ignore this sms, this is mms noti.");
1638                         }
1639                     }
1640                     else if((msgType >= MSG_TYPE_MMS) && (msgType <= MSG_TYPE_MMS_NOTI))
1641                     {
1642                         if(msgType  != MSG_TYPE_MMS_NOTI)
1643                         {
1644                             int msgId = 0;
1645                             msg_get_int_value(msg, MSG_MESSAGE_ID_INT, &msgId);
1646                             IMessagePtr message = MessageFactory::createMessage(
1647                                                                                 MMS,
1648 //                                                                                msg_get_message_id(
1649                                                                                 msgId,
1650                                                                                 msg
1651                                                                                 );
1652                             IMmsPtr mms = MessageFactory::convertToMms(message);
1653                             IConversationPtr conversation(new Conversation(message->getId(), MMS));
1654                             EventMessageReceivedPtr event(new EventMessageReceived());
1655                             event->setMessage(message);
1656                             event->setConversation(conversation);
1657
1658                             if(storageChangeType == MSG_STORAGE_CHANGE_INSERT)
1659                             {
1660                                 event->setMsg_Event_Type(EventMessageReceived::MSG_ADDED);
1661                             }
1662                             else if(storageChangeType == MSG_STORAGE_CHANGE_UPDATE)
1663                             {
1664                                 event->setMsg_Event_Type(EventMessageReceived::MSG_UPDATED);
1665                             }
1666 //                              else if(storageChangeType == MSG_STORAGE_CHANGE_DELETE)
1667 //                              {
1668 //                                  event->setMsg_Event_Type(EventMessageReceived::MSG_DELETED);
1669 //                              }
1670
1671                             if(this_->m_onMessageReceived.size() > 0){
1672                                 this_->m_onMessageReceived.emit(event);
1673                             }
1674                             if(this_->m_onConversationReceived.size() > 0){
1675                                 this_->m_onConversationReceived.emit(event);
1676                             }
1677                         }
1678                         else
1679                         {
1680                             LoggerE("Ignore this mms, this is mms noti.");
1681                         }
1682                     }
1683
1684                     if(msg != NULL)
1685                     {
1686                           LoggerE("release msg : " << msg);
1687                     msg_release_struct(&msg);
1688                     }
1689                     msg_release_struct(&sendOpt);
1690                 }
1691             }
1692         }
1693         Catch(WrtDeviceApis::Commons::ConversionException) {
1694             LoggerE("Couldn't convert message to sms.");
1695         }
1696         Catch(WrtDeviceApis::Commons::PlatformException) {
1697             LoggerE("onMessageStorageChanged platform exception");
1698         }
1699     }
1700 }
1701
1702 /*
1703 void Messaging::onSmsReceived(MSG_HANDLE_T handle,
1704         msg_message_t msg,
1705         void* data)
1706 {
1707     LoggerD("ENTER");
1708     Messaging* this_ = static_cast<Messaging*>(data);
1709     if (this_) {
1710         Try {
1711                         if(msg_get_message_type(msg) != MSG_TYPE_MMS_NOTI)
1712                         {
1713             IMessagePtr message = MessageFactory::createMessage(
1714                     SMS,
1715                     msg_get_message_id(
1716                         msg));
1717             ISmsPtr sms = MessageFactory::convertToSms(message);
1718             IConversationPtr conversation(new Conversation(message->getId(), SMS));
1719
1720             EventMessageReceivedPtr event(new EventMessageReceived());
1721             event->setMessage(message);
1722             event->setConversation(conversation);
1723                         event->setMsg_Event_Type(EventMessageReceived::MSG_ADDED);
1724                         this_->m_onMessageReceived.emit(event);
1725         }
1726                         else
1727                         {
1728                                 LoggerE("Ignore this sms, this is mms noti.");
1729                         }
1730         }
1731         Catch(WrtDeviceApis::Commons::ConversionException) {
1732             LoggerE("Couldn't convert message to sms.");
1733         }
1734     }
1735 }
1736
1737 void Messaging::onMmsReceived(MSG_HANDLE_T handle,
1738         msg_message_t msg,
1739         void* data)
1740 {
1741     LoggerD("ENTER");
1742     Messaging* this_ = static_cast<Messaging*>(data);
1743     if (this_) {
1744         Try {
1745             IMessagePtr message = MessageFactory::createMessage(
1746                     MMS,
1747                     msg_get_message_id(
1748                         msg));
1749             IMmsPtr mms = MessageFactory::convertToMms(message);
1750             IConversationPtr conversation(new Conversation(message->getId(), MMS));
1751             EventMessageReceivedPtr event(new EventMessageReceived());
1752             event->setMessage(message);
1753             event->setConversation(conversation);
1754                         event->setMsg_Event_Type(EventMessageReceived::MSG_ADDED);
1755                         this_->m_onMessageReceived.emit(event);
1756         }
1757         Catch(WrtDeviceApis::Commons::ConversionException) {
1758             LoggerE("Couldn't convert message to mms.");
1759         }
1760     }
1761 }
1762
1763 void Messaging::getNumberOfEmails(FolderType folder,
1764         int* read,
1765         int* unread)
1766 {
1767     LOG_ENTER
1768
1769     email_mailbox_t mailbox = {};
1770     mailbox.account_id = 0; // means for all accounts
1771     mailbox.name = String::strdup(
1772             EmailConverter::toMailboxName(folder)
1773             );
1774
1775     int error = email_count_mail(&mailbox, read, unread);
1776     free(mailbox.name);
1777
1778     if (EMAIL_ERROR_NONE != error) {
1779         ThrowMsg(WrtDeviceApis::Commons::PlatformException,
1780                  "Couldn't get number of emails. [" << error << "]");
1781     }
1782
1783     LOG_EXIT
1784 }
1785
1786 void Messaging::getNumberOfSms(FolderType folder,
1787         int* read,
1788         int* unread)
1789 {
1790     getNumberOfSmsMms(folder, read, unread, SMS);
1791 }
1792
1793 void Messaging::getNumberOfMms(FolderType folder,
1794         int* read,
1795         int* unread)
1796 {
1797     getNumberOfSmsMms(folder, read, unread, MMS);
1798 }
1799
1800 void Messaging::getNumberOfSmsMms(FolderType folder,
1801         int* read,
1802         int* unread,
1803         MessageType msgType)
1804 {
1805     MSG_LIST_S folderListView = { 0, NULL };
1806
1807     *read = 0;
1808     *unread = 0;
1809
1810     Try
1811     {
1812         MSG_MESSAGE_TYPE_T msgTypePlatform;
1813         if (SMS == msgType) {
1814             msgTypePlatform = MSG_TYPE_SMS;
1815         } else if (MMS == msgType) {
1816             msgTypePlatform = MSG_TYPE_MMS;
1817         } else {
1818             LoggerE("no supported message type in this method");
1819             Throw(WrtDeviceApis::Commons::PlatformException);
1820         }
1821
1822         msg_folder_id_t msgFolderId;
1823         switch (folder) {
1824         case INBOX:
1825             msgFolderId = MSG_INBOX_ID;
1826             break;
1827         case OUTBOX:
1828             msgFolderId = MSG_OUTBOX_ID;
1829             break;
1830         case SENTBOX:
1831             msgFolderId = MSG_SENTBOX_ID;
1832             break;
1833         case DRAFTBOX:
1834             msgFolderId = MSG_DRAFT_ID;
1835             break;
1836         default:
1837             LoggerE("wrong folder type");
1838             Throw(WrtDeviceApis::Commons::PlatformException);
1839             break;
1840         }
1841
1842         const MSG_SORT_RULE_S sort_rules = { MSG_SORT_BY_DISPLAY_TIME, true };
1843         if (msg_get_folder_view_list(MsgGetCommonHandle(), msgFolderId,
1844                                      &sort_rules,
1845                                      &folderListView) != MSG_SUCCESS) {
1846             LoggerD(
1847                 "msg_get_folder_view_list empty or failed, msgFolderId=" <<
1848                 (int) msgFolderId);
1849             Throw(WrtDeviceApis::Commons::PlatformException);
1850         }
1851         // go thtough all message to check type of message
1852         LoggerD("msgCount=" << (int) folderListView.nCount);
1853         for (int msg_cnt = 0; msg_cnt < folderListView.nCount; msg_cnt++) {
1854             LoggerD("msgMainType=" <<
1855                                          (int) msg_get_message_type(folderListView.
1856                                                                         msgInfo[
1857                                                                 msg_cnt]) <<
1858                      ", searching for = " << (int) msgTypePlatform);
1859             if (msgTypePlatform ==
1860                                 msg_get_message_type(folderListView.msgInfo[
1861                                                      msg_cnt])) {
1862                 if (msg_is_read(folderListView.msgInfo[msg_cnt]))
1863                 {
1864                     (*read)++;
1865                 } else {
1866                     (*unread)++;
1867                 }
1868             }
1869         }
1870                 msg_release_list_struct(&folderListView);
1871
1872         LoggerD("readed=" << *read << ", unReaded=" << *unread);
1873     }
1874
1875     Catch(WrtDeviceApis::Commons::PlatformException) {
1876         if (folderListView.nCount) {
1877                         msg_release_list_struct(&folderListView);
1878         }
1879         throw;
1880     }
1881 }
1882
1883         vector<IMessagePtr> Messaging::findSms(FolderType folder, const DeviceAPI::Tizen::FilterPtr& filter)
1884         {
1885                 LoggerD("<<<");
1886
1887                 vector<IMessagePtr> retVal;
1888                 msg_message_t msg = msg_new_message();
1889                 MSG_LIST_S folder_list_view = {0, NULL};
1890
1891                 Try{
1892                         const MSG_SORT_RULE_S sort_rules = {MSG_SORT_BY_DISPLAY_TIME, true};
1893                         msg_error_t res = MSG_ERR_UNKNOWN;
1894                         const msg_folder_id_t platformFolder = convertFolderToPlatform(folder);
1895                         res = msg_get_folder_view_list(MsgGetCommonHandle(), platformFolder, &sort_rules, &folder_list_view);
1896
1897                         if (MSG_SUCCESS != res) {
1898                                 LoggerE("msg_get_folder_view_list failed " << res);
1899                                 Throw(WrtDeviceApis::Commons::PlatformException);
1900                         }
1901
1902                         for (int i = 0; i < folder_list_view.nCount; i++) {
1903                                 if (MSG_TYPE_SMS == msg_get_message_type(folder_list_view.msgInfo[i])) {
1904                                         int l_msgId = msg_get_message_id(folder_list_view.msgInfo[i]);
1905                                         IMessagePtr msg = MessageFactory::createMessage(SMS, l_msgId);
1906
1907                                         //                if (!filter || !filter->isValid() ||
1908                                         //                    filter->compare(MessageFactory::convertToSms(msg))) {
1909                                                             retVal.push_back(msg);
1910                                         //                }
1911                                 }
1912                         }
1913
1914                         msg_release_list_struct(&folder_list_view);
1915                 }Catch(WrtDeviceApis::Commons::PlatformException) {
1916                         LoggerE("Problem with message creation, cleaning");
1917                         if (folder_list_view.nCount) {
1918                                 msg_release_list_struct(&folder_list_view);
1919                         }
1920                         if (msg) {
1921                                 msg_release_message(&msg);
1922                         }
1923                         throw;
1924                 }
1925
1926                 LoggerD(">>>");
1927                 return retVal;
1928         }
1929
1930         vector<IMessagePtr> Messaging::findMms(FolderType folder,
1931                         const DeviceAPI::Tizen::FilterPtr& filter)
1932         {
1933                 vector<IMessagePtr> retVal;
1934                 msg_message_t msg = msg_new_message();
1935                 MSG_LIST_S folder_list_view = {0, NULL};
1936
1937                 Try
1938                 {
1939                         const MSG_SORT_RULE_S sort_rules = {MSG_SORT_BY_DISPLAY_TIME, true};
1940                         msg_error_t res = MSG_ERR_UNKNOWN;
1941                         const msg_folder_id_t platformFolder = convertFolderToPlatform(folder);
1942                         res = msg_get_folder_view_list(
1943                                         MsgGetCommonHandle(), platformFolder, &sort_rules,
1944                                         &folder_list_view);
1945
1946                         if (MSG_SUCCESS != res) {
1947                                 LoggerE("msg_Get_folder_view_list failed" << res);
1948                                 Throw(WrtDeviceApis::Commons::PlatformException);
1949                         }
1950
1951                         for (int i = 0; i < folder_list_view.nCount; i++) {
1952                                 if (MSG_TYPE_MMS ==
1953                                                 msg_get_message_type(folder_list_view.
1954                                                                 msgInfo[i])) {
1955                                         int l_msgId = msg_get_message_id(
1956                                                         folder_list_view.msgInfo[i]);
1957                                         IMessagePtr msg = MessageFactory::createMessage(MMS, l_msgId);
1958                                 }
1959                         }
1960
1961                         msg_release_list_struct(&folder_list_view);
1962                 }
1963
1964                 Catch(WrtDeviceApis::Commons::PlatformException) {
1965                         LoggerE("Problem with message creation, cleaning");
1966                         if (folder_list_view.nCount) {
1967                                 msg_release_list_struct(&folder_list_view);
1968                         }
1969                         if (msg) {
1970                                 msg_release_message(&msg);
1971                         }
1972                         throw;
1973                 }
1974
1975                 return retVal;
1976         }
1977 */
1978 void Messaging::createFolder(MessageType msgType,
1979         const string& userFolder)
1980 {
1981     switch (msgType) {
1982     case SMS:
1983     case MMS:
1984         createMsgServiceFolder(userFolder);
1985         break;
1986     case EMAIL:
1987         createEmailFolder(userFolder);
1988         break;
1989     default:
1990         LoggerE("msg not supported");
1991         Throw(WrtDeviceApis::Commons::UnknownException);
1992     }
1993 }
1994
1995 void Messaging::createMsgServiceFolder(const std::string& userFolder)
1996 {
1997 /*
1998     if (userFolder.length() > MAX_FOLDER_NAME_SIZE) {
1999         LoggerE("folder name to long");
2000         Throw(WrtDeviceApis::Commons::PlatformException);
2001     }
2002
2003     MSG_FOLDER_INFO_S folderInfo;
2004
2005     folderInfo.folderId = 0;
2006     strncpy(folderInfo.folderName, userFolder.c_str(), userFolder.length());
2007
2008     folderInfo.folderType = MSG_FOLDER_TYPE_USER_DEF;
2009
2010     if (msg_add_folder(MsgGetCommonHandle(), &folderInfo) != MSG_SUCCESS) {
2011         LoggerE("msg_add_folder failed");
2012         Throw(WrtDeviceApis::Commons::PlatformException);
2013     }
2014 */
2015 }
2016
2017 void Messaging::createEmailFolder(const std::string& userFolder)
2018 {
2019     //TODO
2020     LoggerE("TODO");
2021     Throw(WrtDeviceApis::Commons::UnknownException);
2022 }
2023
2024 void Messaging::deleteFolder(MessageType msgType,
2025         const string& userFolder)
2026 {
2027     switch (msgType) {
2028     case SMS:
2029     case MMS:
2030         deleteMsgServiceFolder(userFolder);
2031         break;
2032     case EMAIL:
2033         deleteEmailFolder(userFolder);
2034         break;
2035     default:
2036         LoggerE("msg not supported");
2037         Throw(WrtDeviceApis::Commons::UnknownException);
2038     }
2039 }
2040
2041 void Messaging::deleteMsgServiceFolder(const string& userFolder)
2042 {
2043 /*
2044     Try
2045     {
2046         int platformFolderId = convertFolderToPlatform(userFolder);
2047         if (MSG_SUCCESS !=
2048             msg_delete_folder(MsgGetCommonHandle(), platformFolderId)) {
2049             LoggerE("msg_get_folder_list failed");
2050             Throw(WrtDeviceApis::Commons::PlatformException);
2051         }
2052     }
2053     Catch(WrtDeviceApis::Commons::PlatformException) {
2054         throw;
2055     }
2056 */
2057 }
2058
2059 void Messaging::deleteEmailFolder(const string& userFolder)
2060 {
2061     //TODO
2062     LoggerE("TODO");
2063     Throw(WrtDeviceApis::Commons::UnknownException);
2064 }
2065
2066 vector<string> Messaging::getFolderNames(MessageType msgType)
2067 {
2068     switch (msgType) {
2069     case SMS:
2070     case MMS:
2071         return getFolderNamesMsgService();
2072     case EMAIL:
2073         return getFolderNamesEmail();
2074     default:
2075         LoggerE("msg not supported");
2076         Throw(WrtDeviceApis::Commons::UnknownException);
2077     }
2078 }
2079
2080 vector<string> Messaging::getFolderNamesMsgService()
2081 {
2082     vector<string> retVal;
2083 //    MSG_FOLDER_LIST_S msgFolderList = { 0, NULL }; // output data
2084 /*
2085     msg_struct_list_s msgFolderList = {0,};
2086
2087     Try
2088     {
2089         if (msg_get_folder_list(MsgGetCommonHandle(),
2090                                 &msgFolderList) != MSG_SUCCESS) {
2091             LoggerE("msg_get_folder_list failed");
2092             Throw(WrtDeviceApis::Commons::PlatformException);
2093         }
2094
2095         LoggerD("number of folder=" << msgFolderList.nCount);
2096         for (int i = 0; i < msgFolderList.nCount; i++) {
2097             LoggerD("folderName=" << msgFolderList.folderInfo[i].folderName);
2098             LoggerD("folderId=" << (int) msgFolderList.folderInfo[i].folderId);
2099             LoggerD(
2100                 "folderType=" <<
2101                 (int) msgFolderList.folderInfo[i].folderType);
2102             retVal.push_back(msgFolderList.folderInfo[i].folderName);
2103         }
2104         (void) msg_release_folder_list(&msgFolderList);
2105     }
2106
2107     Catch(WrtDeviceApis::Commons::PlatformException) {
2108         if (msgFolderList.nCount) {
2109             (void) msg_release_folder_list(&msgFolderList);
2110         }
2111         throw;
2112     }
2113     */
2114     return retVal;
2115 }
2116
2117 vector<string> Messaging::getFolderNamesEmail()
2118 {
2119     vector<string> retVal;
2120
2121     string tmpStr;
2122     email_mailbox_t* mailboxes = NULL;
2123     int mailboxesCount;
2124     string emailAccountName;
2125     EmailAccountInfo account = getCurrentEmailAccount();
2126
2127     Try
2128     {
2129         if (!email_get_mailbox_list(account.getIntId(), -1, &mailboxes,
2130                                     &mailboxesCount) || !mailboxes) {
2131             LoggerE("error during get mailboxes");
2132         }
2133                 if(mailboxes == NULL)
2134                 {
2135             LoggerE("error during get mailboxes");
2136                         ThrowMsg(WrtDeviceApis::Commons::PlatformException,
2137                                          "Couldn't get mailboxes");
2138                 }
2139         for (int i = 0; i < mailboxesCount; i++) {
2140             retVal.push_back(mailboxes->mailbox_name);
2141             LoggerD("mailbox found, name=" << mailboxes->mailbox_name);
2142             mailboxes++;
2143         }
2144                 if(mailboxes != NULL)
2145                 {
2146              if(  EMAIL_ERROR_NONE != email_free_mailbox( &mailboxes , mailboxesCount) )
2147                                         LoggerD("fail to email_free_mailbox - err ");
2148                 }
2149     }
2150
2151     Catch(WrtDeviceApis::Commons::PlatformException) {
2152         // nothing to clean, re-throw exception
2153         throw;
2154     }
2155
2156     return retVal;
2157 }
2158 /*
2159 vector<IMessagePtr> Messaging::findEmail(const std::string &folder,
2160                 const DeviceAPI::Tizen::FilterPtr& filter)
2161 {
2162     vector<IMessagePtr> retVal;
2163
2164     EmailAccountInfo account = getCurrentEmailAccount();
2165     if (account.getId().empty()) {
2166         LoggerW("No valid email accounts. Skipping");
2167         return retVal;
2168     }
2169
2170     int accountId = account.getIntId();
2171
2172     // number of found emails
2173     int count = 0;
2174     // start index
2175     int startIndex = 0;
2176
2177     do {
2178         email_mail_list_item_t* results = NULL;
2179         int err = email_get_mail_list(accountId,
2180                                          folder.c_str(),
2181                                          EMAIL_LIST_TYPE_NORMAL,
2182                                          startIndex,
2183                                          MESSAGE_FIND_LIMIT,
2184                                          EMAIL_SORT_DATETIME_HIGH,
2185                                          &results,
2186                                          &count);
2187         DPL::ScopedFree<email_mail_list_item_t> autoFree(results);
2188         (void)autoFree;
2189         if (EMAIL_ERROR_MAIL_NOT_FOUND == err || results == NULL) {
2190             LoggerW("No emails found in mailbox: " << folder);
2191             break;
2192         } else if (EMAIL_ERROR_NONE != err) {
2193             LoggerE(
2194                 "Unable to get mail list for mailbox: " << folder <<
2195                 ", Error: " << err);
2196             Throw(WrtDeviceApis::Commons::PlatformException);
2197         }
2198
2199         // apply filter
2200         for (int i = 0; i < count; ++i) {
2201             IMessagePtr msg = MessageFactory::createMessage(EMAIL, results[i].mail_id);
2202
2203
2204             if (!filter
2205 //                      || filter->compare(MessageFactory::convertToEmail(msg))         //TODO implemnet compare in filter
2206                         ) {
2207                 retVal.push_back(msg);
2208             }
2209         }
2210
2211         startIndex += count;
2212     }
2213     while (count >= MESSAGE_FIND_LIMIT);
2214
2215     return retVal;
2216 }
2217
2218 vector<IMessagePtr> Messaging::findEmail(FolderType folder,
2219                 const DeviceAPI::Tizen::FilterPtr& filter)
2220 {
2221     vector<IMessagePtr> result;
2222
2223     EmailAccountInfo account = getCurrentEmailAccount();
2224     if (account.getId().empty()) {
2225         LoggerW("No valid email accounts.");
2226         return result;
2227     }
2228
2229     string name;
2230     try {
2231         name = EmailConverter::toMailboxName(folder);
2232     }
2233     catch (const WrtDeviceApis::Commons::PlatformException& ex) {
2234         LoggerW(ex.DumpToString());
2235         return result;
2236     }
2237
2238     int accountId = account.getIntId();
2239     int startIndex = 0;
2240     int count = 0;
2241     do {
2242         email_mail_list_item_t* messages = NULL;
2243         int error = email_get_mail_list(accountId,
2244                                            name.c_str(),
2245                                            EMAIL_LIST_TYPE_NORMAL,
2246                                            startIndex,
2247                                            MESSAGE_FIND_LIMIT,
2248                                            EMAIL_SORT_DATETIME_HIGH,
2249                                            &messages,
2250                                            &count);
2251         DPL::ScopedFree<email_mail_list_item_t> freeGuard(messages);
2252         if ((EMAIL_ERROR_MAIL_NOT_FOUND == error) || (NULL == messages)) {
2253             LoggerW("No emails found in mailbox: " << name);
2254             break;
2255         } else if (EMAIL_ERROR_NONE != error) {
2256             ThrowMsg(WrtDeviceApis::Commons::PlatformException,
2257                      "Couldn't get mail list from mailbox: " << name <<
2258                      ". [" << error << "]");
2259         }
2260
2261         for (int i = 0; i < count; ++i) {
2262             IMessagePtr msg =
2263                 MessageFactory::createMessage(EMAIL, messages[i].mail_id);
2264             if (!filter
2265 //                      ||filter->compare(MessageFactory::convertToEmail(msg))          //TODO implement compare in filter
2266                 ) {
2267                 result.push_back(msg);
2268             }
2269         }
2270
2271         startIndex += count;
2272     }
2273     while (count >= MESSAGE_FIND_LIMIT);
2274
2275     return result;
2276 }
2277 */
2278 int Messaging::getConversationId(const int& msgId, const MessageType& msgtype)
2279 {
2280         LoggerD("Enter");
2281
2282         switch(msgtype)
2283         {
2284                 case EMAIL:
2285                 {
2286                         int index = 0, count = 0;
2287 //                      char *mailBox = NULL;
2288                         email_mail_list_item_t *mailList = NULL;
2289                         email_mail_data_t* result = NULL;
2290
2291                         LoggerD("Current Account " << m_currentEmailAccountId);
2292
2293                         try
2294                         {
2295
2296                                 if (EMAIL_ERROR_NONE != email_get_mail_data(msgId, &result)) {
2297                                         ThrowMsg(WrtDeviceApis::Commons::PlatformException,
2298                                                          "Couldn't get conversatino Id " << msgId );
2299                                 }
2300
2301                                 if (email_get_mail_list(m_currentEmailAccountId, result->mailbox_id, EMAIL_LIST_TYPE_NORMAL, 0, MESSAGE_FIND_LIMIT,
2302                                         EMAIL_SORT_DATETIME_HIGH, &mailList, &count) != EMAIL_ERROR_NONE)
2303                                 {
2304                                         ThrowMsg(WrtDeviceApis::Commons::PlatformException, "get email list fail" );
2305                                 }
2306
2307                                 email_free_mail_data(&result,1);
2308
2309                                 for (index = 0; index < count; index++)
2310                                 {
2311                                         if (mailList[index].mail_id == (int)msgId)
2312                                         {
2313                                                 return mailList[index].thread_id;
2314                                         }
2315                                 }
2316                                 ThrowMsg(WrtDeviceApis::Commons::PlatformException, "can not find msg" );
2317                         }
2318                         catch (const WrtDeviceApis::Commons::Exception& ex)
2319                         {
2320 //                              if (mailBox)
2321 //                                      free(mailBox);
2322                                 email_free_mail_data(&result,1);
2323                                 LoggerE("Exception: " << ex.GetMessage());
2324                                 throw;
2325                         }
2326                         return MSG_ERR_INVALID_MSG_TYPE;
2327                 }
2328                 break;
2329                 case SMS:
2330                 case MMS:
2331                 {
2332                         msg_struct_t msg = msg_create_struct(MSG_STRUCT_MESSAGE_INFO);
2333                         msg_struct_t sendOpt = msg_create_struct(MSG_STRUCT_SENDOPT);
2334                         msg_handle_t handle = MsgGetCommonHandle();
2335                         msg_error_t err = MSG_SUCCESS;
2336
2337                         err = msg_get_message(handle, msgId, msg, sendOpt);
2338
2339                         if( err < MSG_SUCCESS )
2340                         {
2341                                 ThrowMsg(WrtDeviceApis::Commons::PlatformException,
2342                                 "can not find msg id(" << msgId << ")");
2343                         }
2344
2345                         int threadId = 0;
2346                         err = msg_get_int_value(msg, MSG_MESSAGE_THREAD_ID_INT, &threadId);
2347
2348                         LoggerD(err);
2349
2350                         if( err < MSG_SUCCESS )
2351                         {
2352                                 ThrowMsg(WrtDeviceApis::Commons::PlatformException,
2353                                 "can not find thread with msg id(" << msgId << ")");
2354                         }
2355                         msg_release_struct(&msg);
2356                         msg_release_struct(&sendOpt);
2357
2358                         return threadId;
2359                 }
2360                 break;
2361                 default:
2362                         ThrowMsg(WrtDeviceApis::Commons::PlatformException,
2363                                 "Wrong Type (" << msgId << ")");
2364                         return MSG_ERR_INVALID_MSG_TYPE;
2365
2366         }
2367 }
2368 /*
2369 std::vector<IConversationPtr> Messaging::queryConversations(const DeviceAPI::Tizen::SortModePtr& sortMode,
2370                 const DeviceAPI::Tizen::FilterPtr& filter, long limit, long offset)
2371 {
2372         LoggerD("Enter");
2373
2374         std::vector<IConversationPtr> result;
2375         std::string filterSql;
2376         std::string orderLimitSql ="";
2377
2378         ConversationQueryGeneratorPtr queryGenerator(new ConversationQueryGenerator(sortMode, limit, offset));
2379         IFilterVisitorPtr filterVisitor = DPL::StaticPointerCast<IFilterVisitor>(queryGenerator);
2380         filter->travel(filterVisitor, 0);
2381
2382         LoggerD("filterSql:[" << filterSql <<"]");
2383
2384         int conversationType = queryGenerator->getMessageType();
2385         switch(conversationType){
2386                 case EMAIL:{
2387                         LoggerD("type is EMAIL:[" << conversationType <<"]");
2388                         queryGenerator->reset(MessageQueryGenerator::MODE_EMAIL);
2389                         filter->travel(filterVisitor, 0);
2390                         filterSql = queryGenerator->getQuery();
2391                         result = queryEmailConversation(filterSql);
2392                         break;
2393                 }
2394
2395                 case SMS:{
2396                         LoggerD("type is SMS:[" << conversationType <<"]");
2397                         queryGenerator->reset(MessageQueryGenerator::MODE_SMS_MMS);
2398                         IFilterVisitorPtr filterVisitor = DPL::StaticPointerCast<IFilterVisitor>(queryGenerator);
2399                         filter->travel(filterVisitor, 0);
2400                         filterSql = queryGenerator->getQuery();
2401                         LoggerD("filterSql:[" << filterSql <<"]");
2402                         LoggerD("orderLimitSql:[" << orderLimitSql <<"]");
2403                         result = querySmsMmsConversation(filterSql, orderLimitSql);
2404                         break;
2405                 }
2406
2407                 case MMS:{
2408                         LoggerD("type is MMS:[" << conversationType <<"]");
2409                         queryGenerator->reset(MessageQueryGenerator::MODE_SMS_MMS);
2410                         IFilterVisitorPtr filterVisitor = DPL::StaticPointerCast<IFilterVisitor>(queryGenerator);
2411                         filter->travel(filterVisitor, 0);
2412                         filterSql = queryGenerator->getQuery();
2413                         LoggerD("filterSql:[" << filterSql <<"]");
2414                         LoggerD("orderLimitSql:[" << orderLimitSql <<"]");
2415                         result = querySmsMmsConversation(filterSql, orderLimitSql);
2416                         break;
2417                 }
2418
2419                 default:{
2420                         LoggerE("[ERROR] >>> invlid type:[" << conversationType <<"]");
2421                  return result;
2422                 }
2423         }       //switch
2424
2425         return result;
2426 }
2427 */
2428 std::vector<IConversationPtr> Messaging::queryConversations(const DeviceAPI::Tizen::FilterPtr& filter,
2429                 const DeviceAPI::Tizen::SortModePtr& sortMode, int type, long limit, long offset)
2430 {
2431         LoggerD("Enter");
2432
2433         std::vector<IConversationPtr> result;
2434         std::string filterSql;
2435         std::string orderLimitSql ="";
2436
2437         ConversationQueryGeneratorPtr queryGenerator(new ConversationQueryGenerator(sortMode, limit, offset, type));
2438         IFilterVisitorPtr filterVisitor = DPL::StaticPointerCast<IFilterVisitor>(queryGenerator);
2439         filter->travel(filterVisitor, 0);
2440
2441         LoggerD("filterSql:[" << filterSql <<"]");
2442         int conversationType = queryGenerator->getMessageType();
2443         if(conversationType != -1)
2444         {
2445                 if(conversationType != type)
2446                 {
2447                         LoggerD("filter conversationType and service msg type is diff");
2448                         ThrowMsg(WrtDeviceApis::Commons::InvalidArgumentException, "invalid Fiilter Type");
2449                 }
2450         }
2451         switch(type){
2452                 case EMAIL:{
2453                         LoggerD("type is EMAIL:[" << conversationType <<"]");
2454                         queryGenerator->reset(MessageQueryGenerator::MODE_EMAIL);
2455                         filter->travel(filterVisitor, 0);
2456                         filterSql = queryGenerator->getQuery();
2457                         LoggerD("filterSql:[" << filterSql <<"]");
2458                         result = queryEmailConversation(filterSql);
2459                         break;
2460                 }
2461
2462                 case SMS:{
2463                         LoggerD("type is SMS:[" << conversationType <<"]");
2464                         queryGenerator->reset(MessageQueryGenerator::MODE_SMS);
2465                         IFilterVisitorPtr filterVisitor = DPL::StaticPointerCast<IFilterVisitor>(queryGenerator);
2466                         filter->travel(filterVisitor, 0);
2467                         filterSql = queryGenerator->getQuery();
2468                         orderLimitSql = queryGenerator->getOrderLimit();
2469                         LoggerD("filterSql:[" << filterSql <<"]");
2470                         LoggerD("orderLimitSql:[" << orderLimitSql <<"]");
2471                         result = querySmsMmsConversation(filterSql, orderLimitSql);
2472                         break;
2473                 }
2474
2475                 case MMS:{
2476                         LoggerD("type is MMS:[" << conversationType <<"]");
2477                         queryGenerator->reset(MessageQueryGenerator::MODE_MMS);
2478                         IFilterVisitorPtr filterVisitor = DPL::StaticPointerCast<IFilterVisitor>(queryGenerator);
2479                         filter->travel(filterVisitor, 0);
2480                         filterSql = queryGenerator->getQuery();
2481                         orderLimitSql = queryGenerator->getOrderLimit();
2482                         LoggerD("filterSql:[" << filterSql <<"]");
2483                         LoggerD("orderLimitSql:[" << orderLimitSql <<"]");
2484                         result = querySmsMmsConversation(filterSql, orderLimitSql);
2485                         break;
2486                 }
2487
2488                 default:{
2489                         LoggerE("[ERROR] >>> invlid type:[" << conversationType <<"]");
2490                  return result;
2491                 }
2492         }       //switch
2493
2494         return result;
2495 }
2496 /*
2497 bool Messaging::deleteConversations(const DeviceAPI::Tizen::SortModePtr& sortMode, const DeviceAPI::Tizen::FilterPtr& filter)
2498 {
2499         LoggerD("Enter");
2500
2501         std::vector<IConversationPtr> conversationsToDelete = queryConversations(sortMode, filter);
2502         return deleteConversations(conversationsToDelete);
2503 }
2504 */
2505 bool Messaging::deleteConversations(const std::vector<IConversationPtr>& conversations)
2506 {
2507         LoggerD("Enter");
2508
2509         if (conversations.size() == 0)
2510                 return false;
2511
2512         if (conversations[0]->getType() == EMAIL)
2513         {
2514                 LoggerD("Enter-Email");
2515                 int threadId = 0;
2516
2517                 for (std::size_t i = 0; i < conversations.size(); ++i)
2518                 {
2519                         threadId = conversations[i]->getConvId();
2520
2521                         if (email_delete_thread(threadId, false) != EMAIL_ERROR_NONE)
2522                         {
2523                                 return false;
2524                         }
2525                 }
2526         }
2527         else
2528         {
2529                 LoggerD("Enter-Msg");
2530                 msg_thread_id_t threadId = 0;
2531                 msg_handle_t handle = MsgGetCommonHandle();
2532
2533                 for (std::size_t i = 0; i < conversations.size(); ++i)
2534                 {
2535                         threadId = conversations[i]->getConvId();
2536                         if (msg_delete_thread_message_list(handle, threadId, FALSE) != MSG_SUCCESS)
2537                         {
2538                                 return false;
2539                         }
2540                 }
2541         }
2542         return true;
2543 }
2544
2545 std::vector<IMessageFolderPtr> Messaging::queryFolders(const DeviceAPI::Tizen::FilterPtr& filter)
2546 {
2547         LoggerD("Enter");
2548
2549         email_mailbox_t* mailboxes = NULL;
2550         email_mailbox_t* mailboxes_org = NULL;
2551         email_mailbox_t m_mailboxes;
2552         int mailboxesCount;
2553         int error = 0;
2554
2555         std::vector<IMessageFolderPtr> result;
2556         std::string folderName;
2557         int accountId = 0;
2558
2559     EmailAccountInfo account = getCurrentEmailAccount();
2560
2561         if (account.getId().empty()) {
2562                 LoggerW("No valid email accounts. Skipping");
2563                 return result;
2564         }
2565
2566         const vector<EmailAccountInfo> accounts = getEmailAccounts();
2567
2568         FolderQueryGeneratorPtr queryGenerator(new FolderQueryGenerator());
2569
2570         IFilterVisitorPtr filterVisitor = DPL::StaticPointerCast<IFilterVisitor>(queryGenerator);
2571         queryGenerator->reset();
2572         filter->travel(filterVisitor, 0);
2573         accountId = queryGenerator->getAccountId();
2574
2575         if(accountId == 0)
2576         {
2577                 LoggerW("No valid email accounts. accountId : 0");
2578                 return result;
2579         }
2580
2581         if(queryGenerator->isFolderPathExist() == 1){
2582 /*
2583                         folderName = queryGenerator->getFolderPath();
2584
2585                 if(email_get_mailbox_by_name(accountId, folderName.c_str(), &mailboxes) != 1)
2586                 {
2587                         LoggerE("error during get mailboxes");
2588                         return result;
2589                 }
2590
2591                 m_mailboxes = *mailboxes;
2592                 IMessageFolderPtr folderPtr(new MessageFolder(m_mailboxes));
2593                 result.push_back(folderPtr);
2594 */
2595         }else{
2596
2597                 if (!email_get_mailbox_list(accountId, -1, &mailboxes, &mailboxesCount) || !mailboxes)
2598                 {
2599                         LoggerE("error during get mailboxes");
2600                         return result;
2601                 }
2602
2603                 mailboxes_org = mailboxes;
2604
2605                 if (mailboxesCount <= 0)
2606                 {
2607                         LoggerD("Empty...");
2608                 }
2609                 else
2610                 {
2611                         LoggerD("found mailboxs : " << mailboxesCount);
2612                         for (int i = 0; i < mailboxesCount; i++)
2613                         {
2614
2615                                 m_mailboxes = *mailboxes;
2616                                 IMessageFolderPtr folderPtr(new MessageFolder(m_mailboxes));
2617                                 result.push_back(folderPtr);
2618                                 mailboxes++;
2619                         }
2620                 }
2621
2622                 mailboxes = mailboxes_org;
2623
2624                 if(mailboxes != NULL)
2625                 {
2626                         error = email_free_mailbox(&mailboxes,mailboxesCount);
2627                         LoggerE("email_free_mailbox : " << error);
2628                 }
2629         }
2630
2631         LoggerD("End");
2632
2633         return result;
2634
2635 }
2636
2637 }
2638 }