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