diff options
Diffstat (limited to 'services/java/com/android/server/am')
26 files changed, 15099 insertions, 0 deletions
diff --git a/services/java/com/android/server/am/ActivityManagerService.java b/services/java/com/android/server/am/ActivityManagerService.java new file mode 100644 index 0000000..141569e --- /dev/null +++ b/services/java/com/android/server/am/ActivityManagerService.java @@ -0,0 +1,11790 @@ +/* + * Copyright (C) 2006-2008 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.server.am; + +import com.android.internal.os.BatteryStatsImpl; +import com.android.internal.os.RuntimeInit; +import com.android.server.IntentResolver; +import com.android.server.ProcessMap; +import com.android.server.ProcessStats; +import com.android.server.SystemServer; +import com.android.server.Watchdog; +import com.android.server.WindowManagerService; + +import android.app.Activity; +import android.app.ActivityManager; +import android.app.ActivityManagerNative; +import android.app.ActivityThread; +import android.app.AlertDialog; +import android.app.Dialog; +import android.app.IActivityWatcher; +import android.app.IApplicationThread; +import android.app.IInstrumentationWatcher; +import android.app.IIntentReceiver; +import android.app.IIntentSender; +import android.app.IServiceConnection; +import android.app.IThumbnailReceiver; +import android.app.Instrumentation; +import android.app.PendingIntent; +import android.app.ResultInfo; +import android.content.ComponentName; +import android.content.ContentResolver; +import android.content.Context; +import android.content.Intent; +import android.content.IntentFilter; +import android.content.pm.ActivityInfo; +import android.content.pm.ApplicationInfo; +import android.content.pm.ConfigurationInfo; +import android.content.pm.IPackageDataObserver; +import android.content.pm.IPackageManager; +import android.content.pm.InstrumentationInfo; +import android.content.pm.PackageManager; +import android.content.pm.ProviderInfo; +import android.content.pm.ResolveInfo; +import android.content.pm.ServiceInfo; +import android.content.res.Configuration; +import android.graphics.Bitmap; +import android.net.Uri; +import android.os.Binder; +import android.os.Bundle; +import android.os.Environment; +import android.os.FileUtils; +import android.os.Handler; +import android.os.IBinder; +import android.os.IPermissionController; +import android.os.Looper; +import android.os.Message; +import android.os.Parcel; +import android.os.ParcelFileDescriptor; +import android.os.PowerManager; +import android.os.Process; +import android.os.RemoteException; +import android.os.ServiceManager; +import android.os.SystemClock; +import android.os.SystemProperties; +import android.provider.Checkin; +import android.provider.Settings; +import android.text.TextUtils; +import android.util.Config; +import android.util.EventLog; +import android.util.Log; +import android.util.PrintWriterPrinter; +import android.util.SparseArray; +import android.view.Gravity; +import android.view.LayoutInflater; +import android.view.View; +import android.view.WindowManager; +import android.view.WindowManagerPolicy; + +import dalvik.system.Zygote; + +import java.io.File; +import java.io.FileDescriptor; +import java.io.FileInputStream; +import java.io.FileNotFoundException; +import java.io.PrintWriter; +import java.lang.IllegalStateException; +import java.lang.ref.WeakReference; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Iterator; +import java.util.List; +import java.util.Locale; +import java.util.Map; + +public final class ActivityManagerService extends ActivityManagerNative implements Watchdog.Monitor { + static final String TAG = "ActivityManager"; + static final boolean DEBUG = false; + static final boolean localLOGV = DEBUG ? Config.LOGD : Config.LOGV; + static final boolean DEBUG_SWITCH = localLOGV || false; + static final boolean DEBUG_TASKS = localLOGV || false; + static final boolean DEBUG_PAUSE = localLOGV || false; + static final boolean DEBUG_OOM_ADJ = localLOGV || false; + static final boolean DEBUG_TRANSITION = localLOGV || false; + static final boolean DEBUG_BROADCAST = localLOGV || false; + static final boolean DEBUG_SERVICE = localLOGV || false; + static final boolean DEBUG_VISBILITY = localLOGV || false; + static final boolean DEBUG_PROCESSES = localLOGV || false; + static final boolean DEBUG_USER_LEAVING = localLOGV || false; + static final boolean VALIDATE_TOKENS = false; + static final boolean SHOW_ACTIVITY_START_TIME = true; + + // Control over CPU and battery monitoring. + static final long BATTERY_STATS_TIME = 30*60*1000; // write battery stats every 30 minutes. + static final boolean MONITOR_CPU_USAGE = true; + static final long MONITOR_CPU_MIN_TIME = 5*1000; // don't sample cpu less than every 5 seconds. + static final long MONITOR_CPU_MAX_TIME = 0x0fffffff; // wait possibly forever for next cpu sample. + static final boolean MONITOR_THREAD_CPU_USAGE = false; + + // Event log tags + static final int LOG_CONFIGURATION_CHANGED = 2719; + static final int LOG_CPU = 2721; + static final int LOG_AM_FINISH_ACTIVITY = 30001; + static final int LOG_TASK_TO_FRONT = 30002; + static final int LOG_AM_NEW_INTENT = 30003; + static final int LOG_AM_CREATE_TASK = 30004; + static final int LOG_AM_CREATE_ACTIVITY = 30005; + static final int LOG_AM_RESTART_ACTIVITY = 30006; + static final int LOG_AM_RESUME_ACTIVITY = 30007; + static final int LOG_ANR = 30008; + static final int LOG_ACTIVITY_LAUNCH_TIME = 30009; + static final int LOG_AM_PROCESS_BOUND = 30010; + static final int LOG_AM_PROCESS_DIED = 30011; + static final int LOG_AM_FAILED_TO_PAUSE_ACTIVITY = 30012; + static final int LOG_AM_PAUSE_ACTIVITY = 30013; + static final int LOG_AM_PROCESS_START = 30014; + static final int LOG_AM_PROCESS_BAD = 30015; + static final int LOG_AM_PROCESS_GOOD = 30016; + static final int LOG_AM_LOW_MEMORY = 30017; + static final int LOG_AM_DESTROY_ACTIVITY = 30018; + static final int LOG_AM_RELAUNCH_RESUME_ACTIVITY = 30019; + static final int LOG_AM_RELAUNCH_ACTIVITY = 30020; + static final int LOG_AM_KILL_FOR_MEMORY = 30023; + static final int LOG_AM_BROADCAST_DISCARD_FILTER = 30024; + static final int LOG_AM_BROADCAST_DISCARD_APP = 30025; + static final int LOG_AM_CREATE_SERVICE = 30030; + static final int LOG_AM_DESTROY_SERVICE = 30031; + static final int LOG_AM_PROCESS_CRASHED_TOO_MUCH = 30032; + static final int LOG_AM_DROP_PROCESS = 30033; + static final int LOG_AM_SERVICE_CRASHED_TOO_MUCH = 30034; + static final int LOG_AM_SCHEDULE_SERVICE_RESTART = 30035; + static final int LOG_AM_PROVIDER_LOST_PROCESS = 30036; + + static final int LOG_BOOT_PROGRESS_AMS_READY = 3040; + static final int LOG_BOOT_PROGRESS_ENABLE_SCREEN = 3050; + + private static final String SYSTEM_SECURE = "ro.secure"; + + // This is the maximum number of application processes we would like + // to have running. Due to the asynchronous nature of things, we can + // temporarily go beyond this limit. + static final int MAX_PROCESSES = 2; + + // Set to false to leave processes running indefinitely, relying on + // the kernel killing them as resources are required. + static final boolean ENFORCE_PROCESS_LIMIT = false; + + // This is the maximum number of activities that we would like to have + // running at a given time. + static final int MAX_ACTIVITIES = 20; + + // Maximum number of recent tasks that we can remember. + static final int MAX_RECENT_TASKS = 20; + + // How long until we reset a task when the user returns to it. Currently + // 30 minutes. + static final long ACTIVITY_INACTIVE_RESET_TIME = 1000*60*30; + + // Set to true to disable the icon that is shown while a new activity + // is being started. + static final boolean SHOW_APP_STARTING_ICON = true; + + // How long we wait until giving up on the last activity to pause. This + // is short because it directly impacts the responsiveness of starting the + // next activity. + static final int PAUSE_TIMEOUT = 500; + + /** + * How long we can hold the launch wake lock before giving up. + */ + static final int LAUNCH_TIMEOUT = 10*1000; + + // How long we wait for a launched process to attach to the activity manager + // before we decide it's never going to come up for real. + static final int PROC_START_TIMEOUT = 10*1000; + + // How long we wait until giving up on the last activity telling us it + // is idle. + static final int IDLE_TIMEOUT = 10*1000; + + // How long to wait after going idle before forcing apps to GC. + static final int GC_TIMEOUT = 5*1000; + + // How long we wait until giving up on an activity telling us it has + // finished destroying itself. + static final int DESTROY_TIMEOUT = 10*1000; + + // How long we allow a receiver to run before giving up on it. + static final int BROADCAST_TIMEOUT = 10*1000; + + // How long we wait for a service to finish executing. + static final int SERVICE_TIMEOUT = 20*1000; + + // How long a service needs to be running until restarting its process + // is no longer considered to be a relaunch of the service. + static final int SERVICE_RESTART_DURATION = 5*1000; + + // Maximum amount of time for there to be no activity on a service before + // we consider it non-essential and allow its process to go on the + // LRU background list. + static final int MAX_SERVICE_INACTIVITY = 10*60*1000; + + // How long we wait until we timeout on key dispatching. + static final int KEY_DISPATCHING_TIMEOUT = 5*1000; + + // The minimum time we allow between crashes, for us to consider this + // application to be bad and stop and its services and reject broadcasts. + static final int MIN_CRASH_INTERVAL = 60*1000; + + // How long we wait until we timeout on key dispatching during instrumentation. + static final int INSTRUMENTATION_KEY_DISPATCHING_TIMEOUT = 60*1000; + + // OOM adjustments for processes in various states: + + // This is a process without anything currently running in it. Definitely + // the first to go! Value set in system/rootdir/init.rc on startup. + // This value is initalized in the constructor, careful when refering to + // this static variable externally. + static int EMPTY_APP_ADJ; + + // This is a process with a content provider that does not have any clients + // attached to it. If it did have any clients, its adjustment would be the + // one for the highest-priority of those processes. + static int CONTENT_PROVIDER_ADJ; + + // This is a process only hosting activities that are not visible, + // so it can be killed without any disruption. Value set in + // system/rootdir/init.rc on startup. + final int HIDDEN_APP_MAX_ADJ; + static int HIDDEN_APP_MIN_ADJ; + + // This is a process holding a secondary server -- killing it will not + // have much of an impact as far as the user is concerned. Value set in + // system/rootdir/init.rc on startup. + final int SECONDARY_SERVER_ADJ; + + // This is a process only hosting activities that are visible to the + // user, so we'd prefer they don't disappear. Value set in + // system/rootdir/init.rc on startup. + final int VISIBLE_APP_ADJ; + + // This is the process running the current foreground app. We'd really + // rather not kill it! Value set in system/rootdir/init.rc on startup. + final int FOREGROUND_APP_ADJ; + + // This is a process running a core server, such as telephony. Definitely + // don't want to kill it, but doing so is not completely fatal. + static final int CORE_SERVER_ADJ = -12; + + // The system process runs at the default adjustment. + static final int SYSTEM_ADJ = -16; + + // Memory pages are 4K. + static final int PAGE_SIZE = 4*1024; + + // Corresponding memory levels for above adjustments. + final int EMPTY_APP_MEM; + final int HIDDEN_APP_MEM; + final int SECONDARY_SERVER_MEM; + final int VISIBLE_APP_MEM; + final int FOREGROUND_APP_MEM; + + final int MY_PID; + + static final String[] EMPTY_STRING_ARRAY = new String[0]; + + enum ActivityState { + INITIALIZING, + RESUMED, + PAUSING, + PAUSED, + STOPPING, + STOPPED, + FINISHING, + DESTROYING, + DESTROYED + } + + /** + * The back history of all previous (and possibly still + * running) activities. It contains HistoryRecord objects. + */ + final ArrayList mHistory = new ArrayList(); + + /** + * List of all active broadcasts that are to be executed immediately + * (without waiting for another broadcast to finish). Currently this only + * contains broadcasts to registered receivers, to avoid spinning up + * a bunch of processes to execute IntentReceiver components. + */ + final ArrayList<BroadcastRecord> mParallelBroadcasts + = new ArrayList<BroadcastRecord>(); + + /** + * List of all active broadcasts that are to be executed one at a time. + * The object at the top of the list is the currently activity broadcasts; + * those after it are waiting for the top to finish.. + */ + final ArrayList<BroadcastRecord> mOrderedBroadcasts + = new ArrayList<BroadcastRecord>(); + + /** + * Set when we current have a BROADCAST_INTENT_MSG in flight. + */ + boolean mBroadcastsScheduled = false; + + /** + * Set to indicate whether to issue an onUserLeaving callback when a + * newly launched activity is being brought in front of us. + */ + boolean mUserLeaving = false; + + /** + * When we are in the process of pausing an activity, before starting the + * next one, this variable holds the activity that is currently being paused. + */ + HistoryRecord mPausingActivity = null; + + /** + * Current activity that is resumed, or null if there is none. + */ + HistoryRecord mResumedActivity = null; + + /** + * Activity we have told the window manager to have key focus. + */ + HistoryRecord mFocusedActivity = null; + + /** + * This is the last activity that we put into the paused state. This is + * used to determine if we need to do an activity transition while sleeping, + * when we normally hold the top activity paused. + */ + HistoryRecord mLastPausedActivity = null; + + /** + * List of activities that are waiting for a new activity + * to become visible before completing whatever operation they are + * supposed to do. + */ + final ArrayList mWaitingVisibleActivities = new ArrayList(); + + /** + * List of activities that are ready to be stopped, but waiting + * for the next activity to settle down before doing so. It contains + * HistoryRecord objects. + */ + final ArrayList<HistoryRecord> mStoppingActivities + = new ArrayList<HistoryRecord>(); + + /** + * List of intents that were used to start the most recent tasks. + */ + final ArrayList<TaskRecord> mRecentTasks + = new ArrayList<TaskRecord>(); + + /** + * List of activities that are ready to be finished, but waiting + * for the previous activity to settle down before doing so. It contains + * HistoryRecord objects. + */ + final ArrayList mFinishingActivities = new ArrayList(); + + /** + * All of the applications we currently have running organized by name. + * The keys are strings of the application package name (as + * returned by the package manager), and the keys are ApplicationRecord + * objects. + */ + final ProcessMap<ProcessRecord> mProcessNames + = new ProcessMap<ProcessRecord>(); + + /** + * The last time that various processes have crashed. + */ + final ProcessMap<Long> mProcessCrashTimes = new ProcessMap<Long>(); + + /** + * Set of applications that we consider to be bad, and will reject + * incoming broadcasts from (which the user has no control over). + * Processes are added to this set when they have crashed twice within + * a minimum amount of time; they are removed from it when they are + * later restarted (hopefully due to some user action). The value is the + * time it was added to the list. + */ + final ProcessMap<Long> mBadProcesses = new ProcessMap<Long>(); + + /** + * All of the processes we currently have running organized by pid. + * The keys are the pid running the application. + * + * <p>NOTE: This object is protected by its own lock, NOT the global + * activity manager lock! + */ + final SparseArray<ProcessRecord> mPidsSelfLocked + = new SparseArray<ProcessRecord>(); + + /** + * All of the processes that have been forced to be foreground. The key + * is the pid of the caller who requested it (we hold a death + * link on it). + */ + abstract class ForegroundToken implements IBinder.DeathRecipient { + int pid; + IBinder token; + } + final SparseArray<ForegroundToken> mForegroundProcesses + = new SparseArray<ForegroundToken>(); + + /** + * List of records for processes that someone had tried to start before the + * system was ready. We don't start them at that point, but ensure they + * are started by the time booting is complete. + */ + final ArrayList<ProcessRecord> mProcessesOnHold + = new ArrayList<ProcessRecord>(); + + /** + * List of records for processes that we have started and are waiting + * for them to call back. This is really only needed when running in + * single processes mode, in which case we do not have a unique pid for + * each process. + */ + final ArrayList<ProcessRecord> mStartingProcesses + = new ArrayList<ProcessRecord>(); + + /** + * List of persistent applications that are in the process + * of being started. + */ + final ArrayList<ProcessRecord> mPersistentStartingProcesses + = new ArrayList<ProcessRecord>(); + + /** + * Processes that are being forcibly torn down. + */ + final ArrayList<ProcessRecord> mRemovedProcesses + = new ArrayList<ProcessRecord>(); + + /** + * List of running applications, sorted by recent usage. + * The first entry in the list is the least recently used. + * It contains ApplicationRecord objects. This list does NOT include + * any persistent application records (since we never want to exit them). + */ + final ArrayList<ProcessRecord> mLRUProcesses + = new ArrayList<ProcessRecord>(); + + /** + * List of processes that should gc as soon as things are idle. + */ + final ArrayList<ProcessRecord> mProcessesToGc + = new ArrayList<ProcessRecord>(); + + /** + * List of running activities, sorted by recent usage. + * The first entry in the list is the least recently used. + * It contains HistoryRecord objects. + */ + private final ArrayList mLRUActivities = new ArrayList(); + + /** + * Set of PendingResultRecord objects that are currently active. + */ + final HashSet mPendingResultRecords = new HashSet(); + + /** + * Set of IntentSenderRecord objects that are currently active. + */ + final HashMap<PendingIntentRecord.Key, WeakReference<PendingIntentRecord>> mIntentSenderRecords + = new HashMap<PendingIntentRecord.Key, WeakReference<PendingIntentRecord>>(); + + /** + * Intent broadcast that we have tried to start, but are + * waiting for its application's process to be created. We only + * need one (instead of a list) because we always process broadcasts + * one at a time, so no others can be started while waiting for this + * one. + */ + BroadcastRecord mPendingBroadcast = null; + + /** + * Keeps track of all IIntentReceivers that have been registered for + * broadcasts. Hash keys are the receiver IBinder, hash value is + * a ReceiverList. + */ + final HashMap mRegisteredReceivers = new HashMap(); + + /** + * Resolver for broadcast intents to registered receivers. + * Holds BroadcastFilter (subclass of IntentFilter). + */ + final IntentResolver<BroadcastFilter, BroadcastFilter> mReceiverResolver + = new IntentResolver<BroadcastFilter, BroadcastFilter>() { + @Override + protected boolean allowFilterResult( + BroadcastFilter filter, List<BroadcastFilter> dest) { + IBinder target = filter.receiverList.receiver.asBinder(); + for (int i=dest.size()-1; i>=0; i--) { + if (dest.get(i).receiverList.receiver.asBinder() == target) { + return false; + } + } + return true; + } + }; + + /** + * State of all active sticky broadcasts. Keys are the action of the + * sticky Intent, values are an ArrayList of all broadcasted intents with + * that action (which should usually be one). + */ + final HashMap<String, ArrayList<Intent>> mStickyBroadcasts = + new HashMap<String, ArrayList<Intent>>(); + + /** + * All currently running services. + */ + final HashMap<ComponentName, ServiceRecord> mServices = + new HashMap<ComponentName, ServiceRecord>(); + + /** + * All currently running services indexed by the Intent used to start them. + */ + final HashMap<Intent.FilterComparison, ServiceRecord> mServicesByIntent = + new HashMap<Intent.FilterComparison, ServiceRecord>(); + + /** + * All currently bound service connections. Keys are the IBinder of + * the client's IServiceConnection. + */ + final HashMap<IBinder, ConnectionRecord> mServiceConnections + = new HashMap<IBinder, ConnectionRecord>(); + + /** + * List of services that we have been asked to start, + * but haven't yet been able to. It is used to hold start requests + * while waiting for their corresponding application thread to get + * going. + */ + final ArrayList<ServiceRecord> mPendingServices + = new ArrayList<ServiceRecord>(); + + /** + * List of services that are scheduled to restart following a crash. + */ + final ArrayList<ServiceRecord> mRestartingServices + = new ArrayList<ServiceRecord>(); + + /** + * List of services that are in the process of being stopped. + */ + final ArrayList<ServiceRecord> mStoppingServices + = new ArrayList<ServiceRecord>(); + + /** + * List of PendingThumbnailsRecord objects of clients who are still + * waiting to receive all of the thumbnails for a task. + */ + final ArrayList mPendingThumbnails = new ArrayList(); + + /** + * List of HistoryRecord objects that have been finished and must + * still report back to a pending thumbnail receiver. + */ + final ArrayList mCancelledThumbnails = new ArrayList(); + + /** + * All of the currently running global content providers. Keys are a + * string containing the provider name and values are a + * ContentProviderRecord object containing the data about it. Note + * that a single provider may be published under multiple names, so + * there may be multiple entries here for a single one in mProvidersByClass. + */ + final HashMap mProvidersByName = new HashMap(); + + /** + * All of the currently running global content providers. Keys are a + * string containing the provider's implementation class and values are a + * ContentProviderRecord object containing the data about it. + */ + final HashMap mProvidersByClass = new HashMap(); + + /** + * List of content providers who have clients waiting for them. The + * application is currently being launched and the provider will be + * removed from this list once it is published. + */ + final ArrayList mLaunchingProviders = new ArrayList(); + + /** + * Global set of specific Uri permissions that have been granted. + */ + final private SparseArray<HashMap<Uri, UriPermission>> mGrantedUriPermissions + = new SparseArray<HashMap<Uri, UriPermission>>(); + + /** + * Thread-local storage used to carry caller permissions over through + * indirect content-provider access. + * @see #ActivityManagerService.openContentUri() + */ + private class Identity { + public int pid; + public int uid; + + Identity(int _pid, int _uid) { + pid = _pid; + uid = _uid; + } + } + private static ThreadLocal<Identity> sCallerIdentity = new ThreadLocal<Identity>(); + + /** + * All information we have collected about the runtime performance of + * any user id that can impact battery performance. + */ + final BatteryStatsService mBatteryStatsService; + + /** + * information about component usage + */ + final UsageStatsService mUsageStatsService; + + /** + * Current configuration information. HistoryRecord objects are given + * a reference to this object to indicate which configuration they are + * currently running in, so this object must be kept immutable. + */ + Configuration mConfiguration = new Configuration(); + + /** + * List of initialization arguments to pass to all processes when binding applications to them. + * For example, references to the commonly used services. + */ + HashMap<String, IBinder> mAppBindArgs; + + /** + * Used to control how we initialize the service. + */ + boolean mStartRunning = false; + ComponentName mTopComponent; + String mTopAction; + String mTopData; + boolean mSystemReady = false; + boolean mBooting = false; + + Context mContext; + + int mFactoryTest; + + /** + * Set while we are wanting to sleep, to prevent any + * activities from being started/resumed. + */ + boolean mSleeping = false; + + /** + * Set when the system is going to sleep, until we have + * successfully paused the current activity and released our wake lock. + * At that point the system is allowed to actually sleep. + */ + PowerManager.WakeLock mGoingToSleep; + + /** + * We don't want to allow the device to go to sleep while in the process + * of launching an activity. This is primarily to allow alarm intent + * receivers to launch an activity and get that to run before the device + * goes back to sleep. + */ + PowerManager.WakeLock mLaunchingActivity; + + /** + * Task identifier that activities are currently being started + * in. Incremented each time a new task is created. + * todo: Replace this with a TokenSpace class that generates non-repeating + * integers that won't wrap. + */ + int mCurTask = 1; + + /** + * Current sequence id for oom_adj computation traversal. + */ + int mAdjSeq = 0; + + /** + * Set to true if the ANDROID_SIMPLE_PROCESS_MANAGEMENT envvar + * is set, indicating the user wants processes started in such a way + * that they can use ANDROID_PROCESS_WRAPPER and know what will be + * running in each process (thus no pre-initialized process, etc). + */ + boolean mSimpleProcessManagement = false; + + /** + * System monitoring: number of processes that died since the last + * N procs were started. + */ + int[] mProcDeaths = new int[20]; + + String mDebugApp = null; + boolean mWaitForDebugger = false; + boolean mDebugTransient = false; + String mOrigDebugApp = null; + boolean mOrigWaitForDebugger = false; + boolean mAlwaysFinishActivities = false; + IActivityWatcher mWatcher = null; + + /** + * Callback of last caller to {@link #requestPss}. + */ + Runnable mRequestPssCallback; + + /** + * Remaining processes for which we are waiting results from the last + * call to {@link #requestPss}. + */ + final ArrayList<ProcessRecord> mRequestPssList + = new ArrayList<ProcessRecord>(); + + /** + * Runtime statistics collection thread. This object's lock is used to + * protect all related state. + */ + final Thread mProcessStatsThread; + + /** + * Used to collect process stats when showing not responding dialog. + * Protected by mProcessStatsThread. + */ + final ProcessStats mProcessStats = new ProcessStats( + MONITOR_THREAD_CPU_USAGE); + long mLastCpuTime = 0; + long mLastWriteTime = 0; + + /** + * Set to true after the system has finished booting. + */ + boolean mBooted = false; + + int mProcessLimit = 0; + + WindowManagerService mWindowManager; + + static ActivityManagerService mSelf; + static ActivityThread mSystemThread; + + private final class AppDeathRecipient implements IBinder.DeathRecipient { + final ProcessRecord mApp; + final int mPid; + final IApplicationThread mAppThread; + + AppDeathRecipient(ProcessRecord app, int pid, + IApplicationThread thread) { + if (localLOGV) Log.v( + TAG, "New death recipient " + this + + " for thread " + thread.asBinder()); + mApp = app; + mPid = pid; + mAppThread = thread; + } + + public void binderDied() { + if (localLOGV) Log.v( + TAG, "Death received in " + this + + " for thread " + mAppThread.asBinder()); + removeRequestedPss(mApp); + synchronized(ActivityManagerService.this) { + appDiedLocked(mApp, mPid, mAppThread); + } + } + } + + static final int SHOW_ERROR_MSG = 1; + static final int SHOW_NOT_RESPONDING_MSG = 2; + static final int SHOW_FACTORY_ERROR_MSG = 3; + static final int UPDATE_CONFIGURATION_MSG = 4; + static final int GC_BACKGROUND_PROCESSES_MSG = 5; + static final int WAIT_FOR_DEBUGGER_MSG = 6; + static final int BROADCAST_INTENT_MSG = 7; + static final int BROADCAST_TIMEOUT_MSG = 8; + static final int PAUSE_TIMEOUT_MSG = 9; + static final int IDLE_TIMEOUT_MSG = 10; + static final int IDLE_NOW_MSG = 11; + static final int SERVICE_TIMEOUT_MSG = 12; + static final int UPDATE_TIME_ZONE = 13; + static final int SHOW_UID_ERROR_MSG = 14; + static final int IM_FEELING_LUCKY_MSG = 15; + static final int LAUNCH_TIMEOUT_MSG = 16; + static final int DESTROY_TIMEOUT_MSG = 17; + static final int SERVICE_ERROR_MSG = 18; + static final int RESUME_TOP_ACTIVITY_MSG = 19; + static final int PROC_START_TIMEOUT_MSG = 20; + + AlertDialog mUidAlert; + + final Handler mHandler = new Handler() { + //public Handler() { + // if (localLOGV) Log.v(TAG, "Handler started!"); + //} + + public void handleMessage(Message msg) { + switch (msg.what) { + case SHOW_ERROR_MSG: { + HashMap data = (HashMap) msg.obj; + byte[] crashData = (byte[])data.get("crashData"); + if (crashData != null) { + // This needs to be *un*synchronized to avoid deadlock. + ContentResolver resolver = mContext.getContentResolver(); + Checkin.reportCrash(resolver, crashData); + } + synchronized (ActivityManagerService.this) { + ProcessRecord proc = (ProcessRecord)data.get("app"); + if (proc != null && proc.crashDialog != null) { + Log.e(TAG, "App already has crash dialog: " + proc); + return; + } + AppErrorResult res = (AppErrorResult) data.get("result"); + if (!mSleeping) { + Dialog d = new AppErrorDialog( + mContext, res, proc, + (Integer)data.get("flags"), + (String)data.get("shortMsg"), + (String)data.get("longMsg")); + d.show(); + proc.crashDialog = d; + } else { + // The device is asleep, so just pretend that the user + // saw a crash dialog and hit "force quit". + res.set(0); + } + } + } break; + case SHOW_NOT_RESPONDING_MSG: { + synchronized (ActivityManagerService.this) { + HashMap data = (HashMap) msg.obj; + ProcessRecord proc = (ProcessRecord)data.get("app"); + if (proc != null && proc.anrDialog != null) { + Log.e(TAG, "App already has anr dialog: " + proc); + return; + } + Dialog d = new AppNotRespondingDialog(ActivityManagerService.this, + mContext, proc, (HistoryRecord)data.get("activity")); + d.show(); + proc.anrDialog = d; + } + } break; + case SHOW_FACTORY_ERROR_MSG: { + Dialog d = new FactoryErrorDialog( + mContext, msg.getData().getCharSequence("msg")); + d.show(); + enableScreenAfterBoot(); + } break; + case UPDATE_CONFIGURATION_MSG: { + final ContentResolver resolver = mContext.getContentResolver(); + Settings.System.putConfiguration(resolver, (Configuration)msg.obj); + } break; + case GC_BACKGROUND_PROCESSES_MSG: { + synchronized (ActivityManagerService.this) { + performAppGcsIfAppropriateLocked(); + } + } break; + case WAIT_FOR_DEBUGGER_MSG: { + synchronized (ActivityManagerService.this) { + ProcessRecord app = (ProcessRecord)msg.obj; + if (msg.arg1 != 0) { + if (!app.waitedForDebugger) { + Dialog d = new AppWaitingForDebuggerDialog( + ActivityManagerService.this, + mContext, app); + app.waitDialog = d; + app.waitedForDebugger = true; + d.show(); + } + } else { + if (app.waitDialog != null) { + app.waitDialog.dismiss(); + app.waitDialog = null; + } + } + } + } break; + case BROADCAST_INTENT_MSG: { + if (DEBUG_BROADCAST) Log.v( + TAG, "Received BROADCAST_INTENT_MSG"); + processNextBroadcast(true); + } break; + case BROADCAST_TIMEOUT_MSG: { + broadcastTimeout(); + } break; + case PAUSE_TIMEOUT_MSG: { + IBinder token = (IBinder)msg.obj; + // We don't at this point know if the activity is fullscreen, + // so we need to be conservative and assume it isn't. + Log.w(TAG, "Activity pause timeout for " + token); + activityPaused(token, null, true); + } break; + case IDLE_TIMEOUT_MSG: { + IBinder token = (IBinder)msg.obj; + // We don't at this point know if the activity is fullscreen, + // so we need to be conservative and assume it isn't. + Log.w(TAG, "Activity idle timeout for " + token); + activityIdleInternal(token, true); + } break; + case DESTROY_TIMEOUT_MSG: { + IBinder token = (IBinder)msg.obj; + // We don't at this point know if the activity is fullscreen, + // so we need to be conservative and assume it isn't. + Log.w(TAG, "Activity destroy timeout for " + token); + activityDestroyed(token); + } break; + case IDLE_NOW_MSG: { + IBinder token = (IBinder)msg.obj; + activityIdle(token); + } break; + case SERVICE_TIMEOUT_MSG: { + serviceTimeout((ProcessRecord)msg.obj); + } break; + case UPDATE_TIME_ZONE: { + synchronized (ActivityManagerService.this) { + for (int i = mLRUProcesses.size() - 1 ; i >= 0 ; i--) { + ProcessRecord r = mLRUProcesses.get(i); + if (r.thread != null) { + try { + r.thread.updateTimeZone(); + } catch (RemoteException ex) { + Log.w(TAG, "Failed to update time zone for: " + r.info.processName); + } + } + } + } + break; + } + case SHOW_UID_ERROR_MSG: { + // XXX This is a temporary dialog, no need to localize. + AlertDialog d = new BaseErrorDialog(mContext); + d.getWindow().setType(WindowManager.LayoutParams.TYPE_SYSTEM_ERROR); + d.setCancelable(false); + d.setTitle("System UIDs Inconsistent"); + d.setMessage("UIDs on the system are inconsistent, you need to wipe your data partition or your device will be unstable."); + d.setButton("I'm Feeling Lucky", + mHandler.obtainMessage(IM_FEELING_LUCKY_MSG)); + mUidAlert = d; + d.show(); + } break; + case IM_FEELING_LUCKY_MSG: { + if (mUidAlert != null) { + mUidAlert.dismiss(); + mUidAlert = null; + } + } break; + case LAUNCH_TIMEOUT_MSG: { + synchronized (ActivityManagerService.this) { + if (mLaunchingActivity.isHeld()) { + Log.w(TAG, "Launch timeout has expired, giving up wake lock!"); + mLaunchingActivity.release(); + } + } + } break; + case SERVICE_ERROR_MSG: { + ServiceRecord srv = (ServiceRecord)msg.obj; + // This needs to be *un*synchronized to avoid deadlock. + Checkin.logEvent(mContext.getContentResolver(), + Checkin.Events.Tag.SYSTEM_SERVICE_LOOPING, + srv.name.toShortString()); + } break; + case RESUME_TOP_ACTIVITY_MSG: { + synchronized (ActivityManagerService.this) { + resumeTopActivityLocked(null); + } + } + case PROC_START_TIMEOUT_MSG: { + ProcessRecord app = (ProcessRecord)msg.obj; + synchronized (ActivityManagerService.this) { + processStartTimedOutLocked(app); + } + } + } + } + }; + + public static void setSystemProcess() { + try { + ActivityManagerService m = mSelf; + + ServiceManager.addService("activity", m); + ServiceManager.addService("meminfo", new MemBinder(m)); + if (MONITOR_CPU_USAGE) { + ServiceManager.addService("cpuinfo", new CpuBinder(m)); + } + ServiceManager.addService("activity.broadcasts", new BroadcastsBinder(m)); + ServiceManager.addService("activity.services", new ServicesBinder(m)); + ServiceManager.addService("activity.senders", new SendersBinder(m)); + ServiceManager.addService("activity.providers", new ProvidersBinder(m)); + ServiceManager.addService("permission", new PermissionController(m)); + + ApplicationInfo info = + mSelf.mContext.getPackageManager().getApplicationInfo( + "android", PackageManager.GET_SHARED_LIBRARY_FILES); + synchronized (mSelf) { + ProcessRecord app = mSelf.newProcessRecordLocked( + mSystemThread.getApplicationThread(), info, + info.processName); + app.persistent = true; + app.pid = Process.myPid(); + app.maxAdj = SYSTEM_ADJ; + mSelf.mProcessNames.put(app.processName, app.info.uid, app); + synchronized (mSelf.mPidsSelfLocked) { + mSelf.mPidsSelfLocked.put(app.pid, app); + } + mSelf.updateLRUListLocked(app, true); + } + } catch (PackageManager.NameNotFoundException e) { + throw new RuntimeException( + "Unable to find android system package", e); + } + } + + public void setWindowManager(WindowManagerService wm) { + mWindowManager = wm; + } + + public static final Context main(int factoryTest) { + AThread thr = new AThread(); + thr.start(); + + synchronized (thr) { + while (thr.mService == null) { + try { + thr.wait(); + } catch (InterruptedException e) { + } + } + } + + ActivityManagerService m = thr.mService; + mSelf = m; + ActivityThread at = ActivityThread.systemMain(); + mSystemThread = at; + Context context = at.getSystemContext(); + m.mContext = context; + m.mFactoryTest = factoryTest; + PowerManager pm = + (PowerManager)context.getSystemService(Context.POWER_SERVICE); + m.mGoingToSleep = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "ActivityManager-Sleep"); + m.mLaunchingActivity = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "ActivityManager-Launch"); + m.mLaunchingActivity.setReferenceCounted(false); + + m.mBatteryStatsService.publish(context); + m.mUsageStatsService.publish(context); + + synchronized (thr) { + thr.mReady = true; + thr.notifyAll(); + } + + m.startRunning(null, null, null, null); + + return context; + } + + public static ActivityManagerService self() { + return mSelf; + } + + static class AThread extends Thread { + ActivityManagerService mService; + boolean mReady = false; + + public AThread() { + super("ActivityManager"); + } + + public void run() { + Looper.prepare(); + + android.os.Process.setThreadPriority( + android.os.Process.THREAD_PRIORITY_FOREGROUND); + + ActivityManagerService m = new ActivityManagerService(); + + synchronized (this) { + mService = m; + notifyAll(); + } + + synchronized (this) { + while (!mReady) { + try { + wait(); + } catch (InterruptedException e) { + } + } + } + + Looper.loop(); + } + } + + static class BroadcastsBinder extends Binder { + ActivityManagerService mActivityManagerService; + BroadcastsBinder(ActivityManagerService activityManagerService) { + mActivityManagerService = activityManagerService; + } + + @Override + protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) { + mActivityManagerService.dumpBroadcasts(pw); + } + } + + static class ServicesBinder extends Binder { + ActivityManagerService mActivityManagerService; + ServicesBinder(ActivityManagerService activityManagerService) { + mActivityManagerService = activityManagerService; + } + + @Override + protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) { + mActivityManagerService.dumpServices(pw); + } + } + + static class SendersBinder extends Binder { + ActivityManagerService mActivityManagerService; + SendersBinder(ActivityManagerService activityManagerService) { + mActivityManagerService = activityManagerService; + } + + @Override + protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) { + mActivityManagerService.dumpSenders(pw); + } + } + + static class ProvidersBinder extends Binder { + ActivityManagerService mActivityManagerService; + ProvidersBinder(ActivityManagerService activityManagerService) { + mActivityManagerService = activityManagerService; + } + + @Override + protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) { + mActivityManagerService.dumpProviders(pw); + } + } + + static class MemBinder extends Binder { + ActivityManagerService mActivityManagerService; + MemBinder(ActivityManagerService activityManagerService) { + mActivityManagerService = activityManagerService; + } + + @Override + protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) { + ActivityManagerService service = mActivityManagerService; + ArrayList<ProcessRecord> procs; + synchronized (mActivityManagerService) { + if (args != null && args.length > 0 + && args[0].charAt(0) != '-') { + procs = new ArrayList<ProcessRecord>(); + int pid = -1; + try { + pid = Integer.parseInt(args[0]); + } catch (NumberFormatException e) { + + } + for (int i=0; i<service.mLRUProcesses.size(); i++) { + ProcessRecord proc = service.mLRUProcesses.get(i); + if (proc.pid == pid) { + procs.add(proc); + } else if (proc.processName.equals(args[0])) { + procs.add(proc); + } + } + if (procs.size() <= 0) { + pw.println("No process found for: " + args[0]); + return; + } + } else { + procs = service.mLRUProcesses; + } + } + dumpApplicationMemoryUsage(fd, pw, procs, " ", args); + } + } + + static class CpuBinder extends Binder { + ActivityManagerService mActivityManagerService; + CpuBinder(ActivityManagerService activityManagerService) { + mActivityManagerService = activityManagerService; + } + + @Override + protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) { + synchronized (mActivityManagerService.mProcessStatsThread) { + pw.print(mActivityManagerService.mProcessStats.printCurrentState()); + } + } + } + + private ActivityManagerService() { + String v = System.getenv("ANDROID_SIMPLE_PROCESS_MANAGEMENT"); + if (v != null && Integer.getInteger(v) != 0) { + mSimpleProcessManagement = true; + } + v = System.getenv("ANDROID_DEBUG_APP"); + if (v != null) { + mSimpleProcessManagement = true; + } + + MY_PID = Process.myPid(); + + File dataDir = Environment.getDataDirectory(); + File systemDir = new File(dataDir, "system"); + systemDir.mkdirs(); + mBatteryStatsService = new BatteryStatsService(new File( + systemDir, "batterystats.bin").toString()); + mBatteryStatsService.getActiveStatistics().readLocked(); + mBatteryStatsService.getActiveStatistics().writeLocked(); + + mUsageStatsService = new UsageStatsService( new File( + systemDir, "usagestats.bin").toString()); + + mConfiguration.makeDefault(); + mProcessStats.init(); + + // Add ourself to the Watchdog monitors. + Watchdog.getInstance().addMonitor(this); + + // These values are set in system/rootdir/init.rc on startup. + FOREGROUND_APP_ADJ = + Integer.valueOf(SystemProperties.get("ro.FOREGROUND_APP_ADJ")); + VISIBLE_APP_ADJ = + Integer.valueOf(SystemProperties.get("ro.VISIBLE_APP_ADJ")); + SECONDARY_SERVER_ADJ = + Integer.valueOf(SystemProperties.get("ro.SECONDARY_SERVER_ADJ")); + HIDDEN_APP_MIN_ADJ = + Integer.valueOf(SystemProperties.get("ro.HIDDEN_APP_MIN_ADJ")); + CONTENT_PROVIDER_ADJ = + Integer.valueOf(SystemProperties.get("ro.CONTENT_PROVIDER_ADJ")); + HIDDEN_APP_MAX_ADJ = CONTENT_PROVIDER_ADJ-1; + EMPTY_APP_ADJ = + Integer.valueOf(SystemProperties.get("ro.EMPTY_APP_ADJ")); + FOREGROUND_APP_MEM = + Integer.valueOf(SystemProperties.get("ro.FOREGROUND_APP_MEM"))*PAGE_SIZE; + VISIBLE_APP_MEM = + Integer.valueOf(SystemProperties.get("ro.VISIBLE_APP_MEM"))*PAGE_SIZE; + SECONDARY_SERVER_MEM = + Integer.valueOf(SystemProperties.get("ro.SECONDARY_SERVER_MEM"))*PAGE_SIZE; + HIDDEN_APP_MEM = + Integer.valueOf(SystemProperties.get("ro.HIDDEN_APP_MEM"))*PAGE_SIZE; + EMPTY_APP_MEM = + Integer.valueOf(SystemProperties.get("ro.EMPTY_APP_MEM"))*PAGE_SIZE; + + mProcessStatsThread = new Thread("ProcessStats") { + public void run() { + while (true) { + try { + try { + synchronized(this) { + final long now = SystemClock.uptimeMillis(); + long nextCpuDelay = (mLastCpuTime+MONITOR_CPU_MAX_TIME)-now; + long nextWriteDelay = (mLastWriteTime+BATTERY_STATS_TIME)-now; + //Log.i(TAG, "Cpu delay=" + nextCpuDelay + // + ", write delay=" + nextWriteDelay); + if (nextWriteDelay < nextCpuDelay) { + nextCpuDelay = nextWriteDelay; + } + if (nextCpuDelay > 0) { + this.wait(nextCpuDelay); + } + } + } catch (InterruptedException e) { + } + + updateCpuStatsNow(); + } catch (Exception e) { + Log.e(TAG, "Unexpected exception collecting process stats", e); + } + } + } + }; + mProcessStatsThread.start(); + } + + @Override + public boolean onTransact(int code, Parcel data, Parcel reply, int flags) + throws RemoteException { + try { + return super.onTransact(code, data, reply, flags); + } catch (RuntimeException e) { + // The activity manager only throws security exceptions, so let's + // log all others. + if (!(e instanceof SecurityException)) { + Log.e(TAG, "Activity Manager Crash", e); + } + throw e; + } + } + + void updateCpuStats() { + synchronized (mProcessStatsThread) { + final long now = SystemClock.uptimeMillis(); + if (mLastCpuTime < (now-MONITOR_CPU_MIN_TIME)) { + mProcessStatsThread.notify(); + } + } + } + + void updateCpuStatsNow() { + synchronized (mProcessStatsThread) { + final long now = SystemClock.uptimeMillis(); + boolean haveNewCpuStats = false; + + if (MONITOR_CPU_USAGE && + mLastCpuTime < (now-MONITOR_CPU_MIN_TIME)) { + mLastCpuTime = now; + haveNewCpuStats = true; + mProcessStats.update(); + //Log.i(TAG, mProcessStats.printCurrentState()); + //Log.i(TAG, "Total CPU usage: " + // + mProcessStats.getTotalCpuPercent() + "%"); + + // Log the cpu usage if the property is set. + if ("true".equals(SystemProperties.get("events.cpu"))) { + int user = mProcessStats.getLastUserTime(); + int system = mProcessStats.getLastSystemTime(); + int iowait = mProcessStats.getLastIoWaitTime(); + int irq = mProcessStats.getLastIrqTime(); + int softIrq = mProcessStats.getLastSoftIrqTime(); + int idle = mProcessStats.getLastIdleTime(); + + int total = user + system + iowait + irq + softIrq + idle; + if (total == 0) total = 1; + + EventLog.writeEvent(LOG_CPU, + ((user+system+iowait+irq+softIrq) * 100) / total, + (user * 100) / total, + (system * 100) / total, + (iowait * 100) / total, + (irq * 100) / total, + (softIrq * 100) / total); + } + } + + synchronized(mBatteryStatsService.getActiveStatistics()) { + synchronized(mPidsSelfLocked) { + if (haveNewCpuStats) { + if (mBatteryStatsService.isOnBattery()) { + final int N = mProcessStats.countWorkingStats(); + for (int i=0; i<N; i++) { + ProcessStats.Stats st + = mProcessStats.getWorkingStats(i); + ProcessRecord pr = mPidsSelfLocked.get(st.pid); + if (pr != null) { + BatteryStatsImpl.Uid.Proc ps = pr.batteryStats; + ps.addCpuTimeLocked(st.rel_utime, st.rel_stime); + } + } + } + } + } + + if (mLastWriteTime < (now-BATTERY_STATS_TIME)) { + mLastWriteTime = now; + mBatteryStatsService.getActiveStatistics().writeLocked(); + } + } + } + } + + /** + * Initialize the application bind args. These are passed to each + * process when the bindApplication() IPC is sent to the process. They're + * lazily setup to make sure the services are running when they're asked for. + */ + private HashMap<String, IBinder> getCommonServicesLocked() { + if (mAppBindArgs == null) { + mAppBindArgs = new HashMap<String, IBinder>(); + + // Setup the application init args + mAppBindArgs.put("package", ServiceManager.getService("package")); + mAppBindArgs.put("window", ServiceManager.getService("window")); + mAppBindArgs.put(Context.ALARM_SERVICE, + ServiceManager.getService(Context.ALARM_SERVICE)); + } + return mAppBindArgs; + } + + private final void setFocusedActivityLocked(HistoryRecord r) { + if (mFocusedActivity != r) { + mFocusedActivity = r; + mWindowManager.setFocusedApp(r, true); + } + } + + private final void updateLRUListLocked(ProcessRecord app, + boolean oomAdj) { + // put it on the LRU to keep track of when it should be exited. + int lrui = mLRUProcesses.indexOf(app); + if (lrui >= 0) mLRUProcesses.remove(lrui); + mLRUProcesses.add(app); + //Log.i(TAG, "Putting proc to front: " + app.processName); + if (oomAdj) { + updateOomAdjLocked(); + } + } + + private final boolean updateLRUListLocked(HistoryRecord r) { + final boolean hadit = mLRUActivities.remove(r); + mLRUActivities.add(r); + return hadit; + } + + private final HistoryRecord topRunningActivityLocked(HistoryRecord notTop) { + int i = mHistory.size()-1; + while (i >= 0) { + HistoryRecord r = (HistoryRecord)mHistory.get(i); + if (!r.finishing && r != notTop) { + return r; + } + i--; + } + return null; + } + + /** + * This is a simplified version of topRunningActivityLocked that provides a number of + * optional skip-over modes. It is intended for use with the ActivityWatcher hook only. + * + * @param token If non-null, any history records matching this token will be skipped. + * @param taskId If non-zero, we'll attempt to skip over records with the same task ID. + * + * @return Returns the HistoryRecord of the next activity on the stack. + */ + private final HistoryRecord topRunningActivityLocked(IBinder token, int taskId) { + int i = mHistory.size()-1; + while (i >= 0) { + HistoryRecord r = (HistoryRecord)mHistory.get(i); + // Note: the taskId check depends on real taskId fields being non-zero + if (!r.finishing && (token != r) && (taskId != r.task.taskId)) { + return r; + } + i--; + } + return null; + } + + private final ProcessRecord getProcessRecordLocked( + String processName, int uid) { + if (uid == Process.SYSTEM_UID) { + // The system gets to run in any process. If there are multiple + // processes with the same uid, just pick the first (this + // should never happen). + SparseArray<ProcessRecord> procs = mProcessNames.getMap().get( + processName); + return procs != null ? procs.valueAt(0) : null; + } + ProcessRecord proc = mProcessNames.get(processName, uid); + return proc; + } + + private boolean isNextTransitionForward() { + int transit = mWindowManager.getPendingAppTransition(); + return transit == WindowManagerPolicy.TRANSIT_ACTIVITY_OPEN + || transit == WindowManagerPolicy.TRANSIT_TASK_OPEN + || transit == WindowManagerPolicy.TRANSIT_TASK_TO_FRONT; + } + + private final boolean realStartActivityLocked(HistoryRecord r, + ProcessRecord app, boolean andResume, boolean checkConfig) + throws RemoteException { + + r.startFreezingScreenLocked(app, 0); + mWindowManager.setAppVisibility(r, true); + + // Have the window manager re-evaluate the orientation of + // the screen based on the new activity order. Note that + // as a result of this, it can call back into the activity + // manager with a new orientation. We don't care about that, + // because the activity is not currently running so we are + // just restarting it anyway. + if (checkConfig) { + Configuration config = mWindowManager.updateOrientationFromAppTokens( + r.mayFreezeScreenLocked(app) ? r : null); + updateConfigurationLocked(config, r); + } + + r.app = app; + + if (localLOGV) Log.v(TAG, "Launching: " + r); + + int idx = app.activities.indexOf(r); + if (idx < 0) { + app.activities.add(r); + } + updateLRUListLocked(app, true); + + try { + if (app.thread == null) { + throw new RemoteException(); + } + List<ResultInfo> results = null; + List<Intent> newIntents = null; + if (andResume) { + results = r.results; + newIntents = r.newIntents; + } + if (DEBUG_SWITCH) Log.v(TAG, "Launching: " + r + + " icicle=" + r.icicle + + " with results=" + results + " newIntents=" + newIntents + + " andResume=" + andResume); + if (andResume) { + EventLog.writeEvent(LOG_AM_RESTART_ACTIVITY, + System.identityHashCode(r), + r.task.taskId, r.shortComponentName); + } + app.thread.scheduleLaunchActivity(new Intent(r.intent), r, + r.info, r.icicle, results, newIntents, !andResume, + isNextTransitionForward()); + // Update usage stats for launched activity + updateUsageStats(r, true); + } catch (RemoteException e) { + if (r.launchFailed) { + // This is the second time we failed -- finish activity + // and give up. + Log.e(TAG, "Second failure launching " + + r.intent.getComponent().flattenToShortString() + + ", giving up", e); + appDiedLocked(app, app.pid, app.thread); + requestFinishActivityLocked(r, Activity.RESULT_CANCELED, null, + "2nd-crash"); + return false; + } + + // This is the first time we failed -- restart process and + // retry. + app.activities.remove(r); + throw e; + } + + r.launchFailed = false; + if (updateLRUListLocked(r)) { + Log.w(TAG, "Activity " + r + + " being launched, but already in LRU list"); + } + + if (andResume) { + // As part of the process of launching, ActivityThread also performs + // a resume. + r.state = ActivityState.RESUMED; + r.icicle = null; + r.haveState = false; + r.stopped = false; + mResumedActivity = r; + r.task.touchActiveTime(); + completeResumeLocked(r); + pauseIfSleepingLocked(); + } else { + // This activity is not starting in the resumed state... which + // should look like we asked it to pause+stop (but remain visible), + // and it has done so and reported back the current icicle and + // other state. + r.state = ActivityState.STOPPED; + r.stopped = true; + } + + return true; + } + + private final void startSpecificActivityLocked(HistoryRecord r, + boolean andResume, boolean checkConfig) { + // Is this activity's application already running? + ProcessRecord app = getProcessRecordLocked(r.processName, + r.info.applicationInfo.uid); + + if (r.startTime == 0) { + r.startTime = SystemClock.uptimeMillis(); + } + + if (app != null && app.thread != null) { + try { + realStartActivityLocked(r, app, andResume, checkConfig); + return; + } catch (RemoteException e) { + Log.w(TAG, "Exception when starting activity " + + r.intent.getComponent().flattenToShortString(), e); + } + + // If a dead object exception was thrown -- fall through to + // restart the application. + } + + startProcessLocked(r.processName, r.info.applicationInfo, true, 0, + "activity", r.intent.getComponent()); + } + + private final ProcessRecord startProcessLocked(String processName, + ApplicationInfo info, boolean knownToBeDead, int intentFlags, + String hostingType, ComponentName hostingName) { + ProcessRecord app = getProcessRecordLocked(processName, info.uid); + // We don't have to do anything more if: + // (1) There is an existing application record; and + // (2) The caller doesn't think it is dead, OR there is no thread + // object attached to it so we know it couldn't have crashed; and + // (3) There is a pid assigned to it, so it is either starting or + // already running. + if (DEBUG_PROCESSES) Log.v(TAG, "startProcess: name=" + processName + + " app=" + app + " knownToBeDead=" + knownToBeDead + + " thread=" + (app != null ? app.thread : null) + + " pid=" + (app != null ? app.pid : -1)); + if (app != null && + (!knownToBeDead || app.thread == null) && app.pid > 0) { + return app; + } + + String hostingNameStr = hostingName != null + ? hostingName.flattenToShortString() : null; + + if ((intentFlags&Intent.FLAG_FROM_BACKGROUND) != 0) { + // If we are in the background, then check to see if this process + // is bad. If so, we will just silently fail. + if (mBadProcesses.get(info.processName, info.uid) != null) { + return null; + } + } else { + // When the user is explicitly starting a process, then clear its + // crash count so that we won't make it bad until they see at + // least one crash dialog again, and make the process good again + // if it had been bad. + mProcessCrashTimes.remove(info.processName, info.uid); + if (mBadProcesses.get(info.processName, info.uid) != null) { + EventLog.writeEvent(LOG_AM_PROCESS_GOOD, info.uid, + info.processName); + mBadProcesses.remove(info.processName, info.uid); + if (app != null) { + app.bad = false; + } + } + } + + if (app == null) { + app = newProcessRecordLocked(null, info, processName); + mProcessNames.put(processName, info.uid, app); + } else { + // If this is a new package in the process, add the package to the list + app.addPackage(info.packageName); + } + + // If the system is not ready yet, then hold off on starting this + // process until it is. + if (!mSystemReady + && (info.flags&ApplicationInfo.FLAG_PERSISTENT) == 0) { + if (!mProcessesOnHold.contains(app)) { + mProcessesOnHold.add(app); + } + return app; + } + + startProcessLocked(app, hostingType, hostingNameStr); + return (app.pid != 0) ? app : null; + } + + private final void startProcessLocked(ProcessRecord app, + String hostingType, String hostingNameStr) { + if (app.pid > 0 && app.pid != MY_PID) { + synchronized (mPidsSelfLocked) { + mPidsSelfLocked.remove(app.pid); + mHandler.removeMessages(PROC_START_TIMEOUT_MSG, app); + } + app.pid = 0; + } + + mProcessesOnHold.remove(app); + + updateCpuStats(); + + System.arraycopy(mProcDeaths, 0, mProcDeaths, 1, mProcDeaths.length-1); + mProcDeaths[0] = 0; + + try { + int uid = app.info.uid; + int[] gids = null; + try { + gids = mContext.getPackageManager().getPackageGids( + app.info.packageName); + } catch (PackageManager.NameNotFoundException e) { + Log.w(TAG, "Unable to retrieve gids", e); + } + if (mFactoryTest != SystemServer.FACTORY_TEST_OFF) { + if (mFactoryTest == SystemServer.FACTORY_TEST_LOW_LEVEL + && mTopComponent != null + && app.processName.equals(mTopComponent.getPackageName())) { + uid = 0; + } + if (mFactoryTest == SystemServer.FACTORY_TEST_HIGH_LEVEL + && (app.info.flags&ApplicationInfo.FLAG_FACTORY_TEST) != 0) { + uid = 0; + } + } + int debugFlags = 0; + if ((app.info.flags & ApplicationInfo.FLAG_DEBUGGABLE) != 0) { + debugFlags |= Zygote.DEBUG_ENABLE_DEBUGGER; + } + if ("1".equals(SystemProperties.get("debug.checkjni"))) { + debugFlags |= Zygote.DEBUG_ENABLE_CHECKJNI; + } + if ("1".equals(SystemProperties.get("debug.assert"))) { + debugFlags |= Zygote.DEBUG_ENABLE_ASSERT; + } + int pid = Process.start("android.app.ActivityThread", + mSimpleProcessManagement ? app.processName : null, uid, uid, + gids, debugFlags, null); + BatteryStatsImpl bs = app.batteryStats.getBatteryStats(); + synchronized (bs) { + if (bs.isOnBattery()) { + app.batteryStats.incStartsLocked(); + } + } + + EventLog.writeEvent(LOG_AM_PROCESS_START, pid, uid, + app.processName, hostingType, + hostingNameStr != null ? hostingNameStr : ""); + + if (app.persistent) { + Watchdog.getInstance().processStarted(app, app.processName, pid); + } + + StringBuilder buf = new StringBuilder(128); + buf.append("Start proc "); + buf.append(app.processName); + buf.append(" for "); + buf.append(hostingType); + if (hostingNameStr != null) { + buf.append(" "); + buf.append(hostingNameStr); + } + buf.append(": pid="); + buf.append(pid); + buf.append(" uid="); + buf.append(uid); + buf.append(" gids={"); + if (gids != null) { + for (int gi=0; gi<gids.length; gi++) { + if (gi != 0) buf.append(", "); + buf.append(gids[gi]); + + } + } + buf.append("}"); + Log.i(TAG, buf.toString()); + if (pid == 0 || pid == MY_PID) { + // Processes are being emulated with threads. + app.pid = MY_PID; + app.removed = false; + mStartingProcesses.add(app); + } else if (pid > 0) { + app.pid = pid; + app.removed = false; + synchronized (mPidsSelfLocked) { + this.mPidsSelfLocked.put(pid, app); + Message msg = mHandler.obtainMessage(PROC_START_TIMEOUT_MSG); + msg.obj = app; + mHandler.sendMessageDelayed(msg, PROC_START_TIMEOUT); + } + } else { + app.pid = 0; + RuntimeException e = new RuntimeException( + "Failure starting process " + app.processName + + ": returned pid=" + pid); + Log.e(TAG, e.getMessage(), e); + } + } catch (RuntimeException e) { + // XXX do better error recovery. + app.pid = 0; + Log.e(TAG, "Failure starting process " + app.processName, e); + } + } + + private final void startPausingLocked(boolean userLeaving, boolean uiSleeping) { + if (mPausingActivity != null) { + RuntimeException e = new RuntimeException(); + Log.e(TAG, "Trying to pause when pause is already pending for " + + mPausingActivity, e); + } + HistoryRecord prev = mResumedActivity; + if (prev == null) { + RuntimeException e = new RuntimeException(); + Log.e(TAG, "Trying to pause when nothing is resumed", e); + resumeTopActivityLocked(null); + return; + } + if (DEBUG_PAUSE) Log.v(TAG, "Start pausing: " + prev); + mResumedActivity = null; + mPausingActivity = prev; + mLastPausedActivity = prev; + prev.state = ActivityState.PAUSING; + prev.task.touchActiveTime(); + + updateCpuStats(); + + if (prev.app != null && prev.app.thread != null) { + if (DEBUG_PAUSE) Log.v(TAG, "Enqueueing pending pause: " + prev); + try { + EventLog.writeEvent(LOG_AM_PAUSE_ACTIVITY, + System.identityHashCode(prev), + prev.shortComponentName); + prev.app.thread.schedulePauseActivity(prev, prev.finishing, userLeaving, + prev.configChangeFlags); + updateUsageStats(prev, false); + } catch (Exception e) { + // Ignore exception, if process died other code will cleanup. + Log.w(TAG, "Exception thrown during pause", e); + mPausingActivity = null; + mLastPausedActivity = null; + } + } else { + mPausingActivity = null; + mLastPausedActivity = null; + } + + // If we are not going to sleep, we want to ensure the device is + // awake until the next activity is started. + if (!mSleeping) { + mLaunchingActivity.acquire(); + if (!mHandler.hasMessages(LAUNCH_TIMEOUT_MSG)) { + // To be safe, don't allow the wake lock to be held for too long. + Message msg = mHandler.obtainMessage(LAUNCH_TIMEOUT_MSG); + mHandler.sendMessageDelayed(msg, LAUNCH_TIMEOUT); + } + } + + + if (mPausingActivity != null) { + // Have the window manager pause its key dispatching until the new + // activity has started. If we're pausing the activity just because + // the screen is being turned off and the UI is sleeping, don't interrupt + // key dispatch; the same activity will pick it up again on wakeup. + if (!uiSleeping) { + prev.pauseKeyDispatchingLocked(); + } else { + if (DEBUG_PAUSE) Log.v(TAG, "Key dispatch not paused for screen off"); + } + + // Schedule a pause timeout in case the app doesn't respond. + // We don't give it much time because this directly impacts the + // responsiveness seen by the user. + Message msg = mHandler.obtainMessage(PAUSE_TIMEOUT_MSG); + msg.obj = prev; + mHandler.sendMessageDelayed(msg, PAUSE_TIMEOUT); + if (DEBUG_PAUSE) Log.v(TAG, "Waiting for pause to complete..."); + } else { + // This activity failed to schedule the + // pause, so just treat it as being paused now. + if (DEBUG_PAUSE) Log.v(TAG, "Activity not running, resuming next."); + resumeTopActivityLocked(null); + } + } + + private final void completePauseLocked() { + HistoryRecord prev = mPausingActivity; + if (DEBUG_PAUSE) Log.v(TAG, "Complete pause: " + prev); + + if (prev != null) { + if (prev.finishing) { + if (DEBUG_PAUSE) Log.v(TAG, "Executing finish of activity: " + prev); + prev = finishCurrentActivityLocked(prev, FINISH_AFTER_VISIBLE); + } else if (prev.app != null) { + if (DEBUG_PAUSE) Log.v(TAG, "Enqueueing pending stop: " + prev); + if (prev.waitingVisible) { + prev.waitingVisible = false; + mWaitingVisibleActivities.remove(prev); + if (DEBUG_SWITCH || DEBUG_PAUSE) Log.v( + TAG, "Complete pause, no longer waiting: " + prev); + } + if (prev.configDestroy) { + // The previous is being paused because the configuration + // is changing, which means it is actually stopping... + // To juggle the fact that we are also starting a new + // instance right now, we need to first completely stop + // the current instance before starting the new one. + if (DEBUG_PAUSE) Log.v(TAG, "Destroying after pause: " + prev); + destroyActivityLocked(prev, true); + } else { + mStoppingActivities.add(prev); + if (mStoppingActivities.size() > 3) { + // If we already have a few activities waiting to stop, + // then give up on things going idle and start clearing + // them out. + if (DEBUG_PAUSE) Log.v(TAG, "To many pending stops, forcing idle"); + Message msg = Message.obtain(); + msg.what = ActivityManagerService.IDLE_NOW_MSG; + mHandler.sendMessage(msg); + } + } + } else { + if (DEBUG_PAUSE) Log.v(TAG, "App died during pause, not stopping: " + prev); + prev = null; + } + mPausingActivity = null; + } + + if (!mSleeping) { + resumeTopActivityLocked(prev); + } else { + if (mGoingToSleep.isHeld()) { + mGoingToSleep.release(); + } + } + + if (prev != null) { + prev.resumeKeyDispatchingLocked(); + } + } + + /** + * Once we know that we have asked an application to put an activity in + * the resumed state (either by launching it or explicitly telling it), + * this function updates the rest of our state to match that fact. + */ + private final void completeResumeLocked(HistoryRecord next) { + next.idle = false; + next.results = null; + next.newIntents = null; + + // schedule an idle timeout in case the app doesn't do it for us. + Message msg = mHandler.obtainMessage(IDLE_TIMEOUT_MSG); + msg.obj = next; + mHandler.sendMessageDelayed(msg, IDLE_TIMEOUT); + + if (false) { + // The activity was never told to pause, so just keep + // things going as-is. To maintain our own state, + // we need to emulate it coming back and saying it is + // idle. + msg = mHandler.obtainMessage(IDLE_NOW_MSG); + msg.obj = next; + mHandler.sendMessage(msg); + } + + next.thumbnail = null; + setFocusedActivityLocked(next); + next.resumeKeyDispatchingLocked(); + ensureActivitiesVisibleLocked(null, 0); + mWindowManager.executeAppTransition(); + } + + /** + * Make sure that all activities that need to be visible (that is, they + * currently can be seen by the user) actually are. + */ + private final void ensureActivitiesVisibleLocked(HistoryRecord top, + HistoryRecord starting, String onlyThisProcess, int configChanges) { + if (DEBUG_VISBILITY) Log.v( + TAG, "ensureActivitiesVisible behind " + top + + " configChanges=0x" + Integer.toHexString(configChanges)); + + // If the top activity is not fullscreen, then we need to + // make sure any activities under it are now visible. + final int count = mHistory.size(); + int i = count-1; + while (mHistory.get(i) != top) { + i--; + } + HistoryRecord r; + boolean behindFullscreen = false; + for (; i>=0; i--) { + r = (HistoryRecord)mHistory.get(i); + if (DEBUG_VISBILITY) Log.v( + TAG, "Make visible? " + r + " finishing=" + r.finishing + + " state=" + r.state); + if (r.finishing) { + continue; + } + + final boolean doThisProcess = onlyThisProcess == null + || onlyThisProcess.equals(r.processName); + + // First: if this is not the current activity being started, make + // sure it matches the current configuration. + if (r != starting && doThisProcess) { + ensureActivityConfigurationLocked(r, 0); + } + + if (r.app == null || r.app.thread == null) { + if (onlyThisProcess == null + || onlyThisProcess.equals(r.processName)) { + // This activity needs to be visible, but isn't even + // running... get it started, but don't resume it + // at this point. + if (DEBUG_VISBILITY) Log.v( + TAG, "Start and freeze screen for " + r); + if (r != starting) { + r.startFreezingScreenLocked(r.app, configChanges); + } + if (!r.visible) { + if (DEBUG_VISBILITY) Log.v( + TAG, "Starting and making visible: " + r); + mWindowManager.setAppVisibility(r, true); + } + if (r != starting) { + startSpecificActivityLocked(r, false, false); + } + } + + } else if (r.visible) { + // If this activity is already visible, then there is nothing + // else to do here. + if (DEBUG_VISBILITY) Log.v( + TAG, "Skipping: already visible at " + r); + r.stopFreezingScreenLocked(false); + + } else if (onlyThisProcess == null) { + // This activity is not currently visible, but is running. + // Tell it to become visible. + r.visible = true; + if (r.state != ActivityState.RESUMED && r != starting) { + // If this activity is paused, tell it + // to now show its window. + if (DEBUG_VISBILITY) Log.v( + TAG, "Making visible and scheduling visibility: " + r); + try { + mWindowManager.setAppVisibility(r, true); + r.app.thread.scheduleWindowVisibility(r, true); + r.stopFreezingScreenLocked(false); + } catch (Exception e) { + // Just skip on any failure; we'll make it + // visible when it next restarts. + Log.w(TAG, "Exception thrown making visibile: " + + r.intent.getComponent(), e); + } + } + } + + // Aggregate current change flags. + configChanges |= r.configChangeFlags; + + if (r.fullscreen) { + // At this point, nothing else needs to be shown + if (DEBUG_VISBILITY) Log.v( + TAG, "Stopping: fullscreen at " + r); + behindFullscreen = true; + i--; + break; + } + } + + // Now for any activities that aren't visible to the user, make + // sure they no longer are keeping the screen frozen. + while (i >= 0) { + r = (HistoryRecord)mHistory.get(i); + if (DEBUG_VISBILITY) Log.v( + TAG, "Make invisible? " + r + " finishing=" + r.finishing + + " state=" + r.state + + " behindFullscreen=" + behindFullscreen); + if (!r.finishing) { + if (behindFullscreen) { + if (r.visible) { + if (DEBUG_VISBILITY) Log.v( + TAG, "Making invisible: " + r); + r.visible = false; + try { + mWindowManager.setAppVisibility(r, false); + if ((r.state == ActivityState.STOPPING + || r.state == ActivityState.STOPPED) + && r.app != null && r.app.thread != null) { + if (DEBUG_VISBILITY) Log.v( + TAG, "Scheduling invisibility: " + r); + r.app.thread.scheduleWindowVisibility(r, false); + } + } catch (Exception e) { + // Just skip on any failure; we'll make it + // visible when it next restarts. + Log.w(TAG, "Exception thrown making hidden: " + + r.intent.getComponent(), e); + } + } else { + if (DEBUG_VISBILITY) Log.v( + TAG, "Already invisible: " + r); + } + } else if (r.fullscreen) { + if (DEBUG_VISBILITY) Log.v( + TAG, "Now behindFullscreen: " + r); + behindFullscreen = true; + } + } + i--; + } + } + + /** + * Version of ensureActivitiesVisible that can easily be called anywhere. + */ + private final void ensureActivitiesVisibleLocked(HistoryRecord starting, + int configChanges) { + HistoryRecord r = topRunningActivityLocked(null); + if (r != null) { + ensureActivitiesVisibleLocked(r, starting, null, configChanges); + } + } + + private void updateUsageStats(HistoryRecord resumedComponent, boolean resumed) { + if (resumed) { + mUsageStatsService.noteResumeComponent(resumedComponent.realActivity); + } else { + mUsageStatsService.notePauseComponent(resumedComponent.realActivity); + } + } + + /** + * Ensure that the top activity in the stack is resumed. + * + * @param prev The previously resumed activity, for when in the process + * of pausing; can be null to call from elsewhere. + * + * @return Returns true if something is being resumed, or false if + * nothing happened. + */ + private final boolean resumeTopActivityLocked(HistoryRecord prev) { + // Find the first activity that is not finishing. + HistoryRecord next = topRunningActivityLocked(null); + + // Remember how we'll process this pause/resume situation, and ensure + // that the state is reset however we wind up proceeding. + final boolean userLeaving = mUserLeaving; + mUserLeaving = false; + + if (next == null) { + // There are no more activities! Let's just start up the + // Launcher... + if (mFactoryTest == SystemServer.FACTORY_TEST_LOW_LEVEL + && mTopAction == null) { + // We are running in factory test mode, but unable to find + // the factory test app, so just sit around displaying the + // error message and don't try to start anything. + return false; + } + Intent intent = new Intent( + mTopAction, + mTopData != null ? Uri.parse(mTopData) : null); + intent.setComponent(mTopComponent); + if (mFactoryTest != SystemServer.FACTORY_TEST_LOW_LEVEL) { + intent.addCategory(Intent.CATEGORY_HOME); + } + ActivityInfo aInfo = + intent.resolveActivityInfo(mContext.getPackageManager(), + PackageManager.GET_SHARED_LIBRARY_FILES); + if (aInfo != null) { + intent.setComponent(new ComponentName( + aInfo.applicationInfo.packageName, aInfo.name)); + // Don't do this if the home app is currently being + // instrumented. + ProcessRecord app = getProcessRecordLocked(aInfo.processName, + aInfo.applicationInfo.uid); + if (app == null || app.instrumentationClass == null) { + intent.setFlags(intent.getFlags() | Intent.FLAG_ACTIVITY_NEW_TASK); + startActivityLocked(null, intent, null, null, 0, aInfo, + null, null, 0, 0, 0, false); + } + } + return true; + } + + // If the top activity is the resumed one, nothing to do. + if (mResumedActivity == next && next.state == ActivityState.RESUMED) { + // Make sure we have executed any pending transitions, since there + // should be nothing left to do at this point. + mWindowManager.executeAppTransition(); + return false; + } + + // If we are sleeping, and there is no resumed activity, and the top + // activity is paused, well that is the state we want. + if (mSleeping && mLastPausedActivity == next && next.state == ActivityState.PAUSED) { + // Make sure we have executed any pending transitions, since there + // should be nothing left to do at this point. + mWindowManager.executeAppTransition(); + return false; + } + + // The activity may be waiting for stop, but that is no longer + // appropriate for it. + mStoppingActivities.remove(next); + mWaitingVisibleActivities.remove(next); + + if (DEBUG_SWITCH) Log.v(TAG, "Resuming " + next); + + // If we are currently pausing an activity, then don't do anything + // until that is done. + if (mPausingActivity != null) { + if (DEBUG_SWITCH) Log.v(TAG, "Skip resume: pausing=" + mPausingActivity); + return false; + } + + // We need to start pausing the current activity so the top one + // can be resumed... + if (mResumedActivity != null) { + if (DEBUG_SWITCH) Log.v(TAG, "Skip resume: need to start pausing"); + startPausingLocked(userLeaving, false); + return true; + } + + if (prev != null && prev != next) { + if (!prev.waitingVisible && next != null && !next.nowVisible) { + prev.waitingVisible = true; + mWaitingVisibleActivities.add(prev); + if (DEBUG_SWITCH) Log.v( + TAG, "Resuming top, waiting visible to hide: " + prev); + } else { + // The next activity is already visible, so hide the previous + // activity's windows right now so we can show the new one ASAP. + // We only do this if the previous is finishing, which should mean + // it is on top of the one being resumed so hiding it quickly + // is good. Otherwise, we want to do the normal route of allowing + // the resumed activity to be shown so we can decide if the + // previous should actually be hidden depending on whether the + // new one is found to be full-screen or not. + if (prev.finishing) { + mWindowManager.setAppVisibility(prev, false); + if (DEBUG_SWITCH) Log.v(TAG, "Not waiting for visible to hide: " + + prev + ", waitingVisible=" + + (prev != null ? prev.waitingVisible : null) + + ", nowVisible=" + next.nowVisible); + } else { + if (DEBUG_SWITCH) Log.v(TAG, "Previous already visible but still waiting to hide: " + + prev + ", waitingVisible=" + + (prev != null ? prev.waitingVisible : null) + + ", nowVisible=" + next.nowVisible); + } + } + } + + // We are starting up the next activity, so tell the window manager + // that the previous one will be hidden soon. This way it can know + // to ignore it when computing the desired screen orientation. + if (prev != null) { + if (prev.finishing) { + if (DEBUG_TRANSITION) Log.v(TAG, + "Prepare close transition: prev=" + prev); + mWindowManager.prepareAppTransition(prev.task == next.task + ? WindowManagerPolicy.TRANSIT_ACTIVITY_CLOSE + : WindowManagerPolicy.TRANSIT_TASK_CLOSE); + mWindowManager.setAppWillBeHidden(prev); + mWindowManager.setAppVisibility(prev, false); + } else { + if (DEBUG_TRANSITION) Log.v(TAG, + "Prepare open transition: prev=" + prev); + mWindowManager.prepareAppTransition(prev.task == next.task + ? WindowManagerPolicy.TRANSIT_ACTIVITY_OPEN + : WindowManagerPolicy.TRANSIT_TASK_OPEN); + } + if (false) { + mWindowManager.setAppWillBeHidden(prev); + mWindowManager.setAppVisibility(prev, false); + } + } else if (mHistory.size() > 1) { + if (DEBUG_TRANSITION) Log.v(TAG, + "Prepare open transition: no previous"); + mWindowManager.prepareAppTransition(WindowManagerPolicy.TRANSIT_ACTIVITY_OPEN); + } + + if (next.app != null && next.app.thread != null) { + if (DEBUG_SWITCH) Log.v(TAG, "Resume running: " + next); + + // This activity is now becoming visible. + mWindowManager.setAppVisibility(next, true); + + HistoryRecord lastResumedActivity = mResumedActivity; + ActivityState lastState = next.state; + + updateCpuStats(); + + next.state = ActivityState.RESUMED; + mResumedActivity = next; + next.task.touchActiveTime(); + updateLRUListLocked(next.app, true); + updateLRUListLocked(next); + + // Have the window manager re-evaluate the orientation of + // the screen based on the new activity order. + Configuration config = mWindowManager.updateOrientationFromAppTokens( + next.mayFreezeScreenLocked(next.app) ? next : null); + if (config != null) { + next.frozenBeforeDestroy = true; + } + if (!updateConfigurationLocked(config, next)) { + // The configuration update wasn't able to keep the existing + // instance of the activity, and instead started a new one. + // We should be all done, but let's just make sure our activity + // is still at the top and schedule another run if something + // weird happened. + HistoryRecord nextNext = topRunningActivityLocked(null); + if (DEBUG_SWITCH) Log.i(TAG, + "Activity config changed during resume: " + next + + ", new next: " + nextNext); + if (nextNext != next) { + // Do over! + mHandler.sendEmptyMessage(RESUME_TOP_ACTIVITY_MSG); + } + mWindowManager.executeAppTransition(); + return true; + } + + try { + // Deliver all pending results. + ArrayList a = next.results; + if (a != null) { + final int N = a.size(); + if (!next.finishing && N > 0) { + if (localLOGV) Log.v( + TAG, "Delivering results to " + next + + ": " + a); + next.app.thread.scheduleSendResult(next, a); + } + } + + if (next.newIntents != null) { + next.app.thread.scheduleNewIntent(next.newIntents, next); + } + + EventLog.writeEvent(LOG_AM_RESUME_ACTIVITY, + System.identityHashCode(next), + next.task.taskId, next.shortComponentName); + updateUsageStats(next, true); + + next.app.thread.scheduleResumeActivity(next, + isNextTransitionForward()); + pauseIfSleepingLocked(); + + } catch (Exception e) { + // Whoops, need to restart this activity! + next.state = lastState; + mResumedActivity = lastResumedActivity; + if (Config.LOGD) Log.d(TAG, + "Restarting because process died: " + next); + if (!next.hasBeenLaunched) { + next.hasBeenLaunched = true; + } else { + if (SHOW_APP_STARTING_ICON) { + mWindowManager.setAppStartingWindow( + next, next.packageName, next.theme, + next.nonLocalizedLabel, + next.labelRes, next.icon, null, true); + } + } + startSpecificActivityLocked(next, true, false); + return true; + } + + // From this point on, if something goes wrong there is no way + // to recover the activity. + try { + next.visible = true; + completeResumeLocked(next); + } catch (Exception e) { + // If any exception gets thrown, toss away this + // activity and try the next one. + Log.w(TAG, "Exception thrown during resume of " + next, e); + requestFinishActivityLocked(next, Activity.RESULT_CANCELED, null, + "resume-exception"); + return true; + } + + // Didn't need to use the icicle, and it is now out of date. + next.icicle = null; + next.haveState = false; + next.stopped = false; + + } else { + // Whoops, need to restart this activity! + if (!next.hasBeenLaunched) { + next.hasBeenLaunched = true; + } else { + if (SHOW_APP_STARTING_ICON) { + mWindowManager.setAppStartingWindow( + next, next.packageName, next.theme, + next.nonLocalizedLabel, + next.labelRes, next.icon, null, true); + } + if (DEBUG_SWITCH) Log.v(TAG, "Restarting: " + next); + } + startSpecificActivityLocked(next, true, true); + } + + return true; + } + + private final void startActivityLocked(HistoryRecord r, boolean newTask) { + final int NH = mHistory.size(); + + int addPos = -1; + + if (!newTask) { + // If starting in an existing task, find where that is... + HistoryRecord next = null; + boolean startIt = true; + for (int i = NH-1; i >= 0; i--) { + HistoryRecord p = (HistoryRecord)mHistory.get(i); + if (p.finishing) { + continue; + } + if (p.task == r.task) { + // Here it is! Now, if this is not yet visible to the + // user, then just add it without starting; it will + // get started when the user navigates back to it. + addPos = i+1; + if (!startIt) { + mHistory.add(addPos, r); + r.inHistory = true; + r.task.numActivities++; + mWindowManager.addAppToken(addPos, r, r.task.taskId, + r.info.screenOrientation, r.fullscreen); + if (VALIDATE_TOKENS) { + mWindowManager.validateAppTokens(mHistory); + } + return; + } + break; + } + if (p.fullscreen) { + startIt = false; + } + next = p; + } + } + + // Place a new activity at top of stack, so it is next to interact + // with the user. + if (addPos < 0) { + addPos = mHistory.size(); + } + + // If we are not placing the new activity frontmost, we do not want + // to deliver the onUserLeaving callback to the actual frontmost + // activity + if (addPos < NH) { + mUserLeaving = false; + if (DEBUG_USER_LEAVING) Log.v(TAG, "startActivity() behind front, mUserLeaving=false"); + } + + // Slot the activity into the history stack and proceed + mHistory.add(addPos, r); + r.inHistory = true; + r.frontOfTask = newTask; + r.task.numActivities++; + if (NH > 0) { + // We want to show the starting preview window if we are + // switching to a new task, or the next activity's process is + // not currently running. + boolean showStartingIcon = newTask; + ProcessRecord proc = r.app; + if (proc == null) { + proc = mProcessNames.get(r.processName, r.info.applicationInfo.uid); + } + if (proc == null || proc.thread == null) { + showStartingIcon = true; + } + if (DEBUG_TRANSITION) Log.v(TAG, + "Prepare open transition: starting " + r); + mWindowManager.prepareAppTransition(newTask + ? WindowManagerPolicy.TRANSIT_TASK_OPEN + : WindowManagerPolicy.TRANSIT_ACTIVITY_OPEN); + mWindowManager.addAppToken( + addPos, r, r.task.taskId, r.info.screenOrientation, r.fullscreen); + boolean doShow = true; + if (newTask) { + // Even though this activity is starting fresh, we still need + // to reset it to make sure we apply affinities to move any + // existing activities from other tasks in to it. + // If the caller has requested that the target task be + // reset, then do so. + if ((r.intent.getFlags() + &Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED) != 0) { + resetTaskIfNeededLocked(r, r); + doShow = topRunningActivityLocked(null) == r; + } + } + if (SHOW_APP_STARTING_ICON && doShow) { + // Figure out if we are transitioning from another activity that is + // "has the same starting icon" as the next one. This allows the + // window manager to keep the previous window it had previously + // created, if it still had one. + HistoryRecord prev = mResumedActivity; + if (prev != null) { + // We don't want to reuse the previous starting preview if: + // (1) The current activity is in a different task. + if (prev.task != r.task) prev = null; + // (2) The current activity is already displayed. + else if (prev.nowVisible) prev = null; + } + mWindowManager.setAppStartingWindow( + r, r.packageName, r.theme, r.nonLocalizedLabel, + r.labelRes, r.icon, prev, showStartingIcon); + } + } else { + // If this is the first activity, don't do any fancy animations, + // because there is nothing for it to animate on top of. + mWindowManager.addAppToken(addPos, r, r.task.taskId, + r.info.screenOrientation, r.fullscreen); + } + if (VALIDATE_TOKENS) { + mWindowManager.validateAppTokens(mHistory); + } + + resumeTopActivityLocked(null); + } + + /** + * Perform clear operation as requested by + * {@link Intent#FLAG_ACTIVITY_CLEAR_TOP}: assuming the top task on the + * stack is the one that the new activity is being launched in, look for + * an instance of that activity in the stack and, if found, finish all + * activities on top of it and return the instance. + * + * @param newR Description of the new activity being started. + * @return Returns the old activity that should be continue to be used, + * or null if none was found. + */ + private final HistoryRecord performClearTopTaskLocked(int taskId, + HistoryRecord newR, boolean doClear) { + int i = mHistory.size(); + while (i > 0) { + i--; + HistoryRecord r = (HistoryRecord)mHistory.get(i); + if (r.finishing) { + continue; + } + if (r.task.taskId != taskId) { + return null; + } + if (r.realActivity.equals(newR.realActivity)) { + // Here it is! Now finish everything in front... + HistoryRecord ret = r; + if (doClear) { + while (i < (mHistory.size()-1)) { + i++; + r = (HistoryRecord)mHistory.get(i); + if (r.finishing) { + continue; + } + if (finishActivityLocked(r, i, Activity.RESULT_CANCELED, + null, "clear")) { + i--; + } + } + } + + // Finally, if this is a normal launch mode (that is, not + // expecting onNewIntent()), then we will finish the current + // instance of the activity so a new fresh one can be started. + if (ret.launchMode == ActivityInfo.LAUNCH_MULTIPLE) { + if (!ret.finishing) { + int index = indexOfTokenLocked(ret, false); + if (index >= 0) { + finishActivityLocked(ret, 0, Activity.RESULT_CANCELED, + null, "clear"); + } + return null; + } + } + + return ret; + } + } + + return null; + } + + /** + * Find the activity in the history stack within the given task. Returns + * the index within the history at which it's found, or < 0 if not found. + */ + private final int findActivityInHistoryLocked(HistoryRecord r, int task) { + int i = mHistory.size(); + while (i > 0) { + i--; + HistoryRecord candidate = (HistoryRecord)mHistory.get(i); + if (candidate.task.taskId != task) { + break; + } + if (candidate.realActivity.equals(r.realActivity)) { + return i; + } + } + + return -1; + } + + /** + * Reorder the history stack so that the activity at the given index is + * brought to the front. + */ + private final HistoryRecord moveActivityToFrontLocked(int where) { + HistoryRecord newTop = (HistoryRecord)mHistory.remove(where); + int top = mHistory.size(); + HistoryRecord oldTop = (HistoryRecord)mHistory.get(top-1); + mHistory.add(top, newTop); + oldTop.frontOfTask = false; + newTop.frontOfTask = true; + return newTop; + } + + /** + * Deliver a new Intent to an existing activity, so that its onNewIntent() + * method will be called at the proper time. + */ + private final void deliverNewIntentLocked(HistoryRecord r, Intent intent) { + boolean sent = false; + if (r.state == ActivityState.RESUMED + && r.app != null && r.app.thread != null) { + try { + ArrayList<Intent> ar = new ArrayList<Intent>(); + ar.add(new Intent(intent)); + r.app.thread.scheduleNewIntent(ar, r); + sent = true; + } catch (Exception e) { + Log.w(TAG, "Exception thrown sending new intent to " + r, e); + } + } + if (!sent) { + r.addNewIntentLocked(new Intent(intent)); + } + } + + private final void logStartActivity(int tag, HistoryRecord r, + TaskRecord task) { + EventLog.writeEvent(tag, + System.identityHashCode(r), task.taskId, + r.shortComponentName, r.intent.getAction(), + r.intent.getType(), r.intent.getDataString(), + r.intent.getFlags()); + } + + private final int startActivityLocked(IApplicationThread caller, + Intent intent, String resolvedType, + Uri[] grantedUriPermissions, + int grantedMode, ActivityInfo aInfo, IBinder resultTo, + String resultWho, int requestCode, + int callingPid, int callingUid, boolean onlyIfNeeded) { + Log.i(TAG, "Starting activity: " + intent); + + HistoryRecord sourceRecord = null; + HistoryRecord resultRecord = null; + if (resultTo != null) { + int index = indexOfTokenLocked(resultTo, false); + if (localLOGV) Log.v( + TAG, "Sending result to " + resultTo + " (index " + index + ")"); + if (index >= 0) { + sourceRecord = (HistoryRecord)mHistory.get(index); + if (requestCode >= 0 && !sourceRecord.finishing) { + resultRecord = sourceRecord; + } + } + } + + int launchFlags = intent.getFlags(); + + if ((launchFlags&Intent.FLAG_ACTIVITY_FORWARD_RESULT) != 0 + && sourceRecord != null) { + // Transfer the result target from the source activity to the new + // one being started, including any failures. + if (requestCode >= 0) { + return START_FORWARD_AND_REQUEST_CONFLICT; + } + resultRecord = sourceRecord.resultTo; + resultWho = sourceRecord.resultWho; + requestCode = sourceRecord.requestCode; + sourceRecord.resultTo = null; + if (resultRecord != null) { + resultRecord.removeResultsLocked( + sourceRecord, resultWho, requestCode); + } + } + + int err = START_SUCCESS; + + if (intent.getComponent() == null) { + // We couldn't find a class that can handle the given Intent. + // That's the end of that! + err = START_INTENT_NOT_RESOLVED; + } + + if (err == START_SUCCESS && aInfo == null) { + // We couldn't find the specific class specified in the Intent. + // Also the end of the line. + err = START_CLASS_NOT_FOUND; + } + + ProcessRecord callerApp = null; + if (err == START_SUCCESS && caller != null) { + callerApp = getRecordForAppLocked(caller); + if (callerApp != null) { + callingPid = callerApp.pid; + callingUid = callerApp.info.uid; + } else { + Log.w(TAG, "Unable to find app for caller " + caller + + " (pid=" + callingPid + ") when starting: " + + intent.toString()); + err = START_PERMISSION_DENIED; + } + } + + if (err != START_SUCCESS) { + if (resultRecord != null) { + sendActivityResultLocked(-1, + resultRecord, resultWho, requestCode, + Activity.RESULT_CANCELED, null); + } + return err; + } + + final int perm = checkComponentPermission(aInfo.permission, callingPid, + callingUid, aInfo.exported ? -1 : aInfo.applicationInfo.uid); + if (perm != PackageManager.PERMISSION_GRANTED) { + if (resultRecord != null) { + sendActivityResultLocked(-1, + resultRecord, resultWho, requestCode, + Activity.RESULT_CANCELED, null); + } + String msg = "Permission Denial: starting " + intent.toString() + + " from " + callerApp + " (pid=" + callingPid + + ", uid=" + callingUid + ")" + + " requires " + aInfo.permission; + Log.w(TAG, msg); + throw new SecurityException(msg); + } + + if (mWatcher != null) { + boolean abort = false; + try { + // The Intent we give to the watcher has the extra data + // stripped off, since it can contain private information. + Intent watchIntent = intent.cloneFilter(); + abort = !mWatcher.activityStarting(watchIntent, + aInfo.applicationInfo.packageName); + } catch (RemoteException e) { + mWatcher = null; + } + + if (abort) { + if (resultRecord != null) { + sendActivityResultLocked(-1, + resultRecord, resultWho, requestCode, + Activity.RESULT_CANCELED, null); + } + // We pretend to the caller that it was really started, but + // they will just get a cancel result. + return START_SUCCESS; + } + } + + HistoryRecord r = new HistoryRecord(this, callerApp, callingUid, + intent, resolvedType, aInfo, mConfiguration, + resultRecord, resultWho, requestCode); + r.startTime = SystemClock.uptimeMillis(); + + HistoryRecord notTop = (launchFlags&Intent.FLAG_ACTIVITY_PREVIOUS_IS_TOP) + != 0 ? r : null; + + // We'll invoke onUserLeaving before onPause only if the launching + // activity did not explicitly state that this is an automated launch. + mUserLeaving = (launchFlags&Intent.FLAG_ACTIVITY_NO_USER_ACTION) == 0; + if (DEBUG_USER_LEAVING) Log.v(TAG, + "startActivity() => mUserLeaving=" + mUserLeaving); + + // If the onlyIfNeeded flag is set, then we can do this if the activity + // being launched is the same as the one making the call... or, as + // a special case, if we do not know the caller then we count the + // current top activity as the caller. + if (onlyIfNeeded) { + HistoryRecord checkedCaller = sourceRecord; + if (checkedCaller == null) { + checkedCaller = topRunningActivityLocked(notTop); + } + if (!checkedCaller.realActivity.equals(r.realActivity)) { + // Caller is not the same as launcher, so always needed. + onlyIfNeeded = false; + } + } + + if (grantedUriPermissions != null && callingUid > 0) { + for (int i=0; i<grantedUriPermissions.length; i++) { + grantUriPermissionLocked(callingUid, r.packageName, + grantedUriPermissions[i], grantedMode, r); + } + } + + grantUriPermissionFromIntentLocked(callingUid, r.packageName, + intent, r); + + if (sourceRecord == null) { + // This activity is not being started from another... in this + // case we -always- start a new task. + if ((launchFlags&Intent.FLAG_ACTIVITY_NEW_TASK) == 0) { + Log.w(TAG, "startActivity called from non-Activity context; forcing Intent.FLAG_ACTIVITY_NEW_TASK for: " + + intent); + launchFlags |= Intent.FLAG_ACTIVITY_NEW_TASK; + } + } else if (sourceRecord.launchMode == ActivityInfo.LAUNCH_SINGLE_INSTANCE) { + // The original activity who is starting us is running as a single + // instance... this new activity it is starting must go on its + // own task. + launchFlags |= Intent.FLAG_ACTIVITY_NEW_TASK; + } else if (r.launchMode == ActivityInfo.LAUNCH_SINGLE_INSTANCE + || r.launchMode == ActivityInfo.LAUNCH_SINGLE_TASK) { + // The activity being started is a single instance... it always + // gets launched into its own task. + launchFlags |= Intent.FLAG_ACTIVITY_NEW_TASK; + } + + if (resultRecord != null && (launchFlags&Intent.FLAG_ACTIVITY_NEW_TASK) != 0) { + // For whatever reason this activity is being launched into a new + // task... yet the caller has requested a result back. Well, that + // is pretty messed up, so instead immediately send back a cancel + // and let the new task continue launched as normal without a + // dependency on its originator. + Log.w(TAG, "Activity is launching as a new task, so cancelling activity result."); + sendActivityResultLocked(-1, + resultRecord, resultWho, requestCode, + Activity.RESULT_CANCELED, null); + r.resultTo = null; + resultRecord = null; + } + + boolean addingToTask = false; + if (((launchFlags&Intent.FLAG_ACTIVITY_NEW_TASK) != 0 && + (launchFlags&Intent.FLAG_ACTIVITY_MULTIPLE_TASK) == 0) + || r.launchMode == ActivityInfo.LAUNCH_SINGLE_TASK + || r.launchMode == ActivityInfo.LAUNCH_SINGLE_INSTANCE) { + // If bring to front is requested, and no result is requested, and + // we can find a task that was started with this same + // component, then instead of launching bring that one to the front. + if (resultRecord == null) { + // See if there is a task to bring to the front. If this is + // a SINGLE_INSTANCE activity, there can be one and only one + // instance of it in the history, and it is always in its own + // unique task, so we do a special search. + HistoryRecord taskTop = r.launchMode != ActivityInfo.LAUNCH_SINGLE_INSTANCE + ? findTaskLocked(intent, r.info) + : findActivityLocked(intent, r.info); + if (taskTop != null) { + if (taskTop.task.intent == null) { + // This task was started because of movement of + // the activity based on affinity... now that we + // are actually launching it, we can assign the + // base intent. + taskTop.task.setIntent(intent, r.info); + } + // If the target task is not in the front, then we need + // to bring it to the front... except... well, with + // SINGLE_TASK_LAUNCH it's not entirely clear. We'd like + // to have the same behavior as if a new instance was + // being started, which means not bringing it to the front + // if the caller is not itself in the front. + HistoryRecord curTop = topRunningActivityLocked(notTop); + if (curTop.task != taskTop.task) { + r.intent.addFlags(Intent.FLAG_ACTIVITY_BROUGHT_TO_FRONT); + boolean callerAtFront = sourceRecord == null + || curTop.task == sourceRecord.task; + if (callerAtFront) { + // We really do want to push this one into the + // user's face, right now. + moveTaskToFrontLocked(taskTop.task); + } + } + // If the caller has requested that the target task be + // reset, then do so. + if ((launchFlags&Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED) != 0) { + taskTop = resetTaskIfNeededLocked(taskTop, r); + } + if (onlyIfNeeded) { + // We don't need to start a new activity, and + // the client said not to do anything if that + // is the case, so this is it! And for paranoia, make + // sure we have correctly resumed the top activity. + resumeTopActivityLocked(null); + return START_RETURN_INTENT_TO_CALLER; + } + if ((launchFlags&Intent.FLAG_ACTIVITY_CLEAR_TOP) != 0 + || r.launchMode == ActivityInfo.LAUNCH_SINGLE_TASK + || r.launchMode == ActivityInfo.LAUNCH_SINGLE_INSTANCE) { + // In this situation we want to remove all activities + // from the task up to the one being started. In most + // cases this means we are resetting the task to its + // initial state. + HistoryRecord top = performClearTopTaskLocked( + taskTop.task.taskId, r, true); + if (top != null) { + if (top.frontOfTask) { + // Activity aliases may mean we use different + // intents for the top activity, so make sure + // the task now has the identity of the new + // intent. + top.task.setIntent(r.intent, r.info); + } + logStartActivity(LOG_AM_NEW_INTENT, r, top.task); + deliverNewIntentLocked(top, r.intent); + } else { + // A special case: we need to + // start the activity because it is not currently + // running, and the caller has asked to clear the + // current task to have this activity at the top. + addingToTask = true; + // Now pretend like this activity is being started + // by the top of its task, so it is put in the + // right place. + sourceRecord = taskTop; + } + } else if (r.realActivity.equals(taskTop.task.realActivity)) { + // In this case the top activity on the task is the + // same as the one being launched, so we take that + // as a request to bring the task to the foreground. + // If the top activity in the task is the root + // activity, deliver this new intent to it if it + // desires. + if ((launchFlags&Intent.FLAG_ACTIVITY_SINGLE_TOP) != 0 + && taskTop.realActivity.equals(r.realActivity)) { + logStartActivity(LOG_AM_NEW_INTENT, r, taskTop.task); + if (taskTop.frontOfTask) { + taskTop.task.setIntent(r.intent, r.info); + } + deliverNewIntentLocked(taskTop, r.intent); + } else if (!r.intent.filterEquals(taskTop.task.intent)) { + // In this case we are launching the root activity + // of the task, but with a different intent. We + // should start a new instance on top. + addingToTask = true; + sourceRecord = taskTop; + } + } else if ((launchFlags&Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED) == 0) { + // In this case an activity is being launched in to an + // existing task, without resetting that task. This + // is typically the situation of launching an activity + // from a notification or shortcut. We want to place + // the new activity on top of the current task. + addingToTask = true; + sourceRecord = taskTop; + } else if (!taskTop.task.rootWasReset) { + // In this case we are launching in to an existing task + // that has not yet been started from its front door. + // The current task has been brought to the front. + // Ideally, we'd probably like to place this new task + // at the bottom of its stack, but that's a little hard + // to do with the current organization of the code so + // for now we'll just drop it. + taskTop.task.setIntent(r.intent, r.info); + } + if (!addingToTask) { + // We didn't do anything... but it was needed (a.k.a., client + // don't use that intent!) And for paranoia, make + // sure we have correctly resumed the top activity. + resumeTopActivityLocked(null); + return START_TASK_TO_FRONT; + } + } + } + } + + //String uri = r.intent.toURI(); + //Intent intent2 = new Intent(uri); + //Log.i(TAG, "Given intent: " + r.intent); + //Log.i(TAG, "URI is: " + uri); + //Log.i(TAG, "To intent: " + intent2); + + if (r.packageName != null) { + // If the activity being launched is the same as the one currently + // at the top, then we need to check if it should only be launched + // once. + HistoryRecord top = topRunningActivityLocked(notTop); + if (top != null && resultRecord == null) { + if (top.realActivity.equals(r.realActivity)) { + if (top.app != null && top.app.thread != null) { + if ((launchFlags&Intent.FLAG_ACTIVITY_SINGLE_TOP) != 0 + || r.launchMode == ActivityInfo.LAUNCH_SINGLE_TOP + || r.launchMode == ActivityInfo.LAUNCH_SINGLE_TASK) { + logStartActivity(LOG_AM_NEW_INTENT, top, top.task); + // For paranoia, make sure we have correctly + // resumed the top activity. + resumeTopActivityLocked(null); + if (onlyIfNeeded) { + // We don't need to start a new activity, and + // the client said not to do anything if that + // is the case, so this is it! + return START_RETURN_INTENT_TO_CALLER; + } + deliverNewIntentLocked(top, r.intent); + return START_DELIVERED_TO_TOP; + } + } + } + } + + } else { + if (resultRecord != null) { + sendActivityResultLocked(-1, + resultRecord, resultWho, requestCode, + Activity.RESULT_CANCELED, null); + } + return START_CLASS_NOT_FOUND; + } + + boolean newTask = false; + + // Should this be considered a new task? + if (resultRecord == null && !addingToTask + && (launchFlags&Intent.FLAG_ACTIVITY_NEW_TASK) != 0) { + // todo: should do better management of integers. + mCurTask++; + if (mCurTask <= 0) { + mCurTask = 1; + } + r.task = new TaskRecord(mCurTask, r.info, intent, + (r.info.flags&ActivityInfo.FLAG_CLEAR_TASK_ON_LAUNCH) != 0); + if (DEBUG_TASKS) Log.v(TAG, "Starting new activity " + r + + " in new task " + r.task); + newTask = true; + addRecentTask(r.task); + + } else if (sourceRecord != null) { + if (!addingToTask && + (launchFlags&Intent.FLAG_ACTIVITY_CLEAR_TOP) != 0) { + // In this case, we are adding the activity to an existing + // task, but the caller has asked to clear that task if the + // activity is already running. + HistoryRecord top = performClearTopTaskLocked( + sourceRecord.task.taskId, r, true); + if (top != null) { + logStartActivity(LOG_AM_NEW_INTENT, r, top.task); + deliverNewIntentLocked(top, r.intent); + // For paranoia, make sure we have correctly + // resumed the top activity. + resumeTopActivityLocked(null); + return START_DELIVERED_TO_TOP; + } + } else if (!addingToTask && + (launchFlags&Intent.FLAG_ACTIVITY_REORDER_TO_FRONT) != 0) { + // In this case, we are launching an activity in our own task + // that may already be running somewhere in the history, and + // we want to shuffle it to the front of the stack if so. + int where = findActivityInHistoryLocked(r, sourceRecord.task.taskId); + if (where >= 0) { + HistoryRecord top = moveActivityToFrontLocked(where); + logStartActivity(LOG_AM_NEW_INTENT, r, top.task); + deliverNewIntentLocked(top, r.intent); + resumeTopActivityLocked(null); + return START_DELIVERED_TO_TOP; + } + } + // An existing activity is starting this new activity, so we want + // to keep the new one in the same task as the one that is starting + // it. + r.task = sourceRecord.task; + if (DEBUG_TASKS) Log.v(TAG, "Starting new activity " + r + + " in existing task " + r.task); + + } else { + // This not being started from an existing activity, and not part + // of a new task... just put it in the top task, though these days + // this case should never happen. + final int N = mHistory.size(); + HistoryRecord prev = + N > 0 ? (HistoryRecord)mHistory.get(N-1) : null; + r.task = prev != null + ? prev.task + : new TaskRecord(mCurTask, r.info, intent, + (r.info.flags&ActivityInfo.FLAG_CLEAR_TASK_ON_LAUNCH) != 0); + if (DEBUG_TASKS) Log.v(TAG, "Starting new activity " + r + + " in new guessed " + r.task); + } + if (newTask) { + EventLog.writeEvent(LOG_AM_CREATE_TASK, r.task.taskId); + } + logStartActivity(LOG_AM_CREATE_ACTIVITY, r, r.task); + startActivityLocked(r, newTask); + return START_SUCCESS; + } + + public final int startActivity(IApplicationThread caller, + Intent intent, String resolvedType, Uri[] grantedUriPermissions, + int grantedMode, IBinder resultTo, + String resultWho, int requestCode, boolean onlyIfNeeded, + boolean debug) { + // Refuse possible leaked file descriptors + if (intent != null && intent.hasFileDescriptors()) { + throw new IllegalArgumentException("File descriptors passed in Intent"); + } + + // Don't modify the client's object! + intent = new Intent(intent); + + // Collect information about the target of the Intent. + // Must do this before locking, because resolving the intent + // may require launching a process to run its content provider. + ActivityInfo aInfo; + try { + ResolveInfo rInfo = + ActivityThread.getPackageManager().resolveIntent( + intent, resolvedType, + PackageManager.MATCH_DEFAULT_ONLY + | PackageManager.GET_SHARED_LIBRARY_FILES); + aInfo = rInfo != null ? rInfo.activityInfo : null; + } catch (RemoteException e) { + aInfo = null; + } + + if (aInfo != null) { + // Store the found target back into the intent, because now that + // we have it we never want to do this again. For example, if the + // user navigates back to this point in the history, we should + // always restart the exact same activity. + intent.setComponent(new ComponentName( + aInfo.applicationInfo.packageName, aInfo.name)); + + // Don't debug things in the system process + if (debug) { + if (!aInfo.processName.equals("system")) { + setDebugApp(aInfo.processName, true, false); + } + } + } + + synchronized(this) { + final long origId = Binder.clearCallingIdentity(); + int res = startActivityLocked(caller, intent, resolvedType, + grantedUriPermissions, grantedMode, aInfo, + resultTo, resultWho, requestCode, -1, -1, + onlyIfNeeded); + Binder.restoreCallingIdentity(origId); + return res; + } + } + + public boolean startNextMatchingActivity(IBinder callingActivity, + Intent intent) { + // Refuse possible leaked file descriptors + if (intent != null && intent.hasFileDescriptors() == true) { + throw new IllegalArgumentException("File descriptors passed in Intent"); + } + + synchronized (this) { + int index = indexOfTokenLocked(callingActivity, false); + if (index < 0) { + return false; + } + HistoryRecord r = (HistoryRecord)mHistory.get(index); + if (r.app == null || r.app.thread == null) { + // The caller is not running... d'oh! + return false; + } + intent = new Intent(intent); + // The caller is not allowed to change the data. + intent.setDataAndType(r.intent.getData(), r.intent.getType()); + // And we are resetting to find the next component... + intent.setComponent(null); + + ActivityInfo aInfo = null; + try { + List<ResolveInfo> resolves = + ActivityThread.getPackageManager().queryIntentActivities( + intent, r.resolvedType, + PackageManager.MATCH_DEFAULT_ONLY + | PackageManager.GET_SHARED_LIBRARY_FILES); + + // Look for the original activity in the list... + final int N = resolves != null ? resolves.size() : 0; + for (int i=0; i<N; i++) { + ResolveInfo rInfo = resolves.get(i); + if (rInfo.activityInfo.packageName.equals(r.packageName) + && rInfo.activityInfo.name.equals(r.info.name)) { + // We found the current one... the next matching is + // after it. + i++; + if (i<N) { + aInfo = resolves.get(i).activityInfo; + } + break; + } + } + } catch (RemoteException e) { + } + + if (aInfo == null) { + // Nobody who is next! + return false; + } + + intent.setComponent(new ComponentName( + aInfo.applicationInfo.packageName, aInfo.name)); + intent.setFlags(intent.getFlags()&~( + Intent.FLAG_ACTIVITY_FORWARD_RESULT| + Intent.FLAG_ACTIVITY_CLEAR_TOP| + Intent.FLAG_ACTIVITY_MULTIPLE_TASK| + Intent.FLAG_ACTIVITY_NEW_TASK)); + + // Okay now we need to start the new activity, replacing the + // currently running activity. This is a little tricky because + // we want to start the new one as if the current one is finished, + // but not finish the current one first so that there is no flicker. + // And thus... + final boolean wasFinishing = r.finishing; + r.finishing = true; + + // Propagate reply information over to the new activity. + final HistoryRecord resultTo = r.resultTo; + final String resultWho = r.resultWho; + final int requestCode = r.requestCode; + r.resultTo = null; + if (resultTo != null) { + resultTo.removeResultsLocked(r, resultWho, requestCode); + } + + final long origId = Binder.clearCallingIdentity(); + // XXX we are not dealing with propagating grantedUriPermissions... + // those are not yet exposed to user code, so there is no need. + int res = startActivityLocked(r.app.thread, intent, + r.resolvedType, null, 0, aInfo, resultTo, resultWho, + requestCode, -1, r.launchedFromUid, false); + Binder.restoreCallingIdentity(origId); + + r.finishing = wasFinishing; + if (res != START_SUCCESS) { + return false; + } + return true; + } + } + + final int startActivityInPackage(int uid, + Intent intent, String resolvedType, IBinder resultTo, + String resultWho, int requestCode, boolean onlyIfNeeded) { + // Don't modify the client's object! + intent = new Intent(intent); + + // Collect information about the target of the Intent. + // Must do this before locking, because resolving the intent + // may require launching a process to run its content provider. + ActivityInfo aInfo; + try { + ResolveInfo rInfo = + ActivityThread.getPackageManager().resolveIntent( + intent, resolvedType, + PackageManager.MATCH_DEFAULT_ONLY + | PackageManager.GET_SHARED_LIBRARY_FILES); + aInfo = rInfo != null ? rInfo.activityInfo : null; + } catch (RemoteException e) { + aInfo = null; + } + + if (aInfo != null) { + // Store the found target back into the intent, because now that + // we have it we never want to do this again. For example, if the + // user navigates back to this point in the history, we should + // always restart the exact same activity. + intent.setComponent(new ComponentName( + aInfo.applicationInfo.packageName, aInfo.name)); + } + + synchronized(this) { + return startActivityLocked(null, intent, resolvedType, + null, 0, aInfo, resultTo, resultWho, requestCode, -1, uid, + onlyIfNeeded); + } + } + + private final void addRecentTask(TaskRecord task) { + // Remove any existing entries that are the same kind of task. + int N = mRecentTasks.size(); + for (int i=0; i<N; i++) { + TaskRecord tr = mRecentTasks.get(i); + if ((task.affinity != null && task.affinity.equals(tr.affinity)) + || (task.intent != null && task.intent.filterEquals(tr.intent))) { + mRecentTasks.remove(i); + i--; + N--; + if (task.intent == null) { + // If the new recent task we are adding is not fully + // specified, then replace it with the existing recent task. + task = tr; + } + } + } + if (N >= MAX_RECENT_TASKS) { + mRecentTasks.remove(N-1); + } + mRecentTasks.add(0, task); + } + + public void setRequestedOrientation(IBinder token, + int requestedOrientation) { + synchronized (this) { + int index = indexOfTokenLocked(token, false); + if (index < 0) { + return; + } + HistoryRecord r = (HistoryRecord)mHistory.get(index); + final long origId = Binder.clearCallingIdentity(); + mWindowManager.setAppOrientation(r, requestedOrientation); + Configuration config = mWindowManager.updateOrientationFromAppTokens( + r.mayFreezeScreenLocked(r.app) ? r : null); + if (config != null) { + r.frozenBeforeDestroy = true; + if (!updateConfigurationLocked(config, r)) { + resumeTopActivityLocked(null); + } + } + Binder.restoreCallingIdentity(origId); + } + } + + public int getRequestedOrientation(IBinder token) { + synchronized (this) { + int index = indexOfTokenLocked(token, false); + if (index < 0) { + return ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED; + } + HistoryRecord r = (HistoryRecord)mHistory.get(index); + return mWindowManager.getAppOrientation(r); + } + } + + private final void stopActivityLocked(HistoryRecord r) { + if (DEBUG_SWITCH) Log.d(TAG, "Stopping: " + r); + if ((r.intent.getFlags()&Intent.FLAG_ACTIVITY_NO_HISTORY) != 0 + || (r.info.flags&ActivityInfo.FLAG_NO_HISTORY) != 0) { + if (!r.finishing) { + requestFinishActivityLocked(r, Activity.RESULT_CANCELED, null, + "no-history"); + } + } else if (r.app != null && r.app.thread != null) { + if (mFocusedActivity == r) { + setFocusedActivityLocked(topRunningActivityLocked(null)); + } + r.resumeKeyDispatchingLocked(); + try { + r.stopped = false; + r.state = ActivityState.STOPPING; + if (DEBUG_VISBILITY) Log.v( + TAG, "Stopping visible=" + r.visible + " for " + r); + if (!r.visible) { + mWindowManager.setAppVisibility(r, false); + } + r.app.thread.scheduleStopActivity(r, r.visible, r.configChangeFlags); + } catch (Exception e) { + // Maybe just ignore exceptions here... if the process + // has crashed, our death notification will clean things + // up. + Log.w(TAG, "Exception thrown during pause", e); + // Just in case, assume it to be stopped. + r.stopped = true; + r.state = ActivityState.STOPPED; + if (r.configDestroy) { + destroyActivityLocked(r, true); + } + } + } + } + + /** + * @return Returns true if the activity is being finished, false if for + * some reason it is being left as-is. + */ + private final boolean requestFinishActivityLocked(IBinder token, int resultCode, + Intent resultData, String reason) { + if (localLOGV) Log.v( + TAG, "Finishing activity: token=" + token + + ", result=" + resultCode + ", data=" + resultData); + + int index = indexOfTokenLocked(token, false); + if (index < 0) { + return false; + } + HistoryRecord r = (HistoryRecord)mHistory.get(index); + + // Is this the last activity left? + boolean lastActivity = true; + for (int i=mHistory.size()-1; i>=0; i--) { + HistoryRecord p = (HistoryRecord)mHistory.get(i); + if (!p.finishing && p != r) { + lastActivity = false; + break; + } + } + + // If this is the last activity, but it is the home activity, then + // just don't finish it. + if (lastActivity) { + if (r.intent.hasCategory(Intent.CATEGORY_HOME)) { + return false; + } + } + + finishActivityLocked(r, index, resultCode, resultData, reason); + return true; + } + + /** + * @return Returns true if this activity has been removed from the history + * list, or false if it is still in the list and will be removed later. + */ + private final boolean finishActivityLocked(HistoryRecord r, int index, + int resultCode, Intent resultData, String reason) { + if (r.finishing) { + Log.w(TAG, "Duplicate finish request for " + r); + return false; + } + + r.finishing = true; + EventLog.writeEvent(LOG_AM_FINISH_ACTIVITY, + System.identityHashCode(r), + r.task.taskId, r.shortComponentName, reason); + r.task.numActivities--; + if (r.frontOfTask && index < (mHistory.size()-1)) { + HistoryRecord next = (HistoryRecord)mHistory.get(index+1); + if (next.task == r.task) { + next.frontOfTask = true; + } + } + + r.pauseKeyDispatchingLocked(); + if (mFocusedActivity == r) { + setFocusedActivityLocked(topRunningActivityLocked(null)); + } + + // send the result + HistoryRecord resultTo = r.resultTo; + if (resultTo != null) { + if (localLOGV) Log.v(TAG, "Adding result to " + resultTo); + if (r.info.applicationInfo.uid > 0) { + grantUriPermissionFromIntentLocked(r.info.applicationInfo.uid, + r.packageName, resultData, r); + } + resultTo.addResultLocked(r, r.resultWho, r.requestCode, resultCode, + resultData); + r.resultTo = null; + } + + // Make sure this HistoryRecord is not holding on to other resources, + // because clients have remote IPC references to this object so we + // can't assume that will go away and want to avoid circular IPC refs. + r.results = null; + r.pendingResults = null; + r.newIntents = null; + r.icicle = null; + + if (mPendingThumbnails.size() > 0) { + // There are clients waiting to receive thumbnails so, in case + // this is an activity that someone is waiting for, add it + // to the pending list so we can correctly update the clients. + mCancelledThumbnails.add(r); + } + + if (mResumedActivity == r) { + boolean endTask = index <= 0 + || ((HistoryRecord)mHistory.get(index-1)).task != r.task; + if (DEBUG_TRANSITION) Log.v(TAG, + "Prepare close transition: finishing " + r); + mWindowManager.prepareAppTransition(endTask + ? WindowManagerPolicy.TRANSIT_TASK_CLOSE + : WindowManagerPolicy.TRANSIT_ACTIVITY_CLOSE); + + // Tell window manager to prepare for this one to be removed. + mWindowManager.setAppVisibility(r, false); + + if (mPausingActivity == null) { + if (DEBUG_PAUSE) Log.v(TAG, "Finish needs to pause: " + r); + if (DEBUG_USER_LEAVING) Log.v(TAG, "finish() => pause with userLeaving=false"); + startPausingLocked(false, false); + } + + } else if (r.state != ActivityState.PAUSING) { + // If the activity is PAUSING, we will complete the finish once + // it is done pausing; else we can just directly finish it here. + if (DEBUG_PAUSE) Log.v(TAG, "Finish not pausing: " + r); + return finishCurrentActivityLocked(r, index, + FINISH_AFTER_PAUSE) == null; + } else { + if (DEBUG_PAUSE) Log.v(TAG, "Finish waiting for pause of: " + r); + } + + return false; + } + + private static final int FINISH_IMMEDIATELY = 0; + private static final int FINISH_AFTER_PAUSE = 1; + private static final int FINISH_AFTER_VISIBLE = 2; + + private final HistoryRecord finishCurrentActivityLocked(HistoryRecord r, + int mode) { + final int index = indexOfTokenLocked(r, false); + if (index < 0) { + return null; + } + + return finishCurrentActivityLocked(r, index, mode); + } + + private final HistoryRecord finishCurrentActivityLocked(HistoryRecord r, + int index, int mode) { + // First things first: if this activity is currently visible, + // and the resumed activity is not yet visible, then hold off on + // finishing until the resumed one becomes visible. + if (mode == FINISH_AFTER_VISIBLE && r.nowVisible) { + if (!mStoppingActivities.contains(r)) { + mStoppingActivities.add(r); + if (mStoppingActivities.size() > 3) { + // If we already have a few activities waiting to stop, + // then give up on things going idle and start clearing + // them out. + Message msg = Message.obtain(); + msg.what = ActivityManagerService.IDLE_NOW_MSG; + mHandler.sendMessage(msg); + } + } + r.state = ActivityState.STOPPING; + updateOomAdjLocked(); + return r; + } + + // make sure the record is cleaned out of other places. + mStoppingActivities.remove(r); + mWaitingVisibleActivities.remove(r); + if (mResumedActivity == r) { + mResumedActivity = null; + } + final ActivityState prevState = r.state; + r.state = ActivityState.FINISHING; + + if (mode == FINISH_IMMEDIATELY + || prevState == ActivityState.STOPPED + || prevState == ActivityState.INITIALIZING) { + // If this activity is already stopped, we can just finish + // it right now. + return destroyActivityLocked(r, true) ? null : r; + } else { + // Need to go through the full pause cycle to get this + // activity into the stopped state and then finish it. + if (localLOGV) Log.v(TAG, "Enqueueing pending finish: " + r); + mFinishingActivities.add(r); + resumeTopActivityLocked(null); + } + return r; + } + + /** + * This is the internal entry point for handling Activity.finish(). + * + * @param token The Binder token referencing the Activity we want to finish. + * @param resultCode Result code, if any, from this Activity. + * @param resultData Result data (Intent), if any, from this Activity. + * + * @result Returns true if the activity successfully finished, or false if it is still running. + */ + public final boolean finishActivity(IBinder token, int resultCode, Intent resultData) { + // Refuse possible leaked file descriptors + if (resultData != null && resultData.hasFileDescriptors() == true) { + throw new IllegalArgumentException("File descriptors passed in Intent"); + } + + synchronized(this) { + if (mWatcher != null) { + // Find the first activity that is not finishing. + HistoryRecord next = topRunningActivityLocked(token, 0); + if (next != null) { + // ask watcher if this is allowed + boolean resumeOK = true; + try { + resumeOK = mWatcher.activityResuming(next.packageName); + } catch (RemoteException e) { + mWatcher = null; + } + + if (!resumeOK) { + return false; + } + } + } + final long origId = Binder.clearCallingIdentity(); + boolean res = requestFinishActivityLocked(token, resultCode, + resultData, "app-request"); + Binder.restoreCallingIdentity(origId); + return res; + } + } + + void sendActivityResultLocked(int callingUid, HistoryRecord r, + String resultWho, int requestCode, int resultCode, Intent data) { + + if (callingUid > 0) { + grantUriPermissionFromIntentLocked(callingUid, r.packageName, + data, r); + } + + if (mResumedActivity == r && r.app != null && r.app.thread != null) { + try { + ArrayList<ResultInfo> list = new ArrayList<ResultInfo>(); + list.add(new ResultInfo(resultWho, requestCode, + resultCode, data)); + r.app.thread.scheduleSendResult(r, list); + return; + } catch (Exception e) { + Log.w(TAG, "Exception thrown sending result to " + r, e); + } + } + + r.addResultLocked(null, resultWho, requestCode, resultCode, data); + } + + public final void finishSubActivity(IBinder token, String resultWho, + int requestCode) { + synchronized(this) { + int index = indexOfTokenLocked(token, false); + if (index < 0) { + return; + } + HistoryRecord self = (HistoryRecord)mHistory.get(index); + + final long origId = Binder.clearCallingIdentity(); + + int i; + for (i=mHistory.size()-1; i>=0; i--) { + HistoryRecord r = (HistoryRecord)mHistory.get(i); + if (r.resultTo == self && r.requestCode == requestCode) { + if ((r.resultWho == null && resultWho == null) || + (r.resultWho != null && r.resultWho.equals(resultWho))) { + finishActivityLocked(r, i, + Activity.RESULT_CANCELED, null, "request-sub"); + } + } + } + + Binder.restoreCallingIdentity(origId); + } + } + + /** + * Perform clean-up of service connections in an activity record. + */ + private final void cleanUpActivityServicesLocked(HistoryRecord r) { + // Throw away any services that have been bound by this activity. + if (r.connections != null) { + Iterator<ConnectionRecord> it = r.connections.iterator(); + while (it.hasNext()) { + ConnectionRecord c = it.next(); + removeConnectionLocked(c, null, r); + } + r.connections = null; + } + } + + /** + * Perform the common clean-up of an activity record. This is called both + * as part of destroyActivityLocked() (when destroying the client-side + * representation) and cleaning things up as a result of its hosting + * processing going away, in which case there is no remaining client-side + * state to destroy so only the cleanup here is needed. + */ + private final void cleanUpActivityLocked(HistoryRecord r, boolean cleanServices) { + if (mResumedActivity == r) { + mResumedActivity = null; + } + if (mFocusedActivity == r) { + mFocusedActivity = null; + } + + r.configDestroy = false; + r.frozenBeforeDestroy = false; + + // Make sure this record is no longer in the pending finishes list. + // This could happen, for example, if we are trimming activities + // down to the max limit while they are still waiting to finish. + mFinishingActivities.remove(r); + mWaitingVisibleActivities.remove(r); + + // Remove any pending results. + if (r.finishing && r.pendingResults != null) { + for (WeakReference<PendingIntentRecord> apr : r.pendingResults) { + PendingIntentRecord rec = apr.get(); + if (rec != null) { + cancelIntentSenderLocked(rec, false); + } + } + r.pendingResults = null; + } + + if (cleanServices) { + cleanUpActivityServicesLocked(r); + } + + if (mPendingThumbnails.size() > 0) { + // There are clients waiting to receive thumbnails so, in case + // this is an activity that someone is waiting for, add it + // to the pending list so we can correctly update the clients. + mCancelledThumbnails.add(r); + } + + // Get rid of any pending idle timeouts. + mHandler.removeMessages(PAUSE_TIMEOUT_MSG, r); + mHandler.removeMessages(IDLE_TIMEOUT_MSG, r); + } + + private final void removeActivityFromHistoryLocked(HistoryRecord r) { + if (r.state != ActivityState.DESTROYED) { + mHistory.remove(r); + r.inHistory = false; + r.state = ActivityState.DESTROYED; + mWindowManager.removeAppToken(r); + if (VALIDATE_TOKENS) { + mWindowManager.validateAppTokens(mHistory); + } + cleanUpActivityServicesLocked(r); + removeActivityUriPermissionsLocked(r); + } + } + + /** + * Destroy the current CLIENT SIDE instance of an activity. This may be + * called both when actually finishing an activity, or when performing + * a configuration switch where we destroy the current client-side object + * but then create a new client-side object for this same HistoryRecord. + */ + private final boolean destroyActivityLocked(HistoryRecord r, + boolean removeFromApp) { + if (DEBUG_SWITCH) Log.v( + TAG, "Removing activity: token=" + r + + ", app=" + (r.app != null ? r.app.processName : "(null)")); + EventLog.writeEvent(LOG_AM_DESTROY_ACTIVITY, + System.identityHashCode(r), + r.task.taskId, r.shortComponentName); + + boolean removedFromHistory = false; + + cleanUpActivityLocked(r, false); + + if (r.app != null) { + if (removeFromApp) { + int idx = r.app.activities.indexOf(r); + if (idx >= 0) { + r.app.activities.remove(idx); + } + if (r.persistent) { + decPersistentCountLocked(r.app); + } + } + + boolean skipDestroy = false; + + try { + if (DEBUG_SWITCH) Log.i(TAG, "Destroying: " + r); + r.app.thread.scheduleDestroyActivity(r, r.finishing, + r.configChangeFlags); + } catch (Exception e) { + // We can just ignore exceptions here... if the process + // has crashed, our death notification will clean things + // up. + //Log.w(TAG, "Exception thrown during finish", e); + if (r.finishing) { + removeActivityFromHistoryLocked(r); + removedFromHistory = true; + skipDestroy = true; + } + } + + r.app = null; + r.nowVisible = false; + + if (r.finishing && !skipDestroy) { + r.state = ActivityState.DESTROYING; + Message msg = mHandler.obtainMessage(DESTROY_TIMEOUT_MSG); + msg.obj = r; + mHandler.sendMessageDelayed(msg, DESTROY_TIMEOUT); + } else { + r.state = ActivityState.DESTROYED; + } + } else { + // remove this record from the history. + if (r.finishing) { + removeActivityFromHistoryLocked(r); + removedFromHistory = true; + } else { + r.state = ActivityState.DESTROYED; + } + } + + r.configChangeFlags = 0; + + if (!mLRUActivities.remove(r)) { + Log.w(TAG, "Activity " + r + " being finished, but not in LRU list"); + } + + return removedFromHistory; + } + + private static void removeHistoryRecordsForAppLocked(ArrayList list, + ProcessRecord app) + { + int i = list.size(); + if (localLOGV) Log.v( + TAG, "Removing app " + app + " from list " + list + + " with " + i + " entries"); + while (i > 0) { + i--; + HistoryRecord r = (HistoryRecord)list.get(i); + if (localLOGV) Log.v( + TAG, "Record #" + i + " " + r + ": app=" + r.app); + if (r.app == app) { + if (localLOGV) Log.v(TAG, "Removing this entry!"); + list.remove(i); + } + } + } + + /** + * Main function for removing an existing process from the activity manager + * as a result of that process going away. Clears out all connections + * to the process. + */ + private final void handleAppDiedLocked(ProcessRecord app, + boolean restarting) { + cleanUpApplicationRecordLocked(app, restarting, -1); + if (!restarting) { + mLRUProcesses.remove(app); + } + + // Just in case... + if (mPausingActivity != null && mPausingActivity.app == app) { + if (DEBUG_PAUSE) Log.v(TAG, "App died while pausing: " + mPausingActivity); + mPausingActivity = null; + } + if (mLastPausedActivity != null && mLastPausedActivity.app == app) { + mLastPausedActivity = null; + } + + // Remove this application's activities from active lists. + removeHistoryRecordsForAppLocked(mLRUActivities, app); + removeHistoryRecordsForAppLocked(mStoppingActivities, app); + removeHistoryRecordsForAppLocked(mWaitingVisibleActivities, app); + removeHistoryRecordsForAppLocked(mFinishingActivities, app); + + boolean atTop = true; + boolean hasVisibleActivities = false; + + // Clean out the history list. + int i = mHistory.size(); + if (localLOGV) Log.v( + TAG, "Removing app " + app + " from history with " + i + " entries"); + while (i > 0) { + i--; + HistoryRecord r = (HistoryRecord)mHistory.get(i); + if (localLOGV) Log.v( + TAG, "Record #" + i + " " + r + ": app=" + r.app); + if (r.app == app) { + if ((!r.haveState && !r.stateNotNeeded) || r.finishing) { + if (localLOGV) Log.v( + TAG, "Removing this entry! frozen=" + r.haveState + + " finishing=" + r.finishing); + mHistory.remove(i); + + r.inHistory = false; + mWindowManager.removeAppToken(r); + if (VALIDATE_TOKENS) { + mWindowManager.validateAppTokens(mHistory); + } + removeActivityUriPermissionsLocked(r); + + } else { + // We have the current state for this activity, so + // it can be restarted later when needed. + if (localLOGV) Log.v( + TAG, "Keeping entry, setting app to null"); + if (r.visible) { + hasVisibleActivities = true; + } + r.app = null; + r.nowVisible = false; + if (!r.haveState) { + r.icicle = null; + } + } + + cleanUpActivityLocked(r, true); + r.state = ActivityState.STOPPED; + } + atTop = false; + } + + app.activities.clear(); + + if (app.instrumentationClass != null) { + Log.w(TAG, "Crash of app " + app.processName + + " running instrumentation " + app.instrumentationClass); + Bundle info = new Bundle(); + info.putString("shortMsg", "Process crashed."); + finishInstrumentationLocked(app, Activity.RESULT_CANCELED, info); + } + + if (!restarting) { + if (!resumeTopActivityLocked(null)) { + // If there was nothing to resume, and we are not already + // restarting this process, but there is a visible activity that + // is hosted by the process... then make sure all visible + // activities are running, taking care of restarting this + // process. + if (hasVisibleActivities) { + ensureActivitiesVisibleLocked(null, 0); + } + } + } + } + + private final int getLRURecordIndexForAppLocked(IApplicationThread thread) { + IBinder threadBinder = thread.asBinder(); + + // Find the application record. + int count = mLRUProcesses.size(); + int i; + for (i=0; i<count; i++) { + ProcessRecord rec = mLRUProcesses.get(i); + if (rec.thread != null && rec.thread.asBinder() == threadBinder) { + return i; + } + } + return -1; + } + + private final ProcessRecord getRecordForAppLocked( + IApplicationThread thread) { + if (thread == null) { + return null; + } + + int appIndex = getLRURecordIndexForAppLocked(thread); + return appIndex >= 0 ? mLRUProcesses.get(appIndex) : null; + } + + private final void appDiedLocked(ProcessRecord app, int pid, + IApplicationThread thread) { + + mProcDeaths[0]++; + + if (app.thread != null && app.thread.asBinder() == thread.asBinder()) { + Log.i(TAG, "Process " + app.processName + " (pid " + pid + + ") has died."); + EventLog.writeEvent(LOG_AM_PROCESS_DIED, app.pid, app.processName); + if (localLOGV) Log.v( + TAG, "Dying app: " + app + ", pid: " + pid + + ", thread: " + thread.asBinder()); + boolean doLowMem = app.instrumentationClass == null; + handleAppDiedLocked(app, false); + + if (doLowMem) { + // If there are no longer any background processes running, + // and the app that died was not running instrumentation, + // then tell everyone we are now low on memory. + boolean haveBg = false; + int count = mLRUProcesses.size(); + int i; + for (i=0; i<count; i++) { + ProcessRecord rec = mLRUProcesses.get(i); + if (rec.thread != null && rec.setAdj >= HIDDEN_APP_MIN_ADJ) { + haveBg = true; + break; + } + } + + if (!haveBg) { + Log.i(TAG, "Low Memory: No more background processes."); + EventLog.writeEvent(LOG_AM_LOW_MEMORY, mLRUProcesses.size()); + for (i=0; i<count; i++) { + ProcessRecord rec = mLRUProcesses.get(i); + if (rec.thread != null) { + rec.lastRequestedGc = SystemClock.uptimeMillis(); + try { + rec.thread.scheduleLowMemory(); + } catch (RemoteException e) { + // Don't care if the process is gone. + } + } + } + } + } + } else if (Config.LOGD) { + Log.d(TAG, "Received spurious death notification for thread " + + thread.asBinder()); + } + } + + final String readFile(String filename) { + try { + FileInputStream fs = new FileInputStream(filename); + byte[] inp = new byte[8192]; + int size = fs.read(inp); + fs.close(); + return new String(inp, 0, 0, size); + } catch (java.io.IOException e) { + } + return ""; + } + + final void appNotRespondingLocked(ProcessRecord app, HistoryRecord activity, + final String annotation) { + if (app.notResponding || app.crashing) { + return; + } + + // Log the ANR to the event log. + EventLog.writeEvent(LOG_ANR, app.pid, app.processName, annotation); + + // If we are on a secure build and the application is not interesting to the user (it is + // not visible or in the background), just kill it instead of displaying a dialog. + boolean isSecure = "1".equals(SystemProperties.get(SYSTEM_SECURE, "0")); + if (isSecure && !app.isInterestingToUserLocked() && Process.myPid() != app.pid) { + Process.killProcess(app.pid); + return; + } + + // DeviceMonitor.start(); + + String processInfo = null; + if (MONITOR_CPU_USAGE) { + updateCpuStatsNow(); + synchronized (mProcessStatsThread) { + processInfo = mProcessStats.printCurrentState(); + } + } + + StringBuilder info = new StringBuilder(); + info.append("ANR (application not responding) in process: "); + info.append(app.processName); + if (annotation != null) { + info.append("\nAnnotation: "); + info.append(annotation); + } + if (MONITOR_CPU_USAGE) { + info.append("\nCPU usage:\n"); + info.append(processInfo); + } + Log.i(TAG, info.toString()); + + // The application is not responding. Dump as many thread traces as we can. + boolean fileDump = prepareTraceFile(true); + if (!fileDump) { + // Dumping traces to the log, just dump the process that isn't responding so + // we don't overflow the log + Process.sendSignal(app.pid, Process.SIGNAL_QUIT); + } else { + // Dumping traces to a file so dump all active processes we know about + synchronized (this) { + for (int i = mLRUProcesses.size() - 1 ; i >= 0 ; i--) { + ProcessRecord r = mLRUProcesses.get(i); + if (r.thread != null) { + Process.sendSignal(r.pid, Process.SIGNAL_QUIT); + } + } + } + } + + if (mWatcher != null) { + try { + int res = mWatcher.appNotResponding(app.processName, + app.pid, info.toString()); + if (res != 0) { + if (res < 0) { + // wait until the SIGQUIT has had a chance to process before killing the + // process. + try { + wait(2000); + } catch (InterruptedException e) { + } + + Process.killProcess(app.pid); + return; + } + } + } catch (RemoteException e) { + mWatcher = null; + } + } + + makeAppNotRespondingLocked(app, + activity != null ? activity.shortComponentName : null, + annotation != null ? "ANR " + annotation : "ANR", + info.toString(), null); + Message msg = Message.obtain(); + HashMap map = new HashMap(); + msg.what = SHOW_NOT_RESPONDING_MSG; + msg.obj = map; + map.put("app", app); + if (activity != null) { + map.put("activity", activity); + } + + mHandler.sendMessage(msg); + return; + } + + /** + * If a stack trace file has been configured, prepare the filesystem + * by creating the directory if it doesn't exist and optionally + * removing the old trace file. + * + * @param removeExisting If set, the existing trace file will be removed. + * @return Returns true if the trace file preparations succeeded + */ + public static boolean prepareTraceFile(boolean removeExisting) { + String tracesPath = SystemProperties.get("dalvik.vm.stack-trace-file", null); + boolean fileReady = false; + if (!TextUtils.isEmpty(tracesPath)) { + File f = new File(tracesPath); + if (!f.exists()) { + // Ensure the enclosing directory exists + File dir = f.getParentFile(); + if (!dir.exists()) { + fileReady = dir.mkdirs(); + FileUtils.setPermissions(dir.getAbsolutePath(), + FileUtils.S_IRWXU | FileUtils.S_IRWXG | FileUtils.S_IRWXO, -1, -1); + } else if (dir.isDirectory()) { + fileReady = true; + } + } else if (removeExisting) { + // Remove the previous traces file, so we don't fill the disk. + // The VM will recreate it + Log.i(TAG, "Removing old ANR trace file from " + tracesPath); + fileReady = f.delete(); + } + } + + return fileReady; + } + + + private final void decPersistentCountLocked(ProcessRecord app) + { + app.persistentActivities--; + if (app.persistentActivities > 0) { + // Still more of 'em... + return; + } + if (app.persistent) { + // Ah, but the application itself is persistent. Whatever! + return; + } + + // App is no longer persistent... make sure it and the ones + // following it in the LRU list have the correc oom_adj. + updateOomAdjLocked(); + } + + public void setPersistent(IBinder token, boolean isPersistent) { + if (checkCallingPermission(android.Manifest.permission.PERSISTENT_ACTIVITY) + != PackageManager.PERMISSION_GRANTED) { + String msg = "Permission Denial: setPersistent() from pid=" + + Binder.getCallingPid() + + ", uid=" + Binder.getCallingUid() + + " requires " + android.Manifest.permission.PERSISTENT_ACTIVITY; + Log.w(TAG, msg); + throw new SecurityException(msg); + } + + synchronized(this) { + int index = indexOfTokenLocked(token, true); + if (index < 0) { + return; + } + HistoryRecord r = (HistoryRecord)mHistory.get(index); + ProcessRecord app = r.app; + + if (localLOGV) Log.v( + TAG, "Setting persistence " + isPersistent + ": " + r); + + if (isPersistent) { + if (r.persistent) { + // Okay okay, I heard you already! + if (localLOGV) Log.v(TAG, "Already persistent!"); + return; + } + r.persistent = true; + app.persistentActivities++; + if (localLOGV) Log.v(TAG, "Num persistent now: " + app.persistentActivities); + if (app.persistentActivities > 1) { + // We aren't the first... + if (localLOGV) Log.v(TAG, "Not the first!"); + return; + } + if (app.persistent) { + // This would be redundant. + if (localLOGV) Log.v(TAG, "App is persistent!"); + return; + } + + // App is now persistent... make sure it and the ones + // following it now have the correct oom_adj. + final long origId = Binder.clearCallingIdentity(); + updateOomAdjLocked(); + Binder.restoreCallingIdentity(origId); + + } else { + if (!r.persistent) { + // Okay okay, I heard you already! + return; + } + r.persistent = false; + final long origId = Binder.clearCallingIdentity(); + decPersistentCountLocked(app); + Binder.restoreCallingIdentity(origId); + + } + } + } + + public boolean clearApplicationUserData(final String packageName, + final IPackageDataObserver observer) { + int uid = Binder.getCallingUid(); + int pid = Binder.getCallingPid(); + long callingId = Binder.clearCallingIdentity(); + try { + IPackageManager pm = ActivityThread.getPackageManager(); + int pkgUid = -1; + synchronized(this) { + try { + pkgUid = pm.getPackageUid(packageName); + } catch (RemoteException e) { + } + if (pkgUid == -1) { + Log.w(TAG, "Invalid packageName:" + packageName); + return false; + } + if (uid == pkgUid || checkComponentPermission( + android.Manifest.permission.CLEAR_APP_USER_DATA, + pid, uid, -1) + == PackageManager.PERMISSION_GRANTED) { + restartPackageLocked(packageName, pkgUid); + } else { + throw new SecurityException(pid+" does not have permission:"+ + android.Manifest.permission.CLEAR_APP_USER_DATA+" to clear data" + + "for process:"+packageName); + } + } + + try { + //clear application user data + pm.clearApplicationUserData(packageName, observer); + Intent intent = new Intent(Intent.ACTION_PACKAGE_DATA_CLEARED, + Uri.fromParts("package", packageName, null)); + intent.putExtra(Intent.EXTRA_UID, pkgUid); + broadcastIntentLocked(null, null, intent, + null, null, 0, null, null, null, + false, false, MY_PID, Process.SYSTEM_UID); + } catch (RemoteException e) { + } + } finally { + Binder.restoreCallingIdentity(callingId); + } + return true; + } + + public void restartPackage(final String packageName) { + if (checkCallingPermission(android.Manifest.permission.RESTART_PACKAGES) + != PackageManager.PERMISSION_GRANTED) { + String msg = "Permission Denial: restartPackage() from pid=" + + Binder.getCallingPid() + + ", uid=" + Binder.getCallingUid() + + " requires " + android.Manifest.permission.RESTART_PACKAGES; + Log.w(TAG, msg); + throw new SecurityException(msg); + } + + long callingId = Binder.clearCallingIdentity(); + try { + IPackageManager pm = ActivityThread.getPackageManager(); + int pkgUid = -1; + synchronized(this) { + try { + pkgUid = pm.getPackageUid(packageName); + } catch (RemoteException e) { + } + if (pkgUid == -1) { + Log.w(TAG, "Invalid packageName: " + packageName); + return; + } + restartPackageLocked(packageName, pkgUid); + } + } finally { + Binder.restoreCallingIdentity(callingId); + } + } + + private void restartPackageLocked(final String packageName, int uid) { + uninstallPackageLocked(packageName, uid, false); + Intent intent = new Intent(Intent.ACTION_PACKAGE_RESTARTED, + Uri.fromParts("package", packageName, null)); + intent.putExtra(Intent.EXTRA_UID, uid); + broadcastIntentLocked(null, null, intent, + null, null, 0, null, null, null, + false, false, MY_PID, Process.SYSTEM_UID); + } + + private final void uninstallPackageLocked(String name, int uid, + boolean callerWillRestart) { + if (Config.LOGD) Log.d(TAG, "Uninstalling process " + name); + + int i, N; + + final String procNamePrefix = name + ":"; + if (uid < 0) { + try { + uid = ActivityThread.getPackageManager().getPackageUid(name); + } catch (RemoteException e) { + } + } + + Iterator<SparseArray<Long>> badApps = mProcessCrashTimes.getMap().values().iterator(); + while (badApps.hasNext()) { + SparseArray<Long> ba = badApps.next(); + if (ba.get(uid) != null) { + badApps.remove(); + } + } + + ArrayList<ProcessRecord> procs = new ArrayList<ProcessRecord>(); + + // Remove all processes this package may have touched: all with the + // same UID (except for the system or root user), and all whose name + // matches the package name. + for (SparseArray<ProcessRecord> apps : mProcessNames.getMap().values()) { + final int NA = apps.size(); + for (int ia=0; ia<NA; ia++) { + ProcessRecord app = apps.valueAt(ia); + if (app.removed) { + procs.add(app); + } else if ((uid > 0 && uid != Process.SYSTEM_UID && app.info.uid == uid) + || app.processName.equals(name) + || app.processName.startsWith(procNamePrefix)) { + app.removed = true; + procs.add(app); + } + } + } + + N = procs.size(); + for (i=0; i<N; i++) { + removeProcessLocked(procs.get(i), callerWillRestart); + } + + for (i=mHistory.size()-1; i>=0; i--) { + HistoryRecord r = (HistoryRecord)mHistory.get(i); + if (r.packageName.equals(name)) { + if (Config.LOGD) Log.d( + TAG, " Force finishing activity " + + r.intent.getComponent().flattenToShortString()); + if (r.app != null) { + r.app.removed = true; + } + r.app = null; + finishActivityLocked(r, i, Activity.RESULT_CANCELED, null, "uninstall"); + } + } + + ArrayList<ServiceRecord> services = new ArrayList<ServiceRecord>(); + for (ServiceRecord service : mServices.values()) { + if (service.packageName.equals(name)) { + if (service.app != null) { + service.app.removed = true; + } + service.app = null; + services.add(service); + } + } + + N = services.size(); + for (i=0; i<N; i++) { + bringDownServiceLocked(services.get(i), true); + } + + resumeTopActivityLocked(null); + } + + private final boolean removeProcessLocked(ProcessRecord app, boolean callerWillRestart) { + final String name = app.processName; + final int uid = app.info.uid; + if (Config.LOGD) Log.d( + TAG, "Force removing process " + app + " (" + name + + "/" + uid + ")"); + + mProcessNames.remove(name, uid); + boolean needRestart = false; + if (app.pid > 0 && app.pid != MY_PID) { + int pid = app.pid; + synchronized (mPidsSelfLocked) { + mPidsSelfLocked.remove(pid); + mHandler.removeMessages(PROC_START_TIMEOUT_MSG, app); + } + handleAppDiedLocked(app, true); + mLRUProcesses.remove(app); + Process.killProcess(pid); + + if (app.persistent) { + if (!callerWillRestart) { + addAppLocked(app.info); + } else { + needRestart = true; + } + } + } else { + mRemovedProcesses.add(app); + } + + return needRestart; + } + + private final void processStartTimedOutLocked(ProcessRecord app) { + final int pid = app.pid; + boolean gone = false; + synchronized (mPidsSelfLocked) { + ProcessRecord knownApp = mPidsSelfLocked.get(pid); + if (knownApp != null && knownApp.thread == null) { + mPidsSelfLocked.remove(pid); + gone = true; + } + } + + if (gone) { + Log.w(TAG, "Process " + app + " failed to attach"); + mProcessNames.remove(app.processName, app.info.uid); + Process.killProcess(pid); + if (mPendingBroadcast != null && mPendingBroadcast.curApp.pid == pid) { + Log.w(TAG, "Unattached app died before broadcast acknowledged, skipping"); + mPendingBroadcast = null; + scheduleBroadcastsLocked(); + } + } else { + Log.w(TAG, "Spurious process start timeout - pid not known for " + app); + } + } + + private final boolean attachApplicationLocked(IApplicationThread thread, + int pid) { + + // Find the application record that is being attached... either via + // the pid if we are running in multiple processes, or just pull the + // next app record if we are emulating process with anonymous threads. + ProcessRecord app; + if (pid != MY_PID && pid >= 0) { + synchronized (mPidsSelfLocked) { + app = mPidsSelfLocked.get(pid); + } + } else if (mStartingProcesses.size() > 0) { + app = mStartingProcesses.remove(0); + app.pid = pid; + } else { + app = null; + } + + if (app == null) { + Log.w(TAG, "No pending application record for pid " + pid + + " (IApplicationThread " + thread + "); dropping process"); + EventLog.writeEvent(LOG_AM_DROP_PROCESS, pid); + if (pid > 0 && pid != MY_PID) { + Process.killProcess(pid); + } else { + try { + thread.scheduleExit(); + } catch (Exception e) { + // Ignore exceptions. + } + } + return false; + } + + // If this application record is still attached to a previous + // process, clean it up now. + if (app.thread != null) { + handleAppDiedLocked(app, true); + } + + // Tell the process all about itself. + + if (localLOGV) Log.v( + TAG, "Binding process pid " + pid + " to record " + app); + + String processName = app.processName; + try { + thread.asBinder().linkToDeath(new AppDeathRecipient( + app, pid, thread), 0); + } catch (RemoteException e) { + app.resetPackageList(); + startProcessLocked(app, "link fail", processName); + return false; + } + + EventLog.writeEvent(LOG_AM_PROCESS_BOUND, app.pid, app.processName); + + app.thread = thread; + app.curAdj = app.setAdj = -100; + app.forcingToForeground = null; + app.foregroundServices = false; + app.debugging = false; + + mHandler.removeMessages(PROC_START_TIMEOUT_MSG, app); + + List providers = generateApplicationProvidersLocked(app); + + if (localLOGV) Log.v( + TAG, "New app record " + app + + " thread=" + thread.asBinder() + " pid=" + pid); + try { + int testMode = IApplicationThread.DEBUG_OFF; + if (mDebugApp != null && mDebugApp.equals(processName)) { + testMode = mWaitForDebugger + ? IApplicationThread.DEBUG_WAIT + : IApplicationThread.DEBUG_ON; + app.debugging = true; + if (mDebugTransient) { + mDebugApp = mOrigDebugApp; + mWaitForDebugger = mOrigWaitForDebugger; + } + } + thread.bindApplication(processName, app.info, providers, + app.instrumentationClass, app.instrumentationProfileFile, + app.instrumentationArguments, app.instrumentationWatcher, testMode, + mConfiguration, getCommonServicesLocked()); + updateLRUListLocked(app, false); + app.lastRequestedGc = SystemClock.uptimeMillis(); + } catch (Exception e) { + // todo: Yikes! What should we do? For now we will try to + // start another process, but that could easily get us in + // an infinite loop of restarting processes... + Log.w(TAG, "Exception thrown during bind!", e); + + app.resetPackageList(); + startProcessLocked(app, "bind fail", processName); + return false; + } + + // Remove this record from the list of starting applications. + mPersistentStartingProcesses.remove(app); + mProcessesOnHold.remove(app); + + boolean badApp = false; + boolean didSomething = false; + + // See if the top visible activity is waiting to run in this process... + HistoryRecord hr = topRunningActivityLocked(null); + if (hr != null) { + if (hr.app == null && app.info.uid == hr.info.applicationInfo.uid + && processName.equals(hr.processName)) { + try { + if (realStartActivityLocked(hr, app, true, true)) { + didSomething = true; + } + } catch (Exception e) { + Log.w(TAG, "Exception in new application when starting activity " + + hr.intent.getComponent().flattenToShortString(), e); + badApp = true; + } + } else { + ensureActivitiesVisibleLocked(hr, null, processName, 0); + } + } + + // Find any services that should be running in this process... + if (!badApp && mPendingServices.size() > 0) { + ServiceRecord sr = null; + try { + for (int i=0; i<mPendingServices.size(); i++) { + sr = mPendingServices.get(i); + if (app.info.uid != sr.appInfo.uid + || !processName.equals(sr.processName)) { + continue; + } + + mPendingServices.remove(i); + i--; + realStartServiceLocked(sr, app); + didSomething = true; + } + } catch (Exception e) { + Log.w(TAG, "Exception in new application when starting service " + + sr.shortName, e); + badApp = true; + } + } + + // Check if the next broadcast receiver is in this process... + BroadcastRecord br = mPendingBroadcast; + if (!badApp && br != null && br.curApp == app) { + try { + mPendingBroadcast = null; + processCurBroadcastLocked(br, app); + didSomething = true; + } catch (Exception e) { + Log.w(TAG, "Exception in new application when starting receiver " + + br.curComponent.flattenToShortString(), e); + badApp = true; + logBroadcastReceiverDiscard(br); + finishReceiverLocked(br.receiver, br.resultCode, br.resultData, + br.resultExtras, br.resultAbort, true); + scheduleBroadcastsLocked(); + } + } + + if (badApp) { + // todo: Also need to kill application to deal with all + // kinds of exceptions. + handleAppDiedLocked(app, false); + return false; + } + + if (!didSomething) { + updateOomAdjLocked(); + } + + return true; + } + + public final void attachApplication(IApplicationThread thread) { + synchronized (this) { + int callingPid = Binder.getCallingPid(); + final long origId = Binder.clearCallingIdentity(); + attachApplicationLocked(thread, callingPid); + Binder.restoreCallingIdentity(origId); + } + } + + public final void activityIdle(IBinder token) { + final long origId = Binder.clearCallingIdentity(); + activityIdleInternal(token, false); + Binder.restoreCallingIdentity(origId); + } + + final ArrayList<HistoryRecord> processStoppingActivitiesLocked( + boolean remove) { + int N = mStoppingActivities.size(); + if (N <= 0) return null; + + ArrayList<HistoryRecord> stops = null; + + final boolean nowVisible = mResumedActivity != null + && mResumedActivity.nowVisible + && !mResumedActivity.waitingVisible; + for (int i=0; i<N; i++) { + HistoryRecord s = mStoppingActivities.get(i); + if (localLOGV) Log.v(TAG, "Stopping " + s + ": nowVisible=" + + nowVisible + " waitingVisible=" + s.waitingVisible + + " finishing=" + s.finishing); + if (s.waitingVisible && nowVisible) { + mWaitingVisibleActivities.remove(s); + s.waitingVisible = false; + if (s.finishing) { + // If this activity is finishing, it is sitting on top of + // everyone else but we now know it is no longer needed... + // so get rid of it. Otherwise, we need to go through the + // normal flow and hide it once we determine that it is + // hidden by the activities in front of it. + if (localLOGV) Log.v(TAG, "Before stopping, can hide: " + s); + mWindowManager.setAppVisibility(s, false); + } + } + if (!s.waitingVisible && remove) { + if (localLOGV) Log.v(TAG, "Ready to stop: " + s); + if (stops == null) { + stops = new ArrayList<HistoryRecord>(); + } + stops.add(s); + mStoppingActivities.remove(i); + N--; + i--; + } + } + + return stops; + } + + void enableScreenAfterBoot() { + mWindowManager.enableScreenAfterBoot(); + } + + final void activityIdleInternal(IBinder token, boolean fromTimeout) { + if (localLOGV) Log.v(TAG, "Activity idle: " + token); + + ArrayList<HistoryRecord> stops = null; + ArrayList<HistoryRecord> finishes = null; + ArrayList<HistoryRecord> thumbnails = null; + int NS = 0; + int NF = 0; + int NT = 0; + IApplicationThread sendThumbnail = null; + boolean booting = false; + boolean enableScreen = false; + + synchronized (this) { + if (token != null) { + mHandler.removeMessages(IDLE_TIMEOUT_MSG, token); + } + + // Get the activity record. + int index = indexOfTokenLocked(token, false); + if (index >= 0) { + HistoryRecord r = (HistoryRecord)mHistory.get(index); + + // No longer need to keep the device awake. + if (mResumedActivity == r && mLaunchingActivity.isHeld()) { + mHandler.removeMessages(LAUNCH_TIMEOUT_MSG); + mLaunchingActivity.release(); + } + + // We are now idle. If someone is waiting for a thumbnail from + // us, we can now deliver. + r.idle = true; + scheduleAppGcsLocked(); + if (r.thumbnailNeeded && r.app != null && r.app.thread != null) { + sendThumbnail = r.app.thread; + r.thumbnailNeeded = false; + } + + // If this activity is fullscreen, set up to hide those under it. + + if (DEBUG_VISBILITY) Log.v(TAG, "Idle activity for " + r); + ensureActivitiesVisibleLocked(null, 0); + + //Log.i(TAG, "IDLE: mBooted=" + mBooted + ", fromTimeout=" + fromTimeout); + if (!mBooted && !fromTimeout) { + mBooted = true; + enableScreen = true; + } + } + + // Atomically retrieve all of the other things to do. + stops = processStoppingActivitiesLocked(true); + NS = stops != null ? stops.size() : 0; + if ((NF=mFinishingActivities.size()) > 0) { + finishes = new ArrayList<HistoryRecord>(mFinishingActivities); + mFinishingActivities.clear(); + } + if ((NT=mCancelledThumbnails.size()) > 0) { + thumbnails = new ArrayList<HistoryRecord>(mCancelledThumbnails); + mCancelledThumbnails.clear(); + } + + booting = mBooting; + mBooting = false; + } + + int i; + + // Send thumbnail if requested. + if (sendThumbnail != null) { + try { + sendThumbnail.requestThumbnail(token); + } catch (Exception e) { + Log.w(TAG, "Exception thrown when requesting thumbnail", e); + sendPendingThumbnail(null, token, null, null, true); + } + } + + // Stop any activities that are scheduled to do so but have been + // waiting for the next one to start. + for (i=0; i<NS; i++) { + HistoryRecord r = (HistoryRecord)stops.get(i); + synchronized (this) { + if (r.finishing) { + finishCurrentActivityLocked(r, FINISH_IMMEDIATELY); + } else { + stopActivityLocked(r); + } + } + } + + // Finish any activities that are scheduled to do so but have been + // waiting for the next one to start. + for (i=0; i<NF; i++) { + HistoryRecord r = (HistoryRecord)finishes.get(i); + synchronized (this) { + destroyActivityLocked(r, true); + } + } + + // Report back to any thumbnail receivers. + for (i=0; i<NT; i++) { + HistoryRecord r = (HistoryRecord)thumbnails.get(i); + sendPendingThumbnail(r, null, null, null, true); + } + + if (booting) { + // Ensure that any processes we had put on hold are now started + // up. + final int NP = mProcessesOnHold.size(); + if (NP > 0) { + ArrayList<ProcessRecord> procs = + new ArrayList<ProcessRecord>(mProcessesOnHold); + for (int ip=0; ip<NP; ip++) { + this.startProcessLocked(procs.get(ip), "on-hold", null); + } + } + if (mFactoryTest != SystemServer.FACTORY_TEST_LOW_LEVEL) { + // Tell anyone interested that we are done booting! + synchronized (this) { + broadcastIntentLocked(null, null, + new Intent(Intent.ACTION_BOOT_COMPLETED, null), + null, null, 0, null, null, + android.Manifest.permission.RECEIVE_BOOT_COMPLETED, + false, false, MY_PID, Process.SYSTEM_UID); + } + } + } + + trimApplications(); + //dump(); + //mWindowManager.dump(); + + if (enableScreen) { + EventLog.writeEvent(LOG_BOOT_PROGRESS_ENABLE_SCREEN, + SystemClock.uptimeMillis()); + enableScreenAfterBoot(); + } + } + + public final void activityPaused(IBinder token, Bundle icicle) { + // Refuse possible leaked file descriptors + if (icicle != null && icicle.hasFileDescriptors()) { + throw new IllegalArgumentException("File descriptors passed in Bundle"); + } + + final long origId = Binder.clearCallingIdentity(); + activityPaused(token, icicle, false); + Binder.restoreCallingIdentity(origId); + } + + final void activityPaused(IBinder token, Bundle icicle, boolean timeout) { + if (DEBUG_PAUSE) Log.v( + TAG, "Activity paused: token=" + token + ", icicle=" + icicle + + ", timeout=" + timeout); + + HistoryRecord r = null; + + synchronized (this) { + int index = indexOfTokenLocked(token, false); + if (index >= 0) { + r = (HistoryRecord)mHistory.get(index); + if (!timeout) { + r.icicle = icicle; + r.haveState = true; + } + mHandler.removeMessages(PAUSE_TIMEOUT_MSG, r); + if (mPausingActivity == r) { + r.state = ActivityState.PAUSED; + completePauseLocked(); + } else { + EventLog.writeEvent(LOG_AM_FAILED_TO_PAUSE_ACTIVITY, + System.identityHashCode(r), r.shortComponentName, + mPausingActivity != null + ? mPausingActivity.shortComponentName : "(none)"); + } + } + } + } + + public final void activityStopped(IBinder token, Bitmap thumbnail, + CharSequence description) { + if (localLOGV) Log.v( + TAG, "Activity stopped: token=" + token); + + HistoryRecord r = null; + + final long origId = Binder.clearCallingIdentity(); + + synchronized (this) { + int index = indexOfTokenLocked(token, false); + if (index >= 0) { + r = (HistoryRecord)mHistory.get(index); + r.thumbnail = thumbnail; + r.description = description; + r.stopped = true; + r.state = ActivityState.STOPPED; + if (!r.finishing) { + if (r.configDestroy) { + destroyActivityLocked(r, true); + resumeTopActivityLocked(null); + } + } + } + } + + if (r != null) { + sendPendingThumbnail(r, null, null, null, false); + } + + trimApplications(); + + Binder.restoreCallingIdentity(origId); + } + + public final void activityDestroyed(IBinder token) { + if (DEBUG_SWITCH) Log.v(TAG, "ACTIVITY DESTROYED: " + token); + synchronized (this) { + mHandler.removeMessages(DESTROY_TIMEOUT_MSG, token); + + int index = indexOfTokenLocked(token, false); + if (index >= 0) { + HistoryRecord r = (HistoryRecord)mHistory.get(index); + if (r.state == ActivityState.DESTROYING) { + final long origId = Binder.clearCallingIdentity(); + removeActivityFromHistoryLocked(r); + Binder.restoreCallingIdentity(origId); + } + } + } + } + + public String getCallingPackage(IBinder token) { + synchronized (this) { + HistoryRecord r = getCallingRecordLocked(token); + return r != null && r.app != null ? r.app.processName : null; + } + } + + public ComponentName getCallingActivity(IBinder token) { + synchronized (this) { + HistoryRecord r = getCallingRecordLocked(token); + return r != null ? r.intent.getComponent() : null; + } + } + + private HistoryRecord getCallingRecordLocked(IBinder token) { + int index = indexOfTokenLocked(token, true); + if (index >= 0) { + HistoryRecord r = (HistoryRecord)mHistory.get(index); + if (r != null) { + return r.resultTo; + } + } + return null; + } + + public ComponentName getActivityClassForToken(IBinder token) { + synchronized(this) { + int index = indexOfTokenLocked(token, false); + if (index >= 0) { + HistoryRecord r = (HistoryRecord)mHistory.get(index); + return r.intent.getComponent(); + } + return null; + } + } + + public String getPackageForToken(IBinder token) { + synchronized(this) { + int index = indexOfTokenLocked(token, false); + if (index >= 0) { + HistoryRecord r = (HistoryRecord)mHistory.get(index); + return r.packageName; + } + return null; + } + } + + public IIntentSender getIntentSender(int type, + String packageName, IBinder token, String resultWho, + int requestCode, Intent intent, String resolvedType, int flags) { + // Refuse possible leaked file descriptors + if (intent != null && intent.hasFileDescriptors() == true) { + throw new IllegalArgumentException("File descriptors passed in Intent"); + } + + synchronized(this) { + int callingUid = Binder.getCallingUid(); + try { + if (callingUid != 0 && callingUid != Process.SYSTEM_UID && + Process.supportsProcesses()) { + int uid = ActivityThread.getPackageManager() + .getPackageUid(packageName); + if (uid != Binder.getCallingUid()) { + String msg = "Permission Denial: getIntentSender() from pid=" + + Binder.getCallingPid() + + ", uid=" + Binder.getCallingUid() + + ", (need uid=" + uid + ")" + + " is not allowed to send as package " + packageName; + Log.w(TAG, msg); + throw new SecurityException(msg); + } + } + } catch (RemoteException e) { + throw new SecurityException(e); + } + HistoryRecord activity = null; + if (type == INTENT_SENDER_ACTIVITY_RESULT) { + int index = indexOfTokenLocked(token, false); + if (index < 0) { + return null; + } + activity = (HistoryRecord)mHistory.get(index); + if (activity.finishing) { + return null; + } + } + + final boolean noCreate = (flags&PendingIntent.FLAG_NO_CREATE) != 0; + final boolean cancelCurrent = (flags&PendingIntent.FLAG_CANCEL_CURRENT) != 0; + final boolean updateCurrent = (flags&PendingIntent.FLAG_UPDATE_CURRENT) != 0; + flags &= ~(PendingIntent.FLAG_NO_CREATE|PendingIntent.FLAG_CANCEL_CURRENT + |PendingIntent.FLAG_UPDATE_CURRENT); + + PendingIntentRecord.Key key = new PendingIntentRecord.Key( + type, packageName, activity, resultWho, + requestCode, intent, resolvedType, flags); + WeakReference<PendingIntentRecord> ref; + ref = mIntentSenderRecords.get(key); + PendingIntentRecord rec = ref != null ? ref.get() : null; + if (rec != null) { + if (!cancelCurrent) { + if (updateCurrent) { + rec.key.requestIntent.replaceExtras(intent); + } + return rec; + } + rec.canceled = true; + mIntentSenderRecords.remove(key); + } + if (noCreate) { + return rec; + } + rec = new PendingIntentRecord(this, key, callingUid); + mIntentSenderRecords.put(key, rec.ref); + if (type == INTENT_SENDER_ACTIVITY_RESULT) { + if (activity.pendingResults == null) { + activity.pendingResults + = new HashSet<WeakReference<PendingIntentRecord>>(); + } + activity.pendingResults.add(rec.ref); + } + return rec; + } + } + + public void cancelIntentSender(IIntentSender sender) { + if (!(sender instanceof PendingIntentRecord)) { + return; + } + synchronized(this) { + PendingIntentRecord rec = (PendingIntentRecord)sender; + try { + int uid = ActivityThread.getPackageManager() + .getPackageUid(rec.key.packageName); + if (uid != Binder.getCallingUid()) { + String msg = "Permission Denial: cancelIntentSender() from pid=" + + Binder.getCallingPid() + + ", uid=" + Binder.getCallingUid() + + " is not allowed to cancel packges " + + rec.key.packageName; + Log.w(TAG, msg); + throw new SecurityException(msg); + } + } catch (RemoteException e) { + throw new SecurityException(e); + } + cancelIntentSenderLocked(rec, true); + } + } + + void cancelIntentSenderLocked(PendingIntentRecord rec, boolean cleanActivity) { + rec.canceled = true; + mIntentSenderRecords.remove(rec.key); + if (cleanActivity && rec.key.activity != null) { + rec.key.activity.pendingResults.remove(rec.ref); + } + } + + public String getPackageForIntentSender(IIntentSender pendingResult) { + if (!(pendingResult instanceof PendingIntentRecord)) { + return null; + } + synchronized(this) { + try { + PendingIntentRecord res = (PendingIntentRecord)pendingResult; + return res.key.packageName; + } catch (ClassCastException e) { + } + } + return null; + } + + public void setProcessLimit(int max) { + enforceCallingPermission(android.Manifest.permission.SET_PROCESS_LIMIT, + "setProcessLimit()"); + mProcessLimit = max; + } + + public int getProcessLimit() { + return mProcessLimit; + } + + void foregroundTokenDied(ForegroundToken token) { + synchronized (ActivityManagerService.this) { + synchronized (mPidsSelfLocked) { + ForegroundToken cur + = mForegroundProcesses.get(token.pid); + if (cur != token) { + return; + } + mForegroundProcesses.remove(token.pid); + ProcessRecord pr = mPidsSelfLocked.get(token.pid); + if (pr == null) { + return; + } + pr.forcingToForeground = null; + pr.foregroundServices = false; + } + updateOomAdjLocked(); + } + } + + public void setProcessForeground(IBinder token, int pid, boolean isForeground) { + enforceCallingPermission(android.Manifest.permission.SET_PROCESS_LIMIT, + "setProcessForeground()"); + synchronized(this) { + boolean changed = false; + + synchronized (mPidsSelfLocked) { + ProcessRecord pr = mPidsSelfLocked.get(pid); + if (pr == null) { + Log.w(TAG, "setProcessForeground called on unknown pid: " + pid); + return; + } + ForegroundToken oldToken = mForegroundProcesses.get(pid); + if (oldToken != null) { + oldToken.token.unlinkToDeath(oldToken, 0); + mForegroundProcesses.remove(pid); + pr.forcingToForeground = null; + changed = true; + } + if (isForeground && token != null) { + ForegroundToken newToken = new ForegroundToken() { + public void binderDied() { + foregroundTokenDied(this); + } + }; + newToken.pid = pid; + newToken.token = token; + try { + token.linkToDeath(newToken, 0); + mForegroundProcesses.put(pid, newToken); + pr.forcingToForeground = token; + changed = true; + } catch (RemoteException e) { + // If the process died while doing this, we will later + // do the cleanup with the process death link. + } + } + } + + if (changed) { + updateOomAdjLocked(); + } + } + } + + // ========================================================= + // PERMISSIONS + // ========================================================= + + static class PermissionController extends IPermissionController.Stub { + ActivityManagerService mActivityManagerService; + PermissionController(ActivityManagerService activityManagerService) { + mActivityManagerService = activityManagerService; + } + + public boolean checkPermission(String permission, int pid, int uid) { + return mActivityManagerService.checkPermission(permission, pid, + uid) == PackageManager.PERMISSION_GRANTED; + } + } + + /** + * This can be called with or without the global lock held. + */ + int checkComponentPermission(String permission, int pid, int uid, + int reqUid) { + // We might be performing an operation on behalf of an indirect binder + // invocation, e.g. via {@link #openContentUri}. Check and adjust the + // client identity accordingly before proceeding. + Identity tlsIdentity = sCallerIdentity.get(); + if (tlsIdentity != null) { + Log.d(TAG, "checkComponentPermission() adjusting {pid,uid} to {" + + tlsIdentity.pid + "," + tlsIdentity.uid + "}"); + uid = tlsIdentity.uid; + pid = tlsIdentity.pid; + } + + // Root, system server and our own process get to do everything. + if (uid == 0 || uid == Process.SYSTEM_UID || pid == MY_PID || + !Process.supportsProcesses()) { + return PackageManager.PERMISSION_GRANTED; + } + // If the target requires a specific UID, always fail for others. + if (reqUid >= 0 && uid != reqUid) { + return PackageManager.PERMISSION_DENIED; + } + if (permission == null) { + return PackageManager.PERMISSION_GRANTED; + } + try { + return ActivityThread.getPackageManager() + .checkUidPermission(permission, uid); + } catch (RemoteException e) { + // Should never happen, but if it does... deny! + Log.e(TAG, "PackageManager is dead?!?", e); + } + return PackageManager.PERMISSION_DENIED; + } + + /** + * As the only public entry point for permissions checking, this method + * can enforce the semantic that requesting a check on a null global + * permission is automatically denied. (Internally a null permission + * string is used when calling {@link #checkComponentPermission} in cases + * when only uid-based security is needed.) + * + * This can be called with or without the global lock held. + */ + public int checkPermission(String permission, int pid, int uid) { + if (permission == null) { + return PackageManager.PERMISSION_DENIED; + } + return checkComponentPermission(permission, pid, uid, -1); + } + + /** + * Binder IPC calls go through the public entry point. + * This can be called with or without the global lock held. + */ + int checkCallingPermission(String permission) { + return checkPermission(permission, + Binder.getCallingPid(), + Binder.getCallingUid()); + } + + /** + * This can be called with or without the global lock held. + */ + void enforceCallingPermission(String permission, String func) { + if (checkCallingPermission(permission) + == PackageManager.PERMISSION_GRANTED) { + return; + } + + String msg = "Permission Denial: " + func + " from pid=" + + Binder.getCallingPid() + + ", uid=" + Binder.getCallingUid() + + " requires " + permission; + Log.w(TAG, msg); + throw new SecurityException(msg); + } + + private final boolean checkHoldingPermissionsLocked(IPackageManager pm, + ProviderInfo pi, int uid, int modeFlags) { + try { + if ((modeFlags&Intent.FLAG_GRANT_READ_URI_PERMISSION) != 0) { + if ((pi.readPermission != null) && + (pm.checkUidPermission(pi.readPermission, uid) + != PackageManager.PERMISSION_GRANTED)) { + return false; + } + } + if ((modeFlags&Intent.FLAG_GRANT_WRITE_URI_PERMISSION) != 0) { + if ((pi.writePermission != null) && + (pm.checkUidPermission(pi.writePermission, uid) + != PackageManager.PERMISSION_GRANTED)) { + return false; + } + } + return true; + } catch (RemoteException e) { + return false; + } + } + + private final boolean checkUriPermissionLocked(Uri uri, int uid, + int modeFlags) { + // Root gets to do everything. + if (uid == 0 || !Process.supportsProcesses()) { + return true; + } + HashMap<Uri, UriPermission> perms = mGrantedUriPermissions.get(uid); + if (perms == null) return false; + UriPermission perm = perms.get(uri); + if (perm == null) return false; + return (modeFlags&perm.modeFlags) == modeFlags; + } + + public int checkUriPermission(Uri uri, int pid, int uid, int modeFlags) { + // Another redirected-binder-call permissions check as in + // {@link checkComponentPermission}. + Identity tlsIdentity = sCallerIdentity.get(); + if (tlsIdentity != null) { + uid = tlsIdentity.uid; + pid = tlsIdentity.pid; + } + + // Our own process gets to do everything. + if (pid == MY_PID) { + return PackageManager.PERMISSION_GRANTED; + } + synchronized(this) { + return checkUriPermissionLocked(uri, uid, modeFlags) + ? PackageManager.PERMISSION_GRANTED + : PackageManager.PERMISSION_DENIED; + } + } + + private void grantUriPermissionLocked(int callingUid, + String targetPkg, Uri uri, int modeFlags, HistoryRecord activity) { + modeFlags &= (Intent.FLAG_GRANT_READ_URI_PERMISSION + | Intent.FLAG_GRANT_WRITE_URI_PERMISSION); + if (modeFlags == 0) { + return; + } + + final IPackageManager pm = ActivityThread.getPackageManager(); + + // If this is not a content: uri, we can't do anything with it. + if (!ContentResolver.SCHEME_CONTENT.equals(uri.getScheme())) { + return; + } + + String name = uri.getAuthority(); + ProviderInfo pi = null; + ContentProviderRecord cpr + = (ContentProviderRecord)mProvidersByName.get(name); + if (cpr != null) { + pi = cpr.info; + } else { + try { + pi = pm.resolveContentProvider(name, + PackageManager.GET_URI_PERMISSION_PATTERNS); + } catch (RemoteException ex) { + } + } + if (pi == null) { + Log.w(TAG, "No content provider found for: " + name); + return; + } + + int targetUid; + try { + targetUid = pm.getPackageUid(targetPkg); + if (targetUid < 0) { + return; + } + } catch (RemoteException ex) { + return; + } + + // First... does the target actually need this permission? + if (checkHoldingPermissionsLocked(pm, pi, targetUid, modeFlags)) { + // No need to grant the target this permission. + return; + } + + // Second... maybe someone else has already granted the + // permission? + if (checkUriPermissionLocked(uri, targetUid, modeFlags)) { + // No need to grant the target this permission. + return; + } + + // Third... is the provider allowing granting of URI permissions? + if (!pi.grantUriPermissions) { + throw new SecurityException("Provider " + pi.packageName + + "/" + pi.name + + " does not allow granting of Uri permissions (uri " + + uri + ")"); + } + if (pi.uriPermissionPatterns != null) { + final int N = pi.uriPermissionPatterns.length; + boolean allowed = false; + for (int i=0; i<N; i++) { + if (pi.uriPermissionPatterns[i] != null + && pi.uriPermissionPatterns[i].match(uri.getPath())) { + allowed = true; + break; + } + } + if (!allowed) { + throw new SecurityException("Provider " + pi.packageName + + "/" + pi.name + + " does not allow granting of permission to path of Uri " + + uri); + } + } + + // Fourth... does the caller itself have permission to access + // this uri? + if (!checkHoldingPermissionsLocked(pm, pi, callingUid, modeFlags)) { + if (!checkUriPermissionLocked(uri, callingUid, modeFlags)) { + throw new SecurityException("Uid " + callingUid + + " does not have permission to uri " + uri); + } + } + + // Okay! So here we are: the caller has the assumed permission + // to the uri, and the target doesn't. Let's now give this to + // the target. + + HashMap<Uri, UriPermission> targetUris + = mGrantedUriPermissions.get(targetUid); + if (targetUris == null) { + targetUris = new HashMap<Uri, UriPermission>(); + mGrantedUriPermissions.put(targetUid, targetUris); + } + + UriPermission perm = targetUris.get(uri); + if (perm == null) { + perm = new UriPermission(targetUid, uri); + targetUris.put(uri, perm); + + } + perm.modeFlags |= modeFlags; + if (activity == null) { + perm.globalModeFlags |= modeFlags; + } else if ((modeFlags&Intent.FLAG_GRANT_READ_URI_PERMISSION) != 0) { + perm.readActivities.add(activity); + if (activity.readUriPermissions == null) { + activity.readUriPermissions = new HashSet<UriPermission>(); + } + activity.readUriPermissions.add(perm); + } else if ((modeFlags&Intent.FLAG_GRANT_WRITE_URI_PERMISSION) != 0) { + perm.writeActivities.add(activity); + if (activity.writeUriPermissions == null) { + activity.writeUriPermissions = new HashSet<UriPermission>(); + } + activity.writeUriPermissions.add(perm); + } + } + + private void grantUriPermissionFromIntentLocked(int callingUid, + String targetPkg, Intent intent, HistoryRecord activity) { + if (intent == null) { + return; + } + Uri data = intent.getData(); + if (data == null) { + return; + } + grantUriPermissionLocked(callingUid, targetPkg, data, + intent.getFlags(), activity); + } + + public void grantUriPermission(IApplicationThread caller, String targetPkg, + Uri uri, int modeFlags) { + synchronized(this) { + final ProcessRecord r = getRecordForAppLocked(caller); + if (r == null) { + throw new SecurityException("Unable to find app for caller " + + caller + + " when granting permission to uri " + uri); + } + if (targetPkg == null) { + Log.w(TAG, "grantUriPermission: null target"); + return; + } + if (uri == null) { + Log.w(TAG, "grantUriPermission: null uri"); + return; + } + + grantUriPermissionLocked(r.info.uid, targetPkg, uri, modeFlags, + null); + } + } + + private void removeUriPermissionIfNeededLocked(UriPermission perm) { + if ((perm.modeFlags&(Intent.FLAG_GRANT_READ_URI_PERMISSION + |Intent.FLAG_GRANT_WRITE_URI_PERMISSION)) == 0) { + HashMap<Uri, UriPermission> perms + = mGrantedUriPermissions.get(perm.uid); + if (perms != null) { + perms.remove(perm.uri); + if (perms.size() == 0) { + mGrantedUriPermissions.remove(perm.uid); + } + } + } + } + + private void removeActivityUriPermissionsLocked(HistoryRecord activity) { + if (activity.readUriPermissions != null) { + for (UriPermission perm : activity.readUriPermissions) { + perm.readActivities.remove(activity); + if (perm.readActivities.size() == 0 && (perm.globalModeFlags + &Intent.FLAG_GRANT_READ_URI_PERMISSION) == 0) { + perm.modeFlags &= ~Intent.FLAG_GRANT_READ_URI_PERMISSION; + removeUriPermissionIfNeededLocked(perm); + } + } + } + if (activity.writeUriPermissions != null) { + for (UriPermission perm : activity.writeUriPermissions) { + perm.writeActivities.remove(activity); + if (perm.writeActivities.size() == 0 && (perm.globalModeFlags + &Intent.FLAG_GRANT_WRITE_URI_PERMISSION) == 0) { + perm.modeFlags &= ~Intent.FLAG_GRANT_WRITE_URI_PERMISSION; + removeUriPermissionIfNeededLocked(perm); + } + } + } + } + + private void revokeUriPermissionLocked(int callingUid, Uri uri, + int modeFlags) { + modeFlags &= (Intent.FLAG_GRANT_READ_URI_PERMISSION + | Intent.FLAG_GRANT_WRITE_URI_PERMISSION); + if (modeFlags == 0) { + return; + } + + final IPackageManager pm = ActivityThread.getPackageManager(); + + final String authority = uri.getAuthority(); + ProviderInfo pi = null; + ContentProviderRecord cpr + = (ContentProviderRecord)mProvidersByName.get(authority); + if (cpr != null) { + pi = cpr.info; + } else { + try { + pi = pm.resolveContentProvider(authority, + PackageManager.GET_URI_PERMISSION_PATTERNS); + } catch (RemoteException ex) { + } + } + if (pi == null) { + Log.w(TAG, "No content provider found for: " + authority); + return; + } + + // Does the caller have this permission on the URI? + if (!checkHoldingPermissionsLocked(pm, pi, callingUid, modeFlags)) { + // Right now, if you are not the original owner of the permission, + // you are not allowed to revoke it. + //if (!checkUriPermissionLocked(uri, callingUid, modeFlags)) { + throw new SecurityException("Uid " + callingUid + + " does not have permission to uri " + uri); + //} + } + + // Go through all of the permissions and remove any that match. + final List<String> SEGMENTS = uri.getPathSegments(); + if (SEGMENTS != null) { + final int NS = SEGMENTS.size(); + int N = mGrantedUriPermissions.size(); + for (int i=0; i<N; i++) { + HashMap<Uri, UriPermission> perms + = mGrantedUriPermissions.valueAt(i); + Iterator<UriPermission> it = perms.values().iterator(); + toploop: + while (it.hasNext()) { + UriPermission perm = it.next(); + Uri targetUri = perm.uri; + if (!authority.equals(targetUri.getAuthority())) { + continue; + } + List<String> targetSegments = targetUri.getPathSegments(); + if (targetSegments == null) { + continue; + } + if (targetSegments.size() < NS) { + continue; + } + for (int j=0; j<NS; j++) { + if (!SEGMENTS.get(j).equals(targetSegments.get(j))) { + continue toploop; + } + } + perm.clearModes(modeFlags); + if (perm.modeFlags == 0) { + it.remove(); + } + } + if (perms.size() == 0) { + mGrantedUriPermissions.remove( + mGrantedUriPermissions.keyAt(i)); + N--; + i--; + } + } + } + } + + public void revokeUriPermission(IApplicationThread caller, Uri uri, + int modeFlags) { + synchronized(this) { + final ProcessRecord r = getRecordForAppLocked(caller); + if (r == null) { + throw new SecurityException("Unable to find app for caller " + + caller + + " when revoking permission to uri " + uri); + } + if (uri == null) { + Log.w(TAG, "revokeUriPermission: null uri"); + return; + } + + modeFlags &= (Intent.FLAG_GRANT_READ_URI_PERMISSION + | Intent.FLAG_GRANT_WRITE_URI_PERMISSION); + if (modeFlags == 0) { + return; + } + + final IPackageManager pm = ActivityThread.getPackageManager(); + + final String authority = uri.getAuthority(); + ProviderInfo pi = null; + ContentProviderRecord cpr + = (ContentProviderRecord)mProvidersByName.get(authority); + if (cpr != null) { + pi = cpr.info; + } else { + try { + pi = pm.resolveContentProvider(authority, + PackageManager.GET_URI_PERMISSION_PATTERNS); + } catch (RemoteException ex) { + } + } + if (pi == null) { + Log.w(TAG, "No content provider found for: " + authority); + return; + } + + revokeUriPermissionLocked(r.info.uid, uri, modeFlags); + } + } + + public void showWaitingForDebugger(IApplicationThread who, boolean waiting) { + synchronized (this) { + ProcessRecord app = + who != null ? getRecordForAppLocked(who) : null; + if (app == null) return; + + Message msg = Message.obtain(); + msg.what = WAIT_FOR_DEBUGGER_MSG; + msg.obj = app; + msg.arg1 = waiting ? 1 : 0; + mHandler.sendMessage(msg); + } + } + + public void getMemoryInfo(ActivityManager.MemoryInfo outInfo) { + outInfo.availMem = Process.getFreeMemory(); + outInfo.threshold = SECONDARY_SERVER_MEM; + outInfo.lowMemory = outInfo.availMem < + (SECONDARY_SERVER_MEM + ((HIDDEN_APP_MEM-SECONDARY_SERVER_MEM)/2)); + } + + // ========================================================= + // TASK MANAGEMENT + // ========================================================= + + public List getTasks(int maxNum, int flags, + IThumbnailReceiver receiver) { + ArrayList list = new ArrayList(); + + PendingThumbnailsRecord pending = null; + IApplicationThread topThumbnail = null; + HistoryRecord topRecord = null; + + synchronized(this) { + if (localLOGV) Log.v( + TAG, "getTasks: max=" + maxNum + ", flags=" + flags + + ", receiver=" + receiver); + + if (checkCallingPermission(android.Manifest.permission.GET_TASKS) + != PackageManager.PERMISSION_GRANTED) { + if (receiver != null) { + // If the caller wants to wait for pending thumbnails, + // it ain't gonna get them. + try { + receiver.finished(); + } catch (RemoteException ex) { + } + } + String msg = "Permission Denial: getTasks() from pid=" + + Binder.getCallingPid() + + ", uid=" + Binder.getCallingUid() + + " requires " + android.Manifest.permission.GET_TASKS; + Log.w(TAG, msg); + throw new SecurityException(msg); + } + + int pos = mHistory.size()-1; + HistoryRecord next = + pos >= 0 ? (HistoryRecord)mHistory.get(pos) : null; + HistoryRecord top = null; + CharSequence topDescription = null; + TaskRecord curTask = null; + int numActivities = 0; + int numRunning = 0; + while (pos >= 0 && maxNum > 0) { + final HistoryRecord r = next; + pos--; + next = pos >= 0 ? (HistoryRecord)mHistory.get(pos) : null; + + // Initialize state for next task if needed. + if (top == null || + (top.state == ActivityState.INITIALIZING + && top.task == r.task)) { + top = r; + topDescription = r.description; + curTask = r.task; + numActivities = numRunning = 0; + } + + // Add 'r' into the current task. + numActivities++; + if (r.app != null && r.app.thread != null) { + numRunning++; + } + if (topDescription == null) { + topDescription = r.description; + } + + if (localLOGV) Log.v( + TAG, r.intent.getComponent().flattenToShortString() + + ": task=" + r.task); + + // If the next one is a different task, generate a new + // TaskInfo entry for what we have. + if (next == null || next.task != curTask) { + ActivityManager.RunningTaskInfo ci + = new ActivityManager.RunningTaskInfo(); + ci.id = curTask.taskId; + ci.baseActivity = r.intent.getComponent(); + ci.topActivity = top.intent.getComponent(); + ci.thumbnail = top.thumbnail; + ci.description = topDescription; + ci.numActivities = numActivities; + ci.numRunning = numRunning; + //System.out.println( + // "#" + maxNum + ": " + " descr=" + ci.description); + if (ci.thumbnail == null && receiver != null) { + if (localLOGV) Log.v( + TAG, "State=" + top.state + "Idle=" + top.idle + + " app=" + top.app + + " thr=" + (top.app != null ? top.app.thread : null)); + if (top.state == ActivityState.RESUMED + || top.state == ActivityState.PAUSING) { + if (top.idle && top.app != null + && top.app.thread != null) { + topRecord = top; + topThumbnail = top.app.thread; + } else { + top.thumbnailNeeded = true; + } + } + if (pending == null) { + pending = new PendingThumbnailsRecord(receiver); + } + pending.pendingRecords.add(top); + } + list.add(ci); + maxNum--; + top = null; + } + } + + if (pending != null) { + mPendingThumbnails.add(pending); + } + } + + if (localLOGV) Log.v(TAG, "We have pending thumbnails: " + pending); + + if (topThumbnail != null) { + if (localLOGV) Log.v(TAG, "Requesting top thumbnail"); + try { + topThumbnail.requestThumbnail(topRecord); + } catch (Exception e) { + Log.w(TAG, "Exception thrown when requesting thumbnail", e); + sendPendingThumbnail(null, topRecord, null, null, true); + } + } + + if (pending == null && receiver != null) { + // In this case all thumbnails were available and the client + // is being asked to be told when the remaining ones come in... + // which is unusually, since the top-most currently running + // activity should never have a canned thumbnail! Oh well. + try { + receiver.finished(); + } catch (RemoteException ex) { + } + } + + return list; + } + + public List<ActivityManager.RecentTaskInfo> getRecentTasks(int maxNum, + int flags) { + synchronized (this) { + enforceCallingPermission(android.Manifest.permission.GET_TASKS, + "getRecentTasks()"); + + final int N = mRecentTasks.size(); + ArrayList<ActivityManager.RecentTaskInfo> res + = new ArrayList<ActivityManager.RecentTaskInfo>( + maxNum < N ? maxNum : N); + for (int i=0; i<N && maxNum > 0; i++) { + TaskRecord tr = mRecentTasks.get(i); + if (((flags&ActivityManager.RECENT_WITH_EXCLUDED) != 0) + || (tr.intent == null) + || ((tr.intent.getFlags() + &Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS) == 0)) { + ActivityManager.RecentTaskInfo rti + = new ActivityManager.RecentTaskInfo(); + rti.id = tr.numActivities > 0 ? tr.taskId : -1; + rti.baseIntent = new Intent( + tr.intent != null ? tr.intent : tr.affinityIntent); + rti.origActivity = tr.origActivity; + res.add(rti); + maxNum--; + } + } + return res; + } + } + + private final int findAffinityTaskTopLocked(int startIndex, String affinity) { + int j; + TaskRecord startTask = ((HistoryRecord)mHistory.get(startIndex)).task; + TaskRecord jt = startTask; + + // First look backwards + for (j=startIndex-1; j>=0; j--) { + HistoryRecord r = (HistoryRecord)mHistory.get(j); + if (r.task != jt) { + jt = r.task; + if (affinity.equals(jt.affinity)) { + return j; + } + } + } + + // Now look forwards + final int N = mHistory.size(); + jt = startTask; + for (j=startIndex+1; j<N; j++) { + HistoryRecord r = (HistoryRecord)mHistory.get(j); + if (r.task != jt) { + if (affinity.equals(jt.affinity)) { + return j; + } + jt = r.task; + } + } + + // Might it be at the top? + if (affinity.equals(((HistoryRecord)mHistory.get(N-1)).task.affinity)) { + return N-1; + } + + return -1; + } + + /** + * Perform a reset of the given task, if needed as part of launching it. + * Returns the new HistoryRecord at the top of the task. + */ + private final HistoryRecord resetTaskIfNeededLocked(HistoryRecord taskTop, + HistoryRecord newActivity) { + boolean forceReset = (newActivity.info.flags + &ActivityInfo.FLAG_CLEAR_TASK_ON_LAUNCH) != 0; + if (taskTop.task.getInactiveDuration() > ACTIVITY_INACTIVE_RESET_TIME) { + if ((newActivity.info.flags + &ActivityInfo.FLAG_ALWAYS_RETAIN_TASK_STATE) == 0) { + forceReset = true; + } + } + + final TaskRecord task = taskTop.task; + + // We are going to move through the history list so that we can look + // at each activity 'target' with 'below' either the interesting + // activity immediately below it in the stack or null. + HistoryRecord target = null; + int targetI = 0; + int taskTopI = -1; + int replyChainEnd = -1; + int lastReparentPos = -1; + for (int i=mHistory.size()-1; i>=-1; i--) { + HistoryRecord below = i >= 0 ? (HistoryRecord)mHistory.get(i) : null; + + if (below != null && below.finishing) { + continue; + } + if (target == null) { + target = below; + targetI = i; + // If we were in the middle of a reply chain before this + // task, it doesn't appear like the root of the chain wants + // anything interesting, so drop it. + replyChainEnd = -1; + continue; + } + + final int flags = target.info.flags; + + final boolean finishOnTaskLaunch = + (flags&ActivityInfo.FLAG_FINISH_ON_TASK_LAUNCH) != 0; + final boolean allowTaskReparenting = + (flags&ActivityInfo.FLAG_ALLOW_TASK_REPARENTING) != 0; + + if (target.task == task) { + // We are inside of the task being reset... we'll either + // finish this activity, push it out for another task, + // or leave it as-is. We only do this + // for activities that are not the root of the task (since + // if we finish the root, we may no longer have the task!). + if (taskTopI < 0) { + taskTopI = targetI; + } + if (below != null && below.task == task) { + final boolean clearWhenTaskReset = + (target.intent.getFlags() + &Intent.FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET) != 0; + if (!finishOnTaskLaunch && target.resultTo != null) { + // If this activity is sending a reply to a previous + // activity, we can't do anything with it now until + // we reach the start of the reply chain. + // XXX note that we are assuming the result is always + // to the previous activity, which is almost always + // the case but we really shouldn't count on. + if (replyChainEnd < 0) { + replyChainEnd = targetI; + } + } else if (!finishOnTaskLaunch && allowTaskReparenting + && target.taskAffinity != null + && !target.taskAffinity.equals(task.affinity)) { + // If this activity has an affinity for another + // task, then we need to move it out of here. We will + // move it as far out of the way as possible, to the + // bottom of the activity stack. This also keeps it + // correctly ordered with any activities we previously + // moved. + HistoryRecord p = (HistoryRecord)mHistory.get(0); + if (target.taskAffinity != null + && target.taskAffinity.equals(p.task.affinity)) { + // If the activity currently at the bottom has the + // same task affinity as the one we are moving, + // then merge it into the same task. + target.task = p.task; + if (DEBUG_TASKS) Log.v(TAG, "Start pushing activity " + target + + " out to bottom task " + p.task); + } else { + mCurTask++; + if (mCurTask <= 0) { + mCurTask = 1; + } + target.task = new TaskRecord(mCurTask, target.info, null, + (target.info.flags&ActivityInfo.FLAG_CLEAR_TASK_ON_LAUNCH) != 0); + target.task.affinityIntent = target.intent; + if (DEBUG_TASKS) Log.v(TAG, "Start pushing activity " + target + + " out to new task " + target.task); + } + mWindowManager.setAppGroupId(target, task.taskId); + if (replyChainEnd < 0) { + replyChainEnd = targetI; + } + int dstPos = 0; + for (int srcPos=targetI; srcPos<=replyChainEnd; srcPos++) { + p = (HistoryRecord)mHistory.get(srcPos); + if (p.finishing) { + continue; + } + if (DEBUG_TASKS) Log.v(TAG, "Pushing next activity " + p + + " out to target's task " + target.task); + task.numActivities--; + p.task = target.task; + target.task.numActivities++; + mHistory.remove(srcPos); + mHistory.add(dstPos, p); + mWindowManager.moveAppToken(dstPos, p); + mWindowManager.setAppGroupId(p, p.task.taskId); + dstPos++; + if (VALIDATE_TOKENS) { + mWindowManager.validateAppTokens(mHistory); + } + i++; + } + if (taskTop == p) { + taskTop = below; + } + if (taskTopI == replyChainEnd) { + taskTopI = -1; + } + replyChainEnd = -1; + addRecentTask(target.task); + } else if (forceReset || finishOnTaskLaunch + || clearWhenTaskReset) { + // If the activity should just be removed -- either + // because it asks for it, or the task should be + // cleared -- then finish it and anything that is + // part of its reply chain. + if (clearWhenTaskReset) { + // In this case, we want to finish this activity + // and everything above it, so be sneaky and pretend + // like these are all in the reply chain. + replyChainEnd = targetI+1; + while (replyChainEnd < mHistory.size() && + ((HistoryRecord)mHistory.get( + replyChainEnd)).task == task) { + replyChainEnd++; + } + replyChainEnd--; + } else if (replyChainEnd < 0) { + replyChainEnd = targetI; + } + HistoryRecord p = null; + for (int srcPos=targetI; srcPos<=replyChainEnd; srcPos++) { + p = (HistoryRecord)mHistory.get(srcPos); + if (p.finishing) { + continue; + } + if (finishActivityLocked(p, srcPos, + Activity.RESULT_CANCELED, null, "reset")) { + replyChainEnd--; + srcPos--; + } + } + if (taskTop == p) { + taskTop = below; + } + if (taskTopI == replyChainEnd) { + taskTopI = -1; + } + replyChainEnd = -1; + } else { + // If we were in the middle of a chain, well the + // activity that started it all doesn't want anything + // special, so leave it all as-is. + replyChainEnd = -1; + } + } else { + // Reached the bottom of the task -- any reply chain + // should be left as-is. + replyChainEnd = -1; + } + + } else if (target.resultTo != null) { + // If this activity is sending a reply to a previous + // activity, we can't do anything with it now until + // we reach the start of the reply chain. + // XXX note that we are assuming the result is always + // to the previous activity, which is almost always + // the case but we really shouldn't count on. + if (replyChainEnd < 0) { + replyChainEnd = targetI; + } + + } else if (taskTopI >= 0 && allowTaskReparenting + && task.affinity != null + && task.affinity.equals(target.taskAffinity)) { + // We are inside of another task... if this activity has + // an affinity for our task, then either remove it if we are + // clearing or move it over to our task. Note that + // we currently punt on the case where we are resetting a + // task that is not at the top but who has activities above + // with an affinity to it... this is really not a normal + // case, and we will need to later pull that task to the front + // and usually at that point we will do the reset and pick + // up those remaining activities. (This only happens if + // someone starts an activity in a new task from an activity + // in a task that is not currently on top.) + if (forceReset || finishOnTaskLaunch) { + if (replyChainEnd < 0) { + replyChainEnd = targetI; + } + HistoryRecord p = null; + for (int srcPos=targetI; srcPos<=replyChainEnd; srcPos++) { + p = (HistoryRecord)mHistory.get(srcPos); + if (p.finishing) { + continue; + } + if (finishActivityLocked(p, srcPos, + Activity.RESULT_CANCELED, null, "reset")) { + taskTopI--; + lastReparentPos--; + replyChainEnd--; + srcPos--; + } + } + replyChainEnd = -1; + } else { + if (replyChainEnd < 0) { + replyChainEnd = targetI; + } + for (int srcPos=replyChainEnd; srcPos>=targetI; srcPos--) { + HistoryRecord p = (HistoryRecord)mHistory.get(srcPos); + if (p.finishing) { + continue; + } + if (lastReparentPos < 0) { + lastReparentPos = taskTopI; + taskTop = p; + } else { + lastReparentPos--; + } + mHistory.remove(srcPos); + p.task.numActivities--; + p.task = task; + mHistory.add(lastReparentPos, p); + if (DEBUG_TASKS) Log.v(TAG, "Pulling activity " + p + + " in to resetting task " + task); + task.numActivities++; + mWindowManager.moveAppToken(lastReparentPos, p); + mWindowManager.setAppGroupId(p, p.task.taskId); + if (VALIDATE_TOKENS) { + mWindowManager.validateAppTokens(mHistory); + } + } + replyChainEnd = -1; + + // Now we've moved it in to place... but what if this is + // a singleTop activity and we have put it on top of another + // instance of the same activity? Then we drop the instance + // below so it remains singleTop. + if (target.info.launchMode == ActivityInfo.LAUNCH_SINGLE_TOP) { + for (int j=lastReparentPos-1; j>=0; j--) { + HistoryRecord p = (HistoryRecord)mHistory.get(j); + if (p.finishing) { + continue; + } + if (p.intent.getComponent().equals(target.intent.getComponent())) { + if (finishActivityLocked(p, j, + Activity.RESULT_CANCELED, null, "replace")) { + taskTopI--; + lastReparentPos--; + } + } + } + } + } + } + + target = below; + targetI = i; + } + + return taskTop; + } + + /** + * TODO: Add mWatcher hook + */ + public void moveTaskToFront(int task) { + enforceCallingPermission(android.Manifest.permission.REORDER_TASKS, + "moveTaskToFront()"); + + synchronized(this) { + final long origId = Binder.clearCallingIdentity(); + try { + int N = mRecentTasks.size(); + for (int i=0; i<N; i++) { + TaskRecord tr = mRecentTasks.get(i); + if (tr.taskId == task) { + moveTaskToFrontLocked(tr); + return; + } + } + for (int i=mHistory.size()-1; i>=0; i--) { + HistoryRecord hr = (HistoryRecord)mHistory.get(i); + if (hr.task.taskId == task) { + moveTaskToFrontLocked(hr.task); + return; + } + } + } finally { + Binder.restoreCallingIdentity(origId); + } + } + } + + private final void moveTaskToFrontLocked(TaskRecord tr) { + if (DEBUG_SWITCH) Log.v(TAG, "moveTaskToFront: " + tr); + + final int task = tr.taskId; + int top = mHistory.size()-1; + + if (top < 0 || ((HistoryRecord)mHistory.get(top)).task.taskId == task) { + // nothing to do! + return; + } + + if (DEBUG_TRANSITION) Log.v(TAG, + "Prepare to front transition: task=" + tr); + mWindowManager.prepareAppTransition(WindowManagerPolicy.TRANSIT_TASK_TO_FRONT); + + ArrayList moved = new ArrayList(); + + // Applying the affinities may have removed entries from the history, + // so get the size again. + top = mHistory.size()-1; + int pos = top; + + // Shift all activities with this task up to the top + // of the stack, keeping them in the same internal order. + while (pos >= 0) { + HistoryRecord r = (HistoryRecord)mHistory.get(pos); + if (localLOGV) Log.v( + TAG, "At " + pos + " ckp " + r.task + ": " + r); + boolean first = true; + if (r.task.taskId == task) { + if (localLOGV) Log.v(TAG, "Removing and adding at " + top); + mHistory.remove(pos); + mHistory.add(top, r); + moved.add(0, r); + top--; + if (first) { + addRecentTask(r.task); + first = false; + } + } + pos--; + } + + mWindowManager.moveAppTokensToTop(moved); + if (VALIDATE_TOKENS) { + mWindowManager.validateAppTokens(mHistory); + } + + finishTaskMove(task); + EventLog.writeEvent(LOG_TASK_TO_FRONT, task); + } + + private final void finishTaskMove(int task) { + resumeTopActivityLocked(null); + } + + public void moveTaskToBack(int task) { + enforceCallingPermission(android.Manifest.permission.REORDER_TASKS, + "moveTaskToBack()"); + + synchronized(this) { + final long origId = Binder.clearCallingIdentity(); + moveTaskToBackLocked(task); + Binder.restoreCallingIdentity(origId); + } + } + + /** + * Moves an activity, and all of the other activities within the same task, to the bottom + * of the history stack. The activity's order within the task is unchanged. + * + * @param token A reference to the activity we wish to move + * @param nonRoot If false then this only works if the activity is the root + * of a task; if true it will work for any activity in a task. + * @return Returns true if the move completed, false if not. + */ + public boolean moveActivityTaskToBack(IBinder token, boolean nonRoot) { + synchronized(this) { + final long origId = Binder.clearCallingIdentity(); + int taskId = getTaskForActivityLocked(token, !nonRoot); + if (taskId >= 0) { + return moveTaskToBackLocked(taskId); + } + Binder.restoreCallingIdentity(origId); + } + return false; + } + + /** + * Worker method for rearranging history stack. Implements the function of moving all + * activities for a specific task (gathering them if disjoint) into a single group at the + * bottom of the stack. + * + * If a watcher is installed, the action is preflighted and the watcher has an opportunity + * to premeptively cancel the move. + * + * @param task The taskId to collect and move to the bottom. + * @return Returns true if the move completed, false if not. + */ + private final boolean moveTaskToBackLocked(int task) { + Log.i(TAG, "moveTaskToBack: " + task); + + // If we have a watcher, preflight the move before committing to it. First check + // for *other* available tasks, but if none are available, then try again allowing the + // current task to be selected. + if (mWatcher != null) { + HistoryRecord next = topRunningActivityLocked(null, task); + if (next == null) { + next = topRunningActivityLocked(null, 0); + } + if (next != null) { + // ask watcher if this is allowed + boolean moveOK = true; + try { + moveOK = mWatcher.activityResuming(next.packageName); + } catch (RemoteException e) { + mWatcher = null; + } + if (!moveOK) { + return false; + } + } + } + + ArrayList moved = new ArrayList(); + + if (DEBUG_TRANSITION) Log.v(TAG, + "Prepare to back transition: task=" + task); + mWindowManager.prepareAppTransition(WindowManagerPolicy.TRANSIT_TASK_TO_BACK); + + final int N = mHistory.size(); + int bottom = 0; + int pos = 0; + + // Shift all activities with this task down to the bottom + // of the stack, keeping them in the same internal order. + while (pos < N) { + HistoryRecord r = (HistoryRecord)mHistory.get(pos); + if (localLOGV) Log.v( + TAG, "At " + pos + " ckp " + r.task + ": " + r); + if (r.task.taskId == task) { + if (localLOGV) Log.v(TAG, "Removing and adding at " + (N-1)); + mHistory.remove(pos); + mHistory.add(bottom, r); + moved.add(r); + bottom++; + } + pos++; + } + + mWindowManager.moveAppTokensToBottom(moved); + if (VALIDATE_TOKENS) { + mWindowManager.validateAppTokens(mHistory); + } + + finishTaskMove(task); + return true; + } + + public void moveTaskBackwards(int task) { + enforceCallingPermission(android.Manifest.permission.REORDER_TASKS, + "moveTaskBackwards()"); + + synchronized(this) { + final long origId = Binder.clearCallingIdentity(); + moveTaskBackwardsLocked(task); + Binder.restoreCallingIdentity(origId); + } + } + + private final void moveTaskBackwardsLocked(int task) { + Log.e(TAG, "moveTaskBackwards not yet implemented!"); + } + + public int getTaskForActivity(IBinder token, boolean onlyRoot) { + synchronized(this) { + return getTaskForActivityLocked(token, onlyRoot); + } + } + + int getTaskForActivityLocked(IBinder token, boolean onlyRoot) { + final int N = mHistory.size(); + TaskRecord lastTask = null; + for (int i=0; i<N; i++) { + HistoryRecord r = (HistoryRecord)mHistory.get(i); + if (r == token) { + if (!onlyRoot || lastTask != r.task) { + return r.task.taskId; + } + return -1; + } + lastTask = r.task; + } + + return -1; + } + + /** + * Returns the top activity in any existing task matching the given + * Intent. Returns null if no such task is found. + */ + private HistoryRecord findTaskLocked(Intent intent, ActivityInfo info) { + ComponentName cls = intent.getComponent(); + if (info.targetActivity != null) { + cls = new ComponentName(info.packageName, info.targetActivity); + } + + TaskRecord cp = null; + + final int N = mHistory.size(); + for (int i=(N-1); i>=0; i--) { + HistoryRecord r = (HistoryRecord)mHistory.get(i); + if (!r.finishing && r.task != cp + && r.launchMode != ActivityInfo.LAUNCH_SINGLE_INSTANCE) { + cp = r.task; + //Log.i(TAG, "Comparing existing cls=" + r.task.intent.getComponent().flattenToShortString() + // + "/aff=" + r.task.affinity + " to new cls=" + // + intent.getComponent().flattenToShortString() + "/aff=" + taskAffinity); + if (r.task.affinity != null) { + if (r.task.affinity.equals(info.taskAffinity)) { + //Log.i(TAG, "Found matching affinity!"); + return r; + } + } else if (r.task.intent != null + && r.task.intent.getComponent().equals(cls)) { + //Log.i(TAG, "Found matching class!"); + //dump(); + //Log.i(TAG, "For Intent " + intent + " bringing to top: " + r.intent); + return r; + } else if (r.task.affinityIntent != null + && r.task.affinityIntent.getComponent().equals(cls)) { + //Log.i(TAG, "Found matching class!"); + //dump(); + //Log.i(TAG, "For Intent " + intent + " bringing to top: " + r.intent); + return r; + } + } + } + + return null; + } + + /** + * Returns the first activity (starting from the top of the stack) that + * is the same as the given activity. Returns null if no such activity + * is found. + */ + private HistoryRecord findActivityLocked(Intent intent, ActivityInfo info) { + ComponentName cls = intent.getComponent(); + if (info.targetActivity != null) { + cls = new ComponentName(info.packageName, info.targetActivity); + } + + final int N = mHistory.size(); + for (int i=(N-1); i>=0; i--) { + HistoryRecord r = (HistoryRecord)mHistory.get(i); + if (!r.finishing) { + if (r.intent.getComponent().equals(cls)) { + //Log.i(TAG, "Found matching class!"); + //dump(); + //Log.i(TAG, "For Intent " + intent + " bringing to top: " + r.intent); + return r; + } + } + } + + return null; + } + + public void finishOtherInstances(IBinder token, ComponentName className) { + synchronized(this) { + final long origId = Binder.clearCallingIdentity(); + + int N = mHistory.size(); + TaskRecord lastTask = null; + for (int i=0; i<N; i++) { + HistoryRecord r = (HistoryRecord)mHistory.get(i); + if (r.realActivity.equals(className) + && r != token && lastTask != r.task) { + if (finishActivityLocked(r, i, Activity.RESULT_CANCELED, + null, "others")) { + i--; + N--; + } + } + lastTask = r.task; + } + + Binder.restoreCallingIdentity(origId); + } + } + + // ========================================================= + // THUMBNAILS + // ========================================================= + + public void reportThumbnail(IBinder token, + Bitmap thumbnail, CharSequence description) { + //System.out.println("Report thumbnail for " + token + ": " + thumbnail); + final long origId = Binder.clearCallingIdentity(); + sendPendingThumbnail(null, token, thumbnail, description, true); + Binder.restoreCallingIdentity(origId); + } + + final void sendPendingThumbnail(HistoryRecord r, IBinder token, + Bitmap thumbnail, CharSequence description, boolean always) { + TaskRecord task = null; + ArrayList receivers = null; + + //System.out.println("Send pending thumbnail: " + r); + + synchronized(this) { + if (r == null) { + int index = indexOfTokenLocked(token, false); + if (index < 0) { + return; + } + r = (HistoryRecord)mHistory.get(index); + } + if (thumbnail == null) { + thumbnail = r.thumbnail; + description = r.description; + } + if (thumbnail == null && !always) { + // If there is no thumbnail, and this entry is not actually + // going away, then abort for now and pick up the next + // thumbnail we get. + return; + } + task = r.task; + + int N = mPendingThumbnails.size(); + int i=0; + while (i<N) { + PendingThumbnailsRecord pr = + (PendingThumbnailsRecord)mPendingThumbnails.get(i); + //System.out.println("Looking in " + pr.pendingRecords); + if (pr.pendingRecords.remove(r)) { + if (receivers == null) { + receivers = new ArrayList(); + } + receivers.add(pr); + if (pr.pendingRecords.size() == 0) { + pr.finished = true; + mPendingThumbnails.remove(i); + N--; + continue; + } + } + i++; + } + } + + if (receivers != null) { + final int N = receivers.size(); + for (int i=0; i<N; i++) { + try { + PendingThumbnailsRecord pr = + (PendingThumbnailsRecord)receivers.get(i); + pr.receiver.newThumbnail( + task != null ? task.taskId : -1, thumbnail, description); + if (pr.finished) { + pr.receiver.finished(); + } + } catch (Exception e) { + Log.w(TAG, "Exception thrown when sending thumbnail", e); + } + } + } + } + + // ========================================================= + // CONTENT PROVIDERS + // ========================================================= + + private final List generateApplicationProvidersLocked(ProcessRecord app) { + List providers = null; + try { + providers = ActivityThread.getPackageManager(). + queryContentProviders(app.processName, app.info.uid, + PackageManager.GET_SHARED_LIBRARY_FILES + | PackageManager.GET_URI_PERMISSION_PATTERNS); + } catch (RemoteException ex) { + } + if (providers != null) { + final int N = providers.size(); + for (int i=0; i<N; i++) { + ProviderInfo cpi = + (ProviderInfo)providers.get(i); + ContentProviderRecord cpr = + (ContentProviderRecord)mProvidersByClass.get(cpi.name); + if (cpr == null) { + cpr = new ContentProviderRecord(cpi, app.info); + mProvidersByClass.put(cpi.name, cpr); + } + app.pubProviders.put(cpi.name, cpr); + app.addPackage(cpi.applicationInfo.packageName); + } + } + return providers; + } + + private final String checkContentProviderPermissionLocked( + ProviderInfo cpi, ProcessRecord r, int mode) { + final int callingPid = (r != null) ? r.pid : Binder.getCallingPid(); + final int callingUid = (r != null) ? r.info.uid : Binder.getCallingUid(); + if (checkComponentPermission(cpi.readPermission, callingPid, callingUid, + cpi.exported ? -1 : cpi.applicationInfo.uid) + == PackageManager.PERMISSION_GRANTED + && mode == ParcelFileDescriptor.MODE_READ_ONLY || mode == -1) { + return null; + } + if (checkComponentPermission(cpi.writePermission, callingPid, callingUid, + cpi.exported ? -1 : cpi.applicationInfo.uid) + == PackageManager.PERMISSION_GRANTED) { + return null; + } + String msg = "Permission Denial: opening provider " + cpi.name + + " from " + (r != null ? r : "(null)") + " (pid=" + callingPid + + ", uid=" + callingUid + ") requires " + + cpi.readPermission + " or " + cpi.writePermission; + Log.w(TAG, msg); + return msg; + } + + private final ContentProviderHolder getContentProviderImpl( + IApplicationThread caller, String name) { + ContentProviderRecord cpr; + ProviderInfo cpi = null; + + synchronized(this) { + ProcessRecord r = null; + if (caller != null) { + r = getRecordForAppLocked(caller); + if (r == null) { + throw new SecurityException( + "Unable to find app for caller " + caller + + " (pid=" + Binder.getCallingPid() + + ") when getting content provider " + name); + } + } + + // First check if this content provider has been published... + cpr = (ContentProviderRecord)mProvidersByName.get(name); + if (cpr != null) { + cpi = cpr.info; + if (checkContentProviderPermissionLocked(cpi, r, -1) != null) { + return new ContentProviderHolder(cpi, + cpi.readPermission != null + ? cpi.readPermission : cpi.writePermission); + } + + if (r != null && cpr.canRunHere(r)) { + // This provider has been published or is in the process + // of being published... but it is also allowed to run + // in the caller's process, so don't make a connection + // and just let the caller instantiate its own instance. + if (cpr.provider != null) { + // don't give caller the provider object, it needs + // to make its own. + cpr = new ContentProviderRecord(cpr); + } + return cpr; + } + + final long origId = Binder.clearCallingIdentity(); + + // In this case the provider is a single instance, so we can + // return it right away. + if (r != null) { + r.conProviders.add(cpr); + cpr.clients.add(r); + } else { + cpr.externals++; + } + + if (cpr.app != null) { + updateOomAdjLocked(cpr.app); + } + + Binder.restoreCallingIdentity(origId); + + } else { + try { + cpi = ActivityThread.getPackageManager(). + resolveContentProvider(name, PackageManager.GET_URI_PERMISSION_PATTERNS); + } catch (RemoteException ex) { + } + if (cpi == null) { + return null; + } + + if (checkContentProviderPermissionLocked(cpi, r, -1) != null) { + return new ContentProviderHolder(cpi, + cpi.readPermission != null + ? cpi.readPermission : cpi.writePermission); + } + + cpr = (ContentProviderRecord)mProvidersByClass.get(cpi.name); + final boolean firstClass = cpr == null; + if (firstClass) { + try { + ApplicationInfo ai = + ActivityThread.getPackageManager(). + getApplicationInfo( + cpi.applicationInfo.packageName, + PackageManager.GET_SHARED_LIBRARY_FILES); + if (ai == null) { + Log.w(TAG, "No package info for content provider " + + cpi.name); + return null; + } + cpr = new ContentProviderRecord(cpi, ai); + } catch (RemoteException ex) { + // pm is in same process, this will never happen. + } + } + + if (r != null && cpr.canRunHere(r)) { + // If this is a multiprocess provider, then just return its + // info and allow the caller to instantiate it. Only do + // this if the provider is the same user as the caller's + // process, or can run as root (so can be in any process). + return cpr; + } + + if (false) { + RuntimeException e = new RuntimeException("foo"); + //Log.w(TAG, "LAUNCHING REMOTE PROVIDER (myuid " + r.info.uid + // + " pruid " + ai.uid + "): " + cpi.className, e); + } + + // This is single process, and our app is now connecting to it. + // See if we are already in the process of launching this + // provider. + final int N = mLaunchingProviders.size(); + int i; + for (i=0; i<N; i++) { + if (mLaunchingProviders.get(i) == cpr) { + break; + } + if (false) { + final ContentProviderRecord rec = + (ContentProviderRecord)mLaunchingProviders.get(i); + if (rec.info.name.equals(cpr.info.name)) { + cpr = rec; + break; + } + } + } + + // If the provider is not already being launched, then get it + // started. + if (i >= N) { + final long origId = Binder.clearCallingIdentity(); + ProcessRecord proc = startProcessLocked(cpi.processName, + cpr.appInfo, false, 0, "content provider", + new ComponentName(cpi.applicationInfo.packageName, + cpi.name)); + if (proc == null) { + Log.w(TAG, "Unable to launch app " + + cpi.applicationInfo.packageName + "/" + + cpi.applicationInfo.uid + " for provider " + + name + ": process is bad"); + return null; + } + cpr.launchingApp = proc; + mLaunchingProviders.add(cpr); + Binder.restoreCallingIdentity(origId); + } + + // Make sure the provider is published (the same provider class + // may be published under multiple names). + if (firstClass) { + mProvidersByClass.put(cpi.name, cpr); + } + mProvidersByName.put(name, cpr); + + if (r != null) { + r.conProviders.add(cpr); + cpr.clients.add(r); + } else { + cpr.externals++; + } + } + } + + // Wait for the provider to be published... + synchronized (cpr) { + while (cpr.provider == null) { + if (cpr.launchingApp == null) { + Log.w(TAG, "Unable to launch app " + + cpi.applicationInfo.packageName + "/" + + cpi.applicationInfo.uid + " for provider " + + name + ": launching app became null"); + EventLog.writeEvent(LOG_AM_PROVIDER_LOST_PROCESS, + cpi.applicationInfo.packageName, + cpi.applicationInfo.uid, name); + return null; + } + try { + cpr.wait(); + } catch (InterruptedException ex) { + } + } + } + return cpr; + } + + public final ContentProviderHolder getContentProvider( + IApplicationThread caller, String name) { + if (caller == null) { + String msg = "null IApplicationThread when getting content provider " + + name; + Log.w(TAG, msg); + throw new SecurityException(msg); + } + + return getContentProviderImpl(caller, name); + } + + private ContentProviderHolder getContentProviderExternal(String name) { + return getContentProviderImpl(null, name); + } + + /** + * Drop a content provider from a ProcessRecord's bookkeeping + * @param cpr + */ + public void removeContentProvider(IApplicationThread caller, String name) { + synchronized (this) { + ContentProviderRecord cpr = (ContentProviderRecord)mProvidersByName.get(name); + if(cpr == null) { + //remove from mProvidersByClass + if(localLOGV) Log.v(TAG, name+" content provider not found in providers list"); + return; + } + final ProcessRecord r = getRecordForAppLocked(caller); + if (r == null) { + throw new SecurityException( + "Unable to find app for caller " + caller + + " when removing content provider " + name); + } + //update content provider record entry info + ContentProviderRecord localCpr = (ContentProviderRecord) mProvidersByClass.get(cpr.info.name); + if(localLOGV) Log.v(TAG, "Removing content provider requested by "+ + r.info.processName+" from process "+localCpr.appInfo.processName); + if(localCpr.appInfo.processName == r.info.processName) { + //should not happen. taken care of as a local provider + if(localLOGV) Log.v(TAG, "local provider doing nothing Ignoring other names"); + return; + } else { + localCpr.clients.remove(r); + r.conProviders.remove(localCpr); + } + updateOomAdjLocked(); + } + } + + private void removeContentProviderExternal(String name) { + synchronized (this) { + ContentProviderRecord cpr = (ContentProviderRecord)mProvidersByName.get(name); + if(cpr == null) { + //remove from mProvidersByClass + if(localLOGV) Log.v(TAG, name+" content provider not found in providers list"); + return; + } + + //update content provider record entry info + ContentProviderRecord localCpr = (ContentProviderRecord) mProvidersByClass.get(cpr.info.name); + localCpr.externals--; + if (localCpr.externals < 0) { + Log.e(TAG, "Externals < 0 for content provider " + localCpr); + } + updateOomAdjLocked(); + } + } + + public final void publishContentProviders(IApplicationThread caller, + List<ContentProviderHolder> providers) { + if (providers == null) { + return; + } + + synchronized(this) { + final ProcessRecord r = getRecordForAppLocked(caller); + if (r == null) { + throw new SecurityException( + "Unable to find app for caller " + caller + + " (pid=" + Binder.getCallingPid() + + ") when publishing content providers"); + } + + final long origId = Binder.clearCallingIdentity(); + + final int N = providers.size(); + for (int i=0; i<N; i++) { + ContentProviderHolder src = providers.get(i); + if (src == null || src.info == null || src.provider == null) { + continue; + } + ContentProviderRecord dst = + (ContentProviderRecord)r.pubProviders.get(src.info.name); + if (dst != null) { + mProvidersByClass.put(dst.info.name, dst); + String names[] = dst.info.authority.split(";"); + for (int j = 0; j < names.length; j++) { + mProvidersByName.put(names[j], dst); + } + + int NL = mLaunchingProviders.size(); + int j; + for (j=0; j<NL; j++) { + if (mLaunchingProviders.get(j) == dst) { + mLaunchingProviders.remove(j); + j--; + NL--; + } + } + synchronized (dst) { + dst.provider = src.provider; + dst.app = r; + dst.notifyAll(); + } + updateOomAdjLocked(r); + } + } + + Binder.restoreCallingIdentity(origId); + } + } + + public static final void installSystemProviders() { + ProcessRecord app = mSelf.mProcessNames.get("system", Process.SYSTEM_UID); + List providers = mSelf.generateApplicationProvidersLocked(app); + mSystemThread.installSystemProviders(providers); + } + + // ========================================================= + // GLOBAL MANAGEMENT + // ========================================================= + + final ProcessRecord newProcessRecordLocked(IApplicationThread thread, + ApplicationInfo info, String customProcess) { + String proc = customProcess != null ? customProcess : info.processName; + BatteryStatsImpl.Uid.Proc ps = null; + BatteryStatsImpl stats = mBatteryStatsService.getActiveStatistics(); + synchronized (stats) { + ps = stats.getProcessStatsLocked(info.uid, proc); + } + return new ProcessRecord(ps, thread, info, proc); + } + + final ProcessRecord addAppLocked(ApplicationInfo info) { + ProcessRecord app = getProcessRecordLocked(info.processName, info.uid); + + if (app == null) { + app = newProcessRecordLocked(null, info, null); + mProcessNames.put(info.processName, info.uid, app); + updateLRUListLocked(app, true); + } + + if ((info.flags&(ApplicationInfo.FLAG_SYSTEM|ApplicationInfo.FLAG_PERSISTENT)) + == (ApplicationInfo.FLAG_SYSTEM|ApplicationInfo.FLAG_PERSISTENT)) { + app.persistent = true; + app.maxAdj = CORE_SERVER_ADJ; + } + if (app.thread == null && mPersistentStartingProcesses.indexOf(app) < 0) { + mPersistentStartingProcesses.add(app); + startProcessLocked(app, "added application", app.processName); + } + + return app; + } + + public void unhandledBack() { + enforceCallingPermission(android.Manifest.permission.FORCE_BACK, + "unhandledBack()"); + + synchronized(this) { + int count = mHistory.size(); + if (Config.LOGD) Log.d( + TAG, "Performing unhandledBack(): stack size = " + count); + if (count > 1) { + final long origId = Binder.clearCallingIdentity(); + finishActivityLocked((HistoryRecord)mHistory.get(count-1), + count-1, Activity.RESULT_CANCELED, null, "unhandled-back"); + Binder.restoreCallingIdentity(origId); + } + } + } + + public ParcelFileDescriptor openContentUri(Uri uri) throws RemoteException { + String name = uri.getAuthority(); + ContentProviderHolder cph = getContentProviderExternal(name); + ParcelFileDescriptor pfd = null; + if (cph != null) { + // We record the binder invoker's uid in thread-local storage before + // going to the content provider to open the file. Later, in the code + // that handles all permissions checks, we look for this uid and use + // that rather than the Activity Manager's own uid. The effect is that + // we do the check against the caller's permissions even though it looks + // to the content provider like the Activity Manager itself is making + // the request. + sCallerIdentity.set(new Identity( + Binder.getCallingPid(), Binder.getCallingUid())); + try { + pfd = cph.provider.openFile(uri, "r"); + } catch (FileNotFoundException e) { + // do nothing; pfd will be returned null + } finally { + // Ensure that whatever happens, we clean up the identity state + sCallerIdentity.remove(); + } + + // We've got the fd now, so we're done with the provider. + removeContentProviderExternal(name); + } else { + Log.d(TAG, "Failed to get provider for authority '" + name + "'"); + } + return pfd; + } + + public void goingToSleep() { + synchronized(this) { + mSleeping = true; + mWindowManager.setEventDispatching(false); + + if (mResumedActivity != null) { + pauseIfSleepingLocked(); + } else { + Log.w(TAG, "goingToSleep with no resumed activity!"); + } + } + } + + void pauseIfSleepingLocked() { + if (mSleeping) { + if (!mGoingToSleep.isHeld()) { + mGoingToSleep.acquire(); + if (mLaunchingActivity.isHeld()) { + mLaunchingActivity.release(); + mHandler.removeMessages(LAUNCH_TIMEOUT_MSG); + } + } + + // If we are not currently pausing an activity, get the current + // one to pause. If we are pausing one, we will just let that stuff + // run and release the wake lock when all done. + if (mPausingActivity == null) { + if (DEBUG_PAUSE) Log.v(TAG, "Sleep needs to pause..."); + if (DEBUG_USER_LEAVING) Log.v(TAG, "Sleep => pause with userLeaving=false"); + startPausingLocked(false, true); + } + } + } + + public void wakingUp() { + synchronized(this) { + if (mGoingToSleep.isHeld()) { + mGoingToSleep.release(); + } + mWindowManager.setEventDispatching(true); + mSleeping = false; + resumeTopActivityLocked(null); + } + } + + public void setDebugApp(String packageName, boolean waitForDebugger, + boolean persistent) { + enforceCallingPermission(android.Manifest.permission.SET_DEBUG_APP, + "setDebugApp()"); + + // Note that this is not really thread safe if there are multiple + // callers into it at the same time, but that's not a situation we + // care about. + if (persistent) { + final ContentResolver resolver = mContext.getContentResolver(); + Settings.System.putString( + resolver, Settings.System.DEBUG_APP, + packageName); + Settings.System.putInt( + resolver, Settings.System.WAIT_FOR_DEBUGGER, + waitForDebugger ? 1 : 0); + } + + synchronized (this) { + if (!persistent) { + mOrigDebugApp = mDebugApp; + mOrigWaitForDebugger = mWaitForDebugger; + } + mDebugApp = packageName; + mWaitForDebugger = waitForDebugger; + mDebugTransient = !persistent; + if (packageName != null) { + final long origId = Binder.clearCallingIdentity(); + uninstallPackageLocked(packageName, -1, false); + Binder.restoreCallingIdentity(origId); + } + } + } + + public void setAlwaysFinish(boolean enabled) { + enforceCallingPermission(android.Manifest.permission.SET_ALWAYS_FINISH, + "setAlwaysFinish()"); + + Settings.System.putInt( + mContext.getContentResolver(), + Settings.System.ALWAYS_FINISH_ACTIVITIES, enabled ? 1 : 0); + + synchronized (this) { + mAlwaysFinishActivities = enabled; + } + } + + public void setActivityWatcher(IActivityWatcher watcher) { + enforceCallingPermission(android.Manifest.permission.SET_ACTIVITY_WATCHER, + "setActivityWatcher()"); + synchronized (this) { + mWatcher = watcher; + } + } + + public final void enterSafeMode() { + synchronized(this) { + // It only makes sense to do this before the system is ready + // and started launching other packages. + if (!mSystemReady) { + try { + ActivityThread.getPackageManager().enterSafeMode(); + } catch (RemoteException e) { + } + + View v = LayoutInflater.from(mContext).inflate( + com.android.internal.R.layout.safe_mode, null); + WindowManager.LayoutParams lp = new WindowManager.LayoutParams(); + lp.type = WindowManager.LayoutParams.TYPE_SYSTEM_OVERLAY; + lp.width = WindowManager.LayoutParams.WRAP_CONTENT; + lp.height = WindowManager.LayoutParams.WRAP_CONTENT; + lp.gravity = Gravity.BOTTOM | Gravity.LEFT; + lp.format = v.getBackground().getOpacity(); + lp.flags = WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE + | WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE; + ((WindowManager)mContext.getSystemService( + Context.WINDOW_SERVICE)).addView(v, lp); + } + } + } + + public void noteWakeupAlarm(IIntentSender sender) { + if (!(sender instanceof PendingIntentRecord)) { + return; + } + BatteryStatsImpl stats = mBatteryStatsService.getActiveStatistics(); + synchronized (stats) { + if (mBatteryStatsService.isOnBattery()) { + mBatteryStatsService.enforceCallingPermission(); + PendingIntentRecord rec = (PendingIntentRecord)sender; + int MY_UID = Binder.getCallingUid(); + int uid = rec.uid == MY_UID ? Process.SYSTEM_UID : rec.uid; + BatteryStatsImpl.Uid.Pkg pkg = + stats.getPackageStatsLocked(uid, rec.key.packageName); + pkg.incWakeupsLocked(); + } + } + } + + public boolean killPidsForMemory(int[] pids) { + if (Binder.getCallingUid() != Process.SYSTEM_UID) { + throw new SecurityException("killPidsForMemory only available to the system"); + } + + // XXX Note: don't acquire main activity lock here, because the window + // manager calls in with its locks held. + + boolean killed = false; + synchronized (mPidsSelfLocked) { + int[] types = new int[pids.length]; + int worstType = 0; + for (int i=0; i<pids.length; i++) { + ProcessRecord proc = mPidsSelfLocked.get(pids[i]); + if (proc != null) { + int type = proc.setAdj; + types[i] = type; + if (type > worstType) { + worstType = type; + } + } + } + + // If the worse oom_adj is somewhere in the hidden proc LRU range, + // then constrain it so we will kill all hidden procs. + if (worstType < EMPTY_APP_ADJ && worstType > HIDDEN_APP_MIN_ADJ) { + worstType = HIDDEN_APP_MIN_ADJ; + } + Log.w(TAG, "Killing processes for memory at adjustment " + worstType); + for (int i=0; i<pids.length; i++) { + ProcessRecord proc = mPidsSelfLocked.get(pids[i]); + if (proc == null) { + continue; + } + int adj = proc.setAdj; + if (adj >= worstType) { + Log.w(TAG, "Killing for memory: " + proc + " (adj " + + adj + ")"); + EventLog.writeEvent(LOG_AM_KILL_FOR_MEMORY, proc.pid, + proc.processName, adj); + killed = true; + Process.killProcess(pids[i]); + } + } + } + return killed; + } + + public void reportPss(IApplicationThread caller, int pss) { + Watchdog.PssRequestor req; + String name; + ProcessRecord callerApp; + synchronized (this) { + if (caller == null) { + return; + } + callerApp = getRecordForAppLocked(caller); + if (callerApp == null) { + return; + } + callerApp.lastPss = pss; + req = callerApp; + name = callerApp.processName; + } + Watchdog.getInstance().reportPss(req, name, pss); + if (!callerApp.persistent) { + removeRequestedPss(callerApp); + } + } + + public void requestPss(Runnable completeCallback) { + ArrayList<ProcessRecord> procs; + synchronized (this) { + mRequestPssCallback = completeCallback; + mRequestPssList.clear(); + for (int i=mLRUProcesses.size()-1; i>=0; i--) { + ProcessRecord proc = mLRUProcesses.get(i); + if (!proc.persistent) { + mRequestPssList.add(proc); + } + } + procs = new ArrayList<ProcessRecord>(mRequestPssList); + } + + int oldPri = Process.getThreadPriority(Process.myTid()); + Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND); + for (int i=procs.size()-1; i>=0; i--) { + ProcessRecord proc = procs.get(i); + proc.lastPss = 0; + proc.requestPss(); + } + Process.setThreadPriority(oldPri); + } + + void removeRequestedPss(ProcessRecord proc) { + Runnable callback = null; + synchronized (this) { + if (mRequestPssList.remove(proc)) { + if (mRequestPssList.size() == 0) { + callback = mRequestPssCallback; + mRequestPssCallback = null; + } + } + } + + if (callback != null) { + callback.run(); + } + } + + public void collectPss(Watchdog.PssStats stats) { + stats.mEmptyPss = 0; + stats.mEmptyCount = 0; + stats.mBackgroundPss = 0; + stats.mBackgroundCount = 0; + stats.mServicePss = 0; + stats.mServiceCount = 0; + stats.mVisiblePss = 0; + stats.mVisibleCount = 0; + stats.mForegroundPss = 0; + stats.mForegroundCount = 0; + stats.mNoPssCount = 0; + synchronized (this) { + int i; + int NPD = mProcDeaths.length < stats.mProcDeaths.length + ? mProcDeaths.length : stats.mProcDeaths.length; + int aggr = 0; + for (i=0; i<NPD; i++) { + aggr += mProcDeaths[i]; + stats.mProcDeaths[i] = aggr; + } + while (i<stats.mProcDeaths.length) { + stats.mProcDeaths[i] = 0; + i++; + } + + for (i=mLRUProcesses.size()-1; i>=0; i--) { + ProcessRecord proc = mLRUProcesses.get(i); + if (proc.persistent) { + continue; + } + //Log.i(TAG, "Proc " + proc + ": pss=" + proc.lastPss); + if (proc.lastPss == 0) { + stats.mNoPssCount++; + continue; + } + if (proc.setAdj == EMPTY_APP_ADJ) { + stats.mEmptyPss += proc.lastPss; + stats.mEmptyCount++; + } else if (proc.setAdj == CONTENT_PROVIDER_ADJ) { + stats.mEmptyPss += proc.lastPss; + stats.mEmptyCount++; + } else if (proc.setAdj >= HIDDEN_APP_MIN_ADJ) { + stats.mBackgroundPss += proc.lastPss; + stats.mBackgroundCount++; + } else if (proc.setAdj >= VISIBLE_APP_ADJ) { + stats.mVisiblePss += proc.lastPss; + stats.mVisibleCount++; + } else { + stats.mForegroundPss += proc.lastPss; + stats.mForegroundCount++; + } + } + } + } + + public final void startRunning(String pkg, String cls, String action, + String data) { + synchronized(this) { + if (mStartRunning) { + return; + } + mStartRunning = true; + mTopComponent = pkg != null && cls != null + ? new ComponentName(pkg, cls) : null; + mTopAction = action != null ? action : Intent.ACTION_MAIN; + mTopData = data; + if (!mSystemReady) { + return; + } + } + + systemReady(); + } + + private void retrieveSettings() { + final ContentResolver resolver = mContext.getContentResolver(); + String debugApp = Settings.System.getString( + resolver, Settings.System.DEBUG_APP); + boolean waitForDebugger = Settings.System.getInt( + resolver, Settings.System.WAIT_FOR_DEBUGGER, 0) != 0; + boolean alwaysFinishActivities = Settings.System.getInt( + resolver, Settings.System.ALWAYS_FINISH_ACTIVITIES, 0) != 0; + + Configuration configuration = new Configuration(); + Settings.System.getConfiguration(resolver, configuration); + + synchronized (this) { + mDebugApp = mOrigDebugApp = debugApp; + mWaitForDebugger = mOrigWaitForDebugger = waitForDebugger; + mAlwaysFinishActivities = alwaysFinishActivities; + // This happens before any activities are started, so we can + // change mConfiguration in-place. + mConfiguration.updateFrom(configuration); + } + } + + public boolean testIsSystemReady() { + // no need to synchronize(this) just to read & return the value + return mSystemReady; + } + + public void systemReady() { + // In the simulator, startRunning will never have been called, which + // normally sets a few crucial variables. Do it here instead. + if (!Process.supportsProcesses()) { + mStartRunning = true; + mTopAction = Intent.ACTION_MAIN; + } + + synchronized(this) { + if (mSystemReady) { + return; + } + mSystemReady = true; + if (!mStartRunning) { + return; + } + } + + if (Config.LOGD) Log.d(TAG, "Start running!"); + EventLog.writeEvent(LOG_BOOT_PROGRESS_AMS_READY, + SystemClock.uptimeMillis()); + + synchronized(this) { + if (mFactoryTest == SystemServer.FACTORY_TEST_LOW_LEVEL) { + ResolveInfo ri = mContext.getPackageManager() + .resolveActivity(new Intent(Intent.ACTION_FACTORY_TEST), + 0); + CharSequence errorMsg = null; + if (ri != null) { + ActivityInfo ai = ri.activityInfo; + ApplicationInfo app = ai.applicationInfo; + if ((app.flags&ApplicationInfo.FLAG_SYSTEM) != 0) { + mTopAction = Intent.ACTION_FACTORY_TEST; + mTopData = null; + mTopComponent = new ComponentName(app.packageName, + ai.name); + } else { + errorMsg = mContext.getResources().getText( + com.android.internal.R.string.factorytest_not_system); + } + } else { + errorMsg = mContext.getResources().getText( + com.android.internal.R.string.factorytest_no_action); + } + if (errorMsg != null) { + mTopAction = null; + mTopData = null; + mTopComponent = null; + Message msg = Message.obtain(); + msg.what = SHOW_FACTORY_ERROR_MSG; + msg.getData().putCharSequence("msg", errorMsg); + mHandler.sendMessage(msg); + } + } + } + + retrieveSettings(); + + synchronized (this) { + if (mFactoryTest != SystemServer.FACTORY_TEST_LOW_LEVEL) { + try { + List apps = ActivityThread.getPackageManager(). + getPersistentApplications(PackageManager.GET_SHARED_LIBRARY_FILES); + if (apps != null) { + int N = apps.size(); + int i; + for (i=0; i<N; i++) { + ApplicationInfo info + = (ApplicationInfo)apps.get(i); + if (info != null && + !info.packageName.equals("android")) { + addAppLocked(info); + } + } + } + } catch (RemoteException ex) { + // pm is in same process, this will never happen. + } + } + + try { + if (ActivityThread.getPackageManager().hasSystemUidErrors()) { + Message msg = Message.obtain(); + msg.what = SHOW_UID_ERROR_MSG; + mHandler.sendMessage(msg); + } + } catch (RemoteException e) { + } + + // Start up initial activity. + mBooting = true; + resumeTopActivityLocked(null); + } + } + + boolean makeAppCrashingLocked(ProcessRecord app, + String tag, String shortMsg, String longMsg, byte[] crashData) { + app.crashing = true; + app.crashingReport = generateProcessError(app, + ActivityManager.ProcessErrorStateInfo.CRASHED, tag, shortMsg, longMsg, crashData); + startAppProblemLocked(app); + app.stopFreezingAllLocked(); + return handleAppCrashLocked(app); + } + + void makeAppNotRespondingLocked(ProcessRecord app, + String tag, String shortMsg, String longMsg, byte[] crashData) { + app.notResponding = true; + app.notRespondingReport = generateProcessError(app, + ActivityManager.ProcessErrorStateInfo.NOT_RESPONDING, tag, shortMsg, longMsg, + crashData); + startAppProblemLocked(app); + app.stopFreezingAllLocked(); + } + + /** + * Generate a process error record, suitable for attachment to a ProcessRecord. + * + * @param app The ProcessRecord in which the error occurred. + * @param condition Crashing, Application Not Responding, etc. Values are defined in + * ActivityManager.AppErrorStateInfo + * @param tag The tag that was passed into handleApplicationError(). Typically the classname. + * @param shortMsg Short message describing the crash. + * @param longMsg Long message describing the crash. + * @param crashData Raw data passed into handleApplicationError(). Typically a stack trace. + * + * @return Returns a fully-formed AppErrorStateInfo record. + */ + private ActivityManager.ProcessErrorStateInfo generateProcessError(ProcessRecord app, + int condition, String tag, String shortMsg, String longMsg, byte[] crashData) { + ActivityManager.ProcessErrorStateInfo report = new ActivityManager.ProcessErrorStateInfo(); + + report.condition = condition; + report.processName = app.processName; + report.pid = app.pid; + report.uid = app.info.uid; + report.tag = tag; + report.shortMsg = shortMsg; + report.longMsg = longMsg; + report.crashData = crashData; + + return report; + } + + void killAppAtUsersRequest(ProcessRecord app, Dialog fromDialog, + boolean crashed) { + synchronized (this) { + app.crashing = false; + app.crashingReport = null; + app.notResponding = false; + app.notRespondingReport = null; + if (app.anrDialog == fromDialog) { + app.anrDialog = null; + } + if (app.waitDialog == fromDialog) { + app.waitDialog = null; + } + if (app.pid > 0 && app.pid != MY_PID) { + if (crashed) { + handleAppCrashLocked(app); + } + Log.i(ActivityManagerService.TAG, "Killing process " + + app.processName + + " (pid=" + app.pid + ") at user's request"); + Process.killProcess(app.pid); + } + + } + } + + boolean handleAppCrashLocked(ProcessRecord app) { + long now = SystemClock.uptimeMillis(); + + Long crashTime = mProcessCrashTimes.get(app.info.processName, + app.info.uid); + if (crashTime != null && now < crashTime+MIN_CRASH_INTERVAL) { + // This process loses! + Log.w(TAG, "Process " + app.info.processName + + " has crashed too many times: killing!"); + EventLog.writeEvent(LOG_AM_PROCESS_CRASHED_TOO_MUCH, + app.info.processName, app.info.uid); + killServicesLocked(app, false); + for (int i=mHistory.size()-1; i>=0; i--) { + HistoryRecord r = (HistoryRecord)mHistory.get(i); + if (r.app == app) { + if (Config.LOGD) Log.d( + TAG, " Force finishing activity " + + r.intent.getComponent().flattenToShortString()); + finishActivityLocked(r, i, Activity.RESULT_CANCELED, null, "crashed"); + } + } + if (!app.persistent) { + // We don't want to start this process again until the user + // explicitly does so... but for persistent process, we really + // need to keep it running. If a persistent process is actually + // repeatedly crashing, then badness for everyone. + EventLog.writeEvent(LOG_AM_PROCESS_BAD, app.info.uid, + app.info.processName); + mBadProcesses.put(app.info.processName, app.info.uid, now); + app.bad = true; + mProcessCrashTimes.remove(app.info.processName, app.info.uid); + app.removed = true; + removeProcessLocked(app, false); + return false; + } + } + + // Bump up the crash count of any services currently running in the proc. + if (app.services.size() != 0) { + // Any services running in the application need to be placed + // back in the pending list. + Iterator it = app.services.iterator(); + while (it.hasNext()) { + ServiceRecord sr = (ServiceRecord)it.next(); + sr.crashCount++; + } + } + + mProcessCrashTimes.put(app.info.processName, app.info.uid, now); + return true; + } + + void startAppProblemLocked(ProcessRecord app) { + skipCurrentReceiverLocked(app); + } + + void skipCurrentReceiverLocked(ProcessRecord app) { + boolean reschedule = false; + BroadcastRecord r = app.curReceiver; + if (r != null) { + // The current broadcast is waiting for this app's receiver + // to be finished. Looks like that's not going to happen, so + // let the broadcast continue. + logBroadcastReceiverDiscard(r); + finishReceiverLocked(r.receiver, r.resultCode, r.resultData, + r.resultExtras, r.resultAbort, true); + reschedule = true; + } + r = mPendingBroadcast; + if (r != null && r.curApp == app) { + if (DEBUG_BROADCAST) Log.v(TAG, + "skip & discard pending app " + r); + logBroadcastReceiverDiscard(r); + finishReceiverLocked(r.receiver, r.resultCode, r.resultData, + r.resultExtras, r.resultAbort, true); + reschedule = true; + } + if (reschedule) { + scheduleBroadcastsLocked(); + } + } + + public int handleApplicationError(IBinder app, int flags, + String tag, String shortMsg, String longMsg, byte[] crashData) { + AppErrorResult result = new AppErrorResult(); + + ProcessRecord r = null; + synchronized (this) { + if (app != null) { + for (SparseArray<ProcessRecord> apps : mProcessNames.getMap().values()) { + final int NA = apps.size(); + for (int ia=0; ia<NA; ia++) { + ProcessRecord p = apps.valueAt(ia); + if (p.thread != null && p.thread.asBinder() == app) { + r = p; + break; + } + } + } + } + + if (r != null) { + // The application has crashed. Send the SIGQUIT to the process so + // that it can dump its state. + Process.sendSignal(r.pid, Process.SIGNAL_QUIT); + //Log.i(TAG, "Current system threads:"); + //Process.sendSignal(MY_PID, Process.SIGNAL_QUIT); + } + + if (mWatcher != null) { + try { + String name = r != null ? r.processName : null; + int pid = r != null ? r.pid : Binder.getCallingPid(); + if (!mWatcher.appCrashed(name, pid, + shortMsg, longMsg, crashData)) { + Log.w(TAG, "Force-killing crashed app " + name + + " at watcher's request"); + Process.killProcess(pid); + return 0; + } + } catch (RemoteException e) { + mWatcher = null; + } + } + + final long origId = Binder.clearCallingIdentity(); + + // If this process is running instrumentation, finish it. + if (r != null && r.instrumentationClass != null) { + Log.w(TAG, "Error in app " + r.processName + + " running instrumentation " + r.instrumentationClass + ":"); + if (shortMsg != null) Log.w(TAG, " " + shortMsg); + if (longMsg != null) Log.w(TAG, " " + longMsg); + Bundle info = new Bundle(); + info.putString("shortMsg", shortMsg); + info.putString("longMsg", longMsg); + finishInstrumentationLocked(r, Activity.RESULT_CANCELED, info); + Binder.restoreCallingIdentity(origId); + return 0; + } + + if (r != null) { + if (!makeAppCrashingLocked(r, tag, shortMsg, longMsg, crashData)) { + return 0; + } + } else { + Log.w(TAG, "Some application object " + app + " tag " + tag + + " has crashed, but I don't know who it is."); + Log.w(TAG, "ShortMsg:" + shortMsg); + Log.w(TAG, "LongMsg:" + longMsg); + Binder.restoreCallingIdentity(origId); + return 0; + } + + Message msg = Message.obtain(); + msg.what = SHOW_ERROR_MSG; + HashMap data = new HashMap(); + data.put("result", result); + data.put("app", r); + data.put("flags", flags); + data.put("shortMsg", shortMsg); + data.put("longMsg", longMsg); + if (r != null && (r.info.flags&ApplicationInfo.FLAG_SYSTEM) != 0) { + // For system processes, submit crash data to the server. + data.put("crashData", crashData); + } + msg.obj = data; + mHandler.sendMessage(msg); + + Binder.restoreCallingIdentity(origId); + } + + int res = result.get(); + + synchronized (this) { + if (r != null) { + mProcessCrashTimes.put(r.info.processName, r.info.uid, + SystemClock.uptimeMillis()); + } + } + + return res; + } + + public List<ActivityManager.ProcessErrorStateInfo> getProcessesInErrorState() { + // assume our apps are happy - lazy create the list + List<ActivityManager.ProcessErrorStateInfo> errList = null; + + synchronized (this) { + + // iterate across all processes + final int N = mLRUProcesses.size(); + for (int i = 0; i < N; i++) { + ProcessRecord app = mLRUProcesses.get(i); + if ((app.thread != null) && (app.crashing || app.notResponding)) { + // This one's in trouble, so we'll generate a report for it + // crashes are higher priority (in case there's a crash *and* an anr) + ActivityManager.ProcessErrorStateInfo report = null; + if (app.crashing) { + report = app.crashingReport; + } else if (app.notResponding) { + report = app.notRespondingReport; + } + + if (report != null) { + if (errList == null) { + errList = new ArrayList<ActivityManager.ProcessErrorStateInfo>(1); + } + errList.add(report); + } else { + Log.w(TAG, "Missing app error report, app = " + app.processName + + " crashing = " + app.crashing + + " notResponding = " + app.notResponding); + } + } + } + } + + return errList; + } + + public List<ActivityManager.RunningAppProcessInfo> getRunningAppProcesses() { + // Lazy instantiation of list + List<ActivityManager.RunningAppProcessInfo> runList = null; + synchronized (this) { + // Iterate across all processes + final int N = mLRUProcesses.size(); + for (int i = 0; i < N; i++) { + ProcessRecord app = mLRUProcesses.get(i); + if ((app.thread != null) && (!app.crashing && !app.notResponding)) { + // Generate process state info for running application + ActivityManager.RunningAppProcessInfo currApp = + new ActivityManager.RunningAppProcessInfo(app.processName, + app.pid, app.getPackageList()); + int adj = app.curAdj; + if (adj >= CONTENT_PROVIDER_ADJ) { + currApp.importance = ActivityManager.RunningAppProcessInfo.IMPORTANCE_EMPTY; + } else if (adj >= HIDDEN_APP_MIN_ADJ) { + currApp.importance = ActivityManager.RunningAppProcessInfo.IMPORTANCE_BACKGROUND; + currApp.lru = adj - HIDDEN_APP_MIN_ADJ; + } else if (adj >= SECONDARY_SERVER_ADJ) { + currApp.importance = ActivityManager.RunningAppProcessInfo.IMPORTANCE_SERVICE; + } else if (adj >= VISIBLE_APP_ADJ) { + currApp.importance = ActivityManager.RunningAppProcessInfo.IMPORTANCE_VISIBLE; + } else { + currApp.importance = ActivityManager.RunningAppProcessInfo.IMPORTANCE_FOREGROUND; + } + //Log.v(TAG, "Proc " + app.processName + ": imp=" + currApp.importance + // + " lru=" + currApp.lru); + if (runList == null) { + runList = new ArrayList<ActivityManager.RunningAppProcessInfo>(); + } + runList.add(currApp); + } + } + } + return runList; + } + + @Override + protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) { + synchronized (this) { + if (checkCallingPermission(android.Manifest.permission.DUMP) + != PackageManager.PERMISSION_GRANTED) { + pw.println("Permission Denial: can't dump ActivityManager from from pid=" + + Binder.getCallingPid() + + ", uid=" + Binder.getCallingUid() + + " without permission " + + android.Manifest.permission.DUMP); + return; + } + if (args.length != 0 && "service".equals(args[0])) { + dumpService(fd, pw, args); + return; + } + pw.println("Activities in Current Activity Manager State:"); + dumpHistoryList(pw, mHistory, " ", "History"); + pw.println(" "); + pw.println(" Running activities (most recent first):"); + dumpHistoryList(pw, mLRUActivities, " ", "Running"); + if (mWaitingVisibleActivities.size() > 0) { + pw.println(" "); + pw.println(" Activities waiting for another to become visible:"); + dumpHistoryList(pw, mWaitingVisibleActivities, " ", "Waiting"); + } + if (mStoppingActivities.size() > 0) { + pw.println(" "); + pw.println(" Activities waiting to stop:"); + dumpHistoryList(pw, mStoppingActivities, " ", "Stopping"); + } + if (mFinishingActivities.size() > 0) { + pw.println(" "); + pw.println(" Activities waiting to finish:"); + dumpHistoryList(pw, mFinishingActivities, " ", "Finishing"); + } + + pw.println(" "); + pw.println(" mPausingActivity: " + mPausingActivity); + pw.println(" mResumedActivity: " + mResumedActivity); + pw.println(" mFocusedActivity: " + mFocusedActivity); + pw.println(" mLastPausedActivity: " + mLastPausedActivity); + + if (mRecentTasks.size() > 0) { + pw.println(" "); + pw.println("Recent tasks in Current Activity Manager State:"); + + final int N = mRecentTasks.size(); + for (int i=0; i<N; i++) { + pw.println(" Recent Task #" + i); + mRecentTasks.get(i).dump(pw, " "); + } + } + + pw.println(" "); + pw.println(" mCurTask: " + mCurTask); + + pw.println(" "); + pw.println("Processes in Current Activity Manager State:"); + + boolean needSep = false; + int numPers = 0; + + for (SparseArray<ProcessRecord> procs : mProcessNames.getMap().values()) { + final int NA = procs.size(); + for (int ia=0; ia<NA; ia++) { + if (!needSep) { + pw.println(" All known processes:"); + needSep = true; + } + ProcessRecord r = procs.valueAt(ia); + pw.println((r.persistent ? " *PERSISTENT* Process [" : " Process [") + + r.processName + "] UID " + procs.keyAt(ia)); + r.dump(pw, " "); + if (r.persistent) { + numPers++; + } + } + } + + if (mLRUProcesses.size() > 0) { + if (needSep) pw.println(" "); + needSep = true; + pw.println(" Running processes (most recent first):"); + dumpProcessList(pw, mLRUProcesses, " ", + "Running Norm Proc", "Running PERS Proc", true); + needSep = true; + } + + synchronized (mPidsSelfLocked) { + if (mPidsSelfLocked.size() > 0) { + if (needSep) pw.println(" "); + needSep = true; + pw.println(" PID mappings:"); + for (int i=0; i<mPidsSelfLocked.size(); i++) { + pw.println(" PID #" + mPidsSelfLocked.keyAt(i) + + ": " + mPidsSelfLocked.valueAt(i)); + } + } + } + + if (mForegroundProcesses.size() > 0) { + if (needSep) pw.println(" "); + needSep = true; + pw.println(" Foreground Processes:"); + for (int i=0; i<mForegroundProcesses.size(); i++) { + pw.println(" PID #" + mForegroundProcesses.keyAt(i) + + ": " + mForegroundProcesses.valueAt(i)); + } + } + + if (mPersistentStartingProcesses.size() > 0) { + if (needSep) pw.println(" "); + needSep = true; + pw.println(" Persisent processes that are starting:"); + dumpProcessList(pw, mPersistentStartingProcesses, " ", + "Starting Initial Proc", "Restarting PERS Proc", false); + } + + if (mStartingProcesses.size() > 0) { + if (needSep) pw.println(" "); + needSep = true; + pw.println(" Processes that are starting:"); + dumpProcessList(pw, mStartingProcesses, " ", + "Starting Norm Proc", "Starting PERS Proc", false); + } + + if (mRemovedProcesses.size() > 0) { + if (needSep) pw.println(" "); + needSep = true; + pw.println(" Processes that are being removed:"); + dumpProcessList(pw, mRemovedProcesses, " ", + "Removed Norm Proc", "Removed PERS Proc", false); + } + + if (mProcessesOnHold.size() > 0) { + if (needSep) pw.println(" "); + needSep = true; + pw.println(" Processes that are on old until the system is ready:"); + dumpProcessList(pw, mProcessesOnHold, " ", + "OnHold Norm Proc", "OnHold PERS Proc", false); + } + + if (mProcessCrashTimes.getMap().size() > 0) { + if (needSep) pw.println(" "); + needSep = true; + pw.println(" Time since processes crashed:"); + long now = SystemClock.uptimeMillis(); + for (Map.Entry<String, SparseArray<Long>> procs + : mProcessCrashTimes.getMap().entrySet()) { + SparseArray<Long> uids = procs.getValue(); + final int N = uids.size(); + for (int i=0; i<N; i++) { + pw.println(" Process " + procs.getKey() + + " uid " + uids.keyAt(i) + + ": last crashed " + + (now-uids.valueAt(i)) + " ms ago"); + } + } + } + + if (mBadProcesses.getMap().size() > 0) { + if (needSep) pw.println(" "); + needSep = true; + pw.println(" Bad processes:"); + for (Map.Entry<String, SparseArray<Long>> procs + : mBadProcesses.getMap().entrySet()) { + SparseArray<Long> uids = procs.getValue(); + final int N = uids.size(); + for (int i=0; i<N; i++) { + pw.println(" Bad process " + procs.getKey() + + " uid " + uids.keyAt(i) + + ": crashed at time " + uids.valueAt(i)); + } + } + } + + pw.println(" "); + pw.println(" Total persistent processes: " + numPers); + pw.println(" mConfiguration: " + mConfiguration); + pw.println(" mStartRunning=" + mStartRunning + + " mSystemReady=" + mSystemReady + + " mBooting=" + mBooting + + " mBooted=" + mBooted + + " mFactoryTest=" + mFactoryTest); + pw.println(" mSleeping=" + mSleeping); + pw.println(" mGoingToSleep=" + mGoingToSleep); + pw.println(" mLaunchingActivity=" + mLaunchingActivity); + pw.println(" mDebugApp=" + mDebugApp + "/orig=" + mOrigDebugApp + + " mDebugTransient=" + mDebugTransient + + " mOrigWaitForDebugger=" + mOrigWaitForDebugger); + pw.println(" mAlwaysFinishActivities=" + mAlwaysFinishActivities + + " mWatcher=" + mWatcher); + } + } + + /** + * There are three ways to call this: + * - no service specified: dump all the services + * - a flattened component name that matched an existing service was specified as the + * first arg: dump that one service + * - the first arg isn't the flattened component name of an existing service: + * dump all services whose component contains the first arg as a substring + */ + protected void dumpService(FileDescriptor fd, PrintWriter pw, String[] args) { + String[] newArgs; + String componentNameString; + ServiceRecord r; + if (args.length == 1) { + componentNameString = null; + newArgs = EMPTY_STRING_ARRAY; + r = null; + } else { + componentNameString = args[1]; + ComponentName componentName = ComponentName.unflattenFromString(componentNameString); + r = componentName != null ? mServices.get(componentName) : null; + newArgs = new String[args.length - 2]; + if (args.length > 2) System.arraycopy(args, 2, newArgs, 0, args.length - 2); + } + + if (r != null) { + dumpService(fd, pw, r, newArgs); + } else { + for (ServiceRecord r1 : mServices.values()) { + if (componentNameString == null + || r1.name.flattenToString().contains(componentNameString)) { + dumpService(fd, pw, r1, newArgs); + } + } + } + } + + /** + * Invokes IApplicationThread.dumpService() on the thread of the specified service if + * there is a thread associated with the service. + */ + private void dumpService(FileDescriptor fd, PrintWriter pw, ServiceRecord r, String[] args) { + pw.println(" Service " + r.name.flattenToString()); + if (r.app != null && r.app.thread != null) { + try { + // flush anything that is already in the PrintWriter since the thread is going + // to write to the file descriptor directly + pw.flush(); + r.app.thread.dumpService(fd, r, args); + pw.print("\n"); + } catch (RemoteException e) { + pw.println("got a RemoteException while dumping the service"); + } + } + } + + void dumpBroadcasts(PrintWriter pw) { + synchronized (this) { + if (checkCallingPermission(android.Manifest.permission.DUMP) + != PackageManager.PERMISSION_GRANTED) { + pw.println("Permission Denial: can't dump ActivityManager from from pid=" + + Binder.getCallingPid() + + ", uid=" + Binder.getCallingUid() + + " without permission " + + android.Manifest.permission.DUMP); + return; + } + pw.println("Broadcasts in Current Activity Manager State:"); + + if (mRegisteredReceivers.size() > 0) { + pw.println(" "); + pw.println(" Registered Receivers:"); + Iterator it = mRegisteredReceivers.values().iterator(); + while (it.hasNext()) { + ReceiverList r = (ReceiverList)it.next(); + pw.println(" Receiver " + r.receiver); + r.dump(pw, " "); + } + } + + pw.println(" "); + pw.println("Receiver Resolver Table:"); + mReceiverResolver.dump(new PrintWriterPrinter(pw), " "); + + if (mParallelBroadcasts.size() > 0 || mOrderedBroadcasts.size() > 0 + || mPendingBroadcast != null) { + if (mParallelBroadcasts.size() > 0) { + pw.println(" "); + pw.println(" Active broadcasts:"); + } + for (int i=mParallelBroadcasts.size()-1; i>=0; i--) { + pw.println(" Broadcast #" + i + ":"); + mParallelBroadcasts.get(i).dump(pw, " "); + } + if (mOrderedBroadcasts.size() > 0) { + pw.println(" "); + pw.println(" Active serialized broadcasts:"); + } + for (int i=mOrderedBroadcasts.size()-1; i>=0; i--) { + pw.println(" Serialized Broadcast #" + i + ":"); + mOrderedBroadcasts.get(i).dump(pw, " "); + } + pw.println(" "); + pw.println(" Pending broadcast:"); + if (mPendingBroadcast != null) { + mPendingBroadcast.dump(pw, " "); + } else { + pw.println(" (null)"); + } + } + + pw.println(" "); + pw.println(" mBroadcastsScheduled=" + mBroadcastsScheduled); + if (mStickyBroadcasts != null) { + pw.println(" "); + pw.println(" Sticky broadcasts:"); + for (Map.Entry<String, ArrayList<Intent>> ent + : mStickyBroadcasts.entrySet()) { + pw.println(" Sticky action " + ent.getKey() + ":"); + ArrayList<Intent> intents = ent.getValue(); + final int N = intents.size(); + for (int i=0; i<N; i++) { + pw.println(" " + intents.get(i)); + } + } + } + + pw.println(" "); + pw.println(" mHandler:"); + mHandler.dump(new PrintWriterPrinter(pw), " "); + } + } + + void dumpServices(PrintWriter pw) { + synchronized (this) { + if (checkCallingPermission(android.Manifest.permission.DUMP) + != PackageManager.PERMISSION_GRANTED) { + pw.println("Permission Denial: can't dump ActivityManager from from pid=" + + Binder.getCallingPid() + + ", uid=" + Binder.getCallingUid() + + " without permission " + + android.Manifest.permission.DUMP); + return; + } + pw.println("Services in Current Activity Manager State:"); + + boolean needSep = false; + + if (mServices.size() > 0) { + pw.println(" Active services:"); + Iterator<ServiceRecord> it = mServices.values().iterator(); + while (it.hasNext()) { + ServiceRecord r = it.next(); + pw.println(" Service " + r.shortName); + r.dump(pw, " "); + } + needSep = true; + } + + if (mPendingServices.size() > 0) { + if (needSep) pw.println(" "); + pw.println(" Pending services:"); + for (int i=0; i<mPendingServices.size(); i++) { + ServiceRecord r = mPendingServices.get(i); + pw.println(" Pending Service " + r.shortName); + r.dump(pw, " "); + } + needSep = true; + } + + if (mRestartingServices.size() > 0) { + if (needSep) pw.println(" "); + pw.println(" Restarting services:"); + for (int i=0; i<mRestartingServices.size(); i++) { + ServiceRecord r = mRestartingServices.get(i); + pw.println(" Restarting Service " + r.shortName); + r.dump(pw, " "); + } + needSep = true; + } + + if (mStoppingServices.size() > 0) { + if (needSep) pw.println(" "); + pw.println(" Stopping services:"); + for (int i=0; i<mStoppingServices.size(); i++) { + ServiceRecord r = mStoppingServices.get(i); + pw.println(" Stopping Service " + r.shortName); + r.dump(pw, " "); + } + needSep = true; + } + + if (mServiceConnections.size() > 0) { + if (needSep) pw.println(" "); + pw.println(" Connection bindings to services:"); + Iterator<ConnectionRecord> it + = mServiceConnections.values().iterator(); + while (it.hasNext()) { + ConnectionRecord r = it.next(); + pw.println(" " + r.binding.service.shortName + + " -> " + r.conn.asBinder()); + r.dump(pw, " "); + } + } + } + } + + void dumpProviders(PrintWriter pw) { + synchronized (this) { + if (checkCallingPermission(android.Manifest.permission.DUMP) + != PackageManager.PERMISSION_GRANTED) { + pw.println("Permission Denial: can't dump ActivityManager from from pid=" + + Binder.getCallingPid() + + ", uid=" + Binder.getCallingUid() + + " without permission " + + android.Manifest.permission.DUMP); + return; + } + + pw.println("Content Providers in Current Activity Manager State:"); + + boolean needSep = false; + + if (mProvidersByName.size() > 0) { + pw.println(" Published content providers (by name):"); + Iterator it = mProvidersByName.entrySet().iterator(); + while (it.hasNext()) { + Map.Entry e = (Map.Entry)it.next(); + ContentProviderRecord r = (ContentProviderRecord)e.getValue(); + pw.println(" Provider " + (String)e.getKey()); + r.dump(pw, " "); + } + needSep = true; + } + + if (mProvidersByClass.size() > 0) { + if (needSep) pw.println(" "); + pw.println(" Published content providers (by class):"); + Iterator it = mProvidersByClass.entrySet().iterator(); + while (it.hasNext()) { + Map.Entry e = (Map.Entry)it.next(); + ContentProviderRecord r = (ContentProviderRecord)e.getValue(); + pw.println(" Provider " + (String)e.getKey()); + r.dump(pw, " "); + } + needSep = true; + } + + if (mLaunchingProviders.size() > 0) { + if (needSep) pw.println(" "); + pw.println(" Launching content providers:"); + for (int i=mLaunchingProviders.size()-1; i>=0; i--) { + pw.println(" Provider #" + i + ":"); + ((ContentProviderRecord)mLaunchingProviders.get(i)).dump(pw, " "); + } + needSep = true; + } + + pw.println(); + pw.println("Granted Uri Permissions:"); + for (int i=0; i<mGrantedUriPermissions.size(); i++) { + int uid = mGrantedUriPermissions.keyAt(i); + HashMap<Uri, UriPermission> perms + = mGrantedUriPermissions.valueAt(i); + pw.println(" Uris granted to uid " + uid + ":"); + for (UriPermission perm : perms.values()) { + perm.dump(pw, " "); + } + } + } + } + + void dumpSenders(PrintWriter pw) { + synchronized (this) { + if (checkCallingPermission(android.Manifest.permission.DUMP) + != PackageManager.PERMISSION_GRANTED) { + pw.println("Permission Denial: can't dump ActivityManager from from pid=" + + Binder.getCallingPid() + + ", uid=" + Binder.getCallingUid() + + " without permission " + + android.Manifest.permission.DUMP); + return; + } + + pw.println("Intent Senders in Current Activity Manager State:"); + + if (this.mIntentSenderRecords.size() > 0) { + Iterator<WeakReference<PendingIntentRecord>> it + = mIntentSenderRecords.values().iterator(); + while (it.hasNext()) { + WeakReference<PendingIntentRecord> ref = it.next(); + PendingIntentRecord rec = ref != null ? ref.get(): null; + if (rec != null) { + pw.println(" IntentSender " + rec); + rec.dump(pw, " "); + } else { + pw.println(" IntentSender " + ref); + } + } + } + } + } + + private static final void dumpHistoryList(PrintWriter pw, List list, + String prefix, String label) { + TaskRecord lastTask = null; + for (int i=list.size()-1; i>=0; i--) { + HistoryRecord r = (HistoryRecord)list.get(i); + if (lastTask != r.task) { + lastTask = r.task; + lastTask.dump(pw, prefix + " "); + } + pw.println(prefix + " " + label + " #" + i + ":"); + r.dump(pw, prefix + " "); + } + } + + private static final int dumpProcessList(PrintWriter pw, List list, + String prefix, String normalLabel, String persistentLabel, + boolean inclOomAdj) { + int numPers = 0; + for (int i=list.size()-1; i>=0; i--) { + ProcessRecord r = (ProcessRecord)list.get(i); + if (false) { + pw.println(prefix + (r.persistent ? persistentLabel : normalLabel) + + " #" + i + ":"); + r.dump(pw, prefix + " "); + } else if (inclOomAdj) { + pw.println(String.format("%s%s #%2d: oom_adj=%3d %s", + prefix, (r.persistent ? persistentLabel : normalLabel), + i, r.setAdj, r.toString())); + } else { + pw.println(String.format("%s%s #%2d: %s", + prefix, (r.persistent ? persistentLabel : normalLabel), + i, r.toString())); + } + if (r.persistent) { + numPers++; + } + } + return numPers; + } + + private static final void dumpApplicationMemoryUsage(FileDescriptor fd, + PrintWriter pw, List list, String prefix, String[] args) { + final boolean isCheckinRequest = scanArgs(args, "-c"); + long uptime = SystemClock.uptimeMillis(); + long realtime = SystemClock.elapsedRealtime(); + + if (isCheckinRequest) { + // short checkin version + pw.println(uptime + "," + realtime); + pw.flush(); + } else { + pw.println("Applications Memory Usage (kB):"); + pw.println("Uptime: " + uptime + " Realtime: " + realtime); + } + for (int i = list.size() - 1 ; i >= 0 ; i--) { + ProcessRecord r = (ProcessRecord)list.get(i); + if (r.thread != null) { + if (!isCheckinRequest) { + pw.println("\n** MEMINFO in pid " + r.pid + " [" + r.processName + "] **"); + pw.flush(); + } + try { + r.thread.asBinder().dump(fd, args); + } catch (RemoteException e) { + if (!isCheckinRequest) { + pw.println("Got RemoteException!"); + pw.flush(); + } + } + } + } + } + + /** + * Searches array of arguments for the specified string + * @param args array of argument strings + * @param value value to search for + * @return true if the value is contained in the array + */ + private static boolean scanArgs(String[] args, String value) { + if (args != null) { + for (String arg : args) { + if (value.equals(arg)) { + return true; + } + } + } + return false; + } + + private final int indexOfTokenLocked(IBinder token, boolean required) { + int count = mHistory.size(); + + // convert the token to an entry in the history. + HistoryRecord r = null; + int index = -1; + for (int i=count-1; i>=0; i--) { + Object o = mHistory.get(i); + if (o == token) { + r = (HistoryRecord)o; + index = i; + break; + } + } + if (index < 0 && required) { + RuntimeInit.crash(TAG, new InvalidTokenException(token)); + } + + return index; + } + + static class InvalidTokenException extends Exception { + InvalidTokenException(IBinder token) { + super("Bad activity token: " + token); + } + } + + private final void killServicesLocked(ProcessRecord app, + boolean allowRestart) { + // Report disconnected services. + if (false) { + // XXX we are letting the client link to the service for + // death notifications. + if (app.services.size() > 0) { + Iterator it = app.services.iterator(); + while (it.hasNext()) { + ServiceRecord r = (ServiceRecord)it.next(); + if (r.connections.size() > 0) { + Iterator<ConnectionRecord> jt + = r.connections.values().iterator(); + while (jt.hasNext()) { + ConnectionRecord c = jt.next(); + if (c.binding.client != app) { + try { + //c.conn.connected(r.className, null); + } catch (Exception e) { + // todo: this should be asynchronous! + Log.w(TAG, "Exception thrown disconnected servce " + + r.shortName + + " from app " + app.processName, e); + } + } + } + } + } + } + } + + // Clean up any connections this application has to other services. + if (app.connections.size() > 0) { + Iterator<ConnectionRecord> it = app.connections.iterator(); + while (it.hasNext()) { + ConnectionRecord r = it.next(); + removeConnectionLocked(r, app, null); + } + } + app.connections.clear(); + + if (app.services.size() != 0) { + // Any services running in the application need to be placed + // back in the pending list. + Iterator it = app.services.iterator(); + while (it.hasNext()) { + ServiceRecord sr = (ServiceRecord)it.next(); + synchronized (sr.stats.getBatteryStats()) { + sr.stats.stopLaunchedLocked(); + } + sr.app = null; + sr.executeNesting = 0; + mStoppingServices.remove(sr); + if (sr.bindings.size() > 0) { + Iterator<IntentBindRecord> bindings + = sr.bindings.values().iterator(); + while (bindings.hasNext()) { + IntentBindRecord b = bindings.next(); + if (DEBUG_SERVICE) Log.v(TAG, "Killing binding " + b + + ": shouldUnbind=" + b.hasBound); + b.binder = null; + b.requested = b.received = b.hasBound = false; + } + } + + if (sr.crashCount >= 2) { + Log.w(TAG, "Service crashed " + sr.crashCount + + " times, stopping: " + sr); + EventLog.writeEvent(LOG_AM_SERVICE_CRASHED_TOO_MUCH, + sr.crashCount, sr.shortName, app.pid); + bringDownServiceLocked(sr, true); + } else if (!allowRestart) { + bringDownServiceLocked(sr, true); + } else { + scheduleServiceRestartLocked(sr); + } + } + + if (!allowRestart) { + app.services.clear(); + } + } + + app.executingServices.clear(); + } + + private final void removeDyingProviderLocked(ProcessRecord proc, + ContentProviderRecord cpr) { + synchronized (cpr) { + cpr.launchingApp = null; + cpr.notifyAll(); + } + + mProvidersByClass.remove(cpr.info.name); + String names[] = cpr.info.authority.split(";"); + for (int j = 0; j < names.length; j++) { + mProvidersByName.remove(names[j]); + } + + Iterator<ProcessRecord> cit = cpr.clients.iterator(); + while (cit.hasNext()) { + ProcessRecord capp = cit.next(); + if (!capp.persistent && capp.thread != null + && capp.pid != 0 + && capp.pid != MY_PID) { + Log.i(TAG, "Killing app " + capp.processName + + " (pid " + capp.pid + + ") because provider " + cpr.info.name + + " is in dying process " + proc.processName); + Process.killProcess(capp.pid); + } + } + + mLaunchingProviders.remove(cpr); + } + + /** + * Main code for cleaning up a process when it has gone away. This is + * called both as a result of the process dying, or directly when stopping + * a process when running in single process mode. + */ + private final void cleanUpApplicationRecordLocked(ProcessRecord app, + boolean restarting, int index) { + if (index >= 0) { + mLRUProcesses.remove(index); + } + + // Dismiss any open dialogs. + if (app.crashDialog != null) { + app.crashDialog.dismiss(); + app.crashDialog = null; + } + if (app.anrDialog != null) { + app.anrDialog.dismiss(); + app.anrDialog = null; + } + if (app.waitDialog != null) { + app.waitDialog.dismiss(); + app.waitDialog = null; + } + + app.crashing = false; + app.notResponding = false; + + app.resetPackageList(); + app.thread = null; + app.forcingToForeground = null; + app.foregroundServices = false; + + killServicesLocked(app, true); + + boolean restart = false; + + int NL = mLaunchingProviders.size(); + + // Remove published content providers. + if (!app.pubProviders.isEmpty()) { + Iterator it = app.pubProviders.values().iterator(); + while (it.hasNext()) { + ContentProviderRecord cpr = (ContentProviderRecord)it.next(); + cpr.provider = null; + cpr.app = null; + + // See if someone is waiting for this provider... in which + // case we don't remove it, but just let it restart. + int i = 0; + if (!app.bad) { + for (; i<NL; i++) { + if (mLaunchingProviders.get(i) == cpr) { + restart = true; + break; + } + } + } else { + i = NL; + } + + if (i >= NL) { + removeDyingProviderLocked(app, cpr); + NL = mLaunchingProviders.size(); + } + } + app.pubProviders.clear(); + } + + // Look through the content providers we are waiting to have launched, + // and if any run in this process then either schedule a restart of + // the process or kill the client waiting for it if this process has + // gone bad. + for (int i=0; i<NL; i++) { + ContentProviderRecord cpr = (ContentProviderRecord) + mLaunchingProviders.get(i); + if (cpr.launchingApp == app) { + if (!app.bad) { + restart = true; + } else { + removeDyingProviderLocked(app, cpr); + NL = mLaunchingProviders.size(); + } + } + } + + // Unregister from connected content providers. + if (!app.conProviders.isEmpty()) { + Iterator it = app.conProviders.iterator(); + while (it.hasNext()) { + ContentProviderRecord cpr = (ContentProviderRecord)it.next(); + cpr.clients.remove(app); + } + app.conProviders.clear(); + } + + skipCurrentReceiverLocked(app); + + // Unregister any receivers. + if (app.receivers.size() > 0) { + Iterator<ReceiverList> it = app.receivers.iterator(); + while (it.hasNext()) { + removeReceiverLocked(it.next()); + } + app.receivers.clear(); + } + + // If the caller is restarting this app, then leave it in its + // current lists and let the caller take care of it. + if (restarting) { + return; + } + + if (!app.persistent) { + if (DEBUG_PROCESSES) Log.v(TAG, + "Removing non-persistent process during cleanup: " + app); + mProcessNames.remove(app.processName, app.info.uid); + } else if (!app.removed) { + // This app is persistent, so we need to keep its record around. + // If it is not already on the pending app list, add it there + // and start a new process for it. + app.thread = null; + app.forcingToForeground = null; + app.foregroundServices = false; + if (mPersistentStartingProcesses.indexOf(app) < 0) { + mPersistentStartingProcesses.add(app); + restart = true; + } + } + mProcessesOnHold.remove(app); + + if (restart) { + // We have components that still need to be running in the + // process, so re-launch it. + mProcessNames.put(app.processName, app.info.uid, app); + startProcessLocked(app, "restart", app.processName); + } else if (app.pid > 0 && app.pid != MY_PID) { + // Goodbye! + synchronized (mPidsSelfLocked) { + mPidsSelfLocked.remove(app.pid); + mHandler.removeMessages(PROC_START_TIMEOUT_MSG, app); + } + app.pid = 0; + } + } + + // ========================================================= + // SERVICES + // ========================================================= + + ActivityManager.RunningServiceInfo makeRunningServiceInfoLocked(ServiceRecord r) { + ActivityManager.RunningServiceInfo info = + new ActivityManager.RunningServiceInfo(); + info.service = r.name; + if (r.app != null) { + info.pid = r.app.pid; + } + info.process = r.processName; + info.foreground = r.isForeground; + info.activeSince = r.createTime; + info.started = r.startRequested; + info.clientCount = r.connections.size(); + info.crashCount = r.crashCount; + info.lastActivityTime = r.lastActivity; + return info; + } + + public List<ActivityManager.RunningServiceInfo> getServices(int maxNum, + int flags) { + synchronized (this) { + ArrayList<ActivityManager.RunningServiceInfo> res + = new ArrayList<ActivityManager.RunningServiceInfo>(); + + if (mServices.size() > 0) { + Iterator<ServiceRecord> it = mServices.values().iterator(); + while (it.hasNext() && res.size() < maxNum) { + res.add(makeRunningServiceInfoLocked(it.next())); + } + } + + for (int i=0; i<mRestartingServices.size() && res.size() < maxNum; i++) { + ServiceRecord r = mRestartingServices.get(i); + ActivityManager.RunningServiceInfo info = + makeRunningServiceInfoLocked(r); + info.restarting = r.nextRestartTime; + res.add(info); + } + + return res; + } + } + + private final ServiceRecord findServiceLocked(ComponentName name, + IBinder token) { + ServiceRecord r = mServices.get(name); + return r == token ? r : null; + } + + private final class ServiceLookupResult { + final ServiceRecord record; + final String permission; + + ServiceLookupResult(ServiceRecord _record, String _permission) { + record = _record; + permission = _permission; + } + }; + + private ServiceLookupResult findServiceLocked(Intent service, + String resolvedType) { + ServiceRecord r = null; + if (service.getComponent() != null) { + r = mServices.get(service.getComponent()); + } + if (r == null) { + Intent.FilterComparison filter = new Intent.FilterComparison(service); + r = mServicesByIntent.get(filter); + } + + if (r == null) { + try { + ResolveInfo rInfo = + ActivityThread.getPackageManager().resolveService( + service, resolvedType, 0); + ServiceInfo sInfo = + rInfo != null ? rInfo.serviceInfo : null; + if (sInfo == null) { + return null; + } + + ComponentName name = new ComponentName( + sInfo.applicationInfo.packageName, sInfo.name); + r = mServices.get(name); + } catch (RemoteException ex) { + // pm is in same process, this will never happen. + } + } + if (r != null) { + int callingPid = Binder.getCallingPid(); + int callingUid = Binder.getCallingUid(); + if (checkComponentPermission(r.permission, + callingPid, callingUid, r.exported ? -1 : r.appInfo.uid) + != PackageManager.PERMISSION_GRANTED) { + Log.w(TAG, "Permission Denial: Accessing service " + r.name + + " from pid=" + callingPid + + ", uid=" + callingUid + + " requires " + r.permission); + return new ServiceLookupResult(null, r.permission); + } + return new ServiceLookupResult(r, null); + } + return null; + } + + private class ServiceRestarter implements Runnable { + private ServiceRecord mService; + + void setService(ServiceRecord service) { + mService = service; + } + + public void run() { + synchronized(ActivityManagerService.this) { + performServiceRestartLocked(mService); + } + } + } + + private ServiceLookupResult retrieveServiceLocked(Intent service, + String resolvedType, int callingPid, int callingUid) { + ServiceRecord r = null; + if (service.getComponent() != null) { + r = mServices.get(service.getComponent()); + } + Intent.FilterComparison filter = new Intent.FilterComparison(service); + r = mServicesByIntent.get(filter); + if (r == null) { + try { + ResolveInfo rInfo = + ActivityThread.getPackageManager().resolveService( + service, resolvedType, PackageManager.GET_SHARED_LIBRARY_FILES); + ServiceInfo sInfo = + rInfo != null ? rInfo.serviceInfo : null; + if (sInfo == null) { + Log.w(TAG, "Unable to start service " + service + + ": not found"); + return null; + } + + ComponentName name = new ComponentName( + sInfo.applicationInfo.packageName, sInfo.name); + r = mServices.get(name); + if (r == null) { + filter = new Intent.FilterComparison(service.cloneFilter()); + ServiceRestarter res = new ServiceRestarter(); + BatteryStatsImpl.Uid.Pkg.Serv ss = null; + BatteryStatsImpl stats = mBatteryStatsService.getActiveStatistics(); + synchronized (stats) { + ss = stats.getServiceStatsLocked( + sInfo.applicationInfo.uid, sInfo.packageName, + sInfo.name); + } + r = new ServiceRecord(ss, name, filter, sInfo, res); + res.setService(r); + mServices.put(name, r); + mServicesByIntent.put(filter, r); + + // Make sure this component isn't in the pending list. + int N = mPendingServices.size(); + for (int i=0; i<N; i++) { + ServiceRecord pr = mPendingServices.get(i); + if (pr.name.equals(name)) { + mPendingServices.remove(i); + i--; + N--; + } + } + } + } catch (RemoteException ex) { + // pm is in same process, this will never happen. + } + } + if (r != null) { + if (checkComponentPermission(r.permission, + callingPid, callingUid, r.exported ? -1 : r.appInfo.uid) + != PackageManager.PERMISSION_GRANTED) { + Log.w(TAG, "Permission Denial: Accessing service " + r.name + + " from pid=" + Binder.getCallingPid() + + ", uid=" + Binder.getCallingUid() + + " requires " + r.permission); + return new ServiceLookupResult(null, r.permission); + } + return new ServiceLookupResult(r, null); + } + return null; + } + + private final void bumpServiceExecutingLocked(ServiceRecord r) { + long now = SystemClock.uptimeMillis(); + if (r.executeNesting == 0 && r.app != null) { + if (r.app.executingServices.size() == 0) { + Message msg = mHandler.obtainMessage(SERVICE_TIMEOUT_MSG); + msg.obj = r.app; + mHandler.sendMessageAtTime(msg, now+SERVICE_TIMEOUT); + } + r.app.executingServices.add(r); + } + r.executeNesting++; + r.executingStart = now; + } + + private final void sendServiceArgsLocked(ServiceRecord r, + boolean oomAdjusted) { + final int N = r.startArgs.size(); + if (N == 0) { + return; + } + + final int BASEID = r.lastStartId - N + 1; + int i = 0; + while (i < N) { + try { + Intent args = r.startArgs.get(i); + if (DEBUG_SERVICE) Log.v(TAG, "Sending arguments to service: " + + r.name + " " + r.intent + " args=" + args); + bumpServiceExecutingLocked(r); + if (!oomAdjusted) { + oomAdjusted = true; + updateOomAdjLocked(r.app); + } + r.app.thread.scheduleServiceArgs(r, BASEID+i, args); + i++; + } catch (Exception e) { + break; + } + } + if (i == N) { + r.startArgs.clear(); + } else { + while (i > 0) { + r.startArgs.remove(0); + i--; + } + } + } + + private final boolean requestServiceBindingLocked(ServiceRecord r, + IntentBindRecord i, boolean rebind) { + if (r.app == null || r.app.thread == null) { + // If service is not currently running, can't yet bind. + return false; + } + if ((!i.requested || rebind) && i.apps.size() > 0) { + try { + bumpServiceExecutingLocked(r); + if (DEBUG_SERVICE) Log.v(TAG, "Connecting binding " + i + + ": shouldUnbind=" + i.hasBound); + r.app.thread.scheduleBindService(r, i.intent.getIntent(), rebind); + if (!rebind) { + i.requested = true; + } + i.hasBound = true; + i.doRebind = false; + } catch (RemoteException e) { + return false; + } + } + return true; + } + + private final void requestServiceBindingsLocked(ServiceRecord r) { + Iterator<IntentBindRecord> bindings = r.bindings.values().iterator(); + while (bindings.hasNext()) { + IntentBindRecord i = bindings.next(); + if (!requestServiceBindingLocked(r, i, false)) { + break; + } + } + } + + private final void realStartServiceLocked(ServiceRecord r, + ProcessRecord app) throws RemoteException { + if (app.thread == null) { + throw new RemoteException(); + } + + r.app = app; + r.restartTime = SystemClock.uptimeMillis(); + + app.services.add(r); + bumpServiceExecutingLocked(r); + updateLRUListLocked(app, true); + + boolean created = false; + try { + if (DEBUG_SERVICE) Log.v(TAG, "Scheduling start service: " + + r.name + " " + r.intent); + EventLog.writeEvent(LOG_AM_CREATE_SERVICE, + System.identityHashCode(r), r.shortName, + r.intent.getIntent().toString(), r.app.pid); + synchronized (r.stats.getBatteryStats()) { + r.stats.startLaunchedLocked(); + } + app.thread.scheduleCreateService(r, r.serviceInfo); + created = true; + } finally { + if (!created) { + app.services.remove(r); + scheduleServiceRestartLocked(r); + } + } + + requestServiceBindingsLocked(r); + sendServiceArgsLocked(r, true); + } + + private final void scheduleServiceRestartLocked(ServiceRecord r) { + r.totalRestartCount++; + if (r.restartDelay == 0) { + r.restartCount++; + r.restartDelay = SERVICE_RESTART_DURATION; + } else { + // If it has been a "reasonably long time" since the service + // was started, then reset our restart duration back to + // the beginning, so we don't infinitely increase the duration + // on a service that just occasionally gets killed (which is + // a normal case, due to process being killed to reclaim memory). + long now = SystemClock.uptimeMillis(); + if (now > (r.restartTime+(SERVICE_RESTART_DURATION*2*2*2))) { + r.restartCount = 1; + r.restartDelay = SERVICE_RESTART_DURATION; + } else { + r.restartDelay *= 2; + } + } + if (!mRestartingServices.contains(r)) { + mRestartingServices.add(r); + } + mHandler.removeCallbacks(r.restarter); + mHandler.postDelayed(r.restarter, r.restartDelay); + r.nextRestartTime = SystemClock.uptimeMillis() + r.restartDelay; + Log.w(TAG, "Scheduling restart of crashed service " + + r.shortName + " in " + r.restartDelay + "ms"); + EventLog.writeEvent(LOG_AM_SCHEDULE_SERVICE_RESTART, + r.shortName, r.restartDelay); + + Message msg = Message.obtain(); + msg.what = SERVICE_ERROR_MSG; + msg.obj = r; + mHandler.sendMessage(msg); + } + + final void performServiceRestartLocked(ServiceRecord r) { + if (!mRestartingServices.contains(r)) { + return; + } + bringUpServiceLocked(r, r.intent.getIntent().getFlags(), true); + } + + private final boolean unscheduleServiceRestartLocked(ServiceRecord r) { + if (r.restartDelay == 0) { + return false; + } + r.resetRestartCounter(); + mRestartingServices.remove(r); + mHandler.removeCallbacks(r.restarter); + return true; + } + + private final boolean bringUpServiceLocked(ServiceRecord r, + int intentFlags, boolean whileRestarting) { + //Log.i(TAG, "Bring up service:"); + //r.dump(" "); + + if (r.app != null) { + sendServiceArgsLocked(r, false); + return true; + } + + if (!whileRestarting && r.restartDelay > 0) { + // If waiting for a restart, then do nothing. + return true; + } + + if (DEBUG_SERVICE) Log.v(TAG, "Bringing up service " + r.name + + " " + r.intent); + + final String appName = r.processName; + ProcessRecord app = getProcessRecordLocked(appName, r.appInfo.uid); + if (app != null && app.thread != null) { + try { + realStartServiceLocked(r, app); + return true; + } catch (RemoteException e) { + Log.w(TAG, "Exception when starting service " + r.shortName, e); + } + + // If a dead object exception was thrown -- fall through to + // restart the application. + } + + if (!mPendingServices.contains(r)) { + // Not running -- get it started, and enqueue this service record + // to be executed when the app comes up. + if (startProcessLocked(appName, r.appInfo, true, intentFlags, + "service", r.name) == null) { + Log.w(TAG, "Unable to launch app " + + r.appInfo.packageName + "/" + + r.appInfo.uid + " for service " + + r.intent.getIntent() + ": process is bad"); + bringDownServiceLocked(r, true); + return false; + } + mPendingServices.add(r); + } + return true; + } + + private final void bringDownServiceLocked(ServiceRecord r, boolean force) { + //Log.i(TAG, "Bring down service:"); + //r.dump(" "); + + // Does it still need to run? + if (!force && r.startRequested) { + return; + } + if (r.connections.size() > 0) { + if (!force) { + // XXX should probably keep a count of the number of auto-create + // connections directly in the service. + Iterator<ConnectionRecord> it = r.connections.values().iterator(); + while (it.hasNext()) { + ConnectionRecord cr = it.next(); + if ((cr.flags&Context.BIND_AUTO_CREATE) != 0) { + return; + } + } + } + + // Report to all of the connections that the service is no longer + // available. + Iterator<ConnectionRecord> it = r.connections.values().iterator(); + while (it.hasNext()) { + ConnectionRecord c = it.next(); + try { + // todo: shouldn't be a synchronous call! + c.conn.connected(r.name, null); + } catch (Exception e) { + Log.w(TAG, "Failure disconnecting service " + r.name + + " to connection " + c.conn.asBinder() + + " (in " + c.binding.client.processName + ")", e); + } + } + } + + // Tell the service that it has been unbound. + if (r.bindings.size() > 0 && r.app != null && r.app.thread != null) { + Iterator<IntentBindRecord> it = r.bindings.values().iterator(); + while (it.hasNext()) { + IntentBindRecord ibr = it.next(); + if (DEBUG_SERVICE) Log.v(TAG, "Bringing down binding " + ibr + + ": hasBound=" + ibr.hasBound); + if (r.app != null && r.app.thread != null && ibr.hasBound) { + try { + bumpServiceExecutingLocked(r); + updateOomAdjLocked(r.app); + ibr.hasBound = false; + r.app.thread.scheduleUnbindService(r, + ibr.intent.getIntent()); + } catch (Exception e) { + Log.w(TAG, "Exception when unbinding service " + + r.shortName, e); + serviceDoneExecutingLocked(r, true); + } + } + } + } + + if (DEBUG_SERVICE) Log.v(TAG, "Bringing down service " + r.name + + " " + r.intent); + EventLog.writeEvent(LOG_AM_DESTROY_SERVICE, + System.identityHashCode(r), r.shortName, + (r.app != null) ? r.app.pid : -1); + + mServices.remove(r.name); + mServicesByIntent.remove(r.intent); + if (localLOGV) Log.v(TAG, "BRING DOWN SERVICE: " + r.shortName); + r.totalRestartCount = 0; + unscheduleServiceRestartLocked(r); + + // Also make sure it is not on the pending list. + int N = mPendingServices.size(); + for (int i=0; i<N; i++) { + if (mPendingServices.get(i) == r) { + mPendingServices.remove(i); + if (DEBUG_SERVICE) Log.v( + TAG, "Removed pending service: " + r.shortName); + i--; + N--; + } + } + + if (r.app != null) { + synchronized (r.stats.getBatteryStats()) { + r.stats.stopLaunchedLocked(); + } + r.app.services.remove(r); + if (r.app.thread != null) { + updateServiceForegroundLocked(r.app, false); + try { + Log.i(TAG, "Stopping service: " + r.shortName); + bumpServiceExecutingLocked(r); + mStoppingServices.add(r); + updateOomAdjLocked(r.app); + r.app.thread.scheduleStopService(r); + } catch (Exception e) { + Log.w(TAG, "Exception when stopping service " + + r.shortName, e); + serviceDoneExecutingLocked(r, true); + } + } else { + if (DEBUG_SERVICE) Log.v( + TAG, "Removed service that has no process: " + r.shortName); + } + } else { + if (DEBUG_SERVICE) Log.v( + TAG, "Removed service that is not running: " + r.shortName); + } + } + + ComponentName startServiceLocked(IApplicationThread caller, + Intent service, String resolvedType, + int callingPid, int callingUid) { + synchronized(this) { + if (DEBUG_SERVICE) Log.v(TAG, "startService: " + service + + " type=" + resolvedType + " args=" + service.getExtras()); + + if (caller != null) { + final ProcessRecord callerApp = getRecordForAppLocked(caller); + if (callerApp == null) { + throw new SecurityException( + "Unable to find app for caller " + caller + + " (pid=" + Binder.getCallingPid() + + ") when starting service " + service); + } + } + + ServiceLookupResult res = + retrieveServiceLocked(service, resolvedType, + callingPid, callingUid); + if (res == null) { + return null; + } + if (res.record == null) { + return new ComponentName("!", res.permission != null + ? res.permission : "private to package"); + } + ServiceRecord r = res.record; + if (unscheduleServiceRestartLocked(r)) { + if (DEBUG_SERVICE) Log.v(TAG, "START SERVICE WHILE RESTART PENDING: " + + r.shortName); + } + r.startRequested = true; + r.startArgs.add(service); + r.lastStartId++; + if (r.lastStartId < 1) { + r.lastStartId = 1; + } + r.lastActivity = SystemClock.uptimeMillis(); + synchronized (r.stats.getBatteryStats()) { + r.stats.startRunningLocked(); + } + if (!bringUpServiceLocked(r, service.getFlags(), false)) { + return new ComponentName("!", "Service process is bad"); + } + return r.name; + } + } + + public ComponentName startService(IApplicationThread caller, Intent service, + String resolvedType) { + // Refuse possible leaked file descriptors + if (service != null && service.hasFileDescriptors() == true) { + throw new IllegalArgumentException("File descriptors passed in Intent"); + } + + synchronized(this) { + final int callingPid = Binder.getCallingPid(); + final int callingUid = Binder.getCallingUid(); + final long origId = Binder.clearCallingIdentity(); + ComponentName res = startServiceLocked(caller, service, + resolvedType, callingPid, callingUid); + Binder.restoreCallingIdentity(origId); + return res; + } + } + + ComponentName startServiceInPackage(int uid, + Intent service, String resolvedType) { + synchronized(this) { + final long origId = Binder.clearCallingIdentity(); + ComponentName res = startServiceLocked(null, service, + resolvedType, -1, uid); + Binder.restoreCallingIdentity(origId); + return res; + } + } + + public int stopService(IApplicationThread caller, Intent service, + String resolvedType) { + // Refuse possible leaked file descriptors + if (service != null && service.hasFileDescriptors() == true) { + throw new IllegalArgumentException("File descriptors passed in Intent"); + } + + synchronized(this) { + if (DEBUG_SERVICE) Log.v(TAG, "stopService: " + service + + " type=" + resolvedType); + + final ProcessRecord callerApp = getRecordForAppLocked(caller); + if (caller != null && callerApp == null) { + throw new SecurityException( + "Unable to find app for caller " + caller + + " (pid=" + Binder.getCallingPid() + + ") when stopping service " + service); + } + + // If this service is active, make sure it is stopped. + ServiceLookupResult r = findServiceLocked(service, resolvedType); + if (r != null) { + if (r.record != null) { + synchronized (r.record.stats.getBatteryStats()) { + r.record.stats.stopRunningLocked(); + } + r.record.startRequested = false; + final long origId = Binder.clearCallingIdentity(); + bringDownServiceLocked(r.record, false); + Binder.restoreCallingIdentity(origId); + return 1; + } + return -1; + } + } + + return 0; + } + + public IBinder peekService(Intent service, String resolvedType) { + // Refuse possible leaked file descriptors + if (service != null && service.hasFileDescriptors() == true) { + throw new IllegalArgumentException("File descriptors passed in Intent"); + } + + IBinder ret = null; + + synchronized(this) { + ServiceLookupResult r = findServiceLocked(service, resolvedType); + + if (r != null) { + // r.record is null if findServiceLocked() failed the caller permission check + if (r.record == null) { + throw new SecurityException( + "Permission Denial: Accessing service " + r.record.name + + " from pid=" + Binder.getCallingPid() + + ", uid=" + Binder.getCallingUid() + + " requires " + r.permission); + } + IntentBindRecord ib = r.record.bindings.get(r.record.intent); + if (ib != null) { + ret = ib.binder; + } + } + } + + return ret; + } + + public boolean stopServiceToken(ComponentName className, IBinder token, + int startId) { + synchronized(this) { + if (DEBUG_SERVICE) Log.v(TAG, "stopServiceToken: " + className + + " " + token + " startId=" + startId); + ServiceRecord r = findServiceLocked(className, token); + if (r != null && (startId < 0 || r.lastStartId == startId)) { + synchronized (r.stats.getBatteryStats()) { + r.stats.stopRunningLocked(); + r.startRequested = false; + } + final long origId = Binder.clearCallingIdentity(); + bringDownServiceLocked(r, false); + Binder.restoreCallingIdentity(origId); + return true; + } + } + return false; + } + + public void setServiceForeground(ComponentName className, IBinder token, + boolean isForeground) { + synchronized(this) { + ServiceRecord r = findServiceLocked(className, token); + if (r != null) { + if (r.isForeground != isForeground) { + final long origId = Binder.clearCallingIdentity(); + r.isForeground = isForeground; + if (r.app != null) { + updateServiceForegroundLocked(r.app, true); + } + Binder.restoreCallingIdentity(origId); + } + } + } + } + + public void updateServiceForegroundLocked(ProcessRecord proc, boolean oomAdj) { + boolean anyForeground = false; + for (ServiceRecord sr : (HashSet<ServiceRecord>)proc.services) { + if (sr.isForeground) { + anyForeground = true; + break; + } + } + if (anyForeground != proc.foregroundServices) { + proc.foregroundServices = anyForeground; + if (oomAdj) { + updateOomAdjLocked(); + } + } + } + + public int bindService(IApplicationThread caller, IBinder token, + Intent service, String resolvedType, + IServiceConnection connection, int flags) { + // Refuse possible leaked file descriptors + if (service != null && service.hasFileDescriptors() == true) { + throw new IllegalArgumentException("File descriptors passed in Intent"); + } + + synchronized(this) { + if (DEBUG_SERVICE) Log.v(TAG, "bindService: " + service + + " type=" + resolvedType + " conn=" + connection.asBinder() + + " flags=0x" + Integer.toHexString(flags)); + final ProcessRecord callerApp = getRecordForAppLocked(caller); + if (callerApp == null) { + throw new SecurityException( + "Unable to find app for caller " + caller + + " (pid=" + Binder.getCallingPid() + + ") when binding service " + service); + } + + HistoryRecord activity = null; + if (token != null) { + int aindex = indexOfTokenLocked(token, false); + if (aindex < 0) { + Log.w(TAG, "Binding with unknown activity: " + token); + return 0; + } + activity = (HistoryRecord)mHistory.get(aindex); + } + + ServiceLookupResult res = + retrieveServiceLocked(service, resolvedType, + Binder.getCallingPid(), Binder.getCallingUid()); + if (res == null) { + return 0; + } + if (res.record == null) { + return -1; + } + ServiceRecord s = res.record; + + final long origId = Binder.clearCallingIdentity(); + + if (unscheduleServiceRestartLocked(s)) { + if (DEBUG_SERVICE) Log.v(TAG, "BIND SERVICE WHILE RESTART PENDING: " + + s.shortName); + } + + AppBindRecord b = s.retrieveAppBindingLocked(service, callerApp); + ConnectionRecord c = new ConnectionRecord(b, activity, + connection, flags); + + IBinder binder = connection.asBinder(); + s.connections.put(binder, c); + b.connections.add(c); + if (activity != null) { + if (activity.connections == null) { + activity.connections = new HashSet<ConnectionRecord>(); + } + activity.connections.add(c); + } + b.client.connections.add(c); + mServiceConnections.put(binder, c); + + if ((flags&Context.BIND_AUTO_CREATE) != 0) { + s.lastActivity = SystemClock.uptimeMillis(); + if (!bringUpServiceLocked(s, service.getFlags(), false)) { + return 0; + } + } + + if (s.app != null) { + // This could have made the service more important. + updateOomAdjLocked(s.app); + } + + if (DEBUG_SERVICE) Log.v(TAG, "Bind " + s + " with " + b + + ": received=" + b.intent.received + + " apps=" + b.intent.apps.size() + + " doRebind=" + b.intent.doRebind); + + if (s.app != null && b.intent.received) { + // Service is already running, so we can immediately + // publish the connection. + try { + c.conn.connected(s.name, b.intent.binder); + } catch (Exception e) { + Log.w(TAG, "Failure sending service " + s.shortName + + " to connection " + c.conn.asBinder() + + " (in " + c.binding.client.processName + ")", e); + } + + // If this is the first app connected back to this binding, + // and the service had previously asked to be told when + // rebound, then do so. + if (b.intent.apps.size() == 1 && b.intent.doRebind) { + requestServiceBindingLocked(s, b.intent, true); + } + } else if (!b.intent.requested) { + requestServiceBindingLocked(s, b.intent, false); + } + + Binder.restoreCallingIdentity(origId); + } + + return 1; + } + + private void removeConnectionLocked( + ConnectionRecord c, ProcessRecord skipApp, HistoryRecord skipAct) { + IBinder binder = c.conn.asBinder(); + AppBindRecord b = c.binding; + ServiceRecord s = b.service; + s.connections.remove(binder); + b.connections.remove(c); + if (c.activity != null && c.activity != skipAct) { + if (c.activity.connections != null) { + c.activity.connections.remove(c); + } + } + if (b.client != skipApp) { + b.client.connections.remove(c); + } + mServiceConnections.remove(binder); + + if (b.connections.size() == 0) { + b.intent.apps.remove(b.client); + } + + if (DEBUG_SERVICE) Log.v(TAG, "Disconnecting binding " + b.intent + + ": shouldUnbind=" + b.intent.hasBound); + if (s.app != null && s.app.thread != null && b.intent.apps.size() == 0 + && b.intent.hasBound) { + try { + bumpServiceExecutingLocked(s); + updateOomAdjLocked(s.app); + b.intent.hasBound = false; + // Assume the client doesn't want to know about a rebind; + // we will deal with that later if it asks for one. + b.intent.doRebind = false; + s.app.thread.scheduleUnbindService(s, b.intent.intent.getIntent()); + } catch (Exception e) { + Log.w(TAG, "Exception when unbinding service " + s.shortName, e); + serviceDoneExecutingLocked(s, true); + } + } + + if ((c.flags&Context.BIND_AUTO_CREATE) != 0) { + bringDownServiceLocked(s, false); + } + } + + public boolean unbindService(IServiceConnection connection) { + synchronized (this) { + IBinder binder = connection.asBinder(); + if (DEBUG_SERVICE) Log.v(TAG, "unbindService: conn=" + binder); + ConnectionRecord r = mServiceConnections.get(binder); + if (r == null) { + Log.w(TAG, "Unbind failed: could not find connection for " + + connection.asBinder()); + return false; + } + + final long origId = Binder.clearCallingIdentity(); + + removeConnectionLocked(r, null, null); + + if (r.binding.service.app != null) { + // This could have made the service less important. + updateOomAdjLocked(r.binding.service.app); + } + + Binder.restoreCallingIdentity(origId); + } + + return true; + } + + public void publishService(IBinder token, Intent intent, IBinder service) { + // Refuse possible leaked file descriptors + if (intent != null && intent.hasFileDescriptors() == true) { + throw new IllegalArgumentException("File descriptors passed in Intent"); + } + + synchronized(this) { + if (!(token instanceof ServiceRecord)) { + throw new IllegalArgumentException("Invalid service token"); + } + ServiceRecord r = (ServiceRecord)token; + + final long origId = Binder.clearCallingIdentity(); + + if (DEBUG_SERVICE) Log.v(TAG, "PUBLISHING SERVICE " + r.name + + " " + intent + ": " + service); + if (r != null) { + Intent.FilterComparison filter + = new Intent.FilterComparison(intent); + IntentBindRecord b = r.bindings.get(filter); + if (b != null && !b.received) { + b.binder = service; + b.requested = true; + b.received = true; + if (r.connections.size() > 0) { + Iterator<ConnectionRecord> it + = r.connections.values().iterator(); + while (it.hasNext()) { + ConnectionRecord c = it.next(); + if (!filter.equals(c.binding.intent.intent)) { + if (DEBUG_SERVICE) Log.v( + TAG, "Not publishing to: " + c); + if (DEBUG_SERVICE) Log.v( + TAG, "Bound intent: " + c.binding.intent.intent); + if (DEBUG_SERVICE) Log.v( + TAG, "Published intent: " + intent); + continue; + } + if (DEBUG_SERVICE) Log.v(TAG, "Publishing to: " + c); + try { + c.conn.connected(r.name, service); + } catch (Exception e) { + Log.w(TAG, "Failure sending service " + r.name + + " to connection " + c.conn.asBinder() + + " (in " + c.binding.client.processName + ")", e); + } + } + } + } + + serviceDoneExecutingLocked(r, mStoppingServices.contains(r)); + + Binder.restoreCallingIdentity(origId); + } + } + } + + public void unbindFinished(IBinder token, Intent intent, boolean doRebind) { + // Refuse possible leaked file descriptors + if (intent != null && intent.hasFileDescriptors() == true) { + throw new IllegalArgumentException("File descriptors passed in Intent"); + } + + synchronized(this) { + if (!(token instanceof ServiceRecord)) { + throw new IllegalArgumentException("Invalid service token"); + } + ServiceRecord r = (ServiceRecord)token; + + final long origId = Binder.clearCallingIdentity(); + + if (r != null) { + Intent.FilterComparison filter + = new Intent.FilterComparison(intent); + IntentBindRecord b = r.bindings.get(filter); + if (DEBUG_SERVICE) Log.v(TAG, "unbindFinished in " + r + + " at " + b + ": apps=" + + (b != null ? b.apps.size() : 0)); + if (b != null) { + if (b.apps.size() > 0) { + // Applications have already bound since the last + // unbind, so just rebind right here. + requestServiceBindingLocked(r, b, true); + } else { + // Note to tell the service the next time there is + // a new client. + b.doRebind = true; + } + } + + serviceDoneExecutingLocked(r, mStoppingServices.contains(r)); + + Binder.restoreCallingIdentity(origId); + } + } + } + + public void serviceDoneExecuting(IBinder token) { + synchronized(this) { + if (!(token instanceof ServiceRecord)) { + throw new IllegalArgumentException("Invalid service token"); + } + ServiceRecord r = (ServiceRecord)token; + boolean inStopping = mStoppingServices.contains(token); + if (r != null) { + if (DEBUG_SERVICE) Log.v(TAG, "DONE EXECUTING SERVICE " + r.name + + ": nesting=" + r.executeNesting + + ", inStopping=" + inStopping); + if (r != token) { + Log.w(TAG, "Done executing service " + r.name + + " with incorrect token: given " + token + + ", expected " + r); + return; + } + + final long origId = Binder.clearCallingIdentity(); + serviceDoneExecutingLocked(r, inStopping); + Binder.restoreCallingIdentity(origId); + } else { + Log.w(TAG, "Done executing unknown service " + r.name + + " with token " + token); + } + } + } + + public void serviceDoneExecutingLocked(ServiceRecord r, boolean inStopping) { + r.executeNesting--; + if (r.executeNesting <= 0 && r.app != null) { + r.app.executingServices.remove(r); + if (r.app.executingServices.size() == 0) { + mHandler.removeMessages(SERVICE_TIMEOUT_MSG, r.app); + } + if (inStopping) { + mStoppingServices.remove(r); + } + updateOomAdjLocked(r.app); + } + } + + void serviceTimeout(ProcessRecord proc) { + synchronized(this) { + if (proc.executingServices.size() == 0 || proc.thread == null) { + return; + } + long maxTime = SystemClock.uptimeMillis() - SERVICE_TIMEOUT; + Iterator<ServiceRecord> it = proc.executingServices.iterator(); + ServiceRecord timeout = null; + long nextTime = 0; + while (it.hasNext()) { + ServiceRecord sr = it.next(); + if (sr.executingStart < maxTime) { + timeout = sr; + break; + } + if (sr.executingStart > nextTime) { + nextTime = sr.executingStart; + } + } + if (timeout != null && mLRUProcesses.contains(proc)) { + Log.w(TAG, "Timeout executing service: " + timeout); + appNotRespondingLocked(proc, null, "Executing service " + + timeout.name); + } else { + Message msg = mHandler.obtainMessage(SERVICE_TIMEOUT_MSG); + msg.obj = proc; + mHandler.sendMessageAtTime(msg, nextTime+SERVICE_TIMEOUT); + } + } + } + + // ========================================================= + // BROADCASTS + // ========================================================= + + private final List getStickies(String action, IntentFilter filter, + List cur) { + final ContentResolver resolver = mContext.getContentResolver(); + final ArrayList<Intent> list = mStickyBroadcasts.get(action); + if (list == null) { + return cur; + } + int N = list.size(); + for (int i=0; i<N; i++) { + Intent intent = list.get(i); + if (filter.match(resolver, intent, true, TAG) >= 0) { + if (cur == null) { + cur = new ArrayList<Intent>(); + } + cur.add(intent); + } + } + return cur; + } + + private final void scheduleBroadcastsLocked() { + if (DEBUG_BROADCAST) Log.v(TAG, "Schedule broadcasts: current=" + + mBroadcastsScheduled); + + if (mBroadcastsScheduled) { + return; + } + mHandler.sendEmptyMessage(BROADCAST_INTENT_MSG); + mBroadcastsScheduled = true; + } + + public Intent registerReceiver(IApplicationThread caller, + IIntentReceiver receiver, IntentFilter filter, String permission) { + synchronized(this) { + ProcessRecord callerApp = null; + if (caller != null) { + callerApp = getRecordForAppLocked(caller); + if (callerApp == null) { + throw new SecurityException( + "Unable to find app for caller " + caller + + " (pid=" + Binder.getCallingPid() + + ") when registering receiver " + receiver); + } + } + + List allSticky = null; + + // Look for any matching sticky broadcasts... + Iterator actions = filter.actionsIterator(); + if (actions != null) { + while (actions.hasNext()) { + String action = (String)actions.next(); + allSticky = getStickies(action, filter, allSticky); + } + } else { + allSticky = getStickies(null, filter, allSticky); + } + + // The first sticky in the list is returned directly back to + // the client. + Intent sticky = allSticky != null ? (Intent)allSticky.get(0) : null; + + if (DEBUG_BROADCAST) Log.v(TAG, "Register receiver " + filter + + ": " + sticky); + + if (receiver == null) { + return sticky; + } + + ReceiverList rl + = (ReceiverList)mRegisteredReceivers.get(receiver.asBinder()); + if (rl == null) { + rl = new ReceiverList(this, callerApp, + Binder.getCallingPid(), + Binder.getCallingUid(), receiver); + if (rl.app != null) { + rl.app.receivers.add(rl); + } else { + try { + receiver.asBinder().linkToDeath(rl, 0); + } catch (RemoteException e) { + return sticky; + } + rl.linkedToDeath = true; + } + mRegisteredReceivers.put(receiver.asBinder(), rl); + } + BroadcastFilter bf = new BroadcastFilter(filter, rl, permission); + rl.add(bf); + if (!bf.debugCheck()) { + Log.w(TAG, "==> For Dynamic broadast"); + } + mReceiverResolver.addFilter(bf); + + // Enqueue broadcasts for all existing stickies that match + // this filter. + if (allSticky != null) { + ArrayList receivers = new ArrayList(); + receivers.add(bf); + + int N = allSticky.size(); + for (int i=0; i<N; i++) { + Intent intent = (Intent)allSticky.get(i); + BroadcastRecord r = new BroadcastRecord(intent, null, + null, -1, -1, null, receivers, null, 0, null, null, + false); + if (mParallelBroadcasts.size() == 0) { + scheduleBroadcastsLocked(); + } + mParallelBroadcasts.add(r); + } + } + + return sticky; + } + } + + public void unregisterReceiver(IIntentReceiver receiver) { + if (DEBUG_BROADCAST) Log.v(TAG, "Unregister receiver: " + receiver); + + boolean doNext = false; + + synchronized(this) { + ReceiverList rl + = (ReceiverList)mRegisteredReceivers.get(receiver.asBinder()); + if (rl != null) { + if (rl.curBroadcast != null) { + BroadcastRecord r = rl.curBroadcast; + doNext = finishReceiverLocked( + receiver.asBinder(), r.resultCode, r.resultData, + r.resultExtras, r.resultAbort, true); + } + + if (rl.app != null) { + rl.app.receivers.remove(rl); + } + removeReceiverLocked(rl); + if (rl.linkedToDeath) { + rl.linkedToDeath = false; + rl.receiver.asBinder().unlinkToDeath(rl, 0); + } + } + } + + if (!doNext) { + return; + } + + final long origId = Binder.clearCallingIdentity(); + processNextBroadcast(false); + trimApplications(); + Binder.restoreCallingIdentity(origId); + } + + void removeReceiverLocked(ReceiverList rl) { + mRegisteredReceivers.remove(rl.receiver.asBinder()); + int N = rl.size(); + for (int i=0; i<N; i++) { + mReceiverResolver.removeFilter(rl.get(i)); + } + } + + private final int broadcastIntentLocked(ProcessRecord callerApp, + String callerPackage, Intent intent, String resolvedType, + IIntentReceiver resultTo, int resultCode, String resultData, + Bundle map, String requiredPermission, + boolean ordered, boolean sticky, int callingPid, int callingUid) { + intent = new Intent(intent); + + if (DEBUG_BROADCAST) Log.v( + TAG, (sticky ? "Broadcast sticky: ": "Broadcast: ") + intent + + " ordered=" + ordered); + if ((resultTo != null) && !ordered) { + Log.w(TAG, "Broadcast " + intent + " not ordered but result callback requested!"); + } + + // Handle special intents: if this broadcast is from the package + // manager about a package being removed, we need to remove all of + // its activities from the history stack. + final boolean uidRemoved = intent.ACTION_UID_REMOVED.equals( + intent.getAction()); + if (intent.ACTION_PACKAGE_REMOVED.equals(intent.getAction()) + || intent.ACTION_PACKAGE_CHANGED.equals(intent.getAction()) + || uidRemoved) { + if (checkComponentPermission( + android.Manifest.permission.BROADCAST_PACKAGE_REMOVED, + callingPid, callingUid, -1) + == PackageManager.PERMISSION_GRANTED) { + if (uidRemoved) { + final Bundle intentExtras = intent.getExtras(); + final int uid = intentExtras != null + ? intentExtras.getInt(Intent.EXTRA_UID) : -1; + if (uid >= 0) { + BatteryStatsImpl bs = mBatteryStatsService.getActiveStatistics(); + synchronized (bs) { + bs.removeUidStatsLocked(uid); + } + } + } else { + Uri data = intent.getData(); + String ssp; + if (data != null && (ssp=data.getSchemeSpecificPart()) != null) { + if (!intent.getBooleanExtra(Intent.EXTRA_DONT_KILL_APP, false)) { + uninstallPackageLocked(ssp, + intent.getIntExtra(Intent.EXTRA_UID, -1), false); + } + } + } + } else { + String msg = "Permission Denial: " + intent.getAction() + + " broadcast from " + callerPackage + " (pid=" + callingPid + + ", uid=" + callingUid + ")" + + " requires " + + android.Manifest.permission.BROADCAST_PACKAGE_REMOVED; + Log.w(TAG, msg); + throw new SecurityException(msg); + } + } + + /* + * If this is the time zone changed action, queue up a message that will reset the timezone + * of all currently running processes. This message will get queued up before the broadcast + * happens. + */ + if (intent.ACTION_TIMEZONE_CHANGED.equals(intent.getAction())) { + mHandler.sendEmptyMessage(UPDATE_TIME_ZONE); + } + + // Add to the sticky list if requested. + if (sticky) { + if (checkPermission(android.Manifest.permission.BROADCAST_STICKY, + callingPid, callingUid) + != PackageManager.PERMISSION_GRANTED) { + String msg = "Permission Denial: broadcastIntent() requesting a sticky broadcast from pid=" + + callingPid + ", uid=" + callingUid + + " requires " + android.Manifest.permission.BROADCAST_STICKY; + Log.w(TAG, msg); + throw new SecurityException(msg); + } + if (requiredPermission != null) { + Log.w(TAG, "Can't broadcast sticky intent " + intent + + " and enforce permission " + requiredPermission); + return BROADCAST_STICKY_CANT_HAVE_PERMISSION; + } + if (intent.getComponent() != null) { + throw new SecurityException( + "Sticky broadcasts can't target a specific component"); + } + ArrayList<Intent> list = mStickyBroadcasts.get(intent.getAction()); + if (list == null) { + list = new ArrayList<Intent>(); + mStickyBroadcasts.put(intent.getAction(), list); + } + int N = list.size(); + int i; + for (i=0; i<N; i++) { + if (intent.filterEquals(list.get(i))) { + // This sticky already exists, replace it. + list.set(i, new Intent(intent)); + break; + } + } + if (i >= N) { + list.add(new Intent(intent)); + } + } + + final ContentResolver resolver = mContext.getContentResolver(); + + // Figure out who all will receive this broadcast. + List receivers = null; + List<BroadcastFilter> registeredReceivers = null; + try { + if (intent.getComponent() != null) { + // Broadcast is going to one specific receiver class... + ActivityInfo ai = ActivityThread.getPackageManager(). + getReceiverInfo(intent.getComponent(), 0); + if (ai != null) { + receivers = new ArrayList(); + ResolveInfo ri = new ResolveInfo(); + ri.activityInfo = ai; + receivers.add(ri); + } + } else { + // Need to resolve the intent to interested receivers... + if ((intent.getFlags()&Intent.FLAG_RECEIVER_REGISTERED_ONLY) + == 0) { + receivers = + ActivityThread.getPackageManager().queryIntentReceivers( + intent, resolvedType, PackageManager.GET_SHARED_LIBRARY_FILES); + } + registeredReceivers = mReceiverResolver.queryIntent(resolver, + intent, resolvedType, false); + } + } catch (RemoteException ex) { + // pm is in same process, this will never happen. + } + + int NR = registeredReceivers != null ? registeredReceivers.size() : 0; + if (!ordered && NR > 0) { + // If we are not serializing this broadcast, then send the + // registered receivers separately so they don't wait for the + // components to be launched. + BroadcastRecord r = new BroadcastRecord(intent, callerApp, + callerPackage, callingPid, callingUid, requiredPermission, + registeredReceivers, resultTo, resultCode, resultData, map, + ordered); + if (DEBUG_BROADCAST) Log.v( + TAG, "Enqueueing parallel broadcast " + r + + ": prev had " + mParallelBroadcasts.size()); + mParallelBroadcasts.add(r); + scheduleBroadcastsLocked(); + registeredReceivers = null; + NR = 0; + } + + // Merge into one list. + int ir = 0; + if (receivers != null) { + // A special case for PACKAGE_ADDED: do not allow the package + // being added to see this broadcast. This prevents them from + // using this as a back door to get run as soon as they are + // installed. Maybe in the future we want to have a special install + // broadcast or such for apps, but we'd like to deliberately make + // this decision. + String skipPackage = (intent.ACTION_PACKAGE_ADDED.equals( + intent.getAction()) && intent.getData() != null) + ? intent.getData().getSchemeSpecificPart() + : null; + if (skipPackage != null && receivers != null) { + int NT = receivers.size(); + for (int it=0; it<NT; it++) { + ResolveInfo curt = (ResolveInfo)receivers.get(it); + if (curt.activityInfo.packageName.equals(skipPackage)) { + receivers.remove(it); + it--; + NT--; + } + } + } + + int NT = receivers != null ? receivers.size() : 0; + int it = 0; + ResolveInfo curt = null; + BroadcastFilter curr = null; + while (it < NT && ir < NR) { + if (curt == null) { + curt = (ResolveInfo)receivers.get(it); + } + if (curr == null) { + curr = registeredReceivers.get(ir); + } + if (curr.getPriority() >= curt.priority) { + // Insert this broadcast record into the final list. + receivers.add(it, curr); + ir++; + curr = null; + it++; + NT++; + } else { + // Skip to the next ResolveInfo in the final list. + it++; + curt = null; + } + } + } + while (ir < NR) { + if (receivers == null) { + receivers = new ArrayList(); + } + receivers.add(registeredReceivers.get(ir)); + ir++; + } + + if ((receivers != null && receivers.size() > 0) + || resultTo != null) { + BroadcastRecord r = new BroadcastRecord(intent, callerApp, + callerPackage, callingPid, callingUid, requiredPermission, + receivers, resultTo, resultCode, resultData, map, ordered); + if (DEBUG_BROADCAST) Log.v( + TAG, "Enqueueing ordered broadcast " + r + + ": prev had " + mOrderedBroadcasts.size()); + if (DEBUG_BROADCAST) { + int seq = r.intent.getIntExtra("seq", -1); + Log.i(TAG, "Enqueueing broadcast " + r.intent.getAction() + " seq=" + seq); + } + mOrderedBroadcasts.add(r); + scheduleBroadcastsLocked(); + } + + return BROADCAST_SUCCESS; + } + + public final int broadcastIntent(IApplicationThread caller, + Intent intent, String resolvedType, IIntentReceiver resultTo, + int resultCode, String resultData, Bundle map, + String requiredPermission, boolean serialized, boolean sticky) { + // Refuse possible leaked file descriptors + if (intent != null && intent.hasFileDescriptors() == true) { + throw new IllegalArgumentException("File descriptors passed in Intent"); + } + + synchronized(this) { + if (!mSystemReady) { + // if the caller really truly claims to know what they're doing, go + // ahead and allow the broadcast without launching any receivers + int flags = intent.getFlags(); + if ((flags&Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT) != 0) { + intent = new Intent(intent); + intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY); + } else if ((flags&Intent.FLAG_RECEIVER_REGISTERED_ONLY) == 0){ + Log.e(TAG, "Attempt to launch receivers of broadcast intent " + intent + + " before boot completion"); + throw new IllegalStateException("Cannot broadcast before boot completed"); + } + } + + final ProcessRecord callerApp = getRecordForAppLocked(caller); + final int callingPid = Binder.getCallingPid(); + final int callingUid = Binder.getCallingUid(); + final long origId = Binder.clearCallingIdentity(); + int res = broadcastIntentLocked(callerApp, + callerApp != null ? callerApp.info.packageName : null, + intent, resolvedType, resultTo, + resultCode, resultData, map, requiredPermission, serialized, + sticky, callingPid, callingUid); + Binder.restoreCallingIdentity(origId); + return res; + } + } + + int broadcastIntentInPackage(String packageName, int uid, + Intent intent, String resolvedType, IIntentReceiver resultTo, + int resultCode, String resultData, Bundle map, + String requiredPermission, boolean serialized, boolean sticky) { + synchronized(this) { + final long origId = Binder.clearCallingIdentity(); + int res = broadcastIntentLocked(null, packageName, intent, resolvedType, + resultTo, resultCode, resultData, map, requiredPermission, + serialized, sticky, -1, uid); + Binder.restoreCallingIdentity(origId); + return res; + } + } + + public final void unbroadcastIntent(IApplicationThread caller, + Intent intent) { + // Refuse possible leaked file descriptors + if (intent != null && intent.hasFileDescriptors() == true) { + throw new IllegalArgumentException("File descriptors passed in Intent"); + } + + synchronized(this) { + if (checkCallingPermission(android.Manifest.permission.BROADCAST_STICKY) + != PackageManager.PERMISSION_GRANTED) { + String msg = "Permission Denial: unbroadcastIntent() from pid=" + + Binder.getCallingPid() + + ", uid=" + Binder.getCallingUid() + + " requires " + android.Manifest.permission.BROADCAST_STICKY; + Log.w(TAG, msg); + throw new SecurityException(msg); + } + ArrayList<Intent> list = mStickyBroadcasts.get(intent.getAction()); + if (list != null) { + int N = list.size(); + int i; + for (i=0; i<N; i++) { + if (intent.filterEquals(list.get(i))) { + list.remove(i); + break; + } + } + } + } + } + + private final boolean finishReceiverLocked(IBinder receiver, int resultCode, + String resultData, Bundle resultExtras, boolean resultAbort, + boolean explicit) { + if (mOrderedBroadcasts.size() == 0) { + if (explicit) { + Log.w(TAG, "finishReceiver called but no pending broadcasts"); + } + return false; + } + BroadcastRecord r = mOrderedBroadcasts.get(0); + if (r.receiver == null) { + if (explicit) { + Log.w(TAG, "finishReceiver called but none active"); + } + return false; + } + if (r.receiver != receiver) { + Log.w(TAG, "finishReceiver called but active receiver is different"); + return false; + } + int state = r.state; + r.state = r.IDLE; + if (state == r.IDLE) { + if (explicit) { + Log.w(TAG, "finishReceiver called but state is IDLE"); + } + } + r.receiver = null; + r.intent.setComponent(null); + if (r.curApp != null) { + r.curApp.curReceiver = null; + } + if (r.curFilter != null) { + r.curFilter.receiverList.curBroadcast = null; + } + r.curFilter = null; + r.curApp = null; + r.curComponent = null; + r.curReceiver = null; + mPendingBroadcast = null; + + r.resultCode = resultCode; + r.resultData = resultData; + r.resultExtras = resultExtras; + r.resultAbort = resultAbort; + + // We will process the next receiver right now if this is finishing + // an app receiver (which is always asynchronous) or after we have + // come back from calling a receiver. + return state == BroadcastRecord.APP_RECEIVE + || state == BroadcastRecord.CALL_DONE_RECEIVE; + } + + public void finishReceiver(IBinder who, int resultCode, String resultData, + Bundle resultExtras, boolean resultAbort) { + if (DEBUG_BROADCAST) Log.v(TAG, "Finish receiver: " + who); + + // Refuse possible leaked file descriptors + if (resultExtras != null && resultExtras.hasFileDescriptors()) { + throw new IllegalArgumentException("File descriptors passed in Bundle"); + } + + boolean doNext; + + final long origId = Binder.clearCallingIdentity(); + + synchronized(this) { + doNext = finishReceiverLocked( + who, resultCode, resultData, resultExtras, resultAbort, true); + } + + if (doNext) { + processNextBroadcast(false); + } + trimApplications(); + + Binder.restoreCallingIdentity(origId); + } + + private final void logBroadcastReceiverDiscard(BroadcastRecord r) { + if (r.nextReceiver > 0) { + Object curReceiver = r.receivers.get(r.nextReceiver-1); + if (curReceiver instanceof BroadcastFilter) { + BroadcastFilter bf = (BroadcastFilter) curReceiver; + EventLog.writeEvent(LOG_AM_BROADCAST_DISCARD_FILTER, + System.identityHashCode(r), + r.intent.getAction(), + r.nextReceiver - 1, + System.identityHashCode(bf)); + } else { + EventLog.writeEvent(LOG_AM_BROADCAST_DISCARD_APP, + System.identityHashCode(r), + r.intent.getAction(), + r.nextReceiver - 1, + ((ResolveInfo)curReceiver).toString()); + } + } else { + Log.w(TAG, "Discarding broadcast before first receiver is invoked: " + + r); + EventLog.writeEvent(LOG_AM_BROADCAST_DISCARD_APP, + System.identityHashCode(r), + r.intent.getAction(), + r.nextReceiver, + "NONE"); + } + } + + private final void broadcastTimeout() { + synchronized (this) { + if (mOrderedBroadcasts.size() == 0) { + return; + } + long now = SystemClock.uptimeMillis(); + BroadcastRecord r = mOrderedBroadcasts.get(0); + if ((r.startTime+BROADCAST_TIMEOUT) > now) { + if (DEBUG_BROADCAST) Log.v(TAG, + "Premature timeout @ " + now + ": resetting BROADCAST_TIMEOUT_MSG for " + + (r.startTime + BROADCAST_TIMEOUT)); + Message msg = mHandler.obtainMessage(BROADCAST_TIMEOUT_MSG); + mHandler.sendMessageAtTime(msg, r.startTime+BROADCAST_TIMEOUT); + return; + } + + Log.w(TAG, "Timeout of broadcast " + r + " - receiver=" + r.receiver); + r.startTime = now; + r.anrCount++; + + // Current receiver has passed its expiration date. + if (r.nextReceiver <= 0) { + Log.w(TAG, "Timeout on receiver with nextReceiver <= 0"); + return; + } + + ProcessRecord app = null; + + Object curReceiver = r.receivers.get(r.nextReceiver-1); + Log.w(TAG, "Receiver during timeout: " + curReceiver); + logBroadcastReceiverDiscard(r); + if (curReceiver instanceof BroadcastFilter) { + BroadcastFilter bf = (BroadcastFilter)curReceiver; + if (bf.receiverList.pid != 0 + && bf.receiverList.pid != MY_PID) { + synchronized (this.mPidsSelfLocked) { + app = this.mPidsSelfLocked.get( + bf.receiverList.pid); + } + } + } else { + app = r.curApp; + } + + if (app != null) { + appNotRespondingLocked(app, null, "Broadcast of " + r.intent.toString()); + } + + if (mPendingBroadcast == r) { + mPendingBroadcast = null; + } + + // Move on to the next receiver. + finishReceiverLocked(r.receiver, r.resultCode, r.resultData, + r.resultExtras, r.resultAbort, true); + scheduleBroadcastsLocked(); + } + } + + private final void processCurBroadcastLocked(BroadcastRecord r, + ProcessRecord app) throws RemoteException { + if (app.thread == null) { + throw new RemoteException(); + } + r.receiver = app.thread.asBinder(); + r.curApp = app; + app.curReceiver = r; + updateLRUListLocked(app, true); + + // Tell the application to launch this receiver. + r.intent.setComponent(r.curComponent); + + boolean started = false; + try { + if (DEBUG_BROADCAST) Log.v(TAG, + "Delivering to component " + r.curComponent + + ": " + r); + app.thread.scheduleReceiver(new Intent(r.intent), r.curReceiver, + r.resultCode, r.resultData, r.resultExtras, r.ordered); + started = true; + } finally { + if (!started) { + r.receiver = null; + r.curApp = null; + app.curReceiver = null; + } + } + + } + + static void performReceive(ProcessRecord app, IIntentReceiver receiver, + Intent intent, int resultCode, String data, + Bundle extras, boolean ordered) throws RemoteException { + if (app != null && app.thread != null) { + // If we have an app thread, do the call through that so it is + // correctly ordered with other one-way calls. + app.thread.scheduleRegisteredReceiver(receiver, intent, resultCode, + data, extras, ordered); + } else { + receiver.performReceive(intent, resultCode, data, extras, ordered); + } + } + + private final void deliverToRegisteredReceiver(BroadcastRecord r, + BroadcastFilter filter, boolean ordered) { + boolean skip = false; + if (filter.requiredPermission != null) { + int perm = checkComponentPermission(filter.requiredPermission, + r.callingPid, r.callingUid, -1); + if (perm != PackageManager.PERMISSION_GRANTED) { + Log.w(TAG, "Permission Denial: broadcasting " + + r.intent.toString() + + " from " + r.callerPackage + " (pid=" + + r.callingPid + ", uid=" + r.callingUid + ")" + + " requires " + filter.requiredPermission + + " due to registered receiver " + filter); + skip = true; + } + } + if (r.requiredPermission != null) { + int perm = checkComponentPermission(r.requiredPermission, + filter.receiverList.pid, filter.receiverList.uid, -1); + if (perm != PackageManager.PERMISSION_GRANTED) { + Log.w(TAG, "Permission Denial: receiving " + + r.intent.toString() + + " to " + filter.receiverList.app + + " (pid=" + filter.receiverList.pid + + ", uid=" + filter.receiverList.uid + ")" + + " requires " + r.requiredPermission + + " due to sender " + r.callerPackage + + " (uid " + r.callingUid + ")"); + skip = true; + } + } + + if (!skip) { + // If this is not being sent as an ordered broadcast, then we + // don't want to touch the fields that keep track of the current + // state of ordered broadcasts. + if (ordered) { + r.receiver = filter.receiverList.receiver.asBinder(); + r.curFilter = filter; + filter.receiverList.curBroadcast = r; + r.state = BroadcastRecord.CALL_IN_RECEIVE; + } + try { + if (DEBUG_BROADCAST) { + int seq = r.intent.getIntExtra("seq", -1); + Log.i(TAG, "Sending broadcast " + r.intent.getAction() + " seq=" + seq + + " app=" + filter.receiverList.app); + } + performReceive(filter.receiverList.app, filter.receiverList.receiver, + new Intent(r.intent), r.resultCode, + r.resultData, r.resultExtras, r.ordered); + if (ordered) { + r.state = BroadcastRecord.CALL_DONE_RECEIVE; + } + } catch (RemoteException e) { + Log.w(TAG, "Failure sending broadcast " + r.intent, e); + if (ordered) { + r.receiver = null; + r.curFilter = null; + filter.receiverList.curBroadcast = null; + } + } + } + } + + private final void processNextBroadcast(boolean fromMsg) { + synchronized(this) { + BroadcastRecord r; + + if (DEBUG_BROADCAST) Log.v(TAG, "processNextBroadcast: " + + mParallelBroadcasts.size() + " broadcasts, " + + mOrderedBroadcasts.size() + " serialized broadcasts"); + + updateCpuStats(); + + if (fromMsg) { + mBroadcastsScheduled = false; + } + + // First, deliver any non-serialized broadcasts right away. + while (mParallelBroadcasts.size() > 0) { + r = mParallelBroadcasts.remove(0); + final int N = r.receivers.size(); + for (int i=0; i<N; i++) { + Object target = r.receivers.get(i); + if (DEBUG_BROADCAST) Log.v(TAG, + "Delivering non-serialized to registered " + + target + ": " + r); + deliverToRegisteredReceiver(r, (BroadcastFilter)target, false); + } + } + + // Now take care of the next serialized one... + + // If we are waiting for a process to come up to handle the next + // broadcast, then do nothing at this point. Just in case, we + // check that the process we're waiting for still exists. + if (mPendingBroadcast != null) { + Log.i(TAG, "processNextBroadcast: waiting for " + + mPendingBroadcast.curApp); + + boolean isDead; + synchronized (mPidsSelfLocked) { + isDead = (mPidsSelfLocked.get(mPendingBroadcast.curApp.pid) == null); + } + if (!isDead) { + // It's still alive, so keep waiting + return; + } else { + Log.w(TAG, "pending app " + mPendingBroadcast.curApp + + " died before responding to broadcast"); + mPendingBroadcast = null; + } + } + + do { + if (mOrderedBroadcasts.size() == 0) { + // No more broadcasts pending, so all done! + scheduleAppGcsLocked(); + return; + } + r = mOrderedBroadcasts.get(0); + boolean forceReceive = false; + + // Ensure that even if something goes awry with the timeout + // detection, we catch "hung" broadcasts here, discard them, + // and continue to make progress. + int numReceivers = (r.receivers != null) ? r.receivers.size() : 0; + long now = SystemClock.uptimeMillis(); + if (r.dispatchTime > 0) { + if ((numReceivers > 0) && + (now > r.dispatchTime + (2*BROADCAST_TIMEOUT*numReceivers))) { + Log.w(TAG, "Hung broadcast discarded after timeout failure:" + + " now=" + now + + " dispatchTime=" + r.dispatchTime + + " startTime=" + r.startTime + + " intent=" + r.intent + + " numReceivers=" + numReceivers + + " nextReceiver=" + r.nextReceiver + + " state=" + r.state); + broadcastTimeout(); // forcibly finish this broadcast + forceReceive = true; + r.state = BroadcastRecord.IDLE; + } + } + + if (r.state != BroadcastRecord.IDLE) { + if (DEBUG_BROADCAST) Log.d(TAG, + "processNextBroadcast() called when not idle (state=" + + r.state + ")"); + return; + } + + if (r.receivers == null || r.nextReceiver >= numReceivers + || r.resultAbort || forceReceive) { + // No more receivers for this broadcast! Send the final + // result if requested... + if (r.resultTo != null) { + try { + if (DEBUG_BROADCAST) { + int seq = r.intent.getIntExtra("seq", -1); + Log.i(TAG, "Finishing broadcast " + r.intent.getAction() + + " seq=" + seq + " app=" + r.callerApp); + } + performReceive(r.callerApp, r.resultTo, + new Intent(r.intent), r.resultCode, + r.resultData, r.resultExtras, false); + } catch (RemoteException e) { + Log.w(TAG, "Failure sending broadcast result of " + r.intent, e); + } + } + + if (DEBUG_BROADCAST) Log.v(TAG, "Cancelling BROADCAST_TIMEOUT_MSG"); + mHandler.removeMessages(BROADCAST_TIMEOUT_MSG); + + // ... and on to the next... + mOrderedBroadcasts.remove(0); + r = null; + continue; + } + } while (r == null); + + // Get the next receiver... + int recIdx = r.nextReceiver++; + + // Keep track of when this receiver started, and make sure there + // is a timeout message pending to kill it if need be. + r.startTime = SystemClock.uptimeMillis(); + if (recIdx == 0) { + r.dispatchTime = r.startTime; + + if (DEBUG_BROADCAST) Log.v(TAG, + "Submitting BROADCAST_TIMEOUT_MSG for " + + (r.startTime + BROADCAST_TIMEOUT)); + Message msg = mHandler.obtainMessage(BROADCAST_TIMEOUT_MSG); + mHandler.sendMessageAtTime(msg, r.startTime+BROADCAST_TIMEOUT); + } + + Object nextReceiver = r.receivers.get(recIdx); + if (nextReceiver instanceof BroadcastFilter) { + // Simple case: this is a registered receiver who gets + // a direct call. + BroadcastFilter filter = (BroadcastFilter)nextReceiver; + if (DEBUG_BROADCAST) Log.v(TAG, + "Delivering serialized to registered " + + filter + ": " + r); + deliverToRegisteredReceiver(r, filter, r.ordered); + if (r.receiver == null || !r.ordered) { + // The receiver has already finished, so schedule to + // process the next one. + r.state = BroadcastRecord.IDLE; + scheduleBroadcastsLocked(); + } + return; + } + + // Hard case: need to instantiate the receiver, possibly + // starting its application process to host it. + + ResolveInfo info = + (ResolveInfo)nextReceiver; + + boolean skip = false; + int perm = checkComponentPermission(info.activityInfo.permission, + r.callingPid, r.callingUid, + info.activityInfo.exported + ? -1 : info.activityInfo.applicationInfo.uid); + if (perm != PackageManager.PERMISSION_GRANTED) { + Log.w(TAG, "Permission Denial: broadcasting " + + r.intent.toString() + + " from " + r.callerPackage + " (pid=" + r.callingPid + + ", uid=" + r.callingUid + ")" + + " requires " + info.activityInfo.permission + + " due to receiver " + info.activityInfo.packageName + + "/" + info.activityInfo.name); + skip = true; + } + if (r.callingUid != Process.SYSTEM_UID && + r.requiredPermission != null) { + try { + perm = ActivityThread.getPackageManager(). + checkPermission(r.requiredPermission, + info.activityInfo.applicationInfo.packageName); + } catch (RemoteException e) { + perm = PackageManager.PERMISSION_DENIED; + } + if (perm != PackageManager.PERMISSION_GRANTED) { + Log.w(TAG, "Permission Denial: receiving " + + r.intent + " to " + + info.activityInfo.applicationInfo.packageName + + " requires " + r.requiredPermission + + " due to sender " + r.callerPackage + + " (uid " + r.callingUid + ")"); + skip = true; + } + } + if (r.curApp != null && r.curApp.crashing) { + // If the target process is crashing, just skip it. + skip = true; + } + + if (skip) { + r.receiver = null; + r.curFilter = null; + r.state = BroadcastRecord.IDLE; + scheduleBroadcastsLocked(); + return; + } + + r.state = BroadcastRecord.APP_RECEIVE; + String targetProcess = info.activityInfo.processName; + r.curComponent = new ComponentName( + info.activityInfo.applicationInfo.packageName, + info.activityInfo.name); + r.curReceiver = info.activityInfo; + + // Is this receiver's application already running? + ProcessRecord app = getProcessRecordLocked(targetProcess, + info.activityInfo.applicationInfo.uid); + if (app != null && app.thread != null) { + try { + processCurBroadcastLocked(r, app); + return; + } catch (RemoteException e) { + Log.w(TAG, "Exception when sending broadcast to " + + r.curComponent, e); + } + + // If a dead object exception was thrown -- fall through to + // restart the application. + } + + // Not running -- get it started, and enqueue this history record + // to be executed when the app comes up. + if ((r.curApp=startProcessLocked(targetProcess, + info.activityInfo.applicationInfo, true, + r.intent.getFlags() | Intent.FLAG_FROM_BACKGROUND, + "broadcast", r.curComponent)) == null) { + // Ah, this recipient is unavailable. Finish it if necessary, + // and mark the broadcast record as ready for the next. + Log.w(TAG, "Unable to launch app " + + info.activityInfo.applicationInfo.packageName + "/" + + info.activityInfo.applicationInfo.uid + " for broadcast " + + r.intent + ": process is bad"); + logBroadcastReceiverDiscard(r); + finishReceiverLocked(r.receiver, r.resultCode, r.resultData, + r.resultExtras, r.resultAbort, true); + scheduleBroadcastsLocked(); + r.state = BroadcastRecord.IDLE; + return; + } + + mPendingBroadcast = r; + } + } + + // ========================================================= + // INSTRUMENTATION + // ========================================================= + + public boolean startInstrumentation(ComponentName className, + String profileFile, int flags, Bundle arguments, + IInstrumentationWatcher watcher) { + // Refuse possible leaked file descriptors + if (arguments != null && arguments.hasFileDescriptors()) { + throw new IllegalArgumentException("File descriptors passed in Bundle"); + } + + synchronized(this) { + InstrumentationInfo ii = null; + ApplicationInfo ai = null; + try { + ii = mContext.getPackageManager().getInstrumentationInfo( + className, 0); + ai = mContext.getPackageManager().getApplicationInfo( + ii.targetPackage, PackageManager.GET_SHARED_LIBRARY_FILES); + } catch (PackageManager.NameNotFoundException e) { + } + if (ii == null) { + reportStartInstrumentationFailure(watcher, className, + "Unable to find instrumentation info for: " + className); + return false; + } + if (ai == null) { + reportStartInstrumentationFailure(watcher, className, + "Unable to find instrumentation target package: " + ii.targetPackage); + return false; + } + + int match = mContext.getPackageManager().checkSignatures( + ii.targetPackage, ii.packageName); + if (match < 0 && match != PackageManager.SIGNATURE_FIRST_NOT_SIGNED) { + String msg = "Permission Denial: starting instrumentation " + + className + " from pid=" + + Binder.getCallingPid() + + ", uid=" + Binder.getCallingPid() + + " not allowed because package " + ii.packageName + + " does not have a signature matching the target " + + ii.targetPackage; + reportStartInstrumentationFailure(watcher, className, msg); + throw new SecurityException(msg); + } + + final long origId = Binder.clearCallingIdentity(); + uninstallPackageLocked(ii.targetPackage, -1, true); + ProcessRecord app = addAppLocked(ai); + app.instrumentationClass = className; + app.instrumentationProfileFile = profileFile; + app.instrumentationArguments = arguments; + app.instrumentationWatcher = watcher; + app.instrumentationResultClass = className; + Binder.restoreCallingIdentity(origId); + } + + return true; + } + + /** + * Report errors that occur while attempting to start Instrumentation. Always writes the + * error to the logs, but if somebody is watching, send the report there too. This enables + * the "am" command to report errors with more information. + * + * @param watcher The IInstrumentationWatcher. Null if there isn't one. + * @param cn The component name of the instrumentation. + * @param report The error report. + */ + private void reportStartInstrumentationFailure(IInstrumentationWatcher watcher, + ComponentName cn, String report) { + Log.w(TAG, report); + try { + if (watcher != null) { + Bundle results = new Bundle(); + results.putString(Instrumentation.REPORT_KEY_IDENTIFIER, "ActivityManagerService"); + results.putString("Error", report); + watcher.instrumentationStatus(cn, -1, results); + } + } catch (RemoteException e) { + Log.w(TAG, e); + } + } + + void finishInstrumentationLocked(ProcessRecord app, int resultCode, Bundle results) { + if (app.instrumentationWatcher != null) { + try { + // NOTE: IInstrumentationWatcher *must* be oneway here + app.instrumentationWatcher.instrumentationFinished( + app.instrumentationClass, + resultCode, + results); + } catch (RemoteException e) { + } + } + app.instrumentationWatcher = null; + app.instrumentationClass = null; + app.instrumentationProfileFile = null; + app.instrumentationArguments = null; + + uninstallPackageLocked(app.processName, -1, false); + } + + public void finishInstrumentation(IApplicationThread target, + int resultCode, Bundle results) { + // Refuse possible leaked file descriptors + if (results != null && results.hasFileDescriptors()) { + throw new IllegalArgumentException("File descriptors passed in Intent"); + } + + synchronized(this) { + ProcessRecord app = getRecordForAppLocked(target); + if (app == null) { + Log.w(TAG, "finishInstrumentation: no app for " + target); + return; + } + final long origId = Binder.clearCallingIdentity(); + finishInstrumentationLocked(app, resultCode, results); + Binder.restoreCallingIdentity(origId); + } + } + + // ========================================================= + // CONFIGURATION + // ========================================================= + + public ConfigurationInfo getDeviceConfigurationInfo() { + ConfigurationInfo config = new ConfigurationInfo(); + synchronized (this) { + config.reqTouchScreen = mConfiguration.touchscreen; + config.reqKeyboardType = mConfiguration.keyboard; + config.reqNavigation = mConfiguration.navigation; + if (mConfiguration.navigation != Configuration.NAVIGATION_NONAV) { + config.reqInputFeatures |= ConfigurationInfo.INPUT_FEATURE_FIVE_WAY_NAV; + } + if (mConfiguration.keyboard != Configuration.KEYBOARD_UNDEFINED) { + config.reqInputFeatures |= ConfigurationInfo.INPUT_FEATURE_HARD_KEYBOARD; + } + } + return config; + } + + public Configuration getConfiguration() { + Configuration ci; + synchronized(this) { + ci = new Configuration(mConfiguration); + } + return ci; + } + + public void updateConfiguration(Configuration values) { + enforceCallingPermission(android.Manifest.permission.CHANGE_CONFIGURATION, + "updateConfiguration()"); + + synchronized(this) { + if (values == null && mWindowManager != null) { + // sentinel: fetch the current configuration from the window manager + values = mWindowManager.computeNewConfiguration(); + } + + final long origId = Binder.clearCallingIdentity(); + updateConfigurationLocked(values, null); + Binder.restoreCallingIdentity(origId); + } + } + + /** + * Do either or both things: (1) change the current configuration, and (2) + * make sure the given activity is running with the (now) current + * configuration. Returns true if the activity has been left running, or + * false if <var>starting</var> is being destroyed to match the new + * configuration. + */ + public boolean updateConfigurationLocked(Configuration values, + HistoryRecord starting) { + int changes = 0; + + boolean kept = true; + + if (values != null) { + Configuration newConfig = new Configuration(mConfiguration); + changes = newConfig.updateFrom(values); + if (changes != 0) { + if (DEBUG_SWITCH) { + Log.i(TAG, "Updating configuration to: " + values); + } + + EventLog.writeEvent(LOG_CONFIGURATION_CHANGED, changes); + + if (values.locale != null) { + saveLocaleLocked(values.locale, + !values.locale.equals(mConfiguration.locale), + values.userSetLocale); + } + + mConfiguration = newConfig; + + Message msg = mHandler.obtainMessage(UPDATE_CONFIGURATION_MSG); + msg.obj = new Configuration(mConfiguration); + mHandler.sendMessage(msg); + + final int N = mLRUProcesses.size(); + for (int i=0; i<N; i++) { + ProcessRecord app = mLRUProcesses.get(i); + try { + if (app.thread != null) { + app.thread.scheduleConfigurationChanged(mConfiguration); + } + } catch (Exception e) { + } + } + Intent intent = new Intent(Intent.ACTION_CONFIGURATION_CHANGED); + broadcastIntentLocked(null, null, intent, null, null, 0, null, null, + null, false, false, MY_PID, Process.SYSTEM_UID); + } + } + + if (changes != 0 && starting == null) { + // If the configuration changed, and the caller is not already + // in the process of starting an activity, then find the top + // activity to check if its configuration needs to change. + starting = topRunningActivityLocked(null); + } + + if (starting != null) { + kept = ensureActivityConfigurationLocked(starting, changes); + if (kept) { + // If this didn't result in the starting activity being + // destroyed, then we need to make sure at this point that all + // other activities are made visible. + if (DEBUG_SWITCH) Log.i(TAG, "Config didn't destroy " + starting + + ", ensuring others are correct."); + ensureActivitiesVisibleLocked(starting, changes); + } + } + + return kept; + } + + private final boolean relaunchActivityLocked(HistoryRecord r, + int changes, boolean andResume) { + List<ResultInfo> results = null; + List<Intent> newIntents = null; + if (andResume) { + results = r.results; + newIntents = r.newIntents; + } + if (DEBUG_SWITCH) Log.v(TAG, "Relaunching: " + r + + " with results=" + results + " newIntents=" + newIntents + + " andResume=" + andResume); + EventLog.writeEvent(andResume ? LOG_AM_RELAUNCH_RESUME_ACTIVITY + : LOG_AM_RELAUNCH_ACTIVITY, System.identityHashCode(r), + r.task.taskId, r.shortComponentName); + + r.startFreezingScreenLocked(r.app, 0); + + try { + if (DEBUG_SWITCH) Log.i(TAG, "Switch is restarting resumed " + r); + r.app.thread.scheduleRelaunchActivity(r, results, newIntents, + changes, !andResume); + // Note: don't need to call pauseIfSleepingLocked() here, because + // the caller will only pass in 'andResume' if this activity is + // currently resumed, which implies we aren't sleeping. + } catch (RemoteException e) { + return false; + } + + if (andResume) { + r.results = null; + r.newIntents = null; + } + + return true; + } + + /** + * Make sure the given activity matches the current configuration. Returns + * false if the activity had to be destroyed. Returns true if the + * configuration is the same, or the activity will remain running as-is + * for whatever reason. Ensures the HistoryRecord is updated with the + * correct configuration and all other bookkeeping is handled. + */ + private final boolean ensureActivityConfigurationLocked(HistoryRecord r, + int globalChanges) { + if (DEBUG_SWITCH) Log.i(TAG, "Ensuring correct configuration: " + r); + + // Short circuit: if the two configurations are the exact same + // object (the common case), then there is nothing to do. + Configuration newConfig = mConfiguration; + if (r.configuration == newConfig) { + if (DEBUG_SWITCH) Log.i(TAG, "Configuration unchanged in " + r); + return true; + } + + // We don't worry about activities that are finishing. + if (r.finishing) { + if (DEBUG_SWITCH) Log.i(TAG, + "Configuration doesn't matter in finishing " + r); + r.stopFreezingScreenLocked(false); + return true; + } + + // Okay we now are going to make this activity have the new config. + // But then we need to figure out how it needs to deal with that. + Configuration oldConfig = r.configuration; + r.configuration = newConfig; + + // If the activity isn't currently running, just leave the new + // configuration and it will pick that up next time it starts. + if (r.app == null || r.app.thread == null) { + if (DEBUG_SWITCH) Log.i(TAG, + "Configuration doesn't matter not running " + r); + r.stopFreezingScreenLocked(false); + return true; + } + + // If the activity isn't persistent, there is a chance we will + // need to restart it. + if (!r.persistent) { + + // Figure out what has changed between the two configurations. + int changes = oldConfig.diff(newConfig); + if (DEBUG_SWITCH) { + Log.i(TAG, "Checking to restart " + r.info.name + ": changed=0x" + + Integer.toHexString(changes) + ", handles=0x" + + Integer.toHexString(r.info.configChanges)); + } + if ((changes&(~r.info.configChanges)) != 0) { + // Aha, the activity isn't handling the change, so DIE DIE DIE. + r.configChangeFlags |= changes; + r.startFreezingScreenLocked(r.app, globalChanges); + if (r.app == null || r.app.thread == null) { + if (DEBUG_SWITCH) Log.i(TAG, "Switch is destroying non-running " + r); + destroyActivityLocked(r, true); + } else if (r.state == ActivityState.PAUSING) { + // A little annoying: we are waiting for this activity to + // finish pausing. Let's not do anything now, but just + // flag that it needs to be restarted when done pausing. + r.configDestroy = true; + return true; + } else if (r.state == ActivityState.RESUMED) { + // Try to optimize this case: the configuration is changing + // and we need to restart the top, resumed activity. + // Instead of doing the normal handshaking, just say + // "restart!". + if (DEBUG_SWITCH) Log.i(TAG, "Switch is restarting resumed " + r); + relaunchActivityLocked(r, r.configChangeFlags, true); + r.configChangeFlags = 0; + } else { + if (DEBUG_SWITCH) Log.i(TAG, "Switch is restarting non-resumed " + r); + relaunchActivityLocked(r, r.configChangeFlags, false); + r.configChangeFlags = 0; + } + + // All done... tell the caller we weren't able to keep this + // activity around. + return false; + } + } + + // Default case: the activity can handle this new configuration, so + // hand it over. Note that we don't need to give it the new + // configuration, since we always send configuration changes to all + // process when they happen so it can just use whatever configuration + // it last got. + if (r.app != null && r.app.thread != null) { + try { + r.app.thread.scheduleActivityConfigurationChanged(r); + } catch (RemoteException e) { + // If process died, whatever. + } + } + r.stopFreezingScreenLocked(false); + + return true; + } + + /** + * Save the locale. You must be inside a synchronized (this) block. + */ + private void saveLocaleLocked(Locale l, boolean isDiff, boolean isPersist) { + if(isDiff) { + SystemProperties.set("user.language", l.getLanguage()); + SystemProperties.set("user.region", l.getCountry()); + } + + if(isPersist) { + SystemProperties.set("persist.sys.language", l.getLanguage()); + SystemProperties.set("persist.sys.country", l.getCountry()); + SystemProperties.set("persist.sys.localevar", l.getVariant()); + } + } + + // ========================================================= + // LIFETIME MANAGEMENT + // ========================================================= + + private final int computeOomAdjLocked( + ProcessRecord app, int hiddenAdj, ProcessRecord TOP_APP) { + if (mAdjSeq == app.adjSeq) { + // This adjustment has already been computed. + return app.curAdj; + } + + if (app.thread == null) { + app.adjSeq = mAdjSeq; + return (app.curAdj=EMPTY_APP_ADJ); + } + + app.isForeground = false; + + // Right now there are three interesting states: it is + // either the foreground app, background with activities, + // or background without activities. + int adj; + int N; + if (app == TOP_APP || app.instrumentationClass != null + || app.persistentActivities > 0) { + // The last app on the list is the foreground app. + adj = FOREGROUND_APP_ADJ; + app.isForeground = true; + } else if (app.curReceiver != null || + (mPendingBroadcast != null && mPendingBroadcast.curApp == app)) { + // An app that is currently receiving a broadcast also + // counts as being in the foreground. + adj = FOREGROUND_APP_ADJ; + } else if (app.executingServices.size() > 0) { + // An app that is currently executing a service callback also + // counts as being in the foreground. + adj = FOREGROUND_APP_ADJ; + } else if (app.foregroundServices || app.forcingToForeground != null) { + // The user is aware of this app, so make it visible. + adj = VISIBLE_APP_ADJ; + } else if ((N=app.activities.size()) != 0) { + // This app is in the background with paused activities. + adj = hiddenAdj; + for (int j=0; j<N; j++) { + if (((HistoryRecord)app.activities.get(j)).visible) { + // This app has a visible activity! + adj = VISIBLE_APP_ADJ; + break; + } + } + } else { + // A very not-needed process. + adj = EMPTY_APP_ADJ; + } + + // By default, we use the computed adjusted. It may be changed if + // there are applications dependent on our services or providers, but + // this gives us a baseline and makes sure we don't get into an + // infinite recursion. + app.adjSeq = mAdjSeq; + app.curRawAdj = adj; + app.curAdj = adj <= app.maxAdj ? adj : app.maxAdj; + + if (app.services.size() != 0 && adj > FOREGROUND_APP_ADJ) { + // If this process has active services running in it, we would + // like to avoid killing it unless it would prevent the current + // application from running. + if (adj > hiddenAdj) { + adj = hiddenAdj; + } + final long now = SystemClock.uptimeMillis(); + // This process is more important if the top activity is + // bound to the service. + Iterator jt = app.services.iterator(); + while (jt.hasNext() && adj > FOREGROUND_APP_ADJ) { + ServiceRecord s = (ServiceRecord)jt.next(); + if (s.startRequested) { + if (now < (s.lastActivity+MAX_SERVICE_INACTIVITY)) { + // This service has seen some activity within + // recent memory, so we will keep its process ahead + // of the background processes. + if (adj > SECONDARY_SERVER_ADJ) { + adj = SECONDARY_SERVER_ADJ; + } + } else { + // This service has been inactive for too long, just + // put it with the rest of the background processes. + if (adj > hiddenAdj) { + adj = hiddenAdj; + } + } + } + if (s.connections.size() > 0 && adj > FOREGROUND_APP_ADJ) { + Iterator<ConnectionRecord> kt + = s.connections.values().iterator(); + while (kt.hasNext() && adj > FOREGROUND_APP_ADJ) { + // XXX should compute this based on the max of + // all connected clients. + ConnectionRecord cr = kt.next(); + if ((cr.flags&Context.BIND_AUTO_CREATE) != 0) { + ProcessRecord client = cr.binding.client; + int myHiddenAdj = hiddenAdj; + if (myHiddenAdj > client.hiddenAdj) { + if (client.hiddenAdj > VISIBLE_APP_ADJ) { + myHiddenAdj = client.hiddenAdj; + } else { + myHiddenAdj = VISIBLE_APP_ADJ; + } + } + int clientAdj = computeOomAdjLocked( + client, myHiddenAdj, TOP_APP); + if (adj > clientAdj) { + adj = clientAdj > VISIBLE_APP_ADJ + ? clientAdj : VISIBLE_APP_ADJ; + } + } + HistoryRecord a = cr.activity; + //if (a != null) { + // Log.i(TAG, "Connection to " + a ": state=" + a.state); + //} + if (a != null && adj > FOREGROUND_APP_ADJ && + (a.state == ActivityState.RESUMED + || a.state == ActivityState.PAUSING)) { + adj = FOREGROUND_APP_ADJ; + } + } + } + } + } + + if (app.pubProviders.size() != 0 && adj > FOREGROUND_APP_ADJ) { + // If this process has published any content providers, then + // its adjustment makes it at least as important as any of the + // processes using those providers, and no less important than + // CONTENT_PROVIDER_ADJ, which is just shy of EMPTY. + if (adj > CONTENT_PROVIDER_ADJ) { + adj = CONTENT_PROVIDER_ADJ; + } + Iterator jt = app.pubProviders.values().iterator(); + while (jt.hasNext() && adj > FOREGROUND_APP_ADJ) { + ContentProviderRecord cpr = (ContentProviderRecord)jt.next(); + if (cpr.clients.size() != 0) { + Iterator<ProcessRecord> kt = cpr.clients.iterator(); + while (kt.hasNext() && adj > FOREGROUND_APP_ADJ) { + ProcessRecord client = kt.next(); + int myHiddenAdj = hiddenAdj; + if (myHiddenAdj > client.hiddenAdj) { + if (client.hiddenAdj > FOREGROUND_APP_ADJ) { + myHiddenAdj = client.hiddenAdj; + } else { + myHiddenAdj = FOREGROUND_APP_ADJ; + } + } + int clientAdj = computeOomAdjLocked( + client, myHiddenAdj, TOP_APP); + if (adj > clientAdj) { + adj = clientAdj > FOREGROUND_APP_ADJ + ? clientAdj : FOREGROUND_APP_ADJ; + } + } + } + // If the provider has external (non-framework) process + // dependencies, ensure that its adjustment is at least + // FOREGROUND_APP_ADJ. + if (cpr.externals != 0) { + if (adj > FOREGROUND_APP_ADJ) { + adj = FOREGROUND_APP_ADJ; + } + } + } + } + + app.curRawAdj = adj; + + //Log.i(TAG, "OOM ADJ " + app + ": pid=" + app.pid + + // " adj=" + adj + " curAdj=" + app.curAdj + " maxAdj=" + app.maxAdj); + if (adj > app.maxAdj) { + adj = app.maxAdj; + } + + app.curAdj = adj; + + return adj; + } + + /** + * Ask a given process to GC right now. + */ + final void performAppGcLocked(ProcessRecord app) { + try { + app.lastRequestedGc = SystemClock.uptimeMillis(); + if (app.thread != null) { + app.thread.processInBackground(); + } + } catch (Exception e) { + // whatever. + } + } + + /** + * Returns true if things are idle enough to perform GCs. + */ + private final boolean canGcNow() { + return mParallelBroadcasts.size() == 0 + && mOrderedBroadcasts.size() == 0 + && (mSleeping || (mResumedActivity != null && + mResumedActivity.idle)); + } + + /** + * Perform GCs on all processes that are waiting for it, but only + * if things are idle. + */ + final void performAppGcsLocked() { + final int N = mProcessesToGc.size(); + if (N <= 0) { + return; + } + if (canGcNow()) { + while (mProcessesToGc.size() > 0) { + ProcessRecord proc = mProcessesToGc.remove(0); + if (proc.curRawAdj > VISIBLE_APP_ADJ) { + // To avoid spamming the system, we will GC processes one + // at a time, waiting a few seconds between each. + performAppGcLocked(proc); + scheduleAppGcsLocked(); + return; + } + } + } + } + + /** + * If all looks good, perform GCs on all processes waiting for them. + */ + final void performAppGcsIfAppropriateLocked() { + if (canGcNow()) { + performAppGcsLocked(); + return; + } + // Still not idle, wait some more. + scheduleAppGcsLocked(); + } + + /** + * Schedule the execution of all pending app GCs. + */ + final void scheduleAppGcsLocked() { + mHandler.removeMessages(GC_BACKGROUND_PROCESSES_MSG); + Message msg = mHandler.obtainMessage(GC_BACKGROUND_PROCESSES_MSG); + mHandler.sendMessageDelayed(msg, GC_TIMEOUT); + } + + /** + * Set up to ask a process to GC itself. This will either do it + * immediately, or put it on the list of processes to gc the next + * time things are idle. + */ + final void scheduleAppGcLocked(ProcessRecord app) { + long now = SystemClock.uptimeMillis(); + if ((app.lastRequestedGc+5000) > now) { + return; + } + if (!mProcessesToGc.contains(app)) { + mProcessesToGc.add(app); + scheduleAppGcsLocked(); + } + } + + private final boolean updateOomAdjLocked( + ProcessRecord app, int hiddenAdj, ProcessRecord TOP_APP) { + app.hiddenAdj = hiddenAdj; + + if (app.thread == null) { + return true; + } + + int adj = computeOomAdjLocked(app, hiddenAdj, TOP_APP); + + //Log.i(TAG, "Computed adj " + adj + " for app " + app.processName); + //Thread priority adjustment is disabled out to see + //how the kernel scheduler performs. + if (false) { + if (app.pid != 0 && app.isForeground != app.setIsForeground) { + app.setIsForeground = app.isForeground; + if (app.pid != MY_PID) { + if (DEBUG_SWITCH || DEBUG_OOM_ADJ) Log.v(TAG, "Setting priority of " + app + + " to " + (app.isForeground + ? Process.THREAD_PRIORITY_FOREGROUND + : Process.THREAD_PRIORITY_DEFAULT)); + try { + Process.setThreadPriority(app.pid, app.isForeground + ? Process.THREAD_PRIORITY_FOREGROUND + : Process.THREAD_PRIORITY_DEFAULT); + } catch (RuntimeException e) { + Log.w(TAG, "Exception trying to set priority of application thread " + + app.pid, e); + } + } + } + } + if (app.pid != 0 && app.pid != MY_PID) { + if (app.curRawAdj != app.setRawAdj) { + if (app.curRawAdj > FOREGROUND_APP_ADJ + && app.setRawAdj <= FOREGROUND_APP_ADJ) { + // If this app is transitioning from foreground to + // non-foreground, have it do a gc. + scheduleAppGcLocked(app); + } else if (app.curRawAdj >= HIDDEN_APP_MIN_ADJ + && app.setRawAdj < HIDDEN_APP_MIN_ADJ) { + // Likewise do a gc when an app is moving in to the + // background (such as a service stopping). + scheduleAppGcLocked(app); + } + app.setRawAdj = app.curRawAdj; + } + if (adj != app.setAdj) { + if (Process.setOomAdj(app.pid, adj)) { + if (DEBUG_SWITCH || DEBUG_OOM_ADJ) Log.v( + TAG, "Set app " + app.processName + + " oom adj to " + adj); + app.setAdj = adj; + } else { + return false; + } + } + } + + return true; + } + + private final HistoryRecord resumedAppLocked() { + HistoryRecord resumedActivity = mResumedActivity; + if (resumedActivity == null || resumedActivity.app == null) { + resumedActivity = mPausingActivity; + if (resumedActivity == null || resumedActivity.app == null) { + resumedActivity = topRunningActivityLocked(null); + } + } + return resumedActivity; + } + + private final boolean updateOomAdjLocked(ProcessRecord app) { + final HistoryRecord TOP_ACT = resumedAppLocked(); + final ProcessRecord TOP_APP = TOP_ACT != null ? TOP_ACT.app : null; + int curAdj = app.curAdj; + final boolean wasHidden = app.curAdj >= HIDDEN_APP_MIN_ADJ + && app.curAdj <= HIDDEN_APP_MAX_ADJ; + + mAdjSeq++; + + final boolean res = updateOomAdjLocked(app, app.hiddenAdj, TOP_APP); + if (res) { + final boolean nowHidden = app.curAdj >= HIDDEN_APP_MIN_ADJ + && app.curAdj <= HIDDEN_APP_MAX_ADJ; + if (nowHidden != wasHidden) { + // Changed to/from hidden state, so apps after it in the LRU + // list may also be changed. + updateOomAdjLocked(); + } + } + return res; + } + + private final boolean updateOomAdjLocked() { + boolean didOomAdj = true; + final HistoryRecord TOP_ACT = resumedAppLocked(); + final ProcessRecord TOP_APP = TOP_ACT != null ? TOP_ACT.app : null; + + if (false) { + RuntimeException e = new RuntimeException(); + e.fillInStackTrace(); + Log.i(TAG, "updateOomAdj: top=" + TOP_ACT, e); + } + + mAdjSeq++; + + // First try updating the OOM adjustment for each of the + // application processes based on their current state. + int i = mLRUProcesses.size(); + int curHiddenAdj = HIDDEN_APP_MIN_ADJ; + while (i > 0) { + i--; + ProcessRecord app = mLRUProcesses.get(i); + if (updateOomAdjLocked(app, curHiddenAdj, TOP_APP)) { + if (curHiddenAdj < HIDDEN_APP_MAX_ADJ + && app.curAdj == curHiddenAdj) { + curHiddenAdj++; + } + } else { + didOomAdj = false; + } + } + + // todo: for now pretend like OOM ADJ didn't work, because things + // aren't behaving as expected on Linux -- it's not killing processes. + return ENFORCE_PROCESS_LIMIT || mProcessLimit > 0 ? false : didOomAdj; + } + + private final void trimApplications() { + synchronized (this) { + int i; + + // First remove any unused application processes whose package + // has been removed. + for (i=mRemovedProcesses.size()-1; i>=0; i--) { + final ProcessRecord app = mRemovedProcesses.get(i); + if (app.activities.size() == 0 + && app.curReceiver == null && app.services.size() == 0) { + Log.i( + TAG, "Exiting empty application process " + + app.processName + " (" + + (app.thread != null ? app.thread.asBinder() : null) + + ")\n"); + if (app.pid > 0 && app.pid != MY_PID) { + Process.killProcess(app.pid); + } else { + try { + app.thread.scheduleExit(); + } catch (Exception e) { + // Ignore exceptions. + } + } + cleanUpApplicationRecordLocked(app, false, -1); + mRemovedProcesses.remove(i); + + if (app.persistent) { + if (app.persistent) { + addAppLocked(app.info); + } + } + } + } + + // Now try updating the OOM adjustment for each of the + // application processes based on their current state. + // If the setOomAdj() API is not supported, then go with our + // back-up plan... + if (!updateOomAdjLocked()) { + + // Count how many processes are running services. + int numServiceProcs = 0; + for (i=mLRUProcesses.size()-1; i>=0; i--) { + final ProcessRecord app = mLRUProcesses.get(i); + + if (app.persistent || app.services.size() != 0 + || app.curReceiver != null + || app.persistentActivities > 0) { + // Don't count processes holding services against our + // maximum process count. + if (localLOGV) Log.v( + TAG, "Not trimming app " + app + " with services: " + + app.services); + numServiceProcs++; + } + } + + int curMaxProcs = mProcessLimit; + if (curMaxProcs <= 0) curMaxProcs = MAX_PROCESSES; + if (mAlwaysFinishActivities) { + curMaxProcs = 1; + } + curMaxProcs += numServiceProcs; + + // Quit as many processes as we can to get down to the desired + // process count. First remove any processes that no longer + // have activites running in them. + for ( i=0; + i<mLRUProcesses.size() + && mLRUProcesses.size() > curMaxProcs; + i++) { + final ProcessRecord app = mLRUProcesses.get(i); + // Quit an application only if it is not currently + // running any activities. + if (!app.persistent && app.activities.size() == 0 + && app.curReceiver == null && app.services.size() == 0) { + Log.i( + TAG, "Exiting empty application process " + + app.processName + " (" + + (app.thread != null ? app.thread.asBinder() : null) + + ")\n"); + if (app.pid > 0 && app.pid != MY_PID) { + Process.killProcess(app.pid); + } else { + try { + app.thread.scheduleExit(); + } catch (Exception e) { + // Ignore exceptions. + } + } + // todo: For now we assume the application is not buggy + // or evil, and will quit as a result of our request. + // Eventually we need to drive this off of the death + // notification, and kill the process if it takes too long. + cleanUpApplicationRecordLocked(app, false, i); + i--; + } + } + + // If we still have too many processes, now from the least + // recently used process we start finishing activities. + if (Config.LOGV) Log.v( + TAG, "*** NOW HAVE " + mLRUProcesses.size() + + " of " + curMaxProcs + " processes"); + for ( i=0; + i<mLRUProcesses.size() + && mLRUProcesses.size() > curMaxProcs; + i++) { + final ProcessRecord app = mLRUProcesses.get(i); + // Quit the application only if we have a state saved for + // all of its activities. + boolean canQuit = !app.persistent && app.curReceiver == null + && app.services.size() == 0 + && app.persistentActivities == 0; + int NUMA = app.activities.size(); + int j; + if (Config.LOGV) Log.v( + TAG, "Looking to quit " + app.processName); + for (j=0; j<NUMA && canQuit; j++) { + HistoryRecord r = (HistoryRecord)app.activities.get(j); + if (Config.LOGV) Log.v( + TAG, " " + r.intent.getComponent().flattenToShortString() + + ": frozen=" + r.haveState + ", visible=" + r.visible); + canQuit = (r.haveState || !r.stateNotNeeded) + && !r.visible && r.stopped; + } + if (canQuit) { + // Finish all of the activities, and then the app itself. + for (j=0; j<NUMA; j++) { + HistoryRecord r = (HistoryRecord)app.activities.get(j); + if (!r.finishing) { + destroyActivityLocked(r, false); + } + r.resultTo = null; + } + Log.i(TAG, "Exiting application process " + + app.processName + " (" + + (app.thread != null ? app.thread.asBinder() : null) + + ")\n"); + if (app.pid > 0 && app.pid != MY_PID) { + Process.killProcess(app.pid); + } else { + try { + app.thread.scheduleExit(); + } catch (Exception e) { + // Ignore exceptions. + } + } + // todo: For now we assume the application is not buggy + // or evil, and will quit as a result of our request. + // Eventually we need to drive this off of the death + // notification, and kill the process if it takes too long. + cleanUpApplicationRecordLocked(app, false, i); + i--; + //dump(); + } + } + + } + + int curMaxActivities = MAX_ACTIVITIES; + if (mAlwaysFinishActivities) { + curMaxActivities = 1; + } + + // Finally, if there are too many activities now running, try to + // finish as many as we can to get back down to the limit. + for ( i=0; + i<mLRUActivities.size() + && mLRUActivities.size() > curMaxActivities; + i++) { + final HistoryRecord r + = (HistoryRecord)mLRUActivities.get(i); + + // We can finish this one if we have its icicle saved and + // it is not persistent. + if ((r.haveState || !r.stateNotNeeded) && !r.visible + && r.stopped && !r.persistent && !r.finishing) { + final int origSize = mLRUActivities.size(); + destroyActivityLocked(r, true); + + // This will remove it from the LRU list, so keep + // our index at the same value. Note that this check to + // see if the size changes is just paranoia -- if + // something unexpected happens, we don't want to end up + // in an infinite loop. + if (origSize > mLRUActivities.size()) { + i--; + } + } + } + } + } + + /** This method sends the specified signal to each of the persistent apps */ + public void signalPersistentProcesses(int sig) throws RemoteException { + if (sig != Process.SIGNAL_USR1) { + throw new SecurityException("Only SIGNAL_USR1 is allowed"); + } + + synchronized (this) { + if (checkCallingPermission(android.Manifest.permission.SIGNAL_PERSISTENT_PROCESSES) + != PackageManager.PERMISSION_GRANTED) { + throw new SecurityException("Requires permission " + + android.Manifest.permission.SIGNAL_PERSISTENT_PROCESSES); + } + + for (int i = mLRUProcesses.size() - 1 ; i >= 0 ; i--) { + ProcessRecord r = mLRUProcesses.get(i); + if (r.thread != null && r.persistent) { + Process.sendSignal(r.pid, sig); + } + } + } + } + + /** In this method we try to acquire our lock to make sure that we have not deadlocked */ + public void monitor() { + synchronized (this) { } + } +} diff --git a/services/java/com/android/server/am/ActivityResult.java b/services/java/com/android/server/am/ActivityResult.java new file mode 100644 index 0000000..3cc2725 --- /dev/null +++ b/services/java/com/android/server/am/ActivityResult.java @@ -0,0 +1,34 @@ +/* + * Copyright (C) 2006 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.server.am; + +import android.app.ResultInfo; +import android.content.Intent; +import android.os.Bundle; + +/** + * Pending result information to send back to an activity. + */ +class ActivityResult extends ResultInfo { + final HistoryRecord mFrom; + + public ActivityResult(HistoryRecord from, String resultWho, + int requestCode, int resultCode, Intent data) { + super(resultWho, requestCode, resultCode, data); + mFrom = from; + } +} diff --git a/services/java/com/android/server/am/AppBindRecord.java b/services/java/com/android/server/am/AppBindRecord.java new file mode 100644 index 0000000..ce6f6dc --- /dev/null +++ b/services/java/com/android/server/am/AppBindRecord.java @@ -0,0 +1,60 @@ +/* + * Copyright (C) 2006 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.server.am; + +import java.io.PrintWriter; +import java.util.HashSet; +import java.util.Iterator; + +/** + * An association between a service and one of its client applications. + */ +class AppBindRecord { + final ServiceRecord service; // The running service. + final IntentBindRecord intent; // The intent we are bound to. + final ProcessRecord client; // Who has started/bound the service. + + final HashSet<ConnectionRecord> connections = new HashSet<ConnectionRecord>(); + // All ConnectionRecord for this client. + + void dump(PrintWriter pw, String prefix) { + pw.println(prefix + this); + pw.println(prefix + "service=" + service); + pw.println(prefix + "client=" + client); + if (connections.size() > 0) { + pw.println(prefix + "Per-process Connections:"); + Iterator<ConnectionRecord> it = connections.iterator(); + while (it.hasNext()) { + ConnectionRecord c = it.next(); + pw.println(prefix + " " + c); + } + } + } + + AppBindRecord(ServiceRecord _service, IntentBindRecord _intent, + ProcessRecord _client) { + service = _service; + intent = _intent; + client = _client; + } + + public String toString() { + return "AppBindRecord{" + + Integer.toHexString(System.identityHashCode(this)) + + " " + service.shortName + ":" + client.processName + "}"; + } +} diff --git a/services/java/com/android/server/am/AppErrorDialog.java b/services/java/com/android/server/am/AppErrorDialog.java new file mode 100644 index 0000000..3fcfad0 --- /dev/null +++ b/services/java/com/android/server/am/AppErrorDialog.java @@ -0,0 +1,94 @@ +/* + * Copyright (C) 2006 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.server.am; + +import static android.view.WindowManager.LayoutParams.FLAG_SYSTEM_ERROR; + +import android.content.Context; +import android.content.res.Resources; +import android.os.Handler; +import android.os.Message; + +class AppErrorDialog extends BaseErrorDialog { + private final AppErrorResult mResult; + private final ProcessRecord mProc; + + // Event 'what' codes + static final int FORCE_QUIT = 0; + static final int DEBUG = 1; + + // 5-minute timeout, then we automatically dismiss the crash dialog + static final long DISMISS_TIMEOUT = 1000 * 60 * 5; + + public AppErrorDialog(Context context, AppErrorResult result, + ProcessRecord app, int flags, + String shortMsg, String longMsg) { + super(context); + + Resources res = context.getResources(); + + mProc = app; + mResult = result; + CharSequence name; + if ((app.pkgList.size() == 1) && + (name=context.getPackageManager().getApplicationLabel(app.info)) != null) { + setMessage(res.getString( + com.android.internal.R.string.aerr_application, + name.toString(), app.info.processName)); + } else { + name = app.processName; + setMessage(res.getString( + com.android.internal.R.string.aerr_process, + name.toString())); + } + + setCancelable(false); + + setButton(res.getText(com.android.internal.R.string.force_close), + mHandler.obtainMessage(FORCE_QUIT)); + if ((flags&1) != 0) { + setButton(res.getText(com.android.internal.R.string.debug), + mHandler.obtainMessage(DEBUG)); + } + setTitle(res.getText(com.android.internal.R.string.aerr_title)); + getWindow().addFlags(FLAG_SYSTEM_ERROR); + getWindow().setTitle("Application Error: " + app.info.processName); + + // After the timeout, pretend the user clicked the quit button + mHandler.sendMessageDelayed( + mHandler.obtainMessage(FORCE_QUIT), + DISMISS_TIMEOUT); + } + + public void onStop() { + } + + private final Handler mHandler = new Handler() { + public void handleMessage(Message msg) { + synchronized (mProc) { + if (mProc != null && mProc.crashDialog == AppErrorDialog.this) { + mProc.crashDialog = null; + } + } + mResult.set(msg.what); + + // If this is a timeout we won't be automatically closed, so go + // ahead and explicitly dismiss ourselves just in case. + dismiss(); + } + }; +} diff --git a/services/java/com/android/server/am/AppErrorResult.java b/services/java/com/android/server/am/AppErrorResult.java new file mode 100644 index 0000000..ebfcfe2 --- /dev/null +++ b/services/java/com/android/server/am/AppErrorResult.java @@ -0,0 +1,43 @@ +/* + * Copyright (C) 2006 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.server.am; + + +class AppErrorResult { + public void set(int res) { + synchronized (this) { + mHasResult = true; + mResult = res; + notifyAll(); + } + } + + public int get() { + synchronized (this) { + while (!mHasResult) { + try { + wait(); + } catch (InterruptedException e) { + } + } + } + return mResult; + } + + boolean mHasResult = false; + int mResult; +} diff --git a/services/java/com/android/server/am/AppNotRespondingDialog.java b/services/java/com/android/server/am/AppNotRespondingDialog.java new file mode 100644 index 0000000..7390ed0 --- /dev/null +++ b/services/java/com/android/server/am/AppNotRespondingDialog.java @@ -0,0 +1,104 @@ +/* + * Copyright (C) 2006 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.server.am; + +import static android.view.WindowManager.LayoutParams.FLAG_SYSTEM_ERROR; + +import android.content.Context; +import android.content.res.Resources; +import android.os.Handler; +import android.os.Message; +import android.os.Process; +import android.util.Log; + +class AppNotRespondingDialog extends BaseErrorDialog { + private final ActivityManagerService mService; + private final ProcessRecord mProc; + + public AppNotRespondingDialog(ActivityManagerService service, Context context, + ProcessRecord app, HistoryRecord activity) { + super(context); + + mService = service; + mProc = app; + Resources res = context.getResources(); + + setCancelable(false); + + int resid; + CharSequence name1 = activity != null + ? activity.info.loadLabel(context.getPackageManager()) + : null; + CharSequence name2 = null; + if ((app.pkgList.size() == 1) && + (name2=context.getPackageManager().getApplicationLabel(app.info)) != null) { + if (name1 != null) { + resid = com.android.internal.R.string.anr_activity_application; + } else { + name1 = name2; + name2 = app.processName; + resid = com.android.internal.R.string.anr_application_process; + } + } else { + if (name1 != null) { + name2 = app.processName; + resid = com.android.internal.R.string.anr_activity_process; + } else { + name1 = app.processName; + resid = com.android.internal.R.string.anr_process; + } + } + + setMessage(name2 != null + ? res.getString(resid, name1.toString(), name2.toString()) + : res.getString(resid, name1.toString())); + + setButton(res.getText(com.android.internal.R.string.force_close), + mHandler.obtainMessage(1)); + setButton2(res.getText(com.android.internal.R.string.wait), + mHandler.obtainMessage(2)); + setTitle(res.getText(com.android.internal.R.string.anr_title)); + getWindow().addFlags(FLAG_SYSTEM_ERROR); + getWindow().setTitle("Application Not Responding: " + app.info.processName); + } + + public void onStop() { + } + + private final Handler mHandler = new Handler() { + public void handleMessage(Message msg) { + switch (msg.what) { + case 1: + // Kill the application. + mService.killAppAtUsersRequest(mProc, + AppNotRespondingDialog.this, true); + break; + case 2: + // Continue waiting for the application. + synchronized (mService) { + ProcessRecord app = mProc; + app.notResponding = false; + app.notRespondingReport = null; + if (app.anrDialog == AppNotRespondingDialog.this) { + app.anrDialog = null; + } + } + break; + } + } + }; +} diff --git a/services/java/com/android/server/am/AppWaitingForDebuggerDialog.java b/services/java/com/android/server/am/AppWaitingForDebuggerDialog.java new file mode 100644 index 0000000..0992d4d --- /dev/null +++ b/services/java/com/android/server/am/AppWaitingForDebuggerDialog.java @@ -0,0 +1,71 @@ +/* + * Copyright (C) 2006 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.server.am; + +import android.content.Context; +import android.os.Handler; +import android.os.Message; + +class AppWaitingForDebuggerDialog extends BaseErrorDialog { + final ActivityManagerService mService; + final ProcessRecord mProc; + private CharSequence mAppName; + + public AppWaitingForDebuggerDialog(ActivityManagerService service, + Context context, ProcessRecord app) { + super(context); + mService = service; + mProc = app; + mAppName = context.getPackageManager().getApplicationLabel(app.info); + + setCancelable(false); + + StringBuilder text = new StringBuilder(); + if (mAppName != null && mAppName.length() > 0) { + text.append("Application "); + text.append(mAppName); + text.append(" (process "); + text.append(app.processName); + text.append(")"); + } else { + text.append("Process "); + text.append(app.processName); + } + + text.append(" is waiting for the debugger to attach."); + + setMessage(text.toString()); + setButton("Force Close", mHandler.obtainMessage(1, app)); + setTitle("Waiting For Debugger"); + getWindow().setTitle("Waiting For Debugger: " + app.info.processName); + } + + public void onStop() { + } + + private final Handler mHandler = new Handler() { + public void handleMessage(Message msg) { + switch (msg.what) { + case 1: + // Kill the application. + mService.killAppAtUsersRequest(mProc, + AppWaitingForDebuggerDialog.this, true); + break; + } + } + }; +} diff --git a/services/java/com/android/server/am/BaseErrorDialog.java b/services/java/com/android/server/am/BaseErrorDialog.java new file mode 100644 index 0000000..bed2768 --- /dev/null +++ b/services/java/com/android/server/am/BaseErrorDialog.java @@ -0,0 +1,76 @@ +/* + * Copyright (C) 2006 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.server.am; + +import com.android.internal.R; + +import android.app.AlertDialog; +import android.content.Context; +import android.os.Handler; +import android.os.Message; +import android.view.KeyEvent; +import android.view.WindowManager; +import android.widget.Button; + +class BaseErrorDialog extends AlertDialog { + public BaseErrorDialog(Context context) { + super(context, com.android.internal.R.style.Theme_Dialog_AppError); + + getWindow().setType(WindowManager.LayoutParams.TYPE_SYSTEM_ALERT); + getWindow().setFlags(WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM, + WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM); + getWindow().setTitle("Error Dialog"); + setIcon(R.drawable.ic_dialog_alert); + } + + public void onStart() { + super.onStart(); + setEnabled(false); + mHandler.sendMessageDelayed(mHandler.obtainMessage(0), 1000); + } + + public boolean dispatchKeyEvent(KeyEvent event) { + if (mConsuming) { + //Log.i(TAG, "Consuming: " + event); + return true; + } + //Log.i(TAG, "Dispatching: " + event); + return super.dispatchKeyEvent(event); + } + + private void setEnabled(boolean enabled) { + Button b = (Button)findViewById(R.id.button1); + if (b != null) { + b.setEnabled(enabled); + } + b = (Button)findViewById(R.id.button2); + if (b != null) { + b.setEnabled(enabled); + } + } + + private Handler mHandler = new Handler() { + public void handleMessage(Message msg) { + if (msg.what == 0) { + mConsuming = false; + setEnabled(true); + } + } + }; + + private boolean mConsuming = true; +} diff --git a/services/java/com/android/server/am/BatteryStatsService.java b/services/java/com/android/server/am/BatteryStatsService.java new file mode 100644 index 0000000..27d0401 --- /dev/null +++ b/services/java/com/android/server/am/BatteryStatsService.java @@ -0,0 +1,197 @@ +/* + * Copyright (C) 2006-2007 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.server.am; + +import com.android.internal.app.IBatteryStats; +import com.android.internal.os.BatteryStatsImpl; + +import android.content.Context; +import android.os.Binder; +import android.os.IBinder; +import android.os.Parcel; +import android.os.Process; +import android.os.ServiceManager; +import android.util.PrintWriterPrinter; + +import java.io.FileDescriptor; +import java.io.PrintWriter; + +/** + * All information we are collecting about things that can happen that impact + * battery life. + */ +public final class BatteryStatsService extends IBatteryStats.Stub { + static IBatteryStats sService; + + final BatteryStatsImpl mStats; + Context mContext; + + BatteryStatsService(String filename) { + mStats = new BatteryStatsImpl(filename); + } + + public void publish(Context context) { + mContext = context; + ServiceManager.addService("batteryinfo", asBinder()); + } + + public static IBatteryStats getService() { + if (sService != null) { + return sService; + } + IBinder b = ServiceManager.getService("batteryinfo"); + sService = asInterface(b); + return sService; + } + + /** + * @return the current statistics object, which may be modified + * to reflect events that affect battery usage. You must lock the + * stats object before doing anything with it. + */ + public BatteryStatsImpl getActiveStatistics() { + return mStats; + } + + public byte[] getStatistics() { + mContext.enforceCallingPermission( + android.Manifest.permission.BATTERY_STATS, null); + //Log.i("foo", "SENDING BATTERY INFO:"); + //mStats.dumpLocked(new LogPrinter(Log.INFO, "foo")); + Parcel out = Parcel.obtain(); + mStats.writeToParcel(out, 0); + byte[] data = out.marshall(); + out.recycle(); + return data; + } + + public void noteStartWakelock(int uid, String name, int type) { + enforceCallingPermission(); + synchronized (mStats) { + mStats.getUidStatsLocked(uid).noteStartWakeLocked(name, type); + } + } + + public void noteStopWakelock(int uid, String name, int type) { + enforceCallingPermission(); + synchronized (mStats) { + mStats.getUidStatsLocked(uid).noteStopWakeLocked(name, type); + } + } + + public void noteStartSensor(int uid, int sensor) { + enforceCallingPermission(); + synchronized (mStats) { + mStats.getUidStatsLocked(uid).noteStartSensor(sensor); + } + } + + public void noteStopSensor(int uid, int sensor) { + enforceCallingPermission(); + synchronized (mStats) { + mStats.getUidStatsLocked(uid).noteStopSensor(sensor); + } + } + + public void noteStartGps(int uid) { + enforceCallingPermission(); + synchronized (mStats) { + mStats.noteStartGps(uid); + } + } + + public void noteStopGps(int uid) { + enforceCallingPermission(); + synchronized (mStats) { + mStats.noteStopGps(uid); + } + } + + public void noteScreenOn() { + enforceCallingPermission(); + synchronized (mStats) { + mStats.noteScreenOnLocked(); + } + } + + public void noteScreenOff() { + enforceCallingPermission(); + synchronized (mStats) { + mStats.noteScreenOffLocked(); + } + } + + public void notePhoneOn() { + enforceCallingPermission(); + synchronized (mStats) { + mStats.notePhoneOnLocked(); + } + } + + public void notePhoneOff() { + enforceCallingPermission(); + synchronized (mStats) { + mStats.notePhoneOffLocked(); + } + } + + public boolean isOnBattery() { + return mStats.isOnBattery(); + } + + public void setOnBattery(boolean onBattery) { + enforceCallingPermission(); + mStats.setOnBattery(onBattery); + } + + public long getAwakeTimeBattery() { + mContext.enforceCallingOrSelfPermission( + android.Manifest.permission.BATTERY_STATS, null); + return mStats.getAwakeTimeBattery(); + } + + public long getAwakeTimePlugged() { + mContext.enforceCallingOrSelfPermission( + android.Manifest.permission.BATTERY_STATS, null); + return mStats.getAwakeTimePlugged(); + } + + public void enforceCallingPermission() { + if (Binder.getCallingPid() == Process.myPid()) { + return; + } + mContext.enforcePermission(android.Manifest.permission.UPDATE_DEVICE_STATS, + Binder.getCallingPid(), Binder.getCallingUid(), null); + } + + @Override + protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) { + synchronized (mStats) { + boolean isCheckin = false; + if (args != null) { + for (String arg : args) { + if ("-c".equals(arg)) { + isCheckin = true; + break; + } + } + } + if (isCheckin) mStats.dumpCheckinLocked(pw, args); + else mStats.dumpLocked(new PrintWriterPrinter(pw)); + } + } +} diff --git a/services/java/com/android/server/am/BroadcastFilter.java b/services/java/com/android/server/am/BroadcastFilter.java new file mode 100644 index 0000000..cd7f720 --- /dev/null +++ b/services/java/com/android/server/am/BroadcastFilter.java @@ -0,0 +1,51 @@ +/* + * Copyright (C) 2006 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.server.am; + +import android.content.IntentFilter; +import android.util.PrintWriterPrinter; + +import java.io.PrintWriter; + +class BroadcastFilter extends IntentFilter { + // Back-pointer to the list this filter is in. + final ReceiverList receiverList; + final String requiredPermission; + + BroadcastFilter(IntentFilter _filter, ReceiverList _receiverList, + String _requiredPermission) { + super(_filter); + receiverList = _receiverList; + requiredPermission = _requiredPermission; + } + + public void dumpLocal(PrintWriter pw, String prefix) { + super.dump(new PrintWriterPrinter(pw), prefix); + } + + public void dump(PrintWriter pw, String prefix) { + dumpLocal(pw, prefix); + pw.println(prefix + "requiredPermission=" + requiredPermission); + receiverList.dumpLocal(pw, prefix); + } + + public String toString() { + return "BroadcastFilter{" + + Integer.toHexString(System.identityHashCode(this)) + + " " + receiverList + "}"; + } +} diff --git a/services/java/com/android/server/am/BroadcastRecord.java b/services/java/com/android/server/am/BroadcastRecord.java new file mode 100644 index 0000000..4057ae8 --- /dev/null +++ b/services/java/com/android/server/am/BroadcastRecord.java @@ -0,0 +1,147 @@ +/* + * Copyright (C) 2006 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.server.am; + +import android.app.IIntentReceiver; +import android.content.ComponentName; +import android.content.Intent; +import android.content.pm.ActivityInfo; +import android.content.pm.ResolveInfo; +import android.os.Binder; +import android.os.Bundle; +import android.os.IBinder; +import android.os.SystemClock; +import android.util.PrintWriterPrinter; + +import java.io.PrintWriter; +import java.util.List; + +/** + * An active intent broadcast. + */ +class BroadcastRecord extends Binder { + final Intent intent; // the original intent that generated us + final ProcessRecord callerApp; // process that sent this + final String callerPackage; // who sent this + final int callingPid; // the pid of who sent this + final int callingUid; // the uid of who sent this + String requiredPermission; // a permission the caller has required + final List receivers; // contains BroadcastFilter and ResolveInfo + final IIntentReceiver resultTo; // who receives final result if non-null + long dispatchTime; // when dispatch started on this set of receivers + long startTime; // when current receiver started for timeouts. + int resultCode; // current result code value. + String resultData; // current result data value. + Bundle resultExtras; // current result extra data values. + boolean resultAbort; // current result abortBroadcast value. + boolean ordered; // serialize the send to receivers? + int nextReceiver; // next receiver to be executed. + IBinder receiver; // who is currently running, null if none. + int state; + int anrCount; // has this broadcast record hit any ANRs? + + static final int IDLE = 0; + static final int APP_RECEIVE = 1; + static final int CALL_IN_RECEIVE = 2; + static final int CALL_DONE_RECEIVE = 3; + + // The following are set when we are calling a receiver (one that + // was found in our list of registered receivers). + BroadcastFilter curFilter; + + // The following are set only when we are launching a receiver (one + // that was found by querying the package manager). + ProcessRecord curApp; // hosting application of current receiver. + ComponentName curComponent; // the receiver class that is currently running. + ActivityInfo curReceiver; // info about the receiver that is currently running. + + void dump(PrintWriter pw, String prefix) { + pw.println(prefix + this); + pw.println(prefix + intent); + pw.println(prefix + "proc=" + callerApp); + pw.println(prefix + "caller=" + callerPackage + + " callingPid=" + callingPid + + " callingUid=" + callingUid); + pw.println(prefix + "requiredPermission=" + requiredPermission); + pw.println(prefix + "dispatchTime=" + dispatchTime + " (" + + (SystemClock.uptimeMillis()-dispatchTime) + " since now)"); + pw.println(prefix + "startTime=" + startTime + " (" + + (SystemClock.uptimeMillis()-startTime) + " since now)"); + pw.println(prefix + "anrCount=" + anrCount); + pw.println(prefix + "resultTo=" + resultTo + + " resultCode=" + resultCode + " resultData=" + resultData); + pw.println(prefix + "resultExtras=" + resultExtras); + pw.println(prefix + "resultAbort=" + resultAbort + + " ordered=" + ordered); + pw.println(prefix + "nextReceiver=" + nextReceiver + + " receiver=" + receiver); + pw.println(prefix + "curFilter=" + curFilter); + pw.println(prefix + "curReceiver=" + + ((curReceiver != null) ? curReceiver : "(null)")); + pw.println(prefix + "curApp=" + curApp); + if (curApp != null) { + pw.println(prefix + "curComponent=" + + (curComponent != null ? curComponent.toShortString() : "--")); + pw.println(prefix + "curSourceDir=" + curReceiver.applicationInfo.sourceDir); + } + String stateStr = " (?)"; + switch (state) { + case IDLE: stateStr=" (IDLE)"; break; + case APP_RECEIVE: stateStr=" (APP_RECEIVE)"; break; + case CALL_IN_RECEIVE: stateStr=" (CALL_IN_RECEIVE)"; break; + case CALL_DONE_RECEIVE: stateStr=" (CALL_DONE_RECEIVE)"; break; + } + pw.println(prefix + "state=" + state + stateStr); + final int N = receivers != null ? receivers.size() : 0; + String p2 = prefix + " "; + PrintWriterPrinter printer = new PrintWriterPrinter(pw); + for (int i=0; i<N; i++) { + Object o = receivers.get(i); + pw.println(prefix + "Receiver #" + i + ": " + o); + if (o instanceof BroadcastFilter) + ((BroadcastFilter)o).dump(pw, p2); + else if (o instanceof ResolveInfo) + ((ResolveInfo)o).dump(printer, p2); + } + } + + BroadcastRecord(Intent _intent, ProcessRecord _callerApp, String _callerPackage, + int _callingPid, int _callingUid, String _requiredPermission, + List _receivers, IIntentReceiver _resultTo, int _resultCode, + String _resultData, Bundle _resultExtras, boolean _serialized) { + intent = _intent; + callerApp = _callerApp; + callerPackage = _callerPackage; + callingPid = _callingPid; + callingUid = _callingUid; + requiredPermission = _requiredPermission; + receivers = _receivers; + resultTo = _resultTo; + resultCode = _resultCode; + resultData = _resultData; + resultExtras = _resultExtras; + ordered = _serialized; + nextReceiver = 0; + state = IDLE; + } + + public String toString() { + return "BroadcastRecord{" + + Integer.toHexString(System.identityHashCode(this)) + + " " + intent.getAction() + "}"; + } +} diff --git a/services/java/com/android/server/am/ConnectionRecord.java b/services/java/com/android/server/am/ConnectionRecord.java new file mode 100644 index 0000000..41a783f --- /dev/null +++ b/services/java/com/android/server/am/ConnectionRecord.java @@ -0,0 +1,54 @@ +/* + * Copyright (C) 2006 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.server.am; + +import android.app.IServiceConnection; + +import java.io.PrintWriter; + +/** + * Description of a single binding to a service. + */ +class ConnectionRecord { + final AppBindRecord binding; // The application/service binding. + final HistoryRecord activity; // If non-null, the owning activity. + final IServiceConnection conn; // The client connection. + final int flags; // Binding options. + + void dump(PrintWriter pw, String prefix) { + pw.println(prefix + this); + pw.println(prefix + "binding=" + binding); + pw.println(prefix + "activity=" + activity); + pw.println(prefix + "conn=" + conn.asBinder() + + " flags=0x" + Integer.toHexString(flags)); + } + + ConnectionRecord(AppBindRecord _binding, HistoryRecord _activity, + IServiceConnection _conn, int _flags) { + binding = _binding; + activity = _activity; + conn = _conn; + flags = _flags; + } + + public String toString() { + return "ConnectionRecord{" + + Integer.toHexString(System.identityHashCode(this)) + + " " + binding.service.shortName + + ":@" + Integer.toHexString(System.identityHashCode(conn.asBinder())) + "}"; + } +} diff --git a/services/java/com/android/server/am/ContentProviderRecord.java b/services/java/com/android/server/am/ContentProviderRecord.java new file mode 100644 index 0000000..9f37c14 --- /dev/null +++ b/services/java/com/android/server/am/ContentProviderRecord.java @@ -0,0 +1,76 @@ +/* + * Copyright (C) 2006 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.server.am; + +import android.app.IActivityManager.ContentProviderHolder; +import android.content.pm.ApplicationInfo; +import android.content.pm.ProviderInfo; +import android.os.Process; + +import java.io.PrintWriter; +import java.util.HashSet; + +class ContentProviderRecord extends ContentProviderHolder { + // All attached clients + final HashSet<ProcessRecord> clients = new HashSet<ProcessRecord>(); + final int uid; + final ApplicationInfo appInfo; + int externals; // number of non-framework processes supported by this provider + ProcessRecord app; // if non-null, hosting application + ProcessRecord launchingApp; // if non-null, waiting for this app to be launched. + + public ContentProviderRecord(ProviderInfo _info, ApplicationInfo ai) { + super(_info); + uid = ai.uid; + appInfo = ai; + noReleaseNeeded = uid == 0 || uid == Process.SYSTEM_UID; + } + + public ContentProviderRecord(ContentProviderRecord cpr) { + super(cpr.info); + uid = cpr.uid; + appInfo = cpr.appInfo; + noReleaseNeeded = cpr.noReleaseNeeded; + } + + public boolean canRunHere(ProcessRecord app) { + return (info.multiprocess || info.processName.equals(app.processName)) + && (uid == Process.SYSTEM_UID || uid == app.info.uid); + } + + void dump(PrintWriter pw, String prefix) { + pw.println(prefix + this); + pw.println(prefix + "package=" + info.applicationInfo.packageName + + " process=" + info.processName); + pw.println(prefix + "app=" + app); + pw.println(prefix + "launchingApp=" + launchingApp); + pw.println(prefix + "provider=" + provider); + pw.println(prefix + "name=" + info.authority); + pw.println(prefix + "isSyncable=" + info.isSyncable); + pw.println(prefix + "multiprocess=" + info.multiprocess + + " initOrder=" + info.initOrder + + " uid=" + uid); + pw.println(prefix + "clients=" + clients); + pw.println(prefix + "externals=" + externals); + } + + public String toString() { + return "ContentProviderRecord{" + + Integer.toHexString(System.identityHashCode(this)) + + " " + info.name + "}"; + } +} diff --git a/services/java/com/android/server/am/DeviceMonitor.java b/services/java/com/android/server/am/DeviceMonitor.java new file mode 100644 index 0000000..ce07430 --- /dev/null +++ b/services/java/com/android/server/am/DeviceMonitor.java @@ -0,0 +1,230 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.server.am; + +import android.util.Log; + +import java.io.*; +import java.util.Arrays; + +/** + * Monitors device resources periodically for some period of time. Useful for + * tracking down performance problems. + */ +class DeviceMonitor { + + private static final String LOG_TAG = DeviceMonitor.class.getName(); + + /** Number of samples to take. */ + private static final int SAMPLE_COUNT = 10; + + /** Time to wait in ms between samples. */ + private static final int INTERVAL = 1000; + + /** Time to wait in ms between samples. */ + private static final int MAX_FILES = 30; + + private final byte[] buffer = new byte[1024]; + + /** Is the monitor currently running? */ + private boolean running = false; + + private DeviceMonitor() { + new Thread() { + public void run() { + monitor(); + } + }.start(); + } + + /** + * Loops continuously. Pauses until someone tells us to start monitoring. + */ + @SuppressWarnings("InfiniteLoopStatement") + private void monitor() { + while (true) { + waitForStart(); + + purge(); + + for (int i = 0; i < SAMPLE_COUNT; i++) { + try { + dump(); + } catch (IOException e) { + Log.w(LOG_TAG, "Dump failed.", e); + } + pause(); + } + + stop(); + } + } + + private static final File PROC = new File("/proc"); + private static final File BASE = new File("/data/anr/"); + static { + if (!BASE.isDirectory() && !BASE.mkdirs()) { + throw new AssertionError("Couldn't create " + BASE + "."); + } + } + + private static final File[] PATHS = { + new File(PROC, "zoneinfo"), + new File(PROC, "interrupts"), + new File(PROC, "meminfo"), + new File(PROC, "slabinfo"), + }; + + + /** + * Deletes old files. + */ + private void purge() { + File[] files = BASE.listFiles(); + int count = files.length - MAX_FILES; + if (count > 0) { + Arrays.sort(files); + for (int i = 0; i < count; i++) { + if (!files[i].delete()) { + Log.w(LOG_TAG, "Couldn't delete " + files[i] + "."); + } + } + } + } + + /** + * Dumps the current device stats to a new file. + */ + private void dump() throws IOException { + OutputStream out = new FileOutputStream( + new File(BASE, String.valueOf(System.currentTimeMillis()))); + try { + // Copy /proc/*/stat + for (File processDirectory : PROC.listFiles()) { + if (isProcessDirectory(processDirectory)) { + dump(new File(processDirectory, "stat"), out); + } + } + + // Copy other files. + for (File file : PATHS) { + dump(file, out); + } + } finally { + closeQuietly(out); + } + } + + /** + * Returns true if the given file represents a process directory. + */ + private static boolean isProcessDirectory(File file) { + try { + Integer.parseInt(file.getName()); + return file.isDirectory(); + } catch (NumberFormatException e) { + return false; + } + } + + /** + * Copies from a file to an output stream. + */ + private void dump(File from, OutputStream out) throws IOException { + writeHeader(from, out); + + FileInputStream in = null; + try { + in = new FileInputStream(from); + int count; + while ((count = in.read(buffer)) != -1) { + out.write(buffer, 0, count); + } + } finally { + closeQuietly(in); + } + } + + /** + * Writes a header for the given file. + */ + private static void writeHeader(File file, OutputStream out) + throws IOException { + String header = "*** " + file.toString() + "\n"; + out.write(header.getBytes()); + } + + /** + * Closes the given resource. Logs exceptions. + * @param closeable + */ + private static void closeQuietly(Closeable closeable) { + try { + if (closeable != null) { + closeable.close(); + } + } catch (IOException e) { + Log.w(LOG_TAG, e); + } + } + + /** + * Pauses momentarily before we start the next dump. + */ + private void pause() { + try { + Thread.sleep(INTERVAL); + } catch (InterruptedException e) { /* ignore */ } + } + + /** + * Stops dumping. + */ + private synchronized void stop() { + running = false; + } + + /** + * Waits until someone starts us. + */ + private synchronized void waitForStart() { + while (!running) { + try { + wait(); + } catch (InterruptedException e) { /* ignore */ } + } + } + + /** + * Instructs the monitoring to start if it hasn't already. + */ + private synchronized void startMonitoring() { + if (!running) { + running = true; + notifyAll(); + } + } + + private static DeviceMonitor instance = new DeviceMonitor(); + + /** + * Starts monitoring if it hasn't started already. + */ + static void start() { + instance.startMonitoring(); + } +} diff --git a/services/java/com/android/server/am/FactoryErrorDialog.java b/services/java/com/android/server/am/FactoryErrorDialog.java new file mode 100644 index 0000000..2e25474 --- /dev/null +++ b/services/java/com/android/server/am/FactoryErrorDialog.java @@ -0,0 +1,42 @@ +/* + * Copyright (C) 2006 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.server.am; + +import android.content.Context; +import android.os.Handler; +import android.os.Message; + +class FactoryErrorDialog extends BaseErrorDialog { + public FactoryErrorDialog(Context context, CharSequence msg) { + super(context); + setCancelable(false); + setTitle(context.getText(com.android.internal.R.string.factorytest_failed)); + setMessage(msg); + setButton(context.getText(com.android.internal.R.string.factorytest_reboot), + mHandler.obtainMessage(0)); + getWindow().setTitle("Factory Error"); + } + + public void onStop() { + } + + private final Handler mHandler = new Handler() { + public void handleMessage(Message msg) { + throw new RuntimeException("Rebooting from failed factory test"); + } + }; +} diff --git a/services/java/com/android/server/am/HistoryRecord.java b/services/java/com/android/server/am/HistoryRecord.java new file mode 100644 index 0000000..b407208 --- /dev/null +++ b/services/java/com/android/server/am/HistoryRecord.java @@ -0,0 +1,429 @@ +/* + * Copyright (C) 2006 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.server.am; + +import com.android.server.AttributeCache; +import com.android.server.am.ActivityManagerService.ActivityState; + +import android.app.Activity; +import android.content.ComponentName; +import android.content.Intent; +import android.content.pm.ActivityInfo; +import android.content.pm.ApplicationInfo; +import android.content.res.Configuration; +import android.graphics.Bitmap; +import android.os.Bundle; +import android.os.Message; +import android.os.Process; +import android.os.SystemClock; +import android.util.EventLog; +import android.util.Log; +import android.view.IApplicationToken; + +import java.io.PrintWriter; +import java.lang.ref.WeakReference; +import java.util.ArrayList; +import java.util.HashSet; + +/** + * An entry in the history stack, representing an activity. + */ +class HistoryRecord extends IApplicationToken.Stub { + final ActivityManagerService service; // owner + final ActivityInfo info; // all about me + final int launchedFromUid; // always the uid who started the activity. + final Intent intent; // the original intent that generated us + final ComponentName realActivity; // the intent component, or target of an alias. + final String shortComponentName; // the short component name of the intent + final String resolvedType; // as per original caller; + final String packageName; // the package implementing intent's component + final String processName; // process where this component wants to run + final String taskAffinity; // as per ActivityInfo.taskAffinity + final boolean stateNotNeeded; // As per ActivityInfo.flags + final boolean fullscreen; // covers the full screen? + final String baseDir; // where activity source (resources etc) located + final String resDir; // where public activity source (public resources etc) located + final String dataDir; // where activity data should go + CharSequence nonLocalizedLabel; // the label information from the package mgr. + int labelRes; // the label information from the package mgr. + int icon; // resource identifier of activity's icon. + int theme; // resource identifier of activity's theme. + TaskRecord task; // the task this is in. + long startTime; // when we starting launching this activity + Configuration configuration; // configuration activity was last running in + HistoryRecord resultTo; // who started this entry, so will get our reply + final String resultWho; // additional identifier for use by resultTo. + final int requestCode; // code given by requester (resultTo) + ArrayList results; // pending ActivityResult objs we have received + HashSet<WeakReference<PendingIntentRecord>> pendingResults; // all pending intents for this act + ArrayList newIntents; // any pending new intents for single-top mode + HashSet<ConnectionRecord> connections; // All ConnectionRecord we hold + HashSet<UriPermission> readUriPermissions; // special access to reading uris. + HashSet<UriPermission> writeUriPermissions; // special access to writing uris. + ProcessRecord app; // if non-null, hosting application + Bitmap thumbnail; // icon representation of paused screen + CharSequence description; // textual description of paused screen + ActivityManagerService.ActivityState state; // current state we are in + Bundle icicle; // last saved activity state + boolean frontOfTask; // is this the root activity of its task? + boolean launchFailed; // set if a launched failed, to abort on 2nd try + boolean haveState; // have we gotten the last activity state? + boolean stopped; // is activity pause finished? + boolean finishing; // activity in pending finish list? + boolean configDestroy; // need to destroy due to config change? + int configChangeFlags; // which config values have changed + boolean keysPaused; // has key dispatching been paused for it? + boolean inHistory; // are we in the history stack? + boolean persistent; // requested to be persistent? + int launchMode; // the launch mode activity attribute. + boolean visible; // does this activity's window need to be shown? + boolean waitingVisible; // true if waiting for a new act to become vis + boolean nowVisible; // is this activity's window visible? + boolean thumbnailNeeded;// has someone requested a thumbnail? + boolean idle; // has the activity gone idle? + boolean hasBeenLaunched;// has this activity ever been launched? + boolean frozenBeforeDestroy;// has been frozen but not yet destroyed. + + void dump(PrintWriter pw, String prefix) { + pw.println(prefix + this); + pw.println(prefix + "packageName=" + packageName + + " processName=" + processName); + pw.println(prefix + "app=" + app); + pw.println(prefix + "launchedFromUid=" + launchedFromUid); + pw.println(prefix + intent); + pw.println(prefix + "frontOfTask=" + frontOfTask + " task=" + task); + pw.println(prefix + "taskAffinity=" + taskAffinity); + pw.println(prefix + "realActivity=" + realActivity); + pw.println(prefix + "dir=" + baseDir + " res=" + resDir + " data=" + dataDir); + pw.println(prefix + "labelRes=0x" + Integer.toHexString(labelRes) + + " icon=0x" + Integer.toHexString(icon) + + " theme=0x" + Integer.toHexString(theme)); + pw.println(prefix + "configuration=" + configuration); + pw.println(prefix + "resultTo=" + resultTo + + " resultWho=" + resultWho + " resultCode=" + requestCode); + pw.println(prefix + "results=" + results); + pw.println(prefix + "pendingResults=" + pendingResults); + pw.println(prefix + "readUriPermissions=" + readUriPermissions); + pw.println(prefix + "writeUriPermissions=" + writeUriPermissions); + pw.println(prefix + "launchFailed=" + launchFailed + + " haveState=" + haveState + " icicle=" + icicle); + pw.println(prefix + "state=" + state + + " stopped=" + stopped + " finishing=" + finishing); + pw.println(prefix + "keysPaused=" + keysPaused + + " inHistory=" + inHistory + " persistent=" + persistent + + " launchMode=" + launchMode); + pw.println(prefix + "fullscreen=" + fullscreen + + " visible=" + visible + + " frozenBeforeDestroy=" + frozenBeforeDestroy + + " thumbnailNeeded=" + thumbnailNeeded + " idle=" + idle); + pw.println(prefix + "waitingVisible=" + waitingVisible + + " nowVisible=" + nowVisible); + pw.println(prefix + "configDestroy=" + configDestroy + + " configChangeFlags=" + Integer.toHexString(configChangeFlags)); + pw.println(prefix + "connections=" + connections); + } + + HistoryRecord(ActivityManagerService _service, ProcessRecord _caller, + int _launchedFromUid, Intent _intent, String _resolvedType, + ActivityInfo aInfo, Configuration _configuration, + HistoryRecord _resultTo, String _resultWho, int _reqCode) { + service = _service; + info = aInfo; + launchedFromUid = _launchedFromUid; + intent = _intent; + shortComponentName = _intent.getComponent().flattenToShortString(); + resolvedType = _resolvedType; + configuration = _configuration; + resultTo = _resultTo; + resultWho = _resultWho; + requestCode = _reqCode; + state = ActivityManagerService.ActivityState.INITIALIZING; + frontOfTask = false; + launchFailed = false; + haveState = false; + stopped = false; + finishing = false; + configDestroy = false; + keysPaused = false; + inHistory = false; + persistent = false; + visible = true; + waitingVisible = false; + nowVisible = false; + thumbnailNeeded = false; + idle = false; + hasBeenLaunched = false; + + if (aInfo != null) { + if (aInfo.targetActivity == null + || aInfo.launchMode == ActivityInfo.LAUNCH_MULTIPLE + || aInfo.launchMode == ActivityInfo.LAUNCH_SINGLE_TOP) { + realActivity = _intent.getComponent(); + } else { + realActivity = new ComponentName(aInfo.packageName, + aInfo.targetActivity); + } + taskAffinity = aInfo.taskAffinity; + stateNotNeeded = (aInfo.flags& + ActivityInfo.FLAG_STATE_NOT_NEEDED) != 0; + baseDir = aInfo.applicationInfo.sourceDir; + resDir = aInfo.applicationInfo.publicSourceDir; + dataDir = aInfo.applicationInfo.dataDir; + nonLocalizedLabel = aInfo.nonLocalizedLabel; + labelRes = aInfo.labelRes; + if (nonLocalizedLabel == null && labelRes == 0) { + ApplicationInfo app = aInfo.applicationInfo; + nonLocalizedLabel = app.nonLocalizedLabel; + labelRes = app.labelRes; + } + icon = aInfo.getIconResource(); + theme = aInfo.getThemeResource(); + if ((aInfo.flags&ActivityInfo.FLAG_MULTIPROCESS) != 0 + && _caller != null + && (aInfo.applicationInfo.uid == Process.SYSTEM_UID + || aInfo.applicationInfo.uid == _caller.info.uid)) { + processName = _caller.processName; + } else { + processName = aInfo.processName; + } + + if (intent != null && (aInfo.flags & ActivityInfo.FLAG_EXCLUDE_FROM_RECENTS) != 0) { + intent.addFlags(Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS); + } + + packageName = aInfo.applicationInfo.packageName; + launchMode = aInfo.launchMode; + + AttributeCache.Entry ent = AttributeCache.instance().get(packageName, + theme != 0 ? theme : android.R.style.Theme, + com.android.internal.R.styleable.Window); + fullscreen = ent != null && !ent.array.getBoolean( + com.android.internal.R.styleable.Window_windowIsFloating, false) + && !ent.array.getBoolean( + com.android.internal.R.styleable.Window_windowIsTranslucent, false); + + } else { + realActivity = null; + taskAffinity = null; + stateNotNeeded = false; + baseDir = null; + resDir = null; + dataDir = null; + processName = null; + packageName = null; + fullscreen = true; + } + } + + void addResultLocked(HistoryRecord from, String resultWho, + int requestCode, int resultCode, + Intent resultData) { + ActivityResult r = new ActivityResult(from, resultWho, + requestCode, resultCode, resultData); + if (results == null) { + results = new ArrayList(); + } + results.add(r); + } + + void removeResultsLocked(HistoryRecord from, String resultWho, + int requestCode) { + if (results != null) { + for (int i=results.size()-1; i>=0; i--) { + ActivityResult r = (ActivityResult)results.get(i); + if (r.mFrom != from) continue; + if (r.mResultWho == null) { + if (resultWho != null) continue; + } else { + if (!r.mResultWho.equals(resultWho)) continue; + } + if (r.mRequestCode != requestCode) continue; + + results.remove(i); + } + } + } + + void addNewIntentLocked(Intent intent) { + if (newIntents == null) { + newIntents = new ArrayList(); + } + newIntents.add(intent); + } + + void pauseKeyDispatchingLocked() { + if (!keysPaused) { + keysPaused = true; + service.mWindowManager.pauseKeyDispatching(this); + } + } + + void resumeKeyDispatchingLocked() { + if (keysPaused) { + keysPaused = false; + service.mWindowManager.resumeKeyDispatching(this); + } + } + + // IApplicationToken + + public boolean mayFreezeScreenLocked(ProcessRecord app) { + // Only freeze the screen if this activity is currently attached to + // an application, and that application is not blocked or unresponding. + // In any other case, we can't count on getting the screen unfrozen, + // so it is best to leave as-is. + return app == null || (!app.crashing && !app.notResponding); + } + + public void startFreezingScreenLocked(ProcessRecord app, int configChanges) { + if (mayFreezeScreenLocked(app)) { + service.mWindowManager.startAppFreezingScreen(this, configChanges); + } + } + + public void stopFreezingScreenLocked(boolean force) { + if (force || frozenBeforeDestroy) { + frozenBeforeDestroy = false; + service.mWindowManager.stopAppFreezingScreen(this, force); + } + } + + public void windowsVisible() { + synchronized(service) { + if (ActivityManagerService.SHOW_ACTIVITY_START_TIME + && startTime != 0) { + long time = SystemClock.uptimeMillis() - startTime; + EventLog.writeEvent(ActivityManagerService.LOG_ACTIVITY_LAUNCH_TIME, + System.identityHashCode(this), shortComponentName, time); + Log.i(ActivityManagerService.TAG, "Displayed activity " + + shortComponentName + + ": " + time + " ms"); + startTime = 0; + } + if (ActivityManagerService.DEBUG_SWITCH) Log.v( + ActivityManagerService.TAG, "windowsVisible(): " + this); + if (!nowVisible) { + nowVisible = true; + if (!idle) { + // Instead of doing the full stop routine here, let's just + // hide any activities we now can, and let them stop when + // the normal idle happens. + service.processStoppingActivitiesLocked(false); + } else { + // If this activity was already idle, then we now need to + // make sure we perform the full stop of any activities + // that are waiting to do so. This is because we won't + // do that while they are still waiting for this one to + // become visible. + final int N = service.mWaitingVisibleActivities.size(); + if (N > 0) { + for (int i=0; i<N; i++) { + HistoryRecord r = (HistoryRecord) + service.mWaitingVisibleActivities.get(i); + r.waitingVisible = false; + if (ActivityManagerService.DEBUG_SWITCH) Log.v( + ActivityManagerService.TAG, + "Was waiting for visible: " + r); + } + service.mWaitingVisibleActivities.clear(); + Message msg = Message.obtain(); + msg.what = ActivityManagerService.IDLE_NOW_MSG; + service.mHandler.sendMessage(msg); + } + } + service.scheduleAppGcsLocked(); + } + } + } + + public void windowsGone() { + if (ActivityManagerService.DEBUG_SWITCH) Log.v( + ActivityManagerService.TAG, "windowsGone(): " + this); + nowVisible = false; + } + + private HistoryRecord getWaitingHistoryRecordLocked() { + // First find the real culprit... if we are waiting + // for another app to start, then we have paused dispatching + // for this activity. + HistoryRecord r = this; + if (r.waitingVisible) { + // Hmmm, who might we be waiting for? + r = service.mResumedActivity; + if (r == null) { + r = service.mPausingActivity; + } + // Both of those null? Fall back to 'this' again + if (r == null) { + r = this; + } + } + + return r; + } + + public boolean keyDispatchingTimedOut() { + synchronized(service) { + HistoryRecord r = getWaitingHistoryRecordLocked(); + if (r != null && r.app != null) { + if (r.app.debugging) { + return false; + } + + if (r.app.instrumentationClass == null) { + service.appNotRespondingLocked(r.app, r, "keyDispatchingTimedOut"); + } else { + Bundle info = new Bundle(); + info.putString("shortMsg", "keyDispatchingTimedOut"); + info.putString("longMsg", "Timed out while dispatching key event"); + service.finishInstrumentationLocked( + r.app, Activity.RESULT_CANCELED, info); + } + } + return true; + } + } + + /** Returns the key dispatching timeout for this application token. */ + public long getKeyDispatchingTimeout() { + synchronized(service) { + HistoryRecord r = getWaitingHistoryRecordLocked(); + if (r == null || r.app == null + || r.app.instrumentationClass == null) { + return ActivityManagerService.KEY_DISPATCHING_TIMEOUT; + } + + return ActivityManagerService.INSTRUMENTATION_KEY_DISPATCHING_TIMEOUT; + } + } + + /** + * This method will return true if the activity is either visible, is becoming visible, is + * currently pausing, or is resumed. + */ + public boolean isInterestingToUserLocked() { + return visible || nowVisible || state == ActivityState.PAUSING || + state == ActivityState.RESUMED; + } + + + public String toString() { + return "HistoryRecord{" + + Integer.toHexString(System.identityHashCode(this)) + + " " + intent.getComponent().toShortString() + "}"; + } +} diff --git a/services/java/com/android/server/am/IntentBindRecord.java b/services/java/com/android/server/am/IntentBindRecord.java new file mode 100644 index 0000000..24c3943 --- /dev/null +++ b/services/java/com/android/server/am/IntentBindRecord.java @@ -0,0 +1,79 @@ +/* + * Copyright (C) 2006 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.server.am; + +import android.content.Intent; +import android.os.IBinder; + +import java.io.PrintWriter; +import java.util.HashMap; +import java.util.Iterator; + +/** + * A particular Intent that has been bound to a Service. + */ +class IntentBindRecord { + /** The running service. */ + final ServiceRecord service; + /** The intent that is bound.*/ + final Intent.FilterComparison intent; // + /** All apps that have bound to this Intent. */ + final HashMap<ProcessRecord, AppBindRecord> apps + = new HashMap<ProcessRecord, AppBindRecord>(); + /** Binder published from service. */ + IBinder binder; + /** Set when we have initiated a request for this binder. */ + boolean requested; + /** Set when we have received the requested binder. */ + boolean received; + /** Set when we still need to tell the service all clients are unbound. */ + boolean hasBound; + /** Set when the service's onUnbind() has asked to be told about new clients. */ + boolean doRebind; + + void dump(PrintWriter pw, String prefix) { + pw.println(prefix + this); + pw.println(prefix + "service=" + service); + pw.println(prefix + "intent=" + intent.getIntent()); + pw.println(prefix + "binder=" + binder + + " requested=" + requested + + " received=" + received + + " hasBound=" + hasBound + + " doRebind=" + doRebind); + if (apps.size() > 0) { + pw.println(prefix + "Application Bindings:"); + Iterator<AppBindRecord> it = apps.values().iterator(); + while (it.hasNext()) { + AppBindRecord a = it.next(); + pw.println(prefix + "Client " + a.client); + a.dump(pw, prefix + " "); + } + } + } + + IntentBindRecord(ServiceRecord _service, Intent.FilterComparison _intent) { + service = _service; + intent = _intent; + } + + public String toString() { + return "IntentBindRecord{" + + Integer.toHexString(System.identityHashCode(this)) + + " " + service.name.toShortString() + + ":" + intent + "}"; + } +} diff --git a/services/java/com/android/server/am/PendingIntentRecord.java b/services/java/com/android/server/am/PendingIntentRecord.java new file mode 100644 index 0000000..b18aaf7 --- /dev/null +++ b/services/java/com/android/server/am/PendingIntentRecord.java @@ -0,0 +1,278 @@ +/* + * Copyright (C) 2006 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.server.am; + +import android.app.IActivityManager; +import android.app.IIntentSender; +import android.app.IIntentReceiver; +import android.app.PendingIntent; +import android.content.Intent; +import android.os.Binder; +import android.os.RemoteException; +import android.util.Log; + +import java.io.PrintWriter; +import java.lang.ref.WeakReference; + +class PendingIntentRecord extends IIntentSender.Stub { + final ActivityManagerService owner; + final Key key; + final int uid; + final WeakReference<PendingIntentRecord> ref; + boolean sent = false; + boolean canceled = false; + + final static class Key { + final int type; + final String packageName; + final HistoryRecord activity; + final String who; + final int requestCode; + final Intent requestIntent; + final String requestResolvedType; + final int flags; + final int hashCode; + + private static final int ODD_PRIME_NUMBER = 37; + + Key(int _t, String _p, HistoryRecord _a, String _w, + int _r, Intent _i, String _it, int _f) { + type = _t; + packageName = _p; + activity = _a; + who = _w; + requestCode = _r; + requestIntent = _i; + requestResolvedType = _it; + flags = _f; + + int hash = 23; + hash = (ODD_PRIME_NUMBER*hash) + _f; + hash = (ODD_PRIME_NUMBER*hash) + _r; + if (_w != null) { + hash = (ODD_PRIME_NUMBER*hash) + _w.hashCode(); + } + if (_a != null) { + hash = (ODD_PRIME_NUMBER*hash) + _a.hashCode(); + } + if (_i != null) { + hash = (ODD_PRIME_NUMBER*hash) + _i.filterHashCode(); + } + if (_it != null) { + hash = (ODD_PRIME_NUMBER*hash) + _it.hashCode(); + } + hash = (ODD_PRIME_NUMBER*hash) + _p.hashCode(); + hash = (ODD_PRIME_NUMBER*hash) + _t; + hashCode = hash; + //Log.i(ActivityManagerService.TAG, this + " hashCode=0x" + // + Integer.toHexString(hashCode)); + } + + public boolean equals(Object otherObj) { + if (otherObj == null) { + return false; + } + try { + Key other = (Key)otherObj; + if (type != other.type) { + return false; + } + if (!packageName.equals(other.packageName)) { + return false; + } + if (activity != other.activity) { + return false; + } + if (who != other.who) { + if (who != null) { + if (!who.equals(other.who)) { + return false; + } + } else if (other.who != null) { + return false; + } + } + if (requestCode != other.requestCode) { + return false; + } + if (requestIntent != other.requestIntent) { + if (requestIntent != null) { + if (!requestIntent.filterEquals(other.requestIntent)) { + return false; + } + } else if (other.requestIntent != null) { + return false; + } + } + if (requestResolvedType != other.requestResolvedType) { + if (requestResolvedType != null) { + if (!requestResolvedType.equals(other.requestResolvedType)) { + return false; + } + } else if (other.requestResolvedType != null) { + return false; + } + } + if (flags != other.flags) { + return false; + } + return true; + } catch (ClassCastException e) { + } + return false; + } + + public int hashCode() { + return hashCode; + } + + public String toString() { + return "Key{" + typeName() + " pkg=" + packageName + + " intent=" + requestIntent + " flags=0x" + + Integer.toHexString(flags) + "}"; + } + + String typeName() { + switch (type) { + case IActivityManager.INTENT_SENDER_ACTIVITY: + return "startActivity"; + case IActivityManager.INTENT_SENDER_BROADCAST: + return "broadcastIntent"; + case IActivityManager.INTENT_SENDER_SERVICE: + return "startService"; + case IActivityManager.INTENT_SENDER_ACTIVITY_RESULT: + return "activityResult"; + } + return Integer.toString(type); + } + } + + PendingIntentRecord(ActivityManagerService _owner, Key _k, int _u) { + owner = _owner; + key = _k; + uid = _u; + ref = new WeakReference<PendingIntentRecord>(this); + } + + public int send(int code, Intent intent, String resolvedType, + IIntentReceiver finishedReceiver) { + synchronized(owner) { + if (!canceled) { + sent = true; + if ((key.flags&PendingIntent.FLAG_ONE_SHOT) != 0) { + owner.cancelIntentSenderLocked(this, true); + canceled = true; + } + Intent finalIntent = key.requestIntent != null + ? new Intent(key.requestIntent) : new Intent(); + if (intent != null) { + int changes = finalIntent.fillIn(intent, key.flags); + if ((changes&Intent.FILL_IN_DATA) == 0) { + resolvedType = key.requestResolvedType; + } + } else { + resolvedType = key.requestResolvedType; + } + + final long origId = Binder.clearCallingIdentity(); + + boolean sendFinish = finishedReceiver != null; + switch (key.type) { + case IActivityManager.INTENT_SENDER_ACTIVITY: + try { + owner.startActivityInPackage(uid, + finalIntent, resolvedType, + null, null, 0, false); + } catch (RuntimeException e) { + Log.w(ActivityManagerService.TAG, + "Unable to send startActivity intent", e); + } + break; + case IActivityManager.INTENT_SENDER_ACTIVITY_RESULT: + owner.sendActivityResultLocked(-1, key.activity, + key.who, key.requestCode, code, finalIntent); + break; + case IActivityManager.INTENT_SENDER_BROADCAST: + try { + // If a completion callback has been requested, require + // that the broadcast be delivered synchronously + owner.broadcastIntentInPackage(key.packageName, uid, + finalIntent, resolvedType, + finishedReceiver, code, null, null, null, + (finishedReceiver != null), false); + sendFinish = false; + } catch (RuntimeException e) { + Log.w(ActivityManagerService.TAG, + "Unable to send startActivity intent", e); + } + break; + case IActivityManager.INTENT_SENDER_SERVICE: + try { + owner.startServiceInPackage(uid, + finalIntent, resolvedType); + } catch (RuntimeException e) { + Log.w(ActivityManagerService.TAG, + "Unable to send startService intent", e); + } + break; + } + + if (sendFinish) { + try { + finishedReceiver.performReceive(new Intent(finalIntent), 0, + null, null, false); + } catch (RemoteException e) { + } + } + + Binder.restoreCallingIdentity(origId); + + return 0; + } + } + return -1; + } + + protected void finalize() throws Throwable { + if (!canceled) { + synchronized(owner) { + WeakReference<PendingIntentRecord> current = + owner.mIntentSenderRecords.get(key); + if (current == ref) { + owner.mIntentSenderRecords.remove(key); + } + } + } + } + + void dump(PrintWriter pw, String prefix) { + pw.println(prefix + "packageName=" + key.packageName + + " type=" + key.typeName() + + " flags=0x" + Integer.toHexString(key.flags)); + pw.println(prefix + "activity=" + key.activity + " who=" + key.who); + pw.println(prefix + "requestCode=" + key.requestCode + + " requestResolvedType=" + key.requestResolvedType); + pw.println(prefix + "requestIntent=" + key.requestIntent); + pw.println(prefix + "sent=" + sent + " canceled=" + canceled); + } + + public String toString() { + return "IntentSenderRecord{" + + Integer.toHexString(System.identityHashCode(this)) + + " " + key.packageName + " " + key.typeName() + "}"; + } +} diff --git a/services/java/com/android/server/am/PendingThumbnailsRecord.java b/services/java/com/android/server/am/PendingThumbnailsRecord.java new file mode 100644 index 0000000..ed478c9 --- /dev/null +++ b/services/java/com/android/server/am/PendingThumbnailsRecord.java @@ -0,0 +1,39 @@ +/* + * Copyright (C) 2006 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.server.am; + +import android.app.IThumbnailReceiver; + +import java.util.HashSet; + +/** + * This class keeps track of calls to getTasks() that are still + * waiting for thumbnail images. + */ +class PendingThumbnailsRecord +{ + final IThumbnailReceiver receiver; // who is waiting. + HashSet pendingRecords; // HistoryRecord objects we still wait for. + boolean finished; // Is pendingRecords empty? + + PendingThumbnailsRecord(IThumbnailReceiver _receiver) + { + receiver = _receiver; + pendingRecords = new HashSet(); + finished = false; + } +} diff --git a/services/java/com/android/server/am/ProcessRecord.java b/services/java/com/android/server/am/ProcessRecord.java new file mode 100644 index 0000000..a1320df --- /dev/null +++ b/services/java/com/android/server/am/ProcessRecord.java @@ -0,0 +1,224 @@ +/* + * Copyright (C) 2006 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.server.am; + +import com.android.internal.os.BatteryStatsImpl; +import com.android.server.Watchdog; + +import android.app.ActivityManager; +import android.app.Dialog; +import android.app.IApplicationThread; +import android.app.IInstrumentationWatcher; +import android.content.ComponentName; +import android.content.pm.ApplicationInfo; +import android.os.Bundle; +import android.os.IBinder; +import android.os.RemoteException; + +import java.io.PrintWriter; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.HashSet; + +/** + * Full information about a particular process that + * is currently running. + */ +class ProcessRecord implements Watchdog.PssRequestor { + final BatteryStatsImpl.Uid.Proc batteryStats; // where to collect runtime statistics + final ApplicationInfo info; // all about the first app in the process + final String processName; // name of the process + // List of packages running in the process + final HashSet<String> pkgList = new HashSet(); + IApplicationThread thread; // the actual proc... may be null only if + // 'persistent' is true (in which case we + // are in the process of launching the app) + int pid; // The process of this application; 0 if none + boolean starting; // True if the process is being started + int maxAdj; // Maximum OOM adjustment for this process + int hiddenAdj; // If hidden, this is the adjustment to use + int curRawAdj; // Current OOM unlimited adjustment for this process + int setRawAdj; // Last set OOM unlimited adjustment for this process + int curAdj; // Current OOM adjustment for this process + int setAdj; // Last set OOM adjustment for this process + boolean isForeground; // Is this app running the foreground UI? + boolean setIsForeground; // Running foreground UI when last set? + boolean foregroundServices; // Running any services that are foreground? + boolean bad; // True if disabled in the bad process list + IBinder forcingToForeground;// Token that is forcing this process to be foreground + int adjSeq; // Sequence id for identifying repeated trav + ComponentName instrumentationClass;// class installed to instrument app + String instrumentationProfileFile; // where to save profiling + IInstrumentationWatcher instrumentationWatcher; // who is waiting + Bundle instrumentationArguments;// as given to us + ComponentName instrumentationResultClass;// copy of instrumentationClass + BroadcastRecord curReceiver;// receiver currently running in the app + long lastRequestedGc; // When we last asked the app to do a gc + int lastPss; // Last pss size reported by app. + + // contains HistoryRecord objects + final ArrayList activities = new ArrayList(); + // all ServiceRecord running in this process + final HashSet services = new HashSet(); + // services that are currently executing code (need to remain foreground). + final HashSet<ServiceRecord> executingServices + = new HashSet<ServiceRecord>(); + // All ConnectionRecord this process holds + final HashSet<ConnectionRecord> connections + = new HashSet<ConnectionRecord>(); + // all IIntentReceivers that are registered from this process. + final HashSet<ReceiverList> receivers = new HashSet<ReceiverList>(); + // class (String) -> ContentProviderRecord + final HashMap pubProviders = new HashMap(); + // All ContentProviderRecord process is using + final HashSet conProviders = new HashSet(); + + boolean persistent; // always keep this application running? + boolean crashing; // are we in the process of crashing? + Dialog crashDialog; // dialog being displayed due to crash. + boolean notResponding; // does the app have a not responding dialog? + Dialog anrDialog; // dialog being displayed due to app not resp. + boolean removed; // has app package been removed from device? + boolean debugging; // was app launched for debugging? + int persistentActivities; // number of activities that are persistent + boolean waitedForDebugger; // has process show wait for debugger dialog? + Dialog waitDialog; // current wait for debugger dialog + + // These reports are generated & stored when an app gets into an error condition. + // They will be "null" when all is OK. + ActivityManager.ProcessErrorStateInfo crashingReport; + ActivityManager.ProcessErrorStateInfo notRespondingReport; + + void dump(PrintWriter pw, String prefix) { + pw.println(prefix + this); + pw.println(prefix + "class=" + info.className); + pw.println(prefix+"manageSpaceActivityName="+info.manageSpaceActivityName); + pw.println(prefix + "dir=" + info.sourceDir + " publicDir=" + info.publicSourceDir + + " data=" + info.dataDir); + pw.println(prefix + "packageList=" + pkgList); + pw.println(prefix + "instrumentationClass=" + instrumentationClass + + " instrumentationProfileFile=" + instrumentationProfileFile); + pw.println(prefix + "instrumentationArguments=" + instrumentationArguments); + pw.println(prefix + "thread=" + thread + " curReceiver=" + curReceiver); + pw.println(prefix + "pid=" + pid + " starting=" + starting + + " lastPss=" + lastPss); + pw.println(prefix + "maxAdj=" + maxAdj + " hiddenAdj=" + hiddenAdj + + " curRawAdj=" + curRawAdj + " setRawAdj=" + setRawAdj + + " curAdj=" + curAdj + " setAdj=" + setAdj); + pw.println(prefix + "isForeground=" + isForeground + + " setIsForeground=" + setIsForeground + + " foregroundServices=" + foregroundServices + + " forcingToForeground=" + forcingToForeground); + pw.println(prefix + "persistent=" + persistent + " removed=" + removed + + " persistentActivities=" + persistentActivities); + pw.println(prefix + "debugging=" + debugging + + " crashing=" + crashing + " " + crashDialog + + " notResponding=" + notResponding + " " + anrDialog + + " bad=" + bad); + pw.println(prefix + "activities=" + activities); + pw.println(prefix + "services=" + services); + pw.println(prefix + "executingServices=" + executingServices); + pw.println(prefix + "connections=" + connections); + pw.println(prefix + "pubProviders=" + pubProviders); + pw.println(prefix + "conProviders=" + conProviders); + pw.println(prefix + "receivers=" + receivers); + } + + ProcessRecord(BatteryStatsImpl.Uid.Proc _batteryStats, IApplicationThread _thread, + ApplicationInfo _info, String _processName) { + batteryStats = _batteryStats; + info = _info; + processName = _processName; + pkgList.add(_info.packageName); + thread = _thread; + maxAdj = ActivityManagerService.EMPTY_APP_ADJ; + hiddenAdj = ActivityManagerService.HIDDEN_APP_MIN_ADJ; + curRawAdj = setRawAdj = -100; + curAdj = setAdj = -100; + persistent = false; + removed = false; + persistentActivities = 0; + } + + /** + * This method returns true if any of the activities within the process record are interesting + * to the user. See HistoryRecord.isInterestingToUserLocked() + */ + public boolean isInterestingToUserLocked() { + final int size = activities.size(); + for (int i = 0 ; i < size ; i++) { + HistoryRecord r = (HistoryRecord) activities.get(i); + if (r.isInterestingToUserLocked()) { + return true; + } + } + return false; + } + + public void stopFreezingAllLocked() { + int i = activities.size(); + while (i > 0) { + i--; + ((HistoryRecord)activities.get(i)).stopFreezingScreenLocked(true); + } + } + + public void requestPss() { + IApplicationThread localThread = thread; + if (localThread != null) { + try { + localThread.requestPss(); + } catch (RemoteException e) { + } + } + } + + public String toString() { + return "ProcessRecord{" + + Integer.toHexString(System.identityHashCode(this)) + + " " + pid + ":" + processName + "/" + info.uid + "}"; + } + + /* + * Return true if package has been added false if not + */ + public boolean addPackage(String pkg) { + if (!pkgList.contains(pkg)) { + pkgList.add(pkg); + return true; + } + return false; + } + + /* + * Delete all packages from list except the package indicated in info + */ + public void resetPackageList() { + pkgList.clear(); + pkgList.add(info.packageName); + } + + public String[] getPackageList() { + int size = pkgList.size(); + if (size == 0) { + return null; + } + String list[] = new String[size]; + pkgList.toArray(list); + return list; + } +} diff --git a/services/java/com/android/server/am/ReceiverList.java b/services/java/com/android/server/am/ReceiverList.java new file mode 100644 index 0000000..6ac527b --- /dev/null +++ b/services/java/com/android/server/am/ReceiverList.java @@ -0,0 +1,92 @@ +/* + * Copyright (C) 2006 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.server.am; + +import android.app.IIntentReceiver; +import android.content.Intent; +import android.os.Bundle; +import android.os.IBinder; +import android.os.RemoteException; + +import java.io.PrintWriter; +import java.util.ArrayList; + +/** + * A receiver object that has registered for one or more broadcasts. + * The ArrayList holds BroadcastFilter objects. + */ +class ReceiverList extends ArrayList<BroadcastFilter> + implements IBinder.DeathRecipient { + final ActivityManagerService owner; + public final IIntentReceiver receiver; + public final ProcessRecord app; + public final int pid; + public final int uid; + BroadcastRecord curBroadcast = null; + boolean linkedToDeath = false; + + ReceiverList(ActivityManagerService _owner, ProcessRecord _app, + int _pid, int _uid, IIntentReceiver _receiver) { + owner = _owner; + receiver = _receiver; + app = _app; + pid = _pid; + uid = _uid; + } + + // Want object identity, not the array identity we are inheriting. + public boolean equals(Object o) { + return this == o; + } + public int hashCode() { + return System.identityHashCode(this); + } + + public void binderDied() { + linkedToDeath = false; + owner.unregisterReceiver(receiver); + } + + void dumpLocal(PrintWriter pw, String prefix) { + pw.println(prefix + "receiver=IBinder " + + Integer.toHexString(System.identityHashCode(receiver.asBinder()))); + pw.println(prefix + "app=" + app + " pid=" + pid + " uid=" + uid); + pw.println(prefix + "curBroadcast=" + curBroadcast + + " linkedToDeath=" + linkedToDeath); + } + + void dump(PrintWriter pw, String prefix) { + pw.println(prefix + this); + dumpLocal(pw, prefix); + String p2 = prefix + " "; + final int N = size(); + for (int i=0; i<N; i++) { + BroadcastFilter bf = get(i); + pw.println(prefix + "Filter #" + i + ": " + bf); + bf.dump(pw, p2); + } + } + + public String toString() { + return "ReceiverList{" + + Integer.toHexString(System.identityHashCode(this)) + + " " + pid + " " + (app != null ? app.processName : "(unknown name)") + + "/" + uid + " client " + + Integer.toHexString(System.identityHashCode(receiver.asBinder())) + + "}"; + } +} diff --git a/services/java/com/android/server/am/ServiceRecord.java b/services/java/com/android/server/am/ServiceRecord.java new file mode 100644 index 0000000..4b90600 --- /dev/null +++ b/services/java/com/android/server/am/ServiceRecord.java @@ -0,0 +1,166 @@ +/* + * Copyright (C) 2006 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.server.am; + +import com.android.internal.os.BatteryStatsImpl; + +import android.content.ComponentName; +import android.content.Intent; +import android.content.pm.ApplicationInfo; +import android.content.pm.ServiceInfo; +import android.os.Binder; +import android.os.IBinder; +import android.os.SystemClock; + +import java.io.PrintWriter; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.Iterator; +import java.util.List; + +/** + * A running application service. + */ +class ServiceRecord extends Binder { + final BatteryStatsImpl.Uid.Pkg.Serv stats; + final ComponentName name; // service component. + final String shortName; // name.flattenToShortString(). + final Intent.FilterComparison intent; + // original intent used to find service. + final ServiceInfo serviceInfo; + // all information about the service. + final ApplicationInfo appInfo; + // information about service's app. + final String packageName; // the package implementing intent's component + final String processName; // process where this component wants to run + final String permission;// permission needed to access service + final String baseDir; // where activity source (resources etc) located + final String resDir; // where public activity source (public resources etc) located + final String dataDir; // where activity data should go + final boolean exported; // from ServiceInfo.exported + final Runnable restarter; // used to schedule retries of starting the service + final long createTime; // when this service was created + final HashMap<Intent.FilterComparison, IntentBindRecord> bindings + = new HashMap<Intent.FilterComparison, IntentBindRecord>(); + // All active bindings to the service. + final HashMap<IBinder, ConnectionRecord> connections + = new HashMap<IBinder, ConnectionRecord>(); + // IBinder -> ConnectionRecord of all bound clients + final List<Intent> startArgs = new ArrayList<Intent>(); + // start() arguments that haven't yet been delivered. + + ProcessRecord app; // where this service is running or null. + boolean isForeground; // asked to run as a foreground service? + long lastActivity; // last time there was some activity on the service. + boolean startRequested; // someone explicitly called start? + int lastStartId; // identifier of most recent start request. + int executeNesting; // number of outstanding operations keeping foreground. + long executingStart; // start time of last execute request. + int crashCount; // number of times proc has crashed with service running + int totalRestartCount; // number of times we have had to restart. + int restartCount; // number of restarts performed in a row. + long restartDelay; // delay until next restart attempt. + long restartTime; // time of last restart. + long nextRestartTime; // time when restartDelay will expire. + + void dump(PrintWriter pw, String prefix) { + pw.println(prefix + this); + pw.println(prefix + "intent=" + intent.getIntent()); + pw.println(prefix + "packageName=" + packageName); + pw.println(prefix + "processName=" + processName); + pw.println(prefix + "permission=" + permission); + pw.println(prefix + "baseDir=" + baseDir+ " resDir=" + resDir + " dataDir=" + dataDir); + pw.println(prefix + "app=" + app); + pw.println(prefix + "isForeground=" + isForeground + + " lastActivity=" + lastActivity); + pw.println(prefix + "startRequested=" + startRequested + + " startId=" + lastStartId + + " executeNesting=" + executeNesting + + " executingStart=" + executingStart + + " crashCount=" + crashCount); + pw.println(prefix + "totalRestartCount=" + totalRestartCount + + " restartCount=" + restartCount + + " restartDelay=" + restartDelay + + " restartTime=" + restartTime + + " nextRestartTime=" + nextRestartTime); + if (bindings.size() > 0) { + pw.println(prefix + "Bindings:"); + Iterator<IntentBindRecord> it = bindings.values().iterator(); + while (it.hasNext()) { + IntentBindRecord b = it.next(); + pw.println(prefix + "Binding " + b); + b.dump(pw, prefix + " "); + } + } + if (connections.size() > 0) { + pw.println(prefix + "All Connections:"); + Iterator<ConnectionRecord> it = connections.values().iterator(); + while (it.hasNext()) { + ConnectionRecord c = it.next(); + pw.println(prefix + " " + c); + } + } + } + + ServiceRecord(BatteryStatsImpl.Uid.Pkg.Serv servStats, ComponentName name, + Intent.FilterComparison intent, ServiceInfo sInfo, Runnable restarter) { + this.stats = servStats; + this.name = name; + shortName = name.flattenToShortString(); + this.intent = intent; + serviceInfo = sInfo; + appInfo = sInfo.applicationInfo; + packageName = sInfo.applicationInfo.packageName; + processName = sInfo.processName; + permission = sInfo.permission; + baseDir = sInfo.applicationInfo.sourceDir; + resDir = sInfo.applicationInfo.publicSourceDir; + dataDir = sInfo.applicationInfo.dataDir; + exported = sInfo.exported; + this.restarter = restarter; + createTime = lastActivity = SystemClock.uptimeMillis(); + } + + public AppBindRecord retrieveAppBindingLocked(Intent intent, + ProcessRecord app) { + Intent.FilterComparison filter = new Intent.FilterComparison(intent); + IntentBindRecord i = bindings.get(filter); + if (i == null) { + i = new IntentBindRecord(this, filter); + bindings.put(filter, i); + } + AppBindRecord a = i.apps.get(app); + if (a != null) { + return a; + } + a = new AppBindRecord(this, i, app); + i.apps.put(app, a); + return a; + } + + public void resetRestartCounter() { + restartCount = 0; + restartDelay = 0; + restartTime = 0; + } + + public String toString() { + return "ServiceRecord{" + + Integer.toHexString(System.identityHashCode(this)) + + " " + shortName + "}"; + } +} diff --git a/services/java/com/android/server/am/TaskRecord.java b/services/java/com/android/server/am/TaskRecord.java new file mode 100644 index 0000000..aab3736 --- /dev/null +++ b/services/java/com/android/server/am/TaskRecord.java @@ -0,0 +1,104 @@ +/* + * Copyright (C) 2006 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.server.am; + +import android.content.ComponentName; +import android.content.Intent; +import android.content.pm.ActivityInfo; +import android.os.SystemClock; + +import java.io.PrintWriter; + +class TaskRecord { + final int taskId; // Unique identifier for this task. + final String affinity; // The affinity name for this task, or null. + final boolean clearOnBackground; // As per the original activity. + Intent intent; // The original intent that started the task. + Intent affinityIntent; // Intent of affinity-moved activity that started this task. + ComponentName origActivity; // The non-alias activity component of the intent. + ComponentName realActivity; // The actual activity component that started the task. + int numActivities; // Current number of activities in this task. + long lastActiveTime; // Last time this task was active, including sleep. + boolean rootWasReset; // True if the intent at the root of the task had + // the FLAG_ACTIVITY_RESET_TASK_IF_NEEDED flag. + + TaskRecord(int _taskId, ActivityInfo info, Intent _intent, + boolean _clearOnBackground) { + taskId = _taskId; + affinity = info.taskAffinity; + clearOnBackground = _clearOnBackground; + setIntent(_intent, info); + } + + void touchActiveTime() { + lastActiveTime = android.os.SystemClock.elapsedRealtime(); + } + + long getInactiveDuration() { + return android.os.SystemClock.elapsedRealtime() - lastActiveTime; + } + + void setIntent(Intent _intent, ActivityInfo info) { + if (info.targetActivity == null) { + intent = _intent; + realActivity = _intent != null ? _intent.getComponent() : null; + origActivity = null; + } else { + ComponentName targetComponent = new ComponentName( + info.packageName, info.targetActivity); + if (_intent != null) { + Intent targetIntent = new Intent(_intent); + targetIntent.setComponent(targetComponent); + intent = targetIntent; + realActivity = targetComponent; + origActivity = _intent.getComponent(); + } else { + intent = null; + realActivity = targetComponent; + origActivity = new ComponentName(info.packageName, info.name); + } + } + + if (intent != null && + (intent.getFlags()&Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED) != 0) { + // Once we are set to an Intent with this flag, we count this + // task as having a true root activity. + rootWasReset = true; + } + } + + void dump(PrintWriter pw, String prefix) { + pw.println(prefix + this); + pw.println(prefix + "clearOnBackground=" + clearOnBackground + + " numActivities=" + numActivities + + " rootWasReset=" + rootWasReset); + pw.println(prefix + "affinity=" + affinity); + pw.println(prefix + "intent=" + intent); + pw.println(prefix + "affinityIntent=" + affinityIntent); + pw.println(prefix + "origActivity=" + origActivity); + pw.println(prefix + "lastActiveTime=" + lastActiveTime + +" (inactive for " + (getInactiveDuration()/1000) + "s)"); + } + + public String toString() { + return "Task{" + taskId + " " + + (affinity != null ? affinity + : (intent != null ? intent.getComponent().flattenToShortString() + : affinityIntent != null ? affinityIntent.getComponent().flattenToShortString() : "??")) + + "}"; + } +} diff --git a/services/java/com/android/server/am/UriPermission.java b/services/java/com/android/server/am/UriPermission.java new file mode 100644 index 0000000..fb7a745 --- /dev/null +++ b/services/java/com/android/server/am/UriPermission.java @@ -0,0 +1,82 @@ +/* + * Copyright (C) 2006 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.server.am; + +import android.content.Intent; +import android.net.Uri; + +import java.io.PrintWriter; +import java.util.HashSet; + +class UriPermission { + final int uid; + final Uri uri; + int modeFlags = 0; + int globalModeFlags = 0; + final HashSet<HistoryRecord> readActivities = new HashSet<HistoryRecord>(); + final HashSet<HistoryRecord> writeActivities = new HashSet<HistoryRecord>(); + + UriPermission(int _uid, Uri _uri) { + uid = _uid; + uri = _uri; + } + + void clearModes(int modeFlags) { + if ((modeFlags&Intent.FLAG_GRANT_READ_URI_PERMISSION) != 0) { + globalModeFlags &= ~Intent.FLAG_GRANT_READ_URI_PERMISSION; + modeFlags &= ~Intent.FLAG_GRANT_READ_URI_PERMISSION; + if (readActivities.size() > 0) { + for (HistoryRecord r : readActivities) { + r.readUriPermissions.remove(this); + if (r.readUriPermissions.size() == 0) { + r.readUriPermissions = null; + } + } + readActivities.clear(); + } + } + if ((modeFlags&Intent.FLAG_GRANT_WRITE_URI_PERMISSION) != 0) { + globalModeFlags &= ~Intent.FLAG_GRANT_WRITE_URI_PERMISSION; + modeFlags &= ~Intent.FLAG_GRANT_WRITE_URI_PERMISSION; + if (readActivities.size() > 0) { + for (HistoryRecord r : readActivities) { + r.writeUriPermissions.remove(this); + if (r.writeUriPermissions.size() == 0) { + r.writeUriPermissions = null; + } + } + readActivities.clear(); + } + } + } + + public String toString() { + return "UriPermission{" + + Integer.toHexString(System.identityHashCode(this)) + + " " + uri + "}"; + } + + void dump(PrintWriter pw, String prefix) { + pw.println(prefix + this); + pw.println(prefix + " modeFlags=0x" + Integer.toHexString(modeFlags) + + " uid=" + uid + + " globalModeFlags=0x" + + Integer.toHexString(globalModeFlags)); + pw.println(prefix + " readActivities=" + readActivities); + pw.println(prefix + " writeActivities=" + writeActivities); + } +} diff --git a/services/java/com/android/server/am/UsageStatsService.java b/services/java/com/android/server/am/UsageStatsService.java new file mode 100755 index 0000000..3922f39 --- /dev/null +++ b/services/java/com/android/server/am/UsageStatsService.java @@ -0,0 +1,532 @@ +/* + * Copyright (C) 2006-2007 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.server.am; + +import com.android.internal.app.IUsageStats; +import android.content.ComponentName; +import android.content.Context; +import android.os.Binder; +import android.os.IBinder; +import com.android.internal.os.PkgUsageStats; +import android.os.Parcel; +import android.os.Process; +import android.os.ServiceManager; +import android.os.SystemClock; +import android.util.Log; +import java.io.File; +import java.io.FileDescriptor; +import java.io.FileInputStream; +import java.io.FileNotFoundException; +import java.io.FileOutputStream; +import java.io.IOException; +import java.io.PrintWriter; +import java.util.ArrayList; +import java.util.Calendar; +import java.util.Collections; +import java.util.Date; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Set; + +/** + * This service collects the statistics associated with usage + * of various components, like when a particular package is launched or + * paused and aggregates events like number of time a component is launched + * total duration of a component launch. + */ +public final class UsageStatsService extends IUsageStats.Stub { + public static final String SERVICE_NAME = "usagestats"; + private static final boolean localLOGV = false; + private static final String TAG = "UsageStats"; + static IUsageStats sService; + private Context mContext; + // structure used to maintain statistics since the last checkin. + final private Map<String, PkgUsageStatsExtended> mStats; + // Lock to update package stats. Methods suffixed by SLOCK should invoked with + // this lock held + final Object mStatsLock; + // Lock to write to file. Methods suffixed by FLOCK should invoked with + // this lock held. + final Object mFileLock; + // Order of locks is mFileLock followed by mStatsLock to avoid deadlocks + private String mResumedPkg; + private File mFile; + //private File mBackupFile; + private long mLastWriteRealTime; + private int _FILE_WRITE_INTERVAL = 30*60*1000; //ms + private static final String _PREFIX_DELIMIT="."; + private String mFilePrefix; + private Calendar mCal; + private static final int _MAX_NUM_FILES = 10; + private long mLastTime; + + private class PkgUsageStatsExtended { + int mLaunchCount; + long mUsageTime; + long mPausedTime; + long mResumedTime; + + PkgUsageStatsExtended() { + mLaunchCount = 0; + mUsageTime = 0; + } + void updateResume() { + mLaunchCount ++; + mResumedTime = SystemClock.elapsedRealtime(); + } + void updatePause() { + mPausedTime = SystemClock.elapsedRealtime(); + mUsageTime += (mPausedTime - mResumedTime); + } + void clear() { + mLaunchCount = 0; + mUsageTime = 0; + } + } + + UsageStatsService(String fileName) { + mStats = new HashMap<String, PkgUsageStatsExtended>(); + mStatsLock = new Object(); + mFileLock = new Object(); + mFilePrefix = fileName; + mCal = Calendar.getInstance(); + // Update current stats which are binned by date + String uFileName = getCurrentDateStr(mFilePrefix); + mFile = new File(uFileName); + readStatsFromFile(); + mLastWriteRealTime = SystemClock.elapsedRealtime(); + mLastTime = new Date().getTime(); + } + + /* + * Utility method to convert date into string. + */ + private String getCurrentDateStr(String prefix) { + mCal.setTime(new Date()); + StringBuilder sb = new StringBuilder(); + if (prefix != null) { + sb.append(prefix); + sb.append("."); + } + int mm = mCal.get(Calendar.MONTH) - Calendar.JANUARY +1; + if (mm < 10) { + sb.append("0"); + } + sb.append(mm); + int dd = mCal.get(Calendar.DAY_OF_MONTH); + if (dd < 10) { + sb.append("0"); + } + sb.append(dd); + sb.append(mCal.get(Calendar.YEAR)); + return sb.toString(); + } + + private Parcel getParcelForFile(File file) throws IOException { + FileInputStream stream = new FileInputStream(file); + byte[] raw = readFully(stream); + Parcel in = Parcel.obtain(); + in.unmarshall(raw, 0, raw.length); + in.setDataPosition(0); + stream.close(); + return in; + } + + private void readStatsFromFile() { + File newFile = mFile; + synchronized (mFileLock) { + try { + if (newFile.exists()) { + readStatsFLOCK(newFile); + } else { + // Check for file limit before creating a new file + checkFileLimitFLOCK(); + newFile.createNewFile(); + } + } catch (IOException e) { + Log.w(TAG,"Error : " + e + " reading data from file:" + newFile); + } + } + } + + private void readStatsFLOCK(File file) throws IOException { + Parcel in = getParcelForFile(file); + while (in.dataAvail() > 0) { + String pkgName = in.readString(); + PkgUsageStatsExtended pus = new PkgUsageStatsExtended(); + pus.mLaunchCount = in.readInt(); + pus.mUsageTime = in.readLong(); + synchronized (mStatsLock) { + mStats.put(pkgName, pus); + } + } + } + + private ArrayList<String> getUsageStatsFileListFLOCK() { + File dir = getUsageFilesDir(); + if (dir == null) { + Log.w(TAG, "Couldnt find writable directory for usage stats file"); + return null; + } + // Check if there are too many files in the system and delete older files + String fList[] = dir.list(); + if (fList == null) { + return null; + } + File pre = new File(mFilePrefix); + String filePrefix = pre.getName(); + // file name followed by dot + int prefixLen = filePrefix.length()+1; + ArrayList<String> fileList = new ArrayList<String>(); + for (String file : fList) { + int index = file.indexOf(filePrefix); + if (index == -1) { + continue; + } + if (file.endsWith(".bak")) { + continue; + } + fileList.add(file); + } + return fileList; + } + + private File getUsageFilesDir() { + if (mFilePrefix == null) { + return null; + } + File pre = new File(mFilePrefix); + return new File(pre.getParent()); + } + + private void checkFileLimitFLOCK() { + File dir = getUsageFilesDir(); + if (dir == null) { + Log.w(TAG, "Couldnt find writable directory for usage stats file"); + return; + } + // Get all usage stats output files + ArrayList<String> fileList = getUsageStatsFileListFLOCK(); + if (fileList == null) { + // Strange but we dont have to delete any thing + return; + } + int count = fileList.size(); + if (count <= _MAX_NUM_FILES) { + return; + } + // Sort files + Collections.sort(fileList); + count -= _MAX_NUM_FILES; + // Delete older files + for (int i = 0; i < count; i++) { + String fileName = fileList.get(i); + File file = new File(dir, fileName); + Log.i(TAG, "Deleting file : "+fileName); + file.delete(); + } + } + + private void writeStatsToFile() { + synchronized (mFileLock) { + long currTime = new Date().getTime(); + boolean dayChanged = ((currTime - mLastTime) >= (24*60*60*1000)); + long currRealTime = SystemClock.elapsedRealtime(); + if (((currRealTime-mLastWriteRealTime) < _FILE_WRITE_INTERVAL) && + (!dayChanged)) { + // wait till the next update + return; + } + // Get the most recent file + String todayStr = getCurrentDateStr(mFilePrefix); + // Copy current file to back up + File backupFile = new File(mFile.getPath() + ".bak"); + mFile.renameTo(backupFile); + try { + checkFileLimitFLOCK(); + mFile.createNewFile(); + // Write mStats to file + writeStatsFLOCK(); + mLastWriteRealTime = currRealTime; + mLastTime = currTime; + if (dayChanged) { + // clear stats + synchronized (mStats) { + mStats.clear(); + } + mFile = new File(todayStr); + } + // Delete the backup file + if (backupFile != null) { + backupFile.delete(); + } + } catch (IOException e) { + Log.w(TAG, "Failed writing stats to file:" + mFile); + if (backupFile != null) { + backupFile.renameTo(mFile); + } + } + } + } + + private void writeStatsFLOCK() throws IOException { + FileOutputStream stream = new FileOutputStream(mFile); + Parcel out = Parcel.obtain(); + writeStatsToParcelFLOCK(out); + stream.write(out.marshall()); + out.recycle(); + stream.flush(); + stream.close(); + } + + private void writeStatsToParcelFLOCK(Parcel out) { + synchronized (mStatsLock) { + Set<String> keys = mStats.keySet(); + for (String key : keys) { + PkgUsageStatsExtended pus = mStats.get(key); + out.writeString(key); + out.writeInt(pus.mLaunchCount); + out.writeLong(pus.mUsageTime); + } + } + } + + public void publish(Context context) { + mContext = context; + ServiceManager.addService(SERVICE_NAME, asBinder()); + } + + public static IUsageStats getService() { + if (sService != null) { + return sService; + } + IBinder b = ServiceManager.getService(SERVICE_NAME); + sService = asInterface(b); + return sService; + } + + public void noteResumeComponent(ComponentName componentName) { + enforceCallingPermission(); + String pkgName; + if ((componentName == null) || + ((pkgName = componentName.getPackageName()) == null)) { + return; + } + if ((mResumedPkg != null) && (mResumedPkg.equalsIgnoreCase(pkgName))) { + // Moving across activities in same package. just return + return; + } + if (localLOGV) Log.i(TAG, "started component:"+pkgName); + synchronized (mStatsLock) { + PkgUsageStatsExtended pus = mStats.get(pkgName); + if (pus == null) { + pus = new PkgUsageStatsExtended(); + mStats.put(pkgName, pus); + } + pus.updateResume(); + } + mResumedPkg = pkgName; + } + + public void notePauseComponent(ComponentName componentName) { + enforceCallingPermission(); + String pkgName; + if ((componentName == null) || + ((pkgName = componentName.getPackageName()) == null)) { + return; + } + if ((mResumedPkg == null) || (!pkgName.equalsIgnoreCase(mResumedPkg))) { + Log.w(TAG, "Something wrong here, Didn't expect "+pkgName+" to be paused"); + return; + } + if (localLOGV) Log.i(TAG, "paused component:"+pkgName); + synchronized (mStatsLock) { + PkgUsageStatsExtended pus = mStats.get(pkgName); + if (pus == null) { + // Weird some error here + Log.w(TAG, "No package stats for pkg:"+pkgName); + return; + } + pus.updatePause(); + } + // Persist data to file + writeStatsToFile(); + } + + public void enforceCallingPermission() { + if (Binder.getCallingPid() == Process.myPid()) { + return; + } + mContext.enforcePermission(android.Manifest.permission.UPDATE_DEVICE_STATS, + Binder.getCallingPid(), Binder.getCallingUid(), null); + } + + public PkgUsageStats getPkgUsageStats(ComponentName componentName) { + mContext.enforceCallingOrSelfPermission( + android.Manifest.permission.PACKAGE_USAGE_STATS, null); + String pkgName; + if ((componentName == null) || + ((pkgName = componentName.getPackageName()) == null)) { + return null; + } + synchronized (mStatsLock) { + PkgUsageStatsExtended pus = mStats.get(pkgName); + if (pus == null) { + return null; + } + return new PkgUsageStats(pkgName, pus.mLaunchCount, pus.mUsageTime); + } + } + + public PkgUsageStats[] getAllPkgUsageStats() { + mContext.enforceCallingOrSelfPermission( + android.Manifest.permission.PACKAGE_USAGE_STATS, null); + synchronized (mStatsLock) { + Set<String> keys = mStats.keySet(); + int size = keys.size(); + if (size <= 0) { + return null; + } + PkgUsageStats retArr[] = new PkgUsageStats[size]; + int i = 0; + for (String key: keys) { + PkgUsageStatsExtended pus = mStats.get(key); + retArr[i] = new PkgUsageStats(key, pus.mLaunchCount, pus.mUsageTime); + i++; + } + return retArr; + } + } + + static byte[] readFully(FileInputStream stream) throws java.io.IOException { + int pos = 0; + int avail = stream.available(); + byte[] data = new byte[avail]; + while (true) { + int amt = stream.read(data, pos, data.length-pos); + if (amt <= 0) { + return data; + } + pos += amt; + avail = stream.available(); + if (avail > data.length-pos) { + byte[] newData = new byte[pos+avail]; + System.arraycopy(data, 0, newData, 0, pos); + data = newData; + } + } + } + + private void collectDumpInfoFLOCK(PrintWriter pw, String[] args) { + List<String> fileList = getUsageStatsFileListFLOCK(); + if (fileList == null) { + return; + } + final boolean isCheckinRequest = scanArgs(args, "-c"); + Collections.sort(fileList); + File usageFile = new File(mFilePrefix); + String dirName = usageFile.getParent(); + File dir = new File(dirName); + String filePrefix = usageFile.getName(); + // file name followed by dot + int prefixLen = filePrefix.length()+1; + String todayStr = getCurrentDateStr(null); + for (String file : fileList) { + File dFile = new File(dir, file); + String dateStr = file.substring(prefixLen); + try { + Parcel in = getParcelForFile(dFile); + collectDumpInfoFromParcelFLOCK(in, pw, dateStr, isCheckinRequest); + if (isCheckinRequest && !todayStr.equalsIgnoreCase(dateStr)) { + // Delete old file after collecting info only for checkin requests + dFile.delete(); + } + } catch (FileNotFoundException e) { + Log.w(TAG, "Failed with "+e+" when collecting dump info from file : " + file); + return; + } catch (IOException e) { + Log.w(TAG, "Failed with "+e+" when collecting dump info from file : "+file); + } + } + } + + private void collectDumpInfoFromParcelFLOCK(Parcel in, PrintWriter pw, + String date, boolean isCheckinRequest) { + StringBuilder sb = new StringBuilder(); + sb.append("Date:"); + sb.append(date); + boolean first = true; + while (in.dataAvail() > 0) { + String pkgName = in.readString(); + int launchCount = in.readInt(); + long usageTime = in.readLong(); + if (isCheckinRequest) { + if (!first) { + sb.append(","); + } + sb.append(pkgName); + sb.append(","); + sb.append(launchCount); + sb.append(","); + sb.append(usageTime); + sb.append("ms"); + } else { + if (first) { + sb.append("\n"); + } + sb.append("pkg="); + sb.append(pkgName); + sb.append(", launchCount="); + sb.append(launchCount); + sb.append(", usageTime="); + sb.append(usageTime); + sb.append(" ms\n"); + } + first = false; + } + pw.write(sb.toString()); + } + + /** + * Searches array of arguments for the specified string + * @param args array of argument strings + * @param value value to search for + * @return true if the value is contained in the array + */ + private static boolean scanArgs(String[] args, String value) { + if (args != null) { + for (String arg : args) { + if (value.equals(arg)) { + return true; + } + } + } + return false; + } + + @Override + /* + * The data persisted to file is parsed and the stats are computed. + */ + protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) { + synchronized (mFileLock) { + collectDumpInfoFLOCK(pw, args); + } + } + +} diff --git a/services/java/com/android/server/am/package.html b/services/java/com/android/server/am/package.html new file mode 100755 index 0000000..c9f96a6 --- /dev/null +++ b/services/java/com/android/server/am/package.html @@ -0,0 +1,5 @@ +<body> + +{@hide} + +</body> |