Clean up unused methods from DataUsageController (31b3e445) · Commits · e / os / android_frameworks_base

packages/SettingsLib/src/com/android/settingslib/net/ChartDataLoader.java

deleted100644 → 0

+0 −154

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2011 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.settingslib.net;

		import static android.net.NetworkStats.SET_DEFAULT;
		import static android.net.NetworkStats.SET_FOREGROUND;
		import static android.net.NetworkStats.TAG_NONE;

		import android.annotation.NonNull;
		import android.app.usage.NetworkStats;
		import android.app.usage.NetworkStatsManager;
		import android.content.AsyncTaskLoader;
		import android.content.Context;
		import android.net.NetworkTemplate;
		import android.os.Bundle;
		import android.os.RemoteException;

		import com.android.settingslib.AppItem;

		import java.util.ArrayList;
		import java.util.List;

		/**
		* Framework loader is deprecated, use the compat version instead.
		*
		* @deprecated
		*/
		@Deprecated
		public class ChartDataLoader extends AsyncTaskLoader<ChartData> {
		private static final String KEY_TEMPLATE = "template";
		private static final String KEY_APP = "app";

		private final NetworkStatsManager mNetworkStatsManager;
		private final Bundle mArgs;

		public static Bundle buildArgs(NetworkTemplate template, AppItem app) {
		final Bundle args = new Bundle();
		args.putParcelable(KEY_TEMPLATE, template);
		args.putParcelable(KEY_APP, app);
		return args;
		}

		public ChartDataLoader(Context context, NetworkStatsManager statsManager, Bundle args) {
		super(context);
		mNetworkStatsManager = statsManager;
		mArgs = args;
		}

		@Override
		protected void onStartLoading() {
		super.onStartLoading();
		forceLoad();
		}

		@Override
		public ChartData loadInBackground() {
		final NetworkTemplate template = mArgs.getParcelable(KEY_TEMPLATE);
		final AppItem app = mArgs.getParcelable(KEY_APP);

		try {
		return loadInBackground(template, app);
		} catch (RemoteException e) {
		// since we can't do much without history, and we don't want to
		// leave with half-baked UI, we bail hard.
		throw new RuntimeException("problem reading network stats", e);
		}
		}

		@NonNull
		private List<NetworkStats.Bucket> convertToBuckets(@NonNull NetworkStats stats) {
		final List<NetworkStats.Bucket> ret = new ArrayList<>();
		while (stats.hasNextBucket()) {
		final NetworkStats.Bucket bucket = new NetworkStats.Bucket();
		stats.getNextBucket(bucket);
		ret.add(bucket);
		}
		return ret;
		}

		private ChartData loadInBackground(NetworkTemplate template, AppItem app)
		throws RemoteException {
		final ChartData data = new ChartData();
		data.network = convertToBuckets(mNetworkStatsManager.queryDetailsForDevice(
		template, Long.MIN_VALUE, Long.MAX_VALUE));

		if (app != null) {
		// load stats for current uid and template
		final int size = app.uids.size();
		for (int i = 0; i < size; i++) {
		final int uid = app.uids.keyAt(i);
		data.detailDefault = collectHistoryForUid(
		template, uid, SET_DEFAULT, data.detailDefault);
		data.detailForeground = collectHistoryForUid(
		template, uid, SET_FOREGROUND, data.detailForeground);
		}

		if (size > 0) {
		data.detail = new ArrayList<>();
		data.detail.addAll(data.detailDefault);
		data.detail.addAll(data.detailForeground);
		} else {
		data.detailDefault = new ArrayList<>();
		data.detailForeground = new ArrayList<>();
		data.detail = new ArrayList<>();
		}
		}

		return data;
		}

		@Override
		protected void onStopLoading() {
		super.onStopLoading();
		cancelLoad();
		}

		@Override
		protected void onReset() {
		super.onReset();
		cancelLoad();
		}

		/**
		* Collect {@link List<NetworkStats.Bucket>} for the requested UID, combining with
		* an existing {@link List<NetworkStats.Bucket>} if provided.
		*/
		private List<NetworkStats.Bucket> collectHistoryForUid(
		NetworkTemplate template, int uid, int set, List<NetworkStats.Bucket> existing) {
		final List<NetworkStats.Bucket> history = convertToBuckets(
		mNetworkStatsManager.queryDetailsForUidTagState(template,
		Long.MIN_VALUE, Long.MAX_VALUE, uid, TAG_NONE, set));

		if (existing != null) {
		existing.addAll(history);
		return existing;
		} else {
		return history;
		}
		}
		}

packages/SettingsLib/src/com/android/settingslib/net/DataUsageController.java

+4 −51

Original line number	Diff line number	Diff line
		@@ -23,7 +23,6 @@ import static android.text.format.DateUtils.FORMAT_SHOW_DATE;
		import android.app.usage.NetworkStats.Bucket;
		import android.app.usage.NetworkStatsManager;
		import android.content.Context;
		import android.net.ConnectivityManager;
		import android.net.NetworkPolicy;
		import android.net.NetworkPolicyManager;
		import android.net.NetworkTemplate;
		@@ -95,17 +94,6 @@ public class DataUsageController {
		return null;
		}

		public DataUsageInfo getDataUsageInfo() {
		NetworkTemplate template = DataUsageUtils.getMobileTemplate(mContext, mSubscriptionId);

		return getDataUsageInfo(template);
		}

		public DataUsageInfo getWifiDataUsageInfo() {
		NetworkTemplate template = new NetworkTemplate.Builder(NetworkTemplate.MATCH_WIFI).build();
		return getDataUsageInfo(template);
		}

		public DataUsageInfo getDataUsageInfo(NetworkTemplate template) {
		final NetworkPolicy policy = findNetworkPolicy(template);
		final long now = System.currentTimeMillis();
		@@ -137,7 +125,7 @@ public class DataUsageController {
		} else {
		usage.warningLevel = getDefaultWarningLevel();
		}
		if (usage != null && mNetworkController != null) {
		if (mNetworkController != null) {
		usage.carrier = mNetworkController.getMobileDataNetworkName();
		}
		return usage;
		@@ -170,9 +158,7 @@ public class DataUsageController {
		if (mPolicyManager == null \|\| template == null) return null;
		final NetworkPolicy[] policies = mPolicyManager.getNetworkPolicies();
		if (policies == null) return null;
		final int N = policies.length;
		for (int i = 0; i < N; i++) {
		final NetworkPolicy policy = policies[i];
		for (final NetworkPolicy policy : policies) {
		if (policy != null && template.equals(policy.template)) {
		return policy;
		}
		@@ -180,17 +166,6 @@ public class DataUsageController {
		return null;
		}

		private static String statsBucketToString(Bucket bucket) {
		return bucket == null ? null : new StringBuilder("Entry[")
		.append("bucketDuration=").append(bucket.getEndTimeStamp() - bucket.getStartTimeStamp())
		.append(",bucketStart=").append(bucket.getStartTimeStamp())
		.append(",rxBytes=").append(bucket.getRxBytes())
		.append(",rxPackets=").append(bucket.getRxPackets())
		.append(",txBytes=").append(bucket.getTxBytes())
		.append(",txPackets=").append(bucket.getTxPackets())
		.append(']').toString();
		}

		@VisibleForTesting
		public TelephonyManager getTelephonyManager() {
		int subscriptionId = mSubscriptionId;
		@@ -208,8 +183,8 @@ public class DataUsageController {
		}
		}

		return mContext.getSystemService(
		TelephonyManager.class).createForSubscriptionId(subscriptionId);
		return mContext.getSystemService(TelephonyManager.class)
		.createForSubscriptionId(subscriptionId);
		}

		public void setMobileDataEnabled(boolean enabled) {
		@@ -230,28 +205,6 @@ public class DataUsageController {
		return getTelephonyManager().isDataEnabled();
		}

		static int getNetworkType(NetworkTemplate networkTemplate) {
		if (networkTemplate == null) {
		return ConnectivityManager.TYPE_NONE;
		}
		final int matchRule = networkTemplate.getMatchRule();
		switch (matchRule) {
		case NetworkTemplate.MATCH_MOBILE:
		return ConnectivityManager.TYPE_MOBILE;
		case NetworkTemplate.MATCH_WIFI:
		return ConnectivityManager.TYPE_WIFI;
		case NetworkTemplate.MATCH_ETHERNET:
		return ConnectivityManager.TYPE_ETHERNET;
		default:
		return ConnectivityManager.TYPE_MOBILE;
		}
		}

		private String getActiveSubscriberId() {
		final String actualSubscriberId = getTelephonyManager().getSubscriberId();
		return actualSubscriberId;
		}

		private String formatDateRange(long start, long end) {
		final int flags = FORMAT_SHOW_DATE \| FORMAT_ABBREV_MONTH;
		synchronized (PERIOD_BUILDER) {

packages/SettingsLib/src/com/android/settingslib/net/DataUsageUtils.java

deleted100644 → 0

+0 −107

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2019 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.settingslib.net;

		import android.content.Context;
		import android.net.NetworkStats;
		import android.net.NetworkTemplate;
		import android.telephony.SubscriptionInfo;
		import android.telephony.SubscriptionManager;
		import android.telephony.TelephonyManager;
		import android.util.Log;

		import com.android.internal.util.ArrayUtils;

		import java.util.List;
		import java.util.Set;

		/**
		* Utils class for data usage
		*/
		public class DataUsageUtils {
		private static final String TAG = "DataUsageUtils";

		/**
		* Return mobile NetworkTemplate based on {@code subId}
		*/
		public static NetworkTemplate getMobileTemplate(Context context, int subId) {
		final TelephonyManager telephonyManager = context.getSystemService(TelephonyManager.class);
		final int mobileDefaultSubId = telephonyManager.getSubscriptionId();

		final SubscriptionManager subscriptionManager =
		context.getSystemService(SubscriptionManager.class);
		final List<SubscriptionInfo> subInfoList =
		subscriptionManager.getAvailableSubscriptionInfoList();
		if (subInfoList == null) {
		Log.i(TAG, "Subscription is not inited: " + subId);
		return getMobileTemplateForSubId(telephonyManager, mobileDefaultSubId);
		}

		for (SubscriptionInfo subInfo : subInfoList) {
		if ((subInfo != null) && (subInfo.getSubscriptionId() == subId)) {
		return getNormalizedMobileTemplate(telephonyManager, subId);
		}
		}
		Log.i(TAG, "Subscription is not active: " + subId);
		return getMobileTemplateForSubId(telephonyManager, mobileDefaultSubId);
		}

		private static NetworkTemplate getNormalizedMobileTemplate(
		TelephonyManager telephonyManager, int subId) {
		final NetworkTemplate mobileTemplate = getMobileTemplateForSubId(telephonyManager, subId);
		final Set<String> mergedSubscriberIds = Set.of(telephonyManager
		.createForSubscriptionId(subId).getMergedImsisFromGroup());
		if (ArrayUtils.isEmpty(mergedSubscriberIds)) {
		Log.i(TAG, "mergedSubscriberIds is null.");
		return mobileTemplate;
		}

		return normalizeMobileTemplate(mobileTemplate, mergedSubscriberIds);
		}

		private static NetworkTemplate normalizeMobileTemplate(
		NetworkTemplate template, Set<String> mergedSet) {
		if (template.getSubscriberIds().isEmpty()) return template;
		// The input template should have at most 1 subscriberId.
		final String subscriberId = template.getSubscriberIds().iterator().next();

		if (mergedSet.contains(subscriberId)) {
		// Requested template subscriber is part of the merge group; return
		// a template that matches all merged subscribers.
		return new NetworkTemplate.Builder(template.getMatchRule())
		.setSubscriberIds(mergedSet)
		.setWifiNetworkKeys(template.getWifiNetworkKeys())
		.setMeteredness(NetworkStats.METERED_YES).build();
		}

		return template;
		}

		private static NetworkTemplate getMobileTemplateForSubId(
		TelephonyManager telephonyManager, int subId) {
		// Create template that matches any mobile network when the subscriberId is null.
		String subscriberId = telephonyManager.getSubscriberId(subId);
		return subscriberId != null
		? new NetworkTemplate.Builder(NetworkTemplate.MATCH_CARRIER)
		.setSubscriberIds(Set.of(subscriberId))
		.setMeteredness(NetworkStats.METERED_YES)
		.build()
		: new NetworkTemplate.Builder(NetworkTemplate.MATCH_MOBILE)
		.setMeteredness(NetworkStats.METERED_YES)
		.build();
		}
		}

packages/SettingsLib/tests/robotests/src/com/android/settingslib/net/DataUsageUtilsTest.java

deleted100644 → 0

+0 −113

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2019 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.settingslib.net;

		import static com.google.common.truth.Truth.assertThat;

		import static org.mockito.Mockito.anyInt;
		import static org.mockito.Mockito.spy;
		import static org.mockito.Mockito.when;

		import android.content.Context;
		import android.net.NetworkTemplate;
		import android.os.ParcelUuid;
		import android.os.RemoteException;
		import android.telephony.SubscriptionInfo;
		import android.telephony.SubscriptionManager;
		import android.telephony.TelephonyManager;

		import org.junit.Before;
		import org.junit.Ignore;
		import org.junit.Test;
		import org.junit.runner.RunWith;
		import org.mockito.Mock;
		import org.mockito.MockitoAnnotations;
		import org.robolectric.RobolectricTestRunner;
		import org.robolectric.RuntimeEnvironment;

		import java.util.List;

		@RunWith(RobolectricTestRunner.class)
		public class DataUsageUtilsTest {

		private static final int SUB_ID = 1;
		private static final int SUB_ID_2 = 2;
		private static final String SUBSCRIBER_ID = "Test Subscriber";
		private static final String SUBSCRIBER_ID_2 = "Test Subscriber 2";

		@Mock
		private TelephonyManager mTelephonyManager;
		@Mock
		private SubscriptionManager mSubscriptionManager;
		@Mock
		private SubscriptionInfo mInfo1;
		@Mock
		private SubscriptionInfo mInfo2;
		@Mock
		private ParcelUuid mParcelUuid;
		private Context mContext;
		private List<SubscriptionInfo> mInfos;

		@Before
		public void setUp() throws RemoteException {
		MockitoAnnotations.initMocks(this);

		mContext = spy(RuntimeEnvironment.application);
		when(mContext.getSystemService(TelephonyManager.class)).thenReturn(mTelephonyManager);
		when(mContext.getSystemService(SubscriptionManager.class)).thenReturn(mSubscriptionManager);
		when(mTelephonyManager.getSubscriberId(SUB_ID)).thenReturn(SUBSCRIBER_ID);
		when(mTelephonyManager.getSubscriberId(SUB_ID_2)).thenReturn(SUBSCRIBER_ID_2);
		when(mTelephonyManager.createForSubscriptionId(anyInt())).thenReturn(mTelephonyManager);
		when(mSubscriptionManager.isActiveSubscriptionId(anyInt())).thenReturn(true);
		}

		@Test
		@Ignore
		public void getMobileTemplate_infoNull_returnMobileAll() {
		when(mSubscriptionManager.isActiveSubscriptionId(SUB_ID)).thenReturn(false);

		final NetworkTemplate networkTemplate = DataUsageUtils.getMobileTemplate(mContext, SUB_ID);
		assertThat(networkTemplate.getSubscriberIds().contains(SUBSCRIBER_ID)).isTrue();
		assertThat(networkTemplate.getSubscriberIds().contains(SUBSCRIBER_ID_2)).isFalse();
		}

		@Test
		@Ignore
		public void getMobileTemplate_groupUuidNull_returnMobileAll() {
		when(mSubscriptionManager.getActiveSubscriptionInfo(SUB_ID)).thenReturn(mInfo1);
		when(mInfo1.getGroupUuid()).thenReturn(null);
		when(mTelephonyManager.getMergedImsisFromGroup())
		.thenReturn(new String[] {SUBSCRIBER_ID});

		final NetworkTemplate networkTemplate = DataUsageUtils.getMobileTemplate(mContext, SUB_ID);
		assertThat(networkTemplate.getSubscriberIds().contains(SUBSCRIBER_ID)).isTrue();
		assertThat(networkTemplate.getSubscriberIds().contains(SUBSCRIBER_ID_2)).isFalse();
		}

		@Test
		@Ignore
		public void getMobileTemplate_groupUuidExist_returnMobileMerged() {
		when(mSubscriptionManager.getActiveSubscriptionInfo(SUB_ID)).thenReturn(mInfo1);
		when(mInfo1.getGroupUuid()).thenReturn(mParcelUuid);
		when(mTelephonyManager.getMergedImsisFromGroup())
		.thenReturn(new String[] {SUBSCRIBER_ID, SUBSCRIBER_ID_2});

		final NetworkTemplate networkTemplate = DataUsageUtils.getMobileTemplate(mContext, SUB_ID);
		assertThat(networkTemplate.getSubscriberIds().contains(SUBSCRIBER_ID)).isTrue();
		assertThat(networkTemplate.getSubscriberIds().contains(SUBSCRIBER_ID_2)).isTrue();
		}
		}