'mediacontroller_instance.h',
'mediacontroller_server.cc',
'mediacontroller_server.h',
- 'mediacontroller_types.cc',
- 'mediacontroller_types.h',
+ 'mediacontroller_utils.cc',
+ 'mediacontroller_utils.h',
],
'conditions': [
['tizen == 1', {
var _repeatState = MediaControllerRepeatState.REPEAT_OFF;
var _ageRating = MediaControllerContentAgeRating.ALL;
var _metadata = new MediaControllerMetadata();
+ var _index = null;
+ var _playlistName = null;
Object.defineProperties(this, {
state: {
get: function() {
_metadata = edit_.isAllowed && v ? new MediaControllerMetadata(v) : _metadata;
},
enumerable: true
+ },
+ index: {
+ get: function() {
+ return _index;
+ },
+ set: function(v) {
+ _index = edit_.isAllowed && v ? v : _index;
+ },
+ enumerable: true
+ },
+ playlistName: {
+ get: function() {
+ return _playlistName;
+ },
+ set: function(v) {
+ _playlistName = edit_.isAllowed && v ? v : _playlistName;
+ },
+ enumerable: true
}
});
if (native_.isFailure(result)) {
throw native_.getErrorObject(result);
}
+
+ edit_.allow();
+ this.playbackInfo.index = args.index;
+ this.playbackInfo.playlistName = args.playlistName;
+ edit_.disallow();
};
+MediaControllerServer.prototype.getAllPlaylists = function(successCallback, errorCallback) {
+ var args = validator_.validateArgs(arguments, [
+ {name: 'successCallback', type: types_.FUNCTION, optional: false, nullable: false},
+ {name: 'errorCallback', type: types_.FUNCTION, optional: true, nullable: true}
+ ]);
+
+ var callback = function(result) {
+ if (native_.isFailure(result)) {
+ native_.callIfPossible(args.errorCallback, native_.getErrorObject(result));
+ return;
+ }
+ var data = native_.getResultObject(result);
+ var playlists = [];
+
+ for(var i = 0; i < data.length; i++) {
+ playlists.push(new MediaControllerPlaylist(data[i]));
+ }
+
+ native_.callIfPossible(args.successCallback, playlists);
+ };
+
+ var result = native_.call('MediaControllerServer_getAllPlaylists', {}, callback);
+
+ if (native_.isFailure(result)) {
+ throw native_.getErrorObject(result);
+ }
+}
+
function MediaControllerClient() {}
MediaControllerClient.prototype.findServers = function(successCallback, errorCallback) {
}
};
+MediaControllerServerInfo.prototype.getAllPlaylists = function(successCallback, errorCallback) {
+ var args = validator_.validateArgs(arguments, [
+ {name: 'successCallback', type: types_.FUNCTION, optional: false, nullable: false},
+ {name: 'errorCallback', type: types_.FUNCTION, optional: true, nullable: true}
+ ]);
+
+ var callback = function(result) {
+ if (native_.isFailure(result)) {
+ native_.callIfPossible(args.errorCallback, native_.getErrorObject(result));
+ return;
+ }
+ var data = native_.getResultObject(result);
+ var playlists = [];
+
+ for(var i = 0; i < data.length; i++) {
+ playlists.push(new MediaControllerPlaylist(data[i]));
+ }
+
+ native_.callIfPossible(args.successCallback, playlists);
+ };
+
+ var result = native_.call('MediaControllerServerInfo_getAllPlaylists', {name:this.name}, callback);
+
+ if (native_.isFailure(result)) {
+ throw native_.getErrorObject(result);
+ }
+}
+
MediaControllerServerInfo.prototype.sendPlaybackItem = function(playlistName, index, state, position) {
var args = validator_.validateArgs(arguments, [
{name: 'playlistName', type: types_.STRING},
}
}
+MediaControllerPlaylist.prototype.getItems = function(successCallback, errorCallback) {
+ var args = validator_.validateArgs(arguments, [
+ {name: 'successCallback', type: types_.FUNCTION, optional: false, nullable: false},
+ {name: 'errorCallback', type: types_.FUNCTION, optional: true, nullable: true}
+ ]);
+
+ var data = {
+ name: this.name
+ };
+
+ var callback = function(result) {
+ if (native_.isFailure(result)) {
+ native_.callIfPossible(args.errorCallback, native_.getErrorObject(result));
+ return;
+ }
+ var data = native_.getResultObject(result);
+ var items = [];
+
+ for(var i = 0; i < data.length; i++) {
+ items.push(new MediaControllerPlaylistItem(data[i]));
+ }
+
+ native_.callIfPossible(args.successCallback, items);
+ };
+
+ var result = native_.call('MediaControllerPlaylist_getItems', data, callback);
+
+ if (native_.isFailure(result)) {
+ throw native_.getErrorObject(result);
+ }
+}
+
exports = new MediaControllerManager();
#include "common/scope_exit.h"
#include "common/tools.h"
-#include "mediacontroller/mediacontroller_types.h"
-
namespace extension {
namespace mediacontroller {
ScopeLogger();
int ret;
+ char* index = nullptr;
+ char* playlist_name = nullptr;
mc_playback_h playback_h;
ret = mc_client_get_server_playback_info(handle_, server_name.c_str(), &playback_h);
if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
SCOPE_EXIT {
mc_client_destroy_playback(playback_h);
+ free(index);
+ free(playlist_name);
};
// playback state
return result;
}
+ ret = mc_client_get_playlist_item_info(playback_h, &playlist_name, &index);
+ if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
+ return LogAndCreateResult(
+ ErrorCode::UNKNOWN_ERR, "Error getting playlistName and index",
+ ("mc_client_get_playlist_item_info() error: %d, message: %s", ret, get_error_message(ret)));
+ }
+
// fill return object
(*playback_info)["state"] = picojson::value(state);
(*playback_info)["position"] = picojson::value(position);
(*playback_info)["shuffleMode"] = picojson::value(shuffle == MC_SHUFFLE_MODE_ON);
(*playback_info)["repeatMode"] = picojson::value(repeat == MC_REPEAT_MODE_ON);
(*playback_info)["metadata"] = metadata;
+ (*playback_info)["index"] = picojson::value(std::string(index ? index : ""));
+ (*playback_info)["playlistName"] =
+ picojson::value(std::string(playlist_name ? playlist_name : ""));
+ ;
return PlatformResult(ErrorCode::NO_ERROR);
}
return PlatformResult(ErrorCode::NO_ERROR);
}
-void MediaControllerClient::OnPlaylistUpdate(const char *server_name, mc_playlist_update_mode_e mode,
- const char *playlist_name, mc_playlist_h playlist, void *user_data) {
+void MediaControllerClient::OnPlaylistUpdate(const char* server_name,
+ mc_playlist_update_mode_e mode,
+ const char* playlist_name, mc_playlist_h playlist,
+ void* user_data) {
ScopeLogger();
- MediaControllerClient *client = static_cast<MediaControllerClient *>(user_data);
+ MediaControllerClient* client = static_cast<MediaControllerClient*>(user_data);
picojson::value data = picojson::value(picojson::object());
- picojson::object
&data_o = data.get<picojson::object>();
+ picojson::object
& data_o = data.get<picojson::object>();
if (MC_PLAYLIST_UPDATED == mode) {
// Create or Update playlist
#include "common/platform_result.h"
-#include "mediacontroller/mediacontroller_types.h"
+#include "mediacontroller/mediacontroller_utils.h"
namespace extension {
namespace mediacontroller {
static void OnShuffleModeUpdate(const char* server_name, mc_shuffle_mode_e mode, void* user_data);
static void OnRepeatModeUpdate(const char* server_name, mc_repeat_mode_e mode, void* user_data);
static void OnMetadataUpdate(const char* server_name, mc_metadata_h metadata_h, void* user_data);
- static void OnPlaylistUpdate(const char *server_name, mc_playlist_update_mode_e mode,
- const char *playlist_name, mc_playlist_h playlist, void *user_data);
+ static void OnPlaylistUpdate(const char* server_name, mc_playlist_update_mode_e mode,
+ const char* playlist_name, mc_playlist_h playlist, void* user_data);
};
} // namespace mediacontroller
#include "mediacontroller/mediacontroller_instance.h"
+#include "common/current_application.h"
#include "common/logger.h"
#include "common/picojson.h"
#include "common/platform_result.h"
#include "common/task-queue.h"
#include "common/tools.h"
-#include "mediacontroller/mediacontroller_types.h"
+#include "mediacontroller/mediacontroller_utils.h"
namespace extension {
namespace mediacontroller {
REGISTER_ASYNC("MediaControllerServer_deletePlaylist", MediaControllerServerDeletePlaylist);
REGISTER_SYNC("MediaControllerServer_updatePlaybackItem",
MediaControllerServerUpdatePlaybackItem);
+ REGISTER_ASYNC("MediaControllerServer_getAllPlaylists", MediaControllerServerGetAllPlaylists);
// client
REGISTER_SYNC("MediaControllerManager_getClient", MediaControllerManagerGetClient);
MediaControllerServerInfoAddPlaylistUpdateListener);
REGISTER_SYNC("MediaControllerServerInfo_removePlaylistUpdatedListener",
MediaControllerServerInfoRemovePlaylistUpdateListener);
+ REGISTER_ASYNC("MediaControllerServerInfo_getAllPlaylists",
+ MediaControllerServerInfoGetAllPlaylists);
// playlist
REGISTER_SYNC("MediaControllerPlaylist_addItem", MediaControllerPlaylistAddItem);
+ REGISTER_ASYNC("MediaControllerPlaylist_getItems", MediaControllerPlaylistGetItems);
#undef REGISTER_SYNC
#undef REGISTER_ASYNC
ReportSuccess(out);
}
+void MediaControllerInstance::MediaControllerServerGetAllPlaylists(const picojson::value& args,
+ picojson::object& out) {
+ ScopeLogger();
+
+ auto get = [this, args]() -> void {
+ picojson::value response = picojson::value(picojson::object());
+ picojson::object& response_obj = response.get<picojson::object>();
+
+ response_obj["callbackId"] = args.get("callbackId");
+
+ std::string app_id = common::CurrentApplication::GetInstance().GetApplicationId();
+
+ if (app_id.empty()) {
+ LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Error while get playlists"),
+ &response_obj, ("CurrentApplication::GetInstance().GetApplicationId()"));
+ Instance::PostMessage(this, response.serialize().c_str());
+ return;
+ }
+
+ picojson::value playlists{picojson::array{}};
+ auto result = utils::GetAllPlaylists(app_id, &playlists.get<picojson::array>());
+
+ if (!result) {
+ LogAndReportError(result, &response_obj, ("Failed: utils::GetAllPlaylists"));
+ Instance::PostMessage(this, response.serialize().c_str());
+ return;
+ }
+
+ response_obj["result"] = picojson::value{playlists};
+ ReportSuccess(response_obj);
+ Instance::PostMessage(this, response.serialize().c_str());
+ };
+
+ TaskQueue::GetInstance().Async(get);
+
+ ReportSuccess(out);
+}
+
void MediaControllerInstance::MediaControllerManagerGetClient(const picojson::value& args,
picojson::object& out) {
ScopeLogger();
if (result) {
ReportSuccess(out);
- out["requestId"] = picojson::value(std::string(request_id));
} else {
LogAndReportError(result, &out, ("Failed to send command."));
}
ReportSuccess(out);
}
-void MediaControllerInstance::MediaControllerPlaylistAddItem(
- const picojson::value& args, picojson::object& out) {
+void MediaControllerInstance::MediaControllerServerInfoGetAllPlaylists(const picojson::value& args,
+ picojson::object& out) {
+ ScopeLogger();
+
+ CHECK_ARGS(args, "name", std::string, out)
+
+ auto get = [this, args]() -> void {
+ picojson::value response = picojson::value(picojson::object());
+ picojson::object& response_obj = response.get<picojson::object>();
+
+ response_obj["callbackId"] = args.get("callbackId");
+
+ picojson::value playlists{picojson::array{}};
+
+ auto result = utils::GetAllPlaylists(args.get("name").get<std::string>(),
+ &playlists.get<picojson::array>());
+
+ if (!result) {
+ LogAndReportError(result, &response_obj, ("Failed: utils::GetAllPlaylists"));
+ Instance::PostMessage(this, response.serialize().c_str());
+ return;
+ }
+
+ response_obj["result"] = picojson::value{playlists};
+ ReportSuccess(response_obj);
+ Instance::PostMessage(this, response.serialize().c_str());
+ };
+
+ TaskQueue::GetInstance().Async(get);
+
+ ReportSuccess(out);
+}
+
+void MediaControllerInstance::MediaControllerPlaylistAddItem(const picojson::value& args,
+ picojson::object& out) {
ScopeLogger();
// MediaControllerPlaylistAddItem is implemented in MediaControllerServer because
}
CHECK_ARGS(args, "index", std::string, out)
- CHECK_ARGS(args, "metadata",picojson::object, 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>();
ReportSuccess(out);
}
+void MediaControllerInstance::MediaControllerPlaylistGetItems(const picojson::value& args,
+ 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, "Unknown error occured."), &out,
+ ("Failed: server_"));
+ return;
+ }
+ CHECK_EXIST(args, "callbackId", out)
+ CHECK_ARGS(args, "name", std::string, out)
+
+ auto get = [this, args]() -> void {
+ picojson::value response = picojson::value(picojson::object());
+ picojson::object& response_obj = response.get<picojson::object>();
+
+ response_obj["callbackId"] = args.get("callbackId");
+
+ picojson::value items{picojson::array{}};
+
+ auto result = server_->MediaControllerPlaylistGetItems(args.get("name").get<std::string>(),
+ &items.get<picojson::array>());
+
+ if (!result) {
+ LogAndReportError(result, &response_obj,
+ ("Failed: server_->MediaControllerPlaylistGetItems"));
+ Instance::PostMessage(this, response.serialize().c_str());
+ return;
+ }
+
+ response_obj["result"] = picojson::value{items};
+ ReportSuccess(response_obj);
+ Instance::PostMessage(this, response.serialize().c_str());
+ };
+
+ TaskQueue::GetInstance().Async(get);
+
+ ReportSuccess(out);
+}
+
#undef CHECK_EXIST
} // namespace mediacontroller
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);
+ void MediaControllerServerGetAllPlaylists(const picojson::value& args, picojson::object& out);
// client
void MediaControllerManagerGetClient(const picojson::value& args, picojson::object& out);
picojson::object& out);
void MediaControllerServerInfoRemovePlaylistUpdateListener(const picojson::value& args,
picojson::object& out);
+ void MediaControllerServerInfoGetAllPlaylists(const picojson::value& args, picojson::object& out);
// playlist
void MediaControllerPlaylistAddItem(const picojson::value& args, picojson::object& out);
+ void MediaControllerPlaylistGetItems(const picojson::value& args, picojson::object& out);
std::shared_ptr<MediaControllerClient> client_;
std::shared_ptr<MediaControllerServer> server_;
#include "common/scope_exit.h"
#include "common/tools.h"
-#include "mediacontroller/mediacontroller_types.h"
-
namespace extension {
namespace mediacontroller {
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::CreatePlaylist(const std::string& name, picojson::value* playlist_info) {
+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");
+ 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)));
+ 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_;
ScopeLogger();
if (playlist_handle_map_.find(name) == playlist_handle_map_.end()) {
- return LogAndCreateResult(ErrorCode::INVALID_VALUES_ERR, "Playlist with given name doesn't exist");
+ 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 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);
ScopeLogger();
if (playlist_handle_map_.find(name) == playlist_handle_map_.end()) {
- return LogAndCreateResult(ErrorCode::INVALID_VALUES_ERR, "Playlist with given name doesn't exist");
+ 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)));
+ 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::UpdatePlaybackItem(const std::string& playlist_name, const std::string& index) {
+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");
+ 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)));
+ 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_);
("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)
-{
+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");
+ if (playlist_handle_map_.find(name) == playlist_handle_map_.end()) {
+ return LogAndCreateResult(ErrorCode::UNKNOWN_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) {
+ 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,
return result;
}
- ret = mc_server_add_item_to_playlist(handle_, playlist_handle_map_[name], index.c_str(), static_cast<mc_meta_e>(attribute_int),
+ 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)));
+ 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::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("index", picojson::value{index}));
+ obj.insert(std::make_pair("metadata", 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);
int (*unsetters[])(mc_server_h) = {
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,
+ mc_server_unset_shuffle_mode_cmd_received_cb, 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.
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",
+ 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)));
}
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)));
+ 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;
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) {
+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);
#include <string>
#include "common/platform_result.h"
-#include "mediacontroller/mediacontroller_types.h"
+#include "mediacontroller/mediacontroller_utils.h"
namespace extension {
namespace mediacontroller {
common::PlatformResult MediaControllerPlaylistAddItem(const std::string& name,
const std::string& index,
const picojson::object& metadata);
+ common::PlatformResult MediaControllerPlaylistGetItems(const std::string& name,
+ picojson::array* items);
private:
mc_server_h handle_;
+++ /dev/null
-/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd All Rights Reserved
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "mediacontroller/mediacontroller_types.h"
-
-#include <media_controller_client.h>
-
-#include "common/logger.h"
-#include "common/platform_result.h"
-#include "common/scope_exit.h"
-
-namespace extension {
-namespace mediacontroller {
-
-using common::PlatformResult;
-using common::ErrorCode;
-
-const std::string Types::kMediaControllerServerState = "MediaControllerServerState";
-const std::string Types::kMediaControllerPlaybackState = "MediaControllerPlaybackState";
-const std::string Types::kMediaControllerPlaybackAction = "MediaControllerPlaybackAction";
-const std::string Types::kMediaControllerMetadataAttribute = "MediaControllerMetadataAttribute";
-const std::string Types::kMediaControllerRepeatState = "MediaControllerRepeatState";
-const std::string Types::kMediaControllerContentAgeRating = "MediaControllerContentAgeRationg";
-
-const PlatformEnumMap Types::platform_enum_map_ = {
- {kMediaControllerServerState,
- {{"NONE", MC_SERVER_STATE_NONE},
- {"ACTIVE", MC_SERVER_STATE_ACTIVATE},
- {"INACTIVE", MC_SERVER_STATE_DEACTIVATE}}},
- {kMediaControllerPlaybackState,
- {{"PLAY", MC_PLAYBACK_STATE_PLAYING},
- {"PAUSE", MC_PLAYBACK_STATE_PAUSED},
- {"STOP", MC_PLAYBACK_STATE_STOPPED},
- {"NEXT", MC_PLAYBACK_STATE_MOVING_TO_NEXT},
- {"PREV", MC_PLAYBACK_STATE_MOVING_TO_PREVIOUS},
- {"FORWARD", MC_PLAYBACK_STATE_FAST_FORWARDING},
- {"REWIND", MC_PLAYBACK_STATE_REWINDING}}},
- {kMediaControllerPlaybackAction,
- {{"PLAY", MC_PLAYBACK_ACTION_PLAY},
- {"PAUSE", MC_PLAYBACK_ACTION_PAUSE},
- {"STOP", MC_PLAYBACK_ACTION_STOP},
- {"NEXT", MC_PLAYBACK_ACTION_NEXT},
- {"PREV", MC_PLAYBACK_ACTION_PREV},
- {"FORWARD", MC_PLAYBACK_ACTION_FAST_FORWARD},
- {"REWIND", MC_PLAYBACK_ACTION_REWIND}}},
- {kMediaControllerMetadataAttribute,
- {{"title", MC_META_MEDIA_TITLE},
- {"artist", MC_META_MEDIA_ARTIST},
- {"album", MC_META_MEDIA_ALBUM},
- {"author", MC_META_MEDIA_AUTHOR},
- {"genre", MC_META_MEDIA_GENRE},
- {"duration", MC_META_MEDIA_DURATION},
- {"date", MC_META_MEDIA_DATE},
- {"copyright", MC_META_MEDIA_COPYRIGHT},
- {"description", MC_META_MEDIA_DESCRIPTION},
- {"trackNum", MC_META_MEDIA_TRACK_NUM},
- {"picture", MC_META_MEDIA_PICTURE}}},
- {kMediaControllerRepeatState,
- {{"REPEAT_OFF", MC_REPEAT_MODE_OFF},
- {"REPEAT_ONE", MC_REPEAT_MODE_ONE_MEDIA},
- {"REPEAT_ALL", MC_REPEAT_MODE_ON}}},
- {kMediaControllerContentAgeRating,
- {
- {"ALL", MC_CONTENT_RATING_ALL}, {"1", MC_CONTENT_RATING_1_PLUS},
- {"2", MC_CONTENT_RATING_2_PLUS}, {"3", MC_CONTENT_RATING_3_PLUS},
- {"4", MC_CONTENT_RATING_4_PLUS}, {"5", MC_CONTENT_RATING_5_PLUS},
- {"6", MC_CONTENT_RATING_6_PLUS}, {"7", MC_CONTENT_RATING_7_PLUS},
- {"8", MC_CONTENT_RATING_8_PLUS}, {"9", MC_CONTENT_RATING_9_PLUS},
- {"10", MC_CONTENT_RATING_10_PLUS}, {"11", MC_CONTENT_RATING_11_PLUS},
- {"12", MC_CONTENT_RATING_12_PLUS}, {"13", MC_CONTENT_RATING_13_PLUS},
- {"14", MC_CONTENT_RATING_14_PLUS}, {"15", MC_CONTENT_RATING_15_PLUS},
- {"16", MC_CONTENT_RATING_16_PLUS}, {"17", MC_CONTENT_RATING_17_PLUS},
- {"18", MC_CONTENT_RATING_18_PLUS}, {"19", MC_CONTENT_RATING_19_PLUS},
- }}};
-
-PlatformEnumReverseMap Types::platform_enum_reverse_map_ = {};
-
-PlatformResult Types::GetPlatformEnumMap(const std::string& type,
- std::map<std::string, int> const** enum_map) {
- ScopeLogger();
-
- auto iter = platform_enum_map_.find(type);
- if (iter == platform_enum_map_.end()) {
- return LogAndCreateResult(ErrorCode::UNKNOWN_ERR,
- std::string("Undefined platform enum type ") + type);
- }
-
- *enum_map = &iter->second;
-
- return PlatformResult(ErrorCode::NO_ERROR);
-}
-
-PlatformResult Types::StringToPlatformEnum(const std::string& type, const std::string& value,
- int* platform_enum) {
- ScopeLogger();
-
- std::map<std::string, int> const* def = nullptr;
- PlatformResult result = GetPlatformEnumMap(type, &def);
- if (!result) {
- return result;
- }
-
- auto def_iter = def->find(value);
- if (def_iter != def->end()) {
- *platform_enum = def_iter->second;
- return PlatformResult(ErrorCode::NO_ERROR);
- }
-
- std::string message = "Platform enum value " + value + " not found for " + type;
- return LogAndCreateResult(ErrorCode::INVALID_VALUES_ERR, message);
-}
-
-PlatformResult Types::PlatformEnumToString(const std::string& type, int value,
- std::string* platform_str) {
- ScopeLogger();
-
- if (platform_enum_reverse_map_.empty()) {
- for (auto& def : platform_enum_map_) {
- platform_enum_reverse_map_[def.first] = {};
-
- for (auto& key : def.second) {
- platform_enum_reverse_map_[def.first][key.second] = key.first;
- }
- }
- }
-
- auto it = platform_enum_reverse_map_.find(type);
- if (it == platform_enum_reverse_map_.end()) {
- return LogAndCreateResult(ErrorCode::UNKNOWN_ERR,
- std::string("Undefined platform enum type ") + type);
- }
-
- auto def = platform_enum_reverse_map_.at(type);
- auto def_it = def.find(value);
- if (def_it != def.end()) {
- *platform_str = def_it->second;
- return PlatformResult(ErrorCode::NO_ERROR);
- }
-
- std::string message = "Platform enum value " + std::to_string(value) + " not found for " + type;
- return LogAndCreateResult(ErrorCode::INVALID_VALUES_ERR, message);
-}
-
-PlatformResult Types::ConvertPlaybackState(mc_playback_h playback_h, std::string* state) {
- ScopeLogger();
-
- int ret;
- mc_playback_states_e state_e;
- ret = mc_client_get_playback_state(playback_h, &state_e);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
- return LogAndCreateResult(
- ErrorCode::UNKNOWN_ERR, "Error getting playback state",
- ("mc_client_get_playback_state() error: %d, message: %s", ret, get_error_message(ret)));
- }
- if (state_e == MC_PLAYBACK_STATE_NONE) {
- state_e = MC_PLAYBACK_STATE_STOPPED;
- }
-
- PlatformResult result = Types::PlatformEnumToString(Types::kMediaControllerPlaybackState,
- static_cast<int>(state_e), state);
- if (!result) {
- LoggerE("PlatformEnumToString failed, error: %s", result.message().c_str());
- return result;
- }
-
- return PlatformResult(ErrorCode::NO_ERROR);
-}
-
-PlatformResult Types::ConvertContentAgeRating(mc_playback_h playback_h, std::string* rating) {
- ScopeLogger();
-
- mc_content_age_rating_e rating_e = MC_CONTENT_RATING_ALL;
- int ret = mc_client_get_age_rating(playback_h, &rating_e);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
- return LogAndCreateResult(
- ErrorCode::UNKNOWN_ERR, "Error getting content age rating",
- ("mc_client_get_age_rating() error: %d, message: %s", ret, get_error_message(ret)));
- }
-
- PlatformResult result = Types::PlatformEnumToString(Types::kMediaControllerContentAgeRating,
- static_cast<int>(rating_e), rating);
-
- if (!result) {
- LoggerE("PlatformEnumToString failed, error: %s", result.message().c_str());
- return result;
- }
-
- return PlatformResult(ErrorCode::NO_ERROR);
-}
-
-PlatformResult Types::ConvertPlaybackPosition(mc_playback_h playback_h, double* position) {
- ScopeLogger();
-
- int ret;
-
- unsigned long long pos;
- ret = mc_client_get_playback_position(playback_h, &pos);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
- return LogAndCreateResult(
- ErrorCode::UNKNOWN_ERR, "Error getting playback position",
- ("mc_client_get_playback_position() error: %d, message: %s", ret, get_error_message(ret)));
- }
-
- *position = static_cast<double>(pos);
-
- return PlatformResult(ErrorCode::NO_ERROR);
-}
-
-PlatformResult Types::ConvertMetadata(mc_metadata_h metadata_h, picojson::object* metadata) {
- ScopeLogger();
-
- std::map<std::string, int> const* metadata_fields = nullptr;
- PlatformResult result =
- GetPlatformEnumMap(Types::kMediaControllerMetadataAttribute, &metadata_fields);
- if (!result) {
- LoggerE("GetPlatformEnumMap failed, error: %s", result.message().c_str());
- return result;
- }
-
- char* value = nullptr;
- SCOPE_EXIT {
- free(value);
- };
-
- for (auto& field : *metadata_fields) {
- int ret = mc_metadata_get(metadata_h, static_cast<mc_meta_e>(field.second), &value);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
- return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Error getting metadata",
- ("mc_metadata_get(%s) error: %d, message: %s", field.first.c_str(),
- ret, get_error_message(ret)));
- }
-
- (*metadata)[field.first] = picojson::value(std::string(value ? value : ""));
- }
-
- return PlatformResult(ErrorCode::NO_ERROR);
-}
-
-} // namespace mediacontroller
-} // namespace extension
+++ /dev/null
-/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd All Rights Reserved
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef MEDIACONTROLLER_MEDIACONTROLLER_TYPES_H_
-#define MEDIACONTROLLER_MEDIACONTROLLER_TYPES_H_
-
-#include <media_controller_type.h>
-#include <functional>
-#include <map>
-#include <string>
-
-#include "common/platform_result.h"
-
-namespace extension {
-namespace mediacontroller {
-
-typedef std::map<std::string, std::map<std::string, int>> PlatformEnumMap;
-typedef std::map<std::string, std::map<int, std::string>> PlatformEnumReverseMap;
-typedef std::function<void(picojson::value*)> JsonCallback;
-
-class Types {
- public:
- static const std::string kMediaControllerServerState;
- static const std::string kMediaControllerPlaybackState;
- static const std::string kMediaControllerPlaybackAction;
- static const std::string kMediaControllerMetadataAttribute;
- static const std::string kMediaControllerRepeatState;
- static const std::string kMediaControllerContentAgeRating;
-
- static common::PlatformResult GetPlatformEnumMap(const std::string& type,
- std::map<std::string, int> const** platform_str);
-
- static common::PlatformResult StringToPlatformEnum(const std::string& type,
- const std::string& value, int* platform_enum);
-
- static common::PlatformResult PlatformEnumToString(const std::string& type, int value,
- std::string* platform_str);
-
- static common::PlatformResult ConvertPlaybackState(mc_playback_h playback_h, std::string* state);
- static common::PlatformResult ConvertContentAgeRating(mc_playback_h playback_h,
- std::string* state);
-
- static common::PlatformResult ConvertPlaybackPosition(mc_playback_h playback_h, double* position);
- static common::PlatformResult ConvertMetadata(mc_metadata_h metadata_h,
- picojson::object* metadata);
-
- private:
- static const PlatformEnumMap platform_enum_map_;
- static PlatformEnumReverseMap platform_enum_reverse_map_;
-};
-
-} // namespace mediacontroller
-} // namespace extension
-
-#endif // MEDIACONTROLLER_MEDIACONTROLLER_TYPES_H_
--- /dev/null
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "mediacontroller/mediacontroller_utils.h"
+
+#include <media_controller_client.h>
+
+#include "common/logger.h"
+#include "common/platform_result.h"
+#include "common/scope_exit.h"
+
+namespace extension {
+namespace mediacontroller {
+
+using common::PlatformResult;
+using common::ErrorCode;
+
+const std::string Types::kMediaControllerServerState = "MediaControllerServerState";
+const std::string Types::kMediaControllerPlaybackState = "MediaControllerPlaybackState";
+const std::string Types::kMediaControllerPlaybackAction = "MediaControllerPlaybackAction";
+const std::string Types::kMediaControllerMetadataAttribute = "MediaControllerMetadataAttribute";
+const std::string Types::kMediaControllerRepeatState = "MediaControllerRepeatState";
+const std::string Types::kMediaControllerContentAgeRating = "MediaControllerContentAgeRationg";
+
+const PlatformEnumMap Types::platform_enum_map_ = {
+ {kMediaControllerServerState,
+ {{"NONE", MC_SERVER_STATE_NONE},
+ {"ACTIVE", MC_SERVER_STATE_ACTIVATE},
+ {"INACTIVE", MC_SERVER_STATE_DEACTIVATE}}},
+ {kMediaControllerPlaybackState,
+ {{"PLAY", MC_PLAYBACK_STATE_PLAYING},
+ {"PAUSE", MC_PLAYBACK_STATE_PAUSED},
+ {"STOP", MC_PLAYBACK_STATE_STOPPED},
+ {"NEXT", MC_PLAYBACK_STATE_MOVING_TO_NEXT},
+ {"PREV", MC_PLAYBACK_STATE_MOVING_TO_PREVIOUS},
+ {"FORWARD", MC_PLAYBACK_STATE_FAST_FORWARDING},
+ {"REWIND", MC_PLAYBACK_STATE_REWINDING}}},
+ {kMediaControllerPlaybackAction,
+ {{"PLAY", MC_PLAYBACK_ACTION_PLAY},
+ {"PAUSE", MC_PLAYBACK_ACTION_PAUSE},
+ {"STOP", MC_PLAYBACK_ACTION_STOP},
+ {"NEXT", MC_PLAYBACK_ACTION_NEXT},
+ {"PREV", MC_PLAYBACK_ACTION_PREV},
+ {"FORWARD", MC_PLAYBACK_ACTION_FAST_FORWARD},
+ {"REWIND", MC_PLAYBACK_ACTION_REWIND}}},
+ {kMediaControllerMetadataAttribute,
+ {{"title", MC_META_MEDIA_TITLE},
+ {"artist", MC_META_MEDIA_ARTIST},
+ {"album", MC_META_MEDIA_ALBUM},
+ {"author", MC_META_MEDIA_AUTHOR},
+ {"genre", MC_META_MEDIA_GENRE},
+ {"duration", MC_META_MEDIA_DURATION},
+ {"date", MC_META_MEDIA_DATE},
+ {"copyright", MC_META_MEDIA_COPYRIGHT},
+ {"description", MC_META_MEDIA_DESCRIPTION},
+ {"trackNum", MC_META_MEDIA_TRACK_NUM},
+ {"picture", MC_META_MEDIA_PICTURE}}},
+ {kMediaControllerRepeatState,
+ {{"REPEAT_OFF", MC_REPEAT_MODE_OFF},
+ {"REPEAT_ONE", MC_REPEAT_MODE_ONE_MEDIA},
+ {"REPEAT_ALL", MC_REPEAT_MODE_ON}}},
+ {kMediaControllerContentAgeRating,
+ {
+ {"ALL", MC_CONTENT_RATING_ALL}, {"1", MC_CONTENT_RATING_1_PLUS},
+ {"2", MC_CONTENT_RATING_2_PLUS}, {"3", MC_CONTENT_RATING_3_PLUS},
+ {"4", MC_CONTENT_RATING_4_PLUS}, {"5", MC_CONTENT_RATING_5_PLUS},
+ {"6", MC_CONTENT_RATING_6_PLUS}, {"7", MC_CONTENT_RATING_7_PLUS},
+ {"8", MC_CONTENT_RATING_8_PLUS}, {"9", MC_CONTENT_RATING_9_PLUS},
+ {"10", MC_CONTENT_RATING_10_PLUS}, {"11", MC_CONTENT_RATING_11_PLUS},
+ {"12", MC_CONTENT_RATING_12_PLUS}, {"13", MC_CONTENT_RATING_13_PLUS},
+ {"14", MC_CONTENT_RATING_14_PLUS}, {"15", MC_CONTENT_RATING_15_PLUS},
+ {"16", MC_CONTENT_RATING_16_PLUS}, {"17", MC_CONTENT_RATING_17_PLUS},
+ {"18", MC_CONTENT_RATING_18_PLUS}, {"19", MC_CONTENT_RATING_19_PLUS},
+ }}};
+
+PlatformEnumReverseMap Types::platform_enum_reverse_map_ = {};
+
+PlatformResult Types::GetPlatformEnumMap(const std::string& type,
+ std::map<std::string, int> const** enum_map) {
+ ScopeLogger();
+
+ auto iter = platform_enum_map_.find(type);
+ if (iter == platform_enum_map_.end()) {
+ return LogAndCreateResult(ErrorCode::UNKNOWN_ERR,
+ std::string("Undefined platform enum type ") + type);
+ }
+
+ *enum_map = &iter->second;
+
+ return PlatformResult(ErrorCode::NO_ERROR);
+}
+
+PlatformResult Types::StringToPlatformEnum(const std::string& type, const std::string& value,
+ int* platform_enum) {
+ ScopeLogger();
+
+ std::map<std::string, int> const* def = nullptr;
+ PlatformResult result = GetPlatformEnumMap(type, &def);
+ if (!result) {
+ return result;
+ }
+
+ auto def_iter = def->find(value);
+ if (def_iter != def->end()) {
+ *platform_enum = def_iter->second;
+ return PlatformResult(ErrorCode::NO_ERROR);
+ }
+
+ std::string message = "Platform enum value " + value + " not found for " + type;
+ return LogAndCreateResult(ErrorCode::INVALID_VALUES_ERR, message);
+}
+
+PlatformResult Types::PlatformEnumToString(const std::string& type, int value,
+ std::string* platform_str) {
+ ScopeLogger();
+
+ if (platform_enum_reverse_map_.empty()) {
+ for (auto& def : platform_enum_map_) {
+ platform_enum_reverse_map_[def.first] = {};
+
+ for (auto& key : def.second) {
+ platform_enum_reverse_map_[def.first][key.second] = key.first;
+ }
+ }
+ }
+
+ auto it = platform_enum_reverse_map_.find(type);
+ if (it == platform_enum_reverse_map_.end()) {
+ return LogAndCreateResult(ErrorCode::UNKNOWN_ERR,
+ std::string("Undefined platform enum type ") + type);
+ }
+
+ auto def = platform_enum_reverse_map_.at(type);
+ auto def_it = def.find(value);
+ if (def_it != def.end()) {
+ *platform_str = def_it->second;
+ return PlatformResult(ErrorCode::NO_ERROR);
+ }
+
+ std::string message = "Platform enum value " + std::to_string(value) + " not found for " + type;
+ return LogAndCreateResult(ErrorCode::INVALID_VALUES_ERR, message);
+}
+
+PlatformResult Types::ConvertPlaybackState(mc_playback_h playback_h, std::string* state) {
+ ScopeLogger();
+
+ int ret;
+ mc_playback_states_e state_e;
+ ret = mc_client_get_playback_state(playback_h, &state_e);
+ if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
+ return LogAndCreateResult(
+ ErrorCode::UNKNOWN_ERR, "Error getting playback state",
+ ("mc_client_get_playback_state() error: %d, message: %s", ret, get_error_message(ret)));
+ }
+ if (state_e == MC_PLAYBACK_STATE_NONE) {
+ state_e = MC_PLAYBACK_STATE_STOPPED;
+ }
+
+ PlatformResult result = Types::PlatformEnumToString(Types::kMediaControllerPlaybackState,
+ static_cast<int>(state_e), state);
+ if (!result) {
+ LoggerE("PlatformEnumToString failed, error: %s", result.message().c_str());
+ return result;
+ }
+
+ return PlatformResult(ErrorCode::NO_ERROR);
+}
+
+PlatformResult Types::ConvertContentAgeRating(mc_playback_h playback_h, std::string* rating) {
+ ScopeLogger();
+
+ mc_content_age_rating_e rating_e = MC_CONTENT_RATING_ALL;
+ int ret = mc_client_get_age_rating(playback_h, &rating_e);
+ if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
+ return LogAndCreateResult(
+ ErrorCode::UNKNOWN_ERR, "Error getting content age rating",
+ ("mc_client_get_age_rating() error: %d, message: %s", ret, get_error_message(ret)));
+ }
+
+ PlatformResult result = Types::PlatformEnumToString(Types::kMediaControllerContentAgeRating,
+ static_cast<int>(rating_e), rating);
+
+ if (!result) {
+ LoggerE("PlatformEnumToString failed, error: %s", result.message().c_str());
+ return result;
+ }
+
+ return PlatformResult(ErrorCode::NO_ERROR);
+}
+
+PlatformResult Types::ConvertPlaybackPosition(mc_playback_h playback_h, double* position) {
+ ScopeLogger();
+
+ int ret;
+
+ unsigned long long pos;
+ ret = mc_client_get_playback_position(playback_h, &pos);
+ if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
+ return LogAndCreateResult(
+ ErrorCode::UNKNOWN_ERR, "Error getting playback position",
+ ("mc_client_get_playback_position() error: %d, message: %s", ret, get_error_message(ret)));
+ }
+
+ *position = static_cast<double>(pos);
+
+ return PlatformResult(ErrorCode::NO_ERROR);
+}
+
+PlatformResult Types::ConvertMetadata(mc_metadata_h metadata_h, picojson::object* metadata) {
+ ScopeLogger();
+
+ std::map<std::string, int> const* metadata_fields = nullptr;
+ PlatformResult result =
+ GetPlatformEnumMap(Types::kMediaControllerMetadataAttribute, &metadata_fields);
+ if (!result) {
+ LoggerE("GetPlatformEnumMap failed, error: %s", result.message().c_str());
+ return result;
+ }
+
+ char* value = nullptr;
+ SCOPE_EXIT {
+ free(value);
+ };
+
+ for (auto& field : *metadata_fields) {
+ int ret = mc_metadata_get(metadata_h, static_cast<mc_meta_e>(field.second), &value);
+ if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
+ return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Error getting metadata",
+ ("mc_metadata_get(%s) error: %d, message: %s", field.first.c_str(),
+ ret, get_error_message(ret)));
+ }
+
+ (*metadata)[field.first] = picojson::value(std::string(value ? value : ""));
+ }
+
+ return PlatformResult(ErrorCode::NO_ERROR);
+}
+
+PlatformResult utils::GetAllPlaylists(const std::string& app_id, picojson::array* 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<picojson::array*>(user_data);
+
+ picojson::value value = picojson::value(picojson::object());
+ picojson::object& obj = value.get<picojson::object>();
+
+ obj.insert(std::make_pair("name", picojson::value{name}));
+ playlists->push_back(value);
+
+ 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);
+}
+
+} // namespace mediacontroller
+} // namespace extension
--- /dev/null
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef MEDIACONTROLLER_MEDIACONTROLLER_UTILS_H_
+#define MEDIACONTROLLER_MEDIACONTROLLER_UTILS_H_
+
+#include <media_controller_type.h>
+#include <functional>
+#include <map>
+#include <string>
+
+#include "common/platform_result.h"
+
+namespace extension {
+namespace mediacontroller {
+
+typedef std::map<std::string, std::map<std::string, int>> PlatformEnumMap;
+typedef std::map<std::string, std::map<int, std::string>> PlatformEnumReverseMap;
+typedef std::function<void(picojson::value*)> JsonCallback;
+
+class Types {
+ public:
+ static const std::string kMediaControllerServerState;
+ static const std::string kMediaControllerPlaybackState;
+ static const std::string kMediaControllerPlaybackAction;
+ static const std::string kMediaControllerMetadataAttribute;
+ static const std::string kMediaControllerRepeatState;
+ static const std::string kMediaControllerContentAgeRating;
+
+ static common::PlatformResult GetPlatformEnumMap(const std::string& type,
+ std::map<std::string, int> const** platform_str);
+
+ static common::PlatformResult StringToPlatformEnum(const std::string& type,
+ const std::string& value, int* platform_enum);
+
+ static common::PlatformResult PlatformEnumToString(const std::string& type, int value,
+ std::string* platform_str);
+
+ static common::PlatformResult ConvertPlaybackState(mc_playback_h playback_h, std::string* state);
+ static common::PlatformResult ConvertContentAgeRating(mc_playback_h playback_h,
+ std::string* state);
+
+ static common::PlatformResult ConvertPlaybackPosition(mc_playback_h playback_h, double* position);
+ static common::PlatformResult ConvertMetadata(mc_metadata_h metadata_h,
+ picojson::object* metadata);
+
+ private:
+ static const PlatformEnumMap platform_enum_map_;
+ static PlatformEnumReverseMap platform_enum_reverse_map_;
+};
+
+namespace utils {
+common::PlatformResult GetAllPlaylists(const std::string& app_id, picojson::array* playlists);
+}
+
+} // namespace mediacontroller
+} // namespace extension
+
+#endif // MEDIACONTROLLER_MEDIACONTROLLER_UTILS_H_
projects / platform / core / api / webapi-plugins.git / commitdiff