Java 类android.support.v7.widget.RecyclerView.ViewHolder 实例源码

private List<ViewHolder> findSwapTargets(ViewHolder viewHolder) {
    if (this.mSwapTargets == null) {
        this.mSwapTargets = new ArrayList();
        this.mDistances = new ArrayList();
    } else {
        this.mSwapTargets.clear();
        this.mDistances.clear();
    }
    int margin = this.mCallback.getBoundingBoxMargin();
    int left = Math.round(this.mSelectedStartX + this.mDx) - margin;
    int top = Math.round(this.mSelectedStartY + this.mDy) - margin;
    int right = (viewHolder.itemView.getWidth() + left) + (margin * 2);
    int bottom = (viewHolder.itemView.getHeight() + top) + (margin * 2);
    int centerX = (left + right) / 2;
    int centerY = (top + bottom) / 2;
    LayoutManager lm = this.mRecyclerView.getLayoutManager();
    int childCount = lm.getChildCount();
    for (int i = 0; i < childCount; i++) {
        View other = lm.getChildAt(i);
        if (other != viewHolder.itemView && other.getBottom() >= top && other.getTop() <= bottom && other.getRight() >= left && other.getLeft() <= right) {
            ViewHolder otherVh = this.mRecyclerView.getChildViewHolder(other);
            if (this.mCallback.canDropOver(this.mRecyclerView, this.mSelected, otherVh)) {
                int dx = Math.abs(centerX - ((other.getLeft() + other.getRight()) / 2));
                int dy = Math.abs(centerY - ((other.getTop() + other.getBottom()) / 2));
                int dist = (dx * dx) + (dy * dy);
                int pos = 0;
                int cnt = this.mSwapTargets.size();
                int j = 0;
                while (j < cnt && dist > ((Integer) this.mDistances.get(j)).intValue()) {
                    pos++;
                    j++;
                }
                this.mSwapTargets.add(pos, otherVh);
                this.mDistances.add(pos, Integer.valueOf(dist));
            }
        }
    }
    return this.mSwapTargets;
}

private boolean endChangeAnimationIfNecessary(ChangeInfo changeInfo, ViewHolder item) {
    boolean oldItem = false;
    if (changeInfo.newHolder == item) {
        changeInfo.newHolder = null;
    } else if (changeInfo.oldHolder != item) {
        return false;
    } else {
        changeInfo.oldHolder = null;
        oldItem = true;
    }
    ViewCompat.setAlpha(item.itemView, 1.0f);
    ViewCompat.setTranslationX(item.itemView, 0.0f);
    ViewCompat.setTranslationY(item.itemView, 0.0f);
    dispatchChangeFinished(item, oldItem);
    return true;
}

@Override
public ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
    View view;
    if (viewType == TYPE_ITEM) {
        if (mContext == null) {
            mContext = parent.getContext();
        }
        view = LayoutInflater.from(mContext).inflate(R.layout.content_search_needs, parent, false);
        if (orderDao == null) orderDao = new OrderDao(mContext);
        final ItemViewHolder holder = new ItemViewHolder(view);
        return holder;
    }
    else if (viewType == TYPE_FOOTER) {
        view = LayoutInflater.from(mContext).inflate(R.layout.item_foot, parent,
                false);
        Log.e("!!!!!","111111111111");
        return new FootViewHolder(view);
    }
    return null;
}

@Override
public boolean animateChange(ViewHolder oldHolder, ViewHolder newHolder, int fromX, int fromY,
                             int toX, int toY) {
    final float prevTranslationX = ViewCompat.getTranslationX(oldHolder.itemView);
    final float prevTranslationY = ViewCompat.getTranslationY(oldHolder.itemView);
    final float prevAlpha = ViewCompat.getAlpha(oldHolder.itemView);
    endAnimation(oldHolder);
    int deltaX = (int) (toX - fromX - prevTranslationX);
    int deltaY = (int) (toY - fromY - prevTranslationY);
    // recover prev translation state after ending animation
    ViewCompat.setTranslationX(oldHolder.itemView, prevTranslationX);
    ViewCompat.setTranslationY(oldHolder.itemView, prevTranslationY);
    ViewCompat.setAlpha(oldHolder.itemView, prevAlpha);
    if (newHolder != null && newHolder.itemView != null) {
        // carry over translation values
        endAnimation(newHolder);
        ViewCompat.setTranslationX(newHolder.itemView, -deltaX);
        ViewCompat.setTranslationY(newHolder.itemView, -deltaY);
        ViewCompat.setAlpha(newHolder.itemView, 0);
    }
    mPendingChanges.add(new ChangeInfo(oldHolder, newHolder, fromX, fromY, toX, toY));
    return true;
}

private ItemHolderInfo popFromLayoutStep(ViewHolder vh, int flag) {
    ItemHolderInfo itemHolderInfo = null;
    int index = this.mLayoutHolderMap.indexOfKey(vh);
    if (index >= 0) {
        InfoRecord record = (InfoRecord) this.mLayoutHolderMap.valueAt(index);
        if (!(record == null || (record.flags & flag) == 0)) {
            record.flags &= flag ^ -1;
            if (flag == 4) {
                itemHolderInfo = record.preInfo;
            } else if (flag == 8) {
                itemHolderInfo = record.postInfo;
            } else {
                throw new IllegalArgumentException("Must provide flag PRE or POST");
            }
            if ((record.flags & 12) == 0) {
                this.mLayoutHolderMap.removeAt(index);
                InfoRecord.recycle(record);
            }
        }
    }
    return itemHolderInfo;
}

@Override
public ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
    View v = null;
    ViewHolder viewHolder = null;
    if (viewType == TYPE_COLOR) {
        v = LayoutInflater.from(parent.getContext()).inflate(
                R.layout.view_color_panel, parent,false);
        viewHolder = new ColorViewHolder(v);
    } else if (viewType == TYPE_MORE) {
        v = LayoutInflater.from(parent.getContext())
                .inflate(R.layout.view_color_more_panel,parent,false);
        viewHolder = new MoreViewHolder(v);
    }

    return viewHolder;
}

@Override
public RecyclerView.ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {

    if (viewType == ITEM_TYPE_HEADER) {
        return new HeaderBottomHolder(recyclerViewHeader);
    } else if (viewType == ITEM_TYPE_CONTENT) {
        return adapter.onCreateViewHolder(parent, viewType);
    } else if (viewType == ITEM_TYPE_BOTTOM) {
        return new HeaderBottomHolder(recyclerViewFooter);
    } else if (viewType == ITEM_TYPE_HEADERVIEW) {
        return new HeaderBottomHolder(headerView);
    } else if (viewType == ITEM_TYPE_FOOTVIEW) {
        return new HeaderBottomHolder(footView);
    }
    return adapter.onCreateViewHolder(parent, viewType);
}

void process(ProcessCallback callback) {
    for (int index = this.mLayoutHolderMap.size() - 1; index >= 0; index--) {
        ViewHolder viewHolder = (ViewHolder) this.mLayoutHolderMap.keyAt(index);
        InfoRecord record = (InfoRecord) this.mLayoutHolderMap.removeAt(index);
        if ((record.flags & 3) == 3) {
            callback.unused(viewHolder);
        } else if ((record.flags & 1) != 0) {
            if (record.preInfo == null) {
                callback.unused(viewHolder);
            } else {
                callback.processDisappeared(viewHolder, record.preInfo, record.postInfo);
            }
        } else if ((record.flags & 14) == 14) {
            callback.processAppeared(viewHolder, record.preInfo, record.postInfo);
        } else if ((record.flags & 12) == 12) {
            callback.processPersistent(viewHolder, record.preInfo, record.postInfo);
        } else if ((record.flags & 4) != 0) {
            callback.processDisappeared(viewHolder, record.preInfo, null);
        } else if ((record.flags & 8) != 0) {
            callback.processAppeared(viewHolder, record.preInfo, record.postInfo);
        } else if ((record.flags & 2) != 0) {
        }
        InfoRecord.recycle(record);
    }
}

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;
}

public void onLongPress(MotionEvent e) {
    View child = ItemTouchHelper.this.findChildView(e);
    if (child != null) {
        ViewHolder vh = ItemTouchHelper.this.mRecyclerView.getChildViewHolder(child);
        if (vh != null && ItemTouchHelper.this.mCallback.hasDragFlag(ItemTouchHelper.this.mRecyclerView, vh) && MotionEventCompat.getPointerId(e, 0) == ItemTouchHelper.this.mActivePointerId) {
            int index = MotionEventCompat.findPointerIndex(e, ItemTouchHelper.this.mActivePointerId);
            float x = MotionEventCompat.getX(e, index);
            float y = MotionEventCompat.getY(e, index);
            ItemTouchHelper.this.mInitialTouchX = x;
            ItemTouchHelper.this.mInitialTouchY = y;
            ItemTouchHelper itemTouchHelper = ItemTouchHelper.this;
            ItemTouchHelper.this.mDy = 0.0f;
            itemTouchHelper.mDx = 0.0f;
            if (ItemTouchHelper.this.mCallback.isLongPressDragEnabled()) {
                ItemTouchHelper.this.select(vh, 2);
            }
        }
    }
}

@SuppressWarnings("unchecked")
@Override
public final void onViewRecycled(ViewHolder holder) {
  if (!(holder instanceof HeaderFooterViewHolder)) {
    onItemViewRecycled((VH)holder);
  }
}

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;
}

private void callBack(OnGridItemMoveListener listener, ViewHolder viewHolder, int fromPos, ViewHolder target, int toPos, boolean addFirst, boolean isLast) {
    if (isLast || addFirst) {
        listener.onItemMove(fromPos, toPos, addFirst, isLast);
    } else if (viewHolder.getItemViewType() == target.getItemViewType()) {
        listener.onItemMove(fromPos, toPos, false, false);
    }
}

/**
 * If this method returns true, ItemTouchHelper assumes viewHolder has been
 * moved to the adapter position of target ViewHolder
 * @param recyclerView
 * @param viewHolder
 * @param target
 * @return
 */
@Override
public boolean onMove(RecyclerView recyclerView,
                      ViewHolder viewHolder,
                      ViewHolder target) {
    int toPosition = target.getAdapterPosition();
    mListener.onItemMove(viewHolder.getAdapterPosition(), toPosition);

    draggedTo = toPosition;

    return true;
}

@Override
/** Override prepHolderForAnimateRemove
 *
 * Called when an item is removed from the RecyclerView. Implementors can choose
 * whether and how to animate that change, but must always call
 * {@link #dispatchRemoveFinished(ViewHolder)} when done, either
 * immediately (if no animation will occur) or after the animation actually finishes.
 * The return value indicates whether an animation has been set up and whether the
 * ItemAnimators {@link #runPendingAnimations()} method should be called at the
 * next opportunity. This mechanism allows ItemAnimator to set up individual animations
 * as separate calls to {@link #animateAdd(H) animateAdd()},
 * {@link #animateMove(ViewHolder, int, int, int, int) animateMove()}, and
 * {@link #animateRemove(ViewHolder) animateRemove()} come in one by one, then
 * start the animations together in the later call to {@link #runPendingAnimations()}.
 *
 * <p>This method may also be called for disappearing items which continue to exist in the
 * RecyclerView, but for which the system does not have enough information to animate
 * them out of view. In that case, the default animation for removing items is run
 * on those items as well.</p>
 *
 * @param holder The item that is being removed.
 * @return true if a later call to {@link #runPendingAnimations()} is requested,
 * false otherwise.
 */
public boolean animateRemove(final ViewHolder holder) {
    mPendingRemovals.add((H) holder);
    return prepHolderForAnimateRemove((H) holder);
}

private void preAnimateAdd(final RecyclerView.ViewHolder holder) {
    clear(holder.itemView);

    if (holder instanceof AnimateViewHolder) {
        ((AnimateViewHolder) holder).preAnimateAddImpl();
    } else {
        preAnimateAddImpl(holder);
    }
}

@Override
public final ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
  switch (viewType) {
  case HEADER_TYPE: return new HeaderFooterViewHolder(header);
  case FOOTER_TYPE: return new HeaderFooterViewHolder(footer);
  default:          return onCreateItemViewHolder(parent, viewType);
  }
}

@Override
public boolean animateAdd(final ViewHolder holder) {
    resetAnimation(holder);
    ViewCompat.setAlpha(holder.itemView, 0);
    ViewCompat.setTranslationY(holder.itemView, holder.itemView.getHeight());
    mPendingAdditions.add(holder);
    return true;
}

public void startDrag(ViewHolder viewHolder) {
    if (!this.mCallback.hasDragFlag(this.mRecyclerView, viewHolder)) {
        Log.e(TAG, "Start drag has been called but swiping is not enabled");
    } else if (viewHolder.itemView.getParent() != this.mRecyclerView) {
        Log.e(TAG, "Start drag has been called with a view holder which is not a child of the RecyclerView which is controlled by this ItemTouchHelper.");
    } else {
        obtainVelocityTracker();
        this.mDy = 0.0f;
        this.mDx = 0.0f;
        select(viewHolder, 2);
    }
}

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;
}

private void preAnimateRemove(final ViewHolder holder) {
    ViewHelper.clear(holder.itemView);

    if (holder instanceof AnimateViewHolder) {
        ((AnimateViewHolder) holder).preAnimateRemoveImpl();
    } else {
        preAnimateRemoveImpl(holder);
    }
}

private void endChangeAnimation(List<ChangeInfo> infoList, ViewHolder item) {
    for (int i = infoList.size() - 1; i >= 0; i--) {
        ChangeInfo changeInfo = infoList.get(i);
        if (endChangeAnimationIfNecessary(changeInfo, item)) {
            if (changeInfo.oldHolder == null && changeInfo.newHolder == null) {
                infoList.remove(changeInfo);
            }
        }
    }
}

private int endRecoverAnimation(ViewHolder viewHolder, boolean override) {
    for (int i = this.mRecoverAnimations.size() - 1; i >= 0; i--) {
        RecoverAnimation anim = (RecoverAnimation) this.mRecoverAnimations.get(i);
        if (anim.mViewHolder == viewHolder) {
            anim.mOverridden |= override;
            if (!anim.mEnded) {
                anim.cancel();
            }
            this.mRecoverAnimations.remove(i);
            return anim.mAnimationType;
        }
    }
    return 0;
}

private void runAddAnimation(boolean removalsPending, boolean changesPending,
                             boolean movesPending, boolean additionsPending) {
    if (additionsPending) {
        final ArrayList<ViewHolder> additions = new ArrayList<>();
        // Sorting addition animations based on it's original layout position
        Collections.sort(mPendingAdditions, new Comparator<ViewHolder>() {
            @Override
            public int compare(ViewHolder vh1, ViewHolder vh2) {
                return vh1.getLayoutPosition() - vh2.getLayoutPosition();
            }
        });
        additions.addAll(mPendingAdditions);
        mAdditionsList.add(additions);
        mPendingAdditions.clear();
        Runnable adder = new Runnable() {
            public void run() {
                int index = 0;
                for (ViewHolder holder : additions) {
                    doAnimateAdd(holder, index++);
                }
                additions.clear();
                mAdditionsList.remove(additions);
            }
        };
        if (removalsPending || movesPending || changesPending) {
            long removeDuration = removalsPending ? getRemoveDuration() : 0;
            long moveDuration = movesPending ? getMoveDuration() : 0;
            long changeDuration = changesPending ? getChangeDuration() : 0;
            long totalDelay = removeDuration + Math.max(moveDuration, changeDuration);
            View view = additions.get(0).itemView;
            ViewCompat.postOnAnimationDelayed(view, adder, totalDelay);
        } else {
            adder.run();
        }
    }
}

@Override
    public void onChildDrawOver(Canvas c, RecyclerView recyclerView, ViewHolder viewHolder, float dX, float dY, int actionState, boolean isCurrentlyActive) {
        super.onChildDrawOver(c, recyclerView, viewHolder, dX, dY, actionState, isCurrentlyActive);
//        L.e("call: onChildDrawOver([c, recyclerView, viewHolder, dX, dY, actionState, isCurrentlyActive])-> " + actionState + " " + isCurrentlyActive + " " + viewHolder, 300);
        if (drawOverInFullscreen && viewHolder.getAdapterPosition() >= 0) {
            //L.e("call: onChildDrawOver([c, recyclerView, viewHolder, dX, dY, actionState, isCurrentlyActive])-> dx:" + dX + " dy:" + dY + " " + actionState + " " + isCurrentlyActive);
            c.save();
            c.getClipBounds(clipBounds);
            clipBounds.inset(-ScreenUtil.screenWidth, -ScreenUtil.screenHeight);
            c.clipRect(clipBounds, Region.Op.REPLACE);
            c.translate(viewHolder.itemView.getLeft() + dX, viewHolder.itemView.getTop() + dY);
            viewHolder.itemView.draw(c);
            c.restore();
        }
    }

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;
}

public void startSwipe(ViewHolder viewHolder) {
    if (!this.mCallback.hasSwipeFlag(this.mRecyclerView, viewHolder)) {
        Log.e(TAG, "Start swipe has been called but dragging is not enabled");
    } else if (viewHolder.itemView.getParent() != this.mRecyclerView) {
        Log.e(TAG, "Start swipe has been called with a view holder which is not a child of the RecyclerView controlled by this ItemTouchHelper.");
    } else {
        obtainVelocityTracker();
        this.mDy = 0.0f;
        this.mDx = 0.0f;
        select(viewHolder, 1);
    }
}

private View nextViewFromScrapList() {
    int size = this.mScrapList.size();
    for (int i = 0; i < size; i++) {
        View view = ((ViewHolder) this.mScrapList.get(i)).itemView;
        LayoutParams lp = (LayoutParams) view.getLayoutParams();
        if (!lp.isItemRemoved() && this.mCurrentPosition == lp.getViewLayoutPosition()) {
            assignPositionFromScrapList(view);
            return view;
        }
    }
    return null;
}

@Override
public void onBindViewHolder(ViewHolder holder, int position) {
    if (holder != null) {
        baseHolder = (SuperItemHolder) holder;
        baseHolder.setPosition(position);
        baseHolder.setData(mDatas.get(position), countPosition(position));
    }
}

@Override
protected void onCreate(Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);
  setContentView(R.layout.activity_main);

  ImageView giphyLogoView = (ImageView) findViewById(R.id.giphy_logo_view);

  GlideApp.with(this)
      .load(R.raw.large_giphy_logo)
      .into(giphyLogoView);

  RecyclerView gifList = (RecyclerView) findViewById(R.id.gif_list);
  LinearLayoutManager layoutManager = new LinearLayoutManager(this);
  gifList.setLayoutManager(layoutManager);

  RequestBuilder<Drawable> gifItemRequest = GlideApp.with(this)
      .asDrawable();

  ViewPreloadSizeProvider<Api.GifResult> preloadSizeProvider =
      new ViewPreloadSizeProvider<>();
  adapter = new GifAdapter(this, gifItemRequest, preloadSizeProvider);
  gifList.setAdapter(adapter);
  RecyclerViewPreloader<Api.GifResult> preloader =
      new RecyclerViewPreloader<>(GlideApp.with(this), adapter, preloadSizeProvider, 4);
  gifList.addOnScrollListener(preloader);
  gifList.setRecyclerListener(new RecyclerListener() {
    @Override
    public void onViewRecycled(ViewHolder holder) {
      // This is an optimization to reduce the memory usage of RecyclerView's recycled view pool
      // and good practice when using Glide with RecyclerView.
      GifViewHolder gifViewHolder = (GifViewHolder) holder;
      GlideApp.with(MainActivity.this).clear(gifViewHolder.gifView);
    }
  });
}

public void onChildViewDetachedFromWindow(View view) {
    removeChildDrawingOrderCallbackIfNecessary(view);
    ViewHolder holder = this.mRecyclerView.getChildViewHolder(view);
    if (holder != null) {
        if (this.mSelected == null || holder != this.mSelected) {
            endRecoverAnimation(holder, false);
            if (this.mPendingCleanup.remove(holder.itemView)) {
                this.mCallback.clearView(this.mRecyclerView, holder);
                return;
            }
            return;
        }
        select(null, 0);
    }
}

/**
 * Returns another view holder that should be dismissed at the same time as the provided one.
 */
public ViewHolder getDismissSibling(ViewHolder viewHolder) {
    int swipePos = viewHolder.getAdapterPosition();
    int siblingPosDelta = mRoot.getDismissSiblingPosDelta(swipePos);
    if (siblingPosDelta == 0) return null;

    return mRecyclerView.findViewHolderForAdapterPosition(siblingPosDelta + swipePos);
}

@Override
public void onBindViewHolder(ViewHolder holder, int position) {
    int type = getItemViewType(position);
    if(type == TYPE_COLOR){
        onBindColorViewHolder((ColorViewHolder)holder,position);
    }else if(type == TYPE_MORE){
        onBindColorMoreViewHolder((MoreViewHolder)holder,position);
    }
}

public void onChildViewDetachedFromWindow(View view) {
    removeChildDrawingOrderCallbackIfNecessary(view);
    ViewHolder holder = this.mRecyclerView.getChildViewHolder(view);
    if (holder != null) {
        if (this.mSelected == null || holder != this.mSelected) {
            endRecoverAnimation(holder, false);
            if (this.mPendingCleanup.remove(holder.itemView)) {
                this.mCallback.clearView(this.mRecyclerView, holder);
                return;
            }
            return;
        }
        select(null, 0);
    }
}

@Override
public final ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
  switch (viewType) {
  case HEADER_TYPE: return new HeaderFooterViewHolder(header);
  case FOOTER_TYPE: return new HeaderFooterViewHolder(footer);
  default:          return onCreateItemViewHolder(parent, viewType);
  }
}

protected ViewHolder getHeader(RecyclerView parent, StickyHeaderAdapter adapter, int position) {
  final long key = adapter.getHeaderId(position);

  if (headerCache.containsKey(key)) {
    return headerCache.get(key);
  } else {
    final ViewHolder holder = adapter.onCreateHeaderViewHolder(parent);
    final View header = holder.itemView;

    //noinspection unchecked
    adapter.onBindHeaderViewHolder(holder, position);

    int widthSpec = View.MeasureSpec.makeMeasureSpec(parent.getWidth(), View.MeasureSpec.EXACTLY);
    int heightSpec = View.MeasureSpec.makeMeasureSpec(parent.getHeight(), View.MeasureSpec.UNSPECIFIED);

    int childWidth = ViewGroup.getChildMeasureSpec(widthSpec,
                                                   parent.getPaddingLeft() + parent.getPaddingRight(), header.getLayoutParams().width);
    int childHeight = ViewGroup.getChildMeasureSpec(heightSpec,
                                                    parent.getPaddingTop() + parent.getPaddingBottom(), header.getLayoutParams().height);

    header.measure(childWidth, childHeight);
    header.layout(0, 0, header.getMeasuredWidth(), header.getMeasuredHeight());

    headerCache.put(key, holder);

    return holder;
  }
}

public boolean animateChange(@NonNull ViewHolder oldHolder, @NonNull ViewHolder newHolder, @NonNull ItemHolderInfo preInfo, @NonNull ItemHolderInfo postInfo) {
    int toLeft;
    int toTop;
    int fromLeft = preInfo.left;
    int fromTop = preInfo.top;
    if (newHolder.shouldIgnore()) {
        toLeft = preInfo.left;
        toTop = preInfo.top;
    } else {
        toLeft = postInfo.left;
        toTop = postInfo.top;
    }
    return animateChange(oldHolder, newHolder, fromLeft, fromTop, toLeft, toTop);
}

@Override
public void onBindViewHolder(ViewHolder holder, int position) {
    if (holder != null) {
        baseHolder = (SuperItemHolder) holder;
        baseHolder.setPosition(position);
        baseHolder.setData(mDatas.get(position));
    }
}

@Override
public
@NonNull
ItemHolderInfo recordPreLayoutInformation(@NonNull State state,
                                          @NonNull ViewHolder viewHolder, @AdapterChanges int changeFlags,
                                          @NonNull List<Object> payloads) {
    final ItemHolderInfo itemHolderInfo = super.recordPreLayoutInformation(state, viewHolder,
            changeFlags, payloads);
    if (itemHolderInfo instanceof PayloadItemHolderInfo) {
        ((PayloadItemHolderInfo) itemHolderInfo).setPayloads(payloads);
    }
    return itemHolderInfo;
}

public void onBindViewHolder(ViewHolder holder, int position) {
    PPModel model = (PPModel) this.mDatas.get(position);
    if (holder != null && model != null) {
        if (model.type() == ItemType.TYPE_HEADER) {
            onBindHeaderView(holder, position);
        } else if (model.type() == ItemType.TYPE_FOOTER) {
            onBindFooterView(holder, position);
        } else {
            onBindItemView(holder, position);
        }
    }
}