• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2016 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file
5  * except in compliance with the License. You may obtain a copy of the License at
6  *
7  *      http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software distributed under the
10  * License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
11  * KIND, either express or implied. See the License for the specific language governing
12  * permissions and limitations under the License.
13  */
14 
15 package com.android.settings.datausage;
16 
17 import android.app.LoaderManager;
18 import android.content.Context;
19 import android.content.Intent;
20 import android.content.Loader;
21 import android.content.pm.ApplicationInfo;
22 import android.content.pm.PackageManager;
23 import android.content.pm.UserInfo;
24 import android.graphics.drawable.Drawable;
25 import android.net.INetworkStatsSession;
26 import android.net.NetworkPolicy;
27 import android.net.NetworkStatsHistory;
28 import android.net.NetworkTemplate;
29 import android.net.TrafficStats;
30 import android.os.AsyncTask;
31 import android.os.Bundle;
32 import android.os.Process;
33 import android.os.RemoteException;
34 import android.os.UserHandle;
35 import android.os.UserManager;
36 import android.support.v14.preference.SwitchPreference;
37 import android.support.v7.preference.Preference;
38 import android.support.v7.preference.PreferenceCategory;
39 import android.text.format.Formatter;
40 import android.util.ArraySet;
41 import android.util.Log;
42 import android.view.View;
43 import android.widget.AdapterView;
44 import com.android.internal.logging.MetricsProto.MetricsEvent;
45 import com.android.settings.AppHeader;
46 import com.android.settings.R;
47 import com.android.settings.applications.AppInfoBase;
48 import com.android.settingslib.AppItem;
49 import com.android.settingslib.Utils;
50 import com.android.settingslib.net.ChartData;
51 import com.android.settingslib.net.ChartDataLoader;
52 import com.android.settingslib.net.UidDetailProvider;
53 
54 import java.util.concurrent.BlockingQueue;
55 import java.util.concurrent.LinkedBlockingQueue;
56 import java.util.concurrent.RejectedExecutionException;
57 import java.util.concurrent.ThreadPoolExecutor;
58 import java.util.concurrent.TimeUnit;
59 
60 import static android.net.NetworkPolicyManager.POLICY_REJECT_METERED_BACKGROUND;
61 
62 public class AppDataUsage extends DataUsageBase implements Preference.OnPreferenceChangeListener,
63         DataSaverBackend.Listener {
64 
65     private static final String TAG = "AppDataUsage";
66 
67     public static final String ARG_APP_ITEM = "app_item";
68     public static final String ARG_NETWORK_TEMPLATE = "network_template";
69 
70     private static final String KEY_TOTAL_USAGE = "total_usage";
71     private static final String KEY_FOREGROUND_USAGE = "foreground_usage";
72     private static final String KEY_BACKGROUND_USAGE = "background_usage";
73     private static final String KEY_APP_SETTINGS = "app_settings";
74     private static final String KEY_RESTRICT_BACKGROUND = "restrict_background";
75     private static final String KEY_APP_LIST = "app_list";
76     private static final String KEY_CYCLE = "cycle";
77     private static final String KEY_UNRESTRICTED_DATA = "unrestricted_data_saver";
78 
79     private static final int LOADER_CHART_DATA = 2;
80 
81     private final ArraySet<String> mPackages = new ArraySet<>();
82     private Preference mTotalUsage;
83     private Preference mForegroundUsage;
84     private Preference mBackgroundUsage;
85     private Preference mAppSettings;
86     private SwitchPreference mRestrictBackground;
87     private PreferenceCategory mAppList;
88 
89     private Drawable mIcon;
90     private CharSequence mLabel;
91     private String mPackageName;
92     private INetworkStatsSession mStatsSession;
93     private CycleAdapter mCycleAdapter;
94 
95     private long mStart;
96     private long mEnd;
97     private ChartData mChartData;
98     private NetworkTemplate mTemplate;
99     private NetworkPolicy mPolicy;
100     private AppItem mAppItem;
101     private Intent mAppSettingsIntent;
102     private SpinnerPreference mCycle;
103     private SwitchPreference mUnrestrictedData;
104     private DataSaverBackend mDataSaverBackend;
105 
106     // Parameters to construct an efficient ThreadPoolExecutor
107     private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
108     private static final int CORE_POOL_SIZE = Math.max(2, Math.min(CPU_COUNT - 1, 4));
109     private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
110     private static final int KEEP_ALIVE_SECONDS = 30;
111 
112     @Override
onCreate(Bundle icicle)113     public void onCreate(Bundle icicle) {
114         super.onCreate(icicle);
115         final Bundle args = getArguments();
116 
117         try {
118             mStatsSession = services.mStatsService.openSession();
119         } catch (RemoteException e) {
120             throw new RuntimeException(e);
121         }
122 
123         mAppItem = (args != null) ? (AppItem) args.getParcelable(ARG_APP_ITEM) : null;
124         mTemplate = (args != null) ? (NetworkTemplate) args.getParcelable(ARG_NETWORK_TEMPLATE)
125                 : null;
126         if (mTemplate == null) {
127             Context context = getContext();
128             mTemplate = DataUsageSummary.getDefaultTemplate(context,
129                     DataUsageSummary.getDefaultSubscriptionId(context));
130         }
131         if (mAppItem == null) {
132             int uid = (args != null) ? args.getInt(AppInfoBase.ARG_PACKAGE_UID, -1)
133                     : getActivity().getIntent().getIntExtra(AppInfoBase.ARG_PACKAGE_UID, -1);
134             if (uid == -1) {
135                 // TODO: Log error.
136                 getActivity().finish();
137             } else {
138                 addUid(uid);
139                 mAppItem = new AppItem(uid);
140                 mAppItem.addUid(uid);
141             }
142         } else {
143             for (int i = 0; i < mAppItem.uids.size(); i++) {
144                 addUid(mAppItem.uids.keyAt(i));
145             }
146         }
147         addPreferencesFromResource(R.xml.app_data_usage);
148 
149         mTotalUsage = findPreference(KEY_TOTAL_USAGE);
150         mForegroundUsage = findPreference(KEY_FOREGROUND_USAGE);
151         mBackgroundUsage = findPreference(KEY_BACKGROUND_USAGE);
152 
153         mCycle = (SpinnerPreference) findPreference(KEY_CYCLE);
154         mCycleAdapter = new CycleAdapter(getContext(), mCycle, mCycleListener, false);
155 
156         if (mAppItem.key > 0) {
157             if (mPackages.size() != 0) {
158                 PackageManager pm = getPackageManager();
159                 try {
160                     ApplicationInfo info = pm.getApplicationInfo(mPackages.valueAt(0), 0);
161                     mIcon = info.loadIcon(pm);
162                     mLabel = info.loadLabel(pm);
163                     mPackageName = info.packageName;
164                 } catch (PackageManager.NameNotFoundException e) {
165                 }
166             }
167             if (!UserHandle.isApp(mAppItem.key)) {
168                 removePreference(KEY_UNRESTRICTED_DATA);
169                 removePreference(KEY_RESTRICT_BACKGROUND);
170             } else {
171                 mRestrictBackground = (SwitchPreference) findPreference(KEY_RESTRICT_BACKGROUND);
172                 mRestrictBackground.setOnPreferenceChangeListener(this);
173                 mUnrestrictedData = (SwitchPreference) findPreference(KEY_UNRESTRICTED_DATA);
174                 mUnrestrictedData.setOnPreferenceChangeListener(this);
175             }
176             mDataSaverBackend = new DataSaverBackend(getContext());
177             mAppSettings = findPreference(KEY_APP_SETTINGS);
178 
179             mAppSettingsIntent = new Intent(Intent.ACTION_MANAGE_NETWORK_USAGE);
180             mAppSettingsIntent.addCategory(Intent.CATEGORY_DEFAULT);
181 
182             PackageManager pm = getPackageManager();
183             boolean matchFound = false;
184             for (String packageName : mPackages) {
185                 mAppSettingsIntent.setPackage(packageName);
186                 if (pm.resolveActivity(mAppSettingsIntent, 0) != null) {
187                     matchFound = true;
188                     break;
189                 }
190             }
191             if (!matchFound) {
192                 removePreference(KEY_APP_SETTINGS);
193                 mAppSettings = null;
194             }
195 
196             if (mPackages.size() > 1) {
197                 mAppList = (PreferenceCategory) findPreference(KEY_APP_LIST);
198                 final int packageSize = mPackages.size();
199                 final BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<>(packageSize);
200                 final ThreadPoolExecutor executor = new ThreadPoolExecutor(CORE_POOL_SIZE,
201                         MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS, workQueue);
202                 for (int i = 1; i < mPackages.size(); i++) {
203                     final AppPrefLoader loader = new AppPrefLoader();
204                         loader.executeOnExecutor(executor, mPackages.valueAt(i));
205                 }
206             } else {
207                 removePreference(KEY_APP_LIST);
208             }
209         } else {
210             if (mAppItem.key == TrafficStats.UID_REMOVED) {
211                 mLabel = getContext().getString(R.string.data_usage_uninstalled_apps_users);
212             } else if (mAppItem.key == TrafficStats.UID_TETHERING) {
213                 mLabel = getContext().getString(R.string.tether_settings_title_all);
214             } else {
215                 final int userId = UidDetailProvider.getUserIdForKey(mAppItem.key);
216                 final UserManager um = UserManager.get(getActivity());
217                 final UserInfo info = um.getUserInfo(userId);
218                 final PackageManager pm = getPackageManager();
219                 mIcon = Utils.getUserIcon(getActivity(), um, info);
220                 mLabel = Utils.getUserLabel(getActivity(), info);
221                 mPackageName = getActivity().getPackageName();
222             }
223             removePreference(KEY_UNRESTRICTED_DATA);
224             removePreference(KEY_APP_SETTINGS);
225             removePreference(KEY_RESTRICT_BACKGROUND);
226             removePreference(KEY_APP_LIST);
227         }
228     }
229 
230     @Override
onDestroy()231     public void onDestroy() {
232         TrafficStats.closeQuietly(mStatsSession);
233         super.onDestroy();
234     }
235 
236     @Override
onResume()237     public void onResume() {
238         super.onResume();
239         if (mDataSaverBackend != null) {
240             mDataSaverBackend.addListener(this);
241         }
242         mPolicy = services.mPolicyEditor.getPolicy(mTemplate);
243         getLoaderManager().restartLoader(LOADER_CHART_DATA,
244                 ChartDataLoader.buildArgs(mTemplate, mAppItem), mChartDataCallbacks);
245         updatePrefs();
246     }
247 
248     @Override
onPause()249     public void onPause() {
250         super.onPause();
251         if (mDataSaverBackend != null) {
252             mDataSaverBackend.remListener(this);
253         }
254     }
255 
256     @Override
onPreferenceChange(Preference preference, Object newValue)257     public boolean onPreferenceChange(Preference preference, Object newValue) {
258         if (preference == mRestrictBackground) {
259             mDataSaverBackend.setIsBlacklisted(mAppItem.key, mPackageName, !(Boolean) newValue);
260             return true;
261         } else if (preference == mUnrestrictedData) {
262             mDataSaverBackend.setIsWhitelisted(mAppItem.key, mPackageName, (Boolean) newValue);
263             return true;
264         }
265         return false;
266     }
267 
268     @Override
onPreferenceTreeClick(Preference preference)269     public boolean onPreferenceTreeClick(Preference preference) {
270         if (preference == mAppSettings) {
271             // TODO: target towards entire UID instead of just first package
272             getActivity().startActivityAsUser(mAppSettingsIntent, new UserHandle(
273                     UserHandle.getUserId(mAppItem.key)));
274             return true;
275         }
276         return super.onPreferenceTreeClick(preference);
277     }
278 
updatePrefs()279     private void updatePrefs() {
280         updatePrefs(getAppRestrictBackground(), getUnrestrictData());
281     }
282 
updatePrefs(boolean restrictBackground, boolean unrestrictData)283     private void updatePrefs(boolean restrictBackground, boolean unrestrictData) {
284         if (mRestrictBackground != null) {
285             mRestrictBackground.setChecked(!restrictBackground);
286         }
287         if (mUnrestrictedData != null) {
288             if (restrictBackground) {
289                 mUnrestrictedData.setVisible(false);
290             } else {
291                 mUnrestrictedData.setVisible(true);
292                 mUnrestrictedData.setChecked(unrestrictData);
293             }
294         }
295     }
296 
addUid(int uid)297     private void addUid(int uid) {
298         String[] packages = getPackageManager().getPackagesForUid(uid);
299         if (packages != null) {
300             for (int i = 0; i < packages.length; i++) {
301                 mPackages.add(packages[i]);
302             }
303         }
304     }
305 
bindData()306     private void bindData() {
307         final long backgroundBytes, foregroundBytes;
308         if (mChartData == null || mStart == 0) {
309             backgroundBytes = foregroundBytes = 0;
310             mCycle.setVisible(false);
311         } else {
312             mCycle.setVisible(true);
313             final long now = System.currentTimeMillis();
314             NetworkStatsHistory.Entry entry = null;
315             entry = mChartData.detailDefault.getValues(mStart, mEnd, now, entry);
316             backgroundBytes = entry.rxBytes + entry.txBytes;
317             entry = mChartData.detailForeground.getValues(mStart, mEnd, now, entry);
318             foregroundBytes = entry.rxBytes + entry.txBytes;
319         }
320         final long totalBytes = backgroundBytes + foregroundBytes;
321         final Context context = getContext();
322 
323         mTotalUsage.setSummary(Formatter.formatFileSize(context, totalBytes));
324         mForegroundUsage.setSummary(Formatter.formatFileSize(context, foregroundBytes));
325         mBackgroundUsage.setSummary(Formatter.formatFileSize(context, backgroundBytes));
326     }
327 
getAppRestrictBackground()328     private boolean getAppRestrictBackground() {
329         final int uid = mAppItem.key;
330         final int uidPolicy = services.mPolicyManager.getUidPolicy(uid);
331         return (uidPolicy & POLICY_REJECT_METERED_BACKGROUND) != 0;
332     }
333 
getUnrestrictData()334     private boolean getUnrestrictData() {
335         if (mDataSaverBackend != null) {
336             return mDataSaverBackend.isWhitelisted(mAppItem.key);
337         }
338         return false;
339     }
340 
341     @Override
onViewCreated(View view, Bundle savedInstanceState)342     public void onViewCreated(View view, Bundle savedInstanceState) {
343         super.onViewCreated(view, savedInstanceState);
344 
345         View header = setPinnedHeaderView(R.layout.app_header);
346         String pkg = mPackages.size() != 0 ? mPackages.valueAt(0) : null;
347         int uid = 0;
348         try {
349             uid = pkg != null ? getPackageManager().getPackageUid(pkg, 0) : 0;
350         } catch (PackageManager.NameNotFoundException e) {
351         }
352         AppHeader.setupHeaderView(getActivity(), mIcon, mLabel,
353                 pkg, uid, AppHeader.includeAppInfo(this), 0, header, null);
354     }
355 
356     @Override
getMetricsCategory()357     protected int getMetricsCategory() {
358         return MetricsEvent.APP_DATA_USAGE;
359     }
360 
361     private AdapterView.OnItemSelectedListener mCycleListener =
362             new AdapterView.OnItemSelectedListener() {
363         @Override
364         public void onItemSelected(AdapterView<?> parent, View view, int position, long id) {
365             final CycleAdapter.CycleItem cycle = (CycleAdapter.CycleItem) mCycle.getSelectedItem();
366 
367             mStart = cycle.start;
368             mEnd = cycle.end;
369             bindData();
370         }
371 
372         @Override
373         public void onNothingSelected(AdapterView<?> parent) {
374             // ignored
375         }
376     };
377 
378     private final LoaderManager.LoaderCallbacks<ChartData> mChartDataCallbacks =
379             new LoaderManager.LoaderCallbacks<ChartData>() {
380         @Override
381         public Loader<ChartData> onCreateLoader(int id, Bundle args) {
382             return new ChartDataLoader(getActivity(), mStatsSession, args);
383         }
384 
385         @Override
386         public void onLoadFinished(Loader<ChartData> loader, ChartData data) {
387             mChartData = data;
388             mCycleAdapter.updateCycleList(mPolicy, mChartData);
389             bindData();
390         }
391 
392         @Override
393         public void onLoaderReset(Loader<ChartData> loader) {
394         }
395     };
396 
397     private class AppPrefLoader extends AsyncTask<String, Void, Preference> {
398         @Override
doInBackground(String... params)399         protected Preference doInBackground(String... params) {
400             PackageManager pm = getPackageManager();
401             String pkg = params[0];
402             try {
403                 ApplicationInfo info = pm.getApplicationInfo(pkg, 0);
404                 Preference preference = new Preference(getPrefContext());
405                 preference.setIcon(info.loadIcon(pm));
406                 preference.setTitle(info.loadLabel(pm));
407                 preference.setSelectable(false);
408                 return preference;
409             } catch (PackageManager.NameNotFoundException e) {
410             }
411             return null;
412         }
413 
414         @Override
onPostExecute(Preference pref)415         protected void onPostExecute(Preference pref) {
416             if (pref != null && mAppList != null) {
417                 mAppList.addPreference(pref);
418             }
419         }
420     }
421 
422     @Override
onDataSaverChanged(boolean isDataSaving)423     public void onDataSaverChanged(boolean isDataSaving) {
424 
425     }
426 
427     @Override
onWhitelistStatusChanged(int uid, boolean isWhitelisted)428     public void onWhitelistStatusChanged(int uid, boolean isWhitelisted) {
429         if (mAppItem.uids.get(uid, false)) {
430             updatePrefs(getAppRestrictBackground(), isWhitelisted);
431         }
432     }
433 
434     @Override
onBlacklistStatusChanged(int uid, boolean isBlacklisted)435     public void onBlacklistStatusChanged(int uid, boolean isBlacklisted) {
436         if (mAppItem.uids.get(uid, false)) {
437             updatePrefs(isBlacklisted, getUnrestrictData());
438         }
439     }
440 }
441