[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 <r.walczyna@samsung.com>
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() {
};
};
-// 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;
writable: false
},
displayRotation: {
- value: new MediaControllerDisplayRotationInfo(),
+ value: new MediaControllerDisplayRotationInfo(data.name),
enumerable: true,
writable: false
}
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");
}
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<MediaControllerClient*>(user_data);
+
+ picojson::value data = picojson::value(picojson::object());
+ picojson::object& data_o = data.get<picojson::object>();
+
+ 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
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_;
JsonCallback mode360_update_listener_;
// display mode
JsonCallback display_mode_update_listener_;
+ // displayRotation
+ JsonCallback display_rotation_update_listener;
std::list<std::string> subscribed_servers;
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
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
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<std::string>();
+ 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<picojson::object>();
+ 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<std::string>(), &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<picojson::object>();
+ 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<std::string>(), args.get("displayRotation").get<std::string>(), 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<picojson::object>();
+ 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
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<MediaControllerClient> client_;
std::shared_ptr<MediaControllerServer> server_;
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());
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<MediaControllerServer*>(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<picojson::object>();
+
+ 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
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_;
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
{"FULL_SCREEN", MC_DISPLAY_MODE_FULL_SCREEN},
{"CROPPED_FULL", MC_DISPLAY_MODE_CROPPED_FULL}};
+const common::PlatformEnum<mc_display_rotation_e> 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();
extern const common::PlatformEnum<mc_subscription_type_e> MediaControllerSubscriptionTypeEnum;
extern const common::PlatformEnum<mc_ability_e> MediaControllerSimpleAbilityEnum;
extern const common::PlatformEnum<mc_display_mode_e> MediaControllerDisplayModeEnum;
+extern const common::PlatformEnum<mc_display_rotation_e> MediaControllerDisplayRotationEnum;
} // namespace types
projects / platform / core / api / webapi-plugins.git / commitdiff