wip

Update Brazilian Portuguese Translation

.clang-format

@@ -20,6 +20,7 @@ AlwaysBreakTemplateDeclarations: true
 BinPackArguments: true
 BinPackParameters: true
 BraceWrapping:   
+  AfterCaseLabel:  true
   AfterClass:      true
   AfterControlStatement: true
   AfterEnum:       true

.github/workflows/linux-build.yml.disabled

@@ -0,0 +1,38 @@
+name: Linux Build
+
+on:
+  pull_request:
+  push:
+    branches:
+      - master
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v1
+
+    - name: Install packages
+      shell: bash
+      run: |
+        sudo apt-get update
+        sudo apt-get -y install libsdl2-dev libgtk2.0-dev
+
+    - name: Compile debug build
+      shell: bash
+      run: |
+        mkdir build-debug
+        cd build-debug
+        cmake -DCMAKE_BUILD_TYPE=Debug -DBUILD_QT_FRONTEND=OFF ..
+        make
+        
+    - name: Compile release build
+      shell: bash
+      run: |
+        mkdir build-release
+        cd build-release
+        cmake -DCMAKE_BUILD_TYPE=Release -DBUILD_QT_FRONTEND=OFF ..
+        make
+

.github/workflows/rolling-release.yml

@@ -0,0 +1,354 @@
+name: Create rolling release
+
+on:
+  pull_request:
+    paths-ignore:
+      - '**.md'
+      - 'appveyor.yml'
+      - 'scripts/*'
+  push:
+    branches:
+      - master
+    paths-ignore:
+      - '**.md'
+      - 'appveyor.yml'
+      - 'scripts/*'
+  workflow_dispatch:
+
+jobs:
+  windows-build:
+    runs-on: windows-2019
+    steps:
+    - uses: actions/checkout@v2.3.1
+      with:
+        fetch-depth: 0
+        submodules: true
+
+    - name: Tag as release build
+      shell: cmd
+      run: |
+        echo #pragma once > src/scmversion/tag.h
+        echo #define SCM_RELEASE_TAG "latest" >> src/scmversion/tag.h
+        echo #define SCM_RELEASE_ASSET "duckstation-windows-x64-release.zip" >> src/scmversion/tag.h
+
+    - name: Compile release build
+      shell: cmd
+      run: |
+        call "C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\VC\Auxiliary\Build\vcvarsall.bat" x64
+        msbuild duckstation.sln -t:Build -p:Platform=x64;Configuration=ReleaseLTCG
+
+    - name: Remove extra bloat before archiving
+      shell: cmd
+      run: |
+        del /Q bin\x64\*.pdb
+        del /Q bin\x64\*.exp
+        del /Q bin\x64\*.lib
+        del /Q bin\x64\*.iobj
+        del /Q bin\x64\*.ipdb
+        del /Q bin\x64\common-tests*
+        del /Q bin\x64\duckstation-libretro-*
+        rename bin\x64\updater-x64-ReleaseLTCG.exe updater.exe
+                
+    - name: Create release archive
+      shell: cmd
+      run: |
+        "C:\Program Files\7-Zip\7z.exe" a -r duckstation-windows-x64-release.zip ./bin/x64/*
+
+    - name: Upload release artifact
+      uses: actions/upload-artifact@v1
+      with:
+        name: "windows-x64"
+        path: "duckstation-windows-x64-release.zip"
+
+
+  windows-libretro-build:
+    runs-on: windows-2019
+    steps:
+    - uses: actions/checkout@v2.3.1
+      with:
+        fetch-depth: 0
+
+    - name: Compile release build
+      shell: cmd
+      run: |
+        call "C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\VC\Auxiliary\Build\vcvarsall.bat" x64
+        mkdir build
+        cd build
+        cmake -G Ninja -DCMAKE_BUILD_TYPE=Release -DBUILD_LIBRETRO_CORE=ON -DCMAKE_C_COMPILER:FILEPATH="%VCToolsInstallDir%\bin\HostX64\x64\cl.exe" -DCMAKE_CXX_COMPILER:FILEPATH="%VCToolsInstallDir%\bin\HostX64\x64\cl.exe" ..
+        ninja
+        
+    - name: Create libretro core archive
+      shell: cmd
+      run: |
+        cd build
+        "C:\Program Files\7-Zip\7z.exe" a -r duckstation_libretro.dll.zip ./duckstation_libretro.dll
+
+    - name: Upload release artifact
+      uses: actions/upload-artifact@v1
+      with:
+        name: "windows-libretro-x64"
+        path: "build/duckstation_libretro.dll.zip"
+
+
+  linux-build:
+    runs-on: ubuntu-18.04
+    steps:
+    - uses: actions/checkout@v2.3.1
+      with:
+        fetch-depth: 0
+
+    - name: Install packages
+      shell: bash
+      run: |
+        sudo apt-get update
+        sudo apt-get -y install cmake ninja-build ccache libsdl2-dev libgtk2.0-dev qtbase5-dev qtbase5-dev-tools qtbase5-private-dev qt5-default qttools5-dev
+
+    - name: Compile build
+      shell: bash
+      run: |
+        mkdir build
+        cd build
+        cmake -DCMAKE_BUILD_TYPE=Release -DBUILD_SDL_FRONTEND=ON -DBUILD_QT_FRONTEND=ON -DUSE_SDL2=ON -G Ninja ..
+        ninja
+        ../appimage/generate_appimages.sh $(pwd)
+
+    - name: Upload SDL AppImage
+      uses: actions/upload-artifact@v1
+      with:
+        name: "linux-x64-appimage-sdl"
+        path: "build/duckstation-sdl-x64.AppImage"
+
+    - name: Upload SDL AppImage zsync
+      uses: actions/upload-artifact@v1
+      with:
+        name: "linux-x64-appimage-sdl-zsync"
+        path: "build/duckstation-sdl-x64.AppImage.zsync"
+
+    - name: Upload Qt AppImage
+      uses: actions/upload-artifact@v1
+      with:
+        name: "linux-x64-appimage-qt"
+        path: "build/duckstation-qt-x64.AppImage"
+
+    - name: Upload Qt AppImage zsync
+      uses: actions/upload-artifact@v1
+      with:
+        name: "linux-x64-appimage-qt-zsync"
+        path: "build/duckstation-qt-x64.AppImage.zsync"
+
+
+  linux-libretro-build:
+    runs-on: ubuntu-20.04
+    steps:
+    - uses: actions/checkout@v2.3.1
+      with:
+        fetch-depth: 0
+
+    - name: Install packages
+      shell: bash
+      run: |
+        sudo apt-get update
+        sudo apt-get -y install gcc-aarch64-linux-gnu g++-aarch64-linux-gnu
+
+    - name: Compile and zip Linux x64 libretro core
+      shell: bash
+      run: |
+        mkdir build-libretro-linux-x64
+        cd build-libretro-linux-x64
+        cmake -DCMAKE_BUILD_TYPE=Release -DBUILD_LIBRETRO_CORE=ON ..
+        cmake --build . --parallel 2
+        zip -j duckstation_libretro_x64.so.zip duckstation_libretro.so
+
+    - name: Upload Linux x64 libretro core
+      uses: actions/upload-artifact@v1
+      with:
+        name: "linux-libretro"
+        path: "build-libretro-linux-x64/duckstation_libretro_x64.so.zip"
+
+    - name: Compile and zip Linux AArch64 libretro core
+      shell: bash
+      run: |
+        mkdir build-libretro-linux-aarch64
+        cd build-libretro-linux-aarch64
+        cmake -DCMAKE_BUILD_TYPE=Release -DBUILD_LIBRETRO_CORE=ON -DCMAKE_TOOLCHAIN_FILE=../CMakeModules/aarch64-cross-toolchain.cmake ..
+        cmake --build . --parallel 2
+        zip -j duckstation_libretro_linux_aarch64.so.zip duckstation_libretro.so
+      
+    - name: Upload Linux AArch64 libretro core
+      uses: actions/upload-artifact@v1
+      with:
+        name: "linux-libretro"
+        path: "build-libretro-linux-aarch64/duckstation_libretro_linux_aarch64.so.zip"
+
+    - name: Compile and zip Android AArch64 libretro core
+      shell: bash
+      run: |
+        mkdir build-libretro-android-aarch64
+        cd build-libretro-android-aarch64
+        cmake -DCMAKE_BUILD_TYPE=Release -DBUILD_LIBRETRO_CORE=ON -DANDROID_ABI=arm64-v8a -DCMAKE_TOOLCHAIN_FILE=${ANDROID_SDK_ROOT}/ndk-bundle/build/cmake/android.toolchain.cmake ..
+        cmake --build . --parallel 2
+        zip -j duckstation_libretro_android_aarch64.so.zip duckstation_libretro_android.so
+      
+    - name: Upload Android AArch64 libretro core
+      uses: actions/upload-artifact@v1
+      with:
+        name: "linux-libretro"
+        path: "build-libretro-android-aarch64/duckstation_libretro_android_aarch64.so.zip"
+
+
+  android-build:
+    runs-on: ubuntu-20.04
+    steps:
+    - uses: actions/checkout@v2.3.1
+      with:
+        fetch-depth: 0
+
+    - name: Compile with Gradle
+      shell: bash
+      run: |
+        cd android
+        ./gradlew assembleRelease
+
+    - name: Sign APK
+      if: github.ref == 'refs/heads/master'
+      uses: r0adkll/sign-android-release@v1
+      with:
+        releaseDirectory: android/app/build/outputs/apk/release
+        signingKeyBase64: ${{ secrets.APK_SIGNING_KEY }}
+        alias: ${{ secrets.APK_KEY_ALIAS }}
+        keyStorePassword: ${{ secrets.APK_KEY_STORE_PASSWORD }}
+        keyPassword: ${{ secrets.APK_KEY_PASSWORD }}
+
+    - name: Rename APK
+      if: github.ref == 'refs/heads/master'
+      shell: bash
+      run: |
+        cd android
+        mv app/build/outputs/apk/release/app-release-unsigned-signed.apk ../duckstation-android-aarch64.apk
+         
+    - name: Upload APK
+      if: github.ref == 'refs/heads/master'
+      uses: actions/upload-artifact@v1
+      with:
+        name: "android"
+        path: "duckstation-android-aarch64.apk"
+
+  macos-build:
+    runs-on: macos-10.15
+    steps:
+    - uses: actions/checkout@v2.3.1
+      with:
+        fetch-depth: 0
+
+    - name: Install packages
+      shell: bash
+      run: |
+        brew install qt5 sdl2
+
+    - name: Clone mac externals
+      shell: bash
+      run: |
+        git clone https://github.com/stenzek/duckstation-ext-mac.git dep/mac
+
+    - name: Compile and zip .app
+      shell: bash
+      run: |
+        mkdir build
+        cd build
+        cmake -DCMAKE_BUILD_TYPE=Release -DBUILD_SDL_FRONTEND=OFF -DBUILD_QT_FRONTEND=ON -DUSE_SDL2=ON -DQt5_DIR=/usr/local/opt/qt/lib/cmake/Qt5 ..
+        cmake --build . --parallel 2
+        cd bin
+        zip -r duckstation-mac-release.zip DuckStation.app/
+
+    - name: Upload macOS .app
+      uses: actions/upload-artifact@v1
+      with:
+        name: "macos-x64"
+        path: "build/bin/duckstation-mac-release.zip"
+
+    - name: Compile libretro core and zip
+      shell: bash
+      run: |
+        mkdir build-libretro
+        cd build-libretro
+        cmake -DCMAKE_BUILD_TYPE=Release -DCMAKE_BUILD_TYPE=Release -DBUILD_LIBRETRO_CORE=ON  ..
+        cmake --build . --parallel 2
+        zip -j duckstation_libretro_mac.dylib.zip duckstation_libretro.dylib
+
+    - name: Upload macOS libretro core
+      uses: actions/upload-artifact@v1
+      with:
+        name: "macos-x64"
+        path: "build-libretro/duckstation_libretro_mac.dylib.zip"
+
+
+  create-release:
+    needs: [windows-build, windows-libretro-build, linux-build, linux-libretro-build, android-build, macos-build]
+    runs-on: "ubuntu-latest"
+    if: github.ref == 'refs/heads/master'
+    steps:
+      - name: Download Windows x64 Artifact
+        uses: actions/download-artifact@v1
+        with:
+          name: "windows-x64"
+
+      - name: Download Windows libretro x64 Artifact
+        uses: actions/download-artifact@v1
+        with:
+          name: "windows-libretro-x64"
+
+      - name: Download SDL AppImage Artifact
+        uses: actions/download-artifact@v1
+        with:
+          name: "linux-x64-appimage-sdl"
+
+      - name: Download SDL AppImage zsync Artifact
+        uses: actions/download-artifact@v1
+        with:
+          name: "linux-x64-appimage-sdl-zsync"
+
+      - name: Download Qt AppImage Artifact
+        uses: actions/download-artifact@v1
+        with:
+          name: "linux-x64-appimage-qt"
+
+      - name: Download Qt AppImage zsync Artifact
+        uses: actions/download-artifact@v1
+        with:
+          name: "linux-x64-appimage-qt-zsync"
+
+      - name: Download Linux libretro core
+        uses: actions/download-artifact@v1
+        with:
+          name: "linux-libretro"
+
+      - name: Download Android APK
+        uses: actions/download-artifact@v1
+        with:
+          name: "android"
+
+      - name: Download Mac App
+        uses: actions/download-artifact@v1
+        with:
+          name: "macos-x64"
+
+      - name: Create release
+        uses: "marvinpinto/action-automatic-releases@latest"
+        with:
+          repo_token: "${{ secrets.GITHUB_TOKEN }}"
+          automatic_release_tag: "latest"
+          title: "Latest Development Build"
+          files: |
+            windows-x64/duckstation-windows-x64-release.zip
+            windows-libretro-x64/duckstation_libretro.dll.zip
+            linux-x64-appimage-sdl/duckstation-sdl-x64.AppImage
+            linux-x64-appimage-sdl-zsync/duckstation-sdl-x64.AppImage.zsync
+            linux-x64-appimage-qt/duckstation-qt-x64.AppImage
+            linux-x64-appimage-qt-zsync/duckstation-qt-x64.AppImage.zsync
+            linux-libretro/duckstation_libretro_x64.so.zip
+            linux-libretro/duckstation_libretro_linux_aarch64.so.zip
+            linux-libretro/duckstation_libretro_android_aarch64.so.zip
+            android/duckstation-android-aarch64.apk
+            macos-x64/duckstation-mac-release.zip
+            macos-x64/duckstation_libretro_mac.dylib.zip
+

.github/workflows/windows-build.yml.disabled

@@ -22,19 +22,17 @@ jobs:
         call "C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\VC\Auxiliary\Build\vcvarsall.bat" x64
         msbuild duckstation.sln -t:Build -p:Platform=x64;Configuration=ReleaseLTCG
         
-    - name: Copy dependencies to binary directory
+    - name: Remove extra bloat before archiving
       shell: cmd
       run: |
-        copy /Y dep\msvc\bin64\*.* bin\x64
-      
-    - name: Create zip archive of binary
-      shell: cmd
-      run: |
-        7z a -t7z duckstation-windows-x64-release.7z .\bin\x64\*
+        del /Q bin\x64\*.pdb
+        del /Q bin\x64\*.exp
+        del /Q bin\x64\*.lib
+        del /Q bin\x64\*.iobj
+        del /Q bin\x64\*.ipdb
 
     - name: Upload release archive
       uses: actions/upload-artifact@v1
       with:
-        name: "duckstation-windows-x64-release.7z"
-        path: "duckstation-windows-x64-release.7z"
-          
+        name: "duckstation-windows-x64-release"
+        path: ".\\bin\\x64"

.gitignore

@@ -5,6 +5,7 @@
 /bin/
 /Build/
 /build/
+/build-*/
 
 # vs stuff
 .vs
@@ -36,3 +37,6 @@ CMakeLists.txt.user
 
 # python bytecode
 __pycache__
+
+# other repos
+/dep/mac

.gitmodules

@@ -1,3 +1,4 @@
-[submodule "dep/YBaseLib"]
-	path = dep/YBaseLib
-	url = https://github.com/stenzek/YBaseLib.git
+[submodule "dep/msvc/qt"]
+	path = dep/msvc/qt
+	url = https://github.com/stenzek/duckstation-ext-qt-minimal.git
+	shallow = true

CMakeLists.txt

@@ -1,36 +1,120 @@
-cmake_minimum_required(VERSION 3.10)
+cmake_minimum_required(VERSION 3.8)
 project(duckstation C CXX)
 
+message("CMake Version: ${CMAKE_VERSION}")
+
 # Pull in modules.
 set(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/CMakeModules/")
 
+# Platform detection.
+if(${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
+  set(LINUX TRUE)
+  set(SUPPORTS_X11 TRUE)
+  set(SUPPORTS_WAYLAND TRUE)
+endif()
+
+
+# Global options.
+if(NOT ANDROID)
+  option(BUILD_SDL_FRONTEND "Build the SDL frontend" ON)
+  option(BUILD_QT_FRONTEND "Build the Qt frontend" ON)
+  option(BUILD_LIBRETRO_CORE "Build a libretro core" OFF)
+  option(ENABLE_DISCORD_PRESENCE "Build with Discord Rich Presence support" ON)
+  option(USE_SDL2 "Link with SDL2 for controller support" ON)
+endif()
+
+
+# OpenGL context creation methods.
+if(SUPPORTS_X11)
+  option(USE_X11 "Support X11 window system" ON)
+endif()
+if(SUPPORTS_WAYLAND)
+  option(USE_WAYLAND "Support Wayland window system" OFF)
+endif()
+if(LINUX OR ANDROID)
+  option(USE_EGL "Support EGL OpenGL context creation" ON)
+endif()
+
+# Force EGL when using Wayland
+if(USE_WAYLAND)
+  set(USE_EGL ON)
+endif()
+
+# When we're building for libretro, everything else is invalid because of PIC.
+if(ANDROID OR BUILD_LIBRETRO_CORE)
+  if(BUILD_SDL_FRONTEND)
+    message(WARNING "Building for Android or libretro core, disabling SDL frontend")
+    set(BUILD_SDL_FRONTEND OFF)
+  endif()
+  if(BUILD_QT_FRONTEND)
+    message(WARNING "Building for Android or libretro core, disabling Qt frontend")
+    set(BUILD_QT_FRONTEND OFF)
+  endif()
+  if(ENABLE_DISCORD_PRESENCE)
+    message("Building for Android or libretro core, disabling Discord Presence support")
+    set(ENABLE_DISCORD_PRESENCE OFF)
+  endif()
+  if(USE_SDL2)
+    message("Building for Android or libretro core, disabling SDL2 support")
+    set(USE_SDL2 OFF)
+  endif()
+  if(USE_X11)
+    set(USE_X11 OFF)
+  endif()
+  if(USE_WAYLAND)
+    set(USE_WAYLAND OFF)
+  endif()
+  if(BUILD_LIBRETRO_CORE AND USE_EGL)
+    set(USE_EGL OFF)
+  endif()
+
+  # Force PIC when compiling a libretro core.
+  if(BUILD_LIBRETRO_CORE)
+    set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+  endif()
+endif()
+
 
 # Common include/library directories on Windows.
 if(WIN32)
-  set(SDL2_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/dep/msvc/include/SDL")
-  if ("${CMAKE_BUILD_TYPE}" STREQUAL "Debug")
-    if(CMAKE_SIZEOF_VOID_P EQUAL 8)
-      set(SDL2_LIBRARY "${CMAKE_CURRENT_SOURCE_DIR}/dep/msvc/lib64-debug/SDL2.lib")
-      set(SDL2MAIN_LIBRARY "${CMAKE_CURRENT_SOURCE_DIR}/dep/msvc/lib64-debug/SDL2main.lib")
-    else()
-      set(SDL2_LIBRARY "${CMAKE_CURRENT_SOURCE_DIR}/dep/msvc/lib32-debug/SDL2.lib")
-      set(SDL2MAIN_LIBRARY "${CMAKE_CURRENT_SOURCE_DIR}/dep/msvc/lib32-debug/SDL2main.lib")
-    endif()
+  set(SDL2_FOUND TRUE)
+  set(SDL2_INCLUDE_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/dep/msvc/sdl2/include")
+  if(CMAKE_SIZEOF_VOID_P EQUAL 8)
+    set(SDL2_LIBRARIES "${CMAKE_CURRENT_SOURCE_DIR}/dep/msvc/sdl2/lib64/SDL2.lib")
+    set(SDL2MAIN_LIBRARIES "${CMAKE_CURRENT_SOURCE_DIR}/dep/msvc/sdl2/lib64/SDL2main.lib")
+    set(SDL2_DLL_PATH "${CMAKE_CURRENT_SOURCE_DIR}/dep/msvc/sdl2/bin64/SDL2.dll")
+    set(Qt5_DIR "${CMAKE_CURRENT_SOURCE_DIR}/dep/msvc/qt/5.15.0/msvc2017_64/lib/cmake/Qt5")
   else()
-    if(CMAKE_SIZEOF_VOID_P EQUAL 8)
-      set(SDL2_LIBRARY "${CMAKE_CURRENT_SOURCE_DIR}/dep/msvc/lib64/SDL2.lib")
-      set(SDL2MAIN_LIBRARY "${CMAKE_CURRENT_SOURCE_DIR}/dep/msvc/lib64/SDL2main.lib")
-    else()
-      set(SDL2_LIBRARY "${CMAKE_CURRENT_SOURCE_DIR}/dep/msvc/lib32/SDL2.lib")
-      set(SDL2MAIN_LIBRARY "${CMAKE_CURRENT_SOURCE_DIR}/dep/msvc/lib32/SDL2main.lib")
-    endif()
+    set(SDL2_LIBRARIES "${CMAKE_CURRENT_SOURCE_DIR}/dep/msvc/sdl2/lib32/SDL2.lib")
+    set(SDL2MAIN_LIBRARIES "${CMAKE_CURRENT_SOURCE_DIR}/dep/msvc/sdl2/lib32/SDL2main.lib")
+    set(SDL2_DLL_PATH "${CMAKE_CURRENT_SOURCE_DIR}/dep/msvc/sdl2/bin32/SDL2.dll")
+    set(Qt5_DIR "${CMAKE_CURRENT_SOURCE_DIR}/dep/msvc/qt/5.15.0/msvc2017_32/lib/cmake/Qt5")
   endif()
 endif()
 
 
 # Required libraries.
-find_package(SDL2 REQUIRED)
+if(NOT ANDROID)
+  if(NOT WIN32 AND (BUILD_SDL_FRONTEND OR USE_SDL2))
+    find_package(SDL2 REQUIRED)
+  endif()
+  if(BUILD_QT_FRONTEND)
+    find_package(Qt5 COMPONENTS Core Gui Widgets Network LinguistTools REQUIRED)
+  endif()
+endif()
 
+if(USE_EGL)
+  find_package(EGL REQUIRED)
+endif()
+if(USE_X11)
+  find_package(X11 REQUIRED)
+endif()
+if(USE_WAYLAND)
+  find_package(ECM REQUIRED NO_MODULE)
+  list(APPEND CMAKE_MODULE_PATH "${ECM_MODULE_PATH}")
+  find_package(Wayland REQUIRED Egl)
+  message(STATUS "Wayland support enabled")
+endif()
 
 # Set _DEBUG macro for Debug builds.
 set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -D_DEBUG")
@@ -44,8 +128,8 @@ if(MSVC)
     # Set warning level 3 instead of 4.
     string(REPLACE "/W3" "/W4" ${config} "${${config}}")
 
-    # Enable intrinsic functions, disable minimal rebuild.
-    set(${config} "${${config}} /Oi /Gm-")
+    # Enable intrinsic functions, disable minimal rebuild, UTF-8 source.
+    set(${config} "${${config}} /Oi /Gm- /utf-8")
   endforeach()
 
   # RelWithDebInfo is set to Ob1 instead of Ob2.   
@@ -58,6 +142,23 @@ if(MSVC)
   # COMDAT folding/remove unused functions.
   set(CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE} /OPT:REF /OPT:ICF")
   set(CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO "${CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO} /OPT:REF /OPT:ICF")
+
+  # Enable LTO/LTCG on Release builds.
+  if(${CMAKE_BUILD_TYPE} STREQUAL "Release")
+    if (${CMAKE_VERSION} VERSION_LESS "3.9.0")
+      message(WARNING "CMake version is less than 3.9.0, we can't enable LTCG/IPO. This will make the build slightly slower, consider updating your CMake version.")
+    else()
+      cmake_policy(SET CMP0069 NEW)
+      include(CheckIPOSupported)
+      check_ipo_supported(RESULT IPO_IS_SUPPORTED)
+      if(IPO_IS_SUPPORTED)
+        message(STATUS "Enabling LTCG/IPO.")
+        set(CMAKE_INTERPROCEDURAL_OPTIMIZATION ON)
+      else()
+        message(WARNING "LTCG/IPO is not supported, this will make the build slightly slower.")
+      endif()
+    endif()
+  endif()
 endif()
 
 
@@ -65,14 +166,14 @@ endif()
 set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 if(CMAKE_COMPILER_IS_GNUCC OR CMAKE_CXX_COMPILER_ID MATCHES "Clang")
-    include(CheckCXXCompilerFlag)
-    CHECK_CXX_COMPILER_FLAG("-Wall" COMPILER_SUPPORTS_WALL)
-    if(COMPILER_SUPPORTS_WALL)
-      message("Enabling -Wall")
-      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall")
-    endif()
+    include(CheckCXXFlag)
+    check_cxx_flag(-Wall COMPILER_SUPPORTS_WALL)
     set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-switch")
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-switch -Wno-class-memaccess -Wno-invalid-offsetof")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-switch")
+    if(NOT ANDROID)
+      check_cxx_flag(-Wno-class-memaccess COMPILER_SUPPORTS_MEMACCESS)
+      check_cxx_flag(-Wno-invalid-offsetof COMPILER_SUPPORTS_OFFSETOF)
+    endif()
 endif()
 
 
@@ -91,13 +192,25 @@ elseif(${CMAKE_SYSTEM_PROCESSOR} STREQUAL "x86" OR ${CMAKE_SYSTEM_PROCESSOR} STR
   set(CPU_ARCH "x86")
 elseif(${CMAKE_SYSTEM_PROCESSOR} STREQUAL "aarch64")
   set(CPU_ARCH "aarch64")
-elseif(${CMAKE_SYSTEM_PROCESSOR} STREQUAL "arm")
+elseif(${CMAKE_SYSTEM_PROCESSOR} STREQUAL "arm" OR ${CMAKE_SYSTEM_PROCESSOR} STREQUAL "armv7-a")
   set(CPU_ARCH "arm")
 else()
   message(FATAL_ERROR "Unknown system processor: " ${CMAKE_SYSTEM_PROCESSOR})
 endif()
 
 
+# Write binaries to a seperate directory.
+if(WIN32 AND NOT BUILD_LIBRETRO_CORE)
+  # For Windows, use the source directory, except for libretro.
+  set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/bin/${CPU_ARCH}")
+else()
+  set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/bin")
+endif()
+
+# Needed for Linux - put shared libraries in the binary directory.
+set(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}")
+
+
 # Enable threads everywhere.
 set(THREADS_PREFER_PTHREAD_FLAG ON)
 find_package(Threads REQUIRED)
@@ -107,3 +220,7 @@ find_package(Threads REQUIRED)
 enable_testing()
 add_subdirectory(dep)
 add_subdirectory(src)
+
+if(ANDROID AND NOT BUILD_LIBRETRO_CORE)
+  add_subdirectory(android/app/src/cpp)
+endif()

CMakeModules/CheckCXXFlag.cmake

@@ -0,0 +1,8 @@
+include(CheckCXXCompilerFlag)
+
+function(check_cxx_flag flag var)
+    CHECK_CXX_COMPILER_FLAG("-Werror ${flag}" ${var})
+    if(${var})
+       set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${flag}" PARENT_SCOPE)
+    endif()
+endfunction()

CMakeModules/DolphinPostprocessBundle.cmake

@@ -0,0 +1,46 @@
+# This module can be used in two different ways.
+#
+# When invoked as `cmake -P DolphinPostprocessBundle.cmake`, it fixes up an
+# application folder to be standalone. It bundles all required libraries from
+# the system and fixes up library IDs. Any additional shared libraries, like
+# plugins, that are found under Contents/MacOS/ will be made standalone as well.
+#
+# When called with `include(DolphinPostprocessBundle)`, it defines a helper
+# function `dolphin_postprocess_bundle` that sets up the command form of the
+# module as a post-build step.
+
+if(CMAKE_GENERATOR)
+	# Being called as include(DolphinPostprocessBundle), so define a helper function.
+	set(_DOLPHIN_POSTPROCESS_BUNDLE_MODULE_LOCATION "${CMAKE_CURRENT_LIST_FILE}")
+	function(dolphin_postprocess_bundle target)
+		add_custom_command(TARGET ${target} POST_BUILD
+			COMMAND ${CMAKE_COMMAND} -DDOLPHIN_BUNDLE_PATH="$<TARGET_FILE_DIR:${target}>/../.."
+				-P "${_DOLPHIN_POSTPROCESS_BUNDLE_MODULE_LOCATION}"
+		)
+	endfunction()
+	return()
+endif()
+
+get_filename_component(DOLPHIN_BUNDLE_PATH "${DOLPHIN_BUNDLE_PATH}" ABSOLUTE)
+message(STATUS "Fixing up application bundle: ${DOLPHIN_BUNDLE_PATH}")
+
+# Make sure to fix up any additional shared libraries (like plugins) that are
+# needed.
+file(GLOB_RECURSE extra_libs "${DOLPHIN_BUNDLE_PATH}/Contents/MacOS/*.dylib")
+
+# BundleUtilities doesn't support DYLD_FALLBACK_LIBRARY_PATH behavior, which
+# makes it sometimes break on libraries that do weird things with @rpath. Specify
+# equivalent search directories until https://gitlab.kitware.com/cmake/cmake/issues/16625
+# is fixed and in our minimum CMake version.
+set(extra_dirs "/usr/local/lib" "/lib" "/usr/lib")
+
+# BundleUtilities is overly verbose, so disable most of its messages
+function(message)
+	if(NOT ARGV MATCHES "^STATUS;")
+		_message(${ARGV})
+	endif()
+endfunction()
+
+include(BundleUtilities)
+set(BU_CHMOD_BUNDLE_ITEMS ON)
+fixup_bundle("${DOLPHIN_BUNDLE_PATH}" "${extra_libs}" "${extra_dirs}")

CMakeModules/ECMFindModuleHelpers.cmake

@@ -0,0 +1,297 @@
+#.rst:
+# ECMFindModuleHelpers
+# --------------------
+#
+# Helper macros for find modules: ecm_find_package_version_check(),
+# ecm_find_package_parse_components() and
+# ecm_find_package_handle_library_components().
+#
+# ::
+#
+#   ecm_find_package_version_check(<name>)
+#
+# Prints warnings if the CMake version or the project's required CMake version
+# is older than that required by extra-cmake-modules.
+#
+# ::
+#
+#   ecm_find_package_parse_components(<name>
+#       RESULT_VAR <variable>
+#       KNOWN_COMPONENTS <component1> [<component2> [...]]
+#       [SKIP_DEPENDENCY_HANDLING])
+#
+# This macro will populate <variable> with a list of components found in
+# <name>_FIND_COMPONENTS, after checking that all those components are in the
+# list of KNOWN_COMPONENTS; if there are any unknown components, it will print
+# an error or warning (depending on the value of <name>_FIND_REQUIRED) and call
+# return().
+#
+# The order of components in <variable> is guaranteed to match the order they
+# are listed in the KNOWN_COMPONENTS argument.
+#
+# If SKIP_DEPENDENCY_HANDLING is not set, for each component the variable
+# <name>_<component>_component_deps will be checked for dependent components.
+# If <component> is listed in <name>_FIND_COMPONENTS, then all its (transitive)
+# dependencies will also be added to <variable>.
+#
+# ::
+#
+#   ecm_find_package_handle_library_components(<name>
+#       COMPONENTS <component> [<component> [...]]
+#       [SKIP_DEPENDENCY_HANDLING])
+#       [SKIP_PKG_CONFIG])
+#
+# Creates an imported library target for each component.  The operation of this
+# macro depends on the presence of a number of CMake variables.
+#
+# The <name>_<component>_lib variable should contain the name of this library,
+# and <name>_<component>_header variable should contain the name of a header
+# file associated with it (whatever relative path is normally passed to
+# '#include'). <name>_<component>_header_subdir variable can be used to specify
+# which subdirectory of the include path the headers will be found in.
+# ecm_find_package_components() will then search for the library
+# and include directory (creating appropriate cache variables) and create an
+# imported library target named <name>::<component>.
+#
+# Additional variables can be used to provide additional information:
+#
+# If SKIP_PKG_CONFIG, the <name>_<component>_pkg_config variable is set, and
+# pkg-config is found, the pkg-config module given by
+# <name>_<component>_pkg_config will be searched for and used to help locate the
+# library and header file.  It will also be used to set
+# <name>_<component>_VERSION.
+#
+# Note that if version information is found via pkg-config,
+# <name>_<component>_FIND_VERSION can be set to require a particular version
+# for each component.
+#
+# If SKIP_DEPENDENCY_HANDLING is not set, the INTERFACE_LINK_LIBRARIES property
+# of the imported target for <component> will be set to contain the imported
+# targets for the components listed in <name>_<component>_component_deps.
+# <component>_FOUND will also be set to false if any of the compoments in
+# <name>_<component>_component_deps are not found.  This requires the components
+# in <name>_<component>_component_deps to be listed before <component> in the
+# COMPONENTS argument.
+#
+# The following variables will be set:
+#
+# ``<name>_TARGETS``
+#   the imported targets
+# ``<name>_LIBRARIES``
+#   the found libraries
+# ``<name>_INCLUDE_DIRS``
+#   the combined required include directories for the components
+# ``<name>_DEFINITIONS``
+#   the "other" CFLAGS provided by pkg-config, if any
+# ``<name>_VERSION``
+#   the value of ``<name>_<component>_VERSION`` for the first component that
+#   has this variable set (note that components are searched for in the order
+#   they are passed to the macro), although if it is already set, it will not
+#   be altered
+#
+# Note that these variables are never cleared, so if
+# ecm_find_package_handle_library_components() is called multiple times with
+# different components (typically because of multiple find_package() calls) then
+# ``<name>_TARGETS``, for example, will contain all the targets found in any
+# call (although no duplicates).
+#
+# Since pre-1.0.0.
+
+#=============================================================================
+# Copyright 2014 Alex Merry <alex.merry@kde.org>
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# 1. Redistributions of source code must retain the copyright
+#    notice, this list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the copyright
+#    notice, this list of conditions and the following disclaimer in the
+#    documentation and/or other materials provided with the distribution.
+# 3. The name of the author may not be used to endorse or promote products
+#    derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+include(CMakeParseArguments)
+
+macro(ecm_find_package_version_check module_name)
+    if(CMAKE_VERSION VERSION_LESS 2.8.12)
+        message(FATAL_ERROR "CMake 2.8.12 is required by Find${module_name}.cmake")
+    endif()
+    if(CMAKE_MINIMUM_REQUIRED_VERSION VERSION_LESS 2.8.12)
+        message(AUTHOR_WARNING "Your project should require at least CMake 2.8.12 to use Find${module_name}.cmake")
+    endif()
+endmacro()
+
+macro(ecm_find_package_parse_components module_name)
+    set(ecm_fppc_options SKIP_DEPENDENCY_HANDLING)
+    set(ecm_fppc_oneValueArgs RESULT_VAR)
+    set(ecm_fppc_multiValueArgs KNOWN_COMPONENTS DEFAULT_COMPONENTS)
+    cmake_parse_arguments(ECM_FPPC "${ecm_fppc_options}" "${ecm_fppc_oneValueArgs}" "${ecm_fppc_multiValueArgs}" ${ARGN})
+
+    if(ECM_FPPC_UNPARSED_ARGUMENTS)
+        message(FATAL_ERROR "Unexpected arguments to ecm_find_package_parse_components: ${ECM_FPPC_UNPARSED_ARGUMENTS}")
+    endif()
+    if(NOT ECM_FPPC_RESULT_VAR)
+        message(FATAL_ERROR "Missing RESULT_VAR argument to ecm_find_package_parse_components")
+    endif()
+    if(NOT ECM_FPPC_KNOWN_COMPONENTS)
+        message(FATAL_ERROR "Missing KNOWN_COMPONENTS argument to ecm_find_package_parse_components")
+    endif()
+    if(NOT ECM_FPPC_DEFAULT_COMPONENTS)
+        set(ECM_FPPC_DEFAULT_COMPONENTS ${ECM_FPPC_KNOWN_COMPONENTS})
+    endif()
+
+    if(${module_name}_FIND_COMPONENTS)
+        set(ecm_fppc_requestedComps ${${module_name}_FIND_COMPONENTS})
+
+        if(NOT ECM_FPPC_SKIP_DEPENDENCY_HANDLING)
+            # Make sure deps are included
+            foreach(ecm_fppc_comp ${ecm_fppc_requestedComps})
+                foreach(ecm_fppc_dep_comp ${${module_name}_${ecm_fppc_comp}_component_deps})
+                    list(FIND ecm_fppc_requestedComps "${ecm_fppc_dep_comp}" ecm_fppc_index)
+                    if("${ecm_fppc_index}" STREQUAL "-1")
+                        if(NOT ${module_name}_FIND_QUIETLY)
+                            message(STATUS "${module_name}: ${ecm_fppc_comp} requires ${${module_name}_${ecm_fppc_comp}_component_deps}")
+                        endif()
+                        list(APPEND ecm_fppc_requestedComps "${ecm_fppc_dep_comp}")
+                    endif()
+                endforeach()
+            endforeach()
+        else()
+            message(STATUS "Skipping dependency handling for ${module_name}")
+        endif()
+        list(REMOVE_DUPLICATES ecm_fppc_requestedComps)
+
+        # This makes sure components are listed in the same order as
+        # KNOWN_COMPONENTS (potentially important for inter-dependencies)
+        set(${ECM_FPPC_RESULT_VAR})
+        foreach(ecm_fppc_comp ${ECM_FPPC_KNOWN_COMPONENTS})
+            list(FIND ecm_fppc_requestedComps "${ecm_fppc_comp}" ecm_fppc_index)
+            if(NOT "${ecm_fppc_index}" STREQUAL "-1")
+                list(APPEND ${ECM_FPPC_RESULT_VAR} "${ecm_fppc_comp}")
+                list(REMOVE_AT ecm_fppc_requestedComps ${ecm_fppc_index})
+            endif()
+        endforeach()
+        # if there are any left, they are unknown components
+        if(ecm_fppc_requestedComps)
+            set(ecm_fppc_msgType STATUS)
+            if(${module_name}_FIND_REQUIRED)
+                set(ecm_fppc_msgType FATAL_ERROR)
+            endif()
+            if(NOT ${module_name}_FIND_QUIETLY)
+                message(${ecm_fppc_msgType} "${module_name}: requested unknown components ${ecm_fppc_requestedComps}")
+            endif()
+            return()
+        endif()
+    else()
+        set(${ECM_FPPC_RESULT_VAR} ${ECM_FPPC_DEFAULT_COMPONENTS})
+    endif()
+endmacro()
+
+macro(ecm_find_package_handle_library_components module_name)
+    set(ecm_fpwc_options SKIP_PKG_CONFIG SKIP_DEPENDENCY_HANDLING)
+    set(ecm_fpwc_oneValueArgs)
+    set(ecm_fpwc_multiValueArgs COMPONENTS)
+    cmake_parse_arguments(ECM_FPWC "${ecm_fpwc_options}" "${ecm_fpwc_oneValueArgs}" "${ecm_fpwc_multiValueArgs}" ${ARGN})
+
+    if(ECM_FPWC_UNPARSED_ARGUMENTS)
+        message(FATAL_ERROR "Unexpected arguments to ecm_find_package_handle_components: ${ECM_FPWC_UNPARSED_ARGUMENTS}")
+    endif()
+    if(NOT ECM_FPWC_COMPONENTS)
+        message(FATAL_ERROR "Missing COMPONENTS argument to ecm_find_package_handle_components")
+    endif()
+
+    include(FindPackageHandleStandardArgs)
+    find_package(PkgConfig)
+    foreach(ecm_fpwc_comp ${ECM_FPWC_COMPONENTS})
+        set(ecm_fpwc_dep_vars)
+        set(ecm_fpwc_dep_targets)
+        if(NOT SKIP_DEPENDENCY_HANDLING)
+            foreach(ecm_fpwc_dep ${${module_name}_${ecm_fpwc_comp}_component_deps})
+                list(APPEND ecm_fpwc_dep_vars "${module_name}_${ecm_fpwc_dep}_FOUND")
+                list(APPEND ecm_fpwc_dep_targets "${module_name}::${ecm_fpwc_dep}")
+            endforeach()
+        endif()
+
+        if(NOT ECM_FPWC_SKIP_PKG_CONFIG AND ${module_name}_${ecm_fpwc_comp}_pkg_config)
+            pkg_check_modules(PKG_${module_name}_${ecm_fpwc_comp} QUIET
+                              ${${module_name}_${ecm_fpwc_comp}_pkg_config})
+        endif()
+
+        find_path(${module_name}_${ecm_fpwc_comp}_INCLUDE_DIR
+            NAMES ${${module_name}_${ecm_fpwc_comp}_header}
+            HINTS ${PKG_${module_name}_${ecm_fpwc_comp}_INCLUDE_DIRS}
+            PATH_SUFFIXES ${${module_name}_${ecm_fpwc_comp}_header_subdir}
+        )
+        find_library(${module_name}_${ecm_fpwc_comp}_LIBRARY
+            NAMES ${${module_name}_${ecm_fpwc_comp}_lib}
+            HINTS ${PKG_${module_name}_${ecm_fpwc_comp}_LIBRARY_DIRS}
+        )
+
+        set(${module_name}_${ecm_fpwc_comp}_VERSION "${PKG_${module_name}_${ecm_fpwc_comp}_VERSION}")
+        if(NOT ${module_name}_VERSION)
+            set(${module_name}_VERSION ${${module_name}_${ecm_fpwc_comp}_VERSION})
+        endif()
+
+        find_package_handle_standard_args(${module_name}_${ecm_fpwc_comp}
+            FOUND_VAR
+                ${module_name}_${ecm_fpwc_comp}_FOUND
+            REQUIRED_VARS
+                ${module_name}_${ecm_fpwc_comp}_LIBRARY
+                ${module_name}_${ecm_fpwc_comp}_INCLUDE_DIR
+                ${ecm_fpwc_dep_vars}
+            VERSION_VAR
+                ${module_name}_${ecm_fpwc_comp}_VERSION
+            )
+
+        mark_as_advanced(
+            ${module_name}_${ecm_fpwc_comp}_LIBRARY
+            ${module_name}_${ecm_fpwc_comp}_INCLUDE_DIR
+        )
+
+        if(${module_name}_${ecm_fpwc_comp}_FOUND)
+            list(APPEND ${module_name}_LIBRARIES
+                        "${${module_name}_${ecm_fpwc_comp}_LIBRARY}")
+            list(APPEND ${module_name}_INCLUDE_DIRS
+                        "${${module_name}_${ecm_fpwc_comp}_INCLUDE_DIR}")
+            set(${module_name}_DEFINITIONS
+                    ${${module_name}_DEFINITIONS}
+                    ${PKG_${module_name}_${ecm_fpwc_comp}_DEFINITIONS})
+            if(NOT TARGET ${module_name}::${ecm_fpwc_comp})
+                add_library(${module_name}::${ecm_fpwc_comp} UNKNOWN IMPORTED)
+                set_target_properties(${module_name}::${ecm_fpwc_comp} PROPERTIES
+                    IMPORTED_LOCATION "${${module_name}_${ecm_fpwc_comp}_LIBRARY}"
+                    INTERFACE_COMPILE_OPTIONS "${PKG_${module_name}_${ecm_fpwc_comp}_DEFINITIONS}"
+                    INTERFACE_INCLUDE_DIRECTORIES "${${module_name}_${ecm_fpwc_comp}_INCLUDE_DIR}"
+                    INTERFACE_LINK_LIBRARIES "${ecm_fpwc_dep_targets}"
+                )
+            endif()
+            list(APPEND ${module_name}_TARGETS
+                        "${module_name}::${ecm_fpwc_comp}")
+        endif()
+    endforeach()
+    if(${module_name}_LIBRARIES)
+        list(REMOVE_DUPLICATES ${module_name}_LIBRARIES)
+    endif()
+    if(${module_name}_INCLUDE_DIRS)
+        list(REMOVE_DUPLICATES ${module_name}_INCLUDE_DIRS)
+    endif()
+    if(${module_name}_DEFINITIONS)
+        list(REMOVE_DUPLICATES ${module_name}_DEFINITIONS)
+    endif()
+    if(${module_name}_TARGETS)
+        list(REMOVE_DUPLICATES ${module_name}_TARGETS)
+    endif()
+endmacro()

CMakeModules/ECMFindModuleHelpersStub.cmake

@@ -0,0 +1 @@
+include(${CMAKE_CURRENT_LIST_DIR}/ECMFindModuleHelpers.cmake)

CMakeModules/FindEGL.cmake

@@ -0,0 +1,172 @@
+#.rst:
+# FindEGL
+# -------
+#
+# Try to find EGL.
+#
+# This will define the following variables:
+#
+# ``EGL_FOUND``
+#     True if (the requested version of) EGL is available
+# ``EGL_VERSION``
+#     The version of EGL; note that this is the API version defined in the
+#     headers, rather than the version of the implementation (eg: Mesa)
+# ``EGL_LIBRARIES``
+#     This can be passed to target_link_libraries() instead of the ``EGL::EGL``
+#     target
+# ``EGL_INCLUDE_DIRS``
+#     This should be passed to target_include_directories() if the target is not
+#     used for linking
+# ``EGL_DEFINITIONS``
+#     This should be passed to target_compile_options() if the target is not
+#     used for linking
+#
+# If ``EGL_FOUND`` is TRUE, it will also define the following imported target:
+#
+# ``EGL::EGL``
+#     The EGL library
+#
+# In general we recommend using the imported target, as it is easier to use.
+# Bear in mind, however, that if the target is in the link interface of an
+# exported library, it must be made available by the package config file.
+#
+# Since pre-1.0.0.
+
+#=============================================================================
+# Copyright 2014 Alex Merry <alex.merry@kde.org>
+# Copyright 2014 Martin Gräßlin <mgraesslin@kde.org>
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# 1. Redistributions of source code must retain the copyright
+#    notice, this list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the copyright
+#    notice, this list of conditions and the following disclaimer in the
+#    documentation and/or other materials provided with the distribution.
+# 3. The name of the author may not be used to endorse or promote products
+#    derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#=============================================================================
+
+include(${CMAKE_CURRENT_LIST_DIR}/ECMFindModuleHelpersStub.cmake)
+include(CheckCXXSourceCompiles)
+include(CMakePushCheckState)
+
+ecm_find_package_version_check(EGL)
+
+# Use pkg-config to get the directories and then use these values
+# in the FIND_PATH() and FIND_LIBRARY() calls
+find_package(PkgConfig)
+pkg_check_modules(PKG_EGL QUIET egl)
+
+set(EGL_DEFINITIONS ${PKG_EGL_CFLAGS_OTHER})
+
+find_path(EGL_INCLUDE_DIR
+    NAMES
+        EGL/egl.h
+    HINTS
+        ${PKG_EGL_INCLUDE_DIRS}
+)
+find_library(EGL_LIBRARY
+    NAMES
+        EGL
+    HINTS
+        ${PKG_EGL_LIBRARY_DIRS}
+)
+
+# NB: We do *not* use the version information from pkg-config, as that
+#     is the implementation version (eg: the Mesa version)
+if(EGL_INCLUDE_DIR)
+    # egl.h has defines of the form EGL_VERSION_x_y for each supported
+    # version; so the header for EGL 1.1 will define EGL_VERSION_1_0 and
+    # EGL_VERSION_1_1.  Finding the highest supported version involves
+    # finding all these defines and selecting the highest numbered.
+    file(READ "${EGL_INCLUDE_DIR}/EGL/egl.h" _EGL_header_contents)
+    string(REGEX MATCHALL
+        "[ \t]EGL_VERSION_[0-9_]+"
+        _EGL_version_lines
+        "${_EGL_header_contents}"
+    )
+    unset(_EGL_header_contents)
+    foreach(_EGL_version_line ${_EGL_version_lines})
+        string(REGEX REPLACE
+            "[ \t]EGL_VERSION_([0-9_]+)"
+            "\\1"
+            _version_candidate
+            "${_EGL_version_line}"
+        )
+        string(REPLACE "_" "." _version_candidate "${_version_candidate}")
+        if(NOT DEFINED EGL_VERSION OR EGL_VERSION VERSION_LESS _version_candidate)
+            set(EGL_VERSION "${_version_candidate}")
+        endif()
+    endforeach()
+    unset(_EGL_version_lines)
+endif()
+
+cmake_push_check_state(RESET)
+list(APPEND CMAKE_REQUIRED_LIBRARIES "${EGL_LIBRARY}")
+list(APPEND CMAKE_REQUIRED_INCLUDES "${EGL_INCLUDE_DIR}")
+
+check_cxx_source_compiles("
+#include <EGL/egl.h>
+
+int main(int argc, char *argv[]) {
+    EGLint x = 0; EGLDisplay dpy = 0; EGLContext ctx = 0;
+    eglDestroyContext(dpy, ctx);
+}" HAVE_EGL)
+
+cmake_pop_check_state()
+
+set(required_vars EGL_INCLUDE_DIR HAVE_EGL)
+if(NOT EMSCRIPTEN)
+    list(APPEND required_vars EGL_LIBRARY)
+endif()
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(EGL
+    FOUND_VAR
+        EGL_FOUND
+    REQUIRED_VARS
+        ${required_vars}
+    VERSION_VAR
+        EGL_VERSION
+)
+
+if(EGL_FOUND AND NOT TARGET EGL::EGL)
+    if (EMSCRIPTEN)
+        add_library(EGL::EGL INTERFACE IMPORTED)
+        # Nothing further to be done, system include paths have headers and linkage is implicit.
+    else()
+        add_library(EGL::EGL UNKNOWN IMPORTED)
+        set_target_properties(EGL::EGL PROPERTIES
+            IMPORTED_LOCATION "${EGL_LIBRARY}"
+            INTERFACE_COMPILE_OPTIONS "${EGL_DEFINITIONS}"
+            INTERFACE_INCLUDE_DIRECTORIES "${EGL_INCLUDE_DIR}"
+        )
+    endif()
+endif()
+
+mark_as_advanced(EGL_LIBRARY EGL_INCLUDE_DIR HAVE_EGL)
+
+# compatibility variables
+set(EGL_LIBRARIES ${EGL_LIBRARY})
+set(EGL_INCLUDE_DIRS ${EGL_INCLUDE_DIR})
+set(EGL_VERSION_STRING ${EGL_VERSION})
+
+include(FeatureSummary)
+set_package_properties(EGL PROPERTIES
+    URL "https://www.khronos.org/egl/"
+    DESCRIPTION "A platform-agnostic mechanism for creating rendering surfaces for use with other graphics libraries, such as OpenGL|ES and OpenVG."
+)

CMakeModules/FindOpenSLES.cmake

@@ -0,0 +1,30 @@
+# - Try to find OpenSLES
+# Once done this will define
+#  OPENSLES_FOUND - System has OpenSLES
+#  OPENSLES_INCLUDE_DIR - The OpenSLES include directory
+#  OPENSLES_LIBRARY - The library needed to use OpenSLES
+# An imported target OpenSLES::OpenSLES is also created, prefer this
+
+find_path(OPENSLES_INCLUDE_DIR
+  NAMES SLES/OpenSLES.h
+)
+
+find_library(OPENSLES_LIBRARY
+  NAMES OpenSLES
+)
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(OpenSLES  DEFAULT_MSG
+                                  OPENSLES_LIBRARY OPENSLES_INCLUDE_DIR)
+
+if(OpenSLES_FOUND)
+  if(NOT TARGET OpenSLES::OpenSLES)
+    add_library(OpenSLES::OpenSLES UNKNOWN IMPORTED)
+    set_target_properties(OpenSLES::OpenSLES PROPERTIES
+      IMPORTED_LOCATION ${OPENSLES_LIBRARY}
+      INTERFACE_INCLUDE_DIRECTORIES ${OPENSLES_INCLUDE_DIR}
+    )
+  endif()
+endif()
+
+mark_as_advanced(OPENSLES_INCLUDE_DIR OPENSLES_LIBRARY )

CMakeModules/aarch64-cross-toolchain.cmake

@@ -0,0 +1,14 @@
+# Source: https://github.com/stenzek/duckstation/issues/626#issuecomment-660718306
+
+# Target system
+SET(CMAKE_SYSTEM_NAME Linux)
+SET(CMAKE_SYSTEM_PROCESSOR aarch64)
+SET(CMAKE_SYSTEM_VERSION 1)
+set(CMAKE_CROSSCOMPILING TRUE)
+
+# Cross compiler
+SET(CMAKE_C_COMPILER   aarch64-linux-gnu-gcc)
+SET(CMAKE_CXX_COMPILER aarch64-linux-gnu-g++)
+set(CMAKE_LIBRARY_ARCHITECTURE aarch64-linux-gnu)
+
+set(THREADS_PTHREAD_ARG "0" CACHE STRING "Result from TRY_RUN" FORCE)

CONTRIBUTORS.md

@@ -0,0 +1,47 @@
+# DuckStation Contributors List
+The following people have contributed to the project in some way, and are credited here.
+
+## Code Contributions
+- Connor McLaughlin - @stenzek
+- @ggrtk
+- @CookiePLMonster
+
+## Translators
+- Anderson Cardoso - Portuguese (Br)
+- @bajolzas - Portuguese (Pt)
+- posix - @Richard-L - German
+- @phoe-nix, @zkdpower - Chinese (Simplified)
+- Sorer - @MojoJojoDojo - Hebrew
+- Hipnosis183 - Spanish
+- @RaydenX93 - Italian
+- @r57zone - Russian
+- @DenSinH - Dutch
+- @BenjaminSiskoo - French
+
+## Game Compatibility Database
+ - @Zet-sensei
+ - @DarkFrost89
+ - @macattack222
+ - @HeroponRikiBestest
+ - @picili
+ - @andercard0
+ - @Abbanon
+ - @Shideravan
+ - @mirrornoir
+ - @pryon
+ - @MojoJojoDojo
+ - @heckez-sys
+ - @Damaniel
+ - @RaydenX93
+ - @gp2man
+ - @Richard-L
+ - @pan2marumie3
+ - @CookiePLMonster
+
+## Special Thanks
+The following people did not directly contribute to the emulator, but it would not be in the state if not for them.
+ - nocash (https://problemkaputt.de/) for fantastic documentation.
+ - @PeterLemon for great simple test programs.
+ - amidog for CPU, GTE and GPU test programs.
+ - Jakub Czekański - @JaCzekanski - for collaboration on hardware tests.
+

README.md

@@ -1,78 +1,317 @@
-# DuckStation - PlayStation (PSX) Emulator
-![Main Window Screenshot](https://raw.githubusercontent.com/stenzek/duckstation/md-images/main.png)
+# DuckStation - PlayStation 1, aka. PSX Emulator
+[Latest News](#latest-news) | [Features](#features) | [Screenshots](#screenshots) | [Downloading and Running](#downloading-and-running) | [Libretro Core](#libretro-core) | [Building](#building) | [Disclaimers](#disclaimers)
+
+**Discord Server:** https://discord.gg/Buktv3t
+
+**Latest Windows, Linux (AppImage), and Libretro Builds:** https://github.com/stenzek/duckstation/releases/tag/latest
+
+**Game Compatibility List:** https://docs.google.com/spreadsheets/d/1H66MxViRjjE5f8hOl5RQmF5woS1murio2dsLn14kEqo/edit?usp=sharing
+
+DuckStation is an simulator/emulator of the Sony PlayStation(TM) console, focusing on playability, speed, and long-term maintainability. The goal is to be as accurate as possible while maintaining performance suitable for low-end devices. "Hack" options are discouraged, the default configuration should support all playable games with only some of the enhancements having compatibility issues.
+
+A "BIOS" ROM image is required to to start the emulator and to play games. You can use an image from any hardware version or region, although mismatching game regions and BIOS regions may have compatibility issues. A ROM image is not provided with the emulator for legal reasons, you should dump this from your own console using Caetla or other means.
+
+## Latest News
+
+- 2020/10/05: CD-ROM read speedup enhancement added.
+- 2020/09/30: CPU overclocking is now supported. Use with caution as it will break games and increase system requirements. It can be set globally or per-game.
+- 2020/09/25: Cheat support added for libretro core.
+- 2020/09/23: Game covers added to Qt frontend (see [Adding Game Covers](https://github.com/stenzek/duckstation/wiki/Adding-Game-Covers)).
+- 2020/09/19: Memory card importer/editor added to Qt frontend.
+- 2020/09/13: Support for chaining post processing shaders added.
+- 2020/09/12: Additional texture filtering options added.
+- 2020/09/09: Basic cheat support added. Not all instructions/commands are supported yet.
+- 2020/09/01: Many additional user settings available, including memory cards and enhancements. Now you can set these per-game.
+- 2020/08/25: Automated builds for macOS now available.
+- 2020/08/22: XInput controller backend added.
+- 2020/08/20: Per-game setting overrides added. Mostly for compatibility, but some options are customizable.
+- 2020/08/19: CPU PGXP mode added. It is very slow and incompatible with the recompiler, only use for games which need it.
+- 2020/08/15: Playlist support/single memcard for multi-disc games in Qt frontend added.
+- 2020/08/07: Automatic updater for standalone Windows builds.
+- 2020/08/01: Initial PGXP (geometry/perspective correction) support.
+- 2020/07/28: Qt frontend supports displaying interface in multiple languages.
+- 2020/07/23: m3u multi-disc support for libretro core.
+- 2020/07/22: Support multiple bindings for each controller button/axis.
+- 2020/07/18: Widescreen hack enhancement added.
+- 2020/07/04: Vulkan renderer now available in libretro core.
+- 2020/07/02: Now available as a libretro core.
+- 2020/07/01: Lightgun support with custom crosshairs.
+- 2020/06/19: Vulkan hardware renderer added.
 
 ## Features
- - CPU Recompiler/JIT (x86_64 work-in-progress, AArch64 planned)
- - Hardware (D3D11 and OpenGL) and software rendering
- - Upscaling and true colour (24-bit) in hardware renderers
+
+DuckStation features a fully-featured frontend built using Qt (pictured), as well as a simplified frontend based on SDL and Dear ImGui. An Android version has been started, but is not yet feature complete.
+
+<p align="center">
+  <img src="https://raw.githubusercontent.com/stenzek/duckstation/md-images/main-qt.png" alt="Main Window Screenshot" />
+</p>
+
+Other features include:
+
+ - CPU Recompiler/JIT (x86-64 and AArch64)
+ - Hardware (D3D11, OpenGL, Vulkan) and software rendering
+ - Upscaling, texture filtering, and true colour (24-bit) in hardware renderers
+ - PGXP for geometry precision and texture correction
+ - Post processing shader chains
  - "Fast boot" for skipping BIOS splash/intro
  - Save state support
- - Windows and Linux support - macOS may work, but not actively maintained
- - Currently only .bin/.cue disc image formats are supported. Additional formats are planned
+ - Windows, Linux, **highly experimental** macOS support
+ - Supports bin/cue images, raw bin/img files, and MAME CHD formats.
  - Direct booting of homebrew executables
+ - Direct loading of Portable Sound Format (psf) files
+ - Digital and analog controllers for input (rumble is forwarded to host)
+ - Namco GunCon lightgun support (simulated with mouse)
+ - NeGcon support
+ - Qt and SDL frontends for desktop
+ - libretro core for Windows and Linux
+ - Automatic updates for Windows builds
+ - Automatic content scanning - game titles/regions are provided by redump.org
+ - Optional automatic switching of memory cards for each game
+ - Supports loading cheats from libretro or PCSXR format lists
+ - Memory card editor and save importer
+ - Emulated CPU overclocking
 
 ## System Requirements
- - A CPU faster than a potato.
- - For the hardware renderers, a GPU capable of OpenGL 3.0/OpenGL ES 3.0/Direct3D 11 Feature Level 10.0 and above. So, basically anything made in the last 10 years or so.
- - SDL-compatible game controller (e.g. XB360/XBOne)
+ - A CPU faster than a potato. But it needs to be 64-bit (either x86_64 or AArch64/ARMv8) otherwise you won't get a recompiler and it'll be slow. There are no plans to add any 32-bit recompilers.
+ - For the hardware renderers, a GPU capable of OpenGL 3.0/OpenGL ES 3.0/Direct3D 11 Feature Level 10.0 (or Vulkan 1.0) and above. So, basically anything made in the last 10 years or so.
+ - SDL or XInput compatible game controller (e.g. XB360/XBOne). DualShock 3 users on Windows will need to install the official DualShock 3 drivers included as part of PlayStation Now.
+   - Optional [SDL game contoller database files](#sdl-game-controller-database) are also supported.
+
+## Downloading and running
+Binaries of DuckStation for Windows 64-bit, x86_64 Linux x86_64 (in AppImage format), and Android ARMv8/AArch64 are available via GitHub Releases and are automatically built with every commit/push. Binaries or packages distributed through other sources may be out of date and are not supported by the developer.
+
+### Windows
+
+**Windows 10 is the only version of Windows supported by the developer.** Windows 7/8 may work, but is not supported. I am aware some users are still using Windows 7, but it is no longer supported by Microsoft and too much effort to get running on modern hardware. Game bugs are unlikely to be affected by the operating system, however performance issues should be verified on Windows 10 before reporting.
+
+To download:
+ - Go to https://github.com/stenzek/duckstation/releases/tag/latest, and download the Windows x64 build. This is a zip archive containing the prebuilt binary.
+ - Alternatively, direct download link: https://github.com/stenzek/duckstation/releases/download/latest/duckstation-windows-x64-release.zip
+ - Extract the archive **to a subdirectory**. The archive has no root subdirectory, so extracting to the current directory will drop a bunch of files in your download directory if you do not extract to a subdirectory.
+
+Once downloaded and extracted, you can launch the Qt frontend from `duckstation-qt-x64-ReleaseLTCG.exe`, or the SDL frontend from `duckstation-sdl-x64-ReleaseLTCG.exe`.
+To set up:
+1. Either configure the path to a BIOS image in the settings, or copy one or more PlayStation BIOS images to the bios/ subdirectory. On Windows, by default this will be located in `C:\Users\YOUR_USERNAME\Documents\DuckStation\bios`. If you don't want to use the Documents directory to save the BIOS/memory cards/etc, you can use portable mode. See [User directory](#user-directories).
+2. If using the SDL frontend, add the directories containing your disc images by clicking `Settings->Add Game Directory`.
+2. Select a game from the list, or open a disc image file and enjoy.
+
+**If you get an error about `vcruntime140_1.dll` being missing, you will need to update your Visual C++ runtime.** You can do that from this page: https://support.microsoft.com/en-au/help/2977003/the-latest-supported-visual-c-downloads. Specifically, you want the x64 runtime, which can be downloaded from https://aka.ms/vs/16/release/vc_redist.x64.exe.
+
+The Qt frontend includes an automatic update checker. Builds downloaded after 2020/08/07 will automatically check for updates each time the emulator starts, this can be disabled in Settings. Alternatively, you can force an update check by clicking `Help->Check for Updates`.
+
+### Linux
+
+Prebuilt binaries for 64-bit Linux distros are available for download in the AppImage format. However, these binaries may be incompatible with older Linux distros (e.g. Ubuntu distros earlier than 18.04.4 LTS) due to older distros not providing newer versions of the C/C++ standard libraries required by the AppImage binaries.
+
+**Linux users are encouraged to build from source when possible and optionally create their own AppImages for features such as desktop integration if desired.**
+
+To download:
+ - Go to https://github.com/stenzek/duckstation/releases/tag/latest, and download either `duckstation-qt-x64.AppImage` or `duckstation-sdl-x64.AppImage` for your desired frontend. Keep in mind that keyboard/controller bindings are currently not customizable through the SDL frontend and should be customized through the Qt frontend instead.
+ - Run `chmod a+x` on the downloaded AppImage -- following this step, the AppImage can be run like a typical executable.
+ - Optionally use a program such as [appimaged](https://github.com/AppImage/appimaged) or [AppImageLauncher](https://github.com/TheAssassin/AppImageLauncher) for desktop integration. [AppImageUpdate](https://github.com/AppImage/AppImageUpdate) can be used alongside appimaged to easily update your DuckStation AppImage.
+
+### macOS
+
+To download:
+ - Go to https://github.com/stenzek/duckstation/releases/tag/latest, and download the Mac build. This is a zip archive containing the prebuilt binary.
+ - Alternatively, direct download link: https://github.com/stenzek/duckstation/releases/download/latest/duckstation-mac-release.zip
+ - Extract the zip archive. If you're using Safari, apparently this happens automatically. This will give you DuckStation.app.
+ - Right click DuckStation.app, and click Open. As the package is not signed (Mac certificates are expensive), you must do this the first time you open it. Subsequent runs can be done by double-clicking.
+
+macOS support is considered experimental and not actively supported by the developer; the builds are provided here as a courtesy. Please feel free to submit issues, but it may be some time before
+they are investigated.
+
+**macOS builds do not support automatic updates yet.** If there is sufficient demand, this may be something I will consider.
+
+
+### Android
+
+A prebuilt APK is now available for Android. However, please keep in mind that the Android version is not yet feature complete, it is more of a preview of things to come. You will need a device running a 64-bit AArch64 userland (anything made in the last few years).
+
+Download link: https://github.com/stenzek/duckstation/releases/download/latest/duckstation-android-aarch64.apk
+
+The main limitations are:
+ - User directory is currently hardcoded to `<external storage path>/duckstation`. This is usually `/storage/emulated/0` or `/sdcard`'. So BIOS files go in `/sdcard/duckstation/bios`.
+ - Lack of options in menu when emulator is running.
+ - Performance is currently lower than the desktop x86_64 counterpart.
+
+To use:
+ - Install and run the app for the first time.
+ - This will create `/sdcard/duckstation`. Drop your BIOS files in `/sdcard/duckstation/bios`.
+ - Add game directories by hitting the `+` icon and selecting a directory.
+ - Tap a game to start.
+
+
+### Title Information
+
+PlayStation game discs do not contain title information. For game titles, we use the redump.org database cross-referenced with the game's executable code.
+This database can be manually downloaded and added as `cache/redump.dat`, or automatically downloaded by going into the `Game List Settings` in the Qt Frontend,
+and clicking `Update Redump Database`.
+
+### Region detection and BIOS images
+By default, DuckStation will emulate the region check present in the CD-ROM controller of the console. This means that when the region of the console does not match the disc, it will refuse to boot, giving a "Please insert PlayStation CD-ROM" message. DuckStation supports automatic detection disc regions, and if you set the console region to auto-detect as well, this should never be a problem.
+
+If you wish to use auto-detection, you do not need to change the BIOS path each time you switch regions. Simply place the BIOS images for the other regions in the **same directory** as the configured image. This will probably be in the `bios/` subdirectory. Then set the console region to "Auto-Detect", and everything should work fine. The console/log will tell you if you are missing the image for the disc's region.
+
+Some users have been confused by the "BIOS Path" option, the reason it is a path and not a directory is so that an unknown BIOS revision can be used/tested.
+
+Alternatively, the region checking can be disabled in the console options tab. This is the only way to play unlicensed games or homebrew which does not supply a correct region string on the disc, aside from using fastboot which skips the check entirely.
+
+Mismatching the disc and console regions with the check disabled is supported, but may break games if they are patching the BIOS and expecting specific content.
+
+### LibCrypt protection and SBI files
+
+A number of PAL region games use LibCrypt protection, requiring additional CD subchannel information to run properly. For these games, make sure that the CD image and its corresponding SBI (.sbi) file have the same name and are placed in the same directory. DuckStation will automatically load the SBI file when it is found next to the CD image.
 
 ## Building
-Clone the respository with submodules (`git clone --recursive` or `git clone` and `git submodule update --init`).
 
 ### Windows
 Requirements:
  - Visual Studio 2019
-
-1. Open the Visual Studio solution `duckstation.sln` in the root, or "Open Folder" for cmake build.
-2. Build, binaries are located in `bin/x64`.
-3. Copy the DLL files from `dep/msvc/bin64` to the binary directory.
-4. Run `duckstation-x64-Release.exe` or whichever config you used.
+ 
+1. Clone the respository with submodules (`git clone --recursive` or `git clone` and `git submodule update --init`).
+2. Open the Visual Studio solution `duckstation.sln` in the root, or "Open Folder" for cmake build.
+3. Build solution.
+4. Binaries are located in `bin/x64`.
+5. Run `duckstation-sdl-x64-Release.exe`/`duckstation-qt-x64-Release.exe` or whichever config you used.
 
 ### Linux
+Requirements (Debian/Ubuntu package names):
+ - CMake (`cmake`)
+ - SDL2 (`libsdl2-dev`)
+ - GTK2.0 for file selector (`libgtk2.0-dev`)
+ - Qt 5 (`qtbase5-dev`, `qtbase5-private-dev`, `qtbase5-dev-tools`, `qttools5-dev`)
+ - Optional for faster building: Ninja (`ninja-build`)
+
+1. Clone the repository. Submodules aren't necessary, there is only one and it is only used for Windows.
+2. Create a build directory, either in-tree or elsewhere.
+3. Run cmake to configure the build system. Assuming a build subdirectory of `build-release`, `cd build-release && cmake -DCMAKE_BUILD_TYPE=Release -GNinja ..`.
+4. Compile the source code. For the example above, run `ninja`.
+5. Run the binary, located in the build directory under `bin/duckstation-sdl`, or `bin/duckstation-qt`.
+
+### macOS
+**NOTE:** macOS is highly experimental and not tested by the developer. Use at your own risk, things may be horribly broken.
+
 Requirements:
- - CMake
- - SDL2
+ - CMake (installed by default? otherwise, `brew install cmake`)
+ - SDL2 (`brew install sdl2`)
+ - Qt 5 (`brew install qt5`)
 
-1. Create a build directory, either in-tree or elsewhere.
-2. Run cmake to configure the build system. Assuming a build subdirectory of `build-release`, `cd build-release && cmake -DCMAKE_BUILD_TYPE=Release -GNinja ..`.
-3. Compile the source code. For the example above, run `ninja`.
-4. Run the binary, located in the build directory under `src/duckstation/duckstation`.
+1. Clone the repository. Submodules aren't necessary, there is only one and it is only used for Windows.
+2. Clone the mac externals repository (for MoltenVK): `git clone https://github.com/stenzek/duckstation-ext-mac.git dep/mac`.
+2. Create a build directory, either in-tree or elsewhere, e.g. `mkdir build-release`, `cd build-release`.
+3. Run cmake to configure the build system: `cmake -DCMAKE_BUILD_TYPE=Release -DQt5_DIR=/usr/local/opt/qt/lib/cmake/Qt5 ..`. You may need to tweak `Qt5_DIR` depending on your system.
+4. Compile the source code: `make`. Use `make -jN` where `N` is the number of CPU cores in your system for a faster build.
+5. Run the binary, located in the build directory under `bin/duckstation-sdl`, or `bin/DuckStation.app` for Qt.
 
-## Running
-1. Configure the BIOS path in the settings.
-2. Open a disc image file, enjoy.
+### Android
+**NOTE:** The Android frontend is still incomplete, not all functionality is available yet. User directory is hardcoded to `/sdcard/duckstation` for now.
 
-## Default keyboard bindings
-Keyboard bindings are currently not customizable. For reference:
- - **D-Pad:** W/A/S/D or Up/Left/Down/Right
- - **Triangle/Square/Circle/Cross:** I/J/L/K or Numpad8/Numpad4/Numpad6/Numpad2
+Requirements:
+ - Android Studio with the NDK and CMake installed
+
+1. Clone the repository. Submodules aren't necessary, there is only one and it is only used for Windows.
+2. Open the project in the `android` directory.
+3. Select Build -> Build Bundle(s) / APKs(s) -> Build APK(s).
+4. Install APK on device, or use Run menu for attached device.
+
+## User Directories
+The "User Directory" is where you should place your BIOS images, where settings are saved to, and memory cards/save states are saved by default.
+An optional [SDL game controller database file](#sdl-game-controller-database) can be also placed here.
+
+This is located in the following places depending on the platform you're using:
+
+- Windows: My Documents\DuckStation
+- Linux: `$XDG_DATA_HOME/duckstation`, or `~/.local/share/duckstation`.
+- macOS: `~/Library/Application Support/DuckStation`.
+
+So, if you were using Linux, you would place your BIOS images in `~/.local/share/duckstation/bios`. This directory will be created upon running DuckStation
+for the first time.
+
+If you wish to use a "portable" build, where the user directory is the same as where the executable is located, create an empty file named `portable.txt`
+in the same directory as the DuckStation executable.
+
+## Bindings for Qt frontend
+Your keyboard and any SDL-compatible game controller can be used to simulate the PS Controller. To bind keys/controllers to buttons, go to
+`Settings -> Port Settings`. Each of the buttons will be listed, along with the corresponding key it is bound to. To re-bind the button to a new key,
+click the button next to button name, and press the key/button you want to use within 5 seconds.
+
+**Currently, it is only possible to bind one input to each controller button/axis. Multiple bindings per button are planned for the future.**
+
+## Bindings for SDL frontend
+Keyboard bindings in the SDL frontend are currently not customizable in the frontend itself. You should use the Qt frontend to set up your key/controller bindings first.
+
+## SDL Game Controller Database
+DuckStation uses the SDL2 GameController API for input handling which requires controller devices to have known input mappings.
+SDL2 provides an embedded database of recognised controllers in its own source code, however it is rather small and thus limited in practice.
+
+There is an officially endorsed [community sourced database](https://github.com/gabomdq/SDL_GameControllerDB) that can be used to support a much broader range of game controllers in DuckStation.
+If your controller is not recognized by DuckStation but can be found in the community database above, just download a recent copy of the `gamecontrollerdb.txt` database file and place it in your [User directory](#user-directories). Your controller should now be recognized by DuckStation.
+
+Alternatively, you can also create your own custom controller mappings from scratch easily using readily available tools. See the referenced community database repository for more information.
+
+Using a mappings database is specially useful when using non-XInput game controllers with DuckStation.
+
+## Default bindings
+Controller 1:
+ - **D-Pad:** W/A/S/D
+ - **Triangle/Square/Circle/Cross:** Numpad8/Numpad4/Numpad6/Numpad2
  - **L1/R1:** Q/E
  - **L2/L2:** 1/3
  - **Start:** Enter
  - **Select:** Backspace
 
-Gamepads are automatically detected and supported. Tested with an Xbox One controller.
-To access the menus with the controller, press the right stick down and use the D-Pad to navigate, A to select.
-
-## Useful hotkeys
- - **F1-F8:** Quick load/save (hold shift to save)
- - **F11:** Toggle fullscreen
+Hotkeys:
+ - **Escape:** Power off console
+ - **ALT+ENTER:** Toggle fullscreen
  - **Tab:** Temporarily disable speed limiter
  - **Pause/Break:** Pause/resume emulation
- - **Space:** Frame step
- - **End:** Toggle software renderer
  - **Page Up/Down:** Increase/decrease resolution scale in hardware renderers
+ - **End:** Toggle software renderer
+ 
+## Libretro Core
+
+DuckStation is available as a libretro core, which can be loaded into a frontend such as RetroArch. It supports most features of the full frontend, within the constraints and limitations of being a libretro core.
+
+Prebuilt binaries for 64-bit Windows, Linux and Android can be found on the releases page. Direct links:
+- 64-bit Windows: https://github.com/stenzek/duckstation/releases/download/latest/duckstation_libretro.dll.zip
+- 64-bit Linux: https://github.com/stenzek/duckstation/releases/download/latest/duckstation_libretro_x64.so.zip
+- AArch64 Linux: https://github.com/stenzek/duckstation/releases/download/latest/duckstation_libretro_linux_aarch64.so.zip
+- AArch64 Android: https://github.com/stenzek/duckstation/releases/download/latest/duckstation_libretro_android_aarch64.so.zip
+
+To use, download and extract, and install the core file in RetroArch or your preferred frontend.
+
+To build on Windows, use cmake using the following commands from a `x64 Native Tools Command Prompt for VS 2019`:
+- mkdir build
+- cd build
+- cmake -G Ninja -DCMAKE_BUILD_TYPE=Release -DBUILD_LIBRETRO_CORE=ON ..
+
+You should then have a file named `duckstation_libretro.dll` which can be loaded as a core.
+
+To build on Linux, follow the same instructions as for a normal build, but for cmake use `cmake -DCMAKE_BUILD_TYPE=Release -DBUILD_LIBRETRO_CORE=ON ..`. The shared library will be named `duckstation_libretro.so` in the current directory.
 
 ## Tests
  - Passes amidog's CPU and GTE tests in both interpreter and recompiler modes, partial passing of CPX tests
 
 ## Screenshots
-![Final Fantasy 7](https://raw.githubusercontent.com/stenzek/duckstation/md-images/ff7.jpg)
-![Final Fantasy 8](https://raw.githubusercontent.com/stenzek/duckstation/md-images/ff8.jpg)
-![Spyro 2](https://raw.githubusercontent.com/stenzek/duckstation/md-images/spyro.jpg)
+<p align="center">
+  <a href="https://raw.githubusercontent.com/stenzek/duckstation/md-images/monkey.jpg"><img src="https://raw.githubusercontent.com/stenzek/duckstation/md-images/monkey.jpg" alt="Monkey Hero" width="400" /></a>
+  <a href="https://raw.githubusercontent.com/stenzek/duckstation/md-images/rrt4.jpg"><img src="https://raw.githubusercontent.com/stenzek/duckstation/md-images/rrt4.jpg" alt="Ridge Racer Type 4" width="400" /></a>
+  <a href="https://raw.githubusercontent.com/stenzek/duckstation/md-images/tr2.jpg"><img src="https://raw.githubusercontent.com/stenzek/duckstation/md-images/tr2.jpg" alt="Tomb Raider 2" width="400" /></a>
+  <a href="https://raw.githubusercontent.com/stenzek/duckstation/md-images/quake2.jpg"><img src="https://raw.githubusercontent.com/stenzek/duckstation/md-images/quake2.jpg" alt="Quake 2" width="400" /></a>
+  <a href="https://raw.githubusercontent.com/stenzek/duckstation/md-images/croc.jpg"><img src="https://raw.githubusercontent.com/stenzek/duckstation/md-images/croc.jpg" alt="Croc" width="400" /></a>
+  <a href="https://raw.githubusercontent.com/stenzek/duckstation/md-images/croc2.jpg"><img src="https://raw.githubusercontent.com/stenzek/duckstation/md-images/croc2.jpg" alt="Croc 2" width="400" /></a>
+  <a href="https://raw.githubusercontent.com/stenzek/duckstation/md-images/ff7.jpg"><img src="https://raw.githubusercontent.com/stenzek/duckstation/md-images/ff7.jpg" alt="Final Fantasy 7" width="400" /></a>
+  <a href="https://raw.githubusercontent.com/stenzek/duckstation/md-images/ff8.jpg"><img src="https://raw.githubusercontent.com/stenzek/duckstation/md-images/ff8.jpg" alt="Final Fantasy 8" width="400" /></a>
+  <a href="https://raw.githubusercontent.com/stenzek/duckstation/md-images/main.png"><img src="https://raw.githubusercontent.com/stenzek/duckstation/md-images/main.png" alt="SDL Frontend" width="400" /></a>
+  <a href="https://raw.githubusercontent.com/stenzek/duckstation/md-images/spyro.jpg"><img src="https://raw.githubusercontent.com/stenzek/duckstation/md-images/spyro.jpg" alt="Spyro 2" width="400" /></a>
+  <a href="https://raw.githubusercontent.com/stenzek/duckstation/md-images/gamegrid.png"><img src="https://raw.githubusercontent.com/stenzek/duckstation/md-images/gamegrid.png" alt="Game Grid" width="400" /></a>
+</p>
 
 ## Disclaimers
 
 Icon by icons8: https://icons8.com/icon/74847/platforms.undefined.short-title
 
-"PlayStation" and "PSX" are registered trademarks of Sony Interactive Entertainment Europe Limited. This project is not affiliated in any way with Sony Interactive Entertainment.
+"PlayStation" and "PSX" are registered trademarks of Sony Interactive Entertainment Europe Limited. This project is not affiliated in any way with Sony Interactive Entertainment.
+
+

android/.gitignore

@@ -0,0 +1,14 @@
+*.iml
+.gradle
+/local.properties
+/.idea/caches
+/.idea/libraries
+/.idea/modules.xml
+/.idea/workspace.xml
+/.idea/navEditor.xml
+/.idea/assetWizardSettings.xml
+.DS_Store
+/build
+/captures
+.externalNativeBuild
+.cxx

android/.idea/.name

@@ -0,0 +1 @@
+DuckStation

android/.idea/codeStyles/Project.xml

@@ -0,0 +1,116 @@
+<component name="ProjectCodeStyleConfiguration">
+  <code_scheme name="Project" version="173">
+    <codeStyleSettings language="XML">
+      <indentOptions>
+        <option name="CONTINUATION_INDENT_SIZE" value="4" />
+      </indentOptions>
+      <arrangement>
+        <rules>
+          <section>
+            <rule>
+              <match>
+                <AND>
+                  <NAME>xmlns:android</NAME>
+                  <XML_ATTRIBUTE />
+                  <XML_NAMESPACE>^$</XML_NAMESPACE>
+                </AND>
+              </match>
+            </rule>
+          </section>
+          <section>
+            <rule>
+              <match>
+                <AND>
+                  <NAME>xmlns:.*</NAME>
+                  <XML_ATTRIBUTE />
+                  <XML_NAMESPACE>^$</XML_NAMESPACE>
+                </AND>
+              </match>
+              <order>BY_NAME</order>
+            </rule>
+          </section>
+          <section>
+            <rule>
+              <match>
+                <AND>
+                  <NAME>.*:id</NAME>
+                  <XML_ATTRIBUTE />
+                  <XML_NAMESPACE>http://schemas.android.com/apk/res/android</XML_NAMESPACE>
+                </AND>
+              </match>
+            </rule>
+          </section>
+          <section>
+            <rule>
+              <match>
+                <AND>
+                  <NAME>.*:name</NAME>
+                  <XML_ATTRIBUTE />
+                  <XML_NAMESPACE>http://schemas.android.com/apk/res/android</XML_NAMESPACE>
+                </AND>
+              </match>
+            </rule>
+          </section>
+          <section>
+            <rule>
+              <match>
+                <AND>
+                  <NAME>name</NAME>
+                  <XML_ATTRIBUTE />
+                  <XML_NAMESPACE>^$</XML_NAMESPACE>
+                </AND>
+              </match>
+            </rule>
+          </section>
+          <section>
+            <rule>
+              <match>
+                <AND>
+                  <NAME>style</NAME>
+                  <XML_ATTRIBUTE />
+                  <XML_NAMESPACE>^$</XML_NAMESPACE>
+                </AND>
+              </match>
+            </rule>
+          </section>
+          <section>
+            <rule>
+              <match>
+                <AND>
+                  <NAME>.*</NAME>
+                  <XML_ATTRIBUTE />
+                  <XML_NAMESPACE>^$</XML_NAMESPACE>
+                </AND>
+              </match>
+              <order>BY_NAME</order>
+            </rule>
+          </section>
+          <section>
+            <rule>
+              <match>
+                <AND>
+                  <NAME>.*</NAME>
+                  <XML_ATTRIBUTE />
+                  <XML_NAMESPACE>http://schemas.android.com/apk/res/android</XML_NAMESPACE>
+                </AND>
+              </match>
+              <order>ANDROID_ATTRIBUTE_ORDER</order>
+            </rule>
+          </section>
+          <section>
+            <rule>
+              <match>
+                <AND>
+                  <NAME>.*</NAME>
+                  <XML_ATTRIBUTE />
+                  <XML_NAMESPACE>.*</XML_NAMESPACE>
+                </AND>
+              </match>
+              <order>BY_NAME</order>
+            </rule>
+          </section>
+        </rules>
+      </arrangement>
+    </codeStyleSettings>
+  </code_scheme>
+</component>

android/.idea/codeStyles/codeStyleConfig.xml

@@ -0,0 +1,5 @@
+<component name="ProjectCodeStyleConfiguration">
+  <state>
+    <option name="PREFERRED_PROJECT_CODE_STYLE" value="Default" />
+  </state>
+</component>

android/.idea/gradle.xml

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="GradleMigrationSettings" migrationVersion="1" />
+  <component name="GradleSettings">
+    <option name="linkedExternalProjectsSettings">
+      <GradleProjectSettings>
+        <option name="testRunner" value="PLATFORM" />
+        <option name="distributionType" value="DEFAULT_WRAPPED" />
+        <option name="externalProjectPath" value="$PROJECT_DIR$" />
+        <option name="modules">
+          <set>
+            <option value="$PROJECT_DIR$" />
+            <option value="$PROJECT_DIR$/app" />
+          </set>
+        </option>
+        <option name="resolveModulePerSourceSet" value="false" />
+      </GradleProjectSettings>
+    </option>
+  </component>
+</project>

android/.idea/jarRepositories.xml

@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="RemoteRepositoriesConfiguration">
+    <remote-repository>
+      <option name="id" value="central" />
+      <option name="name" value="Maven Central repository" />
+      <option name="url" value="https://repo1.maven.org/maven2" />
+    </remote-repository>
+    <remote-repository>
+      <option name="id" value="jboss.community" />
+      <option name="name" value="JBoss Community repository" />
+      <option name="url" value="https://repository.jboss.org/nexus/content/repositories/public/" />
+    </remote-repository>
+    <remote-repository>
+      <option name="id" value="BintrayJCenter" />
+      <option name="name" value="BintrayJCenter" />
+      <option name="url" value="https://jcenter.bintray.com/" />
+    </remote-repository>
+    <remote-repository>
+      <option name="id" value="Google" />
+      <option name="name" value="Google" />
+      <option name="url" value="https://dl.google.com/dl/android/maven2/" />
+    </remote-repository>
+  </component>
+</project>

android/.idea/misc.xml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_1_8" project-jdk-name="1.8" project-jdk-type="JavaSDK">
+    <output url="file://$PROJECT_DIR$/build/classes" />
+  </component>
+  <component name="ProjectType">
+    <option name="id" value="Android" />
+  </component>
+</project>

android/.idea/runConfigurations.xml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="RunConfigurationProducerService">
+    <option name="ignoredProducers">
+      <set>
+        <option value="org.jetbrains.plugins.gradle.execution.test.runner.AllInPackageGradleConfigurationProducer" />
+        <option value="org.jetbrains.plugins.gradle.execution.test.runner.TestClassGradleConfigurationProducer" />
+        <option value="org.jetbrains.plugins.gradle.execution.test.runner.TestMethodGradleConfigurationProducer" />
+      </set>
+    </option>
+  </component>
+</project>

android/.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$/.." vcs="Git" />
+  </component>
+</project>

android/app/.gitignore

@@ -0,0 +1 @@
+/build

android/app/build.gradle

@@ -0,0 +1,80 @@
+apply plugin: 'com.android.application'
+
+android {
+    compileSdkVersion 29
+    buildToolsVersion "29.0.2"
+    defaultConfig {
+        applicationId "com.github.stenzek.duckstation"
+        minSdkVersion 21
+        targetSdkVersion 29
+        versionCode(getBuildVersionCode())
+        versionName "${getVersion()}"
+    }
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
+        }
+    }
+
+    externalNativeBuild {
+        cmake {
+            path "../../CMakeLists.txt"
+            version "3.10.2"
+        }
+    }
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_8
+        targetCompatibility JavaVersion.VERSION_1_8
+    }
+    defaultConfig {
+        externalNativeBuild {
+            cmake {
+                arguments "-DCMAKE_BUILD_TYPE=RelWithDebInfo"
+                abiFilters "arm64-v8a"
+            }
+        }
+    }
+}
+
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation 'androidx.appcompat:appcompat:1.0.2'
+    implementation 'androidx.constraintlayout:constraintlayout:1.1.3'
+    implementation 'com.google.android.material:material:1.1.0'
+    implementation 'androidx.preference:preference:1.1.0-alpha05'
+    implementation 'androidx.legacy:legacy-support-v4:1.0.0'
+    implementation "androidx.viewpager2:viewpager2:1.0.0"
+    testImplementation 'junit:junit:4.12'
+    androidTestImplementation 'androidx.test.ext:junit:1.1.0'
+    androidTestImplementation 'androidx.test.espresso:espresso-core:3.1.1'
+}
+
+// Adapted from Dolphin.
+
+def getVersion() {
+    def versionNumber = '0.0-unknown'
+
+    try {
+        versionNumber = 'git describe --tags --exclude latest'.execute([], project.rootDir).text
+                .trim()
+                .replaceAll(/(-0)?-[^-]+$/, "")
+    } catch (Exception e) {
+        logger.error('Cannot find git, defaulting to dummy version number')
+    }
+
+    return versionNumber
+}
+
+
+def getBuildVersionCode() {
+    try {
+        def versionNumber = 'git rev-list --first-parent --count HEAD'.execute([], project.rootDir).text
+                .trim()
+        return Integer.valueOf(versionNumber);
+    } catch (Exception e) {
+        logger.error('Cannot find git, defaulting to dummy version number')
+    }
+
+    return 1;
+}

android/app/proguard-rules.pro

@@ -0,0 +1,21 @@
+# Add project specific ProGuard rules here.
+# You can control the set of applied configuration files using the
+# proguardFiles setting in build.gradle.
+#
+# For more details, see
+#   http://developer.android.com/guide/developing/tools/proguard.html
+
+# If your project uses WebView with JS, uncomment the following
+# and specify the fully qualified class name to the JavaScript interface
+# class:
+#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
+#   public *;
+#}
+
+# Uncomment this to preserve the line number information for
+# debugging stack traces.
+#-keepattributes SourceFile,LineNumberTable
+
+# If you keep the line number information, uncomment this to
+# hide the original source file name.
+#-renamesourcefileattribute SourceFile

android/app/src/androidTest/java/com/github/stenzek/duckstation/ExampleInstrumentedTest.java

@@ -0,0 +1,27 @@
+package com.github.stenzek.duckstation;
+
+import android.content.Context;
+
+import androidx.test.platform.app.InstrumentationRegistry;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import static org.junit.Assert.*;
+
+/**
+ * Instrumented test, which will execute on an Android device.
+ *
+ * @see <a href="http://d.android.com/tools/testing">Testing documentation</a>
+ */
+@RunWith(AndroidJUnit4.class)
+public class ExampleInstrumentedTest {
+    @Test
+    public void useAppContext() {
+        // Context of the app under test.
+        Context appContext = InstrumentationRegistry.getInstrumentation().getTargetContext();
+
+        assertEquals("com.github.stenzek.duckstation", appContext.getPackageName());
+    }
+}

android/app/src/cpp/CMakeLists.txt

@@ -0,0 +1,19 @@
+set(SRCS
+  android_host_interface.cpp
+  android_host_interface.h
+  android_settings_interface.cpp
+  android_settings_interface.h
+)
+
+add_library(duckstation-native SHARED ${SRCS})
+target_link_libraries(duckstation-native PRIVATE android frontend-common core common glad imgui)
+
+find_package(OpenSLES)
+if(OPENSLES_FOUND)
+  message("Enabling OpenSL ES audio stream")
+  target_sources(duckstation-native PRIVATE
+    opensles_audio_stream.cpp
+    opensles_audio_stream.h)
+  target_link_libraries(duckstation-native PRIVATE OpenSLES::OpenSLES)
+  target_compile_definitions(duckstation-native PRIVATE "-DUSE_OPENSLES=1")
+endif()

android/app/src/cpp/android_host_interface.cpp

@@ -0,0 +1,896 @@
+#include "android_host_interface.h"
+#include "common/assert.h"
+#include "common/audio_stream.h"
+#include "common/file_system.h"
+#include "common/log.h"
+#include "common/string.h"
+#include "common/timestamp.h"
+#include "core/bios.h"
+#include "core/cheats.h"
+#include "core/controller.h"
+#include "core/gpu.h"
+#include "core/host_display.h"
+#include "core/system.h"
+#include "frontend-common/game_list.h"
+#include "frontend-common/imgui_styles.h"
+#include "frontend-common/opengl_host_display.h"
+#include "frontend-common/vulkan_host_display.h"
+#include <android/native_window_jni.h>
+#include <cmath>
+#include <imgui.h>
+Log_SetChannel(AndroidHostInterface);
+
+#ifdef USE_OPENSLES
+#include "opensles_audio_stream.h"
+#endif
+
+static JavaVM* s_jvm;
+static jclass s_AndroidHostInterface_class;
+static jmethodID s_AndroidHostInterface_constructor;
+static jfieldID s_AndroidHostInterface_field_mNativePointer;
+static jmethodID s_AndroidHostInterface_method_reportError;
+static jmethodID s_AndroidHostInterface_method_reportMessage;
+static jmethodID s_EmulationActivity_method_reportError;
+static jmethodID s_EmulationActivity_method_reportMessage;
+static jmethodID s_EmulationActivity_method_onEmulationStarted;
+static jmethodID s_EmulationActivity_method_onEmulationStopped;
+static jmethodID s_EmulationActivity_method_onGameTitleChanged;
+static jclass s_CheatCode_class;
+static jmethodID s_CheatCode_constructor;
+
+namespace AndroidHelpers {
+// helper for retrieving the current per-thread jni environment
+JNIEnv* GetJNIEnv()
+{
+  JNIEnv* env;
+  if (s_jvm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6) != JNI_OK)
+    return nullptr;
+  else
+    return env;
+}
+
+AndroidHostInterface* GetNativeClass(JNIEnv* env, jobject obj)
+{
+  return reinterpret_cast<AndroidHostInterface*>(
+    static_cast<uintptr_t>(env->GetLongField(obj, s_AndroidHostInterface_field_mNativePointer)));
+}
+
+std::string JStringToString(JNIEnv* env, jstring str)
+{
+  if (str == nullptr)
+    return {};
+
+  jsize length = env->GetStringUTFLength(str);
+  if (length == 0)
+    return {};
+
+  const char* data = env->GetStringUTFChars(str, nullptr);
+  Assert(data != nullptr);
+
+  std::string ret(data, length);
+  env->ReleaseStringUTFChars(str, data);
+
+  return ret;
+}
+} // namespace AndroidHelpers
+
+AndroidHostInterface::AndroidHostInterface(jobject java_object, jobject context_object, std::string user_directory)
+  : m_java_object(java_object), m_settings_interface(context_object)
+{
+  m_user_directory = std::move(user_directory);
+}
+
+AndroidHostInterface::~AndroidHostInterface()
+{
+  ImGui::DestroyContext();
+  AndroidHelpers::GetJNIEnv()->DeleteGlobalRef(m_java_object);
+}
+
+bool AndroidHostInterface::Initialize()
+{
+  if (!CommonHostInterface::Initialize())
+    return false;
+
+  return true;
+}
+
+void AndroidHostInterface::Shutdown()
+{
+  HostInterface::Shutdown();
+}
+
+const char* AndroidHostInterface::GetFrontendName() const
+{
+  return "DuckStation Android";
+}
+
+void AndroidHostInterface::RequestExit()
+{
+  ReportError("Ignoring RequestExit()");
+}
+
+void AndroidHostInterface::ReportError(const char* message)
+{
+  CommonHostInterface::ReportError(message);
+
+  JNIEnv* env = AndroidHelpers::GetJNIEnv();
+  jstring message_jstr = env->NewStringUTF(message);
+  if (m_emulation_activity_object)
+    env->CallVoidMethod(m_emulation_activity_object, s_EmulationActivity_method_reportError, message_jstr);
+  else
+    env->CallVoidMethod(m_java_object, s_AndroidHostInterface_method_reportError, message_jstr);
+}
+
+void AndroidHostInterface::ReportMessage(const char* message)
+{
+  CommonHostInterface::ReportMessage(message);
+
+  JNIEnv* env = AndroidHelpers::GetJNIEnv();
+  jstring message_jstr = env->NewStringUTF(message);
+  if (m_emulation_activity_object)
+    env->CallVoidMethod(m_emulation_activity_object, s_EmulationActivity_method_reportMessage, message_jstr);
+  else
+    env->CallVoidMethod(m_java_object, s_AndroidHostInterface_method_reportMessage, message_jstr);
+}
+
+std::string AndroidHostInterface::GetStringSettingValue(const char* section, const char* key, const char* default_value)
+{
+  return m_settings_interface.GetStringValue(section, key, default_value);
+}
+
+bool AndroidHostInterface::GetBoolSettingValue(const char* section, const char* key, bool default_value /* = false */)
+{
+  return m_settings_interface.GetBoolValue(section, key, default_value);
+}
+
+int AndroidHostInterface::GetIntSettingValue(const char* section, const char* key, int default_value /* = 0 */)
+{
+  return m_settings_interface.GetIntValue(section, key, default_value);
+}
+
+float AndroidHostInterface::GetFloatSettingValue(const char* section, const char* key, float default_value /* = 0.0f */)
+{
+  return m_settings_interface.GetFloatValue(section, key, default_value);
+}
+
+void AndroidHostInterface::SetUserDirectory()
+{
+  // Already set in constructor.
+  Assert(!m_user_directory.empty());
+}
+
+void AndroidHostInterface::LoadSettings()
+{
+  CommonHostInterface::LoadSettings(m_settings_interface);
+  CommonHostInterface::FixIncompatibleSettings(false);
+  CommonHostInterface::UpdateInputMap(m_settings_interface);
+}
+
+void AndroidHostInterface::UpdateInputMap()
+{
+  CommonHostInterface::UpdateInputMap(m_settings_interface);
+}
+
+bool AndroidHostInterface::IsEmulationThreadPaused() const
+{
+  return System::IsValid() && System::IsPaused();
+}
+
+bool AndroidHostInterface::StartEmulationThread(jobject emulation_activity, ANativeWindow* initial_surface,
+                                                SystemBootParameters boot_params, bool resume_state)
+{
+  Assert(!IsEmulationThreadRunning());
+
+  emulation_activity = AndroidHelpers::GetJNIEnv()->NewGlobalRef(emulation_activity);
+
+  Log_DevPrintf("Starting emulation thread...");
+  m_emulation_thread_stop_request.store(false);
+  m_emulation_thread = std::thread(&AndroidHostInterface::EmulationThreadEntryPoint, this, emulation_activity,
+                                   initial_surface, std::move(boot_params), resume_state);
+  return true;
+}
+
+void AndroidHostInterface::PauseEmulationThread(bool paused)
+{
+  Assert(IsEmulationThreadRunning());
+  RunOnEmulationThread([this, paused]() { PauseSystem(paused); });
+}
+
+void AndroidHostInterface::StopEmulationThread()
+{
+  if (!IsEmulationThreadRunning())
+    return;
+
+  Log_InfoPrint("Stopping emulation thread...");
+  {
+    std::unique_lock<std::mutex> lock(m_mutex);
+    m_emulation_thread_stop_request.store(true);
+    m_sleep_cv.notify_one();
+  }
+  m_emulation_thread.join();
+  Log_InfoPrint("Emulation thread stopped");
+}
+
+void AndroidHostInterface::RunOnEmulationThread(std::function<void()> function, bool blocking)
+{
+  if (!IsEmulationThreadRunning())
+  {
+    function();
+    return;
+  }
+
+  m_mutex.lock();
+  m_callback_queue.push_back(std::move(function));
+  m_sleep_cv.notify_one();
+
+  if (blocking)
+  {
+    // TODO: Don't spin
+    for (;;)
+    {
+      if (m_callback_queue.empty())
+        break;
+
+      m_mutex.unlock();
+      m_mutex.lock();
+    }
+  }
+
+  m_mutex.unlock();
+}
+
+void AndroidHostInterface::EmulationThreadEntryPoint(jobject emulation_activity, ANativeWindow* initial_surface,
+                                                     SystemBootParameters boot_params, bool resume_state)
+{
+  JNIEnv* thread_env;
+  if (s_jvm->AttachCurrentThread(&thread_env, nullptr) != JNI_OK)
+  {
+    ReportError("Failed to attach JNI to thread");
+    return;
+  }
+
+  CreateImGuiContext();
+  m_surface = initial_surface;
+  m_emulation_activity_object = emulation_activity;
+  ApplySettings(true);
+
+  // Boot system.
+  bool boot_result = false;
+  if (resume_state)
+  {
+    if (boot_params.filename.empty())
+      boot_result = ResumeSystemFromMostRecentState();
+    else
+      boot_result = ResumeSystemFromState(boot_params.filename.c_str(), true);
+  }
+  else
+  {
+    boot_result = BootSystem(boot_params);
+  }
+
+  if (!boot_result)
+  {
+    ReportFormattedError("Failed to boot system on emulation thread (file:%s).", boot_params.filename.c_str());
+    DestroyImGuiContext();
+    thread_env->CallVoidMethod(m_emulation_activity_object, s_EmulationActivity_method_onEmulationStopped);
+    thread_env->DeleteGlobalRef(m_emulation_activity_object);
+    m_emulation_activity_object = {};
+    s_jvm->DetachCurrentThread();
+    return;
+  }
+
+  // System is ready to go.
+  thread_env->CallVoidMethod(m_emulation_activity_object, s_EmulationActivity_method_onEmulationStarted);
+  EmulationThreadLoop();
+
+  thread_env->CallVoidMethod(m_emulation_activity_object, s_EmulationActivity_method_onEmulationStopped);
+  PowerOffSystem();
+  DestroyImGuiContext();
+  thread_env->DeleteGlobalRef(m_emulation_activity_object);
+  m_emulation_activity_object = {};
+  s_jvm->DetachCurrentThread();
+}
+
+void AndroidHostInterface::EmulationThreadLoop()
+{
+  for (;;)
+  {
+    // run any events
+    {
+      std::unique_lock<std::mutex> lock(m_mutex);
+      for (;;)
+      {
+        while (!m_callback_queue.empty())
+        {
+          auto callback = std::move(m_callback_queue.front());
+          m_callback_queue.pop_front();
+          lock.unlock();
+          callback();
+          lock.lock();
+        }
+
+        if (m_emulation_thread_stop_request.load())
+          return;
+
+        if (System::IsPaused())
+        {
+          // paused, wait for us to resume
+          m_sleep_cv.wait(lock);
+        }
+        else
+        {
+          // done with callbacks, run the frame
+          break;
+        }
+      }
+    }
+
+    // simulate the system if not paused
+    if (System::IsRunning())
+      System::RunFrame();
+
+    // rendering
+    {
+      DrawImGuiWindows();
+
+      m_display->Render();
+      ImGui::NewFrame();
+
+      if (System::IsRunning())
+      {
+        System::UpdatePerformanceCounters();
+
+        if (m_speed_limiter_enabled)
+          System::Throttle();
+      }
+    }
+  }
+}
+
+bool AndroidHostInterface::AcquireHostDisplay()
+{
+  WindowInfo wi;
+  wi.type = WindowInfo::Type::Android;
+  wi.window_handle = m_surface;
+  wi.surface_width = ANativeWindow_getWidth(m_surface);
+  wi.surface_height = ANativeWindow_getHeight(m_surface);
+
+  std::unique_ptr<HostDisplay> display;
+  switch (g_settings.gpu_renderer)
+  {
+    case GPURenderer::HardwareVulkan:
+      display = std::make_unique<FrontendCommon::VulkanHostDisplay>();
+      break;
+
+    case GPURenderer::HardwareOpenGL:
+    default:
+      display = std::make_unique<FrontendCommon::OpenGLHostDisplay>();
+      break;
+  }
+
+  if (!display->CreateRenderDevice(wi, {}, g_settings.gpu_use_debug_device) ||
+      !display->InitializeRenderDevice(GetShaderCacheBasePath(), g_settings.gpu_use_debug_device))
+  {
+    ReportError("Failed to acquire host display.");
+    display->DestroyRenderDevice();
+    return false;
+  }
+
+  m_display = std::move(display);
+
+  if (!CreateHostDisplayResources())
+  {
+    ReportError("Failed to create host display resources");
+    ReleaseHostDisplay();
+    return false;
+  }
+
+  ImGui::NewFrame();
+  return true;
+}
+
+void AndroidHostInterface::ReleaseHostDisplay()
+{
+  ReleaseHostDisplayResources();
+  m_display->DestroyRenderDevice();
+  m_display.reset();
+}
+
+std::unique_ptr<AudioStream> AndroidHostInterface::CreateAudioStream(AudioBackend backend)
+{
+#ifdef USE_OPENSLES
+  if (backend == AudioBackend::OpenSLES)
+    return OpenSLESAudioStream::Create();
+#endif
+
+  return CommonHostInterface::CreateAudioStream(backend);
+}
+
+void AndroidHostInterface::OnSystemDestroyed()
+{
+  CommonHostInterface::OnSystemDestroyed();
+  ClearOSDMessages();
+}
+
+void AndroidHostInterface::OnRunningGameChanged()
+{
+  CommonHostInterface::OnRunningGameChanged();
+
+  if (m_emulation_activity_object)
+  {
+    JNIEnv* env = AndroidHelpers::GetJNIEnv();
+    jstring title_string = env->NewStringUTF(System::GetRunningTitle().c_str());
+    env->CallVoidMethod(m_emulation_activity_object, s_EmulationActivity_method_onGameTitleChanged, title_string);
+  }
+}
+
+void AndroidHostInterface::SurfaceChanged(ANativeWindow* surface, int format, int width, int height)
+{
+  Log_InfoPrintf("SurfaceChanged %p %d %d %d", surface, format, width, height);
+  if (m_surface == surface)
+  {
+    if (m_display)
+      m_display->ResizeRenderWindow(width, height);
+
+    return;
+  }
+
+  m_surface = surface;
+
+  if (m_display)
+  {
+    WindowInfo wi;
+    wi.type = surface ? WindowInfo::Type::Android : WindowInfo::Type::Surfaceless;
+    wi.window_handle = surface;
+    wi.surface_width = width;
+    wi.surface_height = height;
+
+    m_display->ChangeRenderWindow(wi);
+  }
+}
+
+void AndroidHostInterface::CreateImGuiContext()
+{
+  ImGui::CreateContext();
+
+  const float framebuffer_scale = 2.0f;
+
+  auto& io = ImGui::GetIO();
+  io.IniFilename = nullptr;
+  io.DisplayFramebufferScale.x = framebuffer_scale;
+  io.DisplayFramebufferScale.y = framebuffer_scale;
+  ImGui::GetStyle().ScaleAllSizes(framebuffer_scale);
+
+  ImGui::StyleColorsDarker();
+  ImGui::AddRobotoRegularFont(15.0f * framebuffer_scale);
+}
+
+void AndroidHostInterface::DestroyImGuiContext()
+{
+  ImGui::DestroyContext();
+}
+
+void AndroidHostInterface::SetControllerType(u32 index, std::string_view type_name)
+{
+  ControllerType type =
+    Settings::ParseControllerTypeName(std::string(type_name).c_str()).value_or(ControllerType::None);
+
+  if (!IsEmulationThreadRunning())
+  {
+    g_settings.controller_types[index] = type;
+    return;
+  }
+
+  RunOnEmulationThread(
+    [index, type]() {
+      Log_InfoPrintf("Changing controller slot %d to %s", index, Settings::GetControllerTypeName(type));
+      g_settings.controller_types[index] = type;
+      System::UpdateControllers();
+    },
+    false);
+}
+
+void AndroidHostInterface::SetControllerButtonState(u32 index, s32 button_code, bool pressed)
+{
+  if (!IsEmulationThreadRunning())
+    return;
+
+  RunOnEmulationThread(
+    [index, button_code, pressed]() {
+      Controller* controller = System::GetController(index);
+      if (!controller)
+        return;
+
+      controller->SetButtonState(button_code, pressed);
+    },
+    false);
+}
+
+void AndroidHostInterface::SetControllerAxisState(u32 index, s32 button_code, float value)
+{
+  if (!IsEmulationThreadRunning())
+    return;
+
+  RunOnEmulationThread(
+    [index, button_code, value]() {
+      Controller* controller = System::GetController(index);
+      if (!controller)
+        return;
+
+      controller->SetAxisState(button_code, value);
+    },
+    false);
+}
+
+void AndroidHostInterface::RefreshGameList(bool invalidate_cache, bool invalidate_database)
+{
+  m_game_list->SetSearchDirectoriesFromSettings(m_settings_interface);
+  m_game_list->Refresh(invalidate_cache, invalidate_database);
+}
+
+void AndroidHostInterface::ApplySettings(bool display_osd_messages)
+{
+  Settings old_settings = std::move(g_settings);
+  CommonHostInterface::LoadSettings(m_settings_interface);
+  CommonHostInterface::FixIncompatibleSettings(display_osd_messages);
+  CheckForSettingsChanges(old_settings);
+}
+
+extern "C" jint JNI_OnLoad(JavaVM* vm, void* reserved)
+{
+  Log::SetDebugOutputParams(true, nullptr, LOGLEVEL_DEV);
+  s_jvm = vm;
+
+  // Create global reference so it doesn't get cleaned up.
+  JNIEnv* env = AndroidHelpers::GetJNIEnv();
+  if ((s_AndroidHostInterface_class = env->FindClass("com/github/stenzek/duckstation/AndroidHostInterface")) ==
+        nullptr ||
+      (s_AndroidHostInterface_class = static_cast<jclass>(env->NewGlobalRef(s_AndroidHostInterface_class))) ==
+        nullptr ||
+      (s_CheatCode_class = env->FindClass("com/github/stenzek/duckstation/CheatCode")) == nullptr ||
+      (s_CheatCode_class = static_cast<jclass>(env->NewGlobalRef(s_CheatCode_class))) == nullptr)
+  {
+    Log_ErrorPrint("AndroidHostInterface class lookup failed");
+    return -1;
+  }
+
+  jclass emulation_activity_class;
+  if ((s_AndroidHostInterface_constructor =
+         env->GetMethodID(s_AndroidHostInterface_class, "<init>", "(Landroid/content/Context;)V")) == nullptr ||
+      (s_AndroidHostInterface_field_mNativePointer =
+         env->GetFieldID(s_AndroidHostInterface_class, "mNativePointer", "J")) == nullptr ||
+      (s_AndroidHostInterface_method_reportError =
+         env->GetMethodID(s_AndroidHostInterface_class, "reportError", "(Ljava/lang/String;)V")) == nullptr ||
+      (s_AndroidHostInterface_method_reportMessage =
+         env->GetMethodID(s_AndroidHostInterface_class, "reportMessage", "(Ljava/lang/String;)V")) == nullptr ||
+      (emulation_activity_class = env->FindClass("com/github/stenzek/duckstation/EmulationActivity")) == nullptr ||
+      (s_EmulationActivity_method_reportError =
+         env->GetMethodID(emulation_activity_class, "reportError", "(Ljava/lang/String;)V")) == nullptr ||
+      (s_EmulationActivity_method_reportMessage =
+         env->GetMethodID(emulation_activity_class, "reportMessage", "(Ljava/lang/String;)V")) == nullptr ||
+      (s_EmulationActivity_method_onEmulationStarted =
+         env->GetMethodID(emulation_activity_class, "onEmulationStarted", "()V")) == nullptr ||
+      (s_EmulationActivity_method_onEmulationStopped =
+         env->GetMethodID(emulation_activity_class, "onEmulationStopped", "()V")) == nullptr ||
+      (s_EmulationActivity_method_onGameTitleChanged =
+         env->GetMethodID(emulation_activity_class, "onGameTitleChanged", "(Ljava/lang/String;)V")) == nullptr ||
+      (s_CheatCode_constructor = env->GetMethodID(s_CheatCode_class, "<init>", "(ILjava/lang/String;Z)V")) == nullptr)
+  {
+    Log_ErrorPrint("AndroidHostInterface lookups failed");
+    return -1;
+  }
+
+  return JNI_VERSION_1_6;
+}
+
+#define DEFINE_JNI_METHOD(return_type, name)                                                                           \
+  extern "C" JNIEXPORT return_type JNICALL Java_com_github_stenzek_duckstation_##name(JNIEnv* env)
+
+#define DEFINE_JNI_ARGS_METHOD(return_type, name, ...)                                                                 \
+  extern "C" JNIEXPORT return_type JNICALL Java_com_github_stenzek_duckstation_##name(JNIEnv* env, __VA_ARGS__)
+
+DEFINE_JNI_ARGS_METHOD(jobject, AndroidHostInterface_create, jobject unused, jobject context_object,
+                       jstring user_directory)
+{
+  Log::SetDebugOutputParams(true, nullptr, LOGLEVEL_DEBUG);
+
+  // initialize the java side
+  jobject java_obj = env->NewObject(s_AndroidHostInterface_class, s_AndroidHostInterface_constructor, context_object);
+  if (!java_obj)
+  {
+    Log_ErrorPrint("Failed to create Java AndroidHostInterface");
+    return nullptr;
+  }
+
+  jobject java_obj_ref = env->NewGlobalRef(java_obj);
+  Assert(java_obj_ref != nullptr);
+
+  // initialize the C++ side
+  std::string user_directory_str = AndroidHelpers::JStringToString(env, user_directory);
+  AndroidHostInterface* cpp_obj = new AndroidHostInterface(java_obj_ref, context_object, std::move(user_directory_str));
+  if (!cpp_obj->Initialize())
+  {
+    // TODO: Do we need to release the original java object reference?
+    Log_ErrorPrint("Failed to create C++ AndroidHostInterface");
+    env->DeleteGlobalRef(java_obj_ref);
+    return nullptr;
+  }
+
+  env->SetLongField(java_obj, s_AndroidHostInterface_field_mNativePointer,
+                    static_cast<long>(reinterpret_cast<uintptr_t>(cpp_obj)));
+
+  return java_obj;
+}
+
+DEFINE_JNI_ARGS_METHOD(jboolean, AndroidHostInterface_isEmulationThreadRunning, jobject obj)
+{
+  return AndroidHelpers::GetNativeClass(env, obj)->IsEmulationThreadRunning();
+}
+
+DEFINE_JNI_ARGS_METHOD(jboolean, AndroidHostInterface_startEmulationThread, jobject obj, jobject emulationActivity,
+                       jobject surface, jstring filename, jboolean resume_state, jstring state_filename)
+{
+  ANativeWindow* native_surface = ANativeWindow_fromSurface(env, surface);
+  if (!native_surface)
+  {
+    Log_ErrorPrint("ANativeWindow_fromSurface() returned null");
+    return false;
+  }
+
+  std::string state_filename_str = AndroidHelpers::JStringToString(env, state_filename);
+
+  SystemBootParameters boot_params;
+  boot_params.filename = AndroidHelpers::JStringToString(env, filename);
+
+  return AndroidHelpers::GetNativeClass(env, obj)->StartEmulationThread(emulationActivity, native_surface,
+                                                                        std::move(boot_params), resume_state);
+}
+
+DEFINE_JNI_ARGS_METHOD(void, AndroidHostInterface_stopEmulationThread, jobject obj)
+{
+  AndroidHelpers::GetNativeClass(env, obj)->StopEmulationThread();
+}
+
+DEFINE_JNI_ARGS_METHOD(void, AndroidHostInterface_surfaceChanged, jobject obj, jobject surface, jint format, jint width,
+                       jint height)
+{
+  ANativeWindow* native_surface = surface ? ANativeWindow_fromSurface(env, surface) : nullptr;
+  if (surface && !native_surface)
+    Log_ErrorPrint("ANativeWindow_fromSurface() returned null");
+
+  AndroidHostInterface* hi = AndroidHelpers::GetNativeClass(env, obj);
+  hi->RunOnEmulationThread(
+    [hi, native_surface, format, width, height]() { hi->SurfaceChanged(native_surface, format, width, height); },
+    false);
+}
+
+DEFINE_JNI_ARGS_METHOD(void, AndroidHostInterface_setControllerType, jobject obj, jint index, jstring controller_type)
+{
+  AndroidHelpers::GetNativeClass(env, obj)->SetControllerType(index,
+                                                              AndroidHelpers::JStringToString(env, controller_type));
+}
+
+DEFINE_JNI_ARGS_METHOD(void, AndroidHostInterface_setControllerButtonState, jobject obj, jint index, jint button_code,
+                       jboolean pressed)
+{
+  AndroidHelpers::GetNativeClass(env, obj)->SetControllerButtonState(index, button_code, pressed);
+}
+
+DEFINE_JNI_ARGS_METHOD(jint, AndroidHostInterface_getControllerButtonCode, jobject unused, jstring controller_type,
+                       jstring button_name)
+{
+  std::optional<ControllerType> type =
+    Settings::ParseControllerTypeName(AndroidHelpers::JStringToString(env, controller_type).c_str());
+  if (!type)
+    return -1;
+
+  std::optional<s32> code =
+    Controller::GetButtonCodeByName(type.value(), AndroidHelpers::JStringToString(env, button_name));
+  return code.value_or(-1);
+}
+
+DEFINE_JNI_ARGS_METHOD(void, AndroidHostInterface_setControllerAxisState, jobject obj, jint index, jint button_code,
+                       jfloat value)
+{
+  AndroidHelpers::GetNativeClass(env, obj)->SetControllerAxisState(index, button_code, value);
+}
+
+DEFINE_JNI_ARGS_METHOD(jint, AndroidHostInterface_getControllerAxisCode, jobject unused, jstring controller_type,
+                       jstring axis_name)
+{
+  std::optional<ControllerType> type =
+    Settings::ParseControllerTypeName(AndroidHelpers::JStringToString(env, controller_type).c_str());
+  if (!type)
+    return -1;
+
+  std::optional<s32> code =
+    Controller::GetAxisCodeByName(type.value(), AndroidHelpers::JStringToString(env, axis_name));
+  return code.value_or(-1);
+}
+
+DEFINE_JNI_ARGS_METHOD(void, AndroidHostInterface_refreshGameList, jobject obj, jboolean invalidate_cache,
+                       jboolean invalidate_database)
+{
+  AndroidHelpers::GetNativeClass(env, obj)->RefreshGameList(invalidate_cache, invalidate_database);
+}
+
+static const char* DiscRegionToString(DiscRegion region)
+{
+  static std::array<const char*, 4> names = {{"NTSC_J", "NTSC_U", "PAL", "Other"}};
+  return names[static_cast<int>(region)];
+}
+
+DEFINE_JNI_ARGS_METHOD(jarray, AndroidHostInterface_getGameListEntries, jobject obj)
+{
+  jclass entry_class = env->FindClass("com/github/stenzek/duckstation/GameListEntry");
+  Assert(entry_class != nullptr);
+
+  jmethodID entry_constructor = env->GetMethodID(entry_class, "<init>",
+                                                 "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;JLjava/lang/"
+                                                 "String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V");
+  Assert(entry_constructor != nullptr);
+
+  AndroidHostInterface* hi = AndroidHelpers::GetNativeClass(env, obj);
+  jobjectArray entry_array = env->NewObjectArray(hi->GetGameList()->GetEntryCount(), entry_class, nullptr);
+  Assert(entry_array != nullptr);
+
+  u32 counter = 0;
+  for (const GameListEntry& entry : hi->GetGameList()->GetEntries())
+  {
+    const Timestamp modified_ts(
+      Timestamp::FromUnixTimestamp(static_cast<Timestamp::UnixTimestampValue>(entry.last_modified_time)));
+
+    jstring path = env->NewStringUTF(entry.path.c_str());
+    jstring code = env->NewStringUTF(entry.code.c_str());
+    jstring title = env->NewStringUTF(entry.title.c_str());
+    jstring region = env->NewStringUTF(DiscRegionToString(entry.region));
+    jstring type = env->NewStringUTF(GameList::EntryTypeToString(entry.type));
+    jstring compatibility_rating =
+      env->NewStringUTF(GameList::EntryCompatibilityRatingToString(entry.compatibility_rating));
+    jstring modified_time = env->NewStringUTF(modified_ts.ToString("%Y/%m/%d, %H:%M:%S"));
+    jlong size = entry.total_size;
+
+    jobject entry_jobject = env->NewObject(entry_class, entry_constructor, path, code, title, size, modified_time,
+                                           region, type, compatibility_rating);
+
+    env->SetObjectArrayElement(entry_array, counter++, entry_jobject);
+  }
+
+  return entry_array;
+}
+
+DEFINE_JNI_ARGS_METHOD(void, AndroidHostInterface_applySettings, jobject obj)
+{
+  AndroidHostInterface* hi = AndroidHelpers::GetNativeClass(env, obj);
+  if (hi->IsEmulationThreadRunning())
+  {
+    hi->RunOnEmulationThread([hi]() { hi->ApplySettings(false); });
+  }
+  else
+  {
+    hi->ApplySettings(false);
+  }
+}
+
+DEFINE_JNI_ARGS_METHOD(void, AndroidHostInterface_resetSystem, jobject obj, jboolean global, jint slot)
+{
+  AndroidHostInterface* hi = AndroidHelpers::GetNativeClass(env, obj);
+  hi->RunOnEmulationThread([hi]() { hi->ResetSystem(); });
+}
+
+DEFINE_JNI_ARGS_METHOD(void, AndroidHostInterface_loadState, jobject obj, jboolean global, jint slot)
+{
+  AndroidHostInterface* hi = AndroidHelpers::GetNativeClass(env, obj);
+  hi->RunOnEmulationThread([hi, global, slot]() { hi->LoadState(global, slot); });
+}
+
+DEFINE_JNI_ARGS_METHOD(void, AndroidHostInterface_saveState, jobject obj, jboolean global, jint slot)
+{
+  AndroidHostInterface* hi = AndroidHelpers::GetNativeClass(env, obj);
+  hi->RunOnEmulationThread([hi, global, slot]() { hi->SaveState(global, slot); });
+}
+
+DEFINE_JNI_ARGS_METHOD(void, AndroidHostInterface_saveResumeState, jobject obj, jboolean wait_for_completion)
+{
+  AndroidHostInterface* hi = AndroidHelpers::GetNativeClass(env, obj);
+  hi->RunOnEmulationThread([hi]() { hi->SaveResumeSaveState(); }, wait_for_completion);
+}
+
+DEFINE_JNI_ARGS_METHOD(void, AndroidHostInterface_setDisplayAlignment, jobject obj, jint alignment)
+{
+  AndroidHostInterface* hi = AndroidHelpers::GetNativeClass(env, obj);
+  hi->RunOnEmulationThread(
+    [hi, alignment]() { hi->GetDisplay()->SetDisplayAlignment(static_cast<HostDisplay::Alignment>(alignment)); });
+}
+
+DEFINE_JNI_ARGS_METHOD(bool, AndroidHostInterface_hasSurface, jobject obj)
+{
+  AndroidHostInterface* hi = AndroidHelpers::GetNativeClass(env, obj);
+  HostDisplay* display = hi->GetDisplay();
+  if (display)
+    return display->HasRenderSurface();
+  else
+    return false;
+}
+
+DEFINE_JNI_ARGS_METHOD(bool, AndroidHostInterface_isEmulationThreadPaused, jobject obj)
+{
+  AndroidHostInterface* hi = AndroidHelpers::GetNativeClass(env, obj);
+  return hi->IsEmulationThreadPaused();
+}
+
+DEFINE_JNI_ARGS_METHOD(void, AndroidHostInterface_pauseEmulationThread, jobject obj, jboolean paused)
+{
+  AndroidHostInterface* hi = AndroidHelpers::GetNativeClass(env, obj);
+  hi->PauseEmulationThread(paused);
+}
+
+DEFINE_JNI_ARGS_METHOD(jobject, AndroidHostInterface_getCheatList, jobject obj)
+{
+  if (!System::IsValid() || !System::HasCheatList())
+    return nullptr;
+
+  CheatList* cl = System::GetCheatList();
+  const u32 count = cl->GetCodeCount();
+
+  jobjectArray arr = env->NewObjectArray(count, s_CheatCode_class, nullptr);
+  for (u32 i = 0; i < count; i++)
+  {
+    const CheatCode& cc = cl->GetCode(i);
+
+    jobject java_cc = env->NewObject(s_CheatCode_class, s_CheatCode_constructor, static_cast<jint>(i),
+                                     env->NewStringUTF(cc.description.c_str()), cc.enabled);
+    env->SetObjectArrayElement(arr, i, java_cc);
+  }
+
+  return arr;
+}
+
+DEFINE_JNI_ARGS_METHOD(void, AndroidHostInterface_setCheatEnabled, jobject obj, jint index, jboolean enabled)
+{
+  if (!System::IsValid() || !System::HasCheatList())
+    return;
+
+  AndroidHostInterface* hi = AndroidHelpers::GetNativeClass(env, obj);
+  hi->RunOnEmulationThread([index, enabled, hi]() { hi->SetCheatCodeState(static_cast<u32>(index), enabled, true); });
+}
+
+DEFINE_JNI_ARGS_METHOD(void, AndroidHostInterface_addOSDMessage, jobject obj, jstring message, jfloat duration)
+{
+  AndroidHostInterface* hi = AndroidHelpers::GetNativeClass(env, obj);
+  hi->AddOSDMessage(AndroidHelpers::JStringToString(env, message), duration);
+}
+
+DEFINE_JNI_ARGS_METHOD(jboolean, AndroidHostInterface_hasAnyBIOSImages, jobject obj)
+{
+  AndroidHostInterface* hi = AndroidHelpers::GetNativeClass(env, obj);
+  return hi->HasAnyBIOSImages();
+}
+
+DEFINE_JNI_ARGS_METHOD(jstring, AndroidHostInterface_importBIOSImage, jobject obj, jbyteArray data)
+{
+  AndroidHostInterface* hi = AndroidHelpers::GetNativeClass(env, obj);
+
+  const jsize len = env->GetArrayLength(data);
+  if (len != BIOS::BIOS_SIZE)
+    return nullptr;
+
+  BIOS::Image image;
+  image.resize(static_cast<size_t>(len));
+  env->GetByteArrayRegion(data, 0, len, reinterpret_cast<jbyte*>(image.data()));
+
+  const BIOS::Hash hash = BIOS::GetHash(image);
+  const BIOS::ImageInfo* ii = BIOS::GetImageInfoForHash(hash);
+
+  const std::string dest_path(hi->GetUserDirectoryRelativePath("bios/%s.bin", hash.ToString().c_str()));
+  if (FileSystem::FileExists(dest_path.c_str()) ||
+      !FileSystem::WriteBinaryFile(dest_path.c_str(), image.data(), image.size()))
+  {
+    return nullptr;
+  }
+
+  if (ii)
+    return env->NewStringUTF(ii->description);
+  else
+    return env->NewStringUTF(hash.ToString().c_str());
+}

android/app/src/cpp/android_host_interface.h

@@ -0,0 +1,94 @@
+#pragma once
+#include "android_settings_interface.h"
+#include "common/event.h"
+#include "frontend-common/common_host_interface.h"
+#include <array>
+#include <atomic>
+#include <condition_variable>
+#include <functional>
+#include <jni.h>
+#include <memory>
+#include <string>
+#include <thread>
+
+struct ANativeWindow;
+
+class Controller;
+
+class AndroidHostInterface final : public CommonHostInterface
+{
+public:
+  AndroidHostInterface(jobject java_object, jobject context_object, std::string user_directory);
+  ~AndroidHostInterface() override;
+
+  bool Initialize() override;
+  void Shutdown() override;
+
+  const char* GetFrontendName() const override;
+  void RequestExit() override;
+
+  void ReportError(const char* message) override;
+  void ReportMessage(const char* message) override;
+
+  std::string GetStringSettingValue(const char* section, const char* key, const char* default_value = "") override;
+  bool GetBoolSettingValue(const char* section, const char* key, bool default_value = false) override;
+  int GetIntSettingValue(const char* section, const char* key, int default_value = 0) override;
+  float GetFloatSettingValue(const char* section, const char* key, float default_value = 0.0f) override;
+
+  bool IsEmulationThreadRunning() const { return m_emulation_thread.joinable(); }
+  bool IsEmulationThreadPaused() const;
+  bool StartEmulationThread(jobject emulation_activity, ANativeWindow* initial_surface,
+                            SystemBootParameters boot_params, bool resume_state);
+  void RunOnEmulationThread(std::function<void()> function, bool blocking = false);
+  void PauseEmulationThread(bool paused);
+  void StopEmulationThread();
+
+  void SurfaceChanged(ANativeWindow* surface, int format, int width, int height);
+
+  void SetControllerType(u32 index, std::string_view type_name);
+  void SetControllerButtonState(u32 index, s32 button_code, bool pressed);
+  void SetControllerAxisState(u32 index, s32 button_code, float value);
+
+  void RefreshGameList(bool invalidate_cache, bool invalidate_database);
+  void ApplySettings(bool display_osd_messages);
+
+protected:
+  void SetUserDirectory() override;
+  void LoadSettings() override;
+  void UpdateInputMap() override;
+
+  bool AcquireHostDisplay() override;
+  void ReleaseHostDisplay() override;
+  std::unique_ptr<AudioStream> CreateAudioStream(AudioBackend backend) override;
+
+  void OnSystemDestroyed() override;
+  void OnRunningGameChanged() override;
+
+private:
+  void EmulationThreadEntryPoint(jobject emulation_activity, ANativeWindow* initial_surface,
+                                 SystemBootParameters boot_params, bool resume_state);
+  void EmulationThreadLoop();
+
+  void CreateImGuiContext();
+  void DestroyImGuiContext();
+
+  jobject m_java_object = {};
+  jobject m_emulation_activity_object = {};
+
+  AndroidSettingsInterface m_settings_interface;
+
+  ANativeWindow* m_surface = nullptr;
+
+  std::mutex m_mutex;
+  std::condition_variable m_sleep_cv;
+  std::deque<std::function<void()>> m_callback_queue;
+
+  std::thread m_emulation_thread;
+  std::atomic_bool m_emulation_thread_stop_request{false};
+};
+
+namespace AndroidHelpers {
+JNIEnv* GetJNIEnv();
+AndroidHostInterface* GetNativeClass(JNIEnv* env, jobject obj);
+std::string JStringToString(JNIEnv* env, jstring str);
+} // namespace AndroidHelpers

android/app/src/cpp/android_settings_interface.cpp

@@ -0,0 +1,191 @@
+#include "android_settings_interface.h"
+#include "android_host_interface.h"
+#include "common/assert.h"
+#include "common/log.h"
+#include "common/string.h"
+#include "common/string_util.h"
+#include <algorithm>
+Log_SetChannel(AndroidSettingsInterface);
+
+ALWAYS_INLINE TinyString GetSettingKey(const char* section, const char* key)
+{
+  return TinyString::FromFormat("%s/%s", section, key);
+}
+
+AndroidSettingsInterface::AndroidSettingsInterface(jobject java_context)
+{
+  JNIEnv* env = AndroidHelpers::GetJNIEnv();
+  jclass c_preference_manager = env->FindClass("androidx/preference/PreferenceManager");
+  jclass c_set = env->FindClass("java/util/Set");
+  jmethodID m_get_default_shared_preferences =
+    env->GetStaticMethodID(c_preference_manager, "getDefaultSharedPreferences",
+                           "(Landroid/content/Context;)Landroid/content/SharedPreferences;");
+  Assert(c_preference_manager && c_set && m_get_default_shared_preferences);
+
+  m_java_shared_preferences =
+    env->CallStaticObjectMethod(c_preference_manager, m_get_default_shared_preferences, java_context);
+  Assert(m_java_shared_preferences);
+  m_java_shared_preferences = env->NewGlobalRef(m_java_shared_preferences);
+  jclass c_shared_preferences = env->GetObjectClass(m_java_shared_preferences);
+
+  m_get_boolean = env->GetMethodID(c_shared_preferences, "getBoolean", "(Ljava/lang/String;Z)Z");
+  m_get_int = env->GetMethodID(c_shared_preferences, "getInt", "(Ljava/lang/String;I)I");
+  m_get_float = env->GetMethodID(c_shared_preferences, "getFloat", "(Ljava/lang/String;F)F");
+  m_get_string =
+    env->GetMethodID(c_shared_preferences, "getString", "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;");
+  m_get_string_set =
+    env->GetMethodID(c_shared_preferences, "getStringSet", "(Ljava/lang/String;Ljava/util/Set;)Ljava/util/Set;");
+  m_set_to_array = env->GetMethodID(c_set, "toArray", "()[Ljava/lang/Object;");
+  Assert(m_get_boolean && m_get_int && m_get_float && m_get_string && m_get_string_set && m_set_to_array);
+}
+
+AndroidSettingsInterface::~AndroidSettingsInterface()
+{
+  if (m_java_shared_preferences)
+    AndroidHelpers::GetJNIEnv()->DeleteGlobalRef(m_java_shared_preferences);
+}
+
+void AndroidSettingsInterface::Clear()
+{
+  Log_ErrorPrint("Not implemented");
+}
+
+int AndroidSettingsInterface::GetIntValue(const char* section, const char* key, int default_value /*= 0*/)
+{
+  JNIEnv* env = AndroidHelpers::GetJNIEnv();
+
+  // Some of these settings are string lists...
+  jstring string_object = reinterpret_cast<jstring>(
+    env->CallObjectMethod(m_java_shared_preferences, m_get_string, env->NewStringUTF(GetSettingKey(section, key)),
+                          env->NewStringUTF(TinyString::FromFormat("%d", default_value))));
+  if (env->ExceptionCheck())
+  {
+    env->ExceptionClear();
+
+    // it might actually be an int (e.g. seek bar preference)
+    const int int_value = static_cast<int>(env->CallIntMethod(m_java_shared_preferences, m_get_int,
+                                                              env->NewStringUTF(GetSettingKey(section, key)), default_value));
+    if (env->ExceptionCheck())
+    {
+      env->ExceptionClear();
+      return default_value;
+    }
+
+    return int_value;
+  }
+
+  if (!string_object)
+    return default_value;
+
+  const char* data = env->GetStringUTFChars(string_object, nullptr);
+  Assert(data != nullptr);
+
+  std::optional<int> value = StringUtil::FromChars<int>(data);
+  env->ReleaseStringUTFChars(string_object, data);
+  return value.value_or(default_value);
+}
+
+float AndroidSettingsInterface::GetFloatValue(const char* section, const char* key, float default_value /*= 0.0f*/)
+{
+  JNIEnv* env = AndroidHelpers::GetJNIEnv();
+#if 0
+  return static_cast<float>(env->CallFloatMethod(m_java_shared_preferences, m_get_float,
+                                                 env->NewStringUTF(GetSettingKey(section, key)), default_value));
+#else
+  // Some of these settings are string lists...
+  jstring string_object = reinterpret_cast<jstring>(
+    env->CallObjectMethod(m_java_shared_preferences, m_get_string, env->NewStringUTF(GetSettingKey(section, key)),
+                          env->NewStringUTF(TinyString::FromFormat("%f", default_value))));
+  if (!string_object)
+    return default_value;
+
+  const char* data = env->GetStringUTFChars(string_object, nullptr);
+  Assert(data != nullptr);
+
+  std::optional<float> value = StringUtil::FromChars<float>(data);
+  env->ReleaseStringUTFChars(string_object, data);
+  return value.value_or(default_value);
+#endif
+}
+
+bool AndroidSettingsInterface::GetBoolValue(const char* section, const char* key, bool default_value /*= false*/)
+{
+  JNIEnv* env = AndroidHelpers::GetJNIEnv();
+  return static_cast<bool>(env->CallBooleanMethod(m_java_shared_preferences, m_get_boolean,
+                                                  env->NewStringUTF(GetSettingKey(section, key)), default_value));
+}
+
+std::string AndroidSettingsInterface::GetStringValue(const char* section, const char* key,
+                                                     const char* default_value /*= ""*/)
+{
+  JNIEnv* env = AndroidHelpers::GetJNIEnv();
+  jobject string_object =
+    env->CallObjectMethod(m_java_shared_preferences, m_get_string, env->NewStringUTF(GetSettingKey(section, key)),
+                          env->NewStringUTF(default_value));
+  return AndroidHelpers::JStringToString(env, reinterpret_cast<jstring>(string_object));
+}
+
+void AndroidSettingsInterface::SetIntValue(const char* section, const char* key, int value)
+{
+  Log_ErrorPrintf("SetIntValue(\"%s\", \"%s\", %d) not implemented", section, key, value);
+}
+
+void AndroidSettingsInterface::SetFloatValue(const char* section, const char* key, float value)
+{
+  Log_ErrorPrintf("SetFloatValue(\"%s\", \"%s\", %f) not implemented", section, key, value);
+}
+
+void AndroidSettingsInterface::SetBoolValue(const char* section, const char* key, bool value)
+{
+  Log_ErrorPrintf("SetBoolValue(\"%s\", \"%s\", %u) not implemented", section, key, static_cast<unsigned>(value));
+}
+
+void AndroidSettingsInterface::SetStringValue(const char* section, const char* key, const char* value)
+{
+  Log_ErrorPrintf("SetStringValue(\"%s\", \"%s\", \"%s\") not implemented", section, key, value);
+}
+
+void AndroidSettingsInterface::DeleteValue(const char* section, const char* key)
+{
+  Log_ErrorPrintf("DeleteValue(\"%s\", \"%s\") not implemented", section, key);
+}
+
+std::vector<std::string> AndroidSettingsInterface::GetStringList(const char* section, const char* key)
+{
+  JNIEnv* env = AndroidHelpers::GetJNIEnv();
+  jobject values_set = env->CallObjectMethod(m_java_shared_preferences, m_get_string_set,
+                                             env->NewStringUTF(GetSettingKey(section, key)), nullptr);
+  if (!values_set)
+    return {};
+
+  jobjectArray values_array = reinterpret_cast<jobjectArray>(env->CallObjectMethod(values_set, m_set_to_array));
+  if (!values_array)
+    return {};
+
+  jsize size = env->GetArrayLength(values_array);
+  std::vector<std::string> values;
+  values.reserve(size);
+  for (jsize i = 0; i < size; i++)
+    values.push_back(
+      AndroidHelpers::JStringToString(env, reinterpret_cast<jstring>(env->GetObjectArrayElement(values_array, i))));
+
+  return values;
+}
+
+void AndroidSettingsInterface::SetStringList(const char* section, const char* key,
+                                             const std::vector<std::string>& items)
+{
+  Log_ErrorPrintf("SetStringList(\"%s\", \"%s\") not implemented", section, key);
+}
+
+bool AndroidSettingsInterface::RemoveFromStringList(const char* section, const char* key, const char* item)
+{
+  Log_ErrorPrintf("RemoveFromStringList(\"%s\", \"%s\", \"%s\") not implemented", section, key, item);
+  return false;
+}
+
+bool AndroidSettingsInterface::AddToStringList(const char* section, const char* key, const char* item)
+{
+  Log_ErrorPrintf("AddToStringList(\"%s\", \"%s\", \"%s\") not implemented", section, key, item);
+  return false;
+}

android/app/src/cpp/android_settings_interface.h

@@ -0,0 +1,37 @@
+#pragma once
+#include "core/settings.h"
+#include <jni.h>
+
+class AndroidSettingsInterface : public SettingsInterface
+{
+public:
+  AndroidSettingsInterface(jobject java_context);
+  ~AndroidSettingsInterface();
+
+  void Clear() override;
+
+  int GetIntValue(const char* section, const char* key, int default_value = 0) override;
+  float GetFloatValue(const char* section, const char* key, float default_value = 0.0f) override;
+  bool GetBoolValue(const char* section, const char* key, bool default_value = false) override;
+  std::string GetStringValue(const char* section, const char* key, const char* default_value = "") override;
+
+  void SetIntValue(const char* section, const char* key, int value) override;
+  void SetFloatValue(const char* section, const char* key, float value) override;
+  void SetBoolValue(const char* section, const char* key, bool value) override;
+  void SetStringValue(const char* section, const char* key, const char* value) override;
+  void DeleteValue(const char* section, const char* key) override;
+
+  std::vector<std::string> GetStringList(const char* section, const char* key) override;
+  void SetStringList(const char* section, const char* key, const std::vector<std::string>& items) override;
+  bool RemoveFromStringList(const char* section, const char* key, const char* item) override;
+  bool AddToStringList(const char* section, const char* key, const char* item) override;
+
+private:
+  jobject m_java_shared_preferences{};
+  jmethodID m_get_boolean{};
+  jmethodID m_get_int{};
+  jmethodID m_get_float{};
+  jmethodID m_get_string{};
+  jmethodID m_get_string_set{};
+  jmethodID m_set_to_array{};
+};

android/app/src/cpp/opensles_audio_stream.cpp

@@ -0,0 +1,209 @@
+#include "opensles_audio_stream.h"
+#include "common/assert.h"
+#include "common/log.h"
+#include <cmath>
+Log_SetChannel(OpenSLESAudioStream);
+
+// Based off Dolphin's OpenSLESStream class.
+
+OpenSLESAudioStream::OpenSLESAudioStream() = default;
+
+OpenSLESAudioStream::~OpenSLESAudioStream()
+{
+  if (IsOpen())
+    OpenSLESAudioStream::CloseDevice();
+}
+
+std::unique_ptr<AudioStream> OpenSLESAudioStream::Create()
+{
+  return std::make_unique<OpenSLESAudioStream>();
+}
+
+bool OpenSLESAudioStream::OpenDevice()
+{
+  DebugAssert(!IsOpen());
+
+  SLresult res = slCreateEngine(&m_engine, 0, nullptr, 0, nullptr, nullptr);
+  if (res != SL_RESULT_SUCCESS)
+  {
+    Log_ErrorPrintf("slCreateEngine failed: %d", res);
+    return false;
+  }
+
+  res = (*m_engine)->Realize(m_engine, SL_BOOLEAN_FALSE);
+  if (res != SL_RESULT_SUCCESS)
+  {
+    Log_ErrorPrintf("Realize(Engine) failed: %d", res);
+    CloseDevice();
+    return false;
+  }
+
+  res = (*m_engine)->GetInterface(m_engine, SL_IID_ENGINE, &m_engine_engine);
+  if (res != SL_RESULT_SUCCESS)
+  {
+    Log_ErrorPrintf("GetInterface(SL_IID_ENGINE) failed: %d", res);
+    CloseDevice();
+    return false;
+  }
+
+  res = (*m_engine_engine)->CreateOutputMix(m_engine_engine, &m_output_mix, 0, 0, 0);
+  if (res != SL_RESULT_SUCCESS)
+  {
+    Log_ErrorPrintf("CreateOutputMix failed: %d", res);
+    CloseDevice();
+    return false;
+  }
+
+  res = (*m_output_mix)->Realize(m_output_mix, SL_BOOLEAN_FALSE);
+  if (res != SL_RESULT_SUCCESS)
+  {
+    Log_ErrorPrintf("Realize(OutputMix) mix failed: %d", res);
+    CloseDevice();
+    return false;
+  }
+
+  SLDataLocator_AndroidSimpleBufferQueue dloc_bq{SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE, NUM_BUFFERS};
+  SLDataFormat_PCM format = {SL_DATAFORMAT_PCM,
+                             m_channels,
+                             m_output_sample_rate * 1000u,
+                             SL_PCMSAMPLEFORMAT_FIXED_16,
+                             SL_PCMSAMPLEFORMAT_FIXED_16,
+                             SL_SPEAKER_FRONT_LEFT | SL_SPEAKER_FRONT_RIGHT,
+                             SL_BYTEORDER_LITTLEENDIAN};
+  SLDataSource dsrc{&dloc_bq, &format};
+  SLDataLocator_OutputMix dloc_outputmix{SL_DATALOCATOR_OUTPUTMIX, m_output_mix};
+  SLDataSink dsink{&dloc_outputmix, nullptr};
+
+  const std::array<SLInterfaceID, 2> ap_interfaces = {{SL_IID_BUFFERQUEUE, SL_IID_VOLUME}};
+  const std::array<SLboolean, 2> ap_interfaces_req = {{true, true}};
+  res = (*m_engine_engine)
+          ->CreateAudioPlayer(m_engine_engine, &m_player, &dsrc, &dsink, static_cast<u32>(ap_interfaces.size()),
+                              ap_interfaces.data(), ap_interfaces_req.data());
+  if (res != SL_RESULT_SUCCESS)
+  {
+    Log_ErrorPrintf("CreateAudioPlayer failed: %d", res);
+    CloseDevice();
+    return false;
+  }
+
+  res = (*m_player)->Realize(m_player, SL_BOOLEAN_FALSE);
+  if (res != SL_RESULT_SUCCESS)
+  {
+    Log_ErrorPrintf("Realize(AudioPlayer) failed: %d", res);
+    CloseDevice();
+    return false;
+  }
+
+  res = (*m_player)->GetInterface(m_player, SL_IID_PLAY, &m_play_interface);
+  if (res != SL_RESULT_SUCCESS)
+  {
+    Log_ErrorPrintf("GetInterface(SL_IID_PLAY) failed: %d", res);
+    CloseDevice();
+    return false;
+  }
+
+  res = (*m_player)->GetInterface(m_player, SL_IID_BUFFERQUEUE, &m_buffer_queue_interface);
+  if (res != SL_RESULT_SUCCESS)
+  {
+    Log_ErrorPrintf("GetInterface(SL_IID_BUFFERQUEUE) failed: %d", res);
+    CloseDevice();
+    return false;
+  }
+
+  res = (*m_player)->GetInterface(m_player, SL_IID_VOLUME, &m_volume_interface);
+  if (res != SL_RESULT_SUCCESS)
+  {
+    Log_ErrorPrintf("GetInterface(SL_IID_VOLUME) failed: %d", res);
+    CloseDevice();
+    return false;
+  }
+
+  res = (*m_buffer_queue_interface)->RegisterCallback(m_buffer_queue_interface, BufferCallback, this);
+  if (res != SL_RESULT_SUCCESS)
+  {
+    Log_ErrorPrintf("Failed to register callback: %d", res);
+    CloseDevice();
+    return false;
+  }
+
+  for (u32 i = 0; i < NUM_BUFFERS; i++)
+    m_buffers[i] = std::make_unique<SampleType[]>(m_buffer_size * m_channels);
+
+  Log_InfoPrintf("OpenSL ES device opened: %uhz, %u channels, %u buffer size, %u buffers",
+      m_output_sample_rate, m_channels, m_buffer_size, NUM_BUFFERS);
+  return true;
+}
+
+void OpenSLESAudioStream::PauseDevice(bool paused)
+{
+  if (m_paused == paused)
+    return;
+
+  SLresult res = (*m_play_interface)->SetPlayState(m_play_interface, paused ? SL_PLAYSTATE_PAUSED : SL_PLAYSTATE_PLAYING);
+  if (res != SL_RESULT_SUCCESS)
+    Log_ErrorPrintf("SetPlayState failed: %d", res);
+
+  if (!paused && !m_buffer_enqueued)
+  {
+    m_buffer_enqueued = true;
+    EnqueueBuffer();
+  }
+
+  m_paused = paused;
+}
+
+void OpenSLESAudioStream::CloseDevice()
+{
+  m_buffers = {};
+  m_current_buffer = 0;
+  m_paused = true;
+  m_buffer_enqueued = false;
+
+  if (m_player)
+  {
+    (*m_player)->Destroy(m_player);
+    m_volume_interface = {};
+    m_buffer_queue_interface = {};
+    m_play_interface = {};
+    m_player = {};
+  }
+  if (m_output_mix)
+  {
+    (*m_output_mix)->Destroy(m_output_mix);
+    m_output_mix = {};
+  }
+  (*m_engine)->Destroy(m_engine);
+  m_engine_engine = {};
+  m_engine = {};
+}
+
+void OpenSLESAudioStream::SetOutputVolume(u32 volume)
+{
+  const SLmillibel attenuation = (volume == 0) ?
+                                   SL_MILLIBEL_MIN :
+                                   static_cast<SLmillibel>(2000.0f * std::log10(static_cast<float>(volume) / 100.0f));
+  SLresult res = (*m_volume_interface)->SetVolumeLevel(m_volume_interface, attenuation);
+  if (res != SL_RESULT_SUCCESS)
+    Log_ErrorPrintf("SetVolumeLevel failed: %d", res);
+}
+
+void OpenSLESAudioStream::EnqueueBuffer()
+{
+  SampleType* samples = m_buffers[m_current_buffer].get();
+  ReadFrames(samples, m_buffer_size, false);
+
+  SLresult res = (*m_buffer_queue_interface)
+                   ->Enqueue(m_buffer_queue_interface, samples, m_buffer_size * m_channels * sizeof(SampleType));
+  if (res != SL_RESULT_SUCCESS)
+    Log_ErrorPrintf("Enqueue buffer failed: %d", res);
+
+  m_current_buffer = (m_current_buffer + 1) % NUM_BUFFERS;
+}
+
+void OpenSLESAudioStream::BufferCallback(SLAndroidSimpleBufferQueueItf buffer_queue, void* context)
+{
+  OpenSLESAudioStream* const this_ptr = static_cast<OpenSLESAudioStream*>(context);
+  this_ptr->EnqueueBuffer();
+}
+
+void OpenSLESAudioStream::FramesAvailable() {}

android/app/src/cpp/opensles_audio_stream.h

@@ -0,0 +1,48 @@
+#pragma once
+#include "common/audio_stream.h"
+#include <SLES/OpenSLES.h>
+#include <SLES/OpenSLES_Android.h>
+#include <array>
+#include <memory>
+
+class OpenSLESAudioStream final : public AudioStream
+{
+public:
+  OpenSLESAudioStream();
+  ~OpenSLESAudioStream();
+
+  static std::unique_ptr<AudioStream> Create();
+
+  void SetOutputVolume(u32 volume) override;
+
+protected:
+  enum : u32
+  {
+    NUM_BUFFERS = 2
+  };
+
+  ALWAYS_INLINE bool IsOpen() const { return (m_engine != nullptr); }
+
+  bool OpenDevice() override;
+  void PauseDevice(bool paused) override;
+  void CloseDevice() override;
+  void FramesAvailable() override;
+
+  void EnqueueBuffer();
+
+  static void BufferCallback(SLAndroidSimpleBufferQueueItf buffer_queue, void* context);
+
+  SLObjectItf m_engine{};
+  SLEngineItf m_engine_engine{};
+  SLObjectItf m_output_mix{};
+
+  SLObjectItf m_player{};
+  SLPlayItf m_play_interface{};
+  SLAndroidSimpleBufferQueueItf m_buffer_queue_interface{};
+  SLVolumeItf m_volume_interface{};
+
+  std::array<std::unique_ptr<SampleType[]>, NUM_BUFFERS> m_buffers;
+  u32 m_current_buffer = 0;
+  bool m_paused = true;
+  bool m_buffer_enqueued = false;
+};

android/app/src/main/AndroidManifest.xml

@@ -0,0 +1,49 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="com.github.stenzek.duckstation">
+
+    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
+    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
+
+    <application
+        android:allowBackup="true"
+        android:icon="@mipmap/ic_launcher"
+        android:label="@string/app_name"
+        android:requestLegacyExternalStorage="true"
+        android:roundIcon="@mipmap/ic_launcher_round"
+        android:supportsRtl="true"
+        android:theme="@style/AppTheme">
+        <activity
+            android:name=".EmulationActivity"
+            android:configChanges="orientation|keyboardHidden|screenSize"
+            android:label="@string/title_activity_emulation"
+            android:parentActivityName=".MainActivity"
+            android:theme="@style/Theme.AppCompat.DayNight.NoActionBar"
+            android:immersive="true">
+            <meta-data
+                android:name="android.support.PARENT_ACTIVITY"
+                android:value="com.github.stenzek.duckstation.MainActivity" />
+        </activity>
+        <activity
+            android:name=".SettingsActivity"
+            android:configChanges="orientation|keyboardHidden|screenSize"
+            android:label="@string/title_activity_settings"
+            android:parentActivityName=".MainActivity">
+            <meta-data
+                android:name="android.support.PARENT_ACTIVITY"
+                android:value="com.github.stenzek.duckstation.MainActivity" />
+        </activity>
+        <activity
+            android:name=".MainActivity"
+            android:configChanges="orientation|keyboardHidden|screenSize"
+            android:label="@string/app_name"
+            android:theme="@style/AppTheme.NoActionBar">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+    </application>
+
+</manifest>

android/app/src/main/java/com/github/stenzek/duckstation/AndroidHostInterface.java

@@ -0,0 +1,107 @@
+package com.github.stenzek.duckstation;
+
+import android.content.Context;
+import android.os.Environment;
+import android.util.Log;
+import android.view.Surface;
+import android.widget.Toast;
+
+import com.google.android.material.snackbar.Snackbar;
+
+public class AndroidHostInterface {
+    public final static int DISPLAY_ALIGNMENT_TOP_OR_LEFT = 0;
+    public final static int DISPLAY_ALIGNMENT_CENTER = 1;
+    public final static int DISPLAY_ALIGNMENT_RIGHT_OR_BOTTOM = 2;
+
+    private long mNativePointer;
+    private Context mContext;
+
+    static public native AndroidHostInterface create(Context context, String userDirectory);
+
+    public AndroidHostInterface(Context context) {
+        this.mContext = context;
+    }
+
+    public void reportError(String message) {
+        Toast.makeText(mContext, message, Toast.LENGTH_LONG).show();
+    }
+
+    public void reportMessage(String message) {
+        Toast.makeText(mContext, message, Toast.LENGTH_SHORT).show();
+    }
+
+    public native boolean isEmulationThreadRunning();
+
+    public native boolean startEmulationThread(EmulationActivity emulationActivity, Surface surface, String filename, boolean resumeState, String state_filename);
+
+    public native boolean isEmulationThreadPaused();
+
+    public native void pauseEmulationThread(boolean paused);
+
+    public native void stopEmulationThread();
+
+    public native boolean hasSurface();
+
+    public native void surfaceChanged(Surface surface, int format, int width, int height);
+
+    // TODO: Find a better place for this.
+    public native void setControllerType(int index, String typeName);
+
+    public native void setControllerButtonState(int index, int buttonCode, boolean pressed);
+
+    public native void setControllerAxisState(int index, int axisCode, float value);
+
+    public static native int getControllerButtonCode(String controllerType, String buttonName);
+
+    public static native int getControllerAxisCode(String controllerType, String axisName);
+
+    public native void refreshGameList(boolean invalidateCache, boolean invalidateDatabase);
+
+    public native GameListEntry[] getGameListEntries();
+
+    public native void resetSystem();
+
+    public native void loadState(boolean global, int slot);
+
+    public native void saveState(boolean global, int slot);
+
+    public native void saveResumeState(boolean waitForCompletion);
+
+    public native void applySettings();
+
+    public native void setDisplayAlignment(int alignment);
+
+    public native CheatCode[] getCheatList();
+    public native void setCheatEnabled(int index, boolean enabled);
+
+    public native void addOSDMessage(String message, float duration);
+
+    public native boolean hasAnyBIOSImages();
+    public native String importBIOSImage(byte[] data);
+
+    static {
+        System.loadLibrary("duckstation-native");
+    }
+
+    static private AndroidHostInterface mInstance;
+
+    static public boolean createInstance(Context context) {
+        // Set user path.
+        String externalStorageDirectory = Environment.getExternalStorageDirectory().getAbsolutePath();
+        if (externalStorageDirectory.isEmpty())
+            externalStorageDirectory = "/sdcard";
+
+        externalStorageDirectory += "/duckstation";
+        Log.i("AndroidHostInterface", "User directory: " + externalStorageDirectory);
+        mInstance = create(context, externalStorageDirectory);
+        return mInstance != null;
+    }
+
+    static public boolean hasInstance() {
+        return mInstance != null;
+    }
+
+    static public AndroidHostInterface getInstance() {
+        return mInstance;
+    }
+}

android/app/src/main/java/com/github/stenzek/duckstation/CheatCode.java

@@ -0,0 +1,17 @@
+package com.github.stenzek.duckstation;
+
+public class CheatCode {
+    private int mIndex;
+    private String mName;
+    private boolean mEnabled;
+
+    public CheatCode(int index, String name, boolean enabled) {
+        mIndex = index;
+        mName = name;
+        mEnabled = enabled;
+    }
+
+    public int getIndex() { return mIndex; }
+    public String getName() { return mName; }
+    public boolean isEnabled() { return mEnabled; }
+}

android/app/src/main/java/com/github/stenzek/duckstation/ConsoleRegion.java

@@ -0,0 +1,8 @@
+package com.github.stenzek.duckstation;
+
+public enum ConsoleRegion {
+    AutoDetect,
+    NTSC_J,
+    NTSC_U,
+    PAL
+}

android/app/src/main/java/com/github/stenzek/duckstation/DiscRegion.java

@@ -0,0 +1,8 @@
+package com.github.stenzek.duckstation;
+
+public enum DiscRegion {
+    NTSC_J,
+    NTSC_U,
+    PAL,
+    Other
+}

android/app/src/main/java/com/github/stenzek/duckstation/EmulationActivity.java

@@ -0,0 +1,467 @@
+package com.github.stenzek.duckstation;
+
+import android.annotation.SuppressLint;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.appcompat.app.ActionBar;
+import androidx.appcompat.app.AlertDialog;
+import androidx.appcompat.app.AppCompatActivity;
+
+import android.content.Context;
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.content.SharedPreferences;
+import android.content.res.Configuration;
+import android.hardware.input.InputManager;
+import android.os.Bundle;
+import android.os.Handler;
+import android.util.AndroidException;
+import android.util.Log;
+import android.view.Menu;
+import android.view.SurfaceHolder;
+import android.view.View;
+import android.view.MenuItem;
+import android.widget.FrameLayout;
+import android.widget.Toast;
+
+import androidx.appcompat.widget.PopupMenu;
+import androidx.preference.PreferenceManager;
+
+/**
+ * An example full-screen activity that shows and hides the system UI (i.e.
+ * status bar and navigation/system bar) with user interaction.
+ */
+public class EmulationActivity extends AppCompatActivity implements SurfaceHolder.Callback {
+    /**
+     * Settings interfaces.
+     */
+    private SharedPreferences mPreferences;
+    private boolean mWasDestroyed = false;
+    private boolean mStopRequested = false;
+    private boolean mWasPausedOnSurfaceLoss = false;
+    private boolean mApplySettingsOnSurfaceRestored = false;
+    private String mGameTitle = null;
+    private EmulationSurfaceView mContentView;
+
+    private boolean getBooleanSetting(String key, boolean defaultValue) {
+        return mPreferences.getBoolean(key, defaultValue);
+    }
+
+    private void setBooleanSetting(String key, boolean value) {
+        SharedPreferences.Editor editor = mPreferences.edit();
+        editor.putBoolean(key, value);
+        editor.apply();
+    }
+
+    private String getStringSetting(String key, String defaultValue) {
+        return mPreferences.getString(key, defaultValue);
+    }
+
+    private void setStringSetting(String key, String value) {
+        SharedPreferences.Editor editor = mPreferences.edit();
+        editor.putString(key, value);
+        editor.apply();
+    }
+
+    public void reportError(String message) {
+        Log.e("EmulationActivity", message);
+
+        Object lock = new Object();
+        runOnUiThread(() -> {
+            // Toast.makeText(this, message, Toast.LENGTH_LONG);
+            new AlertDialog.Builder(this)
+                    .setTitle("Error")
+                    .setMessage(message)
+                    .setPositiveButton("OK", (dialog, button) -> {
+                        dialog.dismiss();
+                        synchronized (lock) {
+                            lock.notify();
+                        }
+                    })
+                    .create()
+                    .show();
+        });
+
+        synchronized (lock) {
+            try {
+                lock.wait();
+            } catch (InterruptedException e) {
+            }
+        }
+    }
+
+    public void reportMessage(String message) {
+        Log.i("EmulationActivity", message);
+        runOnUiThread(() -> {
+            Toast.makeText(this, message, Toast.LENGTH_SHORT);
+        });
+    }
+
+    public void onEmulationStarted() {
+    }
+
+    public void onEmulationStopped() {
+        runOnUiThread(() -> {
+            AndroidHostInterface.getInstance().stopEmulationThread();
+            if (!mWasDestroyed && !mStopRequested)
+                finish();
+        });
+    }
+
+    public void onGameTitleChanged(String title) {
+        runOnUiThread(() -> {
+            mGameTitle = title;
+        });
+    }
+
+    private void applySettings() {
+        if (!AndroidHostInterface.getInstance().isEmulationThreadRunning())
+            return;
+
+        if (AndroidHostInterface.getInstance().hasSurface())
+            AndroidHostInterface.getInstance().applySettings();
+        else
+            mApplySettingsOnSurfaceRestored = true;
+    }
+
+    @Override
+    public void surfaceCreated(SurfaceHolder holder) {
+    }
+
+    @Override
+    public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
+        // Once we get a surface, we can boot.
+        if (AndroidHostInterface.getInstance().isEmulationThreadRunning()) {
+            final boolean hadSurface = AndroidHostInterface.getInstance().hasSurface();
+            AndroidHostInterface.getInstance().surfaceChanged(holder.getSurface(), format, width, height);
+            updateOrientation();
+
+            if (holder.getSurface() != null && !hadSurface && AndroidHostInterface.getInstance().isEmulationThreadPaused() && !mWasPausedOnSurfaceLoss) {
+                AndroidHostInterface.getInstance().pauseEmulationThread(false);
+            }
+
+            if (mApplySettingsOnSurfaceRestored) {
+                AndroidHostInterface.getInstance().applySettings();
+                mApplySettingsOnSurfaceRestored = false;
+            }
+
+            return;
+        }
+
+        final String bootPath = getIntent().getStringExtra("bootPath");
+        final boolean resumeState = getIntent().getBooleanExtra("resumeState", false);
+        final String bootSaveStatePath = getIntent().getStringExtra("saveStatePath");
+
+        AndroidHostInterface.getInstance().startEmulationThread(this, holder.getSurface(), bootPath, resumeState, bootSaveStatePath);
+        updateOrientation();
+    }
+
+    @Override
+    public void surfaceDestroyed(SurfaceHolder holder) {
+        if (!AndroidHostInterface.getInstance().isEmulationThreadRunning())
+            return;
+
+        Log.i("EmulationActivity", "Surface destroyed");
+
+        // Save the resume state in case we never get back again...
+        if (!mStopRequested)
+            AndroidHostInterface.getInstance().saveResumeState(true);
+
+        mWasPausedOnSurfaceLoss = AndroidHostInterface.getInstance().isEmulationThreadPaused();
+        AndroidHostInterface.getInstance().pauseEmulationThread(true);
+        AndroidHostInterface.getInstance().surfaceChanged(null, 0, 0, 0);
+    }
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        mPreferences = PreferenceManager.getDefaultSharedPreferences(this);
+        Log.i("EmulationActivity", "OnCreate");
+
+        enableFullscreenImmersive();
+        setContentView(R.layout.activity_emulation);
+
+        mContentView = findViewById(R.id.fullscreen_content);
+        mContentView.getHolder().addCallback(this);
+        mContentView.setFocusable(true);
+        mContentView.requestFocus();
+
+        // Hook up controller input.
+        updateControllers();
+        registerInputDeviceListener();
+    }
+
+    @Override
+    protected void onPostCreate(Bundle savedInstanceState) {
+        super.onPostCreate(savedInstanceState);
+        enableFullscreenImmersive();
+    }
+
+    @Override
+    protected void onPostResume() {
+        super.onPostResume();
+        enableFullscreenImmersive();
+    }
+
+    @Override
+    protected void onDestroy() {
+        super.onDestroy();
+        Log.i("EmulationActivity", "OnStop");
+        if (AndroidHostInterface.getInstance().isEmulationThreadRunning()) {
+            mWasDestroyed = true;
+            AndroidHostInterface.getInstance().stopEmulationThread();
+        }
+
+        unregisterInputDeviceListener();
+    }
+
+    @Override
+    protected void onActivityResult(int requestCode, int resultCode, @Nullable Intent data) {
+        super.onActivityResult(requestCode, resultCode, data);
+
+        if (requestCode == REQUEST_CODE_SETTINGS) {
+            if (AndroidHostInterface.getInstance().isEmulationThreadRunning())
+                applySettings();
+        }
+    }
+
+    @Override
+    public void onBackPressed() {
+        showMenu();
+    }
+
+    @Override
+    public void onConfigurationChanged(@NonNull Configuration newConfig) {
+        super.onConfigurationChanged(newConfig);
+        updateOrientation(newConfig.orientation);
+    }
+
+    private void updateOrientation() {
+        final int orientation = getResources().getConfiguration().orientation;
+        updateOrientation(orientation);
+    }
+
+    private void updateOrientation(int newOrientation) {
+        if (!AndroidHostInterface.getInstance().isEmulationThreadRunning())
+            return;
+
+        if (newOrientation == Configuration.ORIENTATION_PORTRAIT)
+            AndroidHostInterface.getInstance().setDisplayAlignment(AndroidHostInterface.DISPLAY_ALIGNMENT_TOP_OR_LEFT);
+        else
+            AndroidHostInterface.getInstance().setDisplayAlignment(AndroidHostInterface.DISPLAY_ALIGNMENT_CENTER);
+    }
+
+    private void enableFullscreenImmersive()
+    {
+        getWindow().getDecorView().setSystemUiVisibility(
+                View.SYSTEM_UI_FLAG_LAYOUT_STABLE |
+                        View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION |
+                        View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN |
+                        View.SYSTEM_UI_FLAG_HIDE_NAVIGATION |
+                        View.SYSTEM_UI_FLAG_FULLSCREEN |
+                        View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY);
+        if (mContentView != null)
+            mContentView.requestFocus();
+    }
+
+    private static final int REQUEST_CODE_SETTINGS = 0;
+
+    private void showMenu() {
+        AlertDialog.Builder builder = new AlertDialog.Builder(this);
+        if (mGameTitle != null && !mGameTitle.isEmpty())
+            builder.setTitle(mGameTitle);
+
+        builder.setItems(R.array.emulation_menu, (dialogInterface, i) -> {
+            switch (i)
+            {
+                case 0:     // Quick Load
+                {
+                    AndroidHostInterface.getInstance().loadState(false, 0);
+                    return;
+                }
+
+                case 1:     // Quick Save
+                {
+                    AndroidHostInterface.getInstance().saveState(false, 0);
+                    return;
+                }
+
+                case 2:     // Toggle Speed Limiter
+                {
+                    boolean newSetting = !getBooleanSetting("Main/SpeedLimiterEnabled", true);
+                    setBooleanSetting("Main/SpeedLimiterEnabled", newSetting);
+                    applySettings();
+                    return;
+                }
+
+                case 3:     // More Options
+                {
+                    showMoreMenu();
+                    return;
+                }
+
+                case 4:     // Quit
+                {
+                    mStopRequested = true;
+                    finish();
+                    return;
+                }
+            }
+        });
+        builder.setOnDismissListener(dialogInterface -> enableFullscreenImmersive());
+        builder.create().show();
+    }
+
+    private void showMoreMenu() {
+        AlertDialog.Builder builder = new AlertDialog.Builder(this);
+        if (mGameTitle != null && !mGameTitle.isEmpty())
+            builder.setTitle(mGameTitle);
+
+        builder.setItems(R.array.emulation_more_menu, (dialogInterface, i) -> {
+            switch (i)
+            {
+                case 0:     // Reset
+                {
+                    AndroidHostInterface.getInstance().resetSystem();
+                    return;
+                }
+
+                case 1:     // Cheats
+                {
+                    showCheatsMenu();
+                    return;
+                }
+
+                case 2:     // Change Disc
+                {
+                    return;
+                }
+
+                case 3:     // Change Touchscreen Controller
+                {
+                    showTouchscreenControllerMenu();
+                    return;
+                }
+
+                case 4:     // Settings
+                {
+                    Intent intent = new Intent(EmulationActivity.this, SettingsActivity.class);
+                    intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
+                    startActivityForResult(intent, REQUEST_CODE_SETTINGS);
+                    return;
+                }
+
+                case 5:     // Quit
+                {
+                    finish();
+                    return;
+                }
+            }
+        });
+        builder.setOnDismissListener(dialogInterface -> enableFullscreenImmersive());
+        builder.create().show();
+    }
+
+    private void showTouchscreenControllerMenu() {
+        AlertDialog.Builder builder = new AlertDialog.Builder(this);
+        builder.setItems(R.array.settings_touchscreen_controller_view_entries, (dialogInterface, i) -> {
+            String[] values = getResources().getStringArray(R.array.settings_touchscreen_controller_view_values);
+            setStringSetting("Controller1/TouchscreenControllerView", values[i]);
+            updateControllers();
+        });
+        builder.setOnDismissListener(dialogInterface -> enableFullscreenImmersive());
+        builder.create().show();
+    }
+
+    private void showCheatsMenu() {
+        final CheatCode[] cheats = AndroidHostInterface.getInstance().getCheatList();
+        if (cheats == null) {
+            AndroidHostInterface.getInstance().addOSDMessage("No cheats are loaded.", 5.0f);
+            return;
+        }
+
+        AlertDialog.Builder builder = new AlertDialog.Builder(this);
+
+        CharSequence[] items = new CharSequence[cheats.length];
+        for (int i = 0; i < cheats.length; i++) {
+            final CheatCode cc = cheats[i];
+            items[i] = String.format("%s %s", cc.isEnabled() ? "(ON)" : "(OFF)", cc.getName());
+        }
+
+        builder.setItems(items, (dialogInterface, i) -> AndroidHostInterface.getInstance().setCheatEnabled(i, !cheats[i].isEnabled()));
+        builder.setOnDismissListener(dialogInterface -> enableFullscreenImmersive());
+        builder.create().show();
+    }
+
+    /**
+     * Touchscreen controller overlay
+     */
+    TouchscreenControllerView mTouchscreenController;
+
+    public void updateControllers() {
+        final String controllerType = getStringSetting("Controller1/Type", "DigitalController");
+        final String viewType = getStringSetting("Controller1/TouchscreenControllerView", "digital");
+        final boolean autoHideTouchscreenController = getBooleanSetting("Controller1/AutoHideTouchscreenController", false);
+        final FrameLayout activityLayout = findViewById(R.id.frameLayout);
+
+        Log.i("EmulationActivity", "Controller type: " + controllerType);
+        Log.i("EmulationActivity", "View type: " + viewType);
+
+        final boolean hasAnyControllers = mContentView.initControllerMapping(controllerType);
+
+        if (controllerType == "none" || viewType == "none" || (hasAnyControllers && autoHideTouchscreenController)) {
+            if (mTouchscreenController != null) {
+                activityLayout.removeView(mTouchscreenController);
+                mTouchscreenController = null;
+            }
+        } else {
+            if (mTouchscreenController == null) {
+                mTouchscreenController = new TouchscreenControllerView(this);
+                activityLayout.addView(mTouchscreenController);
+            }
+
+            mTouchscreenController.init(0, controllerType, viewType);
+        }
+    }
+
+    private InputManager.InputDeviceListener mInputDeviceListener;
+    private void registerInputDeviceListener() {
+        if (mInputDeviceListener != null)
+            return;
+
+        mInputDeviceListener = new InputManager.InputDeviceListener() {
+            @Override
+            public void onInputDeviceAdded(int i) {
+                Log.i("EmulationActivity", String.format("InputDeviceAdded %d", i));
+                updateControllers();
+            }
+
+            @Override
+            public void onInputDeviceRemoved(int i) {
+                Log.i("EmulationActivity", String.format("InputDeviceRemoved %d", i));
+                updateControllers();
+            }
+
+            @Override
+            public void onInputDeviceChanged(int i) {
+                Log.i("EmulationActivity", String.format("InputDeviceChanged %d", i));
+                updateControllers();
+            }
+        };
+
+        InputManager inputManager = ((InputManager)getSystemService(Context.INPUT_SERVICE));
+        if (inputManager != null)
+            inputManager.registerInputDeviceListener(mInputDeviceListener, null);
+    }
+    private void unregisterInputDeviceListener() {
+        if (mInputDeviceListener == null)
+            return;
+
+        InputManager inputManager = ((InputManager)getSystemService(Context.INPUT_SERVICE));
+        if (inputManager != null)
+            inputManager.unregisterInputDeviceListener(mInputDeviceListener);
+        
+        mInputDeviceListener = null;
+    }
+}

android/app/src/main/java/com/github/stenzek/duckstation/EmulationSurfaceView.java

@@ -0,0 +1,260 @@
+package com.github.stenzek.duckstation;
+
+import android.content.Context;
+import android.hardware.input.InputManager;
+import android.util.ArrayMap;
+import android.util.AttributeSet;
+import android.util.Log;
+import android.util.Pair;
+import android.view.InputDevice;
+import android.view.KeyEvent;
+import android.view.MotionEvent;
+import android.view.SurfaceView;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class EmulationSurfaceView extends SurfaceView {
+    public EmulationSurfaceView(Context context) {
+        super(context);
+    }
+
+    public EmulationSurfaceView(Context context, AttributeSet attrs) {
+        super(context, attrs);
+    }
+
+    public EmulationSurfaceView(Context context, AttributeSet attrs, int defStyle) {
+        super(context, attrs, defStyle);
+    }
+
+    private boolean isDPadOrButtonEvent(KeyEvent event) {
+        final int source = event.getSource();
+        return (source & InputDevice.SOURCE_GAMEPAD) == InputDevice.SOURCE_GAMEPAD ||
+                (source & InputDevice.SOURCE_DPAD) == InputDevice.SOURCE_DPAD ||
+                (source & InputDevice.SOURCE_JOYSTICK) == InputDevice.SOURCE_JOYSTICK;
+    }
+
+    @Override
+    public boolean onKeyDown(int keyCode, KeyEvent event) {
+        if (isDPadOrButtonEvent(event) && event.getRepeatCount() == 0 &&
+                handleControllerKey(event.getDeviceId(), keyCode, true)) {
+            return true;
+        }
+
+        return super.onKeyDown(keyCode, event);
+    }
+
+    @Override
+    public boolean onKeyUp(int keyCode, KeyEvent event) {
+        if (isDPadOrButtonEvent(event) && event.getRepeatCount() == 0 &&
+                handleControllerKey(event.getDeviceId(), keyCode, false)) {
+            return true;
+        }
+
+        return super.onKeyDown(keyCode, event);
+    }
+
+    @Override
+    public boolean onGenericMotionEvent(MotionEvent event) {
+        final int source = event.getSource();
+        if ((source & InputDevice.SOURCE_JOYSTICK) == 0)
+            return super.onGenericMotionEvent(event);
+
+        final int deviceId = event.getDeviceId();
+        for (AxisMapping mapping : mControllerAxisMapping) {
+            if (mapping.deviceId != deviceId)
+                continue;
+
+            final float axisValue = event.getAxisValue(mapping.deviceAxisOrButton);
+            float emuValue;
+
+            if (mapping.deviceMotionRange != null) {
+                final float transformedValue = (axisValue - mapping.deviceMotionRange.getMin()) / mapping.deviceMotionRange.getRange();
+                emuValue = (transformedValue * 2.0f) - 1.0f;
+            } else {
+                emuValue = axisValue;
+            }
+            Log.d("EmulationSurfaceView", String.format("axis %d value %f emuvalue %f", mapping.deviceAxisOrButton, axisValue, emuValue));
+
+            if (mapping.axisMapping >= 0) {
+                AndroidHostInterface.getInstance().setControllerAxisState(0, mapping.axisMapping, emuValue);
+            }
+
+            final float DEAD_ZONE = 0.25f;
+            if (mapping.negativeButton >= 0) {
+                AndroidHostInterface.getInstance().setControllerButtonState(0, mapping.negativeButton, (emuValue <= -DEAD_ZONE));
+            }
+            if (mapping.positiveButton >= 0) {
+                AndroidHostInterface.getInstance().setControllerButtonState(0, mapping.positiveButton, (emuValue >= DEAD_ZONE));
+            }
+        }
+
+        return true;
+    }
+
+    private class ButtonMapping {
+        public ButtonMapping(int deviceId, int deviceButton, int controllerIndex, int button) {
+            this.deviceId = deviceId;
+            this.deviceAxisOrButton = deviceButton;
+            this.controllerIndex = controllerIndex;
+            this.buttonMapping = button;
+        }
+
+        public int deviceId;
+        public int deviceAxisOrButton;
+        public int controllerIndex;
+        public int buttonMapping;
+    }
+
+    private class AxisMapping {
+        public AxisMapping(int deviceId, int deviceAxis, InputDevice.MotionRange motionRange, int controllerIndex, int axis) {
+            this.deviceId = deviceId;
+            this.deviceAxisOrButton = deviceAxis;
+            this.deviceMotionRange = motionRange;
+            this.controllerIndex = controllerIndex;
+            this.axisMapping = axis;
+            this.positiveButton = -1;
+            this.negativeButton = -1;
+        }
+
+        public AxisMapping(int deviceId, int deviceAxis, InputDevice.MotionRange motionRange, int controllerIndex, int positiveButton, int negativeButton) {
+            this.deviceId = deviceId;
+            this.deviceAxisOrButton = deviceAxis;
+            this.deviceMotionRange = motionRange;
+            this.controllerIndex = controllerIndex;
+            this.axisMapping = -1;
+            this.positiveButton = positiveButton;
+            this.negativeButton = negativeButton;
+        }
+
+        public int deviceId;
+        public int deviceAxisOrButton;
+        public InputDevice.MotionRange deviceMotionRange;
+        public int controllerIndex;
+        public int axisMapping;
+        public int positiveButton;
+        public int negativeButton;
+    }
+
+    private ArrayList<ButtonMapping> mControllerKeyMapping;
+    private ArrayList<AxisMapping> mControllerAxisMapping;
+
+    private void addControllerKeyMapping(int deviceId, int keyCode, int controllerIndex, String controllerType, String buttonName) {
+        int mapping = AndroidHostInterface.getControllerButtonCode(controllerType, buttonName);
+        Log.i("EmulationSurfaceView", String.format("Map %d to %d (%s)", keyCode, mapping,
+                buttonName));
+        if (mapping >= 0) {
+            mControllerKeyMapping.add(new ButtonMapping(deviceId, keyCode, controllerIndex, mapping));
+        }
+    }
+
+    private void addControllerAxisMapping(int deviceId, List<InputDevice.MotionRange> motionRanges, int axis, int controllerIndex, String controllerType, String axisName, String negativeButtonName, String positiveButtonName) {
+        InputDevice.MotionRange range = null;
+        for (InputDevice.MotionRange curRange : motionRanges) {
+            if (curRange.getAxis() == axis) {
+                range = curRange;
+                break;
+            }
+        }
+        if (range == null)
+            return;
+
+        if (axisName != null) {
+            int mapping = AndroidHostInterface.getControllerAxisCode(controllerType, axisName);
+            Log.i("EmulationSurfaceView", String.format("Map axis %d to %d (%s)", axis, mapping, axisName));
+            if (mapping >= 0) {
+                mControllerAxisMapping.add(new AxisMapping(deviceId, axis, range, controllerIndex, mapping));
+                return;
+            }
+        }
+
+        if (negativeButtonName != null && positiveButtonName != null) {
+            final int negativeMapping = AndroidHostInterface.getControllerButtonCode(controllerType, negativeButtonName);
+            final int positiveMapping = AndroidHostInterface.getControllerButtonCode(controllerType, positiveButtonName);
+            Log.i("EmulationSurfaceView", String.format("Map axis %d to %d %d (button %s %s)", axis, negativeMapping, positiveMapping,
+                    negativeButtonName, positiveButtonName));
+            if (negativeMapping >= 0 && positiveMapping >= 0) {
+                mControllerAxisMapping.add(new AxisMapping(deviceId, axis, range, controllerIndex, positiveMapping, negativeMapping));
+            }
+        }
+    }
+
+    private static boolean isJoystickDevice(int deviceId) {
+        if (deviceId < 0)
+            return false;
+
+        final InputDevice dev = InputDevice.getDevice(deviceId);
+        if (dev == null)
+            return false;
+
+        final int sources = dev.getSources();
+        if ((sources & InputDevice.SOURCE_CLASS_JOYSTICK) != 0)
+            return true;
+
+        if ((sources & InputDevice.SOURCE_GAMEPAD) == InputDevice.SOURCE_GAMEPAD)
+            return true;
+
+        if ((sources & InputDevice.SOURCE_DPAD) == InputDevice.SOURCE_DPAD)
+            return true;
+
+        return false;
+    }
+
+    public boolean initControllerMapping(String controllerType) {
+        mControllerKeyMapping = new ArrayList<>();
+        mControllerAxisMapping = new ArrayList<>();
+
+        final int[] deviceIds = InputDevice.getDeviceIds();
+        for (int deviceId : deviceIds) {
+            if (!isJoystickDevice(deviceId))
+                continue;
+
+            InputDevice device = InputDevice.getDevice(deviceId);
+            List<InputDevice.MotionRange> motionRanges = device.getMotionRanges();
+            int controllerIndex = 0;
+
+            addControllerKeyMapping(deviceId, KeyEvent.KEYCODE_DPAD_UP, controllerIndex, controllerType, "Up");
+            addControllerKeyMapping(deviceId, KeyEvent.KEYCODE_DPAD_RIGHT, controllerIndex, controllerType, "Right");
+            addControllerKeyMapping(deviceId, KeyEvent.KEYCODE_DPAD_DOWN, controllerIndex, controllerType, "Down");
+            addControllerKeyMapping(deviceId, KeyEvent.KEYCODE_DPAD_LEFT, controllerIndex, controllerType, "Left");
+            addControllerKeyMapping(deviceId, KeyEvent.KEYCODE_BUTTON_L1, controllerIndex, controllerType, "L1");
+            addControllerKeyMapping(deviceId, KeyEvent.KEYCODE_BUTTON_L2, controllerIndex, controllerType, "L2");
+            addControllerKeyMapping(deviceId, KeyEvent.KEYCODE_BUTTON_SELECT, controllerIndex, controllerType, "Select");
+            addControllerKeyMapping(deviceId, KeyEvent.KEYCODE_BUTTON_START, controllerIndex, controllerType, "Start");
+            addControllerKeyMapping(deviceId, KeyEvent.KEYCODE_BUTTON_Y, controllerIndex, controllerType, "Triangle");
+            addControllerKeyMapping(deviceId, KeyEvent.KEYCODE_BUTTON_B, controllerIndex, controllerType, "Circle");
+            addControllerKeyMapping(deviceId, KeyEvent.KEYCODE_BUTTON_A, controllerIndex, controllerType, "Cross");
+            addControllerKeyMapping(deviceId, KeyEvent.KEYCODE_BUTTON_X, controllerIndex, controllerType, "Square");
+            addControllerKeyMapping(deviceId, KeyEvent.KEYCODE_BUTTON_R1, controllerIndex, controllerType, "R1");
+            addControllerKeyMapping(deviceId, KeyEvent.KEYCODE_BUTTON_R2, controllerIndex, controllerType, "R2");
+            if (motionRanges != null) {
+                addControllerAxisMapping(deviceId, motionRanges, MotionEvent.AXIS_X, controllerIndex, controllerType, "LeftX", null, null);
+                addControllerAxisMapping(deviceId, motionRanges, MotionEvent.AXIS_Y, controllerIndex, controllerType, "LeftY", null, null);
+                addControllerAxisMapping(deviceId, motionRanges, MotionEvent.AXIS_RX, controllerIndex, controllerType, "RightX", null, null);
+                addControllerAxisMapping(deviceId, motionRanges, MotionEvent.AXIS_RY, controllerIndex, controllerType, "RightY", null, null);
+                addControllerAxisMapping(deviceId, motionRanges, MotionEvent.AXIS_Z, controllerIndex, controllerType, "RightX", null, null);
+                addControllerAxisMapping(deviceId, motionRanges, MotionEvent.AXIS_RZ, controllerIndex, controllerType, "RightY", null, null);
+                addControllerAxisMapping(deviceId, motionRanges, MotionEvent.AXIS_LTRIGGER, controllerIndex, controllerType, "L2", "L2", "L2");
+                addControllerAxisMapping(deviceId, motionRanges, MotionEvent.AXIS_RTRIGGER, controllerIndex, controllerType, "R2", "R2", "R2");
+                addControllerAxisMapping(deviceId, motionRanges, MotionEvent.AXIS_HAT_X, controllerIndex, controllerType, null, "Left", "Right");
+                addControllerAxisMapping(deviceId, motionRanges, MotionEvent.AXIS_HAT_Y, controllerIndex, controllerType, null, "Up", "Down");
+            }
+        }
+
+        return !mControllerKeyMapping.isEmpty() || !mControllerKeyMapping.isEmpty();
+    }
+
+    private boolean handleControllerKey(int deviceId, int keyCode, boolean pressed) {
+        boolean result = false;
+        for (ButtonMapping mapping : mControllerKeyMapping) {
+            if (mapping.deviceId != deviceId || mapping.deviceAxisOrButton != keyCode)
+                continue;
+
+            AndroidHostInterface.getInstance().setControllerButtonState(0, mapping.buttonMapping, pressed);
+            Log.d("EmulationSurfaceView", String.format("handleControllerKey %d -> %d %d", keyCode, mapping.buttonMapping, pressed ? 1 : 0));
+            result = true;
+        }
+
+        return result;
+    }
+}

android/app/src/main/java/com/github/stenzek/duckstation/FileUtil.java

@@ -0,0 +1,94 @@
+package com.github.stenzek.duckstation;
+
+// https://stackoverflow.com/questions/34927748/android-5-0-documentfile-from-tree-uri
+
+import android.annotation.SuppressLint;
+import android.annotation.TargetApi;
+import android.content.Context;
+import android.net.Uri;
+import android.os.Build;
+import android.os.storage.StorageManager;
+import android.provider.DocumentsContract;
+
+import androidx.annotation.Nullable;
+
+import java.io.File;
+import java.lang.reflect.Array;
+import java.lang.reflect.Method;
+
+public final class FileUtil {
+    static String TAG = "TAG";
+    private static final String PRIMARY_VOLUME_NAME = "primary";
+
+    @Nullable
+    public static String getFullPathFromTreeUri(@Nullable final Uri treeUri, Context con) {
+        if (treeUri == null) return null;
+        String volumePath = getVolumePath(getVolumeIdFromTreeUri(treeUri), con);
+        if (volumePath == null) return File.separator;
+        if (volumePath.endsWith(File.separator))
+            volumePath = volumePath.substring(0, volumePath.length() - 1);
+
+        String documentPath = getDocumentPathFromTreeUri(treeUri);
+        if (documentPath.endsWith(File.separator))
+            documentPath = documentPath.substring(0, documentPath.length() - 1);
+
+        if (documentPath.length() > 0) {
+            if (documentPath.startsWith(File.separator))
+                return volumePath + documentPath;
+            else
+                return volumePath + File.separator + documentPath;
+        } else return volumePath;
+    }
+
+
+    @SuppressLint("ObsoleteSdkInt")
+    private static String getVolumePath(final String volumeId, Context context) {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) return null;
+        try {
+            StorageManager mStorageManager =
+                    (StorageManager) context.getSystemService(Context.STORAGE_SERVICE);
+            Class<?> storageVolumeClazz = Class.forName("android.os.storage.StorageVolume");
+            Method getVolumeList = mStorageManager.getClass().getMethod("getVolumeList");
+            Method getUuid = storageVolumeClazz.getMethod("getUuid");
+            Method getPath = storageVolumeClazz.getMethod("getPath");
+            Method isPrimary = storageVolumeClazz.getMethod("isPrimary");
+            Object result = getVolumeList.invoke(mStorageManager);
+
+            final int length = Array.getLength(result);
+            for (int i = 0; i < length; i++) {
+                Object storageVolumeElement = Array.get(result, i);
+                String uuid = (String) getUuid.invoke(storageVolumeElement);
+                Boolean primary = (Boolean) isPrimary.invoke(storageVolumeElement);
+
+                // primary volume?
+                if (primary && PRIMARY_VOLUME_NAME.equals(volumeId))
+                    return (String) getPath.invoke(storageVolumeElement);
+
+                // other volumes?
+                if (uuid != null && uuid.equals(volumeId))
+                    return (String) getPath.invoke(storageVolumeElement);
+            }
+            // not found.
+            return null;
+        } catch (Exception ex) {
+            return null;
+        }
+    }
+
+    @TargetApi(Build.VERSION_CODES.LOLLIPOP)
+    private static String getVolumeIdFromTreeUri(final Uri treeUri) {
+        final String docId = DocumentsContract.getTreeDocumentId(treeUri);
+        final String[] split = docId.split(":");
+        if (split.length > 0) return split[0];
+        else return null;
+    }
+
+
+    @TargetApi(Build.VERSION_CODES.LOLLIPOP)
+    private static String getDocumentPathFromTreeUri(final Uri treeUri) {
+        final String docId = DocumentsContract.getTreeDocumentId(treeUri);
+        final String[] split = docId.split(":");
+        if ((split.length >= 2) && (split[1] != null)) return split[1];
+        else return File.separator;
+    }
+}

android/app/src/main/java/com/github/stenzek/duckstation/GameList.java

@@ -0,0 +1,90 @@
+package com.github.stenzek.duckstation;
+
+import android.app.Activity;
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.util.ArraySet;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.BaseAdapter;
+import android.widget.TextView;
+
+import androidx.preference.PreferenceManager;
+
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.Set;
+
+public class GameList {
+    private Context mContext;
+    private GameListEntry[] mEntries;
+    private ListViewAdapter mAdapter;
+
+    public GameList(Context context) {
+        mContext = context;
+        mAdapter = new ListViewAdapter();
+        mEntries = new GameListEntry[0];
+    }
+
+    private class GameListEntryComparator implements Comparator<GameListEntry> {
+        @Override
+        public int compare(GameListEntry left, GameListEntry right) {
+            return left.getTitle().compareTo(right.getTitle());
+        }
+    }
+
+
+    public void refresh(boolean invalidateCache, boolean invalidateDatabase) {
+        // Search and get entries from native code
+        AndroidHostInterface.getInstance().refreshGameList(invalidateCache, invalidateDatabase);
+        mEntries = AndroidHostInterface.getInstance().getGameListEntries();
+        Arrays.sort(mEntries, new GameListEntryComparator());
+        mAdapter.notifyDataSetChanged();
+    }
+
+    public int getEntryCount() {
+        return mEntries.length;
+    }
+
+    public GameListEntry getEntry(int index) {
+        return mEntries[index];
+    }
+
+    private class ListViewAdapter extends BaseAdapter {
+        @Override
+        public int getCount() {
+            return mEntries.length;
+        }
+
+        @Override
+        public Object getItem(int position) {
+            return mEntries[position];
+        }
+
+        @Override
+        public long getItemId(int position) {
+            return position;
+        }
+
+        @Override
+        public int getViewTypeCount() {
+            return 1;
+        }
+
+        @Override
+        public View getView(int position, View convertView, ViewGroup parent) {
+            if (convertView == null) {
+                convertView = LayoutInflater.from(mContext)
+                        .inflate(R.layout.game_list_view_entry, parent, false);
+            }
+
+            mEntries[position].fillView(convertView);
+            return convertView;
+        }
+    }
+
+    public BaseAdapter getListViewAdapter() {
+        return mAdapter;
+    }
+}

android/app/src/main/java/com/github/stenzek/duckstation/GameListEntry.java

@@ -0,0 +1,128 @@
+package com.github.stenzek.duckstation;
+
+import android.view.View;
+import android.widget.ImageView;
+import android.widget.TextView;
+
+import androidx.core.content.ContextCompat;
+
+public class GameListEntry {
+    public enum EntryType {
+        Disc,
+        PSExe
+    }
+
+    public enum CompatibilityRating {
+        Unknown,
+        DoesntBoot,
+        CrashesInIntro,
+        CrashesInGame,
+        GraphicalAudioIssues,
+        NoIssues,
+    }
+
+    private String mPath;
+    private String mCode;
+    private String mTitle;
+    private long mSize;
+    private String mModifiedTime;
+    private DiscRegion mRegion;
+    private EntryType mType;
+    private CompatibilityRating mCompatibilityRating;
+
+
+    public GameListEntry(String path, String code, String title, long size, String modifiedTime, String region,
+                         String type, String compatibilityRating) {
+        mPath = path;
+        mCode = code;
+        mTitle = title;
+        mSize = size;
+        mModifiedTime = modifiedTime;
+
+        try {
+            mRegion = DiscRegion.valueOf(region);
+        } catch (IllegalArgumentException e) {
+            mRegion = DiscRegion.NTSC_U;
+        }
+
+        try {
+            mType = EntryType.valueOf(type);
+        } catch (IllegalArgumentException e) {
+            mType = EntryType.Disc;
+        }
+
+        try {
+            mCompatibilityRating = CompatibilityRating.valueOf(compatibilityRating);
+        } catch (IllegalArgumentException e) {
+            mCompatibilityRating = CompatibilityRating.Unknown;
+        }
+    }
+
+    public String getPath() {
+        return mPath;
+    }
+
+    public String getCode() {
+        return mCode;
+    }
+
+    public String getTitle() {
+        return mTitle;
+    }
+
+    public String getModifiedTime() {
+        return mModifiedTime;
+    }
+
+    public DiscRegion getRegion() {
+        return mRegion;
+    }
+
+    public EntryType getType() {
+        return mType;
+    }
+
+    public CompatibilityRating getCompatibilityRating() {
+        return mCompatibilityRating;
+    }
+
+    public void fillView(View view) {
+        ((TextView) view.findViewById(R.id.game_list_view_entry_title)).setText(mTitle);
+        ((TextView) view.findViewById(R.id.game_list_view_entry_path)).setText(mPath);
+
+        String sizeString = String.format("%.2f MB", (double) mSize / 1048576.0);
+        ((TextView) view.findViewById(R.id.game_list_view_entry_size)).setText(sizeString);
+
+        int regionDrawableId;
+        switch (mRegion) {
+            case NTSC_J:
+                regionDrawableId = R.drawable.flag_jp;
+                break;
+            case NTSC_U:
+            default:
+                regionDrawableId = R.drawable.flag_us;
+                break;
+            case PAL:
+                regionDrawableId = R.drawable.flag_eu;
+                break;
+        }
+
+        ((ImageView) view.findViewById(R.id.game_list_view_entry_region_icon))
+                .setImageDrawable(ContextCompat.getDrawable(view.getContext(), regionDrawableId));
+
+        int typeDrawableId;
+        switch (mType) {
+            case Disc:
+            default:
+                typeDrawableId = R.drawable.ic_media_cdrom;
+                break;
+
+            case PSExe:
+                typeDrawableId = R.drawable.ic_emblem_system;
+                break;
+        }
+
+        ((ImageView) view.findViewById(R.id.game_list_view_entry_type_icon))
+                .setImageDrawable(ContextCompat.getDrawable(view.getContext(), typeDrawableId));
+    }
+}

android/app/src/main/java/com/github/stenzek/duckstation/MainActivity.java

@@ -0,0 +1,334 @@
+package com.github.stenzek.duckstation;
+
+import android.Manifest;
+import android.content.ContentResolver;
+import android.content.SharedPreferences;
+import android.content.pm.PackageManager;
+import android.net.Uri;
+import android.os.Bundle;
+
+import com.google.android.material.floatingactionbutton.FloatingActionButton;
+import com.google.android.material.snackbar.Snackbar;
+
+import androidx.appcompat.app.AlertDialog;
+import androidx.appcompat.app.AppCompatActivity;
+import androidx.appcompat.widget.Toolbar;
+import androidx.core.app.ActivityCompat;
+import androidx.core.content.ContextCompat;
+import androidx.documentfile.provider.DocumentFile;
+import androidx.preference.PreferenceManager;
+
+import android.content.Intent;
+
+import androidx.collection.ArraySet;
+
+import android.provider.DocumentsContract;
+import android.provider.MediaStore;
+import android.util.Log;
+import android.view.Gravity;
+import android.view.View;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.widget.AdapterView;
+import android.widget.ListView;
+import android.widget.PopupMenu;
+import android.widget.Toast;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.prefs.Preferences;
+
+import static com.google.android.material.snackbar.Snackbar.make;
+
+public class MainActivity extends AppCompatActivity {
+    private static final int REQUEST_EXTERNAL_STORAGE_PERMISSIONS = 1;
+    private static final int REQUEST_ADD_DIRECTORY_TO_GAME_LIST = 2;
+    private static final int REQUEST_IMPORT_BIOS_IMAGE = 3;
+
+    private GameList mGameList;
+    private ListView mGameListView;
+    private boolean mHasExternalStoragePermissions = false;
+
+    private boolean shouldResumeStateByDefault() {
+        SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this);
+        return prefs.getBoolean("Main/SaveStateOnExit", true);
+    }
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        setContentView(R.layout.activity_main);
+        Toolbar toolbar = findViewById(R.id.toolbar);
+        setSupportActionBar(toolbar);
+
+        findViewById(R.id.fab_add_game_directory).setOnClickListener(new View.OnClickListener() {
+            @Override
+            public void onClick(View view) {
+                startAddGameDirectory();
+            }
+        });
+        findViewById(R.id.fab_resume).setOnClickListener(new View.OnClickListener() {
+            @Override
+            public void onClick(View view) {
+                startEmulation(null, shouldResumeStateByDefault());
+            }
+        });
+
+        // Set up game list view.
+        mGameList = new GameList(this);
+        mGameListView = findViewById(R.id.game_list_view);
+        mGameListView.setAdapter(mGameList.getListViewAdapter());
+        mGameListView.setOnItemClickListener(new AdapterView.OnItemClickListener() {
+            @Override
+            public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
+                startEmulation(mGameList.getEntry(position).getPath(), shouldResumeStateByDefault());
+            }
+        });
+        mGameListView.setOnItemLongClickListener(new AdapterView.OnItemLongClickListener() {
+            @Override
+            public boolean onItemLongClick(AdapterView<?> parent, View view, int position,
+                                           long id) {
+                PopupMenu menu = new PopupMenu(MainActivity.this, view,
+                        Gravity.RIGHT | Gravity.TOP);
+                menu.getMenuInflater().inflate(R.menu.menu_game_list_entry, menu.getMenu());
+                menu.setOnMenuItemClickListener(new PopupMenu.OnMenuItemClickListener() {
+                    @Override
+                    public boolean onMenuItemClick(MenuItem item) {
+                        int id = item.getItemId();
+                        if (id == R.id.game_list_entry_menu_start_game) {
+                            startEmulation(mGameList.getEntry(position).getPath(), false);
+                            return true;
+                        } else if (id == R.id.game_list_entry_menu_resume_game) {
+                            startEmulation(mGameList.getEntry(position).getPath(), true);
+                            return true;
+                        }
+                        return false;
+                    }
+                });
+                menu.show();
+                return true;
+            }
+        });
+
+        mHasExternalStoragePermissions = checkForExternalStoragePermissions();
+        if (mHasExternalStoragePermissions)
+            completeStartup();
+    }
+
+    private void completeStartup() {
+        if (!AndroidHostInterface.hasInstance() && !AndroidHostInterface.createInstance(this)) {
+            Log.i("MainActivity", "Failed to create host interface");
+            throw new RuntimeException("Failed to create host interface");
+        }
+
+        mGameList.refresh(false, false);
+    }
+
+    private void startAddGameDirectory() {
+        if (!checkForExternalStoragePermissions())
+            return;
+
+        Intent i = new Intent(Intent.ACTION_OPEN_DOCUMENT_TREE);
+        i.addCategory(Intent.CATEGORY_DEFAULT);
+        i.putExtra(Intent.EXTRA_LOCAL_ONLY, true);
+        startActivityForResult(Intent.createChooser(i, "Choose directory"),
+                REQUEST_ADD_DIRECTORY_TO_GAME_LIST);
+    }
+
+    @Override
+    public boolean onCreateOptionsMenu(Menu menu) {
+        // Inflate the menu; this adds items to the action bar if it is present.
+        getMenuInflater().inflate(R.menu.menu_main, menu);
+        return true;
+    }
+
+    @Override
+    public boolean onOptionsItemSelected(MenuItem item) {
+        // Handle action bar item clicks here. The action bar will
+        // automatically handle clicks on the Home/Up button, so long
+        // as you specify a parent activity in AndroidManifest.xml.
+        int id = item.getItemId();
+
+        //noinspection SimplifiableIfStatement
+        if (id == R.id.action_resume) {
+            startEmulation(null, true);
+        } else if (id == R.id.action_start_bios) {
+            startEmulation(null, false);
+        } else if (id == R.id.action_add_game_directory) {
+            startAddGameDirectory();
+        } else if (id == R.id.action_scan_for_new_games) {
+            mGameList.refresh(false, false);
+        } else if (id == R.id.action_rescan_all_games) {
+            mGameList.refresh(true, true);
+        } else if (id == R.id.action_import_bios) {
+            importBIOSImage();
+        } else if (id == R.id.action_settings) {
+            Intent intent = new Intent(this, SettingsActivity.class);
+            startActivity(intent);
+            return true;
+        }
+
+        return super.onOptionsItemSelected(item);
+    }
+
+    @Override
+    public void onActivityResult(int requestCode, int resultCode, Intent data) {
+        super.onActivityResult(requestCode, resultCode, data);
+
+        switch (requestCode) {
+            case REQUEST_ADD_DIRECTORY_TO_GAME_LIST: {
+                if (resultCode != RESULT_OK)
+                    return;
+
+                Uri treeUri = data.getData();
+                String path = FileUtil.getFullPathFromTreeUri(treeUri, this);
+                if (path.length() < 5) {
+                    new AlertDialog.Builder(this)
+                            .setTitle("Error")
+                            .setMessage("Failed to get path for the selected directory. Please make sure the directory is in internal/external storage.\n\n" +
+                                        "Tap the overflow button in the directory selector.\nSelect \"Show Internal Storage\".\n" +
+                                        "Tap the menu button and select your device name or SD card.")
+                            .setPositiveButton("OK", (dialog, button) -> {})
+                            .create()
+                            .show();
+                    return;
+                }
+
+                SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this);
+                Set<String> currentValues = prefs.getStringSet("GameList/RecursivePaths", null);
+                if (currentValues == null)
+                    currentValues = new HashSet<String>();
+
+                currentValues.add(path);
+                SharedPreferences.Editor editor = prefs.edit();
+                editor.putStringSet("GameList/RecursivePaths", currentValues);
+                editor.apply();
+                Log.i("MainActivity", "Added path '" + path + "' to game list search directories");
+                mGameList.refresh(false, false);
+            }
+            break;
+
+            case REQUEST_IMPORT_BIOS_IMAGE: {
+                if (resultCode != RESULT_OK)
+                    return;
+
+                onImportBIOSImageResult(data.getData());
+            }
+            break;
+        }
+    }
+
+    private boolean checkForExternalStoragePermissions() {
+        if (ContextCompat.checkSelfPermission(this, Manifest.permission.READ_EXTERNAL_STORAGE) ==
+                PackageManager.PERMISSION_GRANTED &&
+                ContextCompat
+                        .checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE) ==
+                        PackageManager.PERMISSION_GRANTED) {
+            return true;
+        }
+
+        ActivityCompat.requestPermissions(this,
+                new String[]{Manifest.permission.READ_EXTERNAL_STORAGE,
+                        Manifest.permission.WRITE_EXTERNAL_STORAGE},
+                REQUEST_EXTERNAL_STORAGE_PERMISSIONS);
+        return false;
+    }
+
+    public void onRequestPermissionsResult(int requestCode, String[] permissions,
+                                           int[] grantResults) {
+        // check that all were successful
+        for (int i = 0; i < grantResults.length; i++) {
+            if (grantResults[i] == PackageManager.PERMISSION_GRANTED) {
+                if (!mHasExternalStoragePermissions) {
+                    mHasExternalStoragePermissions = true;
+                    completeStartup();
+                }
+            } else {
+                Toast.makeText(this,
+                        "External storage permissions are required to use DuckStation.",
+                        Toast.LENGTH_LONG);
+                finish();
+            }
+        }
+    }
+
+    private boolean startEmulation(String bootPath, boolean resumeState) {
+        if (!doBIOSCheck())
+            return false;
+
+        Intent intent = new Intent(this, EmulationActivity.class);
+        intent.putExtra("bootPath", bootPath);
+        intent.putExtra("resumeState", resumeState);
+        startActivity(intent);
+        return true;
+    }
+
+    private boolean doBIOSCheck() {
+        if (AndroidHostInterface.getInstance().hasAnyBIOSImages())
+            return true;
+
+        new AlertDialog.Builder(this)
+                .setTitle("Missing BIOS Image")
+                .setMessage("No BIOS image was found in DuckStation's bios directory. Do you with to locate and import a BIOS image now?")
+                .setPositiveButton("Yes", (dialog, button) -> importBIOSImage())
+                .setNegativeButton("No", (dialog, button) -> {})
+                .create()
+                .show();
+
+        return false;
+    }
+
+    private void importBIOSImage() {
+        Intent intent = new Intent(Intent.ACTION_GET_CONTENT);
+        intent.setType("*/*");
+        intent.addCategory(Intent.CATEGORY_OPENABLE);
+        startActivityForResult(Intent.createChooser(intent, "Choose BIOS Image"), REQUEST_IMPORT_BIOS_IMAGE);
+    }
+
+    private void onImportBIOSImageResult(Uri uri) {
+        // This should really be 512K but just in case we wanted to support the other BIOSes in the future...
+        final int MAX_BIOS_SIZE = 2 * 1024 * 1024;
+
+        InputStream stream = null;
+        try {
+            stream = getContentResolver().openInputStream(uri);
+        } catch (FileNotFoundException e) {
+            Toast.makeText(this, "Failed to open BIOS image.", Toast.LENGTH_LONG);
+            return;
+        }
+
+        ByteArrayOutputStream os = new ByteArrayOutputStream();
+        try {
+            byte[] buffer = new byte[512 * 1024];
+            int len;
+            while ((len = stream.read(buffer)) > 0) {
+                os.write(buffer, 0, len);
+                if (os.size() > MAX_BIOS_SIZE) {
+                    throw new IOException("BIOS image is too large.");
+                }
+            }
+        } catch (IOException e) {
+            new AlertDialog.Builder(this)
+                    .setMessage("Failed to read BIOS image: " + e.getMessage())
+                    .setPositiveButton("OK", (dialog, button) -> {})
+                    .create()
+                    .show();
+            return;
+        }
+
+        String importResult = AndroidHostInterface.getInstance().importBIOSImage(os.toByteArray());
+        String message = (importResult == null) ? "This BIOS image is invalid, or has already been imported." : ("BIOS '" + importResult + "' imported.");
+
+        new AlertDialog.Builder(this)
+            .setMessage(message)
+            .setPositiveButton("OK", (dialog, button) -> {})
+            .create()
+            .show();
+    }
+}

android/app/src/main/java/com/github/stenzek/duckstation/SettingsActivity.java

@@ -0,0 +1,119 @@
+package com.github.stenzek.duckstation;
+
+import android.os.Bundle;
+import android.view.LayoutInflater;
+import android.view.MenuItem;
+import android.view.View;
+import android.view.ViewGroup;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.appcompat.app.ActionBar;
+import androidx.appcompat.app.AppCompatActivity;
+import androidx.fragment.app.Fragment;
+import androidx.preference.PreferenceFragmentCompat;
+import androidx.viewpager2.adapter.FragmentStateAdapter;
+import androidx.viewpager2.widget.ViewPager2;
+
+import com.google.android.material.tabs.TabLayout;
+import com.google.android.material.tabs.TabLayoutMediator;
+
+public class SettingsActivity extends AppCompatActivity {
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.settings_activity);
+        getSupportFragmentManager()
+                .beginTransaction()
+                .replace(R.id.settings, new SettingsCollectionFragment())
+                .commit();
+        ActionBar actionBar = getSupportActionBar();
+        if (actionBar != null) {
+            actionBar.setDisplayHomeAsUpEnabled(true);
+        }
+    }
+
+    @Override
+    public boolean onOptionsItemSelected(@NonNull MenuItem item) {
+        if (item.getItemId() == android.R.id.home) {
+            onBackPressed();
+            return true;
+        }
+
+        return super.onOptionsItemSelected(item);
+    }
+
+    public static class SettingsFragment extends PreferenceFragmentCompat {
+        private int resourceId;
+        public SettingsFragment(int resourceId) {
+            this.resourceId = resourceId;
+        }
+
+        @Override
+        public void onCreatePreferences(Bundle savedInstanceState, String rootKey) {
+            setPreferencesFromResource(resourceId, rootKey);
+        }
+    }
+
+    public static class SettingsCollectionFragment extends Fragment {
+        private SettingsCollectionAdapter adapter;
+        private ViewPager2 viewPager;
+
+        @Nullable
+        @Override
+        public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
+            return inflater.inflate(R.layout.fragment_settings_collection, container, false);
+        }
+
+        @Override
+        public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
+            adapter = new SettingsCollectionAdapter(this);
+            viewPager = view.findViewById(R.id.view_pager);
+            viewPager.setAdapter(adapter);
+
+            TabLayout tabLayout = view.findViewById(R.id.tab_layout);
+            new TabLayoutMediator(tabLayout, viewPager,
+                    (tab, position) -> tab.setText(getResources().getStringArray(R.array.settings_tabs)[position])
+            ).attach();
+        }
+    }
+
+    public static class SettingsCollectionAdapter extends FragmentStateAdapter {
+        public SettingsCollectionAdapter(@NonNull Fragment fragment) {
+            super(fragment);
+        }
+
+        @NonNull
+        @Override
+        public Fragment createFragment(int position) {
+            switch (position) {
+                case 0:     // General
+                    return new SettingsFragment(R.xml.general_preferences);
+
+                case 1:     // Display
+                    return new SettingsFragment(R.xml.display_preferences);
+
+                case 2:     // Audio
+                    return new SettingsFragment(R.xml.audio_preferences);
+
+                case 3:     // Enhancements
+                    return new SettingsFragment(R.xml.enhancements_preferences);
+
+                case 4:     // Controllers
+                    return new SettingsFragment(R.xml.controllers_preferences);
+
+                case 5:     // Advanced
+                    return new SettingsFragment(R.xml.advanced_preferences);
+
+                default:
+                    return new Fragment();
+            }
+        }
+
+        @Override
+        public int getItemCount() {
+            return 5;
+        }
+    }
+}

android/app/src/main/java/com/github/stenzek/duckstation/TouchscreenControllerAxisView.java

@@ -0,0 +1,179 @@
+package com.github.stenzek.duckstation;
+
+import android.content.Context;
+import android.graphics.Canvas;
+import android.graphics.drawable.Drawable;
+import android.util.AttributeSet;
+import android.util.Log;
+import android.view.View;
+
+public class TouchscreenControllerAxisView extends View {
+    private Drawable mBaseDrawable;
+    private Drawable mStickUnpressedDrawable;
+    private Drawable mStickPressedDrawable;
+    private boolean mPressed = false;
+    private int mPointerId = 0;
+    private float mXValue = 0.0f;
+    private float mYValue = 0.0f;
+    private int mDrawXPos = 0;
+    private int mDrawYPos = 0;
+
+    private int mControllerIndex = -1;
+    private int mXAxisCode = -1;
+    private int mYAxisCode = -1;
+    private int mLeftButtonCode = -1;
+    private int mRightButtonCode = -1;
+    private int mUpButtonCode = -1;
+    private int mDownButtonCode = -1;
+
+    public TouchscreenControllerAxisView(Context context) {
+        super(context);
+        init();
+    }
+
+    public TouchscreenControllerAxisView(Context context, AttributeSet attrs) {
+        super(context, attrs);
+        init();
+    }
+
+    public TouchscreenControllerAxisView(Context context, AttributeSet attrs, int defStyle) {
+        super(context, attrs, defStyle);
+        init();
+    }
+
+    private void init() {
+        mBaseDrawable = getContext().getDrawable(R.drawable.ic_controller_analog_base);
+        mBaseDrawable.setCallback(this);
+        mStickUnpressedDrawable = getContext().getDrawable(R.drawable.ic_controller_analog_stick_unpressed);
+        mStickUnpressedDrawable.setCallback(this);
+        mStickPressedDrawable = getContext().getDrawable(R.drawable.ic_controller_analog_stick_pressed);
+        mStickPressedDrawable.setCallback(this);
+    }
+
+    public void setControllerAxis(int controllerIndex, int xCode, int yCode) {
+        mControllerIndex = controllerIndex;
+        mXAxisCode = xCode;
+        mYAxisCode = yCode;
+        mLeftButtonCode = -1;
+        mRightButtonCode = -1;
+        mUpButtonCode = -1;
+        mDownButtonCode = -1;
+    }
+
+    public void setControllerButtons(int controllerIndex, int leftCode, int rightCode, int upCode, int downCode) {
+        mControllerIndex = controllerIndex;
+        mXAxisCode = -1;
+        mYAxisCode = -1;
+        mLeftButtonCode = leftCode;
+        mRightButtonCode = rightCode;
+        mUpButtonCode = upCode;
+        mDownButtonCode = downCode;
+    }
+
+    public void setUnpressed() {
+        if (!mPressed && mXValue == 0.0f && mYValue == 0.0f)
+            return;
+
+        mPressed = false;
+        mXValue = 0.0f;
+        mYValue = 0.0f;
+        mDrawXPos = 0;
+        mDrawYPos = 0;
+        invalidate();
+        updateControllerState();
+    }
+
+    public void setPressed(int pointerId, float pointerX, float pointerY) {
+        final float dx = pointerX - (float)(getX() + (float)(getWidth() / 2));
+        final float dy = pointerY - (float)(getY() + (float)(getHeight() / 2));
+        // Log.i("SetPressed", String.format("px=%f,py=%f dx=%f,dy=%f", pointerX, pointerY, dx, dy));
+
+        final float pointerDistance = Math.max(Math.abs(dx), Math.abs(dy));
+        final float angle = (float)Math.atan2((double)dy, (double)dx);
+
+        final float maxDistance = (float)Math.min((getWidth() - getPaddingLeft() - getPaddingRight()) / 2, (getHeight() - getPaddingTop() - getPaddingBottom()) / 2);
+        final float length = Math.min(pointerDistance / maxDistance, 1.0f);
+        // Log.i("SetPressed", String.format("pointerDist=%f,angle=%f,w=%d,h=%d,maxDist=%f,length=%f", pointerDistance, angle, getWidth(), getHeight(), maxDistance, length));
+
+        final float xValue = (float)Math.cos((double)angle) * length;
+        final float yValue = (float)Math.sin((double)angle) * length;
+        mDrawXPos = (int)(xValue * maxDistance);
+        mDrawYPos = (int)(yValue * maxDistance);
+
+        boolean doUpdate = (pointerId != mPointerId || !mPressed || (xValue != mXValue || yValue != mYValue));
+        mPointerId = pointerId;
+        mPressed = true;
+        mXValue = xValue;
+        mYValue = yValue;
+        // Log.i("SetPressed", String.format("xval=%f,yval=%f,drawX=%d,drawY=%d", mXValue, mYValue, mDrawXPos, mDrawYPos));
+
+        if (doUpdate) {
+            invalidate();
+            updateControllerState();
+        }
+    }
+
+    private void updateControllerState() {
+        final float BUTTON_THRESHOLD = 0.33f;
+
+        AndroidHostInterface hostInterface = AndroidHostInterface.getInstance();
+        if (mXAxisCode >= 0)
+            hostInterface.setControllerAxisState(mControllerIndex, mXAxisCode, mXValue);
+        if (mYAxisCode >= 0)
+            hostInterface.setControllerAxisState(mControllerIndex, mYAxisCode, mYValue);
+
+        if (mLeftButtonCode >= 0)
+            hostInterface.setControllerButtonState(mControllerIndex, mLeftButtonCode, (mXValue <= -BUTTON_THRESHOLD));
+        if (mRightButtonCode >= 0)
+            hostInterface.setControllerButtonState(mControllerIndex, mRightButtonCode, (mXValue >= BUTTON_THRESHOLD));
+        if (mUpButtonCode >= 0)
+            hostInterface.setControllerButtonState(mControllerIndex, mUpButtonCode, (mYValue <= -BUTTON_THRESHOLD));
+        if (mDownButtonCode  >= 0)
+            hostInterface.setControllerButtonState(mControllerIndex, mDownButtonCode, (mYValue >= BUTTON_THRESHOLD));
+    }
+
+    @Override
+    protected void onDraw(Canvas canvas) {
+        super.onDraw(canvas);
+
+        final int paddingLeft = getPaddingLeft();
+        final int paddingTop = getPaddingTop();
+        final int paddingRight = getPaddingRight();
+        final int paddingBottom = getPaddingBottom();
+        final int contentWidth = getWidth() - paddingLeft - paddingRight;
+        final int contentHeight = getHeight() - paddingTop - paddingBottom;
+
+        mBaseDrawable.setBounds(paddingLeft, paddingTop,
+                paddingLeft + contentWidth, paddingTop + contentHeight);
+        mBaseDrawable.draw(canvas);
+
+        final int stickWidth = contentWidth / 3;
+        final int stickHeight = contentHeight / 3;
+        final int halfStickWidth = stickWidth / 2;
+        final int halfStickHeight = stickHeight / 2;
+        final int centerX = getWidth() / 2;
+        final int centerY = getHeight() / 2;
+        final int drawX = centerX + mDrawXPos;
+        final int drawY = centerY + mDrawYPos;
+
+        Drawable stickDrawable = mPressed ? mStickPressedDrawable : mStickUnpressedDrawable;
+        stickDrawable.setBounds(drawX - halfStickWidth, drawY - halfStickHeight, drawX + halfStickWidth, drawY + halfStickHeight);
+        stickDrawable.draw(canvas);
+    }
+
+    public boolean isPressed() {
+        return mPressed;
+    }
+
+    public boolean hasPointerId() {
+        return mPointerId >= 0;
+    }
+
+    public int getPointerId() {
+        return mPointerId;
+    }
+
+    public void setPointerId(int mPointerId) {
+        this.mPointerId = mPointerId;
+    }
+}

android/app/src/main/java/com/github/stenzek/duckstation/TouchscreenControllerButtonView.java

@@ -0,0 +1,113 @@
+package com.github.stenzek.duckstation;
+
+import android.content.Context;
+import android.content.res.TypedArray;
+import android.graphics.Canvas;
+import android.graphics.drawable.Drawable;
+import android.util.AttributeSet;
+import android.util.Log;
+import android.view.MotionEvent;
+import android.view.View;
+
+/**
+ * TODO: document your custom view class.
+ */
+public class TouchscreenControllerButtonView extends View {
+    private Drawable mUnpressedDrawable;
+    private Drawable mPressedDrawable;
+    private boolean mPressed = false;
+    private int mControllerIndex = -1;
+    private int mButtonCode = -1;
+
+    public TouchscreenControllerButtonView(Context context) {
+        super(context);
+        init(context, null, 0);
+    }
+
+    public TouchscreenControllerButtonView(Context context, AttributeSet attrs) {
+        super(context, attrs);
+        init(context, attrs, 0);
+    }
+
+    public TouchscreenControllerButtonView(Context context, AttributeSet attrs, int defStyle) {
+        super(context, attrs, defStyle);
+        init(context, attrs, defStyle);
+    }
+
+    private void init(Context context, AttributeSet attrs, int defStyle) {
+        // Load attributes
+        final TypedArray a = getContext().obtainStyledAttributes(
+                attrs, R.styleable.TouchscreenControllerButtonView, defStyle, 0);
+
+        if (a.hasValue(R.styleable.TouchscreenControllerButtonView_unpressedDrawable)) {
+            mUnpressedDrawable = a.getDrawable(R.styleable.TouchscreenControllerButtonView_unpressedDrawable);
+            mUnpressedDrawable.setCallback(this);
+        }
+
+        if (a.hasValue(R.styleable.TouchscreenControllerButtonView_pressedDrawable)) {
+            mPressedDrawable = a.getDrawable(R.styleable.TouchscreenControllerButtonView_pressedDrawable);
+            mPressedDrawable.setCallback(this);
+        }
+
+        a.recycle();
+    }
+
+    @Override
+    protected void onDraw(Canvas canvas) {
+        super.onDraw(canvas);
+
+        final int paddingLeft = getPaddingLeft();
+        final int paddingTop = getPaddingTop();
+        final int paddingRight = getPaddingRight();
+        final int paddingBottom = getPaddingBottom();
+        final int contentWidth = getWidth() - paddingLeft - paddingRight;
+        final int contentHeight = getHeight() - paddingTop - paddingBottom;
+
+        // Draw the example drawable on top of the text.
+        Drawable drawable = mPressed ? mPressedDrawable : mUnpressedDrawable;
+        if (drawable != null) {
+            drawable.setBounds(paddingLeft, paddingTop,
+                    paddingLeft + contentWidth, paddingTop + contentHeight);
+            drawable.draw(canvas);
+        }
+    }
+
+    public boolean isPressed() {
+        return mPressed;
+    }
+
+    public void setPressed(boolean pressed) {
+        if (pressed == mPressed)
+            return;
+
+        mPressed = pressed;
+        invalidate();
+        updateControllerState();
+    }
+
+    public void setButtonCode(int controllerIndex, int code) {
+        mControllerIndex = controllerIndex;
+        mButtonCode = code;
+    }
+
+    private void updateControllerState() {
+        if (mButtonCode >= 0)
+            AndroidHostInterface.getInstance().setControllerButtonState(mControllerIndex, mButtonCode, mPressed);
+    }
+
+    public Drawable getPressedDrawable() {
+        return mPressedDrawable;
+    }
+
+    public void setPressedDrawable(Drawable pressedDrawable) {
+        mPressedDrawable = pressedDrawable;
+    }
+
+    public Drawable getUnpressedDrawable() {
+        return mUnpressedDrawable;
+    }
+
+    public void setUnpressedDrawable(Drawable unpressedDrawable) {
+        mUnpressedDrawable = unpressedDrawable;
+    }
+}

android/app/src/main/java/com/github/stenzek/duckstation/TouchscreenControllerView.java

@@ -0,0 +1,216 @@
+package com.github.stenzek.duckstation;
+
+import android.content.Context;
+import android.graphics.Rect;
+import android.util.AttributeSet;
+import android.util.Log;
+import android.view.LayoutInflater;
+import android.view.MotionEvent;
+import android.view.View;
+import android.widget.FrameLayout;
+
+import java.util.ArrayList;
+
+/**
+ * TODO: document your custom view class.
+ */
+public class TouchscreenControllerView extends FrameLayout {
+    private int mControllerIndex;
+    private String mControllerType;
+    private View mMainView;
+    private ArrayList<TouchscreenControllerButtonView> mButtonViews = new ArrayList<>();
+    private ArrayList<TouchscreenControllerAxisView> mAxisViews = new ArrayList<>();
+
+    public TouchscreenControllerView(Context context) {
+        super(context);
+    }
+
+    public TouchscreenControllerView(Context context, AttributeSet attrs) {
+        super(context, attrs);
+    }
+
+    public TouchscreenControllerView(Context context, AttributeSet attrs, int defStyle) {
+        super(context, attrs, defStyle);
+    }
+
+    public void init(int controllerIndex, String controllerType, String viewType) {
+        mControllerIndex = controllerIndex;
+        mControllerType = controllerType;
+
+        mButtonViews.clear();
+        mAxisViews.clear();
+        removeAllViews();
+
+        LayoutInflater inflater = LayoutInflater.from(getContext());
+        switch (viewType)
+        {
+            case "digital":
+                mMainView = inflater.inflate(R.layout.layout_touchscreen_controller_digital, this, true);
+                break;
+
+            case "analog_stick":
+                mMainView = inflater.inflate(R.layout.layout_touchscreen_controller_analog_stick, this, true);
+                break;
+
+            case "analog_sticks":
+                mMainView = inflater.inflate(R.layout.layout_touchscreen_controller_analog_sticks, this, true);
+                break;
+
+            case "none":
+            default:
+                mMainView = null;
+                break;
+        }
+
+        if (mMainView == null)
+            return;
+
+        mMainView.setOnTouchListener((view1, event) -> {
+            return handleTouchEvent(event);
+        });
+
+        linkButton(mMainView, R.id.controller_button_up, "Up");
+        linkButton(mMainView, R.id.controller_button_right, "Right");
+        linkButton(mMainView, R.id.controller_button_down, "Down");
+        linkButton(mMainView, R.id.controller_button_left, "Left");
+        linkButton(mMainView, R.id.controller_button_l1, "L1");
+        linkButton(mMainView, R.id.controller_button_l2, "L2");
+        linkButton(mMainView, R.id.controller_button_select, "Select");
+        linkButton(mMainView, R.id.controller_button_start, "Start");
+        linkButton(mMainView, R.id.controller_button_triangle, "Triangle");
+        linkButton(mMainView, R.id.controller_button_circle, "Circle");
+        linkButton(mMainView, R.id.controller_button_cross, "Cross");
+        linkButton(mMainView, R.id.controller_button_square, "Square");
+        linkButton(mMainView, R.id.controller_button_r1, "R1");
+        linkButton(mMainView, R.id.controller_button_r2, "R2");
+
+        if (!linkAxis(mMainView, R.id.controller_axis_left, "Left"))
+            linkAxisToButtons(mMainView, R.id.controller_axis_left, "");
+
+        linkAxis(mMainView, R.id.controller_axis_right, "Right");
+    }
+
+    private void linkButton(View view, int id, String buttonName) {
+        TouchscreenControllerButtonView buttonView = (TouchscreenControllerButtonView) view.findViewById(id);
+        if (buttonView == null)
+            return;
+
+        int code = AndroidHostInterface.getInstance().getControllerButtonCode(mControllerType, buttonName);
+        Log.i("TouchscreenController", String.format("%s -> %d", buttonName, code));
+
+        if (code >= 0) {
+            buttonView.setButtonCode(mControllerIndex, code);
+            mButtonViews.add(buttonView);
+        } else {
+            Log.e("TouchscreenController", String.format("Unknown button name '%s' " +
+                    "for '%s'", buttonName, mControllerType));
+        }
+    }
+
+    private boolean linkAxis(View view, int id, String axisName) {
+        TouchscreenControllerAxisView axisView = (TouchscreenControllerAxisView) view.findViewById(id);
+        if (axisView == null)
+            return false;
+
+        int xCode = AndroidHostInterface.getInstance().getControllerAxisCode(mControllerType, axisName + "X");
+        int yCode = AndroidHostInterface.getInstance().getControllerAxisCode(mControllerType, axisName + "Y");
+        Log.i("TouchscreenController", String.format("%s -> %d/%d", axisName, xCode, yCode));
+        if (xCode < 0 && yCode < 0)
+            return false;
+
+        axisView.setControllerAxis(mControllerIndex, xCode, yCode);
+        mAxisViews.add(axisView);
+        return true;
+    }
+
+    private boolean linkAxisToButtons(View view, int id, String buttonPrefix) {
+        TouchscreenControllerAxisView axisView = (TouchscreenControllerAxisView) view.findViewById(id);
+        if (axisView == null)
+            return false;
+
+        int leftCode = AndroidHostInterface.getInstance().getControllerButtonCode(mControllerType, buttonPrefix + "Left");
+        int rightCode = AndroidHostInterface.getInstance().getControllerButtonCode(mControllerType, buttonPrefix + "Right");
+        int upCode = AndroidHostInterface.getInstance().getControllerButtonCode(mControllerType, buttonPrefix + "Up");
+        int downCode = AndroidHostInterface.getInstance().getControllerButtonCode(mControllerType, buttonPrefix + "Down");
+        Log.i("TouchscreenController", String.format("%s(ButtonAxis) -> %d,%d,%d,%d", buttonPrefix, leftCode, rightCode, upCode, downCode));
+        if (leftCode < 0 && rightCode < 0 && upCode < 0 && downCode < 0)
+            return false;
+
+        axisView.setControllerButtons(mControllerIndex, leftCode, rightCode, upCode, downCode);
+        mAxisViews.add(axisView);
+        return true;
+    }
+
+    private boolean handleTouchEvent(MotionEvent event) {
+        switch (event.getActionMasked())
+        {
+            case MotionEvent.ACTION_UP:
+            {
+                for (TouchscreenControllerButtonView buttonView : mButtonViews) {
+                    buttonView.setPressed(false);
+                }
+
+                for (TouchscreenControllerAxisView axisView : mAxisViews) {
+                    axisView.setUnpressed();
+                }
+
+                return true;
+            }
+
+            case MotionEvent.ACTION_DOWN:
+            case MotionEvent.ACTION_POINTER_DOWN:
+            case MotionEvent.ACTION_POINTER_UP:
+            case MotionEvent.ACTION_MOVE:
+            {
+                Rect rect = new Rect();
+                final int pointerCount = event.getPointerCount();
+                final int liftedPointerIndex = (event.getActionMasked() == MotionEvent.ACTION_POINTER_UP) ? event.getActionIndex() : -1;
+                for (TouchscreenControllerButtonView buttonView : mButtonViews) {
+                    buttonView.getHitRect(rect);
+                    boolean pressed = false;
+                    for (int i = 0; i < pointerCount; i++) {
+                        if (i == liftedPointerIndex)
+                            continue;
+
+                        final int x = (int) event.getX(i);
+                        final int y = (int) event.getY(i);
+                        if (rect.contains(x, y)) {
+                            buttonView.setPressed(true);
+                            pressed = true;
+                            break;
+                        }
+                    }
+
+                    if (!pressed)
+                        buttonView.setPressed(pressed);
+                }
+
+                for (TouchscreenControllerAxisView axisView : mAxisViews) {
+                    axisView.getHitRect(rect);
+                    boolean pressed = false;
+                    for (int i = 0; i < pointerCount; i++) {
+                        if (i == liftedPointerIndex)
+                            continue;
+
+                        final int pointerId = event.getPointerId(i);
+                        final int x = (int) event.getX(i);
+                        final int y = (int) event.getY(i);
+
+                        if ((rect.contains(x, y) && !axisView.isPressed()) ||
+                                (axisView.isPressed() && axisView.getPointerId() == pointerId)) {
+                            axisView.setPressed(pointerId, x, y);
+                            pressed = true;
+                            break;
+                        }
+                    }
+                    if (!pressed)
+                        axisView.setUnpressed();
+                }
+
+                return true;
+            }
+        }
+
+        return false;
+    }
+}

android/app/src/main/res/drawable-v24/ic_launcher_foreground.xml

@@ -0,0 +1,34 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:aapt="http://schemas.android.com/aapt"
+    android:width="108dp"
+    android:height="108dp"
+    android:viewportWidth="108"
+    android:viewportHeight="108">
+    <path
+        android:fillType="evenOdd"
+        android:pathData="M32,64C32,64 38.39,52.99 44.13,50.95C51.37,48.37 70.14,49.57 70.14,49.57L108.26,87.69L108,109.01L75.97,107.97L32,64Z"
+        android:strokeWidth="1"
+        android:strokeColor="#00000000">
+        <aapt:attr name="android:fillColor">
+            <gradient
+                android:endX="78.5885"
+                android:endY="90.9159"
+                android:startX="48.7653"
+                android:startY="61.0927"
+                android:type="linear">
+                <item
+                    android:color="#44000000"
+                    android:offset="0.0" />
+                <item
+                    android:color="#00000000"
+                    android:offset="1.0" />
+            </gradient>
+        </aapt:attr>
+    </path>
+    <path
+        android:fillColor="#FFFFFF"
+        android:fillType="nonZero"
+        android:pathData="M66.94,46.02L66.94,46.02C72.44,50.07 76,56.61 76,64L32,64C32,56.61 35.56,50.11 40.98,46.06L36.18,41.19C35.45,40.45 35.45,39.3 36.18,38.56C36.91,37.81 38.05,37.81 38.78,38.56L44.25,44.05C47.18,42.57 50.48,41.71 54,41.71C57.48,41.71 60.78,42.57 63.68,44.05L69.11,38.56C69.84,37.81 70.98,37.81 71.71,38.56C72.44,39.3 72.44,40.45 71.71,41.19L66.94,46.02ZM62.94,56.92C64.08,56.92 65,56.01 65,54.88C65,53.76 64.08,52.85 62.94,52.85C61.8,52.85 60.88,53.76 60.88,54.88C60.88,56.01 61.8,56.92 62.94,56.92ZM45.06,56.92C46.2,56.92 47.13,56.01 47.13,54.88C47.13,53.76 46.2,52.85 45.06,52.85C43.92,52.85 43,53.76 43,54.88C43,56.01 43.92,56.92 45.06,56.92Z"
+        android:strokeWidth="1"
+        android:strokeColor="#00000000" />
+</vector>

android/app/src/main/res/drawable/flag_eu.xml

@@ -0,0 +1,71 @@
+<?xml version="1.0" encoding="utf-8"?><!-- https://raw.githubusercontent.com/Shusshu/android-flags/master/flags/src/main/res/drawable/flag_us2.xml -->
+<vector android:height="15dp"
+    android:viewportHeight="15"
+    android:viewportWidth="21"
+    android:width="21dp"
+    xmlns:aapt="http://schemas.android.com/aapt"
+    xmlns:android="http://schemas.android.com/apk/res/android">
+    <path
+        android:fillType="evenOdd"
+        android:pathData="M0,0h21v15h-21z"
+        android:strokeColor="#00000000"
+        android:strokeWidth="1">
+        <aapt:attr name="android:fillColor">
+            <gradient
+                android:endX="10.5"
+                android:endY="15"
+                android:startX="10.5"
+                android:startY="0"
+                android:type="linear">
+                <item
+                    android:color="#FFFFFFFF"
+                    android:offset="0" />
+                <item
+                    android:color="#FFF0F0F0"
+                    android:offset="1" />
+            </gradient>
+        </aapt:attr>
+    </path>
+    <path
+        android:fillType="evenOdd"
+        android:pathData="M0,0h21v15h-21z"
+        android:strokeColor="#00000000"
+        android:strokeWidth="1">
+        <aapt:attr name="android:fillColor">
+            <gradient
+                android:endX="10.5"
+                android:endY="15"
+                android:startX="10.5"
+                android:startY="0"
+                android:type="linear">
+                <item
+                    android:color="#FF043CAE"
+                    android:offset="0" />
+                <item
+                    android:color="#FF00339A"
+                    android:offset="1" />
+            </gradient>
+        </aapt:attr>
+    </path>
+    <path
+        android:fillType="evenOdd"
+        android:pathData="M10.5,3L9.7929,3.2071L10,2.5L9.7929,1.7929L10.5,2L11.2071,1.7929L11,2.5L11.2071,3.2071L10.5,3ZM10.5,13L9.7929,13.2071L10,12.5L9.7929,11.7929L10.5,12L11.2071,11.7929L11,12.5L11.2071,13.2071L10.5,13ZM15.5,8L14.7929,8.2071L15,7.5L14.7929,6.7929L15.5,7L16.2071,6.7929L16,7.5L16.2071,8.2071L15.5,8ZM5.5,8L4.7929,8.2071L5,7.5L4.7929,6.7929L5.5,7L6.2071,6.7929L6,7.5L6.2071,8.2071L5.5,8ZM14.8301,5.5L14.123,5.7071L14.3301,5L14.123,4.2929L14.8301,4.5L15.5372,4.2929L15.3301,5L15.5372,5.7071L14.8301,5.5ZM6.1699,10.5L5.4628,10.7071L5.6699,10L5.4628,9.2929L6.1699,9.5L6.877,9.2929L6.6699,10L6.877,10.7071L6.1699,10.5ZM13,3.6699L12.2929,3.877L12.5,3.1699L12.2929,2.4628L13,2.6699L13.7071,2.4628L13.5,3.1699L13.7071,3.877L13,3.6699ZM8,12.3301L7.2929,12.5372L7.5,11.8301L7.2929,11.123L8,11.3301L8.7071,11.123L8.5,11.8301L8.7071,12.5372L8,12.3301ZM14.8301,10.5L14.123,10.7071L14.3301,10L14.123,9.2929L14.8301,9.5L15.5372,9.2929L15.3301,10L15.5372,10.7071L14.8301,10.5ZM6.1699,5.5L5.4628,5.7071L5.6699,5L5.4628,4.2929L6.1699,4.5L6.877,4.2929L6.6699,5L6.877,5.7071L6.1699,5.5ZM13,12.3301L12.2929,12.5372L12.5,11.8301L12.2929,11.123L13,11.3301L13.7071,11.123L13.5,11.8301L13.7071,12.5372L13,12.3301ZM8,3.6699L7.2929,3.877L7.5,3.1699L7.2929,2.4628L8,2.6699L8.7071,2.4628L8.5,3.1699L8.7071,3.877L8,3.6699Z"
+        android:strokeColor="#00000000"
+        android:strokeWidth="1">
+        <aapt:attr name="android:fillColor">
+            <gradient
+                android:endX="10.5"
+                android:endY="13.2071"
+                android:startX="10.5"
+                android:startY="1.7929"
+                android:type="linear">
+                <item
+                    android:color="#FFFFD429"
+                    android:offset="0" />
+                <item
+                    android:color="#FFFFCC00"
+                    android:offset="1" />
+            </gradient>
+        </aapt:attr>
+    </path>
+</vector>

android/app/src/main/res/drawable/flag_jp.xml

@@ -0,0 +1,50 @@
+<?xml version="1.0" encoding="utf-8"?><!-- https://raw.githubusercontent.com/Shusshu/android-flags/master/flags/src/main/res/drawable/flag_hp.xml -->
+<vector android:height="15dp"
+    android:viewportHeight="15"
+    android:viewportWidth="21"
+    android:width="21dp"
+    xmlns:aapt="http://schemas.android.com/aapt"
+    xmlns:android="http://schemas.android.com/apk/res/android">
+    <path
+        android:fillType="evenOdd"
+        android:pathData="M0,0h21v15h-21z"
+        android:strokeColor="#00000000"
+        android:strokeWidth="1">
+        <aapt:attr name="android:fillColor">
+            <gradient
+                android:endX="10.5"
+                android:endY="15"
+                android:startX="10.5"
+                android:startY="0"
+                android:type="linear">
+                <item
+                    android:color="#FFFFFFFF"
+                    android:offset="0" />
+                <item
+                    android:color="#FFF0F0F0"
+                    android:offset="1" />
+            </gradient>
+        </aapt:attr>
+    </path>
+    <path
+        android:fillType="evenOdd"
+        android:pathData="M10.5,7.5m-4.5,0a4.5,4.5 0,1 1,9 0a4.5,4.5 0,1 1,-9 0"
+        android:strokeColor="#00000000"
+        android:strokeWidth="1">
+        <aapt:attr name="android:fillColor">
+            <gradient
+                android:endX="10.5"
+                android:endY="12"
+                android:startX="10.5"
+                android:startY="3"
+                android:type="linear">
+                <item
+                    android:color="#FFD81441"
+                    android:offset="0" />
+                <item
+                    android:color="#FFBB0831"
+                    android:offset="1" />
+            </gradient>
+        </aapt:attr>
+    </path>
+</vector>

android/app/src/main/res/drawable/flag_us.xml

@@ -0,0 +1,539 @@
+<?xml version="1.0" encoding="utf-8"?><!-- https://raw.githubusercontent.com/Shusshu/android-flags/master/flags/src/main/res/drawable/flag_us2.xml -->
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="21dp"
+    android:height="21dp"
+    android:viewportWidth="10"
+    android:viewportHeight="13">
+    <path
+        android:fillColor="#bd3d44"
+        android:pathData="M0 0h13v1h-13Z" />
+    <path
+        android:fillColor="#fff"
+        android:pathData="M0 1h13v1h-13Z" />
+    <path
+        android:fillColor="#bd3d44"
+        android:pathData="M0 2h13v1h-13Z" />
+    <path
+        android:fillColor="#fff"
+        android:pathData="M0 3h13v1h-13Z" />
+    <path
+        android:fillColor="#bd3d44"
+        android:pathData="M0 4h13v1h-13Z" />
+    <path
+        android:fillColor="#fff"
+        android:pathData="M0 5h13v1h-13Z" />
+    <path
+        android:fillColor="#bd3d44"
+        android:pathData="M0 6h13v1h-13Z" />
+    <path
+        android:fillColor="#fff"
+        android:pathData="M0 7h13v1h-13Z" />
+    <path
+        android:fillColor="#bd3d44"
+        android:pathData="M0 8h13v1h-13Z" />
+    <path
+        android:fillColor="#fff"
+        android:pathData="M0 9h13v1h-13Z" />
+    <path
+        android:fillColor="#bd3d44"
+        android:pathData="M0 10h13v1h-13Z" />
+    <path
+        android:fillColor="#fff"
+        android:pathData="M0 11h13v1h-13Z" />
+    <path
+        android:fillColor="#bd3d44"
+        android:pathData="M0 12h13v1h-13Z" />
+    <path
+        android:fillColor="#192f5d"
+        android:pathData="M0 0h5.2v7h-5.2Z" />
+
+    <group
+        android:translateX="0.2"
+        android:translateY="0.2"
+        android:scaleX="0.009"
+        android:scaleY="0.012">
+        <path
+            android:fillColor="#fff"
+            android:pathData="M 48,54 L 31,42 15,54 21,35 6,23 25,23 32,4 40,23 58,23 42,35 z" />
+    </group>
+    <group
+        android:translateX="1.0"
+        android:translateY="0.2"
+        android:scaleX="0.009"
+        android:scaleY="0.012">
+        <path
+            android:fillColor="#fff"
+            android:pathData="M 48,54 L 31,42 15,54 21,35 6,23 25,23 32,4 40,23 58,23 42,35 z" />
+    </group>
+    <group
+        android:translateX="1.8"
+        android:translateY="0.2"
+        android:scaleX="0.009"
+        android:scaleY="0.012">
+        <path
+            android:fillColor="#fff"
+            android:pathData="M 48,54 L 31,42 15,54 21,35 6,23 25,23 32,4 40,23 58,23 42,35 z" />
+    </group>
+    <group
+        android:translateX="2.6"
+        android:translateY="0.2"
+        android:scaleX="0.009"
+        android:scaleY="0.012">
+        <path
+            android:fillColor="#fff"
+            android:pathData="M 48,54 L 31,42 15,54 21,35 6,23 25,23 32,4 40,23 58,23 42,35 z" />
+    </group>
+    <group
+        android:translateX="3.4"
+        android:translateY="0.2"
+        android:scaleX="0.009"
+        android:scaleY="0.012">
+        <path
+            android:fillColor="#fff"
+            android:pathData="M 48,54 L 31,42 15,54 21,35 6,23 25,23 32,4 40,23 58,23 42,35 z" />
+    </group>
+    <group
+        android:translateX="4.2"
+        android:translateY="0.2"
+        android:scaleX="0.009"
+        android:scaleY="0.012">
+        <path
+            android:fillColor="#fff"
+            android:pathData="M 48,54 L 31,42 15,54 21,35 6,23 25,23 32,4 40,23 58,23 42,35 z" />
+    </group>
+
+
+    <group android:translateY="1.4">
+        <group
+            android:translateX="0.2"
+            android:translateY="0.2"
+            android:scaleX="0.009"
+            android:scaleY="0.012">
+            <path
+                android:fillColor="#fff"
+                android:pathData="M 48,54 L 31,42 15,54 21,35 6,23 25,23 32,4 40,23 58,23 42,35 z" />
+        </group>
+        <group
+            android:translateX="1.0"
+            android:translateY="0.2"
+            android:scaleX="0.009"
+            android:scaleY="0.012">
+            <path
+                android:fillColor="#fff"
+                android:pathData="M 48,54 L 31,42 15,54 21,35 6,23 25,23 32,4 40,23 58,23 42,35 z" />
+        </group>
+        <group
+            android:translateX="1.8"
+            android:translateY="0.2"
+            android:scaleX="0.009"
+            android:scaleY="0.012">
+            <path
+                android:fillColor="#fff"
+                android:pathData="M 48,54 L 31,42 15,54 21,35 6,23 25,23 32,4 40,23 58,23 42,35 z" />
+        </group>
+        <group
+            android:translateX="2.6"
+            android:translateY="0.2"
+            android:scaleX="0.009"
+            android:scaleY="0.012">
+            <path
+                android:fillColor="#fff"
+                android:pathData="M 48,54 L 31,42 15,54 21,35 6,23 25,23 32,4 40,23 58,23 42,35 z" />
+        </group>
+        <group
+            android:translateX="3.4"
+            android:translateY="0.2"
+            android:scaleX="0.009"
+            android:scaleY="0.012">
+            <path
+                android:fillColor="#fff"
+                android:pathData="M 48,54 L 31,42 15,54 21,35 6,23 25,23 32,4 40,23 58,23 42,35 z" />
+        </group>
+        <group
+            android:translateX="4.2"
+            android:translateY="0.2"
+            android:scaleX="0.009"
+            android:scaleY="0.012">
+            <path
+                android:fillColor="#fff"
+                android:pathData="M 48,54 L 31,42 15,54 21,35 6,23 25,23 32,4 40,23 58,23 42,35 z" />
+        </group>
+    </group>
+
+
+    <group android:translateY="2.9">
+        <group
+            android:translateX="0.2"
+            android:translateY="0.2"
+            android:scaleX="0.009"
+            android:scaleY="0.012">
+            <path
+                android:fillColor="#fff"
+                android:pathData="M 48,54 L 31,42 15,54 21,35 6,23 25,23 32,4 40,23 58,23 42,35 z" />
+        </group>
+        <group
+            android:translateX="1.0"
+            android:translateY="0.2"
+            android:scaleX="0.009"
+            android:scaleY="0.012">
+            <path
+                android:fillColor="#fff"
+                android:pathData="M 48,54 L 31,42 15,54 21,35 6,23 25,23 32,4 40,23 58,23 42,35 z" />
+        </group>
+        <group
+            android:translateX="1.8"
+            android:translateY="0.2"
+            android:scaleX="0.009"
+            android:scaleY="0.012">
+            <path
+                android:fillColor="#fff"
+                android:pathData="M 48,54 L 31,42 15,54 21,35 6,23 25,23 32,4 40,23 58,23 42,35 z" />
+        </group>
+        <group
+            android:translateX="2.6"
+            android:translateY="0.2"
+            android:scaleX="0.009"
+            android:scaleY="0.012">
+            <path
+                android:fillColor="#fff"
+                android:pathData="M 48,54 L 31,42 15,54 21,35 6,23 25,23 32,4 40,23 58,23 42,35 z" />
+        </group>
+        <group
+            android:translateX="3.4"
+            android:translateY="0.2"
+            android:scaleX="0.009"
+            android:scaleY="0.012">
+            <path
+                android:fillColor="#fff"
+                android:pathData="M 48,54 L 31,42 15,54 21,35 6,23 25,23 32,4 40,23 58,23 42,35 z" />
+        </group>
+        <group
+            android:translateX="4.2"
+            android:translateY="0.2"
+            android:scaleX="0.009"
+            android:scaleY="0.012">
+            <path
+                android:fillColor="#fff"
+                android:pathData="M 48,54 L 31,42 15,54 21,35 6,23 25,23 32,4 40,23 58,23 42,35 z" />
+        </group>
+    </group>
+
+
+    <group android:translateY="4.3">
+        <group
+            android:translateX="0.2"
+            android:translateY="0.2"
+            android:scaleX="0.009"
+            android:scaleY="0.012">
+            <path
+                android:fillColor="#fff"
+                android:pathData="M 48,54 L 31,42 15,54 21,35 6,23 25,23 32,4 40,23 58,23 42,35 z" />
+        </group>
+        <group
+            android:translateX="1.0"
+            android:translateY="0.2"
+            android:scaleX="0.009"
+            android:scaleY="0.012">
+            <path
+                android:fillColor="#fff"
+                android:pathData="M 48,54 L 31,42 15,54 21,35 6,23 25,23 32,4 40,23 58,23 42,35 z" />
+        </group>
+        <group
+            android:translateX="1.8"
+            android:translateY="0.2"
+            android:scaleX="0.009"
+            android:scaleY="0.012">
+            <path
+                android:fillColor="#fff"
+                android:pathData="M 48,54 L 31,42 15,54 21,35 6,23 25,23 32,4 40,23 58,23 42,35 z" />
+        </group>
+        <group
+            android:translateX="2.6"
+            android:translateY="0.2"
+            android:scaleX="0.009"
+            android:scaleY="0.012">
+            <path
+                android:fillColor="#fff"
+                android:pathData="M 48,54 L 31,42 15,54 21,35 6,23 25,23 32,4 40,23 58,23 42,35 z" />
+        </group>
+        <group
+            android:translateX="3.4"
+            android:translateY="0.2"
+            android:scaleX="0.009"
+            android:scaleY="0.012">
+            <path
+                android:fillColor="#fff"
+                android:pathData="M 48,54 L 31,42 15,54 21,35 6,23 25,23 32,4 40,23 58,23 42,35 z" />
+        </group>
+        <group
+            android:translateX="4.2"
+            android:translateY="0.2"
+            android:scaleX="0.009"
+            android:scaleY="0.012">
+            <path
+                android:fillColor="#fff"
+                android:pathData="M 48,54 L 31,42 15,54 21,35 6,23 25,23 32,4 40,23 58,23 42,35 z" />
+        </group>
+    </group>
+
+
+    <group android:translateY="5.6">
+        <group
+            android:translateX="0.2"
+            android:translateY="0.2"
+            android:scaleX="0.009"
+            android:scaleY="0.012">
+            <path
+                android:fillColor="#fff"
+                android:pathData="M 48,54 L 31,42 15,54 21,35 6,23 25,23 32,4 40,23 58,23 42,35 z" />
+        </group>
+        <group
+            android:translateX="1.0"
+            android:translateY="0.2"
+            android:scaleX="0.009"
+            android:scaleY="0.012">
+            <path
+                android:fillColor="#fff"
+                android:pathData="M 48,54 L 31,42 15,54 21,35 6,23 25,23 32,4 40,23 58,23 42,35 z" />
+        </group>
+        <group
+            android:translateX="1.8"
+            android:translateY="0.2"
+            android:scaleX="0.009"
+            android:scaleY="0.012">
+            <path
+                android:fillColor="#fff"
+                android:pathData="M 48,54 L 31,42 15,54 21,35 6,23 25,23 32,4 40,23 58,23 42,35 z" />
+        </group>
+        <group
+            android:translateX="2.6"
+            android:translateY="0.2"
+            android:scaleX="0.009"
+            android:scaleY="0.012">
+            <path
+                android:fillColor="#fff"
+                android:pathData="M 48,54 L 31,42 15,54 21,35 6,23 25,23 32,4 40,23 58,23 42,35 z" />
+        </group>
+        <group
+            android:translateX="3.4"
+            android:translateY="0.2"
+            android:scaleX="0.009"
+            android:scaleY="0.012">
+            <path
+                android:fillColor="#fff"
+                android:pathData="M 48,54 L 31,42 15,54 21,35 6,23 25,23 32,4 40,23 58,23 42,35 z" />
+        </group>
+        <group
+            android:translateX="4.2"
+            android:translateY="0.2"
+            android:scaleX="0.009"
+            android:scaleY="0.012">
+            <path
+                android:fillColor="#fff"
+                android:pathData="M 48,54 L 31,42 15,54 21,35 6,23 25,23 32,4 40,23 58,23 42,35 z" />
+        </group>
+    </group>
+
+    <!-- Odd stars -->
+
+    <group
+        android:translateY="0.7"
+        android:translateX="0.4">
+        <group
+            android:translateX="0.2"
+            android:translateY="0.2"
+            android:scaleX="0.009"
+            android:scaleY="0.012">
+            <path
+                android:fillColor="#fff"
+                android:pathData="M 48,54 L 31,42 15,54 21,35 6,23 25,23 32,4 40,23 58,23 42,35 z" />
+        </group>
+        <group
+            android:translateX="1.0"
+            android:translateY="0.2"
+            android:scaleX="0.009"
+            android:scaleY="0.012">
+            <path
+                android:fillColor="#fff"
+                android:pathData="M 48,54 L 31,42 15,54 21,35 6,23 25,23 32,4 40,23 58,23 42,35 z" />
+        </group>
+        <group
+            android:translateX="1.8"
+            android:translateY="0.2"
+            android:scaleX="0.009"
+            android:scaleY="0.012">
+            <path
+                android:fillColor="#fff"
+                android:pathData="M 48,54 L 31,42 15,54 21,35 6,23 25,23 32,4 40,23 58,23 42,35 z" />
+        </group>
+        <group
+            android:translateX="2.6"
+            android:translateY="0.2"
+            android:scaleX="0.009"
+            android:scaleY="0.012">
+            <path
+                android:fillColor="#fff"
+                android:pathData="M 48,54 L 31,42 15,54 21,35 6,23 25,23 32,4 40,23 58,23 42,35 z" />
+        </group>
+        <group
+            android:translateX="3.4"
+            android:translateY="0.2"
+            android:scaleX="0.009"
+            android:scaleY="0.012">
+            <path
+                android:fillColor="#fff"
+                android:pathData="M 48,54 L 31,42 15,54 21,35 6,23 25,23 32,4 40,23 58,23 42,35 z" />
+        </group>
+    </group>
+
+    <group
+        android:translateY="2.1"
+        android:translateX="0.4">
+        <group
+            android:translateX="0.2"
+            android:translateY="0.2"
+            android:scaleX="0.009"
+            android:scaleY="0.012">
+            <path
+                android:fillColor="#fff"
+                android:pathData="M 48,54 L 31,42 15,54 21,35 6,23 25,23 32,4 40,23 58,23 42,35 z" />
+        </group>
+        <group
+            android:translateX="1.0"
+            android:translateY="0.2"
+            android:scaleX="0.009"
+            android:scaleY="0.012">
+            <path
+                android:fillColor="#fff"
+                android:pathData="M 48,54 L 31,42 15,54 21,35 6,23 25,23 32,4 40,23 58,23 42,35 z" />
+        </group>
+        <group
+            android:translateX="1.8"
+            android:translateY="0.2"
+            android:scaleX="0.009"
+            android:scaleY="0.012">
+            <path
+                android:fillColor="#fff"
+                android:pathData="M 48,54 L 31,42 15,54 21,35 6,23 25,23 32,4 40,23 58,23 42,35 z" />
+        </group>
+        <group
+            android:translateX="2.6"
+            android:translateY="0.2"
+            android:scaleX="0.009"
+            android:scaleY="0.012">
+            <path
+                android:fillColor="#fff"
+                android:pathData="M 48,54 L 31,42 15,54 21,35 6,23 25,23 32,4 40,23 58,23 42,35 z" />
+        </group>
+        <group
+            android:translateX="3.4"
+            android:translateY="0.2"
+            android:scaleX="0.009"
+            android:scaleY="0.012">
+            <path
+                android:fillColor="#fff"
+                android:pathData="M 48,54 L 31,42 15,54 21,35 6,23 25,23 32,4 40,23 58,23 42,35 z" />
+        </group>
+    </group>
+
+    <group
+        android:translateY="3.6"
+        android:translateX="0.4">
+        <group
+            android:translateX="0.2"
+            android:translateY="0.2"
+            android:scaleX="0.009"
+            android:scaleY="0.012">
+            <path
+                android:fillColor="#fff"
+                android:pathData="M 48,54 L 31,42 15,54 21,35 6,23 25,23 32,4 40,23 58,23 42,35 z" />
+        </group>
+        <group
+            android:translateX="1.0"
+            android:translateY="0.2"
+            android:scaleX="0.009"
+            android:scaleY="0.012">
+            <path
+                android:fillColor="#fff"
+                android:pathData="M 48,54 L 31,42 15,54 21,35 6,23 25,23 32,4 40,23 58,23 42,35 z" />
+        </group>
+        <group
+            android:translateX="1.8"
+            android:translateY="0.2"
+            android:scaleX="0.009"
+            android:scaleY="0.012">
+            <path
+                android:fillColor="#fff"
+                android:pathData="M 48,54 L 31,42 15,54 21,35 6,23 25,23 32,4 40,23 58,23 42,35 z" />
+        </group>
+        <group
+            android:translateX="2.6"
+            android:translateY="0.2"
+            android:scaleX="0.009"
+            android:scaleY="0.012">
+            <path
+                android:fillColor="#fff"
+                android:pathData="M 48,54 L 31,42 15,54 21,35 6,23 25,23 32,4 40,23 58,23 42,35 z" />
+        </group>
+        <group
+            android:translateX="3.4"
+            android:translateY="0.2"
+            android:scaleX="0.009"
+            android:scaleY="0.012">
+            <path
+                android:fillColor="#fff"
+                android:pathData="M 48,54 L 31,42 15,54 21,35 6,23 25,23 32,4 40,23 58,23 42,35 z" />
+        </group>
+    </group>
+
+    <group
+        android:translateY="5.0"
+        android:translateX="0.4">
+        <group
+            android:translateX="0.2"
+            android:translateY="0.2"
+            android:scaleX="0.009"
+            android:scaleY="0.012">
+            <path
+                android:fillColor="#fff"
+                android:pathData="M 48,54 L 31,42 15,54 21,35 6,23 25,23 32,4 40,23 58,23 42,35 z" />
+        </group>
+        <group
+            android:translateX="1.0"
+            android:translateY="0.2"
+            android:scaleX="0.009"
+            android:scaleY="0.012">
+            <path
+                android:fillColor="#fff"
+                android:pathData="M 48,54 L 31,42 15,54 21,35 6,23 25,23 32,4 40,23 58,23 42,35 z" />
+        </group>
+        <group
+            android:translateX="1.8"
+            android:translateY="0.2"
+            android:scaleX="0.009"
+            android:scaleY="0.012">
+            <path
+                android:fillColor="#fff"
+                android:pathData="M 48,54 L 31,42 15,54 21,35 6,23 25,23 32,4 40,23 58,23 42,35 z" />
+        </group>
+        <group
+            android:translateX="2.6"
+            android:translateY="0.2"
+            android:scaleX="0.009"
+            android:scaleY="0.012">
+            <path
+                android:fillColor="#fff"
+                android:pathData="M 48,54 L 31,42 15,54 21,35 6,23 25,23 32,4 40,23 58,23 42,35 z" />
+        </group>
+        <group
+            android:translateX="3.4"
+            android:translateY="0.2"
+            android:scaleX="0.009"
+            android:scaleY="0.012">
+            <path
+                android:fillColor="#fff"
+                android:pathData="M 48,54 L 31,42 15,54 21,35 6,23 25,23 32,4 40,23 58,23 42,35 z" />
+        </group>
+    </group>
+
+</vector>

android/app/src/main/res/drawable/ic_baseline_play_arrow_24.xml

@@ -0,0 +1,10 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="24"
+    android:viewportHeight="24"
+    android:tint="?attr/colorControlNormal">
+    <path
+        android:fillColor="@android:color/white"
+        android:pathData="M8,5v14l11,-7z" />
+</vector>

android/app/src/main/res/drawable/ic_controller_analog_base.xml

@@ -0,0 +1,21 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="194.89dp"
+    android:height="194.89dp"
+    android:viewportWidth="194.89"
+    android:viewportHeight="194.89">
+  <path
+      android:pathData="M194.89,97.445A97.445,97.445 0,0 1,97.445 194.89,97.445 97.445,0 0,1 0,97.445 97.445,97.445 0,0 1,97.445 0,97.445 97.445,0 0,1 194.89,97.445Z"
+      android:strokeAlpha="0.50645"
+      android:fillColor="#1a1a1a"
+      android:fillAlpha="0.504414"/>
+  <path
+      android:pathData="M178.82,97.445A81.381,81.381 0,0 1,97.439 178.826,81.381 81.381,0 0,1 16.058,97.445 81.381,81.381 0,0 1,97.439 16.064,81.381 81.381,0 0,1 178.82,97.445Z"
+      android:strokeAlpha="0.50645"
+      android:fillColor="#333333"
+      android:fillAlpha="0.504414"/>
+  <path
+      android:pathData="M159.05,97.445A61.609,61.609 0,0 1,97.441 159.054,61.609 61.609,0 0,1 35.832,97.445 61.609,61.609 0,0 1,97.441 35.836,61.609 61.609,0 0,1 159.05,97.445Z"
+      android:strokeAlpha="0.50645"
+      android:fillColor="#1a1a1a"
+      android:fillAlpha="0.504414"/>
+</vector>

android/app/src/main/res/drawable/ic_controller_analog_stick_pressed.xml

@@ -0,0 +1,11 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="191.756dp"
+    android:height="191.756dp"
+    android:viewportWidth="191.756"
+    android:viewportHeight="191.756">
+  <path
+      android:pathData="M191.756,95.878A95.878,95.878 0,0 1,95.878 191.756,95.878 95.878,0 0,1 0,95.878 95.878,95.878 0,0 1,95.878 0,95.878 95.878,0 0,1 191.756,95.878Z"
+      android:strokeAlpha="0.8"
+      android:fillColor="#666666"
+      android:fillAlpha="0.796784"/>
+</vector>

android/app/src/main/res/drawable/ic_controller_analog_stick_unpressed.xml

@@ -0,0 +1,11 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="191.756dp"
+    android:height="191.756dp"
+    android:viewportWidth="191.756"
+    android:viewportHeight="191.756">
+  <path
+      android:pathData="M191.756,95.878A95.878,95.878 0,0 1,95.878 191.756,95.878 95.878,0 0,1 0,95.878 95.878,95.878 0,0 1,95.878 0,95.878 95.878,0 0,1 191.756,95.878Z"
+      android:strokeAlpha="0.50645"
+      android:fillColor="#666666"
+      android:fillAlpha="0.504414"/>
+</vector>

android/app/src/main/res/drawable/ic_controller_circle_button.xml

@@ -0,0 +1,19 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="100dp"
+    android:height="100dp"
+    android:viewportWidth="26.458332"
+    android:viewportHeight="26.45833">
+    <path
+        android:pathData="M13.2292,13.2292m-12.5677,0a12.5677,12.5677 0,1 1,25.1354 0a12.5677,12.5677 0,1 1,-25.1354 0"
+        android:strokeWidth="0.26458332"
+        android:fillColor="#00000000"
+        android:strokeColor="#ffffff" />
+    <path
+        android:pathData="M13.2292,13.2292m-10.5833,0a10.5833,10.5833 0,1 1,21.1667 0a10.5833,10.5833 0,1 1,-21.1667 0"
+        android:strokeLineJoin="round"
+        android:strokeWidth="1.05833328"
+        android:fillColor="#00000000"
+        android:strokeColor="#ff0000"
+        android:fillAlpha="1"
+        android:strokeLineCap="butt" />
+</vector>

android/app/src/main/res/drawable/ic_controller_circle_button_pressed.xml

@@ -0,0 +1,19 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="100dp"
+    android:height="100dp"
+    android:viewportWidth="26.458332"
+    android:viewportHeight="26.45833">
+    <path
+        android:pathData="M13.2292,13.2292m-12.5677,0a12.5677,12.5677 0,1 1,25.1354 0a12.5677,12.5677 0,1 1,-25.1354 0"
+        android:strokeWidth="0.26458332"
+        android:fillColor="#4d4d4d"
+        android:strokeColor="#ffffff" />
+    <path
+        android:pathData="M13.2292,13.2292m-10.5833,0a10.5833,10.5833 0,1 1,21.1667 0a10.5833,10.5833 0,1 1,-21.1667 0"
+        android:strokeLineJoin="round"
+        android:strokeWidth="1.05833328"
+        android:fillColor="#00000000"
+        android:strokeColor="#ff0000"
+        android:fillAlpha="1"
+        android:strokeLineCap="butt" />
+</vector>

android/app/src/main/res/drawable/ic_controller_cross_button.xml

@@ -0,0 +1,27 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="100dp"
+    android:height="100dp"
+    android:viewportWidth="26.458332"
+    android:viewportHeight="26.45833">
+    <path
+        android:pathData="M13.2292,13.2292m-12.5677,0a12.5677,12.5677 0,1 1,25.1354 0a12.5677,12.5677 0,1 1,-25.1354 0"
+        android:strokeWidth="0.26458332"
+        android:fillColor="#00000000"
+        android:strokeColor="#ffffff" />
+    <path
+        android:pathData="m5.2917,5.2917 l15.875,15.875"
+        android:strokeAlpha="1"
+        android:strokeLineJoin="miter"
+        android:strokeWidth="1.05833333"
+        android:fillColor="#ffffff"
+        android:strokeColor="#008080"
+        android:strokeLineCap="butt" />
+    <path
+        android:pathData="m5.2917,21.1667 l15.875,-15.875"
+        android:strokeAlpha="1"
+        android:strokeLineJoin="miter"
+        android:strokeWidth="1.05833333"
+        android:fillColor="#00000000"
+        android:strokeColor="#008080"
+        android:strokeLineCap="butt" />
+</vector>

android/app/src/main/res/drawable/ic_controller_cross_button_pressed.xml

@@ -0,0 +1,27 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="100dp"
+    android:height="100dp"
+    android:viewportWidth="26.458332"
+    android:viewportHeight="26.45833">
+    <path
+        android:pathData="M13.2292,13.2292m-12.5677,0a12.5677,12.5677 0,1 1,25.1354 0a12.5677,12.5677 0,1 1,-25.1354 0"
+        android:strokeWidth="0.26458332"
+        android:fillColor="#4d4d4d"
+        android:strokeColor="#ffffff" />
+    <path
+        android:pathData="m5.2917,5.2917 l15.875,15.875"
+        android:strokeAlpha="1"
+        android:strokeLineJoin="miter"
+        android:strokeWidth="1.05833333"
+        android:fillColor="#ffffff"
+        android:strokeColor="#008080"
+        android:strokeLineCap="butt" />
+    <path
+        android:pathData="m5.2917,21.1667 l15.875,-15.875"
+        android:strokeAlpha="1"
+        android:strokeLineJoin="miter"
+        android:strokeWidth="1.05833333"
+        android:fillColor="#00000000"
+        android:strokeColor="#008080"
+        android:strokeLineCap="butt" />
+</vector>

android/app/src/main/res/drawable/ic_controller_down_button.xml

@@ -0,0 +1,14 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="100dp"
+    android:height="100dp"
+    android:viewportWidth="26.458332"
+    android:viewportHeight="26.458332">
+    <path
+        android:pathData="m5.2917,10.5833 l7.9375,-7.9375 7.9375,7.9375v14.5521L5.2917,25.1354Z"
+        android:strokeAlpha="1"
+        android:strokeLineJoin="miter"
+        android:strokeWidth="0.26458332"
+        android:fillColor="#00000000"
+        android:strokeColor="#e6e6e6"
+        android:strokeLineCap="butt" />
+</vector>

android/app/src/main/res/drawable/ic_controller_down_button_pressed.xml

@@ -0,0 +1,14 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="100dp"
+    android:height="100dp"
+    android:viewportWidth="26.458332"
+    android:viewportHeight="26.458332">
+    <path
+        android:pathData="m5.2917,10.5833 l7.9375,-7.9375 7.9375,7.9375v14.5521L5.2917,25.1354Z"
+        android:strokeAlpha="1"
+        android:strokeLineJoin="miter"
+        android:strokeWidth="0.26458332"
+        android:fillColor="#4d4d4d"
+        android:strokeColor="#e6e6e6"
+        android:strokeLineCap="butt" />
+</vector>

android/app/src/main/res/drawable/ic_controller_l1_button.xml

@@ -0,0 +1,28 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="100dp"
+    android:height="50dp"
+    android:viewportWidth="26.458332"
+    android:viewportHeight="13.229165">
+    <path
+        android:pathData="M0.6615,0.6614L25.7969,0.6614v11.9063L0.6615,12.5677Z"
+        android:strokeAlpha="1"
+        android:strokeLineJoin="round"
+        android:strokeWidth="0.26458332"
+        android:fillColor="#00000000"
+        android:strokeColor="#e6e6e6"
+        android:strokeLineCap="round" />
+    <path
+        android:pathData="m9.6928,4.0428h0.6959v4.5579h2.5046v0.5857L9.6928,9.1863Z"
+        android:strokeAlpha="1"
+        android:strokeWidth="0.13229167"
+        android:fillColor="#000000"
+        android:strokeColor="#e6e6e6"
+        android:fillAlpha="0" />
+    <path
+        android:pathData="m13.8028,8.6007h1.1369v-3.924l-1.2368,0.2481v-0.6339l1.2299,-0.248h0.6959v4.5579h1.1369v0.5857h-2.9628z"
+        android:strokeAlpha="1"
+        android:strokeWidth="0.13229167"
+        android:fillColor="#000000"
+        android:strokeColor="#e6e6e6"
+        android:fillAlpha="0" />
+</vector>

android/app/src/main/res/drawable/ic_controller_l1_button_pressed.xml

@@ -0,0 +1,28 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="100dp"
+    android:height="50dp"
+    android:viewportWidth="26.458332"
+    android:viewportHeight="13.229165">
+    <path
+        android:pathData="M0.6615,0.6614L25.7969,0.6614v11.9063L0.6615,12.5677Z"
+        android:strokeAlpha="1"
+        android:strokeLineJoin="round"
+        android:strokeWidth="0.26458332"
+        android:fillColor="#4d4d4d"
+        android:strokeColor="#e6e6e6"
+        android:strokeLineCap="round" />
+    <path
+        android:pathData="m9.6928,4.0428h0.6959v4.5579h2.5046v0.5857L9.6928,9.1863Z"
+        android:strokeAlpha="1"
+        android:strokeWidth="0.13229167"
+        android:fillColor="#1a1a1a"
+        android:strokeColor="#000000"
+        android:fillAlpha="1" />
+    <path
+        android:pathData="m13.8028,8.6007h1.1369v-3.924l-1.2368,0.2481v-0.6339l1.2299,-0.248h0.6959v4.5579h1.1369v0.5857h-2.9628z"
+        android:strokeAlpha="1"
+        android:strokeWidth="0.13229167"
+        android:fillColor="#1a1a1a"
+        android:strokeColor="#000000"
+        android:fillAlpha="1" />
+</vector>

android/app/src/main/res/drawable/ic_controller_l2_button.xml

@@ -0,0 +1,28 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="100dp"
+    android:height="50dp"
+    android:viewportWidth="26.458332"
+    android:viewportHeight="13.229165">
+    <path
+        android:pathData="M0.6615,0.6614L25.7969,0.6614v11.9063L0.6615,12.5677Z"
+        android:strokeAlpha="1"
+        android:strokeLineJoin="round"
+        android:strokeWidth="0.26458332"
+        android:fillColor="#00000000"
+        android:strokeColor="#e6e6e6"
+        android:strokeLineCap="round" />
+    <path
+        android:pathData="m9.6928,4.0428h0.6959v4.5579h2.5046v0.5857L9.6928,9.1863Z"
+        android:strokeAlpha="1"
+        android:strokeWidth="0.13229167"
+        android:fillColor="#000000"
+        android:strokeColor="#e6e6e6"
+        android:fillAlpha="0" />
+    <path
+        android:pathData="m14.2816,8.6007h2.4288v0.5857h-3.2659v-0.5857q0.3962,-0.41 1.0783,-1.099 0.6856,-0.6925 0.8613,-0.8923 0.3342,-0.3755 0.4651,-0.6339 0.1344,-0.2618 0.1344,-0.5133 0,-0.41 -0.2894,-0.6683 -0.2859,-0.2584 -0.7476,-0.2584 -0.3273,0 -0.6925,0.1137 -0.3617,0.1137 -0.7751,0.3445v-0.7028q0.4203,-0.1688 0.7855,-0.2549 0.3652,-0.0861 0.6683,-0.0861 0.7993,0 1.2747,0.3996 0.4754,0.3996 0.4754,1.068 0,0.3169 -0.1206,0.6029 -0.1171,0.2825 -0.4306,0.6683 -0.0861,0.0999 -0.5478,0.5788 -0.4616,0.4754 -1.3022,1.3333z"
+        android:strokeAlpha="1"
+        android:strokeWidth="0.13229167"
+        android:fillColor="#000000"
+        android:strokeColor="#e6e6e6"
+        android:fillAlpha="0" />
+</vector>

android/app/src/main/res/drawable/ic_controller_l2_button_pressed.xml

@@ -0,0 +1,28 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="100dp"
+    android:height="50dp"
+    android:viewportWidth="26.458332"
+    android:viewportHeight="13.229165">
+    <path
+        android:pathData="M0.6615,0.6614L25.7969,0.6614v11.9063L0.6615,12.5677Z"
+        android:strokeAlpha="1"
+        android:strokeLineJoin="round"
+        android:strokeWidth="0.26458332"
+        android:fillColor="#4d4d4d"
+        android:strokeColor="#e6e6e6"
+        android:strokeLineCap="round" />
+    <path
+        android:pathData="m9.6928,4.0428h0.6959v4.5579h2.5046v0.5857L9.6928,9.1863Z"
+        android:strokeAlpha="1"
+        android:strokeWidth="0.13229167"
+        android:fillColor="#1a1a1a"
+        android:strokeColor="#000000"
+        android:fillAlpha="1" />
+    <path
+        android:pathData="m14.2816,8.6007h2.4288v0.5857h-3.2659v-0.5857q0.3962,-0.41 1.0783,-1.099 0.6856,-0.6925 0.8613,-0.8923 0.3342,-0.3755 0.4651,-0.6339 0.1344,-0.2618 0.1344,-0.5133 0,-0.41 -0.2894,-0.6683 -0.2859,-0.2584 -0.7476,-0.2584 -0.3273,0 -0.6925,0.1137 -0.3617,0.1137 -0.7751,0.3445v-0.7028q0.4203,-0.1688 0.7855,-0.2549 0.3652,-0.0861 0.6683,-0.0861 0.7993,0 1.2747,0.3996 0.4754,0.3996 0.4754,1.068 0,0.3169 -0.1206,0.6029 -0.1171,0.2825 -0.4306,0.6683 -0.0861,0.0999 -0.5478,0.5788 -0.4616,0.4754 -1.3022,1.3333z"
+        android:strokeAlpha="1"
+        android:strokeWidth="0.13229167"
+        android:fillColor="#1a1a1a"
+        android:strokeColor="#000000"
+        android:fillAlpha="1" />
+</vector>

android/app/src/main/res/drawable/ic_controller_left_button.xml

@@ -0,0 +1,14 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="100dp"
+    android:height="100dp"
+    android:viewportWidth="26.458332"
+    android:viewportHeight="26.458332">
+    <path
+        android:pathData="m16.5365,5.9531 l7.9375,7.9375 -7.9375,7.9375L1.9844,21.8281v-15.875z"
+        android:strokeAlpha="1"
+        android:strokeLineJoin="miter"
+        android:strokeWidth="0.26458332"
+        android:fillColor="#00000000"
+        android:strokeColor="#e6e6e6"
+        android:strokeLineCap="butt" />
+</vector>

android/app/src/main/res/drawable/ic_controller_left_button_pressed.xml

@@ -0,0 +1,14 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="100dp"
+    android:height="100dp"
+    android:viewportWidth="26.458332"
+    android:viewportHeight="26.458332">
+    <path
+        android:pathData="m16.5365,5.9531 l7.9375,7.9375 -7.9375,7.9375L1.9844,21.8281v-15.875z"
+        android:strokeAlpha="1"
+        android:strokeLineJoin="miter"
+        android:strokeWidth="0.26458332"
+        android:fillColor="#4d4d4d"
+        android:strokeColor="#e6e6e6"
+        android:strokeLineCap="butt" />
+</vector>

android/app/src/main/res/drawable/ic_controller_r1_button.xml

@@ -0,0 +1,28 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="100dp"
+    android:height="50dp"
+    android:viewportWidth="26.458332"
+    android:viewportHeight="13.229165">
+    <path
+        android:pathData="M0.6615,0.6614L25.7969,0.6614v11.9063L0.6615,12.5677Z"
+        android:strokeAlpha="1"
+        android:strokeLineJoin="round"
+        android:strokeWidth="0.26458332"
+        android:fillColor="#00000000"
+        android:strokeColor="#e6e6e6"
+        android:strokeLineCap="round" />
+    <path
+        android:pathData="m11.6703,6.8213q0.2239,0.0758 0.4341,0.3238 0.2136,0.248 0.4272,0.6821l0.7062,1.4056h-0.7476l-0.658,-1.3195q-0.2549,-0.5168 -0.4961,-0.6856 -0.2377,-0.1688 -0.6511,-0.1688L9.927,7.059v2.1739L9.2311,9.2329v-5.1435h1.571q0.8819,0 1.316,0.3686 0.4341,0.3686 0.4341,1.1128 0,0.4858 -0.2274,0.8062 -0.2239,0.3204 -0.6546,0.4444zM9.927,4.6612v1.8259h0.8751q0.503,0 0.7579,-0.2308 0.2584,-0.2343 0.2584,-0.6856 0,-0.4513 -0.2584,-0.6787 -0.2549,-0.2308 -0.7579,-0.2308z"
+        android:strokeAlpha="1"
+        android:strokeWidth="0.13229167"
+        android:fillColor="#000000"
+        android:strokeColor="#e6e6e6"
+        android:fillAlpha="0" />
+    <path
+        android:pathData="m14.3195,8.6472h1.1369v-3.924l-1.2368,0.2481v-0.6339l1.2299,-0.248h0.6959v4.5579h1.1369v0.5857h-2.9628z"
+        android:strokeAlpha="1"
+        android:strokeWidth="0.13229167"
+        android:fillColor="#000000"
+        android:strokeColor="#e6e6e6"
+        android:fillAlpha="0" />
+</vector>

android/app/src/main/res/drawable/ic_controller_r1_button_pressed.xml

@@ -0,0 +1,28 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="100dp"
+    android:height="50dp"
+    android:viewportWidth="26.458332"
+    android:viewportHeight="13.229165">
+    <path
+        android:pathData="M0.6615,0.6614L25.7969,0.6614v11.9063L0.6615,12.5677Z"
+        android:strokeAlpha="1"
+        android:strokeLineJoin="round"
+        android:strokeWidth="0.26458332"
+        android:fillColor="#4d4d4d"
+        android:strokeColor="#e6e6e6"
+        android:strokeLineCap="round" />
+    <path
+        android:pathData="m11.6703,6.8213q0.2239,0.0758 0.4341,0.3238 0.2136,0.248 0.4272,0.6821l0.7062,1.4056h-0.7476l-0.658,-1.3195q-0.2549,-0.5168 -0.4961,-0.6856 -0.2377,-0.1688 -0.6511,-0.1688L9.927,7.059v2.1739L9.2311,9.2329v-5.1435h1.571q0.8819,0 1.316,0.3686 0.4341,0.3686 0.4341,1.1128 0,0.4858 -0.2274,0.8062 -0.2239,0.3204 -0.6546,0.4444zM9.927,4.6612v1.8259h0.8751q0.503,0 0.7579,-0.2308 0.2584,-0.2343 0.2584,-0.6856 0,-0.4513 -0.2584,-0.6787 -0.2549,-0.2308 -0.7579,-0.2308z"
+        android:strokeAlpha="1"
+        android:strokeWidth="0.13229167"
+        android:fillColor="#1a1a1a"
+        android:strokeColor="#000000"
+        android:fillAlpha="1" />
+    <path
+        android:pathData="m14.3195,8.6472h1.1369v-3.924l-1.2368,0.2481v-0.6339l1.2299,-0.248h0.6959v4.5579h1.1369v0.5857h-2.9628z"
+        android:strokeAlpha="1"
+        android:strokeWidth="0.13229167"
+        android:fillColor="#1a1a1a"
+        android:strokeColor="#000000"
+        android:fillAlpha="1" />
+</vector>

android/app/src/main/res/drawable/ic_controller_r2_button.xml

@@ -0,0 +1,28 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="100dp"
+    android:height="50dp"
+    android:viewportWidth="26.458332"
+    android:viewportHeight="13.229165">
+    <path
+        android:pathData="M0.6615,0.6614L25.7969,0.6614v11.9063L0.6615,12.5677Z"
+        android:strokeAlpha="1"
+        android:strokeLineJoin="round"
+        android:strokeWidth="0.26458332"
+        android:fillColor="#00000000"
+        android:strokeColor="#e6e6e6"
+        android:strokeLineCap="round" />
+    <path
+        android:pathData="m11.6703,6.8213q0.2239,0.0758 0.4341,0.3238 0.2136,0.248 0.4272,0.6821l0.7062,1.4056h-0.7476l-0.658,-1.3195q-0.2549,-0.5168 -0.4961,-0.6856 -0.2377,-0.1688 -0.6511,-0.1688L9.927,7.059v2.1739L9.2311,9.2329v-5.1435h1.571q0.8819,0 1.316,0.3686 0.4341,0.3686 0.4341,1.1128 0,0.4858 -0.2274,0.8062 -0.2239,0.3204 -0.6546,0.4444zM9.927,4.6612v1.8259h0.8751q0.503,0 0.7579,-0.2308 0.2584,-0.2343 0.2584,-0.6856 0,-0.4513 -0.2584,-0.6787 -0.2549,-0.2308 -0.7579,-0.2308z"
+        android:strokeAlpha="1"
+        android:strokeWidth="0.13229167"
+        android:fillColor="#000000"
+        android:strokeColor="#e6e6e6"
+        android:fillAlpha="0" />
+    <path
+        android:pathData="m14.7984,8.6472h2.4288v0.5857h-3.2659v-0.5857q0.3962,-0.41 1.0783,-1.099 0.6856,-0.6925 0.8613,-0.8923 0.3342,-0.3755 0.4651,-0.6339 0.1344,-0.2618 0.1344,-0.5133 0,-0.41 -0.2894,-0.6683 -0.2859,-0.2584 -0.7476,-0.2584 -0.3273,0 -0.6925,0.1137 -0.3617,0.1137 -0.7751,0.3445v-0.7028q0.4203,-0.1688 0.7855,-0.2549 0.3652,-0.0861 0.6683,-0.0861 0.7993,0 1.2747,0.3996 0.4754,0.3996 0.4754,1.068 0,0.3169 -0.1206,0.6029 -0.1171,0.2825 -0.4306,0.6683 -0.0861,0.0999 -0.5478,0.5788 -0.4616,0.4754 -1.3022,1.3333z"
+        android:strokeAlpha="1"
+        android:strokeWidth="0.13229167"
+        android:fillColor="#000000"
+        android:strokeColor="#e6e6e6"
+        android:fillAlpha="0" />
+</vector>

android/app/src/main/res/drawable/ic_controller_r2_button_pressed.xml

@@ -0,0 +1,28 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="100dp"
+    android:height="50dp"
+    android:viewportWidth="26.458332"
+    android:viewportHeight="13.229165">
+    <path
+        android:pathData="M0.6615,0.6614L25.7969,0.6614v11.9063L0.6615,12.5677Z"
+        android:strokeAlpha="1"
+        android:strokeLineJoin="round"
+        android:strokeWidth="0.26458332"
+        android:fillColor="#4d4d4d"
+        android:strokeColor="#e6e6e6"
+        android:strokeLineCap="round" />
+    <path
+        android:pathData="m11.6703,6.8213q0.2239,0.0758 0.4341,0.3238 0.2136,0.248 0.4272,0.6821l0.7062,1.4056h-0.7476l-0.658,-1.3195q-0.2549,-0.5168 -0.4961,-0.6856 -0.2377,-0.1688 -0.6511,-0.1688L9.927,7.059v2.1739L9.2311,9.2329v-5.1435h1.571q0.8819,0 1.316,0.3686 0.4341,0.3686 0.4341,1.1128 0,0.4858 -0.2274,0.8062 -0.2239,0.3204 -0.6546,0.4444zM9.927,4.6612v1.8259h0.8751q0.503,0 0.7579,-0.2308 0.2584,-0.2343 0.2584,-0.6856 0,-0.4513 -0.2584,-0.6787 -0.2549,-0.2308 -0.7579,-0.2308z"
+        android:strokeAlpha="1"
+        android:strokeWidth="0.13229167"
+        android:fillColor="#1a1a1a"
+        android:strokeColor="#000000"
+        android:fillAlpha="1" />
+    <path
+        android:pathData="m14.7984,8.6472h2.4288v0.5857h-3.2659v-0.5857q0.3962,-0.41 1.0783,-1.099 0.6856,-0.6925 0.8613,-0.8923 0.3342,-0.3755 0.4651,-0.6339 0.1344,-0.2618 0.1344,-0.5133 0,-0.41 -0.2894,-0.6683 -0.2859,-0.2584 -0.7476,-0.2584 -0.3273,0 -0.6925,0.1137 -0.3617,0.1137 -0.7751,0.3445v-0.7028q0.4203,-0.1688 0.7855,-0.2549 0.3652,-0.0861 0.6683,-0.0861 0.7993,0 1.2747,0.3996 0.4754,0.3996 0.4754,1.068 0,0.3169 -0.1206,0.6029 -0.1171,0.2825 -0.4306,0.6683 -0.0861,0.0999 -0.5478,0.5788 -0.4616,0.4754 -1.3022,1.3333z"
+        android:strokeAlpha="1"
+        android:strokeWidth="0.13229167"
+        android:fillColor="#1a1a1a"
+        android:strokeColor="#000000"
+        android:fillAlpha="1" />
+</vector>

android/app/src/main/res/drawable/ic_controller_right_button.xml

@@ -0,0 +1,14 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="100dp"
+    android:height="100dp"
+    android:viewportWidth="26.458332"
+    android:viewportHeight="26.458332">
+    <path
+        android:pathData="m9.9219,21.8281 l-7.9375,-7.9375 7.9375,-7.9375L24.474,5.9531v15.875z"
+        android:strokeAlpha="1"
+        android:strokeLineJoin="miter"
+        android:strokeWidth="0.26458332"
+        android:fillColor="#00000000"
+        android:strokeColor="#e6e6e6"
+        android:strokeLineCap="butt" />
+</vector>

android/app/src/main/res/drawable/ic_controller_right_button_pressed.xml

@@ -0,0 +1,14 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="100dp"
+    android:height="100dp"
+    android:viewportWidth="26.458332"
+    android:viewportHeight="26.458332">
+    <path
+        android:pathData="m9.9219,21.8281 l-7.9375,-7.9375 7.9375,-7.9375L24.474,5.9531v15.875z"
+        android:strokeAlpha="1"
+        android:strokeLineJoin="miter"
+        android:strokeWidth="0.26458332"
+        android:fillColor="#4d4d4d"
+        android:strokeColor="#e6e6e6"
+        android:strokeLineCap="butt" />
+</vector>

android/app/src/main/res/drawable/ic_controller_select_button.xml

@@ -0,0 +1,14 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="100dp"
+    android:height="50dp"
+    android:viewportWidth="26.458332"
+    android:viewportHeight="13.229165">
+    <path
+        android:pathData="m0.6615,0.6614v11.9063L25.7969,12.5677v-11.9063z"
+        android:strokeAlpha="1"
+        android:strokeLineJoin="miter"
+        android:strokeWidth="0.26458332"
+        android:fillColor="#00000000"
+        android:strokeColor="#6e6e6f"
+        android:strokeLineCap="butt" />
+</vector>

android/app/src/main/res/drawable/ic_controller_select_button_pressed.xml

@@ -0,0 +1,14 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="100dp"
+    android:height="50dp"
+    android:viewportWidth="26.458332"
+    android:viewportHeight="13.229165">
+    <path
+        android:pathData="m0.6615,0.6614v11.9063L25.7969,12.5677v-11.9063z"
+        android:strokeAlpha="1"
+        android:strokeLineJoin="miter"
+        android:strokeWidth="0.26458332"
+        android:fillColor="#4d4d4d"
+        android:strokeColor="#6e6e6f"
+        android:strokeLineCap="butt" />
+</vector>

android/app/src/main/res/drawable/ic_controller_square_button.xml

@@ -0,0 +1,20 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="100dp"
+    android:height="100dp"
+    android:viewportWidth="26.458332"
+    android:viewportHeight="26.45833">
+    <path
+        android:pathData="M13.2292,13.2292m-12.5677,0a12.5677,12.5677 0,1 1,25.1354 0a12.5677,12.5677 0,1 1,-25.1354 0"
+        android:strokeWidth="0.26458332"
+        android:fillColor="#00000000"
+        android:strokeColor="#ffffff" />
+    <path
+        android:pathData="M5.2917,5.2917L21.1667,5.2917v15.875L5.2917,21.1667v-15.875"
+        android:strokeAlpha="1"
+        android:strokeLineJoin="miter"
+        android:strokeWidth="1.05833333"
+        android:fillColor="#00000000"
+        android:fillAlpha="1"
+        android:strokeColor="#ff00ff"
+        android:strokeLineCap="square" />
+</vector>

android/app/src/main/res/drawable/ic_controller_square_button_pressed.xml

@@ -0,0 +1,20 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="100dp"
+    android:height="100dp"
+    android:viewportWidth="26.458332"
+    android:viewportHeight="26.45833">
+    <path
+        android:pathData="M13.2292,13.2292m-12.5677,0a12.5677,12.5677 0,1 1,25.1354 0a12.5677,12.5677 0,1 1,-25.1354 0"
+        android:strokeWidth="0.26458332"
+        android:fillColor="#4d4d4d"
+        android:strokeColor="#ffffff" />
+    <path
+        android:pathData="M5.2917,5.2917L21.1667,5.2917v15.875L5.2917,21.1667v-15.875"
+        android:strokeAlpha="1"
+        android:strokeLineJoin="miter"
+        android:strokeWidth="1.05833333"
+        android:fillColor="#00000000"
+        android:fillAlpha="1"
+        android:strokeColor="#ff00ff"
+        android:strokeLineCap="square" />
+</vector>

android/app/src/main/res/drawable/ic_controller_start_button.xml

@@ -0,0 +1,14 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="100dp"
+    android:height="50dp"
+    android:viewportWidth="26.458332"
+    android:viewportHeight="13.229165">
+    <path
+        android:pathData="m0.6615,0.6614v11.9063l25.1354,-5.9531z"
+        android:strokeAlpha="0.94117647"
+        android:strokeLineJoin="miter"
+        android:strokeWidth="0.265"
+        android:fillColor="#00000000"
+        android:strokeColor="#6e6e6f"
+        android:strokeLineCap="butt" />
+</vector>

android/app/src/main/res/drawable/ic_controller_start_button_pressed.xml

@@ -0,0 +1,14 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="100dp"
+    android:height="50dp"
+    android:viewportWidth="26.458332"
+    android:viewportHeight="13.229165">
+    <path
+        android:pathData="m0.6615,0.6614v11.9063l25.1354,-5.9531z"
+        android:strokeAlpha="0.94117647"
+        android:strokeLineJoin="miter"
+        android:strokeWidth="0.265"
+        android:fillColor="#4d4d4d"
+        android:strokeColor="#6e6e6f"
+        android:strokeLineCap="butt" />
+</vector>

android/app/src/main/res/drawable/ic_controller_triangle_button.xml

@@ -0,0 +1,19 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="100dp"
+    android:height="100dp"
+    android:viewportWidth="26.458332"
+    android:viewportHeight="26.45833">
+    <path
+        android:pathData="M13.2292,13.2292m-12.5677,0a12.5677,12.5677 0,1 1,25.1354 0a12.5677,12.5677 0,1 1,-25.1354 0"
+        android:strokeWidth="0.26458332"
+        android:fillColor="#00000000"
+        android:strokeColor="#ffffff" />
+    <path
+        android:pathData="M5.2917,19.0398L21.1667,19.0398l-7.9375,-13.7481 -7.8548,13.6049"
+        android:strokeAlpha="1"
+        android:strokeLineJoin="round"
+        android:strokeWidth="1.05833328"
+        android:fillColor="#00000000"
+        android:strokeColor="#00ff00"
+        android:strokeLineCap="round" />
+</vector>

android/app/src/main/res/drawable/ic_controller_triangle_button_pressed.xml

@@ -0,0 +1,19 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="100dp"
+    android:height="100dp"
+    android:viewportWidth="26.458332"
+    android:viewportHeight="26.45833">
+    <path
+        android:pathData="M13.2292,13.2292m-12.5677,0a12.5677,12.5677 0,1 1,25.1354 0a12.5677,12.5677 0,1 1,-25.1354 0"
+        android:strokeWidth="0.26458332"
+        android:fillColor="#4d4d4d"
+        android:strokeColor="#ffffff" />
+    <path
+        android:pathData="M5.2917,19.0398L21.1667,19.0398l-7.9375,-13.7481 -7.8548,13.6049"
+        android:strokeAlpha="1"
+        android:strokeLineJoin="round"
+        android:strokeWidth="1.05833328"
+        android:fillColor="#00000000"
+        android:strokeColor="#00ff00"
+        android:strokeLineCap="round" />
+</vector>

android/app/src/main/res/drawable/ic_controller_up_button.xml

@@ -0,0 +1,14 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="100dp"
+    android:height="100dp"
+    android:viewportWidth="26.458332"
+    android:viewportHeight="26.458332">
+    <path
+        android:pathData="m21.1667,17.1979 l-7.9375,7.9375 -7.9375,-7.9375L5.2917,2.6458L21.1667,2.6458Z"
+        android:strokeAlpha="1"
+        android:strokeLineJoin="miter"
+        android:strokeWidth="0.26458332"
+        android:fillColor="#00000000"
+        android:strokeColor="#e6e6e6"
+        android:strokeLineCap="butt" />
+</vector>

android/app/src/main/res/drawable/ic_controller_up_button_pressed.xml

@@ -0,0 +1,14 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="100dp"
+    android:height="100dp"
+    android:viewportWidth="26.458332"
+    android:viewportHeight="26.458332">
+    <path
+        android:pathData="m21.1667,17.1979 l-7.9375,7.9375 -7.9375,-7.9375L5.2917,2.6458L21.1667,2.6458Z"
+        android:strokeAlpha="1"
+        android:strokeLineJoin="miter"
+        android:strokeWidth="0.26458332"
+        android:fillColor="#4d4d4d"
+        android:strokeColor="#e6e6e6"
+        android:strokeLineCap="butt" />
+</vector>

android/app/src/main/res/drawable/ic_emblem_system.xml

@@ -0,0 +1,45 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:aapt="http://schemas.android.com/aapt"
+    android:width="48dp"
+    android:height="48dp"
+    android:viewportWidth="48"
+    android:viewportHeight="48">
+    <path
+        android:pathData="M44.1942,41.636A19.6222,6.1872 0,1 1,4.9497 41.636A19.6222,6.1872 0,1 1,44.1942 41.636z"
+        android:strokeAlpha="0.40909088"
+        android:strokeLineJoin="miter"
+        android:strokeWidth="1"
+        android:strokeColor="#00000000"
+        android:fillType="nonZero"
+        android:fillAlpha="0.40909088"
+        android:strokeLineCap="butt"></path>
+    <path
+        android:pathData="M23.25,0.4688C22.7846,0.5006 22.3322,0.5727 21.875,0.625L21.8438,0.625L20.75,6.5938C18.9673,6.9997 17.2901,7.6887 15.7813,8.625L10.875,5.0938C9.5487,6.1234 8.3418,7.3243 7.2813,8.625L10.6875,13.5938C9.6533,15.1743 8.8755,16.979 8.4375,18.875C8.4374,18.884 8.4374,18.9047 8.4375,18.9063L2.5,19.8438C2.3914,20.7304 2.3438,21.6467 2.3438,22.5625C2.3438,23.3118 2.3644,24.0511 2.4375,24.7813L8.375,25.8438C8.7973,27.9056 9.5995,29.8313 10.7188,31.5313L7.1875,36.375C8.1988,37.6305 9.3664,38.7736 10.625,39.7813L15.625,36.3438C17.3724,37.4585 19.3231,38.2401 21.4375,38.625L22.375,44.5313C23.0412,44.5919 23.7243,44.5938 24.4063,44.5938C25.3689,44.5938 26.2885,44.5573 27.2188,44.4375L28.3438,38.4063C30.3513,37.9067 32.2372,37.04 33.875,35.875L38.6875,39.375C39.9355,38.3132 41.0768,37.0927 42.0625,35.7813L38.5625,30.7188C39.5104,29.0818 40.1671,27.2756 40.5,25.3438L46.4063,24.4063C46.458,23.7899 46.4688,23.1922 46.4688,22.5625C46.4688,21.4683 46.3416,20.3954 46.1875,19.3438L40.1875,18.25C39.7173,16.5138 38.9458,14.8939 37.9688,13.4375L41.5,8.5938C40.4054,7.2551 39.1568,6.0186 37.7813,4.9688L32.6875,8.4688C31.2235,7.6029 29.648,6.9386 27.9375,6.5625L27,0.625C26.1467,0.5246 25.2864,0.4688 24.4063,0.4688C24.1684,0.4688 23.9236,0.4613 23.6875,0.4688C23.5724,0.4724 23.4585,0.4621 23.3438,0.4688C23.3127,0.4706 23.281,0.4666 23.25,0.4688zM24.0625,15.6563C24.1767,15.6505 24.2907,15.6563 24.4063,15.6563C28.1054,15.6563 31.125,18.6759 31.125,22.375C31.125,26.0741 28.1054,29.0625 24.4063,29.0625C20.7071,29.0625 17.7188,26.0741 17.7188,22.375C17.7188,18.7915 20.5233,15.8358 24.0625,15.6563z"
+        android:strokeAlpha="1"
+        android:strokeLineJoin="miter"
+        android:strokeWidth="1"
+        android:strokeColor="#808080"
+        android:fillType="nonZero"
+        android:fillAlpha="1"
+        android:strokeLineCap="butt"></path>
+    <path
+        android:pathData="M32.13,22.3608A7.7197,7.7197 45,1 1,16.6905 22.3608A7.7197,7.7197 135,1 1,32.13 22.3608z"
+        android:strokeAlpha="0.64772725"
+        android:strokeLineJoin="miter"
+        android:strokeWidth="1.64875567"
+        android:fillColor="#00000000"
+        android:strokeColor="#ffffff"
+        android:fillType="nonZero"
+        android:fillAlpha="0.64772725"
+        android:strokeLineCap="butt" />
+    <path
+        android:pathData="M22.5578,1.6501L21.6796,7.4291C20.0086,7.8097 16.9349,8.9735 15.5206,9.8511L10.8486,6.3639C9.6054,7.3291 9.5201,7.3945 8.5261,8.6137L11.9041,13.6236C10.9347,15.1051 9.7703,17.7451 9.3522,19.6317C9.3522,19.6317 3.4328,20.6296 3.4328,20.6296C3.3311,21.4606 3.38,23.2394 3.4485,23.9238L9.1027,24.9423C9.4985,26.875 10.9797,29.9859 12.0289,31.5794L8.4533,36.3034C9.4012,37.4803 9.591,37.5879 10.7707,38.5324L15.5519,35.0296C17.1898,36.0745 20.4409,37.3455 22.4228,37.7063L23.2075,43.4125C23.8319,43.4693 25.557,43.6288 26.4289,43.5165L27.3071,37.5764C29.1889,37.1081 32.4403,35.7734 33.9754,34.6815L38.7515,38.1323C39.9213,37.137 39.9318,36.9871 40.8557,35.7578L37.3165,30.7271C38.205,29.1927 39.3537,26.1918 39.6657,24.381L45.4604,23.4196C45.5089,22.8419 45.5113,21.2308 45.3669,20.245L39.4631,19.2264C39.0224,17.599 37.5099,14.6665 36.5941,13.3013L40.3464,8.5773C39.3204,7.3226 38.939,7.1504 37.6496,6.1664L32.7073,9.7056C31.335,8.894 28.5987,7.6569 26.9953,7.3044L26.1223,1.6501C25.3224,1.556 23.0149,1.5978 22.5578,1.6501z"
+        android:strokeAlpha="0.34659088"
+        android:strokeLineJoin="miter"
+        android:strokeWidth="0.9999997"
+        android:fillColor="#00000000"
+        android:strokeColor="#ffffff"
+        android:fillType="nonZero"
+        android:fillAlpha="0.34659088"
+        android:strokeLineCap="butt" />
+</vector>

android/app/src/main/res/drawable/ic_launcher_background.xml

@@ -0,0 +1,170 @@
+<?xml version="1.0" encoding="utf-8"?>
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="108dp"
+    android:height="108dp"
+    android:viewportWidth="108"
+    android:viewportHeight="108">
+    <path
+        android:fillColor="#008577"
+        android:pathData="M0,0h108v108h-108z" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M9,0L9,108"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M19,0L19,108"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M29,0L29,108"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M39,0L39,108"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M49,0L49,108"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M59,0L59,108"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M69,0L69,108"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M79,0L79,108"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M89,0L89,108"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M99,0L99,108"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M0,9L108,9"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M0,19L108,19"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M0,29L108,29"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M0,39L108,39"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M0,49L108,49"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M0,59L108,59"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M0,69L108,69"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M0,79L108,79"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M0,89L108,89"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M0,99L108,99"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M19,29L89,29"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M19,39L89,39"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M19,49L89,49"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M19,59L89,59"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M19,69L89,69"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M19,79L89,79"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M29,19L29,89"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M39,19L39,89"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M49,19L49,89"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M59,19L59,89"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M69,19L69,89"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M79,19L79,89"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+</vector>

android/app/src/main/res/drawable/ic_media_cdrom.xml

@@ -0,0 +1,97 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:aapt="http://schemas.android.com/aapt"
+    android:width="48dp"
+    android:height="48dp"
+    android:viewportWidth="48"
+    android:viewportHeight="48">
+    <path
+        android:pathData="M46.9619,41.511A6.0319,22.6274 90,1 1,1.7071 41.511A6.0319,22.6274 90,1 1,46.9619 41.511z"
+        android:strokeAlpha="0.55"
+        android:strokeLineJoin="miter"
+        android:strokeWidth="2"
+        android:strokeColor="#00000000"
+        android:fillType="evenOdd"
+        android:fillAlpha="0.55"
+        android:strokeLineCap="butt"></path>
+    <path
+        android:pathData="M24.347,4.1667C12.7994,4.1667 3.5137,13.4524 3.5137,25C3.5137,36.5476 12.7994,45.8333 24.347,45.8333C35.8946,45.8333 45.1803,36.5476 45.1803,25C45.1803,13.4524 35.8946,4.1667 24.347,4.1667L24.347,4.1667zM24.347,30C21.6089,30 19.347,27.7381 19.347,25C19.347,22.2619 21.6089,20 24.347,20C27.0851,20 29.347,22.2619 29.347,25C29.347,27.7381 27.0851,30 24.347,30z"
+        android:strokeColor="#00000000"
+        android:fillType="nonZero"></path>
+    <path
+        android:strokeWidth="1"
+        android:pathData="M24.347,4.1667C12.7994,4.1667 3.5137,13.4524 3.5137,25C3.5137,36.5476 12.7994,45.8333 24.347,45.8333C35.8946,45.8333 45.1803,36.5476 45.1803,25C45.1803,13.4524 35.8946,4.1667 24.347,4.1667L24.347,4.1667zM24.347,30C21.6089,30 19.347,27.7381 19.347,25C19.347,22.2619 21.6089,20 24.347,20C27.0851,20 29.347,22.2619 29.347,25C29.347,27.7381 27.0851,30 24.347,30z"
+        android:strokeAlpha="1"
+        android:strokeColor="#808080"
+        android:fillType="nonZero"></path>
+    <path
+        android:fillColor="#FF000000"
+        android:pathData="M24.347,14.8958C18.7044,14.8958 14.2428,19.4886 14.2428,25C14.2428,30.6426 18.8356,35.1042 24.347,35.1042C29.9896,35.1042 34.4512,30.5114 34.4512,25C34.4512,19.3574 29.8584,14.8958 24.347,14.8958L24.347,14.8958zM24.347,30.5114C21.3289,30.5114 18.8356,28.0181 18.8356,25C18.8356,21.9819 21.3289,19.4886 24.347,19.4886C27.3651,19.4886 29.8584,21.9819 29.8584,25C29.8584,28.0181 27.3651,30.5114 24.347,30.5114z"
+        android:strokeAlpha="0.10999995"
+        android:strokeColor="#00000000"
+        android:fillType="nonZero"
+        android:fillAlpha="0.10999995" />
+    <path
+        android:pathData="M29.9221,5.6692L26.3255,19.6639C27.4502,19.9634 28.3497,20.6594 28.9606,21.6224L41.3529,14.0732C38.8176,9.9434 34.7487,6.9051 29.9221,5.6692z"
+        android:strokeAlpha="1"
+        android:strokeColor="#00000000"
+        android:fillType="nonZero"
+        android:fillAlpha="1"></path>
+    <path
+        android:pathData="M17.3078,43.7661L22.0431,30.1146C20.9468,29.7236 20.1077,28.956 19.5779,27.946L6.6069,34.4506C8.7939,38.7748 12.5993,42.1375 17.3078,43.7661z"
+        android:strokeAlpha="1"
+        android:strokeColor="#00000000"
+        android:fillType="nonZero"
+        android:fillAlpha="1"></path>
+    <path
+        android:strokeWidth="1"
+        android:pathData="M24.347,5.2024C13.3735,5.2024 4.5494,14.0265 4.5494,25C4.5494,35.9735 13.3735,44.7976 24.347,44.7976C35.3205,44.7976 44.1446,35.9735 44.1446,25C44.1446,14.0265 35.3205,5.2024 24.347,5.2024L24.347,5.2024z"
+        android:strokeAlpha="0.5464481"
+        android:fillColor="#00000000"
+        android:fillType="nonZero"
+        android:fillAlpha="0.5464481"></path>
+    <path
+        android:pathData="M30.494,25.019A6.0988,6.0988 0,1 1,18.2964 25.019A6.0988,6.0988 0,1 1,30.494 25.019z"
+        android:strokeAlpha="0.6721311"
+        android:strokeLineJoin="miter"
+        android:strokeWidth="0.93053865"
+        android:fillColor="#00000000"
+        android:fillType="nonZero"
+        android:fillAlpha="0.21265164"
+        android:strokeLineCap="butt"></path>
+    <path
+        android:pathData="M24.347,4.1667C12.7994,4.1667 3.5137,13.4524 3.5137,25C3.5137,36.5476 12.7994,45.8333 24.347,45.8333C35.8946,45.8333 45.1803,36.5476 45.1803,25C45.1803,13.4524 35.8946,4.1667 24.347,4.1667L24.347,4.1667zM24.347,30C21.6089,30 19.347,27.7381 19.347,25C19.347,22.2619 21.6089,20 24.347,20C27.0851,20 29.347,22.2619 29.347,25C29.347,27.7381 27.0851,30 24.347,30z"
+        android:strokeAlpha="0.1142857"
+        android:strokeColor="#00000000"
+        android:fillType="nonZero"
+        android:fillAlpha="0.1142857"></path>
+    <path
+        android:pathData="M24.347,4.1667C12.7994,4.1667 3.5137,13.4524 3.5137,25C3.5137,36.5476 12.7994,45.8333 24.347,45.8333C35.8946,45.8333 45.1803,36.5476 45.1803,25C45.1803,13.4524 35.8946,4.1667 24.347,4.1667L24.347,4.1667zM24.347,30C21.6089,30 19.347,27.7381 19.347,25C19.347,22.2619 21.6089,20 24.347,20C27.0851,20 29.347,22.2619 29.347,25C29.347,27.7381 27.0851,30 24.347,30z"
+        android:strokeAlpha="0.09714284"
+        android:strokeColor="#00000000"
+        android:fillType="nonZero"
+        android:fillAlpha="0.09714284"></path>
+    <path
+        android:pathData="M24.347,4.1667C12.7994,4.1667 3.5137,13.4524 3.5137,25C3.5137,36.5476 12.7994,45.8333 24.347,45.8333C35.8946,45.8333 45.1803,36.5476 45.1803,25C45.1803,13.4524 35.8946,4.1667 24.347,4.1667L24.347,4.1667zM24.347,30C21.6089,30 19.347,27.7381 19.347,25C19.347,22.2619 21.6089,20 24.347,20C27.0851,20 29.347,22.2619 29.347,25C29.347,27.7381 27.0851,30 24.347,30z"
+        android:strokeAlpha="0.71428573"
+        android:strokeColor="#00000000"
+        android:fillType="nonZero"
+        android:fillAlpha="0.71428573"></path>
+    <path
+        android:pathData="M24.347,4.1667C12.7994,4.1667 3.5137,13.4524 3.5137,25C3.5137,36.5476 12.7994,45.8333 24.347,45.8333C35.8946,45.8333 45.1803,36.5476 45.1803,25C45.1803,13.4524 35.8946,4.1667 24.347,4.1667L24.347,4.1667zM24.347,30C21.6089,30 19.347,27.7381 19.347,25C19.347,22.2619 21.6089,20 24.347,20C27.0851,20 29.347,22.2619 29.347,25C29.347,27.7381 27.0851,30 24.347,30z"
+        android:strokeAlpha="0.62285715"
+        android:strokeColor="#00000000"
+        android:fillType="nonZero"
+        android:fillAlpha="0.62285715"></path>
+    <path
+        android:pathData="M24.347,4.1667C12.7994,4.1667 3.5137,13.4524 3.5137,25C3.5137,36.5476 12.7994,45.8333 24.347,45.8333C35.8946,45.8333 45.1803,36.5476 45.1803,25C45.1803,13.4524 35.8946,4.1667 24.347,4.1667L24.347,4.1667zM24.347,30C21.6089,30 19.347,27.7381 19.347,25C19.347,22.2619 21.6089,20 24.347,20C27.0851,20 29.347,22.2619 29.347,25C29.347,27.7381 27.0851,30 24.347,30z"
+        android:strokeAlpha="0.3714286"
+        android:strokeColor="#00000000"
+        android:fillType="nonZero"
+        android:fillAlpha="0.3714286"></path>
+    <path
+        android:pathData="M24.347,4.1667C12.7994,4.1667 3.5137,13.4524 3.5137,25C3.5137,36.5476 12.7994,45.8333 24.347,45.8333C35.8946,45.8333 45.1803,36.5476 45.1803,25C45.1803,13.4524 35.8946,4.1667 24.347,4.1667L24.347,4.1667zM24.347,30C21.6089,30 19.347,27.7381 19.347,25C19.347,22.2619 21.6089,20 24.347,20C27.0851,20 29.347,22.2619 29.347,25C29.347,27.7381 27.0851,30 24.347,30z"
+        android:strokeAlpha="0.23428573"
+        android:strokeColor="#00000000"
+        android:fillType="nonZero"
+        android:fillAlpha="0.23428573"></path>
+</vector>

android/app/src/main/res/layout/activity_emulation.xml

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="utf-8"?>
+<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:id="@+id/frameLayout"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:background="#0099cc"
+    tools:context=".EmulationActivity">
+
+    <!-- The primary full-screen view. This can be replaced with whatever view
+         is needed to present your content, e.g. VideoView, SurfaceView,
+         TextureView, etc. -->
+    <com.github.stenzek.duckstation.EmulationSurfaceView
+        android:id="@+id/fullscreen_content"
+        android:layout_width="match_parent"
+        android:layout_height="match_parent"
+        android:gravity="center"
+        android:keepScreenOn="true" />
+
+</FrameLayout>

android/app/src/main/res/layout/activity_main.xml

@@ -0,0 +1,57 @@
+<?xml version="1.0" encoding="utf-8"?>
+<androidx.coordinatorlayout.widget.CoordinatorLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    tools:context=".MainActivity">
+
+    <com.google.android.material.appbar.AppBarLayout
+        android:layout_height="wrap_content"
+        android:layout_width="match_parent"
+        android:theme="@style/AppTheme.AppBarOverlay">
+
+        <LinearLayout
+            android:layout_width="match_parent"
+            android:layout_height="match_parent"
+            android:orientation="horizontal">
+
+            <ImageView
+                android:id="@+id/imageView2"
+                android:layout_width="64dp"
+                android:layout_height="match_parent"
+                app:srcCompat="@mipmap/ic_launcher_foreground" />
+
+            <androidx.appcompat.widget.Toolbar
+                android:id="@+id/toolbar"
+                android:layout_width="match_parent"
+                android:layout_height="?attr/actionBarSize"
+                android:background="?attr/colorPrimary"
+                app:popupTheme="@style/AppTheme.PopupOverlay" />
+
+        </LinearLayout>
+
+    </com.google.android.material.appbar.AppBarLayout>
+
+    <include layout="@layout/content_main" />
+
+    <com.google.android.material.floatingactionbutton.FloatingActionButton
+        android:id="@+id/fab_resume"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:layout_gravity="bottom|end"
+        android:layout_marginBottom="@dimen/fab_margin"
+        android:layout_marginRight="96dp"
+        app:backgroundTint="@android:color/background_light"
+        app:srcCompat="@drawable/ic_baseline_play_arrow_24" />
+
+    <com.google.android.material.floatingactionbutton.FloatingActionButton
+        android:id="@+id/fab_add_game_directory"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:layout_gravity="bottom|end"
+        android:layout_margin="@dimen/fab_margin"
+        app:backgroundTint="@android:color/background_light"
+        app:srcCompat="@android:drawable/ic_input_add" />
+
+</androidx.coordinatorlayout.widget.CoordinatorLayout>

android/app/src/main/res/layout/content_main.xml

@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?>
+<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    app:layout_behavior="@string/appbar_scrolling_view_behavior"
+    tools:context=".MainActivity"
+    tools:showIn="@layout/activity_main">
+
+    <ListView
+        android:id="@+id/game_list_view"
+        android:layout_width="match_parent"
+        android:layout_height="match_parent"
+        app:layout_constraintBottom_toBottomOf="parent"
+        app:layout_constraintLeft_toLeftOf="parent"
+        app:layout_constraintRight_toRightOf="parent"
+        app:layout_constraintTop_toTopOf="parent" />
+</androidx.constraintlayout.widget.ConstraintLayout>

android/app/src/main/res/layout/fragment_settings_collection.xml

@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:orientation="vertical">
+
+    <com.google.android.material.tabs.TabLayout
+        android:id="@+id/tab_layout"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        app:tabTextAppearance="@style/TabTextAppearance"
+        app:tabMinWidth="150dp"
+        app:tabMode="scrollable" />
+
+    <androidx.viewpager2.widget.ViewPager2
+        android:id="@+id/view_pager"
+        android:layout_width="match_parent"
+        android:layout_height="0dp"
+        android:layout_weight="1" />
+
+</LinearLayout>

android/app/src/main/res/layout/game_list_view_entry.xml

@@ -0,0 +1,76 @@
+<?xml version="1.0" encoding="utf-8"?>
+<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:id="@+id/linearLayout"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent">
+
+    <ImageView
+        android:id="@+id/game_list_view_entry_type_icon"
+        android:layout_width="48dp"
+        android:layout_height="48dp"
+        android:layout_marginStart="8dp"
+        android:layout_marginTop="8dp"
+        app:layout_constraintStart_toStartOf="parent"
+        app:layout_constraintTop_toTopOf="parent"
+        tools:srcCompat="@drawable/ic_media_cdrom" />
+
+    <TextView
+        android:id="@+id/game_list_view_entry_title"
+        android:layout_width="0dp"
+        android:layout_height="wrap_content"
+        android:layout_marginLeft="10dp"
+        android:layout_marginTop="8dp"
+        android:layout_marginRight="64dp"
+        android:focusable="false"
+        android:focusableInTouchMode="false"
+        android:text="Game Title"
+        android:textAppearance="@style/TextAppearance.AppCompat.Large"
+        app:layout_constraintEnd_toEndOf="parent"
+        app:layout_constraintStart_toEndOf="@+id/game_list_view_entry_type_icon"
+        app:layout_constraintTop_toTopOf="parent" />
+
+    <TextView
+        android:id="@+id/game_list_view_entry_path"
+        android:layout_width="0dp"
+        android:layout_height="wrap_content"
+        android:layout_marginLeft="10dp"
+        android:layout_marginRight="64dp"
+        android:focusable="false"
+        android:focusableInTouchMode="false"
+        android:paddingBottom="8px"
+        android:text="Game Path"
+        android:textAppearance="@style/TextAppearance.AppCompat.Small"
+        app:layout_constraintEnd_toEndOf="parent"
+        app:layout_constraintStart_toEndOf="@+id/game_list_view_entry_type_icon"
+        app:layout_constraintTop_toBottomOf="@+id/game_list_view_entry_title" />
+
+    <TextView
+        android:id="@+id/game_list_view_entry_size"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:layout_marginTop="8dp"
+        android:layout_marginEnd="8dp"
+        android:focusable="false"
+        android:focusableInTouchMode="false"
+        android:text="123.4 MB"
+        android:textAppearance="@style/TextAppearance.AppCompat.Small"
+        android:textSize="12sp"
+        app:layout_constraintEnd_toEndOf="parent"
+        app:layout_constraintTop_toTopOf="parent" />
+
+    <ImageView
+        android:id="@+id/game_list_view_entry_region_icon"
+        android:layout_width="32dp"
+        android:layout_height="28dp"
+        android:layout_marginTop="8px"
+        android:layout_marginEnd="8dp"
+        android:focusable="false"
+        android:focusableInTouchMode="false"
+        android:paddingBottom="8px"
+        app:layout_constraintEnd_toEndOf="parent"
+        app:layout_constraintTop_toBottomOf="@+id/game_list_view_entry_size"
+        app:srcCompat="@drawable/flag_jp" />
+
+</androidx.constraintlayout.widget.ConstraintLayout>

android/app/src/main/res/layout/layout_touchscreen_controller_analog_stick.xml

@@ -0,0 +1,136 @@
+<?xml version="1.0" encoding="utf-8"?>
+<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:id="@+id/constraintLayout"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:orientation="vertical">
+
+    <com.github.stenzek.duckstation.TouchscreenControllerButtonView
+        android:id="@+id/controller_button_r2"
+        android:layout_width="70dp"
+        android:layout_height="35dp"
+        android:layout_marginEnd="60dp"
+        android:layout_marginBottom="280dp"
+        app:layout_constraintBottom_toBottomOf="parent"
+        app:layout_constraintEnd_toEndOf="parent"
+        app:pressedDrawable="@drawable/ic_controller_r2_button_pressed"
+        app:unpressedDrawable="@drawable/ic_controller_r2_button" />
+
+    <com.github.stenzek.duckstation.TouchscreenControllerButtonView
+        android:id="@+id/controller_button_r1"
+        android:layout_width="70dp"
+        android:layout_height="35dp"
+        android:layout_marginEnd="60dp"
+        android:layout_marginBottom="220dp"
+        app:layout_constraintBottom_toBottomOf="parent"
+        app:layout_constraintEnd_toEndOf="parent"
+        app:pressedDrawable="@drawable/ic_controller_r1_button_pressed"
+        app:unpressedDrawable="@drawable/ic_controller_r1_button" />
+
+    <com.github.stenzek.duckstation.TouchscreenControllerButtonView
+        android:id="@+id/controller_button_l1"
+        android:layout_width="70dp"
+        android:layout_height="35dp"
+        android:layout_marginStart="60dp"
+        android:layout_marginBottom="220dp"
+        app:layout_constraintBottom_toBottomOf="parent"
+        app:layout_constraintStart_toStartOf="parent"
+        app:pressedDrawable="@drawable/ic_controller_l1_button_pressed"
+        app:unpressedDrawable="@drawable/ic_controller_l1_button" />
+
+    <com.github.stenzek.duckstation.TouchscreenControllerButtonView
+        android:id="@+id/controller_button_l2"
+        android:layout_width="70dp"
+        android:layout_height="35dp"
+        android:layout_marginStart="60dp"
+        android:layout_marginBottom="280dp"
+        app:layout_constraintBottom_toBottomOf="parent"
+        app:layout_constraintStart_toStartOf="parent"
+        app:pressedDrawable="@drawable/ic_controller_l2_button_pressed"
+        app:unpressedDrawable="@drawable/ic_controller_l2_button" />
+
+    <com.github.stenzek.duckstation.TouchscreenControllerButtonView
+        android:id="@+id/controller_button_start"
+        android:layout_width="40dp"
+        android:layout_height="25dp"
+        android:layout_marginStart="80dp"
+        android:layout_marginBottom="8dp"
+        app:layout_constraintBottom_toBottomOf="parent"
+        app:layout_constraintEnd_toEndOf="parent"
+        app:layout_constraintHorizontal_bias="0.5"
+        app:layout_constraintStart_toStartOf="parent"
+        app:pressedDrawable="@drawable/ic_controller_start_button_pressed"
+        app:unpressedDrawable="@drawable/ic_controller_start_button" />
+
+    <com.github.stenzek.duckstation.TouchscreenControllerButtonView
+        android:id="@+id/controller_button_select"
+        android:layout_width="40dp"
+        android:layout_height="25dp"
+        android:layout_marginEnd="50dp"
+        android:layout_marginBottom="8dp"
+        app:layout_constraintBottom_toBottomOf="parent"
+        app:layout_constraintEnd_toEndOf="parent"
+        app:layout_constraintHorizontal_bias="0.5"
+        app:layout_constraintStart_toStartOf="parent"
+        app:pressedDrawable="@drawable/ic_controller_select_button_pressed"
+        app:unpressedDrawable="@drawable/ic_controller_select_button" />
+
+    <com.github.stenzek.duckstation.TouchscreenControllerButtonView
+        android:id="@+id/controller_button_cross"
+        android:layout_width="50dp"
+        android:layout_height="50dp"
+        android:layout_marginEnd="70dp"
+        android:layout_marginBottom="30dp"
+        app:layout_constraintBottom_toBottomOf="parent"
+        app:layout_constraintEnd_toEndOf="parent"
+        app:pressedDrawable="@drawable/ic_controller_cross_button_pressed"
+        app:unpressedDrawable="@drawable/ic_controller_cross_button" />
+
+    <com.github.stenzek.duckstation.TouchscreenControllerButtonView
+        android:id="@+id/controller_button_square"
+        android:layout_width="50dp"
+        android:layout_height="50dp"
+        android:layout_marginEnd="120dp"
+        android:layout_marginBottom="80dp"
+        app:layout_constraintBottom_toBottomOf="parent"
+        app:layout_constraintEnd_toEndOf="parent"
+        app:pressedDrawable="@drawable/ic_controller_square_button_pressed"
+        app:unpressedDrawable="@drawable/ic_controller_square_button" />
+
+    <com.github.stenzek.duckstation.TouchscreenControllerButtonView
+        android:id="@+id/controller_button_triangle"
+        android:layout_width="50dp"
+        android:layout_height="50dp"
+        android:layout_marginEnd="70dp"
+        android:layout_marginBottom="130dp"
+        app:layout_constraintBottom_toBottomOf="parent"
+        app:layout_constraintEnd_toEndOf="parent"
+        app:pressedDrawable="@drawable/ic_controller_triangle_button_pressed"
+        app:unpressedDrawable="@drawable/ic_controller_triangle_button" />
+
+    <com.github.stenzek.duckstation.TouchscreenControllerButtonView
+        android:id="@+id/controller_button_circle"
+        android:layout_width="50dp"
+        android:layout_height="50dp"
+        android:layout_marginEnd="20dp"
+        android:layout_marginBottom="80dp"
+        app:layout_constraintBottom_toBottomOf="parent"
+        app:layout_constraintEnd_toEndOf="parent"
+        app:pressedDrawable="@drawable/ic_controller_circle_button_pressed"
+        app:unpressedDrawable="@drawable/ic_controller_circle_button" />
+
+    <com.github.stenzek.duckstation.TouchscreenControllerAxisView
+        android:id="@+id/controller_axis_left"
+        android:layout_width="150dp"
+        android:layout_height="150dp"
+        android:layout_marginStart="20dp"
+        android:layout_marginBottom="30dp"
+        android:paddingTop="20dp"
+        android:paddingBottom="20dp"
+        android:paddingLeft="20dp"
+        android:paddingRight="20dp"
+        app:layout_constraintBottom_toBottomOf="parent"
+        app:layout_constraintStart_toStartOf="parent" />
+</androidx.constraintlayout.widget.ConstraintLayout>

android/app/src/main/res/layout/layout_touchscreen_controller_analog_sticks.xml

@@ -0,0 +1,201 @@
+<?xml version="1.0" encoding="utf-8"?>
+<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:id="@+id/constraintLayout"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:orientation="vertical">
+
+    <com.github.stenzek.duckstation.TouchscreenControllerButtonView
+        android:id="@+id/controller_button_r2"
+        android:layout_width="70dp"
+        android:layout_height="35dp"
+        android:layout_marginEnd="60dp"
+        android:layout_marginBottom="260dp"
+        app:layout_constraintBottom_toBottomOf="parent"
+        app:layout_constraintEnd_toEndOf="parent"
+        app:pressedDrawable="@drawable/ic_controller_r2_button_pressed"
+        app:unpressedDrawable="@drawable/ic_controller_r2_button" />
+
+    <com.github.stenzek.duckstation.TouchscreenControllerButtonView
+        android:id="@+id/controller_button_r1"
+        android:layout_width="70dp"
+        android:layout_height="35dp"
+        android:layout_marginEnd="60dp"
+        android:layout_marginBottom="200dp"
+        app:layout_constraintBottom_toBottomOf="parent"
+        app:layout_constraintEnd_toEndOf="parent"
+        app:pressedDrawable="@drawable/ic_controller_r1_button_pressed"
+        app:unpressedDrawable="@drawable/ic_controller_r1_button" />
+
+    <com.github.stenzek.duckstation.TouchscreenControllerButtonView
+        android:id="@+id/controller_button_l1"
+        android:layout_width="70dp"
+        android:layout_height="35dp"
+        android:layout_marginStart="60dp"
+        android:layout_marginBottom="200dp"
+        app:layout_constraintBottom_toBottomOf="parent"
+        app:layout_constraintStart_toStartOf="parent"
+        app:pressedDrawable="@drawable/ic_controller_l1_button_pressed"
+        app:unpressedDrawable="@drawable/ic_controller_l1_button" />
+
+    <com.github.stenzek.duckstation.TouchscreenControllerButtonView
+        android:id="@+id/controller_button_l2"
+        android:layout_width="70dp"
+        android:layout_height="35dp"
+        android:layout_marginStart="60dp"
+        android:layout_marginBottom="260dp"
+        app:layout_constraintBottom_toBottomOf="parent"
+        app:layout_constraintStart_toStartOf="parent"
+        app:pressedDrawable="@drawable/ic_controller_l2_button_pressed"
+        app:unpressedDrawable="@drawable/ic_controller_l2_button" />
+
+    <com.github.stenzek.duckstation.TouchscreenControllerButtonView
+        android:id="@+id/controller_button_start"
+        android:layout_width="40dp"
+        android:layout_height="25dp"
+        android:layout_marginStart="80dp"
+        android:layout_marginBottom="8dp"
+        app:layout_constraintBottom_toBottomOf="parent"
+        app:layout_constraintEnd_toEndOf="parent"
+        app:layout_constraintHorizontal_bias="0.5"
+        app:layout_constraintStart_toStartOf="parent"
+        app:pressedDrawable="@drawable/ic_controller_start_button_pressed"
+        app:unpressedDrawable="@drawable/ic_controller_start_button" />
+
+    <com.github.stenzek.duckstation.TouchscreenControllerButtonView
+        android:id="@+id/controller_button_select"
+        android:layout_width="40dp"
+        android:layout_height="25dp"
+        android:layout_marginEnd="50dp"
+        android:layout_marginBottom="8dp"
+        app:layout_constraintBottom_toBottomOf="parent"
+        app:layout_constraintEnd_toEndOf="parent"
+        app:layout_constraintHorizontal_bias="0.5"
+        app:layout_constraintStart_toStartOf="parent"
+        app:pressedDrawable="@drawable/ic_controller_select_button_pressed"
+        app:unpressedDrawable="@drawable/ic_controller_select_button" />
+
+    <com.github.stenzek.duckstation.TouchscreenControllerButtonView
+        android:id="@+id/controller_button_cross"
+        android:layout_width="50dp"
+        android:layout_height="50dp"
+        android:layout_marginEnd="70dp"
+        android:layout_marginBottom="30dp"
+        app:layout_constraintBottom_toBottomOf="parent"
+        app:layout_constraintEnd_toEndOf="parent"
+        app:pressedDrawable="@drawable/ic_controller_cross_button_pressed"
+        app:unpressedDrawable="@drawable/ic_controller_cross_button" />
+
+    <com.github.stenzek.duckstation.TouchscreenControllerButtonView
+        android:id="@+id/controller_button_square"
+        android:layout_width="50dp"
+        android:layout_height="50dp"
+        android:layout_marginEnd="120dp"
+        android:layout_marginBottom="80dp"
+        app:layout_constraintBottom_toBottomOf="parent"
+        app:layout_constraintEnd_toEndOf="parent"
+        app:pressedDrawable="@drawable/ic_controller_square_button_pressed"
+        app:unpressedDrawable="@drawable/ic_controller_square_button" />
+
+    <com.github.stenzek.duckstation.TouchscreenControllerButtonView
+        android:id="@+id/controller_button_triangle"
+        android:layout_width="50dp"
+        android:layout_height="50dp"
+        android:layout_marginEnd="70dp"
+        android:layout_marginBottom="130dp"
+        app:layout_constraintBottom_toBottomOf="parent"
+        app:layout_constraintEnd_toEndOf="parent"
+        app:pressedDrawable="@drawable/ic_controller_triangle_button_pressed"
+        app:unpressedDrawable="@drawable/ic_controller_triangle_button" />
+
+    <com.github.stenzek.duckstation.TouchscreenControllerButtonView
+        android:id="@+id/controller_button_circle"
+        android:layout_width="50dp"
+        android:layout_height="50dp"
+        android:layout_marginEnd="20dp"
+        android:layout_marginBottom="80dp"
+        app:layout_constraintBottom_toBottomOf="parent"
+        app:layout_constraintEnd_toEndOf="parent"
+        app:pressedDrawable="@drawable/ic_controller_circle_button_pressed"
+        app:unpressedDrawable="@drawable/ic_controller_circle_button" />
+
+    <com.github.stenzek.duckstation.TouchscreenControllerAxisView
+        android:id="@+id/controller_axis_left"
+        android:layout_width="150dp"
+        android:layout_height="150dp"
+        android:layout_marginStart="20dp"
+        android:layout_marginBottom="30dp"
+        android:paddingTop="20dp"
+        android:paddingBottom="20dp"
+        android:paddingLeft="20dp"
+        android:paddingRight="20dp"
+        app:layout_constraintBottom_toBottomOf="parent"
+        app:layout_constraintStart_toStartOf="parent" />
+
+    <com.github.stenzek.duckstation.TouchscreenControllerAxisView
+        android:id="@+id/controller_axis_right"
+        android:layout_width="150dp"
+        android:layout_height="150dp"
+        android:layout_marginEnd="20dp"
+        android:layout_marginBottom="300dp"
+        android:paddingLeft="20dp"
+        android:paddingTop="20dp"
+        android:paddingRight="20dp"
+        android:paddingBottom="20dp"
+        app:layout_constraintBottom_toBottomOf="parent"
+        app:layout_constraintEnd_toEndOf="parent" />
+
+    <com.github.stenzek.duckstation.TouchscreenControllerButtonView
+        android:id="@+id/controller_button_left"
+        android:layout_width="50dp"
+        android:layout_height="150dp"
+        android:layout_marginStart="20dp"
+        android:layout_marginBottom="300dp"
+        android:paddingTop="50dp"
+        android:paddingBottom="50dp"
+        app:layout_constraintBottom_toBottomOf="parent"
+        app:layout_constraintStart_toStartOf="parent"
+        app:pressedDrawable="@drawable/ic_controller_left_button_pressed"
+        app:unpressedDrawable="@drawable/ic_controller_left_button" />
+
+    <com.github.stenzek.duckstation.TouchscreenControllerButtonView
+        android:id="@+id/controller_button_down"
+        android:layout_width="150dp"
+        android:layout_height="50dp"
+        android:layout_marginStart="20dp"
+        android:layout_marginBottom="300dp"
+        android:paddingStart="50dp"
+        android:paddingEnd="50dp"
+        app:layout_constraintBottom_toBottomOf="parent"
+        app:layout_constraintStart_toStartOf="parent"
+        app:pressedDrawable="@drawable/ic_controller_down_button_pressed"
+        app:unpressedDrawable="@drawable/ic_controller_down_button" />
+
+    <com.github.stenzek.duckstation.TouchscreenControllerButtonView
+        android:id="@+id/controller_button_right"
+        android:layout_width="50dp"
+        android:layout_height="150dp"
+        android:layout_marginStart="120dp"
+        android:layout_marginBottom="300dp"
+        android:paddingTop="50dp"
+        android:paddingBottom="50dp"
+        app:layout_constraintBottom_toBottomOf="parent"
+        app:layout_constraintStart_toStartOf="parent"
+        app:pressedDrawable="@drawable/ic_controller_right_button_pressed"
+        app:unpressedDrawable="@drawable/ic_controller_right_button" />
+
+    <com.github.stenzek.duckstation.TouchscreenControllerButtonView
+        android:id="@+id/controller_button_up"
+        android:layout_width="150dp"
+        android:layout_height="50dp"
+        android:layout_marginStart="20dp"
+        android:layout_marginBottom="400dp"
+        android:paddingStart="50dp"
+        android:paddingEnd="50dp"
+        app:layout_constraintBottom_toBottomOf="parent"
+        app:layout_constraintStart_toStartOf="parent"
+        app:pressedDrawable="@drawable/ic_controller_up_button_pressed"
+        app:unpressedDrawable="@drawable/ic_controller_up_button" />
+</androidx.constraintlayout.widget.ConstraintLayout>

android/app/src/main/res/layout/layout_touchscreen_controller_digital.xml

@@ -0,0 +1,175 @@
+<?xml version="1.0" encoding="utf-8"?>
+<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:id="@+id/constraintLayout"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:orientation="vertical">
+
+    <com.github.stenzek.duckstation.TouchscreenControllerButtonView
+        android:id="@+id/controller_button_r2"
+        android:layout_width="70dp"
+        android:layout_height="35dp"
+        android:layout_marginEnd="60dp"
+        android:layout_marginBottom="280dp"
+        app:layout_constraintBottom_toBottomOf="parent"
+        app:layout_constraintEnd_toEndOf="parent"
+        app:pressedDrawable="@drawable/ic_controller_r2_button_pressed"
+        app:unpressedDrawable="@drawable/ic_controller_r2_button" />
+
+    <com.github.stenzek.duckstation.TouchscreenControllerButtonView
+        android:id="@+id/controller_button_r1"
+        android:layout_width="70dp"
+        android:layout_height="35dp"
+        android:layout_marginEnd="60dp"
+        android:layout_marginBottom="220dp"
+        app:layout_constraintBottom_toBottomOf="parent"
+        app:layout_constraintEnd_toEndOf="parent"
+        app:pressedDrawable="@drawable/ic_controller_r1_button_pressed"
+        app:unpressedDrawable="@drawable/ic_controller_r1_button" />
+
+    <com.github.stenzek.duckstation.TouchscreenControllerButtonView
+        android:id="@+id/controller_button_right"
+        android:layout_width="50dp"
+        android:layout_height="150dp"
+        android:layout_marginStart="120dp"
+        android:layout_marginBottom="30dp"
+        android:paddingTop="50dp"
+        android:paddingBottom="50dp"
+        app:layout_constraintBottom_toBottomOf="parent"
+        app:layout_constraintStart_toStartOf="parent"
+        app:pressedDrawable="@drawable/ic_controller_right_button_pressed"
+        app:unpressedDrawable="@drawable/ic_controller_right_button" />
+
+    <com.github.stenzek.duckstation.TouchscreenControllerButtonView
+        android:id="@+id/controller_button_up"
+        android:layout_width="150dp"
+        android:layout_height="50dp"
+        android:layout_marginStart="20dp"
+        android:layout_marginBottom="130dp"
+        android:paddingStart="50dp"
+        android:paddingEnd="50dp"
+        app:layout_constraintBottom_toBottomOf="parent"
+        app:layout_constraintStart_toStartOf="parent"
+        app:pressedDrawable="@drawable/ic_controller_up_button_pressed"
+        app:unpressedDrawable="@drawable/ic_controller_up_button" />
+
+    <com.github.stenzek.duckstation.TouchscreenControllerButtonView
+        android:id="@+id/controller_button_l1"
+        android:layout_width="70dp"
+        android:layout_height="35dp"
+        android:layout_marginStart="60dp"
+        android:layout_marginBottom="220dp"
+        app:layout_constraintBottom_toBottomOf="parent"
+        app:layout_constraintStart_toStartOf="parent"
+        app:pressedDrawable="@drawable/ic_controller_l1_button_pressed"
+        app:unpressedDrawable="@drawable/ic_controller_l1_button" />
+
+    <com.github.stenzek.duckstation.TouchscreenControllerButtonView
+        android:id="@+id/controller_button_l2"
+        android:layout_width="70dp"
+        android:layout_height="35dp"
+        android:layout_marginStart="60dp"
+        android:layout_marginBottom="280dp"
+        app:layout_constraintBottom_toBottomOf="parent"
+        app:layout_constraintStart_toStartOf="parent"
+        app:pressedDrawable="@drawable/ic_controller_l2_button_pressed"
+        app:unpressedDrawable="@drawable/ic_controller_l2_button" />
+
+    <com.github.stenzek.duckstation.TouchscreenControllerButtonView
+        android:id="@+id/controller_button_left"
+        android:layout_width="50dp"
+        android:layout_height="150dp"
+        android:layout_marginStart="20dp"
+        android:layout_marginBottom="30dp"
+        android:paddingTop="50dp"
+        android:paddingBottom="50dp"
+        app:layout_constraintBottom_toBottomOf="parent"
+        app:layout_constraintStart_toStartOf="parent"
+        app:pressedDrawable="@drawable/ic_controller_left_button_pressed"
+        app:unpressedDrawable="@drawable/ic_controller_left_button" />
+
+    <com.github.stenzek.duckstation.TouchscreenControllerButtonView
+        android:id="@+id/controller_button_down"
+        android:layout_width="150dp"
+        android:layout_height="50dp"
+        android:layout_marginStart="20dp"
+        android:layout_marginBottom="30dp"
+        android:paddingStart="50dp"
+        android:paddingEnd="50dp"
+        app:layout_constraintBottom_toBottomOf="parent"
+        app:layout_constraintStart_toStartOf="parent"
+        app:pressedDrawable="@drawable/ic_controller_down_button_pressed"
+        app:unpressedDrawable="@drawable/ic_controller_down_button" />
+
+    <com.github.stenzek.duckstation.TouchscreenControllerButtonView
+        android:id="@+id/controller_button_start"
+        android:layout_width="40dp"
+        android:layout_height="25dp"
+        android:layout_marginStart="80dp"
+        android:layout_marginBottom="8dp"
+        app:layout_constraintBottom_toBottomOf="parent"
+        app:layout_constraintEnd_toEndOf="parent"
+        app:layout_constraintHorizontal_bias="0.5"
+        app:layout_constraintStart_toStartOf="parent"
+        app:pressedDrawable="@drawable/ic_controller_start_button_pressed"
+        app:unpressedDrawable="@drawable/ic_controller_start_button" />
+
+    <com.github.stenzek.duckstation.TouchscreenControllerButtonView
+        android:id="@+id/controller_button_select"
+        android:layout_width="40dp"
+        android:layout_height="25dp"
+        android:layout_marginEnd="50dp"
+        android:layout_marginBottom="8dp"
+        app:layout_constraintBottom_toBottomOf="parent"
+        app:layout_constraintEnd_toEndOf="parent"
+        app:layout_constraintHorizontal_bias="0.5"
+        app:layout_constraintStart_toStartOf="parent"
+        app:pressedDrawable="@drawable/ic_controller_select_button_pressed"
+        app:unpressedDrawable="@drawable/ic_controller_select_button" />
+
+    <com.github.stenzek.duckstation.TouchscreenControllerButtonView
+        android:id="@+id/controller_button_cross"
+        android:layout_width="50dp"
+        android:layout_height="50dp"
+        android:layout_marginEnd="70dp"
+        android:layout_marginBottom="30dp"
+        app:layout_constraintBottom_toBottomOf="parent"
+        app:layout_constraintEnd_toEndOf="parent"
+        app:pressedDrawable="@drawable/ic_controller_cross_button_pressed"
+        app:unpressedDrawable="@drawable/ic_controller_cross_button" />
+
+    <com.github.stenzek.duckstation.TouchscreenControllerButtonView
+        android:id="@+id/controller_button_square"
+        android:layout_width="50dp"
+        android:layout_height="50dp"
+        android:layout_marginEnd="120dp"
+        android:layout_marginBottom="80dp"
+        app:layout_constraintBottom_toBottomOf="parent"
+        app:layout_constraintEnd_toEndOf="parent"
+        app:pressedDrawable="@drawable/ic_controller_square_button_pressed"
+        app:unpressedDrawable="@drawable/ic_controller_square_button" />
+
+    <com.github.stenzek.duckstation.TouchscreenControllerButtonView
+        android:id="@+id/controller_button_triangle"
+        android:layout_width="50dp"
+        android:layout_height="50dp"
+        android:layout_marginEnd="70dp"
+        android:layout_marginBottom="130dp"
+        app:layout_constraintBottom_toBottomOf="parent"
+        app:layout_constraintEnd_toEndOf="parent"
+        app:pressedDrawable="@drawable/ic_controller_triangle_button_pressed"
+        app:unpressedDrawable="@drawable/ic_controller_triangle_button" />
+
+    <com.github.stenzek.duckstation.TouchscreenControllerButtonView
+        android:id="@+id/controller_button_circle"
+        android:layout_width="50dp"
+        android:layout_height="50dp"
+        android:layout_marginEnd="20dp"
+        android:layout_marginBottom="80dp"
+        app:layout_constraintBottom_toBottomOf="parent"
+        app:layout_constraintEnd_toEndOf="parent"
+        app:pressedDrawable="@drawable/ic_controller_circle_button_pressed"
+        app:unpressedDrawable="@drawable/ic_controller_circle_button" />
+</androidx.constraintlayout.widget.ConstraintLayout>

android/app/src/main/res/layout/settings_activity.xml

@@ -0,0 +1,9 @@
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent">
+
+    <FrameLayout
+        android:id="@+id/settings"
+        android:layout_width="match_parent"
+        android:layout_height="match_parent" />
+</LinearLayout>