Android仿QQ5.0侧滑菜单ResideMenu源码分析-阿里云开发者社区

开发者社区> 一叶飘舟> 正文

Android仿QQ5.0侧滑菜单ResideMenu源码分析

简介:
+关注继续查看

转自:http://blog.csdn.net/cym492224103/article/details/39177275

AndroidResideMenu

github:https://github.com/SpecialCyCi/AndroidResideMenu  csdn:http://download.csdn.net/detail/cym492224103/7887801

先看看如何使用:

把项目源码下载下来导入工程,可以看到


ResideMenu为引用工程,再看看如何使用这个引用工程来构建出ResideMenu,

1.先new一个ResideMenu对象

  1. resideMenu = new ResideMenu(this);  
2.设置它的背景图片

  1. resideMenu.setBackground(R.drawable.menu_background);  
3.绑定当前Activity

  1. resideMenu.attachToActivity(this);  
4.设置监听

  1. resideMenu.setMenuListener(menuListener);  
可以监听菜单打开和关闭状态

  1. private ResideMenu.OnMenuListener menuListener = new ResideMenu.OnMenuListener() {  
  2.     @Override  
  3.     public void openMenu() {  
  4.         Toast.makeText(mContext, "Menu is opened!", Toast.LENGTH_SHORT).show();  
  5.     }  
  6.   
  7.     @Override  
  8.     public void closeMenu() {  
  9.         Toast.makeText(mContext, "Menu is closed!", Toast.LENGTH_SHORT).show();  
  10.     }  
  11. };  
5.设置内容缩放比例(0.1~1f)

  1. //valid scale factor is between 0.0f and 1.0f. leftmenu'width is 150dip.   
  2.         resideMenu.setScaleValue(0.6f);  
6.创建子菜单

  1. // create menu items;  
  2.        itemHome     = new ResideMenuItem(this, R.drawable.icon_home,     "Home");  
  3.        itemProfile  = new ResideMenuItem(this, R.drawable.icon_profile,  "Profile");  
  4.        itemCalendar = new ResideMenuItem(this, R.drawable.icon_calendar, "Calendar");  
  5.        itemSettings = new ResideMenuItem(this, R.drawable.icon_settings, "Settings");  
7.设置点击事件及将刚创建的子菜单添加到侧换菜单中(可以看到它是通过常量来控制子菜单的添加位置)

  1. itemHome.setOnClickListener(this);  
  2.         itemProfile.setOnClickListener(this);  
  3.         itemCalendar.setOnClickListener(this);  
  4.         itemSettings.setOnClickListener(this);  
  5.   
  6.         resideMenu.addMenuItem(itemHome, ResideMenu.DIRECTION_LEFT);  
  7.         resideMenu.addMenuItem(itemProfile, ResideMenu.DIRECTION_LEFT);  
  8.         resideMenu.addMenuItem(itemCalendar, ResideMenu.DIRECTION_RIGHT);  
  9.         resideMenu.addMenuItem(itemSettings, ResideMenu.DIRECTION_RIGHT);  
8.设置title按钮的点击事件,设置左右菜单的开关

  1. // You can disable a direction by setting ->  
  2.         // resideMenu.setSwipeDirectionDisable(ResideMenu.DIRECTION_RIGHT);  
  3.   
  4.         findViewById(R.id.title_bar_left_menu).setOnClickListener(new View.OnClickListener() {  
  5.             @Override  
  6.             public void onClick(View view) {  
  7.                 resideMenu.openMenu(ResideMenu.DIRECTION_LEFT);  
  8.             }  
  9.         });  
  10.         findViewById(R.id.title_bar_right_menu).setOnClickListener(new View.OnClickListener() {  
  11.             @Override  
  12.             public void onClick(View view) {  
  13.                 resideMenu.openMenu(ResideMenu.DIRECTION_RIGHT);  
  14.             }  
  15.         });  
9.还重写了dispatchTouchEvent

  1. @Override  
  2.     public boolean dispatchTouchEvent(MotionEvent ev) {  
  3.         return resideMenu.dispatchTouchEvent(ev);  
  4.     }  
10.菜单关闭方法

  1. resideMenu.closeMenu();  

11.屏蔽菜单方法

  1. // You can disable a direction by setting ->  
  2.         // resideMenu.setSwipeDirectionDisable(ResideMenu.DIRECTION_RIGHT);  

使用方法已经说完了,接下来,看看它的源码,先看看源码的项目结构。



很多人初学者都曾纠结,看源码,如何从何看起,我个人建议从上面使用的顺序看起,并且在看的时候要带个问题去看去思考,这样更容易理解。

上面的第一步是,创建ResideMenu对象,我们就看看ResideMenu的构造。

  1. public ResideMenu(Context context) {  
  2.         super(context);  
  3.         initViews(context);  
  4.     }  
从上面代码,看到构造里面就一个初始化view,思考问题:如何初始化view及初始化了什么view。

  1. private void initViews(Context context){  
  2.         LayoutInflater inflater = (LayoutInflater)  
  3.                 context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);  
  4.         inflater.inflate(R.layout.residemenu, this);  
  5.         scrollViewLeftMenu = (ScrollView) findViewById(R.id.sv_left_menu);  
  6.         scrollViewRightMenu = (ScrollView) findViewById(R.id.sv_right_menu);  
  7.         imageViewShadow = (ImageView) findViewById(R.id.iv_shadow);  
  8.         layoutLeftMenu = (LinearLayout) findViewById(R.id.layout_left_menu);  
  9.         layoutRightMenu = (LinearLayout) findViewById(R.id.layout_right_menu);  
  10.         imageViewBackground = (ImageView) findViewById(R.id.iv_background);  
  11.     }  
原理分析:从上面的代码可以看到,加载了一个residemenu的布局,先看布局

  1. <?xml version="1.0" encoding="utf-8"?>  
  2.   
  3. <FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"  
  4.               android:layout_width="match_parent"  
  5.               android:layout_height="match_parent">  
  6.     <ImageView  
  7.             android:id="@+id/iv_background"  
  8.             android:adjustViewBounds="true"  
  9.             android:scaleType="centerCrop"  
  10.             android:layout_width="match_parent"  
  11.             android:layout_height="match_parent"/>  
  12.   
  13.     <ImageView  
  14.             android:id="@+id/iv_shadow"  
  15.             android:background="@drawable/shadow"  
  16.             android:layout_width="fill_parent"  
  17.             android:layout_height="fill_parent"  
  18.             android:scaleType="fitXY"/>  
  19.   
  20.     <ScrollView  
  21.             android:id="@+id/sv_left_menu"  
  22.             android:scrollbars="none"  
  23.             android:paddingLeft="30dp"  
  24.             android:layout_width="150dp"  
  25.             android:layout_height="fill_parent">  
  26.         <LinearLayout  
  27.                 android:id="@+id/layout_left_menu"  
  28.                 android:orientation="vertical"  
  29.                 android:layout_gravity="center_vertical"  
  30.                 android:layout_width="wrap_content"  
  31.                 android:layout_height="wrap_content">  
  32.   
  33.         </LinearLayout>  
  34.     </ScrollView>  
  35.   
  36.     <ScrollView  
  37.             android:id="@+id/sv_right_menu"  
  38.             android:scrollbars="none"  
  39.             android:paddingRight="30dp"  
  40.             android:layout_width="150dp"  
  41.             android:layout_height="fill_parent"  
  42.             android:layout_gravity="right">  
  43.         <LinearLayout  
  44.                 android:id="@+id/layout_right_menu"  
  45.                 android:orientation="vertical"  
  46.                 android:layout_gravity="center_vertical"  
  47.                 android:layout_width="wrap_content"  
  48.                 android:layout_height="wrap_content"  
  49.                 android:gravity="right">  
  50.   
  51.         </LinearLayout>  
  52.     </ScrollView>  
  53.   
  54. </FrameLayout>  
布局显示效果


从布局文件,以及显示效果我们可以看到,它是一个帧布局,第一个ImageView是背景,第二个ImageView是.9的阴影效果的图片(看下面的图),

两个(ScrollView包裹着一个LinerLayout),可以从上面图看到结构分别是左菜单和右菜单

  1. <img src="http://img.blog.csdn.net/20140910100807704?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvY3ltNDkyMjI0MTAz/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast" style="font-family: Arial; background-color: rgb(255, 255, 255);" alt="" />  

1.初始化布局以及布局文件分析完毕,2.接下来是设置背景图,初始化view的时候就已经拿到了背景控件,所以设置背景图也是非常好实现的事情了。

  1. public void setBackground(int imageResrouce){  
  2.        imageViewBackground.setImageResource(imageResrouce);  
  3.    }  
3.绑定activity,思考问题:它做了什么?

  1. /** 
  2.   * use the method to set up the activity which residemenu need to show; 
  3.   * 
  4.   * @param activity 
  5.   */  
  6.  public void attachToActivity(Activity activity){  
  7.      initValue(activity);  
  8.      setShadowAdjustScaleXByOrientation();  
  9.      viewDecor.addView(this0);  
  10.      setViewPadding();  
  11.  }  
原理分析:绑定activity做了4件事情,分别是:

1.初始化参数:

  1. private void initValue(Activity activity){  
  2.     this.activity   = activity;  
  3.     leftMenuItems   = new ArrayList<ResideMenuItem>();  
  4.     rightMenuItems  = new ArrayList<ResideMenuItem>();  
  5.     ignoredViews    = new ArrayList<View>();  
  6.     viewDecor = (ViewGroup) activity.getWindow().getDecorView();  
  7.     viewActivity = new TouchDisableView(this.activity);  
  8.   
  9.     View mContent   = viewDecor.getChildAt(0);  
  10.     viewDecor.removeViewAt(0);  
  11.     viewActivity.setContent(mContent);  
  12.     addView(viewActivity);  
  13.   
  14.     ViewGroup parent = (ViewGroup) scrollViewLeftMenu.getParent();  
  15.     parent.removeView(scrollViewLeftMenu);  
  16.     parent.removeView(scrollViewRightMenu);  
  17. }  

2.正对横竖屏缩放比例进行调整

  1. private void setShadowAdjustScaleXByOrientation(){  
  2.       int orientation = getResources().getConfiguration().orientation;  
  3.       if (orientation == Configuration.ORIENTATION_LANDSCAPE) {  
  4.           shadowAdjustScaleX = 0.034f;  
  5.           shadowAdjustScaleY = 0.12f;  
  6.       } else if (orientation == Configuration.ORIENTATION_PORTRAIT) {  
  7.           shadowAdjustScaleX = 0.06f;  
  8.           shadowAdjustScaleY = 0.07f;  
  9.       }  
  10.   }  

3.添加当前view

  1. viewDecor.addView(this0);  

4.设置view边距

  1. /** 
  2.      * we need the call the method before the menu show, because the 
  3.      * padding of activity can't get at the moment of onCreateView(); 
  4.      */  
  5.     private void setViewPadding(){  
  6.         this.setPadding(viewActivity.getPaddingLeft(),  
  7.                 viewActivity.getPaddingTop(),  
  8.                 viewActivity.getPaddingRight(),  
  9.                 viewActivity.getPaddingBottom());  
  10.     }  
4.设置监听,思考问题:它什么时候调用监听,原理分析:动画监听开始执行动画掉哦那个openMenu动画结束调用closeMenu,从此我们可以想到,但它调用openMenu(int direction)和closeMenu()都会设置这个监听。

  1. private Animator.AnimatorListener animationListener = new Animator.AnimatorListener() {  
  2.         @Override  
  3.         public void onAnimationStart(Animator animation) {  
  4.             if (isOpened()){  
  5.                 showScrollViewMenu();  
  6.                 if (menuListener != null)  
  7.                     menuListener.openMenu();  
  8.             }  
  9.         }  
  10.   
  11.         @Override  
  12.         public void onAnimationEnd(Animator animation) {  
  13.             // reset the view;  
  14.             if(isOpened()){  
  15.                 viewActivity.setTouchDisable(true);  
  16.                 viewActivity.setOnClickListener(viewActivityOnClickListener);  
  17.             }else{  
  18.                 viewActivity.setTouchDisable(false);  
  19.                 viewActivity.setOnClickListener(null);  
  20.                 hideScrollViewMenu();  
  21.                 if (menuListener != null)  
  22.                     menuListener.closeMenu();  
  23.             }  
  24.         }  
  25.   
  26.         @Override  
  27.         public void onAnimationCancel(Animator animation) {  
  28.   
  29.         }  
  30.   
  31.         @Override  
  32.         public void onAnimationRepeat(Animator animation) {  
  33.   
  34.         }  
  35.     };  
5.设置内容缩放比例(0.1~1f),细心的同学会发现在当缩完成后还可以在往里面拉到更小,有种弹性的感觉,挺有趣的。但是有些人的需求不想要有这种弹性效果,我们可以通过修改源码修改这个弹性效果,找到getTargetScale这个方法,修改下面0.5这个数值。使用时设置了0.6的缩放比例,默认下面的弹性参数是0.5所以我们当缩完成后还可以在往里面拉0.1的比例。

  1. private float getTargetScale(float currentRawX){  
  2.     float scaleFloatX = ((currentRawX - lastRawX) / getScreenWidth()) * 0.75f;  
  3.     scaleFloatX = scaleDirection == DIRECTION_RIGHT ? - scaleFloatX : scaleFloatX;  
  4.   
  5.     float targetScale = ViewHelper.getScaleX(viewActivity) - scaleFloatX;  
  6.     targetScale = targetScale > 1.0f ? 1.0f : targetScale;  
  7.     targetScale = targetScale < 0.5f ? 0.5f : targetScale;  
  8.     return targetScale;  
  9. }  

默认缩放比例:

  1. //valid scale factor is between 0.0f and 1.0f.  
  2.    private float mScaleValue = 0.5f;  
  1. AnimatorSet scaleDown_activity = buildScaleDownAnimation(viewActivity, mScaleValue, mScaleValue);  
  1. /** 
  2.      * a helper method to build scale down animation; 
  3.      * 
  4.      * @param target 
  5.      * @param targetScaleX 
  6.      * @param targetScaleY 
  7.      * @return 
  8.      */  
  9.     private AnimatorSet buildScaleDownAnimation(View target,float targetScaleX,float targetScaleY){  
  10.   
  11.         AnimatorSet scaleDown = new AnimatorSet();  
  12.         scaleDown.playTogether(  
  13.                 ObjectAnimator.ofFloat(target, "scaleX", targetScaleX),  
  14.                 ObjectAnimator.ofFloat(target, "scaleY", targetScaleY)  
  15.         );  
  16.   
  17.         scaleDown.setInterpolator(AnimationUtils.loadInterpolator(activity,  
  18.                 android.R.anim.decelerate_interpolator));  
  19.         scaleDown.setDuration(250);  
  20.         return scaleDown;  
  21.     }  
6.创建子菜单,看下子菜单的构造,我们通过上面的学习,原理分析:我们可以猜测到,无非就是加载布局设置内容

  1. public ResideMenuItem(Context context, int icon, String title) {  
  2.         super(context);  
  3.         initViews(context);  
  4.         iv_icon.setImageResource(icon);  
  5.         tv_title.setText(title);  
  6.     }  
  7.   
  8.     private void initViews(Context context){  
  9.         LayoutInflater inflater=(LayoutInflater) context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);  
  10.         inflater.inflate(R.layout.residemenu_item, this);  
  11.         iv_icon = (ImageView) findViewById(R.id.iv_icon);  
  12.         tv_title = (TextView) findViewById(R.id.tv_title);  
  13.     }  
布局文件:

  1. <?xml version="1.0" encoding="utf-8"?>  
  2.   
  3. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
  4.               android:orientation="horizontal"  
  5.               android:layout_width="match_parent"  
  6.               android:layout_height="wrap_content"  
  7.               android:gravity="center_vertical"  
  8.               android:paddingTop="30dp">  
  9.   
  10.     <ImageView  
  11.             android:layout_width="30dp"  
  12.             android:layout_height="30dp"  
  13.             android:scaleType="centerCrop"  
  14.             android:id="@+id/iv_icon"/>  
  15.   
  16.     <TextView  
  17.             android:layout_width="match_parent"  
  18.             android:layout_height="wrap_content"  
  19.             android:textColor="@android:color/white"  
  20.             android:textSize="18sp"  
  21.             android:layout_marginLeft="10dp"  
  22.             android:id="@+id/tv_title"/>  
  23.   
  24. </LinearLayout>  

显示效果图:


7.子菜单添加到侧换菜单中(可以看到它是通过常量来控制子菜单的添加位置)原理分析:根据不同的常量来区分添加不同菜单的子菜单

  1. /** 
  2.     * add a single items; 
  3.     * 
  4.     * @param menuItem 
  5.     * @param direction 
  6.     */  
  7.    public void addMenuItem(ResideMenuItem menuItem, int direction){  
  8.        if (direction == DIRECTION_LEFT){  
  9.            this.leftMenuItems.add(menuItem);  
  10.            layoutLeftMenu.addView(menuItem);  
  11.        }else{  
  12.            this.rightMenuItems.add(menuItem);  
  13.            layoutRightMenu.addView(menuItem);  
  14.        }  
  15.    }  
8.设置title按钮的点击事件,设置左右菜单的开关,原理分析:先设置了缩放方向然后在设置动画,正如我们上面想的一样还设置了动画监听。

  1. /** 
  2.  * show the reside menu; 
  3.  */  
  4. public void openMenu(int direction){  
  5.   
  6.     setScaleDirection(direction);  
  7.   
  8.     isOpened = true;  
  9.     AnimatorSet scaleDown_activity = buildScaleDownAnimation(viewActivity, mScaleValue, mScaleValue);  
  10.     AnimatorSet scaleDown_shadow = buildScaleDownAnimation(imageViewShadow,  
  11.             mScaleValue + shadowAdjustScaleX, mScaleValue + shadowAdjustScaleY);  
  12.     AnimatorSet alpha_menu = buildMenuAnimation(scrollViewMenu, 1.0f);  
  13.     scaleDown_shadow.addListener(animationListener);  
  14.     scaleDown_activity.playTogether(scaleDown_shadow);  
  15.     scaleDown_activity.playTogether(alpha_menu);  
  16.     scaleDown_activity.start();  
  17. }  
设置缩放方向及计算x,y轴位置。

  1. private void setScaleDirection(int direction){  
  2.   
  3.     int screenWidth = getScreenWidth();  
  4.     float pivotX;  
  5.     float pivotY = getScreenHeight() * 0.5f;  
  6.   
  7.     if (direction == DIRECTION_LEFT){  
  8.         scrollViewMenu = scrollViewLeftMenu;  
  9.         pivotX  = screenWidth * 1.5f;  
  10.     }else{  
  11.         scrollViewMenu = scrollViewRightMenu;  
  12.         pivotX  = screenWidth * -0.5f;  
  13.     }  
  14.   
  15.     ViewHelper.setPivotX(viewActivity, pivotX);  
  16.     ViewHelper.setPivotY(viewActivity, pivotY);  
  17.     ViewHelper.setPivotX(imageViewShadow, pivotX);  
  18.     ViewHelper.setPivotY(imageViewShadow, pivotY);  
  19.     scaleDirection = direction;  
  20. }  
9.重写dispatchTouchEvent,问题思考:如何到根据手指滑动自动缩放

如果还不了解,dispatchTouchEvent这个函数如何调用?什么时候调用?请先看看http://blog.csdn.net/cym492224103/article/details/39179311

  1. @Override  
  2. public boolean dispatchTouchEvent(MotionEvent ev) {  
  3.     float currentActivityScaleX = ViewHelper.getScaleX(viewActivity);  
  4.     if (currentActivityScaleX == 1.0f)  
  5.         setScaleDirectionByRawX(ev.getRawX());  
  6.   
  7.     switch (ev.getAction()){  
  8.         case MotionEvent.ACTION_DOWN:  
  9.             lastActionDownX = ev.getX();  
  10.             lastActionDownY = ev.getY();  
  11.             isInIgnoredView = isInIgnoredView(ev) && !isOpened();  
  12.             pressedState    = PRESSED_DOWN;  
  13.             break;  
  14.   
  15.         case MotionEvent.ACTION_MOVE:  
  16.             if (isInIgnoredView || isInDisableDirection(scaleDirection))  
  17.                 break;  
  18.   
  19.             if(pressedState != PRESSED_DOWN &&  
  20.                     pressedState != PRESSED_MOVE_HORIZANTAL)  
  21.                 break;  
  22.   
  23.             int xOffset = (int) (ev.getX() - lastActionDownX);  
  24.             int yOffset = (int) (ev.getY() - lastActionDownY);  
  25.   
  26.             if(pressedState == PRESSED_DOWN) {  
  27.                 if(yOffset > 25 || yOffset < -25) {  
  28.                     pressedState = PRESSED_MOVE_VERTICAL;  
  29.                     break;  
  30.                 }  
  31.                 if(xOffset < -50 || xOffset > 50) {  
  32.                     pressedState = PRESSED_MOVE_HORIZANTAL;  
  33.                     ev.setAction(MotionEvent.ACTION_CANCEL);  
  34.                 }  
  35.             } else if(pressedState == PRESSED_MOVE_HORIZANTAL) {  
  36.                 if (currentActivityScaleX < 0.95)  
  37.                     showScrollViewMenu();  
  38.   
  39.                 float targetScale = getTargetScale(ev.getRawX());  
  40.                 ViewHelper.setScaleX(viewActivity, targetScale);  
  41.                 ViewHelper.setScaleY(viewActivity, targetScale);  
  42.                 ViewHelper.setScaleX(imageViewShadow, targetScale + shadowAdjustScaleX);  
  43.                 ViewHelper.setScaleY(imageViewShadow, targetScale + shadowAdjustScaleY);  
  44.                 ViewHelper.setAlpha(scrollViewMenu, (1 - targetScale) * 2.0f);  
  45.   
  46.                 lastRawX = ev.getRawX();  
  47.                 return true;  
  48.             }  
  49.   
  50.             break;  
  51.   
  52.         case MotionEvent.ACTION_UP:  
  53.   
  54.             if (isInIgnoredView) break;  
  55.             if (pressedState != PRESSED_MOVE_HORIZANTAL) break;  
  56.   
  57.             pressedState = PRESSED_DONE;  
  58.             if (isOpened()){  
  59.                 if (currentActivityScaleX > 0.56f)  
  60.                     closeMenu();  
  61.                 else  
  62.                     openMenu(scaleDirection);  
  63.             }else{  
  64.                 if (currentActivityScaleX < 0.94f){  
  65.                     openMenu(scaleDirection);  
  66.                 }else{  
  67.                     closeMenu();  
  68.                 }  
  69.             }  
  70.   
  71.             break;  
  72.   
  73.     }  
  74.     lastRawX = ev.getRawX();  
  75.     return super.dispatchTouchEvent(ev);  
  76. }  
上面代码量有点多,看上去有点晕,接下来我们来分别从按下、移动、放开、来原理分析:

MotionEvent.ACTION_DOWN:

记录了X,Y轴的坐标点,判断是否打开,设置了按下的状态为PRESSED_DOWN

MotionEvent.ACTION_MOVE:

拿到当前X,Y减去DOWN下记录下来的X,Y,这样得到了移动的X,Y,

然后判断如果如果移动的X,Y大于25或者小于-25就改变按下状态为PRESSED_MOVE_VERTICAL

如果移动的X,Y大于50或者小于-50就改变状态为PRESSED_MOVE_HORIZANTAL

状态为PRESSED_MOVE_HORIZANTAL就改变菜单主视图内容以及阴影图片大小,在改变的同时还设置了当前菜单的透明度。

MotionEvent.ACTION_UP:

判断是否菜单是否打开状态,在获取当前缩放的X比例,

判断比例小于0.56f,则关闭菜单,反正开启菜单。

看完后,我们在回去看看代码,就会发现其实也不过如此~!

10.菜单关闭方法,同样也设置了动画监听之前的想法也是成立的。

  1. /** 
  2.     * close the reslide menu; 
  3.     */  
  4.    public void closeMenu(){  
  5.   
  6.        isOpened = false;  
  7.        AnimatorSet scaleUp_activity = buildScaleUpAnimation(viewActivity, 1.0f, 1.0f);  
  8.        AnimatorSet scaleUp_shadow = buildScaleUpAnimation(imageViewShadow, 1.0f, 1.0f);  
  9.        AnimatorSet alpha_menu = buildMenuAnimation(scrollViewMenu, 0.0f);  
  10.        scaleUp_activity.addListener(animationListener);  
  11.        scaleUp_activity.playTogether(scaleUp_shadow);  
  12.        scaleUp_activity.playTogether(alpha_menu);  
  13.        scaleUp_activity.start();  
  14.    }  
11.屏蔽菜单方法

  1. public void setSwipeDirectionDisable(int direction){  
  2.         disabledSwipeDirection.add(direction);  
  3.     }  
  1. private boolean isInDisableDirection(int direction){  
  2.         return disabledSwipeDirection.contains(direction);  
  3.     }  
原理分析:在重写dispatchTouchEvent的时候,细心的同学应该会看到,ACTION_MOVE下面有个判断

  1. if (isInIgnoredView || isInDisableDirection(scaleDirection))  
如果这个方向的菜单被屏蔽了,就滑不出来了。

最后我们会发现我们一直都没说到TouchDisableView,其实initValue的时候就初始化了,它就是viewActivity,是我们的内容视图。


我们来看看它做了什么?

  1. @Override  
  2.     protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {  
  3.   
  4.         int width = getDefaultSize(0, widthMeasureSpec);  
  5.         int height = getDefaultSize(0, heightMeasureSpec);  
  6.         setMeasuredDimension(width, height);  
  7.   
  8.         final int contentWidth = getChildMeasureSpec(widthMeasureSpec, 0, width);  
  9.         final int contentHeight = getChildMeasureSpec(heightMeasureSpec, 0, height);  
  10.         mContent.measure(contentWidth, contentHeight);  
  11.     }  
  12.   
  13.     @Override  
  14.     protected void onLayout(boolean changed, int l, int t, int r, int b) {  
  15.         final int width = r - l;  
  16.         final int height = b - t;  
  17.         mContent.layout(00, width, height);  
  18.     }  
  19.   
  20.     @Override  
  21.     public boolean onInterceptTouchEvent(MotionEvent ev) {  
  22.         return mTouchDisabled;  
  23.     }  
  24.   
  25.     void setTouchDisable(boolean disableTouch) {  
  26.         mTouchDisabled = disableTouch;  
  27.     }  
  28.   
  29.     boolean isTouchDisabled() {  
  30.         return mTouchDisabled;  
  31.     }  
动态设置宽高,设置事件是否传递下去的flag。

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

相关文章
hbase 学习(十四)Facebook针对hbase的优化方案分析
使用hbase的目的是为了海量数据的随机读写,但是在实际使用中却发现针对随机读的优化和gc是一个很大的问题,而且hbase的数据是存储在Hdfs,而Hdfs是面向流失数据访问进行设计的,就难免带来效率的下降。
2263 0
Java对文件的读、写随机访问,RandomAccessFile类的使用分析
  在网上看了一些关于java中的RandomAccessFile类的介绍,又经过查看Java API和自己编的测试程序,总算是对RandomAccessFile的使用有了一定的了解。自己做了以下比较详细的总结吧。
1033 0
memset 的实现分析
  memset 是 msvcrt 中的一个函数,其作用和用途是显而易见的,通常是对一段内存进行填充,就其作用本身不具有任何歧义性。但就有人一定要纠结对数组的初始化一定要写成如下形式:     int a[...] = { 0 };   int a[100] = { 1, 2 };     而认为如下使用 memset 的写法不明就里的被其排斥和拒绝:     memset(a, 0, sizeof(a));     这种看法首先是毫无道理的,在代码风格,可读性,可维护性上根本不构成一个命题,且 memset 在开发中的使用是非常常见的。
1208 0
RestTemplate源码分析
RestTemplate是Spring提供的访问Rest服务的客户端,它简化了和http服务器的交互。 HTTP 协议特点是纯文本协议,其媒体类型MediaType可以为text/html、text/xml、application/json等,HTTP消息必须使用content-type进行自我描述,否则不能区分媒体类型。
3786 0
android(cm11)状态栏源码分析(一)
版权声明:您好,转载请留下本人博客的地址,谢谢 https://blog.csdn.net/hongbochen1223/article/details/50216563 (一):写在前面 最近由于工作需要,需要了解CM11中的有关于StatusBar相关的内容。
950 0
Ingress-nginx 源码分析
对于像我这样的 k8s 萌新来说,ingress-nginx 项目有着很重要的意义。从学习 k8s 的角度来讲,它功能简练,代码量相对较少,很适合我们通过它来侧面理解 k8s 中的一些概念。
2488 0
一对一聊天源码,语音聊天的优劣势分析
一对一聊天源码,语音聊天的优劣势分析
132 0
Rainbond 内置 ServiceMesh架构分析
在 Cloud Native 架构下,容器的使用给予了异构应用程序的更多可行性,kubernetes 增强的应用的横向扩容能力,用户可以快速的编排出复杂环境、复杂依赖关系的应用程序,同时开发者又无须过分关心应用程序的监控、扩展性、服务发现、负载均衡和分布式追踪这些繁琐的事情而专注于程序开发,赋予开发者更多的创造性。
1040 0
[Android]Android系统启动流程源码分析
以下内容为原创,欢迎转载,转载请注明 来自天天博客:http://www.cnblogs.com/tiantianbyconan/p/5013863.html Android系统启动流程源码分析 首先我们知道,Android是基于Linux的,当Linux内核加载完成时就会自动启动一个init的进程。
710 0
+关注
1635
文章
0
问答
文章排行榜
最热
最新
相关电子书
更多
《2021云上架构与运维峰会演讲合集》
立即下载
《零基础CSS入门教程》
立即下载
《零基础HTML入门教程》
立即下载