[Mediacontroller] Added refreshing the list of handles

[Bug] If native application (e.g. service) adds the playlist,
web api is able to gather it, but cannot perform any actions on it,
because web API stores only handles to playlists created by itself.

[Solution] Added functionality of refreshing handles always when gathering
a playlists handles using native API

[Verification] Code compiles without errors.

Change-Id: I9bb757f50c3bc4167b0a97c923d49a1ccbbe0195

diff --git a/src/mediacontroller/mediacontroller_api.js b/src/mediacontroller/mediacontroller_api.js
index a033c540026aacc25f7b10c45b03e592a1baeff5..41ab05153e209dd14d7c05f546298ccf4de6cac1 100755 (executable)
--- a/src/mediacontroller/mediacontroller_api.js
+++ b/src/mediacontroller/mediacontroller_api.js
@@ -2634,7 +2634,8 @@ var savePlaylist = function() {
     ]);
 
     var data = {
-        playlistName: args.playlist.name
+        playlistName: args.playlist.name,
+        serverName: args.playlist._serverName
     };
 
     var callback = function(result) {
@@ -3937,6 +3938,11 @@ function MediaControllerPlaylist(data) {
                 _name = edit_.isAllowed && v ? v : _name;
             },
             enumerable: true
+        },
+        _serverName: {
+            value: data.serverName,
+            writable: false,
+            enumerable: false
         }
     });
     edit_.allow();
@@ -3981,7 +3987,8 @@ MediaControllerPlaylist.prototype.getItems = function() {
     ]);
 
     var data = {
-        name: this.name
+        name: this.name,
+        serverName: this._serverName
     };
 
     var callback = function(result) {

diff --git a/src/mediacontroller/mediacontroller_instance.cc b/src/mediacontroller/mediacontroller_instance.cc
index b7bc412ed7686301397e74bfbe9e029fa091771b..2c8c09520e2a86910ede904267e4d2cb50a53d53 100644 (file)
--- a/src/mediacontroller/mediacontroller_instance.cc
+++ b/src/mediacontroller/mediacontroller_instance.cc
@@ -179,6 +179,13 @@ MediaControllerInstance::MediaControllerInstance() {
 
 MediaControllerInstance::~MediaControllerInstance() {
   ScopeLogger();
+  for (auto const& s : server_playlist_map_) {
+    for (auto const& v : s.second) {
+      if (MEDIA_CONTROLLER_ERROR_NONE != mc_playlist_destroy(v.second)) {
+        LoggerE("Unable to destroy playlist %s", v.first.c_str());
+      }
+    }
+  }
 }
 
 #define CHECK_EXIST(args, name, out)                                            \
@@ -598,13 +605,26 @@ void MediaControllerInstance::MediaControllerServerCreatePlaylist(const picojson
   CHECK_ARGS(args, kPlaylistName, std::string, out)
 
   picojson::value playlist_info = picojson::value();
-
-  auto result = server_->CreatePlaylist(args.get(kPlaylistName).get<std::string>(), &playlist_info);
+  std::string serverName = common::CurrentApplication::GetInstance().GetApplicationId();
+  auto playlistName = args.get(kPlaylistName).get<std::string>();
+  PlatformResult result = PlatformResult(ErrorCode::NO_ERROR);
+  if (server_playlist_map_.find(serverName) != server_playlist_map_.end() &&
+      server_playlist_map_[serverName].find(playlistName) !=
+          server_playlist_map_[serverName].end()) {
+    result = LogAndCreateResult(ErrorCode::INVALID_VALUES_ERR,
+                                "Playlist with given name already exists");
+    LogAndReportError(result, &out);
+    return;
+  }
+  mc_playlist_h playlist_handle = nullptr;
+  result = server_->CreatePlaylist(serverName, playlistName, &playlist_info, playlist_handle);
   if (!result) {
     LogAndReportError(result, &out, ("Failed: server_->CreatePlaylist"));
     return;
   }
 
+  server_playlist_map_[serverName][playlistName] = playlist_handle;
+
   ReportSuccess(playlist_info, out);
 }
 
@@ -619,13 +639,29 @@ void MediaControllerInstance::MediaControllerServerSavePlaylist(const picojson::
 
   CHECK_EXIST(args, kCallbackId, out)
   CHECK_ARGS(args, kPlaylistName, std::string, out)
+  CHECK_ARGS(args, kServerName, std::string, out)
 
   auto save = [this, args]() -> void {
     picojson::value response = picojson::value(picojson::object());
     picojson::object& response_obj = response.get<picojson::object>();
     response_obj[kCallbackId] = args.get(kCallbackId);
 
-    auto result = server_->SavePlaylist(args.get(kPlaylistName).get<std::string>());
+    auto name = args.get(kPlaylistName).get<std::string>();
+    auto serverName = args.get(kServerName).get<std::string>();
+
+    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]);
 
     if (result) {
       ReportSuccess(response_obj);
@@ -658,7 +694,21 @@ void MediaControllerInstance::MediaControllerServerDeletePlaylist(const picojson
     picojson::object& response_obj = response.get<picojson::object>();
     response_obj[kCallbackId] = args.get(kCallbackId);
 
-    auto result = server_->DeletePlaylist(args.get(kPlaylistName).get<std::string>());
+    auto name = args.get(kPlaylistName).get<std::string>();
+    std::string serverName = common::CurrentApplication::GetInstance().GetApplicationId();
+
+    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]);
 
     if (result) {
       ReportSuccess(response_obj);
@@ -666,6 +716,12 @@ void MediaControllerInstance::MediaControllerServerDeletePlaylist(const picojson
       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());
+    }
+
+    server_playlist_map_[serverName].erase(name);
+
     Instance::PostMessage(this, response.serialize().c_str());
   };
 
@@ -699,6 +755,11 @@ void MediaControllerInstance::MediaControllerServerUpdatePlaybackItem(const pico
 void MediaControllerInstance::MediaControllerServerGetAllPlaylists(const picojson::value& args,
                                                                    picojson::object& out) {
   ScopeLogger();
+  if (!server_) {
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerServerUnknownErrorMsg));
+    return;
+  }
 
   auto get = [this, args]() -> void {
     picojson::value response = picojson::value(picojson::object());
@@ -715,14 +776,16 @@ void MediaControllerInstance::MediaControllerServerGetAllPlaylists(const picojso
       return;
     }
 
-    picojson::value playlists{picojson::array{}};
-    auto result = utils::GetAllPlaylists(app_id, &playlists.get<picojson::array>());
-
+    std::map<std::string, mc_playlist_h> new_playlists_map;
+    auto result = utils::GetAllPlaylistsHandles(app_id, &new_playlists_map);
     if (!result) {
       LogAndReportError(result, &response_obj, ("Failed: utils::GetAllPlaylists"));
       Instance::PostMessage(this, response.serialize().c_str());
       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);
 
     response_obj[kResult] = picojson::value{playlists};
     ReportSuccess(response_obj);
@@ -1629,16 +1692,17 @@ void MediaControllerInstance::MediaControllerServerInfoGetAllPlaylists(const pic
 
     response_obj[kCallbackId] = args.get(kCallbackId);
 
-    picojson::value playlists{picojson::array{}};
-
-    auto result = utils::GetAllPlaylists(args.get(kServerName).get<std::string>(),
-                                         &playlists.get<picojson::array>());
-
+    std::map<std::string, mc_playlist_h> new_playlists_map;
+    std::string serverName = args.get(kServerName).get<std::string>();
+    auto result = utils::GetAllPlaylistsHandles(serverName, &new_playlists_map);
     if (!result) {
       LogAndReportError(result, &response_obj, ("Failed: utils::GetAllPlaylists"));
       Instance::PostMessage(this, response.serialize().c_str());
       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);
 
     response_obj[kResult] = picojson::value{playlists};
     ReportSuccess(response_obj);
@@ -1983,8 +2047,26 @@ void MediaControllerInstance::MediaControllerPlaylistAddItem(const picojson::val
 
   const picojson::object& metadata = args.get(kMetadata).get<picojson::object>();
 
-  auto result = server_->MediaControllerPlaylistAddItem(
-      args.get(kName).get<std::string>(), args.get(kIndex).get<std::string>(), metadata);
+  auto name = args.get(kName).get<std::string>();
+
+  std::string serverName = "";
+  if (args.contains(kServerName)) {
+    serverName = args.get(kServerName).get<std::string>();
+  } else {
+    serverName = common::CurrentApplication::GetInstance().GetApplicationId();
+  }
+
+  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::UNKNOWN_ERR, "Playlist with given name doesn't exist");
+    LogAndReportError(result, &out);
+    return;
+  }
+
+  result = server_->MediaControllerPlaylistAddItem(server_playlist_map_[serverName][name],
+                                                   args.get(kIndex).get<std::string>(), metadata);
   if (!result) {
     LogAndReportError(result, &out);
     return;
@@ -1997,15 +2079,9 @@ void MediaControllerInstance::MediaControllerPlaylistGetItems(const picojson::va
                                                               picojson::object& out) {
   ScopeLogger();
 
-  // MediaControllerPlaylistGetItems is implemented in MediaControllerServer because
-  // mc_playlist_foreach_item need mc_playlist_h as parameter which is already stored in server
-  if (!server_) {
-    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
-                      (MediaControllerServerUnknownErrorMsg));
-    return;
-  }
   CHECK_EXIST(args, kCallbackId, out)
   CHECK_ARGS(args, kName, std::string, out)
+  CHECK_ARGS(args, kServerName, std::string, out)
 
   auto get = [this, args]() -> void {
     picojson::value response = picojson::value(picojson::object());
@@ -2015,12 +2091,24 @@ void MediaControllerInstance::MediaControllerPlaylistGetItems(const picojson::va
 
     picojson::value items{picojson::array{}};
 
-    auto result = server_->MediaControllerPlaylistGetItems(args.get(kName).get<std::string>(),
-                                                           &items.get<picojson::array>());
+    auto name = args.get(kName).get<std::string>();
+    auto serverName = args.get(kServerName).get<std::string>();
 
-    if (!result) {
+    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::UNKNOWN_ERR, "Playlist with given name doesn't exist");
       LogAndReportError(result, &response_obj,
-                        ("Failed: server_->MediaControllerPlaylistGetItems"));
+                        ("Failed: MediaControllerInstance::MediaControllerPlaylistGetItems"));
+      Instance::PostMessage(this, response.serialize().c_str());
+      return;
+    }
+
+    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());
       return;
     }
@@ -2038,6 +2126,11 @@ void MediaControllerInstance::MediaControllerPlaylistGetItems(const picojson::va
 void MediaControllerInstance::MediaControllerPlaylistsGetPlaylist(const picojson::value& args,
                                                                   picojson::object& out) {
   ScopeLogger();
+  if (!server_) {
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerServerUnknownErrorMsg));
+    return;
+  }
   CHECK_ARGS(args, kPlaylistName, std::string, out);
 
   const std::string& playlist_name = args.get(kPlaylistName).get<std::string>();
@@ -2045,12 +2138,23 @@ void MediaControllerInstance::MediaControllerPlaylistsGetPlaylist(const picojson
   picojson::value playlist_info = picojson::value(picojson::object());
   picojson::object& playlist_obj = playlist_info.get<picojson::object>();
 
-  auto result = utils::GetPlaylist(app_id, playlist_name, &playlist_obj);
+  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");
+    handle = server_playlist_map_[app_id][playlist_name];
+  }
+
+  auto result = utils::GetPlaylist(app_id, playlist_name, &playlist_obj, &handle);
   if (!result) {
     LogAndReportError(result, &out, ("Failed: utils::GetPlaylist"));
     return;
   }
 
+  // update the list of stored handles
+  server_playlist_map_[app_id][playlist_name] = handle;
+
   ReportSuccess(playlist_info, out);
 }
 

diff --git a/src/mediacontroller/mediacontroller_instance.h b/src/mediacontroller/mediacontroller_instance.h
index d21c7431f590fa9a45fe1e157d4f8340f7d816ee..d41ae51d5c05812641ea5190cf05ca80911b915d 100644 (file)
--- a/src/mediacontroller/mediacontroller_instance.h
+++ b/src/mediacontroller/mediacontroller_instance.h
@@ -206,6 +206,7 @@ class MediaControllerInstance : public common::ParsedInstance {
 
   std::shared_ptr<MediaControllerClient> client_;
   std::shared_ptr<MediaControllerServer> server_;
+  std::map<std::string, PlaylistHandleMap> server_playlist_map_;
 };
 
 }  // namespace mediacontroller

diff --git a/src/mediacontroller/mediacontroller_server.cc b/src/mediacontroller/mediacontroller_server.cc
index 82da535fd0f438d164cfdd7b4b8135f6d9d9dc77..89f3c33ba096682379cf86fedd721460f52d79d1 100644 (file)
--- a/src/mediacontroller/mediacontroller_server.cc
+++ b/src/mediacontroller/mediacontroller_server.cc
@@ -93,14 +93,9 @@ MediaControllerServer::~MediaControllerServer() {
     LoggerE("Failed to unset event reply received callback");
   }
 
-  for (auto const& v : playlist_handle_map_) {
-    if (MEDIA_CONTROLLER_ERROR_NONE != mc_playlist_destroy(v.second)) {
-      LoggerE("Unable to destroy playlist %s", v.first.c_str());
-    }
-  }
-
   {
     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");
     }
@@ -527,15 +522,12 @@ PlatformResult MediaControllerServer::UnsetCommandListener() {
   return PlatformResult(ErrorCode::NO_ERROR);
 }
 
-PlatformResult MediaControllerServer::CreatePlaylist(const std::string& name,
-                                                     picojson::value* playlist_info) {
+PlatformResult MediaControllerServer::CreatePlaylist(const std::string& serverName,
+                                                     const std::string& name,
+                                                     picojson::value* playlist_info,
+                                                     mc_playlist_h& playlist_handle) {
   ScopeLogger();
 
-  if (playlist_handle_map_.find(name) != playlist_handle_map_.end()) {
-    return LogAndCreateResult(ErrorCode::INVALID_VALUES_ERR,
-                              "Playlist with given name already exists");
-  }
-
   mc_playlist_h playlist_handle_ = nullptr;
 
   int ret = mc_server_create_playlist(handle_, name.c_str(), &playlist_handle_);
@@ -546,7 +538,7 @@ PlatformResult MediaControllerServer::CreatePlaylist(const std::string& name,
         ("mc_server_create_playlist() error: %d, message: %s", ret, get_error_message(ret)));
   }
 
-  playlist_handle_map_[name] = playlist_handle_;
+  playlist_handle = playlist_handle_;
 
   if (playlist_info == nullptr) {
     return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Unable to createPlaylist",
@@ -556,20 +548,16 @@ PlatformResult MediaControllerServer::CreatePlaylist(const std::string& name,
   *playlist_info = picojson::value(picojson::object());
   picojson::object& obj = playlist_info->get<picojson::object>();
   obj[kName] = picojson::value(name);
+  obj[kServerName] = picojson::value(serverName);
 
   return PlatformResult(ErrorCode::NO_ERROR);
 }
 
-PlatformResult MediaControllerServer::SavePlaylist(const std::string& name) {
+PlatformResult MediaControllerServer::SavePlaylist(const mc_playlist_h& playlist_handle) {
   ScopeLogger();
 
-  if (playlist_handle_map_.find(name) == playlist_handle_map_.end()) {
-    return LogAndCreateResult(ErrorCode::INVALID_VALUES_ERR,
-                              "Playlist with given name doesn't exist");
-  }
-
   std::lock_guard<std::mutex> lock(handle_mutex_);
-  int ret = mc_server_update_playlist_done(handle_, playlist_handle_map_[name]);
+  int ret = mc_server_update_playlist_done(handle_, playlist_handle);
 
   if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
     return LogAndCreateResult(
@@ -580,16 +568,11 @@ PlatformResult MediaControllerServer::SavePlaylist(const std::string& name) {
   return PlatformResult(ErrorCode::NO_ERROR);
 }
 
-PlatformResult MediaControllerServer::DeletePlaylist(const std::string& name) {
+PlatformResult MediaControllerServer::DeletePlaylist(const mc_playlist_h& playlist_handle) {
   ScopeLogger();
 
-  if (playlist_handle_map_.find(name) == playlist_handle_map_.end()) {
-    return LogAndCreateResult(ErrorCode::INVALID_VALUES_ERR,
-                              "Playlist with given name doesn't exist");
-  }
-
   std::lock_guard<std::mutex> lock(handle_mutex_);
-  int ret = mc_server_delete_playlist(handle_, playlist_handle_map_[name]);
+  int ret = mc_server_delete_playlist(handle_, playlist_handle);
 
   if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
     return LogAndCreateResult(
@@ -597,8 +580,6 @@ PlatformResult MediaControllerServer::DeletePlaylist(const std::string& name) {
         ("mc_server_delete_playlist() error: %d, message: %s", ret, get_error_message(ret)));
   }
 
-  playlist_handle_map_.erase(name);
-
   return PlatformResult(ErrorCode::NO_ERROR);
 }
 
@@ -636,13 +617,10 @@ common::PlatformResult MediaControllerServer::UpdateIconURI(const char* icon_uri
 }
 
 PlatformResult MediaControllerServer::MediaControllerPlaylistAddItem(
-    const std::string& name, const std::string& index, const picojson::object& metadata) {
+    const mc_playlist_h& playlist_handle, const std::string& index,
+    const picojson::object& metadata) {
   ScopeLogger();
 
-  if (playlist_handle_map_.find(name) == playlist_handle_map_.end()) {
-    return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Playlist with given name doesn't exist");
-  }
-
   picojson::object encoded;
   PlatformResult result = utils::EncodeMetadata(metadata, &encoded);
   if (!result) {
@@ -653,8 +631,8 @@ PlatformResult MediaControllerServer::MediaControllerPlaylistAddItem(
     std::string value = encoded[v.first].get<std::string>();
     LoggerD("Key: %s - Value: %s", v.first.c_str(), value.c_str());
 
-    int ret = mc_server_add_item_to_playlist(handle_, playlist_handle_map_[name], index.c_str(),
-                                             v.second, value.c_str());
+    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) {
       return LogAndCreateResult(
           ErrorCode::UNKNOWN_ERR, "Error adding playlist item",
@@ -665,49 +643,6 @@ PlatformResult MediaControllerServer::MediaControllerPlaylistAddItem(
   return PlatformResult(ErrorCode::NO_ERROR);
 }
 
-PlatformResult MediaControllerServer::MediaControllerPlaylistGetItems(const std::string& name,
-                                                                      picojson::array* items) {
-  ScopeLogger();
-
-  if (playlist_handle_map_.find(name) == playlist_handle_map_.end()) {
-    return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Playlist with given name doesn't exist");
-  }
-
-  auto OnPlaylistItemCommand = [](const char* index, mc_metadata_h metadata,
-                                  void* user_data) -> bool {
-    ScopeLogger();
-
-    auto items = static_cast<picojson::array*>(user_data);
-
-    picojson::value metadata_v = picojson::value(picojson::object());
-    picojson::object& metadata_obj = metadata_v.get<picojson::object>();
-
-    auto result = types::ConvertMetadata(metadata, &metadata_obj);
-    if (!result) {
-      return false;
-    }
-
-    picojson::value value = picojson::value(picojson::object());
-    picojson::object& obj = value.get<picojson::object>();
-
-    obj.insert(std::make_pair(kIndex, picojson::value{index}));
-    obj.insert(std::make_pair(kMetadata, metadata_v));
-    items->push_back(value);
-
-    return true;
-  };
-
-  int ret = mc_playlist_foreach_item(playlist_handle_map_[name], OnPlaylistItemCommand, items);
-
-  if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
-    return LogAndCreateResult(
-        ErrorCode::UNKNOWN_ERR, "Error while get playlist item",
-        ("mc_playlist_foreach_item() error: %d, message: %s", ret, get_error_message(ret)));
-  }
-
-  return PlatformResult(ErrorCode::NO_ERROR);
-}
-
 PlatformResult MediaControllerServer::SetPlaybackAbility(const std::string& action,
                                                          const std::string& support_str,
                                                          bool* is_changed) {

diff --git a/src/mediacontroller/mediacontroller_server.h b/src/mediacontroller/mediacontroller_server.h
index a9af3040143d6ef2de75c00e6f3cfe8f2e8416d3..83ee0863eb82e36f1f8c5782b300e2ff4510a5a0 100644 (file)
--- a/src/mediacontroller/mediacontroller_server.h
+++ b/src/mediacontroller/mediacontroller_server.h
@@ -54,16 +54,17 @@ class MediaControllerServer {
   common::PlatformResult SetCommandListener(const JsonCallback& callback);
   common::PlatformResult UnsetCommandListener();
 
-  common::PlatformResult CreatePlaylist(const std::string& name, picojson::value* playlist_info);
-  common::PlatformResult SavePlaylist(const std::string& name);
-  common::PlatformResult DeletePlaylist(const std::string& name);
+  common::PlatformResult CreatePlaylist(const std::string& serverName, const std::string& name,
+                                        picojson::value* playlist_info,
+                                        mc_playlist_h& playlist_handle);
+  common::PlatformResult SavePlaylist(const mc_playlist_h& playlist_handle);
+  common::PlatformResult DeletePlaylist(const mc_playlist_h& playlist_handle);
   common::PlatformResult UpdatePlaybackItem(const std::string& name, const std::string& index);
 
-  common::PlatformResult MediaControllerPlaylistAddItem(const std::string& name,
+  common::PlatformResult MediaControllerPlaylistAddItem(const mc_playlist_h& playlist_handle,
                                                         const std::string& index,
                                                         const picojson::object& metadata);
-  common::PlatformResult MediaControllerPlaylistGetItems(const std::string& name,
-                                                         picojson::array* items);
+
   common::PlatformResult UpdateIconURI(const char* icon_uri);
   common::PlatformResult SetPlaybackAbility(const std::string& action,
                                             const std::string& support_str, bool* is_changed);
@@ -124,8 +125,6 @@ class MediaControllerServer {
   bool is_repeat_mode_set_;
   std::map<std::string, mc_ability_support_e> abilities_;
 
-  std::map<std::string, mc_playlist_h> playlist_handle_map_;
-
   static void OnPlaybackActionCommand(const char* client_name, const char* request_id,
                                       mc_playback_action_e action, void* user_data);
   static void OnPlaybackPositionCommand(const char* client_name, const char* request_id,

diff --git a/src/mediacontroller/mediacontroller_utils.cc b/src/mediacontroller/mediacontroller_utils.cc
index c40c41374d63fed6c1f28239eac110bfeac080e2..034920dccdbfb7d80c2172fd79077da765916590 100644 (file)
--- a/src/mediacontroller/mediacontroller_utils.cc
+++ b/src/mediacontroller/mediacontroller_utils.cc
@@ -381,8 +381,82 @@ PlatformResult utils::GetAllPlaylists(const std::string& app_id, picojson::array
   return PlatformResult(ErrorCode::NO_ERROR);
 }
 
+PlatformResult utils::GetAllPlaylistsHandles(const std::string& app_id,
+                                             std::map<std::string, mc_playlist_h>* playlists) {
+  ScopeLogger();
+
+  auto OnPlaylists = [](mc_playlist_h playlist, void* user_data) -> bool {
+    char* name = nullptr;
+
+    SCOPE_EXIT {
+      free(name);
+    };
+
+    int ret = mc_playlist_get_name(playlist, &name);
+    if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
+      return false;
+    }
+
+    auto playlists = static_cast<std::map<std::string, mc_playlist_h>*>(user_data);
+    mc_playlist_h playlist_cpy = nullptr;
+    ret = mc_playlist_clone(playlist, &playlist_cpy);
+    if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
+      return false;
+    }
+    (*playlists)[name] = playlist_cpy;
+
+    return true;
+  };
+
+  int ret = mc_playlist_foreach_playlist(app_id.c_str(), OnPlaylists, playlists);
+
+  if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
+    return LogAndCreateResult(
+        ErrorCode::UNKNOWN_ERR, "Error while get playlists",
+        ("mc_playlist_foreach_playlist() error: %d, message: %s", ret, get_error_message(ret)));
+  }
+
+  return PlatformResult(ErrorCode::NO_ERROR);
+}
+
+picojson::value utils::CreatePlaylistsJSON(const std::string& app_id,
+                                           const std::map<std::string, mc_playlist_h>& playlists) {
+  ScopeLogger();
+  picojson::value playlists_json{picojson::array{}};
+  picojson::array& playlists_array = playlists_json.get<picojson::array>();
+  for (const auto& v : playlists) {
+    picojson::value value = picojson::value(picojson::object());
+    picojson::object& obj = value.get<picojson::object>();
+    obj.insert(std::make_pair(kName, picojson::value{v.first}));
+    obj.insert(std::make_pair(kServerName, picojson::value{app_id}));
+    playlists_array.push_back(value);
+  }
+  return playlists_json;
+}
+
+void utils::UpdatePlaylistHandleMap(const std::string& serverName,
+                                    const std::map<std::string, mc_playlist_h>& to_update,
+                                    std::map<std::string, PlaylistHandleMap>& server_playlist_map) {
+  ScopeLogger();
+
+  if (server_playlist_map.find(serverName) != server_playlist_map.end()) {
+    // drop all old saved elements
+    for (auto const& v : server_playlist_map[serverName]) {
+      if (MEDIA_CONTROLLER_ERROR_NONE != mc_playlist_destroy(v.second)) {
+        LoggerW("Unable to destroy playlist %s handle", v.first.c_str());
+      }
+    }
+    server_playlist_map.erase(serverName);
+  }
+
+  // save new elements
+  for (auto const& u : to_update) {
+    server_playlist_map[serverName][u.first] = u.second;
+  }
+}
+
 PlatformResult utils::GetPlaylist(const std::string& app_id, const std::string& playlist_name,
-                                  picojson::object* playlist_obj) {
+                                  picojson::object* playlist_obj, mc_playlist_h* handle) {
   ScopeLogger();
 
   if (nullptr == playlist_obj) {
@@ -393,7 +467,9 @@ PlatformResult utils::GetPlaylist(const std::string& app_id, const std::string&
 
   mc_playlist_h playlist_item = nullptr;
   SCOPE_EXIT {
-    mc_playlist_destroy(playlist_item);
+    if (!handle) {
+      mc_playlist_destroy(playlist_item);
+    }
   };
 
   int ret = mc_playlist_get_playlist(app_id.c_str(), playlist_name.c_str(), &playlist_item);
@@ -412,6 +488,10 @@ PlatformResult utils::GetPlaylist(const std::string& app_id, const std::string&
   }
 
   (*playlist_obj)[kName] = picojson::value(playlist_name);
+  if (handle && handle != playlist_item) {
+    mc_playlist_destroy(*handle);
+    *handle = playlist_item;
+  }
 
   return PlatformResult(ErrorCode::NO_ERROR);
 }
@@ -431,6 +511,45 @@ ErrorCode utils::ConvertMediaControllerError(int e) {
   return error;
 }
 
+PlatformResult utils::MediaControllerPlaylistGetItems(const mc_playlist_h playlist_handle,
+                                                      picojson::array* items) {
+  ScopeLogger();
+
+  auto OnPlaylistItemCommand = [](const char* index, mc_metadata_h metadata,
+                                  void* user_data) -> bool {
+    ScopeLogger();
+
+    auto items = static_cast<picojson::array*>(user_data);
+
+    picojson::value metadata_v = picojson::value(picojson::object());
+    picojson::object& metadata_obj = metadata_v.get<picojson::object>();
+
+    auto result = types::ConvertMetadata(metadata, &metadata_obj);
+    if (!result) {
+      return false;
+    }
+
+    picojson::value value = picojson::value(picojson::object());
+    picojson::object& obj = value.get<picojson::object>();
+
+    obj.insert(std::make_pair(kIndex, picojson::value{index}));
+    obj.insert(std::make_pair(kMetadata, metadata_v));
+    items->push_back(value);
+
+    return true;
+  };
+
+  int ret = mc_playlist_foreach_item(playlist_handle, OnPlaylistItemCommand, items);
+
+  if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
+    return LogAndCreateResult(
+        ErrorCode::UNKNOWN_ERR, "Error while get playlist item",
+        ("mc_playlist_foreach_item() error: %d, message: %s", ret, get_error_message(ret)));
+  }
+
+  return PlatformResult(ErrorCode::NO_ERROR);
+}
+
 bool utils::isMetadataAttributeEncodable(const std::string& name) {
   return name == kSeason || name == kEpisode || name == kResolution;
 }

diff --git a/src/mediacontroller/mediacontroller_utils.h b/src/mediacontroller/mediacontroller_utils.h
index 24d7c4b5e8ad2a3b723ef9089aa455c4285b0ef8..1f21dfc1daf9e790b12aaf60c583de80d2a1b5d6 100644 (file)
--- a/src/mediacontroller/mediacontroller_utils.h
+++ b/src/mediacontroller/mediacontroller_utils.h
@@ -29,6 +29,7 @@ namespace extension {
 namespace mediacontroller {
 
 typedef std::function<void(picojson::value*)> JsonCallback;
+typedef std::map<std::string, mc_playlist_h> PlaylistHandleMap;
 
 namespace privileges {
 
@@ -122,9 +123,19 @@ extern const common::PlatformEnum<mc_display_rotation_e> MediaControllerDisplayR
 
 namespace utils {
 common::PlatformResult GetAllPlaylists(const std::string& app_id, picojson::array* playlists);
+common::PlatformResult GetAllPlaylistsHandles(const std::string& app_id,
+                                              std::map<std::string, mc_playlist_h>* playlists);
+picojson::value CreatePlaylistsJSON(const std::string& app_id,
+                                    const std::map<std::string, mc_playlist_h>& playlists);
+void UpdatePlaylistHandleMap(const std::string& app_id,
+                             const std::map<std::string, mc_playlist_h>& to_update,
+                             std::map<std::string, PlaylistHandleMap>& server_playlist_map);
 common::PlatformResult GetPlaylist(const std::string& app_id, const std::string& playlist_name,
-                                   picojson::object* playlist_obj);
+                                   picojson::object* playlist_obj, mc_playlist_h* handle = nullptr);
 common::ErrorCode ConvertMediaControllerError(int e);
+common::PlatformResult MediaControllerPlaylistGetItems(const mc_playlist_h playlist_handle,
+                                                       picojson::array* items);
+
 bool isMetadataAttributeEncodable(const std::string& name);
 common::PlatformResult EncodeMetadata(const picojson::object& to_encode, picojson::object* encoded);
 common::PlatformResult DecodeMetadata(const picojson::value& to_decode, picojson::object* decoded);