2 * Copyright (c) 2015 Samsung Electronics Co., Ltd All Rights Reserved
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
17 #include "messaging_instance.h"
19 #include <system_info.h>
23 #include "common/filesystem/filesystem_provider.h"
24 #include "common/logger.h"
25 #include "common/tools.h"
27 #include "MsgCommon/AbstractFilter.h"
28 #include "conversations_change_callback.h"
29 #include "email_manager.h"
30 #include "find_msg_callback_user_data.h"
31 #include "folders_callback_data.h"
32 #include "folders_change_callback.h"
34 #include "message_storage.h"
35 #include "messages_callback_user_data.h"
36 #include "messages_change_callback.h"
37 #include "messaging_manager.h"
38 #include "messaging_util.h"
39 #include "short_message_manager.h"
41 using common::ErrorCode;
42 using common::TypeMismatchException;
43 using common::PlatformResult;
49 const char* GET_MESSAGE_SERVICES_ARGS_MESSAGE_SERVICE_TYPE = "messageServiceType";
50 const char* SEND_MESSAGE_ARGS_MESSAGE = "message";
51 const char* SEND_MESSAGE_ARGS_SIMINDEX = "simIndex";
52 const char* LOAD_MESSAGE_ATTACHMENT_ARGS_ATTACHMENT = "attachment";
53 const char* SYNC_ARGS_ID = "id";
54 const char* SYNC_ARGS_LIMIT = "limit";
55 const char* SYNC_FOLDER_ARGS_ID = "id";
56 const char* SYNC_FOLDER_ARGS_FOLDER = "folder";
57 const char* SYNC_FOLDER_ARGS_LIMIT = "limit";
58 const char* STOP_SYNC_ARGS_ID = "id";
59 const char* STOP_SYNC_ARGS_OPID = "opId";
60 const char* ADD_DRAFT_MESSAGE_ARGS_MESSAGE = "message";
61 const char* REMOVE_MESSAGES_ARGS_MESSAGES = "messages";
62 const char* UPDATE_MESSAGES_ARGS_MESSAGES = "messages";
63 const char* FIND_CONVERSATIONS_ARGS_LIMIT = "limit";
64 const char* FIND_CONVERSATIONS_ARGS_OFFSET = "offset";
65 const char* REMOVE_CONVERSATIONS_ARGS_CONVERSATIONS = "conversations";
66 const char* FIND_FOLDERS_ARGS_LIMIT = "limit";
67 const char* FIND_FOLDERS_ARGS_OFFSET = "offset";
68 const char* REMOVE_CHANGE_LISTENER_ARGS_WATCHID = "watchId";
69 const char* FUNCTIONS_HIDDEN_ARGS_SERVICE_ID = "serviceId";
70 const char* FUN_MESSAGE_MESSAGING_EMAIL = "messaging.email";
72 auto getServiceIdFromJSON = [](picojson::object& data) -> int {
73 std::string serviceStrId;
76 MessagingUtil::getValueFromJSONObject<std::string>(data, FUNCTIONS_HIDDEN_ARGS_SERVICE_ID);
77 return std::stoi(serviceStrId);
83 const std::string kPrivilegeMessagingRead = "http://tizen.org/privilege/messaging.read";
84 const std::string kPrivilegeMessagingWrite = "http://tizen.org/privilege/messaging.write";
86 const long kDumbCallbackId = -1;
89 MessagingInstance::MessagingInstance() : manager_(*this), queue_(*this) {
91 using std::placeholders::_1;
92 using std::placeholders::_2;
94 #define REGISTER_METHOD(M) \
95 RegisterSyncHandler(#M, std::bind(&MessagingInstance::M, this, _1, _2))
96 REGISTER_METHOD(GetMessageServices);
97 REGISTER_METHOD(MessageServiceSendMessage);
98 REGISTER_METHOD(MessageServiceLoadMessageBody);
99 REGISTER_METHOD(MessageServiceLoadMessageAttachment);
100 REGISTER_METHOD(MessageStorageAddDraftMessage);
101 REGISTER_METHOD(MessageStorageFindMessages);
102 REGISTER_METHOD(MessageStorageRemoveMessages);
103 REGISTER_METHOD(MessageStorageUpdateMessages);
104 REGISTER_METHOD(MessageStorageFindConversations);
105 REGISTER_METHOD(MessageStorageRemoveConversations);
106 REGISTER_METHOD(MessageStorageFindFolders);
109 REGISTER_METHOD(MessageServiceSync);
110 REGISTER_METHOD(MessageServiceStopSync);
111 REGISTER_METHOD(MessageServiceSyncFolder);
112 REGISTER_METHOD(MessageStorageAddMessagesChangeListener);
113 REGISTER_METHOD(MessageStorageAddConversationsChangeListener);
114 REGISTER_METHOD(MessageStorageAddFolderChangeListener);
115 REGISTER_METHOD(MessageStorageRemoveChangeListener);
116 REGISTER_METHOD(MessageGetMessageStatus);
117 #undef REGISTER_METHOD
120 MessagingInstance::~MessagingInstance() {
124 #define POST_AND_RETURN(ret, json, obj) \
125 LogAndReportError(ret, &obj); \
126 queue_.addAndResolve(obj.at(JSON_CALLBACK_ID).get<double>(), PostPriority::HIGH, \
127 json->serialize()); \
130 #define CHECK_EXIST(args, name, out) \
131 if (!args.contains(name)) { \
132 std::string message = std::string(name) + " is required argument"; \
133 LogAndReportError(PlatformResult(ErrorCode::TYPE_MISMATCH_ERR, message), &out); \
137 EmailManager& MessagingInstance::getEmailManager() {
138 return email_manager_;
141 ShortMsgManager& MessagingInstance::getShortMsgManager() {
142 return short_msg_manager_;
145 void MessagingInstance::GetMessageServices(const picojson::value& args, picojson::object& out) {
148 CHECK_EXIST(args, JSON_CALLBACK_ID, out);
150 picojson::value serviceTag =
151 args.get<picojson::object>().at(GET_MESSAGE_SERVICES_ARGS_MESSAGE_SERVICE_TYPE);
152 const double callbackId = args.get(JSON_CALLBACK_ID).get<double>();
153 // above values should be validated in js
154 manager_.getMessageServices(serviceTag.to_str(), callbackId);
157 void MessagingInstance::MessageServiceSendMessage(const picojson::value& args,
158 picojson::object& out) {
161 CHECK_PRIVILEGE_ACCESS(kPrivilegeMessagingWrite, &out);
162 CHECK_EXIST(args, JSON_CALLBACK_ID, out);
164 picojson::object data = args.get<picojson::object>();
165 picojson::value v_message = data.at(SEND_MESSAGE_ARGS_MESSAGE);
167 bool has_attachments = v_message.get("hasAttachment").get<bool>();
168 if (has_attachments) {
169 const auto& attachments = v_message.get("attachments").get<std::vector<picojson::value>>();
170 for (const auto& att : attachments) {
171 const auto& attachment_path = att.get("filePath").get<std::string>();
172 const auto& attachment_real_path =
173 common::FilesystemProvider::Create().GetRealPath(attachment_path);
174 CHECK_STORAGE_ACCESS(attachment_real_path, &out);
178 const double callbackId = args.get(JSON_CALLBACK_ID).get<double>();
180 auto json = std::shared_ptr<picojson::value>(new picojson::value(picojson::object()));
181 picojson::object& obj = json->get<picojson::object>();
182 obj[JSON_CALLBACK_ID] = picojson::value(callbackId);
184 std::shared_ptr<Message> message;
185 PlatformResult ret = MessagingUtil::jsonToMessage(v_message, &message, *this);
187 POST_AND_RETURN(ret, json, obj)
190 MessageRecipientsCallbackData* callback =
191 new MessageRecipientsCallbackData(queue_, callbackId, *this);
195 callback->setMessage(message);
196 serviceId = getServiceIdFromJSON(data);
197 callback->setAccountId(serviceId);
198 simIndex = static_cast<long>(
199 MessagingUtil::getValueFromJSONObject<double>(data, SEND_MESSAGE_ARGS_SIMINDEX));
201 bool cell_support = false;
202 system_info_get_platform_bool("http://tizen.org/feature/network.telephony", &cell_support);
204 LoggerD("cell_support is true");
205 if (!callback->setSimIndex(simIndex)) {
208 POST_AND_RETURN(PlatformResult(ErrorCode::UNKNOWN_ERR, "set sim index failed"), json, obj)
211 LoggerD("cell_support is false");
214 callback->AddToQueue();
215 auto service = manager_.getMessageService(serviceId);
217 ret = service->sendMessage(callback);
219 POST_AND_RETURN(ret, json, obj)
223 void MessagingInstance::MessageServiceLoadMessageBody(const picojson::value& args,
224 picojson::object& out) {
227 CHECK_PRIVILEGE_ACCESS(kPrivilegeMessagingWrite, &out);
228 CHECK_EXIST(args, JSON_CALLBACK_ID, out);
230 picojson::object data = args.get<picojson::object>();
232 picojson::value json_message = data.at(ADD_DRAFT_MESSAGE_ARGS_MESSAGE);
233 const double callbackId = args.get(JSON_CALLBACK_ID).get<double>();
235 auto json = std::shared_ptr<picojson::value>(new picojson::value(picojson::object()));
236 picojson::object& obj = json->get<picojson::object>();
237 obj[JSON_CALLBACK_ID] = picojson::value(callbackId);
239 std::shared_ptr<Message> message;
240 PlatformResult ret = MessagingUtil::jsonToMessage(json_message, &message, *this);
242 POST_AND_RETURN(ret, json, obj)
245 MessageBodyCallbackData* callback = new MessageBodyCallbackData(queue_, callbackId, *this);
247 callback->setMessage(message);
249 callback->AddToQueue();
250 auto service = manager_.getMessageService(getServiceIdFromJSON(data));
251 ret = service->loadMessageBody(callback);
253 POST_AND_RETURN(ret, json, obj)
257 void MessagingInstance::MessageServiceLoadMessageAttachment(const picojson::value& args,
258 picojson::object& out) {
261 CHECK_PRIVILEGE_ACCESS(kPrivilegeMessagingWrite, &out);
262 CHECK_EXIST(args, JSON_CALLBACK_ID, out);
264 picojson::object data = args.get<picojson::object>();
265 picojson::value attachment = data.at(LOAD_MESSAGE_ATTACHMENT_ARGS_ATTACHMENT);
266 const double callbackId = args.get(JSON_CALLBACK_ID).get<double>();
268 MessageAttachmentCallbackData* callback =
269 new MessageAttachmentCallbackData(queue_, callbackId, *this);
270 callback->setMessageAttachment(MessagingUtil::jsonToMessageAttachment(attachment));
272 callback->AddToQueue();
273 auto service = manager_.getMessageService(getServiceIdFromJSON(data));
274 const auto result = service->loadMessageAttachment(callback);
275 if (result.IsError()) {
276 auto json = std::shared_ptr<picojson::value>(new picojson::value(picojson::object()));
277 picojson::object& obj = json->get<picojson::object>();
278 obj[JSON_CALLBACK_ID] = picojson::value(callbackId);
279 POST_AND_RETURN(result, json, obj)
283 void MessagingInstance::MessageServiceSync(const picojson::value& args, picojson::object& out) {
286 CHECK_PRIVILEGE_ACCESS(kPrivilegeMessagingWrite, &out);
287 CHECK_EXIST(args, JSON_CALLBACK_ID, out);
289 picojson::object data = args.get<picojson::object>();
290 picojson::value v_id = data.at(SYNC_ARGS_ID);
291 picojson::value v_limit = data.at(SYNC_ARGS_LIMIT);
292 const double callbackId = args.get(JSON_CALLBACK_ID).get<double>();
296 id = std::stoi(v_id.get<std::string>());
298 LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR), &out,
299 ("Problem with MessageService"));
303 if (v_limit.is<double>()) {
304 limit = static_cast<long>(v_limit.get<double>());
307 SyncCallbackData* callback = new SyncCallbackData(queue_, callbackId, *this);
308 callback->setAccountId(id);
309 callback->setLimit(limit);
311 callback->AddToQueue();
314 const auto result = manager_.getMessageService(id)->sync(callback, &op_id);
317 ReportSuccess(picojson::value(static_cast<double>(op_id)), out);
319 LogAndReportError(result, &out);
323 void MessagingInstance::MessageServiceSyncFolder(const picojson::value& args,
324 picojson::object& out) {
327 CHECK_PRIVILEGE_ACCESS(kPrivilegeMessagingWrite, &out);
328 CHECK_EXIST(args, JSON_CALLBACK_ID, out);
330 picojson::object data = args.get<picojson::object>();
331 picojson::value v_id = data.at(SYNC_FOLDER_ARGS_ID);
332 picojson::value v_folder = data.at(SYNC_FOLDER_ARGS_FOLDER);
333 picojson::value v_limit = data.at(SYNC_FOLDER_ARGS_LIMIT);
334 const double callbackId = args.get(JSON_CALLBACK_ID).get<double>();
338 id = std::stoi(v_id.get<std::string>());
340 LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR), &out,
341 ("Problem with MessageService"));
346 if (v_limit.is<double>()) {
347 limit = static_cast<long>(v_limit.get<double>());
350 SyncFolderCallbackData* callback = new SyncFolderCallbackData(queue_, callbackId, *this);
351 callback->setAccountId(id);
352 callback->setMessageFolder(MessagingUtil::jsonToMessageFolder(v_folder));
353 callback->setLimit(limit);
355 callback->AddToQueue();
358 const auto result = manager_.getMessageService(id)->syncFolder(callback, &op_id);
360 ReportSuccess(picojson::value(static_cast<double>(op_id)), out);
362 LogAndReportError(result, &out);
366 void MessagingInstance::MessageServiceStopSync(const picojson::value& args, picojson::object& out) {
368 CHECK_EXIST(args, STOP_SYNC_ARGS_OPID, out);
370 picojson::object data = args.get<picojson::object>();
372 if (data.find(STOP_SYNC_ARGS_ID) != data.end()) {
373 picojson::value v_id = data.at(STOP_SYNC_ARGS_ID);
374 picojson::value v_op_id = data.at(STOP_SYNC_ARGS_OPID);
378 id = std::stoi(v_id.get<std::string>());
380 LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR), &out,
381 ("Problem with MessageService"));
386 if (v_op_id.is<double>()) {
387 op_id = static_cast<long>(v_op_id.get<double>());
390 const auto result = manager_.getMessageService(id)->stopSync(op_id);
395 LogAndReportError(result, &out);
398 LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR), &out, ("Unknown error"));
402 void MessagingInstance::MessageStorageAddDraftMessage(const picojson::value& args, picojson::object& out) {
405 CHECK_PRIVILEGE_ACCESS(kPrivilegeMessagingWrite, &out);
406 CHECK_EXIST(args, JSON_CALLBACK_ID, out);
408 picojson::object data = args.get<picojson::object>();
409 picojson::value v_message = data.at(ADD_DRAFT_MESSAGE_ARGS_MESSAGE);
410 const double callbackId = args.get(JSON_CALLBACK_ID).get<double>();
412 auto json = std::shared_ptr<picojson::value>(new picojson::value(picojson::object()));
413 picojson::object& obj = json->get<picojson::object>();
414 obj[JSON_CALLBACK_ID] = picojson::value(callbackId);
416 std::shared_ptr<Message> message;
417 PlatformResult ret = MessagingUtil::jsonToMessage(v_message, &message, *this);
419 POST_AND_RETURN(ret, json, obj)
422 MessageCallbackUserData* callback = new MessageCallbackUserData(queue_, callbackId, *this);
423 callback->setMessage(message);
425 int serviceId = getServiceIdFromJSON(data);
426 callback->setAccountId(serviceId);
428 callback->AddToQueue();
429 auto service = manager_.getMessageService(serviceId);
430 service->getMsgStorage()->addDraftMessage(callback);
433 void MessagingInstance::MessageStorageFindMessages(const picojson::value& args,
434 picojson::object& out) {
437 CHECK_PRIVILEGE_ACCESS(kPrivilegeMessagingRead, &out);
438 CHECK_EXIST(args, JSON_CALLBACK_ID, out);
440 picojson::object data = args.get<picojson::object>();
441 const double callbackId = args.get(JSON_CALLBACK_ID).get<double>();
443 auto json = std::shared_ptr<picojson::value>(new picojson::value(picojson::object()));
444 picojson::object& obj = json->get<picojson::object>();
445 obj[JSON_CALLBACK_ID] = picojson::value(callbackId);
447 AbstractFilterPtr filter;
448 PlatformResult ret = MessagingUtil::jsonToAbstractFilter(data, &filter);
450 POST_AND_RETURN(ret, json, obj)
452 auto sortMode = MessagingUtil::jsonToSortMode(data);
454 long limit = static_cast<long>(
455 MessagingUtil::getValueFromJSONObject<double>(data, FIND_FOLDERS_ARGS_LIMIT));
457 long offset = static_cast<long>(
458 MessagingUtil::getValueFromJSONObject<double>(data, FIND_FOLDERS_ARGS_OFFSET));
460 int serviceId = getServiceIdFromJSON(data);
461 auto storage = manager_.getMessageService(serviceId)->getMsgStorage();
463 FindMsgCallbackUserData* callback = new FindMsgCallbackUserData(queue_, callbackId, *this);
464 callback->setFilter(filter);
465 callback->setLimit(limit);
466 callback->setOffset(offset);
467 callback->setAccountId(serviceId);
468 callback->setSortMode(sortMode);
470 callback->AddToQueue();
471 storage->findMessages(callback);
474 void MessagingInstance::MessageStorageRemoveMessages(const picojson::value& args,
475 picojson::object& out) {
478 CHECK_PRIVILEGE_ACCESS(kPrivilegeMessagingWrite, &out);
479 CHECK_EXIST(args, JSON_CALLBACK_ID, out);
481 picojson::object data = args.get<picojson::object>();
482 picojson::array messages = data.at(REMOVE_MESSAGES_ARGS_MESSAGES).get<picojson::array>();
483 const double callbackId = args.get(JSON_CALLBACK_ID).get<double>();
485 MessagesCallbackUserData* callback = new MessagesCallbackUserData(queue_, callbackId, *this);
487 auto each = [callback, this](picojson::value& v) -> void {
488 std::shared_ptr<Message> message;
489 PlatformResult ret = MessagingUtil::jsonToMessage(v, &message, *this);
490 if (ret.IsSuccess()) {
491 callback->addMessage(message);
495 for_each(messages.begin(), messages.end(), each);
497 auto service = manager_.getMessageService(getServiceIdFromJSON(data));
499 callback->AddToQueue();
500 service->getMsgStorage()->removeMessages(callback);
503 void MessagingInstance::MessageStorageUpdateMessages(const picojson::value& args,
504 picojson::object& out) {
507 CHECK_PRIVILEGE_ACCESS(kPrivilegeMessagingWrite, &out);
508 CHECK_EXIST(args, JSON_CALLBACK_ID, out);
510 picojson::object data = args.get<picojson::object>();
511 picojson::value pico_messages = data.at(UPDATE_MESSAGES_ARGS_MESSAGES);
512 auto pico_array = pico_messages.get<picojson::array>();
513 const double callbackId = args.get(JSON_CALLBACK_ID).get<double>();
515 auto callback = new MessagesCallbackUserData(queue_, callbackId, *this);
517 std::for_each(pico_array.begin(), pico_array.end(),
518 [&callback, this](picojson::value& v) -> void {
519 std::shared_ptr<Message> message;
520 PlatformResult ret = MessagingUtil::jsonToMessage(v, &message, *this);
521 if (ret.IsSuccess()) {
522 callback->addMessage(message);
526 auto service = manager_.getMessageService(getServiceIdFromJSON(data));
528 callback->AddToQueue();
529 service->getMsgStorage()->updateMessages(callback);
532 void MessagingInstance::MessageStorageFindConversations(const picojson::value& args,
533 picojson::object& out) {
536 CHECK_PRIVILEGE_ACCESS(kPrivilegeMessagingRead, &out);
537 CHECK_EXIST(args, JSON_CALLBACK_ID, out);
539 picojson::object data = args.get<picojson::object>();
540 const double callbackId = args.get(JSON_CALLBACK_ID).get<double>();
542 auto json = std::shared_ptr<picojson::value>(new picojson::value(picojson::object()));
543 picojson::object& obj = json->get<picojson::object>();
544 obj[JSON_CALLBACK_ID] = picojson::value(callbackId);
546 AbstractFilterPtr filter;
547 PlatformResult ret = MessagingUtil::jsonToAbstractFilter(data, &filter);
549 POST_AND_RETURN(ret, json, obj)
551 auto sortMode = MessagingUtil::jsonToSortMode(data);
552 long limit = static_cast<long>(
553 MessagingUtil::getValueFromJSONObject<double>(data, FIND_CONVERSATIONS_ARGS_LIMIT));
554 long offset = static_cast<long>(
555 MessagingUtil::getValueFromJSONObject<double>(data, FIND_CONVERSATIONS_ARGS_OFFSET));
557 int serviceId = getServiceIdFromJSON(data);
559 ConversationCallbackData* callback = new ConversationCallbackData(queue_, callbackId, *this);
560 callback->setFilter(filter);
561 callback->setLimit(limit);
562 callback->setOffset(offset);
563 callback->setAccountId(serviceId);
564 callback->setSortMode(sortMode);
566 callback->AddToQueue();
567 auto storage = manager_.getMessageService(serviceId)->getMsgStorage();
568 storage->findConversations(callback);
571 void MessagingInstance::MessageStorageRemoveConversations(const picojson::value& args,
572 picojson::object& out) {
575 CHECK_PRIVILEGE_ACCESS(kPrivilegeMessagingWrite, &out);
576 CHECK_EXIST(args, JSON_CALLBACK_ID, out);
578 picojson::object data = args.get<picojson::object>();
579 picojson::array conversations =
580 data.at(REMOVE_CONVERSATIONS_ARGS_CONVERSATIONS).get<picojson::array>();
581 const double callbackId = args.get(JSON_CALLBACK_ID).get<double>();
583 auto json = std::shared_ptr<picojson::value>(new picojson::value(picojson::object()));
584 picojson::object& obj = json->get<picojson::object>();
585 obj[JSON_CALLBACK_ID] = picojson::value(callbackId);
587 ConversationCallbackData* callback = new ConversationCallbackData(queue_, callbackId, *this);
589 PlatformResult ret(ErrorCode::NO_ERROR);
590 for (auto it = conversations.begin(); it != conversations.end(); ++it) {
591 std::shared_ptr<MessageConversation> conversation;
592 ret = MessagingUtil::jsonToMessageConversation(*it, &conversation);
595 POST_AND_RETURN(ret, json, obj)
597 callback->addConversation(conversation);
600 auto service = manager_.getMessageService(getServiceIdFromJSON(data));
602 callback->AddToQueue();
603 service->getMsgStorage()->removeConversations(callback);
606 void MessagingInstance::MessageStorageFindFolders(const picojson::value& args,
607 picojson::object& out) {
610 CHECK_PRIVILEGE_ACCESS(kPrivilegeMessagingRead, &out);
611 CHECK_EXIST(args, JSON_CALLBACK_ID, out);
613 picojson::object data = args.get<picojson::object>();
614 const double callbackId = args.get(JSON_CALLBACK_ID).get<double>();
616 auto json = std::shared_ptr<picojson::value>(new picojson::value(picojson::object()));
617 picojson::object& obj = json->get<picojson::object>();
618 obj[JSON_CALLBACK_ID] = picojson::value(callbackId);
620 AbstractFilterPtr filter;
621 PlatformResult ret = MessagingUtil::jsonToAbstractFilter(data, &filter);
623 POST_AND_RETURN(ret, json, obj)
626 FoldersCallbackData* callback = new FoldersCallbackData(queue_, callbackId, *this);
627 callback->setFilter(filter);
629 callback->AddToQueue();
630 auto service = manager_.getMessageService(getServiceIdFromJSON(data));
631 service->getMsgStorage()->findFolders(callback);
634 void MessagingInstance::MessageStorageAddMessagesChangeListener(const picojson::value& args,
635 picojson::object& out) {
638 CHECK_PRIVILEGE_ACCESS(kPrivilegeMessagingRead, &out);
640 picojson::object data = args.get<picojson::object>();
642 AbstractFilterPtr filter;
643 PlatformResult ret = MessagingUtil::jsonToAbstractFilter(data, &filter);
645 ReportError(ret, &out);
649 int serviceId = getServiceIdFromJSON(data);
651 auto service = manager_.getMessageService(serviceId);
653 std::shared_ptr<MessagesChangeCallback> callback(new MessagesChangeCallback(
654 kDumbCallbackId, serviceId, service->getMsgServiceType(), queue_, *this));
656 callback->setFilter(filter);
658 long op_id = service->getMsgStorage()->addMessagesChangeListener(callback);
660 picojson::value v(static_cast<double>(op_id));
661 ReportSuccess(v, out);
664 void MessagingInstance::MessageStorageAddConversationsChangeListener(const picojson::value& args,
665 picojson::object& out) {
668 CHECK_PRIVILEGE_ACCESS(kPrivilegeMessagingRead, &out);
670 picojson::object data = args.get<picojson::object>();
672 AbstractFilterPtr filter;
673 PlatformResult ret = MessagingUtil::jsonToAbstractFilter(data, &filter);
675 ReportError(ret, &out);
679 int serviceId = getServiceIdFromJSON(data);
681 auto service = manager_.getMessageService(serviceId);
683 std::shared_ptr<ConversationsChangeCallback> callback(new ConversationsChangeCallback(
684 static_cast<long>(-1), serviceId, service->getMsgServiceType(), queue_, *this));
686 callback->setFilter(filter);
688 long op_id = service->getMsgStorage()->addConversationsChangeListener(callback);
690 picojson::value v(static_cast<double>(op_id));
691 ReportSuccess(v, out);
694 void MessagingInstance::MessageStorageAddFolderChangeListener(const picojson::value& args,
695 picojson::object& out) {
698 CHECK_PRIVILEGE_ACCESS(kPrivilegeMessagingRead, &out);
700 picojson::object data = args.get<picojson::object>();
702 AbstractFilterPtr filter;
703 PlatformResult ret = MessagingUtil::jsonToAbstractFilter(data, &filter);
705 ReportError(ret, &out);
709 int serviceId = getServiceIdFromJSON(data);
711 auto service = manager_.getMessageService(serviceId);
713 std::shared_ptr<FoldersChangeCallback> callback(new FoldersChangeCallback(
714 static_cast<long>(-1), serviceId, service->getMsgServiceType(), queue_, *this));
716 callback->setFilter(filter);
718 long op_id = service->getMsgStorage()->addFoldersChangeListener(callback);
720 picojson::value v(static_cast<double>(op_id));
721 ReportSuccess(v, out);
724 void MessagingInstance::MessageStorageRemoveChangeListener(const picojson::value& args,
725 picojson::object& out) {
728 CHECK_PRIVILEGE_ACCESS(kPrivilegeMessagingRead, &out);
730 picojson::object data = args.get<picojson::object>();
732 static_cast<long>(data.at(REMOVE_CHANGE_LISTENER_ARGS_WATCHID).get<double>());
734 auto service = manager_.getMessageService(getServiceIdFromJSON(data));
736 service->getMsgStorage()->removeChangeListener(watchId);
740 void MessagingInstance::MessageGetMessageStatus(const picojson::value& args,
741 picojson::object& out) {
744 picojson::object data = args.get<picojson::object>();
745 const int id = stoi(data.at("id").get<std::string>());
746 const std::string& type = data.at("type").get<std::string>();
749 if (FUN_MESSAGE_MESSAGING_EMAIL == type) {
750 status = email_manager_.getMessageStatus(id);
752 status = short_msg_manager_.getMessageStatus(id);
755 ReportSuccess(picojson::value(status), out);
758 } // namespace messaging
759 } // namespace extension