src/Messaging/Messaging.cpp

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