[MediaController] Add guards to map of playlists' handles

Previously only mc_server handle were guarded by mutexes.
Playlist also needs one.

[Verification] Tested on TM1, tct-mediacontroller pass 100% x 10, no issue occurred.

Change-Id: I155cc4f2dd87d4b1237537532105b7c251689279
Signed-off-by: Rafal Walczyna <r.walczyna@samsung.com>

diff --git a/src/mediacontroller/mediacontroller_instance.cc b/src/mediacontroller/mediacontroller_instance.cc
index 2c8c095..b9d6b07 100644 (file)
--- a/src/mediacontroller/mediacontroller_instance.cc
+++ b/src/mediacontroller/mediacontroller_instance.cc
@@ -179,6 +179,7 @@ MediaControllerInstance::MediaControllerInstance() {
 
 MediaControllerInstance::~MediaControllerInstance() {
   ScopeLogger();
+  std::lock_guard<std::mutex> lock(playlist_map_mutex_);
   for (auto const& s : server_playlist_map_) {
     for (auto const& v : s.second) {
       if (MEDIA_CONTROLLER_ERROR_NONE != mc_playlist_destroy(v.second)) {
@@ -608,6 +609,8 @@ void MediaControllerInstance::MediaControllerServerCreatePlaylist(const picojson
   std::string serverName = common::CurrentApplication::GetInstance().GetApplicationId();
   auto playlistName = args.get(kPlaylistName).get<std::string>();
   PlatformResult result = PlatformResult(ErrorCode::NO_ERROR);
+  std::lock_guard<std::mutex> lock(playlist_map_mutex_);
+
   if (server_playlist_map_.find(serverName) != server_playlist_map_.end() &&
       server_playlist_map_[serverName].find(playlistName) !=
           server_playlist_map_[serverName].end()) {
@@ -651,18 +654,20 @@ void MediaControllerInstance::MediaControllerServerSavePlaylist(const picojson::
 
     PlatformResult result = PlatformResult(ErrorCode::NO_ERROR);
 
-    if (server_playlist_map_.find(serverName) == server_playlist_map_.end() ||
-        server_playlist_map_[serverName].find(name) == server_playlist_map_[serverName].end()) {
-      result = LogAndCreateResult(ErrorCode::INVALID_VALUES_ERR,
-                                  "Playlist with given name doesn't exist");
-      LogAndReportError(result, &response_obj,
-                        ("Failed: MediaControllerInstance::MediaControllerServerSavePlaylist"));
-      Instance::PostMessage(this, response.serialize().c_str());
-      return;
-    }
-
-    result = server_->SavePlaylist(server_playlist_map_[serverName][name]);
+    {
+      std::lock_guard<std::mutex> lock(playlist_map_mutex_);
+      if (server_playlist_map_.find(serverName) == server_playlist_map_.end() ||
+          server_playlist_map_[serverName].find(name) == server_playlist_map_[serverName].end()) {
+        result = LogAndCreateResult(ErrorCode::INVALID_VALUES_ERR,
+                                    "Playlist with given name doesn't exist");
+        LogAndReportError(result, &response_obj,
+                          ("Failed: MediaControllerInstance::MediaControllerServerSavePlaylist"));
+        Instance::PostMessage(this, response.serialize().c_str());
+        return;
+      }
 
+      result = server_->SavePlaylist(server_playlist_map_[serverName][name]);
+    }
     if (result) {
       ReportSuccess(response_obj);
     } else {
@@ -699,28 +704,33 @@ void MediaControllerInstance::MediaControllerServerDeletePlaylist(const picojson
 
     PlatformResult result = PlatformResult(ErrorCode::NO_ERROR);
 
-    if (server_playlist_map_.find(serverName) == server_playlist_map_.end() ||
-        server_playlist_map_[serverName].find(name) == server_playlist_map_[serverName].end()) {
-      result = LogAndCreateResult(ErrorCode::INVALID_VALUES_ERR,
-                                  "Playlist with given name doesn't exist");
-      LogAndReportError(result, &response_obj,
-                        ("Failed: MediaControllerInstance::MediaControllerServerDeletePlaylist"));
-      Instance::PostMessage(this, response.serialize().c_str());
-      return;
-    }
-    result = server_->DeletePlaylist(server_playlist_map_[serverName][name]);
+    {
+      std::lock_guard<std::mutex> lock(playlist_map_mutex_);
+
+      if (server_playlist_map_.find(serverName) == server_playlist_map_.end() ||
+          server_playlist_map_[serverName].find(name) == server_playlist_map_[serverName].end()) {
+        result = LogAndCreateResult(ErrorCode::INVALID_VALUES_ERR,
+                                    "Playlist with given name doesn't exist");
+        LogAndReportError(result, &response_obj,
+                          ("Failed: MediaControllerInstance::MediaControllerServerDeletePlaylist"));
+        Instance::PostMessage(this, response.serialize().c_str());
+        return;
+      }
+      result = server_->DeletePlaylist(server_playlist_map_[serverName][name]);
 
-    if (result) {
-      ReportSuccess(response_obj);
-    } else {
-      LogAndReportError(result, &response_obj, ("Failed: server_->DeletePlaylist"));
-    }
+      if (result) {
+        ReportSuccess(response_obj);
+      } else {
+        LogAndReportError(result, &response_obj, ("Failed: server_->DeletePlaylist"));
+      }
 
-    if (MEDIA_CONTROLLER_ERROR_NONE != mc_playlist_destroy(server_playlist_map_[serverName][name])) {
-      LoggerE("Unable to destroy playlist %s", name.c_str());
-    }
+      if (MEDIA_CONTROLLER_ERROR_NONE !=
+          mc_playlist_destroy(server_playlist_map_[serverName][name])) {
+        LoggerE("Unable to destroy playlist %s", name.c_str());
+      }
 
-    server_playlist_map_[serverName].erase(name);
+      server_playlist_map_[serverName].erase(name);
+    }
 
     Instance::PostMessage(this, response.serialize().c_str());
   };
@@ -784,10 +794,14 @@ void MediaControllerInstance::MediaControllerServerGetAllPlaylists(const picojso
       return;
     }
     // update the list of stored handles
-    utils::UpdatePlaylistHandleMap(app_id, new_playlists_map, server_playlist_map_);
-    picojson::value playlists = utils::CreatePlaylistsJSON(app_id, new_playlists_map);
+    {
+      std::lock_guard<std::mutex> lock(playlist_map_mutex_);
+
+      utils::UpdatePlaylistHandleMap(app_id, new_playlists_map, server_playlist_map_);
+      picojson::value playlists = utils::CreatePlaylistsJSON(app_id, new_playlists_map);
 
-    response_obj[kResult] = picojson::value{playlists};
+      response_obj[kResult] = picojson::value{playlists};
+    }
     ReportSuccess(response_obj);
     Instance::PostMessage(this, response.serialize().c_str());
   };
@@ -1701,10 +1715,13 @@ void MediaControllerInstance::MediaControllerServerInfoGetAllPlaylists(const pic
       return;
     }
     // update the list of stored handles
-    utils::UpdatePlaylistHandleMap(serverName, new_playlists_map, server_playlist_map_);
-    picojson::value playlists = utils::CreatePlaylistsJSON(serverName, new_playlists_map);
+    {
+      std::lock_guard<std::mutex> lock(playlist_map_mutex_);
+      utils::UpdatePlaylistHandleMap(serverName, new_playlists_map, server_playlist_map_);
+      picojson::value playlists = utils::CreatePlaylistsJSON(serverName, new_playlists_map);
 
-    response_obj[kResult] = picojson::value{playlists};
+      response_obj[kResult] = picojson::value{playlists};
+    }
     ReportSuccess(response_obj);
     Instance::PostMessage(this, response.serialize().c_str());
   };
@@ -2057,6 +2074,7 @@ void MediaControllerInstance::MediaControllerPlaylistAddItem(const picojson::val
   }
 
   PlatformResult result = PlatformResult(ErrorCode::NO_ERROR);
+  std::lock_guard<std::mutex> lock(playlist_map_mutex_);
 
   if (server_playlist_map_.find(serverName) == server_playlist_map_.end() ||
       server_playlist_map_[serverName].find(name) == server_playlist_map_[serverName].end()) {
@@ -2095,18 +2113,22 @@ void MediaControllerInstance::MediaControllerPlaylistGetItems(const picojson::va
     auto serverName = args.get(kServerName).get<std::string>();
 
     PlatformResult result = PlatformResult(ErrorCode::NO_ERROR);
+    {
+      std::lock_guard<std::mutex> lock(playlist_map_mutex_);
+
+      if (server_playlist_map_.find(serverName) == server_playlist_map_.end() ||
+          server_playlist_map_[serverName].find(name) == server_playlist_map_[serverName].end()) {
+        result =
+            LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Playlist with given name doesn't exist");
+        LogAndReportError(result, &response_obj,
+                          ("Failed: MediaControllerInstance::MediaControllerPlaylistGetItems"));
+        Instance::PostMessage(this, response.serialize().c_str());
+        return;
+      }
 
-    if (server_playlist_map_.find(serverName) == server_playlist_map_.end() ||
-        server_playlist_map_[serverName].find(name) == server_playlist_map_[serverName].end()) {
-      result = LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Playlist with given name doesn't exist");
-      LogAndReportError(result, &response_obj,
-                        ("Failed: MediaControllerInstance::MediaControllerPlaylistGetItems"));
-      Instance::PostMessage(this, response.serialize().c_str());
-      return;
+      result = utils::MediaControllerPlaylistGetItems(server_playlist_map_[serverName][name],
+                                                      &items.get<picojson::array>());
     }
-
-    result = utils::MediaControllerPlaylistGetItems(server_playlist_map_[serverName][name],
-                                                    &items.get<picojson::array>());
     if (!result) {
       LogAndReportError(result, &response_obj, ("Failed: utils::MediaControllerPlaylistGetItems"));
       Instance::PostMessage(this, response.serialize().c_str());
@@ -2138,11 +2160,11 @@ void MediaControllerInstance::MediaControllerPlaylistsGetPlaylist(const picojson
   picojson::value playlist_info = picojson::value(picojson::object());
   picojson::object& playlist_obj = playlist_info.get<picojson::object>();
 
+  std::lock_guard<std::mutex> lock(playlist_map_mutex_);
   mc_playlist_h handle = nullptr;
   if (server_playlist_map_.find(app_id) != server_playlist_map_.end() &&
-      server_playlist_map_[app_id].find(playlist_name) !=
-          server_playlist_map_[app_id].end()) {
-            LoggerD("Using saved handle");
+      server_playlist_map_[app_id].find(playlist_name) != server_playlist_map_[app_id].end()) {
+    LoggerD("Using saved handle");
     handle = server_playlist_map_[app_id][playlist_name];
   }
 

diff --git a/src/mediacontroller/mediacontroller_instance.h b/src/mediacontroller/mediacontroller_instance.h
index d41ae51..d0c2845 100644 (file)
--- a/src/mediacontroller/mediacontroller_instance.h
+++ b/src/mediacontroller/mediacontroller_instance.h
@@ -18,6 +18,7 @@
 #define MEDIACONTROLLER_MEDIACONTROLLER_INSTANCE_H_
 
 #include <memory>
+#include <mutex>
 
 #include "common/extension.h"
 #include "mediacontroller/mediacontroller_client.h"
@@ -207,6 +208,9 @@ class MediaControllerInstance : public common::ParsedInstance {
   std::shared_ptr<MediaControllerClient> client_;
   std::shared_ptr<MediaControllerServer> server_;
   std::map<std::string, PlaylistHandleMap> server_playlist_map_;
+  // This mutex is used to guard playlist usage by server_
+  // Some of the calls are async, so it needs to be guarded
+  std::mutex playlist_map_mutex_;
 };
 
 }  // namespace mediacontroller

diff --git a/src/mediacontroller/mediacontroller_server.cc b/src/mediacontroller/mediacontroller_server.cc
index 89f3c33..87c6bb7 100644 (file)
--- a/src/mediacontroller/mediacontroller_server.cc
+++ b/src/mediacontroller/mediacontroller_server.cc
@@ -88,24 +88,22 @@ MediaControllerServer::~MediaControllerServer() {
     LoggerE("Failed to unset display rotation listener");
   }
 
+  std::lock_guard<std::mutex> lock(handle_mutex_);
   int ret = mc_server_unset_event_reply_received_cb(handle_);
   if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
     LoggerE("Failed to unset event reply received callback");
   }
 
-  {
-    std::lock_guard<std::mutex> lock(handle_mutex_);
-
-    if (nullptr != handle_ && MEDIA_CONTROLLER_ERROR_NONE != mc_server_destroy(handle_)) {
-      LoggerE("Unable to destroy media controller server");
-    }
-    handle_ = nullptr;
+  if (nullptr != handle_ && MEDIA_CONTROLLER_ERROR_NONE != mc_server_destroy(handle_)) {
+    LoggerE("Unable to destroy media controller server");
   }
+  handle_ = nullptr;
 }
 
 PlatformResult MediaControllerServer::Init() {
   ScopeLogger();
 
+  std::lock_guard<std::mutex> lock(handle_mutex_);
   int ret = mc_server_create(&handle_);
   if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
     return LogAndCreateResult(
@@ -138,6 +136,7 @@ PlatformResult MediaControllerServer::SetPlaybackState(const std::string& state)
     return PlatformResult(ErrorCode::NO_ERROR);
   }
 
+  std::lock_guard<std::mutex> lock(handle_mutex_);
   int ret = mc_server_set_playback_state(handle_, state_e);
   if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
     return LogAndCreateResult(
@@ -165,6 +164,7 @@ PlatformResult MediaControllerServer::SetPlaybackPosition(double position) {
     return PlatformResult(ErrorCode::NO_ERROR);
   }
 
+  std::lock_guard<std::mutex> lock(handle_mutex_);
   int ret = mc_server_set_playback_position(handle_, static_cast<unsigned long long>(position));
   if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
     return LogAndCreateResult(
@@ -193,6 +193,7 @@ PlatformResult MediaControllerServer::SetContentAgeRating(const std::string& rat
     return result;
   }
 
+  std::lock_guard<std::mutex> lock(handle_mutex_);
   int ret = mc_server_set_content_age_rating(handle_, rating_e);
   if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
     return LogAndCreateResult(
@@ -224,6 +225,7 @@ PlatformResult MediaControllerServer::SetContentType(const std::string& content_
         ("MediaControllerContentTypeEnum.getValue() error message: %s", result.message().c_str()));
   }
 
+  std::lock_guard<std::mutex> lock(handle_mutex_);
   int ret = mc_server_set_playback_content_type(handle_, content_type_e);
   if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
     return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Error updating playback content type",
@@ -252,6 +254,7 @@ PlatformResult MediaControllerServer::SetShuffleMode(bool mode) {
     return PlatformResult(ErrorCode::NO_ERROR);
   }
 
+  std::lock_guard<std::mutex> lock(handle_mutex_);
   int ret = mc_server_update_shuffle_mode(handle_, shuffle_mode);
   if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
     return LogAndCreateResult(
@@ -274,6 +277,7 @@ PlatformResult MediaControllerServer::SetRepeatMode(bool mode) {
     return PlatformResult(ErrorCode::NO_ERROR);
   }
 
+  std::lock_guard<std::mutex> lock(handle_mutex_);
   int ret = mc_server_update_repeat_mode(handle_, repeat_mode);
   if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
     return LogAndCreateResult(
@@ -301,6 +305,7 @@ PlatformResult MediaControllerServer::SetRepeatState(const std::string& state) {
     return PlatformResult(ErrorCode::NO_ERROR);
   }
 
+  std::lock_guard<std::mutex> lock(handle_mutex_);
   int ret = mc_server_update_repeat_mode(handle_, mode_e);
   if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
     return LogAndCreateResult(
@@ -330,6 +335,7 @@ PlatformResult MediaControllerServer::SetMetadata(const picojson::object& metada
       return result;
     }
 
+    std::lock_guard<std::mutex> lock(handle_mutex_);
     int ret = mc_server_set_metadata(handle_, attr_e, i->second.to_str().c_str());
     if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
       return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Error setting metadata",
@@ -457,6 +463,7 @@ PlatformResult MediaControllerServer::CommandReply(const std::string& client_nam
     return result;
   }
 
+  std::lock_guard<std::mutex> lock(handle_mutex_);
   int ret =
       mc_server_send_cmd_reply(handle_, client_name.c_str(), request_id.c_str(), code, bundle);
   if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
@@ -471,6 +478,7 @@ PlatformResult MediaControllerServer::CommandReply(const std::string& client_nam
 PlatformResult MediaControllerServer::SetSearchRequestListener(const JsonCallback& callback) {
   ScopeLogger();
 
+  std::lock_guard<std::mutex> lock(handle_mutex_);
   int ret = mc_server_set_search_cmd_received_cb(handle_, OnSearchRequestReceived, this);
   if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
     return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Unable to set search request callback.",
@@ -484,6 +492,7 @@ PlatformResult MediaControllerServer::SetSearchRequestListener(const JsonCallbac
 
 PlatformResult MediaControllerServer::UnsetSearchRequestListener() {
   ScopeLogger();
+  std::lock_guard<std::mutex> lock(handle_mutex_);
   int ret = mc_server_unset_search_cmd_received_cb(handle_);
   if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
     return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Unable to unset search request callback.",
@@ -497,6 +506,7 @@ PlatformResult MediaControllerServer::UnsetSearchRequestListener() {
 PlatformResult MediaControllerServer::SetCommandListener(const JsonCallback& callback) {
   ScopeLogger();
 
+  std::lock_guard<std::mutex> lock(handle_mutex_);
   int ret = mc_server_set_custom_cmd_received_cb(handle_, OnCommandReceived, this);
   if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
     return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Unable to set command callback",
@@ -511,6 +521,7 @@ PlatformResult MediaControllerServer::SetCommandListener(const JsonCallback& cal
 PlatformResult MediaControllerServer::UnsetCommandListener() {
   ScopeLogger();
 
+  std::lock_guard<std::mutex> lock(handle_mutex_);
   int ret = mc_server_unset_custom_cmd_received_cb(handle_);
   if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
     return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Unable to unset command callback",
@@ -530,6 +541,7 @@ PlatformResult MediaControllerServer::CreatePlaylist(const std::string& serverNa
 
   mc_playlist_h playlist_handle_ = nullptr;
 
+  std::lock_guard<std::mutex> lock(handle_mutex_);
   int ret = mc_server_create_playlist(handle_, name.c_str(), &playlist_handle_);
 
   if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
@@ -587,6 +599,7 @@ PlatformResult MediaControllerServer::UpdatePlaybackItem(const std::string& play
                                                          const std::string& index) {
   ScopeLogger();
 
+  std::lock_guard<std::mutex> lock(handle_mutex_);
   int ret = mc_server_set_playlist_item_info(handle_, playlist_name.c_str(), index.c_str());
 
   if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
@@ -607,6 +620,7 @@ PlatformResult MediaControllerServer::UpdatePlaybackItem(const std::string& play
 
 common::PlatformResult MediaControllerServer::UpdateIconURI(const char* icon_uri) {
   ScopeLogger();
+  std::lock_guard<std::mutex> lock(handle_mutex_);
   int ret = mc_server_set_icon(handle_, icon_uri);
   if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
     return LogAndCreateResult(
@@ -631,6 +645,7 @@ PlatformResult MediaControllerServer::MediaControllerPlaylistAddItem(
     std::string value = encoded[v.first].get<std::string>();
     LoggerD("Key: %s - Value: %s", v.first.c_str(), value.c_str());
 
+    std::lock_guard<std::mutex> lock(handle_mutex_);
     int ret = mc_server_add_item_to_playlist(handle_, playlist_handle, index.c_str(), v.second,
                                              value.c_str());
     if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
@@ -676,6 +691,7 @@ PlatformResult MediaControllerServer::SetPlaybackAbility(const std::string& acti
     }
   }
 
+  std::lock_guard<std::mutex> lock(handle_mutex_);
   int ret = mc_server_set_playback_ability(handle_, action_e, support);
   if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
     return LogAndCreateResult(
@@ -703,6 +719,7 @@ PlatformResult MediaControllerServer::SavePlaybackAbilities(const picojson::valu
   }
 
   if (is_changed) {
+    std::lock_guard<std::mutex> lock(handle_mutex_);
     int ret = mc_server_update_playback_ability(handle_);
     if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
       return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Error updating playback ability",
@@ -733,6 +750,7 @@ PlatformResult MediaControllerServer::SetDisplayModeAbility(const std::string& m
                                result.message().c_str()));
   }
 
+  std::lock_guard<std::mutex> lock(handle_mutex_);
   int ret = mc_server_set_display_mode_ability(handle_, mode_e, support_e);
   if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
     return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Error setting playback ability",
@@ -763,6 +781,7 @@ PlatformResult MediaControllerServer::SetDisplayRotationAbility(
                                result.message().c_str()));
   }
 
+  std::lock_guard<std::mutex> lock(handle_mutex_);
   int ret = mc_server_set_display_rotation_ability(handle_, display_rotation_e, support_e);
   if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
     return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Error setting ability",
@@ -801,6 +820,7 @@ PlatformResult MediaControllerServer::SetSimpleAbility(const std::string& abilit
                                result.message().c_str()));
   }
 
+  std::lock_guard<std::mutex> lock(handle_mutex_);
   int ret = mc_server_set_ability_support(handle_, ability_e, support_e);
   if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
     return LogAndCreateResult(
@@ -829,6 +849,7 @@ PlatformResult MediaControllerServer::SetChangeRequestPlaybackInfoListener(
         /*mc_server_unset_playlist_cmd_received_cb the last unsetter will never be used*/};
 
     // This loop is no-op in case of success.
+    std::lock_guard<std::mutex> lock(handle_mutex_);
     for (int i = 0; i < failed_setter; ++i) {
       auto ret = unsetters[i](handle_);
       if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
@@ -837,6 +858,7 @@ PlatformResult MediaControllerServer::SetChangeRequestPlaybackInfoListener(
     }
   };
 
+  std::lock_guard<std::mutex> lock(handle_mutex_);
   // In Native API, since Tizen 5.0 an action instead of a state is sent to change the state of a
   // server. In Web API the names were not refactored.
   int ret = mc_server_set_playback_action_cmd_received_cb(handle_, OnPlaybackActionCommand, this);
@@ -890,6 +912,7 @@ PlatformResult MediaControllerServer::SetChangeRequestPlaybackInfoListener(
 PlatformResult MediaControllerServer::UnsetChangeRequestPlaybackInfoListener() {
   ScopeLogger();
 
+  std::lock_guard<std::mutex> lock(handle_mutex_);
   int ret = mc_server_unset_playback_action_cmd_received_cb(handle_);
   if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
     return LogAndCreateResult(
@@ -1089,6 +1112,7 @@ void MediaControllerServer::OnPlaybackItemCommand(const char* client_name, const
 // subtitles
 common::PlatformResult MediaControllerServer::UpdateSubtitlesEnabled(bool enabled) {
   ScopeLogger();
+  std::lock_guard<std::mutex> lock(handle_mutex_);
   int ret = mc_server_update_subtitles_enabled(handle_, enabled);
   if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
     return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Error setting server subtitles",
@@ -1119,6 +1143,7 @@ PlatformResult MediaControllerServer::SetSubtitlesChangeRequestListener(
     const JsonCallback& callback) {
   ScopeLogger();
 
+  std::lock_guard<std::mutex> lock(handle_mutex_);
   int ret = mc_server_set_subtitles_cmd_received_cb(handle_, OnSubtitlesChangeCommand, this);
   if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
     return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Unable to set subtitles command listener",
@@ -1134,6 +1159,7 @@ PlatformResult MediaControllerServer::SetSubtitlesChangeRequestListener(
 PlatformResult MediaControllerServer::UnsetSubtitlesChangeRequestListener() {
   ScopeLogger();
 
+  std::lock_guard<std::mutex> lock(handle_mutex_);
   int ret = mc_server_unset_subtitles_cmd_received_cb(handle_);
   if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
     return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Unable to unset subtitles command listener",
@@ -1148,6 +1174,7 @@ PlatformResult MediaControllerServer::UnsetSubtitlesChangeRequestListener() {
 // mode360
 common::PlatformResult MediaControllerServer::UpdateMode360Enabled(bool enabled) {
   ScopeLogger();
+  std::lock_guard<std::mutex> lock(handle_mutex_);
   int ret = mc_server_update_360_mode_enabled(handle_, enabled);
   if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
     return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Error setting server mode 360",
@@ -1177,6 +1204,7 @@ PlatformResult MediaControllerServer::SetMode360ChangeRequestListener(
     const JsonCallback& callback) {
   ScopeLogger();
 
+  std::lock_guard<std::mutex> lock(handle_mutex_);
   int ret = mc_server_set_360_mode_cmd_received_cb(handle_, OnMode360ChangeCommand, this);
   if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
     return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Unable to set mode 360 command listener",
@@ -1192,6 +1220,7 @@ PlatformResult MediaControllerServer::SetMode360ChangeRequestListener(
 PlatformResult MediaControllerServer::UnsetMode360ChangeRequestListener() {
   ScopeLogger();
 
+  std::lock_guard<std::mutex> lock(handle_mutex_);
   int ret = mc_server_unset_360_mode_cmd_received_cb(handle_);
   if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
     return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Unable to unset mode 360 command listener",
@@ -1214,6 +1243,7 @@ common::PlatformResult MediaControllerServer::UpdateDisplayModeType(const std::s
     return result;
   }
 
+  std::lock_guard<std::mutex> lock(handle_mutex_);
   int ret = mc_server_update_display_mode(handle_, mode);
   if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
     return LogAndCreateResult(
@@ -1252,6 +1282,7 @@ PlatformResult MediaControllerServer::SetDisplayModeChangeRequestListener(
     const JsonCallback& callback) {
   ScopeLogger();
 
+  std::lock_guard<std::mutex> lock(handle_mutex_);
   int ret = mc_server_set_display_mode_cmd_received_cb(handle_, OnDisplayModeChangeCommand, this);
   if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
     return LogAndCreateResult(
@@ -1268,6 +1299,7 @@ PlatformResult MediaControllerServer::SetDisplayModeChangeRequestListener(
 PlatformResult MediaControllerServer::UnsetDisplayModeChangeRequestListener() {
   ScopeLogger();
 
+  std::lock_guard<std::mutex> lock(handle_mutex_);
   int ret = mc_server_unset_display_mode_cmd_received_cb(handle_);
   if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
     return LogAndCreateResult(
@@ -1292,6 +1324,7 @@ PlatformResult MediaControllerServer::UpdateDisplayRotation(const std::string& d
     return PlatformResult(ErrorCode::UNKNOWN_ERR);
   }
 
+  std::lock_guard<std::mutex> lock(handle_mutex_);
   int ret = mc_server_update_display_rotation(handle_, rotation);
   if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
     return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Error setting server display rotation",
@@ -1331,6 +1364,7 @@ PlatformResult MediaControllerServer::SetDisplayRotationChangeRequestListener(
     const JsonCallback& callback) {
   ScopeLogger();
 
+  std::lock_guard<std::mutex> lock(handle_mutex_);
   int ret =
       mc_server_set_display_rotation_cmd_received_cb(handle_, OnDisplayRotationChangeCommand, this);
   if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
@@ -1348,6 +1382,7 @@ PlatformResult MediaControllerServer::SetDisplayRotationChangeRequestListener(
 PlatformResult MediaControllerServer::UnsetDisplayRotationChangeRequestListener() {
   ScopeLogger();
 
+  std::lock_guard<std::mutex> lock(handle_mutex_);
   int ret = mc_server_unset_display_rotation_cmd_received_cb(handle_);
   if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
     return LogAndCreateResult(
@@ -1370,6 +1405,7 @@ PlatformResult MediaControllerServer::GetAllClientsInfo(picojson::array* clients
     return true;
   };
 
+  std::lock_guard<std::mutex> lock(handle_mutex_);
   int ret = mc_server_foreach_client(handle_, client_cb, clients_info);
   if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
     return LogAndCreateResult(
@@ -1406,6 +1442,7 @@ PlatformResult MediaControllerServer::SendEvent(const char* event_name,
     LoggerD("data is null");
   }
 
+  std::lock_guard<std::mutex> lock(handle_mutex_);
   int ret =
       mc_server_send_custom_event(handle_, client_name, event_name, event_data_bundle, request_id);
   if (MEDIA_CONTROLLER_ERROR_NONE != ret) {

diff --git a/src/mediacontroller/mediacontroller_server.h b/src/mediacontroller/mediacontroller_server.h
index 83ee086..77edd4f 100644 (file)
--- a/src/mediacontroller/mediacontroller_server.h
+++ b/src/mediacontroller/mediacontroller_server.h
@@ -101,9 +101,6 @@ class MediaControllerServer {
  private:
   mc_server_h handle_;
 
-  // This mutex is used to guard handle_ usage in TaskQueue
-  // and its destruction, but there is no need to
-  // guard every call on main thread.
   std::mutex handle_mutex_;
 
   JsonCallback change_request_playback_info_listener_;