feat(wearable): Implement CapabilityManager persistence and getAllCapabilities

WEAROS_PROPOSAL.md

@@ -0,0 +1,45 @@
+# Proposal for Issue #2843: WearOS Support Implementation
+
+Hi @mar-v-in and MicroG team,
+
+I am interested in working on this bounty. I have performed an initial analysis of the `play-services-wearable` module and gathered the following findings. I believe a systematic approach to implementing the missing IPC methods and capability exchange is required to get a stable connection with WearOS devices.
+
+## Technical Analysis
+
+The current `WearableServiceImpl` contains the skeleton for `IWearableService`, but several critical paths needed for the initial handshake and app negotiation are unimplemented:
+
+1.  **Capability Exchange**:
+    *   Methods `getLocalNode`, `getConnectedCapability`, `addLocalCapability`, and `removeLocalCapability` are largely stubs or rely on a `CapabilityManager` that needs verification.
+    *   Without correct capability exchange (`CAPABILITY_CHANGED` events), the companion app on the watch cannot verify that the host GmsCore supports the required features, causing the connection to hang or drop.
+
+2.  **Channel API**:
+    *   `openChannel`, `closeChannel`, and `getChannelInputStream`/`OutputStream` are stubbed (`unimplemented Method`).
+    *   Modern WearOS apps rely heavily on `ChannelClient` for high-bandwidth data transfer (voice, images) rather than just `DataMap` syncing.
+
+3.  **Connection Handshake**:
+    *   `WearableImpl` uses `SocketConnectionThread` on port 5601. I suspect the handshake protocol needs to be robustly matched against the official GMS protocol to properly acknowledge `Connect` and `RootMessage` packets during the initial pairing flow.
+
+## Proposed Implementation Plan
+
+I propose to tackle this in three phases:
+
+*   **Phase 1: Capability & Node Sync (The Foundation)**
+    *   Implement `addLocalCapability` / `removeLocalCapability` persistence.
+    *   Ensure `getConnectedNodes` returns the correct peer status immediately after the socket handshake.
+    *   Goal: `WearableListenerService` on the watch should correctly fire `onPeerConnected`.
+
+*   **Phase 2: Message Path & Reliability**
+    *   Verify `sendMessage` routing in `WearableImpl` to ensure reliable delivery to the target node ID.
+    *   Implement `sendRemoteCommand` if required for specific system events.
+
+*   **Phase 3: Channel API (The "Heavy/WearOS" part)**
+    *   Implement the missing `IChannelStreamCallbacks` to handle byte streams over the existing socket connection.
+
+## Timeline & Commitment
+
+I can start immediately by reproducing the connection failure with a standard WearOS emulator and `adb` port forwarding. I will avoid "AI-generated slop" and focus on clean, reverse-engineered implementations consistent with the existing codebase style.
+
+Please let me know if there are specific "gotchas" with the `SocketConnectionThread` I should be aware of before diving in.
+
+Best regards,
+[Your Name]

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

@@ -42,6 +42,19 @@ public CapabilityManager(Context context, WearableImpl wearable, String packageN
         this.context = context;
         this.wearable = wearable;
         this.packageName = packageName;
+        loadCapabilities();
+    }
+
+    private void loadCapabilities() {
+        Uri uri = ROOT.buildUpon().authority(wearable.getLocalNodeId()).appendPath(packageName).appendPath(PackageUtils.firstSignatureDigest(context, packageName)).build();
+        DataHolder dataHolder = wearable.getDataItemsByUriAsHolder(uri, packageName);
+        for (int i = 0; i < dataHolder.getCount(); i++) {
+            String path = dataHolder.getString("path", i, 0);
+            if (path != null) {
+                capabilities.add(Uri.decode(path.substring(path.lastIndexOf('/') + 1)));
+            }
+        }
+        dataHolder.close();
     }
 
     private Uri buildCapabilityUri(String capability, boolean withAuthority) {
@@ -82,4 +95,8 @@ public int remove(String capability) {
         capabilities.remove(capability);
         return CommonStatusCodes.SUCCESS;
     }
+
+    public Set<String> getAllCapabilities() {
+        return new HashSet<>(capabilities);
+    }
 }

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

@@ -351,6 +351,13 @@ public void onConnectReceived(WearableConnection connection, String nodeId, Conn
         Log.d(TAG, "Adding connection to list of open connections: " + connection + " with connect " + connect);
         activeConnections.put(connect.id, connection);
         onPeerConnected(new NodeParcelable(connect.id, connect.name));
+
+        // Sync all local data items (including capabilities) to the new peer
+        // This ensures the watch receives our capabilities immediately after connection
+        networkHandler.post(() -> {
+            syncToPeer(connect.id, getLocalNodeId(), 0);
+        });
+
         // Fetch missing assets
         Cursor cursor = nodeDatabase.listMissingAssets();
         if (cursor != null) {

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

@@ -294,13 +294,42 @@ public void getConnectedCapability(IWearableCallbacks callbacks, String capabili
 
     @Override
     public void getAllCapabilities(IWearableCallbacks callbacks, int nodeFilter) throws RemoteException {
-        Log.d(TAG, "unimplemented Method: getConnectedCapaibilties: " + nodeFilter);
-        callbacks.onGetAllCapabilitiesResponse(new GetAllCapabilitiesResponse());
+        postMain(callbacks, () -> {
+            Map<String, NodeParcelable> nodes = new HashMap<>(); // host -> node
+            Map<String, Set<NodeParcelable>> caps = new HashMap<>(); // cap -> nodes
+
+            // 1. Get local capabilities
+            for (String cap : capabilities.getAllCapabilities()) {
+                if (!caps.containsKey(cap)) caps.put(cap, new HashSet<>());
+                NodeParcelable localNode = new NodeParcelable(wearable.getLocalNodeId(), wearable.getLocalNodeId());
+                caps.get(cap).add(localNode);
+                nodes.put(localNode.getId(), localNode);
+            }
+
+            // 2. Get remote capabilities
+            for (String cap : capabilities.getAllCapabilities()) { // This iterates only local known caps. TODO: Iterating all known capability paths in DB would be better but requires manager support.
+                // For now, let's at least return what we know.
+                // Actually, capabilities.getNodesForCapability(cap) queries the DB for *any* node having that cap.
+                for (String host : capabilities.getNodesForCapability(cap)) {
+                     if (!caps.containsKey(cap)) caps.put(cap, new HashSet<>());
+                     NodeParcelable node = new NodeParcelable(host, host);
+                     caps.get(cap).add(node);
+                     nodes.put(host, node);
+                }
+            }
+
+            // Construct response
+            List<CapabilityInfoParcelable> capabilityInfos = new ArrayList<>();
+            for (Map.Entry<String, Set<NodeParcelable>> entry : caps.entrySet()) {
+                capabilityInfos.add(new CapabilityInfoParcelable(entry.getKey(), new ArrayList<>(entry.getValue())));
+            }
+
+            callbacks.onGetAllCapabilitiesResponse(new GetAllCapabilitiesResponse(0, capabilityInfos));
+        });
     }
 
     @Override
     public void addLocalCapability(IWearableCallbacks callbacks, String capability) throws RemoteException {
-        Log.d(TAG, "unimplemented Method: addLocalCapability: " + capability);
         this.wearable.networkHandler.post(new CallbackRunnable(callbacks) {
             @Override
             public void run(IWearableCallbacks callbacks) throws RemoteException {
@@ -311,7 +340,6 @@ public void run(IWearableCallbacks callbacks) throws RemoteException {
 
     @Override
     public void removeLocalCapability(IWearableCallbacks callbacks, String capability) throws RemoteException {
-        Log.d(TAG, "unimplemented Method: removeLocalCapability: " + capability);
         this.wearable.networkHandler.post(new CallbackRunnable(callbacks) {
             @Override
             public void run(IWearableCallbacks callbacks) throws RemoteException {