Add Bluetooth mic support for video recording, tested.

Signed-off-by: Keith Conger <keith.conger@blackboxembedded.com>

Author: blackboxembedded

app/src/main/java/com/blackboxembedded/WunderLINQ/BluetoothMicRouter.java

@@ -22,8 +22,10 @@
 import android.content.Context;
 import android.content.Intent;
 import android.content.IntentFilter;
+import android.media.AudioAttributes;
 import android.media.AudioDeviceInfo;
 import android.media.AudioManager;
+import android.media.AudioFocusRequest;
 import android.os.Build;
 import android.os.Handler;
 import android.os.Looper;
@@ -33,167 +35,140 @@
 import androidx.annotation.Nullable;
 import androidx.core.content.ContextCompat;
 
+import java.util.List;
+
 import static android.content.pm.PackageManager.PERMISSION_GRANTED;
 
 public final class BluetoothMicRouter {
     private static final String TAG = "BluetoothMicRouter";
-    private static final long LEGACY_SCO_TIMEOUT_MS = 4000; // fail-safe
+    private static final long LEGACY_SCO_TIMEOUT_MS = 4000;
 
     private final Context appContext;
     private final AudioManager audioManager;
     private final Handler mainHandler = new Handler(Looper.getMainLooper());
 
     @Nullable private BroadcastReceiver scoReceiver;
-    @Nullable private Runnable pendingCallback;
     @Nullable private Runnable scoTimeout;
+    @Nullable private Runnable pendingCallback;
+
+    // Audio focus (26+) or legacy focus
+    @Nullable private AudioFocusRequest focusRequest;
+    @Nullable private AudioManager.OnAudioFocusChangeListener legacyFocusCb;
 
     private boolean usingBtMic = false;
     private boolean waitingForSco = false;
 
     public BluetoothMicRouter(@NonNull Context ctx) {
-        this.appContext = ctx.getApplicationContext();
-        this.audioManager = (AudioManager) appContext.getSystemService(Context.AUDIO_SERVICE);
+        appContext = ctx.getApplicationContext();
+        audioManager = (AudioManager) appContext.getSystemService(Context.AUDIO_SERVICE);
     }
 
     /**
-     * Attempts to route input to a Bluetooth microphone if one is present.
-     * Calls {@code onInputReady.run()}:
-     *  - immediately if routing succeeds (API 31+) or no BT mic is present (fallback to built-in),
-     *  - after SCO connects on legacy devices (<=30), or after a timeout (fallback).
+     * Route to a Bluetooth mic if available, then run onInputReady.
+     * Always calls the callback (falls back to built-in mic if routing fails).
      */
     public void routeToBluetoothIfPresentThen(@NonNull Runnable onInputReady) {
-        if (audioManager == null) {
-            Log.w(TAG, "AudioManager null; continuing without BT mic");
-            runOnMain(onInputReady);
-            return;
-        }
+        if (audioManager == null) { runOnMain(onInputReady); return; }
+
+        // 1) Ask for voice-comm focus and set COMM mode (helps a lot of stacks)
+        requestVoiceCommFocus();
+        try { audioManager.setMode(AudioManager.MODE_IN_COMMUNICATION); } catch (Throwable ignored) {}
 
-        // API 31+ modern routing
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
-            if (ContextCompat.checkSelfPermission(appContext, Manifest.permission.BLUETOOTH_CONNECT) != PERMISSION_GRANTED) {
-                Log.w(TAG, "BLUETOOTH_CONNECT not granted; continuing without BT routing");
-                runOnMain(onInputReady);
-                return;
+            // 2) API 31+: pick a communication device (BLE preferred, then SCO)
+            AudioDeviceInfo selected = pickBtCommDevice31Plus();
+            boolean ok = false;
+            if (selected != null) {
+                ok = audioManager.setCommunicationDevice(selected);
+                usingBtMic = ok;
+                Log.d(TAG, "setCommunicationDevice -> " + ok + " (" + deviceLabel(selected) + ")");
+            } else {
+                Log.d(TAG, "No BT communication devices currently listed");
             }
 
-            try {
-                AudioDeviceInfo bt = findBluetoothInputApi31Plus();
-                if (bt != null) {
-                    audioManager.setMode(AudioManager.MODE_IN_COMMUNICATION);
-                    boolean ok = audioManager.setCommunicationDevice(bt);
-                    usingBtMic = ok;
-                    Log.d(TAG, "setCommunicationDevice -> " + ok + " (" + deviceLabel(bt) + ")");
-                    // Either way, start now (if ok=true it's BT, else built-in)
-                    runOnMain(onInputReady);
-                    return;
-                }
-            } catch (SecurityException se) {
-                Log.w(TAG, "setCommunicationDevice denied", se);
-            } catch (Throwable t) {
-                Log.w(TAG, "API31+ routing error", t);
+            // 3) If that didn’t stick, try SCO as a fallback (some stacks need SCO handshake)
+            if (!ok && audioManager.isBluetoothScoAvailableOffCall()) {
+                startScoThen(onInputReady, /*retrySetCommDevice=*/true);
+                return;
             }
 
-            // No BT mic found; continue with built-in
+            // 4) Log current comm device and continue
+            AudioDeviceInfo cur = audioManager.getCommunicationDevice();
+            Log.d(TAG, "Current COMM device: " + (cur == null ? "null" : deviceLabel(cur)));
             runOnMain(onInputReady);
             return;
         }
 
-        // Legacy (<=30): SCO
+        // 5) Legacy (<=30): use SCO if available, else continue
         if (audioManager.isBluetoothScoAvailableOffCall()) {
-            try {
-                audioManager.setMode(AudioManager.MODE_IN_COMMUNICATION);
-                // Some OEMs require this deprecated toggle for SCO mic path pre-31:
-                try {
-                    audioManager.setBluetoothScoOn(true);
-                } catch (Throwable ignored) { }
-
-                waitingForSco = true;
-                registerScoReceiver(onInputReady);
-
-                audioManager.startBluetoothSco();
-                Log.d(TAG, "startBluetoothSco() called; waiting for SCO connect");
-
-                // Fail-safe timeout: start anyway after X ms if SCO never connects
-                scoTimeout = () -> {
-                    Log.w(TAG, "SCO connect timeout; continuing without BT mic");
-                    waitingForSco = false;
-                    runAndClearPending(onInputReady);
-                };
-                mainHandler.postDelayed(scoTimeout, LEGACY_SCO_TIMEOUT_MS);
-                return;
-            } catch (Throwable t) {
-                Log.w(TAG, "Legacy SCO routing error; continuing without BT mic", t);
-            }
+            startScoThen(onInputReady, /*retrySetCommDevice=*/false);
+        } else {
+            runOnMain(onInputReady);
         }
-
-        // No SCO available; continue with built-in
-        runOnMain(onInputReady);
     }
 
-    /** Undo routing and restore audio mode. Safe to call multiple times. */
+    /** Undo routing and restore defaults. Safe to call multiple times. */
     public void clearRouting() {
-        // Cancel timeout/pending
         if (scoTimeout != null) {
             mainHandler.removeCallbacks(scoTimeout);
             scoTimeout = null;
         }
         pendingCallback = null;
 
-        // Unregister receiver
         if (scoReceiver != null) {
             try { appContext.unregisterReceiver(scoReceiver); } catch (Throwable ignored) {}
             scoReceiver = null;
         }
 
-        // Clear routing
         if (audioManager != null) {
             try {
                 if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
                     audioManager.clearCommunicationDevice();
                 } else {
-                    if (waitingForSco || usingBtMic) {
-                        try { audioManager.stopBluetoothSco(); } catch (Throwable ignored) {}
-                        try {
-                            audioManager.setBluetoothScoOn(false);
-                        } catch (Throwable ignored) {}
-                    }
+                    try { audioManager.stopBluetoothSco(); } catch (Throwable ignored) {}
+                    try { /*noinspection deprecation*/ audioManager.setBluetoothScoOn(false); } catch (Throwable ignored) {}
                 }
             } catch (Throwable t) {
                 Log.w(TAG, "clearRouting error", t);
             }
-
-            try {
-                audioManager.setMode(AudioManager.MODE_NORMAL);
-            } catch (Throwable ignored) {}
+            try { audioManager.setMode(AudioManager.MODE_NORMAL); } catch (Throwable ignored) {}
         }
 
+        abandonVoiceCommFocus();
+
         usingBtMic = false;
         waitingForSco = false;
     }
 
-    /** True if we successfully routed to a BT mic. */
     public boolean isUsingBtMic() { return usingBtMic; }
-
-    /** True while <=30 is waiting for SCO connection. */
     public boolean isWaitingForSco() { return waitingForSco; }
 
     // ---------- Internals ----------
 
-    @Nullable
-    private AudioDeviceInfo findBluetoothInputApi31Plus() {
-        // Look through input devices and find first BT-capable mic
-        for (AudioDeviceInfo dev : audioManager.getDevices(AudioManager.GET_DEVICES_INPUTS)) {
-            int type = dev.getType();
-            if (type == AudioDeviceInfo.TYPE_BLUETOOTH_SCO
-                    || (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S
-                    && type == AudioDeviceInfo.TYPE_BLE_HEADSET)) {
-                return dev;
-            }
+    private void startScoThen(@NonNull Runnable onInputReady, boolean retrySetCommDeviceAfterConnected) {
+        try { /*noinspection deprecation*/ audioManager.setBluetoothScoOn(true); } catch (Throwable ignored) {}
+        waitingForSco = true;
+        registerScoReceiver(onInputReady, retrySetCommDeviceAfterConnected);
+        try {
+            audioManager.startBluetoothSco();
+            Log.d(TAG, "startBluetoothSco… waiting for SCO_AUDIO_STATE_CONNECTED");
+        } catch (Throwable t) {
+            Log.w(TAG, "startBluetoothSco failed; continuing without BT mic", t);
+            waitingForSco = false;
+            runOnMain(onInputReady);
+            return;
         }
-        return null;
+
+        // Fail-safe timeout
+        scoTimeout = () -> {
+            Log.w(TAG, "SCO timeout; continuing");
+            waitingForSco = false;
+            runOnMain(onInputReady);
+        };
+        mainHandler.postDelayed(scoTimeout, LEGACY_SCO_TIMEOUT_MS);
     }
 
-    private void registerScoReceiver(@NonNull Runnable onInputReady) {
+    private void registerScoReceiver(@NonNull Runnable onInputReady, boolean retrySetCommDeviceAfterConnected) {
         if (scoReceiver != null) return;
 
         pendingCallback = onInputReady;
@@ -208,13 +183,24 @@ private void registerScoReceiver(@NonNull Runnable onInputReady) {
                     usingBtMic = true;
                     waitingForSco = false;
 
-                    // Cancel timeout, run callback
                     if (scoTimeout != null) {
                         mainHandler.removeCallbacks(scoTimeout);
                         scoTimeout = null;
                     }
-                    runAndClearPending(null);
 
+                    // On API 31+, retry setting COMM device now that SCO is active
+                    if (retrySetCommDeviceAfterConnected && Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+                        AudioDeviceInfo pick = pickBtCommDevice31Plus(/*preferSco=*/true);
+                        if (pick != null) {
+                            boolean ok2 = audioManager.setCommunicationDevice(pick);
+                            Log.d(TAG, "setCommunicationDevice(after SCO) -> " + ok2 + " (" + deviceLabel(pick) + ")");
+                            usingBtMic = usingBtMic || ok2;
+                        }
+                        AudioDeviceInfo cur = audioManager.getCommunicationDevice();
+                        Log.d(TAG, "Current COMM device: " + (cur == null ? "null" : deviceLabel(cur)));
+                    }
+
+                    runAndClearPending();
                 } else if (state == AudioManager.SCO_AUDIO_STATE_DISCONNECTED) {
                     Log.d(TAG, "SCO disconnected");
                 }
@@ -223,8 +209,84 @@ private void registerScoReceiver(@NonNull Runnable onInputReady) {
         appContext.registerReceiver(scoReceiver, f);
     }
 
-    private void runAndClearPending(@Nullable Runnable fallback) {
-        Runnable cb = pendingCallback != null ? pendingCallback : fallback;
+    @Nullable
+    private AudioDeviceInfo pickBtCommDevice31Plus() {
+        return pickBtCommDevice31Plus(false);
+    }
+
+    @Nullable
+    private AudioDeviceInfo pickBtCommDevice31Plus(boolean preferSco) {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.S) return null;
+        if (ContextCompat.checkSelfPermission(appContext, Manifest.permission.BLUETOOTH_CONNECT) != PERMISSION_GRANTED) {
+            Log.w(TAG, "BLUETOOTH_CONNECT not granted; cannot list comm devices");
+            return null;
+        }
+        try {
+            List<AudioDeviceInfo> comm = audioManager.getAvailableCommunicationDevices();
+            if (comm == null || comm.isEmpty()) return null;
+
+            AudioDeviceInfo ble = null, sco = null;
+            for (AudioDeviceInfo d : comm) {
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S && d.getType() == AudioDeviceInfo.TYPE_BLE_HEADSET) ble = d;
+                if (d.getType() == AudioDeviceInfo.TYPE_BLUETOOTH_SCO) sco = d;
+            }
+            if (preferSco) return (sco != null) ? sco : ble;
+            return (ble != null) ? ble : sco;
+        } catch (Throwable t) {
+            Log.w(TAG, "pickBtCommDevice31Plus error", t);
+            return null;
+        }
+    }
+
+    private void requestVoiceCommFocus() {
+        if (audioManager == null) return;
+        try {
+            AudioAttributes attrs = new AudioAttributes.Builder()
+                    .setUsage(AudioAttributes.USAGE_VOICE_COMMUNICATION)
+                    .setContentType(AudioAttributes.CONTENT_TYPE_SPEECH)
+                    .build();
+
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                focusRequest = new AudioFocusRequest.Builder(AudioManager.AUDIOFOCUS_GAIN_TRANSIENT_EXCLUSIVE)
+                        .setAudioAttributes(attrs)
+                        .setOnAudioFocusChangeListener(fc -> {})
+                        .build();
+                int res = audioManager.requestAudioFocus(focusRequest);
+                Log.d(TAG, "requestAudioFocus(26+) -> " + res);
+            } else {
+                legacyFocusCb = fc -> {};
+                @SuppressWarnings("deprecation")
+                int res = audioManager.requestAudioFocus(
+                        legacyFocusCb,
+                        AudioManager.STREAM_VOICE_CALL,
+                        AudioManager.AUDIOFOCUS_GAIN_TRANSIENT_EXCLUSIVE
+                );
+                Log.d(TAG, "requestAudioFocus(legacy) -> " + res);
+            }
+        } catch (Throwable t) {
+            Log.w(TAG, "requestVoiceCommFocus failed", t);
+        }
+    }
+
+    private void abandonVoiceCommFocus() {
+        if (audioManager == null) return;
+        try {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                if (focusRequest != null) {
+                    audioManager.abandonAudioFocusRequest(focusRequest);
+                    focusRequest = null;
+                }
+            } else if (legacyFocusCb != null) {
+                @SuppressWarnings("deprecation")
+                int res = audioManager.abandonAudioFocus(legacyFocusCb);
+                legacyFocusCb = null;
+                Log.d(TAG, "abandonAudioFocus(legacy) -> " + res);
+            }
+        } catch (Throwable ignored) {}
+    }
+
+    private void runAndClearPending() {
+        Runnable cb = pendingCallback;
         pendingCallback = null;
         if (cb != null) runOnMain(cb);
     }
@@ -234,15 +296,13 @@ private void runOnMain(@NonNull Runnable r) {
         else mainHandler.post(r);
     }
 
-    private static String deviceLabel(AudioDeviceInfo dev) {
+    private static String deviceLabel(@NonNull AudioDeviceInfo dev) {
         String addr = null;
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) { // API 28+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
             try { addr = dev.getAddress(); } catch (Throwable ignored) {}
         }
-        CharSequence pn = dev.getProductName(); // avail since API 23
+        CharSequence pn = dev.getProductName();
         String name = (pn != null) ? pn.toString() : "unknown";
-
-        // On API < 28 we won't have an address; include id/name instead.
         return "type=" + dev.getType()
                 + " id=" + dev.getId()
                 + " name=" + name