常见framework源码分析

3种

事件分发
view的绘制
启动Activity的流程

#

事件分发
- 事件指的是事件流。从手指按下到手指抬起，中间经历数个手指移动
```
// 事件分发流程，CEO-->总经理-->自己
02-22 02:14:52.426 29552-29552/? E/tag: ViewGroup1---->dispatchTouchEvent
02-22 02:14:52.426 29552-29552/? E/tag: ViewGroup1---->onInterceptTouchEvent
02-22 02:14:52.426 29552-29552/? E/tag: ViewGroup2---->dispatchTouchEvent
02-22 02:14:52.426 29552-29552/? E/tag: ViewGroup2---->onInterceptTouchEvent
02-22 02:14:52.426 29552-29552/? E/tag: MyView---->dispatchTouchEvent
// 自己-->总经理-->CEO
02-22 02:14:52.426 29552-29552/? E/tag: MyView---->onTouchEvent
02-22 02:14:52.426 29552-29552/? E/tag: ViewGroup2---->onTouchEvent
02-22 02:14:52.426 29552-29552/? E/tag: ViewGroup1---->onTouchEvent
```
- 下面是加上Activity的分发流程
  // Activiy分发
  02-22 02:17:29.442 29647-29647/? E/tag: MainActivity—->dispatchTouchEvent
  02-22 02:17:29.442 29647-29647/? E/tag: ViewGroup1—->dispatchTouchEvent
  02-22 02:17:29.442 29647-29647/? E/tag: ViewGroup1—->onInterceptTouchEvent
  02-22 02:17:29.442 29647-29647/? E/tag: ViewGroup2—->dispatchTouchEvent
  02-22 02:17:29.442 29647-29647/? E/tag: ViewGroup2—->onInterceptTouchEvent
  02-22 02:17:29.442 29647-29647/? E/tag: MyView—->dispatchTouchEvent
  02-22 02:17:29.442 29647-29647/? E/tag: MyView—->onTouchEvent
  02-22 02:17:29.442 29647-29647/? E/tag: ViewGroup2—->onTouchEvent
  02-22 02:17:29.442 29647-29647/? E/tag: ViewGroup1—->onTouchEvent
  02-22 02:17:29.442 29647-29647/? E/tag: MainActivity—->onTouchEvent
  02-22 02:17:31.394 29647-29647/? E/tag: MainActivity—->dispatchTouchEvent
  // 无人处理返回给我们的Activity
  02-22 02:17:31.394 29647-29647/? E/tag: MainActivity—->onTouchEvent
- 下面根据Activity的dispatchTouchEvent方法，源码
```
 if (getWindow().superDispatchTouchEvent(ev)) {
            return true;
        }
```
- window的实现是PhoneWindow,那么只需要找到phoneWindow的superDispatchTouchEvent(ev)即可
```
      @Override
public boolean superDispatchTouchEvent(MotionEvent event) {
    // 发现调用的mDecor就是DecorView（FrameLayout）
    return mDecor.superDispatchTouchEvent(event);
}
```
- DecorView调用的是下面方法
```
public boolean superDispatchTouchEvent(MotionEvent event) {
    // 这里的super指的是谁。DecorView的父类。FrameLayout。其实就是ViewGroup递归，分发事件
    return super.dispatchTouchEvent(event);
}
```
- dispatchTouchEvent的伪代码
```
         @Override
public boolean dispatchTouchEvent(MotionEvent ev) {
    // 如果拦截会调用自己的onTouchEvent();
    boolean dissallowIntercept;
    if(!dissallowIntercept){
        dissallowIntercept=onInterceptTouchEvent(ev);       
        }
    if(dissallowIntercept){
        onTouchEvent(ev);
    }else {
        // 孩子分发
        // 哪个孩子分发呀？根据的是ev.getX()，ev.getY()能够找到哪个孩子在这个范围内
        // 如果两个孩子在范围内。
        // 根据Z-Order（z轴）传递事件。先让最上面的孩子处理，如果不处理，事件传递到下一个孩子。
        // 这里的child应该是个集合
        if(child在ev.getX(),ev.getY()之内)
        child.dispatchTouchEvent(ev);
    }
    return super.dispatchTouchEvent(ev);
}
```
- 一般来说所有的ViewGroup都不拦截ACTION_DOWN。（因为不知道孩子是否处理）
- 一般来说一旦事件拦截，事件再也不会分发给孩子了。也就是不dispatch给孩子。
- 一般来说，一旦事件拦截之后，再也不会进事件拦截（onInterceptTouchEvent(ev)）方法了（重点）。拦截意味着事件流自己处理。(也就是再也不会问，到底事件交给你处理，还是交给孩子处理)。所以不要再事件拦截方法中根据ev获得一些数据。因为这个方法，一旦决定拦截后，再也不会进入了。系统源码决定。
- 第一种事件冲突的处理方法，在父容器的onInterceptTouchEvent根据条件是否拦截。（ViewPager+DrawLayout）.事件拦截外部拦截法
- 让孩子决定是否拦截。 getParent().requestDisallowInterceptTouchEvent(）内部拦截法
- 如果一个孩子处理事件ActionDown，那么接下来的事件还会给这个孩子，其他是没有拦截。
View的显示流程，以Activity举例

从WM代码开始

WindowManagerImpl的addView();

    @Override
public void addView(@NonNull View view, @NonNull ViewGroup.LayoutParams params) {
   // mGlobal的addView。
    // WindowManagerGlobal
    mGlobal.addView(view, params, mContext.getDisplay(), mParentWindow);
}

mGlobal的addView

// 顶级节点的布局参数是WindowManager.LayoutParams
final WindowManager.LayoutParams wparams = (WindowManager.LayoutParams) params;‘
    // 创建 一个ViewRootImpl对象
    root = new ViewRootImpl(view.getContext(), display);
    // 将view添加到ViewRootImpl这里面
 root.setView(view, wparams, panelParentView);

先分析ViewRootImpl的构造方法

    //checkThread()的时候使用
    // 将创建ViewRootImpl的线程存起来，以便checkThread() 更新ui的时候做检查
    mThread = Thread.currentThread();
    // 通过WindowManagerGlobal获得window的session（即wm和wms的通讯回话）
     mWindowSession = WindowManagerGlobal.getWindowSession();
    // session就是会话

接下来查看 WindowManagerGlobal.getWindowSession();来知道到底适合谁建立了会话。

    public static IWindowSession getWindowSession() {
synchronized (WindowManagerGlobal.class) {
    if (sWindowSession == null) {
        try {
            //imm是实现cs通讯的，也就是client和server的通讯（framework和c的通讯）。client指的是ViewRootImpl，Server指的是WMS
            InputMethodManager imm = InputMethodManager.getInstance();
            // 这里获得的是wms
            IWindowManager windowManager = getWindowManagerService();
            // 建立cs连接
            //wms和imm简历连接
            // 建立viewRootImpl和WMS的连接
            sWindowSession = windowManager.openSession(
                    new IWindowSessionCallback.Stub() {
                        @Override
                        public void onAnimatorScaleChanged(float scale) {
                            ValueAnimator.setDurationScale(scale);
                        }
                    },
                    imm.getClient(), imm.getInputContext());
        } catch (RemoteException e) {
            throw e.rethrowFromSystemServer();
        }
    }
    return sWindowSession;
}

}

接下来查看getWindowManagerService();方法

public static IWindowManager getWindowManagerService() {
        synchronized (WindowManagerGlobal.class) {
            if (sWindowManagerService == null) {
                // 在service錗anager中找到window的binder，通过打开session
                // AIDL 强转
                // ServiceManager专门存储系统级别服务的。可以想象成map
                sWindowManagerService = IWindowManager.Stub.asInterface(
                        .getService("window"));
                try {
                    sWindowManagerService = getWindowManagerService();
                    ValueAnimator.setDurationScale(sWindowManagerService.getCurrentAnimatorScale());
                } catch (RemoteException e) {
                    throw e.rethrowFromSystemServer();
                }
            }
            return sWindowManagerService;
        }
    }

ViewRootImpl实现了WMS和view的通讯。

接下来分析viewRootImpl的setView（）；里面有一个requestLayout();方法

 @Override
    public void requestLayout() {
        if (!mHandlingLayoutInLayoutRequest) {
            // 检查
            checkThread();
            mLayoutRequested = true;
            scheduleTraversals();
        }
    }

scheduleTraversals

void scheduleTraversals() {
        if (!mTraversalScheduled) {
            mTraversalScheduled = true;
            mTraversalBarrier = mHandler.getLooper().getQueue().postSyncBarrier();
                // mTraversalRunnable 是？
            mChoreographer.postCallback(
                    Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null);
            if (!mUnbufferedInputDispatch) {
                scheduleConsumeBatchedInput();
            }
            notifyRendererOfFramePending();
            pokeDrawLockIfNeeded();
        }
    }


    final class TraversalRunnable implements Runnable {
            @Override
            public void run() {
                // 做
                doTraversal();
            }
        }

doTraversal

        void doTraversal() {
    if (mTraversalScheduled) {
        mTraversalScheduled = false;
        mHandler.getLooper().getQueue().removeSyncBarrier(mTraversalBarrier);

        if (mProfile) {
            Debug.startMethodTracing("ViewAncestor");
        }
        // 执行perform
        performTraversals();

        if (mProfile) {
            Debug.stopMethodTracing();
            mProfile = false;
        }
    }
}

performTraversals();完成了3件事
// 获得decorView的测量算子
int childWidthMeasureSpec = getRootMeasureSpec(mWidth, lp.width);
int childHeightMeasureSpec = getRootMeasureSpec(mHeight, lp.height);
// perforMeasure
performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);
// performLayout
performLayout(lp, mWidth, mHeight);
// performDraw;
performDraw();

performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);

            private void performMeasure(int childWidthMeasureSpec, int childHeightMeasureSpec) {
        Trace.traceBegin(Trace.TRACE_TAG_VIEW, "measure");
        try {
            // 最顶层节点开始递归测量
            mView.measure(childWidthMeasureSpec, childHeightMeasureSpec);
        } finally {
            Trace.traceEnd(Trace.TRACE_TAG_VIEW);
        }
    }

performLayout(lp, mWidth, mHeight); 递归layout
performDraw(); mView.draw(canvas);递归绘制。
从wm添加view开始。经历wm，wmg，viewRootImp,setView()—>requestLayout–> scheduleTraversals–doTraversal–>performTravaersal–>performMeasure–>performLayout–

启动Activity流程

startActivity开始

@Override
        public void startActivityForResult(
                String who, Intent intent, int requestCode, @Nullable Bundle options) {
            Uri referrer = onProvideReferrer();
            if (referrer != null) {
                intent.putExtra(Intent.EXTRA_REFERRER, referrer);
            }
                // mInstrumentation启动的Activity
            Instrumentation.ActivityResult ar =
                mInstrumentation.execStartActivity(
                    this, mMainThread.getApplicationThread(), mToken, who,
                    intent, requestCode, options);
            if (ar != null) {
                mMainThread.sendActivityResult(
                    mToken, who, requestCode,
                    ar.getResultCode(), ar.getResultData());
            }
            cancelInputsAndStartExitTransition(options);
        }

mInstrumentation.execStartActivity

                    //AMS.startActivity 
        int result = ActivityManagerNative.getDefault()
                    .startActivity(whoThread, who.getBasePackageName(), intent,
                            intent.resolveTypeIfNeeded(who.getContentResolver()),
                            token, target != null ? target.mEmbeddedID : null,
                            requestCode, 0, null, options);

AMS的startActivity（）调用了startActivityAsUser()

    @Override
    public final int startActivityAsUser(IApplicationThread caller, String callingPackage,
            Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
            int startFlags, ProfilerInfo profilerInfo, Bundle bOptions, int userId) {
        enforceNotIsolatedCaller("startActivity");
        userId = mUserController.handleIncomingUser(Binder.getCallingPid(), Binder.getCallingUid(),
                userId, false, ALLOW_FULL_ONLY, "startActivity", null);
        // TODO: Switch to user app stacks here.
        return mActivityStarter.startActivityMayWait(caller, -1, callingPackage, intent,
                resolvedType, null, null, resultTo, resultWho, requestCode, startFlags,
                profilerInfo, null, null, bOptions, false, userId, null, null);
    }

startActivityMayWait

        // mSupervisor解析intent。其实是通讯PMS来解析的。PMS在开机时候会扫描所有的app的清单文件，找到activity存起来。
         ResolveInfo rInfo = mSupervisor.resolveIntent(intent, resolvedType, userId)
        startActivityLocked（）；

最终调用ActivityStackSupervisor的realStartActivityLocked

// thread指的是APPLICATIONTHRE
app.thread.scheduleLaunchActivity(new Intent(r.intent), r.appToken,
            System.identityHashCode(r), r.info, new Configuration(mService.mConfiguration),
            new Configuration(task.mOverrideConfig), r.compat, r.launchedFromPackage,
            task.voiceInteractor, app.repProcState, r.icicle, r.persistentState, results,
            newIntents, !andResume, mService.isNextTransitionForward(), profilerInfo);

ApplicationThread.scheduleLaunchActivity
```
 sendMessage(H.LAUNCH_ACTIVITY, r);
```

调用 handleLaunchActivity(r, null, “LAUNCH_ACTIVITY”);

private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent, String reason) {

        Activity a = performLaunchActivity(r, customIntent);

        if (a != null) {
            handleResumeActivity(r.token, false, r.isForward,
                    !r.activity.mFinished && !r.startsNotResumed, r.lastProcessedSeq, reason);
        } else {

        }
    }

performLaunchActivity 完成了三件事。创建一个Activity，以及回调onCreat，onStart

     private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
Activity activity = null;
try {
    java.lang.ClassLoader cl = r.packageInfo.getClassLoader();
        // 创建一个Activity对象
    activity = mInstrumentation.newActivity(
            cl, component.getClassName(), r.intent);
} catch (Exception e) {

}

try {

    if (activity != null) {
        // 各种context服务。都放在createBaseContextForActivity注册的。
            // getSystemService,
        Context appContext = createBaseContextForActivity(r, activity);

        Window window = null;
        if (r.mPendingRemoveWindow != null && r.mPreserveWindow) {
            window = r.mPendingRemoveWindow;
            r.mPendingRemoveWindow = null;
            r.mPendingRemoveWindowManager = null;
        }
        // 绑定下
        activity.attach(appContext, this, getInstrumentation(), r.token,
                r.ident, app, r.intent, r.activityInfo, title, r.parent,
                r.embeddedID, r.lastNonConfigurationInstances, config,
                r.referrer, r.voiceInteractor, window);
        if (r.isPersistable()) {
            // 回调activity的onCreate方法
            mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
        } else {
            mInstrumentation.callActivityOnCreate(activity, r.state);
        }


        if (!r.activity.mFinished) {
            if (r.isPersistable()) {
                // 调用onRestore方法
                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的onStart方法
            activity.performStart();
            r.stopped = false;
        }
    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;

}

handleResumeActivity

final void handleResumeActivity(IBinder token,
boolean clearHide, boolean isForward, boolean reallyResume, int seq, String reason) {
// 执行resume方法
r = performResumeActivity(token, clearHide, reason);

if (r != null) {
    final Activity a = r.activity;


    if (r.window == null && !a.mFinished && willBeVisible) {
        r.window = r.activity.getWindow();
        View decor = r.window.getDecorView();
        decor.setVisibility(View.INVISIBLE);
        ViewManager wm = a.getWindowManager();
        WindowManager.LayoutParams l = r.window.getAttributes();
        a.mDecor = decor;
        l.type = WindowManager.LayoutParams.TYPE_BASE_APPLICATION;
        l.softInputMode |= forwardBit;
        if (a.mVisibleFromClient && !a.mWindowAdded) {
            a.mWindowAdded = true;
            // WM和decor关联起来了。执行了第二部分代码。完成view的测量布局绘制，显示、
            wm.addView(decor, l);
        }


 }

Activity的启动流程，Insturmentation调用ASM启动Activity。ASM在启动Activity的时候让PMS解析以下要启动的Activity。之后交给ActivityStatckSuperior.realSatrtActivity。再交给ApplicatoinThread.scheaclLuanchActvity()。handleLaunchActivity方法完成Activity的创建以及onCreate，onstart方法的调用（performLuanchActivity）.之后完成Activity的onResume。最后将window的decorView添加到WM上，有ViewRootImpl完成测量布局绘制显示给用户。

phoneWindow

 @Override
    public void setContentView(int layoutResID) {
        if (mContentParent == null) {
            // 安装decorView 并填充mContentParent
            installDecor();
        } else if (!hasFeature(FEATURE_CONTENT_TRANSITIONS)) {
            mContentParent.removeAllViews();
        }


        // 将layoutResID添加到ContentParent上面
            // mContentParent是id为ID_ANDROID_CONTENT的这个容器
            mLayoutInflater.inflate(layoutResID, mContentParent);

    }

* installDecor();

    private void installDecor() {
    mForceDecorInstall = false;
    if (mDecor == null) {
        // 产生decorView Window的最顶层节点
        mDecor = generateDecor(-1);
        mDecor.setDescendantFocusability(ViewGroup.FOCUS_AFTER_DESCENDANTS);
        mDecor.setIsRootNamespace(true);
    } else {
        // 将decorView和window关联起来
        mDecor.setWindow(this);
    }
    if (mContentParent == null) {
        // 根据decorview产生我们的ContentParent也就是id为content的viewGroup,
                        // 根据不同的requestFeature找到不同的布局文件
                        // 天假给decorView.之后将id为content的view找到
                        // 添加给mContentParent
        mContentParent = generateLayout(mDecor);
        }
             }

* phoneWindow的主要功能就是装饰。给布局文件添加不同decor层次。根据不同的reuqestfreature添加不同的layoutresource。直接给view交互，通过viewrootimpl。

LayoutInflater

简介

基于5.0的framework源码进行分析，通过这篇文章我们能了解：
- LayoutInflater的系统级服务的注册过程
- inflate填充的过程
- ViewStub,merge,include的加载过程

LayoutInflater系统服务的注册过程

我们经常调用

context.getSystemService(Context.LAYOUT_INFLATE_SERVICE)

获得LayoutInflater对象。那么这个对象是什么时候注册到Context中的呢?这个对象的具体实现类是谁？

LayoutInflater这个服务，是在创建Activity的时候，作为baseContext传递给Activity的。接下来我们看源码过程。

我们知道Activity的创建过程是在ApplicationThread的performLaunchActivity方法中。那么接下来我们分析这个方法

 private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
    /*/
    Activity activity = null;
    try{
        // 通过Instrumentation类创建Activity
         java.lang.ClassLoader cl = r.packageInfo.getClassLoader();
activity = mInstrumentation.newActivity(
        cl, component.getClassName(), r.intent);

        }catch(Exeception e){}
    /*/
    // 创建Context过程，也就是baseContext
     Context appContext = createBaseContextForActivity(r, activity);
    // 关联activity和baseContext
    activity.attach(appContext, this, getInstrumentation(), r.token,
            r.ident, app, r.intent, r.activityInfo, title, r.parent,
            r.embeddedID, r.lastNonConfigurationInstances, config,
            r.referrer, r.voiceInteractor, window);

 }

那么接下来我们只要分析

 Context appContext = createBaseContextForActivity(r, activity);

这个方法即可，源码继续

 private Context createBaseContextForActivity(ActivityClientRecord r, final Activity activity) {
    // 通过调用ContextImpl的静态方法创建baseContext对象
    ContextImpl appContext = ContextImpl.createActivityContext(
            this, r.packageInfo, r.token, displayId, r.overrideConfig);
    appContext.setOuterContext(activity);
    return baseContext;
}

接下来分析

ContextImpl.createActivityContext(
                this, r.packageInfo, r.token, displayId, r.overrideConfig);
        appContext.setOuterContext(activity);

接下来我们分析下ContextImpl这个类，发现其有一个成员变量

    // 在这里注册系统级别的服务
// The system service cache for the system services that are cached per-ContextImpl.
final Object[] mServiceCache = SystemServiceRegistry.createServiceCache();

SystemServiceRegistry类有个静态代码块，完成了常用服务的注册，代码如下

static{
    // 注册LayoutLAYOUT_INFLATER_SERVICE系统服务，具体实现类是PhoneLayoutInflater
     registerService(Context.LAYOUT_INFLATER_SERVICE, LayoutInflater.class,
            new CachedServiceFetcher<LayoutInflater>() {
        @Override
        public LayoutInflater createService(ContextImpl ctx) {
            return new PhoneLayoutInflater(ctx.getOuterContext());
        }});
    // 注册AM 
     registerService(Context.ACTIVITY_SERVICE, ActivityManager.class,
        new CachedServiceFetcher<ActivityManager>() {
    @Override
    public ActivityManager createService(ContextImpl ctx) {
        return new ActivityManager(ctx.getOuterContext(), ctx.mMainThread.getHandler());
    }});
    // 注册WM
     registerService(Context.WINDOW_SERVICE, WindowManager.class,
        new CachedServiceFetcher<WindowManager>() {
    @Override
    public WindowManager createService(ContextImpl ctx) {
        return new WindowManagerImpl(ctx);
    }});
    // 等等
      }

接下来我们看inflate过程，下面是整个inflate过程

public View inflate(XmlPullParser parser, @Nullable ViewGroup root, boolean attachToRoot) {
synchronized (mConstructorArgs) {
    Trace.traceBegin(Trace.TRACE_TAG_VIEW, "inflate");

    final Context inflaterContext = mContext;
    final AttributeSet attrs = Xml.asAttributeSet(parser);
    Context lastContext = (Context) mConstructorArgs[0];
    mConstructorArgs[0] = inflaterContext;
    View result = root;

    try {
        // 循环找到第一个view节点，
        int type;
        while ((type = parser.next()) != XmlPullParser.START_TAG &&
                type != XmlPullParser.END_DOCUMENT) {
            // Empty
        }
        // 这里判断是否是第一个view节点
        if (type != XmlPullParser.START_TAG) {
            throw new InflateException(parser.getPositionDescription()
                    + ": No start tag found!");
        }

        final String name = parser.getName();
       // 解析merge标签
        if (TAG_MERGE.equals(name)) {
            if (root == null || !attachToRoot) {
                throw new InflateException("<merge /> can be used only with a valid "
                        + "ViewGroup root and attachToRoot=true");
            }
            // 通过rInflate方法将merge标签下的孩子直接合并到root上，这样减少一层布局，达到减少viewTree的目的
            rInflate(parser, root, inflaterContext, attrs, false);
        } else {
            // 调用反射创建view对象
            final View temp = createViewFromTag(root, name, inflaterContext, attrs);

            ViewGroup.LayoutParams params = null;

            if (root != null) {
                // Create layout params that match root, if supplied
                params = root.generateLayoutParams(attrs);
                if (!attachToRoot) {
                    // 如果view的父容器不为null，并且attachToRoot未true得话，这里只是让刚刚通过反射创建的view使用root（父容器的布局参数）
                    temp.setLayoutParams(params);
                }
            }


            // 通过深度遍历temp下的节点，之后将节点依次添加到刚刚通过反射创建的temp对象上，因为采用的是深度优先遍历算法，因此viewTree的层级很深的话，会影响遍历的性能
            rInflateChildren(parser, temp, attrs, true);
           // 判断刚刚创建的temp对象是否添加到父节点上.
            // 满足两个条件1 父节点(root)不为null，2 attachToRoot=true
            if (root != null && attachToRoot) {
                root.addView(temp, params);
            }

            // 设置result
            if (root == null || !attachToRoot) {
                result = temp;
            }
        }

    } catch (XmlPullParserException e) {
        final InflateException ie = new InflateException(e.getMessage(), e);
        ie.setStackTrace(EMPTY_STACK_TRACE);
        throw ie;
    } catch (Exception e) {

    } finally {
        // Don't retain static reference on context.
        mConstructorArgs[0] = lastContext;
        mConstructorArgs[1] = null;

        Trace.traceEnd(Trace.TRACE_TAG_VIEW);
    }
    // 返回

    return result;
}

}

通过上面分析，我们对inflate的整体过程有了一个了解，也见到了merge标签（经常作为布局文件根节点，来达到减少viewTree的层次）
接下来，我们分析4个方法
rInflate(parser, root, inflaterContext, attrs, false);，其实不管是根节点为merge还是普通的view（最终都会用这个方法），深度遍历添加view

下面是代码

    // 深度遍历添加孩子
 void rInflate(XmlPullParser parser, View parent, Context context,
            AttributeSet attrs, boolean finishInflate) throws XmlPullParserException, IOException {

    final int depth = parser.getDepth();
    int type;

    while (((type = parser.next()) != XmlPullParser.END_TAG ||
            parser.getDepth() > depth) && type != XmlPullParser.END_DOCUMENT) {

        if (type != XmlPullParser.START_TAG) {
            continue;
        }

        final String name = parser.getName();

        if (TAG_REQUEST_FOCUS.equals(name)) {
            parseRequestFocus(parser, parent);
        } else if (TAG_TAG.equals(name)) {
        // 如果我们调用了View.setTag()，将会执行下面代码
            parseViewTag(parser, parent, attrs);
        // include不能作为根节点
        } else if (TAG_INCLUDE.equals(name)) {
            if (parser.getDepth() == 0) {
                throw new InflateException("<include /> cannot be the root element");
            }
            // 这里解析include标签代码
            parseInclude(parser, context, parent, attrs);
        } else if (TAG_MERGE.equals(name)) {
            // merge一定是根节点
            throw new InflateException("<merge /> must be the root element");
        } else {
            final View view = createViewFromTag(parent, name, context, attrs);
            final ViewGroup viewGroup = (ViewGroup) parent;
            final ViewGroup.LayoutParams params = viewGroup.generateLayoutParams(attrs);
            // 递归，因为rInflateChildren最终还会调用rInflate(parser, parent, parent.getContext(), attrs, finishInflate);方法
            rInflateChildren(parser, view, attrs, true);
            viewGroup.addView(view, params);
        }
    }

    if (finishInflate) {
        // viewTree填充完毕，回调自定义view经常使用的onFinishInflate方法
        parent.onFinishInflate();
    }
}

rInflateChildren(parser, view, attrs, true);方法

    // 直接调用rInflate()实现ViewTree
 final void rInflateChildren(XmlPullParser parser, View parent, AttributeSet attrs,
    boolean finishInflate) throws XmlPullParserException, IOException {
rInflate(parser, parent, parent.getContext(), attrs, finishInflate);

}

createViewFromTag(root, name, inflaterContext, attrs);方法，这个方法其实处理了自定义view和系统view的创建。最终调用了下面方法

     View createViewFromTag(View parent, String name, Context context, AttributeSet attrs,
        boolean ignoreThemeAttr) {
    if (name.equals("view")) {
        name = attrs.getAttributeValue(null, "class");
    }

    // 设置view默认样式
    if (!ignoreThemeAttr) {
        final TypedArray ta = context.obtainStyledAttributes(attrs, ATTRS_THEME);
        final int themeResId = ta.getResourceId(0, 0);
        if (themeResId != 0) {
            context = new ContextThemeWrapper(context, themeResId);
        }
        ta.recycle();
    }

    try {
        View view;
        if (view == null) {
            final Object lastContext = mConstructorArgs[0];
            mConstructorArgs[0] = context;
            try {//创建系统view的方法，因为系统view的标签不是完整类名，需要会在 onCreateView中完成拼接（拼接出系统view的完整类名）
                if (-1 == name.indexOf('.')) {
                    view = onCreateView(parent, name, attrs);
                } else {
                    //自定义view的创建
                    view = createView(name, null, attrs);
                }
            } finally {
                mConstructorArgs[0] = lastContext;
            }
        }

        return view;
    } catch (InflateException e) {
        throw e;

    } catch (ClassNotFoundException e) {
        final InflateException ie = new InflateException(attrs.getPositionDescription()
                + ": Error inflating class " + name, e);
        ie.setStackTrace(EMPTY_STACK_TRACE);
        throw ie;

    } catch (Exception e) {
        final InflateException ie = new InflateException(attrs.getPositionDescription()
                + ": Error inflating class " + name, e);
        ie.setStackTrace(EMPTY_STACK_TRACE);
        throw ie;
    }
}

接下来我们分析 createView(String name, String prefix, AttributeSet attrs)方法，系统view的创建，最终也会调用createView方法。只不过在前面拼接上了系统view的包名。

     public final View createView(String name, String prefix, AttributeSet attrs)
        throws ClassNotFoundException, InflateException {
    // 获取view的构造方法
    Constructor<? extends View> constructor = sConstructorMap.get(name);
    //　验证
    if (constructor != null && !verifyClassLoader(constructor)) {
        constructor = null;
        sConstructorMap.remove(name);
    }
    Class<? extends View> clazz = null;

    try {
        if (constructor == null) {

            clazz = mContext.getClassLoader().loadClass(
                    prefix != null ? (prefix + name) : name).asSubclass(View.class);

            if (mFilter != null && clazz != null) {
                boolean allowed = mFilter.onLoadClass(clazz);
                if (!allowed) {
                    failNotAllowed(name, prefix, attrs);
                }
            }
            constructor = clazz.getConstructor(mConstructorSignature);
            constructor.setAccessible(true);
            // 将view的构造方法缓存起来
            sConstructorMap.put(name, constructor);
        } else {
          /*/
        }

        Object[] args = mConstructorArgs;
        args[1] = attrs;
        // 反射创建view对象
        final View view = constructor.newInstance(args);
        // 对viewStub进行处理
        if (view instanceof ViewStub) {
            // 给ViewStub设置LayoutInfalter.什么时候inflate，什么时候viewStub的内容才显示，（比GONE性能好）
            final ViewStub viewStub = (ViewStub) view;
            viewStub.setLayoutInflater(cloneInContext((Context) args[0]));
        }
        return view;

    } catch (NoSuchMethodException e) {


    } catch (ClassCastException e) {

    } catch (ClassNotFoundException e) {

    } catch (Exception e) {

    } finally {

    }
}

总结

系统服务的填充过程，是在ContextImpl中完成注册的
LayoutInflater的实现类是PhoneLayoutInflater
如果仅仅使用父容器的布局参数，可以使用inflater.inflate(layoutId,parent,false);
onFinishInflate()方法是在viewTree遍历完成之后，调用的
merge标签只能是根节点，include标签不能是根节点。
布局优化
- view的inflate的过程是深度遍历，因此应该尽量减少viewTree的层次，可以考虑使用merge标签
- 如果我们不知道view什么时候填充的时候，可以使用ViewStub标签，什么时候用什么时候填充
- include是提升复用的

阳光下的小树

发布了33 篇原创文章 · 获赞 21 · 访问量 4万+

私信关注

常见framework源码分析

常见framework源码分析

3种

#

View的显示流程，以Activity举例

启动Activity流程

phoneWindow

LayoutInflater

简介

LayoutInflater系统服务的注册过程

总结

猜你喜欢