[Messaging] tct fixes for sms part 4

Added Queue to delay listeners callbacks
to satisfate tests.

tct:
    pass: 181
    fail: 0
    timeout 1

pass rate: ~99.5%

The only timeouted test is MessageStorage_sms_findMessages_plainBody_and_id_with_errorCallback
Above test is using Composite Filter which is not implemented

Change-Id: I60685a0fd5c2b1ea238c34d04678d5ce17a02798
Signed-off-by: Maciek Blim <m.blim@samsung.com>

diff --git a/src/messaging/DBus/LoadAttachmentProxy.cpp b/src/messaging/DBus/LoadAttachmentProxy.cpp
index e353e58453e0d017b76d603aa7cbd2c53cbaf602..f875898bedfaac6dc2caa67c1876b3e152440b4e 100644 (file)
--- a/src/messaging/DBus/LoadAttachmentProxy.cpp
+++ b/src/messaging/DBus/LoadAttachmentProxy.cpp
@@ -199,7 +199,10 @@ void LoadAttachmentProxy::handleEmailSignal(const int status,
                         callback->getMessageAttachment());
                 obj[JSON_DATA] = picojson::value(args);
 
-                MessagingInstance::getInstance().PostMessage(json->serialize().c_str());
+                PostQueue::getInstance().resolve(
+                        obj.at(JSON_CALLBACK_ID).get<double>(),
+                        json->serialize()
+                );
             } catch (...) {
                 LoggerW("Couldn't create JSMessageAttachment object!");
                 throw common::UnknownException(
@@ -210,17 +213,26 @@ void LoadAttachmentProxy::handleEmailSignal(const int status,
             LoggerD("Load message attachment failed!");
             common::UnknownException e("Load message attachment failed!");
             callback->setError(e.name(), e.message());
-            MessagingInstance::getInstance().PostMessage(callback->getJson()->serialize().c_str());
+            PostQueue::getInstance().resolve(
+                    callback->getJson()->get<picojson::object>().at(JSON_CALLBACK_ID).get<double>(),
+                    callback->getJson()->serialize()
+            );
         }
     } catch (const common::PlatformException& e) {
         LoggerE("Exception in signal callback");
         callback->setError(e.name(), e.message());
-        MessagingInstance::getInstance().PostMessage(callback->getJson()->serialize().c_str());
+        PostQueue::getInstance().resolve(
+                callback->getJson()->get<picojson::object>().at(JSON_CALLBACK_ID).get<double>(),
+                callback->getJson()->serialize()
+        );
     } catch (...) {
         LoggerE("Exception in signal callback");
         common::UnknownException e("Exception in signal callback");
         callback->setError(e.name(), e.message());
-        MessagingInstance::getInstance().PostMessage(callback->getJson()->serialize().c_str());
+        PostQueue::getInstance().resolve(
+                callback->getJson()->get<picojson::object>().at(JSON_CALLBACK_ID).get<double>(),
+                callback->getJson()->serialize()
+        );
     }
 
     if(callback) {

diff --git a/src/messaging/DBus/LoadBodyProxy.cpp b/src/messaging/DBus/LoadBodyProxy.cpp
index 26b24aa001f127a6c2078a104f7e582540a1336c..68cb03b63606ffdc406075b07a9b4bb81b183c0a 100644 (file)
--- a/src/messaging/DBus/LoadBodyProxy.cpp
+++ b/src/messaging/DBus/LoadBodyProxy.cpp
@@ -181,7 +181,10 @@ void LoadBodyProxy::handleEmailSignal(const int status,
                             callback->getMessage()->getBody());
                     obj[JSON_DATA] = picojson::value(args);
 
-                    MessagingInstance::getInstance().PostMessage(json->serialize().c_str());
+                    PostQueue::getInstance().resolve(
+                            obj.at(JSON_CALLBACK_ID).get<double>(),
+                            json->serialize()
+                    );
                 } catch (...) {
                     LoggerW("Couldn't create JSMessage object!");
                     throw common::UnknownException(
@@ -193,8 +196,10 @@ void LoadBodyProxy::handleEmailSignal(const int status,
 
                 common::UnknownException e("Load message body failed!");
                 callback->setError(e.name(), e.message());
-                MessagingInstance::getInstance().PostMessage(
-                        callback->getJson()->serialize().c_str());
+                PostQueue::getInstance().resolve(
+                        callback->getJson()->get<picojson::object>().at(JSON_CALLBACK_ID).get<double>(),
+                        callback->getJson()->serialize()
+                );
             }
         }
     }
@@ -202,14 +207,20 @@ void LoadBodyProxy::handleEmailSignal(const int status,
         LoggerE("Exception in signal callback");
 
         callback->setError(e.name(), e.message());
-        MessagingInstance::getInstance().PostMessage(callback->getJson()->serialize().c_str());
+        PostQueue::getInstance().resolve(
+                callback->getJson()->get<picojson::object>().at(JSON_CALLBACK_ID).get<double>(),
+                callback->getJson()->serialize()
+        );
     }
     catch (...) {
         LoggerE("Exception in signal callback");
 
         common::UnknownException e("Load message body failed!");
         callback->setError(e.name(), e.message());
-        MessagingInstance::getInstance().PostMessage(callback->getJson()->serialize().c_str());
+        PostQueue::getInstance().resolve(
+                callback->getJson()->get<picojson::object>().at(JSON_CALLBACK_ID).get<double>(),
+                callback->getJson()->serialize()
+        );
     }
 
     if(callback) {

diff --git a/src/messaging/DBus/SyncProxy.cpp b/src/messaging/DBus/SyncProxy.cpp
index adc0cc858449d6a43e347191a36bbb84b1900f83..f7c5703ea9080bb07d6dd9be0aa735c329e93756 100644 (file)
--- a/src/messaging/DBus/SyncProxy.cpp
+++ b/src/messaging/DBus/SyncProxy.cpp
@@ -114,7 +114,10 @@ void SyncProxy::handleEmailSignal(const int status,
             case NOTI_DOWNLOAD_FINISH:
                 LoggerD("Sync finished!");
                 obj[JSON_ACTION] = picojson::value(JSON_CALLBACK_SUCCCESS);
-                MessagingInstance::getInstance().PostMessage(response->serialize().c_str());
+                PostQueue::getInstance().resolve(
+                        obj.at(JSON_CALLBACK_ID).get<double>(),
+                        response->serialize()
+                );
                 break;
 
             case NOTI_DOWNLOAD_FAIL:
@@ -122,7 +125,10 @@ void SyncProxy::handleEmailSignal(const int status,
                 LoggerD("Sync failed!");
                 common::UnknownException err("Sync failed!");
                 callback->setError(err.name(), err.message());
-                MessagingInstance::getInstance().PostMessage(response->serialize().c_str());
+                PostQueue::getInstance().resolve(
+                        obj.at(JSON_CALLBACK_ID).get<double>(),
+                        response->serialize()
+                );
             }
             break;
 

diff --git a/src/messaging/conversations_change_callback.cc b/src/messaging/conversations_change_callback.cc
index a16fd292bf0d559699e4dfed0cf11a72cd559034..1d3048c5b5ffdcccac4da1f570236d72f619309b 100644 (file)
--- a/src/messaging/conversations_change_callback.cc
+++ b/src/messaging/conversations_change_callback.cc
@@ -98,7 +98,9 @@ void ConversationsChangeCallback::added(
     picojson::object& obj = json->get<picojson::object>();
     obj[JSON_ACTION] = picojson::value(CONVERSATIONSADDED);
     obj[JSON_DATA] = picojson::value(array);
-    MessagingInstance::getInstance().PostMessage(json->serialize().c_str());
+
+    PostQueue::getInstance().addAndResolve(obj.at(
+                JSON_CALLBACK_ID).get<double>(), PostPriority::MEDIUM, json->serialize());
 }
 
 void ConversationsChangeCallback::updated(
@@ -124,7 +126,9 @@ void ConversationsChangeCallback::updated(
     picojson::object& obj = json->get<picojson::object>();
     obj[JSON_ACTION] = picojson::value(CONVERSATIONSUPDATED);
     obj[JSON_DATA] = picojson::value(array);
-    MessagingInstance::getInstance().PostMessage(json->serialize().c_str());
+
+    PostQueue::getInstance().addAndResolve(obj.at(
+                JSON_CALLBACK_ID).get<double>(), PostPriority::LOW, json->serialize());
 }
 
 void ConversationsChangeCallback::removed(
@@ -150,7 +154,9 @@ void ConversationsChangeCallback::removed(
     picojson::object& obj = json->get<picojson::object>();
     obj[JSON_ACTION] = picojson::value(CONVERSATIONSREMOVED);
     obj[JSON_DATA] = picojson::value(array);
-    MessagingInstance::getInstance().PostMessage(json->serialize().c_str());
+
+    PostQueue::getInstance().addAndResolve(obj.at(
+                JSON_CALLBACK_ID).get<double>(), PostPriority::LAST, json->serialize());
 }
 
 void ConversationsChangeCallback::setFilter(tizen::AbstractFilterPtr filter)

diff --git a/src/messaging/email_manager.cc b/src/messaging/email_manager.cc
index 1f616a3ac4f4437d21cd12e8d6fc249b19d05cc4..e5be79a70394d6b3b7e7cf105834d0845625bee3 100644 (file)
--- a/src/messaging/email_manager.cc
+++ b/src/messaging/email_manager.cc
@@ -280,7 +280,10 @@ static gboolean addDraftMessageCompleteCB(void *data)
     try {
         if (callback->isError()) {
             LoggerD("Calling error callback");
-            MessagingInstance::getInstance().PostMessage(callback->getJson()->serialize().c_str());
+            PostQueue::getInstance().resolve(
+                    callback->getJson()->get<picojson::object>().at(JSON_CALLBACK_ID).get<double>(),
+                    callback->getJson()->serialize()
+            );
             callback->getMessage()->setMessageStatus(MessageStatus::STATUS_FAILED);
         } else {
             LoggerD("Calling success callback");
@@ -292,7 +295,10 @@ static gboolean addDraftMessageCompleteCB(void *data)
             args[JSON_DATA_MESSAGE] = MessagingUtil::messageToJson(callback->getMessage());
             obj[JSON_DATA] = picojson::value(args);
 
-            MessagingInstance::getInstance().PostMessage(json->serialize().c_str());
+            PostQueue::getInstance().resolve(
+                    obj.at(JSON_CALLBACK_ID).get<double>(),
+                    json->serialize()
+            );
         }
     } catch (const PlatformException& err) {
         LoggerE("%s (%s)", (err.name()).c_str(), (err.message()).c_str());
@@ -352,7 +358,10 @@ static gboolean sendEmailCompleteCB(void* data)
 
     try {
         if (callback->isError()) {
-            MessagingInstance::getInstance().PostMessage(callback->getJson()->serialize().c_str());
+            PostQueue::getInstance().resolve(
+                    callback->getJson()->get<picojson::object>().at(JSON_CALLBACK_ID).get<double>(),
+                    callback->getJson()->serialize()
+            );
             callback->getMessage()->setMessageStatus(MessageStatus::STATUS_FAILED);
         }
         else {
@@ -379,7 +388,10 @@ static gboolean sendEmailCompleteCB(void* data)
             data[JSON_DATA_MESSAGE] = MessagingUtil::messageToJson(callback->getMessage());
             obj[JSON_DATA] = picojson::value(data);
 
-            MessagingInstance::getInstance().PostMessage(json->serialize().c_str());
+            PostQueue::getInstance().resolve(
+                    obj.at(JSON_CALLBACK_ID).get<double>(),
+                    json->serialize()
+            );
             callback->getMessage()->setMessageStatus(MessageStatus::STATUS_SENT);
         }
     }
@@ -801,7 +813,10 @@ void EmailManager::stopSync(long op_id)
     picojson::object& obj = response->get<picojson::object>();
     AbortException error("Sync aborted by user");
     callback->setError(error.name(), error.message());
-    MessagingInstance::getInstance().PostMessage(response->serialize().c_str());
+    PostQueue::getInstance().resolve(
+            obj.at(JSON_CALLBACK_ID).get<double>(),
+            response->serialize()
+    );
     m_proxy_sync->removeCallback(op_id);
 }
 
@@ -818,15 +833,20 @@ void removeEmailCompleteCB(MessagesCallbackUserData* callback)
     try {
         if (callback->isError()) {
             LoggerD("Calling error callback");
-            MessagingInstance::getInstance().PostMessage(
-                    callback->getJson()->serialize().c_str());
+            PostQueue::getInstance().resolve(
+                    callback->getJson()->get<picojson::object>().at(JSON_CALLBACK_ID).get<double>(),
+                    callback->getJson()->serialize()
+            );
         } else {
             LoggerD("Calling success callback");
 
             auto json = callback->getJson();
             picojson::object& obj = json->get<picojson::object>();
             obj[JSON_ACTION] = picojson::value(JSON_CALLBACK_SUCCCESS);
-            MessagingInstance::getInstance().PostMessage(json->serialize().c_str());
+            PostQueue::getInstance().resolve(
+                    obj.at(JSON_CALLBACK_ID).get<double>(),
+                    json->serialize()
+            );
         }
     } catch (const PlatformException& err) {
         LoggerE("Error while calling removeEmail callback: %s (%s)",
@@ -1017,13 +1037,19 @@ void EmailManager::updateMessages(MessagesCallbackUserData* callback)
     try {
         if (callback->isError()) {
             LoggerD("Calling error callback");
-            MessagingInstance::getInstance().PostMessage(callback->getJson()->serialize().c_str());
+            PostQueue::getInstance().resolve(
+                    callback->getJson()->get<picojson::object>().at(JSON_CALLBACK_ID).get<double>(),
+                    callback->getJson()->serialize()
+            );
         } else {
             LoggerD("Calling success callback");
             auto json = callback->getJson();
             picojson::object& obj = json->get<picojson::object>();
             obj[JSON_ACTION] = picojson::value(JSON_CALLBACK_SUCCCESS);
-            MessagingInstance::getInstance().PostMessage(json->serialize().c_str());
+            PostQueue::getInstance().resolve(
+                    obj.at(JSON_CALLBACK_ID).get<double>(),
+                    json->serialize()
+            );
         }
     } catch (const PlatformException& err) {
         LoggerE("Error while calling updateEmail callback: %s (%s)",
@@ -1085,7 +1111,10 @@ void EmailManager::findMessages(FindMsgCallbackUserData* callback)
     try {
         if (callback->isError()) {
             LoggerD("Calling error callback");
-            MessagingInstance::getInstance().PostMessage(callback->getJson()->serialize().c_str());
+            PostQueue::getInstance().resolve(
+                    callback->getJson()->get<picojson::object>().at(JSON_CALLBACK_ID).get<double>(),
+                    callback->getJson()->serialize()
+            );
         } else {
             LoggerD("Calling success callback");
             auto json = callback->getJson();
@@ -1098,7 +1127,11 @@ void EmailManager::findMessages(FindMsgCallbackUserData* callback)
             });
             obj[JSON_DATA] = picojson::value(response);
             obj[JSON_ACTION] = picojson::value(JSON_CALLBACK_SUCCCESS);
-            MessagingInstance::getInstance().PostMessage(json->serialize().c_str());
+
+            PostQueue::getInstance().resolve(
+                    obj.at(JSON_CALLBACK_ID).get<double>(),
+                    json->serialize()
+            );
         }
     } catch (const PlatformException& err) {
         LoggerE("Error while calling findMessages callback: %s (%s)",
@@ -1151,7 +1184,10 @@ void EmailManager::findConversations(ConversationCallbackData* callback)
     try {
         if (callback->isError()) {
             LoggerD("Calling error callback");
-            MessagingInstance::getInstance().PostMessage(callback->getJson()->serialize().c_str());
+            PostQueue::getInstance().resolve(
+                    callback->getJson()->get<picojson::object>().at(JSON_CALLBACK_ID).get<double>(),
+                    callback->getJson()->serialize()
+            );
         } else {
             LoggerD("Calling success callback");
             auto json = callback->getJson();
@@ -1166,7 +1202,11 @@ void EmailManager::findConversations(ConversationCallbackData* callback)
             );
             obj[JSON_DATA] = picojson::value(response);
             obj[JSON_ACTION] = picojson::value(JSON_CALLBACK_SUCCCESS);
-            MessagingInstance::getInstance().PostMessage(json->serialize().c_str());
+
+            PostQueue::getInstance().resolve(
+                    obj.at(JSON_CALLBACK_ID).get<double>(),
+                    json->serialize()
+            );
         }
     } catch (const PlatformException& err) {
         LoggerE("Error while calling findConversations callback: %s (%s)",
@@ -1285,7 +1325,10 @@ void EmailManager::findFolders(FoldersCallbackData* callback)
     try {
         if (callback->isError()) {
             LoggerD("Calling error callback");
-            MessagingInstance::getInstance().PostMessage(callback->getJson()->serialize().c_str());
+            PostQueue::getInstance().resolve(
+                    callback->getJson()->get<picojson::object>().at(JSON_CALLBACK_ID).get<double>(),
+                    callback->getJson()->serialize()
+            );
         } else {
             LoggerD("Calling success callback");
             auto json = callback->getJson();
@@ -1300,7 +1343,11 @@ void EmailManager::findFolders(FoldersCallbackData* callback)
             );
             obj[JSON_DATA] = picojson::value(response);
             obj[JSON_ACTION] = picojson::value(JSON_CALLBACK_SUCCCESS);
-            MessagingInstance::getInstance().PostMessage(json->serialize().c_str());
+
+            PostQueue::getInstance().resolve(
+                    obj.at(JSON_CALLBACK_ID).get<double>(),
+                    json->serialize()
+            );
         }
     } catch (const PlatformException& err) {
         LoggerE("Error while calling findFolders callback: %s (%s)",
@@ -1376,15 +1423,21 @@ void EmailManager::removeConversations(ConversationCallbackData* callback)
     try {
         if (callback->isError()) {
             LoggerD("Calling error callback");
-            MessagingInstance::getInstance().PostMessage(
-                    callback->getJson()->serialize().c_str());
+            PostQueue::getInstance().resolve(
+                    callback->getJson()->get<picojson::object>().at(JSON_CALLBACK_ID).get<double>(),
+                    callback->getJson()->serialize()
+            );
         } else {
             LoggerD("Calling success callback");
 
             auto json = callback->getJson();
             picojson::object& obj = json->get<picojson::object>();
             obj[JSON_ACTION] = picojson::value(JSON_CALLBACK_SUCCCESS);
-            MessagingInstance::getInstance().PostMessage(json->serialize().c_str());
+
+            PostQueue::getInstance().resolve(
+                    obj.at(JSON_CALLBACK_ID).get<double>(),
+                    json->serialize()
+            );
         }
     } catch (const PlatformException& err) {
         LoggerE("Error while calling removeConversations callback: %s (%s)",

diff --git a/src/messaging/folders_change_callback.cc b/src/messaging/folders_change_callback.cc
index 5c33cc49e4fac0fdd7d316cbf9c913bc778f4870..3fc7b9be579f129855b7283073ff701da1e8e8ca 100644 (file)
--- a/src/messaging/folders_change_callback.cc
+++ b/src/messaging/folders_change_callback.cc
@@ -93,7 +93,9 @@ void FoldersChangeCallback::added(const FolderPtrVector& folders)
     picojson::object& obj = json->get<picojson::object>();
     obj[JSON_ACTION] = picojson::value(FOLDERSADDED);
     obj[JSON_DATA] = picojson::value(array);
-    MessagingInstance::getInstance().PostMessage(json->serialize().c_str());
+
+    PostQueue::getInstance().addAndResolve(obj.at(
+                JSON_CALLBACK_ID).get<double>(), PostPriority::MEDIUM, json->serialize());
 }
 
 void FoldersChangeCallback::updated(const FolderPtrVector& folders)
@@ -118,7 +120,9 @@ void FoldersChangeCallback::updated(const FolderPtrVector& folders)
     picojson::object& obj = json->get<picojson::object>();
     obj[JSON_ACTION] = picojson::value(FOLDERSUPDATED);
     obj[JSON_DATA] = picojson::value(array);
-    MessagingInstance::getInstance().PostMessage(json->serialize().c_str());
+
+    PostQueue::getInstance().addAndResolve(obj.at(
+                JSON_CALLBACK_ID).get<double>(), PostPriority::LOW, json->serialize());
 }
 
 void FoldersChangeCallback::removed(const FolderPtrVector& folders)
@@ -143,7 +147,9 @@ void FoldersChangeCallback::removed(const FolderPtrVector& folders)
     picojson::object& obj = json->get<picojson::object>();
     obj[JSON_ACTION] = picojson::value(FOLDERSREMOVED);
     obj[JSON_DATA] = picojson::value(array);
-    MessagingInstance::getInstance().PostMessage(json->serialize().c_str());
+
+    PostQueue::getInstance().addAndResolve(obj.at(
+                JSON_CALLBACK_ID).get<double>(), PostPriority::LAST, json->serialize());
 }
 
 void FoldersChangeCallback::setFilter(tizen::AbstractFilterPtr filter)

diff --git a/src/messaging/message_service_email.cc b/src/messaging/message_service_email.cc
index 9566ade85ae844bd1c24b3d6ad857afa7dcc9628..e13a568e3873753af6ad0df3f7e7878de52dbc72 100644 (file)
--- a/src/messaging/message_service_email.cc
+++ b/src/messaging/message_service_email.cc
@@ -123,7 +123,11 @@ static gboolean loadMessageAttachmentTask(void* data)
                     callback->getMessageAttachment());
             obj[JSON_DATA] = picojson::value(args);
 
-            MessagingInstance::getInstance().PostMessage(json->serialize().c_str());
+            PostQueue::getInstance().resolve(
+                    obj.at(JSON_CALLBACK_ID).get<double>(),
+                    json->serialize()
+            );
+
             delete callback;
             callback = NULL;
             return FALSE;

diff --git a/src/messaging/message_service_short_msg.cc b/src/messaging/message_service_short_msg.cc
index 961e9c8626bf19bc50812ab20ae48df47553a360..32cc27837d762aa63c283e79586d470a49d3b240 100644 (file)
--- a/src/messaging/message_service_short_msg.cc
+++ b/src/messaging/message_service_short_msg.cc
@@ -133,12 +133,18 @@ static gboolean loadMessageBodyTask(void* data)
         args[JSON_DATA_MESSAGE_BODY] = MessagingUtil::messageBodyToJson(body);
         obj[JSON_DATA] = picojson::value(args);
 
-        MessagingInstance::getInstance().PostMessage(json->serialize().c_str());
+        PostQueue::getInstance().resolve(
+                obj.at(JSON_CALLBACK_ID).get<double>(),
+                json->serialize()
+        );
     } catch (...) {
         LoggerE("Couldn't create JSMessage object!");
         common::UnknownException e("Loade message body failed");
         callback->setError(e.name(), e.message());
-        MessagingInstance::getInstance().PostMessage(callback->getJson()->serialize().c_str());
+        PostQueue::getInstance().resolve(
+                callback->getJson()->get<picojson::object>().at(JSON_CALLBACK_ID).get<double>(),
+                callback->getJson()->serialize()
+        );
     }
 
     return FALSE;

diff --git a/src/messaging/message_storage_email.cc b/src/messaging/message_storage_email.cc
index fcff018b10b296faeae23d9e3fd9f03fb2985aac..6668e511be22363f71feafccd6e46b94158a0fb0 100644 (file)
--- a/src/messaging/message_storage_email.cc
+++ b/src/messaging/message_storage_email.cc
@@ -44,7 +44,10 @@ static gboolean callError(void* data)
        return FALSE;
     }
 
-    MessagingInstance::getInstance().PostMessage(callback->getJson()->serialize().c_str());
+    PostQueue::getInstance().resolve(
+            callback->getJson()->get<picojson::object>().at(JSON_CALLBACK_ID).get<double>(),
+            callback->getJson()->serialize()
+    );
 
     return FALSE;
 }

diff --git a/src/messaging/message_storage_short_msg.cc b/src/messaging/message_storage_short_msg.cc
index a666a76c086357ee96a65f5800d9989a8d0170e3..87755a20fdba96dd33dfbfa638cac5f194c60e83 100644 (file)
--- a/src/messaging/message_storage_short_msg.cc
+++ b/src/messaging/message_storage_short_msg.cc
@@ -206,7 +206,11 @@ static gboolean findFoldersCB(void* data)
 
     obj[JSON_DATA] = picojson::value(array);
     obj[JSON_ACTION] = picojson::value(JSON_CALLBACK_SUCCCESS);
-    MessagingInstance::getInstance().PostMessage(json->serialize().c_str());
+
+    PostQueue::getInstance().resolve(
+            obj.at(JSON_CALLBACK_ID).get<double>(),
+            json->serialize()
+    );
 
     delete callback;
     callback = NULL;

diff --git a/src/messaging/messages_change_callback.cc b/src/messaging/messages_change_callback.cc
index dc41ff49aa993b89c5c2f2d69ade9ead71a9ed34..b7c2dda1240dea72ca25c3d076bf2962999203bf 100644 (file)
--- a/src/messaging/messages_change_callback.cc
+++ b/src/messaging/messages_change_callback.cc
@@ -125,7 +125,9 @@ void MessagesChangeCallback::added(const MessagePtrVector& msgs)
     picojson::object& obj = json->get<picojson::object>();
     obj[JSON_ACTION] = picojson::value(MESSAGESADDED);
     obj[JSON_DATA] = picojson::value(array);
-    MessagingInstance::getInstance().PostMessage(json->serialize().c_str());
+
+    PostQueue::getInstance().addAndResolve(obj.at(
+                JSON_CALLBACK_ID).get<double>(), PostPriority::MEDIUM, json->serialize());
 }
 
 void MessagesChangeCallback::updated(const MessagePtrVector& msgs)
@@ -156,7 +158,9 @@ void MessagesChangeCallback::updated(const MessagePtrVector& msgs)
     picojson::object& obj = json->get<picojson::object>();
     obj[JSON_ACTION] = picojson::value(MESSAGESUPDATED);
     obj[JSON_DATA] = picojson::value(array);
-    MessagingInstance::getInstance().PostMessage(json->serialize().c_str());
+
+    PostQueue::getInstance().addAndResolve(obj.at(
+                JSON_CALLBACK_ID).get<double>(), PostPriority::LOW, json->serialize());
 }
 
 void MessagesChangeCallback::removed(const MessagePtrVector& msgs)
@@ -189,8 +193,9 @@ void MessagesChangeCallback::removed(const MessagePtrVector& msgs)
     obj[JSON_ACTION] = picojson::value(MESSAGESREMOVED);
     LoggerD("MESSAGES: %s", picojson::value(array).serialize().c_str());
     obj[JSON_DATA] = picojson::value(array);
-    MessagingInstance::getInstance().PostMessage(json->serialize().c_str());
 
+    PostQueue::getInstance().addAndResolve(obj.at(
+                JSON_CALLBACK_ID).get<double>(), PostPriority::LAST, json->serialize());
 }
 
 void MessagesChangeCallback::setFilter(tizen::AbstractFilterPtr filter)

diff --git a/src/messaging/messaging_instance.cc b/src/messaging/messaging_instance.cc
index d1b930c6a1d2b331489bbc1545bc3fc814699e52..7ce5108a48a16889a8ef7de452d76c955e039e8b 100644 (file)
--- a/src/messaging/messaging_instance.cc
+++ b/src/messaging/messaging_instance.cc
@@ -196,7 +196,10 @@ void MessagingInstance::MessageServiceSendMessage(const picojson::value& args,
             (MessagingUtil::getValueFromJSONObject<double>(data,SEND_MESSAGE_ARGS_SIMINDEX));
 
     if (!callback->setSimIndex(simIndex)) {
-        PostMessage(json->serialize().c_str());
+        PostQueue::getInstance().resolve(
+                obj.at(JSON_CALLBACK_ID).get<double>(),
+                json->serialize()
+        );
         delete callback;
         callback = NULL;
         return;
@@ -204,6 +207,7 @@ void MessagingInstance::MessageServiceSendMessage(const picojson::value& args,
 
     callback->setJson(json);
 
+    PostQueue::getInstance().add(static_cast<long>(callbackId), PostPriority::HIGH);
     auto service = MessagingManager::getInstance().getMessageService(serviceId);
     service->sendMessage(callback);
 }
@@ -217,6 +221,7 @@ void MessagingInstance::MessageServiceLoadMessageBody(const picojson::value& arg
     picojson::value message = data.at(ADD_DRAFT_MESSAGE_ARGS_MESSAGE);
     const double callbackId = args.get(JSON_CALLBACK_ID).get<double>();
 
+
     MessageBodyCallbackData* callback = new MessageBodyCallbackData();
     callback->setMessage(MessagingUtil::jsonToMessage(message));
 
@@ -225,6 +230,7 @@ void MessagingInstance::MessageServiceLoadMessageBody(const picojson::value& arg
     obj[JSON_CALLBACK_ID] = picojson::value(callbackId);
     callback->setJson(json);
 
+    PostQueue::getInstance().add(static_cast<long>(callbackId), PostPriority::HIGH);
     auto service = MessagingManager::getInstance().getMessageService(getServiceIdFromJSON(data));
     service->loadMessageBody(callback);
 }
@@ -237,6 +243,7 @@ void MessagingInstance::MessageServiceLoadMessageAttachment(const picojson::valu
     picojson::object data = args.get(JSON_DATA).get<picojson::object>();
     picojson::value attachment = data.at(LOAD_MESSAGE_ATTACHMENT_ARGS_ATTACHMENT);
     const double callbackId = args.get(JSON_CALLBACK_ID).get<double>();
+
     MessageAttachmentCallbackData* callback = new MessageAttachmentCallbackData();
     callback->setMessageAttachment(MessagingUtil::jsonToMessageAttachment(attachment));
 
@@ -245,6 +252,7 @@ void MessagingInstance::MessageServiceLoadMessageAttachment(const picojson::valu
     obj[JSON_CALLBACK_ID] = picojson::value(callbackId);
     callback->setJson(json);
 
+    PostQueue::getInstance().add(static_cast<long>(callbackId), PostPriority::HIGH);
     auto service = MessagingManager::getInstance().getMessageService(getServiceIdFromJSON(data));
     service->loadMessageAttachment(callback);
 }
@@ -280,6 +288,7 @@ void MessagingInstance::MessageServiceSync(const picojson::value& args,
     callback->setAccountId(id);
     callback->setLimit(limit);
 
+    PostQueue::getInstance().add(static_cast<long>(callbackId), PostPriority::HIGH);
     long op_id = MessagingManager::getInstance().getMessageService(id)->sync(callback);
 
     picojson::value v_op_id(static_cast<double>(op_id));
@@ -320,6 +329,7 @@ void MessagingInstance::MessageServiceSyncFolder(const picojson::value& args,
     callback->setMessageFolder(MessagingUtil::jsonToMessageFolder(v_folder));
     callback->setLimit(limit);
 
+    PostQueue::getInstance().add(static_cast<long>(callbackId), PostPriority::HIGH);
     long op_id = MessagingManager::getInstance().getMessageService(id)->syncFolder(callback);
 
     picojson::value v_op_id(static_cast<double>(op_id));
@@ -377,6 +387,7 @@ void MessagingInstance::MessageStorageAddDraft(const picojson::value& args,
     obj[JSON_CALLBACK_ID] = picojson::value(callbackId);
     callback->setJson(json);
 
+    PostQueue::getInstance().add(static_cast<long>(callbackId), PostPriority::HIGH);
     auto service = MessagingManager::getInstance().getMessageService(serviceId);
     service->getMsgStorage()->addDraftMessage(callback);
 }
@@ -414,6 +425,7 @@ void MessagingInstance::MessageStorageFindMessages(const picojson::value& args,
     obj[JSON_CALLBACK_ID] = picojson::value(callbackId);
     callback->setJson(json);
 
+    PostQueue::getInstance().add(static_cast<long>(callbackId), PostPriority::HIGH);
     storage->findMessages(callback);
 }
 
@@ -440,6 +452,7 @@ void MessagingInstance::MessageStorageRemoveMessages(const picojson::value& args
 
     auto service = MessagingManager::getInstance().getMessageService(getServiceIdFromJSON(data));
 
+    PostQueue::getInstance().add(static_cast<long>(callbackId), PostPriority::HIGH);
     service->getMsgStorage()->removeMessages(callback);
 }
 
@@ -467,6 +480,7 @@ void MessagingInstance::MessageStorageUpdateMessages(const picojson::value& args
 
     auto service = MessagingManager::getInstance().getMessageService(getServiceIdFromJSON(data));
 
+    PostQueue::getInstance().add(static_cast<long>(callbackId), PostPriority::HIGH);
     service->getMsgStorage()->updateMessages(callback);
 }
 
@@ -500,6 +514,7 @@ void MessagingInstance::MessageStorageFindConversations(const picojson::value& a
     obj[JSON_CALLBACK_ID] = picojson::value(callbackId);
     callback->setJson(json);
 
+    PostQueue::getInstance().add(static_cast<long>(callbackId), PostPriority::HIGH);
     auto storage = MessagingManager::getInstance().getMessageService(serviceId)->getMsgStorage();
     storage->findConversations(callback);
 }
@@ -526,6 +541,7 @@ void MessagingInstance::MessageStorageRemoveConversations(const picojson::value&
 
     auto service = MessagingManager::getInstance().getMessageService(getServiceIdFromJSON(data));
 
+    PostQueue::getInstance().add(static_cast<long>(callbackId), PostPriority::HIGH);
     service->getMsgStorage()->removeConversations(callback);
 }
 
@@ -545,6 +561,8 @@ void MessagingInstance::MessageStorageFindFolders(const picojson::value& args,
     picojson::object& obj = json->get<picojson::object>();
     obj[JSON_CALLBACK_ID] = picojson::value(callbackId);
     callback->setJson(json);
+
+    PostQueue::getInstance().add(static_cast<long>(callbackId), PostPriority::HIGH);
     auto service = MessagingManager::getInstance().getMessageService(getServiceIdFromJSON(data));
     service->getMsgStorage()->findFolders(callback);
 }

diff --git a/src/messaging/messaging_util.cc b/src/messaging/messaging_util.cc
index fe87e11174438d9f289170a04507d3b8b97995bb..b1c45494d1b173bf0a8027636380b67518b9112a 100644 (file)
--- a/src/messaging/messaging_util.cc
+++ b/src/messaging/messaging_util.cc
@@ -4,7 +4,6 @@
 #include "messaging_util.h"
 
 #include <fstream>
-#include <map>
 #include <stdexcept>
 #include <streambuf>
 #include <sstream>
@@ -15,6 +14,7 @@
 #include "message_sms.h"
 #include "message_mms.h"
 #include "message_conversation.h"
+#include "messaging_instance.h"
 
 #include "tizen/tizen.h"
 #include "common/logger.h"
@@ -870,5 +870,166 @@ std::shared_ptr<MessageConversation> MessagingUtil::jsonToMessageConversation(co
     return conversation;
 }
 
+PostQueue& PostQueue::getInstance()
+{
+    LoggerD("Entered");
+    static PostQueue instance;
+    return instance;
+}
+
+PostQueue::PostQueue()
+{
+    LoggerD("Entered");
+}
+PostQueue::~PostQueue()
+{
+    LoggerD("Entered");
+}
+
+void PostQueue::addAndResolve(const long cid, PostPriority priority, const std::string json)
+{
+    LoggerD("Entered");
+
+    std::shared_ptr<PostTask> t(new PostTask(priority));
+    t->attach(json);
+    tasks_mutex_.lock();
+    tasks_.push_back(std::make_pair(cid, t));
+    tasks_mutex_.unlock();
+
+    resolve(PostPriority::HIGH);
+
+    return;
+}
+
+void PostQueue::add(const long cid, PostPriority priority)
+{
+    LoggerD("Entered");
+
+    tasks_mutex_.lock();
+    tasks_.push_back(std::make_pair(cid, std::shared_ptr<PostTask>(new PostTask(priority))));
+    tasks_mutex_.unlock();
+
+    return;
+}
+
+void PostQueue::resolve(const long cid, const std::string json)
+{
+    LoggerD("Entered");
+
+    tasks_mutex_.lock();
+
+    TasksCollection::iterator i;
+    i = std::find_if(tasks_.begin(), tasks_.end(), [&cid] (TasksCollectionItem item)->bool {
+        return (cid == item.first);
+    });
+
+    if (tasks_.end() == i) {
+        LoggerD("Not found cid");
+        tasks_mutex_.unlock();
+        return;
+    }
+
+    i->second->attach(json);
+    tasks_mutex_.unlock();
+
+    resolve(PostPriority::HIGH);
+    return;
+}
+
+void PostQueue::resolve(PostPriority p)
+{
+    LoggerD("Entered");
+
+    TasksCollection::iterator i;
+
+    tasks_mutex_.lock();
+    i = std::find_if(tasks_.begin(), tasks_.end(), [&p] (TasksCollectionItem item)->bool {
+        return (p == item.second->priority());
+    });
+
+    if (tasks_.end() == i) {
+        // not found
+        tasks_mutex_.unlock();
+
+        if (PostPriority::LAST != p) {
+            return resolve(static_cast<PostPriority>(p-1));
+        } else {
+            return;
+        }
+    }
+
+    if (TaskState::READY == i->second->state()) {
+        i->second->resolve();
+        std::string json = i->second->json();
+
+        i = tasks_.erase(i);
+        tasks_mutex_.unlock();
+
+        MessagingInstance::getInstance().PostMessage(json.c_str());
+    } else if (TaskState::NEW == i->second->state()) {
+        tasks_mutex_.unlock();
+
+        return;
+    } else if (TaskState::DONE == i->second->state()) {
+        i = tasks_.erase(i);
+        tasks_mutex_.unlock();
+    }
+
+    return resolve(static_cast<PostPriority>(p));
+}
+
+PostQueue::PostTask::PostTask()
+{
+    LoggerD("Entered");
+    priority_ = PostPriority::LOW;
+    state_ = TaskState::NEW;
+}
+PostQueue::PostTask::PostTask(PostPriority p)
+{
+    LoggerD("Entered");
+    priority_ = p;
+    state_ = TaskState::NEW;
+}
+PostQueue::PostTask::~PostTask()
+{
+    LoggerD("Entered");
+}
+
+void PostQueue::PostTask::attach(const std::string j)
+{
+    LoggerD("Entered");
+    if (TaskState::DONE == state_) {
+        return;
+    }
+    json_ = j;
+    state_ = TaskState::READY;
+    return;
+}
+
+PostPriority PostQueue::PostTask::priority()
+{
+    return priority_;
+}
+
+PostQueue::TaskState PostQueue::PostTask::state()
+{
+    return state_;
+}
+
+std::string PostQueue::PostTask::json()
+{
+    return json_;
+}
+
+void PostQueue::PostTask::resolve()
+{
+    LoggerD("Entered");
+    if (TaskState::READY == state_) {
+        state_ = TaskState::DONE;
+    }
+    return;
+}
+
+
 } // messaging
 } // extension

diff --git a/src/messaging/messaging_util.h b/src/messaging/messaging_util.h
index 885b18a7d5c0f0720071432f73a9db5b57413902..849959861b71b138bd29150612cbc34fdf23c959 100644 (file)
--- a/src/messaging/messaging_util.h
+++ b/src/messaging/messaging_util.h
@@ -8,6 +8,8 @@
 #include <string>
 #include <vector>
 #include <memory>
+#include <mutex>
+#include <map>
 #include <stdexcept>
 #include "common/logger.h"
 #include "common/picojson.h"
@@ -159,6 +161,56 @@ private:
     static tizen::AttributeRangeFilterPtr jsonFilterToAttributeRangeFilter(const picojson::object& json);
 };
 
+enum PostPriority {
+    LAST = 0,
+    LOW,
+    MEDIUM,
+    HIGH
+};
+
+class PostQueue {
+public:
+    static PostQueue& getInstance();
+    void addAndResolve(const long cid, PostPriority priority, const std::string json);
+    void add(const long cid, PostPriority priority = PostPriority::LAST);
+    void resolve(const long cid, const std::string json);
+
+    enum TaskState {
+        NEW = 0,
+        READY,
+        DONE
+    };
+
+private:
+    class PostTask;
+    typedef std::pair<long, std::shared_ptr<PostTask>> TasksCollectionItem;
+    typedef std::vector<TasksCollectionItem> TasksCollection;
+
+    PostQueue();
+    PostQueue(const PostQueue &);
+    ~PostQueue();
+    void operator=(const PostQueue &);
+    void resolve(PostPriority p);
+    TasksCollection tasks_;
+    std::mutex tasks_mutex_;
+
+    class PostTask {
+    public:
+        PostTask();
+        PostTask(PostPriority p);
+        ~PostTask();
+        void attach(const std::string j);
+        PostPriority priority();
+        TaskState state();
+        std::string json();
+        void resolve();
+    private:
+        std::string json_;
+        PostPriority priority_;
+        TaskState state_;
+    };
+};
+
 } // messaging
 } // extension
 #endif // MESSAGING_MESSAGING_UTIL_H_

diff --git a/src/messaging/short_message_manager.cc b/src/messaging/short_message_manager.cc
index 734ede73aab99a8f30bab888c60ec23f7d4786d5..4ffe81dd972ec3ca82df1232ea47238b6dd64d06 100644 (file)
--- a/src/messaging/short_message_manager.cc
+++ b/src/messaging/short_message_manager.cc
@@ -45,7 +45,10 @@ static gboolean sendMessageCompleteCB(void* data)
 
     try {
         if (callback->isError()) {
-            MessagingInstance::getInstance().PostMessage(callback->getJson()->serialize().c_str());
+            PostQueue::getInstance().resolve(
+                    callback->getJson()->get<picojson::object>().at(JSON_CALLBACK_ID).get<double>(),
+                    callback->getJson()->serialize()
+            );
             callback->getMessage()->setMessageStatus(MessageStatus::STATUS_FAILED);
         }
         else {
@@ -70,7 +73,10 @@ static gboolean sendMessageCompleteCB(void* data)
             data[JSON_DATA_MESSAGE] = MessagingUtil::messageToJson(message);
             obj[JSON_DATA] = picojson::value(data);
 
-            MessagingInstance::getInstance().PostMessage(json->serialize().c_str());
+            PostQueue::getInstance().resolve(
+                    obj.at(JSON_CALLBACK_ID).get<double>(),
+                    json->serialize()
+            );
             callback->getMessage()->setMessageStatus(MessageStatus::STATUS_SENT);
         }
     }
@@ -101,7 +107,10 @@ static gboolean addDraftMessageCompleteCB(void *data)
         if (callback->isError()) {
             LoggerD("Calling error callback");
 
-            MessagingInstance::getInstance().PostMessage(callback->getJson()->serialize().c_str());
+            PostQueue::getInstance().resolve(
+                    callback->getJson()->get<picojson::object>().at(JSON_CALLBACK_ID).get<long>(),
+                    callback->getJson()->serialize()
+            );
             callback->getMessage()->setMessageStatus(MessageStatus::STATUS_FAILED);
         } else {
             LoggerD("Calling success callback");
@@ -114,7 +123,10 @@ static gboolean addDraftMessageCompleteCB(void *data)
             args[JSON_DATA_MESSAGE] = MessagingUtil::messageToJson(callback->getMessage());
             obj[JSON_DATA] = picojson::value(args);
 
-            MessagingInstance::getInstance().PostMessage(json->serialize().c_str());
+            PostQueue::getInstance().resolve(
+                    obj.at(JSON_CALLBACK_ID).get<double>(),
+                    json->serialize()
+            );
         }
     } catch (const common::PlatformException& err) {
         LoggerE("Error while calling addDraftMessage callback: %s (%s)",
@@ -768,14 +780,21 @@ void ShortMsgManager::removeMessages(MessagesCallbackUserData* callback)
     try {
         if (callback->isError()) {
             LoggerD("Calling error callback");
-            MessagingInstance::getInstance().PostMessage(callback->getJson()->serialize().c_str());
+            PostQueue::getInstance().resolve(
+                    callback->getJson()->get<picojson::object>().at(JSON_CALLBACK_ID).get<double>(),
+                    callback->getJson()->serialize()
+            );
         } else {
             LoggerD("Calling success callback");
 
             auto json = callback->getJson();
             picojson::object& obj = json->get<picojson::object>();
             obj[JSON_ACTION] = picojson::value(JSON_CALLBACK_SUCCCESS);
-            MessagingInstance::getInstance().PostMessage(json->serialize().c_str());
+
+            PostQueue::getInstance().resolve(
+                    obj.at(JSON_CALLBACK_ID).get<double>(),
+                    json->serialize()
+            );
         }
     } catch (const common::PlatformException& err) {
         LoggerE("Error while calling removeShortMsg callback: %s (%s)",
@@ -840,7 +859,10 @@ void ShortMsgManager::updateMessages(MessagesCallbackUserData* callback)
         if (callback->isError()) {
             LoggerD("Calling error callback");
 
-            MessagingInstance::getInstance().PostMessage(callback->getJson()->serialize().c_str());
+            PostQueue::getInstance().resolve(
+                    callback->getJson()->get<picojson::object>().at(JSON_CALLBACK_ID).get<double>(),
+                    callback->getJson()->serialize()
+            );
         } else {
             LoggerD("Calling success callback");
 
@@ -858,7 +880,11 @@ void ShortMsgManager::updateMessages(MessagesCallbackUserData* callback)
             obj[JSON_DATA] = picojson::value(array);
 
             obj[JSON_ACTION] = picojson::value(JSON_CALLBACK_SUCCCESS);
-            MessagingInstance::getInstance().PostMessage(json->serialize().c_str());
+
+            PostQueue::getInstance().resolve(
+                    obj.at(JSON_CALLBACK_ID).get<double>(),
+                    json->serialize()
+            );
         }
     } catch (const common::PlatformException& err) {
         LoggerE("Error while calling updateShortMsg callback: %s (%s)",
@@ -970,7 +996,10 @@ void ShortMsgManager::findMessages(FindMsgCallbackUserData* callback)
     try {
         if (callback->isError()) {
             LoggerD("Calling error callback");
-            MessagingInstance::getInstance().PostMessage(callback->getJson()->serialize().c_str());
+            PostQueue::getInstance().resolve(
+                    callback->getJson()->get<picojson::object>().at(JSON_CALLBACK_ID).get<double>(),
+                    callback->getJson()->serialize()
+            );
         } else {
             LoggerD("Calling success callback with %d messages:",
                     callback->getMessages().size());
@@ -986,7 +1015,11 @@ void ShortMsgManager::findMessages(FindMsgCallbackUserData* callback)
 
             obj[JSON_DATA] = picojson::value(response);
             obj[JSON_ACTION] = picojson::value(JSON_CALLBACK_SUCCCESS);
-            MessagingInstance::getInstance().PostMessage(json->serialize().c_str());
+
+            PostQueue::getInstance().resolve(
+                    obj.at(JSON_CALLBACK_ID).get<double>(),
+                    json->serialize()
+            );
         }
     } catch (const common::PlatformException& err) {
         LoggerE("Error while calling findMessages callback: %s (%s)",
@@ -1034,7 +1067,10 @@ void ShortMsgManager::findConversations(ConversationCallbackData* callback)
     try {
         if (callback->isError()) {
             LoggerD("Calling error callback");
-            MessagingInstance::getInstance().PostMessage(callback->getJson()->serialize().c_str());
+            PostQueue::getInstance().resolve(
+                    callback->getJson()->get<picojson::object>().at(JSON_CALLBACK_ID).get<double>(),
+                    callback->getJson()->serialize()
+            );
         } else {
             LoggerD("Calling success callback");
             auto json = callback->getJson();
@@ -1049,7 +1085,11 @@ void ShortMsgManager::findConversations(ConversationCallbackData* callback)
             );
             obj[JSON_DATA] = picojson::value(response);
             obj[JSON_ACTION] = picojson::value(JSON_CALLBACK_SUCCCESS);
-            MessagingInstance::getInstance().PostMessage(json->serialize().c_str());
+
+            PostQueue::getInstance().resolve(
+                    obj.at(JSON_CALLBACK_ID).get<double>(),
+                    json->serialize()
+            );
         }
     } catch (const common::PlatformException& err) {
         LoggerE("Error while calling findConversations callback: %s (%s)",
@@ -1169,15 +1209,21 @@ void ShortMsgManager::removeConversations(ConversationCallbackData* callback)
     try {
         if (callback->isError()) {
             LoggerD("Calling error callback");
-            MessagingInstance::getInstance().PostMessage(
-                    callback->getJson()->serialize().c_str());
+            PostQueue::getInstance().resolve(
+                    callback->getJson()->get<picojson::object>().at(JSON_CALLBACK_ID).get<double>(),
+                    callback->getJson()->serialize()
+            );
         } else {
             LoggerD("Calling success callback");
 
             auto json = callback->getJson();
             picojson::object& obj = json->get<picojson::object>();
             obj[JSON_ACTION] = picojson::value(JSON_CALLBACK_SUCCCESS);
-            MessagingInstance::getInstance().PostMessage(json->serialize().c_str());
+
+            PostQueue::getInstance().resolve(
+                    obj.at(JSON_CALLBACK_ID).get<double>(),
+                    json->serialize()
+            );
         }
     } catch (const common::PlatformException& err) {
         LoggerE("Error while calling removeConversations callback: %s (%s)",