2 // Tizen Web Device API
3 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
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
9 // http://www.apache.org/licenses/LICENSE-2.0
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.
18 #include <email-types.h>
19 #include <email-api.h>
21 #include <Commons/Exception.h>
22 #include <Commons/StringUtils.h>
23 #include <dpl/scoped_free.h>
24 #include "Messaging.h"
27 #include "BinarySms.h"
29 #include "EmailConverter.h"
31 #include "StorageChangesMessageFilterValidatorFactory.h"
32 #include "StorageChangesConversationFilterValidatorFactory.h"
33 #include "StorageChangesFolderFilterValidatorFactory.h"
34 #include "MessageQueryGenerator.h"
35 #include "ConversationQueryGenerator.h"
36 #include "FolderQueryGenerator.h"
37 #include "messageDB/MessageStorageReader.h"
40 #include <msg_storage.h>
42 #include <msg_transport.h>
45 #include <Commons/ThreadPool.h>
46 #include "Conversation.h"
47 #include "MessageFolder.h"
48 #include <dpl/singleton_safe_impl.h>
51 IMPLEMENT_SAFE_SINGLETON(DeviceAPI::Messaging::MsgServiceHandle)
54 #define LOG_ENTER LoggerD("---> ENTER");
55 #define LOG_EXIT LoggerD("---> EXIT");
59 using namespace DeviceAPI::Tizen;
60 using namespace WrtDeviceApis::Commons;
63 const char* DBUS_INTERFACE_EMAIL_RECEIVED = "User.Email.StorageChange";
64 const char* DBUS_FILTER_EMAIL_RECEIVED =
65 "type='signal',interface='User.Email.StorageChange'";
67 const int MESSAGE_FIND_LIMIT = 100;
73 int Messaging::m_currentEmailAccountId = 0;
74 DPL::Atomic Messaging::m_objCounter;
76 Messaging& Messaging::getInstance()
78 static Messaging instance;
82 Messaging::Messaging() :
83 m_onMessageReceivedHandleMgr(NULL),
84 m_dbusConnection(new DBus::Connection()),
85 m_dbusWorkerThread(new DPL::Thread())
89 const vector<EmailAccountInfo> accounts = getEmailAccounts();
90 LoggerD("Number of emails account=" << accounts.size());
91 if (accounts.size() > 0) {
92 // set default email account - first from the list
93 setCurrentEmailAccount(accounts[0]);
95 LoggerE("no default email account set");
99 Catch(WrtDeviceApis::Commons::PlatformException) {
100 LoggerE("No email accounts available");
103 Catch(WrtDeviceApis::Commons::InvalidArgumentException) {
104 LoggerE("No email accounts available");
105 //current email not configured, skipped
108 Catch(WrtDeviceApis::Commons::UnknownException) {
109 LoggerE("unknown error");
112 // Begin service for email management ?? pmi question if it should be added before email actions
113 if (0 == m_objCounter) {
114 int error = email_service_begin();
115 if (EMAIL_ERROR_NONE != error) {
116 LoggerE("email_service_begin() returned error " << error);
118 LoggerI("email_service_begin() executed without error");
123 m_dbusWorkerThread->Run();
124 m_dbusConnection->setWorkerThread(m_dbusWorkerThread);
125 m_dbusConnection->addFilter(DBUS_FILTER_EMAIL_RECEIVED);
126 m_dbusConnection->AddListener(this);
129 Messaging::~Messaging()
131 // Endservice for email management
132 m_dbusConnection->RemoveListener(this);
133 // m_dbusConnection->setWorkerThread(NULL);
134 m_dbusWorkerThread->Quit();
135 delete m_dbusWorkerThread;
137 if (!--m_objCounter) {
138 int error = email_service_end();
139 if (EMAIL_ERROR_NONE != error) {
140 LoggerE("email_service_end() returned error " << error);
142 LoggerD("email_service_end() executed without error");
148 void Messaging::getNumberOfMessages(MessageType msgType,
153 if (NULL == readed ||
155 LoggerE("output pointers are NULL");
156 Throw(WrtDeviceApis::Commons::InvalidArgumentException);
160 if (SMS == msgType) {
161 getNumberOfSms(folder, readed, unReaded);
162 } else if (MMS == msgType) {
163 getNumberOfMms(folder, readed, unReaded);
164 } else if (EMAIL == msgType) {
165 getNumberOfEmails(folder, readed, unReaded);
167 LoggerE("wrong message type");
168 Throw(WrtDeviceApis::Commons::PlatformException);
172 vector<IMessagePtr> Messaging::findMessages(const vector<MessageType>& msgTypes,
173 const string &folder,
174 const DeviceAPI::Tizen::FilterPtr& filter)
177 vector<IMessagePtr> retVal;
178 back_insert_iterator< vector<IMessagePtr> > biit(retVal);
179 vector<MessageType>::const_iterator it = msgTypes.begin();
180 for (; it != msgTypes.end(); ++it) {
181 LoggerD("Finding messages (" << *it << ") in folder: " << folder);
182 vector<IMessagePtr> result;
187 FolderType folderEnum = Sms::toFolder(folder);
188 result = findSms(folderEnum, filter);
193 FolderType folderEnum = Mms::toFolder(folder);
194 result = findMms(folderEnum, filter);
199 result = findEmail(folder, filter);
203 LoggerE("message type unknown");
204 Throw(WrtDeviceApis::Commons::PlatformException);
206 LoggerD("Found: " << result.size());
207 copy(result.begin(), result.end(), biit);
213 std::string Messaging::generateFilterSql(const DeviceAPI::Tizen::FilterPtr& filter){
215 std::string filterSql;
217 MessageQueryGeneratorPtr queryGenerator(new MessageQueryGenerator());
218 IFilterVisitorPtr filterVisitor = DPL::StaticPointerCast<IFilterVisitor>(queryGenerator);
219 filter->travel(filterVisitor, 0);
220 filterSql = queryGenerator->getQuery();
222 // LOGD(">>> filterSql:[%s]", filterSql.c_str());
227 vector<IMessagePtr> Messaging::findMessages(const vector<MessageType>& msgTypes, FolderType folder,
228 const DeviceAPI::Tizen::FilterPtr& filter)
231 vector<IMessagePtr> retVal;
232 back_insert_iterator< vector<IMessagePtr> > biit(retVal);
234 std::string filterSql = generateFilterSql(filter);
238 vector<MessageType>::const_iterator it = msgTypes.begin();
239 for (; it != msgTypes.end(); ++it) {
240 LoggerD("Finding messages (" << *it << ") in folder: " << folder);
241 vector<IMessagePtr>(Messaging::*findFnPtr)(FolderType folder, const DeviceAPI::Tizen::FilterPtr& filter) = NULL;
246 findFnPtr = &Messaging::findSms;
251 findFnPtr = &Messaging::findMms;
256 findFnPtr = &Messaging::findEmail;
260 LoggerE("message type unknown");
261 Throw(WrtDeviceApis::Commons::PlatformException);
264 vector<IMessagePtr> result = (this->*findFnPtr)(folder, filter);
265 LoggerD("Found: " << result.size());
266 copy(result.begin(), result.end(), biit);
272 void Messaging::printErrorMessage(int errorCode){
274 case EMAIL_ERROR_MAIL_NOT_FOUND:{
275 LoggerD("EMAIL_ERROR_MAIL_NOT_FOUND");
278 case EMAIL_ERROR_DB_FAILURE:{
279 LoggerD("EMAIL_ERROR_DB_FAILURE");
283 LoggerD("other error message:" << errorCode);
288 vector<IMessagePtr> Messaging::createVectorFromeMessageList(const msg_struct_list_s &message_list){
289 // vector<IMessagePtr> Messaging::createVectorFromeMessageList(const msg_struct_list_s message_list){
292 vector<IMessagePtr> retVal;
295 MessageType webApiMsgType;
297 LoggerD("message_list.nCount:" << message_list.nCount);
298 for (int i = 0; i < message_list.nCount; i++) {
299 int err = msg_get_int_value(message_list.msg_struct_info[i], MSG_MESSAGE_TYPE_INT, &tempInt);
300 if(err != MSG_SUCCESS)
302 ThrowMsg(WrtDeviceApis::Commons::UnknownException, "get message type fail");
304 LoggerD("Message type : " << tempInt);
316 LoggerE("[ERROR]invalid message type:" << tempInt);
321 // int l_msgId = msg_get_message_id(message_list.msgInfo[i]);
322 err = msg_get_int_value(message_list.msg_struct_info[i], MSG_MESSAGE_ID_INT, &tempInt);
323 LoggerD("Message Id : " << tempInt);
324 if(err != MSG_SUCCESS)
326 ThrowMsg(WrtDeviceApis::Commons::UnknownException, "get message id fail");
330 msg = MessageFactory::createMessage(webApiMsgType, tempInt);
331 retVal.push_back(msg);
338 std::vector<IConversationPtr> Messaging::createVectorFromeThreadViewList(const msg_struct_list_s& threadViewList){
339 vector<IConversationPtr> recVec;
341 if (threadViewList.nCount <= 0) {
344 for (int i = 0; i < threadViewList.nCount; i++) {
345 // IConversationPtr convPtr(new Conversation(i));
346 IConversationPtr convPtr(new Conversation(threadViewList.msg_struct_info[i]));
348 recVec.push_back(convPtr);
355 vector<IMessagePtr> Messaging::querySmsMmsMessages(const std::string& queryString){
356 // LOGD("<<< queryString:[%s]" ,queryString.c_str());
358 vector<IMessagePtr> retVal;
359 std::string tempString = "";
360 // MSG_LIST_S message_list = {0, NULL};
361 msg_struct_list_s message_list = {0,};
362 MessageStorageReader reader;
365 msg_error_t res = MSG_ERR_UNKNOWN;
367 reader.MsgStoConnectDB();
368 res = reader.queryMessage(queryString, tempString, &message_list);
370 if (MSG_SUCCESS != res) {
371 LoggerE("msg_get_folder_view_list failed " << res);
372 Throw(WrtDeviceApis::Commons::PlatformException);
374 reader.MsgStoDisconnectDB();
376 retVal = createVectorFromeMessageList(message_list);
377 reader.msg_release_list_struct_private(&message_list);
378 }Catch(WrtDeviceApis::Commons::PlatformException) {
379 LoggerE("Problem with message creation, cleaning");
380 if (message_list.nCount) {
381 reader.msg_release_list_struct_private(&message_list);
390 vector<IMessagePtr> Messaging::querySmsMmsMessages(const std::string& queryString, const std::string& orderLimitString){
391 // LOGD("<<< queryString:[%s]", queryString.c_str());
392 // LOGD("<<< orderLimitString:[%s]", orderLimitString.c_str());
394 vector<IMessagePtr> retVal;
395 // MSG_LIST_S message_list = {0, NULL};
396 msg_struct_list_s message_list = {0,};
397 MessageStorageReader reader;
400 msg_error_t res = MSG_ERR_UNKNOWN;
402 reader.MsgStoConnectDB();
403 res = reader.queryMessage(queryString, orderLimitString, &message_list);
405 if (MSG_SUCCESS != res) {
406 LoggerE("msg_get_folder_view_list failed " << res);
407 Throw(WrtDeviceApis::Commons::PlatformException);
409 reader.MsgStoDisconnectDB();
411 retVal = createVectorFromeMessageList(message_list);
412 LoggerD("<<< message_list.nCount:[" << message_list.nCount <<"]");
414 reader.msg_release_list_struct_private(&message_list);
415 }Catch(WrtDeviceApis::Commons::PlatformException) {
416 LoggerE("Problem with message creation, cleaning");
417 if (message_list.nCount) {
418 reader.msg_release_list_struct_private(&message_list);
427 vector<IConversationPtr> Messaging::querySmsMmsConversation(const std::string& sqlWhereClause, const std::string& orderLimitString){
428 // LOGD("sqlWhereClause:[%s]", sqlWhereClause.c_str());
429 // LOGD("<<< orderLimitString:[%s]", orderLimitString.c_str());
431 std::vector<IConversationPtr> recVec;
432 // MSG_THREAD_VIEW_LIST_S threadViewList;
433 msg_struct_list_s threadViewList;
435 msg_error_t res = MSG_ERR_UNKNOWN;
437 MessageStorageReader reader;
438 reader.MsgStoConnectDB();
439 res = reader.queryConversation(sqlWhereClause, orderLimitString, &threadViewList);
441 if (MSG_SUCCESS != res) {
442 LoggerE("queryConversation failed:" << res);
443 Throw(WrtDeviceApis::Commons::PlatformException);
445 reader.MsgStoDisconnectDB();
447 recVec = createVectorFromeThreadViewList(threadViewList);
449 reader.msg_release_list_struct_private(&threadViewList);
455 vector<IConversationPtr> Messaging::queryEmailConversation(const std::string& sqlWhereClause){
456 // LOGD("sqlWhereClause:[%s]",sqlWhereClause.c_str());
458 std::vector<IConversationPtr> emailResultVector;
459 email_mail_list_item_t* mailList = NULL;
460 int mailListCount = 0;
462 errCode = email_query_mail_list(const_cast<char*>(sqlWhereClause.c_str()), &mailList, &mailListCount);
464 if(errCode != EMAIL_ERROR_NONE){
465 LoggerE("[ERROR]email_query_mail_list failed:" << errCode);
466 printErrorMessage(errCode);
468 LoggerD("message found mailListCount:" << mailListCount);
469 std::map<int, int> checkUnique;
471 for(int i=0; i<mailListCount; i++){
472 if (checkUnique.find(mailList[i].thread_id) == checkUnique.end()){
473 checkUnique[mailList[i].thread_id] = mailList[i].thread_id;
474 IConversationPtr convPtr(new Conversation(mailList[i].thread_id, EMAIL));
477 LoggerD("mailList[i].thread_id:[" << mailList[i].thread_id << "]");
478 LoggerD("mailList[i].full_address_from:[" << mailList[i].full_address_from << "]");
479 LoggerD("mailList[i].email_address_sender : [" << mailList[i].email_address_sender <<"]");
480 LoggerD("mailList[i].subject:[" << mailList[i].subject << "]");
481 LoggerD("mailList[i].preview_text:[" << mailList[i].preview_text << "]");
482 LoggerD("mailList[i].flags_seen_field:[" << mailList[i].flags_seen_field << "]");
483 LoggerD("mailList[i].priority:[" << mailList[i].priority<< "]");
485 if (convPtr->getResult() == true)
487 emailResultVector.push_back(convPtr);
493 if (mailList != NULL){
498 return emailResultVector;
501 vector<IMessagePtr> Messaging::queryEmailMessage(const std::string& sqlWhereClause){
502 // LOGD("sqlWhereClause:[%s]", sqlWhereClause.c_str());
504 vector<IMessagePtr> emailResultVector;
506 email_mail_list_item_t* mailList = NULL;
507 int mailListCount = 0;
509 errCode = email_query_mail_list(const_cast<char*>(sqlWhereClause.c_str()), &mailList, &mailListCount);
511 if(errCode != EMAIL_ERROR_NONE){
512 LoggerE("[ERROR]email_query_mail_list failed:" << errCode);
513 printErrorMessage(errCode);
515 LoggerD("message found mailListCount:" << mailListCount);
517 for(int i=0; i<mailListCount; i++){
518 //IMessagePtr msg = MessageFactory::createMessage(EMAIL, mailList[i].mail_id);
519 IMessagePtr msg = MessageFactory::createEmailMessage(mailList[i].account_id, mailList[i].mail_id);
522 LoggerD("mailList[i].full_address_from:[" << mailList[i].full_address_from << "]");
523 LoggerD("mailList[i].email_address_sender : [" << mailList[i].email_address_sender <<"]");
524 //LoggerD("mailList[i].datetime:[" << mailList[i].datetime << "]");
525 LoggerD("mailList[i].subject:[" << mailList[i].subject << "]");
526 // LoggerD("mailList[i].mailbox_name:[" << mailList[i].mailbox_name << "]");
527 LoggerD("mailList[i].preview_text:[" << mailList[i].preview_text << "]");
528 LoggerD("mailList[i].flags_seen_field:[" << mailList[i].flags_seen_field << "]");
529 LoggerD("mailList[i].priority:[" << mailList[i].priority<< "]");
531 emailResultVector.push_back(msg);
535 if (mailList != NULL) {
540 return emailResultVector;
543 vector<IMessagePtr> Messaging::findMessages(const DeviceAPI::Tizen::FilterPtr& filter){
546 vector<IMessagePtr> retVal;
547 std::string filterSql;
549 MessageQueryGeneratorPtr queryGenerator(new MessageQueryGenerator());
551 IFilterVisitorPtr filterVisitor = DPL::StaticPointerCast<IFilterVisitor>(queryGenerator);
552 filter->travel(filterVisitor, 0);
553 filterSql = queryGenerator->getQuery();
554 // LOGD("filterSql:[%s]", filterSql.c_str());
556 int messageType = queryGenerator->getMessageType();
559 LoggerD("message type is EMAIL:[" << messageType <<"]");
560 retVal = queryEmailMessage(filterSql);
565 LoggerD("message type is SMS or MMS:[" << messageType <<"]");
566 queryGenerator->reset(MessageQueryGenerator::MODE_SMS_MMS);
567 filterVisitor = DPL::StaticPointerCast<IFilterVisitor>(queryGenerator);
568 filter->travel(filterVisitor);
569 filterSql = queryGenerator->getQuery();
570 retVal = querySmsMmsMessages(filterSql);
574 LoggerE("[ERROR] >>> invlid message type:[" << messageType <<"]");
584 vector<IMessagePtr> Messaging::findMessages(const DeviceAPI::Tizen::FilterPtr& filter, const DeviceAPI::Tizen::SortModePtr& sortMode, const long limit, const long offset)
588 vector<IMessagePtr> retVal;
589 std::string filterSql;
591 MessageQueryGeneratorPtr queryGenerator(new MessageQueryGenerator(sortMode, limit, offset));
593 IFilterVisitorPtr filterVisitor = DPL::StaticPointerCast<IFilterVisitor>(queryGenerator);
594 filter->travel(filterVisitor, 0);
595 filterSql = queryGenerator->getQuery();
596 // LOGD("filterSql:[%s]", filterSql.c_str());
598 int messageType = queryGenerator->getMessageType();
601 LoggerD("message type is EMAIL:[" << messageType <<"]");
602 retVal = queryEmailMessage(filterSql);
607 LoggerD("message type is SMS or MMS:[" << messageType <<"]");
608 queryGenerator->reset(MessageQueryGenerator::MODE_SMS_MMS);
609 filterVisitor = DPL::StaticPointerCast<IFilterVisitor>(queryGenerator);
610 filter->travel(filterVisitor);
611 filterSql = queryGenerator->getQuery();
612 retVal = querySmsMmsMessages(filterSql);
616 MsgLoggerE("[ERROR] >>> invlid message type:[" << messageType <<"]");
624 vector<IMessagePtr> Messaging::findMessages(const DeviceAPI::Tizen::FilterPtr& filter, const DeviceAPI::Tizen::SortModePtr& sortMode, const long limit, const long offset, const int type)
628 vector<IMessagePtr> retVal;
629 std::string filterSql;
630 std::string orderLimitSql ="";
631 std::string emailFilterSql;
632 std::string typeAndString = "AND A.MAIN_TYPE=";
633 std::string typeString = "A.MAIN_TYPE=";
635 MessageQueryGeneratorPtr queryGenerator(new MessageQueryGenerator(sortMode, limit, offset, type));
637 IFilterVisitorPtr filterVisitor = DPL::StaticPointerCast<IFilterVisitor>(queryGenerator);
638 filter->travel(filterVisitor, 0);
639 filterSql = queryGenerator->getQuery();
640 orderLimitSql = queryGenerator->getOrderLimit();
641 // //LOGD("filterSql:[%s]", filterSql.c_str());
642 // LOGD("filterSql:[%s]", filterSql.c_str());
643 // LOGD("orderLimitSql:[%s]", orderLimitSql.c_str());
645 int messageType = queryGenerator->getMessageType();
646 if(messageType != -1)
648 if(messageType != type)
650 LoggerD("filter messageType and service msg type is diff");
651 ThrowMsg(WrtDeviceApis::Commons::InvalidArgumentException, "invalid Fiilter Type");
656 LoggerD("message type is EMAIL:[" << messageType <<"]");
657 emailFilterSql = filterSql + orderLimitSql;
658 // LOGD("filterSql:[%s]", emailFilterSql.c_str());
659 retVal = queryEmailMessage(emailFilterSql);
663 LoggerD("message type is SMS :[" << messageType <<"]");
664 typeString.append("1");
665 typeAndString.append("1");
666 if(filterSql.length() == 0)
668 filterSql.append(typeString);
669 // LOGD("filterSql:[%s]", filterSql.c_str());
673 filterSql.append(typeAndString);
674 // LOGD("filterSql:[%s]", filterSql.c_str());
676 // LOGD("filterSql:[%s]", filterSql.c_str());
677 LoggerD("orderLimitSql.length():[" << orderLimitSql.length() <<"]");
678 retVal = querySmsMmsMessages(filterSql, orderLimitSql);
679 // LOGD("filterSql:[%s]", filterSql.c_str());
682 LoggerD("message type is MMS:[" << messageType <<"]");
683 typeString.append("2");
684 typeAndString.append("2");
685 if(filterSql.length() == 0)
687 filterSql.append(typeString);
688 // LOGD("filterSql:[%s]", filterSql.c_str());
692 filterSql.append(typeAndString);
693 // LOGD("filterSql:[%s]", filterSql.c_str());
695 // LOGD("filterSql:[%s]", filterSql.c_str());
696 LoggerD("orderLimitSql.length():[" << orderLimitSql.length() <<"]");
697 retVal = querySmsMmsMessages(filterSql, orderLimitSql);
698 // LOGD("filterSql:[%s]", filterSql.c_str());
702 MsgLoggerE("[ERROR] >>> invlid message type:[" << messageType <<"]");
711 vector<string> Messaging::getMessageIds(MessageType msgType,
716 return getSmsIds(folder);
718 return getMmsIds(folder);
720 return getEmailIds(folder);
722 LoggerE("not supported message type");
723 Throw(WrtDeviceApis::Commons::InvalidArgumentException);
727 vector<string> Messaging::getSmsIds(FolderType folder)
729 vector<string> retVal;
730 msg_message_t msg = msg_new_message();
731 MSG_LIST_S folder_list_view = { 0, NULL };
735 const MSG_SORT_RULE_S sort_rules = { MSG_SORT_BY_DISPLAY_TIME, true };
736 msg_error_t res = MSG_ERR_UNKNOWN;
737 const msg_folder_id_t platformFolder = convertFolderToPlatform(folder);
738 res = msg_get_folder_view_list(
739 MsgGetCommonHandle(), platformFolder, &sort_rules,
742 if (MSG_SUCCESS != res) {
743 LoggerE("msg_Get_folder_view_list failed" << res);
744 Throw(WrtDeviceApis::Commons::PlatformException);
747 for (int i = 0; i < folder_list_view.nCount; i++) {
749 msg_get_message_type(folder_list_view.
751 int l_msgId = msg_get_message_id(
752 folder_list_view.msgInfo[i]);
753 ostringstream stream;
755 retVal.push_back(stream.str());
759 msg_release_list_struct(&folder_list_view);
762 Catch(WrtDeviceApis::Commons::PlatformException) {
763 LoggerE("Problem with message creation, cleaning");
764 if (folder_list_view.nCount) {
765 msg_release_list_struct(&folder_list_view);
768 msg_release_message(&msg);
776 vector<string> Messaging::getMmsIds(FolderType folder)
778 vector<string> retVal;
779 msg_message_t msg = msg_new_message();
780 MSG_LIST_S folder_list_view = { 0, NULL };
784 const MSG_SORT_RULE_S sort_rules = { MSG_SORT_BY_DISPLAY_TIME, true };
785 msg_error_t res = MSG_ERR_UNKNOWN;
786 const msg_folder_id_t platformFolder = convertFolderToPlatform(folder);
787 res = msg_get_folder_view_list(
788 MsgGetCommonHandle(), platformFolder, &sort_rules,
791 if (MSG_SUCCESS != res) {
792 LoggerE("msg_Get_folder_view_list failed" << res);
793 Throw(WrtDeviceApis::Commons::PlatformException);
796 for (int i = 0; i < folder_list_view.nCount; i++) {
798 msg_get_message_type(folder_list_view.
800 int l_msgId = msg_get_message_id(
801 folder_list_view.msgInfo[i]);
802 ostringstream stream;
804 retVal.push_back(stream.str());
808 msg_release_list_struct(&folder_list_view);
811 Catch(WrtDeviceApis::Commons::PlatformException) {
812 LoggerE("Problem with message creation, cleaning");
813 if (folder_list_view.nCount) {
814 msg_release_list_struct(&folder_list_view);
817 msg_release_message(&msg);
825 vector<string> Messaging::getEmailIds(FolderType folder)
827 vector<string> retVal;
831 Throw(WrtDeviceApis::Commons::UnknownException);
836 vector<EmailAccountInfo> Messaging::getEmailAccounts() const
839 email_account_t* accounts = NULL;
842 if (!email_get_account_list(&accounts, &count)) {
843 ThrowMsg(WrtDeviceApis::Commons::PlatformException, "Couldn't get e-mail accounts.");
846 LoggerE( "count : " << count);
849 ThrowMsg(WrtDeviceApis::Commons::PlatformException, "No e-mail account found.");
852 vector<EmailAccountInfo> result;
853 for (int i = 0; i < count; ++i)
855 if(accounts[i].incoming_server_user_name != NULL)
857 LoggerE("server user name is NULL");
858 EmailAccountInfo account(accounts[i].account_id,
859 accounts[i].incoming_server_user_name,
860 accounts[i].user_email_address);
861 result.push_back(account);
865 LoggerE("normal case");
866 std::string Unknown = "UNKNOWN";
867 EmailAccountInfo account(accounts[i].account_id,
869 accounts[i].user_email_address);
870 result.push_back(account);
874 if (accounts != NULL) {
875 email_free_account(&accounts, count);
880 Catch(WrtDeviceApis::Commons::PlatformException) {
881 if (accounts != NULL) {
882 email_free_account(&accounts, count);
884 LoggerE("PlatformException");
885 ThrowMsg(WrtDeviceApis::Commons::PlatformException, "No e-mail account found.");
887 Catch(WrtDeviceApis::Commons::UnknownException) {
888 if (accounts != NULL) {
889 email_free_account(&accounts, count);
891 LoggerE("UnknownException");
892 ThrowMsg(WrtDeviceApis::Commons::PlatformException, "Couldn't convert e-mail account id");
896 int Messaging::getEmailAccountId(const std::string& account)
899 string tmpAccount = account;
900 email_account_t *pAccountArray = NULL;
905 if (account.empty()) {
906 tmpAccount = getCurrentEmailAccount().getAddress();
907 if (tmpAccount.empty()) {
909 "current email account is not set, possible that no account created");
910 Throw(WrtDeviceApis::Commons::PlatformException);
914 if (!email_get_account_list(&pAccountArray, &iCount)) {
915 LoggerE("email_get_account_list error");
916 Throw(WrtDeviceApis::Commons::PlatformException);
920 LoggerE("no email account exist");
921 Throw(WrtDeviceApis::Commons::PlatformException);
924 for (int i = 0; i < iCount; i++) {
925 string tmp = pAccountArray[i].user_email_address;
926 if (tmp == tmpAccount) {
927 m_currentEmailAccountId = pAccountArray[i].account_id;
928 retVal = m_currentEmailAccountId;
933 if (0 == m_currentEmailAccountId) {
934 LoggerE("wrong email account ID");
935 Throw(WrtDeviceApis::Commons::PlatformException);
938 if (pAccountArray != NULL) {
939 LoggerD("free account, ptr=" << pAccountArray);
940 email_free_account(&pAccountArray, iCount);
944 LoggerE("no email account created");
945 Throw(WrtDeviceApis::Commons::PlatformException);
949 Catch(WrtDeviceApis::Commons::PlatformException) {
950 LoggerE("exception catch, platform exception");
951 if (pAccountArray != NULL) {
952 email_free_account(&pAccountArray, iCount);
960 void Messaging::fetchEmailHeaders()
963 email_mailbox_t *mailbox = NULL;
966 mailbox = static_cast<email_mailbox_t*>(calloc(sizeof (email_mailbox_t), 1));
968 LoggerE("calloc failed");
971 mailbox->account_id = m_currentEmailAccountId;
972 mailbox->mailbox_name = strdup(EMAIL_INBOX_NAME);
973 // if (EMAIL_ERROR_NONE != email_sync_header(mailbox, &handle)) {
974 if (EMAIL_ERROR_NONE != email_sync_header(mailbox->account_id, 0, &handle)) {
975 LoggerE("email_sync_header failed");
977 error = email_free_mailbox(&mailbox, 1);
978 LoggerE("email_free_mailbox : " << error);
982 int Messaging::convertFolderToPlatform(const FolderType folder)
984 msg_folder_id_t platfromFolderId;
987 platfromFolderId = MSG_INBOX_ID;
990 platfromFolderId = MSG_DRAFT_ID;
993 platfromFolderId = MSG_OUTBOX_ID;
996 platfromFolderId = MSG_SENTBOX_ID;
999 // intentionally not break in platform is no spambox
1001 LoggerE("Invalid folder: " << folder);
1002 Throw(WrtDeviceApis::Commons::PlatformException);
1005 return platfromFolderId;
1008 int Messaging::convertFolderToPlatform(const std::string &folder)
1010 // MSG_FOLDER_LIST_S folderList = { 0, NULL };
1017 msg_get_folder_list(MsgGetCommonHandle(), &folderList)) {
1018 LoggerE("msg_get_folder_list error");
1019 Throw(WrtDeviceApis::Commons::PlatformException);
1021 for (int i = 0; i < folderList.nCount; ++i) {
1022 if (MSG_FOLDER_TYPE_USER_DEF ==
1023 folderList.folderInfo[i].folderType &&
1024 NULL != folderList.folderInfo[i].folderName &&
1025 folder == folderList.folderInfo[i].folderName) {
1026 result = folderList.folderInfo[i].folderId;
1031 Catch(WrtDeviceApis::Commons::PlatformException) {
1032 if (folderList.nCount) {
1033 msg_release_folder_list(&folderList);
1037 if (folderList.nCount) {
1038 msg_release_folder_list(&folderList);
1044 void Messaging::addOnMessageReceived(
1045 const EmitterMessageReceivedPtr& emitter, const DeviceAPI::Tizen::FilterPtr& filter, int funtionIndex)
1053 LoggerD("funtionIndex = " << funtionIndex);
1054 bool isValidFilter = validateFilter(filter, funtionIndex);
1055 if(isValidFilter == false){
1056 LoggerE("[ERROR]this filter is invalid");
1057 Throw(WrtDeviceApis::Commons::InvalidArgumentException);
1060 Catch(WrtDeviceApis::Commons::PlatformException) {
1065 LoggerD("filter is NULL");
1069 m_onMessageReceived.attach(emitter);
1070 EmittersMessageReceived::LockType lock = m_onMessageReceived.getLock();
1071 if ((m_onMessageReceived.size() == 1)&&((m_onConversationReceived.size() + m_onFolderReceived.size()) == 0)) {
1072 m_onMessageReceivedHandleMgr = MsgServiceHandleMgrPtr(
1073 new MsgServiceHandleMgr());
1076 err = msg_reg_storage_change_callback(
1077 m_onMessageReceivedHandleMgr->getHandle(),
1078 onMessageStorageChanged,
1081 Catch(WrtDeviceApis::Commons::PlatformException){
1082 LoggerD("addOnMessageReceived failed");
1083 Throw(WrtDeviceApis::Commons::PlatformException);
1086 if (err != MSG_SUCCESS) {
1087 LoggerE("Couldn't register on MMS received callback, err=" << err);
1090 m_dbusConnection->open(DBUS_BUS_SYSTEM);
1094 void Messaging::addOnMessageReceived(
1095 const EmitterConversationReceivedPtr& emitter, const DeviceAPI::Tizen::FilterPtr& filter, int funtionIndex)
1103 LoggerD("funtionIndex = " << funtionIndex);
1104 bool isValidFilter = validateFilter(filter, funtionIndex);
1105 if(isValidFilter == false){
1106 LoggerE("[ERROR]this filter is invalid");
1107 Throw(WrtDeviceApis::Commons::InvalidArgumentException);
1110 Catch(WrtDeviceApis::Commons::PlatformException) {
1115 LoggerD("filter is NULL");
1119 m_onConversationReceived.attach(emitter);
1120 EmittersConversationReceived::LockType lock = m_onConversationReceived.getLock();
1121 if ((m_onConversationReceived.size() == 1)&&((m_onMessageReceived.size() + m_onFolderReceived.size()) == 0)) {
1122 m_onMessageReceivedHandleMgr = MsgServiceHandleMgrPtr(
1123 new MsgServiceHandleMgr());
1126 err = msg_reg_storage_change_callback(
1127 m_onMessageReceivedHandleMgr->getHandle(),
1128 onMessageStorageChanged,
1131 Catch(WrtDeviceApis::Commons::PlatformException){
1132 LoggerD("addOnMessageReceived failed");
1133 Throw(WrtDeviceApis::Commons::PlatformException);
1136 if (err != MSG_SUCCESS) {
1137 LoggerE("Couldn't register on MMS received callback, err=" << err);
1140 m_dbusConnection->open(DBUS_BUS_SYSTEM);
1144 void Messaging::addOnMessageReceived(
1145 const EmitterFolderReceivedPtr& emitter, const DeviceAPI::Tizen::FilterPtr& filter, int funtionIndex)
1153 LoggerD("funtionIndex = " << funtionIndex);
1154 bool isValidFilter = validateFilter(filter, funtionIndex);
1155 if(isValidFilter == false){
1156 LoggerE("[ERROR]this filter is invalid");
1157 Throw(WrtDeviceApis::Commons::InvalidArgumentException);
1160 Catch(WrtDeviceApis::Commons::PlatformException) {
1165 LoggerD("filter is NULL");
1169 m_onFolderReceived.attach(emitter);
1170 EmittersFolderReceived::LockType lock = m_onFolderReceived.getLock();
1171 if ((m_onFolderReceived.size() == 1)&&((m_onMessageReceived.size() + m_onConversationReceived.size()) == 0)) {
1172 m_onMessageReceivedHandleMgr = MsgServiceHandleMgrPtr(
1173 new MsgServiceHandleMgr());
1178 err = msg_reg_storage_change_callback(
1179 m_onMessageReceivedHandleMgr->getHandle(),
1180 onMessageStorageChanged,
1183 Catch(WrtDeviceApis::Commons::PlatformException){
1184 LoggerD("addOnMessageReceived failed");
1185 Throw(WrtDeviceApis::Commons::PlatformException);
1188 if (err != MSG_SUCCESS) {
1189 LoggerE("Couldn't register on MMS received callback, err=" << err);
1190 // Throw(WrtDeviceApis::Commons::UnknownException);
1193 m_dbusConnection->open(DBUS_BUS_SYSTEM);
1197 bool Messaging::validateFilter(const DeviceAPI::Tizen::FilterPtr& filter, const int funtionIndex){
1200 bool retBool = false;
1201 LoggerD("funtionIndex = " << funtionIndex);
1204 if(funtionIndex == 0)
1206 StorageChangesMessageFilterValidatorPtr validatorMsg =
1207 StorageChangesMessageFilterValidatorFactory::getStorageChangesMessageFilterValidator();
1209 FilterValidatorPtr filterValidatorMsg = DPL::StaticPointerCast<FilterValidator>(validatorMsg);
1210 retBool = filter->validate(filterValidatorMsg);
1211 }else if(funtionIndex == 1)
1213 StorageChangesConversationFilterValidatorPtr validatorConv =
1214 StorageChangesConversationFilterValidatorFactory::getStorageChangesConversationFilterValidator();
1216 FilterValidatorPtr filterValidatorConv = DPL::StaticPointerCast<FilterValidator>(validatorConv);
1217 retBool = filter->validate(filterValidatorConv);
1218 }else if(funtionIndex == 2)
1220 StorageChangesFolderFilterValidatorPtr validatorFolder =
1221 StorageChangesFolderFilterValidatorFactory::getStorageChangesFolderFilterValidator();
1223 FilterValidatorPtr filterValidatorFolder = DPL::StaticPointerCast<FilterValidator>(validatorFolder);
1224 retBool = filter->validate(filterValidatorFolder);
1227 if(retBool == false){
1228 Throw(WrtDeviceApis::Commons::InvalidArgumentException);
1231 LoggerD("filter is NULL");
1235 LoggerD(">>> retBool:" << retBool);
1241 void Messaging::removeOnMessageMsgReceived(EmitterMessageReceived::IdType id)
1244 m_onMessageReceived.detach(id);
1245 EmittersMessageReceived::LockType lock = m_onMessageReceived.getLock();
1246 if ((m_onMessageReceived.size()+m_onConversationReceived.size()+m_onFolderReceived.size()) == 0) {
1247 m_onMessageReceivedHandleMgr = MsgServiceHandleMgrPtr(NULL);
1248 m_dbusConnection->close();
1252 void Messaging::removeOnMessageConvReceived(EmitterConversationReceived::IdType id)
1255 m_onConversationReceived.detach(id);
1256 EmittersConversationReceived::LockType lock = m_onConversationReceived.getLock();
1257 if ((m_onMessageReceived.size()+m_onConversationReceived.size()+m_onFolderReceived.size()) == 0) {
1258 m_onMessageReceivedHandleMgr = MsgServiceHandleMgrPtr(NULL);
1259 m_dbusConnection->close();
1263 void Messaging::removeOnMessageFolderReceived(EmitterFolderReceived::IdType id)
1266 m_onFolderReceived.detach(id);
1267 EmittersFolderReceived::LockType lock = m_onFolderReceived.getLock();
1268 if ((m_onMessageReceived.size()+m_onConversationReceived.size()+m_onFolderReceived.size()) == 0) {
1269 m_onMessageReceivedHandleMgr = MsgServiceHandleMgrPtr(NULL);
1270 m_dbusConnection->close();
1274 void Messaging::OnEventReceived(const DBus::MessageEvent& event)
1277 EventMessageReceivedPtr jsEvent(new EventMessageReceived());
1278 DBus::MessagePtr message = event.GetArg0();
1282 jsEvent->setExceptionCode(WrtDeviceApis::Commons::ExceptionCodes::PlatformException);
1283 m_onMessageReceived.emit(jsEvent);
1287 if (message->getInterface() == DBUS_INTERFACE_EMAIL_RECEIVED)
1289 int account_id = 0, mail_id = 0, thread_id = 0, status = 0;
1291 email_mailbox_t m_mailboxes;
1293 DBus::Message::ReadIterator it = message->getReadIterator();
1294 for (int i = 0; it->isValid(); it->next(), ++i)
1296 if ((i == 0) && (it->getArgType() == DBUS_TYPE_INT32))
1298 status = it->getInt();
1299 LoggerI("status: " << status);
1301 else if ((i == 1) && (it->getArgType() == DBUS_TYPE_INT32))
1303 account_id = it->getInt();
1304 LoggerI("account_id: " << account_id);
1306 else if ((i == 2) && (it->getArgType() == DBUS_TYPE_INT32))
1308 mail_id = it->getInt();
1309 LoggerI("mail_id: " << mail_id);
1311 else if ((i == 3) && (it->getArgType() == DBUS_TYPE_STRING))
1313 name = it->getString();
1314 LoggerI("name: " << name);
1316 else if ((i == 4) && (it->getArgType() == DBUS_TYPE_INT32))
1318 thread_id = it->getInt();
1319 LoggerI("thread_id: " << thread_id);
1323 if ((mail_id > 0) && (NOTI_MAIL_ADD == status))
1324 { // TODO also RECEIVE_THREAD_ITEM?
1325 LoggerI("Email received. mail_id: " << mail_id);
1327 IMessagePtr msg = MessageFactory::createMessage(EMAIL, mail_id);
1328 IConversationPtr conversation(new Conversation(thread_id, EMAIL));
1330 // TODO Temporary fix: ignore messages from OUTBOX, SENTBOX & DRAFTBOX -> most probably we added them
1331 FolderType folder = msg->getCurrentFolder();
1332 jsEvent->setMsg_Event_Type(EventMessageReceived::MSG_ADDED);
1334 LoggerI("Added message is in folder: " << folder);
1336 jsEvent->setMessage(msg);
1337 jsEvent->setConversation(conversation);
1339 if(m_onMessageReceived.size() > 0){
1340 m_onMessageReceived.emit(jsEvent);
1343 if(m_onConversationReceived.size() > 0){
1344 m_onConversationReceived.emit(jsEvent);
1347 if (OUTBOX != folder && SENTBOX != folder && DRAFTBOX != folder)
1349 jsEvent->setMessage(msg);
1350 jsEvent->setConversation(conversation);
1352 if(m_onMessageReceived.size() > 0){
1353 m_onMessageReceived.emit(jsEvent);
1356 if(m_onConversationReceived.size() > 0){
1357 m_onConversationReceived.emit(jsEvent);
1361 LoggerW("New email message in ignored folder: " << folder);
1365 else if ((mail_id > 0) && (NOTI_MAIL_DELETE == status))
1366 { // TODO also RECEIVE_THREAD_ITEM?
1367 LoggerI("Email received. delete type: " << mail_id);
1369 std::vector<std::string> strIds = String::split(name, ',');
1371 std::stringstream stream;
1372 for (std::vector<std::string>::iterator it = strIds.begin(); it != strIds.end(); ++it)
1374 LoggerD("ID is :" << *it);
1376 if ( (*it).length() > 0 ) //vaild id
1382 IMessagePtr msg = MessageFactory::createMessage(EMPTY_MESSAGE, id);
1383 IConversationPtr conversation(new Conversation());
1385 FolderType folder = msg->getCurrentFolder();
1386 jsEvent->setMsg_Event_Type(EventMessageReceived::MSG_DELETED);
1388 if (true) { // if (OUTBOX != folder && SENTBOX != folder && DRAFTBOX != folder)
1389 jsEvent->setMessage(msg);
1390 jsEvent->setConversation(conversation);
1391 if(m_onMessageReceived.size() > 0){
1392 m_onMessageReceived.emit(jsEvent);
1396 LoggerW("New email message in ignored folder: " << folder);
1404 else if ((mail_id > 0) && (NOTI_MAIL_UPDATE == status))
1405 { // TODO also RECEIVE_THREAD_ITEM?
1406 LoggerI("Email received. mail_id: " << mail_id);
1408 IMessagePtr msg = MessageFactory::createMessage(EMAIL, mail_id);
1409 IConversationPtr conversation(new Conversation(thread_id, EMAIL));
1411 FolderType folder = msg->getCurrentFolder();
1412 jsEvent->setMsg_Event_Type(EventMessageReceived::MSG_UPDATED);
1414 if (true) { // if (OUTBOX != folder && SENTBOX != folder && DRAFTBOX != folder)
1415 jsEvent->setMessage(msg);
1416 jsEvent->setConversation(conversation);
1417 if(m_onMessageReceived.size() > 0)
1418 m_onMessageReceived.emit(jsEvent);
1419 if(m_onConversationReceived.size() > 0)
1420 m_onConversationReceived.emit(jsEvent);
1422 LoggerW("New email message in ignored folder: " << folder);
1425 else if ((mail_id > 0) && (NOTI_THREAD_DELETE == status))
1426 { // TODO also RECEIVE_THREAD_ITEM?
1427 LoggerI("Email received. delete thread Id : " << mail_id);
1429 IConversationPtr conversation(new Conversation());
1430 conversation->setConvId(mail_id);
1431 jsEvent->setMsg_Event_Type(EventMessageReceived::MSG_DELETED);
1432 jsEvent->setConversation(conversation);
1434 if(m_onConversationReceived.size() > 0){
1435 m_onConversationReceived.emit(jsEvent);
1438 else if (NOTI_MAILBOX_ADD == status)
1440 LoggerI("Emailbox received. account Id: " << account_id);
1441 LoggerI("name Id: " << name);
1442 LoggerI("mailBox Id: " << mail_id);
1444 email_mailbox_t* mail_box = NULL;
1446 if (EMAIL_ERROR_NONE != email_get_mailbox_by_mailbox_id(mail_id, &mail_box)) {
1447 LoggerE("Couldn't retrieve message or it has been malformed.");
1450 if(mail_box != NULL)
1452 m_mailboxes = *mail_box;
1453 IMessageFolderPtr folderPtr(new MessageFolder(m_mailboxes));
1454 jsEvent->setMessageFolder(folderPtr);
1455 jsEvent->setMsg_Event_Type(EventMessageReceived::MSG_ADDED);
1456 if(m_onFolderReceived.size() > 0)
1458 m_onFolderReceived.emit(jsEvent);
1465 if( EMAIL_ERROR_NONE != email_free_mailbox( &mail_box , 1) )
1466 LoggerD("fail to email_free_mailbox - err ");
1470 else if ((NOTI_MAILBOX_UPDATE == status) || (NOTI_MAILBOX_FIELD_UPDATE == status) || (NOTI_MAILBOX_RENAME == status))
1472 LoggerI("Emailbox received. account Id: " << account_id);
1473 LoggerI("name Id: " << name);
1474 LoggerI("mailBox Id: " << mail_id);
1476 email_mailbox_t* mail_box = NULL;
1478 if (EMAIL_ERROR_NONE != email_get_mailbox_by_mailbox_id(mail_id, &mail_box)) {
1479 LoggerE("Couldn't retrieve message or it has been malformed.");
1482 if(mail_box != NULL)
1484 m_mailboxes = *mail_box;
1486 IMessageFolderPtr folderPtr(new MessageFolder(m_mailboxes));
1487 jsEvent->setMessageFolder(folderPtr);
1488 jsEvent->setMsg_Event_Type(EventMessageReceived::MSG_UPDATED);
1490 if(m_onFolderReceived.size() > 0)
1492 m_onFolderReceived.emit(jsEvent);
1498 if( EMAIL_ERROR_NONE != email_free_mailbox( &mail_box , 1) )
1499 LoggerD("fail to email_free_mailbox - err ");
1502 else if (NOTI_MAILBOX_DELETE == status)
1504 LoggerI("Emailbox received. account Id: " << account_id);
1505 LoggerI("name Id: " << name);
1506 LoggerI("mailBox Id: " << mail_id);
1508 // make empty mailbox
1509 m_mailboxes.mailbox_id = mail_id;
1510 m_mailboxes.account_id = account_id;
1511 m_mailboxes.alias = (char *)"";
1512 m_mailboxes.mailbox_name = (char *)"";
1514 IMessageFolderPtr folderPtr(new MessageFolder(m_mailboxes));
1515 jsEvent->setMessageFolder(folderPtr);
1516 jsEvent->setMsg_Event_Type(EventMessageReceived::MSG_DELETED);
1518 if(m_onFolderReceived.size() > 0)
1520 m_onFolderReceived.emit(jsEvent);
1525 LoggerE("Couldn't retrieve message or it has been malformed.");
1528 else // DBUS_INTERFACE_EMAIL_RECEIVED
1530 LoggerD("Wrong DBus interface, skipping it.");
1535 void Messaging::onMessageStorageChanged(msg_handle_t handle,
1536 msg_storage_change_type_t storageChangeType,
1537 msg_id_list_s *pMsgIdList,
1543 msg_error_t err = MSG_SUCCESS;
1545 if(storageChangeType == MSG_STORAGE_CHANGE_CONTACT)
1547 LoggerD("storageChangeType is MSG_STORAGE_CHANGE_CONTACT");
1551 Messaging* this_ = static_cast<Messaging*>(data);
1555 int msgCount = pMsgIdList->nCount;
1556 LoggerD("msgCount = "<< msgCount);
1558 for(int index = 0; index < msgCount; index++)
1561 LoggerD("storageChangeType = "<< storageChangeType);
1563 if(storageChangeType == MSG_STORAGE_CHANGE_DELETE)
1565 IMessagePtr message = MessageFactory::createMessage(EMPTY_MESSAGE, pMsgIdList->msgIdList[index]);
1566 IConversationPtr conversation(new Conversation());
1567 EventMessageReceivedPtr event(new EventMessageReceived());
1568 event->setMessage(message);
1569 event->setConversation(conversation);
1570 event->setMsg_Event_Type(EventMessageReceived::MSG_DELETED);
1572 if(this_->m_onMessageReceived.size() > 0){
1573 this_->m_onMessageReceived.emit(event);
1575 if(this_->m_onConversationReceived.size() > 0){
1576 this_->m_onConversationReceived.emit(event);
1581 msg_struct_t msg = NULL;
1582 msg_struct_t sendOpt = NULL;
1583 msg = msg_create_struct(MSG_STRUCT_MESSAGE_INFO);
1584 sendOpt = msg_create_struct(MSG_STRUCT_SENDOPT);
1586 err = msg_get_message(handle, pMsgIdList->msgIdList[index], msg, sendOpt);
1588 if (err != MSG_SUCCESS)
1590 LoggerD("Get Message Failed!");
1591 LoggerD("err" << err);
1592 msg_release_struct(&msg);
1593 msg_release_struct(&sendOpt);
1599 msg_get_int_value(msg, MSG_MESSAGE_TYPE_INT, &msgType);
1600 LoggerD("msgType : " << msgType);
1601 if((msgType > MSG_TYPE_INVALID) && ( msgType <= MSG_TYPE_SMS_REJECT))
1603 if(msgType != MSG_TYPE_MMS_NOTI)
1606 msg_get_int_value(msg, MSG_MESSAGE_ID_INT, &msgId);
1607 IMessagePtr message = MessageFactory::createMessage(
1612 ISmsPtr sms = MessageFactory::convertToSms(message);
1613 IConversationPtr conversation(new Conversation(message->getId(), SMS));
1614 EventMessageReceivedPtr event(new EventMessageReceived());
1615 event->setMessage(message);
1616 event->setConversation(conversation);
1618 if(storageChangeType == MSG_STORAGE_CHANGE_INSERT)
1620 LoggerD("MSG_STORAGE_CHANGE_INSERT");
1621 event->setMsg_Event_Type(EventMessageReceived::MSG_ADDED);
1623 else if(storageChangeType == MSG_STORAGE_CHANGE_UPDATE)
1625 LoggerD("MSG_STORAGE_CHANGE_UPDATE");
1626 event->setMsg_Event_Type(EventMessageReceived::MSG_UPDATED);
1629 if(this_->m_onMessageReceived.size() > 0){
1630 this_->m_onMessageReceived.emit(event);
1632 if(this_->m_onConversationReceived.size() > 0){
1633 this_->m_onConversationReceived.emit(event);
1638 LoggerE("Ignore this sms, this is mms noti.");
1641 else if((msgType >= MSG_TYPE_MMS) && (msgType <= MSG_TYPE_MMS_NOTI))
1643 if(msgType != MSG_TYPE_MMS_NOTI)
1646 msg_get_int_value(msg, MSG_MESSAGE_ID_INT, &msgId);
1647 IMessagePtr message = MessageFactory::createMessage(
1649 // msg_get_message_id(
1653 IMmsPtr mms = MessageFactory::convertToMms(message);
1654 IConversationPtr conversation(new Conversation(message->getId(), MMS));
1655 EventMessageReceivedPtr event(new EventMessageReceived());
1656 event->setMessage(message);
1657 event->setConversation(conversation);
1659 if(storageChangeType == MSG_STORAGE_CHANGE_INSERT)
1661 event->setMsg_Event_Type(EventMessageReceived::MSG_ADDED);
1663 else if(storageChangeType == MSG_STORAGE_CHANGE_UPDATE)
1665 event->setMsg_Event_Type(EventMessageReceived::MSG_UPDATED);
1667 // else if(storageChangeType == MSG_STORAGE_CHANGE_DELETE)
1669 // event->setMsg_Event_Type(EventMessageReceived::MSG_DELETED);
1672 if(this_->m_onMessageReceived.size() > 0){
1673 this_->m_onMessageReceived.emit(event);
1675 if(this_->m_onConversationReceived.size() > 0){
1676 this_->m_onConversationReceived.emit(event);
1681 LoggerE("Ignore this mms, this is mms noti.");
1687 LoggerE("release msg : " << msg);
1688 msg_release_struct(&msg);
1690 msg_release_struct(&sendOpt);
1694 Catch(WrtDeviceApis::Commons::ConversionException) {
1695 LoggerE("Couldn't convert message to sms.");
1697 Catch(WrtDeviceApis::Commons::PlatformException) {
1698 LoggerE("onMessageStorageChanged platform exception");
1704 void Messaging::onSmsReceived(MSG_HANDLE_T handle,
1709 Messaging* this_ = static_cast<Messaging*>(data);
1712 if(msg_get_message_type(msg) != MSG_TYPE_MMS_NOTI)
1714 IMessagePtr message = MessageFactory::createMessage(
1718 ISmsPtr sms = MessageFactory::convertToSms(message);
1719 IConversationPtr conversation(new Conversation(message->getId(), SMS));
1721 EventMessageReceivedPtr event(new EventMessageReceived());
1722 event->setMessage(message);
1723 event->setConversation(conversation);
1724 event->setMsg_Event_Type(EventMessageReceived::MSG_ADDED);
1725 this_->m_onMessageReceived.emit(event);
1729 LoggerE("Ignore this sms, this is mms noti.");
1732 Catch(WrtDeviceApis::Commons::ConversionException) {
1733 LoggerE("Couldn't convert message to sms.");
1738 void Messaging::onMmsReceived(MSG_HANDLE_T handle,
1743 Messaging* this_ = static_cast<Messaging*>(data);
1746 IMessagePtr message = MessageFactory::createMessage(
1750 IMmsPtr mms = MessageFactory::convertToMms(message);
1751 IConversationPtr conversation(new Conversation(message->getId(), MMS));
1752 EventMessageReceivedPtr event(new EventMessageReceived());
1753 event->setMessage(message);
1754 event->setConversation(conversation);
1755 event->setMsg_Event_Type(EventMessageReceived::MSG_ADDED);
1756 this_->m_onMessageReceived.emit(event);
1758 Catch(WrtDeviceApis::Commons::ConversionException) {
1759 LoggerE("Couldn't convert message to mms.");
1764 void Messaging::getNumberOfEmails(FolderType folder,
1770 email_mailbox_t mailbox = {};
1771 mailbox.account_id = 0; // means for all accounts
1772 mailbox.name = String::strdup(
1773 EmailConverter::toMailboxName(folder)
1776 int error = email_count_mail(&mailbox, read, unread);
1779 if (EMAIL_ERROR_NONE != error) {
1780 ThrowMsg(WrtDeviceApis::Commons::PlatformException,
1781 "Couldn't get number of emails. [" << error << "]");
1787 void Messaging::getNumberOfSms(FolderType folder,
1791 getNumberOfSmsMms(folder, read, unread, SMS);
1794 void Messaging::getNumberOfMms(FolderType folder,
1798 getNumberOfSmsMms(folder, read, unread, MMS);
1801 void Messaging::getNumberOfSmsMms(FolderType folder,
1804 MessageType msgType)
1806 MSG_LIST_S folderListView = { 0, NULL };
1813 MSG_MESSAGE_TYPE_T msgTypePlatform;
1814 if (SMS == msgType) {
1815 msgTypePlatform = MSG_TYPE_SMS;
1816 } else if (MMS == msgType) {
1817 msgTypePlatform = MSG_TYPE_MMS;
1819 LoggerE("no supported message type in this method");
1820 Throw(WrtDeviceApis::Commons::PlatformException);
1823 msg_folder_id_t msgFolderId;
1826 msgFolderId = MSG_INBOX_ID;
1829 msgFolderId = MSG_OUTBOX_ID;
1832 msgFolderId = MSG_SENTBOX_ID;
1835 msgFolderId = MSG_DRAFT_ID;
1838 LoggerE("wrong folder type");
1839 Throw(WrtDeviceApis::Commons::PlatformException);
1843 const MSG_SORT_RULE_S sort_rules = { MSG_SORT_BY_DISPLAY_TIME, true };
1844 if (msg_get_folder_view_list(MsgGetCommonHandle(), msgFolderId,
1846 &folderListView) != MSG_SUCCESS) {
1848 "msg_get_folder_view_list empty or failed, msgFolderId=" <<
1850 Throw(WrtDeviceApis::Commons::PlatformException);
1852 // go thtough all message to check type of message
1853 LoggerD("msgCount=" << (int) folderListView.nCount);
1854 for (int msg_cnt = 0; msg_cnt < folderListView.nCount; msg_cnt++) {
1855 LoggerD("msgMainType=" <<
1856 (int) msg_get_message_type(folderListView.
1859 ", searching for = " << (int) msgTypePlatform);
1860 if (msgTypePlatform ==
1861 msg_get_message_type(folderListView.msgInfo[
1863 if (msg_is_read(folderListView.msgInfo[msg_cnt]))
1871 msg_release_list_struct(&folderListView);
1873 LoggerD("readed=" << *read << ", unReaded=" << *unread);
1876 Catch(WrtDeviceApis::Commons::PlatformException) {
1877 if (folderListView.nCount) {
1878 msg_release_list_struct(&folderListView);
1884 vector<IMessagePtr> Messaging::findSms(FolderType folder, const DeviceAPI::Tizen::FilterPtr& filter)
1888 vector<IMessagePtr> retVal;
1889 msg_message_t msg = msg_new_message();
1890 MSG_LIST_S folder_list_view = {0, NULL};
1893 const MSG_SORT_RULE_S sort_rules = {MSG_SORT_BY_DISPLAY_TIME, true};
1894 msg_error_t res = MSG_ERR_UNKNOWN;
1895 const msg_folder_id_t platformFolder = convertFolderToPlatform(folder);
1896 res = msg_get_folder_view_list(MsgGetCommonHandle(), platformFolder, &sort_rules, &folder_list_view);
1898 if (MSG_SUCCESS != res) {
1899 LoggerE("msg_get_folder_view_list failed " << res);
1900 Throw(WrtDeviceApis::Commons::PlatformException);
1903 for (int i = 0; i < folder_list_view.nCount; i++) {
1904 if (MSG_TYPE_SMS == msg_get_message_type(folder_list_view.msgInfo[i])) {
1905 int l_msgId = msg_get_message_id(folder_list_view.msgInfo[i]);
1906 IMessagePtr msg = MessageFactory::createMessage(SMS, l_msgId);
1908 // if (!filter || !filter->isValid() ||
1909 // filter->compare(MessageFactory::convertToSms(msg))) {
1910 retVal.push_back(msg);
1915 msg_release_list_struct(&folder_list_view);
1916 }Catch(WrtDeviceApis::Commons::PlatformException) {
1917 LoggerE("Problem with message creation, cleaning");
1918 if (folder_list_view.nCount) {
1919 msg_release_list_struct(&folder_list_view);
1922 msg_release_message(&msg);
1931 vector<IMessagePtr> Messaging::findMms(FolderType folder,
1932 const DeviceAPI::Tizen::FilterPtr& filter)
1934 vector<IMessagePtr> retVal;
1935 msg_message_t msg = msg_new_message();
1936 MSG_LIST_S folder_list_view = {0, NULL};
1940 const MSG_SORT_RULE_S sort_rules = {MSG_SORT_BY_DISPLAY_TIME, true};
1941 msg_error_t res = MSG_ERR_UNKNOWN;
1942 const msg_folder_id_t platformFolder = convertFolderToPlatform(folder);
1943 res = msg_get_folder_view_list(
1944 MsgGetCommonHandle(), platformFolder, &sort_rules,
1947 if (MSG_SUCCESS != res) {
1948 LoggerE("msg_Get_folder_view_list failed" << res);
1949 Throw(WrtDeviceApis::Commons::PlatformException);
1952 for (int i = 0; i < folder_list_view.nCount; i++) {
1954 msg_get_message_type(folder_list_view.
1956 int l_msgId = msg_get_message_id(
1957 folder_list_view.msgInfo[i]);
1958 IMessagePtr msg = MessageFactory::createMessage(MMS, l_msgId);
1962 msg_release_list_struct(&folder_list_view);
1965 Catch(WrtDeviceApis::Commons::PlatformException) {
1966 LoggerE("Problem with message creation, cleaning");
1967 if (folder_list_view.nCount) {
1968 msg_release_list_struct(&folder_list_view);
1971 msg_release_message(&msg);
1979 void Messaging::createFolder(MessageType msgType,
1980 const string& userFolder)
1985 createMsgServiceFolder(userFolder);
1988 createEmailFolder(userFolder);
1991 LoggerE("msg not supported");
1992 Throw(WrtDeviceApis::Commons::UnknownException);
1996 void Messaging::createMsgServiceFolder(const std::string& userFolder)
1999 if (userFolder.length() > MAX_FOLDER_NAME_SIZE) {
2000 LoggerE("folder name to long");
2001 Throw(WrtDeviceApis::Commons::PlatformException);
2004 MSG_FOLDER_INFO_S folderInfo;
2006 folderInfo.folderId = 0;
2007 strncpy(folderInfo.folderName, userFolder.c_str(), userFolder.length());
2009 folderInfo.folderType = MSG_FOLDER_TYPE_USER_DEF;
2011 if (msg_add_folder(MsgGetCommonHandle(), &folderInfo) != MSG_SUCCESS) {
2012 LoggerE("msg_add_folder failed");
2013 Throw(WrtDeviceApis::Commons::PlatformException);
2018 void Messaging::createEmailFolder(const std::string& userFolder)
2022 Throw(WrtDeviceApis::Commons::UnknownException);
2025 void Messaging::deleteFolder(MessageType msgType,
2026 const string& userFolder)
2031 deleteMsgServiceFolder(userFolder);
2034 deleteEmailFolder(userFolder);
2037 LoggerE("msg not supported");
2038 Throw(WrtDeviceApis::Commons::UnknownException);
2042 void Messaging::deleteMsgServiceFolder(const string& userFolder)
2047 int platformFolderId = convertFolderToPlatform(userFolder);
2049 msg_delete_folder(MsgGetCommonHandle(), platformFolderId)) {
2050 LoggerE("msg_get_folder_list failed");
2051 Throw(WrtDeviceApis::Commons::PlatformException);
2054 Catch(WrtDeviceApis::Commons::PlatformException) {
2060 void Messaging::deleteEmailFolder(const string& userFolder)
2064 Throw(WrtDeviceApis::Commons::UnknownException);
2067 vector<string> Messaging::getFolderNames(MessageType msgType)
2072 return getFolderNamesMsgService();
2074 return getFolderNamesEmail();
2076 LoggerE("msg not supported");
2077 Throw(WrtDeviceApis::Commons::UnknownException);
2081 vector<string> Messaging::getFolderNamesMsgService()
2083 vector<string> retVal;
2084 // MSG_FOLDER_LIST_S msgFolderList = { 0, NULL }; // output data
2086 msg_struct_list_s msgFolderList = {0,};
2090 if (msg_get_folder_list(MsgGetCommonHandle(),
2091 &msgFolderList) != MSG_SUCCESS) {
2092 LoggerE("msg_get_folder_list failed");
2093 Throw(WrtDeviceApis::Commons::PlatformException);
2096 LoggerD("number of folder=" << msgFolderList.nCount);
2097 for (int i = 0; i < msgFolderList.nCount; i++) {
2098 LoggerD("folderName=" << msgFolderList.folderInfo[i].folderName);
2099 LoggerD("folderId=" << (int) msgFolderList.folderInfo[i].folderId);
2102 (int) msgFolderList.folderInfo[i].folderType);
2103 retVal.push_back(msgFolderList.folderInfo[i].folderName);
2105 (void) msg_release_folder_list(&msgFolderList);
2108 Catch(WrtDeviceApis::Commons::PlatformException) {
2109 if (msgFolderList.nCount) {
2110 (void) msg_release_folder_list(&msgFolderList);
2118 vector<string> Messaging::getFolderNamesEmail()
2120 vector<string> retVal;
2123 email_mailbox_t* mailboxes = NULL;
2125 string emailAccountName;
2126 EmailAccountInfo account = getCurrentEmailAccount();
2130 if (!email_get_mailbox_list(account.getIntId(), -1, &mailboxes,
2131 &mailboxesCount) || !mailboxes) {
2132 LoggerE("error during get mailboxes");
2134 if(mailboxes == NULL)
2136 LoggerE("error during get mailboxes");
2137 ThrowMsg(WrtDeviceApis::Commons::PlatformException,
2138 "Couldn't get mailboxes");
2140 for (int i = 0; i < mailboxesCount; i++) {
2141 retVal.push_back(mailboxes->mailbox_name);
2142 LoggerD("mailbox found, name=" << mailboxes->mailbox_name);
2145 if(mailboxes != NULL)
2147 if( EMAIL_ERROR_NONE != email_free_mailbox( &mailboxes , mailboxesCount) )
2148 LoggerD("fail to email_free_mailbox - err ");
2152 Catch(WrtDeviceApis::Commons::PlatformException) {
2153 // nothing to clean, re-throw exception
2160 vector<IMessagePtr> Messaging::findEmail(const std::string &folder,
2161 const DeviceAPI::Tizen::FilterPtr& filter)
2163 vector<IMessagePtr> retVal;
2165 EmailAccountInfo account = getCurrentEmailAccount();
2166 if (account.getId().empty()) {
2167 LoggerW("No valid email accounts. Skipping");
2171 int accountId = account.getIntId();
2173 // number of found emails
2179 email_mail_list_item_t* results = NULL;
2180 int err = email_get_mail_list(accountId,
2182 EMAIL_LIST_TYPE_NORMAL,
2185 EMAIL_SORT_DATETIME_HIGH,
2188 DPL::ScopedFree<email_mail_list_item_t> autoFree(results);
2190 if (EMAIL_ERROR_MAIL_NOT_FOUND == err || results == NULL) {
2191 LoggerW("No emails found in mailbox: " << folder);
2193 } else if (EMAIL_ERROR_NONE != err) {
2195 "Unable to get mail list for mailbox: " << folder <<
2196 ", Error: " << err);
2197 Throw(WrtDeviceApis::Commons::PlatformException);
2201 for (int i = 0; i < count; ++i) {
2202 IMessagePtr msg = MessageFactory::createMessage(EMAIL, results[i].mail_id);
2206 // || filter->compare(MessageFactory::convertToEmail(msg)) //TODO implemnet compare in filter
2208 retVal.push_back(msg);
2212 startIndex += count;
2214 while (count >= MESSAGE_FIND_LIMIT);
2219 vector<IMessagePtr> Messaging::findEmail(FolderType folder,
2220 const DeviceAPI::Tizen::FilterPtr& filter)
2222 vector<IMessagePtr> result;
2224 EmailAccountInfo account = getCurrentEmailAccount();
2225 if (account.getId().empty()) {
2226 LoggerW("No valid email accounts.");
2232 name = EmailConverter::toMailboxName(folder);
2234 catch (const WrtDeviceApis::Commons::PlatformException& ex) {
2235 LoggerW(ex.DumpToString());
2239 int accountId = account.getIntId();
2243 email_mail_list_item_t* messages = NULL;
2244 int error = email_get_mail_list(accountId,
2246 EMAIL_LIST_TYPE_NORMAL,
2249 EMAIL_SORT_DATETIME_HIGH,
2252 DPL::ScopedFree<email_mail_list_item_t> freeGuard(messages);
2253 if ((EMAIL_ERROR_MAIL_NOT_FOUND == error) || (NULL == messages)) {
2254 LoggerW("No emails found in mailbox: " << name);
2256 } else if (EMAIL_ERROR_NONE != error) {
2257 ThrowMsg(WrtDeviceApis::Commons::PlatformException,
2258 "Couldn't get mail list from mailbox: " << name <<
2259 ". [" << error << "]");
2262 for (int i = 0; i < count; ++i) {
2264 MessageFactory::createMessage(EMAIL, messages[i].mail_id);
2266 // ||filter->compare(MessageFactory::convertToEmail(msg)) //TODO implement compare in filter
2268 result.push_back(msg);
2272 startIndex += count;
2274 while (count >= MESSAGE_FIND_LIMIT);
2279 int Messaging::getConversationId(const int& msgId, const MessageType& msgtype)
2287 int index = 0, count = 0;
2288 // char *mailBox = NULL;
2289 email_mail_list_item_t *mailList = NULL;
2290 email_mail_data_t* result = NULL;
2292 LoggerD("Current Account " << m_currentEmailAccountId);
2297 if (EMAIL_ERROR_NONE != email_get_mail_data(msgId, &result)) {
2298 ThrowMsg(WrtDeviceApis::Commons::PlatformException,
2299 "Couldn't get conversatino Id " << msgId );
2302 if (email_get_mail_list(m_currentEmailAccountId, result->mailbox_id, EMAIL_LIST_TYPE_NORMAL, 0, MESSAGE_FIND_LIMIT,
2303 EMAIL_SORT_DATETIME_HIGH, &mailList, &count) != EMAIL_ERROR_NONE)
2305 ThrowMsg(WrtDeviceApis::Commons::PlatformException, "get email list fail" );
2308 email_free_mail_data(&result,1);
2310 for (index = 0; index < count; index++)
2312 if (mailList[index].mail_id == (int)msgId)
2314 return mailList[index].thread_id;
2317 ThrowMsg(WrtDeviceApis::Commons::PlatformException, "can not find msg" );
2319 catch (const WrtDeviceApis::Commons::Exception& ex)
2323 email_free_mail_data(&result,1);
2324 LoggerE("Exception: " << ex.GetMessage());
2327 return MSG_ERR_INVALID_MSG_TYPE;
2333 msg_struct_t msg = msg_create_struct(MSG_STRUCT_MESSAGE_INFO);
2334 msg_struct_t sendOpt = msg_create_struct(MSG_STRUCT_SENDOPT);
2335 msg_handle_t handle = MsgGetCommonHandle();
2336 msg_error_t err = MSG_SUCCESS;
2338 err = msg_get_message(handle, msgId, msg, sendOpt);
2340 if( err < MSG_SUCCESS )
2342 ThrowMsg(WrtDeviceApis::Commons::PlatformException,
2343 "can not find msg id(" << msgId << ")");
2347 err = msg_get_int_value(msg, MSG_MESSAGE_THREAD_ID_INT, &threadId);
2351 if( err < MSG_SUCCESS )
2353 ThrowMsg(WrtDeviceApis::Commons::PlatformException,
2354 "can not find thread with msg id(" << msgId << ")");
2356 msg_release_struct(&msg);
2357 msg_release_struct(&sendOpt);
2363 ThrowMsg(WrtDeviceApis::Commons::PlatformException,
2364 "Wrong Type (" << msgId << ")");
2365 return MSG_ERR_INVALID_MSG_TYPE;
2370 std::vector<IConversationPtr> Messaging::queryConversations(const DeviceAPI::Tizen::SortModePtr& sortMode,
2371 const DeviceAPI::Tizen::FilterPtr& filter, long limit, long offset)
2375 std::vector<IConversationPtr> result;
2376 std::string filterSql;
2377 std::string orderLimitSql ="";
2379 ConversationQueryGeneratorPtr queryGenerator(new ConversationQueryGenerator(sortMode, limit, offset));
2380 IFilterVisitorPtr filterVisitor = DPL::StaticPointerCast<IFilterVisitor>(queryGenerator);
2381 filter->travel(filterVisitor, 0);
2383 // LOGD("filterSql:[%s]", filterSql.c_str());
2385 int conversationType = queryGenerator->getMessageType();
2386 switch(conversationType){
2388 LoggerD("type is EMAIL:[" << conversationType <<"]");
2389 queryGenerator->reset(MessageQueryGenerator::MODE_EMAIL);
2390 filter->travel(filterVisitor, 0);
2391 filterSql = queryGenerator->getQuery();
2392 result = queryEmailConversation(filterSql);
2397 LoggerD("type is SMS:[" << conversationType <<"]");
2398 queryGenerator->reset(MessageQueryGenerator::MODE_SMS_MMS);
2399 IFilterVisitorPtr filterVisitor = DPL::StaticPointerCast<IFilterVisitor>(queryGenerator);
2400 filter->travel(filterVisitor, 0);
2401 filterSql = queryGenerator->getQuery();
2402 // LOGD("filterSql:[%s]", filterSql.c_str());
2403 // LOGD("orderLimitSql:[%s]", orderLimitSql.c_str());
2404 result = querySmsMmsConversation(filterSql, orderLimitSql);
2409 LoggerD("type is MMS:[" << conversationType <<"]");
2410 queryGenerator->reset(MessageQueryGenerator::MODE_SMS_MMS);
2411 IFilterVisitorPtr filterVisitor = DPL::StaticPointerCast<IFilterVisitor>(queryGenerator);
2412 filter->travel(filterVisitor, 0);
2413 filterSql = queryGenerator->getQuery();
2414 // LOGD("filterSql:[%s]", filterSql.c_str());
2415 // LOGD("orderLimitSql:[%s]", orderLimitSql.c_str());
2416 result = querySmsMmsConversation(filterSql, orderLimitSql);
2421 LoggerE("[ERROR] >>> invlid type:[" << conversationType <<"]");
2429 std::vector<IConversationPtr> Messaging::queryConversations(const DeviceAPI::Tizen::FilterPtr& filter,
2430 const DeviceAPI::Tizen::SortModePtr& sortMode, int type, long limit, long offset)
2434 std::vector<IConversationPtr> result;
2435 std::string filterSql;
2436 std::string orderLimitSql ="";
2438 ConversationQueryGeneratorPtr queryGenerator(new ConversationQueryGenerator(sortMode, limit, offset, type));
2439 IFilterVisitorPtr filterVisitor = DPL::StaticPointerCast<IFilterVisitor>(queryGenerator);
2440 filter->travel(filterVisitor, 0);
2442 // LOGD("filterSql:[%s]", filterSql.c_str());
2443 int conversationType = queryGenerator->getMessageType();
2444 if(conversationType != -1)
2446 if(conversationType != type)
2448 LoggerD("filter conversationType and service msg type is diff");
2449 ThrowMsg(WrtDeviceApis::Commons::InvalidArgumentException, "invalid Fiilter Type");
2454 LoggerD("type is EMAIL:[" << conversationType <<"]");
2455 queryGenerator->reset(MessageQueryGenerator::MODE_EMAIL);
2456 filter->travel(filterVisitor, 0);
2457 filterSql = queryGenerator->getQuery();
2458 // LOGD("filterSql:[%s]", filterSql.c_str());
2459 result = queryEmailConversation(filterSql);
2464 LoggerD("type is SMS:[" << conversationType <<"]");
2465 queryGenerator->reset(MessageQueryGenerator::MODE_SMS);
2466 IFilterVisitorPtr filterVisitor = DPL::StaticPointerCast<IFilterVisitor>(queryGenerator);
2467 filter->travel(filterVisitor, 0);
2468 filterSql = queryGenerator->getQuery();
2469 orderLimitSql = queryGenerator->getOrderLimit();
2470 // LOGD("filterSql:[%s]", filterSql.c_str());
2471 // LOGD("orderLimitSql:[%s]", orderLimitSql.c_str());
2472 result = querySmsMmsConversation(filterSql, orderLimitSql);
2477 LoggerD("type is MMS:[" << conversationType <<"]");
2478 queryGenerator->reset(MessageQueryGenerator::MODE_MMS);
2479 IFilterVisitorPtr filterVisitor = DPL::StaticPointerCast<IFilterVisitor>(queryGenerator);
2480 filter->travel(filterVisitor, 0);
2481 filterSql = queryGenerator->getQuery();
2482 orderLimitSql = queryGenerator->getOrderLimit();
2483 // LOGD("filterSql:[%s]", filterSql.c_str());
2484 // LOGD("orderLimitSql:[%s]", orderLimitSql.c_str());
2485 result = querySmsMmsConversation(filterSql, orderLimitSql);
2490 LoggerE("[ERROR] >>> invlid type:[" << conversationType <<"]");
2498 bool Messaging::deleteConversations(const DeviceAPI::Tizen::SortModePtr& sortMode, const DeviceAPI::Tizen::FilterPtr& filter)
2502 std::vector<IConversationPtr> conversationsToDelete = queryConversations(sortMode, filter);
2503 return deleteConversations(conversationsToDelete);
2506 bool Messaging::deleteConversations(const std::vector<IConversationPtr>& conversations)
2510 if (conversations.size() == 0)
2513 if (conversations[0]->getType() == EMAIL)
2515 LoggerD("Enter-Email");
2518 for (std::size_t i = 0; i < conversations.size(); ++i)
2520 threadId = conversations[i]->getConvId();
2522 if (email_delete_thread(threadId, false) != EMAIL_ERROR_NONE)
2530 LoggerD("Enter-Msg");
2531 msg_thread_id_t threadId = 0;
2532 msg_handle_t handle = MsgGetCommonHandle();
2534 for (std::size_t i = 0; i < conversations.size(); ++i)
2536 threadId = conversations[i]->getConvId();
2537 if (msg_delete_thread_message_list(handle, threadId, FALSE) != MSG_SUCCESS)
2546 std::vector<IMessageFolderPtr> Messaging::queryFolders(const DeviceAPI::Tizen::FilterPtr& filter)
2550 email_mailbox_t* mailboxes = NULL;
2551 email_mailbox_t* mailboxes_org = NULL;
2552 email_mailbox_t m_mailboxes;
2556 std::vector<IMessageFolderPtr> result;
2557 std::string folderName;
2560 EmailAccountInfo account = getCurrentEmailAccount();
2562 if (account.getId().empty()) {
2563 LoggerW("No valid email accounts. Skipping");
2567 const vector<EmailAccountInfo> accounts = getEmailAccounts();
2569 FolderQueryGeneratorPtr queryGenerator(new FolderQueryGenerator());
2571 IFilterVisitorPtr filterVisitor = DPL::StaticPointerCast<IFilterVisitor>(queryGenerator);
2572 queryGenerator->reset();
2573 filter->travel(filterVisitor, 0);
2574 accountId = queryGenerator->getAccountId();
2578 LoggerW("No valid email accounts. accountId : 0");
2582 if(queryGenerator->isFolderPathExist() == 1){
2584 folderName = queryGenerator->getFolderPath();
2586 if(email_get_mailbox_by_name(accountId, folderName.c_str(), &mailboxes) != 1)
2588 LoggerE("error during get mailboxes");
2592 m_mailboxes = *mailboxes;
2593 IMessageFolderPtr folderPtr(new MessageFolder(m_mailboxes));
2594 result.push_back(folderPtr);
2598 if (!email_get_mailbox_list(accountId, -1, &mailboxes, &mailboxesCount) || !mailboxes)
2600 LoggerE("error during get mailboxes");
2604 mailboxes_org = mailboxes;
2606 if (mailboxesCount <= 0)
2608 LoggerD("Empty...");
2612 LoggerD("found mailboxs : " << mailboxesCount);
2613 for (int i = 0; i < mailboxesCount; i++)
2616 m_mailboxes = *mailboxes;
2617 IMessageFolderPtr folderPtr(new MessageFolder(m_mailboxes));
2618 result.push_back(folderPtr);
2623 mailboxes = mailboxes_org;
2625 if(mailboxes != NULL)
2627 error = email_free_mailbox(&mailboxes,mailboxesCount);
2628 LoggerE("email_free_mailbox : " << error);