| /* |
| * Copyright (C) 2016 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.settings.datausage; |
| |
| import android.app.ActivityManager; |
| import android.app.LoaderManager.LoaderCallbacks; |
| import android.content.Context; |
| import android.content.Loader; |
| import android.content.pm.UserInfo; |
| import android.graphics.Color; |
| import android.net.ConnectivityManager; |
| import android.net.INetworkStatsSession; |
| import android.net.NetworkPolicy; |
| import android.net.NetworkStats; |
| import android.net.NetworkStatsHistory; |
| import android.net.NetworkTemplate; |
| import android.net.TrafficStats; |
| import android.os.AsyncTask; |
| import android.os.Bundle; |
| import android.os.RemoteException; |
| import android.os.SystemProperties; |
| import android.os.UserHandle; |
| import android.os.UserManager; |
| import android.support.v7.preference.Preference; |
| import android.support.v7.preference.PreferenceGroup; |
| import android.telephony.SubscriptionInfo; |
| import android.telephony.SubscriptionManager; |
| import android.telephony.TelephonyManager; |
| import android.text.format.DateUtils; |
| import android.text.format.Formatter; |
| import android.util.Log; |
| import android.util.SparseArray; |
| import android.view.View; |
| import android.widget.AdapterView; |
| import android.widget.AdapterView.OnItemSelectedListener; |
| import android.widget.Spinner; |
| import com.android.internal.logging.MetricsProto.MetricsEvent; |
| import com.android.settings.R; |
| import com.android.settingslib.AppItem; |
| import com.android.settingslib.net.ChartData; |
| import com.android.settingslib.net.ChartDataLoader; |
| import com.android.settingslib.net.SummaryForAllUidLoader; |
| import com.android.settingslib.net.UidDetailProvider; |
| |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| |
| import static android.net.ConnectivityManager.TYPE_MOBILE; |
| import static android.net.NetworkPolicyManager.POLICY_REJECT_METERED_BACKGROUND; |
| import static android.net.TrafficStats.UID_REMOVED; |
| import static android.net.TrafficStats.UID_TETHERING; |
| import static android.telephony.TelephonyManager.SIM_STATE_READY; |
| import static com.android.settings.datausage.DataUsageSummary.TEST_RADIOS; |
| import static com.android.settings.datausage.DataUsageSummary.TEST_RADIOS_PROP; |
| |
| /** |
| * Panel showing data usage history across various networks, including options |
| * to inspect based on usage cycle and control through {@link NetworkPolicy}. |
| */ |
| public class DataUsageList extends DataUsageBase { |
| private static final String TAG = "DataUsage"; |
| private static final boolean LOGD = false; |
| |
| private static final String KEY_USAGE_AMOUNT = "usage_amount"; |
| private static final String KEY_CHART_DATA = "chart_data"; |
| private static final String KEY_APPS_GROUP = "apps_group"; |
| |
| private static final int LOADER_CHART_DATA = 2; |
| private static final int LOADER_SUMMARY = 3; |
| public static final String EXTRA_SUB_ID = "sub_id"; |
| public static final String EXTRA_NETWORK_TEMPLATE = "network_template"; |
| |
| private INetworkStatsSession mStatsSession; |
| |
| private ChartDataUsagePreference mChart; |
| |
| private NetworkTemplate mTemplate; |
| private int mSubId; |
| private ChartData mChartData; |
| |
| /** Flag used to ignore listeners during binding. */ |
| private boolean mBinding; |
| |
| private UidDetailProvider mUidDetailProvider; |
| |
| /** |
| * Local cache of data enabled for subId, used to work around delays. |
| */ |
| private final Map<String, Boolean> mMobileDataEnabled = new HashMap<String, Boolean>(); |
| private CycleAdapter mCycleAdapter; |
| private Spinner mCycleSpinner; |
| private Preference mUsageAmount; |
| private PreferenceGroup mApps; |
| private View mHeader; |
| |
| @Override |
| protected int getMetricsCategory() { |
| return MetricsEvent.DATA_USAGE_LIST; |
| } |
| |
| @Override |
| public void onCreate(Bundle savedInstanceState) { |
| super.onCreate(savedInstanceState); |
| final Context context = getActivity(); |
| |
| if (!isBandwidthControlEnabled()) { |
| Log.w(TAG, "No bandwidth control; leaving"); |
| getActivity().finish(); |
| } |
| |
| try { |
| mStatsSession = services.mStatsService.openSession(); |
| } catch (RemoteException e) { |
| throw new RuntimeException(e); |
| } |
| |
| mUidDetailProvider = new UidDetailProvider(context); |
| |
| addPreferencesFromResource(R.xml.data_usage_list); |
| mUsageAmount = findPreference(KEY_USAGE_AMOUNT); |
| mChart = (ChartDataUsagePreference) findPreference(KEY_CHART_DATA); |
| mApps = (PreferenceGroup) findPreference(KEY_APPS_GROUP); |
| |
| final Bundle args = getArguments(); |
| mSubId = args.getInt(EXTRA_SUB_ID, SubscriptionManager.INVALID_SUBSCRIPTION_ID); |
| mTemplate = args.getParcelable(EXTRA_NETWORK_TEMPLATE); |
| } |
| |
| @Override |
| public void onViewCreated(View v, Bundle savedInstanceState) { |
| super.onViewCreated(v, savedInstanceState); |
| |
| mHeader = setPinnedHeaderView(R.layout.apps_filter_spinner); |
| mCycleSpinner = (Spinner) mHeader.findViewById(R.id.filter_spinner); |
| mCycleAdapter = new CycleAdapter(getContext(), new CycleAdapter.SpinnerInterface() { |
| @Override |
| public void setAdapter(CycleAdapter cycleAdapter) { |
| mCycleSpinner.setAdapter(cycleAdapter); |
| } |
| |
| @Override |
| public void setOnItemSelectedListener(OnItemSelectedListener listener) { |
| mCycleSpinner.setOnItemSelectedListener(listener); |
| } |
| |
| @Override |
| public Object getSelectedItem() { |
| return mCycleSpinner.getSelectedItem(); |
| } |
| |
| @Override |
| public void setSelection(int position) { |
| mCycleSpinner.setSelection(position); |
| } |
| }, mCycleListener, true); |
| setLoading(true, false); |
| } |
| |
| @Override |
| public void onResume() { |
| super.onResume(); |
| |
| updateBody(); |
| |
| // kick off background task to update stats |
| new AsyncTask<Void, Void, Void>() { |
| @Override |
| protected Void doInBackground(Void... params) { |
| try { |
| // wait a few seconds before kicking off |
| Thread.sleep(2 * DateUtils.SECOND_IN_MILLIS); |
| services.mStatsService.forceUpdate(); |
| } catch (InterruptedException e) { |
| } catch (RemoteException e) { |
| } |
| return null; |
| } |
| |
| @Override |
| protected void onPostExecute(Void result) { |
| if (isAdded()) { |
| updateBody(); |
| } |
| } |
| }.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR); |
| } |
| |
| @Override |
| public void onDestroy() { |
| mUidDetailProvider.clearCache(); |
| mUidDetailProvider = null; |
| |
| TrafficStats.closeQuietly(mStatsSession); |
| |
| super.onDestroy(); |
| } |
| |
| /** |
| * Update body content based on current tab. Loads |
| * {@link NetworkStatsHistory} and {@link NetworkPolicy} from system, and |
| * binds them to visible controls. |
| */ |
| private void updateBody() { |
| mBinding = true; |
| if (!isAdded()) return; |
| |
| final Context context = getActivity(); |
| |
| // kick off loader for network history |
| // TODO: consider chaining two loaders together instead of reloading |
| // network history when showing app detail. |
| getLoaderManager().restartLoader(LOADER_CHART_DATA, |
| ChartDataLoader.buildArgs(mTemplate, null), mChartDataCallbacks); |
| |
| // detail mode can change visible menus, invalidate |
| getActivity().invalidateOptionsMenu(); |
| |
| mBinding = false; |
| |
| int seriesColor = context.getColor(R.color.sim_noitification); |
| if (mSubId != SubscriptionManager.INVALID_SUBSCRIPTION_ID){ |
| final SubscriptionInfo sir = services.mSubscriptionManager |
| .getActiveSubscriptionInfo(mSubId); |
| |
| if (sir != null) { |
| seriesColor = sir.getIconTint(); |
| } |
| } |
| |
| final int secondaryColor = Color.argb(127, Color.red(seriesColor), Color.green(seriesColor), |
| Color.blue(seriesColor)); |
| mChart.setColors(seriesColor, secondaryColor); |
| } |
| |
| /** |
| * Update chart sweeps and cycle list to reflect {@link NetworkPolicy} for |
| * current {@link #mTemplate}. |
| */ |
| private void updatePolicy(boolean refreshCycle) { |
| final NetworkPolicy policy = services.mPolicyEditor.getPolicy(mTemplate); |
| //SUB SELECT |
| if (isNetworkPolicyModifiable(policy, mSubId) && isMobileDataAvailable(mSubId)) { |
| mChart.setNetworkPolicy(policy); |
| mHeader.findViewById(R.id.filter_settings).setVisibility(View.VISIBLE); |
| mHeader.findViewById(R.id.filter_settings).setOnClickListener( |
| new View.OnClickListener() { |
| @Override |
| public void onClick(View v) { |
| Bundle args = new Bundle(); |
| args.putParcelable(DataUsageList.EXTRA_NETWORK_TEMPLATE, mTemplate); |
| startFragment(DataUsageList.this, BillingCycleSettings.class.getName(), |
| R.string.billing_cycle, 0, args); |
| } |
| }); |
| } else { |
| // controls are disabled; don't bind warning/limit sweeps |
| mChart.setNetworkPolicy(null); |
| mHeader.findViewById(R.id.filter_settings).setVisibility(View.GONE); |
| } |
| |
| if (refreshCycle) { |
| // generate cycle list based on policy and available history |
| if (mCycleAdapter.updateCycleList(policy, mChartData)) { |
| updateDetailData(); |
| } |
| } |
| } |
| |
| /** |
| * Update details based on {@link #mChart} inspection range depending on |
| * current mode. Updates {@link #mAdapter} with sorted list |
| * of applications data usage. |
| */ |
| private void updateDetailData() { |
| if (LOGD) Log.d(TAG, "updateDetailData()"); |
| |
| final long start = mChart.getInspectStart(); |
| final long end = mChart.getInspectEnd(); |
| final long now = System.currentTimeMillis(); |
| |
| final Context context = getActivity(); |
| |
| NetworkStatsHistory.Entry entry = null; |
| if (mChartData != null) { |
| entry = mChartData.network.getValues(start, end, now, null); |
| } |
| |
| // kick off loader for detailed stats |
| getLoaderManager().restartLoader(LOADER_SUMMARY, |
| SummaryForAllUidLoader.buildArgs(mTemplate, start, end), mSummaryCallbacks); |
| |
| final long totalBytes = entry != null ? entry.rxBytes + entry.txBytes : 0; |
| final String totalPhrase = Formatter.formatFileSize(context, totalBytes); |
| mUsageAmount.setTitle(getString(R.string.data_used_template, totalPhrase)); |
| } |
| |
| /** |
| * Bind the given {@link NetworkStats}, or {@code null} to clear list. |
| */ |
| public void bindStats(NetworkStats stats, int[] restrictedUids) { |
| ArrayList<AppItem> items = new ArrayList<>(); |
| long largest = 0; |
| |
| final int currentUserId = ActivityManager.getCurrentUser(); |
| UserManager userManager = UserManager.get(getContext()); |
| final List<UserHandle> profiles = userManager.getUserProfiles(); |
| final SparseArray<AppItem> knownItems = new SparseArray<AppItem>(); |
| |
| NetworkStats.Entry entry = null; |
| final int size = stats != null ? stats.size() : 0; |
| for (int i = 0; i < size; i++) { |
| entry = stats.getValues(i, entry); |
| |
| // Decide how to collapse items together |
| final int uid = entry.uid; |
| |
| final int collapseKey; |
| final int category; |
| final int userId = UserHandle.getUserId(uid); |
| if (UserHandle.isApp(uid)) { |
| if (profiles.contains(new UserHandle(userId))) { |
| if (userId != currentUserId) { |
| // Add to a managed user item. |
| final int managedKey = UidDetailProvider.buildKeyForUser(userId); |
| largest = accumulate(managedKey, knownItems, entry, AppItem.CATEGORY_USER, |
| items, largest); |
| } |
| // Add to app item. |
| collapseKey = uid; |
| category = AppItem.CATEGORY_APP; |
| } else { |
| // If it is a removed user add it to the removed users' key |
| final UserInfo info = userManager.getUserInfo(userId); |
| if (info == null) { |
| collapseKey = UID_REMOVED; |
| category = AppItem.CATEGORY_APP; |
| } else { |
| // Add to other user item. |
| collapseKey = UidDetailProvider.buildKeyForUser(userId); |
| category = AppItem.CATEGORY_USER; |
| } |
| } |
| } else if (uid == UID_REMOVED || uid == UID_TETHERING) { |
| collapseKey = uid; |
| category = AppItem.CATEGORY_APP; |
| } else { |
| collapseKey = android.os.Process.SYSTEM_UID; |
| category = AppItem.CATEGORY_APP; |
| } |
| largest = accumulate(collapseKey, knownItems, entry, category, items, largest); |
| } |
| |
| final int restrictedUidsMax = restrictedUids.length; |
| for (int i = 0; i < restrictedUidsMax; ++i) { |
| final int uid = restrictedUids[i]; |
| // Only splice in restricted state for current user or managed users |
| if (!profiles.contains(new UserHandle(UserHandle.getUserId(uid)))) { |
| continue; |
| } |
| |
| AppItem item = knownItems.get(uid); |
| if (item == null) { |
| item = new AppItem(uid); |
| item.total = -1; |
| items.add(item); |
| knownItems.put(item.key, item); |
| } |
| item.restricted = true; |
| } |
| |
| Collections.sort(items); |
| mApps.removeAll(); |
| for (int i = 0; i < items.size(); i++) { |
| final int percentTotal = largest != 0 ? (int) (items.get(i).total * 100 / largest) : 0; |
| AppDataUsagePreference preference = new AppDataUsagePreference(getContext(), |
| items.get(i), percentTotal, mUidDetailProvider); |
| preference.setOnPreferenceClickListener(new Preference.OnPreferenceClickListener() { |
| @Override |
| public boolean onPreferenceClick(Preference preference) { |
| AppDataUsagePreference pref = (AppDataUsagePreference) preference; |
| AppItem item = pref.getItem(); |
| startAppDataUsage(item); |
| return true; |
| } |
| }); |
| mApps.addPreference(preference); |
| } |
| } |
| |
| private void startAppDataUsage(AppItem item) { |
| Bundle args = new Bundle(); |
| args.putParcelable(AppDataUsage.ARG_APP_ITEM, item); |
| args.putParcelable(AppDataUsage.ARG_NETWORK_TEMPLATE, mTemplate); |
| startFragment(this, AppDataUsage.class.getName(), R.string.app_data_usage, 0, args); |
| } |
| |
| /** |
| * Accumulate data usage of a network stats entry for the item mapped by the collapse key. |
| * Creates the item if needed. |
| * @param collapseKey the collapse key used to map the item. |
| * @param knownItems collection of known (already existing) items. |
| * @param entry the network stats entry to extract data usage from. |
| * @param itemCategory the item is categorized on the list view by this category. Must be |
| */ |
| private static long accumulate(int collapseKey, final SparseArray<AppItem> knownItems, |
| NetworkStats.Entry entry, int itemCategory, ArrayList<AppItem> items, long largest) { |
| final int uid = entry.uid; |
| AppItem item = knownItems.get(collapseKey); |
| if (item == null) { |
| item = new AppItem(collapseKey); |
| item.category = itemCategory; |
| items.add(item); |
| knownItems.put(item.key, item); |
| } |
| item.addUid(uid); |
| item.total += entry.rxBytes + entry.txBytes; |
| return Math.max(largest, item.total); |
| } |
| |
| /** |
| * Test if device has a mobile data radio with SIM in ready state. |
| */ |
| public static boolean hasReadyMobileRadio(Context context) { |
| if (TEST_RADIOS) { |
| return SystemProperties.get(TEST_RADIOS_PROP).contains("mobile"); |
| } |
| |
| final ConnectivityManager conn = ConnectivityManager.from(context); |
| final TelephonyManager tele = TelephonyManager.from(context); |
| |
| final List<SubscriptionInfo> subInfoList = |
| SubscriptionManager.from(context).getActiveSubscriptionInfoList(); |
| // No activated Subscriptions |
| if (subInfoList == null) { |
| if (LOGD) Log.d(TAG, "hasReadyMobileRadio: subInfoList=null"); |
| return false; |
| } |
| // require both supported network and ready SIM |
| boolean isReady = true; |
| for (SubscriptionInfo subInfo : subInfoList) { |
| isReady = isReady & tele.getSimState(subInfo.getSimSlotIndex()) == SIM_STATE_READY; |
| if (LOGD) Log.d(TAG, "hasReadyMobileRadio: subInfo=" + subInfo); |
| } |
| boolean retVal = conn.isNetworkSupported(TYPE_MOBILE) && isReady; |
| if (LOGD) { |
| Log.d(TAG, "hasReadyMobileRadio:" |
| + " conn.isNetworkSupported(TYPE_MOBILE)=" |
| + conn.isNetworkSupported(TYPE_MOBILE) |
| + " isReady=" + isReady); |
| } |
| return retVal; |
| } |
| |
| /* |
| * TODO: consider adding to TelephonyManager or SubscriptionManager. |
| */ |
| public static boolean hasReadyMobileRadio(Context context, int subId) { |
| if (TEST_RADIOS) { |
| return SystemProperties.get(TEST_RADIOS_PROP).contains("mobile"); |
| } |
| |
| final ConnectivityManager conn = ConnectivityManager.from(context); |
| final TelephonyManager tele = TelephonyManager.from(context); |
| final int slotId = SubscriptionManager.getSlotId(subId); |
| final boolean isReady = tele.getSimState(slotId) == SIM_STATE_READY; |
| |
| boolean retVal = conn.isNetworkSupported(TYPE_MOBILE) && isReady; |
| if (LOGD) Log.d(TAG, "hasReadyMobileRadio: subId=" + subId |
| + " conn.isNetworkSupported(TYPE_MOBILE)=" + conn.isNetworkSupported(TYPE_MOBILE) |
| + " isReady=" + isReady); |
| return retVal; |
| } |
| |
| private OnItemSelectedListener mCycleListener = new OnItemSelectedListener() { |
| @Override |
| public void onItemSelected(AdapterView<?> parent, View view, int position, long id) { |
| final CycleAdapter.CycleItem cycle = (CycleAdapter.CycleItem) |
| mCycleSpinner.getSelectedItem(); |
| |
| if (LOGD) { |
| Log.d(TAG, "showing cycle " + cycle + ", start=" + cycle.start + ", end=" |
| + cycle.end + "]"); |
| } |
| |
| // update chart to show selected cycle, and update detail data |
| // to match updated sweep bounds. |
| mChart.setVisibleRange(cycle.start, cycle.end); |
| |
| updateDetailData(); |
| } |
| |
| @Override |
| public void onNothingSelected(AdapterView<?> parent) { |
| // ignored |
| } |
| }; |
| |
| private final LoaderCallbacks<ChartData> mChartDataCallbacks = new LoaderCallbacks< |
| ChartData>() { |
| @Override |
| public Loader<ChartData> onCreateLoader(int id, Bundle args) { |
| return new ChartDataLoader(getActivity(), mStatsSession, args); |
| } |
| |
| @Override |
| public void onLoadFinished(Loader<ChartData> loader, ChartData data) { |
| setLoading(false, true); |
| mChartData = data; |
| mChart.setNetworkStats(mChartData.network); |
| |
| // calcuate policy cycles based on available data |
| updatePolicy(true); |
| } |
| |
| @Override |
| public void onLoaderReset(Loader<ChartData> loader) { |
| mChartData = null; |
| mChart.setNetworkStats(null); |
| } |
| }; |
| |
| private final LoaderCallbacks<NetworkStats> mSummaryCallbacks = new LoaderCallbacks< |
| NetworkStats>() { |
| @Override |
| public Loader<NetworkStats> onCreateLoader(int id, Bundle args) { |
| return new SummaryForAllUidLoader(getActivity(), mStatsSession, args); |
| } |
| |
| @Override |
| public void onLoadFinished(Loader<NetworkStats> loader, NetworkStats data) { |
| final int[] restrictedUids = services.mPolicyManager.getUidsWithPolicy( |
| POLICY_REJECT_METERED_BACKGROUND); |
| bindStats(data, restrictedUids); |
| updateEmptyVisible(); |
| } |
| |
| @Override |
| public void onLoaderReset(Loader<NetworkStats> loader) { |
| bindStats(null, new int[0]); |
| updateEmptyVisible(); |
| } |
| |
| private void updateEmptyVisible() { |
| if ((mApps.getPreferenceCount() != 0) != |
| (getPreferenceScreen().getPreferenceCount() != 0)) { |
| if (mApps.getPreferenceCount() != 0) { |
| getPreferenceScreen().addPreference(mUsageAmount); |
| getPreferenceScreen().addPreference(mApps); |
| } else { |
| getPreferenceScreen().removeAll(); |
| } |
| } |
| } |
| }; |
| } |