Revert "Extract network observer code from NetworkManagementService." (bfd0aa02) · Commits · e / os / android_frameworks_base

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

+248 −110

Original line number	Diff line number	Diff line
		@@ -47,8 +47,10 @@ import android.app.ActivityManager;
		import android.content.Context;
		import android.net.ConnectivityManager;
		import android.net.INetd;
		import android.net.INetdUnsolicitedEventListener;
		import android.net.INetworkManagementEventObserver;
		import android.net.ITetheringStatsProvider;
		import android.net.InetAddresses;
		import android.net.InterfaceConfiguration;
		import android.net.InterfaceConfigurationParcel;
		import android.net.IpPrefix;
		@@ -61,7 +63,6 @@ import android.net.RouteInfo;
		import android.net.TetherStatsParcel;
		import android.net.UidRange;
		import android.net.shared.NetdService;
		import android.net.shared.NetworkObserverRegistry;
		import android.os.BatteryStats;
		import android.os.Binder;
		import android.os.Handler;
		@@ -205,13 +206,16 @@ public class NetworkManagementService extends INetworkManagementService.Stub

		private INetd mNetdService;

		private NMSNetworkObserverRegistry mNetworkObserverRegistry;
		private final NetdUnsolicitedEventListener mNetdUnsolicitedEventListener;

		private IBatteryStats mBatteryStats;

		private final Thread mThread;
		private CountDownLatch mConnectedSignal = new CountDownLatch(1);

		private final RemoteCallbackList<INetworkManagementEventObserver> mObservers =
		new RemoteCallbackList<>();

		private final NetworkStatsFactory mStatsFactory = new NetworkStatsFactory();

		@GuardedBy("mTetheringStatsProviders")
		@@ -321,6 +325,8 @@ public class NetworkManagementService extends INetworkManagementService.Stub

		mDaemonHandler = new Handler(FgThread.get().getLooper());

		mNetdUnsolicitedEventListener = new NetdUnsolicitedEventListener();

		// Add ourself to the Watchdog monitors.
		Watchdog.getInstance().addMonitor(this);

		@@ -339,7 +345,7 @@ public class NetworkManagementService extends INetworkManagementService.Stub
		mFgHandler = null;
		mThread = null;
		mServices = null;
		mNetworkObserverRegistry = null;
		mNetdUnsolicitedEventListener = null;
		}

		static NetworkManagementService create(Context context, String socket, SystemServices services)
		@@ -387,12 +393,14 @@ public class NetworkManagementService extends INetworkManagementService.Stub

		@Override
		public void registerObserver(INetworkManagementEventObserver observer) {
		mNetworkObserverRegistry.registerObserver(observer);
		mContext.enforceCallingOrSelfPermission(CONNECTIVITY_INTERNAL, TAG);
		mObservers.register(observer);
		}

		@Override
		public void unregisterObserver(INetworkManagementEventObserver observer) {
		mNetworkObserverRegistry.unregisterObserver(observer);
		mContext.enforceCallingOrSelfPermission(CONNECTIVITY_INTERNAL, TAG);
		mObservers.unregister(observer);
		}

		@FunctionalInterface
		@@ -400,23 +408,69 @@ public class NetworkManagementService extends INetworkManagementService.Stub
		public void sendCallback(INetworkManagementEventObserver o) throws RemoteException;
		}

		private class NMSNetworkObserverRegistry extends NetworkObserverRegistry {
		NMSNetworkObserverRegistry(Context context, Handler handler, INetd netd)
		throws RemoteException {
		super(context, handler, netd);
		private void invokeForAllObservers(NetworkManagementEventCallback eventCallback) {
		final int length = mObservers.beginBroadcast();
		try {
		for (int i = 0; i < length; i++) {
		try {
		eventCallback.sendCallback(mObservers.getBroadcastItem(i));
		} catch (RemoteException \| RuntimeException e) {
		}
		}
		} finally {
		mObservers.finishBroadcast();
		}
		}

		/**
		* Notify our observers of an interface status change
		*/
		private void notifyInterfaceStatusChanged(String iface, boolean up) {
		invokeForAllObservers(o -> o.interfaceStatusChanged(iface, up));
		}

		/**
		* Notify our observers of an interface link state change
		* (typically, an Ethernet cable has been plugged-in or unplugged).
		*/
		private void notifyInterfaceLinkStateChanged(String iface, boolean up) {
		invokeForAllObservers(o -> o.interfaceLinkStateChanged(iface, up));
		}

		/**
		* Notify our observers of an interface addition.
		*/
		private void notifyInterfaceAdded(String iface) {
		invokeForAllObservers(o -> o.interfaceAdded(iface));
		}

		/**
		* Notify our observers of an interface removal.
		*/
		private void notifyInterfaceRemoved(String iface) {
		// netd already clears out quota and alerts for removed ifaces; update
		// our sanity-checking state.
		mActiveAlerts.remove(iface);
		mActiveQuotas.remove(iface);
		invokeForAllObservers(o -> o.interfaceRemoved(iface));
		}

		/**
		* Notify our observers of a limit reached.
		*/
		private void notifyLimitReached(String limitName, String iface) {
		invokeForAllObservers(o -> o.limitReached(limitName, iface));
		}

		/**
		* Notify our observers of a change in the data activity state of the interface
		*/
		@Override
		public void notifyInterfaceClassActivity(int type, boolean isActive, long tsNanos,
		private void notifyInterfaceClassActivity(int type, boolean isActive, long tsNanos,
		int uid, boolean fromRadio) {
		final boolean isMobile = ConnectivityManager.isNetworkTypeMobile(type);
		int powerState = isActive
		? DataConnectionRealTimeInfo.DC_POWER_STATE_HIGH
		: DataConnectionRealTimeInfo.DC_POWER_STATE_LOW;

		if (isMobile) {
		if (!fromRadio) {
		if (mMobileActivityFromRadio) {
		@@ -453,7 +507,8 @@ public class NetworkManagementService extends INetworkManagementService.Stub
		// have previously seen change reports from the radio. In that case only
		// the radio is the authority for the current state.
		final boolean active = isActive;
		super.notifyInterfaceClassActivity(type, isActive, tsNanos, uid, fromRadio);
		invokeForAllObservers(o -> o.interfaceClassDataActivityChanged(
		Integer.toString(type), active, tsNanos));
		}

		boolean report = false;
		@@ -473,27 +528,6 @@ public class NetworkManagementService extends INetworkManagementService.Stub
		}
		}

		/**
		* Notify our observers of an interface removal.
		*/
		@Override
		public void notifyInterfaceRemoved(String iface) {
		// netd already clears out quota and alerts for removed ifaces; update
		// our sanity-checking state.
		mActiveAlerts.remove(iface);
		mActiveQuotas.remove(iface);
		super.notifyInterfaceRemoved(iface);
		}

		@Override
		public void onStrictCleartextDetected(int uid, String hex) throws RemoteException {
		// Don't need to post to mDaemonHandler because the only thing
		// that notifyCleartextNetwork does is post to a handler
		ActivityManager.getService().notifyCleartextNetwork(uid,
		HexDump.hexStringToByteArray(hex));
		}
		}

		@Override
		public void registerTetheringStatsProvider(ITetheringStatsProvider provider, String name) {
		mContext.enforceCallingOrSelfPermission(NETWORK_STACK, TAG);
		@@ -519,8 +553,7 @@ public class NetworkManagementService extends INetworkManagementService.Stub
		return;
		}
		// No current code examines the interface parameter in a global alert. Just pass null.
		mDaemonHandler.post(() -> mNetworkObserverRegistry.notifyLimitReached(
		LIMIT_GLOBAL_ALERT, null));
		mDaemonHandler.post(() -> notifyLimitReached(LIMIT_GLOBAL_ALERT, null));
		}
		}

		@@ -552,11 +585,10 @@ public class NetworkManagementService extends INetworkManagementService.Stub
		private void connectNativeNetdService() {
		mNetdService = mServices.getNetd();
		try {
		mNetworkObserverRegistry = new NMSNetworkObserverRegistry(
		mContext, mDaemonHandler, mNetdService);
		if (DBG) Slog.d(TAG, "Registered NetworkObserverRegistry");
		mNetdService.registerUnsolicitedEventListener(mNetdUnsolicitedEventListener);
		if (DBG) Slog.d(TAG, "Register unsolicited event listener");
		} catch (RemoteException \| ServiceSpecificException e) {
		Slog.wtf(TAG, "Failed to register NetworkObserverRegistry: " + e);
		Slog.e(TAG, "Failed to set Netd unsolicited event listener " + e);
		}
		}

		@@ -660,6 +692,118 @@ public class NetworkManagementService extends INetworkManagementService.Stub

		}

		/**
		* Notify our observers of a new or updated interface address.
		*/
		private void notifyAddressUpdated(String iface, LinkAddress address) {
		invokeForAllObservers(o -> o.addressUpdated(iface, address));
		}

		/**
		* Notify our observers of a deleted interface address.
		*/
		private void notifyAddressRemoved(String iface, LinkAddress address) {
		invokeForAllObservers(o -> o.addressRemoved(iface, address));
		}

		/**
		* Notify our observers of DNS server information received.
		*/
		private void notifyInterfaceDnsServerInfo(String iface, long lifetime, String[] addresses) {
		invokeForAllObservers(o -> o.interfaceDnsServerInfo(iface, lifetime, addresses));
		}

		/**
		* Notify our observers of a route change.
		*/
		private void notifyRouteChange(boolean updated, RouteInfo route) {
		if (updated) {
		invokeForAllObservers(o -> o.routeUpdated(route));
		} else {
		invokeForAllObservers(o -> o.routeRemoved(route));
		}
		}

		private class NetdUnsolicitedEventListener extends INetdUnsolicitedEventListener.Stub {
		@Override
		public void onInterfaceClassActivityChanged(boolean isActive,
		int label, long timestamp, int uid) throws RemoteException {
		final long timestampNanos;
		if (timestamp <= 0) {
		timestampNanos = SystemClock.elapsedRealtimeNanos();
		} else {
		timestampNanos = timestamp;
		}
		mDaemonHandler.post(() ->
		notifyInterfaceClassActivity(label, isActive, timestampNanos, uid, false));
		}

		@Override
		public void onQuotaLimitReached(String alertName, String ifName)
		throws RemoteException {
		mDaemonHandler.post(() -> notifyLimitReached(alertName, ifName));
		}

		@Override
		public void onInterfaceDnsServerInfo(String ifName,
		long lifetime, String[] servers) throws RemoteException {
		mDaemonHandler.post(() -> notifyInterfaceDnsServerInfo(ifName, lifetime, servers));
		}

		@Override
		public void onInterfaceAddressUpdated(String addr,
		String ifName, int flags, int scope) throws RemoteException {
		final LinkAddress address = new LinkAddress(addr, flags, scope);
		mDaemonHandler.post(() -> notifyAddressUpdated(ifName, address));
		}

		@Override
		public void onInterfaceAddressRemoved(String addr,
		String ifName, int flags, int scope) throws RemoteException {
		final LinkAddress address = new LinkAddress(addr, flags, scope);
		mDaemonHandler.post(() -> notifyAddressRemoved(ifName, address));
		}

		@Override
		public void onInterfaceAdded(String ifName) throws RemoteException {
		mDaemonHandler.post(() -> notifyInterfaceAdded(ifName));
		}

		@Override
		public void onInterfaceRemoved(String ifName) throws RemoteException {
		mDaemonHandler.post(() -> notifyInterfaceRemoved(ifName));
		}

		@Override
		public void onInterfaceChanged(String ifName, boolean up)
		throws RemoteException {
		mDaemonHandler.post(() -> notifyInterfaceStatusChanged(ifName, up));
		}

		@Override
		public void onInterfaceLinkStateChanged(String ifName, boolean up)
		throws RemoteException {
		mDaemonHandler.post(() -> notifyInterfaceLinkStateChanged(ifName, up));
		}

		@Override
		public void onRouteChanged(boolean updated,
		String route, String gateway, String ifName) throws RemoteException {
		final RouteInfo processRoute = new RouteInfo(new IpPrefix(route),
		("".equals(gateway)) ? null : InetAddresses.parseNumericAddress(gateway),
		ifName);
		mDaemonHandler.post(() -> notifyRouteChange(updated, processRoute));
		}

		@Override
		public void onStrictCleartextDetected(int uid, String hex) throws RemoteException {
		// Don't need to post to mDaemonHandler because the only thing
		// that notifyCleartextNetwork does is post to a handler
		ActivityManager.getService().notifyCleartextNetwork(uid,
		HexDump.hexStringToByteArray(hex));
		}
		}

		//
		// Netd Callback handling
		//
		@@ -708,18 +852,16 @@ public class NetworkManagementService extends INetworkManagementService.Stub
		throw new IllegalStateException(errorMessage);
		}
		if (cooked[2].equals("added")) {
		mNetworkObserverRegistry.notifyInterfaceAdded(cooked[3]);
		notifyInterfaceAdded(cooked[3]);
		return true;
		} else if (cooked[2].equals("removed")) {
		mNetworkObserverRegistry.notifyInterfaceRemoved(cooked[3]);
		notifyInterfaceRemoved(cooked[3]);
		return true;
		} else if (cooked[2].equals("changed") && cooked.length == 5) {
		mNetworkObserverRegistry.notifyInterfaceStatusChanged(
		cooked[3], cooked[4].equals("up"));
		notifyInterfaceStatusChanged(cooked[3], cooked[4].equals("up"));
		return true;
		} else if (cooked[2].equals("linkstate") && cooked.length == 5) {
		mNetworkObserverRegistry.notifyInterfaceLinkStateChanged(
		cooked[3], cooked[4].equals("up"));
		notifyInterfaceLinkStateChanged(cooked[3], cooked[4].equals("up"));
		return true;
		}
		throw new IllegalStateException(errorMessage);
		@@ -733,7 +875,7 @@ public class NetworkManagementService extends INetworkManagementService.Stub
		throw new IllegalStateException(errorMessage);
		}
		if (cooked[2].equals("alert")) {
		mNetworkObserverRegistry.notifyLimitReached(cooked[3], cooked[4]);
		notifyLimitReached(cooked[3], cooked[4]);
		return true;
		}
		throw new IllegalStateException(errorMessage);
		@@ -759,9 +901,8 @@ public class NetworkManagementService extends INetworkManagementService.Stub
		timestampNanos = SystemClock.elapsedRealtimeNanos();
		}
		boolean isActive = cooked[2].equals("active");
		mNetworkObserverRegistry.notifyInterfaceClassActivity(
		Integer.parseInt(cooked[3]), isActive,
		timestampNanos, processUid, false);
		notifyInterfaceClassActivity(Integer.parseInt(cooked[3]),
		isActive, timestampNanos, processUid, false);
		return true;
		// break;
		case NetdResponseCode.InterfaceAddressChange:
		@@ -787,9 +928,9 @@ public class NetworkManagementService extends INetworkManagementService.Stub
		}

		if (cooked[2].equals("updated")) {
		mNetworkObserverRegistry.notifyAddressUpdated(iface, address);
		notifyAddressUpdated(iface, address);
		} else {
		mNetworkObserverRegistry.notifyAddressRemoved(iface, address);
		notifyAddressRemoved(iface, address);
		}
		return true;
		// break;
		@@ -809,8 +950,7 @@ public class NetworkManagementService extends INetworkManagementService.Stub
		throw new IllegalStateException(errorMessage);
		}
		String[] servers = cooked[5].split(",");
		mNetworkObserverRegistry.notifyInterfaceDnsServerInfo(
		cooked[3], lifetime, servers);
		notifyInterfaceDnsServerInfo(cooked[3], lifetime, servers);
		}
		return true;
		// break;
		@@ -849,8 +989,7 @@ public class NetworkManagementService extends INetworkManagementService.Stub
		InetAddress gateway = null;
		if (via != null) gateway = InetAddress.parseNumericAddress(via);
		RouteInfo route = new RouteInfo(new IpPrefix(cooked[3]), gateway, dev);
		mNetworkObserverRegistry.notifyRouteChange(
		cooked[2].equals("updated"), route);
		notifyRouteChange(cooked[2].equals("updated"), route);
		return true;
		} catch (IllegalArgumentException e) {}
		}
		@@ -1313,8 +1452,8 @@ public class NetworkManagementService extends INetworkManagementService.Stub
		if (ConnectivityManager.isNetworkTypeMobile(type)) {
		mNetworkActive = false;
		}
		mDaemonHandler.post(() -> mNetworkObserverRegistry.notifyInterfaceClassActivity(
		type, true /* isActive */, SystemClock.elapsedRealtimeNanos(), -1, false));
		mDaemonHandler.post(() -> notifyInterfaceClassActivity(type, true,
		SystemClock.elapsedRealtimeNanos(), -1, false));
		}
		}

		@@ -1337,9 +1476,8 @@ public class NetworkManagementService extends INetworkManagementService.Stub
		throw new IllegalStateException(e);
		}
		mActiveIdleTimers.remove(iface);
		mDaemonHandler.post(() -> mNetworkObserverRegistry.notifyInterfaceClassActivity(
		params.type, false /* isActive */, SystemClock.elapsedRealtimeNanos(), -1,
		false));
		mDaemonHandler.post(() -> notifyInterfaceClassActivity(params.type, false,
		SystemClock.elapsedRealtimeNanos(), -1, false));
		}
		}

services/net/java/android/net/shared/NetworkObserverRegistry.java

deleted100644 → 0

+0 −255

File deleted.

Preview size limit exceeded, changes collapsed.