Java ViewHolder类代码示例

import org.telegram.messenger.support.widget.RecyclerView.ViewHolder; //导入依赖的package包/类
@Override
public boolean animateMove(final ViewHolder holder, int fromX, int fromY,
        int toX, int toY) {
    final View view = holder.itemView;
    fromX += ViewCompat.getTranslationX(holder.itemView);
    fromY += ViewCompat.getTranslationY(holder.itemView);
    resetAnimation(holder);
    int deltaX = toX - fromX;
    int deltaY = toY - fromY;
    if (deltaX == 0 && deltaY == 0) {
        dispatchMoveFinished(holder);
        return false;
    }
    if (deltaX != 0) {
        ViewCompat.setTranslationX(view, -deltaX);
    }
    if (deltaY != 0) {
        ViewCompat.setTranslationY(view, -deltaY);
    }
    mPendingMoves.add(new MoveInfo(holder, fromX, fromY, toX, toY));
    return true;
}
 

import org.telegram.messenger.support.widget.RecyclerView.ViewHolder; //导入依赖的package包/类
@Override
public void onChildViewDetachedFromWindow(View view) {
    removeChildDrawingOrderCallbackIfNecessary(view);
    final ViewHolder holder = mRecyclerView.getChildViewHolder(view);
    if (holder == null) {
        return;
    }
    if (mSelected != null && holder == mSelected) {
        select(null, ACTION_STATE_IDLE);
    } else {
        endRecoverAnimation(holder, false); // this may push it into pending cleanup list.
        if (mPendingCleanup.remove(holder.itemView)) {
            mCallback.clearView(mRecyclerView, holder);
        }
    }
}
 

import org.telegram.messenger.support.widget.RecyclerView.ViewHolder; //导入依赖的package包/类
/**
 * Returns the animation type or 0 if cannot be found.
 */
private int endRecoverAnimation(ViewHolder viewHolder, boolean override) {
    final int recoverAnimSize = mRecoverAnimations.size();
    for (int i = recoverAnimSize - 1; i >= 0; i--) {
        final RecoverAnimation anim = mRecoverAnimations.get(i);
        if (anim.mViewHolder == viewHolder) {
            anim.mOverridden |= override;
            if (!anim.mEnded) {
                anim.cancel();
            }
            mRecoverAnimations.remove(i);
            return anim.mAnimationType;
        }
    }
    return 0;
}
 

import org.telegram.messenger.support.widget.RecyclerView.ViewHolder; //导入依赖的package包/类
private ViewHolder findSwipedView(MotionEvent motionEvent) {
    final RecyclerView.LayoutManager lm = mRecyclerView.getLayoutManager();
    if (mActivePointerId == ACTIVE_POINTER_ID_NONE) {
        return null;
    }
    final int pointerIndex = MotionEventCompat.findPointerIndex(motionEvent, mActivePointerId);
    final float dx = MotionEventCompat.getX(motionEvent, pointerIndex) - mInitialTouchX;
    final float dy = MotionEventCompat.getY(motionEvent, pointerIndex) - mInitialTouchY;
    final float absDx = Math.abs(dx);
    final float absDy = Math.abs(dy);

    if (absDx < mSlop && absDy < mSlop) {
        return null;
    }
    if (absDx > absDy && lm.canScrollHorizontally()) {
        return null;
    } else if (absDy > absDx && lm.canScrollVertically()) {
        return null;
    }
    View child = findChildView(motionEvent);
    if (child == null) {
        return null;
    }
    return mRecyclerView.getChildViewHolder(child);
}
 

import org.telegram.messenger.support.widget.RecyclerView.ViewHolder; //导入依赖的package包/类
@Override
public boolean animateAppearance(@NonNull ViewHolder viewHolder,
        @Nullable ItemHolderInfo preLayoutInfo, @NonNull ItemHolderInfo postLayoutInfo) {
    if (preLayoutInfo != null && (preLayoutInfo.left != postLayoutInfo.left
            || preLayoutInfo.top != postLayoutInfo.top)) {
        // slide items in if before/after locations differ
        if (DEBUG) {
            Log.d(TAG, "APPEARING: " + viewHolder + " with view " + viewHolder);
        }
        return animateMove(viewHolder, preLayoutInfo.left, preLayoutInfo.top,
                postLayoutInfo.left, postLayoutInfo.top);
    } else {
        if (DEBUG) {
            Log.d(TAG, "ADDED: " + viewHolder + " with view " + viewHolder);
        }
        return animateAdd(viewHolder);
    }
}
 

import org.telegram.messenger.support.widget.RecyclerView.ViewHolder; //导入依赖的package包/类
@Override
public boolean animateDisappearance(@NonNull ViewHolder viewHolder,
        @NonNull ItemHolderInfo preLayoutInfo, @Nullable ItemHolderInfo postLayoutInfo) {
    int oldLeft = preLayoutInfo.left;
    int oldTop = preLayoutInfo.top;
    View disappearingItemView = viewHolder.itemView;
    int newLeft = postLayoutInfo == null ? disappearingItemView.getLeft() : postLayoutInfo.left;
    int newTop = postLayoutInfo == null ? disappearingItemView.getTop() : postLayoutInfo.top;
    if (!viewHolder.isRemoved() && (oldLeft != newLeft || oldTop != newTop)) {
        disappearingItemView.layout(newLeft, newTop,
                newLeft + disappearingItemView.getWidth(),
                newTop + disappearingItemView.getHeight());
        if (DEBUG) {
            Log.d(TAG, "DISAPPEARING: " + viewHolder + " with view " + disappearingItemView);
        }
        return animateMove(viewHolder, oldLeft, oldTop, newLeft, newTop);
    } else {
        if (DEBUG) {
            Log.d(TAG, "REMOVED: " + viewHolder + " with view " + disappearingItemView);
        }
        return animateRemove(viewHolder);
    }
}
 

import org.telegram.messenger.support.widget.RecyclerView.ViewHolder; //导入依赖的package包/类
@Override
public boolean animateChange(@NonNull ViewHolder oldHolder, @NonNull ViewHolder newHolder,
        @NonNull ItemHolderInfo preInfo, @NonNull ItemHolderInfo postInfo) {
    if (DEBUG) {
        Log.d(TAG, "CHANGED: " + oldHolder + " with view " + oldHolder.itemView);
    }
    final int fromLeft = preInfo.left;
    final int fromTop = preInfo.top;
    final int toLeft, toTop;
    if (newHolder.shouldIgnore()) {
        toLeft = preInfo.left;
        toTop = preInfo.top;
    } else {
        toLeft = postInfo.left;
        toTop = postInfo.top;
    }
    return animateChange(oldHolder, newHolder, fromLeft, fromTop, toLeft, toTop);
}
 

import org.telegram.messenger.support.widget.RecyclerView.ViewHolder; //导入依赖的package包/类
private boolean endChangeAnimationIfNecessary(ChangeInfo changeInfo, ViewHolder item) {
    boolean oldItem = false;
    if (changeInfo.newHolder == item) {
        changeInfo.newHolder = null;
    } else if (changeInfo.oldHolder == item) {
        changeInfo.oldHolder = null;
        oldItem = true;
    } else {
        return false;
    }
    ViewCompat.setAlpha(item.itemView, 1);
    ViewCompat.setTranslationX(item.itemView, 0);
    ViewCompat.setTranslationY(item.itemView, 0);
    dispatchChangeFinished(item, oldItem);
    return true;
}
 

import org.telegram.messenger.support.widget.RecyclerView.ViewHolder; //导入依赖的package包/类
public RecoverAnimation(ViewHolder viewHolder, int animationType,
        int actionState, float startDx, float startDy, float targetX, float targetY) {
    mActionState = actionState;
    mAnimationType = animationType;
    mViewHolder = viewHolder;
    mStartDx = startDx;
    mStartDy = startDy;
    mTargetX = targetX;
    mTargetY = targetY;
    mValueAnimator = AnimatorCompatHelper.emptyValueAnimator();
    mValueAnimator.addUpdateListener(
            new AnimatorUpdateListenerCompat() {
                @Override
                public void onAnimationUpdate(ValueAnimatorCompat animation) {
                    setFraction(animation.getAnimatedFraction());
                }
            });
    mValueAnimator.setTarget(viewHolder.itemView);
    mValueAnimator.addListener(this);
    setFraction(0f);
}
 

import org.telegram.messenger.support.widget.RecyclerView.ViewHolder; //导入依赖的package包/类
private MoveInfo(ViewHolder holder, int fromX, int fromY, int toX, int toY) {
    this.holder = holder;
    this.fromX = fromX;
    this.fromY = fromY;
    this.toX = toX;
    this.toY = toY;
}
 

import org.telegram.messenger.support.widget.RecyclerView.ViewHolder; //导入依赖的package包/类
private ChangeInfo(ViewHolder oldHolder, ViewHolder newHolder,
        int fromX, int fromY, int toX, int toY) {
    this(oldHolder, newHolder);
    this.fromX = fromX;
    this.fromY = fromY;
    this.toX = toX;
    this.toY = toY;
}
 

import org.telegram.messenger.support.widget.RecyclerView.ViewHolder; //导入依赖的package包/类
@Override
public boolean animateAdd(final ViewHolder holder) {
    resetAnimation(holder);
    ViewCompat.setAlpha(holder.itemView, 0);
    mPendingAdditions.add(holder);
    return true;
}
 

import org.telegram.messenger.support.widget.RecyclerView.ViewHolder; //导入依赖的package包/类
/**
 * Checks if we should swap w/ another view holder.
 */
private void moveIfNecessary(ViewHolder viewHolder) {
    if (mRecyclerView.isLayoutRequested()) {
        return;
    }
    if (mActionState != ACTION_STATE_DRAG) {
        return;
    }

    final float threshold = mCallback.getMoveThreshold(viewHolder);
    final int x = (int) (mSelectedStartX + mDx);
    final int y = (int) (mSelectedStartY + mDy);
    if (Math.abs(y - viewHolder.itemView.getTop()) < viewHolder.itemView.getHeight() * threshold
            && Math.abs(x - viewHolder.itemView.getLeft())
            < viewHolder.itemView.getWidth() * threshold) {
        return;
    }
    List<ViewHolder> swapTargets = findSwapTargets(viewHolder);
    if (swapTargets.size() == 0) {
        return;
    }
    // may swap.
    ViewHolder target = mCallback.chooseDropTarget(viewHolder, swapTargets, x, y);
    if (target == null) {
        mSwapTargets.clear();
        mDistances.clear();
        return;
    }
    final int toPosition = target.getAdapterPosition();
    final int fromPosition = viewHolder.getAdapterPosition();
    if (mCallback.onMove(mRecyclerView, viewHolder, target)) {
        // keep target visible
        mCallback.onMoved(mRecyclerView, viewHolder, fromPosition,
                target, toPosition, x, y);
    }
}
 

import org.telegram.messenger.support.widget.RecyclerView.ViewHolder; //导入依赖的package包/类
@Override
public void onLongPress(MotionEvent e) {
    View child = findChildView(e);
    if (child != null) {
        ViewHolder vh = mRecyclerView.getChildViewHolder(child);
        if (vh != null) {
            if (!mCallback.hasDragFlag(mRecyclerView, vh)) {
                return;
            }
            int pointerId = MotionEventCompat.getPointerId(e, 0);
            // Long press is deferred.
            // Check w/ active pointer id to avoid selecting after motion
            // event is canceled.
            if (pointerId == mActivePointerId) {
                final int index = MotionEventCompat
                        .findPointerIndex(e, mActivePointerId);
                final float x = MotionEventCompat.getX(e, index);
                final float y = MotionEventCompat.getY(e, index);
                mInitialTouchX = x;
                mInitialTouchY = y;
                mDx = mDy = 0f;
                if (DEBUG) {
                    Log.d(TAG,
                            "onlong press: x:" + mInitialTouchX + ",y:" + mInitialTouchY);
                }
                if (mCallback.isLongPressDragEnabled()) {
                    select(vh, ACTION_STATE_DRAG);
                }
            }
        }
    }
}
 

import org.telegram.messenger.support.widget.RecyclerView.ViewHolder; //导入依赖的package包/类
/**
 * Called when {@link #onMove(RecyclerView, ViewHolder, ViewHolder)} returns true.
 * <p>
 * ItemTouchHelper does not create an extra Bitmap or View while dragging, instead, it
 * modifies the existing View. Because of this reason, it is important that the View is
 * still part of the layout after it is moved. This may not work as intended when swapped
 * Views are close to RecyclerView bounds or there are gaps between them (e.g. other Views
 * which were not eligible for dropping over).
 * <p>
 * This method is responsible to give necessary hint to the LayoutManager so that it will
 * keep the View in visible area. For example, for LinearLayoutManager, this is as simple
 * as calling {@link LinearLayoutManager#scrollToPositionWithOffset(int, int)}.
 *
 * Default implementation calls {@link RecyclerView#scrollToPosition(int)} if the View's
 * new position is likely to be out of bounds.
 * <p>
 * It is important to ensure the ViewHolder will stay visible as otherwise, it might be
 * removed by the LayoutManager if the move causes the View to go out of bounds. In that
 * case, drag will end prematurely.
 *
 * @param recyclerView The RecyclerView controlled by the ItemTouchHelper.
 * @param viewHolder   The ViewHolder under user's control.
 * @param fromPos      The previous adapter position of the dragged item (before it was
 *                     moved).
 * @param target       The ViewHolder on which the currently active item has been dropped.
 * @param toPos        The new adapter position of the dragged item.
 * @param x            The updated left value of the dragged View after drag translations
 *                     are applied. This value does not include margins added by
 *                     {@link RecyclerView.ItemDecoration}s.
 * @param y            The updated top value of the dragged View after drag translations
 *                     are applied. This value does not include margins added by
 *                     {@link RecyclerView.ItemDecoration}s.
 */
public void onMoved(final RecyclerView recyclerView,
        final ViewHolder viewHolder, int fromPos, final ViewHolder target, int toPos, int x,
        int y) {
    final RecyclerView.LayoutManager layoutManager = recyclerView.getLayoutManager();
    if (layoutManager instanceof ViewDropHandler) {
        ((ViewDropHandler) layoutManager).prepareForDrop(viewHolder.itemView,
                target.itemView, x, y);
        return;
    }

    // if layout manager cannot handle it, do some guesswork
    if (layoutManager.canScrollHorizontally()) {
        final int minLeft = layoutManager.getDecoratedLeft(target.itemView);
        if (minLeft <= recyclerView.getPaddingLeft()) {
            recyclerView.scrollToPosition(toPos);
        }
        final int maxRight = layoutManager.getDecoratedRight(target.itemView);
        if (maxRight >= recyclerView.getWidth() - recyclerView.getPaddingRight()) {
            recyclerView.scrollToPosition(toPos);
        }
    }

    if (layoutManager.canScrollVertically()) {
        final int minTop = layoutManager.getDecoratedTop(target.itemView);
        if (minTop <= recyclerView.getPaddingTop()) {
            recyclerView.scrollToPosition(toPos);
        }
        final int maxBottom = layoutManager.getDecoratedBottom(target.itemView);
        if (maxBottom >= recyclerView.getHeight() - recyclerView.getPaddingBottom()) {
            recyclerView.scrollToPosition(toPos);
        }
    }
}