Android侧滑效果简单实现代码

先看看效果：

首先，导入包：compile files('libs/nineoldandroids-2.4.0.jar')

r然后在main中创建一个widget包。
c创建ViewDragHelper类

public class ViewDragHelper {
private static final String TAG = "ViewDragHelper";
public static final int INVALID_POINTER = -1
public static final int STATE_IDLE = 0;
public static final int STATE_DRAGGING = 1;
public static final int STATE_SETTLING = 2;
public static final int EDGE_LEFT = 1 << 0;
public static final int EDGE_RIGHT = 1 << 1
public static final int EDGE_TOP = 1 << 2;
public static final int EDGE_BOTTOM = 1 << 3
public static final int EDGE_ALL = EDGE_LEFT | EDGE_TOP | EDGE_RIGHT | EDGE_BOTTOM;
public static final int DIRECTION_HORIZONTAL = 1 << 0;
public static final int DIRECTION_VERTICAL = 1 << 1;
public static final int DIRECTION_ALL = DIRECTION_HORIZONTAL | DIRECTION_VERTICAL;
private static final int EDGE_SIZE = 20; // dp
private static final int BASE_SETTLE_DURATION = 256; // ms
private static final int MAX_SETTLE_DURATION = 600; // ms
// Current drag state; idle, dragging or settling
private int mDragState;

// Distance to travel before a drag may begin
private int mTouchSlop;

// Last known position/pointer tracking
private int mActivePointerId = INVALID_POINTER;
private float[] mInitialMotionX;
private float[] mInitialMotionY;
private float[] mLastMotionX;
private float[] mLastMotionY;
private int[] mInitialEdgesTouched;
private int[] mEdgeDragsInProgress;
private int[] mEdgeDragsLocked;
private int mPointersDown;

private VelocityTracker mVelocityTracker;
private final float mMaxVelocity;
private float mMinVelocity;

private final int mEdgeSize;
private int mTrackingEdges;

private final ScrollerCompat mScroller;

private final Callback mCallback;

private View mCapturedView;
private boolean mReleaseInProgress;

private final ViewGroup mParentView;

private static final Interpolator sInterpolator = new Interpolator() {
 public float getInterpolation(float t) {
  t -= 1.0f;
  return t * t * t * t * t + 1.0f;
 }
};

private final Runnable mSetIdleRunnable = new Runnable() {
 public void run() {
  setDragState(STATE_IDLE);
 }
};

private ViewDragHelper(Context context, ViewGroup forParent, Callback cb) {
 if (forParent == null) {
  throw new IllegalArgumentException("Parent view may not be null");
 }
 if (cb == null) {
  throw new IllegalArgumentException("Callback may not be null");
 }

mParentView = forParent;
 mCallback = cb;

final ViewConfiguration vc = ViewConfiguration.get(context);
 final float density = context.getResources().getDisplayMetrics().density;
 mEdgeSize = (int) (EDGE_SIZE * density + 0.5f);

mTouchSlop = vc.getScaledTouchSlop();
 mMaxVelocity = vc.getScaledMaximumFlingVelocity();
 mMinVelocity = vc.getScaledMinimumFlingVelocity();
 mScroller = ScrollerCompat.create(context, sInterpolator);
}

public static abstract class Callback {

public void onViewDragStateChanged(int state) {}

public void onViewPositionChanged(View changedView, int left, int top, int dx, int dy) {}

public void onViewCaptured(View capturedChild, int activePointerId) {}

public void onViewReleased(View releasedChild, float xvel, float yvel) {}

public void onEdgeTouched(int edgeFlags, int pointerId) {}

public boolean onEdgeLock(int edgeFlags) {
  return false;
 }

public void onEdgeDragStarted(int edgeFlags, int pointerId) {}

public int getOrderedChildIndex(int index) {
  return index;
 }

public int getViewHorizontalDragRange(View child) {
  return 0;
 }

public int getViewVerticalDragRange(View child) {
  return 0;
 }

public abstract boolean tryCaptureView(View child, int pointerId);

public int clampViewPositionHorizontal(View child, int left, int dx) {
  return 0;
 }

public int clampViewPositionVertical(View child, int top, int dy) {
  return 0;
 }
}

public static ViewDragHelper create(ViewGroup forParent, Callback cb) {
 return new ViewDragHelper(forParent.getContext(), forParent, cb);
}

public static ViewDragHelper create(ViewGroup forParent, float sensitivity, Callback cb) {
 final ViewDragHelper helper = create(forParent, cb);
 helper.mTouchSlop = (int) (helper.mTouchSlop * (1 / sensitivity));
 return helper;
}

public void setMinVelocity(float minVel) {
 mMinVelocity = minVel;
}

public float getMinVelocity() {
 return mMinVelocity;
}

public int getViewDragState() {
 return mDragState;
}

public void setEdgeTrackingEnabled(int edgeFlags) {
 mTrackingEdges = edgeFlags;
}

public int getEdgeSize() {
 return mEdgeSize;
}

public void captureChildView(View childView, int activePointerId) {
 if (childView.getParent() != mParentView) {
  throw new IllegalArgumentException("captureChildView: parameter must be a descendant " +
    "of the ViewDragHelper's tracked parent view (" + mParentView + ")");
 }

mCapturedView = childView;
 mActivePointerId = activePointerId;
 mCallback.onViewCaptured(childView, activePointerId);
 setDragState(STATE_DRAGGING);
}

public View getCapturedView() {
 return mCapturedView;
}

public int getActivePointerId() {
 return mActivePointerId;
}

public int getTouchSlop() {
 return mTouchSlop;
}

public void cancel() {
 mActivePointerId = INVALID_POINTER;
 clearMotionHistory();

if (mVelocityTracker != null) {
  mVelocityTracker.recycle();
  mVelocityTracker = null;
 }
}

public void abort() {
 cancel();
 if (mDragState == STATE_SETTLING) {
  final int oldX = mScroller.getCurrX();
  final int oldY = mScroller.getCurrY();
  mScroller.abortAnimation();
  final int newX = mScroller.getCurrX();
  final int newY = mScroller.getCurrY();
  mCallback.onViewPositionChanged(mCapturedView, newX, newY, newX - oldX, newY - oldY);
 }
 setDragState(STATE_IDLE);
}

public boolean smoothSlideViewTo(View child, int finalLeft, int finalTop) {
 mCapturedView = child;
 mActivePointerId = INVALID_POINTER;

boolean continueSliding = forceSettleCapturedViewAt(finalLeft, finalTop, 0, 0);
 if (!continueSliding && mDragState == STATE_IDLE && mCapturedView != null) {
  // If we're in an IDLE state to begin with and aren't moving anywhere, we
  // end up having a non-null capturedView with an IDLE dragState
  mCapturedView = null;
 }

return continueSliding;
}

public boolean settleCapturedViewAt(int finalLeft, int finalTop) {
 if (!mReleaseInProgress) {
  throw new IllegalStateException("Cannot settleCapturedViewAt outside of a call to " +
    "Callback#onViewReleased");
 }

return forceSettleCapturedViewAt(finalLeft, finalTop,
   (int) VelocityTrackerCompat.getXVelocity(mVelocityTracker, mActivePointerId),
   (int) VelocityTrackerCompat.getYVelocity(mVelocityTracker, mActivePointerId));
}

private boolean forceSettleCapturedViewAt(int finalLeft, int finalTop, int xvel, int yvel) {
 final int startLeft = mCapturedView.getLeft();
 final int startTop = mCapturedView.getTop();
 final int dx = finalLeft - startLeft;
 final int dy = finalTop - startTop;

if (dx == 0 && dy == 0) {
  // Nothing to do. Send callbacks, be done.
  mScroller.abortAnimation();
  setDragState(STATE_IDLE);
  return false;
 }

final int duration = computeSettleDuration(mCapturedView, dx, dy, xvel, yvel);
 mScroller.startScroll(startLeft, startTop, dx, dy, duration);

setDragState(STATE_SETTLING);
 return true;
}

private int computeSettleDuration(View child, int dx, int dy, int xvel, int yvel) {
 xvel = clampMag(xvel, (int) mMinVelocity, (int) mMaxVelocity);
 yvel = clampMag(yvel, (int) mMinVelocity, (int) mMaxVelocity);
 final int absDx = Math.abs(dx);
 final int absDy = Math.abs(dy);
 final int absXVel = Math.abs(xvel);
 final int absYVel = Math.abs(yvel);
 final int addedVel = absXVel + absYVel;
 final int addedDistance = absDx + absDy;

final float xweight = xvel != 0 ? (float) absXVel / addedVel :
   (float) absDx / addedDistance;
 final float yweight = yvel != 0 ? (float) absYVel / addedVel :
   (float) absDy / addedDistance;

int xduration = computeAxisDuration(dx, xvel, mCallback.getViewHorizontalDragRange(child));
 int yduration = computeAxisDuration(dy, yvel, mCallback.getViewVerticalDragRange(child));

return (int) (xduration * xweight + yduration * yweight);
}

private int computeAxisDuration(int delta, int velocity, int motionRange) {
 if (delta == 0) {
  return 0;
 }

final int width = mParentView.getWidth();
 final int halfWidth = width / 2;
 final float distanceRatio = Math.min(1f, (float) Math.abs(delta) / width);
 final float distance = halfWidth + halfWidth *
   distanceInfluenceForSnapDuration(distanceRatio);

int duration;
 velocity = Math.abs(velocity);
 if (velocity > 0) {
  duration = 4 * Math.round(1000 * Math.abs(distance / velocity));
 } else {
  final float range = (float) Math.abs(delta) / motionRange;
  duration = (int) ((range + 1) * BASE_SETTLE_DURATION);
 }
 return Math.min(duration, MAX_SETTLE_DURATION);
}

private static int clampMag(int value, int absMin, int absMax) {
 final int absValue = Math.abs(value);
 if (absValue < absMin) return 0;
 if (absValue > absMax) return value > 0 ? absMax : -absMax;
 return value;
}

private static float clampMag(float value, float absMin, float absMax) {
 final float absValue = Math.abs(value);
 if (absValue < absMin) return 0;
 if (absValue > absMax) return value > 0 ? absMax : -absMax;
 return value;
}

private static float distanceInfluenceForSnapDuration(float f) {
 f -= 0.5f; // center the values about 0.
 f *= 0.3f * Math.PI / 2.0f;
 return (float) Math.sin(f);
}

public void flingCapturedView(int minLeft, int minTop, int maxLeft, int maxTop) {
 if (!mReleaseInProgress) {
  throw new IllegalStateException("Cannot flingCapturedView outside of a call to " +
    "Callback#onViewReleased");
 }

mScroller.fling(mCapturedView.getLeft(), mCapturedView.getTop(),
   (int) VelocityTrackerCompat.getXVelocity(mVelocityTracker, mActivePointerId),
   (int) VelocityTrackerCompat.getYVelocity(mVelocityTracker, mActivePointerId),
   minLeft, maxLeft, minTop, maxTop);

setDragState(STATE_SETTLING);
}

public boolean continueSettling(boolean deferCallbacks) {
 if (mDragState == STATE_SETTLING) {
  boolean keepGoing = mScroller.computeScrollOffset();
  final int x = mScroller.getCurrX();
  final int y = mScroller.getCurrY();
  final int dx = x - mCapturedView.getLeft();
  final int dy = y - mCapturedView.getTop();

if (dx != 0) {
   mCapturedView.offsetLeftAndRight(dx);
  }
  if (dy != 0) {
   mCapturedView.offsetTopAndBottom(dy);
  }

if (dx != 0 || dy != 0) {
   mCallback.onViewPositionChanged(mCapturedView, x, y, dx, dy);
  }

if (keepGoing && x == mScroller.getFinalX() && y == mScroller.getFinalY()) {
   // Close enough. The interpolator/scroller might think we're still moving
   // but the user sure doesn't.
   mScroller.abortAnimation();
   keepGoing = false;
  }

if (!keepGoing) {
   if (deferCallbacks) {
    mParentView.post(mSetIdleRunnable);
   } else {
    setDragState(STATE_IDLE);
   }
  }
 }

return mDragState == STATE_SETTLING;
}

private void dispatchViewReleased(float xvel, float yvel) {
 mReleaseInProgress = true;
 mCallback.onViewReleased(mCapturedView, xvel, yvel);
 mReleaseInProgress = false;

if (mDragState == STATE_DRAGGING) {
  // onViewReleased didn't call a method that would have changed this. Go idle.
  setDragState(STATE_IDLE);
 }
}

private void clearMotionHistory() {
 if (mInitialMotionX == null) {
  return;
 }
 Arrays.fill(mInitialMotionX, 0);
 Arrays.fill(mInitialMotionY, 0);
 Arrays.fill(mLastMotionX, 0);
 Arrays.fill(mLastMotionY, 0);
 Arrays.fill(mInitialEdgesTouched, 0);
 Arrays.fill(mEdgeDragsInProgress, 0);
 Arrays.fill(mEdgeDragsLocked, 0);
 mPointersDown = 0;
}

private void clearMotionHistory(int pointerId) {
 if (mInitialMotionX == null) {
  return;
 }
 mInitialMotionX[pointerId] = 0;
 mInitialMotionY[pointerId] = 0;
 mLastMotionX[pointerId] = 0;
 mLastMotionY[pointerId] = 0;
 mInitialEdgesTouched[pointerId] = 0;
 mEdgeDragsInProgress[pointerId] = 0;
 mEdgeDragsLocked[pointerId] = 0;
 mPointersDown &= ~(1 << pointerId);
}

private void ensureMotionHistorySizeForId(int pointerId) {
 if (mInitialMotionX == null || mInitialMotionX.length <= pointerId) {
  float[] imx = new float[pointerId + 1];
  float[] imy = new float[pointerId + 1];
  float[] lmx = new float[pointerId + 1];
  float[] lmy = new float[pointerId + 1];
  int[] iit = new int[pointerId + 1];
  int[] edip = new int[pointerId + 1];
  int[] edl = new int[pointerId + 1];

if (mInitialMotionX != null) {
   System.arraycopy(mInitialMotionX, 0, imx, 0, mInitialMotionX.length);
   System.arraycopy(mInitialMotionY, 0, imy, 0, mInitialMotionY.length);
   System.arraycopy(mLastMotionX, 0, lmx, 0, mLastMotionX.length);
   System.arraycopy(mLastMotionY, 0, lmy, 0, mLastMotionY.length);
   System.arraycopy(mInitialEdgesTouched, 0, iit, 0, mInitialEdgesTouched.length);
   System.arraycopy(mEdgeDragsInProgress, 0, edip, 0, mEdgeDragsInProgress.length);
   System.arraycopy(mEdgeDragsLocked, 0, edl, 0, mEdgeDragsLocked.length);
  }

mInitialMotionX = imx;
  mInitialMotionY = imy;
  mLastMotionX = lmx;
  mLastMotionY = lmy;
  mInitialEdgesTouched = iit;
  mEdgeDragsInProgress = edip;
  mEdgeDragsLocked = edl;
 }
}

private void saveInitialMotion(float x, float y, int pointerId) {
 ensureMotionHistorySizeForId(pointerId);
 mInitialMotionX[pointerId] = mLastMotionX[pointerId] = x;
 mInitialMotionY[pointerId] = mLastMotionY[pointerId] = y;
 mInitialEdgesTouched[pointerId] = getEdgesTouched((int) x, (int) y);
 mPointersDown |= 1 << pointerId;
}

private void saveLastMotion(MotionEvent ev) {
 final int pointerCount = MotionEventCompat.getPointerCount(ev);
 for (int i = 0; i < pointerCount; i++) {
  final int pointerId = MotionEventCompat.getPointerId(ev, i);
  final float x = MotionEventCompat.getX(ev, i);
  final float y = MotionEventCompat.getY(ev, i);
  mLastMotionX[pointerId] = x;
  mLastMotionY[pointerId] = y;
 }
}

public boolean isPointerDown(int pointerId) {
 return (mPointersDown & 1 << pointerId) != 0;
}

void setDragState(int state) {
 mParentView.removeCallbacks(mSetIdleRunnable);
 if (mDragState != state) {
  mDragState = state;
  mCallback.onViewDragStateChanged(state);
  if (mDragState == STATE_IDLE) {
   mCapturedView = null;
  }
 }
}

boolean tryCaptureViewForDrag(View toCapture, int pointerId) {
 if (toCapture == mCapturedView && mActivePointerId == pointerId) {
  // Already done!
  return true;
 }
 if (toCapture != null && mCallback.tryCaptureView(toCapture, pointerId)) {
  mActivePointerId = pointerId;
  captureChildView(toCapture, pointerId);
  return true;
 }
 return false;
}

protected boolean canScroll(View v, boolean checkV, int dx, int dy, int x, int y) {
 if (v instanceof ViewGroup) {
  final ViewGroup group = (ViewGroup) v;
  final int scrollX = v.getScrollX();
  final int scrollY = v.getScrollY();
  final int count = group.getChildCount();
  // Count backwards - let topmost views consume scroll distance first.
  for (int i = count - 1; i >= 0; i--) {
   // TODO: Add versioned support here for transformed views.
   // This will not work for transformed views in Honeycomb+
   final View child = group.getChildAt(i);
   if (x + scrollX >= child.getLeft() && x + scrollX < child.getRight() &&
     y + scrollY >= child.getTop() && y + scrollY < child.getBottom() &&
     canScroll(child, true, dx, dy, x + scrollX - child.getLeft(),
       y + scrollY - child.getTop())) {
    return true;
   }
  }
 }

return checkV && (ViewCompat.canScrollHorizontally(v, -dx) ||
   ViewCompat.canScrollVertically(v, -dy));
}

public boolean shouldInterceptTouchEvent(MotionEvent ev) {
 final int action = MotionEventCompat.getActionMasked(ev);
 final int actionIndex = MotionEventCompat.getActionIndex(ev);

if (action == MotionEvent.ACTION_DOWN) {
  // Reset things for a new event stream, just in case we didn't get
  // the whole previous stream.
  cancel();
 }

if (mVelocityTracker == null) {
  mVelocityTracker = VelocityTracker.obtain();
 }
 mVelocityTracker.addMovement(ev);

switch (action) {
  case MotionEvent.ACTION_DOWN: {
   final float x = ev.getX();
   final float y = ev.getY();
   final int pointerId = MotionEventCompat.getPointerId(ev, 0);
   saveInitialMotion(x, y, pointerId);

final View toCapture = findTopChildUnder((int) x, (int) y);

// Catch a settling view if possible.
   if (toCapture == mCapturedView && mDragState == STATE_SETTLING) {
    tryCaptureViewForDrag(toCapture, pointerId);
   }

final int edgesTouched = mInitialEdgesTouched[pointerId];
   if ((edgesTouched & mTrackingEdges) != 0) {
    mCallback.onEdgeTouched(edgesTouched & mTrackingEdges, pointerId);
   }
   break;
  }

case MotionEventCompat.ACTION_POINTER_DOWN: {
   final int pointerId = MotionEventCompat.getPointerId(ev, actionIndex);
   final float x = MotionEventCompat.getX(ev, actionIndex);
   final float y = MotionEventCompat.getY(ev, actionIndex);

saveInitialMotion(x, y, pointerId);

// A ViewDragHelper can only manipulate one view at a time.
   if (mDragState == STATE_IDLE) {
    final int edgesTouched = mInitialEdgesTouched[pointerId];
    if ((edgesTouched & mTrackingEdges) != 0) {
     mCallback.onEdgeTouched(edgesTouched & mTrackingEdges, pointerId);
    }
   } else if (mDragState == STATE_SETTLING) {
    // Catch a settling view if possible.
    final View toCapture = findTopChildUnder((int) x, (int) y);
    if (toCapture == mCapturedView) {
     tryCaptureViewForDrag(toCapture, pointerId);
    }
   }
   break;
  }

case MotionEvent.ACTION_MOVE: {
   if (mInitialMotionX == null || mInitialMotionY == null) break;

// First to cross a touch slop over a draggable view wins. Also report edge drags.
   final int pointerCount = MotionEventCompat.getPointerCount(ev);
   for (int i = 0; i < pointerCount; i++) {
    final int pointerId = MotionEventCompat.getPointerId(ev, i);
    final float x = MotionEventCompat.getX(ev, i);
    final float y = MotionEventCompat.getY(ev, i);
    final float dx = x - mInitialMotionX[pointerId];
    final float dy = y - mInitialMotionY[pointerId];

final View toCapture = findTopChildUnder((int) x, (int) y);
    final boolean pastSlop = toCapture != null && checkTouchSlop(toCapture, dx, dy);
    if (pastSlop) {
     // check the callback's
     // getView[Horizontal|Vertical]DragRange methods to know
     // if you can move at all along an axis, then see if it
     // would clamp to the same value. If you can't move at
     // all in every dimension with a nonzero range, bail.
     final int oldLeft = toCapture.getLeft();
     final int targetLeft = oldLeft + (int) dx;
     final int newLeft = mCallback.clampViewPositionHorizontal(toCapture,
       targetLeft, (int) dx);
     final int oldTop = toCapture.getTop();
     final int targetTop = oldTop + (int) dy;
     final int newTop = mCallback.clampViewPositionVertical(toCapture, targetTop,
       (int) dy);
     final int horizontalDragRange = mCallback.getViewHorizontalDragRange(
       toCapture);
     final int verticalDragRange = mCallback.getViewVerticalDragRange(toCapture);
     if ((horizontalDragRange == 0 || horizontalDragRange > 0
       && newLeft == oldLeft) && (verticalDragRange == 0
       || verticalDragRange > 0 && newTop == oldTop)) {
      break;
     }
    }
    reportNewEdgeDrags(dx, dy, pointerId);
    if (mDragState == STATE_DRAGGING) {
     // Callback might have started an edge drag
     break;
    }

if (pastSlop && tryCaptureViewForDrag(toCapture, pointerId)) {
     break;
    }
   }
   saveLastMotion(ev);
   break;
  }

case MotionEventCompat.ACTION_POINTER_UP: {
   final int pointerId = MotionEventCompat.getPointerId(ev, actionIndex);
   clearMotionHistory(pointerId);
   break;
  }

case MotionEvent.ACTION_UP:
  case MotionEvent.ACTION_CANCEL: {
   cancel();
   break;
  }
  default:
   break;
 }

return mDragState == STATE_DRAGGING;
}

public void processTouchEvent(MotionEvent ev) {
 final int action = MotionEventCompat.getActionMasked(ev);
 final int actionIndex = MotionEventCompat.getActionIndex(ev);

if (action == MotionEvent.ACTION_DOWN) {
  // Reset things for a new event stream, just in case we didn't get
  // the whole previous stream.
  cancel();
 }

if (mVelocityTracker == null) {
  mVelocityTracker = VelocityTracker.obtain();
 }
 mVelocityTracker.addMovement(ev);

switch (action) {
  case MotionEvent.ACTION_DOWN: {
   final float x = ev.getX();
   final float y = ev.getY();
   final int pointerId = MotionEventCompat.getPointerId(ev, 0);
   final View toCapture = findTopChildUnder((int) x, (int) y);

saveInitialMotion(x, y, pointerId);

// Since the parent is already directly processing this touch event,
   // there is no reason to delay for a slop before dragging.
   // Start immediately if possible.
   tryCaptureViewForDrag(toCapture, pointerId);

final int edgesTouched = mInitialEdgesTouched[pointerId];
   if ((edgesTouched & mTrackingEdges) != 0) {
    mCallback.onEdgeTouched(edgesTouched & mTrackingEdges, pointerId);
   }
   break;
  }

case MotionEventCompat.ACTION_POINTER_DOWN: {
   final int pointerId = MotionEventCompat.getPointerId(ev, actionIndex);
   final float x = MotionEventCompat.getX(ev, actionIndex);
   final float y = MotionEventCompat.getY(ev, actionIndex);

saveInitialMotion(x, y, pointerId);

// A ViewDragHelper can only manipulate one view at a time.
   if (mDragState == STATE_IDLE) {
    // If we're idle we can do anything! Treat it like a normal down event.

final View toCapture = findTopChildUnder((int) x, (int) y);
    tryCaptureViewForDrag(toCapture, pointerId);

final int edgesTouched = mInitialEdgesTouched[pointerId];
    if ((edgesTouched & mTrackingEdges) != 0) {
     mCallback.onEdgeTouched(edgesTouched & mTrackingEdges, pointerId);
    }
   } else if (isCapturedViewUnder((int) x, (int) y)) {
    // We're still tracking a captured view. If the same view is under this
    // point, we'll swap to controlling it with this pointer instead.
    // (This will still work if we're "catching" a settling view.)

tryCaptureViewForDrag(mCapturedView, pointerId);
   }
   break;
  }

case MotionEvent.ACTION_MOVE: {
   if (mDragState == STATE_DRAGGING) {
    final int index = MotionEventCompat.findPointerIndex(ev, mActivePointerId);
    final float x = MotionEventCompat.getX(ev, index);
    final float y = MotionEventCompat.getY(ev, index);
    final int idx = (int) (x - mLastMotionX[mActivePointerId]);
    final int idy = (int) (y - mLastMotionY[mActivePointerId]);

dragTo(mCapturedView.getLeft() + idx, mCapturedView.getTop() + idy, idx, idy);

saveLastMotion(ev);
   } else {
    // Check to see if any pointer is now over a draggable view.
    final int pointerCount = MotionEventCompat.getPointerCount(ev);
    for (int i = 0; i < pointerCount; i++) {
     final int pointerId = MotionEventCompat.getPointerId(ev, i);
     final float x = MotionEventCompat.getX(ev, i);
     final float y = MotionEventCompat.getY(ev, i);
     final float dx = x - mInitialMotionX[pointerId];
     final float dy = y - mInitialMotionY[pointerId];

reportNewEdgeDrags(dx, dy, pointerId);
     if (mDragState == STATE_DRAGGING) {
      // Callback might have started an edge drag.
      break;
     }

final View toCapture = findTopChildUnder((int) x, (int) y);
     if (checkTouchSlop(toCapture, dx, dy) &&
       tryCaptureViewForDrag(toCapture, pointerId)) {
      break;
     }
    }
    saveLastMotion(ev);
   }
   break;
  }

case MotionEventCompat.ACTION_POINTER_UP: {
   final int pointerId = MotionEventCompat.getPointerId(ev, actionIndex);
   if (mDragState == STATE_DRAGGING && pointerId == mActivePointerId) {
    // Try to find another pointer that's still holding on to the captured view.
    int newActivePointer = INVALID_POINTER;
    final int pointerCount = MotionEventCompat.getPointerCount(ev);
    for (int i = 0; i < pointerCount; i++) {
     final int id = MotionEventCompat.getPointerId(ev, i);
     if (id == mActivePointerId) {
      // This one's going away, skip.
      continue;
     }

final float x = MotionEventCompat.getX(ev, i);
     final float y = MotionEventCompat.getY(ev, i);
     if (findTopChildUnder((int) x, (int) y) == mCapturedView &&
       tryCaptureViewForDrag(mCapturedView, id)) {
      newActivePointer = mActivePointerId;
      break;
     }
    }

if (newActivePointer == INVALID_POINTER) {
     // We didn't find another pointer still touching the view, release it.
     releaseViewForPointerUp();
    }
   }
   clearMotionHistory(pointerId);
   break;
  }

case MotionEvent.ACTION_UP: {
   if (mDragState == STATE_DRAGGING) {
    releaseViewForPointerUp();
   }
   cancel();
   break;
  }

case MotionEvent.ACTION_CANCEL: {
   if (mDragState == STATE_DRAGGING) {
    dispatchViewReleased(0, 0);
   }
   cancel();
   break;
  }
  default:
   break;

}
}

private void reportNewEdgeDrags(float dx, float dy, int pointerId) {
 int dragsStarted = 0;
 if (checkNewEdgeDrag(dx, dy, pointerId, EDGE_LEFT)) {
  dragsStarted |= EDGE_LEFT;
 }
 if (checkNewEdgeDrag(dy, dx, pointerId, EDGE_TOP)) {
  dragsStarted |= EDGE_TOP;
 }
 if (checkNewEdgeDrag(dx, dy, pointerId, EDGE_RIGHT)) {
  dragsStarted |= EDGE_RIGHT;
 }
 if (checkNewEdgeDrag(dy, dx, pointerId, EDGE_BOTTOM)) {
  dragsStarted |= EDGE_BOTTOM;
 }

if (dragsStarted != 0) {
  mEdgeDragsInProgress[pointerId] |= dragsStarted;
  mCallback.onEdgeDragStarted(dragsStarted, pointerId);
 }
}

private boolean checkNewEdgeDrag(float delta, float odelta, int pointerId, int edge) {
 final float absDelta = Math.abs(delta);
 final float absODelta = Math.abs(odelta);

if ((mInitialEdgesTouched[pointerId] & edge) != edge || (mTrackingEdges & edge) == 0 ||
   (mEdgeDragsLocked[pointerId] & edge) == edge ||
   (mEdgeDragsInProgress[pointerId] & edge) == edge ||
   (absDelta <= mTouchSlop && absODelta <= mTouchSlop)) {
  return false;
 }
 if (absDelta < absODelta * 0.5f && mCallback.onEdgeLock(edge)) {
  mEdgeDragsLocked[pointerId] |= edge;
  return false;
 }
 return (mEdgeDragsInProgress[pointerId] & edge) == 0 && absDelta > mTouchSlop;
}

private boolean checkTouchSlop(View child, float dx, float dy) {
 if (child == null) {
  return false;
 }
 final boolean checkHorizontal = mCallback.getViewHorizontalDragRange(child) > 0;
 final boolean checkVertical = mCallback.getViewVerticalDragRange(child) > 0;

if (checkHorizontal && checkVertical) {
  return dx * dx + dy * dy > mTouchSlop * mTouchSlop;
 } else if (checkHorizontal) {
  return Math.abs(dx) > mTouchSlop;
 } else if (checkVertical) {
  return Math.abs(dy) > mTouchSlop;
 }
 return false;
}

public boolean checkTouchSlop(int directions) {
 final int count = mInitialMotionX.length;
 for (int i = 0; i < count; i++) {
  if (checkTouchSlop(directions, i)) {
   return true;
  }
 }
 return false;
}

public boolean checkTouchSlop(int directions, int pointerId) {
 if (!isPointerDown(pointerId)) {
  return false;
 }

final boolean checkHorizontal = (directions & DIRECTION_HORIZONTAL) == DIRECTION_HORIZONTAL;
 final boolean checkVertical = (directions & DIRECTION_VERTICAL) == DIRECTION_VERTICAL;

final float dx = mLastMotionX[pointerId] - mInitialMotionX[pointerId];
 final float dy = mLastMotionY[pointerId] - mInitialMotionY[pointerId];

if (checkHorizontal && checkVertical) {
  return dx * dx + dy * dy > mTouchSlop * mTouchSlop;
 } else if (checkHorizontal) {
  return Math.abs(dx) > mTouchSlop;
 } else if (checkVertical) {
  return Math.abs(dy) > mTouchSlop;
 }
 return false;
}

public boolean isEdgeTouched(int edges) {
 final int count = mInitialEdgesTouched.length;
 for (int i = 0; i < count; i++) {
  if (isEdgeTouched(edges, i)) {
   return true;
  }
 }
 return false;
}

public boolean isEdgeTouched(int edges, int pointerId) {
 return isPointerDown(pointerId) && (mInitialEdgesTouched[pointerId] & edges) != 0;
}

private void releaseViewForPointerUp() {
 mVelocityTracker.computeCurrentVelocity(1000, mMaxVelocity);
 final float xvel = clampMag(
   VelocityTrackerCompat.getXVelocity(mVelocityTracker, mActivePointerId),
   mMinVelocity, mMaxVelocity);
 final float yvel = clampMag(
   VelocityTrackerCompat.getYVelocity(mVelocityTracker, mActivePointerId),
   mMinVelocity, mMaxVelocity);
 dispatchViewReleased(xvel, yvel);
}

private void dragTo(int left, int top, int dx, int dy) {
 int clampedX = left;
 int clampedY = top;
 final int oldLeft = mCapturedView.getLeft();
 final int oldTop = mCapturedView.getTop();
 if (dx != 0) {
  clampedX = mCallback.clampViewPositionHorizontal(mCapturedView, left, dx);
  mCapturedView.offsetLeftAndRight(clampedX - oldLeft);
 }
 if (dy != 0) {
  clampedY = mCallback.clampViewPositionVertical(mCapturedView, top, dy);
  mCapturedView.offsetTopAndBottom(clampedY - oldTop);
 }

if (dx != 0 || dy != 0) {
  final int clampedDx = clampedX - oldLeft;
  final int clampedDy = clampedY - oldTop;
  mCallback.onViewPositionChanged(mCapturedView, clampedX, clampedY,
    clampedDx, clampedDy);
 }
}

public boolean isCapturedViewUnder(int x, int y) {
 return isViewUnder(mCapturedView, x, y);
}

public boolean isViewUnder(View view, int x, int y) {
 if (view == null) {
  return false;
 }
 return x >= view.getLeft() &&
   x < view.getRight() &&
   y >= view.getTop() &&
   y < view.getBottom();
}

public View findTopChildUnder(int x, int y) {
 final int childCount = mParentView.getChildCount();
 for (int i = childCount - 1; i >= 0; i--) {
  final View child = mParentView.getChildAt(mCallback.getOrderedChildIndex(i));
  if (x >= child.getLeft() && x < child.getRight() &&
    y >= child.getTop() && y < child.getBottom()) {
   return child;
  }
 }
 return null;
}

private int getEdgesTouched(int x, int y) {
 int result = 0;

if (x < mParentView.getLeft() + mEdgeSize) result |= EDGE_LEFT;
 if (y < mParentView.getTop() + mEdgeSize) result |= EDGE_TOP;
 if (x > mParentView.getRight() - mEdgeSize) result |= EDGE_RIGHT;
 if (y > mParentView.getBottom() - mEdgeSize) result |= EDGE_BOTTOM;

return result;
}
}

DragLayout布局继承FrameLayout：

public class DragLayout extends FrameLayout {

private static final boolean IS_SHOW_SHADOW = true;
//手势处理类
private GestureDetectorCompat gestureDetector;
//视图拖拽移动帮助类
private ViewDragHelper dragHelper;
//滑动 *
private DragListener dragListener;
//水平拖拽的距离
private int range;
//宽度
private int width;
//高度
private int height;
//main视图距离在ViewGroup距离左边的距离
private int mainLeft;
private Context context;
private ImageView ivShadow;
//左侧布局
private RelativeLayout vgLeft;
//右侧(主界面布局)
private CustomRelativeLayout vgMain;
//页面状态 默认为关闭
private Status status = Status.CLOSE;

private final ViewDragHelper.Callback dragHelperCallback = new ViewDragHelper.Callback() {

@Override
 public int clampViewPositionHorizontal(View child, int left, int dx) {
  if (mainLeft + dx < 0) {
   return 0;
  } else if (mainLeft + dx > range) {
   return range;
  } else {
   return left;
  }
 }

@Override
 public boolean tryCaptureView(View child, int pointerId) {
  return true;
 }

@Override
 public int getViewHorizontalDragRange(View child) {
  return width;
 }

@Override
 public void onViewReleased(View releasedChild, float xvel, float yvel) {
  super.onViewReleased(releasedChild, xvel, yvel);
  if (xvel > 0) {
   open();
  } else if (xvel < 0) {
   close();
  } else if (releasedChild == vgMain && mainLeft > range * 0.3) {
   open();
  } else if (releasedChild == vgLeft && mainLeft > range * 0.7) {
   open();
  } else {
   close();
  }
 }

@Override
 public void onViewPositionChanged(View changedView, int left, int top,
          int dx, int dy) {
  if (changedView == vgMain) {
   mainLeft = left;
  } else {
   mainLeft = mainLeft + left;
  }
  if (mainLeft < 0) {
   mainLeft = 0;
  } else if (mainLeft > range) {
   mainLeft = range;
  }

if (IS_SHOW_SHADOW) {
   ivShadow.layout(mainLeft, 0, mainLeft + width, height);
  }
  if (changedView == vgLeft) {
   vgLeft.layout(0, 0, width, height);
   vgMain.layout(mainLeft, 0, mainLeft + width, height);
  }

dispatchDragEvent(mainLeft);
 }
};

public DragLayout(Context context) {
 this(context, null);
}

public DragLayout(Context context, AttributeSet attrs) {
 this(context, attrs, 0);
 this.context = context;
}

public DragLayout(Context context, AttributeSet attrs, int defStyle) {
 super(context, attrs, defStyle);
 gestureDetector = new GestureDetectorCompat(context, new YScrollDetector());
 dragHelper = ViewDragHelper.create(this, dragHelperCallback);
}

class YScrollDetector extends GestureDetector.SimpleOnGestureListener {
 @Override
 public boolean onScroll(MotionEvent e1, MotionEvent e2, float dx, float dy) {
  return Math.abs(dy) <= Math.abs(dx);
 }
}

/**
 * 滑动相关回调接口
 */
public interface DragListener {
 //界面打开
 public void onOpen();
 //界面关闭
 public void onClose();
 //界面滑动过程中
 public void onDrag(float percent);
}
public void setDragListener(DragListener dragListener) {
 this.dragListener = dragListener;
}

/**
 * 布局加载完成回调
 * 做一些初始化的操作
 */
@Override
protected void onFinishInflate() {
 super.onFinishInflate();
 if (IS_SHOW_SHADOW) {
  ivShadow = new ImageView(context);
  ivShadow.setImageResource(R.mipmap.shadow);
  LayoutParams lp = new LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT);
  addView(ivShadow, 1, lp);
 }
 //左侧界面
 vgLeft = (RelativeLayout) getChildAt(0);
 //右侧(主)界面
 vgMain = (CustomRelativeLayout) getChildAt(IS_SHOW_SHADOW ? 2 : 1);
 vgMain.setDragLayout(this);
 vgLeft.setClickable(true);
 vgMain.setClickable(true);
}

public ViewGroup getVgMain() {
 return vgMain;
}

public ViewGroup getVgLeft() {
 return vgLeft;
}

@Override
protected void onSizeChanged(int w, int h, int oldw, int oldh) {
 super.onSizeChanged(w, h, oldw, oldh);
 width = vgLeft.getMeasuredWidth();
 height = vgLeft.getMeasuredHeight();
 //可以水平拖拽滑动的距离 一共为屏幕宽度的80％
 range = (int) (width * 0.8f);
}

@Override
protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
 vgLeft.layout(0, 0, width, height);
 vgMain.layout(mainLeft, 0, mainLeft + width, height);
}

/**
 * 拦截触摸事件
 * @param ev
 * @return
 */
@Override
public boolean onInterceptTouchEvent(MotionEvent ev) {
 return dragHelper.shouldInterceptTouchEvent(ev) && gestureDetector.onTouchEvent(ev);
}

/**
 * 将拦截的到事件给ViewDragHelper进行处理
 * @param e
 * @return
 */
@Override
public boolean onTouchEvent(MotionEvent e) {
 try {
  dragHelper.processTouchEvent(e);
 } catch (Exception ex) {
  ex.printStackTrace();
 }
 return false;
}

/**
 * 进行处理拖拽事件
 * @param mainLeft
 */
private void dispatchDragEvent(int mainLeft) {
 if (dragListener == null) {
  return;
 }
 float percent = mainLeft / (float) range;
 //滑动动画效果
 animateView(percent);
 //进行回调滑动的百分比
 dragListener.onDrag(percent);
 Status lastStatus = status;
 if (lastStatus != getStatus() && status == Status.CLOSE) {
  dragListener.onClose();
 } else if (lastStatus != getStatus() && status == Status.OPEN) {
  dragListener.onOpen();
 }
}

/**
 * 根据滑动的距离的比例,进行平移动画
 * @param percent
 */
private void animateView(float percent) {
 float f1 = 1 - percent * 0.5f;

ViewHelper.setTranslationX(vgLeft, -vgLeft.getWidth() / 2.5f + vgLeft.getWidth() / 2.5f * percent);
 if (IS_SHOW_SHADOW) {
  //阴影效果视图大小进行缩放
  ViewHelper.setScaleX(ivShadow, f1 * 1.2f * (1 - percent * 0.10f));
  ViewHelper.setScaleY(ivShadow, f1 * 1.85f * (1 - percent * 0.10f));
 }
}
/**
 * 有加速度,当我们停止滑动的时候，该不会立即停止动画效果
 */
@Override
public void computeScroll() {
 if (dragHelper.continueSettling(true)) {
  ViewCompat.postInvalidateOnAnimation(this);
 }
}

/**
 * 页面状态(滑动,打开,关闭)
 */
public enum Status {
 DRAG, OPEN, CLOSE
}

/**
 * 页面状态设置
 * @return
 */
public Status getStatus() {
 if (mainLeft == 0) {
  status = Status.CLOSE;
 } else if (mainLeft == range) {
  status = Status.OPEN;
 } else {
  status = Status.DRAG;
 }
 return status;
}

public void open() {
 open(true);
}

public void open(boolean animate) {
 if (animate) {
  //继续滑动
  if (dragHelper.smoothSlideViewTo(vgMain, range, 0)) {
   ViewCompat.postInvalidateOnAnimation(this);
  }
 } else {
  vgMain.layout(range, 0, range * 2, height);
  dispatchDragEvent(range);
 }
}

public void close() {
 close(true);
}

public void close(boolean animate) {
 if (animate) {
  //继续滑动
  if (dragHelper.smoothSlideViewTo(vgMain, 0, 0)) {
   ViewCompat.postInvalidateOnAnimation(this);
  }
 } else {
  vgMain.layout(0, 0, width, height);
  dispatchDragEvent(0);
 }
}
}

CustomRelativeLayout：

public class CustomRelativeLayout extends RelativeLayout {
private DragLayout dl;
public CustomRelativeLayout(Context context) {
 super(context);
}

public CustomRelativeLayout(Context context, AttributeSet attrs) {
 super(context, attrs);
}

public CustomRelativeLayout(Context context, AttributeSet attrs, int defStyleAttr) {
 super(context, attrs, defStyleAttr);
}

public void setDragLayout(DragLayout dl) {
 this.dl = dl;
}

@Override
public boolean onInterceptTouchEvent(MotionEvent event) {
 if (dl.getStatus() != DragLayout.Status.CLOSE) {
  return true;
 }
 return super.onInterceptTouchEvent(event);
}

@Override
public boolean onTouchEvent(MotionEvent event) {
 if (dl.getStatus() != DragLayout.Status.CLOSE) {
  if (event.getAction() == MotionEvent.ACTION_UP) {
   dl.close();
  }
  return true;
 }
 return super.onTouchEvent(event);
}

}

c沉浸式状态栏：BaseActivity：

public class BaseActivity extends FragmentActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
 super.onCreate(savedInstanceState);
 this.requestWindowFeature(Window.FEATURE_NO_TITLE);
 if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
  //透明状态栏
  getWindow().addFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS);
  //透明导航栏
  getWindow().addFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_NAVIGATION);
 }
}
/**
 * 设置沉浸式状态栏
 */
protected void setStatusBar() {
 if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
  final ViewGroup linear_bar = (ViewGroup) findViewById(R.id.rl_title);
  final int statusHeight = getStatusBarHeight();
  linear_bar.post(new Runnable() {
   @Override
   public void run() {
    int titleHeight = linear_bar.getHeight();
    android.widget.LinearLayout.LayoutParams params = (android.widget.LinearLayout.LayoutParams) linear_bar.getLayoutParams();
    params.height = statusHeight + titleHeight;
    linear_bar.setLayoutParams(params);
   }
  });
 }
}
/**
 * 获取状态栏的高度
 * @return
 */
protected int getStatusBarHeight(){
 try
 {
  Class<?> c=Class.forName("com.android.internal.R$dimen");
  Object obj=c.newInstance();
  Field field=c.getField("status_bar_height");
  int x=Integer.parseInt(field.get(obj).toString());
  return getResources().getDimensionPixelSize(x);
 }catch(Exception e){
  e.printStackTrace();
 }
 return 0;
}

}

MainActivity：

public class MainActivity extends BaseActivity {
private DragLayout dl;
private LinearLayout linearLayout;
@Override
protected void onCreate(Bundle savedInstanceState) {
 super.onCreate(savedInstanceState);
 setContentView(R.layout.activity_main);
 initDragLayout();
}
private void initDragLayout() {
 dl = (DragLayout) findViewById(R.id.dl);
 linearLayout =(LinearLayout) findViewById(R.id.aaa);
 dl.setDragListener(new DragLayout.DragListener() {
  //界面打开的时候
  @Override
  public void onOpen() {
  }
  //界面关闭的时候
  @Override
  public void onClose() {
  }

//界面滑动的时候
  @Override
  public void onDrag(float percent) {
  }
 });
}
}

OneFragment：

public class OneFragment extends Fragment {
private View mView;
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
 if(mView==null){
  mView=inflater.inflate(R.layout.one_frag_layout,container,false);
 }
 return mView;
}
}

b布局文件：
one_frag_layout.xml
LinearLayout布局

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical" android:layout_width="match_parent"
android:layout_height="match_parent"
android:gravity="center"
android:id="@+id/aaa"

>

<TextView
 android:text="界面"
 android:layout_gravity="center"
 android:layout_width="wrap_content"
 android:layout_height="wrap_content" />
</LinearLayout>

one_frag_layout1.xml:
RelativeLayout布局

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical" android:layout_width="match_parent"
android:layout_height="match_parent"
android:gravity="center"
>

<TextView
 android:text="主界面"
 android:layout_gravity="center"
 android:layout_width="wrap_content"
 android:layout_height="wrap_content" />
</RelativeLayout>

activity.main.xml:

<com.包名.myapplication.widget.DragLayout
xmlns:android="http://schemas.android.com/apk/res/android"
android:id="@+id/dl"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:background="@android:color/transparent"
>
<!--下层 左边的布局 这个布局不能省去-->
<include layout="@layout/one_frag_layout1"/>
<!--上层 右边的主布局-->
<com.包名.myapplication.widget.CustomRelativeLayout
 android:layout_width="match_parent"
 android:layout_height="match_parent"
 android:background="#FFFFFF"
 >
 <LinearLayout
  android:layout_width="fill_parent"
  android:layout_height="fill_parent"
  android:orientation="vertical"
  >
 <RelativeLayout
  android:id="@+id/rl_title"
  android:layout_width="match_parent"
  android:layout_height="49dp"
  android:gravity="bottom"
  android:background="#2aaced"
   >
  <include layout="@layout/one_frag_layout"/>
 </RelativeLayout>
 <!--中间内容后面放入Fragment-->
 <FrameLayout
  android:layout_width="fill_parent"
  android:layout_height="fill_parent"
  >
  <fragment
   android:id="@+id/main_info_fragment"
   class="com.mieasy.myapplication.OneFragment"
   android:layout_width="fill_parent"
   android:layout_height="fill_parent"/>
 </FrameLayout>
 </LinearLayout>
</com.包名.myapplication.widget.CustomRelativeLayout>
</com.包名.myapplication.widget.DragLayout>