Merge changes Icf32cb46,I43434c80,I59dc46dc,I7df3f14b,I50f2c0e9 am: e253ce3463 (9083a4cf) · Commits · e / os / android_frameworks_base

services/core/java/com/android/server/VcnManagementService.java

+7 −13

Original line number	Original line	Diff line number	Diff line
	@@ -542,16 +542,7 @@ public class VcnManagementService extends IVcnManagementService.Stub {

	if (mVcns.containsKey(subscriptionGroup)) {		if (mVcns.containsKey(subscriptionGroup)) {
	final Vcn vcn = mVcns.get(subscriptionGroup);		final Vcn vcn = mVcns.get(subscriptionGroup);
	final int status = vcn.getStatus();
	vcn.updateConfig(config);		vcn.updateConfig(config);

	// TODO(b/183174340): Remove this once opportunistic-safe-mode is supported
	// Only notify VcnStatusCallbacks if this VCN was previously in Safe Mode
	if (status == VCN_STATUS_CODE_SAFE_MODE) {
	// TODO(b/181789060): invoke asynchronously after Vcn notifies through VcnCallback
	notifyAllPermissionedStatusCallbacksLocked(
	subscriptionGroup, VCN_STATUS_CODE_ACTIVE);
	}
	} else {		} else {
	startVcnLocked(subscriptionGroup, config);		startVcnLocked(subscriptionGroup, config);
	}		}
	@@ -941,8 +932,8 @@ public class VcnManagementService extends IVcnManagementService.Stub {
	// TODO(b/180452282): Make name more generic and implement directly with VcnManagementService		// TODO(b/180452282): Make name more generic and implement directly with VcnManagementService
	/** Callback for Vcn signals sent up to VcnManagementService. */		/** Callback for Vcn signals sent up to VcnManagementService. */
	public interface VcnCallback {		public interface VcnCallback {
	/** Called by a Vcn to signal that it has entered safe mode. */		/** Called by a Vcn to signal that its safe mode status has changed. */
	void onEnteredSafeMode();		void onSafeModeStatusChanged(boolean isInSafeMode);

	/** Called by a Vcn to signal that an error occurred. */		/** Called by a Vcn to signal that an error occurred. */
	void onGatewayConnectionError(		void onGatewayConnectionError(
	@@ -1004,15 +995,18 @@ public class VcnManagementService extends IVcnManagementService.Stub {
	}		}

	@Override		@Override
	public void onEnteredSafeMode() {		public void onSafeModeStatusChanged(boolean isInSafeMode) {
	synchronized (mLock) {		synchronized (mLock) {
	// Ignore if this subscription group doesn't exist anymore		// Ignore if this subscription group doesn't exist anymore
	if (!mVcns.containsKey(mSubGroup)) {		if (!mVcns.containsKey(mSubGroup)) {
	return;		return;
	}		}

			final int status =
			isInSafeMode ? VCN_STATUS_CODE_SAFE_MODE : VCN_STATUS_CODE_ACTIVE;

	notifyAllPolicyListenersLocked();		notifyAllPolicyListenersLocked();
	notifyAllPermissionedStatusCallbacksLocked(mSubGroup, VCN_STATUS_CODE_SAFE_MODE);		notifyAllPermissionedStatusCallbacksLocked(mSubGroup, status);
	}		}
	}		}

services/core/java/com/android/server/vcn/Vcn.java

+65 −63

Original line number	Original line	Diff line number	Diff line
	@@ -17,6 +17,7 @@
	package com.android.server.vcn;		package com.android.server.vcn;

	import static android.net.NetworkCapabilities.NET_CAPABILITY_NOT_VCN_MANAGED;		import static android.net.NetworkCapabilities.NET_CAPABILITY_NOT_VCN_MANAGED;
			import static android.net.NetworkCapabilities.TRANSPORT_CELLULAR;
	import static android.net.vcn.VcnManager.VCN_STATUS_CODE_ACTIVE;		import static android.net.vcn.VcnManager.VCN_STATUS_CODE_ACTIVE;
	import static android.net.vcn.VcnManager.VCN_STATUS_CODE_INACTIVE;		import static android.net.vcn.VcnManager.VCN_STATUS_CODE_INACTIVE;
	import static android.net.vcn.VcnManager.VCN_STATUS_CODE_SAFE_MODE;		import static android.net.vcn.VcnManager.VCN_STATUS_CODE_SAFE_MODE;
	@@ -96,16 +97,20 @@ public class Vcn extends Handler {
	*/		*/
	private static final int MSG_EVENT_GATEWAY_CONNECTION_QUIT = MSG_EVENT_BASE + 3;		private static final int MSG_EVENT_GATEWAY_CONNECTION_QUIT = MSG_EVENT_BASE + 3;

	/** Triggers an immediate teardown of the entire Vcn, including GatewayConnections. */
	private static final int MSG_CMD_TEARDOWN = MSG_CMD_BASE;

	/**		/**
	* Causes this VCN to immediately enter safe mode.		* Triggers reevaluation of safe mode conditions.
			*
			* <p>Upon entering safe mode, the VCN will only provide gateway connections opportunistically,
			* leaving the underlying networks marked as NOT_VCN_MANAGED.
	*		*
	* <p>Upon entering safe mode, the VCN will unregister its RequestListener, tear down all of its		* <p>Any VcnGatewayConnection in safe mode will result in the entire Vcn instance being put
	* VcnGatewayConnections, and notify VcnManagementService that it is in safe mode.		* into safe mode. Upon receiving this message, the Vcn MUST query all VcnGatewayConnections to
			* determine if any are in safe mode.
	*/		*/
	private static final int MSG_CMD_ENTER_SAFE_MODE = MSG_CMD_BASE + 1;		private static final int MSG_EVENT_SAFE_MODE_STATE_CHANGED = MSG_EVENT_BASE + 4;

			/** Triggers an immediate teardown of the entire Vcn, including GatewayConnections. */
			private static final int MSG_CMD_TEARDOWN = MSG_CMD_BASE;

	@NonNull private final VcnContext mVcnContext;		@NonNull private final VcnContext mVcnContext;
	@NonNull private final ParcelUuid mSubscriptionGroup;		@NonNull private final ParcelUuid mSubscriptionGroup;
	@@ -233,6 +238,11 @@ public class Vcn extends Handler {

	@Override		@Override
	public void handleMessage(@NonNull Message msg) {		public void handleMessage(@NonNull Message msg) {
			if (mCurrentStatus != VCN_STATUS_CODE_ACTIVE
			&& mCurrentStatus != VCN_STATUS_CODE_SAFE_MODE) {
			return;
			}

	switch (msg.what) {		switch (msg.what) {
	case MSG_EVENT_CONFIG_UPDATED:		case MSG_EVENT_CONFIG_UPDATED:
	handleConfigUpdated((VcnConfig) msg.obj);		handleConfigUpdated((VcnConfig) msg.obj);
	@@ -246,12 +256,12 @@ public class Vcn extends Handler {
	case MSG_EVENT_GATEWAY_CONNECTION_QUIT:		case MSG_EVENT_GATEWAY_CONNECTION_QUIT:
	handleGatewayConnectionQuit((VcnGatewayConnectionConfig) msg.obj);		handleGatewayConnectionQuit((VcnGatewayConnectionConfig) msg.obj);
	break;		break;
			case MSG_EVENT_SAFE_MODE_STATE_CHANGED:
			handleSafeModeStatusChanged();
			break;
	case MSG_CMD_TEARDOWN:		case MSG_CMD_TEARDOWN:
	handleTeardown();		handleTeardown();
	break;		break;
	case MSG_CMD_ENTER_SAFE_MODE:
	handleEnterSafeMode();
	break;
	default:		default:
	Slog.wtf(getLogTag(), "Unknown msg.what: " + msg.what);		Slog.wtf(getLogTag(), "Unknown msg.what: " + msg.what);
	}		}
	@@ -263,10 +273,8 @@ public class Vcn extends Handler {

	mConfig = config;		mConfig = config;

	// TODO(b/183174340): Remove this once opportunistic safe mode is supported.		// Teardown any GatewayConnections whose configs have been removed and get all current
	if (mCurrentStatus == VCN_STATUS_CODE_ACTIVE) {		// requests
	// VCN is already active - teardown any GatewayConnections whose configs have been
	// removed and get all current requests
	for (final Entry<VcnGatewayConnectionConfig, VcnGatewayConnection> entry :		for (final Entry<VcnGatewayConnectionConfig, VcnGatewayConnection> entry :
	mVcnGatewayConnections.entrySet()) {		mVcnGatewayConnections.entrySet()) {
	final VcnGatewayConnectionConfig gatewayConnectionConfig = entry.getKey();		final VcnGatewayConnectionConfig gatewayConnectionConfig = entry.getKey();
	@@ -277,8 +285,7 @@ public class Vcn extends Handler {
	if (!mConfig.getGatewayConnectionConfigs().contains(gatewayConnectionConfig)) {		if (!mConfig.getGatewayConnectionConfigs().contains(gatewayConnectionConfig)) {
	if (gatewayConnection == null) {		if (gatewayConnection == null) {
	Slog.wtf(		Slog.wtf(
	getLogTag(),		getLogTag(), "Found gatewayConnectionConfig without GatewayConnection");
	"Found gatewayConnectionConfig without GatewayConnection");
	} else {		} else {
	gatewayConnection.teardownAsynchronously();		gatewayConnection.teardownAsynchronously();
	}		}
	@@ -288,15 +295,6 @@ public class Vcn extends Handler {
	// Trigger a re-evaluation of all NetworkRequests (to make sure any that can be		// Trigger a re-evaluation of all NetworkRequests (to make sure any that can be
	// satisfied start a new GatewayConnection)		// satisfied start a new GatewayConnection)
	mVcnContext.getVcnNetworkProvider().resendAllRequests(mRequestListener);		mVcnContext.getVcnNetworkProvider().resendAllRequests(mRequestListener);
	} else if (mCurrentStatus == VCN_STATUS_CODE_SAFE_MODE) {
	// If this VCN was not previously active, it is exiting Safe Mode. Re-register the
	// request listener to get NetworkRequests again (and all cached requests).
	mVcnContext.getVcnNetworkProvider().registerListener(mRequestListener);
	} else {
	// Ignored; VCN was not active; config updates ignored.
	return;
	}
	mCurrentStatus = VCN_STATUS_CODE_ACTIVE;
	}		}

	private void handleTeardown() {		private void handleTeardown() {
	@@ -309,21 +307,27 @@ public class Vcn extends Handler {
	mCurrentStatus = VCN_STATUS_CODE_INACTIVE;		mCurrentStatus = VCN_STATUS_CODE_INACTIVE;
	}		}

	private void handleEnterSafeMode() {		private void handleSafeModeStatusChanged() {
	// TODO(b/183174340): Remove this once opportunistic-safe-mode is supported		boolean hasSafeModeGatewayConnection = false;
	handleTeardown();

	mCurrentStatus = VCN_STATUS_CODE_SAFE_MODE;		// If any VcnGatewayConnection is in safe mode, mark the entire VCN as being in safe mode
	mVcnCallback.onEnteredSafeMode();		for (VcnGatewayConnection gatewayConnection : mVcnGatewayConnections.values()) {
			if (gatewayConnection.isInSafeMode()) {
			hasSafeModeGatewayConnection = true;
			break;
			}
	}		}

	private void handleNetworkRequested(		final int oldStatus = mCurrentStatus;
	@NonNull NetworkRequest request, int score, int providerId) {		mCurrentStatus =
	if (mCurrentStatus != VCN_STATUS_CODE_ACTIVE) {		hasSafeModeGatewayConnection ? VCN_STATUS_CODE_SAFE_MODE : VCN_STATUS_CODE_ACTIVE;
	Slog.v(getLogTag(), "Received NetworkRequest while inactive. Ignore for now");		if (oldStatus != mCurrentStatus) {
	return;		mVcnCallback.onSafeModeStatusChanged(hasSafeModeGatewayConnection);
			}
	}		}

			private void handleNetworkRequested(
			@NonNull NetworkRequest request, int score, int providerId) {
	if (score > getNetworkScore()) {		if (score > getNetworkScore()) {
	if (VDBG) {		if (VDBG) {
	Slog.v(		Slog.v(
	@@ -376,25 +380,23 @@ public class Vcn extends Handler {
	mVcnGatewayConnections.remove(config);		mVcnGatewayConnections.remove(config);

	// Trigger a re-evaluation of all NetworkRequests (to make sure any that can be satisfied		// Trigger a re-evaluation of all NetworkRequests (to make sure any that can be satisfied
	// start a new GatewayConnection), but only if the Vcn is still alive		// start a new GatewayConnection). VCN is always alive here, courtesy of the liveness check
	if (mCurrentStatus == VCN_STATUS_CODE_ACTIVE) {		// in handleMessage()
	mVcnContext.getVcnNetworkProvider().resendAllRequests(mRequestListener);		mVcnContext.getVcnNetworkProvider().resendAllRequests(mRequestListener);
	}		}
	}

	private void handleSubscriptionsChanged(@NonNull TelephonySubscriptionSnapshot snapshot) {		private void handleSubscriptionsChanged(@NonNull TelephonySubscriptionSnapshot snapshot) {
	mLastSnapshot = snapshot;		mLastSnapshot = snapshot;

	if (mCurrentStatus == VCN_STATUS_CODE_ACTIVE) {
	for (VcnGatewayConnection gatewayConnection : mVcnGatewayConnections.values()) {		for (VcnGatewayConnection gatewayConnection : mVcnGatewayConnections.values()) {
	gatewayConnection.updateSubscriptionSnapshot(mLastSnapshot);		gatewayConnection.updateSubscriptionSnapshot(mLastSnapshot);
	}		}
	}		}
	}

	private boolean isRequestSatisfiedByGatewayConnectionConfig(		private boolean isRequestSatisfiedByGatewayConnectionConfig(
	@NonNull NetworkRequest request, @NonNull VcnGatewayConnectionConfig config) {		@NonNull NetworkRequest request, @NonNull VcnGatewayConnectionConfig config) {
	final NetworkCapabilities.Builder builder = new NetworkCapabilities.Builder();		final NetworkCapabilities.Builder builder = new NetworkCapabilities.Builder();
			builder.addTransportType(TRANSPORT_CELLULAR);
	builder.addCapability(NET_CAPABILITY_NOT_VCN_MANAGED);		builder.addCapability(NET_CAPABILITY_NOT_VCN_MANAGED);
	for (int cap : config.getAllExposedCapabilities()) {		for (int cap : config.getAllExposedCapabilities()) {
	builder.addCapability(cap);		builder.addCapability(cap);
	@@ -418,8 +420,8 @@ public class Vcn extends Handler {
	/** Callback used for passing status signals from a VcnGatewayConnection to its managing Vcn. */		/** Callback used for passing status signals from a VcnGatewayConnection to its managing Vcn. */
	@VisibleForTesting(visibility = Visibility.PACKAGE)		@VisibleForTesting(visibility = Visibility.PACKAGE)
	public interface VcnGatewayStatusCallback {		public interface VcnGatewayStatusCallback {
	/** Called by a VcnGatewayConnection to indicate that it has entered safe mode. */		/** Called by a VcnGatewayConnection to indicate that it's safe mode status has changed. */
	void onEnteredSafeMode();		void onSafeModeStatusChanged();

	/** Callback by a VcnGatewayConnection to indicate that an error occurred. */		/** Callback by a VcnGatewayConnection to indicate that an error occurred. */
	void onGatewayConnectionError(		void onGatewayConnectionError(
	@@ -445,8 +447,8 @@ public class Vcn extends Handler {
	}		}

	@Override		@Override
	public void onEnteredSafeMode() {		public void onSafeModeStatusChanged() {
	sendMessage(obtainMessage(MSG_CMD_ENTER_SAFE_MODE));		sendMessage(obtainMessage(MSG_EVENT_SAFE_MODE_STATE_CHANGED));
	}		}

	@Override		@Override

services/core/java/com/android/server/vcn/VcnGatewayConnection.java

+110 −38

Original line number	Original line	Diff line number	Diff line
	@@ -32,6 +32,7 @@ import static com.android.server.VcnManagementService.VDBG;
	import android.annotation.NonNull;		import android.annotation.NonNull;
	import android.annotation.Nullable;		import android.annotation.Nullable;
	import android.content.Context;		import android.content.Context;
			import android.net.ConnectivityManager;
	import android.net.InetAddresses;		import android.net.InetAddresses;
	import android.net.IpPrefix;		import android.net.IpPrefix;
	import android.net.IpSecManager;		import android.net.IpSecManager;
	@@ -44,6 +45,7 @@ import android.net.Network;
	import android.net.NetworkAgent;		import android.net.NetworkAgent;
	import android.net.NetworkAgentConfig;		import android.net.NetworkAgentConfig;
	import android.net.NetworkCapabilities;		import android.net.NetworkCapabilities;
			import android.net.NetworkProvider;
	import android.net.RouteInfo;		import android.net.RouteInfo;
	import android.net.TelephonyNetworkSpecifier;		import android.net.TelephonyNetworkSpecifier;
	import android.net.Uri;		import android.net.Uri;
	@@ -92,6 +94,7 @@ import java.util.List;
	import java.util.Objects;		import java.util.Objects;
	import java.util.Set;		import java.util.Set;
	import java.util.concurrent.TimeUnit;		import java.util.concurrent.TimeUnit;
			import java.util.function.Consumer;

	/**		/**
	* A single VCN Gateway Connection, providing a single public-facing VCN network.		* A single VCN Gateway Connection, providing a single public-facing VCN network.
	@@ -503,6 +506,15 @@ public class VcnGatewayConnection extends StateMachine {
	*/		*/
	private boolean mIsQuitting = false;		private boolean mIsQuitting = false;

			/**
			* Whether the VcnGatewayConnection is in safe mode.
			*
			* <p>Upon hitting the safe mode timeout, this will be set to {@code true}. In safe mode, this
			* VcnGatewayConnection will continue attempting to connect, and if a successful connection is
			* made, safe mode will be exited.
			*/
			private boolean mIsInSafeMode = false;

	/**		/**
	* The token used by the primary/current/active session.		* The token used by the primary/current/active session.
	*		*
	@@ -562,8 +574,7 @@ public class VcnGatewayConnection extends StateMachine {
	* <p>Set in Connected state, always @NonNull in Connected, Migrating states, @Nullable		* <p>Set in Connected state, always @NonNull in Connected, Migrating states, @Nullable
	* otherwise.		* otherwise.
	*/		*/
	@VisibleForTesting(visibility = Visibility.PRIVATE)		private NetworkAgent mNetworkAgent;
	NetworkAgent mNetworkAgent;

	@Nullable private WakeupMessage mTeardownTimeoutAlarm;		@Nullable private WakeupMessage mTeardownTimeoutAlarm;
	@Nullable private WakeupMessage mDisconnectRequestAlarm;		@Nullable private WakeupMessage mDisconnectRequestAlarm;
	@@ -628,6 +639,14 @@ public class VcnGatewayConnection extends StateMachine {
	start();		start();
	}		}

			/** Queries whether this VcnGatewayConnection is in safe mode. */
			public boolean isInSafeMode() {
			// Accessing internal state; must only be done on looper thread.
			mVcnContext.ensureRunningOnLooperThread();

			return mIsInSafeMode;
			}

	/**		/**
	* Asynchronously tears down this GatewayConnection, and any resources used.		* Asynchronously tears down this GatewayConnection, and any resources used.
	*		*
	@@ -1162,6 +1181,15 @@ public class VcnGatewayConnection extends StateMachine {
	}		}
	}		}

			protected void handleSafeModeTimeoutExceeded() {
			mSafeModeTimeoutAlarm = null;

			// Connectivity for this GatewayConnection is broken; tear down the Network.
			teardownNetwork();
			mIsInSafeMode = true;
			mGatewayStatusCallback.onSafeModeStatusChanged();
			}

	protected void logUnexpectedEvent(int what) {		protected void logUnexpectedEvent(int what) {
	Slog.d(TAG, String.format(		Slog.d(TAG, String.format(
	"Unexpected event code %d in state %s", what, this.getClass().getSimpleName()));		"Unexpected event code %d in state %s", what, this.getClass().getSimpleName()));
	@@ -1315,8 +1343,7 @@ public class VcnGatewayConnection extends StateMachine {
	}		}
	break;		break;
	case EVENT_SAFE_MODE_TIMEOUT_EXCEEDED:		case EVENT_SAFE_MODE_TIMEOUT_EXCEEDED:
	mGatewayStatusCallback.onEnteredSafeMode();		handleSafeModeTimeoutExceeded();
	mSafeModeTimeoutAlarm = null;
	break;		break;
	default:		default:
	logUnhandledMessage(msg);		logUnhandledMessage(msg);
	@@ -1401,8 +1428,7 @@ public class VcnGatewayConnection extends StateMachine {
	handleDisconnectRequested((EventDisconnectRequestedInfo) msg.obj);		handleDisconnectRequested((EventDisconnectRequestedInfo) msg.obj);
	break;		break;
	case EVENT_SAFE_MODE_TIMEOUT_EXCEEDED:		case EVENT_SAFE_MODE_TIMEOUT_EXCEEDED:
	mGatewayStatusCallback.onEnteredSafeMode();		handleSafeModeTimeoutExceeded();
	mSafeModeTimeoutAlarm = null;
	break;		break;
	default:		default:
	logUnhandledMessage(msg);		logUnhandledMessage(msg);
	@@ -1432,30 +1458,35 @@ public class VcnGatewayConnection extends StateMachine {
	buildNetworkCapabilities(mConnectionConfig, mUnderlying);		buildNetworkCapabilities(mConnectionConfig, mUnderlying);
	final LinkProperties lp =		final LinkProperties lp =
	buildConnectedLinkProperties(mConnectionConfig, tunnelIface, childConfig);		buildConnectedLinkProperties(mConnectionConfig, tunnelIface, childConfig);
			final NetworkAgentConfig nac =
			new NetworkAgentConfig.Builder()
			.setLegacyType(ConnectivityManager.TYPE_MOBILE)
			.build();

	final NetworkAgent agent =		final NetworkAgent agent =
	new NetworkAgent(		mDeps.newNetworkAgent(
	mVcnContext.getContext(),		mVcnContext,
	mVcnContext.getLooper(),
	TAG,		TAG,
	caps,		caps,
	lp,		lp,
	Vcn.getNetworkScore(),		Vcn.getNetworkScore(),
	new NetworkAgentConfig.Builder().build(),		nac,
	mVcnContext.getVcnNetworkProvider()) {		mVcnContext.getVcnNetworkProvider(),
	@Override		() -> {
	public void onNetworkUnwanted() {
	Slog.d(TAG, "NetworkAgent was unwanted");		Slog.d(TAG, "NetworkAgent was unwanted");
			// If network agent has already been torn down, skip sending the
			// disconnect. Unwanted() is always called, even when networkAgents
			// are unregistered in teardownNetwork(), so prevent duplicate
			// notifications.
			if (mNetworkAgent != null) {
	teardownAsynchronously();		teardownAsynchronously();
	}		}
			} /* networkUnwantedCallback */,
	@Override		(status) -> {
	public void onValidationStatus(int status, @Nullable Uri redirectUri) {
	if (status == NetworkAgent.VALIDATION_STATUS_VALID) {		if (status == NetworkAgent.VALIDATION_STATUS_VALID) {
	clearFailedAttemptCounterAndSafeModeAlarm();		clearFailedAttemptCounterAndSafeModeAlarm();
	}		}
	}		} /* validationStatusCallback */);
	};

	agent.register();		agent.register();
	agent.markConnected();		agent.markConnected();
	@@ -1469,6 +1500,11 @@ public class VcnGatewayConnection extends StateMachine {
	// Validated connection, clear failed attempt counter		// Validated connection, clear failed attempt counter
	mFailedAttempts = 0;		mFailedAttempts = 0;
	cancelSafeModeAlarm();		cancelSafeModeAlarm();

			if (mIsInSafeMode) {
			mIsInSafeMode = false;
			mGatewayStatusCallback.onSafeModeStatusChanged();
			}
	}		}

	protected void applyTransform(		protected void applyTransform(
	@@ -1488,13 +1524,6 @@ public class VcnGatewayConnection extends StateMachine {
	}		}
	}		}

	protected void setupInterface(
	int token,
	@NonNull IpSecTunnelInterface tunnelIface,
	@NonNull VcnChildSessionConfiguration childConfig) {
	setupInterface(token, tunnelIface, childConfig, null);
	}

	protected void setupInterface(		protected void setupInterface(
	int token,		int token,
	@NonNull IpSecTunnelInterface tunnelIface,		@NonNull IpSecTunnelInterface tunnelIface,
	@@ -1579,16 +1608,17 @@ public class VcnGatewayConnection extends StateMachine {
	transformCreatedInfo.direction);		transformCreatedInfo.direction);
	break;		break;
	case EVENT_SETUP_COMPLETED:		case EVENT_SETUP_COMPLETED:
			final VcnChildSessionConfiguration oldChildConfig = mChildConfig;
	mChildConfig = ((EventSetupCompletedInfo) msg.obj).childSessionConfig;		mChildConfig = ((EventSetupCompletedInfo) msg.obj).childSessionConfig;

	setupInterfaceAndNetworkAgent(mCurrentToken, mTunnelIface, mChildConfig);		setupInterfaceAndNetworkAgent(
			mCurrentToken, mTunnelIface, mChildConfig, oldChildConfig);
	break;		break;
	case EVENT_DISCONNECT_REQUESTED:		case EVENT_DISCONNECT_REQUESTED:
	handleDisconnectRequested((EventDisconnectRequestedInfo) msg.obj);		handleDisconnectRequested((EventDisconnectRequestedInfo) msg.obj);
	break;		break;
	case EVENT_SAFE_MODE_TIMEOUT_EXCEEDED:		case EVENT_SAFE_MODE_TIMEOUT_EXCEEDED:
	mGatewayStatusCallback.onEnteredSafeMode();		handleSafeModeTimeoutExceeded();
	mSafeModeTimeoutAlarm = null;
	break;		break;
	default:		default:
	logUnhandledMessage(msg);		logUnhandledMessage(msg);
	@@ -1626,8 +1656,9 @@ public class VcnGatewayConnection extends StateMachine {
	protected void setupInterfaceAndNetworkAgent(		protected void setupInterfaceAndNetworkAgent(
	int token,		int token,
	@NonNull IpSecTunnelInterface tunnelIface,		@NonNull IpSecTunnelInterface tunnelIface,
	@NonNull VcnChildSessionConfiguration childConfig) {		@NonNull VcnChildSessionConfiguration childConfig,
	setupInterface(token, tunnelIface, childConfig);		@NonNull VcnChildSessionConfiguration oldChildConfig) {
			setupInterface(token, tunnelIface, childConfig, oldChildConfig);

	if (mNetworkAgent == null) {		if (mNetworkAgent == null) {
	mNetworkAgent = buildNetworkAgent(tunnelIface, childConfig);		mNetworkAgent = buildNetworkAgent(tunnelIface, childConfig);
	@@ -1692,8 +1723,7 @@ public class VcnGatewayConnection extends StateMachine {
	handleDisconnectRequested((EventDisconnectRequestedInfo) msg.obj);		handleDisconnectRequested((EventDisconnectRequestedInfo) msg.obj);
	break;		break;
	case EVENT_SAFE_MODE_TIMEOUT_EXCEEDED:		case EVENT_SAFE_MODE_TIMEOUT_EXCEEDED:
	mGatewayStatusCallback.onEnteredSafeMode();		handleSafeModeTimeoutExceeded();
	mSafeModeTimeoutAlarm = null;
	break;		break;
	default:		default:
	logUnhandledMessage(msg);		logUnhandledMessage(msg);
	@@ -1934,6 +1964,16 @@ public class VcnGatewayConnection extends StateMachine {
	mIkeSession = session;		mIkeSession = session;
	}		}

			@VisibleForTesting(visibility = Visibility.PRIVATE)
			NetworkAgent getNetworkAgent() {
			return mNetworkAgent;
			}

			@VisibleForTesting(visibility = Visibility.PRIVATE)
			void setNetworkAgent(@Nullable NetworkAgent networkAgent) {
			mNetworkAgent = networkAgent;
			}

	@VisibleForTesting(visibility = Visibility.PRIVATE)		@VisibleForTesting(visibility = Visibility.PRIVATE)
	void sendDisconnectRequestedAndAcquireWakelock(String reason, boolean shouldQuit) {		void sendDisconnectRequestedAndAcquireWakelock(String reason, boolean shouldQuit) {
	sendMessageAndAcquireWakeLock(		sendMessageAndAcquireWakeLock(
	@@ -2018,6 +2058,38 @@ public class VcnGatewayConnection extends StateMachine {
	return new WakeupMessage(vcnContext.getContext(), handler, tag, runnable);		return new WakeupMessage(vcnContext.getContext(), handler, tag, runnable);
	}		}

			/** Builds a new NetworkAgent. */
			public NetworkAgent newNetworkAgent(
			@NonNull VcnContext vcnContext,
			@NonNull String tag,
			@NonNull NetworkCapabilities caps,
			@NonNull LinkProperties lp,
			@NonNull int score,
			@NonNull NetworkAgentConfig nac,
			@NonNull NetworkProvider provider,
			@NonNull Runnable networkUnwantedCallback,
			@NonNull Consumer<Integer> validationStatusCallback) {
			return new NetworkAgent(
			vcnContext.getContext(),
			vcnContext.getLooper(),
			tag,
			caps,
			lp,
			score,
			nac,
			provider) {
			@Override
			public void onNetworkUnwanted() {
			networkUnwantedCallback.run();
			}

			@Override
			public void onValidationStatus(int status, @Nullable Uri redirectUri) {
			validationStatusCallback.accept(status);
			}
			};
			}

	/** Gets the elapsed real time since boot, in millis. */		/** Gets the elapsed real time since boot, in millis. */
	public long getElapsedRealTime() {		public long getElapsedRealTime() {
	return SystemClock.elapsedRealtime();		return SystemClock.elapsedRealtime();

tests/vcn/java/com/android/server/VcnManagementServiceTest.java

+28 −24

File changed.

Preview size limit exceeded, changes collapsed.

tests/vcn/java/com/android/server/vcn/VcnGatewayConnectionConnectedStateTest.java

+126 −16

File changed.

Preview size limit exceeded, changes collapsed.