Java Code Examples for androidx.recyclerview.widget.DiffUtil#DiffResult

public void swapItems(List<List<ISortableModel>> newItems, int column) {

        List<List<ISortableModel>> oldItems = (List<List<ISortableModel>>)
                mCellRecyclerViewAdapter.getItems();

        // Set new items without calling notifyCellDataSetChanged method of CellRecyclerViewAdapter
        mCellRecyclerViewAdapter.setItems(newItems, !mEnableAnimation);

        if(mEnableAnimation) {
            // Find the differences between old cell items and new items.
            final ColumnSortCallback diffCallback = new ColumnSortCallback(oldItems, newItems, column);
            final DiffUtil.DiffResult diffResult = DiffUtil.calculateDiff(diffCallback);

            diffResult.dispatchUpdatesTo(mCellRecyclerViewAdapter);
            diffResult.dispatchUpdatesTo(mRowHeaderRecyclerViewAdapter);
        }

    }
 

/**
 * 处理数据，通知RV刷新
 *
 * @param diffResult 返回的diffResult
 */
protected final void handleResult(DiffUtil.DiffResult diffResult) {
    checkAdapterBind();

    diffResult.dispatchUpdatesTo(getListUpdateCallback(mAdapter));

    mData.clear();
    mData.addAll(mNewData);

    HandleBase<T> pollData = mRefreshQueue.poll();
    if (pollData != null) {
        startRefresh(pollData);
    } else {
        onEnd();
    }
}
 

/**
 * @return null if removement cant be executed because min list size is required
 */
@Nullable
public Pair<List<Item>, DiffUtil.DiffResult> remove() {
    if (currentList.size() <= 6) {
        return null;
    }
    List<Item> newlist = copyCurrent();

    newlist.remove(1);
    newlist.remove(3);

    DiffUtil.DiffResult diffResult = DiffUtil.calculateDiff(new ItemDiff(currentList, newlist));

    currentList = newlist;
    return Pair.create(newlist, diffResult);
}
 

public Pair<List<Item>, DiffUtil.DiffResult> modify() {
    List<Item> newlist = copyCurrent();

    Item c1 = newlist.get(0).copy();
    c1.color = color();
    newlist.set(0, c1);

    Item c2 = newlist.get(5).copy();
    c2.text = c2.text + " - Updated";
    newlist.set(5, c2);

    DiffUtil.DiffResult diffResult = DiffUtil.calculateDiff(new ItemDiff(currentList, newlist));

    currentList = newlist;
    return Pair.create(newlist, diffResult);
}
 

private void swapItems(List<List<ISortableModel>> oldItems, List<List<ISortableModel>>
        newItems, int column, List<ISortableModel> newRowHeader, SortState sortState) {

    // Set new items without calling notifyCellDataSetChanged method of CellRecyclerViewAdapter
    mCellRecyclerViewAdapter.setItems(newItems, !mEnableAnimation);
    mRowHeaderRecyclerViewAdapter.setItems(newRowHeader, !mEnableAnimation);

    if(mEnableAnimation) {
        // Find the differences between old cell items and new items.
        final ColumnSortCallback diffCallback = new ColumnSortCallback(oldItems, newItems, column);
        final DiffUtil.DiffResult diffResult = DiffUtil.calculateDiff(diffCallback);

        diffResult.dispatchUpdatesTo(mCellRecyclerViewAdapter);
        diffResult.dispatchUpdatesTo(mRowHeaderRecyclerViewAdapter);
    }

    for (ColumnSortStateChangedListener listener : columnSortStateChangedListeners) {
        listener.onColumnSortStatusChanged(column, sortState);
    }
}
 

private void swapItems(List<ISortableModel> oldRowHeader,
                       List<ISortableModel> newRowHeader,
                       List<List<ISortableModel>> newColumnItems,
                       SortState sortState
) {

    // Set new items without calling notifyCellDataSetChanged method of CellRecyclerViewAdapter
    mRowHeaderRecyclerViewAdapter.setItems(newRowHeader, !mEnableAnimation);
    mCellRecyclerViewAdapter.setItems(newColumnItems, !mEnableAnimation);

    if(mEnableAnimation) {
        // Find the differences between old cell items and new items.
        final RowHeaderSortCallback diffCallback = new RowHeaderSortCallback(oldRowHeader, newRowHeader);
        final DiffUtil.DiffResult diffResult = DiffUtil.calculateDiff(diffCallback);

        diffResult.dispatchUpdatesTo(mRowHeaderRecyclerViewAdapter);
        diffResult.dispatchUpdatesTo(mCellRecyclerViewAdapter);
    }

    for (ColumnSortStateChangedListener listener : columnSortStateChangedListeners) {
        listener.onRowHeaderSortStatusChanged(sortState);
    }
}
 

private void refreshTransfer() {
    try {
        UserEntity userEntity = sDataManager.getTradeBean().getUsers().get(sDataManager.USER_ID);
        if (userEntity == null) return;
        mNewData.clear();
        for (TransferEntity transferEntity :
                userEntity.getTransfers().values()) {
            TransferEntity t = CloneUtils.clone(transferEntity);
            mNewData.add(t);
        }
        Collections.sort(mNewData);
        DiffUtil.DiffResult diffResult = DiffUtil.calculateDiff(new TransferDiffCallback(mOldData, mNewData), false);
        mAdapter.setData(mNewData);
        diffResult.dispatchUpdatesTo(mAdapter);
        mOldData.clear();
        mOldData.addAll(mNewData);
    } catch (Exception e) {
        e.printStackTrace();
    }

}
 

private void swapItems(@NonNull List<List<ISortableModel>> oldItems, @NonNull List<List<ISortableModel>>
        newItems, int column, @NonNull List<ISortableModel> newRowHeader, @NonNull SortState sortState) {

    // Set new items without calling notifyCellDataSetChanged method of CellRecyclerViewAdapter
    mCellRecyclerViewAdapter.setItems(newItems, !mEnableAnimation);
    mRowHeaderRecyclerViewAdapter.setItems(newRowHeader, !mEnableAnimation);

    if (mEnableAnimation) {
        // Find the differences between old cell items and new items.
        final ColumnSortCallback diffCallback = new ColumnSortCallback(oldItems, newItems, column);
        final DiffUtil.DiffResult diffResult = DiffUtil.calculateDiff(diffCallback);

        diffResult.dispatchUpdatesTo(mCellRecyclerViewAdapter);
        diffResult.dispatchUpdatesTo(mRowHeaderRecyclerViewAdapter);
    }

    for (ColumnSortStateChangedListener listener : columnSortStateChangedListeners) {
        listener.onColumnSortStatusChanged(column, sortState);
    }
}
 

private DiffResult(
    @NonNull List<? extends EpoxyModel<?>> previousModels,
    @NonNull List<? extends EpoxyModel<?>> newModels,
    @Nullable DiffUtil.DiffResult differResult
) {
  this.previousModels = previousModels;
  this.newModels = newModels;
  this.differResult = differResult;
}
 

void updateData(@NonNull List<? extends GroupMemberEntry> recipients) {
  if (data.isEmpty()) {
    data.addAll(recipients);
    notifyDataSetChanged();
  } else {
    DiffUtil.DiffResult diffResult = DiffUtil.calculateDiff(new DiffCallback(data, recipients));
    data.clear();
    data.addAll(recipients);
    diffResult.dispatchUpdatesTo(this);
  }
}
 

/**
 * Set breadcrumb items list and animates them correctly with recyclerview diff
 *
 * @param items Target list
 */
public <E extends IBreadcrumbItem> void updateItems(@NonNull List<E> items) {
	DiffUtil.DiffResult diffResult = DiffUtil.calculateDiff(new BreadcrumbsDiffCallback((List<IBreadcrumbItem>)items, mAdapter.getItems()));
	mAdapter.setItems(items);
	diffResult.dispatchUpdatesTo(mAdapter);
	postScroll(-1, 0);
}
 

public void updateItems(List<Spending> spendings){
    final SpendingDiffCallback diffCallback = new SpendingDiffCallback(this.spendings, spendings);
    final DiffUtil.DiffResult diffResult = DiffUtil.calculateDiff(diffCallback);

    this.spendings.clear();
    this.spendings.addAll(spendings);
    diffResult.dispatchUpdatesTo(this);
}
 

public Pair<List<Item>, DiffUtil.DiffResult> move() {
    List<Item> newlist = copyCurrent();

    Item c2 = newlist.remove(5);
    c2.color = color();
    newlist.add(1, c2);

    DiffUtil.DiffResult diffResult =
            DiffUtil.calculateDiff(new ItemDiff(currentList, newlist), true);

    currentList = newlist;
    return Pair.create(newlist, diffResult);
}
 

private void applyDiffResult(List<Game> games, DiffUtil.DiffResult diffResult) {
    pendingUpdates.remove(games);
    dispatchUpdates(games, diffResult);
    if (pendingUpdates.size() > 0) {
        final List<Game> latest = pendingUpdates.pop();
        pendingUpdates.clear();
        updateDataInternal(latest);
    }
}
 

public Pair<List<Item>, DiffUtil.DiffResult> add() {
    List<Item> newlist = copyCurrent();

    newlist.add(2, newItem());
    newlist.add(4, newItem());

    DiffUtil.DiffResult diffResult = DiffUtil.calculateDiff(new ItemDiff(currentList, newlist));

    currentList = newlist;
    return Pair.create(newlist, diffResult);
}
 

public void set(@NonNull List<EntityAccount> accounts) {
    Log.i("Set accounts=" + accounts.size());

    DiffUtil.DiffResult diff = DiffUtil.calculateDiff(new DiffCallback(items, accounts), false);
    items = accounts;
    diff.dispatchUpdatesTo(this);
}
 

private void updateItems() {
    Pair<List<Item>, DiffUtil.DiffResult> modify = itemProvider.modify();

    adapter.setItems(modify.first);
    modify.second.dispatchUpdatesTo(adapter);
}
 

public void updateList(List<AccountHistoryResponseItem> newList) {
    List<AccountHistoryResponseItem> oldList = this.historyList;
    this.historyList = newList;
    DiffUtil.DiffResult diffResult = DiffUtil.calculateDiff(new AccountHistoryDiffCallback(oldList, newList), true);
    diffResult.dispatchUpdatesTo(this);
}
 

public void updateList(List<Contact> newList) {
    List<Contact> oldList = this.contactList;
    this.contactList = newList;
    DiffUtil.DiffResult diffResult = DiffUtil.calculateDiff(new ContactSelectionDiffCallback(oldList, newList), false);
    diffResult.dispatchUpdatesTo(this);
}
 

@Override
public void dispatchUpdate(@NonNull DiffUtil.DiffResult result) {
    result.dispatchUpdatesTo(this);
}