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() {
};
};
-// 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() {};
writable: false
},
displayMode: {
- value: new MediaControllerDisplayModeInfo(),
+ value: new MediaControllerDisplayModeInfo(data.name),
enumerable: true,
writable: false
},
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");
}
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<MediaControllerClient*>(user_data);
+
+ picojson::value data = picojson::value(picojson::object());
+ picojson::object& data_o = data.get<picojson::object>();
+
+ 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
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:
JsonCallback subtitles_update_listener_;
// mode 360
JsonCallback mode360_update_listener_;
+ // display mode
+ JsonCallback display_mode_update_listener_;
std::list<std::string> subscribed_servers;
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
};
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
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<std::string>();
+ 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<picojson::object>();
+ 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<std::string>(), &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<picojson::object>();
+ 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<std::string>(),
+ args.get("type").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 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<picojson::object>();
+ 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
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<MediaControllerClient> client_;
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());
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<MediaControllerServer*>(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<picojson::object>();
+
+ 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
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_;
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
};
{"SUBTITLES", MC_ABILITY_SUBTITLES},
{"MODE_360", MC_ABILITY_360_MODE}};
+const common::PlatformEnum<mc_display_mode_e> 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();
extern const common::PlatformEnum<mc_ability_support_e> MediaControllerAbilitySupportEnum;
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;
} // namespace types
projects / platform / core / api / webapi-plugins.git / commitdiff