src/com/android/settings/datausage/AppDataUsage.java

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