[关闭]
@myron-lee 2017-03-22T12:26:56.000000Z 字数 12477 阅读 1989

可滑动关闭的对话框(二)

Blog

前言

继续完善，希望这个控件可以变成轮子被更多的人使用。

效果图

效果图

改进

  1. 改变使用方式，现在可以直接继承SwipeDialog使用，更加方便。并且和系统Dialog特性保持一致，比如设置Dialog的显示、取消、关闭监听器，设置可取消、可点击窗口以外区域取消等等。
  2. 增强适用性，SwipeDialog的布局支持ListView、ScrollView、设置了MovementMethod的长TextView等可滑动的视图，并与Dialog本身的滑动不冲突。解决办法是，当判定出用户有滑动行为的时候，去判断ListView、ScrollView、长TextView等可滑动的视图是不是存在并可滑动，如果是则把整个手势交给它们处理，如果不是则截获整个手势。
  3. 优化体验，解决在我只是想点击Dialog上面某个按钮的时候，Dialog也出现了移动的问题。解决办法很简单，只有在用户手指移动距离超过touchSlop的时候，我才移动Dialog，并且将此时的Y坐标作为downY。

TODO

  1. 解决调用高版本API问题，比如public void setTranslationY (float translationY) （Added in API level 11）

Demo

Github

源码

  1. public class SwipeDialog extends Dialog {
  3.     private DialogContainer container;
  4.     private boolean cancel;
  6.     public SwipeDialog(Context context) {
  7.         super(context);
  8.         init();
  9.     }
  11.     public SwipeDialog(Context context, int theme) {
  12.         super(context, theme);
  13.         init();
  14.     }
  16.     protected SwipeDialog(Context context, boolean cancelable, OnCancelListener cancelListener) {
  17.         super(context, cancelable, cancelListener);
  18.         init();
  19.     }
  21.     private void init() {
  22.         final Window window = getWindow();
  23.         window.requestFeature(Window.FEATURE_NO_TITLE);
  24.         window.addFlags(WindowManager.LayoutParams.FLAG_HARDWARE_ACCELERATED);
  25.         getWindow().clearFlags(WindowManager.LayoutParams.FLAG_DIM_BEHIND);
  26.         window.setBackgroundDrawable(new ColorDrawable(Color.TRANSPARENT));
  27.         window.getAttributes().windowAnimations = 0;
  29.         container = new DialogContainer(getContext());
  30.         container.setSwipeListener(new DialogContainer.SwipeListener() {
  31.             @Override
  32.             public void onFallIn() {
  33.             }
  35.             @Override
  36.             public void onRiseOut() {
  37.                 if (cancel) {
  38.                     SwipeDialog.super.cancel();
  39.                     cancel = false;
  40.                 } else {
  41.                     SwipeDialog.super.dismiss();
  42.                 }
  43.             }
  45.             @Override
  46.             public void onFallOut() {
  47.                 SwipeDialog.super.dismiss();
  48.             }
  50.             @Override
  51.             public void onRecover() {
  52.             }
  54.             @Override
  55.             public void onTouchOutside() {
  56.                 cancel = true;
  57.             }
  58.         });
  59.     }
  62.     @Override
  63.     public void setContentView(int layoutResID) {
  64.         View dialogView = LayoutInflater.from(getContext()).inflate(layoutResID, container, false);
  65. //        container.setDialogView(dialogView);
  66. //        ViewGroup.LayoutParams layoutParams = new ViewGroup.LayoutParams(getWidth(), getHeight());
  67. //        super.setContentView(container, layoutParams);
  68.         setContentView(dialogView, null);
  69.     }
  71.     @Override
  72.     public void setContentView(View view) {
  73.         setContentView(view, null);
  74.     }
  76.     @Override
  77.     public void setContentView(View view, ViewGroup.LayoutParams params) {
  78.         container.removeAllViews();
  79.         container.addDialogView(view);
  80.         ViewGroup.LayoutParams layoutParams = new ViewGroup.LayoutParams(getWidth(), getHeight());
  81.         super.setContentView(container, layoutParams);
  82.     }
  83. //
  84. //    /**
  85. //     * Sets whether this dialog is canceled when touched outside the window's
  86. //     * bounds. If setting to true, the dialog is set to be cancelable if not
  87. //     * already set.
  88. //     *
  89. //     * @param cancel Whether the dialog should be canceled when touched outside
  90. //     *            the window.
  91. //     */
  92. //    public void setCanceledOnTouchOutside(boolean cancel) {
  93. //        if (cancel && !mCancelable) {
  94. //            mCancelable = true;
  95. //        }
  96. //
  97. //        mWindow.setCloseOnTouchOutside(cancel);
  98. //    }
  99. //
  100.     @Override
  101.     public void setCanceledOnTouchOutside(boolean cancel) {
  102.         super.setCanceledOnTouchOutside(cancel);
  103.         container.setCanceledOnTouchOutside(cancel);
  104.     }
  106.     @Override
  107.     public void show() {
  108.         super.show();
  109.         container.show();
  110.     }
  112.     @Override
  113.     public void dismiss() {
  114.         container.riseOut();
  115.     }
  117.     @Override
  118.     public void cancel() {
  119.         cancel = true;
  120.         container.riseOut();
  121.     }
  123.     public void setChangeDimEnabled(boolean changeDimEnabled) {
  124.         container.setChangeDimEnabled(changeDimEnabled);
  125.     }
  127.     public int getWidth() {
  128.         return getContext().getResources().getDisplayMetrics().widthPixels;
  129.     }
  131.     public int getHeight() {
  132.         return getContext().getResources().getDisplayMetrics().heightPixels - getStatusBarHeight();
  133.     }
  135.     public int getStatusBarHeight() {
  136.         int result = 0;
  137.         int resourceId = getContext().getResources().getIdentifier("status_bar_height", "dimen", "android");
  138.         if (resourceId > 0) {
  139.             result = getContext().getResources().getDimensionPixelSize(resourceId);
  140.         }
  141.         return result;
  142.     }
  143. }
  1. public class DialogContainer extends FrameLayout {
  3.     private boolean handleByChild;
  4.     private View targetView;
  7.     private enum AnimateType {FALL_IN, RECOVER, RISE_OUT, FALL_OUT}
  9.     private static final float MAX_DIM = 0.5F;
  10.     private float currDim;
  11.     private boolean changeDimEnabled = true;
  13.     private boolean canceledOnTouchOutside;
  14.     private boolean touchOutside;
  16.     private View dialogView;
  18.     private float downY;
  19.     private float lastY;
  20.     private int translationYTopBoundary;
  21.     private int translationYBottomBoundary;
  22.     private int translationYMax;
  24.     private boolean animating;
  25.     private boolean handleBySelf;
  27.     private int touchSlop;
  28.     private int flingVelocityThreshold;
  29.     private VelocityTracker velocityTracker;
  31.     private SwipeListener swipeListener;
  33.     public DialogContainer(Context context) {
  34.         super(context);
  35.         init();
  36.     }
  38.     public DialogContainer(Context context, AttributeSet attrs) {
  39.         super(context, attrs);
  40.         init();
  41.     }
  43.     public DialogContainer(Context context, AttributeSet attrs, int defStyleAttr) {
  44.         super(context, attrs, defStyleAttr);
  45.         init();
  46.     }
  48.     private void init() {
  49.         ViewConfiguration viewConfiguration = ViewConfiguration.get(getContext());
  50.         int minFlingVelocity = viewConfiguration.getScaledMinimumFlingVelocity();
  51.         int maxFlingVelocity = viewConfiguration.getScaledMaximumFlingVelocity();
  52.         flingVelocityThreshold = (minFlingVelocity + maxFlingVelocity) / 5;
  53.         touchSlop = viewConfiguration.getScaledTouchSlop();
  55.         setVisibility(INVISIBLE);
  57.     }
  59.     public void addDialogView(View dialogView) {
  60.         this.dialogView = dialogView;
  61.         FrameLayout.LayoutParams params = (LayoutParams) dialogView.getLayoutParams();
  62.         if (params == null) {
  63.             params = generateDefaultLayoutParams();
  64.         }
  65.         if (params.width == LayoutParams.MATCH_PARENT) {
  66.             params.width = LayoutParams.WRAP_CONTENT;
  67.         }
  68.         if (params.height == LayoutParams.MATCH_PARENT) {
  69.             params.height = LayoutParams.WRAP_CONTENT;
  70.         }
  71.         params.gravity = Gravity.CENTER;
  72.         addView(dialogView, params);
  73.     }
  76.     public void show() {
  77.         getViewTreeObserver().addOnPreDrawListener(new ViewTreeObserver.OnPreDrawListener() {
  78.             @Override
  79.             public boolean onPreDraw() {
  80.                 translationYTopBoundary = -(DialogContainer.this.dialogView.getTop() + DialogContainer.this.dialogView.getBottom()) / 2;
  81.                 translationYBottomBoundary = -translationYTopBoundary;
  82.                 translationYMax = DialogContainer.this.dialogView.getBottom();
  84.                 dialogView.setTranslationY(-dialogView.getBottom());
  85.                 if (!changeDimEnabled) {
  86.                     setDim(MAX_DIM);
  87.                 }
  88.                 setVisibility(VISIBLE);
  90.                 fallIn();
  91.                 getViewTreeObserver().removeOnPreDrawListener(this);
  92.                 return true;
  93.             }
  94.         });
  95.         invalidate();
  96.     }
  98.     @Override
  99.     protected void onAttachedToWindow() {
  100.         super.onAttachedToWindow();
  101.         velocityTracker = VelocityTracker.obtain();
  102.     }
  104.     @Override
  105.     protected void onDetachedFromWindow() {
  106.         super.onDetachedFromWindow();
  107.         velocityTracker.clear();
  108.     }
  110.     @Override
  111.     public boolean dispatchTouchEvent(MotionEvent ev) {
  112.         if (animating) {
  113.             return false;
  114.         }
  115.         switch (ev.getAction()) {
  116.             case MotionEvent.ACTION_DOWN:
  117.                 return onDown(ev);
  118.             case MotionEvent.ACTION_MOVE:
  119.                 return onMove(ev);
  120.             case MotionEvent.ACTION_CANCEL:
  121.             case MotionEvent.ACTION_UP:
  122.                 return onEnd(ev);
  123.         }
  124.         return super.dispatchTouchEvent(ev);
  125.     }
  127.     private boolean onDown(MotionEvent ev) {
  128.         velocityTracker.clear();
  129.         velocityTracker.addMovement(ev);
  131.         Rect dialogHitRect = new Rect();
  132.         dialogView.getHitRect(dialogHitRect);
  133.         touchOutside = !dialogHitRect.contains(((int) ev.getX()), ((int) ev.getY()));
  135.         targetView = getTargetView(this, MotionEvent.obtain(ev));
  137.         downY = ev.getY();
  138.         lastY = ev.getY();
  139.         super.dispatchTouchEvent(ev);
  140.         return true;
  141.     }
  143.     private boolean onMove(MotionEvent ev) {
  144.         velocityTracker.addMovement(ev);
  146.         if (downY == -1) {
  147.             downY = ev.getY();
  148.         }
  150.         if (lastY == -1) {
  151.             lastY = ev.getY();
  152.         }
  154.         final float dy = ev.getY() - downY;
  156.         if (handleBySelf) {
  157.             dialogView.setTranslationY(dy);
  158.             if (changeDimEnabled) {
  159.                 float newDim = MAX_DIM * (1 - Math.min(1, Math.abs(dy / translationYMax)));
  160.                 setDim(newDim);
  161.             }
  162.             return true;
  163.         }
  165.         if (handleByChild) {
  166.             super.dispatchTouchEvent(ev);
  167.             return true;
  168.         }
  170.         if (Math.abs(dy) >= touchSlop) {
  171.             if (touchOutside || !targetViewCanScroll(ev.getY() - lastY)) {
  172.                 handleBySelf = true;
  173.                 handleByChild = false;
  174.                 downY = ev.getY();
  175.                 dispatchCancelEventToChild(ev);
  176.                 return true;
  177.             } else {
  178.                 handleByChild = true;
  179.                 handleBySelf = false;
  180.                 super.dispatchTouchEvent(ev);
  181.                 return true;
  182.             }
  183.         }
  185.         lastY = ev.getY();
  186.         super.dispatchTouchEvent(ev);
  187.         return true;
  188.     }
  190.     private boolean onEnd(MotionEvent ev) {
  191.         velocityTracker.addMovement(ev);
  192.         velocityTracker.computeCurrentVelocity(1000);
  193.         float velocityY = velocityTracker.getYVelocity();
  194.         if (handleBySelf) {
  195.             if (Math.abs(velocityY) < flingVelocityThreshold) {
  196.                 if (dialogView.getTranslationY() < translationYTopBoundary) {//[-infinite, -dialogTop)
  197.                     riseOut();
  198.                 } else if (dialogView.getTranslationY() < translationYBottomBoundary) {//[-dialog, bottom)
  199.                     recover();
  200.                 } else {
  201.                     fallOut();
  202.                 }
  203.             } else {
  205.                 if (velocityY < 0) {
  206.                     riseOut();
  207.                 } else {
  208.                     fallOut();
  209.                 }
  210.             }
  211.         }
  212.         reset();
  213.         return super.dispatchTouchEvent(ev);
  214.     }
  217.     private void reset() {
  218.         downY = -1;
  219.         lastY = -1;
  220.         handleBySelf = false;
  221.         handleByChild = false;
  222.     }
  225.     private boolean targetViewCanScroll(float dy) {
  226.         if (targetView instanceof AdapterView<?>) {
  227.             AdapterView<?> adapterView = (AdapterView<?>) targetView;
  228.             if (adapterView.getCount() == 0
  229.                     || (adapterView.getLastVisiblePosition() == adapterView.getCount() - 1
  230.                     && adapterView.getChildAt(adapterView.getChildCount() - 1).getBottom() <= adapterView.getHeight()
  231.                     && dy < 0)
  232.                     || (adapterView.getFirstVisiblePosition() == 0
  233.                     && adapterView.getChildAt(0).getTop() >= 0)
  234.                     && dy > 0) {
  235.                 return false;
  236.             } else {
  237.                 return true;
  238.             }
  239.         }
  241.         if ((targetView instanceof ScrollView)
  242.                 && ((ScrollView) targetView).getChildCount() > 0
  243.                 && ((ScrollView) targetView).getChildAt(0).getMeasuredHeight() > targetView.getHeight()
  244.                 && !((targetView.getScrollY() <= 0 && dy > 0) || (targetView.getScrollY() >= ((ScrollView) targetView).getChildAt(0).getMeasuredHeight() - targetView.getHeight() && dy < 0))) {
  245.             return true;
  246.         }
  248.         if (targetView instanceof TextView
  249.                 && ((TextView) targetView).getMovementMethod() != null
  250.                 && ((TextView) targetView).getLayout().getHeight() > targetView.getHeight()
  251.                 && !((targetView.getScrollY() <= 0 && dy > 0) || (targetView.getScrollY() >= ((TextView) targetView).getLayout().getHeight() - targetView.getHeight() && dy < 0))) {
  252.             return true;
  253.         }
  255.         return false;
  256.     }
  258.     private View getTargetView(View view, MotionEvent event) {
  259.         if (view instanceof AdapterView<?> || view instanceof ScrollView) {
  260.             event.recycle();
  261.             return view;
  262.         } else if (view instanceof ViewGroup) {
  263.             event.offsetLocation(-view.getLeft(), -view.getTop());//do not swap them, tears
  264.             ViewGroup viewGroup = (ViewGroup) view;
  265.             for (int i = 0; i < viewGroup.getChildCount(); i++) {
  266.                 View child = viewGroup.getChildAt(i);
  267.                 Rect childHitRect = new Rect();
  268.                 child.getHitRect(childHitRect);
  269.                 if (childHitRect.contains(((int) event.getX()), ((int) event.getY()))) {
  270. //                    event.offsetLocation(-child.getTop(), -child.getLeft());
  271. //                    event.transform(child.getInverseMatrix());
  272.                     return getTargetView(child, event);
  273.                 }
  274.             }
  275.             event.recycle();
  276.             return view;
  277.         } else {
  278.             event.recycle();
  279.             return view;
  280.         }
  281.     }
  283.     private void dispatchDownEventToChild(MotionEvent ev) {
  284.         MotionEvent cancelEvent = MotionEvent.obtain(ev);
  285.         cancelEvent.setAction(MotionEvent.ACTION_DOWN);
  286.         super.dispatchTouchEvent(cancelEvent);
  287.         cancelEvent.recycle();
  288.     }
  290.     private void dispatchCancelEventToChild(MotionEvent ev) {
  291.         MotionEvent cancelEvent = MotionEvent.obtain(ev);
  292.         cancelEvent.setAction(MotionEvent.ACTION_CANCEL);
  293.         super.dispatchTouchEvent(cancelEvent);
  294.         cancelEvent.recycle();
  295.     }
  297.     public void fallIn() {
  298.         animate(0, MAX_DIM, AnimateType.FALL_IN);
  299.     }
  301.     private void recover() {
  302.         animate(0, MAX_DIM, AnimateType.RECOVER);
  303.     }
  305.     public void riseOut() {
  306.         animate(-dialogView.getBottom(), 0, AnimateType.RISE_OUT);
  307.     }
  309.     private void fallOut() {
  310.         animate(getHeight() - dialogView.getTop(), 0, AnimateType.FALL_OUT);
  311.     }
  313.     private void animate(float endTranslationY, float endDim, final AnimateType animateType) {
  314.         float translationYDelta = endTranslationY - dialogView.getTranslationY();
  315.         long duration = Math.min(Math.max((long) (Math.abs(translationYDelta) * 0.7F), 400), 600);
  316.         final float startDim = currDim;
  317.         final float dimDelta = endDim - startDim;
  318.         ValueAnimator animator = ValueAnimator.ofFloat(dialogView.getTranslationY(), endTranslationY);
  319.         animator.setDuration(duration);
  320.         animator.setInterpolator(new DecelerateInterpolator(1.6F));
  321.         animator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
  322.             @Override
  323.             public void onAnimationUpdate(ValueAnimator valueAnimator) {
  324.                 dialogView.setTranslationY((Float) valueAnimator.getAnimatedValue());
  325.                 if (changeDimEnabled) {
  326.                     setDim(startDim + dimDelta * valueAnimator.getAnimatedFraction());
  327.                 }
  328.             }
  329.         });
  330.         animator.addListener(new Animator.AnimatorListener() {
  331.             @Override
  332.             public void onAnimationStart(Animator animator) {
  333.                 animating = true;
  334.             }
  336.             @Override
  337.             public void onAnimationEnd(Animator animator) {
  338.                 animating = false;
  339.                 if (swipeListener != null) {
  340.                     switch (animateType) {
  341.                         case FALL_IN:
  342.                             swipeListener.onFallIn();
  343.                             break;
  344.                         case RECOVER:
  345.                             swipeListener.onRecover();
  346.                             break;
  347.                         case RISE_OUT:
  348.                             swipeListener.onRiseOut();
  349.                             break;
  350.                         case FALL_OUT:
  351.                             swipeListener.onFallOut();
  352.                             break;
  353.                     }
  354.                 }
  355.             }
  357.             @Override
  358.             public void onAnimationCancel(Animator animator) {
  360.             }
  362.             @Override
  363.             public void onAnimationRepeat(Animator animator) {
  365.             }
  366.         });
  367.         animator.start();
  369.     }
  371.     private void setDim(float dim) {
  372.         setBackgroundColor(Color.argb((int) (255 * dim), 0, 0, 0));
  373.         currDim = dim;
  374.     }
  376.     public void setDialogView(View dialogView) {
  377.         this.dialogView = dialogView;
  378.     }
  380.     public void setSwipeListener(SwipeListener swipeListener) {
  381.         this.swipeListener = swipeListener;
  382.     }
  384.     public interface SwipeListener {
  385.         void onFallIn();
  387.         void onRiseOut();
  389.         void onFallOut();
  391.         void onRecover();
  393.         void onTouchOutside();
  394.     }
  396.     public void setChangeDimEnabled(boolean changeDimEnabled) {
  397.         this.changeDimEnabled = changeDimEnabled;
  398.     }
  400.     public void setCanceledOnTouchOutside(boolean cancel) {
  401.         canceledOnTouchOutside = cancel;
  402.         if (canceledOnTouchOutside) {
  403.             setOnClickListener(new OnClickListener() {
  404.                 @Override
  405.                 public void onClick(View v) {
  406.                     if (touchOutside) {
  407.                         if (swipeListener != null) {
  408.                             swipeListener.onTouchOutside();
  409.                         }
  410.                         riseOut();
  411.                     }
  412.                 }
  413.             });
  414.         }
  415.     }
  418. }
添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注