if (msg.action === 'onrepeatstaterequest') {
listener[msg.action](msg.state, msg.clientName);
}
+ if (msg.action === 'onplaybackitemrequest') {
+ listener[msg.action](msg.playlistName, msg.index, msg.state, msg.position, msg.clientName);
+ }
+
});
var ServerInfoStatusListener = new ListenerManager(native_, '_ServerInfoStatusListener', function(msg, listener) {
'onplaybackpositionrequest',
'onshufflemoderequest',
'onrepeatmoderequest',
- 'onrepeatstaterequest'
+ 'onrepeatstaterequest',
+ 'onplaybackitemrequest'
]
}]);
}
};
+MediaControllerServer.prototype.updatePlaybackItem = function(playlistName, index) {
+ var args = validator_.validateArgs(arguments, [
+ {name: 'playlistName', type: types_.STRING},
+ {name: 'index', type: types_.STRING}
+ ]);
+
+ var data = {
+ playlistName: args.playlistName,
+ index: args.index
+ };
+
+ var result = native_.callSync('MediaControllerServer_updatePlaybackItem', data);
+
+ if (native_.isFailure(result)) {
+ throw native_.getErrorObject(result);
+ }
+};
+
function MediaControllerClient() {}
MediaControllerClient.prototype.findServers = function(successCallback, errorCallback) {
}
};
+MediaControllerServerInfo.prototype.sendPlaybackItem = function(playlistName, index, state, position) {
+ var args = validator_.validateArgs(arguments, [
+ {name: 'playlistName', type: types_.STRING},
+ {name: 'index', type: types_.STRING},
+ {name: 'state', type: types_.ENUM, values: Object.keys(MediaControllerPlaybackState)},
+ {name: 'position', type: types_.UNSIGNED_LONG_LONG}
+ ]);
+
+ var data = {
+ name: this.name,
+ playlistName: args.playlistName,
+ index: args.index,
+ state: args.state,
+ position: args.position
+ };
+
+ var result = native_.callSync('MediaControllerServerInfo_sendPlaybackItem', data);
+
+ if (native_.isFailure(result)) {
+ throw native_.getErrorObject(result);
+ }
+};
+
var MediaControllerPlaylistItem = function(data) {
var _index = "";
var _metadata = new MediaControllerMetadata();
edit_.disallow();
}
+MediaControllerPlaylist.prototype.addItem = function(index, metadata) {
+ var args = validator_.validateArgs(arguments, [
+ {name: 'index', type: types_.STRING},
+ {name: 'metadata', type: types_.DICTIONARY}
+ ]);
+
+ var data = {
+ index: args.index,
+ metadata: args.metadata,
+ name: this.name
+ };
+
+ var result = native_.callSync('MediaControllerPlaylist_addItem', data);
+
+ if (native_.isFailure(result)) {
+ throw native_.getErrorObject(result);
+ }
+}
+
exports = new MediaControllerManager();
PlatformResult MediaControllerClient::SendCommand(const std::string& server_name,
const std::string& command,
const picojson::value& data,
- const JsonCallback& reply_cb,
- char** request_id) {
+ const JsonCallback& reply_cb, char** request_id) {
ScopeLogger();
bundle* bundle = bundle_create();
SCOPE_EXIT {
return PlatformResult(ErrorCode::NO_ERROR);
}
+PlatformResult MediaControllerClient::SendPlaybackItem(const std::string& name,
+ const std::string& playlist_name,
+ const std::string& index,
+ const std::string& state, double position) {
+ ScopeLogger();
+
+ int state_e;
+ // 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.
+ PlatformResult result =
+ Types::StringToPlatformEnum(Types::kMediaControllerPlaybackAction, state, &state_e);
+
+ if (!result) {
+ return result;
+ }
+
+ int ret = mc_client_send_playlist_cmd(handle_, name.c_str(), playlist_name.c_str(), index.c_str(),
+ static_cast<mc_playback_action_e>(state_e),
+ static_cast<unsigned long long>(position), nullptr);
+
+ if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
+ return LogAndCreateResult(
+ ErrorCode::UNKNOWN_ERR, "Error sending playlist item",
+ ("mc_client_send_playlist_cmd() error: %d, message: %s", ret, get_error_message(ret)));
+ }
+
+ return PlatformResult(ErrorCode::NO_ERROR);
+}
+
} // namespace mediacontroller
} // namespace extension
common::PlatformResult SetPlaybackInfoListener(const JsonCallback& callback);
common::PlatformResult UnsetPlaybackInfoListener();
+ common::PlatformResult SendPlaybackItem(const std::string& name, const std::string& playlist_name,
+ const std::string& index, const std::string& state,
+ double position);
private:
mc_client_h handle_;
#include "common/logger.h"
#include "common/picojson.h"
#include "common/platform_result.h"
+#include "common/scope_exit.h"
#include "common/task-queue.h"
#include "common/tools.h"
-#include "common/scope_exit.h"
#include "mediacontroller/mediacontroller_types.h"
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);
+ REGISTER_SYNC("MediaControllerServer_createPlaylist", MediaControllerServerCreatePlaylist);
+ REGISTER_ASYNC("MediaControllerServer_savePlaylist", MediaControllerServerSavePlaylist);
+ REGISTER_ASYNC("MediaControllerServer_deletePlaylist", MediaControllerServerDeletePlaylist);
+ REGISTER_SYNC("MediaControllerServer_updatePlaybackItem",
+ MediaControllerServerUpdatePlaybackItem);
// client
REGISTER_SYNC("MediaControllerManager_getClient", MediaControllerManagerGetClient);
MediaControllerServerInfoAddPlaybackInfoChangeListener);
REGISTER_SYNC("MediaControllerServerInfo_removePlaybackInfoChangeListener",
MediaControllerServerInfoRemovePlaybackInfoChangeListener);
+ REGISTER_SYNC("MediaControllerServerInfo_sendPlaybackItem",
+ MediaControllerServerInfoSendPlaybackItem);
+
+ // playlist
+ REGISTER_SYNC("MediaControllerPlaylist_addItem", MediaControllerPlaylistAddItem);
#undef REGISTER_SYNC
#undef REGISTER_ASYNC
return; \
}
+#define CHECK_TYPE(args, name, type, out) \
+ if (!args.get(name).is<type>()) { \
+ LogAndReportError(PlatformResult(ErrorCode::TYPE_MISMATCH_ERR, name " is not a " #type), \
+ &out); \
+ return; \
+ }
+
+#define CHECK_ARGS(args, name, type, out) \
+ CHECK_EXIST(args, name, out) \
+ CHECK_TYPE(args, name, type, out)
+
void MediaControllerInstance::MediaControllerManagerCreateServer(const picojson::value& args,
picojson::object& out) {
ScopeLogger();
LoggerE("No data passed to json callback");
return;
}
-
picojson::object& request_o = data->get<picojson::object>();
request_o["listenerId"] = args.get("listenerId");
CHECK_EXIST(args, "requestId", out)
CHECK_EXIST(args, "data", out)
- server_->CommandReply(
- args.get("clientName").get<std::string>(),
- args.get("requestId").get<std::string>(),
- args.get("data"));
+ server_->CommandReply(args.get("clientName").get<std::string>(),
+ args.get("requestId").get<std::string>(), args.get("data"));
ReportSuccess(out);
}
ReportSuccess(out);
}
-void MediaControllerInstance::MediaControllerServerCreatePlaylist(
- const picojson::value& args, picojson::object& out) {
+void MediaControllerInstance::MediaControllerServerCreatePlaylist(const picojson::value& args,
+ picojson::object& out) {
ScopeLogger();
if (!server_) {
LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occured."), &out,
return;
}
- CHECK_EXIST(args, "name", out)
+ CHECK_ARGS(args, "name", std::string, out)
picojson::value playlist_info = picojson::value();
ReportSuccess(playlist_info, out);
}
-void MediaControllerInstance::MediaControllerServerSavePlaylist(
- const picojson::value& args, picojson::object& out) {
+void MediaControllerInstance::MediaControllerServerSavePlaylist(const picojson::value& args,
+ picojson::object& out) {
ScopeLogger();
if (!server_) {
LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occured."), &out,
}
CHECK_EXIST(args, "callbackId", out)
- CHECK_EXIST(args, "name", out)
+ CHECK_ARGS(args, "name", std::string, out)
auto save = [this, args]() -> void {
picojson::value response = picojson::value(picojson::object());
ReportSuccess(out);
}
-void MediaControllerInstance::MediaControllerServerDeletePlaylist(
- const picojson::value& args, picojson::object& out) {
+void MediaControllerInstance::MediaControllerServerDeletePlaylist(const picojson::value& args,
+ picojson::object& out) {
ScopeLogger();
if (!server_) {
LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occured."), &out,
}
CHECK_EXIST(args, "callbackId", out)
- CHECK_EXIST(args, "name", out)
+ CHECK_ARGS(args, "name", std::string, out)
auto del = [this, args]() -> void {
picojson::value response = picojson::value(picojson::object());
ReportSuccess(out);
}
+void MediaControllerInstance::MediaControllerServerUpdatePlaybackItem(const picojson::value& args,
+ picojson::object& out) {
+ ScopeLogger();
+ if (!server_) {
+ LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occured."), &out,
+ ("Failed: server_"));
+ return;
+ }
+
+ CHECK_ARGS(args, "playlistName", std::string, out)
+ CHECK_ARGS(args, "index", std::string, out)
+
+ auto result = server_->UpdatePlaybackItem(args.get("playlistName").get<std::string>(),
+ args.get("index").get<std::string>());
+ if (!result) {
+ LogAndReportError(result, &out);
+ return;
+ }
+
+ ReportSuccess(out);
+}
+
void MediaControllerInstance::MediaControllerManagerGetClient(const picojson::value& args,
picojson::object& out) {
ScopeLogger();
free(request_id);
};
- PlatformResult result = client_->SendCommand(
- args.get("name").get<std::string>(),
- args.get("command").get<std::string>(),
- args.get("data"),
- reply_cb,
- &request_id);
+ PlatformResult result = client_->SendCommand(args.get("name").get<std::string>(),
+ args.get("command").get<std::string>(),
+ args.get("data"), reply_cb, &request_id);
if (result) {
ReportSuccess(out);
}
}
+void MediaControllerInstance::MediaControllerServerInfoSendPlaybackItem(const picojson::value& args,
+ picojson::object& out) {
+ ScopeLogger();
+
+ if (!client_) {
+ LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Client not initialized."), &out,
+ ("Failed: client_"));
+ return;
+ }
+
+ CHECK_ARGS(args, "name", std::string, out)
+ CHECK_ARGS(args, "playlistName", std::string, out)
+ CHECK_ARGS(args, "index", std::string, out)
+ CHECK_ARGS(args, "state", std::string, out)
+ CHECK_ARGS(args, "position", double, out)
+
+ auto result = client_->SendPlaybackItem(
+ args.get("name").get<std::string>(), args.get("playlistName").get<std::string>(),
+ args.get("index").get<std::string>(), args.get("state").get<std::string>(),
+ args.get("position").get<double>());
+ if (!result) {
+ LogAndReportError(result, &out);
+ return;
+ }
+
+ ReportSuccess(out);
+}
+
+void MediaControllerInstance::MediaControllerPlaylistAddItem(const picojson::value& args,
+ picojson::object& out) {
+ ScopeLogger();
+
+ // MediaControllerPlaylistAddItem is implemented in MediaControllerServer because
+ // mc_server_add_item_to_playlist need mc_server_h as parameter
+ if (!server_) {
+ LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Server not initialized."), &out,
+ ("Failed: server_"));
+ return;
+ }
+
+ CHECK_ARGS(args, "index", std::string, out)
+ CHECK_ARGS(args, "metadata",picojson::object, out)
+ CHECK_ARGS(args, "name", std::string, out)
+
+ const picojson::object& metadata = args.get("metadata").get<picojson::object>();
+
+ auto result = server_->MediaControllerPlaylistAddItem(
+ args.get("name").get<std::string>(), args.get("index").get<std::string>(), metadata);
+ if (!result) {
+ LogAndReportError(result, &out);
+ return;
+ }
+
+ ReportSuccess(out);
+}
+
#undef CHECK_EXIST
} // namespace mediacontroller
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);
+ void MediaControllerServerUpdatePlaybackItem(const picojson::value& args, picojson::object& out);
// client
void MediaControllerManagerGetClient(const picojson::value& args, picojson::object& out);
picojson::object& out);
void MediaControllerServerInfoRemovePlaybackInfoChangeListener(const picojson::value& args,
picojson::object& out);
+ void MediaControllerServerInfoSendPlaybackItem(const picojson::value& args,
+ picojson::object& out);
+
+ // playlist
+ void MediaControllerPlaylistAddItem(const picojson::value& args, picojson::object& out);
std::shared_ptr<MediaControllerClient> client_;
std::shared_ptr<MediaControllerServer> server_;
if (nullptr != command_listener_ && !UnsetCommandListener()) {
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());
}
void MediaControllerServer::OnCommandReceived(const char* client_name, const char* request_id,
- const char* command, bundle* bundle,
- void* user_data) {
+ const char* command, bundle* bundle, void* user_data) {
ScopeLogger();
MediaControllerServer* server = static_cast<MediaControllerServer*>(user_data);
return PlatformResult(ErrorCode::NO_ERROR);
}
+PlatformResult MediaControllerServer::UpdatePlaybackItem(const std::string& playlist_name, const std::string& index) {
+ ScopeLogger();
+
+ if (playlist_handle_map_.find(playlist_name) == playlist_handle_map_.end()) {
+ return LogAndCreateResult(ErrorCode::INVALID_VALUES_ERR, "Playlist with given name doesn't exist");
+ }
+
+ int ret = mc_server_set_playlist_item_info(handle_, playlist_name.c_str(), index.c_str());
+
+ if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
+ return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Error updating playback item",
+ ("mc_server_set_playlist_item_info() error: %d, message: %s", ret,
+ get_error_message(ret)));
+ }
+
+ ret = mc_server_update_playback_info(handle_);
+ if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
+ return LogAndCreateResult(
+ ErrorCode::UNKNOWN_ERR, "Error updating playback info",
+ ("mc_server_update_playback_info() error: %d, message: %s", ret, get_error_message(ret)));
+ }
+
+
+ return PlatformResult(ErrorCode::NO_ERROR);
+}
+
+PlatformResult MediaControllerServer::MediaControllerPlaylistAddItem(const std::string &name, const std::string &index,
+ const picojson::object &metadata)
+{
+ 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 attribute_int = MC_META_MEDIA_TITLE, ret = MEDIA_CONTROLLER_ERROR_NONE;
+ for (const auto& v: metadata) {
+ LoggerD("Key: %s - Value: %s ", v.first.c_str(), v.second.to_str().c_str());
+
+ PlatformResult result = Types::StringToPlatformEnum(Types::kMediaControllerMetadataAttribute,
+ v.first, &attribute_int);
+ if (!result) {
+ return result;
+ }
+
+ ret = mc_server_add_item_to_playlist(handle_, playlist_handle_map_[name], index.c_str(), static_cast<mc_meta_e>(attribute_int),
+ v.second.to_str().c_str());
+ if (MEDIA_CONTROLLER_ERROR_NONE != ret)
+ {
+ return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Error adding playlist item",
+ ("mc_server_add_item_to_playlist() error: %d, message: %s", ret,
+ get_error_message(ret)));
+ }
+ }
+
+ return PlatformResult(ErrorCode::NO_ERROR);
+}
+
PlatformResult MediaControllerServer::SetChangeRequestPlaybackInfoListener(
const JsonCallback& callback) {
ScopeLogger();
int failed_setter = 0;
+
SCOPE_EXIT {
// Lambda function used to clean all set listeners (in case of failure of
// SetPlaybackInfoListener method).
mc_server_unset_playback_action_cmd_received_cb,
mc_server_unset_playback_position_cmd_received_cb,
mc_server_unset_shuffle_mode_cmd_received_cb,
- /*mc_server_unset_repeat_mode_cmd_received_cb the last unsetter will never be used*/};
+ mc_server_unset_repeat_mode_cmd_received_cb,
+ /*mc_server_unset_playlist_cmd_received_cb the last unsetter will never be used*/};
// This loop is no-op in case of success.
for (int i = 0; i < failed_setter; ++i) {
ret, get_error_message(ret)));
}
+ ret = mc_server_set_playlist_cmd_received_cb(handle_, OnPlaybackItemCommand, this);
+ if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
+ failed_setter = 4;
+ return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Unable to set playback item command listener",
+ ("mc_server_set_playlist_cmd_received_cb() error: %d, message: %s",
+ ret, get_error_message(ret)));
+ }
+
change_request_playback_info_listener_ = callback;
return PlatformResult(ErrorCode::NO_ERROR);
get_error_message(ret)));
}
+ ret = mc_server_unset_playlist_cmd_received_cb(handle_);
+ if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
+ return LogAndCreateResult(
+ ErrorCode::UNKNOWN_ERR, "Unable to unset playback item command listener",
+ ("mc_server_unset_playlist_cmd_received_cb() error: %d, message: %s", ret,
+ get_error_message(ret)));
+ }
+
change_request_playback_info_listener_ = nullptr;
return PlatformResult(ErrorCode::NO_ERROR);
server->change_request_playback_info_listener_(&data);
}
+void MediaControllerServer::OnPlaybackItemCommand(const char* client_name, const char *request_id,
+ const char *playlist_name, const char *index, mc_playback_action_e action,
+ unsigned long long position, void *user_data) {
+ ScopeLogger();
+
+ MediaControllerServer* server = static_cast<MediaControllerServer*>(user_data);
+
+ std::string state;
+ PlatformResult result = Types::PlatformEnumToString(Types::kMediaControllerPlaybackAction,
+ static_cast<int>(action), &state);
+
+ if (!result) {
+ LoggerE("PlatformEnumToString failed, error: %s", result.message().c_str());
+ return;
+ }
+
+ picojson::value data = picojson::value(picojson::object());
+ picojson::object& data_o = data.get<picojson::object>();
+
+ data_o["action"] = picojson::value(std::string("onplaybackitemrequest"));
+ data_o["playlistName"] = picojson::value(playlist_name);
+ data_o["index"] = picojson::value(index);
+ data_o["state"] = picojson::value(state);
+ data_o["position"] = picojson::value(static_cast<double>(position));
+ data_o["clientName"] = picojson::value(client_name);
+
+ server->change_request_playback_info_listener_(&data);
+}
+
} // namespace mediacontroller
} // namespace extension
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 UpdatePlaybackItem(const std::string& name, const std::string& index);
+
+ common::PlatformResult MediaControllerPlaylistAddItem(const std::string& name,
+ const std::string& index,
+ const picojson::object& metadata);
private:
mc_server_h handle_;
mc_shuffle_mode_e mode, void* user_data);
static void OnRepeatModeCommand(const char* client_name, const char* request_id,
mc_repeat_mode_e mode, void* user_data);
+ static void OnPlaybackItemCommand(const char* client_name, const char* request_id,
+ const char* playlist_name, const char* index,
+ mc_playback_action_e action, unsigned long long position,
+ void* user_data);
static void OnCommandReceived(const char* client_name, const char* request_id,
const char* command, bundle* data, void* user_data);
projects / platform / core / api / webapi-plugins.git / commitdiff