module resolution for serverNotifications

src/components/serverNotifications/gamepadtokey.js

@@ -0,0 +1,370 @@
+// #      The MIT License (MIT)
+// #
+// #      Copyright (c) 2016 Microsoft. All rights reserved.
+// #
+// #      Permission is hereby granted, free of charge, to any person obtaining a copy
+// #      of this software and associated documentation files (the "Software"), to deal
+// #      in the Software without restriction, including without limitation the rights
+// #      to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// #      copies of the Software, and to permit persons to whom the Software is
+// #      furnished to do so, subject to the following conditions:
+// #
+// #      The above copyright notice and this permission notice shall be included in
+// #      all copies or substantial portions of the Software.
+// #
+// #      THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// #      IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// #      FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// #      AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// #      LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// #      OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// #      THE SOFTWARE.
+require(['apphost'], function (appHost) {
+    "use strict";
+
+    var _GAMEPAD_A_BUTTON_INDEX = 0,
+    _GAMEPAD_B_BUTTON_INDEX = 1,
+    _GAMEPAD_DPAD_UP_BUTTON_INDEX = 12,
+    _GAMEPAD_DPAD_DOWN_BUTTON_INDEX = 13,
+    _GAMEPAD_DPAD_LEFT_BUTTON_INDEX = 14,
+    _GAMEPAD_DPAD_RIGHT_BUTTON_INDEX = 15,
+    _GAMEPAD_A_KEY = "GamepadA",
+    _GAMEPAD_B_KEY = "GamepadB",
+    _GAMEPAD_DPAD_UP_KEY = "GamepadDPadUp",
+    _GAMEPAD_DPAD_DOWN_KEY = "GamepadDPadDown",
+    _GAMEPAD_DPAD_LEFT_KEY = "GamepadDPadLeft",
+    _GAMEPAD_DPAD_RIGHT_KEY = "GamepadDPadRight",
+    _GAMEPAD_LEFT_THUMBSTICK_UP_KEY = "GamepadLeftThumbStickUp",
+    _GAMEPAD_LEFT_THUMBSTICK_DOWN_KEY = "GamepadLeftThumbStickDown",
+    _GAMEPAD_LEFT_THUMBSTICK_LEFT_KEY = "GamepadLeftThumbStickLeft",
+    _GAMEPAD_LEFT_THUMBSTICK_RIGHT_KEY = "GamepadLeftThumbStickRight",
+    _GAMEPAD_A_KEYCODE = 0,
+    _GAMEPAD_B_KEYCODE = 27,
+    _GAMEPAD_DPAD_UP_KEYCODE = 38,
+    _GAMEPAD_DPAD_DOWN_KEYCODE = 40,
+    _GAMEPAD_DPAD_LEFT_KEYCODE = 37,
+    _GAMEPAD_DPAD_RIGHT_KEYCODE = 39,
+    _GAMEPAD_LEFT_THUMBSTICK_UP_KEYCODE = 38,
+    _GAMEPAD_LEFT_THUMBSTICK_DOWN_KEYCODE = 40,
+    _GAMEPAD_LEFT_THUMBSTICK_LEFT_KEYCODE = 37,
+    _GAMEPAD_LEFT_THUMBSTICK_RIGHT_KEYCODE = 39,
+    _THUMB_STICK_THRESHOLD = 0.75;
+
+    var _leftThumbstickUpPressed = false,
+    _leftThumbstickDownPressed = false,
+    _leftThumbstickLeftPressed = false,
+    _leftThumbstickRightPressed = false,
+    _dPadUpPressed = false,
+    _dPadDownPressed = false,
+    _dPadLeftPressed = false,
+    _dPadRightPressed = false,
+    _gamepadAPressed = false,
+    _gamepadBPressed = false;
+
+    // The set of buttons on the gamepad we listen for.
+    var ProcessedButtons = [
+        _GAMEPAD_DPAD_UP_BUTTON_INDEX,
+        _GAMEPAD_DPAD_DOWN_BUTTON_INDEX,
+        _GAMEPAD_DPAD_LEFT_BUTTON_INDEX,
+        _GAMEPAD_DPAD_RIGHT_BUTTON_INDEX,
+        _GAMEPAD_A_BUTTON_INDEX,
+        _GAMEPAD_B_BUTTON_INDEX
+    ];
+
+    var _ButtonPressedState = {};
+    _ButtonPressedState.getgamepadA = function () {
+        return _gamepadAPressed;
+    };
+
+    _ButtonPressedState.setgamepadA = function (newPressedState) {
+        raiseKeyEvent(_gamepadAPressed, newPressedState, _GAMEPAD_A_KEY, _GAMEPAD_A_KEYCODE, false, true);
+        _gamepadAPressed = newPressedState;
+    };
+
+    _ButtonPressedState.getgamepadB = function () {
+        return _gamepadBPressed;
+    };
+
+    _ButtonPressedState.setgamepadB = function (newPressedState) {
+        raiseKeyEvent(_gamepadBPressed, newPressedState, _GAMEPAD_B_KEY, _GAMEPAD_B_KEYCODE);
+        _gamepadBPressed = newPressedState;
+    };
+
+    _ButtonPressedState.getleftThumbstickUp = function () {
+        return _leftThumbstickUpPressed;
+    };
+
+    _ButtonPressedState.setleftThumbstickUp = function (newPressedState) {
+        raiseKeyEvent(_leftThumbstickUpPressed, newPressedState, _GAMEPAD_LEFT_THUMBSTICK_UP_KEY, _GAMEPAD_LEFT_THUMBSTICK_UP_KEYCODE, true);
+        _leftThumbstickUpPressed = newPressedState;
+    };
+
+    _ButtonPressedState.getleftThumbstickDown = function () {
+        return _leftThumbstickDownPressed;
+    };
+
+    _ButtonPressedState.setleftThumbstickDown = function (newPressedState) {
+        raiseKeyEvent(_leftThumbstickDownPressed, newPressedState, _GAMEPAD_LEFT_THUMBSTICK_DOWN_KEY, _GAMEPAD_LEFT_THUMBSTICK_DOWN_KEYCODE, true);
+        _leftThumbstickDownPressed = newPressedState;
+    };
+
+    _ButtonPressedState.getleftThumbstickLeft = function () {
+        return _leftThumbstickLeftPressed;
+    };
+
+    _ButtonPressedState.setleftThumbstickLeft = function (newPressedState) {
+        raiseKeyEvent(_leftThumbstickLeftPressed, newPressedState, _GAMEPAD_LEFT_THUMBSTICK_LEFT_KEY, _GAMEPAD_LEFT_THUMBSTICK_LEFT_KEYCODE, true);
+        _leftThumbstickLeftPressed = newPressedState;
+    };
+
+    _ButtonPressedState.getleftThumbstickRight = function () {
+        return _leftThumbstickRightPressed;
+    };
+
+    _ButtonPressedState.setleftThumbstickRight = function (newPressedState) {
+        raiseKeyEvent(_leftThumbstickRightPressed, newPressedState, _GAMEPAD_LEFT_THUMBSTICK_RIGHT_KEY, _GAMEPAD_LEFT_THUMBSTICK_RIGHT_KEYCODE, true);
+        _leftThumbstickRightPressed = newPressedState;
+    };
+
+    _ButtonPressedState.getdPadUp = function () {
+        return _dPadUpPressed;
+    };
+
+    _ButtonPressedState.setdPadUp = function (newPressedState) {
+        raiseKeyEvent(_dPadUpPressed, newPressedState, _GAMEPAD_DPAD_UP_KEY, _GAMEPAD_DPAD_UP_KEYCODE, true);
+        _dPadUpPressed = newPressedState;
+    };
+
+    _ButtonPressedState.getdPadDown = function () {
+        return _dPadDownPressed;
+    };
+
+    _ButtonPressedState.setdPadDown = function (newPressedState) {
+        raiseKeyEvent(_dPadDownPressed, newPressedState, _GAMEPAD_DPAD_DOWN_KEY, _GAMEPAD_DPAD_DOWN_KEYCODE, true);
+        _dPadDownPressed = newPressedState;
+    };
+
+    _ButtonPressedState.getdPadLeft = function () {
+        return _dPadLeftPressed;
+    };
+
+    _ButtonPressedState.setdPadLeft = function (newPressedState) {
+        raiseKeyEvent(_dPadLeftPressed, newPressedState, _GAMEPAD_DPAD_LEFT_KEY, _GAMEPAD_DPAD_LEFT_KEYCODE, true);
+        _dPadLeftPressed = newPressedState;
+    };
+
+    _ButtonPressedState.getdPadRight = function () {
+        return _dPadRightPressed;
+    };
+
+    _ButtonPressedState.setdPadRight = function (newPressedState) {
+        raiseKeyEvent(_dPadRightPressed, newPressedState, _GAMEPAD_DPAD_RIGHT_KEY, _GAMEPAD_DPAD_RIGHT_KEYCODE, true);
+        _dPadRightPressed = newPressedState;
+    };
+
+    var times = {};
+
+    function throttle(key) {
+        var time = times[key] || 0;
+        var now = new Date().getTime();
+
+        if ((now - time) >= 200) {
+            //times[key] = now;
+            return true;
+        }
+
+        return false;
+    }
+
+    function resetThrottle(key) {
+        times[key] = new Date().getTime();
+    }
+
+    var isElectron = navigator.userAgent.toLowerCase().indexOf('electron') !== -1;
+    function allowInput() {
+
+        // This would be nice but always seems to return true with electron
+        if (!isElectron && document.hidden) {
+            return false;
+        }
+
+        if (appHost.getWindowState() === 'Minimized') {
+            return false;
+        }
+
+        return true;
+    }
+
+    function raiseEvent(name, key, keyCode) {
+
+        if (!allowInput()) {
+            return;
+        }
+
+        var event = document.createEvent('Event');
+        event.initEvent(name, true, true);
+        event.key = key;
+        event.keyCode = keyCode;
+        (document.activeElement || document.body).dispatchEvent(event);
+    }
+
+    function clickElement(elem) {
+
+        if (!allowInput()) {
+            return;
+        }
+
+        elem.click();
+    }
+
+    function raiseKeyEvent(oldPressedState, newPressedState, key, keyCode, enableRepeatKeyDown, clickonKeyUp) {
+
+        // No-op if oldPressedState === newPressedState
+        if (newPressedState === true) {
+
+            // button down
+            var fire = false;
+
+            // always fire if this is the initial down press
+            if (oldPressedState === false) {
+                fire = true;
+                resetThrottle(key);
+            } else if (enableRepeatKeyDown) {
+                fire = throttle(key);
+            }
+
+            if (fire && keyCode) {
+                raiseEvent("keydown", key, keyCode);
+            }
+
+        } else if (newPressedState === false && oldPressedState === true) {
+
+            resetThrottle(key);
+
+            // button up
+            if (keyCode) {
+                raiseEvent("keyup", key, keyCode);
+            }
+            if (clickonKeyUp) {
+                clickElement(document.activeElement || window);
+            }
+        }
+    }
+
+    function runInputLoop() {
+        // Get the latest gamepad state.
+        var gamepads;
+        if (navigator.getGamepads) {
+            gamepads = navigator.getGamepads();
+        } else if (navigator.webkitGetGamepads) {
+            gamepads = navigator.webkitGetGamepads();
+        }
+        gamepads = gamepads || [];
+        var i, j, len;
+        for (i = 0, len = gamepads.length; i < len; i++) {
+            var gamepad = gamepads[i];
+            if (gamepad) {
+                // Iterate through the axes
+                var axes = gamepad.axes;
+                var leftStickX = axes[0];
+                var leftStickY = axes[1];
+                if (leftStickX > _THUMB_STICK_THRESHOLD) { // Right
+                    _ButtonPressedState.setleftThumbstickRight(true);
+                } else if (leftStickX < -_THUMB_STICK_THRESHOLD) { // Left
+                    _ButtonPressedState.setleftThumbstickLeft(true);
+                } else if (leftStickY < -_THUMB_STICK_THRESHOLD) { // Up
+                    _ButtonPressedState.setleftThumbstickUp(true);
+                } else if (leftStickY > _THUMB_STICK_THRESHOLD) { // Down
+                    _ButtonPressedState.setleftThumbstickDown(true);
+                } else {
+                    _ButtonPressedState.setleftThumbstickLeft(false);
+                    _ButtonPressedState.setleftThumbstickRight(false);
+                    _ButtonPressedState.setleftThumbstickUp(false);
+                    _ButtonPressedState.setleftThumbstickDown(false);
+                }
+                // Iterate through the buttons to see if Left thumbstick, DPad, A and B are pressed.
+                var buttons = gamepad.buttons;
+                for (j = 0, len = buttons.length; j < len; j++) {
+                    if (ProcessedButtons.indexOf(j) !== -1) {
+
+                        if (buttons[j].pressed) {
+                            switch (j) {
+                                case _GAMEPAD_DPAD_UP_BUTTON_INDEX:
+                                    _ButtonPressedState.setdPadUp(true);
+                                    break;
+                                case _GAMEPAD_DPAD_DOWN_BUTTON_INDEX:
+                                    _ButtonPressedState.setdPadDown(true);
+                                    break;
+                                case _GAMEPAD_DPAD_LEFT_BUTTON_INDEX:
+                                    _ButtonPressedState.setdPadLeft(true);
+                                    break;
+                                case _GAMEPAD_DPAD_RIGHT_BUTTON_INDEX:
+                                    _ButtonPressedState.setdPadRight(true);
+                                    break;
+                                case _GAMEPAD_A_BUTTON_INDEX:
+                                    _ButtonPressedState.setgamepadA(true);
+                                    break;
+                                case _GAMEPAD_B_BUTTON_INDEX:
+                                    _ButtonPressedState.setgamepadB(true);
+                                    break;
+                                default:
+                                    // No-op
+                                    break;
+                            }
+                        } else {
+                            switch (j) {
+                                case _GAMEPAD_DPAD_UP_BUTTON_INDEX:
+                                    if (_ButtonPressedState.getdPadUp()) {
+                                        _ButtonPressedState.setdPadUp(false);
+                                    }
+                                    break;
+                                case _GAMEPAD_DPAD_DOWN_BUTTON_INDEX:
+                                    if (_ButtonPressedState.getdPadDown()) {
+                                        _ButtonPressedState.setdPadDown(false);
+                                    }
+                                    break;
+                                case _GAMEPAD_DPAD_LEFT_BUTTON_INDEX:
+                                    if (_ButtonPressedState.getdPadLeft()) {
+                                        _ButtonPressedState.setdPadLeft(false);
+                                    }
+                                    break;
+                                case _GAMEPAD_DPAD_RIGHT_BUTTON_INDEX:
+                                    if (_ButtonPressedState.getdPadRight()) {
+                                        _ButtonPressedState.setdPadRight(false);
+                                    }
+                                    break;
+                                case _GAMEPAD_A_BUTTON_INDEX:
+                                    if (_ButtonPressedState.getgamepadA()) {
+                                        _ButtonPressedState.setgamepadA(false);
+                                    }
+                                    break;
+                                case _GAMEPAD_B_BUTTON_INDEX:
+                                    if (_ButtonPressedState.getgamepadB()) {
+                                        _ButtonPressedState.setgamepadB(false);
+                                    }
+                                    break;
+                                default:
+                                    // No-op
+                                    break;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        // Schedule the next one
+        requestAnimationFrame(runInputLoop);
+    }
+
+    runInputLoop();
+
+    // The gamepadInputEmulation is a string property that exists in JavaScript UWAs and in WebViews in UWAs.
+    // It won't exist in Win8.1 style apps or browsers.
+    if (window.navigator && typeof window.navigator.gamepadInputEmulation === "string") {
+        // We want the gamepad to provide gamepad VK keyboard events rather than moving a
+        // mouse like cursor. Set to "keyboard", the gamepad will provide such keyboard events
+        // and provide input to the DOM navigator.getGamepads API.
+        window.navigator.gamepadInputEmulation = "gamepad";
+    }
+
+});

src/components/serverNotifications/mouseManager.js

@@ -0,0 +1,169 @@
+define(['inputManager', 'focusManager', 'browser', 'layoutManager', 'events', 'dom'], function (inputmanager, focusManager, browser, layoutManager, events, dom) {
+    'use strict';
+
+    var self = {};
+
+    var lastMouseInputTime = new Date().getTime();
+    var isMouseIdle;
+
+    function mouseIdleTime() {
+        return new Date().getTime() - lastMouseInputTime;
+    }
+
+    function notifyApp() {
+
+        inputmanager.notifyMouseMove();
+    }
+
+    function removeIdleClasses() {
+
+        var classList = document.body.classList;
+
+        classList.remove('mouseIdle');
+        classList.remove('mouseIdle-tv');
+    }
+
+    function addIdleClasses() {
+
+        var classList = document.body.classList;
+
+        classList.add('mouseIdle');
+
+        if (layoutManager.tv) {
+            classList.add('mouseIdle-tv');
+        }
+    }
+
+    var lastPointerMoveData;
+    function onPointerMove(e) {
+
+        var eventX = e.screenX;
+        var eventY = e.screenY;
+
+        // if coord don't exist how could it move
+        if (typeof eventX === "undefined" && typeof eventY === "undefined") {
+            return;
+        }
+
+        var obj = lastPointerMoveData;
+        if (!obj) {
+            lastPointerMoveData = {
+                x: eventX,
+                y: eventY
+            };
+            return;
+        }
+
+        // if coord are same, it didn't move
+        if (Math.abs(eventX - obj.x) < 10 && Math.abs(eventY - obj.y) < 10) {
+            return;
+        }
+
+        obj.x = eventX;
+        obj.y = eventY;
+
+        lastMouseInputTime = new Date().getTime();
+        notifyApp();
+
+        if (isMouseIdle) {
+            isMouseIdle = false;
+            removeIdleClasses();
+            events.trigger(self, 'mouseactive');
+        }
+    }
+
+    function onPointerEnter(e) {
+
+        var pointerType = e.pointerType || (layoutManager.mobile ? 'touch' : 'mouse');
+
+        if (pointerType === 'mouse') {
+            if (!isMouseIdle) {
+                var parent = focusManager.focusableParent(e.target);
+                if (parent) {
+                    focusManager.focus(parent);
+                }
+            }
+        }
+    }
+
+    function enableFocusWithMouse() {
+
+        if (!layoutManager.tv) {
+            return false;
+        }
+
+        if (browser.web0s) {
+            return false;
+        }
+
+        if (browser.tv) {
+            return true;
+        }
+
+        return false;
+    }
+
+    function onMouseInterval() {
+
+        if (!isMouseIdle && mouseIdleTime() >= 5000) {
+            isMouseIdle = true;
+            addIdleClasses();
+            events.trigger(self, 'mouseidle');
+        }
+    }
+
+    var mouseInterval;
+    function startMouseInterval() {
+
+        if (!mouseInterval) {
+            mouseInterval = setInterval(onMouseInterval, 5000);
+        }
+    }
+
+    function stopMouseInterval() {
+
+        var interval = mouseInterval;
+
+        if (interval) {
+            clearInterval(interval);
+            mouseInterval = null;
+        }
+
+        removeIdleClasses();
+    }
+
+    function initMouse() {
+
+        stopMouseInterval();
+
+        dom.removeEventListener(document, (window.PointerEvent ? 'pointermove' : 'mousemove'), onPointerMove, {
+            passive: true
+        });
+
+        if (!layoutManager.mobile) {
+            startMouseInterval();
+
+            dom.addEventListener(document, (window.PointerEvent ? 'pointermove' : 'mousemove'), onPointerMove, {
+                passive: true
+            });
+        }
+
+        dom.removeEventListener(document, (window.PointerEvent ? 'pointerenter' : 'mouseenter'), onPointerEnter, {
+            capture: true,
+            passive: true
+        });
+
+        if (enableFocusWithMouse()) {
+            dom.addEventListener(document, (window.PointerEvent ? 'pointerenter' : 'mouseenter'), onPointerEnter, {
+                capture: true,
+                passive: true
+            });
+        }
+    }
+
+    initMouse();
+
+    events.on(layoutManager, 'modechange', initMouse);
+
+    return self;
+});

src/components/serverNotifications/package.json

@@ -0,0 +1,3 @@
+{
+    "main": "serverNotifications.js"
+}

src/components/serverNotifications/serverNotifications.js

@@ -0,0 +1,257 @@
+define(['connectionManager', 'playbackManager', 'events', 'inputManager', 'focusManager', 'appRouter'], function (connectionManager, playbackManager, events, inputManager, focusManager, appRouter) {
+    'use strict';
+
+    var serverNotifications = {};
+
+    function notifyApp() {
+
+        inputManager.notify();
+    }
+
+    function displayMessage(cmd) {
+
+        var args = cmd.Arguments;
+
+        if (args.TimeoutMs) {
+
+            require(['toast'], function (toast) {
+                toast({ title: args.Header, text: args.Text });
+            });
+
+        }
+        else {
+            require(['alert'], function (alert) {
+                alert({ title: args.Header, text: args.Text });
+            });
+        }
+    }
+
+    function displayContent(cmd, apiClient) {
+        if (!playbackManager.isPlayingLocally(['Video', 'Book'])) {
+            appRouter.showItem(cmd.Arguments.ItemId, apiClient.serverId());
+        }
+    }
+
+    function playTrailers(apiClient, itemId) {
+        apiClient.getItem(apiClient.getCurrentUserId(), itemId).then(function (item) {
+            playbackManager.playTrailers(item);
+        });
+    }
+
+    function processGeneralCommand(cmd, apiClient) {
+        // https://github.com/jellyfin/jellyfin/blob/master/MediaBrowser.Model/Session/GeneralCommandType.cs
+        console.log('Received command: ' + cmd.Name);
+        switch (cmd.Name) {
+            case 'Select':
+                inputManager.trigger('select');
+                return;
+            case 'Back':
+                inputManager.trigger('back');
+                return;
+            case 'MoveUp':
+                inputManager.trigger('up');
+                return;
+            case 'MoveDown':
+                inputManager.trigger('down');
+                return;
+            case 'MoveLeft':
+                inputManager.trigger('left');
+                return;
+            case 'MoveRight':
+                inputManager.trigger('right');
+                return;
+            case 'PageUp':
+                inputManager.trigger('pageup');
+                return;
+            case 'PageDown':
+                inputManager.trigger('pagedown');
+                return;
+            case 'PlayTrailers':
+                playTrailers(apiClient, cmd.Arguments.ItemId);
+                break;
+            case 'SetRepeatMode':
+                playbackManager.setRepeatMode(cmd.Arguments.RepeatMode);
+                break;
+            case 'VolumeUp':
+                inputManager.trigger('volumeup');
+                return;
+            case 'VolumeDown':
+                inputManager.trigger('volumedown');
+                return;
+            case 'ChannelUp':
+                inputManager.trigger('channelup');
+                return;
+            case 'ChannelDown':
+                inputManager.trigger('channeldown');
+                return;
+            case 'Mute':
+                inputManager.trigger('mute');
+                return;
+            case 'Unmute':
+                inputManager.trigger('unmute');
+                return;
+            case 'ToggleMute':
+                inputManager.trigger('togglemute');
+                return;
+            case 'SetVolume':
+                notifyApp();
+                playbackManager.setVolume(cmd.Arguments.Volume);
+                break;
+            case 'SetAudioStreamIndex':
+                notifyApp();
+                playbackManager.setAudioStreamIndex(parseInt(cmd.Arguments.Index));
+                break;
+            case 'SetSubtitleStreamIndex':
+                notifyApp();
+                playbackManager.setSubtitleStreamIndex(parseInt(cmd.Arguments.Index));
+                break;
+            case 'ToggleFullscreen':
+                inputManager.trigger('togglefullscreen');
+                return;
+            case 'GoHome':
+                inputManager.trigger('home');
+                return;
+            case 'GoToSettings':
+                inputManager.trigger('settings');
+                return;
+            case 'DisplayContent':
+                displayContent(cmd, apiClient);
+                break;
+            case 'GoToSearch':
+                inputManager.trigger('search');
+                return;
+            case 'DisplayMessage':
+                displayMessage(cmd);
+                break;
+            case 'ToggleOsd':
+                // todo
+                break;
+            case 'ToggleContextMenu':
+                // todo
+                break;
+            case 'TakeScreenShot':
+                // todo
+                break;
+            case 'SendKey':
+                // todo
+                break;
+            case 'SendString':
+                // todo
+                focusManager.sendText(cmd.Arguments.String);
+                break;
+            default:
+                console.log('processGeneralCommand does not recognize: ' + cmd.Name);
+                break;
+        }
+
+        notifyApp();
+    }
+
+    function onMessageReceived(e, msg) {
+
+        var apiClient = this;
+
+        if (msg.MessageType === "Play") {
+
+            notifyApp();
+            var serverId = apiClient.serverInfo().Id;
+
+            if (msg.Data.PlayCommand === "PlayNext") {
+                playbackManager.queueNext({ ids: msg.Data.ItemIds, serverId: serverId });
+            }
+            else if (msg.Data.PlayCommand === "PlayLast") {
+                playbackManager.queue({ ids: msg.Data.ItemIds, serverId: serverId });
+            }
+            else {
+                playbackManager.play({
+                    ids: msg.Data.ItemIds,
+                    startPositionTicks: msg.Data.StartPositionTicks,
+                    mediaSourceId: msg.Data.MediaSourceId,
+                    audioStreamIndex: msg.Data.AudioStreamIndex,
+                    subtitleStreamIndex: msg.Data.SubtitleStreamIndex,
+                    startIndex: msg.Data.StartIndex,
+                    serverId: serverId
+                });
+            }
+
+        }
+        else if (msg.MessageType === "Playstate") {
+
+            if (msg.Data.Command === 'Stop') {
+                inputManager.trigger('stop');
+            }
+            else if (msg.Data.Command === 'Pause') {
+                inputManager.trigger('pause');
+            }
+            else if (msg.Data.Command === 'Unpause') {
+                inputManager.trigger('play');
+            }
+            else if (msg.Data.Command === 'PlayPause') {
+                inputManager.trigger('playpause');
+            }
+            else if (msg.Data.Command === 'Seek') {
+                playbackManager.seek(msg.Data.SeekPositionTicks);
+            }
+            else if (msg.Data.Command === 'NextTrack') {
+                inputManager.trigger('next');
+            }
+            else if (msg.Data.Command === 'PreviousTrack') {
+                inputManager.trigger('previous');
+            } else {
+                notifyApp();
+            }
+        }
+        else if (msg.MessageType === "GeneralCommand") {
+            var cmd = msg.Data;
+            processGeneralCommand(cmd, apiClient);
+        }
+        else if (msg.MessageType === "UserDataChanged") {
+
+            if (msg.Data.UserId === apiClient.getCurrentUserId()) {
+
+                for (var i = 0, length = msg.Data.UserDataList.length; i < length; i++) {
+                    events.trigger(serverNotifications, 'UserDataChanged', [apiClient, msg.Data.UserDataList[i]]);
+                }
+            }
+        }
+        else {
+
+            events.trigger(serverNotifications, msg.MessageType, [apiClient, msg.Data]);
+        }
+
+    }
+
+    function bindEvents(apiClient) {
+
+        events.off(apiClient, "message", onMessageReceived);
+        events.on(apiClient, "message", onMessageReceived);
+    }
+
+    function enableNativeGamepadKeyMapping() {
+        if (window.navigator && "string" == typeof window.navigator.gamepadInputEmulation) {
+            window.navigator.gamepadInputEmulation = "keyboard";
+            return true;
+        }
+
+        return false;
+    }
+
+    function isGamepadSupported() {
+        return "ongamepadconnected" in window || navigator.getGamepads || navigator.webkitGetGamepads;
+    }
+
+    connectionManager.getApiClients().forEach(bindEvents);
+
+    events.on(connectionManager, 'apiclientcreated', function (e, newApiClient) {
+
+        bindEvents(newApiClient);
+    });
+
+    if (!enableNativeGamepadKeyMapping() && isGamepadSupported()) {
+        require(["components/serverNotifications/gamepadtokey"]);
+    }
+
+    require(["components/serverNotifications/mouseManager"]);
+
+    return serverNotifications;
+});