src/com/android/settings/applications/RunningState.java

   1 /*
   2  * Copyright (C) 2010 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 com.android.settings.R;
  20 import com.android.settings.users.UserUtils;
  21
  22 import android.app.ActivityManager;
  23 import android.app.ActivityManagerNative;
  24 import android.app.ActivityThread;
  25 import android.content.ComponentName;
  26 import android.content.Context;
  27 import android.content.pm.ApplicationInfo;
  28 import android.content.pm.PackageInfo;
  29 import android.content.pm.PackageItemInfo;
  30 import android.content.pm.PackageManager;
  31 import android.content.pm.ServiceInfo;
  32 import android.content.pm.UserInfo;
  33 import android.content.res.Resources;
  34 import android.graphics.drawable.Drawable;
  35 import android.os.Handler;
  36 import android.os.HandlerThread;
  37 import android.os.Looper;
  38 import android.os.Message;
  39 import android.os.RemoteException;
  40 import android.os.UserHandle;
  41 import android.os.UserManager;
  42 import android.text.format.Formatter;
  43 import android.util.Log;
  44 import android.util.SparseArray;
  45
  46 import java.util.ArrayList;
  47 import java.util.Collections;
  48 import java.util.Comparator;
  49 import java.util.HashMap;
  50 import java.util.Iterator;
  51 import java.util.List;
  52
  53 /**
  54  * Singleton for retrieving and monitoring the state about all running
  55  * applications/processes/services.
  56  */
  57 public class RunningState {
  58     static final String TAG = "RunningState";
  59     static final boolean DEBUG_COMPARE = false;
  60
  61     static Object sGlobalLock = new Object();
  62     static RunningState sInstance;
  63
  64     static final int MSG_RESET_CONTENTS = 1;
  65     static final int MSG_UPDATE_CONTENTS = 2;
  66     static final int MSG_REFRESH_UI = 3;
  67     static final int MSG_UPDATE_TIME = 4;
  68
  69     static final long TIME_UPDATE_DELAY = 1000;
  70     static final long CONTENTS_UPDATE_DELAY = 2000;
  71
  72     static final int MAX_SERVICES = 100;
  73
  74     final Context mApplicationContext;
  75     final ActivityManager mAm;
  76     final PackageManager mPm;
  77     final UserManager mUm;
  78     final int mMyUserId;
  79
  80     OnRefreshUiListener mRefreshUiListener;
  81
  82     final InterestingConfigChanges mInterestingConfigChanges = new InterestingConfigChanges();
  83
  84     // Processes that are hosting a service we are interested in, organized
  85     // by uid and name.  Note that this mapping does not change even across
  86     // service restarts, and during a restart there will still be a process
  87     // entry.
  88     final SparseArray<HashMap<String, ProcessItem>> mServiceProcessesByName
  89             = new SparseArray<HashMap<String, ProcessItem>>();
  90
  91     // Processes that are hosting a service we are interested in, organized
  92     // by their pid.  These disappear and re-appear as services are restarted.
  93     final SparseArray<ProcessItem> mServiceProcessesByPid
  94             = new SparseArray<ProcessItem>();
  95
  96     // Used to sort the interesting processes.
  97     final ServiceProcessComparator mServiceProcessComparator
  98             = new ServiceProcessComparator();
  99
 100     // Additional interesting processes to be shown to the user, even if
 101     // there is no service running in them.
 102     final ArrayList<ProcessItem> mInterestingProcesses = new ArrayList<ProcessItem>();
 103
 104     // All currently running processes, for finding dependencies etc.
 105     final SparseArray<ProcessItem> mRunningProcesses
 106             = new SparseArray<ProcessItem>();
 107
 108     // The processes associated with services, in sorted order.
 109     final ArrayList<ProcessItem> mProcessItems = new ArrayList<ProcessItem>();
 110
 111     // All processes, used for retrieving memory information.
 112     final ArrayList<ProcessItem> mAllProcessItems = new ArrayList<ProcessItem>();
 113
 114     // If there are other users on the device, these are the merged items
 115     // representing all items that would be put in mMergedItems for that user.
 116     final SparseArray<MergedItem> mOtherUserMergedItems = new SparseArray<MergedItem>();
 117
 118     // If there are other users on the device, these are the merged items
 119     // representing all items that would be put in mUserBackgroundItems for that user.
 120     final SparseArray<MergedItem> mOtherUserBackgroundItems = new SparseArray<MergedItem>();
 121
 122     // Tracking of information about users.
 123     final SparseArray<UserState> mUsers = new SparseArray<UserState>();
 124
 125     static class AppProcessInfo {
 126         final ActivityManager.RunningAppProcessInfo info;
 127         boolean hasServices;
 128         boolean hasForegroundServices;
 129
 130         AppProcessInfo(ActivityManager.RunningAppProcessInfo _info) {
 131             info = _info;
 132         }
 133     }
 134
 135     // Temporary structure used when updating above information.
 136     final SparseArray<AppProcessInfo> mTmpAppProcesses = new SparseArray<AppProcessInfo>();
 137
 138     int mSequence = 0;
 139
 140     final Comparator<RunningState.MergedItem> mBackgroundComparator
 141         = new Comparator<RunningState.MergedItem>() {
 142             @Override
 143             public int compare(MergedItem lhs, MergedItem rhs) {
 144                 if (DEBUG_COMPARE) {
 145                     Log.i(TAG, "Comparing " + lhs + " with " + rhs);
 146                     Log.i(TAG, "     Proc " + lhs.mProcess + " with " + rhs.mProcess);
 147                     Log.i(TAG, "   UserId " + lhs.mUserId + " with " + rhs.mUserId);
 148                 }
 149                 if (lhs.mUserId != rhs.mUserId) {
 150                     if (lhs.mUserId == mMyUserId) return -1;
 151                     if (rhs.mUserId == mMyUserId) return 1;
 152                     return lhs.mUserId < rhs.mUserId ? -1 : 1;
 153                 }
 154                 if (lhs.mProcess == rhs.mProcess) {
 155                     if (lhs.mLabel == rhs.mLabel) {
 156                         return 0;
 157                     }
 158                     return lhs.mLabel != null ? lhs.mLabel.compareTo(rhs.mLabel) : -1;
 159                 }
 160                 if (lhs.mProcess == null) return -1;
 161                 if (rhs.mProcess == null) return 1;
 162                 if (DEBUG_COMPARE) Log.i(TAG, "    Label " + lhs.mProcess.mLabel
 163                         + " with " + rhs.mProcess.mLabel);
 164                 final ActivityManager.RunningAppProcessInfo lhsInfo
 165                         = lhs.mProcess.mRunningProcessInfo;
 166                 final ActivityManager.RunningAppProcessInfo rhsInfo
 167                         = rhs.mProcess.mRunningProcessInfo;
 168                 final boolean lhsBg = lhsInfo.importance
 169                         >= ActivityManager.RunningAppProcessInfo.IMPORTANCE_BACKGROUND;
 170                 final boolean rhsBg = rhsInfo.importance
 171                         >= ActivityManager.RunningAppProcessInfo.IMPORTANCE_BACKGROUND;
 172                         if (DEBUG_COMPARE) Log.i(TAG, "       Bg " + lhsBg + " with " + rhsBg);
 173                 if (lhsBg != rhsBg) {
 174                     return lhsBg ? 1 : -1;
 175                 }
 176                 final boolean lhsA = (lhsInfo.flags
 177                         & ActivityManager.RunningAppProcessInfo.FLAG_HAS_ACTIVITIES) != 0;
 178                 final boolean rhsA = (rhsInfo.flags
 179                         & ActivityManager.RunningAppProcessInfo.FLAG_HAS_ACTIVITIES) != 0;
 180                 if (DEBUG_COMPARE) Log.i(TAG, "      Act " + lhsA + " with " + rhsA);
 181                 if (lhsA != rhsA) {
 182                     return lhsA ? -1 : 1;
 183                 }
 184                 if (DEBUG_COMPARE) Log.i(TAG, "      Lru " + lhsInfo.lru + " with " + rhsInfo.lru);
 185                 if (lhsInfo.lru != rhsInfo.lru) {
 186                     return lhsInfo.lru < rhsInfo.lru ? -1 : 1;
 187                 }
 188                 if (lhs.mProcess.mLabel == rhs.mProcess.mLabel) {
 189                     return 0;
 190                 }
 191                 if (lhs.mProcess.mLabel == null) return 1;
 192                 if (rhs.mProcess.mLabel == null) return -1;
 193                 return lhs.mProcess.mLabel.compareTo(rhs.mProcess.mLabel);
 194             }
 195     };
 196
 197     // ----- following protected by mLock -----
 198
 199     // Lock for protecting the state that will be shared between the
 200     // background update thread and the UI thread.
 201     final Object mLock = new Object();
 202
 203     boolean mResumed;
 204     boolean mHaveData;
 205     boolean mWatchingBackgroundItems;
 206
 207     ArrayList<BaseItem> mItems = new ArrayList<BaseItem>();
 208     ArrayList<MergedItem> mMergedItems = new ArrayList<MergedItem>();
 209     ArrayList<MergedItem> mBackgroundItems = new ArrayList<MergedItem>();
 210     ArrayList<MergedItem> mUserBackgroundItems = new ArrayList<MergedItem>();
 211
 212     int mNumBackgroundProcesses;
 213     long mBackgroundProcessMemory;
 214     int mNumForegroundProcesses;
 215     long mForegroundProcessMemory;
 216     int mNumServiceProcesses;
 217     long mServiceProcessMemory;
 218
 219     // ----- BACKGROUND MONITORING THREAD -----
 220
 221     final HandlerThread mBackgroundThread;
 222     final class BackgroundHandler extends Handler {
 223         public BackgroundHandler(Looper looper) {
 224             super(looper);
 225         }
 226
 227         @Override
 228         public void handleMessage(Message msg) {
 229             switch (msg.what) {
 230                 case MSG_RESET_CONTENTS:
 231                     reset();
 232                     break;
 233                 case MSG_UPDATE_CONTENTS:
 234                     synchronized (mLock) {
 235                         if (!mResumed) {
 236                             return;
 237                         }
 238                     }
 239                     Message cmd = mHandler.obtainMessage(MSG_REFRESH_UI);
 240                     cmd.arg1 = update(mApplicationContext, mAm) ? 1 : 0;
 241                     mHandler.sendMessage(cmd);
 242                     removeMessages(MSG_UPDATE_CONTENTS);
 243                     msg = obtainMessage(MSG_UPDATE_CONTENTS);
 244                     sendMessageDelayed(msg, CONTENTS_UPDATE_DELAY);
 245                     break;
 246             }
 247         }
 248     };
 249
 250     final BackgroundHandler mBackgroundHandler;
 251
 252     final Handler mHandler = new Handler() {
 253         int mNextUpdate = OnRefreshUiListener.REFRESH_TIME;
 254
 255         @Override
 256         public void handleMessage(Message msg) {
 257             switch (msg.what) {
 258                 case MSG_REFRESH_UI:
 259                     mNextUpdate = msg.arg1 != 0
 260                             ? OnRefreshUiListener.REFRESH_STRUCTURE
 261                             : OnRefreshUiListener.REFRESH_DATA;
 262                     break;
 263                 case MSG_UPDATE_TIME:
 264                     synchronized (mLock) {
 265                         if (!mResumed) {
 266                             return;
 267                         }
 268                     }
 269                     removeMessages(MSG_UPDATE_TIME);
 270                     Message m = obtainMessage(MSG_UPDATE_TIME);
 271                     sendMessageDelayed(m, TIME_UPDATE_DELAY);
 272
 273                     if (mRefreshUiListener != null) {
 274                         //Log.i("foo", "Refresh UI: " + mNextUpdate
 275                         //        + " @ " + SystemClock.uptimeMillis());
 276                         mRefreshUiListener.onRefreshUi(mNextUpdate);
 277                         mNextUpdate = OnRefreshUiListener.REFRESH_TIME;
 278                     }
 279                     break;
 280             }
 281         }
 282     };
 283
 284     // ----- DATA STRUCTURES -----
 285
 286     static interface OnRefreshUiListener {
 287         public static final int REFRESH_TIME = 0;
 288         public static final int REFRESH_DATA = 1;
 289         public static final int REFRESH_STRUCTURE = 2;
 290
 291         public void onRefreshUi(int what);
 292     }
 293
 294     static class UserState {
 295         UserInfo mInfo;
 296         String mLabel;
 297         Drawable mIcon;
 298     }
 299
 300     static class BaseItem {
 301         final boolean mIsProcess;
 302         final int mUserId;
 303
 304         PackageItemInfo mPackageInfo;
 305         CharSequence mDisplayLabel;
 306         String mLabel;
 307         String mDescription;
 308
 309         int mCurSeq;
 310
 311         long mActiveSince;
 312         long mSize;
 313         String mSizeStr;
 314         String mCurSizeStr;
 315         boolean mNeedDivider;
 316         boolean mBackground;
 317
 318         public BaseItem(boolean isProcess, int userId) {
 319             mIsProcess = isProcess;
 320             mUserId = userId;
 321         }
 322
 323         public Drawable loadIcon(Context context, RunningState state) {
 324             if (mPackageInfo != null) {
 325                 return mPackageInfo.loadIcon(state.mPm);
 326             }
 327             return null;
 328         }
 329     }
 330
 331     static class ServiceItem extends BaseItem {
 332         ActivityManager.RunningServiceInfo mRunningService;
 333         ServiceInfo mServiceInfo;
 334         boolean mShownAsStarted;
 335
 336         MergedItem mMergedItem;
 337
 338         public ServiceItem(int userId) {
 339             super(false, userId);
 340         }
 341     }
 342
 343     static class ProcessItem extends BaseItem {
 344         final HashMap<ComponentName, ServiceItem> mServices
 345                 = new HashMap<ComponentName, ServiceItem>();
 346         final SparseArray<ProcessItem> mDependentProcesses
 347                 = new SparseArray<ProcessItem>();
 348
 349         final int mUid;
 350         final String mProcessName;
 351         int mPid;
 352
 353         ProcessItem mClient;
 354         int mLastNumDependentProcesses;
 355
 356         int mRunningSeq;
 357         ActivityManager.RunningAppProcessInfo mRunningProcessInfo;
 358
 359         MergedItem mMergedItem;
 360
 361         boolean mInteresting;
 362
 363         // Purely for sorting.
 364         boolean mIsSystem;
 365         boolean mIsStarted;
 366         long mActiveSince;
 367
 368         public ProcessItem(Context context, int uid, String processName) {
 369             super(true, UserHandle.getUserId(uid));
 370             mDescription = context.getResources().getString(
 371                     R.string.service_process_name, processName);
 372             mUid = uid;
 373             mProcessName = processName;
 374         }
 375
 376         void ensureLabel(PackageManager pm) {
 377             if (mLabel != null) {
 378                 return;
 379             }
 380
 381             try {
 382                 ApplicationInfo ai = pm.getApplicationInfo(mProcessName,
 383                         PackageManager.GET_UNINSTALLED_PACKAGES);
 384                 if (ai.uid == mUid) {
 385                     mDisplayLabel = ai.loadLabel(pm);
 386                     mLabel = mDisplayLabel.toString();
 387                     mPackageInfo = ai;
 388                     return;
 389                 }
 390             } catch (PackageManager.NameNotFoundException e) {
 391             }
 392
 393             // If we couldn't get information about the overall
 394             // process, try to find something about the uid.
 395             String[] pkgs = pm.getPackagesForUid(mUid);
 396
 397             // If there is one package with this uid, that is what we want.
 398             if (pkgs.length == 1) {
 399                 try {
 400                     ApplicationInfo ai = pm.getApplicationInfo(pkgs[0],
 401                             PackageManager.GET_UNINSTALLED_PACKAGES);
 402                     mDisplayLabel = ai.loadLabel(pm);
 403                     mLabel = mDisplayLabel.toString();
 404                     mPackageInfo = ai;
 405                     return;
 406                 } catch (PackageManager.NameNotFoundException e) {
 407                 }
 408             }
 409
 410             // If there are multiple, see if one gives us the official name
 411             // for this uid.
 412             for (String name : pkgs) {
 413                 try {
 414                     PackageInfo pi = pm.getPackageInfo(name, 0);
 415                     if (pi.sharedUserLabel != 0) {
 416                         CharSequence nm = pm.getText(name,
 417                                 pi.sharedUserLabel, pi.applicationInfo);
 418                         if (nm != null) {
 419                             mDisplayLabel = nm;
 420                             mLabel = nm.toString();
 421                             mPackageInfo = pi.applicationInfo;
 422                             return;
 423                         }
 424                     }
 425                 } catch (PackageManager.NameNotFoundException e) {
 426                 }
 427             }
 428
 429             // If still don't have anything to display, just use the
 430             // service info.
 431             if (mServices.size() > 0) {
 432                 ApplicationInfo ai = mServices.values().iterator().next()
 433                         .mServiceInfo.applicationInfo;
 434                 mPackageInfo = ai;
 435                 mDisplayLabel = mPackageInfo.loadLabel(pm);
 436                 mLabel = mDisplayLabel.toString();
 437                 return;
 438             }
 439
 440             // Finally... whatever, just pick the first package's name.
 441             try {
 442                 ApplicationInfo ai = pm.getApplicationInfo(pkgs[0],
 443                         PackageManager.GET_UNINSTALLED_PACKAGES);
 444                 mDisplayLabel = ai.loadLabel(pm);
 445                 mLabel = mDisplayLabel.toString();
 446                 mPackageInfo = ai;
 447                 return;
 448             } catch (PackageManager.NameNotFoundException e) {
 449             }
 450         }
 451
 452         boolean updateService(Context context, ActivityManager.RunningServiceInfo service) {
 453             final PackageManager pm = context.getPackageManager();
 454
 455             boolean changed = false;
 456             ServiceItem si = mServices.get(service.service);
 457             if (si == null) {
 458                 changed = true;
 459                 si = new ServiceItem(mUserId);
 460                 si.mRunningService = service;
 461                 try {
 462                     si.mServiceInfo = ActivityThread.getPackageManager().getServiceInfo(
 463                             service.service, PackageManager.GET_UNINSTALLED_PACKAGES,
 464                             UserHandle.getUserId(service.uid));
 465
 466                     if (si.mServiceInfo == null) {
 467                         Log.d("RunningService", "getServiceInfo returned null for: "
 468                                 + service.service);
 469                         return false;
 470                     }
 471                 } catch (RemoteException e) {
 472                 }
 473                 si.mDisplayLabel = makeLabel(pm,
 474                         si.mRunningService.service.getClassName(), si.mServiceInfo);
 475                 mLabel = mDisplayLabel != null ? mDisplayLabel.toString() : null;
 476                 si.mPackageInfo = si.mServiceInfo.applicationInfo;
 477                 mServices.put(service.service, si);
 478             }
 479             si.mCurSeq = mCurSeq;
 480             si.mRunningService = service;
 481             long activeSince = service.restarting == 0 ? service.activeSince : -1;
 482             if (si.mActiveSince != activeSince) {
 483                 si.mActiveSince = activeSince;
 484                 changed = true;
 485             }
 486             if (service.clientPackage != null && service.clientLabel != 0) {
 487                 if (si.mShownAsStarted) {
 488                     si.mShownAsStarted = false;
 489                     changed = true;
 490                 }
 491                 try {
 492                     Resources clientr = pm.getResourcesForApplication(service.clientPackage);
 493                     String label = clientr.getString(service.clientLabel);
 494                     si.mDescription = context.getResources().getString(
 495                             R.string.service_client_name, label);
 496                 } catch (PackageManager.NameNotFoundException e) {
 497                     si.mDescription = null;
 498                 }
 499             } else {
 500                 if (!si.mShownAsStarted) {
 501                     si.mShownAsStarted = true;
 502                     changed = true;
 503                 }
 504                 si.mDescription = context.getResources().getString(
 505                         R.string.service_started_by_app);
 506             }
 507
 508             return changed;
 509         }
 510
 511         boolean updateSize(Context context, long pss, int curSeq) {
 512             mSize = pss * 1024;
 513             if (mCurSeq == curSeq) {
 514                 String sizeStr = Formatter.formatShortFileSize(
 515                         context, mSize);
 516                 if (!sizeStr.equals(mSizeStr)){
 517                     mSizeStr = sizeStr;
 518                     // We update this on the second tick where we update just
 519                     // the text in the current items, so no need to say we
 520                     // changed here.
 521                     return false;
 522                 }
 523             }
 524             return false;
 525         }
 526
 527         boolean buildDependencyChain(Context context, PackageManager pm, int curSeq) {
 528             final int NP = mDependentProcesses.size();
 529             boolean changed = false;
 530             for (int i=0; i<NP; i++) {
 531                 ProcessItem proc = mDependentProcesses.valueAt(i);
 532                 if (proc.mClient != this) {
 533                     changed = true;
 534                     proc.mClient = this;
 535                 }
 536                 proc.mCurSeq = curSeq;
 537                 proc.ensureLabel(pm);
 538                 changed |= proc.buildDependencyChain(context, pm, curSeq);
 539             }
 540
 541             if (mLastNumDependentProcesses != mDependentProcesses.size()) {
 542                 changed = true;
 543                 mLastNumDependentProcesses = mDependentProcesses.size();
 544             }
 545
 546             return changed;
 547         }
 548
 549         void addDependentProcesses(ArrayList<BaseItem> dest,
 550                 ArrayList<ProcessItem> destProc) {
 551             final int NP = mDependentProcesses.size();
 552             for (int i=0; i<NP; i++) {
 553                 ProcessItem proc = mDependentProcesses.valueAt(i);
 554                 proc.addDependentProcesses(dest, destProc);
 555                 dest.add(proc);
 556                 if (proc.mPid > 0) {
 557                     destProc.add(proc);
 558                 }
 559             }
 560         }
 561     }
 562
 563     static class MergedItem extends BaseItem {
 564         ProcessItem mProcess;
 565         UserState mUser;
 566         final ArrayList<ProcessItem> mOtherProcesses = new ArrayList<ProcessItem>();
 567         final ArrayList<ServiceItem> mServices = new ArrayList<ServiceItem>();
 568         final ArrayList<MergedItem> mChildren = new ArrayList<MergedItem>();
 569
 570         private int mLastNumProcesses = -1, mLastNumServices = -1;
 571
 572         MergedItem(int userId) {
 573             super(false, userId);
 574         }
 575
 576         private void setDescription(Context context, int numProcesses, int numServices) {
 577             if (mLastNumProcesses != numProcesses || mLastNumServices != numServices) {
 578                 mLastNumProcesses = numProcesses;
 579                 mLastNumServices = numServices;
 580                 int resid = R.string.running_processes_item_description_s_s;
 581                 if (numProcesses != 1) {
 582                     resid = numServices != 1
 583                             ? R.string.running_processes_item_description_p_p
 584                             : R.string.running_processes_item_description_p_s;
 585                 } else if (numServices != 1) {
 586                     resid = R.string.running_processes_item_description_s_p;
 587                 }
 588                 mDescription = context.getResources().getString(resid, numProcesses,
 589                         numServices);
 590             }
 591         }
 592
 593         boolean update(Context context, boolean background) {
 594             mBackground = background;
 595
 596             if (mUser != null) {
 597                 // This is a merged item that contains a child collection
 598                 // of items...  that is, it is an entire user, containing
 599                 // everything associated with that user.  So set it up as such.
 600                 // For concrete stuff we need about the process of this item,
 601                 // we will just use the info from the first child.
 602                 MergedItem child0 = mChildren.get(0);
 603                 mPackageInfo = child0.mProcess.mPackageInfo;
 604                 mLabel = mUser != null ? mUser.mLabel : null;
 605                 mDisplayLabel = mLabel;
 606                 int numProcesses = 0;
 607                 int numServices = 0;
 608                 mActiveSince = -1;
 609                 for (int i=0; i<mChildren.size(); i++) {
 610                     MergedItem child = mChildren.get(i);
 611                     numProcesses += child.mLastNumProcesses;
 612                     numServices += child.mLastNumServices;
 613                     if (child.mActiveSince >= 0 && mActiveSince < child.mActiveSince) {
 614                         mActiveSince = child.mActiveSince;
 615                     }
 616                 }
 617                 if (!mBackground) {
 618                     setDescription(context, numProcesses, numServices);
 619                 }
 620             } else {
 621                 mPackageInfo = mProcess.mPackageInfo;
 622                 mDisplayLabel = mProcess.mDisplayLabel;
 623                 mLabel = mProcess.mLabel;
 624
 625                 if (!mBackground) {
 626                     setDescription(context, (mProcess.mPid > 0 ? 1 : 0) + mOtherProcesses.size(),
 627                             mServices.size());
 628                 }
 629
 630                 mActiveSince = -1;
 631                 for (int i=0; i<mServices.size(); i++) {
 632                     ServiceItem si = mServices.get(i);
 633                     if (si.mActiveSince >= 0 && mActiveSince < si.mActiveSince) {
 634                         mActiveSince = si.mActiveSince;
 635                     }
 636                 }
 637             }
 638
 639             return false;
 640         }
 641
 642         boolean updateSize(Context context) {
 643             if (mUser != null) {
 644                 mSize = 0;
 645                 for (int i=0; i<mChildren.size(); i++) {
 646                     MergedItem child = mChildren.get(i);
 647                     child.updateSize(context);
 648                     mSize += child.mSize;
 649                 }
 650             } else {
 651                 mSize = mProcess.mSize;
 652                 for (int i=0; i<mOtherProcesses.size(); i++) {
 653                     mSize += mOtherProcesses.get(i).mSize;
 654                 }
 655             }
 656
 657             String sizeStr = Formatter.formatShortFileSize(
 658                     context, mSize);
 659             if (!sizeStr.equals(mSizeStr)){
 660                 mSizeStr = sizeStr;
 661                 // We update this on the second tick where we update just
 662                 // the text in the current items, so no need to say we
 663                 // changed here.
 664                 return false;
 665             }
 666             return false;
 667         }
 668
 669         public Drawable loadIcon(Context context, RunningState state) {
 670             if (mUser == null) {
 671                 return super.loadIcon(context, state);
 672             }
 673             if (mUser.mIcon != null) {
 674                 return mUser.mIcon.getConstantState().newDrawable();
 675             }
 676             return context.getResources().getDrawable(
 677                     com.android.internal.R.drawable.ic_menu_cc);
 678         }
 679     }
 680
 681     class ServiceProcessComparator implements Comparator<ProcessItem> {
 682         public int compare(ProcessItem object1, ProcessItem object2) {
 683             if (object1.mUserId != object2.mUserId) {
 684                 if (object1.mUserId == mMyUserId) return -1;
 685                 if (object2.mUserId == mMyUserId) return 1;
 686                 return object1.mUserId < object2.mUserId ? -1 : 1;
 687             }
 688             if (object1.mIsStarted != object2.mIsStarted) {
 689                 // Non-started processes go last.
 690                 return object1.mIsStarted ? -1 : 1;
 691             }
 692             if (object1.mIsSystem != object2.mIsSystem) {
 693                 // System processes go below non-system.
 694                 return object1.mIsSystem ? 1 : -1;
 695             }
 696             if (object1.mActiveSince != object2.mActiveSince) {
 697                 // Remaining ones are sorted with the longest running
 698                 // services last.
 699                 return (object1.mActiveSince > object2.mActiveSince) ? -1 : 1;
 700             }
 701             return 0;
 702         }
 703     }
 704
 705     static CharSequence makeLabel(PackageManager pm,
 706             String className, PackageItemInfo item) {
 707         if (item != null && (item.labelRes != 0
 708                 || item.nonLocalizedLabel != null)) {
 709             CharSequence label = item.loadLabel(pm);
 710             if (label != null) {
 711                 return label;
 712             }
 713         }
 714
 715         String label = className;
 716         int tail = label.lastIndexOf('.');
 717         if (tail >= 0) {
 718             label = label.substring(tail+1, label.length());
 719         }
 720         return label;
 721     }
 722
 723     static RunningState getInstance(Context context) {
 724         synchronized (sGlobalLock) {
 725             if (sInstance == null) {
 726                 sInstance = new RunningState(context);
 727             }
 728             return sInstance;
 729         }
 730     }
 731
 732     private RunningState(Context context) {
 733         mApplicationContext = context.getApplicationContext();
 734         mAm = (ActivityManager)mApplicationContext.getSystemService(Context.ACTIVITY_SERVICE);
 735         mPm = mApplicationContext.getPackageManager();
 736         mUm = (UserManager)mApplicationContext.getSystemService(Context.USER_SERVICE);
 737         mMyUserId = UserHandle.myUserId();
 738         mResumed = false;
 739         mBackgroundThread = new HandlerThread("RunningState:Background");
 740         mBackgroundThread.start();
 741         mBackgroundHandler = new BackgroundHandler(mBackgroundThread.getLooper());
 742     }
 743
 744     void resume(OnRefreshUiListener listener) {
 745         synchronized (mLock) {
 746             mResumed = true;
 747             mRefreshUiListener = listener;
 748             if (mInterestingConfigChanges.applyNewConfig(mApplicationContext.getResources())) {
 749                 mHaveData = false;
 750                 mBackgroundHandler.removeMessages(MSG_RESET_CONTENTS);
 751                 mBackgroundHandler.removeMessages(MSG_UPDATE_CONTENTS);
 752                 mBackgroundHandler.sendEmptyMessage(MSG_RESET_CONTENTS);
 753             }
 754             if (!mBackgroundHandler.hasMessages(MSG_UPDATE_CONTENTS)) {
 755                 mBackgroundHandler.sendEmptyMessage(MSG_UPDATE_CONTENTS);
 756             }
 757             mHandler.sendEmptyMessage(MSG_UPDATE_TIME);
 758         }
 759     }
 760
 761     void updateNow() {
 762         synchronized (mLock) {
 763             mBackgroundHandler.removeMessages(MSG_UPDATE_CONTENTS);
 764             mBackgroundHandler.sendEmptyMessage(MSG_UPDATE_CONTENTS);
 765         }
 766     }
 767
 768     boolean hasData() {
 769         synchronized (mLock) {
 770             return mHaveData;
 771         }
 772     }
 773
 774     void waitForData() {
 775         synchronized (mLock) {
 776             while (!mHaveData) {
 777                 try {
 778                     mLock.wait(0);
 779                 } catch (InterruptedException e) {
 780                 }
 781             }
 782         }
 783     }
 784
 785     void pause() {
 786         synchronized (mLock) {
 787             mResumed = false;
 788             mRefreshUiListener = null;
 789             mHandler.removeMessages(MSG_UPDATE_TIME);
 790         }
 791     }
 792
 793     private boolean isInterestingProcess(ActivityManager.RunningAppProcessInfo pi) {
 794         if ((pi.flags&ActivityManager.RunningAppProcessInfo.FLAG_CANT_SAVE_STATE) != 0) {
 795             return true;
 796         }
 797         if ((pi.flags&ActivityManager.RunningAppProcessInfo.FLAG_PERSISTENT) == 0
 798                 && pi.importance >= ActivityManager.RunningAppProcessInfo.IMPORTANCE_FOREGROUND
 799                 && pi.importance < ActivityManager.RunningAppProcessInfo.IMPORTANCE_CANT_SAVE_STATE
 800                 && pi.importanceReasonCode
 801                         == ActivityManager.RunningAppProcessInfo.REASON_UNKNOWN) {
 802             return true;
 803         }
 804         return false;
 805     }
 806
 807     private void reset() {
 808         mServiceProcessesByName.clear();
 809         mServiceProcessesByPid.clear();
 810         mInterestingProcesses.clear();
 811         mRunningProcesses.clear();
 812         mProcessItems.clear();
 813         mAllProcessItems.clear();
 814         mUsers.clear();
 815     }
 816
 817     private void addOtherUserItem(Context context, ArrayList<MergedItem> newMergedItems,
 818             SparseArray<MergedItem> userItems, MergedItem newItem) {
 819         MergedItem userItem = userItems.get(newItem.mUserId);
 820         boolean first = userItem == null || userItem.mCurSeq != mSequence;
 821         if (first) {
 822             if (userItem == null) {
 823                 userItem = new MergedItem(newItem.mUserId);
 824                 userItems.put(newItem.mUserId, userItem);
 825             } else {
 826                 userItem.mChildren.clear();
 827             }
 828             userItem.mCurSeq = mSequence;
 829             if ((userItem.mUser=mUsers.get(newItem.mUserId)) == null) {
 830                 userItem.mUser = new UserState();
 831                 UserInfo info = mUm.getUserInfo(newItem.mUserId);
 832                 userItem.mUser.mInfo = info;
 833                 if (info != null) {
 834                     userItem.mUser.mIcon = UserUtils.getUserIcon(mUm, info,
 835                             context.getResources());
 836                 }
 837                 String name = info != null ? info.name : null;
 838                 if (name == null) {
 839                     name = Integer.toString(info.id);
 840                 }
 841                 userItem.mUser.mLabel = context.getResources().getString(
 842                         R.string.running_process_item_user_label, name);
 843             }
 844             newMergedItems.add(userItem);
 845         }
 846         userItem.mChildren.add(newItem);
 847     }
 848
 849     private boolean update(Context context, ActivityManager am) {
 850         final PackageManager pm = context.getPackageManager();
 851
 852         mSequence++;
 853
 854         boolean changed = false;
 855
 856         // Retrieve list of services, filtering out anything that definitely
 857         // won't be shown in the UI.
 858         List<ActivityManager.RunningServiceInfo> services
 859                 = am.getRunningServices(MAX_SERVICES);
 860         int NS = services != null ? services.size() : 0;
 861         for (int i=0; i<NS; i++) {
 862             ActivityManager.RunningServiceInfo si = services.get(i);
 863             // We are not interested in services that have not been started
 864             // and don't have a known client, because
 865             // there is nothing the user can do about them.
 866             if (!si.started && si.clientLabel == 0) {
 867                 services.remove(i);
 868                 i--;
 869                 NS--;
 870                 continue;
 871             }
 872             // We likewise don't care about services running in a
 873             // persistent process like the system or phone.
 874             if ((si.flags&ActivityManager.RunningServiceInfo.FLAG_PERSISTENT_PROCESS)
 875                     != 0) {
 876                 services.remove(i);
 877                 i--;
 878                 NS--;
 879                 continue;
 880             }
 881         }
 882
 883         // Retrieve list of running processes, organizing them into a sparse
 884         // array for easy retrieval.
 885         List<ActivityManager.RunningAppProcessInfo> processes
 886                 = am.getRunningAppProcesses();
 887         final int NP = processes != null ? processes.size() : 0;
 888         mTmpAppProcesses.clear();
 889         for (int i=0; i<NP; i++) {
 890             ActivityManager.RunningAppProcessInfo pi = processes.get(i);
 891             mTmpAppProcesses.put(pi.pid, new AppProcessInfo(pi));
 892         }
 893
 894         // Initial iteration through running services to collect per-process
 895         // info about them.
 896         for (int i=0; i<NS; i++) {
 897             ActivityManager.RunningServiceInfo si = services.get(i);
 898             if (si.restarting == 0 && si.pid > 0) {
 899                 AppProcessInfo ainfo = mTmpAppProcesses.get(si.pid);
 900                 if (ainfo != null) {
 901                     ainfo.hasServices = true;
 902                     if (si.foreground) {
 903                         ainfo.hasForegroundServices = true;
 904                     }
 905                 }
 906             }
 907         }
 908
 909         // Update state we are maintaining about process that are running services.
 910         for (int i=0; i<NS; i++) {
 911             ActivityManager.RunningServiceInfo si = services.get(i);
 912
 913             // If this service's process is in use at a higher importance
 914             // due to another process bound to one of its services, then we
 915             // won't put it in the top-level list of services.  Instead we
 916             // want it to be included in the set of processes that the other
 917             // process needs.
 918             if (si.restarting == 0 && si.pid > 0) {
 919                 AppProcessInfo ainfo = mTmpAppProcesses.get(si.pid);
 920                 if (ainfo != null && !ainfo.hasForegroundServices) {
 921                     // This process does not have any foreground services.
 922                     // If its importance is greater than the service importance
 923                     // then there is something else more significant that is
 924                     // keeping it around that it should possibly be included as
 925                     // a part of instead of being shown by itself.
 926                     if (ainfo.info.importance
 927                             < ActivityManager.RunningAppProcessInfo.IMPORTANCE_SERVICE) {
 928                         // Follow process chain to see if there is something
 929                         // else that could be shown
 930                         boolean skip = false;
 931                         ainfo = mTmpAppProcesses.get(ainfo.info.importanceReasonPid);
 932                         while (ainfo != null) {
 933                             if (ainfo.hasServices || isInterestingProcess(ainfo.info)) {
 934                                 skip = true;
 935                                 break;
 936                             }
 937                             ainfo = mTmpAppProcesses.get(ainfo.info.importanceReasonPid);
 938                         }
 939                         if (skip) {
 940                             continue;
 941                         }
 942                     }
 943                 }
 944             }
 945
 946             HashMap<String, ProcessItem> procs = mServiceProcessesByName.get(si.uid);
 947             if (procs == null) {
 948                 procs = new HashMap<String, ProcessItem>();
 949                 mServiceProcessesByName.put(si.uid, procs);
 950             }
 951             ProcessItem proc = procs.get(si.process);
 952             if (proc == null) {
 953                 changed = true;
 954                 proc = new ProcessItem(context, si.uid, si.process);
 955                 procs.put(si.process, proc);
 956             }
 957
 958             if (proc.mCurSeq != mSequence) {
 959                 int pid = si.restarting == 0 ? si.pid : 0;
 960                 if (pid != proc.mPid) {
 961                     changed = true;
 962                     if (proc.mPid != pid) {
 963                         if (proc.mPid != 0) {
 964                             mServiceProcessesByPid.remove(proc.mPid);
 965                         }
 966                         if (pid != 0) {
 967                             mServiceProcessesByPid.put(pid, proc);
 968                         }
 969                         proc.mPid = pid;
 970                     }
 971                 }
 972                 proc.mDependentProcesses.clear();
 973                 proc.mCurSeq = mSequence;
 974             }
 975             changed |= proc.updateService(context, si);
 976         }
 977
 978         // Now update the map of other processes that are running (but
 979         // don't have services actively running inside them).
 980         for (int i=0; i<NP; i++) {
 981             ActivityManager.RunningAppProcessInfo pi = processes.get(i);
 982             ProcessItem proc = mServiceProcessesByPid.get(pi.pid);
 983             if (proc == null) {
 984                 // This process is not one that is a direct container
 985                 // of a service, so look for it in the secondary
 986                 // running list.
 987                 proc = mRunningProcesses.get(pi.pid);
 988                 if (proc == null) {
 989                     changed = true;
 990                     proc = new ProcessItem(context, pi.uid, pi.processName);
 991                     proc.mPid = pi.pid;
 992                     mRunningProcesses.put(pi.pid, proc);
 993                 }
 994                 proc.mDependentProcesses.clear();
 995             }
 996
 997             if (isInterestingProcess(pi)) {
 998                 if (!mInterestingProcesses.contains(proc)) {
 999                     changed = true;
1000                     mInterestingProcesses.add(proc);
1001                 }
1002                 proc.mCurSeq = mSequence;
1003                 proc.mInteresting = true;
1004                 proc.ensureLabel(pm);
1005             } else {
1006                 proc.mInteresting = false;
1007             }
1008
1009             proc.mRunningSeq = mSequence;
1010             proc.mRunningProcessInfo = pi;
1011         }
1012
1013         // Build the chains from client processes to the process they are
1014         // dependent on; also remove any old running processes.
1015         int NRP = mRunningProcesses.size();
1016         for (int i = 0; i < NRP;) {
1017             ProcessItem proc = mRunningProcesses.valueAt(i);
1018             if (proc.mRunningSeq == mSequence) {
1019                 int clientPid = proc.mRunningProcessInfo.importanceReasonPid;
1020                 if (clientPid != 0) {
1021                     ProcessItem client = mServiceProcessesByPid.get(clientPid);
1022                     if (client == null) {
1023                         client = mRunningProcesses.get(clientPid);
1024                     }
1025                     if (client != null) {
1026                         client.mDependentProcesses.put(proc.mPid, proc);
1027                     }
1028                 } else {
1029                     // In this pass the process doesn't have a client.
1030                     // Clear to make sure that, if it later gets the same one,
1031                     // we will detect the change.
1032                     proc.mClient = null;
1033                 }
1034                 i++;
1035             } else {
1036                 changed = true;
1037                 mRunningProcesses.remove(mRunningProcesses.keyAt(i));
1038                 NRP--;
1039             }
1040         }
1041
1042         // Remove any old interesting processes.
1043         int NHP = mInterestingProcesses.size();
1044         for (int i=0; i<NHP; i++) {
1045             ProcessItem proc = mInterestingProcesses.get(i);
1046             if (!proc.mInteresting || mRunningProcesses.get(proc.mPid) == null) {
1047                 changed = true;
1048                 mInterestingProcesses.remove(i);
1049                 i--;
1050                 NHP--;
1051             }
1052         }
1053
1054         // Follow the tree from all primary service processes to all
1055         // processes they are dependent on, marking these processes as
1056         // still being active and determining if anything has changed.
1057         final int NAP = mServiceProcessesByPid.size();
1058         for (int i=0; i<NAP; i++) {
1059             ProcessItem proc = mServiceProcessesByPid.valueAt(i);
1060             if (proc.mCurSeq == mSequence) {
1061                 changed |= proc.buildDependencyChain(context, pm, mSequence);
1062             }
1063         }
1064
1065         // Look for services and their primary processes that no longer exist...
1066         ArrayList<Integer> uidToDelete = null;
1067         for (int i=0; i<mServiceProcessesByName.size(); i++) {
1068             HashMap<String, ProcessItem> procs = mServiceProcessesByName.valueAt(i);
1069             Iterator<ProcessItem> pit = procs.values().iterator();
1070             while (pit.hasNext()) {
1071                 ProcessItem pi = pit.next();
1072                 if (pi.mCurSeq == mSequence) {
1073                     pi.ensureLabel(pm);
1074                     if (pi.mPid == 0) {
1075                         // Sanity: a non-process can't be dependent on
1076                         // anything.
1077                         pi.mDependentProcesses.clear();
1078                     }
1079                 } else {
1080                     changed = true;
1081                     pit.remove();
1082                     if (procs.size() == 0) {
1083                         if (uidToDelete == null) {
1084                             uidToDelete = new ArrayList<Integer>();
1085                         }
1086                         uidToDelete.add(mServiceProcessesByName.keyAt(i));
1087                     }
1088                     if (pi.mPid != 0) {
1089                         mServiceProcessesByPid.remove(pi.mPid);
1090                     }
1091                     continue;
1092                 }
1093                 Iterator<ServiceItem> sit = pi.mServices.values().iterator();
1094                 while (sit.hasNext()) {
1095                     ServiceItem si = sit.next();
1096                     if (si.mCurSeq != mSequence) {
1097                         changed = true;
1098                         sit.remove();
1099                     }
1100                 }
1101             }
1102         }
1103
1104         if (uidToDelete != null) {
1105             for (int i = 0; i < uidToDelete.size(); i++) {
1106                 int uid = uidToDelete.get(i);
1107                 mServiceProcessesByName.remove(uid);
1108             }
1109         }
1110
1111         if (changed) {
1112             // First determine an order for the services.
1113             ArrayList<ProcessItem> sortedProcesses = new ArrayList<ProcessItem>();
1114             for (int i=0; i<mServiceProcessesByName.size(); i++) {
1115                 for (ProcessItem pi : mServiceProcessesByName.valueAt(i).values()) {
1116                     pi.mIsSystem = false;
1117                     pi.mIsStarted = true;
1118                     pi.mActiveSince = Long.MAX_VALUE;
1119                     for (ServiceItem si : pi.mServices.values()) {
1120                         if (si.mServiceInfo != null
1121                                 && (si.mServiceInfo.applicationInfo.flags
1122                                         & ApplicationInfo.FLAG_SYSTEM) != 0) {
1123                             pi.mIsSystem = true;
1124                         }
1125                         if (si.mRunningService != null
1126                                 && si.mRunningService.clientLabel != 0) {
1127                             pi.mIsStarted = false;
1128                             if (pi.mActiveSince > si.mRunningService.activeSince) {
1129                                 pi.mActiveSince = si.mRunningService.activeSince;
1130                             }
1131                         }
1132                     }
1133                     sortedProcesses.add(pi);
1134                 }
1135             }
1136
1137             Collections.sort(sortedProcesses, mServiceProcessComparator);
1138
1139             ArrayList<BaseItem> newItems = new ArrayList<BaseItem>();
1140             ArrayList<MergedItem> newMergedItems = new ArrayList<MergedItem>();
1141             SparseArray<MergedItem> otherUsers = null;
1142             mProcessItems.clear();
1143             for (int i=0; i<sortedProcesses.size(); i++) {
1144                 ProcessItem pi = sortedProcesses.get(i);
1145                 pi.mNeedDivider = false;
1146
1147                 int firstProc = mProcessItems.size();
1148                 // First add processes we are dependent on.
1149                 pi.addDependentProcesses(newItems, mProcessItems);
1150                 // And add the process itself.
1151                 newItems.add(pi);
1152                 if (pi.mPid > 0) {
1153                     mProcessItems.add(pi);
1154                 }
1155
1156                 // Now add the services running in it.
1157                 MergedItem mergedItem = null;
1158                 boolean haveAllMerged = false;
1159                 boolean needDivider = false;
1160                 for (ServiceItem si : pi.mServices.values()) {
1161                     si.mNeedDivider = needDivider;
1162                     needDivider = true;
1163                     newItems.add(si);
1164                     if (si.mMergedItem != null) {
1165                         if (mergedItem != null && mergedItem != si.mMergedItem) {
1166                             haveAllMerged = false;
1167                         }
1168                         mergedItem = si.mMergedItem;
1169                     } else {
1170                         haveAllMerged = false;
1171                     }
1172                 }
1173
1174                 if (!haveAllMerged || mergedItem == null
1175                         || mergedItem.mServices.size() != pi.mServices.size()) {
1176                     // Whoops, we need to build a new MergedItem!
1177                     mergedItem = new MergedItem(pi.mUserId);
1178                     for (ServiceItem si : pi.mServices.values()) {
1179                         mergedItem.mServices.add(si);
1180                         si.mMergedItem = mergedItem;
1181                     }
1182                     mergedItem.mProcess = pi;
1183                     mergedItem.mOtherProcesses.clear();
1184                     for (int mpi=firstProc; mpi<(mProcessItems.size()-1); mpi++) {
1185                         mergedItem.mOtherProcesses.add(mProcessItems.get(mpi));
1186                     }
1187                 }
1188
1189                 mergedItem.update(context, false);
1190                 if (mergedItem.mUserId != mMyUserId) {
1191                     addOtherUserItem(context, newMergedItems, mOtherUserMergedItems, mergedItem);
1192                 } else {
1193                     newMergedItems.add(mergedItem);
1194                 }
1195             }
1196
1197             // Finally, interesting processes need to be shown and will
1198             // go at the top.
1199             NHP = mInterestingProcesses.size();
1200             for (int i=0; i<NHP; i++) {
1201                 ProcessItem proc = mInterestingProcesses.get(i);
1202                 if (proc.mClient == null && proc.mServices.size() <= 0) {
1203                     if (proc.mMergedItem == null) {
1204                         proc.mMergedItem = new MergedItem(proc.mUserId);
1205                         proc.mMergedItem.mProcess = proc;
1206                     }
1207                     proc.mMergedItem.update(context, false);
1208                     if (proc.mMergedItem.mUserId != mMyUserId) {
1209                         addOtherUserItem(context, newMergedItems, mOtherUserMergedItems,
1210                                 proc.mMergedItem);
1211                     } else {
1212                         newMergedItems.add(0, proc.mMergedItem);
1213                     }
1214                     mProcessItems.add(proc);
1215                 }
1216             }
1217
1218             // Finally finally, user aggregated merged items need to be
1219             // updated now that they have all of their children.
1220             final int NU = mOtherUserMergedItems.size();
1221             for (int i=0; i<NU; i++) {
1222                 MergedItem user = mOtherUserMergedItems.valueAt(i);
1223                 if (user.mCurSeq == mSequence) {
1224                     user.update(context, false);
1225                 }
1226             }
1227
1228             synchronized (mLock) {
1229                 mItems = newItems;
1230                 mMergedItems = newMergedItems;
1231             }
1232         }
1233
1234         // Count number of interesting other (non-active) processes, and
1235         // build a list of all processes we will retrieve memory for.
1236         mAllProcessItems.clear();
1237         mAllProcessItems.addAll(mProcessItems);
1238         int numBackgroundProcesses = 0;
1239         int numForegroundProcesses = 0;
1240         int numServiceProcesses = 0;
1241         NRP = mRunningProcesses.size();
1242         for (int i=0; i<NRP; i++) {
1243             ProcessItem proc = mRunningProcesses.valueAt(i);
1244             if (proc.mCurSeq != mSequence) {
1245                 // We didn't hit this process as a dependency on one
1246                 // of our active ones, so add it up if needed.
1247                 if (proc.mRunningProcessInfo.importance >=
1248                         ActivityManager.RunningAppProcessInfo.IMPORTANCE_BACKGROUND) {
1249                     numBackgroundProcesses++;
1250                     mAllProcessItems.add(proc);
1251                 } else if (proc.mRunningProcessInfo.importance <=
1252                         ActivityManager.RunningAppProcessInfo.IMPORTANCE_VISIBLE) {
1253                     numForegroundProcesses++;
1254                     mAllProcessItems.add(proc);
1255                 } else {
1256                     Log.i("RunningState", "Unknown non-service process: "
1257                             + proc.mProcessName + " #" + proc.mPid);
1258                 }
1259             } else {
1260                 numServiceProcesses++;
1261             }
1262         }
1263
1264         long backgroundProcessMemory = 0;
1265         long foregroundProcessMemory = 0;
1266         long serviceProcessMemory = 0;
1267         ArrayList<MergedItem> newBackgroundItems = null;
1268         ArrayList<MergedItem> newUserBackgroundItems = null;
1269         boolean diffUsers = false;
1270         try {
1271             final int numProc = mAllProcessItems.size();
1272             int[] pids = new int[numProc];
1273             for (int i=0; i<numProc; i++) {
1274                 pids[i] = mAllProcessItems.get(i).mPid;
1275             }
1276             long[] pss = ActivityManagerNative.getDefault()
1277                     .getProcessPss(pids);
1278             int bgIndex = 0;
1279             for (int i=0; i<pids.length; i++) {
1280                 ProcessItem proc = mAllProcessItems.get(i);
1281                 changed |= proc.updateSize(context, pss[i], mSequence);
1282                 if (proc.mCurSeq == mSequence) {
1283                     serviceProcessMemory += proc.mSize;
1284                 } else if (proc.mRunningProcessInfo.importance >=
1285                         ActivityManager.RunningAppProcessInfo.IMPORTANCE_BACKGROUND) {
1286                     backgroundProcessMemory += proc.mSize;
1287                     MergedItem mergedItem;
1288                     if (newBackgroundItems != null) {
1289                         mergedItem = proc.mMergedItem = new MergedItem(proc.mUserId);
1290                         proc.mMergedItem.mProcess = proc;
1291                         diffUsers |= mergedItem.mUserId != mMyUserId;
1292                         newBackgroundItems.add(mergedItem);
1293                     } else {
1294                         if (bgIndex >= mBackgroundItems.size()
1295                                 || mBackgroundItems.get(bgIndex).mProcess != proc) {
1296                             newBackgroundItems = new ArrayList<MergedItem>(numBackgroundProcesses);
1297                             for (int bgi=0; bgi<bgIndex; bgi++) {
1298                                 mergedItem = mBackgroundItems.get(bgi);
1299                                 diffUsers |= mergedItem.mUserId != mMyUserId;
1300                                 newBackgroundItems.add(mergedItem);
1301                             }
1302                             mergedItem = proc.mMergedItem = new MergedItem(proc.mUserId);
1303                             proc.mMergedItem.mProcess = proc;
1304                             diffUsers |= mergedItem.mUserId != mMyUserId;
1305                             newBackgroundItems.add(mergedItem);
1306                         } else {
1307                             mergedItem = mBackgroundItems.get(bgIndex);
1308                         }
1309                     }
1310                     mergedItem.update(context, true);
1311                     mergedItem.updateSize(context);
1312                     bgIndex++;
1313                 } else if (proc.mRunningProcessInfo.importance <=
1314                         ActivityManager.RunningAppProcessInfo.IMPORTANCE_VISIBLE) {
1315                     foregroundProcessMemory += proc.mSize;
1316                 }
1317             }
1318         } catch (RemoteException e) {
1319         }
1320
1321         if (newBackgroundItems == null) {
1322             // One or more at the bottom may no longer exist.
1323             if (mBackgroundItems.size() > numBackgroundProcesses) {
1324                 newBackgroundItems = new ArrayList<MergedItem>(numBackgroundProcesses);
1325                 for (int bgi=0; bgi<numBackgroundProcesses; bgi++) {
1326                     MergedItem mergedItem = mBackgroundItems.get(bgi);
1327                     diffUsers |= mergedItem.mUserId != mMyUserId;
1328                     newBackgroundItems.add(mergedItem);
1329                 }
1330             }
1331         }
1332
1333         if (newBackgroundItems != null) {
1334             // The background items have changed; we need to re-build the
1335             // per-user items.
1336             if (!diffUsers) {
1337                 // Easy: there are no other users, we can just use the same array.
1338                 newUserBackgroundItems = newBackgroundItems;
1339             } else {
1340                 // We now need to re-build the per-user list so that background
1341                 // items for users are collapsed together.
1342                 newUserBackgroundItems = new ArrayList<MergedItem>();
1343                 final int NB = newBackgroundItems.size();
1344                 for (int i=0; i<NB; i++) {
1345                     MergedItem mergedItem = newBackgroundItems.get(i);
1346                     if (mergedItem.mUserId != mMyUserId) {
1347                         addOtherUserItem(context, newUserBackgroundItems,
1348                                 mOtherUserBackgroundItems, mergedItem);
1349                     } else {
1350                         newUserBackgroundItems.add(mergedItem);
1351                     }
1352                 }
1353                 // And user aggregated merged items need to be
1354                 // updated now that they have all of their children.
1355                 final int NU = mOtherUserBackgroundItems.size();
1356                 for (int i=0; i<NU; i++) {
1357                     MergedItem user = mOtherUserBackgroundItems.valueAt(i);
1358                     if (user.mCurSeq == mSequence) {
1359                         user.update(context, true);
1360                         user.updateSize(context);
1361                     }
1362                 }
1363             }
1364         }
1365
1366         for (int i=0; i<mMergedItems.size(); i++) {
1367             mMergedItems.get(i).updateSize(context);
1368         }
1369
1370         synchronized (mLock) {
1371             mNumBackgroundProcesses = numBackgroundProcesses;
1372             mNumForegroundProcesses = numForegroundProcesses;
1373             mNumServiceProcesses = numServiceProcesses;
1374             mBackgroundProcessMemory = backgroundProcessMemory;
1375             mForegroundProcessMemory = foregroundProcessMemory;
1376             mServiceProcessMemory = serviceProcessMemory;
1377             if (newBackgroundItems != null) {
1378                 mBackgroundItems = newBackgroundItems;
1379                 mUserBackgroundItems = newUserBackgroundItems;
1380                 if (mWatchingBackgroundItems) {
1381                     changed = true;
1382                 }
1383             }
1384             if (!mHaveData) {
1385                 mHaveData = true;
1386                 mLock.notifyAll();
1387             }
1388         }
1389
1390         return changed;
1391     }
1392
1393     ArrayList<BaseItem> getCurrentItems() {
1394         synchronized (mLock) {
1395             return mItems;
1396         }
1397     }
1398
1399     void setWatchingBackgroundItems(boolean watching) {
1400         synchronized (mLock) {
1401             mWatchingBackgroundItems = watching;
1402         }
1403     }
1404
1405     ArrayList<MergedItem> getCurrentMergedItems() {
1406         synchronized (mLock) {
1407             return mMergedItems;
1408         }
1409     }
1410
1411     ArrayList<MergedItem> getCurrentBackgroundItems() {
1412         synchronized (mLock) {
1413             return mUserBackgroundItems;
1414         }
1415     }
1416 }