Android 自定义控件打造史上最简单的侧滑菜单

侧滑菜单在很多应用中都会见到，最近QQ5.0侧滑还玩了点花样~~对于侧滑菜单，一般大家都会自定义ViewGroup，然后隐藏菜单栏，当手指滑动时，通过Scroller或者不断的改变leftMargin等实现；多少都有点复杂，完成以后还需要对滑动冲突等进行处理~~今天给大家带来一个简单的实现，史上最简单有点夸张，但是的确是我目前遇到过的最简单的一种实现~~~

1、原理分析

既然是侧滑，无非就是在巴掌大的屏幕，塞入大概两巴掌大的布局，需要滑动可以出现另一个，既然这样，大家为啥不考虑使用Android提供的HorizontalScrollView呢~

如果使用HorizontalScrollView，还需要在ACTION_DOWN , ACTION_MOVE里面去监听，判断，不断改变控件位置了么? NO！！！HorizontalScrollView本身就带了滑动的功能~~

还需要自己的手动处理各种冲突么？NO！！！当然了，还是需要了解下事件分发机制的~~~

2、效果图

嗯，主界面搞了QQ一张图片，左边盗用了一兄弟的布局文件~~罪过~~ 谁有好看的布局、图片、图标神马的，可以给我发点，感激~

3、布局文件

[html] view plain copy

1.  <com.example.zhy_slidingmenu.SlidingMenu xmlns:android="http://schemas.android.com/apk/res/android"  

2.      xmlns:tools="http://schemas.android.com/tools"  

3.      android:layout_width="wrap_content"  

4.      android:layout_height="fill_parent"  

5.      android:scrollbars="none" >  

6.    

7.      <LinearLayout  

8.          android:layout_width="wrap_content"  

9.          android:layout_height="fill_parent"  

10.         android:orientation="horizontal" >  

11.   

12.         <include layout="@layout/layout_menu" />  

13.   

14.         <LinearLayout  

15.             android:layout_width="fill_parent"  

16.             android:layout_height="fill_parent"  

17.             android:background="@drawable/qq" >  

18.         </LinearLayout>  

19.     </LinearLayout>  

20.   

21. </com.example.zhy_slidingmenu.SlidingMenu>  

首先是我们的自定义View，里面一个方向水平的LinearLayout，然后就是一个是菜单的布局，一个是主布局了~

4、自定义SlidingMenu

接下来就是我们最核心的代码了~

[java] view plain copy

1.  package com.example.zhy_slidingmenu;  

2.    

3.  import android.content.Context;  

4.  import android.util.AttributeSet;  

5.  import android.util.TypedValue;  

6.  import android.view.MotionEvent;  

7.  import android.view.ViewGroup;  

8.  import android.widget.HorizontalScrollView;  

9.  import android.widget.LinearLayout;  

10.   

11. import com.zhy.utils.ScreenUtils;  

12.   

13. public class SlidingMenu extends HorizontalScrollView  

14. {  

15.     /** 

16.      * 屏幕宽度 

17.      */  

18.     private int mScreenWidth;  

19.     /** 

20.      * dp 

21.      */  

22.     private int mMenuRightPadding = 50;  

23.     /** 

24.      * 菜单的宽度 

25.      */  

26.     private int mMenuWidth;  

27.     private int mHalfMenuWidth;  

28.   

29.     private boolean once;  

30.   

31.     public SlidingMenu(Context context, AttributeSet attrs)  

32.     {  

33.         super(context, attrs);  

34.         mScreenWidth = ScreenUtils.getScreenWidth(context);  

35.     }  

36.   

37.     @Override  

38.     protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec)  

39.     {  

40.         /** 

41.          * 显示的设置一个宽度 

42.          */  

43.         if (!once)  

44.         {  

45.             LinearLayout wrapper = (LinearLayout) getChildAt(0);  

46.             ViewGroup menu = (ViewGroup) wrapper.getChildAt(0);  

47.             ViewGroup content = (ViewGroup) wrapper.getChildAt(1);  

48.             // dp to px  

49.             mMenuRightPadding = (int) TypedValue.applyDimension(  

50.                     TypedValue.COMPLEX_UNIT_DIP, mMenuRightPadding, content  

51.                             .getResources().getDisplayMetrics());  

52.   

53.             mMenuWidth = mScreenWidth - mMenuRightPadding;  

54.             mHalfMenuWidth = mMenuWidth / 2;  

55.             menu.getLayoutParams().width = mMenuWidth;  

56.             content.getLayoutParams().width = mScreenWidth;  

57.   

58.         }  

59.         super.onMeasure(widthMeasureSpec, heightMeasureSpec);  

60.   

61.     }  

62.   

63.     @Override  

64.     protected void onLayout(boolean changed, int l, int t, int r, int b)  

65.     {  

66.         super.onLayout(changed, l, t, r, b);  

67.         if (changed)  

68.         {  

69.             // 将菜单隐藏  

70.             this.scrollTo(mMenuWidth, 0);  

71.             once = true;  

72.         }  

73.     }  

74.   

75.     @Override  

76.     public boolean onTouchEvent(MotionEvent ev)  

77.     {  

78.         int action = ev.getAction();  

79.         switch (action)  

80.         {  

81.         // Up时，进行判断，如果显示区域大于菜单宽度一半则完全显示，否则隐藏  

82.         case MotionEvent.ACTION_UP:  

83.             int scrollX = getScrollX();  

84.             if (scrollX > mHalfMenuWidth)  

85.                 this.smoothScrollTo(mMenuWidth, 0);  

86.             else  

87.                 this.smoothScrollTo(0, 0);  

88.             return true;  

89.         }  

90.         return super.onTouchEvent(ev);  

91.     }  

92.   

93. }  

哈哈，完工~上面的演示图，就用到这么点代码~~

代码怎么样，短不短~除了设置宽度这些杂七杂八的代码~正在处理滑动的代码不过10行~~我说史上最简单不为过吧~

嗯，由于代码过于短，就不解释了，大家自己看下注释~

5、扩展

嗯，就下来，我们完善下程序，我准备首先把菜单布局里面改成ListView来证明我们是没有冲突的；然后添加一个属性让用户配置菜单距离右边的边距的值；再对外公布一个方法，点击自动打开菜单，供用户点击某个按钮，菜单慢慢滑出来~

1、添加自定义属性

a、首先在values文件夹下新建一个attr.xml，写入以下内容：

[html] view plain copy

1.  <?xml version="1.0" encoding="utf-8"?>  

2.  <resources>  

3.    

4.      <attr name="rightPadding" format="dimension" />  

5.    

6.      <declare-styleable name="SlidingMenu">  

7.          <attr name="rightPadding" />  

8.      </declare-styleable>  

9.    

10. </resources>  

b、在布局中声明命名空间和使用属性

定义完了，肯定要使用么。

[html] view plain copy

1.  <com.example.zhy_slidingmenu.SlidingMenu xmlns:android="http://schemas.android.com/apk/res/android"  

2.      xmlns:tools="http://schemas.android.com/tools"  

3.      xmlns:zhy="http://schemas.android.com/apk/res/com.example.zhy_slidingmenu"  

4.      android:layout_width="wrap_content"  

5.      android:layout_height="fill_parent"  

6.      android:scrollbars="none"  

7.      zhy:rightPadding="100dp" >  

可以看到我们的命名空间：xmlns:zhy="http://schemas.android.com/apk/res/com.example.zhy_slidingmenu" 是http://schemas.android.com/apk/res/加上我们的包名；

我们的属性：zhy:rightPadding="100dp"这里我设置了100dp；

注：很多人问我，没有提示咋办，这样，你clean下项目，如果你运气好，就有提示了，嗯，运气好~

c、在我们自定义类中获得属性

[java] view plain copy

1.  public SlidingMenu(Context context, AttributeSet attrs, int defStyle)  

2.      {  

3.          super(context, attrs, defStyle);  

4.          mScreenWidth = ScreenUtils.getScreenWidth(context);  

5.    

6.          TypedArray a = context.getTheme().obtainStyledAttributes(attrs,  

7.                  R.styleable.SlidingMenu, defStyle, 0);  

8.          int n = a.getIndexCount();  

9.          for (int i = 0; i < n; i++)  

10.         {  

11.             int attr = a.getIndex(i);  

12.             switch (attr)  

13.             {  

14.             case R.styleable.SlidingMenu_rightPadding:  

15.                 // 默认50  

16.                 mMenuRightPadding = a.getDimensionPixelSize(attr,  

17.                         (int) TypedValue.applyDimension(  

18.                                 TypedValue.COMPLEX_UNIT_DIP, 50f,  

19.                                 getResources().getDisplayMetrics()));// 默认为10DP  

20.                 break;  

21.             }  

22.         }  

23.         a.recycle();  

24.     }  

在三个参数的构造方法中，通过TypeArray获取就行了~

好了，这样就行了~如果你又很多自定义属性，按照上面的步骤来就行了~~

2、对外公布一个打开菜单的方法

首先定义一个boolean isOpen变量，用来标识我们当前菜单的状态~~然后记得在ACTION_UP的时候改变下状态：

[java] view plain copy

1.  case MotionEvent.ACTION_UP:  

2.              int scrollX = getScrollX();  

3.              if (scrollX > mHalfMenuWidth)  

4.              {  

5.                  this.smoothScrollTo(mMenuWidth, 0);  

6.                  isOpen = false;  

7.              } else  

8.              {  

9.                  this.smoothScrollTo(0, 0);  

10.                 isOpen = true;  

11.             }  

12.             return true;  

13.         }  

下面开始添加方法：

[java] view plain copy

1.  /** 

2.       * 打开菜单 

3.       */  

4.      public void openMenu()  

5.      {  

6.          if (isOpen)  

7.              return;  

8.          this.smoothScrollTo(0, 0);  

9.          isOpen = true;  

10.     }  

11.   

12.     /** 

13.      * 关闭菜单 

14.      */  

15.     public void closeMenu()  

16.     {  

17.         if (isOpen)  

18.         {  

19.             this.smoothScrollTo(mMenuWidth, 0);  

20.             isOpen = false;  

21.         }  

22.     }  

23.   

24.     /** 

25.      * 切换菜单状态 

26.      */  

27.     public void toggle()  

28.     {  

29.         if (isOpen)  

30.         {  

31.             closeMenu();  

32.         } else  

33.         {  

34.             openMenu();  

35.         }  

36.     }  

顺手多添加了两个。。。

下面，我们挑一个进行测试：

主布局多添加一个按钮，用于触发toggleMenu（）方法

主Activity

[java] view plain copy

1.  public class MainActivity extends Activity  

2.  {  

3.      private SlidingMenu mMenu ;   

4.    

5.      @Override  

6.      protected void onCreate(Bundle savedInstanceState)  

7.      {  

8.          super.onCreate(savedInstanceState);  

9.          requestWindowFeature(Window.FEATURE_NO_TITLE);  

10.         setContentView(R.layout.activity_main);  

11.         mMenu = (SlidingMenu) findViewById(R.id.id_menu);  

12.     }  

13.       

14.     public void toggleMenu(View view)  

15.     {  

16.         mMenu.toggle();  

17.     }  

18. }  

好了，看下现在的效果图：

我们把padding改成了100dp~

然后点击我们的按钮，看哈效果~~

3、添加ListView测试

好了~~ListView也测试完了~~大家可以根据自己的需求各种修改~~

对了，今天测试用QQ的目的是为了，下次我要拿上面的代码，改造和QQ5.0一模一样的效果，大家有兴趣可以提前试一试，QQ的菜单好像是隐藏在主界面下面一样，给人感觉不是划出来的，我们这个例子也能做出那样的效果，拭目以待吧；剩下就是各种缩放，透明度的动画了~~~

原文链接：http://www.apkbus.com/blog-784586-61685.html