}
};
+MediaControllerMetadata.prototype.save = function() {
+ var data = {
+ metadata: this
+ };
+
+ var result = native_.callSync('MediaControllerServerUpdateMetadata', data);
+
+ if (native_.isFailure(result)) {
+ throw native_.getErrorObject(result);
+ }
+};
+
var MediaControllerPlaybackInfo = function(data) {
var _state = 'STOP';
var _position = 0;
TOGGLE_PLAY_PAUSE: _togglePlayPause
};
- var result = native_.callSync(
- 'MediaControllerServerSavePlaybackAbilities',
- data
- );
+ var result = native_.callSync('MediaControllerServerSavePlaybackAbilities', data);
if (native_.isFailure(result)) {
throw new native_.getErrorObject(result);
}
Object.defineProperties(this, {
displayRotation: {
get: function() {
- var result = native_.callSync(
- 'MediaControllerDisplayRotationInfoGet',
- {
- name: _serverName
- }
- );
+ var result = native_.callSync('MediaControllerDisplayRotationInfoGet', {
+ name: _serverName
+ });
if (native_.isFailure(result)) {
throw new native_.getErrorObject(result);
}
function MediaControllerServer(data) {
var _iconURI = null;
+ var _playbackInfo = new MediaControllerPlaybackInfo(data);
+ var _playback = new MediaControllerServerPlaybackInfo(data, _playbackInfo);
Object.defineProperties(this, {
playbackInfo: {
- value: new MediaControllerPlaybackInfo(data),
- writable: false,
+ get: function() {
+ return _playbackInfo;
+ },
+ set: function() {},
+ enumerable: true
+ },
+ playback: {
+ get: function() {
+ return _playback;
+ },
+ set: function() {},
enumerable: true
},
iconURI: {
}
MediaControllerServer.prototype.updatePlaybackState = function(state) {
+ utils_.printDeprecationWarningFor('updatePlaybackState()');
+
+ this.playback.state = state;
+};
+
+var updatePlaybackState = function(state) {
var args = validator_.validateArgs(arguments, [
{
name: 'state',
if (native_.isFailure(result)) {
throw native_.getErrorObject(result);
}
-
- edit_.allow();
- this.playbackInfo.state = args.state;
- edit_.disallow();
};
MediaControllerServer.prototype.updateIconURI = function(iconURI) {
};
MediaControllerServer.prototype.updatePlaybackPosition = function(position) {
+ utils_.printDeprecationWarningFor('updatePlaybackPosition()');
+ var args = validator_.validateArgs(arguments, [
+ { name: 'position', type: types_.UNSIGNED_LONG_LONG }
+ ]);
+ this.playback.position = args.position;
+};
+
+var updatePlaybackPosition = function(position) {
+ if (position < 0) {
+ throw new WebAPIException(
+ WebAPIException.INVALID_VALUES_ERR,
+ 'Cannot set playback position to ' + position
+ );
+ }
+
var args = validator_.validateArgs(arguments, [
{ name: 'position', type: types_.UNSIGNED_LONG_LONG }
]);
if (native_.isFailure(result)) {
throw native_.getErrorObject(result);
}
-
- edit_.allow();
- this.playbackInfo.position = args.position;
- edit_.disallow();
};
MediaControllerServer.prototype.updatePlaybackAgeRating = function(rating) {
+ utils_.printDeprecationWarningFor('updatePlaybackAgeRating()');
+ this.playback.ageRating = rating;
+};
+
+var updatePlaybackAgeRating = function(rating) {
var args = validator_.validateArgs(arguments, [
{
name: 'rating',
if (native_.isFailure(result)) {
throw native_.getErrorObject(result);
}
-
- edit_.allow();
- this.playbackInfo.ageRating = args.rating;
- edit_.disallow();
};
MediaControllerServer.prototype.updatePlaybackContentType = function(contentType) {
+ utils_.printDeprecationWarningFor('updatePlaybackContentType()');
+ this.playback.contentType = contentType;
+};
+
+var updatePlaybackContentType = function(contentType) {
var args = validator_.validateArgs(arguments, [
{
name: 'contentType',
contentType: args.contentType
};
- var result = native_.callSync(
- 'MediaControllerServerUpdatePlaybackContentType',
- data
- );
+ var result = native_.callSync('MediaControllerServerUpdatePlaybackContentType', data);
if (native_.isFailure(result)) {
throw native_.getErrorObject(result);
}
-
- edit_.allow();
- this.playbackInfo.contentType = args.contentType;
- edit_.disallow();
};
MediaControllerServer.prototype.updateShuffleMode = function(mode) {
+ utils_.printDeprecationWarningFor('updateShuffleMode()');
+ this.playback.shuffleMode = mode;
+};
+
+var updateShuffleMode = function() {
var args = validator_.validateArgs(arguments, [
{ name: 'mode', type: types_.BOOLEAN }
]);
if (native_.isFailure(result)) {
throw native_.getErrorObject(result);
}
-
- edit_.allow();
- this.playbackInfo.shuffleMode = args.mode;
- edit_.disallow();
};
MediaControllerServer.prototype.updateRepeatMode = function(mode) {
edit_.disallow();
};
-MediaControllerServer.prototype.updateRepeatState = function() {
+MediaControllerServer.prototype.updateRepeatState = function(state) {
+ utils_.printDeprecationWarningFor('updateRepeatState()');
+ this.playback.repeatState = state;
+};
+
+var updateRepeatState = function(state) {
var args = validator_.validateArgs(arguments, [
{
name: 'state',
if (native_.isFailure(result)) {
throw native_.getErrorObject(result);
}
-
- edit_.allow();
- this.playbackInfo.repeatState = args.state;
- if (MediaControllerRepeatState.REPEAT_ONE !== args.state) {
- this.playbackInfo.repeatMode =
- args.state === MediaControllerRepeatState.REPEAT_ALL;
- }
- edit_.disallow();
};
MediaControllerServer.prototype.updateMetadata = function(metadata) {
+ utils_.printDeprecationWarningFor(
+ 'updateMetadata()',
+ 'MediaControllerMetadata.save()'
+ );
var args = validator_.validateArgs(arguments, [
{
name: 'metadata',
values: MediaControllerMetadata
}
]);
-
- var data = {
- metadata: args.metadata
- };
-
- var result = native_.callSync('MediaControllerServerUpdateMetadata', data);
-
- if (native_.isFailure(result)) {
- throw native_.getErrorObject(result);
+ for (var elem in args.metadata) {
+ this.playback.metadata[elem] = args.metadata[elem];
}
-
- edit_.allow();
- this.playbackInfo.metadata = args.metadata;
- edit_.disallow();
+ this.playback.metadata.save();
};
MediaControllerServer.prototype.addChangeRequestPlaybackInfoListener = function(
};
MediaControllerServer.prototype.updatePlaybackItem = function(playlistName, index) {
+ utils_.printDeprecationWarningFor(
+ 'MediaControllerServer.updatePlaybackItem()',
+ 'MediaControllerServerPlaybackInfo.updatePlaybackItem()'
+ );
+ updatePlaybackItem(playlistName, index);
+ edit_.allow();
+ this.playback.playlistName = playlistName;
+ this.playback.index = index;
+ edit_.disallow();
+};
+
+var updatePlaybackItem = function(playlistName, index) {
var args = validator_.validateArgs(arguments, [
{ name: 'playlistName', type: types_.STRING },
{ name: 'index', type: types_.STRING }
if (native_.isFailure(result)) {
throw native_.getErrorObject(result);
}
-
- edit_.allow();
- this.playbackInfo.index = args.index;
- this.playbackInfo.playlistName = args.playlistName;
- edit_.disallow();
};
MediaControllerServer.prototype.getAllPlaylists = function(
serverName: serverName,
displayRotationAbility: displayRotation
};
- var result = native_.callSync(
- 'MediaControllerClientGetDisplayRotationAbility',
- data
- );
+ var result = native_.callSync('MediaControllerClientGetDisplayRotationAbility', data);
if (native_.isFailure(result)) {
throw new native_.getErrorObject(result);
}
support: support
};
- var result = native_.callSync(
- 'MediaControllerServerSetDisplayRotationAbility',
- data
- );
+ var result = native_.callSync('MediaControllerServerSetDisplayRotationAbility', data);
if (native_.isFailure(result)) {
throw native_.getErrorObject(result);
ClientAbilityChangeListener.removeListener(args.callbackId);
if (type_.isEmptyObject(ClientAbilityChangeListener.listeners)) {
- var result = native_.callSync(
- 'MediaControllerClientRemoveAbilityChangeListener'
- );
+ var result = native_.callSync('MediaControllerClientRemoveAbilityChangeListener');
if (native_.isFailure(result)) {
throw native_.getErrorObject(result);
}
if (native_.isFailure(result)) {
throw new native_.getErrorObject(result);
}
+ var retData = native_.getResultObject(result);
edit_.allow();
- var data = native_.getResultObject(result);
- var playbackInfo = new MediaControllerPlaybackInfo(data);
+ var ret = new MediaControllerPlaybackInfo(retData);
edit_.disallow();
-
- return playbackInfo;
+ return ret;
+ }.bind(this),
+ set: function() {},
+ enumerable: true
+ },
+ playback: {
+ get: function() {
+ var result = native_.callSync('MediaControllerClientGetPlaybackInfo', {
+ name: this.name
+ });
+ if (native_.isFailure(result)) {
+ throw new native_.getErrorObject(result);
+ }
+ var playbackData = native_.getResultObject(result);
+ return new MediaControllerServerInfoPlaybackInfo(this.name, playbackData);
}.bind(this),
set: function() {},
enumerable: true
}
};
+function MediaControllerServerPlaybackInfo(data, oldPlaybackInfo) {
+ var _state = 'STOP';
+ var _position = 0;
+ var _shuffleMode = false;
+ var _contentType = MediaControllerContentType.UNDECIDED;
+ var _repeatState = MediaControllerRepeatState.REPEAT_ALL;
+ var _ageRating = MediaControllerContentAgeRating.ALL;
+ var _metadata = new MediaControllerMetadata();
+ var _index = null;
+ var _playlistName = null;
+ // it is needed to keep consistency in both old and new type of PlaybackInfo
+ var _oldPlaybackInfo = oldPlaybackInfo;
+
+ Object.defineProperties(this, {
+ state: {
+ get: function() {
+ return _state;
+ },
+ set: function(v) {
+ updatePlaybackState(v);
+ _state = v;
+ edit_.allow();
+ _oldPlaybackInfo.state = v;
+ edit_.disallow();
+ },
+ enumerable: true
+ },
+ position: {
+ get: function() {
+ return _position;
+ },
+ set: function(v) {
+ updatePlaybackPosition(v);
+ _position = v;
+ edit_.allow();
+ _oldPlaybackInfo.position = v;
+ edit_.disallow();
+ },
+ enumerable: true
+ },
+ ageRating: {
+ get: function() {
+ return _ageRating;
+ },
+ set: function(v) {
+ updatePlaybackAgeRating(v);
+ _ageRating = v;
+ edit_.allow();
+ _oldPlaybackInfo.ageRating = v;
+ edit_.disallow();
+ },
+ enumerable: true
+ },
+ shuffleMode: {
+ get: function() {
+ return _shuffleMode;
+ },
+ set: function(v) {
+ updateShuffleMode(v);
+ _shuffleMode = v;
+ edit_.allow();
+ _oldPlaybackInfo.shuffleMode = v;
+ edit_.disallow();
+ },
+ enumerable: true
+ },
+ repeatState: {
+ get: function() {
+ return _repeatState;
+ },
+ set: function(v) {
+ updateRepeatState(v);
+ _repeatState = v;
+ edit_.allow();
+ _oldPlaybackInfo.repeatState = v;
+ if (MediaControllerRepeatState.REPEAT_ONE !== v) {
+ _oldPlaybackInfo.repeatMode =
+ v === MediaControllerRepeatState.REPEAT_ALL;
+ }
+ edit_.disallow();
+ },
+ enumerable: true
+ },
+ contentType: {
+ get: function() {
+ return _contentType;
+ },
+ set: function(v) {
+ updatePlaybackContentType(v);
+ _contentType = v;
+ edit_.allow();
+ _oldPlaybackInfo.contentType = v;
+ edit_.disallow();
+ },
+ enumerable: true
+ },
+ metadata: {
+ get: function() {
+ return _metadata;
+ },
+ set: function() {},
+ enumerable: true
+ },
+ index: {
+ get: function() {
+ return _index;
+ },
+ set: function(v) {
+ if (edit_.isAllowed && v) {
+ _index = v;
+ _oldPlaybackInfo.index = v;
+ }
+ },
+ enumerable: true
+ },
+ playlistName: {
+ get: function() {
+ return _playlistName;
+ },
+ set: function(v) {
+ if (edit_.isAllowed && v) {
+ _playlistName = v;
+ _oldPlaybackInfo.playlistName = v;
+ }
+ },
+ enumerable: true
+ }
+ });
+
+ if (data instanceof _global.Object) {
+ for (var prop in data) {
+ if (data.hasOwnProperty(prop) && this.hasOwnProperty(prop)) {
+ this[prop] = data[prop];
+ }
+ }
+ }
+}
+
+MediaControllerServerPlaybackInfo.prototype.updatePlaybackItem = function(
+ playlistName,
+ index
+) {
+ updatePlaybackItem(playlistName, index);
+ edit_.allow();
+ this.playlistName = playlistName;
+ this.index = index;
+ edit_.disallow();
+};
+
+function MediaControllerServerInfoPlaybackInfo(serverName, data) {
+ var _serverName = serverName; // this variable will be used in the future
+
+ Object.defineProperties(this, {
+ state: {
+ value: data.state,
+ enumerable: true,
+ writable: false
+ },
+ position: {
+ value: data.position,
+ enumerable: true,
+ writable: false
+ },
+ ageRating: {
+ value: data.ageRating,
+ enumerable: true,
+ writable: false
+ },
+ shuffleMode: {
+ value: data.shuffleMode,
+ enumerable: true,
+ writable: false
+ },
+ repeatState: {
+ value: data.repeatState,
+ enumerable: true,
+ writable: false
+ },
+ contentType: {
+ value: data.contentType,
+ enumerable: true,
+ writable: false
+ },
+ metadata: {
+ value: new MediaControllerMetadata(data.metadata),
+ enumerable: true,
+ writable: false
+ },
+ index: {
+ value: data.index,
+ enumerable: true,
+ writable: false
+ },
+ playlistName: {
+ value: data.playlistName,
+ enumerable: true,
+ writable: false
+ }
+ });
+}
+
exports = new MediaControllerManager();
exports.SearchFilter = SearchFilter;
exports.RequestReply = RequestReply;