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>
22 #include <Commons/Exception.h>
23 #include <Commons/StringUtils.h>
24 #include <dpl/scoped_free.h>
25 #include "Messaging.h"
28 #include "BinarySms.h"
30 #include "EmailConverter.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"
41 #include <msg_storage.h>
43 #include <msg_transport.h>
46 #include <Commons/ThreadPool.h>
47 #include "Conversation.h"
48 #include "MessageFolder.h"
49 #include <dpl/singleton_safe_impl.h>
52 IMPLEMENT_SAFE_SINGLETON(DeviceAPI::Messaging::MsgServiceHandle)
53 IMPLEMENT_SAFE_SINGLETON(DeviceAPI::Messaging::WidgetFilePath)
56 #define LOG_ENTER LoggerD("---> ENTER");
57 #define LOG_EXIT LoggerD("---> EXIT");
61 using namespace DeviceAPI::Tizen;
62 using namespace WrtDeviceApis::Commons;
65 const char* DBUS_INTERFACE_EMAIL_RECEIVED = "User.Email.StorageChange";
66 const char* DBUS_FILTER_EMAIL_RECEIVED =
67 "type='signal',interface='User.Email.StorageChange'";
69 const int MESSAGE_FIND_LIMIT = 100;
75 int Messaging::m_currentEmailAccountId = 0;
76 DPL::Atomic Messaging::m_objCounter;
78 Messaging& Messaging::getInstance()
80 static Messaging instance;
84 Messaging::Messaging() :
85 m_onMessageReceivedHandleMgr(NULL),
86 m_dbusConnection(new DBus::Connection()),
87 m_dbusWorkerThread(new DPL::Thread())
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]);
97 LoggerE("no default email account set");
101 Catch(WrtDeviceApis::Commons::PlatformException) {
102 LoggerE("No email accounts available");
105 Catch(WrtDeviceApis::Commons::InvalidArgumentException) {
106 LoggerE("No email accounts available");
107 //current email not configured, skipped
110 Catch(WrtDeviceApis::Commons::UnknownException) {
111 LoggerE("unknown error");
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);
120 LoggerI("email_service_begin() executed without error");
125 m_dbusWorkerThread->Run();
126 m_dbusConnection->setWorkerThread(m_dbusWorkerThread);
127 m_dbusConnection->addFilter(DBUS_FILTER_EMAIL_RECEIVED);
128 m_dbusConnection->AddListener(this);
131 Messaging::~Messaging()
133 // Endservice for email management
134 m_dbusConnection->RemoveListener(this);
135 // m_dbusConnection->setWorkerThread(NULL);
136 m_dbusWorkerThread->Quit();
137 delete m_dbusWorkerThread;
139 if (!--m_objCounter) {
140 int error = email_service_end();
141 if (EMAIL_ERROR_NONE != error) {
142 LoggerE("email_service_end() returned error " << error);
144 LoggerD("email_service_end() executed without error");
150 void Messaging::getNumberOfMessages(MessageType msgType,
155 if (NULL == readed ||
157 LoggerE("output pointers are NULL");
158 Throw(WrtDeviceApis::Commons::InvalidArgumentException);
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);
169 LoggerE("wrong message type");
170 Throw(WrtDeviceApis::Commons::PlatformException);
174 vector<IMessagePtr> Messaging::findMessages(const vector<MessageType>& msgTypes,
175 const string &folder,
176 const DeviceAPI::Tizen::FilterPtr& filter)
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;
189 FolderType folderEnum = Sms::toFolder(folder);
190 result = findSms(folderEnum, filter);
195 FolderType folderEnum = Mms::toFolder(folder);
196 result = findMms(folderEnum, filter);
201 result = findEmail(folder, filter);
205 LoggerE("message type unknown");
206 Throw(WrtDeviceApis::Commons::PlatformException);
208 LoggerD("Found: " << result.size());
209 copy(result.begin(), result.end(), biit);
215 std::string Messaging::generateFilterSql(const DeviceAPI::Tizen::FilterPtr& filter){
217 std::string filterSql;
219 MessageQueryGeneratorPtr queryGenerator(new MessageQueryGenerator());
220 IFilterVisitorPtr filterVisitor = DPL::StaticPointerCast<IFilterVisitor>(queryGenerator);
221 filter->travel(filterVisitor, 0);
222 filterSql = queryGenerator->getQuery();
224 // LOGD(">>> filterSql:[%s]", filterSql.c_str());
229 vector<IMessagePtr> Messaging::findMessages(const vector<MessageType>& msgTypes, FolderType folder,
230 const DeviceAPI::Tizen::FilterPtr& filter)
233 vector<IMessagePtr> retVal;
234 back_insert_iterator< vector<IMessagePtr> > biit(retVal);
236 std::string filterSql = generateFilterSql(filter);
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;
248 findFnPtr = &Messaging::findSms;
253 findFnPtr = &Messaging::findMms;
258 findFnPtr = &Messaging::findEmail;
262 LoggerE("message type unknown");
263 Throw(WrtDeviceApis::Commons::PlatformException);
266 vector<IMessagePtr> result = (this->*findFnPtr)(folder, filter);
267 LoggerD("Found: " << result.size());
268 copy(result.begin(), result.end(), biit);
274 void Messaging::printErrorMessage(int errorCode){
276 case EMAIL_ERROR_MAIL_NOT_FOUND:{
277 LoggerD("EMAIL_ERROR_MAIL_NOT_FOUND");
280 case EMAIL_ERROR_DB_FAILURE:{
281 LoggerD("EMAIL_ERROR_DB_FAILURE");
285 LoggerD("other error message:" << errorCode);
290 vector<IMessagePtr> Messaging::createVectorFromeMessageList(const msg_struct_list_s &message_list){
291 // vector<IMessagePtr> Messaging::createVectorFromeMessageList(const msg_struct_list_s message_list){
294 vector<IMessagePtr> retVal;
296 set<int> alreadyCreated;
298 MessageType webApiMsgType;
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)
305 ThrowMsg(WrtDeviceApis::Commons::UnknownException, "get message type fail");
307 LoggerD("Message type : " << tempInt);
319 LoggerE("[ERROR]invalid message type:" << tempInt);
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)
329 ThrowMsg(WrtDeviceApis::Commons::UnknownException, "get message id fail");
331 if(alreadyCreated.find(tempInt) == alreadyCreated.end())
334 msg = MessageFactory::createMessage(webApiMsgType, tempInt);
335 alreadyCreated.insert(tempInt);
336 retVal.push_back(msg);
344 std::vector<IConversationPtr> Messaging::createVectorFromeThreadViewList(const msg_struct_list_s& threadViewList){
345 vector<IConversationPtr> recVec;
347 if (threadViewList.nCount <= 0) {
351 for (int i = 0; i < threadViewList.nCount; i++)
355 IConversationPtr convPtr(new Conversation(threadViewList.msg_struct_info[i]));
356 recVec.push_back(convPtr);
358 catch (const WrtDeviceApis::Commons::Exception& ex)
360 LoggerD("make conversation error for element " << i);
369 vector<IMessagePtr> Messaging::querySmsMmsMessages(const std::string& queryString){
370 // LOGD("<<< queryString:[%s]" ,queryString.c_str());
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;
379 msg_error_t res = MSG_ERR_UNKNOWN;
381 reader.MsgStoConnectDB();
382 res = reader.queryMessage(queryString, tempString, &message_list);
384 if (MSG_SUCCESS != res) {
385 LoggerE("msg_get_folder_view_list failed " << res);
386 Throw(WrtDeviceApis::Commons::PlatformException);
388 reader.MsgStoDisconnectDB();
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);
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());
407 vector<IMessagePtr> retVal;
408 // MSG_LIST_S message_list = {0, NULL};
409 msg_struct_list_s message_list = {0,};
410 MessageStorageReader reader;
413 msg_error_t res = MSG_ERR_UNKNOWN;
415 reader.MsgStoConnectDB();
416 res = reader.queryMessage(queryString, orderLimitString, &message_list);
418 if (MSG_SUCCESS != res) {
419 LoggerE("msg_get_folder_view_list failed " << res);
420 Throw(WrtDeviceApis::Commons::PlatformException);
422 reader.MsgStoDisconnectDB();
424 retVal = createVectorFromeMessageList(message_list);
425 LoggerD("<<< message_list.nCount:[" << message_list.nCount <<"]");
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);
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());
444 std::vector<IConversationPtr> recVec;
445 // MSG_THREAD_VIEW_LIST_S threadViewList;
446 msg_struct_list_s threadViewList = {0,};
448 msg_error_t res = MSG_ERR_UNKNOWN;
450 MessageStorageReader reader;
451 reader.MsgStoConnectDB();
452 res = reader.queryConversation(sqlWhereClause, orderLimitString, &threadViewList);
454 if (MSG_SUCCESS != res) {
455 LoggerE("queryConversation failed:" << res);
456 Throw(WrtDeviceApis::Commons::PlatformException);
458 reader.MsgStoDisconnectDB();
460 recVec = createVectorFromeThreadViewList(threadViewList);
462 reader.msg_release_list_struct_private(&threadViewList);
468 vector<IConversationPtr> Messaging::queryEmailConversation(const std::string& sqlWhereClause){
469 // LOGD("sqlWhereClause:[%s]",sqlWhereClause.c_str());
471 std::vector<IConversationPtr> emailResultVector;
472 email_mail_list_item_t* mailList = NULL;
473 int mailListCount = 0;
475 errCode = email_query_mail_list(const_cast<char*>(sqlWhereClause.c_str()), &mailList, &mailListCount);
477 if(errCode != EMAIL_ERROR_NONE){
478 LoggerE("[ERROR]email_query_mail_list failed:" << errCode);
479 printErrorMessage(errCode);
481 LoggerD("message found mailListCount:" << mailListCount);
482 std::set<int> checkUnique;
484 for(int i=0; i<mailListCount; i++){
485 if(mailList[i].mail_id != mailList[i].thread_id)
487 LoggerD("skip mail");
488 LoggerD("mailList[i].mail_id: " << mailList[i].mail_id);
489 LoggerD("mailList[i].thread_id:" << mailList[i].thread_id);
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));
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<< "]");
505 if (convPtr->getResult() == true)
507 emailResultVector.push_back(convPtr);
513 if (mailList != NULL){
518 return emailResultVector;
521 vector<IMessagePtr> Messaging::queryEmailMessage(const std::string& sqlWhereClause){
522 // LOGD("sqlWhereClause:[%s]", sqlWhereClause.c_str());
524 vector<IMessagePtr> emailResultVector;
526 email_mail_list_item_t* mailList = NULL;
527 int mailListCount = 0;
529 errCode = email_query_mail_list(const_cast<char*>(sqlWhereClause.c_str()), &mailList, &mailListCount);
531 if(errCode != EMAIL_ERROR_NONE){
532 LoggerE("[ERROR]email_query_mail_list failed:" << errCode);
533 printErrorMessage(errCode);
535 LoggerD("message found mailListCount:" << mailListCount);
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);
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<< "]");
551 emailResultVector.push_back(msg);
555 if (mailList != NULL) {
560 return emailResultVector;
563 vector<IMessagePtr> Messaging::findMessages(const DeviceAPI::Tizen::FilterPtr& filter){
566 vector<IMessagePtr> retVal;
567 std::string filterSql;
569 MessageQueryGeneratorPtr queryGenerator(new MessageQueryGenerator());
571 IFilterVisitorPtr filterVisitor = DPL::StaticPointerCast<IFilterVisitor>(queryGenerator);
572 filter->travel(filterVisitor, 0);
573 filterSql = queryGenerator->getQuery();
574 // LOGD("filterSql:[%s]", filterSql.c_str());
576 int messageType = queryGenerator->getMessageType();
579 LoggerD("message type is EMAIL:[" << messageType <<"]");
580 retVal = queryEmailMessage(filterSql);
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);
594 LoggerE("[ERROR] >>> invlid message type:[" << messageType <<"]");
604 vector<IMessagePtr> Messaging::findMessages(const DeviceAPI::Tizen::FilterPtr& filter, const DeviceAPI::Tizen::SortModePtr& sortMode, const long limit, const long offset)
608 vector<IMessagePtr> retVal;
609 std::string filterSql;
611 MessageQueryGeneratorPtr queryGenerator(new MessageQueryGenerator(sortMode, limit, offset));
613 IFilterVisitorPtr filterVisitor = DPL::StaticPointerCast<IFilterVisitor>(queryGenerator);
614 filter->travel(filterVisitor, 0);
615 filterSql = queryGenerator->getQuery();
616 // LOGD("filterSql:[%s]", filterSql.c_str());
618 int messageType = queryGenerator->getMessageType();
621 LoggerD("message type is EMAIL:[" << messageType <<"]");
622 retVal = queryEmailMessage(filterSql);
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);
636 MsgLoggerE("[ERROR] >>> invlid message type:[" << messageType <<"]");
644 vector<IMessagePtr> Messaging::findMessages(const DeviceAPI::Tizen::FilterPtr& filter, const DeviceAPI::Tizen::SortModePtr& sortMode, const long limit, const long offset, const int type)
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=";
655 MessageQueryGeneratorPtr queryGenerator(new MessageQueryGenerator(sortMode, limit, offset, type));
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());
665 int messageType = queryGenerator->getMessageType();
666 if(messageType != -1)
668 if(messageType != type)
670 LoggerD("filter messageType and service msg type is diff");
671 ThrowMsg(WrtDeviceApis::Commons::InvalidArgumentException, "invalid Fiilter Type");
676 LoggerD("message type is EMAIL:[" << messageType <<"]");
677 emailFilterSql = filterSql + orderLimitSql;
678 // LOGD("filterSql:[%s]", emailFilterSql.c_str());
679 retVal = queryEmailMessage(emailFilterSql);
683 LoggerD("message type is SMS :[" << messageType <<"]");
684 typeString.append("1");
685 typeAndString.append("1");
686 if(filterSql.length() == 0)
688 filterSql.append(typeString);
689 // LOGD("filterSql:[%s]", filterSql.c_str());
693 filterSql.append(typeAndString);
694 // LOGD("filterSql:[%s]", filterSql.c_str());
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());
702 LoggerD("message type is MMS:[" << messageType <<"]");
703 typeString.append("2");
704 typeAndString.append("2");
705 if(filterSql.length() == 0)
707 filterSql.append(typeString);
708 // LOGD("filterSql:[%s]", filterSql.c_str());
712 filterSql.append(typeAndString);
713 // LOGD("filterSql:[%s]", filterSql.c_str());
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());
722 MsgLoggerE("[ERROR] >>> invlid message type:[" << messageType <<"]");
731 vector<string> Messaging::getMessageIds(MessageType msgType,
736 return getSmsIds(folder);
738 return getMmsIds(folder);
740 return getEmailIds(folder);
742 LoggerE("not supported message type");
743 Throw(WrtDeviceApis::Commons::InvalidArgumentException);
747 vector<string> Messaging::getSmsIds(FolderType folder)
749 vector<string> retVal;
750 msg_message_t msg = msg_new_message();
751 MSG_LIST_S folder_list_view = { 0, NULL };
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,
762 if (MSG_SUCCESS != res) {
763 LoggerE("msg_Get_folder_view_list failed" << res);
764 Throw(WrtDeviceApis::Commons::PlatformException);
767 for (int i = 0; i < folder_list_view.nCount; i++) {
769 msg_get_message_type(folder_list_view.
771 int l_msgId = msg_get_message_id(
772 folder_list_view.msgInfo[i]);
773 ostringstream stream;
775 retVal.push_back(stream.str());
779 msg_release_list_struct(&folder_list_view);
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);
788 msg_release_message(&msg);
796 vector<string> Messaging::getMmsIds(FolderType folder)
798 vector<string> retVal;
799 msg_message_t msg = msg_new_message();
800 MSG_LIST_S folder_list_view = { 0, NULL };
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,
811 if (MSG_SUCCESS != res) {
812 LoggerE("msg_Get_folder_view_list failed" << res);
813 Throw(WrtDeviceApis::Commons::PlatformException);
816 for (int i = 0; i < folder_list_view.nCount; i++) {
818 msg_get_message_type(folder_list_view.
820 int l_msgId = msg_get_message_id(
821 folder_list_view.msgInfo[i]);
822 ostringstream stream;
824 retVal.push_back(stream.str());
828 msg_release_list_struct(&folder_list_view);
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);
837 msg_release_message(&msg);
845 vector<string> Messaging::getEmailIds(FolderType folder)
847 vector<string> retVal;
851 Throw(WrtDeviceApis::Commons::UnknownException);
856 vector<EmailAccountInfo> Messaging::getEmailAccounts() const
859 email_account_t* accounts = NULL;
862 if (!email_get_account_list(&accounts, &count)) {
863 ThrowMsg(WrtDeviceApis::Commons::PlatformException, "Couldn't get e-mail accounts.");
866 LoggerE( "count : " << count);
869 ThrowMsg(WrtDeviceApis::Commons::PlatformException, "No e-mail account found.");
872 vector<EmailAccountInfo> result;
873 for (int i = 0; i < count; ++i)
875 if(accounts[i].user_display_name != NULL)
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);
885 LoggerE("normal case");
886 std::string Unknown = "UNKNOWN";
887 EmailAccountInfo account(accounts[i].account_id,
889 accounts[i].user_email_address);
890 result.push_back(account);
894 if (accounts != NULL) {
895 email_free_account(&accounts, count);
900 Catch(WrtDeviceApis::Commons::PlatformException) {
901 if (accounts != NULL) {
902 email_free_account(&accounts, count);
904 LoggerE("PlatformException");
905 ThrowMsg(WrtDeviceApis::Commons::PlatformException, "No e-mail account found.");
907 Catch(WrtDeviceApis::Commons::UnknownException) {
908 if (accounts != NULL) {
909 email_free_account(&accounts, count);
911 LoggerE("UnknownException");
912 ThrowMsg(WrtDeviceApis::Commons::PlatformException, "Couldn't convert e-mail account id");
916 int Messaging::getEmailAccountId(const std::string& account)
919 string tmpAccount = account;
920 email_account_t *pAccountArray = NULL;
925 if (account.empty()) {
926 tmpAccount = getCurrentEmailAccount().getAddress();
927 if (tmpAccount.empty()) {
929 "current email account is not set, possible that no account created");
930 Throw(WrtDeviceApis::Commons::PlatformException);
934 if (!email_get_account_list(&pAccountArray, &iCount)) {
935 LoggerE("email_get_account_list error");
936 Throw(WrtDeviceApis::Commons::PlatformException);
940 LoggerE("no email account exist");
941 Throw(WrtDeviceApis::Commons::PlatformException);
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;
953 if (0 == m_currentEmailAccountId) {
954 LoggerE("wrong email account ID");
955 Throw(WrtDeviceApis::Commons::PlatformException);
958 if (pAccountArray != NULL) {
959 LoggerD("free account, ptr=" << pAccountArray);
960 email_free_account(&pAccountArray, iCount);
964 LoggerE("no email account created");
965 Throw(WrtDeviceApis::Commons::PlatformException);
969 Catch(WrtDeviceApis::Commons::PlatformException) {
970 LoggerE("exception catch, platform exception");
971 if (pAccountArray != NULL) {
972 email_free_account(&pAccountArray, iCount);
980 void Messaging::fetchEmailHeaders()
983 email_mailbox_t *mailbox = NULL;
986 mailbox = static_cast<email_mailbox_t*>(calloc(sizeof (email_mailbox_t), 1));
988 LoggerE("calloc failed");
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");
997 error = email_free_mailbox(&mailbox, 1);
998 LoggerE("email_free_mailbox : " << error);
1002 int Messaging::convertFolderToPlatform(const FolderType folder)
1004 msg_folder_id_t platfromFolderId;
1007 platfromFolderId = MSG_INBOX_ID;
1010 platfromFolderId = MSG_DRAFT_ID;
1013 platfromFolderId = MSG_OUTBOX_ID;
1016 platfromFolderId = MSG_SENTBOX_ID;
1019 // intentionally not break in platform is no spambox
1021 LoggerE("Invalid folder: " << folder);
1022 Throw(WrtDeviceApis::Commons::PlatformException);
1025 return platfromFolderId;
1028 int Messaging::convertFolderToPlatform(const std::string &folder)
1030 // MSG_FOLDER_LIST_S folderList = { 0, NULL };
1037 msg_get_folder_list(MsgGetCommonHandle(), &folderList)) {
1038 LoggerE("msg_get_folder_list error");
1039 Throw(WrtDeviceApis::Commons::PlatformException);
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;
1051 Catch(WrtDeviceApis::Commons::PlatformException) {
1052 if (folderList.nCount) {
1053 msg_release_folder_list(&folderList);
1057 if (folderList.nCount) {
1058 msg_release_folder_list(&folderList);
1064 void Messaging::addOnMessageReceived(
1065 const EmitterMessageReceivedPtr& emitter, const DeviceAPI::Tizen::FilterPtr& filter, int funtionIndex)
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);
1080 Catch(WrtDeviceApis::Commons::PlatformException) {
1085 LoggerD("filter is NULL");
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());
1096 err = msg_reg_storage_change_callback(
1097 m_onMessageReceivedHandleMgr->getHandle(),
1098 onMessageStorageChanged,
1101 Catch(WrtDeviceApis::Commons::PlatformException){
1102 LoggerD("addOnMessageReceived failed");
1103 Throw(WrtDeviceApis::Commons::PlatformException);
1106 if (err != MSG_SUCCESS) {
1107 LoggerE("Couldn't register on MMS received callback, err=" << err);
1110 m_dbusConnection->open(DBUS_BUS_SYSTEM);
1114 void Messaging::addOnMessageReceived(
1115 const EmitterConversationReceivedPtr& emitter, const DeviceAPI::Tizen::FilterPtr& filter, int funtionIndex)
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);
1130 Catch(WrtDeviceApis::Commons::PlatformException) {
1135 LoggerD("filter is NULL");
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());
1146 err = msg_reg_storage_change_callback(
1147 m_onMessageReceivedHandleMgr->getHandle(),
1148 onMessageStorageChanged,
1151 Catch(WrtDeviceApis::Commons::PlatformException){
1152 LoggerD("addOnMessageReceived failed");
1153 Throw(WrtDeviceApis::Commons::PlatformException);
1156 if (err != MSG_SUCCESS) {
1157 LoggerE("Couldn't register on MMS received callback, err=" << err);
1160 m_dbusConnection->open(DBUS_BUS_SYSTEM);
1164 void Messaging::addOnMessageReceived(
1165 const EmitterFolderReceivedPtr& emitter, const DeviceAPI::Tizen::FilterPtr& filter, int funtionIndex)
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);
1180 Catch(WrtDeviceApis::Commons::PlatformException) {
1185 LoggerD("filter is NULL");
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());
1198 err = msg_reg_storage_change_callback(
1199 m_onMessageReceivedHandleMgr->getHandle(),
1200 onMessageStorageChanged,
1203 Catch(WrtDeviceApis::Commons::PlatformException){
1204 LoggerD("addOnMessageReceived failed");
1205 Throw(WrtDeviceApis::Commons::PlatformException);
1208 if (err != MSG_SUCCESS) {
1209 LoggerE("Couldn't register on MMS received callback, err=" << err);
1210 // Throw(WrtDeviceApis::Commons::UnknownException);
1213 m_dbusConnection->open(DBUS_BUS_SYSTEM);
1217 bool Messaging::validateFilter(const DeviceAPI::Tizen::FilterPtr& filter, const int funtionIndex){
1220 bool retBool = false;
1221 LoggerD("funtionIndex = " << funtionIndex);
1224 if(funtionIndex == 0)
1226 StorageChangesMessageFilterValidatorPtr validatorMsg =
1227 StorageChangesMessageFilterValidatorFactory::getStorageChangesMessageFilterValidator();
1229 FilterValidatorPtr filterValidatorMsg = DPL::StaticPointerCast<FilterValidator>(validatorMsg);
1230 retBool = filter->validate(filterValidatorMsg);
1231 }else if(funtionIndex == 1)
1233 StorageChangesConversationFilterValidatorPtr validatorConv =
1234 StorageChangesConversationFilterValidatorFactory::getStorageChangesConversationFilterValidator();
1236 FilterValidatorPtr filterValidatorConv = DPL::StaticPointerCast<FilterValidator>(validatorConv);
1237 retBool = filter->validate(filterValidatorConv);
1238 }else if(funtionIndex == 2)
1240 StorageChangesFolderFilterValidatorPtr validatorFolder =
1241 StorageChangesFolderFilterValidatorFactory::getStorageChangesFolderFilterValidator();
1243 FilterValidatorPtr filterValidatorFolder = DPL::StaticPointerCast<FilterValidator>(validatorFolder);
1244 retBool = filter->validate(filterValidatorFolder);
1247 if(retBool == false){
1248 Throw(WrtDeviceApis::Commons::InvalidArgumentException);
1251 LoggerD("filter is NULL");
1255 LoggerD(">>> retBool:" << retBool);
1261 void Messaging::removeOnMessageMsgReceived(EmitterMessageReceived::IdType id)
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();
1272 void Messaging::removeOnMessageConvReceived(EmitterConversationReceived::IdType id)
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();
1283 void Messaging::removeOnMessageFolderReceived(EmitterFolderReceived::IdType id)
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();
1294 void Messaging::OnEventReceived(const DBus::MessageEvent& event)
1297 EventMessageReceivedPtr jsEvent(new EventMessageReceived());
1298 DBus::MessagePtr message = event.GetArg0();
1304 jsEvent->setExceptionCode(WrtDeviceApis::Commons::ExceptionCodes::PlatformException);
1305 m_onMessageReceived.emit(jsEvent);
1309 if (message->getInterface() == DBUS_INTERFACE_EMAIL_RECEIVED)
1311 int account_id = 0, mail_id = 0, thread_id = 0, status = 0;
1313 email_mailbox_t m_mailboxes;
1315 DBus::Message::ReadIterator it = message->getReadIterator();
1316 for (int i = 0; it->isValid(); it->next(), ++i)
1318 if ((i == 0) && (it->getArgType() == DBUS_TYPE_INT32))
1320 status = it->getInt();
1321 LoggerI("status: " << status);
1323 else if ((i == 1) && (it->getArgType() == DBUS_TYPE_INT32))
1325 account_id = it->getInt();
1326 LoggerI("account_id: " << account_id);
1328 else if ((i == 2) && (it->getArgType() == DBUS_TYPE_INT32))
1330 mail_id = it->getInt();
1331 LoggerI("mail_id: " << mail_id);
1333 else if ((i == 3) && (it->getArgType() == DBUS_TYPE_STRING))
1335 name = it->getString();
1336 LoggerI("name: " << name);
1338 else if ((i == 4) && (it->getArgType() == DBUS_TYPE_INT32))
1340 thread_id = it->getInt();
1341 LoggerI("thread_id: " << thread_id);
1345 jsEvent->setMsg_Type(EMAIL);
1346 jsEvent->setAccount_Id(account_id);
1348 if ((mail_id > 0) && (NOTI_MAIL_ADD == status))
1349 { // TODO also RECEIVE_THREAD_ITEM?
1350 LoggerI("Email received. mail_id: " << mail_id);
1352 IMessagePtr msg = MessageFactory::createMessage(EMAIL, mail_id);
1353 IConversationPtr conversation(new Conversation(thread_id, EMAIL));
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);
1359 LoggerI("Added message is in folder: " << folder);
1361 jsEvent->setMessage(msg);
1362 jsEvent->setConversation(conversation);
1364 if(m_onMessageReceived.size() > 0){
1365 m_onMessageReceived.emit(jsEvent);
1368 if(m_onConversationReceived.size() > 0){
1369 if(mail_id != thread_id)
1371 jsEvent->setMsg_Event_Type(EventMessageReceived::MSG_UPDATED);
1373 m_onConversationReceived.emit(jsEvent);
1376 else if ((name.size() > 0) && (NOTI_MAIL_DELETE == status))
1377 { // TODO also RECEIVE_THREAD_ITEM?
1378 LoggerI("name.size(): " << name.size());
1380 unsigned foundLocation = name.rfind(0x01);
1381 LoggerI("foundLocation: " << foundLocation);
1382 if(foundLocation != std::string::npos)
1384 LoggerI("name: " << name);
1385 name = name.substr(foundLocation+1);
1386 LoggerI("name: " << name);
1389 std::vector<std::string> strIds = String::split(name, ',');
1391 std::stringstream stream;
1392 for (std::vector<std::string>::iterator it = strIds.begin(); it != strIds.end(); ++it)
1394 LoggerD("ID is :" << *it);
1396 if ( (*it).length() > 0 ) //vaild id
1402 IMessagePtr msg = MessageFactory::createMessage(EMPTY_MESSAGE, id);
1403 IConversationPtr conversation(new Conversation(mail_id, EMPTY_EMAIL_CONVERSATION));
1405 FolderType folder = msg->getCurrentFolder();
1406 jsEvent->setMsg_Event_Type(EventMessageReceived::MSG_DELETED);
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);
1416 LoggerW("New email message in ignored folder: " << folder);
1424 else if ((mail_id > 0) && (NOTI_MAIL_UPDATE == status))
1425 { // TODO also RECEIVE_THREAD_ITEM?
1426 LoggerI("Email received. mail_id: " << mail_id);
1428 IMessagePtr msg = MessageFactory::createMessage(EMAIL, mail_id);
1429 IConversationPtr conversation(new Conversation(msg->getConvId(), EMAIL));
1431 FolderType folder = msg->getCurrentFolder();
1432 jsEvent->setMsg_Event_Type(EventMessageReceived::MSG_UPDATED);
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);
1442 LoggerW("New email message in ignored folder: " << folder);
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);
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);
1454 if(m_onConversationReceived.size() > 0){
1455 m_onConversationReceived.emit(jsEvent);
1458 else if (NOTI_MAILBOX_ADD == status)
1460 LoggerI("Emailbox received. account Id: " << account_id);
1461 LoggerI("name Id: " << name);
1462 LoggerI("mailBox Id: " << mail_id);
1464 email_mailbox_t* mail_box = NULL;
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.");
1470 if(mail_box != NULL)
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)
1478 m_onFolderReceived.emit(jsEvent);
1484 if( EMAIL_ERROR_NONE != email_free_mailbox( &mail_box , 1) )
1485 LoggerD("fail to email_free_mailbox - err ");
1489 else if ((NOTI_MAILBOX_UPDATE == status) || (NOTI_MAILBOX_FIELD_UPDATE == status) || (NOTI_MAILBOX_RENAME == status))
1491 LoggerI("Emailbox received. account Id: " << account_id);
1492 LoggerI("name Id: " << name);
1493 LoggerI("mailBox Id: " << mail_id);
1495 email_mailbox_t* mail_box = NULL;
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.");
1501 if(mail_box != NULL)
1503 m_mailboxes = *mail_box;
1505 IMessageFolderPtr folderPtr(new MessageFolder(m_mailboxes));
1506 jsEvent->setMessageFolder(folderPtr);
1507 jsEvent->setMsg_Event_Type(EventMessageReceived::MSG_UPDATED);
1509 if(m_onFolderReceived.size() > 0)
1511 m_onFolderReceived.emit(jsEvent);
1517 if( EMAIL_ERROR_NONE != email_free_mailbox( &mail_box , 1) )
1518 LoggerD("fail to email_free_mailbox - err ");
1521 else if (NOTI_MAILBOX_DELETE == status)
1523 LoggerI("Emailbox received. account Id: " << account_id);
1524 LoggerI("name Id: " << name);
1525 LoggerI("mailBox Id: " << mail_id);
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 *)"";
1533 IMessageFolderPtr folderPtr(new MessageFolder(m_mailboxes));
1534 jsEvent->setMessageFolder(folderPtr);
1535 jsEvent->setMsg_Event_Type(EventMessageReceived::MSG_DELETED);
1537 if(m_onFolderReceived.size() > 0)
1539 m_onFolderReceived.emit(jsEvent);
1544 LoggerE("Couldn't retrieve message or it has been malformed.");
1547 else // DBUS_INTERFACE_EMAIL_RECEIVED
1549 LoggerD("Wrong DBus interface, skipping it.");
1552 }Catch(WrtDeviceApis::Commons::Exception) {
1553 LoggerE("Couldn't retrieve message or it has been malformed.");
1557 void Messaging::onMessageStorageChanged(msg_handle_t handle,
1558 msg_storage_change_type_t storageChangeType,
1559 msg_id_list_s *pMsgIdList,
1565 msg_error_t err = MSG_SUCCESS;
1566 msg_struct_t msg = NULL;
1567 msg_struct_t sendOpt = NULL;
1569 if(storageChangeType == MSG_STORAGE_CHANGE_CONTACT)
1571 LoggerD("storageChangeType is MSG_STORAGE_CHANGE_CONTACT");
1575 Messaging* this_ = static_cast<Messaging*>(data);
1579 int msgCount = pMsgIdList->nCount;
1580 LoggerD("msgCount = "<< msgCount);
1582 for(int index = 0; index < msgCount; index++)
1585 LoggerD("storageChangeType = "<< storageChangeType);
1587 if(storageChangeType == MSG_STORAGE_CHANGE_DELETE)
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);
1597 if(this_->m_onMessageReceived.size() > 0){
1598 this_->m_onMessageReceived.emit(event);
1600 if(this_->m_onConversationReceived.size() > 0){
1601 this_->m_onConversationReceived.emit(event);
1606 msg = msg_create_struct(MSG_STRUCT_MESSAGE_INFO);
1607 sendOpt = msg_create_struct(MSG_STRUCT_SENDOPT);
1609 err = msg_get_message(handle, pMsgIdList->msgIdList[index], msg, sendOpt);
1611 if (err != MSG_SUCCESS)
1613 LoggerD("Get Message Failed!");
1614 LoggerD("err" << err);
1615 msg_release_struct(&msg);
1616 msg_release_struct(&sendOpt);
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))
1627 if(msgType != MSG_TYPE_MMS_NOTI)
1630 msg_get_int_value(msg, MSG_MESSAGE_ID_INT, &msgId);
1631 IMessagePtr message = MessageFactory::createMessage(
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);
1643 if(this_->m_onMessageReceived.size() > 0){
1644 LoggerD("Message Status = " << message->getMessageStatus());
1645 if((storageChangeType == MSG_STORAGE_CHANGE_INSERT))
1647 LoggerD("MSG_STORAGE_CHANGE_INSERT");
1648 event->setMsg_Event_Type(EventMessageReceived::MSG_ADDED);
1649 this_->m_onMessageReceived.emit(event);
1651 else if(storageChangeType == MSG_STORAGE_CHANGE_UPDATE)
1653 LoggerD("MSG_STORAGE_CHANGE_UPDATE");
1654 event->setMsg_Event_Type(EventMessageReceived::MSG_UPDATED);
1655 this_->m_onMessageReceived.emit(event);
1658 if(this_->m_onConversationReceived.size() > 0){
1660 LoggerD("Message Status = " << message->getMessageStatus());
1661 if((conversation->getMessageCount() == 1) && (storageChangeType == MSG_STORAGE_CHANGE_INSERT))
1664 LoggerD("MSG_STORAGE_CHANGE_INSERT");
1665 event->setMsg_Event_Type(EventMessageReceived::MSG_ADDED);
1666 this_->m_onConversationReceived.emit(event);
1668 if(emitCheck == 0 && (message->getMessageStatus()!=MESSAGE_STATUS_SENT))
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);
1678 LoggerE("Ignore this sms, this is mms noti.");
1681 else if((msgType >= MSG_TYPE_MMS) && (msgType <= MSG_TYPE_MMS_NOTI))
1683 if(msgType != MSG_TYPE_MMS_NOTI)
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(
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);
1701 if(this_->m_onMessageReceived.size() > 0){
1702 if(storageChangeType == MSG_STORAGE_CHANGE_INSERT)
1704 LoggerD("MSG_STORAGE_CHANGE_INSERT");
1705 event->setMsg_Event_Type(EventMessageReceived::MSG_ADDED);
1707 else if(storageChangeType == MSG_STORAGE_CHANGE_UPDATE)
1709 LoggerD("MSG_STORAGE_CHANGE_UPDATE");
1710 if(mmsDirection == 1) // check incomming mms
1712 LoggerD("mmsDirection == 1");
1713 event->setMsg_Event_Type(EventMessageReceived::MSG_ADDED);
1717 event->setMsg_Event_Type(EventMessageReceived::MSG_UPDATED);
1720 this_->m_onMessageReceived.emit(event);
1722 if(this_->m_onConversationReceived.size() > 0){
1724 LoggerD("Message Status = " << message->getMessageStatus());
1725 if((conversation->getMessageCount() == 1) && (storageChangeType == MSG_STORAGE_CHANGE_INSERT))
1728 LoggerD("MSG_STORAGE_CHANGE_INSERT");
1729 event->setMsg_Event_Type(EventMessageReceived::MSG_ADDED);
1730 this_->m_onConversationReceived.emit(event);
1732 if(emitCheck == 0 && (message->getMessageStatus()!=MESSAGE_STATUS_SENT))
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);
1742 LoggerE("Ignore this mms, this is mms noti.");
1747 LoggerE("release msg : " << msg);
1748 msg_release_struct(&msg);
1752 LoggerE("release sendOpt");
1753 msg_release_struct(&sendOpt);
1758 Catch(WrtDeviceApis::Commons::ConversionException) {
1759 LoggerE("Couldn't convert message to sms.");
1762 LoggerE("release msg : " << msg);
1763 msg_release_struct(&msg);
1767 LoggerE("release sendOpt");
1768 msg_release_struct(&sendOpt);
1771 Catch(WrtDeviceApis::Commons::PlatformException) {
1772 LoggerE("onMessageStorageChanged platform exception");
1775 LoggerE("release msg : " << msg);
1776 msg_release_struct(&msg);
1780 LoggerE("release sendOpt");
1781 msg_release_struct(&sendOpt);
1784 Catch(WrtDeviceApis::Commons::Exception) {
1785 LoggerE("onMessageStorageChanged Exception");
1788 LoggerE("release msg : " << msg);
1789 msg_release_struct(&msg);
1793 LoggerE("release sendOpt");
1794 msg_release_struct(&sendOpt);
1801 void Messaging::onSmsReceived(MSG_HANDLE_T handle,
1806 Messaging* this_ = static_cast<Messaging*>(data);
1809 if(msg_get_message_type(msg) != MSG_TYPE_MMS_NOTI)
1811 IMessagePtr message = MessageFactory::createMessage(
1815 ISmsPtr sms = MessageFactory::convertToSms(message);
1816 IConversationPtr conversation(new Conversation(message->getId(), SMS));
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);
1826 LoggerE("Ignore this sms, this is mms noti.");
1829 Catch(WrtDeviceApis::Commons::ConversionException) {
1830 LoggerE("Couldn't convert message to sms.");
1835 void Messaging::onMmsReceived(MSG_HANDLE_T handle,
1840 Messaging* this_ = static_cast<Messaging*>(data);
1843 IMessagePtr message = MessageFactory::createMessage(
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);
1855 Catch(WrtDeviceApis::Commons::ConversionException) {
1856 LoggerE("Couldn't convert message to mms.");
1861 void Messaging::getNumberOfEmails(FolderType folder,
1867 email_mailbox_t mailbox = {};
1868 mailbox.account_id = 0; // means for all accounts
1869 mailbox.name = String::strdup(
1870 EmailConverter::toMailboxName(folder)
1873 int error = email_count_mail(&mailbox, read, unread);
1876 if (EMAIL_ERROR_NONE != error) {
1877 ThrowMsg(WrtDeviceApis::Commons::PlatformException,
1878 "Couldn't get number of emails. [" << error << "]");
1884 void Messaging::getNumberOfSms(FolderType folder,
1888 getNumberOfSmsMms(folder, read, unread, SMS);
1891 void Messaging::getNumberOfMms(FolderType folder,
1895 getNumberOfSmsMms(folder, read, unread, MMS);
1898 void Messaging::getNumberOfSmsMms(FolderType folder,
1901 MessageType msgType)
1903 MSG_LIST_S folderListView = { 0, NULL };
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;
1916 LoggerE("no supported message type in this method");
1917 Throw(WrtDeviceApis::Commons::PlatformException);
1920 msg_folder_id_t msgFolderId;
1923 msgFolderId = MSG_INBOX_ID;
1926 msgFolderId = MSG_OUTBOX_ID;
1929 msgFolderId = MSG_SENTBOX_ID;
1932 msgFolderId = MSG_DRAFT_ID;
1935 LoggerE("wrong folder type");
1936 Throw(WrtDeviceApis::Commons::PlatformException);
1940 const MSG_SORT_RULE_S sort_rules = { MSG_SORT_BY_DISPLAY_TIME, true };
1941 if (msg_get_folder_view_list(MsgGetCommonHandle(), msgFolderId,
1943 &folderListView) != MSG_SUCCESS) {
1945 "msg_get_folder_view_list empty or failed, msgFolderId=" <<
1947 Throw(WrtDeviceApis::Commons::PlatformException);
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.
1956 ", searching for = " << (int) msgTypePlatform);
1957 if (msgTypePlatform ==
1958 msg_get_message_type(folderListView.msgInfo[
1960 if (msg_is_read(folderListView.msgInfo[msg_cnt]))
1968 msg_release_list_struct(&folderListView);
1970 LoggerD("readed=" << *read << ", unReaded=" << *unread);
1973 Catch(WrtDeviceApis::Commons::PlatformException) {
1974 if (folderListView.nCount) {
1975 msg_release_list_struct(&folderListView);
1981 vector<IMessagePtr> Messaging::findSms(FolderType folder, const DeviceAPI::Tizen::FilterPtr& filter)
1985 vector<IMessagePtr> retVal;
1986 msg_message_t msg = msg_new_message();
1987 MSG_LIST_S folder_list_view = {0, NULL};
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);
1995 if (MSG_SUCCESS != res) {
1996 LoggerE("msg_get_folder_view_list failed " << res);
1997 Throw(WrtDeviceApis::Commons::PlatformException);
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);
2005 // if (!filter || !filter->isValid() ||
2006 // filter->compare(MessageFactory::convertToSms(msg))) {
2007 retVal.push_back(msg);
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);
2019 msg_release_message(&msg);
2028 vector<IMessagePtr> Messaging::findMms(FolderType folder,
2029 const DeviceAPI::Tizen::FilterPtr& filter)
2031 vector<IMessagePtr> retVal;
2032 msg_message_t msg = msg_new_message();
2033 MSG_LIST_S folder_list_view = {0, NULL};
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,
2044 if (MSG_SUCCESS != res) {
2045 LoggerE("msg_Get_folder_view_list failed" << res);
2046 Throw(WrtDeviceApis::Commons::PlatformException);
2049 for (int i = 0; i < folder_list_view.nCount; i++) {
2051 msg_get_message_type(folder_list_view.
2053 int l_msgId = msg_get_message_id(
2054 folder_list_view.msgInfo[i]);
2055 IMessagePtr msg = MessageFactory::createMessage(MMS, l_msgId);
2059 msg_release_list_struct(&folder_list_view);
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);
2068 msg_release_message(&msg);
2076 void Messaging::createFolder(MessageType msgType,
2077 const string& userFolder)
2082 createMsgServiceFolder(userFolder);
2085 createEmailFolder(userFolder);
2088 LoggerE("msg not supported");
2089 Throw(WrtDeviceApis::Commons::UnknownException);
2093 void Messaging::createMsgServiceFolder(const std::string& userFolder)
2096 if (userFolder.length() > MAX_FOLDER_NAME_SIZE) {
2097 LoggerE("folder name to long");
2098 Throw(WrtDeviceApis::Commons::PlatformException);
2101 MSG_FOLDER_INFO_S folderInfo;
2103 folderInfo.folderId = 0;
2104 strncpy(folderInfo.folderName, userFolder.c_str(), userFolder.length());
2106 folderInfo.folderType = MSG_FOLDER_TYPE_USER_DEF;
2108 if (msg_add_folder(MsgGetCommonHandle(), &folderInfo) != MSG_SUCCESS) {
2109 LoggerE("msg_add_folder failed");
2110 Throw(WrtDeviceApis::Commons::PlatformException);
2115 void Messaging::createEmailFolder(const std::string& userFolder)
2119 Throw(WrtDeviceApis::Commons::UnknownException);
2122 void Messaging::deleteFolder(MessageType msgType,
2123 const string& userFolder)
2128 deleteMsgServiceFolder(userFolder);
2131 deleteEmailFolder(userFolder);
2134 LoggerE("msg not supported");
2135 Throw(WrtDeviceApis::Commons::UnknownException);
2139 void Messaging::deleteMsgServiceFolder(const string& userFolder)
2144 int platformFolderId = convertFolderToPlatform(userFolder);
2146 msg_delete_folder(MsgGetCommonHandle(), platformFolderId)) {
2147 LoggerE("msg_get_folder_list failed");
2148 Throw(WrtDeviceApis::Commons::PlatformException);
2151 Catch(WrtDeviceApis::Commons::PlatformException) {
2157 void Messaging::deleteEmailFolder(const string& userFolder)
2161 Throw(WrtDeviceApis::Commons::UnknownException);
2164 vector<string> Messaging::getFolderNames(MessageType msgType)
2169 return getFolderNamesMsgService();
2171 return getFolderNamesEmail();
2173 LoggerE("msg not supported");
2174 Throw(WrtDeviceApis::Commons::UnknownException);
2178 vector<string> Messaging::getFolderNamesMsgService()
2180 vector<string> retVal;
2181 // MSG_FOLDER_LIST_S msgFolderList = { 0, NULL }; // output data
2183 msg_struct_list_s msgFolderList = {0,};
2187 if (msg_get_folder_list(MsgGetCommonHandle(),
2188 &msgFolderList) != MSG_SUCCESS) {
2189 LoggerE("msg_get_folder_list failed");
2190 Throw(WrtDeviceApis::Commons::PlatformException);
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);
2199 (int) msgFolderList.folderInfo[i].folderType);
2200 retVal.push_back(msgFolderList.folderInfo[i].folderName);
2202 (void) msg_release_folder_list(&msgFolderList);
2205 Catch(WrtDeviceApis::Commons::PlatformException) {
2206 if (msgFolderList.nCount) {
2207 (void) msg_release_folder_list(&msgFolderList);
2215 vector<string> Messaging::getFolderNamesEmail()
2217 vector<string> retVal;
2220 email_mailbox_t* mailboxes = NULL;
2222 string emailAccountName;
2223 EmailAccountInfo account = getCurrentEmailAccount();
2227 if (!email_get_mailbox_list(account.getIntId(), -1, &mailboxes,
2228 &mailboxesCount) || !mailboxes) {
2229 LoggerE("error during get mailboxes");
2231 if(mailboxes == NULL)
2233 LoggerE("error during get mailboxes");
2234 ThrowMsg(WrtDeviceApis::Commons::PlatformException,
2235 "Couldn't get mailboxes");
2237 for (int i = 0; i < mailboxesCount; i++) {
2238 retVal.push_back(mailboxes->mailbox_name);
2239 LoggerD("mailbox found, name=" << mailboxes->mailbox_name);
2242 if(mailboxes != NULL)
2244 if( EMAIL_ERROR_NONE != email_free_mailbox( &mailboxes , mailboxesCount) )
2245 LoggerD("fail to email_free_mailbox - err ");
2249 Catch(WrtDeviceApis::Commons::PlatformException) {
2250 // nothing to clean, re-throw exception
2257 vector<IMessagePtr> Messaging::findEmail(const std::string &folder,
2258 const DeviceAPI::Tizen::FilterPtr& filter)
2260 vector<IMessagePtr> retVal;
2262 EmailAccountInfo account = getCurrentEmailAccount();
2263 if (account.getId().empty()) {
2264 LoggerW("No valid email accounts. Skipping");
2268 int accountId = account.getIntId();
2270 // number of found emails
2276 email_mail_list_item_t* results = NULL;
2277 int err = email_get_mail_list(accountId,
2279 EMAIL_LIST_TYPE_NORMAL,
2282 EMAIL_SORT_DATETIME_HIGH,
2285 DPL::ScopedFree<email_mail_list_item_t> autoFree(results);
2287 if (EMAIL_ERROR_MAIL_NOT_FOUND == err || results == NULL) {
2288 LoggerW("No emails found in mailbox: " << folder);
2290 } else if (EMAIL_ERROR_NONE != err) {
2292 "Unable to get mail list for mailbox: " << folder <<
2293 ", Error: " << err);
2294 Throw(WrtDeviceApis::Commons::PlatformException);
2298 for (int i = 0; i < count; ++i) {
2299 IMessagePtr msg = MessageFactory::createMessage(EMAIL, results[i].mail_id);
2303 // || filter->compare(MessageFactory::convertToEmail(msg)) //TODO implemnet compare in filter
2305 retVal.push_back(msg);
2309 startIndex += count;
2311 while (count >= MESSAGE_FIND_LIMIT);
2316 vector<IMessagePtr> Messaging::findEmail(FolderType folder,
2317 const DeviceAPI::Tizen::FilterPtr& filter)
2319 vector<IMessagePtr> result;
2321 EmailAccountInfo account = getCurrentEmailAccount();
2322 if (account.getId().empty()) {
2323 LoggerW("No valid email accounts.");
2329 name = EmailConverter::toMailboxName(folder);
2331 catch (const WrtDeviceApis::Commons::PlatformException& ex) {
2332 LoggerW(ex.DumpToString());
2336 int accountId = account.getIntId();
2340 email_mail_list_item_t* messages = NULL;
2341 int error = email_get_mail_list(accountId,
2343 EMAIL_LIST_TYPE_NORMAL,
2346 EMAIL_SORT_DATETIME_HIGH,
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);
2353 } else if (EMAIL_ERROR_NONE != error) {
2354 ThrowMsg(WrtDeviceApis::Commons::PlatformException,
2355 "Couldn't get mail list from mailbox: " << name <<
2356 ". [" << error << "]");
2359 for (int i = 0; i < count; ++i) {
2361 MessageFactory::createMessage(EMAIL, messages[i].mail_id);
2363 // ||filter->compare(MessageFactory::convertToEmail(msg)) //TODO implement compare in filter
2365 result.push_back(msg);
2369 startIndex += count;
2371 while (count >= MESSAGE_FIND_LIMIT);
2376 int Messaging::getConversationId(const int& msgId, const MessageType& msgtype)
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;
2389 LoggerD("Current Account " << m_currentEmailAccountId);
2394 if (EMAIL_ERROR_NONE != email_get_mail_data(msgId, &result)) {
2395 ThrowMsg(WrtDeviceApis::Commons::PlatformException,
2396 "Couldn't get conversatino Id " << msgId );
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)
2402 ThrowMsg(WrtDeviceApis::Commons::PlatformException, "get email list fail" );
2405 email_free_mail_data(&result,1);
2407 for (index = 0; index < count; index++)
2409 if (mailList[index].mail_id == (int)msgId)
2411 return mailList[index].thread_id;
2414 ThrowMsg(WrtDeviceApis::Commons::PlatformException, "can not find msg" );
2416 catch (const WrtDeviceApis::Commons::Exception& ex)
2420 email_free_mail_data(&result,1);
2421 LoggerE("Exception: " << ex.GetMessage());
2424 return MSG_ERR_INVALID_MSG_TYPE;
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;
2435 err = msg_get_message(handle, msgId, msg, sendOpt);
2437 if( err < MSG_SUCCESS )
2439 ThrowMsg(WrtDeviceApis::Commons::PlatformException,
2440 "can not find msg id(" << msgId << ")");
2444 err = msg_get_int_value(msg, MSG_MESSAGE_THREAD_ID_INT, &threadId);
2448 if( err < MSG_SUCCESS )
2450 ThrowMsg(WrtDeviceApis::Commons::PlatformException,
2451 "can not find thread with msg id(" << msgId << ")");
2453 msg_release_struct(&msg);
2454 msg_release_struct(&sendOpt);
2460 ThrowMsg(WrtDeviceApis::Commons::PlatformException,
2461 "Wrong Type (" << msgId << ")");
2462 return MSG_ERR_INVALID_MSG_TYPE;
2467 std::vector<IConversationPtr> Messaging::queryConversations(const DeviceAPI::Tizen::SortModePtr& sortMode,
2468 const DeviceAPI::Tizen::FilterPtr& filter, long limit, long offset)
2472 std::vector<IConversationPtr> result;
2473 std::string filterSql;
2474 std::string orderLimitSql ="";
2476 ConversationQueryGeneratorPtr queryGenerator(new ConversationQueryGenerator(sortMode, limit, offset));
2477 IFilterVisitorPtr filterVisitor = DPL::StaticPointerCast<IFilterVisitor>(queryGenerator);
2478 filter->travel(filterVisitor, 0);
2480 // LOGD("filterSql:[%s]", filterSql.c_str());
2482 int conversationType = queryGenerator->getMessageType();
2483 switch(conversationType){
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);
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);
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);
2518 LoggerE("[ERROR] >>> invlid type:[" << conversationType <<"]");
2526 std::vector<IConversationPtr> Messaging::queryConversations(const DeviceAPI::Tizen::FilterPtr& filter,
2527 const DeviceAPI::Tizen::SortModePtr& sortMode, int type, long limit, long offset)
2531 std::vector<IConversationPtr> result;
2532 std::string filterSql;
2533 std::string orderLimitSql ="";
2535 ConversationQueryGeneratorPtr queryGenerator(new ConversationQueryGenerator(sortMode, limit, offset, type));
2536 IFilterVisitorPtr filterVisitor = DPL::StaticPointerCast<IFilterVisitor>(queryGenerator);
2537 filter->travel(filterVisitor, 0);
2539 // LOGD("filterSql:[%s]", filterSql.c_str());
2540 int conversationType = queryGenerator->getMessageType();
2541 if(conversationType != -1)
2543 if(conversationType != type)
2545 LoggerD("filter conversationType and service msg type is diff");
2546 ThrowMsg(WrtDeviceApis::Commons::InvalidArgumentException, "invalid Fiilter Type");
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);
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);
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);
2589 LoggerE("[ERROR] >>> invlid type:[" << conversationType <<"]");
2597 bool Messaging::deleteConversations(const DeviceAPI::Tizen::SortModePtr& sortMode, const DeviceAPI::Tizen::FilterPtr& filter)
2601 std::vector<IConversationPtr> conversationsToDelete = queryConversations(sortMode, filter);
2602 return deleteConversations(conversationsToDelete);
2605 bool Messaging::deleteConversations(const std::vector<IConversationPtr>& conversations)
2609 if (conversations.size() == 0)
2612 if (conversations[0]->getType() == EMAIL)
2614 LoggerD("Enter-Email");
2618 for (std::size_t i = 0; i < conversations.size(); ++i)
2620 threadId = conversations[i]->getConvId();
2622 if (email_delete_thread(threadId, false) != EMAIL_ERROR_NONE)
2628 // email_delete_thread is asyncronous so check last deleted thread status check
2629 email_mail_list_item_t *thread_info = NULL;
2633 err = email_get_thread_information_ex(threadId, &thread_info);
2634 LoggerD("err " << err);
2635 }while(err != EMAIL_ERROR_MAIL_NOT_FOUND);
2637 if (thread_info != NULL){
2643 LoggerD("Enter-Msg");
2644 msg_thread_id_t threadId = 0;
2645 msg_handle_t handle = MsgGetCommonHandle();
2647 for (std::size_t i = 0; i < conversations.size(); ++i)
2649 threadId = conversations[i]->getConvId();
2650 if (msg_delete_thread_message_list(handle, threadId, FALSE) != MSG_SUCCESS)
2659 std::vector<IMessageFolderPtr> Messaging::queryFolders(const DeviceAPI::Tizen::FilterPtr& filter)
2663 email_mailbox_t* mailboxes = NULL;
2664 email_mailbox_t* mailboxes_org = NULL;
2665 email_mailbox_t m_mailboxes;
2669 std::vector<IMessageFolderPtr> result;
2670 std::string folderName;
2673 EmailAccountInfo account = getCurrentEmailAccount();
2675 if (account.getId().empty()) {
2676 LoggerW("No valid email accounts. Skipping");
2680 const vector<EmailAccountInfo> accounts = getEmailAccounts();
2682 FolderQueryGeneratorPtr queryGenerator(new FolderQueryGenerator());
2684 IFilterVisitorPtr filterVisitor = DPL::StaticPointerCast<IFilterVisitor>(queryGenerator);
2685 queryGenerator->reset();
2686 filter->travel(filterVisitor, 0);
2687 accountId = queryGenerator->getAccountId();
2691 LoggerW("No valid email accounts. accountId : 0");
2695 if(queryGenerator->isFolderPathExist() == 1){
2697 folderName = queryGenerator->getFolderPath();
2699 if(email_get_mailbox_by_name(accountId, folderName.c_str(), &mailboxes) != 1)
2701 LoggerE("error during get mailboxes");
2705 m_mailboxes = *mailboxes;
2706 IMessageFolderPtr folderPtr(new MessageFolder(m_mailboxes));
2707 result.push_back(folderPtr);
2711 if (!email_get_mailbox_list(accountId, -1, &mailboxes, &mailboxesCount) || !mailboxes)
2713 LoggerE("error during get mailboxes");
2717 mailboxes_org = mailboxes;
2719 if (mailboxesCount <= 0)
2721 LoggerD("Empty...");
2725 LoggerD("found mailboxs : " << mailboxesCount);
2726 for (int i = 0; i < mailboxesCount; i++)
2729 m_mailboxes = *mailboxes;
2730 IMessageFolderPtr folderPtr(new MessageFolder(m_mailboxes));
2731 result.push_back(folderPtr);
2736 mailboxes = mailboxes_org;
2738 if(mailboxes != NULL)
2740 error = email_free_mailbox(&mailboxes,mailboxesCount);
2741 LoggerE("email_free_mailbox : " << error);