×

侧滑菜单(抽屉效果)DrawerLayout实现原理

96
Ihesong
2017.10.15 17:39* 字数 2433

DrawerLayout是android support包新增的侧滑菜单控件,在Android Studio中可以很方便的创建一个带有侧滑菜单的页面。今天,我们来分析DrawerLayout它的实现原理,来加深对它的了解。为了能让读者有一个清晰的认识和选择性的了解,我在这里先列出本次分析的内容概要,读者可以按需了解。分析内容为:

  • 1.分析整体结构,实现的功能性。
  • 2.分析包含的重点属性,构造方法初始化等。
  • 3.分析布局实现,包括measure,layout,draw等。
  • 4.分析触摸事件,onTouchEvent,onInteceptTouchEvent等。
  • 5.分析LayoutParams的使用
  • 6.分析SavedState,用于备份还原状态,备忘录模式
  • 7.由此总结,自定义一个View可能需要考虑实现哪些内容。

1.整体结构,功能性分析

DrawerLayout相关的类及接口有如下:

  • 1.类ViewDragHelper,与DrawerLayout最紧密关系的类。作为一个辅助类,它主要用于帮助DrawerLayout进行触摸开启,关闭,拖动,释放滑动等逻辑的判断和处理,同时,还通过ViewDragHelper.Callback通知DrawerLayout状态的一些变化。
  • 2.类ViewDragCallback,ViewDragHelper.Callback接口的实现,通过它可以使DrawerLayout和ViewDragHelper进行一些拖动等逻辑上的交互。
  • 3.接口DrawerListener,提供对外回调的接口,用于监听onDrawerSlide(抽屉滑动),onDrawerOpened(抽屉打开),onDrawerClosed(抽屉关闭),onDrawerStateChanged(抽屉状态变化)等事件,以便外部能做出一些响应。例如配合ToolBar,实现侧滑菜单时,更新ToolBar左侧按钮旋转效果。SimpleDrawerListener,接口DrawerListener的空实现,目的是可以通过它选择性实现接口方法,不会一次弹出那么多方法。
  • 4.接口DrawerLayoutCompatImpl,定义DrawerLayout需要根据版本进行适配的接口。实现类分别有DrawerLayoutCompatImplBase和DrawerLayoutCompatImplApi21。版本21及以上,做的是布局内容区域是否要填充到状态栏,导航栏上,实现沉浸式效果。版本21以下空实现,因为系统不支持,所以不做处理。顺便提下,这里采用了策略模式。
  • 5.类SavedState,用于保存和恢复当前DrawerLayout状态的类,实现Parcelable接口,可实现数据序列化。配合onSaveInstanceState保存状态数据,onRestoreInstanceState恢复状态数据。这里采用了备忘录模式,SavedState作为备忘者,DrawerLayout是备忘录管理者,Activity是备忘录使用者。
  • 6.类LayoutParams,自定义的ViewGroup.MarginLayoutParams,通过它可以增加一些额外属性的处理,这里有onScreen(划出屏幕百分比),openState(开启状态)等。
  • 7.类AccessibilityDelegate,辅助功能逻辑处理类,这里不做详谈。

2.重点属性,构造方法初始化分析

  • 1.包含三种状态,STATE_IDLE(已打开或已关闭), STATE_DRAGGING(正在拖动), STATE_SETTLING(执行打开或关闭的动画过程中)。
  • 2.包含四种锁定模式,LOCK_MODE_UNLOCKED(未锁定,用户可以活动侧滑), LOCK_MODE_LOCKED_CLOSED(锁定并关闭菜单,用户无法侧滑,但是程序调用可以实现侧滑), LOCK_MODE_LOCKED_OPEN(锁定并打开菜单,用户无法侧滑,但是程序调用可以实现侧滑), LOCK_MODE_UNDEFINED(空白状态,初始状态)。
  • 3.mLeftDragger,mRightDragger,用于处理左侧和右侧侧滑的辅助类ViewDragHelper对象。
  • 4.mLeftCallback,mRightCallback,左侧和右侧侧滑处理的回调接口。
  • 5.mShadowStart等各个方向侧滑菜单阴影部分Drawable。

构造方法分析

public DrawerLayout(Context context, AttributeSet attrs, int defStyle) {
    super(context, attrs, defStyle);
    setDescendantFocusability(ViewGroup.FOCUS_AFTER_DESCENDANTS);
    final float density = getResources().getDisplayMetrics().density;
    mMinDrawerMargin = (int) (MIN_DRAWER_MARGIN * density + 0.5f);
    final float minVel = MIN_FLING_VELOCITY * density;
    //初始化左右拖动回调接口
    mLeftCallback = new ViewDragCallback(Gravity.LEFT);
    mRightCallback = new ViewDragCallback(Gravity.RIGHT);
    //初始化左右拖动辅助类,并与拖动回调接口绑定,设置当前方向拖动辅助对象可以触发侧滑的边缘方向
    mLeftDragger = ViewDragHelper.create(this, TOUCH_SLOP_SENSITIVITY, mLeftCallback);
    mLeftDragger.setEdgeTrackingEnabled(ViewDragHelper.EDGE_LEFT);
    mLeftDragger.setMinVelocity(minVel);
    mLeftCallback.setDragger(mLeftDragger);

    mRightDragger = ViewDragHelper.create(this, TOUCH_SLOP_SENSITIVITY, mRightCallback);
    mRightDragger.setEdgeTrackingEnabled(ViewDragHelper.EDGE_RIGHT);
    mRightDragger.setMinVelocity(minVel);
    mRightCallback.setDragger(mRightDragger);

    // 设置可获取焦点,以便能捕获返回键事件
    setFocusableInTouchMode(true);

    ViewCompat.setImportantForAccessibility(this,
            ViewCompat.IMPORTANT_FOR_ACCESSIBILITY_YES);

    ViewCompat.setAccessibilityDelegate(this, new AccessibilityDelegate());
    //设置不支持多点触摸
    ViewGroupCompat.setMotionEventSplittingEnabled(this, false);
    //适配状态栏区域显示
    if (ViewCompat.getFitsSystemWindows(this)) {
        IMPL.configureApplyInsets(this);
        mStatusBarBackground = IMPL.getDefaultStatusBarBackground(context);
    }

    mDrawerElevation = DRAWER_ELEVATION * density;
    //里面非抽屉的子View列表
    mNonDrawerViews = new ArrayList<View>();
}

3.布局实现分析

对于一个自定义View,它的布局实现和触摸事件实现是它的核心功能。布局上一般需要实现测量,布局,绘制三个模块,在DrawerLayout中,实现了以下方法:

  • onMeasure
  • onLayout
  • onDraw
  • drawChild

onMeasure,根据父View传递过来的测量参数,解析得到高度和宽度的测量模式,测量大小,这是父View提供的一个参考标准,在DrawerLayout中,测量模式只接受MeasureSpec.EXACTLY,也就是只接受确定的值,所以DrawerLayout的布局高度宽度属性一般要设置为match_parent或者固定值,而不能是wrap_conent,当然在编辑模式下除外。所以DrawerLayout的测量大小设置了和父View一样大小。然后针对所有子View,确定是否要适应状态栏区域。然后区分内容区域和侧滑区域,内容区域完整填充DrawerLayout区域,侧滑区域根据相应的规则测量,目的使使侧滑能占据DrawerLayout的一部分区域,既不能完全填充,也不能完全没显示区域。

@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
    int widthMode = MeasureSpec.getMode(widthMeasureSpec);
    int heightMode = MeasureSpec.getMode(heightMeasureSpec);
    int widthSize = MeasureSpec.getSize(widthMeasureSpec);
    int heightSize = MeasureSpec.getSize(heightMeasureSpec);
    //默认,测量模式必须为EXACTLY 
    if (widthMode != MeasureSpec.EXACTLY || heightMode != MeasureSpec.EXACTLY) {
        if (isInEditMode()) {
            //编辑模式下,针对非EXACTLY 模式做的一些适配
            }
        } else {
            throw new IllegalArgumentException(
                    "DrawerLayout must be measured with MeasureSpec.EXACTLY.");
        }
    }
    //设置最终DrawerLayout的测量大小
    setMeasuredDimension(widthSize, heightSize);

    final boolean applyInsets = mLastInsets != null && ViewCompat.getFitsSystemWindows(this);
    final int layoutDirection = ViewCompat.getLayoutDirection(this);

    // Only one drawer is permitted along each vertical edge (left / right). These two booleans
    // are tracking the presence of the edge drawers.
    boolean hasDrawerOnLeftEdge = false;
    boolean hasDrawerOnRightEdge = false;
    final int childCount = getChildCount();
    //对所有子View进行测量
    for (int i = 0; i < childCount; i++) {
        final View child = getChildAt(i);

        if (child.getVisibility() == GONE) {
            continue;
        }

        final LayoutParams lp = (LayoutParams) child.getLayoutParams();
        //是否适配状态栏区域
        if (applyInsets) {
            final int cgrav = GravityCompat.getAbsoluteGravity(lp.gravity, layoutDirection);
            if (ViewCompat.getFitsSystemWindows(child)) {
                IMPL.dispatchChildInsets(child, mLastInsets, cgrav);
            } else {
                IMPL.applyMarginInsets(lp, mLastInsets, cgrav);
            }
        }

        if (isContentView(child)) {
            //内容区域,完整填充DrawerLayout
            // Content views get measured at exactly the layout's size.
            final int contentWidthSpec = MeasureSpec.makeMeasureSpec(
                    widthSize - lp.leftMargin - lp.rightMargin, MeasureSpec.EXACTLY);
            final int contentHeightSpec = MeasureSpec.makeMeasureSpec(
                    heightSize - lp.topMargin - lp.bottomMargin, MeasureSpec.EXACTLY);
            child.measure(contentWidthSpec, contentHeightSpec);
        } else if (isDrawerView(child)) {
            //侧滑区域,设置阴影效果
            if (SET_DRAWER_SHADOW_FROM_ELEVATION) {
                if (ViewCompat.getElevation(child) != mDrawerElevation) {
                    ViewCompat.setElevation(child, mDrawerElevation);
                }
            }
            final @EdgeGravity int childGravity =
                    getDrawerViewAbsoluteGravity(child) & Gravity.HORIZONTAL_GRAVITY_MASK;
            // Note that the isDrawerView check guarantees that childGravity here is either
            // LEFT or RIGHT
            boolean isLeftEdgeDrawer = (childGravity == Gravity.LEFT);
            if ((isLeftEdgeDrawer && hasDrawerOnLeftEdge)
                    || (!isLeftEdgeDrawer && hasDrawerOnRightEdge)) {
                throw new IllegalStateException("Child drawer has absolute gravity "
                        + gravityToString(childGravity) + " but this " + TAG + " already has a "
                        + "drawer view along that edge");
            }
            if (isLeftEdgeDrawer) {
                hasDrawerOnLeftEdge = true;
            } else {
                hasDrawerOnRightEdge = true;
            }
            //计算侧滑的宽高的测量值,并对侧滑区域进行测量
            final int drawerWidthSpec = getChildMeasureSpec(widthMeasureSpec,
                    mMinDrawerMargin + lp.leftMargin + lp.rightMargin,
                    lp.width);
            final int drawerHeightSpec = getChildMeasureSpec(heightMeasureSpec,
                    lp.topMargin + lp.bottomMargin,
                    lp.height);
            child.measure(drawerWidthSpec, drawerHeightSpec);
        } else {
            throw new IllegalStateException("Child " + child + " at index " + i
                    + " does not have a valid layout_gravity - must be Gravity.LEFT, "
                    + "Gravity.RIGHT or Gravity.NO_GRAVITY");
        }
    }
}

所以总结测量的结果就是,DrawerLayout的大小完整填充父View,内容区域完整填充DrawerLayout,侧滑区域宽度上部分填充,高度上可完整填充或部分填充。

onLayout,对所有子View,如果是内容区域,根据测量结果进行布局,如果是侧滑区域,那就要区分是左侧侧滑还是右侧侧滑,这里分析左侧侧滑,根据当前子View的LayoutParams参数的gravity属性,在高度上分为顶部对齐,底部对齐,居中显示三种,在宽度上,根据LayoutParams参数的onScreen(侧滑显示在屏幕上的百分比),将侧滑布局到完全收起到完全划出之间。

@Override
protected void onLayout(boolean changed, int l, int t, int r, int b) {
    mInLayout = true;
    final int width = r - l;
    final int childCount = getChildCount();
    for (int i = 0; i < childCount; i++) {
        final View child = getChildAt(i);
        //隐藏的子View不考虑布局
        if (child.getVisibility() == GONE) {
            continue;
        }

        final LayoutParams lp = (LayoutParams) child.getLayoutParams();

        if (isContentView(child)) {
            //内容区域布局
            child.layout(lp.leftMargin, lp.topMargin,
                    lp.leftMargin + child.getMeasuredWidth(),
                    lp.topMargin + child.getMeasuredHeight());
        } else { // Drawer, if it wasn't onMeasure would have thrown an exception.
            final int childWidth = child.getMeasuredWidth();
            final int childHeight = child.getMeasuredHeight();
            int childLeft;
            //计算侧滑显示到屏幕的宽度百分比
            final float newOffset;
            if (checkDrawerViewAbsoluteGravity(child, Gravity.LEFT)) {
                childLeft = -childWidth + (int) (childWidth * lp.onScreen);
                newOffset = (float) (childWidth + childLeft) / childWidth;
            } else { // Right; onMeasure checked for us.
                childLeft = width - (int) (childWidth * lp.onScreen);
                newOffset = (float) (width - childLeft) / childWidth;
            }

            final boolean changeOffset = newOffset != lp.onScreen;

            final int vgrav = lp.gravity & Gravity.VERTICAL_GRAVITY_MASK;
            //区分顶部对齐,底部对齐,居中对齐布局
            switch (vgrav) {
                default:
                case Gravity.TOP: {
                    child.layout(childLeft, lp.topMargin, childLeft + childWidth,
                            lp.topMargin + childHeight);
                    break;
                }

                case Gravity.BOTTOM: {
                    final int height = b - t;
                    child.layout(childLeft,
                            height - lp.bottomMargin - child.getMeasuredHeight(),
                            childLeft + childWidth,
                            height - lp.bottomMargin);
                    break;
                }

                case Gravity.CENTER_VERTICAL: {
                    final int height = b - t;
                    int childTop = (height - childHeight) / 2;

                    // Offset for margins. If things don't fit right because of
                    // bad measurement before, oh well.
                    if (childTop < lp.topMargin) {
                        childTop = lp.topMargin;
                    } else if (childTop + childHeight > height - lp.bottomMargin) {
                        childTop = height - lp.bottomMargin - childHeight;
                    }
                    child.layout(childLeft, childTop, childLeft + childWidth,
                            childTop + childHeight);
                    break;
                }
            }

            if (changeOffset) {
                //侧滑过程中,通知更新布局参数的onScreen属性,并通知监听,侧滑滑动中
                setDrawerViewOffset(child, newOffset);
            }
            //侧滑没有划出屏幕时,设置为不可见,这样后面就避免无效绘制了
            final int newVisibility = lp.onScreen > 0 ? VISIBLE : INVISIBLE;
            if (child.getVisibility() != newVisibility) {
                child.setVisibility(newVisibility);
            }
        }
    }
    mInLayout = false;
    mFirstLayout = false;
}

onDraw,接下来开始绘制,这个很简单,因为作为一个容器,本身不需要绘制什么内容,这里根据版本适配,做了绘制状态栏颜色的工作。

@Override
public void onDraw(Canvas c) {
    super.onDraw(c);
     //如果需要绘制状态栏,并且状态栏背景drawable不为空即21以上版本,就进行状态栏区域的绘制
    if (mDrawStatusBarBackground && mStatusBarBackground != null) {
        final int inset = IMPL.getTopInset(mLastInsets);
        if (inset > 0) {
            mStatusBarBackground.setBounds(0, 0, getWidth(), inset);
            mStatusBarBackground.draw(c);
        }
    }
}

drawChild,接下来是绘制具体的某个子View,首先绘制内容区域,为了提高绘制效率,如果侧滑划出时,那么被侧滑遮挡的区域就不需要绘制了,只裁剪绘制需要显示出来的那部分。然后判断是否绘制覆盖在内容区域上阴影区域,如果不显示内容上层阴影,则判断是否绘制左侧或者右侧的侧边阴影。

@Override
protected boolean drawChild(Canvas canvas, View child, long drawingTime) {
    final int height = getHeight();
    final boolean drawingContent = isContentView(child);
    int clipLeft = 0, clipRight = getWidth();
    //裁剪区域绘制内容区域
    final int restoreCount = canvas.save();
    if (drawingContent) {
        final int childCount = getChildCount();
        for (int i = 0; i < childCount; i++) {
            final View v = getChildAt(i);
            if (v == child || v.getVisibility() != VISIBLE
                    || !hasOpaqueBackground(v) || !isDrawerView(v)
                    || v.getHeight() < height) {
                continue;
            }

            if (checkDrawerViewAbsoluteGravity(v, Gravity.LEFT)) {
                final int vright = v.getRight();
                if (vright > clipLeft) clipLeft = vright;
            } else {
                final int vleft = v.getLeft();
                if (vleft < clipRight) clipRight = vleft;
            }
        }
        canvas.clipRect(clipLeft, 0, clipRight, getHeight());
    }
    final boolean result = super.drawChild(canvas, child, drawingTime);
    canvas.restoreToCount(restoreCount);

    if (mScrimOpacity > 0 && drawingContent) {
        //绘制内容区域上层的阴影区域,一般划出了就会显示
        final int baseAlpha = (mScrimColor & 0xff000000) >>> 24;
        final int imag = (int) (baseAlpha * mScrimOpacity);
        final int color = imag << 24 | (mScrimColor & 0xffffff);
        mScrimPaint.setColor(color);

        canvas.drawRect(clipLeft, 0, clipRight, getHeight(), mScrimPaint);
    } else if (mShadowLeftResolved != null
            &&  checkDrawerViewAbsoluteGravity(child, Gravity.LEFT)) {
        //绘制左侧侧滑栏的阴影部分,根据滑动距离调整阴影透明度
        final int shadowWidth = mShadowLeftResolved.getIntrinsicWidth();
        final int childRight = child.getRight();
        final int drawerPeekDistance = mLeftDragger.getEdgeSize();
        final float alpha =
                Math.max(0, Math.min((float) childRight / drawerPeekDistance, 1.f));
        mShadowLeftResolved.setBounds(childRight, child.getTop(),
                childRight + shadowWidth, child.getBottom());
        mShadowLeftResolved.setAlpha((int) (0xff * alpha));
        mShadowLeftResolved.draw(canvas);
    } else if (mShadowRightResolved != null
            &&  checkDrawerViewAbsoluteGravity(child, Gravity.RIGHT)) {
        //绘制右侧侧滑栏的阴影部分,根据滑动距离调整阴影透明度
        final int shadowWidth = mShadowRightResolved.getIntrinsicWidth();
        final int childLeft = child.getLeft();
        final int showing = getWidth() - childLeft;
        final int drawerPeekDistance = mRightDragger.getEdgeSize();
        final float alpha =
                Math.max(0, Math.min((float) showing / drawerPeekDistance, 1.f));
        mShadowRightResolved.setBounds(childLeft - shadowWidth, child.getTop(),
                childLeft, child.getBottom());
        mShadowRightResolved.setAlpha((int) (0xff * alpha));
        mShadowRightResolved.draw(canvas);
    }
    return result;
}

4.触摸事件分析

DrawerLayout实现了onInterceptTouchEvent和onTouchEvent方法,onInterceptTouchEvent处理TouchEvent事件的拦截,如果左侧或者右侧ViewDragHelper对象要拦截,或者是侧滑菜单显示时,点击位置在内容区域,或者侧滑栏正在执行移动动画,或者取消子View的Touch操作,就会拦截,这样子View就无法接收Touch事件了。

@Override
public boolean onInterceptTouchEvent(MotionEvent ev) {
    final int action = MotionEventCompat.getActionMasked(ev);

    // "|" used deliberately here; both methods should be invoked.
    final boolean interceptForDrag = mLeftDragger.shouldInterceptTouchEvent(ev)
            | mRightDragger.shouldInterceptTouchEvent(ev);

    boolean interceptForTap = false;

    switch (action) {
        case MotionEvent.ACTION_DOWN: {
            final float x = ev.getX();
            final float y = ev.getY();
            mInitialMotionX = x;
            mInitialMotionY = y;
            if (mScrimOpacity > 0) {
                final View child = mLeftDragger.findTopChildUnder((int) x, (int) y);
                if (child != null && isContentView(child)) {
                    interceptForTap = true;
                }
            }
            mDisallowInterceptRequested = false;
            mChildrenCanceledTouch = false;
            break;
        }

        case MotionEvent.ACTION_MOVE: {
            // If we cross the touch slop, don't perform the delayed peek for an edge touch.
            if (mLeftDragger.checkTouchSlop(ViewDragHelper.DIRECTION_ALL)) {
                mLeftCallback.removeCallbacks();
                mRightCallback.removeCallbacks();
            }
            break;
        }

        case MotionEvent.ACTION_CANCEL:
        case MotionEvent.ACTION_UP: {
            closeDrawers(true);
            mDisallowInterceptRequested = false;
            mChildrenCanceledTouch = false;
        }
    }

    return interceptForDrag || interceptForTap || hasPeekingDrawer() || mChildrenCanceledTouch;
}

onTouchEvent方法,会将Touch事件交给左,右ViewDragHelper对象帮助处理,然后自己还实现了发生ACTION_UP和ACTION_CANCEL时,关闭侧滑栏的操作。

@Override
public boolean onTouchEvent(MotionEvent ev) {
    //将Touch事件交给ViewDragHelper对象处理
    mLeftDragger.processTouchEvent(ev);
    mRightDragger.processTouchEvent(ev);

    final int action = ev.getAction();
    boolean wantTouchEvents = true;
    //后面处理ACTION_UP和ACTION_CANCEL时,关闭侧滑栏的操作
    switch (action & MotionEventCompat.ACTION_MASK) {
        case MotionEvent.ACTION_DOWN: {
            final float x = ev.getX();
            final float y = ev.getY();
            mInitialMotionX = x;
            mInitialMotionY = y;
            mDisallowInterceptRequested = false;
            mChildrenCanceledTouch = false;
            break;
        }

        case MotionEvent.ACTION_UP: {
            final float x = ev.getX();
            final float y = ev.getY();
            boolean peekingOnly = true;
            final View touchedView = mLeftDragger.findTopChildUnder((int) x, (int) y);
            if (touchedView != null && isContentView(touchedView)) {
                final float dx = x - mInitialMotionX;
                final float dy = y - mInitialMotionY;
                final int slop = mLeftDragger.getTouchSlop();
                if (dx * dx + dy * dy < slop * slop) {
                    // Taps close a dimmed open drawer but only if it isn't locked open.
                    final View openDrawer = findOpenDrawer();
                    if (openDrawer != null) {
                        peekingOnly = getDrawerLockMode(openDrawer) == LOCK_MODE_LOCKED_OPEN;
                    }
                }
            }
            closeDrawers(peekingOnly);
            mDisallowInterceptRequested = false;
            break;
        }

        case MotionEvent.ACTION_CANCEL: {
            closeDrawers(true);
            mDisallowInterceptRequested = false;
            mChildrenCanceledTouch = false;
            break;
        }
    }

    return wantTouchEvents;
}

DrawerLayout把绝大部分的触摸事件交给ViewDragHelper去处理,那么在ViewDragHelper中是怎么处理的呢?我们看看processTouchEvent

public void processTouchEvent(MotionEvent ev) {
    //取得当前Touch的action 和action 序号
    final int action = MotionEventCompat.getActionMasked(ev);
    final int actionIndex = MotionEventCompat.getActionIndex(ev);
    //down事件的话,执行cancel,重置一些记录Touch事件的对象数据,为后面处理Touch事件做初始化准备
    if (action == MotionEvent.ACTION_DOWN) {
        // Reset things for a new event stream, just in case we didn't get
        // the whole previous stream.
        cancel();
    }
    //添加触摸力度跟踪对象,为后期计算滑动速度检测做准备,这里这个对象的获取采用享元模式,避免频繁创建销毁对象
    if (mVelocityTracker == null) {
        mVelocityTracker = VelocityTracker.obtain();
    }
    mVelocityTracker.addMovement(ev);

    switch (action) {
        case MotionEvent.ACTION_DOWN: {
            final float x = ev.getX();
            final float y = ev.getY();
            final int pointerId = ev.getPointerId(0);
            //这里找到当前触摸点的最顶层的子View,作为需要操作的View
            final View toCapture = findTopChildUnder((int) x, (int) y);
           //保存当前Touch点发生的初始状态
            saveInitialMotion(x, y, pointerId);
            //这里是点在一个正在滑动的侧滑栏上,使侧滑栏的状态由正在滑动状态变为正在拖动状态
            // Since the parent is already directly processing this touch event,
            // there is no reason to delay for a slop before dragging.
            // Start immediately if possible.
            tryCaptureViewForDrag(toCapture, pointerId);
            //这里处理侧滑栏的触摸触发区域是否触摸了,如果侧滑栏边缘触摸了,则通知回调,那么DrawerLayout里就会处理它,执行一个侧滑微弹的操作,也就是稍微弹出一点,表示触发了侧滑操作
            final int edgesTouched = mInitialEdgesTouched[pointerId];
            if ((edgesTouched & mTrackingEdges) != 0) {
                mCallback.onEdgeTouched(edgesTouched & mTrackingEdges, pointerId);
            }
            break;
        }

        case MotionEventCompat.ACTION_POINTER_DOWN: {
            final int pointerId = ev.getPointerId(actionIndex);
            final float x = ev.getX(actionIndex);
            final float y = ev.getY(actionIndex);
            //保存当前Touch点发生的初始状态
            saveInitialMotion(x, y, pointerId);
            //尝试去触发拖动操作
            // A ViewDragHelper can only manipulate one view at a time.
            if (mDragState == STATE_IDLE) {
                // If we're idle we can do anything! Treat it like a normal down event.

                final View toCapture = findTopChildUnder((int) x, (int) y);
                tryCaptureViewForDrag(toCapture, pointerId);

                final int edgesTouched = mInitialEdgesTouched[pointerId];
                if ((edgesTouched & mTrackingEdges) != 0) {
                    mCallback.onEdgeTouched(edgesTouched & mTrackingEdges, pointerId);
                }
            } else if (isCapturedViewUnder((int) x, (int) y)) {
                // We're still tracking a captured view. If the same view is under this
                // point, we'll swap to controlling it with this pointer instead.
                // (This will still work if we're "catching" a settling view.)

                tryCaptureViewForDrag(mCapturedView, pointerId);
            }
            break;
        }

        case MotionEvent.ACTION_MOVE: {
            if (mDragState == STATE_DRAGGING) {
                // If pointer is invalid then skip the ACTION_MOVE.
                if (!isValidPointerForActionMove(mActivePointerId)) break;

                final int index = ev.findPointerIndex(mActivePointerId);
                final float x = ev.getX(index);
                final float y = ev.getY(index);
                final int idx = (int) (x - mLastMotionX[mActivePointerId]);
                final int idy = (int) (y - mLastMotionY[mActivePointerId]);
                //正在拖动时,更新侧滑栏拖动的位置
                dragTo(mCapturedView.getLeft() + idx, mCapturedView.getTop() + idy, idx, idy);

                saveLastMotion(ev);
            } else {
                // Check to see if any pointer is now over a draggable view.
                final int pointerCount = ev.getPointerCount();
                for (int i = 0; i < pointerCount; i++) {
                    final int pointerId = ev.getPointerId(i);

                    // If pointer is invalid then skip the ACTION_MOVE.
                    if (!isValidPointerForActionMove(pointerId)) continue;
                    //否则,判断事件是否正在侧滑边缘移动,以尝试去触发侧滑栏拖动操作
                    final float x = ev.getX(i);
                    final float y = ev.getY(i);
                    final float dx = x - mInitialMotionX[pointerId];
                    final float dy = y - mInitialMotionY[pointerId];

                    reportNewEdgeDrags(dx, dy, pointerId);
                    if (mDragState == STATE_DRAGGING) {
                        // Callback might have started an edge drag.
                        break;
                    }

                    final View toCapture = findTopChildUnder((int) x, (int) y);
                    if (checkTouchSlop(toCapture, dx, dy)
                            && tryCaptureViewForDrag(toCapture, pointerId)) {
                        break;
                    }
                }
                saveLastMotion(ev);
            }
            break;
        }

        case MotionEventCompat.ACTION_POINTER_UP: {
            final int pointerId = ev.getPointerId(actionIndex);
            if (mDragState == STATE_DRAGGING && pointerId == mActivePointerId) {
                // Try to find another pointer that's still holding on to the captured view.
                int newActivePointer = INVALID_POINTER;
                final int pointerCount = ev.getPointerCount();
                for (int i = 0; i < pointerCount; i++) {
                    final int id = ev.getPointerId(i);
                    if (id == mActivePointerId) {
                        // This one's going away, skip.
                        continue;
                    }
                    //在拖动状态下,尝试去寻找当前的新的Touch点是否触发侧滑拖动操作
                    final float x = ev.getX(i);
                    final float y = ev.getY(i);
                    if (findTopChildUnder((int) x, (int) y) == mCapturedView
                            && tryCaptureViewForDrag(mCapturedView, id)) {
                        newActivePointer = mActivePointerId;
                        break;
                    }
                }
                //如果当前这个Touch点没有成功触发侧滑拖动操作,就去释放这个正在拖动的View
                if (newActivePointer == INVALID_POINTER) {
                    // We didn't find another pointer still touching the view, release it.
                    releaseViewForPointerUp();
                }
            }
            clearMotionHistory(pointerId);
            break;
        }

        case MotionEvent.ACTION_UP: {
            //up和cancel事件发生时,释放这个正在拖动的View
            if (mDragState == STATE_DRAGGING) {
                releaseViewForPointerUp();
            }
            cancel();
            break;
        }

        case MotionEvent.ACTION_CANCEL: {
            if (mDragState == STATE_DRAGGING) {
                dispatchViewReleased(0, 0);
            }
            cancel();
            break;
        }
    }
}

此外还有shouldInterceptTouchEvent这个辅助拦截事件,实现上和processTouchEvent差不多,大家可以自行分析。
总结触摸事件的处理,判断是否触摸在可触发侧滑栏的区域,未弹出时,根据滑动的力度判断是否弹出侧滑,在侧滑弹出的过程中,正在拖动侧滑的过程,已经滑出后等状态时,的一些触摸事件的处理。

5.自定义LayoutParams分析,通过自定义LayoutParams,可以为子View提供一些额外的布局参数。实现如下。

public static class LayoutParams extends ViewGroup.MarginLayoutParams {
    private static final int FLAG_IS_OPENED = 0x1;
    private static final int FLAG_IS_OPENING = 0x2;
    private static final int FLAG_IS_CLOSING = 0x4;
    //额外处理了,gravity(靠边方向),onScreen(显示出屏幕的百分比),isPeeking(是否正在微弹),openState(打开状态)
    public int gravity = Gravity.NO_GRAVITY;
    float onScreen;
    boolean isPeeking;
    int openState;

    public LayoutParams(Context c, AttributeSet attrs) {
        super(c, attrs);

        final TypedArray a = c.obtainStyledAttributes(attrs, LAYOUT_ATTRS);
        this.gravity = a.getInt(0, Gravity.NO_GRAVITY);
        a.recycle();
    }

    public LayoutParams(int width, int height) {
        super(width, height);
    }

    public LayoutParams(int width, int height, int gravity) {
        this(width, height);
        this.gravity = gravity;
    }

    public LayoutParams(LayoutParams source) {
        super(source);
        this.gravity = source.gravity;
    }

    public LayoutParams(ViewGroup.LayoutParams source) {
        super(source);
    }

    public LayoutParams(ViewGroup.MarginLayoutParams source) {
        super(source);
    }
}

那么它是在哪里生效的呢?是DrawerLayout复写了ViewGroup的generateLayoutParams方法,在这里提供了自己的LayoutParams

@Override
protected ViewGroup.LayoutParams generateDefaultLayoutParams() {
    return new LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT);
}

@Override
protected ViewGroup.LayoutParams generateLayoutParams(ViewGroup.LayoutParams p) {
    return p instanceof LayoutParams
            ? new LayoutParams((LayoutParams) p)
            : p instanceof ViewGroup.MarginLayoutParams
            ? new LayoutParams((MarginLayoutParams) p)
            : new LayoutParams(p);
}

而generateLayoutParams是在ViewGroup的addView方法中调用的

public void addView(View child, int index) {
    if (child == null) {
        throw new IllegalArgumentException("Cannot add a null child view to a ViewGroup");
    }
    LayoutParams params = child.getLayoutParams();
    if (params == null) {
        //此处调用了generateDefaultLayoutParams
        params = generateDefaultLayoutParams();
        if (params == null) {
            throw new IllegalArgumentException("generateDefaultLayoutParams() cannot return null");
        }
    }
    addView(child, index, params);
}

public void addView(View child, int width, int height) {
    //此处调用了generateDefaultLayoutParams
    final LayoutParams params = generateDefaultLayoutParams();
    params.width = width;
    params.height = height;
    addView(child, -1, params);
}

看到这里,我们就明白我们自定义的LayoutParams是怎么生效的了。

6.SaveState分析

SavedState用于保存和恢复DrawerLayout的状态,SavedState实现Parcelable接口,可实现数据的序列化。这里是一种备忘录模式,SavedState作为备忘者,DrawerLayout是备忘录管理者,Activity是备忘录使用者。那么我们看看使用SavedState的实现

@Override
protected Parcelable onSaveInstanceState() {
//这里是保存状态,系统在需要保存该状态时会调用该方法,在这里初始化SavedState,将要保存的数据集合起来
    final Parcelable superState = super.onSaveInstanceState();
    final SavedState ss = new SavedState(superState);

    final int childCount = getChildCount();
    for (int i = 0; i < childCount; i++) {
        final View child = getChildAt(i);
        LayoutParams lp = (LayoutParams) child.getLayoutParams();
        // Is the current child fully opened (that is, not closing)?
        boolean isOpenedAndNotClosing = (lp.openState == LayoutParams.FLAG_IS_OPENED);
        // Is the current child opening?
        boolean isClosedAndOpening = (lp.openState == LayoutParams.FLAG_IS_OPENING);
        if (isOpenedAndNotClosing || isClosedAndOpening) {
            // If one of the conditions above holds, save the child's gravity
            // so that we open that child during state restore.
            ss.openDrawerGravity = lp.gravity;
            break;
        }
    }

    ss.lockModeLeft = mLockModeLeft;
    ss.lockModeRight = mLockModeRight;
    ss.lockModeStart = mLockModeStart;
    ss.lockModeEnd = mLockModeEnd;

    return ss;
}

下面看看恢复数据的地方

@Override
protected void onRestoreInstanceState(Parcelable state) {
    if (!(state instanceof SavedState)) {
        super.onRestoreInstanceState(state);
        return;
    }
    //先恢复非SavedState 的数据
    final SavedState ss = (SavedState) state;
    super.onRestoreInstanceState(ss.getSuperState());
    //后面再根据SavedState 存储的数据,恢复相应的状态
    if (ss.openDrawerGravity != Gravity.NO_GRAVITY) {
        final View toOpen = findDrawerWithGravity(ss.openDrawerGravity);
        if (toOpen != null) {
            openDrawer(toOpen);
        }
    }

    if (ss.lockModeLeft != LOCK_MODE_UNDEFINED) {
        setDrawerLockMode(ss.lockModeLeft, Gravity.LEFT);
    }
    if (ss.lockModeRight != LOCK_MODE_UNDEFINED) {
        setDrawerLockMode(ss.lockModeRight, Gravity.RIGHT);
    }
    if (ss.lockModeStart != LOCK_MODE_UNDEFINED) {
        setDrawerLockMode(ss.lockModeStart, GravityCompat.START);
    }
    if (ss.lockModeEnd != LOCK_MODE_UNDEFINED) {
        setDrawerLockMode(ss.lockModeEnd, GravityCompat.END);
    }
}

7.实现总结

分析完DrawerLayout之后,我们总结自定义一个View可能需要的实现有,测量,布局,绘制,事件分发处理,事件拦截处理,自身事件处理,自定义LayoutParams,考虑更多的话,有状态的存储恢复,辅助功能状态下的事件处理,当然,还有重要的自身的逻辑处理。

我们也看到DrawerLayout这个View本身只是一个控制侧滑显示的容器,一般我们会有如下的方式使用它。

<android.support.v4.widget.DrawerLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:id="@+id/drawer_layout"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:fitsSystemWindows="true"
    tools:openDrawer="start"
    >

  <include
      layout="@layout/app_bar_main2"
      android:layout_width="match_parent"
      android:layout_height="match_parent"
      />

  <android.support.design.widget.NavigationView
      android:id="@+id/nav_view"
      android:layout_width="wrap_content"
      android:layout_height="match_parent"
      android:layout_gravity="start"
      android:fitsSystemWindows="true"
      app:headerLayout="@layout/nav_header_main2"
      app:menu="@menu/activity_main2_drawer"
      />

</android.support.v4.widget.DrawerLayout>

include的部分就是内容部分,而侧滑部分就是NavigationView了,为什么判断它是侧滑部分,是看其中定义的 android:layout_gravity="start",DrawerLayout会认定它就是侧滑部分。

显然DrawerLayout并没有完全实现我们想要的侧滑菜单,因为里面我们并没有看到侧滑的内容。后面我将分析NavigationView的实现。

android原理分析
Web note ad 1