android 简单滑动菜单之左右侧滑

最新推荐文章于 2024-07-22 08:52:45 发布
最新推荐文章于 2024-07-22 08:52:45 发布
阅读量1.3k 收藏
点赞数
文章标签： 滑动菜单 android slidingmenu
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wb694059179/article/details/11560949
版权

滑动菜单有很多，网上有很多的实现是借用gitHub上的开源代码，slidingmenu.实现价值很高，但是项目宠大，移植不是那么容易，今天介绍一种简单的侧滑。

主要分为，MainActivity(主体)，界面有三人fragment支撑，（LeftFragment,CenterFragmet,RightFragment）

正常显示为CenterFragment,左右需要LeftFragment和RihtFragment.

现在开始代码架构：

MainActivity的布如下

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="wrap_content"
    android:layout_height="match_parent"
    android:background="@drawable/bg_1"
    tools:context=".MainActivity" >

    <FrameLayout
        android:id="@+id/left_frame"
        android:layout_width="wrap_content"
        android:layout_height="match_parent" >
    </FrameLayout>

    <FrameLayout
        android:id="@+id/right_frame"
        android:layout_width="wrap_content"
        android:layout_height="match_parent"
        android:layout_alignParentRight="true" >
    </FrameLayout>

    <FrameLayout
        android:id="@+id/center_frame"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:background="@color/transparent" >
    </FrameLayout>

</RelativeLayout>

 

中间布局是关键因为需要包含一个Slider来支持左右滑动

<com.example.Slider xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:id="@+id/center_slider"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:background="@color/home_blue"
    tools:context=".MainActivity" >

<RelativeLayout>

..........这里自己写你自己的布局

</RelativeLayout>

</com.example.Slider>

 

LeftFragment的布局主要是正常布局，居左对齐，宽度为home_page_left_menu_width，固定宽度

RightFragment的布局主要是正常布局，居右对齐，宽度为home_page_Right_menu_width，固定宽度

接下来到核心Slider类的书写

public class Slider extends RelativeLayout {

    private int mTouchSlop;

    private float mLastMotionX, mLastMotionY;

    private int mState = 0;

    private int mLeftMenuWidth;

    private int mRightMenuWidth;

    private int mCurrentPosition = 0; // -1(left),0(center),1(right)

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

    private void init(Context context) {
        mCurrentPosition = 0;
        mLeftMenuWidth = context.getResources().getDimensionPixelSize(
                R.dimen.home_page_left_menu_width);

             DisplayMetrics metrics = new DisplayMetrics();
        ((MainActivity)context).getWindowManager().getDefaultDisplay().getMetrics(metrics);
        mRightMenuWidth = metrics.widthPixels     

        mState = ScrollState.DEFAULT;
        mTouchSlop = ViewConfiguration.get(context).getScaledTouchSlop();
    }

    private void calibrateView() {
        int currentX = getLeftMargin();
        if (currentX < 0) {
            ((MainActivity)getContext()).showRightView();
        } else if (currentX > 0) {
            ((MainActivity)getContext()).showLeftView();
        } else {
            ((MainActivity)getContext()).showCenterView();
        }
    }

    private boolean checkMoveState(int x, int y) {
        int dx = (int)(x - mLastMotionX);
        int deltaX = Math.abs(dx);
        int deltaY = Math.abs((int)(y - mLastMotionY));
        if (mState == ScrollState.DEFAULT) {
            if (deltaX > mTouchSlop && deltaX > deltaY) {
                if (dx > 0) {
                    mState = ScrollState.RIGHT;
                    mLastMotionX = x - mTouchSlop;
                } else {
                    mState = ScrollState.LEFT;
                    mLastMotionX = x + mTouchSlop;
                }
                calibrateView();
                return true;
            }
        }
        return false;
    }

    private int getLeftMargin() {
        FrameLayout.LayoutParams params = (FrameLayout.LayoutParams)getLayoutParams();
        return params.leftMargin;
    }

    @Override
    public boolean onInterceptTouchEvent(MotionEvent ev) {
        float x = ev.getX();
        float y = ev.getY();
        switch (ev.getAction()) {
        case MotionEvent.ACTION_DOWN: {
            mLastMotionX = x;
            mLastMotionY = y;
            break;
        }
        case MotionEvent.ACTION_MOVE: {
            return checkMoveState((int)x, (int)y);
        }
        case MotionEvent.ACTION_UP:
        case MotionEvent.ACTION_CANCEL: {
            mState = ScrollState.DEFAULT;
            break;
        }
        }
        return false;
    }

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        float x = event.getRawX();
        calibrateView();

        switch (event.getAction()) {
        case MotionEvent.ACTION_DOWN: {
            mLastMotionX = x;
            break;
        }
        case MotionEvent.ACTION_MOVE: {
            int dx = (int)(x - mLastMotionX);

            if (ScrollState.DEFAULT == mState) {
                if (dx > 0) {
                    mState = ScrollState.RIGHT;
                } else if (dx < 0) {
                    mState = ScrollState.LEFT;
                }
                return true;
            }
            mLastMotionX = x;

            int scrollX = dx + getLeftMargin();

            if (mCurrentPosition == 0) {
                // 中间位置上
                if (dx > 0) {
                    if (mState == ScrollState.RIGHT) {
                        // 不能出界
                        scrollX = Math.min(mLeftMenuWidth, scrollX);
                    } else if (mState == ScrollState.LEFT) {
                        scrollX = getLeftMargin();
                        mState = ScrollState.DEFAULT;
                    }
                } else if (dx < 0) {
                    if (mState == ScrollState.RIGHT) {
                        scrollX = getLeftMargin();
                        mState = ScrollState.DEFAULT;
                    } else if (mState == ScrollState.LEFT) {
                        scrollX = Math.max(-mRightMenuWidth, scrollX);
                    }
                }
            } else if (mCurrentPosition == -1) {
                // LeftView is shown
                if (dx > 0) {
                    // ---->
                    if (mState == ScrollState.RIGHT) {
                        scrollX = mLeftMenuWidth;
                    } else if (mState == ScrollState.LEFT) {
                        scrollX = Math.min(scrollX, mLeftMenuWidth);
                    }
                } else if (dx < 0) {
                    // <----
                    if (mState == ScrollState.RIGHT) {
                        scrollX = getLeftMargin();
                        mState = ScrollState.DEFAULT;
                    } else if (mState == ScrollState.LEFT) {
                        scrollX = Math.max(0, scrollX);
                    }
                }
            } else if (mCurrentPosition == 1) {
                // RightView is shown.
                if (dx > 0) {
                    // ---->
                    if (mState == ScrollState.RIGHT) {
                        scrollX = Math.min(0, scrollX);
                    } else if (mState == ScrollState.LEFT) {
                        scrollX = getLeftMargin();
                        mState = ScrollState.DEFAULT;

                    }
                } else if (dx < 0) {
                    // <-----
                    if (mState == ScrollState.RIGHT) {
                        scrollX = Math.max(-mRightMenuWidth, scrollX);
                    } else if (mState == ScrollState.LEFT) {
                        scrollX = -mRightMenuWidth;
                    }
                }

            }

            scrollTo(scrollX);
            break;
        }
        case MotionEvent.ACTION_UP:
        case MotionEvent.ACTION_CANCEL: {
            int currentX = getLeftMargin();
            final int currentPos = mCurrentPosition;
            if (currentPos == 0) {
                if (currentX > mTouchSlop) {
                    smoothScrollBy(mLeftMenuWidth - currentX);
                    mCurrentPosition = -1;
                } else if (currentX < -mTouchSlop) {
                    smoothScrollBy(-mRightMenuWidth - currentX);
                    mCurrentPosition = 1;
                } else {
                    smoothScrollBy(-currentX);
                    mCurrentPosition = 0;

                }
            } else if (currentPos == 1) {
                if (currentX > -mRightMenuWidth + mTouchSlop) {
                    smoothScrollBy(-currentX);
                    mCurrentPosition = 0;
                } else {
                    smoothScrollBy(-mRightMenuWidth - currentX);
                    mCurrentPosition = 1;
                }
            } else if (currentPos == -1) {

                if (currentX < mLeftMenuWidth - mTouchSlop) {
                    smoothScrollBy(-currentX);
                    mCurrentPosition = 0;
                } else {
                    smoothScrollBy(mLeftMenuWidth - currentX);
                    mCurrentPosition = -1;
                }
            }
            mState = ScrollState.DEFAULT;
            break;
        }
        }
        return true;

    }

    public void scrollTo(int x) {
        FrameLayout.LayoutParams params = (FrameLayout.LayoutParams)getLayoutParams();
        params.leftMargin = x;
        params.rightMargin = -x;
        params.gravity = Gravity.NO_GRAVITY;
        setLayoutParams(params);
        invalidate();
    }

    public void smoothScrollBy(int dx) {
        new SmoothMove().execute(dx);
    }

    public boolean onBackPressed() {
        if (mCurrentPosition == 0) {
            return false;
        }
        if (mCurrentPosition == -1) {
            smoothScrollBy(-mLeftMenuWidth);
        }
        if (mCurrentPosition == 1) {
            smoothScrollBy(mRightMenuWidth);
        }
        mCurrentPosition = 0;
        return true;
    }

    public void clickLeftButton() {
        if (mCurrentPosition == 0) {
            ((MainActivity)getContext()).showLeftView();
            smoothScrollBy(mLeftMenuWidth);
            mCurrentPosition = -1;
        } else {
            smoothScrollBy(-getLeftMargin());
            mCurrentPosition = 0;
        }
    }

    public void clickRightButton() {
        if (mCurrentPosition == 0) {
            ((MainActivity)getContext()).showRightView();
            smoothScrollBy(-mRightMenuWidth);
            mCurrentPosition = 1;
        } else {
            smoothScrollBy(-getLeftMargin());
            mCurrentPosition = 0;
        }
    }

    private class SmoothMove extends AsyncTask<Integer, Integer, Void> {

        private static final long SLEEP_TIME = 5;

        private static final int MOVE_SPEED = 30;

        @Override
        protected Void doInBackground(Integer... params) {
            int distance = params[0];
            int times = Math.abs(distance) / MOVE_SPEED;
            times = Math.max(1, times);

            int dis = distance / times;
            int total = 0;
            for (int i = 0; i < times - 1; i++) {
                publishProgress(dis);
                total += dis;
                try {
                    Thread.sleep(SLEEP_TIME);
                } catch (InterruptedException e) {
                }
            }

            // 最后一次自己移动,防止余数
            dis = distance - total;
            publishProgress(dis);

            return null;
        }

        @Override
        protected void onProgressUpdate(Integer... values) {
            super.onProgressUpdate(values);
            int scrollX = values[0] + getLeftMargin();
            scrollTo(scrollX);
        }

    }

    private class ScrollState {
        static final int DEFAULT = 0;

        static final int RIGHT = 1;

        static final int LEFT = -1;
    }

}

MainActivity加载这几个Fragment.

FragmentTransaction t = this.getSupportFragmentManager().beginTransaction();
        mLeftFragment = new LeftFragment();
        t.replace(R.id.left_frame, mLeftFragment);

        mRightFragment = new RightFragment();
        t.replace(R.id.right_frame, mRightFragment);

        mCenterFragment = new CenterFragment();
        t.replace(R.id.center_frame, mCenterFragment);

        t.commit();

 

这样一个左右滑动菜单的页面就完成了  另外中间CenterFrament可以增加两个按扭，分别点击可以达到相同的效果

Slider类的如上public void clickLeftButton() {}和public void clickRightButton() {}

大致辞思想就是这样，可以根据自己的实际情作相应修改。

 

 

 

 

 

 

飞上云端123
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【Android】侧滑菜单的实现方式
好记性不如烂笔头，用文档记录技术，方便自己和他人。
09-17 635
对于侧滑菜单的实现方式，一种比较标准化的实现方式是DrawerLayout + NavigationView的方式，该方式的实现过程可以看我的另一篇博客【Android】Material Design 之三 NavigationView 使用 。然而，DrawerLayout + NavigationView的侧滑实现有个缺点就是，菜单的布局是单一的，只有一个图标、一个标题，当我们想要实现丰富的菜...
利用DrawLayout和Fragment实现左右侧滑菜单
linda的专栏
05-27 2881
利用Fragment实现界面左右滑动后显示侧滑的菜单，效果图如下： 点击下方的左边按钮就会显示左边的侧滑按钮，向右滑动手势也可以打开左侧的侧滑菜单，同理右边的侧滑菜单也是同样的，具体结构如下： MainActivity extends FragmentActivity 3个XML布局文件 activity_main       中间主界面布局 left_men
android的左右侧滑菜单实现
热门推荐
小崔的博客
09-24 1万+
最近看了很多app应用都采用的是左右侧滑，比如网易新闻、凡客等这里也试着写一下侧滑首先看一下效果 然后给出xml布局代码<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android" xmlns:tools="http://schemas.android.com/tools" android:
Android 双侧侧滑菜单（主界面和菜单都会滑动）
高磊的专栏
11-14 3550
最近公司刚开始做一个项目视频分享，主界面菜单需要实现两侧都是侧滑菜单, 现在我想实现效果如360手机助手，下面菜单也会滚动。github上有开源项目SlidingMenu,但是导入时会报错，主要是需要依赖ActionBarSherLock,经过本人修改后好用的SlidingMenu地址：http://download.csdn.net/detail/gaolei1201/9259839
Android滑动菜单简单实现
qq_35647047的博客
05-03 1819
所谓的滑动菜单就是将一些菜单选项隐藏起来，而不是放置在主屏幕上，然后可以通过滑动的方式将菜单显示出来。如果全靠自己实现的话会非常的困难，幸运的是，谷歌提供了一个DrawerLayout控件假设我们要实现这样一个功能，点击一个导航按钮，展示滑动菜单&lt;android.support.v4.widget.DrawerLayout android:layout_width="matc...
Android侧滑菜单（最简）
洋大阔天的博客
02-18 695
作为新手，对于侧滑菜单的使用，当然也是用最简单的实现方式。 一样的，首先来讲一下侧滑菜单的原理，其实很简单，就是关于屏幕的触碰事件，监听手指的移动来判断是显示菜单栏还是显示主页面，所以只需要在主页面横着放两个布局（一个菜单布局和一个主页面布局）即可，然后进行判断！
Android仿人人客户端滑动菜单的侧滑菜单效果
01-04
人人客户端有一个特效还是挺吸引人的，在主界面手指向右滑动，就可以将菜单展示出来，而主...但其实这种效果并不难实现，因此我今天给大家带来的也是史上最简单的滑动菜单实现方案。 首先还是讲一下实现原理。在一个A
android 左右侧滑菜单（点击+左右滑动）
05-20
综上所述，实现一个“android 左右侧滑菜单（点击+左右滑动）”涉及到多个Android核心组件和技术，如`DrawerLayout`、`NavigationView`、手势检测和动画。通过合理的设计和编码，可以创建一个既美观又实用的侧滑菜单...
android实现左右侧滑菜单效果
08-29
对于菜单的数据，我们可以使用`ArrayAdapter`或自定义的`BaseAdapter`绑定到`ListView`，这样当用户滑动菜单时，就可以看到相应的列表项。 总结起来，Android实现左右侧滑菜单效果涉及的主要知识点包括： 1. 使用`...
Android 左右滑动菜单 DrawerLayout简单实现
05-13
非常简单地实现左右滑动菜单。 导航抽屉可以显示在屏幕的左右两侧，默认情况下是隐藏的，当用户用手指从边缘向另一侧滑动的时候，会在内容上方出现一个隐藏的面板，此时内容视图区域会变暗。当点击面板外部或者向原来的方向滑动的时候，导航抽屉就会消失。通常这个导航抽屉用来当作流行的侧滑菜单。 这个类就是DrawerLayout，该类位于V4包中。
Android利用滑动菜单框架实现滑动菜单效果
08-27
【Android滑动菜单框架实现详解】 在Android应用开发中，滑动菜单是一个常见的交互元素，它通常用于在主界面和侧边菜单之间切换。本文将详细介绍如何利用自定义的滑动菜单框架在Android中实现这一功能，使得在多个...
Android滑动优化高仿QQ6.0侧滑菜单（滑动优化）
09-02
之前的实现只是简单的可以显示和隐藏左侧的菜单，但是特别生硬，而且没有任何平滑的趋势，那么今天就来优化一下吧，加上平滑效果，而且可以根据手势滑动的方向来判断是否是显示和隐藏
Android 实现形态各异的双向侧滑菜单 自定义控件来袭
modabobo
10-08 173
转载请标明出处：http://blog.csdn.net/lmj623565791/article/details/39670935，本文出自：【张鸿洋的博客】 1、概述 关于自定义控件侧滑已经写了两篇了~~今天决定把之前的单向改成双向，当然了，单纯的改动之前的代码也没意思，今天不仅会把之前的单向改为双向，还会多添加一种侧滑效果，给大家带来若干种形态各异的双向侧滑菜单，不过请放心，代码会很简单~~...
android 滑动窗体使用方法,Android实现左右滑动效果的方法详解
weixin_30792221的博客
05-25 624
本示例演示在android中实现图片左右滑动效果。关于滑动效果，在android中用得比较多，本示例实现的滑动效果是使用viewflipper来实现的，当然也可以使用其它的view来实现。接下来就让我们开始实现这种效果。为了方便大家理解，我们先来看一下效果图：主要效果图如下图：接下来我们看一下程序结构图：mainactivity文件中代码：复制代码 代码如下:package com.andro...
Android实现左右滑动效果
游戏盒子
03-20 1682
利用Android的ViewFlapper和OnGestureListener实现图片的左右滑动功能，其中当图片播放到最后一张时，会切换到第一张图片，效果图如下： 1、设置布局文件activity_image_flipper.xml，其中使用到ViewFlipper控件，内容如下： <RelativeLayout xmlns:android="http://schemas.andro
android实现自定义RelativeLayout可拖动、缩放、旋转TextView
roll圈圈的博客
01-09 6506
因最近公司项目需求，需要做出一个在一张背景图上添加文字，文字可编辑如修改颜色、样式、字体、背景添加气泡等，也可对文字的位置进行修改，实现拖动、旋转、缩放等功能，类似于美图秀秀中文字的添加，最后可将背景图和文字联合生成一张图片，保存到相册中，自网上也没有找到合适的代码以供参考，所以决定自己写一个自定义的控件实现以上的效果。             先贴上图看一下效果，那个键盘是用相机拍
Android 一体机等root后的机器指令截屏
csdn_zxw的博客
07-19 345
Android 一体机等root后的机器指令截屏
Android 10.0 蓝牙音乐获取歌手、歌曲等信息功能实现
最新发布
安卓兼职framework和app工程师的博客
07-22 1508
在10.0的系统rom定制化开发中，在一些功能性开发中，可能会遇到一些蓝牙音乐的项目，所以会要求在手机端获取 蓝牙音乐的歌手歌曲的信息功能，这就需要了解Bluetooth的音乐播放功能，然后实现这些获取歌手信息和歌曲详情的功能
实现Android左右滑动菜单实例及冲突解决方案
当用户试图从左侧滑动时，`GestureDetector`会捕获到这一动作，这时，开发者需要暂停ListView的滚动，防止上下滚动与侧滑菜单操作相冲突。同样地，对于右侧滑动，也需要进行类似的逻辑处理，可能需要设置监听器来...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值