Google Daydream / Cardboard builds: detect and warn (GitHub #335)

Analysis extra.google_vr (ANALYSIS_VERSION 20): manifest DAYDREAM/CARDBOARD
categories, enableVrMode=com.google.vr.vrcore, libgvr.so / Cardboard SDK libs,
GVR Java classes, Unity vr-device-list (not libgvraudio.so, which Quest games
ship too). A build without Oculus support gets a warning (recipe notes, CLI,
game page); never unsupported from the manifest. Triage gvr-not-supported for
Unity's 'Google VR Error', the bridge's missing CardboardViewNativeImpl and
VrCore binds. PLAYBOOK row, tests.

catalog/triage.yaml

@@ -71,6 +71,13 @@ signatures:
     severity: fatal
     diagnosis: This app is a website, not a game, and it can't open on the Frame. It is a Trusted Web Activity that opens Meta's browser (com.oculus.browser), which the Frame doesn't have; open the website (TWALauncherActivity's "Using URL" line) in a browser instead.
     suggest: []
+  - id: gvr-not-supported
+    # GitHub #335 (Blade Runner: Revelations, Daydream, Unity 2017.4): Unity's "Google VR Error [Daydream]", the GVR
+    # library's Java side missing on the 32-bit bridge, or a bind to Daydream's VrCore service
+    pattern: 'Google VR Error \[(Daydream|Cardboard)\]|Google VR had a fatal issue while loading|class com/google/vr/sdk/base/CardboardViewNativeImpl not found|act=com\.google\.vr\.vrcore\.\S+ pkg=com\.google\.vr\.vrcore'
+    severity: fatal
+    diagnosis: This is a Google Daydream / Cardboard VR build (Google VR SDK), and its VR can't reach the Frame's headset. Daydream needs Google's VR services (VrCore) and Cardboard draws for a phone in a viewer; FramePort has no translation for either, so the game runs as a flat window at best, usually without working controls. An Oculus build of the same game (Meta Quest, Oculus Go or Gear VR) goes through FramePort's normal path.
+    suggest: []
   - id: unity-render-crash
     pattern: 'CRASH\s*:.*#\d+\s+pc [0-9a-f]+\s+\S*libgallium_dri\.so'
     severity: fatal

docs/PLAYBOOK.md

@@ -87,6 +87,7 @@ version is `catalog/triage.yaml` (used by `frameport test` / the Job screen); ke
 | 32-bit Unity game on the bridge: player stands in the floor (Spunky Dungeon) | Unity's floor-level tracking origin: `vrapi_SetTrackingSpace(1)` (LOCAL_FLOOR) was ignored | The VrApi bridge puts the origin on the STAGE floor for LOCAL_FLOOR/STAGE |
 | Crash at start: `NoClassDefFoundError: … Landroid/window/OnBackInvokedCallback;` or `NoSuchMethodError: No static method storeStoreFence()V in class Ljava/lang/invoke/VarHandle;` (GitHub #71/#72, triage `android-too-new`) | The APK needs Android 13+ (minSdk 33 or more; those were 34) and calls its classes at start; Lepton's Android is 11 (API 30). OVRPort lowers minSdk to 29, so it installs anyway. minSdk ≤ 32 (Quest's Android 12L) is fine: 16 working catalog games declare 32 | None (analysis `extra.min_sdk` > 32 → a warning on the game page/CLI and in the recipe notes; never unsupported from the manifest alone, the launch test's triage decides). Waits for Valve to update Lepton's Android |
 | Nothing opens; `TWALauncherActivity: Using URL from Manifest (https://…)`, `Creating TwaLauncher for com.oculus.browser`, `NameNotFoundException: com.oculus.browser` (GitHub #86 Mahjong Table VR, triage `web-wrapper`) | The APK is a Trusted Web Activity (Bubblewrap / Meta's PWA packaging): a website that opens in Meta's browser, which Lepton doesn't have | None: open the URL in a browser. Analysis `extra.web_wrapper` (manifest meta-data `android.support.customtabs.trusted.DEFAULT_URL`, resolved through resources.arsc, or androidbrowserhelper's LauncherActivity) → a warning with the URL (not unsupported: the manifest alone never decides) |
+| A flat window, no VR and no way to interact; `Google VR Error [Daydream]: Google VR had a fatal issue while loading`, `class com/google/vr/sdk/base/CardboardViewNativeImpl not found` (32-bit bridge), `Unable to start service Intent { act=com.google.vr.vrcore.… }` (GitHub #335 Blade Runner: Revelations, triage `gvr-not-supported`) | A Google Daydream / Cardboard build: Google's VR SDK (GVR, `libgvr.so`) or the Cardboard SDK. Daydream needs Google's VrCore service, Cardboard draws a distorted side-by-side image for a phone screen; neither reaches OpenXR, the Frame's only way into the headset | None: get the game's Oculus build (Quest, Go or Gear VR), which goes through the normal path. Analysis `extra.google_vr` (`daydream`/`cardboard`: manifest categories `com.google.intent.category.DAYDREAM`/`CARDBOARD`, `enableVrMode="com.google.vr.vrcore/…"`, `libgvr.so`/Cardboard SDK libraries, GVR Java classes, Unity `vr-device-list`; not `libgvraudio.so`, which Quest games ship too) → a warning on the game page/CLI and in the recipe notes, only when the APK has no Oculus support; never unsupported from the manifest alone. A GVR → OpenXR shim (like the VrApi bridge) is possible in principle but not built |
 | `UnsatisfiedLinkError` / `cannot locate symbol "ovr_…"` | overport's platform loader lacks Meta platform functions | `frame.ovrstubs` (automatic, generated stubs) |
 | missing `ovrMessageType_ToString` | same, but the game needs a real string | `frame.ovrplatformcompat` (automatic) |
 | The game stays in its built-in language or waits at start although its OBB / files hold language packs (`<tag>.lang`, for example `de.lang`) | overport's platform loader answers `ovr_LanguagePack_GetCurrent/SetCurrent` with request id 0, so the game never gets the pack's path | `frame.langpacks` (opt-in, experimental, shown for games whose data has `*.lang`; `native/langpack`, build it with `python native/build.py --only langpack`). Default pack: the one the game applies, else env `FRAMEPORT_LANGPACK=<tag>`, else the only pack; search path override `FRAMEPORT_LANGPACK_DIRS`. Unreal games (Deadpool VR) gray out a pack whose asset `Metadata` differs from the game's version string: the patch writes the APK's versionName as Metadata (env `FRAMEPORT_LANGPACK_META` overrides) and reports the pack under the `/storage/emulated/0/Android/obb/<pkg>/` spelling of its path; with `/sdcard/…` the text switched but the dialogue stayed silent (verified in the headset with Deadpool VR) |

src/frameport/analysis/detect.py

@@ -43,7 +43,10 @@ IL2CPP_METADATA = "assets/bin/Data/Managed/Metadata/global-metadata.dat"
 # 17: headset (the Meta headset a VR app was made for: Gear VR / Go games run through frame.a32_bridge) (2026-10)
 # 18: headset "quest" also for 32-bit apps that require 6DoF head tracking (Santa Cruz builds, e.g. Sports
 #     Scramble: Touch controllers on the a32 bridge) (2026-10)
-ANALYSIS_VERSION = 19
+# 19: unreal_obb_delivery also for obfuscated DownloaderActivity predicates (GitHub #159) (2026-10)
+# 20: google_vr (Google Daydream / Cardboard builds: GVR or Cardboard SDK, no path to the Frame's headset,
+#     GitHub #335) (2026-10)
+ANALYSIS_VERSION = 20
 
 
 # Android versions by API level (for messages); the Frame's Lepton container runs Android 11 (API 30)
@@ -197,6 +200,32 @@ def vr_kind(libs: set[str], manifest_strings: list[str]) -> str:
     return "none"
 
 
+# Google VR (Daydream / Cardboard): the manifest categories of a Daydream / Cardboard app, Daydream's VR service
+# (android:enableVrMode="com.google.vr.vrcore/..."), the GVR SDK's library and the Cardboard SDK's
+# (github.com/googlevr/cardboard), and the GVR SDK's Java classes. Not libgvraudio.so / Unity's
+# libaudioplugingvrunity.so: Google's spatial audio, which Quest games ship too (e.g. Shadow Point).
+DAYDREAM_CATEGORY = "com.google.intent.category.DAYDREAM"
+CARDBOARD_CATEGORY = "com.google.intent.category.CARDBOARD"
+GOOGLE_VR_LIBS = {"libgvr.so", "libcardboard_api.so", "libGfxPluginCardboard.so"}
+GVR_DEX_MARKERS = (b"Lcom/google/vr/ndk/base/GvrLayout;", b"Lcom/google/vr/sdk/base/GvrView;",
+                   b"Lcom/google/vr/sdk/base/GvrActivity;", b"Lcom/google/cardboard/sdk/")
+
+
+def google_vr(libs: set[str], cats: set[str], manifest_strings: list[str], gvr_java: bool = False,
+              boot: str = "") -> str:
+    """A Google VR app: "daydream" (Daydream: needs Google's VR services, VrCore), "cardboard" (Cardboard: draws
+    both eyes side by side with lens distortion onto a phone screen) or "" (neither). Neither has a path to the
+    Frame's headset: a Lepton app only reaches it through OpenXR (VrApi / OVRPlugin games are translated to it).
+    `boot` = Unity's boot.config (vr-device-list=, where Unity builds list their VR devices)."""
+    devices = next((ln.split("=", 1)[1].lower() for ln in boot.splitlines() if ln.startswith("vr-device-list=")), "")
+    if (DAYDREAM_CATEGORY in cats or any(s.startswith("com.google.vr.vrcore") for s in manifest_strings)
+            or "daydream" in devices):
+        return "daydream"
+    if CARDBOARD_CATEGORY in cats or "cardboard" in devices or libs & GOOGLE_VR_LIBS or gvr_java:
+        return "cardboard"
+    return ""
+
+
 # Kotlin's message for a failed non-null cast to ClipboardManager (Godot 4.2-4.4; 4.1 is Java, 4.5+ uses `as?`)
 GODOT_CLIPBOARD_CAST = b"null cannot be cast to non-null type android.content.ClipboardManager"
 
@@ -249,6 +278,8 @@ def analyze(path: Path, deep: bool = True, data_bytes: int | None = None) -> Ana
                                   for d in dexes)
         # video through Android's decoders (frame.hw_video_decode): Java MediaCodec, ExoPlayer/Media3, or libVLC
         media_codec = any(m in d for d in dexes for m in MEDIA_CODEC_MARKERS) or "libvlc.so" in libs
+        # Google VR's Java side (GvrLayout / GvrView, the Cardboard SDK): a Daydream / Cardboard app (google_vr)
+        gvr_java = any(m in d for d in dexes for m in GVR_DEX_MARKERS)
         from ..patches.frame.unreal_obb_check import has_delivery_check
 
         # Includes obfuscated DownloaderActivity predicates; CRC verification is a separate manifest switch.
@@ -372,6 +403,8 @@ def analyze(path: Path, deep: bool = True, data_bytes: int | None = None) -> Ana
             "xr_layer_exts": sorted(layer_exts),  # composition-layer extensions the game's own libraries request
             "vr_kind": vr_kind(libset, manifest_strings),
             "headset": headset(meta, abis, vr_kind(libset, manifest_strings), requires_6dof(manifest)),
+            # a Google Daydream / Cardboard build (GVR / Cardboard SDK): no path to the Frame's headset (GitHub #335)
+            "google_vr": google_vr(libset, cats, manifest_strings, gvr_java, boot),
             # the base of a split APK set (Play "app bundle" installs): the code/libraries live in split APKs
             "split_apk": bool({"isSplitRequired", "requiredSplitTypes"} & set(manifest_strings)),
             # Unity (IL2CPP) text fields: they close at once on the Frame (frame.unity_text_input)

src/frameport/locales/template.json

@@ -1609,6 +1609,7 @@
  "This Frame's SSH key changed since FramePort last connected (SteamOS was reset, or another device now has its address). If it's your Frame, choose Trust the new key on the Steam Frame page.": "",
  "This game can't run on the Steam Frame.": "",
  "This game is marked \"Can't run\" on the Steam Frame:": "",
+ "This is a Google {platform} VR build. Its VR can't reach the Frame's headset, so it runs as a flat window at best, usually without working controls. An Oculus build of the game (Meta Quest, Oculus Go or Gear VR) works the normal way.": "",
  "This is a website in an app: it opens in Meta's browser, which the Frame doesn't have. If nothing opens, visit the website in a browser.": "",
  "This is the example button from frameport.app. Real buttons install real games.": "",
  "this PC": "",

src/frameport/recommend/engine.py

@@ -246,10 +246,23 @@ def web_wrapper_note(analysis: Analysis) -> str | None:
             f"Meta's browser, which the Frame doesn't have. If nothing opens, {where}.")
 
 
+def google_vr_note(analysis: Analysis) -> str | None:
+    """A Google Daydream / Cardboard build (analysis.detect.google_vr) that isn't also a Meta build: its VR can't
+    reach the Frame's headset (GitHub #335)."""
+    kind = (analysis.extra or {}).get("google_vr")
+    if not kind or analysis.vr_kind == "quest":  # a build with Oculus support too goes the normal way
+        return None
+    name = "Google Daydream" if kind == "daydream" else "Google Cardboard"
+    return (f"This is a {name} VR build (Google VR SDK). Its VR can't reach the Steam Frame's headset: Daydream "
+            "needs Google's VR services and Cardboard draws for a phone in a viewer, and FramePort has no "
+            "translation for either, so it runs as a flat window at best, usually without working controls. An "
+            "Oculus build of the same game (Meta Quest, Oculus Go or Gear VR) goes through FramePort's normal path.")
+
+
 def blocker_notes(analysis: Analysis) -> list[str]:
     """Warnings read from the APK's manifest that it may not run on the Frame (whatever the recipe says). Only
     warnings: the manifest alone never marks a game unsupported (owner's rule); a launch test's triage decides."""
-    return [n for n in (android_version_note(analysis), web_wrapper_note(analysis)) if n]
+    return [n for n in (android_version_note(analysis), web_wrapper_note(analysis), google_vr_note(analysis)) if n]
 
 
 def _static_blockers(analysis: Analysis, recipe: Recipe) -> None:
@@ -274,7 +287,8 @@ def _non_quest(analysis: Analysis, recipe: Recipe) -> None:
         recipe.reasons = {pid: v for pid, v in recipe.reasons.items() if pid in recipe.patches}
         recipe.alt_patches = []
         recipe.as_is = not any(base.get(pid).stage == "apk" for pid in recipe.patches)  # the APK stays unchanged
-        recipe.notes = _add(recipe.notes, "Android app without VR: installed without FramePort's VR translation.")
+        if not (analysis.extra or {}).get("google_vr"):  # a Google VR build says so in its own note (blocker_notes)
+            recipe.notes = _add(recipe.notes, "Android app without VR: installed without FramePort's VR translation.")
     elif kind in ("pico_sdk", "wave"):
         recipe.status = "unsupported"
         recipe.notes = _add(recipe.notes, f"Uses {'Pico' if kind == 'pico_sdk' else 'HTC Vive Wave'}'s own VR SDK "

src/frameport/ui/views/game.py

@@ -412,8 +412,17 @@ class GameView:
                           "have. If nothing opens, visit the website in a browser."), T.TEXT)]
                 + ([C.meta(web["url"], T.TEXT_2, selectable=True)] if web.get("url") else []), spacing=T.px(4)),
                 "warn", ft.Icons.LANGUAGE_ROUNDED))
+        # a Google Daydream / Cardboard build (no Oculus support in it): its VR has no way to the headset (#335)
+        gvr = (extra.get("google_vr") if not self.rift and not self.linux and extra.get("vr_kind") != "quest"
+               else "")
+        if gvr:
+            out.append(C.callout(tr("This is a Google {platform} VR build. Its VR can't reach the Frame's headset, so "
+                                    "it runs as a flat window at best, usually without working controls. An Oculus "
+                                    "build of the game (Meta Quest, Oculus Go or Gear VR) works the normal way.")
+                                 .format(platform="Daydream" if gvr == "daydream" else "Cardboard"),
+                                 "warn", ft.Icons.VIEW_IN_AR_ROUNDED))
         static = " ".join(engine.blocker_notes(library.analysis_from_dict(g["analysis"]))) \
-            if (too_new or web) else ""
+            if (too_new or web or gvr) else ""
         if static and recipe.notes.strip() == static:
             pass  # the recipe's note says the same (shown above)
         elif recipe.status == "unsupported":

tests/test_google_vr.py

@@ -0,0 +1,115 @@
+"""Google Daydream / Cardboard (GVR SDK) apps: detected, warned about, never marked unsupported (GitHub #335)."""
+import zipfile
+
+from conftest import build_axml
+
+from frameport.analysis import detect
+from frameport.recommend import engine
+from frameport.validate.triage import triage
+
+DAYDREAM_VR_MODE = "com.google.vr.vrcore/com.google.vr.vrcore.common.VrCoreListenerService"
+
+
+def _manifest(package="com.example.daydream", categories=(), enable_vr_mode=None):
+    activity = [("name", "str", "com.unity3d.player.UnityPlayerActivity")]
+    if enable_vr_mode:
+        activity.append(("enableVrMode", "str", enable_vr_mode))
+    cats = []
+    for c in ("android.intent.category.LAUNCHER", *categories):
+        cats += [("start", "category", [("name", "str", c)]), ("end", "category")]
+    return build_axml([
+        ("start", "manifest", [("package", "str", package)]),
+        ("start", "uses-sdk", [("minSdkVersion", "int", 24), ("targetSdkVersion", "int", 26)]),
+        ("end", "uses-sdk"),
+        ("start", "application", []),
+        ("start", "activity", activity),
+        ("start", "intent-filter", []),
+        ("start", "action", [("name", "str", "android.intent.action.MAIN")]),
+        ("end", "action"),
+        *cats,
+        ("end", "intent-filter"),
+        ("end", "activity"),
+        ("end", "application"),
+        ("end", "manifest"),
+    ])
+
+
+def _apk(tmp_path, manifest, libs=("libmain.so", "libunity.so"), abi="armeabi-v7a", dex=b"dex\n035\0"):
+    p = tmp_path / "game.apk"
+    with zipfile.ZipFile(p, "w") as z:
+        z.writestr("AndroidManifest.xml", manifest)
+        z.writestr("classes.dex", dex)
+        for lib in libs:
+            z.writestr(f"lib/{abi}/{lib}", b"\x7fELF-" + lib.encode())
+    return p
+
+
+def test_google_vr_signals():
+    assert detect.google_vr(set(), {detect.DAYDREAM_CATEGORY}, []) == "daydream"
+    assert detect.google_vr(set(), set(), [DAYDREAM_VR_MODE]) == "daydream"
+    assert detect.google_vr(set(), {detect.CARDBOARD_CATEGORY}, []) == "cardboard"
+    assert detect.google_vr({"libgvr.so"}, set(), []) == "cardboard"
+    assert detect.google_vr({"libGfxPluginCardboard.so"}, set(), []) == "cardboard"
+    assert detect.google_vr(set(), set(), [], gvr_java=True) == "cardboard"
+    assert detect.google_vr(set(), set(), [], boot="vr-enabled=1\nvr-device-list=Daydream,Cardboard\n") == "daydream"
+    # both: Daydream is the more specific
+    assert detect.google_vr({"libgvr.so"}, {detect.CARDBOARD_CATEGORY, detect.DAYDREAM_CATEGORY}, []) == "daydream"
+    # Google's spatial audio alone isn't Google VR (Quest games ship it, e.g. Shadow Point)
+    assert detect.google_vr({"libgvraudio.so", "libaudioplugingvrunity.so"}, set(), []) == ""
+    assert detect.google_vr(set(), set(), [], boot="vr-enabled=1\nvr-device-list=Oculus\n") == ""
+
+
+def test_daydream_apk_is_detected(tmp_path):
+    """Blade Runner: Revelations' shape: Unity 2017, 32-bit, Daydream category + VrCore's VR mode, libgvr.so."""
+    m = _manifest(categories=[detect.DAYDREAM_CATEGORY], enable_vr_mode=DAYDREAM_VR_MODE)
+    a = detect.analyze(_apk(tmp_path, m, ("libmain.so", "libunity.so", "libgvr.so", "libaudioplugingvrunity.so")))
+    assert a.extra["google_vr"] == "daydream"
+    assert a.vr_kind == "none" and a.extra["analysis_version"] == detect.ANALYSIS_VERSION
+
+
+def test_cardboard_from_java_classes(tmp_path):
+    dex = b"dex\n035\0...Lcom/google/vr/sdk/base/GvrView;..."
+    a = detect.analyze(_apk(tmp_path, _manifest(), dex=dex))
+    assert a.extra["google_vr"] == "cardboard"
+
+
+def test_quest_game_with_google_audio_is_not_google_vr(tmp_path):
+    a = detect.analyze(_apk(tmp_path, _manifest(), ("libmain.so", "libunity.so", "libvrapi.so", "libgvraudio.so")))
+    assert a.extra["google_vr"] == "" and engine.google_vr_note(a) is None
+
+
+def test_warning_but_never_unsupported(tmp_path):
+    m = _manifest(categories=[detect.DAYDREAM_CATEGORY], enable_vr_mode=DAYDREAM_VR_MODE)
+    a = detect.analyze(_apk(tmp_path, m, ("libmain.so", "libunity.so", "libgvr.so")))
+    note = engine.google_vr_note(a)
+    assert note and "Daydream" in note and "Oculus build" in note
+    assert note in engine.blocker_notes(a)
+    r = engine.suggest(a, use_catalog=False)
+    assert r.status != "unsupported"  # the manifest alone never decides; the launch test's triage does
+    assert note in r.notes and "Android app without VR" not in r.notes
+
+
+def test_daydream_and_oculus_build_goes_the_normal_way(tmp_path):
+    """A Unity build with both Daydream and Oculus support: the Oculus path works, so no warning."""
+    m = _manifest(categories=[detect.DAYDREAM_CATEGORY], enable_vr_mode=DAYDREAM_VR_MODE)
+    a = detect.analyze(_apk(tmp_path, m, ("libmain.so", "libunity.so", "libgvr.so", "libvrapi.so")))
+    assert a.extra["google_vr"] == "daydream" and a.vr_kind == "quest"
+    assert engine.google_vr_note(a) is None
+
+
+def test_triage_gvr_not_supported():
+    """Lines from #335's launch log (Blade Runner: Revelations on the 32-bit bridge)."""
+    lines = [
+        "10-16 05:27:34.526  1355  1384 W a32bridge: libgvr.so: Java_com_google_vr_sdk_base_CardboardViewNativeImpl_"
+        "nativeDestroy: class com/google/vr/sdk/base/CardboardViewNativeImpl not found",
+        "10-16 05:27:34.560  1355  1384 E Unity   : Google VR Error [Daydream]: Google VR had a fatal issue while "
+        "loading. VR will not be available.",
+        "10-16 05:27:43.854   225  1097 W ActivityManager: Unable to start service Intent { "
+        "act=com.google.vr.vrcore.controller.BIND pkg=com.google.vr.vrcore } U=0: not found",
+    ]
+    for line in lines:
+        r = triage(line + "\n", "RUNNING")
+        assert [f.id for f in r.findings] == ["gvr-not-supported"] and r.verdict == "fail", line
+    # GVR's own start-up line alone isn't a failure (a Daydream build with Oculus support logs it too)
+    assert not triage("10-16 05:27:34.555  1355  1355 I GVR     : [vr/gvr/capi/src/gvr.cc:103] Initialized GVR "
+                      "version 1.101.0\n", "RUNNING").findings