[Messaging] Refactor singleton managers into instance's fields

to prevent crash

Callback could be called even after MessagingInstance
object was destroyed.

[Verification] Passrate didn't change

Change-Id: I3ac0db270f9f7a07613a9bd53e18f3b954952944
Signed-off-by: Pawel Kaczmarczyk <p.kaczmarczy@partner.samsung.com>

diff --git a/src/messaging/DBus/MessageProxy.cpp b/src/messaging/DBus/MessageProxy.cpp
index 7cc1653dbc2de02c3a512f4f4c6485b2463a6dd2..30e17b5fae03f497af4a410ad84d8f1d45e840e2 100644 (file)
--- a/src/messaging/DBus/MessageProxy.cpp
+++ b/src/messaging/DBus/MessageProxy.cpp
@@ -31,10 +31,11 @@ namespace DBus {
 
 using namespace common;
 
-MessageProxy::MessageProxy()
+MessageProxy::MessageProxy(EmailManager& manager)
     : common::dbus::Proxy(kDBusPathEmailStorageChange, kDBusIfaceEmailStorageChange,
                           kDBusNameSignalEmail, kDBusPathEmailStorageChange,
-                          kDBusIfaceEmailStorageChange) {
+                          kDBusIfaceEmailStorageChange),
+                          email_manager_(manager) {
   ScopeLogger();
 }
 
@@ -42,9 +43,9 @@ MessageProxy::~MessageProxy() {
   ScopeLogger();
 }
 
-PlatformResult MessageProxy::create(MessageProxyPtr* message_proxy) {
+PlatformResult MessageProxy::create(EmailManager& manager, MessageProxyPtr* message_proxy) {
   ScopeLogger();
-  message_proxy->reset(new MessageProxy());
+  message_proxy->reset(new MessageProxy(manager));
   if ((*message_proxy)->isNotProxyGot()) {
     message_proxy->reset();
     return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Could not get proxy");
@@ -129,7 +130,7 @@ PlatformResult MessageProxy::handleEmailEvent(int account_id, int mail_id, int t
       }
     }
 
-    email_mail_data_t* mail_data = EmailManager::getInstance().loadMessage(mail_id);
+    email_mail_data_t* mail_data = email_manager_.loadMessage(mail_id);
     if (mail_data == NULL) {
       return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Failed to load email");
     }
@@ -170,7 +171,7 @@ PlatformResult MessageProxy::handleEmailEvent(int account_id, int mail_id, int t
     delete eventMsg;
     delete eventConv;
 
-    EmailManager::getInstance().freeMessage(mail_data);
+    email_manager_.freeMessage(mail_data);
   } else {
     LoggerD("Listener not registered just ignore");
   }
@@ -226,7 +227,7 @@ void MessageProxy::notifyEmailManager(const std::string& idsString,
     LoggerD("Mail id list is empty.");
     return;
   }
-  EmailManager::getInstance().removeStatusCallback(ids, status);
+  email_manager_.removeStatusCallback(ids, status);
 }
 
 void MessageProxy::handleThreadRemoveEvent(int account_id, int thread_id) {

diff --git a/src/messaging/DBus/MessageProxy.h b/src/messaging/DBus/MessageProxy.h
index 6006117ebe67e6702a373dbb1951b6d746959749..4089fcdd6a9e248675ff740f973313184d8336c2 100644 (file)
--- a/src/messaging/DBus/MessageProxy.h
+++ b/src/messaging/DBus/MessageProxy.h
@@ -30,6 +30,7 @@
 
 namespace extension {
 namespace messaging {
+class EmailManager;
 namespace DBus {
 
 class MessageProxy;
@@ -38,10 +39,10 @@ typedef std::shared_ptr<MessageProxy> MessageProxyPtr;
 class MessageProxy : public common::dbus::Proxy {
  public:
   virtual ~MessageProxy();
-  static common::PlatformResult create(MessageProxyPtr *message_proxy);
+  static common::PlatformResult create(EmailManager &manager, MessageProxyPtr *message_proxy);
 
  protected:
-  MessageProxy();
+  MessageProxy(EmailManager &manager);
   virtual void signalCallback(GDBusConnection *connection, const gchar *sender_name,
                               const gchar *object_path, const gchar *interface_name,
                               const gchar *signal_name, GVariant *parameters);
@@ -57,6 +58,7 @@ class MessageProxy : public common::dbus::Proxy {
   void notifyEmailManager(const std::string &idsString, email_noti_on_storage_event status);
   void handleThreadRemoveEvent(int account_id, int thread_id);
   common::PlatformResult handleMailboxEvent(int account_id, int mailbox_id, int event);
+  EmailManager &email_manager_;
 };
 
 }  // namespace DBus

diff --git a/src/messaging/DBus/SendProxy.cpp b/src/messaging/DBus/SendProxy.cpp
index 0e8dc8e7ab7fbfd6cf019452fffd1127307510cb..f2a57ef6a3fa65c479f913fe8c851a98d0c9ac37 100644 (file)
--- a/src/messaging/DBus/SendProxy.cpp
+++ b/src/messaging/DBus/SendProxy.cpp
@@ -29,7 +29,8 @@ namespace DBus {
 
 using namespace common;
 
-SendProxy::SendProxy() : EmailSignalProxy(kDBusPathNetworkStatus, kDBusIfaceNetworkStatus) {
+SendProxy::SendProxy(EmailManager& manager)
+    : EmailSignalProxy(kDBusPathNetworkStatus, kDBusIfaceNetworkStatus), email_manager_(manager) {
   ScopeLogger();
 }
 
@@ -37,9 +38,9 @@ SendProxy::~SendProxy() {
   ScopeLogger();
 }
 
-PlatformResult SendProxy::create(SendProxyPtr* send_proxy) {
+PlatformResult SendProxy::create(EmailManager& manager, SendProxyPtr* send_proxy) {
   ScopeLogger();
-  send_proxy->reset(new SendProxy());
+  send_proxy->reset(new SendProxy(manager));
   if ((*send_proxy)->isNotProxyGot()) {
     send_proxy->reset();
     return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Could not get send proxy");
@@ -59,8 +60,8 @@ void SendProxy::handleEmailSignal(const int status, const int account_id, const
           "received email signal with:\n  status: %d\n  account_id: %d\n  "
           "source: %s\n  mail_id: %d\n  error_code: %d",
           status, account_id, source.c_str(), mail_id, error_code);
-      EmailManager::getInstance().sendStatusCallback(
-          mail_id, static_cast<email_noti_on_network_event>(status), error_code);
+      email_manager_.sendStatusCallback(mail_id, static_cast<email_noti_on_network_event>(status),
+                                        error_code);
       break;
     default:
       LoggerD("Unrecognized status %d, ignoring", status);

diff --git a/src/messaging/DBus/SendProxy.h b/src/messaging/DBus/SendProxy.h
index e9f211b77fdfcb5e74f2a0087ee7e13b7eaf95d1..8e3271621033b6c131ac1211f09d886d62ea574c 100644 (file)
--- a/src/messaging/DBus/SendProxy.h
+++ b/src/messaging/DBus/SendProxy.h
@@ -23,6 +23,7 @@
 
 namespace extension {
 namespace messaging {
+class EmailManager;
 namespace DBus {
 
 class SendProxy;
@@ -31,12 +32,13 @@ typedef std::shared_ptr<SendProxy> SendProxyPtr;
 class SendProxy : public EmailSignalProxy {
  public:
   virtual ~SendProxy();
-  static common::PlatformResult create(SendProxyPtr* send_proxy);
+  static common::PlatformResult create(EmailManager& manager, SendProxyPtr* send_proxy);
 
  protected:
-  SendProxy();
+  SendProxy(EmailManager& manager);
   virtual void handleEmailSignal(const int status, const int account_id, const std::string& source,
                                  const int op_handle, const int error_code);
+  EmailManager& email_manager_;
 };
 
 }  // DBus

diff --git a/src/messaging/callback_user_data.cc b/src/messaging/callback_user_data.cc
old mode 100755 (executable)
new mode 100644 (file)
index dfe796a..e29ba89
--- a/src/messaging/callback_user_data.cc
+++ b/src/messaging/callback_user_data.cc
@@ -19,18 +19,22 @@
 #include "common/logger.h"
 #include "common/tools.h"
 
+#include "messaging_instance.h"
+
 using common::tools::ReportSuccess;
 using common::tools::ReportError;
 
 namespace extension {
 namespace messaging {
 
-CallbackUserData::CallbackUserData(PostQueue& queue, long cid, bool keep /* = false */)
+CallbackUserData::CallbackUserData(PostQueue& queue, long cid, MessagingInstance& instance,
+                                   bool keep /* = false */)
     : json_(picojson::object()),
       obj_(json_.get<picojson::object>()),
       cid_(cid),
       queue_(queue),
-      result_(common::ErrorCode::NO_ERROR) {
+      result_(common::ErrorCode::NO_ERROR),
+      instance_(instance) {
   ScopeLogger();
   if (!keep) {
     // this is not listener, add callbackId
@@ -101,5 +105,13 @@ void CallbackUserData::AddJsonData(const char* key, const picojson::value& value
   obj_[key] = value;
 }
 
+EmailManager& CallbackUserData::getEmailManager() {
+  return instance_.getEmailManager();
+}
+
+ShortMsgManager& CallbackUserData::getShortMsgManager() {
+  return instance_.getShortMsgManager();
+}
+
 }  // messaging
 }  // extension

diff --git a/src/messaging/callback_user_data.h b/src/messaging/callback_user_data.h
old mode 100755 (executable)
new mode 100644 (file)
index 6f72c83..a51aea9
--- a/src/messaging/callback_user_data.h
+++ b/src/messaging/callback_user_data.h
@@ -26,9 +26,12 @@
 namespace extension {
 namespace messaging {
 
+class EmailManager;
+class ShortMsgManager;
+
 class CallbackUserData {
  public:
-  CallbackUserData(PostQueue& queue, long cid, bool keep = false);
+  CallbackUserData(PostQueue& queue, long cid, MessagingInstance& instance, bool keep = false);
   virtual ~CallbackUserData();
 
   bool IsError() const;
@@ -42,6 +45,9 @@ class CallbackUserData {
   void AddAndPost(PostPriority p);
   bool HasQueue(const PostQueue& q) const;
 
+  EmailManager& getEmailManager();
+  ShortMsgManager& getShortMsgManager();
+
  private:
   void AddJsonData(const char* key, const picojson::value& value);
 
@@ -50,6 +56,7 @@ class CallbackUserData {
   long cid_;
   PostQueue& queue_;
   common::PlatformResult result_;
+  MessagingInstance& instance_;
 };
 
 }  // messaging

diff --git a/src/messaging/change_listener_container.cc b/src/messaging/change_listener_container.cc
index e201c8fcea368d61697fa50db507bb541f15c9b5..b0824460bd6897d4cfe373f22e389910e526e256 100644 (file)
--- a/src/messaging/change_listener_container.cc
+++ b/src/messaging/change_listener_container.cc
@@ -211,8 +211,6 @@ ChangeListenerContainer::ChangeListeners::ListenerGroup::Get<FoldersChangeCallba
 
 ChangeListenerContainer& ChangeListenerContainer::getInstance() {
   ScopeLogger();
-  EmailManager::getInstance();  // make sure that callbacks are registered in email-service
-  // ShortMsgManager::getInstance(); //make sure that callbacks are registered in msg-service
   static ChangeListenerContainer clc;
   return clc;
 }

diff --git a/src/messaging/conversation_callback_data.cc b/src/messaging/conversation_callback_data.cc
index 830709200b7e5b6ec378ae7c96ef1c85ce14ae90..326705050f2a823c77f18a80cb927f195d53e9c7 100644 (file)
--- a/src/messaging/conversation_callback_data.cc
+++ b/src/messaging/conversation_callback_data.cc
@@ -21,8 +21,9 @@ namespace extension {
 namespace messaging {
 
 ConversationCallbackData::ConversationCallbackData(PostQueue& queue, long cid,
+                                                   MessagingInstance& instance,
                                                    bool keep /* = false */)
-    : CallbackUserData(queue, cid, keep),
+    : CallbackUserData(queue, cid, instance, keep),
       m_limit(0),
       m_offset(0),
       m_account_id(0),

diff --git a/src/messaging/conversation_callback_data.h b/src/messaging/conversation_callback_data.h
index 2bbfb8c01d38db546b357896e977248c9ee732e2..b8203deeda421f4c5db360fcff34d874d501c082 100644 (file)
--- a/src/messaging/conversation_callback_data.h
+++ b/src/messaging/conversation_callback_data.h
@@ -36,7 +36,8 @@ class MessageConversation;
 
 class ConversationCallbackData : public CallbackUserData {
  public:
-  ConversationCallbackData(PostQueue& queue, long cid, bool keep = false);
+  ConversationCallbackData(PostQueue& queue, long cid, MessagingInstance& instance,
+                           bool keep = false);
   virtual ~ConversationCallbackData();
 
   void setFilter(AbstractFilterPtr filter);

diff --git a/src/messaging/conversations_change_callback.cc b/src/messaging/conversations_change_callback.cc
index 91620a4b029cfe3d76d4011168bd7b7519471ae4..fe5f7e0f62e1337f3d5b28af4c10291598a485df 100644 (file)
--- a/src/messaging/conversations_change_callback.cc
+++ b/src/messaging/conversations_change_callback.cc
@@ -39,8 +39,9 @@ const char* CONVERSATIONSUPDATED = "conversationsupdated";
 const char* CONVERSATIONSREMOVED = "conversationsremoved";
 
 ConversationsChangeCallback::ConversationsChangeCallback(long cid, int service_id,
-                                                         MessageType service_type, PostQueue& queue)
-    : m_callback_data(queue, cid, true),
+                                                         MessageType service_type, PostQueue& queue,
+                                                         MessagingInstance& instance)
+    : m_callback_data(queue, cid, instance, true),
       m_id(service_id),
       m_msg_type(service_type),
       m_is_act(true) {

diff --git a/src/messaging/conversations_change_callback.h b/src/messaging/conversations_change_callback.h
index e3edfdbb4d448804ac54d803030bdebd4ed915da..e609fe8628b664dc9a4518fc6fe7e0d139c70e8d 100644 (file)
--- a/src/messaging/conversations_change_callback.h
+++ b/src/messaging/conversations_change_callback.h
@@ -34,7 +34,8 @@ class ConversationsChangeCallback {
   typedef void (ConversationsChangeCallback::*Signature)(
       const ConversationPtrVector& conversations);
 
-  ConversationsChangeCallback(long cid, int service_id, MessageType service_type, PostQueue& queue);
+  ConversationsChangeCallback(long cid, int service_id, MessageType service_type, PostQueue& queue,
+                              MessagingInstance& instance);
   virtual ~ConversationsChangeCallback();
 
   void added(const ConversationPtrVector& conversations);

diff --git a/src/messaging/email_manager.cc b/src/messaging/email_manager.cc
index 3bdb55cae4b58472cbdb25ff0072b07d167e8d0b..9a80c0dbca6e45a2722c895dda71d9b02fc60934 100644 (file)
--- a/src/messaging/email_manager.cc
+++ b/src/messaging/email_manager.cc
@@ -75,12 +75,6 @@ EmailManager::EmailManager() : m_slot_size(-1), m_is_initialized(false) {
   ScopeLogger();
 }
 
-EmailManager& EmailManager::getInstance() {
-  ScopeLogger();
-  static EmailManager instance;
-  return instance;
-}
-
 #define CHECK_ERROR(ret, message) \
   if (ret.IsError()) {            \
     LoggerE(message);             \
@@ -89,10 +83,9 @@ EmailManager& EmailManager::getInstance() {
 
 PlatformResult EmailManager::InitializeEmailService() {
   ScopeLogger();
-  EmailManager& instance = EmailManager::getInstance();
 
-  if (!instance.m_is_initialized) {
-    instance.getUniqueOpId();
+  if (!m_is_initialized) {
+    getUniqueOpId();
 
     int ntv_ret = email_service_begin();
     if (ntv_ret != EMAIL_ERROR_NONE) {
@@ -111,25 +104,25 @@ PlatformResult EmailManager::InitializeEmailService() {
     int slot_size = -1;
     vconf_get_int("db/private/email-service/slot_size", &(slot_size));
     if (slot_size > 0) {
-      instance.m_slot_size = slot_size;
+      m_slot_size = slot_size;
     }
 
-    PlatformResult ret = DBus::SyncProxy::create(
-        DBus::kDBusPathNetworkStatus, DBus::kDBusIfaceNetworkStatus, &instance.m_proxy_sync);
+    PlatformResult ret = DBus::SyncProxy::create(DBus::kDBusPathNetworkStatus,
+                                                 DBus::kDBusIfaceNetworkStatus, &m_proxy_sync);
     CHECK_ERROR(ret, "create sync proxy failed");
-    if (!instance.m_proxy_sync) {
+    if (!m_proxy_sync) {
       LoggerE("Sync proxy is null");
       return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Sync proxy is null");
     }
-    instance.m_proxy_sync->signalSubscribe();
+    m_proxy_sync->signalSubscribe();
 
     ret = DBus::LoadBodyProxy::create(DBus::kDBusPathNetworkStatus, DBus::kDBusIfaceNetworkStatus,
-                                      &instance.m_proxy_load_body);
+                                      &m_proxy_load_body);
     CHECK_ERROR(ret, "create load body proxy failed");
-    if (!instance.m_proxy_load_body) {
+    if (!m_proxy_load_body) {
       return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Load body proxy is null");
     }
-    instance.m_proxy_load_body->signalSubscribe();
+    m_proxy_load_body->signalSubscribe();
 
     //    ret = DBus::LoadAttachmentProxy::create(DBus::Proxy::DBUS_PATH_NETWORK_STATUS,
     //                                            DBus::Proxy::DBUS_IFACE_NETWORK_STATUS,
@@ -141,21 +134,21 @@ PlatformResult EmailManager::InitializeEmailService() {
     //    }
     //    m_proxy_load_attachment->signalSubscribe();
 
-    ret = DBus::MessageProxy::create(&instance.m_proxy_messageStorage);
+    ret = DBus::MessageProxy::create(*this, &m_proxy_messageStorage);
     CHECK_ERROR(ret, "create message proxy failed");
-    if (!instance.m_proxy_messageStorage) {
+    if (!m_proxy_messageStorage) {
       return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Message proxy is null");
     }
-    instance.m_proxy_messageStorage->signalSubscribe();
+    m_proxy_messageStorage->signalSubscribe();
 
-    ret = DBus::SendProxy::create(&instance.m_proxy_send);
+    ret = DBus::SendProxy::create(*this, &m_proxy_send);
     CHECK_ERROR(ret, "create send proxy failed");
-    if (!instance.m_proxy_send) {
+    if (!m_proxy_send) {
       return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Send proxy is null");
     }
-    instance.m_proxy_send->signalSubscribe();
+    m_proxy_send->signalSubscribe();
 
-    instance.m_is_initialized = true;
+    m_is_initialized = true;
   }
 
   return PlatformResult(ErrorCode::NO_ERROR);
@@ -1123,6 +1116,10 @@ PlatformResult EmailManager::FindConversationsPlatform(ConversationCallbackData*
     std::shared_ptr<MessageConversation> conversation;
     PlatformResult ret = MessageConversation::convertEmailConversationToObject(
         conversationsInfo.at(i).id, &conversation);
+    if (ret.IsError()) {
+      LoggerE("%d (%s)", ret.error_code(), (ret.message()).c_str());
+      return ret;
+    }
     conversation->setUnreadMessages(conversationsInfo.at(i).unreadMessages);
     callback->addConversation(conversation);
   }

diff --git a/src/messaging/email_manager.h b/src/messaging/email_manager.h
index e6e8c1d0f8dae7c7135efebaa4988d371d580731..a591e1d43ffae8d83740bec8831567bf10adea0f 100644 (file)
--- a/src/messaging/email_manager.h
+++ b/src/messaging/email_manager.h
@@ -57,8 +57,10 @@ class MessageBodyCallbackData;
 
 class EmailManager {
  public:
-  static EmailManager& getInstance();
-  static common::PlatformResult InitializeEmailService();
+  EmailManager();
+  virtual ~EmailManager();
+
+  common::PlatformResult InitializeEmailService();
 
   void addDraftMessage(MessageCallbackUserData* callback);
   void removeMessages(MessagesCallbackUserData* callback);
@@ -94,10 +96,6 @@ class EmailManager {
   long getUniqueOpId();
 
  private:
-  EmailManager();
-  EmailManager(const EmailManager&);
-  void operator=(const EmailManager&);
-  virtual ~EmailManager();
   common::PlatformResult addDraftMessagePlatform(int account_id, std::shared_ptr<Message> message);
   common::PlatformResult addOutboxMessagePlatform(int account_id, std::shared_ptr<Message> message);
   common::PlatformResult addMessagePlatform(int account_id, std::shared_ptr<Message> message,

diff --git a/src/messaging/find_msg_callback_user_data.cc b/src/messaging/find_msg_callback_user_data.cc
index 2b309a2a32bd3d1d796a9b7e45f9dd4264276437..f09e223bcd37fd02700e081c8dfb4fed44124b3e 100644 (file)
--- a/src/messaging/find_msg_callback_user_data.cc
+++ b/src/messaging/find_msg_callback_user_data.cc
@@ -23,8 +23,9 @@
 namespace extension {
 namespace messaging {
 
-FindMsgCallbackUserData::FindMsgCallbackUserData(PostQueue& queue, long cid)
-    : CallbackUserData(queue, cid),
+FindMsgCallbackUserData::FindMsgCallbackUserData(PostQueue& queue, long cid,
+                                                 MessagingInstance& instance)
+    : CallbackUserData(queue, cid, instance),
       m_limit(0),
       m_offset(0),
       m_account_id(0),

diff --git a/src/messaging/find_msg_callback_user_data.h b/src/messaging/find_msg_callback_user_data.h
index da7f194c3bbdb8951987630d5a633461f8e422a7..8445653c0d4d9119cd056f305c9151d0fed2d301 100644 (file)
--- a/src/messaging/find_msg_callback_user_data.h
+++ b/src/messaging/find_msg_callback_user_data.h
@@ -40,7 +40,7 @@ class Message;
 
 class FindMsgCallbackUserData : public CallbackUserData {
  public:
-  FindMsgCallbackUserData(PostQueue& queue, long cid);
+  FindMsgCallbackUserData(PostQueue& queue, long cid, MessagingInstance& instance);
   virtual ~FindMsgCallbackUserData();
 
   void setFilter(AbstractFilterPtr filter);

diff --git a/src/messaging/folders_change_callback.cc b/src/messaging/folders_change_callback.cc
index 59c159ba36e09ad818b54e3513a28a18b509132b..6ceda0b2ed921d76174bd7a3de9a583b7ee43718 100644 (file)
--- a/src/messaging/folders_change_callback.cc
+++ b/src/messaging/folders_change_callback.cc
@@ -28,8 +28,8 @@ const char* FOLDERSUPDATED = "foldersupdated";
 const char* FOLDERSREMOVED = "foldersremoved";
 
 FoldersChangeCallback::FoldersChangeCallback(long cid, int service_id, MessageType service_type,
-                                             PostQueue& queue)
-    : m_callback_data(queue, cid, true),
+                                             PostQueue& queue, MessagingInstance& instance)
+    : m_callback_data(queue, cid, instance, true),
       m_id(service_id),
       m_msg_type(service_type),
       m_is_act(true) {

diff --git a/src/messaging/folders_change_callback.h b/src/messaging/folders_change_callback.h
index f6649a080e1486ac7b76649bdd5224c0a32dee42..1b870ec6c44c3ada813420866e5b766ab011bef8 100644 (file)
--- a/src/messaging/folders_change_callback.h
+++ b/src/messaging/folders_change_callback.h
@@ -37,7 +37,8 @@ class FoldersChangeCallback {
  public:
   typedef void (FoldersChangeCallback::*Signature)(const FolderPtrVector& conversations);
 
-  FoldersChangeCallback(long cid, int service_id, MessageType service_type, PostQueue& queue);
+  FoldersChangeCallback(long cid, int service_id, MessageType service_type, PostQueue& queue,
+                        MessagingInstance& instance);
   virtual ~FoldersChangeCallback();
 
   void added(const FolderPtrVector& folders);

diff --git a/src/messaging/message.cc b/src/messaging/message.cc
index a171c9a2bf9dbfa45114e249d19e60ad275a4bf0..d439357f4cd7af6f14f8aed3b90508580df7b710 100644 (file)
--- a/src/messaging/message.cc
+++ b/src/messaging/message.cc
@@ -29,6 +29,7 @@
 #include "message_email.h"
 #include "message_mms.h"
 #include "message_sms.h"
+#include "messaging_instance.h"
 #include "messaging_util.h"
 #include "short_message_manager.h"
 
@@ -1476,10 +1477,11 @@ PlatformResult Message::convertPlatformShortMessageToObject(msg_struct_t msg,
   return PlatformResult(ErrorCode::NO_ERROR);
 }
 
-PlatformResult Message::findShortMessageById(const int id, MessagePtr* message) {
+PlatformResult Message::findShortMessageById(const int id, MessagingInstance& instance,
+                                             MessagePtr* message) {
   ScopeLogger();
   msg_struct_t msg;
-  PlatformResult ret = ShortMsgManager::getInstance().getMessage(id, &msg);
+  PlatformResult ret = instance.getShortMsgManager().getMessage(id, &msg);
   if (ret.IsError()) {
     return ret;
   }

diff --git a/src/messaging/message.h b/src/messaging/message.h
index 87578eada3c04331d28fafe8b37b1fa54f3e1fa5..c4c5c15f10125c2341f8dc29a57efe7af4465e6d 100644 (file)
--- a/src/messaging/message.h
+++ b/src/messaging/message.h
@@ -145,7 +145,8 @@ class Message : public FilterableObject {
   // function for filling Message attributes
   static common::PlatformResult convertPlatformShortMessageToObject(msg_struct_t msg,
                                                                     Message** message);
-  static common::PlatformResult findShortMessageById(const int id, MessagePtr* message);
+  static common::PlatformResult findShortMessageById(const int id, MessagingInstance& instance,
+                                                     MessagePtr* message);
   static common::PlatformResult addMMSBodyAndAttachmentsToStruct(const AttachmentPtrVector& attach,
                                                                  msg_struct_t& mms_struct,
                                                                  Message* message);

diff --git a/src/messaging/message_callback_user_data.cc b/src/messaging/message_callback_user_data.cc
index bb6f1b9786e765852edebb45e42cae446e98cb90..d00c46b04e58570b2d42b340366f56b8b3c1415b 100644 (file)
--- a/src/messaging/message_callback_user_data.cc
+++ b/src/messaging/message_callback_user_data.cc
@@ -20,8 +20,9 @@
 namespace extension {
 namespace messaging {
 
-MessageCallbackUserData::MessageCallbackUserData(PostQueue& queue, long cid)
-    : CallbackUserData(queue, cid), m_account_id(0) {
+MessageCallbackUserData::MessageCallbackUserData(PostQueue& queue, long cid,
+                                                 MessagingInstance& instance)
+    : CallbackUserData(queue, cid, instance), m_account_id(0) {
   ScopeLogger();
 }
 

diff --git a/src/messaging/message_callback_user_data.h b/src/messaging/message_callback_user_data.h
index c1f7c1a5222ce92c47b5a87dbb1672d694b152a1..5360f930c5a51942424c6fdc008e8a62754b6b6a 100644 (file)
--- a/src/messaging/message_callback_user_data.h
+++ b/src/messaging/message_callback_user_data.h
@@ -31,7 +31,7 @@ class PostQueue;
 
 class MessageCallbackUserData : public CallbackUserData {
  public:
-  MessageCallbackUserData(PostQueue& queue, long cid);
+  MessageCallbackUserData(PostQueue& queue, long cid, MessagingInstance& instance);
   virtual ~MessageCallbackUserData();
 
   void setMessage(std::shared_ptr<Message> message);

diff --git a/src/messaging/message_service.cc b/src/messaging/message_service.cc
index aa922a5246ad62906467bc011b720791329f71d7..6f683e67f77c637c802ea76d3cda52e158a47272 100644 (file)
--- a/src/messaging/message_service.cc
+++ b/src/messaging/message_service.cc
@@ -41,8 +41,9 @@ const char* JSON_SERVICE_NAME = "name";
 
 //#################### MessageRecipientsCallbackData ####################
 
-MessageRecipientsCallbackData::MessageRecipientsCallbackData(PostQueue& queue, long cid)
-    : CallbackUserData(queue, cid),
+MessageRecipientsCallbackData::MessageRecipientsCallbackData(PostQueue& queue, long cid,
+                                                             MessagingInstance& instance)
+    : CallbackUserData(queue, cid, instance),
       m_account_id(-1),
       m_sim_index(TAPI_NETWORK_DEFAULT_DATA_SUBS_UNKNOWN),
       m_default_sim_index(TAPI_NETWORK_DEFAULT_DATA_SUBS_UNKNOWN) {
@@ -122,8 +123,9 @@ TelNetworkDefaultDataSubs_t MessageRecipientsCallbackData::getDefaultSimIndex()
 
 //#################### BaseMessageServiceCallbackData ####################
 
-BaseMessageServiceCallbackData::BaseMessageServiceCallbackData(PostQueue& queue, long cid)
-    : CallbackUserData(queue, cid), m_op_handle(-1) {
+BaseMessageServiceCallbackData::BaseMessageServiceCallbackData(PostQueue& queue, long cid,
+                                                               MessagingInstance& instance)
+    : CallbackUserData(queue, cid, instance), m_op_handle(-1) {
   ScopeLogger();
 }
 
@@ -155,8 +157,9 @@ std::shared_ptr<Message> MessageBodyCallbackData::getMessage() const {
 
 //#################### MessageAttachmentCallbackData ####################
 
-MessageAttachmentCallbackData::MessageAttachmentCallbackData(PostQueue& queue, long cid)
-    : BaseMessageServiceCallbackData(queue, cid), m_nth(0) {
+MessageAttachmentCallbackData::MessageAttachmentCallbackData(PostQueue& queue, long cid,
+                                                             MessagingInstance& instance)
+    : BaseMessageServiceCallbackData(queue, cid, instance), m_nth(0) {
   ScopeLogger();
 }
 
@@ -183,8 +186,8 @@ int MessageAttachmentCallbackData::getNth() const {
 
 //#################### SyncCallbackData ####################
 
-SyncCallbackData::SyncCallbackData(PostQueue& queue, long cid)
-    : BaseMessageServiceCallbackData(queue, cid),
+SyncCallbackData::SyncCallbackData(PostQueue& queue, long cid, MessagingInstance& instance)
+    : BaseMessageServiceCallbackData(queue, cid, instance),
       m_is_limit(false),
       m_limit(0),
       m_op_id(-1),
@@ -241,8 +244,9 @@ std::shared_ptr<MessageFolder> SyncFolderCallbackData::getMessageFolder() const
 
 //#################### MessageService ####################
 
-MessageService::MessageService(int id, MessageType msgType, const std::string& name)
-    : m_id(id), m_msg_type(msgType), m_name(name) {
+MessageService::MessageService(int id, MessageType msgType, const std::string& name,
+                               MessagingInstance& instance)
+    : m_id(id), m_msg_type(msgType), m_name(name), instance_(instance) {
   ScopeLogger();
   switch (msgType) {
     case MessageType::SMS:

diff --git a/src/messaging/message_service.h b/src/messaging/message_service.h
index e0e888e8f339f58f61ffb5a8f548335e8bdd5846..ca16baf8ffc64c10794a53e919ae6b663fcdde41 100644 (file)
--- a/src/messaging/message_service.h
+++ b/src/messaging/message_service.h
@@ -36,7 +36,7 @@ enum MessageServiceAccountId { UNKNOWN_ACCOUNT_ID = 0, SMS_ACCOUNT_ID = 101, MMS
 
 class MessageRecipientsCallbackData : public CallbackUserData {
  public:
-  MessageRecipientsCallbackData(PostQueue& queue, long cid);
+  MessageRecipientsCallbackData(PostQueue& queue, long cid, MessagingInstance& instance);
   virtual ~MessageRecipientsCallbackData();
 
   void setMessage(std::shared_ptr<Message> message);
@@ -64,7 +64,7 @@ class MessageRecipientsCallbackData : public CallbackUserData {
 
 class BaseMessageServiceCallbackData : public CallbackUserData {
  public:
-  BaseMessageServiceCallbackData(PostQueue& queue, long cid);
+  BaseMessageServiceCallbackData(PostQueue& queue, long cid, MessagingInstance& instance);
   virtual ~BaseMessageServiceCallbackData();
 
   /**
@@ -96,7 +96,7 @@ class MessageBodyCallbackData : public BaseMessageServiceCallbackData {
 
 class MessageAttachmentCallbackData : public BaseMessageServiceCallbackData {
  public:
-  MessageAttachmentCallbackData(PostQueue& queue, long cid);
+  MessageAttachmentCallbackData(PostQueue& queue, long cid, MessagingInstance& instance);
   virtual ~MessageAttachmentCallbackData();
 
   void setMessageAttachment(std::shared_ptr<MessageAttachment> messageAttachment);
@@ -119,7 +119,7 @@ class MessageAttachmentCallbackData : public BaseMessageServiceCallbackData {
 
 class SyncCallbackData : public BaseMessageServiceCallbackData {
  public:
-  SyncCallbackData(PostQueue& queue, long cid);
+  SyncCallbackData(PostQueue& queue, long cid, MessagingInstance& instance);
   virtual ~SyncCallbackData();
 
   void setLimit(const unsigned long limit);
@@ -177,12 +177,13 @@ class MessageService {
    * We have child classes MessageServiceEmail and MessageServiceShortMsg which
    * should provide specialized implementation.
    */
-  MessageService(int id, MessageType msgType, const std::string& name);
+  MessageService(int id, MessageType msgType, const std::string& name, MessagingInstance& instance);
 
   int m_id;
   MessageType m_msg_type;
   std::string m_name;
   MessageStoragePtr m_storage;
+  MessagingInstance& instance_;
 };
 
 }  // messaging

diff --git a/src/messaging/message_service_email.cc b/src/messaging/message_service_email.cc
index 09b941e7626095f3995b1c5b9eff3b11cc4a7eac..9a8a874836871ffd1c7fac07278caab50565fce0 100644 (file)
--- a/src/messaging/message_service_email.cc
+++ b/src/messaging/message_service_email.cc
@@ -16,6 +16,7 @@
 
 #include "message_service_email.h"
 #include "email_manager.h"
+#include "messaging_instance.h"
 
 #include "common/logger.h"
 
@@ -25,8 +26,8 @@ using common::PlatformResult;
 namespace extension {
 namespace messaging {
 
-MessageServiceEmail::MessageServiceEmail(int id, std::string name)
-    : MessageService(id, MessageType::EMAIL, name) {
+MessageServiceEmail::MessageServiceEmail(int id, std::string name, MessagingInstance& instance)
+    : MessageService(id, MessageType::EMAIL, name, instance) {
   ScopeLogger();
 }
 
@@ -36,15 +37,14 @@ MessageServiceEmail::~MessageServiceEmail() {
   for (auto id : registered_callbacks_) {
     // this may internally fail, because we don't have information about
     // callbacks which already have fired
-    EmailManager::getInstance().RemoveSyncCallback(id);
+    instance_.getEmailManager().RemoveSyncCallback(id);
   }
 }
 
 static gboolean sendMessageTask(void* data) {
   ScopeLogger();
-
-  auto ret =
-      EmailManager::getInstance().sendMessage(static_cast<MessageRecipientsCallbackData*>(data));
+  MessageRecipientsCallbackData* callback = static_cast<MessageRecipientsCallbackData*>(data);
+  auto ret = callback->getEmailManager().sendMessage(callback);
 
   if (!ret) {
     LoggerE("Error: %d - %s", ret.error_code(), ret.message().c_str());
@@ -73,8 +73,8 @@ PlatformResult MessageServiceEmail::sendMessage(MessageRecipientsCallbackData* c
 
 static gboolean loadMessageBodyTask(void* data) {
   ScopeLogger();
-
-  EmailManager::getInstance().loadMessageBody(static_cast<MessageBodyCallbackData*>(data));
+  MessageBodyCallbackData* callback = static_cast<MessageBodyCallbackData*>(data);
+  callback->getEmailManager().loadMessageBody(callback);
 
   return FALSE;
 }
@@ -113,7 +113,7 @@ static gboolean loadMessageAttachmentTask(void* data) {
       delete callback;
       callback = nullptr;
     } else {
-      const auto ret = EmailManager::getInstance().loadMessageAttachment(callback);
+      const auto ret = callback->getEmailManager().loadMessageAttachment(callback);
 
       if (!ret) {
         LoggerE("Error: %d - %s", ret.error_code(), ret.message().c_str());
@@ -138,8 +138,8 @@ PlatformResult MessageServiceEmail::loadMessageAttachment(MessageAttachmentCallb
 
 static gboolean syncTask(void* data) {
   ScopeLogger();
-
-  EmailManager::getInstance().sync(data);
+  SyncCallbackData* callback = static_cast<SyncCallbackData*>(data);
+  callback->getEmailManager().sync(data);
 
   return FALSE;
 }
@@ -151,7 +151,7 @@ PlatformResult MessageServiceEmail::sync(SyncCallbackData* callback, long* opera
     return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Callback is null");
   }
 
-  long op_id = EmailManager::getInstance().getUniqueOpId();
+  long op_id = callback->getEmailManager().getUniqueOpId();
   callback->setOpId(op_id);
 
   guint id = g_idle_add(syncTask, static_cast<void*>(callback));
@@ -166,8 +166,8 @@ PlatformResult MessageServiceEmail::sync(SyncCallbackData* callback, long* opera
 
 static gboolean syncFolderTask(void* data) {
   ScopeLogger();
-
-  EmailManager::getInstance().syncFolder(static_cast<SyncFolderCallbackData*>(data));
+  SyncFolderCallbackData* callback = static_cast<SyncFolderCallbackData*>(data);
+  callback->getEmailManager().syncFolder(callback);
 
   return FALSE;
 }
@@ -184,7 +184,7 @@ PlatformResult MessageServiceEmail::syncFolder(SyncFolderCallbackData* callback,
     return LogAndCreateResult(ErrorCode::TYPE_MISMATCH_ERR, "Message folder is null");
   }
 
-  long op_id = EmailManager::getInstance().getUniqueOpId();
+  long op_id = callback->getEmailManager().getUniqueOpId();
   callback->setOpId(op_id);
 
   guint id = g_idle_add(syncFolderTask, callback);
@@ -205,11 +205,11 @@ static gboolean stopSyncTask(void* data) {
     return FALSE;
   }
 
-  const long op_id = *(static_cast<long*>(data));
-  delete static_cast<long*>(data);
-  data = NULL;
-  EmailManager::getInstance().stopSync(op_id);
-
+  StopSyncData* callback = static_cast<StopSyncData*>(data);
+  long op_id = callback->op_id;
+  callback->instance.getEmailManager().stopSync(op_id);
+  delete callback;
+  callback = nullptr;
   return FALSE;
 }
 
@@ -217,7 +217,7 @@ PlatformResult MessageServiceEmail::stopSync(long op_id) {
   ScopeLogger();
 
   registered_callbacks_.erase(op_id);
-  long* data = new long(op_id);
+  StopSyncData* data = new StopSyncData{op_id, instance_};
   guint id = g_idle_add(stopSyncTask, static_cast<void*>(data));
 
   if (!id) {

diff --git a/src/messaging/message_service_email.h b/src/messaging/message_service_email.h
index 8d14bb7bf9fdd1971ea8e7cde36981dca7a9f0a9..e16911093ba2fc35deef498715c23918e3f64214 100644 (file)
--- a/src/messaging/message_service_email.h
+++ b/src/messaging/message_service_email.h
@@ -24,9 +24,14 @@
 namespace extension {
 namespace messaging {
 
+struct StopSyncData {
+  long op_id;
+  MessagingInstance& instance;
+};
+
 class MessageServiceEmail : public MessageService {
  public:
-  MessageServiceEmail(int id, std::string name);
+  MessageServiceEmail(int id, std::string name, MessagingInstance& instance);
   virtual ~MessageServiceEmail();
 
   virtual common::PlatformResult sendMessage(MessageRecipientsCallbackData* callback);

diff --git a/src/messaging/message_service_short_msg.cc b/src/messaging/message_service_short_msg.cc
index 78db705840ff491aef53d9928d90985ae0c38b5f..a5ca744a3d1cf7d88d77207d7547b8c9889c115d 100644 (file)
--- a/src/messaging/message_service_short_msg.cc
+++ b/src/messaging/message_service_short_msg.cc
@@ -37,8 +37,9 @@ using common::PlatformResult;
 namespace extension {
 namespace messaging {
 
-MessageServiceShortMsg::MessageServiceShortMsg(int id, MessageType msgType)
-    : MessageService(id, msgType, MessagingUtil::messageTypeToString(msgType)) {
+MessageServiceShortMsg::MessageServiceShortMsg(int id, MessageType msgType,
+                                               MessagingInstance& instance)
+    : MessageService(id, msgType, MessagingUtil::messageTypeToString(msgType), instance) {
   ScopeLogger();
 }
 
@@ -49,8 +50,8 @@ MessageServiceShortMsg::~MessageServiceShortMsg() {
 static gboolean sendMessageThread(void* data) {
   ScopeLogger();
 
-  auto ret =
-      ShortMsgManager::getInstance().sendMessage(static_cast<MessageRecipientsCallbackData*>(data));
+  MessageRecipientsCallbackData* callback = static_cast<MessageRecipientsCallbackData*>(data);
+  auto ret = callback->getShortMsgManager().sendMessage(callback);
 
   if (!ret) {
     LoggerE("Error: %d - %s", ret.error_code(), ret.message().c_str());
@@ -150,16 +151,16 @@ PlatformResult MessageServiceShortMsg::loadMessageBody(MessageBodyCallbackData*
   return PlatformResult(ErrorCode::NO_ERROR);
 }
 
-MessageServiceShortMsg* MessageServiceShortMsg::GetMmsMessageService() {
+MessageServiceShortMsg* MessageServiceShortMsg::GetMmsMessageService(MessagingInstance& instance) {
   ScopeLogger();
   return new (std::nothrow)
-      MessageServiceShortMsg(MessageServiceAccountId::MMS_ACCOUNT_ID, MessageType::MMS);
+      MessageServiceShortMsg(MessageServiceAccountId::MMS_ACCOUNT_ID, MessageType::MMS, instance);
 }
 
-MessageServiceShortMsg* MessageServiceShortMsg::GetSmsMessageService() {
+MessageServiceShortMsg* MessageServiceShortMsg::GetSmsMessageService(MessagingInstance& instance) {
   ScopeLogger();
   return new (std::nothrow)
-      MessageServiceShortMsg(MessageServiceAccountId::SMS_ACCOUNT_ID, MessageType::SMS);
+      MessageServiceShortMsg(MessageServiceAccountId::SMS_ACCOUNT_ID, MessageType::SMS, instance);
 }
 
 }  // namespace messaging

diff --git a/src/messaging/message_service_short_msg.h b/src/messaging/message_service_short_msg.h
index d1ad5f2d94505dfca1716609f04d902ccec25abb..a18c40a875d54b6055152789957ebeecb6f517b0 100644 (file)
--- a/src/messaging/message_service_short_msg.h
+++ b/src/messaging/message_service_short_msg.h
@@ -31,11 +31,11 @@ class MessageServiceShortMsg : public MessageService {
 
   virtual common::PlatformResult loadMessageBody(MessageBodyCallbackData* callback);
 
-  static MessageServiceShortMsg* GetMmsMessageService();
-  static MessageServiceShortMsg* GetSmsMessageService();
+  static MessageServiceShortMsg* GetMmsMessageService(MessagingInstance& instance);
+  static MessageServiceShortMsg* GetSmsMessageService(MessagingInstance& instance);
 
  protected:
-  MessageServiceShortMsg(int id, MessageType msgType);
+  MessageServiceShortMsg(int id, MessageType msgType, MessagingInstance& instance);
 };
 
 }  // namespace messaging

diff --git a/src/messaging/message_storage_email.cc b/src/messaging/message_storage_email.cc
index 87e670c7840faeeb4f663c591f518b360083f387..fc5bfa00099192141c9b4999dbed774a92386a1d 100644 (file)
--- a/src/messaging/message_storage_email.cc
+++ b/src/messaging/message_storage_email.cc
@@ -22,6 +22,7 @@
 
 #include "email_manager.h"
 #include "message.h"
+#include "messaging_instance.h"
 
 namespace extension {
 namespace messaging {
@@ -38,7 +39,7 @@ static gboolean addDraftMessageTask(void* data) {
   ScopeLogger();
 
   MessageCallbackUserData* callback = static_cast<MessageCallbackUserData*>(data);
-  EmailManager::getInstance().addDraftMessage(callback);
+  callback->getEmailManager().addDraftMessage(callback);
 
   return FALSE;
 }
@@ -65,7 +66,7 @@ static gboolean removeMessagesTask(void* data) {
   ScopeLogger();
 
   MessagesCallbackUserData* callback = static_cast<MessagesCallbackUserData*>(data);
-  EmailManager::getInstance().removeMessages(callback);
+  callback->getEmailManager().removeMessages(callback);
 
   return FALSE;
 }
@@ -92,7 +93,7 @@ static gboolean updateMessagesTask(void* data) {
   ScopeLogger();
 
   MessagesCallbackUserData* callback = static_cast<MessagesCallbackUserData*>(data);
-  EmailManager::getInstance().updateMessages(callback);
+  callback->getEmailManager().updateMessages(callback);
 
   return FALSE;
 }
@@ -118,7 +119,7 @@ static gboolean findMessagesTask(void* data) {
   ScopeLogger();
 
   FindMsgCallbackUserData* callback = static_cast<FindMsgCallbackUserData*>(data);
-  EmailManager::getInstance().findMessages(callback);
+  callback->getEmailManager().findMessages(callback);
 
   return FALSE;
 }
@@ -146,7 +147,7 @@ static gboolean findConversationsTask(void* data) {
   ScopeLogger();
 
   ConversationCallbackData* callback = static_cast<ConversationCallbackData*>(data);
-  EmailManager::getInstance().findConversations(callback);
+  callback->getEmailManager().findConversations(callback);
 
   return FALSE;
 }
@@ -173,7 +174,7 @@ static gboolean removeConversationsTask(void* data) {
   ScopeLogger();
 
   ConversationCallbackData* callback = static_cast<ConversationCallbackData*>(data);
-  EmailManager::getInstance().removeConversations(callback);
+  callback->getEmailManager().removeConversations(callback);
 
   return FALSE;
 }
@@ -200,7 +201,7 @@ static gboolean findFoldersTask(void* data) {
   ScopeLogger();
 
   FoldersCallbackData* callback = static_cast<FoldersCallbackData*>(data);
-  EmailManager::getInstance().findFolders(callback);
+  callback->getEmailManager().findFolders(callback);
 
   return FALSE;
 }

diff --git a/src/messaging/message_storage_short_msg.cc b/src/messaging/message_storage_short_msg.cc
index 335b189911abe46df380c47cce23b05a003ed216..2c1e47270c833a749386ea2b530801b5ad46169c 100644 (file)
--- a/src/messaging/message_storage_short_msg.cc
+++ b/src/messaging/message_storage_short_msg.cc
@@ -39,7 +39,7 @@ static gboolean addDraftMessageTask(void* data) {
   ScopeLogger();
 
   MessageCallbackUserData* callback = static_cast<MessageCallbackUserData*>(data);
-  ShortMsgManager::getInstance().addDraftMessage(callback);
+  callback->getShortMsgManager().addDraftMessage(callback);
 
   return false;
 }
@@ -64,7 +64,7 @@ static gboolean removeMessagesTask(void* data) {
   ScopeLogger();
 
   MessagesCallbackUserData* callback = static_cast<MessagesCallbackUserData*>(data);
-  ShortMsgManager::getInstance().removeMessages(callback);
+  callback->getShortMsgManager().removeMessages(callback);
 
   return false;
 }
@@ -91,7 +91,7 @@ static gboolean updateMessagesTask(void* data) {
   ScopeLogger();
 
   MessagesCallbackUserData* callback = static_cast<MessagesCallbackUserData*>(data);
-  ShortMsgManager::getInstance().updateMessages(callback);
+  callback->getShortMsgManager().updateMessages(callback);
 
   return false;
 }
@@ -118,7 +118,7 @@ static gboolean findMessagesTask(void* data) {
   ScopeLogger();
 
   FindMsgCallbackUserData* callback = static_cast<FindMsgCallbackUserData*>(data);
-  ShortMsgManager::getInstance().findMessages(callback);
+  callback->getShortMsgManager().findMessages(callback);
 
   return false;
 }
@@ -145,7 +145,7 @@ static gboolean findConversationsTask(void* data) {
   ScopeLogger();
 
   ConversationCallbackData* callback = static_cast<ConversationCallbackData*>(data);
-  ShortMsgManager::getInstance().findConversations(callback);
+  callback->getShortMsgManager().findConversations(callback);
 
   return false;
 }
@@ -172,7 +172,7 @@ static gboolean removeConversationsTask(void* data) {
   ScopeLogger();
 
   ConversationCallbackData* callback = static_cast<ConversationCallbackData*>(data);
-  ShortMsgManager::getInstance().removeConversations(callback);
+  callback->getShortMsgManager().removeConversations(callback);
 
   return false;
 }

diff --git a/src/messaging/messages_callback_user_data.cc b/src/messaging/messages_callback_user_data.cc
index ef74d62e3f2d87eb635f93ea2de35b98cac297ac..b84746803cfb1695138f5a55d5f3bca8ed0ebc26 100644 (file)
--- a/src/messaging/messages_callback_user_data.cc
+++ b/src/messaging/messages_callback_user_data.cc
@@ -20,8 +20,9 @@ namespace extension {
 namespace messaging {
 
 MessagesCallbackUserData::MessagesCallbackUserData(PostQueue& queue, long cid,
+                                                   MessagingInstance& instance,
                                                    bool keep /* = false*/)
-    : CallbackUserData(queue, cid, keep), m_service_type(UNDEFINED) {
+    : CallbackUserData(queue, cid, instance, keep), m_service_type(UNDEFINED) {
   ScopeLogger();
 }
 

diff --git a/src/messaging/messages_callback_user_data.h b/src/messaging/messages_callback_user_data.h
index e59b10073406a6328fc4c6637d03b7556a26bc6e..4869ccee9a2bbd6cd09817f3788f020b3c6411d1 100644 (file)
--- a/src/messaging/messages_callback_user_data.h
+++ b/src/messaging/messages_callback_user_data.h
@@ -32,7 +32,8 @@ class Message;
 
 class MessagesCallbackUserData : public CallbackUserData {
  public:
-  MessagesCallbackUserData(PostQueue& queue, long cid, bool keep = false);
+  MessagesCallbackUserData(PostQueue& queue, long cid, MessagingInstance& instance,
+                           bool keep = false);
   virtual ~MessagesCallbackUserData();
 
   void addMessage(std::shared_ptr<Message> msg);

diff --git a/src/messaging/messages_change_callback.cc b/src/messaging/messages_change_callback.cc
index d262a42594d843d0d7115bc02f9f791e8da647b3..d476d9c55d2b319f137a74b2a2fdbd534fa8e252 100644 (file)
--- a/src/messaging/messages_change_callback.cc
+++ b/src/messaging/messages_change_callback.cc
@@ -47,8 +47,8 @@ const char* MESSAGESUPDATED = "messagesupdated";
 const char* MESSAGESREMOVED = "messagesremoved";
 
 MessagesChangeCallback::MessagesChangeCallback(long cid, int service_id, MessageType service_type,
-                                               PostQueue& queue)
-    : m_callback_data(queue, cid, true),
+                                               PostQueue& queue, MessagingInstance& instance)
+    : m_callback_data(queue, cid, instance, true),
       m_service_id(service_id),
       m_msg_type(service_type),
       m_is_act(true) {

diff --git a/src/messaging/messages_change_callback.h b/src/messaging/messages_change_callback.h
index 64343cbf231f3157ef1e5af13558c57be89d87c2..fe721be75590047d15291c714596f483e52e73fa 100644 (file)
--- a/src/messaging/messages_change_callback.h
+++ b/src/messaging/messages_change_callback.h
@@ -38,7 +38,8 @@ class MessagesChangeCallback {
  public:
   typedef void (MessagesChangeCallback::*Signature)(const MessagePtrVector& conversations);
 
-  MessagesChangeCallback(long cid, int service_id, MessageType service_type, PostQueue& queue);
+  MessagesChangeCallback(long cid, int service_id, MessageType service_type, PostQueue& queue,
+                         MessagingInstance& instance);
   virtual ~MessagesChangeCallback();
 
   void added(const MessagePtrVector& messages);

diff --git a/src/messaging/messaging_extension.cc b/src/messaging/messaging_extension.cc
index caefca7e2884a80373d64a14c3e7373171d58144..97e5e9a79168b93cea4dd76a895de87292860ca7 100644 (file)
--- a/src/messaging/messaging_extension.cc
+++ b/src/messaging/messaging_extension.cc
@@ -47,10 +47,11 @@ MessagingExtension::~MessagingExtension() {
 
 common::Instance* MessagingExtension::CreateInstance() {
   ScopeLogger();
-  PlatformResult ret = extension::messaging::EmailManager::InitializeEmailService();
+  extension::messaging::MessagingInstance* instance = new extension::messaging::MessagingInstance();
+  PlatformResult ret = instance->getEmailManager().InitializeEmailService();
   if (ret.IsError()) {
     LoggerE("Initializing the email service failed (%s)", ret.message().c_str());
     return nullptr;
   }
-  return new extension::messaging::MessagingInstance();
+  return static_cast<Instance*>(instance);
 }

diff --git a/src/messaging/messaging_instance.cc b/src/messaging/messaging_instance.cc
index 1446c731a9af5526ae48275995eda57de0410dfc..2cf41a50a0eefc90398585a4f46e765adbc7df08 100644 (file)
--- a/src/messaging/messaging_instance.cc
+++ b/src/messaging/messaging_instance.cc
@@ -174,6 +174,14 @@ MessagingInstance::~MessagingInstance() {
     return;                                                                         \
   }
 
+EmailManager& MessagingInstance::getEmailManager() {
+  return email_manager_;
+}
+
+ShortMsgManager& MessagingInstance::getShortMsgManager() {
+  return short_msg_manager_;
+}
+
 void MessagingInstance::GetMessageServices(const picojson::value& args, picojson::object& out) {
   ScopeLogger();
 
@@ -202,12 +210,13 @@ void MessagingInstance::MessageServiceSendMessage(const picojson::value& args,
   obj[JSON_CALLBACK_ID] = picojson::value(callbackId);
 
   std::shared_ptr<Message> message;
-  PlatformResult ret = MessagingUtil::jsonToMessage(v_message, &message);
+  PlatformResult ret = MessagingUtil::jsonToMessage(v_message, &message, *this);
   if (ret.IsError()) {
     POST_AND_RETURN(ret, json, obj)
   }
 
-  MessageRecipientsCallbackData* callback = new MessageRecipientsCallbackData(queue_, callbackId);
+  MessageRecipientsCallbackData* callback =
+      new MessageRecipientsCallbackData(queue_, callbackId, *this);
   long simIndex = 0;
   int serviceId = 0;
 
@@ -256,12 +265,12 @@ void MessagingInstance::MessageServiceLoadMessageBody(const picojson::value& arg
   obj[JSON_CALLBACK_ID] = picojson::value(callbackId);
 
   std::shared_ptr<Message> message;
-  PlatformResult ret = MessagingUtil::jsonToMessage(json_message, &message);
+  PlatformResult ret = MessagingUtil::jsonToMessage(json_message, &message, *this);
   if (ret.IsError()) {
     POST_AND_RETURN(ret, json, obj)
   }
 
-  MessageBodyCallbackData* callback = new MessageBodyCallbackData(queue_, callbackId);
+  MessageBodyCallbackData* callback = new MessageBodyCallbackData(queue_, callbackId, *this);
 
   callback->setMessage(message);
 
@@ -284,7 +293,8 @@ void MessagingInstance::MessageServiceLoadMessageAttachment(const picojson::valu
   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_, callbackId);
+  MessageAttachmentCallbackData* callback =
+      new MessageAttachmentCallbackData(queue_, callbackId, *this);
   callback->setMessageAttachment(MessagingUtil::jsonToMessageAttachment(attachment));
 
   callback->AddToQueue();
@@ -322,7 +332,7 @@ void MessagingInstance::MessageServiceSync(const picojson::value& args, picojson
     limit = static_cast<long>(v_limit.get<double>());
   }
 
-  SyncCallbackData* callback = new SyncCallbackData(queue_, callbackId);
+  SyncCallbackData* callback = new SyncCallbackData(queue_, callbackId, *this);
   callback->setAccountId(id);
   callback->setLimit(limit);
 
@@ -365,7 +375,7 @@ void MessagingInstance::MessageServiceSyncFolder(const picojson::value& args,
     limit = static_cast<long>(v_limit.get<double>());
   }
 
-  SyncFolderCallbackData* callback = new SyncFolderCallbackData(queue_, callbackId);
+  SyncFolderCallbackData* callback = new SyncFolderCallbackData(queue_, callbackId, *this);
   callback->setAccountId(id);
   callback->setMessageFolder(MessagingUtil::jsonToMessageFolder(v_folder));
   callback->setLimit(limit);
@@ -432,12 +442,12 @@ void MessagingInstance::MessageStorageAddDraft(const picojson::value& args, pico
   obj[JSON_CALLBACK_ID] = picojson::value(callbackId);
 
   std::shared_ptr<Message> message;
-  PlatformResult ret = MessagingUtil::jsonToMessage(v_message, &message);
+  PlatformResult ret = MessagingUtil::jsonToMessage(v_message, &message, *this);
   if (ret.IsError()) {
     POST_AND_RETURN(ret, json, obj)
   }
 
-  MessageCallbackUserData* callback = new MessageCallbackUserData(queue_, callbackId);
+  MessageCallbackUserData* callback = new MessageCallbackUserData(queue_, callbackId, *this);
   callback->setMessage(message);
 
   int serviceId = getServiceIdFromJSON(data);
@@ -478,7 +488,7 @@ void MessagingInstance::MessageStorageFindMessages(const picojson::value& args,
   int serviceId = getServiceIdFromJSON(data);
   auto storage = manager_.getMessageService(serviceId)->getMsgStorage();
 
-  FindMsgCallbackUserData* callback = new FindMsgCallbackUserData(queue_, callbackId);
+  FindMsgCallbackUserData* callback = new FindMsgCallbackUserData(queue_, callbackId, *this);
   callback->setFilter(filter);
   callback->setLimit(limit);
   callback->setOffset(offset);
@@ -500,11 +510,11 @@ void MessagingInstance::MessageStorageRemoveMessages(const picojson::value& args
   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_, callbackId);
+  MessagesCallbackUserData* callback = new MessagesCallbackUserData(queue_, callbackId, *this);
 
-  auto each = [callback](picojson::value& v) -> void {
+  auto each = [callback, this](picojson::value& v) -> void {
     std::shared_ptr<Message> message;
-    PlatformResult ret = MessagingUtil::jsonToMessage(v, &message);
+    PlatformResult ret = MessagingUtil::jsonToMessage(v, &message, *this);
     if (ret.IsSuccess()) {
       callback->addMessage(message);
     }
@@ -530,15 +540,16 @@ void MessagingInstance::MessageStorageUpdateMessages(const picojson::value& args
   auto pico_array = pico_messages.get<picojson::array>();
   const double callbackId = args.get(JSON_CALLBACK_ID).get<double>();
 
-  auto callback = new MessagesCallbackUserData(queue_, callbackId);
+  auto callback = new MessagesCallbackUserData(queue_, callbackId, *this);
 
-  std::for_each(pico_array.begin(), pico_array.end(), [&callback](picojson::value& v) -> void {
-    std::shared_ptr<Message> message;
-    PlatformResult ret = MessagingUtil::jsonToMessage(v, &message);
-    if (ret.IsSuccess()) {
-      callback->addMessage(message);
-    }
-  });
+  std::for_each(pico_array.begin(), pico_array.end(),
+                [&callback, this](picojson::value& v) -> void {
+                  std::shared_ptr<Message> message;
+                  PlatformResult ret = MessagingUtil::jsonToMessage(v, &message, *this);
+                  if (ret.IsSuccess()) {
+                    callback->addMessage(message);
+                  }
+                });
 
   auto service = manager_.getMessageService(getServiceIdFromJSON(data));
 
@@ -573,7 +584,7 @@ void MessagingInstance::MessageStorageFindConversations(const picojson::value& a
 
   int serviceId = getServiceIdFromJSON(data);
 
-  ConversationCallbackData* callback = new ConversationCallbackData(queue_, callbackId);
+  ConversationCallbackData* callback = new ConversationCallbackData(queue_, callbackId, *this);
   callback->setFilter(filter);
   callback->setLimit(limit);
   callback->setOffset(offset);
@@ -601,7 +612,7 @@ void MessagingInstance::MessageStorageRemoveConversations(const picojson::value&
   picojson::object& obj = json->get<picojson::object>();
   obj[JSON_CALLBACK_ID] = picojson::value(callbackId);
 
-  ConversationCallbackData* callback = new ConversationCallbackData(queue_, callbackId);
+  ConversationCallbackData* callback = new ConversationCallbackData(queue_, callbackId, *this);
 
   PlatformResult ret(ErrorCode::NO_ERROR);
   for (auto it = conversations.begin(); it != conversations.end(); ++it) {
@@ -640,7 +651,7 @@ void MessagingInstance::MessageStorageFindFolders(const picojson::value& args,
     POST_AND_RETURN(ret, json, obj)
   }
 
-  FoldersCallbackData* callback = new FoldersCallbackData(queue_, callbackId);
+  FoldersCallbackData* callback = new FoldersCallbackData(queue_, callbackId, *this);
   callback->setFilter(filter);
 
   callback->AddToQueue();
@@ -667,8 +678,8 @@ void MessagingInstance::MessageStorageAddMessagesChangeListener(const picojson::
 
   auto service = manager_.getMessageService(serviceId);
 
-  std::shared_ptr<MessagesChangeCallback> callback(
-      new MessagesChangeCallback(kDumbCallbackId, serviceId, service->getMsgServiceType(), queue_));
+  std::shared_ptr<MessagesChangeCallback> callback(new MessagesChangeCallback(
+      kDumbCallbackId, serviceId, service->getMsgServiceType(), queue_, *this));
 
   callback->setFilter(filter);
 
@@ -698,7 +709,7 @@ void MessagingInstance::MessageStorageAddConversationsChangeListener(const picoj
   auto service = manager_.getMessageService(serviceId);
 
   std::shared_ptr<ConversationsChangeCallback> callback(new ConversationsChangeCallback(
-      static_cast<long>(-1), serviceId, service->getMsgServiceType(), queue_));
+      static_cast<long>(-1), serviceId, service->getMsgServiceType(), queue_, *this));
 
   callback->setFilter(filter);
 
@@ -728,7 +739,7 @@ void MessagingInstance::MessageStorageAddFolderChangeListener(const picojson::va
   auto service = manager_.getMessageService(serviceId);
 
   std::shared_ptr<FoldersChangeCallback> callback(new FoldersChangeCallback(
-      static_cast<long>(-1), serviceId, service->getMsgServiceType(), queue_));
+      static_cast<long>(-1), serviceId, service->getMsgServiceType(), queue_, *this));
 
   callback->setFilter(filter);
 
@@ -764,9 +775,9 @@ void MessagingInstance::MessageGetMessageStatus(const picojson::value& args,
 
   std::string status;
   if (FUN_MESSAGE_MESSAGING_EMAIL == type) {
-    status = EmailManager::getInstance().getMessageStatus(id);
+    status = email_manager_.getMessageStatus(id);
   } else {
-    status = ShortMsgManager::getInstance().getMessageStatus(id);
+    status = short_msg_manager_.getMessageStatus(id);
   }
 
   ReportSuccess(picojson::value(status), out);

diff --git a/src/messaging/messaging_instance.h b/src/messaging/messaging_instance.h
index 531af888015564ea3570ac5c1f26f472d2e507b6..d5ff5d75e928822d5652f15f20ea8df71ec255e2 100644 (file)
--- a/src/messaging/messaging_instance.h
+++ b/src/messaging/messaging_instance.h
@@ -19,8 +19,10 @@
 
 #include "common/extension.h"
 
+#include "email_manager.h"
 #include "messaging_manager.h"
 #include "messaging_util.h"
+#include "short_message_manager.h"
 
 namespace extension {
 namespace messaging {
@@ -29,6 +31,8 @@ class MessagingInstance : public common::ParsedInstance {
  public:
   MessagingInstance();
   virtual ~MessagingInstance();
+  EmailManager& getEmailManager();
+  ShortMsgManager& getShortMsgManager();
 
  private:
   void GetMessageServices(const picojson::value& args, picojson::object& out);
@@ -55,6 +59,8 @@ class MessagingInstance : public common::ParsedInstance {
   void MessageGetMessageStatus(const picojson::value& args, picojson::object& out);
 
   MessagingManager manager_;
+  ShortMsgManager short_msg_manager_;
+  EmailManager email_manager_;
   PostQueue queue_;
 };
 

diff --git a/src/messaging/messaging_manager.cc b/src/messaging/messaging_manager.cc
index 3016ff94646cdd373682b229a83e045015153449..dbb4f4c5ae441b73f3b4fd20dc47e60edec34093 100644 (file)
--- a/src/messaging/messaging_manager.cc
+++ b/src/messaging/messaging_manager.cc
@@ -61,7 +61,7 @@ MessagingManager::MessagingManager(MessagingInstance& instance) : instance_(inst
   if (ret != MSG_SUCCESS) {
     LoggerE("Cannot get message handle: %d", ret);
   } else {
-    ShortMsgManager::getInstance().registerStatusCallback(m_msg_handle);
+    instance.getShortMsgManager().registerStatusCallback(m_msg_handle);
   }
 
   m_sms_service = std::make_pair(UNDEFINED_MESSAGE_SERVICE, nullptr);
@@ -113,7 +113,8 @@ static void* getMsgServicesThread(const std::shared_ptr<MsgManagerCallbackData>&
             delete user_data->sms_service->second;
           }
 
-          MessageService* service = MessageServiceShortMsg::GetSmsMessageService();
+          MessageService* service =
+              MessageServiceShortMsg::GetSmsMessageService(user_data->instance_);
 
           if (!service) {
             platform_result = LogAndCreateResult(ErrorCode::UNKNOWN_ERR,
@@ -138,7 +139,8 @@ static void* getMsgServicesThread(const std::shared_ptr<MsgManagerCallbackData>&
             delete user_data->mms_service->second;
           }
 
-          MessageService* service = MessageServiceShortMsg::GetMmsMessageService();
+          MessageService* service =
+              MessageServiceShortMsg::GetMmsMessageService(user_data->instance_);
 
           if (!service) {
             platform_result = LogAndCreateResult(ErrorCode::UNKNOWN_ERR,
@@ -180,8 +182,8 @@ static void* getMsgServicesThread(const std::shared_ptr<MsgManagerCallbackData>&
               LoggerD("Account[%d/%d] id: %d, name: %s", i, count, email_accounts[i].account_id,
                       name.c_str());
 
-              MessageService* service = new (std::nothrow)
-                  MessageServiceEmail(email_accounts[i].account_id, name.c_str());
+              MessageService* service = new (std::nothrow) MessageServiceEmail(
+                  email_accounts[i].account_id, name.c_str(), user_data->instance_);
               if (!service) {
                 LoggerD("message service[%d] is NULL", i);
                 std::for_each(msgServices.begin(), msgServices.end(),

diff --git a/src/messaging/messaging_util.cc b/src/messaging/messaging_util.cc
index 6385c43309121cab09df36e9a7b07378a0e51444..d919911c5940211b391e47425a4141c25a84af82 100644 (file)
--- a/src/messaging/messaging_util.cc
+++ b/src/messaging/messaging_util.cc
@@ -674,7 +674,8 @@ picojson::value MessagingUtil::folderToJson(std::shared_ptr<MessageFolder> folde
 }
 
 PlatformResult MessagingUtil::jsonToMessage(const picojson::value& json,
-                                            std::shared_ptr<Message>* result_message) {
+                                            std::shared_ptr<Message>* result_message,
+                                            MessagingInstance& instance) {
   ScopeLogger();
   std::shared_ptr<Message> message;
   picojson::object data = json.get<picojson::object>();
@@ -700,7 +701,7 @@ PlatformResult MessagingUtil::jsonToMessage(const picojson::value& json,
       } else {
         std::string mid = data.at(MESSAGE_ATTRIBUTE_ID).get<std::string>();
         int message_id = std::atoi(mid.c_str());
-        platform_result = Message::findShortMessageById(message_id, &message);
+        platform_result = Message::findShortMessageById(message_id, instance, &message);
         if (!platform_result) return platform_result;
       }
       break;
@@ -1143,7 +1144,7 @@ PostQueue::PostQueue(MessagingInstance& instance) : instance_(instance) {
 PostQueue::~PostQueue() {
   ScopeLogger("this: [%p]", this);
 
-  EmailManager::getInstance().RemoveCallbacksByQueue(*this);
+  instance_.getEmailManager().RemoveCallbacksByQueue(*this);
 }
 
 void PostQueue::addAndResolve(const long cid, PostPriority priority, const std::string& json) {

diff --git a/src/messaging/messaging_util.h b/src/messaging/messaging_util.h
index bbd89268af986d256742de08ab9d9a047157f7ab..7ccd031a99f41c984c004a8ff86bc7d4af590911 100644 (file)
--- a/src/messaging/messaging_util.h
+++ b/src/messaging/messaging_util.h
@@ -128,7 +128,8 @@ class MessagingUtil {
   static picojson::value conversationToJson(std::shared_ptr<MessageConversation> conversation);
   static picojson::value folderToJson(std::shared_ptr<MessageFolder> folder);
   static common::PlatformResult jsonToMessage(const picojson::value& json,
-                                              std::shared_ptr<Message>* result);
+                                              std::shared_ptr<Message>* result,
+                                              MessagingInstance& instance);
   static std::shared_ptr<MessageBody> jsonToMessageBody(const picojson::value& json);
   static std::shared_ptr<MessageFolder> jsonToMessageFolder(const picojson::value& json);
   static tizen::SortModePtr jsonToSortMode(const picojson::object& json);

diff --git a/src/messaging/short_message_manager.cc b/src/messaging/short_message_manager.cc
index 8bc5468dc347ebc987bca7e785be61a1ed8376ac..6007a5929725371eb4f00146a7fe909b8e644ac5 100644 (file)
--- a/src/messaging/short_message_manager.cc
+++ b/src/messaging/short_message_manager.cc
@@ -39,13 +39,6 @@ using common::PlatformResult;
 namespace extension {
 namespace messaging {
 
-ShortMsgManager& ShortMsgManager::getInstance() {
-  ScopeLogger();
-
-  static ShortMsgManager instance;
-  return instance;
-}
-
 static gboolean sendMessageCompleteCB(void* data) {
   ScopeLogger("callback:%p", data);
 
@@ -390,13 +383,15 @@ void ShortMsgManager::sendStatusCallback(msg_struct_t sent_status) {
 
 static void sent_status_cb(msg_handle_t handle, msg_struct_t sent_status, void* data) {
   ScopeLogger();
-  ShortMsgManager::getInstance().sendStatusCallback(sent_status);
+  ShortMsgManager* short_msg_manager = static_cast<ShortMsgManager*>(data);
+  short_msg_manager->sendStatusCallback(sent_status);
 
   return;
 }
 
-PlatformResult ShortMsgManager::callProperEventMessages(
-    EventMessages* event, msg_storage_change_type_t storageChangeType) {
+PlatformResult ShortMsgManager::callProperEventMessages(EventMessages* event,
+                                                        msg_storage_change_type_t storageChangeType,
+                                                        ShortMsgManager* shortMsgManager) {
   ScopeLogger(
       "event.items.size()=%d event.removed_conversations.size()=%d"
       " sChangeType:%d",
@@ -410,7 +405,7 @@ PlatformResult ShortMsgManager::callProperEventMessages(
     eventConv->items = event->removed_conversations;
   } else {
     PlatformResult ret = ShortMsgManager::getConversationsForMessages(
-        event->items, storageChangeType, &(eventConv->items));
+        event->items, storageChangeType, &(eventConv->items), shortMsgManager);
     if (ret.IsError()) {
       LoggerD("Error while getting conversations for message");
       delete event;
@@ -513,21 +508,23 @@ void ShortMsgManager::storage_change_cb(msg_handle_t handle,
   eventMMS->service_type = MessageType::MMS;
   eventMMS->service_id = MMS_ACCOUNT_ID;
 
+  ShortMsgManager* short_msg_manager = static_cast<ShortMsgManager*>(data);
+
   if (MSG_STORAGE_CHANGE_DELETE == storageChangeType) {
-    ShortMsgManager& msg_manager = ShortMsgManager::getInstance();
-    std::lock_guard<std::mutex> lock(msg_manager.m_mutex);
+    std::lock_guard<std::mutex> lock(short_msg_manager->m_mutex);
 
     std::map<int, MessagePtr>* rem_msgs[2] = {
         // Recently removed messages
-        &msg_manager.m_sms_removed_messages, &msg_manager.m_mms_removed_messages};
+        &short_msg_manager->m_sms_removed_messages, &short_msg_manager->m_mms_removed_messages};
     std::map<int, int>* rem_convs[2] = {// Recently removed conversations
-                                        &msg_manager.m_sms_removed_msg_id_conv_id_map,
-                                        &msg_manager.m_mms_removed_msg_id_conv_id_map};
+                                        &short_msg_manager->m_sms_removed_msg_id_conv_id_map,
+                                        &short_msg_manager->m_mms_removed_msg_id_conv_id_map};
     EventMessages* dest_event[2] = {// SMS/MMS EventMessage to be propagated
                                     eventSMS, eventMMS};
-    std::map<int, ConversationPtr>* conv_map[2] = {// Map conversationId - object
-                                                   &msg_manager.m_sms_removed_conv_id_object_map,
-                                                   &msg_manager.m_mms_removed_conv_id_object_map};
+    std::map<int, ConversationPtr>* conv_map[2] = {
+        // Map conversationId - object
+        &short_msg_manager->m_sms_removed_conv_id_object_map,
+        &short_msg_manager->m_mms_removed_conv_id_object_map};
 
     for (int event_i = 0; event_i < 2; ++event_i) {
       std::map<int, MessagePtr>& cur_rem_msgs = *(rem_msgs[event_i]);
@@ -590,7 +587,7 @@ void ShortMsgManager::storage_change_cb(msg_handle_t handle,
     PlatformResult ret(ErrorCode::NO_ERROR);
     for (int i = 0; i < pMsgIdList->nCount; ++i) {
       msg_struct_t msg;
-      ret = ShortMsgManager::getInstance().getMessage(pMsgIdList->msgIdList[i], &msg);
+      ret = short_msg_manager->getMessage(pMsgIdList->msgIdList[i], &msg);
       if (ret.IsError() || NULL == msg) {
         LoggerE("Failed to load short message");
         delete eventSMS;
@@ -632,7 +629,8 @@ void ShortMsgManager::storage_change_cb(msg_handle_t handle,
   }
 
   if (!eventSMS->items.empty() || !eventSMS->removed_conversations.empty()) {
-    PlatformResult ret = ShortMsgManager::callProperEventMessages(eventSMS, storageChangeType);
+    PlatformResult ret =
+        ShortMsgManager::callProperEventMessages(eventSMS, storageChangeType, short_msg_manager);
     // PlatformResult could be ignored here. eventSMS is deleted in callProperEventMessages()
   } else {
     LoggerD("No SMS messages, not triggering eventSMS");
@@ -640,7 +638,8 @@ void ShortMsgManager::storage_change_cb(msg_handle_t handle,
     eventSMS = NULL;
   }
   if (!eventMMS->items.empty() || !eventMMS->removed_conversations.empty()) {
-    PlatformResult ret = ShortMsgManager::callProperEventMessages(eventMMS, storageChangeType);
+    PlatformResult ret =
+        ShortMsgManager::callProperEventMessages(eventMMS, storageChangeType, short_msg_manager);
     // PlatformResult could be ignored here. eventMMS is deleted in callProperEventMessages()
   } else {
     LoggerD("No MMS messages, not triggering eventMMS");
@@ -653,10 +652,12 @@ void ShortMsgManager::registerStatusCallback(msg_handle_t msg_handle) {
   ScopeLogger();
   m_msg_handle = msg_handle;
   // set message sent status callback
-  if (MSG_SUCCESS != msg_reg_sent_status_callback(m_msg_handle, &sent_status_cb, NULL)) {
+  if (MSG_SUCCESS !=
+      msg_reg_sent_status_callback(m_msg_handle, &sent_status_cb, static_cast<void*>(this))) {
     LoggerE("sent status callback register error!!!");
   }
-  if (MSG_SUCCESS != msg_reg_storage_change_callback(m_msg_handle, &storage_change_cb, NULL)) {
+  if (MSG_SUCCESS !=
+      msg_reg_storage_change_callback(m_msg_handle, &storage_change_cb, static_cast<void*>(this))) {
     LoggerE("storage change callback register error!");
   }
 }
@@ -847,7 +848,7 @@ PlatformResult ShortMsgManager::getMessage(int msg_id, msg_struct_t* out_msg) {
 
 PlatformResult ShortMsgManager::getConversationsForMessages(
     MessagePtrVector messages, msg_storage_change_type_t storageChangeType,
-    ConversationPtrVector* result) {
+    ConversationPtrVector* result, ShortMsgManager* shortMsgManager) {
   ScopeLogger("messages.size()=%d storageChangeType=%d", messages.size(), storageChangeType);
 
   std::unordered_set<int> unique_conv_ids;
@@ -864,7 +865,7 @@ PlatformResult ShortMsgManager::getConversationsForMessages(
       unique_conv_ids.insert(conv_id);
       ConversationPtr conv;
       PlatformResult ret = MessageConversation::convertMsgConversationToObject(
-          conv_id, ShortMsgManager::getInstance().m_msg_handle, &conv);
+          conv_id, shortMsgManager->m_msg_handle, &conv);
       if (ret.IsError()) {
         LoggerD("Convert msg conversation to object failed (%s)", ret.message().c_str());
         return ret;

diff --git a/src/messaging/short_message_manager.h b/src/messaging/short_message_manager.h
index 3af61424136c7d0e83f5249a9f149fe01611c38a..6bfe440a854fd5e8b95a1a68b4e1c17afacc7479 100644 (file)
--- a/src/messaging/short_message_manager.h
+++ b/src/messaging/short_message_manager.h
@@ -40,7 +40,8 @@ class FindMsgCallbackUserData;
 
 class ShortMsgManager {
  public:
-  static ShortMsgManager& getInstance();
+  ShortMsgManager();
+  virtual ~ShortMsgManager();
 
   common::PlatformResult sendMessage(MessageRecipientsCallbackData* callback);
   void sendStatusCallback(msg_struct_t sent_status);
@@ -58,11 +59,6 @@ class ShortMsgManager {
   std::string getMessageStatus(int id);
 
  private:
-  ShortMsgManager();
-  ShortMsgManager(const ShortMsgManager&);
-  void operator=(const ShortMsgManager&);
-  virtual ~ShortMsgManager();
-
   /**
    * Listener for msg storage changes. Calls callbacks from ChangeListenerContainer.
    * @param handle
@@ -87,9 +83,10 @@ class ShortMsgManager {
    */
   static common::PlatformResult getConversationsForMessages(
       MessagePtrVector messages, msg_storage_change_type_t storageChangeType,
-      ConversationPtrVector* result);
-  static common::PlatformResult callProperEventMessages(
-      EventMessages* event, msg_storage_change_type_t storageChangeType);
+      ConversationPtrVector* result, ShortMsgManager* shortMsgManager);
+  static common::PlatformResult callProperEventMessages(EventMessages* event,
+                                                        msg_storage_change_type_t storageChangeType,
+                                                        ShortMsgManager* shortMsgManager);
   typedef std::map<msg_request_id_t, MessageRecipientsCallbackData*> SendReqMap;
   SendReqMap m_sendRequests;
   msg_handle_t m_msg_handle;