/** * Interface to global information about an application environment.  This is * an abstract class whose implementation is provided by * the Android system.  It * allows access to application-specific resources and classes, as well as * up-calls for application-level operations such as launching activities, * broadcasting and receiving intents, etc. */public abstract class Context {    /**     * File creation mode: the default mode, where the created file can only     * be accessed by the calling application (or all applications sharing the     * same user ID).     * @see #MODE_WORLD_READABLE     * @see #MODE_WORLD_WRITEABLE     */。。。。。。    /**     * Launch a new activity.  You will not receive any information about when     * the activity exits.     *     * <p>Note that if this method is being called from outside of an     * {@link android.app.Activity} Context, then the Intent must include     * the {@link Intent#FLAG_ACTIVITY_NEW_TASK} launch flag.  This is because,     * without being started from an existing Activity, there is no existing     * task in which to place the new activity and thus it needs to be placed     * in its own separate task.     *     * <p>This method throws {@link ActivityNotFoundException}     * if there was no Activity found to run the given Intent.     *     * @param intent The description of the activity to start.     *     * @throws ActivityNotFoundException     *     * @see PackageManager#resolveActivity     */    public abstract void startActivity(Intent intent);......

/** * Common implementation of Context API, which provides the base * context object for Activity and other application components. */class ContextImpl extends Context {    private final static String TAG = "ApplicationContext";    private final static boolean DEBUG = false;    private static final HashMap<String, SharedPreferencesImpl> sSharedPrefs =            new HashMap<String, SharedPreferencesImpl>();。。。。。。    @Override    public void startActivity(Intent intent) {        if ((intent.getFlags()&Intent.FLAG_ACTIVITY_NEW_TASK) == 0) {            throw new AndroidRuntimeException(                    "Calling startActivity() from outside of an Activity "                    + " context requires the FLAG_ACTIVITY_NEW_TASK flag."                    + " Is this really what you want?");        }        mMainThread.getInstrumentation().execStartActivity(            getOuterContext(), mMainThread.getApplicationThread(), null,            (Activity)null, intent, -1);    }.....

/** * Proxying implementation of Context that simply delegates all of its calls to * another Context.  Can be subclassed to modify behavior without changing * the original Context. */public class ContextWrapper extends Context {    Context mBase;    public ContextWrapper(Context base) {        mBase = base;    }

 @Override    public void startActivity(Intent intent) {        mBase.startActivity(intent);    }

public class Activity extends ContextThemeWrapper        implements LayoutInflater.Factory2,        Window.Callback, KeyEvent.Callback,        OnCreateContextMenuListener, ComponentCallbacks2 {    private static final String TAG = "Activity";    /** Standard activity result: operation canceled. */    public static final int RESULT_CANCELED    = 0;    /** Standard activity result: operation succeeded. */    public static final int RESULT_OK           = -1;    /** Start of user-defined activity results. */    public static final int RESULT_FIRST_USER   = 1;    private static final String WINDOW_HIERARCHY_TAG = "android:viewHierarchyState";    private static final String FRAGMENTS_TAG = "android:fragments";    private static final String SAVED_DIALOG_IDS_KEY = "android:savedDialogIds";    private static final String SAVED_DIALOGS_TAG = "android:savedDialogs";    private static final String SAVED_DIALOG_KEY_PREFIX = "android:dialog_";    private static final String SAVED_DIALOG_ARGS_KEY_PREFIX = "android:dialog_args_";    private static class ManagedDialog {        Dialog mDialog;        Bundle mArgs;    }    private SparseArray<ManagedDialog> mManagedDialogs;    // set by the thread after the constructor and before onCreate(Bundle savedInstanceState) is called.    private Instrumentation mInstrumentation;    private IBinder mToken;    private int mIdent;    /*package*/ String mEmbeddedID;    private Application mApplication;    /*package*/ Intent mIntent;    private ComponentName mComponent;    /*package*/ ActivityInfo mActivityInfo;    /*package*/ ActivityThread mMainThread;    Activity mParent;    boolean mCalled;    boolean mCheckedForLoaderManager;    boolean mLoadersStarted;    /*package*/ boolean mResumed;    private boolean mStopped;    boolean mFinished;    boolean mStartedActivity;    /** true if the activity is going through a transient pause */    /*package*/ boolean mTemporaryPause = false;    /** true if the activity is being destroyed in order to recreate it with a new configuration */    /*package*/ boolean mChangingConfigurations = false;    /*package*/ int mConfigChangeFlags;    /*package*/ Configuration mCurrentConfig;    private SearchManager mSearchManager;    private MenuInflater mMenuInflater;    static final class NonConfigurationInstances {        Object activity;        HashMap<String, Object> children;        ArrayList<Fragment> fragments;        SparseArray<LoaderManagerImpl> loaders;    }    /* package */ NonConfigurationInstances mLastNonConfigurationInstances;        private Window mWindow;    private WindowManager mWindowManager;    /*package*/ View mDecor = null;    /*package*/ boolean mWindowAdded = false;    /*package*/ boolean mVisibleFromServer = false;    /*package*/ boolean mVisibleFromClient = true;    /*package*/ ActionBarImpl mActionBar = null;    private CharSequence mTitle;    private int mTitleColor = 0;    final FragmentManagerImpl mFragments = new FragmentManagerImpl();        SparseArray<LoaderManagerImpl> mAllLoaderManagers;    LoaderManagerImpl mLoaderManager;        private static final class ManagedCursor {        ManagedCursor(Cursor cursor) {            mCursor = cursor;            mReleased = false;            mUpdated = false;        }        private final Cursor mCursor;        private boolean mReleased;        private boolean mUpdated;    }    private final ArrayList<ManagedCursor> mManagedCursors =        new ArrayList<ManagedCursor>();    // protected by synchronized (this)     int mResultCode = RESULT_CANCELED;    Intent mResultData = null;    private boolean mTitleReady = false;    private int mDefaultKeyMode = DEFAULT_KEYS_DISABLE;    private SpannableStringBuilder mDefaultKeySsb = null;        protected static final int[] FOCUSED_STATE_SET = {com.android.internal.R.attr.state_focused};    private final Object mInstanceTracker = StrictMode.trackActivity(this);    private Thread mUiThread;    final Handler mHandler = new Handler();    /** Return the intent that started this activity. */    public Intent getIntent() {        return mIntent;    }    /**      * Change the intent returned by {@link #getIntent}.  This holds a      * reference to the given intent; it does not copy it.  Often used in      * conjunction with {@link #onNewIntent}.      *       * @param newIntent The new Intent object to return from getIntent      *      * @see #getIntent     * @see #onNewIntent     */     public void setIntent(Intent newIntent) {        mIntent = newIntent;    }    /** Return the application that owns this activity. */    public final Application getApplication() {        return mApplication;    }    /** Is this activity embedded inside of another activity? */    public final boolean isChild() {        return mParent != null;    }        /** Return the parent activity if this view is an embedded child. */    public final Activity getParent() {        return mParent;    }    /** Retrieve the window manager for showing custom windows. */    public WindowManager getWindowManager() {        return mWindowManager;    }    /**     * Retrieve the current {@link android.view.Window} for the activity.     * This can be used to directly access parts of the Window API that     * are not available through Activity/Screen.     *      * @return Window The current window, or null if the activity is not     *         visual.     */

public abstract class Service extends ContextWrapper implements ComponentCallbacks2 {    private static final String TAG = "Service";    public Service() {        super(null);    }    /** Return the application that owns this service. */    public final Application getApplication() {        return mApplication;    }    /**     * Called by the system when the service is first created.  Do not call this method directly.     */    public void onCreate() {    }    /**     * @deprecated Implement {@link #onStartCommand(Intent, int, int)} instead.     */    @Deprecated    public void onStart(Intent intent, int startId) {    }    /**     * Bits returned by {@link #onStartCommand} describing how to continue     * the service if it is killed.  May be {@link #START_STICKY},     * {@link #START_NOT_STICKY}, {@link #START_REDELIVER_INTENT},     * or {@link #START_STICKY_COMPATIBILITY}.     */    public static final int START_CONTINUATION_MASK = 0xf;        /**     * Constant to return from {@link #onStartCommand}: compatibility     * version of {@link #START_STICKY} that does not guarantee that     * {@link #onStartCommand} will be called again after being killed.     */    public static final int START_STICKY_COMPATIBILITY = 0;        /**     * Constant to return from {@link #onStartCommand}: if this service‘s     * process is killed while it is started (after returning from     * {@link #onStartCommand}), then leave it in the started state but     * don‘t retain this delivered intent.  Later the system will try to     * re-create the service.  Because it is in the started state, it will     * guarantee to call {@link #onStartCommand} after creating the new     * service instance; if there are not any pending start commands to be     * delivered to the service, it will be called with a null intent     * object, so you must take care to check for this.     *      * <p>This mode makes sense for things that will be explicitly started     * and stopped to run for arbitrary periods of time, such as a service     * performing background music playback.     */    public static final int START_STICKY = 1;        /**     * Constant to return from {@link #onStartCommand}: if this service‘s     * process is killed while it is started (after returning from     * {@link #onStartCommand}), and there are no new start intents to     * deliver to it, then take the service out of the started state and     * don‘t recreate until a future explicit call to     * {@link Context#startService Context.startService(Intent)}.  The     * service will not receive a {@link #onStartCommand(Intent, int, int)}     * call with a null Intent because it will not be re-started if there     * are no pending Intents to deliver.     * 。。。。。。

public class Application extends ContextWrapper implements ComponentCallbacks2 {    private ArrayList<ComponentCallbacks> mComponentCallbacks =            new ArrayList<ComponentCallbacks>();    private ArrayList<ActivityLifecycleCallbacks> mActivityLifecycleCallbacks =            new ArrayList<ActivityLifecycleCallbacks>();    /** @hide */    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);    }    public Application() {        super(null);    }