仿qq最新侧滑菜单

原创

wx5aae83353cec4 2022-12-16 20:01:15 ©著作权

文章标签 ci sed ide 文章分类 虚拟化云计算

©著作权归作者所有：来自51CTO博客作者wx5aae83353cec4的原创作品，请联系作者获取转载授权，否则将追究法律责任

为了后续对这个项目进行优化，比如透明度动画、背景图的位移动画，以及性能上的优化。

我把这个项目上传到github上面，请大家随时关注。

github地址 https://github.com/sunguowei

最近项目要做一个QQ5.0的侧滑菜单效果，和传统的侧滑菜单存在着一些差异。想必大家都已经见识过了。

为了不重复发明轮子，先去github上面搜索了一番。

发现了几个类似的，但是还是有一些不同。

下面是搜索到的类似的开源项目。

RESideMenu（ios项目）

https://github.com/romaonthego/RESideMenu

仿qq最新侧滑菜单_ide

AndroidResideMenu

https://github.com/SpecialCyCi/AndroidResideMenu

仿qq最新侧滑菜单_sed_02

ResideLayout

https://github.com/kyze8439690/ResideLayout

仿qq最新侧滑菜单_ide_03

研究了一下这些开源项目的源代码。感觉并不是特别适用于我们自己的项目。所以，我自己又研究了一下。最后的效果如下。当然了，还有很多可以优化的地方，后续再慢慢优化。

仿qq最新侧滑菜单_ide_04

备注：如果图片动画显示不出来，可以点击这个网址查看。

https://s2.51cto.com/images/blog/202209/07101227_6317fe0ba30b091784.gif

我是基于SlidingMenu库进行的二次修改，增加了一些转场动画。

大家对这个库应该比较熟悉，下面是SlidingMenu的github地址。非常感谢Jeremy Feinstein提供的这个库，让广大Android Developers省去了非常多的麻烦。

https://github.com/jfeinstein10/SlidingMenu

备注：SlidingMenu使用了SherlockActionBar这个库，配置起来会比较麻烦，在文章的最后我会把demo上传，供大家下载，减去了大家自己配置项目的麻烦。

我主要修改了2个类，SlidingMenu.java和CustonViewAbove.java，只是增加了一些功能，并没有修改原本的功能。

做了修改的地方，我做了中文注释，其实实现很简单，几行代码而已。推荐大家下载Demo，然后自己调试一下。Demo的下载地址在文章的末尾。

废话不多说，直接上代码，略微有点长。

[java] view plain co

public class SlidingMenu extends
private static final String TAG = SlidingMenu.class.getSimpleName();
public static final int SLIDING_WINDOW = 0;
public static final int SLIDING_CONTENT = 1;
private boolean mActionbarOverlay = false;
/**
* Constant value for use with setTouchModeAbove(). Allows the SlidingMenu
* to be opened with a swipe gesture on the screen's margin
*/
public static final int TOUCHMODE_MARGIN = 0;
/**
* Constant value for use with setTouchModeAbove(). Allows the SlidingMenu
* to be opened with a swipe gesture anywhere on the screen
*/
public static final int TOUCHMODE_FULLSCREEN = 1;
/**
* Constant value for use with setTouchModeAbove(). Denies the SlidingMenu
* to be opened with a swipe gesture
*/
public static final int TOUCHMODE_NONE = 2;
/**
* Constant value for use with setMode(). Puts the menu to the left of the
* content.
*/
public static final int LEFT = 0;
/**
* Constant value for use with setMode(). Puts the menu to the right of the
* content.
*/
public static final int RIGHT = 1;
/**
* Constant value for use with setMode(). Puts menus to the left and right
* of the content.
*/
public static final int LEFT_RIGHT = 2;
private
private
/** 整体的背景，用一个ImageView代替 */
private
private
private
private
/**
* The listener interface for receiving onOpen events. The class that is
* interested in processing a onOpen event implements this interface, and
* the object created with that class is registered with a component using
* the component's <code>addOnOpenListener<code> method. When
* the onOpen event occurs, that object's appropriate
* method is invoked
*/
public interface
/**
* On open.
*/
public void
}
/**
* The listener interface for receiving onOpened events. The class that is
* interested in processing a onOpened event implements this interface, and
* the object created with that class is registered with a component using
* the component's <code>addOnOpenedListener<code> method. When
* the onOpened event occurs, that object's appropriate
* method is invoked.
*
* @see OnOpenedEvent
*/
public interface
/**
* On opened.
*/
public void
}
/**
* The listener interface for receiving onClose events. The class that is
* interested in processing a onClose event implements this interface, and
* the object created with that class is registered with a component using
* the component's <code>addOnCloseListener<code> method. When
* the onClose event occurs, that object's appropriate
* method is invoked.
*
* @see OnCloseEvent
*/
public interface
/**
* On close.
*/
public void
}
/**
* The listener interface for receiving onClosed events. The class that is
* interested in processing a onClosed event implements this interface, and
* the object created with that class is registered with a component using
* the component's <code>addOnClosedListener<code> method. When
* the onClosed event occurs, that object's appropriate
* method is invoked.
*
* @see OnClosedEvent
*/
public interface
/**
* On closed.
*/
public void
}
/**
* The Interface CanvasTransformer.
*/
public interface
/**
* Transform canvas.
*
* @param canvas
* the canvas
* @param percentOpen
* the percent open
*/
public void transformCanvas(Canvas canvas, float
}
/**
* Instantiates a new SlidingMenu.
*
* @param context
* the associated Context
*/
public
this(context, null);
}
/**
* Instantiates a new SlidingMenu and attach to Activity.
*
* @param activity
* the activity to attach slidingmenu
* @param slideStyle
* the slidingmenu style
*/
public SlidingMenu(Activity activity, int
this(activity, null);
this.attachToActivity(activity, slideStyle);
}
/**
* Instantiates a new SlidingMenu.
*
* @param context
* the associated Context
* @param attrs
* the attrs
*/
public
this(context, attrs, 0);
}
/**
* Instantiates a new SlidingMenu.
*
* @param context
* the associated Context
* @param attrs
* the attrs
* @param defStyle
* the def style
*/
public SlidingMenu(Context context, AttributeSet attrs, int
super(context, attrs, defStyle);
/** SlidingMenu是一个RelativeLayout，这里把背景图ImageView添加到RelativeLayout的最底层。*/
new
LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT);
new
mViewBackground.setScaleType(ImageView.ScaleType.CENTER_CROP);
addView(mViewBackground, backgroundParams);
new
LayoutParams.MATCH_PARENT);
new
addView(mViewBehind, behindParams);
new
LayoutParams.MATCH_PARENT);
new
addView(mViewAbove, aboveParams);
// register the CustomViewBehind with the CustomViewAbove
mViewAbove.setCustomViewBehind(mViewBehind);
mViewBehind.setCustomViewAbove(mViewAbove);
new
public static final int POSITION_OPEN = 0;
public static final int POSITION_CLOSE = 1;
public static final int POSITION_SECONDARY_OPEN = 2;
public void onPageScrolled(int position, float
int
}
public void onPageSelected(int
if (position == POSITION_OPEN && mOpenListener != null) {
mOpenListener.onOpen();
else if (position == POSITION_CLOSE && mCloseListener != null) {
mCloseListener.onClose();
else if
null) {
mSecondaryOpenListner.onOpen();
}
}
});
// now style everything!
TypedArray ta = context.obtainStyledAttributes(attrs,
R.styleable.SlidingMenu);
// set the above and behind views if defined in xml
int
setMode(mode);
int viewAbove = ta.getResourceId(R.styleable.SlidingMenu_viewAbove, -1);
if (viewAbove != -1) {
setContent(viewAbove);
else
new
}
int
1);
if (viewBehind != -1) {
setMenu(viewBehind);
else
new
}
int
TOUCHMODE_MARGIN);
setTouchModeAbove(touchModeAbove);
int
R.styleable.SlidingMenu_touchModeBehind, TOUCHMODE_MARGIN);
setTouchModeBehind(touchModeBehind);
int offsetBehind = (int) ta.getDimension(
1);
int widthBehind = (int) ta.getDimension(
1);
if (offsetBehind != -1 && widthBehind != -1)
throw new
"Cannot set both behindOffset and behindWidth for a SlidingMenu");
else if (offsetBehind != -1)
setBehindOffset(offsetBehind);
else if (widthBehind != -1)
setBehindWidth(widthBehind);
else
0);
float
0.33f);
setBehindScrollScale(scrollOffsetBehind);
int
1);
if (shadowRes != -1) {
setShadowDrawable(shadowRes);
}
int shadowWidth = (int) ta.getDimension(
0);
setShadowWidth(shadowWidth);
boolean
true);
setFadeEnabled(fadeEnabled);
float fadeDeg = ta.getFloat(R.styleable.SlidingMenu_fadeDegree, 0.33f);
setFadeDegree(fadeDeg);
boolean
false);
setSelectorEnabled(selectorEnabled);
int
1);
if (selectorRes != -1)
setSelectorDrawable(selectorRes);
ta.recycle();
}
/**
* Attaches the SlidingMenu to an entire Activity
*
* @param activity
* the Activity
* @param slideStyle
* either SLIDING_CONTENT or SLIDING_WINDOW
*/
public void attachToActivity(Activity activity, int
false);
}
/**
* Attaches the SlidingMenu to an entire Activity
*
* @param activity
* the Activity
* @param slideStyle
* either SLIDING_CONTENT or SLIDING_WINDOW
* @param actionbarOverlay
* whether or not the ActionBar is overlaid
*/
public void attachToActivity(Activity activity, int
boolean
if
throw new
"slideStyle must be either SLIDING_WINDOW or SLIDING_CONTENT");
if (getParent() != null)
throw new
"This SlidingMenu appears to already be attached");
// get the window background
TypedArray a = activity.getTheme().obtainStyledAttributes(
new int[] { android.R.attr.windowBackground });
int background = a.getResourceId(0, 0);
a.recycle();
switch
case
false;
ViewGroup decor = (ViewGroup) activity.getWindow().getDecorView();
0);
// save ActionBar themes that have transparent assets
decorChild.setBackgroundResource(background);
decor.removeView(decorChild);
this);
setContent(decorChild);
break;
case
mActionbarOverlay = actionbarOverlay;
// take the above view out of
ViewGroup contentParent = (ViewGroup) activity
.findViewById(android.R.id.content);
0);
contentParent.removeView(content);
this);
setContent(content);
// save people from having transparent backgrounds
if (content.getBackground() == null)
content.setBackgroundResource(background);
break;
}
}
/**
* Set the above view content from a layout resource. The resource will be
* inflated, adding all top-level views to the above view.
*
* @param res
* the new content
*/
public void setContent(int
null));
}
/**
* Set the above view content to the given View.
*
* @param view
* The desired content to display.
*/
public void
mViewAbove.setContent(view);
showContent();
}
/**
* 设置背景图片
*
* @param resid
*/
public void setBackgroundImage(int
mViewBackground.setBackgroundResource(resid);
}
/**
* Retrieves the current content.
*
* @return the current content
*/
public
return
}
/**
* Set the behind view (menu) content from a layout resource. The resource
* will be inflated, adding all top-level views to the behind view.
*
* @param res
* the new content
*/
public void setMenu(int
null));
}
/**
* Set the behind view (menu) content to the given View.
*
* @param view
* The desired content to display.
*/
public void
mViewBehind.setContent(v);
}
/**
* Retrieves the main menu.
*
* @return the main menu
*/
public
return
}
/**
* Set the secondary behind view (right menu) content from a layout
* resource. The resource will be inflated, adding all top-level views to
* the behind view.
*
* @param res
* the new content
*/
public void setSecondaryMenu(int
null));
}
/**
* Set the secondary behind view (right menu) content to the given View.
*
* @param view
* The desired content to display.
*/
public void
mViewBehind.setSecondaryContent(v);
// mViewBehind.invalidate();
}
/**
* Retrieves the current secondary menu (right).
*
* @return the current menu
*/
public
return
}
/**
* Sets the sliding enabled.
*
* @param b
* true to enable sliding, false to disable it.
*/
public void setSlidingEnabled(boolean
mViewAbove.setSlidingEnabled(b);
}
/**
* Checks if is sliding enabled.
*
* @return true, if is sliding enabled
*/
public boolean
return
}
/**
* Sets which side the SlidingMenu should appear on.
*
* @param mode
* must be either SlidingMenu.LEFT or SlidingMenu.RIGHT
*/
public void setMode(int
if
throw new
"SlidingMenu mode must be LEFT, RIGHT, or LEFT_RIGHT");
}
mViewBehind.setMode(mode);
}
/**
* Returns the current side that the SlidingMenu is on.
*
* @return the current mode, either SlidingMenu.LEFT or SlidingMenu.RIGHT
*/
public int
return
}
/**
* Sets whether or not the SlidingMenu is in static mode (i.e. nothing is
* moving and everything is showing)
*
* @param b
* true to set static mode, false to disable static mode.
*/
public void setStatic(boolean
if
false);
null);
1);
// mViewBehind.setCurrentItem(0);
else
1);
// mViewBehind.setCurrentItem(1);
mViewAbove.setCustomViewBehind(mViewBehind);
true);
}
}
/**
* Opens the menu and shows the menu view.
*/
public void
true);
}
/**
* Opens the menu and shows the menu view.
*
* @param animate
* true to animate the transition, false to ignore animation
*/
public void showMenu(boolean
0, animate);
}
/**
* Opens the menu and shows the secondary menu view. Will default to the
* regular menu if there is only one.
*/
public void
true);
}
/**
* Opens the menu and shows the secondary (right) menu view. Will default to
* the regular menu if there is only one.
*
* @param animate
* true to animate the transition, false to ignore animation
*/
public void showSecondaryMenu(boolean
2, animate);
}
/**
* Closes the menu and shows the above view.
*/
public void
true);
}
/**
* Closes the menu and shows the above view.
*
* @param animate
* true to animate the transition, false to ignore animation
*/
public void showContent(boolean
1, animate);
}
/**
* Toggle the SlidingMenu. If it is open, it will be closed, and vice versa.
*/
public void
true);
}
/**
* Toggle the SlidingMenu. If it is open, it will be closed, and vice versa.
*
* @param animate
* true to animate the transition, false to ignore animation
*/
public void toggle(boolean
if
showContent(animate);
else
showMenu(animate);
}
}
/**
* Checks if is the behind view showing.
*
* @return Whether or not the behind view is showing
*/
public boolean
return mViewAbove.getCurrentItem() == 0
2;
}
/**
* Checks if is the behind view showing.
*
* @return Whether or not the behind view is showing
*/
public boolean
return mViewAbove.getCurrentItem() == 2;
}
/**
* Gets the behind offset.
*
* @return The margin on the right of the screen that the behind view
* scrolls to
*/
public int
return
}
/**
* Sets the behind offset.
*
* @param i
* The margin, in pixels, on the right of the screen that the
* behind view scrolls to.
*/
public void setBehindOffset(int
// RelativeLayout.LayoutParams params =
// ((RelativeLayout.LayoutParams)mViewBehind.getLayoutParams());
// int bottom = params.bottomMargin;
// int top = params.topMargin;
// int left = params.leftMargin;
// params.setMargins(left, top, i, bottom);
mViewBehind.setWidthOffset(i);
}
/**
* Sets the behind offset.
*
* @param resID
* The dimension resource id to be set as the behind offset. The
* menu, when open, will leave this width margin on the right of
* the screen.
*/
public void setBehindOffsetRes(int
int i = (int) getContext().getResources().getDimension(resID);
setBehindOffset(i);
}
/**
* Sets the above offset.
*
* @param i
* the new above offset, in pixels
*/
public void setAboveOffset(int
mViewAbove.setAboveOffset(i);
}
/**
* Sets the above offset.
*
* @param resID
* The dimension resource id to be set as the above offset.
*/
public void setAboveOffsetRes(int
int i = (int) getContext().getResources().getDimension(resID);
setAboveOffset(i);
}
/**
* Sets the behind width.
*
* @param i
* The width the Sliding Menu will open to, in pixels
*/
@SuppressWarnings("deprecation")
public void setBehindWidth(int
int
Display display = ((WindowManager) getContext().getSystemService(
Context.WINDOW_SERVICE)).getDefaultDisplay();
try
class;
class
new
"getSize", parameterTypes);
method.invoke(display, parameter);
width = parameter.x;
catch
width = display.getWidth();
}
setBehindOffset(width - i);
}
/**
* Sets the behind width.
*
* @param res
* The dimension resource id to be set as the behind width
* offset. The menu, when open, will open this wide.
*/
public void setBehindWidthRes(int
int i = (int) getContext().getResources().getDimension(res);
setBehindWidth(i);
}
/**
* Gets the behind scroll scale.
*
* @return The scale of the parallax scroll
*/
public float
return
}
/**
* Gets the touch mode margin threshold
*
* @return the touch mode margin threshold
*/
public int
return
}
/**
* Set the touch mode margin threshold
*
* @param touchmodeMarginThreshold
*/
public void setTouchmodeMarginThreshold(int
mViewBehind.setMarginThreshold(touchmodeMarginThreshold);
}
/**
* Sets the behind scroll scale.
*
* @param f
* The scale of the parallax scroll (i.e. 1.0f scrolls 1 pixel
* for every 1 pixel that the above view scrolls and 0.0f scrolls
* 0 pixels)
*/
public void setBehindScrollScale(float
if (f < 0 && f > 1)
throw new
"ScrollScale must be between 0 and 1");
mViewBehind.setScrollScale(f);
}
/**
* Sets the behind canvas transformer.
*
* @param t
* the new behind canvas transformer
*/
public void
mViewBehind.setCanvasTransformer(t);
}
/**
* 设置右侧视图的转场动画
*
* @param t
* the new above canvas transformer
*/
public void
mViewAbove.setCanvasTransformer(t);
}
/**
* Gets the touch mode above.
*
* @return the touch mode above
*/
public int
return
}
/**
* Controls whether the SlidingMenu can be opened with a swipe gesture.
* Options are {@link #TOUCHMODE_MARGIN TOUCHMODE_MARGIN},
* {@link #TOUCHMODE_FULLSCREEN TOUCHMODE_FULLSCREEN}, or
* {@link #TOUCHMODE_NONE TOUCHMODE_NONE}
*
* @param i
* the new touch mode
*/
public void setTouchModeAbove(int
if
&& i != TOUCHMODE_NONE) {
throw new
"TouchMode must be set to either"
"TOUCHMODE_FULLSCREEN or TOUCHMODE_MARGIN or TOUCHMODE_NONE.");
}
mViewAbove.setTouchMode(i);
}
/**
* Controls whether the SlidingMenu can be opened with a swipe gesture.
* Options are {@link #TOUCHMODE_MARGIN TOUCHMODE_MARGIN},
* {@link #TOUCHMODE_FULLSCREEN TOUCHMODE_FULLSCREEN}, or
* {@link #TOUCHMODE_NONE TOUCHMODE_NONE}
*
* @param i
* the new touch mode
*/
public void setTouchModeBehind(int
if
&& i != TOUCHMODE_NONE) {
throw new
"TouchMode must be set to either"
"TOUCHMODE_FULLSCREEN or TOUCHMODE_MARGIN or TOUCHMODE_NONE.");
}
mViewBehind.setTouchMode(i);
}
/**
* Sets the shadow drawable.
*
* @param resId
* the resource ID of the new shadow drawable
*/
public void setShadowDrawable(int
setShadowDrawable(getContext().getResources().getDrawable(resId));
}
/**
* Sets the shadow drawable.
*
* @param d
* the new shadow drawable
*/
public void
mViewBehind.setShadowDrawable(d);
}
/**
* Sets the secondary (right) shadow drawable.
*
* @param resId
* the resource ID of the new shadow drawable
*/
public void setSecondaryShadowDrawable(int
setSecondaryShadowDrawable(getContext().getResources().getDrawable(
resId));
}
/**
* Sets the secondary (right) shadow drawable.
*
* @param d
* the new shadow drawable
*/
public void
mViewBehind.setSecondaryShadowDrawable(d);
}
/**
* Sets the shadow width.
*
* @param resId
* The dimension resource id to be set as the shadow width.
*/
public void setShadowWidthRes(int
int) getResources().getDimension(resId));
}
/**
* Sets the shadow width.
*
* @param pixels
* the new shadow width, in pixels
*/
public void setShadowWidth(int
mViewBehind.setShadowWidth(pixels);
}
/**
* Enables or disables the SlidingMenu's fade in and out
*
* @param b
* true to enable fade, false to disable it
*/
public void setFadeEnabled(boolean
mViewBehind.setFadeEnabled(b);
}
/**
* Sets how much the SlidingMenu fades in and out. Fade must be enabled, see
* {@link #setFadeEnabled(boolean) setFadeEnabled(boolean)}
*
* @param f
* the new fade degree, between 0.0f and 1.0f
*/
public void setFadeDegree(float
mViewBehind.setFadeDegree(f);
}
/**
* Enables or disables whether the selector is drawn
*
* @param b
* true to draw the selector, false to not draw the selector
*/
public void setSelectorEnabled(boolean
true);
}
/**
* Sets the selected view. The selector will be drawn here
*
* @param v
* the new selected view
*/
public void
mViewBehind.setSelectedView(v);
}
/**
* Sets the selector drawable.
*
* @param res
* a resource ID for the selector drawable
*/
public void setSelectorDrawable(int
mViewBehind.setSelectorBitmap(BitmapFactory.decodeResource(
getResources(), res));
}
/**
* Sets the selector drawable.
*
* @param b
* the new selector bitmap
*/
public void
mViewBehind.setSelectorBitmap(b);
}
/**
* Add a View ignored by the Touch Down event when mode is Fullscreen
*
* @param v
* a view to be ignored
*/
public void
mViewAbove.addIgnoredView(v);
}
/**
* Remove a View ignored by the Touch Down event when mode is Fullscreen
*
* @param v
* a view not wanted to be ignored anymore
*/
public void
mViewAbove.removeIgnoredView(v);
}
/**
* Clear the list of Views ignored by the Touch Down event when mode is
* Fullscreen
*/
public void
mViewAbove.clearIgnoredViews();
}
/**
* Sets the OnOpenListener. {@link OnOpenListener#onOpen()
* OnOpenListener.onOpen()} will be called when the SlidingMenu is opened
*
* @param listener
* the new OnOpenListener
*/
public void
// mViewAbove.setOnOpenListener(listener);
mOpenListener = listener;
}
/**
* Sets the OnOpenListner for secondary menu {@link OnOpenListener#onOpen()
* OnOpenListener.onOpen()} will be called when the secondary SlidingMenu is
* opened
*
* @param listener
* the new OnOpenListener
*/
public void
mSecondaryOpenListner = listener;
}
/**
* Sets the OnCloseListener. {@link OnCloseListener#onClose()
* OnCloseListener.onClose()} will be called when any one of the SlidingMenu
* is closed
*
* @param listener
* the new setOnCloseListener
*/
public void
// mViewAbove.setOnCloseListener(listener);
mCloseListener = listener;
}
/**
* Sets the OnOpenedListener. {@link OnOpenedListener#onOpened()
* OnOpenedListener.onOpened()} will be called after the SlidingMenu is
* opened
*
* @param listener
* the new OnOpenedListener
*/
public void
mViewAbove.setOnOpenedListener(listener);
}
/**
* Sets the OnClosedListener. {@link OnClosedListener#onClosed()
* OnClosedListener.onClosed()} will be called after the SlidingMenu is
* closed
*
* @param listener
* the new OnClosedListener
*/
public void
mViewAbove.setOnClosedListener(listener);
}
public static class SavedState extends
private final int
public SavedState(Parcelable superState, int
super(superState);
mItem = item;
}
private
super(in);
mItem = in.readInt();
}
public int
return
}
/*
* (non-Javadoc)
*
* @see android.view.AbsSavedState#writeToParcel(android.os.Parcel, int)
*/
public void writeToParcel(Parcel out, int
super.writeToParcel(out, flags);
out.writeInt(mItem);
}
public static final Parcelable.Creator<SavedState> CREATOR = new
public
return new
}
public SavedState[] newArray(int
return new
}
};
}
/*
* (non-Javadoc)
*
* @see android.view.View#onSaveInstanceState()
*/
@Override
protected
super.onSaveInstanceState();
new
return
}
/*
* (non-Javadoc)
*
* @see android.view.View#onRestoreInstanceState(android.os.Parcelable)
*/
@Override
protected void
SavedState ss = (SavedState) state;
super.onRestoreInstanceState(ss.getSuperState());
mViewAbove.setCurrentItem(ss.getItem());
}
/*
* (non-Javadoc)
*
* @see android.view.ViewGroup#fitSystemWindows(android.graphics.Rect)
*/
@SuppressLint("NewApi")
@Override
protected boolean
int
int
int
int
if
"setting padding!");
setPadding(leftPadding, topPadding, rightPadding, bottomPadding);
}
return true;
}
@TargetApi(Build.VERSION_CODES.HONEYCOMB)
public void manageLayers(float
if (Build.VERSION.SDK_INT < 11)
return;
boolean layer = percentOpen > 0.0f && percentOpen < 1.0f;
final int
: View.LAYER_TYPE_NONE;
if
new
public void
"changing layerType. hardware? "
+ (layerType == View.LAYER_TYPE_HARDWARE));
null);
null);
if (getSecondaryMenu() != null) {
null);
}
}
});
}
}
}

[java] view plain cop

public class CustomViewAbove extends
private static final String TAG = "CustomViewAbove";
private static final boolean DEBUG = false;
private static final boolean USE_CACHE = false;
private static final int MAX_SETTLE_DURATION = 600; // ms
private static final int MIN_DISTANCE_FOR_FLING = 25; // dips
private static final Interpolator sInterpolator = new
public float getInterpolation(float
1.0f;
return t * t * t * t * t + 1.0f;
}
};
private
private int
private
private boolean
private boolean
private boolean
private boolean
private int
private float
/**
* Position of the last motion event.
*/
private float
private float
/**
* ID of the active pointer. This is used to retain consistency during
* drags/flings if multiple pointers are used.
*/
protected int
/**
* Sentinel value for no current active pointer.
* Used by {@link #mActivePointerId}.
*/
private static final int INVALID_POINTER = -1;
/** 保存转场动画的变量*/
private
/**
* Determines speed during touch scrolling
*/
protected
private int
protected int
private int
private
// private int mMode;
private boolean mEnabled = true;
private
private
// private OnCloseListener mCloseListener;
// private OnOpenListener mOpenListener;
private
private
private List<View> mIgnoredViews = new
// private int mScrollState = SCROLL_STATE_IDLE;
/**
* Callback interface for responding to changing state of the selected page.
*/
public interface
/**
* This method will be invoked when the current page is scrolled, either as part
* of a programmatically initiated smooth scroll or a user initiated touch scroll.
*
* @param position Position index of the first page currently being displayed.
* Page position+1 will be visible if positionOffset is nonzero.
* @param positionOffset Value from [0, 1) indicating the offset from the page at position.
* @param positionOffsetPixels Value in pixels indicating the offset from position.
*/
public void onPageScrolled(int position, float positionOffset, int
/**
* This method will be invoked when a new page becomes selected. Animation is not
* necessarily complete.
*
* @param position Position index of the new selected page.
*/
public void onPageSelected(int
}
/**
* Simple implementation of the {@link OnPageChangeListener} interface with stub
* implementations of each method. Extend this if you do not intend to override
* every method of {@link OnPageChangeListener}.
*/
public static class SimpleOnPageChangeListener implements
public void onPageScrolled(int position, float positionOffset, int
// This space for rent
}
public void onPageSelected(int
// This space for rent
}
public void onPageScrollStateChanged(int
// This space for rent
}
}
public
this(context, null);
}
public
super(context, attrs);
initCustomViewAbove();
}
void
false);
setDescendantFocusability(FOCUS_AFTER_DESCENDANTS);
true);
final
new
final
mTouchSlop = ViewConfigurationCompat.getScaledPagingTouchSlop(configuration);
mMinimumVelocity = configuration.getScaledMinimumFlingVelocity();
mMaximumVelocity = configuration.getScaledMaximumFlingVelocity();
new
public void onPageSelected(int
if (mViewBehind != null) {
switch
case 0:
case 2:
true);
break;
case 1:
false);
break;
}
}
}
});
final float
int) (MIN_DISTANCE_FOR_FLING * density);
}
/**
* Set the currently selected page. If the CustomViewPager has already been through its first
* layout there will be a smooth animated transition between the current item and the
* specified item.
*
* @param item Item index to select
*/
public void setCurrentItem(int
true, false);
}
/**
* Set the currently selected page.
*
* @param item Item index to select
* @param smoothScroll True to smoothly scroll to the new item, false to transition immediately
*/
public void setCurrentItem(int item, boolean
false);
}
public int
return
}
void setCurrentItemInternal(int item, boolean smoothScroll, boolean
0);
}
void setCurrentItemInternal(int item, boolean smoothScroll, boolean always, int
if
false);
return;
}
item = mViewBehind.getMenuPage(item);
final boolean
mCurItem = item;
final int
if (dispatchSelected && mOnPageChangeListener != null) {
mOnPageChangeListener.onPageSelected(item);
}
if (dispatchSelected && mInternalPageChangeListener != null) {
mInternalPageChangeListener.onPageSelected(item);
}
if
0, velocity);
else
completeScroll();
0);
}
}
/**
* Set a listener that will be invoked whenever the page changes or is incrementally
* scrolled. See {@link OnPageChangeListener}.
*
* @param listener Listener to set
*/
public void
mOnPageChangeListener = listener;
}
/*
public void setOnOpenListener(OnOpenListener l) {
mOpenListener = l;
}
public void setOnCloseListener(OnCloseListener l) {
mCloseListener = l;
}
*/
public void
mOpenedListener = l;
}
public void
mClosedListener = l;
}
/**
* Set a separate OnPageChangeListener for internal use by the support library.
*
* @param listener Listener to set
* @return The old listener that was set, if any.
*/
OnPageChangeListener setInternalPageChangeListener(OnPageChangeListener listener) {
OnPageChangeListener oldListener = mInternalPageChangeListener;
mInternalPageChangeListener = listener;
return
}
public void
if
mIgnoredViews.add(v);
}
}
public void
mIgnoredViews.remove(v);
}
public void
mIgnoredViews.clear();
}
// We want the duration of the page snap animation to be influenced by the distance that
// the screen has to travel, however, we don't want this duration to be effected in a
// purely linear fashion. Instead, we use this method to moderate the effect that the distance
// of travel has on the overall snap duration.
float distanceInfluenceForSnapDuration(float
0.5f; // center the values about 0.
0.3f * Math.PI / 2.0f;
return (float) FloatMath.sin(f);
}
public int getDestScrollX(int
switch
case 0:
case 2:
return
case 1:
return
}
return 0;
}
private int
return
}
private int
return
}
public int
return
}
public boolean
return mCurItem == 0 || mCurItem == 2;
}
private boolean
new
for
v.getHitRect(rect);
if (rect.contains((int)ev.getX(), (int)ev.getY())) return true;
}
return false;
}
public int
if (mViewBehind == null) {
return 0;
else
return
}
}
public int getChildWidth(int
switch
case 0:
return
case 1:
return
default:
return 0;
}
}
public boolean
return
}
public void setSlidingEnabled(boolean
mEnabled = b;
}
/**
* Like {@link View#scrollBy}, but scroll smoothly instead of immediately.
*
* @param x the number of pixels to scroll by on the X axis
* @param y the number of pixels to scroll by on the Y axis
*/
void smoothScrollTo(int x, int
0);
}
/**
* Like {@link View#scrollBy}, but scroll smoothly instead of immediately.
*
* @param x the number of pixels to scroll by on the X axis
* @param y the number of pixels to scroll by on the Y axis
* @param velocity the velocity associated with a fling, if applicable. (0 otherwise)
*/
void smoothScrollTo(int x, int y, int
if (getChildCount() == 0) {
// Nothing to do.
false);
return;
}
int
int
int
int
if (dx == 0 && dy == 0) {
completeScroll();
if
if (mOpenedListener != null)
mOpenedListener.onOpened();
else
if (mClosedListener != null)
mClosedListener.onClosed();
}
return;
}
true);
true;
final int
final int halfWidth = width / 2;
final float distanceRatio = Math.min(1f, 1.0f * Math.abs(dx) / width);
final float
distanceInfluenceForSnapDuration(distanceRatio);
int duration = 0;
velocity = Math.abs(velocity);
if (velocity > 0) {
4 * Math.round(1000
else
final float pageDelta = (float) Math.abs(dx) / width;
int) ((pageDelta + 1) * 100);
duration = MAX_SETTLE_DURATION;
}
duration = Math.min(duration, MAX_SETTLE_DURATION);
mScroller.startScroll(sx, sy, dx, dy, duration);
invalidate();
}
public void
if (mContent != null)
this.removeView(mContent);
mContent = v;
addView(mContent);
}
public
return
}
public void
mViewBehind = cvb;
}
@Override
protected void onMeasure(int widthMeasureSpec, int
int width = getDefaultSize(0, widthMeasureSpec);
int height = getDefaultSize(0, heightMeasureSpec);
setMeasuredDimension(width, height);
final int contentWidth = getChildMeasureSpec(widthMeasureSpec, 0, width);
final int contentHeight = getChildMeasureSpec(heightMeasureSpec, 0, height);
mContent.measure(contentWidth, contentHeight);
}
@Override
protected void onSizeChanged(int w, int h, int oldw, int
super.onSizeChanged(w, h, oldw, oldh);
// Make sure scroll position is set correctly.
if
// [ChrisJ] - This fixes the onConfiguration change for orientation issue..
// maybe worth having a look why the recomputeScroll pos is screwing
// up?
completeScroll();
scrollTo(getDestScrollX(mCurItem), getScrollY());
}
}
@Override
protected void onLayout(boolean changed, int l, int t, int r, int
final int
final int
0, 0, width, height);
}
public void setAboveOffset(int
// RelativeLayout.LayoutParams params = ((RelativeLayout.LayoutParams)mContent.getLayoutParams());
// params.setMargins(i, params.topMargin, params.rightMargin, params.bottomMargin);
mContent.setPadding(i, mContent.getPaddingTop(),
mContent.getPaddingRight(), mContent.getPaddingBottom());
}
@Override
public void
if
if
int
int
int
int
if
scrollTo(x, y);
pageScrolled(x);
}
// Keep on drawing until the animation has finished.
invalidate();
return;
}
}
// Done with scroll, clean up state.
completeScroll();
}
private void pageScrolled(int
final int
final int
final int
final float offset = (float) offsetPixels / widthWithMargin;
onPageScrolled(position, offset, offsetPixels);
}
/**
* This method will be invoked when the current page is scrolled, either as part
* of a programmatically initiated smooth scroll or a user initiated touch scroll.
* If you override this method you must call through to the superclass implementation
* (e.g. super.onPageScrolled(position, offset, offsetPixels)) before onPageScrolled
* returns.
*
* @param position Position index of the first page currently being displayed.
* Page position+1 will be visible if positionOffset is nonzero.
* @param offset Value from [0, 1) indicating the offset from the page at position.
* @param offsetPixels Value in pixels indicating the offset from position.
*/
protected void onPageScrolled(int position, float offset, int
if (mOnPageChangeListener != null) {
mOnPageChangeListener.onPageScrolled(position, offset, offsetPixels);
}
if (mInternalPageChangeListener != null) {
mInternalPageChangeListener.onPageScrolled(position, offset, offsetPixels);
}
}
private void
boolean
if
// Done with scroll, no longer want to cache view drawing.
false);
mScroller.abortAnimation();
int
int
int
int
if
scrollTo(x, y);
}
if
if (mOpenedListener != null)
mOpenedListener.onOpened();
else
if (mClosedListener != null)
mClosedListener.onClosed();
}
}
false;
}
protected int
public void setTouchMode(int
mTouchMode = i;
}
public int
return
}
private boolean
int x = (int) (ev.getX() + mScrollX);
if
return
else
switch
case
return
case
return false;
case
return
}
}
return false;
}
private boolean thisSlideAllowed(float
boolean allowed = false;
if
allowed = mViewBehind.menuOpenSlideAllowed(dx);
else
allowed = mViewBehind.menuClosedSlideAllowed(dx);
}
if
"this slide allowed " + allowed + " dx: "
return
}
private int getPointerIndex(MotionEvent ev, int
int
if (activePointerIndex == -1)
mActivePointerId = INVALID_POINTER;
return
}
private boolean mQuickReturn = false;
@Override
public boolean
if
return false;
final int
if
if
"Received ACTION_DOWN");
if
|| (action != MotionEvent.ACTION_DOWN && mIsUnableToDrag)) {
endDrag();
return false;
}
switch
case
determineDrag(ev);
break;
case
int
mActivePointerId = MotionEventCompat.getPointerId(ev, index);
if
break;
mLastMotionX = mInitialMotionX = MotionEventCompat.getX(ev, index);
mLastMotionY = MotionEventCompat.getY(ev, index);
if
false;
false;
if
true;
}
else
true;
}
break;
case
onSecondaryPointerUp(ev);
break;
}
if
if (mVelocityTracker == null) {
mVelocityTracker = VelocityTracker.obtain();
}
mVelocityTracker.addMovement(ev);
}
return
}
@Override
public boolean
if
return false;
if
return false;
// if (!mIsBeingDragged && !mQuickReturn)
// return false;
final int
if (mVelocityTracker == null) {
mVelocityTracker = VelocityTracker.obtain();
}
mVelocityTracker.addMovement(ev);
switch
case
/*
* If being flinged and user touches, stop the fling. isFinished
* will be false if being flinged.
*/
completeScroll();
// Remember where the motion event started
int
mActivePointerId = MotionEventCompat.getPointerId(ev, index);
mLastMotionX = mInitialMotionX = ev.getX();
break;
case
if
determineDrag(ev);
if
return false;
}
if
// Scroll to follow the motion event
final int
if
break;
final float
final float
mLastMotionX = x;
float
float
final float
final float
if
scrollX = leftBound;
else if
scrollX = rightBound;
}
// Don't lose the rounded component
int) scrollX;
int) scrollX, getScrollY());
int) scrollX);
}
break;
case
if
final
1000, mMaximumVelocity);
int initialVelocity = (int) VelocityTrackerCompat.getXVelocity(
velocityTracker, mActivePointerId);
final int
final float pageOffset = (float) (scrollX - getDestScrollX(mCurItem)) / getBehindWidth();
final int
if
final float
final int totalDelta = (int) (x - mInitialMotionX);
int
true, true, initialVelocity);
else
true, true, initialVelocity);
}
mActivePointerId = INVALID_POINTER;
endDrag();
else if
// close the menu
1);
endDrag();
}
break;
case
if
true, true);
mActivePointerId = INVALID_POINTER;
endDrag();
}
break;
case
final int
mLastMotionX = MotionEventCompat.getX(ev, indexx);
mActivePointerId = MotionEventCompat.getPointerId(ev, indexx);
break;
}
case
onSecondaryPointerUp(ev);
int
if
break;
mLastMotionX = MotionEventCompat.getX(ev, pointerIndex);
break;
}
return true;
}
private void
final int
final int
if
return;
final float
final float
final float
final float
final float
final float
if (xDiff > (isMenuOpen()?mTouchSlop/2:mTouchSlop) && xDiff > yDiff && thisSlideAllowed(dx)) {
startDrag();
mLastMotionX = x;
mLastMotionY = y;
true);
// TODO add back in touch slop check
else if
true;
}
}
@Override
public void scrollTo(int x, int
super.scrollTo(x, y);
mScrollX = x;
mViewBehind.scrollBehindTo(mContent, x, y);
((SlidingMenu)getParent()).manageLayers(getPercentOpen());
if (mTransformer != null) {
invalidate();
}
}
private int determineTargetPage(float pageOffset, int velocity, int
int
if
if (velocity > 0 && deltaX > 0) {
1;
else if (velocity < 0 && deltaX < 0){
1;
}
else
int) Math.round(mCurItem + pageOffset);
}
return
}
protected float
return
}
@Override
protected void
// 这句要注释掉，否则会出现2个右侧的视图，一个有转场动画，一个没有转场动画
// super.dispatchDraw(canvas);
// Draw the margin drawable if needed.
mViewBehind.drawShadow(mContent, canvas);
mViewBehind.drawFade(mContent, canvas, getPercentOpen());
mViewBehind.drawSelector(mContent, canvas, getPercentOpen());
// 设置右侧视图的转场效果，主要是修改Canvas。
if (mTransformer != null) {
canvas.save();
mTransformer.transformCanvas(canvas, getPercentOpen());
super.dispatchDraw(canvas);
canvas.restore();
else
super.dispatchDraw(canvas);
}
}
// variables for drawing
private float mScrollX = 0.0f;
private void
if (DEBUG) Log.v(TAG, "onSecondaryPointerUp called");
final int
final int
if
// This was our active pointer going up. Choose a new
// active pointer and adjust accordingly.
final int newPointerIndex = pointerIndex == 0 ? 1 : 0;
mLastMotionX = MotionEventCompat.getX(ev, newPointerIndex);
mActivePointerId = MotionEventCompat.getPointerId(ev, newPointerIndex);
if (mVelocityTracker != null) {
mVelocityTracker.clear();
}
}
}
private void
true;
false;
}
private void
false;
false;
false;
mActivePointerId = INVALID_POINTER;
if (mVelocityTracker != null) {
mVelocityTracker.recycle();
null;
}
}
private void setScrollingCacheEnabled(boolean
if
mScrollingCacheEnabled = enabled;
if
final int
for (int i = 0; i < size; ++i) {
final
if
child.setDrawingCacheEnabled(enabled);
}
}
}
}
}
/**
* Tests scrollability within child views of v given a delta of dx.
*
* @param v View to test for horizontal scrollability
* @param checkV Whether the view v passed should itself be checked for scrollability (true),
* or just its children (false).
* @param dx Delta scrolled in pixels
* @param x X coordinate of the active touch point
* @param y Y coordinate of the active touch point
* @return true if child views of v can be scrolled by delta of dx.
*/
protected boolean canScroll(View v, boolean checkV, int dx, int x, int
if (v instanceof
final
final int
final int
final int
// Count backwards - let topmost views consume scroll distance first.
for (int i = count - 1; i >= 0; i--) {
final
if
y + scrollY >= child.getTop() && y + scrollY < child.getBottom() &&
true, dx, x + scrollX - child.getLeft(),
y + scrollY - child.getTop())) {
return true;
}
}
}
return
}
@Override
public boolean
// Let the focused view and/or our descendants get the key first
return super.dispatchKeyEvent(event) || executeKeyEvent(event);
}
/**
* You can call this function yourself to have the scroll view perform
* scrolling from a key event, just as if the event had been dispatched to
* it by the view hierarchy.
*
* @param event The key event to execute.
* @return Return true if the event was handled, else false.
*/
public boolean
boolean handled = false;
if
switch
case
handled = arrowScroll(FOCUS_LEFT);
break;
case
handled = arrowScroll(FOCUS_RIGHT);
break;
case
if (Build.VERSION.SDK_INT >= 11) {
// The focus finder had a bug handling FOCUS_FORWARD and FOCUS_BACKWARD
// before Android 3.0. Ignore the tab key on those devices.
if
handled = arrowScroll(FOCUS_FORWARD);
else if
handled = arrowScroll(FOCUS_BACKWARD);
}
}
break;
}
}
return
}
public boolean arrowScroll(int
View currentFocused = findFocus();
if (currentFocused == this) currentFocused = null;
boolean handled = false;
this, currentFocused,
direction);
if (nextFocused != null
if
handled = nextFocused.requestFocus();
else if
// If there is nothing to the right, or this is causing us to
// jump to the left, then what we really want to do is page right.
if (currentFocused != null
handled = pageRight();
else
handled = nextFocused.requestFocus();
}
}
else if
// Trying to move left and nothing there; try to page.
handled = pageLeft();
else if
// Trying to move right and nothing there; try to page.
handled = pageRight();
}
if
playSoundEffect(SoundEffectConstants.getContantForFocusDirection(direction));
}
return
}
boolean
if (mCurItem > 0) {
1, true);
return true;
}
return false;
}
boolean
if (mCurItem < 1) {
1, true);
return true;
}
return false;
}
public void
mTransformer = t;
}
}