mirror of
https://github.com/jellyfin/jellyfin-web
synced 2025-03-30 19:56:21 +00:00
410 lines
16 KiB
JavaScript
410 lines
16 KiB
JavaScript
// # 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;
|
|
var _GAMEPAD_B_BUTTON_INDEX = 1;
|
|
var _GAMEPAD_DPAD_UP_BUTTON_INDEX = 12;
|
|
var _GAMEPAD_DPAD_DOWN_BUTTON_INDEX = 13;
|
|
var _GAMEPAD_DPAD_LEFT_BUTTON_INDEX = 14;
|
|
var _GAMEPAD_DPAD_RIGHT_BUTTON_INDEX = 15;
|
|
var _GAMEPAD_A_KEY = "GamepadA";
|
|
var _GAMEPAD_B_KEY = "GamepadB";
|
|
var _GAMEPAD_DPAD_UP_KEY = "GamepadDPadUp";
|
|
var _GAMEPAD_DPAD_DOWN_KEY = "GamepadDPadDown";
|
|
var _GAMEPAD_DPAD_LEFT_KEY = "GamepadDPadLeft";
|
|
var _GAMEPAD_DPAD_RIGHT_KEY = "GamepadDPadRight";
|
|
var _GAMEPAD_LEFT_THUMBSTICK_UP_KEY = "GamepadLeftThumbStickUp";
|
|
var _GAMEPAD_LEFT_THUMBSTICK_DOWN_KEY = "GamepadLeftThumbStickDown";
|
|
var _GAMEPAD_LEFT_THUMBSTICK_LEFT_KEY = "GamepadLeftThumbStickLeft";
|
|
var _GAMEPAD_LEFT_THUMBSTICK_RIGHT_KEY = "GamepadLeftThumbStickRight";
|
|
var _GAMEPAD_A_KEYCODE = 0;
|
|
var _GAMEPAD_B_KEYCODE = 27;
|
|
var _GAMEPAD_DPAD_UP_KEYCODE = 38;
|
|
var _GAMEPAD_DPAD_DOWN_KEYCODE = 40;
|
|
var _GAMEPAD_DPAD_LEFT_KEYCODE = 37;
|
|
var _GAMEPAD_DPAD_RIGHT_KEYCODE = 39;
|
|
var _GAMEPAD_LEFT_THUMBSTICK_UP_KEYCODE = 38;
|
|
var _GAMEPAD_LEFT_THUMBSTICK_DOWN_KEYCODE = 40;
|
|
var _GAMEPAD_LEFT_THUMBSTICK_LEFT_KEYCODE = 37;
|
|
var _GAMEPAD_LEFT_THUMBSTICK_RIGHT_KEYCODE = 39;
|
|
var _THUMB_STICK_THRESHOLD = 0.75;
|
|
|
|
var _leftThumbstickUpPressed = false;
|
|
var _leftThumbstickDownPressed = false;
|
|
var _leftThumbstickLeftPressed = false;
|
|
var _leftThumbstickRightPressed = false;
|
|
var _dPadUpPressed = false;
|
|
var _dPadDownPressed = false;
|
|
var _dPadLeftPressed = false;
|
|
var _dPadRightPressed = false;
|
|
var _gamepadAPressed = false;
|
|
var _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) { /* eslint-disable-line compat/compat */
|
|
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);
|
|
}
|
|
}
|
|
}
|
|
|
|
var inputLoopTimer;
|
|
function runInputLoop() {
|
|
// Get the latest gamepad state.
|
|
var gamepads = navigator.getGamepads(); /* eslint-disable-line compat/compat */
|
|
for (var i = 0, len = gamepads.length; i < len; i++) {
|
|
var gamepad = gamepads[i];
|
|
if (!gamepad) {
|
|
continue;
|
|
}
|
|
// 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 (var 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
|
|
inputLoopTimer = requestAnimationFrame(runInputLoop);
|
|
}
|
|
|
|
function startInputLoop() {
|
|
if (!inputLoopTimer) {
|
|
runInputLoop();
|
|
}
|
|
}
|
|
|
|
function stopInputLoop() {
|
|
cancelAnimationFrame(inputLoopTimer);
|
|
inputLoopTimer = undefined;
|
|
}
|
|
|
|
function isGamepadConnected() {
|
|
var gamepads = navigator.getGamepads(); /* eslint-disable-line compat/compat */
|
|
for (var i = 0, len = gamepads.length; i < len; i++) {
|
|
var gamepad = gamepads[i];
|
|
if (gamepad && gamepad.connected) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
function onFocusOrGamepadAttach(e) {
|
|
/* eslint-disable-next-line compat/compat */
|
|
if (isGamepadConnected() && document.hasFocus()) {
|
|
console.log("Gamepad connected! Starting input loop");
|
|
startInputLoop();
|
|
}
|
|
}
|
|
|
|
function onFocusOrGamepadDetach(e) {
|
|
/* eslint-disable-next-line compat/compat */
|
|
if (!isGamepadConnected() || !document.hasFocus()) {
|
|
console.log("Gamepad disconnected! No other gamepads are connected, stopping input loop");
|
|
stopInputLoop();
|
|
} else {
|
|
console.log("Gamepad disconnected! There are gamepads still connected.");
|
|
}
|
|
}
|
|
|
|
// Event listeners for any change in gamepads' state.
|
|
window.addEventListener("gamepaddisconnected", onFocusOrGamepadDetach);
|
|
window.addEventListener("gamepadconnected", onFocusOrGamepadAttach);
|
|
window.addEventListener("blur", onFocusOrGamepadDetach);
|
|
window.addEventListener("focus", onFocusOrGamepadAttach);
|
|
|
|
onFocusOrGamepadAttach();
|
|
|
|
// 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";
|
|
}
|
|
|
|
});
|