[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 a033c54..41ab051 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 b7bc412..2c8c095 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 d21c743..d41ae51 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 82da535..89f3c33 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 a9af304..83ee086 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 c40c413..034920d 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 24d7c4b..1f21dfc 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);