#include <string>
#include <mutex>
#include <map>
-#include "common/callback_user_data.h"
#include "common/picojson.h"
#include "common/platform_result.h"
+++ /dev/null
-/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd All Rights Reserved
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "common/callback_user_data.h"
-
-namespace common {
-
-CallbackUserData::CallbackUserData() :
- m_is_act(true) {
-}
-
-CallbackUserData::~CallbackUserData() {
-}
-
-void CallbackUserData::setActive(bool act) {
- m_is_act = act;
-}
-
-bool CallbackUserData::isActive() const {
- return m_is_act;
-}
-
-void CallbackUserData::setJson(std::shared_ptr<picojson::value> json) {
- m_json = json;
-}
-
-std::shared_ptr<picojson::value> CallbackUserData::getJson() const {
- return m_json;
-}
-
-} // common
+++ /dev/null
-/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd All Rights Reserved
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-// Class added for backward compatibility with WRT plugins.
-// TODO To be cleaned/replaced in the future.
-
-#ifndef COMMON_CALLBACK_USER_DATA_H_
-#define COMMON_CALLBACK_USER_DATA_H_
-
-#include "common/picojson.h"
-
-#include <memory>
-
-namespace common {
-
-class CallbackUserData {
-public:
- CallbackUserData();
-
- virtual ~CallbackUserData();
-
- void setActive(bool act);
- bool isActive() const;
-
- void setJson(std::shared_ptr<picojson::value> json);
- std::shared_ptr<picojson::value> getJson() const;
-
- virtual void setError(const std::string& err_name,
- const std::string& err_message) = 0;
-
-protected:
- std::shared_ptr<picojson::value> m_json;
-
-private:
- bool m_is_act;
-};
-
-} // common
-
-#endif // COMMON_CALLBACK_USER_DATA_H_
'task-queue.h',
'tools.cc',
'tools.h',
- 'callback_user_data.cc',
- 'callback_user_data.h',
'optional.h',
'platform_result.cc',
'platform_result.h',
if (!ret.IsError()) {
LoggerD("Updated Message attachment object");
- auto json = callback->getJson();
- picojson::object& obj = json->get<picojson::object>();
- obj[JSON_ACTION] = picojson::value(JSON_CALLBACK_SUCCCESS);
-
picojson::object args;
args[JSON_DATA_MESSAGE_ATTACHMENT] = MessagingUtil::messageAttachmentToJson(
callback->getMessageAttachment());
- obj[JSON_DATA] = picojson::value(args);
- callback->getQueue().resolve(
- obj.at(JSON_CALLBACK_ID).get<double>(),
- json->serialize()
- );
+ callback->SetSuccess(picojson::value(args));
+ callback->Post();
}
} else if(NOTI_DOWNLOAD_ATTACH_FAIL) {
LoggerD("Load message attachment failed!");
}
if (ret.IsError()) {
LoggerE("Exception in signal callback");
- callback->setError(ret);
- callback->getQueue().resolve(
- callback->getJson()->get<picojson::object>().at(JSON_CALLBACK_ID).get<double>(),
- callback->getJson()->serialize()
- );
+ callback->SetError(ret);
+ callback->Post();
}
if(callback) {
if (!ret.IsError()) {
LoggerD("Calling success callback");
- auto json = callback->getJson();
- picojson::object& obj = json->get<picojson::object>();
- obj[JSON_ACTION] = picojson::value(JSON_CALLBACK_SUCCCESS);
-
picojson::object args;
args[JSON_DATA_MESSAGE_BODY] = MessagingUtil::messageBodyToJson(
callback->getMessage()->getBody());
- obj[JSON_DATA] = picojson::value(args);
- callback->getQueue().resolve(
- obj.at(JSON_CALLBACK_ID).get<double>(),
- json->serialize()
- );
+ callback->SetSuccess(picojson::value(args));
+ callback->Post();
}
} else if(NOTI_DOWNLOAD_BODY_FAIL == status) {
LoggerD("Load message body failed!");
}
if (ret.IsError()) {
- callback->setError(ret);
- callback->getQueue().resolve(
- callback->getJson()->get<picojson::object>().at(JSON_CALLBACK_ID).get<double>(),
- callback->getJson()->serialize()
- );
+ callback->SetError(ret);
+ callback->Post();
}
removeCallback(callback);
}
}
-void SyncProxy::addCallback(long op_id, common::CallbackUserData* callbackOwned)
+void SyncProxy::addCallback(long op_id, CallbackUserData* callbackOwned)
{
m_callback_map.insert(std::make_pair(op_id, callbackOwned));
}
-common::CallbackUserData* SyncProxy::getCallback(long op_id) {
- common::CallbackUserData* cb = nullptr;
+CallbackUserData* SyncProxy::getCallback(long op_id) {
+ CallbackUserData* cb = nullptr;
const auto it = m_callback_map.find(op_id);
if (it != m_callback_map.end()) {
return;
}
- std::shared_ptr<picojson::value> response = callback->getJson();
- picojson::object& obj = response->get<picojson::object>();
switch (status) {
case NOTI_DOWNLOAD_FINISH:
LoggerD("Sync finished!");
- obj[JSON_ACTION] = picojson::value(JSON_CALLBACK_SUCCCESS);
- callback->getQueue().resolve(
- obj.at(JSON_CALLBACK_ID).get<double>(),
- response->serialize()
- );
+ callback->SetSuccess();
+ callback->Post();
break;
case NOTI_DOWNLOAD_FAIL:
- {
LoggerD("Sync failed!");
- callback->setError("UnknownError", "Sync failed!");
- callback->getQueue().resolve(
- obj.at(JSON_CALLBACK_ID).get<double>(),
- response->serialize()
- );
- }
- break;
+ callback->SetError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Sync failed!"));
+ callback->Post();
+ break;
}
#ifndef __TIZEN_DBUS_SYNC_PROXY_H__
#define __TIZEN_DBUS_SYNC_PROXY_H__
+#include "messaging/callback_user_data.h"
#include "EmailSignalProxy.h"
#include "common/platform_result.h"
public:
// Callback is owned by this map
- typedef std::map<long, common::CallbackUserData*> CallbackMap;
+ typedef std::map<long, CallbackUserData*> CallbackMap;
virtual ~SyncProxy();
const std::string& iface,
SyncProxyPtr* sync_proxy);
//Passed callback will be owned by this proxy
- void addCallback(long op_id, common::CallbackUserData* callbackOwned);
- common::CallbackUserData* getCallback(long op_id);
+ void addCallback(long op_id, CallbackUserData* callbackOwned);
+ CallbackUserData* getCallback(long op_id);
void removeCallback(long op_id);
protected:
--- /dev/null
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "messaging/callback_user_data.h"
+
+#include "common/logger.h"
+
+namespace extension {
+namespace messaging {
+
+CallbackUserData::CallbackUserData(PostQueue& queue, long cid, bool keep /* = false */)
+ : json_(picojson::object()),
+ obj_(json_.get<picojson::object>()),
+ cid_(cid),
+ queue_(queue),
+ result_(common::ErrorCode::NO_ERROR) {
+ LoggerD("Entered");
+ AddJsonData(JSON_CALLBACK_ID, picojson::value(static_cast<double>(cid_)));
+ AddJsonData(JSON_CALLBACK_KEEP, picojson::value(keep));
+}
+
+CallbackUserData::~CallbackUserData() {
+ LoggerD("Entered");
+}
+
+bool CallbackUserData::IsError() const {
+ LoggerD("Entered");
+ return result_.IsError();
+}
+
+void CallbackUserData::SetError(const common::PlatformResult& error) {
+ LoggerD("Entered");
+
+ // keep only the first error
+ if (!IsError()) {
+ result_ = error;
+ SetAction(JSON_CALLBACK_ERROR, error.ToJSON());
+ }
+}
+
+void CallbackUserData::SetSuccess(const picojson::value& data /* = picojson::value()*/) {
+ LoggerD("Entered");
+
+ // do not allow to overwrite the error
+ if (!IsError()) {
+ SetAction(JSON_CALLBACK_SUCCCESS, data);
+ }
+}
+
+void CallbackUserData::SetAction(const char* action, const picojson::value& data) {
+ LoggerD("Entered");
+
+ AddJsonData(JSON_ACTION, picojson::value(action));
+ AddJsonData(JSON_DATA, data);
+}
+
+void CallbackUserData::AddToQueue() {
+ LoggerD("Entered");
+ queue_.add(cid_, PostPriority::HIGH);
+}
+
+void CallbackUserData::Post() {
+ LoggerD("Entered");
+ queue_.resolve(cid_, json_.serialize());
+}
+
+void CallbackUserData::AddAndPost(PostPriority p) {
+ queue_.addAndResolve(cid_, p, json_.serialize());
+}
+
+bool CallbackUserData::HasQueue(const PostQueue& q) const {
+ LoggerD("Entered");
+ return &q == &queue_;
+}
+
+void CallbackUserData::AddJsonData(const char* key, const picojson::value& value) {
+ LoggerD("Entered");
+ // always overwrite
+ obj_[key] = value;
+}
+
+} // messaging
+} // extension
--- /dev/null
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef MESSAGING_CALLBACK_USER_DATA_H_
+#define MESSAGING_CALLBACK_USER_DATA_H_
+
+#include <memory>
+
+#include "common/picojson.h"
+
+#include "messaging/messaging_util.h"
+
+namespace extension {
+namespace messaging {
+
+class CallbackUserData {
+ public:
+ CallbackUserData(PostQueue& queue, long cid, bool keep = false);
+ virtual ~CallbackUserData();
+
+ bool IsError() const;
+ void SetError(const common::PlatformResult& error);
+ void SetSuccess(const picojson::value& data = picojson::value());
+ void SetAction(const char* action, const picojson::value& data);
+
+ void AddToQueue();
+ void Post();
+ void AddAndPost(PostPriority p);
+ bool HasQueue(const PostQueue& q) const;
+
+ private:
+ void AddJsonData(const char* key, const picojson::value& value);
+
+ picojson::value json_;
+ picojson::object& obj_;
+ long cid_;
+ PostQueue& queue_;
+ common::PlatformResult result_;
+};
+
+} // messaging
+} // extension
+
+#endif // MESSAGING_CALLBACK_USER_DATA_H_
namespace extension {
namespace messaging {
-ConversationCallbackData::ConversationCallbackData(PostQueue& queue):
- m_filter(),
- m_sort(),
- m_limit(0),
- m_offset(0),
- m_is_error(false),
- m_account_id(0),
- m_service_type(UNDEFINED),
- queue_(queue)
-{
- LoggerD("Entered");
-}
-
-ConversationCallbackData::ConversationCallbackData(long cid, PostQueue& queue, bool keep):
- m_filter(),
- m_sort(),
- m_limit(0),
- m_offset(0),
- m_is_error(false),
- m_account_id(0),
- 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));
- o[JSON_CALLBACK_KEEP] = picojson::value(keep);
- setJson(json);
+ConversationCallbackData::ConversationCallbackData(PostQueue& queue, long cid, bool keep /* = false */) :
+ CallbackUserData(queue, cid, keep),
+ m_limit(0),
+ m_offset(0),
+ m_account_id(0),
+ m_service_type(UNDEFINED) {
+ LoggerD("Entered");
}
ConversationCallbackData::~ConversationCallbackData()
return m_conversations;
}
-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();
-
- objData[JSON_ERROR_NAME] = picojson::value(err_name);
- objData[JSON_ERROR_MESSAGE] = picojson::value(err_message);
-
- obj[JSON_DATA] = picojson::value(objData);
-
- m_is_error = true;
- m_err_name = err_name;
- m_err_message = err_message;
- }
-}
-
-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);
- auto obj_data = picojson::object();
- obj_data[JSON_ERROR_CODE] = picojson::value(static_cast<double>(error.error_code()));
- obj_data[JSON_ERROR_MESSAGE] = picojson::value(error.message());
- obj[JSON_DATA] = picojson::value(obj_data);
- }
-}
-bool ConversationCallbackData::isError() const
-{
- return m_is_error;
-}
-
-std::string ConversationCallbackData::getErrorName() const
-{
- return m_err_name;
-}
-
-std::string ConversationCallbackData::getErrorMessage() const
-{
- return m_err_message;
-}
-
void ConversationCallbackData::setAccountId(int account_id){
m_account_id = account_id;
}
#ifndef MESSAGING_CONVERSATION_CALLBACK_DATA_H_
#define MESSAGING_CONVERSATION_CALLBACK_DATA_H_
-#include "common/callback_user_data.h"
#include <memory>
#include <string>
#include <vector>
+
+#include "messaging/callback_user_data.h"
#include "MsgCommon/AttributeFilter.h"
#include "MsgCommon/SortMode.h"
#include "messaging_util.h"
class Message;
class MessageConversation;
-class ConversationCallbackData: public common::CallbackUserData {
+class ConversationCallbackData : public CallbackUserData {
public:
- ConversationCallbackData(PostQueue& queue);
- ConversationCallbackData(long cid, PostQueue& queue, bool keep = false);
+ ConversationCallbackData(PostQueue& queue, long cid, bool keep = false);
virtual ~ConversationCallbackData();
void setFilter(AbstractFilterPtr filter);
std::vector<std::shared_ptr<MessageConversation>> getConversations() const;
- void setError(const std::string& err_name,
- const std::string& err_message);
- void SetError(const common::PlatformResult& error);
- bool isError() const;
- std::string getErrorName() const;
- std::string getErrorMessage() const;
-
void setAccountId(int account_id);
int getAccountId() const;
long getLimit() const;
long getOffset() const;
- PostQueue& getQueue() { return queue_;};
private:
AbstractFilterPtr m_filter;
SortModePtr m_sort;
long m_limit;
long m_offset;
- bool m_is_error;
- std::string m_err_name;
- std::string m_err_message;
std::vector<std::shared_ptr<MessageConversation>> m_conversations;
int m_account_id;
MessageType m_service_type;
- PostQueue& queue_;
};
}//messaging
int service_id,
MessageType service_type,
PostQueue& queue) :
- m_callback_data(cid, queue, true),
+ m_callback_data(queue, cid, true),
m_id(service_id),
m_msg_type(service_type),
m_is_act(true)
LoggerD("Calling:%s with:%d added conversations", CONVERSATIONSADDED,
filtered.size());
- auto json = m_callback_data.getJson();
- picojson::object& obj = json->get<picojson::object>();
- obj[JSON_ACTION] = picojson::value(CONVERSATIONSADDED);
- obj[JSON_DATA] = picojson::value(array);
-
- m_callback_data.getQueue().addAndResolve(obj.at(
- JSON_CALLBACK_ID).get<double>(), PostPriority::MEDIUM, json->serialize());
+ m_callback_data.SetAction(CONVERSATIONSADDED, picojson::value(array));
+ m_callback_data.AddAndPost(PostPriority::MEDIUM);
}
void ConversationsChangeCallback::updated(
LoggerD("Calling:%s with:%d added conversations", CONVERSATIONSUPDATED,
filtered.size());
- auto json = m_callback_data.getJson();
- picojson::object& obj = json->get<picojson::object>();
- obj[JSON_ACTION] = picojson::value(CONVERSATIONSUPDATED);
- obj[JSON_DATA] = picojson::value(array);
-
- m_callback_data.getQueue().addAndResolve(obj.at(
- JSON_CALLBACK_ID).get<double>(), PostPriority::LOW, json->serialize());
+ m_callback_data.SetAction(CONVERSATIONSUPDATED, picojson::value(array));
+ m_callback_data.AddAndPost(PostPriority::LOW);
}
void ConversationsChangeCallback::removed(
LoggerD("Calling:%s with:%d added conversations", CONVERSATIONSREMOVED,
filtered.size());
- auto json = m_callback_data.getJson();
- picojson::object& obj = json->get<picojson::object>();
- obj[JSON_ACTION] = picojson::value(CONVERSATIONSREMOVED);
- obj[JSON_DATA] = picojson::value(array);
-
- m_callback_data.getQueue().addAndResolve(obj.at(
- JSON_CALLBACK_ID).get<double>(), PostPriority::LAST, json->serialize());
+ m_callback_data.SetAction(CONVERSATIONSREMOVED, picojson::value(array));
+ m_callback_data.AddAndPost(PostPriority::LAST);
}
void ConversationsChangeCallback::setFilter(tizen::AbstractFilterPtr filter)
return false;
}
- auto json = callback->getJson();
- picojson::object& obj = json->get<picojson::object>();
- if (json->contains(JSON_CALLBACK_ID) && obj.at(JSON_CALLBACK_ID).is<double>()) {
- if (callback->isError()) {
- LoggerD("Calling error callback");
- callback->getQueue().resolve(obj.at(JSON_CALLBACK_ID).get<double>(),
- json->serialize()
- );
- callback->getMessage()->setMessageStatus(MessageStatus::STATUS_FAILED);
- } else {
- LoggerD("Calling success callback");
- obj[JSON_ACTION] = picojson::value(JSON_CALLBACK_SUCCCESS);
-
- picojson::object args;
- args[JSON_DATA_MESSAGE] = MessagingUtil::messageToJson(callback->getMessage());
- obj[JSON_DATA] = picojson::value(args);
-
- callback->getQueue().resolve(
- obj.at(JSON_CALLBACK_ID).get<double>(),
- json->serialize()
- );
- }
- } else {
- LoggerE("Callback id is missing");
+ if (callback->IsError()) {
+ LoggerD("Calling error callback");
callback->getMessage()->setMessageStatus(MessageStatus::STATUS_FAILED);
+ } else {
+ LoggerD("Calling success callback");
+
+ picojson::object args;
+ args[JSON_DATA_MESSAGE] = MessagingUtil::messageToJson(callback->getMessage());
+ callback->SetSuccess(picojson::value(args));
}
+ callback->Post();
+
delete callback;
callback = NULL;
PlatformResult ret = addDraftMessagePlatform(callback->getAccountId(), message);
if (ret.IsError()) {
LoggerE("%d (%s)", ret.error_code(), ret.message().c_str());
- callback->setError(ret);
+ callback->SetError(ret);
}
}
//Complete task
return false;
}
- auto json = callback->getJson();
- picojson::object& obj = json->get<picojson::object>();
- if (json->contains(JSON_CALLBACK_ID) && obj.at(JSON_CALLBACK_ID).is<double>()) {
- if (callback->isError()) {
- LoggerD("Calling error callback");
- callback->getQueue().resolve(obj.at(JSON_CALLBACK_ID).get<double>(),
- json->serialize()
- );
- callback->getMessage()->setMessageStatus(MessageStatus::STATUS_FAILED);
- }
- else {
- LoggerD("Calling success callback");
- obj[JSON_ACTION] = picojson::value(JSON_CALLBACK_SUCCCESS);
-
- std::vector<picojson::value> recipients;
- auto addToRecipients = [&recipients](std::string& e)->void {
- recipients.push_back(picojson::value(e));
- };
-
- auto toVect = callback->getMessage()->getTO();
- std::for_each(toVect.begin(), toVect.end(), addToRecipients);
-
- auto ccVect = callback->getMessage()->getCC();
- std::for_each(ccVect.begin(), ccVect.end(), addToRecipients);
-
- auto bccVect = callback->getMessage()->getBCC();
- std::for_each(bccVect.begin(), bccVect.end(), addToRecipients);
-
- picojson::object data;
- data[JSON_DATA_RECIPIENTS] = picojson::value(recipients);
- data[JSON_DATA_MESSAGE] = MessagingUtil::messageToJson(callback->getMessage());
- obj[JSON_DATA] = picojson::value(data);
-
- callback->getQueue().resolve(
- obj.at(JSON_CALLBACK_ID).get<double>(),
- json->serialize()
- );
- callback->getMessage()->setMessageStatus(MessageStatus::STATUS_SENT);
- }
- } else {
- LoggerE("Callback id is missing");
+ if (callback->IsError()) {
+ LoggerD("Calling error callback");
+ callback->getMessage()->setMessageStatus(MessageStatus::STATUS_FAILED);
+ }
+ else {
+ LoggerD("Calling success callback");
+
+ std::vector<picojson::value> recipients;
+ auto addToRecipients = [&recipients](std::string& e)->void {
+ recipients.push_back(picojson::value(e));
+ };
+
+ auto toVect = callback->getMessage()->getTO();
+ std::for_each(toVect.begin(), toVect.end(), addToRecipients);
+
+ auto ccVect = callback->getMessage()->getCC();
+ std::for_each(ccVect.begin(), ccVect.end(), addToRecipients);
+
+ auto bccVect = callback->getMessage()->getBCC();
+ std::for_each(bccVect.begin(), bccVect.end(), addToRecipients);
+
+ picojson::object data;
+ data[JSON_DATA_RECIPIENTS] = picojson::value(recipients);
+ data[JSON_DATA_MESSAGE] = MessagingUtil::messageToJson(callback->getMessage());
+
+ callback->SetSuccess(picojson::value(data));
+ callback->getMessage()->setMessageStatus(MessageStatus::STATUS_SENT);
}
+ callback->Post();
+
delete callback;
callback = NULL;
if (!platform_result) {
LoggerE("Message send failed");
- callback->setError(platform_result);
+ callback->SetError(platform_result);
if (!g_idle_add(sendEmailCompleteCB, static_cast<void*>(callback))) {
LoggerE("g_idle addition failed");
case EMAIL_ERROR_NO_RESPONSE:
{
LoggerE("Network error %d", error_code);
- common::NetworkException e("Failed to send message");
- callback->setError(e.name(), e.message());
+ callback->SetError(PlatformResult(ErrorCode::NETWORK_ERR, "Failed to send message"));
break;
}
default:
LoggerE("Unknown error %d", error_code);
- common::UnknownException ex("Failed to send message");
- callback->setError(ex.name(),ex.message());
+ callback->SetError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Failed to send message"));
break;
}
} else if (NOTI_SEND_FINISH == status) {
LoggerE("Email cancel job failed, %d", err);
}
- std::shared_ptr<picojson::value> response = callback->getJson();
- picojson::object& obj = response->get<picojson::object>();
-
- if (response->contains(JSON_CALLBACK_ID) && obj.at(JSON_CALLBACK_ID).is<double>()) {
- callback->setError(PlatformResult(ErrorCode::ABORT_ERR, "Sync aborted by user"));
+ callback->SetError(PlatformResult(ErrorCode::ABORT_ERR, "Sync aborted by user"));
- callback->getQueue().resolve(obj.at(JSON_CALLBACK_ID).get<double>(),
- response->serialize());
- m_proxy_sync->removeCallback(op_id);
- } else {
- LoggerE("Callback id is missing");
- }
+ callback->Post();
+ m_proxy_sync->removeCallback(op_id);
}
//################################## ^stopSync #################################
LoggerD("Entered");
for (auto it = m_sendRequests.begin(); it != m_sendRequests.end();) {
- if (&it->second->getQueue() == &q) {
+ if (it->second->HasQueue(q)) {
delete it->second;
m_sendRequests.erase(it++);
} else {
return;
}
- auto json = callback->getJson();
- picojson::object& obj = json->get<picojson::object>();
- if (json->contains(JSON_CALLBACK_ID) && obj.at(JSON_CALLBACK_ID).is<double>()) {
- if (callback->isError()) {
- LoggerD("Calling error callback");
- callback->getQueue().resolve(obj.at(JSON_CALLBACK_ID).get<double>(),
- json->serialize()
- );
- } else {
- LoggerD("Calling success callback");
- obj[JSON_ACTION] = picojson::value(JSON_CALLBACK_SUCCCESS);
- callback->getQueue().resolve(obj.at(JSON_CALLBACK_ID).get<double>(),
- json->serialize()
- );
- }
+ if (callback->IsError()) {
+ LoggerD("Calling error callback");
+
} else {
- LoggerE("Callback id is missing");
+ LoggerD("Calling success callback");
+
+ callback->SetSuccess();
}
+ callback->Post();
+
delete callback;
callback = NULL;
}
MessagesCallbackUserData* callback = it->callback;
if (NOTI_MAIL_DELETE_FAIL == status) {
LoggerD("Failed to remove mail");
- UnknownException e("Messages remove failed");
- callback->setError(e.name(), e.message());
+ callback->SetError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Messages remove failed"));
}
//if one of mails failed, call error callback
//if all mails are deleted, call success.
callback->SetError(ret);
}
- auto json = callback->getJson();
- picojson::object& obj = json->get<picojson::object>();
- if (json->contains(JSON_CALLBACK_ID) && obj.at(JSON_CALLBACK_ID).is<double>()) {
- if (callback->isError()) {
- LoggerD("Calling error callback");
- callback->getQueue().resolve(obj.at(JSON_CALLBACK_ID).get<double>(),
- json->serialize());
- } else {
- LoggerD("Calling success callback");
- obj[JSON_ACTION] = picojson::value(JSON_CALLBACK_SUCCCESS);
-
- picojson::array array;
- auto messages = callback->getMessages();
- size_t messages_size = messages.size();
- for (size_t i = 0 ; i < messages_size; ++i) {
- array.push_back(MessagingUtil::messageToJson(messages[i]));
- }
- obj[JSON_DATA] = picojson::value(array);
+ if (callback->IsError()) {
+ LoggerD("Calling error callback");
+ } else {
+ LoggerD("Calling success callback");
- callback->getQueue().resolve(obj.at(JSON_CALLBACK_ID).get<double>(),
- json->serialize()
- );
+ picojson::array array;
+ auto messages = callback->getMessages();
+ size_t messages_size = messages.size();
+ for (size_t i = 0 ; i < messages_size; ++i) {
+ array.push_back(MessagingUtil::messageToJson(messages[i]));
}
- } else {
- LoggerE("Callback id is missing");
+
+ callback->SetSuccess(picojson::value(array));
}
+
+ callback->Post();
+
delete callback;
callback = NULL;
}
}
//Complete task
- LoggerD("callback: %p error: %d messages.size() = %d", callback, callback->isError(),
+ LoggerD("callback: %p error: %d messages.size() = %d", callback, callback->IsError(),
callback->getMessages().size());
- auto json = callback->getJson();
- picojson::object& obj = json->get<picojson::object>();
- if (json->contains(JSON_CALLBACK_ID) && obj.at(JSON_CALLBACK_ID).is<double>()) {
- if (callback->isError()) {
- LoggerD("Calling error callback");
- callback->getQueue().resolve( obj.at(JSON_CALLBACK_ID).get<double>(),
- json->serialize());
- } else {
- LoggerD("Calling success callback");
- std::vector<picojson::value> response;
- auto messages = callback->getMessages();
- std::for_each(messages.begin(), messages.end(), [&response](MessagePtr &message){
- response.push_back(MessagingUtil::messageToJson(message));
- });
- obj[JSON_DATA] = picojson::value(response);
- obj[JSON_ACTION] = picojson::value(JSON_CALLBACK_SUCCCESS);
+ if (callback->IsError()) {
+ LoggerD("Calling error callback");
- callback->getQueue().resolve(obj.at(JSON_CALLBACK_ID).get<double>(),
- json->serialize());
- }
} else {
- LoggerE("Failed to call findMessages callback.");
+ LoggerD("Calling success callback");
+ std::vector<picojson::value> response;
+ auto messages = callback->getMessages();
+ std::for_each(messages.begin(), messages.end(), [&response](MessagePtr &message){
+ response.push_back(MessagingUtil::messageToJson(message));
+ });
+
+ callback->SetSuccess(picojson::value(response));
}
+ callback->Post();
+
delete callback;
callback = NULL;
}
}
//Complete task
- LoggerD("callback: %p error:%d conversations.size()=%d", callback, callback->isError(),
+ LoggerD("callback: %p error:%d conversations.size()=%d", callback, callback->IsError(),
callback->getConversations().size());
- auto json = callback->getJson();
- picojson::object& obj = json->get<picojson::object>();
- if (json->contains(JSON_CALLBACK_ID) && obj.at(JSON_CALLBACK_ID).is<double>()) {
- if (callback->isError()) {
- LoggerD("Calling error callback");
- callback->getQueue().resolve(obj.at(JSON_CALLBACK_ID).get<double>(),
- json->serialize());
- } else {
- LoggerD("Calling success callback");
-
- std::vector<picojson::value> response;
- auto messages = callback->getConversations();
- std::for_each(messages.begin(), messages.end(),
- [&response](std::shared_ptr<MessageConversation> &conversation) {
- response.push_back(MessagingUtil::conversationToJson(conversation));
- }
- );
- obj[JSON_DATA] = picojson::value(response);
- obj[JSON_ACTION] = picojson::value(JSON_CALLBACK_SUCCCESS);
+ if (callback->IsError()) {
+ LoggerD("Calling error callback");
+ } else {
+ LoggerD("Calling success callback");
- callback->getQueue().resolve(obj.at(JSON_CALLBACK_ID).get<double>(),
- json->serialize()
- );
+ std::vector<picojson::value> response;
+ auto messages = callback->getConversations();
+ std::for_each(messages.begin(), messages.end(),
+ [&response](std::shared_ptr<MessageConversation> &conversation) {
+ response.push_back(MessagingUtil::conversationToJson(conversation));
}
- } else {
- LoggerE("Failed to call findConversations callback.");
+ );
+
+ callback->SetSuccess(picojson::value(response));
}
+ callback->Post();
+
delete callback;
callback = NULL;
}
}
//Complete task
- LoggerD("callback: %p error:%d folders.size()=%d", callback, callback->isError(),
+ LoggerD("callback: %p error:%d folders.size()=%d", callback, callback->IsError(),
callback->getFolders().size());
- auto json = callback->getJson();
- picojson::object& obj = json->get<picojson::object>();
- if (json->contains(JSON_CALLBACK_ID) && obj.at(JSON_CALLBACK_ID).is<double>()) {
- if (callback->isError()) {
- LoggerD("Calling error callback");
- callback->getQueue().resolve(obj.at(JSON_CALLBACK_ID).get<double>(),
- json->serialize());
- } else {
- LoggerD("Calling success callback");
-
- std::vector<picojson::value> response;
- auto folders = callback->getFolders();
- std::for_each(folders.begin(), folders.end(),
- [&response](std::shared_ptr<MessageFolder> &folder) {
- response.push_back(MessagingUtil::folderToJson(folder));
- }
- );
- obj[JSON_DATA] = picojson::value(response);
- obj[JSON_ACTION] = picojson::value(JSON_CALLBACK_SUCCCESS);
+ if (callback->IsError()) {
+ LoggerD("Calling error callback");
+ } else {
+ LoggerD("Calling success callback");
- callback->getQueue().resolve(obj.at(JSON_CALLBACK_ID).get<double>(),
- json->serialize());
+ std::vector<picojson::value> response;
+ auto folders = callback->getFolders();
+ std::for_each(folders.begin(), folders.end(),
+ [&response](std::shared_ptr<MessageFolder> &folder) {
+ response.push_back(MessagingUtil::folderToJson(folder));
}
- } else {
- LoggerE("Unknown error when calling findFolders callback.");
+ );
+
+ callback->SetSuccess(picojson::value(response));
}
+ callback->Post();
+
delete callback;
callback = NULL;
}
callback->SetError(ret);
}
- auto json = callback->getJson();
- picojson::object& obj = json->get<picojson::object>();
- if (json->contains(JSON_CALLBACK_ID) && obj.at(JSON_CALLBACK_ID).is<double>()) {
- if (callback->isError()) {
- LoggerD("Calling error callback");
- callback->getQueue().resolve(obj.at(JSON_CALLBACK_ID).get<double>(),
- json->serialize());
- } else {
- LoggerD("Calling success callback");
- obj[JSON_ACTION] = picojson::value(JSON_CALLBACK_SUCCCESS);
-
- callback->getQueue().resolve(obj.at(JSON_CALLBACK_ID).get<double>(),
- json->serialize());
- }
+ if (callback->IsError()) {
+ LoggerD("Calling error callback");
} else {
- LoggerE("Unknown error when calling removeConversations callback.");
+ LoggerD("Calling success callback");
+
+ callback->SetSuccess();
}
+ callback->Post();
+
delete callback;
callback = NULL;
}
#include "email-api-mail.h"
#include "email-api-mailbox.h"
-#include "common/callback_user_data.h"
+#include "messaging/callback_user_data.h"
#include "common/GDBus/connection.h"
#include "common/platform_exception.h"
#include "common/platform_result.h"
namespace extension {
namespace messaging {
-FindMsgCallbackUserData::FindMsgCallbackUserData(PostQueue& queue):
- CallbackUserData(),
- m_limit(0),
- m_offset(0),
- m_is_error(false),
- m_account_id(0),
- m_service_type(UNDEFINED),
- queue_(queue)
-{
- LoggerD("Entered");
+FindMsgCallbackUserData::FindMsgCallbackUserData(PostQueue& queue, long cid) :
+ CallbackUserData(queue, cid),
+ m_limit(0),
+ m_offset(0),
+ m_account_id(0),
+ m_service_type(UNDEFINED) {
+ LoggerD("Entered");
}
FindMsgCallbackUserData::~FindMsgCallbackUserData()
return m_messages;
}
-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;
-
- picojson::object& obj = m_json->get<picojson::object>();
- obj[JSON_ACTION] = picojson::value(JSON_CALLBACK_ERROR);
-
- auto obj_error = picojson::object();
- obj_error[JSON_ERROR_NAME] = picojson::value(err_name);
- obj_error[JSON_ERROR_MESSAGE] = picojson::value(err_message);
- obj[JSON_DATA] = picojson::value(obj_error);
- }
-}
-
-void FindMsgCallbackUserData::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);
- auto obj_data = picojson::object();
- obj_data[JSON_ERROR_CODE] = picojson::value(static_cast<double>(error.error_code()));
- obj_data[JSON_ERROR_MESSAGE] = picojson::value(error.message());
- obj[JSON_DATA] = picojson::value(obj_data);
- }
-}
-
-bool FindMsgCallbackUserData::isError() const
-{
- return m_is_error;
-}
-
-std::string FindMsgCallbackUserData::getErrorName() const
-{
- return m_err_name;
-}
-
-std::string FindMsgCallbackUserData::getErrorMessage() const
-{
- return m_err_message;
-}
-
void FindMsgCallbackUserData::setAccountId(int account_id){
m_account_id = account_id;
}
#ifndef __TIZEN_FIND_MSG_CALLBACK_USER_DATA_H
#define __TIZEN_FIND_MSG_CALLBACK_USER_DATA_H
-#include "common/callback_user_data.h"
#include <memory>
#include <string>
#include <vector>
+
+#include "messaging/callback_user_data.h"
#include "MsgCommon/AttributeFilter.h"
#include "MsgCommon/SortMode.h"
#include "messaging_util.h"
class Message;
-class FindMsgCallbackUserData: public common::CallbackUserData {
+class FindMsgCallbackUserData : public CallbackUserData {
public:
- FindMsgCallbackUserData(PostQueue& queue);
+ FindMsgCallbackUserData(PostQueue& queue, long cid);
virtual ~FindMsgCallbackUserData();
void setFilter(AbstractFilterPtr filter);
void addMessage(std::shared_ptr<Message> msg);
std::vector<std::shared_ptr<Message>> getMessages() const;
- void setError(const std::string& err_name,
- const std::string& err_message);
- void SetError(const common::PlatformResult& error);
- bool isError() const;
- std::string getErrorName() const;
- std::string getErrorMessage() const;
-
void setAccountId(int account_id);
int getAccountId() const;
long getLimit() const;
long getOffset() const;
- PostQueue& getQueue() { return queue_;};
private:
AbstractFilterPtr m_filter;
SortModePtr m_sort;
long m_limit;
long m_offset;
- bool m_is_error;
- std::string m_err_name;
- std::string m_err_message;
std::vector<std::shared_ptr<Message>> m_messages;
int m_account_id;
MessageType m_service_type;
- PostQueue& queue_;
};
}//Messaging
namespace extension {
namespace messaging {
-
-FoldersCallbackData::FoldersCallbackData(PostQueue& queue):
- m_filter(),
- m_is_error(false),
- queue_(queue)
-{
- LoggerD("Entered");
-}
-
-FoldersCallbackData::FoldersCallbackData(long cid, PostQueue& queue, bool keep):
- m_filter(),
- 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));
- o[JSON_CALLBACK_KEEP] = picojson::value(keep);
- setJson(json);
-}
-
FoldersCallbackData::~FoldersCallbackData() {
LoggerD("Entered");
}
return m_filter;
}
-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;
-
- picojson::object& obj = m_json->get<picojson::object>();
- obj[JSON_ACTION] = picojson::value(JSON_CALLBACK_ERROR);
-
- auto obj_error = picojson::object();
- obj_error[JSON_ERROR_NAME] = picojson::value(err_name);
- obj_error[JSON_ERROR_MESSAGE] = picojson::value(err_message);
- obj[JSON_DATA] = picojson::value(obj_error);
- }
-}
-
-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);
- auto obj_data = picojson::object();
- obj_data[JSON_ERROR_CODE] = picojson::value(static_cast<double>(error.error_code()));
- obj_data[JSON_ERROR_MESSAGE] = picojson::value(error.message());
- obj[JSON_DATA] = picojson::value(obj_data);
- }
-}
-
-bool FoldersCallbackData::isError() const
-{
- return m_is_error;
-}
-
-std::string FoldersCallbackData::getErrorName() const
-{
- return m_err_name;
-}
-
-std::string FoldersCallbackData::getErrorMessage() const
-{
- return m_err_message;
-}
-
}//messaging
}//extension
#ifndef __TIZEN_FOLDERS_CALLBACK_DATA_H__
#define __TIZEN_FOLDERS_CALLBACK_DATA_H__
-#include "common/callback_user_data.h"
#include "common/platform_result.h"
#include <memory>
#include <vector>
#include <string>
+#include "messaging/callback_user_data.h"
#include "MsgCommon/AbstractFilter.h"
#include "message_folder.h"
class MessageFolder;
-class FoldersCallbackData: public common::CallbackUserData {
+class FoldersCallbackData : public CallbackUserData {
public:
- FoldersCallbackData(PostQueue& queue);
- FoldersCallbackData(long cid, PostQueue& queue, bool keep = false);
+ using CallbackUserData::CallbackUserData;
virtual ~FoldersCallbackData();
void addFolder(std::shared_ptr<MessageFolder> folder);
void setFilter(tizen::AbstractFilterPtr filter);
tizen::AbstractFilterPtr getFilter() const;
- void setError(const std::string& err_name,
- const std::string& err_message);
- void SetError(const common::PlatformResult& error);
- bool isError() const;
- std::string getErrorName() const;
- std::string getErrorMessage() const;
-
- PostQueue& getQueue() { return queue_;};
private:
std::vector<std::shared_ptr<MessageFolder>> m_folders;
tizen::AbstractFilterPtr m_filter;
- bool m_is_error;
- std::string m_err_name;
- std::string m_err_message;
- PostQueue& queue_;
-
};
}//messaging
int service_id,
MessageType service_type,
PostQueue& queue):
- m_callback_data(cid, queue, true),
+ m_callback_data(queue, cid, true),
m_id(service_id),
m_msg_type(service_type),
m_is_act(true)
LoggerD("Calling:%s with:%d added folders", FOLDERSADDED,
filtered.size());
- auto json = m_callback_data.getJson();
- picojson::object& obj = json->get<picojson::object>();
- obj[JSON_ACTION] = picojson::value(FOLDERSADDED);
- obj[JSON_DATA] = picojson::value(array);
-
- if (json->contains(JSON_CALLBACK_ID) && obj.at(JSON_CALLBACK_ID).is<double>()) {
- m_callback_data.getQueue().addAndResolve(obj.at(
- JSON_CALLBACK_ID).get<double>(), PostPriority::MEDIUM, json->serialize());
- } else {
- LoggerE("Callback id is missing");
- }
+ m_callback_data.SetAction(FOLDERSADDED, picojson::value(array));
+ m_callback_data.AddAndPost(PostPriority::MEDIUM);
}
void FoldersChangeCallback::updated(const FolderPtrVector& folders)
LoggerD("Calling:%s with:%d updated folders", FOLDERSUPDATED,
filtered.size());
- auto json = m_callback_data.getJson();
- picojson::object& obj = json->get<picojson::object>();
- obj[JSON_ACTION] = picojson::value(FOLDERSUPDATED);
- obj[JSON_DATA] = picojson::value(array);
-
- if (json->contains(JSON_CALLBACK_ID) && obj.at(JSON_CALLBACK_ID).is<double>()) {
- m_callback_data.getQueue().addAndResolve(obj.at(
- JSON_CALLBACK_ID).get<double>(), PostPriority::LOW, json->serialize());
- } else {
- LoggerE("Callback id is missing");
- }
+ m_callback_data.SetAction(FOLDERSUPDATED, picojson::value(array));
+ m_callback_data.AddAndPost(PostPriority::LOW);
}
void FoldersChangeCallback::removed(const FolderPtrVector& folders)
LoggerD("Calling:%s with:%d removed folders", FOLDERSREMOVED,
filtered.size());
- auto json = m_callback_data.getJson();
- picojson::object& obj = json->get<picojson::object>();
- obj[JSON_ACTION] = picojson::value(FOLDERSREMOVED);
- obj[JSON_DATA] = picojson::value(array);
-
- if (json->contains(JSON_CALLBACK_ID) && obj.at(JSON_CALLBACK_ID).is<double>()) {
- m_callback_data.getQueue().addAndResolve(obj.at(
- JSON_CALLBACK_ID).get<double>(), PostPriority::LAST, json->serialize());
- } else {
- LoggerE("Callback id is missing");
- }
+ m_callback_data.SetAction(FOLDERSREMOVED, picojson::value(array));
+ m_callback_data.AddAndPost(PostPriority::LAST);
}
void FoldersChangeCallback::setFilter(tizen::AbstractFilterPtr filter)
namespace extension {
namespace messaging {
-MessageCallbackUserData::MessageCallbackUserData(PostQueue& queue):
- common::CallbackUserData(),
- m_is_error(false),
- queue_(queue),
- m_account_id(-1)
-{
- LoggerD("Entered");
+MessageCallbackUserData::MessageCallbackUserData(PostQueue& queue, long cid) :
+ CallbackUserData(queue, cid),
+ m_account_id(0) {
+ LoggerD("Entered");
}
MessageCallbackUserData::~MessageCallbackUserData() {
return m_account_id;
}
-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();
-
- objData[JSON_ERROR_NAME] = picojson::value(err_name);
- objData[JSON_ERROR_MESSAGE] = picojson::value(err_message);
-
- obj[JSON_DATA] = picojson::value(objData);
-
- m_is_error = true;
- m_err_name = err_name;
- m_err_message = err_message;
- }
-}
-
-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);
- auto obj_data = picojson::object();
-
- obj_data[JSON_ERROR_CODE] = picojson::value(static_cast<double>(error.error_code()));
- obj_data[JSON_ERROR_MESSAGE] = picojson::value(error.message());
-
- obj[JSON_DATA] = picojson::value(obj_data);
- }
-}
-
-bool MessageCallbackUserData::isError() const
-{
- return m_is_error;
-}
-
-std::string MessageCallbackUserData::getErrorName() const
-{
- return m_err_name;
-}
-
-std::string MessageCallbackUserData::getErrorMessage() const
-{
- return m_err_message;
-}
-
}//messaging
}//extension
#ifndef MESSAGING_MESSAGE_CALLBACK_USER_DATA_H_
#define MESSAGING_MESSAGE_CALLBACK_USER_DATA_H_
-#include "common/callback_user_data.h"
#include "common/platform_result.h"
#include <memory>
#include <string>
+#include "messaging/callback_user_data.h"
namespace extension {
namespace messaging {
class Message;
class PostQueue;
-class MessageCallbackUserData: public common::CallbackUserData {
+class MessageCallbackUserData : public CallbackUserData {
public:
- MessageCallbackUserData(PostQueue& queue);
+ MessageCallbackUserData(PostQueue& queue, long cid);
virtual ~MessageCallbackUserData();
void setMessage(std::shared_ptr<Message> message);
void setAccountId(int account_id);
int getAccountId() const;
- void setError(const std::string& err_name,
- const std::string& err_message);
- void setError(const common::PlatformResult& error);
- bool isError() const;
- std::string getErrorName() const;
- std::string getErrorMessage() const;
-
- PostQueue& getQueue() { return queue_;};
-
private:
- bool m_is_error;
- PostQueue& queue_;
- std::string m_err_name;
- std::string m_err_message;
std::shared_ptr<Message> m_message;
int m_account_id;
-
};
}//messaging
//#################### MessageRecipientsCallbackData ####################
-MessageRecipientsCallbackData::MessageRecipientsCallbackData(PostQueue& queue):
- m_is_error(false),
- m_account_id(-1),
- m_sim_index(TAPI_NETWORK_DEFAULT_DATA_SUBS_UNKNOWN),
- m_default_sim_index(TAPI_NETWORK_DEFAULT_DATA_SUBS_UNKNOWN),
- queue_(queue)
-{
- LoggerD("Entered");
- m_msg_recipients = std::vector<std::string>();
+MessageRecipientsCallbackData::MessageRecipientsCallbackData(PostQueue& queue, long cid) :
+ CallbackUserData(queue, cid),
+ m_account_id(-1),
+ m_sim_index(TAPI_NETWORK_DEFAULT_DATA_SUBS_UNKNOWN),
+ m_default_sim_index(TAPI_NETWORK_DEFAULT_DATA_SUBS_UNKNOWN) {
+ LoggerD("Entered");
}
MessageRecipientsCallbackData::~MessageRecipientsCallbackData()
return m_msg_recipients;
}
-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>();
- obj[JSON_ACTION] = picojson::value(JSON_CALLBACK_ERROR);
- auto obj_error = picojson::object();
-
- obj_error[JSON_ERROR_NAME] = picojson::value(err_name);
- obj_error[JSON_ERROR_MESSAGE] = picojson::value(err_message);
-
- obj[JSON_DATA] = picojson::value(obj_error);
- }
-}
-
-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>();
- obj[JSON_ACTION] = picojson::value(JSON_CALLBACK_ERROR);
- auto obj_error = picojson::object();
-
- obj_error[JSON_ERROR_CODE] = picojson::value(static_cast<double>(error.error_code()));
- obj_error[JSON_ERROR_MESSAGE] = picojson::value(error.message());
-
- obj[JSON_DATA] = picojson::value(obj_error);
- }
-}
-
-bool MessageRecipientsCallbackData::isError() const
-{
- return m_is_error;
-}
-
void MessageRecipientsCallbackData::setAccountId(int account_id){
m_account_id = account_id;
}
sim_index--;
if (sim_index >= sim_count || sim_index < -1) {
LoggerE("Sim index out of bound %d : %d", sim_index, sim_count);
- common::InvalidValuesException err("The index of sim is out of bound");
- this->setError(err.name(), err.message());
+ this->SetError(PlatformResult(ErrorCode::INVALID_VALUES_ERR, "The index of sim is out of bound"));
return false;
}
//#################### BaseMessageServiceCallbackData ####################
-BaseMessageServiceCallbackData::BaseMessageServiceCallbackData():
-// CallbackUserData(globalCtx),
- m_is_error(false),
- m_op_handle(-1),
- m_callback_id(-1)
-{
- LoggerD("Entered");
+BaseMessageServiceCallbackData::BaseMessageServiceCallbackData(PostQueue& queue, long cid) :
+ CallbackUserData(queue, cid),
+ m_op_handle(-1) {
+ LoggerD("Entered");
}
BaseMessageServiceCallbackData::~BaseMessageServiceCallbackData()
LoggerD("Entered");
}
-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>();
- obj[JSON_ACTION] = picojson::value(JSON_CALLBACK_ERROR);
-
- auto obj_error = picojson::object();
- obj_error[JSON_ERROR_NAME] = picojson::value(err_name);
- obj_error[JSON_ERROR_MESSAGE] = picojson::value(err_message);
- obj[JSON_DATA] = picojson::value(obj_error);
- }
-}
-
-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>();
- obj[JSON_ACTION] = picojson::value(JSON_CALLBACK_ERROR);
- auto obj_error = picojson::object();
-
- obj_error[JSON_ERROR_CODE] = picojson::value(static_cast<double>(error.error_code()));
- obj_error[JSON_ERROR_MESSAGE] = picojson::value(error.message());
-
- obj[JSON_DATA] = picojson::value(obj_error);
- }
-}
-
-bool BaseMessageServiceCallbackData::isError() const
-{
- return m_is_error;
-}
-
void BaseMessageServiceCallbackData::setOperationHandle(const int op_handle)
{
m_op_handle = op_handle;
return m_op_handle;
}
-void BaseMessageServiceCallbackData::setCallbackId(const double callback_id)
-{
- m_callback_id = callback_id;
-}
-
-double BaseMessageServiceCallbackData::getCallbackId() const
-{
- return m_callback_id;
-}
-
//#################### MessageBodyCallbackData ####################
-MessageBodyCallbackData::MessageBodyCallbackData(PostQueue& queue):
- queue_(queue)
-{
- LoggerD("Entered");
-}
-
MessageBodyCallbackData::~MessageBodyCallbackData()
{
LoggerD("Entered");
//#################### MessageAttachmentCallbackData ####################
-MessageAttachmentCallbackData::MessageAttachmentCallbackData(PostQueue& queue):
- m_nth(0),
- queue_(queue)
-{
- LoggerD("Entered");
+MessageAttachmentCallbackData::MessageAttachmentCallbackData(PostQueue& queue, long cid) :
+ BaseMessageServiceCallbackData(queue, cid),
+ m_nth(0) {
+ LoggerD("Entered");
}
MessageAttachmentCallbackData::~MessageAttachmentCallbackData()
//#################### SyncCallbackData ####################
-SyncCallbackData::SyncCallbackData(PostQueue& queue):
-// BaseMessageServiceCallbackData(globalCtx),
- m_is_limit(false),
- m_limit(0),
- m_op_id(-1),
- m_account_id(-1),
- queue_(queue)
-{
- LoggerD("Entered");
+
+SyncCallbackData::SyncCallbackData(PostQueue& queue, long cid) :
+ BaseMessageServiceCallbackData(queue, cid),
+ m_is_limit(false),
+ m_limit(0),
+ m_op_id(-1),
+ m_account_id(-1) {
+ LoggerD("Entered");
}
SyncCallbackData::~SyncCallbackData()
//#################### SyncFolderCallbackData ####################
-SyncFolderCallbackData::SyncFolderCallbackData(PostQueue& queue):
- SyncCallbackData(queue)
-{
- LoggerD("Entered");
-}
-
SyncFolderCallbackData::~SyncFolderCallbackData()
{
LoggerD("Entered");
#include <memory>
#include <string>
+#include "messaging/callback_user_data.h"
#include "common/picojson.h"
-#include "common/callback_user_data.h"
#include "common/platform_result.h"
#include "messaging_util.h"
MMS_ACCOUNT_ID = 102
};
-class MessageRecipientsCallbackData : public common::CallbackUserData {
+class MessageRecipientsCallbackData : public CallbackUserData {
public:
- MessageRecipientsCallbackData(PostQueue& queue);
+ MessageRecipientsCallbackData(PostQueue& queue, long cid);
virtual ~MessageRecipientsCallbackData();
void setMessage(std::shared_ptr<Message> message);
void setMessageRecipients(const std::vector<std::string>& msgRecipients);
const std::vector<std::string>& getMessageRecipients() const;
- void setError(const std::string& err_name,
- const std::string& err_message);
- void setError(const common::PlatformResult& error);
- bool isError() const;
-
void setAccountId(int account_id);
int getAccountId() const;
TelNetworkDefaultDataSubs_t getDefaultSimIndex() const;
bool isSetSimIndex() const;
- PostQueue& getQueue() { return queue_;};
-
private:
std::shared_ptr<Message> m_message;
- bool m_is_error;
std::vector<std::string> m_msg_recipients;
int m_account_id;
TelNetworkDefaultDataSubs_t m_sim_index;
TelNetworkDefaultDataSubs_t m_default_sim_index;
- PostQueue& queue_;
};
-class BaseMessageServiceCallbackData : public common::CallbackUserData {
+class BaseMessageServiceCallbackData : public CallbackUserData {
public:
- BaseMessageServiceCallbackData();
+ BaseMessageServiceCallbackData(PostQueue& queue, long cid);
virtual ~BaseMessageServiceCallbackData();
- void setError(const std::string& err_name,
- const std::string& err_message);
- void setError(const common::PlatformResult& error);
- bool isError() const;
-
/**
* This handle is returned from various native API functions:
* int email_sync_header(..., int *handle);
*/
void setOperationHandle(const int op_handle);
int getOperationHandle() const;
- void setCallbackId(const double callback_id);
- double getCallbackId() const;
protected:
- bool m_is_error;
-
int m_op_handle;
- double m_callback_id;
};
class MessageBodyCallbackData : public BaseMessageServiceCallbackData {
public:
- MessageBodyCallbackData(PostQueue& queue);
+ using BaseMessageServiceCallbackData::BaseMessageServiceCallbackData;
virtual ~MessageBodyCallbackData();
void setMessage(std::shared_ptr<Message> message);
std::shared_ptr<Message> getMessage() const;
- PostQueue& getQueue() { return queue_;};
private:
std::shared_ptr<Message> m_message;
- PostQueue& queue_;
};
class MessageAttachmentCallbackData : public BaseMessageServiceCallbackData {
public:
- MessageAttachmentCallbackData(PostQueue& queue);
+ MessageAttachmentCallbackData(PostQueue& queue, long cid);
virtual ~MessageAttachmentCallbackData();
void setMessageAttachment(std::shared_ptr<MessageAttachment> messageAttachment);
void setNth(const int nth);
int getNth() const;
- PostQueue& getQueue() { return queue_;};
private:
std::shared_ptr<MessageAttachment> m_message_attachment;
int m_nth;
- PostQueue& queue_;
};
class SyncCallbackData : public BaseMessageServiceCallbackData {
public:
- SyncCallbackData(PostQueue& queue);
+ SyncCallbackData(PostQueue& queue, long cid);
virtual ~SyncCallbackData();
void setLimit(const unsigned long limit);
void setAccountId(int account_id);
int getAccountId() const;
- PostQueue& getQueue() { return queue_;};
protected:
bool m_is_limit;
unsigned long m_limit;
long m_op_id;
int m_account_id;
- PostQueue& queue_;
};
class SyncFolderCallbackData : public SyncCallbackData {
public:
- SyncFolderCallbackData(PostQueue& queue);
+ using SyncCallbackData::SyncCallbackData;
virtual ~SyncFolderCallbackData();
void setMessageFolder(std::shared_ptr<MessageFolder> message_folder);
// if the attachment is already saved, then it doesn't need to load again.
if (att->isFilePathSet() && att->isSaved()) {
- auto json = callback->getJson();
- picojson::object& obj = json->get<picojson::object>();
- obj[JSON_ACTION] = picojson::value(JSON_CALLBACK_SUCCCESS);
-
- if (json->contains(JSON_CALLBACK_ID) && obj.at(JSON_CALLBACK_ID).is<double>()) {
- picojson::object args;
- args[JSON_DATA_MESSAGE_ATTACHMENT] = MessagingUtil::messageAttachmentToJson(att);
- obj[JSON_DATA] = picojson::value(args);
-
- callback->getQueue().resolve(
- obj.at(JSON_CALLBACK_ID).get<double>(),
- json->serialize()
- );
- } else {
- LoggerE("json is incorrect - missing required member");
- }
+ picojson::object args;
+ args[JSON_DATA_MESSAGE_ATTACHMENT] = MessagingUtil::messageAttachmentToJson(att);
+
+ callback->SetSuccess(picojson::value(args));
+ callback->Post();
+
delete callback;
callback = nullptr;
} else {
}
std::shared_ptr<MessageBody> body = callback->getMessage()->getBody();
- auto json = callback->getJson();
- picojson::object& obj = json->get<picojson::object>();
- obj[JSON_ACTION] = picojson::value(JSON_CALLBACK_SUCCCESS);
-
- if (json->contains(JSON_CALLBACK_ID) && obj.at(JSON_CALLBACK_ID).is<double>()) {
- picojson::object args;
- args[JSON_DATA_MESSAGE_BODY] = MessagingUtil::messageBodyToJson(body);
- obj[JSON_DATA] = picojson::value(args);
-
- callback->getQueue().resolve(
- obj.at(JSON_CALLBACK_ID).get<double>(),
- json->serialize()
- );
- } else {
- LoggerE("json is incorrect - missing required member");
- }
+ picojson::object args;
+ args[JSON_DATA_MESSAGE_BODY] = MessagingUtil::messageBodyToJson(body);
+
+ callback->SetSuccess(picojson::value(args));
+ callback->Post();
+
return FALSE;
}
FoldersCallbackData *callback = static_cast<FoldersCallbackData*>(data);
- auto json = callback->getJson();
- picojson::object& obj = json->get<picojson::object>();
+ picojson::array array;
+ auto each = [&array](std::shared_ptr<MessageFolder> folder)->void {
+ array.push_back(MessagingUtil::folderToJson(folder));
+ };
- if (json->contains(JSON_CALLBACK_ID) && obj.at(JSON_CALLBACK_ID).is<double>()) {
- picojson::array array;
- auto each = [&array](std::shared_ptr<MessageFolder> folder)->void {
- array.push_back(MessagingUtil::folderToJson(folder));
- };
+ auto folders = callback->getFolders();
+ for_each(folders.begin(), folders.end(), each);
- auto folders = callback->getFolders();
- for_each(folders.begin(), folders.end(), each);
+ callback->SetSuccess(picojson::value(array));
+ callback->Post();
- obj[JSON_DATA] = picojson::value(array);
- obj[JSON_ACTION] = picojson::value(JSON_CALLBACK_SUCCCESS);
-
-
- callback->getQueue().resolve(
- obj.at(JSON_CALLBACK_ID).get<double>(),
- json->serialize()
- );
- } else {
- LoggerE("json is incorrect - missing required member");
- }
delete callback;
callback = NULL;
namespace extension {
namespace messaging {
-MessagesCallbackUserData::MessagesCallbackUserData(PostQueue& queue):
- common::CallbackUserData(),
- m_is_error(false),
- m_service_type(MessageType::UNDEFINED),
- queue_(queue)
-{
- LoggerD("Entered");
-}
-
-MessagesCallbackUserData::MessagesCallbackUserData(long cid, PostQueue& queue, bool keep):
- common::CallbackUserData(),
- m_is_error(false),
- 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));
- o[JSON_CALLBACK_KEEP] = picojson::value(keep);
- setJson(json);
+MessagesCallbackUserData::MessagesCallbackUserData(PostQueue& queue, long cid, bool keep /* = false*/) :
+ CallbackUserData(queue, cid, keep),
+ m_service_type(UNDEFINED) {
+ LoggerD("Entered");
}
MessagesCallbackUserData::~MessagesCallbackUserData() {
return m_messages;
}
-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();
-
- objData[JSON_ERROR_NAME] = picojson::value(err_name);
- objData[JSON_ERROR_MESSAGE] = picojson::value(err_message);
-
- obj[JSON_DATA] = picojson::value(objData);
-
- m_is_error = true;
- m_err_name = err_name;
- m_err_message = err_message;
- }
-}
-
-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);
- auto obj_data = picojson::object();
- obj_data[JSON_ERROR_CODE] = picojson::value(static_cast<double>(error.error_code()));
- obj_data[JSON_ERROR_MESSAGE] = picojson::value(error.message());
- obj[JSON_DATA] = picojson::value(obj_data);
- }
-}
-
-bool MessagesCallbackUserData::isError() const
-{
- return m_is_error;
-}
-
-std::string MessagesCallbackUserData::getErrorName() const
-{
- return m_err_name;
-}
-
-std::string MessagesCallbackUserData::getErrorMessage() const
-{
- return m_err_message;
-}
-
void MessagesCallbackUserData::setMessageServiceType(MessageType m_msg_type)
{
m_service_type = m_msg_type;
#ifndef MESSAGING_MESSAGES_CALLBACK_USER_DATA_H_
#define MESSAGING_MESSAGES_CALLBACK_USER_DATA_H_
-#include "common/callback_user_data.h"
#include "common/platform_result.h"
#include <memory>
#include <string>
+#include "messaging/callback_user_data.h"
#include "messaging_util.h"
namespace extension {
class Message;
-class MessagesCallbackUserData: public common::CallbackUserData {
+class MessagesCallbackUserData : public CallbackUserData {
public:
- MessagesCallbackUserData(PostQueue& queue);
- MessagesCallbackUserData(long cid, PostQueue& queue, bool keep = false);
+ MessagesCallbackUserData(PostQueue& queue, long cid, bool keep = false);
virtual ~MessagesCallbackUserData();
void addMessage(std::shared_ptr<Message> msg);
std::vector<std::shared_ptr<Message>> getMessages() const;
- void setError(const std::string& err_name,
- const std::string& err_message);
- void SetError(const common::PlatformResult& error);
- bool isError() const;
- std::string getErrorName() const;
- std::string getErrorMessage() const;
-
void setMessageServiceType(MessageType m_msg_type);
MessageType getMessageServiceType() const;
- PostQueue& getQueue() { return queue_;};
-
private:
std::vector<std::shared_ptr<Message>> m_messages;
- bool m_is_error;
- std::string m_err_name;
- std::string m_err_message;
MessageType m_service_type;
- PostQueue& queue_;
};
}//messaging
int service_id,
MessageType service_type,
PostQueue& queue) :
- m_callback_data(cid, queue, true),
+ m_callback_data(queue, cid, true),
m_service_id(service_id),
m_msg_type(service_type),
m_is_act(true)
LoggerD("Calling:%s with:%d added messages", MESSAGESADDED,
filtered_msgs.size());
- auto json = m_callback_data.getJson();
- picojson::object& obj = json->get<picojson::object>();
- if (json->contains(JSON_CALLBACK_ID) && obj.at(JSON_CALLBACK_ID).is<double>()) {
- obj[JSON_ACTION] = picojson::value(MESSAGESADDED);
- obj[JSON_DATA] = picojson::value(array);
-
- m_callback_data.getQueue().addAndResolve(obj.at(
- JSON_CALLBACK_ID).get<double>(), PostPriority::MEDIUM, json->serialize());
- } else {
- LoggerE("json is incorrect - missing required member");
- }
+ m_callback_data.SetAction(MESSAGESADDED, picojson::value(array));
+ m_callback_data.AddAndPost(PostPriority::MEDIUM);
}
void MessagesChangeCallback::updated(const MessagePtrVector& msgs)
LoggerD("Calling:%s with:%d updated messages", MESSAGESUPDATED,
filtered_msgs.size());
- auto json = m_callback_data.getJson();
- picojson::object& obj = json->get<picojson::object>();
- if (json->contains(JSON_CALLBACK_ID) && obj.at(JSON_CALLBACK_ID).is<double>()) {
- obj[JSON_ACTION] = picojson::value(MESSAGESUPDATED);
- obj[JSON_DATA] = picojson::value(array);
-
- m_callback_data.getQueue().addAndResolve(obj.at(
- JSON_CALLBACK_ID).get<double>(), PostPriority::LOW, json->serialize());
- } else {
- LoggerE("json is incorrect - missing required member");
- }
+ m_callback_data.SetAction(MESSAGESUPDATED, picojson::value(array));
+ m_callback_data.AddAndPost(PostPriority::LOW);
}
void MessagesChangeCallback::removed(const MessagePtrVector& msgs)
LoggerD("Calling:%s with:%d removed messages", MESSAGESREMOVED,
filtered_msgs.size());
- auto json = m_callback_data.getJson();
- picojson::object& obj = json->get<picojson::object>();
- if (json->contains(JSON_CALLBACK_ID) && obj.at(JSON_CALLBACK_ID).is<double>()) {
- obj[JSON_ACTION] = picojson::value(MESSAGESREMOVED);
- LoggerD("MESSAGES: %s", picojson::value(array).serialize().c_str());
- obj[JSON_DATA] = picojson::value(array);
-
- m_callback_data.getQueue().addAndResolve(obj.at(
- JSON_CALLBACK_ID).get<double>(), PostPriority::LAST, json->serialize());
- } else {
- LoggerE("json is incorrect - missing required member");
- }
+ m_callback_data.SetAction(MESSAGESREMOVED, picojson::value(array));
+ m_callback_data.AddAndPost(PostPriority::LAST);
}
void MessagesChangeCallback::setFilter(tizen::AbstractFilterPtr filter)
},
'sources': [
'messaging_api.js',
+ 'callback_user_data.cc',
+ 'callback_user_data.h',
'email_manager.cc',
'email_manager.h',
'messaging_instance.cc',
POST_AND_RETURN(ret, json, obj, JSON_CALLBACK_ERROR)
}
- MessageRecipientsCallbackData* callback = new MessageRecipientsCallbackData(queue_);
+ MessageRecipientsCallbackData* callback = new MessageRecipientsCallbackData(queue_, callbackId);
long simIndex = 0;
int serviceId = 0;
- callback->setJson(json);
callback->setMessage(message);
serviceId = getServiceIdFromJSON(data);
callback->setAccountId(serviceId);
json, obj, JSON_CALLBACK_ERROR)
}
- queue_.add(static_cast<long>(callbackId), PostPriority::HIGH);
+ callback->AddToQueue();
auto service = manager_.getMessageService(serviceId);
ret = service->sendMessage(callback);
POST_AND_RETURN(ret, json, obj, JSON_CALLBACK_ERROR)
}
- MessageBodyCallbackData* callback = new MessageBodyCallbackData(queue_);
+ MessageBodyCallbackData* callback = new MessageBodyCallbackData(queue_, callbackId);
- callback->setJson(json);
callback->setMessage(message);
- queue_.add(static_cast<long>(callbackId), PostPriority::HIGH);
+ callback->AddToQueue();
auto service = manager_.getMessageService(getServiceIdFromJSON(data));
ret = service->loadMessageBody(callback);
if (ret.IsError()) {
picojson::value attachment = data.at(LOAD_MESSAGE_ATTACHMENT_ARGS_ATTACHMENT);
const double callbackId = args.get(JSON_CALLBACK_ID).get<double>();
- MessageAttachmentCallbackData* callback = new MessageAttachmentCallbackData(queue_);
+ MessageAttachmentCallbackData* callback = new MessageAttachmentCallbackData(queue_, callbackId);
callback->setMessageAttachment(MessagingUtil::jsonToMessageAttachment(attachment));
- auto json = std::shared_ptr<picojson::value>(new picojson::value(picojson::object()));
- picojson::object& obj = json->get<picojson::object>();
- obj[JSON_CALLBACK_ID] = picojson::value(callbackId);
- callback->setJson(json);
-
- queue_.add(static_cast<long>(callbackId), PostPriority::HIGH);
+ callback->AddToQueue();
auto service = manager_.getMessageService(getServiceIdFromJSON(data));
const auto result = service->loadMessageAttachment(callback);
if (result.IsError()) {
+ auto json = std::shared_ptr<picojson::value>(new picojson::value(picojson::object()));
+ picojson::object& obj = json->get<picojson::object>();
+ obj[JSON_CALLBACK_ID] = picojson::value(callbackId);
POST_AND_RETURN(result, json, obj, JSON_CALLBACK_ERROR)
}
}
limit = static_cast<long>(v_limit.get<double>());
}
- auto json = std::shared_ptr<picojson::value>(new picojson::value(picojson::object()));
- picojson::object& obj = json->get<picojson::object>();
- obj[JSON_CALLBACK_ID] = picojson::value(callbackId);
-
- SyncCallbackData *callback = new SyncCallbackData(queue_);
- callback->setJson(json);
+ SyncCallbackData *callback = new SyncCallbackData(queue_, callbackId);
callback->setAccountId(id);
callback->setLimit(limit);
- queue_.add(static_cast<long>(callbackId), PostPriority::HIGH);
+ callback->AddToQueue();
long op_id = -1;
const auto result = manager_.getMessageService(id)->sync(callback, &op_id);
limit = static_cast<long>(v_limit.get<double>());
}
- auto json = std::shared_ptr<picojson::value>(new picojson::value(picojson::object()));
- picojson::object& obj = json->get<picojson::object>();
- obj[JSON_CALLBACK_ID] = picojson::value(callbackId);
-
- SyncFolderCallbackData *callback = new SyncFolderCallbackData(queue_);
- callback->setJson(json);
+ SyncFolderCallbackData *callback = new SyncFolderCallbackData(queue_, callbackId);
callback->setAccountId(id);
callback->setMessageFolder(MessagingUtil::jsonToMessageFolder(v_folder));
callback->setLimit(limit);
- queue_.add(static_cast<long>(callbackId), PostPriority::HIGH);
+ callback->AddToQueue();
long op_id = -1;
const auto result = manager_.getMessageService(id)->syncFolder(callback, &op_id);
POST_AND_RETURN(ret, json, obj, JSON_CALLBACK_ERROR)
}
- MessageCallbackUserData* callback = new MessageCallbackUserData(queue_);
+ MessageCallbackUserData* callback = new MessageCallbackUserData(queue_, callbackId);
callback->setMessage(message);
int serviceId = getServiceIdFromJSON(data);
callback->setAccountId(serviceId);
- callback->setJson(json);
-
- queue_.add(static_cast<long>(callbackId), PostPriority::HIGH);
+ callback->AddToQueue();
auto service = manager_.getMessageService(serviceId);
service->getMsgStorage()->addDraftMessage(callback);
}
int serviceId = getServiceIdFromJSON(data);
auto storage = manager_.getMessageService(serviceId)->getMsgStorage();
- FindMsgCallbackUserData* callback = new FindMsgCallbackUserData(queue_);
+ FindMsgCallbackUserData* callback = new FindMsgCallbackUserData(queue_, callbackId);
callback->setFilter(filter);
callback->setLimit(limit);
callback->setOffset(offset);
callback->setAccountId(serviceId);
callback->setSortMode(sortMode);
- callback->setJson(json);
- queue_.add(static_cast<long>(callbackId), PostPriority::HIGH);
+ callback->AddToQueue();
storage->findMessages(callback);
}
picojson::array messages = data.at(REMOVE_MESSAGES_ARGS_MESSAGES).get<picojson::array>();
const double callbackId = args.get(JSON_CALLBACK_ID).get<double>();
- MessagesCallbackUserData* callback = new MessagesCallbackUserData(queue_);
+ MessagesCallbackUserData* callback = new MessagesCallbackUserData(queue_, callbackId);
auto each = [callback] (picojson::value& v)->void {
std::shared_ptr<Message> message;
for_each(messages.begin(), messages.end(), each);
- auto json = std::shared_ptr<picojson::value>(new picojson::value(picojson::object()));
- picojson::object& obj = json->get<picojson::object>();
- obj[JSON_CALLBACK_ID] = picojson::value(callbackId);
- callback->setJson(json);
-
auto service = manager_.getMessageService(getServiceIdFromJSON(data));
- queue_.add(static_cast<long>(callbackId), PostPriority::HIGH);
+ callback->AddToQueue();
service->getMsgStorage()->removeMessages(callback);
}
auto pico_array = pico_messages.get<picojson::array>();
const double callbackId = args.get(JSON_CALLBACK_ID).get<double>();
- auto callback = new MessagesCallbackUserData(queue_);
+ auto callback = new MessagesCallbackUserData(queue_, callbackId);
std::for_each(pico_array.begin(), pico_array.end(), [&callback](picojson::value& v)->void {
std::shared_ptr<Message> message;
}
});
- auto json = std::shared_ptr<picojson::value>(new picojson::value(picojson::object()));
- picojson::object& obj = json->get<picojson::object>();
- obj[JSON_CALLBACK_ID] = picojson::value(callbackId);
- callback->setJson(json);
-
auto service = manager_.getMessageService(getServiceIdFromJSON(data));
- queue_.add(static_cast<long>(callbackId), PostPriority::HIGH);
+ callback->AddToQueue();
service->getMsgStorage()->updateMessages(callback);
}
int serviceId = getServiceIdFromJSON(data);
- ConversationCallbackData* callback = new ConversationCallbackData(queue_);
+ ConversationCallbackData* callback = new ConversationCallbackData(queue_, callbackId);
callback->setFilter(filter);
callback->setLimit(limit);
callback->setOffset(offset);
callback->setAccountId(serviceId);
callback->setSortMode(sortMode);
- callback->setJson(json);
- queue_.add(static_cast<long>(callbackId), PostPriority::HIGH);
+ callback->AddToQueue();
auto storage = manager_.getMessageService(serviceId)->getMsgStorage();
storage->findConversations(callback);
}
picojson::object& obj = json->get<picojson::object>();
obj[JSON_CALLBACK_ID] = picojson::value(callbackId);
- ConversationCallbackData* callback = new ConversationCallbackData(queue_);
+ ConversationCallbackData* callback = new ConversationCallbackData(queue_, callbackId);
PlatformResult ret(ErrorCode::NO_ERROR);
for (auto it = conversations.begin(); it != conversations.end(); ++it) {
callback->addConversation(conversation);
}
- callback->setJson(json);
-
auto service = manager_.getMessageService(getServiceIdFromJSON(data));
- queue_.add(static_cast<long>(callbackId), PostPriority::HIGH);
+ callback->AddToQueue();
service->getMsgStorage()->removeConversations(callback);
}
POST_AND_RETURN(ret, json, obj, JSON_CALLBACK_ERROR)
}
- FoldersCallbackData* callback = new FoldersCallbackData(queue_);
+ FoldersCallbackData* callback = new FoldersCallbackData(queue_, callbackId);
callback->setFilter(filter);
- callback->setJson(json);
- queue_.add(static_cast<long>(callbackId), PostPriority::HIGH);
+ callback->AddToQueue();
auto service = manager_.getMessageService(getServiceIdFromJSON(data));
service->getMsgStorage()->findFolders(callback);
}
return false;
}
- if (callback->isError()) {
- callback->getQueue().resolve(
- callback->getJson()->get<picojson::object>().at(JSON_CALLBACK_ID).get<double>(),
- callback->getJson()->serialize()
- );
+ if (callback->IsError()) {
callback->getMessage()->setMessageStatus(MessageStatus::STATUS_FAILED);
}
else {
LoggerD("Calling success callback with: %d recipients", message->getTO().size());
- auto json = callback->getJson();
- picojson::object& obj = json->get<picojson::object>();
- obj[JSON_ACTION] = picojson::value(JSON_CALLBACK_SUCCCESS);
-
std::vector<picojson::value> recipients;
auto addToRecipients = [&recipients](std::string& e)->void {
recipients.push_back(picojson::value(e));
picojson::object data;
data[JSON_DATA_RECIPIENTS] = picojson::value(recipients);
data[JSON_DATA_MESSAGE] = MessagingUtil::messageToJson(message);
- obj[JSON_DATA] = picojson::value(data);
- callback->getQueue().resolve(
- obj.at(JSON_CALLBACK_ID).get<double>(),
- json->serialize()
- );
+ callback->SetSuccess(picojson::value(data));
callback->getMessage()->setMessageStatus(MessageStatus::STATUS_SENT);
}
+ callback->Post();
+
delete callback;
callback = NULL;
return FALSE;
}
- if (callback->isError()) {
+ if (callback->IsError()) {
LoggerD("Calling error callback");
- callback->getQueue().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");
- auto json = callback->getJson();
- picojson::object& obj = json->get<picojson::object>();
- obj[JSON_ACTION] = picojson::value(JSON_CALLBACK_SUCCCESS);
-
picojson::object args;
args[JSON_DATA_MESSAGE] = MessagingUtil::messageToJson(callback->getMessage());
- obj[JSON_DATA] = picojson::value(args);
- callback->getQueue().resolve(
- obj.at(JSON_CALLBACK_ID).get<double>(),
- json->serialize()
- );
+ callback->SetSuccess(picojson::value(args));
}
+ callback->Post();
+
delete callback;
callback = NULL;
if (!platform_result) {
LoggerE("Message send failed");
- callback->setError(platform_result);
+ callback->SetError(platform_result);
if (!g_idle_add(sendMessageCompleteCB, static_cast<void*>(callback))) {
LoggerE("g_idle addition failed");
callback->getMessage()->getId(),
(MSG_NETWORK_SEND_FAIL == status ? "FAIL" : "TIMEOUT"));
- common::UnknownException e("Send message failed");
- callback->setError(e.name(), e.message());
+ callback->SetError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Send message failed"));
}
if (!g_idle_add(sendMessageCompleteCB, static_cast<void*>(callback))) {
PlatformResult ret = addDraftMessagePlatform(message);
if (ret.IsError()) {
LoggerE("%d (%s)", ret.error_code(), ret.message().c_str());
- callback->setError(ret);
+ callback->SetError(ret);
}
}
}
}
- if (!callback->isError()) {
+ if (!callback->IsError()) {
for (auto it = messages.begin() ; it != messages.end(); ++it) {
const int id = (*it)->getId();
}
}
- if (callback->isError()) {
+ if (callback->IsError()) {
LoggerD("Calling error callback");
- callback->getQueue().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);
-
- callback->getQueue().resolve(
- obj.at(JSON_CALLBACK_ID).get<double>(),
- json->serialize()
- );
+ callback->SetSuccess();
}
+ callback->Post();
+
delete callback;
callback = NULL;
}
break;
}
}
- if (!callback->isError()) {
+ if (!callback->IsError()) {
for (auto it = messages.begin() ; it != messages.end(); ++it) {
LoggerD("updating Message(%p) msg_id:%d", (*it).get(), (*it)->getId());
}
}
- if (callback->isError()) {
+ if (callback->IsError()) {
LoggerD("Calling error callback");
-
- callback->getQueue().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>();
-
auto messages = callback->getMessages();
picojson::array array;
auto each = [&array] (std::shared_ptr<Message> m)->void {
for_each(messages.begin(), messages.end(), each);
- obj[JSON_DATA] = picojson::value(array);
-
- obj[JSON_ACTION] = picojson::value(JSON_CALLBACK_SUCCCESS);
-
- callback->getQueue().resolve(
- obj.at(JSON_CALLBACK_ID).get<double>(),
- json->serialize()
- );
+ callback->SetSuccess(picojson::value(array));
}
+ callback->Post();
+
delete callback;
callback = NULL;
}
callback->SetError(ret);
}
- if (!callback->isError()) {
+ if (!callback->IsError()) {
int msgListCount = messagesIds.size();
LoggerD("Found %d messages", msgListCount);
callback->SetError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Cannot get platform Message structure"));
break;
}
- if (!callback->isError()) {
+ if (!callback->IsError()) {
callback->addMessage(std::shared_ptr<Message>{message});
LoggerD("Created message with id %d:", messagesIds[i]);
}
}
}
- if (callback->isError()) {
+ if (callback->IsError()) {
LoggerD("Calling error callback");
- callback->getQueue().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());
- auto json = callback->getJson();
- picojson::object& obj = json->get<picojson::object>();
-
std::vector<picojson::value> response;
auto messages = callback->getMessages();
std::for_each(messages.begin(), messages.end(), [&response](MessagePtr &message){
response.push_back(MessagingUtil::messageToJson(message));
});
- obj[JSON_DATA] = picojson::value(response);
- obj[JSON_ACTION] = picojson::value(JSON_CALLBACK_SUCCCESS);
-
- callback->getQueue().resolve(
- obj.at(JSON_CALLBACK_ID).get<double>(),
- json->serialize()
- );
+ callback->SetSuccess(picojson::value(response));
}
+ callback->Post();
+
delete callback;
callback = NULL;
}
callback->SetError(ret);
}
- if (!callback->isError()) {
+ if (!callback->IsError()) {
int convListCount = conversationsIds.size();
LoggerD("Found %d conversations", convListCount);
}
}
- if (callback->isError()) {
+ if (callback->IsError()) {
LoggerD("Calling error callback");
- callback->getQueue().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>();
std::vector<picojson::value> response;
auto conversations = callback->getConversations();
response.push_back(MessagingUtil::conversationToJson(conversation));
}
);
- obj[JSON_DATA] = picojson::value(response);
- obj[JSON_ACTION] = picojson::value(JSON_CALLBACK_SUCCCESS);
- callback->getQueue().resolve(
- obj.at(JSON_CALLBACK_ID).get<double>(),
- json->serialize()
- );
+ callback->SetSuccess(picojson::value(response));
}
+ callback->Post();
+
delete callback;
callback = NULL;
}
callback->SetError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Error while creatng message handle"));
}
- if (!callback->isError()) {
+ if (!callback->IsError()) {
for(auto it = conversations.begin() ; it != conversations.end(); ++it) {
if((*it)->getType() != type) {
LoggerE("Invalid message type");
}
}
- if (!callback->isError()) {
+ if (!callback->IsError()) {
if(MessageType::SMS == type) {
msg_id_conv_id_map = &m_sms_removed_msg_id_conv_id_map;
conv_id_object_map = &m_sms_removed_conv_id_object_map;
}
}
- if (!callback->isError()) {
+ if (!callback->IsError()) {
int conv_index = 0;
for (auto it = conversations.begin() ; it != conversations.end();
++it, ++conv_index) {
}
}
- if (!callback->isError()) {
+ if (!callback->IsError()) {
error = msg_close_msg_handle(&handle);
if (MSG_SUCCESS != error) {
LoggerW("Cannot close message handle: %d", error);
}
}
- if (callback->isError()) {
+ if (callback->IsError()) {
LoggerD("Calling error callback");
- callback->getQueue().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);
-
- callback->getQueue().resolve(
- obj.at(JSON_CALLBACK_ID).get<double>(),
- json->serialize()
- );
+ callback->SetSuccess();
}
+ callback->Post();
+
delete callback;
callback = NULL;
}
projects / platform / core / api / webapi-plugins.git / commitdiff