| /* |
| * 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 android.app; |
| |
| import android.annotation.CallSuper; |
| import android.annotation.UnsupportedAppUsage; |
| import android.content.ComponentCallbacks; |
| import android.content.ComponentCallbacks2; |
| import android.content.Context; |
| import android.content.ContextWrapper; |
| import android.content.Intent; |
| import android.content.res.Configuration; |
| import android.os.Bundle; |
| import android.util.Log; |
| import android.view.autofill.AutofillManager; |
| |
| import java.util.ArrayList; |
| |
| /** |
| * Base class for maintaining global application state. You can provide your own |
| * implementation by creating a subclass and specifying the fully-qualified name |
| * of this subclass as the <code>"android:name"</code> attribute in your |
| * AndroidManifest.xml's <code><application></code> tag. The Application |
| * class, or your subclass of the Application class, is instantiated before any |
| * other class when the process for your application/package is created. |
| * |
| * <p class="note"><strong>Note: </strong>There is normally no need to subclass |
| * Application. In most situations, static singletons can provide the same |
| * functionality in a more modular way. If your singleton needs a global |
| * context (for example to register broadcast receivers), include |
| * {@link android.content.Context#getApplicationContext() Context.getApplicationContext()} |
| * as a {@link android.content.Context} argument when invoking your singleton's |
| * <code>getInstance()</code> method. |
| * </p> |
| */ |
| public class Application extends ContextWrapper implements ComponentCallbacks2 { |
| private static final String TAG = "Application"; |
| @UnsupportedAppUsage |
| private ArrayList<ComponentCallbacks> mComponentCallbacks = |
| new ArrayList<ComponentCallbacks>(); |
| @UnsupportedAppUsage |
| private ArrayList<ActivityLifecycleCallbacks> mActivityLifecycleCallbacks = |
| new ArrayList<ActivityLifecycleCallbacks>(); |
| @UnsupportedAppUsage |
| private ArrayList<OnProvideAssistDataListener> mAssistCallbacks = null; |
| |
| /** @hide */ |
| @UnsupportedAppUsage |
| public LoadedApk mLoadedApk; |
| |
| public interface ActivityLifecycleCallbacks { |
| void onActivityCreated(Activity activity, Bundle savedInstanceState); |
| void onActivityStarted(Activity activity); |
| void onActivityResumed(Activity activity); |
| void onActivityPaused(Activity activity); |
| void onActivityStopped(Activity activity); |
| void onActivitySaveInstanceState(Activity activity, Bundle outState); |
| void onActivityDestroyed(Activity activity); |
| } |
| |
| /** |
| * Callback interface for use with {@link Application#registerOnProvideAssistDataListener} |
| * and {@link Application#unregisterOnProvideAssistDataListener}. |
| */ |
| public interface OnProvideAssistDataListener { |
| /** |
| * This is called when the user is requesting an assist, to build a full |
| * {@link Intent#ACTION_ASSIST} Intent with all of the context of the current |
| * application. You can override this method to place into the bundle anything |
| * you would like to appear in the {@link Intent#EXTRA_ASSIST_CONTEXT} part |
| * of the assist Intent. |
| */ |
| public void onProvideAssistData(Activity activity, Bundle data); |
| } |
| |
| public Application() { |
| super(null); |
| } |
| |
| /** |
| * Called when the application is starting, before any activity, service, |
| * or receiver objects (excluding content providers) have been created. |
| * |
| * <p>Implementations should be as quick as possible (for example using |
| * lazy initialization of state) since the time spent in this function |
| * directly impacts the performance of starting the first activity, |
| * service, or receiver in a process.</p> |
| * |
| * <p>If you override this method, be sure to call {@code super.onCreate()}.</p> |
| * |
| * <p class="note">Be aware that direct boot may also affect callback order on |
| * Android {@link android.os.Build.VERSION_CODES#N} and later devices. |
| * Until the user unlocks the device, only direct boot aware components are |
| * allowed to run. You should consider that all direct boot unaware |
| * components, including such {@link android.content.ContentProvider}, are |
| * disabled until user unlock happens, especially when component callback |
| * order matters.</p> |
| */ |
| @CallSuper |
| public void onCreate() { |
| } |
| |
| /** |
| * This method is for use in emulated process environments. It will |
| * never be called on a production Android device, where processes are |
| * removed by simply killing them; no user code (including this callback) |
| * is executed when doing so. |
| */ |
| @CallSuper |
| public void onTerminate() { |
| } |
| |
| @CallSuper |
| public void onConfigurationChanged(Configuration newConfig) { |
| Object[] callbacks = collectComponentCallbacks(); |
| if (callbacks != null) { |
| for (int i=0; i<callbacks.length; i++) { |
| ((ComponentCallbacks)callbacks[i]).onConfigurationChanged(newConfig); |
| } |
| } |
| } |
| |
| @CallSuper |
| public void onLowMemory() { |
| Object[] callbacks = collectComponentCallbacks(); |
| if (callbacks != null) { |
| for (int i=0; i<callbacks.length; i++) { |
| ((ComponentCallbacks)callbacks[i]).onLowMemory(); |
| } |
| } |
| } |
| |
| @CallSuper |
| public void onTrimMemory(int level) { |
| Object[] callbacks = collectComponentCallbacks(); |
| if (callbacks != null) { |
| for (int i=0; i<callbacks.length; i++) { |
| Object c = callbacks[i]; |
| if (c instanceof ComponentCallbacks2) { |
| ((ComponentCallbacks2)c).onTrimMemory(level); |
| } |
| } |
| } |
| } |
| |
| public void registerComponentCallbacks(ComponentCallbacks callback) { |
| synchronized (mComponentCallbacks) { |
| mComponentCallbacks.add(callback); |
| } |
| } |
| |
| public void unregisterComponentCallbacks(ComponentCallbacks callback) { |
| synchronized (mComponentCallbacks) { |
| mComponentCallbacks.remove(callback); |
| } |
| } |
| |
| public void registerActivityLifecycleCallbacks(ActivityLifecycleCallbacks callback) { |
| synchronized (mActivityLifecycleCallbacks) { |
| mActivityLifecycleCallbacks.add(callback); |
| } |
| } |
| |
| public void unregisterActivityLifecycleCallbacks(ActivityLifecycleCallbacks callback) { |
| synchronized (mActivityLifecycleCallbacks) { |
| mActivityLifecycleCallbacks.remove(callback); |
| } |
| } |
| |
| public void registerOnProvideAssistDataListener(OnProvideAssistDataListener callback) { |
| synchronized (this) { |
| if (mAssistCallbacks == null) { |
| mAssistCallbacks = new ArrayList<OnProvideAssistDataListener>(); |
| } |
| mAssistCallbacks.add(callback); |
| } |
| } |
| |
| public void unregisterOnProvideAssistDataListener(OnProvideAssistDataListener callback) { |
| synchronized (this) { |
| if (mAssistCallbacks != null) { |
| mAssistCallbacks.remove(callback); |
| } |
| } |
| } |
| |
| /** |
| * Returns the name of the current process. A package's default process name |
| * is the same as its package name. Non-default processes will look like |
| * "$PACKAGE_NAME:$NAME", where $NAME corresponds to an android:process |
| * attribute within AndroidManifest.xml. |
| */ |
| public static String getProcessName() { |
| return ActivityThread.currentProcessName(); |
| } |
| |
| // ------------------ Internal API ------------------ |
| |
| /** |
| * @hide |
| */ |
| @UnsupportedAppUsage |
| /* package */ final void attach(Context context) { |
| attachBaseContext(context); |
| mLoadedApk = ContextImpl.getImpl(context).mPackageInfo; |
| } |
| |
| @UnsupportedAppUsage |
| /* package */ void dispatchActivityCreated(Activity activity, Bundle savedInstanceState) { |
| Object[] callbacks = collectActivityLifecycleCallbacks(); |
| if (callbacks != null) { |
| for (int i=0; i<callbacks.length; i++) { |
| ((ActivityLifecycleCallbacks)callbacks[i]).onActivityCreated(activity, |
| savedInstanceState); |
| } |
| } |
| } |
| |
| @UnsupportedAppUsage |
| /* package */ void dispatchActivityStarted(Activity activity) { |
| Object[] callbacks = collectActivityLifecycleCallbacks(); |
| if (callbacks != null) { |
| for (int i=0; i<callbacks.length; i++) { |
| ((ActivityLifecycleCallbacks)callbacks[i]).onActivityStarted(activity); |
| } |
| } |
| } |
| |
| @UnsupportedAppUsage |
| /* package */ void dispatchActivityResumed(Activity activity) { |
| Object[] callbacks = collectActivityLifecycleCallbacks(); |
| if (callbacks != null) { |
| for (int i=0; i<callbacks.length; i++) { |
| ((ActivityLifecycleCallbacks)callbacks[i]).onActivityResumed(activity); |
| } |
| } |
| } |
| |
| @UnsupportedAppUsage |
| /* package */ void dispatchActivityPaused(Activity activity) { |
| Object[] callbacks = collectActivityLifecycleCallbacks(); |
| if (callbacks != null) { |
| for (int i=0; i<callbacks.length; i++) { |
| ((ActivityLifecycleCallbacks)callbacks[i]).onActivityPaused(activity); |
| } |
| } |
| } |
| |
| @UnsupportedAppUsage |
| /* package */ void dispatchActivityStopped(Activity activity) { |
| Object[] callbacks = collectActivityLifecycleCallbacks(); |
| if (callbacks != null) { |
| for (int i=0; i<callbacks.length; i++) { |
| ((ActivityLifecycleCallbacks)callbacks[i]).onActivityStopped(activity); |
| } |
| } |
| } |
| |
| @UnsupportedAppUsage |
| /* package */ void dispatchActivitySaveInstanceState(Activity activity, Bundle outState) { |
| Object[] callbacks = collectActivityLifecycleCallbacks(); |
| if (callbacks != null) { |
| for (int i=0; i<callbacks.length; i++) { |
| ((ActivityLifecycleCallbacks)callbacks[i]).onActivitySaveInstanceState(activity, |
| outState); |
| } |
| } |
| } |
| |
| @UnsupportedAppUsage |
| /* package */ void dispatchActivityDestroyed(Activity activity) { |
| Object[] callbacks = collectActivityLifecycleCallbacks(); |
| if (callbacks != null) { |
| for (int i=0; i<callbacks.length; i++) { |
| ((ActivityLifecycleCallbacks)callbacks[i]).onActivityDestroyed(activity); |
| } |
| } |
| } |
| |
| private Object[] collectComponentCallbacks() { |
| Object[] callbacks = null; |
| synchronized (mComponentCallbacks) { |
| if (mComponentCallbacks.size() > 0) { |
| callbacks = mComponentCallbacks.toArray(); |
| } |
| } |
| return callbacks; |
| } |
| |
| @UnsupportedAppUsage |
| private Object[] collectActivityLifecycleCallbacks() { |
| Object[] callbacks = null; |
| synchronized (mActivityLifecycleCallbacks) { |
| if (mActivityLifecycleCallbacks.size() > 0) { |
| callbacks = mActivityLifecycleCallbacks.toArray(); |
| } |
| } |
| return callbacks; |
| } |
| |
| /* package */ void dispatchOnProvideAssistData(Activity activity, Bundle data) { |
| Object[] callbacks; |
| synchronized (this) { |
| if (mAssistCallbacks == null) { |
| return; |
| } |
| callbacks = mAssistCallbacks.toArray(); |
| } |
| if (callbacks != null) { |
| for (int i=0; i<callbacks.length; i++) { |
| ((OnProvideAssistDataListener)callbacks[i]).onProvideAssistData(activity, data); |
| } |
| } |
| } |
| |
| /** @hide */ |
| @Override |
| public AutofillManager.AutofillClient getAutofillClient() { |
| final AutofillManager.AutofillClient client = super.getAutofillClient(); |
| if (client != null) { |
| return client; |
| } |
| if (android.view.autofill.Helper.sVerbose) { |
| Log.v(TAG, "getAutofillClient(): null on super, trying to find activity thread"); |
| } |
| // Okay, ppl use the application context when they should not. This breaks |
| // autofill among other things. We pick the focused activity since autofill |
| // interacts only with the currently focused activity and we need the fill |
| // client only if a call comes from the focused activity. Sigh... |
| final ActivityThread activityThread = ActivityThread.currentActivityThread(); |
| if (activityThread == null) { |
| return null; |
| } |
| final int activityCount = activityThread.mActivities.size(); |
| for (int i = 0; i < activityCount; i++) { |
| final ActivityThread.ActivityClientRecord record = |
| activityThread.mActivities.valueAt(i); |
| if (record == null) { |
| continue; |
| } |
| final Activity activity = record.activity; |
| if (activity == null) { |
| continue; |
| } |
| if (activity.getWindow().getDecorView().hasFocus()) { |
| if (android.view.autofill.Helper.sVerbose) { |
| Log.v(TAG, "getAutofillClient(): found activity for " + this + ": " + activity); |
| } |
| return activity; |
| } |
| } |
| if (android.view.autofill.Helper.sVerbose) { |
| Log.v(TAG, "getAutofillClient(): none of the " + activityCount + " activities on " |
| + this + " have focus"); |
| } |
| return null; |
| } |
| } |