From 3e65131ba387c398dfa82549a0d5a1c6b7b6dcd0 Mon Sep 17 00:00:00 2001 From: Quang Anh Luong Date: Mon, 3 Jun 2024 14:58:46 +0900 Subject: [PATCH] Replace TetheringRequestParcel with TetheringRequest Replace TetheringRequestParcel with TetheringRequest in the service code. This makes future changes easier since TetheringRequest is a proper class and not an AIDL object. Bug: 216524590 Test: atest TetheringTest TetheringManagerTest Change-Id: I0cdee597d393e53feb9fe9aff4d6c67330c88599 --- .../src/android/net/TetheringManager.java | 28 ++++++- Tethering/src/android/net/ip/IpServer.java | 20 ++--- .../networkstack/tethering/Tethering.java | 39 +++++----- .../tethering/TetheringService.java | 5 +- .../tethering/util/TetheringUtils.java | 16 ---- .../tethering/TetheringServiceTest.java | 4 +- .../networkstack/tethering/TetheringTest.java | 75 +++++++++---------- .../tethering/util/TetheringUtilsTest.java | 47 ------------ .../tethering/cts/TetheringManagerTest.java | 16 ++-- 9 files changed, 105 insertions(+), 145 deletions(-) diff --git a/Tethering/common/TetheringLib/src/android/net/TetheringManager.java b/Tethering/common/TetheringLib/src/android/net/TetheringManager.java index 2963f87a36..8b3102a063 100644 --- a/Tethering/common/TetheringLib/src/android/net/TetheringManager.java +++ b/Tethering/common/TetheringLib/src/android/net/TetheringManager.java @@ -698,7 +698,11 @@ public class TetheringManager { /** A configuration set for TetheringRequest. */ private final TetheringRequestParcel mRequestParcel; - private TetheringRequest(@NonNull final TetheringRequestParcel request) { + /** + * @hide + */ + @FlaggedApi(Flags.TETHERING_REQUEST_WITH_SOFT_AP_CONFIG) + public TetheringRequest(@NonNull final TetheringRequestParcel request) { mRequestParcel = request; } @@ -901,6 +905,28 @@ public class TetheringManager { + mRequestParcel.exemptFromEntitlementCheck + ", showProvisioningUi= " + mRequestParcel.showProvisioningUi + " ]"; } + + @Override + public boolean equals(Object obj) { + if (this == obj) return true; + if (!(obj instanceof TetheringRequest otherRequest)) return false; + TetheringRequestParcel parcel = getParcel(); + TetheringRequestParcel otherParcel = otherRequest.getParcel(); + return parcel.tetheringType == otherParcel.tetheringType + && Objects.equals(parcel.localIPv4Address, otherParcel.localIPv4Address) + && Objects.equals(parcel.staticClientAddress, otherParcel.staticClientAddress) + && parcel.exemptFromEntitlementCheck == otherParcel.exemptFromEntitlementCheck + && parcel.showProvisioningUi == otherParcel.showProvisioningUi + && parcel.connectivityScope == otherParcel.connectivityScope; + } + + @Override + public int hashCode() { + TetheringRequestParcel parcel = getParcel(); + return Objects.hash(parcel.tetheringType, parcel.localIPv4Address, + parcel.staticClientAddress, parcel.exemptFromEntitlementCheck, + parcel.showProvisioningUi, parcel.connectivityScope); + } } /** diff --git a/Tethering/src/android/net/ip/IpServer.java b/Tethering/src/android/net/ip/IpServer.java index fe5a0c69ee..a213ac45f6 100644 --- a/Tethering/src/android/net/ip/IpServer.java +++ b/Tethering/src/android/net/ip/IpServer.java @@ -47,7 +47,7 @@ import android.net.RouteInfo; import android.net.RoutingCoordinatorManager; import android.net.TetheredClient; import android.net.TetheringManager; -import android.net.TetheringRequestParcel; +import android.net.TetheringManager.TetheringRequest; import android.net.dhcp.DhcpLeaseParcelable; import android.net.dhcp.DhcpServerCallbacks; import android.net.dhcp.DhcpServingParamsParcel; @@ -404,7 +404,7 @@ public class IpServer extends StateMachineShim { } /** Enable this IpServer. IpServer state machine will be tethered or localHotspot state. */ - public void enable(final int requestedState, final TetheringRequestParcel request) { + public void enable(final int requestedState, final TetheringRequest request) { sendMessage(CMD_TETHER_REQUESTED, requestedState, 0, request); } @@ -1006,18 +1006,18 @@ public class IpServer extends StateMachineShim { mLinkProperties.setInterfaceName(mIfaceName); } - private void maybeConfigureStaticIp(final TetheringRequestParcel request) { + private void maybeConfigureStaticIp(final TetheringRequest request) { // Ignore static address configuration if they are invalid or null. In theory, static // addresses should not be invalid here because TetheringManager do not allow caller to // specify invalid static address configuration. - if (request == null || request.localIPv4Address == null - || request.staticClientAddress == null || !checkStaticAddressConfiguration( - request.localIPv4Address, request.staticClientAddress)) { + if (request == null || request.getLocalIpv4Address() == null + || request.getClientStaticIpv4Address() == null || !checkStaticAddressConfiguration( + request.getLocalIpv4Address(), request.getClientStaticIpv4Address())) { return; } - mStaticIpv4ServerAddr = request.localIPv4Address; - mStaticIpv4ClientAddr = request.staticClientAddress; + mStaticIpv4ServerAddr = request.getLocalIpv4Address(); + mStaticIpv4ClientAddr = request.getClientStaticIpv4Address(); } class InitialState extends State { @@ -1034,11 +1034,11 @@ public class IpServer extends StateMachineShim { mLastError = TETHER_ERROR_NO_ERROR; switch (message.arg1) { case STATE_LOCAL_ONLY: - maybeConfigureStaticIp((TetheringRequestParcel) message.obj); + maybeConfigureStaticIp((TetheringRequest) message.obj); transitionTo(mLocalHotspotState); break; case STATE_TETHERED: - maybeConfigureStaticIp((TetheringRequestParcel) message.obj); + maybeConfigureStaticIp((TetheringRequest) message.obj); transitionTo(mTetheredState); break; default: diff --git a/Tethering/src/com/android/networkstack/tethering/Tethering.java b/Tethering/src/com/android/networkstack/tethering/Tethering.java index 0ff89d3118..c310f16778 100644 --- a/Tethering/src/com/android/networkstack/tethering/Tethering.java +++ b/Tethering/src/com/android/networkstack/tethering/Tethering.java @@ -98,7 +98,6 @@ import android.net.TetheringCallbackStartedParcel; import android.net.TetheringConfigurationParcel; import android.net.TetheringInterface; import android.net.TetheringManager.TetheringRequest; -import android.net.TetheringRequestParcel; import android.net.Uri; import android.net.ip.IpServer; import android.net.wifi.WifiClient; @@ -148,7 +147,6 @@ import com.android.networkstack.apishim.common.UnsupportedApiLevelException; import com.android.networkstack.tethering.metrics.TetheringMetrics; import com.android.networkstack.tethering.util.InterfaceSet; import com.android.networkstack.tethering.util.PrefixUtils; -import com.android.networkstack.tethering.util.TetheringUtils; import com.android.networkstack.tethering.util.VersionedBroadcastListener; import com.android.networkstack.tethering.wear.WearableConnectionManager; @@ -232,7 +230,7 @@ public class Tethering { // Currently active tethering requests per tethering type. Only one of each type can be // requested at a time. After a tethering type is requested, the map keeps tethering parameters // to be used after the interface comes up asynchronously. - private final SparseArray mActiveTetheringRequests = + private final SparseArray mActiveTetheringRequests = new SparseArray<>(); private final Context mContext; @@ -661,28 +659,27 @@ public class Tethering { processInterfaceStateChange(iface, false /* enabled */); } - void startTethering(final TetheringRequestParcel request, final String callerPkg, + void startTethering(final TetheringRequest request, final String callerPkg, final IIntResultListener listener) { mHandler.post(() -> { - final TetheringRequestParcel unfinishedRequest = mActiveTetheringRequests.get( - request.tetheringType); + final int type = request.getTetheringType(); + final TetheringRequest unfinishedRequest = mActiveTetheringRequests.get(type); // If tethering is already enabled with a different request, // disable before re-enabling. - if (unfinishedRequest != null - && !TetheringUtils.isTetheringRequestEquals(unfinishedRequest, request)) { - enableTetheringInternal(request.tetheringType, false /* disabled */, null); - mEntitlementMgr.stopProvisioningIfNeeded(request.tetheringType); + if (unfinishedRequest != null && !unfinishedRequest.equals(request)) { + enableTetheringInternal(type, false /* disabled */, null); + mEntitlementMgr.stopProvisioningIfNeeded(type); } - mActiveTetheringRequests.put(request.tetheringType, request); + mActiveTetheringRequests.put(type, request); - if (request.exemptFromEntitlementCheck) { - mEntitlementMgr.setExemptedDownstreamType(request.tetheringType); + if (request.isExemptFromEntitlementCheck()) { + mEntitlementMgr.setExemptedDownstreamType(type); } else { - mEntitlementMgr.startProvisioningIfNeeded(request.tetheringType, - request.showProvisioningUi); + mEntitlementMgr.startProvisioningIfNeeded(type, + request.getShouldShowEntitlementUi()); } - enableTetheringInternal(request.tetheringType, true /* enabled */, listener); - mTetheringMetrics.createBuilder(request.tetheringType, callerPkg); + enableTetheringInternal(type, true /* enabled */, listener); + mTetheringMetrics.createBuilder(type, callerPkg); }); } @@ -1018,7 +1015,7 @@ public class Tethering { // // This code cannot race with untether() because they both run on the handler thread. final int type = tetherState.ipServer.interfaceType(); - final TetheringRequestParcel request = mActiveTetheringRequests.get(type, null); + final TetheringRequest request = mActiveTetheringRequests.get(type, null); if (request != null) { mActiveTetheringRequests.delete(type); } @@ -1075,14 +1072,14 @@ public class Tethering { } private int getRequestedState(int type) { - final TetheringRequestParcel request = mActiveTetheringRequests.get(type); + final TetheringRequest request = mActiveTetheringRequests.get(type); // The request could have been deleted before we had a chance to complete it. // If so, assume that the scope is the default scope for this tethering type. // This likely doesn't matter - if the request has been deleted, then tethering is // likely going to be stopped soon anyway. final int connectivityScope = (request != null) - ? request.connectivityScope + ? request.getConnectivityScope() : TetheringRequest.getDefaultConnectivityScope(type); return connectivityScope == CONNECTIVITY_SCOPE_LOCAL @@ -1381,7 +1378,7 @@ public class Tethering { } @VisibleForTesting - SparseArray getActiveTetheringRequests() { + SparseArray getActiveTetheringRequests() { return mActiveTetheringRequests; } diff --git a/Tethering/src/com/android/networkstack/tethering/TetheringService.java b/Tethering/src/com/android/networkstack/tethering/TetheringService.java index 623f5023d1..a147a4a7aa 100644 --- a/Tethering/src/com/android/networkstack/tethering/TetheringService.java +++ b/Tethering/src/com/android/networkstack/tethering/TetheringService.java @@ -38,6 +38,7 @@ import android.net.INetworkStackConnector; import android.net.ITetheringConnector; import android.net.ITetheringEventCallback; import android.net.NetworkStack; +import android.net.TetheringManager.TetheringRequest; import android.net.TetheringRequestParcel; import android.net.dhcp.DhcpServerCallbacks; import android.net.dhcp.DhcpServingParamsParcel; @@ -137,8 +138,8 @@ public class TetheringService extends Service { listener)) { return; } - - mTethering.startTethering(request, callerPkg, listener); + // TODO(b/216524590): Add UID/packageName of caller to TetheringRequest here + mTethering.startTethering(new TetheringRequest(request), callerPkg, listener); } @Override diff --git a/Tethering/src/com/android/networkstack/tethering/util/TetheringUtils.java b/Tethering/src/com/android/networkstack/tethering/util/TetheringUtils.java index e6236df2cd..76c2f0d68b 100644 --- a/Tethering/src/com/android/networkstack/tethering/util/TetheringUtils.java +++ b/Tethering/src/com/android/networkstack/tethering/util/TetheringUtils.java @@ -16,7 +16,6 @@ package com.android.networkstack.tethering.util; import android.net.TetherStatsParcel; -import android.net.TetheringRequestParcel; import android.util.Log; import androidx.annotation.NonNull; @@ -29,7 +28,6 @@ import java.net.Inet6Address; import java.net.SocketException; import java.net.UnknownHostException; import java.util.Arrays; -import java.util.Objects; /** * The classes and the methods for tethering utilization. @@ -158,20 +156,6 @@ public class TetheringUtils { return s & 0xffff; } - /** Check whether two TetheringRequestParcels are the same. */ - public static boolean isTetheringRequestEquals(final TetheringRequestParcel request, - final TetheringRequestParcel otherRequest) { - if (request == otherRequest) return true; - - return request != null && otherRequest != null - && request.tetheringType == otherRequest.tetheringType - && Objects.equals(request.localIPv4Address, otherRequest.localIPv4Address) - && Objects.equals(request.staticClientAddress, otherRequest.staticClientAddress) - && request.exemptFromEntitlementCheck == otherRequest.exemptFromEntitlementCheck - && request.showProvisioningUi == otherRequest.showProvisioningUi - && request.connectivityScope == otherRequest.connectivityScope; - } - /** Get inet6 address for all nodes given scope ID. */ public static Inet6Address getAllNodesForScopeId(int scopeId) { try { diff --git a/Tethering/tests/unit/src/com/android/networkstack/tethering/TetheringServiceTest.java b/Tethering/tests/unit/src/com/android/networkstack/tethering/TetheringServiceTest.java index da81bda2a8..c0d7ad4e0a 100644 --- a/Tethering/tests/unit/src/com/android/networkstack/tethering/TetheringServiceTest.java +++ b/Tethering/tests/unit/src/com/android/networkstack/tethering/TetheringServiceTest.java @@ -45,6 +45,7 @@ import android.net.IIntResultListener; import android.net.ITetheringConnector; import android.net.ITetheringEventCallback; import android.net.TetheringManager; +import android.net.TetheringManager.TetheringRequest; import android.net.TetheringRequestParcel; import android.net.ip.IpServer; import android.os.Bundle; @@ -311,7 +312,8 @@ public final class TetheringServiceTest { result); verify(mTethering).isTetheringSupported(); verify(mTethering).isTetheringAllowed(); - verify(mTethering).startTethering(eq(request), eq(TEST_CALLER_PKG), eq(result)); + verify(mTethering).startTethering( + eq(new TetheringRequest(request)), eq(TEST_CALLER_PKG), eq(result)); } @Test diff --git a/Tethering/tests/unit/src/com/android/networkstack/tethering/TetheringTest.java b/Tethering/tests/unit/src/com/android/networkstack/tethering/TetheringTest.java index 9f430afb07..e9cde28a17 100644 --- a/Tethering/tests/unit/src/com/android/networkstack/tethering/TetheringTest.java +++ b/Tethering/tests/unit/src/com/android/networkstack/tethering/TetheringTest.java @@ -150,7 +150,7 @@ import android.net.TetheringCallbackStartedParcel; import android.net.TetheringConfigurationParcel; import android.net.TetheringInterface; import android.net.TetheringManager; -import android.net.TetheringRequestParcel; +import android.net.TetheringManager.TetheringRequest; import android.net.dhcp.DhcpLeaseParcelable; import android.net.dhcp.DhcpServerCallbacks; import android.net.dhcp.DhcpServingParamsParcel; @@ -743,22 +743,21 @@ public class TetheringTest { doReturn(upstreamState).when(mUpstreamNetworkMonitor).selectPreferredUpstreamType(any()); } - private TetheringRequestParcel createTetheringRequestParcel(final int type) { - return createTetheringRequestParcel(type, null, null, false, CONNECTIVITY_SCOPE_GLOBAL); + private TetheringRequest createTetheringRequest(final int type) { + return createTetheringRequest(type, null, null, false, CONNECTIVITY_SCOPE_GLOBAL); } - private TetheringRequestParcel createTetheringRequestParcel(final int type, - final LinkAddress serverAddr, final LinkAddress clientAddr, final boolean exempt, - final int scope) { - final TetheringRequestParcel request = new TetheringRequestParcel(); - request.tetheringType = type; - request.localIPv4Address = serverAddr; - request.staticClientAddress = clientAddr; - request.exemptFromEntitlementCheck = exempt; - request.showProvisioningUi = false; - request.connectivityScope = scope; - - return request; + private TetheringRequest createTetheringRequest(final int type, + final LinkAddress localIPv4Address, final LinkAddress staticClientAddress, + final boolean exempt, final int scope) { + TetheringRequest.Builder builder = new TetheringRequest.Builder(type) + .setExemptFromEntitlementCheck(exempt) + .setConnectivityScope(scope) + .setShouldShowEntitlementUi(false); + if (localIPv4Address != null && staticClientAddress != null) { + builder.setStaticIpv4Addresses(localIPv4Address, staticClientAddress); + } + return builder.build(); } @NonNull @@ -911,7 +910,7 @@ public class TetheringTest { private void prepareNcmTethering() { // Emulate startTethering(TETHERING_NCM) called - mTethering.startTethering(createTetheringRequestParcel(TETHERING_NCM), TEST_CALLER_PKG, + mTethering.startTethering(createTetheringRequest(TETHERING_NCM), TEST_CALLER_PKG, null); mLooper.dispatchAll(); verify(mUsbManager, times(1)).setCurrentFunctions(UsbManager.FUNCTION_NCM); @@ -919,7 +918,7 @@ public class TetheringTest { private void prepareUsbTethering() { // Emulate pressing the USB tethering button in Settings UI. - final TetheringRequestParcel request = createTetheringRequestParcel(TETHERING_USB); + final TetheringRequest request = createTetheringRequest(TETHERING_USB); mTethering.startTethering(request, TEST_CALLER_PKG, null); mLooper.dispatchAll(); @@ -1909,7 +1908,7 @@ public class TetheringTest { when(mWifiManager.startTetheredHotspot(any(SoftApConfiguration.class))).thenReturn(true); // Emulate pressing the WiFi tethering button. - mTethering.startTethering(createTetheringRequestParcel(TETHERING_WIFI), TEST_CALLER_PKG, + mTethering.startTethering(createTetheringRequest(TETHERING_WIFI), TEST_CALLER_PKG, null); mLooper.dispatchAll(); verify(mWifiManager, times(1)).startTetheredHotspot(null); @@ -1938,7 +1937,7 @@ public class TetheringTest { when(mWifiManager.startTetheredHotspot(any(SoftApConfiguration.class))).thenReturn(true); // Emulate pressing the WiFi tethering button. - mTethering.startTethering(createTetheringRequestParcel(TETHERING_WIFI), TEST_CALLER_PKG, + mTethering.startTethering(createTetheringRequest(TETHERING_WIFI), TEST_CALLER_PKG, null); mLooper.dispatchAll(); verify(mWifiManager, times(1)).startTetheredHotspot(null); @@ -1988,7 +1987,7 @@ public class TetheringTest { doThrow(new RemoteException()).when(mNetd).ipfwdEnableForwarding(TETHERING_NAME); // Emulate pressing the WiFi tethering button. - mTethering.startTethering(createTetheringRequestParcel(TETHERING_WIFI), TEST_CALLER_PKG, + mTethering.startTethering(createTetheringRequest(TETHERING_WIFI), TEST_CALLER_PKG, null); mLooper.dispatchAll(); verify(mWifiManager, times(1)).startTetheredHotspot(null); @@ -2334,7 +2333,7 @@ public class TetheringTest { tetherState = callback.pollTetherStatesChanged(); assertArrayEquals(tetherState.availableList, new TetheringInterface[] {wifiIface}); - mTethering.startTethering(createTetheringRequestParcel(TETHERING_WIFI), TEST_CALLER_PKG, + mTethering.startTethering(createTetheringRequest(TETHERING_WIFI), TEST_CALLER_PKG, null); sendWifiApStateChanged(WIFI_AP_STATE_ENABLED, TEST_WLAN_IFNAME, IFACE_IP_MODE_TETHERED); tetherState = callback.pollTetherStatesChanged(); @@ -2430,11 +2429,11 @@ public class TetheringTest { initTetheringOnTestThread(); final TetheredInterfaceRequest mockRequest = mock(TetheredInterfaceRequest.class); when(mEm.requestTetheredInterface(any(), any())).thenReturn(mockRequest); - mTethering.startTethering(createTetheringRequestParcel(TETHERING_ETHERNET), TEST_CALLER_PKG, + mTethering.startTethering(createTetheringRequest(TETHERING_ETHERNET), TEST_CALLER_PKG, null); mLooper.dispatchAll(); verify(mEm, times(1)).requestTetheredInterface(any(), any()); - mTethering.startTethering(createTetheringRequestParcel(TETHERING_ETHERNET), TEST_CALLER_PKG, + mTethering.startTethering(createTetheringRequest(TETHERING_ETHERNET), TEST_CALLER_PKG, null); mLooper.dispatchAll(); verifyNoMoreInteractions(mEm); @@ -2644,7 +2643,7 @@ public class TetheringTest { final ResultListener thirdResult = new ResultListener(TETHER_ERROR_NO_ERROR); // Enable USB tethering and check that Tethering starts USB. - mTethering.startTethering(createTetheringRequestParcel(TETHERING_USB), TEST_CALLER_PKG, + mTethering.startTethering(createTetheringRequest(TETHERING_USB), TEST_CALLER_PKG, firstResult); mLooper.dispatchAll(); firstResult.assertHasResult(); @@ -2652,7 +2651,7 @@ public class TetheringTest { verifyNoMoreInteractions(mUsbManager); // Enable USB tethering again with the same request and expect no change to USB. - mTethering.startTethering(createTetheringRequestParcel(TETHERING_USB), TEST_CALLER_PKG, + mTethering.startTethering(createTetheringRequest(TETHERING_USB), TEST_CALLER_PKG, secondResult); mLooper.dispatchAll(); secondResult.assertHasResult(); @@ -2661,7 +2660,7 @@ public class TetheringTest { // Enable USB tethering with a different request and expect that USB is stopped and // started. - mTethering.startTethering(createTetheringRequestParcel(TETHERING_USB, + mTethering.startTethering(createTetheringRequest(TETHERING_USB, serverLinkAddr, clientLinkAddr, false, CONNECTIVITY_SCOPE_GLOBAL), TEST_CALLER_PKG, thirdResult); mLooper.dispatchAll(); @@ -2692,7 +2691,7 @@ public class TetheringTest { final int clientAddrParceled = 0xc0a8002a; final ArgumentCaptor dhcpParamsCaptor = ArgumentCaptor.forClass(DhcpServingParamsParcel.class); - mTethering.startTethering(createTetheringRequestParcel(TETHERING_USB, + mTethering.startTethering(createTetheringRequest(TETHERING_USB, serverLinkAddr, clientLinkAddr, false, CONNECTIVITY_SCOPE_GLOBAL), TEST_CALLER_PKG, null); mLooper.dispatchAll(); @@ -2820,8 +2819,8 @@ public class TetheringTest { public void testExemptFromEntitlementCheck() throws Exception { initTetheringOnTestThread(); setupForRequiredProvisioning(); - final TetheringRequestParcel wifiNotExemptRequest = - createTetheringRequestParcel(TETHERING_WIFI, null, null, false, + final TetheringRequest wifiNotExemptRequest = + createTetheringRequest(TETHERING_WIFI, null, null, false, CONNECTIVITY_SCOPE_GLOBAL); mTethering.startTethering(wifiNotExemptRequest, TEST_CALLER_PKG, null); mLooper.dispatchAll(); @@ -2834,8 +2833,8 @@ public class TetheringTest { reset(mEntitleMgr); setupForRequiredProvisioning(); - final TetheringRequestParcel wifiExemptRequest = - createTetheringRequestParcel(TETHERING_WIFI, null, null, true, + final TetheringRequest wifiExemptRequest = + createTetheringRequest(TETHERING_WIFI, null, null, true, CONNECTIVITY_SCOPE_GLOBAL); mTethering.startTethering(wifiExemptRequest, TEST_CALLER_PKG, null); mLooper.dispatchAll(); @@ -2954,7 +2953,7 @@ public class TetheringTest { when(mEm.requestTetheredInterface(any(), any())).thenReturn(mockRequest); final ArgumentCaptor callbackCaptor = ArgumentCaptor.forClass(TetheredInterfaceCallback.class); - mTethering.startTethering(createTetheringRequestParcel(TETHERING_ETHERNET), + mTethering.startTethering(createTetheringRequest(TETHERING_ETHERNET), TEST_CALLER_PKG, null); mLooper.dispatchAll(); verify(mEm).requestTetheredInterface(any(), callbackCaptor.capture()); @@ -3235,7 +3234,7 @@ public class TetheringTest { final ResultListener result = new ResultListener(TETHER_ERROR_NO_ERROR); mockBluetoothSettings(true /* bluetoothOn */, true /* tetheringOn */); - mTethering.startTethering(createTetheringRequestParcel(TETHERING_BLUETOOTH), + mTethering.startTethering(createTetheringRequest(TETHERING_BLUETOOTH), TEST_CALLER_PKG, result); mLooper.dispatchAll(); verifySetBluetoothTethering(true /* enable */, true /* bindToPanService */); @@ -3272,7 +3271,7 @@ public class TetheringTest { final ResultListener result = new ResultListener(TETHER_ERROR_NO_ERROR); mockBluetoothSettings(true /* bluetoothOn */, true /* tetheringOn */); - mTethering.startTethering(createTetheringRequestParcel(TETHERING_BLUETOOTH), + mTethering.startTethering(createTetheringRequest(TETHERING_BLUETOOTH), TEST_CALLER_PKG, result); mLooper.dispatchAll(); verifySetBluetoothTethering(true /* enable */, true /* bindToPanService */); @@ -3294,7 +3293,7 @@ public class TetheringTest { // already bound. mockBluetoothSettings(true /* bluetoothOn */, true /* tetheringOn */); final ResultListener secondResult = new ResultListener(TETHER_ERROR_NO_ERROR); - mTethering.startTethering(createTetheringRequestParcel(TETHERING_BLUETOOTH), + mTethering.startTethering(createTetheringRequest(TETHERING_BLUETOOTH), TEST_CALLER_PKG, secondResult); mLooper.dispatchAll(); verifySetBluetoothTethering(true /* enable */, false /* bindToPanService */); @@ -3317,7 +3316,7 @@ public class TetheringTest { initTetheringOnTestThread(); final ResultListener result = new ResultListener(TETHER_ERROR_NO_ERROR); mockBluetoothSettings(true /* bluetoothOn */, true /* tetheringOn */); - mTethering.startTethering(createTetheringRequestParcel(TETHERING_BLUETOOTH), + mTethering.startTethering(createTetheringRequest(TETHERING_BLUETOOTH), TEST_CALLER_PKG, result); mLooper.dispatchAll(); ServiceListener panListener = verifySetBluetoothTethering(true /* enable */, @@ -3487,7 +3486,7 @@ public class TetheringTest { // If TETHERING_USB is forced to use ncm function, TETHERING_NCM would no longer be // available. final ResultListener ncmResult = new ResultListener(TETHER_ERROR_SERVICE_UNAVAIL); - mTethering.startTethering(createTetheringRequestParcel(TETHERING_NCM), TEST_CALLER_PKG, + mTethering.startTethering(createTetheringRequest(TETHERING_NCM), TEST_CALLER_PKG, ncmResult); mLooper.dispatchAll(); ncmResult.assertHasResult(); @@ -3638,7 +3637,7 @@ public class TetheringTest { when(mWifiManager.startTetheredHotspot(any())).thenReturn(true); // Emulate pressing the WiFi tethering button. - mTethering.startTethering(createTetheringRequestParcel(TETHERING_WIFI), TEST_CALLER_PKG, + mTethering.startTethering(createTetheringRequest(TETHERING_WIFI), TEST_CALLER_PKG, null); mLooper.dispatchAll(); verify(mWifiManager).startTetheredHotspot(null); diff --git a/Tethering/tests/unit/src/com/android/networkstack/tethering/util/TetheringUtilsTest.java b/Tethering/tests/unit/src/com/android/networkstack/tethering/util/TetheringUtilsTest.java index 94ce2b6370..f0770f9c17 100644 --- a/Tethering/tests/unit/src/com/android/networkstack/tethering/util/TetheringUtilsTest.java +++ b/Tethering/tests/unit/src/com/android/networkstack/tethering/util/TetheringUtilsTest.java @@ -15,8 +15,6 @@ */ package com.android.networkstack.tethering.util; -import static android.net.TetheringManager.CONNECTIVITY_SCOPE_LOCAL; -import static android.net.TetheringManager.TETHERING_USB; import static android.net.TetheringManager.TETHERING_WIFI; import static android.system.OsConstants.AF_UNIX; import static android.system.OsConstants.EAGAIN; @@ -25,8 +23,6 @@ import static android.system.OsConstants.SOCK_DGRAM; import static android.system.OsConstants.SOCK_NONBLOCK; import static junit.framework.Assert.assertEquals; -import static junit.framework.Assert.assertFalse; -import static junit.framework.Assert.assertTrue; import android.net.LinkAddress; import android.net.MacAddress; @@ -43,9 +39,7 @@ import com.android.net.module.util.Struct; import com.android.net.module.util.structs.EthernetHeader; import com.android.net.module.util.structs.Icmpv6Header; import com.android.net.module.util.structs.Ipv6Header; -import com.android.testutils.MiscAsserts; -import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; @@ -61,13 +55,6 @@ public class TetheringUtilsTest { private static final LinkAddress TEST_CLIENT_ADDR = new LinkAddress("192.168.43.5/24"); private static final int PACKET_SIZE = 1500; - private TetheringRequestParcel mTetheringRequest; - - @Before - public void setUp() { - mTetheringRequest = makeTetheringRequestParcel(); - } - public TetheringRequestParcel makeTetheringRequestParcel() { final TetheringRequestParcel request = new TetheringRequestParcel(); request.tetheringType = TETHERING_WIFI; @@ -78,40 +65,6 @@ public class TetheringUtilsTest { return request; } - @Test - public void testIsTetheringRequestEquals() { - TetheringRequestParcel request = makeTetheringRequestParcel(); - - assertTrue(TetheringUtils.isTetheringRequestEquals(mTetheringRequest, mTetheringRequest)); - assertTrue(TetheringUtils.isTetheringRequestEquals(mTetheringRequest, request)); - assertTrue(TetheringUtils.isTetheringRequestEquals(null, null)); - assertFalse(TetheringUtils.isTetheringRequestEquals(mTetheringRequest, null)); - assertFalse(TetheringUtils.isTetheringRequestEquals(null, mTetheringRequest)); - - request = makeTetheringRequestParcel(); - request.tetheringType = TETHERING_USB; - assertFalse(TetheringUtils.isTetheringRequestEquals(mTetheringRequest, request)); - - request = makeTetheringRequestParcel(); - request.localIPv4Address = null; - request.staticClientAddress = null; - assertFalse(TetheringUtils.isTetheringRequestEquals(mTetheringRequest, request)); - - request = makeTetheringRequestParcel(); - request.exemptFromEntitlementCheck = true; - assertFalse(TetheringUtils.isTetheringRequestEquals(mTetheringRequest, request)); - - request = makeTetheringRequestParcel(); - request.showProvisioningUi = false; - assertFalse(TetheringUtils.isTetheringRequestEquals(mTetheringRequest, request)); - - request = makeTetheringRequestParcel(); - request.connectivityScope = CONNECTIVITY_SCOPE_LOCAL; - assertFalse(TetheringUtils.isTetheringRequestEquals(mTetheringRequest, request)); - - MiscAsserts.assertFieldCountEquals(6, TetheringRequestParcel.class); - } - // Writes the specified packet to a filedescriptor, skipping the Ethernet header. // Needed because the Ipv6Utils methods for building packets always include the Ethernet header, // but socket filters applied by TetheringUtils expect the packet to start from the IP header. diff --git a/tests/cts/tethering/src/android/tethering/cts/TetheringManagerTest.java b/tests/cts/tethering/src/android/tethering/cts/TetheringManagerTest.java index 81608f7306..8794847880 100644 --- a/tests/cts/tethering/src/android/tethering/cts/TetheringManagerTest.java +++ b/tests/cts/tethering/src/android/tethering/cts/TetheringManagerTest.java @@ -235,6 +235,12 @@ public class TetheringManagerTest { assertEquals(TETHERING_USB, tr2.getTetheringType()); assertTrue(tr2.isExemptFromEntitlementCheck()); assertFalse(tr2.getShouldShowEntitlementUi()); + + final TetheringRequest tr3 = new TetheringRequest.Builder(TETHERING_USB) + .setStaticIpv4Addresses(localAddr, clientAddr) + .setExemptFromEntitlementCheck(true) + .setShouldShowEntitlementUi(false).build(); + assertEquals(tr2, tr3); } @Test @@ -246,15 +252,7 @@ public class TetheringManagerTest { .setExemptFromEntitlementCheck(true) .setShouldShowEntitlementUi(false).build(); final TetheringRequest parceled = ParcelUtils.parcelingRoundTrip(unparceled); - assertEquals(unparceled.getTetheringType(), parceled.getTetheringType()); - assertEquals(unparceled.getConnectivityScope(), parceled.getConnectivityScope()); - assertEquals(unparceled.getLocalIpv4Address(), parceled.getLocalIpv4Address()); - assertEquals(unparceled.getClientStaticIpv4Address(), - parceled.getClientStaticIpv4Address()); - assertEquals(unparceled.isExemptFromEntitlementCheck(), - parceled.isExemptFromEntitlementCheck()); - assertEquals(unparceled.getShouldShowEntitlementUi(), - parceled.getShouldShowEntitlementUi()); + assertEquals(unparceled, parceled); } @Test