Migration of sessionPlayer to ES6 module

package.json

@@ -157,6 +157,7 @@
           "src/components/scrollManager.js",
           "src/plugins/experimentalWarnings/plugin.js",
           "src/plugins/htmlVideoPlayer/plugin.js",
+          "src/plugins/sessionPlayer/plugin.js",
           "src/components/search/searchfields.js",
           "src/components/search/searchresults.js",
           "src/components/settingshelper.js",

src/plugins/sessionPlayer/plugin.js

@@ -1,21 +1,21 @@
-define(['playbackManager', 'events', 'serverNotifications', 'connectionManager'], function (playbackManager, events, serverNotifications, connectionManager) {
+import playbackManager from 'playbackManager';
-    'use strict';
+import events from 'events';
+import serverNotifications from 'serverNotifications';
+import connectionManager from 'connectionManager';
 
-    playbackManager = playbackManager.default || playbackManager;
+function getActivePlayerId() {
-
+    const info = playbackManager.getPlayerInfo();
-    function getActivePlayerId() {
-        var info = playbackManager.getPlayerInfo();
     return info ? info.id : null;
-    }
+}
 
-    function sendPlayCommand(apiClient, options, playType) {
+function sendPlayCommand(apiClient, options, playType) {
-        var sessionId = getActivePlayerId();
+    const sessionId = getActivePlayerId();
 
-        var ids = options.ids || options.items.map(function (i) {
+    const ids = options.ids || options.items.map(function (i) {
         return i.Id;
     });
 
-        var remoteOptions = {
+    const remoteOptions = {
         ItemIds: ids.join(','),
 
         PlayCommand: playType
@@ -42,26 +42,26 @@ define(['playbackManager', 'events', 'serverNotifications', 'connectionManager']
     }
 
     return apiClient.sendPlayCommand(sessionId, remoteOptions);
-    }
+}
 
-    function sendPlayStateCommand(apiClient, command, options) {
+function sendPlayStateCommand(apiClient, command, options) {
-        var sessionId = getActivePlayerId();
+    const sessionId = getActivePlayerId();
 
     apiClient.sendPlayStateCommand(sessionId, command, options);
-    }
+}
 
-    function getCurrentApiClient(instance) {
+function getCurrentApiClient(instance) {
-        var currentServerId = instance.currentServerId;
+    const currentServerId = instance.currentServerId;
 
     if (currentServerId) {
         return connectionManager.getApiClient(currentServerId);
     }
 
     return connectionManager.currentApiClient();
-    }
+}
 
-    function sendCommandByName(instance, name, options) {
+function sendCommandByName(instance, name, options) {
-        var command = {
+    const command = {
         Name: name
     };
 
@@ -70,21 +70,21 @@ define(['playbackManager', 'events', 'serverNotifications', 'connectionManager']
     }
 
     instance.sendCommand(command);
-    }
+}
 
-    function unsubscribeFromPlayerUpdates(instance) {
+function unsubscribeFromPlayerUpdates(instance) {
     instance.isUpdating = true;
 
-        var apiClient = getCurrentApiClient(instance);
+    const apiClient = getCurrentApiClient(instance);
     apiClient.sendMessage('SessionsStop');
     if (instance.pollInterval) {
         clearInterval(instance.pollInterval);
         instance.pollInterval = null;
     }
-    }
+}
 
-    function processUpdatedSessions(instance, sessions, apiClient) {
+function processUpdatedSessions(instance, sessions, apiClient) {
-        var serverId = apiClient.serverId();
+    const serverId = apiClient.serverId();
 
     sessions.map(function (s) {
         if (s.NowPlayingItem) {
@@ -92,19 +92,19 @@ define(['playbackManager', 'events', 'serverNotifications', 'connectionManager']
         }
     });
 
-        var currentTargetId = getActivePlayerId();
+    const currentTargetId = getActivePlayerId();
 
-        var session = sessions.filter(function (s) {
+    const session = sessions.filter(function (s) {
         return s.Id === currentTargetId;
     })[0];
 
     if (session) {
         normalizeImages(session, apiClient);
 
-            var eventNames = getChangedEvents(instance.lastPlayerData, session);
+        const eventNames = getChangedEvents(instance.lastPlayerData, session);
         instance.lastPlayerData = session;
 
-            for (var i = 0, length = eventNames.length; i < length; i++) {
+        for (let i = 0, length = eventNames.length; i < length; i++) {
             events.trigger(instance, eventNames[i], [session]);
         }
     } else {
@@ -112,10 +112,10 @@ define(['playbackManager', 'events', 'serverNotifications', 'connectionManager']
 
         playbackManager.setDefaultPlayerActive();
     }
-    }
+}
 
-    function getChangedEvents(state1, state2) {
+function getChangedEvents(state1, state2) {
-        var names = [];
+    const names = [];
 
     if (!state1) {
         names.push('statechange');
@@ -131,33 +131,33 @@ define(['playbackManager', 'events', 'serverNotifications', 'connectionManager']
     names.push('pause');
 
     return names;
-    }
+}
 
-    function onPollIntervalFired() {
+function onPollIntervalFired() {
-        var instance = this;
+    const instance = this;
-        var apiClient = getCurrentApiClient(instance);
+    const apiClient = getCurrentApiClient(instance);
     if (!apiClient.isMessageChannelOpen()) {
         apiClient.getSessions().then(function (sessions) {
             processUpdatedSessions(instance, sessions, apiClient);
         });
     }
-    }
+}
 
-    function subscribeToPlayerUpdates(instance) {
+function subscribeToPlayerUpdates(instance) {
     instance.isUpdating = true;
 
-        var apiClient = getCurrentApiClient(instance);
+    const apiClient = getCurrentApiClient(instance);
     apiClient.sendMessage('SessionsStart', '100,800');
     if (instance.pollInterval) {
         clearInterval(instance.pollInterval);
         instance.pollInterval = null;
     }
     instance.pollInterval = setInterval(onPollIntervalFired.bind(instance), 5000);
-    }
+}
 
-    function normalizeImages(state, apiClient) {
+function normalizeImages(state, apiClient) {
     if (state && state.NowPlayingItem) {
-            var item = state.NowPlayingItem;
+        const item = state.NowPlayingItem;
 
         if (!item.ImageTags || !item.ImageTags.Primary) {
             if (item.PrimaryImageTag) {
@@ -176,10 +176,11 @@ define(['playbackManager', 'events', 'serverNotifications', 'connectionManager']
             item.ServerId = apiClient.serverId();
         }
     }
-    }
+}
 
-    function SessionPlayer() {
+class SessionPlayer {
-        var self = this;
+    constructor() {
+        const self = this;
 
         this.name = 'Remote Control';
         this.type = 'mediaplayer';
@@ -191,7 +192,7 @@ define(['playbackManager', 'events', 'serverNotifications', 'connectionManager']
         });
     }
 
-    SessionPlayer.prototype.beginPlayerUpdates = function () {
+    beginPlayerUpdates() {
         this.playerListenerCount = this.playerListenerCount || 0;
 
         if (this.playerListenerCount <= 0) {
@@ -201,9 +202,9 @@ define(['playbackManager', 'events', 'serverNotifications', 'connectionManager']
         }
 
         this.playerListenerCount++;
-    };
+    }
 
-    SessionPlayer.prototype.endPlayerUpdates = function () {
+    endPlayerUpdates() {
         this.playerListenerCount = this.playerListenerCount || 0;
         this.playerListenerCount--;
 
@@ -211,21 +212,21 @@ define(['playbackManager', 'events', 'serverNotifications', 'connectionManager']
             unsubscribeFromPlayerUpdates(this);
             this.playerListenerCount = 0;
         }
-    };
+    }
 
-    SessionPlayer.prototype.getPlayerState = function () {
+    getPlayerState() {
         return this.lastPlayerData || {};
-    };
+    }
 
-    SessionPlayer.prototype.getTargets = function () {
+    getTargets() {
-        var apiClient = getCurrentApiClient(this);
+        const apiClient = getCurrentApiClient(this);
 
-        var sessionQuery = {
+        const sessionQuery = {
             ControllableByUserId: apiClient.getCurrentUserId()
         };
 
         if (apiClient) {
-            var name = this.name;
+            const name = this.name;
 
             return apiClient.getSessions(sessionQuery).then(function (sessions) {
                 return sessions.filter(function (s) {
@@ -242,11 +243,9 @@ define(['playbackManager', 'events', 'serverNotifications', 'connectionManager']
                         isLocalPlayer: false,
                         supportedCommands: s.Capabilities.SupportedCommands,
                         user: s.UserId ? {
-
                             Id: s.UserId,
                             Name: s.UserName,
                             PrimaryImageTag: s.UserPrimaryImageTag
-
                         } : null
                     };
                 });
@@ -254,16 +253,16 @@ define(['playbackManager', 'events', 'serverNotifications', 'connectionManager']
         } else {
             return Promise.resolve([]);
         }
-    };
+    }
 
-    SessionPlayer.prototype.sendCommand = function (command) {
+    sendCommand(command) {
-        var sessionId = getActivePlayerId();
+        const sessionId = getActivePlayerId();
 
-        var apiClient = getCurrentApiClient(this);
+        const apiClient = getCurrentApiClient(this);
         apiClient.sendCommand(sessionId, command);
-    };
+    }
 
-    SessionPlayer.prototype.play = function (options) {
+    play(options) {
         options = Object.assign({}, options);
 
         if (options.items) {
@@ -275,251 +274,230 @@ define(['playbackManager', 'events', 'serverNotifications', 'connectionManager']
         }
 
         return sendPlayCommand(getCurrentApiClient(this), options, 'PlayNow');
-    };
+    }
 
-    SessionPlayer.prototype.shuffle = function (item) {
+    shuffle(item) {
         sendPlayCommand(getCurrentApiClient(this), { ids: [item.Id] }, 'PlayShuffle');
-    };
+    }
 
-    SessionPlayer.prototype.instantMix = function (item) {
+    instantMix(item) {
         sendPlayCommand(getCurrentApiClient(this), { ids: [item.Id] }, 'PlayInstantMix');
-    };
+    }
 
-    SessionPlayer.prototype.queue = function (options) {
+    queue(options) {
         sendPlayCommand(getCurrentApiClient(this), options, 'PlayNext');
-    };
+    }
 
-    SessionPlayer.prototype.queueNext = function (options) {
+    queueNext(options) {
         sendPlayCommand(getCurrentApiClient(this), options, 'PlayLast');
-    };
+    }
 
-    SessionPlayer.prototype.canPlayMediaType = function (mediaType) {
+    canPlayMediaType(mediaType) {
         mediaType = (mediaType || '').toLowerCase();
         return mediaType === 'audio' || mediaType === 'video';
-    };
+    }
 
-    SessionPlayer.prototype.canQueueMediaType = function (mediaType) {
+    canQueueMediaType(mediaType) {
         return this.canPlayMediaType(mediaType);
-    };
+    }
 
-    SessionPlayer.prototype.stop = function () {
+    stop() {
         sendPlayStateCommand(getCurrentApiClient(this), 'stop');
-    };
+    }
 
-    SessionPlayer.prototype.nextTrack = function () {
+    nextTrack() {
         sendPlayStateCommand(getCurrentApiClient(this), 'nextTrack');
-    };
+    }
 
-    SessionPlayer.prototype.previousTrack = function () {
+    previousTrack() {
         sendPlayStateCommand(getCurrentApiClient(this), 'previousTrack');
-    };
+    }
 
-    SessionPlayer.prototype.seek = function (positionTicks) {
+    seek(positionTicks) {
         sendPlayStateCommand(getCurrentApiClient(this), 'seek',
             {
                 SeekPositionTicks: positionTicks
             });
-    };
+    }
 
-    SessionPlayer.prototype.currentTime = function (val) {
+    currentTime(val) {
         if (val != null) {
             return this.seek(val);
         }
 
-        var state = this.lastPlayerData || {};
+        let state = this.lastPlayerData || {};
         state = state.PlayState || {};
         return state.PositionTicks;
-    };
+    }
 
-    SessionPlayer.prototype.duration = function () {
+    duration() {
-        var state = this.lastPlayerData || {};
+        let state = this.lastPlayerData || {};
         state = state.NowPlayingItem || {};
         return state.RunTimeTicks;
-    };
+    }
 
-    SessionPlayer.prototype.paused = function () {
+    paused() {
-        var state = this.lastPlayerData || {};
+        let state = this.lastPlayerData || {};
         state = state.PlayState || {};
         return state.IsPaused;
-    };
+    }
 
-    SessionPlayer.prototype.getVolume = function () {
+    getVolume() {
-        var state = this.lastPlayerData || {};
+        let state = this.lastPlayerData || {};
         state = state.PlayState || {};
         return state.VolumeLevel;
-    };
+    }
 
-    SessionPlayer.prototype.isMuted = function () {
+    isMuted() {
-        var state = this.lastPlayerData || {};
+        let state = this.lastPlayerData || {};
         state = state.PlayState || {};
         return state.IsMuted;
-    };
+    }
 
-    SessionPlayer.prototype.pause = function () {
+    pause() {
         sendPlayStateCommand(getCurrentApiClient(this), 'Pause');
-    };
+    }
 
-    SessionPlayer.prototype.unpause = function () {
+    unpause() {
         sendPlayStateCommand(getCurrentApiClient(this), 'Unpause');
-    };
+    }
 
-    SessionPlayer.prototype.playPause = function () {
+    playPause() {
         sendPlayStateCommand(getCurrentApiClient(this), 'PlayPause');
-    };
+    }
 
-    SessionPlayer.prototype.setMute = function (isMuted) {
+    setMute(isMuted) {
         if (isMuted) {
             sendCommandByName(this, 'Mute');
         } else {
             sendCommandByName(this, 'Unmute');
         }
-    };
+    }
 
-    SessionPlayer.prototype.toggleMute = function () {
+    toggleMute() {
         sendCommandByName(this, 'ToggleMute');
-    };
+    }
 
-    SessionPlayer.prototype.setVolume = function (vol) {
+    setVolume(vol) {
         sendCommandByName(this, 'SetVolume', {
             Volume: vol
         });
-    };
+    }
 
-    SessionPlayer.prototype.volumeUp = function () {
+    volumeUp() {
         sendCommandByName(this, 'VolumeUp');
-    };
+    }
 
-    SessionPlayer.prototype.volumeDown = function () {
+    volumeDown() {
         sendCommandByName(this, 'VolumeDown');
-    };
+    }
 
-    SessionPlayer.prototype.toggleFullscreen = function () {
+    toggleFullscreen() {
         sendCommandByName(this, 'ToggleFullscreen');
-    };
+    }
 
-    SessionPlayer.prototype.audioTracks = function () {
+    audioTracks() {
-        var state = this.lastPlayerData || {};
+        let state = this.lastPlayerData || {};
         state = state.NowPlayingItem || {};
-        var streams = state.MediaStreams || [];
+        const streams = state.MediaStreams || [];
         return streams.filter(function (s) {
             return s.Type === 'Audio';
         });
-    };
+    }
 
-    SessionPlayer.prototype.getAudioStreamIndex = function () {
+    getAudioStreamIndex() {
-        var state = this.lastPlayerData || {};
+        let state = this.lastPlayerData || {};
         state = state.PlayState || {};
         return state.AudioStreamIndex;
-    };
+    }
 
-    SessionPlayer.prototype.playTrailers = function (item) {
+    playTrailers(item) {
         sendCommandByName(this, 'PlayTrailers', {
             ItemId: item.Id
         });
-    };
+    }
 
-    SessionPlayer.prototype.setAudioStreamIndex = function (index) {
+    setAudioStreamIndex(index) {
         sendCommandByName(this, 'SetAudioStreamIndex', {
             Index: index
         });
-    };
+    }
 
-    SessionPlayer.prototype.subtitleTracks = function () {
+    subtitleTracks() {
-        var state = this.lastPlayerData || {};
+        let state = this.lastPlayerData || {};
         state = state.NowPlayingItem || {};
-        var streams = state.MediaStreams || [];
+        const streams = state.MediaStreams || [];
         return streams.filter(function (s) {
             return s.Type === 'Subtitle';
         });
-    };
+    }
 
-    SessionPlayer.prototype.getSubtitleStreamIndex = function () {
+    getSubtitleStreamIndex() {
-        var state = this.lastPlayerData || {};
+        let state = this.lastPlayerData || {};
         state = state.PlayState || {};
         return state.SubtitleStreamIndex;
-    };
+    }
 
-    SessionPlayer.prototype.setSubtitleStreamIndex = function (index) {
+    setSubtitleStreamIndex(index) {
         sendCommandByName(this, 'SetSubtitleStreamIndex', {
             Index: index
         });
-    };
+    }
 
-    SessionPlayer.prototype.getMaxStreamingBitrate = function () {
+    setMaxStreamingBitrate(options) {
+    }
 
-    };
+    setRepeatMode(mode) {
-
-    SessionPlayer.prototype.setMaxStreamingBitrate = function (options) {
-
-    };
-
-    SessionPlayer.prototype.isFullscreen = function () {
-
-    };
-
-    SessionPlayer.prototype.toggleFullscreen = function () {
-
-    };
-
-    SessionPlayer.prototype.getRepeatMode = function () {
-
-    };
-
-    SessionPlayer.prototype.setRepeatMode = function (mode) {
         sendCommandByName(this, 'SetRepeatMode', {
             RepeatMode: mode
         });
-    };
+    }
 
-    SessionPlayer.prototype.setQueueShuffleMode = function (mode) {
+    setQueueShuffleMode(mode) {
         sendCommandByName(this, 'SetShuffleQueue', {
             ShuffleMode: mode
         });
-    };
+    }
 
-    SessionPlayer.prototype.getQueueShuffleMode = function () {
+    getQueueShuffleMode() {
+    }
 
-    };
+    displayContent(options) {
-
-    SessionPlayer.prototype.displayContent = function (options) {
         sendCommandByName(this, 'DisplayContent', options);
-    };
+    }
 
-    SessionPlayer.prototype.isPlaying = function () {
+    isPlaying() {
-        var state = this.lastPlayerData || {};
+        const state = this.lastPlayerData || {};
         return state.NowPlayingItem != null;
-    };
+    }
 
-    SessionPlayer.prototype.isPlayingVideo = function () {
+    isPlayingVideo() {
-        var state = this.lastPlayerData || {};
+        let state = this.lastPlayerData || {};
         state = state.NowPlayingItem || {};
         return state.MediaType === 'Video';
-    };
+    }
 
-    SessionPlayer.prototype.isPlayingAudio = function () {
+    isPlayingAudio() {
-        var state = this.lastPlayerData || {};
+        let state = this.lastPlayerData || {};
         state = state.NowPlayingItem || {};
         return state.MediaType === 'Audio';
-    };
+    }
 
-    SessionPlayer.prototype.getPlaylist = function () {
+    getPlaylist() {
         return Promise.resolve([]);
-    };
+    }
 
-    SessionPlayer.prototype.getCurrentPlaylistItemId = function () {
+    setCurrentPlaylistItem(playlistItemId) {
-    };
-
-    SessionPlayer.prototype.setCurrentPlaylistItem = function (playlistItemId) {
         return Promise.resolve();
-    };
+    }
 
-    SessionPlayer.prototype.removeFromPlaylist = function (playlistItemIds) {
+    removeFromPlaylist(playlistItemIds) {
         return Promise.resolve();
-    };
+    }
 
-    SessionPlayer.prototype.tryPair = function (target) {
+    tryPair(target) {
         return Promise.resolve();
-    };
+    }
+}
 
-    return SessionPlayer;
+export default SessionPlayer;
-});