android 根据手势滚动菜单 SlidingMenu

最新推荐文章于 2024-08-14 11:20:14 发布
最新推荐文章于 2024-08-14 11:20:14 发布
阅读量150 收藏
点赞数
分类专栏： android 文章标签： android 滑动菜单
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012116089/article/details/88266543
版权

public class SlidingMenu extends RelativeLayout {

    private View mCenterView;
    private View mLeftView;
    private View mRightView;
    private RelativeLayout mBgShade;
    private int mScreenWidth;
    private int mScreenHeight;
    private Context mContext;
    private Scroller mScroller;
    private VelocityTracker mVelocityTracker;
    private int mTouchSlop;
    private float mLastMotionX;
    private float mLastMotionY;
    private static final int VELOCITY = 50;
    private boolean mIsBeingDragged = true;
    private boolean isCanSlideLeft = true;
    private boolean isCanSlideRight = false;
    private boolean isHasClickLeft = true;
    private boolean isHasClickRight = false;

    public SlidingMenu(Context context) {
        super(context);
        init(context);
    }

    private void init(Context context) {

        mContext = context;
        // 背景阴影
        mBgShade = new RelativeLayout(context);
        mScroller = new Scroller(getContext());
        mTouchSlop = ViewConfiguration.get(getContext()).getScaledTouchSlop();
        WindowManager windowManager = ((Activity) context).getWindow().getWindowManager();
        Display display = windowManager.getDefaultDisplay();
        mScreenWidth = display.getWidth();
        mScreenHeight = display.getHeight();
        LayoutParams bgParams = new LayoutParams(mScreenWidth, mScreenHeight);
        bgParams.addRule(RelativeLayout.CENTER_IN_PARENT);
        mBgShade.setLayoutParams(bgParams);

    }

    public SlidingMenu(Context context, AttributeSet attrs) {
        super(context, attrs);
        init(context);
    }

    public SlidingMenu(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
        init(context);
    }

    public void addViews(View left, View center, View right) {
        setLeftView(left);
        setRightView(right);
        setCenterView(center);
    }

    public void setLeftView(View view) {
        LayoutParams behindParams = new LayoutParams(LayoutParams.WRAP_CONTENT,
                LayoutParams.FILL_PARENT);
        addView(view, behindParams);
        mLeftView = view;
    }

    public void setRightView(View view) {
        LayoutParams behindParams = new LayoutParams(LayoutParams.WRAP_CONTENT,
                LayoutParams.FILL_PARENT);
        behindParams.addRule(RelativeLayout.ALIGN_PARENT_RIGHT);
        addView(view, behindParams);
        mRightView = view;
    }

    public void setCenterView(View view) {
        LayoutParams aboveParams = new LayoutParams(LayoutParams.FILL_PARENT,
                LayoutParams.FILL_PARENT);

        LayoutParams bgParams = new LayoutParams(mScreenWidth, mScreenHeight);
        bgParams.addRule(RelativeLayout.CENTER_IN_PARENT);

        View bgShadeContent = new View(mContext);
        bgShadeContent.setBackgroundDrawable(getResources().getDrawable(R.drawable.shade_bg));
        mBgShade.addView(bgShadeContent, bgParams);

        addView(mBgShade, bgParams);

        addView(view, aboveParams);
        mCenterView = view;
        mCenterView.bringToFront();
    }

    @Override
    public void scrollTo(int x, int y) {
        super.scrollTo(x, y);
        postInvalidate();
    }

    @Override
    public void computeScroll() {
        if (!mScroller.isFinished()) {
            if (mScroller.computeScrollOffset()) {
                int oldX = mCenterView.getScrollX();
                int oldY = mCenterView.getScrollY();
                int x = mScroller.getCurrX();
                int y = mScroller.getCurrY();
                if (oldX != x || oldY != y) {
                    if (mCenterView != null) {
                        mCenterView.scrollTo(x, y);
                        if (x < 0)
                            mBgShade.scrollTo(x + 20, y);// 背景阴影右偏
                        else
                            mBgShade.scrollTo(x - 20, y);// 背景阴影左偏
                    }
                }
                invalidate();
            }
        }
    }

    private boolean canSlideLeft = true;
    private boolean canSlideRight = false;

    public void setCanSliding(boolean left, boolean right) {
        canSlideLeft = left;
        canSlideRight = right;
    }

    /* 拦截touch事件 */
    @Override
    public boolean onInterceptTouchEvent(MotionEvent ev) {
        final int action = ev.getAction();
        final float x = ev.getX();
        final float y = ev.getY();
        switch (action) {
            case MotionEvent.ACTION_DOWN:
                mLastMotionX = x;
                mLastMotionY = y;
                mIsBeingDragged = false;
                if (canSlideLeft) {
                    mLeftView.setVisibility(View.VISIBLE);
                    if (null != mRightView) {
                        mRightView.setVisibility(View.INVISIBLE);
                    }
                }
                if (canSlideRight) {
                    mLeftView.setVisibility(View.INVISIBLE);
                    if (null != mRightView) {
                        mRightView.setVisibility(View.VISIBLE);
                    }
                }
                break;

            case MotionEvent.ACTION_MOVE:
                final float dx = x - mLastMotionX;
                final float xDiff = Math.abs(dx);
                final float yDiff = Math.abs(y - mLastMotionY);
                if (xDiff > mTouchSlop && xDiff > yDiff) {
                    if (canSlideLeft) {
                        float oldScrollX = mCenterView.getScrollX();
                        if (oldScrollX < 0) {
                            mIsBeingDragged = true;
                            mLastMotionX = x;
                        } else {
                            if (dx > 0) {
                                mIsBeingDragged = true;
                                mLastMotionX = x;
                            }
                        }

                    } else if (canSlideRight) {
                        float oldScrollX = mCenterView.getScrollX();
                        if (oldScrollX > 0) {
                            mIsBeingDragged = true;
                            mLastMotionX = x;
                        } else {
                            if (dx < 0) {
                                mIsBeingDragged = true;
                                mLastMotionX = x;
                            }
                        }
                    }
                }
                break;
        }
        return mIsBeingDragged;
    }

    /* 处理拦截后的touch事件 */
    @Override
    public boolean onTouchEvent(MotionEvent ev) {
        if (mVelocityTracker == null) {
            mVelocityTracker = VelocityTracker.obtain();
        }
        mVelocityTracker.addMovement(ev);

        final int action = ev.getAction();
        final float x = ev.getX();
        final float y = ev.getY();

        switch (action) {
            case MotionEvent.ACTION_DOWN:
                if (!mScroller.isFinished()) {
                    mScroller.abortAnimation();
                }
                mLastMotionX = x;
                mLastMotionY = y;
                if (mCenterView.getScrollX() == -getMenuViewWidth()
                        && mLastMotionX < getMenuViewWidth()) {
                    return false;
                }

                if (mCenterView.getScrollX() == getDetailViewWidth()
                        && mLastMotionX > getMenuViewWidth()) {
                    return false;
                }

                break;
            case MotionEvent.ACTION_MOVE:
                if (mIsBeingDragged) {
                    final float deltaX = mLastMotionX - x;
                    mLastMotionX = x;
                    float oldScrollX = mCenterView.getScrollX();
                    float scrollX = oldScrollX + deltaX;
                    if (canSlideLeft) {
                        if (scrollX > 0)
                            scrollX = 0;
                    }
                    if (canSlideRight) {
                        if (scrollX < 0)
                            scrollX = 0;
                    }
                    if (deltaX < 0 && oldScrollX < 0) { // left view
                        final float leftBound = 0;
                        final float rightBound = -getMenuViewWidth();
                        if (scrollX > leftBound) {
                            scrollX = leftBound;
                        } else if (scrollX < rightBound) {
                            scrollX = rightBound;
                        }
                    } else if (deltaX > 0 && oldScrollX > 0) { // right view
                        final float rightBound = getDetailViewWidth();
                        final float leftBound = 0;
                        if (scrollX < leftBound) {
                            scrollX = leftBound;
                        } else if (scrollX > rightBound) {
                            scrollX = rightBound;
                        }
                    }
                    if (mCenterView != null) {
                        mCenterView.scrollTo((int) scrollX, mCenterView.getScrollY());
                        if (scrollX < 0)
                            mBgShade.scrollTo((int) scrollX + 20, mCenterView.getScrollY());
                        else
                            mBgShade.scrollTo((int) scrollX - 20, mCenterView.getScrollY());
                    }
                }
                break;
            case MotionEvent.ACTION_CANCEL:
            case MotionEvent.ACTION_UP:
                if (mIsBeingDragged) {
                    final VelocityTracker velocityTracker = mVelocityTracker;
                    velocityTracker.computeCurrentVelocity(100);
                    float xVelocity = velocityTracker.getXVelocity();// 滑动的速度
                    int oldScrollX = mCenterView.getScrollX();
                    int dx = 0;
                    if (oldScrollX <= 0 && canSlideLeft) {// left view
                        if (xVelocity > VELOCITY) {
                            dx = -getMenuViewWidth() - oldScrollX;
                        } else if (xVelocity < -VELOCITY) {
                            dx = -oldScrollX;
                            if (isHasClickLeft) {
                                isHasClickLeft = false;
                                setCanSliding(isCanSlideLeft, isCanSlideRight);
                            }
                        } else if (oldScrollX < -getMenuViewWidth() / 2) {
                            dx = -getMenuViewWidth() - oldScrollX;
                        } else if (oldScrollX >= -getMenuViewWidth() / 2) {
                            dx = -oldScrollX;
                            if (isHasClickLeft) {
                                isHasClickLeft = false;
                                setCanSliding(isCanSlideLeft, isCanSlideRight);
                            }
                        }
                    }
                    if (oldScrollX >= 0 && canSlideRight) {
                        if (xVelocity < -VELOCITY) {
                            dx = getDetailViewWidth() - oldScrollX;
                        } else if (xVelocity > VELOCITY) {
                            dx = -oldScrollX;
                            if (isHasClickRight) {
                                isHasClickRight = false;
                                setCanSliding(isCanSlideLeft, isCanSlideRight);
                            }
                        } else if (oldScrollX > getDetailViewWidth() / 2) {
                            dx = getDetailViewWidth() - oldScrollX;
                        } else if (oldScrollX <= getDetailViewWidth() / 2) {
                            dx = -oldScrollX;
                            if (isHasClickRight) {
                                isHasClickRight = false;
                                setCanSliding(isCanSlideLeft, isCanSlideRight);
                            }
                        }
                    }
                    smoothScrollTo(dx);
                }
                break;
        }
        return true;
    }

    private int getMenuViewWidth() {
        if (mLeftView == null) {
            return 0;
        }
        return mLeftView.getWidth();
    }

    private int getDetailViewWidth() {
        if (mRightView == null) {
            return 0;
        }
        return mRightView.getWidth();
    }

    private void smoothScrollTo(int dx) {
        int duration = 500;
        int oldScrollX = mCenterView.getScrollX();
        mScroller.startScroll(oldScrollX, mCenterView.getScrollY(), dx, mCenterView.getScrollY(),
                duration);
        invalidate();
    }

    public boolean isCenterViewShow() {
        int scrollX = mCenterView.getScrollX();
        if (scrollX == 0) {
            return true;
        }
        return false;
    }

    /*
     * 显示左侧边的view
     */
    public void showLeftView() {
        int menuWidth = mLeftView.getWidth();
        int oldScrollX = mCenterView.getScrollX();
        if (oldScrollX == 0) {
            mLeftView.setVisibility(View.VISIBLE);
            if (null != mRightView) {
                mRightView.setVisibility(View.INVISIBLE);
            }
            smoothScrollTo(-menuWidth);
            isCanSlideLeft = canSlideLeft;
            isCanSlideRight = canSlideRight;
            isHasClickLeft = true;
            setCanSliding(true, false);
        } else if (oldScrollX == -menuWidth) {
            smoothScrollTo(menuWidth);
            if (isHasClickLeft) {
                isHasClickLeft = false;
                setCanSliding(isCanSlideLeft, isCanSlideRight);
            }
        }
    }

    /* 显示右侧边的view */
    public void showRightView() {
        int menuWidth = getDetailViewWidth();
        int oldScrollX = mCenterView.getScrollX();
        if (oldScrollX == 0) {
            mLeftView.setVisibility(View.INVISIBLE);
            if (null != mRightView) {
                mRightView.setVisibility(View.VISIBLE);
            }
            smoothScrollTo(menuWidth);
            isCanSlideLeft = canSlideLeft;
            isCanSlideRight = canSlideRight;
            isHasClickRight = true;
            setCanSliding(false, true);
        } else if (oldScrollX == menuWidth) {
            smoothScrollTo(-menuWidth);
            if (isHasClickRight) {
                isHasClickRight = false;
                setCanSliding(isCanSlideLeft, isCanSlideRight);
            }
        }
    }

}
 

 

activity初始化:

protected void initView() {
        slidingMenuView = (MainSlidingMenuView) findViewById(R.id.slidingMenuView);
        slidingMenuView.setMenuView(getLayoutInflater().inflate(
                R.layout.function_grid_frame, null));
        slidingMenuView.setContentView(getLayoutInflater().inflate(
                R.layout.content_container, null));
    }

 

public void showLeft() {
        slidingMenuView.showMenuView();
    }

 

主页面：

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:background="@android:color/white"
    >
    
    
     <widget.MainSlidingMenuView
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:id="@+id/slidingMenuView"
         >
    </widget.MainSlidingMenuView>
    
</RelativeLayout>

 

菜单布局：

<?xml version="1.0" encoding="utf-8"?>
<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/menu_container"
    android:layout_width="match_parent"
    android:layout_height="match_parent" >
</FrameLayout>

 

页面内容部分布局：

<?xml version="1.0" encoding="utf-8"?>
<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:id="@+id/content_container"
    >
</FrameLayout>

 

菜单和内容部分用fragment填充

zh_xuan
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android实现滑动菜单—SlidingMenu
Ryan's zone
05-09 6736
近期在整理一套Android开发包RTCommon，主要集成一些工具类封装成公共API，同时集成一些第三方控件或是工具包，力图提高Android开发效率和速度，目前编写和集成工作正在逐步进行中，待公共开发包完成时，大家可以使用我的工程作为依赖工程引入自己的项目，使用我封装的一些工具类来提高自己的开发效率。今天要说明的一个第三方控件滑动菜单也是我即将要添加到公共开发包中的一个控件。本Demo是借助j
android 滑动菜单SlidingMenu的实现
热门推荐
jj120522的专栏
10-24 8万+
首先我们看下面视图：        这种效果大家都不陌生，网上好多都说是仿人人网的，估计人家牛逼出来的早吧，我也参考了一一些例子，实现起来有三种方法，我下面简单介绍下： 方法一：其实就是对GestureDetector手势的应用及布局文件的设计. 布局文件main.xml    采用RelativeLayout布局. <RelativeLayout xmlns:android="h
Android 自定义底部上拉控件的实现方法
01-05
前言 又到了新的一月，今天提供一个Android自定义底部上拉布局的实现，起因是自己在项目中需要实现这样一个控件，干脆自己写一个练练手。 写完了觉得能想到的需求都基本有了（可能会有其它需求，不过基本上改吧改吧就行了），又花了一点时间直接放到了Github上托管，希望能给您一些参考价值： SlideBottomLayout-Android 简单易上手的Android底部上拉控件 先看一下实现效果： 分析一下这种控件的基本需求有以下几种： 1.有一个部分是能够作为把手（就是图中的handle，）进行拖拽的，这部分高度是暴露在界面中的 -> 需要实现：Handle按钮 * 特殊需求特殊分析，比如让
SlidingDrawerLayout上下滑动的菜单控件
ljj1396847724的博客
06-24 4409
有一种控件需求，通过上下滑动来打开上下菜单。这个控件要求自动打开上下两个菜单，而且还要随着手势（注意：多触点）上下滑动菜单。之前Android系统有提供一个叫SlidingDrawer（完整路径：android.widget.SlidingDrawer）的控件，似乎有类似的效果，但是它不仅过时了，而且远远达不到我提出的要求。为了满足这个需求，我设计了一款自名为SlidingDrawerLayout的控件。
Android滑动菜单框架完全解析，教你如何一分钟实现滑动菜单特效
runfeel
04-02 442
转载请注明出处：http://blog.csdn.net/sinyu890807/article/details/8744400 之前我向大家介绍了史上最简单的滑动菜单的实现方式，相信大家都还记得。如果忘记了其中的实现原理或者还没看过的朋友，请先去看一遍之前的文章Android滑动菜单特效实现，仿人人客户端侧滑效果，史上最简单的侧滑实现，因为我们今天要实现的滑动菜单框架也是基于同样的原理的。 ...
Android实现高德地图上拉,ScrollLayout：上拉滑动上滑拖出，类似高德地图百度地图抽屉拖拽效果...
weixin_33600376的博客
05-26 879
ScrollLayoutAbstract 摘要在ScrollView或者ListView里面使用ViewPager.支持手势上拉滑出,中途停顿,下滑退出页面,类似百度地图内场景抽屉拖拽效果效果Gif 动画 Similar 类似使用 Demo 下载APK体验Usage 使用方法Step 1Gradle 配置dependencies {compile 'com.yinglan.scrolllayo...
Android 自定义底部上拉控件的实现
却把清梅嗅的博客
09-01 6194
前言又到了新的一月，今天提供一个Android自定义底部上拉布局的实现，起因是自己在项目中需要实现这样一个控件，干脆自己写一个练练手。写完了觉得能想到的需求都基本有了（可能会有其它需求，不过基本上改吧改吧就行了），又花了一点时间直接放到了Github上托管，希望能给您一些参考价值：SlideBottomLayout-Android 简单易上手的Android底部上拉控件先看一下实现效果：分析一下这种
Android应用源码之SlidingMenu实现侧滑栏菜单.zip
10-14
本资源"Android应用源码之SlidingMenu实现侧滑栏菜单.zip"提供了一个使用SlidingMenu库实现这一功能的示例代码。SlidingMenu是一款流行的开源Android库，它允许开发者轻松地在他们的应用中添加这种交互式侧滑菜单。 ...
安卓SlidingMenu各种菜单侧滑菜单相关-Android如何实现多层次抽屉菜单.rar
07-29
在Android应用开发中，侧滑菜单（也称为抽屉菜单或Sliding Menu）是一种常见的设计模式，用于提供导航和访问应用程序的不同部分。Android中的多层次抽屉菜单是指可以在多个层级上展开和折叠的侧滑菜单，这通常适用于...
安卓SlidingMenu各种菜单侧滑菜单相关-SlidingMenu侧滑菜单栏.zip
07-29
此外，还要考虑手势冲突，例如防止侧滑菜单与应用内的其他滑动手势（如滚动）产生冲突。 最后，虽然这个资料包可能没有经过全面测试，但作为学习材料，它提供了一种深入理解侧滑菜单实现机制的机会。通过阅读源码和...
Android应用源码SlidingMenu使用例子.rar
09-16
在实际项目中，你可以根据自己的需求对SlidingMenu进行自定义，比如改变滑动速度、菜单的透明度，或者添加自定义的滑动手势。理解并掌握SlidingMenu的使用，对于提升Android开发技能非常有帮助。
Android控件View打造完美的自定义侧滑菜单
08-31
虽然有许多第三方库如SlidingMenu和DrawerLayout可以实现这一效果，但理解如何自定义一个侧滑菜单可以帮助开发者更好地控制用户体验和性能。以下将详细介绍如何使用Android控件View来创建一个自定义的侧滑菜单。 **...
Android中实现滑动（拖动）的几种方法，玩转SlideMenu
Zeeeeeeee的博客
11-15 2712
潜水已久，看了CSDN上很多大牛的博客，学了不少东西，很钦佩这种无私奉献共享的精神。 自己平时有些笔记的习惯，虽然都是一些很基础的东西，最近安定了下来，整理一下复习复习，毕竟自己一个马大哈来着。。。各种健忘
【Android入门到项目实战-- 11.3】—— 实现可左右滑动切换页面的导航栏（ViewPager+TabLayout+Fragment）
张修宇的博客
05-20 2298
Android如何实现可左右滑动的导航栏，使用ViewPager+TabLayout+Fragment实现，在导航栏页面里加入左右滑动的导航栏。
Android 界面左右滑动切换
Scxioi0的博客
05-05 7992
Android 界面左右滑动切换 1.界面布局 <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" xmlns:tools="http://schemas.android.com/tools" android:layout_width="match_parent" android:layout_height="match_parent" android:orientat
android手势分析（应用界面左往右边滑动退出应用）
allen_xu_2012_new的博客
05-15 1720
其中，move状态下的 handleMoveEvent()是主要的处理逻辑：判断 x 轴的 offset 数值是否达到了阈值 mSwipeThreshold，从而 回调 BackCallback 事件 和当前视图的更新，可看出 NavigationBarEdgePanel 就是一个 自定义view，根据 控制器 传递过来的 MotionEvent 实现具体的UI 效果，并回传事件。备注：在PIXEL手机手势设置页面，关闭gesture navigation会回调。
Android 自定义标签控件
2401_84149882的博客
04-16 697
现在随着短视频，抖音，快手的流行NDK模块开发也显得越发重要，需要这块人才的企业也越来越多，随之学习这块的人也变多了，音视频的开发，往往是比较难的，而这个比较难的技术就是NDK里面的技术。音视频/高清大图片/人工智能/直播/抖音等等这年与用户最紧密，与我们生活最相关的技术一直都在寻找最终的技术落地平台，以前是windows系统，而现在则是移动系统了，移动系统中又是以Android占比绝大部分为前提，所以AndroidNDK技术已经是我们必备技能了。
Android逆向题解攻防世界-easy-apk
最新发布
u013170888的博客
08-14 127
魔改码表与标准码表参照对比，将加密字符串还原成标准码表编码的字符串，再标准base64解码即可。运行结果：flag{05397c42f9b6da593a3644162d36eb01}题目比较简单，就是一个改了码表的base64编码。
Jetpack Compose实战教程（六）
xiaoliluote的专栏
08-13 649
我们在写xml布局的时候，经常会用到android:margin属性，毕竟除了居中以外，固定位置的偏移就得用到margin，xml中我们使用margin来设置外边距，使用padding来设置内边距。但在compose中，没有了margin属性，只有一个padding，那么我们如何设置外边距和内边距呢？
自定义ViewGroup实现Android多风格SlidingMenu
"Android自定义ViewGroup打造各种风格的SlidingMenu" 在Android开发中，有时候系统提供的组件无法满足我们对用户界面的个性化需求，这时我们就需要自定义ViewGroup来实现特殊的功能。本篇文章主要讲解如何利用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值