[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 a00af2335fef44e14625450f79600faf021a3358..6f201c7cae100d9cf26cf299db3a14f2f66d777c 100755 (executable)
--- a/src/messaging/change_listener_container.cc
+++ b/src/messaging/change_listener_container.cc
@@ -24,6 +24,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;
@@ -442,6 +443,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 225328eeca31fc0208b9d2e3814f13caa8755b65..8bf1191dc5f6db48fea8808e796ea55ea5cd87e8 100755 (executable)
--- a/src/messaging/conversation_callback_data.cc
+++ b/src/messaging/conversation_callback_data.cc
@@ -30,6 +30,7 @@ ConversationCallbackData::ConversationCallbackData(PostQueue& queue):
         m_service_type(UNDEFINED),
         queue_(queue)
 {
+    LoggerD("Entered");
 }
 
 ConversationCallbackData::ConversationCallbackData(long cid, PostQueue& queue, bool keep):
@@ -42,6 +43,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));
@@ -51,6 +53,7 @@ ConversationCallbackData::ConversationCallbackData(long cid, PostQueue& queue, b
 
 ConversationCallbackData::~ConversationCallbackData()
 {
+    LoggerD("Entered");
 }
 
 void ConversationCallbackData::setFilter(AbstractFilterPtr filter)
@@ -86,8 +89,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();
@@ -105,8 +110,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 1d44328da0d6e7d6c611e0769c29469ed5fb7f3e..9e0cc33d67fba9c0a9dce1857492e27973ef9edd 100755 (executable)
--- a/src/messaging/conversations_change_callback.cc
+++ b/src/messaging/conversations_change_callback.cc
@@ -61,7 +61,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();
@@ -84,6 +86,7 @@ ConversationPtrVector ConversationsChangeCallback::filterConversations(
         return filtered_conversations;
     }
     else {
+        LoggerD("filter pointer is not valid");
         return source_conversations;
     }
 }

diff --git a/src/messaging/find_msg_callback_user_data.cc b/src/messaging/find_msg_callback_user_data.cc
index bc28de9cabd72419543217d60526f505adce1aaf..fa8cc973030852c52ffc6c31d5d4ad8b96f223f5 100755 (executable)
--- a/src/messaging/find_msg_callback_user_data.cc
+++ b/src/messaging/find_msg_callback_user_data.cc
@@ -32,10 +32,12 @@ FindMsgCallbackUserData::FindMsgCallbackUserData(PostQueue& queue):
         m_service_type(UNDEFINED),
         queue_(queue)
 {
+    LoggerD("Entered");
 }
 
 FindMsgCallbackUserData::~FindMsgCallbackUserData()
 {
+    LoggerD("Entered");
 }
 
 void FindMsgCallbackUserData::setFilter(AbstractFilterPtr filter)
@@ -71,8 +73,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;
@@ -89,8 +93,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 32be6acb0eaa02cabfd4c63bc306237ed8c44907..ad34e661753370df5c17c2832b095212a6b0cbd2 100755 (executable)
--- a/src/messaging/folders_callback_data.cc
+++ b/src/messaging/folders_callback_data.cc
@@ -25,6 +25,7 @@ FoldersCallbackData::FoldersCallbackData(PostQueue& queue):
         m_is_error(false),
         queue_(queue)
 {
+    LoggerD("Entered");
 }
 
 FoldersCallbackData::FoldersCallbackData(long cid, PostQueue& queue, bool keep):
@@ -32,6 +33,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));
@@ -40,6 +42,7 @@ FoldersCallbackData::FoldersCallbackData(long cid, PostQueue& queue, bool keep):
 }
 
 FoldersCallbackData::~FoldersCallbackData() {
+    LoggerD("Entered");
 }
 
 void FoldersCallbackData::addFolder(std::shared_ptr<MessageFolder> folder)
@@ -65,8 +68,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;
@@ -83,8 +88,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 a5438555a49ad782b404e41b96412706cc796aeb..810cc573fdaf1b108a284d5c83f412e685f64163 100755 (executable)
--- a/src/messaging/folders_change_callback.cc
+++ b/src/messaging/folders_change_callback.cc
@@ -49,7 +49,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 8e8bc3d58de71d96cffd4b96547a395d0b80a015..975f6781d42b4d4d309165787c7b94a843ffbf0b 100755 (executable)
--- a/src/messaging/message.cc
+++ b/src/messaging/message.cc
@@ -340,6 +340,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)
@@ -352,6 +353,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;
 
@@ -452,6 +454,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.");
     }
@@ -461,6 +464,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");
@@ -501,6 +505,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()) {
@@ -558,6 +563,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;
@@ -674,6 +680,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());
@@ -700,6 +707,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) {
 
@@ -1055,6 +1063,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);
 
@@ -1090,6 +1099,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
@@ -1116,6 +1126,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
@@ -1324,6 +1335,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;
@@ -1342,6 +1354,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;
         }
@@ -1389,18 +1402,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;
         }
@@ -1412,6 +1428,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;
         }
@@ -1505,6 +1522,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()) {
@@ -1523,6 +1541,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;
@@ -1534,6 +1553,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);
@@ -1557,7 +1577,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;
@@ -1566,7 +1586,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;
 
@@ -1589,7 +1609,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 17d51bf702c4e248406b9d42b72a88aa964b7efd..ec102c860d6ef0cb1d09fabe4d1eff55e42f581d 100755 (executable)
--- a/src/messaging/message_attachment.cc
+++ b/src/messaging/message_attachment.cc
@@ -124,6 +124,7 @@ std::string MessageAttachment::getFilePath()
 
 std::string MessageAttachment::getShortFileName() const
 {
+    LoggerD("Entered");
     if (!m_isFilePathSet) {
         return "";
     }
@@ -155,6 +156,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++) {
@@ -205,6 +207,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] = "*/*";
@@ -396,6 +399,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;
@@ -588,6 +592,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;
@@ -597,6 +602,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;
@@ -606,6 +612,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 335878150b361f081d798584f638b42b18dc7566..d9f05d2423c594a9326aebd8dfaa96e6bb04b357 100755 (executable)
--- a/src/messaging/message_body.cc
+++ b/src/messaging/message_body.cc
@@ -32,10 +32,12 @@ MessageBody::MessageBody() : m_messageId(1),
                              m_plainBody(""),
                              m_htmlBody("")
 {
+    LoggerD("Entered");
 }
 
 MessageBody::~MessageBody()
 {
+    LoggerD("Entered");
 }
 
 // messageId
@@ -108,7 +110,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 5de02c0337b41b819c76f06baeba4116410ca30d..42ace37c69c14413c657ffdd9a8da7783ed619e7 100755 (executable)
--- a/src/messaging/message_callback_user_data.cc
+++ b/src/messaging/message_callback_user_data.cc
@@ -25,9 +25,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) {
@@ -50,8 +52,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();
@@ -69,8 +73,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 b20e62b09be3b1182edb653404906b6dfa24ba62..5e9fbf1a31d952264761a563abfb959da4c10f8f 100755 (executable)
--- a/src/messaging/message_conversation.cc
+++ b/src/messaging/message_conversation.cc
@@ -119,6 +119,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;
@@ -273,6 +274,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 286f8b5d60f04d289b6a333e996c8a1360c534b9..bbb4f0854c6448b6ec64baf71a25a08f811e0510 100755 (executable)
--- a/src/messaging/message_email.cc
+++ b/src/messaging/message_email.cc
@@ -93,7 +93,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);
@@ -130,7 +130,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 3de7ce366372847b6545e893adeb95cee821b6b7..355675e054081b0472cf2a009bf2f3bd14849a46 100755 (executable)
--- a/src/messaging/message_folder.cc
+++ b/src/messaging/message_folder.cc
@@ -41,10 +41,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);
@@ -124,6 +126,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 111dd31d5964d4cbab0eeb1657c92bc4f89f34a9..edd0e914152c6c622c8279577dcbb0ac960a45ce 100755 (executable)
--- a/src/messaging/message_mms.cc
+++ b/src/messaging/message_mms.cc
@@ -37,6 +37,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;
 
@@ -48,6 +49,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;
 
@@ -64,6 +66,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 1ac0e09451d65102ec418f85937917cec6f6438c..c32f7bb72c7818d621fd7cface1acfea2740a6ae 100755 (executable)
--- a/src/messaging/message_service.cc
+++ b/src/messaging/message_service.cc
@@ -81,8 +81,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>();
@@ -98,8 +100,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>();
@@ -130,6 +134,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) {
@@ -194,8 +199,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>();
@@ -210,8 +217,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>();
@@ -419,6 +428,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 f8afa495bbbaf0d0093b685cfa4430d4a26e8302..0c405f59b19014561d9b379d9b3cbe4a641cb983 100755 (executable)
--- a/src/messaging/message_service_short_msg.cc
+++ b/src/messaging/message_service_short_msg.cc
@@ -65,6 +65,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");
@@ -156,6 +157,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 1b63875aaa0a6baa212fea078c3606211615a420..92838f63b7a48a339ef799e97f3347cdb9d5fcc4 100755 (executable)
--- a/src/messaging/messages_callback_user_data.cc
+++ b/src/messaging/messages_callback_user_data.cc
@@ -25,6 +25,7 @@ MessagesCallbackUserData::MessagesCallbackUserData(PostQueue& queue):
         m_service_type(MessageType::UNDEFINED),
         queue_(queue)
 {
+    LoggerD("Entered");
 }
 
 MessagesCallbackUserData::MessagesCallbackUserData(long cid, PostQueue& queue, bool keep):
@@ -33,6 +34,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));
@@ -41,10 +43,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);
 }
 
@@ -56,8 +60,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();
@@ -77,6 +83,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 6574a987b647931fd1d1cd620253dc072452e84b..19bdec541238d8de236ec4b138ad92f9ded5f64f 100755 (executable)
--- a/src/messaging/messages_change_callback.cc
+++ b/src/messaging/messages_change_callback.cc
@@ -34,6 +34,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 {
@@ -106,6 +107,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 f33b059b7a4b35b51bccda056bb56dd6881dbfb7..892149809fe86f1a519d281b09dbfc5d42d92a61 100755 (executable)
--- a/src/messaging/messaging_database_manager.cc
+++ b/src/messaging/messaging_database_manager.cc
@@ -43,6 +43,7 @@ AttributeInfo::AttributeInfo() :
         sql_type(UNDEFINED_TYPE),
         any_type(PrimitiveType_NoType)
 {
+    LoggerD("Entered");
 }
 
 AttributeInfo::AttributeInfo(const std::string& in_sql_name,
@@ -52,6 +53,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) :
@@ -59,6 +61,7 @@ AttributeInfo::AttributeInfo(const AttributeInfo& other) :
         sql_type(other.sql_type),
         any_type(other.any_type)
 {
+    LoggerD("Entered");
 }
 
 AttributeInfo& AttributeInfo::operator=(const AttributeInfo& other)
@@ -71,6 +74,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)));
@@ -180,11 +184,12 @@ MessagingDatabaseManager::MessagingDatabaseManager()
 
 MessagingDatabaseManager::~MessagingDatabaseManager()
 {
-
+    LoggerD("Entered");
 }
 
 MessagingDatabaseManager& MessagingDatabaseManager::getInstance()
 {
+    LoggerD("Entered");
     static MessagingDatabaseManager instance;
     return instance;
 }
@@ -297,6 +302,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();
@@ -384,6 +390,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);
@@ -403,6 +410,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) {
@@ -420,6 +428,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 {
@@ -427,6 +436,7 @@ PlatformResult MessagingDatabaseManager::getAttributeFilterQuery(AbstractFilterP
         }
     }
     else if ("isHighPriority" == attribute_name) {
+        LoggerD("Attribute name: isHighPriority");
         if (attr_filter->getMatchValue()->toBool()) {
             sqlQuery << "= ";
         } else {
@@ -440,6 +450,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 ||
@@ -585,21 +596,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;
             }
@@ -643,21 +663,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;
             }
@@ -737,13 +766,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.");
@@ -778,7 +811,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;
@@ -831,13 +867,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.");
@@ -874,7 +914,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 ad24fc9c5b612435681eb1a6cd7444e27a059710..67d0747c5e4e1ea4bcd1f8e76b063b76258c1c3a 100755 (executable)
--- a/src/messaging/messaging_extension.cc
+++ b/src/messaging/messaging_extension.cc
@@ -34,6 +34,7 @@ common::Extension* CreateExtension() {
 }
 
 MessagingExtension::MessagingExtension() {
+  LoggerD("Entered");
   SetExtensionName(kMessaging);
   SetJavaScriptAPI(kSource_messaging_api);
   const char* entry_points[] = {
@@ -44,7 +45,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 1edeb8e105f405d57a1d2dfcd8762e8bc08bf071..d92544d281ed5aa02a36862266deab861068273c 100755 (executable)
--- a/src/messaging/messaging_instance.cc
+++ b/src/messaging/messaging_instance.cc
@@ -170,6 +170,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 75b98b4801c50df4718a926aaa6f5fda7c29309b..9fdf5bd3a25c5c67cf314197ad43ee7dbcd862c3 100755 (executable)
--- a/src/messaging/messaging_manager.cc
+++ b/src/messaging/messaging_manager.cc
@@ -49,6 +49,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 68ea10418854f5ad5a0fdfcb47417b04ac267359..c17ea7b2010109c21b354fb91dc4d243ff79e728 100755 (executable)
--- a/src/messaging/messaging_util.cc
+++ b/src/messaging/messaging_util.cc
@@ -157,6 +157,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;
@@ -173,6 +174,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;
     }
@@ -190,6 +192,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()) {
@@ -203,6 +206,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()) {
@@ -215,6 +219,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);
@@ -223,6 +228,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++) {
@@ -240,6 +246,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 '>'
@@ -258,6 +265,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));
@@ -268,6 +276,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);
 
@@ -311,6 +320,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());
@@ -334,6 +344,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;
@@ -422,6 +433,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()));
@@ -739,6 +751,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) {
@@ -841,7 +854,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 f49fff66a57c48f3f2cfbb1a163168ad28d40e00..face56a57552614937d7b69c1ac499fab80becad 100755 (executable)
--- a/src/messaging/short_message_manager.cc
+++ b/src/messaging/short_message_manager.cc
@@ -148,7 +148,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");
@@ -182,7 +185,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();
@@ -213,6 +219,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);
@@ -369,6 +376,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;
 
@@ -705,6 +713,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,
@@ -904,6 +913,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);
 
@@ -942,7 +952,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);
         }