fix(wearable): harden WearOS transport ownership and drop false UUID claims

- Document WEAR_BT_UUID as microG experimental RFCOMM (not stock Wear/Eddystone interop)
- Dup ChannelManager pipe ends for AIDL callers; avoid AutoClose on canonical FDs
- Use ConcurrentHashMap for activeConnections and multi BT thread map
- Route /wearable/notification/command to NotificationBridge
- Revert unrelated vending-app debug release signing
- Expand unit tests; pin Robolectric to SDK 28

Signed-off-by: namdamdoi68-oss <namdamdoi68@gmail.com>

Author: namdamdoi68-oss

play-services-wearable/README.md

@@ -5,7 +5,7 @@ This module implements the Wearable API (`com.google.android.gms.wearable`), ena
 ## Features
 
 ### Bluetooth RFCOMM Transport (`BluetoothConnectionThread.java`)
-- Implements the standard Wear OS Bluetooth RFCOMM UUID (`a3c87500-8ed3-4bdf-8a39-a01bebede295`)
+- Uses a **microG experimental** Bluetooth RFCOMM UUID (`a3c87500-8ed3-4bdf-8a39-a01bebede295`) for lab / microG-to-microG transport. This is **not** a documented stock Wear OS companion RFCOMM UUID (the bit pattern is publicly known as Eddystone BLE; microG does not implement Eddystone). Stock Wear interop needs a device-proven UUID from an HCI snoop.
 - Wraps `BluetoothSocket` in a `java.net.Socket` proxy to reuse the existing `SocketWearableConnection` framing code
 - Supports both server (listen) and client (connect) modes
 
@@ -18,7 +18,7 @@ This module implements the Wearable API (`com.google.android.gms.wearable`), ena
 - Registers as a media session listener to receive playback state updates
 - Forwards play/pause/skip events from the phone to connected Wear OS devices
 
-### Notification Bridging (`WearableNotificationService.java`)
+### Notification Bridging (`WearableNotificationService.kt`)
 - Extends `NotificationListenerService` to intercept phone notifications
 - Forwards clearable, non-ongoing notifications to connected Wear OS devices
 - Supports notification removal events (same UID on removal)

play-services-wearable/core/src/main/java/org/microg/gms/wearable/BluetoothConnectionThread.java

@@ -52,12 +52,25 @@ public abstract class BluetoothConnectionThread extends Thread {
 
     private static final String TAG = "GmsWearBtThread";
 
-    /** RFCOMM service UUID for the wearable Bluetooth transport. */
+    /**
+     * RFCOMM service UUID used by microG for the wearable Bluetooth transport.
+     *
+     * <p><b>Important:</b> This is a <em>microG experimental</em> service UUID chosen for
+     * local RFCOMM pairing experiments. It is <b>not</b> a documented Google Wear OS / Play
+     * Services companion RFCOMM UUID. Notably, the same 128-bit value is publicly known as
+     * the Eddystone BLE service UUID; microG reuses the bit pattern only as an RFCOMM SDP
+     * record id and does <b>not</b> implement Eddystone advertising or claim stock Wear
+     * companion interop through this constant.
+     *
+     * <p>Interoperability with factory Wear OS companions requires a device-proven UUID from
+     * an HCI/BT snoop of a real pairing session. Until then, treat this transport as
+     * microG-to-microG / lab-only.
+     */
     public static final UUID WEAR_BT_UUID =
             UUID.fromString("a3c87500-8ed3-4bdf-8a39-a01bebede295");
 
     /** SDP service name advertised alongside {@link #WEAR_BT_UUID}. */
-    static final String WEAR_BT_SERVICE_NAME = "WearOS";
+    static final String WEAR_BT_SERVICE_NAME = "microG Wearable";
 
     private volatile SocketWearableConnection wearableConnection;
 
@@ -177,22 +190,26 @@ public void run() {
                             break;
                         }
                         if (btSocket == null || Thread.interrupted()) break;
-                        try {
-                            SocketWearableConnection conn =
-                                    new SocketWearableConnection(proxySocket(btSocket), listener);
-                            setWearableConnection(conn);
+                        final BluetoothSocket accepted = btSocket;
+                        // Run each peer on its own worker so accept() is not blocked by one client.
+                        new Thread(() -> {
                             try {
-                                conn.run();
-                            } finally {
+                                SocketWearableConnection conn =
+                                        new SocketWearableConnection(proxySocket(accepted), listener);
+                                setWearableConnection(conn);
                                 try {
-                                    btSocket.close();
-                                } catch (IOException e) {
-                                    Log.w(TAG, "server: close error for accepted connection", e);
+                                    conn.run();
+                                } finally {
+                                    try {
+                                        accepted.close();
+                                    } catch (IOException e) {
+                                        Log.w(TAG, "server: close error for accepted connection", e);
+                                    }
                                 }
+                            } catch (IOException e) {
+                                Log.w(TAG, "server: error on accepted connection", e);
                             }
-                        } catch (IOException e) {
-                            Log.w(TAG, "server: error on accepted connection", e);
-                        }
+                        }, "GmsWearBtPeer").start();
                     }
                 } catch (IOException e) {
                     if (!Thread.interrupted()) {

play-services-wearable/core/src/main/java/org/microg/gms/wearable/ChannelManager.java

@@ -33,6 +33,19 @@
  * Uses the {@link ChannelControlRequest}, {@link ChannelDataRequest}, and
  * {@link ChannelDataAckRequest} protocol messages to open, transfer data through,
  * and close channels with peer WearOS nodes.
+ *
+ * <h3>ParcelFileDescriptor ownership</h3>
+ * <ul>
+ *   <li>{@link ChannelState} owns the canonical pipe ends created via
+ *       {@link ParcelFileDescriptor#createPipe()}.</li>
+ *   <li>AIDL callers receive {@link ParcelFileDescriptor#dup() duplicated} ends from
+ *       {@link #getInputStream}/{@link #getOutputStream}; closing those dups must not
+ *       tear down the canonical ends still used by the network path.</li>
+ *   <li>{@link #writeInputToFd} / {@link #readOutputFromFd} operate on dups of the
+ *       canonical ends so AutoClose streams cannot invalidate app-facing PFDs.</li>
+ *   <li>The output forwarder owns the read end of the output pipe for the lifetime of
+ *       the channel (or until EOF).</li>
+ * </ul>
  */
 public class ChannelManager {
     private static final String TAG = "GmsWearChannelMgr";
@@ -132,14 +145,19 @@ public boolean closeChannel(String token, int errorCode) {
         }
 
         try {
-            sendChannelControl(state.nodeId, new ChannelControlRequest.Builder()
-                    .type(CONTROL_TYPE_CLOSE)
-                    .channelId(channelId)
-                    .fromChannelOperator(true)
-                    .closeErrorCode(errorCode)
-                    .build());
+            if (wearable != null) {
+                sendChannelControl(state.nodeId, new ChannelControlRequest.Builder()
+                        .type(CONTROL_TYPE_CLOSE)
+                        .channelId(channelId)
+                        .fromChannelOperator(true)
+                        .closeErrorCode(errorCode)
+                        .build());
+            }
         } catch (IOException e) {
             Log.w(TAG, "closeChannel: failed to send CLOSE for channel " + channelId, e);
+        } catch (RuntimeException e) {
+            // Unit tests may construct ChannelManager without a WearableImpl.
+            Log.w(TAG, "closeChannel: skip peer CLOSE for channel " + channelId, e);
         }
 
         state.close();
@@ -166,8 +184,13 @@ public ParcelFileDescriptor getInputStream(String token) {
             synchronized (state) {
                 if (state.inputPipe == null) {
                     state.inputPipe = ParcelFileDescriptor.createPipe();
+                    // Keep a long-lived writer over the write-end for incoming network data.
+                    state.inputPipeWriter = new ParcelFileDescriptor.AutoCloseOutputStream(
+                            state.inputPipe[1]);
                 }
-                return state.inputPipe[0]; // read end
+                // Return a dup so the caller's close (or Binder FD handoff) cannot destroy
+                // the canonical read end still owned by ChannelState.
+                return state.inputPipe[0].dup();
             }
         } catch (IOException e) {
             Log.e(TAG, "getInputStream: failed to create pipe for channel " + token, e);
@@ -195,7 +218,8 @@ public ParcelFileDescriptor getOutputStream(String token) {
                     state.outputPipe = ParcelFileDescriptor.createPipe();
                     startOutputForwarder(state);
                 }
-                return state.outputPipe[1]; // write end for caller
+                // Dup the write end for the AIDL caller; ChannelState keeps the canonical end.
+                return state.outputPipe[1].dup();
             }
         } catch (IOException e) {
             Log.e(TAG, "getOutputStream: failed to create pipe for channel " + token, e);
@@ -224,14 +248,18 @@ public boolean writeInputToFd(String token, ParcelFileDescriptor fd) {
             return false;
         }
         try {
+            final ParcelFileDescriptor readEndDup;
             synchronized (state) {
                 if (state.inputPipe == null) {
                     state.inputPipe = ParcelFileDescriptor.createPipe();
+                    state.inputPipeWriter = new ParcelFileDescriptor.AutoCloseOutputStream(
+                            state.inputPipe[1]);
                 }
+                // Dup so AutoCloseInputStream cannot close the canonical app/network read end.
+                readEndDup = state.inputPipe[0].dup();
             }
-            final ParcelFileDescriptor readEnd = state.inputPipe[0];
             new Thread(() -> {
-                try (InputStream in = new ParcelFileDescriptor.AutoCloseInputStream(readEnd);
+                try (InputStream in = new ParcelFileDescriptor.AutoCloseInputStream(readEndDup);
                      OutputStream out = new ParcelFileDescriptor.AutoCloseOutputStream(fd)) {
                     byte[] buf = new byte[CHUNK_SIZE];
                     int n;
@@ -279,16 +307,18 @@ public boolean readOutputFromFd(String token, ParcelFileDescriptor fd,
             return false;
         }
         try {
+            final ParcelFileDescriptor writeEndDup;
             synchronized (state) {
                 if (state.outputPipe == null) {
                     state.outputPipe = ParcelFileDescriptor.createPipe();
                     startOutputForwarder(state);
                 }
+                // Dup so AutoCloseOutputStream cannot close the canonical app write end.
+                writeEndDup = state.outputPipe[1].dup();
             }
-            final ParcelFileDescriptor writeEnd = state.outputPipe[1];
             new Thread(() -> {
                 try (InputStream in = new ParcelFileDescriptor.AutoCloseInputStream(fd);
-                     OutputStream out = new ParcelFileDescriptor.AutoCloseOutputStream(writeEnd)) {
+                     OutputStream out = new ParcelFileDescriptor.AutoCloseOutputStream(writeEndDup)) {
                     if (startOffset > 0) {
                         long skipped = in.skip(startOffset);
                         if (skipped < startOffset) {
@@ -461,6 +491,8 @@ private void handleIncomingData(ChannelDataRequest data) {
             try {
                 if (state.inputPipe == null) {
                     state.inputPipe = ParcelFileDescriptor.createPipe();
+                }
+                if (state.inputPipeWriter == null && state.inputPipe[1] != null) {
                     // Open a single OutputStream over the write-end PFD and keep it alive
                     // across all chunks. Wrapping the PFD rather than its raw FileDescriptor
                     // ensures the FD is NOT closed when the stream would otherwise be closed.
@@ -526,7 +558,15 @@ private void handleIncomingDataAck(ChannelDataAckRequest ack) {
      * Precondition: {@code state.outputPipe} must already be initialised.
      */
     private void startOutputForwarder(ChannelState state) {
-        final ParcelFileDescriptor readEnd = state.outputPipe[0];
+        final ParcelFileDescriptor readEnd;
+        try {
+            // Forwarder holds its own dup; ChannelState retains the canonical read end.
+            readEnd = state.outputPipe[0].dup();
+        } catch (IOException e) {
+            Log.e(TAG, "startOutputForwarder: failed to dup output read end for channel "
+                    + state.channelId, e);
+            return;
+        }
         new Thread(() -> {
             try (InputStream in = new ParcelFileDescriptor.AutoCloseInputStream(readEnd)) {
                 byte[] buf = new byte[CHUNK_SIZE];
@@ -606,6 +646,9 @@ private void sendChannelControl(String targetNodeId, ChannelControlRequest ctrl)
 
     private void dispatchChannelEvent(ChannelState state, int eventType,
             int closeReason, int appSpecificErrorCode) {
+        if (wearable == null) {
+            return;
+        }
         ChannelEventParcelable event = new ChannelEventParcelable();
         event.channel = new ChannelParcelable(state.token, state.nodeId, state.path);
         event.eventType = eventType;

play-services-wearable/core/src/main/java/org/microg/gms/wearable/NotificationBridge.java

@@ -27,6 +27,15 @@ public class NotificationBridge {
 
     private static final String TAG = "GmsWearNotifBridge";
 
+    /** Path on which the wearable peer sends notification-control commands. */
+    public static final String NOTIFICATION_COMMAND_PATH = "/wearable/notification/command";
+
+    /** Positive / content action (first Notification.Action or contentIntent). */
+    public static final byte CMD_POSITIVE = 1;
+
+    /** Negative action: dismiss / cancel the notification. */
+    public static final byte CMD_NEGATIVE = 2;
+
     /**
      * Maps notification UID (the value sent to the wearable peer) to the live
      * {@link StatusBarNotification}.  Entries are added/removed by the
@@ -35,6 +44,42 @@ public class NotificationBridge {
     public static final Map<Integer, StatusBarNotification> activeNotifications =
             new ConcurrentHashMap<>();
 
+
+    /**
+     * Dispatches a notification-control command received from the watch.
+     *
+     * <p>Payload format:
+     * <pre>
+     *   byte action  1 = positive, 2 = negative
+     *   int  uid     notification uid previously assigned by WearableNotificationService
+     * </pre>
+     */
+    public static void handleCommand(Context context, byte[] data) {
+        if (data == null || data.length < 5) {
+            Log.w(TAG, "handleCommand: empty or short payload");
+            return;
+        }
+        try {
+            java.io.DataInputStream dis =
+                    new java.io.DataInputStream(new java.io.ByteArrayInputStream(data));
+            byte action = dis.readByte();
+            int uid = dis.readInt();
+            Log.d(TAG, "handleCommand: action=" + action + ", uid=" + uid);
+            switch (action) {
+                case CMD_POSITIVE:
+                    doPositiveAction(context, uid);
+                    break;
+                case CMD_NEGATIVE:
+                    doNegativeAction(context, uid);
+                    break;
+                default:
+                    Log.w(TAG, "handleCommand: unknown action=" + action);
+            }
+        } catch (Exception e) {
+            Log.e(TAG, "handleCommand: failed to parse payload", e);
+        }
+    }
+
     /**
      * Executes the <em>positive</em> ANCS action for {@code uid}: fires the first
      * {@link android.app.Notification.Action} on the notification if one exists.