From: Piotr Kosko/Native/Web API (PLT) /SRPOL/Engineer/삼성전자 Date: Thu, 12 Sep 2019 12:38:12 +0000 (+0200) Subject: [Mediacontroller] added display mode feature X-Git-Tag: submit/tizen/20190919.123326~4 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=refs%2Fchanges%2F20%2F213720%2F9;p=platform%2Fcore%2Fapi%2Fwebapi-plugins.git [Mediacontroller] added display mode feature [ACR] http://suprem.sec.samsung.net/jira/browse/TWDAPI-231 [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(type, clientName) { console.log("Display mode change requested to: " + type + " by " + clientName); return new tizen.mediacontroller.RequestReply(new tizen.Bundle({"message": "Not allowed"}), 13); }; watcherId = mcServer.displayMode.addChangeRequestListener(changeListener); /// 2. checking NotSupportedError when sending without enabled ability var mcClient = tizen.mediacontroller.getClient(); var mcServerInfo = mcClient.getLatestServerInfo() var type = "ORIGIN_SIZE"; mcServerInfo.displayMode.sendRequest(type, function(data, code) { console.log( "Server replied with return data: " + JSON.stringify(data) + " and code: " + code); }, function(e) { console.log("Error executing command: " + e.message); }); /// 3. register listener for mode changes (client side) watcherId = mcServerInfo.displayMode.addModeChangeListener(function(type) { console.log(mcServerInfo.name + " server display mode changed to " + type); }); /// 4. change the value of display mode (should trigger listener from point 3) mcServer.displayMode.type = "FULL_SCREEN" /// 4. enable ability of server // TODO support: mcServer.abilities.displayMode.originSize = "YES" /// sendRequest again (should trigger listener from point 1) mcServerInfo.displayMode.sendRequest(type, function(data, code) { console.log( "Server replied with return data: " + JSON.stringify(data) + " and code: " + code); }, function(e) { console.log("Error executing command: " + e.message); }); Change-Id: Icbc98513372d8da8e111a44d873c6559dede89e9 --- diff --git a/src/mediacontroller/mediacontroller_api.js b/src/mediacontroller/mediacontroller_api.js index 037b83fe..3fbf321f 100755 --- a/src/mediacontroller/mediacontroller_api.js +++ b/src/mediacontroller/mediacontroller_api.js @@ -362,6 +362,13 @@ var MediaControllerSimpleAbility = { MODE_360: 'MODE_360' }; +var MediaControllerDisplayModeType = { + LETTER_BOX: 'LETTER_BOX', + ORIGIN_SIZE: 'ORIGIN_SIZE', + FULL_SCREEN: 'FULL_SCREEN', + CROPPED_FULL: 'CROPPED_FULL' +}; + function MediaControllerManager() {} MediaControllerManager.prototype.getClient = function() { @@ -1405,9 +1412,208 @@ var MediaControllerMode360Info = function(name) { }; }; -// TODO displayMode -var MediaControllerDisplayMode = function() {}; -var MediaControllerDisplayModeInfo = function() {}; +// displayMode +var MediaControllerDisplayMode = function() { + // the default value is MediaControllerDisplayModeType.FULL_SCREEN + var _type = MediaControllerDisplayModeType.FULL_SCREEN; + Object.defineProperties(this, { + type: { + get: function() { + return _type; + }, + set: function(v) { + var args = validator_.validateArgs(arguments, [ + { + name: 'type', + type: types_.ENUM, + values: Object.keys(MediaControllerDisplayModeType) + } + ]); + if (args.type !== _type) { + var result = native_.callSync( + 'MediaControllerDisplayMode_updateType', + args + ); + if (native_.isFailure(result)) { + throw native_.getErrorObject(result); + } + _type = args.type; + } + }, + enumerable: true + } + }); +}; + +var MediaControllerDisplayModeListener = new ListenerManager( + native_, + '_MediaControllerDisplayModeListener', + function(msg, listener) { + var reply = listener(msg.clientName, msg.type); + + if (!(reply instanceof RequestReply)) { + reply = new RequestReply( + xwalk.utils.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); + } + } +); + +MediaControllerDisplayMode.prototype.addChangeRequestListener = function() { + var args = validator_.validateArgs(arguments, [ + { + name: 'listener', + type: types_.FUNCTION, + optional: false, + nullable: false + } + ]); + + if (type_.isEmptyObject(MediaControllerDisplayModeListener.listeners)) { + var result = native_.callSync( + 'MediaControllerDisplayMode_addChangeRequestListener', + { + listenerId: MediaControllerDisplayModeListener.listenerName + } + ); + if (native_.isFailure(result)) { + throw native_.getErrorObject(result); + } + } + return MediaControllerDisplayModeListener.addListener(args.listener); +}; + +MediaControllerDisplayMode.prototype.removeChangeRequestListener = function(watchId) { + var args = validator_.validateArgs(arguments, [ + { name: 'watchId', type: types_.LONG } + ]); + + MediaControllerDisplayModeListener.removeListener(args.watchId); + + if (type_.isEmptyObject(MediaControllerDisplayModeListener.listeners)) { + var result = native_.callSync( + 'MediaControllerDisplayMode_removeChangeRequestListener' + ); + if (native_.isFailure(result)) { + throw native_.getErrorObject(result); + } + } +}; + +var DisplayModeChangeListener = new ListenerManager( + native_, + '_DisplayModeChangeListener', + function(msg, listener) { + listener(msg.displayMode); + } +); + +var MediaControllerDisplayModeInfo = function(name) { + var _serverName = name; + Object.defineProperties(this, { + type: { + get: function() { + var result = native_.callSync('MediaControllerDisplayModeInfo_getType', { + 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: 'type', + type: types_.ENUM, + values: Object.keys(MediaControllerDisplayModeType) + }, + { + name: 'replyCallback', + type: types_.FUNCTION + } + ]); + var callback = function(result) { + native_.callIfPossible( + args.replyCallback, + native_.getResultObject(result).data, + native_.getResultObject(result).code + ); + }; + + var nativeData = { + type: args.type, + name: _serverName, + listenerId: ReplyCommandListener.listenerName + }; + + var result = native_.callSync( + 'MediaControllerDisplayModeInfo_SendRequest', + nativeData + ); + if (native_.isFailure(result)) { + throw native_.getErrorObject(result); + } + + var replyListenerId = ReplyCommandListener.addListener(callback); + ReplyCommandListener.requestIdToListenerId[replyListenerId] = result.requestId; + }; + + this.addModeChangeListener = function(listener) { + var args = validator_.validateArgs(arguments, [ + { name: 'listener', type: types_.FUNCTION } + ]); + + if (type_.isEmptyObject(DisplayModeChangeListener.listeners)) { + var result = native_.callSync( + 'MediaControllerDisplayModeInfo_addModeChangeListener', + { + listenerId: DisplayModeChangeListener.listenerName + } + ); + if (native_.isFailure(result)) { + throw native_.getErrorObject(result); + } + } + return DisplayModeChangeListener.addServerInfoListener( + args.listener, + _serverName + ); + }; + this.removeModeChangeListener = function(watchId) { + var args = validator_.validateArgs(arguments, [ + { name: 'watchId', type: types_.LONG } + ]); + + DisplayModeChangeListener.removeServerInfoListener(args.watchId); + + if (type_.isEmptyObject(DisplayModeChangeListener.listeners)) { + var result = native_.callSync( + 'MediaControllerDisplayModeInfo_removeModeChangeListener' + ); + if (native_.isFailure(result)) { + throw native_.getErrorObject(result); + } + } + }; +}; + // TODO displayRotation var MediaControllerDisplayRotation = function() {}; var MediaControllerDisplayRotationInfo = function() {}; @@ -2333,7 +2539,7 @@ function MediaControllerServerInfo(data) { writable: false }, displayMode: { - value: new MediaControllerDisplayModeInfo(), + value: new MediaControllerDisplayModeInfo(data.name), enumerable: true, writable: false }, diff --git a/src/mediacontroller/mediacontroller_client.cc b/src/mediacontroller/mediacontroller_client.cc index 6bbade4d..2f3e7c5e 100644 --- a/src/mediacontroller/mediacontroller_client.cc +++ b/src/mediacontroller/mediacontroller_client.cc @@ -71,6 +71,10 @@ MediaControllerClient::~MediaControllerClient() { LoggerE("Failed to unset mode 360 listener"); } + if (nullptr != display_mode_update_listener_ && !UnsetDisplayModeInfoChangeListener()) { + LoggerE("Failed to unset display mode listener"); + } + if (nullptr != handle_ && MEDIA_CONTROLLER_ERROR_NONE != mc_client_destroy(handle_)) { LoggerE("Unable to destroy media controller client"); } @@ -1304,7 +1308,102 @@ void MediaControllerClient::OnMode360Update(const char* server_name, bool enable client->mode360_update_listener_(&data); } -// TODO displayMode + +// displayMode +PlatformResult MediaControllerClient::GetDisplayModeType(const std::string& name, + std::string* type) { + ScopeLogger(); + mc_display_mode_e mode = MC_DISPLAY_MODE_FULL_SCREEN; + + int ret = mc_client_get_server_display_mode(handle_, name.c_str(), &mode); + if (MEDIA_CONTROLLER_ERROR_NONE != ret) { + return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Error getting display mode type", + ("mc_client_get_server_display_mode() error: %d, message: %s", ret, + get_error_message(ret))); + } + + PlatformResult result = types::MediaControllerDisplayModeEnum.getName(mode, type); + if (!result) { + LoggerE("MediaControllerDisplayModeEnum.getName() failed, error: %s", result.message().c_str()); + return result; + } + return PlatformResult(ErrorCode::NO_ERROR); +} + +PlatformResult MediaControllerClient::SendDisplayModeType(const std::string& server_name, + const std::string& type, + const JsonCallback& reply_cb, + char** request_id) { + ScopeLogger(); + mc_display_mode_e mode = MC_DISPLAY_MODE_FULL_SCREEN; + PlatformResult result = types::MediaControllerDisplayModeEnum.getValue(type, &mode); + if (!result) { + LoggerE("MediaControllerDisplayModeEnum.getValue() failed, error: %s", + result.message().c_str()); + return result; + } + + int ret = mc_client_send_display_mode_cmd(handle_, server_name.c_str(), mode, request_id); + if (MEDIA_CONTROLLER_ERROR_NONE != ret) { + return LogAndCreateResult( + utils::ConvertMediaControllerError(ret), "Error sending display mode command", + ("mc_client_send_display_mode_cmd() error: %d, message: %s", ret, get_error_message(ret))); + } + + command_reply_callback_ = reply_cb; + return PlatformResult(ErrorCode::NO_ERROR); +} + +PlatformResult MediaControllerClient::SetDisplayModeInfoChangeListener( + const JsonCallback& callback) { + ScopeLogger(); + + int ret = mc_client_set_display_mode_updated_cb(handle_, OnDisplayModeUpdate, this); + if (MEDIA_CONTROLLER_ERROR_NONE != ret) { + return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Unable to set display mode listener", + ("mc_client_set_display_mode_updated_cb() error: %d, message: %s", + ret, get_error_message(ret))); + } + + display_mode_update_listener_ = callback; + + return PlatformResult(ErrorCode::NO_ERROR); +} + +PlatformResult MediaControllerClient::UnsetDisplayModeInfoChangeListener() { + ScopeLogger(); + int ret = mc_client_unset_display_mode_updated_cb(handle_); + if (MEDIA_CONTROLLER_ERROR_NONE != ret) { + return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Unable to unset display mode listener", + ("mc_client_unset_display_mode_updated_cb() error: %d, message: %s", + ret, get_error_message(ret))); + } + display_mode_update_listener_ = nullptr; + return PlatformResult(ErrorCode::NO_ERROR); +} + +void MediaControllerClient::OnDisplayModeUpdate(const char* server_name, mc_display_mode_e mode, + 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 mode_str; + PlatformResult result = types::MediaControllerDisplayModeEnum.getName(mode, &mode_str); + if (!result) { + LoggerW("MediaControllerDisplayModeEnum.getName() failed, error: %s, ignoring event", + result.message().c_str()); + return; + } + + data_o["displayMode"] = picojson::value(mode_str); + data_o["name"] = picojson::value(server_name); + + client->display_mode_update_listener_(&data); +} + // TODO displayRotation } // namespace mediacontroller diff --git a/src/mediacontroller/mediacontroller_client.h b/src/mediacontroller/mediacontroller_client.h index 1acf677a..b3d245a8 100644 --- a/src/mediacontroller/mediacontroller_client.h +++ b/src/mediacontroller/mediacontroller_client.h @@ -85,7 +85,13 @@ class MediaControllerClient { const JsonCallback& reply_cb, char** request_id); common::PlatformResult SetMode360InfoChangeListener(const JsonCallback& callback); common::PlatformResult UnsetMode360InfoChangeListener(); - // TODO displayMode + // displayMode + common::PlatformResult GetDisplayModeType(const std::string& name, std::string* type); + common::PlatformResult SendDisplayModeType(const std::string& server_name, + const std::string& type, const JsonCallback& reply_cb, + char** request_id); + common::PlatformResult SetDisplayModeInfoChangeListener(const JsonCallback& callback); + common::PlatformResult UnsetDisplayModeInfoChangeListener(); // TODO displayRotation private: @@ -100,6 +106,8 @@ class MediaControllerClient { JsonCallback subtitles_update_listener_; // mode 360 JsonCallback mode360_update_listener_; + // display mode + JsonCallback display_mode_update_listener_; std::list subscribed_servers; @@ -123,7 +131,8 @@ class MediaControllerClient { static void OnSubtitlesUpdate(const char* server_name, bool enabled, void* user_data); // mode360 static void OnMode360Update(const char* server_name, bool enabled, void* user_data); - // TODO displayMode + // displayMode + static void OnDisplayModeUpdate(const char* server_name, mc_display_mode_e mode, void* user_data); // TODO displayRotation }; diff --git a/src/mediacontroller/mediacontroller_instance.cc b/src/mediacontroller/mediacontroller_instance.cc index b959539d..cc0a770d 100644 --- a/src/mediacontroller/mediacontroller_instance.cc +++ b/src/mediacontroller/mediacontroller_instance.cc @@ -180,7 +180,22 @@ MediaControllerInstance::MediaControllerInstance() { MediaControllerMode360InfoAddModeChangeListener); REGISTER_SYNC("MediaControllerMode360Info_removeModeChangeListener", MediaControllerMode360InfoRemoveModeChangeListener); -// TODO displayMode + + // displayMode + REGISTER_SYNC("MediaControllerDisplayMode_updateType", MediaControllerDisplayModeUpdateType); + REGISTER_SYNC("MediaControllerDisplayMode_addChangeRequestListener", + MediaControllerDisplayModeAddChangeRequestListener); + REGISTER_SYNC("MediaControllerDisplayMode_removeChangeRequestListener", + MediaControllerDisplayModeRemoveChangeRequestListener); + + REGISTER_SYNC("MediaControllerDisplayModeInfo_getType", MediaControllerDisplayModeInfoGetType); + REGISTER_ASYNC("MediaControllerDisplayModeInfo_SendRequest", + MediaControllerDisplayModeInfoSendType); + REGISTER_SYNC("MediaControllerDisplayModeInfo_addModeChangeListener", + MediaControllerDisplayModeInfoAddModeChangeListener); + REGISTER_SYNC("MediaControllerDisplayModeInfo_removeModeChangeListener", + MediaControllerDisplayModeInfoRemoveModeChangeListener); + // TODO displayRotation #undef REGISTER_SYNC @@ -1974,7 +1989,184 @@ void MediaControllerInstance::MediaControllerMode360InfoRemoveModeChangeListener ReportSuccess(out); } -// TODO displayMode +// displayMode +void MediaControllerInstance::MediaControllerDisplayModeUpdateType(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, "type", std::string, out); + + const std::string type = args.get("type").get(); + PlatformResult result = server_->UpdateDisplayModeType(type); + if (!result) { + LogAndReportError(result, &out, ("Failed server_->UpdateDisplayModeType()")); + return; + } + ReportSuccess(out); +} + +void MediaControllerInstance::MediaControllerDisplayModeAddChangeRequestListener( + 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_->SetDisplayModeChangeRequestListener(callback); + if (!result) { + LogAndReportError(result, &out); + return; + } + + ReportSuccess(out); +} + +void MediaControllerInstance::MediaControllerDisplayModeRemoveChangeRequestListener( + 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_->UnsetDisplayModeChangeRequestListener(); + if (!result) { + LogAndReportError(result, &out); + return; + } + ReportSuccess(out); +} + +void MediaControllerInstance::MediaControllerDisplayModeInfoGetType(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 type; + PlatformResult result = client_->GetDisplayModeType(args.get("name").get(), &type); + + if (!result) { + LogAndReportError(result, &out, ("Failed: client_->GetDisplayModeType")); + return; + } + + ReportSuccess(picojson::value(type), out); +} + +void MediaControllerInstance::MediaControllerDisplayModeInfoSendType(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, "type", std::string, out) + + JsonCallback reply_cb = [this, args](picojson::value* reply) -> void { + picojson::object& reply_obj = reply->get(); + reply_obj["listenerId"] = args.get("listenerId"); + Instance::PostMessage(this, reply->serialize().c_str()); + }; + + char* request_id = nullptr; + SCOPE_EXIT { + free(request_id); + }; + + PlatformResult result = + client_->SendDisplayModeType(args.get("name").get(), + args.get("type").get(), reply_cb, &request_id); + + if (result) { + ReportSuccess(out); + out["requestId"] = picojson::value(std::string(request_id)); + } else { + LogAndReportError(result, &out, ("Failed to send command.")); + } +} + +void MediaControllerInstance::MediaControllerDisplayModeInfoAddModeChangeListener( + 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_->SetDisplayModeInfoChangeListener(callback); + if (!result) { + LogAndReportError(result, &out); + return; + } + + ReportSuccess(out); +} + +void MediaControllerInstance::MediaControllerDisplayModeInfoRemoveModeChangeListener( + 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_->UnsetDisplayModeInfoChangeListener(); + if (!result) { + LogAndReportError(result, &out); + return; + } + + ReportSuccess(out); +} + // TODO displayRotation #undef CHECK_EXIST diff --git a/src/mediacontroller/mediacontroller_instance.h b/src/mediacontroller/mediacontroller_instance.h index b820825a..bfd41055 100644 --- a/src/mediacontroller/mediacontroller_instance.h +++ b/src/mediacontroller/mediacontroller_instance.h @@ -145,7 +145,18 @@ class MediaControllerInstance : public common::ParsedInstance { void MediaControllerMode360InfoRemoveModeChangeListener(const picojson::value& args, picojson::object& out); - // TODO displayMode + // displayMode + void MediaControllerDisplayModeUpdateType(const picojson::value& args, picojson::object& out); + void MediaControllerDisplayModeAddChangeRequestListener(const picojson::value& args, + picojson::object& out); + void MediaControllerDisplayModeRemoveChangeRequestListener(const picojson::value& args, + picojson::object& out); + void MediaControllerDisplayModeInfoGetType(const picojson::value& args, picojson::object& out); + void MediaControllerDisplayModeInfoSendType(const picojson::value& args, picojson::object& out); + void MediaControllerDisplayModeInfoAddModeChangeListener(const picojson::value& args, + picojson::object& out); + void MediaControllerDisplayModeInfoRemoveModeChangeListener(const picojson::value& args, + picojson::object& out); // TODO displayRotation std::shared_ptr client_; diff --git a/src/mediacontroller/mediacontroller_server.cc b/src/mediacontroller/mediacontroller_server.cc index 5e2a532f..989c92be 100644 --- a/src/mediacontroller/mediacontroller_server.cc +++ b/src/mediacontroller/mediacontroller_server.cc @@ -68,6 +68,11 @@ MediaControllerServer::~MediaControllerServer() { LoggerE("Failed to unset mode 360 request listener"); } + if (nullptr != display_mode_change_request_listener_ && + !UnsetDisplayModeChangeRequestListener()) { + LoggerE("Failed to unset display mode request 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()); @@ -1174,7 +1179,83 @@ PlatformResult MediaControllerServer::UnsetMode360ChangeRequestListener() { return PlatformResult(ErrorCode::NO_ERROR); } -// TODO displayMode +// displayMode +common::PlatformResult MediaControllerServer::UpdateDisplayModeType(const std::string& type) { + ScopeLogger(); + mc_display_mode_e mode = MC_DISPLAY_MODE_FULL_SCREEN; + PlatformResult result = types::MediaControllerDisplayModeEnum.getValue(type, &mode); + if (!result) { + LoggerE("MediaControllerDisplayModeEnum.getValue() failed, error: %s", + result.message().c_str()); + return result; + } + + int ret = mc_server_update_display_mode(handle_, mode); + if (MEDIA_CONTROLLER_ERROR_NONE != ret) { + return LogAndCreateResult( + ErrorCode::UNKNOWN_ERR, "Error setting server display mode", + ("mc_server_update_display_mode() error: %d, message: %s", ret, get_error_message(ret))); + } + return PlatformResult(ErrorCode::NO_ERROR); +} + +void MediaControllerServer::OnDisplayModeChangeCommand(const char* client_name, + const char* request_id, + mc_display_mode_e mode, void* user_data) { + ScopeLogger(); + + MediaControllerServer* server = static_cast(user_data); + + std::string type; + PlatformResult result = types::MediaControllerDisplayModeEnum.getName(mode, &type); + if (!result) { + LoggerW("MediaControllerDisplayModeEnum.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["type"] = picojson::value(type); + data_o["clientName"] = picojson::value(client_name); + data_o["requestId"] = picojson::value(std::string(request_id)); + + server->display_mode_change_request_listener_(&data); +} + +PlatformResult MediaControllerServer::SetDisplayModeChangeRequestListener( + const JsonCallback& callback) { + ScopeLogger(); + + int ret = mc_server_set_display_mode_cmd_received_cb(handle_, OnDisplayModeChangeCommand, this); + if (MEDIA_CONTROLLER_ERROR_NONE != ret) { + return LogAndCreateResult( + ErrorCode::UNKNOWN_ERR, "Unable to set display mode command listener", + ("mc_server_set_display_mode_cmd_received_cb() error: %d, message: %s", ret, + get_error_message(ret))); + } + + display_mode_change_request_listener_ = callback; + + return PlatformResult(ErrorCode::NO_ERROR); +} + +PlatformResult MediaControllerServer::UnsetDisplayModeChangeRequestListener() { + ScopeLogger(); + + int ret = mc_server_unset_display_mode_cmd_received_cb(handle_); + if (MEDIA_CONTROLLER_ERROR_NONE != ret) { + return LogAndCreateResult( + ErrorCode::UNKNOWN_ERR, "Unable to unset display mode command listener", + ("mc_server_unset_display_mode_cmd_received_cb() error: %d, message: %s", ret, + get_error_message(ret))); + } + display_mode_change_request_listener_ = nullptr; + + return PlatformResult(ErrorCode::NO_ERROR); +} + // TODO displayRotation } // namespace mediacontroller diff --git a/src/mediacontroller/mediacontroller_server.h b/src/mediacontroller/mediacontroller_server.h index 6a401372..262640b3 100644 --- a/src/mediacontroller/mediacontroller_server.h +++ b/src/mediacontroller/mediacontroller_server.h @@ -78,7 +78,12 @@ class MediaControllerServer { common::PlatformResult UpdateMode360Enabled(bool enabled); common::PlatformResult SetMode360ChangeRequestListener(const JsonCallback& callback); common::PlatformResult UnsetMode360ChangeRequestListener(); - // TODO displayMode + + // displayMode + common::PlatformResult UpdateDisplayModeType(const std::string& type); + common::PlatformResult SetDisplayModeChangeRequestListener(const JsonCallback& callback); + common::PlatformResult UnsetDisplayModeChangeRequestListener(); + // TODO displayRotation private: mc_server_h handle_; @@ -123,7 +128,12 @@ class MediaControllerServer { JsonCallback mode360_change_request_listener_; static void OnMode360ChangeCommand(const char* client_name, const char* request_id, bool enabled, void* user_data); - // TODO displayMode + + // displayMode + JsonCallback display_mode_change_request_listener_; + static void OnDisplayModeChangeCommand(const char* client_name, const char* request_id, + mc_display_mode_e type, void* user_data); + // TODO displayRotation }; diff --git a/src/mediacontroller/mediacontroller_utils.cc b/src/mediacontroller/mediacontroller_utils.cc index 6bd2af37..a4908744 100644 --- a/src/mediacontroller/mediacontroller_utils.cc +++ b/src/mediacontroller/mediacontroller_utils.cc @@ -114,6 +114,12 @@ const common::PlatformEnum MediaControllerSimpleAbilityEnum{ {"SUBTITLES", MC_ABILITY_SUBTITLES}, {"MODE_360", MC_ABILITY_360_MODE}}; +const common::PlatformEnum MediaControllerDisplayModeEnum{ + {"LETTER_BOX", MC_DISPLAY_MODE_LETTER_BOX}, + {"ORIGIN_SIZE", MC_DISPLAY_MODE_ORIGIN_SIZE}, + {"FULL_SCREEN", MC_DISPLAY_MODE_FULL_SCREEN}, + {"CROPPED_FULL", MC_DISPLAY_MODE_CROPPED_FULL}}; + 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 cc570d57..8540e727 100644 --- a/src/mediacontroller/mediacontroller_utils.h +++ b/src/mediacontroller/mediacontroller_utils.h @@ -51,6 +51,7 @@ extern const common::PlatformEnum MediaControllerSearchCat extern const common::PlatformEnum MediaControllerAbilitySupportEnum; extern const common::PlatformEnum MediaControllerSubscriptionTypeEnum; extern const common::PlatformEnum MediaControllerSimpleAbilityEnum; +extern const common::PlatformEnum MediaControllerDisplayModeEnum; } // namespace types