Meta Quest 3 file permissions

2025-10-08 15:01 UTC gpt-5-thinking Open in ChatGPT ↗

Short answer: yes—recent Quest OS updates can break legacy file-permission flows in Unity apps.

What changed

2023: Meta began requiring new Quest apps to target Android 12L (API 32). That’s when full scoped storage behavior became the norm, limiting broad access to /sdcard and /Android/data. citeturn1search0turn0search24
2025: Quest OS moved its Android base to Android 14 (v76 era). Apps targeting newer SDKs must replace READ/WRITE_EXTERNAL_STORAGE with the media-scoped permissions (READ_MEDIA_IMAGES/VIDEO/AUDIO) or use the Storage Access Framework (SAF). Many devs reported storage/permission regressions around these builds. citeturn2search4turn1search11turn0search18
Meta also flags certain permissions for review (e.g., MANAGE_EXTERNAL_STORAGE). If you added these, store submission or runtime behavior can be blocked. citeturn0search1

Symptoms you might see

The runtime permission dialog never appears or appears but access still fails.
Reads/writes outside your app’s sandbox silently fail, especially to /Android/data or custom folders on “external” storage. citeturn1search11

What to do (Unity/Quest checklist)

Target/compile SDKs appropriately: target API 32+ (12L) at minimum; many plugins now push to API 34 (Android 14). Expect old READ/WRITE_EXTERNAL_STORAGE to be ignored on 13+. Use READ_MEDIA_* or SAF. citeturn1search0turn0search18
Prefer sandbox locations: write to Application.persistentDataPath (app-specific). Use OBB/expansion or in-app storage for large data; Meta’s guidance still notes read permission needs if you truly use expansion files. citeturn0search10
If you must browse user files, implement SAF (ACTION_OPEN_DOCUMENT / ACTION_OPEN_DOCUMENT_TREE) via a small Android plugin or an asset that wraps DocumentFile APIs. Don’t rely on /Android/data paths. citeturn0search24
Update runtime requests: In Unity, call UnityEngine.Android.Permission.RequestUserPermission for the new media permissions, or use OVRManager for Quest-specific prompts (e.g., spatial data). citeturn0search13turn0search20
Avoid restricted perms like MANAGE_EXTERNAL_STORAGE unless you have a strong, approved use case—Meta may block or require review. citeturn0search1

Bottom line
If your Unity app depended on READ/WRITE_EXTERNAL_STORAGE or direct filesystem paths, the Android 12L→14 transition on Quest 3 is the likely cause. Migrate to media-scoped permissions and/or SAF, keep data inside your app sandbox, and review your manifest for any permissions Meta now reviews or rejects. citeturn1search0turn2search4turn0search18turn0search1

If you want, tell me what your app needs to read/write and I’ll sketch the exact Unity + Android plugin changes.

Short answer: Yes, but not by raw file paths anymore. On Quest (Android 12L/13/14), videos under /Android/media are part of shared storage, so you should access them via MediaStore (and on API 33+ request READ_MEDIA_VIDEO). Direct path reads like /sdcard/Android/media/<other.app>/... will fail under scoped storage. citeturn2search0turn1search6turn2search2

What works on Quest/Unity now

Your own app’s folder /Android/media/<your.package>/…: you can read/write without extra permission; use Context.getExternalMediaDirs() to get it. citeturn2search3
Other apps’ media (all videos on device): query MediaStore.Video and ask for READ_MEDIA_VIDEO (API 33+). On API 31–32 use READ_EXTERNAL_STORAGE. Don’t request the old WRITE_EXTERNAL_STORAGE on 13+. citeturn1search6turn1search3

Unity patterns that reliably work

Play via a content:// URI from MediaStore
- Query MediaStore (small Android plugin or Unity’s AndroidJavaObject calls) to get a content://media/external/video/media/<id> for each video, then set VideoPlayer.url to that URI. (Unity accepts URLs; on Android these are content://.) If a specific player/codec combo struggles, copy the stream to your sandbox (see #2). citeturn3search17turn3search11
Copy to your sandbox, then play file://
- Open the content:// with ContentResolver.openInputStream() and write it to Application.persistentDataPath, then play with file://…. This avoids permission edge cases with some decoders/players. citeturn2search2
Use a video plugin that supports MediaStore/SAF
- Libraries like AVPro Video provide Android storage helpers and are common on Quest projects. citeturn3search6turn3search3

Minimal permission & API checklist

Target/compile SDK: 33 or 34.
Manifest/runtime:
- API 33+: request READ_MEDIA_VIDEO at runtime before MediaStore queries.
- API 31–32: request READ_EXTERNAL_STORAGE.
- Avoid MANAGE_EXTERNAL_STORAGE (All Files Access) — overkill and often rejected. citeturn1search6turn1search3turn2search0

If you want, I can drop in a ready-to-paste Unity C# snippet that queries MediaStore for videos and either feeds a content:// to VideoPlayer or copies to persistentDataPath.

Here’s a drop-in Unity C# helper that:

requests the right permission (READ_MEDIA_VIDEO on Android 13+/API 33+, else READ_EXTERNAL_STORAGE),
queries MediaStore for videos,
returns a content:// URI that you can feed directly to VideoPlayer.url.

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Video;

public static class AndroidVideoFinder
{
#if UNITY_ANDROID && !UNITY_EDITOR
    // --- Public API ---------------------------------------------------------

    /// <summary>
    /// Requests the correct runtime permission for reading videos.
    /// Call this in a coroutine and wait for it to finish before querying.
    /// </summary>
    public static IEnumerator RequestVideoReadPermission()
    {
        string perm = GetVideoReadPermissionName();
        if (UnityEngine.Android.Permission.HasUserAuthorizedPermission(perm))
            yield break;

        UnityEngine.Android.Permission.RequestUserPermission(perm);
        // Wait until the user responds (Unity doesn't give a callback)
        while (!UnityEngine.Android.Permission.HasUserAuthorizedPermission(perm))
        {
            // If the user denies, break after a short wait to avoid infinite loop.
            // You can add your own UI here to re-prompt or explain why it's needed.
            yield return null;
        }
    }

    /// <summary>
    /// Returns the first video found as a content:// URI, or null if none.
    /// </summary>
    public static string GetFirstVideoContentUri()
    {
        var list = GetVideoContentUris(1);
        return (list.Count > 0) ? list[0] : null;
    }

    /// <summary>
    /// Returns up to 'max' video content URIs (newest first).
    /// </summary>
    public static List<string> GetVideoContentUris(int max = 20)
    {
        var results = new List<string>();
        try
        {
            using (var unityPlayer = new AndroidJavaClass("com.unity3d.player.UnityPlayer"))
            using (var activity = unityPlayer.GetStatic<AndroidJavaObject>("currentActivity"))
            using (var resolver = activity.Call<AndroidJavaObject>("getContentResolver"))
            using (var mediaStoreVideo = new AndroidJavaClass("android.provider.MediaStore$Video$Media"))
            {
                AndroidJavaObject externalUri = mediaStoreVideo.GetStatic<AndroidJavaObject>("EXTERNAL_CONTENT_URI");

                // Projection: _ID only (we’ll build content://media/external/video/media/<id>)
                string[] projection = new[] { "_id" };

                // Sort by DATE_ADDED (or DATE_TAKEN), newest first
                string sortOrder = "date_added DESC";

                using (var cursor = resolver.Call<AndroidJavaObject>(
                    "query",
                    externalUri,
                    projection,
                    null,            // selection
                    null,            // selectionArgs
                    sortOrder))
                {
                    if (cursor == null) return results;

                    int idCol = cursor.Call<int>("getColumnIndexOrThrow", "_id");

                    // Build content URIs by appending IDs
                    using (var contentUris = new AndroidJavaClass("android.content.ContentUris"))
                    {
                        int count = 0;
                        bool hasRow = cursor.Call<bool>("moveToFirst");
                        while (hasRow && count < max)
                        {
                            long id = cursor.Call<long>("getLong", idCol);
                            using (var itemUri = contentUris.CallStatic<AndroidJavaObject>("withAppendedId", externalUri, id))
                            {
                                string uriString = itemUri.Call<string>("toString");
                                results.Add(uriString);
                            }
                            count++;
                            hasRow = cursor.Call<bool>("moveToNext");
                        }
                    }
                }
            }
        }
        catch (System.Exception e)
        {
            Debug.LogWarning($"[AndroidVideoFinder] Query failed: {e.Message}");
        }
        return results;
    }

    // --- Helpers ------------------------------------------------------------

    private static string GetVideoReadPermissionName()
    {
        int sdk = GetSdkInt();
        // API 33+ uses media-scoped permission
        return (sdk >= 33) ? "android.permission.READ_MEDIA_VIDEO"
                           : "android.permission.READ_EXTERNAL_STORAGE";
    }

    private static int GetSdkInt()
    {
        using (var version = new AndroidJavaClass("android.os.Build$VERSION"))
        {
            return version.GetStatic<int>("SDK_INT");
        }
    }
#else
    // Stubs for non-Android / Editor so code still compiles.
    public static IEnumerator RequestVideoReadPermission() { yield break; }
    public static string GetFirstVideoContentUri() => null;
    public static List<string> GetVideoContentUris(int max = 20) => new List<string>();
#endif
}

Example usage (play the newest video)

using System.Collections;
using UnityEngine;
using UnityEngine.Video;

public class PlayFirstVideo : MonoBehaviour
{
    public VideoPlayer player;

    private void Start()
    {
        StartCoroutine(PlayNewest());
    }

    private IEnumerator PlayNewest()
    {
#if UNITY_ANDROID && !UNITY_EDITOR
        // 1) Ensure permission
        yield return AndroidVideoFinder.RequestVideoReadPermission();

        // 2) Get a content:// URI for the newest video
        string uri = AndroidVideoFinder.GetFirstVideoContentUri();
        if (string.IsNullOrEmpty(uri))
        {
            Debug.LogWarning("No videos found.");
            yield break;
        }

        // 3) Feed it to VideoPlayer
        player.source = VideoSource.Url;
        player.url = uri;                  // e.g., content://media/external/video/media/12345
        player.Prepare();
        while (!player.isPrepared) yield return null;
        player.Play();
#else
        Debug.Log("This sample runs on an Android device (Quest).");
        yield break;
#endif
    }
}

Notes

In Player Settings → Android set Target API to 33 or 34.
Add the permission to your AndroidManifest.xml via Unity:
- API 33+: <uses-permission android:name="android.permission.READ_MEDIA_VIDEO" />
- API 31–32: <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
Some devices/decoders are picky with content:// sources. If your VideoPlayer build has trouble, read the stream with ContentResolver.openInputStream() and copy it to Application.persistentDataPath, then play with a file:// URL.

Want me to include the optional “copy to sandbox then play” helper too?

Totally—query MediaStore by DISPLAY_NAME and build a content:// URI.
Drop these methods into the same AndroidVideoFinder class from before.

// Add to AndroidVideoFinder.cs (inside the UNITY_ANDROID block)

/// <summary>
/// Returns a content:// URI for the newest video whose DISPLAY_NAME matches
/// the given filename (e.g., "party.mp4"). Case-insensitive.
/// Returns null if not found.
/// </summary>
public static string GetVideoContentUriByFileName(string fileName)
{
    if (string.IsNullOrEmpty(fileName)) return null;

    // Only the leaf name matters
    string leaf = System.IO.Path.GetFileName(fileName).ToLowerInvariant();

    // 1) Exact match on DISPLAY_NAME (e.g., "party.mp4")
    string uri = QueryFirstVideoBySelection(
        "LOWER(display_name)=?",
        new[] { leaf });

    if (!string.IsNullOrEmpty(uri))
        return uri;

    // 2) Fallback: match TITLE without extension (e.g., "party")
    string title = System.IO.Path.GetFileNameWithoutExtension(leaf);
    if (!string.IsNullOrEmpty(title))
    {
        uri = QueryFirstVideoBySelection(
            "LOWER(title)=?",
            new[] { title });
        if (!string.IsNullOrEmpty(uri))
            return uri;
    }

    // 3) Last-ditch: partial match on DISPLAY_NAME (e.g., "%party%")
    return QueryFirstVideoBySelection(
        "LOWER(display_name) LIKE ?",
        new[] { "%" + title + "%" });
}

/// <summary>
/// Returns content:// URIs for up to 'max' videos whose DISPLAY_NAME contains the term.
/// Case-insensitive. Ordered newest first.
/// </summary>
public static List<string> FindVideoUrisByNameContains(string term, int max = 20)
{
    term = (term ?? "").ToLowerInvariant();
    return QueryVideoUrisBySelection(
        "LOWER(display_name) LIKE ?",
        new[] { "%" + term + "%" },
        max);
}

// ----- private helpers -----

private static string QueryFirstVideoBySelection(string selection, string[] selectionArgs)
{
    var list = QueryVideoUrisBySelection(selection, selectionArgs, 1);
    return list.Count > 0 ? list[0] : null;
}

private static List<string> QueryVideoUrisBySelection(string selection, string[] selectionArgs, int max)
{
    var results = new List<string>();

    try
    {
        using (var unityPlayer = new AndroidJavaClass("com.unity3d.player.UnityPlayer"))
        using (var activity = unityPlayer.GetStatic<AndroidJavaObject>("currentActivity"))
        using (var resolver = activity.Call<AndroidJavaObject>("getContentResolver"))
        using (var mediaStoreVideo = new AndroidJavaClass("android.provider.MediaStore$Video$Media"))
        {
            AndroidJavaObject externalUri = mediaStoreVideo.GetStatic<AndroidJavaObject>("EXTERNAL_CONTENT_URI");

            string[] projection = new[] { "_id" };                // we just need IDs
            string sortOrder = "date_added DESC";                  // newest first

            using (var cursor = resolver.Call<AndroidJavaObject>(
                "query", externalUri, projection, selection, selectionArgs, sortOrder))
            {
                if (cursor == null) return results;

                int idCol = cursor.Call<int>("getColumnIndexOrThrow", "_id");
                using (var contentUris = new AndroidJavaClass("android.content.ContentUris"))
                {
                    int count = 0;
                    bool hasRow = cursor.Call<bool>("moveToFirst");
                    while (hasRow && count < max)
                    {
                        long id = cursor.Call<long>("getLong", idCol);
                        using (var itemUri = contentUris.CallStatic<AndroidJavaObject>("withAppendedId", externalUri, id))
                        {
                            results.Add(itemUri.Call<string>("toString"));   // content://…
                        }
                        count++;
                        hasRow = cursor.Call<bool>("moveToNext");
                    }
                }
            }
        }
    }
    catch (System.Exception e)
    {
        Debug.LogWarning($"[AndroidVideoFinder] Name query failed: {e.Message}");
    }

    return results;
}

Usage: play `party.mp4` with `VideoPlayer`

using System.Collections;
using UnityEngine;
using UnityEngine.Video;

public class PlaySpecificVideo : MonoBehaviour
{
    public VideoPlayer player;

    private void Start()
    {
        StartCoroutine(PlayByName("party.mp4"));
    }

    private IEnumerator PlayByName(string fileName)
    {
#if UNITY_ANDROID && !UNITY_EDITOR
        // Ensure you requested permission first (from earlier snippet):
        yield return AndroidVideoFinder.RequestVideoReadPermission();

        string uri = AndroidVideoFinder.GetVideoContentUriByFileName(fileName);
        if (string.IsNullOrEmpty(uri))
        {
            Debug.LogWarning($"Video not found: {fileName}");
            yield break;
        }

        player.source = VideoSource.Url;
        player.url = uri;            // e.g., content://media/external/video/media/12345
        player.Prepare();
        while (!player.isPrepared) yield return null;
        player.Play();
#else
        Debug.Log("Run this on an Android device (Quest).");
        yield break;
#endif
    }
}

Notes

Works case-insensitively and returns the newest match if there are duplicates.
Requires the same permission as before:
- API 33+: android.permission.READ_MEDIA_VIDEO
- API 31–32: android.permission.READ_EXTERNAL_STORAGE
If you keep videos in your own app’s /Android/media/<your.package>/..., you can also enumerate directly via Context.getExternalMediaDirs() and skip permissions. But for general device videos, stick with MediaStore as above.

You don’t “create” the sandbox root yourself—Android gives your app its own private folders. You just ask for them and create any subfolders you want. No runtime storage permission needed.

Option A — Unity’s sandbox (works everywhere)

Application.persistentDataPath points to your app’s private files folder (e.g., /sdcard/Android/data/<package>/files). Ensure it exists and create subfolders with normal .NET IO:

using System.IO;
using UnityEngine;

public static class AppSandbox
{
    public static string EnsureSubfolder(string name)
    {
        string path = Path.Combine(Application.persistentDataPath, name);
        Directory.CreateDirectory(path);       // no-op if it already exists
        return path;                           // e.g., /sdcard/Android/data/pack/files/MyVideos
    }
}

You can then write files there and play with:

player.source = VideoSource.Url;
player.url = "file://" + Path.Combine(AppSandbox.EnsureSubfolder("MyVideos"), "party.mp4");

Option B — App-specific media folder (`/Android/media/<package>/…`)

If you want videos visible to the user/gallery without special permissions, use the app’s media dir. Grab it via a tiny Android call and create the subfolder:

#if UNITY_ANDROID && !UNITY_EDITOR
using UnityEngine;
using System.IO;

public static class AppMediaDir
{
    public static string EnsureMediaSubfolder(string name)
    {
        using (var unityPlayer = new AndroidJavaClass("com.unity3d.player.UnityPlayer"))
        using (var activity = unityPlayer.GetStatic<AndroidJavaObject>("currentActivity"))
        {
            // Prefer external media dir: /sdcard/Android/media/<package>/
            AndroidJavaObject[] mediaDirs = activity.Call<AndroidJavaObject[]>("getExternalMediaDirs");
            string basePath = null;
            if (mediaDirs != null && mediaDirs.Length > 0 && mediaDirs[0] != null)
                basePath = mediaDirs[0].Call<string>("getAbsolutePath");

            // Fallback to Movies in app files if media dir is unavailable
            if (string.IsNullOrEmpty(basePath))
            {
                using (var env = new AndroidJavaClass("android.os.Environment"))
                {
                    string movies = env.GetStatic<string>("DIRECTORY_MOVIES");
                    using (var dir = activity.Call<AndroidJavaObject>("getExternalFilesDir", movies))
                        basePath = dir.Call<string>("getAbsolutePath"); // /Android/data/<package>/files/Movies
                }
            }

            string target = Path.Combine(basePath, name);
            Directory.CreateDirectory(target);
            return target; // e.g., /sdcard/Android/media/<package>/MyVideos
        }
    }
}
#endif

If you drop/copy party.mp4 there and want it to show up in the Gallery/MediaStore, nudge the scanner:

#if UNITY_ANDROID && !UNITY_EDITOR
using UnityEngine;
public static class MediaScan
{
    public static void ScanFile(string absolutePath)
    {
        using (var unityPlayer = new AndroidJavaClass("com.unity3d.player.UnityPlayer"))
        using (var activity = unityPlayer.GetStatic<AndroidJavaObject>("currentActivity"))
        using (var mediaScanner = new AndroidJavaClass("android.media.MediaScannerConnection"))
        {
            mediaScanner.CallStatic("scanFile", activity, new string[] { absolutePath }, null, null);
        }
    }
}
#endif

Which should you use?

Use persistentDataPath for internal app data or temporary copies.
Use /Android/media/<package> when you want user-visible media without extra permissions.

Either way, you just Directory.CreateDirectory(...) to “create” the folder you need.

Got it—since your videos are too large for the APK, you’ve got a few solid patterns on Quest:

Stream over HTTPS directly into VideoPlayer.url (no storage, depends on network).
Download → cache → play from your app’s sandbox (no runtime storage permission).
Download into your app’s media dir (/Android/media/<package>/…) so users can see/manage files in Gallery (still no runtime permission for your own package).
Let the user pick a file via SAF and then play/copy (needs a tiny plugin/UI flow).

Below are ready-to-paste snippets for #2 and #3.

A) Download → cache in sandbox, then play

No permissions needed; works everywhere.

using System.Collections;
using System.IO;
using UnityEngine;
using UnityEngine.Networking;
using UnityEngine.Video;

public class VideoDownloadAndPlay : MonoBehaviour
{
    public VideoPlayer player;

    // Call this with a direct URL to your MP4 (HTTPS recommended)
    public void StartDownloadAndPlay(string videoUrl, string fileName = "video.mp4")
    {
        StartCoroutine(DownloadAndPlay(videoUrl, fileName));
    }

    private IEnumerator DownloadAndPlay(string videoUrl, string fileName)
    {
        string dir = Application.persistentDataPath; // /Android/data/<pkg>/files
        Directory.CreateDirectory(dir);
        string path = Path.Combine(dir, fileName);

        // Stream download straight to file to avoid big memory spikes
        using (UnityWebRequest req = new UnityWebRequest(videoUrl, UnityWebRequest.kHttpVerbGET))
        {
            req.downloadHandler = new DownloadHandlerFile(path) { removeFileOnAbort = true };
            yield return req.SendWebRequest();

            if (req.result != UnityWebRequest.Result.Success)
            {
                Debug.LogError("Download failed: " + req.error);
                yield break;
            }
        }

        // Play from file://
        player.source = VideoSource.Url;
        player.url = "file://" + path;
        player.Prepare();
        while (!player.isPrepared) yield return null;
        player.Play();
    }
}

B) Download into `/Android/media/<package>/Videos`, then play

Still no runtime permission for your own package dir; files are user-visible. (If you want them to appear in Gallery, ping the media scanner once saved.)

#if UNITY_ANDROID && !UNITY_EDITOR
using UnityEngine;
using System.IO;

public static class AppMediaDir
{
    // Returns: /sdcard/Android/media/<package>/Videos
    public static string EnsureVideosDir()
    {
        using (var unityPlayer = new AndroidJavaClass("com.unity3d.player.UnityPlayer"))
        using (var activity = unityPlayer.GetStatic<AndroidJavaObject>("currentActivity"))
        {
            // Preferred: external media dir
            AndroidJavaObject[] mediaDirs = activity.Call<AndroidJavaObject[]>("getExternalMediaDirs");
            string basePath = (mediaDirs != null && mediaDirs.Length > 0 && mediaDirs[0] != null)
                ? mediaDirs[0].Call<string>("getAbsolutePath")
                : null;

            if (string.IsNullOrEmpty(basePath))
            {
                // Fallback to app Movies dir
                using (var env = new AndroidJavaClass("android.os.Environment"))
                {
                    string movies = env.GetStatic<string>("DIRECTORY_MOVIES");
                    using (var dir = activity.Call<AndroidJavaObject>("getExternalFilesDir", movies))
                        basePath = dir.Call<string>("getAbsolutePath"); // /Android/data/<pkg>/files/Movies
                }
            }

            string videosDir = Path.Combine(basePath, "Videos");
            Directory.CreateDirectory(videosDir);
            return videosDir;
        }
    }

    // Ask MediaScanner so Gallery/MediaStore sees the new file
    public static void ScanFile(string absolutePath)
    {
        using (var unityPlayer = new AndroidJavaClass("com.unity3d.player.UnityPlayer"))
        using (var activity = unityPlayer.GetStatic<AndroidJavaObject>("currentActivity"))
        using (var mediaScanner = new AndroidJavaClass("android.media.MediaScannerConnection"))
        {
            mediaScanner.CallStatic("scanFile", activity, new string[] { absolutePath }, null, null);
        }
    }
}
#endif

using System.Collections;
using System.IO;
using UnityEngine;
using UnityEngine.Networking;
using UnityEngine.Video;

public class VideoDownloadToMediaDir : MonoBehaviour
{
    public VideoPlayer player;

    public void StartDownloadAndPlay(string videoUrl, string fileName)
    {
        StartCoroutine(DownloadToMediaDirAndPlay(videoUrl, fileName));
    }

    private IEnumerator DownloadToMediaDirAndPlay(string videoUrl, string fileName)
    {
#if UNITY_ANDROID && !UNITY_EDITOR
        string dir = AppMediaDir.EnsureVideosDir();
        string path = Path.Combine(dir, fileName);

        using (UnityWebRequest req = new UnityWebRequest(videoUrl, UnityWebRequest.kHttpVerbGET))
        {
            req.downloadHandler = new DownloadHandlerFile(path) { removeFileOnAbort = true };
            yield return req.SendWebRequest();

            if (req.result != UnityWebRequest.Result.Success)
            {
                Debug.LogError("Download failed: " + req.error);
                yield break;
            }
        }

        // Make it visible to Gallery/MediaStore
        AppMediaDir.ScanFile(path);

        // Play from file:// path
        var playerComp = player ?? GetComponent<VideoPlayer>();
        playerComp.source = VideoSource.Url;
        playerComp.url = "file://" + path;
        playerComp.Prepare();
        while (!playerComp.isPrepared) yield return null;
        playerComp.Play();
#else
        Debug.Log("Run on Android (Quest).");
        yield break;
#endif
    }
}

Tips & gotchas

No legacy permissions: You don’t need READ_MEDIA_VIDEO or READ_EXTERNAL_STORAGE when reading files you downloaded into your sandbox or your own /Android/media/<package> directory. Permissions are only for reading other apps’ media (via MediaStore).
Disk space: Before big downloads, check free space (e.g., StatFs) and show a friendly error if low.
Resume support: For very large files, add HTTP range requests to resume partial downloads.
Playback source: If VideoPlayer ever struggles with file://, it also accepts content:// URIs (from MediaStore). For your own files, file:// is simplest.

If you tell me how you’ll ship the videos (CDN URLs? user sideloads? in-app downloads?), I can tailor the download/resume + indexing flow exactly to your setup.

Short answer: yes—the break is almost certainly due to Quest’s move to an Android-14 base between v74 and v79 (the jump happened at v76), which changes how media/file permissions work.

Official sources to back this up

Meta’s own developer docs note that features requiring Android 14 (API 34) are “available on HzOS v76+,” explicitly tying Horizon OS v76 and later to Android 14. That’s a first-party confirmation of the Android-14 base from v76 onward. citeturn4search0turn4search2
Google’s official Android docs explain the relevant behavior changes: on Android 13+ you must use the granular media permissions (READ_MEDIA_VIDEO, etc.) and/or MediaStore/SAF—legacy READ/WRITE_EXTERNAL_STORAGE no longer works the way it did, which directly affects apps that used raw file paths. Android 14 adds further tweaks like partial photo/video access. citeturn7search0turn7search13
Meta’s public v79 help page confirms the v79 rollout (though it doesn’t re-hash Android internals). Your “works on v74, fails on v79” observation lines up with the v76→Android 14 transition. citeturn0search3

What this means for your Unity app

If you were loading videos via file paths from shared storage (e.g., /sdcard/... or another app’s folder under /Android/media), that can fail on v76+ unless you:
- request READ_MEDIA_VIDEO (API 33+) and
- access files via MediaStore (get a content:// URI), not raw paths. citeturn7search0
Your own package’s folders (e.g., Application.persistentDataPath or /Android/media/<your.package>/…) are still accessible without extra permissions, but many projects were implicitly reading from broader locations that now require the new flow. citeturn7search0

If you want, I can adapt the earlier C# to: (a) request READ_MEDIA_VIDEO, (b) query MediaStore by filename (e.g., party.mp4), and (c) feed a content:// URI into VideoPlayer—that’s the Android-14-safe path.

my old script was using ” const string androidRoot = “/storage/emulated/0/Android/media/”;

and then

public void LoadVideo() { // Is there a video filename provided? var videoFile = scenes[activeSceneIndex].video;

        if (string.IsNullOrEmpty(videoFile))
            return;

        var url = androidRoot + videoFile + ".mp4";

        if (videoPlayer != null)
        {
            StartVid(videoPlayer, url);
        }
    }

Yeah—that hardcoded path is what breaks on v76+ (Android 14). Don’t build /storage/emulated/0/Android/media/... strings yourself. Instead:

If the file is inside your own app’s media dir (/Android/media/<your.package>/...), play it via a file:// URL after resolving that directory dynamically.
Otherwise, find it via MediaStore by DISPLAY_NAME (e.g., party.mp4) and play the returned content:// URI (with READ_MEDIA_VIDEO on API 33+).

Here’s a drop-in replacement that tries both paths, works on v74 and v79, and keeps your scenes[activeSceneIndex].video logic.

using System.Collections;
using System.Collections.Generic;
using System.IO;
using UnityEngine;
using UnityEngine.Video;

public class QuestVideoCompatLoader : MonoBehaviour
{
    public VideoPlayer videoPlayer;
    public List<SceneInfo> scenes;
    public int activeSceneIndex = 0;

    [System.Serializable]
    public class SceneInfo { public string video; } // "party" (without .mp4) or "party.mp4"

    public void LoadVideo()
    {
        var videoFile = scenes[activeSceneIndex].video;
        if (string.IsNullOrEmpty(videoFile)) return;

        StartCoroutine(LoadAndPlayCompat(videoFile));
    }

    private IEnumerator LoadAndPlayCompat(string nameOrFile)
    {
#if UNITY_ANDROID && !UNITY_EDITOR
        string leaf = Path.GetFileName(nameOrFile);
        if (!leaf.EndsWith(".mp4")) leaf += ".mp4";

        // 1) Try your OWN app's media dir: /Android/media/<package>/
        string ownPath = GetOwnAppMediaPath(leaf); // absolute filesystem path
        if (!string.IsNullOrEmpty(ownPath) && File.Exists(ownPath))
        {
            PlayUrl("file://" + ownPath);
            yield break;
        }

        // 2) Otherwise, search all device videos via MediaStore and play content:// URI
        yield return RequestVideoReadPermissionIfNeeded();
        string contentUri = AndroidVideoFinder_GetVideoContentUriByFileName(leaf);
        if (!string.IsNullOrEmpty(contentUri))
        {
            PlayUrl(contentUri); // content://media/external/video/media/12345
            yield break;
        }

        Debug.LogWarning($"Video not found: {leaf}. Checked own media dir and MediaStore.");
        yield break;
#else
        Debug.Log("Run this on an Android device (Quest).");
        yield break;
#endif
    }

    private void PlayUrl(string url)
    {
        if (videoPlayer == null) { Debug.LogError("VideoPlayer not set."); return; }
        videoPlayer.source = VideoSource.Url;
        videoPlayer.url = url;
        videoPlayer.Play();
    }

#if UNITY_ANDROID && !UNITY_EDITOR
    // ---- Own app media dir (no permission needed for your package) ----
    private static string GetOwnAppMediaPath(string fileLeaf)
    {
        try
        {
            using (var unityPlayer = new AndroidJavaClass("com.unity3d.player.UnityPlayer"))
            using (var activity = unityPlayer.GetStatic<AndroidJavaObject>("currentActivity"))
            {
                AndroidJavaObject[] mediaDirs = activity.Call<AndroidJavaObject[]>("getExternalMediaDirs");
                if (mediaDirs != null && mediaDirs.Length > 0 && mediaDirs[0] != null)
                {
                    string basePath = mediaDirs[0].Call<string>("getAbsolutePath"); // /sdcard/Android/media/<pkg>/
                    if (!string.IsNullOrEmpty(basePath))
                    {
                        // If you keep videos in a subfolder, add it here:
                        // string basePath = Path.Combine(basePath, "Videos");
                        return Path.Combine(basePath, fileLeaf);
                    }
                }
            }
        }
        catch { /* ignore */ }
        return null;
    }

    // ---- Permission helper (needed only for reading other apps' media via MediaStore) ----
    private static IEnumerator RequestVideoReadPermissionIfNeeded()
    {
        string perm = GetVideoReadPermissionName();
        if (UnityEngine.Android.Permission.HasUserAuthorizedPermission(perm))
            yield break;

        UnityEngine.Android.Permission.RequestUserPermission(perm);
        // Unity has no callback; give one frame to settle (or loop if you prefer).
        yield return null;
    }

    private static string GetVideoReadPermissionName()
    {
        int sdk;
        using (var version = new AndroidJavaClass("android.os.Build$VERSION"))
            sdk = version.GetStatic<int>("SDK_INT");
        return (sdk >= 33) ? "android.permission.READ_MEDIA_VIDEO" : "android.permission.READ_EXTERNAL_STORAGE";
    }

    // ---- Minimal MediaStore query by DISPLAY_NAME (case-insensitive) ----
    private static string AndroidVideoFinder_GetVideoContentUriByFileName(string fileName)
    {
        try
        {
            string leaf = Path.GetFileName(fileName).ToLowerInvariant();

            using (var unityPlayer = new AndroidJavaClass("com.unity3d.player.UnityPlayer"))
            using (var activity = unityPlayer.GetStatic<AndroidJavaObject>("currentActivity"))
            using (var resolver = activity.Call<AndroidJavaObject>("getContentResolver"))
            using (var mediaStoreVideo = new AndroidJavaClass("android.provider.MediaStore$Video$Media"))
            using (var contentUris = new AndroidJavaClass("android.content.ContentUris"))
            {
                AndroidJavaObject externalUri = mediaStoreVideo.GetStatic<AndroidJavaObject>("EXTERNAL_CONTENT_URI");
                string[] projection = new[] { "_id" };
                string sortOrder = "date_added DESC";

                // Exact match on DISPLAY_NAME
                using (var cursor = resolver.Call<AndroidJavaObject>(
                    "query",
                    externalUri,
                    projection,
                    "LOWER(display_name)=?",
                    new string[] { leaf },
                    sortOrder))
                {
                    if (cursor != null && cursor.Call<bool>("moveToFirst"))
                    {
                        int idCol = cursor.Call<int>("getColumnIndexOrThrow", "_id");
                        long id = cursor.Call<long>("getLong", idCol);
                        using (var itemUri = contentUris.CallStatic<AndroidJavaObject>("withAppendedId", externalUri, id))
                            return itemUri.Call<string>("toString");
                    }
                }

                // Fallback: match by TITLE (filename without extension)
                string title = Path.GetFileNameWithoutExtension(leaf);
                if (!string.IsNullOrEmpty(title))
                {
                    using (var cursor = resolver.Call<AndroidJavaObject>(
                        "query",
                        externalUri,
                        projection,
                        "LOWER(title)=?",
                        new string[] { title },
                        sortOrder))
                    {
                        if (cursor != null && cursor.Call<bool>("moveToFirst"))
                        {
                            int idCol = cursor.Call<int>("getColumnIndexOrThrow", "_id");
                            long id = cursor.Call<long>("getLong", idCol);
                            using (var itemUri = contentUris.CallStatic<AndroidJavaObject>("withAppendedId", externalUri, id))
                                return itemUri.Call<string>("toString");
                        }
                    }
                }
            }
        }
        catch (System.Exception e)
        {
            Debug.LogWarning("[QuestVideoCompatLoader] MediaStore query failed: " + e.Message);
        }
        return null;
    }
#endif
}

How to adjust your project

Delete the hardcoded androidRoot and path concatenation.
Put your large videos either:
- in your own app media folder (/Android/media/<your.package>/...) so you can play them with file:// and no permission, or
- anywhere the user places them, and then find them via MediaStore (needs READ_MEDIA_VIDEO on API 33+).
In AndroidManifest (Unity → Player Settings → Publishing), include:
- API 33+: <uses-permission android:name="android.permission.READ_MEDIA_VIDEO" />
- API 31–32: <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />

This keeps your app working on both Quest OS v74 and v79 without relying on raw filesystem paths.

Short answer: the folder doesn’t exist until something creates it. Your app (or you via adb/SideQuest) should create /sdcard/Android/media/<your.package>/… the first time you need it.

What to do in your Unity app (recommended)

Create it on first run before you write or look for videos. No special permission needed for your own package dir.

#if UNITY_ANDROID && !UNITY_EDITOR
using UnityEngine;
using System.IO;

public static class AppMediaDir
{
    // e.g. returns /sdcard/Android/media/com.yourcompany.yourapp/Videos (created if missing)
    public static string EnsureVideosDir(string subfolder = "Videos")
    {
        using (var unityPlayer = new AndroidJavaClass("com.unity3d.player.UnityPlayer"))
        using (var activity = unityPlayer.GetStatic<AndroidJavaObject>("currentActivity"))
        {
            AndroidJavaObject[] mediaDirs = activity.Call<AndroidJavaObject[]>("getExternalMediaDirs");
            string basePath = (mediaDirs != null && mediaDirs.Length > 0 && mediaDirs[0] != null)
                ? mediaDirs[0].Call<string>("getAbsolutePath")  // /sdcard/Android/media/<your.package>/
                : null;

            if (string.IsNullOrEmpty(basePath))
            {
                // Fallback: /sdcard/Android/data/<your.package>/files/Movies
                using (var env = new AndroidJavaClass("android.os.Environment"))
                {
                    string movies = env.GetStatic<string>("DIRECTORY_MOVIES");
                    using (var dir = activity.Call<AndroidJavaObject>("getExternalFilesDir", movies))
                        basePath = dir.Call<string>("getAbsolutePath");
                }
            }

            string path = string.IsNullOrEmpty(subfolder) ? basePath : Path.Combine(basePath, subfolder);
            Directory.CreateDirectory(path);  // creates anything missing
            return path;
        }
    }
}
#endif

Use it when saving or searching:

string videosDir = AppMediaDir.EnsureVideosDir();               // creates /Android/media/<pkg>/Videos
string fullPath  = Path.Combine(videosDir, "party.mp4");

If you want to preload videos before the user ever launches the app

Because the folder won’t exist yet, create it yourself via adb (or SideQuest) on your dev PC:

# Replace with your actual package name
PKG=com.yourcompany.yourapp
adb shell "mkdir -p /sdcard/Android/media/$PKG/Videos"
adb push party.mp4 /sdcard/Android/media/$PKG/Videos/

# (optional) index it so Gallery/MediaStore sees it immediately
adb shell "cmd media scan -d /sdcard/Android/media/$PKG/Videos/party.mp4"

SideQuest can also create folders and push files through its UI.

Notes & pitfalls

Make sure the package name in Unity (Player Settings → Identification) matches what you use for sideloading; changing it changes the folder path.
Don’t place a .nomedia file in this directory if you want videos to appear in Gallery/MediaStore.
For playback: VideoPlayer.url = "file://" + fullPath; works for files you put in your own package directory. For videos outside your package, use MediaStore + READ_MEDIA_VIDEO and feed a content:// URI instead.

So: yes—either create the folder at runtime (best), or create it yourself when you upload the videos (adb/SideQuest). Both are valid.

Nice—thanks for the screenshot. With that package name and Target API 33, here’s exactly what to do so Quest v79 works:

1) Folder you should use

Your app-specific media dir will be:

/sdcard/Android/media/com.unchartedlimbo.homecoming/

Create a subfolder for your videos (e.g. Videos) at runtime before you read/write:

#if UNITY_ANDROID && !UNITY_EDITOR
using UnityEngine;
using System.IO;

public static class AppMediaDir {
    public static string EnsureVideosDir() {
        using (var up = new AndroidJavaClass("com.unity3d.player.UnityPlayer"))
        using (var act = up.GetStatic<AndroidJavaObject>("currentActivity")) {
            AndroidJavaObject[] mediaDirs = act.Call<AndroidJavaObject[]>("getExternalMediaDirs");
            string basePath = (mediaDirs != null && mediaDirs.Length > 0 && mediaDirs[0] != null)
                ? mediaDirs[0].Call<string>("getAbsolutePath")    // /sdcard/Android/media/com.unchartedlimbo.homecoming
                : null;
            if (string.IsNullOrEmpty(basePath)) return null;      // extreme fallback: use persistentDataPath instead
            string dir = Path.Combine(basePath, "Videos");
            Directory.CreateDirectory(dir);
            return dir;
        }
    }
}
#endif

Then play files you put there:

string dir = AppMediaDir.EnsureVideosDir();
string path = System.IO.Path.Combine(dir, "party.mp4");
videoPlayer.source = VideoSource.Url;
videoPlayer.url = "file://" + path;   // works for your own package’s folder
videoPlayer.Play();

2) Unity Player settings/manifest

Target API Level: 33 (Android 13) is fine on Quest v79 (Android 14).
Minimum API 29: fine.
Permissions:
- If you only read from your own /Android/media/com.unchartedlimbo.homecoming/..., no runtime permission is needed.
- If you also browse videos outside your package, add to your manifest:
```
<uses-permission android:name="android.permission.READ_MEDIA_VIDEO" />
```
  and query via MediaStore (returning content:// URIs), not hardcoded paths.
In Player Settings → Publishing Settings → Write Permission, choose Internal (don’t request legacy external storage).

3) Preloading from your PC (optional)

If you want to push files before first launch:

PKG=com.unchartedlimbo.homecoming
adb shell "mkdir -p /sdcard/Android/media/$PKG/Videos"
adb push party.mp4 /sdcard/Android/media/$PKG/Videos/

4) Why your old code broke

Hardcoding /storage/emulated/0/Android/media/... and concatenating filenames skips Android’s app-specific resolution and (on v76+) can fail when the folder doesn’t exist yet or when you try to read outside your package. Resolving the app media dir dynamically (above) makes it work on both v74 and v79.

If you also need a fallback to find user-supplied videos anywhere on the device, say the word and I’ll add the MediaStore-by-name lookup that returns a content:// URL.

Short version: you don’t strictly “need” file:// because of Quest v79—what changed is how Unity/Android interpret the string you pass to VideoPlayer.url and where your files live.

What’s going on

VideoPlayer.source = VideoSource.Url expects a URL, not a bare filesystem path.
- Local files → use a file:// URL (e.g., file:///sdcard/Android/media/<pkg>/Videos/party.mp4).
- Device media via MediaStore → use a content:// URI.
On older builds (v74/older Android base), passing a raw path like /storage/emulated/0/... sometimes worked by accident—Unity/Android were lenient and treated it as a file path. On newer builds (v76+ / Android 14), URI parsing is stricter and the same string may no longer be recognized as a valid source when you’ve told Unity “this is a URL”.
Separately, scoped storage tightened access to shared paths. If you were pointing at /Android/media/... outside your own package, the read may fail now unless you use MediaStore (which gives you a content://), so your old plain path would break regardless of file://.

Rules of thumb (works on v74 and v79)

Files your app owns (e.g., /sdcard/Android/media/<your.package>/Videos/party.mp4):
→ videoPlayer.source = VideoSource.Url;
→ videoPlayer.url = "file://" + absolutePath;
Files anywhere else on the device (user library):
→ query MediaStore to find it,
→ set videoPlayer.url = contentUriString; (no file://),
→ request READ_MEDIA_VIDEO on API 33+.

So: it’s not that v79 “requires” file://. It’s that URL mode needs a proper scheme, and with newer Android the lax fallback stopped working. Use file:// for local files you can read directly, and content:// for everything discovered via MediaStore.

Totally fine—you can use the folder as-is and never create it from code. Two important notes first:

Your screenshot showed com.unchartedlimbo.homecoming, but you said you created
…/Android/media/**com.ulc.homecoming**/Videos.
Those are different package names. Android treats them as different apps, so your app will NOT have the “own-app” access to the com.ulc.homecoming folder. Make sure the Unity package name exactly matches the folder you created.
Windows Explorer (MTP) sometimes shows folders that the device hasn’t indexed yet. If a file “exists” on PC but your app can’t see it, trigger a media scan (code below) or unplug/replug.

Here’s a safe loader that doesn’t create anything—it only resolves your app’s media dir, checks for the file, and plays it. If the file isn’t there, it doesn’t try to make folders; it simply logs.

using System.IO;
using UnityEngine;
using UnityEngine.Video;

public class PlayFromPrecreatedMediaDir : MonoBehaviour
{
    public VideoPlayer player;

    public void PlayVideoInPrecreatedDir(string fileName) // e.g., "party.mp4"
    {
#if UNITY_ANDROID && !UNITY_EDITOR
        string dir = GetOwnMediaDirPath(); // does NOT create
        if (string.IsNullOrEmpty(dir))
        {
            Debug.LogError("App media directory not available.");
            return;
        }

        string path = Path.Combine(dir, "Videos");               // your pre-made subfolder
        string full = Path.Combine(path, fileName);

        if (!File.Exists(full))
        {
            Debug.LogError($"File not found at: {full}");
            return;
        }

        player.source = VideoSource.Url;
        player.url = "file://" + full;                           // required scheme
        player.Play();
#else
        Debug.Log("Run on an Android device (Quest).");
#endif
    }

#if UNITY_ANDROID && !UNITY_EDITOR
    // Returns /sdcard/Android/media/<your.package>
    private static string GetOwnMediaDirPath()
    {
        try
        {
            using (var up = new AndroidJavaClass("com.unity3d.player.UnityPlayer"))
            using (var act = up.GetStatic<AndroidJavaObject>("currentActivity"))
            {
                AndroidJavaObject[] mediaDirs = act.Call<AndroidJavaObject[]>("getExternalMediaDirs");
                if (mediaDirs != null && mediaDirs.Length > 0 && mediaDirs[0] != null)
                    return mediaDirs[0].Call<string>("getAbsolutePath"); // no creation here
            }
        }
        catch { }
        return null;
    }
#endif
}

If files don’t show up (MTP quirk)

Sometimes files pushed via Windows Explorer aren’t indexed yet. You can politely scan them (no folder creation):

#if UNITY_ANDROID && !UNITY_EDITOR
public static class MediaScanOnce
{
    public static void Scan(string absolutePath)
    {
        using (var up = new AndroidJavaClass("com.unity3d.player.UnityPlayer"))
        using (var act = up.GetStatic<AndroidJavaObject>("currentActivity"))
        using (var ms = new AndroidJavaClass("android.media.MediaScannerConnection"))
        {
            ms.CallStatic("scanFile", act, new string[]{ absolutePath }, null, null);
        }
    }
}
#endif

Call MediaScanOnce.Scan(fullPath); after you copy files over (or just once on first run) to ensure the device “sees” them.

Quick checklist

✅ Unity Package Name matches the folder you created exactly.
✅ Files live at:
/sdcard/Android/media/<that-exact-package>/Videos/<filename>.mp4
✅ Use file:// with the absolute path for VideoPlayer.url.
🔎 If the app can’t see files you copied from Windows, run a media scan or reconnect the headset.

No directory creation happens in the snippet above—so you’re aligned with your requirement.