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