Immersive OpenXR goggle mode for Quest / Android XR

app/build.gradle

@@ -59,6 +59,7 @@ dependencies {
     implementation(project(":app:mavlink"))
     implementation(project(":app:videonative"))
     implementation(project(":app:wfbngrtl8812"))
+    implementation(project(":app:xr"))
 
     implementation(libs.appcompat)
     implementation(libs.material)

app/src/main/AndroidManifest.xml

@@ -7,6 +7,24 @@
     <uses-feature
         android:name="android.hardware.touchscreen"
         android:required="false" />
+    <!-- Optional: the immersive activity needs it, the flat one does not, so the app
+         still installs and runs on a phone. -->
+    <uses-feature
+        android:name="android.hardware.vr.headtracking"
+        android:required="false" />
+    <!-- Horizon OS treats an app declared with the VR category as controller-required
+         unless it advertises hand tracking, and blocks the launch with
+         RequiresControllersLaunchInterceptor when the controllers are off. A pilot has a
+         radio in their hands, not Touch controllers, and the video path does not need them
+         at all - so declare it and let the app start either way. -->
+    <uses-feature
+        android:name="oculus.software.handtracking"
+        android:required="false" />
+    <!-- Horizon OS only exposes XR_FB_passthrough to an app that asks for it here; without
+         this the extension is simply absent from the instance extension list. -->
+    <uses-feature
+        android:name="com.oculus.feature.PASSTHROUGH"
+        android:required="false" />
 
     <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
     <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
@@ -19,6 +37,9 @@
     <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
     <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
     <uses-permission android:name="android.permission.BIND_VPN_SERVICE" />
+    <!-- Goes with the oculus.software.handtracking feature: without it Horizon OS does
+         not hand the app tracked hands, so the pinch bindings never fire. -->
+    <uses-permission android:name="com.oculus.permission.HAND_TRACKING" />
 
     <application
         android:allowBackup="true"
@@ -29,6 +50,13 @@
         android:roundIcon="@mipmap/ic_launcher_round"
         android:usesCleartextTraffic="true"
         android:supportsRtl="true">
+        <!-- Owns the adapter, the wfb-ng link and the decoder for as long as either
+             presentation mode needs them, and across the switch between them. -->
+        <service
+            android:name=".LinkService"
+            android:exported="false"
+            android:foregroundServiceType="dataSync" />
+
         <service
             android:name=".WfbNgVpnService"
             android:label="Wfb-Ng VPN Service"
@@ -76,5 +104,29 @@
                 <action android:name="android.intent.action.ACTION_POWER_DISCONNECTED" />
             </intent-filter>
         </activity>
+
+        <activity
+            android:name=".XrVideoActivity"
+            android:configChanges="orientation|screenSize|smallestScreenSize|screenLayout|keyboard|keyboardHidden|navigation"
+            android:enabled="false"
+            android:exported="true"
+            android:label="@string/app_name_xr"
+            android:launchMode="singleTask"
+            android:resizeableActivity="true"
+            android:theme="@style/Theme.FPVueMat">
+            <!-- Horizon OS and Android XR pick the immersive launch path from the VR
+                 category. It is a separate launcher entry so the flat activity keeps
+                 working unchanged, including its USB_DEVICE_ATTACHED filter.
+
+                 Shipped disabled: on a phone this entry would be a second icon leading to
+                 an activity that cannot create a session, and there is no manifest
+                 condition for "device has an XR runtime". VideoActivity.onCreate turns it
+                 on where it can actually run - see XrVideoActivity.syncLauncherEntry. -->
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="com.oculus.intent.category.VR" />
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
     </application>
 </manifest>

app/src/main/java/com/openipc/pixelpilot/DvrFiles.java

@@ -0,0 +1,98 @@
+package com.openipc.pixelpilot;
+
+import android.content.Context;
+import android.net.Uri;
+import android.util.Log;
+
+import androidx.documentfile.provider.DocumentFile;
+
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * DVR file naming and creation, shared by the flat and the immersive activity.
+ *
+ * <p>Everything here works off the already granted {@code dvr_folder_} tree URI. Picking a
+ * folder needs an Activity result and stays with the flat activity.
+ */
+public final class DvrFiles {
+    private static final String TAG = "pixelpilot";
+    private static final String PREF_DVR_FILENAME = "dvr_filename";
+    private static final String DEFAULT_TEMPLATE = "pixelpilot_[yyyyMMdd-HHmmss]";
+    private static final Pattern TEMPLATE_PATTERN = Pattern.compile("\\[([^\\]]*)\\]");
+
+    private DvrFiles() {
+    }
+
+    public static String template(Context context) {
+        return context.getSharedPreferences("general", Context.MODE_PRIVATE)
+                .getString(PREF_DVR_FILENAME, DEFAULT_TEMPLATE);
+    }
+
+    public static void setTemplate(Context context, String template) {
+        context.getSharedPreferences("general", Context.MODE_PRIVATE)
+                .edit().putString(PREF_DVR_FILENAME, template).apply();
+    }
+
+    public static boolean fragmentedMp4(Context context) {
+        return context.getSharedPreferences("general", Context.MODE_PRIVATE)
+                .getBoolean("dvr_fmp4", true);
+    }
+
+    /** Expands the {@code [pattern]} placeholder in a file name template. */
+    public static String fileName(String template, LocalDateTime time) {
+        Matcher matcher = TEMPLATE_PATTERN.matcher(template);
+        String fallbackTime = time.format(DateTimeFormatter.ofPattern("yyyyMMdd-HHmmss"));
+
+        if (matcher.find()) {
+            String prefix = template.substring(0, matcher.start());
+            String pattern = matcher.group(1);
+            String suffix = template.substring(matcher.end());
+
+            try {
+                String timePart = time.format(DateTimeFormatter.ofPattern(pattern));
+                return prefix + timePart + suffix;
+            } catch (IllegalArgumentException e) {
+                return prefix + fallbackTime + suffix;
+            }
+        }
+        return "pixelpilot_" + fallbackTime;
+    }
+
+    public static boolean hasRecordingFolder(Context context) {
+        return !context.getSharedPreferences("general", Context.MODE_PRIVATE)
+                .getString("dvr_folder_", "").isEmpty();
+    }
+
+    /**
+     * Creates the next recording file in the configured folder.
+     *
+     * @return its URI, or null if no folder is configured or it is not writable
+     */
+    public static Uri createRecording(Context context) {
+        String dvrFolder = context.getSharedPreferences("general", Context.MODE_PRIVATE)
+                .getString("dvr_folder_", "");
+        if (dvrFolder.isEmpty()) {
+            Log.e(TAG, "dvrFolder is empty");
+            return null;
+        }
+        DocumentFile pickedDir = DocumentFile.fromTreeUri(context, Uri.parse(dvrFolder));
+        if (pickedDir == null || !pickedDir.canWrite()) {
+            return null;
+        }
+        String name = fileName(template(context), LocalDateTime.now()) + ".mp4";
+        DocumentFile newFile = pickedDir.createFile("video/mp4", name);
+        if (newFile == null) {
+            Log.e(TAG, "dvr newFile null");
+            return null;
+        }
+        return newFile.getUri();
+    }
+
+    /** File name the next {@link #createRecording} would use, for UI previews. */
+    public static String nextFileName(Context context) {
+        return fileName(template(context), LocalDateTime.now()) + ".mp4";
+    }
+}

app/src/main/java/com/openipc/pixelpilot/GsKey.java

@@ -0,0 +1,87 @@
+package com.openipc.pixelpilot;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.util.Base64;
+import android.util.Log;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+/**
+ * The wfb-ng ground station key, shared by the flat and the immersive activity.
+ *
+ * <p>The key lives in preferences (so a user-picked one survives) and has to be
+ * materialised as {@code files/gs.key} before {@code WfbNgLink} is constructed: the native
+ * aggregators open that path in their constructor and throw if it is missing.
+ */
+public final class GsKey {
+    private static final String TAG = "pixelpilot";
+    private static final String PREF_KEY = "gs.key";
+    private static final String FILE_NAME = "gs.key";
+
+    private GsKey() {
+    }
+
+    public static byte[] get(Context context) {
+        String pref = context.getSharedPreferences("general", Context.MODE_PRIVATE)
+                .getString(PREF_KEY, "");
+        return Base64.decode(pref, Base64.DEFAULT);
+    }
+
+    public static void set(Context context, InputStream inputStream) throws IOException {
+        ByteArrayOutputStream result = new ByteArrayOutputStream();
+        byte[] buffer = new byte[1024];
+        int length;
+        while ((length = inputStream.read(buffer)) != -1) {
+            result.write(buffer, 0, length);
+        }
+        SharedPreferences prefs = context.getSharedPreferences("general", Context.MODE_PRIVATE);
+        prefs.edit().putString(PREF_KEY, Base64.encodeToString(result.toByteArray(), Base64.DEFAULT)).apply();
+    }
+
+    /** Seeds preferences from the bundled asset the first time round. */
+    public static void importDefaultIfMissing(Context context) {
+        if (get(context).length > 0) {
+            Log.d(TAG, "gs.key already saved in preferences.");
+            return;
+        }
+        try (InputStream inputStream = context.getAssets().open(FILE_NAME)) {
+            Log.d(TAG, "Importing default gs.key...");
+            set(context, inputStream);
+        } catch (IOException e) {
+            Log.e(TAG, "Failed to import default gs.key", e);
+        }
+    }
+
+    /** Writes the key from preferences to {@code files/gs.key}. */
+    public static boolean writeToFilesDir(Context context) {
+        byte[] keyBytes = get(context);
+        if (keyBytes.length == 0) {
+            Log.e(TAG, "No gs.key available to write");
+            return false;
+        }
+        File file = new File(context.getApplicationContext().getFilesDir(), FILE_NAME);
+        try (OutputStream out = new FileOutputStream(file)) {
+            out.write(keyBytes, 0, keyBytes.length);
+            Log.d(TAG, "Wrote gs.key (" + keyBytes.length + " bytes) to " + file.getAbsolutePath());
+            return true;
+        } catch (IOException e) {
+            Log.e(TAG, "Failed to write gs.key", e);
+            return false;
+        }
+    }
+
+    /**
+     * Everything that has to happen before {@code new WfbNgLink(...)}. Call from any
+     * activity that brings up the link.
+     */
+    public static boolean ensure(Context context) {
+        importDefaultIfMissing(context);
+        return writeToFilesDir(context);
+    }
+}

app/src/main/java/com/openipc/pixelpilot/LinkClientActivity.java

@@ -0,0 +1,98 @@
+package com.openipc.pixelpilot;
+
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.content.ServiceConnection;
+import android.os.Bundle;
+import android.os.IBinder;
+import android.util.Log;
+
+import androidx.annotation.Nullable;
+import androidx.appcompat.app.AppCompatActivity;
+
+import com.openipc.videonative.DecodingInfo;
+import com.openipc.wfbngrtl8812.WfbNGStats;
+
+/**
+ * Binds to {@link LinkService} for the lifetime of the activity.
+ *
+ * <p>Bound in {@code onCreate} and unbound in {@code onDestroy} rather than around
+ * start/stop: the point of the service is that the link survives the activity being paused,
+ * so a system menu or taking the headset off no longer costs a reconnect.
+ */
+public abstract class LinkClientActivity extends AppCompatActivity implements LinkService.Client {
+
+    private static final String TAG = "pixelpilot";
+
+    @Nullable
+    protected LinkService link;
+    private boolean bound;
+
+    private final ServiceConnection connection = new ServiceConnection() {
+        @Override
+        public void onServiceConnected(ComponentName name, IBinder service) {
+            link = ((LinkService.LocalBinder) service).service();
+            link.addClient(LinkClientActivity.this);
+            Log.i(TAG, "attached to the link service");
+            onLinkServiceConnected(link);
+        }
+
+        @Override
+        public void onServiceDisconnected(ComponentName name) {
+            // The process is going away; nothing useful to do but stop talking to it.
+            link = null;
+        }
+    };
+
+    /** Called on the main thread once the link is available. */
+    protected abstract void onLinkServiceConnected(LinkService service);
+
+    @Override
+    protected void onCreate(@Nullable Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        Intent intent = new Intent(this, LinkService.class);
+        // Started as well as bound, so it keeps running while no activity is attached - that
+        // is what carries the link across a mode switch.
+        startForegroundService(intent);
+        bound = bindService(intent, connection, Context.BIND_AUTO_CREATE);
+        if (!bound) {
+            Log.e(TAG, "could not bind the link service");
+        }
+    }
+
+    @Override
+    protected void onDestroy() {
+        if (link != null) {
+            link.removeClient(this);
+        }
+        if (bound) {
+            unbindService(connection);
+            bound = false;
+        }
+        link = null;
+        super.onDestroy();
+    }
+
+    // Defaults so a subclass only overrides what it draws.
+
+    @Override
+    public void onLinkStatus(String message) {
+    }
+
+    @Override
+    public void onLocalStreamHint(String url) {
+    }
+
+    @Override
+    public void onVideoResolution(int width, int height) {
+    }
+
+    @Override
+    public void onDecodingInfo(DecodingInfo info) {
+    }
+
+    @Override
+    public void onWfbStats(WfbNGStats stats) {
+    }
+}