Update change log and spec for wrt-plugins-tizen_0.4.65
[platform/framework/web/wrt-plugins-tizen.git] / 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 }