Merge changes I794a24d0,Iab32b2db am: 6dc382dfd5 am: bfd9edf841 am: 2a6439d7e2... (171a541a) · Commits · e / os / android_frameworks_base

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

+46 −46

Original line number	Original line	Diff line number	Diff line
	@@ -306,9 +306,8 @@ public class NetworkStatsService extends INetworkStatsService.Stub {
	/** Data layer operation counters for splicing into other structures. */		/** Data layer operation counters for splicing into other structures. */
	private NetworkStats mUidOperations = new NetworkStats(0L, 10);		private NetworkStats mUidOperations = new NetworkStats(0L, 10);

	/** Must be set in factory by calling #setHandler. */		@NonNull
	private Handler mHandler;		private final Handler mHandler;
	private Handler.Callback mHandlerCallback;

	private volatile boolean mSystemReady;		private volatile boolean mSystemReady;
	private long mPersistThreshold = 2 * MB_IN_BYTES;		private long mPersistThreshold = 2 * MB_IN_BYTES;
	@@ -324,6 +323,9 @@ public class NetworkStatsService extends INetworkStatsService.Stub {

	private final static int DUMP_STATS_SESSION_COUNT = 20;		private final static int DUMP_STATS_SESSION_COUNT = 20;

			@NonNull
			private final Dependencies mDeps;

	private static @NonNull File getDefaultSystemDir() {		private static @NonNull File getDefaultSystemDir() {
	return new File(Environment.getDataDirectory(), "system");		return new File(Environment.getDataDirectory(), "system");
	}		}
	@@ -339,9 +341,24 @@ public class NetworkStatsService extends INetworkStatsService.Stub {
	Clock.systemUTC());		Clock.systemUTC());
	}		}

	private static final class NetworkStatsHandler extends Handler {		private final class NetworkStatsHandler extends Handler {
	NetworkStatsHandler(Looper looper, Handler.Callback callback) {		NetworkStatsHandler(@NonNull Looper looper) {
	super(looper, callback);		super(looper);
			}

			@Override
			public void handleMessage(Message msg) {
			switch (msg.what) {
			case MSG_PERFORM_POLL: {
			performPoll(FLAG_PERSIST_ALL);
			break;
			}
			case MSG_PERFORM_POLL_REGISTER_ALERT: {
			performPoll(FLAG_PERSIST_NETWORK);
			registerGlobalAlert();
			break;
			}
			}
	}		}
	}		}

	@@ -355,14 +372,10 @@ public class NetworkStatsService extends INetworkStatsService.Stub {
	NetworkStatsService service = new NetworkStatsService(context, networkManager, alarmManager,		NetworkStatsService service = new NetworkStatsService(context, networkManager, alarmManager,
	wakeLock, getDefaultClock(), context.getSystemService(TelephonyManager.class),		wakeLock, getDefaultClock(), context.getSystemService(TelephonyManager.class),
	new DefaultNetworkStatsSettings(context), new NetworkStatsFactory(),		new DefaultNetworkStatsSettings(context), new NetworkStatsFactory(),
	new NetworkStatsObservers(), getDefaultSystemDir(), getDefaultBaseDir());		new NetworkStatsObservers(), getDefaultSystemDir(), getDefaultBaseDir(),
			new Dependencies());
	service.registerLocalService();		service.registerLocalService();

	HandlerThread handlerThread = new HandlerThread(TAG);
	Handler.Callback callback = new HandlerCallback(service);
	handlerThread.start();
	Handler handler = new NetworkStatsHandler(handlerThread.getLooper(), callback);
	service.setHandler(handler, callback);
	return service;		return service;
	}		}

	@@ -373,7 +386,7 @@ public class NetworkStatsService extends INetworkStatsService.Stub {
	AlarmManager alarmManager, PowerManager.WakeLock wakeLock, Clock clock,		AlarmManager alarmManager, PowerManager.WakeLock wakeLock, Clock clock,
	TelephonyManager teleManager, NetworkStatsSettings settings,		TelephonyManager teleManager, NetworkStatsSettings settings,
	NetworkStatsFactory factory, NetworkStatsObservers statsObservers, File systemDir,		NetworkStatsFactory factory, NetworkStatsObservers statsObservers, File systemDir,
	File baseDir) {		File baseDir, @NonNull Dependencies deps) {
	mContext = Objects.requireNonNull(context, "missing Context");		mContext = Objects.requireNonNull(context, "missing Context");
	mNetworkManager = Objects.requireNonNull(networkManager,		mNetworkManager = Objects.requireNonNull(networkManager,
	"missing INetworkManagementService");		"missing INetworkManagementService");
	@@ -387,6 +400,26 @@ public class NetworkStatsService extends INetworkStatsService.Stub {
	mSystemDir = Objects.requireNonNull(systemDir, "missing systemDir");		mSystemDir = Objects.requireNonNull(systemDir, "missing systemDir");
	mBaseDir = Objects.requireNonNull(baseDir, "missing baseDir");		mBaseDir = Objects.requireNonNull(baseDir, "missing baseDir");
	mUseBpfTrafficStats = new File("/sys/fs/bpf/map_netd_app_uid_stats_map").exists();		mUseBpfTrafficStats = new File("/sys/fs/bpf/map_netd_app_uid_stats_map").exists();
			mDeps = Objects.requireNonNull(deps, "missing Dependencies");

			final HandlerThread handlerThread = mDeps.makeHandlerThread();
			handlerThread.start();
			mHandler = new NetworkStatsHandler(handlerThread.getLooper());
			}

			/**
			* Dependencies of NetworkStatsService, for injection in tests.
			*/
			// TODO: Move more stuff into dependencies object.
			@VisibleForTesting
			public static class Dependencies {
			/**
			* Create a HandlerThread to use in NetworkStatsService.
			*/
			@NonNull
			public HandlerThread makeHandlerThread() {
			return new HandlerThread(TAG);
			}
	}		}

	private void registerLocalService() {		private void registerLocalService() {
	@@ -394,12 +427,6 @@ public class NetworkStatsService extends INetworkStatsService.Stub {
	new NetworkStatsManagerInternalImpl());		new NetworkStatsManagerInternalImpl());
	}		}

	@VisibleForTesting
	void setHandler(Handler handler, Handler.Callback callback) {
	mHandler = handler;
	mHandlerCallback = callback;
	}

	public void systemReady() {		public void systemReady() {
	synchronized (mStatsLock) {		synchronized (mStatsLock) {
	mSystemReady = true;		mSystemReady = true;
	@@ -1920,33 +1947,6 @@ public class NetworkStatsService extends INetworkStatsService.Stub {

	}		}

	@VisibleForTesting
	static class HandlerCallback implements Handler.Callback {
	private final NetworkStatsService mService;

	HandlerCallback(NetworkStatsService service) {
	this.mService = service;
	}

	@Override
	public boolean handleMessage(Message msg) {
	switch (msg.what) {
	case MSG_PERFORM_POLL: {
	mService.performPoll(FLAG_PERSIST_ALL);
	return true;
	}
	case MSG_PERFORM_POLL_REGISTER_ALERT: {
	mService.performPoll(FLAG_PERSIST_NETWORK);
	mService.registerGlobalAlert();
	return true;
	}
	default: {
	return false;
	}
	}
	}
	}

	private void assertSystemReady() {		private void assertSystemReady() {
	if (!mSystemReady) {		if (!mSystemReady) {
	throw new IllegalStateException("System not ready");		throw new IllegalStateException("System not ready");

tests/net/java/com/android/server/net/NetworkStatsServiceTest.java

+21 −17

Original line number	Original line	Diff line number	Diff line
	@@ -64,6 +64,7 @@ import static org.mockito.Mockito.times;
	import static org.mockito.Mockito.verify;		import static org.mockito.Mockito.verify;
	import static org.mockito.Mockito.when;		import static org.mockito.Mockito.when;

			import android.annotation.NonNull;
	import android.app.AlarmManager;		import android.app.AlarmManager;
	import android.app.usage.NetworkStatsManager;		import android.app.usage.NetworkStatsManager;
	import android.content.Context;		import android.content.Context;
	@@ -163,7 +164,6 @@ public class NetworkStatsServiceTest extends NetworkStatsBaseTest {
	private @Mock IBinder mBinder;		private @Mock IBinder mBinder;
	private @Mock AlarmManager mAlarmManager;		private @Mock AlarmManager mAlarmManager;
	private HandlerThread mHandlerThread;		private HandlerThread mHandlerThread;
	private Handler mHandler;

	private NetworkStatsService mService;		private NetworkStatsService mService;
	private INetworkStatsSession mSession;		private INetworkStatsSession mSession;
	@@ -192,15 +192,11 @@ public class NetworkStatsServiceTest extends NetworkStatsBaseTest {
	PowerManager.WakeLock wakeLock =		PowerManager.WakeLock wakeLock =
	powerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, TAG);		powerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, TAG);

	mService = new NetworkStatsService(
	mServiceContext, mNetManager, mAlarmManager, wakeLock, mClock,
	mServiceContext.getSystemService(TelephonyManager.class), mSettings,
	mStatsFactory, new NetworkStatsObservers(), mStatsDir, getBaseDir(mStatsDir));
	mHandlerThread = new HandlerThread("HandlerThread");		mHandlerThread = new HandlerThread("HandlerThread");
	mHandlerThread.start();		final NetworkStatsService.Dependencies deps = makeDependencies();
	Handler.Callback callback = new NetworkStatsService.HandlerCallback(mService);		mService = new NetworkStatsService(mServiceContext, mNetManager, mAlarmManager, wakeLock,
	mHandler = new Handler(mHandlerThread.getLooper(), callback);		mClock, mServiceContext.getSystemService(TelephonyManager.class), mSettings,
	mService.setHandler(mHandler, callback);		mStatsFactory, new NetworkStatsObservers(), mStatsDir, getBaseDir(mStatsDir), deps);

	mElapsedRealtime = 0L;		mElapsedRealtime = 0L;

	@@ -222,6 +218,16 @@ public class NetworkStatsServiceTest extends NetworkStatsBaseTest {
	mNetworkObserver = networkObserver.getValue();		mNetworkObserver = networkObserver.getValue();
	}		}

			@NonNull
			private NetworkStatsService.Dependencies makeDependencies() {
			return new NetworkStatsService.Dependencies() {
			@Override
			public HandlerThread makeHandlerThread() {
			return mHandlerThread;
			}
			};
			}

	@After		@After
	public void tearDown() throws Exception {		public void tearDown() throws Exception {
	IoUtils.deleteContents(mStatsDir);		IoUtils.deleteContents(mStatsDir);
	@@ -234,6 +240,8 @@ public class NetworkStatsServiceTest extends NetworkStatsBaseTest {

	mSession.close();		mSession.close();
	mService = null;		mService = null;

			mHandlerThread.quitSafely();
	}		}

	@Test		@Test
	@@ -939,9 +947,7 @@ public class NetworkStatsServiceTest extends NetworkStatsBaseTest {
	long minThresholdInBytes = 2 * 1024 * 1024; // 2 MB		long minThresholdInBytes = 2 * 1024 * 1024; // 2 MB
	assertEquals(minThresholdInBytes, request.thresholdInBytes);		assertEquals(minThresholdInBytes, request.thresholdInBytes);

	// Send dummy message to make sure that any previous message has been handled		HandlerUtilsKt.waitForIdle(mHandlerThread, WAIT_TIMEOUT);
	mHandler.sendMessage(mHandler.obtainMessage(-1));
	HandlerUtilsKt.waitForIdle(mHandler, WAIT_TIMEOUT);

	// Make sure that the caller binder gets connected		// Make sure that the caller binder gets connected
	verify(mBinder).linkToDeath(any(IBinder.DeathRecipient.class), anyInt());		verify(mBinder).linkToDeath(any(IBinder.DeathRecipient.class), anyInt());
	@@ -1077,7 +1083,7 @@ public class NetworkStatsServiceTest extends NetworkStatsBaseTest {

	// Simulates alert quota of the provider has been reached.		// Simulates alert quota of the provider has been reached.
	cb.onAlertReached();		cb.onAlertReached();
	HandlerUtilsKt.waitForIdle(mHandler, WAIT_TIMEOUT);		HandlerUtilsKt.waitForIdle(mHandlerThread, WAIT_TIMEOUT);

	// Verifies that polling is triggered by alert reached.		// Verifies that polling is triggered by alert reached.
	provider.expectStatsUpdate(0 /* unused */);		provider.expectStatsUpdate(0 /* unused */);
	@@ -1294,9 +1300,7 @@ public class NetworkStatsServiceTest extends NetworkStatsBaseTest {

	private void forcePollAndWaitForIdle() {		private void forcePollAndWaitForIdle() {
	mServiceContext.sendBroadcast(new Intent(ACTION_NETWORK_STATS_POLL));		mServiceContext.sendBroadcast(new Intent(ACTION_NETWORK_STATS_POLL));
	// Send dummy message to make sure that any previous message has been handled		HandlerUtilsKt.waitForIdle(mHandlerThread, WAIT_TIMEOUT);
	mHandler.sendMessage(mHandler.obtainMessage(-1));
	HandlerUtilsKt.waitForIdle(mHandler, WAIT_TIMEOUT);
	}		}

	static class LatchedHandler extends Handler {		static class LatchedHandler extends Handler {