Lines Matching refs:is
11 * distributed under the License is distributed on an "AS IS" BASIS,
324 // when the request is due to the memory state being lowered.
359 // Maximum number of persisted Uri grants a package is allowed
400 // Convenient for easy iteration over the queues. Foreground is first
520 * Information about a process that is currently marked as bad.
541 * later restarted (hopefully due to some user action). The value is the
550 * <p>NOTE: This object is protected by its own lock, NOT the global
557 * is the pid of the caller who requested it (we hold a death
569 * are started by the time booting is complete.
586 * The first entry in the list is the least recently used.
597 * This is after (lower index) than mLruProcessesActivityStart.
623 * This is the process holding what we currently consider to be
629 * This is the process holding the activity the user last visited that
630 * is in a different process from the one they are currently in.
645 * LRU list of history of current users. Most recently current is at the end.
689 * The string buffer is guarded by itself, and its lock is also
690 * used to determine if another batched write is already
697 * broadcasts. Hash keys are the receiver IBinder, hash value is
744 * that action (which should usually be one). The SparseArray is keyed
745 * by the user ID the sticky is for, and can include UserHandle.USER_ALL
777 * When service association tracking is enabled, this is all of the associations we
778 * have seen. Mapping is target uid -> target component -> source uid -> source process name
795 * application is currently being launched and the provider will be
796 * removed from this list once it is published.
976 * This is set to true after the first switch after mAppSwitchesAllowedTime
977 * is set; any switches after that will clear the time.
999 * sleeping while it is active.
1004 * State of external calls telling us if the device is awake or asleep.
1012 * State of external call telling us if the lock screen is shown.
1053 * This is set to false when we are killing processes for reasons other than
1055 * an indication that memory is tighter.
1082 * If RAM is currently low, when that horrible situation started.
1094 * service. The ProcessMap is package/uid tuples; each of these contain
1101 * This is set if we had to do a delayed dexopt of an app before launching
1156 * Runtime CPU use collection thread. This object's lock is used to
1176 * Used to retain an update lock when the foreground activity is in
1202 * Mapping from each known user ID to the profile group ID it is associated with.
1284 * Flag whether the current user is a "monkey", i.e. whether
1285 * the UI is driven by a UI automation tool.
1340 // The device is asleep, so just pretend that the user
1375 // Just kill the app if there is no dialog to be shown.
1401 // The device is asleep, so just pretend that the user
1838 // This is definitely an application process; skip it.
1843 // This is one of our own processes; skip it.
2058 // Note: This method is invoked on the main thread but may need to attach various
2099 // User 0 is the first and only user that runs at boot.
2246 // Slog the cpu usage if the property is set.
2342 * process when the bindApplication() IPC is sent to the process. They're
2424 // the activity manager's locks. The new state is determined based on the
2425 // state *now* of the relevant activity record. The object is passed to
2511 // First a quick reject: if the app is already at the position we will
2512 // put it, then there is nothing to do.
2537 if the process is not actually going to move. Not yet working.
2614 // it is for the same uid, however, don't do so, because we don't
2645 // If there is a client, don't allow the process to be moved up higher
2652 // list than it already is.
2666 // If the app is currently using a content provider or service,
2746 // In the special case introduced by this method (which is, starting an isolated
2748 // closest thing to a parent's uid is SYSTEM_UID.
2749 // The only important thing here is to keep AI.uid != PR.uid, in order to trigger
2784 // If this is an isolated process, it can't re-use an existing process.
2788 // (1) There is an existing application record; and
2789 // (2) The caller doesn't think it is dead, OR there is no thread
2791 // (3) There is a pid assigned to it, so it is either starting or
2802 // If this is a new package in the process, add the package to the list
2808 // An application record is attached to a previous process,
2823 // is bad. If so, we will just silently fail.
2830 // When the user is explicitly starting a process, then clear its
2864 // If this is a new package in the process, add the package to the list
2869 // If the system is not ready yet, then hold off on starting this
2870 // process until it is.
2979 // system is booted in safe mode.
3127 // Don't do this if the home app is currently being
3174 // We will show this screen if the current one is a different
3374 // This is very dangerous -- it allows you to perform a start activity (including
3391 "Must be called from an activity that is declared in the android package");
3397 // This is still okay, as long as this activity is running under the
3422 // A SecurityException here is generally actually a fault of the original
3484 // If this is coming from the currently resumed activity, it is
3537 // The caller is not running... d'oh!
3542 // The caller is not allowed to change the data.
3563 // We found the current one... the next matching is
3572 Slog.v(TAG, "Next matching activity: next is " + aInfo.packageName
3582 // Nobody who is next!
3597 // currently running activity. This is a little tricky because
3598 // we want to start the new one as if the current one is finished,
3599 // but not finish the current one first so that there is no flicker.
3741 // There is still a slim chance that there are other tasks that point to this task
3742 // and that the chain is so messed up that this task no longer points to them but
3758 // Sort them all by taskId. That is the order they were create in and that order will
3763 // The first one is the end of the chain and has no next.
3771 // Everything in the middle is doubly linked from next to prev.
3790 // The last one is the beginning of the list and has no prev.
3834 // This situation is broken, and we should just get rid of it now.
3842 // Check whether this activity is currently available.
3861 // app is temporarily gone. For the former we want to remove the recents
3921 // mRecentTasks is now in sorted, affiliated order.
4032 // Quick case: check if the top-most recent task is the same.
4037 // Another quick case: check if this is part of a set of affiliated
4053 // Slightly less quick case: the task is already in recents, so all we need
4054 // to do is move it.
4059 // Simple case: this is not an affiliated task, so we just move it to the front.
4094 // If this is a simple non-affiliated task, or we had some failure trying to
4098 // If this is a new affiliated task, then move all of the affiliated tasks
4110 // We found the index of our next affiliation, which is who is
4114 // We found the index of our previous affiliation, which is who is
4184 // Only one of these is a document. Not the droid we're looking for.
4190 // If the caller is not actually asking for a trim, just tell them we reached
4196 // and neither of them is a document, or they are documents using the same activity
4206 // If the new recent task we are adding is not fully
4260 * This is the internal entry point for handling Activity.finish().
4268 * @return Returns true if the activity successfully finished, or false if it is still running.
4298 // Find the first activity that is not finishing.
4301 // ask watcher if this is allowed
4320 // If requested, remove the task that is associated to this activity only if it
4321 // was the root activity in the task. The result code and data is ignored
4580 // restarting this process, but there is a visible activity that
4581 // is hosted by the process... then make sure all visible
4651 // The low memory report is overriding any current
4678 // First check if this ProcessRecord is actually active for the pid.
4737 * If a stack trace dump file is configured, dump process stack traces.
4744 * @return file containing stack traces, or null if no dump file is configured
4779 // The order of traces is considered important to maintain for legibility.
5030 // There is no trace file, so dump (only) the alleged culprit's threads to the log
5347 // Make sure the uid is valid.
5485 // If the other end already died, then our work here is done.
5557 // If no package is specified, we call all processes under the
5607 Slog.w(TAG, "Can't force stop all processes of all users, that is insane!");
5844 // Can't happen; the backup manager is local
5859 // Find the application record that is being attached... either via
5888 // If this application record is still attached to a previous
5964 // If the app is being launched for restore or full backup, set it up specially
6018 // See if the top visible activity is waiting to run in this process...
6040 // Check if a next-broadcast receiver is in this process...
6051 // Check whether the next backup agent is in this process...
6053 if (DEBUG_BACKUP) Slog.v(TAG, "New app is backup target, launching agent for " + app);
6269 Slog.w(TAG, "System backup restored before system is ready");
6466 // We don't want to evaluate this until the pending intent is
6480 + " is not allowed to send as package " + packageName;
6574 + " is not allowed to cancel packges "
6835 * permission is automatically denied. (Internally a null permission
6836 * string is used when calling {@link #checkComponentPermission} in cases
6837 * when only uid-based security is needed.)
6897 * Determine if UID is holding permissions required to access {@link Uri} in
6898 * the given {@link ProviderInfo}. Final permission checking is always done
6935 // track if unprotected read/write is allowed; any denied
7070 * @param userId The userId in which the uri is to be resolved.
7099 * if callingUid is not allowed to do this. Returns the uid of the target
7100 * if the URI permission grant should be performed; returns -1 if it is not
7118 // If this is not a content: uri, we can't do anything with it.
7156 // First... there is no target package, so can anyone access it?
7173 /* There is a special cross user grant if:
7174 * - The target is on another user.
7183 // Second... is the provider allowing granting of URI permissions?
7226 * @param userId The userId in which the uri is to be resolved.
7414 * @param userId The userId in which the uri is to be resolved.
7541 * @param userId The userId in which the uri is to be resolved.
7643 * @param sourceUserId The userId in which the uri is to be resolved.
7677 * @param userId The userId in which the uri is to be resolved.
7809 // Missing grants is okay
7821 * @param userId The userId in which the uri is to be resolved.
7867 * @param userId The userId in which the uri is to be resolved.
8117 + " is using old GET_TASKS but privileged; allowing");
8169 // not supplied RECENT_WITH_EXCLUDED and there is some reason
8396 // Don't kill process that is not associated with this task.
8403 // Don't kill process(es) that has an activity in a different task that is
8579 * of the history stack. The activity's order within the task is unchanged.
8582 * @param nonRoot If false then this only works if the activity is the root
8788 // Since we lost lock on task, make sure it is still there.
8932 // This is a singleton provider, but a user besides the
8933 // default user is asking to initialize a process it runs
8952 // Don't add this if it is a platform component that is marked
8953 // to run in multiple processes, because this is actually
8967 * given {@link ProviderInfo}. Final permission checking is always done
8989 // up different than our initial check for the authority. This is because
9034 + ", uid=" + callingUid + ") that is not exported from uid "
9065 * Returns true if the uri authority is one of the authorities specified in the provider.
9209 // This provider has been published or is in the process
9210 // of being published... but it is also allowed to run
9229 // If this is a perceptible app accessing the provider,
9231 // back up on the LRU list. This is good because
9252 // NOTE: there is still a race here where a signal could be
9255 // the race is now smaller.
9263 + " is crashing; detaching " + r);
9294 // If the provider is a singleton AND
9295 // (it's a call within the same user || the provider is a
9318 // process, and the system is not yet ready to run other
9324 // Make sure that the user who owns this provider is running. If not,
9330 + name + ": user " + userId + " is stopped");
9357 // pm is in same process, this will never happen.
9366 // If this is a multiprocess provider, then just return its
9368 // this if the provider is the same user as the caller's
9379 // This is single process, and our app is now connecting to it.
9390 // If the provider is not already being launched, then get it
9396 // Content provider is now in use, its package can't be stopped.
9433 + name + ": process is bad");
9446 // Make sure the provider is published (the same provider class
9505 // The incoming user check is now handled in checkContentProviderPermissionLocked() to deal
9542 throw new NullPointerException("connection is null");
9662 throw new NullPointerException("connection is null");
9703 throw new NullPointerException("connection is null");
9717 // Make sure the caller is being honest with us.
9736 // Seems like the process is already cleaned up.
9740 // As far as we're concerned, this is just like receiving a
9760 Slog.w(TAG, "ContentProviderConnection is null");
9805 * If an app is in the same user as the ContentProvider, or if it is allowed to interact across
9897 // the uid of the isolated process is specified by the caller.
9971 // that rather than the Activity Manager's own uid. The effect is that
9973 // to the content provider like the Activity Manager itself is making
9995 // Actually is sleeping or shutting down or whatever else in the future
9996 // is an inactive state.
10045 // resuming them until the lock screen is hidden.
10048 // If we're dozing then pause applications whenever the lock screen is shown.
10209 // If the actual IPC caller is different from the logical source, then
10231 // Note that this is not really thread safe if there are multiple
10344 // If there is a controller also implies the user is a monkey.
10505 // Caller is just waiting for the result.
10703 // It only makes sense to do this before the system is ready
10774 // If the worst oom_adj is somewhere in the cached proc LRU range,
10781 // If this is not a secure call, don't let it kill processes that
10867 Slog.w(TAG, "hang: given caller IBinder is already dead.");
10898 // Now the broadcast is done, finish up the low-level shutdown.
11162 // The raw IIntentReceiver interface is called
11196 // Make sure we have the current profile info, since it is needed for
11336 // pm is in same process, this will never happen.
11354 Slog.e(TAG, "Build fingerprint is not consistent, warning user");
11478 // need to keep it running. If a persistent process is actually
11492 // annoy the user repeatedly. Unless it is persistent, since those
11511 // If the crashing process is what we consider to be the "home process" and it has been
11526 // pm is in same process, this will never happen.
11543 // If this app is not running under the current user, then we
11712 // is a non-system app. Non-system apps are isolated with a
11715 // Batching is useful during internal testing with
11738 // An existing dropbox-writing thread is outstanding, so
11772 * @param system whether this wtf is coming from the system
11774 * @return true if the process should exit immediately (WTF is fatal)
11782 // If this is coming from the system, we could very well have low-level
11784 // never want this to become fatal, so there is that too.
11859 // is invoked due to unavailability of lock on am and it
11865 // Note: ProcessRecord 'process' is guarded by the service
12000 // If process is null, we are being called from some internal code
12060 // If this process is running instrumentation, finish it.
12876 pw.println(" Processes that are on old until the system is ready:");
13376 * there is a thread associated with the activity.
13392 // flush anything that is already in the PrintWriter since the thread is going
14105 pw.println("If [process] is specified it can be the name or ");
14779 * @return true if the value is contained in the array
14811 // If this connection is waiting for the provider, then we don't
14813 // or for some reason the provider is not currently launching.
14849 * Main code for cleaning up a process when it has gone away. This is
14934 // the actual situation to identify what is actually going on.
14956 // If the app is undergoing backup, tell the backup manager about it
14965 // can't happen; backup manager is local
14978 // If the caller is restarting this app, then leave it in its
14995 // This app is persistent, so we need to keep its record around.
14996 // If it is not already on the pending app list, add it there
15181 // shouldn't be a big deal, if this is being called outside
15182 // of a locked context there is intrinsically a race with
15233 builder.append(" but is calling from user ");
15296 * Checks to see if the caller is in the same app as the singleton
15297 * component, or the component is in a special app. It allows special apps
15386 // Backup agent is now in use, its package can't be stopped.
15415 // If the process is already attached, schedule the creation of the backup agent now.
15416 // If it is not yet live, this will be done when it attaches to the framework.
15429 // is either already running or in the process of coming up. mBackupTarget and
15466 // can't happen; the backup manager service is local
15491 Slog.e(TAG, "Unbind of " + appInfo + " but is not the current backup target");
15583 + " is not running in process " + callerApp);
15615 // The first sticky in the list is returned directly back to
15765 // If this is not the primary user, we need to check for
15821 // pm is in same process, this will never happen.
15847 // Make sure that the user who is receiving this broadcast is running.
15856 + ": user " + userId + " is stopped");
15891 // it is being sent to the calling app.
15920 // Handle special intents: if this broadcast is from the package
16024 // If this is the time zone changed action, queue up a message that will reset
16070 // We use userId directly here, since the "all" target is maintained
16073 // But first, if this is not a broadcast to all users, then
16510 * error to the logs, but if somebody is watching, send the report there too. This enables
16550 // it is finished we make sure it is reset to its default.
16661 * make sure the given activity is running with the (now) current
16663 * false if <var>starting</var> is being destroyed to match the new
16709 // right now, so that anyone who is going to retrieve
16711 // the new ones. This is especially important during
16714 // code is executed.
16753 // mainStack is null during startup.
16756 // If the configuration changed, and the caller is not already
16779 * crash, etc dialogs. The idea is that if there is no affordnace to
16851 // Returns which broadcast queue the app is the current [or imminent] receiver
16852 // on, or 'null' if the app is not an active broadcast recipient.
16960 // below foreground, so it is not worth doing work for it.
16970 // is currently showing UI.
16998 // The last app on the list is the foreground app.
17011 // An app that is currently receiving a broadcast also
17021 // An app that is currently executing a service callback also
17030 // As far as we know the process is empty. We may change our mind later.
17083 // or empty depending on whether the activity is finishing. We do
17107 // The user is aware of this app, so make it visible.
17114 // The user is aware of this app, so make it visible.
17139 // This process is hosting what we currently consider to be the
17195 for (int is = app.services.size()-1;
17196 is >= 0 && (adj > ProcessList.FOREGROUND_APP_ADJ
17199 is--) {
17200 ServiceRecord s = app.services.valueAt(is);
17210 // debug and understand what is going on.
17226 // state, still have some text describing what it is doing
17248 // Binding to ourself is not interesting.
17257 // If the other app is cached for any reason, for purposes here
17270 // debug and understand what is going on.
17282 // LRU list if there is no other reason to keep
17284 // to help debug and undertand what is going on.
17294 // the process that is binding to it is less
17333 // top state as well, but only if there is not another
17334 // reason for it to be running. Being on the top is a
17336 // for the current top app. If the process is already
17338 // is more important to continue considering it to be
17413 // Being our own client is not interesting.
17419 // If the other app is cached for any reason, for purposes here
17443 // top state as well, but only if there is not another
17444 // reason for it to be running. Being on the top is a
17446 // for the current top app. If the process is already
17448 // is more important to continue considering it to be
17469 // dependencies, ensure that its adjustment is at least
17486 // A client of one of our services or providers is in the top state. We
17490 // is top (states that tend to be longer-term) and otherwise allow it to go
17501 // Otherwise, top is a better choice, so take it.
17509 // This is a cached process, but with client activities. Mark it so.
17513 // This is a cached process, but somebody wants us to treat it like it has
17528 // is large we want to force it down since we would prefer to
17941 // running test... the problem is that this tends to collect
17942 // the data right when a process is transitioning between process
17977 // This app is no longer something we consider important enough to allow to
17980 // it is not behaving well.
18139 // This is the desired cached adjusment we want to tell it to use.
18140 // If our app is currently cached, we know it, and that is it. Otherwise,
18231 // This process is a cached process holding activities...
18256 // state is still as a service), which is what we want.
18308 // If this is an isolated process, and there are no
18309 // services running in it, then the process is no longer
18311 // definition not re-use the same process again, and it is
18329 // are managing to keep around is less than half the maximum we desire;
18347 // down if we are in a state where that is allowed, *and* the total number of processes
18444 // If this application is now in the background and it
18573 throw new SecurityException("Only SIGNAL_USR1 is allowed");
18805 * user switch happens or when a new related user is started in the
18908 // If the user we are switching to is not currently started, then
18938 // Make sure user is in the started state. If it is currently
18957 // Note that this is on the same handler as scheduling of broadcasts,
18958 // which is important because it needs to go first.
19204 // This is a user to be stopped.
19276 // This user is already stopping, doesn't count.
19286 // This is a user to be stopped.
19322 // User is not started, nothing to do... but we do need to
19350 // once that is done send a final ACTION_SHUTDOWN and then
19357 // This is the result receiver for the final shutdown broadcast.
19365 // This is the result receiver for the initial stopping broadcast.