var types_ = validator_.Types;
var native_ = new xwalk.utils.NativeManager(extension);
-// TODO(r.galka) CAPI have no dedicated methods for position/shuffle/repeat change.
-// It should be updated when new version of CAPI will be available.
-// For now implementation is using internal commands.
-var internal_commands_ = {
- sendPlaybackPosition: '__internal_sendPlaybackPosition',
- sendShuffleMode: '__internal_sendShuffleMode',
- sendRepeatMode: '__internal_sendRepeatMode'
-};
-
function ListenerManager(native, listenerName, handle) {
this.listeners = {};
this.listenerNameToIds = {};
};
var data = {
- position: args.position
+ position: args.position,
+ name: this.name
};
- sendDefinedCommand(this.name, internal_commands_.sendPlaybackPosition, data, callback);
+ native_.call('MediaControllerServerInfo_sendPlaybackPosition', data, callback);
};
MediaControllerServerInfo.prototype.sendShuffleMode = function(mode, successCallback, errorCallback) {
};
var data = {
- mode: args.mode
+ mode: args.mode,
+ name: this.name
};
- sendDefinedCommand(this.name, internal_commands_.sendShuffleMode, data, callback);
+ native_.call('MediaControllerServerInfo_sendShuffleMode', data, callback);
};
MediaControllerServerInfo.prototype.sendRepeatMode = function(mode, successCallback, errorCallback) {
};
var data = {
- mode: args.mode
- };
- sendDefinedCommand(this.name, internal_commands_.sendRepeatMode, data, callback);
-};
-
-function sendDefinedCommand(name_, command_, data_, callback_) {
- var nativeData = {
- command: command_,
- data: data_,
- name: name_
+ mode: args.mode,
+ name: this.name
};
-
- var replyId = ReplyCommandListener.addListener(callback_);
-
- nativeData.replyId = replyId;
- nativeData.listenerId = ReplyCommandListener.listenerName;
-
- native_.call('MediaControllerServerInfo_sendCommand', nativeData, callback_);
+ native_.call('MediaControllerServerInfo_sendRepeatMode', data, callback);
};
MediaControllerServerInfo.prototype.sendCommand = function(command, data, successCallback, errorCallback) {
MediaControllerClient::~MediaControllerClient() {
ScopeLogger();
- if (handle_) {
- int ret = mc_client_destroy(handle_);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
- LoggerE("Unable to destroy media controller client");
- }
+
+ if (nullptr != server_status_listener_ && !UnsetServerStatusChangeListener()) {
+ LoggerE("Failed to unset server status change listener");
+ }
+
+ if (nullptr != playback_info_listener_ && !UnsetPlaybackInfoListener()) {
+ LoggerE("Failed to unset playback info listener");
+ }
+
+ if (nullptr != handle_ && MEDIA_CONTROLLER_ERROR_NONE != mc_client_destroy(handle_)) {
+ LoggerE("Unable to destroy media controller client");
}
}
PlatformResult MediaControllerClient::Init() {
ScopeLogger();
int ret = mc_client_create(&handle_);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
+ if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
return LogAndCreateResult(
ErrorCode::UNKNOWN_ERR, "Unable to create media controller client",
("mc_client_create() error: %d, message: %s", ret, get_error_message(ret)));
int ret;
ret = mc_client_foreach_server(handle_, FindServersCallback, servers);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
+ if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
return LogAndCreateResult(
ErrorCode::UNKNOWN_ERR, "Unable to fetch active servers, error",
("mc_client_foreach_server() error: %d, message: %s", ret, get_error_message(ret)));
};
mc_server_state_e state;
ret = mc_client_get_latest_server_info(handle_, &name, &state);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
+ if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
return LogAndCreateResult(
ErrorCode::UNKNOWN_ERR, "Error getting latest server info",
("mc_client_get_latest_server_info() error: %d, message: %s", ret, get_error_message(ret)));
mc_playback_h playback_h;
ret = mc_client_get_server_playback_info(handle_, server_name.c_str(), &playback_h);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
+ if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Error getting playback info",
("mc_client_get_server_playback_info() error: %d, message: %s", ret,
get_error_message(ret)));
// shuffle mode
mc_shuffle_mode_e shuffle;
ret = mc_client_get_server_shuffle_mode(handle_, server_name.c_str(), &shuffle);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
+ if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Error getting shuffle mode",
("mc_client_get_server_shuffle_mode() error: %d, message: %s", ret,
get_error_message(ret)));
// repeat mode
mc_repeat_mode_e repeat;
ret = mc_client_get_server_repeat_mode(handle_, server_name.c_str(), &repeat);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
+ if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
return LogAndCreateResult(
ErrorCode::UNKNOWN_ERR, "Error getting repeat mode",
("mc_client_get_server_repeat_mode() error: %d, message: %s", ret, get_error_message(ret)));
mc_metadata_h metadata_h;
ret = mc_client_get_server_metadata(handle_, server_name.c_str(), &metadata_h);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
+ if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
return LogAndCreateResult(
ErrorCode::UNKNOWN_ERR, "Error getting server metadata",
("mc_client_get_server_metadata() error: %d, message: %s", ret, get_error_message(ret)));
return PlatformResult(ErrorCode::NO_ERROR);
}
-PlatformResult MediaControllerClient::SetServerStatusChangeListener(JsonCallback callback) {
+PlatformResult MediaControllerClient::SetServerStatusChangeListener(const JsonCallback& callback) {
ScopeLogger();
- if (callback && server_status_listener_) {
- return LogAndCreateResult(ErrorCode::INVALID_STATE_ERR, "Listener already registered");
+
+ int ret = mc_client_set_server_update_cb(handle_, OnServerStatusUpdate, this);
+ if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
+ return LogAndCreateResult(
+ ErrorCode::UNKNOWN_ERR, "Unable to set server status listener",
+ ("mc_client_set_server_update_cb() error: %d, message: %s", ret, get_error_message(ret)));
}
server_status_listener_ = callback;
- int ret;
- if (callback) { // set platform callbacks
- ret = mc_client_set_server_update_cb(handle_, OnServerStatusUpdate, this);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
- return LogAndCreateResult(
- ErrorCode::UNKNOWN_ERR, "Unable to set server status listener",
- ("mc_client_set_server_update_cb() error: %d, message: %s", ret, get_error_message(ret)));
- }
+ return PlatformResult(ErrorCode::NO_ERROR);
+}
- } else { // unset platform callbacks
- ret = mc_client_unset_server_update_cb(handle_);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
- return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Unable to unset server status listener",
- ("mc_client_unset_server_update_cb() error: %d, message: %s", ret,
- get_error_message(ret)));
- }
+PlatformResult MediaControllerClient::UnsetServerStatusChangeListener() {
+ ScopeLogger();
+ int ret = mc_client_unset_server_update_cb(handle_);
+ if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
+ return LogAndCreateResult(
+ ErrorCode::UNKNOWN_ERR, "Unable to unset server status listener",
+ ("mc_client_unset_server_update_cb() error: %d, message: %s", ret, get_error_message(ret)));
}
-
+ server_status_listener_ = nullptr;
return PlatformResult(ErrorCode::NO_ERROR);
}
client->server_status_listener_(&data);
}
-PlatformResult MediaControllerClient::SetPlaybackInfoListener(JsonCallback callback) {
+PlatformResult MediaControllerClient::SetPlaybackInfoListener(const JsonCallback& callback) {
ScopeLogger();
- if (callback && playback_info_listener_) {
- return LogAndCreateResult(ErrorCode::INVALID_STATE_ERR, "Listener already registered");
- }
+ int failed_setter = 0;
+ SCOPE_EXIT {
+ int (*unsetters[])(mc_client_h) = {
+ mc_client_unset_playback_update_cb, mc_client_unset_shuffle_mode_update_cb,
+ mc_client_unset_repeat_mode_update_cb,
+ /*mc_client_unset_metadata_update_cb the last unsetter will never be used*/};
+ for (int i = 0; i < failed_setter; ++i) {
+ auto ret = unsetters[i](handle_);
+ if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
+ LoggerE("Fail (%d) returned by the [%d] unsetter", ret, i);
+ }
+ }
+ };
- playback_info_listener_ = callback;
+ int ret = mc_client_set_playback_update_cb(handle_, OnPlaybackUpdate, this);
+ if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
+ return LogAndCreateResult(
+ ErrorCode::UNKNOWN_ERR, "Unable to register playback listener",
+ ("mc_client_set_playback_update_cb() error: %d, message: %s", ret, get_error_message(ret)));
+ }
- int ret;
- if (callback) { // set platform callbacks
- ret = mc_client_set_playback_update_cb(handle_, OnPlaybackUpdate, this);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
- return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Unable to register playback listener",
- ("mc_client_set_playback_update_cb() error: %d, message: %s", ret,
- get_error_message(ret)));
- }
+ ret = mc_client_set_shuffle_mode_update_cb(handle_, OnShuffleModeUpdate, this);
+ if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
+ failed_setter = 1;
+ return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Unable to register shuffle mode listener",
+ ("mc_client_set_shuffle_mode_update_cb() error: %d, message: %s", ret,
+ get_error_message(ret)));
+ }
- ret = mc_client_set_shuffle_mode_update_cb(handle_, OnShuffleModeUpdate, this);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
- return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Unable to register shuffle mode listener",
- ("mc_client_set_shuffle_mode_update_cb() error: %d, message: %s",
- ret, get_error_message(ret)));
- }
+ ret = mc_client_set_repeat_mode_update_cb(handle_, OnRepeatModeUpdate, this);
+ if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
+ failed_setter = 2;
+ return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Unable to register repeat mode listener",
+ ("mc_client_set_repeat_mode_update_cb() error: %d, message: %s", ret,
+ get_error_message(ret)));
+ }
- ret = mc_client_set_repeat_mode_update_cb(handle_, OnRepeatModeUpdate, this);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
- return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Unable to register repeat mode listener",
- ("mc_client_set_repeat_mode_update_cb() error: %d, message: %s",
- ret, get_error_message(ret)));
- }
+ ret = mc_client_set_metadata_update_cb(handle_, OnMetadataUpdate, this);
+ if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
+ failed_setter = 3;
+ return LogAndCreateResult(
+ ErrorCode::UNKNOWN_ERR, "Unable to register metadata listener",
+ ("mc_client_set_metadata_update_cb() error: %d, message: %s", ret, get_error_message(ret)));
+ }
- ret = mc_client_set_metadata_update_cb(handle_, OnMetadataUpdate, this);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
- return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Unable to register metadata listener",
- ("mc_client_set_metadata_update_cb() error: %d, message: %s", ret,
- get_error_message(ret)));
- }
+ playback_info_listener_ = callback;
- } else { // unset platform callbacks
- ret = mc_client_unset_playback_update_cb(handle_);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
- return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Unable to unregister playback listener",
- ("mc_client_unset_playback_update_cb() error: %d, message: %s", ret,
- get_error_message(ret)));
- }
+ return PlatformResult(ErrorCode::NO_ERROR);
+}
- ret = mc_client_unset_shuffle_mode_update_cb(handle_);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
- return LogAndCreateResult(ErrorCode::UNKNOWN_ERR,
- "Unable to unregister shuffle mode listener",
- ("mc_client_unset_shuffle_mode_update_cb() error: %d, message: %s",
- ret, get_error_message(ret)));
- }
+PlatformResult MediaControllerClient::UnsetPlaybackInfoListener() {
+ ScopeLogger();
+ // Even though if one of below functions fails, let's try to unset as much listeners as we can.
+ // In the Javascript layer, the removePlaybackInfoChangeListener() method always succeeds, so we
+ // do not need to catch the returned value.
- ret = mc_client_unset_repeat_mode_update_cb(handle_);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
- return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Unable to unregister repeat mode listener",
- ("mc_client_unset_repeat_mode_update_cb() error: %d, message: %s",
- ret, get_error_message(ret)));
- }
+ mc_client_unset_playback_update_cb(handle_);
+ mc_client_unset_shuffle_mode_update_cb(handle_);
+ mc_client_unset_repeat_mode_update_cb(handle_);
+ mc_client_unset_metadata_update_cb(handle_);
- ret = mc_client_unset_metadata_update_cb(handle_);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
- LoggerE("Unable to unregister metadata listener, error: %d", ret);
- return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Unable to unregister metadata listener",
- ("mc_client_unset_metadata_update_cb() error: %d, message: %s", ret,
- get_error_message(ret)));
- }
- }
+ playback_info_listener_ = nullptr;
return PlatformResult(ErrorCode::NO_ERROR);
-};
+}
void MediaControllerClient::OnPlaybackUpdate(const char* server_name, mc_playback_h playback,
void* user_data) {
int ret;
ret = bundle_add(bundle, "replyId", reply_id.c_str());
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
+ if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
return LogAndCreateResult(
ErrorCode::UNKNOWN_ERR, "Unable to add replyId to bundle",
("bundle_add(replyId) error: %d, message: %s", ret, get_error_message(ret)));
}
ret = bundle_add(bundle, "data", data.serialize().c_str());
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
+ if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
return LogAndCreateResult(
ErrorCode::UNKNOWN_ERR, "Unable to add data to bundle",
("bundle_add(data) error: %d, message: %s", ret, get_error_message(ret)));
ret = mc_client_send_custom_command(handle_, server_name.c_str(), command.c_str(), bundle,
OnCommandReply, this);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
+ if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
return LogAndCreateResult(
ErrorCode::UNKNOWN_ERR, "Error sending custom command",
("mc_client_send_custom_command() error: %d, message: %s", ret, get_error_message(ret)));
};
ret = bundle_get_str(bundle, "replyId", &reply_id_str);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
+ if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
LoggerE("bundle_get_str(replyId) failed, error: %d", ret);
return;
}
reply_o["replyId"] = picojson::value(std::string(reply_id_str));
ret = bundle_get_str(bundle, "data", &data_str);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
+ if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
LoggerE("bundle_get_str(data) failed, error: %d", ret);
return;
}
int ret;
ret = mc_client_send_playback_state_command(handle_, server_name.c_str(),
static_cast<mc_playback_states_e>(state_e));
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
+ if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Error sending playback state",
("mc_client_send_playback_state_command() error: %d, message: %s",
ret, get_error_message(ret)));
PlatformResult MediaControllerClient::SendPlaybackPosition(const std::string& server_name,
double position) {
- // TODO(r.galka) implement when dedicated method will be available in CAPI
+ ScopeLogger();
+ int ret = mc_client_send_playback_position_command(handle_, server_name.c_str(),
+ static_cast<unsigned long long>(position));
+ if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
+ return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Error sending playback position",
+ ("mc_client_send_playback_position_command() error: %d, message: %s",
+ ret, get_error_message(ret)));
+ }
- return LogAndCreateResult(ErrorCode::NOT_SUPPORTED_ERR, "Not supported");
+ return PlatformResult(ErrorCode::NO_ERROR);
}
PlatformResult MediaControllerClient::SendShuffleMode(const std::string& server_name, bool mode) {
- // TODO(r.galka) implement when dedicated method will be available in CAPI
+ ScopeLogger();
+ int ret = mc_client_send_shuffle_mode_command(handle_, server_name.c_str(),
+ mode ? MC_SHUFFLE_MODE_ON : MC_SHUFFLE_MODE_OFF);
+ if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
+ return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Error sending shuffle mode",
+ ("mc_client_send_shuffle_mode_command() error: %d, message: %s", ret,
+ get_error_message(ret)));
+ }
- return LogAndCreateResult(ErrorCode::NOT_SUPPORTED_ERR, "Not supported");
+ return PlatformResult(ErrorCode::NO_ERROR);
}
PlatformResult MediaControllerClient::SendRepeatMode(const std::string& server_name, bool mode) {
- // TODO(r.galka) implement when dedicated method will be available in CAPI
+ ScopeLogger();
+ int ret = mc_client_send_repeat_mode_command(handle_, server_name.c_str(),
+ mode ? MC_REPEAT_MODE_ON : MC_REPEAT_MODE_OFF);
+ if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
+ return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Error sending repeat mode",
+ ("mc_client_send_repeat_mode_command() error: %d, message: %s", ret,
+ get_error_message(ret)));
+ }
- return LogAndCreateResult(ErrorCode::NOT_SUPPORTED_ERR, "Not supported");
+ return PlatformResult(ErrorCode::NO_ERROR);
}
} // namespace mediacontroller
const picojson::value& data, const std::string& reply_id,
const JsonCallback& reply_cb);
- common::PlatformResult SetServerStatusChangeListener(JsonCallback callback);
- common::PlatformResult SetPlaybackInfoListener(JsonCallback callback);
+ common::PlatformResult SetServerStatusChangeListener(const JsonCallback& callback);
+ common::PlatformResult UnsetServerStatusChangeListener();
+
+ common::PlatformResult SetPlaybackInfoListener(const JsonCallback& callback);
+ common::PlatformResult UnsetPlaybackInfoListener();
private:
mc_client_h handle_;
Instance::PostMessage(this, data->serialize().c_str());
};
- server_->SetChangeRequestPlaybackInfoListener(callback);
+ auto result = server_->SetChangeRequestPlaybackInfoListener(callback);
+ if (!result) {
+ LogAndReportError(result, &out);
+ }
ReportSuccess(out);
}
return;
}
- server_->SetChangeRequestPlaybackInfoListener(nullptr);
+ auto result = server_->UnsetChangeRequestPlaybackInfoListener();
+ if (!result) {
+ LogAndReportError(result, &out);
+ }
}
void MediaControllerInstance::MediaControllerServerAddCommandListener(const picojson::value& args,
Instance::PostMessage(this, request->serialize().c_str());
};
- server_->set_command_listener(on_command);
+ auto result = server_->SetCommandListener(on_command);
+ if (!result) {
+ LogAndReportError(result, &out);
+ }
ReportSuccess(out);
}
return;
}
- server_->set_command_listener(nullptr);
+ auto result = server_->UnsetCommandListener();
+ if (!result) {
+ LogAndReportError(result, &out);
+ }
ReportSuccess(out);
}
Instance::PostMessage(this, data->serialize().c_str());
};
- client_->SetServerStatusChangeListener(callback);
+ auto result = client_->SetServerStatusChangeListener(callback);
+ if (!result) {
+ LogAndReportError(result, &out);
+ }
ReportSuccess(out);
}
return;
}
- client_->SetServerStatusChangeListener(nullptr);
+ auto result = client_->UnsetServerStatusChangeListener();
+ if (!result) {
+ LogAndReportError(result, &out);
+ }
}
void MediaControllerInstance::MediaControllerServerInfoAddPlaybackInfoChangeListener(
Instance::PostMessage(this, data->serialize().c_str());
};
- client_->SetPlaybackInfoListener(callback);
+ auto result = client_->SetPlaybackInfoListener(callback);
+ if (!result) {
+ LogAndReportError(result, &out);
+ }
ReportSuccess(out);
}
return;
}
- client_->SetPlaybackInfoListener(nullptr);
+ auto result = client_->UnsetPlaybackInfoListener();
+ if (!result) {
+ LogAndReportError(result, &out);
+ }
}
#undef CHECK_EXIST
MediaControllerServer::~MediaControllerServer() {
ScopeLogger();
- if (handle_) {
- int ret;
- ret = mc_server_unset_custom_command_received_cb(handle_);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
- LoggerE("Unable to unset command callback, error: %d", ret);
- }
+ if (nullptr != change_request_playback_info_listener_ &&
+ !UnsetChangeRequestPlaybackInfoListener()) {
+ LoggerE("Failed to unset change request playback info listener");
+ }
- ret = mc_server_destroy(handle_);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
- LoggerE("mc_server_destroy() failed, error: %d", ret);
- }
+ if (nullptr != command_listener_ && !UnsetCommandListener()) {
+ LoggerE("Failed to unset command listener");
+ }
+
+ if (nullptr != handle_ && MEDIA_CONTROLLER_ERROR_NONE != mc_server_destroy(handle_)) {
+ LoggerE("Unable to destroy media controller server");
}
}
ScopeLogger();
int ret = mc_server_create(&handle_);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
+ if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
return LogAndCreateResult(
ErrorCode::UNKNOWN_ERR, "Unable to create media controller server",
("mc_server_create() error: %d, message: %s", ret, get_error_message(ret)));
}
- ret = mc_server_set_custom_command_received_cb(handle_, OnCommandReceived, this);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
- return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Unable to set command callback",
- ("mc_server_set_custom_command_received_cb() error: %d, message: %s",
- ret, get_error_message(ret)));
- }
-
return PlatformResult(ErrorCode::NO_ERROR);
}
}
int ret = mc_server_set_playback_state(handle_, static_cast<mc_playback_states_e>(state_int));
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
+ if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
return LogAndCreateResult(
ErrorCode::UNKNOWN_ERR, "Error setting playback state",
("mc_server_set_playback_state() error: %d, message: %s", ret, get_error_message(ret)));
}
ret = mc_server_update_playback_info(handle_);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
+ if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
return LogAndCreateResult(
ErrorCode::UNKNOWN_ERR, "Error updating playback info",
("mc_server_update_playback_info() error: %d, message: %s", ret, get_error_message(ret)));
ScopeLogger();
int ret = mc_server_set_playback_position(handle_, static_cast<unsigned long long>(position));
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
+ if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
return LogAndCreateResult(
ErrorCode::UNKNOWN_ERR, "Error setting playback position",
("mc_server_set_playback_position() error: %d, message: %s", ret, get_error_message(ret)));
}
ret = mc_server_update_playback_info(handle_);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
+ if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
return LogAndCreateResult(
ErrorCode::UNKNOWN_ERR, "Error updating playback info",
("mc_server_update_playback_info() error: %d, message: %s", ret, get_error_message(ret)));
ScopeLogger();
int ret = mc_server_update_shuffle_mode(handle_, mode ? MC_SHUFFLE_MODE_ON : MC_SHUFFLE_MODE_OFF);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
+ if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
return LogAndCreateResult(
ErrorCode::UNKNOWN_ERR, "Error updating shuffle mode",
("mc_server_update_shuffle_mode() error: %d, message: %s", ret, get_error_message(ret)));
ScopeLogger();
int ret = mc_server_update_repeat_mode(handle_, mode ? MC_REPEAT_MODE_ON : MC_REPEAT_MODE_OFF);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
+ if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
return LogAndCreateResult(
ErrorCode::UNKNOWN_ERR, "Error updating repeat mode",
("mc_server_update_repeat_mode() error: %d, message: %s", ret, get_error_message(ret)));
ret = mc_server_set_metadata(handle_, static_cast<mc_meta_e>(attribute_int),
i->second.to_str().c_str());
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
+ if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Error setting metadata",
("mc_server_set_metadata(%s) error: %d, message: %s",
i->first.c_str(), ret, get_error_message(ret)));
}
ret = mc_server_update_metadata(handle_);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
+ if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
return LogAndCreateResult(
ErrorCode::UNKNOWN_ERR, "Error updating metadata",
("mc_server_update_metadata() error: %d, message: %s", ret, get_error_message(ret)));
};
ret = bundle_get_str(bundle, "data", &data_str);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
+ if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
LoggerE("bundle_get_str(data) failed, error: %d", ret);
return;
}
ret = bundle_get_str(bundle, "replyId", &reply_id_str);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
+ if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
LoggerE("bundle_get_str(replyId) failed, error: %d", ret);
return;
}
return;
}
- // TODO(r.galka) CAPI have no dedicated methods for position/shuffle/repeat change.
- // It should be updated when new version of CAPI will be available.
- // For now implementation is using internal commands.
- if (command == kInternalCommandSendPlaybackPosition) {
- double position = data.get("position").get<double>();
- server->SetPlaybackPosition(position);
- server->OnPlaybackPositionCommand(client_name, static_cast<unsigned long long>(position),
- server);
- server->CommandReply(client_name, reply_id_str, data);
- return;
- }
- if (command == kInternalCommandSendShuffleMode) {
- bool mode = data.get("mode").get<bool>();
- server->SetShuffleMode(mode);
- server->OnShuffleModeCommand(client_name, mode ? MC_SHUFFLE_MODE_ON : MC_SHUFFLE_MODE_OFF,
- server);
- server->CommandReply(client_name, reply_id_str, data);
- return;
- }
- if (command == kInternalCommandSendRepeatMode) {
- bool mode = data.get("mode").get<bool>();
- server->SetRepeatMode(mode);
- server->OnRepeatModeCommand(client_name, mode ? MC_REPEAT_MODE_ON : MC_REPEAT_MODE_OFF, server);
- server->CommandReply(client_name, reply_id_str, data);
- return;
- }
+ picojson::value request = picojson::value(picojson::object());
+ picojson::object& request_o = request.get<picojson::object>();
- if (server->command_listener_) {
- picojson::value request = picojson::value(picojson::object());
- picojson::object& request_o = request.get<picojson::object>();
+ request_o["clientName"] = picojson::value(std::string(client_name));
+ request_o["command"] = picojson::value(std::string(command));
+ request_o["replyId"] = picojson::value(std::string(reply_id_str));
+ request_o["data"] = data;
- request_o["clientName"] = picojson::value(std::string(client_name));
- request_o["command"] = picojson::value(std::string(command));
- request_o["replyId"] = picojson::value(std::string(reply_id_str));
- request_o["data"] = data;
-
- server->command_listener_(&request);
- }
+ server->command_listener_(&request);
}
PlatformResult MediaControllerServer::CommandReply(const std::string& client_name,
};
ret = bundle_add(bundle, "replyId", reply_id.c_str());
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
+ if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
return LogAndCreateResult(
ErrorCode::UNKNOWN_ERR, "Unable to add replyId to bundle",
("bundle_add(replyId) error: %d, message: %s", ret, get_error_message(ret)));
}
ret = bundle_add(bundle, "data", data.serialize().c_str());
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
+ if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
return LogAndCreateResult(
ErrorCode::UNKNOWN_ERR, "Unable to add data to bundle",
("bundle_add(data) error: %d, message: %s", ret, get_error_message(ret)));
}
ret = mc_server_send_command_reply(handle_, client_name.c_str(), 0, bundle);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
+ if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
return LogAndCreateResult(
ErrorCode::UNKNOWN_ERR, "Error sending command reply",
("mc_server_send_command_reply() error: %d, message: %s", ret, get_error_message(ret)));
return PlatformResult(ErrorCode::NO_ERROR);
}
-PlatformResult MediaControllerServer::SetChangeRequestPlaybackInfoListener(JsonCallback callback) {
+PlatformResult MediaControllerServer::SetCommandListener(const JsonCallback& callback) {
ScopeLogger();
- if (callback && change_request_playback_info_listener_) {
- return LogAndCreateResult(ErrorCode::INVALID_STATE_ERR, "Listener already registered");
+ int ret = mc_server_set_custom_command_received_cb(handle_, OnCommandReceived, this);
+ if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
+ return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Unable to set command callback",
+ ("mc_server_set_custom_command_received_cb() error: %d, message: %s",
+ ret, get_error_message(ret)));
}
+ command_listener_ = callback;
- change_request_playback_info_listener_ = callback;
+ return PlatformResult(ErrorCode::NO_ERROR);
+}
- int ret;
- if (callback) { // set platform callbacks
- ret = mc_server_set_playback_state_command_received_cb(handle_, OnPlaybackStateCommand, this);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
- return LogAndCreateResult(
- ErrorCode::UNKNOWN_ERR, "Unable to set playback state command listener",
- ("mc_server_set_playback_state_command_received_cb() error: %d, message: %s", ret,
- get_error_message(ret)));
- }
- } else { // unset platform callbacks
- ret = mc_server_unset_playback_state_command_received_cb(handle_);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
- return LogAndCreateResult(
- ErrorCode::UNKNOWN_ERR, "Unable to unset playback state command listener",
- ("mc_server_unset_playback_state_command_received_cb() error: %d, message: %s", ret,
- get_error_message(ret)));
+PlatformResult MediaControllerServer::UnsetCommandListener() {
+ ScopeLogger();
+
+ int ret = mc_server_unset_custom_command_received_cb(handle_);
+ if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
+ return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Unable to unset command callback",
+ ("mc_server_set_custom_command_received_cb() error: %d, message: %s",
+ ret, get_error_message(ret)));
+ }
+ command_listener_ = nullptr;
+
+ return PlatformResult(ErrorCode::NO_ERROR);
+}
+
+PlatformResult MediaControllerServer::SetChangeRequestPlaybackInfoListener(
+ const JsonCallback& callback) {
+ ScopeLogger();
+ int failed_setter = 0;
+ SCOPE_EXIT {
+ int (*unsetters[])(mc_server_h) = {
+ mc_server_unset_playback_state_command_received_cb,
+ mc_server_unset_playback_position_command_received_cb,
+ mc_server_unset_shuffle_mode_command_received_cb,
+ /*mc_server_unset_repeat_mode_command_received_cb the last unsetter will never be used*/};
+ for (int i = 0; i < failed_setter; ++i) {
+ auto ret = unsetters[i](handle_);
+ if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
+ LoggerE("Fail (%d) returned by the [%d] unsetter", ret, i);
+ }
}
+ };
+
+ int ret = mc_server_set_playback_state_command_received_cb(handle_, OnPlaybackStateCommand, this);
+ if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
+ return LogAndCreateResult(
+ ErrorCode::UNKNOWN_ERR, "Unable to set playback state command listener",
+ ("mc_server_set_playback_state_command_received_cb() error: %d, message: %s", ret,
+ get_error_message(ret)));
+ }
+
+ ret =
+ mc_server_set_playback_position_command_received_cb(handle_, OnPlaybackPositionCommand, this);
+ if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
+ failed_setter = 1;
+ return LogAndCreateResult(
+ ErrorCode::UNKNOWN_ERR, "Unable to set playback position command listener",
+ ("mc_server_set_playback_state_command_received_cb() error: %d, message: %s", ret,
+ get_error_message(ret)));
+ }
+
+ ret = mc_server_set_shuffle_mode_command_received_cb(handle_, OnShuffleModeCommand, this);
+ if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
+ failed_setter = 2;
+ return LogAndCreateResult(
+ ErrorCode::UNKNOWN_ERR, "Unable to set shuffle mode command listener",
+ ("mc_server_set_shuffle_mode_command_received_cb() error: %d, message: %s", ret,
+ get_error_message(ret)));
+ }
+
+ ret = mc_server_set_repeat_mode_command_received_cb(handle_, OnRepeatModeCommand, this);
+ if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
+ failed_setter = 3;
+ return LogAndCreateResult(
+ ErrorCode::UNKNOWN_ERR, "Unable to set repeat mode command listener",
+ ("mc_server_set_repeat_mode_command_received_cb() error: %d, message: %s", ret,
+ get_error_message(ret)));
+ }
+
+ change_request_playback_info_listener_ = callback;
+
+ return PlatformResult(ErrorCode::NO_ERROR);
+}
+
+PlatformResult MediaControllerServer::UnsetChangeRequestPlaybackInfoListener() {
+ ScopeLogger();
+
+ int ret = mc_server_unset_playback_state_command_received_cb(handle_);
+ if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
+ return LogAndCreateResult(
+ ErrorCode::UNKNOWN_ERR, "Unable to unset playback state command listener",
+ ("mc_server_unset_playback_state_command_received_cb() error: %d, message: %s", ret,
+ get_error_message(ret)));
}
+ ret = mc_server_unset_playback_position_command_received_cb(handle_);
+ if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
+ return LogAndCreateResult(
+ ErrorCode::UNKNOWN_ERR, "Unable to unset playback position command listener",
+ ("mc_server_unset_playback_position_command_received_cb() error: %d, message: %s", ret,
+ get_error_message(ret)));
+ }
+
+ ret = mc_server_unset_shuffle_mode_command_received_cb(handle_);
+ if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
+ return LogAndCreateResult(
+ ErrorCode::UNKNOWN_ERR, "Unable to unset shuffle mode command listener",
+ ("mc_server_unset_shuffle_mode_command_received_cb() error: %d, message: %s", ret,
+ get_error_message(ret)));
+ }
+
+ ret = mc_server_unset_repeat_mode_command_received_cb(handle_);
+ if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
+ return LogAndCreateResult(
+ ErrorCode::UNKNOWN_ERR, "Unable to unset repeat mode command listener",
+ ("mc_server_unset_repeat_mode_command_received_cb() error: %d, message: %s", ret,
+ get_error_message(ret)));
+ }
+
+ change_request_playback_info_listener_ = nullptr;
+
return PlatformResult(ErrorCode::NO_ERROR);
}
common::PlatformResult SetRepeatMode(bool mode);
common::PlatformResult SetMetadata(const picojson::object& metadata);
- common::PlatformResult SetChangeRequestPlaybackInfoListener(JsonCallback callback);
+ common::PlatformResult SetChangeRequestPlaybackInfoListener(const JsonCallback& callback);
+ common::PlatformResult UnsetChangeRequestPlaybackInfoListener();
common::PlatformResult CommandReply(const std::string& client_name, const std::string& reply_id,
const picojson::value& data);
- void set_command_listener(const JsonCallback& func) {
- command_listener_ = func;
- }
+ common::PlatformResult SetCommandListener(const JsonCallback& callback);
+ common::PlatformResult UnsetCommandListener();
private:
mc_server_h handle_;
projects / platform / core / api / webapi-plugins.git / commitdiff