Merge changes If51b6676,Ia6863a70,I802d2316 am: 76851bd64d (4740b853) · Commits · e / os / android_frameworks_base

packages/ConnectivityT/framework-t/src/android/app/usage/NetworkStatsManager.java

+79 −1

Original line number	Diff line number	Diff line
		@@ -142,7 +142,15 @@ public class NetworkStatsManager {
		setAugmentWithSubscriptionPlan(true);
		}

		/** @hide */
		/**
		* Set poll on open flag to indicate the poll is needed before service gets statistics
		* result. This is default enabled. However, for any non-privileged caller, the poll might
		* be omitted in case of rate limiting.
		*
		* @param pollOnOpen true if poll is needed.
		* @hide
		*/
		// @SystemApi(client = MODULE_LIBRARIES)
		public void setPollOnOpen(boolean pollOnOpen) {
		if (pollOnOpen) {
		mFlags \|= FLAG_POLL_ON_OPEN;
		@@ -863,4 +871,74 @@ public class NetworkStatsManager {
		return msg.getData().getParcelable(key);
		}
		}

		/**
		* Mark given UID as being in foreground for stats purposes.
		*
		* @hide
		*/
		// @SystemApi
		@RequiresPermission(anyOf = {
		NetworkStack.PERMISSION_MAINLINE_NETWORK_STACK,
		android.Manifest.permission.NETWORK_STACK})
		public void setUidForeground(int uid, boolean uidForeground) {
		try {
		mService.setUidForeground(uid, uidForeground);
		} catch (RemoteException e) {
		throw e.rethrowFromSystemServer();
		}
		}

		/**
		* Advise persistence threshold; may be overridden internally.
		*
		* @hide
		*/
		// @SystemApi
		@RequiresPermission(anyOf = {
		NetworkStack.PERMISSION_MAINLINE_NETWORK_STACK,
		android.Manifest.permission.NETWORK_STACK})
		public void advisePersistThreshold(long thresholdBytes) {
		try {
		mService.advisePersistThreshold(thresholdBytes);
		} catch (RemoteException e) {
		throw e.rethrowFromSystemServer();
		}
		}

		/**
		* Force update of statistics.
		*
		* @hide
		*/
		// @SystemApi
		@RequiresPermission(anyOf = {
		NetworkStack.PERMISSION_MAINLINE_NETWORK_STACK,
		android.Manifest.permission.NETWORK_STACK})
		public void forceUpdate() {
		try {
		mService.forceUpdate();
		} catch (RemoteException e) {
		throw e.rethrowFromSystemServer();
		}
		}

		/**
		* Set the warning and limit to all registered custom network stats providers.
		* Note that invocation of any interface will be sent to all providers.
		*
		* @hide
		*/
		// @SystemApi
		@RequiresPermission(anyOf = {
		NetworkStack.PERMISSION_MAINLINE_NETWORK_STACK,
		android.Manifest.permission.NETWORK_STACK})
		public void setStatsProviderWarningAndLimitAsync(@NonNull String iface, long warning,
		long limit) {
		try {
		mService.setStatsProviderWarningAndLimitAsync(iface, warning, limit);
		} catch (RemoteException e) {
		throw e.rethrowFromSystemServer();
		}
		}
		}

packages/ConnectivityT/framework-t/src/android/net/INetworkStatsService.aidl

+12 −0

Original line number	Diff line number	Diff line
		@@ -94,4 +94,16 @@ interface INetworkStatsService {
		/** Registers a network stats provider */
		INetworkStatsProviderCallback registerNetworkStatsProvider(String tag,
		in INetworkStatsProvider provider);

		/** Mark given UID as being in foreground for stats purposes. */
		void setUidForeground(int uid, boolean uidForeground);

		/** Advise persistence threshold; may be overridden internally. */
		void advisePersistThreshold(long thresholdBytes);

		/**
		* Set the warning and limit to all registered custom network stats providers.
		* Note that invocation of any interface will be sent to all providers.
		*/
		void setStatsProviderWarningAndLimitAsync(String iface, long warning, long limit);
		}

packages/ConnectivityT/service/src/com/android/server/net/NetworkStatsManagerInternal.java

deleted100644 → 0

+0 −45

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2018 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		package com.android.server.net;

		import android.annotation.NonNull;
		import android.net.NetworkStats;
		import android.net.NetworkTemplate;

		public abstract class NetworkStatsManagerInternal {
		/** Return network layer usage total for traffic that matches template. */
		public abstract long getNetworkTotalBytes(NetworkTemplate template, long start, long end);

		/** Return network layer usage per-UID for traffic that matches template. */
		public abstract NetworkStats getNetworkUidBytes(NetworkTemplate template, long start, long end);

		/** Mark given UID as being in foreground for stats purposes. */
		public abstract void setUidForeground(int uid, boolean uidForeground);

		/** Advise persistance threshold; may be overridden internally. */
		public abstract void advisePersistThreshold(long thresholdBytes);

		/** Force update of statistics. */
		public abstract void forceUpdate();

		/**
		* Set the warning and limit to all registered custom network stats providers.
		* Note that invocation of any interface will be sent to all providers.
		*/
		public abstract void setStatsProviderWarningAndLimitAsync(@NonNull String iface, long warning,
		long limit);
		}

packages/ConnectivityT/service/src/com/android/server/net/NetworkStatsService.java

+18 −54

Original line number	Diff line number	Diff line
		@@ -431,7 +431,6 @@ public class NetworkStatsService extends INetworkStatsService.Stub {
		new DefaultNetworkStatsSettings(context), new NetworkStatsFactory(netd),
		new NetworkStatsObservers(), getDefaultSystemDir(), getDefaultBaseDir(),
		new Dependencies());
		service.registerLocalService();

		return service;
		}
		@@ -512,11 +511,6 @@ public class NetworkStatsService extends INetworkStatsService.Stub {
		}
		}

		private void registerLocalService() {
		LocalServices.addService(NetworkStatsManagerInternal.class,
		new NetworkStatsManagerInternalImpl());
		}

		/**
		* Observer that watches for {@link INetdUnsolicitedEventListener} alerts.
		*/
		@@ -1007,7 +1001,8 @@ public class NetworkStatsService extends INetworkStatsService.Stub {
		}

		@VisibleForTesting
		void setUidForeground(int uid, boolean uidForeground) {
		public void setUidForeground(int uid, boolean uidForeground) {
		PermissionUtils.enforceNetworkStackPermission(mContext);
		synchronized (mStatsLock) {
		final int set = uidForeground ? SET_FOREGROUND : SET_DEFAULT;
		final int oldSet = mActiveUidCounterSet.get(uid, SET_DEFAULT);
		@@ -1043,7 +1038,7 @@ public class NetworkStatsService extends INetworkStatsService.Stub {

		@Override
		public void forceUpdate() {
		mContext.enforceCallingOrSelfPermission(READ_NETWORK_USAGE_HISTORY, TAG);
		PermissionUtils.enforceNetworkStackPermission(mContext);

		final long token = Binder.clearCallingIdentity();
		try {
		@@ -1053,7 +1048,9 @@ public class NetworkStatsService extends INetworkStatsService.Stub {
		}
		}

		private void advisePersistThreshold(long thresholdBytes) {
		/** Advise persistence threshold; may be overridden internally. */
		public void advisePersistThreshold(long thresholdBytes) {
		PermissionUtils.enforceNetworkStackPermission(mContext);
		// clamp threshold into safe range
		mPersistThreshold = NetworkStatsUtils.constrain(thresholdBytes,
		128 * KB_IN_BYTES, 2 * MB_IN_BYTES);
		@@ -1690,45 +1687,13 @@ public class NetworkStatsService extends INetworkStatsService.Stub {
		removeUidsLocked(CollectionUtils.toIntArray(uids));
		}

		private class NetworkStatsManagerInternalImpl extends NetworkStatsManagerInternal {
		@Override
		public long getNetworkTotalBytes(NetworkTemplate template, long start, long end) {
		Trace.traceBegin(TRACE_TAG_NETWORK, "getNetworkTotalBytes");
		try {
		return NetworkStatsService.this.getNetworkTotalBytes(template, start, end);
		} finally {
		Trace.traceEnd(TRACE_TAG_NETWORK);
		}
		}

		@Override
		public NetworkStats getNetworkUidBytes(NetworkTemplate template, long start, long end) {
		Trace.traceBegin(TRACE_TAG_NETWORK, "getNetworkUidBytes");
		try {
		return NetworkStatsService.this.getNetworkUidBytes(template, start, end);
		} finally {
		Trace.traceEnd(TRACE_TAG_NETWORK);
		}
		}

		@Override
		public void setUidForeground(int uid, boolean uidForeground) {
		NetworkStatsService.this.setUidForeground(uid, uidForeground);
		}

		@Override
		public void advisePersistThreshold(long thresholdBytes) {
		NetworkStatsService.this.advisePersistThreshold(thresholdBytes);
		}

		@Override
		public void forceUpdate() {
		NetworkStatsService.this.forceUpdate();
		}

		@Override
		/**
		* Set the warning and limit to all registered custom network stats providers.
		* Note that invocation of any interface will be sent to all providers.
		*/
		public void setStatsProviderWarningAndLimitAsync(
		@NonNull String iface, long warning, long limit) {
		PermissionUtils.enforceNetworkStackPermission(mContext);
		if (LOGV) {
		Log.v(TAG, "setStatsProviderWarningAndLimitAsync("
		+ iface + "," + warning + "," + limit + ")");
		@@ -1736,7 +1701,6 @@ public class NetworkStatsService extends INetworkStatsService.Stub {
		invokeForAllStatsProviderCallbacks((cb) -> cb.mProvider.onSetWarningAndLimit(iface,
		warning, limit));
		}
		}

		@Override
		protected void dump(FileDescriptor fd, PrintWriter rawWriter, String[] args) {

services/core/java/com/android/server/net/NetworkPolicyManagerService.java

+86 −32

Original line number	Diff line number	Diff line
		@@ -151,6 +151,8 @@ import android.app.IUidObserver;
		import android.app.Notification;
		import android.app.NotificationManager;
		import android.app.PendingIntent;
		import android.app.usage.NetworkStats;
		import android.app.usage.NetworkStatsManager;
		import android.app.usage.UsageStatsManagerInternal;
		import android.content.BroadcastReceiver;
		import android.content.ComponentName;
		@@ -181,7 +183,6 @@ import android.net.NetworkRequest;
		import android.net.NetworkSpecifier;
		import android.net.NetworkStack;
		import android.net.NetworkStateSnapshot;
		import android.net.NetworkStats;
		import android.net.NetworkTemplate;
		import android.net.TelephonyNetworkSpecifier;
		import android.net.TrafficStats;
		@@ -443,7 +444,7 @@ public class NetworkPolicyManagerService extends INetworkPolicyManager.Stub {

		private final Context mContext;
		private final IActivityManager mActivityManager;
		private NetworkStatsManagerInternal mNetworkStats;
		private NetworkStatsManager mNetworkStats;
		private final INetworkManagementService mNetworkManager;
		private UsageStatsManagerInternal mUsageStats;
		private AppStandbyInternal mAppStandby;
		@@ -455,6 +456,8 @@ public class NetworkPolicyManagerService extends INetworkPolicyManager.Stub {
		private ConnectivityManager mConnManager;
		private PowerManagerInternal mPowerManagerInternal;
		private PowerWhitelistManager mPowerWhitelistManager;
		@NonNull
		private final Dependencies mDeps;

		/** Current cached value of the current Battery Saver mode's setting for restrict background. */
		@GuardedBy("mUidRulesFirstLock")
		@@ -706,7 +709,7 @@ public class NetworkPolicyManagerService extends INetworkPolicyManager.Stub {
		public NetworkPolicyManagerService(Context context, IActivityManager activityManager,
		INetworkManagementService networkManagement) {
		this(context, activityManager, networkManagement, AppGlobals.getPackageManager(),
		getDefaultClock(), getDefaultSystemDir(), false);
		getDefaultClock(), getDefaultSystemDir(), false, new Dependencies(context));
		}

		private static @NonNull File getDefaultSystemDir() {
		@@ -718,9 +721,59 @@ public class NetworkPolicyManagerService extends INetworkPolicyManager.Stub {
		Clock.systemUTC());
		}

		static class Dependencies {
		final Context mContext;
		final NetworkStatsManager mNetworkStatsManager;
		Dependencies(Context context) {
		mContext = context;
		mNetworkStatsManager = mContext.getSystemService(NetworkStatsManager.class);
		// Query stats from NetworkStatsService will trigger a poll by default.
		// But since NPMS listens stats updated event, and will query stats
		// after the event. A polling -> updated -> query -> polling loop will be introduced
		// if polls on open. Hence, while NPMS manages it's poll requests explicitly, set
		// flag to false to prevent a polling loop.
		mNetworkStatsManager.setPollOnOpen(false);
		}

		long getNetworkTotalBytes(NetworkTemplate template, long start, long end) {
		Trace.traceBegin(TRACE_TAG_NETWORK, "getNetworkTotalBytes");
		try {
		final NetworkStats.Bucket ret = mNetworkStatsManager
		.querySummaryForDevice(template, start, end);
		return ret.getRxBytes() + ret.getTxBytes();
		} catch (RuntimeException e) {
		Slog.w(TAG, "Failed to read network stats: " + e);
		return 0;
		} finally {
		Trace.traceEnd(TRACE_TAG_NETWORK);
		}
		}

		@NonNull
		List<NetworkStats.Bucket> getNetworkUidBytes(
		@NonNull NetworkTemplate template, long start, long end) {
		Trace.traceBegin(TRACE_TAG_NETWORK, "getNetworkUidBytes");
		final List<NetworkStats.Bucket> buckets = new ArrayList<>();
		try {
		final NetworkStats stats = mNetworkStatsManager.querySummary(template, start, end);
		while (stats.hasNextBucket()) {
		final NetworkStats.Bucket bucket = new NetworkStats.Bucket();
		stats.getNextBucket(bucket);
		buckets.add(bucket);
		}
		} catch (RuntimeException e) {
		Slog.w(TAG, "Failed to read network stats: " + e);
		} finally {
		Trace.traceEnd(TRACE_TAG_NETWORK);
		}
		return buckets;
		}
		}

		@VisibleForTesting
		public NetworkPolicyManagerService(Context context, IActivityManager activityManager,
		INetworkManagementService networkManagement, IPackageManager pm, Clock clock,
		File systemDir, boolean suppressDefaultPolicy) {
		File systemDir, boolean suppressDefaultPolicy, Dependencies deps) {
		mContext = Objects.requireNonNull(context, "missing context");
		mActivityManager = Objects.requireNonNull(activityManager, "missing activityManager");
		mNetworkManager = Objects.requireNonNull(networkManagement, "missing networkManagement");
		@@ -741,10 +794,12 @@ public class NetworkPolicyManagerService extends INetworkPolicyManager.Stub {
		mUidEventHandler = new Handler(mUidEventThread.getLooper(), mUidEventHandlerCallback);

		mSuppressDefaultPolicy = suppressDefaultPolicy;
		mDeps = Objects.requireNonNull(deps, "missing Dependencies");

		mPolicyFile = new AtomicFile(new File(systemDir, "netpolicy.xml"), "net-policy");

		mAppOps = context.getSystemService(AppOpsManager.class);
		mNetworkStats = context.getSystemService(NetworkStatsManager.class);
		mMultipathPolicyTracker = new MultipathPolicyTracker(mContext, mHandler);
		// Expose private service for system components to use.
		LocalServices.addService(NetworkPolicyManagerInternal.class,
		@@ -844,7 +899,6 @@ public class NetworkPolicyManagerService extends INetworkPolicyManager.Stub {

		mUsageStats = LocalServices.getService(UsageStatsManagerInternal.class);
		mAppStandby = LocalServices.getService(AppStandbyInternal.class);
		mNetworkStats = LocalServices.getService(NetworkStatsManagerInternal.class);

		synchronized (mUidRulesFirstLock) {
		synchronized (mNetworkPoliciesSecondLock) {
		@@ -1167,21 +1221,34 @@ public class NetworkPolicyManagerService extends INetworkPolicyManager.Stub {
		};

		/**
		* Receiver that watches for {@link INetworkStatsService} updates, which we
		* Receiver that watches for {@link NetworkStatsManager} updates, which we
		* use to check against {@link NetworkPolicy#warningBytes}.
		*/
		final private BroadcastReceiver mStatsReceiver = new BroadcastReceiver() {
		private final NetworkStatsBroadcastReceiver mStatsReceiver =
		new NetworkStatsBroadcastReceiver();
		private class NetworkStatsBroadcastReceiver extends BroadcastReceiver {
		private boolean mIsAnyIntentReceived = false;
		@Override
		public void onReceive(Context context, Intent intent) {
		// on background handler thread, and verified
		// READ_NETWORK_USAGE_HISTORY permission above.

		mIsAnyIntentReceived = true;

		synchronized (mNetworkPoliciesSecondLock) {
		updateNetworkRulesNL();
		updateNetworkEnabledNL();
		updateNotificationsNL();
		}
		}

		/**
		* Return whether any {@code ACTION_NETWORK_STATS_UPDATED} intent is received.
		* Used to determine if NetworkStatsService is ready.
		*/
		public boolean isAnyIntentReceived() {
		return mIsAnyIntentReceived;
		}
		};

		/**
		@@ -1405,15 +1472,17 @@ public class NetworkPolicyManagerService extends INetworkPolicyManager.Stub {
		long maxBytes = 0;
		int maxUid = 0;

		final NetworkStats stats = getNetworkUidBytes(template, start, end);
		NetworkStats.Entry entry = null;
		for (int i = 0; i < stats.size(); i++) {
		entry = stats.getValues(i, entry);
		final long bytes = entry.rxBytes + entry.txBytes;
		// Skip if not ready. NetworkStatsService will block public API calls until it is
		// ready. To prevent NPMS be blocked on that, skip and fail fast instead.
		if (!mStatsReceiver.isAnyIntentReceived()) return null;

		final List<NetworkStats.Bucket> stats = mDeps.getNetworkUidBytes(template, start, end);
		for (final NetworkStats.Bucket entry : stats) {
		final long bytes = entry.getRxBytes() + entry.getTxBytes();
		totalBytes += bytes;
		if (bytes > maxBytes) {
		maxBytes = bytes;
		maxUid = entry.uid;
		maxUid = entry.getUid();
		}
		}

		@@ -5398,25 +5467,10 @@ public class NetworkPolicyManagerService extends INetworkPolicyManager.Stub {

		@Deprecated
		private long getTotalBytes(NetworkTemplate template, long start, long end) {
		return getNetworkTotalBytes(template, start, end);
		}

		private long getNetworkTotalBytes(NetworkTemplate template, long start, long end) {
		try {
		return mNetworkStats.getNetworkTotalBytes(template, start, end);
		} catch (RuntimeException e) {
		Slog.w(TAG, "Failed to read network stats: " + e);
		return 0;
		}
		}

		private NetworkStats getNetworkUidBytes(NetworkTemplate template, long start, long end) {
		try {
		return mNetworkStats.getNetworkUidBytes(template, start, end);
		} catch (RuntimeException e) {
		Slog.w(TAG, "Failed to read network stats: " + e);
		return new NetworkStats(SystemClock.elapsedRealtime(), 0);
		}
		// Skip if not ready. NetworkStatsService will block public API calls until it is
		// ready. To prevent NPMS be blocked on that, skip and fail fast instead.
		if (!mStatsReceiver.isAnyIntentReceived()) return 0;
		return mDeps.getNetworkTotalBytes(template, start, end);
		}

		private boolean isBandwidthControlEnabled() {