From 39c2fcd105bb411a5d9eb21ec46e4f0bd062f41f Mon Sep 17 00:00:00 2001
From: Diego Mugetsu <diegoavilafacebook75@gmail.com>
Date: Sat, 26 Sep 2026 08:20:30 -0600
Subject: [PATCH] Android Save Data Folder picker

---
 docs/launcher.md                              |  23 +
 mobile/ANDROID.md                             |   7 +
 .../android/app/src/main/AndroidManifest.xml  |  14 +-
 .../love/src/jni/love/src/common/android.cpp  | 178 ++++++-
 .../love/src/jni/love/src/common/android.h    |  31 ++
 .../jni/love/src/modules/system/System.cpp    |  68 +++
 .../src/jni/love/src/modules/system/System.h  |  26 +
 .../love/src/modules/system/wrap_System.cpp   |  52 ++
 .../java/org/love2d/android/GameActivity.java | 494 +++++++++++++++++-
 scripts/build_android.sh                      |  75 ++-
 src/core/SaveData.lua                         |  29 +-
 src/import/CacheFs.lua                        |  53 +-
 src/import/RomImporter.lua                    |  98 +++-
 src/mods/Loader.lua                           |   3 +
 src/mods/Storage.lua                          |  18 +-
 15 files changed, 1116 insertions(+), 53 deletions(-)
 mode change 100755 => 100644 scripts/build_android.sh

diff --git a/docs/launcher.md b/docs/launcher.md
index 8bf8eb3f6..1f28ad607 100644
--- a/docs/launcher.md
+++ b/docs/launcher.md
@@ -34,6 +34,29 @@ for the launcher to acknowledge on refocus.
 
 After a successful import the consumed save-dir file is removed.
 
+## Android game-data / mods folder
+
+Android's default save identity (`Android/data/<package>/files/save/pokemon-love2d`)
+is often on a small internal volume. Mods, ROM caches and imported base files
+follow **GAME DATA FOLDER** in launcher Settings instead:
+
+- `love.system.pickFolder()` → `GameActivity.showFolderPicker`: a volume dialog
+  listing each `getExternalFilesDirs()` app folder (phone, SD card, with free
+  space) plus optional `ACTION_OPEN_DOCUMENT_TREE`. The chosen absolute path
+  is written to `picked_folder.txt`; `RomImporter:focus` / `_pollPickedFiles`
+  calls `SaveData.setDataDir`.
+- Direct rows for each volume (`love.system.getExternalDataDirs`) skip the
+  dialog. `USE THE DEFAULT FOLDER` clears the setting.
+- Writes go through `CacheFs` (`io.*`); reads need the folder on the PhysFS
+  path, so Android also exposes `love.system.mountDirectory`.
+- Saves and `options.lua` stay in the identity folder on purpose. After
+  switching, **MOVE EXISTING DATA HERE** copies `mods/`, `modstorage/` and
+  `imports/base/` into the new place.
+
+Most shared folders (Downloads, Drive) are not writable via `io.open` on
+Android 11+; the picker rejects those and asks for Phone storage or an SD
+card. iOS still keeps everything in the app folder.
+
 **Manual check (device/emulator):** import Red → switch to Blue → Choose →
 system file picker must appear (not a silent Red re-extract) → pick Blue →
 Blue becomes ready beside Red. On the MODS tab, Import mod .zip must open the
diff --git a/mobile/ANDROID.md b/mobile/ANDROID.md
index 3bbdca41b..d00098bd5 100644
--- a/mobile/ANDROID.md
+++ b/mobile/ANDROID.md
@@ -83,6 +83,13 @@ chosen file under the app save directory as `picked_rom.gb`,
 from that folder on Choose / refocus; see `docs/launcher.md`. The APK payload
 itself remains data-free (no embedded ROM or generated cache).
 
+Mods and imported game data can leave that identity folder: launcher Settings
+→ GAME DATA FOLDER → CHOOSE STORAGE (`love.system.pickFolder`) lists each
+app-owned volume (`getExternalFilesDirs`, typically phone plus SD card) and
+optionally a tree picker. The path is stored in `options.dataDir`;
+`CacheFs` installs mods there and `love.system.mountDirectory` puts it on
+the read path. Saves stay in the identity folder. See `docs/launcher.md`.
+
 ROM routing is SHA-1 based (not filename based): the importer accepts
 canonical 1 MiB carts (Red/Blue/Yellow) and 2 MiB carts (Gold/Silver), then
 selects the target version from `src/core/GameVersion.lua` by ROM hash.
diff --git a/mobile/android/app/src/main/AndroidManifest.xml b/mobile/android/app/src/main/AndroidManifest.xml
index 5cf7b38a6..95b4433cc 100644
--- a/mobile/android/app/src/main/AndroidManifest.xml
+++ b/mobile/android/app/src/main/AndroidManifest.xml
@@ -1,7 +1,16 @@
 <?xml version="1.0" encoding="utf-8"?>
-<manifest xmlns:android="http://schemas.android.com/apk/res/android" >
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools" >
 <uses-permission android:name="android.permission.VIBRATE" />
   <uses-permission android:name="android.permission.BLUETOOTH" />
+  <!-- Game-data folder: POSIX io.* / PhysFS need real filesystem access to
+       write ROM caches (LuaWriter) and read them back. App-owned volumes
+       (getExternalFilesDirs) do not need this; a user-picked Downloads /
+       SD-root folder on API 30+ does. tools:ignore is the Play policy
+       exemption tag; sideload builds are the usual distribution. -->
+  <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" android:maxSdkVersion="32" />
+  <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" android:maxSdkVersion="32" />
+  <uses-permission android:name="android.permission.MANAGE_EXTERNAL_STORAGE" tools:ignore="ScopedStorage" />
   <!-- Link play (src/link/): both the LAN backend (enet UDP) and the relay
        backend (luasocket TCP) are ordinary sockets, and Android denies those
        to a UID without INTERNET. Bind and connect then come back EPERM, which
@@ -30,7 +39,8 @@
   <application
       android:allowBackup="true"
       android:icon="@drawable/love"
-      android:label="${NAME}" >
+      android:label="${NAME}"
+      android:requestLegacyExternalStorage="true" >
     <activity
         android:name="org.love2d.android.GameActivity"
         android:exported="true"
diff --git a/mobile/android/love/src/jni/love/src/common/android.cpp b/mobile/android/love/src/jni/love/src/common/android.cpp
index d7b9230fc..44187af70 100644
--- a/mobile/android/love/src/jni/love/src/common/android.cpp
+++ b/mobile/android/love/src/jni/love/src/common/android.cpp
@@ -36,6 +36,14 @@
 #include <unistd.h>
 
 #include "filesystem/physfs/PhysfsIo.h"
+#include "libraries/physfs/physfs.h"
+
+// #604 / #839: the SAF bridges below must hand GameActivity the exact
+// directory physfs mounted as the save dir -- the same contract the iOS
+// GRPickerBridge already gets (mobile/ios/patch_love_src.py,
+// gr_saveDirectory) -- instead of letting Java recompute the root on its
+// own, which can name a different volume on merged / adopted-SD storage.
+#include "filesystem/Filesystem.h"
 
 namespace love
 {
@@ -183,6 +191,19 @@ void vibrate(double seconds)
 	env->DeleteLocalRef(activity);
 }
 
+// The directory physfs actually mounted as the save dir, or "" before the
+// filesystem module is up.  GameActivity must copy SAF picks HERE: its own
+// getExternalFilesDir(null) recomputation can disagree with the mounted
+// root on merged / adopted-SD storage (#604, #839).
+static const char *bridgeSaveDirectory()
+{
+	auto fs = Module::getInstance<love::filesystem::Filesystem>(Module::M_FILESYSTEM);
+	if (fs == nullptr)
+		return "";
+	const char *dir = fs->getSaveDirectory();
+	return dir != nullptr ? dir : "";
+}
+
 bool showFilePicker(const char *destFilename)
 {
 	if (destFilename == nullptr || destFilename[0] == '\0')
@@ -192,15 +213,29 @@ bool showFilePicker(const char *destFilename)
 	jclass activity = env->FindClass("org/love2d/android/GameActivity");
 
 	jmethodID method = env->GetStaticMethodID(activity, "showFilePicker",
-		"(Ljava/lang/String;)Z");
+		"(Ljava/lang/String;Ljava/lang/String;)Z");
 	jstring jname = env->NewStringUTF(destFilename);
-	jboolean result = env->CallStaticBooleanMethod(activity, method, jname);
+	jstring jsavedir = env->NewStringUTF(bridgeSaveDirectory());
+	jboolean result = env->CallStaticBooleanMethod(activity, method, jname, jsavedir);
+	env->DeleteLocalRef(jsavedir);
 	env->DeleteLocalRef(jname);
 
 	env->DeleteLocalRef(activity);
 	return result;
 }
 
+bool showImagePicker()
+{
+	JNIEnv *env = (JNIEnv*) SDL_AndroidGetJNIEnv();
+	jclass activity = env->FindClass("org/love2d/android/GameActivity");
+
+	jmethodID method = env->GetStaticMethodID(activity, "showImageFilePicker", "()Z");
+	jboolean result = env->CallStaticBooleanMethod(activity, method);
+
+	env->DeleteLocalRef(activity);
+	return result;
+}
+
 bool showCreateDocument(const char *suggestedName)
 {
 	if (suggestedName == nullptr || suggestedName[0] == '\0')
@@ -210,15 +245,107 @@ bool showCreateDocument(const char *suggestedName)
 	jclass activity = env->FindClass("org/love2d/android/GameActivity");
 
 	jmethodID method = env->GetStaticMethodID(activity, "showCreateDocument",
-		"(Ljava/lang/String;)Z");
+		"(Ljava/lang/String;Ljava/lang/String;)Z");
 	jstring jname = env->NewStringUTF(suggestedName);
-	jboolean result = env->CallStaticBooleanMethod(activity, method, jname);
+	jstring jsavedir = env->NewStringUTF(bridgeSaveDirectory());
+	jboolean result = env->CallStaticBooleanMethod(activity, method, jname, jsavedir);
+	env->DeleteLocalRef(jsavedir);
 	env->DeleteLocalRef(jname);
 
 	env->DeleteLocalRef(activity);
 	return result;
 }
 
+bool showFolderPicker()
+{
+	JNIEnv *env = (JNIEnv*) SDL_AndroidGetJNIEnv();
+	jclass activity = env->FindClass("org/love2d/android/GameActivity");
+
+	jmethodID method = env->GetStaticMethodID(activity, "showFolderPicker",
+		"(Ljava/lang/String;)Z");
+	jstring jsavedir = env->NewStringUTF(bridgeSaveDirectory());
+	jboolean result = env->CallStaticBooleanMethod(activity, method, jsavedir);
+	env->DeleteLocalRef(jsavedir);
+
+	env->DeleteLocalRef(activity);
+	return result;
+}
+
+std::string getExternalDataDirs()
+{
+	JNIEnv *env = (JNIEnv*) SDL_AndroidGetJNIEnv();
+	jclass activity = env->FindClass("org/love2d/android/GameActivity");
+
+	jmethodID method = env->GetStaticMethodID(activity, "getExternalDataDirs",
+		"()Ljava/lang/String;");
+	jstring jresult = (jstring) env->CallStaticObjectMethod(activity, method);
+	std::string result;
+	if (jresult != nullptr)
+	{
+		const char *chars = env->GetStringUTFChars(jresult, nullptr);
+		if (chars != nullptr)
+		{
+			result = chars;
+			env->ReleaseStringUTFChars(jresult, chars);
+		}
+		env->DeleteLocalRef(jresult);
+	}
+
+	env->DeleteLocalRef(activity);
+	return result;
+}
+
+bool mountDirectory(const char *path)
+{
+	if (path == nullptr || path[0] == '\0')
+		return false;
+	if (!PHYSFS_isInit())
+		return false;
+	return PHYSFS_mount(path, nullptr, 1) != 0;
+}
+
+static bool callStaticBool(const char *name, const char *sig, const char *arg)
+{
+	JNIEnv *env = (JNIEnv*) SDL_AndroidGetJNIEnv();
+	jclass activity = env->FindClass("org/love2d/android/GameActivity");
+	jmethodID method = env->GetStaticMethodID(activity, name, sig);
+	jboolean result;
+	if (arg != nullptr)
+	{
+		jstring jarg = env->NewStringUTF(arg);
+		result = env->CallStaticBooleanMethod(activity, method, jarg);
+		env->DeleteLocalRef(jarg);
+	}
+	else
+		result = env->CallStaticBooleanMethod(activity, method);
+	env->DeleteLocalRef(activity);
+	return result;
+}
+
+bool hasStorageAccess()
+{
+	return callStaticBool("hasStorageAccess", "()Z", nullptr);
+}
+
+bool requestStorageAccess()
+{
+	return callStaticBool("requestStorageAccess", "()Z", nullptr);
+}
+
+bool pathIsAppOwned(const char *path)
+{
+	if (path == nullptr)
+		return false;
+	return callStaticBool("pathIsAppOwned", "(Ljava/lang/String;)Z", path);
+}
+
+bool mkdirsReal(const char *path)
+{
+	if (path == nullptr || path[0] == '\0')
+		return false;
+	return callStaticBool("mkdirsReal", "(Ljava/lang/String;)Z", path);
+}
+
 bool syncHealthSteps()
 {
 	JNIEnv *env = (JNIEnv*) SDL_AndroidGetJNIEnv();
@@ -259,7 +386,19 @@ bool httpDownload(const char *url, const char *destPath, const char *userAgent,
 		return false;
 
 	JNIEnv *env = (JNIEnv*) SDL_AndroidGetJNIEnv();
-	jclass activity = env->FindClass("org/love2d/android/GameActivity");
+	// NOT FindClass: this is the one bridge called off the main thread
+	// (love.thread workers in src/net/fetch_worker.lua and
+	// src/update/check_worker.lua).  A worker is a raw pthread whose JNI
+	// class loader is the system one, which cannot see app classes, so
+	// FindClass("org/love2d/android/GameActivity") left a pending
+	// ClassNotFoundException and the next JNI call aborted the process --
+	// opening FIND MODS killed the app on the first stats fetch.  Resolving
+	// through the live activity instance works from any attached thread.
+	jobject activityObj = (jobject) SDL_AndroidGetActivity();
+	if (activityObj == nullptr)
+		return false;
+	jclass activity = env->GetObjectClass(activityObj);
+	env->DeleteLocalRef(activityObj);
 
 	// Old APK / new liblove skew: report "no transport" the same way a
 	// missing curl does, instead of aborting on a missing method (#597).
@@ -967,4 +1106,33 @@ void love_android_secondary_enable(int on)
 	env->DeleteLocalRef(activity);
 }
 
+extern "C" __attribute__((visibility("default")))
+const char *love_android_poll_secondary_touch()
+{
+	static thread_local std::string event;
+	event.clear();
+	JNIEnv *env = (JNIEnv*) SDL_AndroidGetJNIEnv();
+	jclass activity = env->FindClass("org/love2d/android/GameActivity");
+	jmethodID method = env->GetStaticMethodID(activity, "pollSecondaryDisplayTouch",
+		"()Ljava/lang/String;");
+	if (!method)
+		env->ExceptionClear();
+	else
+	{
+		jstring value = (jstring) env->CallStaticObjectMethod(activity, method);
+		if (value)
+		{
+			const char *utf = env->GetStringUTFChars(value, nullptr);
+			if (utf)
+			{
+				event = utf;
+				env->ReleaseStringUTFChars(value, utf);
+			}
+			env->DeleteLocalRef(value);
+		}
+	}
+	env->DeleteLocalRef(activity);
+	return event.empty() ? nullptr : event.c_str();
+}
+
 #endif // LOVE_ANDROID
diff --git a/mobile/android/love/src/jni/love/src/common/android.h b/mobile/android/love/src/jni/love/src/common/android.h
index 23bb905fc..986a71f36 100644
--- a/mobile/android/love/src/jni/love/src/common/android.h
+++ b/mobile/android/love/src/jni/love/src/common/android.h
@@ -68,12 +68,43 @@ void vibrate(double seconds);
  **/
 bool showFilePicker(const char *destFilename = nullptr);
 
+/**
+ * Shows the system's "pick an image" UI (Storage Access Framework with image/* MIME type).
+ * Returns true if the picker was launched; the picked file (if any) is
+ * copied asynchronously by GameActivity.onActivityResult into the app's
+ * external save directory as picked_sky.png, not returned here.
+ **/
+bool showImagePicker();
+
 /**
  * Shows ACTION_CREATE_DOCUMENT so Lua can export a staged pending_export.sav
  * to a user-chosen location. suggestedName is the dialog default filename.
  **/
 bool showCreateDocument(const char *suggestedName = nullptr);
 
+/**
+ * Game-data / mods folder picker. Volume dialog plus optional
+ * ACTION_OPEN_DOCUMENT_TREE; the path lands in picked_folder.txt.
+ **/
+bool showFolderPicker();
+
+/**
+ * "label\\tab path" rows for app-owned external files volumes.
+ **/
+std::string getExternalDataDirs();
+
+/**
+ * Mount an absolute directory onto the PhysFS search path (appended).
+ * love.filesystem.mount refuses paths outside the save dir; the game-data
+ * folder lives beside it (phone/SD gamedata/), so CacheFs needs this.
+ **/
+bool mountDirectory(const char *path);
+
+bool hasStorageAccess();
+bool requestStorageAccess();
+bool pathIsAppOwned(const char *path);
+bool mkdirsReal(const char *path);
+
 /**
  * Pokéwalker step bridge: asks GameActivity to read the hardware step
  * counter and stage steps_pending.json in the save identity dir (see
diff --git a/mobile/android/love/src/jni/love/src/modules/system/System.cpp b/mobile/android/love/src/jni/love/src/modules/system/System.cpp
index 8dd9e8de6..5f0311316 100644
--- a/mobile/android/love/src/jni/love/src/modules/system/System.cpp
+++ b/mobile/android/love/src/jni/love/src/modules/system/System.cpp
@@ -194,6 +194,8 @@ bool System::pickFile(const char *kind) const
 			dest = "picked_save.sav";
 		else if (strcmp(kind, "rom") == 0)
 			dest = "picked_rom.gb";
+		else if (strcmp(kind, "image") == 0)
+			return love::android::showImagePicker();
 	}
 	return love::android::showFilePicker(dest);
 #else
@@ -212,6 +214,72 @@ bool System::createFile(const char *suggestedName) const
 #endif
 }
 
+bool System::pickFolder() const
+{
+#ifdef LOVE_ANDROID
+	return love::android::showFolderPicker();
+#else
+	return false;
+#endif
+}
+
+std::string System::getExternalDataDirs() const
+{
+#ifdef LOVE_ANDROID
+	return love::android::getExternalDataDirs();
+#else
+	return "";
+#endif
+}
+
+bool System::mountDirectory(const char *path) const
+{
+#ifdef LOVE_ANDROID
+	return love::android::mountDirectory(path);
+#else
+	LOVE_UNUSED(path);
+	return false;
+#endif
+}
+
+bool System::hasStorageAccess() const
+{
+#ifdef LOVE_ANDROID
+	return love::android::hasStorageAccess();
+#else
+	return true;
+#endif
+}
+
+bool System::requestStorageAccess() const
+{
+#ifdef LOVE_ANDROID
+	return love::android::requestStorageAccess();
+#else
+	return false;
+#endif
+}
+
+bool System::pathIsAppOwned(const char *path) const
+{
+#ifdef LOVE_ANDROID
+	return love::android::pathIsAppOwned(path);
+#else
+	LOVE_UNUSED(path);
+	return true;
+#endif
+}
+
+bool System::mkdirs(const char *path) const
+{
+#ifdef LOVE_ANDROID
+	return love::android::mkdirsReal(path);
+#else
+	LOVE_UNUSED(path);
+	return false;
+#endif
+}
+
 bool System::syncHealthSteps() const
 {
 #ifdef LOVE_ANDROID
diff --git a/mobile/android/love/src/jni/love/src/modules/system/System.h b/mobile/android/love/src/jni/love/src/modules/system/System.h
index be1ea3074..28b7de41c 100644
--- a/mobile/android/love/src/jni/love/src/modules/system/System.h
+++ b/mobile/android/love/src/jni/love/src/modules/system/System.h
@@ -127,6 +127,32 @@ class System : public Module
 	 **/
 	virtual bool createFile(const char *suggestedName = nullptr) const;
 
+	/**
+	 * Android: show a storage-volume dialog (phone vs SD card) plus an
+	 * optional ACTION_OPEN_DOCUMENT_TREE browse. The chosen path is written
+	 * asynchronously to picked_folder.txt in the save identity; see
+	 * GameActivity.showFolderPicker and src/import/RomImporter.lua.
+	 **/
+	virtual bool pickFolder() const;
+
+	/**
+	 * Android: newline-separated "label<TAB>absolute path" rows for each
+	 * app-owned external files volume (phone, SD card, ...), each already
+	 * pointed at a gamedata/ subdirectory. Empty string elsewhere.
+	 **/
+	virtual std::string getExternalDataDirs() const;
+
+	/**
+	 * Android: PHYSFS_mount an absolute directory onto the read path.
+	 * Needed so CacheFs can see a game-data folder that is not the save dir.
+	 **/
+	virtual bool mountDirectory(const char *path) const;
+
+	virtual bool hasStorageAccess() const;
+	virtual bool requestStorageAccess() const;
+	virtual bool pathIsAppOwned(const char *path) const;
+	virtual bool mkdirs(const char *path) const;
+
 	/**
 	 * Pokéwalker: stage pending real-world steps (steps_pending.json in the
 	 * save dir) from the platform step source. Android-only; false elsewhere.
diff --git a/mobile/android/love/src/jni/love/src/modules/system/wrap_System.cpp b/mobile/android/love/src/jni/love/src/modules/system/wrap_System.cpp
index 1b94ef7c0..4cc4fac4e 100644
--- a/mobile/android/love/src/jni/love/src/modules/system/wrap_System.cpp
+++ b/mobile/android/love/src/jni/love/src/modules/system/wrap_System.cpp
@@ -109,6 +109,51 @@ int w_createFile(lua_State *L)
 	return 1;
 }
 
+int w_pickFolder(lua_State *L)
+{
+	luax_pushboolean(L, instance()->pickFolder());
+	return 1;
+}
+
+int w_getExternalDataDirs(lua_State *L)
+{
+	luax_pushstring(L, instance()->getExternalDataDirs());
+	return 1;
+}
+
+int w_mountDirectory(lua_State *L)
+{
+	const char *path = luaL_checkstring(L, 1);
+	luax_pushboolean(L, instance()->mountDirectory(path));
+	return 1;
+}
+
+int w_hasStorageAccess(lua_State *L)
+{
+	luax_pushboolean(L, instance()->hasStorageAccess());
+	return 1;
+}
+
+int w_requestStorageAccess(lua_State *L)
+{
+	luax_pushboolean(L, instance()->requestStorageAccess());
+	return 1;
+}
+
+int w_pathIsAppOwned(lua_State *L)
+{
+	const char *path = luaL_checkstring(L, 1);
+	luax_pushboolean(L, instance()->pathIsAppOwned(path));
+	return 1;
+}
+
+int w_mkdirs(lua_State *L)
+{
+	const char *path = luaL_checkstring(L, 1);
+	luax_pushboolean(L, instance()->mkdirs(path));
+	return 1;
+}
+
 int w_syncHealthSteps(lua_State *L)
 {
 	luax_pushboolean(L, instance()->syncHealthSteps());
@@ -150,6 +195,13 @@ static const luaL_Reg functions[] =
 	{ "vibrate", w_vibrate },
 	{ "pickFile", w_pickFile },
 	{ "createFile", w_createFile },
+	{ "pickFolder", w_pickFolder },
+	{ "getExternalDataDirs", w_getExternalDataDirs },
+	{ "mountDirectory", w_mountDirectory },
+	{ "hasStorageAccess", w_hasStorageAccess },
+	{ "requestStorageAccess", w_requestStorageAccess },
+	{ "pathIsAppOwned", w_pathIsAppOwned },
+	{ "mkdirs", w_mkdirs },
 	{ "syncHealthSteps", w_syncHealthSteps },
 	{ "restartApp", w_restartApp },
 	{ "httpDownload", w_httpDownload },
diff --git a/mobile/android/love/src/main/java/org/love2d/android/GameActivity.java b/mobile/android/love/src/main/java/org/love2d/android/GameActivity.java
index 9ecbd2d9a..e0ae35ed0 100644
--- a/mobile/android/love/src/main/java/org/love2d/android/GameActivity.java
+++ b/mobile/android/love/src/main/java/org/love2d/android/GameActivity.java
@@ -59,7 +59,12 @@
 import android.os.Environment;
 import android.os.Handler;
 import android.os.Looper;
+import android.os.StatFs;
 import android.os.Vibrator;
+import android.os.storage.StorageManager;
+import android.os.storage.StorageVolume;
+import android.provider.DocumentsContract;
+import android.provider.Settings;
 import android.util.Log;
 import android.util.DisplayMetrics;
 import android.view.*;
@@ -80,6 +85,7 @@ public class GameActivity extends SDLActivity {
     public static final int FILE_CREATE_REQUEST_CODE = 5;
     public static final int STEP_PERMISSION_REQUEST_CODE = 6;
     public static final int RESTART_REQUEST_CODE = 7;
+    public static final int FOLDER_PICKER_REQUEST_CODE = 8;
     /** @deprecated Prefer FILE_PICKER_REQUEST_CODE; kept for older call sites. */
     public static final int ROM_PICKER_REQUEST_CODE = FILE_PICKER_REQUEST_CODE;
     // Mirrors conf.lua's t.identity ("pokemon-love2d"): where the picked file
@@ -90,8 +96,14 @@ public class GameActivity extends SDLActivity {
     private static final String PICKED_ROM_FILENAME = "picked_rom.gb";
     private static final String PICKED_MOD_FILENAME = "picked_mod.zip";
     private static final String PICKED_SAVE_FILENAME = "picked_save.sav";
+    private static final String PICKED_IMAGE_FILENAME = "picked_sky.png";
     private static final String PENDING_EXPORT_FILENAME = "pending_export.sav";
     private static final String EXPORT_DONE_FILENAME = "export_done.flag";
+    private static final String PICKED_FOLDER_FILENAME = "picked_folder.txt";
+    // App-owned subdirectory under each getExternalFilesDir volume: mods and
+    // imported games land here so they are not competing with saves for the
+    // identity folder's space.
+    private static final String GAME_DATA_SUBDIR = "gamedata";
     // Written when a SAF pick cannot be read at all, with the destination
     // basename as its body, so RomImporter:focus can say so in the launcher
     // instead of leaving the player on "No ROM imported" (issue #442).
@@ -133,6 +145,18 @@ public class GameActivity extends SDLActivity {
      */
     private boolean pickRetried = false;
     private static final String STATE_PENDING_PICK = "pendingPickFilename";
+    // Absolute save directory physfs actually mounted, as reported by the
+    // native bridge call that opened the picker (love/src/common/android.cpp,
+    // bridgeSaveDirectory).  This activity used to recompute
+    // getExternalFilesDir(null)/save/<identity> on its own at result time; on
+    // merged / adopted-SD storage that can name a different volume than the
+    // one LOVE mounted, so the copied pick (and pick_error.flag) landed where
+    // Lua never scans -- the launcher then "did nothing" after a pick (#604)
+    // and the folders a file manager can browse stayed empty while the game
+    // saved fine elsewhere (#839).  Empty string means "not told yet": fall
+    // back to the historical computation.
+    private String pendingPickSaveDir = "";
+    private static final String STATE_PENDING_PICK_DIR = "pendingPickSaveDir";
     private static final String STATE_PENDING_CREATE = "pendingCreateSuggestedName";
     // Suggested download name for the in-flight SAF create (set by showCreateDocument).
     private String pendingCreateSuggestedName = "export.sav";
@@ -203,6 +227,8 @@ protected void onCreate(Bundle savedInstanceState) {
             // a recreated activity still lands under the basename it asked for.
             String pick = savedInstanceState.getString(STATE_PENDING_PICK);
             if (pick != null) pendingPickFilename = pick;
+            String pickDir = savedInstanceState.getString(STATE_PENDING_PICK_DIR);
+            if (pickDir != null) pendingPickSaveDir = pickDir;
             String create = savedInstanceState.getString(STATE_PENDING_CREATE);
             if (create != null) pendingCreateSuggestedName = create;
         }
@@ -484,13 +510,23 @@ public static boolean openURLFromLOVE(String url) {
      * @param destFilename basename under the app save identity (e.g.
      *                     picked_rom.gb, picked_mod.zip, picked_save.sav)
      */
+    /** Legacy single-argument entry; resolves the save dir itself. */
     @Keep
     public static boolean showFilePicker(String destFilename) {
+        return showFilePicker(destFilename, null);
+    }
+
+    @Keep
+    public static boolean showFilePicker(String destFilename, String saveDir) {
         GameActivity self = (GameActivity) mSingleton;
         if (self == null) return false;
         if (destFilename == null || destFilename.length() == 0) {
             destFilename = PICKED_ROM_FILENAME;
         }
+        // Remember where LOVE's filesystem is really mounted so
+        // onActivityResult copies the pick there, not into a recomputed
+        // (possibly different-volume) root (#604, #839).
+        self.pendingPickSaveDir = (saveDir != null) ? saveDir : "";
         // Reject path separators so a hostile JNI caller cannot escape the
         // save identity directory.
         if (destFilename.indexOf('/') >= 0 || destFilename.indexOf('\\') >= 0) {
@@ -568,6 +604,346 @@ public static boolean showSaveFilePicker() {
         return showFilePicker(PICKED_SAVE_FILENAME);
     }
 
+    /** Image picker convenience wrapper used for skybox selection. */
+    @Keep
+    public static boolean showImageFilePicker() {
+        if (android.os.Build.VERSION.SDK_INT < 19) return false;
+        GameActivity self = (GameActivity) mSingleton;
+        if (self == null) return false;
+
+        self.pendingPickFilename = PICKED_IMAGE_FILENAME;
+        Intent intent = new Intent(Intent.ACTION_OPEN_DOCUMENT);
+        intent.addCategory(Intent.CATEGORY_OPENABLE);
+        intent.setType("image/*");
+        try {
+            self.startActivityForResult(intent, FILE_PICKER_REQUEST_CODE);
+            return true;
+        } catch (Exception e) {
+            Log.d("GameActivity", "could not open image picker: " + e.getMessage());
+            return false;
+        }
+    }
+
+    /**
+     * App-owned volumes where io.* / PhysFS can actually write: each
+     * getExternalFilesDir plus a gamedata/ subdirectory. Phone storage is
+     * the first row; a removable SD card (when present) is the rest.
+     * Returned as "label\\tpath" lines for love.system.getExternalDataDirs.
+     */
+    @Keep
+    public static String getExternalDataDirs() {
+        GameActivity self = (GameActivity) mSingleton;
+        if (self == null) return "";
+        StringBuilder sb = new StringBuilder();
+        File[] dirs = self.getExternalFilesDirs(null);
+        if (dirs == null) return "";
+        for (int i = 0; i < dirs.length; i++) {
+            File dir = dirs[i];
+            if (dir == null) continue;
+            File gameData = new File(dir, GAME_DATA_SUBDIR);
+            if (!gameData.exists() && !gameData.mkdirs()) {
+                Log.d("GameActivity", "could not create " + gameData);
+                continue;
+            }
+            if (sb.length() > 0) sb.append('\n');
+            sb.append(self.volumeLabel(dir, i)).append('\t')
+                .append(gameData.getAbsolutePath());
+        }
+        return sb.toString();
+    }
+
+    /**
+     * True when POSIX fopen / PhysFS can use shared storage (Downloads, a
+     * user-picked tree, the SD card root). App-owned dirs never need this.
+     */
+    @Keep
+    public static boolean hasStorageAccess() {
+        if (android.os.Build.VERSION.SDK_INT >= 30) {
+            return Environment.isExternalStorageManager();
+        }
+        GameActivity self = (GameActivity) mSingleton;
+        if (self == null) return false;
+        if (android.os.Build.VERSION.SDK_INT < 23) return true;
+        return ActivityCompat.checkSelfPermission(self,
+            Manifest.permission.WRITE_EXTERNAL_STORAGE)
+            == PackageManager.PERMISSION_GRANTED;
+    }
+
+    /** True when path is under this app's files / external-files dirs. */
+    @Keep
+    public static boolean pathIsAppOwned(String path) {
+        if (path == null || path.length() == 0) return false;
+        GameActivity self = (GameActivity) mSingleton;
+        if (self == null) return false;
+        String norm = path.replace('\\', '/');
+        if (!norm.endsWith("/")) norm = norm + "/";
+        File internal = self.getFilesDir();
+        if (internal != null && under(norm, internal)) return true;
+        File[] dirs = self.getExternalFilesDirs(null);
+        if (dirs != null) {
+            for (int i = 0; i < dirs.length; i++) {
+                if (dirs[i] != null && under(norm, dirs[i])) return true;
+            }
+        }
+        return false;
+    }
+
+    private static boolean under(String normPathWithSlash, File dir) {
+        String base = dir.getAbsolutePath().replace('\\', '/');
+        if (!base.endsWith("/")) base = base + "/";
+        return normPathWithSlash.equals(base) || normPathWithSlash.startsWith(base);
+    }
+
+    /**
+     * Opens the system "all files access" screen (API 30+) or the legacy
+     * write-storage prompt. Does not block: Lua retries on the next focus.
+     */
+    @Keep
+    public static boolean requestStorageAccess() {
+        if (hasStorageAccess()) return true;
+        final GameActivity self = (GameActivity) mSingleton;
+        if (self == null) return false;
+        self.runOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                if (android.os.Build.VERSION.SDK_INT >= 30) {
+                    try {
+                        Intent intent = new Intent(
+                            Settings.ACTION_MANAGE_APP_ALL_FILES_ACCESS_PERMISSION);
+                        intent.setData(Uri.parse("package:" + self.getPackageName()));
+                        self.startActivity(intent);
+                    } catch (Exception e) {
+                        try {
+                            self.startActivity(new Intent(
+                                Settings.ACTION_MANAGE_ALL_FILES_ACCESS_PERMISSION));
+                        } catch (Exception e2) {
+                            Log.d("GameActivity", "could not open storage settings: "
+                                + e2.getMessage());
+                        }
+                    }
+                } else if (android.os.Build.VERSION.SDK_INT >= 23) {
+                    ActivityCompat.requestPermissions(self, new String[] {
+                        Manifest.permission.WRITE_EXTERNAL_STORAGE,
+                        Manifest.permission.READ_EXTERNAL_STORAGE
+                    }, EXTERNAL_STORAGE_REQUEST_CODE);
+                }
+            }
+        });
+        return true;
+    }
+
+    /** Java mkdirs for a game-data tree; FFI mkdir often EACCES on shared storage. */
+    @Keep
+    public static boolean mkdirsReal(String path) {
+        if (path == null || path.length() == 0) return false;
+        File dir = new File(path);
+        return dir.isDirectory() || dir.mkdirs();
+    }
+
+    /**
+     * Volume dialog (phone / SD) plus optional ACTION_OPEN_DOCUMENT_TREE.
+     * The chosen absolute path is written to picked_folder.txt in the
+     * mounted save identity so RomImporter can apply it on the next poll
+     * (an AlertDialog does not steal activity focus the way SAF does).
+     */
+    @Keep
+    public static boolean showFolderPicker(String saveDir) {
+        GameActivity self = (GameActivity) mSingleton;
+        if (self == null) return false;
+        self.pendingPickSaveDir = (saveDir != null) ? saveDir : "";
+        self.runOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                self.showFolderPickerDialog();
+            }
+        });
+        return true;
+    }
+
+    private String volumeLabel(File dir, int index) {
+        String name = index == 0 ? "Phone storage" : "SD card";
+        boolean removable = index > 0;
+        if (android.os.Build.VERSION.SDK_INT >= 24) {
+            try {
+                StorageManager sm = (StorageManager) getSystemService(Context.STORAGE_SERVICE);
+                if (sm != null) {
+                    StorageVolume vol = sm.getStorageVolume(dir);
+                    if (vol != null) {
+                        String desc = vol.getDescription(this);
+                        if (desc != null && desc.length() > 0) name = desc;
+                        removable = vol.isRemovable();
+                    }
+                }
+            } catch (Exception e) {
+                // keep the index-based fallback
+            }
+        }
+        long free = bytesFree(dir);
+        String extra = free >= 0 ? " · " + formatBytes(free) : "";
+        if (removable && index == 0) name = name + " (removable)";
+        return name + extra;
+    }
+
+    private static long bytesFree(File dir) {
+        try {
+            StatFs stat = new StatFs(dir.getAbsolutePath());
+            if (android.os.Build.VERSION.SDK_INT >= 18) {
+                return stat.getAvailableBytes();
+            }
+            return (long) stat.getAvailableBlocks() * (long) stat.getBlockSize();
+        } catch (Exception e) {
+            return -1;
+        }
+    }
+
+    private static String formatBytes(long bytes) {
+        double gb = bytes / (1024.0 * 1024.0 * 1024.0);
+        if (gb >= 1) {
+            return String.format(java.util.Locale.US, "%.1f GB free", gb);
+        }
+        double mb = bytes / (1024.0 * 1024.0);
+        return String.format(java.util.Locale.US, "%.0f MB free", mb);
+    }
+
+    private void showFolderPickerDialog() {
+        final ArrayList<String> labels = new ArrayList<String>();
+        final ArrayList<String> paths = new ArrayList<String>();
+        String listing = getExternalDataDirs();
+        if (listing != null && listing.length() > 0) {
+            String[] lines = listing.split("\n");
+            for (int i = 0; i < lines.length; i++) {
+                String line = lines[i];
+                int tab = line.indexOf('\t');
+                if (tab <= 0 || tab >= line.length() - 1) continue;
+                labels.add(line.substring(0, tab));
+                paths.add(line.substring(tab + 1));
+            }
+        }
+        final boolean canBrowse = android.os.Build.VERSION.SDK_INT >= 21;
+        if (canBrowse) labels.add("Browse…");
+        if (labels.isEmpty()) {
+            writeSaveDirFlag(PICK_ERROR_FILENAME, PICKED_FOLDER_FILENAME
+                + "\nno writable storage volume was found");
+            return;
+        }
+        CharSequence[] items = labels.toArray(new CharSequence[labels.size()]);
+        new AlertDialog.Builder(this)
+            .setTitle("Where to install games and mods")
+            .setItems(items, new DialogInterface.OnClickListener() {
+                @Override
+                public void onClick(DialogInterface dialog, int which) {
+                    if (canBrowse && which == labels.size() - 1) {
+                        launchTreePicker();
+                        return;
+                    }
+                    if (which >= 0 && which < paths.size()) {
+                        acceptPickedFolder(paths.get(which));
+                    }
+                }
+            })
+            .setNegativeButton(android.R.string.cancel, null)
+            .show();
+    }
+
+    private void launchTreePicker() {
+        if (android.os.Build.VERSION.SDK_INT < 21) return;
+        Intent intent = new Intent(Intent.ACTION_OPEN_DOCUMENT_TREE);
+        intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION
+            | Intent.FLAG_GRANT_WRITE_URI_PERMISSION);
+        if (android.os.Build.VERSION.SDK_INT >= 19) {
+            intent.addFlags(Intent.FLAG_GRANT_PERSISTABLE_URI_PERMISSION);
+        }
+        try {
+            startActivityForResult(intent, FOLDER_PICKER_REQUEST_CODE);
+        } catch (Exception e) {
+            Log.d("GameActivity", "could not open folder picker: " + e.getMessage());
+            writeSaveDirFlag(PICK_ERROR_FILENAME, PICKED_FOLDER_FILENAME
+                + "\ncould not open the system folder picker");
+        }
+    }
+
+    private void acceptPickedFolder(String path) {
+        if (path == null || path.length() == 0) {
+            writeSaveDirFlag(PICK_ERROR_FILENAME, PICKED_FOLDER_FILENAME
+                + "\nno folder chosen");
+            return;
+        }
+        File dir = new File(path);
+        if (!dir.exists() && !dir.mkdirs()) {
+            writeSaveDirFlag(PICK_ERROR_FILENAME, PICKED_FOLDER_FILENAME
+                + "\ncould not create that folder");
+            return;
+        }
+        if (!pathIsAppOwned(path) && !hasStorageAccess()) {
+            requestStorageAccess();
+        }
+        if (!folderIsWritable(path)) {
+            writeSaveDirFlag(PICK_ERROR_FILENAME, PICKED_FOLDER_FILENAME
+                + "\nthat folder could not be written to. Grant All files access "
+                + "when Android asks, or pick Phone storage / SD card from the list.");
+            return;
+        }
+        writeSaveDirFlag(PICKED_FOLDER_FILENAME, path);
+    }
+
+    private boolean folderIsWritable(String path) {
+        File dir = new File(path);
+        if (!dir.exists() && !dir.mkdirs()) return false;
+        File probe = new File(dir, ".gen2recomp-write-test");
+        try {
+            FileOutputStream fos = new FileOutputStream(probe, false);
+            fos.write("gen2recomp".getBytes("UTF-8"));
+            fos.close();
+            probe.delete();
+            return true;
+        } catch (Exception e) {
+            Log.d("GameActivity", "folder not writable " + path + ": " + e);
+            return false;
+        }
+    }
+
+    /**
+     * Best-effort filesystem path for a tree URI. App-owned dirs and some
+     * primary-storage trees still resolve; Downloads / Drive usually do
+     * not, and folderIsWritable then rejects them instead of pretending.
+     */
+    private String pathFromTreeUri(Uri uri) {
+        if (uri == null) return null;
+        if ("file".equals(uri.getScheme()) && uri.getPath() != null) {
+            return uri.getPath();
+        }
+        if (android.os.Build.VERSION.SDK_INT < 21) return null;
+        String docId;
+        try {
+            docId = DocumentsContract.getTreeDocumentId(uri);
+        } catch (Exception e) {
+            return null;
+        }
+        if (docId == null || docId.length() == 0) return null;
+        String volume;
+        String rel = "";
+        int colon = docId.indexOf(':');
+        if (colon >= 0) {
+            volume = docId.substring(0, colon);
+            rel = docId.substring(colon + 1);
+        } else {
+            volume = docId;
+        }
+        File root;
+        if ("primary".equalsIgnoreCase(volume)) {
+            root = Environment.getExternalStorageDirectory();
+        } else {
+            root = new File("/storage/" + volume);
+            if (!root.exists()) {
+                File alt = new File("/mnt/media_rw/" + volume);
+                if (alt.exists()) root = alt;
+            }
+        }
+        if (root == null) return null;
+        if (rel == null || rel.length() == 0) return root.getAbsolutePath();
+        return new File(root, rel.replace("/", File.separator)).getAbsolutePath();
+    }
+
     /**
      * Relaunches the whole app for love.system.restartApp, used by
      * src/core/HostShell.lua when a mod toggle needs a cold boot (#575).
@@ -685,8 +1061,14 @@ public static boolean httpDownload(String url, String destPath, String userAgent
      * return degrades on the Lua side (RomImporter export) to "Exported
      * inside the app folder", which is the correct pre-KitKat behavior.
      */
+    /** Legacy single-argument entry; resolves the save dir itself. */
     @Keep
     public static boolean showCreateDocument(String suggestedName) {
+        return showCreateDocument(suggestedName, null);
+    }
+
+    @Keep
+    public static boolean showCreateDocument(String suggestedName, String saveDir) {
         if (android.os.Build.VERSION.SDK_INT < 19) return false;
         // (see showFilePicker for why the import side got a pre-19 path)
         GameActivity self = (GameActivity) mSingleton;
@@ -698,9 +1080,12 @@ public static boolean showCreateDocument(String suggestedName) {
             Log.d("GameActivity", "refusing unsafe create name: " + suggestedName);
             return false;
         }
-        File source = new File(
-            new File(self.getExternalFilesDir(null), "save"),
-            ROM_SAVE_IDENTITY + "/" + PENDING_EXPORT_FILENAME);
+        // Route through the mounted save dir (#604, #839): Lua staged
+        // pending_export.sav where physfs writes, which is not necessarily
+        // where a fresh getExternalFilesDir(null) points on merged /
+        // adopted-SD storage.
+        self.pendingPickSaveDir = (saveDir != null) ? saveDir : "";
+        File source = new File(self.saveIdentityDir(), PENDING_EXPORT_FILENAME);
         if (!source.isFile()) {
             Log.d("GameActivity", "no pending export at " + source);
             return false;
@@ -721,14 +1106,28 @@ public static boolean showCreateDocument(String suggestedName) {
     }
 
     private File saveIdentityDir() {
-        return new File(new File(getExternalFilesDir(null), "save"), ROM_SAVE_IDENTITY);
+        // Prefer the mounted save dir the last bridge call reported: the
+        // recomputation below can name a different volume than the one LOVE
+        // mounted on merged / adopted-SD storage (#604, #839).
+        if (pendingPickSaveDir != null && pendingPickSaveDir.length() > 0) {
+            return new File(pendingPickSaveDir);
+        }
+        File ext = getExternalFilesDir(null);
+        if (ext == null) {
+            // Shared storage unavailable (ejected / mid-adoption): without
+            // this guard File(null, "save") silently built the RELATIVE
+            // path save/<identity>, mkdirs() failed against "/", and the
+            // pick was dropped with no message at all (#604).
+            ext = getFilesDir();
+        }
+        return new File(new File(ext, "save"), ROM_SAVE_IDENTITY);
     }
 
     /** Drops a small flag file in the save identity for Lua to consume on focus. */
     private void writeSaveDirFlag(String name, String body) {
         try {
             FileOutputStream fos = new FileOutputStream(new File(saveIdentityDir(), name), false);
-            fos.write(body.getBytes());
+            fos.write(body.getBytes("UTF-8"));
             fos.close();
         } catch (IOException e) {
             Log.d("GameActivity", "could not write " + name + ": " + e.getMessage());
@@ -916,6 +1315,7 @@ private boolean copyFileToUri(File source, Uri destUri) {
     protected void onSaveInstanceState(Bundle outState) {
         super.onSaveInstanceState(outState);
         outState.putString(STATE_PENDING_PICK, pendingPickFilename);
+        outState.putString(STATE_PENDING_PICK_DIR, pendingPickSaveDir);
         outState.putString(STATE_PENDING_CREATE, pendingCreateSuggestedName);
     }
 
@@ -942,6 +1342,32 @@ protected void onActivityResult(int requestCode, int resultCode, Intent data) {
             }
             return;
         }
+        if (requestCode == FOLDER_PICKER_REQUEST_CODE) {
+            if (resultCode != RESULT_OK || data == null || data.getData() == null) {
+                Log.d("GameActivity", "folder picker cancelled");
+                return;
+            }
+            Uri tree = data.getData();
+            try {
+                int keep = data.getFlags()
+                    & (Intent.FLAG_GRANT_READ_URI_PERMISSION
+                        | Intent.FLAG_GRANT_WRITE_URI_PERMISSION);
+                if (keep != 0 && android.os.Build.VERSION.SDK_INT >= 19) {
+                    getContentResolver().takePersistableUriPermission(tree, keep);
+                }
+            } catch (Exception e) {
+                Log.d("GameActivity", "no persistable tree grant for " + tree + ": " + e);
+            }
+            String path = pathFromTreeUri(tree);
+            if (path == null) {
+                writeSaveDirFlag(PICK_ERROR_FILENAME, PICKED_FOLDER_FILENAME
+                    + "\nthat location has no filesystem path this app can write to. "
+                    + "Pick Phone storage or an SD card from the list instead.");
+                return;
+            }
+            acceptPickedFolder(path);
+            return;
+        }
         if (requestCode != FILE_PICKER_REQUEST_CODE) return;
         if (resultCode != RESULT_OK || data == null || data.getData() == null) {
             Log.d("GameActivity", "file picker returned no file (cancelled?)");
@@ -1393,6 +1819,9 @@ public String getCRequirePath() {
     // in src/jni/love/src/common/android.cpp.
     private static volatile SecondaryPresentation secondaryPresentation;
     private static volatile boolean secondaryEnabled = false;
+    private static final int MAX_SECONDARY_TOUCHES = 32;
+    private static final java.util.ArrayDeque<String> secondaryTouches =
+        new java.util.ArrayDeque<>();
 
     @Keep
     public static void setSecondaryEnabled(final boolean on) {
@@ -1445,6 +1874,7 @@ private static void setupSecondaryDisplay() {
     private static void teardownSecondaryDisplay() {
         SecondaryPresentation p = secondaryPresentation;
         secondaryPresentation = null;
+        synchronized (secondaryTouches) { secondaryTouches.clear(); }
         if (p != null) {
             try { p.dismiss(); } catch (Throwable t) {}
         }
@@ -1463,6 +1893,13 @@ public static void updateSecondaryFrame(java.nio.ByteBuffer buf, int w, int h) {
         }
     }
 
+    @Keep
+    public static String pollSecondaryDisplayTouch() {
+        synchronized (secondaryTouches) {
+            return secondaryTouches.pollFirst();
+        }
+    }
+
     private static class SecondaryPresentation extends android.app.Presentation {
         private final FrameView frameView;
 
@@ -1529,6 +1966,7 @@ private static class FrameView extends View {
         private final android.graphics.Paint paint = new android.graphics.Paint();
         private final Object lock = new Object();
         private int fw, fh;
+        private int activePointer = -1;
 
         FrameView(Context context) {
             super(context);
@@ -1550,6 +1988,52 @@ void updateFrame(java.nio.ByteBuffer buf, int w, int h) {
             postInvalidate();
         }
 
+        private void enqueueTouch(String event) {
+            synchronized (secondaryTouches) {
+                if (secondaryTouches.size() >= MAX_SECONDARY_TOUCHES) {
+                    secondaryTouches.clear();
+                    secondaryTouches.addLast("cancel,0,0");
+                } else {
+                    secondaryTouches.addLast(event);
+                }
+            }
+        }
+
+        private int logicalX(float x) {
+            return Math.min(fw - 1, Math.max(0,
+                (int) ((x - dst.left) * fw / dst.width())));
+        }
+
+        private int logicalY(float y) {
+            return Math.min(fh - 1, Math.max(0,
+                (int) ((y - dst.top) * fh / dst.height())));
+        }
+
+        @Override
+        public boolean onTouchEvent(android.view.MotionEvent event) {
+            synchronized (lock) {
+                int action = event.getActionMasked();
+                if (action == android.view.MotionEvent.ACTION_DOWN && fw > 0
+                        && dst.contains((int) event.getX(), (int) event.getY())) {
+                    activePointer = event.getPointerId(0);
+                    enqueueTouch("down," + logicalX(event.getX()) + ","
+                        + logicalY(event.getY()));
+                } else if (action == android.view.MotionEvent.ACTION_UP
+                        && activePointer >= 0) {
+                    int index = event.findPointerIndex(activePointer);
+                    if (index >= 0 && fw > 0) {
+                        enqueueTouch("up," + logicalX(event.getX(index)) + ","
+                            + logicalY(event.getY(index)));
+                    }
+                    activePointer = -1;
+                } else if (action == android.view.MotionEvent.ACTION_CANCEL) {
+                    activePointer = -1;
+                    enqueueTouch("cancel,0,0");
+                }
+            }
+            return true;
+        }
+
         @Override
         protected void onDraw(android.graphics.Canvas canvas) {
             synchronized (lock) {
diff --git a/scripts/build_android.sh b/scripts/build_android.sh
old mode 100755
new mode 100644
index 3925cf54d..7bb3b1bee
--- a/scripts/build_android.sh
+++ b/scripts/build_android.sh
@@ -328,7 +328,19 @@ apply_android_branding() {
 
   say "applying Android branding (gradle.properties + permission trim)"
 
-  python3 - "$props" "$APPLICATION_ID" "$APP_NAME" "$VERSION" "$VERSION_CODE" <<'PY'
+  # Detect if running on Windows (Git Bash) or Linux/macOS
+  local is_windows=false
+  if [[ "$OSTYPE" == "msys" || "$OSTYPE" == "win32" ]]; then
+    is_windows=true
+  fi
+
+  if [ "$is_windows" = true ]; then
+    local win_props
+    local win_manifest
+    win_props="$(git_bash_to_windows_path "$props")"
+    win_manifest="$(git_bash_to_windows_path "$manifest")"
+
+    py - "$win_props" "$APPLICATION_ID" "$APP_NAME" "$VERSION" "$VERSION_CODE" <<'PY'
 import pathlib, re, sys
 path = pathlib.Path(sys.argv[1])
 app_id, name, version, version_code = sys.argv[2], sys.argv[3], sys.argv[4], sys.argv[5]
@@ -352,19 +364,18 @@ if version:
 path.write_text(text)
 PY
 
-  python3 - "$manifest" <<'PY'
+    py - "$win_manifest" <<'PY'
 import pathlib, re, sys
 path = pathlib.Path(sys.argv[1])
 text = path.read_text()
 
-# Drop mic / legacy storage, not needed by this game.
-# Keep VIBRATE (love.system.vibrate), BLUETOOTH (optional gamepads) and
-# INTERNET: link play is not offline-only any more, and stripping INTERNET
-# made every LAN host and every relay connect fail with EPERM (issue #287).
-# Orientation / label come from gradle.properties placeholders.
+# Drop mic only. WRITE_EXTERNAL_STORAGE / MANAGE_EXTERNAL_STORAGE stay:
+# a player-chosen game-data folder (ROM cache, non-mod files) is POSIX
+# io.open + PhysFS, which Android 11+ otherwise denies. Keep VIBRATE,
+# BLUETOOTH, INTERNET (issue #287). Orientation / label come from
+# gradle.properties placeholders.
 for perm in (
     "android.permission.RECORD_AUDIO",
-    "android.permission.WRITE_EXTERNAL_STORAGE",
 ):
     text = re.sub(
         rf'\s*<uses-permission android:name="{re.escape(perm)}"[^/]*/>\s*',
@@ -374,6 +385,54 @@ for perm in (
 text = re.sub(r'\s*android:usesCleartextTraffic="true"', "", text)
 path.write_text(text)
 PY
+  else
+    # Linux/macOS - use native paths
+    python3 - "$props" "$APPLICATION_ID" "$APP_NAME" "$VERSION" "$VERSION_CODE" <<'PY'
+import pathlib, re, sys
+path = pathlib.Path(sys.argv[1])
+app_id, name, version, version_code = sys.argv[2], sys.argv[3], sys.argv[4], sys.argv[5]
+text = path.read_text()
+
+def set_prop(text, key, value):
+    pat = re.compile(rf"(?m)^{re.escape(key)}=.*$")
+    line = f"{key}={value}"
+    if pat.search(text):
+        return pat.sub(line, text)
+    return text.rstrip() + "\n" + line + "\n"
+
+# Prefer plain app.name; clear byte-array form so it cannot win.
+text = re.sub(r"(?m)^app\.name_byte_array=.*\n?", "", text)
+text = set_prop(text, "app.name", name)
+text = set_prop(text, "app.application_id", app_id)
+text = set_prop(text, "app.orientation", "fullUser")
+if version:
+    text = set_prop(text, "app.version_name", version)
+    text = set_prop(text, "app.version_code", version_code)
+path.write_text(text)
+PY
+
+    python3 - "$manifest" <<'PY'
+import pathlib, re, sys
+path = pathlib.Path(sys.argv[1])
+text = path.read_text()
+
+# Drop mic only. WRITE_EXTERNAL_STORAGE / MANAGE_EXTERNAL_STORAGE stay:
+# a player-chosen game-data folder (ROM cache, non-mod files) is POSIX
+# io.open + PhysFS, which Android 11+ otherwise denies. Keep VIBRATE,
+# BLUETOOTH, INTERNET (issue #287). Orientation / label come from
+# gradle.properties placeholders.
+for perm in (
+    "android.permission.RECORD_AUDIO",
+):
+    text = re.sub(
+        rf'\s*<uses-permission android:name="{re.escape(perm)}"[^/]*/>\s*',
+        "\n",
+        text,
+    )
+text = re.sub(r'\s*android:usesCleartextTraffic="true"', "", text)
+path.write_text(text)
+PY
+  fi
 }
 
 # --------------------------------------------------------------- game.love
diff --git a/src/core/SaveData.lua b/src/core/SaveData.lua
index 40b5a4830..fe1d7b683 100644
--- a/src/core/SaveData.lua
+++ b/src/core/SaveData.lua
@@ -218,9 +218,11 @@ end
 -- machine by definition, and two relocation mechanisms arguing over one
 -- cache is a bug report nobody can read.
 --
--- DESKTOP ONLY, for the same reason portable mode is.  On Android/iOS there
--- is no arbitrary writable folder to point at, and the io.* writes CacheFs
--- would make into one fail per file rather than up front.
+-- Desktop always, Android once a folder can be proved writable with the
+-- same io.* probe CacheFs uses.  iOS still has no arbitrary writable
+-- folder to point at.  Android 11+ will refuse most shared folders
+-- (Downloads, DCIM); app-owned dirs on phone storage or an SD card still
+-- pass, which is the whole point of offering the setting there.
 local PROBE_NAME = ".gen2recomp-write-test"
 
 local dataDirChecked = false
@@ -232,6 +234,27 @@ function SaveData.dataDirSupported()
   if not (love.system and love.system.getOS) then return false end
   local osName = love.system.getOS()
   return osName == "Windows" or osName == "Linux" or osName == "OS X"
+    or osName == "Android"
+end
+
+-- Extra app-owned volumes the Android bridge can name (phone vs SD card).
+-- Each line from love.system.getExternalDataDirs is "label<TAB>absolute path".
+-- Empty on every other OS, and on an APK older than the bridge.
+function SaveData.externalDataDirs()
+  if not (love and love.system and type(love.system.getExternalDataDirs) == "function") then
+    return {}
+  end
+  local ok, raw = pcall(love.system.getExternalDataDirs)
+  if not ok or type(raw) ~= "string" or raw == "" then return {} end
+  local out = {}
+  for line in raw:gmatch("[^\r\n]+") do
+    local label, path = line:match("^(.-)\t(.+)$")
+    path = SaveData.normalizeDataDir(path or line)
+    if path then
+      out[#out + 1] = { label = (label and label ~= "" and label) or path, path = path }
+    end
+  end
+  return out
 end
 
 -- Trailing separators removed and slashes left alone otherwise: this string
diff --git a/src/import/CacheFs.lua b/src/import/CacheFs.lua
index bd4a4fc1b..f76c75750 100644
--- a/src/import/CacheFs.lua
+++ b/src/import/CacheFs.lua
@@ -24,8 +24,9 @@
 --
 -- Portable mode is desktop-only (Windows/Linux/macOS); on Android/iOS the
 -- source is a read-only package with no game folder to write into, so
--- SaveData.isPortable() is false there and this module falls back to the
--- ordinary love.filesystem/save-directory behaviour.
+-- SaveData.isPortable() is false there.  Android can still redirect the
+-- cache through SaveData.dataDir() (phone vs SD card / a writable tree),
+-- which this module mounts the same way as a desktop custom folder.
 
 local CacheFs = {}
 
@@ -120,6 +121,8 @@ local function resolveMount()
   local libs = {
     function() return ffi.C end,
     function() return ffi.load("love") end,
+    -- Android loads love as liblove.so; ffi.C does not search it.
+    function() return ffi.load("liblove.so") end,
   }
   for _, getlib in ipairs(libs) do
     local okl, lib = pcall(getlib)
@@ -144,8 +147,19 @@ end
 -- cache on top of the root (Red) copy and the source.
 local function mountReadable(dir, append)
   local fn = resolveMount()
-  if not fn then return false end
-  return fn(dir, "", append)
+  if fn and fn(dir, "", append) then return true end
+  -- Android: PHYSFS_mount through the JNI bridge (love.system.mountDirectory)
+  -- rather than love.filesystem.mount, which refuses paths outside the save
+  -- dir -- and the phone/SD gamedata folder is a sibling of that save dir.
+  if love and love.system and type(love.system.mountDirectory) == "function" then
+    local ok, mounted = pcall(love.system.mountDirectory, dir)
+    if ok and mounted then return true end
+  end
+  if love and love.filesystem and love.filesystem.mount then
+    local ok, mounted = pcall(love.filesystem.mount, dir, "", append ~= false)
+    if ok and mounted then return true end
+  end
+  return false
 end
 
 -- PHYSFS_unmount, resolved the same way PHYSFS_mount is.  Only
@@ -162,6 +176,8 @@ local function resolveUnmount()
   local libs = {
     function() return ffi.C end,
     function() return ffi.load("love") end,
+    -- Android loads love as liblove.so; ffi.C does not search it.
+    function() return ffi.load("liblove.so") end,
   }
   for _, getlib in ipairs(libs) do
     local okl, lib = pcall(getlib)
@@ -194,6 +210,8 @@ local function resolveMountPoint()
   local libs = {
     function() return ffi.C end,
     function() return ffi.load("love") end,
+    -- Android loads love as liblove.so; ffi.C does not search it.
+    function() return ffi.load("liblove.so") end,
   }
   for _, getlib in ipairs(libs) do
     local okl, lib = pcall(getlib)
@@ -344,9 +362,7 @@ end
 -- chosen game-data folder is writable and may have to create it first.
 function CacheFs.mkdirReal(path)
   if type(path) ~= "string" or path == "" then return false end
-  local mkdir = resolveMkdir()
-  if not mkdir then return false end
-  mkdir(path)
+  tryMkdirs(path)
   return true
 end
 
@@ -357,15 +373,27 @@ end
 -- create every parent directory of `rel` under `root` (best effort; an
 -- already-existing directory is fine, a genuine failure surfaces when the
 -- subsequent io.open write fails)
-local function ensureParents(root, rel)
+local function tryMkdirs(path)
+  if type(path) ~= "string" or path == "" then return end
+  -- Android: Java File.mkdirs() is the call that actually creates trees on
+  -- shared storage. FFI mkdir(2) often returns EACCES there even when a
+  -- one-file probe at the folder root succeeded -- which is LuaWriter's
+  -- "access denied" on data/generated during a ROM import.
+  if love and love.system and type(love.system.mkdirs) == "function" then
+    pcall(love.system.mkdirs, path)
+  end
   local mkdir = resolveMkdir()
-  if not mkdir then return end
+  if mkdir then mkdir(path) end
+end
+
+local function ensureParents(root, rel)
   local parts = {}
   for part in rel:gmatch("[^/]+") do parts[#parts + 1] = part end
   local cur = root
+  tryMkdirs(root)
   for i = 1, #parts - 1 do
     cur = cur .. SEP .. parts[i]
-    mkdir(cur)
+    tryMkdirs(cur)
   end
 end
 
@@ -511,12 +539,11 @@ end
 function CacheFs.rawCreateDirectory(rel)
   local root = rawRoot()
   if root then
-    local mkdir = resolveMkdir()
-    if not mkdir then return false end
     local cur = root
+    tryMkdirs(cur)
     for part in rel:gmatch("[^/]+") do
       cur = cur .. SEP .. part
-      mkdir(cur)
+      tryMkdirs(cur)
     end
     return true
   end
diff --git a/src/import/RomImporter.lua b/src/import/RomImporter.lua
index 4579fb263..a0f62c5be 100644
--- a/src/import/RomImporter.lua
+++ b/src/import/RomImporter.lua
@@ -36,6 +36,15 @@ local function pickFile(...)
   return fn(...) and true or false
 end
 
+-- Android folder picker for the game-data / mods install path.  Same bridge
+-- pattern as pickFile: the dialog is a separate UI, and the chosen path lands
+-- later as picked_folder.txt in the save identity (see GameActivity).
+local function pickFolder()
+  local fn = love.system.pickFolder
+  if not fn then return false end
+  return fn() and true or false
+end
+
 -- v17: Force a fresh Gen2 re-import after tileset registry and map-id fixes.
 -- v32: item ItemAttributes property bits (CANT_SELECT / CANT_TOSS).
 -- v33: shiny half of each PokemonPalettes row (MON_<id>_SHINY).
@@ -2864,6 +2873,17 @@ function RomImporter:focus(f)
     if self.tab == "mods" then self.tab = version end
     return
   end
+  -- Game-data folder pick: GameActivity wrote the absolute path into
+  -- picked_folder.txt.  The volume dialog does not steal focus, so this
+  -- also has to run from _pollPickedFiles.
+  if love.filesystem.getInfo("picked_folder.txt", "file") then
+    local path = love.filesystem.read("picked_folder.txt")
+    love.filesystem.remove("picked_folder.txt")
+    self.pickPending = nil
+    path = type(path) == "string" and path:match("^%s*(.-)%s*$") or ""
+    if path ~= "" then self:setDataDir(path) end
+    return
+  end
   -- The SAF pick failed inside GameActivity, which wrote pick_error.flag with
   -- the destination basename in it: some OEM shells (ColorOS) let a third-party
   -- archive manager win the ACTION_OPEN_DOCUMENT chooser and hand back a URI
@@ -2895,7 +2915,16 @@ function RomImporter:focus(f)
     if detail and detail ~= "" then
       text = text .. "  [" .. detail:gsub("\n", " / ") .. "]"
     end
-    if pickError:find("picked_mod", 1, true) then
+    if pickError:find("picked_folder", 1, true) then
+      local text = "Could not use that folder."
+      if detail and detail ~= "" then
+        text = text .. "  " .. detail:gsub("\n", " ")
+      end
+      self.settingsNotice = text
+      self._settingsRowCache = nil
+      self.pickPending = nil
+      return
+    elseif pickError:find("picked_mod", 1, true) then
       self.modNotice = { ok = false, text = text }
     elseif pickError:find("picked_save", 1, true) then
       local version = self.androidPendingVersion or self:_savedropTarget()
@@ -4378,10 +4407,13 @@ function RomImporter:_pollPickedFiles(dt)
     return
   end
   local found = love.filesystem.getInfo("export_done.flag", "file") ~= nil
+    or love.filesystem.getInfo("pick_error.flag", "file") ~= nil
+    or love.filesystem.getInfo("picked_folder.txt", "file") ~= nil
   if not found then
     for _, name in ipairs(love.filesystem.getDirectoryItems("")) do
       local n = name:lower()
-      if isRomFileName(n) or n == "picked_mod.zip" or n == "picked_save.sav" then
+      if isRomFileName(n) or n == "picked_mod.zip" or n == "picked_save.sav"
+          or n == "picked_folder.txt" then
         found = true
         break
       end
@@ -6082,6 +6114,13 @@ local function armedDelete(a, kind, id, version)
     and (love.timer.getTime() - a.t) <= DELETE_CONFIRM_SECONDS
 end
 
+function RomImporter:touchpressed(id, x, y, dx, dy, pressure)
+  -- Android-specific touch handler to avoid mouse emulation issues
+  if self._rename then return end -- the rename modal swallows all clicks
+  -- Route to the same mousepressed logic but with touch handling
+  return self:mousepressed(x, y, 1)
+end
+
 function RomImporter:mousepressed(x, y, button)
   if self._rename then return end -- the rename modal swallows all clicks
   -- The add-index prompt swallows clicks too, except its PASTE button: a
@@ -7662,14 +7701,22 @@ local MAX_FIND_QUERY = 48
 -- lowers on mobile -- setTextInput is global SDL state, not per-widget.
 function RomImporter:_armTextInput()
   if love.keyboard and love.keyboard.setTextInput then
-    pcall(love.keyboard.setTextInput, true)
+    local ok, err = pcall(love.keyboard.setTextInput, true)
+    if not ok then
+      -- Log error but don't crash - text input failure on Android is non-critical
+      print("Failed to arm text input: " .. tostring(err))
+    end
   end
 end
 
 function RomImporter:_disarmTextInput()
   if not self.android then return end
   if love.keyboard and love.keyboard.setTextInput then
-    pcall(love.keyboard.setTextInput, false)
+    local ok, err = pcall(love.keyboard.setTextInput, false)
+    if not ok then
+      -- Log error but don't crash - text input failure on Android is non-critical
+      print("Failed to disarm text input: " .. tostring(err))
+    end
   end
 end
 
@@ -7936,14 +7983,26 @@ function RomImporter:_launcherSettingsRows()
             note = "portable.txt sits beside the game, so everything is kept "
                 .. "in the game folder. Remove it to choose a folder here." })
     else
-      add({ kind = "action", label = "CHOOSE FOLDER", value = "BROWSE",
-            action = "chooseDataDir" })
+      add({ kind = "action",
+            label = self.android and "CHOOSE STORAGE" or "CHOOSE FOLDER",
+            value = self.android and "PICK" or "BROWSE",
+            action = "chooseDataDir",
+            note = self.android
+              and "Phone storage, an SD card, or Browse for another writable folder. Android will not let this app write to Downloads."
+              or nil })
+      for _, vol in ipairs(SaveData.externalDataDirs()) do
+        add({ kind = "action", label = vol.label,
+              value = "USE", action = "setDataDirVolume",
+              path = vol.path, note = vol.path })
+      end
       if SaveData.dataDirSetting() then
         add({ kind = "action", label = "USE THE DEFAULT FOLDER",
               value = "RESET", action = "clearDataDir" })
       end
-      add({ kind = "action", label = "OPEN FOLDER", value = "SHOW",
-            action = "openDataDir" })
+      if not self.android then
+        add({ kind = "action", label = "OPEN FOLDER", value = "SHOW",
+              action = "openDataDir" })
+      end
       -- ...and the way to stop having TWO homes.  Changing the folder points
       -- future writes at it and leaves what is already installed where it was;
       -- love.filesystem shows both at once, so the launcher goes on listing
@@ -8068,6 +8127,12 @@ function RomImporter:_dataDirNote()
   lines[#lines + 1] = "Changing this does not move games you have already "
     .. "imported; they stay where they are and can be re-imported or copied "
     .. "across by hand."
+  if self.android then
+    lines[#lines + 1] = "On Android, Phone storage is the same drive as the "
+      .. "app folder; pick an SD card (or Browse a writable folder on it) "
+      .. "when the app folder is out of space. Then use MOVE EXISTING DATA "
+      .. "HERE if mods are already installed."
+  end
   return table.concat(lines, "\n")
 end
 
@@ -8309,6 +8374,8 @@ function RomImporter:_settingsAction(entry)
     self.settingsNotice = Strings("Appearance back to the default")
   elseif action == "chooseDataDir" then
     self:chooseDataDir()
+  elseif action == "setDataDirVolume" then
+    self:setDataDir(entry.path)
   elseif action == "clearDataDir" then
     self:setDataDir(nil)
   elseif action == "openDataDir" then
@@ -8360,6 +8427,20 @@ function RomImporter:chooseDataDir()
     self.settingsNotice = Strings("This platform keeps games in one place")
     return
   end
+  -- Android: a native volume / tree picker writes picked_folder.txt into
+  -- the save identity (same async contract as pickFile).  hasNativePicker
+  -- is desktop-only (osascript / PowerShell / zenity) and must not gate
+  -- this path.
+  if self.android then
+    if pickFolder() then
+      self.pickPending = true
+      self.pickTimer = 0
+      self.settingsNotice = Strings("Pick where to keep games and mods.")
+    else
+      self.settingsNotice = Strings("No folder picker on this device")
+    end
+    return
+  end
   if not hasNativePicker() then
     self.settingsNotice = Strings("No folder picker on this device")
     return
@@ -8389,6 +8470,7 @@ function RomImporter:setDataDir(path)
   -- one who points at an empty folder should see the truth rather than a row
   -- of PLAY buttons for data that is no longer on the read path.
   self:_recheckReady()
+  pcall(function() self:_refreshMods() end)
   -- Reported from CacheFs, for the same reason the note above is: SaveData
   -- accepting a folder is not the same as the cache being able to live in it,
   -- and a confirmation that names a folder nothing will be written to is
diff --git a/src/mods/Loader.lua b/src/mods/Loader.lua
index 2abdd10fb..009656bdb 100644
--- a/src/mods/Loader.lua
+++ b/src/mods/Loader.lua
@@ -1067,6 +1067,9 @@ function Loader:_api(mod)
   setmetatable(api, { __index = function(_, key)
     if key == "game" then return loader:_game() end
     if key == "storage" then
+      -- Do not pass loader.fs when it is love.filesystem: that always writes
+      -- the OS save directory and leaves modstorage/ on internal storage.
+      -- Storage.fsOr routes the live LOVE fs through CacheFs.dataFs.
       if not storage then storage = ModStorage.new(modId, loader.fs) end
       return storage
     end
diff --git a/src/mods/Storage.lua b/src/mods/Storage.lua
index 34024e122..9b4308cbd 100644
--- a/src/mods/Storage.lua
+++ b/src/mods/Storage.lua
@@ -30,21 +30,21 @@ Storage.RECORD_EXT = ".rec"
 Storage.BYTES_EXT = ".bin"
 Storage.MAX_KEY = 180
 
--- An injected fs always wins (the mod loader's stub, the headless tests).
--- Otherwise modstorage/ follows the player's chosen game-data folder the same
--- way installed mods and the ROM cache do: CacheFs.dataFs reads through
--- love.filesystem, which sees every home at once, and routes writes at
--- whichever root is live -- love.filesystem's own write always lands in the
--- OS save directory, which is why this tree used to stay behind when the
--- folder changed.
+-- An injected stub (the mod loader's tests, a headless fs) always wins.
+-- love.filesystem itself does NOT: it always writes the OS save directory,
+-- so passing it in -- which Loader does as loader.fs -- stranded
+-- modstorage/ on internal storage after the player picked a game-data
+-- folder.  Treat the live LOVE fs as "no preference" and use CacheFs.dataFs
+-- instead, which reads every home and writes the live root.
 local function fsOr(fs)
-  if fs then return fs end
+  local loveFs = love and love.filesystem
+  if fs and fs ~= loveFs then return fs end
   local ok, CacheFs = pcall(require, "src.import.CacheFs")
   if ok and CacheFs and CacheFs.dataFs then
     local okFs, handle = pcall(CacheFs.dataFs)
     if okFs and handle then return handle end
   end
-  return (love and love.filesystem) or nil
+  return loveFs
 end
 
 -- id and key both land in a filesystem path, so both are validated rather