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