设为首页收藏本站
开启辅助访问

在路上

 找回密码
 立即注册
在路上 › 站点首页 ›学习 › 查看内容

基于java中wemall Android app商城系统解决左侧抽屉菜单和viewpager不能兼容问题

2016-12-20 13:13| 发布者: zhangjf| 查看: 627| 评论: 0

摘要: 完美解决左侧抽屉菜单和viewpager不能兼容左右滑动的问题，可进行参考。WeMall-Client/res/layout/wemall_main_ui.xml/RadioGroup /RelativeLayout /cn.edu.zzu.wemall.ui.SlideMenu /RelativeLayout No newline a ...
完美解决左侧抽屉菜单和viewpager不能兼容左右滑动的问题，可进行参考。
WeMall-Client/res/layout/wemall_main_ui.xml
  1. </RadioGroup>
  2. </RelativeLayout>
  3. </cn.edu.zzu.wemall.ui.SlideMenu>

  5. </RelativeLayout>
  6. No newline at end of file
复制代码
WeMall-Client/src/cn/edu/zzu/wemall/ui/MainUIMain.java

  1. import android.view.KeyEvent;
  2. import android.view.Menu;
  3. import android.view.MenuItem;
  4. import android.view.MotionEvent;
  5. import android.view.View;
  6. import android.view.View.OnClickListener;
  7. import android.view.View.OnTouchListener;
  8. import android.view.ViewGroup;
  9. import android.view.Window;
  10. import android.view.inputmethod.InputMethodManager;
  11. @@ -105,6 +107,8 @@ public class MainUIMain extends FragmentActivity implements
  12. menudata = new ArrayList<HashMap<String, Object>>();
  13. menuadapter = new MenuAdapter(this, menudata);
  14. menulistview.setAdapter(menuadapter);

  16. // 初始化ViewPager，菜单数据
  17. InitViewPager();
  18. @@ -206,8 +210,9 @@ public class MainUIMain extends FragmentActivity implements
  19. public void onPageScrollStateChanged(int arg0) {
  20. // 在这里判断vpage是否滑到了商品页面，如果滑到了商品页面并且继续向右拉动屏幕，则展现菜单列表//
  21. if (this.viewPager.getCurrentItem() == 0 && arg0 == 1) {
  22. System.out.println("滑到了最左边且在基于往右侧滑动");
  23. //slideMenu.openMenu();

  25. } else {

  27. }
  28. }
复制代码
WeMall-Client/src/cn/edu/zzu/wemall/ui/SlideMenu.java
  1. package cn.edu.zzu.wemall.ui;

  3. import cn.edu.zzu.wemall.R;
  4. import android.annotation.SuppressLint;
  5. import android.content.Context;
  6. import android.graphics.Canvas;
  7. import android.support.v4.view.ViewPager;
  8. import android.util.AttributeSet;
  9. import android.view.MotionEvent;
  10. import android.view.VelocityTracker;
  11. import android.view.View;
  12. import android.view.ViewConfiguration;
  13. import android.view.ViewGroup;
  14. import android.widget.Scroller;

  16. /*
  17. * 侧边栏类
  18. *
  19. */
  20. public class SlideMenu extends ViewGroup {
  21.         public static final int SCREEN_MENU = 0;
  22.         public static final int SCREEN_MAIN = 1;
  23.         private static final int SCREEN_INVALID = -1;

  25.         private int mCurrentScreen;
  26.         private int mNextScreen = SCREEN_INVALID;

  28.         private Scroller mScroller;
  29.         private VelocityTracker mVelocityTracker;
  30.         private int mTouchSlop;

  32.         private float mLastMotionX;
  33.         private float mLastMotionY;

  35.         private final static int TOUCH_STATE_REST = 0;
  36.         private final static int TOUCH_STATE_SCROLLING = 1;
  37.         private static final int SNAP_VELOCITY = 1000;

  39.         public int mTouchState = TOUCH_STATE_REST;
  40.         private boolean mLocked;
  41.         private boolean mAllowLongPress;

  43.         public SlideMenu(Context context) {
  44.                 this(context, null, 0);
  45.         }

  47.         public SlideMenu(Context context, AttributeSet attrs) {
  48.                 this(context, attrs, 0);
  49.         }


  52.         public SlideMenu(Context context, AttributeSet attrs, int defStyle) {
  53.                 super(context, attrs, defStyle);

  55.                 mScroller = new Scroller(getContext());
  56.                 mCurrentScreen = SCREEN_MAIN;
  57.                 mTouchSlop = ViewConfiguration.get(getContext()).getScaledTouchSlop();
  58.         }

  60.         @Override
  61.         protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
  62.                 super.onMeasure(widthMeasureSpec, heightMeasureSpec);
  63.                 measureViews(widthMeasureSpec, heightMeasureSpec);
  64.         }

  66.         public void measureViews(int widthMeasureSpec, int heightMeasureSpec) {
  67.                 View menuView = getChildAt(0);
  68.                 menuView.measure(menuView.getLayoutParams().width + menuView.getLeft()
  69.                                 + menuView.getRight(), heightMeasureSpec);

  71.                 View contentView = getChildAt(1);
  72.                 contentView.measure(widthMeasureSpec, heightMeasureSpec);
  73.         }

  75.         @Override
  76.         protected void onLayout(boolean changed, int l, int t, int r, int b) {
  77.                 int childCount = getChildCount();
  78.                 if (childCount != 2) {
  79.                         throw new IllegalStateException(
  80.                                         "The childCount of SlidingMenu must be 2");
  81.                 }

  83.                 View menuView = getChildAt(0);
  84.                 final int width = menuView.getMeasuredWidth();
  85.                 menuView.layout(-width, 0, 0, menuView.getMeasuredHeight());

  87.                 View contentView = getChildAt(1);
  88.                 contentView.layout(0, 0, contentView.getMeasuredWidth(),
  89.                                 contentView.getMeasuredHeight());
  90.         }

  92.         @Override
  93.         protected void onFinishInflate() {
  94.                 super.onFinishInflate();
  95.                 View child;
  96.                 for (int i = 0; i < getChildCount(); i++) {
  97.                         child = getChildAt(i);
  98.                         child.setFocusable(true);
  99.                         child.setClickable(true);
  100.                 }
  101.         }

  103.         @Override
  104.         public boolean onInterceptTouchEvent(MotionEvent ev) {
  105.                 if (mLocked) {
  106.                         return true;
  107.                 }

  109.                 final int action = ev.getAction();
  110.                 if ((action == MotionEvent.ACTION_MOVE)
  111.                                 && (mTouchState != TOUCH_STATE_REST)) {
  112.                         return true;
  113.                 }

  115.                 final float x = ev.getX();
  116.                 final float y = ev.getY();

  118.                 switch (action) {
  119.                 case MotionEvent.ACTION_MOVE:
  120.                         //在这里做点文章，侧滑菜单和viewpager的滑动兼容，头疼。。。
  121.                         /**
  122.                          * 设定条件，如果当前页面在商品页面，往右侧拉动屏幕，显示菜单，往左则收回菜单，再往左拉
  123.                          * 则切换到购物车
  124.                          * 如果当前页面在购物车或者个人中心，则无论左右拉，都不理会菜单栏！，直接切换viewpager
  125.                          */
  126.                         ViewPager viewPager = (ViewPager) findViewById(R.id.vPager);
  127.                         if(viewPager.getCurrentItem()>0){ //如果当前页面不在商品页面，则忽略滑动出现菜单
  128.                                 break;
  129.                         }

  131.                         final int xDiff = (int) Math.abs(x - mLastMotionX);
  132.                         final int yDiff = (int) Math.abs(y - mLastMotionY);
  133.                         //菜单没显示且往右滑动时break
  134.                         if(isMainScreenShowing()&&(x - mLastMotionX)<0){
  135.                                 break;
  136.                         }
  137.                         final int touchSlop = mTouchSlop;
  138.                         boolean xMoved = xDiff > touchSlop;
  139.                         boolean yMoved = yDiff > touchSlop;

  141.                         if (xMoved || yMoved) {

  143.                                 if (xMoved) {
  144.                                         // Scroll if the user moved far enough along the X axis
  145.                                         mTouchState = TOUCH_STATE_SCROLLING;
  146.                                         enableChildrenCache();
  147.                                 }
  148.                                 // Either way, cancel any pending longpress
  149.                                 if (mAllowLongPress) {
  150.                                         mAllowLongPress = false;
  151.                                         // Try canceling the long press. It could also have been
  152.                                         // scheduled
  153.                                         // by a distant descendant, so use the mAllowLongPress flag
  154.                                         // to block
  155.                                         // everything
  156.                                         final View currentScreen = getChildAt(mCurrentScreen);
  157.                                         currentScreen.cancelLongPress();
  158.                                 }
  159.                         }
  160.                         break;

  162.                 case MotionEvent.ACTION_DOWN:
  163.                        
  164.                         // Remember location of down touch
  165.                         mLastMotionX = x;
  166.                         mLastMotionY = y;
  167.                         mAllowLongPress = true;
  168.                         mTouchState = mScroller.isFinished() ? TOUCH_STATE_REST
  169.                                         : TOUCH_STATE_SCROLLING;
  170.                         break;

  172.                 case MotionEvent.ACTION_CANCEL:
  173.                 case MotionEvent.ACTION_UP:
  174.                         // Release the drag
  175.                         clearChildrenCache();
  176.                         mTouchState = TOUCH_STATE_REST;
  177.                         mAllowLongPress = false;
  178.                         break;
  179.                 }

  181.                 /*
  182.                  * The only time we want to intercept motion events is if we are in the
  183.                  * drag mode.
  184.                  */
  185.                 return mTouchState != TOUCH_STATE_REST;
  186.         }

  188.         void enableChildrenCache() {
  189.                 final int count = getChildCount();
  190.                 for (int i = 0; i < count; i++) {
  191.                         final View layout = (View) getChildAt(i);
  192.                         layout.setDrawingCacheEnabled(true);
  193.                 }
  194.         }

  196.         void clearChildrenCache() {
  197.                 final int count = getChildCount();
  198.                 for (int i = 0; i < count; i++) {
  199.                         final View layout = (View) getChildAt(i);
  200.                         layout.setDrawingCacheEnabled(false);
  201.                 }
  202.         }

  204.         @SuppressLint("ClickableViewAccessibility")
  205.         @Override
  206.         public boolean onTouchEvent(MotionEvent ev) {
  207.                 if (mLocked) {
  208.                         return true;
  209.                 }

  211.                 if (mVelocityTracker == null) {
  212.                         mVelocityTracker = VelocityTracker.obtain();
  213.                 }
  214.                 mVelocityTracker.addMovement(ev);

  216.                 final int action = ev.getAction();
  217.                 final float x = ev.getX();
  218.                 switch (action) {
  219.                 case MotionEvent.ACTION_DOWN:
  220.                         /*
  221.                          * If being flinged and user touches, stop the fling. isFinished
  222.                          * will be false if being flinged.
  223.                          */
  224.                         if (!mScroller.isFinished()) {
  225.                                 mScroller.abortAnimation();
  226.                         }

  228.                         // Remember where the motion event started
  229.                         mLastMotionX = x;
  230.                         break;
  231.                 case MotionEvent.ACTION_MOVE:
  232.                         if (mTouchState == TOUCH_STATE_SCROLLING) {
  233.                                 // Scroll to follow the motion event
  234.                                 final int deltaX = (int) (mLastMotionX - x);
  235.                                 mLastMotionX = x;
  236.                                 if (deltaX < 0) {
  237.                                         if (deltaX + getScrollX() >= -getChildAt(0).getWidth()) {
  238.                                                 scrollBy(deltaX, 0);
  239.                                         }

  241.                                 } else if (deltaX > 0) {
  242.                                        
  243.                                         final int availableToScroll = getChildAt(
  244.                                                         getChildCount() - 1).getRight()
  245.                                                         - getScrollX() - getWidth();

  247.                                         if (availableToScroll > 0) {
  248.                                                 scrollBy(Math.min(availableToScroll, deltaX), 0);
  249.                                         }
  250.                                 }
  251.                         }
  252.                         break;
  253.                 case MotionEvent.ACTION_UP:
  254.                         if (mTouchState == TOUCH_STATE_SCROLLING) {
  255.                                 final VelocityTracker velocityTracker = mVelocityTracker;
  256.                                 velocityTracker.computeCurrentVelocity(1000);
  257.                                 int velocityX = (int) velocityTracker.getXVelocity();

  259.                                 if (velocityX > SNAP_VELOCITY && mCurrentScreen == SCREEN_MAIN) {
  260.                                         // Fling hard enough to move left
  261.                                         snapToScreen(SCREEN_MENU);
  262.                                 } else if (velocityX < -SNAP_VELOCITY
  263.                                                 && mCurrentScreen == SCREEN_MENU) {
  264.                                         // Fling hard enough to move right
  265.                                         snapToScreen(SCREEN_MAIN);
  266.                                 } else {
  267.                                         snapToDestination();
  268.                                 }

  270.                                 if (mVelocityTracker != null) {
  271.                                         mVelocityTracker.recycle();
  272.                                         mVelocityTracker = null;
  273.                                 }
  274.                         }
  275.                         mTouchState = TOUCH_STATE_REST;
  276.                         break;
  277.                 case MotionEvent.ACTION_CANCEL:
  278.                         mTouchState = TOUCH_STATE_REST;
  279.                 }

  281.                 return true;
  282.         }

  284.         @Override
  285.         public void computeScroll() {
  286.                 if (mScroller.computeScrollOffset()) {
  287.                         scrollTo(mScroller.getCurrX(), mScroller.getCurrY());
  288.                 } else if (mNextScreen != SCREEN_INVALID) {
  289.                         mCurrentScreen = Math.max(0,
  290.                                         Math.min(mNextScreen, getChildCount() - 1));
  291.                         mNextScreen = SCREEN_INVALID;
  292.                         clearChildrenCache();
  293.                 }
  294.         }

  296.         @Override
  297.         public void scrollTo(int x, int y) {
  298.                 super.scrollTo(x, y);
  299.                 postInvalidate();
  300.         }

  302.         @Override
  303.         protected void dispatchDraw(Canvas canvas) {
  304.                 final int scrollX = getScrollX();
  305.                 super.dispatchDraw(canvas);
  306.                 canvas.translate(scrollX, 0);
  307.         }

  309.         @Override
  310.         public boolean dispatchUnhandledMove(View focused, int direction) {
  311.                 if (direction == View.FOCUS_LEFT) {
  312.                         if (getCurrentScreen() > 0) {
  313.                                 snapToScreen(getCurrentScreen() - 1);
  314.                                 return true;
  315.                         }
  316.                 } else if (direction == View.FOCUS_RIGHT) {
  317.                         if (getCurrentScreen() < getChildCount() - 1) {
  318.                                 snapToScreen(getCurrentScreen() + 1);
  319.                                 return true;
  320.                         }
  321.                 }
  322.                 return super.dispatchUnhandledMove(focused, direction);
  323.         }

  325.         protected void snapToScreen(int whichScreen) {

  327.                 enableChildrenCache();

  329.                 whichScreen = Math.max(0, Math.min(whichScreen, getChildCount() - 1));
  330.                 boolean changingScreens = whichScreen != mCurrentScreen;

  332.                 mNextScreen = whichScreen;

  334.                 View focusedChild = getFocusedChild();
  335.                 if (focusedChild != null && changingScreens
  336.                                 && focusedChild == getChildAt(mCurrentScreen)) {
  337.                         focusedChild.clearFocus();
  338.                 }

  340.                 final int newX = (whichScreen - 1) * getChildAt(0).getWidth();
  341.                 final int delta = newX - getScrollX();
  342.                 mScroller.startScroll(getScrollX(), 0, delta, 0, Math.abs(delta) * 2);
  343.                 invalidate();
  344.         }

  346.         protected void snapToDestination() {
  347.                 if (getScrollX() == 0) {
  348.                         return;
  349.                 }
  350.                 final int screenWidth = getChildAt(0).getWidth();
  351.                 final int whichScreen = (screenWidth + getScrollX() + (screenWidth / 2))
  352.                                 / screenWidth;
  353.                 snapToScreen(whichScreen);
  354.         }

  356.         public int getCurrentScreen() {
  357.                 return mCurrentScreen;
  358.         }

  360.         public boolean isMainScreenShowing() {
  361.                 return mCurrentScreen == SCREEN_MAIN;
  362.         }

  364.         public void openMenu() {
  365.                 mCurrentScreen = SCREEN_MENU;
  366.                 snapToScreen(mCurrentScreen);
  367.         }

  369.         public void closeMenu() {
  370.                 mCurrentScreen = SCREEN_MAIN;
  371.                 snapToScreen(mCurrentScreen);
  372.         }

  374.         public void unlock() {
  375.                 mLocked = false;
  376.         }

  378.         public void lock() {
  379.                 mLocked = true;
  380.         }

  382. }
复制代码
原文详情地址：http://git.oschina.net/zzunet/wemall-doraemon/commit/e8f303df5663dc69fe47bb9623222149d40e3956
wemall doraemonAndroid app商城详情地址：http://www.koahub.com/home/product/55
wemall官网地址：http://www.wemallshop.com
wemall 开源微商城 ，微信商城，商城源码，三级分销，微生鲜，微水果，微外卖，微订餐---专业的o2o系统




收藏 邀请
上一篇：使用jacob打印word或excel下一篇：linux系统添加swap虚拟内存与删除配置方法

最新评论

相关分类

小黑屋|在路上 ( 蜀ICP备15035742号-1 )  

;

GMT+8, 2025-7-8 06:15

Copyright 2015-2025 djqfx

返回顶部