}
// --- Listeners registration functions ---
-/*
- *long ChangeListenerContainer::addMessageChangeListener(
- * std::shared_ptr<MessagesChangeCallback> callback)
- *{
- * LoggerD("Entered");
- * // Check type of service for which listener should be registered
- * // and lock appropriate mutex
- * MessageType mtype = callback->getServiceType();
- * if (MessageType(SMS) == mtype || MessageType(MMS) == mtype)
- * {
- * std::lock_guard<std::mutex> lock(m_short_lock);
- * int new_id = getNextId();
- * m_short_message_callbacks.insert(std::make_pair(new_id, callback));
- * LoggerD("Added callback for ShortMessage, watchId: %d", new_id);
- * return new_id;
- * }
- * else if (MessageType(EMAIL) == mtype) {
- * std::lock_guard<std::mutex> lock(m_email_lock);
- * int new_id = getNextId();
- * m_email_message_callbacks.insert(std::make_pair(new_id, callback));
- * LoggerD("Added callback for Email, watchId: %d", new_id);
- * return new_id;
- * }
- * LoggerE("Listener with invalid MessageService type - failed to register");
- * return -1;
- *}
- */
+long ChangeListenerContainer::addMessageChangeListener(
+ std::shared_ptr<MessagesChangeCallback> callback)
+{
+ LoggerD("Entered");
+ // Check type of service for which listener should be registered
+ // and lock appropriate mutex
+ MessageType mtype = callback->getServiceType();
+ if (MessageType(SMS) == mtype || MessageType(MMS) == mtype)
+ {
+ //std::lock_guard<std::mutex> lock(m_short_lock);
+ //int new_id = getNextId();
+ //m_short_message_callbacks.insert(std::make_pair(new_id, callback));
+ //LoggerD("Added callback for ShortMessage, watchId: %d", new_id);
+ //return new_id;
+ }
+ else if (MessageType(EMAIL) == mtype) {
+ std::lock_guard<std::mutex> lock(m_email_lock);
+ int new_id = getNextId();
+ m_email_message_callbacks.insert(std::make_pair(new_id, callback));
+ LoggerD("Added callback for Email, watchId: %d", new_id);
+ return new_id;
+ }
+ LoggerE("Listener with invalid MessageService type - failed to register");
+ return -1;
+}
/*
*long ChangeListenerContainer::addConversationChangeListener(
// Interface for listener's manipulation (registration and removal).
- //long addMessageChangeListener(std::shared_ptr<MessagesChangeCallback> callback);
+ long addMessageChangeListener(std::shared_ptr<MessagesChangeCallback> callback);
//long addConversationChangeListener(std::shared_ptr<ConversationsChangeCallback> callback);
//long addFolderChangeListener(std::shared_ptr<FoldersChangeCallback> callback);
void removeChangeListener(long id);
// found in the LICENSE file.
#include "message_storage.h"
+#include "messages_change_callback.h"
+#include "change_listener_container.h"
#include "common/logger.h"
return m_msg_type;
}
-long MessageStorage::addMessagesChangeListener()
+long MessageStorage::addMessagesChangeListener(std::shared_ptr<MessagesChangeCallback> callback)
{
LoggerD("Entered");
+ return ChangeListenerContainer::getInstance().addMessageChangeListener(callback);
}
long MessageStorage::addConversationsChangeListener()
namespace extension {
namespace messaging {
+class MessagesChangeCallback;
+
class MessageStorage;
typedef std::shared_ptr<MessageStorage> MessageStoragePtr;
// Listeners registration/removal is common for all types of storage
// and does not have to be overwritten in derived classes.
- long addMessagesChangeListener();
+ long addMessagesChangeListener(std::shared_ptr<MessagesChangeCallback> callback);
long addConversationsChangeListener();
long addFoldersChangeListener();
void removeChangeListener();
{
}
+MessagesCallbackUserData::MessagesCallbackUserData(long cid, bool keep):
+ common::CallbackUserData(),
+ m_is_error(false),
+ m_service_type(MessageType::UNDEFINED)
+{
+ 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() {
}
class MessagesCallbackUserData: public common::CallbackUserData {
public:
MessagesCallbackUserData();
+ MessagesCallbackUserData(long cid, bool keep = false);
virtual ~MessagesCallbackUserData();
void addMessage(std::shared_ptr<Message> msg);
#include "common/logger.h"
#include "common/platform_exception.h"
+#include "messaging_instance.h"
#include "messages_change_callback.h"
//#include "JSMessage.h"
const char* MESSAGESUPDATED = "messagesupdated";
const char* MESSAGESREMOVED = "messagesremoved";
-MessagesChangeCallback::MessagesChangeCallback(/*JSContextRef global_ctx,
- JSObjectRef on_added_obj,
- JSObjectRef on_updated_obj,
- JSObjectRef on_removed_obj,*/
+MessagesChangeCallback::MessagesChangeCallback(
+ long cid,
int service_id,
MessageType service_type) :
- /*m_callback_data(global_ctx),*/
+ m_callback_data(cid, true),
m_service_id(service_id),
m_msg_type(service_type),
m_is_act(true)
{
- LOGD("Entered");
-
- //m_callback_data.setCallback(MESSAGESADDED, on_added_obj);
- //m_callback_data.setCallback(MESSAGESUPDATED, on_updated_obj);
- //m_callback_data.setCallback(MESSAGESREMOVED, on_removed_obj);
+ LoggerD("Entered");
}
MessagesChangeCallback::~MessagesChangeCallback()
{
- LOGD("Entered");
+ LoggerD("Entered");
}
-/*
- *MessagePtrVector MessagesChangeCallback::filterMessages(
- * AbstractFilterPtr filter,
- * const MessagePtrVector& source_messages,
- * const int service_id)
- *{
- * LOGD("Entered sourceMessages.size():%d filter:%s", source_messages.size(),
- * (filter ? "PRESENT" : "NULL"));
- *
- * if (filter) {
- * MessagePtrVector filtered_messages;
- * MessagePtrVector::const_iterator it = source_messages.begin();
- * MessagePtrVector::const_iterator end_it = source_messages.end();
- *
- * for(int i = 0; it != end_it ; ++i, ++it) {
- * const MessagePtr& message = *it;
- * message->setServiceId(service_id);
- *
- * const bool matched = filter->isMatching(message.get());
- * if(matched) {
- * filtered_messages.push_back(message);
- * }
- *
- * LOGD("[%d] is Message(%p) {", i, message.get());
- * LOGD("[%d] messageId: %d", i, message->getId());
- * LOGD("[%d] message subject: %s", i, message->getSubject().c_str());
- * LOGD("[%d] from: %s", i, message->getFrom().c_str());
- *
- * if(message->getBody()) {
- * const std::string& pBody = message->getBody()->getPlainBody();
- * LOGD("[%d] message plainBody: %s", i, limitedString(pBody).c_str());
- * }
- *
- * LOGD("[%d] matched filter: %s", i, matched ? "YES" : "NO");
- * LOGD("[%d] }");
- * }
- *
- * LOGD("returning matching %d of %d messages", filtered_messages.size(),
- * source_messages.size());
- * return filtered_messages;
- * }
- * else {
- * return source_messages;
- * }
- *}
- */
+MessagePtrVector MessagesChangeCallback::filterMessages(
+ tizen::AbstractFilterPtr filter,
+ const MessagePtrVector& source_messages,
+ const int service_id)
+{
+ LoggerD("Entered sourceMessages.size():%d filter:%s", source_messages.size(),
+ (filter ? "PRESENT" : "NULL"));
+
+ if (filter) {
+ MessagePtrVector filtered_messages;
+ MessagePtrVector::const_iterator it = source_messages.begin();
+ MessagePtrVector::const_iterator end_it = source_messages.end();
+
+ for(int i = 0; it != end_it ; ++i, ++it) {
+ const MessagePtr& message = *it;
+ message->setServiceId(service_id);
+
+ const bool matched = filter->isMatching(message.get());
+ if(matched) {
+ filtered_messages.push_back(message);
+ }
+
+ LoggerD("[%d] is Message(%p) {", i, message.get());
+ LoggerD("[%d] messageId: %d", i, message->getId());
+ LoggerD("[%d] message subject: %s", i, message->getSubject().c_str());
+ LoggerD("[%d] from: %s", i, message->getFrom().c_str());
+
+ if(message->getBody()) {
+ const std::string& pBody = message->getBody()->getPlainBody();
+ LoggerD("[%d] message plainBody: %s", i, limitedString(pBody).c_str());
+ }
+
+ LoggerD("[%d] matched filter: %s", i, matched ? "YES" : "NO");
+ LoggerD("[%d] }");
+ }
+
+ LoggerD("returning matching %d of %d messages", filtered_messages.size(),
+ source_messages.size());
+ return filtered_messages;
+ }
+ else {
+ return source_messages;
+ }
+}
/*
*void MessagesChangeCallback::added(const MessagePtrVector& msgs)
*{
- * LOGD("Entered num messages: %d", msgs.size());
+ * LoggerD("Entered num messages: %d", msgs.size());
* if (!m_is_act) {
* return;
* }
* //cancel callback only if filter did remove all messages
* //if callback was called with empty msgs list, call it
* if (msgs.size() > 0 && filtered_msgs.size() == 0) {
- * LOGD("All messages were filtered out, not calling callback");
+ * LoggerD("All messages were filtered out, not calling callback");
* return;
* }
* JSObjectRef js_obj = JSMessage::messageVectorToJSObjectArray(
* ctx, filtered_msgs);
*
- * LOGD("Calling:%s with:%d added messages", MESSAGESADDED,
+ * LoggerD("Calling:%s with:%d added messages", MESSAGESADDED,
* filtered_msgs.size());
* m_callback_data.invokeCallback(MESSAGESADDED, js_obj);
*}
*
*void MessagesChangeCallback::updated(const MessagePtrVector& msgs)
*{
- * LOGD("Entered num messages: %d", msgs.size());
+ * LoggerD("Entered num messages: %d", msgs.size());
* if (!m_is_act) {
* return;
* }
* //cancel callback only if filter did remove all messages
* //if callback was called with empty msgs list, call it
* if (msgs.size() > 0 && filtered_msgs.size() == 0) {
- * LOGD("All messages were filtered out, not calling callback");
+ * LoggerD("All messages were filtered out, not calling callback");
* return;
* }
* JSObjectRef js_obj = JSMessage::messageVectorToJSObjectArray(
* ctx, filtered_msgs);
*
- * LOGD("Calling:%s with:%d updated messages", MESSAGESUPDATED,
+ * LoggerD("Calling:%s with:%d updated messages", MESSAGESUPDATED,
* filtered_msgs.size());
* m_callback_data.invokeCallback(MESSAGESUPDATED, js_obj);
*}
void MessagesChangeCallback::removed(const MessagePtrVector& msgs)
{
-/*
- * LOGD("Enter event: msgs.size() = %d", msgs.size());
- * if (!m_is_act) {
- * return;
- * }
- *
- * MessagePtrVector filtered_msgs = filterMessages(m_filter, msgs, m_service_id);
- * //cancel callback only if filter did remove all messages
- * //if callback was called with empty msgs list, call it
- * if (msgs.size() > 0 && filtered_msgs.size() == 0) {
- * LOGD("All messages were filtered out, not calling callback");
- * return;
- * }
- * JSObjectRef js_obj = JSMessage::messageVectorToJSObjectArray(
- * ctx, filtered_msgs);
- *
- * LOGD("Calling:%s with:%d removed messages", MESSAGESREMOVED,
- * filtered_msgs.size());
- * m_callback_data.invokeCallback(MESSAGESREMOVED, js_obj);
- */
+ LoggerD("Enter event: msgs.size() = %d", msgs.size());
+ if (!m_is_act) {
+ return;
+ }
+
+ MessagePtrVector filtered_msgs = filterMessages(m_filter, msgs, m_service_id);
+ //cancel callback only if filter did remove all messages
+ //if callback was called with empty msgs list, call it
+ if (msgs.size() > 0 && filtered_msgs.size() == 0) {
+ LoggerD("All messages were filtered out, not calling callback");
+ return;
+ }
+
+ picojson::array array;
+ auto each = [&array] (std::shared_ptr<Message> m)->void {
+ array.push_back(MessagingUtil::messageToJson(m));
+ };
+
+ for_each(filtered_msgs.begin(), filtered_msgs.end(), each);
+
+ LoggerD("Calling:%s with:%d removed messages", MESSAGESREMOVED,
+ filtered_msgs.size());
+
+ auto json = m_callback_data.getJson();
+ picojson::object& obj = json->get<picojson::object>();
+ 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());
+
}
-/*
- *void MessagesChangeCallback::setFilter(AbstractFilterPtr filter)
- *{
- * m_filter = filter;
- *}
- */
+void MessagesChangeCallback::setFilter(tizen::AbstractFilterPtr filter)
+{
+ m_filter = filter;
+}
-/*
- *AbstractFilterPtr MessagesChangeCallback::getFilter() const
- *{
- * return m_filter;
- *}
- */
+AbstractFilterPtr MessagesChangeCallback::getFilter() const
+{
+ return m_filter;
+}
int MessagesChangeCallback::getServiceId() const
{
//#include <MultiCallbackUserData.h>
-//#include <AbstractFilter.h>
+#include "MsgCommon/AbstractFilter.h"
#include "message.h"
#include "messaging_util.h"
+#include "messages_callback_user_data.h"
namespace extension {
namespace messaging {
class MessagesChangeCallback {
public:
MessagesChangeCallback(
+ long cid,
int service_id,
MessageType service_type);
virtual ~MessagesChangeCallback();
//void updated(const MessagePtrVector& messages);
void removed(const MessagePtrVector& messages);
- //void setFilter(DeviceAPI::Tizen::AbstractFilterPtr filter);
- //DeviceAPI::Tizen::AbstractFilterPtr getFilter() const;
+ void setFilter(tizen::AbstractFilterPtr filter);
+ tizen::AbstractFilterPtr getFilter() const;
int getServiceId() const;
MessageType getServiceType() const;
- /*
- *static MessagePtrVector filterMessages(
- * DeviceAPI::Tizen::AbstractFilterPtr a_filter,
- * const MessagePtrVector& a_sourceMessages,
- * const int service_id);
- */
+ static MessagePtrVector filterMessages(
+ tizen::AbstractFilterPtr a_filter,
+ const MessagePtrVector& a_sourceMessages,
+ const int service_id);
void setActive(bool act);
bool isActive();
void setItems(MessagePtrVector& items);
MessagePtrVector getItems();
private:
- //Common::MultiCallbackUserData m_callback_data;
- //DeviceAPI::Tizen::AbstractFilterPtr m_filter;
+ MessagesCallbackUserData m_callback_data;
+ tizen::AbstractFilterPtr m_filter;
int m_service_id;
MessageType m_msg_type;
bool m_is_act;
optional: true, nullable: true}
]);
- var listeners = [];
- if (args.messagesChangeCallback.messagesadded) listeners.push('messagesadded');
- if (args.messagesChangeCallback.messagesupdated) listeners.push('messagesupdated');
- if (args.messagesChangeCallback.messagesremoved) listeners.push('messagesremoved');
+ var self = this;
- bridge({
- cmd: 'MessageStorage_addMessagesChangeListener',
- args: {
- filter: args.filter,
- listeners: listeners
- }
- }).then({
+ var cid = bridge.listener({
messagesadded: function (data) {
if (args.messagesChangeCallback.messagesadded) {
var messages = [];
data.forEach(function (el) {
- messages.push(new tizen.Message(el));
+ messages.push(new tizen.Message(el.type, new MessageInit_(el)));
});
args.messagesChangeCallback.messagesadded.call(null, messages);
}
if (args.messagesChangeCallback.messagesupdated) {
var messages = [];
data.forEach(function (el) {
- messages.push(new tizen.Message(el));
+ messages.push(new tizen.Message(el.type, new MessageInit_(el)));
});
args.messagesChangeCallback.messagesupdated.call(null, messages);
}
if (args.messagesChangeCallback.messagesremoved) {
var messages = [];
data.forEach(function (el) {
- messages.push(new tizen.Message(el));
+ messages.push(new tizen.Message(el.type, new MessageInit_(el)));
});
args.messagesChangeCallback.messagesremoved.call(null, messages);
}
}
});
+
+ var result = bridge.sync({
+ cmd: 'MessageStorage_addMessagesChangeListener',
+ cid: cid,
+ args: {
+ filter: args.filter || null,
+ serviceId: self.service.id
+ }
+ });
+
+ return result;
};
MessageStorage.prototype. addConversationsChangeListener = function () {
#include "common/logger.h"
+#include "MsgCommon/AbstractFilter.h"
+#include "messages_change_callback.h"
#include "messaging_manager.h"
#include "messaging_util.h"
#include "message_storage.h"
REGISTER_ASYNC(FUN_MESSAGE_STORAGE_FIND_CONVERSATIONS, MessageStorageFindConversations);
REGISTER_ASYNC(FUN_MESSAGE_STORAGE_REMOVE_CONVERSATIONS, MessageStorageRemoveConversations);
REGISTER_ASYNC(FUN_MESSAGE_STORAGE_FIND_FOLDERS, MessageStorageFindFolders);
- REGISTER_ASYNC(FUN_MESSAGE_STORAGE_ADD_MESSAGES_CHANGE_LISTENER, MessageStorageAddMessagesChangeListener);
REGISTER_ASYNC(FUN_MESSAGE_STORAGE_ADD_CONVERSATIONS_CHANGE_LISTENER, MessageStorageAddConversationsChangeListener);
REGISTER_ASYNC(FUN_MESSAGE_STORAGE_ADD_FOLDER_CHANGE_LISTENER, MessageStorageAddFolderChangeListener);
#undef REGISTER_ASYNC
RegisterSyncHandler(c, std::bind(&MessagingInstance::x, this, _1, _2));
REGISTER_SYNC(FUN_MESSAGE_SERVICE_SYNC, MessageServiceSync);
REGISTER_SYNC(FUN_MESSAGE_SERVICE_STOP_SYNC, MessageServiceStopSync);
+ REGISTER_SYNC(FUN_MESSAGE_STORAGE_ADD_MESSAGES_CHANGE_LISTENER, MessageStorageAddMessagesChangeListener);
REGISTER_SYNC(FUN_MESSAGE_STORAGE_REMOVE_CHANGE_LISTENER, MessageStorageRemoveChangeListener);
#undef REGISTER_SYNC
}
picojson::object& out)
{
LoggerD("Entered");
+ picojson::object data = args.get(JSON_DATA).get<picojson::object>();
+ const long callbackId = static_cast<long>(args.get(JSON_CALLBACK_ID).get<double>());
+
+ int serviceId = static_cast<int>(data.at(FUNCTIONS_HIDDEN_ARGS_SERVICE_ID).get<double>());
+ auto service = MessagingManager::getInstance().getMessageServiceEmail(serviceId);
+
+ std::shared_ptr<MessagesChangeCallback> callback(new MessagesChangeCallback(
+ callbackId, serviceId, service->getMsgServiceType()));
+
+ // TODO filter
+ // callback->setFilter(tizen::AbstractFilterPtr(new tizen::AbstractFilter()));
+
+ long op_id = service->getMsgStorage()->addMessagesChangeListener(callback);
+
+ picojson::value v(static_cast<double>(op_id));
+ ReportSuccess(v, out);
}
void MessagingInstance::MessageStorageAddConversationsChangeListener(const picojson::value& args,
projects / platform / core / api / webapi-plugins.git / commitdiff