Object.defineProperties(this, {
play: {
get: function() {
- return getPlaybackAbility(serverName, MediaControllerPlaybackState.PLAY);
+ return getPlaybackAbility(serverName, MediaControllerPlaybackAction.PLAY);
},
set: function() {},
enumerable: true
},
pause: {
get: function() {
- return getPlaybackAbility(serverName, MediaControllerPlaybackState.PAUSE);
+ return getPlaybackAbility(
+ serverName,
+ MediaControllerPlaybackAction.PAUSE
+ );
},
set: function() {},
enumerable: true
},
stop: {
get: function() {
- return getPlaybackAbility(serverName, MediaControllerPlaybackState.STOP);
+ return getPlaybackAbility(serverName, MediaControllerPlaybackAction.STOP);
},
set: function() {},
enumerable: true
},
next: {
get: function() {
- return getPlaybackAbility(serverName, MediaControllerPlaybackState.NEXT);
+ return getPlaybackAbility(serverName, MediaControllerPlaybackAction.NEXT);
},
set: function() {},
enumerable: true
},
prev: {
get: function() {
- return getPlaybackAbility(serverName, MediaControllerPlaybackState.PREV);
+ return getPlaybackAbility(serverName, MediaControllerPlaybackAction.PREV);
},
set: function() {},
enumerable: true
get: function() {
return getPlaybackAbility(
serverName,
- MediaControllerPlaybackState.FORWARD
+ MediaControllerPlaybackAction.FORWARD
);
},
set: function() {},
get: function() {
return getPlaybackAbility(
serverName,
- MediaControllerPlaybackState.REWIND
+ MediaControllerPlaybackAction.REWIND
);
},
set: function() {},
},
togglePlayPause: {
get: function() {
- return getPlaybackAbility(serverName, 'TOGGLE_PLAY_PAUSE');
+ return getPlaybackAbility(
+ serverName,
+ MediaControllerPlaybackAction.TOGGLE_PLAY_PAUSE
+ );
},
set: function() {},
enumerable: true
return MediaControllerSubtitlesListener.addListener(args.listener);
};
-MediaControllerSubtitles.prototype.removeChangeRequestListener = function(watchId) {
+MediaControllerSubtitles.prototype.removeChangeRequestListener = function() {
var args = validator_.validateArgs(arguments, [
{ name: 'watchId', type: types_.LONG }
]);
ReplyCommandListener.requestIdToListenerId[replyListenerId] = result.requestId;
};
- this.addModeChangeListener = function(listener) {
+ this.addModeChangeListener = function() {
var args = validator_.validateArgs(arguments, [
{ name: 'listener', type: types_.FUNCTION }
]);
return SubtitlesChangeListener.addServerInfoListener(args.listener, _serverName);
};
- this.removeModeChangeListener = function(watchId) {
+ this.removeModeChangeListener = function() {
var args = validator_.validateArgs(arguments, [
{ name: 'watchId', type: types_.LONG }
]);
return MediaControllerMode360Listener.addListener(args.listener);
};
-MediaControllerMode360.prototype.removeChangeRequestListener = function(watchId) {
+MediaControllerMode360.prototype.removeChangeRequestListener = function() {
var args = validator_.validateArgs(arguments, [
{ name: 'watchId', type: types_.LONG }
]);
ReplyCommandListener.requestIdToListenerId[replyListenerId] = result.requestId;
};
- this.addModeChangeListener = function(listener) {
+ this.addModeChangeListener = function() {
var args = validator_.validateArgs(arguments, [
{ name: 'listener', type: types_.FUNCTION }
]);
return Mode360ChangeListener.addServerInfoListener(args.listener, _serverName);
};
- this.removeModeChangeListener = function(watchId) {
+ this.removeModeChangeListener = function() {
var args = validator_.validateArgs(arguments, [
{ name: 'watchId', type: types_.LONG }
]);
get: function() {
return _type;
},
- set: function(v) {
+ set: function() {
var args = validator_.validateArgs(arguments, [
{
name: 'type',
return MediaControllerDisplayModeListener.addListener(args.listener);
};
-MediaControllerDisplayMode.prototype.removeChangeRequestListener = function(watchId) {
+MediaControllerDisplayMode.prototype.removeChangeRequestListener = function() {
var args = validator_.validateArgs(arguments, [
{ name: 'watchId', type: types_.LONG }
]);
ReplyCommandListener.requestIdToListenerId[replyListenerId] = result.requestId;
};
- this.addModeChangeListener = function(listener) {
+ this.addModeChangeListener = function() {
var args = validator_.validateArgs(arguments, [
{ name: 'listener', type: types_.FUNCTION }
]);
_serverName
);
};
- this.removeModeChangeListener = function(watchId) {
+ this.removeModeChangeListener = function() {
var args = validator_.validateArgs(arguments, [
{ name: 'watchId', type: types_.LONG }
]);
get: function() {
return _displayRotation;
},
- set: function(v) {
+ set: function() {
var args = validator_.validateArgs(arguments, [
{
name: 'displayRotation',
return MediaControllerDisplayRotationListener.addListener(args.listener);
};
-MediaControllerDisplayRotation.prototype.removeChangeRequestListener = function(watchId) {
+MediaControllerDisplayRotation.prototype.removeChangeRequestListener = function() {
var args = validator_.validateArgs(arguments, [
{ name: 'watchId', type: types_.LONG }
]);
ReplyCommandListener.requestIdToListenerId[replyListenerId] = result.requestId;
};
- this.addDisplayRotationChangeListener = function(listener) {
+ this.addDisplayRotationChangeListener = function() {
var args = validator_.validateArgs(arguments, [
{ name: 'listener', type: types_.FUNCTION }
]);
);
};
- this.removeDisplayRotationChangeListener = function(watchId) {
+ this.removeDisplayRotationChangeListener = function() {
var args = validator_.validateArgs(arguments, [
{ name: 'watchId', type: types_.LONG }
]);
this.playback.state = state;
};
-var updatePlaybackState = function(state) {
+var updatePlaybackState = function() {
var args = validator_.validateArgs(arguments, [
{
name: 'state',
updateIconURI(iconURI);
};
-var updateIconURI = function(iconURI) {
+var updateIconURI = function() {
var args = validator_.validateArgs(arguments, [
{ name: 'iconURI', type: types_.STRING, nullable: true }
]);
}
};
-MediaControllerServer.prototype.updatePlaybackPosition = function(position) {
+MediaControllerServer.prototype.updatePlaybackPosition = function() {
utils_.printDeprecationWarningFor('updatePlaybackPosition()');
var args = validator_.validateArgs(arguments, [
{ name: 'position', type: types_.UNSIGNED_LONG_LONG }
this.playback.ageRating = rating;
};
-var updatePlaybackAgeRating = function(rating) {
+var updatePlaybackAgeRating = function() {
var args = validator_.validateArgs(arguments, [
{
name: 'rating',
this.playback.contentType = contentType;
};
-var updatePlaybackContentType = function(contentType) {
+var updatePlaybackContentType = function() {
var args = validator_.validateArgs(arguments, [
{
name: 'contentType',
}
};
-MediaControllerServer.prototype.updateRepeatMode = function(mode) {
+MediaControllerServer.prototype.updateRepeatMode = function() {
utils_.printDeprecationWarningFor('updateRepeatMode()', 'updateRepeatState()');
var args = validator_.validateArgs(arguments, [
{ name: 'mode', type: types_.BOOLEAN }
this.playback.repeatState = state;
};
-var updateRepeatState = function(state) {
+var updateRepeatState = function() {
var args = validator_.validateArgs(arguments, [
{
name: 'state',
}
};
-MediaControllerServer.prototype.updateMetadata = function(metadata) {
+MediaControllerServer.prototype.updateMetadata = function() {
utils_.printDeprecationWarningFor(
'updateMetadata()',
'MediaControllerMetadata.save()'
this.playback.metadata.save();
};
-MediaControllerServer.prototype.addChangeRequestPlaybackInfoListener = function(
- listener
-) {
+MediaControllerServer.prototype.addChangeRequestPlaybackInfoListener = function() {
utils_.printDeprecationWarningFor(
'MediaControllerServer.addChangeRequestPlaybackInfoListener()',
'MediaControllerServerPlaybackInfo.addChangeRequestListener()'
removeChangeRequestPlaybackInfoListener(watchId);
};
-var removeChangeRequestPlaybackInfoListener = function(watchId) {
+var removeChangeRequestPlaybackInfoListener = function() {
var args = validator_.validateArgs(arguments, [
{ name: 'watchId', type: types_.LONG }
]);
}
};
-MediaControllerServer.prototype.addCommandListener = function(listener) {
+MediaControllerServer.prototype.addCommandListener = function() {
var args = validator_.validateArgs(arguments, [
{ name: 'listener', type: types_.FUNCTION }
]);
return ServerCommandListener.addListener(args.listener);
};
-MediaControllerServer.prototype.removeCommandListener = function(watchId) {
+MediaControllerServer.prototype.removeCommandListener = function() {
var args = validator_.validateArgs(arguments, [
{ name: 'watchId', type: types_.LONG }
]);
return new MediaControllerPlaylist(native_.getResultObject(result));
};
-MediaControllerServer.prototype.savePlaylist = function(
- playlist,
- successCallback,
- errorCallback
-) {
+MediaControllerServer.prototype.savePlaylist = function() {
utils_.printDeprecationWarningFor(
'MediaControllerServer.savePlaylist()',
'MediaControllerPlaylists.savePlaylist()'
savePlaylist.apply(this, arguments);
};
-var savePlaylist = function(playlist, successCallback, errorCallback) {
+var savePlaylist = function() {
var args = validator_.validateArgs(arguments, [
{
name: 'playlist',
}
};
-MediaControllerServer.prototype.deletePlaylist = function(
- playlistName,
- successCallback,
- errorCallback
-) {
+MediaControllerServer.prototype.deletePlaylist = function() {
utils_.printDeprecationWarningFor(
'MediaControllerServer.deletePlaylist()',
'MediaControllerPlaylists.deletePlaylist()'
deletePlaylist.apply(this, arguments);
};
-var deletePlaylist = function(playlistName, successCallback, errorCallback) {
+var deletePlaylist = function() {
var args = validator_.validateArgs(arguments, [
{ name: 'playlistName', type: types_.STRING },
{
edit_.disallow();
};
-var updatePlaybackItem = function(playlistName, index) {
+var updatePlaybackItem = function() {
var args = validator_.validateArgs(arguments, [
{ name: 'playlistName', type: types_.STRING },
{ name: 'index', type: types_.STRING }
}
};
-MediaControllerServer.prototype.getAllPlaylists = function(
- successCallback,
- errorCallback
-) {
+MediaControllerServer.prototype.getAllPlaylists = function() {
utils_.printDeprecationWarningFor(
'MediaControllerServer.getAllPlaylists()',
'MediaControllerPlaylists.getAllPlaylists()'
serverGetAllPlaylists.apply(this, arguments);
};
-var serverGetAllPlaylists = function(successCallback, errorCallback) {
+var serverGetAllPlaylists = function() {
var args = validator_.validateArgs(arguments, [
{
name: 'successCallback',
this.data = xwalk.utils.type.isNullOrUndefined(data) ? null : new tizen.Bundle(data);
}
-MediaControllerServer.prototype.setSearchRequestListener = function(listener) {
+MediaControllerServer.prototype.setSearchRequestListener = function() {
var args = validator_.validateArgs(arguments, [
{ name: 'listener', type: types_.FUNCTION }
]);
return ability.value;
};
-var setSimpleAbility = function(abilityType, support) {
+var setSimpleAbility = function() {
var args = validator_.validateArgs(arguments, [
{
name: 'abilityType',
}
};
-var checkSupportValue = function(support) {
+var checkSupportValue = function() {
var args = validator_.validateArgs(arguments, [
{
name: 'support',
});
}
-MediaControllerClientInfo.prototype.sendEvent = function(event, data, callback) {
+MediaControllerClientInfo.prototype.sendEvent = function() {
var args = validator_.validateArgs(arguments, [
{ name: 'eventName', type: types_.STRING },
{ name: 'eventData', type: types_.DICTIONARY, nullable: true },
}
};
-MediaControllerClient.prototype.setCustomEventListener = function(listener) {
+MediaControllerClient.prototype.setCustomEventListener = function() {
var args = validator_.validateArgs(arguments, [
{ name: 'listener', type: types_.FUNCTION }
]);
}
};
-MediaControllerClient.prototype.findServers = function(successCallback, errorCallback) {
+MediaControllerClient.prototype.findServers = function() {
var args = validator_.validateArgs(arguments, [
{ name: 'successCallback', type: types_.FUNCTION },
{ name: 'errorCallback', type: types_.FUNCTION, optional: true, nullable: true }
get: function() {
return contentType_;
},
- set: function(newContentType) {
+ set: function() {
var args = validator_.validateArgs(arguments, [
{
name: 'newContentType',
get: function() {
return category_;
},
- set: function(newCategory) {
+ set: function() {
var args = validator_.validateArgs(arguments, [
{
name: 'newCategory',
get: function() {
return keyword_;
},
- set: function(newKeyword) {
+ set: function() {
var args = validator_.validateArgs(arguments, [
{
name: 'newKeyword',
});
}
-MediaControllerClient.prototype.addAbilityChangeListener = function(callback) {
+MediaControllerClient.prototype.addAbilityChangeListener = function() {
var args = validator_.validateArgs(arguments, [
{
name: 'callback',
return ClientAbilityChangeListener.addListener(args.callback);
};
-MediaControllerClient.prototype.removeAbilityChangeListener = function(callbackId) {
+MediaControllerClient.prototype.removeAbilityChangeListener = function() {
var args = validator_.validateArgs(arguments, [
{
name: 'callbackId',
}
};
-MediaControllerClient.prototype.findSubscribedServers = function(
- successCallback,
- errorCallback
-) {
+MediaControllerClient.prototype.findSubscribedServers = function() {
var args = validator_.validateArgs(arguments, [
{
name: 'successCallback',
});
}
-MediaControllerServerInfo.prototype.sendPlaybackState = function(
- state,
- successCallback,
- errorCallback
-) {
+MediaControllerServerInfo.prototype.sendPlaybackState = function() {
utils_.printDeprecationWarningFor(
'MediaControllerServerInfo.sendPlaybackState()',
'MediaControllerServerInfoPlaybackInfo.sendPlaybackAction()'
native_.call('MediaControllerServerInfoSendPlaybackState', data, callback);
};
-MediaControllerServerInfo.prototype.sendPlaybackPosition = function(
- position,
- successCallback,
- errorCallback
-) {
+MediaControllerServerInfo.prototype.sendPlaybackPosition = function() {
utils_.printDeprecationWarningFor(
'MediaControllerServerInfo.sendPlaybackPosition()',
'MediaControllerServerInfoPlaybackInfo.sendPlaybackPosition()'
native_.call('MediaControllerServerInfoSendPlaybackPosition', data, callback);
};
-MediaControllerServerInfo.prototype.sendShuffleMode = function(
- mode,
- successCallback,
- errorCallback
-) {
+MediaControllerServerInfo.prototype.sendShuffleMode = function() {
utils_.printDeprecationWarningFor(
'MediaControllerServerInfo.sendShuffleMode()',
'MediaControllerServerInfoPlaybackInfo.sendShuffleMode()'
native_.call('MediaControllerServerInfoSendShuffleMode', data, callback);
};
-MediaControllerServerInfo.prototype.sendRepeatMode = function(
- mode,
- successCallback,
- errorCallback
-) {
+MediaControllerServerInfo.prototype.sendRepeatMode = function() {
utils_.printDeprecationWarningFor('sendRepeatMode()', 'sendRepeatState()');
var args = validator_.validateArgs(arguments, [
{ name: 'mode', type: types_.BOOLEAN },
native_.call('MediaControllerServerInfoSendRepeatMode', data, callback);
};
-MediaControllerServerInfo.prototype.sendRepeatState = function(
- state,
- successCallback,
- errorCallback
-) {
+MediaControllerServerInfo.prototype.sendRepeatState = function() {
utils_.printDeprecationWarningFor(
'MediaControllerServerInfo.sendRepeatState()',
'MediaControllerServerInfoPlaybackInfo.sendRepeatState()'
native_.call('MediaControllerServerInfoSendRepeatState', data, callback);
};
-MediaControllerServerInfo.prototype.sendCommand = function(
- command,
- data,
- successCallback,
- errorCallback
-) {
+MediaControllerServerInfo.prototype.sendCommand = function() {
var args = validator_.validateArgs(arguments, [
{ name: 'command', type: types_.STRING },
{ name: 'data', type: types_.DICTIONARY, nullable: true },
ReplyCommandListener.requestIdToListenerId[replyListenerId] = result.requestId;
};
-MediaControllerServerInfo.prototype.sendSearchRequest = function(
- request,
- successCallback,
- errorCallback
-) {
+MediaControllerServerInfo.prototype.sendSearchRequest = function() {
var args = validator_.validateArgs(arguments, [
{ name: 'request', type: types_.ARRAY, values: SearchFilter },
{ name: 'successCallback', type: types_.FUNCTION },
ReplyCommandListener.requestIdToListenerId[replyListenerId] = result.requestId;
};
-MediaControllerServerInfo.prototype.addServerStatusChangeListener = function(listener) {
+MediaControllerServerInfo.prototype.addServerStatusChangeListener = function() {
var args = validator_.validateArgs(arguments, [
{ name: 'listener', type: types_.FUNCTION }
]);
return ServerInfoStatusListener.addServerInfoListener(args.listener, this.name);
};
-MediaControllerServerInfo.prototype.removeServerStatusChangeListener = function(watchId) {
+MediaControllerServerInfo.prototype.removeServerStatusChangeListener = function() {
var args = validator_.validateArgs(arguments, [
{ name: 'watchId', type: types_.LONG }
]);
return addPlaybackInfoChangeListener.apply(this, args);
};
-var addPlaybackInfoChangeListener = function(serverName, listener) {
+var addPlaybackInfoChangeListener = function() {
var args = validator_.validateArgs(arguments, [
{
name: 'serverName',
removePlaybackInfoChangeListener(watchId);
};
-var removePlaybackInfoChangeListener = function(watchId) {
+var removePlaybackInfoChangeListener = function() {
var args = validator_.validateArgs(arguments, [
{ name: 'watchId', type: types_.LONG }
]);
}
};
-MediaControllerServerInfo.prototype.getAllPlaylists = function(
- successCallback,
- errorCallback
-) {
+MediaControllerServerInfo.prototype.getAllPlaylists = function() {
utils_.printDeprecationWarningFor(
'MediaControllerServerInfo.getAllPlaylists',
'MediaControllerPlaylistsInfo.getAllPlaylists'
serverInfoGetAllPlaylists.apply(this, args);
};
-var serverInfoGetAllPlaylists = function(serverName, successCallback, errorCallback) {
+var serverInfoGetAllPlaylists = function() {
var args = validator_.validateArgs(arguments, [
{
name: 'serverName',
var result = native_.call(
'MediaControllerServerInfoGetAllPlaylists',
- { name: args.serverName },
+ { serverName: args.serverName },
callback
);
}
};
-MediaControllerServerInfo.prototype.sendPlaybackItem = function(
- playlistName,
- index,
- state,
- position
-) {
+MediaControllerServerInfo.prototype.sendPlaybackItem = function() {
utils_.printDeprecationWarningFor(
'MediaControllerServerInfo.sendPlaybackItem()',
'MediaControllerPlaylistsInfo.sendPlaybackItem()'
}
};
-MediaControllerServerInfo.prototype.addPlaylistUpdatedListener = function(listener) {
+MediaControllerServerInfo.prototype.addPlaylistUpdatedListener = function() {
utils_.printDeprecationWarningFor(
'MediaControllerServerInfo.addPlaylistUpdatedListener()',
'MediaControllerPlaylistsInfo.addPlaylistUpdateListener()'
return addPlaylistUpdateListener.apply(this, args);
};
-var addPlaylistUpdateListener = function(serverName, listener) {
+var addPlaylistUpdateListener = function() {
var args = validator_.validateArgs(arguments, [
{
name: 'serverName',
removePlaylistUpdateListener(watchId);
};
-var removePlaylistUpdateListener = function(watchId) {
+var removePlaylistUpdateListener = function() {
var args = validator_.validateArgs(arguments, [
{ name: 'watchId', type: types_.LONG }
]);
edit_.disallow();
}
-MediaControllerPlaylist.prototype.addItem = function(index, metadata) {
+MediaControllerPlaylist.prototype.addItem = function() {
var args = validator_.validateArgs(arguments, [
{ name: 'index', type: types_.STRING },
{ name: 'metadata', type: types_.DICTIONARY }
}
};
-MediaControllerPlaylist.prototype.getItems = function(successCallback, errorCallback) {
+MediaControllerPlaylist.prototype.getItems = function() {
var args = validator_.validateArgs(arguments, [
{
name: 'successCallback',
edit_.disallow();
};
-MediaControllerServerPlaybackInfo.prototype.addChangeRequestListener = function(
- listener
-) {
+MediaControllerServerPlaybackInfo.prototype.addChangeRequestListener = function() {
var args = validator_.validateArgs(arguments, [
{
name: 'listener',
var MediaControllerPlaylists = function() {};
-MediaControllerPlaylists.prototype.createPlaylist = function(name) {
+MediaControllerPlaylists.prototype.createPlaylist = function() {
return createPlaylist.apply(this, arguments);
};
-MediaControllerPlaylists.prototype.savePlaylist = function(
- playlist,
- successCallback,
- errorCallback
-) {
+MediaControllerPlaylists.prototype.savePlaylist = function() {
savePlaylist.apply(this, arguments);
};
-MediaControllerPlaylists.prototype.deletePlaylist = function(
- playlistName,
- successCallback,
- errorCallback
-) {
+MediaControllerPlaylists.prototype.deletePlaylist = function() {
deletePlaylist.apply(this, arguments);
};
-MediaControllerPlaylists.prototype.getAllPlaylists = function(
- successCallback,
- errorCallback
-) {
+MediaControllerPlaylists.prototype.getAllPlaylists = function() {
serverGetAllPlaylists.apply(this, arguments);
};
var MediaControllerPlaylistsInfo = function(serverName) {
var _serverName = serverName;
- this.getAllPlaylists = function(successCallback, errorCallback) {
+ this.getAllPlaylists = function() {
var args = [_serverName].concat(Array.prototype.slice.call(arguments));
serverInfoGetAllPlaylists.apply(this, args);
};
- this.sendPlaybackItem = function(
- playlistName,
- index,
- action,
- position,
- replyCallback
- ) {
+ this.sendPlaybackItem = function() {
var args = validator_.validateArgs(arguments, [
{ name: 'playlistName', type: types_.STRING },
{ name: 'index', type: types_.STRING },
ReplyCommandListener.requestIdToListenerId[replyListenerId] = result.requestId;
};
- this.addPlaylistUpdateListener = function(listener) {
+ this.addPlaylistUpdateListener = function() {
var args = [_serverName].concat(Array.prototype.slice.call(arguments));
return addPlaylistUpdateListener.apply(this, args);
};