7.Android内核 创建窗口的过程（二）

创建应用窗口

1.每个应用类窗口都对应一个Activity对象，所以，创建应用类窗口首先需要创建一个Activity对象。

当AmS决定启动某个Activity时，会通知客户端进程，而每个客户端进程都对应一个ActivityThread

类，任何Activity都必须隶属于一个应用程序，因此，启动Activity的任务最终由ActivityThread 完成。

启动某个Activity的代码本质是构造一个Activity对象，看看ActivityThread里的

performLaunchActivity()方法源码：

    private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
        // System.out.println("##### [" + System.currentTimeMillis() + "] ActivityThread.performLaunchActivity(" + r + ")");

        ActivityInfo aInfo = r.activityInfo;
        if (r.packageInfo == null) {
            r.packageInfo = getPackageInfo(aInfo.applicationInfo, r.compatInfo,
                    Context.CONTEXT_INCLUDE_CODE);
        }

        ComponentName component = r.intent.getComponent();
        if (component == null) {
            component = r.intent.resolveActivity(
                mInitialApplication.getPackageManager());
            r.intent.setComponent(component);
        }

        if (r.activityInfo.targetActivity != null) {
            component = new ComponentName(r.activityInfo.packageName,
                    r.activityInfo.targetActivity);
        }

        Activity activity = null;
        try {
            java.lang.ClassLoader cl = r.packageInfo.getClassLoader();
            activity = mInstrumentation.newActivity(
                    cl, component.getClassName(), r.intent);
            StrictMode.incrementExpectedActivityCount(activity.getClass());
            r.intent.setExtrasClassLoader(cl);
            r.intent.prepareToEnterProcess();
            if (r.state != null) {
                r.state.setClassLoader(cl);
            }
        } catch (Exception e) {
            if (!mInstrumentation.onException(activity, e)) {
                throw new RuntimeException(
                    "Unable to instantiate activity " + component
                    + ": " + e.toString(), e);
            }
        }

        try {
            Application app = r.packageInfo.makeApplication(false, mInstrumentation);

            if (localLOGV) Slog.v(TAG, "Performing launch of " + r);
            if (localLOGV) Slog.v(
                    TAG, r + ": app=" + app
                    + ", appName=" + app.getPackageName()
                    + ", pkg=" + r.packageInfo.getPackageName()
                    + ", comp=" + r.intent.getComponent().toShortString()
                    + ", dir=" + r.packageInfo.getAppDir());

            if (activity != null) {
                Context appContext = createBaseContextForActivity(r, activity);
                CharSequence title = r.activityInfo.loadLabel(appContext.getPackageManager());
                Configuration config = new Configuration(mCompatConfiguration);
                if (DEBUG_CONFIGURATION) Slog.v(TAG, "Launching activity "
                        + r.activityInfo.name + " with config " + config);
                activity.attach(appContext, this, getInstrumentation(), r.token,
                        r.ident, app, r.intent, r.activityInfo, title, r.parent,
                        r.embeddedID, r.lastNonConfigurationInstances, config,
                        r.voiceInteractor);

                if (customIntent != null) {
                    activity.mIntent = customIntent;
                }
                r.lastNonConfigurationInstances = null;
                activity.mStartedActivity = false;
                int theme = r.activityInfo.getThemeResource();
                if (theme != 0) {
                    activity.setTheme(theme);
                }

                activity.mCalled = false;
                if (r.isPersistable()) {
                    mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
                } else {
                    mInstrumentation.callActivityOnCreate(activity, r.state);
                }
                if (!activity.mCalled) {
                    throw new SuperNotCalledException(
                        "Activity " + r.intent.getComponent().toShortString() +
                        " did not call through to super.onCreate()");
                }
                r.activity = activity;
                r.stopped = true;
                if (!r.activity.mFinished) {
                    activity.performStart();
                    r.stopped = false;
                }
                if (!r.activity.mFinished) {
                    if (r.isPersistable()) {
                        if (r.state != null || r.persistentState != null) {
                            mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state,
                                    r.persistentState);
                        }
                    } else if (r.state != null) {
                        mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state);
                    }
                }
                if (!r.activity.mFinished) {
                    activity.mCalled = false;
                    if (r.isPersistable()) {
                        mInstrumentation.callActivityOnPostCreate(activity, r.state,
                                r.persistentState);
                    } else {
                        mInstrumentation.callActivityOnPostCreate(activity, r.state);
                    }
                    if (!activity.mCalled) {
                        throw new SuperNotCalledException(
                            "Activity " + r.intent.getComponent().toShortString() +
                            " did not call through to super.onPostCreate()");
                    }
                }
            }
            r.paused = true;

            mActivities.put(r.token, r);

        } catch (SuperNotCalledException e) {
            throw e;

        } catch (Exception e) {
            if (!mInstrumentation.onException(activity, e)) {
                throw new RuntimeException(
                    "Unable to start activity " + component
                    + ": " + e.toString(), e);
            }
        }

        return activity;
    }

以上，使用了ClassLoader从程序文件中装载指定的Activity对应的class文件。

2.构造好指定的Activity对象后，接着调用Activity的attach()方法：

   attach()的作用是为刚刚构造好的Activity设置内部变量，这些变量是以后进行Activity调度所必

   须的。这些重要的变量包含：

        appContext：该对象将作为Activity的BaseContext。Activity的本质就是一个Context，而同时Activity

        有时继承于ContextWrapper，该类需要一个真正的Context对象，而这就是appContext，该对象使用

        new ContextImpl()方法创建。

        this：这就是指的是当前的ActivityThread对象，Activity对象内部可能会需要主程序的引用。

        r.token：r是一个ActivityRecord对象，其内部变量token的含义是AmS中的一个HistoryRecord对象。

        r.parent：一个Activity可以有一个父Activity，这种理念是为了允许把一个Activity嵌入到另一个Activity内部

        执行。在应用程序使用时，常用ActivityGroup类，而ActivityGroup功能的内部支持的正是该变量。

3.在attach()方法内部，除了进行重要变量赋值外，另一件重要的事情就是为该Activity创建Window对

象，这是通过调用PolicyManager的静态方法makeNewWindow()完成的。

PolicyManager会根据com.android.intemal.policy.impLPolicy的配置创建不同产品类型的窗口。这仅

仅是一种程序设计的灵活性，其代码归根到底是创建了一个PhoneWindow对象而已。当前的Framework

中仅仅定义有两种Window的具体实现，一种是MidWindow类，另一种是PhoneWindow类，而前者基本

上没有使用。从名称不难看出，Android的设计之初所设想的两种应用，其中一种是手机，另一种是便携上

网设备（Mobile Internet Device)。

***创建好Window对象后，将其赋值给Activity的内部变量mWindow，并设置该Window的

Callback接口为当前的Activity对象，这就是为什么用户消息能够传递到Activity中的原因。那么

我们来看一看Activity中的attach()方法源码：

    final void attach(Context context, ActivityThread aThread,
            Instrumentation instr, IBinder token, int ident,
            Application application, Intent intent, ActivityInfo info,
            CharSequence title, Activity parent, String id,
            NonConfigurationInstances lastNonConfigurationInstances,
            Configuration config, IVoiceInteractor voiceInteractor) {
        attachBaseContext(context);

        mFragments.attachActivity(this, mContainer, null);

        mWindow = PolicyManager.makeNewWindow(this);
        mWindow.setCallback(this);
        mWindow.setOnWindowDismissedCallback(this);
        mWindow.getLayoutInflater().setPrivateFactory(this);
        if (info.softInputMode != WindowManager.LayoutParams.SOFT_INPUT_STATE_UNSPECIFIED) {
            mWindow.setSoftInputMode(info.softInputMode);
        }
        if (info.uiOptions != 0) {
            mWindow.setUiOptions(info.uiOptions);
        }
        mUiThread = Thread.currentThread();

        mMainThread = aThread;
        mInstrumentation = instr;
        mToken = token;
        mIdent = ident;
        mApplication = application;
        mIntent = intent;
        mComponent = intent.getComponent();
        mActivityInfo = info;
        mTitle = title;
        mParent = parent;
        mEmbeddedID = id;
        mLastNonConfigurationInstances = lastNonConfigurationInstances;
        if (voiceInteractor != null) {
            if (lastNonConfigurationInstances != null) {
                mVoiceInteractor = lastNonConfigurationInstances.voiceInteractor;
            } else {
                mVoiceInteractor = new VoiceInteractor(voiceInteractor, this, this,
                        Looper.myLooper());
            }
        }

        mWindow.setWindowManager(
                (WindowManager)context.getSystemService(Context.WINDOW_SERVICE),
                mToken, mComponent.flattenToString(),
                (info.flags & ActivityInfo.FLAG_HARDWARE_ACCELERATED) != 0);
        if (mParent != null) {
            mWindow.setContainer(mParent.getWindow());
        }
        mWindowManager = mWindow.getWindowManager();
        mCurrentConfig = config;
    }

4.创建好Window对象后，需要给Window对象中的mWindowMananger变量赋值，该变量的类型

是WindowManager类。每一个Window内部都有一个WindowManager对象，WindowManager

类是一个重量级的类，如果每一个Window中都包含一个WindowManager的引用会不会是一种浪费?

但是实际上，WindowManager类仅仅是一个interface类而已，真正实现该接口的有两个类，一个是

Window.LocalWindowManager子类，另一个是WindowManagerImpl类。LocalWindowManager

仅仅是一个壳而已，这就跟ContextWrapper类似，本身虽然提供了WindowManager接口的全部功

能，然而真正实现这些功能的却是壳里面的WindowManager对象，这就是WindowManagerImpl类。

也正是因为以上关系，所以，每个Window内部才包含一个WindowManager的壳以便进行其他操

作，在Activity里的attach()给mWindowManager赋值了：

        mWindow.setWindowManager(
                (WindowManager)context.getSystemService(Context.WINDOW_SERVICE),
                mToken, mComponent.flattenToString(),
                (info.flags & ActivityInfo.FLAG_HARDWARE_ACCELERATED) != 0);
        if (mParent != null) {
            mWindow.setContainer(mParent.getWindow());
        }
        mWindowManager = mWindow.getWindowManager();

这里调用了Window.setWindowManager方法去设置该Activity对应的WindowManager，那我们

接着来看看Window.setWindowManager的源代码：

    /**
     * Set the window manager for use by this Window to, for example,
     * display panels.  This is <em>not</em> used for displaying the
     * Window itself -- that must be done by the client.
     *
     * @param wm The window manager for adding new windows.
     */
    public void setWindowManager(WindowManager wm, IBinder appToken, String appName,
            boolean hardwareAccelerated) {
        mAppToken = appToken;
        mAppName = appName;
        mHardwareAccelerated = hardwareAccelerated
                || SystemProperties.getBoolean(PROPERTY_HARDWARE_UI, false);
        if (wm == null) {
            wm = (WindowManager)mContext.getSystemService(Context.WINDOW_SERVICE);
        }
        mWindowManager = ((WindowManagerImpl)wm).createLocalWindowManager(this);
    }

结合以上两段源代码来分析，setWindowManager()方法的第一个参数为

(WindowManager)context.getSystemService(Context.WINDOW_SERVICE)，显而易见的

是，这里直接通过Context.getSystemService(String systemName)的方式取得了

WindowManager；第二个参数是mToken，这正是AmS中Activity里对应的HistoryRecord的

Binder引用，该变量将会作为Window中的mAppToken的值被保存下来。

到了Window.setWindowManager中，还进行了一次if(wm==null)的判断，如果为空，则

继续用Context.getSystemService(String systemName)的方式再取一次WindowManager

但是通过mWindowManager = ((WindowManagerImpl)wm).createLocalWindowManager(this)

可以知道，传进来的无论是否是null的WindowManager引用，其实都是备胎，都会转换成

WindowManagerImpl然后再去构造一个LocalWindowManager对象，最后保存在

mWindowManager中。

*** 所以每一个Activity内部都有一个mWindowManager对象，这就是LocalWindowManager，和

Window类中的同名变量相同。

5.配置好了Activity和Window对象后，接下来就需要给该窗口添加真正的显示元素View或者

ViewGroup。这是从Activity.performLaunchActivity()内部调用callActivityOnCreate()开始的 

并会辗转到我们熟悉的Activity.onCreate()中。

我们都可以知道给Activity添加界面是在onCreate()方法中调用setContentView()方法，而该方

法实际上却又调用到了其所对应的Window对象的setContentView方法，对此我们可以看看

Activity.setContentView()的源代码：

    /**
     * Set the activity content from a layout resource.  The resource will be
     * inflated, adding all top-level views to the activity.
     *
     * @param layoutResID Resource ID to be inflated.
     *
     * @see #setContentView(android.view.View)
     * @see #setContentView(android.view.View, android.view.ViewGroup.LayoutParams)
     */
    public void setContentView(int layoutResID) {
        getWindow().setContentView(layoutResID);
        initWindowDecorActionBar();
    }

这里，可以看到我们传进去的Layout对应的Id又被对应的Window拿去执行了setContentView了。

6.PhoneWindow.setContentView()源代码:

    @Override
    public void setContentView(int layoutResID) {
        if (mContentParent == null) {
            installDecor();
        } else {
            mContentParent.removeAllViews();
        }
        mLayoutInflater.inflate(layoutResID, mContentParent);
        final Callback cb = getCallback();
        if (cb != null) {
            cb.onContentChanged();
        }
    }

首先调用installDecor()方法为Window类安装一个窗口装饰，所谓的窗口修饰就是界面上常见的

标题栏，程序中指定的layout.xml界面将被包含在窗口修饰中，称为窗口内容。窗口修饰也是一个

ViewGroup，窗口修饰及其内部的窗口内容就是我们所说的窗口，或者叫做Window的界面。

Framework中定义了多种窗口装饰，installDecor()源代码：

    private void installDecor() {
        if (mDecor == null) {
            mDecor = generateDecor();
            mDecor.setIsRootNamespace(true);
        }
        if (mContentParent == null) {
            mContentParent = generateLayout(mDecor);
 
            mTitleView = (TextView)findViewById(com.android.internal.R.id.title);
            if (mTitleView != null) {
                if ((getLocalFeatures() & (1 << FEATURE_NO_TITLE)) != 0) {
                    View titleContainer = findViewById(com.android.internal.R.id.title_container);
                    if (titleContainer != null) {
                        titleContainer.setVisibility(View.GONE);
                    } else {
                        mTitleView.setVisibility(View.GONE);
                    }
                    if (mContentParent instanceof FrameLayout) {
                        ((FrameLayout)mContentParent).setForeground(null);
                    }
                } else {
                    mTitleView.setText(mTitle);
                }
            }
        }
    }

使用generateDecor()创建一个DecorView对象，并赋值给mDecor变量。该变量并不完全等同于窗口

修饰，窗口修饰是mDecor内部的唯一一个子视图。

根据用户指定的参数选择不同的窗口修饰，并把窗口修饰作为mDecor的子窗口，这是在

generateLayout()中调用mDecor.addView()完成的。

不同窗口的修饰的区别不大，比如是否有标题栏，是否显示左右进度条等，这些修饰窗口共同的

特点是其内部必须包含一个id=content的FrameLayout，因为内容窗口正是被包含在该FrameLayout

之中。常见的窗口修饰对应的XML文件如下，其路径为frameworks/base/core/res/res/layout。

   R.layout.dialog_title_icons

R.layout.screen_title_icons

R.layout.screen_progress

R.layout.dialog_custom_title

R.layout.screen_custom_title

R.layout.dialog_title

R.layout.screen_title

R.layout.screen_simple

安装完窗口修饰后，就可以把用户界面layout.xml文件添加到窗口修饰中，这是通过在

setContentView()中调用inflate()方法完成的，该方法的第二个参数正是mContentParent

即id=content的FrameLayout。

我们再看一看PhoneWindow.setContentView()源代码：

    @Override
    public void setContentView(int layoutResID) {
        if (mContentParent == null) {
            installDecor();
        } else {
            mContentParent.removeAllViews();
        }
        mLayoutInflater.inflate(layoutResID, mContentParent);
        final Callback cb = getCallback();
        if (cb != null) {
            cb.onContentChanged();
        }
    }

最后，回调cb.onContentChanged()方法，通知应用程序窗口内容发生了改变，因为从无到

有了。

再来特别说明一点，所谓的“根据用户指定的参数”中“用户指定”有两个地方可以指定：

第一个地方是在Activity的onCreate()方法中调用得到当前Window，然后调用requestFeature()指

定。generateLayout()方法中使用getLocalFeature()获取feature值，并根据这些值选择不同的窗口

修饰。

另一个地方是在AndroidMainfest.xml中Activity元素内部使用android:theme="XXX"指定。

generateLayout()方法中使用getWindowStyle()方法获取这些值，调用流程如下：

getWindowStyle()：PhoneWindow中generateLayout()

->obtainStyleAttributes()：Window中

->getTheme.obtainStyledAttributes()：Context中

流程中的最后一个是调用getTheme()，而这正是使用android:theme赋值的结果。

"用户指定"及generateLayout()方法内部的流程可以总结如下：