Bump version to 5.4.0

This reverts commit 91ab57fa29.

build.ts

@@ -4,6 +4,7 @@ import { parseArgs } from "node:util";
 import { sys } from "typescript";
 import txtScriptHeader from "./src/assets/header_script.txt" with { type: "text" };
 import txtMetaHeader from "./src/assets/header_meta.txt" with { type: "text" };
+import { assert } from "node:console";
 
 enum BuildTarget {
     ALL = 'all',
@@ -24,6 +25,8 @@ const postProcess = (str: string): string => {
     // Add ADDITIONAL CODE block
     str = str.replace('var DEFAULT_FLAGS', '\n/* ADDITIONAL CODE */\n\nvar DEFAULT_FLAGS');
 
+    assert(str.includes('/* ADDITIONAL CODE */'));
+
     return str;
 }
 

dist/better-xcloud.meta.js

@@ -1,5 +1,5 @@
 // ==UserScript==
 // @name         Better xCloud
 // @namespace    https://github.com/redphx
-// @version      5.1.2
+// @version      5.4.0
 // ==/UserScript==

package.json

@@ -6,8 +6,8 @@
     "build": "build.ts"
   },
   "devDependencies": {
-    "@types/bun": "^1.1.5",
-    "@types/node": "^20.14.9",
+    "@types/bun": "^1.1.6",
+    "@types/node": "^20.14.10",
     "@types/stylus": "^0.48.42",
     "stylus": "^0.63.0"
   },

src/assets/css/button.styl

@@ -83,24 +83,24 @@
         overflow: hidden;
         white-space: nowrap;
     }
+}
 
-    &.bx-focusable {
-        position: relative;
+.bx-focusable {
+    position: relative;
 
-        &::after {
-            border: 2px solid transparent;
-            border-radius: 4px;
-        }
+    &::after {
+        border: 2px solid transparent;
+        border-radius: 4px;
+    }
 
-        &:focus::after {
-            content: '';
-            border-color: white;
-            position: absolute;
-            top: 0;
-            left: 0;
-            right: 0;
-            bottom: 0;
-        }
+    &:focus::after {
+        content: '';
+        border-color: white;
+        position: absolute;
+        top: 0;
+        left: 0;
+        right: 0;
+        bottom: 0;
     }
 }
 
@@ -111,3 +111,9 @@ a.bx-button {
         text-align: center;
     }
 }
+
+button.bx-inactive {
+    pointer-events: none;
+    opacity: 0.2;
+    background: transparent !important;
+}

src/assets/css/global-settings.styl

@@ -17,11 +17,13 @@
 }
 
 .bx-settings-wrapper {
-    width: 450px;
+    min-width: 450px;
+    max-width: 600px;
     margin: auto;
     padding: 12px 6px;
 
     @media screen and (max-width: 450px) {
+        min-width: unset;
         width: 100%;
     }
 
@@ -48,11 +50,18 @@
         text-decoration: none;
         font-weight: bold;
         display: block;
-        color: #5dc21e;
         flex: 1;
+        text-transform: none;
+        margin-right: 10px;
+
+        span {
+            color: #5dc21e !important;
+        }
 
         &:focus {
-            color: #83f73a;
+            span {
+                color: #83f73a !important;
+            }
         }
     }
 
@@ -93,9 +102,14 @@
     position: relative;
 
     label {
-        flex: 1;
         align-self: center;
-        margin-bottom: 0;
+        margin: 0 4px 0;
+    }
+
+    .bx-setting-control {
+        flex: 1;
+        display: flex;
+        justify-content: right;
     }
 
 
@@ -122,14 +136,19 @@
         }
     }
 
-    input[type=checkbox], select {
+    input[type=checkbox] {
+        cursor: pointer;
+    }
+
+    input[type=checkbox],
+    select {
         &:focus {
             filter: drop-shadow(1px 0 0 #fff) drop-shadow(-1px 0 0 #fff) drop-shadow(0 1px 0 #fff) drop-shadow(0 -1px 0 #fff);
         }
     }
 
 
-    &:has(input:focus), &:has(select:focus) {
+    &:has(input:focus), &:has(select:focus), &:has(button:focus) {
         &::before {
             content: ' ';
             border-radius: 4px;

src/assets/css/number-stepper.styl

@@ -5,14 +5,15 @@
         display: inline-block;
         min-width: 40px;
         font-family: var(--bx-monospaced-font);
-        font-size: 14px;
+        font-size: 12px;
+        margin: 0 4px;
     }
 
     button {
         border: none;
         width: 24px;
         height: 24px;
-        margin: 0 4px;
+        margin: 0;
         line-height: 24px;
         background-color: var(--bx-default-button-color);
         color: #fff;

src/assets/css/root.styl

@@ -105,6 +105,10 @@ div[class^=HUDButton-module__hiddenContainer] ~ div:not([class^=HUDButton-module
     font-family: var(--bx-promptfont-font);
 }
 
+.bx-line-through {
+    text-decoration: line-through
+}
+
 select[multiple] {
     overflow: auto;
 }
@@ -132,3 +136,35 @@ div[class*=SupportedInputsBadge] {
         display: none;
     }
 }
+
+
+.bx-game-tile-wait-time {
+    position: absolute;
+    top: 0;
+    left: 0;
+    z-index: 1;
+    background: #0000008c;
+    display: none;
+    border-radius: 0 0 4px 0;
+    align-items: center;
+    padding: 4px 8px;
+
+    a[class^=BaseItem-module__container]:focus &,
+    button[class^=BaseItem-module__container]:focus & {
+        display: flex;
+    }
+
+    svg {
+        width: 14px;
+        height: 16px;
+        margin-right: 2px;
+    }
+
+    span {
+        display: inline-block;
+        height: 16px;
+        line-height: 16px;
+        font-size: 12px;
+        font-weight: bold;
+    }
+}

src/assets/css/stream-settings.styl

@@ -49,6 +49,11 @@
             background: #2f2f2f;
             border-color: #484848;
         }
+
+        &:focus {
+            border-color: #fff;
+            outline: none;
+        }
     }
 }
 
@@ -70,13 +75,14 @@
     box-shadow: 0px 0px 6px #000;
     overflow: overlay;
 
-    > div[data-group=mkb] {
+    > div[data-tab-group=mkb] {
         display: flex;
         flex-direction: column;
         height: 100%;
         overflow: hidden;
     }
 
+    &:focus,
     *:focus {
         outline: none !important;
     }
@@ -106,8 +112,23 @@
 .bx-stream-settings-row {
     display: flex;
     border-bottom: 1px solid #40404080;
-    margin-bottom: 16px;
-    padding-bottom: 16px;
+    padding: 16px 8px;
+    border-left: 2px solid transparent;
+
+    &:hover, &:focus-within {
+        background-color: #242424;
+    }
+
+    input[type=checkbox],
+    select {
+        &:focus {
+            filter: drop-shadow(1px 0 0 #fff) drop-shadow(-1px 0 0 #fff) drop-shadow(0 1px 0 #fff) drop-shadow(0 -1px 0 #fff);
+        }
+    }
+
+    &:has(input:focus), &:has(select:focus), &:has(button:focus) {
+        border-left-color: white;
+    }
 
     > label {
         font-size: 16px;
@@ -120,6 +141,10 @@
 
     input {
         accent-color: var(--bx-primary-button-color);
+
+        &:focus {
+            accent-color: var(--bx-danger-button-color);
+        }
     }
 
     select:disabled {
@@ -143,7 +168,7 @@
 }
 
 .bx-stream-settings-tab-contents {
-    div[data-group="shortcuts"] {
+    div[data-tab-group="shortcuts"] {
         > div {
             &[data-has-gamepad=true] {
                 > div:first-of-type {
@@ -170,10 +195,10 @@
             width: 100%;
             height: 36px;
             display: block;
-            margin-bottom: 10px;
         }
 
         .bx-shortcut-note {
+            margin-top: 10px;
             font-size: 14px;
         }
 

src/assets/css/web-components.styl

@@ -1,19 +1,27 @@
 .bx-select {
+    display: flex;
+    align-items: center;
+    flex: 0 1 auto;
+
     select {
-        display: none;
+        display: none !important;
     }
 
-    > div {
-        display: inline-block;
+    > div, button.bx-select-value {
         min-width: 110px;
         text-align: center;
-        margin: 0 10px;
+        margin: 0 8px;
         line-height: 24px;
         vertical-align: middle;
         background: #fff;
         color: #000;
         border-radius: 4px;
-        padding: 2px 4px;
+        padding: 2px 8px;
+        flex: 1;
+    }
+
+    > div {
+        display: inline-block;
 
         input {
             display: inline-block;
@@ -22,25 +30,62 @@
 
         label {
             margin-bottom: 0;
+            font-size: 14px;
+            width: 100%;
+
+            span {
+                display: block;
+                font-size: 10px;
+                font-weight: bold;
+                text-align: left;
+                line-height: initial;
+            }
         }
     }
 
-    button {
+    button.bx-select-value {
+        border: none;
+        display: inline-flex;
+        cursor: pointer;
+        min-height: 30px;
+        font-size: 0.9rem;
+        align-items: center;
+
+        span {
+            flex: 1;
+            text-align: center;
+            display: inline-block;
+        }
+
+        input {
+            margin: 0 4px;
+            accent-color: var(--bx-primary-button-color);
+        }
+
+        &:hover,
+        &:focus {
+            input {
+                accent-color: var(--bx-danger-button-color);
+            }
+
+            &::after {
+                border-color: #4d4d4d !important;
+            }
+        }
+    }
+
+    button.bx-button {
         border: none;
-        width: 24px;
         height: 24px;
+        width: 24px;
+        padding: 0;
         line-height: 24px;
         color: #fff;
         border-radius: 4px;
         font-weight: bold;
-        font-size: 14px;
+        font-size: 12px;
         font-family: var(--bx-monospaced-font);
 
-        &.bx-inactive {
-            pointer-events: none;
-            opacity: 0.2;
-        }
-
         span {
             line-height: unset;
         }

src/enums/bypass-servers.ts

@@ -0,0 +1,13 @@
+export const BypassServers = {
+    'br': 'Brazil',
+    'jp': 'Japan',
+    'pl': 'Poland',
+    'us': 'United States',
+}
+
+export const BypassServerIps = {
+    'br': '169.150.198.66',
+    'jp': '138.199.21.239',
+    'pl': '45.134.212.66',
+    'us': '143.244.47.65',
+}

src/enums/user-agent.ts

@@ -1,8 +1,8 @@
 export enum UserAgentProfile {
     WINDOWS_EDGE = 'windows-edge',
     MACOS_SAFARI = 'macos-safari',
-    SMARTTV_GENERIC = 'smarttv-generic',
-    SMARTTV_TIZEN = 'smarttv-tizen',
+    SMART_TV_GENERIC = 'smarttv-generic',
+    SMART_TV_TIZEN = 'smarttv-tizen',
     VR_OCULUS = 'vr-oculus',
     DEFAULT = 'default',
     CUSTOM = 'custom',

src/index.ts

@@ -16,7 +16,6 @@ import { PrefKey, getPref } from "@utils/preferences";
 import { LoadingScreen } from "@modules/loading-screen";
 import { MouseCursorHider } from "@modules/mkb/mouse-cursor-hider";
 import { TouchController } from "@modules/touch-controller";
-import { watchHeader } from "@modules/ui/header";
 import { checkForUpdate, disablePwa } from "@utils/utils";
 import { Patcher } from "@modules/patcher";
 import { RemotePlay } from "@modules/remote-play";
@@ -34,6 +33,8 @@ import { GuideMenu, GuideMenuTab } from "./modules/ui/guide-menu";
 import { StreamSettings } from "./modules/stream/stream-settings";
 import { updateVideoPlayer } from "./modules/stream/stream-settings-utils";
 import { UiSection } from "./enums/ui-sections";
+import { HeaderSection } from "./modules/ui/header";
+import { GameTile } from "./modules/ui/game-tile";
 
 
 // Handle login page
@@ -91,8 +92,8 @@ if (BX_FLAGS.SafariWorkaround && document.readyState !== 'loading') {
     throw new Error('[Better xCloud] Executing workaround for Safari');
 }
 
-// Automatically reload the page when running into the "We are sorry..." error message
 window.addEventListener('load', e => {
+    // Automatically reload the page when running into the "We are sorry..." error message
     window.setTimeout(() => {
         if (document.body.classList.contains('legacyBackground')) {
             // Has error message -> reload page
@@ -101,18 +102,29 @@ window.addEventListener('load', e => {
             window.location.reload(true);
         }
     }, 3000);
-
 });
 
-// Hide "Play with Friends" skeleton section
-if (getPref(PrefKey.UI_HIDE_SECTIONS).includes(UiSection.FRIENDS)) {
-    document.addEventListener('readystatechange', e => {
-        if (document.readyState === 'interactive') {
-            const $parent = document.querySelector('div[class*=PlayWithFriendsSkeleton]')?.closest('div[class*=HomePage-module]') as HTMLElement;
-            $parent && ($parent.style.display = 'none');
-        }
-    })
-}
+document.addEventListener('readystatechange', e => {
+    if (document.readyState !== 'interactive') {
+        return;
+    }
+
+    STATES.isSignedIn = (window as any).xbcUser.isSignedIn;
+
+    if (STATES.isSignedIn) {
+        // Preload Remote Play
+        getPref(PrefKey.REMOTE_PLAY_ENABLED) && BX_FLAGS.PreloadRemotePlay && RemotePlay.preload();
+    } else {
+        // Show Settings button in the header when not signed
+        HeaderSection.watchHeader();
+    }
+
+    // Hide "Play with Friends" skeleton section
+    if (getPref(PrefKey.UI_HIDE_SECTIONS).includes(UiSection.FRIENDS)) {
+        const $parent = document.querySelector('div[class*=PlayWithFriendsSkeleton]')?.closest('div[class*=HomePage-module]') as HTMLElement;
+        $parent && ($parent.style.display = 'none');
+    }
+})
 
 window.BX_EXPOSED = BxExposed;
 
@@ -125,13 +137,13 @@ window.addEventListener('popstate', onHistoryChanged);
 window.history.pushState = patchHistoryMethod('pushState');
 window.history.replaceState = patchHistoryMethod('replaceState');
 
+window.addEventListener(BxEvent.XCLOUD_SERVERS_UNAVAILABLE, e => {
+    STATES.supportedRegion = false;
+    window.setTimeout(HeaderSection.watchHeader, 2000);
+});
+
 window.addEventListener(BxEvent.XCLOUD_SERVERS_READY, e => {
-    // Start rendering UI
-    if (document.querySelector('div[class^=UnsupportedMarketPage]')) {
-        window.setTimeout(watchHeader, 2000);
-    } else {
-        watchHeader();
-    }
+    HeaderSection.watchHeader();
 });
 
 window.addEventListener(BxEvent.STREAM_LOADING, e => {
@@ -340,6 +352,9 @@ function main() {
         STATES.pointerServerPort = AppInterface.startPointerServer() || 9269;
         BxLogger.info('startPointerServer', 'Port', STATES.pointerServerPort.toString());
     }
+
+    // Show wait time in game card
+    getPref(PrefKey.UI_GAME_CARD_SHOW_WAIT_TIME) && GameTile.setup();
 }
 
 main();

src/modules/controller-shortcut.ts

@@ -11,6 +11,7 @@ import { PrefKey, getPref } from "@utils/preferences";
 import { SoundShortcut } from "./shortcuts/shortcut-sound";
 import { BxEvent } from "@/utils/bx-event";
 import { AppInterface } from "@/utils/global";
+import { BxSelectElement } from "@/web-components/bx-select";
 
 enum ShortcutAction {
     STREAM_SCREENSHOT_CAPTURE = 'stream-screenshot-capture',
@@ -211,6 +212,8 @@ export class ControllerShortcut {
     }
 
     static renderSettings() {
+        const PREF_CONTROLLER_FRIENDLY_UI = getPref(PrefKey.UI_CONTROLLER_FRIENDLY);
+
         // Read actions from localStorage
         ControllerShortcut.#ACTIONS = JSON.parse(window.localStorage.getItem(ControllerShortcut.#STORAGE_KEY) || '{}');
 
@@ -287,23 +290,23 @@ export class ControllerShortcut {
         }
 
         let $remap: HTMLElement;
-        let $selectProfile: HTMLSelectElement;
+        const $selectProfile = CE<HTMLSelectElement>('select', {class: 'bx-shortcut-profile', autocomplete: 'off'});
 
         const $container = CE('div', {'data-has-gamepad': 'false'},
             CE('div', {},
-                CE('p', {'class': 'bx-shortcut-note'}, t('controller-shortcuts-connect-note')),
+                CE('p', {class: 'bx-shortcut-note'}, t('controller-shortcuts-connect-note')),
             ),
 
             $remap = CE('div', {},
-                $selectProfile = CE('select', {'class': 'bx-shortcut-profile', autocomplete: 'off'}),
-                CE('p', {'class': 'bx-shortcut-note'},
-                    CE('span', {'class': 'bx-prompt'}, PrompFont.HOME),
+                PREF_CONTROLLER_FRIENDLY_UI ? CE('div', {'data-focus-container': 'true'}, BxSelectElement.wrap($selectProfile)) : $selectProfile,
+                CE('p', {class: 'bx-shortcut-note'},
+                    CE('span', {class: 'bx-prompt'}, PrompFont.HOME),
                     ': ' + t('controller-shortcuts-xbox-note'),
                 ),
             ),
         );
 
-        $selectProfile.addEventListener('change', e => {
+        $selectProfile.addEventListener('input', e => {
             ControllerShortcut.#switchProfile($selectProfile.value);
         });
 
@@ -314,38 +317,51 @@ export class ControllerShortcut {
             const button: unknown = $target.dataset.button;
             const action = $target.value as ShortcutAction;
 
-            const $fakeSelect = $target.previousElementSibling! as HTMLSelectElement;
-            let fakeText = '---';
-            if (action) {
-                const $selectedOption =  $target.options[$target.selectedIndex];
-                const $optGroup = $selectedOption.parentElement as HTMLOptGroupElement;
-                fakeText = $optGroup.label + ' ❯ ' + $selectedOption.text;
+            if (!PREF_CONTROLLER_FRIENDLY_UI) {
+                const $fakeSelect = $target.previousElementSibling! as HTMLSelectElement;
+                let fakeText = '---';
+                if (action) {
+                    const $selectedOption =  $target.options[$target.selectedIndex];
+                    const $optGroup = $selectedOption.parentElement as HTMLOptGroupElement;
+                    fakeText = $optGroup.label + ' ❯ ' + $selectedOption.text;
+                }
+                ($fakeSelect.firstElementChild as HTMLOptionElement).text = fakeText;
             }
-            ($fakeSelect.firstElementChild as HTMLOptionElement).text = fakeText;
 
             !(e as any).ignoreOnChange && ControllerShortcut.#updateAction(profile, button as GamepadKey, action);
         };
 
+
         // @ts-ignore
         for (const [button, prompt] of buttons) {
-            const $row = CE('div', {'class': 'bx-shortcut-row'});
+            const $row = CE('div', {
+                class: 'bx-shortcut-row',
+                'data-focus-container': 'true',
+            });
 
-            const $label = CE('label', {'class': 'bx-prompt'}, `${PrompFont.HOME} + ${prompt}`);
+            const $label = CE('label', {class: 'bx-prompt'}, `${PrompFont.HOME} + ${prompt}`);
 
-            const $div = CE('div', {'class': 'bx-shortcut-actions'});
+            const $div = CE('div', {class: 'bx-shortcut-actions'});
 
-            const $fakeSelect = CE<HTMLSelectElement>('select', {autocomplete: 'off'},
-                CE('option', {}, '---'),
-            );
-            $div.appendChild($fakeSelect);
+            if (!PREF_CONTROLLER_FRIENDLY_UI) {
+                const $fakeSelect = CE<HTMLSelectElement>('select', {autocomplete: 'off'},
+                    CE('option', {}, '---'),
+                );
+
+                $div.appendChild($fakeSelect);
+            }
 
             const $select = $baseSelect.cloneNode(true) as HTMLSelectElement;
             $select.dataset.button = button.toString();
-            $select.addEventListener('change', onActionChanged);
+            $select.addEventListener('input', onActionChanged);
 
             ControllerShortcut.#$selectActions[button] = $select;
 
-            $div.appendChild($select);
+            if (PREF_CONTROLLER_FRIENDLY_UI) {
+                $div.appendChild(BxSelectElement.wrap($select));
+            } else {
+                $div.appendChild($select);
+            }
 
             $row.appendChild($label);
             $row.appendChild($div);

src/modules/patcher.ts

@@ -9,6 +9,7 @@ import { BxEvent } from "@/utils/bx-event";
 import codeControllerShortcuts from "./patches/controller-shortcuts.js" with { type: "text" };
 import codeExposeStreamSession from "./patches/expose-stream-session.js" with { type: "text" };
 import codeLocalCoOpEnable from "./patches/local-co-op-enable.js" with { type: "text" };
+import codeSetCurrentlyFocusedInteractable from "./patches/set-currently-focused-interactable.js" with { type: "text" };
 import codeRemotePlayEnable from "./patches/remote-play-enable.js" with { type: "text" };
 import codeRemotePlayKeepAlive from "./patches/remote-play-keep-alive.js" with { type: "text" };
 import codeVibrationAdjust from "./patches/vibration-adjust.js" with { type: "text" };
@@ -451,6 +452,17 @@ BxEvent.dispatch(window, BxEvent.XCLOUD_POLLING_MODE_CHANGED, {mode: e});
         return str;
     },
 
+    patchGamepadPolling(str: string) {
+        let index = str.indexOf('.shouldHandleGamepadInput)())return void');
+        if (index === -1) {
+            return false;
+        }
+
+        index = str.indexOf('{', index - 20) + 1;
+        str = str.substring(0, index) + 'if (window.BX_EXPOSED.disableGamepadPolling) return;' + str.substring(index);
+        return str;
+    },
+
     patchXcloudTitleInfo(str: string) {
         const text = 'async cloudConnect';
         let index = str.indexOf(text);
@@ -738,6 +750,55 @@ true` + text;
         str = str.substring(0, index) + 'true ? null :' + str.substring(index);
         return str;
     },
+
+    // Override Storage.getSettings()
+    overrideStorageGetSettings(str: string) {
+        const text = '}getSetting(e){';
+        if (!str.includes(text)) {
+            return false;
+        }
+
+        const newCode = `
+// console.log('setting', this.baseStorageKey, e);
+if (this.baseStorageKey in window.BX_EXPOSED.overrideSettings) {
+    const settings = window.BX_EXPOSED.overrideSettings[this.baseStorageKey];
+    if (e in settings) {
+        return settings[e];
+    }
+}
+`;
+        str = str.replace(text, text + newCode);
+        return str;
+    },
+
+    // game-stream.js   24.16.4
+    alwaysShowStreamHud(str: string) {
+        let index = str.indexOf(',{onShowStreamMenu:');
+        if (index === -1) {
+            return false;
+        }
+
+        index = str.indexOf('&&(0,', index - 100);
+        if (index === -1) {
+            return false;
+        }
+
+        const commaIndex = str.indexOf(',', index - 10);
+        str = str.substring(0, commaIndex) + ',true' + str.substring(index);
+        return str;
+    },
+
+    // 24225.js#4127, 24.17.11
+    patchSetCurrentlyFocusedInteractable(str: string) {
+        let index = str.indexOf('.setCurrentlyFocusedInteractable=(');
+        if (index === -1) {
+            return false;
+        }
+
+        index = str.indexOf('{', index) + 1;
+        str = str.substring(0, index) + codeSetCurrentlyFocusedInteractable + str.substring(index);
+        return str;
+    },
 };
 
 let PATCH_ORDERS: PatchArray = [
@@ -753,12 +814,16 @@ let PATCH_ORDERS: PatchArray = [
     'disableStreamGate',
     'overrideSettings',
     'broadcastPollingMode',
+    'patchGamepadPolling',
 
     'exposeStreamSession',
     'exposeDialogRoutes',
 
     'enableTvRoutes',
 
+    'overrideStorageGetSettings',
+    getPref(PrefKey.UI_GAME_CARD_SHOW_WAIT_TIME) && 'patchSetCurrentlyFocusedInteractable',
+
     getPref(PrefKey.UI_LAYOUT) !== 'default' && 'websiteLayout',
     getPref(PrefKey.LOCAL_CO_OP_ENABLED) && 'supportLocalCoOp',
     getPref(PrefKey.GAME_FORTNITE_FORCE_CONSOLE) && 'forceFortniteConsole',
@@ -797,6 +862,8 @@ let PLAYING_PATCH_ORDERS: PatchArray = [
     'patchStreamHud',
     'playVibration',
 
+    'alwaysShowStreamHud',
+
     // 'exposeEventTarget',
 
     // Patch volume control for normal stream
@@ -810,7 +877,7 @@ let PLAYING_PATCH_ORDERS: PatchArray = [
     ...(STATES.userAgent.capabilities.touch ? [
         getPref(PrefKey.STREAM_TOUCH_CONTROLLER) === 'all' && 'patchShowSensorControls',
         getPref(PrefKey.STREAM_TOUCH_CONTROLLER) === 'all' && 'exposeTouchLayoutManager',
-        (getPref(PrefKey.STREAM_TOUCH_CONTROLLER) === 'off' || getPref(PrefKey.STREAM_TOUCH_CONTROLLER_AUTO_OFF)) && 'disableTakRenderer',
+        (getPref(PrefKey.STREAM_TOUCH_CONTROLLER) === 'off' || getPref(PrefKey.STREAM_TOUCH_CONTROLLER_AUTO_OFF) || !STATES.userAgent.capabilities.touch) && 'disableTakRenderer',
         getPref(PrefKey.STREAM_TOUCH_CONTROLLER_DEFAULT_OPACITY) !== 100 && 'patchTouchControlDefaultOpacity',
         'patchBabylonRendererClass',
     ] : []),

src/modules/patches/controller-shortcuts.js

@@ -1,3 +1,8 @@
+if (window.BX_EXPOSED.disableGamepadPolling) {
+    this.inputConfiguration.useIntervalWorkerThreadForInput && this.intervalWorker ? this.intervalWorker.scheduleTimer(50) : this.pollGamepadssetTimeoutTimerID = setTimeout(this.pollGamepads, 50);
+    return;
+}
+
 const currentGamepad = ${gamepadVar};
 
 // Share button on XS controller

src/modules/patches/set-currently-focused-interactable.js

@@ -0,0 +1 @@
+e && BxEvent.dispatch(window, BxEvent.NAVIGATION_FOCUS_CHANGED, {element: e});

src/modules/remote-play.ts

@@ -7,6 +7,7 @@ import { getPref, PrefKey, setPref } from "@utils/preferences";
 import { t } from "@utils/translation";
 import { localRedirect } from "@modules/ui/ui";
 import { BxLogger } from "@utils/bx-logger";
+import { HeaderSection } from "./ui/header";
 
 const LOG_TAG = 'RemotePlay';
 
@@ -97,6 +98,10 @@ export class RemotePlay {
         RemotePlay.#getXhomeToken(() => {
             RemotePlay.#getConsolesList(() => {
                 BxLogger.info(LOG_TAG, 'Consoles', RemotePlay.#CONSOLES);
+                if (RemotePlay.#CONSOLES && RemotePlay.#CONSOLES.length > 0) {
+                    STATES.supportedRegion && HeaderSection.showRemotePlayButton();
+                }
+
                 RemotePlay.#renderConsoles();
                 BxEvent.dispatch(window, BxEvent.REMOTE_PLAY_READY);
             });

src/modules/stream-player.ts

@@ -68,7 +68,7 @@ export class StreamPlayer {
         const filters = [];
 
         const sharpness = this.#options.sharpness || 0;
-        if (sharpness != 0) {
+        if (this.#options.processing === StreamVideoProcessing.USM && sharpness != 0) {
             const level = (7 - ((sharpness / 2) - 1) * 0.5).toFixed(1); // 5, 5.5, 6, 6.5, 7
             const matrix = `0 -1 0 -1 ${level} -1 0 -1 0`;
             this.#$usmMatrix?.setAttributeNS(null, 'kernelMatrix', matrix);

src/modules/stream/stream-settings.ts

@@ -11,9 +11,23 @@ import { SoundShortcut } from "../shortcuts/shortcut-sound";
 import { TouchController } from "../touch-controller";
 import { VibrationManager } from "../vibration-manager";
 import { StreamStats } from "./stream-stats";
-import { BX_FLAGS } from "@/utils/bx-flags";
 import { BxSelectElement } from "@/web-components/bx-select";
 import { onChangeVideoPlayerType, updateVideoPlayer } from "./stream-settings-utils";
+import { GamepadKey } from "@/enums/mkb";
+import { EmulatedMkbHandler } from "../mkb/mkb-handler";
+
+enum NavigationDirection {
+    UP = 1,
+    RIGHT,
+    DOWN,
+    LEFT,
+}
+
+enum FocusContainer {
+    OUTSIDE,
+    TABS,
+    SETTINGS,
+}
 
 export class StreamSettings {
     private static instance: StreamSettings;
@@ -26,7 +40,38 @@ export class StreamSettings {
         return StreamSettings.instance;
     }
 
+    static readonly MAIN_CLASS = 'bx-stream-settings-dialog';
+
+    private static readonly GAMEPAD_POLLING_INTERVAL = 50;
+    private static readonly GAMEPAD_KEYS = [
+        GamepadKey.UP,
+        GamepadKey.DOWN,
+        GamepadKey.LEFT,
+        GamepadKey.RIGHT,
+        GamepadKey.A,
+        GamepadKey.B,
+        GamepadKey.LB,
+        GamepadKey.RB,
+    ];
+
+    private static readonly GAMEPAD_DIRECTION_MAP = {
+        [GamepadKey.UP]: NavigationDirection.UP,
+        [GamepadKey.DOWN]: NavigationDirection.DOWN,
+        [GamepadKey.LEFT]: NavigationDirection.LEFT,
+        [GamepadKey.RIGHT]: NavigationDirection.RIGHT,
+
+        [GamepadKey.LS_UP]: NavigationDirection.UP,
+        [GamepadKey.LS_DOWN]: NavigationDirection.DOWN,
+        [GamepadKey.LS_LEFT]: NavigationDirection.LEFT,
+        [GamepadKey.LS_RIGHT]: NavigationDirection.RIGHT,
+    };
+
+    private gamepadPollingIntervalId: number | null = null;
+    private gamepadLastButtons: Array<GamepadKey | null> = [];
+
     private $container: HTMLElement | undefined;
+    private $tabs: HTMLElement | undefined;
+    private $settings: HTMLElement | undefined;
     private $overlay: HTMLElement | undefined;
 
     readonly SETTINGS_UI = [{
@@ -240,46 +285,356 @@ export class StreamSettings {
 
     constructor() {
         this.#setupDialog();
+
+        // Hide dialog when the Guide menu is shown
+        window.addEventListener(BxEvent.XCLOUD_GUIDE_MENU_SHOWN, e => this.hide());
+    }
+
+    isShowing() {
+        return this.$container && !this.$container.classList.contains('bx-gone');
     }
 
     show(tabId?: string) {
         const $container = this.$container!;
         // Select tab
         if (tabId) {
-            const $tab = $container.querySelector(`.bx-stream-settings-tabs svg[data-group=${tabId}]`);
+            const $tab = $container.querySelector(`.bx-stream-settings-tabs svg[data-tab-group=${tabId}]`);
             $tab && $tab.dispatchEvent(new Event('click'));
         }
 
+        // Show overlay
         this.$overlay!.classList.remove('bx-gone');
         this.$overlay!.dataset.isPlaying = STATES.isPlaying.toString();
 
+        // Show dialog
         $container.classList.remove('bx-gone');
+        // Lock scroll bar
         document.body.classList.add('bx-no-scroll');
 
+        // Focus the first visible setting
+        this.#focusDirection(NavigationDirection.DOWN);
+
+        // Add event listeners
+        $container.addEventListener('keydown', this);
+
+        // Start gamepad polling
+        this.#startGamepadPolling();
+
+        // Disable xCloud's navigation polling
+        (window as any).BX_EXPOSED.disableGamepadPolling = true;
+
         BxEvent.dispatch(window, BxEvent.XCLOUD_DIALOG_SHOWN);
     }
 
     hide() {
+        // Hide overlay
         this.$overlay!.classList.add('bx-gone');
+        // Hide dialog
         this.$container!.classList.add('bx-gone');
-
+        // Show scroll bar
         document.body.classList.remove('bx-no-scroll');
 
+        // Remove event listeners
+        this.$container!.removeEventListener('keydown', this);
+
+        // Stop gamepad polling();
+        this.#stopGamepadPolling();
+
+        // Enable xCloud's navigation polling
+        (window as any).BX_EXPOSED.disableGamepadPolling = false;
+
         BxEvent.dispatch(window, BxEvent.XCLOUD_DIALOG_DISMISSED);
     }
 
+    #focusCurrentTab() {
+        const $currentTab = this.$tabs!.querySelector('.bx-active') as HTMLElement;
+        $currentTab && $currentTab.focus();
+    }
+
+    #pollGamepad() {
+        const gamepads = window.navigator.getGamepads();
+
+        let direction: NavigationDirection | null = null;
+        for (const gamepad of gamepads) {
+            if (!gamepad || !gamepad.connected) {
+                continue;
+            }
+
+            // Ignore virtual controller
+            if (gamepad.id === EmulatedMkbHandler.VIRTUAL_GAMEPAD_ID) {
+                continue;
+            }
+
+            const axes = gamepad.axes;
+            const buttons = gamepad.buttons;
+
+            let lastButton = this.gamepadLastButtons[gamepad.index];
+            let pressedButton: GamepadKey | null = null;
+            let holdingButton: GamepadKey | null = null;
+
+            for (const key of StreamSettings.GAMEPAD_KEYS) {
+                if (typeof lastButton === 'number') {
+                    // Key released
+                    if (lastButton === key && !buttons[key].pressed) {
+                        pressedButton = key;
+                        break;
+                    }
+                } else if (buttons[key].pressed) {
+                    // Key pressed
+                    holdingButton = key;
+                    break;
+                }
+            }
+
+            if (holdingButton === null && pressedButton === null && axes && axes.length >= 2) {
+                // Check sticks
+                // LEFT left-right, LEFT up-down
+
+                if (typeof lastButton === 'number') {
+                    const releasedHorizontal = Math.abs(axes[0]) < 0.1 && (lastButton === GamepadKey.LS_LEFT || lastButton === GamepadKey.LS_RIGHT);
+                    const releasedVertical = Math.abs(axes[1]) < 0.1 && (lastButton === GamepadKey.LS_UP || lastButton === GamepadKey.LS_DOWN);
+
+                    if (releasedHorizontal || releasedVertical) {
+                        pressedButton = lastButton;
+                    }
+                } else {
+                    if (axes[0] < -0.5) {
+                        holdingButton = GamepadKey.LS_LEFT;
+                    } else if (axes[0] > 0.5) {
+                        holdingButton = GamepadKey.LS_RIGHT;
+                    } else if (axes[1] < -0.5) {
+                        holdingButton = GamepadKey.LS_UP;
+                    } else if (axes[1] > 0.5) {
+                        holdingButton = GamepadKey.LS_DOWN;
+                    }
+                }
+            }
+
+            if (holdingButton !== null) {
+                this.gamepadLastButtons[gamepad.index] = holdingButton;
+            }
+
+            if (pressedButton === null) {
+                continue;
+            }
+
+            this.gamepadLastButtons[gamepad.index] = null;
+
+            if (pressedButton === GamepadKey.A) {
+                document.activeElement && document.activeElement.dispatchEvent(new MouseEvent('click'));
+                return;
+            } else if (pressedButton === GamepadKey.B) {
+                this.hide();
+                return;
+            } else if (pressedButton === GamepadKey.LB || pressedButton === GamepadKey.RB) {
+                // Focus setting tabs
+                this.#focusCurrentTab();
+                return;
+            }
+
+            direction = StreamSettings.GAMEPAD_DIRECTION_MAP[pressedButton as keyof typeof StreamSettings.GAMEPAD_DIRECTION_MAP];
+            if (direction) {
+                let handled = false;
+                if (document.activeElement instanceof HTMLInputElement && document.activeElement.type === 'range') {
+                    const $range = document.activeElement;
+                    if (direction === NavigationDirection.LEFT || direction === NavigationDirection.RIGHT) {
+                        $range.value = (parseInt($range.value) + parseInt($range.step) * (direction === NavigationDirection.LEFT ? -1 : 1)).toString();
+                        $range.dispatchEvent(new InputEvent('input'));
+                        handled = true;
+                    }
+                }
+
+                if (!handled) {
+                    this.#focusDirection(direction);
+                }
+            }
+
+            return;
+        }
+    }
+
+    #startGamepadPolling() {
+        this.#stopGamepadPolling();
+
+        this.gamepadPollingIntervalId = window.setInterval(this.#pollGamepad.bind(this), StreamSettings.GAMEPAD_POLLING_INTERVAL);
+    }
+
+    #stopGamepadPolling() {
+        this.gamepadLastButtons = [];
+
+        this.gamepadPollingIntervalId && window.clearInterval(this.gamepadPollingIntervalId);
+        this.gamepadPollingIntervalId = null;
+    }
+
+    #handleTabsNavigation($focusing: HTMLElement, direction: NavigationDirection) {
+        if (direction === NavigationDirection.UP || direction === NavigationDirection.DOWN) {
+            let $sibling = $focusing;
+            const siblingProperty = direction === NavigationDirection.UP ? 'previousElementSibling' : 'nextElementSibling';
+
+            while ($sibling[siblingProperty]) {
+                $sibling = $sibling[siblingProperty] as HTMLElement;
+                $sibling && $sibling.focus();
+                return;
+            }
+        } else if (direction === NavigationDirection.RIGHT) {
+            this.#focusFirstVisibleSetting();
+        }
+    }
+
+    #handleSettingsNavigation($focusing: HTMLElement, direction: NavigationDirection) {
+        // If current element's tabIndex property is not 0
+        if ($focusing.tabIndex !== 0) {
+            // Find first visible setting
+            const $childSetting = $focusing.querySelector('div[data-tab-group]:not(.bx-gone) [tabindex="0"]:not(a)') as HTMLElement;
+            if ($childSetting) {
+                $childSetting.focus();
+                return;
+            }
+        }
+
+        // Current element is setting -> Find the next one
+        // Find parent
+        let $parent = $focusing.closest('[data-focus-container]');
+
+        if (!$parent) {
+            return;
+        }
+
+        // Find sibling setting
+        let $sibling = $parent;
+        if (direction === NavigationDirection.UP || direction === NavigationDirection.DOWN) {
+            const siblingProperty = direction === NavigationDirection.UP ? 'previousElementSibling' : 'nextElementSibling';
+
+            while ($sibling[siblingProperty]) {
+                $sibling = $sibling[siblingProperty];
+                const $childSetting = $sibling.querySelector('[tabindex="0"]:last-of-type') as HTMLElement;
+                if ($childSetting) {
+                    $childSetting.focus();
+                    return;
+                }
+            }
+        } else if (direction === NavigationDirection.LEFT || direction === NavigationDirection.RIGHT) {
+            // Find all child elements with tabindex
+            const children = Array.from($parent.querySelectorAll('[tabindex="0"]'));
+            const index = children.indexOf($focusing);
+            let nextIndex;
+            if (direction === NavigationDirection.LEFT) {
+                nextIndex = index - 1;
+            } else {
+                nextIndex = index + 1;
+            }
+
+            nextIndex = Math.max(-1, Math.min(nextIndex, children.length - 1));
+            if (nextIndex === -1) {
+                // Focus setting tabs
+                const $tab = this.$tabs!.querySelector('svg.bx-active') as HTMLElement;
+                $tab && $tab.focus();
+            } else if (nextIndex !== index) {
+                (children[nextIndex] as HTMLElement).focus();
+            }
+        }
+    }
+
+    #focusFirstVisibleSetting() {
+        // Focus the first visible tab content
+        const $tab = this.$settings!.querySelector('div[data-tab-group]:not(.bx-gone)') as HTMLElement;
+
+        if ($tab) {
+            // Focus on the first focusable setting
+            const $control = $tab.querySelector('[tabindex="0"]:not(a)') as HTMLElement;
+            if ($control) {
+                $control.focus();
+            } else {
+                // Focus tab
+                $tab.focus();
+            }
+        }
+    }
+
+    #focusDirection(direction: NavigationDirection) {
+        const $tabs = this.$tabs!;
+        const $settings = this.$settings!;
+
+        // Get current focused element
+        let $focusing = document.activeElement as HTMLElement;
+
+        let focusContainer = FocusContainer.OUTSIDE;
+        if ($focusing) {
+            if ($settings.contains($focusing)) {
+                focusContainer = FocusContainer.SETTINGS;
+            } else if ($tabs.contains($focusing)) {
+                focusContainer = FocusContainer.TABS;
+            }
+        }
+
+        // If not focusing any element or the focused element is not inside the dialog
+        if (focusContainer === FocusContainer.OUTSIDE) {
+            this.#focusFirstVisibleSetting();
+            return;
+        } else if (focusContainer === FocusContainer.SETTINGS) {
+            this.#handleSettingsNavigation($focusing, direction);
+        } else if (focusContainer === FocusContainer.TABS) {
+            this.#handleTabsNavigation($focusing, direction);
+        }
+    }
+
+    handleEvent(event: Event) {
+        switch (event.type) {
+            case 'keydown':
+                const $target = event.target as HTMLElement;
+                const keyboardEvent = event as KeyboardEvent;
+                const keyCode = keyboardEvent.code || keyboardEvent.key;
+
+                let handled = false;
+
+                if (keyCode === 'ArrowUp' || keyCode === 'ArrowDown') {
+                    handled = true;
+                    this.#focusDirection(keyCode === 'ArrowUp' ? NavigationDirection.UP : NavigationDirection.DOWN);
+                } else if (keyCode === 'ArrowLeft' || keyCode === 'ArrowRight') {
+                    if (($target as any).type !== 'range') {
+                        handled = true;
+                        this.#focusDirection(keyCode === 'ArrowLeft' ? NavigationDirection.LEFT : NavigationDirection.RIGHT);
+                    }
+                } else if (keyCode === 'Enter' || keyCode === 'Space') {
+                    if ($target instanceof SVGElement) {
+                        handled = true;
+                        $target.dispatchEvent(new Event('click'));
+                    }
+                } else if (keyCode === 'Tab') {
+                    handled = true;
+                    this.#focusCurrentTab();
+                } else if (keyCode === 'Escape') {
+                    handled = true;
+                    this.hide();
+                }
+
+                if (handled) {
+                    event.preventDefault();
+                    event.stopPropagation();
+                }
+
+                break;
+        }
+    }
+
     #setupDialog() {
         let $tabs: HTMLElement;
         let $settings: HTMLElement;
 
-        const $overlay = CE('div', {'class': 'bx-stream-settings-overlay bx-gone'});
+        const $overlay = CE('div', {class: 'bx-stream-settings-overlay bx-gone'});
         this.$overlay = $overlay;
 
-        const $container = CE('div', {'class': 'bx-stream-settings-dialog bx-gone'},
-                $tabs = CE('div', {'class': 'bx-stream-settings-tabs'}),
-                $settings = CE('div', {'class': 'bx-stream-settings-tab-contents'}),
+        const $container = CE('div', {class: StreamSettings.MAIN_CLASS + ' bx-gone'},
+                $tabs = CE('div', {class: 'bx-stream-settings-tabs'}),
+                $settings = CE('div', {
+                    class: 'bx-stream-settings-tab-contents',
+                    tabindex: 10,
+                }),
             );
+
         this.$container = $container;
+        this.$tabs = $tabs;
+        this.$settings = $settings;
 
         // Close dialog when clicking on the overlay
         $overlay.addEventListener('click', e => {
@@ -294,10 +649,12 @@ export class StreamSettings {
             }
 
             const $svg = createSvgIcon(settingTab.icon);
+            $svg.tabIndex = 0;
+
             $svg.addEventListener('click', e => {
                 // Switch tab
                 for (const $child of Array.from($settings.children)) {
-                    if ($child.getAttribute('data-group') === settingTab.group) {
+                    if ($child.getAttribute('data-tab-group') === settingTab.group) {
                         $child.classList.remove('bx-gone');
                     } else {
                         $child.classList.add('bx-gone');
@@ -314,20 +671,21 @@ export class StreamSettings {
 
             $tabs.appendChild($svg);
 
-            const $group = CE('div', {'data-group': settingTab.group, 'class': 'bx-gone'});
+            const $group = CE('div', {'data-tab-group': settingTab.group, 'class': 'bx-gone'});
 
             for (const settingGroup of settingTab.items) {
                 if (!settingGroup) {
                     continue;
                 }
 
-                $group.appendChild(CE('h2', {},
+                $group.appendChild(CE('h2', {'data-focus-container': 'true'},
                         CE('span', {}, settingGroup.label),
                         settingGroup.help_url && createButton({
                                 icon: BxIcon.QUESTION,
-                                style: ButtonStyle.GHOST,
+                                style: ButtonStyle.GHOST | ButtonStyle.FOCUSABLE,
                                 url: settingGroup.help_url,
                                 title: t('help'),
+                                tabIndex: 0,
                             }),
                     ));
                 if (settingGroup.note) {
@@ -359,7 +717,8 @@ export class StreamSettings {
                     } else if (!setting.unsupported) {
                         $control = toPrefElement(pref, setting.onChange, setting.params);
 
-                        if ($control instanceof HTMLSelectElement && BX_FLAGS.ScriptUi === 'tv') {
+                        // Replace <select> with controller-friendly one
+                        if ($control instanceof HTMLSelectElement && getPref(PrefKey.UI_CONTROLLER_FRIENDLY)) {
                             $control = BxSelectElement.wrap($control);
                         }
                     }
@@ -367,7 +726,11 @@ export class StreamSettings {
                     const label = Preferences.SETTINGS[pref as PrefKey]?.label || setting.label;
                     const note = Preferences.SETTINGS[pref as PrefKey]?.note || setting.note;
 
-                    const $content = CE('div', {'class': 'bx-stream-settings-row', 'data-type': settingGroup.group},
+                    const $content = CE('div', {
+                        class: 'bx-stream-settings-row',
+                        'data-type': settingGroup.group,
+                        'data-focus-container': 'true',
+                    },
                         CE('label', {for: `bx_setting_${pref}`},
                             label,
                             note && CE('div', {'class': 'bx-stream-settings-dialog-note'}, note),
@@ -390,5 +753,8 @@ export class StreamSettings {
 
         document.documentElement.appendChild($overlay);
         document.documentElement.appendChild($container);
+
+        // Update video's settings
+        onChangeVideoPlayerType();
     }
 }

src/modules/stream/stream-stats.ts

@@ -142,10 +142,10 @@ export class StreamStats {
                 this.#$fps!.textContent = stat.framesPerSecond || 0;
 
                 // Packets Lost
-                const packetsLost = stat.packetsLost;
+                const packetsLost = Math.max(0, stat.packetsLost);  // packetsLost can be negative, but we don't care about that
                 const packetsReceived = stat.packetsReceived;
                 const packetsLostPercentage = (packetsLost * 100 / ((packetsLost + packetsReceived) || 1)).toFixed(2);
-                this.#$pl!.textContent = packetsLostPercentage === '0.00' ? packetsLost : `${packetsLost} (${packetsLostPercentage}%)`;
+                this.#$pl!.textContent = packetsLostPercentage === '0.00' ? packetsLost.toString() : `${packetsLost} (${packetsLostPercentage}%)`;
 
                 // Frames dropped
                 const framesDropped = stat.framesDropped;

src/modules/ui/game-tile.ts

@@ -0,0 +1,87 @@
+import { BxEvent } from "@/utils/bx-event";
+import { BxIcon } from "@/utils/bx-icon";
+import { CE, createSvgIcon, getReactProps } from "@/utils/html";
+import { XcloudApi } from "@/utils/xcloud-api";
+
+export class GameTile {
+    static #timeout: number | null;
+
+    static #secondsToHms(seconds: number) {
+        let h = Math.floor(seconds / 3600);
+        seconds %= 3600;
+        let m = Math.floor(seconds / 60);
+        let s = seconds % 60;
+
+        const output = [];
+        h > 0 && output.push(`${h}h`);
+        m > 0 && output.push(`${m}m`);
+        if (s > 0 || output.length === 0) {
+            output.push(`${s}s`);
+        }
+
+        return output.join(' ');
+    }
+
+    static async #showWaitTime($elm: HTMLElement, productId: string) {
+        let totalWaitTime;
+
+        const api = XcloudApi.getInstance();
+        const info = await api.getTitleInfo(productId);
+        if (info) {
+            const waitTime = await api.getWaitTime(info.titleId);
+            if (waitTime) {
+                totalWaitTime = waitTime.estimatedAllocationTimeInSeconds;
+            }
+        }
+
+        if (typeof totalWaitTime === 'number' && $elm.isConnected) {
+            const $div = CE('div', {'class': 'bx-game-tile-wait-time'},
+                createSvgIcon(BxIcon.PLAYTIME),
+                CE('span', {}, GameTile.#secondsToHms(totalWaitTime)),
+            );
+            $elm.insertAdjacentElement('afterbegin', $div);
+        }
+    }
+
+    static requestWaitTime($elm: HTMLElement, productId: string) {
+        GameTile.#timeout && clearTimeout(GameTile.#timeout);
+        GameTile.#timeout = window.setTimeout(async () => {
+            if (!($elm as any).hasWaitTime) {
+                ($elm as any).hasWaitTime = true;
+                GameTile.#showWaitTime($elm, productId);
+            }
+        }, 1000);
+    }
+
+    static setup() {
+        window.addEventListener(BxEvent.NAVIGATION_FOCUS_CHANGED, e => {
+            let productId;
+            const $elm = (e as any).element;
+            try {
+                if (($elm.tagName === 'BUTTON' && $elm.className.includes('MruGameCard')) || (($elm.tagName === 'A' && $elm.className.includes('GameCard')))) {
+                    let props = getReactProps($elm.parentElement);
+
+                    // When context menu is enabled
+                    if (Array.isArray(props.children)) {
+                        productId = props.children[0].props.productId;
+                    } else {
+                        productId = props.children.props.productId;
+                    }
+                } else if ($elm.tagName === 'A' && $elm.className.includes('GameItem'))  {
+                    let props = getReactProps($elm.parentElement);
+                    props = props.children.props;
+                    if (props.location !== 'NonStreamableGameItem') {
+                        if ('productId' in props) {
+                            productId = props.productId;
+                        } else {
+                            // Search page
+                            productId = props.children.props.productId;
+                        }
+                    }
+                }
+            } catch (e) {}
+
+            productId && GameTile.requestWaitTime($elm, productId);
+        });
+    }
+}

src/modules/ui/global-settings.ts

@@ -7,7 +7,6 @@ import { getPref, Preferences, PrefKey, setPref, toPrefElement } from "@utils/pr
 import { t, Translations } from "@utils/translation";
 import { PatcherCache } from "../patcher";
 import { UserAgentProfile } from "@enums/user-agent";
-import { BX_FLAGS } from "@/utils/bx-flags";
 import { BxSelectElement } from "@/web-components/bx-select";
 import { StreamSettings } from "../stream/stream-settings";
 
@@ -15,6 +14,8 @@ const SETTINGS_UI = {
     'Better xCloud': {
         items: [
             PrefKey.BETTER_XCLOUD_LOCALE,
+            PrefKey.SERVER_BYPASS_RESTRICTION,
+            PrefKey.UI_CONTROLLER_FRIENDLY,
             PrefKey.REMOTE_PLAY_ENABLED,
         ],
     },
@@ -89,6 +90,7 @@ const SETTINGS_UI = {
         items: [
             PrefKey.UI_LAYOUT,
             PrefKey.UI_HOME_CONTEXT_MENU_DISABLED,
+            PrefKey.UI_GAME_CARD_SHOW_WAIT_TIME,
             PrefKey.CONTROLLER_SHOW_CONNECTION_STATUS,
             PrefKey.STREAM_SIMPLIFY_MENU,
             PrefKey.SKIP_SPLASH_VIDEO,
@@ -132,11 +134,12 @@ export function setupSettingsUi() {
 
     const $wrapper = CE('div', {'class': 'bx-settings-wrapper'},
             CE('div', {'class': 'bx-settings-title-wrapper'},
-                CE('a', {
-                    'class': 'bx-settings-title',
-                    'href': 'https://github.com/redphx/better-xcloud/releases',
-                    'target': '_blank',
-                }, 'Better xCloud ' + SCRIPT_VERSION),
+                createButton({
+                    classes: ['bx-settings-title'],
+                    style: ButtonStyle.FOCUSABLE | ButtonStyle.GHOST,
+                    label: 'Better xCloud ' + SCRIPT_VERSION,
+                    url: 'https://github.com/redphx/better-xcloud/releases',
+                }),
                 createButton({
                     icon: BxIcon.QUESTION,
                     style: ButtonStyle.FOCUSABLE,
@@ -159,7 +162,7 @@ export function setupSettingsUi() {
     }
 
     // "Stream settings" button
-    topButtons.push(createButton({
+    (STATES.supportedRegion && STATES.isSignedIn) && topButtons.push(createButton({
         label: t('stream-settings'),
         icon: BxIcon.STREAM_SETTINGS,
         style: ButtonStyle.FULL_WIDTH | ButtonStyle.FOCUSABLE,
@@ -200,6 +203,8 @@ export function setupSettingsUi() {
         $wrapper.appendChild($div);
     }
 
+    let localeSwitchingTimeout: number | null;
+
     const onChange = async (e: Event) => {
         // Clear PatcherCache;
         PatcherCache.clear();
@@ -211,12 +216,17 @@ export function setupSettingsUi() {
         $btnHeaderSettings && $btnHeaderSettings.classList.add('bx-danger');
 
         if ((e.target as HTMLElement).id === 'bx_setting_' + PrefKey.BETTER_XCLOUD_LOCALE) {
-            // Update locale
-            Translations.refreshCurrentLocale();
-            await Translations.updateTranslations();
+            if (getPref(PrefKey.UI_CONTROLLER_FRIENDLY)) {
+                localeSwitchingTimeout && window.clearTimeout(localeSwitchingTimeout);
+                localeSwitchingTimeout = window.setTimeout(() => {
+                    Translations.refreshCurrentLocale();
+                    Translations.updateTranslations();
+                }, 1000);
+            } else {
+                // Update locale
+                Translations.refreshCurrentLocale();
+                await Translations.updateTranslations();
 
-            // Don't refresh the page on TV
-            if (BX_FLAGS.ScriptUi !== 'tv') {
                 $btnReload.textContent = t('settings-reloading');
                 $btnReload.click();
             }
@@ -225,6 +235,11 @@ export function setupSettingsUi() {
 
     // Render settings
     for (let groupLabel in SETTINGS_UI) {
+        // Don't render other settings when not signed in
+        if (groupLabel !== 'Better xCloud' && (!STATES.supportedRegion || !STATES.isSignedIn)) {
+            continue;
+        }
+
         const $group = CE('span', {'class': 'bx-settings-group-label'}, groupLabel);
 
         // Render note
@@ -259,9 +274,9 @@ export function setupSettingsUi() {
             if (setting.experimental) {
                 settingLabel = '🧪 ' + settingLabel;
                 if (!settingNote) {
-                    settingNote = t('experimental')
+                    settingNote = t('experimental');
                 } else {
-                    settingNote = `${t('experimental')}: ${settingNote}`
+                    settingNote = `${t('experimental')}: ${settingNote}`;
                 }
             }
 
@@ -342,6 +357,8 @@ export function setupSettingsUi() {
                     $control.appendChild($option);
                 }
 
+                $control.disabled = Object.keys(STATES.serverRegions).length === 0;
+
                 // Select preferred region
                 $control.value = selectedValue;
             } else {
@@ -371,22 +388,26 @@ export function setupSettingsUi() {
                 $control.setAttribute('tabindex', -1);
             }
 
-            const $label = CE('label', labelAttrs, settingLabel);
+            const $label = CE<HTMLLabelElement>('label', labelAttrs, settingLabel);
             if (settingNote) {
                 $label.appendChild(CE('b', {}, settingNote));
             }
 
             let $elm: HTMLElement;
 
-            if ($control instanceof HTMLSelectElement && BX_FLAGS.ScriptUi === 'tv') {
-                $elm = CE('div', {'class': 'bx-settings-row'},
+            if ($control instanceof HTMLSelectElement && getPref(PrefKey.UI_CONTROLLER_FRIENDLY)) {
+                // Controller-friendly <select>
+                $elm = CE('div', {'class': 'bx-settings-row', 'data-group': 0},
                     $label,
-                    BxSelectElement.wrap($control),
+                    CE('div', {class: 'bx-setting-control'}, BxSelectElement.wrap($control)),
                 );
             } else {
-                $elm = CE('div', {'class': 'bx-settings-row'},
+                $elm = CE('div', {'class': 'bx-settings-row', 'data-group': 0},
                     $label,
-                    $control,
+                    $control instanceof HTMLInputElement ? CE('label', {
+                        class: 'bx-setting-control',
+                        for: $label.getAttribute('for'),
+                    }, $control) : CE('div', {class: 'bx-setting-control'}, $control),
                 );
             }
 

src/modules/ui/guide-menu.ts

@@ -43,11 +43,18 @@ export class GuideMenu {
             },
         }),
 
-        reloadStream: createButton({
-            label: t('reload-stream'),
+        reloadPage: createButton({
+            label: t('reload-page'),
             style: ButtonStyle.FULL_WIDTH | ButtonStyle.FOCUSABLE,
             onClick: e => {
-                confirm(t('confirm-reload-stream')) && window.location.reload();
+                if (STATES.isPlaying) {
+                    confirm(t('confirm-reload-stream')) && window.location.reload();
+                } else {
+                    window.location.reload();
+                }
+
+                // Close all xCloud's dialogs
+                window.BX_EXPOSED.dialogRoutes.closeAll();
             },
         }),
 
@@ -88,6 +95,9 @@ export class GuideMenu {
             buttons.push(GuideMenu.#BUTTONS.closeApp);
         }
 
+        // Reload page
+        buttons.push(GuideMenu.#BUTTONS.reloadPage);
+
         const $buttons = GuideMenu.#renderButtons(buttons);
 
         const $lastDivider = $dividers[$dividers.length - 1];
@@ -105,8 +115,8 @@ export class GuideMenu {
         buttons.push(GuideMenu.#BUTTONS.streamSetting);
         AppInterface && buttons.push(GuideMenu.#BUTTONS.appSettings);
 
-        // Reload stream
-        buttons.push(GuideMenu.#BUTTONS.reloadStream);
+        // Reload page
+        buttons.push(GuideMenu.#BUTTONS.reloadPage);
 
         // Back to home
         buttons.push(GuideMenu.#BUTTONS.backToHome);

src/modules/ui/header.ts

@@ -1,5 +1,5 @@
 import { SCRIPT_VERSION } from "@utils/global";
-import { createButton, ButtonStyle } from "@utils/html";
+import { createButton, ButtonStyle, CE } from "@utils/html";
 import { BxIcon } from "@utils/bx-icon";
 import { getPreferredServerRegion } from "@utils/region";
 import { PrefKey, getPref } from "@utils/preferences";
@@ -7,35 +7,20 @@ import { RemotePlay } from "@modules/remote-play";
 import { t } from "@utils/translation";
 import { setupSettingsUi } from "./global-settings";
 
+export class HeaderSection {
+    static #$remotePlayBtn = createButton({
+        classes: ['bx-header-remote-play-button', 'bx-gone'],
+        icon: BxIcon.REMOTE_PLAY,
+        title: t('remote-play'),
+        style: ButtonStyle.GHOST | ButtonStyle.FOCUSABLE,
+        onClick: e => {
+            RemotePlay.togglePopup();
+        },
+    });
 
-function injectSettingsButton($parent?: HTMLElement) {
-    if (!$parent) {
-        return;
-    }
-
-    const PREF_PREFERRED_REGION = getPreferredServerRegion(true);
-    const PREF_LATEST_VERSION = getPref(PrefKey.LATEST_VERSION);
-
-    const $headerFragment = document.createDocumentFragment();
-
-    // Remote Play button
-    if (getPref(PrefKey.REMOTE_PLAY_ENABLED)) {
-        const $remotePlayBtn = createButton({
-            classes: ['bx-header-remote-play-button'],
-            icon: BxIcon.REMOTE_PLAY,
-            title: t('remote-play'),
-            style: ButtonStyle.GHOST | ButtonStyle.FOCUSABLE,
-            onClick: e => {
-                RemotePlay.togglePopup();
-            },
-        });
-        $headerFragment.appendChild($remotePlayBtn);
-    }
-
-    // Setup Settings button
-    const $settingsBtn = createButton({
+    static #$settingsBtn = createButton({
         classes: ['bx-header-settings-button'],
-        label: PREF_PREFERRED_REGION,
+        label: '???',
         style: ButtonStyle.GHOST | ButtonStyle.FOCUSABLE | ButtonStyle.FULL_HEIGHT,
         onClick: e => {
             setupSettingsUi();
@@ -47,39 +32,58 @@ function injectSettingsButton($parent?: HTMLElement) {
         },
     });
 
-    // Show new update status
-    if (!SCRIPT_VERSION.includes('beta') && PREF_LATEST_VERSION && PREF_LATEST_VERSION !== SCRIPT_VERSION) {
-        $settingsBtn.setAttribute('data-update-available', 'true');
+    static #$buttonsWrapper = CE('div', {},
+        getPref(PrefKey.REMOTE_PLAY_ENABLED) ? HeaderSection.#$remotePlayBtn : null,
+        HeaderSection.#$settingsBtn,
+    );
+
+    static #observer: MutationObserver;
+    static #timeout: number | null;
+
+    static #injectSettingsButton($parent?: HTMLElement) {
+        if (!$parent) {
+            return;
+        }
+
+        const PREF_LATEST_VERSION = getPref(PrefKey.LATEST_VERSION);
+
+        // Setup Settings button
+        const $settingsBtn = HeaderSection.#$settingsBtn;
+        $settingsBtn.querySelector('span')!.textContent = getPreferredServerRegion(true);
+
+        // Show new update status
+        if (!SCRIPT_VERSION.includes('beta') && PREF_LATEST_VERSION && PREF_LATEST_VERSION !== SCRIPT_VERSION) {
+            $settingsBtn.setAttribute('data-update-available', 'true');
+        }
+
+        // Add the Settings button to the web page
+        $parent.appendChild(HeaderSection.#$buttonsWrapper);
     }
 
-    // Add the Settings button to the web page
-    $headerFragment.appendChild($settingsBtn);
-    $parent.appendChild($headerFragment);
-}
-
-
-export function checkHeader() {
-    const $button = document.querySelector('.bx-header-settings-button');
-
-    if (!$button) {
-        const $rightHeader = document.querySelector('#PageContent div[class*=EdgewaterHeader-module__rightSectionSpacing]');
-        injectSettingsButton($rightHeader as HTMLElement);
-    }
-}
-
-
-export function watchHeader() {
-    const $header = document.querySelector('#PageContent header');
-    if (!$header) {
-        return;
+    static checkHeader() {
+        if (!HeaderSection.#$buttonsWrapper.isConnected) {
+            const $rightHeader = document.querySelector('#PageContent div[class*=EdgewaterHeader-module__rightSectionSpacing]');
+            HeaderSection.#injectSettingsButton($rightHeader as HTMLElement);
+        }
     }
 
-    let timeout: number | null;
-    const observer = new MutationObserver(mutationList => {
-        timeout && clearTimeout(timeout);
-        timeout = window.setTimeout(checkHeader, 2000);
-    });
-    observer.observe($header, {subtree: true, childList: true});
+    static showRemotePlayButton() {
+        HeaderSection.#$remotePlayBtn.classList.remove('bx-gone');
+    }
 
-    checkHeader();
+    static watchHeader() {
+        const $header = document.querySelector('#PageContent header');
+        if (!$header) {
+            return;
+        }
+
+        HeaderSection.#observer && HeaderSection.#observer.disconnect();
+        HeaderSection.#observer = new MutationObserver(mutationList => {
+            HeaderSection.#timeout && clearTimeout(HeaderSection.#timeout);
+            HeaderSection.#timeout = window.setTimeout(HeaderSection.checkHeader, 2000);
+        });
+        HeaderSection.#observer.observe($header, {subtree: true, childList: true});
+
+        HeaderSection.checkHeader();
+    }
 }

src/types/index.d.ts

@@ -24,9 +24,14 @@ interface NavigatorBattery extends Navigator {
 }
 
 type BxStates = {
+    supportedRegion: boolean;
+    serverRegions: any;
+    selectedRegion: any;
+    gsToken: string;
+    isSignedIn: boolean;
+
     isPlaying: boolean;
     appContext: any | null;
-    serverRegions: any;
 
     browser: {
         capabilities: {
@@ -36,6 +41,7 @@ type BxStates = {
     };
 
     userAgent: {
+        isTv: boolean;
         capabilities: {
             touch: boolean;
         };
@@ -68,6 +74,8 @@ type BxStates = {
 type DualEnum = {[index: string]: number} & {[index: number]: string};
 
 type XcloudTitleInfo = {
+    titleId: string,
+
     details: {
         productId: string;
         supportedInputTypes: InputType[];
@@ -85,6 +93,12 @@ type XcloudTitleInfo = {
     };
 };
 
+type XcloudWaitTimeInfo = Partial<{
+    estimatedAllocationTimeInSeconds: number,
+    estimatedProvisioningTimeInSeconds: number,
+    estimatedTotalWaitTimeInSeconds: number,
+}>;
+
 declare module '*.js';
 declare module '*.svg';
 declare module '*.styl';

src/types/preferences.d.ts

@@ -1,5 +1,6 @@
 export type PreferenceSetting = {
     default: any;
+    optionsGroup?: string;
     options?: {[index: string]: string};
     multipleOptions?: {[index: string]: string};
     unsupported?: string | boolean;

src/utils/bx-event.ts

@@ -26,6 +26,7 @@ export enum BxEvent {
     REMOTE_PLAY_FAILED = 'bx-remote-play-failed',
 
     XCLOUD_SERVERS_READY = 'bx-servers-ready',
+    XCLOUD_SERVERS_UNAVAILABLE = 'bx-servers-unavailable',
 
     DATA_CHANNEL_CREATED = 'bx-data-channel-created',
 
@@ -38,6 +39,8 @@ export enum BxEvent {
     POINTER_LOCK_REQUESTED = 'bx-pointer-lock-requested',
     POINTER_LOCK_EXITED = 'bx-pointer-lock-exited',
 
+    NAVIGATION_FOCUS_CHANGED = 'bx-nav-focus-changed',
+
     // xCloud Dialog events
     XCLOUD_DIALOG_SHOWN = 'bx-xcloud-dialog-shown',
     XCLOUD_DIALOG_DISMISSED = 'bx-xcloud-dialog-dismissed',

src/utils/bx-exposed.ts

@@ -4,6 +4,7 @@ import { deepClone, STATES } from "@utils/global";
 import { getPref, PrefKey } from "@utils/preferences";
 import { BxLogger } from "./bx-logger";
 import { BX_FLAGS } from "./bx-flags";
+import { StreamSettings } from "@/modules/stream/stream-settings";
 
 export enum InputType {
     CONTROLLER = 'Controller',
@@ -109,4 +110,22 @@ export const BxExposed = {
 
     handleControllerShortcut: ControllerShortcut.handle,
     resetControllerShortcut: ControllerShortcut.reset,
+
+    overrideSettings: {
+        'Tv_settings': {
+            hasCompletedOnboarding: true,
+        },
+    },
+
+    disableGamepadPolling: false,
+
+    backButtonPressed: () => {
+        const streamSettings = StreamSettings.getInstance();
+        if (streamSettings.isShowing()) {
+            streamSettings.hide();
+            return true;
+        }
+
+        return false;
+    },
 };

src/utils/bx-flags.ts

@@ -10,8 +10,6 @@ type BxFlags = Partial<{
     ForceNativeMkbTitles: string[];
     FeatureGates: {[key: string]: boolean} | null,
 
-    ScriptUi: 'default' | 'tv',
-
     IsSupportedTvBrowser: boolean,
 }>
 
@@ -27,8 +25,6 @@ const DEFAULT_FLAGS: BxFlags = {
 
     ForceNativeMkbTitles: [],
     FeatureGates: null,
-
-    ScriptUi: 'default',
 }
 
 export const BX_FLAGS: BxFlags = Object.assign(DEFAULT_FLAGS, window.BX_FLAGS || {});

src/utils/feature-gates.ts

@@ -3,6 +3,7 @@ import { getPref, PrefKey } from "./preferences";
 
 export let FeatureGates: {[key: string]: boolean} = {
     'PwaPrompt': false,
+    'EnableWifiWarnings': false,
 };
 
 // Disable context menu in Home page

src/utils/global.ts

@@ -13,9 +13,14 @@ const browserHasTouchSupport = 'ontouchstart' in window || navigator.maxTouchPoi
 const userAgentHasTouchSupport = !isTv && !isVr && browserHasTouchSupport;
 
 export const STATES: BxStates = {
+    supportedRegion: true,
+    serverRegions: {},
+    selectedRegion: {},
+    gsToken: '',
+    isSignedIn: false,
+
     isPlaying: false,
     appContext: {},
-    serverRegions: {},
 
     browser: {
         capabilities: {
@@ -25,6 +30,7 @@ export const STATES: BxStates = {
     },
 
     userAgent: {
+        isTv: isTv,
         capabilities: {
             touch: userAgentHasTouchSupport,
         }

src/utils/history.ts

@@ -1,7 +1,8 @@
 import { BxEvent } from "@utils/bx-event";
 import { LoadingScreen } from "@modules/loading-screen";
 import { RemotePlay } from "@modules/remote-play";
-import { checkHeader } from "@modules/ui/header";
+import { HeaderSection } from "@/modules/ui/header";
+import { StreamSettings } from "@/modules/stream/stream-settings";
 
 export function patchHistoryMethod(type: 'pushState' | 'replaceState') {
     const orig = window.history[type];
@@ -25,16 +26,22 @@ export function onHistoryChanged(e: PopStateEvent) {
 
     window.setTimeout(RemotePlay.detect, 10);
 
+    // Hide Global settings
     const $settings = document.querySelector('.bx-settings-container');
     if ($settings) {
         $settings.classList.add('bx-gone');
     }
 
+    // Hide Stream settings
+    if (document.querySelector('.' + StreamSettings.MAIN_CLASS)) {
+        StreamSettings.getInstance().hide();
+    }
+
     // Hide Remote Play popup
     RemotePlay.detachPopup();
 
     LoadingScreen.reset();
-    window.setTimeout(checkHeader, 2000);
+    window.setTimeout(HeaderSection.watchHeader, 2000);
 
     BxEvent.dispatch(window, BxEvent.STREAM_STOPPED);
 }

src/utils/html.ts

@@ -9,6 +9,7 @@ type BxButton = {
     title?: string;
     disabled?: boolean;
     onClick?: EventListener;
+    tabIndex?: number;
     attributes?: {[key: string]: any},
 }
 
@@ -94,6 +95,7 @@ export const createButton = <T=HTMLButtonElement>(options: BxButton): T => {
     options.title && $btn.setAttribute('title', options.title);
     options.disabled && (($btn as HTMLButtonElement).disabled = true);
     options.onClick && $btn.addEventListener('click', options.onClick);
+    typeof options.tabIndex === 'number' && ($btn.tabIndex = options.tabIndex!);
 
     for (const key in options.attributes) {
         if (!$btn.hasOwnProperty(key)) {
@@ -104,6 +106,16 @@ export const createButton = <T=HTMLButtonElement>(options: BxButton): T => {
     return $btn as T;
 }
 
+export function getReactProps($elm: HTMLElement): any | null {
+    for (const key in $elm) {
+        if (key.startsWith('__reactProps')) {
+            return ($elm as any)[key];
+        }
+    }
+
+    return null;
+}
+
 export function escapeHtml(html: string): string {
     const text = document.createTextNode(html);
     const $span = document.createElement('span');

src/utils/network.ts

@@ -1,16 +1,13 @@
 import { BxEvent } from "@utils/bx-event";
 import { BX_FLAGS, NATIVE_FETCH } from "@utils/bx-flags";
-import { LoadingScreen } from "@modules/loading-screen";
 import { PrefKey, getPref } from "@utils/preferences";
-import { RemotePlay } from "@modules/remote-play";
-import { StreamBadges } from "@modules/stream/stream-badges";
 import { TouchController } from "@modules/touch-controller";
 import { STATES } from "@utils/global";
-import { getPreferredServerRegion } from "@utils/region";
 import { GamePassCloudGallery } from "../enums/game-pass-gallery";
-import { InputType } from "./bx-exposed";
 import { FeatureGates } from "./feature-gates";
 import { BxLogger } from "./bx-logger";
+import { XhomeInterceptor } from "./xhome-interceptor";
+import { XcloudInterceptor } from "./xcloud-interceptor";
 
 enum RequestType {
     XCLOUD = 'xcloud',
@@ -101,7 +98,7 @@ function updateIceCandidates(candidates: any, options: any) {
 }
 
 
-async function patchIceCandidates(request: Request, consoleAddrs?: {[index: string]: number}) {
+export async function patchIceCandidates(request: Request, consoleAddrs?: {[index: string]: number}) {
     const response = await NATIVE_FETCH(request);
     const text = await response.clone().text();
 
@@ -125,383 +122,6 @@ async function patchIceCandidates(request: Request, consoleAddrs?: {[index: stri
     return response;
 }
 
-
-class XhomeInterceptor {
-    static #consoleAddrs: {[index: string]: number} = {};
-
-    static async #handleLogin(request: Request) {
-        try {
-            const clone = (request as Request).clone();
-
-            const obj = await clone.json();
-            obj.offeringId = 'xhome';
-
-            request = new Request('https://xhome.gssv-play-prod.xboxlive.com/v2/login/user', {
-                method: 'POST',
-                body: JSON.stringify(obj),
-                headers: {
-                    'Content-Type': 'application/json',
-                },
-            });
-        } catch (e) {
-            alert(e);
-            console.log(e);
-        }
-
-        return NATIVE_FETCH(request);
-    }
-
-    static async #handleConfiguration(request: Request | URL) {
-        const response = await NATIVE_FETCH(request);
-
-        const obj = await response.clone().json()
-        console.log(obj);
-
-        const serverDetails = obj.serverDetails;
-        if (serverDetails.ipAddress) {
-            XhomeInterceptor.#consoleAddrs[serverDetails.ipAddress] = serverDetails.port;
-        }
-
-        if (serverDetails.ipV4Address) {
-            XhomeInterceptor.#consoleAddrs[serverDetails.ipV4Address] = serverDetails.ipV4Port;
-        }
-
-        if (serverDetails.ipV6Address) {
-            XhomeInterceptor.#consoleAddrs[serverDetails.ipV6Address] = serverDetails.ipV6Port;
-        }
-
-        response.json = () => Promise.resolve(obj);
-        response.text = () => Promise.resolve(JSON.stringify(obj));
-
-        return response;
-    }
-
-    static async #handleInputConfigs(request: Request | URL, opts: {[index: string]: any}) {
-        const response = await NATIVE_FETCH(request);
-
-        if (getPref(PrefKey.STREAM_TOUCH_CONTROLLER) !== 'all') {
-            return response;
-        }
-
-        const obj = await response.clone().json() as any;
-
-        const xboxTitleId = JSON.parse(opts.body).titleIds[0];
-        STATES.currentStream.xboxTitleId = xboxTitleId;
-
-        const inputConfigs = obj[0];
-
-        let hasTouchSupport = inputConfigs.supportedTabs.length > 0;
-        if (!hasTouchSupport) {
-            const supportedInputTypes = inputConfigs.supportedInputTypes;
-            hasTouchSupport = supportedInputTypes.includes(InputType.NATIVE_TOUCH) || supportedInputTypes.includes(InputType.CUSTOM_TOUCH_OVERLAY);
-        }
-
-        if (hasTouchSupport) {
-            TouchController.disable();
-
-            BxEvent.dispatch(window, BxEvent.CUSTOM_TOUCH_LAYOUTS_LOADED, {
-                data: null,
-            });
-        } else {
-            TouchController.enable();
-            TouchController.getCustomLayouts(xboxTitleId);
-        }
-
-        response.json = () => Promise.resolve(obj);
-        response.text = () => Promise.resolve(JSON.stringify(obj));
-
-        return response;
-    }
-
-    static async #handleTitles(request: Request) {
-        const clone = request.clone();
-
-        const headers: {[index: string]: any} = {};
-        for (const pair of (clone.headers as any).entries()) {
-            headers[pair[0]] = pair[1];
-        }
-        headers.authorization = `Bearer ${RemotePlay.XCLOUD_TOKEN}`;
-
-        const index = request.url.indexOf('.xboxlive.com');
-        request = new Request('https://wus.core.gssv-play-prod' + request.url.substring(index), {
-            method: clone.method,
-            body: await clone.text(),
-            headers: headers,
-        });
-
-        return NATIVE_FETCH(request);
-    }
-
-    static async #handlePlay(request: RequestInfo | URL) {
-        const clone = (request as Request).clone();
-        const body = await clone.json();
-
-        // body.settings.useIceConnection = true;
-
-        const newRequest = new Request(request, {
-            body: JSON.stringify(body),
-        });
-
-        return NATIVE_FETCH(newRequest);
-    }
-
-    static async handle(request: Request) {
-        TouchController.disable();
-
-        const clone = request.clone();
-
-        const headers: {[index: string]: string} = {};
-        for (const pair of (clone.headers as any).entries()) {
-            headers[pair[0]] = pair[1];
-        }
-        // Add xHome token to headers
-        headers.authorization = `Bearer ${RemotePlay.XHOME_TOKEN}`;
-
-        // Patch resolution
-        const deviceInfo = RemotePlay.BASE_DEVICE_INFO;
-        if (getPref(PrefKey.REMOTE_PLAY_RESOLUTION) === '720p') {
-            deviceInfo.dev.os.name = 'android';
-        }
-
-        headers['x-ms-device-info'] = JSON.stringify(deviceInfo);
-
-        const opts: {[index: string]: any} = {
-            method: clone.method,
-            headers: headers,
-        };
-
-        if (clone.method === 'POST') {
-            opts.body = await clone.text();
-        }
-
-        let newUrl = request.url;
-        if (!newUrl.includes('/servers/home')) {
-            const index = request.url.indexOf('.xboxlive.com');
-            newUrl = STATES.remotePlay.server + request.url.substring(index + 13);
-        }
-
-        request = new Request(newUrl, opts);
-        let url = (typeof request === 'string') ? request : request.url;
-
-        // Get console IP
-        if (url.includes('/configuration')) {
-            return XhomeInterceptor.#handleConfiguration(request);
-        } else if (url.endsWith('/sessions/home/play')) {
-            return XhomeInterceptor.#handlePlay(request);
-        } else if (url.includes('inputconfigs')) {
-            return XhomeInterceptor.#handleInputConfigs(request, opts);
-        } else if (url.includes('/login/user')) {
-            return XhomeInterceptor.#handleLogin(request);
-        } else if (url.endsWith('/titles')) {
-            return XhomeInterceptor.#handleTitles(request);
-        } else if (url && url.endsWith('/ice') && url.includes('/sessions/') && (request as Request).method === 'GET') {
-            return patchIceCandidates(request, XhomeInterceptor.#consoleAddrs);
-        }
-
-        return await NATIVE_FETCH(request);
-    }
-}
-
-
-class XcloudInterceptor {
-    static async #handleLogin(request: RequestInfo | URL, init?: RequestInit) {
-        const response = await NATIVE_FETCH(request, init);
-        const obj = await response.clone().json();
-
-        // Preload Remote Play
-        getPref(PrefKey.REMOTE_PLAY_ENABLED) && BX_FLAGS.PreloadRemotePlay && RemotePlay.preload();
-
-        // Store xCloud token
-        RemotePlay.XCLOUD_TOKEN = obj.gsToken;
-
-        // Get server list
-        const serverEmojis = {
-            AustraliaEast: '🇦🇺',
-            AustraliaSouthEast: '🇦🇺',
-            BrazilSouth: '🇧🇷',
-            EastUS: '🇺🇸',
-            EastUS2: '🇺🇸',
-            JapanEast: '🇯🇵',
-            KoreaCentral: '🇰🇷',
-            MexicoCentral: '🇲🇽',
-            NorthCentralUs: '🇺🇸',
-            SouthCentralUS: '🇺🇸',
-            UKSouth: '🇬🇧',
-            WestEurope: '🇪🇺',
-            WestUS: '🇺🇸',
-            WestUS2: '🇺🇸',
-        };
-
-        const serverRegex = /\/\/(\w+)\./;
-
-        for (let region of obj.offeringSettings.regions) {
-            const regionName = region.name as keyof typeof serverEmojis;
-            let shortName = region.name;
-
-            let match = serverRegex.exec(region.baseUri);
-            if (match) {
-                shortName = match[1];
-                if (serverEmojis[regionName]) {
-                    shortName = serverEmojis[regionName] + ' ' + shortName;
-                }
-            }
-
-            region.shortName = shortName.toUpperCase();
-            STATES.serverRegions[region.name] = Object.assign({}, region);
-        }
-
-        BxEvent.dispatch(window, BxEvent.XCLOUD_SERVERS_READY);
-
-        const preferredRegion = getPreferredServerRegion();
-        if (preferredRegion in STATES.serverRegions) {
-            const tmp = Object.assign({}, STATES.serverRegions[preferredRegion]);
-            tmp.isDefault = true;
-
-            obj.offeringSettings.regions = [tmp];
-        }
-
-        response.json = () => Promise.resolve(obj);
-        return response;
-    }
-
-    static async #handlePlay(request: RequestInfo | URL, init?: RequestInit) {
-        const PREF_STREAM_TARGET_RESOLUTION = getPref(PrefKey.STREAM_TARGET_RESOLUTION);
-        const PREF_STREAM_PREFERRED_LOCALE = getPref(PrefKey.STREAM_PREFERRED_LOCALE);
-
-        const url = (typeof request === 'string') ? request : (request as Request).url;
-        const parsedUrl = new URL(url);
-
-        let badgeRegion: string = parsedUrl.host.split('.', 1)[0];
-        for (let regionName in STATES.serverRegions) {
-            const region = STATES.serverRegions[regionName];
-            if (parsedUrl.origin == region.baseUri) {
-                badgeRegion = regionName;
-                break;
-            }
-        }
-        StreamBadges.getInstance().setRegion(badgeRegion);
-
-        const clone = (request as Request).clone();
-        const body = await clone.json();
-
-        // Force stream's resolution
-        if (PREF_STREAM_TARGET_RESOLUTION !== 'auto') {
-            const osName = (PREF_STREAM_TARGET_RESOLUTION === '720p') ? 'android' : 'windows';
-            body.settings.osName = osName;
-        }
-
-        // Override "locale" value
-        if (PREF_STREAM_PREFERRED_LOCALE !== 'default') {
-            body.settings.locale = PREF_STREAM_PREFERRED_LOCALE;
-        }
-
-        const newRequest = new Request(request, {
-            body: JSON.stringify(body),
-        });
-
-        return NATIVE_FETCH(newRequest);
-    }
-
-    static async #handleWaitTime(request: RequestInfo | URL, init?: RequestInit) {
-        const response = await NATIVE_FETCH(request, init);
-
-        if (getPref(PrefKey.UI_LOADING_SCREEN_WAIT_TIME)) {
-            const json = await response.clone().json();
-            if (json.estimatedAllocationTimeInSeconds > 0) {
-                // Setup wait time overlay
-                LoadingScreen.setupWaitTime(json.estimatedTotalWaitTimeInSeconds);
-            }
-        }
-
-        return response;
-    }
-
-    static async #handleConfiguration(request: RequestInfo | URL, init?: RequestInit) {
-        if ((request as Request).method !== 'GET') {
-            return NATIVE_FETCH(request, init);
-        }
-
-        // Touch controller for all games
-        if (getPref(PrefKey.STREAM_TOUCH_CONTROLLER) === 'all') {
-            const titleInfo = STATES.currentStream.titleInfo;
-            if (titleInfo?.details.hasTouchSupport) {
-                TouchController.disable();
-            } else {
-                TouchController.enable();
-            }
-        }
-
-        // Intercept configurations
-        const response = await NATIVE_FETCH(request, init);
-        const text = await response.clone().text();
-        if (!text.length) {
-            return response;
-        }
-
-        const obj = JSON.parse(text);
-        let overrides = JSON.parse(obj.clientStreamingConfigOverrides || '{}') || {};
-
-        overrides.inputConfiguration = overrides.inputConfiguration || {};
-        overrides.inputConfiguration.enableVibration = true;
-
-        let overrideMkb: boolean | null = null;
-
-        if (getPref(PrefKey.NATIVE_MKB_ENABLED) === 'on' || (STATES.currentStream.titleInfo && BX_FLAGS.ForceNativeMkbTitles?.includes(STATES.currentStream.titleInfo.details.productId))) {
-            overrideMkb = true;
-        }
-
-        if (getPref(PrefKey.NATIVE_MKB_ENABLED) === 'off') {
-            overrideMkb = false;
-        }
-
-        if (overrideMkb !== null) {
-            overrides.inputConfiguration = Object.assign(overrides.inputConfiguration, {
-                enableMouseInput: overrideMkb,
-                enableKeyboardInput: overrideMkb,
-            });
-        }
-
-        // Enable touch controller
-        if (TouchController.isEnabled()) {
-            overrides.inputConfiguration.enableTouchInput = true;
-            overrides.inputConfiguration.maxTouchPoints = 10;
-        }
-
-        // Enable mic
-        if (getPref(PrefKey.AUDIO_MIC_ON_PLAYING)) {
-            overrides.audioConfiguration = overrides.audioConfiguration || {};
-            overrides.audioConfiguration.enableMicrophone = true;
-        }
-
-        obj.clientStreamingConfigOverrides = JSON.stringify(overrides);
-
-        response.json = () => Promise.resolve(obj);
-        response.text = () => Promise.resolve(JSON.stringify(obj));
-
-        return response;
-    }
-
-    static async handle(request: RequestInfo | URL, init?: RequestInit) {
-        let url = (typeof request === 'string') ? request : (request as Request).url;
-
-        // Server list
-        if (url.endsWith('/v2/login/user')) {
-            return XcloudInterceptor.#handleLogin(request, init);
-        } else if (url.endsWith('/sessions/cloud/play')) {  // Get session
-            return XcloudInterceptor.#handlePlay(request, init);
-        } else if (url.includes('xboxlive.com') && url.includes('/waittime/')) {
-            return XcloudInterceptor.#handleWaitTime(request, init);
-        } else if (url.endsWith('/configuration')) {
-            return XcloudInterceptor.#handleConfiguration(request, init);
-        } else if (url && url.endsWith('/ice') && url.includes('/sessions/') && (request as Request).method === 'GET') {
-            return patchIceCandidates(request as Request);
-        }
-
-        return NATIVE_FETCH(request, init);
-    }
-}
-
-
 export function interceptHttpRequests() {
     let BLOCKED_URLS: string[] = [];
     if (getPref(PrefKey.BLOCK_TRACKING)) {

src/utils/preferences.ts

@@ -1,5 +1,5 @@
 import { CE } from "@utils/html";
-import { SUPPORTED_LANGUAGES, t } from "@utils/translation";
+import { SUPPORTED_LANGUAGES, t} from "@utils/translation";
 import { SettingElement, SettingElementType } from "@utils/settings";
 import { UserAgent } from "@utils/user-agent";
 import { StreamStat } from "@modules/stream/stream-stats";
@@ -8,6 +8,7 @@ import { AppInterface, STATES } from "@utils/global";
 import { StreamPlayerType, StreamVideoProcessing } from "@enums/stream-player";
 import { UserAgentProfile } from "@/enums/user-agent";
 import { UiSection } from "@/enums/ui-sections";
+import { BypassServers } from "@/enums/bypass-servers";
 
 export enum PrefKey {
     LAST_UPDATE_CHECK = 'version_last_check',
@@ -17,6 +18,8 @@ export enum PrefKey {
     BETTER_XCLOUD_LOCALE = 'bx_locale',
 
     SERVER_REGION = 'server_region',
+    SERVER_BYPASS_RESTRICTION = 'server_bypass_restriction',
+
     PREFER_IPV6_SERVER = 'prefer_ipv6_server',
     STREAM_TARGET_RESOLUTION = 'stream_target_resolution',
     STREAM_PREFERRED_LOCALE = 'stream_preferred_locale',
@@ -69,11 +72,13 @@ export enum PrefKey {
     UI_LOADING_SCREEN_WAIT_TIME = 'ui_loading_screen_wait_time',
     UI_LOADING_SCREEN_ROCKET = 'ui_loading_screen_rocket',
 
+    UI_CONTROLLER_FRIENDLY = 'ui_controller_friendly',
     UI_LAYOUT = 'ui_layout',
     UI_SCROLLBAR_HIDE = 'ui_scrollbar_hide',
     UI_HIDE_SECTIONS = 'ui_hide_sections',
 
     UI_HOME_CONTEXT_MENU_DISABLED = 'ui_home_context_menu_disabled',
+    UI_GAME_CARD_SHOW_WAIT_TIME = 'ui_game_card_show_wait_time',
 
     VIDEO_PLAYER_TYPE = 'video_player_type',
     VIDEO_PROCESSING = 'video_processing',
@@ -122,6 +127,16 @@ export class Preferences {
             label: t('region'),
             default: 'default',
         },
+        [PrefKey.SERVER_BYPASS_RESTRICTION]: {
+            label: t('bypass-region-restriction'),
+            note: '⚠️ ' + t('use-this-at-your-own-risk'),
+            default: 'off',
+            optionsGroup: t('region'),
+            options: Object.assign({
+                'off': t('off'),
+            }, BypassServers),
+        },
+
         [PrefKey.STREAM_PREFERRED_LOCALE]: {
             label: t('preferred-game-language'),
             default: 'default',
@@ -539,6 +554,12 @@ export class Preferences {
                 hide: t('rocket-always-hide'),
             },
         },
+
+        [PrefKey.UI_CONTROLLER_FRIENDLY]: {
+            label: t('controller-friendly-ui'),
+            default: false,
+        },
+
         [PrefKey.UI_LAYOUT]: {
             label: t('layout'),
             default: 'default',
@@ -573,6 +594,11 @@ export class Preferences {
             },
         },
 
+        [PrefKey.UI_GAME_CARD_SHOW_WAIT_TIME]: {
+            label: t('show-wait-time-in-game-card'),
+            default: false,
+        },
+
         [PrefKey.BLOCK_SOCIAL_FEATURES]: {
             label: t('disable-social-features'),
             default: false,
@@ -589,8 +615,8 @@ export class Preferences {
                 [UserAgentProfile.DEFAULT]: t('default'),
                 [UserAgentProfile.WINDOWS_EDGE]: 'Edge + Windows',
                 [UserAgentProfile.MACOS_SAFARI]: 'Safari + macOS',
-                [UserAgentProfile.SMARTTV_GENERIC]: 'Smart TV',
-                [UserAgentProfile.SMARTTV_TIZEN]: 'Samsung Smart TV',
+                [UserAgentProfile.SMART_TV_GENERIC]: 'Smart TV',
+                [UserAgentProfile.SMART_TV_TIZEN]: 'Samsung Smart TV',
                 [UserAgentProfile.VR_OCULUS]: 'Meta Quest VR',
                 [UserAgentProfile.CUSTOM]: t('custom'),
             },
@@ -618,7 +644,7 @@ export class Preferences {
             min: 0,
             max: 10,
             params: {
-                hideSlider: true,
+                exactTicks: 2,
                 customTextValue: (value: any) => {
                     value = parseInt(value);
                     return value === 0 ? t('off') : value.toString();
@@ -688,6 +714,7 @@ export class Preferences {
             default: 100,
             min: 0,
             max: 600,
+            steps: 20,
             params: {
                 suffix: '%',
                 ticks: 100,
@@ -746,6 +773,7 @@ export class Preferences {
             default: 80,
             min: 50,
             max: 100,
+            steps: 10,
             params: {
                 suffix: '%',
                 ticks: 10,

src/utils/settings.ts

@@ -30,11 +30,20 @@ export class SettingElement {
                 // title: setting.label,
                 tabindex: 0,
             }) as HTMLSelectElement;
+
+        let $parent: HTMLElement;
+        if (setting.optionsGroup) {
+            $parent = CE('optgroup', {'label': setting.optionsGroup});
+            $control.appendChild($parent);
+        } else {
+            $parent = $control;
+        }
+
         for (let value in setting.options) {
             const label = setting.options[value];
 
             const $option = CE<HTMLOptionElement>('option', {value: value}, label);
-            $control.appendChild($option);
+            $parent.appendChild($option);
         }
 
         $control.value = currentValue;
@@ -158,21 +167,23 @@ export class SettingElement {
         };
 
         const updateButtonsVisibility = () => {
-            $btnDec.classList.toggle('bx-hidden', controlValue === MIN);
-            $btnInc.classList.toggle('bx-hidden', controlValue === MAX);
+            $btnDec.classList.toggle('bx-inactive', controlValue === MIN);
+            $btnInc.classList.toggle('bx-inactive', controlValue === MAX);
         }
 
         const $wrapper = CE('div', {'class': 'bx-number-stepper', id: `bx_setting_${key}`},
                 $btnDec = CE('button', {
                         'data-type': 'dec',
                         type: 'button',
-                        tabindex: -1,
+                        class: options.hideSlider ? 'bx-focusable' : '',
+                        tabindex: options.hideSlider ? 0 : -1,
                     }, '-') as HTMLButtonElement,
                 $text = CE('span', {}, renderTextValue(value)) as HTMLSpanElement,
                 $btnInc = CE('button', {
                         'data-type': 'inc',
                         type: 'button',
-                        tabindex: -1,
+                        class: options.hideSlider ? 'bx-focusable' : '',
+                        tabindex: options.hideSlider ? 0 : -1,
                     }, '+') as HTMLButtonElement,
             );
 
@@ -189,10 +200,16 @@ export class SettingElement {
 
             $range.addEventListener('input', e => {
                 value = parseInt((e.target as HTMLInputElement).value);
+                const valueChanged = controlValue !== value;
+
+                if (!valueChanged) {
+                    return;
+                }
+
                 controlValue = value;
                 updateButtonsVisibility();
-
                 $text.textContent = renderTextValue(value);
+
                 !(e as any).ignoreOnChange && onChange && onChange(e, value);
             });
             $wrapper.appendChild($range);
@@ -223,10 +240,10 @@ export class SettingElement {
 
         if (options.disabled) {
             $btnInc.disabled = true;
-            $btnInc.classList.add('bx-hidden');
+            $btnInc.classList.add('bx-inactive');
 
             $btnDec.disabled = true;
-            $btnDec.classList.add('bx-hidden');
+            $btnDec.classList.add('bx-inactive');
             return $wrapper;
         }
 

src/utils/translation.ts

@@ -20,6 +20,7 @@ export const SUPPORTED_LANGUAGES = {
     'uk-UA': 'українська',
     'vi-VN': 'Tiếng Việt',
     'zh-CN': '中文(简体)',
+    'zh-TW': '中文(繁體)',
 };
 
 const Texts = {
@@ -51,6 +52,7 @@ const Texts = {
     "bottom-right": "Bottom-right",
     "brightness": "Brightness",
     "browser-unsupported-feature": "Your browser doesn't support this feature",
+    "bypass-region-restriction": "Bypass region restriction",
     "can-stream-xbox-360-games": "Can stream Xbox 360 games",
     "cancel": "Cancel",
     "cant-stream-xbox-360-games": "Can't stream Xbox 360 games",
@@ -68,6 +70,7 @@ const Texts = {
     "console-connect": "Connect",
     "contrast": "Contrast",
     "controller": "Controller",
+    "controller-friendly-ui": "Controller-friendly UI",
     "controller-shortcuts": "Controller shortcuts",
     "controller-shortcuts-connect-note": "Connect a controller to use this feature",
     "controller-shortcuts-xbox-note": "Button to open the Guide menu",
@@ -172,12 +175,13 @@ const Texts = {
         (e: any) => `Натисніть ${e.key} щоб перемкнути цю функцію`,
         (e: any) => `Nhấn ${e.key} để bật/tắt tính năng này`,
         (e: any) => `按下 ${e.key} 来切换此功能`,
+        (e: any) => `按下 ${e.key} 來啟用此功能`,
     ],
     "press-to-bind": "Press a key or do a mouse click to bind...",
     "prompt-preset-name": "Preset's name:",
     "reduce-animations": "Reduce UI animations",
     "region": "Region",
-    "reload-stream": "Reload stream",
+    "reload-page": "Reload page",
     "remote-play": "Remote Play",
     "rename": "Rename",
     "renderer": "Renderer",
@@ -211,6 +215,7 @@ const Texts = {
     "show-stats-on-startup": "Show stats when starting the game",
     "show-touch-controller": "Show touch controller",
     "show-wait-time": "Show the estimated wait time",
+    "show-wait-time-in-game-card": "Show wait time in game card",
     "simplify-stream-menu": "Simplify Stream's menu",
     "skip-splash-video": "Skip Xbox splash video",
     "slow": "Slow",
@@ -267,6 +272,7 @@ const Texts = {
         (e: any) => `Розташування сенсорного керування від ${e.name}`,
         (e: any) => `Bố cục điều khiển cảm ứng tạo bởi ${e.name}`,
         (e: any) => `由 ${e.name} 提供的虚拟按键样式`,
+        (e: any) => `觸控遊玩佈局由 ${e.name} 提供`,
     ],
     "touch-controller": "Touch controller",
     "transparent-background": "Transparent background",
@@ -277,6 +283,7 @@ const Texts = {
     "unmuted": "Unmuted",
     "unsharp-masking": "Unsharp masking",
     "use-mouse-absolute-position": "Use mouse's absolute position",
+    "use-this-at-your-own-risk": "Use this at your own risk",
     "user-agent-profile": "User-Agent profile",
     "vertical-scroll-sensitivity": "Vertical scroll sensitivity",
     "vertical-sensitivity": "Vertical sensitivity",
@@ -368,6 +375,7 @@ export class Translations {
     static async updateTranslations(async=false) {
         // Don't have to download en-US
         if (Translations.#selectedLocale === Translations.#EN_US) {
+            localStorage.removeItem(Translations.#KEY_TRANSLATIONS);
             return;
         }
 

src/utils/user-agent.ts

@@ -29,8 +29,8 @@ export class UserAgent {
     static #USER_AGENTS: PartialRecord<UserAgentProfile, string> = {
         [UserAgentProfile.WINDOWS_EDGE]: `Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/${CHROMIUM_VERSION} Safari/537.36 Edg/${CHROMIUM_VERSION}`,
         [UserAgentProfile.MACOS_SAFARI]: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.5.2 Safari/605.1.1',
-        [UserAgentProfile.SMARTTV_GENERIC]: `${window.navigator.userAgent} SmartTV ${SMART_TV_UNIQUE_ID}`,
-        [UserAgentProfile.SMARTTV_TIZEN]: `Mozilla/5.0 (SMART-TV; LINUX; Tizen 7.0) AppleWebKit/537.36 (KHTML, like Gecko) ${CHROMIUM_VERSION}/7.0 TV Safari/537.36 ${SMART_TV_UNIQUE_ID}`,
+        [UserAgentProfile.SMART_TV_GENERIC]: `${window.navigator.userAgent} SmartTV`,
+        [UserAgentProfile.SMART_TV_TIZEN]: `Mozilla/5.0 (SMART-TV; LINUX; Tizen 7.0) AppleWebKit/537.36 (KHTML, like Gecko) ${CHROMIUM_VERSION}/7.0 TV Safari/537.36 ${SMART_TV_UNIQUE_ID}`,
         [UserAgentProfile.VR_OCULUS]: window.navigator.userAgent + ' OculusBrowser VR',
     }
 

src/utils/xcloud-api.ts

@@ -0,0 +1,79 @@
+import { NATIVE_FETCH } from "./bx-flags";
+import { STATES } from "./global";
+
+export class XcloudApi {
+    private static instance: XcloudApi;
+
+    public static getInstance(): XcloudApi {
+        if (!XcloudApi.instance) {
+            XcloudApi.instance = new XcloudApi();
+        }
+
+        return XcloudApi.instance;
+    }
+
+    #CACHE_TITLES: {[key: string]: XcloudTitleInfo} = {};
+    #CACHE_WAIT_TIME: {[key: string]: XcloudWaitTimeInfo} = {};
+
+    async getTitleInfo(id: string): Promise<XcloudTitleInfo | null> {
+        if (id in this.#CACHE_TITLES) {
+            return this.#CACHE_TITLES[id];
+        }
+
+        const baseUri = STATES.selectedRegion.baseUri;
+        if (!baseUri || !STATES.gsToken) {
+            return null;
+        }
+
+        let json;
+        try {
+            const response = await NATIVE_FETCH(`${baseUri}/v2/titles`, {
+                method: 'POST',
+                headers: {
+                    'Authorization': `Bearer ${STATES.gsToken}`,
+                    'Content-Type': 'application/json',
+                },
+
+                // format the data
+                body: JSON.stringify({
+                    alternateIds: [id],
+                    alternateIdType: 'productId',
+                }),
+            });
+
+            json = (await response.json()).results[0];
+        } catch (e) {
+            json = {}
+        }
+        this.#CACHE_TITLES[id] = json;
+        return json;
+    }
+
+    async getWaitTime(id: string): Promise<XcloudWaitTimeInfo | null> {
+        if (id in this.#CACHE_WAIT_TIME) {
+            return this.#CACHE_WAIT_TIME[id];
+        }
+
+        const baseUri = STATES.selectedRegion.baseUri;
+        if (!baseUri || !STATES.gsToken) {
+            return null;
+        }
+
+        let json;
+        try {
+            const response = await NATIVE_FETCH(`${baseUri}/v1/waittime/${id}`, {
+                method: 'GET',
+                headers: {
+                    'Authorization': `Bearer ${STATES.gsToken}`,
+                },
+            });
+
+            json = await response.json();
+        } catch (e) {
+            json = {};
+        }
+
+        this.#CACHE_WAIT_TIME[id] = json;
+        return json;
+    }
+}

src/utils/xcloud-interceptor.ts

@@ -0,0 +1,226 @@
+import { LoadingScreen } from "@modules/loading-screen";
+import { RemotePlay } from "@modules/remote-play";
+import { StreamBadges } from "@modules/stream/stream-badges";
+import { TouchController } from "@modules/touch-controller";
+import { BxEvent } from "./bx-event";
+import { NATIVE_FETCH, BX_FLAGS } from "./bx-flags";
+import { STATES } from "./global";
+import { patchIceCandidates } from "./network";
+import { getPref, PrefKey } from "./preferences";
+import { getPreferredServerRegion } from "./region";
+import { BypassServerIps } from "@/enums/bypass-servers";
+
+export
+class XcloudInterceptor {
+    static async #handleLogin(request: RequestInfo | URL, init?: RequestInit) {
+        const bypassServer = getPref(PrefKey.SERVER_BYPASS_RESTRICTION);
+        if (bypassServer !== 'off') {
+            const ip = BypassServerIps[bypassServer as keyof typeof BypassServerIps];
+            ip && (request as Request).headers.set('X-Forwarded-For', ip);
+        }
+
+        const response = await NATIVE_FETCH(request, init);
+        if (response.status !== 200) {
+            // Unsupported region
+            BxEvent.dispatch(window, BxEvent.XCLOUD_SERVERS_UNAVAILABLE);
+            return response;
+        }
+
+        const obj = await response.clone().json();
+
+        // Store xCloud token
+        RemotePlay.XCLOUD_TOKEN = obj.gsToken;
+
+        // Get server list
+        const serverEmojis = {
+            AustraliaEast: '🇦🇺',
+            AustraliaSouthEast: '🇦🇺',
+            BrazilSouth: '🇧🇷',
+            EastUS: '🇺🇸',
+            EastUS2: '🇺🇸',
+            JapanEast: '🇯🇵',
+            KoreaCentral: '🇰🇷',
+            MexicoCentral: '🇲🇽',
+            NorthCentralUs: '🇺🇸',
+            SouthCentralUS: '🇺🇸',
+            UKSouth: '🇬🇧',
+            WestEurope: '🇪🇺',
+            WestUS: '🇺🇸',
+            WestUS2: '🇺🇸',
+        };
+
+        const serverRegex = /\/\/(\w+)\./;
+
+        for (let region of obj.offeringSettings.regions) {
+            const regionName = region.name as keyof typeof serverEmojis;
+            let shortName = region.name;
+
+            if (region.isDefault) {
+                STATES.selectedRegion = Object.assign({}, region);
+            }
+
+            let match = serverRegex.exec(region.baseUri);
+            if (match) {
+                shortName = match[1];
+                if (serverEmojis[regionName]) {
+                    shortName = serverEmojis[regionName] + ' ' + shortName;
+                }
+            }
+
+            region.shortName = shortName.toUpperCase();
+            STATES.serverRegions[region.name] = Object.assign({}, region);
+        }
+
+        BxEvent.dispatch(window, BxEvent.XCLOUD_SERVERS_READY);
+
+        const preferredRegion = getPreferredServerRegion();
+        if (preferredRegion in STATES.serverRegions) {
+            const tmp = Object.assign({}, STATES.serverRegions[preferredRegion]);
+            tmp.isDefault = true;
+
+            obj.offeringSettings.regions = [tmp];
+            STATES.selectedRegion = tmp;
+        }
+
+        STATES.gsToken = obj.gsToken;
+
+        response.json = () => Promise.resolve(obj);
+        return response;
+    }
+
+    static async #handlePlay(request: RequestInfo | URL, init?: RequestInit) {
+        const PREF_STREAM_TARGET_RESOLUTION = getPref(PrefKey.STREAM_TARGET_RESOLUTION);
+        const PREF_STREAM_PREFERRED_LOCALE = getPref(PrefKey.STREAM_PREFERRED_LOCALE);
+
+        const url = (typeof request === 'string') ? request : (request as Request).url;
+        const parsedUrl = new URL(url);
+
+        let badgeRegion: string = parsedUrl.host.split('.', 1)[0];
+        for (let regionName in STATES.serverRegions) {
+            const region = STATES.serverRegions[regionName];
+            if (parsedUrl.origin == region.baseUri) {
+                badgeRegion = regionName;
+                break;
+            }
+        }
+        StreamBadges.getInstance().setRegion(badgeRegion);
+
+        const clone = (request as Request).clone();
+        const body = await clone.json();
+
+        // Force stream's resolution
+        if (PREF_STREAM_TARGET_RESOLUTION !== 'auto') {
+            const osName = (PREF_STREAM_TARGET_RESOLUTION === '720p') ? 'android' : 'windows';
+            body.settings.osName = osName;
+        }
+
+        // Override "locale" value
+        if (PREF_STREAM_PREFERRED_LOCALE !== 'default') {
+            body.settings.locale = PREF_STREAM_PREFERRED_LOCALE;
+        }
+
+        const newRequest = new Request(request, {
+            body: JSON.stringify(body),
+        });
+
+        return NATIVE_FETCH(newRequest);
+    }
+
+    static async #handleWaitTime(request: RequestInfo | URL, init?: RequestInit) {
+        const response = await NATIVE_FETCH(request, init);
+
+        if (getPref(PrefKey.UI_LOADING_SCREEN_WAIT_TIME)) {
+            const json = await response.clone().json();
+            if (json.estimatedAllocationTimeInSeconds > 0) {
+                // Setup wait time overlay
+                LoadingScreen.setupWaitTime(json.estimatedTotalWaitTimeInSeconds);
+            }
+        }
+
+        return response;
+    }
+
+    static async #handleConfiguration(request: RequestInfo | URL, init?: RequestInit) {
+        if ((request as Request).method !== 'GET') {
+            return NATIVE_FETCH(request, init);
+        }
+
+        // Touch controller for all games
+        if (getPref(PrefKey.STREAM_TOUCH_CONTROLLER) === 'all') {
+            const titleInfo = STATES.currentStream.titleInfo;
+            if (titleInfo?.details.hasTouchSupport) {
+                TouchController.disable();
+            } else {
+                TouchController.enable();
+            }
+        }
+
+        // Intercept configurations
+        const response = await NATIVE_FETCH(request, init);
+        const text = await response.clone().text();
+        if (!text.length) {
+            return response;
+        }
+
+        const obj = JSON.parse(text);
+        let overrides = JSON.parse(obj.clientStreamingConfigOverrides || '{}') || {};
+
+        overrides.inputConfiguration = overrides.inputConfiguration || {};
+        overrides.inputConfiguration.enableVibration = true;
+
+        let overrideMkb: boolean | null = null;
+
+        if (getPref(PrefKey.NATIVE_MKB_ENABLED) === 'on' || (STATES.currentStream.titleInfo && BX_FLAGS.ForceNativeMkbTitles?.includes(STATES.currentStream.titleInfo.details.productId))) {
+            overrideMkb = true;
+        }
+
+        if (getPref(PrefKey.NATIVE_MKB_ENABLED) === 'off') {
+            overrideMkb = false;
+        }
+
+        if (overrideMkb !== null) {
+            overrides.inputConfiguration = Object.assign(overrides.inputConfiguration, {
+                enableMouseInput: overrideMkb,
+                enableKeyboardInput: overrideMkb,
+            });
+        }
+
+        // Enable touch controller
+        if (TouchController.isEnabled()) {
+            overrides.inputConfiguration.enableTouchInput = true;
+            overrides.inputConfiguration.maxTouchPoints = 10;
+        }
+
+        // Enable mic
+        if (getPref(PrefKey.AUDIO_MIC_ON_PLAYING)) {
+            overrides.audioConfiguration = overrides.audioConfiguration || {};
+            overrides.audioConfiguration.enableMicrophone = true;
+        }
+
+        obj.clientStreamingConfigOverrides = JSON.stringify(overrides);
+
+        response.json = () => Promise.resolve(obj);
+        response.text = () => Promise.resolve(JSON.stringify(obj));
+
+        return response;
+    }
+
+    static async handle(request: RequestInfo | URL, init?: RequestInit) {
+        let url = (typeof request === 'string') ? request : (request as Request).url;
+
+        // Server list
+        if (url.endsWith('/v2/login/user')) {
+            return XcloudInterceptor.#handleLogin(request, init);
+        } else if (url.endsWith('/sessions/cloud/play')) {  // Get session
+            return XcloudInterceptor.#handlePlay(request, init);
+        } else if (url.includes('xboxlive.com') && url.includes('/waittime/')) {
+            return XcloudInterceptor.#handleWaitTime(request, init);
+        } else if (url.endsWith('/configuration')) {
+            return XcloudInterceptor.#handleConfiguration(request, init);
+        } else if (url && url.endsWith('/ice') && url.includes('/sessions/') && (request as Request).method === 'GET') {
+            return patchIceCandidates(request as Request);
+        }
+
+        return NATIVE_FETCH(request, init);
+    }
+}

src/utils/xhome-interceptor.ts

@@ -0,0 +1,184 @@
+import { RemotePlay } from "@/modules/remote-play";
+import { TouchController } from "@/modules/touch-controller";
+import { BxEvent } from "./bx-event";
+import { InputType } from "./bx-exposed";
+import { NATIVE_FETCH } from "./bx-flags";
+import { STATES } from "./global";
+import { getPref, PrefKey } from "./preferences";
+import { patchIceCandidates } from "./network";
+
+export class XhomeInterceptor {
+    static #consoleAddrs: {[index: string]: number} = {};
+
+    static async #handleLogin(request: Request) {
+        try {
+            const clone = (request as Request).clone();
+
+            const obj = await clone.json();
+            obj.offeringId = 'xhome';
+
+            request = new Request('https://xhome.gssv-play-prod.xboxlive.com/v2/login/user', {
+                method: 'POST',
+                body: JSON.stringify(obj),
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
+        } catch (e) {
+            alert(e);
+            console.log(e);
+        }
+
+        return NATIVE_FETCH(request);
+    }
+
+    static async #handleConfiguration(request: Request | URL) {
+        const response = await NATIVE_FETCH(request);
+
+        const obj = await response.clone().json()
+        console.log(obj);
+
+        const serverDetails = obj.serverDetails;
+        if (serverDetails.ipAddress) {
+            XhomeInterceptor.#consoleAddrs[serverDetails.ipAddress] = serverDetails.port;
+        }
+
+        if (serverDetails.ipV4Address) {
+            XhomeInterceptor.#consoleAddrs[serverDetails.ipV4Address] = serverDetails.ipV4Port;
+        }
+
+        if (serverDetails.ipV6Address) {
+            XhomeInterceptor.#consoleAddrs[serverDetails.ipV6Address] = serverDetails.ipV6Port;
+        }
+
+        response.json = () => Promise.resolve(obj);
+        response.text = () => Promise.resolve(JSON.stringify(obj));
+
+        return response;
+    }
+
+    static async #handleInputConfigs(request: Request | URL, opts: {[index: string]: any}) {
+        const response = await NATIVE_FETCH(request);
+
+        if (getPref(PrefKey.STREAM_TOUCH_CONTROLLER) !== 'all') {
+            return response;
+        }
+
+        const obj = await response.clone().json() as any;
+
+        const xboxTitleId = JSON.parse(opts.body).titleIds[0];
+        STATES.currentStream.xboxTitleId = xboxTitleId;
+
+        const inputConfigs = obj[0];
+
+        let hasTouchSupport = inputConfigs.supportedTabs.length > 0;
+        if (!hasTouchSupport) {
+            const supportedInputTypes = inputConfigs.supportedInputTypes;
+            hasTouchSupport = supportedInputTypes.includes(InputType.NATIVE_TOUCH) || supportedInputTypes.includes(InputType.CUSTOM_TOUCH_OVERLAY);
+        }
+
+        if (hasTouchSupport) {
+            TouchController.disable();
+
+            BxEvent.dispatch(window, BxEvent.CUSTOM_TOUCH_LAYOUTS_LOADED, {
+                data: null,
+            });
+        } else {
+            TouchController.enable();
+            TouchController.getCustomLayouts(xboxTitleId);
+        }
+
+        response.json = () => Promise.resolve(obj);
+        response.text = () => Promise.resolve(JSON.stringify(obj));
+
+        return response;
+    }
+
+    static async #handleTitles(request: Request) {
+        const clone = request.clone();
+
+        const headers: {[index: string]: any} = {};
+        for (const pair of (clone.headers as any).entries()) {
+            headers[pair[0]] = pair[1];
+        }
+        headers.authorization = `Bearer ${RemotePlay.XCLOUD_TOKEN}`;
+
+        const index = request.url.indexOf('.xboxlive.com');
+        request = new Request('https://wus.core.gssv-play-prod' + request.url.substring(index), {
+            method: clone.method,
+            body: await clone.text(),
+            headers: headers,
+        });
+
+        return NATIVE_FETCH(request);
+    }
+
+    static async #handlePlay(request: RequestInfo | URL) {
+        const clone = (request as Request).clone();
+        const body = await clone.json();
+
+        // body.settings.useIceConnection = true;
+
+        const newRequest = new Request(request, {
+            body: JSON.stringify(body),
+        });
+
+        return NATIVE_FETCH(newRequest);
+    }
+
+    static async handle(request: Request) {
+        TouchController.disable();
+
+        const clone = request.clone();
+
+        const headers: {[index: string]: string} = {};
+        for (const pair of (clone.headers as any).entries()) {
+            headers[pair[0]] = pair[1];
+        }
+        // Add xHome token to headers
+        headers.authorization = `Bearer ${RemotePlay.XHOME_TOKEN}`;
+
+        // Patch resolution
+        const deviceInfo = RemotePlay.BASE_DEVICE_INFO;
+        if (getPref(PrefKey.REMOTE_PLAY_RESOLUTION) === '720p') {
+            deviceInfo.dev.os.name = 'android';
+        }
+
+        headers['x-ms-device-info'] = JSON.stringify(deviceInfo);
+
+        const opts: {[index: string]: any} = {
+            method: clone.method,
+            headers: headers,
+        };
+
+        if (clone.method === 'POST') {
+            opts.body = await clone.text();
+        }
+
+        let newUrl = request.url;
+        if (!newUrl.includes('/servers/home')) {
+            const index = request.url.indexOf('.xboxlive.com');
+            newUrl = STATES.remotePlay.server + request.url.substring(index + 13);
+        }
+
+        request = new Request(newUrl, opts);
+        let url = (typeof request === 'string') ? request : request.url;
+
+        // Get console IP
+        if (url.includes('/configuration')) {
+            return XhomeInterceptor.#handleConfiguration(request);
+        } else if (url.endsWith('/sessions/home/play')) {
+            return XhomeInterceptor.#handlePlay(request);
+        } else if (url.includes('inputconfigs')) {
+            return XhomeInterceptor.#handleInputConfigs(request, opts);
+        } else if (url.includes('/login/user')) {
+            return XhomeInterceptor.#handleLogin(request);
+        } else if (url.endsWith('/titles')) {
+            return XhomeInterceptor.#handleTitles(request);
+        } else if (url && url.endsWith('/ice') && url.includes('/sessions/') && (request as Request).method === 'GET') {
+            return patchIceCandidates(request, XhomeInterceptor.#consoleAddrs);
+        }
+
+        return await NATIVE_FETCH(request);
+    }
+}

src/web-components/bx-select.ts

@@ -2,6 +2,9 @@ import { ButtonStyle, CE, createButton } from "@utils/html";
 
 export class BxSelectElement {
     static wrap($select: HTMLSelectElement) {
+        // Remove "tabindex" attribute from <select>
+        $select.removeAttribute('tabindex');
+
         const $btnPrev = createButton({
             label: '<',
             style: ButtonStyle.FOCUSABLE,
@@ -23,23 +26,36 @@ export class BxSelectElement {
         let $checkBox: HTMLInputElement;
         let $label: HTMLElement;
 
-        const $content = CE('div', {},
-            $checkBox = CE('input', {type: 'checkbox', id: $select.id + '_checkbox'}),
-            $label = CE('label', {for: $select.id + '_checkbox'}, ''),
-        );
+        let $content;
 
-        isMultiple && $checkBox.addEventListener('input', e => {
-            const $option = getOptionAtIndex(visibleIndex);
-            $option && ($option.selected = (e.target as HTMLInputElement).checked);
+        if (isMultiple) {
+            $content = CE('button', {
+                class: 'bx-select-value bx-focusable',
+                tabindex: 0,
+            },
+                $checkBox = CE('input', {type: 'checkbox'}),
+                $label = CE('span', {}, ''),
+            );
 
-            $select.dispatchEvent(new Event('input'));
-        });
+            $content.addEventListener('click', e => {
+                $checkBox.click();
+            });
 
-        // Only show checkbox in "multiple" <select>
-        $checkBox.classList.toggle('bx-gone', !isMultiple);
+            $checkBox.addEventListener('input', e => {
+                const $option = getOptionAtIndex(visibleIndex);
+                $option && ($option.selected = (e.target as HTMLInputElement).checked);
+
+                $select.dispatchEvent(new Event('input'));
+            });
+        } else {
+            $content = CE('div', {},
+                $label = CE('label', {for: $select.id + '_checkbox'}, ''),
+            );
+        }
 
         const getOptionAtIndex = (index: number): HTMLOptionElement | undefined => {
-            return $select.querySelector(`option:nth-of-type(${visibleIndex + 1})`) as HTMLOptionElement;
+            const options = Array.from($select.querySelectorAll('option'));
+            return options[index];
         }
 
         const render = () => {
@@ -51,22 +67,38 @@ export class BxSelectElement {
             let content = '';
             if ($option) {
                 content = $option.textContent || '';
+
+                if (content && $option.parentElement!.tagName === 'OPTGROUP') {
+                    $label.innerHTML = '';
+                    const fragment = document.createDocumentFragment();
+                    fragment.appendChild(CE('span', {}, ($option.parentElement as HTMLOptGroupElement).label));
+                    fragment.appendChild(document.createTextNode(content));
+
+                    $label.appendChild(fragment);
+                } else {
+                    $label.textContent = content;
+                }
+            } else {
+                $label.textContent = content;
             }
 
-            $label.textContent = content;
+            // Add line-through on disabled option
+            $label.classList.toggle('bx-line-through', $option && $option.disabled);
 
             // Hide checkbox when the selection is empty
-            isMultiple && ($checkBox.checked = $option?.selected || false);
-            $checkBox.classList.toggle('bx-gone', !isMultiple || !content);
+            if (isMultiple) {
+                $checkBox.checked = $option?.selected || false;
+                $checkBox.classList.toggle('bx-gone', !content);
+            }
 
             const disablePrev = visibleIndex <= 0;
             const disableNext = visibleIndex === $select.querySelectorAll('option').length - 1;
 
             $btnPrev.classList.toggle('bx-inactive', disablePrev);
-            disablePrev && $btnNext.focus();
+            // disablePrev && document.activeElement === $btnPrev && $btnNext.focus();
 
             $btnNext.classList.toggle('bx-inactive', disableNext);
-            disableNext && $btnPrev.focus();
+            // disableNext && document.activeElement === $btnNext &&$btnPrev.focus();
         }
 
         const normalizeIndex = (index: number): number => {
@@ -94,13 +126,16 @@ export class BxSelectElement {
 
         const observer = new MutationObserver((mutationList, observer) => {
             mutationList.forEach(mutation => {
-                mutation.type === 'childList' && render();
+                if (mutation.type === 'childList' || mutation.type === 'attributes') {
+                    render();
+                }
             });
         });
 
         observer.observe($select, {
             subtree: true,
             childList: true,
+            attributes: true,
         });
 
         render();