src/platform/Tizen/Messaging/Messaging.cpp

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