Experimental AVFoundation renderer

2026-10-13 03:53:59 +00:00 · 2018-07-17 22:57:15 -07:00
906 changed files with 191933 additions and 84746 deletions
@@ -1,55 +0,0 @@
---
-name: Bug report
-about: Follow the troubleshooting guide before reporting a bug
-
---
-**READ ME FIRST!**
-If you're here because something basic is not working (like gamepad input, video, or similar), it's probably something specific to your setup, so make sure you've gone through the Troubleshooting Guide first: https://github.com/moonlight-stream/moonlight-docs/wiki/Troubleshooting
-
-If you still have trouble with basic functionality after following the guide, join our Discord server where there are many other volunteers who can help (or direct you back here if it looks like a Moonlight bug after all). https://moonlight-stream.org/discord
-
-**Describe the bug**
-A clear and concise description of what the bug is.
-
-**Steps to reproduce**
-Any special steps that are required for the bug to appear.
-
-**Screenshots**
-If applicable, add screenshots to help explain your problem. If the issue is related to video glitching or poor quality, please include screenshots.
-
-**Affected games**
-List the games you've tried that exhibit the issue. To see if the issue is game-specific, try streaming Steam Big Picture with Moonlight and see if the issue persists there.
-
-**Other Moonlight clients**
- Does the issue occur when using Moonlight on iOS or Android?
-
-**Moonlight settings (please complete the following information)**
- Have any settings been adjusted from defaults?
- If so, which settings have been changed?
- Does the problem still occur after reverting settings back to default?
-
-**Gamepad-related issues (please complete if problem is gamepad-related)**
- Do you have any gamepads connected to your host PC directly?
- Does the problem still remain if you stream the desktop and use https://html5gamepad.com to test your gamepad?
-  - Instructions for streaming the desktop can be found here: https://github.com/moonlight-stream/moonlight-docs/wiki/Setup-Guide
-
-**Client PC details (please complete the following information)**
- - OS: [e.g. Windows 10 1809]
- - Moonlight Version: [e.g. v0.9.0]
- - GPU: [e.g. Intel HD Graphics 520]
- - Linux package type (if applicable): [e.g. Flatpak]
-
-**Server PC details (please complete the following information)**
- - OS: [e.g. Windows 10 1809]
- - Sunshine or GeForce Experience version: [e.g. Sunshine v0.21.0]
- - GPU: [e.g. AMD Radeon RX 7900 XT]
- - GPU driver: [e.g. 24.1.1]
-
-**Moonlight Logs (please attach)**
- On Windows, `Moonlight-###.log` files can be found in `%TEMP%`. Simply type that into the File Explorer path field to navigate there.
- On macOS, `Moonlight-###.log` files can be found in `/tmp`. In Finder, press Cmd+Shift+G, then type `/tmp` to navigate there.
- On Linux with the Flatpak, logs print to the terminal when running with the command: `flatpak run com.moonlight_stream.Moonlight`
- On Linux with the Snap, logs print to the terminal when running with the command: `moonlight`
-
-**Additional context**
-Anything else you think may be relevant to the issue
@@ -1 +0,0 @@
-blank_issues_enabled: false
@@ -1,17 +0,0 @@
---
-name: Feature request
-about: Suggest an idea for this project
-
---
-
-**Is your feature request related to a problem? Please describe.**
-A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
-
-**Describe the solution you'd like**
-A clear and concise description of what you want to happen.
-
-**Describe alternatives you've considered**
-A clear and concise description of any alternative solutions or features you've considered.
-
-**Additional context**
-Add any other context or screenshots about the feature request here.
@@ -1,4 +0,0 @@
-issuesOpened: >
-  If this is a question about Moonlight or you need help troubleshooting a streaming problem, please use the help channels on our [Discord server](https://moonlight-stream.org/discord) instead of GitHub issues. There are many more people available on Discord to help you and answer your questions.<br /><br />
-  This issue tracker should only be used for specific bugs or feature requests.<br /><br />
-  Thank you, and happy streaming!
@@ -1,9 +0,0 @@
-# Please see the documentation for all configuration options:
-# https://docs.github.com/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file
-
-version: 2
-updates:
-  - package-ecosystem: "gitsubmodule"
-    directory: "/"
-    schedule:
-      interval: "daily"
@@ -1,8 +0,0 @@
-# ProBot No Response (https://probot.github.io/apps/no-response/)
-
-daysUntilClose: 7
-responseRequiredLabel: 'need more info'
-closeComment: >
-  This issue has been automatically closed because there was no response to a
-  request for more information from the issue opener. Please leave a comment or
-  open a new issue if you have additional information related to this issue.
@@ -1,14 +0,0 @@
-# ProBot Stale (https://probot.github.io/apps/stale/)
-
-daysUntilStale: 90
-daysUntilClose: 7
-exemptLabels:
-  - accepted
-  - bug
-  - enhancement
-  - meta
-staleLabel: stale
-markComment: >
-  This issue has been automatically marked as stale because it has not had
-  recent activity. It will be closed if no further activity occurs.
-closeComment: false
@@ -1,166 +0,0 @@
---
-name: Build - Linux AppImage
-permissions:
-  contents: read
-
-on:
-  workflow_call:
-    inputs:
-      ci_version:
-        required: true
-        type: string
-
-jobs:
-  build:
-    env:
-      CI_VERSION: ${{ inputs.ci_version }}
-    runs-on: ubuntu-22.04
-
-    steps:
-      - name: Checkout Repository
-        uses: actions/checkout@v5
-        with:
-          submodules: 'recursive'
-          fetch-depth: 1
-
-      - name: Setup environment
-        run: |
-          wget -qO - https://packages.lunarg.com/lunarg-signing-key-pub.asc | sudo apt-key add -
-          sudo wget -qO /etc/apt/sources.list.d/lunarg-vulkan-1.4.313-jammy.list https://packages.lunarg.com/vulkan/1.4.313/lunarg-vulkan-1.4.313-jammy.list
-          sudo apt update
-          sudo apt install -y qt6-base-dev qt6-declarative-dev libqt6svg6-dev qml6-module-qtquick-controls qml6-module-qtquick-templates qml6-module-qtquick-layouts \
-            qml6-module-qtqml-workerscript qml6-module-qtquick-window qml6-module-qtquick python3-pip nasm libgbm-dev libdrm-dev libfreetype-dev libasound2-dev \
-            libdbus-1-dev libegl1-mesa-dev libgl1-mesa-dev libgles2-mesa-dev libglu1-mesa-dev libibus-1.0-dev libpulse-dev libudev-dev libx11-dev libxcursor-dev \
-            libxext-dev libxi-dev libxinerama-dev libxkbcommon-dev libxrandr-dev libxss-dev libxt-dev libxv-dev libxxf86vm-dev libxcb-dri3-dev libx11-xcb-dev \
-            libxfixes-dev libxtst-dev wayland-protocols libopus-dev libvdpau-dev libgl-dev libpipewire-0.3-dev liburing-dev vulkan-sdk cmake
-          sudo pip3 install meson
-          mkdir -p dep_root/{bin,include,lib}
-          echo "DEP_ROOT=$PWD/dep_root" >> "${GITHUB_ENV}"
-          echo "$PWD/dep_root/bin" >> "${GITHUB_PATH}"
-
-      - name: Checkout SDL3
-        uses: actions/checkout@v5
-        with:
-          repository: libsdl-org/SDL
-          ref: release-3.4.18
-          path: deps/SDL
-
-      - name: Build SDL3
-        working-directory: deps/SDL
-        run: |
-          cmake -DSDL_KMSDRM=OFF -DSDL_TEST_LIBRARY=OFF -DSDL_INSTALL_DOCS=OFF -DCMAKE_INTERPROCEDURAL_OPTIMIZATION=ON -S . -B build
-          cmake --build build -j
-          sudo cmake --install build
-
-      - name: Checkout sdl2-compat
-        uses: actions/checkout@v5
-        with:
-          repository: libsdl-org/sdl2-compat
-          ref: release-2.32.74
-          path: deps/sdl2-compat
-
-      - name: Build sdl2-compat
-        working-directory: deps/sdl2-compat
-        run: |
-          cmake -DSDL2COMPAT_TESTS=OFF -DCMAKE_INTERPROCEDURAL_OPTIMIZATION=ON -S . -B build
-          cmake --build build -j
-          sudo cmake --install build
-
-      - name: Checkout SDL_ttf
-        uses: actions/checkout@v5
-        with:
-          repository: libsdl-org/SDL_ttf
-          ref: a883e490e30fb44a5336ea3dcb990c6982c5216f
-          path: deps/SDL_ttf
-          submodules: 'recursive'
-
-      - name: Build SDL_ttf
-        working-directory: deps/SDL_ttf
-        run: |
-          ./autogen.sh
-          ./configure
-          make -j$(nproc)
-          sudo make install
-
-      - name: Checkout libva
-        uses: actions/checkout@v5
-        with:
-          repository: intel/libva
-          ref: 2.24.1
-          path: deps/libva
-
-      - name: Build libva
-        working-directory: deps/libva
-        run: |
-          ./autogen.sh
-          ./configure --enable-x11=yes --enable-glx=no --enable-drm=no --enable-wayland=no
-          make -j$(nproc)
-          sudo make install
-
-      - name: Checkout libplacebo
-        uses: actions/checkout@v5
-        with:
-          repository: haasn/libplacebo
-          ref: 92b5ac6db79f4d680eb656692f7bf51e9606f42a
-          path: deps/libplacebo
-          submodules: 'recursive'
-
-      - name: Build libplacebo
-        working-directory: deps/libplacebo
-        run: |
-          git apply ../../app/deploy/linux/appimage/*.patch
-          meson setup build -Dvulkan=enabled -Dopengl=disabled -Ddemos=false
-          ninja -C build
-          sudo ninja install -C build
-
-      - name: Build dav1d
-        working-directory: deps
-        env:
-          DAV1D_VER: 1.5.4
-        run: |
-          git clone --branch $DAV1D_VER --depth 1 https://code.videolan.org/videolan/dav1d.git
-          pushd dav1d
-          meson setup build -Ddefault_library=static -Dbuildtype=release -Denable_tools=false -Denable_tests=false
-          ninja -C build
-          sudo ninja install -C build
-          popd
-
-      - name: Checkout FFmpeg
-        uses: actions/checkout@v5
-        with:
-          repository: FFmpeg/FFmpeg
-          ref: n9.0.2
-          path: deps/FFmpeg
-
-      - name: Build FFmpeg
-        working-directory: deps/FFmpeg
-        run: |
-          ./configure --enable-pic --enable-lto --disable-static --enable-shared --disable-all --disable-autodetect \
-            --enable-avcodec --enable-avformat --enable-swscale \
-            --enable-decoder=h264 --enable-decoder=hevc --enable-decoder=av1 \
-            --enable-vaapi --enable-hwaccel=h264_vaapi --enable-hwaccel=hevc_vaapi --enable-hwaccel=av1_vaapi \
-            --enable-vdpau --enable-hwaccel=h264_vdpau  --enable-hwaccel=hevc_vdpau --enable-hwaccel=av1_vdpau \
-            --enable-libdrm --enable-vulkan --enable-hwaccel=h264_vulkan --enable-hwaccel=hevc_vulkan --enable-hwaccel=av1_vulkan \
-            --enable-libdav1d --enable-decoder=libdav1d
-          make -j$(nproc)
-          sudo make install
-
-      - name: Install linuxdeploy
-        working-directory: dep_root/bin
-        run: |
-          wget https://github.com/linuxdeploy/linuxdeploy/releases/download/continuous/linuxdeploy-x86_64.AppImage
-          wget https://github.com/linuxdeploy/linuxdeploy-plugin-qt/releases/download/continuous/linuxdeploy-plugin-qt-x86_64.AppImage
-          chmod +x linuxdeploy*.AppImage
-
-      - name: Build Binaries
-        run: |
-          sudo ldconfig
-          scripts/build-appimage.sh
-
-      - name: Upload Binaries
-        uses: actions/upload-artifact@v6
-        with:
-          name: Moonlight-LinuxAppImage-${{ env.CI_VERSION }}
-          path: build/installer-release/Moonlight-${{ env.CI_VERSION }}-x86_64.AppImage
-          compression-level: 0
-          if-no-files-found: error
@@ -1,41 +0,0 @@
---
-name: Build - Steam Link
-permissions:
-  contents: read
-
-on:
-  workflow_call:
-    inputs:
-      ci_version:
-        required: true
-        type: string
-
-jobs:
-  build:
-    env:
-      CI_VERSION: ${{ inputs.ci_version }}
-    runs-on: ubuntu-22.04
-
-    steps:
-      - name: Checkout Repository
-        uses: actions/checkout@v5
-        with:
-          submodules: 'recursive'
-          fetch-depth: 1
-
-      - name: Checkout Steam Link SDK
-        uses: actions/checkout@v5
-        with:
-          repository: ValveSoftware/steamlink-sdk
-          path: steamlink-sdk
-          fetch-depth: 1
-
-      - name: Build binaries
-        run: STEAMLINK_SDK_PATH=$PWD/steamlink-sdk scripts/build-steamlink-app.sh
-
-      - name: Upload Binaries
-        uses: actions/upload-artifact@v6
-        with:
-          name: Moonlight-SteamLink-${{ env.CI_VERSION }}
-          path: build/deploy-release/*
-          if-no-files-found: error
@@ -1,126 +0,0 @@
---
-name: Build - Windows and macOS
-permissions:
-  contents: read
-
-on:
-  workflow_call:
-    inputs:
-      ci_version:
-        required: true
-        type: string
-
-jobs:
-  build:
-    env:
-      CI_VERSION: ${{ inputs.ci_version }}
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          # Windows
-          - os: windows-2025
-            qt_version: 6.12.0
-          # macOS
-          - os: macos-26
-            qt_version: 6.11.2
-
-    runs-on: ${{ matrix.os }}
-
-    steps:
-      - name: Checkout Repository
-        uses: actions/checkout@v5
-        with:
-          submodules: 'recursive'
-          fetch-depth: 1
-
-      - name: Download dependencies (Windows)
-        if: runner.os == 'Windows'
-        run: powershell ./setup-deps.ps1
-
-      - name: Install create-dmg (macOS)
-        if: runner.os == 'macOS'
-        run: |
-          brew install node
-          npm install --global create-dmg
-
-      - name: Install Qt
-        uses: jurplel/install-qt-action@v4
-        with:
-          cache: true
-          set-env: ${{ runner.os != 'Windows' }}
-          add-tools-to-path: ${{ runner.os != 'Windows' }}
-          tools: ${{ runner.os == 'Windows' && 'tools_qtcreator_gui' || '' }}
-          version: ${{ matrix.qt_version }}
-          aqtsource: 'git+https://github.com/miurahr/aqtinstall.git@073e34d7c2ab4ae6961ed7cca690b3abd5ba5a7e'
-
-      - name: Install Qt ARM64 (Windows)
-        if: runner.os == 'Windows'
-        uses: jurplel/install-qt-action@v4
-        with:
-          cache: true
-          set-env: false
-          add-tools-to-path: false
-          arch: win64_msvc2022_arm64_cross_compiled
-          version: ${{ matrix.qt_version }}
-
-      - name: Build x64 binaries (Windows)
-        if: runner.os == 'Windows'
-        shell: cmd
-        run: |
-          set "PATH=%QT_PATH%;%PATH%"
-          scripts\build-arch.bat Release x64
-        env:
-          QT_PATH: ${{ runner.workspace }}\Qt\${{ matrix.qt_version }}\msvc2022_64\bin
-
-      - name: Build ARM64 binaries (Windows)
-        if: runner.os == 'Windows'
-        shell: cmd
-        run: |
-          set "PATH=%QT_PATH%;%PATH%"
-          scripts\build-arch.bat Release arm64
-        env:
-          QT_PATH: ${{ runner.workspace }}\Qt\${{ matrix.qt_version }}\msvc2022_arm64\bin
-
-      - name: Build Package
-        shell: pwsh
-        run: |
-          if ($Env:RUNNER_OS -eq "Windows") {
-            cmd /c scripts\generate-bundle.bat Release
-          } else {
-            bash scripts/generate-dmg.sh Release
-          }
-
-      - name: Upload Binaries (Windows x64)
-        uses: actions/upload-artifact@v6
-        if: runner.os == 'Windows'
-        with:
-          name: Moonlight-${{ runner.os }}-x64-${{ env.CI_VERSION }}
-          path: build/deploy-x64-release/*
-          if-no-files-found: error
-
-      - name: Upload Binaries (Windows arm64)
-        uses: actions/upload-artifact@v6
-        if: runner.os == 'Windows'
-        with:
-          name: Moonlight-${{ runner.os }}-arm64-${{ env.CI_VERSION }}
-          path: build/deploy-arm64-release/*
-          if-no-files-found: error
-
-      - name: Upload Binaries (macOS)
-        uses: actions/upload-artifact@v6
-        if: runner.os == 'macOS'
-        with:
-          name: Moonlight-${{ runner.os }}-${{ env.CI_VERSION }}
-          path: build/installer-Release/*.dmg
-          compression-level: 0
-          if-no-files-found: error
-
-      - name: Upload Symbols
-        uses: actions/upload-artifact@v6
-        with:
-          name: zDevDbgSyms-${{ runner.os }}-${{ env.CI_VERSION }}
-          path: |
-            build/installer-*/*.dsym/*
-            build/symbols-*/*.pdb
-          if-no-files-found: error
@@ -1,45 +0,0 @@
---
-name: Build
-permissions:
-  contents: read
-
-on:
-  push:
-  pull_request:
-    branches:
-      - master
-
-concurrency:
-  group: build-${{ github.ref }}
-  cancel-in-progress: true
-
-jobs:
-  setup:
-    runs-on: ubuntu-latest
-    outputs:
-      ci_version: ${{ steps.set-ci-version.outputs.ci_version }}
-    steps:
-      - name: Set CI version
-        id: set-ci-version
-        shell: bash
-        run: |
-          CI_VERSION=`echo ${GITHUB_SHA} | cut -c1-6`
-          echo "ci_version=${CI_VERSION}" >> "${GITHUB_OUTPUT}"
-
-  build-appimage:
-    needs: setup
-    uses: ./.github/workflows/build-appimage.yml
-    with:
-      ci_version: ${{ needs.setup.outputs.ci_version }}
-
-  build-steamlink:
-    needs: setup
-    uses: ./.github/workflows/build-steamlink.yml
-    with:
-      ci_version: ${{ needs.setup.outputs.ci_version }}
-
-  build-windows-macos:
-    needs: setup
-    uses: ./.github/workflows/build-win-mac.yml
-    with:
-      ci_version: ${{ needs.setup.outputs.ci_version }}
@@ -1,9 +1 @@
 *pro.user
-
-
-**/.vs/
-.vscode/
-build/
-libs/
-config.tests/*/.qmake.stash
-config.tests/*/Makefile
@@ -1,9 +1,9 @@
 [submodule "moonlight-common-c/moonlight-common-c"]
 	path = moonlight-common-c/moonlight-common-c
 	url = https://github.com/moonlight-stream/moonlight-common-c.git
+[submodule "opus/opus"]
+	path = opus/opus
+	url = https://github.com/xiph/opus.git
 [submodule "qmdnsengine/qmdnsengine"]
 	path = qmdnsengine/qmdnsengine
 	url = https://github.com/cgutman/qmdnsengine.git
-[submodule "app/SDL_GameControllerDB"]
-	path = app/SDL_GameControllerDB
-	url = https://github.com/gabomdq/SDL_GameControllerDB.git
@@ -1,22 +0,0 @@
-QT       -= core gui
-
-TARGET = AntiHooking
-TEMPLATE = lib
-
-include(../globaldefs.pri)
-
-INCLUDEPATH += $$PWD/../libs/windows/include
-contains(QT_ARCH, i386) {
-    LIBS += -L$$PWD/../libs/windows/lib/x86
-}
-contains(QT_ARCH, x86_64) {
-    LIBS += -L$$PWD/../libs/windows/lib/x64
-}
-contains(QT_ARCH, arm64) {
-    LIBS += -L$$PWD/../libs/windows/lib/arm64
-}
-
-LIBS += -ldetours
-DEFINES += ANTIHOOKING_LIBRARY
-SOURCES += antihookingprotection.cpp
-HEADERS += antihookingprotection.h
@@ -1,266 +0,0 @@
-#include "antihookingprotection.h"
-
-#define WIN32_LEAN_AND_MEAN
-#include <Windows.h>
-
-#include <detours.h>
-
-typedef HMODULE (WINAPI *LoadLibraryAFunc)(LPCSTR lpLibFileName);
-typedef HMODULE (WINAPI *LoadLibraryWFunc)(LPCWSTR lpLibFileName);
-typedef HMODULE (WINAPI *LoadLibraryExAFunc)(LPCSTR lpLibFileName, HANDLE hFile, DWORD dwFlags);
-typedef HMODULE (WINAPI *LoadLibraryExWFunc)(LPCWSTR lpLibFileName, HANDLE hFile, DWORD dwFlags);
-
-class AntiHookingProtection
-{
-public:
-    static void enable()
-    {
-        DetourTransactionBegin();
-        DetourUpdateThread(GetCurrentThread());
-
-        s_RealLoadLibraryA = LoadLibraryA;
-        DetourAttach(&(PVOID&)s_RealLoadLibraryA, LoadLibraryAHook);
-
-        s_RealLoadLibraryW = LoadLibraryW;
-        DetourAttach(&(PVOID&)s_RealLoadLibraryW, LoadLibraryWHook);
-
-        s_RealLoadLibraryExA = LoadLibraryExA;
-        DetourAttach(&(PVOID&)s_RealLoadLibraryExA, LoadLibraryExAHook);
-
-        s_RealLoadLibraryExW = LoadLibraryExW;
-        DetourAttach(&(PVOID&)s_RealLoadLibraryExW, LoadLibraryExWHook);
-
-        DetourTransactionCommit();
-    }
-
-    static void disable()
-    {
-        DetourTransactionBegin();
-        DetourUpdateThread(GetCurrentThread());
-
-        DetourDetach(&(PVOID&)s_RealLoadLibraryA, LoadLibraryAHook);
-        DetourDetach(&(PVOID&)s_RealLoadLibraryW, LoadLibraryWHook);
-        DetourDetach(&(PVOID&)s_RealLoadLibraryExA, LoadLibraryExAHook);
-        DetourDetach(&(PVOID&)s_RealLoadLibraryExW, LoadLibraryExWHook);
-
-        DetourTransactionCommit();
-    }
-
-private:
-    static bool isImageBlacklistedW(LPCWSTR lpLibFileName)
-    {
-        LPCWSTR dllName;
-
-        // If the library has a path prefixed, remove it
-        dllName = wcsrchr(lpLibFileName, '\\');
-        if (!dllName) {
-            // No prefix, so use the full name
-            dllName = lpLibFileName;
-        }
-        else {
-            // Advance past the backslash
-            dllName++;
-        }
-
-        // FIXME: We don't currently handle LoadLibrary calls where the
-        // library name does not include a file extension and the loader
-        // automatically assumes .dll.
-
-        for (int i = 0; i < ARRAYSIZE(k_BlacklistedDlls); i++) {
-            if (_wcsicmp(dllName, k_BlacklistedDlls[i]) == 0) {
-                return true;
-            }
-        }
-
-        return false;
-    }
-
-    static bool isImageBlacklistedA(LPCSTR lpLibFileName)
-    {
-        int uniChars = MultiByteToWideChar(CP_THREAD_ACP, 0, lpLibFileName, -1, nullptr, 0);
-        if (uniChars > 0) {
-            PWCHAR wideBuffer = new WCHAR[uniChars];
-            uniChars = MultiByteToWideChar(CP_THREAD_ACP, 0,
-                                           lpLibFileName, -1,
-                                           wideBuffer, uniChars * sizeof(WCHAR));
-            if (uniChars > 0) {
-                bool ret = isImageBlacklistedW(wideBuffer);
-                delete[] wideBuffer;
-                return ret;
-            }
-            else {
-                delete[] wideBuffer;
-            }
-        }
-
-        // Error path
-        return false;
-    }
-
-    static HMODULE WINAPI LoadLibraryAHook(LPCSTR lpLibFileName)
-    {
-        if (lpLibFileName && isImageBlacklistedA(lpLibFileName)) {
-            SetLastError(ERROR_ACCESS_DISABLED_BY_POLICY);
-            return nullptr;
-        }
-
-        return s_RealLoadLibraryA(lpLibFileName);
-    }
-
-    static HMODULE WINAPI LoadLibraryWHook(LPCWSTR lpLibFileName)
-    {
-        if (lpLibFileName && isImageBlacklistedW(lpLibFileName)) {
-            SetLastError(ERROR_ACCESS_DISABLED_BY_POLICY);
-            return nullptr;
-        }
-
-        return s_RealLoadLibraryW(lpLibFileName);
-    }
-
-    static HMODULE WINAPI LoadLibraryExAHook(LPCSTR lpLibFileName, HANDLE hFile, DWORD dwFlags)
-    {
-        if (lpLibFileName && isImageBlacklistedA(lpLibFileName)) {
-            SetLastError(ERROR_ACCESS_DISABLED_BY_POLICY);
-            return nullptr;
-        }
-
-        return s_RealLoadLibraryExA(lpLibFileName, hFile, dwFlags);
-    }
-
-    static HMODULE WINAPI LoadLibraryExWHook(LPCWSTR lpLibFileName, HANDLE hFile, DWORD dwFlags)
-    {
-        if (lpLibFileName && isImageBlacklistedW(lpLibFileName)) {
-            SetLastError(ERROR_ACCESS_DISABLED_BY_POLICY);
-            return nullptr;
-        }
-
-        return s_RealLoadLibraryExW(lpLibFileName, hFile, dwFlags);
-    }
-
-    static LoadLibraryAFunc s_RealLoadLibraryA;
-    static LoadLibraryWFunc s_RealLoadLibraryW;
-    static LoadLibraryExAFunc s_RealLoadLibraryExA;
-    static LoadLibraryExWFunc s_RealLoadLibraryExW;
-
-    static constexpr LPCWSTR k_BlacklistedDlls[] = {
-        // These A-Volute DLLs shipped with various audio driver packages improperly handle
-        // D3D9 exclusive fullscreen in a way that causes CreateDeviceEx() to deadlock.
-        // https://github.com/moonlight-stream/moonlight-qt/issues/102
-        L"NahimicOSD.dll", // ASUS Sonic Radar 3
-        L"SSAudioOSD.dll", // SteelSeries headsets
-        L"SS2OSD.dll", // ASUS Sonic Studio 2
-        L"Nahimic2OSD.dll",
-        L"NahimicMSIOSD.dll",
-        L"nhAsusPhoebusOSD.dll", // ASUS Phoebus
-
-        // This DLL has been seen in several crash reports. Some Googling
-        // suggests it's highly unstable and causes issues in many games.
-        L"EZFRD32.dll",
-        L"EZFRD64.dll",
-
-        // These are the older dList/AppInit DLLs for Optimus hybrid graphics DDI.
-        // https://docs.microsoft.com/en-us/windows-hardware/drivers/display/hybrid-system-ddi
-        //
-        // These seem to cause a crash in PresentEx() in full-screen exclusive mode.
-        // This block will prevent Optimus from ever using the dGPU even if the user has requested it.
-        // https://github.com/moonlight-stream/moonlight-qt/issues/386
-        //
-        // d3d9!CSwapChain::BltToHybridPrimary+0x200:
-        // 00007ffa`23f37e58 488b01          mov     rax,qword ptr [rcx] ds:00000000`00000038=????????????????
-        // 00 0000004e`496ff4e0 00007ffa`23f39e2c d3d9!CSwapChain::BltToHybridPrimary+0x200
-        // 01 0000004e`496ff880 00007ffa`23ee39ce d3d9!CSwapChain::FlipToSurface+0x15c
-        // 02 0000004e`496ff900 00007ffa`23f4dd75 d3d9!CSwapChain::PresentMain+0x3e13e
-        // 03 0000004e`496ffab0 00007ffa`23f4dccd d3d9!CBaseDevice::PresentMain+0x9d
-        // 04 0000004e`496ffb00 00007ff7`8e31016f d3d9!CBaseDevice::PresentEx+0xbd
-        // 05 0000004e`496ffb50 00007ff7`8e30df1e Moonlight!DXVA2Renderer::renderFrame+0x61f [C:\moonlight-qt\app\streaming\video\ffmpeg-renderers\dxva2.cpp @ 1035]
-        // 06 0000004e`496ffd50 00007ff7`8e30e46a Moonlight!Pacer::renderFrame+0x3e [C:\moonlight-qt\app\streaming\video\ffmpeg-renderers\pacer\pacer.cpp @ 265]
-        // 07 (Inline Function) --------`-------- Moonlight!Pacer::renderLastFrameAndUnlock+0x197 [C:\moonlight-qt\app\streaming\video\ffmpeg-renderers\pacer\pacer.cpp @ 156]
-        // 08 0000004e`496ffda0 00007ffa`14476978 Moonlight!Pacer::renderThread+0x1ca [C:\moonlight-qt\app\streaming\video\ffmpeg-renderers\pacer\pacer.cpp @ 88]
-        // 09 0000004e`496ffde0 00007ffa`14476ee2 SDL2!SDL_RunThread+0x38 [C:\Users\camer\SDL\src\thread\SDL_thread.c @ 276]
-        // 0a 0000004e`496ffe10 00007ffa`2aae0e82 SDL2!RunThread+0x12 [C:\Users\camer\SDL\src\thread\windows\SDL_systhread.c @ 83]
-        // 0b 0000004e`496ffe40 00007ffa`2d627bd4 ucrtbase!thread_start<unsigned int (__cdecl*)(void *),1>+0x42
-        // 0c 0000004e`496ffe70 00007ffa`2da4ce51 kernel32!BaseThreadInitThunk+0x14
-        // 0d 0000004e`496ffea0 00000000`00000000 ntdll!RtlUserThreadStart+0x21
-        //
-        L"nvinit.dll",
-        L"nvinitx.dll",
-
-        // In some unknown circumstances, RTSS tries to hook in the middle of an instruction, leaving garbage
-        // code inside d3d9.dll that causes a crash when executed:
-        //
-        // 0:000> u
-        // d3d9!D3D9GetCurrentOwnershipMode+0x5d:
-        // 00007ff8`95b95861 9b              wait
-        // 00007ff8`95b95862 a7              cmps    dword ptr [rsi],dword ptr [rdi]   <--- crash happens here
-        // 00007ff8`95b95863 ff              ???
-        // 00007ff8`95b95864 bfe8ca8a00      mov     edi,8ACAE8h
-        // 00007ff8`95b95869 00eb            add     bl,ch
-        // 00007ff8`95b9586b f1              ???
-        // 00007ff8`95b9586c b808000000      mov     eax,8
-        // 00007ff8`95b95871 ebe6            jmp     d3d9!D3D9GetCurrentOwnershipMode+0x55 (00007ff8`95b95859)
-        //
-        // Disassembling starting at the exact address of the attempted hook yields the intended jmp instruction
-        //
-        // 0:000> u d3d9!D3D9GetCurrentOwnershipMode+0x5c:
-        // 00007ff8`95b95860 e99ba7ffbf      jmp     00007ff8`55b90000
-        //
-        // Since the RTSS OSD doesn't even work with DXVA2, we'll just block the hooks entirely.
-        L"RTSSHooks.dll",
-        L"RTSSHooks64.dll",
-
-        // Bandicam's Vulkan layer DLL crashes during destruction of the Vulkan swapchain
-        // bdcamvk64+0x10b73:
-        // 00007ffa`be3b0b73 498b5630        mov     rdx,qword ptr [r14+30h] ds:00000000`00000030=????????????????
-        //
-        // bdcamvk64+0x10b73
-        // libplacebo_357!vk_sw_destroy+0x14f [D:\a\moonlight-deps\moonlight-deps\libplacebo\src\vulkan\swapchain.c @ 460]
-        // libplacebo_357!pl_swapchain_destroy+0x1a [D:\a\moonlight-deps\moonlight-deps\libplacebo\src\swapchain.c @ 30]
-        // Moonlight!PlVkRenderer::~PlVkRenderer+0x159 [D:\a\moonlight-qt\app\streaming\video\ffmpeg-renderers\plvk.cpp @ 140]
-        // Moonlight!PlVkRenderer::`scalar deleting destructor'+0x17
-        // Moonlight!FFmpegVideoDecoder::reset+0x203 [D:\a\moonlight-qt\app\streaming\video\ffmpeg.cpp @ 301]
-        // Moonlight!FFmpegVideoDecoder::~FFmpegVideoDecoder+0x22 [D:\a\moonlight-qt\app\streaming\video\ffmpeg.cpp @ 257]
-        // Moonlight!FFmpegVideoDecoder::`scalar deleting destructor'+0x17
-        // Moonlight!Session::getDecoderInfo+0x19a [D:\a\moonlight-qt\app\streaming\session.cpp @ 415]
-        // Moonlight!SystemProperties::querySdlVideoInfoInternal+0x134 [D:\a\moonlight-qt\app\backend\systemproperties.cpp @ 161]
-        // Moonlight!SystemProperties::querySdlVideoInfo+0x97 [D:\a\moonlight-qt\app\backend\systemproperties.cpp @ 123]
-        // Moonlight!SystemProperties::SystemProperties+0x4bf [D:\a\moonlight-qt\app\backend\systemproperties.cpp @ 75]
-        //
-        // https://github.com/moonlight-stream/moonlight-qt/issues/1425
-        // https://github.com/moonlight-stream/moonlight-qt/issues/1579
-        L"bdcamvk32.dll",
-        L"bdcamvk64.dll",
-    };
-};
-
-LoadLibraryAFunc AntiHookingProtection::s_RealLoadLibraryA;
-LoadLibraryWFunc AntiHookingProtection::s_RealLoadLibraryW;
-LoadLibraryExAFunc AntiHookingProtection::s_RealLoadLibraryExA;
-LoadLibraryExWFunc AntiHookingProtection::s_RealLoadLibraryExW;
-
-AH_EXPORT void AntiHookingDummyImport() {}
-
-extern "C"
-BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
-{
-    if (DetourIsHelperProcess()) {
-        return TRUE;
-    }
-
-    switch (fdwReason)
-    {
-    case DLL_PROCESS_ATTACH:
-        DetourRestoreAfterWith();
-        AntiHookingProtection::enable();
-        DisableThreadLibraryCalls(hinstDLL);
-        break;
-    case DLL_PROCESS_DETACH:
-        // Ignore DLL_PROCESS_DETACH on process exit. No need to waste time
-        // unhooking everything if the whole process is being destroyed.
-        if (lpvReserved == NULL) {
-            AntiHookingProtection::disable();
-        }
-        break;
-    }
-
-    return TRUE;
-};
@@ -1,10 +0,0 @@
-#pragma once
-
-#ifdef ANTIHOOKING_LIBRARY
-#define AH_EXPORT  extern "C" __declspec(dllexport)
-#else
-#define AH_EXPORT  extern "C" __declspec(dllimport)
-#endif
-
-AH_EXPORT void AntiHookingDummyImport();
-
@@ -1,114 +1,22 @@
 # Moonlight PC

-[Moonlight PC](https://moonlight-stream.org) is an open source PC client for NVIDIA GameStream and [Sunshine](https://github.com/LizardByte/Sunshine).
+[Moonlight PC](http://moonlight-stream.com) is an open source implementation of NVIDIA's GameStream, as used by the NVIDIA Shield, but built to run on Windows, Mac, and Linux.

-Moonlight also has mobile versions for [Android](https://github.com/moonlight-stream/moonlight-android) and [iOS](https://github.com/moonlight-stream/moonlight-ios).
+Moonlight also has mobile versions for [Android](https://github.com/moonlight-stream/moonlight-android) and  [iOS](https://github.com/moonlight-stream/moonlight-ios).

-You can follow development on our [Discord server](https://moonlight-stream.org/discord) and help translate Moonlight into your language on [Weblate](https://hosted.weblate.org/projects/moonlight/moonlight-qt/).
-
- [![Build](https://img.shields.io/github/actions/workflow/status/moonlight-stream/moonlight-qt/build.yml?branch=master)](https://github.com/moonlight-stream/moonlight-qt/actions/workflows/build.yml?query=branch%3Amaster)
- [![Downloads](https://img.shields.io/github/downloads/moonlight-stream/moonlight-qt/total)](https://github.com/moonlight-stream/moonlight-qt/releases)
- [![Translation Status](https://hosted.weblate.org/widgets/moonlight/-/moonlight-qt/svg-badge.svg)](https://hosted.weblate.org/projects/moonlight/moonlight-qt/)
-
-## Features
- - Hardware accelerated video decoding on Windows, Mac, and Linux
- - H.264, HEVC, and AV1 codec support (AV1 requires Sunshine and a supported host GPU)
- - YUV 4:4:4 support (Sunshine only)
- - HDR streaming support
- - 7.1 surround sound audio support
- - 10-point multitouch support (Sunshine only)
- - Gamepad support with force feedback and motion controls for up to 16 players
- - Support for both pointer capture (for games) and direct mouse control (for remote desktop)
- - Support for passing system-wide keyboard shortcuts like Alt+Tab to the host
- 
-## Downloads
- [Windows, macOS, and Steam Link](https://github.com/moonlight-stream/moonlight-qt/releases)
- [Snap (for Ubuntu-based Linux distros)](https://snapcraft.io/moonlight)
- [Flatpak (for other Linux distros)](https://flathub.org/apps/details/com.moonlight_stream.Moonlight)
- [AppImage](https://github.com/moonlight-stream/moonlight-qt/releases)
- [Raspberry Pi 4 and 5](https://github.com/moonlight-stream/moonlight-docs/wiki/Installing-Moonlight-Qt-on-Raspberry-Pi-4)
- [Generic ARM 32-bit and 64-bit Debian packages](https://github.com/moonlight-stream/moonlight-docs/wiki/Installing-Moonlight-Qt-on-ARM%E2%80%90based-Single-Board-Computers) (not for Raspberry Pi)
- [Experimental RISC-V Debian packages](https://github.com/moonlight-stream/moonlight-docs/wiki/Installing-Moonlight-Qt-on-RISC%E2%80%90V-Single-Board-Computers)
- [NVIDIA Jetson and Nintendo Switch (Ubuntu L4T)](https://github.com/moonlight-stream/moonlight-docs/wiki/Installing-Moonlight-Qt-on-Linux4Tegra-(L4T)-Ubuntu)
-
-### Nightly Builds
- [Downloads](https://nightly.link/moonlight-stream/moonlight-qt/workflows/build/master)
-
-#### Special Thanks
-
-[![Hosted By: Cloudsmith](https://img.shields.io/badge/OSS%20hosting%20by-cloudsmith-blue?logo=cloudsmith&style=flat-square)](https://cloudsmith.com)
-
-Hosting for Moonlight's Debian and L4T package repositories is graciously provided for free by [Cloudsmith](https://cloudsmith.com).
+This is a work-in-progress port and is only suitable for development use at this point.

 ## Building
-
-### Windows Build Requirements
-* Qt 6.11 SDK or later (earlier versions may work but are not officially supported)
-* [Visual Studio 2026](https://visualstudio.microsoft.com/downloads/) (Community edition is fine)
-* Select **MSVC** option during Qt installation. MinGW is not supported.
-* [7-Zip](https://www.7-zip.org/) (only if building installers for non-development PCs)
-* Graphics Tools (only if running debug builds)
-  * Install "Graphics Tools" in the Optional Features page of the Windows Settings app.
-  * Alternatively, run `dism /online /add-capability /capabilityname:Tools.Graphics.DirectX~~~~0.0.1.0` and reboot.
-
-### macOS Build Requirements
-* Qt 6.11 SDK or later (earlier versions may work but are not officially supported)
-* Xcode 15 or later (earlier versions may work but are not officially supported)
-* [create-dmg](https://github.com/sindresorhus/create-dmg) (only if building DMGs for use on non-development Macs)
-
-### Linux/Unix Build Requirements
-* Qt 6 is recommended, but Qt 5.12 or later is also supported (replace `qmake6` with `qmake` when using Qt 5).
-* GCC or Clang
-* FFmpeg 4.0 or later
-* Install the required packages:
-  * Debian/Ubuntu:
-    * Base Requirements: `libegl1-mesa-dev libgl1-mesa-dev libopus-dev libsdl2-dev libsdl2-ttf-dev libssl-dev libavcodec-dev libavformat-dev libswscale-dev libva-dev libvdpau-dev libxkbcommon-dev wayland-protocols libdrm-dev`
-    * Qt 6 (Recommended): `qt6-base-dev qt6-declarative-dev libqt6svg6-dev qt6-wayland qml6-module-qtquick-controls qml6-module-qtquick-templates qml6-module-qtquick-layouts qml6-module-qtqml-workerscript qml6-module-qtquick-window qml6-module-qtquick`
-    * Qt 5: `qtbase5-dev qt5-qmake qtdeclarative5-dev qtquickcontrols2-5-dev qml-module-qtquick-controls2 qml-module-qtquick-layouts qml-module-qtquick-window2 qml-module-qtquick2 qtwayland5`
-  * RedHat/Fedora (RPM Fusion repo required):
-    * Base Requirements: `openssl-devel SDL2-devel SDL2_ttf-devel ffmpeg-devel libva-devel libvdpau-devel opus-devel pulseaudio-libs-devel alsa-lib-devel libdrm-devel`
-    * Qt 6 (Recommended): `qt6-qtsvg-devel qt6-qtdeclarative-devel`
-    * Qt 5: `qt5-qtsvg-devel qt5-qtquickcontrols2-devel`
-* Building the Vulkan renderer requires a `libplacebo-dev`/`libplacebo-devel` version of at least v7.349.0 and FFmpeg 6.1 or later.
-
-### Steam Link Build Requirements
-* [Steam Link SDK](https://github.com/ValveSoftware/steamlink-sdk) cloned on your build system
-* STEAMLINK_SDK_PATH environment variable set to the Steam Link SDK path
-
-**Steam Link Hardware Limitations**  
-Moonlight builds for Steam Link are subject to hardware limitations of the Steam Link device:
-* Maximum resolution: **1080p (1920x1080)**
-* Maximum framerate: **60 FPS**
-* Maximum video bitrate: **40 Mbps**
-* **HDR streaming is not supported** on the original hardware
-
-### Docker containers
-If you want to use Docker for building, look at [this repo](https://github.com/cgutman/moonlight-packaging) containing canonical containers
-for different architectures, which handle building deps and extra linking for you.
-
-### Build Setup Steps
 1. Install the latest Qt SDK (and optionally, the Qt Creator IDE) from https://www.qt.io/download
-    * You can install Qt via Homebrew on macOS, but you will need to use `brew install qt --with-debug` to be able to create debug builds of Moonlight.
-    * You may also use your Linux distro's package manager for the Qt SDK as long as the packages are Qt 5.12 or later.
-    * This step is not required for building on Steam Link, because the Steam Link SDK includes Qt 5.14.
-2. Download submodules and dependencies
-    * Run `git submodule update --init --recursive` from within `moonlight-qt/`.
-    * On Windows and macOS, you must also run `setup-deps.ps1` (Windows) or `setup-deps.py` (macOS).
-    * Perform these steps each time you pull new changes from the Git repository.
-3. Open the project in Qt Creator or build from qmake on the command line.
-    * To build a binary for use on non-development machines, use the scripts in the `scripts` folder.
-        * For Windows builds, use `scripts\build-arch.bat` and `scripts\generate-bundle.bat`. Execute these scripts from the root of the repository within a Qt command prompt. Ensure  7-Zip binary directory is on your `%PATH%`.
-        * For macOS builds, use `scripts/generate-dmg.sh`. Execute this script from the root of the repository and ensure Qt's `bin` folder is in your `$PATH`.
-        * For Steam Link builds, run `scripts/build-steamlink-app.sh` from the root of the repository.
-    * To build from the command line for development use on macOS or Linux, run `qmake6 moonlight-qt.pro` then `make debug` or `make release`.
-        * The final binary will be placed in `app/moonlight`.
-    * To create an embedded build for a single-purpose device, use `qmake6 "CONFIG+=embedded" moonlight-qt.pro` and build normally.
-        * This build will lack windowed mode, Discord/Help links, and other features that don't make sense on an embedded device.
-        * For platforms with poor GPU performance, add `"CONFIG+=gpuslow"` to prefer direct KMSDRM rendering over GL/Vulkan renderers. Direct KMSDRM rendering can use dedicated YUV/RGB conversion and scaling hardware rather than slower GPU shaders for these operations.
+3. Run `git submodule update --init --recursive` from within `moonlight-qt/`
+4. Open the project in Qt Creator or build from qmake on the command line

 ## Contribute
+
+This project is being actively developed at [XDA Developers](http://forum.xda-developers.com/showthread.php?t=2505510)
+
 1. Fork us
 2. Write code
 3. Send Pull Requests

-Check out our [website](https://moonlight-stream.org) for project links and information.
+Check out our [website](http://moonlight-stream.com) for project links and information.
@@ -2,57 +2,25 @@
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
 <dict>
-	<key>GCSupportsGameMode</key>
-	<true/>
 	<key>CFBundleExecutable</key>
-	<string>Moonlight</string>
-	<key>LSSupportsGameMode</key>
-	<true/>
+	<string>moonlight-qt</string>
 	<key>CFBundleGetInfoString</key>
-	<string>Stream games and other applications from another PC</string>
+	<string>Created by Qt/QMake</string>
 	<key>CFBundleIconFile</key>
-	<string>moonlight</string>
+	<string>macos</string>
 	<key>CFBundleIdentifier</key>
-	<string>com.moonlight-stream.Moonlight</string>
-	<key>NSHighResolutionCapable</key>
-	<true/>
+	<string>com.yourcompany.moonlight-qt</string>
 	<key>CFBundlePackageType</key>
 	<string>APPL</string>
 	<key>CFBundleSignature</key>
 	<string>????</string>
 	<key>LSMinimumSystemVersion</key>
-	<string>13.0.0</string>
+	<string>10.10</string>
+	<key>NOTE</key>
+	<string>This file was generated by Qt/QMake.</string>
 	<key>NSPrincipalClass</key>
 	<string>NSApplication</string>
 	<key>NSSupportsAutomaticGraphicsSwitching</key>
 	<true/>
-	<key>GCSupportedGameControllers</key>
-	<array>
-		<dict>
-			<key>ProfileName</key>
-			<string>ExtendedGamepad</string>
-		</dict>
-	</array>
-	<key>GCSupportsControllerUserInteraction</key>
-	<true/>
-	<key>NSAppTransportSecurity</key>
-	<dict>
-		<key>NSAllowsArbitraryLoads</key>
-		<true/>
-	</dict>
-	<key>NSLocalNetworkUsageDescription</key>
-	<string>Moonlight uses the local network to connect to your gaming PC for streaming.</string>
-	<key>NSBonjourServices</key>
-	<array>
-		<string>_nvstream._tcp</string>
-	</array>
-	<key>CFBundleVersion</key>
-	<string>VERSION</string>
-	<key>CFBundleShortVersionString</key>
-	<string>VERSION</string>
-	<key>CFBundleDisplayName</key>
-	<string>Moonlight</string>
-    <key>LSApplicationCategoryType</key>
-	<string>public.app-category.games</string>
 </dict>
 </plist>
@@ -1,32 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<assembly xmlns="urn:schemas-microsoft-com:asm.v1" xmlns:asmv3="urn:schemas-microsoft-com:asm.v3" manifestVersion="1.0">
-    <trustInfo xmlns="urn:schemas-microsoft-com:asm.v3">
-        <security>
-            <requestedPrivileges>
-                <requestedExecutionLevel level="asInvoker" uiAccess="false" />
-            </requestedPrivileges>
-        </security>
-    </trustInfo>
-    <description>Moonlight Game Streaming</description>
-    <asmv3:application>
-        <asmv3:windowsSettings>
-            <dpiAware xmlns="http://schemas.microsoft.com/SMI/2005/WindowsSettings">true/pm</dpiAware>
-            <dpiAwareness xmlns="http://schemas.microsoft.com/SMI/2016/WindowsSettings">permonitorv2, permonitor</dpiAwareness>
-            <heapType xmlns="http://schemas.microsoft.com/SMI/2020/WindowsSettings">SegmentHeap</heapType>
-        </asmv3:windowsSettings>
-    </asmv3:application>
-    <compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1">
-        <application>
-            <!-- Windows 10 -->
-            <supportedOS Id="{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}"/>
-            <!-- Windows 8.1 -->
-            <supportedOS Id="{1f676c76-80e1-4239-95bb-83d0f6d0da78}"/>
-            <!-- Windows 8 -->
-            <supportedOS Id="{4a2f28e3-53b9-4441-ba9c-d69d4a4a6e38}"/>
-            <!-- Windows 7 -->
-            <supportedOS Id="{35138b9a-5d96-4fbd-8e2d-a2440225f93a}"/>
-            <!-- Windows Vista -->
-            <supportedOS Id="{e2011457-1546-43c5-a5fe-008deee3d3f0}"/>
-        </application> 
-    </compatibility>
-</assembly>
@@ -1,67 +0,0 @@
-//
-// Compatibility header for older version of SDL.
-// Include this instead of SDL.h directly.
-//
-
-#pragma once
-
-#include <SDL.h>
-
-// SDL_FRect wasn't added until 2.0.10
-#if !SDL_VERSION_ATLEAST(2, 0, 10)
-typedef struct SDL_FRect
-{
-    float x;
-    float y;
-    float w;
-    float h;
-} SDL_FRect;
-#endif
-
-#ifndef SDL_HINT_VIDEO_X11_FORCE_EGL
-#define SDL_HINT_VIDEO_X11_FORCE_EGL "SDL_VIDEO_X11_FORCE_EGL"
-#endif
-
-#ifndef SDL_HINT_KMSDRM_REQUIRE_DRM_MASTER
-#define SDL_HINT_KMSDRM_REQUIRE_DRM_MASTER "SDL_KMSDRM_REQUIRE_DRM_MASTER"
-#endif
-
-#ifndef SDL_HINT_ALLOW_ALT_TAB_WHILE_GRABBED
-#define SDL_HINT_ALLOW_ALT_TAB_WHILE_GRABBED "SDL_ALLOW_ALT_TAB_WHILE_GRABBED"
-#endif
-
-#ifndef SDL_HINT_JOYSTICK_HIDAPI_PS4_RUMBLE
-#define SDL_HINT_JOYSTICK_HIDAPI_PS4_RUMBLE "SDL_JOYSTICK_HIDAPI_PS4_RUMBLE"
-#endif
-
-#ifndef SDL_HINT_JOYSTICK_HIDAPI_PS5_RUMBLE
-#define SDL_HINT_JOYSTICK_HIDAPI_PS5_RUMBLE "SDL_JOYSTICK_HIDAPI_PS5_RUMBLE"
-#endif
-
-#ifndef SDL_HINT_WINDOWS_USE_D3D9EX
-#define SDL_HINT_WINDOWS_USE_D3D9EX "SDL_WINDOWS_USE_D3D9EX"
-#endif
-
-#ifndef SDL_HINT_GAMECONTROLLER_USE_BUTTON_LABELS
-#define SDL_HINT_GAMECONTROLLER_USE_BUTTON_LABELS "SDL_GAMECONTROLLER_USE_BUTTON_LABELS"
-#endif
-
-#ifndef SDL_HINT_MOUSE_RELATIVE_SCALING
-#define SDL_HINT_MOUSE_RELATIVE_SCALING "SDL_MOUSE_RELATIVE_SCALING"
-#endif
-
-#ifndef SDL_HINT_AUDIO_DEVICE_APP_NAME
-#define SDL_HINT_AUDIO_DEVICE_APP_NAME "SDL_AUDIO_DEVICE_APP_NAME"
-#endif
-
-#ifndef SDL_HINT_APP_NAME
-#define SDL_HINT_APP_NAME "SDL_APP_NAME"
-#endif
-
-#ifndef SDL_HINT_MOUSE_AUTO_CAPTURE
-#define SDL_HINT_MOUSE_AUTO_CAPTURE "SDL_MOUSE_AUTO_CAPTURE"
-#endif
-
-#ifndef SDL_HINT_VIDEO_WAYLAND_EMULATE_MOUSE_WARP
-#define SDL_HINT_VIDEO_WAYLAND_EMULATE_MOUSE_WARP "SDL_VIDEO_WAYLAND_EMULATE_MOUSE_WARP"
-#endif
@@ -1,27 +1,7 @@
-QT += core quick network quickcontrols2 svg
-CONFIG += c++17
-
-unix:!macx {
-    TARGET = moonlight
-} else {
-    # On macOS, this is the name displayed in the global menu bar
-    TARGET = Moonlight
-}
-
-include(../globaldefs.pri)
-
-# Precompile QML files to avoid writing qmlcache on portable versions.
-# Since this binds the app against the Qt runtime version, we will only
-# do this for Windows and Mac (when disable-prebuilts is not defined),
-# since they always ship with the matching build of the Qt runtime.
-!disable-prebuilts {
-    win32|macx {
-        CONFIG(release, debug|release) {
-            CONFIG += qtquickcompiler
-        }
-    }
-}
+QT += core quick network quickcontrols2
+CONFIG += c++11

+TARGET = moonlight-qt
 TEMPLATE = app

 # The following define makes your compiler emit warnings if you use
@@ -36,455 +16,84 @@ DEFINES += QT_DEPRECATED_WARNINGS
 DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000    # disables all the APIs deprecated before Qt 6.0.0

 win32 {
-    !exists($$PWD/../libs/windows) {
-        error("Missing dependencies. Please run 'powershell .\setup-deps.ps1' to fetch prebuilt libraries.")
-    }
+    INCLUDEPATH += $$PWD/../libs/windows/include

+    contains(QT_ARCH, i386) {
+        LIBS += -L$$PWD/../libs/windows/lib/x86
+    }
    contains(QT_ARCH, x86_64) {
        LIBS += -L$$PWD/../libs/windows/lib/x64
-        INCLUDEPATH += $$PWD/../libs/windows/include/x64 $$PWD/../libs/windows/include/x64/SDL2
-    }
-    contains(QT_ARCH, arm64) {
-        LIBS += -L$$PWD/../libs/windows/lib/arm64
-        INCLUDEPATH += $$PWD/../libs/windows/include/arm64 $$PWD/../libs/windows/include/arm64/SDL2
    }

-    INCLUDEPATH += $$PWD/../libs/windows/include
-    LIBS += ws2_32.lib winmm.lib dxva2.lib ole32.lib gdi32.lib user32.lib d3d9.lib dwmapi.lib dbghelp.lib
+    LIBS += ws2_32.lib winmm.lib dxva2.lib ole32.lib
 }
-macx:!disable-prebuilts {
-    !exists($$PWD/../libs/mac) {
-        error("Missing dependencies. Please run 'python3 setup-deps.py' to fetch prebuilt libraries.")
-    }
-
-    INCLUDEPATH += $$PWD/../libs/mac/include $$PWD/../libs/mac/include/SDL2
+macx {
+    INCLUDEPATH += $$PWD/../libs/mac/include
    LIBS += -L$$PWD/../libs/mac/lib
 }

-unix:if(!macx|disable-prebuilts) {
+unix:!macx {
    CONFIG += link_pkgconfig
-    PKGCONFIG += openssl sdl2 SDL2_ttf
-
-    # We have our own optimized libopus.a for Steam Link
-    if(!config_SL|disable-prebuilts) {
-        PKGCONFIG += opus
-    }
-
-    !disable-ffmpeg {
-        packagesExist(libavcodec) {
-            PKGCONFIG += libavcodec libavutil libswscale
-            CONFIG += ffmpeg
-
-            !disable-libva {
-                packagesExist(libva) {
-                    !disable-x11 {
-                        packagesExist(libva-x11) {
-                            CONFIG += libva-x11
-                        }
-                    }
-                    !disable-wayland {
-                        packagesExist(libva-wayland) {
-                            CONFIG += libva-wayland
-                        }
-                    }
-                    !disable-libdrm {
-                        packagesExist(libva-drm) {
-                            CONFIG += libva-drm
-                        }
-                    }
-                    CONFIG += libva
-                }
-            }
-
-            !disable-libvdpau {
-                packagesExist(vdpau) {
-                    CONFIG += libvdpau
-                }
-            }
-
-            !disable-mmal {
-                packagesExist(mmal) {
-                    PKGCONFIG += mmal
-                    CONFIG += mmal
-                }
-            }
-
-            !disable-libdrm {
-                packagesExist(libdrm) {
-                    PKGCONFIG += libdrm
-                    CONFIG += libdrm
-                }
-            }
-
-            # Disabled by default due to reliability issues. See #1314.
-            # CUDA interop is superseded by VDPAU and Vulkan Video.
-            enable-cuda {
-                packagesExist(ffnvcodec) {
-                    PKGCONFIG += ffnvcodec
-                    CONFIG += cuda
-                }
-            }
-
-            !disable-libplacebo {
-                packagesExist(libplacebo) {
-                    PKGCONFIG += libplacebo
-                    CONFIG += libplacebo
-                }
-            }
-        }
-
-        !disable-wayland {
-            packagesExist(wayland-client) {
-                CONFIG += wayland
-                PKGCONFIG += wayland-client
-            }
-        }
-
-        !disable-x11 {
-            packagesExist(x11) {
-                DEFINES += HAS_X11
-                PKGCONFIG += x11
-            }
-        }
-    }
+    PKGCONFIG += openssl sdl2 libavcodec libavdevice libavformat libavutil
 }
 win32 {
-    LIBS += -llibssl -llibcrypto -lSDL2 -lSDL2_ttf -lavcodec -lavutil -lswscale -lopus -ldxgi -ld3d11 -llibplacebo
-    CONFIG += ffmpeg libplacebo
-}
-win32:!winrt {
-    CONFIG += discord-rpc
+    LIBS += -llibssl -llibcrypto -lSDL2 -lavcodec -lavdevice -lavformat -lavutil
 }
 macx {
-    !disable-prebuilts {
-        LIBS += -lssl.3 -lcrypto.3 -lavcodec.63 -lavutil.61 -lswscale.10 -lopus.0 -lSDL2 -lSDL2_ttf -lplacebo
-        CONFIG += discord-rpc libplacebo
-    }
-
-    LIBS += -lobjc -framework VideoToolbox -framework AVFoundation -framework CoreVideo -framework CoreGraphics -framework CoreMedia -framework AppKit -framework Metal -framework QuartzCore
-    CONFIG += ffmpeg
+    LIBS += -lssl -lcrypto -lSDL2 -lavcodec.58 -lavdevice.58 -lavformat.58 -lavutil.56
+    LIBS += -lobjc -framework VideoToolbox -framework AVFoundation -framework CoreVideo -framework CoreMedia -framework AppKit
 }

 SOURCES += \
-    backend/nvaddress.cpp \
-    backend/nvapp.cpp \
-    cli/pair.cpp \
    main.cpp \
-    backend/computerseeker.cpp \
    backend/identitymanager.cpp \
-    backend/nvcomputer.cpp \
    backend/nvhttp.cpp \
    backend/nvpairingmanager.cpp \
    backend/computermanager.cpp \
    backend/boxartmanager.cpp \
-    backend/richpresencemanager.cpp \
-    cli/commandlineparser.cpp \
-    cli/listapps.cpp \
-    cli/quitstream.cpp \
-    cli/startstream.cpp \
-    settings/compatfetcher.cpp \
-    settings/mappingfetcher.cpp \
    settings/streamingpreferences.cpp \
-    streaming/input/abstouch.cpp \
-    streaming/input/gamepad.cpp \
-    streaming/input/input.cpp \
-    streaming/input/keyboard.cpp \
-    streaming/input/mouse.cpp \
-    streaming/input/reltouch.cpp \
+    streaming/input.cpp \
    streaming/session.cpp \
-    streaming/audio/audio.cpp \
-    streaming/audio/renderers/sdlaud.cpp \
+    streaming/audio.cpp \
+    streaming/video/ffmpeg.cpp \
    gui/computermodel.cpp \
    gui/appmodel.cpp \
-    streaming/bandwidth.cpp \
-    streaming/streamutils.cpp \
-    backend/autoupdatechecker.cpp \
-    path.cpp \
-    settings/mappingmanager.cpp \
-    gui/sdlgamepadkeynavigation.cpp \
-    streaming/video/overlaymanager.cpp \
-    backend/systemproperties.cpp \
-    wm.cpp
+    streaming/video/ffmpeg-renderers/sdl.cpp
+
+win32 {
+    SOURCES += streaming/video/ffmpeg-renderers/dxva2.cpp
+}
+macx {
+    SOURCES += streaming/video/avfoundation.mm
+}

 HEADERS += \
-    SDL_compat.h \
-    backend/nvaddress.h \
-    backend/nvapp.h \
-    cli/pair.h \
-    settings/compatfetcher.h \
-    settings/mappingfetcher.h \
    utils.h \
-    backend/computerseeker.h \
    backend/identitymanager.h \
-    backend/nvcomputer.h \
    backend/nvhttp.h \
    backend/nvpairingmanager.h \
    backend/computermanager.h \
    backend/boxartmanager.h \
-    backend/richpresencemanager.h \
-    cli/commandlineparser.h \
-    cli/listapps.h \
-    cli/quitstream.h \
-    cli/startstream.h \
    settings/streamingpreferences.h \
-    streaming/input/input.h \
-    streaming/session.h \
-    streaming/audio/renderers/renderer.h \
-    streaming/audio/renderers/sdl.h \
+    streaming/input.hpp \
+    streaming/session.hpp \
    gui/computermodel.h \
    gui/appmodel.h \
    streaming/video/decoder.h \
-    streaming/bandwidth.h \
-    streaming/streamutils.h \
-    backend/autoupdatechecker.h \
-    path.h \
-    settings/mappingmanager.h \
-    gui/sdlgamepadkeynavigation.h \
-    streaming/video/overlaymanager.h \
-    backend/systemproperties.h
+    streaming/video/ffmpeg.h \
+    streaming/video/ffmpeg-renderers/renderer.h

-# Platform-specific renderers and decoders
-ffmpeg {
-    message(FFmpeg decoder selected)
-
-    DEFINES += HAVE_FFMPEG
-    SOURCES += \
-        streaming/video/ffmpeg.cpp \
-        streaming/video/ffmpeg-renderers/genhwaccel.cpp \
-        streaming/video/ffmpeg-renderers/sdlvid.cpp \
-        streaming/video/ffmpeg-renderers/swframemapper.cpp \
-        streaming/video/ffmpeg-renderers/pacer/pacer.cpp
-
-    HEADERS += \
-        streaming/video/ffmpeg.h \
-        streaming/video/ffmpeg-renderers/renderer.h \
-        streaming/video/ffmpeg-renderers/genhwaccel.h \
-        streaming/video/ffmpeg-renderers/sdlvid.h \
-        streaming/video/ffmpeg-renderers/swframemapper.h \
-        streaming/video/ffmpeg-renderers/pacer/pacer.h
-}
-libva {
-    message(VAAPI renderer selected)
-
-    PKGCONFIG += libva
-    DEFINES += HAVE_LIBVA
-    SOURCES += streaming/video/ffmpeg-renderers/vaapi.cpp
-    HEADERS += streaming/video/ffmpeg-renderers/vaapi.h
-}
-libva-x11 {
-    message(VAAPI X11 support enabled)
-
-    PKGCONFIG += libva-x11
-    DEFINES += HAVE_LIBVA_X11
-}
-libva-wayland {
-    message(VAAPI Wayland support enabled)
-
-    PKGCONFIG += libva-wayland
-    DEFINES += HAVE_LIBVA_WAYLAND
-}
-libva-drm {
-    message(VAAPI DRM support enabled)
-
-    PKGCONFIG += libva-drm
-    DEFINES += HAVE_LIBVA_DRM
-}
-libvdpau {
-    message(VDPAU renderer selected)
-
-    DEFINES += HAVE_LIBVDPAU
-    SOURCES += streaming/video/ffmpeg-renderers/vdpau.cpp
-    HEADERS += streaming/video/ffmpeg-renderers/vdpau.h
-}
-mmal {
-    message(MMAL renderer selected)
-
-    DEFINES += HAVE_MMAL
-    SOURCES += streaming/video/ffmpeg-renderers/mmal.cpp
-    HEADERS += streaming/video/ffmpeg-renderers/mmal.h
-
-    # We suppress EGL usage when MMAL is available because MMAL has
-    # significantly better performance than EGL on the Pi. Setting
-    # this option allows EGL usage even if built with MMAL support.
-    #
-    # It is highly recommended to also build with 'gpuslow' to avoid
-    # EGL being preferred if direct DRM rendering is available.
-    allow-egl-with-mmal {
-        message(Allowing EGL usage with MMAL enabled)
-
-        DEFINES += ALLOW_EGL_WITH_MMAL
-    }
-}
-libdrm {
-    message(DRM renderer selected)
-
-    DEFINES += HAVE_DRM
-    SOURCES += streaming/video/ffmpeg-renderers/drm.cpp
-    HEADERS += streaming/video/ffmpeg-renderers/drm.h
-
-    linux {
-        !disable-masterhooks {
-            message(Master hooks enabled)
-            DEFINES += HAVE_DRM_MASTER_HOOKS
-            SOURCES += masterhook.c masterhook_internal.c
-            LIBS += -ldl -pthread
-        }
-    }
-}
-cuda {
-    message(CUDA support enabled)
-
-    DEFINES += HAVE_CUDA
-    SOURCES += streaming/video/ffmpeg-renderers/cuda.cpp
-    HEADERS += streaming/video/ffmpeg-renderers/cuda.h
-
-    # ffnvcodec uses libdl in cuda_load_functions()/cuda_free_functions()
-    LIBS += -ldl
-}
-libplacebo {
-    message(Vulkan support enabled via libplacebo)
-
-    DEFINES += HAVE_LIBPLACEBO_VULKAN
-    SOURCES += \
-        streaming/video/ffmpeg-renderers/plvk.cpp \
-        streaming/video/ffmpeg-renderers/plvk_c.c
-    HEADERS += \
-        streaming/video/ffmpeg-renderers/plvk.h
-
-    macx {
-        SOURCES += streaming/video/ffmpeg-renderers/plvk_objc.mm
-    }
-}
-config_EGL {
-    message(EGL renderer selected)
-
-    CONFIG += egl
-    DEFINES += HAVE_EGL
-    SOURCES += \
-        streaming/video/ffmpeg-renderers/eglvid.cpp \
-        streaming/video/ffmpeg-renderers/egl_extensions.cpp \
-        streaming/video/ffmpeg-renderers/eglimagefactory.cpp
-    HEADERS += \
-        streaming/video/ffmpeg-renderers/eglvid.h \
-        streaming/video/ffmpeg-renderers/eglimagefactory.h
-}
-config_SL {
-    message(Steam Link build configuration selected)
-
-    !disable-prebuilts {
-        # Link against our NEON-optimized libopus build
-        LIBS += -L$$PWD/../libs/steamlink/lib
-        INCLUDEPATH += $$PWD/../libs/steamlink/include
-        LIBS += -lopus -larmasm -lNE10
-    }
-
-    DEFINES += EMBEDDED_BUILD STEAM_LINK HAVE_SLVIDEO HAVE_SLAUDIO
-    LIBS += -lSLVideo -lSLAudio
-
-    SOURCES += \
-        streaming/video/slvid.cpp \
-        streaming/audio/renderers/slaud.cpp
-    HEADERS += \
-        streaming/video/slvid.h \
-        streaming/audio/renderers/slaud.h
-}
 win32 {
-    HEADERS += streaming/video/ffmpeg-renderers/dxutil.h
-}
-win32:!winrt {
-    message(DXVA2 and D3D11VA renderers selected)
-
-    SOURCES += \
-        streaming/video/ffmpeg-renderers/dxva2.cpp \
-        streaming/video/ffmpeg-renderers/d3d11va.cpp \
-        streaming/video/ffmpeg-renderers/pacer/dxvsyncsource.cpp
-
-    HEADERS += \
-        streaming/video/ffmpeg-renderers/dxva2.h \
-        streaming/video/ffmpeg-renderers/d3d11va.h \
-        streaming/video/ffmpeg-renderers/pacer/dxvsyncsource.h
+    HEADERS += streaming/video/ffmpeg-renderers/dxva2.h
 }
 macx {
-    message(VideoToolbox renderer selected)
-
-    SOURCES += \
-        streaming/video/ffmpeg-renderers/vt_base.mm \
-        streaming/video/ffmpeg-renderers/vt_avsamplelayer.mm \
-        streaming/video/ffmpeg-renderers/vt_metal.mm
-
-    HEADERS += \
-        streaming/video/ffmpeg-renderers/vt.h
-}
-discord-rpc {
-    message(Discord integration enabled)
-
-    LIBS += -ldiscord-rpc
-    DEFINES += HAVE_DISCORD
-}
-embedded {
-    message(Embedded build)
-
-    DEFINES += EMBEDDED_BUILD
-}
-glslow {
-    message(GL slow build)
-
-    DEFINES += GL_IS_SLOW
-}
-vkslow {
-    message(Vulkan slow build)
-
-    DEFINES += VULKAN_IS_SLOW
-}
-gpuslow {
-    message(GPU slow build)
-
-    DEFINES += GL_IS_SLOW VULKAN_IS_SLOW
-}
-wayland {
-    message(Wayland extensions enabled)
-
-    DEFINES += HAS_WAYLAND
-    SOURCES += streaming/video/ffmpeg-renderers/pacer/waylandvsyncsource.cpp
-    HEADERS += streaming/video/ffmpeg-renderers/pacer/waylandvsyncsource.h
+    HEADERS += streaming/video/avfoundation.h
 }

 RESOURCES += \
    resources.qrc \
    qml.qrc

-TRANSLATIONS += \
-    languages/qml_zh_CN.ts \
-    languages/qml_de.ts \
-    languages/qml_fr.ts \
-    languages/qml_nb_NO.ts \
-    languages/qml_ru.ts \
-    languages/qml_es.ts \
-    languages/qml_ja.ts \
-    languages/qml_vi.ts \
-    languages/qml_th.ts \
-    languages/qml_ko.ts \
-    languages/qml_hu.ts \
-    languages/qml_nl.ts \
-    languages/qml_sv.ts \
-    languages/qml_tr.ts \
-    languages/qml_uk.ts \
-    languages/qml_zh_TW.ts \
-    languages/qml_el.ts \
-    languages/qml_hi.ts \
-    languages/qml_it.ts \
-    languages/qml_pt.ts \
-    languages/qml_pt_BR.ts \
-    languages/qml_pl.ts \
-    languages/qml_cs.ts \
-    languages/qml_he.ts \
-    languages/qml_ckb.ts \
-    languages/qml_lt.ts \
-    languages/qml_et.ts \
-    languages/qml_bg.ts \
-    languages/qml_eo.ts \
-    languages/qml_ta.ts
-
 # Additional import path used to resolve QML modules in Qt Creator's code model
 QML_IMPORT_PATH =

@@ -498,6 +107,13 @@ else:unix: LIBS += -L$$OUT_PWD/../moonlight-common-c/ -lmoonlight-common-c
 INCLUDEPATH += $$PWD/../moonlight-common-c/moonlight-common-c/src
 DEPENDPATH += $$PWD/../moonlight-common-c/moonlight-common-c/src

+win32:CONFIG(release, debug|release): LIBS += -L$$OUT_PWD/../opus/release/ -lopus
+else:win32:CONFIG(debug, debug|release): LIBS += -L$$OUT_PWD/../opus/debug/ -lopus
+else:unix: LIBS += -L$$OUT_PWD/../opus/ -lopus
+
+INCLUDEPATH += $$PWD/../opus/opus/include
+DEPENDPATH += $$PWD/../opus/opus/include
+
 win32:CONFIG(release, debug|release): LIBS += -L$$OUT_PWD/../qmdnsengine/release/ -lqmdnsengine
 else:win32:CONFIG(debug, debug|release): LIBS += -L$$OUT_PWD/../qmdnsengine/debug/ -lqmdnsengine
 else:unix: LIBS += -L$$OUT_PWD/../qmdnsengine/ -lqmdnsengine
@@ -505,78 +121,14 @@ else:unix: LIBS += -L$$OUT_PWD/../qmdnsengine/ -lqmdnsengine
 INCLUDEPATH += $$PWD/../qmdnsengine/qmdnsengine/src/include $$PWD/../qmdnsengine
 DEPENDPATH += $$PWD/../qmdnsengine/qmdnsengine/src/include $$PWD/../qmdnsengine

-win32:CONFIG(release, debug|release): LIBS += -L$$OUT_PWD/../h264bitstream/release/ -lh264bitstream
-else:win32:CONFIG(debug, debug|release): LIBS += -L$$OUT_PWD/../h264bitstream/debug/ -lh264bitstream
-else:unix: LIBS += -L$$OUT_PWD/../h264bitstream/ -lh264bitstream
+# Default rules for deployment.
+qnx: target.path = /tmp/$${TARGET}/bin
+else: unix:!android: target.path = /opt/$${TARGET}/bin
+!isEmpty(target.path): INSTALLS += target

-INCLUDEPATH += $$PWD/../h264bitstream
-DEPENDPATH += $$PWD/../h264bitstream
-
-!winrt {
-    win32:CONFIG(release, debug|release): LIBS += -L$$OUT_PWD/../AntiHooking/release/ -lAntiHooking
-    else:win32:CONFIG(debug, debug|release): LIBS += -L$$OUT_PWD/../AntiHooking/debug/ -lAntiHooking
-
-    INCLUDEPATH += $$PWD/../AntiHooking
-    DEPENDPATH += $$PWD/../AntiHooking
-}
-
-unix:!macx: {
-    isEmpty(PREFIX) {
-        PREFIX = /usr/local
-    }
-    isEmpty(BINDIR) {
-        BINDIR = bin
-    }
-    isEmpty(DATADIR) {
-        DATADIR = share
-    }
-
-    target.path = $$PREFIX/$$BINDIR/
-
-    desktop.files = deploy/linux/com.moonlight_stream.Moonlight.desktop
-    desktop.path = $$PREFIX/$$DATADIR/applications/
-
-    icons.files = res/moonlight.svg
-    icons.path = $$PREFIX/$$DATADIR/icons/hicolor/scalable/apps/
-
-    appstream.files = deploy/linux/com.moonlight_stream.Moonlight.appdata.xml
-    appstream.path = $$PREFIX/$$DATADIR/metainfo/
-
-    INSTALLS += target desktop icons appstream
-}
-win32 {
-    RC_ICONS = moonlight.ico
-    QMAKE_TARGET_COMPANY = Moonlight Game Streaming Project
-    QMAKE_TARGET_DESCRIPTION = Moonlight Game Streaming Client
-    QMAKE_TARGET_PRODUCT = Moonlight
-
-    CONFIG -= embed_manifest_exe
-    QMAKE_LFLAGS += /MANIFEST:embed /MANIFESTINPUT:$${PWD}/Moonlight.exe.manifest
-}
 macx {
-    # Create Info.plist in object dir with the correct version string
-    system(cp $$PWD/Info.plist $$OUT_PWD/Info.plist)
-    system(sed -i -e 's/VERSION/$$cat(version.txt)/g' $$OUT_PWD/Info.plist)
-
-    QMAKE_INFO_PLIST = $$OUT_PWD/Info.plist
-
-    APP_BUNDLE_RESOURCES.files = moonlight.icns
-    APP_BUNDLE_RESOURCES.path = Contents/Resources
-
-    APP_BUNDLE_PLIST.files = $$OUT_PWD/Info.plist
-    APP_BUNDLE_PLIST.path = Contents
-
-    QMAKE_BUNDLE_DATA += APP_BUNDLE_RESOURCES APP_BUNDLE_PLIST
-
-    !disable-prebuilts {
-        APP_BUNDLE_FRAMEWORKS.files = $$files(../libs/mac/Frameworks/*.framework, true) $$files(../libs/mac/lib/*.dylib, true)
-        APP_BUNDLE_FRAMEWORKS.path = Contents/Frameworks
-
-        QMAKE_BUNDLE_DATA += APP_BUNDLE_FRAMEWORKS
-
-        QMAKE_RPATHDIR += @executable_path/../Frameworks
-    }
+    QMAKE_INFO_PLIST = $$PWD/Info.plist
+    APP_QML_FILES.files = res/macos.icns
+    APP_QML_FILES.path = Contents/Resources
+    QMAKE_BUNDLE_DATA += APP_QML_FILES
 }
-
-VERSION = "$$cat(version.txt)"
-DEFINES += VERSION_STR=\\\"$$cat(version.txt)\\\"
@@ -1,218 +0,0 @@
-#include "autoupdatechecker.h"
-
-#include <QNetworkReply>
-#include <QJsonDocument>
-#include <QJsonArray>
-#include <QJsonObject>
-
-AutoUpdateChecker::AutoUpdateChecker(QObject *parent) :
-    QObject(parent)
-{
-    m_Nam = new QNetworkAccessManager(this);
-
-    // Never communicate over HTTP
-    m_Nam->setStrictTransportSecurityEnabled(true);
-
-    // Allow HTTP redirects
-    m_Nam->setRedirectPolicy(QNetworkRequest::NoLessSafeRedirectPolicy);
-
-    connect(m_Nam, &QNetworkAccessManager::finished,
-            this, &AutoUpdateChecker::handleUpdateCheckRequestFinished);
-
-    QString currentVersion(VERSION_STR);
-    qDebug() << "Current Moonlight version:" << currentVersion;
-    parseStringToVersionQuad(currentVersion, m_CurrentVersionQuad);
-
-    // Should at least have a 1.0-style version number
-    Q_ASSERT(m_CurrentVersionQuad.count() > 1);
-}
-
-void AutoUpdateChecker::start()
-{
-    if (!m_Nam) {
-        Q_ASSERT(m_Nam);
-        return;
-    }
-
-#if defined(Q_OS_WIN32) || defined(Q_OS_DARWIN) || defined(STEAM_LINK) || defined(APP_IMAGE) // Only run update checker on platforms without auto-update
-#if QT_VERSION >= QT_VERSION_CHECK(5, 14, 0) && QT_VERSION < QT_VERSION_CHECK(5, 15, 1) && !defined(QT_NO_BEARERMANAGEMENT)
-    // HACK: Set network accessibility to work around QTBUG-80947 (introduced in Qt 5.14.0 and fixed in Qt 5.15.1)
-    QT_WARNING_PUSH
-    QT_WARNING_DISABLE_DEPRECATED
-    m_Nam->setNetworkAccessible(QNetworkAccessManager::Accessible);
-    QT_WARNING_POP
-#endif
-
-    // We'll get a callback when this is finished
-    QUrl url("https://moonlight-stream.org/updates/qt.json");
-    QNetworkRequest request(url);
-#if QT_VERSION >= QT_VERSION_CHECK(5, 15, 0)
-    request.setAttribute(QNetworkRequest::Http2AllowedAttribute, true);
-#else
-    request.setAttribute(QNetworkRequest::HTTP2AllowedAttribute, true);
-#endif
-    m_Nam->get(request);
-#endif
-}
-
-void AutoUpdateChecker::parseStringToVersionQuad(QString& string, QVector<int>& version)
-{
-    QStringList list = string.split('.');
-    for (const QString& component : std::as_const(list)) {
-        version.append(component.toInt());
-    }
-}
-
-QString AutoUpdateChecker::getPlatform()
-{
-#if defined(STEAM_LINK)
-    return QStringLiteral("steamlink");
-#elif defined(APP_IMAGE)
-    return QStringLiteral("appimage");
-#elif defined(Q_OS_DARWIN) && QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
-    // Qt 6 changed this from 'osx' to 'macos'. Use the old one
-    // to be consistent (and not require another entry in the manifest).
-    return QStringLiteral("osx");
-#else
-    return QSysInfo::productType();
-#endif
-}
-
-int AutoUpdateChecker::compareVersion(QVector<int>& version1, QVector<int>& version2) {
-    for (int i = 0;; i++) {
-        int v1Val = 0;
-        int v2Val = 0;
-
-        // Treat missing decimal places as 0
-        if (i < version1.count()) {
-            v1Val = version1[i];
-        }
-        if (i < version2.count()) {
-            v2Val = version2[i];
-        }
-        if (i >= version1.count() && i >= version2.count()) {
-            // Equal versions
-            return 0;
-        }
-
-        if (v1Val < v2Val) {
-            return -1;
-        }
-        else if (v1Val > v2Val) {
-            return 1;
-        }
-    }
-}
-
-void AutoUpdateChecker::handleUpdateCheckRequestFinished(QNetworkReply* reply)
-{
-    Q_ASSERT(reply->isFinished());
-
-    // Delete the QNetworkAccessManager to free resources and
-    // prevent the bearer plugin from polling in the background.
-    m_Nam->deleteLater();
-    m_Nam = nullptr;
-
-    if (reply->error() == QNetworkReply::NoError) {
-        QTextStream stream(reply);
-
-#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
-        stream.setEncoding(QStringConverter::Utf8);
-#else
-        stream.setCodec("UTF-8");
-#endif
-
-        // Read all data and queue the reply for deletion
-        QString jsonString = stream.readAll();
-        reply->deleteLater();
-
-        QJsonParseError error;
-        QJsonDocument jsonDoc = QJsonDocument::fromJson(jsonString.toUtf8(), &error);
-        if (jsonDoc.isNull()) {
-            qWarning() << "Update manifest malformed:" << error.errorString();
-            return;
-        }
-
-        QJsonArray array = jsonDoc.array();
-        if (array.isEmpty()) {
-            qWarning() << "Update manifest doesn't contain an array";
-            return;
-        }
-
-        for (const auto& updateEntry : std::as_const(array)) {
-            if (updateEntry.isObject()) {
-                QJsonObject updateObj = updateEntry.toObject();
-                if (!updateObj.contains("platform") ||
-                        !updateObj.contains("arch") ||
-                        !updateObj.contains("version") ||
-                        !updateObj.contains("browser_url")) {
-                    qWarning() << "Update manifest entry missing vital field";
-                    continue;
-                }
-
-                if (!updateObj["platform"].isString() ||
-                        !updateObj["arch"].isString() ||
-                        !updateObj["version"].isString() ||
-                        !updateObj["browser_url"].isString()) {
-                    qWarning() << "Update manifest entry has unexpected vital field type";
-                    continue;
-                }
-
-                if (updateObj["arch"] == QSysInfo::buildCpuArchitecture() &&
-                        updateObj["platform"] == getPlatform()) {
-
-                    // Check the kernel version minimum if one exists
-                    if (updateObj.contains("kernel_version_at_least") && updateObj["kernel_version_at_least"].isString()) {
-                        QVector<int> requiredVersionQuad;
-                        QVector<int> actualVersionQuad;
-
-                        QString requiredVersion = updateObj["kernel_version_at_least"].toString();
-                        QString actualVersion = QSysInfo::kernelVersion();
-                        parseStringToVersionQuad(requiredVersion, requiredVersionQuad);
-                        parseStringToVersionQuad(actualVersion, actualVersionQuad);
-
-                        if (compareVersion(actualVersionQuad, requiredVersionQuad) < 0) {
-                            qDebug() << "Skipping manifest entry due to kernel version (" << actualVersion << "<" << requiredVersion << ")";
-                            continue;
-                        }
-                    }
-
-                    qDebug() << "Found update manifest match for current platform";
-
-                    QString latestVersion = updateObj["version"].toString();
-                    qDebug() << "Latest version of Moonlight for this platform is:" << latestVersion;
-
-                    QVector<int> latestVersionQuad;
-                    parseStringToVersionQuad(latestVersion, latestVersionQuad);
-
-                    int res = compareVersion(m_CurrentVersionQuad, latestVersionQuad);
-                    if (res < 0) {
-                        // m_CurrentVersionQuad < latestVersionQuad
-                        qDebug() << "Update available";
-                        emit onUpdateAvailable(updateObj["version"].toString(),
-                                               updateObj["browser_url"].toString());
-                        return;
-                    }
-                    else if (res > 0) {
-                        qDebug() << "Update manifest version lower than current version";
-                        return;
-                    }
-                    else {
-                        qDebug() << "Update manifest version equal to current version";
-                        return;
-                    }
-                }
-            }
-            else {
-                qWarning() << "Update manifest contained unrecognized entry:" << updateEntry.toString();
-            }
-        }
-
-        qWarning() << "No entry in update manifest found for current platform:"
-                   << QSysInfo::buildCpuArchitecture() << getPlatform() << QSysInfo::kernelVersion();
-    }
-    else {
-        qWarning() << "Update checking failed with error:" << reply->error();
-        reply->deleteLater();
-    }
-}
@@ -1,29 +0,0 @@
-#pragma once
-
-#include <QObject>
-#include <QNetworkAccessManager>
-
-class AutoUpdateChecker : public QObject
-{
-    Q_OBJECT
-public:
-    explicit AutoUpdateChecker(QObject *parent = nullptr);
-
-    Q_INVOKABLE void start();
-
-signals:
-    void onUpdateAvailable(QString newVersion, QString url);
-
-private slots:
-    void handleUpdateCheckRequestFinished(QNetworkReply* reply);
-
-private:
-    void parseStringToVersionQuad(QString& string, QVector<int>& version);
-
-    int compareVersion(QVector<int>& version1, QVector<int>& version2);
-
-    QString getPlatform();
-
-    QVector<int> m_CurrentVersionQuad;
-    QNetworkAccessManager* m_Nam;
-};
@@ -1,19 +1,14 @@
 #include "boxartmanager.h"
-#include "../path.h"

+#include <QStandardPaths>
 #include <QImageReader>
 #include <QImageWriter>

 BoxArtManager::BoxArtManager(QObject *parent) :
    QObject(parent),
-    m_BoxArtDir(Path::getBoxArtCacheDir()),
-    m_ThreadPool(this)
+    m_BoxArtDir(
+        QStandardPaths::writableLocation(QStandardPaths::CacheLocation) + "/boxart")
 {
-    // 4 is a good balance between fast loading for large
-    // app grids and not crushing GFE with tons of requests
-    // and causing UI jank from constantly stalling to decode
-    // new images.
-    m_ThreadPool.setMaxThreadCount(4);
    if (!m_BoxArtDir.exists()) {
        m_BoxArtDir.mkpath(".");
    }
@@ -36,77 +31,35 @@ BoxArtManager::getFilePathForBoxArt(NvComputer* computer, int appId)
    return dir.filePath(QString::number(appId) + ".png");
 }

-class NetworkBoxArtLoadTask : public QObject, public QRunnable
-{
-    Q_OBJECT
-
-public:
-    NetworkBoxArtLoadTask(BoxArtManager* boxArtManager, NvComputer* computer, NvApp& app)
-        : m_Bam(boxArtManager),
-          m_Computer(computer),
-          m_App(app)
-    {
-        connect(this, &NetworkBoxArtLoadTask::boxArtFetchCompleted,
-                boxArtManager, &BoxArtManager::handleBoxArtLoadComplete);
-    }
-
-signals:
-    void boxArtFetchCompleted(NvComputer* computer, NvApp app, QUrl image);
-
-private:
-    void run()
-    {
-        QUrl image = m_Bam->loadBoxArtFromNetwork(m_Computer, m_App.id);
-        if (image.isEmpty()) {
-            // Give it another shot if it fails once
-            image = m_Bam->loadBoxArtFromNetwork(m_Computer, m_App.id);
-        }
-        emit boxArtFetchCompleted(m_Computer, m_App, image);
-    }
-
-    BoxArtManager* m_Bam;
-    NvComputer* m_Computer;
-    NvApp m_App;
-};
-
 QUrl BoxArtManager::loadBoxArt(NvComputer* computer, NvApp& app)
 {
-    // Try to open the cached file if it exists and contains data
-    QFile cacheFile(getFilePathForBoxArt(computer, app.id));
-    if (cacheFile.exists() && cacheFile.size() > 0) {
-        return QUrl::fromLocalFile(cacheFile.fileName());
+    // Try to open the cached file
+    QString cacheFilePath = getFilePathForBoxArt(computer, app.id);
+    if (QFile::exists(cacheFilePath)) {
+        return QUrl::fromLocalFile(cacheFilePath);
    }

    // If we get here, we need to fetch asynchronously.
    // Kick off a worker on our thread pool to do just that.
    NetworkBoxArtLoadTask* netLoadTask = new NetworkBoxArtLoadTask(this, computer, app);
-    m_ThreadPool.start(netLoadTask);
+    QThreadPool::globalInstance()->start(netLoadTask);

    // Return the placeholder then we can notify the caller
    // later when the real image is ready.
    return QUrl("qrc:/res/no_app_image.png");
 }

-void BoxArtManager::deleteBoxArt(NvComputer* computer)
-{
-    QDir dir(Path::getBoxArtCacheDir());
-
-    // Delete everything in this computer's box art directory
-    if (dir.cd(computer->uuid)) {
-        dir.removeRecursively();
-    }
-}
-
 void BoxArtManager::handleBoxArtLoadComplete(NvComputer* computer, NvApp app, QUrl image)
 {
-    if (!image.isEmpty()) {
-        emit boxArtLoadComplete(computer, app, image);
+    if (image.isEmpty()) {
+        image = QUrl("qrc:/res/no_app_image.png");
    }
+    emit boxArtLoadComplete(computer, app, image);
 }

 QUrl BoxArtManager::loadBoxArtFromNetwork(NvComputer* computer, int appId)
 {
-    NvHTTP http(computer);
+    NvHTTP http(computer->activeAddress);

    QString cachePath = getFilePathForBoxArt(computer, appId);
    QImage image;
@@ -119,13 +72,7 @@ QUrl BoxArtManager::loadBoxArtFromNetwork(NvComputer* computer, int appId)
        if (image.save(cachePath)) {
            return QUrl::fromLocalFile(cachePath);
        }
-        else {
-            // A failed save() may leave a zero byte file. Make sure that's removed.
-            QFile(cachePath).remove();
-        }
    }

    return QUrl();
 }
-
-#include "boxartmanager.moc"
@@ -18,10 +18,6 @@ public:
    QUrl
    loadBoxArt(NvComputer* computer, NvApp& app);

-    static
-    void
-    deleteBoxArt(NvComputer* computer);
-
 signals:
    void
    boxArtLoadComplete(NvComputer* computer, NvApp app, QUrl image);
@@ -40,5 +36,37 @@ private:
    getFilePathForBoxArt(NvComputer* computer, int appId);

    QDir m_BoxArtDir;
-    QThreadPool m_ThreadPool;
+};
+
+class NetworkBoxArtLoadTask : public QObject, public QRunnable
+{
+    Q_OBJECT
+
+public:
+    NetworkBoxArtLoadTask(BoxArtManager* boxArtManager, NvComputer* computer, NvApp& app)
+        : m_Bam(boxArtManager),
+          m_Computer(computer),
+          m_App(app)
+    {
+        connect(this, SIGNAL(boxArtFetchCompleted(NvComputer*,NvApp,QUrl)),
+                boxArtManager, SLOT(handleBoxArtLoadComplete(NvComputer*,NvApp,QUrl)));
+    }
+
+signals:
+    void boxArtFetchCompleted(NvComputer* computer, NvApp app, QUrl image);
+
+private:
+    void run()
+    {
+        QUrl image = m_Bam->loadBoxArtFromNetwork(m_Computer, m_App.id);
+        if (image.isEmpty()) {
+            // Give it another shot if it fails once
+            image = m_Bam->loadBoxArtFromNetwork(m_Computer, m_App.id);
+        }
+        emit boxArtFetchCompleted(m_Computer, m_App, image);
+    }
+
+    BoxArtManager* m_Bam;
+    NvComputer* m_Computer;
+    NvApp m_App;
 };
@@ -1,8 +1,6 @@
 #pragma once
-
-#include "nvcomputer.h"
-#include "settings/streamingpreferences.h"
-#include "settings/compatfetcher.h"
+#include "nvhttp.h"
+#include "nvpairingmanager.h"

 #include <qmdnsengine/server.h>
 #include <qmdnsengine/cache.h>
@@ -14,27 +12,194 @@
 #include <QReadWriteLock>
 #include <QSettings>
 #include <QRunnable>
-#include <QTimer>
-#include <QMutex>
-#include <QWaitCondition>

-class ComputerManager;
+class NvComputer
+{
+    friend class PcMonitorThread;

-class DelayedFlushThread : public QThread
+private:
+    void sortAppList();
+
+public:
+    explicit NvComputer(QString address, QString serverInfo);
+
+    explicit NvComputer(QSettings& settings);
+
+    bool
+    update(NvComputer& that);
+
+    bool
+    wake();
+
+    QVector<QString>
+    uniqueAddresses();
+
+    void
+    serialize(QSettings& settings);
+
+    enum PairState
+    {
+        PS_UNKNOWN,
+        PS_PAIRED,
+        PS_NOT_PAIRED
+    };
+
+    enum ComputerState
+    {
+        CS_UNKNOWN,
+        CS_ONLINE,
+        CS_OFFLINE
+    };
+
+    // Ephemeral traits
+    ComputerState state;
+    PairState pairState;
+    QString activeAddress;
+    int currentGameId;
+    QString gfeVersion;
+    QString appVersion;
+    QVector<NvDisplayMode> displayModes;
+    int maxLumaPixelsHEVC;
+    int serverCodecModeSupport;
+
+    // Persisted traits
+    QString localAddress;
+    QString remoteAddress;
+    QString manualAddress;
+    QByteArray macAddress;
+    QString name;
+    QString uuid;
+    QVector<NvApp> appList;
+
+    // Synchronization
+    QReadWriteLock lock;
+};
+
+// FIXME: MOC isn't finding Q_OBJECT properly when this is confined
+// to computermanager.cpp as it should be.
+class PcMonitorThread : public QThread
 {
    Q_OBJECT

+#define TRIES_BEFORE_OFFLINING 2
+#define POLLS_PER_APPLIST_FETCH 10
+
 public:
-    DelayedFlushThread(ComputerManager* cm)
-        : m_ComputerManager(cm)
+    PcMonitorThread(NvComputer* computer)
+        : m_Computer(computer)
    {
-        setObjectName("CM Delayed Flush Thread");
+        setObjectName("Polling thread for " + computer->name);
    }

-    void run();
+private:
+    bool tryPollComputer(QString address, bool& changed)
+    {
+        NvHTTP http(address);
+
+        QString serverInfo;
+        try {
+            serverInfo = http.getServerInfo();
+        } catch (...) {
+            return false;
+        }
+
+        NvComputer newState(address, serverInfo);
+
+        // Ensure the machine that responded is the one we intended to contact
+        if (m_Computer->uuid != newState.uuid) {
+            qInfo() << "Found unexpected PC " << newState.name << " looking for " << m_Computer->name;
+            return false;
+        }
+
+        changed = m_Computer->update(newState);
+        return true;
+    }
+
+    bool updateAppList(bool& changed)
+    {
+        Q_ASSERT(m_Computer->activeAddress != nullptr);
+
+        NvHTTP http(m_Computer->activeAddress);
+
+        QVector<NvApp> appList;
+
+        try {
+            appList = http.getAppList();
+            if (appList.isEmpty()) {
+                return false;
+            }
+        } catch (...) {
+            return false;
+        }
+
+        QWriteLocker lock(&m_Computer->lock);
+        if (m_Computer->appList != appList) {
+            m_Computer->appList = appList;
+            m_Computer->sortAppList();
+            changed = true;
+        }
+
+        return true;
+    }
+
+    void run() override
+    {
+        // Always fetch the applist the first time
+        int pollsSinceLastAppListFetch = POLLS_PER_APPLIST_FETCH;
+        while (!isInterruptionRequested()) {
+            bool stateChanged = false;
+            for (int i = 0; i < TRIES_BEFORE_OFFLINING; i++) {
+                for (auto& address : m_Computer->uniqueAddresses()) {
+                    if (isInterruptionRequested()) {
+                        return;
+                    }
+
+                    if (tryPollComputer(address, stateChanged)) {
+                        break;
+                    }
+                }
+
+                // No need to continue retrying if we're online
+                if (m_Computer->state == NvComputer::CS_ONLINE) {
+                    break;
+                }
+            }
+
+            // Check if we failed after all retry attempts
+            // Note: we don't need to acquire the read lock here,
+            // because we're on the writing thread.
+            if (m_Computer->state != NvComputer::CS_ONLINE) {
+                if (m_Computer->state != NvComputer::CS_OFFLINE) {
+                    m_Computer->state = NvComputer::CS_OFFLINE;
+                    stateChanged = true;
+                }
+            }
+
+            // Grab the applist if it's empty or it's been long enough that we need to refresh
+            pollsSinceLastAppListFetch++;
+            if (m_Computer->state == NvComputer::CS_ONLINE &&
+                    m_Computer->pairState == NvComputer::PS_PAIRED &&
+                    (m_Computer->appList.isEmpty() || pollsSinceLastAppListFetch >= POLLS_PER_APPLIST_FETCH)) {
+                if (updateAppList(stateChanged)) {
+                    pollsSinceLastAppListFetch = 0;
+                }
+            }
+
+            if (stateChanged) {
+                // Tell anyone listening that we've changed state
+                emit computerStateChanged(m_Computer);
+            }
+
+            // Wait a bit to poll again
+            QThread::sleep(3);
+        }
+    }
+
+signals:
+   void computerStateChanged(NvComputer* computer);

 private:
-    ComputerManager* m_ComputerManager;
+    NvComputer* m_Computer;
 };

 class MdnsPendingComputer : public QObject
@@ -42,20 +207,14 @@ class MdnsPendingComputer : public QObject
    Q_OBJECT

 public:
-    explicit MdnsPendingComputer(const QSharedPointer<QMdnsEngine::Server> server,
+    explicit MdnsPendingComputer(QMdnsEngine::Server* server,
+                                 QMdnsEngine::Cache* cache,
                                 const QMdnsEngine::Service& service)
        : m_Hostname(service.hostname()),
-          m_Port(service.port()),
-          m_ServerWeak(server),
-          m_Resolver(nullptr)
+          m_Resolver(server, m_Hostname, cache)
    {
-        // Start resolving
-        resolve();
-    }
-
-    virtual ~MdnsPendingComputer()
-    {
-        delete m_Resolver;
+        connect(&m_Resolver, SIGNAL(resolved(QHostAddress)),
+                this, SLOT(handleResolved(QHostAddress)));
    }

    QString hostname()
@@ -63,148 +222,21 @@ public:
        return m_Hostname;
    }

-    uint16_t port()
-    {
-        return m_Port;
-    }
-
 private slots:
-    void handleResolvedTimeout()
+    void handleResolved(const QHostAddress& address)
    {
-        if (m_Addresses.isEmpty()) {
-            if (m_Retries-- > 0) {
-                // Try again
-                qInfo() << "Resolving" << hostname() << "timed out. Retrying...";
-                resolve();
-            }
-            else {
-                qWarning() << "Giving up on resolving" << hostname() << "after repeated failures";
-                cleanup();
-            }
+        if (address.protocol() == QAbstractSocket::IPv4Protocol) {
+            m_Resolver.disconnect();
+            emit resolvedv4(this, address);
        }
-        else {
-            Q_ASSERT(!m_Addresses.isEmpty());
-            emit resolvedHost(this, m_Addresses);
-        }
-    }
-
-    void handleResolvedAddress(const QHostAddress& address)
-    {
-        m_Addresses.push_back(address);
    }

 signals:
-    void resolvedHost(MdnsPendingComputer*,QVector<QHostAddress>&);
+    void resolvedv4(MdnsPendingComputer*, const QHostAddress&);

 private:
-    void cleanup()
-    {
-        // Delete our resolver, so we're guaranteed that nothing is referencing m_Server.
-        delete m_Resolver;
-        m_Resolver = nullptr;
-
-        // Now delete our strong reference that we held on behalf of m_Resolver.
-        // The server may be destroyed after we make this call.
-        m_Server.reset();
-    }
-
-    void resolve()
-    {
-        // Clean up any existing resolver object and server references
-        cleanup();
-
-        // Re-acquire a strong reference if the server still exists.
-        m_Server = m_ServerWeak.toStrongRef();
-        if (!m_Server) {
-            return;
-        }
-
-        m_Resolver = new QMdnsEngine::Resolver(m_Server.data(), m_Hostname);
-        connect(m_Resolver, &QMdnsEngine::Resolver::resolved,
-                this, &MdnsPendingComputer::handleResolvedAddress);
-        QTimer::singleShot(2000, this, &MdnsPendingComputer::handleResolvedTimeout);
-    }
-
    QByteArray m_Hostname;
-    uint16_t m_Port;
-    QWeakPointer<QMdnsEngine::Server> m_ServerWeak;
-    QSharedPointer<QMdnsEngine::Server> m_Server;
-    QMdnsEngine::Resolver* m_Resolver;
-    QVector<QHostAddress> m_Addresses;
-    int m_Retries = 10;
-};
-
-class ComputerPollingEntry
-{
-public:
-    ComputerPollingEntry()
-        : m_ActiveThread(nullptr)
-    {
-
-    }
-
-    virtual ~ComputerPollingEntry()
-    {
-        interrupt();
-
-        // interrupt() should have taken care of this
-        Q_ASSERT(m_ActiveThread == nullptr);
-
-        for (QThread* thread : std::as_const(m_InactiveList)) {
-            thread->wait();
-            delete thread;
-        }
-    }
-
-    bool isActive()
-    {
-        cleanInactiveList();
-
-        return m_ActiveThread != nullptr;
-    }
-
-    void setActiveThread(QThread* thread)
-    {
-        cleanInactiveList();
-
-        Q_ASSERT(!isActive());
-        m_ActiveThread = thread;
-    }
-
-    void interrupt()
-    {
-        cleanInactiveList();
-
-        if (m_ActiveThread != nullptr) {
-            // Interrupt the active thread
-            m_ActiveThread->requestInterruption();
-
-            // Place it on the inactive list awaiting death
-            m_InactiveList.append(m_ActiveThread);
-
-            m_ActiveThread = nullptr;
-        }
-    }
-
-private:
-    void cleanInactiveList()
-    {
-        QMutableListIterator<QThread*> i(m_InactiveList);
-
-        // Reap any threads that have finished
-        while (i.hasNext()) {
-            i.next();
-
-            QThread* thread = i.value();
-            if (thread->isFinished()) {
-                delete thread;
-                i.remove();
-            }
-        }
-    }
-
-    QThread* m_ActiveThread;
-    QList<QThread*> m_InactiveList;
+    QMdnsEngine::Resolver m_Resolver;
 };

 class ComputerManager : public QObject
@@ -213,74 +245,185 @@ class ComputerManager : public QObject

    friend class DeferredHostDeletionTask;
    friend class PendingAddTask;
-    friend class PendingPairingTask;
-    friend class DelayedFlushThread;

 public:
-    explicit ComputerManager(StreamingPreferences* prefs);
-
-    virtual ~ComputerManager();
+    explicit ComputerManager(QObject *parent = nullptr);

    Q_INVOKABLE void startPolling();

    Q_INVOKABLE void stopPollingAsync();

-    Q_INVOKABLE void addNewHostManually(QString address);
-
-    void addNewHost(NvAddress address, bool mdns, QString name = QString(), NvAddress mdnsIpv6Address = NvAddress());
-
-    QString generatePinString();
+    Q_INVOKABLE void addNewHost(QString address, bool mdns);

    void pairHost(NvComputer* computer, QString pin);

-    void quitRunningApp(NvComputer* computer);
-
    QVector<NvComputer*> getComputers();

    // computer is deleted inside this call
    void deleteHost(NvComputer* computer);

-    void renameHost(NvComputer* computer, QString name);
-
-    void clientSideAttributeUpdated(NvComputer* computer);
-
 signals:
    void computerStateChanged(NvComputer* computer);

    void pairingCompleted(NvComputer* computer, QString error);

-    void computerAddCompleted(QVariant success, QVariant detectedPortBlocking);
-
-    void quitAppCompleted(QVariant error);
+    void computerAddCompleted(QVariant success);

 private slots:
-    void handleAboutToQuit();
-
    void handleComputerStateChanged(NvComputer* computer);

-    void handleMdnsServiceResolved(MdnsPendingComputer* computer, QVector<QHostAddress>& addresses);
+    void handleMdnsServiceResolved(MdnsPendingComputer* computer, const QHostAddress& address);

 private:
    void saveHosts();

-    void saveHost(NvComputer* computer);
-
-    QHostAddress getBestGlobalAddressV6(QVector<QHostAddress>& addresses);
-
    void startPollingComputer(NvComputer* computer);

-    StreamingPreferences* m_Prefs;
    int m_PollingRef;
    QReadWriteLock m_Lock;
    QMap<QString, NvComputer*> m_KnownHosts;
-    QMap<QString, ComputerPollingEntry*> m_PollEntries;
-    QHash<QString, NvComputer> m_LastSerializedHosts; // Protected by m_DelayedFlushMutex
-    QSharedPointer<QMdnsEngine::Server> m_MdnsServer;
+    QMap<QString, QThread*> m_PollThreads;
+    QMdnsEngine::Server m_MdnsServer;
    QMdnsEngine::Browser* m_MdnsBrowser;
+    QMdnsEngine::Cache m_MdnsCache;
    QVector<MdnsPendingComputer*> m_PendingResolution;
-    CompatFetcher m_CompatFetcher;
-    DelayedFlushThread* m_DelayedFlushThread;
-    QMutex m_DelayedFlushMutex; // Lock ordering: Must never be acquired while holding NvComputer lock
-    QWaitCondition m_DelayedFlushCondition;
-    bool m_NeedsDelayedFlush;
+};
+
+class PendingPairingTask : public QObject, public QRunnable
+{
+    Q_OBJECT
+
+public:
+    PendingPairingTask(ComputerManager* computerManager, NvComputer* computer, QString pin)
+        : m_Computer(computer),
+          m_Pin(pin)
+    {
+        connect(this, &PendingPairingTask::pairingCompleted,
+                computerManager, &ComputerManager::pairingCompleted);
+    }
+
+signals:
+    void pairingCompleted(NvComputer* computer, QString error);
+
+private:
+    void run()
+    {
+        NvPairingManager pairingManager(m_Computer->activeAddress);
+
+        try {
+           NvPairingManager::PairState result = pairingManager.pair(m_Computer->appVersion, m_Pin);
+           switch (result)
+           {
+           case NvPairingManager::PairState::PIN_WRONG:
+               emit pairingCompleted(m_Computer, "The PIN from the PC didn't match. Please try again.");
+               break;
+           case NvPairingManager::PairState::FAILED:
+               emit pairingCompleted(m_Computer, "Pairing failed. Please try again.");
+               break;
+           case NvPairingManager::PairState::ALREADY_IN_PROGRESS:
+               emit pairingCompleted(m_Computer, "Another pairing attempt is already in progress.");
+               break;
+           case NvPairingManager::PairState::PAIRED:
+               emit pairingCompleted(m_Computer, nullptr);
+               break;
+           }
+        } catch (const GfeHttpResponseException& e) {
+            emit pairingCompleted(m_Computer, e.toQString());
+        }
+    }
+
+    NvComputer* m_Computer;
+    QString m_Pin;
+};
+
+class PendingAddTask : public QObject, public QRunnable
+{
+    Q_OBJECT
+
+public:
+    PendingAddTask(ComputerManager* computerManager, QString address, bool mdns)
+        : m_ComputerManager(computerManager),
+          m_Address(address),
+          m_Mdns(mdns)
+    {
+        connect(this, &PendingAddTask::computerAddCompleted,
+                computerManager, &ComputerManager::computerAddCompleted);
+        connect(this, &PendingAddTask::computerStateChanged,
+                computerManager, &ComputerManager::handleComputerStateChanged);
+    }
+
+signals:
+    void computerAddCompleted(QVariant success);
+
+    void computerStateChanged(NvComputer* computer);
+
+private:
+    void run()
+    {
+        NvHTTP http(m_Address);
+
+        QString serverInfo;
+        try {
+            serverInfo = http.getServerInfo();
+        } catch (...) {
+            if (!m_Mdns) {
+                emit computerAddCompleted(false);
+            }
+            return;
+        }
+
+        NvComputer* newComputer = new NvComputer(m_Address, serverInfo);
+
+        // Update addresses depending on the context
+        if (m_Mdns) {
+            newComputer->localAddress = m_Address;
+        }
+        else {
+            newComputer->manualAddress = m_Address;
+        }
+
+        // Check if this PC already exists
+        QWriteLocker lock(&m_ComputerManager->m_Lock);
+        NvComputer* existingComputer = m_ComputerManager->m_KnownHosts[newComputer->uuid];
+        if (existingComputer != nullptr) {
+            // Fold it into the existing PC
+            bool changed = existingComputer->update(*newComputer);
+            delete newComputer;
+
+            // Drop the lock before notifying
+            lock.unlock();
+
+            // For non-mDNS clients, let them know it succeeded
+            if (!m_Mdns) {
+                emit computerAddCompleted(true);
+            }
+
+            // Tell our client if something changed
+            if (changed) {
+                emit computerStateChanged(existingComputer);
+            }
+        }
+        else {
+            // Store this in our active sets
+            m_ComputerManager->m_KnownHosts[newComputer->uuid] = newComputer;
+
+            // Start polling if enabled (write lock required)
+            m_ComputerManager->startPollingComputer(newComputer);
+
+            // Drop the lock before notifying
+            lock.unlock();
+
+            // For non-mDNS clients, let them know it succeeded
+            if (!m_Mdns) {
+                emit computerAddCompleted(true);
+            }
+
+            // Tell our client about this new PC
+            emit computerStateChanged(newComputer);
+        }
+    }
+
+    ComputerManager* m_ComputerManager;
+    QString m_Address;
+    bool m_Mdns;
 };
@@ -1,90 +0,0 @@
-#include "computerseeker.h"
-#include "computermanager.h"
-#include <QTimer>
-
-ComputerSeeker::ComputerSeeker(ComputerManager *manager, QString computerName, QObject *parent)
-    : QObject(parent), m_ComputerManager(manager), m_ComputerName(computerName),
-      m_TimeoutTimer(new QTimer(this))
-{
-    // If we know this computer, send a WOL packet to wake it up in case it is asleep.
-    NvComputer* matchingComputer = findMatchingComputer();
-    if (matchingComputer) {
-        matchingComputer->wake();
-    }
-
-    m_TimeoutTimer->setSingleShot(true);
-    connect(m_TimeoutTimer, &QTimer::timeout,
-            this, &ComputerSeeker::onTimeout);
-    connect(m_ComputerManager, &ComputerManager::computerStateChanged,
-            this, &ComputerSeeker::onComputerUpdated);
-}
-
-void ComputerSeeker::start(int timeout)
-{
-    m_TimeoutTimer->start(timeout);
-
-    // If we don't know this computer by name, address, or UUID, try adding it
-    // manually and see if we can find it by address, hostname, or mDNS.
-    //
-    // NB: We don't do this unconditionally because it will wipe out the user's
-    // manual address if they pass another reachable hostname/address.
-    if (!findMatchingComputer()) {
-        m_ComputerManager->addNewHostManually(m_ComputerName);
-    }
-
-    m_ComputerManager->startPolling();
-}
-
-void ComputerSeeker::onComputerUpdated(NvComputer *computer)
-{
-    if (!m_TimeoutTimer->isActive()) {
-        return;
-    }
-    if (matchComputer(computer) && isOnline(computer)) {
-        m_ComputerManager->stopPollingAsync();
-        m_TimeoutTimer->stop();
-        emit computerFound(computer);
-    }
-}
-
-bool ComputerSeeker::matchComputer(NvComputer *computer) const
-{
-    QString value = m_ComputerName.toLower();
-
-    if (computer->name.toLower() == value || computer->uuid.toLower() == value) {
-        return true;
-    }
-
-    const auto uniqueAddresses = computer->uniqueAddresses();
-    for (const NvAddress& addr : uniqueAddresses) {
-        if (addr.address().toLower() == value || addr.toString().toLower() == value) {
-            return true;
-        }
-    }
-
-    return false;
-}
-
-NvComputer* ComputerSeeker::findMatchingComputer() const
-{
-    const auto computers = m_ComputerManager->getComputers();
-    for (NvComputer* computer : computers) {
-        if (this->matchComputer(computer)) {
-            return computer;
-        }
-    }
-
-    return nullptr;
-}
-
-bool ComputerSeeker::isOnline(NvComputer *computer) const
-{
-    return computer->state == NvComputer::CS_ONLINE;
-}
-
-void ComputerSeeker::onTimeout()
-{
-    m_TimeoutTimer->stop();
-    m_ComputerManager->stopPollingAsync();
-    emit errorTimeout();
-}
@@ -1,34 +0,0 @@
-#pragma once
-
-#include <QObject>
-
-class ComputerManager;
-class NvComputer;
-class QTimer;
-
-class ComputerSeeker : public QObject
-{
-    Q_OBJECT
-public:
-    explicit ComputerSeeker(ComputerManager *manager, QString computerName, QObject *parent = nullptr);
-
-    void start(int timeout);
-
-signals:
-    void computerFound(NvComputer *computer);
-    void errorTimeout();
-
-private slots:
-    void onComputerUpdated(NvComputer *computer);
-    void onTimeout();
-
-private:
-    bool matchComputer(NvComputer *computer) const;
-    NvComputer* findMatchingComputer() const;
-    bool isOnline(NvComputer *computer) const;
-
-private:
-    ComputerManager *m_ComputerManager;
-    QString m_ComputerName;
-    QTimer *m_TimeoutTimer;
-};
@@ -2,11 +2,12 @@
 #include "utils.h"

 #include <QDebug>
+#include <QRandomGenerator64>

 #include <openssl/pem.h>
 #include <openssl/rsa.h>
+#include <openssl/bn.h>
 #include <openssl/x509.h>
-#include <openssl/rand.h>

 #define SER_UNIQUEID "uniqueid"
 #define SER_CERT "certificate"
@@ -31,23 +32,19 @@ void IdentityManager::createCredentials(QSettings& settings)
    X509* cert = X509_new();
    THROW_BAD_ALLOC_IF_NULL(cert);

-#if OPENSSL_VERSION_NUMBER >= 0x30000000L
-    EVP_PKEY* pk = EVP_RSA_gen(2048);
+    EVP_PKEY* pk = EVP_PKEY_new();
    THROW_BAD_ALLOC_IF_NULL(pk);
-#else
-    EVP_PKEY_CTX* ctx = EVP_PKEY_CTX_new_id(EVP_PKEY_RSA, NULL);
-    THROW_BAD_ALLOC_IF_NULL(ctx);

-    EVP_PKEY_keygen_init(ctx);
-    EVP_PKEY_CTX_set_rsa_keygen_bits(ctx, 2048);
+    BIGNUM* bne = BN_new();
+    THROW_BAD_ALLOC_IF_NULL(bne);

-    // pk must be initialized on input
-    EVP_PKEY* pk = NULL;
-    EVP_PKEY_keygen(ctx, &pk);
+    RSA* rsa = RSA_new();
+    THROW_BAD_ALLOC_IF_NULL(rsa);

-    EVP_PKEY_CTX_free(ctx);
-    THROW_BAD_ALLOC_IF_NULL(pk);
-#endif
+    BN_set_word(bne, RSA_F4);
+    RSA_generate_key_ex(rsa, 2048, bne, nullptr);
+
+    EVP_PKEY_assign_RSA(pk, rsa);

    X509_set_version(cert, 2);
    ASN1_INTEGER_set(X509_get_serialNumber(cert), 0);
@@ -55,22 +52,30 @@ void IdentityManager::createCredentials(QSettings& settings)
    X509_gmtime_adj(X509_get_notBefore(cert), 0);
    X509_gmtime_adj(X509_get_notAfter(cert), 60 * 60 * 24 * 365 * 20); // 20 yrs
 #else
-    X509_gmtime_adj(X509_getm_notBefore(cert), 0);
-    X509_gmtime_adj(X509_getm_notAfter(cert), 60 * 60 * 24 * 365 * 20); // 20 yrs
+    ASN1_TIME* before = ASN1_STRING_dup(X509_get0_notBefore(cert));
+    THROW_BAD_ALLOC_IF_NULL(before);
+    ASN1_TIME* after = ASN1_STRING_dup(X509_get0_notAfter(cert));
+    THROW_BAD_ALLOC_IF_NULL(after);
+
+    X509_gmtime_adj(before, 0);
+    X509_gmtime_adj(after, 60 * 60 * 24 * 365 * 20); // 20 yrs
+
+    X509_set1_notBefore(cert, before);
+    X509_set1_notAfter(cert, after);
+
+    ASN1_STRING_free(before);
+    ASN1_STRING_free(after);
 #endif

    X509_set_pubkey(cert, pk);

-    X509_NAME* name = X509_NAME_new();
-    THROW_BAD_ALLOC_IF_NULL(name);
+    X509_NAME* name = X509_get_subject_name(cert);
    X509_NAME_add_entry_by_txt(name, "CN", MBSTRING_ASC,
                               reinterpret_cast<unsigned char *>(const_cast<char*>("NVIDIA GameStream Client")),
                               -1, -1, 0);
-    X509_set_subject_name(cert, name);
    X509_set_issuer_name(cert, name);
-    X509_NAME_free(name);

-    X509_sign(cert, pk, EVP_sha256());
+    X509_sign(cert, pk, EVP_sha1());

    BIO* biokey = BIO_new(BIO_s_mem());
    THROW_BAD_ALLOC_IF_NULL(biokey);
@@ -89,21 +94,14 @@ void IdentityManager::createCredentials(QSettings& settings)

    X509_free(cert);
    EVP_PKEY_free(pk);
+    BN_free(bne);
    BIO_free(biokey);
    BIO_free(biocert);

-    // Check that the new keypair is valid before persisting it
-    if (getSslCertificate().isNull()) {
-        qFatal("Newly generated certificate is unreadable");
-    }
-    if (getSslKey().isNull()) {
-        qFatal("Newly generated private key is unreadable");
-    }
-
    settings.setValue(SER_CERT, m_CachedPemCert);
    settings.setValue(SER_KEY, m_CachedPrivateKey);

-    qInfo() << "Wrote new identity credentials to settings";
+    qDebug() << "Wrote new identity credentials to settings";
 }

 IdentityManager::IdentityManager()
@@ -114,7 +112,7 @@ IdentityManager::IdentityManager()
    m_CachedPrivateKey = settings.value(SER_KEY).toByteArray();

    if (m_CachedPemCert.isEmpty() || m_CachedPrivateKey.isEmpty()) {
-        qInfo() << "No existing credentials found";
+        qDebug() << "No existing credentials found";
        createCredentials(settings);
    }
    else if (getSslCertificate().isNull()) {
@@ -128,26 +126,10 @@ IdentityManager::IdentityManager()

    // We should have valid credentials now. If not, we're screwed
    if (getSslCertificate().isNull()) {
-        qFatal("Certificate is unreadable");
+        qFatal("Newly generated certificate is unreadable");
    }
    if (getSslKey().isNull()) {
-        qFatal("Private key is unreadable");
-    }
-
-    // Load the unique ID from settings
-    m_CachedUniqueId = settings.value(SER_UNIQUEID).toString();
-    if (!m_CachedUniqueId.isEmpty()) {
-        qInfo() << "Loaded unique ID from settings:" << m_CachedUniqueId;
-    }
-    else {
-        // Generate a new unique ID in base 16
-        uint64_t uid;
-        RAND_bytes(reinterpret_cast<unsigned char*>(&uid), sizeof(uid));
-        m_CachedUniqueId = QString::number(uid, 16);
-
-        qInfo() << "Generated new unique ID:" << m_CachedUniqueId;
-
-        settings.setValue(SER_UNIQUEID, m_CachedUniqueId);
+        qFatal("Newly generated private key is unreadable");
    }
 }

@@ -164,10 +146,7 @@ QSslKey
 IdentityManager::getSslKey()
 {
    if (m_CachedSslKey.isNull()) {
-        // This seemingly useless const_cast is required for old OpenSSL headers
-        // where BIO_new_mem_buf's parameter is not declared const like those on
-        // the Steam Link hardware.
-        BIO* bio = BIO_new_mem_buf(const_cast<char*>(m_CachedPrivateKey.constData()), -1);
+        BIO* bio = BIO_new_mem_buf(m_CachedPrivateKey.data(), -1);
        THROW_BAD_ALLOC_IF_NULL(bio);

        EVP_PKEY* pk = PEM_read_bio_PrivateKey(bio, nullptr, nullptr, nullptr);
@@ -178,15 +157,11 @@ IdentityManager::getSslKey()

        // We must write out our PEM in the old PKCS1 format for SecureTransport
        // on macOS/iOS to be able to read it.
-#ifdef Q_OS_DARWIN
-        PEM_write_bio_PrivateKey_traditional(bio, pk, nullptr, nullptr, 0, nullptr, 0);
-#else
-        PEM_write_bio_PrivateKey(bio, pk, nullptr, nullptr, 0, nullptr, 0);
-#endif
-
        BUF_MEM* mem;
        BIO_get_mem_ptr(bio, &mem);
-        m_CachedSslKey = QSslKey(QByteArray(mem->data, (int)mem->length), QSsl::Rsa);
+        PEM_write_bio_PrivateKey_traditional(bio, pk, nullptr, nullptr, 0, nullptr, 0);
+
+        m_CachedSslKey = QSslKey(QByteArray::fromRawData(mem->data, (int)mem->length), QSsl::Rsa);

        BIO_free(bio);
        EVP_PKEY_free(pk);
@@ -206,6 +181,24 @@ IdentityManager::getSslConfig()
 QString
 IdentityManager::getUniqueId()
 {
+    if (m_CachedUniqueId.isNull()) {
+        QSettings settings;
+
+        // Load the unique ID from settings
+        m_CachedUniqueId = settings.value(SER_UNIQUEID).toString();
+        if (!m_CachedUniqueId.isEmpty() && !m_CachedUniqueId.isNull()) {
+            qDebug() << "Loaded unique ID from settings: " << m_CachedUniqueId;
+        }
+        else {
+            // Generate a new unique ID in base 16
+            m_CachedUniqueId = QString::number(
+                        QRandomGenerator64::securelySeeded().generate64(), 16);
+
+            qDebug() << "Generated new unique ID: " << m_CachedUniqueId;
+
+            settings.setValue(SER_UNIQUEID, m_CachedUniqueId);
+        }
+    }
    return m_CachedUniqueId;
 }

@@ -1,65 +0,0 @@
-#include "nvaddress.h"
-
-#include <QHostAddress>
-
-NvAddress::NvAddress()
-{
-    setAddress(nullptr);
-    setPort(0);
-}
-
-NvAddress::NvAddress(QString addr, uint16_t port)
-{
-    setAddress(addr);
-    setPort(port);
-}
-
-NvAddress::NvAddress(QHostAddress addr, uint16_t port)
-{
-    setAddress(addr);
-    setPort(port);
-}
-
-uint16_t NvAddress::port() const
-{
-    return m_Port;
-}
-
-QString NvAddress::address() const
-{
-    return m_Address;
-}
-
-void NvAddress::setPort(uint16_t port)
-{
-    m_Port = port;
-}
-
-void NvAddress::setAddress(QString addr)
-{
-    m_Address = addr;
-}
-
-void NvAddress::setAddress(QHostAddress addr)
-{
-    m_Address = addr.toString();
-}
-
-bool NvAddress::isNull() const
-{
-    return m_Address.isEmpty();
-}
-
-QString NvAddress::toString() const
-{
-    if (m_Address.isEmpty()) {
-        return "<NULL>";
-    }
-
-    if (QHostAddress(m_Address).protocol() == QAbstractSocket::IPv6Protocol) {
-        return QString("[%1]:%2").arg(m_Address).arg(m_Port);
-    }
-    else {
-        return QString("%1:%2").arg(m_Address).arg(m_Port);
-    }
-}
@@ -1,39 +0,0 @@
-#pragma once
-
-#include <QHostAddress>
-
-#define DEFAULT_HTTP_PORT 47989
-#define DEFAULT_HTTPS_PORT 47984
-
-class NvAddress
-{
-public:
-    NvAddress();
-    explicit NvAddress(QString addr, uint16_t port);
-    explicit NvAddress(QHostAddress addr, uint16_t port);
-
-    uint16_t port() const;
-    void setPort(uint16_t port);
-
-    QString address() const;
-    void setAddress(QString addr);
-    void setAddress(QHostAddress addr);
-
-    bool isNull() const;
-    QString toString() const;
-
-    bool operator==(const NvAddress& other) const
-    {
-        return m_Address == other.m_Address &&
-                m_Port == other.m_Port;
-    }
-
-    bool operator!=(const NvAddress& other) const
-    {
-        return !operator==(other);
-    }
-
-private:
-    QString m_Address;
-    uint16_t m_Port;
-};
@@ -1,28 +0,0 @@
-#include "nvapp.h"
-
-#define SER_APPNAME "name"
-#define SER_APPID "id"
-#define SER_APPHDR "hdr"
-#define SER_APPCOLLECTOR "appcollector"
-#define SER_HIDDEN "hidden"
-#define SER_DIRECTLAUNCH "directlaunch"
-
-NvApp::NvApp(QSettings& settings)
-{
-    name = settings.value(SER_APPNAME).toString();
-    id = settings.value(SER_APPID).toInt();
-    hdrSupported = settings.value(SER_APPHDR).toBool();
-    isAppCollectorGame = settings.value(SER_APPCOLLECTOR).toBool();
-    hidden = settings.value(SER_HIDDEN).toBool();
-    directLaunch = settings.value(SER_DIRECTLAUNCH).toBool();
-}
-
-void NvApp::serialize(QSettings& settings) const
-{
-    settings.setValue(SER_APPNAME, name);
-    settings.setValue(SER_APPID, id);
-    settings.setValue(SER_APPHDR, hdrSupported);
-    settings.setValue(SER_APPCOLLECTOR, isAppCollectorGame);
-    settings.setValue(SER_HIDDEN, hidden);
-    settings.setValue(SER_DIRECTLAUNCH, directLaunch);
-}
@@ -1,44 +0,0 @@
-#pragma once
-
-#include <QSettings>
-
-class NvApp
-{
-public:
-    NvApp() {}
-    explicit NvApp(QSettings& settings);
-
-    bool operator==(const NvApp& other) const
-    {
-        return id == other.id &&
-                name == other.name &&
-                hdrSupported == other.hdrSupported &&
-                isAppCollectorGame == other.isAppCollectorGame &&
-                hidden == other.hidden &&
-                directLaunch == other.directLaunch;
-    }
-
-    bool operator!=(const NvApp& other) const
-    {
-        return !operator==(other);
-    }
-
-    bool isInitialized()
-    {
-        // We use isNull() instead of isEmpty() here because we want
-        // to detect cases where the name is unassigned, not empty.
-        return id != 0 && !name.isNull();
-    }
-
-    void
-    serialize(QSettings& settings) const;
-
-    int id = 0;
-    QString name;
-    bool hdrSupported = false;
-    bool isAppCollectorGame = false;
-    bool hidden = false;
-    bool directLaunch = false;
-};
-
-Q_DECLARE_METATYPE(NvApp)
@@ -1,581 +0,0 @@
-#include "nvcomputer.h"
-#include "nvapp.h"
-#include "settings/compatfetcher.h"
-
-#include <QUdpSocket>
-#include <QHostInfo>
-#include <QNetworkInterface>
-#include <QNetworkProxy>
-
-#define SER_NAME "hostname"
-#define SER_UUID "uuid"
-#define SER_MAC "mac"
-#define SER_LOCALADDR "localaddress"
-#define SER_LOCALPORT "localport"
-#define SER_REMOTEADDR "remoteaddress"
-#define SER_REMOTEPORT "remoteport"
-#define SER_MANUALADDR "manualaddress"
-#define SER_MANUALPORT "manualport"
-#define SER_IPV6ADDR "ipv6address"
-#define SER_IPV6PORT "ipv6port"
-#define SER_APPLIST "apps"
-#define SER_SRVCERT "srvcert"
-#define SER_CUSTOMNAME "customname"
-#define SER_NVIDIASOFTWARE "nvidiasw"
-
-NvComputer::NvComputer(QSettings& settings)
-{
-    this->name = settings.value(SER_NAME).toString();
-    this->uuid = settings.value(SER_UUID).toString();
-    this->hasCustomName = settings.value(SER_CUSTOMNAME).toBool();
-    this->macAddress = settings.value(SER_MAC).toByteArray();
-    this->localAddress = NvAddress(settings.value(SER_LOCALADDR).toString(),
-                                   settings.value(SER_LOCALPORT, QVariant(DEFAULT_HTTP_PORT)).toUInt());
-    this->remoteAddress = NvAddress(settings.value(SER_REMOTEADDR).toString(),
-                                    settings.value(SER_REMOTEPORT, QVariant(DEFAULT_HTTP_PORT)).toUInt());
-    this->ipv6Address = NvAddress(settings.value(SER_IPV6ADDR).toString(),
-                                  settings.value(SER_IPV6PORT, QVariant(DEFAULT_HTTP_PORT)).toUInt());
-    this->manualAddress = NvAddress(settings.value(SER_MANUALADDR).toString(),
-                                    settings.value(SER_MANUALPORT, QVariant(DEFAULT_HTTP_PORT)).toUInt());
-    this->serverCert = QSslCertificate(settings.value(SER_SRVCERT).toByteArray());
-    this->isNvidiaServerSoftware = settings.value(SER_NVIDIASOFTWARE).toBool();
-
-    int appCount = settings.beginReadArray(SER_APPLIST);
-    this->appList.reserve(appCount);
-    for (int i = 0; i < appCount; i++) {
-        settings.setArrayIndex(i);
-
-        NvApp app(settings);
-        this->appList.append(app);
-    }
-    settings.endArray();
-    sortAppList();
-
-    this->currentGameId = 0;
-    this->pairState = PS_UNKNOWN;
-    this->state = CS_UNKNOWN;
-    this->gfeVersion = nullptr;
-    this->appVersion = nullptr;
-    this->maxLumaPixelsHEVC = 0;
-    this->serverCodecModeSupport = 0;
-    this->pendingQuit = false;
-    this->gpuModel = nullptr;
-    this->isSupportedServerVersion = true;
-    this->externalPort = this->remoteAddress.port();
-    this->activeHttpsPort = 0;
-}
-
-void NvComputer::setRemoteAddress(QHostAddress address)
-{
-    QWriteLocker lock(&this->lock);
-
-    Q_ASSERT(this->externalPort != 0);
-
-    this->remoteAddress = NvAddress(address, this->externalPort);
-}
-
-void NvComputer::serialize(QSettings& settings, bool serializeApps) const
-{
-    QReadLocker lock(&this->lock);
-
-    settings.setValue(SER_NAME, name);
-    settings.setValue(SER_CUSTOMNAME, hasCustomName);
-    settings.setValue(SER_UUID, uuid);
-    settings.setValue(SER_MAC, macAddress);
-    settings.setValue(SER_LOCALADDR, localAddress.address());
-    settings.setValue(SER_LOCALPORT, localAddress.port());
-    settings.setValue(SER_REMOTEADDR, remoteAddress.address());
-    settings.setValue(SER_REMOTEPORT, remoteAddress.port());
-    settings.setValue(SER_IPV6ADDR, ipv6Address.address());
-    settings.setValue(SER_IPV6PORT, ipv6Address.port());
-    settings.setValue(SER_MANUALADDR, manualAddress.address());
-    settings.setValue(SER_MANUALPORT, manualAddress.port());
-    settings.setValue(SER_SRVCERT, serverCert.toPem());
-    settings.setValue(SER_NVIDIASOFTWARE, isNvidiaServerSoftware);
-
-    // Avoid deleting an existing applist if we couldn't get one
-    if (!appList.isEmpty() && serializeApps) {
-        settings.remove(SER_APPLIST);
-        settings.beginWriteArray(SER_APPLIST);
-        for (int i = 0; i < appList.count(); i++) {
-            settings.setArrayIndex(i);
-            appList.at(i).serialize(settings);
-        }
-        settings.endArray();
-    }
-}
-
-bool NvComputer::isEqualSerialized(const NvComputer &that) const
-{
-    return this->name == that.name &&
-           this->hasCustomName == that.hasCustomName &&
-           this->uuid == that.uuid &&
-           this->macAddress == that.macAddress &&
-           this->localAddress == that.localAddress &&
-           this->remoteAddress == that.remoteAddress &&
-           this->ipv6Address == that.ipv6Address &&
-           this->manualAddress == that.manualAddress &&
-           this->serverCert == that.serverCert &&
-           this->isNvidiaServerSoftware == that.isNvidiaServerSoftware &&
-           this->appList == that.appList;
-}
-
-void NvComputer::sortAppList()
-{
-    std::stable_sort(appList.begin(), appList.end(), [](const NvApp& app1, const NvApp& app2) {
-       return app1.name.toLower() < app2.name.toLower();
-    });
-}
-
-NvComputer::NvComputer(NvHTTP& http, QString serverInfo)
-{
-    this->serverCert = http.serverCert();
-
-    this->hasCustomName = false;
-    this->name = NvHTTP::getXmlString(serverInfo, "hostname");
-    if (this->name.isEmpty()) {
-        this->name = "UNKNOWN";
-    }
-
-    this->uuid = NvHTTP::getXmlString(serverInfo, "uniqueid");
-    QString newMacString = NvHTTP::getXmlString(serverInfo, "mac");
-    if (newMacString != "00:00:00:00:00:00") {
-        QStringList macOctets = newMacString.split(':');
-        for (const QString& macOctet : std::as_const(macOctets)) {
-            this->macAddress.append((char) macOctet.toInt(nullptr, 16));
-        }
-    }
-
-    QString codecSupport = NvHTTP::getXmlString(serverInfo, "ServerCodecModeSupport");
-    if (!codecSupport.isEmpty()) {
-        this->serverCodecModeSupport = codecSupport.toInt();
-    }
-    else {
-        // Assume H.264 is always supported
-        this->serverCodecModeSupport = SCM_H264;
-    }
-
-    QString maxLumaPixelsHEVC = NvHTTP::getXmlString(serverInfo, "MaxLumaPixelsHEVC");
-    if (!maxLumaPixelsHEVC.isEmpty()) {
-        this->maxLumaPixelsHEVC = maxLumaPixelsHEVC.toInt();
-    }
-    else {
-        this->maxLumaPixelsHEVC = 0;
-    }
-
-    this->displayModes = NvHTTP::getDisplayModeList(serverInfo);
-    std::stable_sort(this->displayModes.begin(), this->displayModes.end(),
-                     [](const NvDisplayMode& mode1, const NvDisplayMode& mode2) {
-        return (uint64_t)mode1.width * mode1.height * mode1.refreshRate <
-                (uint64_t)mode2.width * mode2.height * mode2.refreshRate;
-    });
-
-    // We can get an IPv4 loopback address if we're using the GS IPv6 Forwarder
-    this->localAddress = NvAddress(NvHTTP::getXmlString(serverInfo, "LocalIP"), http.httpPort());
-    if (this->localAddress.address().startsWith("127.")) {
-        this->localAddress = NvAddress();
-    }
-
-    QString httpsPort = NvHTTP::getXmlString(serverInfo, "HttpsPort");
-    if (httpsPort.isEmpty() || (this->activeHttpsPort = httpsPort.toUShort()) == 0) {
-        this->activeHttpsPort = DEFAULT_HTTPS_PORT;
-    }
-
-    // This is an extension which is not present in GFE. It is present for Sunshine to be able
-    // to support dynamic HTTP WAN ports without requiring the user to manually enter the port.
-    QString remotePortStr = NvHTTP::getXmlString(serverInfo, "ExternalPort");
-    if (remotePortStr.isEmpty() || (this->externalPort = remotePortStr.toUShort()) == 0) {
-        this->externalPort = http.httpPort();
-    }
-
-    QString remoteAddress = NvHTTP::getXmlString(serverInfo, "ExternalIP");
-    if (!remoteAddress.isEmpty()) {
-        this->remoteAddress = NvAddress(remoteAddress, this->externalPort);
-    }
-    else {
-        this->remoteAddress = NvAddress();
-    }
-
-    // Real Nvidia host software (GeForce Experience and RTX Experience) both use the 'Mjolnir'
-    // codename in the state field and no version of Sunshine does. We can use this to bypass
-    // some assumptions about Nvidia hardware that don't apply to Sunshine hosts.
-    this->isNvidiaServerSoftware = NvHTTP::getXmlString(serverInfo, "state").contains("MJOLNIR");
-
-    this->pairState = NvHTTP::getXmlString(serverInfo, "PairStatus") == "1" ?
-                PS_PAIRED : PS_NOT_PAIRED;
-    this->currentGameId = NvHTTP::getCurrentGame(serverInfo);
-    this->appVersion = NvHTTP::getXmlString(serverInfo, "appversion");
-    this->gfeVersion = NvHTTP::getXmlString(serverInfo, "GfeVersion");
-    this->gpuModel = NvHTTP::getXmlString(serverInfo, "gputype");
-    this->activeAddress = http.address();
-    this->state = NvComputer::CS_ONLINE;
-    this->pendingQuit = false;
-    this->isSupportedServerVersion = CompatFetcher::isGfeVersionSupported(this->gfeVersion);
-}
-
-bool NvComputer::wake() const
-{
-    QByteArray wolPayload;
-
-    {
-        QReadLocker readLocker(&lock);
-
-        if (state == NvComputer::CS_ONLINE) {
-            qWarning() << name << "is already online";
-            return true;
-        }
-
-        if (macAddress.isEmpty()) {
-            qWarning() << name << "has no MAC address stored";
-            return false;
-        }
-
-        // Create the WoL payload
-        wolPayload.append(QByteArray::fromHex("FFFFFFFFFFFF"));
-        for (int i = 0; i < 16; i++) {
-            wolPayload.append(macAddress);
-        }
-        Q_ASSERT(wolPayload.size() == 102);
-    }
-
-    // Ports used as-is
-    const quint16 STATIC_WOL_PORTS[] = {
-        9, // Standard WOL port (privileged port)
-        47009, // Port opened by Moonlight Internet Hosting Tool for WoL (non-privileged port)
-    };
-
-    // Ports offset by the HTTP base port for hosts using alternate ports
-    const quint16 DYNAMIC_WOL_PORTS[] = {
-        47998, 47999, 48000, 48002, 48010, // Ports opened by GFE
-    };
-
-    // Add the addresses that we know this host to be
-    // and broadcast addresses for this link just in
-    // case the host has timed out in ARP entries.
-    QMap<QString, quint16> addressMap;
-    QSet<quint16> basePortSet;
-    const auto uniqueHostAddresses = uniqueAddresses();
-    for (const NvAddress& addr : uniqueHostAddresses) {
-        addressMap.insert(addr.address(), addr.port());
-        basePortSet.insert(addr.port());
-    }
-    addressMap.insert("255.255.255.255", 0);
-
-    // Try to broadcast on all available NICs
-    const auto allInterfaces = QNetworkInterface::allInterfaces();
-    for (const QNetworkInterface& nic : allInterfaces) {
-        // Ensure the interface is up and skip the loopback adapter
-        if ((nic.flags() & QNetworkInterface::IsUp) == 0 ||
-                (nic.flags() & QNetworkInterface::IsLoopBack) != 0) {
-            continue;
-        }
-
-        QHostAddress allNodesMulticast("FF02::1");
-        const auto allInterfaceAddresses = nic.addressEntries();
-        for (const QNetworkAddressEntry& addr : allInterfaceAddresses) {
-            // Store the scope ID for this NIC if IPv6 is enabled
-            if (!addr.ip().scopeId().isEmpty()) {
-                allNodesMulticast.setScopeId(addr.ip().scopeId());
-            }
-
-            // Skip IPv6 which doesn't support broadcast
-            if (!addr.broadcast().isNull()) {
-                addressMap.insert(addr.broadcast().toString(), 0);
-            }
-        }
-
-        if (!allNodesMulticast.scopeId().isEmpty()) {
-            addressMap.insert(allNodesMulticast.toString(), 0);
-        }
-    }
-
-    // Try all unique address strings or host names
-    bool success = false;
-    for (auto i = addressMap.constBegin(); i != addressMap.constEnd(); i++) {
-        QHostAddress literalAddress;
-        QList<QHostAddress> addressList;
-
-        // If this is an IPv4/IPv6 literal, don't use QHostInfo::fromName() because that will
-        // try to perform a reverse DNS lookup that leads to delays sending WoL packets.
-        if (literalAddress.setAddress(i.key())) {
-            addressList.append(literalAddress);
-        }
-        else {
-            QHostInfo hostInfo = QHostInfo::fromName(i.key());
-            if (hostInfo.error() != QHostInfo::NoError) {
-                qWarning() << "Error resolving" << i.key() << ":" << hostInfo.errorString();
-                continue;
-            }
-
-            addressList.append(hostInfo.addresses());
-        }
-
-        // Try all IP addresses that this string resolves to
-        for (QHostAddress& address : addressList) {
-            QUdpSocket sock;
-
-            // Send to all static ports
-            for (quint16 port : STATIC_WOL_PORTS) {
-                if (sock.writeDatagram(wolPayload, address, port)) {
-                    qInfo().nospace().noquote() << "Sent WoL packet to " << name << " via " << address.toString() << ":" << port;
-                    success = true;
-                }
-                else {
-                    qWarning() << "Send failed:" << sock.error();
-                }
-            }
-
-            QList<quint16> basePorts;
-            if (i.value() != 0) {
-                // If we have a known base port for this address, use only that port
-                basePorts.append(i.value());
-            }
-            else {
-                // If this is a broadcast address without a known HTTP port, try all of them
-                basePorts.append(basePortSet.values());
-            }
-
-            // Send to all dynamic ports using the HTTP port offset(s) for this address
-            for (quint16 basePort : basePorts) {
-                for (quint16 port : DYNAMIC_WOL_PORTS) {
-                    port = (port - 47989) + basePort;
-
-                    if (sock.writeDatagram(wolPayload, address, port)) {
-                        qInfo().nospace().noquote() << "Sent WoL packet to " << name << " via " << address.toString() << ":" << port;
-                        success = true;
-                    }
-                    else {
-                        qWarning() << "Send failed:" << sock.error();
-                    }
-                }
-            }
-        }
-    }
-
-    return success;
-}
-
-NvComputer::ReachabilityType NvComputer::getActiveAddressReachability() const
-{
-    NvAddress copyOfActiveAddress;
-
-    {
-        QReadLocker readLocker(&lock);
-
-        if (activeAddress.isNull()) {
-            return ReachabilityType::RI_UNKNOWN;
-        }
-
-        // Grab a copy of the active address to avoid having to hold
-        // the computer lock while doing socket operations
-        copyOfActiveAddress = activeAddress;
-    }
-
-    QTcpSocket s;
-    s.setProxy(QNetworkProxy::NoProxy);
-    s.connectToHost(copyOfActiveAddress.address(), copyOfActiveAddress.port());
-    if (s.waitForConnected(3000)) {
-        Q_ASSERT(!s.localAddress().isNull());
-        Q_ASSERT(!s.peerAddress().isNull());
-
-        const auto allInterfaces = QNetworkInterface::allInterfaces();
-        for (const QNetworkInterface& nic : allInterfaces) {
-            // Ensure the interface is up
-            if ((nic.flags() & QNetworkInterface::IsUp) == 0) {
-                continue;
-            }
-
-            const auto allInterfaceAddresses = nic.addressEntries();
-            for (const QNetworkAddressEntry& addr : allInterfaceAddresses) {
-                if (addr.ip() == s.localAddress()) {
-                    qInfo() << "Found matching interface:" << nic.humanReadableName() << nic.hardwareAddress() << nic.flags();
-
-#if QT_VERSION >= QT_VERSION_CHECK(5, 11, 0)
-                    qInfo() << "Interface Type:" << nic.type();
-                    qInfo() << "Interface MTU:" << nic.maximumTransmissionUnit();
-
-                    if (nic.type() == QNetworkInterface::Virtual ||
-                            nic.type() == QNetworkInterface::Ppp) {
-                        // Treat PPP and virtual interfaces as likely VPNs
-                        return ReachabilityType::RI_VPN;
-                    }
-
-                    if (nic.maximumTransmissionUnit() != 0 && nic.maximumTransmissionUnit() < 1500) {
-                        // Treat MTUs under 1500 as likely VPNs
-                        return ReachabilityType::RI_VPN;
-                    }
-#endif
-
-                    if (nic.flags() & QNetworkInterface::IsPointToPoint) {
-                        // Treat point-to-point links as likely VPNs.
-                        // This check detects OpenVPN on Unix-like OSes.
-                        return ReachabilityType::RI_VPN;
-                    }
-
-#ifdef Q_OS_WINDOWS
-                    if (nic.name().startsWith("iftype53_") || nic.name().startsWith("iftype131_")) {
-                        // Match by NDIS interface type. These values are Microsoft's recommended values for VPN connections:
-                        // https://learn.microsoft.com/en-US/troubleshoot/windows-client/networking/windows-connection-manager-disconnects-wlan#more-information
-                        //
-                        // The following VPNs use IF_TYPE_PROP_VIRTUAL under Windows:
-                        //  - WireguardNT VPNs
-                        //  - All WinTun-based VPNs (such as Slack Nebula)
-                        //  - OpenVPN with tap-windows6
-                        return ReachabilityType::RI_VPN;
-                    }
-#endif
-
-                    if (nic.hardwareAddress().startsWith("00:FF", Qt::CaseInsensitive)) {
-                        // OpenVPN TAP interfaces have a MAC address starting with 00:FF on Windows
-                        return ReachabilityType::RI_VPN;
-                    }
-
-                    if (nic.humanReadableName().startsWith("ZeroTier")) {
-                        // ZeroTier interfaces always start with "ZeroTier"
-                        return ReachabilityType::RI_VPN;
-                    }
-
-                    if (nic.humanReadableName().contains("VPN")) {
-                        // This one is just a final VPN heuristic if all else fails
-                        return ReachabilityType::RI_VPN;
-                    }
-
-                    // Didn't meet any of our VPN heuristics. Let's see if the peer address is on-link.
-                    Q_ASSERT(addr.prefixLength() >= 0);
-                    if (addr.prefixLength() >= 0 && s.localAddress().isInSubnet(s.peerAddress(), addr.prefixLength())) {
-                        return ReachabilityType::RI_LAN;
-                    }
-
-                    // Default to unknown if nothing else matched
-                    return ReachabilityType::RI_UNKNOWN;
-                }
-            }
-        }
-
-        qWarning() << "No match found for address:" << s.localAddress();
-        return ReachabilityType::RI_UNKNOWN;
-    }
-    else {
-        // If we fail to connect, just pretend that it's not a VPN
-        qWarning() << "Unable to check for reachability within 3 seconds";
-        return ReachabilityType::RI_UNKNOWN;
-    }
-}
-
-bool NvComputer::updateAppList(QVector<NvApp> newAppList) {
-    if (appList == newAppList) {
-        return false;
-    }
-
-    // Propagate client-side attributes to the new app list
-    for (const NvApp& existingApp : std::as_const(appList)) {
-        for (NvApp& newApp : newAppList) {
-            if (existingApp.id == newApp.id) {
-                newApp.hidden = existingApp.hidden;
-                newApp.directLaunch = existingApp.directLaunch;
-            }
-        }
-    }
-
-    appList = newAppList;
-    sortAppList();
-    return true;
-}
-
-QVector<NvAddress> NvComputer::uniqueAddresses() const
-{
-    QReadLocker readLocker(&lock);
-    QVector<NvAddress> uniqueAddressList;
-
-    // Start with addresses correctly ordered
-    uniqueAddressList.append(activeAddress);
-    uniqueAddressList.append(localAddress);
-    uniqueAddressList.append(remoteAddress);
-    uniqueAddressList.append(ipv6Address);
-    uniqueAddressList.append(manualAddress);
-
-    // Prune duplicates (always giving precedence to the first)
-    for (int i = 0; i < uniqueAddressList.count(); i++) {
-        if (uniqueAddressList[i].isNull()) {
-            uniqueAddressList.remove(i);
-            i--;
-            continue;
-        }
-        for (int j = i + 1; j < uniqueAddressList.count(); j++) {
-            if (uniqueAddressList[i] == uniqueAddressList[j]) {
-                // Always remove the later occurrence
-                uniqueAddressList.remove(j);
-                j--;
-            }
-        }
-    }
-
-    // We must have at least 1 address
-    Q_ASSERT(!uniqueAddressList.isEmpty());
-
-    return uniqueAddressList;
-}
-
-bool NvComputer::update(const NvComputer& that)
-{
-    bool changed = false;
-
-    // Lock us for write and them for read
-    QWriteLocker thisLock(&this->lock);
-    QReadLocker thatLock(&that.lock);
-
-    // UUID may not change or we're talking to a new PC
-    Q_ASSERT(this->uuid == that.uuid);
-
-#define ASSIGN_IF_CHANGED(field)       \
-    if (this->field != that.field) {   \
-        this->field = that.field;      \
-        changed = true;                \
-    }
-
-#define ASSIGN_IF_CHANGED_AND_NONEMPTY(field) \
-    if (!that.field.isEmpty() &&              \
-        this->field != that.field) {          \
-        this->field = that.field;             \
-        changed = true;                       \
-    }
-
-#define ASSIGN_IF_CHANGED_AND_NONNULL(field)  \
-    if (!that.field.isNull() &&               \
-        this->field != that.field) {          \
-        this->field = that.field;             \
-        changed = true;                       \
-    }
-
-    if (!hasCustomName) {
-        // Only overwrite the name if it's not custom
-        ASSIGN_IF_CHANGED(name);
-    }
-    ASSIGN_IF_CHANGED_AND_NONEMPTY(macAddress);
-    ASSIGN_IF_CHANGED_AND_NONNULL(localAddress);
-    ASSIGN_IF_CHANGED_AND_NONNULL(remoteAddress);
-    ASSIGN_IF_CHANGED_AND_NONNULL(ipv6Address);
-    ASSIGN_IF_CHANGED_AND_NONNULL(manualAddress);
-    ASSIGN_IF_CHANGED(activeHttpsPort);
-    ASSIGN_IF_CHANGED(externalPort);
-    ASSIGN_IF_CHANGED(pairState);
-    ASSIGN_IF_CHANGED(serverCodecModeSupport);
-    ASSIGN_IF_CHANGED(currentGameId);
-    ASSIGN_IF_CHANGED(activeAddress);
-    ASSIGN_IF_CHANGED(state);
-    ASSIGN_IF_CHANGED(gfeVersion);
-    ASSIGN_IF_CHANGED(appVersion);
-    ASSIGN_IF_CHANGED(isSupportedServerVersion);
-    ASSIGN_IF_CHANGED(isNvidiaServerSoftware);
-    ASSIGN_IF_CHANGED(maxLumaPixelsHEVC);
-    ASSIGN_IF_CHANGED(gpuModel);
-    ASSIGN_IF_CHANGED_AND_NONNULL(serverCert);
-    ASSIGN_IF_CHANGED_AND_NONEMPTY(displayModes);
-
-    if (!that.appList.isEmpty()) {
-        // updateAppList() handles merging client-side attributes
-        updateAppList(that.appList);
-    }
-
-    return changed;
-}
@@ -1,123 +0,0 @@
-#pragma once
-
-#include "nvhttp.h"
-#include "nvaddress.h"
-
-#include <QThread>
-#include <QReadWriteLock>
-#include <QSettings>
-#include <QRunnable>
-
-class CopySafeReadWriteLock : public QReadWriteLock
-{
-public:
-    CopySafeReadWriteLock() = default;
-
-    // Don't actually copy the QReadWriteLock
-    CopySafeReadWriteLock(const CopySafeReadWriteLock&) : QReadWriteLock() {}
-    CopySafeReadWriteLock& operator=(const CopySafeReadWriteLock &) { return *this; }
-};
-
-class NvComputer
-{
-    friend class PcMonitorThread;
-    friend class ComputerManager;
-    friend class PendingQuitTask;
-
-private:
-    void sortAppList();
-
-    bool updateAppList(QVector<NvApp> newAppList);
-
-    bool pendingQuit;
-
-public:
-    NvComputer() = default;
-
-    // Caller is responsible for synchronizing read access to the other host
-    NvComputer(const NvComputer&) = default;
-
-    // Caller is responsible for synchronizing read access to the other host
-    NvComputer& operator=(const NvComputer &) = default;
-
-    explicit NvComputer(NvHTTP& http, QString serverInfo);
-
-    explicit NvComputer(QSettings& settings);
-
-    void
-    setRemoteAddress(QHostAddress);
-
-    bool
-    update(const NvComputer& that);
-
-    bool
-    wake() const;
-
-    enum ReachabilityType
-    {
-        RI_UNKNOWN,
-        RI_LAN,
-        RI_VPN,
-    };
-
-    ReachabilityType
-    getActiveAddressReachability() const;
-
-    QVector<NvAddress>
-    uniqueAddresses() const;
-
-    void
-    serialize(QSettings& settings, bool serializeApps) const;
-
-    // Caller is responsible for synchronizing read access to both hosts
-    bool
-    isEqualSerialized(const NvComputer& that) const;
-
-    enum PairState
-    {
-        PS_UNKNOWN,
-        PS_PAIRED,
-        PS_NOT_PAIRED
-    };
-
-    enum ComputerState
-    {
-        CS_UNKNOWN,
-        CS_ONLINE,
-        CS_OFFLINE
-    };
-
-    // Ephemeral traits
-    ComputerState state;
-    PairState pairState;
-    NvAddress activeAddress;
-    uint16_t activeHttpsPort;
-    int currentGameId;
-    QString gfeVersion;
-    QString appVersion;
-    QVector<NvDisplayMode> displayModes;
-    int maxLumaPixelsHEVC;
-    int serverCodecModeSupport;
-    QString gpuModel;
-    bool isSupportedServerVersion;
-
-    // Persisted traits
-    NvAddress localAddress;
-    NvAddress remoteAddress;
-    NvAddress ipv6Address;
-    NvAddress manualAddress;
-    QByteArray macAddress;
-    QString name;
-    bool hasCustomName;
-    QString uuid;
-    QSslCertificate serverCert;
-    QVector<NvApp> appList;
-    bool isNvidiaServerSoftware;
-    // Remember to update isEqualSerialized() when adding fields here!
-
-    // Synchronization
-    mutable CopySafeReadWriteLock lock;
-
-private:
-    uint16_t externalPort;
-};
@@ -1,4 +1,4 @@
-#include "nvcomputer.h"
+#include "nvhttp.h"
 #include <Limelight.h>

 #include <QDebug>
@@ -10,102 +10,27 @@
 #include <QSslKey>
 #include <QImageReader>
 #include <QtEndian>
-#include <QNetworkProxy>

-#define FAST_FAIL_TIMEOUT_MS 2000
 #define REQUEST_TIMEOUT_MS 5000
-#define LAUNCH_TIMEOUT_MS 120000
-#define RESUME_TIMEOUT_MS 30000
-#define QUIT_TIMEOUT_MS 30000

-#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
-#define XML_NAME_EQUALS(x, y) ((x) == (y))
-#else
-#define XML_NAME_EQUALS(x, y) ((x) == (u##y))
-#endif
-
-NvHTTP::NvHTTP(NvAddress address, uint16_t httpsPort, QSslCertificate serverCert, bool useTrueUid, QNetworkAccessManager* nam) :
-    m_Nam(nam ? nam : new QNetworkAccessManager(this)),
-    m_ServerCert(serverCert),
-    m_UseTrueUid(useTrueUid)
+NvHTTP::NvHTTP(QString address) :
+    m_Address(address)
 {
    m_BaseUrlHttp.setScheme("http");
    m_BaseUrlHttps.setScheme("https");
-
-    setAddress(address);
-    setHttpsPort(httpsPort);
-
-    // Never use a proxy server
-    QNetworkProxy noProxy(QNetworkProxy::NoProxy);
-    m_Nam->setProxy(noProxy);
-}
-
-NvHTTP::NvHTTP(NvComputer* computer, QNetworkAccessManager* nam) :
-    NvHTTP(computer->activeAddress, computer->activeHttpsPort, computer->serverCert, !computer->isNvidiaServerSoftware, nam)
-{
-}
-
-void NvHTTP::setServerCert(QSslCertificate serverCert)
-{
-    m_ServerCert = serverCert;
-}
-
-void NvHTTP::setAddress(NvAddress address)
-{
-    Q_ASSERT(!address.isNull());
-
-    m_Address = address;
-
-    m_BaseUrlHttp.setHost(address.address());
-    m_BaseUrlHttps.setHost(address.address());
-
-    m_BaseUrlHttp.setPort(address.port());
-}
-
-void NvHTTP::setHttpsPort(uint16_t port)
-{
-    m_BaseUrlHttps.setPort(port);
-}
-
-void NvHTTP::setTrueUid(bool useTrueUid)
-{
-    m_UseTrueUid = useTrueUid;
-}
-
-NvAddress NvHTTP::address()
-{
-    return m_Address;
-}
-
-QSslCertificate NvHTTP::serverCert()
-{
-    return m_ServerCert;
-}
-
-uint16_t NvHTTP::httpPort()
-{
-    return m_BaseUrlHttp.port();
-}
-
-uint16_t NvHTTP::httpsPort()
-{
-    return m_BaseUrlHttps.port();
+    m_BaseUrlHttp.setHost(address);
+    m_BaseUrlHttps.setHost(address);
+    m_BaseUrlHttp.setPort(47989);
+    m_BaseUrlHttps.setPort(47984);
 }

 QVector<int>
 NvHTTP::parseQuad(QString quad)
 {
+    QStringList parts = quad.split(".");
    QVector<int> ret;

-    // Return an empty vector for old GFE versions
-    // that were missing GfeVersion.
-    if (quad.isEmpty()) {
-        return ret;
-    }
-
-    QStringList parts = quad.split(".");
-    ret.reserve(parts.length());
-    for (int i = 0; i < parts.length(); i++)
+    for (int i = 0; i < 4; i++)
    {
        ret.append(parts.at(i).toInt());
    }
@@ -120,7 +45,7 @@ NvHTTP::getCurrentGame(QString serverInfo)
    // has the semantics that its name would indicate. To contain the effects of this change as much
    // as possible, we'll force the current game to zero if the server isn't in a streaming session.
    QString serverState = getXmlString(serverInfo, "state");
-    if (serverState.endsWith("_SERVER_BUSY"))
+    if (serverState != nullptr && serverState.endsWith("_SERVER_BUSY"))
    {
        return getXmlString(serverInfo, "currentgame").toInt();
    }
@@ -131,118 +56,109 @@ NvHTTP::getCurrentGame(QString serverInfo)
 }

 QString
-NvHTTP::getServerInfo(NvLogLevel logLevel, bool fastFail)
+NvHTTP::getServerInfo()
 {
    QString serverInfo;

-    // Check if we have a pinned cert and HTTPS port for this host yet
-    if (!m_ServerCert.isNull() && httpsPort() != 0)
+    try
    {
-        try
-        {
-            // Always try HTTPS first, since it properly reports
-            // pairing status (and a few other attributes).
-            serverInfo = openConnectionToString(m_BaseUrlHttps,
-                                                "serverinfo",
-                                                nullptr,
-                                                fastFail ? FAST_FAIL_TIMEOUT_MS : REQUEST_TIMEOUT_MS,
-                                                logLevel);
-            // Throws if the request failed
-            verifyResponseStatus(serverInfo);
-        }
-        catch (const GfeHttpResponseException& e)
-        {
-            if (e.getStatusCode() == 401)
-            {
-                // Certificate validation error, fallback to HTTP
-                serverInfo = openConnectionToString(m_BaseUrlHttp,
-                                                    "serverinfo",
-                                                    nullptr,
-                                                    fastFail ? FAST_FAIL_TIMEOUT_MS : REQUEST_TIMEOUT_MS,
-                                                    logLevel);
-                verifyResponseStatus(serverInfo);
-            }
-            else
-            {
-                // Rethrow real errors
-                throw e;
-            }
-        }
-    }
-    else
-    {
-        // Only use HTTP prior to pairing or fetching HTTPS port
-        serverInfo = openConnectionToString(m_BaseUrlHttp,
+        // Always try HTTPS first, since it properly reports
+        // pairing status (and a few other attributes).
+        serverInfo = openConnectionToString(m_BaseUrlHttps,
                                            "serverinfo",
                                            nullptr,
-                                            fastFail ? FAST_FAIL_TIMEOUT_MS : REQUEST_TIMEOUT_MS,
-                                            logLevel);
+                                            true);
+        // Throws if the request failed
        verifyResponseStatus(serverInfo);
-
-        // Populate the HTTPS port
-        uint16_t httpsPort = getXmlString(serverInfo, "HttpsPort").toUShort();
-        if (httpsPort == 0) {
-            httpsPort = DEFAULT_HTTPS_PORT;
+    }
+    catch (const GfeHttpResponseException& e)
+    {
+        if (e.getStatusCode() == 401)
+        {
+            // Certificate validation error, fallback to HTTP
+            serverInfo = openConnectionToString(m_BaseUrlHttp,
+                                                "serverinfo",
+                                                nullptr,
+                                                true);
+            verifyResponseStatus(serverInfo);
        }
-        setHttpsPort(httpsPort);
-
-        // If we just needed to determine the HTTPS port, we'll try again over
-        // HTTPS now that we have the port number
-        if (!m_ServerCert.isNull()) {
-            return getServerInfo(logLevel, fastFail);
+        else
+        {
+            // Rethrow real errors
+            throw e;
        }
    }

    return serverInfo;
 }

-void
-NvHTTP::startApp(QString verb,
-                 bool isGfe,
-                 int appId,
-                 PSTREAM_CONFIGURATION streamConfig,
-                 bool sops,
-                 bool localAudio,
-                 int gamepadMask,
-                 bool persistGameControllersOnDisconnect,
-                 QString& rtspSessionUrl)
+static QString
+getSurroundAudioInfoString(int audioConfig)
 {
-    int riKeyId;
+    int channelMask;
+    int channelCount;

-    memcpy(&riKeyId, streamConfig->remoteInputAesIv, sizeof(riKeyId));
-    riKeyId = qFromBigEndian(riKeyId);
+    switch (audioConfig)
+    {
+    case AUDIO_CONFIGURATION_STEREO:
+        channelCount = 2;
+        channelMask = 0x3;
+        break;
+    case AUDIO_CONFIGURATION_51_SURROUND:
+        channelCount = 6;
+        channelMask = 0xFC;
+        break;
+    default:
+        Q_ASSERT(false);
+        return 0;
+    }

+    return QString::number(channelMask << 16 | channelCount);
+}
+
+void
+NvHTTP::launchApp(int appId,
+                  PSTREAM_CONFIGURATION streamConfig,
+                  bool sops,
+                  bool localAudio,
+                  int gamepadMask)
+{
    QString response =
            openConnectionToString(m_BaseUrlHttps,
-                                   verb,
+                                   "launch",
                                   "appid="+QString::number(appId)+
                                   "&mode="+QString::number(streamConfig->width)+"x"+
                                   QString::number(streamConfig->height)+"x"+
-                                   // Using an FPS value over 60 causes SOPS to default to 720p60,
-                                   // so force it to 0 to ensure the correct resolution is set. We
-                                   // used to use 60 here but that locked the frame rate to 60 FPS
-                                   // on GFE 3.20.3. We don't need this hack for Sunshine.
-                                   QString::number((streamConfig->fps > 60 && isGfe) ? 0 : streamConfig->fps)+
+                                   QString::number(streamConfig->fps)+
                                   "&additionalStates=1&sops="+QString::number(sops ? 1 : 0)+
                                   "&rikey="+QByteArray(streamConfig->remoteInputAesKey, sizeof(streamConfig->remoteInputAesKey)).toHex()+
-                                   "&rikeyid="+QString::number(riKeyId)+
-                                   ((streamConfig->supportedVideoFormats & VIDEO_FORMAT_MASK_10BIT) ?
+                                   "&rikeyid="+QString::number(qFromBigEndian(*(int*)streamConfig->remoteInputAesIv))+
+                                   (streamConfig->enableHdr ?
                                       "&hdrMode=1&clientHdrCapVersion=0&clientHdrCapSupportedFlagsInUint32=0&clientHdrCapMetaDataId=NV_STATIC_METADATA_TYPE_1&clientHdrCapDisplayData=0x0x0x0x0x0x0x0x0x0x0" :
                                        "")+
                                   "&localAudioPlayMode="+QString::number(localAudio ? 1 : 0)+
-                                   "&surroundAudioInfo="+QString::number(SURROUNDAUDIOINFO_FROM_AUDIO_CONFIGURATION(streamConfig->audioConfiguration))+
+                                   "&surroundAudioInfo="+getSurroundAudioInfoString(streamConfig->audioConfiguration)+
                                   "&remoteControllersBitmap="+QString::number(gamepadMask)+
-                                   "&gcmap="+QString::number(gamepadMask)+
-                                   "&gcpersist="+QString::number(persistGameControllersOnDisconnect ? 1 : 0)+
-                                   LiGetLaunchUrlQueryParameters(),
-                                   LAUNCH_TIMEOUT_MS);
-
-    qInfo() << "Launch response:" << response;
+                                   "&gcmap="+QString::number(gamepadMask),
+                                   false);

    // Throws if the request failed
    verifyResponseStatus(response);
+}

-    rtspSessionUrl = getXmlString(response, "sessionUrl0");
+void
+NvHTTP::resumeApp(PSTREAM_CONFIGURATION streamConfig)
+{
+    QString response =
+            openConnectionToString(m_BaseUrlHttps,
+                                   "resume",
+                                   "rikey="+QString(QByteArray(streamConfig->remoteInputAesKey, sizeof(streamConfig->remoteInputAesKey)).toHex())+
+                                   "&rikeyid="+QString::number(qFromBigEndian(*(int*)streamConfig->remoteInputAesIv))+
+                                   "&surroundAudioInfo="+getSurroundAudioInfoString(streamConfig->audioConfiguration),
+                                   false);
+
+    // Throws if the request failed
+    verifyResponseStatus(response);
 }

 void
@@ -252,16 +168,14 @@ NvHTTP::quitApp()
            openConnectionToString(m_BaseUrlHttps,
                                   "cancel",
                                   nullptr,
-                                   QUIT_TIMEOUT_MS);
-
-    qInfo() << "Quit response:" << response;
+                                   false);

    // Throws if the request failed
    verifyResponseStatus(response);

    // Newer GFE versions will just return success even if quitting fails
-    // if we're not the original requester.
-    if (getCurrentGame(getServerInfo(NvHTTP::NVLL_ERROR)) != 0) {
+    // if we're not the original requestor.
+    if (getCurrentGame(getServerInfo()) != 0) {
        // Generate a synthetic GfeResponseException letting the caller know
        // that they can't kill someone else's stream.
        throw GfeHttpResponseException(599, "");
@@ -276,20 +190,18 @@ NvHTTP::getDisplayModeList(QString serverInfo)

    while (!xmlReader.atEnd()) {
        while (xmlReader.readNextStartElement()) {
-            auto name = xmlReader.name();
-            if (XML_NAME_EQUALS(name, "DisplayMode")) {
+            QStringRef name = xmlReader.name();
+            if (xmlReader.name() == "DisplayMode") {
                modes.append(NvDisplayMode());
            }
-            else if (!modes.isEmpty()) {
-                if (XML_NAME_EQUALS(name, "Width")) {
-                    modes.last().width = xmlReader.readElementText().toInt();
-                }
-                else if (XML_NAME_EQUALS(name, "Height")) {
-                    modes.last().height = xmlReader.readElementText().toInt();
-                }
-                else if (XML_NAME_EQUALS(name, "RefreshRate")) {
-                    modes.last().refreshRate = xmlReader.readElementText().toInt();
-                }
+            else if (xmlReader.name() == "Width") {
+                modes.last().width = xmlReader.readElementText().toInt();
+            }
+            else if (xmlReader.name() == "Height") {
+                modes.last().height = xmlReader.readElementText().toInt();
+            }
+            else if (xmlReader.name() == "RefreshRate") {
+                modes.last().refreshRate = xmlReader.readElementText().toInt();
            }
        }
    }
@@ -303,45 +215,31 @@ NvHTTP::getAppList()
    QString appxml = openConnectionToString(m_BaseUrlHttps,
                                            "applist",
                                            nullptr,
-                                            REQUEST_TIMEOUT_MS,
-                                            NvLogLevel::NVLL_ERROR);
+                                            true);
    verifyResponseStatus(appxml);

    QXmlStreamReader xmlReader(appxml);
    QVector<NvApp> apps;
    while (!xmlReader.atEnd()) {
        while (xmlReader.readNextStartElement()) {
-            auto name = xmlReader.name();
-            if (XML_NAME_EQUALS(name, "App")) {
+            QStringRef name = xmlReader.name();
+            if (xmlReader.name() == "App") {
                // We must have a valid app before advancing to the next one
                if (!apps.isEmpty() && !apps.last().isInitialized()) {
                    qWarning() << "Invalid applist XML";
-                    throw std::runtime_error("Invalid applist XML");
+                    Q_ASSERT(false);
+                    return QVector<NvApp>();
                }
                apps.append(NvApp());
            }
-            else if (!apps.isEmpty()) {
-                if (XML_NAME_EQUALS(name, "AppTitle")) {
-                    // If an app has no name, Sunshine may send us <AppTitle/>,
-                    // which readElementText() returns as a null QString.
-                    // We want to treat this as an empty QString instead, so we
-                    // will explicitly convert it. An empty string will satisfy
-                    // NvApp's isInitialized() check.
-                    QString name = xmlReader.readElementText();
-                    if (name.isNull()) {
-                        name = "";
-                    }
-                    apps.last().name = name;
-                }
-                else if (XML_NAME_EQUALS(name, "ID")) {
-                    apps.last().id = xmlReader.readElementText().toInt();
-                }
-                else if (XML_NAME_EQUALS(name, "IsHdrSupported")) {
-                    apps.last().hdrSupported = xmlReader.readElementText() == "1";
-                }
-                else if (XML_NAME_EQUALS(name, "IsAppCollectorGame")) {
-                    apps.last().isAppCollectorGame = xmlReader.readElementText() == "1";
-                }
+            else if (xmlReader.name() == "AppTitle") {
+                apps.last().name = xmlReader.readElementText();
+            }
+            else if (xmlReader.name() == "ID") {
+                apps.last().id = xmlReader.readElementText().toInt();
+            }
+            else if (xmlReader.name() == "IsHdrSupported") {
+                apps.last().hdrSupported = xmlReader.readElementText() == "1";
            }
        }
    }
@@ -356,12 +254,9 @@ NvHTTP::verifyResponseStatus(QString xml)

    while (xmlReader.readNextStartElement())
    {
-        if (XML_NAME_EQUALS(xmlReader.name(), "root"))
+        if (xmlReader.name() == "root")
        {
-            // Status code can be 0xFFFFFFFF in some rare cases on GFE 3.20.3, and
-            // QString::toInt() will fail in that case, so use QString::toUInt()
-            // and cast the result to an int instead.
-            int statusCode = (int)xmlReader.attributes().value("status_code").toUInt();
+            int statusCode = xmlReader.attributes().value("status_code").toInt();
            if (statusCode == 200)
            {
                // Successful
@@ -370,22 +265,11 @@ NvHTTP::verifyResponseStatus(QString xml)
            else
            {
                QString statusMessage = xmlReader.attributes().value("status_message").toString();
-                if (statusCode != 401) {
-                    // 401 is expected for unpaired PCs when we fetch serverinfo over HTTPS
-                    qWarning() << "Request failed:" << statusCode << statusMessage;
-                }
-                if (statusCode == -1 && statusMessage == "Invalid") {
-                    // Special case handling an audio capture error which GFE doesn't
-                    // provide any useful status message for.
-                    statusCode = 418;
-                    statusMessage = tr("Missing audio capture device. Reinstalling GeForce Experience should resolve this error.");
-                }
+                qDebug() << "Request failed: " << statusCode << " " << statusMessage;
                throw GfeHttpResponseException(statusCode, statusMessage);
            }
        }
    }
-
-    throw GfeHttpResponseException(-1, "Malformed XML (missing root element)");
 }

 QImage
@@ -395,8 +279,7 @@ NvHTTP::getBoxArt(int appId)
                                          "appasset",
                                          "appid="+QString::number(appId)+
                                          "&AssetType=2&AssetIdx=0",
-                                          REQUEST_TIMEOUT_MS,
-                                          NvLogLevel::NVLL_VERBOSE);
+                                          true);
    QImage image = QImageReader(reply).read();
    delete reply;

@@ -407,7 +290,13 @@ QByteArray
 NvHTTP::getXmlStringFromHex(QString xml,
                            QString tagName)
 {
-    return QByteArray::fromHex(getXmlString(xml, tagName).toUtf8());
+    QString str = getXmlString(xml, tagName);
+    if (str == nullptr)
+    {
+        return nullptr;
+    }
+
+    return QByteArray::fromHex(str.toLatin1());
 }

 QString
@@ -429,50 +318,19 @@ NvHTTP::getXmlString(QString xml,
        }
    }

-    return QString();
-}
-
-void NvHTTP::handleSslErrors(QNetworkReply* reply, const QList<QSslError>& errors)
-{
-    bool ignoreErrors = true;
-
-    if (m_ServerCert.isNull()) {
-        // We should never make an HTTPS request without a cert
-        Q_ASSERT(!m_ServerCert.isNull());
-        return;
-    }
-
-    for (const QSslError& error : errors) {
-        if (m_ServerCert != error.certificate()) {
-            ignoreErrors = false;
-            break;
-        }
-    }
-
-    if (ignoreErrors) {
-        reply->ignoreSslErrors(errors);
-    }
+    return nullptr;
 }

 QString
 NvHTTP::openConnectionToString(QUrl baseUrl,
                               QString command,
                               QString arguments,
-                               int timeoutMs,
-                               NvLogLevel logLevel)
+                               bool enableTimeout)
 {
-    QNetworkReply* reply = openConnection(baseUrl, command, arguments, timeoutMs, logLevel);
+    QNetworkReply* reply = openConnection(baseUrl, command, arguments, enableTimeout);
    QString ret;

-    QTextStream stream(reply);
-
-#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
-    stream.setEncoding(QStringConverter::Utf8);
-#else
-    stream.setCodec("UTF-8");
-#endif
-
-    ret = stream.readAll();
+    ret = QTextStream(reply).readAll();
    delete reply;

    return ret;
@@ -482,92 +340,53 @@ QNetworkReply*
 NvHTTP::openConnection(QUrl baseUrl,
                       QString command,
                       QString arguments,
-                       int timeoutMs,
-                       NvLogLevel logLevel)
+                       bool enableTimeout)
 {
-    // Port must be set
-    Q_ASSERT(baseUrl.port(0) != 0);
-
    // Build a URL for the request
    QUrl url(baseUrl);
    url.setPath("/" + command);
-
-    // Use a placeholder UID for GFE allow them to quit games for each other.
-    url.setQuery("uniqueid=" + (m_UseTrueUid ? IdentityManager::get()->getUniqueId() : "0123456789ABCDEF") +
+    url.setQuery("uniqueid=" + IdentityManager::get()->getUniqueId() +
                 "&uuid=" + QUuid::createUuid().toRfc4122().toHex() +
                 ((arguments != nullptr) ? ("&" + arguments) : ""));

-    QNetworkRequest request(url);
+    QNetworkRequest request = QNetworkRequest(url);

    // Add our client certificate
    request.setSslConfiguration(IdentityManager::get()->getSslConfig());

-#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
-    // Disable HTTP/2 (GFE 3.22 doesn't like it) and Qt 6 enables it by default
-    request.setAttribute(QNetworkRequest::Http2AllowedAttribute, false);
-#endif
+    QNetworkReply* reply = m_Nam.get(request);

-#if QT_VERSION >= QT_VERSION_CHECK(6, 3, 0)
-    // Use fine-grained idle timeouts to avoid calling QNetworkAccessManager::clearAccessCache(),
-    // which tears down the NAM's global thread each time. We must not keep persistent connections
-    // or GFE will puke.
-    request.setAttribute(QNetworkRequest::ConnectionCacheExpiryTimeoutSecondsAttribute, 0);
-#endif
-
-    auto sslErrorsConnection = connect(m_Nam, &QNetworkAccessManager::sslErrors, this, &NvHTTP::handleSslErrors);
-    QNetworkReply* reply = m_Nam->get(request);
+    // Ignore self-signed certificate errors (since GFE uses them)
+    reply->ignoreSslErrors();

    // Run the request with a timeout if requested
    QEventLoop loop;
-    connect(reply, &QNetworkReply::finished, &loop, &QEventLoop::quit);
-    connect(QCoreApplication::instance(), &QCoreApplication::aboutToQuit, &loop, &QEventLoop::quit);
-    if (timeoutMs) {
-        QTimer::singleShot(timeoutMs, &loop, &QEventLoop::quit);
-    }
-    if (logLevel >= NvLogLevel::NVLL_VERBOSE) {
-        qInfo() << "Executing request:" << url.toString();
+    QObject::connect(reply, SIGNAL(finished()), &loop, SLOT(quit()));
+    if (enableTimeout)
+    {
+        QTimer::singleShot(REQUEST_TIMEOUT_MS, &loop, SLOT(quit()));
    }
+    qDebug() << "Executing request: " << url.toString();
    loop.exec(QEventLoop::ExcludeUserInputEvents);

    // Abort the request if it timed out
    if (!reply->isFinished())
    {
-        if (logLevel >= NvLogLevel::NVLL_ERROR) {
-            qWarning() << "Aborting timed out request for" << url.toString();
-        }
+        qDebug() << "Aborting timed out request for " << url.toString();
        reply->abort();
    }

-#if QT_VERSION < QT_VERSION_CHECK(6, 3, 0)
-    // If we couldn't use fine-grained connection idle timeouts, kill them all now
-    m_Nam->clearAccessCache();
-#endif
-    disconnect(sslErrorsConnection);
+    // We must clear out cached authentication and connections or
+    // GFE will puke next time
+    m_Nam.clearAccessCache();

    // Handle error
    if (reply->error() != QNetworkReply::NoError)
    {
-        if (logLevel >= NvLogLevel::NVLL_ERROR) {
-            qWarning() << command << "request failed with error:" << reply->error();
-        }
-
-        if (reply->error() == QNetworkReply::SslHandshakeFailedError) {
-            // This will trigger falling back to HTTP for the serverinfo query
-            // then pairing again to get the updated certificate.
-            GfeHttpResponseException exception(401, "Server certificate mismatch");
-            delete reply;
-            throw exception;
-        }
-        else if (reply->error() == QNetworkReply::OperationCanceledError) {
-            QtNetworkReplyException exception(QNetworkReply::TimeoutError, "Request timed out");
-            delete reply;
-            throw exception;
-        }
-        else {
-            QtNetworkReplyException exception(reply->error(), reply->errorString());
-            delete reply;
-            throw exception;
-        }
+        qDebug() << command << " request failed with error " << reply->error();
+        GfeHttpResponseException exception(reply->error(), reply->errorString());
+        delete reply;
+        throw exception;
    }

    return reply;
@@ -1,16 +1,31 @@
 #pragma once

 #include "identitymanager.h"
-#include "nvapp.h"
-#include "nvaddress.h"

 #include <Limelight.h>

 #include <QUrl>
-#include <QNetworkAccessManager>
-#include <QNetworkReply>
+#include <QtNetwork/QNetworkAccessManager>

-class NvComputer;
+class NvApp
+{
+public:
+    bool operator==(const NvApp& other) const
+    {
+        return id == other.id;
+    }
+
+    bool isInitialized()
+    {
+        return id != 0 && !name.isNull();
+    }
+
+    int id;
+    QString name;
+    bool hdrSupported;
+};
+
+Q_DECLARE_METATYPE(NvApp)

 class NvDisplayMode
 {
@@ -26,26 +41,25 @@ public:
    int height;
    int refreshRate;
 };
-Q_DECLARE_TYPEINFO(NvDisplayMode, Q_PRIMITIVE_TYPE);

 class GfeHttpResponseException : public std::exception
 {
 public:
    GfeHttpResponseException(int statusCode, QString message) :
        m_StatusCode(statusCode),
-        m_StatusMessage(message.toUtf8())
+        m_StatusMessage(message)
    {

    }

    const char* what() const throw()
    {
-        return m_StatusMessage.constData();
+        return m_StatusMessage.toLatin1();
    }

    const char* getStatusMessage() const
    {
-        return m_StatusMessage.constData();
+        return m_StatusMessage.toLatin1();
    }

    int getStatusCode() const
@@ -55,70 +69,25 @@ public:

    QString toQString() const
    {
-        return QString::fromUtf8(m_StatusMessage) + " (Error " + QString::number(m_StatusCode) + ")";
+        return m_StatusMessage + " (Error " + QString::number(m_StatusCode) + ")";
    }

 private:
    int m_StatusCode;
-    QByteArray m_StatusMessage;
+    QString m_StatusMessage;
 };

-class QtNetworkReplyException : public std::exception
+class NvHTTP
 {
 public:
-    QtNetworkReplyException(QNetworkReply::NetworkError error, QString errorText) :
-        m_Error(error),
-        m_ErrorText(errorText.toUtf8())
-    {
-
-    }
-
-    const char* what() const throw()
-    {
-        return m_ErrorText.constData();
-    }
-
-    const char* getErrorText() const
-    {
-        return m_ErrorText.constData();
-    }
-
-    QNetworkReply::NetworkError getError() const
-    {
-        return m_Error;
-    }
-
-    QString toQString() const
-    {
-        return QString::fromUtf8(m_ErrorText) + " (Error " + QString::number(m_Error) + ")";
-    }
-
-private:
-    QNetworkReply::NetworkError m_Error;
-    QByteArray m_ErrorText;
-};
-
-class NvHTTP : public QObject
-{
-    Q_OBJECT
-
-public:
-    enum NvLogLevel {
-        NVLL_NONE,
-        NVLL_ERROR,
-        NVLL_VERBOSE
-    };
-
-    explicit NvHTTP(NvAddress address, uint16_t httpsPort, QSslCertificate serverCert, bool useTrueUid, QNetworkAccessManager* nam = nullptr);
-
-    explicit NvHTTP(NvComputer* computer, QNetworkAccessManager* nam = nullptr);
+    explicit NvHTTP(QString address);

    static
    int
    getCurrentGame(QString serverInfo);

    QString
-    getServerInfo(NvLogLevel logLevel, bool fastFail = false);
+    getServerInfo();

    static
    void
@@ -138,21 +107,7 @@ public:
    openConnectionToString(QUrl baseUrl,
                           QString command,
                           QString arguments,
-                           int timeoutMs,
-                           NvLogLevel logLevel = NvLogLevel::NVLL_VERBOSE);
-
-    void setServerCert(QSslCertificate serverCert);
-    void setAddress(NvAddress address);
-    void setHttpsPort(uint16_t port);
-    void setTrueUid(bool useTrueUid);
-
-    NvAddress address();
-
-    QSslCertificate serverCert();
-
-    uint16_t httpPort();
-
-    uint16_t httpsPort();
+                           bool enableTimeout);

    static
    QVector<int>
@@ -162,15 +117,14 @@ public:
    quitApp();

    void
-    startApp(QString verb,
-             bool isGfe,
-             int appId,
-             PSTREAM_CONFIGURATION streamConfig,
-             bool sops,
-             bool localAudio,
-             int gamepadMask,
-             bool persistGameControllersOnDisconnect,
-             QString& rtspSessionUrl);
+    resumeApp(PSTREAM_CONFIGURATION streamConfig);
+
+    void
+    launchApp(int appId,
+              PSTREAM_CONFIGURATION streamConfig,
+              bool sops,
+              bool localAudio,
+              int gamepadMask);

    QVector<NvApp>
    getAppList();
@@ -185,18 +139,12 @@ public:
    QUrl m_BaseUrlHttp;
    QUrl m_BaseUrlHttps;
 private:
-    void
-    handleSslErrors(QNetworkReply* reply, const QList<QSslError>& errors);
-
    QNetworkReply*
    openConnection(QUrl baseUrl,
                   QString command,
                   QString arguments,
-                   int timeoutMs,
-                   NvLogLevel logLevel);
+                   bool enableTimeout);

-    NvAddress m_Address;
-    QNetworkAccessManager* m_Nam;
-    QSslCertificate m_ServerCert;
-    bool m_UseTrueUid;
+    QString m_Address;
+    QNetworkAccessManager m_Nam;
 };
@@ -1,18 +1,17 @@
 #include "nvpairingmanager.h"
 #include "utils.h"

-#include <stdexcept>
+#include <QRandomGenerator>

 #include <openssl/bio.h>
+#include <openssl/aes.h>
 #include <openssl/rand.h>
 #include <openssl/pem.h>
 #include <openssl/x509.h>
 #include <openssl/evp.h>

-#define REQUEST_TIMEOUT_MS 5000
-
-NvPairingManager::NvPairingManager(NvComputer* computer) :
-    m_Http(computer)
+NvPairingManager::NvPairingManager(QString address) :
+    m_Http(address)
 {
    QByteArray cert = IdentityManager::get()->getCertificate();
    BIO *bio = BIO_new_mem_buf(cert.data(), -1);
@@ -22,7 +21,7 @@ NvPairingManager::NvPairingManager(NvComputer* computer) :
    BIO_free_all(bio);
    if (m_Cert == nullptr)
    {
-        throw std::runtime_error("Unable to load certificate");
+        throw new std::runtime_error("Unable to load certificate");
    }

    QByteArray pk = IdentityManager::get()->getPrivateKey();
@@ -33,7 +32,7 @@ NvPairingManager::NvPairingManager(NvComputer* computer) :
    BIO_free_all(bio);
    if (m_PrivateKey == nullptr)
    {
-        throw std::runtime_error("Unable to load private key");
+        throw new std::runtime_error("Unable to load private key");
    }
 }

@@ -52,109 +51,63 @@ NvPairingManager::generateRandomBytes(int length)
 }

 QByteArray
-NvPairingManager::encrypt(const QByteArray& plaintext, const QByteArray& key)
+NvPairingManager::encrypt(QByteArray plaintext, AES_KEY* key)
 {
-    if (plaintext.isEmpty()) {
-        return QByteArray();
-    }
-
-    EVP_CIPHER_CTX* cipher = EVP_CIPHER_CTX_new();
-    THROW_BAD_ALLOC_IF_NULL(cipher);
-
-    EVP_EncryptInit(cipher, EVP_aes_128_ecb(), reinterpret_cast<const unsigned char*>(key.data()), NULL);
-    EVP_CIPHER_CTX_set_padding(cipher, 0);
-
    QByteArray ciphertext(plaintext.size(), 0);
-    int ciphertextLen;
-    EVP_EncryptUpdate(cipher,
-                      reinterpret_cast<unsigned char*>(ciphertext.data()),
-                      &ciphertextLen,
-                      reinterpret_cast<const unsigned char*>(plaintext.data()),
-                      plaintext.length());
-    Q_ASSERT(ciphertextLen == ciphertext.length());

-    EVP_CIPHER_CTX_free(cipher);
+    for (int i = 0; i < plaintext.size(); i += 16)
+    {
+        AES_encrypt(reinterpret_cast<unsigned char*>(&plaintext.data()[i]),
+                    reinterpret_cast<unsigned char*>(&ciphertext.data()[i]),
+                    key);
+    }

    return ciphertext;
 }

 QByteArray
-NvPairingManager::decrypt(const QByteArray& ciphertext, const QByteArray& key)
+NvPairingManager::decrypt(QByteArray ciphertext, AES_KEY* key)
 {
-    if (ciphertext.isEmpty()) {
-        return QByteArray();
-    }
-
-    EVP_CIPHER_CTX* cipher = EVP_CIPHER_CTX_new();
-    THROW_BAD_ALLOC_IF_NULL(cipher);
-
-    EVP_DecryptInit(cipher, EVP_aes_128_ecb(), reinterpret_cast<const unsigned char*>(key.data()), NULL);
-    EVP_CIPHER_CTX_set_padding(cipher, 0);
-
    QByteArray plaintext(ciphertext.size(), 0);
-    int plaintextLen;
-    EVP_DecryptUpdate(cipher,
-                      reinterpret_cast<unsigned char*>(plaintext.data()),
-                      &plaintextLen,
-                      reinterpret_cast<const unsigned char*>(ciphertext.data()),
-                      ciphertext.length());
-    Q_ASSERT(plaintextLen == plaintext.length());

-    EVP_CIPHER_CTX_free(cipher);
+    for (int i = 0; i < plaintext.size(); i += 16)
+    {
+        AES_decrypt(reinterpret_cast<unsigned char*>(&ciphertext.data()[i]),
+                    reinterpret_cast<unsigned char*>(&plaintext.data()[i]),
+                    key);
+    }

    return plaintext;
 }

 QByteArray
-NvPairingManager::getSignatureFromCert(X509* cert)
+NvPairingManager::getSignatureFromPemCert(QByteArray certificate)
 {
-#if (OPENSSL_VERSION_NUMBER < 0x10002000L)
-    ASN1_BIT_STRING *asnSignature = cert->signature;
-#elif (OPENSSL_VERSION_NUMBER < 0x10100000L)
-    ASN1_BIT_STRING *asnSignature;
-    X509_get0_signature(&asnSignature, NULL, cert);
-#else
-    const ASN1_BIT_STRING *asnSignature;
-    X509_get0_signature(&asnSignature, NULL, cert);
-#endif
-
-    return QByteArray(
-#if (OPENSSL_VERSION_NUMBER < 0x10100000L)
-        reinterpret_cast<const char*>(ASN1_STRING_data(asnSignature)),
-#else
-        reinterpret_cast<const char*>(ASN1_STRING_get0_data(asnSignature)),
-#endif
-        ASN1_STRING_length(asnSignature)
-    );
-}
-
-QByteArray
-NvPairingManager::getSignatureFromPemCert(const QByteArray& certificate)
-{
-#if (OPENSSL_VERSION_NUMBER < 0x10100000L)
-    BIO* bio = BIO_new_mem_buf(const_cast<char*>(certificate.data()), -1);
-#else
    BIO* bio = BIO_new_mem_buf(certificate.data(), -1);
-#endif
    THROW_BAD_ALLOC_IF_NULL(bio);

    X509* cert = PEM_read_bio_X509(bio, nullptr, nullptr, nullptr);
    BIO_free_all(bio);

-    QByteArray signature = getSignatureFromCert(cert);
+#if (OPENSSL_VERSION_NUMBER < 0x10100000L)
+   ASN1_BIT_STRING *asnSignature;
+#else
+   const ASN1_BIT_STRING *asnSignature;
+#endif
+
+    X509_get0_signature(&asnSignature, NULL, cert);
+
+    QByteArray signature(reinterpret_cast<char*>(asnSignature->data), asnSignature->length);
+
    X509_free(cert);

    return signature;
 }

 bool
-NvPairingManager::verifySignature(const QByteArray& data, const QByteArray& signature, const QByteArray& serverCertificate)
+NvPairingManager::verifySignature(QByteArray data, QByteArray signature, QByteArray serverCertificate)
 {
-#if (OPENSSL_VERSION_NUMBER < 0x10100000L)
-    BIO* bio = BIO_new_mem_buf(const_cast<char*>(serverCertificate.data()), -1);
-#else
    BIO* bio = BIO_new_mem_buf(serverCertificate.data(), -1);
-#endif
    THROW_BAD_ALLOC_IF_NULL(bio);

    X509* cert = PEM_read_bio_X509(bio, nullptr, nullptr, nullptr);
@@ -168,7 +121,7 @@ NvPairingManager::verifySignature(const QByteArray& data, const QByteArray& sign

    EVP_DigestVerifyInit(mdctx, nullptr, EVP_sha256(), nullptr, pubKey);
    EVP_DigestVerifyUpdate(mdctx, data.data(), data.length());
-    int result = EVP_DigestVerifyFinal(mdctx, reinterpret_cast<unsigned char*>(const_cast<char*>(signature.data())), signature.length());
+    int result = EVP_DigestVerifyFinal(mdctx, reinterpret_cast<unsigned char*>(signature.data()), signature.length());

    EVP_PKEY_free(pubKey);
    EVP_MD_CTX_destroy(mdctx);
@@ -178,13 +131,17 @@ NvPairingManager::verifySignature(const QByteArray& data, const QByteArray& sign
 }

 QByteArray
-NvPairingManager::signMessage(const QByteArray& message)
+NvPairingManager::signMessage(QByteArray message)
 {
    EVP_MD_CTX *ctx = EVP_MD_CTX_create();
    THROW_BAD_ALLOC_IF_NULL(ctx);

-    EVP_DigestSignInit(ctx, NULL, EVP_sha256(), NULL, m_PrivateKey);
-    EVP_DigestSignUpdate(ctx, reinterpret_cast<unsigned char*>(const_cast<char*>(message.data())), message.length());
+    const EVP_MD *md = EVP_get_digestbyname("SHA256");
+    THROW_BAD_ALLOC_IF_NULL(md);
+
+    EVP_DigestInit_ex(ctx, md, NULL);
+    EVP_DigestSignInit(ctx, NULL, md, NULL, m_PrivateKey);
+    EVP_DigestSignUpdate(ctx, reinterpret_cast<unsigned char*>(message.data()), message.length());

    size_t signatureLength = 0;
    EVP_DigestSignFinal(ctx, NULL, &signatureLength);
@@ -198,16 +155,16 @@ NvPairingManager::signMessage(const QByteArray& message)
 }

 QByteArray
-NvPairingManager::saltPin(const QByteArray& salt, QString pin)
+NvPairingManager::saltPin(QByteArray salt, QString pin)
 {
-    return QByteArray().append(salt).append(pin.toUtf8());
+    return QByteArray().append(salt).append(pin.toLatin1());
 }

 NvPairingManager::PairState
-NvPairingManager::pair(QString appVersion, QString pin, QSslCertificate& serverCert)
+NvPairingManager::pair(QString appVersion, QString pin)
 {
    int serverMajorVersion = NvHTTP::parseQuad(appVersion).at(0);
-    qInfo() << "Pairing with server generation:" << serverMajorVersion;
+    qDebug() << "Pairing with server generation: " << serverMajorVersion;

    QCryptographicHash::Algorithm hashAlgo;
    int hashLength;
@@ -227,114 +184,97 @@ NvPairingManager::pair(QString appVersion, QString pin, QSslCertificate& serverC
    QByteArray salt = generateRandomBytes(16);
    QByteArray saltedPin = saltPin(salt, pin);

-    QByteArray aesKey = QCryptographicHash::hash(saltedPin, hashAlgo).constData();
-    aesKey.truncate(16);
+    AES_KEY encKey, decKey;
+    AES_set_decrypt_key(reinterpret_cast<const unsigned char*>(QCryptographicHash::hash(saltedPin, hashAlgo).data()), 128, &decKey);
+    AES_set_encrypt_key(reinterpret_cast<const unsigned char*>(QCryptographicHash::hash(saltedPin, hashAlgo).data()), 128, &encKey);

    QString getCert = m_Http.openConnectionToString(m_Http.m_BaseUrlHttp,
                                                    "pair",
                                                    "devicename=roth&updateState=1&phrase=getservercert&salt=" +
                                                    salt.toHex() + "&clientcert=" + IdentityManager::get()->getCertificate().toHex(),
-                                                    0);
+                                                    false);
    NvHTTP::verifyResponseStatus(getCert);
    if (NvHTTP::getXmlString(getCert, "paired") != "1")
    {
-        qCritical() << "Failed pairing at stage #1";
+        qDebug() << "Failed pairing at stage #1";
        return PairState::FAILED;
    }

-    QByteArray serverCertStr = NvHTTP::getXmlStringFromHex(getCert, "plaincert");
-    if (serverCertStr.isEmpty()) {
-        qCritical() << "Server likely already pairing";
-        m_Http.openConnectionToString(m_Http.m_BaseUrlHttp, "unpair", nullptr, REQUEST_TIMEOUT_MS);
+    QByteArray serverCert = NvHTTP::getXmlStringFromHex(getCert, "plaincert");
+    if (serverCert == nullptr)
+    {
+        qDebug() << "Server likely already pairing";
+        m_Http.openConnectionToString(m_Http.m_BaseUrlHttp, "unpair", nullptr, true);
        return PairState::ALREADY_IN_PROGRESS;
    }

-    QSslCertificate unverifiedServerCert = QSslCertificate(serverCertStr);
-    if (unverifiedServerCert.isNull()) {
-        Q_ASSERT(!unverifiedServerCert.isNull());
-
-        qCritical() << "Failed to parse plaincert";
-        m_Http.openConnectionToString(m_Http.m_BaseUrlHttp, "unpair", nullptr, REQUEST_TIMEOUT_MS);
-        return PairState::FAILED;
-    }
-
-    // Pin this cert for TLS until pairing is complete. If successful, we will propagate
-    // the cert into the NvComputer object and persist it.
-    m_Http.setServerCert(unverifiedServerCert);
-
    QByteArray randomChallenge = generateRandomBytes(16);
-    QByteArray encryptedChallenge = encrypt(randomChallenge, aesKey);
+    QByteArray encryptedChallenge = encrypt(randomChallenge, &encKey);
    QString challengeXml = m_Http.openConnectionToString(m_Http.m_BaseUrlHttp,
                                                         "pair",
                                                         "devicename=roth&updateState=1&clientchallenge=" +
                                                         encryptedChallenge.toHex(),
-                                                         REQUEST_TIMEOUT_MS);
+                                                         true);
    NvHTTP::verifyResponseStatus(challengeXml);
    if (NvHTTP::getXmlString(challengeXml, "paired") != "1")
    {
-        qCritical() << "Failed pairing at stage #2";
-        m_Http.openConnectionToString(m_Http.m_BaseUrlHttp, "unpair", nullptr, REQUEST_TIMEOUT_MS);
-        return PairState::FAILED;
-    }
-
-    QByteArray challengeResponseData = decrypt(m_Http.getXmlStringFromHex(challengeXml, "challengeresponse"), aesKey);
-    if (challengeResponseData.size() < hashLength) {
-        qCritical() << "Invalid challengeresponse at stage #2";
-        m_Http.openConnectionToString(m_Http.m_BaseUrlHttp, "unpair", nullptr, REQUEST_TIMEOUT_MS);
+        qDebug() << "Failed pairing at stage #2";
+        m_Http.openConnectionToString(m_Http.m_BaseUrlHttp, "unpair", nullptr, true);
        return PairState::FAILED;
    }

+    QByteArray challengeResponseData = decrypt(m_Http.getXmlStringFromHex(challengeXml, "challengeresponse"), &decKey);
    QByteArray clientSecretData = generateRandomBytes(16);
    QByteArray challengeResponse;
    QByteArray serverResponse(challengeResponseData.data(), hashLength);

+ #if (OPENSSL_VERSION_NUMBER < 0x10100000L)
+    ASN1_BIT_STRING *asnSignature;
+ #else
+    const ASN1_BIT_STRING *asnSignature;
+ #endif
+
+    X509_get0_signature(&asnSignature, NULL, m_Cert);
+
    challengeResponse.append(challengeResponseData.data() + hashLength, 16);
-    challengeResponse.append(getSignatureFromCert(m_Cert));
+    challengeResponse.append(reinterpret_cast<char*>(asnSignature->data), asnSignature->length);
    challengeResponse.append(clientSecretData);

-    QByteArray paddedHash = QCryptographicHash::hash(challengeResponse, hashAlgo);
-    paddedHash.resize(32);
-    QByteArray encryptedChallengeResponseHash = encrypt(paddedHash, aesKey);
+    QByteArray encryptedChallengeResponseHash = encrypt(QCryptographicHash::hash(challengeResponse, hashAlgo), &encKey);
    QString respXml = m_Http.openConnectionToString(m_Http.m_BaseUrlHttp,
                                                    "pair",
                                                    "devicename=roth&updateState=1&serverchallengeresp=" +
                                                    encryptedChallengeResponseHash.toHex(),
-                                                    REQUEST_TIMEOUT_MS);
+                                                    true);
    NvHTTP::verifyResponseStatus(respXml);
    if (NvHTTP::getXmlString(respXml, "paired") != "1")
    {
-        qCritical() << "Failed pairing at stage #3";
-        m_Http.openConnectionToString(m_Http.m_BaseUrlHttp, "unpair", nullptr, REQUEST_TIMEOUT_MS);
+        qDebug() << "Failed pairing at stage #3";
+        m_Http.openConnectionToString(m_Http.m_BaseUrlHttp, "unpair", nullptr, true);
        return PairState::FAILED;
    }

    QByteArray pairingSecret = NvHTTP::getXmlStringFromHex(respXml, "pairingsecret");
-    if (pairingSecret.size() <= 16) {
-        qCritical() << "Invalid pairingsecret at stage #3";
-        m_Http.openConnectionToString(m_Http.m_BaseUrlHttp, "unpair", nullptr, REQUEST_TIMEOUT_MS);
-        return PairState::FAILED;
-    }
-
-    QByteArray serverSecret = pairingSecret.left(16);
-    QByteArray serverSignature = pairingSecret.mid(16);
+    QByteArray serverSecret = QByteArray(pairingSecret.data(), 16);
+    QByteArray serverSignature = QByteArray(&pairingSecret.data()[16], 256);

    if (!verifySignature(serverSecret,
                         serverSignature,
-                         serverCertStr))
+                         serverCert))
    {
-        qCritical() << "MITM detected";
-        m_Http.openConnectionToString(m_Http.m_BaseUrlHttp, "unpair", nullptr, REQUEST_TIMEOUT_MS);
+        qDebug() << "MITM detected";
+        m_Http.openConnectionToString(m_Http.m_BaseUrlHttp, "unpair", nullptr, true);
        return PairState::FAILED;
    }

    QByteArray expectedResponseData;
    expectedResponseData.append(randomChallenge);
-    expectedResponseData.append(getSignatureFromPemCert(serverCertStr));
+    expectedResponseData.append(getSignatureFromPemCert(serverCert));
    expectedResponseData.append(serverSecret);
    if (QCryptographicHash::hash(expectedResponseData, hashAlgo) != serverResponse)
    {
-        qCritical() << "Incorrect PIN";
-        m_Http.openConnectionToString(m_Http.m_BaseUrlHttp, "unpair", nullptr, REQUEST_TIMEOUT_MS);
+        qDebug() << "Incorrect PIN";
+        m_Http.openConnectionToString(m_Http.m_BaseUrlHttp, "unpair", nullptr, true);
        return PairState::PIN_WRONG;
    }

@@ -346,27 +286,26 @@ NvPairingManager::pair(QString appVersion, QString pin, QSslCertificate& serverC
                                                          "pair",
                                                          "devicename=roth&updateState=1&clientpairingsecret=" +
                                                          clientPairingSecret.toHex(),
-                                                          REQUEST_TIMEOUT_MS);
+                                                          true);
    NvHTTP::verifyResponseStatus(secretRespXml);
    if (NvHTTP::getXmlString(secretRespXml, "paired") != "1")
    {
-        qCritical() << "Failed pairing at stage #4";
-        m_Http.openConnectionToString(m_Http.m_BaseUrlHttp, "unpair", nullptr, REQUEST_TIMEOUT_MS);
+        qDebug() << "Failed pairing at stage #4";
+        m_Http.openConnectionToString(m_Http.m_BaseUrlHttp, "unpair", nullptr, true);
        return PairState::FAILED;
    }

    QString pairChallengeXml = m_Http.openConnectionToString(m_Http.m_BaseUrlHttps,
                                                             "pair",
                                                             "devicename=roth&updateState=1&phrase=pairchallenge",
-                                                             REQUEST_TIMEOUT_MS);
+                                                             true);
    NvHTTP::verifyResponseStatus(pairChallengeXml);
    if (NvHTTP::getXmlString(pairChallengeXml, "paired") != "1")
    {
-        qCritical() << "Failed pairing at stage #5";
-        m_Http.openConnectionToString(m_Http.m_BaseUrlHttp, "unpair", nullptr, REQUEST_TIMEOUT_MS);
+        qDebug() << "Failed pairing at stage #5";
+        m_Http.openConnectionToString(m_Http.m_BaseUrlHttp, "unpair", nullptr, true);
        return PairState::FAILED;
    }

-    serverCert = std::move(unverifiedServerCert);
    return PairState::PAIRED;
 }
@@ -3,6 +3,7 @@
 #include "identitymanager.h"
 #include "nvhttp.h"

+#include <openssl/aes.h>
 #include <openssl/x509.h>
 #include <openssl/evp.h>

@@ -17,37 +18,34 @@ public:
        ALREADY_IN_PROGRESS
    };

-    explicit NvPairingManager(NvComputer* computer);
+    explicit NvPairingManager(QString address);

    ~NvPairingManager();

    PairState
-    pair(QString appVersion, QString pin, QSslCertificate& serverCert);
+    pair(QString appVersion, QString pin);

 private:
    QByteArray
    generateRandomBytes(int length);

    QByteArray
-    saltPin(const QByteArray& salt, QString pin);
+    saltPin(QByteArray salt, QString pin);

    QByteArray
-    encrypt(const QByteArray& plaintext, const QByteArray& key);
+    encrypt(QByteArray plaintext, AES_KEY* key);

    QByteArray
-    decrypt(const QByteArray& ciphertext, const QByteArray& key);
+    decrypt(QByteArray ciphertext, AES_KEY* key);

    QByteArray
-    getSignatureFromCert(X509* cert);
-
-    QByteArray
-    getSignatureFromPemCert(const QByteArray& certificate);
+    getSignatureFromPemCert(QByteArray certificate);

    bool
-    verifySignature(const QByteArray& data, const QByteArray& signature, const QByteArray& serverCertificate);
+    verifySignature(QByteArray data, QByteArray signature, QByteArray serverCertificate);

    QByteArray
-    signMessage(const QByteArray& message);
+    signMessage(QByteArray message);

    NvHTTP m_Http;
    X509* m_Cert;
@@ -1,67 +0,0 @@
-#include "richpresencemanager.h"
-
-#include <QDebug>
-
-RichPresenceManager::RichPresenceManager(StreamingPreferences& prefs, QString gameName)
-    : m_DiscordActive(false)
-{
-#ifdef HAVE_DISCORD
-    if (prefs.richPresence) {
-        DiscordEventHandlers handlers = {};
-        handlers.ready = discordReady;
-        handlers.disconnected = discordDisconnected;
-        handlers.errored = discordErrored;
-        Discord_Initialize("594668102021677159", &handlers, 0, nullptr);
-        m_DiscordActive = true;
-    }
-
-    if (m_DiscordActive) {
-        QByteArray stateStr = (QString("Streaming ") + gameName).toUtf8();
-
-        DiscordRichPresence discordPresence = {};
-        discordPresence.state = stateStr.data();
-        discordPresence.startTimestamp = time(nullptr);
-        discordPresence.largeImageKey = "icon";
-        Discord_UpdatePresence(&discordPresence);
-    }
-#else
-    Q_UNUSED(prefs)
-    Q_UNUSED(gameName)
-#endif
-}
-
-RichPresenceManager::~RichPresenceManager()
-{
-#ifdef HAVE_DISCORD
-    if (m_DiscordActive) {
-        Discord_ClearPresence();
-        Discord_Shutdown();
-    }
-#endif
-}
-
-void RichPresenceManager::runCallbacks()
-{
-#ifdef HAVE_DISCORD
-    if (m_DiscordActive) {
-        Discord_RunCallbacks();
-    }
-#endif
-}
-
-#ifdef HAVE_DISCORD
-void RichPresenceManager::discordReady(const DiscordUser* request)
-{
-    qInfo() << "Discord integration ready for user:" << request->username;
-}
-
-void RichPresenceManager::discordDisconnected(int errorCode, const char *message)
-{
-    qInfo() << "Discord integration disconnected:" << errorCode << message;
-}
-
-void RichPresenceManager::discordErrored(int errorCode, const char *message)
-{
-    qWarning() << "Discord integration error:" << errorCode << message;
-}
-#endif
@@ -1,26 +0,0 @@
-#pragma once
-
-#include "settings/streamingpreferences.h"
-
-#ifdef HAVE_DISCORD
-#include <discord_rpc.h>
-#endif
-
-class RichPresenceManager
-{
-public:
-    RichPresenceManager(StreamingPreferences& prefs, QString gameName);
-    ~RichPresenceManager();
-
-    void runCallbacks();
-
-private:
-#ifdef HAVE_DISCORD
-    static void discordReady(const DiscordUser* request);
-    static void discordDisconnected(int errorCode, const char* message);
-    static void discordErrored(int errorCode, const char* message);
-#endif
-
-    bool m_DiscordActive;
-};
-
@@ -1,279 +0,0 @@
-#include "systemproperties.h"
-#include "utils.h"
-
-#include <QGuiApplication>
-#include <QLibraryInfo>
-
-#include "streaming/session.h"
-#include "streaming/streamutils.h"
-
-#ifdef Q_OS_WIN32
-#define WIN32_LEAN_AND_MEAN
-#include <Windows.h>
-#endif
-
-class SystemPropertyQueryThread : public QThread
-{
-public:
-    SystemPropertyQueryThread(SystemProperties* properties)
-        : QThread(properties), m_Properties(properties)
-    {
-        setObjectName("System Properties Async Query Thread");
-    }
-
-private:
-    void run() override
-    {
-        bool hasHardwareAcceleration;
-        bool rendererAlwaysFullScreen;
-        bool supportsHdr;
-        QSize maximumResolution;
-
-        Session::getDecoderInfo(m_Properties->testWindow, hasHardwareAcceleration, rendererAlwaysFullScreen, supportsHdr, maximumResolution);
-
-        // Propagate the decoder properties to the SystemProperties singleton and emit any change signals on the main thread
-        QMetaObject::invokeMethod(m_Properties, "updateDecoderProperties",
-                                  Qt::QueuedConnection,
-                                  Q_ARG(bool, hasHardwareAcceleration),
-                                  Q_ARG(bool, rendererAlwaysFullScreen),
-                                  Q_ARG(QSize, maximumResolution),
-                                  Q_ARG(bool, supportsHdr));
-    }
-
-private:
-    SystemProperties* m_Properties;
-};
-
-SystemProperties::SystemProperties()
-{
-    versionString = QString(VERSION_STR);
-    hasDesktopEnvironment = WMUtils::isRunningDesktopEnvironment();
-    isRunningWayland = WMUtils::isRunningWayland();
-    isRunningXWayland = isRunningWayland && QGuiApplication::platformName() == "xcb";
-    usesMaterial3Theme = QLibraryInfo::version() >= QVersionNumber(6, 5, 0);
-
-#ifdef Q_OS_DARWIN
-    isDarwin = true;
-#else
-    isDarwin = false;
-#endif
-
-    QString nativeArch = QSysInfo::currentCpuArchitecture();
-
-#ifdef Q_OS_WIN32
-    {
-        USHORT processArch, machineArch;
-
-        // Use IsWow64Process2() because it doesn't lie on ARM64
-        if (IsWow64Process2(GetCurrentProcess(), &processArch, &machineArch)) {
-            switch (machineArch) {
-            case IMAGE_FILE_MACHINE_I386:
-                nativeArch = "i386";
-                break;
-            case IMAGE_FILE_MACHINE_AMD64:
-                nativeArch = "x86_64";
-                break;
-            case IMAGE_FILE_MACHINE_ARM64:
-                nativeArch = "arm64";
-                break;
-            }
-        }
-
-        isWow64 = nativeArch != QSysInfo::buildCpuArchitecture();
-    }
-#else
-    isWow64 = false;
-#endif
-
-    if (nativeArch == "i386") {
-        friendlyNativeArchName = "x86";
-    }
-    else if (nativeArch == "x86_64") {
-        friendlyNativeArchName = "x64";
-    }
-    else {
-        friendlyNativeArchName = nativeArch.toUpper();
-    }
-
-    // Assume we can probably launch a browser if we're in a GUI environment
-    hasBrowser = hasDesktopEnvironment;
-
-#ifdef HAVE_DISCORD
-    hasDiscordIntegration = true;
-#else
-    hasDiscordIntegration = false;
-#endif
-
-    // These will be queried asynchronously to avoid blocking the UI
-    hasHardwareAcceleration = true;
-    rendererAlwaysFullScreen = false;
-    supportsHdr = true;
-    maximumResolution = QSize(0, 0);
-}
-
-SystemProperties::~SystemProperties()
-{
-    waitForAsyncLoad();
-}
-
-void SystemProperties::updateDecoderProperties(bool hasHardwareAcceleration, bool rendererAlwaysFullScreen, QSize maximumResolution, bool supportsHdr)
-{
-    SDL_assert(testWindow);
-
-    if (hasHardwareAcceleration != this->hasHardwareAcceleration) {
-        this->hasHardwareAcceleration = hasHardwareAcceleration;
-        emit hasHardwareAccelerationChanged();
-    }
-
-    if (rendererAlwaysFullScreen != this->rendererAlwaysFullScreen) {
-        this->rendererAlwaysFullScreen = rendererAlwaysFullScreen;
-        emit rendererAlwaysFullScreenChanged();
-    }
-
-    if (maximumResolution != this->maximumResolution) {
-        this->maximumResolution = maximumResolution;
-        emit maximumResolutionChanged();
-    }
-
-    if (supportsHdr != this->supportsHdr) {
-        this->supportsHdr = supportsHdr;
-        emit supportsHdrChanged();
-    }
-
-    SDL_DestroyWindow(testWindow);
-    testWindow = nullptr;
-    SDL_QuitSubSystem(SDL_INIT_VIDEO);
-}
-
-QRect SystemProperties::getNativeResolution(int displayIndex)
-{
-    // Returns default constructed QRect if out of bounds
-    return monitorNativeResolutions.value(displayIndex);
-}
-
-QRect SystemProperties::getSafeAreaResolution(int displayIndex)
-{
-    // Returns default constructed QRect if out of bounds
-    return monitorSafeAreaResolutions.value(displayIndex);
-}
-
-int SystemProperties::getRefreshRate(int displayIndex)
-{
-    // Returns 0 if out of bounds
-    return monitorRefreshRates.value(displayIndex);
-}
-
-void SystemProperties::startAsyncLoad()
-{
-    if (systemPropertyQueryThread) {
-        // Already started/completed
-        return;
-    }
-
-    // This isn't actually asynchronous (due to the need to synchronize with
-    // SdlGamepadKeyNavigation), but we don't query it in the constructor
-    // because it's expensive.
-    unmappedGamepads = SdlInputHandler::getUnmappedGamepads();
-    if (!unmappedGamepads.isEmpty()) {
-        emit unmappedGamepadsChanged();
-    }
-
-    // We initialize the video subsystem and test window on the main thread
-    // because some platforms (macOS) do not support window creation on
-    // non-main threads.
-    if (SDL_InitSubSystem(SDL_INIT_VIDEO) != 0) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                     "SDL_InitSubSystem(SDL_INIT_VIDEO) failed: %s",
-                     SDL_GetError());
-        return;
-    }
-
-    testWindow = StreamUtils::createTestWindow();
-    if (!testWindow) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                     "Failed to create window for hardware decode test: %s",
-                     SDL_GetError());
-        SDL_QuitSubSystem(SDL_INIT_VIDEO);
-        return;
-    }
-
-    // Update display related attributes (max FPS, native resolution, etc).
-    //
-    // NB: SDL3 will forcefully refresh displays when a window is created,
-    // so we place this after the window creation to ensure we don't pay
-    // the penalty for mode enumeration twice.
-    refreshDisplays();
-
-    systemPropertyQueryThread = new SystemPropertyQueryThread(this);
-    systemPropertyQueryThread->start();
-}
-
-void SystemProperties::waitForAsyncLoad()
-{
-    if (systemPropertyQueryThread) {
-        systemPropertyQueryThread->wait();
-    }
-}
-
-void SystemProperties::refreshDisplays()
-{
-    if (SDL_InitSubSystem(SDL_INIT_VIDEO) != 0) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                     "SDL_InitSubSystem(SDL_INIT_VIDEO) failed: %s",
-                     SDL_GetError());
-        return;
-    }
-
-    monitorNativeResolutions.clear();
-    monitorSafeAreaResolutions.clear();
-    monitorRefreshRates.clear();
-
-    SDL_DisplayMode bestMode;
-    for (int displayIndex = 0; displayIndex < SDL_GetNumVideoDisplays(); displayIndex++) {
-        SDL_DisplayMode desktopMode;
-        SDL_Rect safeArea;
-
-        if (StreamUtils::getNativeDesktopMode(displayIndex, &desktopMode, &safeArea)) {
-            if (desktopMode.w <= 8192 && desktopMode.h <= 8192) {
-                // Keep these lists compact because their QML consumers iterate until
-                // the first empty entry. Inserting by SDL display index is invalid if
-                // an earlier display was skipped (for example, a >8K virtual display).
-                monitorNativeResolutions.append(QRect(0, 0, desktopMode.w, desktopMode.h));
-                monitorSafeAreaResolutions.append(QRect(0, 0, safeArea.w, safeArea.h));
-            }
-            else {
-                SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION,
-                            "Skipping resolution over 8K: %dx%d",
-                            desktopMode.w, desktopMode.h);
-            }
-
-            // Start at desktop mode and work our way up
-            bestMode = desktopMode;
-            int numDisplayModes = SDL_GetNumDisplayModes(displayIndex);
-            for (int i = 0; i < numDisplayModes; i++) {
-                SDL_DisplayMode mode;
-                if (SDL_GetDisplayMode(displayIndex, i, &mode) == 0) {
-                    if (mode.w == desktopMode.w && mode.h == desktopMode.h) {
-                        if (mode.refresh_rate > bestMode.refresh_rate) {
-                            bestMode = mode;
-                        }
-                    }
-                }
-            }
-
-            // Try to normalize values around our our standard refresh rates.
-            // Some displays/OSes report values that are slightly off.
-            if (bestMode.refresh_rate >= 58 && bestMode.refresh_rate <= 62) {
-                monitorRefreshRates.append(60);
-            }
-            else if (bestMode.refresh_rate >= 28 && bestMode.refresh_rate <= 32) {
-                monitorRefreshRates.append(30);
-            }
-            else {
-                monitorRefreshRates.append(bestMode.refresh_rate);
-            }
-        }
-    }
-
-    SDL_QuitSubSystem(SDL_INIT_VIDEO);
-}
@@ -1,84 +0,0 @@
-#pragma once
-
-#include <QObject>
-#include <QRect>
-
-#include "SDL_compat.h"
-
-class SystemProperties : public QObject
-{
-    Q_OBJECT
-
-    friend class SystemPropertyQueryThread;
-
-public:
-    SystemProperties();
-    ~SystemProperties();
-
-    // Static properties queried synchronously during the constructor
-    Q_PROPERTY(bool isRunningWayland MEMBER isRunningWayland CONSTANT)
-    Q_PROPERTY(bool isRunningXWayland MEMBER isRunningXWayland CONSTANT)
-    Q_PROPERTY(bool isWow64 MEMBER isWow64 CONSTANT)
-    Q_PROPERTY(bool isDarwin MEMBER isDarwin CONSTANT)
-    Q_PROPERTY(QString friendlyNativeArchName MEMBER friendlyNativeArchName CONSTANT)
-    Q_PROPERTY(bool hasDesktopEnvironment MEMBER hasDesktopEnvironment CONSTANT)
-    Q_PROPERTY(bool hasBrowser MEMBER hasBrowser CONSTANT)
-    Q_PROPERTY(bool hasDiscordIntegration MEMBER hasDiscordIntegration CONSTANT)
-    Q_PROPERTY(bool usesMaterial3Theme MEMBER usesMaterial3Theme CONSTANT)
-    Q_PROPERTY(QString versionString MEMBER versionString CONSTANT)
-
-    // Properties queried asynchronously (startAsyncLoad() must be called!)
-    Q_PROPERTY(bool hasHardwareAcceleration MEMBER hasHardwareAcceleration NOTIFY hasHardwareAccelerationChanged)
-    Q_PROPERTY(bool rendererAlwaysFullScreen MEMBER rendererAlwaysFullScreen NOTIFY rendererAlwaysFullScreenChanged)
-    Q_PROPERTY(QString unmappedGamepads MEMBER unmappedGamepads NOTIFY unmappedGamepadsChanged)
-    Q_PROPERTY(QSize maximumResolution MEMBER maximumResolution NOTIFY maximumResolutionChanged)
-    Q_PROPERTY(bool supportsHdr MEMBER supportsHdr NOTIFY supportsHdrChanged)
-
-    // Either startAsyncLoad()+waitForAsyncLoad() or refreshDisplays() must be invoked first
-    Q_INVOKABLE QRect getNativeResolution(int displayIndex);
-    Q_INVOKABLE QRect getSafeAreaResolution(int displayIndex);
-    Q_INVOKABLE int getRefreshRate(int displayIndex);
-
-    Q_INVOKABLE void startAsyncLoad();
-    Q_INVOKABLE void waitForAsyncLoad();
-    Q_INVOKABLE void refreshDisplays();
-
-signals:
-    void unmappedGamepadsChanged();
-    void hasHardwareAccelerationChanged();
-    void rendererAlwaysFullScreenChanged();
-    void maximumResolutionChanged();
-    void supportsHdrChanged();
-
-private slots:
-    void updateDecoderProperties(bool hasHardwareAcceleration, bool rendererAlwaysFullScreen, QSize maximumResolution, bool supportsHdr);
-
-private:
-    QThread* systemPropertyQueryThread = nullptr;
-    SDL_Window* testWindow = nullptr;
-
-    // Properties set by the constructor
-    bool isRunningWayland;
-    bool isRunningXWayland;
-    bool isWow64;
-    QString friendlyNativeArchName;
-    bool hasDesktopEnvironment;
-    bool hasBrowser;
-    bool hasDiscordIntegration;
-    QString versionString;
-    bool usesMaterial3Theme;
-    bool isDarwin;
-
-    // Properties only set if startAsyncLoad() is called
-    bool hasHardwareAcceleration;
-    bool rendererAlwaysFullScreen;
-    QSize maximumResolution;
-    bool supportsHdr;
-    QString unmappedGamepads;
-
-    // Properties set by refreshDisplays()
-    QList<QRect> monitorNativeResolutions;
-    QList<QRect> monitorSafeAreaResolutions;
-    QList<int> monitorRefreshRates;
-};
-
@@ -1,593 +0,0 @@
-#include "commandlineparser.h"
-
-#include <QCommandLineParser>
-#include <QRegularExpression>
-
-#if defined(Q_OS_WIN)
-#include <qt_windows.h>
-#endif
-
-static bool inRange(int value, int min, int max)
-{
-    return value >= min && value <= max;
-}
-
-// This method returns key's value from QMap where the key is a QString.
-// Key matching is case insensitive.
-template <typename T>
-static T mapValue(QMap<QString, T> map, QString key)
-{
-    for(auto& item : map.toStdMap()) {
-        if (QString::compare(item.first, key, Qt::CaseInsensitive) == 0) {
-            return item.second;
-        }
-    }
-    return T();
-}
-
-class CommandLineParser : public QCommandLineParser
-{
-public:
-    enum MessageType {
-        Info,
-        Error
-    };
-
-    void setupCommonOptions()
-    {
-        setSingleDashWordOptionMode(QCommandLineParser::ParseAsLongOptions);
-        addHelpOption();
-        addVersionOption();
-    }
-
-    void handleHelpAndVersionOptions()
-    {
-        if (isSet("help")) {
-            showInfo(helpText());
-        }
-        if (isSet("version")) {
-            showVersion();
-        }
-    }
-
-    void handleUnknownOptions()
-    {
-        if (!unknownOptionNames().isEmpty()) {
-            showError(QString("Unknown options: %1").arg(unknownOptionNames().join(", ")));
-        }
-    }
-
-    void showMessage(QString message, MessageType type) const
-    {
-        message = message.endsWith('\n') ? message : message + '\n';
-        fputs(qPrintable(message), type == Info ? stdout : stderr);
-    }
-
-    [[ noreturn ]] void showInfo(QString message) const
-    {
-        showMessage(message, Info);
-        exit(0);
-    }
-
-    [[ noreturn ]] void showError(QString message) const
-    {
-        showMessage(message + "\n\n" + helpText(), Error);
-        exit(1);
-    }
-
-    int getIntOption(QString name) const
-    {
-        bool ok;
-        int intValue = value(name).toInt(&ok);
-        if (!ok) {
-            showError(QString("Invalid %1 value: %2").arg(name, value(name)));
-        }
-        return intValue;
-    }
-
-    bool getToggleOptionValue(QString name, bool defaultValue) const
-    {
-        QRegularExpression re(QString("^(%1|no-%1)$").arg(name));
-        QStringList options = optionNames().filter(re);
-        if (options.isEmpty()) {
-            return defaultValue;
-        } else {
-            return options.last() == name;
-        }
-    }
-
-    QString getChoiceOptionValue(QString name) const
-    {
-        if (!m_Choices[name].contains(value(name), Qt::CaseInsensitive)) {
-            showError(QString("Invalid %1 choice: %2").arg(name, value(name)));
-        }
-        return value(name);
-    }
-
-    QPair<int,int> getResolutionOptionValue(QString name) const
-    {
-        static QRegularExpression re("^(\\d+)x(\\d+)$", QRegularExpression::CaseInsensitiveOption);
-        auto match = re.match(value(name));
-        if (!match.hasMatch()) {
-            showError(QString("Invalid %1 format: %2").arg(name, value(name)));
-        }
-        return qMakePair(match.captured(1).toInt(), match.captured(2).toInt());
-    }
-
-    void addFlagOption(QString name, QString descriptiveName)
-    {
-        addOption(QCommandLineOption(name, QString("Use %1.").arg(descriptiveName)));
-    }
-
-    void addToggleOption(QString name, QString descriptiveName)
-    {
-        addOption(QCommandLineOption(name, QString("Use %1.").arg(descriptiveName)));
-        addOption(QCommandLineOption("no-" + name, QString("Do not use %1.").arg(descriptiveName)));
-    }
-
-    void addValueOption(QString name, QString descriptiveName)
-    {
-        addOption(QCommandLineOption(name, QString("Specify %1 to use.").arg(descriptiveName), name));
-    }
-
-    void addChoiceOption(QString name, QString descriptiveName, QStringList choices)
-    {
-        addOption(QCommandLineOption(name, QString("Select %1: %2.").arg(descriptiveName, choices.join('/')), name));
-        m_Choices[name] = choices;
-    }
-
-private:
-    QMap<QString, QStringList> m_Choices;
-};
-
-GlobalCommandLineParser::GlobalCommandLineParser()
-{
-}
-
-GlobalCommandLineParser::~GlobalCommandLineParser()
-{
-}
-
-GlobalCommandLineParser::ParseResult GlobalCommandLineParser::parse(const QStringList &args)
-{
-    CommandLineParser parser;
-    parser.setupCommonOptions();
-    parser.setApplicationDescription(
-        "\n"
-        "Starts Moonlight normally if no arguments are given.\n"
-        "\n"
-        "Available actions:\n"
-        "  list            List the available apps on a host\n"
-        "  quit            Quit the currently running app\n"
-        "  stream          Start streaming an app\n"
-        "  pair            Pair a new host\n"
-        "\n"
-        "See 'moonlight <action> --help' for help of specific action."
-    );
-    parser.addPositionalArgument("action", "Action to execute", "<action>");
-    parser.parse(args);
-    auto posArgs = parser.positionalArguments();
-
-    if (posArgs.isEmpty()) {
-        // This method will not return and terminates the process if --version
-        // or --help is specified
-        parser.handleHelpAndVersionOptions();
-        parser.handleUnknownOptions();
-        return NormalStartRequested;
-    }
-    else {
-        // If users supply arguments that accept values prior to the "quit"
-        // or "stream" positional arguments, we will not be able to correctly
-        // parse the value out of the input because this QCommandLineParser
-        // doesn't know about all of the options that "quit" and "stream"
-        // commands can accept. To work around this issue, we just look
-        // for "quit" or "stream" positional arguments anywhere.
-        for (int i = 0; i < posArgs.size(); i++) {
-            QString action = posArgs.at(i).toLower();
-            if (action == "quit") {
-                return QuitRequested;
-            } else if (action == "stream") {
-                return StreamRequested;
-            } else if (action == "pair") {
-                return PairRequested;
-            } else if (action == "list") {
-                return ListRequested;
-            }
-        }
-
-        parser.showError("Invalid action");
-    }
-}
-
-QuitCommandLineParser::QuitCommandLineParser()
-{
-}
-
-QuitCommandLineParser::~QuitCommandLineParser()
-{
-}
-
-void QuitCommandLineParser::parse(const QStringList &args)
-{
-    CommandLineParser parser;
-    parser.setupCommonOptions();
-    parser.setApplicationDescription(
-        "\n"
-        "Quit the currently running app on the given host."
-    );
-    parser.addPositionalArgument("quit", "quit running app");
-    parser.addPositionalArgument("host", "Host computer name, UUID, or IP address", "<host>");
-
-    if (!parser.parse(args)) {
-        parser.showError(parser.errorText());
-    }
-
-    parser.handleUnknownOptions();
-
-    // This method will not return and terminates the process if --version or
-    // --help is specified
-    parser.handleHelpAndVersionOptions();
-
-    // Verify that host has been provided
-    auto posArgs = parser.positionalArguments();
-    if (posArgs.length() < 2) {
-        parser.showError("Host not provided");
-    }
-    m_Host = parser.positionalArguments().at(1);
-}
-
-QString QuitCommandLineParser::getHost() const
-{
-    return m_Host;
-}
-
-PairCommandLineParser::PairCommandLineParser()
-{
-}
-
-PairCommandLineParser::~PairCommandLineParser()
-{
-}
-
-void PairCommandLineParser::parse(const QStringList &args)
-{
-    CommandLineParser parser;
-    parser.setupCommonOptions();
-    parser.setApplicationDescription(
-        "\n"
-        "Pair with the specified host."
-    );
-    parser.addPositionalArgument("pair", "pair host");
-    parser.addPositionalArgument("host", "Host computer name, UUID, or IP address", "<host>");
-    parser.addValueOption("pin", "4 digit pairing PIN");
-
-    if (!parser.parse(args)) {
-        parser.showError(parser.errorText());
-    }
-
-    parser.handleUnknownOptions();
-
-    // This method will not return and terminates the process if --version or
-    // --help is specified
-    parser.handleHelpAndVersionOptions();
-
-    // Verify that host has been provided
-    auto posArgs = parser.positionalArguments();
-    if (posArgs.length() < 2) {
-        parser.showError("Host not provided");
-    }
-    m_Host = parser.positionalArguments().at(1);
-    m_PredefinedPin = parser.value("pin");
-    if (!m_PredefinedPin.isEmpty() && m_PredefinedPin.length() != 4) {
-        parser.showError("PIN must be 4 digits");
-    }
-}
-
-QString PairCommandLineParser::getHost() const
-{
-    return m_Host;
-}
-
-QString PairCommandLineParser::getPredefinedPin() const
-{
-    return m_PredefinedPin;
-}
-
-StreamCommandLineParser::StreamCommandLineParser()
-{
-    m_WindowModeMap = {
-        {"fullscreen", StreamingPreferences::WM_FULLSCREEN},
-        {"windowed",   StreamingPreferences::WM_WINDOWED},
-        {"borderless", StreamingPreferences::WM_FULLSCREEN_DESKTOP},
-    };
-    m_AudioConfigMap = {
-        {"stereo",       StreamingPreferences::AC_STEREO},
-        {"5.1-surround", StreamingPreferences::AC_51_SURROUND},
-        {"7.1-surround", StreamingPreferences::AC_71_SURROUND},
-    };
-    m_VideoCodecMap = {
-        {"auto",  StreamingPreferences::VCC_AUTO},
-        {"H.264", StreamingPreferences::VCC_FORCE_H264},
-        {"HEVC",  StreamingPreferences::VCC_FORCE_HEVC},
-        {"AV1", StreamingPreferences::VCC_FORCE_AV1},
-    };
-    m_VideoDecoderMap = {
-        {"auto",     StreamingPreferences::VDS_AUTO},
-        {"software", StreamingPreferences::VDS_FORCE_SOFTWARE},
-        {"hardware", StreamingPreferences::VDS_FORCE_HARDWARE},
-    };
-    m_CaptureSysKeysModeMap = {
-        {"never",      StreamingPreferences::CSK_OFF},
-        {"fullscreen", StreamingPreferences::CSK_FULLSCREEN},
-        {"always",     StreamingPreferences::CSK_ALWAYS},
-    };
-}
-
-StreamCommandLineParser::~StreamCommandLineParser()
-{
-}
-
-void StreamCommandLineParser::parse(const QStringList &args, StreamingPreferences *preferences)
-{
-    CommandLineParser parser;
-    parser.setupCommonOptions();
-    parser.setApplicationDescription(
-        "\n"
-        "Starts directly streaming a given app."
-    );
-    parser.addPositionalArgument("stream", "Start stream");
-
-    // Add other arguments and options
-    parser.addPositionalArgument("host", "Host computer name, UUID, or IP address", "<host>");
-    parser.addPositionalArgument("app", "App to stream", "\"<app>\"");
-
-    parser.addFlagOption("720",  "1280x720 resolution");
-    parser.addFlagOption("1080", "1920x1080 resolution");
-    parser.addFlagOption("1440", "2560x1440 resolution");
-    parser.addFlagOption("4K", "3840x2160 resolution");
-    parser.addValueOption("resolution", "custom <width>x<height> resolution");
-    parser.addToggleOption("vsync", "V-Sync");
-    parser.addValueOption("fps", "FPS");
-    parser.addValueOption("bitrate", "bitrate in Kbps");
-    parser.addValueOption("packet-size", "video packet size");
-    parser.addChoiceOption("display-mode", "display mode", m_WindowModeMap.keys());
-    parser.addChoiceOption("audio-config", "audio config", m_AudioConfigMap.keys());
-    parser.addToggleOption("multi-controller", "multiple controller support");
-    parser.addToggleOption("quit-after", "quit app after session");
-    parser.addToggleOption("absolute-mouse", "remote desktop optimized mouse control");
-    parser.addToggleOption("mouse-buttons-swap", "left and right mouse buttons swap");
-    parser.addToggleOption("touchscreen-trackpad", "touchscreen in trackpad mode");
-    parser.addToggleOption("game-optimization", "game optimizations");
-    parser.addToggleOption("audio-on-host", "audio on host PC");
-    parser.addToggleOption("frame-pacing", "frame pacing");
-    parser.addToggleOption("mute-on-focus-loss", "mute audio when Moonlight window loses focus");
-    parser.addToggleOption("background-gamepad", "background gamepad input");
-    parser.addToggleOption("reverse-scroll-direction", "inverted scroll direction");
-    parser.addToggleOption("swap-gamepad-buttons", "swap A/B and X/Y gamepad buttons (Nintendo-style)");
-    parser.addToggleOption("keep-awake", "prevent display sleep while streaming");
-    parser.addToggleOption("performance-overlay", "show performance overlay");
-    parser.addToggleOption("hdr", "HDR streaming");
-    parser.addToggleOption("yuv444", "YUV 4:4:4 sampling, if supported");
-    parser.addChoiceOption("capture-system-keys", "capture system key combos", m_CaptureSysKeysModeMap.keys());
-    parser.addChoiceOption("video-codec", "video codec", m_VideoCodecMap.keys());
-    parser.addChoiceOption("video-decoder", "video decoder", m_VideoDecoderMap.keys());
-
-    if (!parser.parse(args)) {
-        parser.showError(parser.errorText());
-    }
-
-    parser.handleUnknownOptions();
-
-    // Resolve display's width and height
-    static QRegularExpression resolutionRexExp("^(720|1080|1440|4K|resolution)$");
-    QStringList resoOptions = parser.optionNames().filter(resolutionRexExp);
-    bool displaySet = !resoOptions.isEmpty();
-    if (displaySet) {
-        QString name = resoOptions.last();
-        if (name == "720") {
-            preferences->width  = 1280;
-            preferences->height = 720;
-        } else if (name == "1080") {
-            preferences->width  = 1920;
-            preferences->height = 1080;
-        } else if (name == "1440") {
-            preferences->width  = 2560;
-            preferences->height = 1440;
-        } else if (name == "4K") {
-            preferences->width  = 3840;
-            preferences->height = 2160;
-        } else if (name == "resolution") {
-            auto resolution = parser.getResolutionOptionValue(name);
-            preferences->width  = resolution.first;
-            preferences->height = resolution.second;
-        }
-    }
-
-    // Resolve --fps option
-    if (parser.isSet("fps")) {
-        preferences->fps = parser.getIntOption("fps");
-        if (!inRange(preferences->fps, 10, 480)) {
-            fprintf(stderr, "Warning: FPS is out of the supported range (10 - 480 FPS). Performance may suffer!\n");
-        }
-    }
-
-    // Resolve --bitrate option
-    if (parser.isSet("bitrate")) {
-        preferences->bitrateKbps = parser.getIntOption("bitrate");
-        if (!inRange(preferences->bitrateKbps, 500, 500000)) {
-            fprintf(stderr, "Warning: Bitrate is out of the supported range (500 - 500000 Kbps). Performance may suffer!\n");
-        }
-    } else if (displaySet || parser.isSet("fps")) {
-        preferences->bitrateKbps = preferences->getDefaultBitrate(
-            preferences->width, preferences->height, preferences->fps, preferences->enableYUV444);
-    }
-
-    // Resolve --packet-size option
-    if (parser.isSet("packet-size")) {
-        preferences->packetSize = parser.getIntOption("packet-size");
-        if (preferences->packetSize < 1024) {
-            parser.showError("Packet size must be greater than 1024 bytes");
-        }
-    }
-
-    // Resolve --display option
-    if (parser.isSet("display-mode")) {
-        preferences->windowMode = mapValue(m_WindowModeMap, parser.getChoiceOptionValue("display-mode"));
-    }
-
-    // Resolve --vsync and --no-vsync options
-    preferences->enableVsync = parser.getToggleOptionValue("vsync", preferences->enableVsync);
-
-    // Resolve --audio-config option
-    if (parser.isSet("audio-config")) {
-        preferences->audioConfig = mapValue(m_AudioConfigMap, parser.getChoiceOptionValue("audio-config"));
-    }
-
-    // Resolve --multi-controller and --no-multi-controller options
-    preferences->multiController = parser.getToggleOptionValue("multi-controller", preferences->multiController);
-
-    // Resolve --quit-after and --no-quit-after options
-    preferences->quitAppAfter = parser.getToggleOptionValue("quit-after", preferences->quitAppAfter);
-
-    // Resolve --absolute-mouse and --no-absolute-mouse options
-    preferences->absoluteMouseMode = parser.getToggleOptionValue("absolute-mouse", preferences->absoluteMouseMode);
-
-    // Resolve --mouse-buttons-swap and --no-mouse-buttons-swap options
-    preferences->swapMouseButtons = parser.getToggleOptionValue("mouse-buttons-swap", preferences->swapMouseButtons);
-
-    // Resolve --touchscreen-trackpad and --no-touchscreen-trackpad options
-    preferences->absoluteTouchMode = !parser.getToggleOptionValue("touchscreen-trackpad", !preferences->absoluteTouchMode);
-
-    // Resolve --game-optimization and --no-game-optimization options
-    preferences->gameOptimizations = parser.getToggleOptionValue("game-optimization", preferences->gameOptimizations);
-
-    // Resolve --audio-on-host and --no-audio-on-host options
-    preferences->playAudioOnHost = parser.getToggleOptionValue("audio-on-host", preferences->playAudioOnHost);
-
-    // Resolve --frame-pacing and --no-frame-pacing options
-    preferences->framePacing = parser.getToggleOptionValue("frame-pacing", preferences->framePacing);
-
-    // Resolve --mute-on-focus-loss and --no-mute-on-focus-loss options
-    preferences->muteOnFocusLoss = parser.getToggleOptionValue("mute-on-focus-loss", preferences->muteOnFocusLoss);
-
-    // Resolve --background-gamepad and --no-background-gamepad options
-    preferences->backgroundGamepad = parser.getToggleOptionValue("background-gamepad", preferences->backgroundGamepad);
-
-    // Resolve --reverse-scroll-direction and --no-reverse-scroll-direction options
-    preferences->reverseScrollDirection = parser.getToggleOptionValue("reverse-scroll-direction", preferences->reverseScrollDirection);
-
-    // Resolve --swap-gamepad-buttons and --no-swap-gamepad-buttons options
-    preferences->swapFaceButtons = parser.getToggleOptionValue("swap-gamepad-buttons", preferences->swapFaceButtons);
-
-    // Resolve --keep-awake and --no-keep-awake options
-    preferences->keepAwake = parser.getToggleOptionValue("keep-awake", preferences->keepAwake);
-
-    // Resolve --performance-overlay and --no-performance-overlay options
-    preferences->showPerformanceOverlay = parser.getToggleOptionValue("performance-overlay", preferences->showPerformanceOverlay);
-
-    // Resolve --hdr and --no-hdr options
-    preferences->enableHdr = parser.getToggleOptionValue("hdr", preferences->enableHdr);
-
-    // Resolve --yuv444 and --no-yuv444 options
-    preferences->enableYUV444 = parser.getToggleOptionValue("yuv444", preferences->enableYUV444);
-    
-    // Resolve --capture-system-keys option
-    if (parser.isSet("capture-system-keys")) {
-        preferences->captureSysKeysMode = mapValue(m_CaptureSysKeysModeMap, parser.getChoiceOptionValue("capture-system-keys"));
-    }
-
-    // Resolve --video-codec option
-    if (parser.isSet("video-codec")) {
-        preferences->videoCodecConfig = mapValue(m_VideoCodecMap, parser.getChoiceOptionValue("video-codec"));
-    }
-
-    // Resolve --video-decoder option
-    if (parser.isSet("video-decoder")) {
-        preferences->videoDecoderSelection = mapValue(m_VideoDecoderMap, parser.getChoiceOptionValue("video-decoder"));
-    }
-
-    // This method will not return and terminates the process if --version or
-    // --help is specified
-    parser.handleHelpAndVersionOptions();
-
-    // Verify that both host and app has been provided
-    auto posArgs = parser.positionalArguments();
-    if (posArgs.length() < 2) {
-        parser.showError("Host not provided");
-    }
-    m_Host = parser.positionalArguments().at(1);
-
-    if (posArgs.length() < 3) {
-        parser.showError("App not provided");
-    }
-    m_AppName = parser.positionalArguments().at(2);
-}
-
-QString StreamCommandLineParser::getHost() const
-{
-    return m_Host;
-}
-
-QString StreamCommandLineParser::getAppName() const
-{
-    return m_AppName;
-}
-
-ListCommandLineParser::ListCommandLineParser()
-{
-}
-
-ListCommandLineParser::~ListCommandLineParser()
-{
-}
-
-void ListCommandLineParser::parse(const QStringList &args)
-{
-    CommandLineParser parser;
-    parser.setupCommonOptions();
-    parser.setApplicationDescription(
-        "\n"
-        "List the available apps on the given host."
-    );
-    parser.addPositionalArgument("list", "list available apps");
-    parser.addPositionalArgument("host", "Host computer name, UUID, or IP address", "<host>");
-
-    parser.addFlagOption("csv",     "Print as CSV with additional information");
-    parser.addFlagOption("verbose", "Displays additional information");
-
-    if (!parser.parse(args)) {
-        parser.showError(parser.errorText());
-    }
-
-    parser.handleUnknownOptions();
-
-
-    m_PrintCSV = parser.isSet("csv");
-    m_Verbose = parser.isSet("verbose");
-
-    // This method will not return and terminates the process if --version or
-    // --help is specified
-    parser.handleHelpAndVersionOptions();
-
-    // Verify that host has been provided
-    auto posArgs = parser.positionalArguments();
-    if (posArgs.length() < 2) {
-        parser.showError("Host not provided");
-    }
-    m_Host = parser.positionalArguments().at(1);
-}
-
-QString ListCommandLineParser::getHost() const
-{
-    return m_Host;
-}
-
-bool ListCommandLineParser::isPrintCSV() const
-{
-    return m_PrintCSV;
-}
-
-bool ListCommandLineParser::isVerbose() const
-{
-    return m_Verbose;
-}
@@ -1,93 +0,0 @@
-#pragma once
-
-#include "settings/streamingpreferences.h"
-
-#include <QMap>
-#include <QString>
-
-class GlobalCommandLineParser
-{
-public:
-    enum ParseResult {
-        NormalStartRequested,
-        StreamRequested,
-        QuitRequested,
-        PairRequested,
-        ListRequested,
-    };
-
-    GlobalCommandLineParser();
-    virtual ~GlobalCommandLineParser();
-
-    ParseResult parse(const QStringList &args);
-
-};
-
-class QuitCommandLineParser
-{
-public:
-    QuitCommandLineParser();
-    virtual ~QuitCommandLineParser();
-
-    void parse(const QStringList &args);
-
-    QString getHost() const;
-
-private:
-    QString m_Host;
-};
-
-class PairCommandLineParser
-{
-public:
-    PairCommandLineParser();
-    virtual ~PairCommandLineParser();
-
-    void parse(const QStringList &args);
-
-    QString getHost() const;
-    QString getPredefinedPin() const;
-
-private:
-    QString m_Host;
-    QString m_PredefinedPin;
-};
-
-class StreamCommandLineParser
-{
-public:
-    StreamCommandLineParser();
-    virtual ~StreamCommandLineParser();
-
-    void parse(const QStringList &args, StreamingPreferences *preferences);
-
-    QString getHost() const;
-    QString getAppName() const;
-
-private:
-    QString m_Host;
-    QString m_AppName;
-    QMap<QString, StreamingPreferences::WindowMode> m_WindowModeMap;
-    QMap<QString, StreamingPreferences::AudioConfig> m_AudioConfigMap;
-    QMap<QString, StreamingPreferences::VideoCodecConfig> m_VideoCodecMap;
-    QMap<QString, StreamingPreferences::VideoDecoderSelection> m_VideoDecoderMap;
-    QMap<QString, StreamingPreferences::CaptureSysKeysMode> m_CaptureSysKeysModeMap;
-};
-
-class ListCommandLineParser
-{
-public:
-    ListCommandLineParser();
-    virtual ~ListCommandLineParser();
-
-    void parse(const QStringList &args);
-
-    QString getHost() const;
-    bool isPrintCSV() const;
-    bool isVerbose() const;
-
-private:
-    QString m_Host;
-    bool m_PrintCSV;
-    bool m_Verbose;
-};
@@ -1,196 +0,0 @@
-#include "listapps.h"
-
-#include "backend/boxartmanager.h"
-#include "backend/computermanager.h"
-#include "backend/computerseeker.h"
-
-#include <QCoreApplication>
-
-#define COMPUTER_SEEK_TIMEOUT 30000
-
-namespace CliListApps
-{
-
-enum State {
-    StateInit,
-    StateSeekComputer,
-    StateListApps,
-    StateFailure,
-};
-
-class Event
-{
-public:
-    enum Type {
-        ComputerFound,
-        ComputerSeekTimedout,
-        Executed,
-    };
-
-    Event(Type type)
-        : type(type), computerManager(nullptr), computer(nullptr) {}
-
-    Type type;
-    ComputerManager *computerManager;
-    NvComputer *computer;
-    QString errorMessage;
-};
-
-class LauncherPrivate
-{
-    Q_DECLARE_PUBLIC(Launcher)
-
-public:
-    LauncherPrivate(Launcher *q) : q_ptr(q) {}
-
-    void handleEvent(Event event)
-    {
-        Q_Q(Launcher);
-        NvApp app;
-
-        switch (event.type) {
-        // Occurs when CLI main calls execute
-        case Event::Executed:
-            if (m_State == StateInit) {
-                m_State = StateSeekComputer;
-                m_ComputerManager = event.computerManager;
-
-                m_ComputerSeeker = new ComputerSeeker(m_ComputerManager, m_ComputerName, q);
-                q->connect(m_ComputerSeeker, &ComputerSeeker::computerFound,
-                           q, &Launcher::onComputerFound);
-                q->connect(m_ComputerSeeker, &ComputerSeeker::errorTimeout,
-                           q, &Launcher::onComputerSeekTimeout);
-                m_ComputerSeeker->start(COMPUTER_SEEK_TIMEOUT);
-
-                m_BoxArtManager = new BoxArtManager(q);
-
-                if (m_Arguments.isVerbose()) {
-                    fprintf(stdout, "Establishing connection to PC...\n");
-                }
-            }
-            break;
-        // Occurs when computer search timed out
-        case Event::ComputerSeekTimedout:
-            if (m_State == StateSeekComputer) {
-                fprintf(stderr, "%s\n", qPrintable(QString("Failed to connect to %1").arg(m_ComputerName)));
-
-                QCoreApplication::exit(-1);
-            }
-            break;
-        // Occurs when searched computer is found
-        case Event::ComputerFound:
-            if (m_State == StateSeekComputer) {
-                if (event.computer->pairState == NvComputer::PS_PAIRED) {
-                    m_State = StateListApps;
-                    m_Computer = event.computer;
-
-                    if (m_Arguments.isVerbose()) {
-                        fprintf(stdout, "Loading app list...\n");
-                    }
-
-                    // To avoid race conditions where ComputerSeeker stops async polling, but
-                    // ComputerManager is yet to update the app list, we will explicitly fetch the latest app list.
-                    // Otherwise, it becomes complicated as we would have to guess whether ComputerManager
-                    // would emit 1 signal (the list did not change) or 2 signals (indicating that the list has changed)
-                    try {
-                        NvHTTP http{m_Computer};
-
-                        const auto appList = http.getAppList();
-                        m_Arguments.isPrintCSV() ? printAppsCSV(appList) : printApps(appList);
-
-                        QCoreApplication::exit(0);
-                    } catch (std::exception& exception) {
-                        fprintf(stderr, "%s\n", exception.what());
-                        QCoreApplication::exit(1);
-                    }
-                } else {
-                    m_State = StateFailure;
-                    fprintf(stderr, "%s\n", qPrintable(QObject::tr("Computer %1 has not been paired. "
-                                            "Please open Moonlight to pair before retrieving games list.")
-                                            .arg(event.computer->name)));
-
-                    QCoreApplication::exit(-1);
-                }
-            }
-            break;
-        }
-    }
-
-    void printApps(QVector<NvApp> apps) {
-        for (int i = 0; i < apps.length(); i++) {
-            fprintf(stdout, "%s\n", qPrintable(apps[i].name));
-        }
-    }
-
-    void printAppsCSV(QVector<NvApp> apps) {
-        fprintf(stdout, "Name, ID, HDR Support, App Collection Game, Hidden, Direct Launch, Boxart URL\n");
-        for (int i = 0; i < apps.length(); i++) {
-            printAppCSV(apps[i]);
-        }
-    }
-
-    void printAppCSV(NvApp app) const
-    {
-        fprintf(stdout, "\"%s\",%d,%s,%s,%s,%s,\"%s\"\n", qPrintable(app.name),
-                                                          app.id,
-                                                          app.hdrSupported ? "true" : "false",
-                                                          app.isAppCollectorGame ? "true" : "false",
-                                                          app.hidden ? "true" : "false",
-                                                          app.directLaunch ? "true" : "false",
-                                                          qPrintable(m_BoxArtManager->loadBoxArt(m_Computer, app).toDisplayString()));
-    }
-
-    Launcher *q_ptr;
-    ComputerManager *m_ComputerManager;
-    QString m_ComputerName;
-    ComputerSeeker *m_ComputerSeeker;
-    BoxArtManager *m_BoxArtManager;
-    NvComputer *m_Computer;
-    State m_State;
-    ListCommandLineParser m_Arguments;
-};
-
-Launcher::Launcher(QString computer, ListCommandLineParser arguments, QObject *parent)
-    : QObject(parent),
-      m_DPtr(new LauncherPrivate(this))
-{
-    Q_D(Launcher);
-    d->m_ComputerName = computer;
-    d->m_State = StateInit;
-    d->m_Arguments = arguments;
-}
-
-Launcher::~Launcher()
-{
-}
-
-void Launcher::execute(ComputerManager *manager)
-{
-    Q_D(Launcher);
-    Event event(Event::Executed);
-    event.computerManager = manager;
-    d->handleEvent(event);
-}
-
-bool Launcher::isExecuted() const
-{
-    Q_D(const Launcher);
-    return d->m_State != StateInit;
-}
-
-void Launcher::onComputerFound(NvComputer *computer)
-{
-    Q_D(Launcher);
-    Event event(Event::ComputerFound);
-    event.computer = computer;
-    d->handleEvent(event);
-}
-
-void Launcher::onComputerSeekTimeout()
-{
-    Q_D(Launcher);
-    Event event(Event::ComputerSeekTimedout);
-    d->handleEvent(event);
-}
-
-}
@@ -1,37 +0,0 @@
-#pragma once
-
-#include "commandlineparser.h"
-
-#include <QObject>
-#include <QVariant>
-
-class ComputerManager;
-class NvComputer;
-
-namespace CliListApps
-{
-
-class LauncherPrivate;
-
-class Launcher : public QObject
-{
-    Q_OBJECT
-    Q_DECLARE_PRIVATE_D(m_DPtr, Launcher)
-
-public:
-    explicit Launcher(QString computer, ListCommandLineParser arguments, QObject *parent = nullptr);
-    ~Launcher();
-
-    Q_INVOKABLE void execute(ComputerManager *manager);
-    Q_INVOKABLE bool isExecuted() const;
-
-private slots:
-    void onComputerFound(NvComputer *computer);
-    void onComputerSeekTimeout();
-
-private:
-    QScopedPointer<LauncherPrivate> m_DPtr;
-    ListCommandLineParser m_Arguments;
-};
-
-}
@@ -1,181 +0,0 @@
-#include "pair.h"
-
-#include "backend/computermanager.h"
-#include "backend/computerseeker.h"
-#include <QCoreApplication>
-#include <QTimer>
-
-#define COMPUTER_SEEK_TIMEOUT 10000
-
-namespace CliPair
-{
-
-enum State {
-    StateInit,
-    StateSeekComputer,
-    StatePairing,
-    StateFailure,
-    StateComplete,
-};
-
-class Event
-{
-public:
-    enum Type {
-        ComputerFound,
-        Executed,
-        PairingCompleted,
-        Timedout,
-    };
-
-    Event(Type type)
-        : type(type), computerManager(nullptr), computer(nullptr) {}
-
-    Type type;
-    ComputerManager *computerManager;
-    NvComputer *computer;
-    QString errorMessage;
-};
-
-class LauncherPrivate
-{
-    Q_DECLARE_PUBLIC(Launcher)
-
-public:
-    LauncherPrivate(Launcher *q) : q_ptr(q) {}
-
-    void handleEvent(Event event)
-    {
-        Q_Q(Launcher);
-
-        switch (event.type) {
-        // Occurs when CliPair becomes visible and the UI calls launcher's execute()
-        case Event::Executed:
-            if (m_State == StateInit) {
-                m_State = StateSeekComputer;
-                m_ComputerManager = event.computerManager;
-                q->connect(m_ComputerManager, &ComputerManager::pairingCompleted,
-                           q, &Launcher::onPairingCompleted);
-
-                // If we weren't provided a predefined PIN, generate one now
-                if (m_PredefinedPin.isEmpty()) {
-                    m_PredefinedPin = m_ComputerManager->generatePinString();
-                }
-
-                m_ComputerSeeker = new ComputerSeeker(m_ComputerManager, m_ComputerName, q);
-                q->connect(m_ComputerSeeker, &ComputerSeeker::computerFound,
-                           q, &Launcher::onComputerFound);
-                q->connect(m_ComputerSeeker, &ComputerSeeker::errorTimeout,
-                           q, &Launcher::onTimeout);
-                m_ComputerSeeker->start(COMPUTER_SEEK_TIMEOUT);
-
-                emit q->searchingComputer();
-            }
-            break;
-        // Occurs when searched computer is found
-        case Event::ComputerFound:
-            if (m_State == StateSeekComputer) {
-                if (event.computer->pairState == NvComputer::PS_PAIRED) {
-                    m_State = StateFailure;
-                    QString msg = QObject::tr("%1 is already paired").arg(event.computer->name);
-                    emit q->failed(msg);
-                }
-                else {
-                    Q_ASSERT(!m_PredefinedPin.isEmpty());
-
-                    m_State = StatePairing;
-                    m_ComputerManager->pairHost(event.computer, m_PredefinedPin);
-                    emit q->pairing(event.computer->name, m_PredefinedPin);
-                }
-            }
-            break;
-        // Occurs when pairing operation completes
-        case Event::PairingCompleted:
-            if (m_State == StatePairing) {
-                if (event.errorMessage.isEmpty()) {
-                    m_State = StateComplete;
-                    emit q->success();
-                }
-                else {
-                    m_State = StateFailure;
-                    emit q->failed(event.errorMessage);
-                }
-            }
-            break;
-        // Occurs when computer search timed out
-        case Event::Timedout:
-            if (m_State == StateSeekComputer) {
-                m_State = StateFailure;
-                emit q->failed(QObject::tr("Failed to connect to %1").arg(m_ComputerName));
-            }
-            break;
-        }
-    }
-
-    Launcher *q_ptr;
-    QString m_ComputerName;
-    QString m_PredefinedPin;
-    ComputerManager *m_ComputerManager;
-    ComputerSeeker *m_ComputerSeeker;
-    NvComputer *m_Computer;
-    State m_State;
-    QTimer *m_TimeoutTimer;
-};
-
-Launcher::Launcher(QString computer, QString predefinedPin, QObject *parent)
-    : QObject(parent),
-      m_DPtr(new LauncherPrivate(this))
-{
-    Q_D(Launcher);
-    d->m_ComputerName = computer;
-    d->m_PredefinedPin = predefinedPin;
-    d->m_State = StateInit;
-    d->m_TimeoutTimer = new QTimer(this);
-    d->m_TimeoutTimer->setSingleShot(true);
-    connect(d->m_TimeoutTimer, &QTimer::timeout,
-            this, &Launcher::onTimeout);
-}
-
-Launcher::~Launcher()
-{
-}
-
-void Launcher::execute(ComputerManager *manager)
-{
-    Q_D(Launcher);
-    Event event(Event::Executed);
-    event.computerManager = manager;
-    d->handleEvent(event);
-}
-
-bool Launcher::isExecuted() const
-{
-    Q_D(const Launcher);
-    return d->m_State != StateInit;
-}
-
-void Launcher::onComputerFound(NvComputer *computer)
-{
-    Q_D(Launcher);
-    Event event(Event::ComputerFound);
-    event.computer = computer;
-    d->handleEvent(event);
-}
-
-void Launcher::onTimeout()
-{
-    Q_D(Launcher);
-    Event event(Event::Timedout);
-    d->handleEvent(event);
-}
-
-void Launcher::onPairingCompleted(NvComputer* computer, QString error)
-{
-    Q_D(Launcher);
-    Event event(Event::PairingCompleted);
-    event.computer = computer;
-    event.errorMessage = error;
-    d->handleEvent(event);
-}
-
-}
@@ -1,44 +0,0 @@
-#pragma once
-
-#include <QObject>
-#include <QVariant>
-
-class ComputerManager;
-class NvComputer;
-class Session;
-class StreamingPreferences;
-
-namespace CliPair
-{
-
-class Event;
-class LauncherPrivate;
-
-class Launcher : public QObject
-{
-    Q_OBJECT
-    Q_DECLARE_PRIVATE_D(m_DPtr, Launcher)
-
-public:
-    explicit Launcher(QString computer, QString predefinedPin,
-                      QObject *parent = nullptr);
-    ~Launcher();
-    Q_INVOKABLE void execute(ComputerManager *manager);
-    Q_INVOKABLE bool isExecuted() const;
-
-signals:
-    void searchingComputer();
-    void pairing(QString pcName, QString pin);
-    void failed(QString text);
-    void success();
-
-private slots:
-    void onComputerFound(NvComputer *computer);
-    void onPairingCompleted(NvComputer *computer, QString error);
-    void onTimeout();
-
-private:
-    QScopedPointer<LauncherPrivate> m_DPtr;
-};
-
-}
@@ -1,171 +0,0 @@
-#include "quitstream.h"
-
-#include "backend/computermanager.h"
-#include "backend/computerseeker.h"
-#include "streaming/session.h"
-
-#include <QCoreApplication>
-#include <QTimer>
-
-#define COMPUTER_SEEK_TIMEOUT 10000
-
-namespace CliQuitStream
-{
-
-enum State {
-    StateInit,
-    StateSeekComputer,
-    StateQuitApp,
-    StateFailure,
-};
-
-class Event
-{
-public:
-    enum Type {
-        AppQuitCompleted,
-        ComputerFound,
-        ComputerSeekTimedout,
-        Executed,
-    };
-
-    Event(Type type)
-        : type(type), computerManager(nullptr), computer(nullptr) {}
-
-    Type type;
-    ComputerManager *computerManager;
-    NvComputer *computer;
-    QString errorMessage;
-};
-
-class LauncherPrivate
-{
-    Q_DECLARE_PUBLIC(Launcher)
-
-public:
-    LauncherPrivate(Launcher *q) : q_ptr(q) {}
-
-    void handleEvent(Event event)
-    {
-        Q_Q(Launcher);
-        NvApp app;
-
-        switch (event.type) {
-        // Occurs when CliQuitStreamSegue becomes visible and the UI calls launcher's execute()
-        case Event::Executed:
-            if (m_State == StateInit) {
-                m_State = StateSeekComputer;
-                m_ComputerManager = event.computerManager;
-                q->connect(m_ComputerManager, &ComputerManager::quitAppCompleted,
-                           q, &Launcher::onQuitAppCompleted);
-
-                m_ComputerSeeker = new ComputerSeeker(m_ComputerManager, m_ComputerName, q);
-                q->connect(m_ComputerSeeker, &ComputerSeeker::computerFound,
-                           q, &Launcher::onComputerFound);
-                q->connect(m_ComputerSeeker, &ComputerSeeker::errorTimeout,
-                           q, &Launcher::onComputerSeekTimeout);
-                m_ComputerSeeker->start(COMPUTER_SEEK_TIMEOUT);
-
-                emit q->searchingComputer();
-            }
-            break;
-        // Occurs when computer search timed out
-        case Event::ComputerSeekTimedout:
-            if (m_State == StateSeekComputer) {
-                m_State = StateFailure;
-                emit q->failed(QObject::tr("Failed to connect to %1").arg(m_ComputerName));
-            }
-            break;
-        // Occurs when searched computer is found
-        case Event::ComputerFound:
-            if (m_State == StateSeekComputer) {
-                if (event.computer->pairState == NvComputer::PS_PAIRED) {
-                    m_State = StateQuitApp;
-                    emit q->quittingApp();
-                    m_ComputerManager->quitRunningApp(event.computer);
-                } else {
-                    m_State = StateFailure;
-                    QString msg = QObject::tr("Computer %1 has not been paired. "
-                                              "Please open Moonlight to pair before streaming.")
-                            .arg(event.computer->name);
-                    emit q->failed(msg);
-                }
-            }
-            break;
-        // Occurs when app quit completed (error message is set if failed)
-        case Event::AppQuitCompleted:
-            if (m_State == StateQuitApp) {
-                if (event.errorMessage.isEmpty()) {
-                    QCoreApplication::exit(0);
-                } else {
-                    m_State = StateFailure;
-                    emit q->failed(QObject::tr("Quitting app failed, reason: %1").arg(event.errorMessage));
-                }
-            }
-            break;
-        }
-    }
-
-    Launcher *q_ptr;
-    ComputerManager *m_ComputerManager;
-    QString m_ComputerName;
-    ComputerSeeker *m_ComputerSeeker;
-    State m_State;
-    QTimer *m_TimeoutTimer;
-};
-
-Launcher::Launcher(QString computer, QObject *parent)
-    : QObject(parent),
-      m_DPtr(new LauncherPrivate(this))
-{
-    Q_D(Launcher);
-    d->m_ComputerName = computer;
-    d->m_State = StateInit;
-    d->m_TimeoutTimer = new QTimer(this);
-    d->m_TimeoutTimer->setSingleShot(true);
-    connect(d->m_TimeoutTimer, &QTimer::timeout,
-            this, &Launcher::onComputerSeekTimeout);
-}
-
-Launcher::~Launcher()
-{
-}
-
-void Launcher::execute(ComputerManager *manager)
-{
-    Q_D(Launcher);
-    Event event(Event::Executed);
-    event.computerManager = manager;
-    d->handleEvent(event);
-}
-
-bool Launcher::isExecuted() const
-{
-    Q_D(const Launcher);
-    return d->m_State != StateInit;
-}
-
-void Launcher::onComputerFound(NvComputer *computer)
-{
-    Q_D(Launcher);
-    Event event(Event::ComputerFound);
-    event.computer = computer;
-    d->handleEvent(event);
-}
-
-void Launcher::onComputerSeekTimeout()
-{
-    Q_D(Launcher);
-    Event event(Event::ComputerSeekTimedout);
-    d->handleEvent(event);
-}
-
-void Launcher::onQuitAppCompleted(QVariant error)
-{
-    Q_D(Launcher);
-    Event event(Event::AppQuitCompleted);
-    event.errorMessage = error.toString();
-    d->handleEvent(event);
-}
-
-}
@@ -1,40 +0,0 @@
-#pragma once
-
-#include <QObject>
-#include <QVariant>
-
-class ComputerManager;
-class NvComputer;
-
-namespace CliQuitStream
-{
-
-class LauncherPrivate;
-
-class Launcher : public QObject
-{
-    Q_OBJECT
-    Q_DECLARE_PRIVATE_D(m_DPtr, Launcher)
-
-public:
-    explicit Launcher(QString computer, QObject *parent = nullptr);
-    ~Launcher();
-
-    Q_INVOKABLE void execute(ComputerManager *manager);
-    Q_INVOKABLE bool isExecuted() const;
-
-signals:
-    void searchingComputer();
-    void quittingApp();
-    void failed(QString text);
-
-private slots:
-    void onComputerFound(NvComputer *computer);
-    void onComputerSeekTimeout();
-    void onQuitAppCompleted(QVariant error);
-
-private:
-    QScopedPointer<LauncherPrivate> m_DPtr;
-};
-
-}
@@ -1,256 +0,0 @@
-#include "startstream.h"
-#include "backend/computermanager.h"
-#include "backend/computerseeker.h"
-#include "streaming/session.h"
-
-#include <QCoreApplication>
-#include <QTimer>
-
-#define COMPUTER_SEEK_TIMEOUT 30000
-#define APP_SEEK_TIMEOUT 10000
-
-namespace CliStartStream
-{
-
-enum State {
-    StateInit,
-    StateSeekComputer,
-    StateSeekApp,
-    StateStartSession,
-    StateFailure,
-};
-
-class Event
-{
-public:
-    enum Type {
-        AppQuitCompleted,
-        AppQuitRequested,
-        ComputerFound,
-        ComputerUpdated,
-        Executed,
-        Timedout,
-    };
-
-    Event(Type type)
-        : type(type), computerManager(nullptr), computer(nullptr) {}
-
-    Type type;
-    ComputerManager *computerManager;
-    NvComputer *computer;
-    QString errorMessage;
-};
-
-class LauncherPrivate
-{
-    Q_DECLARE_PUBLIC(Launcher)
-
-public:
-    LauncherPrivate(Launcher *q) : q_ptr(q) {}
-
-    void handleEvent(Event event)
-    {
-        Q_Q(Launcher);
-        Session* session;
-        NvApp app;
-
-        switch (event.type) {
-        // Occurs when CliStartStreamSegue becomes visible and the UI calls launcher's execute()
-        case Event::Executed:
-            if (m_State == StateInit) {
-                m_State = StateSeekComputer;
-                m_ComputerManager = event.computerManager;
-
-                m_ComputerSeeker = new ComputerSeeker(m_ComputerManager, m_ComputerName, q);
-                q->connect(m_ComputerSeeker, &ComputerSeeker::computerFound,
-                           q, &Launcher::onComputerFound);
-                q->connect(m_ComputerSeeker, &ComputerSeeker::errorTimeout,
-                           q, &Launcher::onTimeout);
-                m_ComputerSeeker->start(COMPUTER_SEEK_TIMEOUT);
-
-                q->connect(m_ComputerManager, &ComputerManager::computerStateChanged,
-                           q, &Launcher::onComputerUpdated);
-                q->connect(m_ComputerManager, &ComputerManager::quitAppCompleted,
-                           q, &Launcher::onQuitAppCompleted);
-
-                emit q->searchingComputer();
-            }
-            break;
-        // Occurs when searched computer is found
-        case Event::ComputerFound:
-            if (m_State == StateSeekComputer) {
-                if (event.computer->pairState == NvComputer::PS_PAIRED) {
-                    m_State = StateSeekApp;
-                    m_Computer = event.computer;
-                    m_TimeoutTimer->start(APP_SEEK_TIMEOUT);
-                    emit q->searchingApp();
-                } else {
-                    m_State = StateFailure;
-                    QString msg = QObject::tr("Computer %1 has not been paired. "
-                                              "Please open Moonlight to pair before streaming.")
-                            .arg(event.computer->name);
-                    emit q->failed(msg);
-                }
-            }
-            break;
-        // Occurs when a computer is updated
-        case Event::ComputerUpdated:
-            if (m_State == StateSeekApp) {
-                int index = getAppIndex();
-                if (-1 != index) {
-                    app = m_Computer->appList[index];
-                    m_TimeoutTimer->stop();
-                    if (isNotStreaming() || isStreamingApp(app)) {
-                        m_State = StateStartSession;
-                        session = new Session(m_Computer, app, m_Preferences);
-                        emit q->sessionCreated(app.name, session);
-                    } else {
-                        emit q->appQuitRequired(getCurrentAppName());
-                    }
-                }
-            }
-            break;
-        // Occurs when there was another app running on computer and user accepted quit
-        // confirmation dialog
-        case Event::AppQuitRequested:
-            if (m_State == StateSeekApp) {
-                m_ComputerManager->quitRunningApp(m_Computer);
-            }
-            break;
-        // Occurs when the previous app quit has been completed, handles quitting errors if any
-        // happened. ComputerUpdated event's handler handles session start when previous app has
-        // quit.
-        case Event::AppQuitCompleted:
-            if (m_State == StateSeekApp && !event.errorMessage.isEmpty()) {
-                m_State = StateFailure;
-                emit q->failed(QObject::tr("Quitting app failed, reason: %1").arg(event.errorMessage));
-            }
-            break;
-        // Occurs when computer or app search timed out
-        case Event::Timedout:
-            if (m_State == StateSeekComputer) {
-                m_State = StateFailure;
-                emit q->failed(QObject::tr("Failed to connect to %1").arg(m_ComputerName));
-            }
-            if (m_State == StateSeekApp) {
-                m_State = StateFailure;
-                emit q->failed(QObject::tr("Failed to find application %1").arg(m_AppName));
-            }
-            break;
-        }
-    }
-
-    int getAppIndex() const
-    {
-        for (int i = 0; i < m_Computer->appList.length(); i++) {
-            if (m_Computer->appList[i].name.toLower() == m_AppName.toLower()) {
-                return i;
-            }
-        }
-        return -1;
-    }
-
-    bool isNotStreaming() const
-    {
-        return m_Computer->currentGameId == 0;
-    }
-
-    bool isStreamingApp(NvApp app) const
-    {
-        return m_Computer->currentGameId == app.id;
-    }
-
-    QString getCurrentAppName() const
-    {
-        for (const NvApp& app : std::as_const(m_Computer->appList)) {
-            if (m_Computer->currentGameId == app.id) {
-                return app.name;
-            }
-        }
-        return "<UNKNOWN>";
-    }
-
-    Launcher *q_ptr;
-    QString m_ComputerName;
-    QString m_AppName;
-    StreamingPreferences *m_Preferences;
-    ComputerManager *m_ComputerManager;
-    ComputerSeeker *m_ComputerSeeker;
-    NvComputer *m_Computer;
-    State m_State;
-    QTimer *m_TimeoutTimer;
-};
-
-Launcher::Launcher(QString computer, QString app,
-                   StreamingPreferences* preferences, QObject *parent)
-    : QObject(parent),
-      m_DPtr(new LauncherPrivate(this))
-{
-    Q_D(Launcher);
-    d->m_ComputerName = computer;
-    d->m_AppName = app;
-    d->m_Preferences = preferences;
-    d->m_State = StateInit;
-    d->m_TimeoutTimer = new QTimer(this);
-    d->m_TimeoutTimer->setSingleShot(true);
-    connect(d->m_TimeoutTimer, &QTimer::timeout,
-            this, &Launcher::onTimeout);
-}
-
-Launcher::~Launcher()
-{
-}
-
-void Launcher::execute(ComputerManager *manager)
-{
-    Q_D(Launcher);
-    Event event(Event::Executed);
-    event.computerManager = manager;
-    d->handleEvent(event);
-}
-
-void Launcher::quitRunningApp()
-{
-    Q_D(Launcher);
-    Event event(Event::AppQuitRequested);
-    d->handleEvent(event);
-}
-
-bool Launcher::isExecuted() const
-{
-    Q_D(const Launcher);
-    return d->m_State != StateInit;
-}
-
-void Launcher::onComputerFound(NvComputer *computer)
-{
-    Q_D(Launcher);
-    Event event(Event::ComputerFound);
-    event.computer = computer;
-    d->handleEvent(event);
-}
-
-void Launcher::onComputerUpdated(NvComputer *computer)
-{
-    Q_D(Launcher);
-    Event event(Event::ComputerUpdated);
-    event.computer = computer;
-    d->handleEvent(event);
-}
-
-void Launcher::onTimeout()
-{
-    Q_D(Launcher);
-    Event event(Event::Timedout);
-    d->handleEvent(event);
-}
-
-void Launcher::onQuitAppCompleted(QVariant error)
-{
-    Q_D(Launcher);
-    Event event(Event::AppQuitCompleted);
-    event.errorMessage = error.toString();
-    d->handleEvent(event);
-}
-
-}
@@ -1,48 +0,0 @@
-#pragma once
-
-#include <QObject>
-#include <QVariant>
-
-class ComputerManager;
-class NvComputer;
-class Session;
-class StreamingPreferences;
-
-namespace CliStartStream
-{
-
-class Event;
-class LauncherPrivate;
-
-class Launcher : public QObject
-{
-    Q_OBJECT
-    Q_DECLARE_PRIVATE_D(m_DPtr, Launcher)
-
-public:
-    explicit Launcher(QString computer, QString app,
-                      StreamingPreferences* preferences,
-                      QObject *parent = nullptr);
-    ~Launcher();
-    Q_INVOKABLE void execute(ComputerManager *manager);
-    Q_INVOKABLE void quitRunningApp();
-    Q_INVOKABLE bool isExecuted() const;
-
-signals:
-    void searchingComputer();
-    void searchingApp();
-    void sessionCreated(QString appName, Session *session);
-    void failed(QString text);
-    void appQuitRequired(QString appName);
-
-private slots:
-    void onComputerFound(NvComputer *computer);
-    void onComputerUpdated(NvComputer *computer);
-    void onTimeout();
-    void onQuitAppCompleted(QVariant error);
-
-private:
-    QScopedPointer<LauncherPrivate> m_DPtr;
-};
-
-}
@@ -1,13 +0,0 @@
-diff --git a/src/vulkan/context.c b/src/vulkan/context.c
-index bc9084ad..52290154 100644
--- a/src/vulkan/context.c
-+++ b/src/vulkan/context.c
-@@ -265,7 +265,7 @@ static_assert(PL_ARRAY_SIZE(pl_vulkan_recommended_extensions) + 1 ==
- #ifdef VK_KHR_internally_synchronized_queues
- static const VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR synchronized_queues = {
-     .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INTERNALLY_SYNCHRONIZED_QUEUES_FEATURES_KHR,
-    .internallySynchronizedQueues = true,
-+    .internallySynchronizedQueues = false,
- };
- #endif
- 
@@ -1,898 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<component type="desktop-application">
-	<id>com.moonlight_stream.Moonlight</id>
-	<metadata_license>CC0-1.0</metadata_license>
-	<project_license>GPL-3.0+</project_license>
-	<name>Moonlight</name>
-	<summary>Stream games and other applications from another PC running Sunshine or GeForce Experience</summary>
-
-	<description>
-		<p>Moonlight can stream games and other applications from another PC with Sunshine or GeForce Experience software installed.</p>
-		<p>Features include:</p>
-		<ul>
-			<li>Hardware accelerated video decoding with VAAPI, VDPAU, and Vulkan Video support</li>
-			<li>H.264, HEVC, and AV1 codec support</li>
-			<li>7.1 surround sound audio support</li>
-			<li>10-point multitouch support</li>
-			<li>Gamepad support with force feedback for up to 16 players</li>
-			<li>Support for both pointer capture (for games) and direct mouse control (for remote desktop)</li>
-			<li>Support for passing system-wide keyboard shortcuts like Alt+Tab to the host</li>
-		</ul>
-	</description>
-
-	<url type="homepage">https://moonlight-stream.org</url>
-	<url type="bugtracker">https://github.com/moonlight-stream/moonlight-qt/issues</url>
-	<url type="help">https://github.com/moonlight-stream/moonlight-docs/wiki/Setup-Guide</url>
-	<url type="vcs-browser">https://github.com/moonlight-stream/moonlight-qt</url>
-	<developer id="org.moonlight-stream">
-		<name>Moonlight Game Streaming Team</name>
-	</developer>
-	<update_contact>cameron@moonlight-stream.org</update_contact>
-	<launchable type="desktop-id">com.moonlight_stream.Moonlight.desktop</launchable>
-	<provides>
-		<binary>moonlight</binary>
-	</provides>
-	<content_rating type="oars-1.1" />	
-
-	<branding>
-		<color type="primary" scheme_preference="light">#710085</color>
-		<color type="primary" scheme_preference="dark">#55285d</color>
-	</branding>
-
-	<screenshots>
-		<screenshot type="default">
-			<image>https://moonlight-stream.org/appstream_resources/moonlight_screenshot_1.png</image>
-			<caption>Host selection page showing local PCs</caption>
-		</screenshot>
-		<screenshot>
-			<image>https://moonlight-stream.org/appstream_resources/moonlight_screenshot_2.png</image>
-			<caption>Settings page displaying streaming options</caption>
-		</screenshot>
-	</screenshots>
-
-	<releases>
-		<release version="6.2.0" date="2026-10-03">
-			<description>
-				<p>New features:</p>
-				<ul>
-					<li>Ctrl+Alt+Shift+K has been added to toggle system keyboard grab</li>
-					<li>Added support for DualSense adaptive triggers (requires a compatible host)</li>
-					<li>Gamepads with a second trackpad can now be passed to the host (requires host support)</li>
-					<li>Client identifiers are now provided to the host to allow client-specific session management</li>
-					<li>Added an option to disable pre-launch warnings</li>
-				</ul>
-				<p>Behavior Changes:</p>
-				<ul>
-					<li>Most video renderers now use full range color instead of limited range</li>
-					<li>The cursor is now also locked to the video area in single display borderless windowed scenarios. This was previously only done in true full-screen mode.</li>
-					<li>The cursor is no longer captured by default in windowed mode. Clicking on the streaming window or pressing Ctrl+Alt+Shift+Z will capture the cursor.</li>
-					<li>GPUs on non-x86 Linux platforms are now assumed to be slow by default, which enables a number of optimizations for improved performance. GL_IS_SLOW=0/VULKAN_IS_SLOW=0 can be set at runtime to override this.</li>
-					<li>The default streaming resolution for new installs is now 1080p instead of 720p.</li>
-					<li>Video bitrate no longer resets when adjusting resolution or frame rate if it's already been manually adjusted</li>
-				</ul>
-				<p>Security:</p>
-				<ul>
-					<li>CVE-2026-33546, CVE-2026-33547, and CVE-2026-41210 have been fixed</li>
-					<li>These vulnerabilities could allow a malicious host to crash Moonlight when connecting</li>
-				</ul>
-				<p>Bugfixes:</p>
-				<ul>
-					<li>Reduced background CPU usage</li>
-					<li>Improved startup, settings page, and stream load times</li>
-					<li>Optimized the EGL/GLES renderer to improve performance on low end GPUs and embedded devices</li>
-					<li>Fixed EGL/GLES renderer failures under X11 when GLX was used for the UI</li>
-					<li>Improved readability of the statistics overlay by adding an outline</li>
-					<li>Improved timing accuracy in the statistics overlay</li>
-					<li>Improved performance when multiple gamepads are sending input simultaneously</li>
-					<li>Improved performance when recovering from dropped network packets</li>
-					<li>Fixed black or green padding being rendered on the bottom or right side of the video stream when streaming from certain hosts</li>
-					<li>Fixed horizontal scroll direction not being correctly inverted when requested</li>
-					<li>Fixed Moonlight not exiting after an abnormal stream termination when launched via the CLI</li>
-					<li>Fixed failure to start on Linux systems where desktop OpenGL is not available</li>
-					<li>Fixed broken overlay rendering on PowerVR systems using the proprietary driver</li>
-					<li>Fixed automatic selection of AV1 on systems where HEVC is not available</li>
-					<li>Fixed instability when using VAAPI decoding under X11</li>
-					<li>Fixed small deviations in chroma co-siting and color conversion</li>
-					<li>Fixed suboptimal format selection on some V4L2 decoders</li>
-					<li>Fixed handling of some non-US keyboard layouts</li>
-					<li>Fixed stale app list being displayed when using CLI commands</li>
-					<li>Fixed handling of IPv6 literals that are not URL-escaped</li>
-					<li>Fixed AV1 Vulkan Video decoding on newer versions of FFmpeg</li>
-					<li>Fixed Ctrl+C/SIGTERM when running from the console</li>
-					<li>Fixed several GUI interoperability issues with Qt 6.9 and later</li>
-					<li>Fixed the IME or software keyboard being unexpectedly displayed in various situations</li>
-					<li>Fixed launching in a new VT while a Wayland compositor is running</li>
-					<li>Fixed moving focus from the app grid into the toolbar via the gamepad or keyboard</li>
-					<li>Fixed a possible crash in the Vulkan renderer when disabling an overlay</li>
-					<li>Fixed keyboard grab not working under sdl2-compat on Wayland compositors that lack support for keyboard-shortcuts-inhibit-unstable-v1</li>
-					<li>Fixed CLI stream launch causing the saved manual address to be overwritten</li>
-					<li>Fixed distinguishing between Enter and Numpad Enter keys (requires updated host software)</li>
-					<li>Fixed mDNS discovering unexpected devices after running for a period of time</li>
-					<li>Fixed libdecor-gtk window decorations not being displayed on the streaming window</li>
-					<li>Updated community-contributed translations from Weblate</li>
-				</ul>
-			</description>
-		</release>
-		<release version="6.1.0" date="2024-09-16">
-			<description>
-				<p>New features:</p>
-				<ul>
-					<li>Experimental YUV 4:4:4 support for improved text clarity during remote desktop usage</li>
-					<li>HDR is now supported with software decoding (requires GPU with Vulkan support)</li>
-					<li>Bitrate limit can now be increased to 500 Mbps</li>
-					<li>Audio decoding now uses 32-bit floating point format</li>
-				</ul>
-				<p>Bugfixes:</p>
-				<ul>
-					<li>Fixed incorrect color range when streaming with AV1 from a host with an AMD GPU</li>
-					<li>Updated community-contributed translations from Weblate</li>
-				</ul>
-			</description>
-		</release>
-		<release version="6.0.1" date="2024-06-30">
-			<description>
-				<p>New features:</p>
-				<ul>
-					<li>HDR to SDR tonemapping is now supported by the Vulkan renderer on Linux</li>
-				</ul>
-				<p>Behavior Changes:</p>
-				<ul>
-					<li>More time is now provided for PCs to wake up before displaying an error when starting a stream from the CLI</li>
-					<li>Moonlight will no longer try to guess VA driver names when running libva 2.20 or later</li>
-				</ul>
-				<p>Bugfixes:</p>
-				<ul>
-					<li>Fixed crash when the Vulkan renderer executed on a system with no Vulkan devices</li>
-					<li>Updated community-contributed translations from Weblate</li>
-				</ul>
-			</description>
-		</release>
-		<release version="6.0.0" date="2024-06-06">
-			<description>
-				<p>New features:</p>
-				<ul>
-					<li>HDR is now supported on Steam Deck and other HDR-capable Linux systems using a new Vulkan-based renderer</li>
-					<li>Vulkan Video decoding of H.264, HEVC, and AV1 is now supported using the new Vulkan renderer</li>
-					<li>Full E2E stream encryption is now supported when streaming from Sunshine v0.22 or later</li>
-					<li>Initiating a stream via the command-line will now automatically wake the target machine if it is sleeping</li>
-					<li>Error codes are now displayed in the connection termination dialog</li>
-					<li>Detailed PC state information is now available via the new "View Details" context menu option (similar to the Android client)</li>
-					<li>The performance overlay can now be configured to be shown by default when starting a stream</li>
-				</ul>
-				<p>Behavior Changes:</p>
-				<ul>
-					<li>The selected bitrate is no longer silently adjusted by Moonlight based upon the video codec or HDR mode</li>
-					<li>The selected mouse mode when starting a stream no longer influences the acceleration curve when the mouse mode is toggled using the Ctrl+Alt+Shift+M key combo while streaming</li>
-					<li>Hardcoded fallback paths for VAAPI and VDPAU drivers are no longer used</li>
-					<li>Per-session keys (rikey and rikeyid values) are now automatically stripped from logs</li>
-					<li>Log messages will now be logged to stderr rather than stdout</li>
-					<li>EGL is now always used instead of GLX for loading OpenGL in X11 environments on non-x86 platforms</li>
-				</ul>
-				<p>Bugfixes:</p>
-				<ul>
-					<li>Improved reliability of streaming during momentary drops of WiFi connections</li>
-					<li>Improved performance with high polling rate mice</li>
-					<li>Improved input latency when a gamepad is connected</li>
-					<li>Added missing command-line options to control HDR and AV1 codec usage</li>
-					<li>Fixed instant connection termination error when streaming over the Internet behind certain Carrier-Grade NAT devices</li>
-					<li>Fixed incorrect MTU detection when streaming over the Internet without a VPN</li>
-					<li>Fixed recovery of audio when no audio output device is present when the stream starts</li>
-					<li>Fixed merging of gamepad state when multi-controller mode is disabled</li>
-					<li>Fixed indefinitely resending mDNS queries when a host could not be resolved</li>
-					<li>Fixed inability to pair when the host is not using a RSA-2048 key</li>
-					<li>Updated included gamepad mappings</li>
-					<li>Updated community-contributed translations from Weblate</li>
-				</ul>
-			</description>
-		</release>
-		<release version="5.0.1" date="2023-11-02">
-			<description>
-				<p>Bugfixes:</p>
-				<ul>
-					<li>Fixed connection issue streaming from some hosts running GeForce Experience or Sunshine v0.20 and earlier</li>
-					<li>Updated community-contributed translations from Weblate</li>
-				</ul>
-			</description>
-		</release>
-		<release version="5.0.0" date="2023-10-18">
-			<description>
-				<p>New features:</p>
-				<ul>
-					<li>Custom FPS values</li>
-					<li>Streaming using the AV1 codec from Sunshine hosts</li>
-					<li>Horizontal scrolling with Sunshine hosts</li>
-					<li>Native multi-touch input with Sunshine hosts</li>
-					<li>Controller type information is passed to Sunshine for controller type autoselection</li>
-					<li>Extended features of PS4/PS5 controllers (touchpad, battery state, gyro/accelerometer motion, and RGB LED) are natively passed to Sunshine hosts</li>
-					<li>Support for up to 16 gamepads with Sunshine hosts</li>
-					<li>Frame pacing support on Wayland</li>
-					<li>Host-side processing latency is now displayed in the performance overlay with Sunshine hosts</li>
-					<li>Window title now includes the PC name when streaming</li>
-					<li>Alphabetical sorting of the PC list</li>
-					<li>Updated Play and Stop button design to improve contrast with app box art</li>
-					<li>The settings page automatically scrolls to the selected element when using keyboard or gamepad navigation</li>
-					<li>Pressing Share+PS buttons on PS4/PS5 controllers can be used to emulate a clickpad press</li>
-					<li>Improved audio quality when streaming with a high bitrate from remote hosts</li>
-					<li>Increased mouse polling rate</li>
-				</ul>
-				<p>Behavior Changes:</p>
-				<ul>
-					<li>IPv6 addresses must be provided in URL-escaped form. Example: [2001:db8::1234:5678] or [2001:db8::1234:5678]:47989</li>
-					<li>Default bitrate logic has been adjusted to behave better with custom resolutions and frame rates</li>
-				</ul>
-				<p>Bugfixes:</p>
-				<ul>
-					<li>Reduced the frequency of audio underruns (clicks and pops) by increasing audio buffer size</li>
-					<li>Fixed "Quitting App" message never dismissing in some cases</li>
-					<li>Fixed parsing IPv6 literals with port numbers</li>
-					<li>Fixed unnecessary WiFi activity causing stream disruptions</li>
-					<li>Fixed paired hosts being forgotten if Moonlight terminates while writing hosts to disk</li>
-					<li>Fixed freeze when closing the stream on Windows with some software that uses DX11 hooks</li>
-					<li>Fixed delayed PC wake when activating Wake-On-LAN feature</li>
-					<li>Fixed Wake-on-LAN when Sunshine is running on alternate ports</li>
-					<li>Fixed leak of /dev/dri fds when trying to initialize VAAPI decoder</li>
-					<li>Fixed support for the Applications/Menu key</li>
-					<li>Fixed automatic language detection for Simplified Chinese and Traditional Chinese</li>
-					<li>Fixed streaming from Sunshine when the client PC has multiple network interfaces or IPv6 privacy extensions enabled</li>
-					<li>Fixed small receive buffer causing video packet loss on some systems</li>
-					<li>Fixed theme overrides causing the UI to be unusable on some systems</li>
-					<li>Fixed tearing with V-Sync enabled on macOS and Linux when using the SDL renderer (software decoding and some hardware decoders)</li>
-					<li>Fixed stateful V4L2 hardware decoding using h264_v4l2m2m and hevc_v4l2m2m decoders</li>
-					<li>Fixed CVE-2023-42801</li>
-					<li>Updated included gamepad mappings</li>
-					<li>Updated community-contributed translations from Weblate</li>
-				</ul>
-			</description>
-		</release>
-		<release version="4.3.1" date="2022-11-03">
-			<description>
-				<p>Changes:</p>
-				<ul>
-					<li>Fixed crash during specific patterns of audio packet loss</li>
-					<li>Fixed detection of local streaming when using IPv6 addresses</li>
-					<li>Windowed mode streaming now starts maximized if the GUI window was maximized</li>
-					<li>Updated community-contributed translations from Weblate</li>
-				</ul>
-			</description>
-		</release>
-		<release version="4.3.0" date="2022-10-28">
-			<description>
-				<p>New features:</p>
-				<ul>
-					<li>Improved support for GeForce Experience 3.26</li>
-					<li>Improved image quality and performance when recovering from video packet loss using HEVC</li>
-					<li>Improved error concealment after audio packet loss</li>
-					<li>Improved UI performance when paired with many hosts or hosts with large numbers of apps</li>
-					<li>Pairing with Sunshine hosts is now supported even if the host is in a streaming session</li>
-				</ul>
-				<p>Bugfixes:</p>
-				<ul>
-					<li>Fixed streaming at resolutions below 720x480 with GeForce Experience 3.26</li>
-					<li>Fixed window position and size being lost when toggling between full-screen and windowed mode</li>
-					<li>Fixed initial window size not always respecting the stream aspect ratio</li>
-					<li>Fixed unexpected error when streaming at resolutions above 4096x4096 using Sunshine</li>
-					<li>Updated included gamepad mappings</li>
-					<li>Updated community-contributed translations from Weblate</li>
-				</ul>
-			</description>
-		</release>
-		<release version="4.2.1" date="2022-09-12">
-			<description>
-				<p>Bugfixes:</p>
-				<ul>
-					<li>Fixed streaming from hosts running Sunshine</li>
-					<li>Updated community-contributed translations from Weblate</li>
-				</ul>
-			</description>
-		</release>
-		<release version="4.2.0" date="2022-09-10">
-			<description>
-				<p>New features:</p>
-				<ul>
-					<li>Added support for pairing via the terminal</li>
-					<li>Added support for listing installed apps on a host via the terminal</li>
-					<li>Improved handling of V-Sync on Wayland systems to reduce latency</li>
-					<li>Improved performance using the legacy non-EGL VAAPI rendering code</li>
-				</ul>
-				<p>Bugfixes:</p>
-				<ul>
-					<li>Fixed native resolution detection on high DPI Wayland systems</li>
-					<li>Fixed audio crackling with SDL 2.24.0 on systems using PulseAudio</li>
-					<li>Updated included gamepad mappings</li>
-					<li>Updated community-contributed translations from Weblate</li>
-				</ul>
-			</description>
-		</release>
-		<release version="4.1.0" date="2022-05-23">
-			<description>
-				<p>New features:</p>
-				<ul>
-					<li>Overlays are now supported on the non-EGL X11 VAAPI renderer (requires RGBA subpicture support in the VAAPI driver)</li>
-					<li>Cursor lock can now be disabled when in full-screen mode</li>
-				</ul>
-				<p>Behavior Changes:</p>
-				<ul>
-					<li>Moonlight can now reduce the client display resolution in full-screen mode if the current display mode doesn't have a high enough refresh rate for the selected stream frame rate</li>
-					<li>When choosing a new client display resolution in full-screen mode, Moonlight will pick a display mode with the closest aspect ratio to the selected stream resolution</li>
-					<li>Moonlight now defaults to borderless windowed mode on Wayland systems</li>
-
-				</ul>
-				<p>Bugfixes:</p>
-				<ul>
-					<li>Fixed missing toolbar buttons in certain languages</li>
-					<li>Fixed some text on the settings page not updating when the language is changed</li>
-					<li>Fixed a frame pacing bug that could cause excessive frame drops</li>
-					<li>Fixed the "keep display awake" setting not being saved when Moonlight restarts</li>
-					<li>Fixed black screen after unmaximizing the Moonlight window on some Linux systems</li>
-					<li>Updated included gamepad mappings</li>
-					<li>Updated community-contributed translations from Weblate</li>
-				</ul>
-			</description>
-		</release>
-		<release version="4.0.0" date="2022-04-02">
-			<description>
-				<p>New features:</p>
-				<ul>
-					<li>Added a new key combo for locking the mouse cursor to the window (Ctrl+Alt+Shift+L)</li>
-					<li>Added an option to avoid keeping the client display awake while streaming</li>
-				</ul>
-				<p>Behavior Changes:</p>
-				<ul>
-					<li>HDR streaming is now a separate option rather than being part of the Video Codec override dropdown</li>
-					<li>HDR streaming is no longer restricted to apps that are certified by NVIDIA as compatible with GameStream HDR. Some newer games may require an HDR display or EDID emulator dongle connected to your host PC for HDR options to be available.</li>
-				</ul>
-				<p>Bugfixes:</p>
-				<ul>
-					<li>Fixed loss of all audio if the active audio device is unplugged while streaming</li>
-					<li>Fixed the GUI being unresponsive after manually quitting when connection to the host is lost</li>
-					<li>Fixed a rare crash if a controller disconnects right as rumble is starting</li>
-					<li>Fixed text rendering on the overlay UI when using SDL_ttf 2.0.18 on Linux</li>
-					<li>Updated included gamepad mappings</li>
-					<li>Updated community-contributed translations from Weblate</li>
-				</ul>
-			</description>
-		</release>
-		<release version="3.2.0" date="2022-01-18">
-			<description>
-				<p>New features:</p>
-				<ul>
-					<li>Reduced CPU usage while streaming</li>
-					<li>Non-ASCII characters are now supported when pasting clipboard data to the host</li>
-					<li>Added support for zero-copy NVDEC rendering for Nvidia Wayland systems</li>
-					<li>Significantly improved performance with asynchronous decoders like V4L2M2M on Linux</li>
-					<li>Added support for color compression planes on newer Intel systems when using VAAPI decoding</li>
-					<li>Added support for copy-back rendering in non-default pixel formats (like the Raspberry Pi SAND format)</li>
-				</ul>
-				<p>Bugfixes:</p>
-				<ul>
-					<li>Fixed unexpected GUI input after using the gamepad quit combo</li>
-					<li>Updated included gamepad mappings</li>
-					<li>Updated community-contributed translations from Weblate</li>
-				</ul>
-			</description>
-		</release>
-		<release version="3.1.4" date="2021-06-25">
-			<description>
-				<p>Changes:</p>
-				<ul>
-					<li>Added network latency statistics to the performance overlay</li>
-					<li>Improved audio quality on unreliable connections (requires GeForce Experience 3.19 or later)</li>
-					<li>Reduced video frame drops on unreliable connections (requires GeForce Experience 3.22 or later)</li>
-					<li>Updated community-contributed translations from Weblate</li>
-				</ul>
-			</description>
-		</release>
-		<release version="3.1.3" date="2021-05-07">
-			<description>
-				<p>Changes:</p>
-				<ul>
-					<li>Fixed an issue that could cause excessive audio latency on some connections</li>
-					<li>Updated community-contributed translations from Weblate</li>
-				</ul>
-			</description>
-		</release>
-		<release version="3.1.2" date="2021-05-03">
-			<description>
-				<p>Changes:</p>
-				<ul>
-					<li>Improved connection reliability and performance with GeForce Experience 3.22</li>
-					<li>Added support for audio encryption with GeForce Experience 3.22</li>
-					<li>Added compatibility update checks for future versions of GeForce Experience</li>
-					<li>Fixed keyboard capture on X11</li>
-					<li>Updated community-contributed translations from Weblate</li>
-				</ul>
-			</description>
-		</release>
-		<release version="3.1.1" date="2021-04-09">
-			<description>
-				<p>Changes:</p>
-				<ul>
-					<li>Added support for streaming from GeForce Experience 3.22</li>
-					<li>Added support for AMF-encoded HEVC streams from servers like Sunshine and OpenStream</li>
-					<li>Added new community-contributed translations from Weblate</li>
-					<li>Fixed KMSDRM rendering with buffer modifiers on embedded devices</li>
-				</ul>
-			</description>
-		</release>
-		<release version="3.1.0" date="2021-03-14">
-			<description>
-				<p>New features:</p>
-				<ul>
-					<li>System keyboard shortcuts (Alt+Tab, Super key, Ctrl+Shift+Esc, etc.) can now be (optionally) captured in windowed mode</li>
-					<li>System keyboard shortcuts can now be captured under Wayland</li>
-					<li>Added support for typing the client's clipboard text on the host by pressing Ctrl+Alt+Shift+V</li>
-					<li>Added Ctrl+Alt+Shift+D key combo to minimize the streaming window</li>
-					<li>Added Ctrl+Alt+Shift+C key combo to show the local cursor while streaming in remote desktop mouse mode</li>
-					<li>Added Select+L1+R1+X gamepad button combo to toggle performance overlay</li>
-					<li>Added translations for Simplified Chinese and German</li>
-					<li>Added a language selector on the settings page</li>
-				</ul>
-				<p>Bugfixes:</p>
-				<ul>
-					<li>Improved performance of loading the app grid</li>
-					<li>Fixed video scaling in High DPI mode on Wayland</li>
-					<li>Fixed window icons on Wayland</li>
-					<li>Fixed number pad enter key functionality in the UI</li>
-				</ul>
-			</description>
-		</release>
-		<release version="3.0.0" date="2021-01-17">
-			<description>
-				<p>New features:</p>
-				<ul>
-					<li>Added the ability to define a custom streaming resolution using the UI</li>
-					<li>Added the option to capture system key combinations (Alt+Tab, Ctrl+Shift+Esc, Win+Tab, etc) in fullscreen mode</li>
-					<li>Updated gamepad mappings are automatically downloaded each time Moonlight launches</li>
-					<li>The performance overlay is now supported for Linux clients using VAAPI and VDPAU hardware acceleration</li>
-					<li>Added the option to enable "Direct Launch" which immediately launches the specified game when clicking on a PC</li>
-					<li>Added the option to mute audio when the Moonlight window loses input focus</li>
-					<li>Added the option to toggle background gamepad input</li>
-					<li>Added the option to invert scroll direction</li>
-					<li>Added the option to swap gamepad button layout to Nintendo-style</li>
-					<li>Added the option to start the Moonlight UI in fullscreen mode</li>
-					<li>The failing TCP or UDP ports are now displayed when the connection fails</li>
-				</ul>
-				<p>Bugfixes:</p>
-				<ul>
-					<li>Fixed PS4 controllers not reading inputs during haptics in some games</li>
-					<li>Fixed some slow decoders causing the receive time value to increase rather than the decode time</li>
-					<li>Native resolution options now refresh each time the settings page is opened, rather than once per launch of Moonlight</li>
-					<li>Fixed no video or audio while streaming over Internet connections that drop packets with QoS tagging enabled</li>
-					<li>Improved connection testing accuracy for connections with low MTUs</li>
-					<li>Fixed inability to open an app's context menu with a gamepad</li>
-				</ul>
-			</description>
-		</release>
-		<release version="2.2.0" date="2020-09-10">
-			<description>
-				<p>New features:</p>
-				<ul>
-					<li>Added the ability to hide unwanted apps and games</li>
-					<li>Added a network test to determine if your Internet connection is blocking Moonlight</li>
-					<li>Added the option to swap mouse buttons</li>
-					<li>Added codec and resolution to the on-screen performance stats</li>
-					<li>Added a warning if the connection is too unstable to receive any complete video frames</li>
-					<li>Added a Discord link to the toolbar in settings</li>
-					<li>Enabled the new EGL renderer by default on Linux</li>
-				</ul>
-				<p>Bugfixes:</p>
-				<ul>
-					<li>Fixed streaming over networks that block QoS-tagged packets</li>
-					<li>Selecting a frame rate higher than 60 FPS no longer sets the host desktop to 720p</li>
-					<li>Right-side modifier keys no longer press the corresponding left-side keys too</li>
-					<li>Fixed mouse position never reaching the edge of the screen with certain desktop resolutions</li>
-					<li>Improved synchronization between host and client mouse cursor in remote desktop mouse mode</li>
-					<li>Cached box art is now deleted when the PC is removed from Moonlight</li>
-					<li>Fixed several CLI options not properly overriding GUI options</li>
-					<li>Updated included gamepad mappings</li>
-					<li>Updated to Qt 5.15.1</li>
-				</ul>
-			</description>
-		</release>
-		<release version="2.1.0" date="2020-05-17">
-			<description>
-				<p>New features:</p>
-				<ul>
-					<li>Remote desktop mode now allows interaction with the host without having to click to focus the Moonlight window first</li>
-					<li>Added a new EGL renderer for improved performance on Wayland and XWayland</li>
-					<li>Added the option to toggle between direct touchscreen mode and the old trackpad mode</li>
-					<li>Added the option to rename host PCs</li>
-					<li>Added the ability to scroll the settings page with the right analog stick</li>
-					<li>Various UI improvements</li>
-				</ul>
-				<p>Bugfixes:</p>
-				<ul>
-					<li>Fixed unreliable mouse capture when the stream begins</li>
-					<li>Fixed cursor being trapped in full-screen mode even when the mouse wasn't captured</li>
-					<li>Fixed key presses not being sent to the host if the Super/Meta/Windows key is pressed</li>
-					<li>Updated included gamepad mappings</li>
-				</ul>
-			</description>
-		</release>
-		<release version="2.0.0" date="2020-04-28">
-			<description>
-				<p>New features:</p>
-				<ul>
-					<li>Remote desktop-optimized mouse mode which doesn't require capturing the mouse cursor</li>
-					<li>Touchscreen input now directly controls the mouse cursor</li>
-					<li>7.1 surround sound support</li>
-				</ul>
-				<p>Bugfixes:</p>
-				<ul>
-					<li>Improved performance on some lossy networks</li>
-					<li>Fixed disconnect delay when streaming from GeForce Experience 3.20.3.63</li>
-					<li>Fixed frame rate not exceeding 60 when streaming from GeForce Experience 3.20.3.63</li>
-					<li>Fixed parsing of command-line options when passing flags prior to the action</li>
-					<li>Fixed an issue that may cause excessive mDNS network traffic while Moonlight is running</li>
-					<li>Fixed hardware decoding on Intel GPUs running Mesa 20.0 and/or the Iris driver</li>
-					<li>Fixed hardware decoding on Comet Lake and later Intel GPUs using the iHD VA-API driver</li>
-					<li>Fixed hardware decoding on AMD Radeon GPUs with XWayland</li>
-					<li>Fixed a crash when using the iHD VA-API driver on Wayland</li>
-					<li>Fixed delay after exiting the stream on Wayland</li>
-					<li>Updated included gamepad mappings</li>
-				</ul>
-			</description>
-		</release>
-		<release version="1.2.0" date="2019-12-17">
-			<description>
-				<p>Bugfixes:</p>
-				<ul>
-					<li>Improved video encoding efficiency</li>
-					<li>Improved performance when streaming over a VPN</li>
-					<li>Fixed RTSP handshake error on certain networks</li>
-					<li>Fixed rumble not working on certain gamepads</li>
-					<li>Fixed pairing error when double-clicking on an unpaired PC</li>
-					<li>Updated included SDL gamepad mappings</li>
-				</ul>
-			</description>
-		</release>
-		<release version="1.1.1" date="2019-09-29">
-			<description>
-				<p>Bugfixes:</p>
-				<ul>
-					<li>Improved reliability of public IP address detection</li>
-					<li>Fixed connecting to a host PC with multiple network connections</li>
-					<li>Fixed a hang after exiting a full-screen stream with GNOME on Wayland</li>
-					<li>Fixed gamepad hotplugging</li>
-					<li>Updated to SDL 2.0.10</li>
-					<li>Updated to Qt 5.13.1</li>
-				</ul>
-			</description>
-		</release>
-		<release version="1.1.0" date="2019-08-05">
-			<description>
-				<p>New features:</p>
-				<ul>
-					<li>Added support for NVDEC for NVIDIA GPUs on Wayland</li>
-					<li>Added an option to disable gamepad mouse mode for games that require holding the Start button</li>
-					<li>Added automatic detection of IPv6 addresses for Internet streaming over IPv6 networks</li>
-				</ul>
-				<p>Bugfixes:</p>
-				<ul>
-					<li>Improved speed and reliability of automatic PC detection on the local network</li>
-					<li>Fixed audio latency increasing under certain network conditions</li>
-					<li>Fixed 5.1 surround sound sometimes causing no audio to play when streaming over the Internet</li>
-					<li>Fixed graceful termination of games not being detected properly on GFE 3.19</li>
-					<li>Fixed several audio issues on Linux by switching back to SDL for audio</li>
-					<li>Changed client certificate signature algorithm from SHA-1 to SHA-256 for Debian Buster compatibility</li>
-					<li>Updated included gamepad mappings</li>
-				</ul>
-			</description>
-		</release>
-		<release version="1.0.1" date="2019-05-27">
-			<description>
-				<p>Bugfixes:</p>
-				<ul>
-					<li>Fixed broken video on GeForce Experience 3.19</li>
-				</ul>
-			</description>
-		</release>
-		<release version="1.0.0" date="2019-05-21">
-			<description>
-				<p>New features:</p>
-				<ul>
-					<li>Mouse mode for gamepads (Press and hold Start to toggle)</li>
-					<li>Improved gamepad UI navigation</li>
-				</ul>
-				<p>Bugfixes:</p>
-				<ul>
-					<li>Fixed duplicate non-working gamepads appearing on the host</li>
-					<li>Fixed excessive frame queue delay on macOS</li>
-					<li>Fixed excessive audio latency on Steam Link</li>
-					<li>Fixed hiding mouse cursor after streaming on Steam Link</li>
-					<li>Fixed incorrect receive time stats on 32-bit platforms</li>
-					<li>Added UDP ports 48002 and 48010 for Wake-on-LAN</li>
-					<li>Updated included gamepad mappings</li>
-				</ul>
-			</description>
-		</release>
-		<release version="0.10.1" date="2019-04-28">
-			<description>
-				<p>New features:</p>
-				<ul>
-					<li>Video performance optimizations</li>
-					<li>VAAPI support on Wayland</li>
-				</ul>
-				<p>Bugfixes:</p>
-				<ul>
-					<li>Fixed a crash when attempting to dismiss the connection terminated dialog</li>
-					<li>Fixed a crash when using the overlay on the software decoder</li>
-					<li>Fixed software decoder not displaying output in some cases</li>
-					<li>Fixed some minor UI issues on the PC grid</li>
-					<li>Improved visibility of toolbar highlights</li>
-				</ul>
-			</description>
-		</release>
-		<release version="0.10.0" date="2019-04-07">
-			<description>
-				<p>New features:</p>
-				<ul>
-					<li>Redesigned App Grid with larger game artwork and less blank space</li>
-					<li>Redesigned UI dialogs using Material Design</li>
-					<li>Added a connection warning overlay (which can be disabled in settings)</li>
-					<li>Streaming window no longer minimizes when it loses focus in full-screen mode</li>
-					<li>The Steam Link device is now a supported platform</li>
-				</ul>
-				<p>Bugfixes:</p>
-				<ul>
-					<li>Fixed several bugs that could cause UI hangs or lag</li>
-					<li>Fixed rumble support on gamepads with limited rumble motor control</li>
-					<li>Fixed increased memory usage if the software renderer gets delayed</li>
-					<li>Fixed crashes on certain desktop configurations when loading the UI</li>
-					<li>Fixed handling of pairing certificates with a bogus date</li>
-				</ul>
-			</description>
-		</release>
-		<release version="0.9.1" date="2019-02-17">
-			<description>
-				<p>New features:</p>
-				<ul>
-					<li>Added gamepad rumble support</li>
-					<li>Added a dedicated quit button to the running app tile</li>
-					<li>Reduced video latency on Windows and Linux</li>
-					<li>Added a performance overlay for software decoding</li>
-				</ul>
-				<p>Bugfixes:</p>
-				<ul>
-					<li>Fixed delayed first video frame with GFE 3.17</li>
-					<li>Fixed erroneously setting host resolution to 720p in certain configurations</li>
-					<li>The connection termination dialog is no longer displayed for intentional termination</li>
-					<li>Fixed some gamepads only functioning for UI navigation and not in game</li>
-					<li>Fixed audio latency increasing when switching audio devices</li>
-					<li>Fixed VDPAU scaling behavior on AMD cards</li>
-					<li>Fixed several bugs in gamepad navigation behavior</li>
-					<li>Work around a bug in QGnomePlatform that breaks dialog rendering on Linux</li>
-					<li>Updated included SDL gamepad mappings</li>
-					<li>Fixed hotkey behavior on non-latin keyboards</li>
-					<li>Fixed incorrect frame drop percentages in debug stats</li>
-				</ul>
-			</description>
-		</release>
-		<release version="0.8.1" date="2019-01-08">
-			<description>
-				<p>New features:</p>
-				<ul>
-					<li>Stricter adherence to the specified bitrate when streaming over the Internet</li>
-				</ul>
-				<p>Bugfixes:</p>
-				<ul>
-					<li>Fixed audio crackling that impacted certain systems</li>
-					<li>Fixed Wake-on-LAN packets failing to send on some systems</li>
-					<li>Reduced audio latency when resuming a session where audio is already playing</li>
-					<li>Added option to enable the old SDL audio renderer by setting ML_AUDIO=SDL</li>
-					<li>Updated to use the new Qt 5.12 Flatpak runtime</li>
-					<li>Updated to FFmpeg 4.1</li>
-					<li>Minor UI tweaks</li>
-				</ul>
-			</description>
-		</release>
-		<release version="0.8.0" date="2018-12-25">
-			<description>
-				<p>New features:</p>
-				<ul>
-					<li>Improved security of pairing - After this update, you must re-pair with your PC!</li>
-					<li>Enabled quitting games started by other Moonlight clients also running this update</li>
-				</ul>
-				<p>Bugfixes:</p>
-				<ul>
-					<li>Fixed the video bitrate slider not working above certain values on GFE 3.16</li>
-					<li>Fixed broken Bluetooth audio with PulseAudio</li>
-					<li>Reduced audio latency</li>
-					<li>Fixed some non-gamepad devices triggering the unmapped gamepad dialog box</li>
-					<li>Minor UI tweaks</li>
-				</ul>
-			</description>
-		</release>
-		<release version="0.7.0" date="2018-12-05">
-			<description>
-				<p>New features:</p>
-				<ul>
-					<li>Added option to quit the app after stopping the stream</li>
-					<li>Added CLI option to quit the running app</li>
-				</ul>
-				<p>Bugfixes:</p>
-				<ul>
-					<li>Switched to libsoundio backend to address audio glitches and reduce latency</li>
-					<li>Fixed CLI version output</li>
-					<li>Fixed streaming error messages not showing up when launching from CLI</li>
-					<li>Updated included SDL gamepad mappings</li>
-					<li>Various minor UI tweaks</li>
-				</ul>
-			</description>
-		</release>
-		<release version="0.6.4" date="2018-11-20">
-			<description>
-				<p>New features:</p>
-				<ul>
-					<li>Added an option to match client display refresh rate when FPS is unlocked</li>
-				</ul>
-				<p>Bugfixes:</p>
-				<ul>
-					<li>Fixed multiple gamepads not being detected on the host in some scenarios</li>
-					<li>Fixed an incorrect warning when trying to stream at 4K</li>
-				</ul>
-			</description>
-		</release>
-		<release version="0.6.3" date="2018-11-16">
-			<description>
-				<p>New features:</p>
-				<ul>
-					<li>Added support for GeForce Experience 3.16</li>
-					<li>Added an option to force Moonlight to start in windowed mode</li>
-				</ul>
-				<p>Bugfixes:</p>
-				<ul>
-					<li>Fixed scrolling not working on the settings page</li>
-					<li>Skipped using proxy servers when attempting to stream</li>
-					<li>Fixed a couple possible crashes</li>
-					<li>Renamed the mouse acceleration option to be more clear</li>
-				</ul>
-			</description>
-		</release>
-		<release version="0.6.2" date="2018-10-28">
-			<description>
-				<p>New features:</p>
-				<ul>
-					<li>Added automatic IP address detection for Internet streaming</li>
-					<li>Added a quit shortcut tip for gamepad users</li>
-				</ul>
-				<p>Bugfixes:</p>
-				<ul>
-					<li>Fixed server state polling not being stopped while streaming</li>
-				</ul>
-			</description>
-		</release>
-		<release version="0.6.1" date="2018-10-14">
-			<description>
-				<p>New features:</p>
-				<ul>
-					<li>Added support for quitting Moonlight via gamepad</li>
-					<li>Added tooltips for games with very long names</li>
-				</ul>
-				<p>Bugfixes:</p>
-				<ul>
-					<li>Added a workaround for a memory leak in the VAAPI driver for AMD GPUs</li>
-					<li>Fixed combo boxes on the settings page being too small for certain DPI scaling</li>
-					<li>Reduced power usage when Moonlight is idling in the background for a while</li>
-				</ul>
-			</description>
-		</release>
-		<release version="0.6.0" date="2018-10-06">
-			<description>
-				<p>New features:</p>
-				<ul>
-					<li>Added keyboard and gamepad UI navigation</li>
-					<li>Added support for mouse X1 and X2 buttons (back and forward)</li>
-					<li>Added support for mouse movement with touchscreens</li>
-					<li>Improved HEVC performance at high bitrates</li>
-					<li>Added support for launching streaming sessions directly from a terminal or script</li>
-					<li>Added quit shortcut for gamepads: Select+Start+L1+R1</li>
-				</ul>
-				<p>Bugfixes:</p>
-				<ul>
-					<li>Fixed not saving deletion of PCs</li>
-					<li>Fixed keys being stuck down on the host PC after Moonlight loses focus or quits</li>
-					<li>Fixed some warning dialogs being stuck behind the UI window</li>
-					<li>Updated included gamepad mapping list</li>
-				</ul>
-			</description>
-		</release>
-		<release version="0.5.0" date="2018-09-15">
-			<description>
-				<p>New features:</p>
-				<ul>
-					<li>Added option to enable mouse acceleration for remote desktop usage</li>
-					<li>Added option to disable automatic PC discovery</li>
-					<li>Added gamepad mappings from gabomdq's SDL_GameControllerDB</li>
-					<li>Added help links to error dialogs</li>
-					<li>Added quit shortcut tip to stream loading page</li>
-					<li>Restored the autodetect audio configuration option</li>
-				</ul>
-				<p>Bugfixes:</p>
-				<ul>
-					<li>Fixed quit app dialog starting the wrong app</li>
-					<li>Fixed very high input lag on GFE 3.14.0 and earlier</li>
-					<li>Fixed sending errant mouse click when capturing the mouse</li>
-				</ul>
-			</description>
-		</release>
-		<release version="0.4.0" date="2018-09-08">
-			<description>
-				<p>New features:</p>
-				<ul>
-					<li>Added option to enable (unsupported) 90/120 FPS streaming on 60 Hz monitors</li>
-					<li>Added refresh rate matching for better frame pacing on high refresh rate monitors</li>
-					<li>The streaming window now appears on the same monitor the UI was displayed on</li>
-					<li>The streaming window is now centered on the target monitor</li>
-					<li>Display a dialog when the connection is terminated by the remote PC</li>
-					<li>Added option to select between full-screen exclusive and borderless windowed mode</li>
-				</ul>
-				<p>Bugfixes:</p>
-				<ul>
-					<li>Fixed streaming with no audio device</li>
-					<li>Fixed mouse lag with some high polling rate mice</li>
-					<li>Improved UI performance on the app grid page</li>
-					<li>1440p and 4K 120 FPS performance is improved to avoid encoder bottlenecks</li>
-					<li>Autodetect audio configuration option removed because it was broken</li>
-				</ul>
-			</description>
-		</release>
-		<release version="0.3.0" date="2018-08-21">
-			<description>
-				<p>Bugfixes:</p>
-				<ul>
-					<li>Reduced power consumption when the app is minimized</li>
-					<li>Fixed malformed asset requests being sent when the first host in the grid is offline</li>
-				</ul>
-			</description>
-		</release>
-		<release version="0.2.0" date="2018-08-12">
-			<description>
-				<p>Bugfixes:</p>
-				<ul>
-					<li>Fixed functionality of '=', 'Numpad Dot', and 'Numpad Enter' keys</li>
-					<li>Fixed uninitialized variable causing strange gamepad behavior</li>
-					<li>Added a warning for incompatible configs and decoder failures</li>
-					<li>Added a warning for Wayland performance issues</li>
-					<li>Stopped capturing the mouse by default for windowed streams</li>
-				</ul>
-			</description>
-		</release>
-		<release version="0.1.0" date="2018-08-05">
-			<description>
-				<p>New features:</p>
-				<ul>
-					<li>Allow streaming at the client's native resolution</li>
-					<li>VDPAU hardware decoding support for NVIDIA GPUs</li>
-					<li>Updated UI to replace status text with icons</li>
-					<li>Stream window is now resizable</li>
-					<li>Display warnings during game launch for configuration issues</li>
-				</ul>
-				<p>Bugfixes:</p>
-				<ul>
-					<li>Gamepad input now works even if the app doesn't have focus</li>
-					<li>Fixed streaming black screen if the host supported HEVC but the client didn't</li>
-					<li>Fixed broken video scaling causing extra stretching and off-center video</li>
-					<li>Fixed gamepad input issue causing some Y axis inputs to be reversed</li>
-				</ul>
-			</description>
-		</release>
-		<release version="0.0.5" date="2018-08-01">
-			<description>
-				<p>Changes from 0.0.4:</p>
-				<ul>
-					<li>Fixed a bug causing increased frame drops and input lag</li>
-					<li>Added support for quitting running games</li>
-					<li>Added support for waking sleeping PCs with Wake-on-LAN</li>
-					<li>Increased the FPS limit to 120 FPS</li>
-				</ul>
-			</description>
-		</release>
-		<release version="0.0.4a" date="2018-07-30">
-			<description>
-				<p>Initial pre-alpha release for Linux. Please file bugs!</p>
-			</description>
-		</release>
-	</releases>
-
-</component>
@@ -1,9 +0,0 @@
-[Desktop Entry]
-Name=Moonlight
-Comment=Stream games and other applications from another PC running Sunshine or GeForce Experience
-Exec=moonlight
-Icon=moonlight
-Terminal=false
-Type=Application
-Categories=Qt;Game;Network;RemoteAccess;
-Keywords=nvidia;gamestream;stream;sunshine;remote play;
@@ -1,36 +0,0 @@
-/*
- * libva-probe: loadability oracle for the AppImage AppRun.
- *
- * Moonlight and the bundled FFmpeg import libva through symbols carrying
- * VA_API_* ELF version nodes. Whether the libva installed on the host can
- * satisfy those requirements cannot be inferred portably from file names or
- * loader caches, so this program embeds the same DT_NEEDED entries and
- * versioned symbol references as those binaries without ever calling into
- * them: either the dynamic loader resolves everything and main() runs (the
- * host libva is usable), or the exec itself fails and AppRun must fall back
- * to the build-environment libva staged next to this binary.
- *
- * scripts/build-appimage.sh verifies at build time that this file references
- * every VA_API_* node required by the binaries shipped in the AppImage, so
- * it stays automatically in sync with the libva usage there.
- */
-
-#include <stddef.h>
-
-#include <va/va.h>
-#include <va/va_x11.h>
-
-/* Address references are enough: they produce relocations against the
- * versioned symbols, which is what makes the loader check the host's
- * VA_API_* version nodes. The functions must never actually be called.
- * volatile keeps the table (and its relocations) alive through -O2. */
-static void *volatile requirements[] = {
-    (void *)vaCreateSurfaces, /* libva.so.2, VA_API_0.33.0 */
-    (void *)vaMapBuffer2,     /* libva.so.2, 2.21+ */
-    (void *)vaGetDisplay,     /* libva-x11.so.2 */
-};
-
-int main(void)
-{
-    return requirements[0] == NULL;
-}
@@ -1,22 +0,0 @@
-#!/bin/sh
-
-# The default HOME is not persistent, so override
-# it to a path on the onboard flash. Otherwise our
-# pairing data will be lost each reboot.
-HOME=/usr/local/moonlight
-
-# Enable Steam Controller detection in SDL
-# https://github.com/moonlight-stream/moonlight-qt/issues/697
-export SDL_ENABLE_STEAM_CONTROLLERS=1
-
-# Disable gamepad sensors by default to avoid excessive CPU
-# usage that can cause audio glitches. Remove the following
-# line to enable gamepad sensors.
-export SENSOR_REPORT_RATE_LIMIT_HZ=0
-
-# Renice PE_Single_CPU which seems to host A/V stuff
-renice -10 -p $(pidof PE_Single_CPU)
-
-# Renice Moonlight itself to avoid preemption by background tasks
-# Write output to a logfile in /tmp
-exec nice -n -10 ./bin/moonlight > /tmp/moonlight.log 2>&1
@@ -1,3 +0,0 @@
-name=Moonlight
-icon=moonlight.png
-run=moonlight.sh
@@ -1,378 +1,106 @@
 import QtQuick 2.9
 import QtQuick.Controls 2.2
-import QtQuick.Controls.Material 2.2

 import AppModel 1.0
-import ComputerManager 1.0
-import SdlGamepadKeyNavigation 1.0

-CenteredGridView {
+import ComputerManager 1.0
+
+GridView {
    property int computerIndex
    property AppModel appModel : createModel()
-    property bool activated
-    property bool showHiddenGames
-    property bool showGames

    id: appGrid
+    anchors.fill: parent
+    anchors.leftMargin: (parent.width % (cellWidth + anchors.rightMargin)) / 2
+    anchors.topMargin: 5
+    anchors.rightMargin: 5
+    anchors.bottomMargin: 5
+    cellWidth: 225; cellHeight: 350;
    focus: true
-    activeFocusOnTab: true
-    topMargin: 20
-    bottomMargin: 5
-    cellWidth: 230; cellHeight: 297;

-    function computerLost()
-    {
-        // Go back to the PC view on PC loss
-        stackView.pop()
-    }
+    // Cache delegates for 1000px in both directions to improve
+    // scrolling and resizing performance
+    cacheBuffer: 1000

-    Component.onCompleted: {
-        // Don't show any highlighted item until interacting with them.
-        // We do this here instead of onActivated to avoid losing the user's
-        // selection when backing out of a different page of the app.
-        currentIndex = -1
-    }
+    // The StackView will trigger a visibility change when
+    // we're pushed onto it, causing our onVisibleChanged
+    // routine to run, but only if we start as invisible
+    visible: false

-    StackView.onActivated: {
-        appModel.computerLost.connect(computerLost)
-        activated = true
-
-        // Highlight the first item if a gamepad is connected
-        if (currentIndex === -1 && SdlGamepadKeyNavigation.getConnectedGamepads() > 0) {
-            currentIndex = 0
+    onVisibleChanged: {
+        if (visible) {
+            // Start polling when this view is shown
+            ComputerManager.startPolling()
        }
-
-        if (!showGames && !showHiddenGames) {
-            // Check if there's a direct launch app
-            var directLaunchAppIndex = model.getDirectLaunchAppIndex();
-            if (directLaunchAppIndex >= 0) {
-                // Start the direct launch app if nothing else is running
-                currentIndex = directLaunchAppIndex
-                currentItem.launchOrResumeSelectedApp(false)
-
-                // Set showGames so we will not loop when the stream ends
-                showGames = true
-            }
+        else {
+            // Stop polling when this view is not on top
+            ComputerManager.stopPollingAsync()
        }
    }

-    StackView.onDeactivating: {
-        appModel.computerLost.disconnect(computerLost)
-        activated = false
-    }
-
    function createModel()
    {
        var model = Qt.createQmlObject('import AppModel 1.0; AppModel {}', parent, '')
-        model.initialize(ComputerManager, computerIndex, showHiddenGames)
+        model.initialize(ComputerManager, computerIndex)
        return model
    }

    model: appModel

-    delegate: NavigableItemDelegate {
-        width: 220; height: 287;
-        grid: appGrid
+    delegate: Item {
+        width: 200; height: 300;

-        property alias appContextMenu: appContextMenuLoader.item
-        property alias appNameText: appNameTextLoader.item
-
-        // Dim the app if it's hidden
-        opacity: model.hidden ? 0.4 : 1.0
+        Component.onCompleted: {
+            if (model.running) {
+                appNameText.text = "<font color=\"green\">Running</font><font color=\"white\"> - </font>" + appNameText.text
+            }
+        }

        Image {
-            property bool isPlaceholder: false
-
            id: appIcon
-            anchors.horizontalCenter: parent.horizontalCenter
-            y: 10
+            anchors.horizontalCenter: parent.horizontalCenter;
            source: model.boxart
-
-            onSourceSizeChanged: {
-                // Nearly all of Nvidia's official box art does not match the dimensions of placeholder
-                // images, however the one known exception is Overcooked. Therefore, we only execute
-                // the image size checks if this is not an app collector game. We know the officially
-                // supported games all have box art, so this check is not required.
-                if (!model.isAppCollectorGame &&
-                    ((sourceSize.width === 130 && sourceSize.height === 180) || // GFE 2.0 placeholder image
-                     (sourceSize.width === 628 && sourceSize.height === 888) || // GFE 3.0 placeholder image
-                     (sourceSize.width === 200 && sourceSize.height === 266)))  // Our no_app_image.png
-                {
-                    isPlaceholder = true
-                }
-                else
-                {
-                    isPlaceholder = false
-                }
-
-                width = 200
-                height = 267
-            }
-
-            // Display a tooltip with the full name if it's truncated
-            ToolTip.text: model.name
-            ToolTip.delay: 1000
-            ToolTip.timeout: 5000
-            ToolTip.visible: (parent.hovered || parent.highlighted) && (!appNameText || appNameText.truncated)
-        }
-
-        Loader {
-            active: model.running
-            asynchronous: true
-            anchors.fill: appIcon
-
-            sourceComponent: Item {
-                RoundButton {
-                    // Don't steal focus from the toolbar buttons
-                    focusPolicy: Qt.NoFocus
-
-                    anchors.horizontalCenterOffset: appIcon.isPlaceholder ? -47 : 0
-                    anchors.verticalCenterOffset: appIcon.isPlaceholder ? -75 : -60
-                    anchors.centerIn: parent
-                    implicitWidth: 85
-                    implicitHeight: 85
-
-                    icon.source: "qrc:/res/play_arrow_FILL1_wght700_GRAD200_opsz48.svg"
-                    icon.width: 75
-                    icon.height: 75
-
-                    onClicked: {
-                        launchOrResumeSelectedApp(true)
-                    }
-
-                    ToolTip.text: qsTr("Resume Game")
-                    ToolTip.delay: 1000
-                    ToolTip.timeout: 3000
-                    ToolTip.visible: hovered
-
-                    Material.background: "#D0808080"
-                }
-
-                RoundButton {
-                    // Don't steal focus from the toolbar buttons
-                    focusPolicy: Qt.NoFocus
-
-                    anchors.horizontalCenterOffset: appIcon.isPlaceholder ? 47 : 0
-                    anchors.verticalCenterOffset: appIcon.isPlaceholder ? -75 : 60
-                    anchors.centerIn: parent
-                    implicitWidth: 85
-                    implicitHeight: 85
-
-                    icon.source: "qrc:/res/stop_FILL1_wght700_GRAD200_opsz48.svg"
-                    icon.width: 75
-                    icon.height: 75
-
-                    onClicked: {
-                        doQuitGame()
-                    }
-
-                    ToolTip.text: qsTr("Quit Game")
-                    ToolTip.delay: 1000
-                    ToolTip.timeout: 3000
-                    ToolTip.visible: hovered
-
-                    Material.background: "#D0808080"
-                }
+            sourceSize {
+                width: 150
+                height: 200
            }
        }

-        Loader {
-            id: appNameTextLoader
-            active: appIcon.isPlaceholder
+        Text {
+            id: appNameText
+            text: model.name
+            color: "white"

-            // This loader is not asynchronous to avoid noticeable differences
-            // in the time in which the text loads for each game.
-
-            width: appIcon.width
-            height: model.running ? 175 : appIcon.height
-
-            anchors.left: appIcon.left
-            anchors.right: appIcon.right
-            anchors.bottom: appIcon.bottom
-
-            sourceComponent: Label {
-                id: appNameText
-                text: model.name
-                font.pointSize: 22
-                leftPadding: 20
-                rightPadding: 20
-                verticalAlignment: Text.AlignVCenter
-                horizontalAlignment: Text.AlignHCenter
-                wrapMode: Text.Wrap
-                elide: Text.ElideRight
-            }
-        }
-
-        function launchOrResumeSelectedApp(quitExistingApp)
-        {
-            var runningId = appModel.getRunningAppId()
-            if (runningId !== 0 && runningId !== model.appid) {
-                if (quitExistingApp) {
-                    quitAppDialog.appName = appModel.getRunningAppName()
-                    quitAppDialog.segueToStream = true
-                    quitAppDialog.nextAppName = model.name
-                    quitAppDialog.nextAppIndex = index
-                    quitAppDialog.open()
-                }
-
-                return
-            }
-
-            var component = Qt.createComponent("StreamSegue.qml")
-            var segue = component.createObject(stackView, {
-                                                   "appName": model.name,
-                                                   "session": appModel.createSessionForApp(index),
-                                                   "isResume": runningId === model.appid
-                                               })
-            stackView.push(segue)
-        }
-
-        onClicked: {
-            // Only allow clicking on the box art for non-running games.
-            // For running games, buttons will appear to resume or quit which
-            // will handle starting the game and clicks on the box art will
-            // be ignored.
-            if (!model.running) {
-                launchOrResumeSelectedApp(true)
-            }
-        }
-
-        onPressAndHold: {
-            // popup() ensures the menu appears under the mouse cursor
-            if (appContextMenu.popup) {
-                appContextMenu.popup()
-            }
-            else {
-                // Qt 5.9 doesn't have popup()
-                appContextMenu.open()
-            }
+            width: parent.width
+            height: 100
+            anchors.top: appIcon.bottom
+            font.pointSize: 26
+            horizontalAlignment: Text.AlignHCenter
+            wrapMode: Text.Wrap
        }

        MouseArea {
            anchors.fill: parent
-            acceptedButtons: Qt.RightButton;
            onClicked: {
-                parent.pressAndHold()
-            }
-        }
+                // TODO: Check if a different game is running

-        Keys.onReturnPressed: {
-            // Open the app context menu if activated via the gamepad or keyboard
-            // for running games. If the game isn't running, the above onClicked
-            // method will handle the launch.
-            if (model.running) {
-                // This will be keyboard/gamepad driven so use
-                // open() instead of popup()
-                appContextMenu.open()
-            }
-        }
-
-        Keys.onEnterPressed: {
-            // Open the app context menu if activated via the gamepad or keyboard
-            // for running games. If the game isn't running, the above onClicked
-            // method will handle the launch.
-            if (model.running) {
-                // This will be keyboard/gamepad driven so use
-                // open() instead of popup()
-                appContextMenu.open()
-            }
-        }
-
-        Keys.onMenuPressed: {
-            // This will be keyboard/gamepad driven so use open() instead of popup()
-            appContextMenu.open()
-        }
-
-        function doQuitGame() {
-            quitAppDialog.appName = appModel.getRunningAppName()
-            quitAppDialog.segueToStream = false
-            quitAppDialog.open()
-        }
-
-        Loader {
-            id: appContextMenuLoader
-            asynchronous: true
-            sourceComponent: NavigableMenu {
-                id: appContextMenu
-                initiator: appContextMenuLoader.parent
-                NavigableMenuItem {
-                    text: model.running ? qsTr("Resume Game") : qsTr("Launch Game")
-                    onTriggered: launchOrResumeSelectedApp(true)
-                }
-                NavigableMenuItem {
-                    text: qsTr("Quit Game")
-                    onTriggered: doQuitGame()
-                    visible: model.running
-                }
-                NavigableMenuItem {
-                    checkable: true
-                    checked: model.directLaunch
-                    text: qsTr("Direct Launch")
-                    onTriggered: appModel.setAppDirectLaunch(model.index, !model.directLaunch)
-                    enabled: !model.hidden
-
-                    ToolTip.text: qsTr("Launch this app immediately when the host is selected, bypassing the app selection grid.")
-                    ToolTip.delay: 1000
-                    ToolTip.timeout: 3000
-                    ToolTip.visible: hovered
-                }
-                NavigableMenuItem {
-                    checkable: true
-                    checked: model.hidden
-                    text: qsTr("Hide Game")
-                    onTriggered: appModel.setAppHidden(model.index, !model.hidden)
-                    enabled: model.hidden || (!model.running && !model.directLaunch)
-
-                    ToolTip.text: qsTr("Hide this game from the app grid. To access hidden games, right-click on the host and choose %1.").arg(qsTr("View All Apps"))
-                    ToolTip.delay: 1000
-                    ToolTip.timeout: 5000
-                    ToolTip.visible: hovered
-                }
+                var component = Qt.createComponent("StreamSegue.qml")
+                var segue = component.createObject(stackView)
+                segue.appname = model.name
+                segue.session = appModel.createSessionForApp(index)
+                stackView.push(segue)
            }
        }
    }

-    Row {
-        anchors.centerIn: parent
-        spacing: 5
-        visible: appGrid.count === 0
+    ScrollBar.vertical: ScrollBar {
+        parent: appGrid.parent
+        anchors {
+            top: appGrid.top
+            left: appGrid.right
+            bottom: appGrid.bottom

-        Label {
-            text: qsTr("This computer doesn't seem to have any applications or some applications are hidden")
-            font.pointSize: 20
-            verticalAlignment: Text.AlignVCenter
-            wrapMode: Text.Wrap
+            leftMargin: -10
        }
    }
-
-    NavigableMessageDialog {
-        id: quitAppDialog
-        property string appName : ""
-        property bool segueToStream : false
-        property string nextAppName: ""
-        property int nextAppIndex: 0
-        text:qsTr("Are you sure you want to quit %1? Any unsaved progress will be lost.").arg(appName)
-        standardButtons: Dialog.Yes | Dialog.No
-
-        function quitApp() {
-            var component = Qt.createComponent("QuitSegue.qml")
-            var params = {"appName": appName, "quitRunningAppFn": function() { appModel.quitRunningApp() }}
-            if (segueToStream) {
-                // Store the session and app name if we're going to stream after
-                // successfully quitting the old app.
-                params.nextAppName = nextAppName
-                params.nextSession = appModel.createSessionForApp(nextAppIndex)
-            }
-            else {
-                params.nextAppName = null
-                params.nextSession = null
-            }
-
-            stackView.push(component.createObject(stackView, params))
-        }
-
-        onAccepted: quitApp()
-    }
-
-    ScrollBar.vertical: ScrollBar {}
 }
@@ -1,61 +0,0 @@
-import QtQuick 2.9
-import QtQuick.Controls 2.2
-
-import SdlGamepadKeyNavigation 1.0
-import SystemProperties 1.0
-
-// https://stackoverflow.com/questions/45029968/how-do-i-set-the-combobox-width-to-fit-the-largest-item
-ComboBox {
-    property int textWidth
-    property int desiredWidth : leftPadding + textWidth + indicator.width + rightPadding
-    property int maximumWidth : parent.width
-
-    implicitWidth: desiredWidth < maximumWidth ? desiredWidth : maximumWidth
-
-    TextMetrics {
-        id: popupMetrics
-    }
-
-    TextMetrics {
-        id: textMetrics
-    }
-
-    function recalculateWidth() {
-        textMetrics.font = font
-        popupMetrics.font = popup.font
-        textWidth = 0
-        for (var i = 0; i < count; i++){
-            textMetrics.text = textAt(i)
-            popupMetrics.text = textAt(i)
-            textWidth = Math.max(textMetrics.width, textWidth)
-            textWidth = Math.max(popupMetrics.width, textWidth)
-        }
-    }
-
-    // We call this every time the options change (and init)
-    // so we can adjust the combo box width here too
-    onActivated: recalculateWidth()
-
-    popup.onAboutToShow: {
-        // Switch to normal navigation for combo boxes
-        SdlGamepadKeyNavigation.setUiNavMode(false)
-
-        // Override the popup color to improve contrast with the overridden
-        // Material 2 background color set in main.qml.
-        if (SystemProperties.usesMaterial3Theme) {
-            popup.background.color = "#424242"
-        }
-    }
-
-    popup.onAboutToHide: {
-        SdlGamepadKeyNavigation.setUiNavMode(true)
-    }
-
-    Keys.onLeftPressed: {
-        decrementCurrentIndex()
-    }
-
-    Keys.onRightPressed: {
-        incrementCurrentIndex()
-    }
-}
@@ -1,25 +0,0 @@
-import QtQuick 2.9
-import QtQuick.Controls 2.2
-
-GridView {
-    property int minMargin: 10
-    property real availableWidth: (parent.width - 2 * minMargin)
-    property int itemsPerRow: availableWidth / cellWidth
-    property real horizontalMargin: itemsPerRow < count && availableWidth >= cellWidth ?
-                                        (availableWidth % cellWidth) / 2 : minMargin
-
-    function updateMargins() {
-        leftMargin = horizontalMargin
-        rightMargin = horizontalMargin
-    }
-
-    onHorizontalMarginChanged: {
-        updateMargins()
-    }
-
-    Component.onCompleted: {
-        updateMargins()
-    }
-
-    boundsBehavior: Flickable.OvershootBounds
-}
@@ -1,87 +0,0 @@
-import QtQuick 2.0
-import QtQuick.Controls 2.2
-
-import ComputerManager 1.0
-
-Item {
-    function onSearchingComputer() {
-        stageLabel.text = qsTr("Establishing connection to PC...")
-    }
-
-    function onPairing(pcName, pin) {
-        stageLabel.text = qsTr("Pairing... Please enter '%1' on %2.").arg(pin).arg(pcName)
-    }
-
-    function onFailed(message) {
-        stageIndicator.visible = false
-        errorDialog.text = message
-        errorDialog.open()
-    }
-
-    function onSuccess(appName) {
-        stageIndicator.visible = false
-        pairCompleteDialog.open()
-    }
-
-    // Allow user to back out of pairing
-    Keys.onEscapePressed: {
-        Qt.quit()
-    }
-    Keys.onBackPressed: {
-        Qt.quit()
-    }
-    Keys.onCancelPressed: {
-        Qt.quit()
-    }
-
-    StackView.onActivated: {
-        if (!launcher.isExecuted()) {
-            toolBar.visible = false
-
-            launcher.searchingComputer.connect(onSearchingComputer)
-            launcher.pairing.connect(onPairing)
-            launcher.failed.connect(onFailed)
-            launcher.success.connect(onSuccess)
-            launcher.execute(ComputerManager)
-        }
-    }
-
-    Row {
-        anchors.centerIn: parent
-        spacing: 5
-        id: stageIndicator
-
-        BusyIndicator {
-            id: stageSpinner
-            running: visible
-        }
-
-        Label {
-            id: stageLabel
-            height: stageSpinner.height
-            font.pointSize: 20
-            verticalAlignment: Text.AlignVCenter
-
-            wrapMode: Text.Wrap
-        }
-    }
-
-    ErrorMessageDialog {
-        id: errorDialog
-
-        onClosed: {
-            Qt.quit();
-        }
-    }
-
-    NavigableMessageDialog {
-        id: pairCompleteDialog
-        closePolicy: Popup.CloseOnEscape
-
-        text:qsTr("Pairing completed successfully")
-        standardButtons: Dialog.Ok
-        onClosed: {
-            Qt.quit()
-        }
-    }
-}
@@ -1,58 +0,0 @@
-import QtQuick 2.0
-import QtQuick.Controls 2.2
-
-import ComputerManager 1.0
-import Session 1.0
-
-Item {
-    function onSearchingComputer() {
-        stageLabel.text = qsTr("Establishing connection to PC...")
-    }
-
-    function onQuittingApp() {
-        stageLabel.text = qsTr("Quitting app...")
-    }
-
-    function onFailure(message) {
-        errorDialog.text = message
-        errorDialog.open()
-    }
-
-    StackView.onActivated: {
-        if (!launcher.isExecuted()) {
-            toolBar.visible = false
-            launcher.searchingComputer.connect(onSearchingComputer)
-            launcher.quittingApp.connect(onQuittingApp)
-            launcher.failed.connect(onFailure)
-            launcher.execute(ComputerManager)
-        }
-    }
-
-    Row {
-        anchors.centerIn: parent
-        spacing: 5
-
-        BusyIndicator {
-            id: stageSpinner
-            running: visible
-        }
-
-        Label {
-            id: stageLabel
-            height: stageSpinner.height
-            text: stageText
-            font.pointSize: 20
-            verticalAlignment: Text.AlignVCenter
-
-            wrapMode: Text.Wrap
-        }
-    }
-
-    ErrorMessageDialog {
-        id: errorDialog
-
-        onClosed: {
-            Qt.quit()
-        }
-    }
-}
@@ -1,91 +0,0 @@
-import QtQuick 2.0
-import QtQuick.Controls 2.2
-
-import ComputerManager 1.0
-
-Item {
-    function onSearchingComputer() {
-        stageLabel.text = qsTr("Establishing connection to PC...")
-    }
-
-    function onSearchingApp() {
-        stageLabel.text = qsTr("Loading app list...")
-    }
-
-    function onSessionCreated(appName, session) {
-        var component = Qt.createComponent("StreamSegue.qml")
-        var segue = component.createObject(stackView, {
-            "appName": appName,
-            "session": session,
-            "quitAfter": true
-        })
-        stackView.push(segue)
-    }
-
-    function onLaunchFailed(message) {
-        errorDialog.text = message
-        errorDialog.open()
-        console.error(message)
-    }
-
-    function onAppQuitRequired(appName) {
-        quitAppDialog.appName = appName
-        quitAppDialog.open()
-    }
-
-    StackView.onActivated: {
-        if (!launcher.isExecuted()) {
-            toolBar.visible = false
-
-            launcher.searchingComputer.connect(onSearchingComputer)
-            launcher.searchingApp.connect(onSearchingApp)
-            launcher.sessionCreated.connect(onSessionCreated)
-            launcher.failed.connect(onLaunchFailed)
-            launcher.appQuitRequired.connect(onAppQuitRequired)
-            launcher.execute(ComputerManager)
-        }
-    }
-
-    Row {
-        anchors.centerIn: parent
-        spacing: 5
-
-        BusyIndicator {
-            id: stageSpinner
-            running: visible
-        }
-
-        Label {
-            id: stageLabel
-            height: stageSpinner.height
-            font.pointSize: 20
-            verticalAlignment: Text.AlignVCenter
-
-            wrapMode: Text.Wrap
-        }
-    }
-
-    ErrorMessageDialog {
-        id: errorDialog
-
-        onClosed: {
-            Qt.quit();
-        }
-    }
-
-    NavigableMessageDialog {
-        id: quitAppDialog
-        text:qsTr("Are you sure you want to quit %1? Any unsaved progress will be lost.").arg(appName)
-        standardButtons: Dialog.Yes | Dialog.No
-        property string appName : ""
-
-        function quitApp() {
-            var component = Qt.createComponent("QuitSegue.qml")
-            var params = {"appName": appName, "quitRunningAppFn": function() { launcher.quitRunningApp() }}
-            stackView.push(component.createObject(stackView, params))
-        }
-
-        onAccepted: quitApp()
-        onRejected: Qt.quit()
-    }
-}
@@ -1,8 +0,0 @@
-import QtQuick 2.0
-import QtQuick.Controls 2.2
-
-import SystemProperties 1.0
-
-NavigableMessageDialog {
-    standardButtons: Dialog.Ok | (SystemProperties.hasBrowser ? Dialog.Help : 0)
-}
@@ -1,5 +1,5 @@
 import QtQuick 2.0

 Item {
-    objectName: qsTr("Gamepad Mapping")
+    objectName: "Gamepad Mapping"
 }
@@ -1,14 +0,0 @@
-import QtQuick 2.0
-import QtQuick.Controls 2.5
-
-Dialog {
-    modal: true
-    anchors.centerIn: Overlay.overlay
-
-    onClosed: {
-        // We must force focus back to the last item. If we don't,
-        // gamepad and keyboard navigation will break after a
-        // dialog appears.
-        stackView.forceActiveFocus()
-    }
-}
@@ -1,32 +0,0 @@
-import QtQuick 2.0
-import QtQuick.Controls 2.2
-
-ItemDelegate {
-    property GridView grid
-
-    highlighted: grid.activeFocus && grid.currentItem === this
-
-    Keys.onLeftPressed: {
-        grid.moveCurrentIndexLeft()
-    }
-    Keys.onRightPressed: {
-        grid.moveCurrentIndexRight()
-    }
-    Keys.onDownPressed: {
-        grid.moveCurrentIndexDown()
-    }
-    Keys.onUpPressed: {
-        grid.moveCurrentIndexUp()
-
-        // If we've reached the top of the grid, move focus to the toolbar
-        if (grid.currentItem === this) {
-            nextItemInFocusChain(false).forceActiveFocus(Qt.TabFocus)
-        }
-    }
-    Keys.onReturnPressed: {
-        clicked()
-    }
-    Keys.onEnterPressed: {
-        clicked()
-    }
-}
@@ -1,20 +0,0 @@
-import QtQuick 2.0
-import QtQuick.Controls 2.2
-
-Menu {
-    property var initiator
-
-    onOpened: {
-        // If the initiating object currently has keyboard focus,
-        // give focus to the first visible and enabled menu item
-        if (initiator.focus) {
-            for (var i = 0; i < count; i++) {
-                var item = itemAt(i)
-                if (item.visible && item.enabled) {
-                    item.forceActiveFocus(Qt.TabFocusReason)
-                    break
-                }
-            }
-        }
-    }
-}
@@ -1,28 +0,0 @@
-import QtQuick 2.0
-import QtQuick.Controls 2.2
-
-MenuItem {
-    // Ensure focus can't be given to an invisible item
-    enabled: visible
-    height: visible ? implicitHeight : 0
-    focusPolicy: visible ? Qt.TabFocus : Qt.NoFocus
-
-    onTriggered: {
-        // We must close the context menu first or
-        // it can steal focus from any dialogs that
-        // onTriggered may spawn.
-        menu.close()
-    }
-
-    Keys.onReturnPressed: {
-        triggered()
-    }
-
-    Keys.onEnterPressed: {
-        triggered()
-    }
-
-    Keys.onEscapePressed: {
-        menu.close()
-    }
-}
@@ -1,78 +0,0 @@
-import QtQuick 2.0
-import QtQuick.Controls 2.2
-import QtQuick.Layouts 1.2
-
-NavigableDialog {
-    id: dialog
-
-    property alias text: dialogLabel.dialogText
-    property alias showSpinner: dialogSpinner.visible
-    property alias imageSrc: dialogImage.source
-
-    property string helpText
-    property string helpUrl : "https://github.com/moonlight-stream/moonlight-docs/wiki/Troubleshooting"
-    property string helpTextSeparator : " "
-
-    onOpened: {
-        // Force keyboard focus on the label so keyboard navigation works
-        if (dialogButtonBox.count > 0) {
-            dialogButtonBox.itemAt(dialogButtonBox.count - 1).forceActiveFocus(Qt.TabFocus)
-        }
-    }
-
-    RowLayout {
-        spacing: 10
-
-        BusyIndicator {
-            id: dialogSpinner
-            visible: false
-            running: visible
-        }
-
-        Image {
-            id: dialogImage
-            source: (standardButtons & Dialog.Yes) ?
-                        "qrc:/res/baseline-help_outline-24px.svg" :
-                        "qrc:/res/baseline-error_outline-24px.svg"
-            sourceSize {
-                // The icon should be square so use the height as the width too
-                width: 50
-                height: 50
-            }
-            visible: !showSpinner
-        }
-
-        Label {
-            property string dialogText
-
-            id: dialogLabel
-            text: dialogText + ((helpText && (standardButtons & Dialog.Help)) ? (helpTextSeparator + helpText) : "")
-            wrapMode: Text.Wrap
-            elide: Label.ElideRight
-
-            // Cap the width so the dialog doesn't grow horizontally forever. This
-            // will cause word wrap to kick in.
-            Layout.maximumWidth: 400
-            Layout.maximumHeight: 400
-        }
-    }
-
-    footer: DialogButtonBox {
-        id: dialogButtonBox
-        standardButtons: dialog.standardButtons
-
-        delegate: Button {
-            flat: true
-
-            Keys.onReturnPressed: clicked()
-            Keys.onEnterPressed: clicked()
-            Keys.onRightPressed: nextItemInFocusChain(true).forceActiveFocus(Qt.TabFocus)
-            Keys.onLeftPressed: nextItemInFocusChain(false).forceActiveFocus(Qt.TabFocus)
-        }
-
-        onHelpRequested: {
-            Qt.openUrlExternally(helpUrl)
-            close()
-        }
-    }
-}
@@ -1,33 +0,0 @@
-import QtQuick 2.0
-import QtQuick.Controls 2.2
-import QtQuick.Layouts 1.3
-
-ToolButton {
-    property string iconSource
-
-    activeFocusOnTab: true
-
-    icon.source: iconSource
-    icon.width: background.width
-    icon.height: background.height
-
-    // This determines the size of the Material highlight. We increase it
-    // from the default because we use larger than normal icons for TV readability.
-    Layout.preferredHeight: parent.height
-
-    Keys.onReturnPressed: {
-        clicked()
-    }
-
-    Keys.onEnterPressed: {
-        clicked()
-    }
-
-    Keys.onRightPressed: {
-        nextItemInFocusChain(true).forceActiveFocus(Qt.TabFocus)
-    }
-
-    Keys.onLeftPressed: {
-        nextItemInFocusChain(false).forceActiveFocus(Qt.TabFocus)
-    }
-}
@@ -1,47 +1,44 @@
 import QtQuick 2.9
 import QtQuick.Controls 2.2
+import QtQuick.Dialogs 1.3
 import QtQuick.Layouts 1.3

 import ComputerModel 1.0

 import ComputerManager 1.0
-import StreamingPreferences 1.0
-import SystemProperties 1.0
-import SdlGamepadKeyNavigation 1.0

-CenteredGridView {
+GridView {
    property ComputerModel computerModel : createModel()

    id: pcGrid
+    anchors.fill: parent
+    anchors.leftMargin: (parent.width % (cellWidth + anchors.rightMargin)) / 2
+    anchors.topMargin: 5
+    anchors.rightMargin: 5
+    anchors.bottomMargin: 5
+    cellWidth: 350; cellHeight: 350;
    focus: true
-    activeFocusOnTab: true
-    topMargin: 20
-    bottomMargin: 5
-    cellWidth: 310; cellHeight: 330;
-    objectName: qsTr("Computers")
+    objectName: "Computers"
+
+    // The StackView will trigger a visibility change when
+    // we're pushed onto it, causing our onVisibleChanged
+    // routine to run, but only if we start as invisible
+    visible: false

    Component.onCompleted: {
-        // Don't show any highlighted item until interacting with them.
-        // We do this here instead of onActivated to avoid losing the user's
-        // selection when backing out of a different page of the app.
-        currentIndex = -1
-    }
-
-    // Note: Any initialization done here that is critical for streaming must
-    // also be done in CliStartStreamSegue.qml, since this code does not run
-    // for command-line initiated streams.
-    StackView.onActivated: {
        // Setup signals on CM
        ComputerManager.computerAddCompleted.connect(addComplete)
-
-        // Highlight the first item if a gamepad is connected
-        if (currentIndex === -1 && SdlGamepadKeyNavigation.getConnectedGamepads() > 0) {
-            currentIndex = 0
-        }
    }

-    StackView.onDeactivating: {
-        ComputerManager.computerAddCompleted.disconnect(addComplete)
+    onVisibleChanged: {
+        if (visible) {
+            // Start polling when this view is shown
+            ComputerManager.startPolling()
+        }
+        else {
+            // Stop polling when this view is not top-most
+            ComputerManager.stopPollingAsync()
+        }
    }

    function pairingComplete(error)
@@ -49,26 +46,20 @@ CenteredGridView {
        // Close the PIN dialog
        pairDialog.close()

+        // Start polling again
+        ComputerManager.startPolling()
+
        // Display a failed dialog if we got an error
-        if (error !== undefined) {
+        if (error !== null) {
            errorDialog.text = error
-            errorDialog.helpText = ""
            errorDialog.open()
        }
    }

-    function addComplete(success, detectedPortBlocking)
+    function addComplete(success)
    {
        if (!success) {
-            errorDialog.text = qsTr("Unable to connect to the specified PC.")
-
-            if (detectedPortBlocking) {
-                errorDialog.text += "\n\n" + qsTr("This PC's Internet connection is blocking Moonlight. Streaming over the Internet may not work while connected to this network.")
-            }
-            else {
-                errorDialog.helpText = qsTr("Click the Help button for possible solutions.")
-            }
-
+            errorDialog.text = "Unable to connect to the specified PC. Ensure GameStream is enabled in GeForce Experience."
            errorDialog.open()
        }
    }
@@ -78,327 +69,174 @@ CenteredGridView {
        var model = Qt.createQmlObject('import ComputerModel 1.0; ComputerModel {}', parent, '')
        model.initialize(ComputerManager)
        model.pairingCompleted.connect(pairingComplete)
-        model.connectionTestCompleted.connect(testConnectionDialog.connectionTestComplete)
        return model
    }

-    Row {
-        anchors.centerIn: parent
-        spacing: 5
-        visible: pcGrid.count === 0
+    model: createModel()

-        BusyIndicator {
-            id: searchSpinner
-            visible: StreamingPreferences.enableMdns
-            running: visible
-        }
-
-        Label {
-            height: searchSpinner.height
-            elide: Label.ElideRight
-            text: StreamingPreferences.enableMdns ? qsTr("Searching for compatible hosts on your local network...")
-                                                  : qsTr("Automatic PC discovery is disabled. Add your PC manually.")
-            font.pointSize: 20
-            verticalAlignment: Text.AlignVCenter
-            wrapMode: Text.Wrap
-        }
-    }
-
-    model: computerModel
-
-    delegate: NavigableItemDelegate {
-        width: 300; height: 320;
-        grid: pcGrid
-
-        property alias pcContextMenu : pcContextMenuLoader.item
+    delegate: Item {
+        width: 300; height: 300;

        Image {
            id: pcIcon
-            anchors.horizontalCenter: parent.horizontalCenter
-            source: "qrc:/res/desktop_windows-48px.svg"
+            anchors.horizontalCenter: parent.horizontalCenter;
+            source: {
+                model.addPc ? "qrc:/res/ic_add_to_queue_white_48px.svg" : "qrc:/res/ic_tv_white_48px.svg"
+            }
            sourceSize {
                width: 200
                height: 200
            }
        }

-        Image {
-            // TODO: Tooltip
-            id: stateIcon
-            anchors.horizontalCenter: pcIcon.horizontalCenter
-            anchors.verticalCenter: pcIcon.verticalCenter
-            anchors.verticalCenterOffset: !model.online ? -18 : -16
-            visible: !model.statusUnknown && (!model.online || !model.paired)
-            source: !model.online ? "qrc:/res/warning_FILL1_wght300_GRAD200_opsz24.svg" : "qrc:/res/baseline-lock-24px.svg"
-            sourceSize {
-                width: !model.online ? 75 : 70
-                height: !model.online ? 75 : 70
-            }
-        }
-
-        BusyIndicator {
-            id: statusUnknownSpinner
-            anchors.horizontalCenter: pcIcon.horizontalCenter
-            anchors.verticalCenter: pcIcon.verticalCenter
-            anchors.verticalCenterOffset: -15
-            width: 75
-            height: 75
-            visible: model.statusUnknown
-            running: visible
-        }
-
-        Label {
+        Text {
            id: pcNameText
            text: model.name
+            color: "white"

            width: parent.width
            anchors.top: pcIcon.bottom
-            anchors.bottom: parent.bottom
            font.pointSize: 36
            horizontalAlignment: Text.AlignHCenter
            wrapMode: Text.Wrap
-            elide: Text.ElideRight
        }

-        Loader {
-            id: pcContextMenuLoader
-            asynchronous: true
-            sourceComponent: NavigableMenu {
-                id: pcContextMenu
-                initiator: pcContextMenuLoader.parent
-                MenuItem {
-                    text: qsTr("PC Status: %1").arg(model.online ? qsTr("Online") : qsTr("Offline"))
-                    font.bold: true
-                    enabled: false
-                }
-                NavigableMenuItem {
-                    text: qsTr("View All Apps")
-                    onTriggered: {
-                        var component = Qt.createComponent("AppView.qml")
-                        var appView = component.createObject(stackView, {"computerIndex": index, "objectName": model.name, "showHiddenGames": true})
-                        stackView.push(appView)
+        Text {
+            function getStatusText(model)
+            {
+                if (model.online) {
+                    var text = "<font color=\"green\">Online</font>"
+                    text += "<font color=\"white\"> - </font>"
+                    if (model.paired) {
+                        text += "<font color=\"skyblue\">Paired</font>"
                    }
-                    visible: model.online && model.paired
-                }
-                NavigableMenuItem {
-                    text: qsTr("Wake PC")
-                    onTriggered: computerModel.wakeComputer(index)
-                    visible: !model.online && model.wakeable
-                }
-                NavigableMenuItem {
-                    text: qsTr("Test Network")
-                    onTriggered: {
-                        computerModel.testConnectionForComputer(index)
-                        testConnectionDialog.open()
+                    else if (model.busy) {
+                        text += "<font color=\"red\">Busy</font>"
                    }
-                }
-
-                NavigableMenuItem {
-                    text: qsTr("Rename PC")
-                    onTriggered: {
-                        renamePcDialog.pcIndex = index
-                        renamePcDialog.originalName = model.name
-                        renamePcDialog.open()
+                    else {
+                        text += "<font color=\"red\">Not Paired</font>"
                    }
-                }
-                NavigableMenuItem {
-                    text: qsTr("Delete PC")
-                    onTriggered: {
-                        deletePcDialog.pcIndex = index
-                        deletePcDialog.pcName = model.name
-                        deletePcDialog.open()
-                    }
-                }
-                NavigableMenuItem {
-                    text: qsTr("View Details")
-                    onTriggered: {
-                        showPcDetailsDialog.pcDetails = model.details
-                        showPcDetailsDialog.open()
-                    }
-                }
-            }
-        }
-
-        onClicked: {
-            if (model.online) {
-                if (!model.serverSupported) {
-                    errorDialog.text = qsTr("The version of GeForce Experience on %1 is not supported by this build of Moonlight. You must update Moonlight to stream from %1.").arg(model.name)
-                    errorDialog.helpText = ""
-                    errorDialog.open()
-                }
-                else if (model.paired) {
-                    // go to game view
-                    var component = Qt.createComponent("AppView.qml")
-                    var appView = component.createObject(stackView, {"computerIndex": index, "objectName": model.name})
-                    stackView.push(appView)
+                    return text
                }
                else {
-                    var pin = computerModel.generatePinString()
-
-                    // Kick off pairing in the background
-                    computerModel.pairComputer(index, pin)
-
-                    // Display the pairing dialog
-                    pairDialog.pin = pin
-                    pairDialog.open()
+                    return "<font color=\"red\">Offline</font>";
                }
-            } else if (!model.online) {
-                // Using open() here because it may be activated by keyboard
-                pcContextMenu.open()
            }
-        }

-        onPressAndHold: {
-            // popup() ensures the menu appears under the mouse cursor
-            if (pcContextMenu.popup) {
-                pcContextMenu.popup()
-            }
-            else {
-                // Qt 5.9 doesn't have popup()
-                pcContextMenu.open()
-            }
+            id: pcPairedText
+            text: getStatusText(model)
+            visible: !model.addPc
+
+            width: parent.width
+            anchors.top: pcNameText.bottom
+            font.pointSize: 24
+            horizontalAlignment: Text.AlignHCenter
        }

        MouseArea {
            anchors.fill: parent
-            acceptedButtons: Qt.RightButton;
            onClicked: {
-                parent.pressAndHold()
+                if (model.addPc) {
+                    addPcDialog.open()
+                }
+                else if (model.online) {
+                    if (model.paired) {
+                        // go to game view
+                        var component = Qt.createComponent("AppView.qml")
+                        var appView = component.createObject(stackView)
+                        appView.computerIndex = index
+                        appView.objectName = model.name
+                        stackView.push(appView)
+                    }
+                    else {
+                        if (!model.busy) {
+                            var pin = ("0000" + Math.floor(Math.random() * 10000)).slice(-4)
+
+                            // Stop polling, since pairing may make GFE unresponsive
+                            ComputerManager.stopPollingAsync()
+
+                            // Kick off pairing in the background
+                            computerModel.pairComputer(index, pin)
+
+                            // Display the pairing dialog
+                            pairDialog.pin = pin
+                            pairDialog.open()
+                        }
+                        else {
+                            // cannot pair while something is streaming or attempting to pair
+                            errorDialog.text = "This PC is currently busy. Make sure to quit any running games and try again."
+                            errorDialog.open()
+                        }
+                    }
+                }
+                else {
+                    // TODO: Wake on LAN and delete PC options
+                }
            }
        }
-
-        Keys.onMenuPressed: {
-            // We must use open() here so the menu is positioned on
-            // the ItemDelegate and not where the mouse cursor is
-            pcContextMenu.open()
-        }
-
-        Keys.onDeletePressed: {
-            deletePcDialog.pcIndex = index
-            deletePcDialog.pcName = model.name
-            deletePcDialog.open()
-        }
    }

-    ErrorMessageDialog {
+    MessageDialog {
        id: errorDialog
-
-        // Using Setup-Guide here instead of Troubleshooting because it's likely that users
-        // will arrive here by forgetting to enable GameStream or not forwarding ports.
-        helpUrl: "https://github.com/moonlight-stream/moonlight-docs/wiki/Setup-Guide"
+        // don't allow edits to the rest of the window while open
+        modality:Qt.WindowModal
+        icon: StandardIcon.Critical
+        standardButtons: StandardButton.Ok
    }

-    NavigableMessageDialog {
+    MessageDialog {
        id: pairDialog
-        closePolicy: Popup.CloseOnEscape
-
        // don't allow edits to the rest of the window while open
+        modality:Qt.WindowModal
        property string pin : "0000"
-        text:qsTr("Please enter %1 on your host PC. This dialog will close when pairing is completed.").arg(pin)+"\n\n"+
-             qsTr("If your host PC is running Sunshine, navigate to the Sunshine web UI to enter the PIN.")
-        standardButtons: Dialog.Cancel
+        text:"Please enter " + pin + " on your GameStream PC. This dialog will close when pairing is completed."
+        standardButtons: StandardButton.Cancel
        onRejected: {
            // FIXME: We should interrupt pairing here
        }
    }

-    NavigableMessageDialog {
-        id: deletePcDialog
-        // don't allow edits to the rest of the window while open
-        property int pcIndex : -1
-        property string pcName : ""
-        text: qsTr("Are you sure you want to remove '%1'?").arg(pcName)
-        standardButtons: Dialog.Yes | Dialog.No
+    Dialog {
+        id: addPcDialog
+        property string label: "Enter the IP address of your GameStream PC"
+        property string hint: "192.168.1.100"
+        property alias editText : editTextItem

+        standardButtons: StandardButton.Ok | StandardButton.Cancel
+        onVisibleChanged: {
+            editTextItem.focus = true
+            editTextItem.selectAll()
+        }
        onAccepted: {
-            computerModel.deleteComputer(pcIndex)
-        }
-    }
-
-    NavigableMessageDialog {
-        id: testConnectionDialog
-        closePolicy: Popup.CloseOnEscape
-        standardButtons: Dialog.Ok
-
-        onAboutToShow: {
-            testConnectionDialog.text = qsTr("Moonlight is testing your network connection to determine if any required ports are blocked.") + "\n\n" + qsTr("This may take a few seconds…")
-            showSpinner = true
-        }
-
-        function connectionTestComplete(result, blockedPorts)
-        {
-            if (result === -1) {
-                text = qsTr("The network test could not be performed because none of Moonlight's connection testing servers were reachable from this PC. Check your Internet connection or try again later.")
-                imageSrc = "qrc:/res/baseline-warning-24px.svg"
-            }
-            else if (result === 0) {
-                text = qsTr("This network does not appear to be blocking Moonlight. If you still have trouble connecting, check your PC's firewall settings.") + "\n\n" + qsTr("If you are trying to stream over the Internet, install the Moonlight Internet Hosting Tool on your gaming PC and run the included Internet Streaming Tester to check your gaming PC's Internet connection.")
-                imageSrc = "qrc:/res/baseline-check_circle_outline-24px.svg"
-            }
-            else {
-                text = qsTr("Your PC's current network connection seems to be blocking Moonlight. Streaming over the Internet may not work while connected to this network.") + "\n\n" + qsTr("The following network ports were blocked:") + "\n"
-                text += blockedPorts
-                imageSrc = "qrc:/res/baseline-error_outline-24px.svg"
-            }
-
-            // Stop showing the spinner and show the image instead
-            showSpinner = false
-        }
-    }
-
-    NavigableDialog {
-        id: renamePcDialog
-        property string label: qsTr("Enter the new name for this PC:")
-        property string originalName
-        property int pcIndex : -1;
-
-        standardButtons: Dialog.Ok | Dialog.Cancel
-
-        onOpened: {
-            // Force keyboard focus on the textbox so keyboard navigation works
-            editText.forceActiveFocus()
-        }
-
-        onClosed: {
-            editText.clear()
-        }
-
-        onAccepted: {
-            if (editText.text) {
-                computerModel.renameComputer(pcIndex, editText.text)
-            }
+            ComputerManager.addNewHost(editText.text, false)
        }

        ColumnLayout {
-            Label {
-                text: renamePcDialog.label
-                font.bold: true
+            Text {
+                id: addPcDialogLabel
+                text: addPcDialog.label
            }
+            Rectangle {
+                implicitWidth: parent.parent.width
+                height: editTextItem.height

-            TextField {
-                id: editText
-                placeholderText: renamePcDialog.originalName
-                Layout.fillWidth: true
-                focus: true
-
-                Keys.onReturnPressed: {
-                    renamePcDialog.accept()
-                }
-
-                Keys.onEnterPressed: {
-                    renamePcDialog.accept()
+                TextInput {
+                    id: editTextItem
+                    inputMethodHints: Qt.ImhPreferUppercase
+                    text: addPcDialog.hint
                }
            }
        }
    }

-    NavigableMessageDialog {
-        id: showPcDetailsDialog
-        property string pcDetails : "";
-        text: showPcDetailsDialog.pcDetails
-        imageSrc: "qrc:/res/baseline-help_outline-24px.svg"
-        standardButtons: Dialog.Ok
-    }
+    ScrollBar.vertical: ScrollBar {
+        parent: pcGrid.parent
+        anchors {
+            top: pcGrid.top
+            left: pcGrid.right
+            bottom: pcGrid.bottom

-    ScrollBar.vertical: ScrollBar {}
+            leftMargin: -10
+        }
+    }
 }
@@ -1,80 +0,0 @@
-import QtQuick 2.0
-import QtQuick.Controls 2.2
-
-import ComputerManager 1.0
-import Session 1.0
-
-Item {
-    property string appName
-    property var quitRunningAppFn
-    property Session nextSession : null
-    property string nextAppName : ""
-
-    property string stageText : qsTr("Quitting %1...").arg(appName)
-
-    function quitAppCompleted(error)
-    {
-        // Display a failed dialog if we got an error
-        if (error !== undefined) {
-            errorDialog.text = error
-            errorDialog.open()
-            console.error(error)
-        }
-
-        // If we're supposed to launch another game after this, do so now
-        if (error === undefined && nextSession !== null) {
-            var component = Qt.createComponent("StreamSegue.qml")
-            var segue = component.createObject(stackView, {"appName": nextAppName, "session": nextSession})
-            stackView.replace(segue)
-        }
-        else {
-            // Exit this view
-            stackView.pop()
-        }
-    }
-
-    StackView.onActivated: {
-        // Hide the toolbar before we start loading
-        toolBar.visible = false
-
-        // Connect the quit completion signal
-        ComputerManager.quitAppCompleted.connect(quitAppCompleted)
-
-        // Start the quit operation if requested
-        if (quitRunningAppFn) {
-            quitRunningAppFn()
-        }
-    }
-
-    StackView.onDeactivating: {
-        // Show the toolbar again
-        toolBar.visible = true
-
-        // Disconnect the signal
-        ComputerManager.quitAppCompleted.disconnect(quitAppCompleted)
-    }
-
-    Row {
-        anchors.centerIn: parent
-        spacing: 5
-
-        BusyIndicator {
-            id: stageSpinner
-            running: visible
-        }
-
-        Label {
-            id: stageLabel
-            height: stageSpinner.height
-            text: stageText
-            font.pointSize: 20
-            verticalAlignment: Text.AlignVCenter
-
-            wrapMode: Text.Wrap
-        }
-    }
-
-    ErrorMessageDialog {
-        id: errorDialog
-    }
-}
@@ -1,33 +1,31 @@
 import QtQuick 2.0
 import QtQuick.Controls 2.2
-import QtQuick.Window 2.2
+import QtQuick.Dialogs 1.3

-import SdlGamepadKeyNavigation 1.0
 import Session 1.0
-import SystemProperties 1.0

 Item {
    property Session session
-    property string appName
-    property string stageText : isResume ? qsTr("Resuming %1...").arg(appName) :
-                                           qsTr("Starting %1...").arg(appName)
-    property bool isResume : false
-    property bool quitAfter : false
+    property string appname
+    property string stageText : "Starting " + appname + "..."
+
+    anchors.fill: parent
+
+    // The StackView will trigger a visibility change when
+    // we're pushed onto it, causing our onVisibleChanged
+    // routine to run, but only if we start as invisible
+    visible: false

    function stageStarting(stage)
    {
        // Update the spinner text
-        stageText = qsTr("Starting %1...").arg(stage)
+        stageText = "Starting " + stage + "..."
    }

-    function stageFailed(stage, errorCode, failingPorts)
+    function stageFailed(stage, errorCode)
    {
-        // Display the error dialog after Session::exec() returns
-        streamSegueErrorDialog.text = qsTr("Starting %1 failed: Error %2").arg(stage).arg(errorCode)
-
-        if (failingPorts) {
-            streamSegueErrorDialog.text += "\n\n" + qsTr("Check your firewall and port forwarding rules for port(s): %1").arg(failingPorts)
-        }
+        errorDialog.text = "Starting " + stage + " failed: Error " + errorCode
+        errorDialog.open()
    }

    function connectionStarted()
@@ -36,7 +34,6 @@ Item {
        // see them briefly when we pop off the StackView
        stageSpinner.visible = false
        stageLabel.visible = false
-        hintText.visible = false

        // Hide the window now that streaming has begun
        window.visible = false
@@ -44,170 +41,48 @@ Item {

    function displayLaunchError(text)
    {
-        // Display the error dialog after Session::exec() returns
-        streamSegueErrorDialog.text = text
-        console.error(text)
+        errorDialog.text = text
+        errorDialog.open()
    }

-    function quitStarting()
+    function displayLaunchWarning(text)
    {
-        // Avoid the push transition animation
-        var component = Qt.createComponent("QuitSegue.qml")
-        stackView.replace(stackView.currentItem, component.createObject(stackView, {"appName": appName}), StackView.Immediate)
-
-        // Show the Qt window again to show quit segue
-        window.visible = true
+        // TODO: toast
    }

-    function sessionFinished(portTestResult)
-    {
-        if (portTestResult !== 0 && portTestResult !== -1 && streamSegueErrorDialog.text) {
-            streamSegueErrorDialog.text += "\n\n" + qsTr("This PC's Internet connection is blocking Moonlight. Streaming over the Internet may not work while connected to this network.")
-        }
+    onVisibleChanged: {
+        if (visible) {
+            // Hide the toolbar before we start loading
+            toolBar.visible = false

-        // Re-enable GUI gamepad usage now
-        SdlGamepadKeyNavigation.enable()
+            // Hook up our signals
+            session.stageStarting.connect(stageStarting)
+            session.stageFailed.connect(stageFailed)
+            session.connectionStarted.connect(connectionStarted)
+            session.displayLaunchError.connect(displayLaunchError)
+            session.displayLaunchWarning.connect(displayLaunchWarning)

-        // Pop the StreamSegue off the stack if this is a GUI-based app launch
-        if (!quitAfter) {
-            stackView.pop()
-        }
+            // Run the streaming session to completion
+            session.exec()

-        if (quitAfter && !streamSegueErrorDialog.text) {
-            // If this was a CLI launch without errors, exit now
-            Qt.quit()
-        }
-        else {
            // Show the Qt window again after streaming
            window.visible = true

-            // Display any launch errors. We do this after
-            // the Qt UI is visible again to prevent losing
-            // focus on the dialog which would impact gamepad
-            // users.
-            if (streamSegueErrorDialog.text) {
-                streamSegueErrorDialog.quitAfter = quitAfter
-                streamSegueErrorDialog.open()
-            }
+            // Exit this view
+            stackView.pop()
        }
-    }
-
-    function sessionReadyForDeletion()
-    {
-        // Garbage collect the Session object since it's pretty heavyweight
-        // and keeps other libraries (like SDL_TTF) around until it is deleted.
-        session = null
-        gc()
-    }
-
-    StackView.onDeactivating: {
-        // Show the toolbar again when popped off the stack
-        toolBar.visible = true
-
-        // Re-enable GUI gamepad usage now
-        SdlGamepadKeyNavigation.enable()
-    }
-
-    StackView.onActivated: {
-        // Hide the toolbar before we start loading
-        toolBar.visible = false
-
-        // Hook up our signals
-        session.stageStarting.connect(stageStarting)
-        session.stageFailed.connect(stageFailed)
-        session.connectionStarted.connect(connectionStarted)
-        session.displayLaunchError.connect(displayLaunchError)
-        session.quitStarting.connect(quitStarting)
-        session.sessionFinished.connect(sessionFinished)
-        session.readyForDeletion.connect(sessionReadyForDeletion)
-
-        // Ensure the SystemProperties async thread is finished,
-        // since it may currently be using the SDL video subsystem
-        SystemProperties.waitForAsyncLoad()
-
-        // Kick off the stream
-        streamLoader.active = true
-    }
-
-    Timer {
-        id: startSessionTimer
-        onTriggered: {
-            // Garbage collect QML stuff before we start streaming,
-            // since we'll probably be streaming for a while and we
-            // won't be able to GC during the stream.
-            gc()
-
-            // Run the streaming session to completion
-            session.start()
+        else {
+            // Show the toolbar again when we become hidden
+            toolBar.visible = true
        }
    }

-    Loader {
-        id: streamLoader
-        active: false
-        asynchronous: true
-
-        onLoaded: {
-            // Set the hint text. We do this here rather than
-            // in the hintText control itself to synchronize
-            // with Session.exec() which requires no concurrent
-            // gamepad usage.
-            hintText.text = qsTr("Tip:") + " " + qsTr("Press %1 to disconnect your session").arg(SdlGamepadKeyNavigation.getConnectedGamepads() > 0 ?
-                                                  qsTr("Start+Select+L1+R1") : qsTr("Ctrl+Alt+Shift+Q"))
-
-            // Stop GUI gamepad usage now
-            SdlGamepadKeyNavigation.disable()
-
-            // Initialize the session and probe for host/client capabilities
-            if (!session.initialize(window)) {
-                sessionFinished(0);
-                sessionReadyForDeletion();
-                return;
-            }
-
-            // This spinner is shown only after session.initialize() has completed
-            // to prevent active animations from running during decoder probing,
-            // which causes re-entrant event loop livelocks with libdecor-gtk.
-            stageSpinner.visible = true
-
-            // Don't wait unless we have toasts to display
-            startSessionTimer.interval = 0
-
-            // Display the toasts together in a vertical centered arrangement
-            var yOffset = 0
-            for (var i = 0; i < session.launchWarnings.length; i++) {
-                var text = session.launchWarnings[i]
-                console.warn(text)
-
-                // Show the tooltip for 3 seconds
-                var toast = Qt.createQmlObject('import QtQuick.Controls 2.2; ToolTip {}', parent, '')
-                toast.timeout = 3000
-                toast.text = text
-                toast.y += yOffset
-                toast.visible = true
-
-                // Offset the next toast below the previous one
-                yOffset = toast.y + toast.padding + toast.height
-
-                // Allow an extra 500 ms for the tooltip's fade-out animation to finish
-                startSessionTimer.interval = toast.timeout + 500;
-            }
-
-            // Start the timer to wait for toasts (or start the session immediately)
-            startSessionTimer.start()
-        }
-
-        sourceComponent: Item {}
-    }
-
    Row {
        anchors.centerIn: parent
        spacing: 5

        BusyIndicator {
            id: stageSpinner
-            running: visible
-            visible: false
        }

        Label {
@@ -218,17 +93,14 @@ Item {
            verticalAlignment: Text.AlignVCenter

            wrapMode: Text.Wrap
+            color: "white"
        }
    }

-    Label {
-        id: hintText
-        anchors.bottom: parent.bottom
-        anchors.bottomMargin: 50
-        anchors.horizontalCenter: parent.horizontalCenter
-        font.pointSize: 18
-        verticalAlignment: Text.AlignVCenter
-
-        wrapMode: Text.Wrap
+    MessageDialog {
+        id: errorDialog
+        modality:Qt.WindowModal
+        icon: StandardIcon.Critical
+        standardButtons: StandardButton.Ok
    }
 }
@@ -7,7 +7,7 @@ AppModel::AppModel(QObject *parent)
            this, &AppModel::handleBoxArtLoaded);
 }

-void AppModel::initialize(ComputerManager* computerManager, int computerIndex, bool showHiddenGames)
+void AppModel::initialize(ComputerManager* computerManager, int computerIndex)
 {
    m_ComputerManager = computerManager;
    connect(m_ComputerManager, &ComputerManager::computerStateChanged,
@@ -15,49 +15,18 @@ void AppModel::initialize(ComputerManager* computerManager, int computerIndex, b

    Q_ASSERT(computerIndex < m_ComputerManager->getComputers().count());
    m_Computer = m_ComputerManager->getComputers().at(computerIndex);
+    m_Apps = m_Computer->appList;
    m_CurrentGameId = m_Computer->currentGameId;
-    m_ShowHiddenGames = showHiddenGames;
-
-    updateAppList(m_Computer->appList);
-}
-
-int AppModel::getRunningAppId()
-{
-    return m_CurrentGameId;
-}
-
-QString AppModel::getRunningAppName()
-{
-    if (m_CurrentGameId != 0) {
-        for (int i = 0; i < m_AllApps.count(); i++) {
-            if (m_AllApps[i].id == m_CurrentGameId) {
-                return m_AllApps[i].name;
-            }
-        }
-    }
-
-    return nullptr;
 }

 Session* AppModel::createSessionForApp(int appIndex)
 {
-    Q_ASSERT(appIndex < m_VisibleApps.count());
-    NvApp app = m_VisibleApps.at(appIndex);
+    Q_ASSERT(appIndex < m_Apps.count());
+    NvApp app = m_Apps.at(appIndex);

    return new Session(m_Computer, app);
 }

-int AppModel::getDirectLaunchAppIndex()
-{
-    for (int i = 0; i < m_VisibleApps.count(); i++) {
-        if (m_VisibleApps[i].directLaunch) {
-            return i;
-        }
-    }
-
-    return -1;
-}
-
 int AppModel::rowCount(const QModelIndex &parent) const
 {
    // For list models only the root node (an invalid parent) should return the list's size. For all
@@ -65,7 +34,7 @@ int AppModel::rowCount(const QModelIndex &parent) const
    if (parent.isValid())
        return 0;

-    return m_VisibleApps.count();
+    return m_Apps.count();
 }

 QVariant AppModel::data(const QModelIndex &index, int role) const
@@ -73,8 +42,8 @@ QVariant AppModel::data(const QModelIndex &index, int role) const
    if (!index.isValid())
        return QVariant();

-    Q_ASSERT(index.row() < m_VisibleApps.count());
-    NvApp app = m_VisibleApps.at(index.row());
+    Q_ASSERT(index.row() < m_Apps.count());
+    NvApp app = m_Apps.at(index.row());

    switch (role)
    {
@@ -85,14 +54,6 @@ QVariant AppModel::data(const QModelIndex &index, int role) const
    case BoxArtRole:
        // FIXME: const-correctness
        return const_cast<BoxArtManager&>(m_BoxArtManager).loadBoxArt(m_Computer, app);
-    case HiddenRole:
-        return app.hidden;
-    case AppIdRole:
-        return app.id;
-    case DirectLaunchRole:
-        return app.directLaunch;
-    case AppCollectorGameRole:
-        return app.isAppCollectorGame;
    default:
        return QVariant();
    }
@@ -105,151 +66,10 @@ QHash<int, QByteArray> AppModel::roleNames() const
    names[NameRole] = "name";
    names[RunningRole] = "running";
    names[BoxArtRole] = "boxart";
-    names[HiddenRole] = "hidden";
-    names[AppIdRole] = "appid";
-    names[DirectLaunchRole] = "directLaunch";
-    names[AppCollectorGameRole] = "appCollectorGame";

    return names;
 }

-void AppModel::quitRunningApp()
-{
-    m_ComputerManager->quitRunningApp(m_Computer);
-}
-
-bool AppModel::isAppCurrentlyVisible(const NvApp& app)
-{
-    for (const NvApp& visibleApp : std::as_const(m_VisibleApps)) {
-        if (app.id == visibleApp.id) {
-            return true;
-        }
-    }
-
-    return false;
-}
-
-QVector<NvApp> AppModel::getVisibleApps(const QVector<NvApp>& appList)
-{
-    QVector<NvApp> visibleApps;
-
-    for (const NvApp& app : appList) {
-        // Don't immediately hide games that were previously visible. This
-        // allows users to easily uncheck the "Hide App" checkbox if they
-        // check it by mistake.
-        if (m_ShowHiddenGames || !app.hidden || isAppCurrentlyVisible(app)) {
-            visibleApps.append(app);
-        }
-    }
-
-    return visibleApps;
-}
-
-void AppModel::updateAppList(QVector<NvApp> newList)
-{
-    m_AllApps = newList;
-
-    QVector<NvApp> newVisibleList = getVisibleApps(newList);
-
-    // Process removals and updates first
-    for (int i = 0; i < m_VisibleApps.count(); i++) {
-        const NvApp& existingApp = m_VisibleApps.at(i);
-
-        bool found = false;
-        for (const NvApp& newApp : std::as_const(newVisibleList)) {
-            if (existingApp.id == newApp.id) {
-                // If the data changed, update it in our list
-                if (existingApp != newApp) {
-                    m_VisibleApps.replace(i, newApp);
-                    emit dataChanged(createIndex(i, 0), createIndex(i, 0));
-                }
-
-                found = true;
-                break;
-            }
-        }
-
-        if (!found) {
-            beginRemoveRows(QModelIndex(), i, i);
-            m_VisibleApps.removeAt(i);
-            endRemoveRows();
-            i--;
-        }
-    }
-
-    // Process additions now
-    for (const NvApp& newApp : std::as_const(newVisibleList)) {
-        int insertionIndex = m_VisibleApps.size();
-        bool found = false;
-
-        for (int i = 0; i < m_VisibleApps.count(); i++) {
-            const NvApp& existingApp = m_VisibleApps.at(i);
-
-            if (existingApp.id == newApp.id) {
-                found = true;
-                break;
-            }
-            else if (existingApp.name.toLower() > newApp.name.toLower()) {
-                insertionIndex = i;
-                break;
-            }
-        }
-
-        if (!found) {
-            beginInsertRows(QModelIndex(), insertionIndex, insertionIndex);
-            m_VisibleApps.insert(insertionIndex, newApp);
-            endInsertRows();
-        }
-    }
-
-    Q_ASSERT(newVisibleList == m_VisibleApps);
-}
-
-void AppModel::setAppHidden(int appIndex, bool hidden)
-{
-    Q_ASSERT(appIndex < m_VisibleApps.count());
-    int appId = m_VisibleApps.at(appIndex).id;
-
-    {
-        QWriteLocker lock(&m_Computer->lock);
-
-        for (NvApp& app : m_Computer->appList) {
-            if (app.id == appId) {
-                app.hidden = hidden;
-                break;
-            }
-        }
-    }
-
-    m_ComputerManager->clientSideAttributeUpdated(m_Computer);
-}
-
-void AppModel::setAppDirectLaunch(int appIndex, bool directLaunch)
-{
-    Q_ASSERT(appIndex < m_VisibleApps.count());
-    int appId = m_VisibleApps.at(appIndex).id;
-
-    {
-        QWriteLocker lock(&m_Computer->lock);
-
-        for (NvApp& app : m_Computer->appList) {
-            if (directLaunch) {
-                // We must clear direct launch from all other apps
-                // to set it on the new app.
-                app.directLaunch = app.id == appId;
-            }
-            else if (app.id == appId) {
-                // If we're clearing direct launch, we're done once we
-                // find our matching app ID.
-                app.directLaunch = false;
-                break;
-            }
-        }
-    }
-
-    m_ComputerManager->clientSideAttributeUpdated(m_Computer);
-}
-
 void AppModel::handleComputerStateChanged(NvComputer* computer)
 {
    // Ignore updates for computers that aren't ours
@@ -257,26 +77,23 @@ void AppModel::handleComputerStateChanged(NvComputer* computer)
        return;
    }

-    // If the computer has gone offline or we've been unpaired,
-    // signal the UI so we can go back to the PC view.
-    if (m_Computer->state == NvComputer::CS_OFFLINE ||
-            m_Computer->pairState == NvComputer::PS_NOT_PAIRED) {
-        emit computerLost();
-        return;
-    }
-
    // First, process additions/removals from the app list. This
    // is required because the new game may now be running, so
    // we can't check that first.
-    if (computer->appList != m_AllApps) {
-        updateAppList(computer->appList);
+    if (computer->appList != m_Apps) {
+        // Just reset the whole thing if the list changes
+        beginResetModel();
+        m_Apps = computer->appList;
+        m_CurrentGameId = computer->currentGameId;
+        endResetModel();
+        return;
    }

    // Finally, process changes to the active app
    if (computer->currentGameId != m_CurrentGameId) {
        // First, invalidate the running state of newly running game
-        for (int i = 0; i < m_VisibleApps.count(); i++) {
-            if (m_VisibleApps[i].id == computer->currentGameId) {
+        for (int i = 0; i < m_Apps.count(); i++) {
+            if (m_Apps[i].id == computer->currentGameId) {
                emit dataChanged(createIndex(i, 0),
                                 createIndex(i, 0),
                                 QVector<int>() << RunningRole);
@@ -286,8 +103,8 @@ void AppModel::handleComputerStateChanged(NvComputer* computer)

        // Next, invalidate the running state of the old game (if it exists)
        if (m_CurrentGameId != 0) {
-            for (int i = 0; i < m_VisibleApps.count(); i++) {
-                if (m_VisibleApps[i].id == m_CurrentGameId) {
+            for (int i = 0; i < m_Apps.count(); i++) {
+                if (m_Apps[i].id == m_CurrentGameId) {
                    emit dataChanged(createIndex(i, 0),
                                     createIndex(i, 0),
                                     QVector<int>() << RunningRole);
@@ -305,16 +122,11 @@ void AppModel::handleBoxArtLoaded(NvComputer* computer, NvApp app, QUrl /* image
 {
    Q_ASSERT(computer == m_Computer);

-    int index = m_VisibleApps.indexOf(app);
+    int index = m_Apps.indexOf(app);
+    Q_ASSERT(index >= 0);

-    // Make sure we're not delivering a callback to an app that's already been removed
-    if (index >= 0) {
-        // Let our view know the box art data has changed for this app
-        emit dataChanged(createIndex(index, 0),
-                         createIndex(index, 0),
-                         QVector<int>() << BoxArtRole);
-    }
-    else {
-        qWarning() << "App not found for box art callback:" << app.name;
-    }
+    // Let our view know the box art data has changed for this app
+    emit dataChanged(createIndex(index, 0),
+                     createIndex(index, 0),
+                     QVector<int>() << BoxArtRole);
 }
@@ -2,7 +2,7 @@

 #include "backend/boxartmanager.h"
 #include "backend/computermanager.h"
-#include "streaming/session.h"
+#include "streaming/session.hpp"

 #include <QAbstractListModel>

@@ -14,33 +14,17 @@ class AppModel : public QAbstractListModel
    {
        NameRole = Qt::UserRole,
        RunningRole,
-        BoxArtRole,
-        HiddenRole,
-        AppIdRole,
-        DirectLaunchRole,
-        AppCollectorGameRole,
+        BoxArtRole
    };

 public:
    explicit AppModel(QObject *parent = nullptr);

    // Must be called before any QAbstractListModel functions
-    Q_INVOKABLE void initialize(ComputerManager* computerManager, int computerIndex, bool showHiddenGames);
+    Q_INVOKABLE void initialize(ComputerManager* computerManager, int computerIndex);

    Q_INVOKABLE Session* createSessionForApp(int appIndex);

-    Q_INVOKABLE int getDirectLaunchAppIndex();
-
-    Q_INVOKABLE int getRunningAppId();
-
-    Q_INVOKABLE QString getRunningAppName();
-
-    Q_INVOKABLE void quitRunningApp();
-
-    Q_INVOKABLE void setAppHidden(int appIndex, bool hidden);
-
-    Q_INVOKABLE void setAppDirectLaunch(int appIndex, bool directLaunch);
-
    QVariant data(const QModelIndex &index, int role) const override;

    int rowCount(const QModelIndex &parent) const override;
@@ -52,20 +36,10 @@ private slots:

    void handleBoxArtLoaded(NvComputer* computer, NvApp app, QUrl image);

-signals:
-    void computerLost();
-
 private:
-    void updateAppList(QVector<NvApp> newList);
-
-    QVector<NvApp> getVisibleApps(const QVector<NvApp>& appList);
-
-    bool isAppCurrentlyVisible(const NvApp& app);
-
    NvComputer* m_Computer;
    BoxArtManager m_BoxArtManager;
    ComputerManager* m_ComputerManager;
-    QVector<NvApp> m_VisibleApps, m_AllApps;
+    QVector<NvApp> m_Apps;
    int m_CurrentGameId;
-    bool m_ShowHiddenGames;
 };
@@ -1,7 +1,5 @@
 #include "computermodel.h"

-#include <QThreadPool>
-
 ComputerModel::ComputerModel(QObject* object)
    : QAbstractListModel(object) {}

@@ -22,6 +20,18 @@ QVariant ComputerModel::data(const QModelIndex& index, int role) const
        return QVariant();
    }

+    if (index.row() == m_Computers.count()) {
+        // We insert a synthetic item at the end for the Add PC option
+        switch (role) {
+        case NameRole:
+            return "Add PC";
+        case AddPcRole:
+            return true;
+        default:
+            return QVariant();
+        }
+    }
+
    Q_ASSERT(index.row() < m_Computers.count());

    NvComputer* computer = m_Computers[index.row()];
@@ -36,52 +46,8 @@ QVariant ComputerModel::data(const QModelIndex& index, int role) const
        return computer->pairState == NvComputer::PS_PAIRED;
    case BusyRole:
        return computer->currentGameId != 0;
-    case WakeableRole:
-        return !computer->macAddress.isEmpty();
-    case StatusUnknownRole:
-        return computer->state == NvComputer::CS_UNKNOWN;
-    case ServerSupportedRole:
-        return computer->isSupportedServerVersion;
-    case DetailsRole: {
-        QString state, pairState;
-
-        switch (computer->state) {
-        case NvComputer::CS_ONLINE:
-            state = tr("Online");
-            break;
-        case NvComputer::CS_OFFLINE:
-            state = tr("Offline");
-            break;
-        default:
-            state = tr("Unknown");
-            break;
-        }
-
-        switch (computer->pairState) {
-        case NvComputer::PS_PAIRED:
-            pairState = tr("Paired");
-            break;
-        case NvComputer::PS_NOT_PAIRED:
-            pairState = tr("Unpaired");
-            break;
-        default:
-            pairState = tr("Unknown");
-            break;
-        }
-
-        return tr("Name: %1").arg(computer->name) + '\n' +
-               tr("Status: %1").arg(state) + '\n' +
-               tr("Active Address: %1").arg(computer->activeAddress.toString()) + '\n' +
-               tr("UUID: %1").arg(computer->uuid) + '\n' +
-               tr("Local Address: %1").arg(computer->localAddress.toString()) + '\n' +
-               tr("Remote Address: %1").arg(computer->remoteAddress.toString()) + '\n' +
-               tr("IPv6 Address: %1").arg(computer->ipv6Address.toString()) + '\n' +
-               tr("Manual Address: %1").arg(computer->manualAddress.toString()) + '\n' +
-               tr("MAC Address: %1").arg(computer->macAddress.isEmpty() ? tr("Unknown") : QString(computer->macAddress.toHex(':'))) + '\n' +
-               tr("Pair State: %1").arg(pairState) + '\n' +
-               tr("Running Game ID: %1").arg(computer->state == NvComputer::CS_ONLINE ? QString::number(computer->currentGameId) : tr("Unknown")) + '\n' +
-               tr("HTTPS Port: %1").arg(computer->state == NvComputer::CS_ONLINE ? QString::number(computer->activeHttpsPort) : tr("Unknown"));
-    }
+    case AddPcRole:
+        return false;
    default:
        return QVariant();
    }
@@ -95,7 +61,8 @@ int ComputerModel::rowCount(const QModelIndex& parent) const
        return 0;
    }

-    return m_Computers.count();
+    // Add PC placeholder counts as 1
+    return m_Computers.count() + 1;
 }

 QHash<int, QByteArray> ComputerModel::roleNames() const
@@ -106,10 +73,7 @@ QHash<int, QByteArray> ComputerModel::roleNames() const
    names[OnlineRole] = "online";
    names[PairedRole] = "paired";
    names[BusyRole] = "busy";
-    names[WakeableRole] = "wakeable";
-    names[StatusUnknownRole] = "statusUnknown";
-    names[ServerSupportedRole] = "serverSupported";
-    names[DetailsRole] = "details";
+    names[AddPcRole] = "addPc";

    return names;
 }
@@ -149,68 +113,11 @@ void ComputerModel::deleteComputer(int computerIndex)
    endRemoveRows();
 }

-class DeferredWakeHostTask : public QRunnable
-{
-public:
-    DeferredWakeHostTask(NvComputer* computer)
-        : m_Computer(computer) {}
-
-    void run()
-    {
-        m_Computer->wake();
-    }
-
-private:
-    NvComputer* m_Computer;
-};
-
-void ComputerModel::wakeComputer(int computerIndex)
+bool ComputerModel::wakeComputer(int computerIndex)
 {
    Q_ASSERT(computerIndex < m_Computers.count());

-    DeferredWakeHostTask* wakeTask = new DeferredWakeHostTask(m_Computers[computerIndex]);
-    QThreadPool::globalInstance()->start(wakeTask);
-}
-
-void ComputerModel::renameComputer(int computerIndex, QString name)
-{
-    Q_ASSERT(computerIndex < m_Computers.count());
-
-    m_ComputerManager->renameHost(m_Computers[computerIndex], name);
-}
-
-QString ComputerModel::generatePinString()
-{
-    return m_ComputerManager->generatePinString();
-}
-
-class DeferredTestConnectionTask : public QObject, public QRunnable
-{
-    Q_OBJECT
-public:
-    void run()
-    {
-        unsigned int portTestResult = LiTestClientConnectivity("qt.conntest.moonlight-stream.org", 443, ML_PORT_FLAG_ALL);
-        if (portTestResult == ML_TEST_RESULT_INCONCLUSIVE) {
-            emit connectionTestCompleted(-1, QString());
-        }
-        else {
-            char blockedPorts[512];
-            LiStringifyPortFlags(portTestResult, "\n", blockedPorts, sizeof(blockedPorts));
-            emit connectionTestCompleted(portTestResult, QString(blockedPorts));
-        }
-    }
-
-signals:
-    void connectionTestCompleted(int result, QString blockedPorts);
-};
-
-void ComputerModel::testConnectionForComputer(int)
-{
-    DeferredTestConnectionTask* testConnectionTask = new DeferredTestConnectionTask();
-    QObject::connect(testConnectionTask, &DeferredTestConnectionTask::connectionTestCompleted,
-                     this, &ComputerModel::connectionTestCompleted);
-    QThreadPool::globalInstance()->start(testConnectionTask);
+    return m_Computers[computerIndex]->wake();
 }

 void ComputerModel::pairComputer(int computerIndex, QString pin)
@@ -222,24 +129,24 @@ void ComputerModel::pairComputer(int computerIndex, QString pin)

 void ComputerModel::handlePairingCompleted(NvComputer*, QString error)
 {
-    emit pairingCompleted(error.isEmpty() ? QVariant() : error);
+    emit pairingCompleted(error.isNull() ? QVariant() : error);
 }

 void ComputerModel::handleComputerStateChanged(NvComputer* computer)
 {
-    QVector<NvComputer*> newComputerList = m_ComputerManager->getComputers();
-
-    // Reset the model if the structural layout of the list has changed
-    if (m_Computers != newComputerList) {
-        beginResetModel();
-        m_Computers = newComputerList;
-        endResetModel();
+    // If this is an existing computer, we can report the data changed
+    int index = m_Computers.indexOf(computer);
+    if (index >= 0) {
+        // Let the view know that this specific computer changed
+        emit dataChanged(createIndex(index, 0), createIndex(index, 0));
    }
    else {
-        // Let the view know that this specific computer changed
-        int index = m_Computers.indexOf(computer);
-        emit dataChanged(createIndex(index, 0), createIndex(index, 0));
+        // This is a new PC which may be inserted at an arbitrary point
+        // in our computer list (since it comes from CM's QMap). Reload
+        // the whole model state to ensure it stays consistent.
+        beginResetModel();
+        m_Computers = m_ComputerManager->getComputers();
+        endResetModel();
    }
 }

-#include "computermodel.moc"
@@ -1,5 +1,5 @@
 #include "backend/computermanager.h"
-#include "streaming/session.h"
+#include "streaming/session.hpp"

 #include <QAbstractListModel>

@@ -13,10 +13,7 @@ class ComputerModel : public QAbstractListModel
        OnlineRole,
        PairedRole,
        BusyRole,
-        WakeableRole,
-        StatusUnknownRole,
-        ServerSupportedRole,
-        DetailsRole
+        AddPcRole
    };

 public:
@@ -33,21 +30,14 @@ public:

    Q_INVOKABLE void deleteComputer(int computerIndex);

-    Q_INVOKABLE QString generatePinString();
-
    Q_INVOKABLE void pairComputer(int computerIndex, QString pin);

-    Q_INVOKABLE void testConnectionForComputer(int computerIndex);
-
-    Q_INVOKABLE void wakeComputer(int computerIndex);
-
-    Q_INVOKABLE void renameComputer(int computerIndex, QString name);
+    Q_INVOKABLE bool wakeComputer(int computerIndex);

    Q_INVOKABLE Session* createSessionForCurrentGame(int computerIndex);

 signals:
    void pairingCompleted(QVariant error);
-    void connectionTestCompleted(int result, QString blockedPorts);

 private slots:
    void handleComputerStateChanged(NvComputer* computer);
@@ -1,226 +1,28 @@
 import QtQuick 2.9
 import QtQuick.Controls 2.2
 import QtQuick.Layouts 1.3
-import QtQuick.Window 2.2
-import QtQuick.Controls.Material 2.2

-import ComputerManager 1.0
-import AutoUpdateChecker 1.0
-import StreamingPreferences 1.0
-import SystemProperties 1.0
-import SdlGamepadKeyNavigation 1.0
+import QtQuick.Controls.Material 2.1

 ApplicationWindow {
-    property bool pollingActive: false
-
-    // Set by SettingsView to force the back operation to pop all
-    // pages except the initial view. This is required when doing
-    // a retranslate() because AppView breaks for some reason.
-    property bool clearOnBack: false
-
    id: window
+    visible: true
    width: 1280
    height: 600

-    // This function runs prior to creation of the initial StackView item
-    function doEarlyInit() {
-        // Override the background color to Material 2 colors for Qt 6.5+
-        // in order to improve contrast between GFE's placeholder box art
-        // and the background of the app grid.
-        if (SystemProperties.usesMaterial3Theme) {
-            Material.background = "#303030"
-        }
-
-        SdlGamepadKeyNavigation.enable()
-    }
-
-    Component.onCompleted: {
-        // Show the window according to the user's preferences
-        if (SystemProperties.hasDesktopEnvironment) {
-            if (StreamingPreferences.uiDisplayMode == StreamingPreferences.UI_MAXIMIZED) {
-                window.showMaximized()
-            }
-            else if (StreamingPreferences.uiDisplayMode == StreamingPreferences.UI_FULLSCREEN) {
-                window.showFullScreen()
-            }
-            else {
-                window.show()
-            }
-        } else {
-            window.showFullScreen()
-        }
-
-        // Display any modal dialogs for configuration warnings
-        if (runConfigChecks) {
-            if (SystemProperties.isWow64) {
-                wow64Dialog.open()
-            }
-
-            // Hardware acceleration and unmapped gamepads are checked asynchronously
-            SystemProperties.hasHardwareAccelerationChanged.connect(hasHardwareAccelerationChanged)
-            SystemProperties.unmappedGamepadsChanged.connect(hasUnmappedGamepadsChanged)
-            SystemProperties.startAsyncLoad()
-        }
-    }
-
-    function hasHardwareAccelerationChanged() {
-        if (!SystemProperties.hasHardwareAcceleration && StreamingPreferences.videoDecoderSelection !== StreamingPreferences.VDS_FORCE_SOFTWARE) {
-            if (SystemProperties.isRunningXWayland) {
-                xWaylandDialog.open()
-            }
-            else {
-                noHwDecoderDialog.open()
-            }
-        }
-    }
-
-    function hasUnmappedGamepadsChanged() {
-        if (SystemProperties.unmappedGamepads) {
-            unmappedGamepadDialog.unmappedGamepads = SystemProperties.unmappedGamepads
-            unmappedGamepadDialog.open()
-        }
-    }
-
-    // It would be better to use TextMetrics here, but it always lays out
-    // the text slightly more compactly than real Text does in ToolTip,
-    // causing unexpected line breaks to be inserted
-    Text {
-        id: tooltipTextLayoutHelper
-        visible: false
-        font: ToolTip.toolTip.font
-        text: ToolTip.toolTip.text
-    }
-
-    // This configures the maximum width of the singleton attached QML ToolTip. If left unconstrained,
-    // it will never insert a line break and just extend on forever.
-    ToolTip.toolTip.contentWidth: Math.min(tooltipTextLayoutHelper.width, 400)
-
-    function goBack() {
-        if (clearOnBack) {
-            // Pop all items except the first one
-            stackView.pop(null)
-            clearOnBack = false
-        }
-        else {
-            stackView.pop()
-        }
-    }
+    Material.theme: Material.Dark
+    Material.accent: Material.Purple

    StackView {
        id: stackView
+        initialItem: "PcView.qml"
        anchors.fill: parent
-        focus: true
-
-        Component.onCompleted: {
-            // Perform our early initialization before constructing
-            // the initial view and pushing it to the StackView
-            doEarlyInit()
-            push(initialView)
-        }
-
-        onCurrentItemChanged: {
-            // Ensure focus travels to the next view when going back
-            if (currentItem) {
-                currentItem.forceActiveFocus()
-            }
-        }
-
-        Keys.onEscapePressed: {
-            if (depth > 1) {
-                goBack()
-            }
-            else {
-                quitConfirmationDialog.open()
-            }
-        }
-
-        Keys.onBackPressed: {
-            if (depth > 1) {
-                goBack()
-            }
-            else {
-                quitConfirmationDialog.open()
-            }
-        }
-
-        Keys.onMenuPressed: {
-            settingsButton.clicked()
-        }
-
-        // This is a keypress we've reserved for letting the
-        // SdlGamepadKeyNavigation object tell us to show settings
-        // when Menu is consumed by a focused control.
-        Keys.onHangupPressed: {
-            settingsButton.clicked()
-        }
    }

-    // This timer keeps us polling for 5 minutes of inactivity
-    // to allow the user to work with Moonlight on a second display
-    // while dealing with configuration issues. This will ensure
-    // machines come online even if the input focus isn't on Moonlight.
-    Timer {
-        id: inactivityTimer
-        interval: 5 * 60000
-        onTriggered: {
-            if (!active && pollingActive) {
-                ComputerManager.stopPollingAsync()
-                pollingActive = false
-            }
-        }
-    }
-
-    onVisibleChanged: {
-        // When we become invisible while streaming is going on,
-        // stop polling immediately.
-        if (!visible) {
-            inactivityTimer.stop()
-
-            if (pollingActive) {
-                ComputerManager.stopPollingAsync()
-                pollingActive = false
-            }
-        }
-        else if (active) {
-            // When we become visible and active again, start polling
-            inactivityTimer.stop()
-
-            // Restart polling if it was stopped
-            if (!pollingActive) {
-                ComputerManager.startPolling()
-                pollingActive = true
-            }
-        }
-
-        // Poll for gamepad input only when the window is in focus
-        SdlGamepadKeyNavigation.notifyWindowFocus(visible && active)
-    }
-
-    onActiveChanged: {
-        if (active) {
-            // Stop the inactivity timer
-            inactivityTimer.stop()
-
-            // Restart polling if it was stopped
-            if (!pollingActive) {
-                ComputerManager.startPolling()
-                pollingActive = true
-            }
-        }
-        else {
-            // Start the inactivity timer to stop polling
-            // if focus does not return within a few minutes.
-            inactivityTimer.restart()
-        }
-
-        // Poll for gamepad input only when the window is in focus
-        SdlGamepadKeyNavigation.notifyWindowFocus(visible && active)
-    }
-
-    function navigateTo(url, objectType)
+    function navigateTo(url, objectName)
    {
        var existingItem = stackView.find(function(item, index) {
-            return item instanceof objectType
+            return item.objectName === objectName
        })

        if (existingItem !== null) {
@@ -235,321 +37,67 @@ ApplicationWindow {

    header: ToolBar {
        id: toolBar
-        height: 60
-        anchors.topMargin: 5
-        anchors.bottomMargin: 5
-
-        Label {
-            id: titleLabel
-            visible: toolBar.width > 700
-            anchors.fill: parent
-            text: stackView.currentItem.objectName
-            font.pointSize: 20
-            elide: Label.ElideRight
-            horizontalAlignment: Qt.AlignHCenter
-            verticalAlignment: Qt.AlignVCenter
-        }

        RowLayout {
-            spacing: 10
-            anchors.leftMargin: 10
-            anchors.rightMargin: 10
+            spacing: 20
            anchors.fill: parent

-            NavigableToolButton {
+            ToolButton {
                // Only make the button visible if the user has navigated somewhere.
                visible: stackView.depth > 1

-                iconSource: "qrc:/res/arrow_left.svg"
+                icon.source: "qrc:/res/arrow_left.svg"
+                onClicked: stackView.pop()

-                onClicked: goBack()
-
-                Keys.onDownPressed: {
-                    stackView.currentItem.forceActiveFocus(Qt.TabFocus)
+                Menu {
+                    id: backButton
+                    x: parent.width - width
+                    transformOrigin: Menu.TopRight
                }
            }

-            // This label will appear when the window gets too small and
-            // we need to ensure the toolbar controls don't collide
            Label {
-                id: titleRowLabel
-                font.pointSize: titleLabel.font.pointSize
+                id: titleLabel
+                text: stackView.currentItem.objectName
+                font.pointSize: 15
                elide: Label.ElideRight
                horizontalAlignment: Qt.AlignHCenter
                verticalAlignment: Qt.AlignVCenter
                Layout.fillWidth: true
-
-                // We need this label to always be visible so it can occupy
-                // the remaining space in the RowLayout. To "hide" it, we
-                // just set the text to empty string.
-                text: !titleLabel.visible ? stackView.currentItem.objectName : ""
            }

-            Label {
-                id: versionLabel
-                visible: stackView.currentItem instanceof SettingsView
-                text: qsTr("Version %1").arg(SystemProperties.versionString)
-                font.pointSize: 12
-                horizontalAlignment: Qt.AlignRight
-                verticalAlignment: Qt.AlignVCenter
-            }
-
-            NavigableToolButton {
-                id: discordButton
-                visible: SystemProperties.hasBrowser &&
-                         stackView.currentItem instanceof SettingsView
-
-                iconSource: "qrc:/res/discord.svg"
-
-                ToolTip.delay: 1000
-                ToolTip.timeout: 3000
-                ToolTip.visible: hovered
-                ToolTip.text: qsTr("Join our community on Discord")
-
-                // TODO need to make sure browser is brought to foreground.
-                onClicked: Qt.openUrlExternally("https://moonlight-stream.org/discord");
-
-                Keys.onDownPressed: {
-                    stackView.currentItem.forceActiveFocus(Qt.TabFocus)
-                }
-            }
-
-            NavigableToolButton {
-                id: addPcButton
-                visible: stackView.currentItem instanceof PcView
-
-                iconSource:  "qrc:/res/ic_add_to_queue_white_48px.svg"
-
-                ToolTip.delay: 1000
-                ToolTip.timeout: 3000
-                ToolTip.visible: hovered
-                ToolTip.text: qsTr("Add PC manually") + (newPcShortcut.nativeText ? (" ("+newPcShortcut.nativeText+")") : "")
-
-                Shortcut {
-                    id: newPcShortcut
-                    sequence: StandardKey.New
-                    onActivated: addPcButton.clicked()
-                }
-
-                onClicked: {
-                    addPcDialog.open()
-                }
-
-                Keys.onDownPressed: {
-                    stackView.currentItem.forceActiveFocus(Qt.TabFocus)
-                }
-            }
-
-            NavigableToolButton {
-                property string browserUrl: ""
-
-                id: updateButton
-
-                iconSource: "qrc:/res/update.svg"
-
-                ToolTip.delay: 1000
-                ToolTip.timeout: 3000
-                ToolTip.visible: hovered || visible
-
-                // Invisible until we get a callback notifying us that
-                // an update is available
-                visible: false
-
-                onClicked: {
-                    if (SystemProperties.hasBrowser) {
-                        Qt.openUrlExternally(browserUrl);
-                    }
-                }
-
-                function updateAvailable(version, url)
-                {
-                    ToolTip.text = qsTr("Update available for Moonlight: Version %1").arg(version)
-                    updateButton.browserUrl = url
-                    updateButton.visible = true
-                }
-
-                Component.onCompleted: {
-                    AutoUpdateChecker.onUpdateAvailable.connect(updateAvailable)
-                    AutoUpdateChecker.start()
-                }
-
-                Keys.onDownPressed: {
-                    stackView.currentItem.forceActiveFocus(Qt.TabFocus)
-                }
-            }
-
-            NavigableToolButton {
-                id: helpButton
-                visible: SystemProperties.hasBrowser
-
-                iconSource: "qrc:/res/question_mark.svg"
-
-                ToolTip.delay: 1000
-                ToolTip.timeout: 3000
-                ToolTip.visible: hovered
-                ToolTip.text: qsTr("Help") + (helpShortcut.nativeText ? (" ("+helpShortcut.nativeText+")") : "")
-
-                Shortcut {
-                    id: helpShortcut
-                    sequence: StandardKey.HelpContents
-                    onActivated: helpButton.clicked()
-                }
+            ToolButton {
+                icon.source: "qrc:/res/question_mark.svg"

                // TODO need to make sure browser is brought to foreground.
                onClicked: Qt.openUrlExternally("https://github.com/moonlight-stream/moonlight-docs/wiki/Setup-Guide");

-                Keys.onDownPressed: {
-                    stackView.currentItem.forceActiveFocus(Qt.TabFocus)
+                Menu {
+                    id: helpButton
+                    x: parent.width
+                    transformOrigin: Menu.TopRight
                }
            }

-            NavigableToolButton {
-                // TODO: Implement gamepad mapping then unhide this button
-                visible: false
+            ToolButton {
+                icon.source: "qrc:/res/ic_videogame_asset_white_48px.svg"
+                onClicked: navigateTo("qrc:/gui/GamepadMapper.qml", "Gamepad Mapping")

-                ToolTip.delay: 1000
-                ToolTip.timeout: 3000
-                ToolTip.visible: hovered
-                ToolTip.text: qsTr("Gamepad Mapper")
-
-                iconSource: "qrc:/res/ic_videogame_asset_white_48px.svg"
-
-                onClicked: navigateTo("qrc:/gui/GamepadMapper.qml", GamepadMapper)
-
-                Keys.onDownPressed: {
-                    stackView.currentItem.forceActiveFocus(Qt.TabFocus)
+                Menu {
+                    id: gamepadMappingMenu
+                    x: parent.width
+                    transformOrigin: Menu.TopRight
                }
            }

-            NavigableToolButton {
-                id: settingsButton
+            ToolButton {
+                icon.source: "qrc:/res/settings.svg"
+                onClicked: navigateTo("qrc:/gui/SettingsView.qml", "Settings")

-                iconSource:  "qrc:/res/settings.svg"
-
-                onClicked: navigateTo("qrc:/gui/SettingsView.qml", SettingsView)
-
-                Keys.onDownPressed: {
-                    stackView.currentItem.forceActiveFocus(Qt.TabFocus)
-                }
-
-                Shortcut {
-                    id: settingsShortcut
-                    sequence: StandardKey.Preferences
-                    onActivated: settingsButton.clicked()
-                }
-
-                ToolTip.delay: 1000
-                ToolTip.timeout: 3000
-                ToolTip.visible: hovered
-                ToolTip.text: qsTr("Settings") + (settingsShortcut.nativeText ? (" ("+settingsShortcut.nativeText+")") : "")
-            }
-        }
-    }
-
-    ErrorMessageDialog {
-        id: noHwDecoderDialog
-        text: qsTr("No functioning hardware accelerated video decoder was detected by Moonlight. " +
-                   "Your streaming performance may be severely degraded in this configuration.")
-        helpText: qsTr("Click the Help button for more information on solving this problem.")
-        helpUrl: "https://github.com/moonlight-stream/moonlight-docs/wiki/Fixing-Hardware-Decoding-Problems"
-    }
-
-    ErrorMessageDialog {
-        id: xWaylandDialog
-        text: qsTr("Hardware acceleration doesn't work on XWayland. Continuing on XWayland may result in poor streaming performance. " +
-                   "Try running with QT_QPA_PLATFORM=wayland or switch to X11.")
-        helpText: qsTr("Click the Help button for more information.")
-        helpUrl: "https://github.com/moonlight-stream/moonlight-docs/wiki/Fixing-Hardware-Decoding-Problems"
-    }
-
-    NavigableMessageDialog {
-        id: wow64Dialog
-        standardButtons: Dialog.Ok | Dialog.Cancel
-        text: qsTr("This version of Moonlight isn't optimized for your PC. Please download the '%1' version of Moonlight for the best streaming performance.").arg(SystemProperties.friendlyNativeArchName)
-        onAccepted: {
-            Qt.openUrlExternally("https://github.com/moonlight-stream/moonlight-qt/releases");
-        }
-    }
-
-    ErrorMessageDialog {
-        id: unmappedGamepadDialog
-        property string unmappedGamepads : ""
-        text: qsTr("Moonlight detected gamepads without a mapping:") + "\n" + unmappedGamepads
-        helpTextSeparator: "\n\n"
-        helpText: qsTr("Click the Help button for information on how to map your gamepads.")
-        helpUrl: "https://github.com/moonlight-stream/moonlight-docs/wiki/Gamepad-Mapping"
-    }
-
-    // This dialog appears when quitting via keyboard or gamepad button
-    NavigableMessageDialog {
-        id: quitConfirmationDialog
-        standardButtons: Dialog.Yes | Dialog.No
-        text: qsTr("Are you sure you want to quit?")
-        // For keyboard/gamepad navigation
-        onAccepted: Qt.quit()
-    }
-
-    // HACK: This belongs in StreamSegue but keeping a dialog around after the parent
-    // dies can trigger bugs in Qt 5.12 that cause the app to crash. For now, we will
-    // host this dialog in a QML component that is never destroyed.
-    //
-    // To repro: Start a stream, cut the network connection to trigger the "Connection
-    // terminated" dialog, wait until the app grid times out back to the PC grid, then
-    // try to dismiss the dialog.
-    ErrorMessageDialog {
-        id: streamSegueErrorDialog
-
-        property bool quitAfter: false
-
-        onClosed: {
-            if (quitAfter) {
-                Qt.quit()
-            }
-
-            // StreamSegue assumes its dialog will be re-created each time we
-            // start streaming, so fake it by wiping out the text each time.
-            text = ""
-        }
-    }
-
-    NavigableDialog {
-        id: addPcDialog
-        property string label: qsTr("Enter the IP address of your host PC:")
-
-        standardButtons: Dialog.Ok | Dialog.Cancel
-
-        onOpened: {
-            // Force keyboard focus on the textbox so keyboard navigation works
-            editText.forceActiveFocus()
-        }
-
-        onClosed: {
-            editText.clear()
-        }
-
-        onAccepted: {
-            if (editText.text) {
-                ComputerManager.addNewHostManually(editText.text.trim())
-            }
-        }
-
-        ColumnLayout {
-            Label {
-                text: addPcDialog.label
-                font.bold: true
-            }
-
-            TextField {
-                id: editText
-                Layout.fillWidth: true
-                focus: true
-
-                Keys.onReturnPressed: {
-                    addPcDialog.accept()
-                }
-
-                Keys.onEnterPressed: {
-                    addPcDialog.accept()
+                Menu {
+                    id: optionsMenu
+                    x: parent.width
+                    transformOrigin: Menu.TopRight
                }
            }
        }
@@ -1,307 +0,0 @@
-#include "sdlgamepadkeynavigation.h"
-
-#include <QKeyEvent>
-#include <QGuiApplication>
-#include <QWindow>
-
-#include "settings/mappingmanager.h"
-
-#define AXIS_NAVIGATION_REPEAT_DELAY 150
-
-SdlGamepadKeyNavigation::SdlGamepadKeyNavigation(StreamingPreferences* prefs)
-    : m_Prefs(prefs),
-      m_Enabled(false),
-      m_UiNavMode(false),
-      m_FirstPoll(false),
-      m_HasFocus(false),
-      m_LastAxisNavigationEventTime(0)
-{
-    m_PollingTimer = new QTimer(this);
-    connect(m_PollingTimer, &QTimer::timeout, this, &SdlGamepadKeyNavigation::onPollingTimerFired);
-}
-
-SdlGamepadKeyNavigation::~SdlGamepadKeyNavigation()
-{
-    disable();
-}
-
-void SdlGamepadKeyNavigation::enable()
-{
-    if (m_Enabled) {
-        return;
-    }
-
-    // We have to initialize and uninitialize this in enable()/disable()
-    // because we need to get out of the way of the Session class. If it
-    // doesn't get to reinitialize the GC subsystem, it won't get initial
-    // arrival events. Additionally, there's a race condition between
-    // our QML objects being destroyed and SDL being deinitialized that
-    // this solves too.
-    if (SDL_InitSubSystem(SDL_INIT_GAMECONTROLLER) != 0) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                     "SDL_InitSubSystem(SDL_INIT_GAMECONTROLLER) failed: %s",
-                     SDL_GetError());
-        return;
-    }
-
-    MappingManager mappingManager;
-    mappingManager.applyMappings();
-
-    // Drop all pending gamepad add events. SDL will generate these for us
-    // on first init of the GC subsystem. We can't depend on them due to
-    // overlapping lifetimes of SdlGamepadKeyNavigation instances, so we
-    // will attach ourselves.
-    //
-    // NB: We use SDL_JoystickUpdate() instead of SDL_PumpEvents() because
-    // the latter can do a bit more work that we want (like handling video
-    // events that we intentionally do not want to process yet).
-    SDL_JoystickUpdate();
-    SDL_FlushEvent(SDL_CONTROLLERDEVICEADDED);
-
-    // Open all currently attached game controllers
-    int numJoysticks = SDL_NumJoysticks();
-    for (int i = 0; i < numJoysticks; i++) {
-        if (SDL_IsGameController(i)) {
-            SDL_GameController* gc = SDL_GameControllerOpen(i);
-            if (gc != nullptr) {
-                m_Gamepads.append(gc);
-            }
-        }
-    }
-
-    m_Enabled = true;
-
-    // Start the polling timer if the window is focused
-    updateTimerState();
-}
-
-void SdlGamepadKeyNavigation::disable()
-{
-    if (!m_Enabled) {
-        return;
-    }
-
-    m_Enabled = false;
-    updateTimerState();
-    Q_ASSERT(!m_PollingTimer->isActive());
-
-    while (!m_Gamepads.isEmpty()) {
-        SDL_GameControllerClose(m_Gamepads[0]);
-        m_Gamepads.removeAt(0);
-    }
-
-    SDL_QuitSubSystem(SDL_INIT_GAMECONTROLLER);
-}
-
-void SdlGamepadKeyNavigation::notifyWindowFocus(bool hasFocus)
-{
-    m_HasFocus = hasFocus;
-    updateTimerState();
-}
-
-void SdlGamepadKeyNavigation::onPollingTimerFired()
-{
-    SDL_Event event;
-
-    // Update joystick state without pumping other events (see enable() comment)
-    SDL_JoystickUpdate();
-
-    // Discard any pending button events on the first poll to avoid picking up
-    // stale input data from the stream session (like the quit combo).
-    if (m_FirstPoll) {
-        SDL_FlushEvent(SDL_CONTROLLERBUTTONDOWN);
-        SDL_FlushEvent(SDL_CONTROLLERBUTTONUP);
-        m_FirstPoll = false;
-    }
-
-    // Peep events rather than polling to avoid calling SDL_PumpEvents()
-    while (SDL_PeepEvents(&event, 1, SDL_GETEVENT, SDL_FIRSTEVENT, SDL_LASTEVENT) == 1) {
-        switch (event.type) {
-        case SDL_QUIT:
-            // SDL may send us a quit event since we initialize
-            // the video subsystem on startup. If we get one,
-            // forward it on for Qt to take care of.
-            QCoreApplication::instance()->quit();
-            break;
-        case SDL_CONTROLLERBUTTONDOWN:
-        case SDL_CONTROLLERBUTTONUP:
-        {
-            QEvent::Type type =
-                    event.type == SDL_CONTROLLERBUTTONDOWN ?
-                        QEvent::Type::KeyPress : QEvent::Type::KeyRelease;
-
-            // Swap face buttons if needed
-            if (m_Prefs->swapFaceButtons) {
-                switch (event.cbutton.button) {
-                case SDL_CONTROLLER_BUTTON_A:
-                    event.cbutton.button = SDL_CONTROLLER_BUTTON_B;
-                    break;
-                case SDL_CONTROLLER_BUTTON_B:
-                    event.cbutton.button = SDL_CONTROLLER_BUTTON_A;
-                    break;
-                case SDL_CONTROLLER_BUTTON_X:
-                    event.cbutton.button = SDL_CONTROLLER_BUTTON_Y;
-                    break;
-                case SDL_CONTROLLER_BUTTON_Y:
-                    event.cbutton.button = SDL_CONTROLLER_BUTTON_X;
-                    break;
-                }
-            }
-
-            switch (event.cbutton.button) {
-            case SDL_CONTROLLER_BUTTON_DPAD_UP:
-                if (m_UiNavMode) {
-                    // Back-tab
-                    sendKey(type, Qt::Key_Tab, Qt::ShiftModifier);
-                }
-                else {
-                    sendKey(type, Qt::Key_Up);
-                }
-                break;
-            case SDL_CONTROLLER_BUTTON_DPAD_DOWN:
-                if (m_UiNavMode) {
-                    sendKey(type, Qt::Key_Tab);
-                }
-                else {
-                    sendKey(type, Qt::Key_Down);
-                }
-                break;
-            case SDL_CONTROLLER_BUTTON_DPAD_LEFT:
-                sendKey(type, Qt::Key_Left);
-                break;
-            case SDL_CONTROLLER_BUTTON_DPAD_RIGHT:
-                sendKey(type, Qt::Key_Right);
-                break;
-            case SDL_CONTROLLER_BUTTON_A:
-                if (m_UiNavMode) {
-                    sendKey(type, Qt::Key_Space);
-                }
-                else {
-                    sendKey(type, Qt::Key_Return);
-                }
-                break;
-            case SDL_CONTROLLER_BUTTON_B:
-                sendKey(type, Qt::Key_Escape);
-                break;
-            case SDL_CONTROLLER_BUTTON_X:
-                sendKey(type, Qt::Key_Menu);
-                break;
-            case SDL_CONTROLLER_BUTTON_Y:
-            case SDL_CONTROLLER_BUTTON_START:
-                // HACK: We use this keycode to inform main.qml
-                // to show the settings when Key_Menu is handled
-                // by the control in focus.
-                sendKey(type, Qt::Key_Hangup);
-                break;
-            default:
-                break;
-            }
-            break;
-        }
-        case SDL_CONTROLLERDEVICEADDED:
-            SDL_GameController* gc = SDL_GameControllerOpen(event.cdevice.which);
-            if (gc != nullptr) {
-                // SDL_CONTROLLERDEVICEADDED can be reported multiple times for the same
-                // gamepad in rare cases, because SDL doesn't fixup the device index in
-                // the SDL_CONTROLLERDEVICEADDED event if an unopened gamepad disappears
-                // before we've processed the add event.
-                if (!m_Gamepads.contains(gc)) {
-                    m_Gamepads.append(gc);
-                }
-                else {
-                    // We already have this game controller open
-                    SDL_GameControllerClose(gc);
-                }
-            }
-            break;
-        }
-    }
-
-    // Handle analog sticks by polling
-    for (auto gc : std::as_const(m_Gamepads)) {
-        short leftX = SDL_GameControllerGetAxis(gc, SDL_CONTROLLER_AXIS_LEFTX);
-        short leftY = SDL_GameControllerGetAxis(gc, SDL_CONTROLLER_AXIS_LEFTY);
-        if (SDL_GetTicks() - m_LastAxisNavigationEventTime < AXIS_NAVIGATION_REPEAT_DELAY) {
-            // Do nothing
-        }
-        else if (leftY < -30000) {
-            if (m_UiNavMode) {
-                // Back-tab
-                sendKey(QEvent::Type::KeyPress, Qt::Key_Tab, Qt::ShiftModifier);
-                sendKey(QEvent::Type::KeyRelease, Qt::Key_Tab, Qt::ShiftModifier);
-            }
-            else {
-                sendKey(QEvent::Type::KeyPress, Qt::Key_Up);
-                sendKey(QEvent::Type::KeyRelease, Qt::Key_Up);
-            }
-
-            m_LastAxisNavigationEventTime = SDL_GetTicks();
-        }
-        else if (leftY > 30000) {
-            if (m_UiNavMode) {
-                sendKey(QEvent::Type::KeyPress, Qt::Key_Tab);
-                sendKey(QEvent::Type::KeyRelease, Qt::Key_Tab);
-            }
-            else {
-                sendKey(QEvent::Type::KeyPress, Qt::Key_Down);
-                sendKey(QEvent::Type::KeyRelease, Qt::Key_Down);
-            }
-
-            m_LastAxisNavigationEventTime = SDL_GetTicks();
-        }
-        else if (leftX < -30000) {
-            sendKey(QEvent::Type::KeyPress, Qt::Key_Left);
-            sendKey(QEvent::Type::KeyRelease, Qt::Key_Left);
-            m_LastAxisNavigationEventTime = SDL_GetTicks();
-        }
-        else if (leftX > 30000) {
-            sendKey(QEvent::Type::KeyPress, Qt::Key_Right);
-            sendKey(QEvent::Type::KeyRelease, Qt::Key_Right);
-            m_LastAxisNavigationEventTime = SDL_GetTicks();
-        }
-    }
-}
-
-void SdlGamepadKeyNavigation::sendKey(QEvent::Type type, Qt::Key key, Qt::KeyboardModifiers modifiers)
-{
-    QGuiApplication* app = static_cast<QGuiApplication*>(QGuiApplication::instance());
-    QWindow* focusWindow = app->focusWindow();
-    if (focusWindow != nullptr) {
-        QKeyEvent keyPressEvent(type, key, modifiers);
-        app->sendEvent(focusWindow, &keyPressEvent);
-    }
-}
-
-void SdlGamepadKeyNavigation::updateTimerState()
-{
-    if (m_PollingTimer->isActive() && (!m_HasFocus || !m_Enabled)) {
-        m_PollingTimer->stop();
-    }
-    else if (!m_PollingTimer->isActive() && m_HasFocus && m_Enabled) {
-        // Flush events on the first poll
-        m_FirstPoll = true;
-
-        // Poll every 50 ms for a new joystick event
-        m_PollingTimer->start(50);
-    }
-}
-
-void SdlGamepadKeyNavigation::setUiNavMode(bool uiNavMode)
-{
-    m_UiNavMode = uiNavMode;
-}
-
-int SdlGamepadKeyNavigation::getConnectedGamepads()
-{
-    Q_ASSERT(m_Enabled);
-
-    int count = 0;
-    int numJoysticks = SDL_NumJoysticks();
-    for (int i = 0; i < numJoysticks; i++) {
-        if (SDL_IsGameController(i)) {
-            count++;
-        }
-    }
-
-    return count;
-}
@@ -1,46 +0,0 @@
-#pragma once
-
-#include <QTimer>
-#include <QEvent>
-
-#include "SDL_compat.h"
-
-#include "settings/streamingpreferences.h"
-
-class SdlGamepadKeyNavigation : public QObject
-{
-    Q_OBJECT
-
-public:
-    SdlGamepadKeyNavigation(StreamingPreferences* prefs);
-
-    ~SdlGamepadKeyNavigation();
-
-    Q_INVOKABLE void enable();
-
-    Q_INVOKABLE void disable();
-
-    Q_INVOKABLE void notifyWindowFocus(bool hasFocus);
-
-    Q_INVOKABLE void setUiNavMode(bool settingsMode);
-
-    Q_INVOKABLE int getConnectedGamepads();
-
-private:
-    void sendKey(QEvent::Type type, Qt::Key key, Qt::KeyboardModifiers modifiers = Qt::NoModifier);
-
-    void updateTimerState();
-
-private slots:
-    void onPollingTimerFired();
-
-private:
-    StreamingPreferences* m_Prefs;
-    QTimer* m_PollingTimer;
-    QList<SDL_GameController*> m_Gamepads;
-    bool m_Enabled;
-    bool m_UiNavMode;
-    bool m_FirstPoll;
-    bool m_HasFocus;
-    Uint32 m_LastAxisNavigationEventTime;
-};
--- a/Show More
+++ b/Show More