From: Rafal Walczyna Date: Fri, 13 Sep 2019 13:23:21 +0000 (+0200) Subject: [Mediacontroller] added display rotation feature X-Git-Tag: submit/tizen/20190919.123326~3 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=refs%2Fchanges%2F28%2F213828%2F13;p=platform%2Fcore%2Fapi%2Fwebapi-plugins.git [Mediacontroller] added display rotation feature [Verification] Code compiles without errors. Basic test in chrome console works properly. /// 1. adding command listener var mcServer = tizen.mediacontroller.createServer(); mcServer.updatePlaybackState("PLAY"); var changeListener = function(clientName, rotation) { console.log("Display rotation change requested to: " + rotation + " by " + clientName); return new tizen.mediacontroller.RequestReply(new tizen.Bundle({"message": "Success"}), 0); }; watcherId = mcServer.displayRotation.addChangeRequestListener(changeListener); /// 2. checking NotSupportedError when sending without enabled ability var mcClient = tizen.mediacontroller.getClient(); var mcServerInfo = mcClient.getLatestServerInfo() var rotation = "ROTATION_180"; mcServerInfo.displayRotation.sendRequest(rotation, function(data, code) { console.log( "Server replied with return data: " + JSON.stringify(data) + " and code: " + code); }); /// 3. register listener for mode changes (client side) watcherId = mcServerInfo.displayRotation.addDisplayRotationChangeListener(function(rotation) { console.log(mcServerInfo.name + " server display rotation changed to " + rotation); }); /// 4. change the value of mode 360 (should trigger listener from point 3) mcServer.displayRotation.displayRotation = "ROTATION_180" /// 5. enable ability of server // TODO: mcServer.abilities.displayRotation = "?" /// sendRequest again (should trigger listener from point 1) mcServerInfo.displayRotation.sendRequest(rotation, function(data, code) { console.log( "Server replied with return data: " + JSON.stringify(data) + " and code: " + code); }); Change-Id: I9c497dbaaf5e7f491c2d57c568e52581c980951d Signed-off-by: Rafal Walczyna --- diff --git a/src/mediacontroller/mediacontroller_api.js b/src/mediacontroller/mediacontroller_api.js index 3fbf321f..06ef8eec 100755 --- a/src/mediacontroller/mediacontroller_api.js +++ b/src/mediacontroller/mediacontroller_api.js @@ -369,6 +369,13 @@ var MediaControllerDisplayModeType = { CROPPED_FULL: 'CROPPED_FULL' }; +var MediaControllerDisplayRotationType = { + ROTATION_NONE: 'ROTATION_NONE', + ROTATION_90: 'ROTATION_90', + ROTATION_180: 'ROTATION_180', + ROTATION_270: 'ROTATION_270' +}; + function MediaControllerManager() {} MediaControllerManager.prototype.getClient = function() { @@ -1614,9 +1621,213 @@ var MediaControllerDisplayModeInfo = function(name) { }; }; -// TODO displayRotation -var MediaControllerDisplayRotation = function() {}; -var MediaControllerDisplayRotationInfo = function() {}; +// displayRotation +var MediaControllerDisplayRotation = function() { + // the default value is "ROTATION_NONE" + var _displayRotation = MediaControllerDisplayRotationType.ROTATION_NONE; + Object.defineProperties(this, { + displayRotation: { + get: function() { + return _displayRotation; + }, + set: function(v) { + var args = validator_.validateArgs(arguments, [ + { + name: 'displayRotation', + type: types_.ENUM, + values: Object.keys(MediaControllerDisplayRotationType) + } + ]); + if (args.displayRotation == _displayRotation) { + return; + } + var result = native_.callSync( + 'MediaControllerDisplayRotation_updateDisplayRotation', + args + ); + if (native_.isFailure(result)) { + throw native_.getErrorObject(result); + } + _displayRotation = args.displayRotation; + }, + enumerable: true + } + }); +}; + +var MediaControllerDisplayRotationListener = new ListenerManager( + native_, + '_MediaControllerDisplayRotationListener', + function(msg, listener) { + var reply = listener(msg.clientName, msg.displayRotation); + + if (!(reply instanceof RequestReply)) { + reply = new RequestReply(type_.isNullOrUndefined(reply) ? null : reply, 0); + } + + var nativeData = { + clientName: msg.clientName, + requestId: msg.requestId, + reply: reply + }; + var result = native_.callSync('MediaControllerServer_replyCommand', nativeData); + if (native_.isFailure(result)) { + throw native_.getErrorObject(result); + } + } +); + +MediaControllerDisplayRotation.prototype.addChangeRequestListener = function() { + var args = validator_.validateArgs(arguments, [ + { + name: 'listener', + type: types_.FUNCTION, + optional: false, + nullable: false + } + ]); + + if (type_.isEmptyObject(MediaControllerDisplayRotationListener.listeners)) { + var result = native_.callSync( + 'MediaControllerDisplayRotation_addChangeRequestListener', + { + listenerId: MediaControllerDisplayRotationListener.listenerName + } + ); + if (native_.isFailure(result)) { + throw native_.getErrorObject(result); + } + } + return MediaControllerDisplayRotationListener.addListener(args.listener); +}; + +MediaControllerDisplayRotation.prototype.removeChangeRequestListener = function(watchId) { + var args = validator_.validateArgs(arguments, [ + { name: 'watchId', type: types_.LONG } + ]); + + MediaControllerDisplayRotationListener.removeListener(args.watchId); + + if (type_.isEmptyObject(MediaControllerDisplayRotationListener.listeners)) { + var result = native_.callSync( + 'MediaControllerDisplayRotation_removeChangeRequestListener' + ); + if (native_.isFailure(result)) { + throw native_.getErrorObject(result); + } + } +}; + +var MediaControllerDisplayRotationChangeListener = new ListenerManager( + native_, + '_MediaControllerDisplayRotationChangeListener', + function(msg, listener) { + listener(msg.displayRotation); + } +); + +var MediaControllerDisplayRotationInfo = function(name) { + var _serverName = name; + Object.defineProperties(this, { + displayRotation: { + get: function() { + var result = native_.callSync( + 'MediaControllerDisplayRotationInfo_getDisplayRotation', + { + name: _serverName + } + ); + if (native_.isFailure(result)) { + throw new native_.getErrorObject(result); + } + return native_.getResultObject(result); + }, + set: function(v) {}, + enumerable: true + } + }); + + this.sendRequest = function() { + var args = validator_.validateArgs(arguments, [ + { + name: 'displayRotation', + type: types_.ENUM, + values: Object.keys(MediaControllerDisplayRotationType) + }, + { + name: 'replyCallback', + type: types_.FUNCTION, + optional: false, + nullable: false + } + ]); + var callback = function(result) { + native_.callIfPossible( + args.replyCallback, + native_.getResultObject(result).data, + native_.getResultObject(result).code + ); + }; + + var nativeData = { + displayRotation: args.displayRotation, + name: _serverName, + listenerId: ReplyCommandListener.listenerName + }; + + var result = native_.callSync( + 'MediaControllerDisplayRotationInfo_sendRequest', + nativeData + ); + if (native_.isFailure(result)) { + throw native_.getErrorObject(result); + } + + var replyListenerId = ReplyCommandListener.addListener(callback); + ReplyCommandListener.requestIdToListenerId[replyListenerId] = result.requestId; + }; + + this.addDisplayRotationChangeListener = function(listener) { + var args = validator_.validateArgs(arguments, [ + { name: 'listener', type: types_.FUNCTION } + ]); + + if (type_.isEmptyObject(MediaControllerDisplayRotationChangeListener.listeners)) { + var result = native_.callSync( + 'MediaControllerDisplayRotationInfo_addDisplayRotationChangeListener', + { + listenerId: MediaControllerDisplayRotationChangeListener.listenerName + } + ); + if (native_.isFailure(result)) { + throw native_.getErrorObject(result); + } + } + return MediaControllerDisplayRotationChangeListener.addServerInfoListener( + args.listener, + _serverName + ); + }; + + this.removeDisplayRotationChangeListener = function(watchId) { + var args = validator_.validateArgs(arguments, [ + { name: 'watchId', type: types_.LONG } + ]); + + MediaControllerDisplayRotationChangeListener.removeServerInfoListener( + args.watchId + ); + + if (type_.isEmptyObject(MediaControllerDisplayRotationChangeListener.listeners)) { + var result = native_.callSync( + 'MediaControllerDisplayRotationInfo_removeDisplayRotationChangeListener' + ); + if (native_.isFailure(result)) { + throw native_.getErrorObject(result); + } + } + }; +}; function MediaControllerServer(data) { var _iconURI = null; @@ -2544,7 +2755,7 @@ function MediaControllerServerInfo(data) { writable: false }, displayRotation: { - value: new MediaControllerDisplayRotationInfo(), + value: new MediaControllerDisplayRotationInfo(data.name), enumerable: true, writable: false } diff --git a/src/mediacontroller/mediacontroller_client.cc b/src/mediacontroller/mediacontroller_client.cc index 2f3e7c5e..2a42739e 100644 --- a/src/mediacontroller/mediacontroller_client.cc +++ b/src/mediacontroller/mediacontroller_client.cc @@ -75,6 +75,10 @@ MediaControllerClient::~MediaControllerClient() { LoggerE("Failed to unset display mode listener"); } + if (nullptr != display_rotation_update_listener && !UnsetDisplayRotationInfoChangeListener()) { + LoggerE("Failed to unset display rotation listener"); + } + if (nullptr != handle_ && MEDIA_CONTROLLER_ERROR_NONE != mc_client_destroy(handle_)) { LoggerE("Unable to destroy media controller client"); } @@ -1404,7 +1408,112 @@ void MediaControllerClient::OnDisplayModeUpdate(const char* server_name, mc_disp client->display_mode_update_listener_(&data); } -// TODO displayRotation +// displayRotation +PlatformResult MediaControllerClient::GetDisplayRotation(const std::string& name, + std::string* display_rotation) { + ScopeLogger(); + mc_display_rotation_e rotation = MC_DISPLAY_ROTATION_NONE; + + int ret = mc_client_get_server_display_rotation(handle_, name.c_str(), &rotation); + if (MEDIA_CONTROLLER_ERROR_NONE != ret) { + return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Error getting display rotation", + ("mc_client_get_server_display_rotation() error: %d, message: %s", + ret, get_error_message(ret))); + } + + PlatformResult result = + types::MediaControllerDisplayRotationEnum.getName(rotation, display_rotation); + if (!result) { + LoggerE("MediaControllerDisplayRotationEnum.getName() failed, error: %s", + result.message().c_str()); + return PlatformResult(ErrorCode::UNKNOWN_ERR); + } + return PlatformResult(ErrorCode::NO_ERROR); +} + +PlatformResult MediaControllerClient::SendDisplayRotation(const std::string& server_name, + const std::string& display_rotation, + const JsonCallback& reply_cb, + char** request_id) { + ScopeLogger("Rotation to send: %s", display_rotation.c_str()); + mc_display_rotation_e rotation = MC_DISPLAY_ROTATION_NONE; + PlatformResult result = + types::MediaControllerDisplayRotationEnum.getValue(display_rotation, &rotation); + if (!result) { + LoggerE("MediaControllerDisplayRotationEnum.getValue() failed, error: %s", + result.message().c_str()); + return PlatformResult(ErrorCode::UNKNOWN_ERR); + } + + int ret = mc_client_send_display_rotation_cmd(handle_, server_name.c_str(), rotation, request_id); + if (MEDIA_CONTROLLER_ERROR_NONE != ret) { + return LogAndCreateResult(utils::ConvertMediaControllerError(ret), + "Error sending display rotation command", + ("mc_client_send_display_rotation_cmd() error: %d, message: %s", ret, + get_error_message(ret))); + } + + command_reply_callback_ = reply_cb; + return PlatformResult(ErrorCode::NO_ERROR); +} + +PlatformResult MediaControllerClient::SetDisplayRotationInfoChangeListener( + const JsonCallback& callback) { + ScopeLogger(); + + if (nullptr != display_rotation_update_listener) { + LoggerD("Native callback already set"); + return PlatformResult(ErrorCode::NO_ERROR); + } + + int ret = mc_client_set_display_rotation_updated_cb(handle_, OnDisplayRotationUpdate, this); + if (MEDIA_CONTROLLER_ERROR_NONE != ret) { + return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Unable to set display rotation listener", + ("mc_client_set_display_rotation_updated_cb() error: %d, message: %s", + ret, get_error_message(ret))); + } + + display_rotation_update_listener = callback; + + return PlatformResult(ErrorCode::NO_ERROR); +} + +PlatformResult MediaControllerClient::UnsetDisplayRotationInfoChangeListener() { + ScopeLogger(); + int ret = mc_client_unset_display_rotation_updated_cb(handle_); + if (MEDIA_CONTROLLER_ERROR_NONE != ret) { + return LogAndCreateResult( + ErrorCode::UNKNOWN_ERR, "Unable to unset display rotation listener", + ("mc_client_unset_display_rotation_updated_cb() error: %d, message: %s", ret, + get_error_message(ret))); + } + display_rotation_update_listener = nullptr; + return PlatformResult(ErrorCode::NO_ERROR); +} + +void MediaControllerClient::OnDisplayRotationUpdate(const char* server_name, + mc_display_rotation_e rotation, + void* user_data) { + ScopeLogger(); + MediaControllerClient* client = static_cast(user_data); + + picojson::value data = picojson::value(picojson::object()); + picojson::object& data_o = data.get(); + + std::string display_rotation; + PlatformResult result = + types::MediaControllerDisplayRotationEnum.getName(rotation, &display_rotation); + if (!result) { + LoggerW("MediaControllerDisplayRotationEnum.getName() failed, error: %s, ignoring event", + result.message().c_str()); + return; + } + + data_o["displayRotation"] = picojson::value(display_rotation); + data_o["name"] = picojson::value(server_name); + + client->display_rotation_update_listener(&data); +} } // namespace mediacontroller } // namespace extension diff --git a/src/mediacontroller/mediacontroller_client.h b/src/mediacontroller/mediacontroller_client.h index b3d245a8..a7420de5 100644 --- a/src/mediacontroller/mediacontroller_client.h +++ b/src/mediacontroller/mediacontroller_client.h @@ -92,7 +92,13 @@ class MediaControllerClient { char** request_id); common::PlatformResult SetDisplayModeInfoChangeListener(const JsonCallback& callback); common::PlatformResult UnsetDisplayModeInfoChangeListener(); - // TODO displayRotation + // displayRotation + common::PlatformResult GetDisplayRotation(const std::string& name, std::string* display_rotation); + common::PlatformResult SendDisplayRotation(const std::string& server_name, + const std::string& display_rotation, + const JsonCallback& reply_cb, char** request_id); + common::PlatformResult SetDisplayRotationInfoChangeListener(const JsonCallback& callback); + common::PlatformResult UnsetDisplayRotationInfoChangeListener(); private: mc_client_h handle_; @@ -108,6 +114,8 @@ class MediaControllerClient { JsonCallback mode360_update_listener_; // display mode JsonCallback display_mode_update_listener_; + // displayRotation + JsonCallback display_rotation_update_listener; std::list subscribed_servers; @@ -133,7 +141,9 @@ class MediaControllerClient { static void OnMode360Update(const char* server_name, bool enabled, void* user_data); // displayMode static void OnDisplayModeUpdate(const char* server_name, mc_display_mode_e mode, void* user_data); - // TODO displayRotation + // displayRotation + static void OnDisplayRotationUpdate(const char* server_name, mc_display_rotation_e rotation, + void* user_data); }; } // namespace mediacontroller diff --git a/src/mediacontroller/mediacontroller_instance.cc b/src/mediacontroller/mediacontroller_instance.cc index cc0a770d..1a9899d9 100644 --- a/src/mediacontroller/mediacontroller_instance.cc +++ b/src/mediacontroller/mediacontroller_instance.cc @@ -196,7 +196,22 @@ MediaControllerInstance::MediaControllerInstance() { REGISTER_SYNC("MediaControllerDisplayModeInfo_removeModeChangeListener", MediaControllerDisplayModeInfoRemoveModeChangeListener); -// TODO displayRotation + // displayRotation + REGISTER_SYNC("MediaControllerDisplayRotation_updateDisplayRotation", + MediaControllerDisplayRotationUpdate); + REGISTER_SYNC("MediaControllerDisplayRotation_addChangeRequestListener", + MediaControllerDisplayRotationAddChangeRequestListener); + REGISTER_SYNC("MediaControllerDisplayRotation_removeChangeRequestListener", + MediaControllerDisplayRotationRemoveChangeRequestListener); + + REGISTER_SYNC("MediaControllerDisplayRotationInfo_getDisplayRotation", + MediaControllerDisplayRotationInfoGet); + REGISTER_ASYNC("MediaControllerDisplayRotationInfo_sendRequest", + MediaControllerDisplayRotationInfoSend); + REGISTER_SYNC("MediaControllerDisplayRotationInfo_addDisplayRotationChangeListener", + MediaControllerDisplayRotationInfoAddChangeListener); + REGISTER_SYNC("MediaControllerDisplayRotationInfo_removeDisplayRotationChangeListener", + MediaControllerDisplayRotationInfoRemoveChangeListener); #undef REGISTER_SYNC #undef REGISTER_ASYNC @@ -2167,7 +2182,188 @@ void MediaControllerInstance::MediaControllerDisplayModeInfoRemoveModeChangeList ReportSuccess(out); } -// TODO displayRotation +// displayRotation +void MediaControllerInstance::MediaControllerDisplayRotationUpdate(const picojson::value& args, + picojson::object& out) { + ScopeLogger(); + + if (!server_) { + LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occurred."), &out, + ("Failed: server_")); + return; + } + + CHECK_ARGS(args, "displayRotation", std::string, out) + + const std::string display_rotation = args.get("displayRotation").get(); + PlatformResult result = server_->UpdateDisplayRotation(display_rotation); + if (!result) { + LogAndReportError(result, &out, ("Failed server_->UpdateDisplayRotation()")); + return; + } + ReportSuccess(out); +} + +void MediaControllerInstance::MediaControllerDisplayRotationAddChangeRequestListener( + const picojson::value& args, picojson::object& out) { + ScopeLogger(); + if (!server_) { + LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occurred."), &out, + ("Failed: server_")); + return; + } + + CHECK_ARGS(args, "listenerId", std::string, out) + + JsonCallback callback = [this, args](picojson::value* data) -> void { + if (!data) { + LoggerE("No data passed to json callback"); + return; + } + picojson::object& request_o = data->get(); + request_o["listenerId"] = args.get("listenerId"); + + Instance::PostMessage(this, data->serialize().c_str()); + }; + + auto result = server_->SetDisplayRotationChangeRequestListener(callback); + if (!result) { + LogAndReportError(result, &out); + return; + } + + ReportSuccess(out); +} + +void MediaControllerInstance::MediaControllerDisplayRotationRemoveChangeRequestListener( + const picojson::value& args, picojson::object& out) { + ScopeLogger(); + if (!server_) { + LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occurred."), &out, + ("Failed: server_")); + return; + } + + auto result = server_->UnsetDisplayRotationChangeRequestListener(); + if (!result) { + LogAndReportError(result, &out); + return; + } + ReportSuccess(out); +} + +void MediaControllerInstance::MediaControllerDisplayRotationInfoGet(const picojson::value& args, + picojson::object& out) { + ScopeLogger(); + if (!client_) { + LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occurred."), &out, + ("Failed: client_")); + return; + } + + CHECK_ARGS(args, "name", std::string, out) + + std::string rotation; + PlatformResult result = + client_->GetDisplayRotation(args.get("name").get(), &rotation); + + if (!result) { + LogAndReportError(result, &out, ("Failed: client_->GetDisplayRotation")); + return; + } + + ReportSuccess(picojson::value(rotation), out); +} + +void MediaControllerInstance::MediaControllerDisplayRotationInfoSend(const picojson::value& args, + picojson::object& out) { + ScopeLogger(); + if (!client_) { + LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occurred."), &out, + ("Failed: client_")); + return; + } + + CHECK_ARGS(args, "listenerId", std::string, out) + CHECK_ARGS(args, "name", std::string, out) + CHECK_ARGS(args, "displayRotation", std::string, out) + + JsonCallback reply_cb = [this, args](picojson::value* reply) -> void { + if (reply) { + picojson::object& reply_obj = reply->get(); + reply_obj["listenerId"] = args.get("listenerId"); + Instance::PostMessage(this, reply->serialize().c_str()); + } else { + LoggerW("No reply passed to json callback, ignoring"); + } + }; + + char* request_id = nullptr; + SCOPE_EXIT { + free(request_id); + }; + + PlatformResult result = client_->SendDisplayRotation( + args.get("name").get(), args.get("displayRotation").get(), reply_cb, + &request_id); + + if (result) { + ReportSuccess(out); + out["requestId"] = picojson::value(std::string(request_id)); + } else { + LogAndReportError(result, &out, ("Failed to send display rotation command.")); + } +} + +void MediaControllerInstance::MediaControllerDisplayRotationInfoAddChangeListener( + const picojson::value& args, picojson::object& out) { + ScopeLogger(); + if (!client_) { + LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occured."), &out, + ("Failed: client_")); + return; + } + + CHECK_ARGS(args, "listenerId", std::string, out) + + JsonCallback callback = [this, args](picojson::value* data) -> void { + if (nullptr == data) { + LoggerE("No data passed to json callback"); + return; + } + + picojson::object& request_o = data->get(); + request_o["listenerId"] = args.get("listenerId"); + + Instance::PostMessage(this, data->serialize().c_str()); + }; + + auto result = client_->SetDisplayRotationInfoChangeListener(callback); + if (!result) { + LogAndReportError(result, &out); + return; + } + + ReportSuccess(out); +} + +void MediaControllerInstance::MediaControllerDisplayRotationInfoRemoveChangeListener( + const picojson::value& args, picojson::object& out) { + ScopeLogger(); + if (!client_) { + LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occured."), &out, + ("Failed: client_")); + return; + } + + auto result = client_->UnsetDisplayRotationInfoChangeListener(); + if (!result) { + LogAndReportError(result, &out); + return; + } + + ReportSuccess(out); +} #undef CHECK_EXIST diff --git a/src/mediacontroller/mediacontroller_instance.h b/src/mediacontroller/mediacontroller_instance.h index bfd41055..0c9e3e88 100644 --- a/src/mediacontroller/mediacontroller_instance.h +++ b/src/mediacontroller/mediacontroller_instance.h @@ -157,7 +157,19 @@ class MediaControllerInstance : public common::ParsedInstance { picojson::object& out); void MediaControllerDisplayModeInfoRemoveModeChangeListener(const picojson::value& args, picojson::object& out); - // TODO displayRotation + + // displayRotation + void MediaControllerDisplayRotationUpdate(const picojson::value& args, picojson::object& out); + void MediaControllerDisplayRotationAddChangeRequestListener(const picojson::value& args, + picojson::object& out); + void MediaControllerDisplayRotationRemoveChangeRequestListener(const picojson::value& args, + picojson::object& out); + void MediaControllerDisplayRotationInfoGet(const picojson::value& args, picojson::object& out); + void MediaControllerDisplayRotationInfoSend(const picojson::value& args, picojson::object& out); + void MediaControllerDisplayRotationInfoAddChangeListener(const picojson::value& args, + picojson::object& out); + void MediaControllerDisplayRotationInfoRemoveChangeListener(const picojson::value& args, + picojson::object& out); std::shared_ptr client_; std::shared_ptr server_; diff --git a/src/mediacontroller/mediacontroller_server.cc b/src/mediacontroller/mediacontroller_server.cc index 989c92be..353a5093 100644 --- a/src/mediacontroller/mediacontroller_server.cc +++ b/src/mediacontroller/mediacontroller_server.cc @@ -73,6 +73,11 @@ MediaControllerServer::~MediaControllerServer() { LoggerE("Failed to unset display mode request listener"); } + if (nullptr != display_rotation_change_request_listener_ && + !UnsetDisplayRotationChangeRequestListener()) { + LoggerE("Failed to unset display rotation 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()); @@ -1256,7 +1261,85 @@ PlatformResult MediaControllerServer::UnsetDisplayModeChangeRequestListener() { return PlatformResult(ErrorCode::NO_ERROR); } -// TODO displayRotation +// displayRotation +PlatformResult MediaControllerServer::UpdateDisplayRotation(const std::string& display_rotation) { + ScopeLogger(); + mc_display_rotation_e rotation = MC_DISPLAY_ROTATION_NONE; + PlatformResult result = + types::MediaControllerDisplayRotationEnum.getValue(display_rotation, &rotation); + if (!result) { + LoggerE("MediaControllerDisplayRotationEnum.getValue() failed, error: %s", + result.message().c_str()); + return PlatformResult(ErrorCode::UNKNOWN_ERR); + } + + int ret = mc_server_update_display_rotation(handle_, rotation); + if (MEDIA_CONTROLLER_ERROR_NONE != ret) { + return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Error setting server display rotation", + ("mc_server_update_display_rotation() error: %d, message: %s", ret, + get_error_message(ret))); + } + return PlatformResult(ErrorCode::NO_ERROR); +} + +void MediaControllerServer::OnDisplayRotationChangeCommand(const char* client_name, + const char* request_id, + mc_display_rotation_e rotation, + void* user_data) { + ScopeLogger(); + + MediaControllerServer* server = static_cast(user_data); + + std::string display_rotation; + PlatformResult result = + types::MediaControllerDisplayRotationEnum.getName(rotation, &display_rotation); + if (!result) { + LoggerW("MediaControllerDisplayRotationEnum.getName() failed, error: %s, ignoring event", + result.message().c_str()); + return; + } + + picojson::value data = picojson::value(picojson::object()); + picojson::object& data_o = data.get(); + + data_o["displayRotation"] = picojson::value(display_rotation); + data_o["clientName"] = picojson::value(client_name); + data_o["requestId"] = picojson::value(std::string(request_id)); + server->display_rotation_change_request_listener_(&data); +} + +PlatformResult MediaControllerServer::SetDisplayRotationChangeRequestListener( + const JsonCallback& callback) { + ScopeLogger(); + + int ret = + mc_server_set_display_rotation_cmd_received_cb(handle_, OnDisplayRotationChangeCommand, this); + if (MEDIA_CONTROLLER_ERROR_NONE != ret) { + return LogAndCreateResult( + ErrorCode::UNKNOWN_ERR, "Unable to set display rotation command listener", + ("mc_server_set_display_rotation_cmd_received_cb() error: %d, message: %s", ret, + get_error_message(ret))); + } + + display_rotation_change_request_listener_ = callback; + + return PlatformResult(ErrorCode::NO_ERROR); +} + +PlatformResult MediaControllerServer::UnsetDisplayRotationChangeRequestListener() { + ScopeLogger(); + + int ret = mc_server_unset_display_rotation_cmd_received_cb(handle_); + if (MEDIA_CONTROLLER_ERROR_NONE != ret) { + return LogAndCreateResult( + ErrorCode::UNKNOWN_ERR, "Unable to unset display rotation command listener", + ("mc_server_unset_display_rotation_cmd_received_cb() error: %d, message: %s", ret, + get_error_message(ret))); + } + display_rotation_change_request_listener_ = nullptr; + + return PlatformResult(ErrorCode::NO_ERROR); +} } // namespace mediacontroller } // namespace extension diff --git a/src/mediacontroller/mediacontroller_server.h b/src/mediacontroller/mediacontroller_server.h index 262640b3..3c84c124 100644 --- a/src/mediacontroller/mediacontroller_server.h +++ b/src/mediacontroller/mediacontroller_server.h @@ -84,7 +84,11 @@ class MediaControllerServer { common::PlatformResult SetDisplayModeChangeRequestListener(const JsonCallback& callback); common::PlatformResult UnsetDisplayModeChangeRequestListener(); - // TODO displayRotation + // displayRotation + common::PlatformResult UpdateDisplayRotation(const std::string& display_rotation); + common::PlatformResult SetDisplayRotationChangeRequestListener(const JsonCallback& callback); + common::PlatformResult UnsetDisplayRotationChangeRequestListener(); + private: mc_server_h handle_; @@ -134,7 +138,10 @@ class MediaControllerServer { static void OnDisplayModeChangeCommand(const char* client_name, const char* request_id, mc_display_mode_e type, void* user_data); - // TODO displayRotation + // displayRotation + JsonCallback display_rotation_change_request_listener_; + static void OnDisplayRotationChangeCommand(const char* client_name, const char* request_id, + mc_display_rotation_e type, void* user_data); }; } // namespace mediacontroller diff --git a/src/mediacontroller/mediacontroller_utils.cc b/src/mediacontroller/mediacontroller_utils.cc index a4908744..78414918 100644 --- a/src/mediacontroller/mediacontroller_utils.cc +++ b/src/mediacontroller/mediacontroller_utils.cc @@ -120,6 +120,12 @@ const common::PlatformEnum MediaControllerDisplayModeEnum{ {"FULL_SCREEN", MC_DISPLAY_MODE_FULL_SCREEN}, {"CROPPED_FULL", MC_DISPLAY_MODE_CROPPED_FULL}}; +const common::PlatformEnum MediaControllerDisplayRotationEnum{ + {"ROTATION_NONE", MC_DISPLAY_ROTATION_NONE}, + {"ROTATION_90", MC_DISPLAY_ROTATION_90}, + {"ROTATION_180", MC_DISPLAY_ROTATION_180}, + {"ROTATION_270", MC_DISPLAY_ROTATION_270}}; + PlatformResult ConvertPlaybackState(mc_playback_h playback_h, std::string* state) { ScopeLogger(); diff --git a/src/mediacontroller/mediacontroller_utils.h b/src/mediacontroller/mediacontroller_utils.h index 8540e727..2338982e 100644 --- a/src/mediacontroller/mediacontroller_utils.h +++ b/src/mediacontroller/mediacontroller_utils.h @@ -52,6 +52,7 @@ extern const common::PlatformEnum MediaControllerAbilitySu extern const common::PlatformEnum MediaControllerSubscriptionTypeEnum; extern const common::PlatformEnum MediaControllerSimpleAbilityEnum; extern const common::PlatformEnum MediaControllerDisplayModeEnum; +extern const common::PlatformEnum MediaControllerDisplayRotationEnum; } // namespace types