Cant access custom side menu layouts

Question

Cant access custom side menu layouts

Opened this issue 8 years ago · 3 comments

pinvisible commented 8 years ago

Hello ,
I like this library. Great work..

I need to add custom left side layout. But i cant access it.

resideMenu = new ResideMenu(activity, R.layout.menu_left, -1); = shows error

Seems only one constructor is available now..
resideMenu = new ResideMenu(activity); = This works

Please help to sort this out.

Answer 1 · 2017-05-01T03:30:13.000Z

Download the library and replace ResideMenu class with given below code.

package com.special.ResideMenu;

import android.app.Activity;
import android.content.Context;
import android.content.res.Configuration;
import android.content.res.Resources;
import android.graphics.Point;
import android.graphics.Rect;
import android.os.Build;
import android.util.DisplayMetrics;
import android.view.;
import android.view.animation.AnimationUtils;
import android.widget.;

import com.nineoldandroids.animation.Animator;
import com.nineoldandroids.animation.AnimatorSet;
import com.nineoldandroids.animation.ObjectAnimator;
import com.nineoldandroids.view.ViewHelper;

import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.List;

/**

User: special
Date: 13-12-10
Time: 下午10:44
Mail: specialcyci@gmail.com
*/
public class ResideMenu extends FrameLayout {

public static final int DIRECTION_LEFT = 0;
public static final int DIRECTION_RIGHT = 1;
private static final int PRESSED_MOVE_HORIZONTAL = 2;
private static final int PRESSED_DOWN = 3;
private static final int PRESSED_DONE = 4;
private static final int PRESSED_MOVE_VERTICAL = 5;

private ImageView imageViewShadow;
private ImageView imageViewBackground;
private LinearLayout layoutLeftMenu;
private LinearLayout layoutRightMenu;
private View scrollViewLeftMenu;
private View scrollViewRightMenu;
private View scrollViewMenu;
private Context mContext;
/**
- Current attaching activity.
  /
  private Activity activity;
  /*
- The DecorView of current activity.
  /
  private ViewGroup viewDecor;
  private TouchDisableView viewActivity;
  /*
- The flag of menu opening status.
  /
  private boolean isOpened;
  private float shadowAdjustScaleX;
  private float shadowAdjustScaleY;
  /*
- Views which need stop to intercept touch events.
  */
  private List ignoredViews;
  private List leftMenuItems;
  private List rightMenuItems;
  private DisplayMetrics displayMetrics = new DisplayMetrics();
  private OnMenuListener menuListener;
  private float lastRawX;
  private boolean isInIgnoredView = false;
  private int scaleDirection = DIRECTION_LEFT;
  private int pressedState = PRESSED_DOWN;
  private List disabledSwipeDirection = new ArrayList();
  // Valid scale factor is between 0.0f and 1.0f.
  private float mScaleValue = 0.5f;
private boolean mUse3D;
private static final int ROTATE_Y_ANGLE = 10;

public ResideMenu(Context context) {
super(context);
mContext=context;
initViews(context, -1, -1);

}

/**
- This constructor provides you to create menus with your own custom
- layouts, but if you use custom menu then do not call addMenuItem because
- it will not be able to find default views
  */
  public ResideMenu(Context context, int customLeftMenuId,
  int customRightMenuId) {
  super(context);
  mContext=context;
  initViews(context, customLeftMenuId, customRightMenuId);
  }
private void initViews(Context context, int customLeftMenuId,
int customRightMenuId) {
LayoutInflater inflater = (LayoutInflater) context
.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
inflater.inflate(R.layout.residemenu_custom, this);
```
 if (customLeftMenuId >= 0) {
     scrollViewLeftMenu = inflater.inflate(customLeftMenuId, this, false);
 } else {
     scrollViewLeftMenu = inflater.inflate(
             R.layout.residemenu_custom_left_scrollview, this, false);
     layoutLeftMenu = (LinearLayout) scrollViewLeftMenu.findViewById(R.id.layout_left_menu);
 }

 if (customRightMenuId >= 0) {
     scrollViewRightMenu = inflater.inflate(customRightMenuId, this, false);
 } else {
     scrollViewRightMenu = inflater.inflate(
             R.layout.residemenu_custom_right_scrollview, this, false);
     layoutRightMenu = (LinearLayout) scrollViewRightMenu.findViewById(R.id.layout_right_menu);
 }

 imageViewShadow = (ImageView) findViewById(R.id.iv_shadow);
 imageViewBackground = (ImageView) findViewById(R.id.iv_background);

 RelativeLayout menuHolder = (RelativeLayout) findViewById(R.id.sv_menu_holder);
 menuHolder.addView(scrollViewLeftMenu);
 menuHolder.addView(scrollViewRightMenu);
```
}

/**
- Returns left menu view so you can findViews and do whatever you want with
  */
  public View getLeftMenuView() {
  return scrollViewLeftMenu;
  }
/**
- Returns right menu view so you can findViews and do whatever you want with
  */
  public View getRightMenuView() {
  return scrollViewRightMenu;
  }
@OverRide
protected boolean fitSystemWindows(Rect insets) {
// Applies the content insets to the view's padding, consuming that
// content (modifying the insets to be 0),
// and returning true. This behavior is off by default and can be
// enabled through setFitsSystemWindows(boolean)
// in api14+ devices.
```
 Point appUsableSize = getAppUsableScreenSize(mContext);
 Point realScreenSize = getRealScreenSize(mContext);

 boolean hasBackKey=false;
 // navigation bar at the bottom
 if (appUsableSize.y < realScreenSize.y) {
     hasBackKey=true;
 }




 // This is added to fix soft navigationBar's overlapping to content above LOLLIPOP
 int bottomPadding = viewActivity.getPaddingBottom() + insets.bottom;

 if (hasBackKey ) {//there's a navigation bar
     bottomPadding += getNavigationBarHeight();
 }

 this.setPadding(viewActivity.getPaddingLeft() + insets.left,
         viewActivity.getPaddingTop() + insets.top,
         viewActivity.getPaddingRight() + insets.right,
         bottomPadding);
 insets.left = insets.top = insets.right = insets.bottom = 0;
 return true;
```
}

public static Point getAppUsableScreenSize(Context context) {
WindowManager windowManager = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
Display display = windowManager.getDefaultDisplay();
Point size = new Point();
display.getSize(size);
return size;
}

public static Point getRealScreenSize(Context context) {
WindowManager windowManager = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
Display display = windowManager.getDefaultDisplay();
Point size = new Point();
```
 if (Build.VERSION.SDK_INT >= 17) {
     display.getRealSize(size);
 } else if (Build.VERSION.SDK_INT >= 14) {
     try {
         size.x = (Integer) Display.class.getMethod("getRawWidth").invoke(display);
         size.y = (Integer) Display.class.getMethod("getRawHeight").invoke(display);
     } catch (IllegalAccessException e) {} catch (InvocationTargetException e) {} catch (NoSuchMethodException e) {}
 }

 return size;
```
}

private int getNavigationBarHeight() {
Resources resources = getResources();
int resourceId = resources.getIdentifier("navigation_bar_height", "dimen", "android");
if (resourceId > 0) {
return resources.getDimensionPixelSize(resourceId);
}
return 0;
}

/**
- Set up the activity;
- @param activity
  */
  public void attachToActivity(Activity activity) {
  initValue(activity);
  setShadowAdjustScaleXByOrientation();
  viewDecor.addView(this, 0);
  }
private void initValue(Activity activity) {
this.activity = activity;
leftMenuItems = new ArrayList();
rightMenuItems = new ArrayList();
ignoredViews = new ArrayList();
viewDecor = (ViewGroup) activity.getWindow().getDecorView();
viewActivity = new TouchDisableView(this.activity);
```
 View mContent = viewDecor.getChildAt(0);
 viewDecor.removeViewAt(0);
 viewActivity.setContent(mContent);
 addView(viewActivity);

 ViewGroup parent = (ViewGroup) scrollViewLeftMenu.getParent();
 parent.removeView(scrollViewLeftMenu);
 parent.removeView(scrollViewRightMenu);
```
}

private void setShadowAdjustScaleXByOrientation() {
int orientation = getResources().getConfiguration().orientation;
if (orientation == Configuration.ORIENTATION_LANDSCAPE) {
shadowAdjustScaleX = 0.034f;
shadowAdjustScaleY = 0.12f;
} else if (orientation == Configuration.ORIENTATION_PORTRAIT) {
shadowAdjustScaleX = 0.06f;
shadowAdjustScaleY = 0.07f;
}
}

/**
- Set the background image of menu;
- @param imageResource
  */
  public void setBackground(int imageResource) {
  imageViewBackground.setImageResource(imageResource);
  }
/**
- The visibility of the shadow under the activity;
- @param isVisible
  */
  public void setShadowVisible(boolean isVisible) {
  if (isVisible)
  imageViewShadow.setBackgroundResource(R.drawable.shadow);
  else
  imageViewShadow.setBackgroundResource(0);
  }
/**
- Add a single item to the left menu;
- WARNING: It will be removed from v2.0.
- @param menuItem
  */
  @deprecated
  public void addMenuItem(ResideMenuItem menuItem) {
  this.leftMenuItems.add(menuItem);
  layoutLeftMenu.addView(menuItem);
  }
/**
- Add a single items;
- @param menuItem
- @param direction
  */
  public void addMenuItem(ResideMenuItem menuItem, int direction) {
  if (direction == DIRECTION_LEFT) {
  this.leftMenuItems.add(menuItem);
  layoutLeftMenu.addView(menuItem);
  } else {
  this.rightMenuItems.add(menuItem);
  layoutRightMenu.addView(menuItem);
  }
  }
/**
- WARNING: It will be removed from v2.0.
- @param menuItems
  */
  @deprecated
  public void setMenuItems(List menuItems) {
  this.leftMenuItems = menuItems;
  rebuildMenu();
  }
/**
- Set menu items by a array;
- @param menuItems
- @param direction
  */
  public void setMenuItems(List menuItems, int direction) {
  if (direction == DIRECTION_LEFT)
  this.leftMenuItems = menuItems;
  else
  this.rightMenuItems = menuItems;
  rebuildMenu();
  }
private void rebuildMenu() {
if (layoutLeftMenu != null) {
layoutLeftMenu.removeAllViews();
for (ResideMenuItem leftMenuItem : leftMenuItems)
layoutLeftMenu.addView(leftMenuItem);
}
```
 if (layoutRightMenu != null) {
     layoutRightMenu.removeAllViews();
     for (ResideMenuItem rightMenuItem : rightMenuItems)
         layoutRightMenu.addView(rightMenuItem);
 }
```
}

/**
- WARNING: It will be removed from v2.0.
- @return
  */
  @deprecated
  public List getMenuItems() {
  return leftMenuItems;
  }
/**
- Return instances of menu items;
- @return
  */
  public List getMenuItems(int direction) {
  if (direction == DIRECTION_LEFT)
  return leftMenuItems;
  else
  return rightMenuItems;
  }
/**
- If you need to do something on closing or opening menu,
- set a listener here.
- @return
  */
  public void setMenuListener(OnMenuListener menuListener) {
  this.menuListener = menuListener;
  }
public OnMenuListener getMenuListener() {
return menuListener;
}

/**
- Show the menu;
  */
  public void openMenu(int direction) {
  
  setScaleDirection(direction);
  
  isOpened = true;
  AnimatorSet scaleDown_activity = buildScaleDownAnimation(viewActivity, mScaleValue, mScaleValue);
  AnimatorSet scaleDown_shadow = buildScaleDownAnimation(imageViewShadow,
  mScaleValue + shadowAdjustScaleX, mScaleValue + shadowAdjustScaleY);
  AnimatorSet alpha_menu = buildMenuAnimation(scrollViewMenu, 1.0f);
  scaleDown_shadow.addListener(animationListener);
  scaleDown_activity.playTogether(scaleDown_shadow);
  scaleDown_activity.playTogether(alpha_menu);
  scaleDown_activity.start();
  }
/**
- Close the menu;
  */
  public void closeMenu() {
  
  isOpened = false;
  AnimatorSet scaleUp_activity = buildScaleUpAnimation(viewActivity, 1.0f, 1.0f);
  AnimatorSet scaleUp_shadow = buildScaleUpAnimation(imageViewShadow, 1.0f, 1.0f);
  AnimatorSet alpha_menu = buildMenuAnimation(scrollViewMenu, 0.0f);
  scaleUp_activity.addListener(animationListener);
  scaleUp_activity.playTogether(scaleUp_shadow);
  scaleUp_activity.playTogether(alpha_menu);
  scaleUp_activity.start();
  }
@deprecated
public void setDirectionDisable(int direction) {
disabledSwipeDirection.add(direction);
}

public void setSwipeDirectionDisable(int direction) {
disabledSwipeDirection.add(direction);
}

private boolean isInDisableDirection(int direction) {
return disabledSwipeDirection.contains(direction);
}

private void setScaleDirection(int direction) {
```
 int screenWidth = getScreenWidth();
 float pivotX;
 float pivotY = getScreenHeight() * 0.5f;

 if (direction == DIRECTION_LEFT) {
     scrollViewMenu = scrollViewLeftMenu;
     pivotX = screenWidth * 1.5f;
 } else {
     scrollViewMenu = scrollViewRightMenu;
     pivotX = screenWidth * -0.5f;
 }

 ViewHelper.setPivotX(viewActivity, pivotX);
 ViewHelper.setPivotY(viewActivity, pivotY);
 ViewHelper.setPivotX(imageViewShadow, pivotX);
 ViewHelper.setPivotY(imageViewShadow, pivotY);
 scaleDirection = direction;
```
}

/**
- return the flag of menu status;
- @return
  */
  public boolean isOpened() {
  return isOpened;
  }
private OnClickListener viewActivityOnClickListener = new OnClickListener() {
@OverRide
public void onClick(View view) {
if (isOpened()) closeMenu();
}
};

private Animator.AnimatorListener animationListener = new Animator.AnimatorListener() {
@OverRide
public void onAnimationStart(Animator animation) {
if (isOpened()) {
showScrollViewMenu(scrollViewMenu);
if (menuListener != null)
menuListener.openMenu();
}
}
```
 @Override
 public void onAnimationEnd(Animator animation) {
     // reset the view;
     if (isOpened()) {
         viewActivity.setTouchDisable(true);
         viewActivity.setOnClickListener(viewActivityOnClickListener);
     } else {
         viewActivity.setTouchDisable(false);
         viewActivity.setOnClickListener(null);
         hideScrollViewMenu(scrollViewLeftMenu);
         hideScrollViewMenu(scrollViewRightMenu);
         if (menuListener != null)
             menuListener.closeMenu();
     }
 }

 @Override
 public void onAnimationCancel(Animator animation) {

 }

 @Override
 public void onAnimationRepeat(Animator animation) {

 }
```
};

/**
- A helper method to build scale down animation;
- @param target
- @param targetScaleX
- @param targetScaleY
- @return
  */
  private AnimatorSet buildScaleDownAnimation(View target, float targetScaleX, float targetScaleY) {
  
  AnimatorSet scaleDown = new AnimatorSet();
  scaleDown.playTogether(
  ObjectAnimator.ofFloat(target, "scaleX", targetScaleX),
  ObjectAnimator.ofFloat(target, "scaleY", targetScaleY)
  );
  
  if (mUse3D) {
  int angle = scaleDirection == DIRECTION_LEFT ? -ROTATE_Y_ANGLE : ROTATE_Y_ANGLE;
  scaleDown.playTogether(ObjectAnimator.ofFloat(target, "rotationY", angle));
  }
  
  scaleDown.setInterpolator(AnimationUtils.loadInterpolator(activity,
  android.R.anim.decelerate_interpolator));
  scaleDown.setDuration(250);
  return scaleDown;
  }
/**
- A helper method to build scale up animation;
- @param target
- @param targetScaleX
- @param targetScaleY
- @return
  */
  private AnimatorSet buildScaleUpAnimation(View target, float targetScaleX, float targetScaleY) {
  
  AnimatorSet scaleUp = new AnimatorSet();
  scaleUp.playTogether(
  ObjectAnimator.ofFloat(target, "scaleX", targetScaleX),
  ObjectAnimator.ofFloat(target, "scaleY", targetScaleY)
  );
  
  if (mUse3D) {
  scaleUp.playTogether(ObjectAnimator.ofFloat(target, "rotationY", 0));
  }
  
  scaleUp.setDuration(250);
  return scaleUp;
  }
private AnimatorSet buildMenuAnimation(View target, float alpha) {
```
 AnimatorSet alphaAnimation = new AnimatorSet();
 alphaAnimation.playTogether(
         ObjectAnimator.ofFloat(target, "alpha", alpha)
 );

 alphaAnimation.setDuration(250);
 return alphaAnimation;
```
}

/**
- If there were some view you don't want reside menu
- to intercept their touch event, you could add it to
- ignored views.
- @param v
  */
  public void addIgnoredView(View v) {
  ignoredViews.add(v);
  }
/**
- Remove a view from ignored views;
- @param v
  */
  public void removeIgnoredView(View v) {
  ignoredViews.remove(v);
  }
/**
- Clear the ignored view list;
  */
  public void clearIgnoredViewList() {
  ignoredViews.clear();
  }
/**
- If the motion event was relative to the view
- which in ignored view list,return true;
- @param ev
- @return
  */
  private boolean isInIgnoredView(MotionEvent ev) {
  Rect rect = new Rect();
  for (View v : ignoredViews) {
  v.getGlobalVisibleRect(rect);
  if (rect.contains((int) ev.getX(), (int) ev.getY()))
  return true;
  }
  return false;
  }
private void setScaleDirectionByRawX(float currentRawX) {
if (currentRawX < lastRawX)
setScaleDirection(DIRECTION_RIGHT);
else
setScaleDirection(DIRECTION_LEFT);
}

private float getTargetScale(float currentRawX) {
float scaleFloatX = ((currentRawX - lastRawX) / getScreenWidth()) * 0.75f;
scaleFloatX = scaleDirection == DIRECTION_RIGHT ? -scaleFloatX : scaleFloatX;
```
 float targetScale = ViewHelper.getScaleX(viewActivity) - scaleFloatX;
 targetScale = targetScale > 1.0f ? 1.0f : targetScale;
 targetScale = targetScale < 0.5f ? 0.5f : targetScale;
 return targetScale;
```
}

private float lastActionDownX, lastActionDownY;

@OverRide
public boolean dispatchTouchEvent(MotionEvent ev) {
float currentActivityScaleX = ViewHelper.getScaleX(viewActivity);
if (currentActivityScaleX == 1.0f)
setScaleDirectionByRawX(ev.getRawX());
```
 switch (ev.getAction()) {
     case MotionEvent.ACTION_DOWN:
         lastActionDownX = ev.getX();
         lastActionDownY = ev.getY();
         isInIgnoredView = isInIgnoredView(ev) && !isOpened();
         pressedState = PRESSED_DOWN;
         break;

     case MotionEvent.ACTION_MOVE:
         if (isInIgnoredView || isInDisableDirection(scaleDirection))
             break;

         if (pressedState != PRESSED_DOWN &&
                 pressedState != PRESSED_MOVE_HORIZONTAL)
             break;

         int xOffset = (int) (ev.getX() - lastActionDownX);
         int yOffset = (int) (ev.getY() - lastActionDownY);

         if (pressedState == PRESSED_DOWN) {
             if (yOffset > 25 || yOffset < -25) {
                 pressedState = PRESSED_MOVE_VERTICAL;
                 break;
             }
             if (xOffset < -50 || xOffset > 50) {
                 pressedState = PRESSED_MOVE_HORIZONTAL;
                 ev.setAction(MotionEvent.ACTION_CANCEL);
             }
         } else if (pressedState == PRESSED_MOVE_HORIZONTAL) {
             if (currentActivityScaleX < 0.95)
                 showScrollViewMenu(scrollViewMenu);

             float targetScale = getTargetScale(ev.getRawX());
             if (mUse3D) {
                 float angle = scaleDirection == DIRECTION_LEFT ? -ROTATE_Y_ANGLE : ROTATE_Y_ANGLE;
                     //int angle = scaleDirection == DIRECTION_LEFT ? -ROTATE_Y_ANGLE : ROTATE_Y_ANGLE;
                 angle *= (1 - targetScale) * 2;
                 ViewHelper.setRotationY(viewActivity, angle);

                 ViewHelper.setScaleX(imageViewShadow, targetScale - shadowAdjustScaleX);
                 ViewHelper.setScaleY(imageViewShadow, targetScale - shadowAdjustScaleY);
             } else {
                 ViewHelper.setScaleX(imageViewShadow, targetScale + shadowAdjustScaleX);
                 ViewHelper.setScaleY(imageViewShadow, targetScale + shadowAdjustScaleY);
             }
             ViewHelper.setScaleX(viewActivity, targetScale);
             ViewHelper.setScaleY(viewActivity, targetScale);
             ViewHelper.setAlpha(scrollViewMenu, (1 - targetScale) * 2.0f);

             lastRawX = ev.getRawX();
             return true;
         }

         break;

     case MotionEvent.ACTION_UP:

         if (isInIgnoredView) break;
         if (pressedState != PRESSED_MOVE_HORIZONTAL) break;

         pressedState = PRESSED_DONE;
         if (isOpened()) {
             if (currentActivityScaleX > 0.56f)
                 closeMenu();
             else
                 openMenu(scaleDirection);
         } else {
             if (currentActivityScaleX < 0.94f) {
                 openMenu(scaleDirection);
             } else {
                 closeMenu();
             }
         }

         break;

 }
 lastRawX = ev.getRawX();
 return super.dispatchTouchEvent(ev);
```
}

public int getScreenHeight() {
activity.getWindowManager().getDefaultDisplay().getMetrics(displayMetrics);
return displayMetrics.heightPixels;
}

public int getScreenWidth() {
activity.getWindowManager().getDefaultDisplay().getMetrics(displayMetrics);
return displayMetrics.widthPixels;
}

public void setScaleValue(float scaleValue) {
this.mScaleValue = scaleValue;
}

public void setUse3D(boolean use3D) {
mUse3D = use3D;
}

public interface OnMenuListener {
```
 /**
  * This method will be called at the finished time of opening menu animations.
  */
 public void openMenu();

 /**
  * This method will be called at the finished time of closing menu animations.
  */
 public void closeMenu();
```
}

private void showScrollViewMenu(View scrollViewMenu) {
if (scrollViewMenu != null && scrollViewMenu.getParent() == null) {
addView(scrollViewMenu);
}
}

private void hideScrollViewMenu(View scrollViewMenu) {
if (scrollViewMenu != null && scrollViewMenu.getParent() != null) {
removeView(scrollViewMenu);
}
}
}

Answer 2 · 2018-07-21T11:06:12.000Z

public class CustomResideMenuItem extends ResideMenuItem {
    public CustomResideMenuItem_logo(Context context) {
        super(context);
        removeAllViews();
        LayoutInflater.from(getContext()).inflate(R.layout.item_residemenu_image, this);
    }
}

Answer 3 · 2019-07-17T07:17:51.000Z

Unable to add. Can you help me in that?