Merge "Implement the USD callbacks in the framework mainline supplicant class." into main

2 files changed, 219 insertions, 9 deletions

diff --git a/service/java/com/android/server/wifi/mainline_supplicant/MainlineSupplicant.java b/service/java/com/android/server/wifi/mainline_supplicant/MainlineSupplicant.java
index 6310577077..21ed502075 100644
--- a/service/java/com/android/server/wifi/mainline_supplicant/MainlineSupplicant.java
+++ b/service/java/com/android/server/wifi/mainline_supplicant/MainlineSupplicant.java
@@ -30,6 +30,7 @@ import android.util.Log;
 import com.android.internal.annotations.VisibleForTesting;
 import com.android.server.wifi.WifiNative;
 import com.android.server.wifi.WifiThreadRunner;
+import com.android.server.wifi.usd.UsdNativeManager;
 import com.android.wifi.flags.Flags;
 
 import java.util.HashMap;
@@ -57,6 +58,7 @@ public class MainlineSupplicant {
     private final boolean mIsServiceAvailable;
     private Map<String, IStaInterface> mActiveStaIfaces = new HashMap<>();
     private Map<String, IStaInterfaceCallback> mStaIfaceCallbacks = new HashMap<>();
+    private UsdNativeManager.UsdEventsCallback mUsdEventsCallback = null;
 
     public MainlineSupplicant(@NonNull WifiThreadRunner wifiThreadRunner) {
         mWifiThreadRunner = wifiThreadRunner;
@@ -281,6 +283,22 @@ public class MainlineSupplicant {
     }
 
     /**
+     * Register a framework callback to receive USD events.
+     */
+    public void registerUsdEventsCallback(
+            @NonNull UsdNativeManager.UsdEventsCallback usdEventsCallback) {
+        mUsdEventsCallback = usdEventsCallback;
+    }
+
+    /**
+     * Get the registered USD events callback. Method should only be used
+     * by {@link MainlineSupplicantStaIfaceCallback}.
+     */
+    protected @Nullable UsdNativeManager.UsdEventsCallback getUsdEventsCallback() {
+        return mUsdEventsCallback;
+    }
+
+    /**
      * Stop the mainline supplicant process.
      */
     public void stopService() {
diff --git a/service/java/com/android/server/wifi/mainline_supplicant/MainlineSupplicantStaIfaceCallback.java b/service/java/com/android/server/wifi/mainline_supplicant/MainlineSupplicantStaIfaceCallback.java
index 20cda62861..4d6207357e 100644
--- a/service/java/com/android/server/wifi/mainline_supplicant/MainlineSupplicantStaIfaceCallback.java
+++ b/service/java/com/android/server/wifi/mainline_supplicant/MainlineSupplicantStaIfaceCallback.java
@@ -17,15 +17,26 @@
 package com.android.server.wifi.mainline_supplicant;
 
 import android.annotation.NonNull;
+import android.annotation.Nullable;
+import android.annotation.SuppressLint;
+import android.net.MacAddress;
+import android.net.wifi.usd.Config;
+import android.net.wifi.usd.SessionCallback;
 import android.system.wifi.mainline_supplicant.IStaInterfaceCallback;
 import android.system.wifi.mainline_supplicant.UsdMessageInfo;
+import android.system.wifi.mainline_supplicant.UsdServiceProtoType;
+import android.util.Log;
 
 import com.android.server.wifi.WifiThreadRunner;
+import com.android.server.wifi.usd.UsdNativeManager;
+import com.android.server.wifi.usd.UsdRequestManager;
 
 /**
  * Implementation of the mainline supplicant {@link IStaInterfaceCallback}.
  */
 public class MainlineSupplicantStaIfaceCallback extends IStaInterfaceCallback.Stub {
+    private static final String TAG = "MainlineSupplicantStaIfaceCallback";
+
     private final MainlineSupplicant mMainlineSupplicant;
     private final String mIfaceName;
     private final WifiThreadRunner mWifiThreadRunner;
@@ -45,7 +56,17 @@ public class MainlineSupplicantStaIfaceCallback extends IStaInterfaceCallback.St
      * @param publishId Identifier for the publish session.
      */
     @Override
-    public void onUsdPublishStarted(int cmdId, int publishId) { }
+    public void onUsdPublishStarted(int cmdId, int publishId) {
+        mWifiThreadRunner.post(() -> {
+            UsdNativeManager.UsdEventsCallback usdCallback =
+                    mMainlineSupplicant.getUsdEventsCallback();
+            if (usdCallback == null) {
+                Log.e(TAG, "UsdEventsCallback callback is null");
+                return;
+            }
+            usdCallback.onUsdPublishStarted(cmdId, publishId);
+        });
+    }
 
     /**
      * Called in response to startUsdSubscribe to indicate that the subscribe session
@@ -55,7 +76,30 @@ public class MainlineSupplicantStaIfaceCallback extends IStaInterfaceCallback.St
      * @param subscribeId Identifier for the subscribe session.
      */
     @Override
-    public void onUsdSubscribeStarted(int cmdId, int subscribeId) { }
+    public void onUsdSubscribeStarted(int cmdId, int subscribeId) {
+        mWifiThreadRunner.post(() -> {
+            UsdNativeManager.UsdEventsCallback usdCallback =
+                    mMainlineSupplicant.getUsdEventsCallback();
+            if (usdCallback == null) {
+                Log.e(TAG, "UsdEventsCallback callback is null");
+                return;
+            }
+            usdCallback.onUsdSubscribeStarted(cmdId, subscribeId);
+        });
+    }
+
+    @SuppressLint("NewApi")
+    private static @SessionCallback.FailureCode int
+            convertHalToFrameworkUsdConfigErrorCode(int errorCode) {
+        switch (errorCode) {
+            case UsdConfigErrorCode.FAILURE_TIMEOUT:
+                return SessionCallback.FAILURE_TIMEOUT;
+            case UsdConfigErrorCode.FAILURE_NOT_AVAILABLE:
+                return SessionCallback.FAILURE_NOT_AVAILABLE;
+            default:
+                return SessionCallback.FAILURE_UNKNOWN;
+        }
+    }
 
     /**
      * Called in response to startUsdPublish to indicate that the publish session
@@ -64,7 +108,18 @@ public class MainlineSupplicantStaIfaceCallback extends IStaInterfaceCallback.St
      * @param cmdId Identifier for the original request.
      * @param errorCode Code indicating the failure reason.
      */
-    @Override public void onUsdPublishConfigFailed(int cmdId, int errorCode)  { }
+    @Override public void onUsdPublishConfigFailed(int cmdId, int errorCode)  {
+        mWifiThreadRunner.post(() -> {
+            UsdNativeManager.UsdEventsCallback usdCallback =
+                    mMainlineSupplicant.getUsdEventsCallback();
+            if (usdCallback == null) {
+                Log.e(TAG, "UsdEventsCallback callback is null");
+                return;
+            }
+            usdCallback.onUsdPublishConfigFailed(cmdId,
+                    convertHalToFrameworkUsdConfigErrorCode(errorCode));
+        });
+    }
 
     /**
      * Called in response to startUsdSubscribe to indicate that the subscribe session
@@ -74,7 +129,29 @@ public class MainlineSupplicantStaIfaceCallback extends IStaInterfaceCallback.St
      * @param errorCode Code indicating the failure reason.
      */
     @Override
-    public void onUsdSubscribeConfigFailed(int cmdId, int errorCode) { }
+    public void onUsdSubscribeConfigFailed(int cmdId, int errorCode) {
+        mWifiThreadRunner.post(() -> {
+            UsdNativeManager.UsdEventsCallback usdCallback =
+                    mMainlineSupplicant.getUsdEventsCallback();
+            if (usdCallback == null) {
+                Log.e(TAG, "UsdEventsCallback callback is null");
+                return;
+            }
+            usdCallback.onUsdSubscribeConfigFailed(cmdId,
+                    convertHalToFrameworkUsdConfigErrorCode(errorCode));
+        });
+    }
+
+    @SuppressLint("NewApi")
+    private static @SessionCallback.TerminationReasonCode int
+            convertHalToFrameworkUsdTerminateReasonCode(int reasonCode) {
+        switch (reasonCode) {
+            case UsdTerminateReasonCode.USER_REQUESTED:
+                return SessionCallback.TERMINATION_REASON_USER_INITIATED;
+            default:
+                return SessionCallback.TERMINATION_REASON_UNKNOWN;
+        }
+    }
 
     /**
      * Called in response to cancelUsdPublish to indicate that the session was cancelled
@@ -84,7 +161,18 @@ public class MainlineSupplicantStaIfaceCallback extends IStaInterfaceCallback.St
      * @param reasonCode Code indicating the reason for the session cancellation.
      */
     @Override
-    public void onUsdPublishTerminated(int publishId, int reasonCode) { }
+    public void onUsdPublishTerminated(int publishId, int reasonCode) {
+        mWifiThreadRunner.post(() -> {
+            UsdNativeManager.UsdEventsCallback usdCallback =
+                    mMainlineSupplicant.getUsdEventsCallback();
+            if (usdCallback == null) {
+                Log.e(TAG, "UsdEventsCallback callback is null");
+                return;
+            }
+            usdCallback.onUsdPublishTerminated(publishId,
+                    convertHalToFrameworkUsdTerminateReasonCode(reasonCode));
+        });
+    }
 
     /**
      * Called in response to cancelUsdSubscribe to indicate that the session was cancelled
@@ -94,7 +182,59 @@ public class MainlineSupplicantStaIfaceCallback extends IStaInterfaceCallback.St
      * @param reasonCode Code indicating the reason for the session cancellation.
      */
     @Override
-    public void onUsdSubscribeTerminated(int subscribeId, int reasonCode) {  }
+    public void onUsdSubscribeTerminated(int subscribeId, int reasonCode) {
+        mWifiThreadRunner.post(() -> {
+            UsdNativeManager.UsdEventsCallback usdCallback =
+                    mMainlineSupplicant.getUsdEventsCallback();
+            if (usdCallback == null) {
+                Log.e(TAG, "UsdEventsCallback callback is null");
+                return;
+            }
+            usdCallback.onUsdSubscribeTerminated(subscribeId,
+                    convertHalToFrameworkUsdTerminateReasonCode(reasonCode));
+        });
+    }
+
+    private static @Config.ServiceProtoType int
+            convertHalToFrameworkUsdProtocolType(int protocolType) {
+        switch (protocolType) {
+            case UsdServiceProtoType.CSA_MATTER:
+                return Config.SERVICE_PROTO_TYPE_CSA_MATTER;
+            default:
+                return Config.SERVICE_PROTO_TYPE_GENERIC;
+        }
+    }
+
+    private static @Nullable MacAddress safeConvertMacAddress(byte[] macAddrBytes) {
+        if (macAddrBytes == null) return null;
+        try {
+            return MacAddress.fromBytes(macAddrBytes);
+        } catch (Exception e) {
+            return null;
+        }
+    }
+
+    private static UsdRequestManager.UsdHalDiscoveryInfo
+            convertHalToFrameworkUsdDiscoveryInfo(UsdServiceDiscoveryInfo discoveryInfo) {
+        if (discoveryInfo.peerMacAddress == null
+                || discoveryInfo.serviceSpecificInfo == null
+                || discoveryInfo.matchFilter == null) {
+            Log.e(TAG, "USD discovery info contains a null parameter");
+            return null;
+        }
+        MacAddress peerAddress = safeConvertMacAddress(discoveryInfo.peerMacAddress);
+        if (peerAddress == null) {
+            Log.e(TAG, "USD discovery info contains an invalid peer address");
+            return null;
+        }
+        return new UsdRequestManager.UsdHalDiscoveryInfo(discoveryInfo.ownId,
+                discoveryInfo.peerId,
+                peerAddress,
+                discoveryInfo.serviceSpecificInfo,
+                convertHalToFrameworkUsdProtocolType(discoveryInfo.serviceProtoType),
+                discoveryInfo.isFsd,
+                discoveryInfo.matchFilter);
+    }
 
     /**
      * Indicates that the publisher sent a solicited publish message to the subscriber.
@@ -102,7 +242,22 @@ public class MainlineSupplicantStaIfaceCallback extends IStaInterfaceCallback.St
      * @param info Instance of |UsdServiceDiscoveryInfo| containing information about the reply.
      */
     @Override
-    public void onUsdPublishReplied(UsdServiceDiscoveryInfo info) { }
+    public void onUsdPublishReplied(UsdServiceDiscoveryInfo info) {
+        mWifiThreadRunner.post(() -> {
+            UsdNativeManager.UsdEventsCallback usdCallback =
+                    mMainlineSupplicant.getUsdEventsCallback();
+            if (usdCallback == null) {
+                Log.e(TAG, "UsdEventsCallback callback is null");
+                return;
+            }
+            UsdRequestManager.UsdHalDiscoveryInfo convertedInfo =
+                    convertHalToFrameworkUsdDiscoveryInfo(info);
+            if (convertedInfo == null) {
+                return;
+            }
+            usdCallback.onUsdPublishReplied(convertedInfo);
+        });
+    }
 
     /**
      * Indicates that a publisher was discovered. Only called if this device is acting as a
@@ -111,7 +266,22 @@ public class MainlineSupplicantStaIfaceCallback extends IStaInterfaceCallback.St
      * @param info Instance of |UsdServiceDiscoveryInfo| containing information about the service.
      */
     @Override
-    public void onUsdServiceDiscovered(UsdServiceDiscoveryInfo info) { }
+    public void onUsdServiceDiscovered(UsdServiceDiscoveryInfo info) {
+        mWifiThreadRunner.post(() -> {
+            UsdNativeManager.UsdEventsCallback usdCallback =
+                    mMainlineSupplicant.getUsdEventsCallback();
+            if (usdCallback == null) {
+                Log.e(TAG, "UsdEventsCallback callback is null");
+                return;
+            }
+            UsdRequestManager.UsdHalDiscoveryInfo convertedInfo =
+                    convertHalToFrameworkUsdDiscoveryInfo(info);
+            if (convertedInfo == null) {
+                return;
+            }
+            usdCallback.onUsdServiceDiscovered(convertedInfo);
+        });
+    }
 
     /**
      * Indicates that a message was received on an active USD link.
@@ -119,5 +289,27 @@ public class MainlineSupplicantStaIfaceCallback extends IStaInterfaceCallback.St
      * @param messageInfo Information about the message that was received.
      */
     @Override
-    public void onUsdMessageReceived(UsdMessageInfo messageInfo) { }
+    public void onUsdMessageReceived(UsdMessageInfo messageInfo) {
+        mWifiThreadRunner.post(() -> {
+            UsdNativeManager.UsdEventsCallback usdCallback =
+                    mMainlineSupplicant.getUsdEventsCallback();
+            if (usdCallback == null) {
+                Log.e(TAG, "UsdEventsCallback callback is null");
+                return;
+            }
+            MacAddress peerAddress = safeConvertMacAddress(messageInfo.peerMacAddress);
+            if (peerAddress == null) {
+                Log.e(TAG, "USD message info contains an invalid peer address");
+                return;
+            }
+            if (messageInfo.message == null) {
+                Log.e(TAG, "USD message info contains a null message");
+                return;
+            }
+            usdCallback.onUsdMessageReceived(messageInfo.ownId,
+                    messageInfo.peerId,
+                    peerAddress,
+                    messageInfo.message);
+        });
+    }
 }