1 /*
2  * Copyright (C) 2013 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 package com.android.settings.applications;
18 
19 import android.content.Context;
20 import android.content.pm.PackageManager;
21 import android.os.Bundle;
22 import android.support.v7.preference.Preference;
23 import android.support.v7.preference.PreferenceGroup;
24 import android.util.Log;
25 import android.util.TimeUtils;
26 import android.view.Menu;
27 import android.view.MenuInflater;
28 import android.view.MenuItem;
29 
30 import com.android.internal.app.procstats.ProcessStats;
31 import com.android.internal.logging.MetricsProto.MetricsEvent;
32 import com.android.settings.R;
33 import com.android.settings.SettingsActivity;
34 import com.android.settings.applications.ProcStatsData.MemInfo;
35 
36 import java.util.Collections;
37 import java.util.Comparator;
38 import java.util.List;
39 
40 public class ProcessStatsUi extends ProcessStatsBase {
41     static final String TAG = "ProcessStatsUi";
42     static final boolean DEBUG = false;
43 
44     private static final String KEY_APP_LIST = "app_list";
45 
46     private static final int MENU_SHOW_AVG = Menu.FIRST;
47     private static final int MENU_SHOW_MAX = Menu.FIRST + 1;
48 
49     private PreferenceGroup mAppListGroup;
50     private PackageManager mPm;
51 
52     private boolean mShowMax;
53     private MenuItem mMenuAvg;
54     private MenuItem mMenuMax;
55 
56     @Override
onCreate(Bundle icicle)57     public void onCreate(Bundle icicle) {
58         super.onCreate(icicle);
59 
60         mPm = getActivity().getPackageManager();
61 
62         addPreferencesFromResource(R.xml.process_stats_ui);
63         mAppListGroup = (PreferenceGroup) findPreference(KEY_APP_LIST);
64         setHasOptionsMenu(true);
65     }
66 
67     @Override
onCreateOptionsMenu(Menu menu, MenuInflater inflater)68     public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
69         super.onCreateOptionsMenu(menu, inflater);
70         mMenuAvg = menu.add(0, MENU_SHOW_AVG, 0, R.string.sort_avg_use);
71         mMenuMax = menu.add(0, MENU_SHOW_MAX, 0, R.string.sort_max_use);
72         updateMenu();
73     }
74 
75     @Override
onOptionsItemSelected(MenuItem item)76     public boolean onOptionsItemSelected(MenuItem item) {
77         switch (item.getItemId()) {
78             case MENU_SHOW_AVG:
79             case MENU_SHOW_MAX:
80                 mShowMax = !mShowMax;
81                 refreshUi();
82                 updateMenu();
83                 return true;
84         }
85         return super.onOptionsItemSelected(item);
86     }
87 
updateMenu()88     private void updateMenu() {
89         mMenuMax.setVisible(!mShowMax);
90         mMenuAvg.setVisible(mShowMax);
91     }
92 
93     @Override
getMetricsCategory()94     protected int getMetricsCategory() {
95         return MetricsEvent.APPLICATIONS_PROCESS_STATS_UI;
96     }
97 
98     @Override
onSaveInstanceState(Bundle outState)99     public void onSaveInstanceState(Bundle outState) {
100         super.onSaveInstanceState(outState);
101     }
102 
103     @Override
onPreferenceTreeClick(Preference preference)104     public boolean onPreferenceTreeClick(Preference preference) {
105         if (!(preference instanceof ProcessStatsPreference)) {
106             return false;
107         }
108         ProcessStatsPreference pgp = (ProcessStatsPreference) preference;
109         MemInfo memInfo = mStatsManager.getMemInfo();
110         launchMemoryDetail((SettingsActivity) getActivity(), memInfo, pgp.getEntry(), true);
111 
112         return super.onPreferenceTreeClick(preference);
113     }
114 
115     /**
116      * All states in which we consider a process to be actively running (rather than
117      * something that can be freely killed to reclaim RAM).  Note this also includes
118      * the HOME state, because we prioritize home over all cached processes even when
119      * it is in the background, so it is effectively always running from the perspective
120      * of the information we want to show the user here.
121      */
122     public static final int[] BACKGROUND_AND_SYSTEM_PROC_STATES = new int[] {
123             ProcessStats.STATE_PERSISTENT, ProcessStats.STATE_IMPORTANT_FOREGROUND,
124             ProcessStats.STATE_IMPORTANT_BACKGROUND, ProcessStats.STATE_BACKUP,
125             ProcessStats.STATE_HEAVY_WEIGHT, ProcessStats.STATE_SERVICE,
126             ProcessStats.STATE_SERVICE_RESTARTING, ProcessStats.STATE_RECEIVER,
127             ProcessStats.STATE_HOME
128     };
129 
130     public static final int[] FOREGROUND_PROC_STATES = new int[] {
131             ProcessStats.STATE_TOP
132     };
133 
134     public static final int[] CACHED_PROC_STATES = new int[] {
135             ProcessStats.STATE_CACHED_ACTIVITY, ProcessStats.STATE_CACHED_ACTIVITY_CLIENT,
136             ProcessStats.STATE_CACHED_EMPTY
137     };
138 
makeDuration(long time)139     public static String makeDuration(long time) {
140         StringBuilder sb = new StringBuilder(32);
141         TimeUtils.formatDuration(time, sb);
142         return sb.toString();
143     }
144 
145     @Override
refreshUi()146     public void refreshUi() {
147         mAppListGroup.removeAll();
148         mAppListGroup.setOrderingAsAdded(false);
149         mAppListGroup.setTitle(mShowMax ? R.string.maximum_memory_use
150                 : R.string.average_memory_use);
151 
152         final Context context = getActivity();
153         MemInfo memInfo = mStatsManager.getMemInfo();
154 
155         List<ProcStatsPackageEntry> pkgEntries = mStatsManager.getEntries();
156 
157         // Update everything and get the absolute maximum of memory usage for scaling.
158         for (int i=0, N=pkgEntries.size(); i<N; i++) {
159             ProcStatsPackageEntry pkg = pkgEntries.get(i);
160             pkg.updateMetrics();
161         }
162 
163         Collections.sort(pkgEntries, mShowMax ? sMaxPackageEntryCompare : sPackageEntryCompare);
164 
165         // Now collect the per-process information into applications, so that applications
166         // running as multiple processes will have only one entry representing all of them.
167 
168         if (DEBUG) Log.d(TAG, "-------------------- BUILDING UI");
169 
170         double maxMemory = mShowMax ? memInfo.realTotalRam
171                 : memInfo.usedWeight * memInfo.weightToRam;
172         for (int i = 0; i < pkgEntries.size(); i++) {
173             ProcStatsPackageEntry pkg = pkgEntries.get(i);
174             ProcessStatsPreference pref = new ProcessStatsPreference(getPrefContext());
175             pkg.retrieveUiData(context, mPm);
176             pref.init(pkg, mPm, maxMemory, memInfo.weightToRam,
177                     memInfo.totalScale, !mShowMax);
178             pref.setOrder(i);
179             mAppListGroup.addPreference(pref);
180         }
181     }
182 
183     final static Comparator<ProcStatsPackageEntry> sPackageEntryCompare
184             = new Comparator<ProcStatsPackageEntry>() {
185         @Override
186         public int compare(ProcStatsPackageEntry lhs, ProcStatsPackageEntry rhs) {
187             double rhsWeight = Math.max(rhs.mRunWeight, rhs.mBgWeight);
188             double lhsWeight = Math.max(lhs.mRunWeight, lhs.mBgWeight);
189             if (lhsWeight == rhsWeight) {
190                 return 0;
191             }
192             return lhsWeight < rhsWeight ? 1 : -1;
193         }
194     };
195 
196     final static Comparator<ProcStatsPackageEntry> sMaxPackageEntryCompare
197             = new Comparator<ProcStatsPackageEntry>() {
198         @Override
199         public int compare(ProcStatsPackageEntry lhs, ProcStatsPackageEntry rhs) {
200             double rhsMax = Math.max(rhs.mMaxBgMem, rhs.mMaxRunMem);
201             double lhsMax = Math.max(lhs.mMaxBgMem, lhs.mMaxRunMem);
202             if (lhsMax == rhsMax) {
203                 return 0;
204             }
205             return lhsMax < rhsMax ? 1 : -1;
206         }
207     };
208 }
209