[Mediacontroller] Add playlist methods

Add methods
- CreatePlaylist
- SavePlaylist
- DeletePlaylist
Define interfaces
- MediaControllerPlaylist
- MediaControllerPlaylistItem

[Verification] Code compiles without error. Tested in chrome console

ACR: TWDAPI-199

Change-Id: Icf9b043c00b23a29c0e3d13d0c3a3dbcba8c0762
Signed-off-by: Lukasz Bardeli <l.bardeli@samsung.com>

diff --git a/src/mediacontroller/mediacontroller_api.js b/src/mediacontroller/mediacontroller_api.js
index b1070bdbe2d53d1869b47ddc098ab624b3f56dfa..269fde940752732fbca2a61d6efe04c91a759c5f 100755 (executable)
--- a/src/mediacontroller/mediacontroller_api.js
+++ b/src/mediacontroller/mediacontroller_api.js
@@ -642,6 +642,75 @@ MediaControllerServer.prototype.removeCommandListener = function(watchId) {
   }
 };
 
+MediaControllerServer.prototype.createPlaylist = function(name) {
+  var args = validator_.validateArgs(arguments, [
+    {name: 'name', type: types_.STRING}
+  ]);
+
+  var data = {
+    name: args.name
+  };
+
+  var result = native_.callSync('MediaControllerServer_createPlaylist', data);
+
+  if (native_.isFailure(result)) {
+    throw native_.getErrorObject(result);
+  }
+
+  return new MediaControllerPlaylist(native_.getResultObject(result));
+};
+
+MediaControllerServer.prototype.savePlaylist = function(playlist, successCallback, errorCallback) {
+  var args = validator_.validateArgs(arguments, [
+    {name: 'playlist', type: types_.PLATFORM_OBJECT, values: MediaControllerPlaylist},
+    {name: 'successCallback', type: types_.FUNCTION, optional: true, nullable: true},
+    {name: 'errorCallback', type: types_.FUNCTION, optional: true, nullable: true}
+  ]);
+
+  var data = {
+    name: args.playlist.name
+  };
+
+  var callback = function(result) {
+    if (native_.isFailure(result)) {
+      native_.callIfPossible(args.errorCallback, native_.getErrorObject(result));
+      return;
+    }
+    native_.callIfPossible(args.successCallback);
+  };
+
+  var result = native_.call('MediaControllerServer_savePlaylist', data, callback);
+
+  if (native_.isFailure(result)) {
+    throw native_.getErrorObject(result);
+  }
+};
+
+MediaControllerServer.prototype.deletePlaylist = function(name, successCallback, errorCallback) {
+  var args = validator_.validateArgs(arguments, [
+    {name: 'name', type: types_.STRING},
+    {name: 'successCallback', type: types_.FUNCTION, optional: true, nullable: true},
+    {name: 'errorCallback', type: types_.FUNCTION, optional: true, nullable: true}
+  ]);
+
+  var data = {
+    name: args.name
+  };
+
+  var callback = function(result) {
+    if (native_.isFailure(result)) {
+      native_.callIfPossible(args.errorCallback, native_.getErrorObject(result));
+      return;
+    }
+    native_.callIfPossible(args.successCallback);
+  };
+
+  var result = native_.call('MediaControllerServer_deletePlaylist', data, callback);
+
+  if (native_.isFailure(result)) {
+    throw native_.getErrorObject(result);
+  }
+};
 
 function MediaControllerClient() {}
 
@@ -930,5 +999,64 @@ MediaControllerServerInfo.prototype.removePlaybackInfoChangeListener = function(
   }
 };
 
+var MediaControllerPlaylistItem = function(data) {
+  var _index = "";
+  var _metadata = new MediaControllerMetadata();
+  Object.defineProperties(this, {
+    index: {
+      get: function() {
+        return _index;
+      },
+      set: function(v) {
+        _index = edit_.isAllowed && v ? v : _index;
+      },
+      enumerable: true
+    },
+    metadata: {
+      get: function() {
+        return _metadata;
+      },
+      set: function(v) {
+        _metadata = edit_.isAllowed && v ? new MediaControllerMetadata(v) : _metadata;
+      },
+      enumerable: true
+    }
+  });
+
+  edit_.allow();
+  if (data instanceof _global.Object) {
+    for (var prop in data) {
+      if (data.hasOwnProperty(prop) && this.hasOwnProperty(prop)) {
+        this[prop] = data[prop];
+      }
+    }
+  }
+  edit_.disallow();
+};
+
+function MediaControllerPlaylist(data) {
+  var _name = "";
+
+  Object.defineProperties(this, {
+    name: {
+      get: function() {
+        return _name;
+      },
+      set: function(v) {
+        _name = edit_.isAllowed && v ? v : _name;
+      },
+      enumerable: true
+    }
+  });
+  edit_.allow();
+  if (data instanceof _global.Object) {
+    for (var prop in data) {
+      if (data.hasOwnProperty(prop) && this.hasOwnProperty(prop)) {
+        this[prop] = data[prop];
+      }
+    }
+  }
+  edit_.disallow();
+}
 
 exports = new MediaControllerManager();

diff --git a/src/mediacontroller/mediacontroller_instance.cc b/src/mediacontroller/mediacontroller_instance.cc
index 746efcaa3fa1c34293eb5350cd1db0160578c982..6d350ece18c26f1171aa6591288400e97783ca31 100644 (file)
--- a/src/mediacontroller/mediacontroller_instance.cc
+++ b/src/mediacontroller/mediacontroller_instance.cc
@@ -71,6 +71,12 @@ MediaControllerInstance::MediaControllerInstance() {
   REGISTER_SYNC("MediaControllerServer_replyCommand", MediaControllerServerReplyCommand);
   REGISTER_SYNC("MediaControllerServer_removeCommandListener",
                 MediaControllerServerRemoveCommandListener);
+  REGISTER_SYNC("MediaControllerServer_createPlaylist",
+                MediaControllerServerCreatePlaylist);
+  REGISTER_ASYNC("MediaControllerServer_savePlaylist",
+                MediaControllerServerSavePlaylist);
+  REGISTER_ASYNC("MediaControllerServer_deletePlaylist",
+                MediaControllerServerDeletePlaylist);
 
   // client
   REGISTER_SYNC("MediaControllerManager_getClient", MediaControllerManagerGetClient);
@@ -389,6 +395,94 @@ void MediaControllerInstance::MediaControllerServerRemoveCommandListener(
   ReportSuccess(out);
 }
 
+void MediaControllerInstance::MediaControllerServerCreatePlaylist(
+    const picojson::value& args, picojson::object& out) {
+  ScopeLogger();
+  if (!server_) {
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occured."), &out,
+                      ("Failed: server_"));
+    return;
+  }
+
+  CHECK_EXIST(args, "name", out)
+
+  picojson::value playlist_info = picojson::value();
+
+  auto result = server_->CreatePlaylist(args.get("name").get<std::string>(), &playlist_info);
+  if (!result) {
+    LogAndReportError(result, &out, ("Failed: server_->CreatePlaylist["));
+    return;
+  }
+
+  ReportSuccess(playlist_info, out);
+}
+
+void MediaControllerInstance::MediaControllerServerSavePlaylist(
+    const picojson::value& args, picojson::object& out) {
+  ScopeLogger();
+  if (!server_) {
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occured."), &out,
+                      ("Failed: server_"));
+    return;
+  }
+
+  CHECK_EXIST(args, "callbackId", out)
+  CHECK_EXIST(args, "name", out)
+
+  auto save = [this, args]() -> void {
+    picojson::value response = picojson::value(picojson::object());
+    picojson::object& response_obj = response.get<picojson::object>();
+    response_obj["callbackId"] = args.get("callbackId");
+
+    auto result = server_->SavePlaylist(args.get("name").get<std::string>());
+
+    if (result) {
+      ReportSuccess(response_obj);
+    } else {
+      LogAndReportError(result, &response_obj, ("Failed: server_->SavePlaylist"));
+    }
+
+    Instance::PostMessage(this, response.serialize().c_str());
+  };
+
+  TaskQueue::GetInstance().Async(save);
+
+  ReportSuccess(out);
+}
+
+void MediaControllerInstance::MediaControllerServerDeletePlaylist(
+    const picojson::value& args, picojson::object& out) {
+  ScopeLogger();
+  if (!server_) {
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occured."), &out,
+                      ("Failed: server_"));
+    return;
+  }
+
+  CHECK_EXIST(args, "callbackId", out)
+  CHECK_EXIST(args, "name", out)
+
+  auto del = [this, args]() -> void {
+    picojson::value response = picojson::value(picojson::object());
+    picojson::object& response_obj = response.get<picojson::object>();
+    response_obj["callbackId"] = args.get("callbackId");
+
+    auto result = server_->DeletePlaylist(args.get("name").get<std::string>());
+
+    if (result) {
+      ReportSuccess(response_obj);
+    } else {
+      LogAndReportError(result, &response_obj, ("Failed: server_->DeletePlaylist"));
+    }
+
+    Instance::PostMessage(this, response.serialize().c_str());
+  };
+
+  TaskQueue::GetInstance().Async(del);
+
+  ReportSuccess(out);
+}
+
 void MediaControllerInstance::MediaControllerManagerGetClient(const picojson::value& args,
                                                               picojson::object& out) {
   ScopeLogger();

diff --git a/src/mediacontroller/mediacontroller_instance.h b/src/mediacontroller/mediacontroller_instance.h
index ea7173ea34cb7594e137e0aef0d7df93715dee7c..227da85cf9fd39f65f105d9b60ce06fccf26a705 100644 (file)
--- a/src/mediacontroller/mediacontroller_instance.h
+++ b/src/mediacontroller/mediacontroller_instance.h
@@ -51,6 +51,9 @@ class MediaControllerInstance : public common::ParsedInstance {
   void MediaControllerServerReplyCommand(const picojson::value& args, picojson::object& out);
   void MediaControllerServerRemoveCommandListener(const picojson::value& args,
                                                   picojson::object& out);
+  void MediaControllerServerCreatePlaylist(const picojson::value& args, picojson::object& out);
+  void MediaControllerServerSavePlaylist(const picojson::value& args, picojson::object& out);
+  void MediaControllerServerDeletePlaylist(const picojson::value& args, picojson::object& out);
 
   // client
   void MediaControllerManagerGetClient(const picojson::value& args, picojson::object& out);

diff --git a/src/mediacontroller/mediacontroller_server.cc b/src/mediacontroller/mediacontroller_server.cc
index a2a4da02a5f166436dffed1754df9869fd6d6f34..973ea8577f97cfecfa90ff0834db5e1a0f99a5f5 100644 (file)
--- a/src/mediacontroller/mediacontroller_server.cc
+++ b/src/mediacontroller/mediacontroller_server.cc
@@ -55,6 +55,12 @@ MediaControllerServer::~MediaControllerServer() {
     LoggerE("Failed to unset command listener");
   }
 
+  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());
+    }
+  }
+
   if (nullptr != handle_ && MEDIA_CONTROLLER_ERROR_NONE != mc_server_destroy(handle_)) {
     LoggerE("Unable to destroy media controller server");
   }
@@ -363,6 +369,75 @@ PlatformResult MediaControllerServer::UnsetCommandListener() {
   return PlatformResult(ErrorCode::NO_ERROR);
 }
 
+PlatformResult MediaControllerServer::CreatePlaylist(const std::string& name, picojson::value* playlist_info) {
+  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_);
+
+  if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
+    return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Unable to createPlaylist",
+                              ("mc_server_create_playlist() error: %d, message: %s",
+                               ret, get_error_message(ret)));
+  }
+
+  playlist_handle_map_[name] = playlist_handle_;
+
+  if (playlist_info == nullptr) {
+    return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Unable to createPlaylist",
+                              ("playlist_info is nullptr"));
+  }
+
+  *playlist_info = picojson::value(picojson::object());
+  picojson::object& obj = playlist_info->get<picojson::object>();
+  obj["name"] = picojson::value(name);
+
+  return PlatformResult(ErrorCode::NO_ERROR);
+}
+
+PlatformResult MediaControllerServer::SavePlaylist(const std::string& name) {
+  ScopeLogger();
+
+  if (playlist_handle_map_.find(name) == playlist_handle_map_.end()) {
+    return LogAndCreateResult(ErrorCode::INVALID_VALUES_ERR, "Playlist with given name doesn't exist");
+  }
+
+  int ret = mc_server_update_playlist_done(handle_, playlist_handle_map_[name]);
+
+  if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
+    return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Error saving playlist",
+                              ("mc_server_update_playlist_done() error: %d, message: %s", ret,
+                               get_error_message(ret)));
+  }
+
+  return PlatformResult(ErrorCode::NO_ERROR);
+}
+
+PlatformResult MediaControllerServer::DeletePlaylist(const std::string& name) {
+  ScopeLogger();
+
+  if (playlist_handle_map_.find(name) == playlist_handle_map_.end()) {
+    return LogAndCreateResult(ErrorCode::INVALID_VALUES_ERR, "Playlist with given name doesn't exist");
+  }
+
+  int ret = mc_server_delete_playlist(handle_, playlist_handle_map_[name]);
+
+  if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
+    return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Error deleting playlist",
+                              ("mc_server_delete_playlist() error: %d, message: %s", ret,
+                               get_error_message(ret)));
+  }
+
+  playlist_handle_map_.erase(name);
+
+  return PlatformResult(ErrorCode::NO_ERROR);
+}
+
 PlatformResult MediaControllerServer::SetChangeRequestPlaybackInfoListener(
     const JsonCallback& callback) {
   ScopeLogger();

diff --git a/src/mediacontroller/mediacontroller_server.h b/src/mediacontroller/mediacontroller_server.h
index 2c9a01dc88fb2a512e905d912d3a754beab948fd..55476db1cdd160184b6eb66dad695d985e4981d7 100644 (file)
--- a/src/mediacontroller/mediacontroller_server.h
+++ b/src/mediacontroller/mediacontroller_server.h
@@ -49,6 +49,10 @@ 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);
+
  private:
   mc_server_h handle_;
 
@@ -62,6 +66,7 @@ class MediaControllerServer {
   bool is_repeat_mode_set_;
 
   JsonCallback command_listener_;
+  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);