[Messaging] Added logs in methods onEntered and onReturn

Change-Id: Iefc8f9e36e88163a0105453a897594dea653adcb
Signed-off-by: Piotr Kosko <p.kosko@samsung.com>

diff --git a/src/messaging/change_listener_container.cc b/src/messaging/change_listener_container.cc
index 43b67295782e910cf41d7fcafab49474421644b7..548d387b95ededb3af7d4323f365e5a5fc1b369b 100644 (file)
--- a/src/messaging/change_listener_container.cc
+++ b/src/messaging/change_listener_container.cc
@@ -12,6 +12,7 @@ namespace messaging {
 
 ChangeListenerContainer& ChangeListenerContainer::getInstance()
 {
+    LoggerD("Entered");
     EmailManager::getInstance(); //make sure that callbacks are registered in email-service
     //ShortMsgManager::getInstance(); //make sure that callbacks are registered in msg-service
     static ChangeListenerContainer clc;
@@ -430,6 +431,7 @@ void ChangeListenerContainer::callFolderRemoved(EventFolders* event)
 }
 
 int ChangeListenerContainer::getNextId() {
+    LoggerD("Entered");
     // mutex is created only on first call (first call added to constructor
     // to initialize mutex correctly
     static std::mutex id_mutex;

diff --git a/src/messaging/conversation_callback_data.cc b/src/messaging/conversation_callback_data.cc
index 5e9ff716ff47dc6e74362c61f18919cd0b2b97cc..e1e34c35b20fd37c1377ad48976d85e394c1090d 100644 (file)
--- a/src/messaging/conversation_callback_data.cc
+++ b/src/messaging/conversation_callback_data.cc
@@ -18,6 +18,7 @@ ConversationCallbackData::ConversationCallbackData(PostQueue& queue):
         m_service_type(UNDEFINED),
         queue_(queue)
 {
+    LoggerD("Entered");
 }
 
 ConversationCallbackData::ConversationCallbackData(long cid, PostQueue& queue, bool keep):
@@ -30,6 +31,7 @@ ConversationCallbackData::ConversationCallbackData(long cid, PostQueue& queue, b
         m_service_type(UNDEFINED),
         queue_(queue)
 {
+    LoggerD("Entered");
     auto json = std::shared_ptr<picojson::value>(new picojson::value(picojson::object()));
     picojson::object& o = json->get<picojson::object>();
     o[JSON_CALLBACK_ID] = picojson::value(static_cast<double>(cid));
@@ -39,6 +41,7 @@ ConversationCallbackData::ConversationCallbackData(long cid, PostQueue& queue, b
 
 ConversationCallbackData::~ConversationCallbackData()
 {
+    LoggerD("Entered");
 }
 
 void ConversationCallbackData::setFilter(AbstractFilterPtr filter)
@@ -74,8 +77,10 @@ std::vector<std::shared_ptr<MessageConversation>> ConversationCallbackData::getC
 void ConversationCallbackData::setError(const std::string& err_name,
         const std::string& err_message)
 {
+    LoggerD("Entered");
     // keep only first error in chain
     if (!m_is_error) {
+        LoggerD("Error has not been set yet");
         picojson::object& obj = m_json->get<picojson::object>();
         obj[JSON_ACTION] = picojson::value(JSON_CALLBACK_ERROR);
         auto objData = picojson::object();
@@ -93,8 +98,10 @@ void ConversationCallbackData::setError(const std::string& err_name,
 
 void ConversationCallbackData::SetError(const common::PlatformResult& error)
 {
+    LoggerD("Entered");
   // keep only first error in chain
   if (!m_is_error) {
+      LoggerD("Error has not been set yet");
     m_is_error = true;
     picojson::object& obj = m_json->get<picojson::object>();
     obj[JSON_ACTION] = picojson::value(JSON_CALLBACK_ERROR);

diff --git a/src/messaging/conversations_change_callback.cc b/src/messaging/conversations_change_callback.cc
index a47a58da5898634c52aa06c5ace6fffd1154dbc1..bc58fbd5719392e3f8d5ac71600c2022f3dc67a1 100644 (file)
--- a/src/messaging/conversations_change_callback.cc
+++ b/src/messaging/conversations_change_callback.cc
@@ -49,7 +49,9 @@ ConversationPtrVector ConversationsChangeCallback::filterConversations(
         AbstractFilterPtr filter,
         const ConversationPtrVector& source_conversations)
 {
+    LoggerD("Entered");
     if (filter) {
+        LoggerD("filter pointer is valid");
         ConversationPtrVector filtered_conversations;
         ConversationPtrVector::const_iterator it = source_conversations.begin();
         ConversationPtrVector::const_iterator end_it = source_conversations.end();
@@ -72,6 +74,7 @@ ConversationPtrVector ConversationsChangeCallback::filterConversations(
         return filtered_conversations;
     }
     else {
+        LoggerD("filter pointer is not valid");
         return source_conversations;
     }
 }

diff --git a/src/messaging/email_manager.cc b/src/messaging/email_manager.cc
index 251142dab8cc8f7a4e8eddb756104c559520b2c1..8bbb8ee10f14205664d8be749f1410d116a30b0c 100644 (file)
--- a/src/messaging/email_manager.cc
+++ b/src/messaging/email_manager.cc
@@ -300,6 +300,7 @@ PlatformResult EmailManager::addMessagePlatform(int account_id,
 
 static gboolean addDraftMessageCompleteCB(void *data)
 {
+    LoggerD("Entered");
     MessageCallbackUserData* callback =
         static_cast<MessageCallbackUserData *>(data);
     if (!callback) {
@@ -381,12 +382,14 @@ static gboolean sendEmailCompleteCB(void* data)
     picojson::object& obj = json->get<picojson::object>();
     if (json->contains(JSON_CALLBACK_ID) && obj.at(JSON_CALLBACK_ID).is<double>()) {
         if (callback->isError()) {
+            LoggerD("Calling error callback");
             callback->getQueue().resolve(obj.at(JSON_CALLBACK_ID).get<double>(),
                                              json->serialize()
             );
             callback->getMessage()->setMessageStatus(MessageStatus::STATUS_FAILED);
         }
         else {
+            LoggerD("Calling success callback");
             obj[JSON_ACTION] = picojson::value(JSON_CALLBACK_SUCCCESS);
 
             std::vector<picojson::value> recipients;
@@ -501,7 +504,7 @@ void EmailManager::sendStatusCallback(int mail_id,
         email_noti_on_network_event status,
         int error_code)
 {
-    LoggerD("Enter");
+    LoggerD("Entered");
 
     std::lock_guard<std::mutex> lock(m_mutex);
     //find first request for this mail_id
@@ -550,6 +553,7 @@ void EmailManager::sendStatusCallback(int mail_id,
 
 email_mail_data_t* EmailManager::loadMessage(int msg_id)
 {
+    LoggerD("Entered");
     email_mail_data_t* mail_data = NULL;
     int err = EMAIL_ERROR_NONE;
     err = email_get_mail_data(msg_id, &mail_data);
@@ -563,6 +567,7 @@ email_mail_data_t* EmailManager::loadMessage(int msg_id)
 
 EmailManager::SendReqMapIterator EmailManager::getSendRequest(int mail_id)
 {
+    LoggerD("Entered");
     for (auto it = m_sendRequests.begin(); it != m_sendRequests.end(); it++) {
         if (it->second->getMessage()->getId() == mail_id) {
             return it;
@@ -573,6 +578,7 @@ EmailManager::SendReqMapIterator EmailManager::getSendRequest(int mail_id)
 
 void EmailManager::freeMessage(email_mail_data_t* mail_data)
 {
+    LoggerD("Entered");
     if(!mail_data) {
         return;
     }
@@ -797,7 +803,7 @@ void EmailManager::syncFolder(SyncFolderCallbackData* callback)
   if (NULL != mailbox) {
     err = email_free_mailbox(&mailbox, 1);
     if (EMAIL_ERROR_NONE != err) {
-      LoggerD("Failed to email_free_mailbox - err:%d ", err);
+      LoggerE("Failed to email_free_mailbox - err:%d ", err);
     }
     mailbox = NULL;
   }
@@ -883,6 +889,7 @@ void removeEmailCompleteCB(MessagesCallbackUserData* callback)
 EmailManager::DeleteReqVector::iterator EmailManager::getDeleteRequest(
         const std::vector<int> &ids)
 {
+    LoggerD("Entered");
     for (auto idIt = ids.begin(); idIt != ids.end(); ++idIt) {
         for (auto reqIt = m_deleteRequests.begin(); reqIt != m_deleteRequests.end(); ++reqIt) {
             MessagePtrVector msgs = reqIt->callback->getMessages();
@@ -899,7 +906,7 @@ EmailManager::DeleteReqVector::iterator EmailManager::getDeleteRequest(
 void EmailManager::removeStatusCallback(const std::vector<int> &ids,
             email_noti_on_storage_event status)
 {
-    LoggerD("Enter");
+    LoggerD("Entered");
     std::lock_guard<std::mutex> lock(m_mutex);
     DeleteReqVector::iterator it = getDeleteRequest(ids);
     if (it != m_deleteRequests.end()) {
@@ -933,6 +940,7 @@ void EmailManager::removeStatusCallback(const std::vector<int> &ids,
 
 PlatformResult EmailManager::RemoveMessagesPlatform(MessagesCallbackUserData* callback)
 {
+  LoggerD("Entered");
   int error;
   email_mail_data_t *mail = NULL;
 
@@ -988,6 +996,7 @@ void EmailManager::removeMessages(MessagesCallbackUserData* callback)
 }
 
 PlatformResult EmailManager::UpdateMessagesPlatform(MessagesCallbackUserData* callback) {
+  LoggerD("Entered");
   int error;
   email_mail_data_t *mail = NULL;
   SCOPE_EXIT {
@@ -1095,6 +1104,7 @@ void EmailManager::updateMessages(MessagesCallbackUserData* callback)
 
 PlatformResult EmailManager::FindMessagesPlatform(FindMsgCallbackUserData* callback)
 {
+  LoggerD("Entered");
   email_mail_data_t* mailList = NULL;
   int mailListCount = 0;
 
@@ -1175,6 +1185,7 @@ void EmailManager::findMessages(FindMsgCallbackUserData* callback)
 
 PlatformResult EmailManager::FindConversationsPlatform(ConversationCallbackData* callback)
 {
+  LoggerD("Entered");
   int convListCount = 0;
 
   std::lock_guard<std::mutex> lock(m_mutex);
@@ -1199,7 +1210,7 @@ PlatformResult EmailManager::FindConversationsPlatform(ConversationCallbackData*
 
 void EmailManager::findConversations(ConversationCallbackData* callback)
 {
-    LoggerE("Entered");
+    LoggerD("Entered");
 
     if(!callback){
         LoggerE("Callback is null");
@@ -1251,6 +1262,7 @@ void EmailManager::findConversations(ConversationCallbackData* callback)
 
 long EmailManager::getUniqueOpId()
 {
+    LoggerD("Entered");
     // mutex is created only on first call (first call added to constructor
     // to initialize mutex correctly)
     static std::mutex op_id_mutex;
@@ -1261,6 +1273,7 @@ long EmailManager::getUniqueOpId()
 
 PlatformResult EmailManager::FindFoldersPlatform(FoldersCallbackData* callback)
 {
+  LoggerD("Entered");
   int ret = EMAIL_ERROR_UNKNOWN;
   int account_id = ACCOUNT_ID_NOT_INITIALIZED;
   email_mailbox_t* mailboxes = NULL;
@@ -1389,6 +1402,7 @@ void EmailManager::findFolders(FoldersCallbackData* callback)
 
 PlatformResult EmailManager::RemoveConversationsPlatform(ConversationCallbackData* callback)
 {
+  LoggerD("Entered");
   int error;
   std::lock_guard<std::mutex> lock(m_mutex);
   std::vector<std::shared_ptr<MessageConversation>> conversations =

diff --git a/src/messaging/find_msg_callback_user_data.cc b/src/messaging/find_msg_callback_user_data.cc
index 6aa8174b5cdbc6159c3dfec9c9a6e5e3684633df..84013780a58b8eea88d8dc4bb74e08779008a709 100644 (file)
--- a/src/messaging/find_msg_callback_user_data.cc
+++ b/src/messaging/find_msg_callback_user_data.cc
@@ -34,10 +34,12 @@ FindMsgCallbackUserData::FindMsgCallbackUserData(PostQueue& queue):
         m_service_type(UNDEFINED),
         queue_(queue)
 {
+    LoggerD("Entered");
 }
 
 FindMsgCallbackUserData::~FindMsgCallbackUserData()
 {
+    LoggerD("Entered");
 }
 
 void FindMsgCallbackUserData::setFilter(AbstractFilterPtr filter)
@@ -73,8 +75,10 @@ std::vector<std::shared_ptr<Message>> FindMsgCallbackUserData::getMessages() con
 void FindMsgCallbackUserData::setError(const std::string& err_name,
         const std::string& err_message)
 {
+    LoggerD("Entered");
     // keep only first error in chain
     if (!m_is_error) {
+        LoggerD("Error has not been set yet");
         m_is_error = true;
         m_err_name = err_name;
         m_err_message = err_message;
@@ -91,8 +95,10 @@ void FindMsgCallbackUserData::setError(const std::string& err_name,
 
 void FindMsgCallbackUserData::SetError(const common::PlatformResult& error)
 {
-  // keep only first error in chain
-  if (!m_is_error) {
+    LoggerD("Entered");
+    // keep only first error in chain
+    if (!m_is_error) {
+    LoggerD("Error has not been set yet");
     m_is_error = true;
     picojson::object& obj = m_json->get<picojson::object>();
     obj[JSON_ACTION] = picojson::value(JSON_CALLBACK_ERROR);

diff --git a/src/messaging/folders_callback_data.cc b/src/messaging/folders_callback_data.cc
index e63557d08832f34c74165d0e20d142aa392ad665..96732921ca542793bf12f76c0a1ef782e3d7863c 100644 (file)
--- a/src/messaging/folders_callback_data.cc
+++ b/src/messaging/folders_callback_data.cc
@@ -26,6 +26,7 @@ FoldersCallbackData::FoldersCallbackData(PostQueue& queue):
         m_is_error(false),
         queue_(queue)
 {
+    LoggerD("Entered");
 }
 
 FoldersCallbackData::FoldersCallbackData(long cid, PostQueue& queue, bool keep):
@@ -33,6 +34,7 @@ FoldersCallbackData::FoldersCallbackData(long cid, PostQueue& queue, bool keep):
         m_is_error(false),
         queue_(queue)
 {
+    LoggerD("Entered");
     auto json = std::shared_ptr<picojson::value>(new picojson::value(picojson::object()));
     picojson::object& o = json->get<picojson::object>();
     o[JSON_CALLBACK_ID] = picojson::value(static_cast<double>(cid));
@@ -41,6 +43,7 @@ FoldersCallbackData::FoldersCallbackData(long cid, PostQueue& queue, bool keep):
 }
 
 FoldersCallbackData::~FoldersCallbackData() {
+    LoggerD("Entered");
 }
 
 void FoldersCallbackData::addFolder(std::shared_ptr<MessageFolder> folder)
@@ -66,8 +69,10 @@ tizen::AbstractFilterPtr FoldersCallbackData::getFilter() const
 void FoldersCallbackData::setError(const std::string& err_name,
         const std::string& err_message)
 {
+    LoggerD("Entered");
     // keep only first error in chain
     if (!m_is_error) {
+        LoggerD("Error has not been set yet");
         m_is_error = true;
         m_err_name = err_name;
         m_err_message = err_message;
@@ -84,8 +89,10 @@ void FoldersCallbackData::setError(const std::string& err_name,
 
 void FoldersCallbackData::SetError(const common::PlatformResult& error)
 {
+    LoggerD("Entered");
   // keep only first error in chain
   if (!m_is_error) {
+      LoggerD("Error has not been set yet");
     m_is_error = true;
     picojson::object& obj = m_json->get<picojson::object>();
     obj[JSON_ACTION] = picojson::value(JSON_CALLBACK_ERROR);

diff --git a/src/messaging/folders_change_callback.cc b/src/messaging/folders_change_callback.cc
index 2291665351f4ddb80789fab6278e1980b84d714a..4b2e74d1baccfe10742aa3f680316bb93f27a6fb 100644 (file)
--- a/src/messaging/folders_change_callback.cc
+++ b/src/messaging/folders_change_callback.cc
@@ -48,7 +48,9 @@ FolderPtrVector FoldersChangeCallback::filterFolders(
         tizen::AbstractFilterPtr filter,
         const FolderPtrVector& source_folders)
 {
+    LoggerD("Entered");
     if (filter) {
+        LoggerD("filter pointer is valid");
         FolderPtrVector filtered_folders;
         FolderPtrVector::const_iterator it = source_folders.begin();
         FolderPtrVector::const_iterator end_it = source_folders.end();

diff --git a/src/messaging/message.cc b/src/messaging/message.cc
index 797c527f50f3b565cef414dbe9a307a74d6714f1..129d03d442a9327f4b0cca99956dbf0c758817db 100644 (file)
--- a/src/messaging/message.cc
+++ b/src/messaging/message.cc
@@ -328,6 +328,7 @@ bool Message::is_service_is_set() const
 
 std::string Message::convertEmailRecipients(const std::vector<std::string> &recipients)
 {
+    LoggerD("Entered");
     std::string address = "";
     unsigned size = recipients.size();
     for (unsigned i=0; i<size; ++i)
@@ -340,6 +341,7 @@ std::string Message::convertEmailRecipients(const std::vector<std::string> &reci
 
 PlatformResult saveToTempFile(const std::string &data, std::string* file_name)
 {
+    LoggerD("Entered");
     char buf[] = "XXXXXX";
     int res = 0;
 
@@ -440,6 +442,7 @@ PlatformResult copyFileToTemp(const std::string& sourcePath, std::string* result
 
 PlatformResult removeDirFromTemp(const std::string& dirPath)
 {
+    LoggerD("Entered");
     if(EINA_TRUE != ecore_file_recursive_rm(dirPath.c_str())) {
       return PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error while deleting temp directory.");
     }
@@ -449,6 +452,7 @@ PlatformResult removeDirFromTemp(const std::string& dirPath)
 PlatformResult Message::convertPlatformEmail(std::shared_ptr<Message> message,
                                                  email_mail_data_t** result_mail_data)
 {
+    LoggerD("Entered");
     email_mail_data_t* mail_data = nullptr;
     if(EMAIL != message->getType()) {
         LoggerE("Invalid type");
@@ -489,6 +493,7 @@ PlatformResult Message::convertPlatformEmail(std::shared_ptr<Message> message,
     }
 
     if(message->getBody()) {
+        LoggerD("get Body success");
         std::shared_ptr<MessageBody> body;
         body = message->getBody();
         if(!body->getPlainBody().empty()) {
@@ -546,6 +551,7 @@ PlatformResult Message::convertPlatformEmail(std::shared_ptr<Message> message,
 PlatformResult addSingleEmailAttachment(std::shared_ptr<Message> message,
         std::shared_ptr<MessageAttachment> att, AttachmentType attType)
 {
+    LoggerD("Entered");
     std::string dirPath = "";
     PlatformResult ret = copyFileToTemp(att->getFilePath(), &dirPath);
     if (ret.IsError()) return ret;
@@ -662,6 +668,7 @@ PlatformResult Message::addEmailAttachments(std::shared_ptr<Message> message)
 PlatformResult Message::addSMSRecipientsToStruct(const std::vector<std::string> &recipients,
         msg_struct_t &msg)
 {
+    LoggerD("Entered");
     const unsigned size = recipients.size();
     for (unsigned int i = 0; i < size; ++i) {
         char *address = const_cast<char *>(recipients.at(i).c_str());
@@ -688,6 +695,7 @@ PlatformResult Message::addSMSRecipientsToStruct(const std::vector<std::string>
 PlatformResult Message::addMMSRecipientsToStruct(const std::vector<std::string> &recipients,
         msg_struct_t &msg, int type)
 {
+    LoggerD("Entered");
     const unsigned size = recipients.size();
     for (unsigned int i = 0; i < size; ++i) {
 
@@ -1043,6 +1051,7 @@ PlatformResult Message::convertPlatformShortMessageToStruct(Message* message,
 
 std::string Message::getShortMsgSenderFromStruct(msg_struct_t &msg)
 {
+    LoggerD("Entered");
     msg_list_handle_t addr_list = NULL;
     msg_get_list_handle(msg, MSG_MESSAGE_ADDR_LIST_HND, (void **)&addr_list);
 
@@ -1078,6 +1087,7 @@ std::string Message::getShortMsgSenderFromStruct(msg_struct_t &msg)
 PlatformResult Message::getSMSRecipientsFromStruct(msg_struct_t &msg,
                                                    std::vector<std::string>* result_address)
 {
+    LoggerD("Entered");
     std::vector<std::string> address;
     msg_list_handle_t addr_list = NULL;
     if (MSG_SUCCESS
@@ -1104,6 +1114,7 @@ PlatformResult Message::getSMSRecipientsFromStruct(msg_struct_t &msg,
 PlatformResult Message::getMMSRecipientsFromStruct(msg_struct_t &msg,
         int type, std::vector<std::string>* result_address)
 {
+    LoggerD("Entered");
     std::vector<std::string> address;
     msg_list_handle_t addr_list = NULL;
     if (MSG_SUCCESS
@@ -1312,6 +1323,7 @@ PlatformResult Message::setMMSBodyAndAttachmentsFromStruct(Message* message,
 }
 
 PlatformResult Message::convertPlatformShortMessageToObject(msg_struct_t msg, Message** result_message){
+    LoggerD("Entered");
     Message *message = nullptr;
     int infoInt;
     bool infoBool;
@@ -1330,6 +1342,7 @@ PlatformResult Message::convertPlatformShortMessageToObject(msg_struct_t msg, Me
         std::vector<std::string> recp_list;
         PlatformResult ret = message->getSMSRecipientsFromStruct(msg, &recp_list);
         if (ret.IsError()) {
+          LoggerE("failed to get SMS recipients from struct");
           if (message) delete message;
           return ret;
         }
@@ -1377,18 +1390,21 @@ PlatformResult Message::convertPlatformShortMessageToObject(msg_struct_t msg, Me
         std::vector<std::string> recp_list;
         PlatformResult ret = getMMSRecipientsFromStruct(msg, MSG_RECIPIENTS_TYPE_TO, &recp_list);
         if (ret.IsError()) {
+          LoggerE("failed to get MMS recipients from struct");
           if (message) delete message;
           return ret;
         }
         message->setTO(recp_list);
         ret = getMMSRecipientsFromStruct(msg, MSG_RECIPIENTS_TYPE_CC, &recp_list);
         if (ret.IsError()) {
+          LoggerE("failed to get MMS recipients from struct");
           if (message) delete message;
           return ret;
         }
         message->setCC(recp_list);
         ret = getMMSRecipientsFromStruct(msg, MSG_RECIPIENTS_TYPE_BCC, &recp_list);
         if (ret.IsError()) {
+          LoggerE("failed to get MMS recipients from struct");
           if (message) delete message;
           return ret;
         }
@@ -1400,6 +1416,7 @@ PlatformResult Message::convertPlatformShortMessageToObject(msg_struct_t msg, Me
         //set attachments
         ret = setMMSBodyAndAttachmentsFromStruct(message, msg);
         if (ret.IsError()) {
+          LoggerE("failed to set body attachments from struct");
           if (message) delete message;
           return ret;
         }
@@ -1493,6 +1510,7 @@ PlatformResult Message::convertPlatformShortMessageToObject(msg_struct_t msg, Me
 }
 
 PlatformResult Message::findShortMessageById(const int id, MessagePtr* message) {
+    LoggerD("Entered");
     msg_struct_t msg;
     PlatformResult ret = ShortMsgManager::getInstance().getMessage(id, &msg);
     if (ret.IsError()) {
@@ -1511,6 +1529,7 @@ PlatformResult Message::findShortMessageById(const int id, MessagePtr* message)
 std::vector<std::string> Message::split(const std::string& input,
         char delimiter)
 {
+    LoggerD("Entered");
     std::vector<std::string> ret;
     std::stringstream stream(input);
     std::string item;
@@ -1522,6 +1541,7 @@ std::vector<std::string> Message::split(const std::string& input,
 
 std::vector<std::string> Message::getEmailRecipientsFromStruct(const char *recipients)
 {
+    LoggerD("Entered");
     std::vector<std::string> tmp = Message::split(recipients, ';');
     for (std::vector<std::string>::iterator it = tmp.begin(); it != tmp.end(); ++it) {
         *it = MessagingUtil::ltrim(*it);
@@ -1545,7 +1565,7 @@ std::vector<std::string> Message::getEmailRecipientsFromStruct(const char *recip
 std::shared_ptr<MessageBody> Message::convertEmailToMessageBody(
         email_mail_data_t& mail)
 {
-    LoggerD("Enter");
+    LoggerD("Entered");
     std::shared_ptr<MessageBody> body (new MessageBody());
     body->updateBody(mail);
     return body;
@@ -1554,7 +1574,7 @@ std::shared_ptr<MessageBody> Message::convertEmailToMessageBody(
 PlatformResult Message::convertEmailToMessageAttachment(email_mail_data_t& mail,
                                                         AttachmentPtrVector* att)
 {
-  LoggerD("Enter");
+  LoggerD("Entered");
   email_attachment_data_t* attachment = NULL;
   int attachmentCount = 0;
 
@@ -1577,7 +1597,7 @@ PlatformResult Message::convertEmailToMessageAttachment(email_mail_data_t& mail,
 PlatformResult Message::convertPlatformEmailToObject(
         email_mail_data_t& mail, std::shared_ptr<Message>* result)
 {
-    LoggerD("Enter");
+    LoggerD("Entered");
     Message* message = new MessageEmail();
     PlatformResult ret = message->updateEmailMessage(mail);
     if (ret.IsError()) {

diff --git a/src/messaging/message_attachment.cc b/src/messaging/message_attachment.cc
index f8460c8addeda547a68e8a4982743ade959dfbec..2d15b4861097063335856defb10d49518a95d456 100755 (executable)
--- a/src/messaging/message_attachment.cc
+++ b/src/messaging/message_attachment.cc
@@ -112,6 +112,7 @@ std::string MessageAttachment::getFilePath()
 
 std::string MessageAttachment::getShortFileName() const
 {
+    LoggerD("Entered");
     if (!m_isFilePathSet) {
         return "";
     }
@@ -143,6 +144,7 @@ const char PATH_SEPARATOR = '/';
 
 void MessageAttachment::setFilePath(const std::string &value)
 {
+    LoggerD("Entered");
     std::string tmp = value;
     // change to lower case
     for (int i = 0; i < tmp.length() && i < 4; i++) {
@@ -193,6 +195,7 @@ bool MessageAttachment::isSaved() const
 
 std::map<unsigned int, std::string>& MessageAttachment::initializeMIMETypeEnumToStringMap()
 {
+    LoggerD("Entered");
     static std::map<unsigned int, std::string> enumToString;
     //0
     enumToString[MIME_ASTERISK] = "*/*";
@@ -384,6 +387,7 @@ std::map<unsigned int, std::string>& MessageAttachment::initializeMIMETypeEnumTo
 
 std::map<std::string, unsigned int>& MessageAttachment::initializeMIMETypeStringToEnumMap()
 {
+    LoggerD("Entered");
     static std::map<std::string, unsigned int> stringToEnum;
     //0
     stringToEnum["*/*"] = MIME_ASTERISK;
@@ -576,6 +580,7 @@ std::map<std::string, unsigned int>& MessageAttachment::initializeMIMETypeString
 
 unsigned int MessageAttachment::MIMETypeStringToEnum(std::string str)
 {
+    LoggerD("Entered");
     std::map<std::string, unsigned int>::iterator it = MIMETypeStringToEnumMap.find(str);
     if (it != MIMETypeStringToEnumMap.end()) {
         return it->second;
@@ -585,6 +590,7 @@ unsigned int MessageAttachment::MIMETypeStringToEnum(std::string str)
 
 std::string MessageAttachment::MIMETypeEnumToString(unsigned int num)
 {
+    LoggerD("Entered");
     std::map<unsigned int, std::string>::iterator it = MIMETypeEnumToStringMap.find(num);
     if (it != MIMETypeEnumToStringMap.end()) {
         return it->second;
@@ -594,6 +600,7 @@ std::string MessageAttachment::MIMETypeEnumToString(unsigned int num)
 
 void MessageAttachment::updateWithAttachmentData(const email_attachment_data_t& attachment_data)
 {
+    LoggerD("Entered");
     setId(attachment_data.attachment_id);
     setMessageId(attachment_data.mail_id);
     if (attachment_data.attachment_mime_type) {

diff --git a/src/messaging/message_body.cc b/src/messaging/message_body.cc
index 36ad740e1214447126551af80d268f43b68f28e9..2ddc10bd5b0733a709c570f4c2d338184cb0066f 100644 (file)
--- a/src/messaging/message_body.cc
+++ b/src/messaging/message_body.cc
@@ -20,10 +20,12 @@ MessageBody::MessageBody() : m_messageId(1),
                              m_plainBody(""),
                              m_htmlBody("")
 {
+    LoggerD("Entered");
 }
 
 MessageBody::~MessageBody()
 {
+    LoggerD("Entered");
 }
 
 // messageId
@@ -96,7 +98,7 @@ bool MessageBody::is_message_id_set() const
 
 PlatformResult MessageBody::updateBody(email_mail_data_t& mail)
 {
-    LoggerD("Enter");
+    LoggerD("Entered");
     setMessageId(mail.mail_id);
     setLoaded(mail.body_download_status);
 

diff --git a/src/messaging/message_callback_user_data.cc b/src/messaging/message_callback_user_data.cc
index 7483214be35a63990739d756ea8f245dd5832652..88e375afee30107ac6f1014dae1ab99a7a643138 100644 (file)
--- a/src/messaging/message_callback_user_data.cc
+++ b/src/messaging/message_callback_user_data.cc
@@ -13,9 +13,11 @@ MessageCallbackUserData::MessageCallbackUserData(PostQueue& queue):
         m_is_error(false),
         queue_(queue)
 {
+    LoggerD("Entered");
 }
 
 MessageCallbackUserData::~MessageCallbackUserData() {
+    LoggerD("Entered");
 }
 
 void MessageCallbackUserData::setMessage(std::shared_ptr<Message> message) {
@@ -38,8 +40,10 @@ int MessageCallbackUserData::getAccountId() const
 void MessageCallbackUserData::setError(const std::string& err_name,
         const std::string& err_message)
 {
+    LoggerD("Entered");
     // keep only first error in chain
     if (!m_is_error) {
+        LoggerD("Error has not been set yet");
         picojson::object& obj = m_json->get<picojson::object>();
         obj[JSON_ACTION] = picojson::value(JSON_CALLBACK_ERROR);
         auto objData = picojson::object();
@@ -57,8 +61,10 @@ void MessageCallbackUserData::setError(const std::string& err_name,
 
 void MessageCallbackUserData::setError(const common::PlatformResult& error)
 {
+  LoggerD("Entered");
   // keep only first error in chain
   if (!m_is_error) {
+    LoggerD("Error has not been set yet");
     m_is_error = true;
     picojson::object& obj = m_json->get<picojson::object>();
     obj[JSON_ACTION] = picojson::value(JSON_CALLBACK_ERROR);

diff --git a/src/messaging/message_conversation.cc b/src/messaging/message_conversation.cc
index 5dcecbf885fdd0353b2c75b485e97d77290c3f17..2ff1a6c836b001d74aec555524a3bda4e7bccba5 100644 (file)
--- a/src/messaging/message_conversation.cc
+++ b/src/messaging/message_conversation.cc
@@ -107,6 +107,7 @@ int MessageConversation::getLastMessageId() const
 PlatformResult MessageConversation::convertMsgConversationToObject(
         unsigned int threadId, msg_handle_t handle, std::shared_ptr<MessageConversation>* result)
 {
+    LoggerD("Entered");
     std::shared_ptr<MessageConversation> conversation (new MessageConversation());
 
     msg_struct_t msgInfo = NULL;
@@ -261,6 +262,7 @@ PlatformResult MessageConversation::convertMsgConversationToObject(
 PlatformResult MessageConversation::convertEmailConversationToObject(
         unsigned int threadId, std::shared_ptr<MessageConversation>* result)
 {
+    LoggerD("Entered");
     std::shared_ptr<MessageConversation> conversation (new MessageConversation());
 
     email_mail_list_item_t *resultMail = NULL;

diff --git a/src/messaging/message_email.cc b/src/messaging/message_email.cc
index f5c56515bbb1f7c447aa008d22f04ee0e819c22f..5388dcf6e5a5c58dc1d0de81e87fd28e159c23d3 100644 (file)
--- a/src/messaging/message_email.cc
+++ b/src/messaging/message_email.cc
@@ -80,7 +80,7 @@ bool MessageEmail::getHasAttachment() const
 
 PlatformResult MessageEmail::updateEmailMessage(email_mail_data_t& mail)
 {
-    LoggerD("Enter");
+    LoggerD("Entered");
 
     std::vector<std::string> recp_list;
     setId(mail.mail_id);
@@ -117,7 +117,10 @@ PlatformResult MessageEmail::updateEmailMessage(email_mail_data_t& mail)
     }
 
     PlatformResult ret = getBody()->updateBody(mail);
-    if (ret.IsError()) return ret;
+    if (ret.IsError()) {
+        LoggerE("Update Email body failed");
+        return ret;
+    }
 
     if (mail.mail_id != mail.thread_id) {
         setInResponseTo(mail.thread_id);

diff --git a/src/messaging/message_folder.cc b/src/messaging/message_folder.cc
index 22f03934a38d0e5a8e76cd9945d137c0eed950c0..7a778d6dc12dd29c5662e0ec9ee1550e7604ef5a 100644 (file)
--- a/src/messaging/message_folder.cc
+++ b/src/messaging/message_folder.cc
@@ -29,10 +29,12 @@ MessageFolder::MessageFolder(
     m_type(type),
     m_synchronizable(synchronizable)
 {
+    LoggerD("Entered");
 }
 
 MessageFolder::MessageFolder(email_mailbox_t mailbox)
 {
+    LoggerD("Entered");
     m_id = std::to_string(mailbox.mailbox_id);
     m_parent_id_set = false;
     m_service_id = std::to_string(mailbox.account_id);
@@ -112,6 +114,7 @@ void MessageFolder::setSynchronizable(const bool &value)
 MessageFolderType MessageFolder::convertPlatformFolderType(
         email_mailbox_type_e folderType)
 {
+    LoggerD("Entered");
     switch (folderType) {
         case email_mailbox_type_e::EMAIL_MAILBOX_TYPE_INBOX:
             return MessageFolderType::MESSAGE_FOLDER_TYPE_INBOX;

diff --git a/src/messaging/message_mms.cc b/src/messaging/message_mms.cc
index 3c26554669c3f22632a5e013068cda471abfe54a..ce8f6541c3c13511b148080ae2d1d3b2994bd888 100644 (file)
--- a/src/messaging/message_mms.cc
+++ b/src/messaging/message_mms.cc
@@ -41,6 +41,7 @@ MessageMMS::~MessageMMS()
 // *** overrided methods
 void MessageMMS::setCC(std::vector<std::string> &cc)
 {
+    LoggerD("Entered");
     // CC recipient's format validation should be done by email service
     m_cc = cc;
 
@@ -52,6 +53,7 @@ void MessageMMS::setCC(std::vector<std::string> &cc)
 
 void MessageMMS::setBCC(std::vector<std::string> &bcc)
 {
+    LoggerD("Entered");
     // BCC recipient's format validation should be done by email service
     m_bcc = bcc;
 
@@ -68,6 +70,7 @@ void MessageMMS::setSubject(std::string subject)
 
 void MessageMMS::setMessageAttachments(AttachmentPtrVector &attachments)
 {
+    LoggerD("Entered");
     m_attachments = attachments;
 
     m_has_attachment = true;

diff --git a/src/messaging/message_service.cc b/src/messaging/message_service.cc
index 7d6c041802d10d76a29254322adf38ed676ef0b7..0397dc7b9e94b4308f5b3ddd1f2dee6a33c40394 100644 (file)
--- a/src/messaging/message_service.cc
+++ b/src/messaging/message_service.cc
@@ -69,8 +69,10 @@ const std::vector<std::string>& MessageRecipientsCallbackData::getMessageRecipie
 void MessageRecipientsCallbackData::setError(const std::string& err_name,
         const std::string& err_message)
 {
+    LoggerD("Entered");
     // keep only first error in chain
     if (!m_is_error) {
+        LoggerD("Error has not been set yet");
         m_is_error = true;
 
         picojson::object& obj = m_json->get<picojson::object>();
@@ -86,8 +88,10 @@ void MessageRecipientsCallbackData::setError(const std::string& err_name,
 
 void MessageRecipientsCallbackData::setError(const PlatformResult& error)
 {
+  LoggerD("Entered");
   // keep only first error in chain
   if (!m_is_error) {
+    LoggerD("Error has not been set yet");
     m_is_error = true;
 
     picojson::object& obj = m_json->get<picojson::object>();
@@ -118,6 +122,7 @@ int MessageRecipientsCallbackData::getAccountId() const
 bool MessageRecipientsCallbackData::setSimIndex(
     int sim_index)
 {
+    LoggerD("Entered");
     char **cp_list = tel_get_cp_name_list();
     int sim_count = 0;
     if (cp_list) {
@@ -182,8 +187,10 @@ BaseMessageServiceCallbackData::~BaseMessageServiceCallbackData()
 void BaseMessageServiceCallbackData::setError(const std::string& err_name,
         const std::string& err_message)
 {
+    LoggerD("Entered");
     // keep only first error in chain
     if (!m_is_error) {
+        LoggerD("Error has not been set yet");
         m_is_error = true;
 
         picojson::object& obj = m_json->get<picojson::object>();
@@ -198,8 +205,10 @@ void BaseMessageServiceCallbackData::setError(const std::string& err_name,
 
 void BaseMessageServiceCallbackData::setError(const PlatformResult& error)
 {
+  LoggerD("Entered");
   // keep only first error in chain
   if (!m_is_error) {
+    LoggerD("Error has not been set yet");
     m_is_error = true;
 
     picojson::object& obj = m_json->get<picojson::object>();
@@ -407,6 +416,7 @@ MessageService::~MessageService()
 
 picojson::object MessageService::toPicoJS() const
 {
+    LoggerD("Entered");
     picojson::object picojs = picojson::object();
     picojs[JSON_SERVICE_ID] = picojson::value(std::to_string(m_id));
     picojs[JSON_SERVICE_TYPE] = picojson::value(getMsgServiceTypeString());

diff --git a/src/messaging/message_service_short_msg.cc b/src/messaging/message_service_short_msg.cc
index fe7806770499445cfeddf971cd051a92ad6bdcd8..b3e367c8bf21b5c014f6a63cc564335f43863db0 100644 (file)
--- a/src/messaging/message_service_short_msg.cc
+++ b/src/messaging/message_service_short_msg.cc
@@ -54,6 +54,7 @@ static gboolean sendMessageThread(void* data)
 
 PlatformResult MessageServiceShortMsg::sendMessage(MessageRecipientsCallbackData *callback)
 {
+    LoggerD("Entered");
     if (!callback) {
         LoggerE("Callback is null");
         return PlatformResult(ErrorCode::UNKNOWN_ERR, "Callback is null");
@@ -145,6 +146,7 @@ static gboolean loadMessageBodyTask(void* data)
 
 PlatformResult MessageServiceShortMsg::loadMessageBody(MessageBodyCallbackData *callback)
 {
+    LoggerD("Entered");
     if (!callback) {
         LoggerE("Callback is null");
         return PlatformResult(ErrorCode::UNKNOWN_ERR, "Callback is null");

diff --git a/src/messaging/messages_callback_user_data.cc b/src/messaging/messages_callback_user_data.cc
index cdce5dc0ad0b87a244771e62efd739d6442aae31..4b07cc3140d5b84e82bb05f56a38518eee60c1a6 100644 (file)
--- a/src/messaging/messages_callback_user_data.cc
+++ b/src/messaging/messages_callback_user_data.cc
@@ -13,6 +13,7 @@ MessagesCallbackUserData::MessagesCallbackUserData(PostQueue& queue):
         m_service_type(MessageType::UNDEFINED),
         queue_(queue)
 {
+    LoggerD("Entered");
 }
 
 MessagesCallbackUserData::MessagesCallbackUserData(long cid, PostQueue& queue, bool keep):
@@ -21,6 +22,7 @@ MessagesCallbackUserData::MessagesCallbackUserData(long cid, PostQueue& queue, b
         m_service_type(MessageType::UNDEFINED),
         queue_(queue)
 {
+    LoggerD("Entered");
     auto json = std::shared_ptr<picojson::value>(new picojson::value(picojson::object()));
     picojson::object& o = json->get<picojson::object>();
     o[JSON_CALLBACK_ID] = picojson::value(static_cast<double>(cid));
@@ -29,10 +31,12 @@ MessagesCallbackUserData::MessagesCallbackUserData(long cid, PostQueue& queue, b
 }
 
 MessagesCallbackUserData::~MessagesCallbackUserData() {
+    LoggerD("Entered");
 }
 
 void MessagesCallbackUserData::addMessage(std::shared_ptr<Message> msg)
 {
+    LoggerD("Entered");
     m_messages.push_back(msg);
 }
 
@@ -44,8 +48,10 @@ std::vector<std::shared_ptr<Message>> MessagesCallbackUserData::getMessages() co
 void MessagesCallbackUserData::setError(const std::string& err_name,
         const std::string& err_message)
 {
+    LoggerD("Entered");
     // keep only first error in chain
     if (!m_is_error) {
+        LoggerD("Error has not been set yet");
         picojson::object& obj = m_json->get<picojson::object>();
         obj[JSON_ACTION] = picojson::value(JSON_CALLBACK_ERROR);
         auto objData = picojson::object();
@@ -65,6 +71,7 @@ void MessagesCallbackUserData::SetError(const common::PlatformResult& error)
 {
   // keep only first error in chain
   if (!m_is_error) {
+    LoggerD("Error has not been set yet");
     m_is_error = true;
     picojson::object& obj = m_json->get<picojson::object>();
     obj[JSON_ACTION] = picojson::value(JSON_CALLBACK_ERROR);

diff --git a/src/messaging/messages_change_callback.cc b/src/messaging/messages_change_callback.cc
index 161fc51fb2f09bb00833be3929d350b44e5af82d..6b30e9b8d76d5e568b8974f3b9d4d8af060ef3f7 100644 (file)
--- a/src/messaging/messages_change_callback.cc
+++ b/src/messaging/messages_change_callback.cc
@@ -22,6 +22,7 @@ namespace {
 std::string limitedString(const std::string& src,
                           const size_t max_len = 40)
 {
+    LoggerD("Entered");
     if(src.length() > max_len) {
         return src.substr(0,max_len);
     } else {
@@ -94,6 +95,7 @@ MessagePtrVector MessagesChangeCallback::filterMessages(
         return filtered_messages;
     }
     else {
+        LoggerD("Abstract filter pointer is null");
         return source_messages;
     }
 }

diff --git a/src/messaging/messaging_database_manager.cc b/src/messaging/messaging_database_manager.cc
index 21360cd65ab2178e6f18f261b0e463c4023c7e46..e9a219f2616f176fd707c746d866a919af1075cd 100755 (executable)
--- a/src/messaging/messaging_database_manager.cc
+++ b/src/messaging/messaging_database_manager.cc
@@ -48,6 +48,7 @@ AttributeInfo::AttributeInfo() :
         sql_type(UNDEFINED_TYPE),
         any_type(PrimitiveType_NoType)
 {
+    LoggerD("Entered");
 }
 
 AttributeInfo::AttributeInfo(const std::string& in_sql_name,
@@ -57,6 +58,7 @@ AttributeInfo::AttributeInfo(const std::string& in_sql_name,
         sql_type(in_sql_type),
         any_type(in_any_type)
 {
+    LoggerD("Entered");
 }
 
 AttributeInfo::AttributeInfo(const AttributeInfo& other) :
@@ -64,6 +66,7 @@ AttributeInfo::AttributeInfo(const AttributeInfo& other) :
         sql_type(other.sql_type),
         any_type(other.any_type)
 {
+    LoggerD("Entered");
 }
 
 AttributeInfo& AttributeInfo::operator=(const AttributeInfo& other)
@@ -76,6 +79,7 @@ AttributeInfo& AttributeInfo::operator=(const AttributeInfo& other)
 
 MessagingDatabaseManager::MessagingDatabaseManager()
 {
+    LoggerD("Entered");
 // Attributes map for short messages ==========================================
     m_msg_attr_map.insert(std::make_pair("id",
             AttributeInfo("A.MSG_ID", INTEGER, PrimitiveType_String)));
@@ -185,11 +189,12 @@ MessagingDatabaseManager::MessagingDatabaseManager()
 
 MessagingDatabaseManager::~MessagingDatabaseManager()
 {
-
+    LoggerD("Entered");
 }
 
 MessagingDatabaseManager& MessagingDatabaseManager::getInstance()
 {
+    LoggerD("Entered");
     static MessagingDatabaseManager instance;
     return instance;
 }
@@ -302,6 +307,7 @@ int MessagingDatabaseManager::cellToInt(char** array, int cellId)
 std::string MessagingDatabaseManager::getMatchString(tizen::AnyPtr match_value,
         const PrimitiveType type) const
 {
+    LoggerD("Entered");
     if(!match_value) {
         LoggerD("Warning: match value is NULL");
         return std::string();
@@ -389,6 +395,7 @@ PlatformResult MessagingDatabaseManager::getAttributeFilterQuery(AbstractFilterP
             match_value.c_str());
 
     if ("serviceId" == attribute_name) {
+        LoggerD("Attribute name: serviceId");
 
         int i_matchValue;
         std::istringstream iss(match_value);
@@ -408,6 +415,7 @@ PlatformResult MessagingDatabaseManager::getAttributeFilterQuery(AbstractFilterP
         }
     }
     else if ("type" == attribute_name) {
+        LoggerD("Attribute name: type");
         if ("messaging.sms" == match_value && MessageType::SMS == msgType) {
             sqlQuery << "= " << msgType;
         } else if ("messaging.mms" == match_value && MessageType::MMS == msgType) {
@@ -425,6 +433,7 @@ PlatformResult MessagingDatabaseManager::getAttributeFilterQuery(AbstractFilterP
         }
     }
     else if ("isRead" == attribute_name || "hasAttachment" == attribute_name) {
+        LoggerD("Attribute name: isRead or hasAttachment");
         if (attr_filter->getMatchValue()->toBool()) {
             sqlQuery << "> 0";
         } else {
@@ -432,6 +441,7 @@ PlatformResult MessagingDatabaseManager::getAttributeFilterQuery(AbstractFilterP
         }
     }
     else if ("isHighPriority" == attribute_name) {
+        LoggerD("Attribute name: isHighPriority");
         if (attr_filter->getMatchValue()->toBool()) {
             sqlQuery << "= ";
         } else {
@@ -445,6 +455,7 @@ PlatformResult MessagingDatabaseManager::getAttributeFilterQuery(AbstractFilterP
         }
     }
     else {
+        LoggerD("Another attribute");
         // Addresses which are stored in database can have different form than in filters
         if (MessageType::EMAIL == msgType && ("from" == attribute_name ||
                 "to" == attribute_name || "cc" == attribute_name ||
@@ -590,21 +601,30 @@ PlatformResult MessagingDatabaseManager::getCompositeFilterQuery(AbstractFilterP
             case ATTRIBUTE_FILTER: {
               std::string query;
               PlatformResult ret = getAttributeFilterQuery(filters_arr[i], attribute_map, msg_type, &query);
-              if (ret.IsError()) return ret;
+              if (ret.IsError()) {
+                  LoggerE("Get attribute filter query failed (%s)", ret.message().c_str());
+                  return ret;
+              }
               sql_query << query;
               break;
             }
             case ATTRIBUTE_RANGE_FILTER: {
               std::string query;
               PlatformResult ret = getAttributeRangeFilterQuery(filters_arr[i], attribute_map, msg_type, &query);
-              if (ret.IsError()) return ret;
+              if (ret.IsError()) {
+                  LoggerE("Get attribute filter range filter query failed (%s)", ret.message().c_str());
+                  return ret;
+              }
               sql_query << query;
               break;
             }
             case COMPOSITE_FILTER: {
               std::string query;
               PlatformResult ret = getCompositeFilterQuery(filters_arr[i], attribute_map, msg_type, &query);
-              if (ret.IsError()) return ret;
+              if (ret.IsError()) {
+                  LoggerE("Get composite filter query failed (%s)", ret.message().c_str());
+                  return ret;
+              }
               sql_query << query;
               break;
             }
@@ -648,21 +668,30 @@ PlatformResult MessagingDatabaseManager::addFilters(AbstractFilterPtr filter,
             case ATTRIBUTE_FILTER: {
               std::string query;
               PlatformResult ret = getAttributeFilterQuery(filter, attribute_map, msg_type, &query);
-              if (ret.IsError()) return ret;
+              if (ret.IsError()) {
+                  LoggerE("Get attribute filter query failed (%s)", ret.message().c_str());
+                  return ret;
+              }
               sql_query << query;
               break;
             }
             case ATTRIBUTE_RANGE_FILTER: {
               std::string query;
               PlatformResult ret = getAttributeRangeFilterQuery(filter, attribute_map, msg_type, &query);
-              if (ret.IsError()) return ret;
+              if (ret.IsError()) {
+                  LoggerE("Get attribute range filter query failed (%s)", ret.message().c_str());
+                  return ret;
+              }
               sql_query << query;
               break;
             }
             case COMPOSITE_FILTER : {
               std::string query;
               PlatformResult ret = getCompositeFilterQuery(filter, attribute_map, msg_type, &query);
-              if (ret.IsError()) return ret;
+              if (ret.IsError()) {
+                  LoggerE("Get composite filter query failed (%s)", ret.message().c_str());
+                  return ret;
+              }
               sql_query << query;
               break;
             }
@@ -742,13 +771,17 @@ PlatformResult MessagingDatabaseManager::findShortMessages(
     std::string filters_query;
     PlatformResult ret = addFilters(filter, sortMode, limit, offset, m_msg_attr_map,
                                     msgType, &filters_query);
-    if (ret.IsError()) return ret;
+    if (ret.IsError()) {
+        LoggerE("Add filters failed (%s)", ret.message().c_str());
+        return ret;
+    }
     sqlQuery << filters_query;
     LoggerD("%s", sqlQuery.str().c_str());
 
     // Getting results from database
     msg_error_t err = getTable(sqlQuery.str(), &results, &resultsCount);
     if (MSG_SUCCESS != err) {
+        LoggerE("Getting results from database failed [%d]", err);
         freeTable(&results);
         return PlatformResult(ErrorCode::UNKNOWN_ERR,
                               "Error while getting data from database.");
@@ -783,7 +816,10 @@ PlatformResult MessagingDatabaseManager::findEmails(
     std::string filters_query;
     PlatformResult ret = addFilters(filter, sortMode, limit, offset,
                                     m_email_attr_map, msgType, &filters_query);
-    if (ret.IsError()) return ret;
+    if (ret.IsError()) {
+        LoggerE("Add filters failed (%s)", ret.message().c_str());
+        return ret;
+    }
     sqlWhereClause << "WHERE "
             << m_email_attr_map["serviceId"].sql_name << " = " << accountId << " AND "
             << filters_query;
@@ -836,13 +872,17 @@ PlatformResult MessagingDatabaseManager::findShortMessageConversations(
     std::string filters_query;
     PlatformResult ret = addFilters(filter, sortMode, limit, offset, m_msg_conv_attr_map,
                                     msgType, &filters_query);
-    if (ret.IsError()) return ret;
+    if (ret.IsError()) {
+        LoggerE("Add filters failed (%s)", ret.message().c_str());
+        return ret;
+    }
     sqlQuery << filters_query;
     LoggerD("%s", sqlQuery.str().c_str());
 
     // Getting results from database
     msg_error_t err = getTable(sqlQuery.str(), &results, &resultsCount);
     if (MSG_SUCCESS != err) {
+        LoggerE("Getting results from database failed [%d]", err);
         freeTable(&results);
         return PlatformResult(ErrorCode::UNKNOWN_ERR,
                               "Error while getting data from database.");
@@ -879,7 +919,10 @@ PlatformResult MessagingDatabaseManager::findEmailConversations(
     std::string filters_query;
     PlatformResult ret = addFilters(filter, sortMode, limit, offset, m_email_conv_attr_map,
                                     msgType, &filters_query);
-    if (ret.IsError()) return ret;
+    if (ret.IsError()) {
+        LoggerE("Add filters failed (%s)", ret.message().c_str());
+        return ret;
+    }
     sqlWhereClause << "WHERE "
             << m_email_conv_attr_map["serviceId"].sql_name << " = " << accountId << " AND "
             << filters_query;

diff --git a/src/messaging/messaging_extension.cc b/src/messaging/messaging_extension.cc
index 33c3d90c61160d20ab12f32deb2db91871852334..e30e175761ceac2507156885bbdf9174c17dcd2d 100644 (file)
--- a/src/messaging/messaging_extension.cc
+++ b/src/messaging/messaging_extension.cc
@@ -22,6 +22,7 @@ common::Extension* CreateExtension() {
 }
 
 MessagingExtension::MessagingExtension() {
+  LoggerD("Entered");
   SetExtensionName(kMessaging);
   SetJavaScriptAPI(kSource_messaging_api);
   const char* entry_points[] = {
@@ -32,7 +33,9 @@ MessagingExtension::MessagingExtension() {
   SetExtraJSEntryPoints(entry_points);
 }
 
-MessagingExtension::~MessagingExtension() {}
+MessagingExtension::~MessagingExtension() {
+  LoggerD("Entered");
+}
 
 common::Instance* MessagingExtension::CreateInstance() {
   LoggerD("Entered");

diff --git a/src/messaging/messaging_instance.cc b/src/messaging/messaging_instance.cc
index 47f48f96c7d34fe387f335701c192b0f232ad635..fd96caae7e10fe82b1fe8ef1243f8ff67f497d7a 100644 (file)
--- a/src/messaging/messaging_instance.cc
+++ b/src/messaging/messaging_instance.cc
@@ -159,6 +159,7 @@ MessagingInstance::~MessagingInstance()
 }
 
 #define POST_AND_RETURN(ret, json, obj, action) \
+    LoggerE("Error occured: (%s)", ret.message().c_str()); \
     picojson::object args; \
     ReportError(ret, &args); \
     obj[JSON_DATA] = picojson::value(args); \

diff --git a/src/messaging/messaging_manager.cc b/src/messaging/messaging_manager.cc
index dec42556d8d02d3f15899b9fa292244aacfff1cb..fd529e3206b7fe0b39d31f6cbb9e7c19b3fea311 100755 (executable)
--- a/src/messaging/messaging_manager.cc
+++ b/src/messaging/messaging_manager.cc
@@ -37,6 +37,7 @@ MsgManagerCallbackData::MsgManagerCallbackData(MessagingInstance& instance):
     sms_service(nullptr),
     mms_service(nullptr),
     instance_(instance) {
+    LoggerD("Entered");
 }
 
 MessagingManager::MessagingManager(MessagingInstance& instance):

diff --git a/src/messaging/messaging_util.cc b/src/messaging/messaging_util.cc
index 06f934067a5fe04d99a14b2fcdb1c860082bf380..84c221d83787589c56589d43c49298cca0cdf91d 100644 (file)
--- a/src/messaging/messaging_util.cc
+++ b/src/messaging/messaging_util.cc
@@ -143,6 +143,7 @@ const std::string FOLDER_TYPE_SENTBOX = "SENTBOX";
 
 std::string MessagingUtil::messageFolderTypeToString(MessageFolderType type)
 {
+    LoggerD("Entered");
     switch(type) {
         case MessageFolderType::MESSAGE_FOLDER_TYPE_INBOX:
             return FOLDER_TYPE_INBOX;
@@ -159,6 +160,7 @@ std::string MessagingUtil::messageFolderTypeToString(MessageFolderType type)
 
 MessageFolderType MessagingUtil::stringToMessageFolderType(std::string type)
 {
+    LoggerD("Entered");
     if (FOLDER_TYPE_INBOX == type) {
         return MessageFolderType::MESSAGE_FOLDER_TYPE_INBOX;
     }
@@ -176,6 +178,7 @@ MessageFolderType MessagingUtil::stringToMessageFolderType(std::string type)
 
 PlatformResult MessagingUtil::stringToMessageType(const std::string& str, MessageType* out)
 {
+  LoggerD("Entered");
   const auto it = stringToTypeMap.find(str);
 
   if (it == stringToTypeMap.end()) {
@@ -189,6 +192,7 @@ PlatformResult MessagingUtil::stringToMessageType(const std::string& str, Messag
 
 common::PlatformResult MessagingUtil::messageTypeToString(MessageType type, std::string* out)
 {
+  LoggerD("Entered");
   const auto it = typeToStringMap.find(type);
 
   if (it == typeToStringMap.end()) {
@@ -201,6 +205,7 @@ common::PlatformResult MessagingUtil::messageTypeToString(MessageType type, std:
 }
 
 std::string MessagingUtil::messageTypeToString(MessageType type) {
+  LoggerD("Entered");
   std::string type_str;
   PlatformResult platform_result = messageTypeToString(type, &type_str);
   assert(platform_result);
@@ -209,6 +214,7 @@ std::string MessagingUtil::messageTypeToString(MessageType type) {
 
 std::string MessagingUtil::ltrim(const std::string& input)
 {
+    LoggerD("Entered");
     std::string str = input;
     std::string::iterator i;
     for (i = str.begin(); i != str.end(); i++) {
@@ -226,6 +232,7 @@ std::string MessagingUtil::ltrim(const std::string& input)
 
 std::string MessagingUtil::extractSingleEmailAddress(const std::string& address)
 {
+    LoggerD("Entered");
     std::size_t found_begin = address.rfind('<');
     std::size_t found_end = address.rfind('>');
     // if both '<' and '>' bracket found and '<' is before '>'
@@ -244,6 +251,7 @@ std::string MessagingUtil::extractSingleEmailAddress(const std::string& address)
 std::vector<std::string> MessagingUtil::extractEmailAddresses(
         const std::vector<std::string>& addresses)
 {
+    LoggerD("Entered");
     std::vector<std::string> extractedAddresses;
     for(auto it = addresses.begin(); it != addresses.end(); ++it) {
         extractedAddresses.push_back(MessagingUtil::extractSingleEmailAddress(*it));
@@ -254,6 +262,7 @@ std::vector<std::string> MessagingUtil::extractEmailAddresses(
 
 PlatformResult MessagingUtil::loadFileContentToString(const std::string& file_path, std::string* result)
 {
+    LoggerD("Entered");
     std::ifstream input_file;
     input_file.open(file_path, std::ios::in);
 
@@ -297,6 +306,7 @@ std::string MessagingUtil::messageStatusToString(MessageStatus status) {
 
 picojson::value MessagingUtil::messageBodyToJson(std::shared_ptr<MessageBody> body)
 {
+    LoggerD("Entered");
     picojson::object b;
     b[MESSAGE_BODY_ATTRIBUTE_MESSAGE_ID] = picojson::value(std::to_string(body->getMessageId()));
     b[MESSAGE_BODY_ATTRIBUTE_LOADED] = picojson::value(body->getLoaded());
@@ -320,6 +330,7 @@ picojson::value MessagingUtil::messageBodyToJson(std::shared_ptr<MessageBody> bo
 
 picojson::value MessagingUtil::messageToJson(std::shared_ptr<Message> message)
 {
+    LoggerD("Entered");
     picojson::object o;
 
     std::vector<picojson::value> array;
@@ -408,6 +419,7 @@ picojson::value MessagingUtil::messageToJson(std::shared_ptr<Message> message)
 
 picojson::value MessagingUtil::conversationToJson(std::shared_ptr<MessageConversation> conversation)
 {
+    LoggerD("Entered");
     picojson::object o;
 
     o[MESSAGE_CONVERSATION_ATTRIBUTE_ID] = picojson::value(std::to_string(conversation->getConversationId()));
@@ -725,6 +737,7 @@ PlatformResult MessagingUtil::jsonToAbstractFilter(const picojson::object& json,
 PlatformResult MessagingUtil::jsonFilterToAbstractFilter(const picojson::object& filter,
                                                          tizen::AbstractFilterPtr* result)
 {
+    LoggerD("Entered");
     const auto& type = filter.at(JSON_FILTER_TYPE).get<std::string>();
 
     if (JSON_FILTER_ATTRIBUTE_TYPE == type) {
@@ -827,7 +840,10 @@ PlatformResult MessagingUtil::jsonFilterToCompositeFilter(const picojson::object
     for (const auto& a : filter.at(JSON_TO_FILTER_ARRAY).get<picojson::array>()) {
       AbstractFilterPtr filter;
       PlatformResult ret = jsonFilterToAbstractFilter(a.get<picojson::object>(), &filter);
-      if (ret.IsError()) return ret;
+      if (ret.IsError()) {
+          LoggerD("Convert JSON filter to Abstract filter failed (%s)", ret.message().c_str());
+          return ret;
+      }
       compositeFilter->addFilter(filter);
     }
 

diff --git a/src/messaging/short_message_manager.cc b/src/messaging/short_message_manager.cc
index b09947918aad2c2e7c0443e758120a436ec049b4..8ccdef151c1b87b0eab1cd5c1a3cb39b0e98a5b5 100644 (file)
--- a/src/messaging/short_message_manager.cc
+++ b/src/messaging/short_message_manager.cc
@@ -136,7 +136,10 @@ PlatformResult ShortMsgManager::addDraftMessagePlatform(std::shared_ptr<Message>
     msg_struct_t platform_msg = nullptr;
     PlatformResult ret = Message::convertPlatformShortMessageToStruct(message.get(),
                                                                       m_msg_handle, &platform_msg);
-    if (ret.IsError()) return ret;
+    if (ret.IsError()) {
+        LoggerD("Convert Platform Short Message to Struct failed (%s)", ret.message().c_str());
+        return ret;
+    }
 
     if (NULL == platform_msg) {
         LoggerE("Failed to prepare platform message");
@@ -170,7 +173,10 @@ PlatformResult ShortMsgManager::addDraftMessagePlatform(std::shared_ptr<Message>
     Message* msgInfo = nullptr;
     ret = Message::convertPlatformShortMessageToObject(
         platform_msg, &msgInfo);
-    if (ret.IsError()) return ret;
+    if (ret.IsError()) {
+        LoggerD("Convert Platform Short Message to Object failed (%s)", ret.message().c_str());
+        return ret;
+    }
     const int folderId = msgInfo->getFolderId();
     message->setFolderId(folderId);
     const time_t timestamp = msgInfo->getTimestamp();
@@ -201,6 +207,7 @@ PlatformResult ShortMsgManager::addDraftMessagePlatform(std::shared_ptr<Message>
 
 PlatformResult ShortMsgManager::SendMessagePlatform(MessageRecipientsCallbackData* callback)
 {
+  LoggerD("Entered");
   std::lock_guard<std::mutex> lock(m_mutex);
 
   PlatformResult platform_result(ErrorCode::NO_ERROR);
@@ -357,6 +364,7 @@ PlatformResult ShortMsgManager::sendMessage(MessageRecipientsCallbackData* callb
 
 void ShortMsgManager::sendStatusCallback(msg_struct_t sent_status)
 {
+    LoggerD("Entered");
     int reqId = 0;
     int status = MSG_NETWORK_NOT_SEND;
 
@@ -693,6 +701,7 @@ void ShortMsgManager::storage_change_cb(msg_handle_t handle,
 
 void ShortMsgManager::registerStatusCallback(msg_handle_t msg_handle)
 {
+    LoggerD("Entered");
     m_msg_handle = msg_handle;
     // set message sent status callback
     if (MSG_SUCCESS != msg_reg_sent_status_callback(m_msg_handle,
@@ -892,6 +901,7 @@ void ShortMsgManager::updateMessages(MessagesCallbackUserData* callback)
 
 PlatformResult ShortMsgManager::getMessage(int msg_id, msg_struct_t* out_msg)
 {
+    LoggerD("Entered");
     msg_struct_t sendOpt = msg_create_struct(MSG_STRUCT_SENDOPT);
     msg_struct_t msg = msg_create_struct(MSG_STRUCT_MESSAGE_INFO);
 
@@ -930,7 +940,10 @@ PlatformResult ShortMsgManager::getConversationsForMessages(
             ConversationPtr conv;
             PlatformResult ret = MessageConversation::convertMsgConversationToObject(
                     conv_id, ShortMsgManager::getInstance().m_msg_handle, &conv);
-            if (ret.IsError()) return ret;
+            if (ret.IsError()) {
+                LoggerD("Convert msg conversation to object failed (%s)", ret.message().c_str());
+                return ret;
+            }
             LoggerD("Pushed conv=%p", conv.get());
             convs.push_back(conv);
         }