diff --git a/app/build.gradle b/app/build.gradle
index 756a43373d..88b0e572c8 100644
--- a/app/build.gradle
+++ b/app/build.gradle
@@ -608,9 +608,7 @@ dependencies {
// https://mvnrepository.com/artifact/androidx.recyclerview/recyclerview
// https://mvnrepository.com/artifact/androidx.recyclerview/recyclerview-selection
- //implementation "androidx.recyclerview:recyclerview:$recyclerview_version"
- implementation "androidx.customview:customview:1.1.0"
- implementation "androidx.customview:customview-poolingcontainer:1.0.0"
+ implementation "androidx.recyclerview:recyclerview:$recyclerview_version"
//implementation "androidx.recyclerview:recyclerview-selection:1.1.0" // 1.2.0-alpha01
// https://mvnrepository.com/artifact/androidx.coordinatorlayout/coordinatorlayout
diff --git a/app/src/main/java/androidx/recyclerview/widget/AdapterHelper.java b/app/src/main/java/androidx/recyclerview/widget/AdapterHelper.java
deleted file mode 100644
index 004f7445ce..0000000000
--- a/app/src/main/java/androidx/recyclerview/widget/AdapterHelper.java
+++ /dev/null
@@ -1,776 +0,0 @@
-/*
- * Copyright 2018 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package androidx.recyclerview.widget;
-
-import android.util.Log;
-
-import androidx.core.util.Pools;
-
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-
-/**
- * Helper class that can enqueue and process adapter update operations.
- *
- * To support animations, RecyclerView presents an older version the Adapter to best represent
- * previous state of the layout. Sometimes, this is not trivial when items are removed that were
- * not laid out, in which case, RecyclerView has no way of providing that item's view for
- * animations.
- *
- * AdapterHelper creates an UpdateOp for each adapter data change then pre-processes them. During
- * pre processing, AdapterHelper finds out which UpdateOps can be deferred to second layout pass
- * and which cannot. For the UpdateOps that cannot be deferred, AdapterHelper will change them
- * according to previously deferred operation and dispatch them before the first layout pass. It
- * also takes care of updating deferred UpdateOps since order of operations is changed by this
- * process.
- *
- * Although operations may be forwarded to LayoutManager in different orders, resulting data set
- * is guaranteed to be the consistent.
- */
-final class AdapterHelper implements OpReorderer.Callback {
-
- static final int POSITION_TYPE_INVISIBLE = 0;
-
- static final int POSITION_TYPE_NEW_OR_LAID_OUT = 1;
-
- private static final boolean DEBUG = false;
-
- private static final String TAG = "AHT";
-
- private Pools.Pool mUpdateOpPool = new Pools.SimplePool(UpdateOp.POOL_SIZE);
-
- final ArrayList mPendingUpdates = new ArrayList();
-
- final ArrayList mPostponedList = new ArrayList();
-
- final Callback mCallback;
-
- Runnable mOnItemProcessedCallback;
-
- final boolean mDisableRecycler;
-
- final OpReorderer mOpReorderer;
-
- private int mExistingUpdateTypes = 0;
-
- AdapterHelper(Callback callback) {
- this(callback, false);
- }
-
- AdapterHelper(Callback callback, boolean disableRecycler) {
- mCallback = callback;
- mDisableRecycler = disableRecycler;
- mOpReorderer = new OpReorderer(this);
- }
-
- AdapterHelper addUpdateOp(UpdateOp... ops) {
- Collections.addAll(mPendingUpdates, ops);
- return this;
- }
-
- void reset() {
- recycleUpdateOpsAndClearList(mPendingUpdates);
- recycleUpdateOpsAndClearList(mPostponedList);
- mExistingUpdateTypes = 0;
- }
-
- void preProcess() {
- mOpReorderer.reorderOps(mPendingUpdates);
- final int count = mPendingUpdates.size();
- for (int i = 0; i < count; i++) {
- UpdateOp op = mPendingUpdates.get(i);
- switch (op.cmd) {
- case UpdateOp.ADD:
- applyAdd(op);
- break;
- case UpdateOp.REMOVE:
- applyRemove(op);
- break;
- case UpdateOp.UPDATE:
- applyUpdate(op);
- break;
- case UpdateOp.MOVE:
- applyMove(op);
- break;
- }
- if (mOnItemProcessedCallback != null) {
- mOnItemProcessedCallback.run();
- }
- }
- mPendingUpdates.clear();
- }
-
- void consumePostponedUpdates() {
- final int count = mPostponedList.size();
- for (int i = 0; i < count; i++) {
- mCallback.onDispatchSecondPass(mPostponedList.get(i));
- }
- recycleUpdateOpsAndClearList(mPostponedList);
- mExistingUpdateTypes = 0;
- }
-
- private void applyMove(UpdateOp op) {
- // MOVE ops are pre-processed so at this point, we know that item is still in the adapter.
- // otherwise, it would be converted into a REMOVE operation
- postponeAndUpdateViewHolders(op);
- }
-
- private void applyRemove(UpdateOp op) {
- int tmpStart = op.positionStart;
- int tmpCount = 0;
- int tmpEnd = op.positionStart + op.itemCount;
- int type = -1;
- for (int position = op.positionStart; position < tmpEnd; position++) {
- boolean typeChanged = false;
- RecyclerView.ViewHolder vh = mCallback.findViewHolder(position);
- if (vh != null || canFindInPreLayout(position)) {
- // If a ViewHolder exists or this is a newly added item, we can defer this update
- // to post layout stage.
- // * For existing ViewHolders, we'll fake its existence in the pre-layout phase.
- // * For items that are added and removed in the same process cycle, they won't
- // have any effect in pre-layout since their add ops are already deferred to
- // post-layout pass.
- if (type == POSITION_TYPE_INVISIBLE) {
- // Looks like we have other updates that we cannot merge with this one.
- // Create an UpdateOp and dispatch it to LayoutManager.
- UpdateOp newOp = obtainUpdateOp(UpdateOp.REMOVE, tmpStart, tmpCount, null);
- dispatchAndUpdateViewHolders(newOp);
- typeChanged = true;
- }
- type = POSITION_TYPE_NEW_OR_LAID_OUT;
- } else {
- // This update cannot be recovered because we don't have a ViewHolder representing
- // this position. Instead, post it to LayoutManager immediately
- if (type == POSITION_TYPE_NEW_OR_LAID_OUT) {
- // Looks like we have other updates that we cannot merge with this one.
- // Create UpdateOp op and dispatch it to LayoutManager.
- UpdateOp newOp = obtainUpdateOp(UpdateOp.REMOVE, tmpStart, tmpCount, null);
- postponeAndUpdateViewHolders(newOp);
- typeChanged = true;
- }
- type = POSITION_TYPE_INVISIBLE;
- }
- if (typeChanged) {
- position -= tmpCount; // also equal to tmpStart
- tmpEnd -= tmpCount;
- tmpCount = 1;
- } else {
- tmpCount++;
- }
- }
- if (tmpCount != op.itemCount) { // all 1 effect
- recycleUpdateOp(op);
- op = obtainUpdateOp(UpdateOp.REMOVE, tmpStart, tmpCount, null);
- }
- if (type == POSITION_TYPE_INVISIBLE) {
- dispatchAndUpdateViewHolders(op);
- } else {
- postponeAndUpdateViewHolders(op);
- }
- }
-
- private void applyUpdate(UpdateOp op) {
- int tmpStart = op.positionStart;
- int tmpCount = 0;
- int tmpEnd = op.positionStart + op.itemCount;
- int type = -1;
- for (int position = op.positionStart; position < tmpEnd; position++) {
- RecyclerView.ViewHolder vh = mCallback.findViewHolder(position);
- if (vh != null || canFindInPreLayout(position)) { // deferred
- if (type == POSITION_TYPE_INVISIBLE) {
- UpdateOp newOp = obtainUpdateOp(UpdateOp.UPDATE, tmpStart, tmpCount,
- op.payload);
- dispatchAndUpdateViewHolders(newOp);
- tmpCount = 0;
- tmpStart = position;
- }
- type = POSITION_TYPE_NEW_OR_LAID_OUT;
- } else { // applied
- if (type == POSITION_TYPE_NEW_OR_LAID_OUT) {
- UpdateOp newOp = obtainUpdateOp(UpdateOp.UPDATE, tmpStart, tmpCount,
- op.payload);
- postponeAndUpdateViewHolders(newOp);
- tmpCount = 0;
- tmpStart = position;
- }
- type = POSITION_TYPE_INVISIBLE;
- }
- tmpCount++;
- }
- if (tmpCount != op.itemCount) { // all 1 effect
- Object payload = op.payload;
- recycleUpdateOp(op);
- op = obtainUpdateOp(UpdateOp.UPDATE, tmpStart, tmpCount, payload);
- }
- if (type == POSITION_TYPE_INVISIBLE) {
- dispatchAndUpdateViewHolders(op);
- } else {
- postponeAndUpdateViewHolders(op);
- }
- }
-
- private void dispatchAndUpdateViewHolders(UpdateOp op) {
- // tricky part.
- // traverse all postpones and revert their changes on this op if necessary, apply updated
- // dispatch to them since now they are after this op.
- if (op.cmd == UpdateOp.ADD || op.cmd == UpdateOp.MOVE) {
- throw new IllegalArgumentException("should not dispatch add or move for pre layout");
- }
- if (DEBUG) {
- Log.d(TAG, "dispatch (pre)" + op);
- Log.d(TAG, "postponed state before:");
- for (UpdateOp updateOp : mPostponedList) {
- Log.d(TAG, updateOp.toString());
- }
- Log.d(TAG, "----");
- }
-
- // handle each pos 1 by 1 to ensure continuity. If it breaks, dispatch partial
- // TODO Since move ops are pushed to end, we should not need this anymore
- int tmpStart = updatePositionWithPostponed(op.positionStart, op.cmd);
- if (DEBUG) {
- Log.d(TAG, "pos:" + op.positionStart + ",updatedPos:" + tmpStart);
- }
- int tmpCnt = 1;
- int offsetPositionForPartial = op.positionStart;
- final int positionMultiplier;
- switch (op.cmd) {
- case UpdateOp.UPDATE:
- positionMultiplier = 1;
- break;
- case UpdateOp.REMOVE:
- positionMultiplier = 0;
- break;
- default:
- throw new IllegalArgumentException("op should be remove or update." + op);
- }
- for (int p = 1; p < op.itemCount; p++) {
- final int pos = op.positionStart + (positionMultiplier * p);
- int updatedPos = updatePositionWithPostponed(pos, op.cmd);
- if (DEBUG) {
- Log.d(TAG, "pos:" + pos + ",updatedPos:" + updatedPos);
- }
- boolean continuous = false;
- switch (op.cmd) {
- case UpdateOp.UPDATE:
- continuous = updatedPos == tmpStart + 1;
- break;
- case UpdateOp.REMOVE:
- continuous = updatedPos == tmpStart;
- break;
- }
- if (continuous) {
- tmpCnt++;
- } else {
- // need to dispatch this separately
- UpdateOp tmp = obtainUpdateOp(op.cmd, tmpStart, tmpCnt, op.payload);
- if (DEBUG) {
- Log.d(TAG, "need to dispatch separately " + tmp);
- }
- dispatchFirstPassAndUpdateViewHolders(tmp, offsetPositionForPartial);
- recycleUpdateOp(tmp);
- if (op.cmd == UpdateOp.UPDATE) {
- offsetPositionForPartial += tmpCnt;
- }
- tmpStart = updatedPos; // need to remove previously dispatched
- tmpCnt = 1;
- }
- }
- Object payload = op.payload;
- recycleUpdateOp(op);
- if (tmpCnt > 0) {
- UpdateOp tmp = obtainUpdateOp(op.cmd, tmpStart, tmpCnt, payload);
- if (DEBUG) {
- Log.d(TAG, "dispatching:" + tmp);
- }
- dispatchFirstPassAndUpdateViewHolders(tmp, offsetPositionForPartial);
- recycleUpdateOp(tmp);
- }
- if (DEBUG) {
- Log.d(TAG, "post dispatch");
- Log.d(TAG, "postponed state after:");
- for (UpdateOp updateOp : mPostponedList) {
- Log.d(TAG, updateOp.toString());
- }
- Log.d(TAG, "----");
- }
- }
-
- void dispatchFirstPassAndUpdateViewHolders(UpdateOp op, int offsetStart) {
- mCallback.onDispatchFirstPass(op);
- switch (op.cmd) {
- case UpdateOp.REMOVE:
- mCallback.offsetPositionsForRemovingInvisible(offsetStart, op.itemCount);
- break;
- case UpdateOp.UPDATE:
- mCallback.markViewHoldersUpdated(offsetStart, op.itemCount, op.payload);
- break;
- default:
- throw new IllegalArgumentException("only remove and update ops can be dispatched"
- + " in first pass");
- }
- }
-
- private int updatePositionWithPostponed(int pos, int cmd) {
- final int count = mPostponedList.size();
- for (int i = count - 1; i >= 0; i--) {
- UpdateOp postponed = mPostponedList.get(i);
- if (postponed.cmd == UpdateOp.MOVE) {
- int start, end;
- if (postponed.positionStart < postponed.itemCount) {
- start = postponed.positionStart;
- end = postponed.itemCount;
- } else {
- start = postponed.itemCount;
- end = postponed.positionStart;
- }
- if (pos >= start && pos <= end) {
- //i'm affected
- if (start == postponed.positionStart) {
- if (cmd == UpdateOp.ADD) {
- postponed.itemCount++;
- } else if (cmd == UpdateOp.REMOVE) {
- postponed.itemCount--;
- }
- // op moved to left, move it right to revert
- pos++;
- } else {
- if (cmd == UpdateOp.ADD) {
- postponed.positionStart++;
- } else if (cmd == UpdateOp.REMOVE) {
- postponed.positionStart--;
- }
- // op was moved right, move left to revert
- pos--;
- }
- } else if (pos < postponed.positionStart) {
- // postponed MV is outside the dispatched OP. if it is before, offset
- if (cmd == UpdateOp.ADD) {
- postponed.positionStart++;
- postponed.itemCount++;
- } else if (cmd == UpdateOp.REMOVE) {
- postponed.positionStart--;
- postponed.itemCount--;
- }
- }
- } else {
- if (postponed.positionStart <= pos) {
- if (postponed.cmd == UpdateOp.ADD) {
- pos -= postponed.itemCount;
- } else if (postponed.cmd == UpdateOp.REMOVE) {
- pos += postponed.itemCount;
- }
- } else {
- if (cmd == UpdateOp.ADD) {
- postponed.positionStart++;
- } else if (cmd == UpdateOp.REMOVE) {
- postponed.positionStart--;
- }
- }
- }
- if (DEBUG) {
- Log.d(TAG, "dispath (step" + i + ")");
- Log.d(TAG, "postponed state:" + i + ", pos:" + pos);
- for (UpdateOp updateOp : mPostponedList) {
- Log.d(TAG, updateOp.toString());
- }
- Log.d(TAG, "----");
- }
- }
- for (int i = mPostponedList.size() - 1; i >= 0; i--) {
- UpdateOp op = mPostponedList.get(i);
- if (op.cmd == UpdateOp.MOVE) {
- if (op.itemCount == op.positionStart || op.itemCount < 0) {
- mPostponedList.remove(i);
- recycleUpdateOp(op);
- }
- } else if (op.itemCount <= 0) {
- mPostponedList.remove(i);
- recycleUpdateOp(op);
- }
- }
- return pos;
- }
-
- private boolean canFindInPreLayout(int position) {
- final int count = mPostponedList.size();
- for (int i = 0; i < count; i++) {
- UpdateOp op = mPostponedList.get(i);
- if (op.cmd == UpdateOp.MOVE) {
- if (findPositionOffset(op.itemCount, i + 1) == position) {
- return true;
- }
- } else if (op.cmd == UpdateOp.ADD) {
- // TODO optimize.
- final int end = op.positionStart + op.itemCount;
- for (int pos = op.positionStart; pos < end; pos++) {
- if (findPositionOffset(pos, i + 1) == position) {
- return true;
- }
- }
- }
- }
- return false;
- }
-
- private void applyAdd(UpdateOp op) {
- postponeAndUpdateViewHolders(op);
- }
-
- private void postponeAndUpdateViewHolders(UpdateOp op) {
- if (DEBUG) {
- Log.d(TAG, "postponing " + op);
- }
- mPostponedList.add(op);
- switch (op.cmd) {
- case UpdateOp.ADD:
- mCallback.offsetPositionsForAdd(op.positionStart, op.itemCount);
- break;
- case UpdateOp.MOVE:
- mCallback.offsetPositionsForMove(op.positionStart, op.itemCount);
- break;
- case UpdateOp.REMOVE:
- mCallback.offsetPositionsForRemovingLaidOutOrNewView(op.positionStart,
- op.itemCount);
- break;
- case UpdateOp.UPDATE:
- mCallback.markViewHoldersUpdated(op.positionStart, op.itemCount, op.payload);
- break;
- default:
- throw new IllegalArgumentException("Unknown update op type for " + op);
- }
- }
-
- boolean hasPendingUpdates() {
- return mPendingUpdates.size() > 0;
- }
-
- boolean hasAnyUpdateTypes(int updateTypes) {
- return (mExistingUpdateTypes & updateTypes) != 0;
- }
-
- int findPositionOffset(int position) {
- return findPositionOffset(position, 0);
- }
-
- int findPositionOffset(int position, int firstPostponedItem) {
- int count = mPostponedList.size();
- for (int i = firstPostponedItem; i < count; ++i) {
- UpdateOp op = mPostponedList.get(i);
- if (op.cmd == UpdateOp.MOVE) {
- if (op.positionStart == position) {
- position = op.itemCount;
- } else {
- if (op.positionStart < position) {
- position--; // like a remove
- }
- if (op.itemCount <= position) {
- position++; // like an add
- }
- }
- } else if (op.positionStart <= position) {
- if (op.cmd == UpdateOp.REMOVE) {
- if (position < op.positionStart + op.itemCount) {
- return -1;
- }
- position -= op.itemCount;
- } else if (op.cmd == UpdateOp.ADD) {
- position += op.itemCount;
- }
- }
- }
- return position;
- }
-
- /**
- * @return True if updates should be processed.
- */
- boolean onItemRangeChanged(int positionStart, int itemCount, Object payload) {
- if (itemCount < 1) {
- return false;
- }
- mPendingUpdates.add(obtainUpdateOp(UpdateOp.UPDATE, positionStart, itemCount, payload));
- mExistingUpdateTypes |= UpdateOp.UPDATE;
- return mPendingUpdates.size() == 1;
- }
-
- /**
- * @return True if updates should be processed.
- */
- boolean onItemRangeInserted(int positionStart, int itemCount) {
- if (itemCount < 1) {
- return false;
- }
- mPendingUpdates.add(obtainUpdateOp(UpdateOp.ADD, positionStart, itemCount, null));
- mExistingUpdateTypes |= UpdateOp.ADD;
- return mPendingUpdates.size() == 1;
- }
-
- /**
- * @return True if updates should be processed.
- */
- boolean onItemRangeRemoved(int positionStart, int itemCount) {
- if (itemCount < 1) {
- return false;
- }
- mPendingUpdates.add(obtainUpdateOp(UpdateOp.REMOVE, positionStart, itemCount, null));
- mExistingUpdateTypes |= UpdateOp.REMOVE;
- return mPendingUpdates.size() == 1;
- }
-
- /**
- * @return True if updates should be processed.
- */
- boolean onItemRangeMoved(int from, int to, int itemCount) {
- if (from == to) {
- return false; // no-op
- }
- if (itemCount != 1) {
- throw new IllegalArgumentException("Moving more than 1 item is not supported yet");
- }
- mPendingUpdates.add(obtainUpdateOp(UpdateOp.MOVE, from, to, null));
- mExistingUpdateTypes |= UpdateOp.MOVE;
- return mPendingUpdates.size() == 1;
- }
-
- /**
- * Skips pre-processing and applies all updates in one pass.
- */
- void consumeUpdatesInOnePass() {
- // we still consume postponed updates (if there is) in case there was a pre-process call
- // w/o a matching consumePostponedUpdates.
- consumePostponedUpdates();
- final int count = mPendingUpdates.size();
- for (int i = 0; i < count; i++) {
- UpdateOp op = mPendingUpdates.get(i);
- switch (op.cmd) {
- case UpdateOp.ADD:
- mCallback.onDispatchSecondPass(op);
- mCallback.offsetPositionsForAdd(op.positionStart, op.itemCount);
- break;
- case UpdateOp.REMOVE:
- mCallback.onDispatchSecondPass(op);
- mCallback.offsetPositionsForRemovingInvisible(op.positionStart, op.itemCount);
- break;
- case UpdateOp.UPDATE:
- mCallback.onDispatchSecondPass(op);
- mCallback.markViewHoldersUpdated(op.positionStart, op.itemCount, op.payload);
- break;
- case UpdateOp.MOVE:
- mCallback.onDispatchSecondPass(op);
- mCallback.offsetPositionsForMove(op.positionStart, op.itemCount);
- break;
- }
- if (mOnItemProcessedCallback != null) {
- mOnItemProcessedCallback.run();
- }
- }
- recycleUpdateOpsAndClearList(mPendingUpdates);
- mExistingUpdateTypes = 0;
- }
-
- public int applyPendingUpdatesToPosition(int position) {
- final int size = mPendingUpdates.size();
- for (int i = 0; i < size; i++) {
- UpdateOp op = mPendingUpdates.get(i);
- switch (op.cmd) {
- case UpdateOp.ADD:
- if (op.positionStart <= position) {
- position += op.itemCount;
- }
- break;
- case UpdateOp.REMOVE:
- if (op.positionStart <= position) {
- final int end = op.positionStart + op.itemCount;
- if (end > position) {
- return RecyclerView.NO_POSITION;
- }
- position -= op.itemCount;
- }
- break;
- case UpdateOp.MOVE:
- if (op.positionStart == position) {
- position = op.itemCount; //position end
- } else {
- if (op.positionStart < position) {
- position -= 1;
- }
- if (op.itemCount <= position) {
- position += 1;
- }
- }
- break;
- }
- }
- return position;
- }
-
- boolean hasUpdates() {
- return !mPostponedList.isEmpty() && !mPendingUpdates.isEmpty();
- }
-
- /**
- * Queued operation to happen when child views are updated.
- */
- static final class UpdateOp {
-
- static final int ADD = 1;
-
- static final int REMOVE = 1 << 1;
-
- static final int UPDATE = 1 << 2;
-
- static final int MOVE = 1 << 3;
-
- static final int POOL_SIZE = 30;
-
- int cmd;
-
- int positionStart;
-
- Object payload;
-
- // holds the target position if this is a MOVE
- int itemCount;
-
- UpdateOp(int cmd, int positionStart, int itemCount, Object payload) {
- this.cmd = cmd;
- this.positionStart = positionStart;
- this.itemCount = itemCount;
- this.payload = payload;
- }
-
- String cmdToString() {
- switch (cmd) {
- case ADD:
- return "add";
- case REMOVE:
- return "rm";
- case UPDATE:
- return "up";
- case MOVE:
- return "mv";
- }
- return "??";
- }
-
- @Override
- public String toString() {
- return Integer.toHexString(System.identityHashCode(this))
- + "[" + cmdToString() + ",s:" + positionStart + "c:" + itemCount
- + ",p:" + payload + "]";
- }
-
- @Override
- public boolean equals(Object o) {
- if (this == o) {
- return true;
- }
- if (!(o instanceof UpdateOp)) {
- return false;
- }
-
- UpdateOp op = (UpdateOp) o;
-
- if (cmd != op.cmd) {
- return false;
- }
- if (cmd == MOVE && Math.abs(itemCount - positionStart) == 1) {
- // reverse of this is also true
- if (itemCount == op.positionStart && positionStart == op.itemCount) {
- return true;
- }
- }
- if (itemCount != op.itemCount) {
- return false;
- }
- if (positionStart != op.positionStart) {
- return false;
- }
- if (payload != null) {
- if (!payload.equals(op.payload)) {
- return false;
- }
- } else if (op.payload != null) {
- return false;
- }
-
- return true;
- }
-
- @Override
- public int hashCode() {
- int result = cmd;
- result = 31 * result + positionStart;
- result = 31 * result + itemCount;
- return result;
- }
- }
-
- @Override
- public UpdateOp obtainUpdateOp(int cmd, int positionStart, int itemCount, Object payload) {
- UpdateOp op = mUpdateOpPool.acquire();
- if (op == null) {
- op = new UpdateOp(cmd, positionStart, itemCount, payload);
- } else {
- op.cmd = cmd;
- op.positionStart = positionStart;
- op.itemCount = itemCount;
- op.payload = payload;
- }
- return op;
- }
-
- @Override
- public void recycleUpdateOp(UpdateOp op) {
- if (!mDisableRecycler) {
- op.payload = null;
- mUpdateOpPool.release(op);
- }
- }
-
- void recycleUpdateOpsAndClearList(List ops) {
- final int count = ops.size();
- for (int i = 0; i < count; i++) {
- recycleUpdateOp(ops.get(i));
- }
- ops.clear();
- }
-
- /**
- * Contract between AdapterHelper and RecyclerView.
- */
- interface Callback {
-
- RecyclerView.ViewHolder findViewHolder(int position);
-
- void offsetPositionsForRemovingInvisible(int positionStart, int itemCount);
-
- void offsetPositionsForRemovingLaidOutOrNewView(int positionStart, int itemCount);
-
- void markViewHoldersUpdated(int positionStart, int itemCount, Object payloads);
-
- void onDispatchFirstPass(UpdateOp updateOp);
-
- void onDispatchSecondPass(UpdateOp updateOp);
-
- void offsetPositionsForAdd(int positionStart, int itemCount);
-
- void offsetPositionsForMove(int from, int to);
- }
-}
diff --git a/app/src/main/java/androidx/recyclerview/widget/AdapterListUpdateCallback.java b/app/src/main/java/androidx/recyclerview/widget/AdapterListUpdateCallback.java
deleted file mode 100644
index ec94f9c445..0000000000
--- a/app/src/main/java/androidx/recyclerview/widget/AdapterListUpdateCallback.java
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
- * Copyright 2018 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package androidx.recyclerview.widget;
-
-import android.annotation.SuppressLint;
-
-import androidx.annotation.NonNull;
-
-/**
- * ListUpdateCallback that dispatches update events to the given adapter.
- *
- * @see DiffUtil.DiffResult#dispatchUpdatesTo(RecyclerView.Adapter)
- */
-public final class AdapterListUpdateCallback implements ListUpdateCallback {
- @NonNull
- private final RecyclerView.Adapter mAdapter;
-
- /**
- * Creates an AdapterListUpdateCallback that will dispatch update events to the given adapter.
- *
- * @param adapter The Adapter to send updates to.
- */
- public AdapterListUpdateCallback(@NonNull RecyclerView.Adapter adapter) {
- mAdapter = adapter;
- }
-
- /** {@inheritDoc} */
- @Override
- public void onInserted(int position, int count) {
- mAdapter.notifyItemRangeInserted(position, count);
- }
-
- /** {@inheritDoc} */
- @Override
- public void onRemoved(int position, int count) {
- mAdapter.notifyItemRangeRemoved(position, count);
- }
-
- /** {@inheritDoc} */
- @Override
- public void onMoved(int fromPosition, int toPosition) {
- mAdapter.notifyItemMoved(fromPosition, toPosition);
- }
-
- /** {@inheritDoc} */
- @Override
- @SuppressLint("UnknownNullness") // b/240775049: Cannot annotate properly
- public void onChanged(int position, int count, Object payload) {
- mAdapter.notifyItemRangeChanged(position, count, payload);
- }
-}
diff --git a/app/src/main/java/androidx/recyclerview/widget/AsyncDifferConfig.java b/app/src/main/java/androidx/recyclerview/widget/AsyncDifferConfig.java
deleted file mode 100644
index ccd9cfae63..0000000000
--- a/app/src/main/java/androidx/recyclerview/widget/AsyncDifferConfig.java
+++ /dev/null
@@ -1,148 +0,0 @@
-/*
- * Copyright 2018 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package androidx.recyclerview.widget;
-
-import androidx.annotation.NonNull;
-import androidx.annotation.Nullable;
-import androidx.annotation.RestrictTo;
-
-import java.util.concurrent.Executor;
-import java.util.concurrent.Executors;
-
-/**
- * Configuration object for {@link ListAdapter}, {@link AsyncListDiffer}, and similar
- * background-thread list diffing adapter logic.
- *
- * At minimum, defines item diffing behavior with a {@link DiffUtil.ItemCallback}, used to compute
- * item differences to pass to a RecyclerView adapter.
- *
- * @param Type of items in the lists, and being compared.
- */
-public final class AsyncDifferConfig {
- @Nullable
- private final Executor mMainThreadExecutor;
- @NonNull
- private final Executor mBackgroundThreadExecutor;
- @NonNull
- private final DiffUtil.ItemCallback mDiffCallback;
-
- @SuppressWarnings("WeakerAccess") /* synthetic access */
- AsyncDifferConfig(
- @Nullable Executor mainThreadExecutor,
- @NonNull Executor backgroundThreadExecutor,
- @NonNull DiffUtil.ItemCallback diffCallback) {
- mMainThreadExecutor = mainThreadExecutor;
- mBackgroundThreadExecutor = backgroundThreadExecutor;
- mDiffCallback = diffCallback;
- }
-
- /** @hide */
- @SuppressWarnings("WeakerAccess")
- @RestrictTo(RestrictTo.Scope.LIBRARY)
- @Nullable
- public Executor getMainThreadExecutor() {
- return mMainThreadExecutor;
- }
-
- @SuppressWarnings("WeakerAccess")
- @NonNull
- public Executor getBackgroundThreadExecutor() {
- return mBackgroundThreadExecutor;
- }
-
- @SuppressWarnings("WeakerAccess")
- @NonNull
- public DiffUtil.ItemCallback getDiffCallback() {
- return mDiffCallback;
- }
-
- /**
- * Builder class for {@link AsyncDifferConfig}.
- *
- * @param
- */
- public static final class Builder {
- @Nullable
- private Executor mMainThreadExecutor;
- private Executor mBackgroundThreadExecutor;
- private final DiffUtil.ItemCallback mDiffCallback;
-
- public Builder(@NonNull DiffUtil.ItemCallback diffCallback) {
- mDiffCallback = diffCallback;
- }
-
- /**
- * If provided, defines the main thread executor used to dispatch adapter update
- * notifications on the main thread.
- *
- * If not provided or null, it will default to the main thread.
- *
- * @param executor The executor which can run tasks in the UI thread.
- * @return this
- *
- * @hide
- */
- @RestrictTo(RestrictTo.Scope.LIBRARY)
- @NonNull
- public Builder setMainThreadExecutor(@Nullable Executor executor) {
- mMainThreadExecutor = executor;
- return this;
- }
-
- /**
- * If provided, defines the background executor used to calculate the diff between an old
- * and a new list.
- *
- * If not provided or null, defaults to two thread pool executor, shared by all
- * ListAdapterConfigs.
- *
- * @param executor The background executor to run list diffing.
- * @return this
- */
- @SuppressWarnings({"unused", "WeakerAccess"})
- @NonNull
- public Builder setBackgroundThreadExecutor(@Nullable Executor executor) {
- mBackgroundThreadExecutor = executor;
- return this;
- }
-
- /**
- * Creates a {@link AsyncListDiffer} with the given parameters.
- *
- * @return A new AsyncDifferConfig.
- */
- @NonNull
- public AsyncDifferConfig build() {
- if (mBackgroundThreadExecutor == null) {
- synchronized (sExecutorLock) {
- if (sDiffExecutor == null) {
- sDiffExecutor = Executors.newFixedThreadPool(2);
- }
- }
- mBackgroundThreadExecutor = sDiffExecutor;
- }
- return new AsyncDifferConfig<>(
- mMainThreadExecutor,
- mBackgroundThreadExecutor,
- mDiffCallback);
- }
-
- // TODO: remove the below once supportlib has its own appropriate executors
- private static final Object sExecutorLock = new Object();
- private static Executor sDiffExecutor = null;
- }
-}
diff --git a/app/src/main/java/androidx/recyclerview/widget/AsyncListDiffer.java b/app/src/main/java/androidx/recyclerview/widget/AsyncListDiffer.java
deleted file mode 100644
index c1fdb87858..0000000000
--- a/app/src/main/java/androidx/recyclerview/widget/AsyncListDiffer.java
+++ /dev/null
@@ -1,405 +0,0 @@
-/*
- * Copyright 2018 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package androidx.recyclerview.widget;
-
-import android.os.Handler;
-import android.os.Looper;
-
-import androidx.annotation.NonNull;
-import androidx.annotation.Nullable;
-
-import java.util.Collections;
-import java.util.List;
-import java.util.concurrent.CopyOnWriteArrayList;
-import java.util.concurrent.Executor;
-
-/**
- * Helper for computing the difference between two lists via {@link DiffUtil} on a background
- * thread.
- *
- * It can be connected to a
- * {@link RecyclerView.Adapter RecyclerView.Adapter}, and will signal the
- * adapter of changes between sumbitted lists.
- *
- * For simplicity, the {@link ListAdapter} wrapper class can often be used instead of the
- * AsyncListDiffer directly. This AsyncListDiffer can be used for complex cases, where overriding an
- * adapter base class to support asynchronous List diffing isn't convenient.
- *
- * The AsyncListDiffer can consume the values from a LiveData of List and present the
- * data simply for an adapter. It computes differences in list contents via {@link DiffUtil} on a
- * background thread as new Lists are received.
- *
- * Use {@link #getCurrentList()} to access the current List, and present its data objects. Diff
- * results will be dispatched to the ListUpdateCallback immediately before the current list is
- * updated. If you're dispatching list updates directly to an Adapter, this means the Adapter can
- * safely access list items and total size via {@link #getCurrentList()}.
- *
- * A complete usage pattern with Room would look like this:
- *
- * {@literal @}Dao
- * interface UserDao {
- * {@literal @}Query("SELECT * FROM user ORDER BY lastName ASC")
- * public abstract LiveData<List<User>> usersByLastName();
- * }
- *
- * class MyViewModel extends ViewModel {
- * public final LiveData<List<User>> usersList;
- * public MyViewModel(UserDao userDao) {
- * usersList = userDao.usersByLastName();
- * }
- * }
- *
- * class MyActivity extends AppCompatActivity {
- * {@literal @}Override
- * public void onCreate(Bundle savedState) {
- * super.onCreate(savedState);
- * MyViewModel viewModel = new ViewModelProvider(this).get(MyViewModel.class);
- * RecyclerView recyclerView = findViewById(R.id.user_list);
- * UserAdapter adapter = new UserAdapter();
- * viewModel.usersList.observe(this, list -> adapter.submitList(list));
- * recyclerView.setAdapter(adapter);
- * }
- * }
- *
- * class UserAdapter extends RecyclerView.Adapter<UserViewHolder> {
- * private final AsyncListDiffer<User> mDiffer = new AsyncListDiffer(this, DIFF_CALLBACK);
- * {@literal @}Override
- * public int getItemCount() {
- * return mDiffer.getCurrentList().size();
- * }
- * public void submitList(List<User> list) {
- * mDiffer.submitList(list);
- * }
- * {@literal @}Override
- * public void onBindViewHolder(UserViewHolder holder, int position) {
- * User user = mDiffer.getCurrentList().get(position);
- * holder.bindTo(user);
- * }
- * public static final DiffUtil.ItemCallback<User> DIFF_CALLBACK
- * = new DiffUtil.ItemCallback<User>() {
- * {@literal @}Override
- * public boolean areItemsTheSame(
- * {@literal @}NonNull User oldUser, {@literal @}NonNull User newUser) {
- * // User properties may have changed if reloaded from the DB, but ID is fixed
- * return oldUser.getId() == newUser.getId();
- * }
- * {@literal @}Override
- * public boolean areContentsTheSame(
- * {@literal @}NonNull User oldUser, {@literal @}NonNull User newUser) {
- * // NOTE: if you use equals, your object must properly override Object#equals()
- * // Incorrectly returning false here will result in too many animations.
- * return oldUser.equals(newUser);
- * }
- * }
- * }
- *
- * @param Type of the lists this AsyncListDiffer will receive.
- *
- * @see DiffUtil
- * @see AdapterListUpdateCallback
- */
-public class AsyncListDiffer {
- private final ListUpdateCallback mUpdateCallback;
- @SuppressWarnings("WeakerAccess") /* synthetic access */
- final AsyncDifferConfig mConfig;
- Executor mMainThreadExecutor;
-
- private static class MainThreadExecutor implements Executor {
- final Handler mHandler = new Handler(Looper.getMainLooper());
- MainThreadExecutor() {}
- @Override
- public void execute(@NonNull Runnable command) {
- mHandler.post(command);
- }
- }
-
- // TODO: use MainThreadExecutor from supportlib once one exists
- private static final Executor sMainThreadExecutor = new MainThreadExecutor();
-
- /**
- * Listener for when the current List is updated.
- *
- * @param Type of items in List
- */
- public interface ListListener {
- /**
- * Called after the current List has been updated.
- *
- * @param previousList The previous list.
- * @param currentList The new current list.
- */
- void onCurrentListChanged(@NonNull List previousList, @NonNull List currentList);
- }
-
- private final List> mListeners = new CopyOnWriteArrayList<>();
-
- /**
- * Convenience for
- * {@code AsyncListDiffer(new AdapterListUpdateCallback(adapter),
- * new AsyncDifferConfig.Builder().setDiffCallback(diffCallback).build());}
- *
- * @param adapter Adapter to dispatch position updates to.
- * @param diffCallback ItemCallback that compares items to dispatch appropriate animations when
- *
- * @see DiffUtil.DiffResult#dispatchUpdatesTo(RecyclerView.Adapter)
- */
- public AsyncListDiffer(@NonNull RecyclerView.Adapter adapter,
- @NonNull DiffUtil.ItemCallback diffCallback) {
- this(new AdapterListUpdateCallback(adapter),
- new AsyncDifferConfig.Builder<>(diffCallback).build());
- }
-
- /**
- * Create a AsyncListDiffer with the provided config, and ListUpdateCallback to dispatch
- * updates to.
- *
- * @param listUpdateCallback Callback to dispatch updates to.
- * @param config Config to define background work Executor, and DiffUtil.ItemCallback for
- * computing List diffs.
- *
- * @see DiffUtil.DiffResult#dispatchUpdatesTo(RecyclerView.Adapter)
- */
- @SuppressWarnings("WeakerAccess")
- public AsyncListDiffer(@NonNull ListUpdateCallback listUpdateCallback,
- @NonNull AsyncDifferConfig config) {
- mUpdateCallback = listUpdateCallback;
- mConfig = config;
- if (config.getMainThreadExecutor() != null) {
- mMainThreadExecutor = config.getMainThreadExecutor();
- } else {
- mMainThreadExecutor = sMainThreadExecutor;
- }
- }
-
- @Nullable
- private List mList;
-
- /**
- * Non-null, unmodifiable version of mList.
- *
- * Collections.emptyList when mList is null, wrapped by Collections.unmodifiableList otherwise
- */
- @NonNull
- private List mReadOnlyList = Collections.emptyList();
-
- // Max generation of currently scheduled runnable
- @SuppressWarnings("WeakerAccess") /* synthetic access */
- int mMaxScheduledGeneration;
-
- /**
- * Get the current List - any diffing to present this list has already been computed and
- * dispatched via the ListUpdateCallback.
- *
- * If a null List, or no List has been submitted, an empty list will be returned.
- *
- * The returned list may not be mutated - mutations to content must be done through
- * {@link #submitList(List)}.
- *
- * @return current List.
- */
- @NonNull
- public List getCurrentList() {
- return mReadOnlyList;
- }
-
- /**
- * Pass a new List to the AdapterHelper. Adapter updates will be computed on a background
- * thread.
- *
- * If a List is already present, a diff will be computed asynchronously on a background thread.
- * When the diff is computed, it will be applied (dispatched to the {@link ListUpdateCallback}),
- * and the new List will be swapped in.
- *
- * @param newList The new List.
- */
- @SuppressWarnings("WeakerAccess")
- public void submitList(@Nullable final List newList) {
- submitList(newList, null);
- }
-
- /**
- * Pass a new List to the AdapterHelper. Adapter updates will be computed on a background
- * thread.
- *
- * If a List is already present, a diff will be computed asynchronously on a background thread.
- * When the diff is computed, it will be applied (dispatched to the {@link ListUpdateCallback}),
- * and the new List will be swapped in.
- *
- * The commit callback can be used to know when the List is committed, but note that it
- * may not be executed. If List B is submitted immediately after List A, and is
- * committed directly, the callback associated with List A will not be run.
- *
- * @param newList The new List.
- * @param commitCallback Optional runnable that is executed when the List is committed, if
- * it is committed.
- */
- @SuppressWarnings("WeakerAccess")
- public void submitList(@Nullable final List newList,
- @Nullable final Runnable commitCallback) {
- // incrementing generation means any currently-running diffs are discarded when they finish
- final int runGeneration = ++mMaxScheduledGeneration;
-
- if (newList == mList) {
- // nothing to do (Note - still had to inc generation, since may have ongoing work)
- if (commitCallback != null) {
- commitCallback.run();
- }
- return;
- }
-
- final List previousList = mReadOnlyList;
-
- // fast simple remove all
- if (newList == null) {
- //noinspection ConstantConditions
- int countRemoved = mList.size();
- mList = null;
- mReadOnlyList = Collections.emptyList();
- // notify last, after list is updated
- mUpdateCallback.onRemoved(0, countRemoved);
- onCurrentListChanged(previousList, commitCallback);
- return;
- }
-
- // fast simple first insert
- if (mList == null) {
- mList = newList;
- mReadOnlyList = Collections.unmodifiableList(newList);
- // notify last, after list is updated
- mUpdateCallback.onInserted(0, newList.size());
- onCurrentListChanged(previousList, commitCallback);
- return;
- }
-
- final List oldList = mList;
- mConfig.getBackgroundThreadExecutor().execute(new Runnable() {
- @Override
- public void run() {
- final DiffUtil.DiffResult result = DiffUtil.calculateDiff(new DiffUtil.Callback() {
- @Override
- public int getOldListSize() {
- return oldList.size();
- }
-
- @Override
- public int getNewListSize() {
- return newList.size();
- }
-
- @Override
- public boolean areItemsTheSame(int oldItemPosition, int newItemPosition) {
- T oldItem = oldList.get(oldItemPosition);
- T newItem = newList.get(newItemPosition);
- if (oldItem != null && newItem != null) {
- return mConfig.getDiffCallback().areItemsTheSame(oldItem, newItem);
- }
- // If both items are null we consider them the same.
- return oldItem == null && newItem == null;
- }
-
- @Override
- public boolean areContentsTheSame(int oldItemPosition, int newItemPosition) {
- T oldItem = oldList.get(oldItemPosition);
- T newItem = newList.get(newItemPosition);
- if (oldItem != null && newItem != null) {
- return mConfig.getDiffCallback().areContentsTheSame(oldItem, newItem);
- }
- if (oldItem == null && newItem == null) {
- return true;
- }
- // There is an implementation bug if we reach this point. Per the docs, this
- // method should only be invoked when areItemsTheSame returns true. That
- // only occurs when both items are non-null or both are null and both of
- // those cases are handled above.
- throw new AssertionError();
- }
-
- @Nullable
- @Override
- public Object getChangePayload(int oldItemPosition, int newItemPosition) {
- T oldItem = oldList.get(oldItemPosition);
- T newItem = newList.get(newItemPosition);
- if (oldItem != null && newItem != null) {
- return mConfig.getDiffCallback().getChangePayload(oldItem, newItem);
- }
- // There is an implementation bug if we reach this point. Per the docs, this
- // method should only be invoked when areItemsTheSame returns true AND
- // areContentsTheSame returns false. That only occurs when both items are
- // non-null which is the only case handled above.
- throw new AssertionError();
- }
- });
-
- mMainThreadExecutor.execute(new Runnable() {
- @Override
- public void run() {
- if (mMaxScheduledGeneration == runGeneration) {
- latchList(newList, result, commitCallback);
- }
- }
- });
- }
- });
- }
-
- @SuppressWarnings("WeakerAccess") /* synthetic access */
- void latchList(
- @NonNull List newList,
- @NonNull DiffUtil.DiffResult diffResult,
- @Nullable Runnable commitCallback) {
- final List previousList = mReadOnlyList;
- mList = newList;
- // notify last, after list is updated
- mReadOnlyList = Collections.unmodifiableList(newList);
- diffResult.dispatchUpdatesTo(mUpdateCallback);
- onCurrentListChanged(previousList, commitCallback);
- }
-
- private void onCurrentListChanged(@NonNull List previousList,
- @Nullable Runnable commitCallback) {
- // current list is always mReadOnlyList
- for (ListListener listener : mListeners) {
- listener.onCurrentListChanged(previousList, mReadOnlyList);
- }
- if (commitCallback != null) {
- commitCallback.run();
- }
- }
-
- /**
- * Add a ListListener to receive updates when the current List changes.
- *
- * @param listener Listener to receive updates.
- *
- * @see #getCurrentList()
- * @see #removeListListener(ListListener)
- */
- public void addListListener(@NonNull ListListener listener) {
- mListeners.add(listener);
- }
-
- /**
- * Remove a previously registered ListListener.
- *
- * @param listener Previously registered listener.
- * @see #getCurrentList()
- * @see #addListListener(ListListener)
- */
- public void removeListListener(@NonNull ListListener listener) {
- mListeners.remove(listener);
- }
-}
diff --git a/app/src/main/java/androidx/recyclerview/widget/AsyncListUtil.java b/app/src/main/java/androidx/recyclerview/widget/AsyncListUtil.java
deleted file mode 100644
index b50f6a8137..0000000000
--- a/app/src/main/java/androidx/recyclerview/widget/AsyncListUtil.java
+++ /dev/null
@@ -1,596 +0,0 @@
-/*
- * Copyright 2018 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package androidx.recyclerview.widget;
-
-import android.util.Log;
-import android.util.SparseBooleanArray;
-import android.util.SparseIntArray;
-
-import androidx.annotation.NonNull;
-import androidx.annotation.Nullable;
-import androidx.annotation.UiThread;
-import androidx.annotation.WorkerThread;
-
-/**
- * A utility class that supports asynchronous content loading.
- *
- * It can be used to load Cursor data in chunks without querying the Cursor on the UI Thread while
- * keeping UI and cache synchronous for better user experience.
- *
- * It loads the data on a background thread and keeps only a limited number of fixed sized
- * chunks in memory at all times.
- *
- * {@link AsyncListUtil} queries the currently visible range through {@link ViewCallback},
- * loads the required data items in the background through {@link DataCallback}, and notifies a
- * {@link ViewCallback} when the data is loaded. It may load some extra items for smoother
- * scrolling.
- *
- * Note that this class uses a single thread to load the data, so it suitable to load data from
- * secondary storage such as disk, but not from network.
- *
- * This class is designed to work with {@link RecyclerView}, but it does
- * not depend on it and can be used with other list views.
- *
- */
-public class AsyncListUtil {
- static final String TAG = "AsyncListUtil";
-
- static final boolean DEBUG = false;
-
- final Class mTClass;
- final int mTileSize;
- final DataCallback mDataCallback;
- final ViewCallback mViewCallback;
-
- final TileList mTileList;
-
- final ThreadUtil.MainThreadCallback mMainThreadProxy;
- final ThreadUtil.BackgroundCallback mBackgroundProxy;
-
- final int[] mTmpRange = new int[2];
- final int[] mPrevRange = new int[2];
- final int[] mTmpRangeExtended = new int[2];
-
- boolean mAllowScrollHints;
- private int mScrollHint = ViewCallback.HINT_SCROLL_NONE;
-
- int mItemCount = 0;
-
- int mDisplayedGeneration = 0;
- int mRequestedGeneration = mDisplayedGeneration;
-
- final SparseIntArray mMissingPositions = new SparseIntArray();
-
- void log(String s, Object... args) {
- Log.d(TAG, "[MAIN] " + String.format(s, args));
- }
-
- /**
- * Creates an AsyncListUtil.
- *
- * @param klass Class of the data item.
- * @param tileSize Number of item per chunk loaded at once.
- * @param dataCallback Data access callback.
- * @param viewCallback Callback for querying visible item range and update notifications.
- */
- public AsyncListUtil(@NonNull Class klass, int tileSize,
- @NonNull DataCallback dataCallback, @NonNull ViewCallback viewCallback) {
- mTClass = klass;
- mTileSize = tileSize;
- mDataCallback = dataCallback;
- mViewCallback = viewCallback;
-
- mTileList = new TileList(mTileSize);
-
- ThreadUtil threadUtil = new MessageThreadUtil();
- mMainThreadProxy = threadUtil.getMainThreadProxy(mMainThreadCallback);
- mBackgroundProxy = threadUtil.getBackgroundProxy(mBackgroundCallback);
-
- refresh();
- }
-
- private boolean isRefreshPending() {
- return mRequestedGeneration != mDisplayedGeneration;
- }
-
- /**
- * Updates the currently visible item range.
- *
- *
- * Identifies the data items that have not been loaded yet and initiates loading them in the
- * background. Should be called from the view's scroll listener (such as
- * {@link RecyclerView.OnScrollListener#onScrolled}).
- */
- public void onRangeChanged() {
- if (isRefreshPending()) {
- return; // Will update range will the refresh result arrives.
- }
- updateRange();
- mAllowScrollHints = true;
- }
-
- /**
- * Forces reloading the data.
- *
- * Discards all the cached data and reloads all required data items for the currently visible
- * range. To be called when the data item count and/or contents has changed.
- */
- public void refresh() {
- mMissingPositions.clear();
- mBackgroundProxy.refresh(++mRequestedGeneration);
- }
-
- /**
- * Returns the data item at the given position or null if it has not been loaded
- * yet.
- *
- *
- * If this method has been called for a specific position and returned null, then
- * {@link ViewCallback#onItemLoaded(int)} will be called when it finally loads. Note that if
- * this position stays outside of the cached item range (as defined by
- * {@link ViewCallback#extendRangeInto} method), then the callback will never be called for
- * this position.
- *
- * @param position Item position.
- *
- * @return The data item at the given position or null if it has not been loaded
- * yet.
- */
- @Nullable
- public T getItem(int position) {
- if (position < 0 || position >= mItemCount) {
- throw new IndexOutOfBoundsException(position + " is not within 0 and " + mItemCount);
- }
- T item = mTileList.getItemAt(position);
- if (item == null && !isRefreshPending()) {
- mMissingPositions.put(position, 0);
- }
- return item;
- }
-
- /**
- * Returns the number of items in the data set.
- *
- *
- * This is the number returned by a recent call to
- * {@link DataCallback#refreshData()}.
- *
- * @return Number of items.
- */
- public int getItemCount() {
- return mItemCount;
- }
-
- void updateRange() {
- mViewCallback.getItemRangeInto(mTmpRange);
- if (mTmpRange[0] > mTmpRange[1] || mTmpRange[0] < 0) {
- return;
- }
- if (mTmpRange[1] >= mItemCount) {
- // Invalid range may arrive soon after the refresh.
- return;
- }
-
- if (!mAllowScrollHints) {
- mScrollHint = ViewCallback.HINT_SCROLL_NONE;
- } else if (mTmpRange[0] > mPrevRange[1] || mPrevRange[0] > mTmpRange[1]) {
- // Ranges do not intersect, long leap not a scroll.
- mScrollHint = ViewCallback.HINT_SCROLL_NONE;
- } else if (mTmpRange[0] < mPrevRange[0]) {
- mScrollHint = ViewCallback.HINT_SCROLL_DESC;
- } else if (mTmpRange[0] > mPrevRange[0]) {
- mScrollHint = ViewCallback.HINT_SCROLL_ASC;
- }
-
- mPrevRange[0] = mTmpRange[0];
- mPrevRange[1] = mTmpRange[1];
-
- mViewCallback.extendRangeInto(mTmpRange, mTmpRangeExtended, mScrollHint);
- mTmpRangeExtended[0] = Math.min(mTmpRange[0], Math.max(mTmpRangeExtended[0], 0));
- mTmpRangeExtended[1] =
- Math.max(mTmpRange[1], Math.min(mTmpRangeExtended[1], mItemCount - 1));
-
- mBackgroundProxy.updateRange(mTmpRange[0], mTmpRange[1],
- mTmpRangeExtended[0], mTmpRangeExtended[1], mScrollHint);
- }
-
- private final ThreadUtil.MainThreadCallback
- mMainThreadCallback = new ThreadUtil.MainThreadCallback() {
- @Override
- public void updateItemCount(int generation, int itemCount) {
- if (DEBUG) {
- log("updateItemCount: size=%d, gen #%d", itemCount, generation);
- }
- if (!isRequestedGeneration(generation)) {
- return;
- }
- mItemCount = itemCount;
- mViewCallback.onDataRefresh();
- mDisplayedGeneration = mRequestedGeneration;
- recycleAllTiles();
-
- mAllowScrollHints = false; // Will be set to true after a first real scroll.
- // There will be no scroll event if the size change does not affect the current range.
- updateRange();
- }
-
- @Override
- public void addTile(int generation, TileList.Tile tile) {
- if (!isRequestedGeneration(generation)) {
- if (DEBUG) {
- log("recycling an older generation tile @%d", tile.mStartPosition);
- }
- mBackgroundProxy.recycleTile(tile);
- return;
- }
- TileList.Tile duplicate = mTileList.addOrReplace(tile);
- if (duplicate != null) {
- Log.e(TAG, "duplicate tile @" + duplicate.mStartPosition);
- mBackgroundProxy.recycleTile(duplicate);
- }
- if (DEBUG) {
- log("gen #%d, added tile @%d, total tiles: %d",
- generation, tile.mStartPosition, mTileList.size());
- }
- int endPosition = tile.mStartPosition + tile.mItemCount;
- int index = 0;
- while (index < mMissingPositions.size()) {
- final int position = mMissingPositions.keyAt(index);
- if (tile.mStartPosition <= position && position < endPosition) {
- mMissingPositions.removeAt(index);
- mViewCallback.onItemLoaded(position);
- } else {
- index++;
- }
- }
- }
-
- @Override
- public void removeTile(int generation, int position) {
- if (!isRequestedGeneration(generation)) {
- return;
- }
- TileList.Tile tile = mTileList.removeAtPos(position);
- if (tile == null) {
- Log.e(TAG, "tile not found @" + position);
- return;
- }
- if (DEBUG) {
- log("recycling tile @%d, total tiles: %d", tile.mStartPosition, mTileList.size());
- }
- mBackgroundProxy.recycleTile(tile);
- }
-
- private void recycleAllTiles() {
- if (DEBUG) {
- log("recycling all %d tiles", mTileList.size());
- }
- for (int i = 0; i < mTileList.size(); i++) {
- mBackgroundProxy.recycleTile(mTileList.getAtIndex(i));
- }
- mTileList.clear();
- }
-
- private boolean isRequestedGeneration(int generation) {
- return generation == mRequestedGeneration;
- }
- };
-
- private final ThreadUtil.BackgroundCallback
- mBackgroundCallback = new ThreadUtil.BackgroundCallback() {
-
- private TileList.Tile mRecycledRoot;
-
- final SparseBooleanArray mLoadedTiles = new SparseBooleanArray();
-
- private int mGeneration;
- private int mItemCount;
-
- private int mFirstRequiredTileStart;
- private int mLastRequiredTileStart;
-
- @Override
- public void refresh(int generation) {
- mGeneration = generation;
- mLoadedTiles.clear();
- mItemCount = mDataCallback.refreshData();
- mMainThreadProxy.updateItemCount(mGeneration, mItemCount);
- }
-
- @Override
- public void updateRange(int rangeStart, int rangeEnd, int extRangeStart, int extRangeEnd,
- int scrollHint) {
- if (DEBUG) {
- log("updateRange: %d..%d extended to %d..%d, scroll hint: %d",
- rangeStart, rangeEnd, extRangeStart, extRangeEnd, scrollHint);
- }
-
- if (rangeStart > rangeEnd) {
- return;
- }
-
- final int firstVisibleTileStart = getTileStart(rangeStart);
- final int lastVisibleTileStart = getTileStart(rangeEnd);
-
- mFirstRequiredTileStart = getTileStart(extRangeStart);
- mLastRequiredTileStart = getTileStart(extRangeEnd);
- if (DEBUG) {
- log("requesting tile range: %d..%d",
- mFirstRequiredTileStart, mLastRequiredTileStart);
- }
-
- // All pending tile requests are removed by ThreadUtil at this point.
- // Re-request all required tiles in the most optimal order.
- if (scrollHint == ViewCallback.HINT_SCROLL_DESC) {
- requestTiles(mFirstRequiredTileStart, lastVisibleTileStart, scrollHint, true);
- requestTiles(lastVisibleTileStart + mTileSize, mLastRequiredTileStart, scrollHint,
- false);
- } else {
- requestTiles(firstVisibleTileStart, mLastRequiredTileStart, scrollHint, false);
- requestTiles(mFirstRequiredTileStart, firstVisibleTileStart - mTileSize, scrollHint,
- true);
- }
- }
-
- private int getTileStart(int position) {
- return position - position % mTileSize;
- }
-
- private void requestTiles(int firstTileStart, int lastTileStart, int scrollHint,
- boolean backwards) {
- for (int i = firstTileStart; i <= lastTileStart; i += mTileSize) {
- int tileStart = backwards ? (lastTileStart + firstTileStart - i) : i;
- if (DEBUG) {
- log("requesting tile @%d", tileStart);
- }
- mBackgroundProxy.loadTile(tileStart, scrollHint);
- }
- }
-
- @Override
- public void loadTile(int position, int scrollHint) {
- if (isTileLoaded(position)) {
- if (DEBUG) {
- log("already loaded tile @%d", position);
- }
- return;
- }
- TileList.Tile tile = acquireTile();
- tile.mStartPosition = position;
- tile.mItemCount = Math.min(mTileSize, mItemCount - tile.mStartPosition);
- mDataCallback.fillData(tile.mItems, tile.mStartPosition, tile.mItemCount);
- flushTileCache(scrollHint);
- addTile(tile);
- }
-
- @Override
- public void recycleTile(TileList.Tile tile) {
- if (DEBUG) {
- log("recycling tile @%d", tile.mStartPosition);
- }
- mDataCallback.recycleData(tile.mItems, tile.mItemCount);
-
- tile.mNext = mRecycledRoot;
- mRecycledRoot = tile;
- }
-
- private TileList.Tile acquireTile() {
- if (mRecycledRoot != null) {
- TileList.Tile result = mRecycledRoot;
- mRecycledRoot = mRecycledRoot.mNext;
- return result;
- }
- return new TileList.Tile(mTClass, mTileSize);
- }
-
- private boolean isTileLoaded(int position) {
- return mLoadedTiles.get(position);
- }
-
- private void addTile(TileList.Tile tile) {
- mLoadedTiles.put(tile.mStartPosition, true);
- mMainThreadProxy.addTile(mGeneration, tile);
- if (DEBUG) {
- log("loaded tile @%d, total tiles: %d", tile.mStartPosition, mLoadedTiles.size());
- }
- }
-
- private void removeTile(int position) {
- mLoadedTiles.delete(position);
- mMainThreadProxy.removeTile(mGeneration, position);
- if (DEBUG) {
- log("flushed tile @%d, total tiles: %s", position, mLoadedTiles.size());
- }
- }
-
- private void flushTileCache(int scrollHint) {
- final int cacheSizeLimit = mDataCallback.getMaxCachedTiles();
- while (mLoadedTiles.size() >= cacheSizeLimit) {
- int firstLoadedTileStart = mLoadedTiles.keyAt(0);
- int lastLoadedTileStart = mLoadedTiles.keyAt(mLoadedTiles.size() - 1);
- int startMargin = mFirstRequiredTileStart - firstLoadedTileStart;
- int endMargin = lastLoadedTileStart - mLastRequiredTileStart;
- if (startMargin > 0 && (startMargin >= endMargin ||
- (scrollHint == ViewCallback.HINT_SCROLL_ASC))) {
- removeTile(firstLoadedTileStart);
- } else if (endMargin > 0 && (startMargin < endMargin ||
- (scrollHint == ViewCallback.HINT_SCROLL_DESC))){
- removeTile(lastLoadedTileStart);
- } else {
- // Could not flush on either side, bail out.
- return;
- }
- }
- }
-
- private void log(String s, Object... args) {
- Log.d(TAG, "[BKGR] " + String.format(s, args));
- }
- };
-
- /**
- * The callback that provides data access for {@link AsyncListUtil}.
- *
- *
- * All methods are called on the background thread.
- */
- public static abstract class DataCallback {
-
- /**
- * Refresh the data set and return the new data item count.
- *
- *
- * If the data is being accessed through {@link android.database.Cursor} this is where
- * the new cursor should be created.
- *
- * @return Data item count.
- */
- @WorkerThread
- public abstract int refreshData();
-
- /**
- * Fill the given tile.
- *
- *
- * The provided tile might be a recycled tile, in which case it will already have objects.
- * It is suggested to re-use these objects if possible in your use case.
- *
- * @param startPosition The start position in the list.
- * @param itemCount The data item count.
- * @param data The data item array to fill into. Should not be accessed beyond
- * itemCount.
- */
- @WorkerThread
- public abstract void fillData(@NonNull T[] data, int startPosition, int itemCount);
-
- /**
- * Recycle the objects created in {@link #fillData} if necessary.
- *
- *
- * @param data Array of data items. Should not be accessed beyond itemCount.
- * @param itemCount The data item count.
- */
- @WorkerThread
- public void recycleData(@NonNull T[] data, int itemCount) {
- }
-
- /**
- * Returns tile cache size limit (in tiles).
- *
- *
- * The actual number of cached tiles will be the maximum of this value and the number of
- * tiles that is required to cover the range returned by
- * {@link ViewCallback#extendRangeInto(int[], int[], int)}.
- *
- * For example, if this method returns 10, and the most
- * recent call to {@link ViewCallback#extendRangeInto(int[], int[], int)} returned
- * {100, 179}, and the tile size is 5, then the maximum number of cached tiles will be 16.
- *
- * However, if the tile size is 20, then the maximum number of cached tiles will be 10.
- *
- * The default implementation returns 10.
- *
- * @return Maximum cache size.
- */
- @WorkerThread
- public int getMaxCachedTiles() {
- return 10;
- }
- }
-
- /**
- * The callback that links {@link AsyncListUtil} with the list view.
- *
- *
- * All methods are called on the main thread.
- */
- public static abstract class ViewCallback {
-
- /**
- * No scroll direction hint available.
- */
- public static final int HINT_SCROLL_NONE = 0;
-
- /**
- * Scrolling in descending order (from higher to lower positions in the order of the backing
- * storage).
- */
- public static final int HINT_SCROLL_DESC = 1;
-
- /**
- * Scrolling in ascending order (from lower to higher positions in the order of the backing
- * storage).
- */
- public static final int HINT_SCROLL_ASC = 2;
-
- /**
- * Compute the range of visible item positions.
- *
- * outRange[0] is the position of the first visible item (in the order of the backing
- * storage).
- *
- * outRange[1] is the position of the last visible item (in the order of the backing
- * storage).
- *
- * Negative positions and positions greater or equal to {@link #getItemCount} are invalid.
- * If the returned range contains invalid positions it is ignored (no item will be loaded).
- *
- * @param outRange The visible item range.
- */
- @UiThread
- public abstract void getItemRangeInto(@NonNull int[] outRange);
-
- /**
- * Compute a wider range of items that will be loaded for smoother scrolling.
- *
- *
- * If there is no scroll hint, the default implementation extends the visible range by half
- * its length in both directions. If there is a scroll hint, the range is extended by
- * its full length in the scroll direction, and by half in the other direction.
- *
- * For example, if range is {100, 200} and scrollHint
- * is {@link #HINT_SCROLL_ASC}, then outRange will be {50, 300}.
- *
- * However, if scrollHint is {@link #HINT_SCROLL_NONE}, then
- * outRange will be {50, 250}
- *
- * @param range Visible item range.
- * @param outRange Extended range.
- * @param scrollHint The scroll direction hint.
- */
- @UiThread
- public void extendRangeInto(@NonNull int[] range, @NonNull int[] outRange, int scrollHint) {
- final int fullRange = range[1] - range[0] + 1;
- final int halfRange = fullRange / 2;
- outRange[0] = range[0] - (scrollHint == HINT_SCROLL_DESC ? fullRange : halfRange);
- outRange[1] = range[1] + (scrollHint == HINT_SCROLL_ASC ? fullRange : halfRange);
- }
-
- /**
- * Called when the entire data set has changed.
- */
- @UiThread
- public abstract void onDataRefresh();
-
- /**
- * Called when an item at the given position is loaded.
- * @param position Item position.
- */
- @UiThread
- public abstract void onItemLoaded(int position);
- }
-}
diff --git a/app/src/main/java/androidx/recyclerview/widget/BatchingListUpdateCallback.java b/app/src/main/java/androidx/recyclerview/widget/BatchingListUpdateCallback.java
deleted file mode 100644
index bad8cc942e..0000000000
--- a/app/src/main/java/androidx/recyclerview/widget/BatchingListUpdateCallback.java
+++ /dev/null
@@ -1,128 +0,0 @@
-/*
- * Copyright 2018 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package androidx.recyclerview.widget;
-
-import android.annotation.SuppressLint;
-
-import androidx.annotation.NonNull;
-
-/**
- * Wraps a {@link ListUpdateCallback} callback and batches operations that can be merged.
- *
- * For instance, when 2 add operations comes that adds 2 consecutive elements,
- * BatchingListUpdateCallback merges them and calls the wrapped callback only once.
- *
- * This is a general purpose class and is also used by
- * {@link DiffUtil.DiffResult DiffResult} and
- * {@link SortedList} to minimize the number of updates that are dispatched.
- *
- * If you use this class to batch updates, you must call {@link #dispatchLastEvent()} when the
- * stream of update events drain.
- */
-public class BatchingListUpdateCallback implements ListUpdateCallback {
- private static final int TYPE_NONE = 0;
- private static final int TYPE_ADD = 1;
- private static final int TYPE_REMOVE = 2;
- private static final int TYPE_CHANGE = 3;
-
- final ListUpdateCallback mWrapped;
-
- int mLastEventType = TYPE_NONE;
- int mLastEventPosition = -1;
- int mLastEventCount = -1;
- Object mLastEventPayload = null;
-
- public BatchingListUpdateCallback(@NonNull ListUpdateCallback callback) {
- mWrapped = callback;
- }
-
- /**
- * BatchingListUpdateCallback holds onto the last event to see if it can be merged with the
- * next one. When stream of events finish, you should call this method to dispatch the last
- * event.
- */
- public void dispatchLastEvent() {
- if (mLastEventType == TYPE_NONE) {
- return;
- }
- switch (mLastEventType) {
- case TYPE_ADD:
- mWrapped.onInserted(mLastEventPosition, mLastEventCount);
- break;
- case TYPE_REMOVE:
- mWrapped.onRemoved(mLastEventPosition, mLastEventCount);
- break;
- case TYPE_CHANGE:
- mWrapped.onChanged(mLastEventPosition, mLastEventCount, mLastEventPayload);
- break;
- }
- mLastEventPayload = null;
- mLastEventType = TYPE_NONE;
- }
-
- @Override
- public void onInserted(int position, int count) {
- if (mLastEventType == TYPE_ADD && position >= mLastEventPosition
- && position <= mLastEventPosition + mLastEventCount) {
- mLastEventCount += count;
- mLastEventPosition = Math.min(position, mLastEventPosition);
- return;
- }
- dispatchLastEvent();
- mLastEventPosition = position;
- mLastEventCount = count;
- mLastEventType = TYPE_ADD;
- }
-
- @Override
- public void onRemoved(int position, int count) {
- if (mLastEventType == TYPE_REMOVE && mLastEventPosition >= position &&
- mLastEventPosition <= position + count) {
- mLastEventCount += count;
- mLastEventPosition = position;
- return;
- }
- dispatchLastEvent();
- mLastEventPosition = position;
- mLastEventCount = count;
- mLastEventType = TYPE_REMOVE;
- }
-
- @Override
- public void onMoved(int fromPosition, int toPosition) {
- dispatchLastEvent(); // moves are not merged
- mWrapped.onMoved(fromPosition, toPosition);
- }
-
- @Override
- @SuppressLint("UnknownNullness") // b/240775049: Cannot annotate properly
- public void onChanged(int position, int count, Object payload) {
- if (mLastEventType == TYPE_CHANGE &&
- !(position > mLastEventPosition + mLastEventCount
- || position + count < mLastEventPosition || mLastEventPayload != payload)) {
- // take potential overlap into account
- int previousEnd = mLastEventPosition + mLastEventCount;
- mLastEventPosition = Math.min(position, mLastEventPosition);
- mLastEventCount = Math.max(previousEnd, position + count) - mLastEventPosition;
- return;
- }
- dispatchLastEvent();
- mLastEventPosition = position;
- mLastEventCount = count;
- mLastEventPayload = payload;
- mLastEventType = TYPE_CHANGE;
- }
-}
diff --git a/app/src/main/java/androidx/recyclerview/widget/ChildHelper.java b/app/src/main/java/androidx/recyclerview/widget/ChildHelper.java
deleted file mode 100644
index 1541ba8fd3..0000000000
--- a/app/src/main/java/androidx/recyclerview/widget/ChildHelper.java
+++ /dev/null
@@ -1,601 +0,0 @@
-/*
- * Copyright 2018 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package androidx.recyclerview.widget;
-
-import android.util.Log;
-import android.view.View;
-import android.view.ViewGroup;
-
-import java.util.ArrayList;
-import java.util.List;
-
-/**
- * Helper class to manage children.
- *
- * It wraps a RecyclerView and adds ability to hide some children. There are two sets of methods
- * provided by this class. Regular methods are the ones that replicate ViewGroup methods
- * like getChildAt, getChildCount etc. These methods ignore hidden children.
- *
- * When RecyclerView needs direct access to the view group children, it can call unfiltered
- * methods like get getUnfilteredChildCount or getUnfilteredChildAt.
- */
-class ChildHelper {
-
- private static final boolean DEBUG = false;
-
- private static final String TAG = "ChildrenHelper";
-
- /** Not in call to removeView/removeViewAt/removeViewIfHidden. */
- private static final int REMOVE_STATUS_NONE = 0;
-
- /** Within a call to removeView/removeViewAt. */
- private static final int REMOVE_STATUS_IN_REMOVE = 1;
-
- /** Within a call to removeViewIfHidden. */
- private static final int REMOVE_STATUS_IN_REMOVE_IF_HIDDEN = 2;
-
- final Callback mCallback;
-
- final Bucket mBucket;
-
- final List mHiddenViews;
-
- /**
- * One of REMOVE_STATUS_NONE, REMOVE_STATUS_IN_REMOVE, REMOVE_STATUS_IN_REMOVE_IF_HIDDEN.
- * removeView and removeViewIfHidden may call each other:
- * 1. removeView triggers removeViewIfHidden: this happens when removeView stops the item
- * animation. removeViewIfHidden should do nothing.
- * 2. removeView triggers removeView: this should not happen.
- * 3. removeViewIfHidden triggers removeViewIfHidden: this should not happen, since the
- * animation was stopped before the first removeViewIfHidden, it won't trigger another
- * removeViewIfHidden.
- * 4. removeViewIfHidden triggers removeView: this should not happen.
- */
- private int mRemoveStatus = REMOVE_STATUS_NONE;
- /** The view to remove in REMOVE_STATUS_IN_REMOVE. */
- private View mViewInRemoveView;
-
- ChildHelper(Callback callback) {
- mCallback = callback;
- mBucket = new Bucket();
- mHiddenViews = new ArrayList();
- }
-
- /**
- * Marks a child view as hidden
- *
- * @param child View to hide.
- */
- private void hideViewInternal(View child) {
- mHiddenViews.add(child);
- mCallback.onEnteredHiddenState(child);
- }
-
- /**
- * Unmarks a child view as hidden.
- *
- * @param child View to hide.
- */
- private boolean unhideViewInternal(View child) {
- if (mHiddenViews.remove(child)) {
- mCallback.onLeftHiddenState(child);
- return true;
- } else {
- return false;
- }
- }
-
- /**
- * Adds a view to the ViewGroup
- *
- * @param child View to add.
- * @param hidden If set to true, this item will be invisible from regular methods.
- */
- void addView(View child, boolean hidden) {
- addView(child, -1, hidden);
- }
-
- /**
- * Add a view to the ViewGroup at an index
- *
- * @param child View to add.
- * @param index Index of the child from the regular perspective (excluding hidden views).
- * ChildHelper offsets this index to actual ViewGroup index.
- * @param hidden If set to true, this item will be invisible from regular methods.
- */
- void addView(View child, int index, boolean hidden) {
- final int offset;
- if (index < 0) {
- offset = mCallback.getChildCount();
- } else {
- offset = getOffset(index);
- }
- mBucket.insert(offset, hidden);
- if (hidden) {
- hideViewInternal(child);
- }
- mCallback.addView(child, offset);
- if (DEBUG) {
- Log.d(TAG, "addViewAt " + index + ",h:" + hidden + ", " + this);
- }
- }
-
- private int getOffset(int index) {
- if (index < 0) {
- return -1; //anything below 0 won't work as diff will be undefined.
- }
- final int limit = mCallback.getChildCount();
- int offset = index;
- while (offset < limit) {
- final int removedBefore = mBucket.countOnesBefore(offset);
- final int diff = index - (offset - removedBefore);
- if (diff == 0) {
- while (mBucket.get(offset)) { // ensure this offset is not hidden
- offset++;
- }
- return offset;
- } else {
- offset += diff;
- }
- }
- return -1;
- }
-
- /**
- * Removes the provided View from underlying RecyclerView.
- *
- * @param view The view to remove.
- */
- void removeView(View view) {
- if (mRemoveStatus == REMOVE_STATUS_IN_REMOVE) {
- throw new IllegalStateException("Cannot call removeView(At) within removeView(At)");
- } else if (mRemoveStatus == REMOVE_STATUS_IN_REMOVE_IF_HIDDEN) {
- throw new IllegalStateException("Cannot call removeView(At) within removeViewIfHidden");
- }
- try {
- mRemoveStatus = REMOVE_STATUS_IN_REMOVE;
- mViewInRemoveView = view;
- int index = mCallback.indexOfChild(view);
- if (index < 0) {
- return;
- }
- if (mBucket.remove(index)) {
- unhideViewInternal(view);
- }
- mCallback.removeViewAt(index);
- if (DEBUG) {
- Log.d(TAG, "remove View off:" + index + "," + this);
- }
- } finally {
- mRemoveStatus = REMOVE_STATUS_NONE;
- mViewInRemoveView = null;
- }
- }
-
- /**
- * Removes the view at the provided index from RecyclerView.
- *
- * @param index Index of the child from the regular perspective (excluding hidden views).
- * ChildHelper offsets this index to actual ViewGroup index.
- */
- void removeViewAt(int index) {
- if (mRemoveStatus == REMOVE_STATUS_IN_REMOVE) {
- throw new IllegalStateException("Cannot call removeView(At) within removeView(At)");
- } else if (mRemoveStatus == REMOVE_STATUS_IN_REMOVE_IF_HIDDEN) {
- throw new IllegalStateException("Cannot call removeView(At) within removeViewIfHidden");
- }
- try {
- final int offset = getOffset(index);
- final View view = mCallback.getChildAt(offset);
- if (view == null) {
- return;
- }
- mRemoveStatus = REMOVE_STATUS_IN_REMOVE;
- mViewInRemoveView = view;
- if (mBucket.remove(offset)) {
- unhideViewInternal(view);
- }
- mCallback.removeViewAt(offset);
- if (DEBUG) {
- Log.d(TAG, "removeViewAt " + index + ", off:" + offset + ", " + this);
- }
- } finally {
- mRemoveStatus = REMOVE_STATUS_NONE;
- mViewInRemoveView = null;
- }
- }
-
- /**
- * Returns the child at provided index.
- *
- * @param index Index of the child to return in regular perspective.
- */
- View getChildAt(int index) {
- final int offset = getOffset(index);
- return mCallback.getChildAt(offset);
- }
-
- /**
- * Removes all views from the ViewGroup including the hidden ones.
- */
- void removeAllViewsUnfiltered() {
- mBucket.reset();
- for (int i = mHiddenViews.size() - 1; i >= 0; i--) {
- mCallback.onLeftHiddenState(mHiddenViews.get(i));
- mHiddenViews.remove(i);
- }
- mCallback.removeAllViews();
- if (DEBUG) {
- Log.d(TAG, "removeAllViewsUnfiltered");
- }
- }
-
- /**
- * This can be used to find a disappearing view by position.
- *
- * @param position The adapter position of the item.
- * @return A hidden view with a valid ViewHolder that matches the position.
- */
- View findHiddenNonRemovedView(int position) {
- final int count = mHiddenViews.size();
- for (int i = 0; i < count; i++) {
- final View view = mHiddenViews.get(i);
- RecyclerView.ViewHolder holder = mCallback.getChildViewHolder(view);
- if (holder.getLayoutPosition() == position
- && !holder.isInvalid()
- && !holder.isRemoved()) {
- return view;
- }
- }
- return null;
- }
-
- /**
- * Attaches the provided view to the underlying ViewGroup.
- *
- * @param child Child to attach.
- * @param index Index of the child to attach in regular perspective.
- * @param layoutParams LayoutParams for the child.
- * @param hidden If set to true, this item will be invisible to the regular methods.
- */
- void attachViewToParent(View child, int index, ViewGroup.LayoutParams layoutParams,
- boolean hidden) {
- final int offset;
- if (index < 0) {
- offset = mCallback.getChildCount();
- } else {
- offset = getOffset(index);
- }
- mBucket.insert(offset, hidden);
- if (hidden) {
- hideViewInternal(child);
- }
- mCallback.attachViewToParent(child, offset, layoutParams);
- if (DEBUG) {
- Log.d(TAG, "attach view to parent index:" + index + ",off:" + offset + ","
- + "h:" + hidden + ", " + this);
- }
- }
-
- /**
- * Returns the number of children that are not hidden.
- *
- * @return Number of children that are not hidden.
- * @see #getChildAt(int)
- */
- int getChildCount() {
- return mCallback.getChildCount() - mHiddenViews.size();
- }
-
- /**
- * Returns the total number of children.
- *
- * @return The total number of children including the hidden views.
- * @see #getUnfilteredChildAt(int)
- */
- int getUnfilteredChildCount() {
- return mCallback.getChildCount();
- }
-
- /**
- * Returns a child by ViewGroup offset. ChildHelper won't offset this index.
- *
- * @param index ViewGroup index of the child to return.
- * @return The view in the provided index.
- */
- View getUnfilteredChildAt(int index) {
- return mCallback.getChildAt(index);
- }
-
- /**
- * Detaches the view at the provided index.
- *
- * @param index Index of the child to return in regular perspective.
- */
- void detachViewFromParent(int index) {
- final int offset = getOffset(index);
- mBucket.remove(offset);
- mCallback.detachViewFromParent(offset);
- if (DEBUG) {
- Log.d(TAG, "detach view from parent " + index + ", off:" + offset);
- }
- }
-
- /**
- * Returns the index of the child in regular perspective.
- *
- * @param child The child whose index will be returned.
- * @return The regular perspective index of the child or -1 if it does not exists.
- */
- int indexOfChild(View child) {
- final int index = mCallback.indexOfChild(child);
- if (index == -1) {
- return -1;
- }
- if (mBucket.get(index)) {
- if (DEBUG) {
- throw new IllegalArgumentException("cannot get index of a hidden child");
- } else {
- return -1;
- }
- }
- // reverse the index
- return index - mBucket.countOnesBefore(index);
- }
-
- /**
- * Returns whether a View is visible to LayoutManager or not.
- *
- * @param view The child view to check. Should be a child of the Callback.
- * @return True if the View is not visible to LayoutManager
- */
- boolean isHidden(View view) {
- return mHiddenViews.contains(view);
- }
-
- /**
- * Marks a child view as hidden.
- *
- * @param view The view to hide.
- */
- void hide(View view) {
- final int offset = mCallback.indexOfChild(view);
- if (offset < 0) {
- throw new IllegalArgumentException("view is not a child, cannot hide " + view);
- }
- if (DEBUG && mBucket.get(offset)) {
- throw new RuntimeException("trying to hide same view twice, how come ? " + view);
- }
- mBucket.set(offset);
- hideViewInternal(view);
- if (DEBUG) {
- Log.d(TAG, "hiding child " + view + " at offset " + offset + ", " + this);
- }
- }
-
- /**
- * Moves a child view from hidden list to regular list.
- * Calling this method should probably be followed by a detach, otherwise, it will suddenly
- * show up in LayoutManager's children list.
- *
- * @param view The hidden View to unhide
- */
- void unhide(View view) {
- final int offset = mCallback.indexOfChild(view);
- if (offset < 0) {
- throw new IllegalArgumentException("view is not a child, cannot hide " + view);
- }
- if (!mBucket.get(offset)) {
- throw new RuntimeException("trying to unhide a view that was not hidden" + view);
- }
- mBucket.clear(offset);
- unhideViewInternal(view);
- }
-
- @Override
- public String toString() {
- return mBucket.toString() + ", hidden list:" + mHiddenViews.size();
- }
-
- /**
- * Removes a view from the ViewGroup if it is hidden.
- *
- * @param view The view to remove.
- * @return True if the View is found and it is hidden. False otherwise.
- */
- boolean removeViewIfHidden(View view) {
- if (mRemoveStatus == REMOVE_STATUS_IN_REMOVE) {
- if (mViewInRemoveView != view) {
- throw new IllegalStateException("Cannot call removeViewIfHidden within removeView"
- + "(At) for a different view");
- }
- // removeView ends the ItemAnimation and triggers removeViewIfHidden
- return false;
- } else if (mRemoveStatus == REMOVE_STATUS_IN_REMOVE_IF_HIDDEN) {
- throw new IllegalStateException("Cannot call removeViewIfHidden within"
- + " removeViewIfHidden");
- }
- try {
- mRemoveStatus = REMOVE_STATUS_IN_REMOVE_IF_HIDDEN;
- final int index = mCallback.indexOfChild(view);
- if (index == -1) {
- if (unhideViewInternal(view) && DEBUG) {
- throw new IllegalStateException("view is in hidden list but not in view group");
- }
- return true;
- }
- if (mBucket.get(index)) {
- mBucket.remove(index);
- if (!unhideViewInternal(view) && DEBUG) {
- throw new IllegalStateException(
- "removed a hidden view but it is not in hidden views list");
- }
- mCallback.removeViewAt(index);
- return true;
- }
- return false;
- } finally {
- mRemoveStatus = REMOVE_STATUS_NONE;
- }
- }
-
- /**
- * Bitset implementation that provides methods to offset indices.
- */
- static class Bucket {
-
- static final int BITS_PER_WORD = Long.SIZE;
-
- static final long LAST_BIT = 1L << (Long.SIZE - 1);
-
- long mData = 0;
-
- Bucket mNext;
-
- void set(int index) {
- if (index >= BITS_PER_WORD) {
- ensureNext();
- mNext.set(index - BITS_PER_WORD);
- } else {
- mData |= 1L << index;
- }
- }
-
- private void ensureNext() {
- if (mNext == null) {
- mNext = new Bucket();
- }
- }
-
- void clear(int index) {
- if (index >= BITS_PER_WORD) {
- if (mNext != null) {
- mNext.clear(index - BITS_PER_WORD);
- }
- } else {
- mData &= ~(1L << index);
- }
-
- }
-
- boolean get(int index) {
- if (index >= BITS_PER_WORD) {
- ensureNext();
- return mNext.get(index - BITS_PER_WORD);
- } else {
- return (mData & (1L << index)) != 0;
- }
- }
-
- void reset() {
- mData = 0;
- if (mNext != null) {
- mNext.reset();
- }
- }
-
- void insert(int index, boolean value) {
- if (index >= BITS_PER_WORD) {
- ensureNext();
- mNext.insert(index - BITS_PER_WORD, value);
- } else {
- final boolean lastBit = (mData & LAST_BIT) != 0;
- long mask = (1L << index) - 1;
- final long before = mData & mask;
- final long after = (mData & ~mask) << 1;
- mData = before | after;
- if (value) {
- set(index);
- } else {
- clear(index);
- }
- if (lastBit || mNext != null) {
- ensureNext();
- mNext.insert(0, lastBit);
- }
- }
- }
-
- boolean remove(int index) {
- if (index >= BITS_PER_WORD) {
- ensureNext();
- return mNext.remove(index - BITS_PER_WORD);
- } else {
- long mask = (1L << index);
- final boolean value = (mData & mask) != 0;
- mData &= ~mask;
- mask = mask - 1;
- final long before = mData & mask;
- // cannot use >> because it adds one.
- final long after = Long.rotateRight(mData & ~mask, 1);
- mData = before | after;
- if (mNext != null) {
- if (mNext.get(0)) {
- set(BITS_PER_WORD - 1);
- }
- mNext.remove(0);
- }
- return value;
- }
- }
-
- int countOnesBefore(int index) {
- if (mNext == null) {
- if (index >= BITS_PER_WORD) {
- return Long.bitCount(mData);
- }
- return Long.bitCount(mData & ((1L << index) - 1));
- }
- if (index < BITS_PER_WORD) {
- return Long.bitCount(mData & ((1L << index) - 1));
- } else {
- return mNext.countOnesBefore(index - BITS_PER_WORD) + Long.bitCount(mData);
- }
- }
-
- @Override
- public String toString() {
- return mNext == null ? Long.toBinaryString(mData)
- : mNext.toString() + "xx" + Long.toBinaryString(mData);
- }
- }
-
- interface Callback {
-
- int getChildCount();
-
- void addView(View child, int index);
-
- int indexOfChild(View view);
-
- void removeViewAt(int index);
-
- View getChildAt(int offset);
-
- void removeAllViews();
-
- RecyclerView.ViewHolder getChildViewHolder(View view);
-
- void attachViewToParent(View child, int index, ViewGroup.LayoutParams layoutParams);
-
- void detachViewFromParent(int offset);
-
- void onEnteredHiddenState(View child);
-
- void onLeftHiddenState(View child);
- }
-}
diff --git a/app/src/main/java/androidx/recyclerview/widget/ConcatAdapter.java b/app/src/main/java/androidx/recyclerview/widget/ConcatAdapter.java
deleted file mode 100644
index 45b719fe71..0000000000
--- a/app/src/main/java/androidx/recyclerview/widget/ConcatAdapter.java
+++ /dev/null
@@ -1,481 +0,0 @@
-/*
- * Copyright 2020 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package androidx.recyclerview.widget;
-
-import static androidx.recyclerview.widget.ConcatAdapter.Config.StableIdMode.NO_STABLE_IDS;
-
-import android.util.Pair;
-import android.view.ViewGroup;
-
-import androidx.annotation.NonNull;
-import androidx.recyclerview.widget.RecyclerView.Adapter;
-import androidx.recyclerview.widget.RecyclerView.ViewHolder;
-
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
-
-/**
- * An {@link Adapter} implementation that presents the contents of multiple adapters in sequence.
- *
- *
- * MyAdapter adapter1 = ...;
- * AnotherAdapter adapter2 = ...;
- * ConcatAdapter concatenated = new ConcatAdapter(adapter1, adapter2);
- * recyclerView.setAdapter(concatenated);
- *
- *
- * By default, {@link ConcatAdapter} isolates view types of nested adapters from each other such
- * that
- * it will change the view type before reporting it back to the {@link RecyclerView} to avoid any
- * conflicts between the view types of added adapters. This also means each added adapter will have
- * its own isolated pool of {@link ViewHolder}s, with no re-use in between added adapters.
- *
- * If your {@link Adapter}s share the same view types, and can support sharing {@link ViewHolder}
- * s between added adapters, provide an instance of {@link Config} where you set
- * {@link Config#isolateViewTypes} to {@code false}. A common usage pattern for this is to return
- * the {@code R.layout.} from the {@link Adapter#getItemViewType(int)} method.
- *
- * When an added adapter calls one of the {@code notify} methods, {@link ConcatAdapter} properly
- * offsets values before reporting it back to the {@link RecyclerView}.
- * If an adapter calls {@link Adapter#notifyDataSetChanged()}, {@link ConcatAdapter} also calls
- * {@link Adapter#notifyDataSetChanged()} as calling
- * {@link Adapter#notifyItemRangeChanged(int, int)} will confuse the {@link RecyclerView}.
- * You are highly encouraged to to use {@link SortedList} or {@link ListAdapter} to avoid
- * calling {@link Adapter#notifyDataSetChanged()}.
- *
- * Whether {@link ConcatAdapter} should support stable ids is defined in the {@link Config}
- * object. Calling {@link Adapter#setHasStableIds(boolean)} has no effect. See documentation
- * for {@link Config.StableIdMode} for details on how to configure {@link ConcatAdapter} to use
- * stable ids. By default, it will not use stable ids and sub adapter stable ids will be ignored.
- * Similar to the case above, you are highly encouraged to use {@link ListAdapter}, which will
- * automatically calculate the changes in the data set for you so you won't need stable ids.
- *
- * It is common to find the adapter position of a {@link ViewHolder} to handle user action on the
- * {@link ViewHolder}. For those cases, instead of calling {@link ViewHolder#getAdapterPosition()},
- * use {@link ViewHolder#getBindingAdapterPosition()}. If your adapters share {@link ViewHolder}s,
- * you can use the {@link ViewHolder#getBindingAdapter()} method to find the adapter which last
- * bound that {@link ViewHolder}.
- */
-@SuppressWarnings("unchecked")
-public final class ConcatAdapter extends Adapter {
- static final String TAG = "ConcatAdapter";
- /**
- * Bulk of the logic is in the controller to keep this class isolated to the public API.
- */
- private final ConcatAdapterController mController;
-
- /**
- * Creates a ConcatAdapter with {@link Config#DEFAULT} and the given adapters in the given
- * order.
- *
- * @param adapters The list of adapters to add
- */
- @SafeVarargs
- public ConcatAdapter(@NonNull Adapter... adapters) {
- this(Config.DEFAULT, adapters);
- }
-
- /**
- * Creates a ConcatAdapter with the given config and the given adapters in the given order.
- *
- * @param config The configuration for this ConcatAdapter
- * @param adapters The list of adapters to add
- * @see Config.Builder
- */
- @SafeVarargs
- public ConcatAdapter(
- @NonNull Config config,
- @NonNull Adapter... adapters) {
- this(config, Arrays.asList(adapters));
- }
-
- /**
- * Creates a ConcatAdapter with {@link Config#DEFAULT} and the given adapters in the given
- * order.
- *
- * @param adapters The list of adapters to add
- */
- public ConcatAdapter(@NonNull List> adapters) {
- this(Config.DEFAULT, adapters);
- }
-
- /**
- * Creates a ConcatAdapter with the given config and the given adapters in the given order.
- *
- * @param config The configuration for this ConcatAdapter
- * @param adapters The list of adapters to add
- * @see Config.Builder
- */
- public ConcatAdapter(
- @NonNull Config config,
- @NonNull List> adapters) {
- mController = new ConcatAdapterController(this, config);
- for (Adapter adapter : adapters) {
- addAdapter(adapter);
- }
- // go through super as we override it to be no-op
- super.setHasStableIds(mController.hasStableIds());
- }
-
- /**
- * Appends the given adapter to the existing list of adapters and notifies the observers of
- * this {@link ConcatAdapter}.
- *
- * @param adapter The new adapter to add
- * @return {@code true} if the adapter is successfully added because it did not already exist,
- * {@code false} otherwise.
- * @see #addAdapter(int, Adapter)
- * @see #removeAdapter(Adapter)
- */
- public boolean addAdapter(@NonNull Adapter adapter) {
- return mController.addAdapter((Adapter) adapter);
- }
-
- /**
- * Adds the given adapter to the given index among other adapters that are already added.
- *
- * @param index The index into which to insert the adapter. ConcatAdapter will throw an
- * {@link IndexOutOfBoundsException} if the index is not between 0 and current
- * adapter count (inclusive).
- * @param adapter The new adapter to add to the adapters list.
- * @return {@code true} if the adapter is successfully added because it did not already exist,
- * {@code false} otherwise.
- * @see #addAdapter(Adapter)
- * @see #removeAdapter(Adapter)
- */
- public boolean addAdapter(int index, @NonNull Adapter adapter) {
- return mController.addAdapter(index, (Adapter) adapter);
- }
-
- /**
- * Removes the given adapter from the adapters list if it exists
- *
- * @param adapter The adapter to remove
- * @return {@code true} if the adapter was previously added to this {@code ConcatAdapter} and
- * now removed or {@code false} if it couldn't be found.
- */
- public boolean removeAdapter(@NonNull Adapter adapter) {
- return mController.removeAdapter((Adapter) adapter);
- }
-
- @Override
- public int getItemViewType(int position) {
- return mController.getItemViewType(position);
- }
-
- @NonNull
- @Override
- public ViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
- return mController.onCreateViewHolder(parent, viewType);
- }
-
- @Override
- public void onBindViewHolder(@NonNull ViewHolder holder, int position) {
- mController.onBindViewHolder(holder, position);
- }
-
- /**
- * Calling this method is an error and will result in an {@link UnsupportedOperationException}.
- * You should use the {@link Config} object passed into the ConcatAdapter to configure this
- * behavior.
- *
- * @param hasStableIds Whether items in data set have unique identifiers or not.
- */
- @Override
- public void setHasStableIds(boolean hasStableIds) {
- throw new UnsupportedOperationException(
- "Calling setHasStableIds is not allowed on the ConcatAdapter. "
- + "Use the Config object passed in the constructor to control this "
- + "behavior");
- }
-
- /**
- * Calling this method is an error and will result in an {@link UnsupportedOperationException}.
- *
- * ConcatAdapter infers this value from added {@link Adapter}s.
- *
- * @param strategy The saved state restoration strategy for this Adapter such that
- * {@link ConcatAdapter} will allow state restoration only if all added
- * adapters allow it or
- * there are no adapters.
- */
- @Override
- public void setStateRestorationPolicy(@NonNull StateRestorationPolicy strategy) {
- // do nothing
- throw new UnsupportedOperationException(
- "Calling setStateRestorationPolicy is not allowed on the ConcatAdapter."
- + " This value is inferred from added adapters");
- }
-
- @Override
- public long getItemId(int position) {
- return mController.getItemId(position);
- }
-
- /**
- * Internal method called by the ConcatAdapterController.
- */
- void internalSetStateRestorationPolicy(@NonNull StateRestorationPolicy strategy) {
- super.setStateRestorationPolicy(strategy);
- }
-
- @Override
- public int getItemCount() {
- return mController.getTotalCount();
- }
-
- @Override
- public boolean onFailedToRecycleView(@NonNull ViewHolder holder) {
- return mController.onFailedToRecycleView(holder);
- }
-
- @Override
- public void onViewAttachedToWindow(@NonNull ViewHolder holder) {
- mController.onViewAttachedToWindow(holder);
- }
-
- @Override
- public void onViewDetachedFromWindow(@NonNull ViewHolder holder) {
- mController.onViewDetachedFromWindow(holder);
- }
-
- @Override
- public void onViewRecycled(@NonNull ViewHolder holder) {
- mController.onViewRecycled(holder);
- }
-
- @Override
- public void onAttachedToRecyclerView(@NonNull RecyclerView recyclerView) {
- mController.onAttachedToRecyclerView(recyclerView);
- }
-
- @Override
- public void onDetachedFromRecyclerView(@NonNull RecyclerView recyclerView) {
- mController.onDetachedFromRecyclerView(recyclerView);
- }
-
- /**
- * Returns an unmodifiable copy of the list of adapters in this {@link ConcatAdapter}.
- * Note that this is a copy hence future changes in the ConcatAdapter are not reflected in
- * this list.
- *
- * @return A copy of the list of adapters in this ConcatAdapter.
- */
- @NonNull
- public List> getAdapters() {
- return Collections.unmodifiableList(mController.getCopyOfAdapters());
- }
-
- /**
- * Returns the position of the given {@link ViewHolder} in the given {@link Adapter}.
- *
- * If the given {@link Adapter} is not part of this {@link ConcatAdapter},
- * {@link RecyclerView#NO_POSITION} is returned.
- *
- * @param adapter The adapter which is a sub adapter of this ConcatAdapter or itself.
- * @param viewHolder The view holder whose local position in the given adapter will be
- * returned.
- * @param localPosition The position of the given {@link ViewHolder} in this {@link Adapter}.
- * @return The local position of the given {@link ViewHolder} in the given {@link Adapter} or
- * {@link RecyclerView#NO_POSITION} if the {@link ViewHolder} is not bound to an item or the
- * given {@link Adapter} is not part of this ConcatAdapter.
- */
- @Override
- public int findRelativeAdapterPositionIn(
- @NonNull Adapter adapter,
- @NonNull ViewHolder viewHolder,
- int localPosition) {
- return mController.getLocalAdapterPosition(adapter, viewHolder, localPosition);
- }
-
-
- /**
- * Retrieve the adapter and local position for a given position in this {@code ConcatAdapter}.
- *
- * This allows for retrieving wrapped adapter information in situations where you don't have a
- * {@link ViewHolder}, such as within a
- * {@link androidx.recyclerview.widget.GridLayoutManager.SpanSizeLookup} in which you want to
- * look up information from the source adapter.
- *
- * @param globalPosition The position in this {@code ConcatAdapter}.
- * @return a Pair with the first element set to the wrapped {@code Adapter} containing that
- * position and the second element set to the local position in the wrapped adapter
- * @throws IllegalArgumentException if the specified {@code globalPosition} does not
- * correspond to a valid element of this adapter. That is, if {@code globalPosition} is less
- * than 0 or greater than the total number of items in the {@code ConcatAdapter}
- */
- @NonNull
- public Pair, Integer> getWrappedAdapterAndPosition(int
- globalPosition) {
- return mController.getWrappedAdapterAndPosition(globalPosition);
- }
-
- /**
- * The configuration object for a {@link ConcatAdapter}.
- */
- public static final class Config {
- /**
- * If {@code false}, {@link ConcatAdapter} assumes all assigned adapters share a global
- * view type pool such that they use the same view types to refer to the same
- * {@link ViewHolder}s.
- *
- * Setting this to {@code false} will allow nested adapters to share {@link ViewHolder}s but
- * it also means these adapters should not have conflicting view types
- * ({@link Adapter#getItemViewType(int)}) such that two different adapters return the same
- * view type for different {@link ViewHolder}s.
- *
- * By default, it is set to {@code true} which means {@link ConcatAdapter} will isolate
- * view types across adapters, preventing them from using the same {@link ViewHolder}s.
- */
- public final boolean isolateViewTypes;
-
- /**
- * Defines whether the {@link ConcatAdapter} should support stable ids or not
- * ({@link Adapter#hasStableIds()}.
- *
- * There are 3 possible options:
- *
- * {@link StableIdMode#NO_STABLE_IDS}: In this mode, {@link ConcatAdapter} ignores the
- * stable
- * ids reported by sub adapters. This is the default mode.
- *
- * {@link StableIdMode#ISOLATED_STABLE_IDS}: In this mode, {@link ConcatAdapter} will return
- * {@code true} from {@link ConcatAdapter#hasStableIds()} and will require all added
- * {@link Adapter}s to have stable ids. As two different adapters may return same stable ids
- * because they are unaware of each-other, {@link ConcatAdapter} will isolate each
- * {@link Adapter}'s id pool from each other such that it will overwrite the reported stable
- * id before reporting back to the {@link RecyclerView}. In this mode, the value returned
- * from {@link ViewHolder#getItemId()} might differ from the value returned from
- * {@link Adapter#getItemId(int)}.
- *
- * {@link StableIdMode#SHARED_STABLE_IDS}: In this mode, {@link ConcatAdapter} will return
- * {@code true} from {@link ConcatAdapter#hasStableIds()} and will require all added
- * {@link Adapter}s to have stable ids. Unlike {@link StableIdMode#ISOLATED_STABLE_IDS},
- * {@link ConcatAdapter} will not override the returned item ids. In this mode,
- * child {@link Adapter}s must be aware of each-other and never return the same id unless
- * an item is moved between {@link Adapter}s.
- *
- * Default value is {@link StableIdMode#NO_STABLE_IDS}.
- */
- @NonNull
- public final StableIdMode stableIdMode;
-
-
- /**
- * Default configuration for {@link ConcatAdapter} where {@link Config#isolateViewTypes}
- * is set to {@code true} and {@link Config#stableIdMode} is set to
- * {@link StableIdMode#NO_STABLE_IDS}.
- */
- @NonNull
- public static final Config DEFAULT = new Config(true, NO_STABLE_IDS);
-
- Config(boolean isolateViewTypes, @NonNull StableIdMode stableIdMode) {
- this.isolateViewTypes = isolateViewTypes;
- this.stableIdMode = stableIdMode;
- }
-
- /**
- * Defines how {@link ConcatAdapter} handle stable ids ({@link Adapter#hasStableIds()}).
- */
- public enum StableIdMode {
- /**
- * In this mode, {@link ConcatAdapter} ignores the stable
- * ids reported by sub adapters. This is the default mode.
- * Adding an {@link Adapter} with stable ids will result in a warning as it will be
- * ignored.
- */
- NO_STABLE_IDS,
- /**
- * In this mode, {@link ConcatAdapter} will return {@code true} from
- * {@link ConcatAdapter#hasStableIds()} and will require all added
- * {@link Adapter}s to have stable ids. As two different adapters may return
- * same stable ids because they are unaware of each-other, {@link ConcatAdapter} will
- * isolate each {@link Adapter}'s id pool from each other such that it will overwrite
- * the reported stable id before reporting back to the {@link RecyclerView}. In this
- * mode, the value returned from {@link ViewHolder#getItemId()} might differ from the
- * value returned from {@link Adapter#getItemId(int)}.
- *
- * Adding an adapter without stable ids will result in an
- * {@link IllegalArgumentException}.
- */
- ISOLATED_STABLE_IDS,
- /**
- * In this mode, {@link ConcatAdapter} will return {@code true} from
- * {@link ConcatAdapter#hasStableIds()} and will require all added
- * {@link Adapter}s to have stable ids. Unlike {@link StableIdMode#ISOLATED_STABLE_IDS},
- * {@link ConcatAdapter} will not override the returned item ids. In this mode,
- * child {@link Adapter}s must be aware of each-other and never return the same id
- * unless and item is moved between {@link Adapter}s.
- * Adding an adapter without stable ids will result in an
- * {@link IllegalArgumentException}.
- */
- SHARED_STABLE_IDS
- }
-
- /**
- * The builder for {@link Config} class.
- */
- public static final class Builder {
- private boolean mIsolateViewTypes = DEFAULT.isolateViewTypes;
- private StableIdMode mStableIdMode = DEFAULT.stableIdMode;
-
- /**
- * Sets whether {@link ConcatAdapter} should isolate view types of nested adapters from
- * each other.
- *
- * @param isolateViewTypes {@code true} if {@link ConcatAdapter} should override view
- * types of nested adapters to avoid view type
- * conflicts, {@code false} otherwise.
- * Defaults to {@link Config#DEFAULT}'s
- * {@link Config#isolateViewTypes} value ({@code true}).
- * @return this
- * @see Config#isolateViewTypes
- */
- @NonNull
- public Builder setIsolateViewTypes(boolean isolateViewTypes) {
- mIsolateViewTypes = isolateViewTypes;
- return this;
- }
-
- /**
- * Sets how the {@link ConcatAdapter} should handle stable ids
- * ({@link Adapter#hasStableIds()}). See documentation in {@link Config#stableIdMode}
- * for details.
- *
- * @param stableIdMode The stable id mode for the {@link ConcatAdapter}. Defaults to
- * {@link Config#DEFAULT}'s {@link Config#stableIdMode} value
- * ({@link StableIdMode#NO_STABLE_IDS}).
- * @return this
- * @see Config#stableIdMode
- */
- @NonNull
- public Builder setStableIdMode(@NonNull StableIdMode stableIdMode) {
- mStableIdMode = stableIdMode;
- return this;
- }
-
- /**
- * @return A new instance of {@link Config} with the given parameters.
- */
- @NonNull
- public Config build() {
- return new Config(mIsolateViewTypes, mStableIdMode);
- }
- }
- }
-}
diff --git a/app/src/main/java/androidx/recyclerview/widget/ConcatAdapterController.java b/app/src/main/java/androidx/recyclerview/widget/ConcatAdapterController.java
deleted file mode 100644
index d31540c649..0000000000
--- a/app/src/main/java/androidx/recyclerview/widget/ConcatAdapterController.java
+++ /dev/null
@@ -1,528 +0,0 @@
-/*
- * Copyright 2020 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package androidx.recyclerview.widget;
-
-import static androidx.recyclerview.widget.ConcatAdapter.Config.StableIdMode.ISOLATED_STABLE_IDS;
-import static androidx.recyclerview.widget.ConcatAdapter.Config.StableIdMode.NO_STABLE_IDS;
-import static androidx.recyclerview.widget.ConcatAdapter.Config.StableIdMode.SHARED_STABLE_IDS;
-import static androidx.recyclerview.widget.RecyclerView.Adapter.StateRestorationPolicy.ALLOW;
-import static androidx.recyclerview.widget.RecyclerView.Adapter.StateRestorationPolicy.PREVENT;
-import static androidx.recyclerview.widget.RecyclerView.Adapter.StateRestorationPolicy.PREVENT_WHEN_EMPTY;
-import static androidx.recyclerview.widget.RecyclerView.NO_POSITION;
-
-import android.util.Log;
-import android.util.Pair;
-import android.view.ViewGroup;
-
-import androidx.annotation.NonNull;
-import androidx.annotation.Nullable;
-import androidx.core.util.Preconditions;
-import androidx.recyclerview.widget.RecyclerView.Adapter;
-import androidx.recyclerview.widget.RecyclerView.Adapter.StateRestorationPolicy;
-import androidx.recyclerview.widget.RecyclerView.ViewHolder;
-
-import java.lang.ref.WeakReference;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.IdentityHashMap;
-import java.util.List;
-
-/**
- * All logic for the {@link ConcatAdapter} is here so that we can clearly see a separation
- * between an adapter implementation and merging logic.
- */
-class ConcatAdapterController implements NestedAdapterWrapper.Callback {
- private final ConcatAdapter mConcatAdapter;
-
- /**
- * Holds the mapping from the view type to the adapter which reported that type.
- */
- private final ViewTypeStorage mViewTypeStorage;
-
- /**
- * We hold onto the list of attached recyclerviews so that we can dispatch attach/detach to
- * any adapter that was added later on.
- * Probably does not need to be a weak reference but playing safe here.
- */
- private List> mAttachedRecyclerViews = new ArrayList<>();
-
- /**
- * Keeps the information about which ViewHolder is bound by which adapter.
- * It is set in onBind, reset at onRecycle.
- */
- private final IdentityHashMap
- mBinderLookup = new IdentityHashMap<>();
-
- private List mWrappers = new ArrayList<>();
-
- // keep one of these around so that we can return wrapper & position w/o allocation ¯\_(ツ)_/¯
- private WrapperAndLocalPosition mReusableHolder = new WrapperAndLocalPosition();
-
- @NonNull
- private final ConcatAdapter.Config.StableIdMode mStableIdMode;
-
- /**
- * This is where we keep stable ids, if supported
- */
- private final StableIdStorage mStableIdStorage;
-
- ConcatAdapterController(
- ConcatAdapter concatAdapter,
- ConcatAdapter.Config config) {
- mConcatAdapter = concatAdapter;
-
- // setup view type handling
- if (config.isolateViewTypes) {
- mViewTypeStorage = new ViewTypeStorage.IsolatedViewTypeStorage();
- } else {
- mViewTypeStorage = new ViewTypeStorage.SharedIdRangeViewTypeStorage();
- }
-
- // setup stable id handling
- mStableIdMode = config.stableIdMode;
- if (config.stableIdMode == NO_STABLE_IDS) {
- mStableIdStorage = new StableIdStorage.NoStableIdStorage();
- } else if (config.stableIdMode == ISOLATED_STABLE_IDS) {
- mStableIdStorage = new StableIdStorage.IsolatedStableIdStorage();
- } else if (config.stableIdMode == SHARED_STABLE_IDS) {
- mStableIdStorage = new StableIdStorage.SharedPoolStableIdStorage();
- } else {
- throw new IllegalArgumentException("unknown stable id mode");
- }
- }
-
- @Nullable
- private NestedAdapterWrapper findWrapperFor(Adapter adapter) {
- final int index = indexOfWrapper(adapter);
- if (index == -1) {
- return null;
- }
- return mWrappers.get(index);
- }
-
- private int indexOfWrapper(Adapter adapter) {
- final int limit = mWrappers.size();
- for (int i = 0; i < limit; i++) {
- if (mWrappers.get(i).adapter == adapter) {
- return i;
- }
- }
- return -1;
- }
-
- /**
- * return true if added, false otherwise.
- *
- * @see ConcatAdapter#addAdapter(Adapter)
- */
- boolean addAdapter(Adapter adapter) {
- return addAdapter(mWrappers.size(), adapter);
- }
-
- /**
- * return true if added, false otherwise.
- * throws exception if index is out of bounds
- *
- * @see ConcatAdapter#addAdapter(int, Adapter)
- */
- boolean addAdapter(int index, Adapter adapter) {
- if (index < 0 || index > mWrappers.size()) {
- throw new IndexOutOfBoundsException("Index must be between 0 and "
- + mWrappers.size() + ". Given:" + index);
- }
- if (hasStableIds()) {
- Preconditions.checkArgument(adapter.hasStableIds(),
- "All sub adapters must have stable ids when stable id mode "
- + "is ISOLATED_STABLE_IDS or SHARED_STABLE_IDS");
- } else {
- if (adapter.hasStableIds()) {
- Log.w(ConcatAdapter.TAG, "Stable ids in the adapter will be ignored as the"
- + " ConcatAdapter is configured not to have stable ids");
- }
- }
- NestedAdapterWrapper existing = findWrapperFor(adapter);
- if (existing != null) {
- return false;
- }
- NestedAdapterWrapper wrapper = new NestedAdapterWrapper(adapter, this,
- mViewTypeStorage, mStableIdStorage.createStableIdLookup());
- mWrappers.add(index, wrapper);
- // notify attach for all recyclerview
- for (WeakReference reference : mAttachedRecyclerViews) {
- RecyclerView recyclerView = reference.get();
- if (recyclerView != null) {
- adapter.onAttachedToRecyclerView(recyclerView);
- }
- }
- // new items, notify add for them
- if (wrapper.getCachedItemCount() > 0) {
- mConcatAdapter.notifyItemRangeInserted(
- countItemsBefore(wrapper),
- wrapper.getCachedItemCount()
- );
- }
- // reset state restoration strategy
- calculateAndUpdateStateRestorationPolicy();
- return true;
- }
-
- boolean removeAdapter(Adapter adapter) {
- final int index = indexOfWrapper(adapter);
- if (index == -1) {
- return false;
- }
- NestedAdapterWrapper wrapper = mWrappers.get(index);
- int offset = countItemsBefore(wrapper);
- mWrappers.remove(index);
- mConcatAdapter.notifyItemRangeRemoved(offset, wrapper.getCachedItemCount());
- // notify detach for all recyclerviews
- for (WeakReference reference : mAttachedRecyclerViews) {
- RecyclerView recyclerView = reference.get();
- if (recyclerView != null) {
- adapter.onDetachedFromRecyclerView(recyclerView);
- }
- }
- wrapper.dispose();
- calculateAndUpdateStateRestorationPolicy();
- return true;
- }
-
- private int countItemsBefore(NestedAdapterWrapper wrapper) {
- int count = 0;
- for (NestedAdapterWrapper item : mWrappers) {
- if (item != wrapper) {
- count += item.getCachedItemCount();
- } else {
- break;
- }
- }
- return count;
- }
-
- public long getItemId(int globalPosition) {
- WrapperAndLocalPosition wrapperAndPos = findWrapperAndLocalPosition(globalPosition);
- long globalItemId = wrapperAndPos.mWrapper.getItemId(wrapperAndPos.mLocalPosition);
- releaseWrapperAndLocalPosition(wrapperAndPos);
- return globalItemId;
- }
-
- @Override
- public void onChanged(@NonNull NestedAdapterWrapper wrapper) {
- // TODO should we notify more cleverly, maybe in v2
- mConcatAdapter.notifyDataSetChanged();
- calculateAndUpdateStateRestorationPolicy();
- }
-
- @Override
- public void onItemRangeChanged(@NonNull NestedAdapterWrapper nestedAdapterWrapper,
- int positionStart, int itemCount) {
- final int offset = countItemsBefore(nestedAdapterWrapper);
- mConcatAdapter.notifyItemRangeChanged(
- positionStart + offset,
- itemCount
- );
- }
-
- @Override
- public void onItemRangeChanged(@NonNull NestedAdapterWrapper nestedAdapterWrapper,
- int positionStart, int itemCount, @Nullable Object payload) {
- final int offset = countItemsBefore(nestedAdapterWrapper);
- mConcatAdapter.notifyItemRangeChanged(
- positionStart + offset,
- itemCount,
- payload
- );
- }
-
- @Override
- public void onItemRangeInserted(@NonNull NestedAdapterWrapper nestedAdapterWrapper,
- int positionStart, int itemCount) {
- final int offset = countItemsBefore(nestedAdapterWrapper);
- mConcatAdapter.notifyItemRangeInserted(
- positionStart + offset,
- itemCount
- );
- }
-
- @Override
- public void onItemRangeRemoved(@NonNull NestedAdapterWrapper nestedAdapterWrapper,
- int positionStart, int itemCount) {
- int offset = countItemsBefore(nestedAdapterWrapper);
- mConcatAdapter.notifyItemRangeRemoved(
- positionStart + offset,
- itemCount
- );
- }
-
- @Override
- public void onItemRangeMoved(@NonNull NestedAdapterWrapper nestedAdapterWrapper,
- int fromPosition, int toPosition) {
- int offset = countItemsBefore(nestedAdapterWrapper);
- mConcatAdapter.notifyItemMoved(
- fromPosition + offset,
- toPosition + offset
- );
- }
-
- @Override
- public void onStateRestorationPolicyChanged(NestedAdapterWrapper nestedAdapterWrapper) {
- calculateAndUpdateStateRestorationPolicy();
- }
-
- private void calculateAndUpdateStateRestorationPolicy() {
- StateRestorationPolicy newPolicy = computeStateRestorationPolicy();
- if (newPolicy != mConcatAdapter.getStateRestorationPolicy()) {
- mConcatAdapter.internalSetStateRestorationPolicy(newPolicy);
- }
- }
-
- private StateRestorationPolicy computeStateRestorationPolicy() {
- for (NestedAdapterWrapper wrapper : mWrappers) {
- StateRestorationPolicy strategy =
- wrapper.adapter.getStateRestorationPolicy();
- if (strategy == PREVENT) {
- // one adapter can block all
- return PREVENT;
- } else if (strategy == PREVENT_WHEN_EMPTY && wrapper.getCachedItemCount() == 0) {
- // an adapter wants to allow w/ size but we need to make sure there is no prevent
- return PREVENT;
- }
- }
- return ALLOW;
- }
-
- public int getTotalCount() {
- // should we cache this as well ?
- int total = 0;
- for (NestedAdapterWrapper wrapper : mWrappers) {
- total += wrapper.getCachedItemCount();
- }
- return total;
- }
-
- public int getItemViewType(int globalPosition) {
- WrapperAndLocalPosition wrapperAndPos = findWrapperAndLocalPosition(globalPosition);
- int itemViewType = wrapperAndPos.mWrapper.getItemViewType(wrapperAndPos.mLocalPosition);
- releaseWrapperAndLocalPosition(wrapperAndPos);
- return itemViewType;
- }
-
- public ViewHolder onCreateViewHolder(ViewGroup parent, int globalViewType) {
- NestedAdapterWrapper wrapper = mViewTypeStorage.getWrapperForGlobalType(globalViewType);
- return wrapper.onCreateViewHolder(parent, globalViewType);
- }
-
- public Pair, Integer> getWrappedAdapterAndPosition(
- int globalPosition) {
- WrapperAndLocalPosition wrapper = findWrapperAndLocalPosition(globalPosition);
- Pair, Integer> pair = new Pair<>(wrapper.mWrapper.adapter,
- wrapper.mLocalPosition);
- releaseWrapperAndLocalPosition(wrapper);
- return pair;
- }
-
- /**
- * Always call {@link #releaseWrapperAndLocalPosition(WrapperAndLocalPosition)} when you are
- * done with it
- */
- @NonNull
- private WrapperAndLocalPosition findWrapperAndLocalPosition(
- int globalPosition
- ) {
- WrapperAndLocalPosition result;
- if (mReusableHolder.mInUse) {
- result = new WrapperAndLocalPosition();
- } else {
- mReusableHolder.mInUse = true;
- result = mReusableHolder;
- }
- int localPosition = globalPosition;
- for (NestedAdapterWrapper wrapper : mWrappers) {
- if (wrapper.getCachedItemCount() > localPosition) {
- result.mWrapper = wrapper;
- result.mLocalPosition = localPosition;
- break;
- }
- localPosition -= wrapper.getCachedItemCount();
- }
- if (result.mWrapper == null) {
- throw new IllegalArgumentException("Cannot find wrapper for " + globalPosition);
- }
- return result;
- }
-
- private void releaseWrapperAndLocalPosition(WrapperAndLocalPosition wrapperAndLocalPosition) {
- wrapperAndLocalPosition.mInUse = false;
- wrapperAndLocalPosition.mWrapper = null;
- wrapperAndLocalPosition.mLocalPosition = -1;
- mReusableHolder = wrapperAndLocalPosition;
- }
-
- public void onBindViewHolder(ViewHolder holder, int globalPosition) {
- WrapperAndLocalPosition wrapperAndPos = findWrapperAndLocalPosition(globalPosition);
- mBinderLookup.put(holder, wrapperAndPos.mWrapper);
- wrapperAndPos.mWrapper.onBindViewHolder(holder, wrapperAndPos.mLocalPosition);
- releaseWrapperAndLocalPosition(wrapperAndPos);
- }
-
- public boolean canRestoreState() {
- for (NestedAdapterWrapper wrapper : mWrappers) {
- if (!wrapper.adapter.canRestoreState()) {
- return false;
- }
- }
- return true;
- }
-
- public void onViewAttachedToWindow(ViewHolder holder) {
- NestedAdapterWrapper wrapper = getWrapper(holder);
- wrapper.adapter.onViewAttachedToWindow(holder);
- }
-
- public void onViewDetachedFromWindow(ViewHolder holder) {
- NestedAdapterWrapper wrapper = getWrapper(holder);
- wrapper.adapter.onViewDetachedFromWindow(holder);
- }
-
- public void onViewRecycled(ViewHolder holder) {
- NestedAdapterWrapper wrapper = mBinderLookup.get(holder);
- if (wrapper == null) {
- throw new IllegalStateException("Cannot find wrapper for " + holder
- + ", seems like it is not bound by this adapter: " + this);
- }
- wrapper.adapter.onViewRecycled(holder);
- mBinderLookup.remove(holder);
- }
-
- public boolean onFailedToRecycleView(ViewHolder holder) {
- NestedAdapterWrapper wrapper = mBinderLookup.get(holder);
- if (wrapper == null) {
- throw new IllegalStateException("Cannot find wrapper for " + holder
- + ", seems like it is not bound by this adapter: " + this);
- }
- final boolean result = wrapper.adapter.onFailedToRecycleView(holder);
- mBinderLookup.remove(holder);
- return result;
- }
-
- @NonNull
- private NestedAdapterWrapper getWrapper(ViewHolder holder) {
- NestedAdapterWrapper wrapper = mBinderLookup.get(holder);
- if (wrapper == null) {
- throw new IllegalStateException("Cannot find wrapper for " + holder
- + ", seems like it is not bound by this adapter: " + this);
- }
- return wrapper;
- }
-
- private boolean isAttachedTo(RecyclerView recyclerView) {
- for (WeakReference reference : mAttachedRecyclerViews) {
- if (reference.get() == recyclerView) {
- return true;
- }
- }
- return false;
- }
-
- public void onAttachedToRecyclerView(RecyclerView recyclerView) {
- if (isAttachedTo(recyclerView)) {
- return;
- }
- mAttachedRecyclerViews.add(new WeakReference<>(recyclerView));
- for (NestedAdapterWrapper wrapper : mWrappers) {
- wrapper.adapter.onAttachedToRecyclerView(recyclerView);
- }
- }
-
- public void onDetachedFromRecyclerView(RecyclerView recyclerView) {
- for (int i = mAttachedRecyclerViews.size() - 1; i >= 0; i--) {
- WeakReference reference = mAttachedRecyclerViews.get(i);
- if (reference.get() == null) {
- mAttachedRecyclerViews.remove(i);
- } else if (reference.get() == recyclerView) {
- mAttachedRecyclerViews.remove(i);
- break; // here we can break as we don't keep duplicates
- }
- }
- for (NestedAdapterWrapper wrapper : mWrappers) {
- wrapper.adapter.onDetachedFromRecyclerView(recyclerView);
- }
- }
-
- public int getLocalAdapterPosition(
- Adapter adapter,
- ViewHolder viewHolder,
- int globalPosition
- ) {
- NestedAdapterWrapper wrapper = mBinderLookup.get(viewHolder);
- if (wrapper == null) {
- return NO_POSITION;
- }
- int itemsBefore = countItemsBefore(wrapper);
- // local position is globalPosition - itemsBefore
- int localPosition = globalPosition - itemsBefore;
- // Early error detection:
- int itemCount = wrapper.adapter.getItemCount();
- if (localPosition < 0 || localPosition >= itemCount) {
- throw new IllegalStateException("Detected inconsistent adapter updates. The"
- + " local position of the view holder maps to " + localPosition + " which"
- + " is out of bounds for the adapter with size "
- + itemCount + "."
- + "Make sure to immediately call notify methods in your adapter when you "
- + "change the backing data"
- + "viewHolder:" + viewHolder
- + "adapter:" + adapter);
- }
- return wrapper.adapter.findRelativeAdapterPositionIn(adapter, viewHolder, localPosition);
- }
-
-
- @Nullable
- public Adapter getBoundAdapter(ViewHolder viewHolder) {
- NestedAdapterWrapper wrapper = mBinderLookup.get(viewHolder);
- if (wrapper == null) {
- return null;
- }
- return wrapper.adapter;
- }
-
- @SuppressWarnings("MixedMutabilityReturnType")
- public List> getCopyOfAdapters() {
- if (mWrappers.isEmpty()) {
- return Collections.emptyList();
- }
- List> adapters = new ArrayList<>(mWrappers.size());
- for (NestedAdapterWrapper wrapper : mWrappers) {
- adapters.add(wrapper.adapter);
- }
- return adapters;
- }
-
- public boolean hasStableIds() {
- return mStableIdMode != NO_STABLE_IDS;
- }
-
- /**
- * Helper class to hold onto wrapper and local position without allocating objects as this is
- * a very common call.
- */
- static class WrapperAndLocalPosition {
- NestedAdapterWrapper mWrapper;
- int mLocalPosition;
- boolean mInUse;
- }
-}
diff --git a/app/src/main/java/androidx/recyclerview/widget/DefaultItemAnimator.java b/app/src/main/java/androidx/recyclerview/widget/DefaultItemAnimator.java
deleted file mode 100644
index a520aa98d9..0000000000
--- a/app/src/main/java/androidx/recyclerview/widget/DefaultItemAnimator.java
+++ /dev/null
@@ -1,674 +0,0 @@
-/*
- * Copyright 2018 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package androidx.recyclerview.widget;
-
-import android.animation.Animator;
-import android.animation.AnimatorListenerAdapter;
-import android.animation.TimeInterpolator;
-import android.animation.ValueAnimator;
-import android.annotation.SuppressLint;
-import android.view.View;
-import android.view.ViewPropertyAnimator;
-
-import androidx.annotation.NonNull;
-import androidx.core.view.ViewCompat;
-
-import java.util.ArrayList;
-import java.util.List;
-
-/**
- * This implementation of {@link RecyclerView.ItemAnimator} provides basic
- * animations on remove, add, and move events that happen to the items in
- * a RecyclerView. RecyclerView uses a DefaultItemAnimator by default.
- *
- * @see RecyclerView#setItemAnimator(RecyclerView.ItemAnimator)
- */
-public class DefaultItemAnimator extends SimpleItemAnimator {
- private static final boolean DEBUG = false;
-
- private static TimeInterpolator sDefaultInterpolator;
-
- private ArrayList mPendingRemovals = new ArrayList<>();
- private ArrayList mPendingAdditions = new ArrayList<>();
- private ArrayList mPendingMoves = new ArrayList<>();
- private ArrayList mPendingChanges = new ArrayList<>();
-
- ArrayList> mAdditionsList = new ArrayList<>();
- ArrayList> mMovesList = new ArrayList<>();
- ArrayList> mChangesList = new ArrayList<>();
-
- ArrayList mAddAnimations = new ArrayList<>();
- ArrayList mMoveAnimations = new ArrayList<>();
- ArrayList mRemoveAnimations = new ArrayList<>();
- ArrayList mChangeAnimations = new ArrayList<>();
-
- private static class MoveInfo {
- public RecyclerView.ViewHolder holder;
- public int fromX, fromY, toX, toY;
-
- MoveInfo(RecyclerView.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 static class ChangeInfo {
- public RecyclerView.ViewHolder oldHolder, newHolder;
- public int fromX, fromY, toX, toY;
- private ChangeInfo(RecyclerView.ViewHolder oldHolder, RecyclerView.ViewHolder newHolder) {
- this.oldHolder = oldHolder;
- this.newHolder = newHolder;
- }
-
- ChangeInfo(RecyclerView.ViewHolder oldHolder, RecyclerView.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;
- }
-
- @Override
- @SuppressLint("UnknownNullness") // b/240775049: Cannot annotate properly
- public String toString() {
- return "ChangeInfo{"
- + "oldHolder=" + oldHolder
- + ", newHolder=" + newHolder
- + ", fromX=" + fromX
- + ", fromY=" + fromY
- + ", toX=" + toX
- + ", toY=" + toY
- + '}';
- }
- }
-
- @Override
- public void runPendingAnimations() {
- boolean removalsPending = !mPendingRemovals.isEmpty();
- boolean movesPending = !mPendingMoves.isEmpty();
- boolean changesPending = !mPendingChanges.isEmpty();
- boolean additionsPending = !mPendingAdditions.isEmpty();
- if (!removalsPending && !movesPending && !additionsPending && !changesPending) {
- // nothing to animate
- return;
- }
- // First, remove stuff
- for (RecyclerView.ViewHolder holder : mPendingRemovals) {
- animateRemoveImpl(holder);
- }
- mPendingRemovals.clear();
- // Next, move stuff
- if (movesPending) {
- final ArrayList moves = new ArrayList<>();
- moves.addAll(mPendingMoves);
- mMovesList.add(moves);
- mPendingMoves.clear();
- Runnable mover = new Runnable() {
- @Override
- public void run() {
- for (MoveInfo moveInfo : moves) {
- animateMoveImpl(moveInfo.holder, moveInfo.fromX, moveInfo.fromY,
- moveInfo.toX, moveInfo.toY);
- }
- moves.clear();
- mMovesList.remove(moves);
- }
- };
- if (removalsPending) {
- View view = moves.get(0).holder.itemView;
- ViewCompat.postOnAnimationDelayed(view, mover, getRemoveDuration());
- } else {
- mover.run();
- }
- }
- // Next, change stuff, to run in parallel with move animations
- if (changesPending) {
- final ArrayList changes = new ArrayList<>();
- changes.addAll(mPendingChanges);
- mChangesList.add(changes);
- mPendingChanges.clear();
- Runnable changer = new Runnable() {
- @Override
- public void run() {
- for (ChangeInfo change : changes) {
- animateChangeImpl(change);
- }
- changes.clear();
- mChangesList.remove(changes);
- }
- };
- if (removalsPending) {
- RecyclerView.ViewHolder holder = changes.get(0).oldHolder;
- ViewCompat.postOnAnimationDelayed(holder.itemView, changer, getRemoveDuration());
- } else {
- changer.run();
- }
- }
- // Next, add stuff
- if (additionsPending) {
- final ArrayList additions = new ArrayList<>();
- additions.addAll(mPendingAdditions);
- mAdditionsList.add(additions);
- mPendingAdditions.clear();
- Runnable adder = new Runnable() {
- @Override
- public void run() {
- for (RecyclerView.ViewHolder holder : additions) {
- animateAddImpl(holder);
- }
- 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
- @SuppressLint("UnknownNullness") // b/240775049: Cannot annotate properly
- public boolean animateRemove(final RecyclerView.ViewHolder holder) {
- resetAnimation(holder);
- mPendingRemovals.add(holder);
- return true;
- }
-
- private void animateRemoveImpl(final RecyclerView.ViewHolder holder) {
- final View view = holder.itemView;
- final ViewPropertyAnimator animation = view.animate();
- mRemoveAnimations.add(holder);
- animation.setDuration(getRemoveDuration()).alpha(0).setListener(
- new AnimatorListenerAdapter() {
- @Override
- public void onAnimationStart(Animator animator) {
- dispatchRemoveStarting(holder);
- }
-
- @Override
- public void onAnimationEnd(Animator animator) {
- animation.setListener(null);
- view.setAlpha(1);
- dispatchRemoveFinished(holder);
- mRemoveAnimations.remove(holder);
- dispatchFinishedWhenDone();
- }
- }).start();
- }
-
- @Override
- @SuppressLint("UnknownNullness") // b/240775049: Cannot annotate properly
- public boolean animateAdd(final RecyclerView.ViewHolder holder) {
- resetAnimation(holder);
- holder.itemView.setAlpha(0);
- mPendingAdditions.add(holder);
- return true;
- }
-
- void animateAddImpl(final RecyclerView.ViewHolder holder) {
- final View view = holder.itemView;
- final ViewPropertyAnimator animation = view.animate();
- mAddAnimations.add(holder);
- animation.alpha(1).setDuration(getAddDuration())
- .setListener(new AnimatorListenerAdapter() {
- @Override
- public void onAnimationStart(Animator animator) {
- dispatchAddStarting(holder);
- }
-
- @Override
- public void onAnimationCancel(Animator animator) {
- view.setAlpha(1);
- }
-
- @Override
- public void onAnimationEnd(Animator animator) {
- animation.setListener(null);
- dispatchAddFinished(holder);
- mAddAnimations.remove(holder);
- dispatchFinishedWhenDone();
- }
- }).start();
- }
-
- @Override
- @SuppressLint("UnknownNullness") // b/240775049: Cannot annotate properly
- public boolean animateMove(final RecyclerView.ViewHolder holder, int fromX, int fromY,
- int toX, int toY) {
- final View view = holder.itemView;
- fromX += (int) holder.itemView.getTranslationX();
- fromY += (int) holder.itemView.getTranslationY();
- resetAnimation(holder);
- int deltaX = toX - fromX;
- int deltaY = toY - fromY;
- if (deltaX == 0 && deltaY == 0) {
- dispatchMoveFinished(holder);
- return false;
- }
- if (deltaX != 0) {
- view.setTranslationX(-deltaX);
- }
- if (deltaY != 0) {
- view.setTranslationY(-deltaY);
- }
- mPendingMoves.add(new MoveInfo(holder, fromX, fromY, toX, toY));
- return true;
- }
-
- void animateMoveImpl(final RecyclerView.ViewHolder holder, int fromX, int fromY, int toX, int toY) {
- final View view = holder.itemView;
- final int deltaX = toX - fromX;
- final int deltaY = toY - fromY;
- if (deltaX != 0) {
- view.animate().translationX(0);
- }
- if (deltaY != 0) {
- view.animate().translationY(0);
- }
- // TODO: make EndActions end listeners instead, since end actions aren't called when
- // vpas are canceled (and can't end them. why?)
- // need listener functionality in VPACompat for this. Ick.
- final ViewPropertyAnimator animation = view.animate();
- mMoveAnimations.add(holder);
- animation.setDuration(getMoveDuration()).setListener(new AnimatorListenerAdapter() {
- @Override
- public void onAnimationStart(Animator animator) {
- dispatchMoveStarting(holder);
- }
-
- @Override
- public void onAnimationCancel(Animator animator) {
- if (deltaX != 0) {
- view.setTranslationX(0);
- }
- if (deltaY != 0) {
- view.setTranslationY(0);
- }
- }
-
- @Override
- public void onAnimationEnd(Animator animator) {
- animation.setListener(null);
- dispatchMoveFinished(holder);
- mMoveAnimations.remove(holder);
- dispatchFinishedWhenDone();
- }
- }).start();
- }
-
- @Override
- @SuppressLint("UnknownNullness") // b/240775049: Cannot annotate properly
- public boolean animateChange(RecyclerView.ViewHolder oldHolder,
- RecyclerView.ViewHolder newHolder, int fromLeft, int fromTop, int toLeft, int toTop) {
- if (oldHolder == newHolder) {
- // Don't know how to run change animations when the same view holder is re-used.
- // run a move animation to handle position changes.
- return animateMove(oldHolder, fromLeft, fromTop, toLeft, toTop);
- }
- final float prevTranslationX = oldHolder.itemView.getTranslationX();
- final float prevTranslationY = oldHolder.itemView.getTranslationY();
- final float prevAlpha = oldHolder.itemView.getAlpha();
- resetAnimation(oldHolder);
- int deltaX = (int) (toLeft - fromLeft - prevTranslationX);
- int deltaY = (int) (toTop - fromTop - prevTranslationY);
- // recover prev translation state after ending animation
- oldHolder.itemView.setTranslationX(prevTranslationX);
- oldHolder.itemView.setTranslationY(prevTranslationY);
- oldHolder.itemView.setAlpha(prevAlpha);
- if (newHolder != null) {
- // carry over translation values
- resetAnimation(newHolder);
- newHolder.itemView.setTranslationX(-deltaX);
- newHolder.itemView.setTranslationY(-deltaY);
- newHolder.itemView.setAlpha(0);
- }
- mPendingChanges.add(new ChangeInfo(oldHolder, newHolder, fromLeft, fromTop, toLeft, toTop));
- return true;
- }
-
- void animateChangeImpl(final ChangeInfo changeInfo) {
- final RecyclerView.ViewHolder holder = changeInfo.oldHolder;
- final View view = holder == null ? null : holder.itemView;
- final RecyclerView.ViewHolder newHolder = changeInfo.newHolder;
- final View newView = newHolder != null ? newHolder.itemView : null;
- if (view != null) {
- final ViewPropertyAnimator oldViewAnim = view.animate().setDuration(
- getChangeDuration());
- mChangeAnimations.add(changeInfo.oldHolder);
- oldViewAnim.translationX(changeInfo.toX - changeInfo.fromX);
- oldViewAnim.translationY(changeInfo.toY - changeInfo.fromY);
- oldViewAnim.alpha(0).setListener(new AnimatorListenerAdapter() {
- @Override
- public void onAnimationStart(Animator animator) {
- dispatchChangeStarting(changeInfo.oldHolder, true);
- }
-
- @Override
- public void onAnimationEnd(Animator animator) {
- oldViewAnim.setListener(null);
- view.setAlpha(1);
- view.setTranslationX(0);
- view.setTranslationY(0);
- dispatchChangeFinished(changeInfo.oldHolder, true);
- mChangeAnimations.remove(changeInfo.oldHolder);
- dispatchFinishedWhenDone();
- }
- }).start();
- }
- if (newView != null) {
- final ViewPropertyAnimator newViewAnimation = newView.animate();
- mChangeAnimations.add(changeInfo.newHolder);
- newViewAnimation.translationX(0).translationY(0).setDuration(getChangeDuration())
- .alpha(1).setListener(new AnimatorListenerAdapter() {
- @Override
- public void onAnimationStart(Animator animator) {
- dispatchChangeStarting(changeInfo.newHolder, false);
- }
- @Override
- public void onAnimationEnd(Animator animator) {
- newViewAnimation.setListener(null);
- newView.setAlpha(1);
- newView.setTranslationX(0);
- newView.setTranslationY(0);
- dispatchChangeFinished(changeInfo.newHolder, false);
- mChangeAnimations.remove(changeInfo.newHolder);
- dispatchFinishedWhenDone();
- }
- }).start();
- }
- }
-
- private void endChangeAnimation(List infoList, RecyclerView.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 void endChangeAnimationIfNecessary(ChangeInfo changeInfo) {
- if (changeInfo.oldHolder != null) {
- endChangeAnimationIfNecessary(changeInfo, changeInfo.oldHolder);
- }
- if (changeInfo.newHolder != null) {
- endChangeAnimationIfNecessary(changeInfo, changeInfo.newHolder);
- }
- }
- private boolean endChangeAnimationIfNecessary(ChangeInfo changeInfo, RecyclerView.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;
- }
- item.itemView.setAlpha(1);
- item.itemView.setTranslationX(0);
- item.itemView.setTranslationY(0);
- dispatchChangeFinished(item, oldItem);
- return true;
- }
-
- @Override
- @SuppressLint("UnknownNullness") // b/240775049: Cannot annotate properly
- public void endAnimation(RecyclerView.ViewHolder item) {
- final View view = item.itemView;
- // this will trigger end callback which should set properties to their target values.
- view.animate().cancel();
- // TODO if some other animations are chained to end, how do we cancel them as well?
- for (int i = mPendingMoves.size() - 1; i >= 0; i--) {
- MoveInfo moveInfo = mPendingMoves.get(i);
- if (moveInfo.holder == item) {
- view.setTranslationY(0);
- view.setTranslationX(0);
- dispatchMoveFinished(item);
- mPendingMoves.remove(i);
- }
- }
- endChangeAnimation(mPendingChanges, item);
- if (mPendingRemovals.remove(item)) {
- view.setAlpha(1);
- dispatchRemoveFinished(item);
- }
- if (mPendingAdditions.remove(item)) {
- view.setAlpha(1);
- dispatchAddFinished(item);
- }
-
- for (int i = mChangesList.size() - 1; i >= 0; i--) {
- ArrayList changes = mChangesList.get(i);
- endChangeAnimation(changes, item);
- if (changes.isEmpty()) {
- mChangesList.remove(i);
- }
- }
- for (int i = mMovesList.size() - 1; i >= 0; i--) {
- ArrayList moves = mMovesList.get(i);
- for (int j = moves.size() - 1; j >= 0; j--) {
- MoveInfo moveInfo = moves.get(j);
- if (moveInfo.holder == item) {
- view.setTranslationY(0);
- view.setTranslationX(0);
- dispatchMoveFinished(item);
- moves.remove(j);
- if (moves.isEmpty()) {
- mMovesList.remove(i);
- }
- break;
- }
- }
- }
- for (int i = mAdditionsList.size() - 1; i >= 0; i--) {
- ArrayList additions = mAdditionsList.get(i);
- if (additions.remove(item)) {
- view.setAlpha(1);
- dispatchAddFinished(item);
- if (additions.isEmpty()) {
- mAdditionsList.remove(i);
- }
- }
- }
-
- // animations should be ended by the cancel above.
- //noinspection PointlessBooleanExpression,ConstantConditions
- if (mRemoveAnimations.remove(item) && DEBUG) {
- throw new IllegalStateException("after animation is cancelled, item should not be in "
- + "mRemoveAnimations list");
- }
-
- //noinspection PointlessBooleanExpression,ConstantConditions
- if (mAddAnimations.remove(item) && DEBUG) {
- throw new IllegalStateException("after animation is cancelled, item should not be in "
- + "mAddAnimations list");
- }
-
- //noinspection PointlessBooleanExpression,ConstantConditions
- if (mChangeAnimations.remove(item) && DEBUG) {
- throw new IllegalStateException("after animation is cancelled, item should not be in "
- + "mChangeAnimations list");
- }
-
- //noinspection PointlessBooleanExpression,ConstantConditions
- if (mMoveAnimations.remove(item) && DEBUG) {
- throw new IllegalStateException("after animation is cancelled, item should not be in "
- + "mMoveAnimations list");
- }
- dispatchFinishedWhenDone();
- }
-
- private void resetAnimation(RecyclerView.ViewHolder holder) {
- if (sDefaultInterpolator == null) {
- sDefaultInterpolator = new ValueAnimator().getInterpolator();
- }
- holder.itemView.animate().setInterpolator(sDefaultInterpolator);
- endAnimation(holder);
- }
-
- @Override
- public boolean isRunning() {
- return (!mPendingAdditions.isEmpty()
- || !mPendingChanges.isEmpty()
- || !mPendingMoves.isEmpty()
- || !mPendingRemovals.isEmpty()
- || !mMoveAnimations.isEmpty()
- || !mRemoveAnimations.isEmpty()
- || !mAddAnimations.isEmpty()
- || !mChangeAnimations.isEmpty()
- || !mMovesList.isEmpty()
- || !mAdditionsList.isEmpty()
- || !mChangesList.isEmpty());
- }
-
- /**
- * Check the state of currently pending and running animations. If there are none
- * pending/running, call {@link #dispatchAnimationsFinished()} to notify any
- * listeners.
- */
- void dispatchFinishedWhenDone() {
- if (!isRunning()) {
- dispatchAnimationsFinished();
- }
- }
-
- @Override
- public void endAnimations() {
- int count = mPendingMoves.size();
- for (int i = count - 1; i >= 0; i--) {
- MoveInfo item = mPendingMoves.get(i);
- View view = item.holder.itemView;
- view.setTranslationY(0);
- view.setTranslationX(0);
- dispatchMoveFinished(item.holder);
- mPendingMoves.remove(i);
- }
- count = mPendingRemovals.size();
- for (int i = count - 1; i >= 0; i--) {
- RecyclerView.ViewHolder item = mPendingRemovals.get(i);
- dispatchRemoveFinished(item);
- mPendingRemovals.remove(i);
- }
- count = mPendingAdditions.size();
- for (int i = count - 1; i >= 0; i--) {
- RecyclerView.ViewHolder item = mPendingAdditions.get(i);
- item.itemView.setAlpha(1);
- dispatchAddFinished(item);
- mPendingAdditions.remove(i);
- }
- count = mPendingChanges.size();
- for (int i = count - 1; i >= 0; i--) {
- endChangeAnimationIfNecessary(mPendingChanges.get(i));
- }
- mPendingChanges.clear();
- if (!isRunning()) {
- return;
- }
-
- int listCount = mMovesList.size();
- for (int i = listCount - 1; i >= 0; i--) {
- ArrayList moves = mMovesList.get(i);
- count = moves.size();
- for (int j = count - 1; j >= 0; j--) {
- MoveInfo moveInfo = moves.get(j);
- RecyclerView.ViewHolder item = moveInfo.holder;
- View view = item.itemView;
- view.setTranslationY(0);
- view.setTranslationX(0);
- dispatchMoveFinished(moveInfo.holder);
- moves.remove(j);
- if (moves.isEmpty()) {
- mMovesList.remove(moves);
- }
- }
- }
- listCount = mAdditionsList.size();
- for (int i = listCount - 1; i >= 0; i--) {
- ArrayList additions = mAdditionsList.get(i);
- count = additions.size();
- for (int j = count - 1; j >= 0; j--) {
- RecyclerView.ViewHolder item = additions.get(j);
- View view = item.itemView;
- view.setAlpha(1);
- dispatchAddFinished(item);
- additions.remove(j);
- if (additions.isEmpty()) {
- mAdditionsList.remove(additions);
- }
- }
- }
- listCount = mChangesList.size();
- for (int i = listCount - 1; i >= 0; i--) {
- ArrayList changes = mChangesList.get(i);
- count = changes.size();
- for (int j = count - 1; j >= 0; j--) {
- endChangeAnimationIfNecessary(changes.get(j));
- if (changes.isEmpty()) {
- mChangesList.remove(changes);
- }
- }
- }
-
- cancelAll(mRemoveAnimations);
- cancelAll(mMoveAnimations);
- cancelAll(mAddAnimations);
- cancelAll(mChangeAnimations);
-
- dispatchAnimationsFinished();
- }
-
- void cancelAll(List viewHolders) {
- for (int i = viewHolders.size() - 1; i >= 0; i--) {
- viewHolders.get(i).itemView.animate().cancel();
- }
- }
-
- /**
- * {@inheritDoc}
- *
- * If the payload list is not empty, DefaultItemAnimator returns true.
- * When this is the case:
- *
- * If you override {@link #animateChange(RecyclerView.ViewHolder, RecyclerView.ViewHolder, int, int, int, int)}, both
- * ViewHolder arguments will be the same instance.
- *
- *
- * If you are not overriding {@link #animateChange(RecyclerView.ViewHolder, RecyclerView.ViewHolder, int, int, int, int)},
- * then DefaultItemAnimator will call {@link #animateMove(RecyclerView.ViewHolder, int, int, int, int)} and
- * run a move animation instead.
- *
- *
- */
- @Override
- public boolean canReuseUpdatedViewHolder(@NonNull RecyclerView.ViewHolder viewHolder,
- @NonNull List payloads) {
- return !payloads.isEmpty() || super.canReuseUpdatedViewHolder(viewHolder, payloads);
- }
-}
diff --git a/app/src/main/java/androidx/recyclerview/widget/DiffUtil.java b/app/src/main/java/androidx/recyclerview/widget/DiffUtil.java
deleted file mode 100644
index 940901e5a4..0000000000
--- a/app/src/main/java/androidx/recyclerview/widget/DiffUtil.java
+++ /dev/null
@@ -1,1058 +0,0 @@
-/*
- * Copyright 2018 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package androidx.recyclerview.widget;
-
-import androidx.annotation.IntRange;
-import androidx.annotation.NonNull;
-import androidx.annotation.Nullable;
-
-import java.util.ArrayDeque;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.Comparator;
-import java.util.Iterator;
-import java.util.List;
-
-/**
- * DiffUtil is a utility class that calculates the difference between two lists and outputs a
- * list of update operations that converts the first list into the second one.
- *
- * It can be used to calculate updates for a RecyclerView Adapter. See {@link ListAdapter} and
- * {@link AsyncListDiffer} which can simplify the use of DiffUtil on a background thread.
- *
- * DiffUtil uses Eugene W. Myers's difference algorithm to calculate the minimal number of updates
- * to convert one list into another. Myers's algorithm does not handle items that are moved so
- * DiffUtil runs a second pass on the result to detect items that were moved.
- *
- * Note that DiffUtil, {@link ListAdapter}, and {@link AsyncListDiffer} require the list to not
- * mutate while in use.
- * This generally means that both the lists themselves and their elements (or at least, the
- * properties of elements used in diffing) should not be modified directly. Instead, new lists
- * should be provided any time content changes. It's common for lists passed to DiffUtil to share
- * elements that have not mutated, so it is not strictly required to reload all data to use
- * DiffUtil.
- *
- * If the lists are large, this operation may take significant time so you are advised to run this
- * on a background thread, get the {@link DiffResult} then apply it on the RecyclerView on the main
- * thread.
- *
- * This algorithm is optimized for space and uses O(N) space to find the minimal
- * number of addition and removal operations between the two lists. It has O(N + D^2) expected time
- * performance where D is the length of the edit script.
- *
- * If move detection is enabled, it takes an additional O(MN) time where M is the total number of
- * added items and N is the total number of removed items. If your lists are already sorted by
- * the same constraint (e.g. a created timestamp for a list of posts), you can disable move
- * detection to improve performance.
- *
- * The actual runtime of the algorithm significantly depends on the number of changes in the list
- * and the cost of your comparison methods. Below are some average run times for reference:
- * (The test list is composed of random UUID Strings and the tests are run on Nexus 5X with M)
- *
- * 100 items and 10 modifications: avg: 0.39 ms, median: 0.35 ms
- * 100 items and 100 modifications: 3.82 ms, median: 3.75 ms
- * 100 items and 100 modifications without moves: 2.09 ms, median: 2.06 ms
- * 1000 items and 50 modifications: avg: 4.67 ms, median: 4.59 ms
- * 1000 items and 50 modifications without moves: avg: 3.59 ms, median: 3.50 ms
- * 1000 items and 200 modifications: 27.07 ms, median: 26.92 ms
- * 1000 items and 200 modifications without moves: 13.54 ms, median: 13.36 ms
- *
- *
- * Due to implementation constraints, the max size of the list can be 2^26.
- *
- * @see ListAdapter
- * @see AsyncListDiffer
- */
-public class DiffUtil {
- private DiffUtil() {
- // utility class, no instance.
- }
-
- private static final Comparator DIAGONAL_COMPARATOR = new Comparator() {
- @Override
- public int compare(Diagonal o1, Diagonal o2) {
- return o1.x - o2.x;
- }
- };
-
- // Myers' algorithm uses two lists as axis labels. In DiffUtil's implementation, `x` axis is
- // used for old list and `y` axis is used for new list.
-
- /**
- * Calculates the list of update operations that can covert one list into the other one.
- *
- * @param cb The callback that acts as a gateway to the backing list data
- * @return A DiffResult that contains the information about the edit sequence to convert the
- * old list into the new list.
- */
- @NonNull
- public static DiffResult calculateDiff(@NonNull Callback cb) {
- return calculateDiff(cb, true);
- }
-
- /**
- * Calculates the list of update operations that can covert one list into the other one.
- *
- * If your old and new lists are sorted by the same constraint and items never move (swap
- * positions), you can disable move detection which takes O(N^2) time where
- * N is the number of added, moved, removed items.
- *
- * @param cb The callback that acts as a gateway to the backing list data
- * @param detectMoves True if DiffUtil should try to detect moved items, false otherwise.
- *
- * @return A DiffResult that contains the information about the edit sequence to convert the
- * old list into the new list.
- */
- @NonNull
- public static DiffResult calculateDiff(@NonNull Callback cb, boolean detectMoves) {
- final int oldSize = cb.getOldListSize();
- final int newSize = cb.getNewListSize();
-
- final List diagonals = new ArrayList<>();
-
- // instead of a recursive implementation, we keep our own stack to avoid potential stack
- // overflow exceptions
- final List stack = new ArrayList<>();
-
- stack.add(new Range(0, oldSize, 0, newSize));
-
- final int max = (oldSize + newSize + 1) / 2;
- // allocate forward and backward k-lines. K lines are diagonal lines in the matrix. (see the
- // paper for details)
- // These arrays lines keep the max reachable position for each k-line.
- final CenteredArray forward = new CenteredArray(max * 2 + 1);
- final CenteredArray backward = new CenteredArray(max * 2 + 1);
-
- // We pool the ranges to avoid allocations for each recursive call.
- final List rangePool = new ArrayList<>();
- while (!stack.isEmpty()) {
- final Range range = stack.remove(stack.size() - 1);
- final Snake snake = midPoint(range, cb, forward, backward);
- if (snake != null) {
- // if it has a diagonal, save it
- if (snake.diagonalSize() > 0) {
- diagonals.add(snake.toDiagonal());
- }
- // add new ranges for left and right
- final Range left = rangePool.isEmpty() ? new Range() : rangePool.remove(
- rangePool.size() - 1);
- left.oldListStart = range.oldListStart;
- left.newListStart = range.newListStart;
- left.oldListEnd = snake.startX;
- left.newListEnd = snake.startY;
- stack.add(left);
-
- // re-use range for right
- //noinspection UnnecessaryLocalVariable
- final Range right = range;
- right.oldListEnd = range.oldListEnd;
- right.newListEnd = range.newListEnd;
- right.oldListStart = snake.endX;
- right.newListStart = snake.endY;
- stack.add(right);
- } else {
- rangePool.add(range);
- }
-
- }
- // sort snakes
- Collections.sort(diagonals, DIAGONAL_COMPARATOR);
-
- return new DiffResult(cb, diagonals,
- forward.backingData(), backward.backingData(),
- detectMoves);
- }
-
- /**
- * Finds a middle snake in the given range.
- */
- @Nullable
- private static Snake midPoint(
- Range range,
- Callback cb,
- CenteredArray forward,
- CenteredArray backward) {
- if (range.oldSize() < 1 || range.newSize() < 1) {
- return null;
- }
- int max = (range.oldSize() + range.newSize() + 1) / 2;
- forward.set(1, range.oldListStart);
- backward.set(1, range.oldListEnd);
- for (int d = 0; d < max; d++) {
- Snake snake = forward(range, cb, forward, backward, d);
- if (snake != null) {
- return snake;
- }
- snake = backward(range, cb, forward, backward, d);
- if (snake != null) {
- return snake;
- }
- }
- return null;
- }
-
- @Nullable
- private static Snake forward(
- Range range,
- Callback cb,
- CenteredArray forward,
- CenteredArray backward,
- int d) {
- boolean checkForSnake = Math.abs(range.oldSize() - range.newSize()) % 2 == 1;
- int delta = range.oldSize() - range.newSize();
- for (int k = -d; k <= d; k += 2) {
- // we either come from d-1, k-1 OR d-1. k+1
- // as we move in steps of 2, array always holds both current and previous d values
- // k = x - y and each array value holds the max X, y = x - k
- final int startX;
- final int startY;
- int x, y;
- if (k == -d || (k != d && forward.get(k + 1) > forward.get(k - 1))) {
- // picking k + 1, incrementing Y (by simply not incrementing X)
- x = startX = forward.get(k + 1);
- } else {
- // picking k - 1, incrementing X
- startX = forward.get(k - 1);
- x = startX + 1;
- }
- y = range.newListStart + (x - range.oldListStart) - k;
- startY = (d == 0 || x != startX) ? y : y - 1;
- // now find snake size
- while (x < range.oldListEnd
- && y < range.newListEnd
- && cb.areItemsTheSame(x, y)) {
- x++;
- y++;
- }
- // now we have furthest reaching x, record it
- forward.set(k, x);
- if (checkForSnake) {
- // see if we did pass over a backwards array
- // mapping function: delta - k
- int backwardsK = delta - k;
- // if backwards K is calculated and it passed me, found match
- if (backwardsK >= -d + 1
- && backwardsK <= d - 1
- && backward.get(backwardsK) <= x) {
- // match
- Snake snake = new Snake();
- snake.startX = startX;
- snake.startY = startY;
- snake.endX = x;
- snake.endY = y;
- snake.reverse = false;
- return snake;
- }
- }
- }
- return null;
- }
-
- @Nullable
- private static Snake backward(
- Range range,
- Callback cb,
- CenteredArray forward,
- CenteredArray backward,
- int d) {
- boolean checkForSnake = (range.oldSize() - range.newSize()) % 2 == 0;
- int delta = range.oldSize() - range.newSize();
- // same as forward but we go backwards from end of the lists to be beginning
- // this also means we'll try to optimize for minimizing x instead of maximizing it
- for (int k = -d; k <= d; k += 2) {
- // we either come from d-1, k-1 OR d-1, k+1
- // as we move in steps of 2, array always holds both current and previous d values
- // k = x - y and each array value holds the MIN X, y = x - k
- // when x's are equal, we prioritize deletion over insertion
- final int startX;
- final int startY;
- int x, y;
-
- if (k == -d || (k != d && backward.get(k + 1) < backward.get(k - 1))) {
- // picking k + 1, decrementing Y (by simply not decrementing X)
- x = startX = backward.get(k + 1);
- } else {
- // picking k - 1, decrementing X
- startX = backward.get(k - 1);
- x = startX - 1;
- }
- y = range.newListEnd - ((range.oldListEnd - x) - k);
- startY = (d == 0 || x != startX) ? y : y + 1;
- // now find snake size
- while (x > range.oldListStart
- && y > range.newListStart
- && cb.areItemsTheSame(x - 1, y - 1)) {
- x--;
- y--;
- }
- // now we have furthest point, record it (min X)
- backward.set(k, x);
- if (checkForSnake) {
- // see if we did pass over a backwards array
- // mapping function: delta - k
- int forwardsK = delta - k;
- // if forwards K is calculated and it passed me, found match
- if (forwardsK >= -d
- && forwardsK <= d
- && forward.get(forwardsK) >= x) {
- // match
- Snake snake = new Snake();
- // assignment are reverse since we are a reverse snake
- snake.startX = x;
- snake.startY = y;
- snake.endX = startX;
- snake.endY = startY;
- snake.reverse = true;
- return snake;
- }
- }
- }
- return null;
- }
-
- /**
- * A Callback class used by DiffUtil while calculating the diff between two lists.
- */
- public abstract static class Callback {
- /**
- * Returns the size of the old list.
- *
- * @return The size of the old list.
- */
- public abstract int getOldListSize();
-
- /**
- * Returns the size of the new list.
- *
- * @return The size of the new list.
- */
- public abstract int getNewListSize();
-
- /**
- * Called by the DiffUtil to decide whether two object represent the same Item.
- *
- * For example, if your items have unique ids, this method should check their id equality.
- *
- * @param oldItemPosition The position of the item in the old list
- * @param newItemPosition The position of the item in the new list
- * @return True if the two items represent the same object or false if they are different.
- */
- public abstract boolean areItemsTheSame(int oldItemPosition, int newItemPosition);
-
- /**
- * Called by the DiffUtil when it wants to check whether two items have the same data.
- * DiffUtil uses this information to detect if the contents of an item has changed.
- *
- * DiffUtil uses this method to check equality instead of {@link Object#equals(Object)}
- * so that you can change its behavior depending on your UI.
- * For example, if you are using DiffUtil with a
- * {@link RecyclerView.Adapter RecyclerView.Adapter}, you should
- * return whether the items' visual representations are the same.
- *
- * This method is called only if {@link #areItemsTheSame(int, int)} returns
- * {@code true} for these items.
- *
- * @param oldItemPosition The position of the item in the old list
- * @param newItemPosition The position of the item in the new list which replaces the
- * oldItem
- * @return True if the contents of the items are the same or false if they are different.
- */
- public abstract boolean areContentsTheSame(int oldItemPosition, int newItemPosition);
-
- /**
- * When {@link #areItemsTheSame(int, int)} returns {@code true} for two items and
- * {@link #areContentsTheSame(int, int)} returns false for them, DiffUtil
- * calls this method to get a payload about the change.
- *
- * For example, if you are using DiffUtil with {@link RecyclerView}, you can return the
- * particular field that changed in the item and your
- * {@link RecyclerView.ItemAnimator ItemAnimator} can use that
- * information to run the correct animation.
- *
- * Default implementation returns {@code null}.
- *
- * @param oldItemPosition The position of the item in the old list
- * @param newItemPosition The position of the item in the new list
- * @return A payload object that represents the change between the two items.
- */
- @Nullable
- public Object getChangePayload(int oldItemPosition, int newItemPosition) {
- return null;
- }
- }
-
- /**
- * Callback for calculating the diff between two non-null items in a list.
- *
- * {@link Callback} serves two roles - list indexing, and item diffing. ItemCallback handles
- * just the second of these, which allows separation of code that indexes into an array or List
- * from the presentation-layer and content specific diffing code.
- *
- * @param Type of items to compare.
- */
- public abstract static class ItemCallback {
- /**
- * Called to check whether two objects represent the same item.
- *
- * For example, if your items have unique ids, this method should check their id equality.
- *
- * Note: {@code null} items in the list are assumed to be the same as another {@code null}
- * item and are assumed to not be the same as a non-{@code null} item. This callback will
- * not be invoked for either of those cases.
- *
- * @param oldItem The item in the old list.
- * @param newItem The item in the new list.
- * @return True if the two items represent the same object or false if they are different.
- * @see Callback#areItemsTheSame(int, int)
- */
- public abstract boolean areItemsTheSame(@NonNull T oldItem, @NonNull T newItem);
-
- /**
- * Called to check whether two items have the same data.
- *
- * This information is used to detect if the contents of an item have changed.
- *
- * This method to check equality instead of {@link Object#equals(Object)} so that you can
- * change its behavior depending on your UI.
- *
- * For example, if you are using DiffUtil with a
- * {@link RecyclerView.Adapter RecyclerView.Adapter}, you should
- * return whether the items' visual representations are the same.
- *
- * This method is called only if {@link #areItemsTheSame(T, T)} returns {@code true} for
- * these items.
- *
- * Note: Two {@code null} items are assumed to represent the same contents. This callback
- * will not be invoked for this case.
- *
- * @param oldItem The item in the old list.
- * @param newItem The item in the new list.
- * @return True if the contents of the items are the same or false if they are different.
- * @see Callback#areContentsTheSame(int, int)
- */
- public abstract boolean areContentsTheSame(@NonNull T oldItem, @NonNull T newItem);
-
- /**
- * When {@link #areItemsTheSame(T, T)} returns {@code true} for two items and
- * {@link #areContentsTheSame(T, T)} returns false for them, this method is called to
- * get a payload about the change.
- *
- * For example, if you are using DiffUtil with {@link RecyclerView}, you can return the
- * particular field that changed in the item and your
- * {@link RecyclerView.ItemAnimator ItemAnimator} can use that
- * information to run the correct animation.
- *
- * Default implementation returns {@code null}.
- *
- * @see Callback#getChangePayload(int, int)
- */
- @SuppressWarnings({"unused"})
- @Nullable
- public Object getChangePayload(@NonNull T oldItem, @NonNull T newItem) {
- return null;
- }
- }
-
- /**
- * A diagonal is a match in the graph.
- * Rather than snakes, we only record the diagonals in the path.
- */
- static class Diagonal {
- public final int x;
- public final int y;
- public final int size;
-
- Diagonal(int x, int y, int size) {
- this.x = x;
- this.y = y;
- this.size = size;
- }
-
- int endX() {
- return x + size;
- }
-
- int endY() {
- return y + size;
- }
- }
-
- /**
- * Snakes represent a match between two lists. It is optionally prefixed or postfixed with an
- * add or remove operation. See the Myers' paper for details.
- */
- @SuppressWarnings("WeakerAccess")
- static class Snake {
- /**
- * Position in the old list
- */
- public int startX;
-
- /**
- * Position in the new list
- */
- public int startY;
-
- /**
- * End position in the old list, exclusive
- */
- public int endX;
-
- /**
- * End position in the new list, exclusive
- */
- public int endY;
-
- /**
- * True if this snake was created in the reverse search, false otherwise.
- */
- public boolean reverse;
-
- boolean hasAdditionOrRemoval() {
- return endY - startY != endX - startX;
- }
-
- boolean isAddition() {
- return endY - startY > endX - startX;
- }
-
- int diagonalSize() {
- return Math.min(endX - startX, endY - startY);
- }
-
- /**
- * Extract the diagonal of the snake to make reasoning easier for the rest of the
- * algorithm where we try to produce a path and also find moves.
- */
- @NonNull
- Diagonal toDiagonal() {
- if (hasAdditionOrRemoval()) {
- if (reverse) {
- // snake edge it at the end
- return new Diagonal(startX, startY, diagonalSize());
- } else {
- // snake edge it at the beginning
- if (isAddition()) {
- return new Diagonal(startX, startY + 1, diagonalSize());
- } else {
- return new Diagonal(startX + 1, startY, diagonalSize());
- }
- }
- } else {
- // we are a pure diagonal
- return new Diagonal(startX, startY, endX - startX);
- }
- }
- }
-
- /**
- * Represents a range in two lists that needs to be solved.
- *
- * This internal class is used when running Myers' algorithm without recursion.
- *
- * Ends are exclusive
- */
- static class Range {
-
- int oldListStart, oldListEnd;
-
- int newListStart, newListEnd;
-
- public Range() {
- }
-
- public Range(int oldListStart, int oldListEnd, int newListStart, int newListEnd) {
- this.oldListStart = oldListStart;
- this.oldListEnd = oldListEnd;
- this.newListStart = newListStart;
- this.newListEnd = newListEnd;
- }
-
- int oldSize() {
- return oldListEnd - oldListStart;
- }
-
- int newSize() {
- return newListEnd - newListStart;
- }
- }
-
- /**
- * This class holds the information about the result of a
- * {@link DiffUtil#calculateDiff(Callback, boolean)} call.
- *
- * You can consume the updates in a DiffResult via
- * {@link #dispatchUpdatesTo(ListUpdateCallback)} or directly stream the results into a
- * {@link RecyclerView.Adapter} via {@link #dispatchUpdatesTo(RecyclerView.Adapter)}.
- */
- public static class DiffResult {
- /**
- * Signifies an item not present in the list.
- */
- public static final int NO_POSITION = -1;
-
-
- /**
- * While reading the flags below, keep in mind that when multiple items move in a list,
- * Myers's may pick any of them as the anchor item and consider that one NOT_CHANGED while
- * picking others as additions and removals. This is completely fine as we later detect
- * all moves.
- *
- * Below, when an item is mentioned to stay in the same "location", it means we won't
- * dispatch a move/add/remove for it, it DOES NOT mean the item is still in the same
- * position.
- */
- // item stayed the same.
- private static final int FLAG_NOT_CHANGED = 1;
- // item stayed in the same location but changed.
- private static final int FLAG_CHANGED = FLAG_NOT_CHANGED << 1;
- // Item has moved and also changed.
- private static final int FLAG_MOVED_CHANGED = FLAG_CHANGED << 1;
- // Item has moved but did not change.
- private static final int FLAG_MOVED_NOT_CHANGED = FLAG_MOVED_CHANGED << 1;
- // Item moved
- private static final int FLAG_MOVED = FLAG_MOVED_CHANGED | FLAG_MOVED_NOT_CHANGED;
-
- // since we are re-using the int arrays that were created in the Myers' step, we mask
- // change flags
- private static final int FLAG_OFFSET = 4;
-
- private static final int FLAG_MASK = (1 << FLAG_OFFSET) - 1;
-
- // The diagonals extracted from The Myers' snakes.
- private final List mDiagonals;
-
- // The list to keep oldItemStatuses. As we traverse old items, we assign flags to them
- // which also includes whether they were a real removal or a move (and its new index).
- private final int[] mOldItemStatuses;
- // The list to keep newItemStatuses. As we traverse new items, we assign flags to them
- // which also includes whether they were a real addition or a move(and its old index).
- private final int[] mNewItemStatuses;
- // The callback that was given to calculate diff method.
- private final Callback mCallback;
-
- private final int mOldListSize;
-
- private final int mNewListSize;
-
- private final boolean mDetectMoves;
-
- /**
- * @param callback The callback that was used to calculate the diff
- * @param diagonals Matches between the two lists
- * @param oldItemStatuses An int[] that can be re-purposed to keep metadata
- * @param newItemStatuses An int[] that can be re-purposed to keep metadata
- * @param detectMoves True if this DiffResult will try to detect moved items
- */
- DiffResult(Callback callback, List diagonals, int[] oldItemStatuses,
- int[] newItemStatuses, boolean detectMoves) {
- mDiagonals = diagonals;
- mOldItemStatuses = oldItemStatuses;
- mNewItemStatuses = newItemStatuses;
- Arrays.fill(mOldItemStatuses, 0);
- Arrays.fill(mNewItemStatuses, 0);
- mCallback = callback;
- mOldListSize = callback.getOldListSize();
- mNewListSize = callback.getNewListSize();
- mDetectMoves = detectMoves;
- addEdgeDiagonals();
- findMatchingItems();
- }
-
- /**
- * Add edge diagonals so that we can iterate as long as there are diagonals w/o lots of
- * null checks around
- */
- private void addEdgeDiagonals() {
- Diagonal first = mDiagonals.isEmpty() ? null : mDiagonals.get(0);
- // see if we should add 1 to the 0,0
- if (first == null || first.x != 0 || first.y != 0) {
- mDiagonals.add(0, new Diagonal(0, 0, 0));
- }
- // always add one last
- mDiagonals.add(new Diagonal(mOldListSize, mNewListSize, 0));
- }
-
- /**
- * Find position mapping from old list to new list.
- * If moves are requested, we'll also try to do an n^2 search between additions and
- * removals to find moves.
- */
- private void findMatchingItems() {
- for (Diagonal diagonal : mDiagonals) {
- for (int offset = 0; offset < diagonal.size; offset++) {
- int posX = diagonal.x + offset;
- int posY = diagonal.y + offset;
- final boolean theSame = mCallback.areContentsTheSame(posX, posY);
- final int changeFlag = theSame ? FLAG_NOT_CHANGED : FLAG_CHANGED;
- mOldItemStatuses[posX] = (posY << FLAG_OFFSET) | changeFlag;
- mNewItemStatuses[posY] = (posX << FLAG_OFFSET) | changeFlag;
- }
- }
- // now all matches are marked, lets look for moves
- if (mDetectMoves) {
- // traverse each addition / removal from the end of the list, find matching
- // addition removal from before
- findMoveMatches();
- }
- }
-
- private void findMoveMatches() {
- // for each removal, find matching addition
- int posX = 0;
- for (Diagonal diagonal : mDiagonals) {
- while (posX < diagonal.x) {
- if (mOldItemStatuses[posX] == 0) {
- // there is a removal, find matching addition from the rest
- findMatchingAddition(posX);
- }
- posX++;
- }
- // snap back for the next diagonal
- posX = diagonal.endX();
- }
- }
-
- /**
- * Search the whole list to find the addition for the given removal of position posX
- *
- * @param posX position in the old list
- */
- private void findMatchingAddition(int posX) {
- int posY = 0;
- final int diagonalsSize = mDiagonals.size();
- for (int i = 0; i < diagonalsSize; i++) {
- final Diagonal diagonal = mDiagonals.get(i);
- while (posY < diagonal.y) {
- // found some additions, evaluate
- if (mNewItemStatuses[posY] == 0) { // not evaluated yet
- boolean matching = mCallback.areItemsTheSame(posX, posY);
- if (matching) {
- // yay found it, set values
- boolean contentsMatching = mCallback.areContentsTheSame(posX, posY);
- final int changeFlag = contentsMatching ? FLAG_MOVED_NOT_CHANGED
- : FLAG_MOVED_CHANGED;
- // once we process one of these, it will mark the other one as ignored.
- mOldItemStatuses[posX] = (posY << FLAG_OFFSET) | changeFlag;
- mNewItemStatuses[posY] = (posX << FLAG_OFFSET) | changeFlag;
- return;
- }
- }
- posY++;
- }
- posY = diagonal.endY();
- }
- }
-
- /**
- * Given a position in the old list, returns the position in the new list, or
- * {@code NO_POSITION} if it was removed.
- *
- * @param oldListPosition Position of item in old list
- * @return Position of item in new list, or {@code NO_POSITION} if not present.
- * @see #NO_POSITION
- * @see #convertNewPositionToOld(int)
- */
- public int convertOldPositionToNew(@IntRange(from = 0) int oldListPosition) {
- if (oldListPosition < 0 || oldListPosition >= mOldListSize) {
- throw new IndexOutOfBoundsException("Index out of bounds - passed position = "
- + oldListPosition + ", old list size = " + mOldListSize);
- }
- final int status = mOldItemStatuses[oldListPosition];
- if ((status & FLAG_MASK) == 0) {
- return NO_POSITION;
- } else {
- return status >> FLAG_OFFSET;
- }
- }
-
- /**
- * Given a position in the new list, returns the position in the old list, or
- * {@code NO_POSITION} if it was removed.
- *
- * @param newListPosition Position of item in new list
- * @return Position of item in old list, or {@code NO_POSITION} if not present.
- * @see #NO_POSITION
- * @see #convertOldPositionToNew(int)
- */
- public int convertNewPositionToOld(@IntRange(from = 0) int newListPosition) {
- if (newListPosition < 0 || newListPosition >= mNewListSize) {
- throw new IndexOutOfBoundsException("Index out of bounds - passed position = "
- + newListPosition + ", new list size = " + mNewListSize);
- }
- final int status = mNewItemStatuses[newListPosition];
- if ((status & FLAG_MASK) == 0) {
- return NO_POSITION;
- } else {
- return status >> FLAG_OFFSET;
- }
- }
-
- /**
- * Dispatches the update events to the given adapter.
- *
- * For example, if you have an {@link RecyclerView.Adapter Adapter}
- * that is backed by a {@link List}, you can swap the list with the new one then call this
- * method to dispatch all updates to the RecyclerView.
- *
- * List oldList = mAdapter.getData();
- * DiffResult result = DiffUtil.calculateDiff(new MyCallback(oldList, newList));
- * mAdapter.setData(newList);
- * result.dispatchUpdatesTo(mAdapter);
- *
- *
- * Note that the RecyclerView requires you to dispatch adapter updates immediately when you
- * change the data (you cannot defer {@code notify*} calls). The usage above adheres to this
- * rule because updates are sent to the adapter right after the backing data is changed,
- * before RecyclerView tries to read it.
- *
- * On the other hand, if you have another
- * {@link RecyclerView.AdapterDataObserver AdapterDataObserver}
- * that tries to process events synchronously, this may confuse that observer because the
- * list is instantly moved to its final state while the adapter updates are dispatched later
- * on, one by one. If you have such an
- * {@link RecyclerView.AdapterDataObserver AdapterDataObserver},
- * you can use
- * {@link #dispatchUpdatesTo(ListUpdateCallback)} to handle each modification
- * manually.
- *
- * @param adapter A RecyclerView adapter which was displaying the old list and will start
- * displaying the new list.
- * @see AdapterListUpdateCallback
- */
- public void dispatchUpdatesTo(@NonNull final RecyclerView.Adapter adapter) {
- dispatchUpdatesTo(new AdapterListUpdateCallback(adapter));
- }
-
- /**
- * Dispatches update operations to the given Callback.
- *
- * These updates are atomic such that the first update call affects every update call that
- * comes after it (the same as RecyclerView).
- *
- * @param updateCallback The callback to receive the update operations.
- * @see #dispatchUpdatesTo(RecyclerView.Adapter)
- */
- public void dispatchUpdatesTo(@NonNull ListUpdateCallback updateCallback) {
- final BatchingListUpdateCallback batchingCallback;
-
- if (updateCallback instanceof BatchingListUpdateCallback) {
- batchingCallback = (BatchingListUpdateCallback) updateCallback;
- } else {
- batchingCallback = new BatchingListUpdateCallback(updateCallback);
- // replace updateCallback with a batching callback and override references to
- // updateCallback so that we don't call it directly by mistake
- //noinspection UnusedAssignment
- updateCallback = batchingCallback;
- }
- // track up to date current list size for moves
- // when a move is found, we record its position from the end of the list (which is
- // less likely to change since we iterate in reverse).
- // Later when we find the match of that move, we dispatch the update
- int currentListSize = mOldListSize;
- // list of postponed moves
- final Collection postponedUpdates = new ArrayDeque<>();
- // posX and posY are exclusive
- int posX = mOldListSize;
- int posY = mNewListSize;
- // iterate from end of the list to the beginning.
- // this just makes offsets easier since changes in the earlier indices has an effect
- // on the later indices.
- for (int diagonalIndex = mDiagonals.size() - 1; diagonalIndex >= 0; diagonalIndex--) {
- final Diagonal diagonal = mDiagonals.get(diagonalIndex);
- int endX = diagonal.endX();
- int endY = diagonal.endY();
- // dispatch removals and additions until we reach to that diagonal
- // first remove then add so that it can go into its place and we don't need
- // to offset values
- while (posX > endX) {
- posX--;
- // REMOVAL
- int status = mOldItemStatuses[posX];
- if ((status & FLAG_MOVED) != 0) {
- int newPos = status >> FLAG_OFFSET;
- // get postponed addition
- PostponedUpdate postponedUpdate = getPostponedUpdate(postponedUpdates,
- newPos, false);
- if (postponedUpdate != null) {
- // this is an addition that was postponed. Now dispatch it.
- int updatedNewPos = currentListSize - postponedUpdate.currentPos;
- batchingCallback.onMoved(posX, updatedNewPos - 1);
- if ((status & FLAG_MOVED_CHANGED) != 0) {
- Object changePayload = mCallback.getChangePayload(posX, newPos);
- batchingCallback.onChanged(updatedNewPos - 1, 1, changePayload);
- }
- } else {
- // first time we are seeing this, we'll see a matching addition
- postponedUpdates.add(new PostponedUpdate(
- posX,
- currentListSize - posX - 1,
- true
- ));
- }
- } else {
- // simple removal
- batchingCallback.onRemoved(posX, 1);
- currentListSize--;
- }
- }
- while (posY > endY) {
- posY--;
- // ADDITION
- int status = mNewItemStatuses[posY];
- if ((status & FLAG_MOVED) != 0) {
- // this is a move not an addition.
- // see if this is postponed
- int oldPos = status >> FLAG_OFFSET;
- // get postponed removal
- PostponedUpdate postponedUpdate = getPostponedUpdate(postponedUpdates,
- oldPos, true);
- // empty size returns 0 for indexOf
- if (postponedUpdate == null) {
- // postpone it until we see the removal
- postponedUpdates.add(new PostponedUpdate(
- posY,
- currentListSize - posX,
- false
- ));
- } else {
- // oldPosFromEnd = foundListSize - posX
- // we can find posX if we swap the list sizes
- // posX = listSize - oldPosFromEnd
- int updatedOldPos = currentListSize - postponedUpdate.currentPos - 1;
- batchingCallback.onMoved(updatedOldPos, posX);
- if ((status & FLAG_MOVED_CHANGED) != 0) {
- Object changePayload = mCallback.getChangePayload(oldPos, posY);
- batchingCallback.onChanged(posX, 1, changePayload);
- }
- }
- } else {
- // simple addition
- batchingCallback.onInserted(posX, 1);
- currentListSize++;
- }
- }
- // now dispatch updates for the diagonal
- posX = diagonal.x;
- posY = diagonal.y;
- for (int i = 0; i < diagonal.size; i++) {
- // dispatch changes
- if ((mOldItemStatuses[posX] & FLAG_MASK) == FLAG_CHANGED) {
- Object changePayload = mCallback.getChangePayload(posX, posY);
- batchingCallback.onChanged(posX, 1, changePayload);
- }
- posX++;
- posY++;
- }
- // snap back for the next diagonal
- posX = diagonal.x;
- posY = diagonal.y;
- }
- batchingCallback.dispatchLastEvent();
- }
-
- @Nullable
- private static PostponedUpdate getPostponedUpdate(
- Collection postponedUpdates,
- int posInList,
- boolean removal) {
- PostponedUpdate postponedUpdate = null;
- Iterator itr = postponedUpdates.iterator();
- while (itr.hasNext()) {
- PostponedUpdate update = itr.next();
- if (update.posInOwnerList == posInList && update.removal == removal) {
- postponedUpdate = update;
- itr.remove();
- break;
- }
- }
- while (itr.hasNext()) {
- // re-offset all others
- PostponedUpdate update = itr.next();
- if (removal) {
- update.currentPos--;
- } else {
- update.currentPos++;
- }
- }
- return postponedUpdate;
- }
- }
-
- /**
- * Represents an update that we skipped because it was a move.
- *
- * When an update is skipped, it is tracked as other updates are dispatched until the matching
- * add/remove operation is found at which point the tracked position is used to dispatch the
- * update.
- */
- private static class PostponedUpdate {
- /**
- * position in the list that owns this item
- */
- int posInOwnerList;
-
- /**
- * position wrt to the end of the list
- */
- int currentPos;
-
- /**
- * true if this is a removal, false otherwise
- */
- boolean removal;
-
- PostponedUpdate(int posInOwnerList, int currentPos, boolean removal) {
- this.posInOwnerList = posInOwnerList;
- this.currentPos = currentPos;
- this.removal = removal;
- }
- }
-
- /**
- * Array wrapper w/ negative index support.
- * We use this array instead of a regular array so that algorithm is easier to read without
- * too many offsets when accessing the "k" array in the algorithm.
- */
- static class CenteredArray {
- private final int[] mData;
- private final int mMid;
-
- CenteredArray(int size) {
- mData = new int[size];
- mMid = mData.length / 2;
- }
-
- int get(int index) {
- return mData[index + mMid];
- }
-
- int[] backingData() {
- return mData;
- }
-
- void set(int index, int value) {
- mData[index + mMid] = value;
- }
-
- public void fill(int value) {
- Arrays.fill(mData, value);
- }
- }
-}
diff --git a/app/src/main/java/androidx/recyclerview/widget/DividerItemDecoration.java b/app/src/main/java/androidx/recyclerview/widget/DividerItemDecoration.java
deleted file mode 100644
index b4598edfed..0000000000
--- a/app/src/main/java/androidx/recyclerview/widget/DividerItemDecoration.java
+++ /dev/null
@@ -1,194 +0,0 @@
-/*
- * Copyright 2018 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-
-package androidx.recyclerview.widget;
-
-import android.annotation.SuppressLint;
-import android.content.Context;
-import android.content.res.TypedArray;
-import android.graphics.Canvas;
-import android.graphics.Rect;
-import android.graphics.drawable.Drawable;
-import android.util.Log;
-import android.view.View;
-import android.widget.LinearLayout;
-
-import androidx.annotation.NonNull;
-import androidx.annotation.Nullable;
-
-/**
- * DividerItemDecoration is a {@link RecyclerView.ItemDecoration} that can be used as a divider
- * between items of a {@link LinearLayoutManager}. It supports both {@link #HORIZONTAL} and
- * {@link #VERTICAL} orientations.
- *
- *
- * mDividerItemDecoration = new DividerItemDecoration(recyclerView.getContext(),
- * mLayoutManager.getOrientation());
- * recyclerView.addItemDecoration(mDividerItemDecoration);
- *
- */
-public class DividerItemDecoration extends RecyclerView.ItemDecoration {
- public static final int HORIZONTAL = LinearLayout.HORIZONTAL;
- public static final int VERTICAL = LinearLayout.VERTICAL;
-
- private static final String TAG = "DividerItem";
- private static final int[] ATTRS = new int[]{ android.R.attr.listDivider };
-
- private Drawable mDivider;
-
- /**
- * Current orientation. Either {@link #HORIZONTAL} or {@link #VERTICAL}.
- */
- private int mOrientation;
-
- private final Rect mBounds = new Rect();
-
- /**
- * Creates a divider {@link RecyclerView.ItemDecoration} that can be used with a
- * {@link LinearLayoutManager}.
- *
- * @param context Current context, it will be used to access resources.
- * @param orientation Divider orientation. Should be {@link #HORIZONTAL} or {@link #VERTICAL}.
- */
- @SuppressLint("UnknownNullness") // b/240775049: Cannot annotate properly
- public DividerItemDecoration(Context context, int orientation) {
- final TypedArray a = context.obtainStyledAttributes(ATTRS);
- mDivider = a.getDrawable(0);
- if (mDivider == null) {
- Log.w(TAG, "@android:attr/listDivider was not set in the theme used for this "
- + "DividerItemDecoration. Please set that attribute all call setDrawable()");
- }
- a.recycle();
- setOrientation(orientation);
- }
-
- /**
- * Sets the orientation for this divider. This should be called if
- * {@link RecyclerView.LayoutManager} changes orientation.
- *
- * @param orientation {@link #HORIZONTAL} or {@link #VERTICAL}
- */
- public void setOrientation(int orientation) {
- if (orientation != HORIZONTAL && orientation != VERTICAL) {
- throw new IllegalArgumentException(
- "Invalid orientation. It should be either HORIZONTAL or VERTICAL");
- }
- mOrientation = orientation;
- }
-
- /**
- * Sets the {@link Drawable} for this divider.
- *
- * @param drawable Drawable that should be used as a divider.
- */
- public void setDrawable(@NonNull Drawable drawable) {
- if (drawable == null) {
- throw new IllegalArgumentException("Drawable cannot be null.");
- }
- mDivider = drawable;
- }
-
- /**
- * @return the {@link Drawable} for this divider.
- */
- @Nullable
- public Drawable getDrawable() {
- return mDivider;
- }
-
- @Override
- @SuppressLint("UnknownNullness") // b/240775049: Cannot annotate properly
- public void onDraw(Canvas c, RecyclerView parent, RecyclerView.State state) {
- if (parent.getLayoutManager() == null || mDivider == null) {
- return;
- }
- if (mOrientation == VERTICAL) {
- drawVertical(c, parent);
- } else {
- drawHorizontal(c, parent);
- }
- }
-
- private void drawVertical(Canvas canvas, RecyclerView parent) {
- canvas.save();
- final int left;
- final int right;
- //noinspection AndroidLintNewApi - NewApi lint fails to handle overrides.
- if (parent.getClipToPadding()) {
- left = parent.getPaddingLeft();
- right = parent.getWidth() - parent.getPaddingRight();
- canvas.clipRect(left, parent.getPaddingTop(), right,
- parent.getHeight() - parent.getPaddingBottom());
- } else {
- left = 0;
- right = parent.getWidth();
- }
-
- final int childCount = parent.getChildCount();
- for (int i = 0; i < childCount; i++) {
- final View child = parent.getChildAt(i);
- parent.getDecoratedBoundsWithMargins(child, mBounds);
- final int bottom = mBounds.bottom + Math.round(child.getTranslationY());
- final int top = bottom - mDivider.getIntrinsicHeight();
- mDivider.setBounds(left, top, right, bottom);
- mDivider.draw(canvas);
- }
- canvas.restore();
- }
-
- private void drawHorizontal(Canvas canvas, RecyclerView parent) {
- canvas.save();
- final int top;
- final int bottom;
- //noinspection AndroidLintNewApi - NewApi lint fails to handle overrides.
- if (parent.getClipToPadding()) {
- top = parent.getPaddingTop();
- bottom = parent.getHeight() - parent.getPaddingBottom();
- canvas.clipRect(parent.getPaddingLeft(), top,
- parent.getWidth() - parent.getPaddingRight(), bottom);
- } else {
- top = 0;
- bottom = parent.getHeight();
- }
-
- final int childCount = parent.getChildCount();
- for (int i = 0; i < childCount; i++) {
- final View child = parent.getChildAt(i);
- parent.getLayoutManager().getDecoratedBoundsWithMargins(child, mBounds);
- final int right = mBounds.right + Math.round(child.getTranslationX());
- final int left = right - mDivider.getIntrinsicWidth();
- mDivider.setBounds(left, top, right, bottom);
- mDivider.draw(canvas);
- }
- canvas.restore();
- }
-
- @Override
- @SuppressLint("UnknownNullness") // b/240775049: Cannot annotate properly
- public void getItemOffsets(Rect outRect, View view, RecyclerView parent,
- RecyclerView.State state) {
- if (mDivider == null) {
- outRect.set(0, 0, 0, 0);
- return;
- }
- if (mOrientation == VERTICAL) {
- outRect.set(0, 0, 0, mDivider.getIntrinsicHeight());
- } else {
- outRect.set(0, 0, mDivider.getIntrinsicWidth(), 0);
- }
- }
-}
diff --git a/app/src/main/java/androidx/recyclerview/widget/FastScroller.java b/app/src/main/java/androidx/recyclerview/widget/FastScroller.java
deleted file mode 100644
index 180adcc54a..0000000000
--- a/app/src/main/java/androidx/recyclerview/widget/FastScroller.java
+++ /dev/null
@@ -1,588 +0,0 @@
-/*
- * Copyright 2018 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package androidx.recyclerview.widget;
-
-import android.animation.Animator;
-import android.animation.AnimatorListenerAdapter;
-import android.animation.ValueAnimator;
-import android.animation.ValueAnimator.AnimatorUpdateListener;
-import android.graphics.Canvas;
-import android.graphics.drawable.Drawable;
-import android.graphics.drawable.StateListDrawable;
-import android.view.MotionEvent;
-
-import androidx.annotation.IntDef;
-import androidx.annotation.NonNull;
-import androidx.annotation.Nullable;
-import androidx.annotation.VisibleForTesting;
-import androidx.core.view.ViewCompat;
-
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-
-/**
- * Class responsible to animate and provide a fast scroller.
- */
-@VisibleForTesting
-class FastScroller extends RecyclerView.ItemDecoration implements RecyclerView.OnItemTouchListener {
- @IntDef({STATE_HIDDEN, STATE_VISIBLE, STATE_DRAGGING})
- @Retention(RetentionPolicy.SOURCE)
- private @interface State { }
- // Scroll thumb not showing
- private static final int STATE_HIDDEN = 0;
- // Scroll thumb visible and moving along with the scrollbar
- private static final int STATE_VISIBLE = 1;
- // Scroll thumb being dragged by user
- private static final int STATE_DRAGGING = 2;
-
- @IntDef({DRAG_X, DRAG_Y, DRAG_NONE})
- @Retention(RetentionPolicy.SOURCE)
- private @interface DragState{ }
- private static final int DRAG_NONE = 0;
- private static final int DRAG_X = 1;
- private static final int DRAG_Y = 2;
-
- @IntDef({ANIMATION_STATE_OUT, ANIMATION_STATE_FADING_IN, ANIMATION_STATE_IN,
- ANIMATION_STATE_FADING_OUT})
- @Retention(RetentionPolicy.SOURCE)
- private @interface AnimationState { }
- private static final int ANIMATION_STATE_OUT = 0;
- private static final int ANIMATION_STATE_FADING_IN = 1;
- private static final int ANIMATION_STATE_IN = 2;
- private static final int ANIMATION_STATE_FADING_OUT = 3;
-
- private static final int SHOW_DURATION_MS = 500;
- private static final int HIDE_DELAY_AFTER_VISIBLE_MS = 1500;
- private static final int HIDE_DELAY_AFTER_DRAGGING_MS = 1200;
- private static final int HIDE_DURATION_MS = 500;
- private static final int SCROLLBAR_FULL_OPAQUE = 255;
-
- private static final int[] PRESSED_STATE_SET = new int[]{android.R.attr.state_pressed};
- private static final int[] EMPTY_STATE_SET = new int[]{};
-
- private final int mScrollbarMinimumRange;
- private final int mMargin;
-
- // Final values for the vertical scroll bar
- @SuppressWarnings("WeakerAccess") /* synthetic access */
- final StateListDrawable mVerticalThumbDrawable;
- @SuppressWarnings("WeakerAccess") /* synthetic access */
- final Drawable mVerticalTrackDrawable;
- private final int mVerticalThumbWidth;
- private final int mVerticalTrackWidth;
-
- // Final values for the horizontal scroll bar
- private final StateListDrawable mHorizontalThumbDrawable;
- private final Drawable mHorizontalTrackDrawable;
- private final int mHorizontalThumbHeight;
- private final int mHorizontalTrackHeight;
-
- // Dynamic values for the vertical scroll bar
- @VisibleForTesting int mVerticalThumbHeight;
- @VisibleForTesting int mVerticalThumbCenterY;
- @VisibleForTesting float mVerticalDragY;
-
- // Dynamic values for the horizontal scroll bar
- @VisibleForTesting int mHorizontalThumbWidth;
- @VisibleForTesting int mHorizontalThumbCenterX;
- @VisibleForTesting float mHorizontalDragX;
-
- private int mRecyclerViewWidth = 0;
- private int mRecyclerViewHeight = 0;
-
- private RecyclerView mRecyclerView;
- /**
- * Whether the document is long/wide enough to require scrolling. If not, we don't show the
- * relevant scroller.
- */
- private boolean mNeedVerticalScrollbar = false;
- private boolean mNeedHorizontalScrollbar = false;
- @State private int mState = STATE_HIDDEN;
- @DragState private int mDragState = DRAG_NONE;
-
- private final int[] mVerticalRange = new int[2];
- private final int[] mHorizontalRange = new int[2];
- @SuppressWarnings("WeakerAccess") /* synthetic access */
- final ValueAnimator mShowHideAnimator = ValueAnimator.ofFloat(0, 1);
- @SuppressWarnings("WeakerAccess") /* synthetic access */
- @AnimationState int mAnimationState = ANIMATION_STATE_OUT;
- private final Runnable mHideRunnable = new Runnable() {
- @Override
- public void run() {
- hide(HIDE_DURATION_MS);
- }
- };
- private final RecyclerView.OnScrollListener
- mOnScrollListener = new RecyclerView.OnScrollListener() {
- @Override
- public void onScrolled(RecyclerView recyclerView, int dx, int dy) {
- updateScrollPosition(recyclerView.computeHorizontalScrollOffset(),
- recyclerView.computeVerticalScrollOffset());
- }
- };
-
- FastScroller(RecyclerView recyclerView, StateListDrawable verticalThumbDrawable,
- Drawable verticalTrackDrawable, StateListDrawable horizontalThumbDrawable,
- Drawable horizontalTrackDrawable, int defaultWidth, int scrollbarMinimumRange,
- int margin) {
- mVerticalThumbDrawable = verticalThumbDrawable;
- mVerticalTrackDrawable = verticalTrackDrawable;
- mHorizontalThumbDrawable = horizontalThumbDrawable;
- mHorizontalTrackDrawable = horizontalTrackDrawable;
- mVerticalThumbWidth = Math.max(defaultWidth, verticalThumbDrawable.getIntrinsicWidth());
- mVerticalTrackWidth = Math.max(defaultWidth, verticalTrackDrawable.getIntrinsicWidth());
- mHorizontalThumbHeight = Math
- .max(defaultWidth, horizontalThumbDrawable.getIntrinsicWidth());
- mHorizontalTrackHeight = Math
- .max(defaultWidth, horizontalTrackDrawable.getIntrinsicWidth());
- mScrollbarMinimumRange = scrollbarMinimumRange;
- mMargin = margin;
- mVerticalThumbDrawable.setAlpha(SCROLLBAR_FULL_OPAQUE);
- mVerticalTrackDrawable.setAlpha(SCROLLBAR_FULL_OPAQUE);
-
- mShowHideAnimator.addListener(new AnimatorListener());
- mShowHideAnimator.addUpdateListener(new AnimatorUpdater());
-
- attachToRecyclerView(recyclerView);
- }
-
- public void attachToRecyclerView(@Nullable RecyclerView recyclerView) {
- if (mRecyclerView == recyclerView) {
- return; // nothing to do
- }
- if (mRecyclerView != null) {
- destroyCallbacks();
- }
- mRecyclerView = recyclerView;
- if (mRecyclerView != null) {
- setupCallbacks();
- }
- }
-
- private void setupCallbacks() {
- mRecyclerView.addItemDecoration(this);
- mRecyclerView.addOnItemTouchListener(this);
- mRecyclerView.addOnScrollListener(mOnScrollListener);
- }
-
- private void destroyCallbacks() {
- mRecyclerView.removeItemDecoration(this);
- mRecyclerView.removeOnItemTouchListener(this);
- mRecyclerView.removeOnScrollListener(mOnScrollListener);
- cancelHide();
- }
-
- @SuppressWarnings("WeakerAccess") /* synthetic access */
- void requestRedraw() {
- mRecyclerView.invalidate();
- }
-
- void setState(@State int state) {
- if (state == STATE_DRAGGING && mState != STATE_DRAGGING) {
- mVerticalThumbDrawable.setState(PRESSED_STATE_SET);
- cancelHide();
- }
-
- if (state == STATE_HIDDEN) {
- requestRedraw();
- } else {
- show();
- }
-
- if (mState == STATE_DRAGGING && state != STATE_DRAGGING) {
- mVerticalThumbDrawable.setState(EMPTY_STATE_SET);
- resetHideDelay(HIDE_DELAY_AFTER_DRAGGING_MS);
- } else if (state == STATE_VISIBLE) {
- resetHideDelay(HIDE_DELAY_AFTER_VISIBLE_MS);
- }
- mState = state;
- }
-
- private boolean isLayoutRTL() {
- return ViewCompat.getLayoutDirection(mRecyclerView) == ViewCompat.LAYOUT_DIRECTION_RTL;
- }
-
- public boolean isDragging() {
- return mState == STATE_DRAGGING;
- }
-
- @VisibleForTesting boolean isVisible() {
- return mState == STATE_VISIBLE;
- }
-
- public void show() {
- switch (mAnimationState) {
- case ANIMATION_STATE_FADING_OUT:
- mShowHideAnimator.cancel();
- // fall through
- case ANIMATION_STATE_OUT:
- mAnimationState = ANIMATION_STATE_FADING_IN;
- mShowHideAnimator.setFloatValues((float) mShowHideAnimator.getAnimatedValue(), 1);
- mShowHideAnimator.setDuration(SHOW_DURATION_MS);
- mShowHideAnimator.setStartDelay(0);
- mShowHideAnimator.start();
- break;
- }
- }
-
- @VisibleForTesting
- void hide(int duration) {
- switch (mAnimationState) {
- case ANIMATION_STATE_FADING_IN:
- mShowHideAnimator.cancel();
- // fall through
- case ANIMATION_STATE_IN:
- mAnimationState = ANIMATION_STATE_FADING_OUT;
- mShowHideAnimator.setFloatValues((float) mShowHideAnimator.getAnimatedValue(), 0);
- mShowHideAnimator.setDuration(duration);
- mShowHideAnimator.start();
- break;
- }
- }
-
- private void cancelHide() {
- mRecyclerView.removeCallbacks(mHideRunnable);
- }
-
- private void resetHideDelay(int delay) {
- cancelHide();
- mRecyclerView.postDelayed(mHideRunnable, delay);
- }
-
- @Override
- public void onDrawOver(Canvas canvas, RecyclerView parent, RecyclerView.State state) {
- if (mRecyclerViewWidth != mRecyclerView.getWidth()
- || mRecyclerViewHeight != mRecyclerView.getHeight()) {
- mRecyclerViewWidth = mRecyclerView.getWidth();
- mRecyclerViewHeight = mRecyclerView.getHeight();
- // This is due to the different events ordering when keyboard is opened or
- // retracted vs rotate. Hence to avoid corner cases we just disable the
- // scroller when size changed, and wait until the scroll position is recomputed
- // before showing it back.
- setState(STATE_HIDDEN);
- return;
- }
-
- if (mAnimationState != ANIMATION_STATE_OUT) {
- if (mNeedVerticalScrollbar) {
- drawVerticalScrollbar(canvas);
- }
- if (mNeedHorizontalScrollbar) {
- drawHorizontalScrollbar(canvas);
- }
- }
- }
-
- private void drawVerticalScrollbar(Canvas canvas) {
- int viewWidth = mRecyclerViewWidth;
-
- int left = viewWidth - mVerticalThumbWidth;
- int top = mVerticalThumbCenterY - mVerticalThumbHeight / 2;
- mVerticalThumbDrawable.setBounds(0, 0, mVerticalThumbWidth, mVerticalThumbHeight);
- mVerticalTrackDrawable
- .setBounds(0, 0, mVerticalTrackWidth, mRecyclerViewHeight);
-
- if (isLayoutRTL()) {
- mVerticalTrackDrawable.draw(canvas);
- canvas.translate(mVerticalThumbWidth, top);
- canvas.scale(-1, 1);
- mVerticalThumbDrawable.draw(canvas);
- canvas.scale(-1, 1);
- canvas.translate(-mVerticalThumbWidth, -top);
- } else {
- canvas.translate(left, 0);
- mVerticalTrackDrawable.draw(canvas);
- canvas.translate(0, top);
- mVerticalThumbDrawable.draw(canvas);
- canvas.translate(-left, -top);
- }
- }
-
- private void drawHorizontalScrollbar(Canvas canvas) {
- int viewHeight = mRecyclerViewHeight;
-
- int top = viewHeight - mHorizontalThumbHeight;
- int left = mHorizontalThumbCenterX - mHorizontalThumbWidth / 2;
- mHorizontalThumbDrawable.setBounds(0, 0, mHorizontalThumbWidth, mHorizontalThumbHeight);
- mHorizontalTrackDrawable
- .setBounds(0, 0, mRecyclerViewWidth, mHorizontalTrackHeight);
-
- canvas.translate(0, top);
- mHorizontalTrackDrawable.draw(canvas);
- canvas.translate(left, 0);
- mHorizontalThumbDrawable.draw(canvas);
- canvas.translate(-left, -top);
- }
-
- /**
- * Notify the scroller of external change of the scroll, e.g. through dragging or flinging on
- * the view itself.
- *
- * @param offsetX The new scroll X offset.
- * @param offsetY The new scroll Y offset.
- */
- void updateScrollPosition(int offsetX, int offsetY) {
- int verticalContentLength = mRecyclerView.computeVerticalScrollRange();
- int verticalVisibleLength = mRecyclerViewHeight;
- mNeedVerticalScrollbar = verticalContentLength - verticalVisibleLength > 0
- && mRecyclerViewHeight >= mScrollbarMinimumRange;
-
- int horizontalContentLength = mRecyclerView.computeHorizontalScrollRange();
- int horizontalVisibleLength = mRecyclerViewWidth;
- mNeedHorizontalScrollbar = horizontalContentLength - horizontalVisibleLength > 0
- && mRecyclerViewWidth >= mScrollbarMinimumRange;
-
- if (!mNeedVerticalScrollbar && !mNeedHorizontalScrollbar) {
- if (mState != STATE_HIDDEN) {
- setState(STATE_HIDDEN);
- }
- return;
- }
-
- if (mNeedVerticalScrollbar) {
- float middleScreenPos = offsetY + verticalVisibleLength / 2.0f;
- mVerticalThumbCenterY =
- (int) ((verticalVisibleLength * middleScreenPos) / verticalContentLength);
- mVerticalThumbHeight = Math.min(verticalVisibleLength,
- (verticalVisibleLength * verticalVisibleLength) / verticalContentLength);
- }
-
- if (mNeedHorizontalScrollbar) {
- float middleScreenPos = offsetX + horizontalVisibleLength / 2.0f;
- mHorizontalThumbCenterX =
- (int) ((horizontalVisibleLength * middleScreenPos) / horizontalContentLength);
- mHorizontalThumbWidth = Math.min(horizontalVisibleLength,
- (horizontalVisibleLength * horizontalVisibleLength) / horizontalContentLength);
- }
-
- if (mState == STATE_HIDDEN || mState == STATE_VISIBLE) {
- setState(STATE_VISIBLE);
- }
- }
-
- @Override
- public boolean onInterceptTouchEvent(@NonNull RecyclerView recyclerView,
- @NonNull MotionEvent ev) {
- final boolean handled;
- if (mState == STATE_VISIBLE) {
- boolean insideVerticalThumb = isPointInsideVerticalThumb(ev.getX(), ev.getY());
- boolean insideHorizontalThumb = isPointInsideHorizontalThumb(ev.getX(), ev.getY());
- if (ev.getAction() == MotionEvent.ACTION_DOWN
- && (insideVerticalThumb || insideHorizontalThumb)) {
- if (insideHorizontalThumb) {
- mDragState = DRAG_X;
- mHorizontalDragX = (int) ev.getX();
- } else if (insideVerticalThumb) {
- mDragState = DRAG_Y;
- mVerticalDragY = (int) ev.getY();
- }
-
- setState(STATE_DRAGGING);
- handled = true;
- } else {
- handled = false;
- }
- } else if (mState == STATE_DRAGGING) {
- handled = true;
- } else {
- handled = false;
- }
- return handled;
- }
-
- @Override
- public void onTouchEvent(@NonNull RecyclerView recyclerView, @NonNull MotionEvent me) {
- if (mState == STATE_HIDDEN) {
- return;
- }
-
- if (me.getAction() == MotionEvent.ACTION_DOWN) {
- boolean insideVerticalThumb = isPointInsideVerticalThumb(me.getX(), me.getY());
- boolean insideHorizontalThumb = isPointInsideHorizontalThumb(me.getX(), me.getY());
- if (insideVerticalThumb || insideHorizontalThumb) {
- if (insideHorizontalThumb) {
- mDragState = DRAG_X;
- mHorizontalDragX = (int) me.getX();
- } else if (insideVerticalThumb) {
- mDragState = DRAG_Y;
- mVerticalDragY = (int) me.getY();
- }
- setState(STATE_DRAGGING);
- }
- } else if (me.getAction() == MotionEvent.ACTION_UP && mState == STATE_DRAGGING) {
- mVerticalDragY = 0;
- mHorizontalDragX = 0;
- setState(STATE_VISIBLE);
- mDragState = DRAG_NONE;
- } else if (me.getAction() == MotionEvent.ACTION_MOVE && mState == STATE_DRAGGING) {
- show();
- if (mDragState == DRAG_X) {
- horizontalScrollTo(me.getX());
- }
- if (mDragState == DRAG_Y) {
- verticalScrollTo(me.getY());
- }
- }
- }
-
- @Override
- public void onRequestDisallowInterceptTouchEvent(boolean disallowIntercept) { }
-
- private void verticalScrollTo(float y) {
- final int[] scrollbarRange = getVerticalRange();
- y = Math.max(scrollbarRange[0], Math.min(scrollbarRange[1], y));
- if (Math.abs(mVerticalThumbCenterY - y) < 2) {
- return;
- }
- int scrollingBy = scrollTo(mVerticalDragY, y, scrollbarRange,
- mRecyclerView.computeVerticalScrollRange(),
- mRecyclerView.computeVerticalScrollOffset(), mRecyclerViewHeight);
- if (scrollingBy != 0) {
- mRecyclerView.scrollBy(0, scrollingBy);
- }
- mVerticalDragY = y;
- }
-
- private void horizontalScrollTo(float x) {
- final int[] scrollbarRange = getHorizontalRange();
- x = Math.max(scrollbarRange[0], Math.min(scrollbarRange[1], x));
- if (Math.abs(mHorizontalThumbCenterX - x) < 2) {
- return;
- }
-
- int scrollingBy = scrollTo(mHorizontalDragX, x, scrollbarRange,
- mRecyclerView.computeHorizontalScrollRange(),
- mRecyclerView.computeHorizontalScrollOffset(), mRecyclerViewWidth);
- if (scrollingBy != 0) {
- mRecyclerView.scrollBy(scrollingBy, 0);
- }
-
- mHorizontalDragX = x;
- }
-
- private int scrollTo(float oldDragPos, float newDragPos, int[] scrollbarRange, int scrollRange,
- int scrollOffset, int viewLength) {
- int scrollbarLength = scrollbarRange[1] - scrollbarRange[0];
- if (scrollbarLength == 0) {
- return 0;
- }
- float percentage = ((newDragPos - oldDragPos) / (float) scrollbarLength);
- int totalPossibleOffset = scrollRange - viewLength;
- int scrollingBy = (int) (percentage * totalPossibleOffset);
- int absoluteOffset = scrollOffset + scrollingBy;
- if (absoluteOffset < totalPossibleOffset && absoluteOffset >= 0) {
- return scrollingBy;
- } else {
- return 0;
- }
- }
-
- @VisibleForTesting
- boolean isPointInsideVerticalThumb(float x, float y) {
- return (isLayoutRTL() ? x <= mVerticalThumbWidth
- : x >= mRecyclerViewWidth - mVerticalThumbWidth)
- && y >= mVerticalThumbCenterY - mVerticalThumbHeight / 2
- && y <= mVerticalThumbCenterY + mVerticalThumbHeight / 2;
- }
-
- @VisibleForTesting
- boolean isPointInsideHorizontalThumb(float x, float y) {
- return (y >= mRecyclerViewHeight - mHorizontalThumbHeight)
- && x >= mHorizontalThumbCenterX - mHorizontalThumbWidth / 2
- && x <= mHorizontalThumbCenterX + mHorizontalThumbWidth / 2;
- }
-
- @VisibleForTesting
- Drawable getHorizontalTrackDrawable() {
- return mHorizontalTrackDrawable;
- }
-
- @VisibleForTesting
- Drawable getHorizontalThumbDrawable() {
- return mHorizontalThumbDrawable;
- }
-
- @VisibleForTesting
- Drawable getVerticalTrackDrawable() {
- return mVerticalTrackDrawable;
- }
-
- @VisibleForTesting
- Drawable getVerticalThumbDrawable() {
- return mVerticalThumbDrawable;
- }
-
- /**
- * Gets the (min, max) vertical positions of the vertical scroll bar.
- */
- private int[] getVerticalRange() {
- mVerticalRange[0] = mMargin;
- mVerticalRange[1] = mRecyclerViewHeight - mMargin;
- return mVerticalRange;
- }
-
- /**
- * Gets the (min, max) horizontal positions of the horizontal scroll bar.
- */
- private int[] getHorizontalRange() {
- mHorizontalRange[0] = mMargin;
- mHorizontalRange[1] = mRecyclerViewWidth - mMargin;
- return mHorizontalRange;
- }
-
- private class AnimatorListener extends AnimatorListenerAdapter {
-
- private boolean mCanceled = false;
-
- AnimatorListener() {
- }
-
- @Override
- public void onAnimationEnd(Animator animation) {
- // Cancel is always followed by a new directive, so don't update state.
- if (mCanceled) {
- mCanceled = false;
- return;
- }
- if ((float) mShowHideAnimator.getAnimatedValue() == 0) {
- mAnimationState = ANIMATION_STATE_OUT;
- setState(STATE_HIDDEN);
- } else {
- mAnimationState = ANIMATION_STATE_IN;
- requestRedraw();
- }
- }
-
- @Override
- public void onAnimationCancel(Animator animation) {
- mCanceled = true;
- }
- }
-
- private class AnimatorUpdater implements AnimatorUpdateListener {
- AnimatorUpdater() {
- }
-
- @Override
- public void onAnimationUpdate(ValueAnimator valueAnimator) {
- int alpha = (int) (SCROLLBAR_FULL_OPAQUE * ((float) valueAnimator.getAnimatedValue()));
- mVerticalThumbDrawable.setAlpha(alpha);
- mVerticalTrackDrawable.setAlpha(alpha);
- requestRedraw();
- }
- }
-}
diff --git a/app/src/main/java/androidx/recyclerview/widget/GapWorker.java b/app/src/main/java/androidx/recyclerview/widget/GapWorker.java
deleted file mode 100644
index 5bbdcf1b48..0000000000
--- a/app/src/main/java/androidx/recyclerview/widget/GapWorker.java
+++ /dev/null
@@ -1,407 +0,0 @@
-/*
- * Copyright 2018 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package androidx.recyclerview.widget;
-
-import android.annotation.SuppressLint;
-import android.view.View;
-
-import androidx.annotation.Nullable;
-import androidx.core.os.TraceCompat;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.Comparator;
-import java.util.concurrent.TimeUnit;
-
-final class GapWorker implements Runnable {
-
- static final ThreadLocal sGapWorker = new ThreadLocal<>();
-
- ArrayList mRecyclerViews = new ArrayList<>();
- long mPostTimeNs;
- long mFrameIntervalNs;
-
- static class Task {
- public boolean immediate;
- public int viewVelocity;
- public int distanceToItem;
- public RecyclerView view;
- public int position;
-
- public void clear() {
- immediate = false;
- viewVelocity = 0;
- distanceToItem = 0;
- view = null;
- position = 0;
- }
- }
-
- /**
- * Temporary storage for prefetch Tasks that execute in {@link #prefetch(long)}. Task objects
- * are pooled in the ArrayList, and never removed to avoid allocations, but always cleared
- * in between calls.
- */
- private ArrayList mTasks = new ArrayList<>();
-
- /**
- * Prefetch information associated with a specific RecyclerView.
- */
- @SuppressLint("VisibleForTests")
- static class LayoutPrefetchRegistryImpl
- implements RecyclerView.LayoutManager.LayoutPrefetchRegistry {
- int mPrefetchDx;
- int mPrefetchDy;
- int[] mPrefetchArray;
-
- int mCount;
-
- void setPrefetchVector(int dx, int dy) {
- mPrefetchDx = dx;
- mPrefetchDy = dy;
- }
-
- void collectPrefetchPositionsFromView(RecyclerView view, boolean nested) {
- mCount = 0;
- if (mPrefetchArray != null) {
- Arrays.fill(mPrefetchArray, -1);
- }
-
- final RecyclerView.LayoutManager layout = view.mLayout;
- if (view.mAdapter != null
- && layout != null
- && layout.isItemPrefetchEnabled()) {
- if (nested) {
- // nested prefetch, only if no adapter updates pending. Note: we don't query
- // view.hasPendingAdapterUpdates(), as first layout may not have occurred
- if (!view.mAdapterHelper.hasPendingUpdates()) {
- layout.collectInitialPrefetchPositions(view.mAdapter.getItemCount(), this);
- }
- } else {
- // momentum based prefetch, only if we trust current child/adapter state
- if (!view.hasPendingAdapterUpdates()) {
- layout.collectAdjacentPrefetchPositions(mPrefetchDx, mPrefetchDy,
- view.mState, this);
- }
- }
-
- if (mCount > layout.mPrefetchMaxCountObserved) {
- layout.mPrefetchMaxCountObserved = mCount;
- layout.mPrefetchMaxObservedInInitialPrefetch = nested;
- view.mRecycler.updateViewCacheSize();
- }
- }
- }
-
- @Override
- public void addPosition(int layoutPosition, int pixelDistance) {
- if (layoutPosition < 0) {
- throw new IllegalArgumentException("Layout positions must be non-negative");
- }
-
- if (pixelDistance < 0) {
- throw new IllegalArgumentException("Pixel distance must be non-negative");
- }
-
- // allocate or expand array as needed, doubling when needed
- final int storagePosition = mCount * 2;
- if (mPrefetchArray == null) {
- mPrefetchArray = new int[4];
- Arrays.fill(mPrefetchArray, -1);
- } else if (storagePosition >= mPrefetchArray.length) {
- final int[] oldArray = mPrefetchArray;
- mPrefetchArray = new int[storagePosition * 2];
- System.arraycopy(oldArray, 0, mPrefetchArray, 0, oldArray.length);
- }
-
- // add position
- mPrefetchArray[storagePosition] = layoutPosition;
- mPrefetchArray[storagePosition + 1] = pixelDistance;
-
- mCount++;
- }
-
- boolean lastPrefetchIncludedPosition(int position) {
- if (mPrefetchArray != null) {
- final int count = mCount * 2;
- for (int i = 0; i < count; i += 2) {
- if (mPrefetchArray[i] == position) return true;
- }
- }
- return false;
- }
-
- /**
- * Called when prefetch indices are no longer valid for cache prioritization.
- */
- void clearPrefetchPositions() {
- if (mPrefetchArray != null) {
- Arrays.fill(mPrefetchArray, -1);
- }
- mCount = 0;
- }
- }
-
- public void add(RecyclerView recyclerView) {
- if (RecyclerView.sDebugAssertionsEnabled && mRecyclerViews.contains(recyclerView)) {
- throw new IllegalStateException("RecyclerView already present in worker list!");
- }
- mRecyclerViews.add(recyclerView);
- }
-
- public void remove(RecyclerView recyclerView) {
- boolean removeSuccess = mRecyclerViews.remove(recyclerView);
- if (RecyclerView.sDebugAssertionsEnabled && !removeSuccess) {
- throw new IllegalStateException("RecyclerView removal failed!");
- }
- }
-
- /**
- * Schedule a prefetch immediately after the current traversal.
- */
- void postFromTraversal(RecyclerView recyclerView, int prefetchDx, int prefetchDy) {
- if (recyclerView.isAttachedToWindow()) {
- if (RecyclerView.sDebugAssertionsEnabled && !mRecyclerViews.contains(recyclerView)) {
- throw new IllegalStateException("attempting to post unregistered view!");
- }
- if (mPostTimeNs == 0) {
- mPostTimeNs = recyclerView.getNanoTime();
- recyclerView.post(this);
- }
- }
-
- recyclerView.mPrefetchRegistry.setPrefetchVector(prefetchDx, prefetchDy);
- }
-
- static Comparator sTaskComparator = new Comparator() {
- @Override
- public int compare(Task lhs, Task rhs) {
- // first, prioritize non-cleared tasks
- if ((lhs.view == null) != (rhs.view == null)) {
- return lhs.view == null ? 1 : -1;
- }
-
- // then prioritize immediate
- if (lhs.immediate != rhs.immediate) {
- return lhs.immediate ? -1 : 1;
- }
-
- // then prioritize _highest_ view velocity
- int deltaViewVelocity = rhs.viewVelocity - lhs.viewVelocity;
- if (deltaViewVelocity != 0) return deltaViewVelocity;
-
- // then prioritize _lowest_ distance to item
- int deltaDistanceToItem = lhs.distanceToItem - rhs.distanceToItem;
- if (deltaDistanceToItem != 0) return deltaDistanceToItem;
-
- return 0;
- }
- };
-
- private void buildTaskList() {
- // Update PrefetchRegistry in each view
- final int viewCount = mRecyclerViews.size();
- int totalTaskCount = 0;
- for (int i = 0; i < viewCount; i++) {
- RecyclerView view = mRecyclerViews.get(i);
- if (view.getWindowVisibility() == View.VISIBLE) {
- view.mPrefetchRegistry.collectPrefetchPositionsFromView(view, false);
- totalTaskCount += view.mPrefetchRegistry.mCount;
- }
- }
-
- // Populate task list from prefetch data...
- mTasks.ensureCapacity(totalTaskCount);
- int totalTaskIndex = 0;
- for (int i = 0; i < viewCount; i++) {
- RecyclerView view = mRecyclerViews.get(i);
- if (view.getWindowVisibility() != View.VISIBLE) {
- // Invisible view, don't bother prefetching
- continue;
- }
-
- LayoutPrefetchRegistryImpl prefetchRegistry = view.mPrefetchRegistry;
- final int viewVelocity = Math.abs(prefetchRegistry.mPrefetchDx)
- + Math.abs(prefetchRegistry.mPrefetchDy);
- for (int j = 0; j < prefetchRegistry.mCount * 2; j += 2) {
- final Task task;
- if (totalTaskIndex >= mTasks.size()) {
- task = new Task();
- mTasks.add(task);
- } else {
- task = mTasks.get(totalTaskIndex);
- }
- final int distanceToItem = prefetchRegistry.mPrefetchArray[j + 1];
-
- task.immediate = distanceToItem <= viewVelocity;
- task.viewVelocity = viewVelocity;
- task.distanceToItem = distanceToItem;
- task.view = view;
- task.position = prefetchRegistry.mPrefetchArray[j];
-
- totalTaskIndex++;
- }
- }
-
- // ... and priority sort
- Collections.sort(mTasks, sTaskComparator);
- }
-
- static boolean isPrefetchPositionAttached(RecyclerView view, int position) {
- final int childCount = view.mChildHelper.getUnfilteredChildCount();
- for (int i = 0; i < childCount; i++) {
- View attachedView = view.mChildHelper.getUnfilteredChildAt(i);
- RecyclerView.ViewHolder holder = RecyclerView.getChildViewHolderInt(attachedView);
- // Note: can use mPosition here because adapter doesn't have pending updates
- if (holder.mPosition == position && !holder.isInvalid()) {
- return true;
- }
- }
- return false;
- }
-
- private RecyclerView.ViewHolder prefetchPositionWithDeadline(RecyclerView view,
- int position, long deadlineNs) {
- if (isPrefetchPositionAttached(view, position)) {
- // don't attempt to prefetch attached views
- return null;
- }
-
- RecyclerView.Recycler recycler = view.mRecycler;
- RecyclerView.ViewHolder holder;
- try {
- view.onEnterLayoutOrScroll();
- holder = recycler.tryGetViewHolderForPositionByDeadline(
- position, false, deadlineNs);
-
- if (holder != null) {
- if (holder.isBound() && !holder.isInvalid()) {
- // Only give the view a chance to go into the cache if binding succeeded
- // Note that we must use public method, since item may need cleanup
- recycler.recycleView(holder.itemView);
- } else {
- // Didn't bind, so we can't cache the view, but it will stay in the pool until
- // next prefetch/traversal. If a View fails to bind, it means we didn't have
- // enough time prior to the deadline (and won't for other instances of this
- // type, during this GapWorker prefetch pass).
- recycler.addViewHolderToRecycledViewPool(holder, false);
- }
- }
- } finally {
- view.onExitLayoutOrScroll(false);
- }
- return holder;
- }
-
- private void prefetchInnerRecyclerViewWithDeadline(@Nullable RecyclerView innerView,
- long deadlineNs) {
- if (innerView == null) {
- return;
- }
-
- if (innerView.mDataSetHasChangedAfterLayout
- && innerView.mChildHelper.getUnfilteredChildCount() != 0) {
- // RecyclerView has new data, but old attached views. Clear everything, so that
- // we can prefetch without partially stale data.
- innerView.removeAndRecycleViews();
- }
-
- // do nested prefetch!
- final LayoutPrefetchRegistryImpl innerPrefetchRegistry = innerView.mPrefetchRegistry;
- innerPrefetchRegistry.collectPrefetchPositionsFromView(innerView, true);
-
- if (innerPrefetchRegistry.mCount != 0) {
- try {
- TraceCompat.beginSection(RecyclerView.TRACE_NESTED_PREFETCH_TAG);
- innerView.mState.prepareForNestedPrefetch(innerView.mAdapter);
- for (int i = 0; i < innerPrefetchRegistry.mCount * 2; i += 2) {
- // Note that we ignore immediate flag for inner items because
- // we have lower confidence they're needed next frame.
- final int innerPosition = innerPrefetchRegistry.mPrefetchArray[i];
- prefetchPositionWithDeadline(innerView, innerPosition, deadlineNs);
- }
- } finally {
- TraceCompat.endSection();
- }
- }
- }
-
- private void flushTaskWithDeadline(Task task, long deadlineNs) {
- long taskDeadlineNs = task.immediate ? RecyclerView.FOREVER_NS : deadlineNs;
- RecyclerView.ViewHolder holder = prefetchPositionWithDeadline(task.view,
- task.position, taskDeadlineNs);
- if (holder != null
- && holder.mNestedRecyclerView != null
- && holder.isBound()
- && !holder.isInvalid()) {
- prefetchInnerRecyclerViewWithDeadline(holder.mNestedRecyclerView.get(), deadlineNs);
- }
- }
-
- private void flushTasksWithDeadline(long deadlineNs) {
- for (int i = 0; i < mTasks.size(); i++) {
- final Task task = mTasks.get(i);
- if (task.view == null) {
- break; // done with populated tasks
- }
- flushTaskWithDeadline(task, deadlineNs);
- task.clear();
- }
- }
-
- void prefetch(long deadlineNs) {
- buildTaskList();
- flushTasksWithDeadline(deadlineNs);
- }
-
- @Override
- public void run() {
- try {
- TraceCompat.beginSection(RecyclerView.TRACE_PREFETCH_TAG);
-
- if (mRecyclerViews.isEmpty()) {
- // abort - no work to do
- return;
- }
-
- // Query most recent vsync so we can predict next one. Note that drawing time not yet
- // valid in animation/input callbacks, so query it here to be safe.
- final int size = mRecyclerViews.size();
- long latestFrameVsyncMs = 0;
- for (int i = 0; i < size; i++) {
- RecyclerView view = mRecyclerViews.get(i);
- if (view.getWindowVisibility() == View.VISIBLE) {
- latestFrameVsyncMs = Math.max(view.getDrawingTime(), latestFrameVsyncMs);
- }
- }
-
- if (latestFrameVsyncMs == 0) {
- // abort - either no views visible, or couldn't get last vsync for estimating next
- return;
- }
-
- long nextFrameNs = TimeUnit.MILLISECONDS.toNanos(latestFrameVsyncMs) + mFrameIntervalNs;
-
- prefetch(nextFrameNs);
-
- // TODO: consider rescheduling self, if there's more work to do
- } finally {
- mPostTimeNs = 0;
- TraceCompat.endSection();
- }
- }
-}
diff --git a/app/src/main/java/androidx/recyclerview/widget/GridLayoutManager.java b/app/src/main/java/androidx/recyclerview/widget/GridLayoutManager.java
deleted file mode 100644
index 01935b50c0..0000000000
--- a/app/src/main/java/androidx/recyclerview/widget/GridLayoutManager.java
+++ /dev/null
@@ -1,1450 +0,0 @@
-/*
- * Copyright 2018 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package androidx.recyclerview.widget;
-
-import android.content.Context;
-import android.graphics.Rect;
-import android.util.AttributeSet;
-import android.util.Log;
-import android.util.SparseIntArray;
-import android.view.View;
-import android.view.ViewGroup;
-import android.widget.GridView;
-
-import androidx.annotation.NonNull;
-import androidx.core.view.accessibility.AccessibilityNodeInfoCompat;
-
-import java.util.Arrays;
-
-/**
- * A {@link RecyclerView.LayoutManager} implementations that lays out items in a grid.
- *
- * By default, each item occupies 1 span. You can change it by providing a custom
- * {@link SpanSizeLookup} instance via {@link #setSpanSizeLookup(SpanSizeLookup)}.
- */
-public class GridLayoutManager extends LinearLayoutManager {
-
- private static final boolean DEBUG = false;
- private static final String TAG = "GridLayoutManager";
- public static final int DEFAULT_SPAN_COUNT = -1;
- /**
- * Span size have been changed but we've not done a new layout calculation.
- */
- boolean mPendingSpanCountChange = false;
- int mSpanCount = DEFAULT_SPAN_COUNT;
- /**
- * Right borders for each span.
- *
For i-th item start is {@link #mCachedBorders}[i-1] + 1
- * and end is {@link #mCachedBorders}[i].
- */
- int [] mCachedBorders;
- /**
- * Temporary array to keep views in layoutChunk method
- */
- View[] mSet;
- final SparseIntArray mPreLayoutSpanSizeCache = new SparseIntArray();
- final SparseIntArray mPreLayoutSpanIndexCache = new SparseIntArray();
- SpanSizeLookup mSpanSizeLookup = new DefaultSpanSizeLookup();
- // re-used variable to acquire decor insets from RecyclerView
- final Rect mDecorInsets = new Rect();
-
- private boolean mUsingSpansToEstimateScrollBarDimensions;
-
- /**
- * Constructor used when layout manager is set in XML by RecyclerView attribute
- * "layoutManager". If spanCount is not specified in the XML, it defaults to a
- * single column.
- *
- * {@link androidx.recyclerview.R.attr#spanCount}
- */
- public GridLayoutManager(Context context, AttributeSet attrs, int defStyleAttr,
- int defStyleRes) {
- super(context, attrs, defStyleAttr, defStyleRes);
- Properties properties = getProperties(context, attrs, defStyleAttr, defStyleRes);
- setSpanCount(properties.spanCount);
- }
-
- /**
- * Creates a vertical GridLayoutManager
- *
- * @param context Current context, will be used to access resources.
- * @param spanCount The number of columns in the grid
- */
- public GridLayoutManager(Context context, int spanCount) {
- super(context);
- setSpanCount(spanCount);
- }
-
- /**
- * @param context Current context, will be used to access resources.
- * @param spanCount The number of columns or rows in the grid
- * @param orientation Layout orientation. Should be {@link #HORIZONTAL} or {@link
- * #VERTICAL}.
- * @param reverseLayout When set to true, layouts from end to start.
- */
- public GridLayoutManager(Context context, int spanCount,
- @RecyclerView.Orientation int orientation, boolean reverseLayout) {
- super(context, orientation, reverseLayout);
- setSpanCount(spanCount);
- }
-
- /**
- * stackFromEnd is not supported by GridLayoutManager. Consider using
- * {@link #setReverseLayout(boolean)}.
- */
- @Override
- public void setStackFromEnd(boolean stackFromEnd) {
- if (stackFromEnd) {
- throw new UnsupportedOperationException(
- "GridLayoutManager does not support stack from end."
- + " Consider using reverse layout");
- }
- super.setStackFromEnd(false);
- }
-
- @Override
- public int getRowCountForAccessibility(RecyclerView.Recycler recycler,
- RecyclerView.State state) {
- if (mOrientation == HORIZONTAL) {
- return mSpanCount;
- }
- if (state.getItemCount() < 1) {
- return 0;
- }
-
- // Row count is one more than the last item's row index.
- return getSpanGroupIndex(recycler, state, state.getItemCount() - 1) + 1;
- }
-
- @Override
- public int getColumnCountForAccessibility(RecyclerView.Recycler recycler,
- RecyclerView.State state) {
- if (mOrientation == VERTICAL) {
- return mSpanCount;
- }
- if (state.getItemCount() < 1) {
- return 0;
- }
-
- // Column count is one more than the last item's column index.
- return getSpanGroupIndex(recycler, state, state.getItemCount() - 1) + 1;
- }
-
- @Override
- public void onInitializeAccessibilityNodeInfoForItem(RecyclerView.Recycler recycler,
- RecyclerView.State state, View host, AccessibilityNodeInfoCompat info) {
- ViewGroup.LayoutParams lp = host.getLayoutParams();
- if (!(lp instanceof LayoutParams)) {
- super.onInitializeAccessibilityNodeInfoForItem(host, info);
- return;
- }
- LayoutParams glp = (LayoutParams) lp;
- int spanGroupIndex = getSpanGroupIndex(recycler, state, glp.getViewLayoutPosition());
- if (mOrientation == HORIZONTAL) {
- info.setCollectionItemInfo(AccessibilityNodeInfoCompat.CollectionItemInfoCompat.obtain(
- glp.getSpanIndex(), glp.getSpanSize(),
- spanGroupIndex, 1, false, false));
- } else { // VERTICAL
- info.setCollectionItemInfo(AccessibilityNodeInfoCompat.CollectionItemInfoCompat.obtain(
- spanGroupIndex , 1,
- glp.getSpanIndex(), glp.getSpanSize(), false, false));
- }
- }
-
- @Override
- public void onInitializeAccessibilityNodeInfo(@NonNull RecyclerView.Recycler recycler,
- @NonNull RecyclerView.State state, @NonNull AccessibilityNodeInfoCompat info) {
- super.onInitializeAccessibilityNodeInfo(recycler, state, info);
- // Set the class name so this is treated as a grid. A11y services should identify grids
- // and list via CollectionInfos, but an almost empty grid may be incorrectly identified
- // as a list.
- info.setClassName(GridView.class.getName());
- }
-
- @Override
- public void onLayoutChildren(RecyclerView.Recycler recycler, RecyclerView.State state) {
- if (state.isPreLayout()) {
- cachePreLayoutSpanMapping();
- }
- super.onLayoutChildren(recycler, state);
- if (DEBUG) {
- validateChildOrder();
- }
- clearPreLayoutSpanMappingCache();
- }
-
- @Override
- public void onLayoutCompleted(RecyclerView.State state) {
- super.onLayoutCompleted(state);
- mPendingSpanCountChange = false;
- }
-
- private void clearPreLayoutSpanMappingCache() {
- mPreLayoutSpanSizeCache.clear();
- mPreLayoutSpanIndexCache.clear();
- }
-
- private void cachePreLayoutSpanMapping() {
- final int childCount = getChildCount();
- for (int i = 0; i < childCount; i++) {
- final LayoutParams lp = (LayoutParams) getChildAt(i).getLayoutParams();
- final int viewPosition = lp.getViewLayoutPosition();
- mPreLayoutSpanSizeCache.put(viewPosition, lp.getSpanSize());
- mPreLayoutSpanIndexCache.put(viewPosition, lp.getSpanIndex());
- }
- }
-
- @Override
- public void onItemsAdded(RecyclerView recyclerView, int positionStart, int itemCount) {
- mSpanSizeLookup.invalidateSpanIndexCache();
- mSpanSizeLookup.invalidateSpanGroupIndexCache();
- }
-
- @Override
- public void onItemsChanged(RecyclerView recyclerView) {
- mSpanSizeLookup.invalidateSpanIndexCache();
- mSpanSizeLookup.invalidateSpanGroupIndexCache();
- }
-
- @Override
- public void onItemsRemoved(RecyclerView recyclerView, int positionStart, int itemCount) {
- mSpanSizeLookup.invalidateSpanIndexCache();
- mSpanSizeLookup.invalidateSpanGroupIndexCache();
- }
-
- @Override
- public void onItemsUpdated(RecyclerView recyclerView, int positionStart, int itemCount,
- Object payload) {
- mSpanSizeLookup.invalidateSpanIndexCache();
- mSpanSizeLookup.invalidateSpanGroupIndexCache();
- }
-
- @Override
- public void onItemsMoved(RecyclerView recyclerView, int from, int to, int itemCount) {
- mSpanSizeLookup.invalidateSpanIndexCache();
- mSpanSizeLookup.invalidateSpanGroupIndexCache();
- }
-
- @Override
- public RecyclerView.LayoutParams generateDefaultLayoutParams() {
- if (mOrientation == HORIZONTAL) {
- return new LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT,
- ViewGroup.LayoutParams.MATCH_PARENT);
- } else {
- return new LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT,
- ViewGroup.LayoutParams.WRAP_CONTENT);
- }
- }
-
- @Override
- public RecyclerView.LayoutParams generateLayoutParams(Context c, AttributeSet attrs) {
- return new LayoutParams(c, attrs);
- }
-
- @Override
- public RecyclerView.LayoutParams generateLayoutParams(ViewGroup.LayoutParams lp) {
- if (lp instanceof ViewGroup.MarginLayoutParams) {
- return new LayoutParams((ViewGroup.MarginLayoutParams) lp);
- } else {
- return new LayoutParams(lp);
- }
- }
-
- @Override
- public boolean checkLayoutParams(RecyclerView.LayoutParams lp) {
- return lp instanceof LayoutParams;
- }
-
- /**
- * Sets the source to get the number of spans occupied by each item in the adapter.
- *
- * @param spanSizeLookup {@link SpanSizeLookup} instance to be used to query number of spans
- * occupied by each item
- */
- public void setSpanSizeLookup(SpanSizeLookup spanSizeLookup) {
- mSpanSizeLookup = spanSizeLookup;
- }
-
- /**
- * Returns the current {@link SpanSizeLookup} used by the GridLayoutManager.
- *
- * @return The current {@link SpanSizeLookup} used by the GridLayoutManager.
- */
- public SpanSizeLookup getSpanSizeLookup() {
- return mSpanSizeLookup;
- }
-
- private void updateMeasurements() {
- int totalSpace;
- if (getOrientation() == VERTICAL) {
- totalSpace = getWidth() - getPaddingRight() - getPaddingLeft();
- } else {
- totalSpace = getHeight() - getPaddingBottom() - getPaddingTop();
- }
- calculateItemBorders(totalSpace);
- }
-
- @Override
- public void setMeasuredDimension(Rect childrenBounds, int wSpec, int hSpec) {
- if (mCachedBorders == null) {
- super.setMeasuredDimension(childrenBounds, wSpec, hSpec);
- }
- final int width, height;
- final int horizontalPadding = getPaddingLeft() + getPaddingRight();
- final int verticalPadding = getPaddingTop() + getPaddingBottom();
- if (mOrientation == VERTICAL) {
- final int usedHeight = childrenBounds.height() + verticalPadding;
- height = chooseSize(hSpec, usedHeight, getMinimumHeight());
- width = chooseSize(wSpec, mCachedBorders[mCachedBorders.length - 1] + horizontalPadding,
- getMinimumWidth());
- } else {
- final int usedWidth = childrenBounds.width() + horizontalPadding;
- width = chooseSize(wSpec, usedWidth, getMinimumWidth());
- height = chooseSize(hSpec, mCachedBorders[mCachedBorders.length - 1] + verticalPadding,
- getMinimumHeight());
- }
- setMeasuredDimension(width, height);
- }
-
- /**
- * @param totalSpace Total available space after padding is removed
- */
- private void calculateItemBorders(int totalSpace) {
- mCachedBorders = calculateItemBorders(mCachedBorders, mSpanCount, totalSpace);
- }
-
- /**
- * @param cachedBorders The out array
- * @param spanCount number of spans
- * @param totalSpace total available space after padding is removed
- * @return The updated array. Might be the same instance as the provided array if its size
- * has not changed.
- */
- static int[] calculateItemBorders(int[] cachedBorders, int spanCount, int totalSpace) {
- if (cachedBorders == null || cachedBorders.length != spanCount + 1
- || cachedBorders[cachedBorders.length - 1] != totalSpace) {
- cachedBorders = new int[spanCount + 1];
- }
- cachedBorders[0] = 0;
- int sizePerSpan = totalSpace / spanCount;
- int sizePerSpanRemainder = totalSpace % spanCount;
- int consumedPixels = 0;
- int additionalSize = 0;
- for (int i = 1; i <= spanCount; i++) {
- int itemSize = sizePerSpan;
- additionalSize += sizePerSpanRemainder;
- if (additionalSize > 0 && (spanCount - additionalSize) < sizePerSpanRemainder) {
- itemSize += 1;
- additionalSize -= spanCount;
- }
- consumedPixels += itemSize;
- cachedBorders[i] = consumedPixels;
- }
- return cachedBorders;
- }
-
- int getSpaceForSpanRange(int startSpan, int spanSize) {
- if (mOrientation == VERTICAL && isLayoutRTL()) {
- return mCachedBorders[mSpanCount - startSpan]
- - mCachedBorders[mSpanCount - startSpan - spanSize];
- } else {
- return mCachedBorders[startSpan + spanSize] - mCachedBorders[startSpan];
- }
- }
-
- @Override
- void onAnchorReady(RecyclerView.Recycler recycler, RecyclerView.State state,
- AnchorInfo anchorInfo, int itemDirection) {
- super.onAnchorReady(recycler, state, anchorInfo, itemDirection);
- updateMeasurements();
- if (state.getItemCount() > 0 && !state.isPreLayout()) {
- ensureAnchorIsInCorrectSpan(recycler, state, anchorInfo, itemDirection);
- }
- ensureViewSet();
- }
-
- private void ensureViewSet() {
- if (mSet == null || mSet.length != mSpanCount) {
- mSet = new View[mSpanCount];
- }
- }
-
- @Override
- public int scrollHorizontallyBy(int dx, RecyclerView.Recycler recycler,
- RecyclerView.State state) {
- updateMeasurements();
- ensureViewSet();
- return super.scrollHorizontallyBy(dx, recycler, state);
- }
-
- @Override
- public int scrollVerticallyBy(int dy, RecyclerView.Recycler recycler,
- RecyclerView.State state) {
- updateMeasurements();
- ensureViewSet();
- return super.scrollVerticallyBy(dy, recycler, state);
- }
-
- private void ensureAnchorIsInCorrectSpan(RecyclerView.Recycler recycler,
- RecyclerView.State state, AnchorInfo anchorInfo, int itemDirection) {
- final boolean layingOutInPrimaryDirection =
- itemDirection == LayoutState.ITEM_DIRECTION_TAIL;
- int span = getSpanIndex(recycler, state, anchorInfo.mPosition);
- if (layingOutInPrimaryDirection) {
- // choose span 0
- while (span > 0 && anchorInfo.mPosition > 0) {
- anchorInfo.mPosition--;
- span = getSpanIndex(recycler, state, anchorInfo.mPosition);
- }
- } else {
- // choose the max span we can get. hopefully last one
- final int indexLimit = state.getItemCount() - 1;
- int pos = anchorInfo.mPosition;
- int bestSpan = span;
- while (pos < indexLimit) {
- int next = getSpanIndex(recycler, state, pos + 1);
- if (next > bestSpan) {
- pos += 1;
- bestSpan = next;
- } else {
- break;
- }
- }
- anchorInfo.mPosition = pos;
- }
- }
-
- @Override
- View findReferenceChild(RecyclerView.Recycler recycler, RecyclerView.State state,
- boolean layoutFromEnd, boolean traverseChildrenInReverseOrder) {
-
- int start = 0;
- int end = getChildCount();
- int diff = 1;
- if (traverseChildrenInReverseOrder) {
- start = getChildCount() - 1;
- end = -1;
- diff = -1;
- }
-
- int itemCount = state.getItemCount();
-
- ensureLayoutState();
- View invalidMatch = null;
- View outOfBoundsMatch = null;
-
- final int boundsStart = mOrientationHelper.getStartAfterPadding();
- final int boundsEnd = mOrientationHelper.getEndAfterPadding();
-
- for (int i = start; i != end; i += diff) {
- final View view = getChildAt(i);
- final int position = getPosition(view);
- if (position >= 0 && position < itemCount) {
- final int span = getSpanIndex(recycler, state, position);
- if (span != 0) {
- continue;
- }
- if (((RecyclerView.LayoutParams) view.getLayoutParams()).isItemRemoved()) {
- if (invalidMatch == null) {
- invalidMatch = view; // removed item, least preferred
- }
- } else if (mOrientationHelper.getDecoratedStart(view) >= boundsEnd
- || mOrientationHelper.getDecoratedEnd(view) < boundsStart) {
- if (outOfBoundsMatch == null) {
- outOfBoundsMatch = view; // item is not visible, less preferred
- }
- } else {
- return view;
- }
- }
- }
- return outOfBoundsMatch != null ? outOfBoundsMatch : invalidMatch;
- }
-
- private int getSpanGroupIndex(RecyclerView.Recycler recycler, RecyclerView.State state,
- int viewPosition) {
- if (!state.isPreLayout()) {
- return mSpanSizeLookup.getCachedSpanGroupIndex(viewPosition, mSpanCount);
- }
- final int adapterPosition = recycler.convertPreLayoutPositionToPostLayout(viewPosition);
- if (adapterPosition == -1) {
- if (DEBUG) {
- throw new RuntimeException("Cannot find span group index for position "
- + viewPosition);
- }
- Log.w(TAG, "Cannot find span size for pre layout position. " + viewPosition);
- return 0;
- }
- return mSpanSizeLookup.getCachedSpanGroupIndex(adapterPosition, mSpanCount);
- }
-
- private int getSpanIndex(RecyclerView.Recycler recycler, RecyclerView.State state, int pos) {
- if (!state.isPreLayout()) {
- return mSpanSizeLookup.getCachedSpanIndex(pos, mSpanCount);
- }
- final int cached = mPreLayoutSpanIndexCache.get(pos, -1);
- if (cached != -1) {
- return cached;
- }
- final int adapterPosition = recycler.convertPreLayoutPositionToPostLayout(pos);
- if (adapterPosition == -1) {
- if (DEBUG) {
- throw new RuntimeException("Cannot find span index for pre layout position. It is"
- + " not cached, not in the adapter. Pos:" + pos);
- }
- Log.w(TAG, "Cannot find span size for pre layout position. It is"
- + " not cached, not in the adapter. Pos:" + pos);
- return 0;
- }
- return mSpanSizeLookup.getCachedSpanIndex(adapterPosition, mSpanCount);
- }
-
- private int getSpanSize(RecyclerView.Recycler recycler, RecyclerView.State state, int pos) {
- if (!state.isPreLayout()) {
- return mSpanSizeLookup.getSpanSize(pos);
- }
- final int cached = mPreLayoutSpanSizeCache.get(pos, -1);
- if (cached != -1) {
- return cached;
- }
- final int adapterPosition = recycler.convertPreLayoutPositionToPostLayout(pos);
- if (adapterPosition == -1) {
- if (DEBUG) {
- throw new RuntimeException("Cannot find span size for pre layout position. It is"
- + " not cached, not in the adapter. Pos:" + pos);
- }
- Log.w(TAG, "Cannot find span size for pre layout position. It is"
- + " not cached, not in the adapter. Pos:" + pos);
- return 1;
- }
- return mSpanSizeLookup.getSpanSize(adapterPosition);
- }
-
- @Override
- void collectPrefetchPositionsForLayoutState(RecyclerView.State state, LayoutState layoutState,
- LayoutPrefetchRegistry layoutPrefetchRegistry) {
- int remainingSpan = mSpanCount;
- int count = 0;
- while (count < mSpanCount && layoutState.hasMore(state) && remainingSpan > 0) {
- final int pos = layoutState.mCurrentPosition;
- layoutPrefetchRegistry.addPosition(pos, Math.max(0, layoutState.mScrollingOffset));
- final int spanSize = mSpanSizeLookup.getSpanSize(pos);
- remainingSpan -= spanSize;
- layoutState.mCurrentPosition += layoutState.mItemDirection;
- count++;
- }
- }
-
- @Override
- void layoutChunk(RecyclerView.Recycler recycler, RecyclerView.State state,
- LayoutState layoutState, LayoutChunkResult result) {
- final int otherDirSpecMode = mOrientationHelper.getModeInOther();
- final boolean flexibleInOtherDir = otherDirSpecMode != View.MeasureSpec.EXACTLY;
- final int currentOtherDirSize = getChildCount() > 0 ? mCachedBorders[mSpanCount] : 0;
- // if grid layout's dimensions are not specified, let the new row change the measurements
- // This is not perfect since we not covering all rows but still solves an important case
- // where they may have a header row which should be laid out according to children.
- if (flexibleInOtherDir) {
- updateMeasurements(); // reset measurements
- }
- final boolean layingOutInPrimaryDirection =
- layoutState.mItemDirection == LayoutState.ITEM_DIRECTION_TAIL;
- int count = 0;
- int remainingSpan = mSpanCount;
- if (!layingOutInPrimaryDirection) {
- int itemSpanIndex = getSpanIndex(recycler, state, layoutState.mCurrentPosition);
- int itemSpanSize = getSpanSize(recycler, state, layoutState.mCurrentPosition);
- remainingSpan = itemSpanIndex + itemSpanSize;
- }
- while (count < mSpanCount && layoutState.hasMore(state) && remainingSpan > 0) {
- int pos = layoutState.mCurrentPosition;
- final int spanSize = getSpanSize(recycler, state, pos);
- if (spanSize > mSpanCount) {
- throw new IllegalArgumentException("Item at position " + pos + " requires "
- + spanSize + " spans but GridLayoutManager has only " + mSpanCount
- + " spans.");
- }
- remainingSpan -= spanSize;
- if (remainingSpan < 0) {
- break; // item did not fit into this row or column
- }
- View view = layoutState.next(recycler);
- if (view == null) {
- break;
- }
- mSet[count] = view;
- count++;
- }
-
- if (count == 0) {
- result.mFinished = true;
- return;
- }
-
- int maxSize = 0;
- float maxSizeInOther = 0; // use a float to get size per span
-
- // we should assign spans before item decor offsets are calculated
- assignSpans(recycler, state, count, layingOutInPrimaryDirection);
- for (int i = 0; i < count; i++) {
- View view = mSet[i];
- if (layoutState.mScrapList == null) {
- if (layingOutInPrimaryDirection) {
- addView(view);
- } else {
- addView(view, 0);
- }
- } else {
- if (layingOutInPrimaryDirection) {
- addDisappearingView(view);
- } else {
- addDisappearingView(view, 0);
- }
- }
- calculateItemDecorationsForChild(view, mDecorInsets);
-
- measureChild(view, otherDirSpecMode, false);
- final int size = mOrientationHelper.getDecoratedMeasurement(view);
- if (size > maxSize) {
- maxSize = size;
- }
- final LayoutParams lp = (LayoutParams) view.getLayoutParams();
- final float otherSize = 1f * mOrientationHelper.getDecoratedMeasurementInOther(view)
- / lp.mSpanSize;
- if (otherSize > maxSizeInOther) {
- maxSizeInOther = otherSize;
- }
- }
- if (flexibleInOtherDir) {
- // re-distribute columns
- guessMeasurement(maxSizeInOther, currentOtherDirSize);
- // now we should re-measure any item that was match parent.
- maxSize = 0;
- for (int i = 0; i < count; i++) {
- View view = mSet[i];
- measureChild(view, View.MeasureSpec.EXACTLY, true);
- final int size = mOrientationHelper.getDecoratedMeasurement(view);
- if (size > maxSize) {
- maxSize = size;
- }
- }
- }
-
- // Views that did not measure the maxSize has to be re-measured
- // We will stop doing this once we introduce Gravity in the GLM layout params
- for (int i = 0; i < count; i++) {
- final View view = mSet[i];
- if (mOrientationHelper.getDecoratedMeasurement(view) != maxSize) {
- final LayoutParams lp = (LayoutParams) view.getLayoutParams();
- final Rect decorInsets = lp.mDecorInsets;
- final int verticalInsets = decorInsets.top + decorInsets.bottom
- + lp.topMargin + lp.bottomMargin;
- final int horizontalInsets = decorInsets.left + decorInsets.right
- + lp.leftMargin + lp.rightMargin;
- final int totalSpaceInOther = getSpaceForSpanRange(lp.mSpanIndex, lp.mSpanSize);
- final int wSpec;
- final int hSpec;
- if (mOrientation == VERTICAL) {
- wSpec = getChildMeasureSpec(totalSpaceInOther, View.MeasureSpec.EXACTLY,
- horizontalInsets, lp.width, false);
- hSpec = View.MeasureSpec.makeMeasureSpec(maxSize - verticalInsets,
- View.MeasureSpec.EXACTLY);
- } else {
- wSpec = View.MeasureSpec.makeMeasureSpec(maxSize - horizontalInsets,
- View.MeasureSpec.EXACTLY);
- hSpec = getChildMeasureSpec(totalSpaceInOther, View.MeasureSpec.EXACTLY,
- verticalInsets, lp.height, false);
- }
- measureChildWithDecorationsAndMargin(view, wSpec, hSpec, true);
- }
- }
-
- result.mConsumed = maxSize;
-
- int left = 0, right = 0, top = 0, bottom = 0;
- if (mOrientation == VERTICAL) {
- if (layoutState.mLayoutDirection == LayoutState.LAYOUT_START) {
- bottom = layoutState.mOffset;
- top = bottom - maxSize;
- } else {
- top = layoutState.mOffset;
- bottom = top + maxSize;
- }
- } else {
- if (layoutState.mLayoutDirection == LayoutState.LAYOUT_START) {
- right = layoutState.mOffset;
- left = right - maxSize;
- } else {
- left = layoutState.mOffset;
- right = left + maxSize;
- }
- }
- for (int i = 0; i < count; i++) {
- View view = mSet[i];
- LayoutParams params = (LayoutParams) view.getLayoutParams();
- if (mOrientation == VERTICAL) {
- if (isLayoutRTL()) {
- right = getPaddingLeft() + mCachedBorders[mSpanCount - params.mSpanIndex];
- left = right - mOrientationHelper.getDecoratedMeasurementInOther(view);
- } else {
- left = getPaddingLeft() + mCachedBorders[params.mSpanIndex];
- right = left + mOrientationHelper.getDecoratedMeasurementInOther(view);
- }
- } else {
- top = getPaddingTop() + mCachedBorders[params.mSpanIndex];
- bottom = top + mOrientationHelper.getDecoratedMeasurementInOther(view);
- }
- // We calculate everything with View's bounding box (which includes decor and margins)
- // To calculate correct layout position, we subtract margins.
- layoutDecoratedWithMargins(view, left, top, right, bottom);
- if (DEBUG) {
- Log.d(TAG, "laid out child at position " + getPosition(view) + ", with l:"
- + (left + params.leftMargin) + ", t:" + (top + params.topMargin) + ", r:"
- + (right - params.rightMargin) + ", b:" + (bottom - params.bottomMargin)
- + ", span:" + params.mSpanIndex + ", spanSize:" + params.mSpanSize);
- }
- // Consume the available space if the view is not removed OR changed
- if (params.isItemRemoved() || params.isItemChanged()) {
- result.mIgnoreConsumed = true;
- }
- result.mFocusable |= view.hasFocusable();
- }
- Arrays.fill(mSet, null);
- }
-
- /**
- * Measures a child with currently known information. This is not necessarily the child's final
- * measurement. (see fillChunk for details).
- *
- * @param view The child view to be measured
- * @param otherDirParentSpecMode The RV measure spec that should be used in the secondary
- * orientation
- * @param alreadyMeasured True if we've already measured this view once
- */
- private void measureChild(View view, int otherDirParentSpecMode, boolean alreadyMeasured) {
- final LayoutParams lp = (LayoutParams) view.getLayoutParams();
- final Rect decorInsets = lp.mDecorInsets;
- final int verticalInsets = decorInsets.top + decorInsets.bottom
- + lp.topMargin + lp.bottomMargin;
- final int horizontalInsets = decorInsets.left + decorInsets.right
- + lp.leftMargin + lp.rightMargin;
- final int availableSpaceInOther = getSpaceForSpanRange(lp.mSpanIndex, lp.mSpanSize);
- final int wSpec;
- final int hSpec;
- if (mOrientation == VERTICAL) {
- wSpec = getChildMeasureSpec(availableSpaceInOther, otherDirParentSpecMode,
- horizontalInsets, lp.width, false);
- hSpec = getChildMeasureSpec(mOrientationHelper.getTotalSpace(), getHeightMode(),
- verticalInsets, lp.height, true);
- } else {
- hSpec = getChildMeasureSpec(availableSpaceInOther, otherDirParentSpecMode,
- verticalInsets, lp.height, false);
- wSpec = getChildMeasureSpec(mOrientationHelper.getTotalSpace(), getWidthMode(),
- horizontalInsets, lp.width, true);
- }
- measureChildWithDecorationsAndMargin(view, wSpec, hSpec, alreadyMeasured);
- }
-
- /**
- * This is called after laying out a row (if vertical) or a column (if horizontal) when the
- * RecyclerView does not have exact measurement specs.
- *
- * Here we try to assign a best guess width or height and re-do the layout to update other
- * views that wanted to MATCH_PARENT in the non-scroll orientation.
- *
- * @param maxSizeInOther The maximum size per span ratio from the measurement of the children.
- * @param currentOtherDirSize The size before this layout chunk. There is no reason to go below.
- */
- private void guessMeasurement(float maxSizeInOther, int currentOtherDirSize) {
- final int contentSize = Math.round(maxSizeInOther * mSpanCount);
- // always re-calculate because borders were stretched during the fill
- calculateItemBorders(Math.max(contentSize, currentOtherDirSize));
- }
-
- private void measureChildWithDecorationsAndMargin(View child, int widthSpec, int heightSpec,
- boolean alreadyMeasured) {
- RecyclerView.LayoutParams lp = (RecyclerView.LayoutParams) child.getLayoutParams();
- final boolean measure;
- if (alreadyMeasured) {
- measure = shouldReMeasureChild(child, widthSpec, heightSpec, lp);
- } else {
- measure = shouldMeasureChild(child, widthSpec, heightSpec, lp);
- }
- if (measure) {
- child.measure(widthSpec, heightSpec);
- }
- }
-
- private void assignSpans(RecyclerView.Recycler recycler, RecyclerView.State state, int count,
- boolean layingOutInPrimaryDirection) {
- // spans are always assigned from 0 to N no matter if it is RTL or not.
- // RTL is used only when positioning the view.
- int span, start, end, diff;
- // make sure we traverse from min position to max position
- if (layingOutInPrimaryDirection) {
- start = 0;
- end = count;
- diff = 1;
- } else {
- start = count - 1;
- end = -1;
- diff = -1;
- }
- span = 0;
- for (int i = start; i != end; i += diff) {
- View view = mSet[i];
- LayoutParams params = (LayoutParams) view.getLayoutParams();
- params.mSpanSize = getSpanSize(recycler, state, getPosition(view));
- params.mSpanIndex = span;
- span += params.mSpanSize;
- }
- }
-
- /**
- * Returns the number of spans laid out by this grid.
- *
- * @return The number of spans
- * @see #setSpanCount(int)
- */
- public int getSpanCount() {
- return mSpanCount;
- }
-
- /**
- * Sets the number of spans to be laid out.
- *
- * If {@link #getOrientation()} is {@link #VERTICAL}, this is the number of columns.
- * If {@link #getOrientation()} is {@link #HORIZONTAL}, this is the number of rows.
- *
- * @param spanCount The total number of spans in the grid
- * @see #getSpanCount()
- */
- public void setSpanCount(int spanCount) {
- if (spanCount == mSpanCount) {
- return;
- }
- mPendingSpanCountChange = true;
- if (spanCount < 1) {
- throw new IllegalArgumentException("Span count should be at least 1. Provided "
- + spanCount);
- }
- mSpanCount = spanCount;
- mSpanSizeLookup.invalidateSpanIndexCache();
- requestLayout();
- }
-
- /**
- * A helper class to provide the number of spans each item occupies.
- *
- * Default implementation sets each item to occupy exactly 1 span.
- *
- * @see GridLayoutManager#setSpanSizeLookup(SpanSizeLookup)
- */
- public abstract static class SpanSizeLookup {
-
- final SparseIntArray mSpanIndexCache = new SparseIntArray();
- final SparseIntArray mSpanGroupIndexCache = new SparseIntArray();
-
- private boolean mCacheSpanIndices = false;
- private boolean mCacheSpanGroupIndices = false;
-
- /**
- * Returns the number of span occupied by the item at position.
- *
- * @param position The adapter position of the item
- * @return The number of spans occupied by the item at the provided position
- */
- public abstract int getSpanSize(int position);
-
- /**
- * Sets whether the results of {@link #getSpanIndex(int, int)} method should be cached or
- * not. By default these values are not cached. If you are not overriding
- * {@link #getSpanIndex(int, int)} with something highly performant, you should set this
- * to true for better performance.
- *
- * @param cacheSpanIndices Whether results of getSpanIndex should be cached or not.
- */
- public void setSpanIndexCacheEnabled(boolean cacheSpanIndices) {
- if (!cacheSpanIndices) {
- mSpanGroupIndexCache.clear();
- }
- mCacheSpanIndices = cacheSpanIndices;
- }
-
- /**
- * Sets whether the results of {@link #getSpanGroupIndex(int, int)} method should be cached
- * or not. By default these values are not cached. If you are not overriding
- * {@link #getSpanGroupIndex(int, int)} with something highly performant, and you are using
- * spans to calculate scrollbar offset and range, you should set this to true for better
- * performance.
- *
- * @param cacheSpanGroupIndices Whether results of getGroupSpanIndex should be cached or
- * not.
- */
- public void setSpanGroupIndexCacheEnabled(boolean cacheSpanGroupIndices) {
- if (!cacheSpanGroupIndices) {
- mSpanGroupIndexCache.clear();
- }
- mCacheSpanGroupIndices = cacheSpanGroupIndices;
- }
-
- /**
- * Clears the span index cache. GridLayoutManager automatically calls this method when
- * adapter changes occur.
- */
- public void invalidateSpanIndexCache() {
- mSpanIndexCache.clear();
- }
-
- /**
- * Clears the span group index cache. GridLayoutManager automatically calls this method
- * when adapter changes occur.
- */
- public void invalidateSpanGroupIndexCache() {
- mSpanGroupIndexCache.clear();
- }
-
- /**
- * Returns whether results of {@link #getSpanIndex(int, int)} method are cached or not.
- *
- * @return True if results of {@link #getSpanIndex(int, int)} are cached.
- */
- public boolean isSpanIndexCacheEnabled() {
- return mCacheSpanIndices;
- }
-
- /**
- * Returns whether results of {@link #getSpanGroupIndex(int, int)} method are cached or not.
- *
- * @return True if results of {@link #getSpanGroupIndex(int, int)} are cached.
- */
- public boolean isSpanGroupIndexCacheEnabled() {
- return mCacheSpanGroupIndices;
- }
-
- int getCachedSpanIndex(int position, int spanCount) {
- if (!mCacheSpanIndices) {
- return getSpanIndex(position, spanCount);
- }
- final int existing = mSpanIndexCache.get(position, -1);
- if (existing != -1) {
- return existing;
- }
- final int value = getSpanIndex(position, spanCount);
- mSpanIndexCache.put(position, value);
- return value;
- }
-
- int getCachedSpanGroupIndex(int position, int spanCount) {
- if (!mCacheSpanGroupIndices) {
- return getSpanGroupIndex(position, spanCount);
- }
- final int existing = mSpanGroupIndexCache.get(position, -1);
- if (existing != -1) {
- return existing;
- }
- final int value = getSpanGroupIndex(position, spanCount);
- mSpanGroupIndexCache.put(position, value);
- return value;
- }
-
- /**
- * Returns the final span index of the provided position.
- *
- * If you have a faster way to calculate span index for your items, you should override
- * this method. Otherwise, you should enable span index cache
- * ({@link #setSpanIndexCacheEnabled(boolean)}) for better performance. When caching is
- * disabled, default implementation traverses all items from 0 to
- * position. When caching is enabled, it calculates from the closest cached
- * value before the position.
- *
- * If you override this method, you need to make sure it is consistent with
- * {@link #getSpanSize(int)}. GridLayoutManager does not call this method for
- * each item. It is called only for the reference item and rest of the items
- * are assigned to spans based on the reference item. For example, you cannot assign a
- * position to span 2 while span 1 is empty.
- *
- * Note that span offsets always start with 0 and are not affected by RTL.
- *
- * @param position The position of the item
- * @param spanCount The total number of spans in the grid
- * @return The final span position of the item. Should be between 0 (inclusive) and
- * spanCount(exclusive)
- */
- public int getSpanIndex(int position, int spanCount) {
- int positionSpanSize = getSpanSize(position);
- if (positionSpanSize == spanCount) {
- return 0; // quick return for full-span items
- }
- int span = 0;
- int startPos = 0;
- // If caching is enabled, try to jump
- if (mCacheSpanIndices) {
- int prevKey = findFirstKeyLessThan(mSpanIndexCache, position);
- if (prevKey >= 0) {
- span = mSpanIndexCache.get(prevKey) + getSpanSize(prevKey);
- startPos = prevKey + 1;
- }
- }
- for (int i = startPos; i < position; i++) {
- int size = getSpanSize(i);
- span += size;
- if (span == spanCount) {
- span = 0;
- } else if (span > spanCount) {
- // did not fit, moving to next row / column
- span = size;
- }
- }
- if (span + positionSpanSize <= spanCount) {
- return span;
- }
- return 0;
- }
-
- static int findFirstKeyLessThan(SparseIntArray cache, int position) {
- int lo = 0;
- int hi = cache.size() - 1;
-
- while (lo <= hi) {
- // Using unsigned shift here to divide by two because it is guaranteed to not
- // overflow.
- final int mid = (lo + hi) >>> 1;
- final int midVal = cache.keyAt(mid);
- if (midVal < position) {
- lo = mid + 1;
- } else {
- hi = mid - 1;
- }
- }
- int index = lo - 1;
- if (index >= 0 && index < cache.size()) {
- return cache.keyAt(index);
- }
- return -1;
- }
-
- /**
- * Returns the index of the group this position belongs.
- *
- * For example, if grid has 3 columns and each item occupies 1 span, span group index
- * for item 1 will be 0, item 5 will be 1.
- *
- * @param adapterPosition The position in adapter
- * @param spanCount The total number of spans in the grid
- * @return The index of the span group including the item at the given adapter position
- */
- public int getSpanGroupIndex(int adapterPosition, int spanCount) {
- int span = 0;
- int group = 0;
- int start = 0;
- if (mCacheSpanGroupIndices) {
- // This finds the first non empty cached group cache key.
- int prevKey = findFirstKeyLessThan(mSpanGroupIndexCache, adapterPosition);
- if (prevKey != -1) {
- group = mSpanGroupIndexCache.get(prevKey);
- start = prevKey + 1;
- span = getCachedSpanIndex(prevKey, spanCount) + getSpanSize(prevKey);
- if (span == spanCount) {
- span = 0;
- group++;
- }
- }
- }
- int positionSpanSize = getSpanSize(adapterPosition);
- for (int i = start; i < adapterPosition; i++) {
- int size = getSpanSize(i);
- span += size;
- if (span == spanCount) {
- span = 0;
- group++;
- } else if (span > spanCount) {
- // did not fit, moving to next row / column
- span = size;
- group++;
- }
- }
- if (span + positionSpanSize > spanCount) {
- group++;
- }
- return group;
- }
- }
-
- @Override
- public View onFocusSearchFailed(View focused, int direction,
- RecyclerView.Recycler recycler, RecyclerView.State state) {
- View prevFocusedChild = findContainingItemView(focused);
- if (prevFocusedChild == null) {
- return null;
- }
- LayoutParams lp = (LayoutParams) prevFocusedChild.getLayoutParams();
- final int prevSpanStart = lp.mSpanIndex;
- final int prevSpanEnd = lp.mSpanIndex + lp.mSpanSize;
- View view = super.onFocusSearchFailed(focused, direction, recycler, state);
- if (view == null) {
- return null;
- }
- // LinearLayoutManager finds the last child. What we want is the child which has the same
- // spanIndex.
- final int layoutDir = convertFocusDirectionToLayoutDirection(direction);
- final boolean ascend = (layoutDir == LayoutState.LAYOUT_END) != mShouldReverseLayout;
- final int start, inc, limit;
- if (ascend) {
- start = getChildCount() - 1;
- inc = -1;
- limit = -1;
- } else {
- start = 0;
- inc = 1;
- limit = getChildCount();
- }
- final boolean preferLastSpan = mOrientation == VERTICAL && isLayoutRTL();
-
- // The focusable candidate to be picked if no perfect focusable candidate is found.
- // The best focusable candidate is the one with the highest amount of span overlap with
- // the currently focused view.
- View focusableWeakCandidate = null; // somewhat matches but not strong
- int focusableWeakCandidateSpanIndex = -1;
- int focusableWeakCandidateOverlap = 0; // how many spans overlap
-
- // The unfocusable candidate to become visible on the screen next, if no perfect or
- // weak focusable candidates are found to receive focus next.
- // We are only interested in partially visible unfocusable views. These are views that are
- // not fully visible, that is either partially overlapping, or out-of-bounds and right below
- // or above RV's padded bounded area. The best unfocusable candidate is the one with the
- // highest amount of span overlap with the currently focused view.
- View unfocusableWeakCandidate = null; // somewhat matches but not strong
- int unfocusableWeakCandidateSpanIndex = -1;
- int unfocusableWeakCandidateOverlap = 0; // how many spans overlap
-
- // The span group index of the start child. This indicates the span group index of the
- // next focusable item to receive focus, if a focusable item within the same span group
- // exists. Any focusable item beyond this group index are not relevant since they
- // were already stored in the layout before onFocusSearchFailed call and were not picked
- // by the focusSearch algorithm.
- int focusableSpanGroupIndex = getSpanGroupIndex(recycler, state, start);
- for (int i = start; i != limit; i += inc) {
- int spanGroupIndex = getSpanGroupIndex(recycler, state, i);
- View candidate = getChildAt(i);
- if (candidate == prevFocusedChild) {
- break;
- }
-
- if (candidate.hasFocusable() && spanGroupIndex != focusableSpanGroupIndex) {
- // We are past the allowable span group index for the next focusable item.
- // The search only continues if no focusable weak candidates have been found up
- // until this point, in order to find the best unfocusable candidate to become
- // visible on the screen next.
- if (focusableWeakCandidate != null) {
- break;
- }
- continue;
- }
-
- final LayoutParams candidateLp = (LayoutParams) candidate.getLayoutParams();
- final int candidateStart = candidateLp.mSpanIndex;
- final int candidateEnd = candidateLp.mSpanIndex + candidateLp.mSpanSize;
- if (candidate.hasFocusable() && candidateStart == prevSpanStart
- && candidateEnd == prevSpanEnd) {
- return candidate; // perfect match
- }
- boolean assignAsWeek = false;
- if ((candidate.hasFocusable() && focusableWeakCandidate == null)
- || (!candidate.hasFocusable() && unfocusableWeakCandidate == null)) {
- assignAsWeek = true;
- } else {
- int maxStart = Math.max(candidateStart, prevSpanStart);
- int minEnd = Math.min(candidateEnd, prevSpanEnd);
- int overlap = minEnd - maxStart;
- if (candidate.hasFocusable()) {
- if (overlap > focusableWeakCandidateOverlap) {
- assignAsWeek = true;
- } else if (overlap == focusableWeakCandidateOverlap
- && preferLastSpan == (candidateStart
- > focusableWeakCandidateSpanIndex)) {
- assignAsWeek = true;
- }
- } else if (focusableWeakCandidate == null
- && isViewPartiallyVisible(candidate, false, true)) {
- if (overlap > unfocusableWeakCandidateOverlap) {
- assignAsWeek = true;
- } else if (overlap == unfocusableWeakCandidateOverlap
- && preferLastSpan == (candidateStart
- > unfocusableWeakCandidateSpanIndex)) {
- assignAsWeek = true;
- }
- }
- }
-
- if (assignAsWeek) {
- if (candidate.hasFocusable()) {
- focusableWeakCandidate = candidate;
- focusableWeakCandidateSpanIndex = candidateLp.mSpanIndex;
- focusableWeakCandidateOverlap = Math.min(candidateEnd, prevSpanEnd)
- - Math.max(candidateStart, prevSpanStart);
- } else {
- unfocusableWeakCandidate = candidate;
- unfocusableWeakCandidateSpanIndex = candidateLp.mSpanIndex;
- unfocusableWeakCandidateOverlap = Math.min(candidateEnd, prevSpanEnd)
- - Math.max(candidateStart, prevSpanStart);
- }
- }
- }
- return (focusableWeakCandidate != null) ? focusableWeakCandidate : unfocusableWeakCandidate;
- }
-
- @Override
- public boolean supportsPredictiveItemAnimations() {
- return mPendingSavedState == null && !mPendingSpanCountChange;
- }
-
- @Override
- public int computeHorizontalScrollRange(RecyclerView.State state) {
- if (mUsingSpansToEstimateScrollBarDimensions) {
- return computeScrollRangeWithSpanInfo(state);
- } else {
- return super.computeHorizontalScrollRange(state);
- }
- }
-
- @Override
- public int computeVerticalScrollRange(RecyclerView.State state) {
- if (mUsingSpansToEstimateScrollBarDimensions) {
- return computeScrollRangeWithSpanInfo(state);
- } else {
- return super.computeVerticalScrollRange(state);
- }
- }
-
- @Override
- public int computeHorizontalScrollOffset(RecyclerView.State state) {
- if (mUsingSpansToEstimateScrollBarDimensions) {
- return computeScrollOffsetWithSpanInfo(state);
- } else {
- return super.computeHorizontalScrollOffset(state);
- }
- }
-
- @Override
- public int computeVerticalScrollOffset(RecyclerView.State state) {
- if (mUsingSpansToEstimateScrollBarDimensions) {
- return computeScrollOffsetWithSpanInfo(state);
- } else {
- return super.computeVerticalScrollOffset(state);
- }
- }
-
- /**
- * When this flag is set, the scroll offset and scroll range calculations will take account
- * of span information.
- *
- *
This is will increase the accuracy of the scroll bar's size and offset but will require
- * more calls to {@link SpanSizeLookup#getSpanGroupIndex(int, int)}".
- *
- *
This additional accuracy may or may not be needed, depending on the characteristics of
- * your layout. You will likely benefit from this accuracy when:
- *
- *
- * The variation in item span sizes is large.
- * The size of your data set is small (if your data set is large, the scrollbar will
- * likely be very small anyway, and thus the increased accuracy has less impact).
- * Calls to {@link SpanSizeLookup#getSpanGroupIndex(int, int)} are fast.
- *
- *
- * If you decide to enable this feature, you should be sure that calls to
- * {@link SpanSizeLookup#getSpanGroupIndex(int, int)} are fast, that set span group index
- * caching is set to true via a call to
- * {@link SpanSizeLookup#setSpanGroupIndexCacheEnabled(boolean),
- * and span index caching is also enabled via a call to
- * {@link SpanSizeLookup#setSpanIndexCacheEnabled(boolean)}}.
- */
- public void setUsingSpansToEstimateScrollbarDimensions(
- boolean useSpansToEstimateScrollBarDimensions) {
- mUsingSpansToEstimateScrollBarDimensions = useSpansToEstimateScrollBarDimensions;
- }
-
- /**
- * Returns true if the scroll offset and scroll range calculations take account of span
- * information. See {@link #setUsingSpansToEstimateScrollbarDimensions(boolean)} for more
- * information on this topic. Defaults to {@code false}.
- *
- * @return true if the scroll offset and scroll range calculations take account of span
- * information.
- */
- public boolean isUsingSpansToEstimateScrollbarDimensions() {
- return mUsingSpansToEstimateScrollBarDimensions;
- }
-
- private int computeScrollRangeWithSpanInfo(RecyclerView.State state) {
- if (getChildCount() == 0 || state.getItemCount() == 0) {
- return 0;
- }
- ensureLayoutState();
-
- View startChild = findFirstVisibleChildClosestToStart(!isSmoothScrollbarEnabled(), true);
- View endChild = findFirstVisibleChildClosestToEnd(!isSmoothScrollbarEnabled(), true);
-
- if (startChild == null || endChild == null) {
- return 0;
- }
- if (!isSmoothScrollbarEnabled()) {
- return mSpanSizeLookup.getCachedSpanGroupIndex(
- state.getItemCount() - 1, mSpanCount) + 1;
- }
-
- // smooth scrollbar enabled. try to estimate better.
- final int laidOutArea = mOrientationHelper.getDecoratedEnd(endChild)
- - mOrientationHelper.getDecoratedStart(startChild);
-
- final int firstVisibleSpan =
- mSpanSizeLookup.getCachedSpanGroupIndex(getPosition(startChild), mSpanCount);
- final int lastVisibleSpan = mSpanSizeLookup.getCachedSpanGroupIndex(getPosition(endChild),
- mSpanCount);
- final int totalSpans = mSpanSizeLookup.getCachedSpanGroupIndex(state.getItemCount() - 1,
- mSpanCount) + 1;
- final int laidOutSpans = lastVisibleSpan - firstVisibleSpan + 1;
-
- // estimate a size for full list.
- return (int) (((float) laidOutArea / laidOutSpans) * totalSpans);
- }
-
- private int computeScrollOffsetWithSpanInfo(RecyclerView.State state) {
- if (getChildCount() == 0 || state.getItemCount() == 0) {
- return 0;
- }
- ensureLayoutState();
-
- boolean smoothScrollEnabled = isSmoothScrollbarEnabled();
- View startChild = findFirstVisibleChildClosestToStart(!smoothScrollEnabled, true);
- View endChild = findFirstVisibleChildClosestToEnd(!smoothScrollEnabled, true);
- if (startChild == null || endChild == null) {
- return 0;
- }
- int startChildSpan = mSpanSizeLookup.getCachedSpanGroupIndex(getPosition(startChild),
- mSpanCount);
- int endChildSpan = mSpanSizeLookup.getCachedSpanGroupIndex(getPosition(endChild),
- mSpanCount);
-
- final int minSpan = Math.min(startChildSpan, endChildSpan);
- final int maxSpan = Math.max(startChildSpan, endChildSpan);
- final int totalSpans = mSpanSizeLookup.getCachedSpanGroupIndex(state.getItemCount() - 1,
- mSpanCount) + 1;
-
- final int spansBefore = mShouldReverseLayout
- ? Math.max(0, totalSpans - maxSpan - 1)
- : Math.max(0, minSpan);
- if (!smoothScrollEnabled) {
- return spansBefore;
- }
- final int laidOutArea = Math.abs(mOrientationHelper.getDecoratedEnd(endChild)
- - mOrientationHelper.getDecoratedStart(startChild));
-
- final int firstVisibleSpan =
- mSpanSizeLookup.getCachedSpanGroupIndex(getPosition(startChild), mSpanCount);
- final int lastVisibleSpan = mSpanSizeLookup.getCachedSpanGroupIndex(getPosition(endChild),
- mSpanCount);
- final int laidOutSpans = lastVisibleSpan - firstVisibleSpan + 1;
- final float avgSizePerSpan = (float) laidOutArea / laidOutSpans;
-
- return Math.round(spansBefore * avgSizePerSpan + (mOrientationHelper.getStartAfterPadding()
- - mOrientationHelper.getDecoratedStart(startChild)));
- }
-
- /**
- * Default implementation for {@link SpanSizeLookup}. Each item occupies 1 span.
- */
- public static final class DefaultSpanSizeLookup extends SpanSizeLookup {
-
- @Override
- public int getSpanSize(int position) {
- return 1;
- }
-
- @Override
- public int getSpanIndex(int position, int spanCount) {
- return position % spanCount;
- }
- }
-
- /**
- * LayoutParams used by GridLayoutManager.
- *
- * Note that if the orientation is {@link #VERTICAL}, the width parameter is ignored and if the
- * orientation is {@link #HORIZONTAL} the height parameter is ignored because child view is
- * expected to fill all of the space given to it.
- */
- public static class LayoutParams extends RecyclerView.LayoutParams {
-
- /**
- * Span Id for Views that are not laid out yet.
- */
- public static final int INVALID_SPAN_ID = -1;
-
- int mSpanIndex = INVALID_SPAN_ID;
-
- int mSpanSize = 0;
-
- public LayoutParams(Context c, AttributeSet attrs) {
- super(c, attrs);
- }
-
- public LayoutParams(int width, int height) {
- super(width, height);
- }
-
- public LayoutParams(ViewGroup.MarginLayoutParams source) {
- super(source);
- }
-
- public LayoutParams(ViewGroup.LayoutParams source) {
- super(source);
- }
-
- public LayoutParams(RecyclerView.LayoutParams source) {
- super(source);
- }
-
- /**
- * Returns the current span index of this View. If the View is not laid out yet, the return
- * value is undefined.
- *
- * Starting with RecyclerView 24.2.0 , span indices are always indexed from position 0
- * even if the layout is RTL. In a vertical GridLayoutManager, leftmost span is span
- * 0 if the layout is LTR and rightmost span is span 0 if the layout is
- * RTL . Prior to 24.2.0, it was the opposite which was conflicting with
- * {@link SpanSizeLookup#getSpanIndex(int, int)}.
- *
- * If the View occupies multiple spans, span with the minimum index is returned.
- *
- * @return The span index of the View.
- */
- public int getSpanIndex() {
- return mSpanIndex;
- }
-
- /**
- * Returns the number of spans occupied by this View. If the View not laid out yet, the
- * return value is undefined.
- *
- * @return The number of spans occupied by this View.
- */
- public int getSpanSize() {
- return mSpanSize;
- }
- }
-
-}
diff --git a/app/src/main/java/androidx/recyclerview/widget/ItemTouchHelper.java b/app/src/main/java/androidx/recyclerview/widget/ItemTouchHelper.java
deleted file mode 100644
index 2865dadd18..0000000000
--- a/app/src/main/java/androidx/recyclerview/widget/ItemTouchHelper.java
+++ /dev/null
@@ -1,2494 +0,0 @@
-/*
- * Copyright 2018 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package androidx.recyclerview.widget;
-
-import android.animation.Animator;
-import android.animation.ValueAnimator;
-import android.annotation.SuppressLint;
-import android.content.res.Resources;
-import android.graphics.Canvas;
-import android.graphics.Rect;
-import android.os.Build;
-import android.util.Log;
-import android.view.GestureDetector;
-import android.view.HapticFeedbackConstants;
-import android.view.MotionEvent;
-import android.view.VelocityTracker;
-import android.view.View;
-import android.view.ViewConfiguration;
-import android.view.ViewParent;
-import android.view.animation.Interpolator;
-
-import androidx.annotation.NonNull;
-import androidx.annotation.Nullable;
-import androidx.annotation.VisibleForTesting;
-import androidx.core.view.GestureDetectorCompat;
-import androidx.core.view.ViewCompat;
-import androidx.recyclerview.R;
-import androidx.recyclerview.widget.RecyclerView.OnItemTouchListener;
-import androidx.recyclerview.widget.RecyclerView.ViewHolder;
-
-import java.util.ArrayList;
-import java.util.List;
-
-/**
- * This is a utility class to add swipe to dismiss and drag & drop support to RecyclerView.
- *
- * It works with a RecyclerView and a Callback class, which configures what type of interactions
- * are enabled and also receives events when user performs these actions.
- *
- * Depending on which functionality you support, you should override
- * {@link Callback#onMove(RecyclerView, ViewHolder, ViewHolder)} and / or
- * {@link Callback#onSwiped(ViewHolder, int)}.
- *
- * This class is designed to work with any LayoutManager but for certain situations, it can be
- * optimized for your custom LayoutManager by extending methods in the
- * {@link ItemTouchHelper.Callback} class or implementing {@link ItemTouchHelper.ViewDropHandler}
- * interface in your LayoutManager.
- *
- * By default, ItemTouchHelper moves the items' translateX/Y properties to reposition them. You can
- * customize these behaviors by overriding {@link Callback#onChildDraw(Canvas, RecyclerView,
- * ViewHolder, float, float, int, boolean)}
- * or {@link Callback#onChildDrawOver(Canvas, RecyclerView, ViewHolder, float, float, int,
- * boolean)}.
- *
- * Most of the time you only need to override onChildDraw.
- */
-public class ItemTouchHelper extends RecyclerView.ItemDecoration
- implements RecyclerView.OnChildAttachStateChangeListener {
-
- /**
- * Up direction, used for swipe & drag control.
- */
- public static final int UP = 1;
-
- /**
- * Down direction, used for swipe & drag control.
- */
- public static final int DOWN = 1 << 1;
-
- /**
- * Left direction, used for swipe & drag control.
- */
- public static final int LEFT = 1 << 2;
-
- /**
- * Right direction, used for swipe & drag control.
- */
- public static final int RIGHT = 1 << 3;
-
- // If you change these relative direction values, update Callback#convertToAbsoluteDirection,
- // Callback#convertToRelativeDirection.
- /**
- * Horizontal start direction. Resolved to LEFT or RIGHT depending on RecyclerView's layout
- * direction. Used for swipe & drag control.
- */
- public static final int START = LEFT << 2;
-
- /**
- * Horizontal end direction. Resolved to LEFT or RIGHT depending on RecyclerView's layout
- * direction. Used for swipe & drag control.
- */
- public static final int END = RIGHT << 2;
-
- /**
- * ItemTouchHelper is in idle state. At this state, either there is no related motion event by
- * the user or latest motion events have not yet triggered a swipe or drag.
- */
- public static final int ACTION_STATE_IDLE = 0;
-
- /**
- * A View is currently being swiped.
- */
- @SuppressWarnings("WeakerAccess")
- public static final int ACTION_STATE_SWIPE = 1;
-
- /**
- * A View is currently being dragged.
- */
- @SuppressWarnings("WeakerAccess")
- public static final int ACTION_STATE_DRAG = 2;
-
- /**
- * Animation type for views which are swiped successfully.
- */
- @SuppressWarnings("WeakerAccess")
- public static final int ANIMATION_TYPE_SWIPE_SUCCESS = 1 << 1;
-
- /**
- * Animation type for views which are not completely swiped thus will animate back to their
- * original position.
- */
- @SuppressWarnings("WeakerAccess")
- public static final int ANIMATION_TYPE_SWIPE_CANCEL = 1 << 2;
-
- /**
- * Animation type for views that were dragged and now will animate to their final position.
- */
- @SuppressWarnings("WeakerAccess")
- public static final int ANIMATION_TYPE_DRAG = 1 << 3;
-
- private static final String TAG = "ItemTouchHelper";
-
- private static final boolean DEBUG = false;
-
- private static final int ACTIVE_POINTER_ID_NONE = -1;
-
- static final int DIRECTION_FLAG_COUNT = 8;
-
- private static final int ACTION_MODE_IDLE_MASK = (1 << DIRECTION_FLAG_COUNT) - 1;
-
- static final int ACTION_MODE_SWIPE_MASK = ACTION_MODE_IDLE_MASK << DIRECTION_FLAG_COUNT;
-
- static final int ACTION_MODE_DRAG_MASK = ACTION_MODE_SWIPE_MASK << DIRECTION_FLAG_COUNT;
-
- /**
- * The unit we are using to track velocity
- */
- private static final int PIXELS_PER_SECOND = 1000;
-
- /**
- * Views, whose state should be cleared after they are detached from RecyclerView.
- * This is necessary after swipe dismissing an item. We wait until animator finishes its job
- * to clean these views.
- */
- final List mPendingCleanup = new ArrayList<>();
-
- /**
- * Re-use array to calculate dx dy for a ViewHolder
- */
- private final float[] mTmpPosition = new float[2];
-
- /**
- * Currently selected view holder
- */
- @SuppressWarnings("WeakerAccess") /* synthetic access */
- ViewHolder mSelected = null;
-
- /**
- * The reference coordinates for the action start. For drag & drop, this is the time long
- * press is completed vs for swipe, this is the initial touch point.
- */
- float mInitialTouchX;
-
- float mInitialTouchY;
-
- /**
- * Set when ItemTouchHelper is assigned to a RecyclerView.
- */
- private float mSwipeEscapeVelocity;
-
- /**
- * Set when ItemTouchHelper is assigned to a RecyclerView.
- */
- private float mMaxSwipeVelocity;
-
- /**
- * The diff between the last event and initial touch.
- */
- float mDx;
-
- float mDy;
-
- /**
- * The coordinates of the selected view at the time it is selected. We record these values
- * when action starts so that we can consistently position it even if LayoutManager moves the
- * View.
- */
- private float mSelectedStartX;
-
- private float mSelectedStartY;
-
- /**
- * The pointer we are tracking.
- */
- @SuppressWarnings("WeakerAccess") /* synthetic access */
- int mActivePointerId = ACTIVE_POINTER_ID_NONE;
-
- /**
- * Developer callback which controls the behavior of ItemTouchHelper.
- */
- @NonNull
- Callback mCallback;
-
- /**
- * Current mode.
- */
- private int mActionState = ACTION_STATE_IDLE;
-
- /**
- * The direction flags obtained from unmasking
- * {@link Callback#getAbsoluteMovementFlags(RecyclerView, ViewHolder)} for the current
- * action state.
- */
- @SuppressWarnings("WeakerAccess") /* synthetic access */
- int mSelectedFlags;
-
- /**
- * When a View is dragged or swiped and needs to go back to where it was, we create a Recover
- * Animation and animate it to its location using this custom Animator, instead of using
- * framework Animators.
- * Using framework animators has the side effect of clashing with ItemAnimator, creating
- * jumpy UIs.
- */
- @VisibleForTesting
- List mRecoverAnimations = new ArrayList<>();
-
- private int mSlop;
-
- RecyclerView mRecyclerView;
-
- /**
- * When user drags a view to the edge, we start scrolling the LayoutManager as long as View
- * is partially out of bounds.
- */
- @SuppressWarnings("WeakerAccess") /* synthetic access */
- final Runnable mScrollRunnable = new Runnable() {
- @Override
- public void run() {
- if (mSelected != null && scrollIfNecessary()) {
- if (mSelected != null) { //it might be lost during scrolling
- moveIfNecessary(mSelected);
- }
- mRecyclerView.removeCallbacks(mScrollRunnable);
- ViewCompat.postOnAnimation(mRecyclerView, this);
- }
- }
- };
-
- /**
- * Used for detecting fling swipe
- */
- VelocityTracker mVelocityTracker;
-
- //re-used list for selecting a swap target
- private List mSwapTargets;
-
- //re used for for sorting swap targets
- private List mDistances;
-
- /**
- * If drag & drop is supported, we use child drawing order to bring them to front.
- */
- private RecyclerView.ChildDrawingOrderCallback mChildDrawingOrderCallback = null;
-
- /**
- * This keeps a reference to the child dragged by the user. Even after user stops dragging,
- * until view reaches its final position (end of recover animation), we keep a reference so
- * that it can be drawn above other children.
- */
- @SuppressWarnings("WeakerAccess") /* synthetic access */
- View mOverdrawChild = null;
-
- /**
- * We cache the position of the overdraw child to avoid recalculating it each time child
- * position callback is called. This value is invalidated whenever a child is attached or
- * detached.
- */
- @SuppressWarnings("WeakerAccess") /* synthetic access */
- int mOverdrawChildPosition = -1;
-
- /**
- * Used to detect long press.
- */
- @SuppressWarnings("WeakerAccess") /* synthetic access */
- GestureDetectorCompat mGestureDetector;
-
- /**
- * Callback for when long press occurs.
- */
- private ItemTouchHelperGestureListener mItemTouchHelperGestureListener;
-
- private final OnItemTouchListener mOnItemTouchListener = new OnItemTouchListener() {
- @Override
- public boolean onInterceptTouchEvent(@NonNull RecyclerView recyclerView,
- @NonNull MotionEvent event) {
- mGestureDetector.onTouchEvent(event);
- if (DEBUG) {
- Log.d(TAG, "intercept: x:" + event.getX() + ",y:" + event.getY() + ", " + event);
- }
- final int action = event.getActionMasked();
- if (action == MotionEvent.ACTION_DOWN) {
- mActivePointerId = event.getPointerId(0);
- mInitialTouchX = event.getX();
- mInitialTouchY = event.getY();
- obtainVelocityTracker();
- if (mSelected == null) {
- final RecoverAnimation animation = findAnimation(event);
- if (animation != null) {
- mInitialTouchX -= animation.mX;
- mInitialTouchY -= animation.mY;
- endRecoverAnimation(animation.mViewHolder, true);
- if (mPendingCleanup.remove(animation.mViewHolder.itemView)) {
- mCallback.clearView(mRecyclerView, animation.mViewHolder);
- }
- select(animation.mViewHolder, animation.mActionState);
- updateDxDy(event, mSelectedFlags, 0);
- }
- }
- } else if (action == MotionEvent.ACTION_CANCEL || action == MotionEvent.ACTION_UP) {
- mActivePointerId = ACTIVE_POINTER_ID_NONE;
- select(null, ACTION_STATE_IDLE);
- } else if (mActivePointerId != ACTIVE_POINTER_ID_NONE) {
- // in a non scroll orientation, if distance change is above threshold, we
- // can select the item
- final int index = event.findPointerIndex(mActivePointerId);
- if (DEBUG) {
- Log.d(TAG, "pointer index " + index);
- }
- if (index >= 0) {
- checkSelectForSwipe(action, event, index);
- }
- }
- if (mVelocityTracker != null) {
- mVelocityTracker.addMovement(event);
- }
- return mSelected != null;
- }
-
- @Override
- public void onTouchEvent(@NonNull RecyclerView recyclerView, @NonNull MotionEvent event) {
- mGestureDetector.onTouchEvent(event);
- if (DEBUG) {
- Log.d(TAG,
- "on touch: x:" + mInitialTouchX + ",y:" + mInitialTouchY + ", :" + event);
- }
- if (mVelocityTracker != null) {
- mVelocityTracker.addMovement(event);
- }
- if (mActivePointerId == ACTIVE_POINTER_ID_NONE) {
- return;
- }
- final int action = event.getActionMasked();
- final int activePointerIndex = event.findPointerIndex(mActivePointerId);
- if (activePointerIndex >= 0) {
- checkSelectForSwipe(action, event, activePointerIndex);
- }
- ViewHolder viewHolder = mSelected;
- if (viewHolder == null) {
- return;
- }
- switch (action) {
- case MotionEvent.ACTION_MOVE: {
- // Find the index of the active pointer and fetch its position
- if (activePointerIndex >= 0) {
- updateDxDy(event, mSelectedFlags, activePointerIndex);
- moveIfNecessary(viewHolder);
- mRecyclerView.removeCallbacks(mScrollRunnable);
- mScrollRunnable.run();
- mRecyclerView.invalidate();
- }
- break;
- }
- case MotionEvent.ACTION_CANCEL:
- if (mVelocityTracker != null) {
- mVelocityTracker.clear();
- }
- // fall through
- case MotionEvent.ACTION_UP:
- select(null, ACTION_STATE_IDLE);
- mActivePointerId = ACTIVE_POINTER_ID_NONE;
- break;
- case MotionEvent.ACTION_POINTER_UP: {
- final int pointerIndex = event.getActionIndex();
- final int pointerId = event.getPointerId(pointerIndex);
- if (pointerId == mActivePointerId) {
- // This was our active pointer going up. Choose a new
- // active pointer and adjust accordingly.
- final int newPointerIndex = pointerIndex == 0 ? 1 : 0;
- mActivePointerId = event.getPointerId(newPointerIndex);
- updateDxDy(event, mSelectedFlags, pointerIndex);
- }
- break;
- }
- }
- }
-
- @Override
- public void onRequestDisallowInterceptTouchEvent(boolean disallowIntercept) {
- if (!disallowIntercept) {
- return;
- }
- select(null, ACTION_STATE_IDLE);
- }
- };
-
- /**
- * Temporary rect instance that is used when we need to lookup Item decorations.
- */
- private Rect mTmpRect;
-
- /**
- * When user started to drag scroll. Reset when we don't scroll
- */
- private long mDragScrollStartTimeInMs;
-
- /**
- * Creates an ItemTouchHelper that will work with the given Callback.
- *
- * You can attach ItemTouchHelper to a RecyclerView via
- * {@link #attachToRecyclerView(RecyclerView)}. Upon attaching, it will add an item decoration,
- * an onItemTouchListener and a Child attach / detach listener to the RecyclerView.
- *
- * @param callback The Callback which controls the behavior of this touch helper.
- */
- public ItemTouchHelper(@NonNull Callback callback) {
- mCallback = callback;
- }
-
- private static boolean hitTest(View child, float x, float y, float left, float top) {
- return x >= left
- && x <= left + child.getWidth()
- && y >= top
- && y <= top + child.getHeight();
- }
-
- /**
- * Attaches the ItemTouchHelper to the provided RecyclerView. If TouchHelper is already
- * attached to a RecyclerView, it will first detach from the previous one. You can call this
- * method with {@code null} to detach it from the current RecyclerView.
- *
- * @param recyclerView The RecyclerView instance to which you want to add this helper or
- * {@code null} if you want to remove ItemTouchHelper from the current
- * RecyclerView.
- */
- public void attachToRecyclerView(@Nullable RecyclerView recyclerView) {
- if (mRecyclerView == recyclerView) {
- return; // nothing to do
- }
- if (mRecyclerView != null) {
- destroyCallbacks();
- }
- mRecyclerView = recyclerView;
- if (recyclerView != null) {
- final Resources resources = recyclerView.getResources();
- mSwipeEscapeVelocity = resources
- .getDimension(R.dimen.item_touch_helper_swipe_escape_velocity);
- mMaxSwipeVelocity = resources
- .getDimension(R.dimen.item_touch_helper_swipe_escape_max_velocity);
- setupCallbacks();
- }
- }
-
- private void setupCallbacks() {
- ViewConfiguration vc = ViewConfiguration.get(mRecyclerView.getContext());
- mSlop = vc.getScaledTouchSlop();
- mRecyclerView.addItemDecoration(this);
- mRecyclerView.addOnItemTouchListener(mOnItemTouchListener);
- mRecyclerView.addOnChildAttachStateChangeListener(this);
- startGestureDetection();
- }
-
- private void destroyCallbacks() {
- mRecyclerView.removeItemDecoration(this);
- mRecyclerView.removeOnItemTouchListener(mOnItemTouchListener);
- mRecyclerView.removeOnChildAttachStateChangeListener(this);
- // clean all attached
- final int recoverAnimSize = mRecoverAnimations.size();
- for (int i = recoverAnimSize - 1; i >= 0; i--) {
- final RecoverAnimation recoverAnimation = mRecoverAnimations.get(0);
- recoverAnimation.cancel();
- mCallback.clearView(mRecyclerView, recoverAnimation.mViewHolder);
- }
- mRecoverAnimations.clear();
- mOverdrawChild = null;
- mOverdrawChildPosition = -1;
- releaseVelocityTracker();
- stopGestureDetection();
- }
-
- private void startGestureDetection() {
- mItemTouchHelperGestureListener = new ItemTouchHelperGestureListener();
- mGestureDetector = new GestureDetectorCompat(mRecyclerView.getContext(),
- mItemTouchHelperGestureListener);
- }
-
- private void stopGestureDetection() {
- if (mItemTouchHelperGestureListener != null) {
- mItemTouchHelperGestureListener.doNotReactToLongPress();
- mItemTouchHelperGestureListener = null;
- }
- if (mGestureDetector != null) {
- mGestureDetector = null;
- }
- }
-
- private void getSelectedDxDy(float[] outPosition) {
- if ((mSelectedFlags & (LEFT | RIGHT)) != 0) {
- outPosition[0] = mSelectedStartX + mDx - mSelected.itemView.getLeft();
- } else {
- outPosition[0] = mSelected.itemView.getTranslationX();
- }
- if ((mSelectedFlags & (UP | DOWN)) != 0) {
- outPosition[1] = mSelectedStartY + mDy - mSelected.itemView.getTop();
- } else {
- outPosition[1] = mSelected.itemView.getTranslationY();
- }
- }
-
- @Override
- public void onDrawOver(
- @NonNull Canvas c,
- @NonNull RecyclerView parent,
- @NonNull RecyclerView.State state
- ) {
- float dx = 0, dy = 0;
- if (mSelected != null) {
- getSelectedDxDy(mTmpPosition);
- dx = mTmpPosition[0];
- dy = mTmpPosition[1];
- }
- mCallback.onDrawOver(c, parent, mSelected,
- mRecoverAnimations, mActionState, dx, dy);
- }
-
- @Override
- @SuppressLint("UnknownNullness") // b/240775049: Cannot annotate properly
- public void onDraw(Canvas c, RecyclerView parent, RecyclerView.State state) {
- // we don't know if RV changed something so we should invalidate this index.
- mOverdrawChildPosition = -1;
- float dx = 0, dy = 0;
- if (mSelected != null) {
- getSelectedDxDy(mTmpPosition);
- dx = mTmpPosition[0];
- dy = mTmpPosition[1];
- }
- mCallback.onDraw(c, parent, mSelected,
- mRecoverAnimations, mActionState, dx, dy);
- }
-
- /**
- * Starts dragging or swiping the given View. Call with null if you want to clear it.
- *
- * @param selected The ViewHolder to drag or swipe. Can be null if you want to cancel the
- * current action, but may not be null if actionState is ACTION_STATE_DRAG.
- * @param actionState The type of action
- */
- @SuppressWarnings("WeakerAccess") /* synthetic access */
- void select(@Nullable ViewHolder selected, int actionState) {
- if (selected == mSelected && actionState == mActionState) {
- return;
- }
- mDragScrollStartTimeInMs = Long.MIN_VALUE;
- final int prevActionState = mActionState;
- // prevent duplicate animations
- endRecoverAnimation(selected, true);
- mActionState = actionState;
- if (actionState == ACTION_STATE_DRAG) {
- if (selected == null) {
- throw new IllegalArgumentException("Must pass a ViewHolder when dragging");
- }
-
- // we remove after animation is complete. this means we only elevate the last drag
- // child but that should perform good enough as it is very hard to start dragging a
- // new child before the previous one settles.
- mOverdrawChild = selected.itemView;
- addChildDrawingOrderCallback();
- }
- int actionStateMask = (1 << (DIRECTION_FLAG_COUNT + DIRECTION_FLAG_COUNT * actionState))
- - 1;
- boolean preventLayout = false;
-
- if (mSelected != null) {
- final ViewHolder prevSelected = mSelected;
- if (prevSelected.itemView.getParent() != null) {
- final int swipeDir = prevActionState == ACTION_STATE_DRAG ? 0
- : swipeIfNecessary(prevSelected);
- releaseVelocityTracker();
- // find where we should animate to
- final float targetTranslateX, targetTranslateY;
- int animationType;
- switch (swipeDir) {
- case LEFT:
- case RIGHT:
- case START:
- case END:
- targetTranslateY = 0;
- targetTranslateX = Math.signum(mDx) * mRecyclerView.getWidth();
- break;
- case UP:
- case DOWN:
- targetTranslateX = 0;
- targetTranslateY = Math.signum(mDy) * mRecyclerView.getHeight();
- break;
- default:
- targetTranslateX = 0;
- targetTranslateY = 0;
- }
- if (prevActionState == ACTION_STATE_DRAG) {
- animationType = ANIMATION_TYPE_DRAG;
- } else if (swipeDir > 0) {
- animationType = ANIMATION_TYPE_SWIPE_SUCCESS;
- } else {
- animationType = ANIMATION_TYPE_SWIPE_CANCEL;
- }
- getSelectedDxDy(mTmpPosition);
- final float currentTranslateX = mTmpPosition[0];
- final float currentTranslateY = mTmpPosition[1];
- final RecoverAnimation rv = new RecoverAnimation(prevSelected, animationType,
- prevActionState, currentTranslateX, currentTranslateY,
- targetTranslateX, targetTranslateY) {
- @Override
- public void onAnimationEnd(Animator animation) {
- super.onAnimationEnd(animation);
- if (this.mOverridden) {
- return;
- }
- if (swipeDir <= 0) {
- // this is a drag or failed swipe. recover immediately
- mCallback.clearView(mRecyclerView, prevSelected);
- // full cleanup will happen on onDrawOver
- } else {
- // wait until remove animation is complete.
- mPendingCleanup.add(prevSelected.itemView);
- mIsPendingCleanup = true;
- if (swipeDir > 0) {
- // Animation might be ended by other animators during a layout.
- // We defer callback to avoid editing adapter during a layout.
- postDispatchSwipe(this, swipeDir);
- }
- }
- // removed from the list after it is drawn for the last time
- if (mOverdrawChild == prevSelected.itemView) {
- removeChildDrawingOrderCallbackIfNecessary(prevSelected.itemView);
- }
- }
- };
- final long duration = mCallback.getAnimationDuration(mRecyclerView, animationType,
- targetTranslateX - currentTranslateX, targetTranslateY - currentTranslateY);
- rv.setDuration(duration);
- mRecoverAnimations.add(rv);
- rv.start();
- preventLayout = true;
- } else {
- removeChildDrawingOrderCallbackIfNecessary(prevSelected.itemView);
- mCallback.clearView(mRecyclerView, prevSelected);
- }
- mSelected = null;
- }
- if (selected != null) {
- mSelectedFlags =
- (mCallback.getAbsoluteMovementFlags(mRecyclerView, selected) & actionStateMask)
- >> (mActionState * DIRECTION_FLAG_COUNT);
- mSelectedStartX = selected.itemView.getLeft();
- mSelectedStartY = selected.itemView.getTop();
- mSelected = selected;
-
- if (actionState == ACTION_STATE_DRAG) {
- mSelected.itemView.performHapticFeedback(HapticFeedbackConstants.LONG_PRESS);
- }
- }
- final ViewParent rvParent = mRecyclerView.getParent();
- if (rvParent != null) {
- rvParent.requestDisallowInterceptTouchEvent(mSelected != null);
- }
- if (!preventLayout) {
- mRecyclerView.getLayoutManager().requestSimpleAnimationsInNextLayout();
- }
- mCallback.onSelectedChanged(mSelected, mActionState);
- mRecyclerView.invalidate();
- }
-
- @SuppressWarnings("WeakerAccess") /* synthetic access */
- void postDispatchSwipe(final RecoverAnimation anim, final int swipeDir) {
- // wait until animations are complete.
- mRecyclerView.post(new Runnable() {
- @Override
- public void run() {
- if (mRecyclerView != null && mRecyclerView.isAttachedToWindow()
- && !anim.mOverridden
- && anim.mViewHolder.getAbsoluteAdapterPosition()
- != RecyclerView.NO_POSITION) {
- final RecyclerView.ItemAnimator animator = mRecyclerView.getItemAnimator();
- // if animator is running or we have other active recover animations, we try
- // not to call onSwiped because DefaultItemAnimator is not good at merging
- // animations. Instead, we wait and batch.
- if ((animator == null || !animator.isRunning(null))
- && !hasRunningRecoverAnim()) {
- mCallback.onSwiped(anim.mViewHolder, swipeDir);
- } else {
- mRecyclerView.post(this);
- }
- }
- }
- });
- }
-
- @SuppressWarnings("WeakerAccess") /* synthetic access */
- boolean hasRunningRecoverAnim() {
- final int size = mRecoverAnimations.size();
- for (int i = 0; i < size; i++) {
- if (!mRecoverAnimations.get(i).mEnded) {
- return true;
- }
- }
- return false;
- }
-
- /**
- * If user drags the view to the edge, trigger a scroll if necessary.
- */
- @SuppressWarnings("WeakerAccess") /* synthetic access */
- boolean scrollIfNecessary() {
- if (mSelected == null) {
- mDragScrollStartTimeInMs = Long.MIN_VALUE;
- return false;
- }
- final long now = System.currentTimeMillis();
- final long scrollDuration = mDragScrollStartTimeInMs
- == Long.MIN_VALUE ? 0 : now - mDragScrollStartTimeInMs;
- RecyclerView.LayoutManager lm = mRecyclerView.getLayoutManager();
- if (mTmpRect == null) {
- mTmpRect = new Rect();
- }
- int scrollX = 0;
- int scrollY = 0;
- lm.calculateItemDecorationsForChild(mSelected.itemView, mTmpRect);
- if (lm.canScrollHorizontally()) {
- int curX = (int) (mSelectedStartX + mDx);
- final int leftDiff = curX - mTmpRect.left - mRecyclerView.getPaddingLeft();
- if (mDx < 0 && leftDiff < 0) {
- scrollX = leftDiff;
- } else if (mDx > 0) {
- final int rightDiff =
- curX + mSelected.itemView.getWidth() + mTmpRect.right
- - (mRecyclerView.getWidth() - mRecyclerView.getPaddingRight());
- if (rightDiff > 0) {
- scrollX = rightDiff;
- }
- }
- }
- if (lm.canScrollVertically()) {
- int curY = (int) (mSelectedStartY + mDy);
- final int topDiff = curY - mTmpRect.top - mRecyclerView.getPaddingTop();
- if (mDy < 0 && topDiff < 0) {
- scrollY = topDiff;
- } else if (mDy > 0) {
- final int bottomDiff = curY + mSelected.itemView.getHeight() + mTmpRect.bottom
- - (mRecyclerView.getHeight() - mRecyclerView.getPaddingBottom());
- if (bottomDiff > 0) {
- scrollY = bottomDiff;
- }
- }
- }
- if (scrollX != 0) {
- scrollX = mCallback.interpolateOutOfBoundsScroll(mRecyclerView,
- mSelected.itemView.getWidth(), scrollX,
- mRecyclerView.getWidth(), scrollDuration);
- }
- if (scrollY != 0) {
- scrollY = mCallback.interpolateOutOfBoundsScroll(mRecyclerView,
- mSelected.itemView.getHeight(), scrollY,
- mRecyclerView.getHeight(), scrollDuration);
- }
- if (scrollX != 0 || scrollY != 0) {
- if (mDragScrollStartTimeInMs == Long.MIN_VALUE) {
- mDragScrollStartTimeInMs = now;
- }
- mRecyclerView.scrollBy(scrollX, scrollY);
- return true;
- }
- mDragScrollStartTimeInMs = Long.MIN_VALUE;
- return false;
- }
-
- private List findSwapTargets(ViewHolder viewHolder) {
- if (mSwapTargets == null) {
- mSwapTargets = new ArrayList<>();
- mDistances = new ArrayList<>();
- } else {
- mSwapTargets.clear();
- mDistances.clear();
- }
- final int margin = mCallback.getBoundingBoxMargin();
- final int left = Math.round(mSelectedStartX + mDx) - margin;
- final int top = Math.round(mSelectedStartY + mDy) - margin;
- final int right = left + viewHolder.itemView.getWidth() + 2 * margin;
- final int bottom = top + viewHolder.itemView.getHeight() + 2 * margin;
- final int centerX = (left + right) / 2;
- final int centerY = (top + bottom) / 2;
- final RecyclerView.LayoutManager lm = mRecyclerView.getLayoutManager();
- final int childCount = lm.getChildCount();
- for (int i = 0; i < childCount; i++) {
- View other = lm.getChildAt(i);
- if (other == viewHolder.itemView) {
- continue; //myself!
- }
- if (other.getBottom() < top || other.getTop() > bottom
- || other.getRight() < left || other.getLeft() > right) {
- continue;
- }
- final ViewHolder otherVh = mRecyclerView.getChildViewHolder(other);
- if (mCallback.canDropOver(mRecyclerView, mSelected, otherVh)) {
- // find the index to add
- final int dx = Math.abs(centerX - (other.getLeft() + other.getRight()) / 2);
- final int dy = Math.abs(centerY - (other.getTop() + other.getBottom()) / 2);
- final int dist = dx * dx + dy * dy;
-
- int pos = 0;
- final int cnt = mSwapTargets.size();
- for (int j = 0; j < cnt; j++) {
- if (dist > mDistances.get(j)) {
- pos++;
- } else {
- break;
- }
- }
- mSwapTargets.add(pos, otherVh);
- mDistances.add(pos, dist);
- }
- }
- return mSwapTargets;
- }
-
- /**
- * Checks if we should swap w/ another view holder.
- */
- @SuppressWarnings("WeakerAccess") /* synthetic access */
- 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 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.getAbsoluteAdapterPosition();
- final int fromPosition = viewHolder.getAbsoluteAdapterPosition();
- if (mCallback.onMove(mRecyclerView, viewHolder, target)) {
- // keep target visible
- mCallback.onMoved(mRecyclerView, viewHolder, fromPosition,
- target, toPosition, x, y);
- }
- }
-
- @Override
- public void onChildViewAttachedToWindow(@NonNull View view) {
- }
-
- @Override
- public void onChildViewDetachedFromWindow(@NonNull 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);
- }
- }
- }
-
- /**
- * Returns the animation type or 0 if cannot be found.
- */
- @SuppressWarnings("WeakerAccess") /* synthetic access */
- void 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;
- }
- }
- }
-
- @Override
- @SuppressLint("UnknownNullness") // b/240775049: Cannot annotate properly
- public void getItemOffsets(Rect outRect, View view, RecyclerView parent,
- RecyclerView.State state) {
- outRect.setEmpty();
- }
-
- @SuppressWarnings("WeakerAccess") /* synthetic access */
- void obtainVelocityTracker() {
- if (mVelocityTracker != null) {
- mVelocityTracker.recycle();
- }
- mVelocityTracker = VelocityTracker.obtain();
- }
-
- private void releaseVelocityTracker() {
- if (mVelocityTracker != null) {
- mVelocityTracker.recycle();
- mVelocityTracker = null;
- }
- }
-
- private ViewHolder findSwipedView(MotionEvent motionEvent) {
- final RecyclerView.LayoutManager lm = mRecyclerView.getLayoutManager();
- if (mActivePointerId == ACTIVE_POINTER_ID_NONE) {
- return null;
- }
- final int pointerIndex = motionEvent.findPointerIndex(mActivePointerId);
- final float dx = motionEvent.getX(pointerIndex) - mInitialTouchX;
- final float dy = motionEvent.getY(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);
- }
-
- /**
- * Checks whether we should select a View for swiping.
- */
- @SuppressWarnings("WeakerAccess") /* synthetic access */
- void checkSelectForSwipe(int action, MotionEvent motionEvent, int pointerIndex) {
- if (mSelected != null || action != MotionEvent.ACTION_MOVE
- || mActionState == ACTION_STATE_DRAG || !mCallback.isItemViewSwipeEnabled()) {
- return;
- }
- if (mRecyclerView.getScrollState() == RecyclerView.SCROLL_STATE_DRAGGING) {
- return;
- }
- final ViewHolder vh = findSwipedView(motionEvent);
- if (vh == null) {
- return;
- }
- final int movementFlags = mCallback.getAbsoluteMovementFlags(mRecyclerView, vh);
-
- final int swipeFlags = (movementFlags & ACTION_MODE_SWIPE_MASK)
- >> (DIRECTION_FLAG_COUNT * ACTION_STATE_SWIPE);
-
- if (swipeFlags == 0) {
- return;
- }
-
- // mDx and mDy are only set in allowed directions. We use custom x/y here instead of
- // updateDxDy to avoid swiping if user moves more in the other direction
- final float x = motionEvent.getX(pointerIndex);
- final float y = motionEvent.getY(pointerIndex);
-
- // Calculate the distance moved
- final float dx = x - mInitialTouchX;
- final float dy = y - mInitialTouchY;
- // swipe target is chose w/o applying flags so it does not really check if swiping in that
- // direction is allowed. This why here, we use mDx mDy to check slope value again.
- final float absDx = Math.abs(dx);
- final float absDy = Math.abs(dy);
-
- if (absDx < mSlop && absDy < mSlop) {
- return;
- }
- if (absDx > absDy) {
- if (dx < 0 && (swipeFlags & LEFT) == 0) {
- return;
- }
- if (dx > 0 && (swipeFlags & RIGHT) == 0) {
- return;
- }
- } else {
- if (dy < 0 && (swipeFlags & UP) == 0) {
- return;
- }
- if (dy > 0 && (swipeFlags & DOWN) == 0) {
- return;
- }
- }
- mDx = mDy = 0f;
- mActivePointerId = motionEvent.getPointerId(0);
- select(vh, ACTION_STATE_SWIPE);
- }
-
- @SuppressWarnings("WeakerAccess") /* synthetic access */
- View findChildView(MotionEvent event) {
- // first check elevated views, if none, then call RV
- final float x = event.getX();
- final float y = event.getY();
- if (mSelected != null) {
- final View selectedView = mSelected.itemView;
- if (hitTest(selectedView, x, y, mSelectedStartX + mDx, mSelectedStartY + mDy)) {
- return selectedView;
- }
- }
- for (int i = mRecoverAnimations.size() - 1; i >= 0; i--) {
- final RecoverAnimation anim = mRecoverAnimations.get(i);
- final View view = anim.mViewHolder.itemView;
- if (hitTest(view, x, y, anim.mX, anim.mY)) {
- return view;
- }
- }
- return mRecyclerView.findChildViewUnder(x, y);
- }
-
- /**
- * Starts dragging the provided ViewHolder. By default, ItemTouchHelper starts a drag when a
- * View is long pressed. You can disable that behavior by overriding
- * {@link ItemTouchHelper.Callback#isLongPressDragEnabled()}.
- *
- * For this method to work:
- *
- * The provided ViewHolder must be a child of the RecyclerView to which this
- * ItemTouchHelper
- * is attached.
- * {@link ItemTouchHelper.Callback} must have dragging enabled.
- * There must be a previous touch event that was reported to the ItemTouchHelper
- * through RecyclerView's ItemTouchListener mechanism. As long as no other ItemTouchListener
- * grabs previous events, this should work as expected.
- *
- *
- * For example, if you would like to let your user to be able to drag an Item by touching one
- * of its descendants, you may implement it as follows:
- *
- * viewHolder.dragButton.setOnTouchListener(new View.OnTouchListener() {
- * public boolean onTouch(View v, MotionEvent event) {
- * if (MotionEvent.getActionMasked(event) == MotionEvent.ACTION_DOWN) {
- * mItemTouchHelper.startDrag(viewHolder);
- * }
- * return false;
- * }
- * });
- *
- *
- *
- * @param viewHolder The ViewHolder to start dragging. It must be a direct child of
- * RecyclerView.
- * @see ItemTouchHelper.Callback#isItemViewSwipeEnabled()
- */
- public void startDrag(@NonNull ViewHolder viewHolder) {
- if (!mCallback.hasDragFlag(mRecyclerView, viewHolder)) {
- Log.e(TAG, "Start drag has been called but dragging is not enabled");
- return;
- }
- if (viewHolder.itemView.getParent() != 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.");
- return;
- }
- obtainVelocityTracker();
- mDx = mDy = 0f;
- select(viewHolder, ACTION_STATE_DRAG);
- }
-
- /**
- * Starts swiping the provided ViewHolder. By default, ItemTouchHelper starts swiping a View
- * when user swipes their finger (or mouse pointer) over the View. You can disable this
- * behavior
- * by overriding {@link ItemTouchHelper.Callback}
- *
- * For this method to work:
- *
- * The provided ViewHolder must be a child of the RecyclerView to which this
- * ItemTouchHelper is attached.
- * {@link ItemTouchHelper.Callback} must have swiping enabled.
- * There must be a previous touch event that was reported to the ItemTouchHelper
- * through RecyclerView's ItemTouchListener mechanism. As long as no other ItemTouchListener
- * grabs previous events, this should work as expected.
- *
- *
- * For example, if you would like to let your user to be able to swipe an Item by touching one
- * of its descendants, you may implement it as follows:
- *
- * viewHolder.dragButton.setOnTouchListener(new View.OnTouchListener() {
- * public boolean onTouch(View v, MotionEvent event) {
- * if (MotionEvent.getActionMasked(event) == MotionEvent.ACTION_DOWN) {
- * mItemTouchHelper.startSwipe(viewHolder);
- * }
- * return false;
- * }
- * });
- *
- *
- * @param viewHolder The ViewHolder to start swiping. It must be a direct child of
- * RecyclerView.
- */
- public void startSwipe(@NonNull ViewHolder viewHolder) {
- if (!mCallback.hasSwipeFlag(mRecyclerView, viewHolder)) {
- Log.e(TAG, "Start swipe has been called but swiping is not enabled");
- return;
- }
- if (viewHolder.itemView.getParent() != 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.");
- return;
- }
- obtainVelocityTracker();
- mDx = mDy = 0f;
- select(viewHolder, ACTION_STATE_SWIPE);
- }
-
- @SuppressWarnings("WeakerAccess") /* synthetic access */
- RecoverAnimation findAnimation(MotionEvent event) {
- if (mRecoverAnimations.isEmpty()) {
- return null;
- }
- View target = findChildView(event);
- for (int i = mRecoverAnimations.size() - 1; i >= 0; i--) {
- final RecoverAnimation anim = mRecoverAnimations.get(i);
- if (anim.mViewHolder.itemView == target) {
- return anim;
- }
- }
- return null;
- }
-
- @SuppressWarnings("WeakerAccess") /* synthetic access */
- void updateDxDy(MotionEvent ev, int directionFlags, int pointerIndex) {
- final float x = ev.getX(pointerIndex);
- final float y = ev.getY(pointerIndex);
-
- // Calculate the distance moved
- mDx = x - mInitialTouchX;
- mDy = y - mInitialTouchY;
- if ((directionFlags & LEFT) == 0) {
- mDx = Math.max(0, mDx);
- }
- if ((directionFlags & RIGHT) == 0) {
- mDx = Math.min(0, mDx);
- }
- if ((directionFlags & UP) == 0) {
- mDy = Math.max(0, mDy);
- }
- if ((directionFlags & DOWN) == 0) {
- mDy = Math.min(0, mDy);
- }
- }
-
- private int swipeIfNecessary(ViewHolder viewHolder) {
- if (mActionState == ACTION_STATE_DRAG) {
- return 0;
- }
- final int originalMovementFlags = mCallback.getMovementFlags(mRecyclerView, viewHolder);
- final int absoluteMovementFlags = mCallback.convertToAbsoluteDirection(
- originalMovementFlags,
- ViewCompat.getLayoutDirection(mRecyclerView));
- final int flags = (absoluteMovementFlags
- & ACTION_MODE_SWIPE_MASK) >> (ACTION_STATE_SWIPE * DIRECTION_FLAG_COUNT);
- if (flags == 0) {
- return 0;
- }
- final int originalFlags = (originalMovementFlags
- & ACTION_MODE_SWIPE_MASK) >> (ACTION_STATE_SWIPE * DIRECTION_FLAG_COUNT);
- int swipeDir;
- if (Math.abs(mDx) > Math.abs(mDy)) {
- if ((swipeDir = checkHorizontalSwipe(viewHolder, flags)) > 0) {
- // if swipe dir is not in original flags, it should be the relative direction
- if ((originalFlags & swipeDir) == 0) {
- // convert to relative
- return Callback.convertToRelativeDirection(swipeDir,
- ViewCompat.getLayoutDirection(mRecyclerView));
- }
- return swipeDir;
- }
- if ((swipeDir = checkVerticalSwipe(viewHolder, flags)) > 0) {
- return swipeDir;
- }
- } else {
- if ((swipeDir = checkVerticalSwipe(viewHolder, flags)) > 0) {
- return swipeDir;
- }
- if ((swipeDir = checkHorizontalSwipe(viewHolder, flags)) > 0) {
- // if swipe dir is not in original flags, it should be the relative direction
- if ((originalFlags & swipeDir) == 0) {
- // convert to relative
- return Callback.convertToRelativeDirection(swipeDir,
- ViewCompat.getLayoutDirection(mRecyclerView));
- }
- return swipeDir;
- }
- }
- return 0;
- }
-
- private int checkHorizontalSwipe(ViewHolder viewHolder, int flags) {
- if ((flags & (LEFT | RIGHT)) != 0) {
- final int dirFlag = mDx > 0 ? RIGHT : LEFT;
- if (mVelocityTracker != null && mActivePointerId > -1) {
- mVelocityTracker.computeCurrentVelocity(PIXELS_PER_SECOND,
- mCallback.getSwipeVelocityThreshold(mMaxSwipeVelocity));
- final float xVelocity = mVelocityTracker.getXVelocity(mActivePointerId);
- final float yVelocity = mVelocityTracker.getYVelocity(mActivePointerId);
- final int velDirFlag = xVelocity > 0f ? RIGHT : LEFT;
- final float absXVelocity = Math.abs(xVelocity);
- if ((velDirFlag & flags) != 0 && dirFlag == velDirFlag
- && absXVelocity >= mCallback.getSwipeEscapeVelocity(mSwipeEscapeVelocity)
- && absXVelocity > Math.abs(yVelocity)) {
- return velDirFlag;
- }
- }
-
- final float threshold = mRecyclerView.getWidth() * mCallback
- .getSwipeThreshold(viewHolder);
-
- if ((flags & dirFlag) != 0 && Math.abs(mDx) > threshold) {
- return dirFlag;
- }
- }
- return 0;
- }
-
- private int checkVerticalSwipe(ViewHolder viewHolder, int flags) {
- if ((flags & (UP | DOWN)) != 0) {
- final int dirFlag = mDy > 0 ? DOWN : UP;
- if (mVelocityTracker != null && mActivePointerId > -1) {
- mVelocityTracker.computeCurrentVelocity(PIXELS_PER_SECOND,
- mCallback.getSwipeVelocityThreshold(mMaxSwipeVelocity));
- final float xVelocity = mVelocityTracker.getXVelocity(mActivePointerId);
- final float yVelocity = mVelocityTracker.getYVelocity(mActivePointerId);
- final int velDirFlag = yVelocity > 0f ? DOWN : UP;
- final float absYVelocity = Math.abs(yVelocity);
- if ((velDirFlag & flags) != 0 && velDirFlag == dirFlag
- && absYVelocity >= mCallback.getSwipeEscapeVelocity(mSwipeEscapeVelocity)
- && absYVelocity > Math.abs(xVelocity)) {
- return velDirFlag;
- }
- }
-
- final float threshold = mRecyclerView.getHeight() * mCallback
- .getSwipeThreshold(viewHolder);
- if ((flags & dirFlag) != 0 && Math.abs(mDy) > threshold) {
- return dirFlag;
- }
- }
- return 0;
- }
-
- private void addChildDrawingOrderCallback() {
- if (Build.VERSION.SDK_INT >= 21) {
- return; // we use elevation on Lollipop
- }
- if (mChildDrawingOrderCallback == null) {
- mChildDrawingOrderCallback = new RecyclerView.ChildDrawingOrderCallback() {
- @Override
- public int onGetChildDrawingOrder(int childCount, int i) {
- if (mOverdrawChild == null) {
- return i;
- }
- int childPosition = mOverdrawChildPosition;
- if (childPosition == -1) {
- childPosition = mRecyclerView.indexOfChild(mOverdrawChild);
- mOverdrawChildPosition = childPosition;
- }
- if (i == childCount - 1) {
- return childPosition;
- }
- return i < childPosition ? i : i + 1;
- }
- };
- }
- mRecyclerView.setChildDrawingOrderCallback(mChildDrawingOrderCallback);
- }
-
- @SuppressWarnings("WeakerAccess") /* synthetic access */
- void removeChildDrawingOrderCallbackIfNecessary(View view) {
- if (view == mOverdrawChild) {
- mOverdrawChild = null;
- // only remove if we've added
- if (mChildDrawingOrderCallback != null) {
- mRecyclerView.setChildDrawingOrderCallback(null);
- }
- }
- }
-
- /**
- * An interface which can be implemented by LayoutManager for better integration with
- * {@link ItemTouchHelper}.
- */
- public interface ViewDropHandler {
-
- /**
- * Called by the {@link ItemTouchHelper} after a View is dropped over another View.
- *
- * A LayoutManager should implement this interface to get ready for the upcoming move
- * operation.
- *
- * For example, LinearLayoutManager sets up a "scrollToPositionWithOffset" calls so that
- * the View under drag will be used as an anchor View while calculating the next layout,
- * making layout stay consistent.
- *
- * @param view The View which is being dragged. It is very likely that user is still
- * dragging this View so there might be other calls to
- * {@code prepareForDrop()} after this one.
- * @param target The target view which is being dropped on.
- * @param x The left offset of the View that is being dragged. This value
- * includes the movement caused by the user.
- * @param y The top offset of the View that is being dragged. This value
- * includes the movement caused by the user.
- */
- void prepareForDrop(@NonNull View view, @NonNull View target, int x, int y);
- }
-
- /**
- * This class is the contract between ItemTouchHelper and your application. It lets you control
- * which touch behaviors are enabled per each ViewHolder and also receive callbacks when user
- * performs these actions.
- *
- * To control which actions user can take on each view, you should override
- * {@link #getMovementFlags(RecyclerView, ViewHolder)} and return appropriate set
- * of direction flags. ({@link #LEFT}, {@link #RIGHT}, {@link #START}, {@link #END},
- * {@link #UP}, {@link #DOWN}). You can use
- * {@link #makeMovementFlags(int, int)} to easily construct it. Alternatively, you can use
- * {@link SimpleCallback}.
- *
- * If user drags an item, ItemTouchHelper will call
- * {@link Callback#onMove(RecyclerView, ViewHolder, ViewHolder)
- * onMove(recyclerView, dragged, target)}.
- * Upon receiving this callback, you should move the item from the old position
- * ({@code dragged.getAdapterPosition()}) to new position ({@code target.getAdapterPosition()})
- * in your adapter and also call {@link RecyclerView.Adapter#notifyItemMoved(int, int)}.
- * To control where a View can be dropped, you can override
- * {@link #canDropOver(RecyclerView, ViewHolder, ViewHolder)}. When a
- * dragging View overlaps multiple other views, Callback chooses the closest View with which
- * dragged View might have changed positions. Although this approach works for many use cases,
- * if you have a custom LayoutManager, you can override
- * {@link #chooseDropTarget(ViewHolder, java.util.List, int, int)} to select a
- * custom drop target.
- *
- * When a View is swiped, ItemTouchHelper animates it until it goes out of bounds, then calls
- * {@link #onSwiped(ViewHolder, int)}. At this point, you should update your
- * adapter (e.g. remove the item) and call related Adapter#notify event.
- */
- @SuppressWarnings("UnusedParameters")
- public abstract static class Callback {
-
- @SuppressWarnings("WeakerAccess")
- public static final int DEFAULT_DRAG_ANIMATION_DURATION = 200;
-
- @SuppressWarnings("WeakerAccess")
- public static final int DEFAULT_SWIPE_ANIMATION_DURATION = 250;
-
- static final int RELATIVE_DIR_FLAGS = START | END
- | ((START | END) << DIRECTION_FLAG_COUNT)
- | ((START | END) << (2 * DIRECTION_FLAG_COUNT));
-
- private static final int ABS_HORIZONTAL_DIR_FLAGS = LEFT | RIGHT
- | ((LEFT | RIGHT) << DIRECTION_FLAG_COUNT)
- | ((LEFT | RIGHT) << (2 * DIRECTION_FLAG_COUNT));
-
- private static final Interpolator sDragScrollInterpolator = new Interpolator() {
- @Override
- public float getInterpolation(float t) {
- return t * t * t * t * t;
- }
- };
-
- private static final Interpolator sDragViewScrollCapInterpolator = new Interpolator() {
- @Override
- public float getInterpolation(float t) {
- t -= 1.0f;
- return t * t * t * t * t + 1.0f;
- }
- };
-
- /**
- * Drag scroll speed keeps accelerating until this many milliseconds before being capped.
- */
- private static final long DRAG_SCROLL_ACCELERATION_LIMIT_TIME_MS = 2000;
-
- private int mCachedMaxScrollSpeed = -1;
-
- /**
- * Returns the {@link ItemTouchUIUtil} that is used by the {@link Callback} class for
- * visual
- * changes on Views in response to user interactions. {@link ItemTouchUIUtil} has different
- * implementations for different platform versions.
- *
- * By default, {@link Callback} applies these changes on
- * {@link RecyclerView.ViewHolder#itemView}.
- *
- * For example, if you have a use case where you only want the text to move when user
- * swipes over the view, you can do the following:
- *
- * public void clearView(RecyclerView recyclerView, RecyclerView.ViewHolder viewHolder){
- * getDefaultUIUtil().clearView(((ItemTouchViewHolder) viewHolder).textView);
- * }
- * public void onSelectedChanged(RecyclerView.ViewHolder viewHolder, int actionState) {
- * if (viewHolder != null){
- * getDefaultUIUtil().onSelected(((ItemTouchViewHolder) viewHolder).textView);
- * }
- * }
- * public void onChildDraw(Canvas c, RecyclerView recyclerView,
- * RecyclerView.ViewHolder viewHolder, float dX, float dY, int actionState,
- * boolean isCurrentlyActive) {
- * getDefaultUIUtil().onDraw(c, recyclerView,
- * ((ItemTouchViewHolder) viewHolder).textView, dX, dY,
- * actionState, isCurrentlyActive);
- * return true;
- * }
- * public void onChildDrawOver(Canvas c, RecyclerView recyclerView,
- * RecyclerView.ViewHolder viewHolder, float dX, float dY, int actionState,
- * boolean isCurrentlyActive) {
- * getDefaultUIUtil().onDrawOver(c, recyclerView,
- * ((ItemTouchViewHolder) viewHolder).textView, dX, dY,
- * actionState, isCurrentlyActive);
- * return true;
- * }
- *
- *
- * @return The {@link ItemTouchUIUtil} instance that is used by the {@link Callback}
- */
- @SuppressWarnings("WeakerAccess")
- @NonNull
- public static ItemTouchUIUtil getDefaultUIUtil() {
- return ItemTouchUIUtilImpl.INSTANCE;
- }
-
- /**
- * Replaces a movement direction with its relative version by taking layout direction into
- * account.
- *
- * @param flags The flag value that include any number of movement flags.
- * @param layoutDirection The layout direction of the View. Can be obtained from
- * {@link ViewCompat#getLayoutDirection(android.view.View)}.
- * @return Updated flags which uses relative flags ({@link #START}, {@link #END}) instead
- * of {@link #LEFT}, {@link #RIGHT}.
- * @see #convertToAbsoluteDirection(int, int)
- */
- @SuppressWarnings("WeakerAccess")
- public static int convertToRelativeDirection(int flags, int layoutDirection) {
- int masked = flags & ABS_HORIZONTAL_DIR_FLAGS;
- if (masked == 0) {
- return flags; // does not have any abs flags, good.
- }
- flags &= ~masked; //remove left / right.
- if (layoutDirection == ViewCompat.LAYOUT_DIRECTION_LTR) {
- // no change. just OR with 2 bits shifted mask and return
- flags |= masked << 2; // START is 2 bits after LEFT, END is 2 bits after RIGHT.
- return flags;
- } else {
- // add RIGHT flag as START
- flags |= ((masked << 1) & ~ABS_HORIZONTAL_DIR_FLAGS);
- // first clean RIGHT bit then add LEFT flag as END
- flags |= ((masked << 1) & ABS_HORIZONTAL_DIR_FLAGS) << 2;
- }
- return flags;
- }
-
- /**
- * Convenience method to create movement flags.
- *
- * For instance, if you want to let your items be drag & dropped vertically and swiped
- * left to be dismissed, you can call this method with:
- * makeMovementFlags(UP | DOWN, LEFT);
- *
- * @param dragFlags The directions in which the item can be dragged.
- * @param swipeFlags The directions in which the item can be swiped.
- * @return Returns an integer composed of the given drag and swipe flags.
- */
- public static int makeMovementFlags(int dragFlags, int swipeFlags) {
- return makeFlag(ACTION_STATE_IDLE, swipeFlags | dragFlags)
- | makeFlag(ACTION_STATE_SWIPE, swipeFlags)
- | makeFlag(ACTION_STATE_DRAG, dragFlags);
- }
-
- /**
- * Shifts the given direction flags to the offset of the given action state.
- *
- * @param actionState The action state you want to get flags in. Should be one of
- * {@link #ACTION_STATE_IDLE}, {@link #ACTION_STATE_SWIPE} or
- * {@link #ACTION_STATE_DRAG}.
- * @param directions The direction flags. Can be composed from {@link #UP}, {@link #DOWN},
- * {@link #RIGHT}, {@link #LEFT} {@link #START} and {@link #END}.
- * @return And integer that represents the given directions in the provided actionState.
- */
- @SuppressWarnings("WeakerAccess")
- public static int makeFlag(int actionState, int directions) {
- return directions << (actionState * DIRECTION_FLAG_COUNT);
- }
-
- /**
- * Should return a composite flag which defines the enabled move directions in each state
- * (idle, swiping, dragging).
- *
- * Instead of composing this flag manually, you can use {@link #makeMovementFlags(int,
- * int)}
- * or {@link #makeFlag(int, int)}.
- *
- * This flag is composed of 3 sets of 8 bits, where first 8 bits are for IDLE state, next
- * 8 bits are for SWIPE state and third 8 bits are for DRAG state.
- * Each 8 bit sections can be constructed by simply OR'ing direction flags defined in
- * {@link ItemTouchHelper}.
- *
- * For example, if you want it to allow swiping LEFT and RIGHT but only allow starting to
- * swipe by swiping RIGHT, you can return:
- *
- * makeFlag(ACTION_STATE_IDLE, RIGHT) | makeFlag(ACTION_STATE_SWIPE, LEFT | RIGHT);
- *
- * This means, allow right movement while IDLE and allow right and left movement while
- * swiping.
- *
- * @param recyclerView The RecyclerView to which ItemTouchHelper is attached.
- * @param viewHolder The ViewHolder for which the movement information is necessary.
- * @return flags specifying which movements are allowed on this ViewHolder.
- * @see #makeMovementFlags(int, int)
- * @see #makeFlag(int, int)
- */
- public abstract int getMovementFlags(@NonNull RecyclerView recyclerView,
- @NonNull ViewHolder viewHolder);
-
- /**
- * Converts a given set of flags to absolution direction which means {@link #START} and
- * {@link #END} are replaced with {@link #LEFT} and {@link #RIGHT} depending on the layout
- * direction.
- *
- * @param flags The flag value that include any number of movement flags.
- * @param layoutDirection The layout direction of the RecyclerView.
- * @return Updated flags which includes only absolute direction values.
- */
- @SuppressWarnings("WeakerAccess")
- public int convertToAbsoluteDirection(int flags, int layoutDirection) {
- int masked = flags & RELATIVE_DIR_FLAGS;
- if (masked == 0) {
- return flags; // does not have any relative flags, good.
- }
- flags &= ~masked; //remove start / end
- if (layoutDirection == ViewCompat.LAYOUT_DIRECTION_LTR) {
- // no change. just OR with 2 bits shifted mask and return
- flags |= masked >> 2; // START is 2 bits after LEFT, END is 2 bits after RIGHT.
- return flags;
- } else {
- // add START flag as RIGHT
- flags |= ((masked >> 1) & ~RELATIVE_DIR_FLAGS);
- // first clean start bit then add END flag as LEFT
- flags |= ((masked >> 1) & RELATIVE_DIR_FLAGS) >> 2;
- }
- return flags;
- }
-
- final int getAbsoluteMovementFlags(RecyclerView recyclerView,
- ViewHolder viewHolder) {
- final int flags = getMovementFlags(recyclerView, viewHolder);
- return convertToAbsoluteDirection(flags, ViewCompat.getLayoutDirection(recyclerView));
- }
-
- boolean hasDragFlag(RecyclerView recyclerView, ViewHolder viewHolder) {
- final int flags = getAbsoluteMovementFlags(recyclerView, viewHolder);
- return (flags & ACTION_MODE_DRAG_MASK) != 0;
- }
-
- boolean hasSwipeFlag(RecyclerView recyclerView,
- ViewHolder viewHolder) {
- final int flags = getAbsoluteMovementFlags(recyclerView, viewHolder);
- return (flags & ACTION_MODE_SWIPE_MASK) != 0;
- }
-
- /**
- * Return true if the current ViewHolder can be dropped over the the target ViewHolder.
- *
- * This method is used when selecting drop target for the dragged View. After Views are
- * eliminated either via bounds check or via this method, resulting set of views will be
- * passed to {@link #chooseDropTarget(ViewHolder, java.util.List, int, int)}.
- *
- * Default implementation returns true.
- *
- * @param recyclerView The RecyclerView to which ItemTouchHelper is attached to.
- * @param current The ViewHolder that user is dragging.
- * @param target The ViewHolder which is below the dragged ViewHolder.
- * @return True if the dragged ViewHolder can be replaced with the target ViewHolder, false
- * otherwise.
- */
- @SuppressWarnings("WeakerAccess")
- public boolean canDropOver(@NonNull RecyclerView recyclerView, @NonNull ViewHolder current,
- @NonNull ViewHolder target) {
- return true;
- }
-
- /**
- * Called when ItemTouchHelper wants to move the dragged item from its old position to
- * the new position.
- *
- * If this method returns true, ItemTouchHelper assumes {@code viewHolder} has been moved
- * to the adapter position of {@code target} ViewHolder
- * ({@link ViewHolder#getAbsoluteAdapterPosition()
- * ViewHolder#getAdapterPositionInRecyclerView()}).
- *
- * If you don't support drag & drop, this method will never be called.
- *
- * @param recyclerView The RecyclerView to which ItemTouchHelper is attached to.
- * @param viewHolder The ViewHolder which is being dragged by the user.
- * @param target The ViewHolder over which the currently active item is being
- * dragged.
- * @return True if the {@code viewHolder} has been moved to the adapter position of
- * {@code target}.
- * @see #onMoved(RecyclerView, ViewHolder, int, ViewHolder, int, int, int)
- */
- public abstract boolean onMove(@NonNull RecyclerView recyclerView,
- @NonNull ViewHolder viewHolder, @NonNull ViewHolder target);
-
- /**
- * Returns whether ItemTouchHelper should start a drag and drop operation if an item is
- * long pressed.
- *
- * Default value returns true but you may want to disable this if you want to start
- * dragging on a custom view touch using {@link #startDrag(ViewHolder)}.
- *
- * @return True if ItemTouchHelper should start dragging an item when it is long pressed,
- * false otherwise. Default value is true.
- * @see #startDrag(ViewHolder)
- */
- public boolean isLongPressDragEnabled() {
- return true;
- }
-
- /**
- * Returns whether ItemTouchHelper should start a swipe operation if a pointer is swiped
- * over the View.
- *
- * Default value returns true but you may want to disable this if you want to start
- * swiping on a custom view touch using {@link #startSwipe(ViewHolder)}.
- *
- * @return True if ItemTouchHelper should start swiping an item when user swipes a pointer
- * over the View, false otherwise. Default value is true.
- * @see #startSwipe(ViewHolder)
- */
- public boolean isItemViewSwipeEnabled() {
- return true;
- }
-
- /**
- * When finding views under a dragged view, by default, ItemTouchHelper searches for views
- * that overlap with the dragged View. By overriding this method, you can extend or shrink
- * the search box.
- *
- * @return The extra margin to be added to the hit box of the dragged View.
- */
- @SuppressWarnings("WeakerAccess")
- public int getBoundingBoxMargin() {
- return 0;
- }
-
- /**
- * Returns the fraction that the user should move the View to be considered as swiped.
- * The fraction is calculated with respect to RecyclerView's bounds.
- *
- * Default value is .5f, which means, to swipe a View, user must move the View at least
- * half of RecyclerView's width or height, depending on the swipe direction.
- *
- * @param viewHolder The ViewHolder that is being dragged.
- * @return A float value that denotes the fraction of the View size. Default value
- * is .5f .
- */
- @SuppressWarnings("WeakerAccess")
- public float getSwipeThreshold(@NonNull ViewHolder viewHolder) {
- return .5f;
- }
-
- /**
- * Returns the fraction that the user should move the View to be considered as it is
- * dragged. After a view is moved this amount, ItemTouchHelper starts checking for Views
- * below it for a possible drop.
- *
- * @param viewHolder The ViewHolder that is being dragged.
- * @return A float value that denotes the fraction of the View size. Default value is
- * .5f .
- */
- @SuppressWarnings("WeakerAccess")
- public float getMoveThreshold(@NonNull ViewHolder viewHolder) {
- return .5f;
- }
-
- /**
- * Defines the minimum velocity which will be considered as a swipe action by the user.
- *
- * You can increase this value to make it harder to swipe or decrease it to make it easier.
- * Keep in mind that ItemTouchHelper also checks the perpendicular velocity and makes sure
- * current direction velocity is larger then the perpendicular one. Otherwise, user's
- * movement is ambiguous. You can change the threshold by overriding
- * {@link #getSwipeVelocityThreshold(float)}.
- *
- * The velocity is calculated in pixels per second.
- *
- * The default framework value is passed as a parameter so that you can modify it with a
- * multiplier.
- *
- * @param defaultValue The default value (in pixels per second) used by the
- * ItemTouchHelper.
- * @return The minimum swipe velocity. The default implementation returns the
- * defaultValue parameter.
- * @see #getSwipeVelocityThreshold(float)
- * @see #getSwipeThreshold(ViewHolder)
- */
- @SuppressWarnings("WeakerAccess")
- public float getSwipeEscapeVelocity(float defaultValue) {
- return defaultValue;
- }
-
- /**
- * Defines the maximum velocity ItemTouchHelper will ever calculate for pointer movements.
- *
- * To consider a movement as swipe, ItemTouchHelper requires it to be larger than the
- * perpendicular movement. If both directions reach to the max threshold, none of them will
- * be considered as a swipe because it is usually an indication that user rather tried to
- * scroll then swipe.
- *
- * The velocity is calculated in pixels per second.
- *
- * You can customize this behavior by changing this method. If you increase the value, it
- * will be easier for the user to swipe diagonally and if you decrease the value, user will
- * need to make a rather straight finger movement to trigger a swipe.
- *
- * @param defaultValue The default value(in pixels per second) used by the ItemTouchHelper.
- * @return The velocity cap for pointer movements. The default implementation returns the
- * defaultValue parameter.
- * @see #getSwipeEscapeVelocity(float)
- */
- @SuppressWarnings("WeakerAccess")
- public float getSwipeVelocityThreshold(float defaultValue) {
- return defaultValue;
- }
-
- /**
- * Called by ItemTouchHelper to select a drop target from the list of ViewHolders that
- * are under the dragged View.
- *
- * Default implementation filters the View with which dragged item have changed position
- * in the drag direction. For instance, if the view is dragged UP, it compares the
- * view.getTop() of the two views before and after drag started. If that value
- * is different, the target view passes the filter.
- *
- * Among these Views which pass the test, the one closest to the dragged view is chosen.
- *
- * This method is called on the main thread every time user moves the View. If you want to
- * override it, make sure it does not do any expensive operations.
- *
- * @param selected The ViewHolder being dragged by the user.
- * @param dropTargets The list of ViewHolder that are under the dragged View and
- * candidate as a drop.
- * @param curX 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 curY 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.
- * @return A ViewHolder to whose position the dragged ViewHolder should be
- * moved to.
- */
- @SuppressWarnings("WeakerAccess")
- @SuppressLint("UnknownNullness") // b/240775049: Cannot annotate properly
- public ViewHolder chooseDropTarget(@NonNull ViewHolder selected,
- @NonNull List dropTargets, int curX, int curY) {
- int right = curX + selected.itemView.getWidth();
- int bottom = curY + selected.itemView.getHeight();
- ViewHolder winner = null;
- int winnerScore = -1;
- final int dx = curX - selected.itemView.getLeft();
- final int dy = curY - selected.itemView.getTop();
- final int targetsSize = dropTargets.size();
- for (int i = 0; i < targetsSize; i++) {
- final ViewHolder target = dropTargets.get(i);
- if (dx > 0) {
- int diff = target.itemView.getRight() - right;
- if (diff < 0 && target.itemView.getRight() > selected.itemView.getRight()) {
- final int score = Math.abs(diff);
- if (score > winnerScore) {
- winnerScore = score;
- winner = target;
- }
- }
- }
- if (dx < 0) {
- int diff = target.itemView.getLeft() - curX;
- if (diff > 0 && target.itemView.getLeft() < selected.itemView.getLeft()) {
- final int score = Math.abs(diff);
- if (score > winnerScore) {
- winnerScore = score;
- winner = target;
- }
- }
- }
- if (dy < 0) {
- int diff = target.itemView.getTop() - curY;
- if (diff > 0 && target.itemView.getTop() < selected.itemView.getTop()) {
- final int score = Math.abs(diff);
- if (score > winnerScore) {
- winnerScore = score;
- winner = target;
- }
- }
- }
-
- if (dy > 0) {
- int diff = target.itemView.getBottom() - bottom;
- if (diff < 0 && target.itemView.getBottom() > selected.itemView.getBottom()) {
- final int score = Math.abs(diff);
- if (score > winnerScore) {
- winnerScore = score;
- winner = target;
- }
- }
- }
- }
- return winner;
- }
-
- /**
- * Called when a ViewHolder is swiped by the user.
- *
- * If you are returning relative directions ({@link #START} , {@link #END}) from the
- * {@link #getMovementFlags(RecyclerView, ViewHolder)} method, this method
- * will also use relative directions. Otherwise, it will use absolute directions.
- *
- * If you don't support swiping, this method will never be called.
- *
- * ItemTouchHelper will keep a reference to the View until it is detached from
- * RecyclerView.
- * As soon as it is detached, ItemTouchHelper will call
- * {@link #clearView(RecyclerView, ViewHolder)}.
- *
- * @param viewHolder The ViewHolder which has been swiped by the user.
- * @param direction The direction to which the ViewHolder is swiped. It is one of
- * {@link #UP}, {@link #DOWN},
- * {@link #LEFT} or {@link #RIGHT}. If your
- * {@link #getMovementFlags(RecyclerView, ViewHolder)}
- * method
- * returned relative flags instead of {@link #LEFT} / {@link #RIGHT};
- * `direction` will be relative as well. ({@link #START} or {@link
- * #END}).
- */
- public abstract void onSwiped(@NonNull ViewHolder viewHolder, int direction);
-
- /**
- * Called when the ViewHolder swiped or dragged by the ItemTouchHelper is changed.
- *
- * If you override this method, you should call super.
- *
- * @param viewHolder The new ViewHolder that is being swiped or dragged. Might be null if
- * it is cleared.
- * @param actionState One of {@link ItemTouchHelper#ACTION_STATE_IDLE},
- * {@link ItemTouchHelper#ACTION_STATE_SWIPE} or
- * {@link ItemTouchHelper#ACTION_STATE_DRAG}.
- * @see #clearView(RecyclerView, RecyclerView.ViewHolder)
- */
- public void onSelectedChanged(@Nullable ViewHolder viewHolder, int actionState) {
- if (viewHolder != null) {
- ItemTouchUIUtilImpl.INSTANCE.onSelected(viewHolder.itemView);
- }
- }
-
- private int getMaxDragScroll(RecyclerView recyclerView) {
- if (mCachedMaxScrollSpeed == -1) {
- mCachedMaxScrollSpeed = recyclerView.getResources().getDimensionPixelSize(
- R.dimen.item_touch_helper_max_drag_scroll_per_frame);
- }
- return mCachedMaxScrollSpeed;
- }
-
- /**
- * Called when {@link #onMove(RecyclerView, ViewHolder, ViewHolder)} returns true.
- *
- * 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).
- *
- * 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.
- *
- * 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(@NonNull final RecyclerView recyclerView,
- @NonNull final ViewHolder viewHolder, int fromPos, @NonNull 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);
- }
- }
- }
-
- void onDraw(Canvas c, RecyclerView parent, ViewHolder selected,
- List recoverAnimationList,
- int actionState, float dX, float dY) {
- final int recoverAnimSize = recoverAnimationList.size();
- for (int i = 0; i < recoverAnimSize; i++) {
- final ItemTouchHelper.RecoverAnimation anim = recoverAnimationList.get(i);
- anim.update();
- final int count = c.save();
- onChildDraw(c, parent, anim.mViewHolder, anim.mX, anim.mY, anim.mActionState,
- false);
- c.restoreToCount(count);
- }
- if (selected != null) {
- final int count = c.save();
- onChildDraw(c, parent, selected, dX, dY, actionState, true);
- c.restoreToCount(count);
- }
- }
-
- void onDrawOver(Canvas c, RecyclerView parent, ViewHolder selected,
- List recoverAnimationList,
- int actionState, float dX, float dY) {
- final int recoverAnimSize = recoverAnimationList.size();
- for (int i = 0; i < recoverAnimSize; i++) {
- final ItemTouchHelper.RecoverAnimation anim = recoverAnimationList.get(i);
- final int count = c.save();
- onChildDrawOver(c, parent, anim.mViewHolder, anim.mX, anim.mY, anim.mActionState,
- false);
- c.restoreToCount(count);
- }
- if (selected != null) {
- final int count = c.save();
- onChildDrawOver(c, parent, selected, dX, dY, actionState, true);
- c.restoreToCount(count);
- }
- boolean hasRunningAnimation = false;
- for (int i = recoverAnimSize - 1; i >= 0; i--) {
- final RecoverAnimation anim = recoverAnimationList.get(i);
- if (anim.mEnded && !anim.mIsPendingCleanup) {
- recoverAnimationList.remove(i);
- } else if (!anim.mEnded) {
- hasRunningAnimation = true;
- }
- }
- if (hasRunningAnimation) {
- parent.invalidate();
- }
- }
-
- /**
- * Called by the ItemTouchHelper when the user interaction with an element is over and it
- * also completed its animation.
- *
- * This is a good place to clear all changes on the View that was done in
- * {@link #onSelectedChanged(RecyclerView.ViewHolder, int)},
- * {@link #onChildDraw(Canvas, RecyclerView, ViewHolder, float, float, int,
- * boolean)} or
- * {@link #onChildDrawOver(Canvas, RecyclerView, ViewHolder, float, float, int, boolean)}.
- *
- * @param recyclerView The RecyclerView which is controlled by the ItemTouchHelper.
- * @param viewHolder The View that was interacted by the user.
- */
- public void clearView(@NonNull RecyclerView recyclerView, @NonNull ViewHolder viewHolder) {
- ItemTouchUIUtilImpl.INSTANCE.clearView(viewHolder.itemView);
- }
-
- /**
- * Called by ItemTouchHelper on RecyclerView's onDraw callback.
- *
- * If you would like to customize how your View's respond to user interactions, this is
- * a good place to override.
- *
- * Default implementation translates the child by the given dX,
- * dY.
- * ItemTouchHelper also takes care of drawing the child after other children if it is being
- * dragged. This is done using child re-ordering mechanism. On platforms prior to L, this
- * is
- * achieved via {@link android.view.ViewGroup#getChildDrawingOrder(int, int)} and on L
- * and after, it changes View's elevation value to be greater than all other children.)
- *
- * @param c The canvas which RecyclerView is drawing its children
- * @param recyclerView The RecyclerView to which ItemTouchHelper is attached to
- * @param viewHolder The ViewHolder which is being interacted by the User or it was
- * interacted and simply animating to its original position
- * @param dX The amount of horizontal displacement caused by user's action
- * @param dY The amount of vertical displacement caused by user's action
- * @param actionState The type of interaction on the View. Is either {@link
- * #ACTION_STATE_DRAG} or {@link #ACTION_STATE_SWIPE}.
- * @param isCurrentlyActive True if this view is currently being controlled by the user or
- * false it is simply animating back to its original state.
- * @see #onChildDrawOver(Canvas, RecyclerView, ViewHolder, float, float, int,
- * boolean)
- */
- public void onChildDraw(@NonNull Canvas c, @NonNull RecyclerView recyclerView,
- @NonNull ViewHolder viewHolder,
- float dX, float dY, int actionState, boolean isCurrentlyActive) {
- ItemTouchUIUtilImpl.INSTANCE.onDraw(c, recyclerView, viewHolder.itemView, dX, dY,
- actionState, isCurrentlyActive);
- }
-
- /**
- * Called by ItemTouchHelper on RecyclerView's onDraw callback.
- *
- * If you would like to customize how your View's respond to user interactions, this is
- * a good place to override.
- *
- * Default implementation translates the child by the given dX,
- * dY.
- * ItemTouchHelper also takes care of drawing the child after other children if it is being
- * dragged. This is done using child re-ordering mechanism. On platforms prior to L, this
- * is
- * achieved via {@link android.view.ViewGroup#getChildDrawingOrder(int, int)} and on L
- * and after, it changes View's elevation value to be greater than all other children.)
- *
- * @param c The canvas which RecyclerView is drawing its children
- * @param recyclerView The RecyclerView to which ItemTouchHelper is attached to
- * @param viewHolder The ViewHolder which is being interacted by the User or it was
- * interacted and simply animating to its original position
- * @param dX The amount of horizontal displacement caused by user's action
- * @param dY The amount of vertical displacement caused by user's action
- * @param actionState The type of interaction on the View. Is either {@link
- * #ACTION_STATE_DRAG} or {@link #ACTION_STATE_SWIPE}.
- * @param isCurrentlyActive True if this view is currently being controlled by the user or
- * false it is simply animating back to its original state.
- * @see #onChildDrawOver(Canvas, RecyclerView, ViewHolder, float, float, int,
- * boolean)
- */
- public void onChildDrawOver(@NonNull Canvas c, @NonNull RecyclerView recyclerView,
- @SuppressLint("UnknownNullness") // b/240775049: Cannot annotate properly
- ViewHolder viewHolder,
- float dX, float dY, int actionState, boolean isCurrentlyActive) {
- ItemTouchUIUtilImpl.INSTANCE.onDrawOver(c, recyclerView, viewHolder.itemView, dX, dY,
- actionState, isCurrentlyActive);
- }
-
- /**
- * Called by the ItemTouchHelper when user action finished on a ViewHolder and now the View
- * will be animated to its final position.
- *
- * Default implementation uses ItemAnimator's duration values. If
- * animationType is {@link #ANIMATION_TYPE_DRAG}, it returns
- * {@link RecyclerView.ItemAnimator#getMoveDuration()}, otherwise, it returns
- * {@link RecyclerView.ItemAnimator#getRemoveDuration()}. If RecyclerView does not have
- * any {@link RecyclerView.ItemAnimator} attached, this method returns
- * {@code DEFAULT_DRAG_ANIMATION_DURATION} or {@code DEFAULT_SWIPE_ANIMATION_DURATION}
- * depending on the animation type.
- *
- * @param recyclerView The RecyclerView to which the ItemTouchHelper is attached to.
- * @param animationType The type of animation. Is one of {@link #ANIMATION_TYPE_DRAG},
- * {@link #ANIMATION_TYPE_SWIPE_CANCEL} or
- * {@link #ANIMATION_TYPE_SWIPE_SUCCESS}.
- * @param animateDx The horizontal distance that the animation will offset
- * @param animateDy The vertical distance that the animation will offset
- * @return The duration for the animation
- */
- @SuppressWarnings("WeakerAccess")
- public long getAnimationDuration(@NonNull RecyclerView recyclerView, int animationType,
- float animateDx, float animateDy) {
- final RecyclerView.ItemAnimator itemAnimator = recyclerView.getItemAnimator();
- if (itemAnimator == null) {
- return animationType == ANIMATION_TYPE_DRAG ? DEFAULT_DRAG_ANIMATION_DURATION
- : DEFAULT_SWIPE_ANIMATION_DURATION;
- } else {
- return animationType == ANIMATION_TYPE_DRAG ? itemAnimator.getMoveDuration()
- : itemAnimator.getRemoveDuration();
- }
- }
-
- /**
- * Called by the ItemTouchHelper when user is dragging a view out of bounds.
- *
- * You can override this method to decide how much RecyclerView should scroll in response
- * to this action. Default implementation calculates a value based on the amount of View
- * out of bounds and the time it spent there. The longer user keeps the View out of bounds,
- * the faster the list will scroll. Similarly, the larger portion of the View is out of
- * bounds, the faster the RecyclerView will scroll.
- *
- * @param recyclerView The RecyclerView instance to which ItemTouchHelper is
- * attached to.
- * @param viewSize The total size of the View in scroll direction, excluding
- * item decorations.
- * @param viewSizeOutOfBounds The total size of the View that is out of bounds. This value
- * is negative if the View is dragged towards left or top edge.
- * @param totalSize The total size of RecyclerView in the scroll direction.
- * @param msSinceStartScroll The time passed since View is kept out of bounds.
- * @return The amount that RecyclerView should scroll. Keep in mind that this value will
- * be passed to {@link RecyclerView#scrollBy(int, int)} method.
- */
- @SuppressWarnings("WeakerAccess")
- public int interpolateOutOfBoundsScroll(@NonNull RecyclerView recyclerView,
- int viewSize, int viewSizeOutOfBounds,
- int totalSize, long msSinceStartScroll) {
- final int maxScroll = getMaxDragScroll(recyclerView);
- final int absOutOfBounds = Math.abs(viewSizeOutOfBounds);
- final int direction = (int) Math.signum(viewSizeOutOfBounds);
- // might be negative if other direction
- float outOfBoundsRatio = Math.min(1f, 1f * absOutOfBounds / viewSize);
- final int cappedScroll = (int) (direction * maxScroll
- * sDragViewScrollCapInterpolator.getInterpolation(outOfBoundsRatio));
- final float timeRatio;
- if (msSinceStartScroll > DRAG_SCROLL_ACCELERATION_LIMIT_TIME_MS) {
- timeRatio = 1f;
- } else {
- timeRatio = (float) msSinceStartScroll / DRAG_SCROLL_ACCELERATION_LIMIT_TIME_MS;
- }
- final int value = (int) (cappedScroll * sDragScrollInterpolator
- .getInterpolation(timeRatio));
- if (value == 0) {
- return viewSizeOutOfBounds > 0 ? 1 : -1;
- }
- return value;
- }
- }
-
- /**
- * A simple wrapper to the default Callback which you can construct with drag and swipe
- * directions and this class will handle the flag callbacks. You should still override onMove
- * or
- * onSwiped depending on your use case.
- *
- *
- * ItemTouchHelper mIth = new ItemTouchHelper(
- * new ItemTouchHelper.SimpleCallback(ItemTouchHelper.UP | ItemTouchHelper.DOWN,
- * ItemTouchHelper.LEFT) {
- * public boolean onMove(RecyclerView recyclerView,
- * ViewHolder viewHolder, ViewHolder target) {
- * final int fromPos = viewHolder.getAdapterPosition();
- * final int toPos = target.getAdapterPosition();
- * // move item in `fromPos` to `toPos` in adapter.
- * return true;// true if moved, false otherwise
- * }
- * public void onSwiped(ViewHolder viewHolder, int direction) {
- * // remove from adapter
- * }
- * });
- *
- */
- public abstract static class SimpleCallback extends Callback {
-
- private int mDefaultSwipeDirs;
-
- private int mDefaultDragDirs;
-
- /**
- * Creates a Callback for the given drag and swipe allowance. These values serve as
- * defaults
- * and if you want to customize behavior per ViewHolder, you can override
- * {@link #getSwipeDirs(RecyclerView, ViewHolder)}
- * and / or {@link #getDragDirs(RecyclerView, ViewHolder)}.
- *
- * @param dragDirs Binary OR of direction flags in which the Views can be dragged. Must be
- * composed of {@link #LEFT}, {@link #RIGHT}, {@link #START}, {@link
- * #END},
- * {@link #UP} and {@link #DOWN}.
- * @param swipeDirs Binary OR of direction flags in which the Views can be swiped. Must be
- * composed of {@link #LEFT}, {@link #RIGHT}, {@link #START}, {@link
- * #END},
- * {@link #UP} and {@link #DOWN}.
- */
- public SimpleCallback(int dragDirs, int swipeDirs) {
- mDefaultSwipeDirs = swipeDirs;
- mDefaultDragDirs = dragDirs;
- }
-
- /**
- * Updates the default swipe directions. For example, you can use this method to toggle
- * certain directions depending on your use case.
- *
- * @param defaultSwipeDirs Binary OR of directions in which the ViewHolders can be swiped.
- */
- @SuppressWarnings({"WeakerAccess", "unused"})
- public void setDefaultSwipeDirs(@SuppressWarnings("unused") int defaultSwipeDirs) {
- mDefaultSwipeDirs = defaultSwipeDirs;
- }
-
- /**
- * Updates the default drag directions. For example, you can use this method to toggle
- * certain directions depending on your use case.
- *
- * @param defaultDragDirs Binary OR of directions in which the ViewHolders can be dragged.
- */
- @SuppressWarnings({"WeakerAccess", "unused"})
- public void setDefaultDragDirs(@SuppressWarnings("unused") int defaultDragDirs) {
- mDefaultDragDirs = defaultDragDirs;
- }
-
- /**
- * Returns the swipe directions for the provided ViewHolder.
- * Default implementation returns the swipe directions that was set via constructor or
- * {@link #setDefaultSwipeDirs(int)}.
- *
- * @param recyclerView The RecyclerView to which the ItemTouchHelper is attached to.
- * @param viewHolder The ViewHolder for which the swipe direction is queried.
- * @return A binary OR of direction flags.
- */
- @SuppressWarnings("WeakerAccess")
- public int getSwipeDirs(@SuppressWarnings("unused") @NonNull RecyclerView recyclerView,
- @NonNull @SuppressWarnings("unused") ViewHolder viewHolder) {
- return mDefaultSwipeDirs;
- }
-
- /**
- * Returns the drag directions for the provided ViewHolder.
- * Default implementation returns the drag directions that was set via constructor or
- * {@link #setDefaultDragDirs(int)}.
- *
- * @param recyclerView The RecyclerView to which the ItemTouchHelper is attached to.
- * @param viewHolder The ViewHolder for which the swipe direction is queried.
- * @return A binary OR of direction flags.
- */
- @SuppressWarnings("WeakerAccess")
- public int getDragDirs(@SuppressWarnings("unused") @NonNull RecyclerView recyclerView,
- @SuppressWarnings("unused") @NonNull ViewHolder viewHolder) {
- return mDefaultDragDirs;
- }
-
- @Override
- public int getMovementFlags(@NonNull RecyclerView recyclerView,
- @NonNull ViewHolder viewHolder) {
- return makeMovementFlags(getDragDirs(recyclerView, viewHolder),
- getSwipeDirs(recyclerView, viewHolder));
- }
- }
-
- private class ItemTouchHelperGestureListener extends GestureDetector.SimpleOnGestureListener {
-
- /**
- * Whether to execute code in response to the the invoking of
- * {@link ItemTouchHelperGestureListener#onLongPress(MotionEvent)}.
- *
- * It is necessary to control this here because
- * {@link GestureDetector.SimpleOnGestureListener} can only be set on a
- * {@link GestureDetector} in a GestureDetector's constructor, a GestureDetector will call
- * onLongPress if an {@link MotionEvent#ACTION_DOWN} event is not followed by another event
- * that would cancel it (like {@link MotionEvent#ACTION_UP} or
- * {@link MotionEvent#ACTION_CANCEL}), the long press responding to the long press event
- * needs to be cancellable to prevent unexpected behavior.
- *
- * @see #doNotReactToLongPress()
- */
- private boolean mShouldReactToLongPress = true;
-
- ItemTouchHelperGestureListener() {
- }
-
- /**
- * Call to prevent executing code in response to
- * {@link ItemTouchHelperGestureListener#onLongPress(MotionEvent)} being called.
- */
- void doNotReactToLongPress() {
- mShouldReactToLongPress = false;
- }
-
- @Override
- public boolean onDown(MotionEvent e) {
- return true;
- }
-
- @Override
- public void onLongPress(MotionEvent e) {
- if (!mShouldReactToLongPress) {
- return;
- }
- View child = findChildView(e);
- if (child != null) {
- ViewHolder vh = mRecyclerView.getChildViewHolder(child);
- if (vh != null) {
- if (!mCallback.hasDragFlag(mRecyclerView, vh)) {
- return;
- }
- int pointerId = e.getPointerId(0);
- // Long press is deferred.
- // Check w/ active pointer id to avoid selecting after motion
- // event is canceled.
- if (pointerId == mActivePointerId) {
- final int index = e.findPointerIndex(mActivePointerId);
- final float x = e.getX(index);
- final float y = e.getY(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);
- }
- }
- }
- }
- }
- }
-
- @VisibleForTesting
- static class RecoverAnimation implements Animator.AnimatorListener {
-
- final float mStartDx;
-
- final float mStartDy;
-
- final float mTargetX;
-
- final float mTargetY;
-
- final ViewHolder mViewHolder;
-
- final int mActionState;
-
- @VisibleForTesting
- final ValueAnimator mValueAnimator;
-
- final int mAnimationType;
-
- boolean mIsPendingCleanup;
-
- float mX;
-
- float mY;
-
- // if user starts touching a recovering view, we put it into interaction mode again,
- // instantly.
- boolean mOverridden = false;
-
- boolean mEnded = false;
-
- private float mFraction;
-
- 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 = ValueAnimator.ofFloat(0f, 1f);
- mValueAnimator.addUpdateListener(
- new ValueAnimator.AnimatorUpdateListener() {
- @Override
- public void onAnimationUpdate(ValueAnimator animation) {
- setFraction(animation.getAnimatedFraction());
- }
- });
- mValueAnimator.setTarget(viewHolder.itemView);
- mValueAnimator.addListener(this);
- setFraction(0f);
- }
-
- public void setDuration(long duration) {
- mValueAnimator.setDuration(duration);
- }
-
- public void start() {
- mViewHolder.setIsRecyclable(false);
- mValueAnimator.start();
- }
-
- public void cancel() {
- mValueAnimator.cancel();
- }
-
- public void setFraction(float fraction) {
- mFraction = fraction;
- }
-
- /**
- * We run updates on onDraw method but use the fraction from animator callback.
- * This way, we can sync translate x/y values w/ the animators to avoid one-off frames.
- */
- public void update() {
- if (mStartDx == mTargetX) {
- mX = mViewHolder.itemView.getTranslationX();
- } else {
- mX = mStartDx + mFraction * (mTargetX - mStartDx);
- }
- if (mStartDy == mTargetY) {
- mY = mViewHolder.itemView.getTranslationY();
- } else {
- mY = mStartDy + mFraction * (mTargetY - mStartDy);
- }
- }
-
- @Override
- public void onAnimationStart(Animator animation) {
-
- }
-
- @Override
- public void onAnimationEnd(Animator animation) {
- if (!mEnded) {
- mViewHolder.setIsRecyclable(true);
- }
- mEnded = true;
- }
-
- @Override
- public void onAnimationCancel(Animator animation) {
- setFraction(1f); //make sure we recover the view's state.
- }
-
- @Override
- public void onAnimationRepeat(Animator animation) {
-
- }
- }
-}
diff --git a/app/src/main/java/androidx/recyclerview/widget/ItemTouchUIUtil.java b/app/src/main/java/androidx/recyclerview/widget/ItemTouchUIUtil.java
deleted file mode 100644
index 8f4f8f0616..0000000000
--- a/app/src/main/java/androidx/recyclerview/widget/ItemTouchUIUtil.java
+++ /dev/null
@@ -1,68 +0,0 @@
-/*
- * Copyright 2018 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package androidx.recyclerview.widget;
-
-import android.annotation.SuppressLint;
-import android.graphics.Canvas;
-import android.view.View;
-
-/**
- * Utility class for {@link ItemTouchHelper} which handles item transformations for different
- * API versions.
- *
- * This class has methods that map to {@link ItemTouchHelper.Callback}'s drawing methods. Default
- * implementations in {@link ItemTouchHelper.Callback} call these methods with
- * {@link RecyclerView.ViewHolder#itemView} and {@link ItemTouchUIUtil} makes necessary changes
- * on the View depending on the API level. You can access the instance of {@link ItemTouchUIUtil}
- * via {@link ItemTouchHelper.Callback#getDefaultUIUtil()} and call its methods with the children
- * of ViewHolder that you want to apply default effects.
- *
- * @see ItemTouchHelper.Callback#getDefaultUIUtil()
- */
-public interface ItemTouchUIUtil {
-
- /**
- * The default implementation for {@link ItemTouchHelper.Callback#onChildDraw(Canvas,
- * RecyclerView, RecyclerView.ViewHolder, float, float, int, boolean)}
- */
- @SuppressLint("UnknownNullness") // b/240775049: Cannot annotate properly
- void onDraw(Canvas c, RecyclerView recyclerView, View view,
- float dX, float dY, int actionState, boolean isCurrentlyActive);
-
- /**
- * The default implementation for {@link ItemTouchHelper.Callback#onChildDrawOver(Canvas,
- * RecyclerView, RecyclerView.ViewHolder, float, float, int, boolean)}
- */
- @SuppressLint("UnknownNullness") // b/240775049: Cannot annotate properly
- void onDrawOver(Canvas c, RecyclerView recyclerView, View view,
- float dX, float dY, int actionState, boolean isCurrentlyActive);
-
- /**
- * The default implementation for {@link ItemTouchHelper.Callback#clearView(RecyclerView,
- * RecyclerView.ViewHolder)}
- */
- @SuppressLint("UnknownNullness") // b/240775049: Cannot annotate properly
- void clearView(View view);
-
- /**
- * The default implementation for {@link ItemTouchHelper.Callback#onSelectedChanged(
- * RecyclerView.ViewHolder, int)}
- */
- @SuppressLint("UnknownNullness") // b/240775049: Cannot annotate properly
- void onSelected(View view);
-}
-
diff --git a/app/src/main/java/androidx/recyclerview/widget/ItemTouchUIUtilImpl.java b/app/src/main/java/androidx/recyclerview/widget/ItemTouchUIUtilImpl.java
deleted file mode 100644
index c592e3e526..0000000000
--- a/app/src/main/java/androidx/recyclerview/widget/ItemTouchUIUtilImpl.java
+++ /dev/null
@@ -1,105 +0,0 @@
-/*
- * Copyright 2018 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package androidx.recyclerview.widget;
-
-import android.graphics.Canvas;
-import android.os.Build;
-import android.view.View;
-
-import androidx.annotation.NonNull;
-import androidx.core.view.ViewCompat;
-import androidx.recyclerview.R;
-
-/**
- * Package private class to keep implementations. Putting them inside ItemTouchUIUtil makes them
- * public API, which is not desired in this case.
- */
-class ItemTouchUIUtilImpl implements ItemTouchUIUtil {
- static final ItemTouchUIUtil INSTANCE = new ItemTouchUIUtilImpl();
-
- @Override
- public void onDraw(
- @NonNull Canvas c,
- @NonNull RecyclerView recyclerView,
- @NonNull View view,
- float dX,
- float dY,
- int actionState,
- boolean isCurrentlyActive
- ) {
- if (Build.VERSION.SDK_INT >= 21) {
- if (isCurrentlyActive) {
- Object originalElevation = view.getTag(R.id.item_touch_helper_previous_elevation);
- if (originalElevation == null) {
- originalElevation = ViewCompat.getElevation(view);
- float newElevation = 1f + findMaxElevation(recyclerView, view);
- ViewCompat.setElevation(view, newElevation);
- view.setTag(R.id.item_touch_helper_previous_elevation, originalElevation);
- }
- }
- }
-
- view.setTranslationX(dX);
- view.setTranslationY(dY);
- }
-
- private static float findMaxElevation(RecyclerView recyclerView, View itemView) {
- final int childCount = recyclerView.getChildCount();
- float max = 0;
- for (int i = 0; i < childCount; i++) {
- final View child = recyclerView.getChildAt(i);
- if (child == itemView) {
- continue;
- }
- final float elevation = ViewCompat.getElevation(child);
- if (elevation > max) {
- max = elevation;
- }
- }
- return max;
- }
-
- @Override
- public void onDrawOver(
- @NonNull Canvas c,
- @NonNull RecyclerView recyclerView,
- @NonNull View view,
- float dX,
- float dY,
- int actionState,
- boolean isCurrentlyActive
- ) {
- }
-
- @Override
- public void clearView(@NonNull View view) {
- if (Build.VERSION.SDK_INT >= 21) {
- final Object tag = view.getTag(R.id.item_touch_helper_previous_elevation);
- if (tag instanceof Float) {
- ViewCompat.setElevation(view, (Float) tag);
- }
- view.setTag(R.id.item_touch_helper_previous_elevation, null);
- }
-
- view.setTranslationX(0f);
- view.setTranslationY(0f);
- }
-
- @Override
- public void onSelected(@NonNull View view) {
- }
-}
diff --git a/app/src/main/java/androidx/recyclerview/widget/LayoutState.java b/app/src/main/java/androidx/recyclerview/widget/LayoutState.java
deleted file mode 100644
index 8805c1cc93..0000000000
--- a/app/src/main/java/androidx/recyclerview/widget/LayoutState.java
+++ /dev/null
@@ -1,114 +0,0 @@
-/*
- * Copyright 2018 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package androidx.recyclerview.widget;
-
-import android.view.View;
-
-/**
- * Helper class that keeps temporary state while {LayoutManager} is filling out the empty
- * space.
- */
-class LayoutState {
-
- static final int LAYOUT_START = -1;
-
- static final int LAYOUT_END = 1;
-
- static final int INVALID_LAYOUT = Integer.MIN_VALUE;
-
- static final int ITEM_DIRECTION_HEAD = -1;
-
- static final int ITEM_DIRECTION_TAIL = 1;
-
- /**
- * We may not want to recycle children in some cases (e.g. layout)
- */
- boolean mRecycle = true;
-
- /**
- * Number of pixels that we should fill, in the layout direction.
- */
- int mAvailable;
-
- /**
- * Current position on the adapter to get the next item.
- */
- int mCurrentPosition;
-
- /**
- * Defines the direction in which the data adapter is traversed.
- * Should be {@link #ITEM_DIRECTION_HEAD} or {@link #ITEM_DIRECTION_TAIL}
- */
- int mItemDirection;
-
- /**
- * Defines the direction in which the layout is filled.
- * Should be {@link #LAYOUT_START} or {@link #LAYOUT_END}
- */
- int mLayoutDirection;
-
- /**
- * This is the target pixel closest to the start of the layout that we are trying to fill
- */
- int mStartLine = 0;
-
- /**
- * This is the target pixel closest to the end of the layout that we are trying to fill
- */
- int mEndLine = 0;
-
- /**
- * If true, layout should stop if a focusable view is added
- */
- boolean mStopInFocusable;
-
- /**
- * If the content is not wrapped with any value
- */
- boolean mInfinite;
-
- /**
- * @return true if there are more items in the data adapter
- */
- boolean hasMore(RecyclerView.State state) {
- return mCurrentPosition >= 0 && mCurrentPosition < state.getItemCount();
- }
-
- /**
- * Gets the view for the next element that we should render.
- * Also updates current item index to the next item, based on {@link #mItemDirection}
- *
- * @return The next element that we should render.
- */
- View next(RecyclerView.Recycler recycler) {
- final View view = recycler.getViewForPosition(mCurrentPosition);
- mCurrentPosition += mItemDirection;
- return view;
- }
-
- @Override
- public String toString() {
- return "LayoutState{"
- + "mAvailable=" + mAvailable
- + ", mCurrentPosition=" + mCurrentPosition
- + ", mItemDirection=" + mItemDirection
- + ", mLayoutDirection=" + mLayoutDirection
- + ", mStartLine=" + mStartLine
- + ", mEndLine=" + mEndLine
- + '}';
- }
-}
diff --git a/app/src/main/java/androidx/recyclerview/widget/LinearLayoutManager.java b/app/src/main/java/androidx/recyclerview/widget/LinearLayoutManager.java
deleted file mode 100644
index 22fd533731..0000000000
--- a/app/src/main/java/androidx/recyclerview/widget/LinearLayoutManager.java
+++ /dev/null
@@ -1,2624 +0,0 @@
-/*
- * Copyright 2018 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package androidx.recyclerview.widget;
-
-import static androidx.annotation.RestrictTo.Scope.LIBRARY;
-
-import android.annotation.SuppressLint;
-import android.content.Context;
-import android.graphics.PointF;
-import android.os.Parcel;
-import android.os.Parcelable;
-import android.util.AttributeSet;
-import android.util.Log;
-import android.view.View;
-import android.view.ViewGroup;
-import android.view.accessibility.AccessibilityEvent;
-
-import androidx.annotation.NonNull;
-import androidx.annotation.RestrictTo;
-import androidx.core.os.TraceCompat;
-import androidx.core.view.ViewCompat;
-
-import java.util.List;
-
-/**
- * A {@link RecyclerView.LayoutManager} implementation which provides
- * similar functionality to {@link android.widget.ListView}.
- */
-public class LinearLayoutManager extends RecyclerView.LayoutManager implements
- ItemTouchHelper.ViewDropHandler, RecyclerView.SmoothScroller.ScrollVectorProvider {
-
- private static final String TAG = "LinearLayoutManager";
-
- static final boolean DEBUG = false;
-
- public static final int HORIZONTAL = RecyclerView.HORIZONTAL;
-
- public static final int VERTICAL = RecyclerView.VERTICAL;
-
- public static final int INVALID_OFFSET = Integer.MIN_VALUE;
-
-
- /**
- * While trying to find next view to focus, LayoutManager will not try to scroll more
- * than this factor times the total space of the list. If layout is vertical, total space is the
- * height minus padding, if layout is horizontal, total space is the width minus padding.
- */
- private static final float MAX_SCROLL_FACTOR = 1 / 3f;
-
- /**
- * Current orientation. Either {@link #HORIZONTAL} or {@link #VERTICAL}
- */
- @RecyclerView.Orientation
- int mOrientation = RecyclerView.DEFAULT_ORIENTATION;
-
- /**
- * Helper class that keeps temporary layout state.
- * It does not keep state after layout is complete but we still keep a reference to re-use
- * the same object.
- */
- private LayoutState mLayoutState;
-
- /**
- * Many calculations are made depending on orientation. To keep it clean, this interface
- * helps {@link LinearLayoutManager} make those decisions.
- */
- OrientationHelper mOrientationHelper;
-
- /**
- * We need to track this so that we can ignore current position when it changes.
- */
- private boolean mLastStackFromEnd;
-
-
- /**
- * Defines if layout should be calculated from end to start.
- *
- * @see #mShouldReverseLayout
- */
- private boolean mReverseLayout = false;
-
- /**
- * This keeps the final value for how LayoutManager should start laying out views.
- * It is calculated by checking {@link #getReverseLayout()} and View's layout direction.
- * {@link #onLayoutChildren(RecyclerView.Recycler, RecyclerView.State)} is run.
- */
- boolean mShouldReverseLayout = false;
-
- /**
- * Works the same way as {@link android.widget.AbsListView#setStackFromBottom(boolean)} and
- * it supports both orientations.
- * see {@link android.widget.AbsListView#setStackFromBottom(boolean)}
- */
- private boolean mStackFromEnd = false;
-
- /**
- * Works the same way as {@link android.widget.AbsListView#setSmoothScrollbarEnabled(boolean)}.
- * see {@link android.widget.AbsListView#setSmoothScrollbarEnabled(boolean)}
- */
- private boolean mSmoothScrollbarEnabled = true;
-
- /**
- * When LayoutManager needs to scroll to a position, it sets this variable and requests a
- * layout which will check this variable and re-layout accordingly.
- */
- int mPendingScrollPosition = RecyclerView.NO_POSITION;
-
- /**
- * Used to keep the offset value when {@link #scrollToPositionWithOffset(int, int)} is
- * called.
- */
- int mPendingScrollPositionOffset = INVALID_OFFSET;
-
- private boolean mRecycleChildrenOnDetach;
-
- SavedState mPendingSavedState = null;
-
- /**
- * Re-used variable to keep anchor information on re-layout.
- * Anchor position and coordinate defines the reference point for LLM while doing a layout.
- */
- final AnchorInfo mAnchorInfo = new AnchorInfo();
-
- /**
- * Stashed to avoid allocation, currently only used in #fill()
- */
- private final LayoutChunkResult mLayoutChunkResult = new LayoutChunkResult();
-
- /**
- * Number of items to prefetch when first coming on screen with new data.
- */
- private int mInitialPrefetchItemCount = 2;
-
- // Reusable int array to be passed to method calls that mutate it in order to "return" two ints.
- // This should only be used used transiently and should not be used to retain any state over
- // time.
- private int[] mReusableIntPair = new int[2];
-
- /**
- * Creates a vertical LinearLayoutManager
- *
- * @param context Current context, will be used to access resources.
- */
- public LinearLayoutManager(
- // Suppressed because fixing it requires a source-incompatible change to a very
- // commonly used constructor, for no benefit: the context parameter is unused
- @SuppressLint("UnknownNullness") Context context
- ) {
- this(context, RecyclerView.DEFAULT_ORIENTATION, false);
- }
-
- /**
- * @param context Current context, will be used to access resources.
- * @param orientation Layout orientation. Should be {@link #HORIZONTAL} or {@link
- * #VERTICAL}.
- * @param reverseLayout When set to true, layouts from end to start.
- */
- public LinearLayoutManager(
- // Suppressed because fixing it requires a source-incompatible change to a very
- // commonly used constructor, for no benefit: the context parameter is unused
- @SuppressLint("UnknownNullness") Context context,
- @RecyclerView.Orientation int orientation,
- boolean reverseLayout
- ) {
- setOrientation(orientation);
- setReverseLayout(reverseLayout);
- }
-
- /**
- * Constructor used when layout manager is set in XML by RecyclerView attribute
- * "layoutManager". Defaults to vertical orientation.
- *
- * {@link android.R.attr#orientation}
- * {@link androidx.recyclerview.R.attr#reverseLayout}
- * {@link androidx.recyclerview.R.attr#stackFromEnd}
- */
- @SuppressLint("UnknownNullness") // b/240775049: Cannot annotate properly
- public LinearLayoutManager(Context context, AttributeSet attrs, int defStyleAttr,
- int defStyleRes) {
- Properties properties = getProperties(context, attrs, defStyleAttr, defStyleRes);
- setOrientation(properties.orientation);
- setReverseLayout(properties.reverseLayout);
- setStackFromEnd(properties.stackFromEnd);
- }
-
- @Override
- public boolean isAutoMeasureEnabled() {
- return true;
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- @SuppressLint("UnknownNullness") // b/240775049: Cannot annotate properly
- public RecyclerView.LayoutParams generateDefaultLayoutParams() {
- return new RecyclerView.LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT,
- ViewGroup.LayoutParams.WRAP_CONTENT);
- }
-
- /**
- * Returns whether LayoutManager will recycle its children when it is detached from
- * RecyclerView.
- *
- * @return true if LayoutManager will recycle its children when it is detached from
- * RecyclerView.
- */
- public boolean getRecycleChildrenOnDetach() {
- return mRecycleChildrenOnDetach;
- }
-
- /**
- * Set whether LayoutManager will recycle its children when it is detached from
- * RecyclerView.
- *
- * If you are using a {@link RecyclerView.RecycledViewPool}, it might be a good idea to set
- * this flag to true so that views will be available to other RecyclerViews
- * immediately.
- *
- * Note that, setting this flag will result in a performance drop if RecyclerView
- * is restored.
- *
- * @param recycleChildrenOnDetach Whether children should be recycled in detach or not.
- */
- public void setRecycleChildrenOnDetach(boolean recycleChildrenOnDetach) {
- mRecycleChildrenOnDetach = recycleChildrenOnDetach;
- }
-
- @Override
- @SuppressLint("UnknownNullness") // b/240775049: Cannot annotate properly
- public void onDetachedFromWindow(RecyclerView view, RecyclerView.Recycler recycler) {
- super.onDetachedFromWindow(view, recycler);
- if (mRecycleChildrenOnDetach) {
- removeAndRecycleAllViews(recycler);
- recycler.clear();
- }
- }
-
- @Override
- @SuppressLint("UnknownNullness") // b/240775049: Cannot annotate properly
- public void onInitializeAccessibilityEvent(AccessibilityEvent event) {
- super.onInitializeAccessibilityEvent(event);
- if (getChildCount() > 0) {
- event.setFromIndex(findFirstVisibleItemPosition());
- event.setToIndex(findLastVisibleItemPosition());
- }
- }
-
- @Override
- @SuppressLint("UnknownNullness") // b/240775049: Cannot annotate properly
- public Parcelable onSaveInstanceState() {
- if (mPendingSavedState != null) {
- return new SavedState(mPendingSavedState);
- }
- SavedState state = new SavedState();
- if (getChildCount() > 0) {
- ensureLayoutState();
- boolean didLayoutFromEnd = mLastStackFromEnd ^ mShouldReverseLayout;
- state.mAnchorLayoutFromEnd = didLayoutFromEnd;
- if (didLayoutFromEnd) {
- final View refChild = getChildClosestToEnd();
- state.mAnchorOffset = mOrientationHelper.getEndAfterPadding()
- - mOrientationHelper.getDecoratedEnd(refChild);
- state.mAnchorPosition = getPosition(refChild);
- } else {
- final View refChild = getChildClosestToStart();
- state.mAnchorPosition = getPosition(refChild);
- state.mAnchorOffset = mOrientationHelper.getDecoratedStart(refChild)
- - mOrientationHelper.getStartAfterPadding();
- }
- } else {
- state.invalidateAnchor();
- }
- return state;
- }
-
- @Override
- @SuppressLint("UnknownNullness") // b/240775049: Cannot annotate properly
- public void onRestoreInstanceState(Parcelable state) {
- if (state instanceof SavedState) {
- mPendingSavedState = (SavedState) state;
- if (mPendingScrollPosition != RecyclerView.NO_POSITION) {
- mPendingSavedState.invalidateAnchor();
- }
- requestLayout();
- if (DEBUG) {
- Log.d(TAG, "loaded saved state");
- }
- } else if (DEBUG) {
- Log.d(TAG, "invalid saved state class");
- }
- }
-
- /**
- * @return true if {@link #getOrientation()} is {@link #HORIZONTAL}
- */
- @Override
- public boolean canScrollHorizontally() {
- return mOrientation == HORIZONTAL;
- }
-
- /**
- * @return true if {@link #getOrientation()} is {@link #VERTICAL}
- */
- @Override
- public boolean canScrollVertically() {
- return mOrientation == VERTICAL;
- }
-
- /**
- * Compatibility support for {@link android.widget.AbsListView#setStackFromBottom(boolean)}
- */
- public void setStackFromEnd(boolean stackFromEnd) {
- assertNotInLayoutOrScroll(null);
- if (mStackFromEnd == stackFromEnd) {
- return;
- }
- mStackFromEnd = stackFromEnd;
- requestLayout();
- }
-
- public boolean getStackFromEnd() {
- return mStackFromEnd;
- }
-
- /**
- * Returns the current orientation of the layout.
- *
- * @return Current orientation, either {@link #HORIZONTAL} or {@link #VERTICAL}
- * @see #setOrientation(int)
- */
- @RecyclerView.Orientation
- public int getOrientation() {
- return mOrientation;
- }
-
- /**
- * Sets the orientation of the layout. {@link LinearLayoutManager}
- * will do its best to keep scroll position.
- *
- * @param orientation {@link #HORIZONTAL} or {@link #VERTICAL}
- */
- public void setOrientation(@RecyclerView.Orientation int orientation) {
- if (orientation != HORIZONTAL && orientation != VERTICAL) {
- throw new IllegalArgumentException("invalid orientation:" + orientation);
- }
-
- assertNotInLayoutOrScroll(null);
-
- if (orientation != mOrientation || mOrientationHelper == null) {
- mOrientationHelper =
- OrientationHelper.createOrientationHelper(this, orientation);
- mAnchorInfo.mOrientationHelper = mOrientationHelper;
- mOrientation = orientation;
- requestLayout();
- }
- }
-
- /**
- * Calculates the view layout order. (e.g. from end to start or start to end)
- * RTL layout support is applied automatically. So if layout is RTL and
- * {@link #getReverseLayout()} is {@code true}, elements will be laid out starting from left.
- */
- private void resolveShouldLayoutReverse() {
- // A == B is the same result, but we rather keep it readable
- if (mOrientation == VERTICAL || !isLayoutRTL()) {
- mShouldReverseLayout = mReverseLayout;
- } else {
- mShouldReverseLayout = !mReverseLayout;
- }
- }
-
- /**
- * Returns if views are laid out from the opposite direction of the layout.
- *
- * @return If layout is reversed or not.
- * @see #setReverseLayout(boolean)
- */
- public boolean getReverseLayout() {
- return mReverseLayout;
- }
-
- /**
- * Used to reverse item traversal and layout order.
- * This behaves similar to the layout change for RTL views. When set to true, first item is
- * laid out at the end of the UI, second item is laid out before it etc.
- *
- * For horizontal layouts, it depends on the layout direction.
- * When set to true, If {@link RecyclerView} is LTR, than it will
- * layout from RTL, if {@link RecyclerView}} is RTL, it will layout
- * from LTR.
- *
- * If you are looking for the exact same behavior of
- * {@link android.widget.AbsListView#setStackFromBottom(boolean)}, use
- * {@link #setStackFromEnd(boolean)}
- */
- public void setReverseLayout(boolean reverseLayout) {
- assertNotInLayoutOrScroll(null);
- if (reverseLayout == mReverseLayout) {
- return;
- }
- mReverseLayout = reverseLayout;
- requestLayout();
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- @SuppressLint("UnknownNullness") // b/240775049: Cannot annotate properly
- public View findViewByPosition(int position) {
- final int childCount = getChildCount();
- if (childCount == 0) {
- return null;
- }
- final int firstChild = getPosition(getChildAt(0));
- final int viewPosition = position - firstChild;
- if (viewPosition >= 0 && viewPosition < childCount) {
- final View child = getChildAt(viewPosition);
- if (getPosition(child) == position) {
- return child; // in pre-layout, this may not match
- }
- }
- // fallback to traversal. This might be necessary in pre-layout.
- return super.findViewByPosition(position);
- }
-
- /**
- *
Returns the amount of extra space that should be laid out by LayoutManager.
- *
- * By default, {@link LinearLayoutManager} lays out 1 extra page
- * of items while smooth scrolling and 0 otherwise. You can override this method to implement
- * your custom layout pre-cache logic.
- *
- * Note: Laying out invisible elements generally comes with significant
- * performance cost. It's typically only desirable in places like smooth scrolling to an unknown
- * location, where 1) the extra content helps LinearLayoutManager know in advance when its
- * target is approaching, so it can decelerate early and smoothly and 2) while motion is
- * continuous.
- *
- * Extending the extra layout space is especially expensive if done while the user may change
- * scrolling direction. Changing direction will cause the extra layout space to swap to the
- * opposite side of the viewport, incurring many rebinds/recycles, unless the cache is large
- * enough to handle it.
- *
- * @return The extra space that should be laid out (in pixels).
- * @deprecated Use {@link #calculateExtraLayoutSpace(RecyclerView.State, int[])} instead.
- */
- @SuppressWarnings("DeprecatedIsStillUsed")
- @Deprecated
- protected int getExtraLayoutSpace(RecyclerView.State state) {
- if (state.hasTargetScrollPosition()) {
- return mOrientationHelper.getTotalSpace();
- } else {
- return 0;
- }
- }
-
- /**
- * Calculates the amount of extra space (in pixels) that should be laid out by {@link
- * LinearLayoutManager} and stores the result in {@code extraLayoutSpace}. {@code
- * extraLayoutSpace[0]} should be used for the extra space at the top/left, and {@code
- * extraLayoutSpace[1]} should be used for the extra space at the bottom/right (depending on the
- * orientation). Thus, the side where it is applied is unaffected by {@link
- * #getLayoutDirection()} (LTR vs RTL), {@link #getStackFromEnd()} and {@link
- * #getReverseLayout()}. Negative values are ignored.
- *
- * By default, {@code LinearLayoutManager} lays out 1 extra page of items while smooth
- * scrolling, in the direction of the scroll, and no extra space is laid out in all other
- * situations. You can override this method to implement your own custom pre-cache logic. Use
- * {@link RecyclerView.State#hasTargetScrollPosition()} to find out if a smooth scroll to a
- * position is in progress, and {@link RecyclerView.State#getTargetScrollPosition()} to find out
- * which item it is scrolling to.
- *
- * Note: Laying out extra items generally comes with significant performance
- * cost. It's typically only desirable in places like smooth scrolling to an unknown location,
- * where 1) the extra content helps LinearLayoutManager know in advance when its target is
- * approaching, so it can decelerate early and smoothly and 2) while motion is continuous.
- *
- * Extending the extra layout space is especially expensive if done while the user may change
- * scrolling direction. In the default implementation, changing direction will cause the extra
- * layout space to swap to the opposite side of the viewport, incurring many rebinds/recycles,
- * unless the cache is large enough to handle it.
- */
- protected void calculateExtraLayoutSpace(@NonNull RecyclerView.State state,
- @NonNull int[] extraLayoutSpace) {
- int extraLayoutSpaceStart = 0;
- int extraLayoutSpaceEnd = 0;
-
- // If calculateExtraLayoutSpace is not overridden, call the
- // deprecated getExtraLayoutSpace for backwards compatibility
- @SuppressWarnings("deprecation")
- int extraScrollSpace = getExtraLayoutSpace(state);
- if (mLayoutState.mLayoutDirection == LayoutState.LAYOUT_START) {
- extraLayoutSpaceStart = extraScrollSpace;
- } else {
- extraLayoutSpaceEnd = extraScrollSpace;
- }
-
- extraLayoutSpace[0] = extraLayoutSpaceStart;
- extraLayoutSpace[1] = extraLayoutSpaceEnd;
- }
-
- @Override
- @SuppressLint("UnknownNullness") // b/240775049: Cannot annotate properly
- public void smoothScrollToPosition(RecyclerView recyclerView, RecyclerView.State state,
- int position) {
- LinearSmoothScroller linearSmoothScroller =
- new LinearSmoothScroller(recyclerView.getContext());
- linearSmoothScroller.setTargetPosition(position);
- startSmoothScroll(linearSmoothScroller);
- }
-
- @Override
- @SuppressLint("UnknownNullness") // b/240775049: Cannot annotate properly
- public PointF computeScrollVectorForPosition(int targetPosition) {
- if (getChildCount() == 0) {
- return null;
- }
- final int firstChildPos = getPosition(getChildAt(0));
- final int direction = targetPosition < firstChildPos != mShouldReverseLayout ? -1 : 1;
- if (mOrientation == HORIZONTAL) {
- return new PointF(direction, 0);
- } else {
- return new PointF(0, direction);
- }
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- @SuppressLint("UnknownNullness") // b/240775049: Cannot annotate properly
- public void onLayoutChildren(RecyclerView.Recycler recycler, RecyclerView.State state) {
- // layout algorithm:
- // 1) by checking children and other variables, find an anchor coordinate and an anchor
- // item position.
- // 2) fill towards start, stacking from bottom
- // 3) fill towards end, stacking from top
- // 4) scroll to fulfill requirements like stack from bottom.
- // create layout state
- if (DEBUG) {
- Log.d(TAG, "is pre layout:" + state.isPreLayout());
- }
- if (mPendingSavedState != null || mPendingScrollPosition != RecyclerView.NO_POSITION) {
- if (state.getItemCount() == 0) {
- removeAndRecycleAllViews(recycler);
- return;
- }
- }
- if (mPendingSavedState != null && mPendingSavedState.hasValidAnchor()) {
- mPendingScrollPosition = mPendingSavedState.mAnchorPosition;
- }
-
- ensureLayoutState();
- mLayoutState.mRecycle = false;
- // resolve layout direction
- resolveShouldLayoutReverse();
-
- final View focused = getFocusedChild();
- if (!mAnchorInfo.mValid || mPendingScrollPosition != RecyclerView.NO_POSITION
- || mPendingSavedState != null) {
- mAnchorInfo.reset();
- mAnchorInfo.mLayoutFromEnd = mShouldReverseLayout ^ mStackFromEnd;
- // calculate anchor position and coordinate
- updateAnchorInfoForLayout(recycler, state, mAnchorInfo);
- mAnchorInfo.mValid = true;
- } else if (focused != null && (mOrientationHelper.getDecoratedStart(focused)
- >= mOrientationHelper.getEndAfterPadding()
- || mOrientationHelper.getDecoratedEnd(focused)
- <= mOrientationHelper.getStartAfterPadding())) {
- // This case relates to when the anchor child is the focused view and due to layout
- // shrinking the focused view fell outside the viewport, e.g. when soft keyboard shows
- // up after tapping an EditText which shrinks RV causing the focused view (The tapped
- // EditText which is the anchor child) to get kicked out of the screen. Will update the
- // anchor coordinate in order to make sure that the focused view is laid out. Otherwise,
- // the available space in layoutState will be calculated as negative preventing the
- // focused view from being laid out in fill.
- // Note that we won't update the anchor position between layout passes (refer to
- // TestResizingRelayoutWithAutoMeasure), which happens if we were to call
- // updateAnchorInfoForLayout for an anchor that's not the focused view (e.g. a reference
- // child which can change between layout passes).
- mAnchorInfo.assignFromViewAndKeepVisibleRect(focused, getPosition(focused));
- }
- if (DEBUG) {
- Log.d(TAG, "Anchor info:" + mAnchorInfo);
- }
-
- // LLM may decide to layout items for "extra" pixels to account for scrolling target,
- // caching or predictive animations.
-
- mLayoutState.mLayoutDirection = mLayoutState.mLastScrollDelta >= 0
- ? LayoutState.LAYOUT_END : LayoutState.LAYOUT_START;
- mReusableIntPair[0] = 0;
- mReusableIntPair[1] = 0;
- calculateExtraLayoutSpace(state, mReusableIntPair);
- int extraForStart = Math.max(0, mReusableIntPair[0])
- + mOrientationHelper.getStartAfterPadding();
- int extraForEnd = Math.max(0, mReusableIntPair[1])
- + mOrientationHelper.getEndPadding();
- if (state.isPreLayout() && mPendingScrollPosition != RecyclerView.NO_POSITION
- && mPendingScrollPositionOffset != INVALID_OFFSET) {
- // if the child is visible and we are going to move it around, we should layout
- // extra items in the opposite direction to make sure new items animate nicely
- // instead of just fading in
- final View existing = findViewByPosition(mPendingScrollPosition);
- if (existing != null) {
- final int current;
- final int upcomingOffset;
- if (mShouldReverseLayout) {
- current = mOrientationHelper.getEndAfterPadding()
- - mOrientationHelper.getDecoratedEnd(existing);
- upcomingOffset = current - mPendingScrollPositionOffset;
- } else {
- current = mOrientationHelper.getDecoratedStart(existing)
- - mOrientationHelper.getStartAfterPadding();
- upcomingOffset = mPendingScrollPositionOffset - current;
- }
- if (upcomingOffset > 0) {
- extraForStart += upcomingOffset;
- } else {
- extraForEnd -= upcomingOffset;
- }
- }
- }
- int startOffset;
- int endOffset;
- final int firstLayoutDirection;
- if (mAnchorInfo.mLayoutFromEnd) {
- firstLayoutDirection = mShouldReverseLayout ? LayoutState.ITEM_DIRECTION_TAIL
- : LayoutState.ITEM_DIRECTION_HEAD;
- } else {
- firstLayoutDirection = mShouldReverseLayout ? LayoutState.ITEM_DIRECTION_HEAD
- : LayoutState.ITEM_DIRECTION_TAIL;
- }
-
- onAnchorReady(recycler, state, mAnchorInfo, firstLayoutDirection);
- detachAndScrapAttachedViews(recycler);
- mLayoutState.mInfinite = resolveIsInfinite();
- mLayoutState.mIsPreLayout = state.isPreLayout();
- // noRecycleSpace not needed: recycling doesn't happen in below's fill
- // invocations because mScrollingOffset is set to SCROLLING_OFFSET_NaN
- mLayoutState.mNoRecycleSpace = 0;
- if (mAnchorInfo.mLayoutFromEnd) {
- // fill towards start
- updateLayoutStateToFillStart(mAnchorInfo);
- mLayoutState.mExtraFillSpace = extraForStart;
- fill(recycler, mLayoutState, state, false);
- startOffset = mLayoutState.mOffset;
- final int firstElement = mLayoutState.mCurrentPosition;
- if (mLayoutState.mAvailable > 0) {
- extraForEnd += mLayoutState.mAvailable;
- }
- // fill towards end
- updateLayoutStateToFillEnd(mAnchorInfo);
- mLayoutState.mExtraFillSpace = extraForEnd;
- mLayoutState.mCurrentPosition += mLayoutState.mItemDirection;
- fill(recycler, mLayoutState, state, false);
- endOffset = mLayoutState.mOffset;
-
- if (mLayoutState.mAvailable > 0) {
- // end could not consume all. add more items towards start
- extraForStart = mLayoutState.mAvailable;
- updateLayoutStateToFillStart(firstElement, startOffset);
- mLayoutState.mExtraFillSpace = extraForStart;
- fill(recycler, mLayoutState, state, false);
- startOffset = mLayoutState.mOffset;
- }
- } else {
- // fill towards end
- updateLayoutStateToFillEnd(mAnchorInfo);
- mLayoutState.mExtraFillSpace = extraForEnd;
- fill(recycler, mLayoutState, state, false);
- endOffset = mLayoutState.mOffset;
- final int lastElement = mLayoutState.mCurrentPosition;
- if (mLayoutState.mAvailable > 0) {
- extraForStart += mLayoutState.mAvailable;
- }
- // fill towards start
- updateLayoutStateToFillStart(mAnchorInfo);
- mLayoutState.mExtraFillSpace = extraForStart;
- mLayoutState.mCurrentPosition += mLayoutState.mItemDirection;
- fill(recycler, mLayoutState, state, false);
- startOffset = mLayoutState.mOffset;
-
- if (mLayoutState.mAvailable > 0) {
- extraForEnd = mLayoutState.mAvailable;
- // start could not consume all it should. add more items towards end
- updateLayoutStateToFillEnd(lastElement, endOffset);
- mLayoutState.mExtraFillSpace = extraForEnd;
- fill(recycler, mLayoutState, state, false);
- endOffset = mLayoutState.mOffset;
- }
- }
-
- // changes may cause gaps on the UI, try to fix them.
- // TODO we can probably avoid this if neither stackFromEnd/reverseLayout/RTL values have
- // changed
- if (getChildCount() > 0) {
- // because layout from end may be changed by scroll to position
- // we re-calculate it.
- // find which side we should check for gaps.
- if (mShouldReverseLayout ^ mStackFromEnd) {
- int fixOffset = fixLayoutEndGap(endOffset, recycler, state, true);
- startOffset += fixOffset;
- endOffset += fixOffset;
- fixOffset = fixLayoutStartGap(startOffset, recycler, state, false);
- startOffset += fixOffset;
- endOffset += fixOffset;
- } else {
- int fixOffset = fixLayoutStartGap(startOffset, recycler, state, true);
- startOffset += fixOffset;
- endOffset += fixOffset;
- fixOffset = fixLayoutEndGap(endOffset, recycler, state, false);
- startOffset += fixOffset;
- endOffset += fixOffset;
- }
- }
- layoutForPredictiveAnimations(recycler, state, startOffset, endOffset);
- if (!state.isPreLayout()) {
- mOrientationHelper.onLayoutComplete();
- } else {
- mAnchorInfo.reset();
- }
- mLastStackFromEnd = mStackFromEnd;
- if (DEBUG) {
- validateChildOrder();
- }
- }
-
- @Override
- @SuppressLint("UnknownNullness") // b/240775049: Cannot annotate properly
- public void onLayoutCompleted(RecyclerView.State state) {
- super.onLayoutCompleted(state);
- mPendingSavedState = null; // we don't need this anymore
- mPendingScrollPosition = RecyclerView.NO_POSITION;
- mPendingScrollPositionOffset = INVALID_OFFSET;
- mAnchorInfo.reset();
- }
-
- /**
- * Method called when Anchor position is decided. Extending class can setup accordingly or
- * even update anchor info if necessary.
- *
- * @param recycler The recycler for the layout
- * @param state The layout state
- * @param anchorInfo The mutable POJO that keeps the position and offset.
- * @param firstLayoutItemDirection The direction of the first layout filling in terms of adapter
- * indices.
- */
- void onAnchorReady(RecyclerView.Recycler recycler, RecyclerView.State state,
- AnchorInfo anchorInfo, int firstLayoutItemDirection) {
- }
-
- /**
- * If necessary, layouts new items for predictive animations
- */
- private void layoutForPredictiveAnimations(RecyclerView.Recycler recycler,
- RecyclerView.State state, int startOffset,
- int endOffset) {
- // If there are scrap children that we did not layout, we need to find where they did go
- // and layout them accordingly so that animations can work as expected.
- // This case may happen if new views are added or an existing view expands and pushes
- // another view out of bounds.
- if (!state.willRunPredictiveAnimations() || getChildCount() == 0 || state.isPreLayout()
- || !supportsPredictiveItemAnimations()) {
- return;
- }
- // to make the logic simpler, we calculate the size of children and call fill.
- int scrapExtraStart = 0, scrapExtraEnd = 0;
- final List scrapList = recycler.getScrapList();
- final int scrapSize = scrapList.size();
- final int firstChildPos = getPosition(getChildAt(0));
- for (int i = 0; i < scrapSize; i++) {
- RecyclerView.ViewHolder scrap = scrapList.get(i);
- if (scrap.isRemoved()) {
- continue;
- }
- final int position = scrap.getLayoutPosition();
- final int direction = position < firstChildPos != mShouldReverseLayout
- ? LayoutState.LAYOUT_START : LayoutState.LAYOUT_END;
- if (direction == LayoutState.LAYOUT_START) {
- scrapExtraStart += mOrientationHelper.getDecoratedMeasurement(scrap.itemView);
- } else {
- scrapExtraEnd += mOrientationHelper.getDecoratedMeasurement(scrap.itemView);
- }
- }
-
- if (DEBUG) {
- Log.d(TAG, "for unused scrap, decided to add " + scrapExtraStart
- + " towards start and " + scrapExtraEnd + " towards end");
- }
- mLayoutState.mScrapList = scrapList;
- if (scrapExtraStart > 0) {
- View anchor = getChildClosestToStart();
- updateLayoutStateToFillStart(getPosition(anchor), startOffset);
- mLayoutState.mExtraFillSpace = scrapExtraStart;
- mLayoutState.mAvailable = 0;
- mLayoutState.assignPositionFromScrapList();
- fill(recycler, mLayoutState, state, false);
- }
-
- if (scrapExtraEnd > 0) {
- View anchor = getChildClosestToEnd();
- updateLayoutStateToFillEnd(getPosition(anchor), endOffset);
- mLayoutState.mExtraFillSpace = scrapExtraEnd;
- mLayoutState.mAvailable = 0;
- mLayoutState.assignPositionFromScrapList();
- fill(recycler, mLayoutState, state, false);
- }
- mLayoutState.mScrapList = null;
- }
-
- private void updateAnchorInfoForLayout(RecyclerView.Recycler recycler, RecyclerView.State state,
- AnchorInfo anchorInfo) {
- if (updateAnchorFromPendingData(state, anchorInfo)) {
- if (DEBUG) {
- Log.d(TAG, "updated anchor info from pending information");
- }
- return;
- }
-
- if (updateAnchorFromChildren(recycler, state, anchorInfo)) {
- if (DEBUG) {
- Log.d(TAG, "updated anchor info from existing children");
- }
- return;
- }
- if (DEBUG) {
- Log.d(TAG, "deciding anchor info for fresh state");
- }
- anchorInfo.assignCoordinateFromPadding();
- anchorInfo.mPosition = mStackFromEnd ? state.getItemCount() - 1 : 0;
- }
-
- /**
- * Finds an anchor child from existing Views. Most of the time, this is the view closest to
- * start or end that has a valid position (e.g. not removed).
- *
- * If a child has focus, it is given priority.
- */
- private boolean updateAnchorFromChildren(RecyclerView.Recycler recycler,
- RecyclerView.State state, AnchorInfo anchorInfo) {
- if (getChildCount() == 0) {
- return false;
- }
- final View focused = getFocusedChild();
- if (focused != null && anchorInfo.isViewValidAsAnchor(focused, state)) {
- anchorInfo.assignFromViewAndKeepVisibleRect(focused, getPosition(focused));
- return true;
- }
- if (mLastStackFromEnd != mStackFromEnd) {
- return false;
- }
- View referenceChild =
- findReferenceChild(
- recycler,
- state,
- anchorInfo.mLayoutFromEnd,
- mStackFromEnd);
- if (referenceChild != null) {
- anchorInfo.assignFromView(referenceChild, getPosition(referenceChild));
- // If all visible views are removed in 1 pass, reference child might be out of bounds.
- // If that is the case, offset it back to 0 so that we use these pre-layout children.
- if (!state.isPreLayout() && supportsPredictiveItemAnimations()) {
- // validate this child is at least partially visible. if not, offset it to start
- final int childStart = mOrientationHelper.getDecoratedStart(referenceChild);
- final int childEnd = mOrientationHelper.getDecoratedEnd(referenceChild);
- final int boundsStart = mOrientationHelper.getStartAfterPadding();
- final int boundsEnd = mOrientationHelper.getEndAfterPadding();
- // b/148869110: usually if childStart >= boundsEnd the child is out of
- // bounds, except if the child is 0 pixels!
- boolean outOfBoundsBefore = childEnd <= boundsStart && childStart < boundsStart;
- boolean outOfBoundsAfter = childStart >= boundsEnd && childEnd > boundsEnd;
- if (outOfBoundsBefore || outOfBoundsAfter) {
- anchorInfo.mCoordinate = anchorInfo.mLayoutFromEnd ? boundsEnd : boundsStart;
- }
- }
- return true;
- }
- return false;
- }
-
- /**
- * If there is a pending scroll position or saved states, updates the anchor info from that
- * data and returns true
- */
- private boolean updateAnchorFromPendingData(RecyclerView.State state, AnchorInfo anchorInfo) {
- if (state.isPreLayout() || mPendingScrollPosition == RecyclerView.NO_POSITION) {
- return false;
- }
- // validate scroll position
- if (mPendingScrollPosition < 0 || mPendingScrollPosition >= state.getItemCount()) {
- mPendingScrollPosition = RecyclerView.NO_POSITION;
- mPendingScrollPositionOffset = INVALID_OFFSET;
- if (DEBUG) {
- Log.e(TAG, "ignoring invalid scroll position " + mPendingScrollPosition);
- }
- return false;
- }
-
- // if child is visible, try to make it a reference child and ensure it is fully visible.
- // if child is not visible, align it depending on its virtual position.
- anchorInfo.mPosition = mPendingScrollPosition;
- if (mPendingSavedState != null && mPendingSavedState.hasValidAnchor()) {
- // Anchor offset depends on how that child was laid out. Here, we update it
- // according to our current view bounds
- anchorInfo.mLayoutFromEnd = mPendingSavedState.mAnchorLayoutFromEnd;
- if (anchorInfo.mLayoutFromEnd) {
- anchorInfo.mCoordinate = mOrientationHelper.getEndAfterPadding()
- - mPendingSavedState.mAnchorOffset;
- } else {
- anchorInfo.mCoordinate = mOrientationHelper.getStartAfterPadding()
- + mPendingSavedState.mAnchorOffset;
- }
- return true;
- }
-
- if (mPendingScrollPositionOffset == INVALID_OFFSET) {
- View child = findViewByPosition(mPendingScrollPosition);
- if (child != null) {
- final int childSize = mOrientationHelper.getDecoratedMeasurement(child);
- if (childSize > mOrientationHelper.getTotalSpace()) {
- // item does not fit. fix depending on layout direction
- anchorInfo.assignCoordinateFromPadding();
- return true;
- }
- final int startGap = mOrientationHelper.getDecoratedStart(child)
- - mOrientationHelper.getStartAfterPadding();
- if (startGap < 0) {
- anchorInfo.mCoordinate = mOrientationHelper.getStartAfterPadding();
- anchorInfo.mLayoutFromEnd = false;
- return true;
- }
- final int endGap = mOrientationHelper.getEndAfterPadding()
- - mOrientationHelper.getDecoratedEnd(child);
- if (endGap < 0) {
- anchorInfo.mCoordinate = mOrientationHelper.getEndAfterPadding();
- anchorInfo.mLayoutFromEnd = true;
- return true;
- }
- anchorInfo.mCoordinate = anchorInfo.mLayoutFromEnd
- ? (mOrientationHelper.getDecoratedEnd(child) + mOrientationHelper
- .getTotalSpaceChange())
- : mOrientationHelper.getDecoratedStart(child);
- } else { // item is not visible.
- if (getChildCount() > 0) {
- // get position of any child, does not matter
- int pos = getPosition(getChildAt(0));
- anchorInfo.mLayoutFromEnd = mPendingScrollPosition < pos
- == mShouldReverseLayout;
- }
- anchorInfo.assignCoordinateFromPadding();
- }
- return true;
- }
- // override layout from end values for consistency
- anchorInfo.mLayoutFromEnd = mShouldReverseLayout;
- // if this changes, we should update prepareForDrop as well
- if (mShouldReverseLayout) {
- anchorInfo.mCoordinate = mOrientationHelper.getEndAfterPadding()
- - mPendingScrollPositionOffset;
- } else {
- anchorInfo.mCoordinate = mOrientationHelper.getStartAfterPadding()
- + mPendingScrollPositionOffset;
- }
- return true;
- }
-
- /**
- * @return The final offset amount for children
- */
- private int fixLayoutEndGap(int endOffset, RecyclerView.Recycler recycler,
- RecyclerView.State state, boolean canOffsetChildren) {
- int gap = mOrientationHelper.getEndAfterPadding() - endOffset;
- int fixOffset = 0;
- if (gap > 0) {
- fixOffset = -scrollBy(-gap, recycler, state);
- } else {
- return 0; // nothing to fix
- }
- // move offset according to scroll amount
- endOffset += fixOffset;
- if (canOffsetChildren) {
- // re-calculate gap, see if we could fix it
- gap = mOrientationHelper.getEndAfterPadding() - endOffset;
- if (gap > 0) {
- mOrientationHelper.offsetChildren(gap);
- return gap + fixOffset;
- }
- }
- return fixOffset;
- }
-
- /**
- * @return The final offset amount for children
- */
- private int fixLayoutStartGap(int startOffset, RecyclerView.Recycler recycler,
- RecyclerView.State state, boolean canOffsetChildren) {
- int gap = startOffset - mOrientationHelper.getStartAfterPadding();
- int fixOffset = 0;
- if (gap > 0) {
- // check if we should fix this gap.
- fixOffset = -scrollBy(gap, recycler, state);
- } else {
- return 0; // nothing to fix
- }
- startOffset += fixOffset;
- if (canOffsetChildren) {
- // re-calculate gap, see if we could fix it
- gap = startOffset - mOrientationHelper.getStartAfterPadding();
- if (gap > 0) {
- mOrientationHelper.offsetChildren(-gap);
- return fixOffset - gap;
- }
- }
- return fixOffset;
- }
-
- private void updateLayoutStateToFillEnd(AnchorInfo anchorInfo) {
- updateLayoutStateToFillEnd(anchorInfo.mPosition, anchorInfo.mCoordinate);
- }
-
- private void updateLayoutStateToFillEnd(int itemPosition, int offset) {
- mLayoutState.mAvailable = mOrientationHelper.getEndAfterPadding() - offset;
- mLayoutState.mItemDirection = mShouldReverseLayout ? LayoutState.ITEM_DIRECTION_HEAD :
- LayoutState.ITEM_DIRECTION_TAIL;
- mLayoutState.mCurrentPosition = itemPosition;
- mLayoutState.mLayoutDirection = LayoutState.LAYOUT_END;
- mLayoutState.mOffset = offset;
- mLayoutState.mScrollingOffset = LayoutState.SCROLLING_OFFSET_NaN;
- }
-
- private void updateLayoutStateToFillStart(AnchorInfo anchorInfo) {
- updateLayoutStateToFillStart(anchorInfo.mPosition, anchorInfo.mCoordinate);
- }
-
- private void updateLayoutStateToFillStart(int itemPosition, int offset) {
- mLayoutState.mAvailable = offset - mOrientationHelper.getStartAfterPadding();
- mLayoutState.mCurrentPosition = itemPosition;
- mLayoutState.mItemDirection = mShouldReverseLayout ? LayoutState.ITEM_DIRECTION_TAIL :
- LayoutState.ITEM_DIRECTION_HEAD;
- mLayoutState.mLayoutDirection = LayoutState.LAYOUT_START;
- mLayoutState.mOffset = offset;
- mLayoutState.mScrollingOffset = LayoutState.SCROLLING_OFFSET_NaN;
-
- }
-
- protected boolean isLayoutRTL() {
- return getLayoutDirection() == ViewCompat.LAYOUT_DIRECTION_RTL;
- }
-
- void ensureLayoutState() {
- if (mLayoutState == null) {
- mLayoutState = createLayoutState();
- }
- }
-
- /**
- * Test overrides this to plug some tracking and verification.
- *
- * @return A new LayoutState
- */
- LayoutState createLayoutState() {
- return new LayoutState();
- }
-
- /**
- *
Scroll the RecyclerView to make the position visible.
- *
- * RecyclerView will scroll the minimum amount that is necessary to make the
- * target position visible. If you are looking for a similar behavior to
- * {@link android.widget.ListView#setSelection(int)} or
- * {@link android.widget.ListView#setSelectionFromTop(int, int)}, use
- * {@link #scrollToPositionWithOffset(int, int)}.
- *
- * Note that scroll position change will not be reflected until the next layout call.
- *
- * @param position Scroll to this adapter position
- * @see #scrollToPositionWithOffset(int, int)
- */
- @Override
- public void scrollToPosition(int position) {
- mPendingScrollPosition = position;
- mPendingScrollPositionOffset = INVALID_OFFSET;
- if (mPendingSavedState != null) {
- mPendingSavedState.invalidateAnchor();
- }
- requestLayout();
- }
-
- /**
- * Scroll to the specified adapter position with the given offset from resolved layout
- * start. Resolved layout start depends on {@link #getReverseLayout()},
- * {@link ViewCompat#getLayoutDirection(android.view.View)} and {@link #getStackFromEnd()}.
- *
- * For example, if layout is {@link #VERTICAL} and {@link #getStackFromEnd()} is true, calling
- * scrollToPositionWithOffset(10, 20) will layout such that
- * item[10]'s bottom is 20 pixels above the RecyclerView's bottom.
- *
- * Note that scroll position change will not be reflected until the next layout call.
- *
- * If you are just trying to make a position visible, use {@link #scrollToPosition(int)}.
- *
- * @param position Index (starting at 0) of the reference item.
- * @param offset The distance (in pixels) between the start edge of the item view and
- * start edge of the RecyclerView.
- * @see #setReverseLayout(boolean)
- * @see #scrollToPosition(int)
- */
- public void scrollToPositionWithOffset(int position, int offset) {
- mPendingScrollPosition = position;
- mPendingScrollPositionOffset = offset;
- if (mPendingSavedState != null) {
- mPendingSavedState.invalidateAnchor();
- }
- requestLayout();
- }
-
-
- /**
- * {@inheritDoc}
- */
- @Override
- @SuppressLint("UnknownNullness") // b/240775049: Cannot annotate properly
- public int scrollHorizontallyBy(int dx, RecyclerView.Recycler recycler,
- RecyclerView.State state) {
- if (mOrientation == VERTICAL) {
- return 0;
- }
- return scrollBy(dx, recycler, state);
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- @SuppressLint("UnknownNullness") // b/240775049: Cannot annotate properly
- public int scrollVerticallyBy(int dy, RecyclerView.Recycler recycler,
- RecyclerView.State state) {
- if (mOrientation == HORIZONTAL) {
- return 0;
- }
- return scrollBy(dy, recycler, state);
- }
-
- @Override
- @SuppressLint("UnknownNullness") // b/240775049: Cannot annotate properly
- public int computeHorizontalScrollOffset(RecyclerView.State state) {
- return computeScrollOffset(state);
- }
-
- @Override
- @SuppressLint("UnknownNullness") // b/240775049: Cannot annotate properly
- public int computeVerticalScrollOffset(RecyclerView.State state) {
- return computeScrollOffset(state);
- }
-
- @Override
- @SuppressLint("UnknownNullness") // b/240775049: Cannot annotate properly
- public int computeHorizontalScrollExtent(RecyclerView.State state) {
- return computeScrollExtent(state);
- }
-
- @Override
- @SuppressLint("UnknownNullness") // b/240775049: Cannot annotate properly
- public int computeVerticalScrollExtent(RecyclerView.State state) {
- return computeScrollExtent(state);
- }
-
- @Override
- @SuppressLint("UnknownNullness") // b/240775049: Cannot annotate properly
- public int computeHorizontalScrollRange(RecyclerView.State state) {
- return computeScrollRange(state);
- }
-
- @Override
- @SuppressLint("UnknownNullness") // b/240775049: Cannot annotate properly
- public int computeVerticalScrollRange(RecyclerView.State state) {
- return computeScrollRange(state);
- }
-
- private int computeScrollOffset(RecyclerView.State state) {
- if (getChildCount() == 0) {
- return 0;
- }
- ensureLayoutState();
- return ScrollbarHelper.computeScrollOffset(state, mOrientationHelper,
- findFirstVisibleChildClosestToStart(!mSmoothScrollbarEnabled, true),
- findFirstVisibleChildClosestToEnd(!mSmoothScrollbarEnabled, true),
- this, mSmoothScrollbarEnabled, mShouldReverseLayout);
- }
-
- private int computeScrollExtent(RecyclerView.State state) {
- if (getChildCount() == 0) {
- return 0;
- }
- ensureLayoutState();
- return ScrollbarHelper.computeScrollExtent(state, mOrientationHelper,
- findFirstVisibleChildClosestToStart(!mSmoothScrollbarEnabled, true),
- findFirstVisibleChildClosestToEnd(!mSmoothScrollbarEnabled, true),
- this, mSmoothScrollbarEnabled);
- }
-
- private int computeScrollRange(RecyclerView.State state) {
- if (getChildCount() == 0) {
- return 0;
- }
- ensureLayoutState();
- return ScrollbarHelper.computeScrollRange(state, mOrientationHelper,
- findFirstVisibleChildClosestToStart(!mSmoothScrollbarEnabled, true),
- findFirstVisibleChildClosestToEnd(!mSmoothScrollbarEnabled, true),
- this, mSmoothScrollbarEnabled);
- }
-
- /**
- * When smooth scrollbar is enabled, the position and size of the scrollbar thumb is computed
- * based on the number of visible pixels in the visible items. This however assumes that all
- * list items have similar or equal widths or heights (depending on list orientation).
- * If you use a list in which items have different dimensions, the scrollbar will change
- * appearance as the user scrolls through the list. To avoid this issue, you need to disable
- * this property.
- *
- * When smooth scrollbar is disabled, the position and size of the scrollbar thumb is based
- * solely on the number of items in the adapter and the position of the visible items inside
- * the adapter. This provides a stable scrollbar as the user navigates through a list of items
- * with varying widths / heights.
- *
- * @param enabled Whether or not to enable smooth scrollbar.
- * @see #setSmoothScrollbarEnabled(boolean)
- */
- public void setSmoothScrollbarEnabled(boolean enabled) {
- mSmoothScrollbarEnabled = enabled;
- }
-
- /**
- * Returns the current state of the smooth scrollbar feature. It is enabled by default.
- *
- * @return True if smooth scrollbar is enabled, false otherwise.
- * @see #setSmoothScrollbarEnabled(boolean)
- */
- public boolean isSmoothScrollbarEnabled() {
- return mSmoothScrollbarEnabled;
- }
-
- private void updateLayoutState(int layoutDirection, int requiredSpace,
- boolean canUseExistingSpace, RecyclerView.State state) {
- // If parent provides a hint, don't measure unlimited.
- mLayoutState.mInfinite = resolveIsInfinite();
- mLayoutState.mLayoutDirection = layoutDirection;
- mReusableIntPair[0] = 0;
- mReusableIntPair[1] = 0;
- calculateExtraLayoutSpace(state, mReusableIntPair);
- int extraForStart = Math.max(0, mReusableIntPair[0]);
- int extraForEnd = Math.max(0, mReusableIntPair[1]);
- boolean layoutToEnd = layoutDirection == LayoutState.LAYOUT_END;
- mLayoutState.mExtraFillSpace = layoutToEnd ? extraForEnd : extraForStart;
- mLayoutState.mNoRecycleSpace = layoutToEnd ? extraForStart : extraForEnd;
- int scrollingOffset;
- if (layoutToEnd) {
- mLayoutState.mExtraFillSpace += mOrientationHelper.getEndPadding();
- // get the first child in the direction we are going
- final View child = getChildClosestToEnd();
- // the direction in which we are traversing children
- mLayoutState.mItemDirection = mShouldReverseLayout ? LayoutState.ITEM_DIRECTION_HEAD
- : LayoutState.ITEM_DIRECTION_TAIL;
- mLayoutState.mCurrentPosition = getPosition(child) + mLayoutState.mItemDirection;
- mLayoutState.mOffset = mOrientationHelper.getDecoratedEnd(child);
- // calculate how much we can scroll without adding new children (independent of layout)
- scrollingOffset = mOrientationHelper.getDecoratedEnd(child)
- - mOrientationHelper.getEndAfterPadding();
-
- } else {
- final View child = getChildClosestToStart();
- mLayoutState.mExtraFillSpace += mOrientationHelper.getStartAfterPadding();
- mLayoutState.mItemDirection = mShouldReverseLayout ? LayoutState.ITEM_DIRECTION_TAIL
- : LayoutState.ITEM_DIRECTION_HEAD;
- mLayoutState.mCurrentPosition = getPosition(child) + mLayoutState.mItemDirection;
- mLayoutState.mOffset = mOrientationHelper.getDecoratedStart(child);
- scrollingOffset = -mOrientationHelper.getDecoratedStart(child)
- + mOrientationHelper.getStartAfterPadding();
- }
- mLayoutState.mAvailable = requiredSpace;
- if (canUseExistingSpace) {
- mLayoutState.mAvailable -= scrollingOffset;
- }
- mLayoutState.mScrollingOffset = scrollingOffset;
- }
-
- boolean resolveIsInfinite() {
- return mOrientationHelper.getMode() == View.MeasureSpec.UNSPECIFIED
- && mOrientationHelper.getEnd() == 0;
- }
-
- void collectPrefetchPositionsForLayoutState(RecyclerView.State state, LayoutState layoutState,
- LayoutPrefetchRegistry layoutPrefetchRegistry) {
- final int pos = layoutState.mCurrentPosition;
- if (pos >= 0 && pos < state.getItemCount()) {
- layoutPrefetchRegistry.addPosition(pos, Math.max(0, layoutState.mScrollingOffset));
- }
- }
-
- @Override
- @SuppressLint("UnknownNullness") // b/240775049: Cannot annotate properly
- public void collectInitialPrefetchPositions(int adapterItemCount,
- LayoutPrefetchRegistry layoutPrefetchRegistry) {
- final boolean fromEnd;
- final int anchorPos;
- if (mPendingSavedState != null && mPendingSavedState.hasValidAnchor()) {
- // use restored state, since it hasn't been resolved yet
- fromEnd = mPendingSavedState.mAnchorLayoutFromEnd;
- anchorPos = mPendingSavedState.mAnchorPosition;
- } else {
- resolveShouldLayoutReverse();
- fromEnd = mShouldReverseLayout;
- if (mPendingScrollPosition == RecyclerView.NO_POSITION) {
- anchorPos = fromEnd ? adapterItemCount - 1 : 0;
- } else {
- anchorPos = mPendingScrollPosition;
- }
- }
-
- final int direction = fromEnd
- ? LayoutState.ITEM_DIRECTION_HEAD
- : LayoutState.ITEM_DIRECTION_TAIL;
- int targetPos = anchorPos;
- for (int i = 0; i < mInitialPrefetchItemCount; i++) {
- if (targetPos >= 0 && targetPos < adapterItemCount) {
- layoutPrefetchRegistry.addPosition(targetPos, 0);
- } else {
- break; // no more to prefetch
- }
- targetPos += direction;
- }
- }
-
- /**
- * Sets the number of items to prefetch in
- * {@link #collectInitialPrefetchPositions(int, LayoutPrefetchRegistry)}, which defines
- * how many inner items should be prefetched when this LayoutManager's RecyclerView
- * is nested inside another RecyclerView.
- *
- *
Set this value to the number of items this inner LayoutManager will display when it is
- * first scrolled into the viewport. RecyclerView will attempt to prefetch that number of items
- * so they are ready, avoiding jank as the inner RecyclerView is scrolled into the viewport.
- *
- * For example, take a vertically scrolling RecyclerView with horizontally scrolling inner
- * RecyclerViews. The rows always have 4 items visible in them (or 5 if not aligned). Passing
- * 4 to this method for each inner RecyclerView's LinearLayoutManager will enable
- * RecyclerView's prefetching feature to do create/bind work for 4 views within a row early,
- * before it is scrolled on screen, instead of just the default 2.
- *
- * Calling this method does nothing unless the LayoutManager is in a RecyclerView
- * nested in another RecyclerView.
- *
- * Note: Setting this value to be larger than the number of
- * views that will be visible in this view can incur unnecessary bind work, and an increase to
- * the number of Views created and in active use.
- *
- * @param itemCount Number of items to prefetch
- * @see #isItemPrefetchEnabled()
- * @see #getInitialPrefetchItemCount()
- * @see #collectInitialPrefetchPositions(int, LayoutPrefetchRegistry)
- */
- public void setInitialPrefetchItemCount(int itemCount) {
- mInitialPrefetchItemCount = itemCount;
- }
-
- /**
- * Gets the number of items to prefetch in
- * {@link #collectInitialPrefetchPositions(int, LayoutPrefetchRegistry)}, which defines
- * how many inner items should be prefetched when this LayoutManager's RecyclerView
- * is nested inside another RecyclerView.
- *
- * @return number of items to prefetch.
- * @see #isItemPrefetchEnabled()
- * @see #setInitialPrefetchItemCount(int)
- * @see #collectInitialPrefetchPositions(int, LayoutPrefetchRegistry)
- */
- public int getInitialPrefetchItemCount() {
- return mInitialPrefetchItemCount;
- }
-
- @Override
- @SuppressLint("UnknownNullness") // b/240775049: Cannot annotate properly
- public void collectAdjacentPrefetchPositions(int dx, int dy, RecyclerView.State state,
- LayoutPrefetchRegistry layoutPrefetchRegistry) {
- int delta = (mOrientation == HORIZONTAL) ? dx : dy;
- if (getChildCount() == 0 || delta == 0) {
- // can't support this scroll, so don't bother prefetching
- return;
- }
-
- ensureLayoutState();
- final int layoutDirection = delta > 0 ? LayoutState.LAYOUT_END : LayoutState.LAYOUT_START;
- final int absDelta = Math.abs(delta);
- updateLayoutState(layoutDirection, absDelta, true, state);
- collectPrefetchPositionsForLayoutState(state, mLayoutState, layoutPrefetchRegistry);
- }
-
- int scrollBy(int delta, RecyclerView.Recycler recycler, RecyclerView.State state) {
- if (getChildCount() == 0 || delta == 0) {
- return 0;
- }
- ensureLayoutState();
- mLayoutState.mRecycle = true;
- final int layoutDirection = delta > 0 ? LayoutState.LAYOUT_END : LayoutState.LAYOUT_START;
- final int absDelta = Math.abs(delta);
- updateLayoutState(layoutDirection, absDelta, true, state);
- final int consumed = mLayoutState.mScrollingOffset
- + fill(recycler, mLayoutState, state, false);
- if (consumed < 0) {
- if (DEBUG) {
- Log.d(TAG, "Don't have any more elements to scroll");
- }
- return 0;
- }
- final int scrolled = absDelta > consumed ? layoutDirection * consumed : delta;
- mOrientationHelper.offsetChildren(-scrolled);
- if (DEBUG) {
- Log.d(TAG, "scroll req: " + delta + " scrolled: " + scrolled);
- }
- mLayoutState.mLastScrollDelta = scrolled;
- return scrolled;
- }
-
- @Override
- @SuppressLint("UnknownNullness") // b/240775049: Cannot annotate properly
- public void assertNotInLayoutOrScroll(String message) {
- if (mPendingSavedState == null) {
- super.assertNotInLayoutOrScroll(message);
- }
- }
-
- /**
- * Recycles children between given indices.
- *
- * @param startIndex inclusive
- * @param endIndex exclusive
- */
- private void recycleChildren(RecyclerView.Recycler recycler, int startIndex, int endIndex) {
- if (startIndex == endIndex) {
- return;
- }
- if (DEBUG) {
- Log.d(TAG, "Recycling " + Math.abs(startIndex - endIndex) + " items");
- }
- if (endIndex > startIndex) {
- for (int i = endIndex - 1; i >= startIndex; i--) {
- removeAndRecycleViewAt(i, recycler);
- }
- } else {
- for (int i = startIndex; i > endIndex; i--) {
- removeAndRecycleViewAt(i, recycler);
- }
- }
- }
-
- /**
- * Recycles views that went out of bounds after scrolling towards the end of the layout.
- *
- * Checks both layout position and visible position to guarantee that the view is not visible.
- *
- * @param recycler Recycler instance of {@link RecyclerView}
- * @param scrollingOffset This can be used to add additional padding to the visible area. This
- * is used to detect children that will go out of bounds after scrolling,
- * without actually moving them.
- * @param noRecycleSpace Extra space that should be excluded from recycling. This is the space
- * from {@code extraLayoutSpace[0]}, calculated in {@link
- * #calculateExtraLayoutSpace}.
- */
- private void recycleViewsFromStart(RecyclerView.Recycler recycler, int scrollingOffset,
- int noRecycleSpace) {
- if (scrollingOffset < 0) {
- if (DEBUG) {
- Log.d(TAG, "Called recycle from start with a negative value. This might happen"
- + " during layout changes but may be sign of a bug");
- }
- return;
- }
- // ignore padding, ViewGroup may not clip children.
- final int limit = scrollingOffset - noRecycleSpace;
- final int childCount = getChildCount();
- if (mShouldReverseLayout) {
- for (int i = childCount - 1; i >= 0; i--) {
- View child = getChildAt(i);
- if (mOrientationHelper.getDecoratedEnd(child) > limit
- || mOrientationHelper.getTransformedEndWithDecoration(child) > limit) {
- // stop here
- recycleChildren(recycler, childCount - 1, i);
- return;
- }
- }
- } else {
- for (int i = 0; i < childCount; i++) {
- View child = getChildAt(i);
- if (mOrientationHelper.getDecoratedEnd(child) > limit
- || mOrientationHelper.getTransformedEndWithDecoration(child) > limit) {
- // stop here
- recycleChildren(recycler, 0, i);
- return;
- }
- }
- }
- }
-
-
- /**
- * Recycles views that went out of bounds after scrolling towards the start of the layout.
- *
- * Checks both layout position and visible position to guarantee that the view is not visible.
- *
- * @param recycler Recycler instance of {@link RecyclerView}
- * @param scrollingOffset This can be used to add additional padding to the visible area. This
- * is used to detect children that will go out of bounds after scrolling,
- * without actually moving them.
- * @param noRecycleSpace Extra space that should be excluded from recycling. This is the space
- * from {@code extraLayoutSpace[1]}, calculated in {@link
- * #calculateExtraLayoutSpace}.
- */
- private void recycleViewsFromEnd(RecyclerView.Recycler recycler, int scrollingOffset,
- int noRecycleSpace) {
- final int childCount = getChildCount();
- if (scrollingOffset < 0) {
- if (DEBUG) {
- Log.d(TAG, "Called recycle from end with a negative value. This might happen"
- + " during layout changes but may be sign of a bug");
- }
- return;
- }
- final int limit = mOrientationHelper.getEnd() - scrollingOffset + noRecycleSpace;
- if (mShouldReverseLayout) {
- for (int i = 0; i < childCount; i++) {
- View child = getChildAt(i);
- if (mOrientationHelper.getDecoratedStart(child) < limit
- || mOrientationHelper.getTransformedStartWithDecoration(child) < limit) {
- // stop here
- recycleChildren(recycler, 0, i);
- return;
- }
- }
- } else {
- for (int i = childCount - 1; i >= 0; i--) {
- View child = getChildAt(i);
- if (mOrientationHelper.getDecoratedStart(child) < limit
- || mOrientationHelper.getTransformedStartWithDecoration(child) < limit) {
- // stop here
- recycleChildren(recycler, childCount - 1, i);
- return;
- }
- }
- }
- }
-
- /**
- * Helper method to call appropriate recycle method depending on current layout direction
- *
- * @param recycler Current recycler that is attached to RecyclerView
- * @param layoutState Current layout state. Right now, this object does not change but
- * we may consider moving it out of this view so passing around as a
- * parameter for now, rather than accessing {@link #mLayoutState}
- * @see #recycleViewsFromStart(RecyclerView.Recycler, int, int)
- * @see #recycleViewsFromEnd(RecyclerView.Recycler, int, int)
- * @see LinearLayoutManager.LayoutState#mLayoutDirection
- */
- private void recycleByLayoutState(RecyclerView.Recycler recycler, LayoutState layoutState) {
- if (!layoutState.mRecycle || layoutState.mInfinite) {
- return;
- }
- int scrollingOffset = layoutState.mScrollingOffset;
- int noRecycleSpace = layoutState.mNoRecycleSpace;
- if (layoutState.mLayoutDirection == LayoutState.LAYOUT_START) {
- recycleViewsFromEnd(recycler, scrollingOffset, noRecycleSpace);
- } else {
- recycleViewsFromStart(recycler, scrollingOffset, noRecycleSpace);
- }
- }
-
- /**
- * The magic functions :). Fills the given layout, defined by the layoutState. This is fairly
- * independent from the rest of the {@link LinearLayoutManager}
- * and with little change, can be made publicly available as a helper class.
- *
- * @param recycler Current recycler that is attached to RecyclerView
- * @param layoutState Configuration on how we should fill out the available space.
- * @param state Context passed by the RecyclerView to control scroll steps.
- * @param stopOnFocusable If true, filling stops in the first focusable new child
- * @return Number of pixels that it added. Useful for scroll functions.
- */
- int fill(RecyclerView.Recycler recycler, LayoutState layoutState,
- RecyclerView.State state, boolean stopOnFocusable) {
- // max offset we should set is mFastScroll + available
- final int start = layoutState.mAvailable;
- if (layoutState.mScrollingOffset != LayoutState.SCROLLING_OFFSET_NaN) {
- // TODO ugly bug fix. should not happen
- if (layoutState.mAvailable < 0) {
- layoutState.mScrollingOffset += layoutState.mAvailable;
- }
- recycleByLayoutState(recycler, layoutState);
- }
- int remainingSpace = layoutState.mAvailable + layoutState.mExtraFillSpace;
- LayoutChunkResult layoutChunkResult = mLayoutChunkResult;
- while ((layoutState.mInfinite || remainingSpace > 0) && layoutState.hasMore(state)) {
- layoutChunkResult.resetInternal();
- if (RecyclerView.VERBOSE_TRACING) {
- TraceCompat.beginSection("LLM LayoutChunk");
- }
- layoutChunk(recycler, state, layoutState, layoutChunkResult);
- if (RecyclerView.VERBOSE_TRACING) {
- TraceCompat.endSection();
- }
- if (layoutChunkResult.mFinished) {
- break;
- }
- layoutState.mOffset += layoutChunkResult.mConsumed * layoutState.mLayoutDirection;
- /**
- * Consume the available space if:
- * * layoutChunk did not request to be ignored
- * * OR we are laying out scrap children
- * * OR we are not doing pre-layout
- */
- if (!layoutChunkResult.mIgnoreConsumed || layoutState.mScrapList != null
- || !state.isPreLayout()) {
- layoutState.mAvailable -= layoutChunkResult.mConsumed;
- // we keep a separate remaining space because mAvailable is important for recycling
- remainingSpace -= layoutChunkResult.mConsumed;
- }
-
- if (layoutState.mScrollingOffset != LayoutState.SCROLLING_OFFSET_NaN) {
- layoutState.mScrollingOffset += layoutChunkResult.mConsumed;
- if (layoutState.mAvailable < 0) {
- layoutState.mScrollingOffset += layoutState.mAvailable;
- }
- recycleByLayoutState(recycler, layoutState);
- }
- if (stopOnFocusable && layoutChunkResult.mFocusable) {
- break;
- }
- }
- if (DEBUG) {
- validateChildOrder();
- }
- return start - layoutState.mAvailable;
- }
-
- void layoutChunk(RecyclerView.Recycler recycler, RecyclerView.State state,
- LayoutState layoutState, LayoutChunkResult result) {
- View view = layoutState.next(recycler);
- if (view == null) {
- if (DEBUG && layoutState.mScrapList == null) {
- throw new RuntimeException("received null view when unexpected");
- }
- // if we are laying out views in scrap, this may return null which means there is
- // no more items to layout.
- result.mFinished = true;
- return;
- }
- RecyclerView.LayoutParams params = (RecyclerView.LayoutParams) view.getLayoutParams();
- if (layoutState.mScrapList == null) {
- if (mShouldReverseLayout == (layoutState.mLayoutDirection
- == LayoutState.LAYOUT_START)) {
- addView(view);
- } else {
- addView(view, 0);
- }
- } else {
- if (mShouldReverseLayout == (layoutState.mLayoutDirection
- == LayoutState.LAYOUT_START)) {
- addDisappearingView(view);
- } else {
- addDisappearingView(view, 0);
- }
- }
- measureChildWithMargins(view, 0, 0);
- result.mConsumed = mOrientationHelper.getDecoratedMeasurement(view);
- int left, top, right, bottom;
- if (mOrientation == VERTICAL) {
- if (isLayoutRTL()) {
- right = getWidth() - getPaddingRight();
- left = right - mOrientationHelper.getDecoratedMeasurementInOther(view);
- } else {
- left = getPaddingLeft();
- right = left + mOrientationHelper.getDecoratedMeasurementInOther(view);
- }
- if (layoutState.mLayoutDirection == LayoutState.LAYOUT_START) {
- bottom = layoutState.mOffset;
- top = layoutState.mOffset - result.mConsumed;
- } else {
- top = layoutState.mOffset;
- bottom = layoutState.mOffset + result.mConsumed;
- }
- } else {
- top = getPaddingTop();
- bottom = top + mOrientationHelper.getDecoratedMeasurementInOther(view);
-
- if (layoutState.mLayoutDirection == LayoutState.LAYOUT_START) {
- right = layoutState.mOffset;
- left = layoutState.mOffset - result.mConsumed;
- } else {
- left = layoutState.mOffset;
- right = layoutState.mOffset + result.mConsumed;
- }
- }
- // We calculate everything with View's bounding box (which includes decor and margins)
- // To calculate correct layout position, we subtract margins.
- layoutDecoratedWithMargins(view, left, top, right, bottom);
- if (DEBUG) {
- Log.d(TAG, "laid out child at position " + getPosition(view) + ", with l:"
- + (left + params.leftMargin) + ", t:" + (top + params.topMargin) + ", r:"
- + (right - params.rightMargin) + ", b:" + (bottom - params.bottomMargin));
- }
- // Consume the available space if the view is not removed OR changed
- if (params.isItemRemoved() || params.isItemChanged()) {
- result.mIgnoreConsumed = true;
- }
- result.mFocusable = view.hasFocusable();
- }
-
- @Override
- boolean shouldMeasureTwice() {
- return getHeightMode() != View.MeasureSpec.EXACTLY
- && getWidthMode() != View.MeasureSpec.EXACTLY
- && hasFlexibleChildInBothOrientations();
- }
-
- /**
- * Converts a focusDirection to orientation.
- *
- * @param focusDirection One of {@link View#FOCUS_UP}, {@link View#FOCUS_DOWN},
- * {@link View#FOCUS_LEFT}, {@link View#FOCUS_RIGHT},
- * {@link View#FOCUS_BACKWARD}, {@link View#FOCUS_FORWARD}
- * or 0 for not applicable
- * @return {@link LayoutState#LAYOUT_START} or {@link LayoutState#LAYOUT_END} if focus direction
- * is applicable to current state, {@link LayoutState#INVALID_LAYOUT} otherwise.
- */
- int convertFocusDirectionToLayoutDirection(int focusDirection) {
- switch (focusDirection) {
- case View.FOCUS_BACKWARD:
- if (mOrientation == VERTICAL) {
- return LayoutState.LAYOUT_START;
- } else if (isLayoutRTL()) {
- return LayoutState.LAYOUT_END;
- } else {
- return LayoutState.LAYOUT_START;
- }
- case View.FOCUS_FORWARD:
- if (mOrientation == VERTICAL) {
- return LayoutState.LAYOUT_END;
- } else if (isLayoutRTL()) {
- return LayoutState.LAYOUT_START;
- } else {
- return LayoutState.LAYOUT_END;
- }
- case View.FOCUS_UP:
- return mOrientation == VERTICAL ? LayoutState.LAYOUT_START
- : LayoutState.INVALID_LAYOUT;
- case View.FOCUS_DOWN:
- return mOrientation == VERTICAL ? LayoutState.LAYOUT_END
- : LayoutState.INVALID_LAYOUT;
- case View.FOCUS_LEFT:
- return mOrientation == HORIZONTAL ? LayoutState.LAYOUT_START
- : LayoutState.INVALID_LAYOUT;
- case View.FOCUS_RIGHT:
- return mOrientation == HORIZONTAL ? LayoutState.LAYOUT_END
- : LayoutState.INVALID_LAYOUT;
- default:
- if (DEBUG) {
- Log.d(TAG, "Unknown focus request:" + focusDirection);
- }
- return LayoutState.INVALID_LAYOUT;
- }
-
- }
-
- /**
- * Convenience method to find the child closes to start. Caller should check it has enough
- * children.
- *
- * @return The child closes to start of the layout from user's perspective.
- */
- private View getChildClosestToStart() {
- return getChildAt(mShouldReverseLayout ? getChildCount() - 1 : 0);
- }
-
- /**
- * Convenience method to find the child closes to end. Caller should check it has enough
- * children.
- *
- * @return The child closes to end of the layout from user's perspective.
- */
- private View getChildClosestToEnd() {
- return getChildAt(mShouldReverseLayout ? 0 : getChildCount() - 1);
- }
-
- /**
- * Convenience method to find the visible child closes to start. Caller should check if it has
- * enough children.
- *
- * @param completelyVisible Whether child should be completely visible or not
- * @return The first visible child closest to start of the layout from user's perspective.
- */
- View findFirstVisibleChildClosestToStart(boolean completelyVisible,
- boolean acceptPartiallyVisible) {
- if (mShouldReverseLayout) {
- return findOneVisibleChild(getChildCount() - 1, -1, completelyVisible,
- acceptPartiallyVisible);
- } else {
- return findOneVisibleChild(0, getChildCount(), completelyVisible,
- acceptPartiallyVisible);
- }
- }
-
- /**
- * Convenience method to find the visible child closes to end. Caller should check if it has
- * enough children.
- *
- * @param completelyVisible Whether child should be completely visible or not
- * @return The first visible child closest to end of the layout from user's perspective.
- */
- View findFirstVisibleChildClosestToEnd(boolean completelyVisible,
- boolean acceptPartiallyVisible) {
- if (mShouldReverseLayout) {
- return findOneVisibleChild(0, getChildCount(), completelyVisible,
- acceptPartiallyVisible);
- } else {
- return findOneVisibleChild(getChildCount() - 1, -1, completelyVisible,
- acceptPartiallyVisible);
- }
- }
-
- // overridden by GridLayoutManager
-
- /**
- * Finds a suitable anchor child.
- *
- * Due to ambiguous adapter updates or children being removed, some children's positions may be
- * invalid. This method is a best effort to find a position within adapter bounds if possible.
- *
- * It also prioritizes children from best to worst in this order:
- *
- * An in bounds child.
- * An out of bounds child.
- * An invalid child.
- *
- *
- * @param layoutFromEnd True if the RV scrolls in the reverse direction, which is the same as
- * (reverseLayout ^ stackFromEnd).
- * @param traverseChildrenInReverseOrder True if the children should be traversed in reverse
- * order (stackFromEnd).
- * @return A View that can be used an an anchor View.
- */
- View findReferenceChild(RecyclerView.Recycler recycler, RecyclerView.State state,
- boolean layoutFromEnd, boolean traverseChildrenInReverseOrder) {
- ensureLayoutState();
-
- // Determine which direction through the view children we are going iterate.
- int start = 0;
- int end = getChildCount();
- int diff = 1;
- if (traverseChildrenInReverseOrder) {
- start = getChildCount() - 1;
- end = -1;
- diff = -1;
- }
-
- int itemCount = state.getItemCount();
-
- final int boundsStart = mOrientationHelper.getStartAfterPadding();
- final int boundsEnd = mOrientationHelper.getEndAfterPadding();
-
- View invalidMatch = null;
- View bestFirstFind = null;
- View bestSecondFind = null;
-
- for (int i = start; i != end; i += diff) {
- final View view = getChildAt(i);
- final int position = getPosition(view);
- final int childStart = mOrientationHelper.getDecoratedStart(view);
- final int childEnd = mOrientationHelper.getDecoratedEnd(view);
- if (position >= 0 && position < itemCount) {
- if (((RecyclerView.LayoutParams) view.getLayoutParams()).isItemRemoved()) {
- if (invalidMatch == null) {
- invalidMatch = view; // removed item, least preferred
- }
- } else {
- // b/148869110: usually if childStart >= boundsEnd the child is out of
- // bounds, except if the child is 0 pixels!
- boolean outOfBoundsBefore = childEnd <= boundsStart && childStart < boundsStart;
- boolean outOfBoundsAfter = childStart >= boundsEnd && childEnd > boundsEnd;
- if (outOfBoundsBefore || outOfBoundsAfter) {
- // The item is out of bounds.
- // We want to find the items closest to the in bounds items and because we
- // are always going through the items linearly, the 2 items we want are the
- // last out of bounds item on the side we start searching on, and the first
- // out of bounds item on the side we are ending on. The side that we are
- // ending on ultimately takes priority because we want items later in the
- // layout to move forward if no in bounds anchors are found.
- if (layoutFromEnd) {
- if (outOfBoundsAfter) {
- bestFirstFind = view;
- } else if (bestSecondFind == null) {
- bestSecondFind = view;
- }
- } else {
- if (outOfBoundsBefore) {
- bestFirstFind = view;
- } else if (bestSecondFind == null) {
- bestSecondFind = view;
- }
- }
- } else {
- // We found an in bounds item, greedily return it.
- return view;
- }
- }
- }
- }
- // We didn't find an in bounds item so we will settle for an item in this order:
- // 1. bestSecondFind
- // 2. bestFirstFind
- // 3. invalidMatch
- return bestSecondFind != null ? bestSecondFind :
- (bestFirstFind != null ? bestFirstFind : invalidMatch);
- }
-
- // returns the out-of-bound child view closest to RV's end bounds. An out-of-bound child is
- // defined as a child that's either partially or fully invisible (outside RV's padding area).
- private View findPartiallyOrCompletelyInvisibleChildClosestToEnd() {
- return mShouldReverseLayout ? findFirstPartiallyOrCompletelyInvisibleChild()
- : findLastPartiallyOrCompletelyInvisibleChild();
- }
-
- // returns the out-of-bound child view closest to RV's starting bounds. An out-of-bound child is
- // defined as a child that's either partially or fully invisible (outside RV's padding area).
- private View findPartiallyOrCompletelyInvisibleChildClosestToStart() {
- return mShouldReverseLayout ? findLastPartiallyOrCompletelyInvisibleChild() :
- findFirstPartiallyOrCompletelyInvisibleChild();
- }
-
- private View findFirstPartiallyOrCompletelyInvisibleChild() {
- return findOnePartiallyOrCompletelyInvisibleChild(0, getChildCount());
- }
-
- private View findLastPartiallyOrCompletelyInvisibleChild() {
- return findOnePartiallyOrCompletelyInvisibleChild(getChildCount() - 1, -1);
- }
-
- /**
- * Returns the adapter position of the first visible view. This position does not include
- * adapter changes that were dispatched after the last layout pass.
- *
- * Note that, this value is not affected by layout orientation or item order traversal.
- * ({@link #setReverseLayout(boolean)}). Views are sorted by their positions in the adapter,
- * not in the layout.
- *
- * If RecyclerView has item decorators, they will be considered in calculations as well.
- *
- * LayoutManager may pre-cache some views that are not necessarily visible. Those views
- * are ignored in this method.
- *
- * @return The adapter position of the first visible item or {@link RecyclerView#NO_POSITION} if
- * there aren't any visible items.
- * @see #findFirstCompletelyVisibleItemPosition()
- * @see #findLastVisibleItemPosition()
- */
- public int findFirstVisibleItemPosition() {
- final View child = findOneVisibleChild(0, getChildCount(), false, true);
- return child == null ? RecyclerView.NO_POSITION : getPosition(child);
- }
-
- /**
- * Returns the adapter position of the first fully visible view. This position does not include
- * adapter changes that were dispatched after the last layout pass.
- *
- * Note that bounds check is only performed in the current orientation. That means, if
- * LayoutManager is horizontal, it will only check the view's left and right edges.
- *
- * @return The adapter position of the first fully visible item or
- * {@link RecyclerView#NO_POSITION} if there aren't any visible items.
- * @see #findFirstVisibleItemPosition()
- * @see #findLastCompletelyVisibleItemPosition()
- */
- public int findFirstCompletelyVisibleItemPosition() {
- final View child = findOneVisibleChild(0, getChildCount(), true, false);
- return child == null ? RecyclerView.NO_POSITION : getPosition(child);
- }
-
- /**
- * Returns the adapter position of the last visible view. This position does not include
- * adapter changes that were dispatched after the last layout pass.
- *
- * Note that, this value is not affected by layout orientation or item order traversal.
- * ({@link #setReverseLayout(boolean)}). Views are sorted by their positions in the adapter,
- * not in the layout.
- *
- * If RecyclerView has item decorators, they will be considered in calculations as well.
- *
- * LayoutManager may pre-cache some views that are not necessarily visible. Those views
- * are ignored in this method.
- *
- * @return The adapter position of the last visible view or {@link RecyclerView#NO_POSITION} if
- * there aren't any visible items.
- * @see #findLastCompletelyVisibleItemPosition()
- * @see #findFirstVisibleItemPosition()
- */
- public int findLastVisibleItemPosition() {
- final View child = findOneVisibleChild(getChildCount() - 1, -1, false, true);
- return child == null ? RecyclerView.NO_POSITION : getPosition(child);
- }
-
- /**
- * Returns the adapter position of the last fully visible view. This position does not include
- * adapter changes that were dispatched after the last layout pass.
- *
- * Note that bounds check is only performed in the current orientation. That means, if
- * LayoutManager is horizontal, it will only check the view's left and right edges.
- *
- * @return The adapter position of the last fully visible view or
- * {@link RecyclerView#NO_POSITION} if there aren't any visible items.
- * @see #findLastVisibleItemPosition()
- * @see #findFirstCompletelyVisibleItemPosition()
- */
- public int findLastCompletelyVisibleItemPosition() {
- final View child = findOneVisibleChild(getChildCount() - 1, -1, true, false);
- return child == null ? RecyclerView.NO_POSITION : getPosition(child);
- }
-
- // Returns the first child that is visible in the provided index range, i.e. either partially or
- // fully visible depending on the arguments provided. Completely invisible children are not
- // acceptable by this method, but could be returned
- // using #findOnePartiallyOrCompletelyInvisibleChild
- View findOneVisibleChild(int fromIndex, int toIndex, boolean completelyVisible,
- boolean acceptPartiallyVisible) {
- ensureLayoutState();
- @ViewBoundsCheck.ViewBounds int preferredBoundsFlag = 0;
- @ViewBoundsCheck.ViewBounds int acceptableBoundsFlag = 0;
- if (completelyVisible) {
- preferredBoundsFlag = (ViewBoundsCheck.FLAG_CVS_GT_PVS | ViewBoundsCheck.FLAG_CVS_EQ_PVS
- | ViewBoundsCheck.FLAG_CVE_LT_PVE | ViewBoundsCheck.FLAG_CVE_EQ_PVE);
- } else {
- preferredBoundsFlag = (ViewBoundsCheck.FLAG_CVS_LT_PVE
- | ViewBoundsCheck.FLAG_CVE_GT_PVS);
- }
- if (acceptPartiallyVisible) {
- acceptableBoundsFlag = (ViewBoundsCheck.FLAG_CVS_LT_PVE
- | ViewBoundsCheck.FLAG_CVE_GT_PVS);
- }
- return (mOrientation == HORIZONTAL) ? mHorizontalBoundCheck
- .findOneViewWithinBoundFlags(fromIndex, toIndex, preferredBoundsFlag,
- acceptableBoundsFlag) : mVerticalBoundCheck
- .findOneViewWithinBoundFlags(fromIndex, toIndex, preferredBoundsFlag,
- acceptableBoundsFlag);
- }
-
- View findOnePartiallyOrCompletelyInvisibleChild(int fromIndex, int toIndex) {
- ensureLayoutState();
- final int next = toIndex > fromIndex ? 1 : (toIndex < fromIndex ? -1 : 0);
- if (next == 0) {
- return getChildAt(fromIndex);
- }
- @ViewBoundsCheck.ViewBounds int preferredBoundsFlag = 0;
- @ViewBoundsCheck.ViewBounds int acceptableBoundsFlag = 0;
- if (mOrientationHelper.getDecoratedStart(getChildAt(fromIndex))
- < mOrientationHelper.getStartAfterPadding()) {
- preferredBoundsFlag = (ViewBoundsCheck.FLAG_CVS_LT_PVS | ViewBoundsCheck.FLAG_CVE_LT_PVE
- | ViewBoundsCheck.FLAG_CVE_GT_PVS);
- acceptableBoundsFlag = (ViewBoundsCheck.FLAG_CVS_LT_PVS
- | ViewBoundsCheck.FLAG_CVE_LT_PVE);
- } else {
- preferredBoundsFlag = (ViewBoundsCheck.FLAG_CVE_GT_PVE | ViewBoundsCheck.FLAG_CVS_GT_PVS
- | ViewBoundsCheck.FLAG_CVS_LT_PVE);
- acceptableBoundsFlag = (ViewBoundsCheck.FLAG_CVE_GT_PVE
- | ViewBoundsCheck.FLAG_CVS_GT_PVS);
- }
- return (mOrientation == HORIZONTAL) ? mHorizontalBoundCheck
- .findOneViewWithinBoundFlags(fromIndex, toIndex, preferredBoundsFlag,
- acceptableBoundsFlag) : mVerticalBoundCheck
- .findOneViewWithinBoundFlags(fromIndex, toIndex, preferredBoundsFlag,
- acceptableBoundsFlag);
- }
-
- @Override
- @SuppressLint("UnknownNullness") // b/240775049: Cannot annotate properly
- public View onFocusSearchFailed(View focused, int direction,
- RecyclerView.Recycler recycler, RecyclerView.State state) {
- resolveShouldLayoutReverse();
- if (getChildCount() == 0) {
- return null;
- }
-
- final int layoutDir = convertFocusDirectionToLayoutDirection(direction);
- if (layoutDir == LayoutState.INVALID_LAYOUT) {
- return null;
- }
- ensureLayoutState();
- final int maxScroll = (int) (MAX_SCROLL_FACTOR * mOrientationHelper.getTotalSpace());
- updateLayoutState(layoutDir, maxScroll, false, state);
- mLayoutState.mScrollingOffset = LayoutState.SCROLLING_OFFSET_NaN;
- mLayoutState.mRecycle = false;
- fill(recycler, mLayoutState, state, true);
-
- // nextCandidate is the first child view in the layout direction that's partially
- // within RV's bounds, i.e. part of it is visible or it's completely invisible but still
- // touching RV's bounds. This will be the unfocusable candidate view to become visible onto
- // the screen if no focusable views are found in the given layout direction.
- final View nextCandidate;
- if (layoutDir == LayoutState.LAYOUT_START) {
- nextCandidate = findPartiallyOrCompletelyInvisibleChildClosestToStart();
- } else {
- nextCandidate = findPartiallyOrCompletelyInvisibleChildClosestToEnd();
- }
- // nextFocus is meaningful only if it refers to a focusable child, in which case it
- // indicates the next view to gain focus.
- final View nextFocus;
- if (layoutDir == LayoutState.LAYOUT_START) {
- nextFocus = getChildClosestToStart();
- } else {
- nextFocus = getChildClosestToEnd();
- }
- if (nextFocus.hasFocusable()) {
- if (nextCandidate == null) {
- return null;
- }
- return nextFocus;
- }
- return nextCandidate;
- }
-
- /**
- * Used for debugging.
- * Logs the internal representation of children to default logger.
- */
- private void logChildren() {
- Log.d(TAG, "internal representation of views on the screen");
- for (int i = 0; i < getChildCount(); i++) {
- View child = getChildAt(i);
- Log.d(TAG, "item " + getPosition(child) + ", coord:"
- + mOrientationHelper.getDecoratedStart(child));
- }
- Log.d(TAG, "==============");
- }
-
- /**
- * Used for debugging.
- * Validates that child views are laid out in correct order. This is important because rest of
- * the algorithm relies on this constraint.
- *
- * In default layout, child 0 should be closest to screen position 0 and last child should be
- * closest to position WIDTH or HEIGHT.
- * In reverse layout, last child should be closes to screen position 0 and first child should
- * be closest to position WIDTH or HEIGHT
- */
- void validateChildOrder() {
- Log.d(TAG, "validating child count " + getChildCount());
- if (getChildCount() < 1) {
- return;
- }
- int lastPos = getPosition(getChildAt(0));
- int lastScreenLoc = mOrientationHelper.getDecoratedStart(getChildAt(0));
- if (mShouldReverseLayout) {
- for (int i = 1; i < getChildCount(); i++) {
- View child = getChildAt(i);
- int pos = getPosition(child);
- int screenLoc = mOrientationHelper.getDecoratedStart(child);
- if (pos < lastPos) {
- logChildren();
- throw new RuntimeException("detected invalid position. loc invalid? "
- + (screenLoc < lastScreenLoc));
- }
- if (screenLoc > lastScreenLoc) {
- logChildren();
- throw new RuntimeException("detected invalid location");
- }
- }
- } else {
- for (int i = 1; i < getChildCount(); i++) {
- View child = getChildAt(i);
- int pos = getPosition(child);
- int screenLoc = mOrientationHelper.getDecoratedStart(child);
- if (pos < lastPos) {
- logChildren();
- throw new RuntimeException("detected invalid position. loc invalid? "
- + (screenLoc < lastScreenLoc));
- }
- if (screenLoc < lastScreenLoc) {
- logChildren();
- throw new RuntimeException("detected invalid location");
- }
- }
- }
- }
-
- @Override
- public boolean supportsPredictiveItemAnimations() {
- return mPendingSavedState == null && mLastStackFromEnd == mStackFromEnd;
- }
-
- /**
- * {@inheritDoc}
- */
- // This method is only intended to be called (and should only ever be called) by
- // ItemTouchHelper.
- @Override
- public void prepareForDrop(@NonNull View view, @NonNull View target, int x, int y) {
- assertNotInLayoutOrScroll("Cannot drop a view during a scroll or layout calculation");
- ensureLayoutState();
- resolveShouldLayoutReverse();
- final int myPos = getPosition(view);
- final int targetPos = getPosition(target);
- final int dropDirection = myPos < targetPos ? LayoutState.ITEM_DIRECTION_TAIL
- : LayoutState.ITEM_DIRECTION_HEAD;
- if (mShouldReverseLayout) {
- if (dropDirection == LayoutState.ITEM_DIRECTION_TAIL) {
- scrollToPositionWithOffset(targetPos,
- mOrientationHelper.getEndAfterPadding()
- - (mOrientationHelper.getDecoratedStart(target)
- + mOrientationHelper.getDecoratedMeasurement(view)));
- } else {
- scrollToPositionWithOffset(targetPos,
- mOrientationHelper.getEndAfterPadding()
- - mOrientationHelper.getDecoratedEnd(target));
- }
- } else {
- if (dropDirection == LayoutState.ITEM_DIRECTION_HEAD) {
- scrollToPositionWithOffset(targetPos, mOrientationHelper.getDecoratedStart(target));
- } else {
- scrollToPositionWithOffset(targetPos,
- mOrientationHelper.getDecoratedEnd(target)
- - mOrientationHelper.getDecoratedMeasurement(view));
- }
- }
- }
-
- /**
- * Helper class that keeps temporary state while {LayoutManager} is filling out the empty
- * space.
- */
- static class LayoutState {
-
- static final String TAG = "LLM#LayoutState";
-
- static final int LAYOUT_START = -1;
-
- static final int LAYOUT_END = 1;
-
- static final int INVALID_LAYOUT = Integer.MIN_VALUE;
-
- static final int ITEM_DIRECTION_HEAD = -1;
-
- static final int ITEM_DIRECTION_TAIL = 1;
-
- static final int SCROLLING_OFFSET_NaN = Integer.MIN_VALUE;
-
- /**
- * We may not want to recycle children in some cases (e.g. layout)
- */
- boolean mRecycle = true;
-
- /**
- * Pixel offset where layout should start
- */
- int mOffset;
-
- /**
- * Number of pixels that we should fill, in the layout direction.
- */
- int mAvailable;
-
- /**
- * Current position on the adapter to get the next item.
- */
- int mCurrentPosition;
-
- /**
- * Defines the direction in which the data adapter is traversed.
- * Should be {@link #ITEM_DIRECTION_HEAD} or {@link #ITEM_DIRECTION_TAIL}
- */
- int mItemDirection;
-
- /**
- * Defines the direction in which the layout is filled.
- * Should be {@link #LAYOUT_START} or {@link #LAYOUT_END}
- */
- int mLayoutDirection;
-
- /**
- * Used when LayoutState is constructed in a scrolling state.
- * It should be set the amount of scrolling we can make without creating a new view.
- * Settings this is required for efficient view recycling.
- */
- int mScrollingOffset;
-
- /**
- * Used if you want to pre-layout items that are not yet visible.
- * The difference with {@link #mAvailable} is that, when recycling, distance laid out for
- * {@link #mExtraFillSpace} is not considered to avoid recycling visible children.
- */
- int mExtraFillSpace = 0;
-
- /**
- * Contains the {@link #calculateExtraLayoutSpace(RecyclerView.State, int[])} extra layout
- * space} that should be excluded for recycling when cleaning up the tail of the list during
- * a smooth scroll.
- */
- int mNoRecycleSpace = 0;
-
- /**
- * Equal to {@link RecyclerView.State#isPreLayout()}. When consuming scrap, if this value
- * is set to true, we skip removed views since they should not be laid out in post layout
- * step.
- */
- boolean mIsPreLayout = false;
-
- /**
- * The most recent {@link #scrollBy(int, RecyclerView.Recycler, RecyclerView.State)}
- * amount.
- */
- int mLastScrollDelta;
-
- /**
- * When LLM needs to layout particular views, it sets this list in which case, LayoutState
- * will only return views from this list and return null if it cannot find an item.
- */
- List mScrapList = null;
-
- /**
- * Used when there is no limit in how many views can be laid out.
- */
- boolean mInfinite;
-
- /**
- * @return true if there are more items in the data adapter
- */
- boolean hasMore(RecyclerView.State state) {
- return mCurrentPosition >= 0 && mCurrentPosition < state.getItemCount();
- }
-
- /**
- * Gets the view for the next element that we should layout.
- * Also updates current item index to the next item, based on {@link #mItemDirection}
- *
- * @return The next element that we should layout.
- */
- View next(RecyclerView.Recycler recycler) {
- if (mScrapList != null) {
- return nextViewFromScrapList();
- }
- final View view = recycler.getViewForPosition(mCurrentPosition);
- mCurrentPosition += mItemDirection;
- return view;
- }
-
- /**
- * Returns the next item from the scrap list.
- *
- * Upon finding a valid VH, sets current item position to VH.itemPosition + mItemDirection
- *
- * @return View if an item in the current position or direction exists if not null.
- */
- private View nextViewFromScrapList() {
- final int size = mScrapList.size();
- for (int i = 0; i < size; i++) {
- final View view = mScrapList.get(i).itemView;
- final RecyclerView.LayoutParams lp =
- (RecyclerView.LayoutParams) view.getLayoutParams();
- if (lp.isItemRemoved()) {
- continue;
- }
- if (mCurrentPosition == lp.getViewLayoutPosition()) {
- assignPositionFromScrapList(view);
- return view;
- }
- }
- return null;
- }
-
- public void assignPositionFromScrapList() {
- assignPositionFromScrapList(null);
- }
-
- public void assignPositionFromScrapList(View ignore) {
- final View closest = nextViewInLimitedList(ignore);
- if (closest == null) {
- mCurrentPosition = RecyclerView.NO_POSITION;
- } else {
- mCurrentPosition = ((RecyclerView.LayoutParams) closest.getLayoutParams())
- .getViewLayoutPosition();
- }
- }
-
- public View nextViewInLimitedList(View ignore) {
- int size = mScrapList.size();
- View closest = null;
- int closestDistance = Integer.MAX_VALUE;
- if (DEBUG && mIsPreLayout) {
- throw new IllegalStateException("Scrap list cannot be used in pre layout");
- }
- for (int i = 0; i < size; i++) {
- View view = mScrapList.get(i).itemView;
- final RecyclerView.LayoutParams lp =
- (RecyclerView.LayoutParams) view.getLayoutParams();
- if (view == ignore || lp.isItemRemoved()) {
- continue;
- }
- final int distance = (lp.getViewLayoutPosition() - mCurrentPosition)
- * mItemDirection;
- if (distance < 0) {
- continue; // item is not in current direction
- }
- if (distance < closestDistance) {
- closest = view;
- closestDistance = distance;
- if (distance == 0) {
- break;
- }
- }
- }
- return closest;
- }
-
- void log() {
- Log.d(TAG, "avail:" + mAvailable + ", ind:" + mCurrentPosition + ", dir:"
- + mItemDirection + ", offset:" + mOffset + ", layoutDir:" + mLayoutDirection);
- }
- }
-
- /**
- * @hide
- */
- @RestrictTo(LIBRARY)
- @SuppressLint("BanParcelableUsage")
- public static class SavedState implements Parcelable {
-
- int mAnchorPosition;
-
- int mAnchorOffset;
-
- boolean mAnchorLayoutFromEnd;
-
- public SavedState() {
-
- }
-
- SavedState(Parcel in) {
- mAnchorPosition = in.readInt();
- mAnchorOffset = in.readInt();
- mAnchorLayoutFromEnd = in.readInt() == 1;
- }
-
- @SuppressLint("UnknownNullness") // b/240775049: Cannot annotate properly
- public SavedState(SavedState other) {
- mAnchorPosition = other.mAnchorPosition;
- mAnchorOffset = other.mAnchorOffset;
- mAnchorLayoutFromEnd = other.mAnchorLayoutFromEnd;
- }
-
- boolean hasValidAnchor() {
- return mAnchorPosition >= 0;
- }
-
- void invalidateAnchor() {
- mAnchorPosition = RecyclerView.NO_POSITION;
- }
-
- @Override
- public int describeContents() {
- return 0;
- }
-
- @Override
- public void writeToParcel(Parcel dest, int flags) {
- dest.writeInt(mAnchorPosition);
- dest.writeInt(mAnchorOffset);
- dest.writeInt(mAnchorLayoutFromEnd ? 1 : 0);
- }
-
- public static final Parcelable.Creator CREATOR =
- new Parcelable.Creator() {
- @Override
- public SavedState createFromParcel(Parcel in) {
- return new SavedState(in);
- }
-
- @Override
- public SavedState[] newArray(int size) {
- return new SavedState[size];
- }
- };
- }
-
- /**
- * Simple data class to keep Anchor information
- */
- static class AnchorInfo {
- OrientationHelper mOrientationHelper;
- int mPosition;
- int mCoordinate;
- boolean mLayoutFromEnd;
- boolean mValid;
-
- AnchorInfo() {
- reset();
- }
-
- void reset() {
- mPosition = RecyclerView.NO_POSITION;
- mCoordinate = INVALID_OFFSET;
- mLayoutFromEnd = false;
- mValid = false;
- }
-
- /**
- * assigns anchor coordinate from the RecyclerView's padding depending on current
- * layoutFromEnd value
- */
- void assignCoordinateFromPadding() {
- mCoordinate = mLayoutFromEnd
- ? mOrientationHelper.getEndAfterPadding()
- : mOrientationHelper.getStartAfterPadding();
- }
-
- @Override
- public String toString() {
- return "AnchorInfo{"
- + "mPosition=" + mPosition
- + ", mCoordinate=" + mCoordinate
- + ", mLayoutFromEnd=" + mLayoutFromEnd
- + ", mValid=" + mValid
- + '}';
- }
-
- boolean isViewValidAsAnchor(View child, RecyclerView.State state) {
- RecyclerView.LayoutParams lp = (RecyclerView.LayoutParams) child.getLayoutParams();
- return !lp.isItemRemoved() && lp.getViewLayoutPosition() >= 0
- && lp.getViewLayoutPosition() < state.getItemCount();
- }
-
- public void assignFromViewAndKeepVisibleRect(View child, int position) {
- final int spaceChange = mOrientationHelper.getTotalSpaceChange();
- if (spaceChange >= 0) {
- assignFromView(child, position);
- return;
- }
- mPosition = position;
- if (mLayoutFromEnd) {
- final int prevLayoutEnd = mOrientationHelper.getEndAfterPadding() - spaceChange;
- final int childEnd = mOrientationHelper.getDecoratedEnd(child);
- final int previousEndMargin = prevLayoutEnd - childEnd;
- mCoordinate = mOrientationHelper.getEndAfterPadding() - previousEndMargin;
- // ensure we did not push child's top out of bounds because of this
- if (previousEndMargin > 0) { // we have room to shift bottom if necessary
- final int childSize = mOrientationHelper.getDecoratedMeasurement(child);
- final int estimatedChildStart = mCoordinate - childSize;
- final int layoutStart = mOrientationHelper.getStartAfterPadding();
- final int previousStartMargin = mOrientationHelper.getDecoratedStart(child)
- - layoutStart;
- final int startReference = layoutStart + Math.min(previousStartMargin, 0);
- final int startMargin = estimatedChildStart - startReference;
- if (startMargin < 0) {
- // offset to make top visible but not too much
- mCoordinate += Math.min(previousEndMargin, -startMargin);
- }
- }
- } else {
- final int childStart = mOrientationHelper.getDecoratedStart(child);
- final int startMargin = childStart - mOrientationHelper.getStartAfterPadding();
- mCoordinate = childStart;
- if (startMargin > 0) { // we have room to fix end as well
- final int estimatedEnd = childStart
- + mOrientationHelper.getDecoratedMeasurement(child);
- final int previousLayoutEnd = mOrientationHelper.getEndAfterPadding()
- - spaceChange;
- final int previousEndMargin = previousLayoutEnd
- - mOrientationHelper.getDecoratedEnd(child);
- final int endReference = mOrientationHelper.getEndAfterPadding()
- - Math.min(0, previousEndMargin);
- final int endMargin = endReference - estimatedEnd;
- if (endMargin < 0) {
- mCoordinate -= Math.min(startMargin, -endMargin);
- }
- }
- }
- }
-
- public void assignFromView(View child, int position) {
- if (mLayoutFromEnd) {
- mCoordinate = mOrientationHelper.getDecoratedEnd(child)
- + mOrientationHelper.getTotalSpaceChange();
- } else {
- mCoordinate = mOrientationHelper.getDecoratedStart(child);
- }
-
- mPosition = position;
- }
- }
-
- protected static class LayoutChunkResult {
- public int mConsumed;
- public boolean mFinished;
- public boolean mIgnoreConsumed;
- public boolean mFocusable;
-
- void resetInternal() {
- mConsumed = 0;
- mFinished = false;
- mIgnoreConsumed = false;
- mFocusable = false;
- }
- }
-}
diff --git a/app/src/main/java/androidx/recyclerview/widget/LinearSmoothScroller.java b/app/src/main/java/androidx/recyclerview/widget/LinearSmoothScroller.java
deleted file mode 100644
index b4ba75fcdf..0000000000
--- a/app/src/main/java/androidx/recyclerview/widget/LinearSmoothScroller.java
+++ /dev/null
@@ -1,360 +0,0 @@
-/*
- * Copyright 2018 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package androidx.recyclerview.widget;
-
-import android.annotation.SuppressLint;
-import android.content.Context;
-import android.graphics.PointF;
-import android.util.DisplayMetrics;
-import android.view.View;
-import android.view.animation.DecelerateInterpolator;
-import android.view.animation.LinearInterpolator;
-
-/**
- * {@link RecyclerView.SmoothScroller} implementation which uses a {@link LinearInterpolator} until
- * the target position becomes a child of the RecyclerView and then uses a
- * {@link DecelerateInterpolator} to slowly approach to target position.
- *
- * If the {@link RecyclerView.LayoutManager} you are using does not implement the
- * {@link RecyclerView.SmoothScroller.ScrollVectorProvider} interface, then you must override the
- * {@link #computeScrollVectorForPosition(int)} method. All the LayoutManagers bundled with
- * the support library implement this interface.
- */
-public class LinearSmoothScroller extends RecyclerView.SmoothScroller {
-
- private static final boolean DEBUG = false;
-
- private static final float MILLISECONDS_PER_INCH = 25f;
-
- private static final int TARGET_SEEK_SCROLL_DISTANCE_PX = 10000;
-
- /**
- * Align child view's left or top with parent view's left or top
- *
- * @see #calculateDtToFit(int, int, int, int, int)
- * @see #calculateDxToMakeVisible(android.view.View, int)
- * @see #calculateDyToMakeVisible(android.view.View, int)
- */
- public static final int SNAP_TO_START = -1;
-
- /**
- * Align child view's right or bottom with parent view's right or bottom
- *
- * @see #calculateDtToFit(int, int, int, int, int)
- * @see #calculateDxToMakeVisible(android.view.View, int)
- * @see #calculateDyToMakeVisible(android.view.View, int)
- */
- public static final int SNAP_TO_END = 1;
-
- /**
- *
Decides if the child should be snapped from start or end, depending on where it
- * currently is in relation to its parent.
- * For instance, if the view is virtually on the left of RecyclerView, using
- * {@code SNAP_TO_ANY} is the same as using {@code SNAP_TO_START}
- *
- * @see #calculateDtToFit(int, int, int, int, int)
- * @see #calculateDxToMakeVisible(android.view.View, int)
- * @see #calculateDyToMakeVisible(android.view.View, int)
- */
- public static final int SNAP_TO_ANY = 0;
-
- // Trigger a scroll to a further distance than TARGET_SEEK_SCROLL_DISTANCE_PX so that if target
- // view is not laid out until interim target position is reached, we can detect the case before
- // scrolling slows down and reschedule another interim target scroll
- private static final float TARGET_SEEK_EXTRA_SCROLL_RATIO = 1.2f;
-
- protected final LinearInterpolator mLinearInterpolator = new LinearInterpolator();
-
- protected final DecelerateInterpolator mDecelerateInterpolator = new DecelerateInterpolator();
-
- @SuppressLint("UnknownNullness") // b/240775049: Cannot annotate properly
- protected PointF mTargetVector;
-
- private final DisplayMetrics mDisplayMetrics;
- private boolean mHasCalculatedMillisPerPixel = false;
- private float mMillisPerPixel;
-
- // Temporary variables to keep track of the interim scroll target. These values do not
- // point to a real item position, rather point to an estimated location pixels.
- protected int mInterimTargetDx = 0, mInterimTargetDy = 0;
-
- @SuppressLint("UnknownNullness") // b/240775049: Cannot annotate properly
- public LinearSmoothScroller(Context context) {
- mDisplayMetrics = context.getResources().getDisplayMetrics();
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- protected void onStart() {
-
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- @SuppressLint("UnknownNullness") // b/240775049: Cannot annotate properly
- protected void onTargetFound(View targetView, RecyclerView.State state, Action action) {
- final int dx = calculateDxToMakeVisible(targetView, getHorizontalSnapPreference());
- final int dy = calculateDyToMakeVisible(targetView, getVerticalSnapPreference());
- final int distance = (int) Math.sqrt(dx * dx + dy * dy);
- final int time = calculateTimeForDeceleration(distance);
- if (time > 0) {
- action.update(-dx, -dy, time, mDecelerateInterpolator);
- }
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- @SuppressLint("UnknownNullness") // b/240775049: Cannot annotate properly
- protected void onSeekTargetStep(int dx, int dy, RecyclerView.State state, Action action) {
- // TODO(b/72745539): Is there ever a time when onSeekTargetStep should be called when
- // getChildCount returns 0? Should this logic be extracted out of this method such that
- // this method is not called if getChildCount() returns 0?
- if (getChildCount() == 0) {
- stop();
- return;
- }
- //noinspection PointlessBooleanExpression
- if (DEBUG && mTargetVector != null
- && (mTargetVector.x * dx < 0 || mTargetVector.y * dy < 0)) {
- throw new IllegalStateException("Scroll happened in the opposite direction"
- + " of the target. Some calculations are wrong");
- }
- mInterimTargetDx = clampApplyScroll(mInterimTargetDx, dx);
- mInterimTargetDy = clampApplyScroll(mInterimTargetDy, dy);
-
- if (mInterimTargetDx == 0 && mInterimTargetDy == 0) {
- updateActionForInterimTarget(action);
- } // everything is valid, keep going
-
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- protected void onStop() {
- mInterimTargetDx = mInterimTargetDy = 0;
- mTargetVector = null;
- }
-
- /**
- * Calculates the scroll speed.
- *
- * By default, LinearSmoothScroller assumes this method always returns the same value and
- * caches the result of calling it.
- *
- * @param displayMetrics DisplayMetrics to be used for real dimension calculations
- * @return The time (in ms) it should take for each pixel. For instance, if returned value is
- * 2 ms, it means scrolling 1000 pixels with LinearInterpolation should take 2 seconds.
- */
- @SuppressLint("UnknownNullness") // b/240775049: Cannot annotate properly
- protected float calculateSpeedPerPixel(DisplayMetrics displayMetrics) {
- return MILLISECONDS_PER_INCH / displayMetrics.densityDpi;
- }
-
- private float getSpeedPerPixel() {
- if (!mHasCalculatedMillisPerPixel) {
- mMillisPerPixel = calculateSpeedPerPixel(mDisplayMetrics);
- mHasCalculatedMillisPerPixel = true;
- }
- return mMillisPerPixel;
- }
-
- /**
- *
Calculates the time for deceleration so that transition from LinearInterpolator to
- * DecelerateInterpolator looks smooth.
- *
- * @param dx Distance to scroll
- * @return Time for DecelerateInterpolator to smoothly traverse the distance when transitioning
- * from LinearInterpolation
- */
- protected int calculateTimeForDeceleration(int dx) {
- // we want to cover same area with the linear interpolator for the first 10% of the
- // interpolation. After that, deceleration will take control.
- // area under curve (1-(1-x)^2) can be calculated as (1 - x/3) * x * x
- // which gives 0.100028 when x = .3356
- // this is why we divide linear scrolling time with .3356
- return (int) Math.ceil(calculateTimeForScrolling(dx) / .3356);
- }
-
- /**
- * Calculates the time it should take to scroll the given distance (in pixels)
- *
- * @param dx Distance in pixels that we want to scroll
- * @return Time in milliseconds
- * @see #calculateSpeedPerPixel(android.util.DisplayMetrics)
- */
- protected int calculateTimeForScrolling(int dx) {
- // In a case where dx is very small, rounding may return 0 although dx > 0.
- // To avoid that issue, ceil the result so that if dx > 0, we'll always return positive
- // time.
- return (int) Math.ceil(Math.abs(dx) * getSpeedPerPixel());
- }
-
- /**
- * When scrolling towards a child view, this method defines whether we should align the left
- * or the right edge of the child with the parent RecyclerView.
- *
- * @return SNAP_TO_START, SNAP_TO_END or SNAP_TO_ANY; depending on the current target vector
- * @see #SNAP_TO_START
- * @see #SNAP_TO_END
- * @see #SNAP_TO_ANY
- */
- protected int getHorizontalSnapPreference() {
- return mTargetVector == null || mTargetVector.x == 0 ? SNAP_TO_ANY :
- mTargetVector.x > 0 ? SNAP_TO_END : SNAP_TO_START;
- }
-
- /**
- * When scrolling towards a child view, this method defines whether we should align the top
- * or the bottom edge of the child with the parent RecyclerView.
- *
- * @return SNAP_TO_START, SNAP_TO_END or SNAP_TO_ANY; depending on the current target vector
- * @see #SNAP_TO_START
- * @see #SNAP_TO_END
- * @see #SNAP_TO_ANY
- */
- protected int getVerticalSnapPreference() {
- return mTargetVector == null || mTargetVector.y == 0 ? SNAP_TO_ANY :
- mTargetVector.y > 0 ? SNAP_TO_END : SNAP_TO_START;
- }
-
- /**
- * When the target scroll position is not a child of the RecyclerView, this method calculates
- * a direction vector towards that child and triggers a smooth scroll.
- *
- * @see #computeScrollVectorForPosition(int)
- */
- @SuppressLint("UnknownNullness") // b/240775049: Cannot annotate properly
- protected void updateActionForInterimTarget(Action action) {
- // find an interim target position
- PointF scrollVector = computeScrollVectorForPosition(getTargetPosition());
- if (scrollVector == null || (scrollVector.x == 0 && scrollVector.y == 0)) {
- final int target = getTargetPosition();
- action.jumpTo(target);
- stop();
- return;
- }
- normalize(scrollVector);
- mTargetVector = scrollVector;
-
- mInterimTargetDx = (int) (TARGET_SEEK_SCROLL_DISTANCE_PX * scrollVector.x);
- mInterimTargetDy = (int) (TARGET_SEEK_SCROLL_DISTANCE_PX * scrollVector.y);
- final int time = calculateTimeForScrolling(TARGET_SEEK_SCROLL_DISTANCE_PX);
- // To avoid UI hiccups, trigger a smooth scroll to a distance little further than the
- // interim target. Since we track the distance travelled in onSeekTargetStep callback, it
- // won't actually scroll more than what we need.
- action.update((int) (mInterimTargetDx * TARGET_SEEK_EXTRA_SCROLL_RATIO),
- (int) (mInterimTargetDy * TARGET_SEEK_EXTRA_SCROLL_RATIO),
- (int) (time * TARGET_SEEK_EXTRA_SCROLL_RATIO), mLinearInterpolator);
- }
-
- private int clampApplyScroll(int tmpDt, int dt) {
- final int before = tmpDt;
- tmpDt -= dt;
- if (before * tmpDt <= 0) { // changed sign, reached 0 or was 0, reset
- return 0;
- }
- return tmpDt;
- }
-
- /**
- * Helper method for {@link #calculateDxToMakeVisible(android.view.View, int)} and
- * {@link #calculateDyToMakeVisible(android.view.View, int)}
- */
- public int calculateDtToFit(int viewStart, int viewEnd, int boxStart, int boxEnd, int
- snapPreference) {
- switch (snapPreference) {
- case SNAP_TO_START:
- return boxStart - viewStart;
- case SNAP_TO_END:
- return boxEnd - viewEnd;
- case SNAP_TO_ANY:
- final int dtStart = boxStart - viewStart;
- if (dtStart > 0) {
- return dtStart;
- }
- final int dtEnd = boxEnd - viewEnd;
- if (dtEnd < 0) {
- return dtEnd;
- }
- break;
- default:
- throw new IllegalArgumentException("snap preference should be one of the"
- + " constants defined in SmoothScroller, starting with SNAP_");
- }
- return 0;
- }
-
- /**
- * Calculates the vertical scroll amount necessary to make the given view fully visible
- * inside the RecyclerView.
- *
- * @param view The view which we want to make fully visible
- * @param snapPreference The edge which the view should snap to when entering the visible
- * area. One of {@link #SNAP_TO_START}, {@link #SNAP_TO_END} or
- * {@link #SNAP_TO_ANY}.
- * @return The vertical scroll amount necessary to make the view visible with the given
- * snap preference.
- */
- @SuppressLint("UnknownNullness") // b/240775049: Cannot annotate properly
- public int calculateDyToMakeVisible(View view, int snapPreference) {
- final RecyclerView.LayoutManager layoutManager = getLayoutManager();
- if (layoutManager == null || !layoutManager.canScrollVertically()) {
- return 0;
- }
- final RecyclerView.LayoutParams params = (RecyclerView.LayoutParams)
- view.getLayoutParams();
- final int top = layoutManager.getDecoratedTop(view) - params.topMargin;
- final int bottom = layoutManager.getDecoratedBottom(view) + params.bottomMargin;
- final int start = layoutManager.getPaddingTop();
- final int end = layoutManager.getHeight() - layoutManager.getPaddingBottom();
- return calculateDtToFit(top, bottom, start, end, snapPreference);
- }
-
- /**
- * Calculates the horizontal scroll amount necessary to make the given view fully visible
- * inside the RecyclerView.
- *
- * @param view The view which we want to make fully visible
- * @param snapPreference The edge which the view should snap to when entering the visible
- * area. One of {@link #SNAP_TO_START}, {@link #SNAP_TO_END} or
- * {@link #SNAP_TO_END}
- * @return The vertical scroll amount necessary to make the view visible with the given
- * snap preference.
- */
- @SuppressLint("UnknownNullness") // b/240775049: Cannot annotate properly
- public int calculateDxToMakeVisible(View view, int snapPreference) {
- final RecyclerView.LayoutManager layoutManager = getLayoutManager();
- if (layoutManager == null || !layoutManager.canScrollHorizontally()) {
- return 0;
- }
- final RecyclerView.LayoutParams params = (RecyclerView.LayoutParams)
- view.getLayoutParams();
- final int left = layoutManager.getDecoratedLeft(view) - params.leftMargin;
- final int right = layoutManager.getDecoratedRight(view) + params.rightMargin;
- final int start = layoutManager.getPaddingLeft();
- final int end = layoutManager.getWidth() - layoutManager.getPaddingRight();
- return calculateDtToFit(left, right, start, end, snapPreference);
- }
-}
diff --git a/app/src/main/java/androidx/recyclerview/widget/LinearSnapHelper.java b/app/src/main/java/androidx/recyclerview/widget/LinearSnapHelper.java
deleted file mode 100644
index 6481b877e5..0000000000
--- a/app/src/main/java/androidx/recyclerview/widget/LinearSnapHelper.java
+++ /dev/null
@@ -1,276 +0,0 @@
-/*
- * Copyright 2018 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package androidx.recyclerview.widget;
-
-import android.graphics.PointF;
-import android.view.View;
-
-import androidx.annotation.NonNull;
-import androidx.annotation.Nullable;
-
-/**
- * Implementation of the {@link SnapHelper} supporting snapping in either vertical or horizontal
- * orientation.
- *
- * The implementation will snap the center of the target child view to the center of
- * the attached {@link RecyclerView}. If you intend to change this behavior then override
- * {@link SnapHelper#calculateDistanceToFinalSnap}.
- */
-public class LinearSnapHelper extends SnapHelper {
-
- private static final float INVALID_DISTANCE = 1f;
-
- // Orientation helpers are lazily created per LayoutManager.
- @Nullable
- private OrientationHelper mVerticalHelper;
- @Nullable
- private OrientationHelper mHorizontalHelper;
-
- @Override
- public int[] calculateDistanceToFinalSnap(
- @NonNull RecyclerView.LayoutManager layoutManager, @NonNull View targetView) {
- int[] out = new int[2];
- if (layoutManager.canScrollHorizontally()) {
- out[0] = distanceToCenter(targetView,
- getHorizontalHelper(layoutManager));
- } else {
- out[0] = 0;
- }
-
- if (layoutManager.canScrollVertically()) {
- out[1] = distanceToCenter(targetView,
- getVerticalHelper(layoutManager));
- } else {
- out[1] = 0;
- }
- return out;
- }
-
- @Override
- public int findTargetSnapPosition(RecyclerView.LayoutManager layoutManager, int velocityX,
- int velocityY) {
- if (!(layoutManager instanceof RecyclerView.SmoothScroller.ScrollVectorProvider)) {
- return RecyclerView.NO_POSITION;
- }
-
- final int itemCount = layoutManager.getItemCount();
- if (itemCount == 0) {
- return RecyclerView.NO_POSITION;
- }
-
- final View currentView = findSnapView(layoutManager);
- if (currentView == null) {
- return RecyclerView.NO_POSITION;
- }
-
- final int currentPosition = layoutManager.getPosition(currentView);
- if (currentPosition == RecyclerView.NO_POSITION) {
- return RecyclerView.NO_POSITION;
- }
-
- RecyclerView.SmoothScroller.ScrollVectorProvider vectorProvider =
- (RecyclerView.SmoothScroller.ScrollVectorProvider) layoutManager;
- // deltaJumps sign comes from the velocity which may not match the order of children in
- // the LayoutManager. To overcome this, we ask for a vector from the LayoutManager to
- // get the direction.
- PointF vectorForEnd = vectorProvider.computeScrollVectorForPosition(itemCount - 1);
- if (vectorForEnd == null) {
- // cannot get a vector for the given position.
- return RecyclerView.NO_POSITION;
- }
-
- int vDeltaJump, hDeltaJump;
- if (layoutManager.canScrollHorizontally()) {
- hDeltaJump = estimateNextPositionDiffForFling(layoutManager,
- getHorizontalHelper(layoutManager), velocityX, 0);
- if (vectorForEnd.x < 0) {
- hDeltaJump = -hDeltaJump;
- }
- } else {
- hDeltaJump = 0;
- }
- if (layoutManager.canScrollVertically()) {
- vDeltaJump = estimateNextPositionDiffForFling(layoutManager,
- getVerticalHelper(layoutManager), 0, velocityY);
- if (vectorForEnd.y < 0) {
- vDeltaJump = -vDeltaJump;
- }
- } else {
- vDeltaJump = 0;
- }
-
- int deltaJump = layoutManager.canScrollVertically() ? vDeltaJump : hDeltaJump;
- if (deltaJump == 0) {
- return RecyclerView.NO_POSITION;
- }
-
- int targetPos = currentPosition + deltaJump;
- if (targetPos < 0) {
- targetPos = 0;
- }
- if (targetPos >= itemCount) {
- targetPos = itemCount - 1;
- }
- return targetPos;
- }
-
- @Override
- public View findSnapView(RecyclerView.LayoutManager layoutManager) {
- if (layoutManager.canScrollVertically()) {
- return findCenterView(layoutManager, getVerticalHelper(layoutManager));
- } else if (layoutManager.canScrollHorizontally()) {
- return findCenterView(layoutManager, getHorizontalHelper(layoutManager));
- }
- return null;
- }
-
- private int distanceToCenter(@NonNull View targetView, OrientationHelper helper) {
- final int childCenter = helper.getDecoratedStart(targetView)
- + (helper.getDecoratedMeasurement(targetView) / 2);
- final int containerCenter = helper.getStartAfterPadding() + helper.getTotalSpace() / 2;
- return childCenter - containerCenter;
- }
-
- /**
- * Estimates a position to which SnapHelper will try to scroll to in response to a fling.
- *
- * @param layoutManager The {@link RecyclerView.LayoutManager} associated with the attached
- * {@link RecyclerView}.
- * @param helper The {@link OrientationHelper} that is created from the LayoutManager.
- * @param velocityX The velocity on the x axis.
- * @param velocityY The velocity on the y axis.
- *
- * @return The diff between the target scroll position and the current position.
- */
- private int estimateNextPositionDiffForFling(RecyclerView.LayoutManager layoutManager,
- OrientationHelper helper, int velocityX, int velocityY) {
- int[] distances = calculateScrollDistance(velocityX, velocityY);
- float distancePerChild = computeDistancePerChild(layoutManager, helper);
- if (distancePerChild <= 0) {
- return 0;
- }
- int distance =
- Math.abs(distances[0]) > Math.abs(distances[1]) ? distances[0] : distances[1];
- return (int) Math.round(distance / distancePerChild);
- }
-
- /**
- * Return the child view that is currently closest to the center of this parent.
- *
- * @param layoutManager The {@link RecyclerView.LayoutManager} associated with the attached
- * {@link RecyclerView}.
- * @param helper The relevant {@link OrientationHelper} for the attached {@link RecyclerView}.
- *
- * @return the child view that is currently closest to the center of this parent.
- */
- @Nullable
- private View findCenterView(RecyclerView.LayoutManager layoutManager,
- OrientationHelper helper) {
- int childCount = layoutManager.getChildCount();
- if (childCount == 0) {
- return null;
- }
-
- View closestChild = null;
- final int center = helper.getStartAfterPadding() + helper.getTotalSpace() / 2;
- int absClosest = Integer.MAX_VALUE;
-
- for (int i = 0; i < childCount; i++) {
- final View child = layoutManager.getChildAt(i);
- int childCenter = helper.getDecoratedStart(child)
- + (helper.getDecoratedMeasurement(child) / 2);
- int absDistance = Math.abs(childCenter - center);
-
- /** if child center is closer than previous closest, set it as closest **/
- if (absDistance < absClosest) {
- absClosest = absDistance;
- closestChild = child;
- }
- }
- return closestChild;
- }
-
- /**
- * Computes an average pixel value to pass a single child.
- *
- * Returns a negative value if it cannot be calculated.
- *
- * @param layoutManager The {@link RecyclerView.LayoutManager} associated with the attached
- * {@link RecyclerView}.
- * @param helper The relevant {@link OrientationHelper} for the attached
- * {@link RecyclerView.LayoutManager}.
- *
- * @return A float value that is the average number of pixels needed to scroll by one view in
- * the relevant direction.
- */
- private float computeDistancePerChild(RecyclerView.LayoutManager layoutManager,
- OrientationHelper helper) {
- View minPosView = null;
- View maxPosView = null;
- int minPos = Integer.MAX_VALUE;
- int maxPos = Integer.MIN_VALUE;
- int childCount = layoutManager.getChildCount();
- if (childCount == 0) {
- return INVALID_DISTANCE;
- }
-
- for (int i = 0; i < childCount; i++) {
- View child = layoutManager.getChildAt(i);
- final int pos = layoutManager.getPosition(child);
- if (pos == RecyclerView.NO_POSITION) {
- continue;
- }
- if (pos < minPos) {
- minPos = pos;
- minPosView = child;
- }
- if (pos > maxPos) {
- maxPos = pos;
- maxPosView = child;
- }
- }
- if (minPosView == null || maxPosView == null) {
- return INVALID_DISTANCE;
- }
- int start = Math.min(helper.getDecoratedStart(minPosView),
- helper.getDecoratedStart(maxPosView));
- int end = Math.max(helper.getDecoratedEnd(minPosView),
- helper.getDecoratedEnd(maxPosView));
- int distance = end - start;
- if (distance == 0) {
- return INVALID_DISTANCE;
- }
- return 1f * distance / ((maxPos - minPos) + 1);
- }
-
- @NonNull
- private OrientationHelper getVerticalHelper(@NonNull RecyclerView.LayoutManager layoutManager) {
- if (mVerticalHelper == null || mVerticalHelper.mLayoutManager != layoutManager) {
- mVerticalHelper = OrientationHelper.createVerticalHelper(layoutManager);
- }
- return mVerticalHelper;
- }
-
- @NonNull
- private OrientationHelper getHorizontalHelper(
- @NonNull RecyclerView.LayoutManager layoutManager) {
- if (mHorizontalHelper == null || mHorizontalHelper.mLayoutManager != layoutManager) {
- mHorizontalHelper = OrientationHelper.createHorizontalHelper(layoutManager);
- }
- return mHorizontalHelper;
- }
-}
diff --git a/app/src/main/java/androidx/recyclerview/widget/ListAdapter.java b/app/src/main/java/androidx/recyclerview/widget/ListAdapter.java
deleted file mode 100644
index 6b1ad73c13..0000000000
--- a/app/src/main/java/androidx/recyclerview/widget/ListAdapter.java
+++ /dev/null
@@ -1,190 +0,0 @@
-/*
- * Copyright 2018 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package androidx.recyclerview.widget;
-
-import androidx.annotation.NonNull;
-import androidx.annotation.Nullable;
-
-import java.util.List;
-
-/**
- * {@link RecyclerView.Adapter RecyclerView.Adapter} base class for presenting List data in a
- * {@link RecyclerView}, including computing diffs between Lists on a background thread.
- *
- * This class is a convenience wrapper around {@link AsyncListDiffer} that implements Adapter common
- * default behavior for item access and counting.
- *
- * While using a LiveData<List> is an easy way to provide data to the adapter, it isn't required
- * - you can use {@link #submitList(List)} when new lists are available.
- *
- * A complete usage pattern with Room would look like this:
- *
- * {@literal @}Dao
- * interface UserDao {
- * {@literal @}Query("SELECT * FROM user ORDER BY lastName ASC")
- * public abstract LiveData<List<User>> usersByLastName();
- * }
- *
- * class MyViewModel extends ViewModel {
- * public final LiveData<List<User>> usersList;
- * public MyViewModel(UserDao userDao) {
- * usersList = userDao.usersByLastName();
- * }
- * }
- *
- * class MyActivity extends AppCompatActivity {
- * {@literal @}Override
- * public void onCreate(Bundle savedState) {
- * super.onCreate(savedState);
- * MyViewModel viewModel = new ViewModelProvider(this).get(MyViewModel.class);
- * RecyclerView recyclerView = findViewById(R.id.user_list);
- * UserAdapter<User> adapter = new UserAdapter();
- * viewModel.usersList.observe(this, list -> adapter.submitList(list));
- * recyclerView.setAdapter(adapter);
- * }
- * }
- *
- * class UserAdapter extends ListAdapter<User, UserViewHolder> {
- * public UserAdapter() {
- * super(User.DIFF_CALLBACK);
- * }
- * {@literal @}Override
- * public void onBindViewHolder(UserViewHolder holder, int position) {
- * holder.bindTo(getItem(position));
- * }
- * public static final DiffUtil.ItemCallback<User> DIFF_CALLBACK =
- * new DiffUtil.ItemCallback<User>() {
- * {@literal @}Override
- * public boolean areItemsTheSame(
- * {@literal @}NonNull User oldUser, {@literal @}NonNull User newUser) {
- * // User properties may have changed if reloaded from the DB, but ID is fixed
- * return oldUser.getId() == newUser.getId();
- * }
- * {@literal @}Override
- * public boolean areContentsTheSame(
- * {@literal @}NonNull User oldUser, {@literal @}NonNull User newUser) {
- * // NOTE: if you use equals, your object must properly override Object#equals()
- * // Incorrectly returning false here will result in too many animations.
- * return oldUser.equals(newUser);
- * }
- * }
- * }
- *
- * Advanced users that wish for more control over adapter behavior, or to provide a specific base
- * class should refer to {@link AsyncListDiffer}, which provides custom mapping from diff events
- * to adapter positions.
- *
- * @param Type of the Lists this Adapter will receive.
- * @param A class that extends ViewHolder that will be used by the adapter.
- */
-public abstract class ListAdapter
- extends RecyclerView.Adapter {
- final AsyncListDiffer mDiffer;
- private final AsyncListDiffer.ListListener mListener =
- new AsyncListDiffer.ListListener() {
- @Override
- public void onCurrentListChanged(
- @NonNull List previousList, @NonNull List currentList) {
- ListAdapter.this.onCurrentListChanged(previousList, currentList);
- }
- };
-
- @SuppressWarnings("unused")
- protected ListAdapter(@NonNull DiffUtil.ItemCallback diffCallback) {
- mDiffer = new AsyncListDiffer<>(new AdapterListUpdateCallback(this),
- new AsyncDifferConfig.Builder<>(diffCallback).build());
- mDiffer.addListListener(mListener);
- }
-
- @SuppressWarnings("unused")
- protected ListAdapter(@NonNull AsyncDifferConfig config) {
- mDiffer = new AsyncListDiffer<>(new AdapterListUpdateCallback(this), config);
- mDiffer.addListListener(mListener);
- }
-
- /**
- * Submits a new list to be diffed, and displayed.
- *
- * If a list is already being displayed, a diff will be computed on a background thread, which
- * will dispatch Adapter.notifyItem events on the main thread.
- *
- * @param list The new list to be displayed.
- */
- public void submitList(@Nullable List list) {
- mDiffer.submitList(list);
- }
-
- /**
- * Set the new list to be displayed.
- *
- * If a List is already being displayed, a diff will be computed on a background thread, which
- * will dispatch Adapter.notifyItem events on the main thread.
- *
- * The commit callback can be used to know when the List is committed, but note that it
- * may not be executed. If List B is submitted immediately after List A, and is
- * committed directly, the callback associated with List A will not be run.
- *
- * @param list The new list to be displayed.
- * @param commitCallback Optional runnable that is executed when the List is committed, if
- * it is committed.
- */
- public void submitList(@Nullable List list, @Nullable final Runnable commitCallback) {
- mDiffer.submitList(list, commitCallback);
- }
-
- protected T getItem(int position) {
- return mDiffer.getCurrentList().get(position);
- }
-
- @Override
- public int getItemCount() {
- return mDiffer.getCurrentList().size();
- }
-
- /**
- * Get the current List - any diffing to present this list has already been computed and
- * dispatched via the ListUpdateCallback.
- *
- * If a null List, or no List has been submitted, an empty list will be returned.
- *
- * The returned list may not be mutated - mutations to content must be done through
- * {@link #submitList(List)}.
- *
- * @return The list currently being displayed.
- *
- * @see #onCurrentListChanged(List, List)
- */
- @NonNull
- public List getCurrentList() {
- return mDiffer.getCurrentList();
- }
-
- /**
- * Called when the current List is updated.
- *
- * If a null List is passed to {@link #submitList(List)}, or no List has been
- * submitted, the current List is represented as an empty List.
- *
- * @param previousList List that was displayed previously.
- * @param currentList new List being displayed, will be empty if {@code null} was passed to
- * {@link #submitList(List)}.
- *
- * @see #getCurrentList()
- */
- public void onCurrentListChanged(@NonNull List previousList, @NonNull List currentList) {
- }
-}
diff --git a/app/src/main/java/androidx/recyclerview/widget/ListUpdateCallback.java b/app/src/main/java/androidx/recyclerview/widget/ListUpdateCallback.java
deleted file mode 100644
index ed8e7fc676..0000000000
--- a/app/src/main/java/androidx/recyclerview/widget/ListUpdateCallback.java
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
- * Copyright 2018 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package androidx.recyclerview.widget;
-
-import androidx.annotation.Nullable;
-
-/**
- * An interface that can receive Update operations that are applied to a list.
- *
- * This class can be used together with DiffUtil to detect changes between two lists.
- */
-public interface ListUpdateCallback {
- /**
- * Called when {@code count} number of items are inserted at the given position.
- *
- * @param position The position of the new item.
- * @param count The number of items that have been added.
- */
- void onInserted(int position, int count);
-
- /**
- * Called when {@code count} number of items are removed from the given position.
- *
- * @param position The position of the item which has been removed.
- * @param count The number of items which have been removed.
- */
- void onRemoved(int position, int count);
-
- /**
- * Called when an item changes its position in the list.
- *
- * @param fromPosition The previous position of the item before the move.
- * @param toPosition The new position of the item.
- */
- void onMoved(int fromPosition, int toPosition);
-
- /**
- * Called when {@code count} number of items are updated at the given position.
- *
- * @param position The position of the item which has been updated.
- * @param count The number of items which has changed.
- */
- void onChanged(int position, int count, @Nullable Object payload);
-}
diff --git a/app/src/main/java/androidx/recyclerview/widget/MessageThreadUtil.java b/app/src/main/java/androidx/recyclerview/widget/MessageThreadUtil.java
deleted file mode 100644
index 4286cd639c..0000000000
--- a/app/src/main/java/androidx/recyclerview/widget/MessageThreadUtil.java
+++ /dev/null
@@ -1,294 +0,0 @@
-/*
- * Copyright 2018 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package androidx.recyclerview.widget;
-
-import android.os.Handler;
-import android.os.Looper;
-import android.util.Log;
-
-import java.util.concurrent.Executor;
-import java.util.concurrent.atomic.AtomicBoolean;
-
-class MessageThreadUtil implements ThreadUtil {
-
- @Override
- public MainThreadCallback getMainThreadProxy(final MainThreadCallback callback) {
- return new MainThreadCallback() {
- final MessageQueue mQueue = new MessageQueue();
- final private Handler mMainThreadHandler = new Handler(Looper.getMainLooper());
-
- static final int UPDATE_ITEM_COUNT = 1;
- static final int ADD_TILE = 2;
- static final int REMOVE_TILE = 3;
-
- @Override
- public void updateItemCount(int generation, int itemCount) {
- sendMessage(SyncQueueItem.obtainMessage(UPDATE_ITEM_COUNT, generation, itemCount));
- }
-
- @Override
- public void addTile(int generation, TileList.Tile tile) {
- sendMessage(SyncQueueItem.obtainMessage(ADD_TILE, generation, tile));
- }
-
- @Override
- public void removeTile(int generation, int position) {
- sendMessage(SyncQueueItem.obtainMessage(REMOVE_TILE, generation, position));
- }
-
- private void sendMessage(SyncQueueItem msg) {
- mQueue.sendMessage(msg);
- mMainThreadHandler.post(mMainThreadRunnable);
- }
-
- private Runnable mMainThreadRunnable = new Runnable() {
- @Override
- public void run() {
- SyncQueueItem msg = mQueue.next();
- while (msg != null) {
- switch (msg.what) {
- case UPDATE_ITEM_COUNT:
- callback.updateItemCount(msg.arg1, msg.arg2);
- break;
- case ADD_TILE:
- @SuppressWarnings("unchecked")
- TileList.Tile tile = (TileList.Tile) msg.data;
- callback.addTile(msg.arg1, tile);
- break;
- case REMOVE_TILE:
- callback.removeTile(msg.arg1, msg.arg2);
- break;
- default:
- Log.e("ThreadUtil", "Unsupported message, what=" + msg.what);
- }
- msg = mQueue.next();
- }
- }
- };
- };
- }
-
- @SuppressWarnings("deprecation") /* AsyncTask */
- @Override
- public BackgroundCallback getBackgroundProxy(final BackgroundCallback callback) {
- return new BackgroundCallback() {
- final MessageQueue mQueue = new MessageQueue();
- private final Executor mExecutor = android.os.AsyncTask.THREAD_POOL_EXECUTOR;
- AtomicBoolean mBackgroundRunning = new AtomicBoolean(false);
-
- static final int REFRESH = 1;
- static final int UPDATE_RANGE = 2;
- static final int LOAD_TILE = 3;
- static final int RECYCLE_TILE = 4;
-
- @Override
- public void refresh(int generation) {
- sendMessageAtFrontOfQueue(SyncQueueItem.obtainMessage(REFRESH, generation, null));
- }
-
- @Override
- public void updateRange(int rangeStart, int rangeEnd,
- int extRangeStart, int extRangeEnd, int scrollHint) {
- sendMessageAtFrontOfQueue(SyncQueueItem.obtainMessage(UPDATE_RANGE,
- rangeStart, rangeEnd, extRangeStart, extRangeEnd, scrollHint, null));
- }
-
- @Override
- public void loadTile(int position, int scrollHint) {
- sendMessage(SyncQueueItem.obtainMessage(LOAD_TILE, position, scrollHint));
- }
-
- @Override
- public void recycleTile(TileList.Tile tile) {
- sendMessage(SyncQueueItem.obtainMessage(RECYCLE_TILE, 0, tile));
- }
-
- private void sendMessage(SyncQueueItem msg) {
- mQueue.sendMessage(msg);
- maybeExecuteBackgroundRunnable();
- }
-
- private void sendMessageAtFrontOfQueue(SyncQueueItem msg) {
- mQueue.sendMessageAtFrontOfQueue(msg);
- maybeExecuteBackgroundRunnable();
- }
-
- private void maybeExecuteBackgroundRunnable() {
- if (mBackgroundRunning.compareAndSet(false, true)) {
- mExecutor.execute(mBackgroundRunnable);
- }
- }
-
- private Runnable mBackgroundRunnable = new Runnable() {
- @Override
- public void run() {
- while (true) {
- SyncQueueItem msg = mQueue.next();
- if (msg == null) {
- break;
- }
- switch (msg.what) {
- case REFRESH:
- mQueue.removeMessages(REFRESH);
- callback.refresh(msg.arg1);
- break;
- case UPDATE_RANGE:
- mQueue.removeMessages(UPDATE_RANGE);
- mQueue.removeMessages(LOAD_TILE);
- callback.updateRange(
- msg.arg1, msg.arg2, msg.arg3, msg.arg4, msg.arg5);
- break;
- case LOAD_TILE:
- callback.loadTile(msg.arg1, msg.arg2);
- break;
- case RECYCLE_TILE:
- @SuppressWarnings("unchecked")
- TileList.Tile tile = (TileList.Tile) msg.data;
- callback.recycleTile(tile);
- break;
- default:
- Log.e("ThreadUtil", "Unsupported message, what=" + msg.what);
- }
- }
- mBackgroundRunning.set(false);
- }
- };
- };
- }
-
- /**
- * Replica of android.os.Message. Unfortunately, cannot use it without a Handler and don't want
- * to create a thread just for this component.
- */
- static class SyncQueueItem {
-
- private static SyncQueueItem sPool;
- private static final Object sPoolLock = new Object();
- SyncQueueItem next;
- public int what;
- public int arg1;
- public int arg2;
- public int arg3;
- public int arg4;
- public int arg5;
- public Object data;
-
- void recycle() {
- next = null;
- what = arg1 = arg2 = arg3 = arg4 = arg5 = 0;
- data = null;
- synchronized (sPoolLock) {
- if (sPool != null) {
- next = sPool;
- }
- sPool = this;
- }
- }
-
- static SyncQueueItem obtainMessage(int what, int arg1, int arg2, int arg3, int arg4,
- int arg5, Object data) {
- synchronized (sPoolLock) {
- final SyncQueueItem item;
- if (sPool == null) {
- item = new SyncQueueItem();
- } else {
- item = sPool;
- sPool = sPool.next;
- item.next = null;
- }
- item.what = what;
- item.arg1 = arg1;
- item.arg2 = arg2;
- item.arg3 = arg3;
- item.arg4 = arg4;
- item.arg5 = arg5;
- item.data = data;
- return item;
- }
- }
-
- static SyncQueueItem obtainMessage(int what, int arg1, int arg2) {
- return obtainMessage(what, arg1, arg2, 0, 0, 0, null);
- }
-
- static SyncQueueItem obtainMessage(int what, int arg1, Object data) {
- return obtainMessage(what, arg1, 0, 0, 0, 0, data);
- }
- }
-
- static class MessageQueue {
-
- private SyncQueueItem mRoot;
- private final Object mLock = new Object();
-
- SyncQueueItem next() {
- synchronized (mLock) {
- if (mRoot == null) {
- return null;
- }
- final SyncQueueItem next = mRoot;
- mRoot = mRoot.next;
- return next;
- }
- }
-
- void sendMessageAtFrontOfQueue(SyncQueueItem item) {
- synchronized (mLock) {
- item.next = mRoot;
- mRoot = item;
- }
- }
-
- void sendMessage(SyncQueueItem item) {
- synchronized (mLock) {
- if (mRoot == null) {
- mRoot = item;
- return;
- }
- SyncQueueItem last = mRoot;
- while (last.next != null) {
- last = last.next;
- }
- last.next = item;
- }
- }
-
- void removeMessages(int what) {
- synchronized (mLock) {
- while (mRoot != null && mRoot.what == what) {
- SyncQueueItem item = mRoot;
- mRoot = mRoot.next;
- item.recycle();
- }
- if (mRoot != null) {
- SyncQueueItem prev = mRoot;
- SyncQueueItem item = prev.next;
- while (item != null) {
- SyncQueueItem next = item.next;
- if (item.what == what) {
- prev.next = next;
- item.recycle();
- } else {
- prev = item;
- }
- item = next;
- }
- }
- }
- }
- }
-}
diff --git a/app/src/main/java/androidx/recyclerview/widget/NestedAdapterWrapper.java b/app/src/main/java/androidx/recyclerview/widget/NestedAdapterWrapper.java
deleted file mode 100644
index a6b9a300e3..0000000000
--- a/app/src/main/java/androidx/recyclerview/widget/NestedAdapterWrapper.java
+++ /dev/null
@@ -1,201 +0,0 @@
-/*
- * Copyright 2020 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package androidx.recyclerview.widget;
-
-import static androidx.recyclerview.widget.RecyclerView.Adapter.StateRestorationPolicy.PREVENT_WHEN_EMPTY;
-
-import android.view.ViewGroup;
-
-import androidx.annotation.NonNull;
-import androidx.annotation.Nullable;
-import androidx.core.util.Preconditions;
-import androidx.recyclerview.widget.RecyclerView.Adapter;
-import androidx.recyclerview.widget.RecyclerView.ViewHolder;
-
-/**
- * Wrapper for each adapter in {@link ConcatAdapter}.
- */
-class NestedAdapterWrapper {
- @NonNull
- private final ViewTypeStorage.ViewTypeLookup mViewTypeLookup;
- @NonNull
- private final StableIdStorage.StableIdLookup mStableIdLookup;
- public final Adapter adapter;
- @SuppressWarnings("WeakerAccess")
- final Callback mCallback;
- // we cache this value so that we can know the previous size when change happens
- // this is also important as getting real size while an adapter is dispatching possibly a
- // a chain of events might create inconsistencies (as it happens in DiffUtil).
- // Instead, we always calculate this value based on notify events.
- @SuppressWarnings("WeakerAccess")
- int mCachedItemCount;
-
- private RecyclerView.AdapterDataObserver mAdapterObserver =
- new RecyclerView.AdapterDataObserver() {
- @Override
- public void onChanged() {
- mCachedItemCount = adapter.getItemCount();
- mCallback.onChanged(NestedAdapterWrapper.this);
- }
-
- @Override
- public void onItemRangeChanged(int positionStart, int itemCount) {
- mCallback.onItemRangeChanged(
- NestedAdapterWrapper.this,
- positionStart,
- itemCount,
- null
- );
- }
-
- @Override
- public void onItemRangeChanged(int positionStart, int itemCount,
- @Nullable Object payload) {
- mCallback.onItemRangeChanged(
- NestedAdapterWrapper.this,
- positionStart,
- itemCount,
- payload
- );
- }
-
- @Override
- public void onItemRangeInserted(int positionStart, int itemCount) {
- mCachedItemCount += itemCount;
- mCallback.onItemRangeInserted(
- NestedAdapterWrapper.this,
- positionStart,
- itemCount);
- if (mCachedItemCount > 0
- && adapter.getStateRestorationPolicy() == PREVENT_WHEN_EMPTY) {
- mCallback.onStateRestorationPolicyChanged(NestedAdapterWrapper.this);
- }
- }
-
- @Override
- public void onItemRangeRemoved(int positionStart, int itemCount) {
- mCachedItemCount -= itemCount;
- mCallback.onItemRangeRemoved(
- NestedAdapterWrapper.this,
- positionStart,
- itemCount
- );
- if (mCachedItemCount < 1
- && adapter.getStateRestorationPolicy() == PREVENT_WHEN_EMPTY) {
- mCallback.onStateRestorationPolicyChanged(NestedAdapterWrapper.this);
- }
- }
-
- @Override
- public void onItemRangeMoved(int fromPosition, int toPosition, int itemCount) {
- Preconditions.checkArgument(itemCount == 1,
- "moving more than 1 item is not supported in RecyclerView");
- mCallback.onItemRangeMoved(
- NestedAdapterWrapper.this,
- fromPosition,
- toPosition
- );
- }
-
- @Override
- public void onStateRestorationPolicyChanged() {
- mCallback.onStateRestorationPolicyChanged(
- NestedAdapterWrapper.this
- );
- }
- };
-
- NestedAdapterWrapper(
- Adapter adapter,
- final Callback callback,
- ViewTypeStorage viewTypeStorage,
- StableIdStorage.StableIdLookup stableIdLookup) {
- this.adapter = adapter;
- mCallback = callback;
- mViewTypeLookup = viewTypeStorage.createViewTypeWrapper(this);
- mStableIdLookup = stableIdLookup;
- mCachedItemCount = this.adapter.getItemCount();
- this.adapter.registerAdapterDataObserver(mAdapterObserver);
- }
-
-
- void dispose() {
- adapter.unregisterAdapterDataObserver(mAdapterObserver);
- mViewTypeLookup.dispose();
- }
-
- int getCachedItemCount() {
- return mCachedItemCount;
- }
-
- int getItemViewType(int localPosition) {
- return mViewTypeLookup.localToGlobal(adapter.getItemViewType(localPosition));
- }
-
- ViewHolder onCreateViewHolder(
- ViewGroup parent,
- int globalViewType) {
- int localType = mViewTypeLookup.globalToLocal(globalViewType);
- return adapter.onCreateViewHolder(parent, localType);
- }
-
- void onBindViewHolder(ViewHolder viewHolder, int localPosition) {
- adapter.bindViewHolder(viewHolder, localPosition);
- }
-
- public long getItemId(int localPosition) {
- long localItemId = adapter.getItemId(localPosition);
- return mStableIdLookup.localToGlobal(localItemId);
- }
-
- interface Callback {
- void onChanged(@NonNull NestedAdapterWrapper wrapper);
-
- void onItemRangeChanged(
- @NonNull NestedAdapterWrapper nestedAdapterWrapper,
- int positionStart,
- int itemCount
- );
-
- void onItemRangeChanged(
- @NonNull NestedAdapterWrapper nestedAdapterWrapper,
- int positionStart,
- int itemCount,
- @Nullable Object payload
- );
-
- void onItemRangeInserted(
- @NonNull NestedAdapterWrapper nestedAdapterWrapper,
- int positionStart,
- int itemCount);
-
- void onItemRangeRemoved(
- @NonNull NestedAdapterWrapper nestedAdapterWrapper,
- int positionStart,
- int itemCount
- );
-
- void onItemRangeMoved(
- @NonNull NestedAdapterWrapper nestedAdapterWrapper,
- int fromPosition,
- int toPosition
- );
-
- void onStateRestorationPolicyChanged(NestedAdapterWrapper nestedAdapterWrapper);
- }
-
-}
diff --git a/app/src/main/java/androidx/recyclerview/widget/OpReorderer.java b/app/src/main/java/androidx/recyclerview/widget/OpReorderer.java
deleted file mode 100644
index 722960c82e..0000000000
--- a/app/src/main/java/androidx/recyclerview/widget/OpReorderer.java
+++ /dev/null
@@ -1,233 +0,0 @@
-/*
- * Copyright 2018 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package androidx.recyclerview.widget;
-
-import java.util.List;
-
-class OpReorderer {
-
- final Callback mCallback;
-
- OpReorderer(Callback callback) {
- mCallback = callback;
- }
-
- void reorderOps(List ops) {
- // since move operations breaks continuity, their effects on ADD/RM are hard to handle.
- // we push them to the end of the list so that they can be handled easily.
- int badMove;
- while ((badMove = getLastMoveOutOfOrder(ops)) != -1) {
- swapMoveOp(ops, badMove, badMove + 1);
- }
- }
-
- private void swapMoveOp(List list, int badMove, int next) {
- final AdapterHelper.UpdateOp moveOp = list.get(badMove);
- final AdapterHelper.UpdateOp nextOp = list.get(next);
- switch (nextOp.cmd) {
- case AdapterHelper.UpdateOp.REMOVE:
- swapMoveRemove(list, badMove, moveOp, next, nextOp);
- break;
- case AdapterHelper.UpdateOp.ADD:
- swapMoveAdd(list, badMove, moveOp, next, nextOp);
- break;
- case AdapterHelper.UpdateOp.UPDATE:
- swapMoveUpdate(list, badMove, moveOp, next, nextOp);
- break;
- }
- }
-
- void swapMoveRemove(List list, int movePos, AdapterHelper.UpdateOp moveOp,
- int removePos, AdapterHelper.UpdateOp removeOp) {
- AdapterHelper.UpdateOp extraRm = null;
- // check if move is nulled out by remove
- boolean revertedMove = false;
- final boolean moveIsBackwards;
-
- if (moveOp.positionStart < moveOp.itemCount) {
- moveIsBackwards = false;
- if (removeOp.positionStart == moveOp.positionStart
- && removeOp.itemCount == moveOp.itemCount - moveOp.positionStart) {
- revertedMove = true;
- }
- } else {
- moveIsBackwards = true;
- if (removeOp.positionStart == moveOp.itemCount + 1
- && removeOp.itemCount == moveOp.positionStart - moveOp.itemCount) {
- revertedMove = true;
- }
- }
-
- // going in reverse, first revert the effect of add
- if (moveOp.itemCount < removeOp.positionStart) {
- removeOp.positionStart--;
- } else if (moveOp.itemCount < removeOp.positionStart + removeOp.itemCount) {
- // move is removed.
- removeOp.itemCount--;
- moveOp.cmd = AdapterHelper.UpdateOp.REMOVE;
- moveOp.itemCount = 1;
- if (removeOp.itemCount == 0) {
- list.remove(removePos);
- mCallback.recycleUpdateOp(removeOp);
- }
- // no need to swap, it is already a remove
- return;
- }
-
- // now affect of add is consumed. now apply effect of first remove
- if (moveOp.positionStart <= removeOp.positionStart) {
- removeOp.positionStart++;
- } else if (moveOp.positionStart < removeOp.positionStart + removeOp.itemCount) {
- final int remaining = removeOp.positionStart + removeOp.itemCount
- - moveOp.positionStart;
- extraRm = mCallback.obtainUpdateOp(AdapterHelper.UpdateOp.REMOVE, moveOp.positionStart + 1, remaining, null);
- removeOp.itemCount = moveOp.positionStart - removeOp.positionStart;
- }
-
- // if effects of move is reverted by remove, we are done.
- if (revertedMove) {
- list.set(movePos, removeOp);
- list.remove(removePos);
- mCallback.recycleUpdateOp(moveOp);
- return;
- }
-
- // now find out the new locations for move actions
- if (moveIsBackwards) {
- if (extraRm != null) {
- if (moveOp.positionStart > extraRm.positionStart) {
- moveOp.positionStart -= extraRm.itemCount;
- }
- if (moveOp.itemCount > extraRm.positionStart) {
- moveOp.itemCount -= extraRm.itemCount;
- }
- }
- if (moveOp.positionStart > removeOp.positionStart) {
- moveOp.positionStart -= removeOp.itemCount;
- }
- if (moveOp.itemCount > removeOp.positionStart) {
- moveOp.itemCount -= removeOp.itemCount;
- }
- } else {
- if (extraRm != null) {
- if (moveOp.positionStart >= extraRm.positionStart) {
- moveOp.positionStart -= extraRm.itemCount;
- }
- if (moveOp.itemCount >= extraRm.positionStart) {
- moveOp.itemCount -= extraRm.itemCount;
- }
- }
- if (moveOp.positionStart >= removeOp.positionStart) {
- moveOp.positionStart -= removeOp.itemCount;
- }
- if (moveOp.itemCount >= removeOp.positionStart) {
- moveOp.itemCount -= removeOp.itemCount;
- }
- }
-
- list.set(movePos, removeOp);
- if (moveOp.positionStart != moveOp.itemCount) {
- list.set(removePos, moveOp);
- } else {
- list.remove(removePos);
- }
- if (extraRm != null) {
- list.add(movePos, extraRm);
- }
- }
-
- private void swapMoveAdd(List list, int move, AdapterHelper.UpdateOp moveOp, int add,
- AdapterHelper.UpdateOp addOp) {
- int offset = 0;
- // going in reverse, first revert the effect of add
- if (moveOp.itemCount < addOp.positionStart) {
- offset--;
- }
- if (moveOp.positionStart < addOp.positionStart) {
- offset++;
- }
- if (addOp.positionStart <= moveOp.positionStart) {
- moveOp.positionStart += addOp.itemCount;
- }
- if (addOp.positionStart <= moveOp.itemCount) {
- moveOp.itemCount += addOp.itemCount;
- }
- addOp.positionStart += offset;
- list.set(move, addOp);
- list.set(add, moveOp);
- }
-
- void swapMoveUpdate(List list, int move, AdapterHelper.UpdateOp moveOp, int update,
- AdapterHelper.UpdateOp updateOp) {
- AdapterHelper.UpdateOp extraUp1 = null;
- AdapterHelper.UpdateOp extraUp2 = null;
- // going in reverse, first revert the effect of add
- if (moveOp.itemCount < updateOp.positionStart) {
- updateOp.positionStart--;
- } else if (moveOp.itemCount < updateOp.positionStart + updateOp.itemCount) {
- // moved item is updated. add an update for it
- updateOp.itemCount--;
- extraUp1 = mCallback.obtainUpdateOp(AdapterHelper.UpdateOp.UPDATE, moveOp.positionStart, 1, updateOp.payload);
- }
- // now affect of add is consumed. now apply effect of first remove
- if (moveOp.positionStart <= updateOp.positionStart) {
- updateOp.positionStart++;
- } else if (moveOp.positionStart < updateOp.positionStart + updateOp.itemCount) {
- final int remaining = updateOp.positionStart + updateOp.itemCount
- - moveOp.positionStart;
- extraUp2 = mCallback.obtainUpdateOp(
- AdapterHelper.UpdateOp.UPDATE, moveOp.positionStart + 1, remaining,
- updateOp.payload);
- updateOp.itemCount -= remaining;
- }
- list.set(update, moveOp);
- if (updateOp.itemCount > 0) {
- list.set(move, updateOp);
- } else {
- list.remove(move);
- mCallback.recycleUpdateOp(updateOp);
- }
- if (extraUp1 != null) {
- list.add(move, extraUp1);
- }
- if (extraUp2 != null) {
- list.add(move, extraUp2);
- }
- }
-
- private int getLastMoveOutOfOrder(List list) {
- boolean foundNonMove = false;
- for (int i = list.size() - 1; i >= 0; i--) {
- final AdapterHelper.UpdateOp op1 = list.get(i);
- if (op1.cmd == AdapterHelper.UpdateOp.MOVE) {
- if (foundNonMove) {
- return i;
- }
- } else {
- foundNonMove = true;
- }
- }
- return -1;
- }
-
- interface Callback {
-
- AdapterHelper.UpdateOp obtainUpdateOp(int cmd, int startPosition, int itemCount, Object payload);
-
- void recycleUpdateOp(AdapterHelper.UpdateOp op);
- }
-}
diff --git a/app/src/main/java/androidx/recyclerview/widget/OrientationHelper.java b/app/src/main/java/androidx/recyclerview/widget/OrientationHelper.java
deleted file mode 100644
index f94e0dd162..0000000000
--- a/app/src/main/java/androidx/recyclerview/widget/OrientationHelper.java
+++ /dev/null
@@ -1,446 +0,0 @@
-/*
- * Copyright 2018 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package androidx.recyclerview.widget;
-
-import android.graphics.Rect;
-import android.view.View;
-
-/**
- * Helper class for LayoutManagers to abstract measurements depending on the View's orientation.
- *
- * It is developed to easily support vertical and horizontal orientations in a LayoutManager but
- * can also be used to abstract calls around view bounds and child measurements with margins and
- * decorations.
- *
- * @see #createHorizontalHelper(RecyclerView.LayoutManager)
- * @see #createVerticalHelper(RecyclerView.LayoutManager)
- */
-public abstract class OrientationHelper {
-
- private static final int INVALID_SIZE = Integer.MIN_VALUE;
-
- protected final RecyclerView.LayoutManager mLayoutManager;
-
- public static final int HORIZONTAL = RecyclerView.HORIZONTAL;
-
- public static final int VERTICAL = RecyclerView.VERTICAL;
-
- private int mLastTotalSpace = INVALID_SIZE;
-
- final Rect mTmpRect = new Rect();
-
- private OrientationHelper(RecyclerView.LayoutManager layoutManager) {
- mLayoutManager = layoutManager;
- }
-
- /**
- * Returns the {@link RecyclerView.LayoutManager LayoutManager} that
- * is associated with this OrientationHelper.
- */
- public RecyclerView.LayoutManager getLayoutManager() {
- return mLayoutManager;
- }
-
- /**
- * Call this method after onLayout method is complete if state is NOT pre-layout.
- * This method records information like layout bounds that might be useful in the next layout
- * calculations.
- */
- public void onLayoutComplete() {
- mLastTotalSpace = getTotalSpace();
- }
-
- /**
- * Returns the layout space change between the previous layout pass and current layout pass.
- *
- * Make sure you call {@link #onLayoutComplete()} at the end of your LayoutManager's
- * {@link RecyclerView.LayoutManager#onLayoutChildren(RecyclerView.Recycler,
- * RecyclerView.State)} method.
- *
- * @return The difference between the current total space and previous layout's total space.
- * @see #onLayoutComplete()
- */
- public int getTotalSpaceChange() {
- return INVALID_SIZE == mLastTotalSpace ? 0 : getTotalSpace() - mLastTotalSpace;
- }
-
- /**
- * Returns the start of the view including its decoration and margin.
- *
- * For example, for the horizontal helper, if a View's left is at pixel 20, has 2px left
- * decoration and 3px left margin, returned value will be 15px.
- *
- * @param view The view element to check
- * @return The first pixel of the element
- * @see #getDecoratedEnd(android.view.View)
- */
- public abstract int getDecoratedStart(View view);
-
- /**
- * Returns the end of the view including its decoration and margin.
- *
- * For example, for the horizontal helper, if a View's right is at pixel 200, has 2px right
- * decoration and 3px right margin, returned value will be 205.
- *
- * @param view The view element to check
- * @return The last pixel of the element
- * @see #getDecoratedStart(android.view.View)
- */
- public abstract int getDecoratedEnd(View view);
-
- /**
- * Returns the end of the View after its matrix transformations are applied to its layout
- * position.
- *
- * This method is useful when trying to detect the visible edge of a View.
- *
- * It includes the decorations but does not include the margins.
- *
- * @param view The view whose transformed end will be returned
- * @return The end of the View after its decor insets and transformation matrix is applied to
- * its position
- *
- * @see RecyclerView.LayoutManager#getTransformedBoundingBox(View, boolean, Rect)
- */
- public abstract int getTransformedEndWithDecoration(View view);
-
- /**
- * Returns the start of the View after its matrix transformations are applied to its layout
- * position.
- *
- * This method is useful when trying to detect the visible edge of a View.
- *
- * It includes the decorations but does not include the margins.
- *
- * @param view The view whose transformed start will be returned
- * @return The start of the View after its decor insets and transformation matrix is applied to
- * its position
- *
- * @see RecyclerView.LayoutManager#getTransformedBoundingBox(View, boolean, Rect)
- */
- public abstract int getTransformedStartWithDecoration(View view);
-
- /**
- * Returns the space occupied by this View in the current orientation including decorations and
- * margins.
- *
- * @param view The view element to check
- * @return Total space occupied by this view
- * @see #getDecoratedMeasurementInOther(View)
- */
- public abstract int getDecoratedMeasurement(View view);
-
- /**
- * Returns the space occupied by this View in the perpendicular orientation including
- * decorations and margins.
- *
- * @param view The view element to check
- * @return Total space occupied by this view in the perpendicular orientation to current one
- * @see #getDecoratedMeasurement(View)
- */
- public abstract int getDecoratedMeasurementInOther(View view);
-
- /**
- * Returns the start position of the layout after the start padding is added.
- *
- * @return The very first pixel we can draw.
- */
- public abstract int getStartAfterPadding();
-
- /**
- * Returns the end position of the layout after the end padding is removed.
- *
- * @return The end boundary for this layout.
- */
- public abstract int getEndAfterPadding();
-
- /**
- * Returns the end position of the layout without taking padding into account.
- *
- * @return The end boundary for this layout without considering padding.
- */
- public abstract int getEnd();
-
- /**
- * Offsets all children's positions by the given amount.
- *
- * @param amount Value to add to each child's layout parameters
- */
- public abstract void offsetChildren(int amount);
-
- /**
- * Returns the total space to layout. This number is the difference between
- * {@link #getEndAfterPadding()} and {@link #getStartAfterPadding()}.
- *
- * @return Total space to layout children
- */
- public abstract int getTotalSpace();
-
- /**
- * Offsets the child in this orientation.
- *
- * @param view View to offset
- * @param offset offset amount
- */
- public abstract void offsetChild(View view, int offset);
-
- /**
- * Returns the padding at the end of the layout. For horizontal helper, this is the right
- * padding and for vertical helper, this is the bottom padding. This method does not check
- * whether the layout is RTL or not.
- *
- * @return The padding at the end of the layout.
- */
- public abstract int getEndPadding();
-
- /**
- * Returns the MeasureSpec mode for the current orientation from the LayoutManager.
- *
- * @return The current measure spec mode.
- *
- * @see View.MeasureSpec
- * @see RecyclerView.LayoutManager#getWidthMode()
- * @see RecyclerView.LayoutManager#getHeightMode()
- */
- public abstract int getMode();
-
- /**
- * Returns the MeasureSpec mode for the perpendicular orientation from the LayoutManager.
- *
- * @return The current measure spec mode.
- *
- * @see View.MeasureSpec
- * @see RecyclerView.LayoutManager#getWidthMode()
- * @see RecyclerView.LayoutManager#getHeightMode()
- */
- public abstract int getModeInOther();
-
- /**
- * Creates an OrientationHelper for the given LayoutManager and orientation.
- *
- * @param layoutManager LayoutManager to attach to
- * @param orientation Desired orientation. Should be {@link #HORIZONTAL} or {@link #VERTICAL}
- * @return A new OrientationHelper
- */
- public static OrientationHelper createOrientationHelper(
- RecyclerView.LayoutManager layoutManager, @RecyclerView.Orientation int orientation) {
- switch (orientation) {
- case HORIZONTAL:
- return createHorizontalHelper(layoutManager);
- case VERTICAL:
- return createVerticalHelper(layoutManager);
- }
- throw new IllegalArgumentException("invalid orientation");
- }
-
- /**
- * Creates a horizontal OrientationHelper for the given LayoutManager.
- *
- * @param layoutManager The LayoutManager to attach to.
- * @return A new OrientationHelper
- */
- public static OrientationHelper createHorizontalHelper(
- RecyclerView.LayoutManager layoutManager) {
- return new OrientationHelper(layoutManager) {
- @Override
- public int getEndAfterPadding() {
- return mLayoutManager.getWidth() - mLayoutManager.getPaddingRight();
- }
-
- @Override
- public int getEnd() {
- return mLayoutManager.getWidth();
- }
-
- @Override
- public void offsetChildren(int amount) {
- mLayoutManager.offsetChildrenHorizontal(amount);
- }
-
- @Override
- public int getStartAfterPadding() {
- return mLayoutManager.getPaddingLeft();
- }
-
- @Override
- public int getDecoratedMeasurement(View view) {
- final RecyclerView.LayoutParams params = (RecyclerView.LayoutParams)
- view.getLayoutParams();
- return mLayoutManager.getDecoratedMeasuredWidth(view) + params.leftMargin
- + params.rightMargin;
- }
-
- @Override
- public int getDecoratedMeasurementInOther(View view) {
- final RecyclerView.LayoutParams params = (RecyclerView.LayoutParams)
- view.getLayoutParams();
- return mLayoutManager.getDecoratedMeasuredHeight(view) + params.topMargin
- + params.bottomMargin;
- }
-
- @Override
- public int getDecoratedEnd(View view) {
- final RecyclerView.LayoutParams params = (RecyclerView.LayoutParams)
- view.getLayoutParams();
- return mLayoutManager.getDecoratedRight(view) + params.rightMargin;
- }
-
- @Override
- public int getDecoratedStart(View view) {
- final RecyclerView.LayoutParams params = (RecyclerView.LayoutParams)
- view.getLayoutParams();
- return mLayoutManager.getDecoratedLeft(view) - params.leftMargin;
- }
-
- @Override
- public int getTransformedEndWithDecoration(View view) {
- mLayoutManager.getTransformedBoundingBox(view, true, mTmpRect);
- return mTmpRect.right;
- }
-
- @Override
- public int getTransformedStartWithDecoration(View view) {
- mLayoutManager.getTransformedBoundingBox(view, true, mTmpRect);
- return mTmpRect.left;
- }
-
- @Override
- public int getTotalSpace() {
- return mLayoutManager.getWidth() - mLayoutManager.getPaddingLeft()
- - mLayoutManager.getPaddingRight();
- }
-
- @Override
- public void offsetChild(View view, int offset) {
- view.offsetLeftAndRight(offset);
- }
-
- @Override
- public int getEndPadding() {
- return mLayoutManager.getPaddingRight();
- }
-
- @Override
- public int getMode() {
- return mLayoutManager.getWidthMode();
- }
-
- @Override
- public int getModeInOther() {
- return mLayoutManager.getHeightMode();
- }
- };
- }
-
- /**
- * Creates a vertical OrientationHelper for the given LayoutManager.
- *
- * @param layoutManager The LayoutManager to attach to.
- * @return A new OrientationHelper
- */
- public static OrientationHelper createVerticalHelper(RecyclerView.LayoutManager layoutManager) {
- return new OrientationHelper(layoutManager) {
- @Override
- public int getEndAfterPadding() {
- return mLayoutManager.getHeight() - mLayoutManager.getPaddingBottom();
- }
-
- @Override
- public int getEnd() {
- return mLayoutManager.getHeight();
- }
-
- @Override
- public void offsetChildren(int amount) {
- mLayoutManager.offsetChildrenVertical(amount);
- }
-
- @Override
- public int getStartAfterPadding() {
- return mLayoutManager.getPaddingTop();
- }
-
- @Override
- public int getDecoratedMeasurement(View view) {
- final RecyclerView.LayoutParams params = (RecyclerView.LayoutParams)
- view.getLayoutParams();
- return mLayoutManager.getDecoratedMeasuredHeight(view) + params.topMargin
- + params.bottomMargin;
- }
-
- @Override
- public int getDecoratedMeasurementInOther(View view) {
- final RecyclerView.LayoutParams params = (RecyclerView.LayoutParams)
- view.getLayoutParams();
- return mLayoutManager.getDecoratedMeasuredWidth(view) + params.leftMargin
- + params.rightMargin;
- }
-
- @Override
- public int getDecoratedEnd(View view) {
- final RecyclerView.LayoutParams params = (RecyclerView.LayoutParams)
- view.getLayoutParams();
- return mLayoutManager.getDecoratedBottom(view) + params.bottomMargin;
- }
-
- @Override
- public int getDecoratedStart(View view) {
- final RecyclerView.LayoutParams params = (RecyclerView.LayoutParams)
- view.getLayoutParams();
- return mLayoutManager.getDecoratedTop(view) - params.topMargin;
- }
-
- @Override
- public int getTransformedEndWithDecoration(View view) {
- mLayoutManager.getTransformedBoundingBox(view, true, mTmpRect);
- return mTmpRect.bottom;
- }
-
- @Override
- public int getTransformedStartWithDecoration(View view) {
- mLayoutManager.getTransformedBoundingBox(view, true, mTmpRect);
- return mTmpRect.top;
- }
-
- @Override
- public int getTotalSpace() {
- return mLayoutManager.getHeight() - mLayoutManager.getPaddingTop()
- - mLayoutManager.getPaddingBottom();
- }
-
- @Override
- public void offsetChild(View view, int offset) {
- view.offsetTopAndBottom(offset);
- }
-
- @Override
- public int getEndPadding() {
- return mLayoutManager.getPaddingBottom();
- }
-
- @Override
- public int getMode() {
- return mLayoutManager.getHeightMode();
- }
-
- @Override
- public int getModeInOther() {
- return mLayoutManager.getWidthMode();
- }
- };
- }
-}
diff --git a/app/src/main/java/androidx/recyclerview/widget/PagerSnapHelper.java b/app/src/main/java/androidx/recyclerview/widget/PagerSnapHelper.java
deleted file mode 100644
index 3d97cdf552..0000000000
--- a/app/src/main/java/androidx/recyclerview/widget/PagerSnapHelper.java
+++ /dev/null
@@ -1,273 +0,0 @@
-/*
- * Copyright 2018 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package androidx.recyclerview.widget;
-
-import android.annotation.SuppressLint;
-import android.graphics.PointF;
-import android.util.DisplayMetrics;
-import android.view.View;
-
-import androidx.annotation.NonNull;
-import androidx.annotation.Nullable;
-
-/**
- * Implementation of the {@link SnapHelper} supporting pager style snapping in either vertical or
- * horizontal orientation.
- *
- *
- *
- * PagerSnapHelper can help achieve a similar behavior to
- * {@link androidx.viewpager.widget.ViewPager}. Set both {@link RecyclerView} and the items of the
- * {@link RecyclerView.Adapter} to have
- * {@link android.view.ViewGroup.LayoutParams#MATCH_PARENT} height and width and then attach
- * PagerSnapHelper to the {@link RecyclerView} using {@link #attachToRecyclerView(RecyclerView)}.
- */
-public class PagerSnapHelper extends SnapHelper {
- private static final int MAX_SCROLL_ON_FLING_DURATION = 100; // ms
-
- // Orientation helpers are lazily created per LayoutManager.
- @Nullable
- private OrientationHelper mVerticalHelper;
- @Nullable
- private OrientationHelper mHorizontalHelper;
-
- @Nullable
- @Override
- public int[] calculateDistanceToFinalSnap(@NonNull RecyclerView.LayoutManager layoutManager,
- @NonNull View targetView) {
- int[] out = new int[2];
- if (layoutManager.canScrollHorizontally()) {
- out[0] = distanceToCenter(targetView,
- getHorizontalHelper(layoutManager));
- } else {
- out[0] = 0;
- }
-
- if (layoutManager.canScrollVertically()) {
- out[1] = distanceToCenter(targetView,
- getVerticalHelper(layoutManager));
- } else {
- out[1] = 0;
- }
- return out;
- }
-
- @Nullable
- @Override
- @SuppressLint("UnknownNullness") // b/240775049: Cannot annotate properly
- public View findSnapView(RecyclerView.LayoutManager layoutManager) {
- if (layoutManager.canScrollVertically()) {
- return findCenterView(layoutManager, getVerticalHelper(layoutManager));
- } else if (layoutManager.canScrollHorizontally()) {
- return findCenterView(layoutManager, getHorizontalHelper(layoutManager));
- }
- return null;
- }
-
- @Override
- @SuppressLint("UnknownNullness") // b/240775049: Cannot annotate properly
- public int findTargetSnapPosition(RecyclerView.LayoutManager layoutManager, int velocityX,
- int velocityY) {
- final int itemCount = layoutManager.getItemCount();
- if (itemCount == 0) {
- return RecyclerView.NO_POSITION;
- }
-
- final OrientationHelper orientationHelper = getOrientationHelper(layoutManager);
- if (orientationHelper == null) {
- return RecyclerView.NO_POSITION;
- }
-
- // A child that is exactly in the center is eligible for both before and after
- View closestChildBeforeCenter = null;
- int distanceBefore = Integer.MIN_VALUE;
- View closestChildAfterCenter = null;
- int distanceAfter = Integer.MAX_VALUE;
-
- // Find the first view before the center, and the first view after the center
- final int childCount = layoutManager.getChildCount();
- for (int i = 0; i < childCount; i++) {
- final View child = layoutManager.getChildAt(i);
- if (child == null) {
- continue;
- }
- final int distance = distanceToCenter(child, orientationHelper);
-
- if (distance <= 0 && distance > distanceBefore) {
- // Child is before the center and closer then the previous best
- distanceBefore = distance;
- closestChildBeforeCenter = child;
- }
- if (distance >= 0 && distance < distanceAfter) {
- // Child is after the center and closer then the previous best
- distanceAfter = distance;
- closestChildAfterCenter = child;
- }
- }
-
- // Return the position of the first child from the center, in the direction of the fling
- final boolean forwardDirection = isForwardFling(layoutManager, velocityX, velocityY);
- if (forwardDirection && closestChildAfterCenter != null) {
- return layoutManager.getPosition(closestChildAfterCenter);
- } else if (!forwardDirection && closestChildBeforeCenter != null) {
- return layoutManager.getPosition(closestChildBeforeCenter);
- }
-
- // There is no child in the direction of the fling. Either it doesn't exist (start/end of
- // the list), or it is not yet attached (very rare case when children are larger then the
- // viewport). Extrapolate from the child that is visible to get the position of the view to
- // snap to.
- View visibleView = forwardDirection ? closestChildBeforeCenter : closestChildAfterCenter;
- if (visibleView == null) {
- return RecyclerView.NO_POSITION;
- }
- int visiblePosition = layoutManager.getPosition(visibleView);
- int snapToPosition = visiblePosition
- + (isReverseLayout(layoutManager) == forwardDirection ? -1 : +1);
-
- if (snapToPosition < 0 || snapToPosition >= itemCount) {
- return RecyclerView.NO_POSITION;
- }
- return snapToPosition;
- }
-
- private boolean isForwardFling(RecyclerView.LayoutManager layoutManager, int velocityX,
- int velocityY) {
- if (layoutManager.canScrollHorizontally()) {
- return velocityX > 0;
- } else {
- return velocityY > 0;
- }
- }
-
- private boolean isReverseLayout(RecyclerView.LayoutManager layoutManager) {
- final int itemCount = layoutManager.getItemCount();
- if ((layoutManager instanceof RecyclerView.SmoothScroller.ScrollVectorProvider)) {
- RecyclerView.SmoothScroller.ScrollVectorProvider vectorProvider =
- (RecyclerView.SmoothScroller.ScrollVectorProvider) layoutManager;
- PointF vectorForEnd = vectorProvider.computeScrollVectorForPosition(itemCount - 1);
- if (vectorForEnd != null) {
- return vectorForEnd.x < 0 || vectorForEnd.y < 0;
- }
- }
- return false;
- }
-
- @Nullable
- @Override
- protected RecyclerView.SmoothScroller createScroller(
- @NonNull RecyclerView.LayoutManager layoutManager) {
- if (!(layoutManager instanceof RecyclerView.SmoothScroller.ScrollVectorProvider)) {
- return null;
- }
- return new LinearSmoothScroller(mRecyclerView.getContext()) {
- @Override
- protected void onTargetFound(@NonNull View targetView,
- @NonNull RecyclerView.State state, @NonNull Action action) {
- int[] snapDistances = calculateDistanceToFinalSnap(mRecyclerView.getLayoutManager(),
- targetView);
- final int dx = snapDistances[0];
- final int dy = snapDistances[1];
- final int time = calculateTimeForDeceleration(Math.max(Math.abs(dx), Math.abs(dy)));
- if (time > 0) {
- action.update(dx, dy, time, mDecelerateInterpolator);
- }
- }
-
- @Override
- protected float calculateSpeedPerPixel(@NonNull DisplayMetrics displayMetrics) {
- return MILLISECONDS_PER_INCH / displayMetrics.densityDpi;
- }
-
- @Override
- protected int calculateTimeForScrolling(int dx) {
- return Math.min(MAX_SCROLL_ON_FLING_DURATION, super.calculateTimeForScrolling(dx));
- }
- };
- }
-
- private int distanceToCenter(@NonNull View targetView, OrientationHelper helper) {
- final int childCenter = helper.getDecoratedStart(targetView)
- + (helper.getDecoratedMeasurement(targetView) / 2);
- final int containerCenter = helper.getStartAfterPadding() + helper.getTotalSpace() / 2;
- return childCenter - containerCenter;
- }
-
- /**
- * Return the child view that is currently closest to the center of this parent.
- *
- * @param layoutManager The {@link RecyclerView.LayoutManager} associated with the attached
- * {@link RecyclerView}.
- * @param helper The relevant {@link OrientationHelper} for the attached {@link RecyclerView}.
- *
- * @return the child view that is currently closest to the center of this parent.
- */
- @Nullable
- private View findCenterView(RecyclerView.LayoutManager layoutManager,
- OrientationHelper helper) {
- int childCount = layoutManager.getChildCount();
- if (childCount == 0) {
- return null;
- }
-
- View closestChild = null;
- final int center = helper.getStartAfterPadding() + helper.getTotalSpace() / 2;
- int absClosest = Integer.MAX_VALUE;
-
- for (int i = 0; i < childCount; i++) {
- final View child = layoutManager.getChildAt(i);
- int childCenter = helper.getDecoratedStart(child)
- + (helper.getDecoratedMeasurement(child) / 2);
- int absDistance = Math.abs(childCenter - center);
-
- /* if child center is closer than previous closest, set it as closest */
- if (absDistance < absClosest) {
- absClosest = absDistance;
- closestChild = child;
- }
- }
- return closestChild;
- }
-
- @Nullable
- private OrientationHelper getOrientationHelper(RecyclerView.LayoutManager layoutManager) {
- if (layoutManager.canScrollVertically()) {
- return getVerticalHelper(layoutManager);
- } else if (layoutManager.canScrollHorizontally()) {
- return getHorizontalHelper(layoutManager);
- } else {
- return null;
- }
- }
-
- @NonNull
- private OrientationHelper getVerticalHelper(@NonNull RecyclerView.LayoutManager layoutManager) {
- if (mVerticalHelper == null || mVerticalHelper.mLayoutManager != layoutManager) {
- mVerticalHelper = OrientationHelper.createVerticalHelper(layoutManager);
- }
- return mVerticalHelper;
- }
-
- @NonNull
- private OrientationHelper getHorizontalHelper(
- @NonNull RecyclerView.LayoutManager layoutManager) {
- if (mHorizontalHelper == null || mHorizontalHelper.mLayoutManager != layoutManager) {
- mHorizontalHelper = OrientationHelper.createHorizontalHelper(layoutManager);
- }
- return mHorizontalHelper;
- }
-}
diff --git a/app/src/main/java/androidx/recyclerview/widget/RecyclerView.java b/app/src/main/java/androidx/recyclerview/widget/RecyclerView.java
deleted file mode 100644
index 9265d56d01..0000000000
--- a/app/src/main/java/androidx/recyclerview/widget/RecyclerView.java
+++ /dev/null
@@ -1,14454 +0,0 @@
-/*
- * Copyright 2018 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-
-package androidx.recyclerview.widget;
-
-import static androidx.annotation.RestrictTo.Scope.LIBRARY;
-import static androidx.annotation.RestrictTo.Scope.LIBRARY_GROUP_PREFIX;
-import static androidx.core.util.Preconditions.checkArgument;
-import static androidx.core.view.ViewCompat.TYPE_NON_TOUCH;
-import static androidx.core.view.ViewCompat.TYPE_TOUCH;
-
-import android.animation.LayoutTransition;
-import android.annotation.SuppressLint;
-import android.content.Context;
-import android.content.res.Resources;
-import android.content.res.TypedArray;
-import android.database.Observable;
-import android.graphics.Canvas;
-import android.graphics.Matrix;
-import android.graphics.PointF;
-import android.graphics.Rect;
-import android.graphics.RectF;
-import android.graphics.drawable.Drawable;
-import android.graphics.drawable.StateListDrawable;
-import android.hardware.SensorManager;
-import android.os.Build;
-import android.os.Bundle;
-import android.os.Parcel;
-import android.os.Parcelable;
-import android.os.SystemClock;
-import android.util.AttributeSet;
-import android.util.Log;
-import android.util.SparseArray;
-import android.view.Display;
-import android.view.FocusFinder;
-import android.view.InputDevice;
-import android.view.MotionEvent;
-import android.view.VelocityTracker;
-import android.view.View;
-import android.view.ViewConfiguration;
-import android.view.ViewGroup;
-import android.view.ViewParent;
-import android.view.accessibility.AccessibilityEvent;
-import android.view.accessibility.AccessibilityManager;
-import android.view.animation.Interpolator;
-import android.widget.EdgeEffect;
-import android.widget.LinearLayout;
-import android.widget.OverScroller;
-
-import androidx.annotation.CallSuper;
-import androidx.annotation.IntDef;
-import androidx.annotation.NonNull;
-import androidx.annotation.Nullable;
-import androidx.annotation.Px;
-import androidx.annotation.RestrictTo;
-import androidx.annotation.VisibleForTesting;
-import androidx.core.os.TraceCompat;
-import androidx.core.util.Preconditions;
-import androidx.core.view.AccessibilityDelegateCompat;
-import androidx.core.view.InputDeviceCompat;
-import androidx.core.view.MotionEventCompat;
-import androidx.core.view.NestedScrollingChild2;
-import androidx.core.view.NestedScrollingChild3;
-import androidx.core.view.NestedScrollingChildHelper;
-import androidx.core.view.ScrollingView;
-import androidx.core.view.ViewCompat;
-import androidx.core.view.ViewConfigurationCompat;
-import androidx.core.view.accessibility.AccessibilityEventCompat;
-import androidx.core.view.accessibility.AccessibilityNodeInfoCompat;
-import androidx.core.widget.EdgeEffectCompat;
-import androidx.customview.poolingcontainer.PoolingContainer;
-import androidx.customview.poolingcontainer.PoolingContainerListener;
-import androidx.customview.view.AbsSavedState;
-import androidx.recyclerview.R;
-import androidx.recyclerview.widget.RecyclerView.ItemAnimator.ItemHolderInfo;
-
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.ref.WeakReference;
-import java.lang.reflect.Constructor;
-import java.lang.reflect.InvocationTargetException;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.IdentityHashMap;
-import java.util.List;
-import java.util.Set;
-
-/**
- * A flexible view for providing a limited window into a large data set.
- *
- *
Glossary of terms:
- *
- *
- * Adapter: A subclass of {@link Adapter} responsible for providing views
- * that represent items in a data set.Position: The position of a data item within an Adapter .Index: The index of an attached child view as used in a call to
- * {@link ViewGroup#getChildAt}. Contrast with Position. Binding: The process of preparing a child view to display data corresponding
- * to a position within the adapter.Recycle (view): A view previously used to display data for a specific adapter
- * position may be placed in a cache for later reuse to display the same type of data again
- * later. This can drastically improve performance by skipping initial layout inflation
- * or construction.Scrap (view): A child view that has entered into a temporarily detached
- * state during layout. Scrap views may be reused without becoming fully detached
- * from the parent RecyclerView, either unmodified if no rebinding is required or modified
- * by the adapter if the view was considered dirty .Dirty (view): A child view that must be rebound by the adapter before
- * being displayed.
- *
- * Positions in RecyclerView:
- *
- * RecyclerView introduces an additional level of abstraction between the {@link Adapter} and
- * {@link LayoutManager} to be able to detect data set changes in batches during a layout
- * calculation. This saves LayoutManager from tracking adapter changes to calculate animations.
- * It also helps with performance because all view bindings happen at the same time and unnecessary
- * bindings are avoided.
- *
- * For this reason, there are two types of position related methods in RecyclerView:
- *
- * layout position: Position of an item in the latest layout calculation. This is the
- * position from the LayoutManager's perspective.
- * adapter position: Position of an item in the adapter. This is the position from
- * the Adapter's perspective.
- *
- *
- * These two positions are the same except the time between dispatching adapter.notify*
- * events and calculating the updated layout.
- *
- * Methods that return or receive *LayoutPosition* use position as of the latest
- * layout calculation (e.g. {@link ViewHolder#getLayoutPosition()},
- * {@link #findViewHolderForLayoutPosition(int)}). These positions include all changes until the
- * last layout calculation. You can rely on these positions to be consistent with what user is
- * currently seeing on the screen. For example, if you have a list of items on the screen and user
- * asks for the 5th element, you should use these methods as they'll match what user
- * is seeing.
- *
- * The other set of position related methods are in the form of
- * *AdapterPosition*. (e.g. {@link ViewHolder#getAbsoluteAdapterPosition()},
- * {@link ViewHolder#getBindingAdapterPosition()},
- * {@link #findViewHolderForAdapterPosition(int)}) You should use these methods when you need to
- * work with up-to-date adapter positions even if they may not have been reflected to layout yet.
- * For example, if you want to access the item in the adapter on a ViewHolder click, you should use
- * {@link ViewHolder#getBindingAdapterPosition()}. Beware that these methods may not be able to
- * calculate adapter positions if {@link Adapter#notifyDataSetChanged()} has been called and new
- * layout has not yet been calculated. For this reasons, you should carefully handle
- * {@link #NO_POSITION} or null results from these methods.
- *
- * When writing a {@link LayoutManager} you almost always want to use layout positions whereas when
- * writing an {@link Adapter}, you probably want to use adapter positions.
- *
- *
Presenting Dynamic Data
- * To display updatable data in a RecyclerView, your adapter needs to signal inserts, moves, and
- * deletions to RecyclerView. You can build this yourself by manually calling
- * {@code adapter.notify*} methods when content changes, or you can use one of the easier solutions
- * RecyclerView provides:
- *
- *
List diffing with DiffUtil
- * If your RecyclerView is displaying a list that is re-fetched from scratch for each update (e.g.
- * from the network, or from a database), {@link DiffUtil} can calculate the difference between
- * versions of the list. {@code DiffUtil} takes both lists as input and computes the difference,
- * which can be passed to RecyclerView to trigger minimal animations and updates to keep your UI
- * performant, and animations meaningful. This approach requires that each list is represented in
- * memory with immutable content, and relies on receiving updates as new instances of lists. This
- * approach is also ideal if your UI layer doesn't implement sorting, it just presents the data in
- * the order it's given.
- *
- * The best part of this approach is that it extends to any arbitrary changes - item updates,
- * moves, addition and removal can all be computed and handled the same way. Though you do have
- * to keep two copies of the list in memory while diffing, and must avoid mutating them, it's
- * possible to share unmodified elements between list versions.
- *
- * There are three primary ways to do this for RecyclerView. We recommend you start with
- * {@link ListAdapter}, the higher-level API that builds in {@link List} diffing on a background
- * thread, with minimal code. {@link AsyncListDiffer} also provides this behavior, but without
- * defining an Adapter to subclass. If you want more control, {@link DiffUtil} is the lower-level
- * API you can use to compute the diffs yourself. Each approach allows you to specify how diffs
- * should be computed based on item data.
- *
- *
List mutation with SortedList
- * If your RecyclerView receives updates incrementally, e.g. item X is inserted, or item Y is
- * removed, you can use {@link SortedList} to manage your list. You define how to order items,
- * and it will automatically trigger update signals that RecyclerView can use. SortedList works
- * if you only need to handle insert and remove events, and has the benefit that you only ever
- * need to have a single copy of the list in memory. It can also compute differences with
- * {@link SortedList#replaceAll(Object[])}, but this method is more limited than the list diffing
- * behavior above.
- *
- *
Paging Library
- * The Paging
- * library extends the diff-based approach to additionally support paged loading. It provides
- * the {@link androidx.paging.PagedList} class that operates as a self-loading list, provided a
- * source of data like a database, or paginated network API. It provides convenient list diffing
- * support out of the box, similar to {@code ListAdapter} and {@code AsyncListDiffer}. For more
- * information about the Paging library, see the
- * library
- * documentation .
- *
- * {@link androidx.recyclerview.R.attr#layoutManager}
- */
-public class RecyclerView extends ViewGroup implements ScrollingView,
- NestedScrollingChild2, NestedScrollingChild3 {
-
- static final String TAG = "RecyclerView";
-
- static boolean sDebugAssertionsEnabled = false;
- static boolean sVerboseLoggingEnabled = false;
-
- static final boolean VERBOSE_TRACING = false;
-
- private static final int[] NESTED_SCROLLING_ATTRS =
- {16843830 /* android.R.attr.nestedScrollingEnabled */};
-
- /**
- * The following are copied from OverScroller to determine how far a fling will go.
- */
- private static final float SCROLL_FRICTION = 0.015f;
- private static final float INFLEXION = 0.35f; // Tension lines cross at (INFLEXION, 1)
- private static final float DECELERATION_RATE = (float) (Math.log(0.78) / Math.log(0.9));
- private final float mPhysicalCoef;
-
- /**
- * On Kitkat and JB MR2, there is a bug which prevents DisplayList from being invalidated if
- * a View is two levels deep(wrt to ViewHolder.itemView). DisplayList can be invalidated by
- * setting View's visibility to INVISIBLE when View is detached. On Kitkat and JB MR2, Recycler
- * recursively traverses itemView and invalidates display list for each ViewGroup that matches
- * this criteria.
- */
- static final boolean FORCE_INVALIDATE_DISPLAY_LIST = Build.VERSION.SDK_INT == 18
- || Build.VERSION.SDK_INT == 19 || Build.VERSION.SDK_INT == 20;
- /**
- * On M+, an unspecified measure spec may include a hint which we can use. On older platforms,
- * this value might be garbage. To save LayoutManagers from it, RecyclerView sets the size to
- * 0 when mode is unspecified.
- */
- static final boolean ALLOW_SIZE_IN_UNSPECIFIED_SPEC = Build.VERSION.SDK_INT >= 23;
-
- static final boolean POST_UPDATES_ON_ANIMATION = Build.VERSION.SDK_INT >= 16;
-
- /**
- * On L+, with RenderThread, the UI thread has idle time after it has passed a frame off to
- * RenderThread but before the next frame begins. We schedule prefetch work in this window.
- */
- static final boolean ALLOW_THREAD_GAP_WORK = Build.VERSION.SDK_INT >= 21;
-
- /**
- * FocusFinder#findNextFocus is broken on ICS MR1 and older for View.FOCUS_BACKWARD direction.
- * We convert it to an absolute direction such as FOCUS_DOWN or FOCUS_LEFT.
- */
- private static final boolean FORCE_ABS_FOCUS_SEARCH_DIRECTION = Build.VERSION.SDK_INT <= 15;
-
- /**
- * on API 15-, a focused child can still be considered a focused child of RV even after
- * it's being removed or its focusable flag is set to false. This is because when this focused
- * child is detached, the reference to this child is not removed in clearFocus. API 16 and above
- * properly handle this case by calling ensureInputFocusOnFirstFocusable or rootViewRequestFocus
- * to request focus on a new child, which will clear the focus on the old (detached) child as a
- * side-effect.
- */
- private static final boolean IGNORE_DETACHED_FOCUSED_CHILD = Build.VERSION.SDK_INT <= 15;
-
- /**
- * When flinging the stretch towards scrolling content, it should destretch quicker than the
- * fling would normally do. The visual effect of flinging the stretch looks strange as little
- * appears to happen at first and then when the stretch disappears, the content starts
- * scrolling quickly.
- */
- private static final float FLING_DESTRETCH_FACTOR = 4f;
-
- static final boolean DISPATCH_TEMP_DETACH = false;
-
- /** @hide */
- @RestrictTo(LIBRARY_GROUP_PREFIX)
- @IntDef({HORIZONTAL, VERTICAL})
- @Retention(RetentionPolicy.SOURCE)
- public @interface Orientation {
- }
-
- public static final int HORIZONTAL = LinearLayout.HORIZONTAL;
- public static final int VERTICAL = LinearLayout.VERTICAL;
-
- static final int DEFAULT_ORIENTATION = VERTICAL;
- public static final int NO_POSITION = -1;
- public static final long NO_ID = -1;
- public static final int INVALID_TYPE = -1;
-
- /**
- * Constant for use with {@link #setScrollingTouchSlop(int)}. Indicates
- * that the RecyclerView should use the standard touch slop for smooth,
- * continuous scrolling.
- */
- public static final int TOUCH_SLOP_DEFAULT = 0;
-
- /**
- * Constant for use with {@link #setScrollingTouchSlop(int)}. Indicates
- * that the RecyclerView should use the standard touch slop for scrolling
- * widgets that snap to a page or other coarse-grained barrier.
- */
- public static final int TOUCH_SLOP_PAGING = 1;
-
- /**
- * Constant that represents that a duration has not been defined.
- */
- public static final int UNDEFINED_DURATION = Integer.MIN_VALUE;
-
- static final int MAX_SCROLL_DURATION = 2000;
-
- /**
- * RecyclerView is calculating a scroll.
- * If there are too many of these in Systrace, some Views inside RecyclerView might be causing
- * it. Try to avoid using EditText, focusable views or handle them with care.
- */
- static final String TRACE_SCROLL_TAG = "RV Scroll";
-
- /**
- * OnLayout has been called by the View system.
- * If this shows up too many times in Systrace, make sure the children of RecyclerView do not
- * update themselves directly. This will cause a full re-layout but when it happens via the
- * Adapter notifyItemChanged, RecyclerView can avoid full layout calculation.
- */
- private static final String TRACE_ON_LAYOUT_TAG = "RV OnLayout";
-
- /**
- * NotifyDataSetChanged or equal has been called.
- * If this is taking a long time, try sending granular notify adapter changes instead of just
- * calling notifyDataSetChanged or setAdapter / swapAdapter. Adding stable ids to your adapter
- * might help.
- */
- private static final String TRACE_ON_DATA_SET_CHANGE_LAYOUT_TAG = "RV FullInvalidate";
-
- /**
- * RecyclerView is doing a layout for partial adapter updates (we know what has changed)
- * If this is taking a long time, you may have dispatched too many Adapter updates causing too
- * many Views being rebind. Make sure all are necessary and also prefer using notify*Range
- * methods.
- */
- private static final String TRACE_HANDLE_ADAPTER_UPDATES_TAG = "RV PartialInvalidate";
-
- /**
- * RecyclerView is rebinding a View.
- * If this is taking a lot of time, consider optimizing your layout or make sure you are not
- * doing extra operations in onBindViewHolder call.
- */
- static final String TRACE_BIND_VIEW_TAG = "RV OnBindView";
-
- /**
- * RecyclerView is attempting to pre-populate off screen views.
- */
- static final String TRACE_PREFETCH_TAG = "RV Prefetch";
-
- /**
- * RecyclerView is attempting to pre-populate off screen itemviews within an off screen
- * RecyclerView.
- */
- static final String TRACE_NESTED_PREFETCH_TAG = "RV Nested Prefetch";
-
- /**
- * RecyclerView is creating a new View.
- * If too many of these present in Systrace:
- * - There might be a problem in Recycling (e.g. custom Animations that set transient state and
- * prevent recycling or ItemAnimator not implementing the contract properly. ({@link
- * > Adapter#onFailedToRecycleView(ViewHolder)})
- *
- * - There might be too many item view types.
- * > Try merging them
- *
- * - There might be too many itemChange animations and not enough space in RecyclerPool.
- * >Try increasing your pool size and item cache size.
- */
- static final String TRACE_CREATE_VIEW_TAG = "RV CreateView";
- private static final Class[] LAYOUT_MANAGER_CONSTRUCTOR_SIGNATURE =
- new Class[]{Context.class, AttributeSet.class, int.class, int.class};
-
- /**
- * Enable internal assertions about RecyclerView's state and throw exceptions if the
- * assertions are violated.
- *
- * This is primarily intended to diagnose problems with RecyclerView, and
- * should not be enabled in production unless you have a specific reason to
- * do so.
- *
- * Enabling this may negatively affect performance and/or stability.
- *
- * @param debugAssertionsEnabled true to enable assertions; false to disable them
- */
- public static void setDebugAssertionsEnabled(boolean debugAssertionsEnabled) {
- RecyclerView.sDebugAssertionsEnabled = debugAssertionsEnabled;
- }
-
- /**
- * Enable verbose logging within RecyclerView itself.
- *
- * Enabling this may negatively affect performance and reduce the utility of logcat due to
- * high-volume logging. This generally should not be enabled in production
- * unless you have a specific reason for doing so.
- *
- * @param verboseLoggingEnabled true to enable logging; false to disable it
- */
- public static void setVerboseLoggingEnabled(boolean verboseLoggingEnabled) {
- RecyclerView.sVerboseLoggingEnabled = verboseLoggingEnabled;
- }
-
- private final RecyclerViewDataObserver mObserver = new RecyclerViewDataObserver();
-
- final Recycler mRecycler = new Recycler();
-
- SavedState mPendingSavedState;
-
- /**
- * Handles adapter updates
- */
- AdapterHelper mAdapterHelper;
-
- /**
- * Handles abstraction between LayoutManager children and RecyclerView children
- */
- ChildHelper mChildHelper;
-
- /**
- * Keeps data about views to be used for animations
- */
- final ViewInfoStore mViewInfoStore = new ViewInfoStore();
-
- /**
- * Prior to L, there is no way to query this variable which is why we override the setter and
- * track it here.
- */
- boolean mClipToPadding;
-
- /**
- * Note: this Runnable is only ever posted if:
- * 1) We've been through first layout
- * 2) We know we have a fixed size (mHasFixedSize)
- * 3) We're attached
- */
- final Runnable mUpdateChildViewsRunnable = new Runnable() {
- @Override
- public void run() {
- if (!mFirstLayoutComplete || isLayoutRequested()) {
- // a layout request will happen, we should not do layout here.
- return;
- }
- if (!mIsAttached) {
- requestLayout();
- // if we are not attached yet, mark us as requiring layout and skip
- return;
- }
- if (mLayoutSuppressed) {
- mLayoutWasDefered = true;
- return; //we'll process updates when ice age ends.
- }
- consumePendingUpdateOperations();
- }
- };
-
- final Rect mTempRect = new Rect();
- private final Rect mTempRect2 = new Rect();
- final RectF mTempRectF = new RectF();
- Adapter mAdapter;
- @VisibleForTesting
- LayoutManager mLayout;
- // TODO: Remove this once setRecyclerListener has been removed.
- RecyclerListener mRecyclerListener;
- // default access to avoid the need for synthetic accessors for Recycler inner class.
- final List mRecyclerListeners = new ArrayList<>();
- final ArrayList mItemDecorations = new ArrayList<>();
- private final ArrayList mOnItemTouchListeners =
- new ArrayList<>();
- private OnItemTouchListener mInterceptingOnItemTouchListener;
- boolean mIsAttached;
- boolean mHasFixedSize;
- boolean mEnableFastScroller;
- @VisibleForTesting
- boolean mFirstLayoutComplete;
-
- /**
- * The current depth of nested calls to {@link #startInterceptRequestLayout()} (number of
- * calls to {@link #startInterceptRequestLayout()} - number of calls to
- * {@link #stopInterceptRequestLayout(boolean)} . This is used to signal whether we
- * should defer layout operations caused by layout requests from children of
- * {@link RecyclerView}.
- */
- private int mInterceptRequestLayoutDepth = 0;
-
- /**
- * True if a call to requestLayout was intercepted and prevented from executing like normal and
- * we plan on continuing with normal execution later.
- */
- boolean mLayoutWasDefered;
-
- boolean mLayoutSuppressed;
- private boolean mIgnoreMotionEventTillDown;
-
- // binary OR of change events that were eaten during a layout or scroll.
- private int mEatenAccessibilityChangeFlags;
- boolean mAdapterUpdateDuringMeasure;
-
- private final AccessibilityManager mAccessibilityManager;
- private List mOnChildAttachStateListeners;
-
- /**
- * True after an event occurs that signals that the entire data set has changed. In that case,
- * we cannot run any animations since we don't know what happened until layout.
- *
- * Attached items are invalid until next layout, at which point layout will animate/replace
- * items as necessary, building up content from the (effectively) new adapter from scratch.
- *
- * Cached items must be discarded when setting this to true, so that the cache may be freely
- * used by prefetching until the next layout occurs.
- *
- * @see #processDataSetCompletelyChanged(boolean)
- */
- boolean mDataSetHasChangedAfterLayout = false;
-
- /**
- * True after the data set has completely changed and
- * {@link LayoutManager#onItemsChanged(RecyclerView)} should be called during the subsequent
- * measure/layout.
- *
- * @see #processDataSetCompletelyChanged(boolean)
- */
- boolean mDispatchItemsChangedEvent = false;
-
- /**
- * This variable is incremented during a dispatchLayout and/or scroll.
- * Some methods should not be called during these periods (e.g. adapter data change).
- * Doing so will create hard to find bugs so we better check it and throw an exception.
- *
- * @see #assertInLayoutOrScroll(String)
- * @see #assertNotInLayoutOrScroll(String)
- */
- private int mLayoutOrScrollCounter = 0;
-
- /**
- * Similar to mLayoutOrScrollCounter but logs a warning instead of throwing an exception
- * (for API compatibility).
- *
- * It is a bad practice for a developer to update the data in a scroll callback since it is
- * potentially called during a layout.
- */
- private int mDispatchScrollCounter = 0;
-
- @NonNull
- private EdgeEffectFactory mEdgeEffectFactory = sDefaultEdgeEffectFactory;
- private EdgeEffect mLeftGlow, mTopGlow, mRightGlow, mBottomGlow;
-
- ItemAnimator mItemAnimator = new DefaultItemAnimator();
-
- private static final int INVALID_POINTER = -1;
-
- /**
- * The RecyclerView is not currently scrolling.
- *
- * @see #getScrollState()
- */
- public static final int SCROLL_STATE_IDLE = 0;
-
- /**
- * The RecyclerView is currently being dragged by outside input such as user touch input.
- *
- * @see #getScrollState()
- */
- public static final int SCROLL_STATE_DRAGGING = 1;
-
- /**
- * The RecyclerView is currently animating to a final position while not under
- * outside control.
- *
- * @see #getScrollState()
- */
- public static final int SCROLL_STATE_SETTLING = 2;
-
- static final long FOREVER_NS = Long.MAX_VALUE;
-
- // Touch/scrolling handling
-
- private int mScrollState = SCROLL_STATE_IDLE;
- private int mScrollPointerId = INVALID_POINTER;
- private VelocityTracker mVelocityTracker;
- private int mInitialTouchX;
- private int mInitialTouchY;
- private int mLastTouchX;
- private int mLastTouchY;
- private int mTouchSlop;
- private OnFlingListener mOnFlingListener;
- private final int mMinFlingVelocity;
- private final int mMaxFlingVelocity;
-
- // This value is used when handling rotary encoder generic motion events.
- private float mScaledHorizontalScrollFactor = Float.MIN_VALUE;
- private float mScaledVerticalScrollFactor = Float.MIN_VALUE;
-
- private boolean mPreserveFocusAfterLayout = true;
-
- final ViewFlinger mViewFlinger = new ViewFlinger();
-
- GapWorker mGapWorker;
- GapWorker.LayoutPrefetchRegistryImpl mPrefetchRegistry =
- ALLOW_THREAD_GAP_WORK ? new GapWorker.LayoutPrefetchRegistryImpl() : null;
-
- final State mState = new State();
-
- private OnScrollListener mScrollListener;
- private List mScrollListeners;
-
- // For use in item animations
- boolean mItemsAddedOrRemoved = false;
- boolean mItemsChanged = false;
- private ItemAnimator.ItemAnimatorListener mItemAnimatorListener =
- new ItemAnimatorRestoreListener();
- boolean mPostedAnimatorRunner = false;
- RecyclerViewAccessibilityDelegate mAccessibilityDelegate;
- private ChildDrawingOrderCallback mChildDrawingOrderCallback;
-
- // simple array to keep min and max child position during a layout calculation
- // preserved not to create a new one in each layout pass
- private final int[] mMinMaxLayoutPositions = new int[2];
-
- private NestedScrollingChildHelper mScrollingChildHelper;
- private final int[] mScrollOffset = new int[2];
- private final int[] mNestedOffsets = new int[2];
-
- // Reusable int array to be passed to method calls that mutate it in order to "return" two ints.
- final int[] mReusableIntPair = new int[2];
-
- /**
- * These are views that had their a11y importance changed during a layout. We defer these events
- * until the end of the layout because a11y service may make sync calls back to the RV while
- * the View's state is undefined.
- */
- @VisibleForTesting
- final List mPendingAccessibilityImportanceChange = new ArrayList<>();
-
- private Runnable mItemAnimatorRunner = new Runnable() {
- @Override
- public void run() {
- if (mItemAnimator != null) {
- mItemAnimator.runPendingAnimations();
- }
- mPostedAnimatorRunner = false;
- }
- };
-
- static final Interpolator sQuinticInterpolator = new Interpolator() {
- @Override
- public float getInterpolation(float t) {
- t -= 1.0f;
- return t * t * t * t * t + 1.0f;
- }
- };
-
- static final StretchEdgeEffectFactory sDefaultEdgeEffectFactory =
- new StretchEdgeEffectFactory();
-
- // These fields are only used to track whether we need to layout and measure RV children in
- // onLayout.
- //
- // We track this information because there is an optimized path such that when
- // LayoutManager#isAutoMeasureEnabled() returns true and we are measured with
- // MeasureSpec.EXACTLY in both dimensions, we skip measuring and layout children till the
- // layout phase.
- //
- // However, there are times when we are first measured with something other than
- // MeasureSpec.EXACTLY in both dimensions, in which case we measure and layout children during
- // onMeasure. Then if we are measured again with EXACTLY, and we skip measurement, we will
- // get laid out with a different size than we were last aware of being measured with. If
- // that happens and we don't check for it, we may not remeasure children, which would be a bug.
- //
- // mLastAutoMeasureNonExactMeasureResult tracks our last known measurements in this case, and
- // mLastAutoMeasureSkippedDueToExact tracks whether or not we skipped. So, whenever we
- // layout, we can see if our last known measurement information is different from our actual
- // laid out size, and if it is, only then do we remeasure and relayout children.
- private boolean mLastAutoMeasureSkippedDueToExact;
- private int mLastAutoMeasureNonExactMeasuredWidth = 0;
- private int mLastAutoMeasureNonExactMeasuredHeight = 0;
-
- /**
- * The callback to convert view info diffs into animations.
- */
- private final ViewInfoStore.ProcessCallback mViewInfoProcessCallback =
- new ViewInfoStore.ProcessCallback() {
- @Override
- public void processDisappeared(ViewHolder viewHolder, @NonNull ItemHolderInfo info,
- @Nullable ItemHolderInfo postInfo) {
- mRecycler.unscrapView(viewHolder);
- animateDisappearance(viewHolder, info, postInfo);
- }
-
- @Override
- public void processAppeared(ViewHolder viewHolder,
- ItemHolderInfo preInfo, ItemHolderInfo info) {
- animateAppearance(viewHolder, preInfo, info);
- }
-
- @Override
- public void processPersistent(ViewHolder viewHolder,
- @NonNull ItemHolderInfo preInfo, @NonNull ItemHolderInfo postInfo) {
- viewHolder.setIsRecyclable(false);
- if (mDataSetHasChangedAfterLayout) {
- // since it was rebound, use change instead as we'll be mapping them from
- // stable ids. If stable ids were false, we would not be running any
- // animations
- if (mItemAnimator.animateChange(viewHolder, viewHolder, preInfo,
- postInfo)) {
- postAnimationRunner();
- }
- } else if (mItemAnimator.animatePersistence(viewHolder, preInfo, postInfo)) {
- postAnimationRunner();
- }
- }
-
- @Override
- public void unused(ViewHolder viewHolder) {
- mLayout.removeAndRecycleView(viewHolder.itemView, mRecycler);
- }
- };
-
- public RecyclerView(@NonNull Context context) {
- this(context, null);
- }
-
- public RecyclerView(@NonNull Context context, @Nullable AttributeSet attrs) {
- this(context, attrs, R.attr.recyclerViewStyle);
- }
-
- public RecyclerView(@NonNull Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
- super(context, attrs, defStyleAttr);
- setScrollContainer(true);
- setFocusableInTouchMode(true);
-
- final ViewConfiguration vc = ViewConfiguration.get(context);
- mTouchSlop = vc.getScaledTouchSlop();
- mScaledHorizontalScrollFactor =
- ViewConfigurationCompat.getScaledHorizontalScrollFactor(vc, context);
- mScaledVerticalScrollFactor =
- ViewConfigurationCompat.getScaledVerticalScrollFactor(vc, context);
- mMinFlingVelocity = vc.getScaledMinimumFlingVelocity();
- mMaxFlingVelocity = vc.getScaledMaximumFlingVelocity();
- final float ppi = context.getResources().getDisplayMetrics().density * 160.0f;
- mPhysicalCoef = SensorManager.GRAVITY_EARTH // g (m/s^2)
- * 39.37f // inch/meter
- * ppi
- * 0.84f; // look and feel tuning
- setWillNotDraw(getOverScrollMode() == View.OVER_SCROLL_NEVER);
-
- mItemAnimator.setListener(mItemAnimatorListener);
- initAdapterManager();
- initChildrenHelper();
- initAutofill();
- // If not explicitly specified this view is important for accessibility.
- if (ViewCompat.getImportantForAccessibility(this)
- == ViewCompat.IMPORTANT_FOR_ACCESSIBILITY_AUTO) {
- ViewCompat.setImportantForAccessibility(this,
- ViewCompat.IMPORTANT_FOR_ACCESSIBILITY_YES);
- }
- mAccessibilityManager = (AccessibilityManager) getContext()
- .getSystemService(Context.ACCESSIBILITY_SERVICE);
- setAccessibilityDelegateCompat(new RecyclerViewAccessibilityDelegate(this));
-
- TypedArray a = context.obtainStyledAttributes(attrs, R.styleable.RecyclerView,
- defStyleAttr, 0);
-
- ViewCompat.saveAttributeDataForStyleable(this, context, R.styleable.RecyclerView,
- attrs, a, defStyleAttr, 0);
- String layoutManagerName = a.getString(R.styleable.RecyclerView_layoutManager);
- int descendantFocusability = a.getInt(
- R.styleable.RecyclerView_android_descendantFocusability, -1);
- if (descendantFocusability == -1) {
- setDescendantFocusability(ViewGroup.FOCUS_AFTER_DESCENDANTS);
- }
- mClipToPadding = a.getBoolean(R.styleable.RecyclerView_android_clipToPadding, true);
- mEnableFastScroller = a.getBoolean(R.styleable.RecyclerView_fastScrollEnabled, false);
- if (mEnableFastScroller) {
- StateListDrawable verticalThumbDrawable = (StateListDrawable) a
- .getDrawable(R.styleable.RecyclerView_fastScrollVerticalThumbDrawable);
- Drawable verticalTrackDrawable = a
- .getDrawable(R.styleable.RecyclerView_fastScrollVerticalTrackDrawable);
- StateListDrawable horizontalThumbDrawable = (StateListDrawable) a
- .getDrawable(R.styleable.RecyclerView_fastScrollHorizontalThumbDrawable);
- Drawable horizontalTrackDrawable = a
- .getDrawable(R.styleable.RecyclerView_fastScrollHorizontalTrackDrawable);
- initFastScroller(verticalThumbDrawable, verticalTrackDrawable,
- horizontalThumbDrawable, horizontalTrackDrawable);
- }
- a.recycle();
-
- // Create the layoutManager if specified.
- createLayoutManager(context, layoutManagerName, attrs, defStyleAttr, 0);
-
- boolean nestedScrollingEnabled = true;
- if (Build.VERSION.SDK_INT >= 21) {
- a = context.obtainStyledAttributes(attrs, NESTED_SCROLLING_ATTRS,
- defStyleAttr, 0);
- ViewCompat.saveAttributeDataForStyleable(this,
- context, NESTED_SCROLLING_ATTRS, attrs, a, defStyleAttr, 0);
- nestedScrollingEnabled = a.getBoolean(0, true);
- a.recycle();
- }
- // Re-set whether nested scrolling is enabled so that it is set on all API levels
- setNestedScrollingEnabled(nestedScrollingEnabled);
- PoolingContainer.setPoolingContainer(this, true);
- }
-
- /**
- * Label appended to all public exception strings, used to help find which RV in an app is
- * hitting an exception.
- */
- String exceptionLabel() {
- return " " + super.toString()
- + ", adapter:" + mAdapter
- + ", layout:" + mLayout
- + ", context:" + getContext();
- }
-
- /**
- * If not explicitly specified, this view and its children don't support autofill.
- *
- * This is done because autofill's means of uniquely identifying views doesn't work out of the
- * box with View recycling.
- */
- @SuppressLint("InlinedApi")
- private void initAutofill() {
- if (ViewCompat.getImportantForAutofill(this) == View.IMPORTANT_FOR_AUTOFILL_AUTO) {
- ViewCompat.setImportantForAutofill(this,
- View.IMPORTANT_FOR_AUTOFILL_NO_EXCLUDE_DESCENDANTS);
- }
- }
-
- /**
- * Returns the accessibility delegate compatibility implementation used by the RecyclerView.
- *
- * @return An instance of AccessibilityDelegateCompat used by RecyclerView
- */
- @Nullable
- public RecyclerViewAccessibilityDelegate getCompatAccessibilityDelegate() {
- return mAccessibilityDelegate;
- }
-
- /**
- * Sets the accessibility delegate compatibility implementation used by RecyclerView.
- *
- * @param accessibilityDelegate The accessibility delegate to be used by RecyclerView.
- */
- public void setAccessibilityDelegateCompat(
- @Nullable RecyclerViewAccessibilityDelegate accessibilityDelegate) {
- mAccessibilityDelegate = accessibilityDelegate;
- ViewCompat.setAccessibilityDelegate(this, mAccessibilityDelegate);
- }
-
- @Override
- public CharSequence getAccessibilityClassName() {
- return "androidx.recyclerview.widget.RecyclerView";
- }
-
- /**
- * Instantiate and set a LayoutManager, if specified in the attributes.
- */
- private void createLayoutManager(Context context, String className, AttributeSet attrs,
- int defStyleAttr, int defStyleRes) {
- if (className != null) {
- className = className.trim();
- if (!className.isEmpty()) {
- className = getFullClassName(context, className);
- try {
- ClassLoader classLoader;
- if (isInEditMode()) {
- // Stupid layoutlib cannot handle simple class loaders.
- classLoader = this.getClass().getClassLoader();
- } else {
- classLoader = context.getClassLoader();
- }
- Class layoutManagerClass =
- Class.forName(className, false, classLoader)
- .asSubclass(LayoutManager.class);
- Constructor constructor;
- Object[] constructorArgs = null;
- try {
- constructor = layoutManagerClass
- .getConstructor(LAYOUT_MANAGER_CONSTRUCTOR_SIGNATURE);
- constructorArgs = new Object[]{context, attrs, defStyleAttr, defStyleRes};
- } catch (NoSuchMethodException e) {
- try {
- constructor = layoutManagerClass.getConstructor();
- } catch (NoSuchMethodException e1) {
- e1.initCause(e);
- throw new IllegalStateException(attrs.getPositionDescription()
- + ": Error creating LayoutManager " + className, e1);
- }
- }
- constructor.setAccessible(true);
- setLayoutManager(constructor.newInstance(constructorArgs));
- } catch (ClassNotFoundException e) {
- throw new IllegalStateException(attrs.getPositionDescription()
- + ": Unable to find LayoutManager " + className, e);
- } catch (InvocationTargetException e) {
- throw new IllegalStateException(attrs.getPositionDescription()
- + ": Could not instantiate the LayoutManager: " + className, e);
- } catch (InstantiationException e) {
- throw new IllegalStateException(attrs.getPositionDescription()
- + ": Could not instantiate the LayoutManager: " + className, e);
- } catch (IllegalAccessException e) {
- throw new IllegalStateException(attrs.getPositionDescription()
- + ": Cannot access non-public constructor " + className, e);
- } catch (ClassCastException e) {
- throw new IllegalStateException(attrs.getPositionDescription()
- + ": Class is not a LayoutManager " + className, e);
- }
- }
- }
- }
-
- private String getFullClassName(Context context, String className) {
- if (className.charAt(0) == '.') {
- return context.getPackageName() + className;
- }
- if (className.contains(".")) {
- return className;
- }
- return RecyclerView.class.getPackage().getName() + '.' + className;
- }
-
- private void initChildrenHelper() {
- mChildHelper = new ChildHelper(new ChildHelper.Callback() {
- @Override
- public int getChildCount() {
- return RecyclerView.this.getChildCount();
- }
-
- @Override
- public void addView(View child, int index) {
- if (VERBOSE_TRACING) {
- TraceCompat.beginSection("RV addView");
- }
- RecyclerView.this.addView(child, index);
- if (VERBOSE_TRACING) {
- TraceCompat.endSection();
- }
- dispatchChildAttached(child);
- }
-
- @Override
- public int indexOfChild(View view) {
- return RecyclerView.this.indexOfChild(view);
- }
-
- @Override
- public void removeViewAt(int index) {
- final View child = RecyclerView.this.getChildAt(index);
- if (child != null) {
- dispatchChildDetached(child);
-
- // Clear any android.view.animation.Animation that may prevent the item from
- // detaching when being removed. If a child is re-added before the
- // lazy detach occurs, it will receive invalid attach/detach sequencing.
- child.clearAnimation();
- }
- if (VERBOSE_TRACING) {
- TraceCompat.beginSection("RV removeViewAt");
- }
- RecyclerView.this.removeViewAt(index);
- if (VERBOSE_TRACING) {
- TraceCompat.endSection();
- }
- }
-
- @Override
- public View getChildAt(int offset) {
- return RecyclerView.this.getChildAt(offset);
- }
-
- @Override
- public void removeAllViews() {
- final int count = getChildCount();
- for (int i = 0; i < count; i++) {
- View child = getChildAt(i);
- dispatchChildDetached(child);
-
- // Clear any android.view.animation.Animation that may prevent the item from
- // detaching when being removed. If a child is re-added before the
- // lazy detach occurs, it will receive invalid attach/detach sequencing.
- child.clearAnimation();
- }
- RecyclerView.this.removeAllViews();
- }
-
- @Override
- public ViewHolder getChildViewHolder(View view) {
- return getChildViewHolderInt(view);
- }
-
- @Override
- public void attachViewToParent(View child, int index,
- ViewGroup.LayoutParams layoutParams) {
- final ViewHolder vh = getChildViewHolderInt(child);
- if (vh != null) {
- if (!vh.isTmpDetached() && !vh.shouldIgnore()) {
- throw new IllegalArgumentException("Called attach on a child which is not"
- + " detached: " + vh + exceptionLabel());
- }
- if (sVerboseLoggingEnabled) {
- Log.d(TAG, "reAttach " + vh);
- }
- vh.clearTmpDetachFlag();
- } else {
- if (sDebugAssertionsEnabled) {
- throw new IllegalArgumentException(
- "No ViewHolder found for child: " + child + ", index: " + index
- + exceptionLabel());
- }
- }
- RecyclerView.this.attachViewToParent(child, index, layoutParams);
- }
-
- @Override
- public void detachViewFromParent(int offset) {
- final View view = getChildAt(offset);
- if (view != null) {
- final ViewHolder vh = getChildViewHolderInt(view);
- if (vh != null) {
- if (vh.isTmpDetached() && !vh.shouldIgnore()) {
- throw new IllegalArgumentException("called detach on an already"
- + " detached child " + vh + exceptionLabel());
- }
- if (sVerboseLoggingEnabled) {
- Log.d(TAG, "tmpDetach " + vh);
- }
- vh.addFlags(ViewHolder.FLAG_TMP_DETACHED);
- }
- } else {
- if (sDebugAssertionsEnabled) {
- throw new IllegalArgumentException(
- "No view at offset " + offset + exceptionLabel());
- }
- }
- RecyclerView.this.detachViewFromParent(offset);
- }
-
- @Override
- public void onEnteredHiddenState(View child) {
- final ViewHolder vh = getChildViewHolderInt(child);
- if (vh != null) {
- vh.onEnteredHiddenState(RecyclerView.this);
- }
- }
-
- @Override
- public void onLeftHiddenState(View child) {
- final ViewHolder vh = getChildViewHolderInt(child);
- if (vh != null) {
- vh.onLeftHiddenState(RecyclerView.this);
- }
- }
- });
- }
-
- void initAdapterManager() {
- mAdapterHelper = new AdapterHelper(new AdapterHelper.Callback() {
- @Override
- public ViewHolder findViewHolder(int position) {
- final ViewHolder vh = findViewHolderForPosition(position, true);
- if (vh == null) {
- return null;
- }
- // ensure it is not hidden because for adapter helper, the only thing matter is that
- // LM thinks view is a child.
- if (mChildHelper.isHidden(vh.itemView)) {
- if (sVerboseLoggingEnabled) {
- Log.d(TAG, "assuming view holder cannot be find because it is hidden");
- }
- return null;
- }
- return vh;
- }
-
- @Override
- public void offsetPositionsForRemovingInvisible(int start, int count) {
- offsetPositionRecordsForRemove(start, count, true);
- mItemsAddedOrRemoved = true;
- mState.mDeletedInvisibleItemCountSincePreviousLayout += count;
- }
-
- @Override
- public void offsetPositionsForRemovingLaidOutOrNewView(
- int positionStart, int itemCount) {
- offsetPositionRecordsForRemove(positionStart, itemCount, false);
- mItemsAddedOrRemoved = true;
- }
-
-
- @Override
- public void markViewHoldersUpdated(int positionStart, int itemCount, Object payload) {
- viewRangeUpdate(positionStart, itemCount, payload);
- mItemsChanged = true;
- }
-
- @Override
- public void onDispatchFirstPass(AdapterHelper.UpdateOp op) {
- dispatchUpdate(op);
- }
-
- void dispatchUpdate(AdapterHelper.UpdateOp op) {
- switch (op.cmd) {
- case AdapterHelper.UpdateOp.ADD:
- mLayout.onItemsAdded(RecyclerView.this, op.positionStart, op.itemCount);
- break;
- case AdapterHelper.UpdateOp.REMOVE:
- mLayout.onItemsRemoved(RecyclerView.this, op.positionStart, op.itemCount);
- break;
- case AdapterHelper.UpdateOp.UPDATE:
- mLayout.onItemsUpdated(RecyclerView.this, op.positionStart, op.itemCount,
- op.payload);
- break;
- case AdapterHelper.UpdateOp.MOVE:
- mLayout.onItemsMoved(RecyclerView.this, op.positionStart, op.itemCount, 1);
- break;
- }
- }
-
- @Override
- public void onDispatchSecondPass(AdapterHelper.UpdateOp op) {
- dispatchUpdate(op);
- }
-
- @Override
- public void offsetPositionsForAdd(int positionStart, int itemCount) {
- offsetPositionRecordsForInsert(positionStart, itemCount);
- mItemsAddedOrRemoved = true;
- }
-
- @Override
- public void offsetPositionsForMove(int from, int to) {
- offsetPositionRecordsForMove(from, to);
- // should we create mItemsMoved ?
- mItemsAddedOrRemoved = true;
- }
- });
- }
-
- /**
- * RecyclerView can perform several optimizations if it can know in advance that RecyclerView's
- * size is not affected by the adapter contents. RecyclerView can still change its size based
- * on other factors (e.g. its parent's size) but this size calculation cannot depend on the
- * size of its children or contents of its adapter (except the number of items in the adapter).
- *
- * If your use of RecyclerView falls into this category, set this to {@code true}. It will allow
- * RecyclerView to avoid invalidating the whole layout when its adapter contents change.
- *
- * @param hasFixedSize true if adapter changes cannot affect the size of the RecyclerView.
- */
- public void setHasFixedSize(boolean hasFixedSize) {
- mHasFixedSize = hasFixedSize;
- }
-
- /**
- * @return true if the app has specified that changes in adapter content cannot change
- * the size of the RecyclerView itself.
- */
- public boolean hasFixedSize() {
- return mHasFixedSize;
- }
-
- @Override
- public void setClipToPadding(boolean clipToPadding) {
- if (clipToPadding != mClipToPadding) {
- invalidateGlows();
- }
- mClipToPadding = clipToPadding;
- super.setClipToPadding(clipToPadding);
- if (mFirstLayoutComplete) {
- requestLayout();
- }
- }
-
- /**
- * Returns whether this RecyclerView will clip its children to its padding, and resize (but
- * not clip) any EdgeEffect to the padded region, if padding is present.
- *
- * By default, children are clipped to the padding of their parent
- * RecyclerView. This clipping behavior is only enabled if padding is non-zero.
- *
- * @return true if this RecyclerView clips children to its padding and resizes (but doesn't
- * clip) any EdgeEffect to the padded region, false otherwise.
- * @attr name android:clipToPadding
- */
- @Override
- public boolean getClipToPadding() {
- return mClipToPadding;
- }
-
- /**
- * Configure the scrolling touch slop for a specific use case.
- *
- * Set up the RecyclerView's scrolling motion threshold based on common usages.
- * Valid arguments are {@link #TOUCH_SLOP_DEFAULT} and {@link #TOUCH_SLOP_PAGING}.
- *
- * @param slopConstant One of the TOUCH_SLOP_ constants representing
- * the intended usage of this RecyclerView
- */
- public void setScrollingTouchSlop(int slopConstant) {
- final ViewConfiguration vc = ViewConfiguration.get(getContext());
- switch (slopConstant) {
- default:
- Log.w(TAG, "setScrollingTouchSlop(): bad argument constant "
- + slopConstant + "; using default value");
- // fall-through
- case TOUCH_SLOP_DEFAULT:
- mTouchSlop = vc.getScaledTouchSlop();
- break;
-
- case TOUCH_SLOP_PAGING:
- mTouchSlop = vc.getScaledPagingTouchSlop();
- break;
- }
- }
-
- /**
- * Swaps the current adapter with the provided one. It is similar to
- * {@link #setAdapter(Adapter)} but assumes existing adapter and the new adapter uses the same
- * {@link ViewHolder} and does not clear the RecycledViewPool.
- *
- * Note that it still calls onAdapterChanged callbacks.
- *
- * @param adapter The new adapter to set, or null to set no adapter.
- * @param removeAndRecycleExistingViews If set to true, RecyclerView will recycle all existing
- * Views. If adapters have stable ids and/or you want to
- * animate the disappearing views, you may prefer to set
- * this to false.
- * @see #setAdapter(Adapter)
- */
- public void swapAdapter(@Nullable Adapter adapter, boolean removeAndRecycleExistingViews) {
- // bail out if layout is frozen
- setLayoutFrozen(false);
- setAdapterInternal(adapter, true, removeAndRecycleExistingViews);
- processDataSetCompletelyChanged(true);
- requestLayout();
- }
-
- /**
- * Set a new adapter to provide child views on demand.
- *
- * When adapter is changed, all existing views are recycled back to the pool. If the pool has
- * only one adapter, it will be cleared.
- *
- * @param adapter The new adapter to set, or null to set no adapter.
- * @see #swapAdapter(Adapter, boolean)
- */
- public void setAdapter(@Nullable Adapter adapter) {
- // bail out if layout is frozen
- setLayoutFrozen(false);
- setAdapterInternal(adapter, false, true);
- processDataSetCompletelyChanged(false);
- requestLayout();
- }
-
- /**
- * Removes and recycles all views - both those currently attached, and those in the Recycler.
- */
- void removeAndRecycleViews() {
- // end all running animations
- if (mItemAnimator != null) {
- mItemAnimator.endAnimations();
- }
- // Since animations are ended, mLayout.children should be equal to
- // recyclerView.children. This may not be true if item animator's end does not work as
- // expected. (e.g. not release children instantly). It is safer to use mLayout's child
- // count.
- if (mLayout != null) {
- mLayout.removeAndRecycleAllViews(mRecycler);
- mLayout.removeAndRecycleScrapInt(mRecycler);
- }
- // we should clear it here before adapters are swapped to ensure correct callbacks.
- mRecycler.clear();
- }
-
- /**
- * Replaces the current adapter with the new one and triggers listeners.
- *
- * @param adapter The new adapter
- * @param compatibleWithPrevious If true, the new adapter is using the same View Holders and
- * item types with the current adapter (helps us avoid cache
- * invalidation).
- * @param removeAndRecycleViews If true, we'll remove and recycle all existing views. If
- * compatibleWithPrevious is false, this parameter is ignored.
- */
- private void setAdapterInternal(@Nullable Adapter adapter, boolean compatibleWithPrevious,
- boolean removeAndRecycleViews) {
- if (mAdapter != null) {
- mAdapter.unregisterAdapterDataObserver(mObserver);
- mAdapter.onDetachedFromRecyclerView(this);
- }
- if (!compatibleWithPrevious || removeAndRecycleViews) {
- removeAndRecycleViews();
- }
- mAdapterHelper.reset();
- final Adapter oldAdapter = mAdapter;
- mAdapter = adapter;
- if (adapter != null) {
- adapter.registerAdapterDataObserver(mObserver);
- adapter.onAttachedToRecyclerView(this);
- }
- if (mLayout != null) {
- mLayout.onAdapterChanged(oldAdapter, mAdapter);
- }
- mRecycler.onAdapterChanged(oldAdapter, mAdapter, compatibleWithPrevious);
- mState.mStructureChanged = true;
- }
-
- /**
- * Retrieves the previously set adapter or null if no adapter is set.
- *
- * @return The previously set adapter
- * @see #setAdapter(Adapter)
- */
- @Nullable
- public Adapter getAdapter() {
- return mAdapter;
- }
-
- /**
- * Register a listener that will be notified whenever a child view is recycled.
- *
- *
This listener will be called when a LayoutManager or the RecyclerView decides
- * that a child view is no longer needed. If an application associates expensive
- * or heavyweight data with item views, this may be a good place to release
- * or free those resources.
- *
- * @param listener Listener to register, or null to clear
- * @deprecated Use {@link #addRecyclerListener(RecyclerListener)} and
- * {@link #removeRecyclerListener(RecyclerListener)}
- */
- @Deprecated
- public void setRecyclerListener(@Nullable RecyclerListener listener) {
- mRecyclerListener = listener;
- }
-
- /**
- * Register a listener that will be notified whenever a child view is recycled.
- *
- * The listeners will be called when a LayoutManager or the RecyclerView decides
- * that a child view is no longer needed. If an application associates data with
- * the item views being recycled, this may be a good place to release
- * or free those resources.
- *
- * @param listener Listener to register.
- */
- public void addRecyclerListener(@NonNull RecyclerListener listener) {
- checkArgument(listener != null, "'listener' arg cannot "
- + "be null.");
- mRecyclerListeners.add(listener);
- }
-
- /**
- * Removes the provided listener from RecyclerListener list.
- *
- * @param listener Listener to unregister.
- */
- public void removeRecyclerListener(@NonNull RecyclerListener listener) {
- mRecyclerListeners.remove(listener);
- }
-
- /**
- * Return the offset of the RecyclerView's text baseline from the its top
- * boundary. If the LayoutManager of this RecyclerView does not support baseline alignment,
- * this method returns -1.
- *
- * @return the offset of the baseline within the RecyclerView's bounds or -1
- * if baseline alignment is not supported
- */
- @Override
- public int getBaseline() {
- if (mLayout != null) {
- return mLayout.getBaseline();
- } else {
- return super.getBaseline();
- }
- }
-
- /**
- * Register a listener that will be notified whenever a child view is attached to or detached
- * from RecyclerView.
- *
- * This listener will be called when a LayoutManager or the RecyclerView decides
- * that a child view is no longer needed. If an application associates expensive
- * or heavyweight data with item views, this may be a good place to release
- * or free those resources.
- *
- * @param listener Listener to register
- */
- public void addOnChildAttachStateChangeListener(
- @NonNull OnChildAttachStateChangeListener listener) {
- if (mOnChildAttachStateListeners == null) {
- mOnChildAttachStateListeners = new ArrayList<>();
- }
- mOnChildAttachStateListeners.add(listener);
- }
-
- /**
- * Removes the provided listener from child attached state listeners list.
- *
- * @param listener Listener to unregister
- */
- public void removeOnChildAttachStateChangeListener(
- @NonNull OnChildAttachStateChangeListener listener) {
- if (mOnChildAttachStateListeners == null) {
- return;
- }
- mOnChildAttachStateListeners.remove(listener);
- }
-
- /**
- * Removes all listeners that were added via
- * {@link #addOnChildAttachStateChangeListener(OnChildAttachStateChangeListener)}.
- */
- public void clearOnChildAttachStateChangeListeners() {
- if (mOnChildAttachStateListeners != null) {
- mOnChildAttachStateListeners.clear();
- }
- }
-
- /**
- * Set the {@link LayoutManager} that this RecyclerView will use.
- *
- * In contrast to other adapter-backed views such as {@link android.widget.ListView}
- * or {@link android.widget.GridView}, RecyclerView allows client code to provide custom
- * layout arrangements for child views. These arrangements are controlled by the
- * {@link LayoutManager}. A LayoutManager must be provided for RecyclerView to function.
- *
- * Several default strategies are provided for common uses such as lists and grids.
- *
- * @param layout LayoutManager to use
- */
- public void setLayoutManager(@Nullable LayoutManager layout) {
- if (layout == mLayout) {
- return;
- }
- stopScroll();
- // TODO We should do this switch a dispatchLayout pass and animate children. There is a good
- // chance that LayoutManagers will re-use views.
- if (mLayout != null) {
- // end all running animations
- if (mItemAnimator != null) {
- mItemAnimator.endAnimations();
- }
- mLayout.removeAndRecycleAllViews(mRecycler);
- mLayout.removeAndRecycleScrapInt(mRecycler);
- mRecycler.clear();
-
- if (mIsAttached) {
- mLayout.dispatchDetachedFromWindow(this, mRecycler);
- }
- mLayout.setRecyclerView(null);
- mLayout = null;
- } else {
- mRecycler.clear();
- }
- // this is just a defensive measure for faulty item animators.
- mChildHelper.removeAllViewsUnfiltered();
- mLayout = layout;
- if (layout != null) {
- if (layout.mRecyclerView != null) {
- throw new IllegalArgumentException("LayoutManager " + layout
- + " is already attached to a RecyclerView:"
- + layout.mRecyclerView.exceptionLabel());
- }
- mLayout.setRecyclerView(this);
- if (mIsAttached) {
- mLayout.dispatchAttachedToWindow(this);
- }
- }
- mRecycler.updateViewCacheSize();
- requestLayout();
- }
-
- /**
- * Set a {@link OnFlingListener} for this {@link RecyclerView}.
- *
- * If the {@link OnFlingListener} is set then it will receive
- * calls to {@link #fling(int, int)} and will be able to intercept them.
- *
- * @param onFlingListener The {@link OnFlingListener} instance.
- */
- public void setOnFlingListener(@Nullable OnFlingListener onFlingListener) {
- mOnFlingListener = onFlingListener;
- }
-
- /**
- * Get the current {@link OnFlingListener} from this {@link RecyclerView}.
- *
- * @return The {@link OnFlingListener} instance currently set (can be null).
- */
- @Nullable
- public OnFlingListener getOnFlingListener() {
- return mOnFlingListener;
- }
-
- @Override
- protected Parcelable onSaveInstanceState() {
- SavedState state = new SavedState(super.onSaveInstanceState());
- if (mPendingSavedState != null) {
- state.copyFrom(mPendingSavedState);
- } else if (mLayout != null) {
- state.mLayoutState = mLayout.onSaveInstanceState();
- } else {
- state.mLayoutState = null;
- }
-
- return state;
- }
-
- @Override
- protected void onRestoreInstanceState(Parcelable state) {
- if (!(state instanceof SavedState)) {
- super.onRestoreInstanceState(state);
- return;
- }
-
- mPendingSavedState = (SavedState) state;
- super.onRestoreInstanceState(mPendingSavedState.getSuperState());
- // Historically, some app developers have used onRestoreInstanceState(State) in ways it
- // was never intended. For example, some devs have used it to manually set a state they
- // updated themselves such that passing the state here would cause a LayoutManager to
- // receive it and update its internal state accordingly, even if state was already
- // previously restored. Therefore, it is necessary to always call requestLayout to retain
- // the functionality even if it otherwise seems like a strange thing to do.
- // ¯\_(ツ)_/¯
- requestLayout();
- }
-
- /**
- * Override to prevent freezing of any views created by the adapter.
- */
- @Override
- protected void dispatchSaveInstanceState(SparseArray container) {
- dispatchFreezeSelfOnly(container);
- }
-
- /**
- * Override to prevent thawing of any views created by the adapter.
- */
- @Override
- protected void dispatchRestoreInstanceState(SparseArray container) {
- dispatchThawSelfOnly(container);
- }
-
- /**
- * Adds a view to the animatingViews list.
- * mAnimatingViews holds the child views that are currently being kept around
- * purely for the purpose of being animated out of view. They are drawn as a regular
- * part of the child list of the RecyclerView, but they are invisible to the LayoutManager
- * as they are managed separately from the regular child views.
- *
- * @param viewHolder The ViewHolder to be removed
- */
- private void addAnimatingView(ViewHolder viewHolder) {
- final View view = viewHolder.itemView;
- final boolean alreadyParented = view.getParent() == this;
- mRecycler.unscrapView(getChildViewHolder(view));
- if (viewHolder.isTmpDetached()) {
- // re-attach
- mChildHelper.attachViewToParent(view, -1, view.getLayoutParams(), true);
- } else if (!alreadyParented) {
- mChildHelper.addView(view, true);
- } else {
- mChildHelper.hide(view);
- }
- }
-
- /**
- * Removes a view from the animatingViews list.
- *
- * @param view The view to be removed
- * @return true if an animating view is removed
- * @see #addAnimatingView(RecyclerView.ViewHolder)
- */
- boolean removeAnimatingView(View view) {
- startInterceptRequestLayout();
- final boolean removed = mChildHelper.removeViewIfHidden(view);
- if (removed) {
- final ViewHolder viewHolder = getChildViewHolderInt(view);
- mRecycler.unscrapView(viewHolder);
- mRecycler.recycleViewHolderInternal(viewHolder);
- if (sVerboseLoggingEnabled) {
- Log.d(TAG, "after removing animated view: " + view + ", " + this);
- }
- }
- // only clear request eaten flag if we removed the view.
- stopInterceptRequestLayout(!removed);
- return removed;
- }
-
- /**
- * Return the {@link LayoutManager} currently responsible for
- * layout policy for this RecyclerView.
- *
- * @return The currently bound LayoutManager
- */
- @Nullable
- public LayoutManager getLayoutManager() {
- return mLayout;
- }
-
- /**
- * Retrieve this RecyclerView's {@link RecycledViewPool}. This method will never return null;
- * if no pool is set for this view a new one will be created. See
- * {@link #setRecycledViewPool(RecycledViewPool) setRecycledViewPool} for more information.
- *
- * @return The pool used to store recycled item views for reuse.
- * @see #setRecycledViewPool(RecycledViewPool)
- */
- @NonNull
- public RecycledViewPool getRecycledViewPool() {
- return mRecycler.getRecycledViewPool();
- }
-
- /**
- * Recycled view pools allow multiple RecyclerViews to share a common pool of scrap views.
- * This can be useful if you have multiple RecyclerViews with adapters that use the same
- * view types, for example if you have several data sets with the same kinds of item views
- * displayed by a {@link androidx.viewpager.widget.ViewPager}.
- *
- * @param pool Pool to set. If this parameter is null a new pool will be created and used.
- */
- public void setRecycledViewPool(@Nullable RecycledViewPool pool) {
- mRecycler.setRecycledViewPool(pool);
- }
-
- /**
- * Sets a new {@link ViewCacheExtension} to be used by the Recycler.
- *
- * @param extension ViewCacheExtension to be used or null if you want to clear the existing one.
- * @see ViewCacheExtension#getViewForPositionAndType(Recycler, int, int)
- */
- public void setViewCacheExtension(@Nullable ViewCacheExtension extension) {
- mRecycler.setViewCacheExtension(extension);
- }
-
- /**
- * Set the number of offscreen views to retain before adding them to the potentially shared
- * {@link #getRecycledViewPool() recycled view pool}.
- *
- * The offscreen view cache stays aware of changes in the attached adapter, allowing
- * a LayoutManager to reuse those views unmodified without needing to return to the adapter
- * to rebind them.
- *
- * @param size Number of views to cache offscreen before returning them to the general
- * recycled view pool
- */
- public void setItemViewCacheSize(int size) {
- mRecycler.setViewCacheSize(size);
- }
-
- /**
- * Return the current scrolling state of the RecyclerView.
- *
- * @return {@link #SCROLL_STATE_IDLE}, {@link #SCROLL_STATE_DRAGGING} or
- * {@link #SCROLL_STATE_SETTLING}
- */
- public int getScrollState() {
- return mScrollState;
- }
-
- void setScrollState(int state) {
- if (state == mScrollState) {
- return;
- }
- if (sVerboseLoggingEnabled) {
- Log.d(TAG, "setting scroll state to " + state + " from " + mScrollState,
- new Exception());
- }
- mScrollState = state;
- if (state != SCROLL_STATE_SETTLING) {
- stopScrollersInternal();
- }
- dispatchOnScrollStateChanged(state);
- }
-
- /**
- * Add an {@link ItemDecoration} to this RecyclerView. Item decorations can
- * affect both measurement and drawing of individual item views.
- *
- * Item decorations are ordered. Decorations placed earlier in the list will
- * be run/queried/drawn first for their effects on item views. Padding added to views
- * will be nested; a padding added by an earlier decoration will mean further
- * item decorations in the list will be asked to draw/pad within the previous decoration's
- * given area.
- *
- * @param decor Decoration to add
- * @param index Position in the decoration chain to insert this decoration at. If this value
- * is negative the decoration will be added at the end.
- */
- public void addItemDecoration(@NonNull ItemDecoration decor, int index) {
- if (mLayout != null) {
- mLayout.assertNotInLayoutOrScroll("Cannot add item decoration during a scroll or"
- + " layout");
- }
- if (mItemDecorations.isEmpty()) {
- setWillNotDraw(false);
- }
- if (index < 0) {
- mItemDecorations.add(decor);
- } else {
- mItemDecorations.add(index, decor);
- }
- markItemDecorInsetsDirty();
- requestLayout();
- }
-
- /**
- * Add an {@link ItemDecoration} to this RecyclerView. Item decorations can
- * affect both measurement and drawing of individual item views.
- *
- * Item decorations are ordered. Decorations placed earlier in the list will
- * be run/queried/drawn first for their effects on item views. Padding added to views
- * will be nested; a padding added by an earlier decoration will mean further
- * item decorations in the list will be asked to draw/pad within the previous decoration's
- * given area.
- *
- * @param decor Decoration to add
- */
- public void addItemDecoration(@NonNull ItemDecoration decor) {
- addItemDecoration(decor, -1);
- }
-
- /**
- * Returns an {@link ItemDecoration} previously added to this RecyclerView.
- *
- * @param index The index position of the desired ItemDecoration.
- * @return the ItemDecoration at index position
- * @throws IndexOutOfBoundsException on invalid index
- */
- @NonNull
- public ItemDecoration getItemDecorationAt(int index) {
- final int size = getItemDecorationCount();
- if (index < 0 || index >= size) {
- throw new IndexOutOfBoundsException(index + " is an invalid index for size " + size);
- }
-
- return mItemDecorations.get(index);
- }
-
- /**
- * Returns the number of {@link ItemDecoration} currently added to this RecyclerView.
- *
- * @return number of ItemDecorations currently added added to this RecyclerView.
- */
- public int getItemDecorationCount() {
- return mItemDecorations.size();
- }
-
- /**
- * Removes the {@link ItemDecoration} associated with the supplied index position.
- *
- * @param index The index position of the ItemDecoration to be removed.
- */
- public void removeItemDecorationAt(int index) {
- final int size = getItemDecorationCount();
- if (index < 0 || index >= size) {
- throw new IndexOutOfBoundsException(index + " is an invalid index for size " + size);
- }
-
- removeItemDecoration(getItemDecorationAt(index));
- }
-
- /**
- * Remove an {@link ItemDecoration} from this RecyclerView.
- *
- * The given decoration will no longer impact the measurement and drawing of
- * item views.
- *
- * @param decor Decoration to remove
- * @see #addItemDecoration(ItemDecoration)
- */
- public void removeItemDecoration(@NonNull ItemDecoration decor) {
- if (mLayout != null) {
- mLayout.assertNotInLayoutOrScroll("Cannot remove item decoration during a scroll or"
- + " layout");
- }
- mItemDecorations.remove(decor);
- if (mItemDecorations.isEmpty()) {
- setWillNotDraw(getOverScrollMode() == View.OVER_SCROLL_NEVER);
- }
- markItemDecorInsetsDirty();
- requestLayout();
- }
-
- /**
- * Sets the {@link ChildDrawingOrderCallback} to be used for drawing children.
- *
- * See {@link ViewGroup#getChildDrawingOrder(int, int)} for details. Calling this method will
- * always call {@link ViewGroup#setChildrenDrawingOrderEnabled(boolean)}. The parameter will be
- * true if childDrawingOrderCallback is not null, false otherwise.
- *
- * Note that child drawing order may be overridden by View's elevation.
- *
- * @param childDrawingOrderCallback The ChildDrawingOrderCallback to be used by the drawing
- * system.
- */
- public void setChildDrawingOrderCallback(
- @Nullable ChildDrawingOrderCallback childDrawingOrderCallback) {
- if (childDrawingOrderCallback == mChildDrawingOrderCallback) {
- return;
- }
- mChildDrawingOrderCallback = childDrawingOrderCallback;
- setChildrenDrawingOrderEnabled(mChildDrawingOrderCallback != null);
- }
-
- /**
- * Set a listener that will be notified of any changes in scroll state or position.
- *
- * @param listener Listener to set or null to clear
- * @deprecated Use {@link #addOnScrollListener(OnScrollListener)} and
- * {@link #removeOnScrollListener(OnScrollListener)}
- */
- @Deprecated
- public void setOnScrollListener(@Nullable OnScrollListener listener) {
- mScrollListener = listener;
- }
-
- /**
- * Add a listener that will be notified of any changes in scroll state or position.
- *
- *
Components that add a listener should take care to remove it when finished.
- * Other components that take ownership of a view may call {@link #clearOnScrollListeners()}
- * to remove all attached listeners.
- *
- * @param listener listener to set
- */
- public void addOnScrollListener(@NonNull OnScrollListener listener) {
- if (mScrollListeners == null) {
- mScrollListeners = new ArrayList<>();
- }
- mScrollListeners.add(listener);
- }
-
- /**
- * Remove a listener that was notified of any changes in scroll state or position.
- *
- * @param listener listener to set or null to clear
- */
- public void removeOnScrollListener(@NonNull OnScrollListener listener) {
- if (mScrollListeners != null) {
- mScrollListeners.remove(listener);
- }
- }
-
- /**
- * Remove all secondary listener that were notified of any changes in scroll state or position.
- */
- public void clearOnScrollListeners() {
- if (mScrollListeners != null) {
- mScrollListeners.clear();
- }
- }
-
- /**
- * Convenience method to scroll to a certain position.
- *
- * RecyclerView does not implement scrolling logic, rather forwards the call to
- * {@link RecyclerView.LayoutManager#scrollToPosition(int)}
- *
- * @param position Scroll to this adapter position
- * @see RecyclerView.LayoutManager#scrollToPosition(int)
- */
- public void scrollToPosition(int position) {
- if (mLayoutSuppressed) {
- return;
- }
- stopScroll();
- if (mLayout == null) {
- Log.e(TAG, "Cannot scroll to position a LayoutManager set. "
- + "Call setLayoutManager with a non-null argument.");
- return;
- }
- mLayout.scrollToPosition(position);
- awakenScrollBars();
- }
-
- void jumpToPositionForSmoothScroller(int position) {
- if (mLayout == null) {
- return;
- }
-
- // If we are jumping to a position, we are in fact scrolling the contents of the RV, so
- // we should be sure that we are in the settling state.
- setScrollState(SCROLL_STATE_SETTLING);
- mLayout.scrollToPosition(position);
- awakenScrollBars();
- }
-
- /**
- * Starts a smooth scroll to an adapter position.
- *
- * To support smooth scrolling, you must override
- * {@link LayoutManager#smoothScrollToPosition(RecyclerView, State, int)} and create a
- * {@link SmoothScroller}.
- *
- * {@link LayoutManager} is responsible for creating the actual scroll action. If you want to
- * provide a custom smooth scroll logic, override
- * {@link LayoutManager#smoothScrollToPosition(RecyclerView, State, int)} in your
- * LayoutManager.
- *
- * @param position The adapter position to scroll to
- * @see LayoutManager#smoothScrollToPosition(RecyclerView, State, int)
- */
- public void smoothScrollToPosition(int position) {
- if (mLayoutSuppressed) {
- return;
- }
- if (mLayout == null) {
- Log.e(TAG, "Cannot smooth scroll without a LayoutManager set. "
- + "Call setLayoutManager with a non-null argument.");
- return;
- }
- mLayout.smoothScrollToPosition(this, mState, position);
- }
-
- @Override
- public void scrollTo(int x, int y) {
- Log.w(TAG, "RecyclerView does not support scrolling to an absolute position. "
- + "Use scrollToPosition instead");
- }
-
- @Override
- public void scrollBy(int x, int y) {
- if (mLayout == null) {
- Log.e(TAG, "Cannot scroll without a LayoutManager set. "
- + "Call setLayoutManager with a non-null argument.");
- return;
- }
- if (mLayoutSuppressed) {
- return;
- }
- final boolean canScrollHorizontal = mLayout.canScrollHorizontally();
- final boolean canScrollVertical = mLayout.canScrollVertically();
- if (canScrollHorizontal || canScrollVertical) {
- scrollByInternal(canScrollHorizontal ? x : 0, canScrollVertical ? y : 0, null,
- TYPE_TOUCH);
- }
- }
-
- /**
- * Same as {@link RecyclerView#scrollBy(int, int)}, but also participates in nested scrolling.
- * @param x The amount of horizontal scroll requested
- * @param y The amount of vertical scroll requested
- * @see androidx.core.view.NestedScrollingChild
- */
- public void nestedScrollBy(int x, int y) {
- nestedScrollByInternal(x, y, null, TYPE_NON_TOUCH);
- }
-
- /**
- * Similar to {@link RecyclerView#scrollByInternal(int, int, MotionEvent, int)}, but fully
- * participates in nested scrolling "end to end", meaning that it will start nested scrolling,
- * participate in nested scrolling, and then end nested scrolling all within one call.
- * @param x The amount of horizontal scroll requested.
- * @param y The amount of vertical scroll requested.
- * @param motionEvent The originating MotionEvent if any.
- * @param type The type of nested scrolling to engage in (TYPE_TOUCH or TYPE_NON_TOUCH).
- */
- @SuppressWarnings("SameParameterValue")
- private void nestedScrollByInternal(int x, int y, @Nullable MotionEvent motionEvent, int type) {
-
- if (mLayout == null) {
- Log.e(TAG, "Cannot scroll without a LayoutManager set. "
- + "Call setLayoutManager with a non-null argument.");
- return;
- }
- if (mLayoutSuppressed) {
- return;
- }
- mReusableIntPair[0] = 0;
- mReusableIntPair[1] = 0;
- final boolean canScrollHorizontal = mLayout.canScrollHorizontally();
- final boolean canScrollVertical = mLayout.canScrollVertically();
-
- int nestedScrollAxis = ViewCompat.SCROLL_AXIS_NONE;
- if (canScrollHorizontal) {
- nestedScrollAxis |= ViewCompat.SCROLL_AXIS_HORIZONTAL;
- }
- if (canScrollVertical) {
- nestedScrollAxis |= ViewCompat.SCROLL_AXIS_VERTICAL;
- }
-
- // If there is no MotionEvent, treat it as center-aligned edge effect:
- float verticalDisplacement = motionEvent == null ? getHeight() / 2f : motionEvent.getY();
- float horizontalDisplacement = motionEvent == null ? getWidth() / 2f : motionEvent.getX();
- x -= releaseHorizontalGlow(x, verticalDisplacement);
- y -= releaseVerticalGlow(y, horizontalDisplacement);
- startNestedScroll(nestedScrollAxis, type);
- if (dispatchNestedPreScroll(
- canScrollHorizontal ? x : 0,
- canScrollVertical ? y : 0,
- mReusableIntPair, mScrollOffset, type
- )) {
- x -= mReusableIntPair[0];
- y -= mReusableIntPair[1];
- }
-
- scrollByInternal(
- canScrollHorizontal ? x : 0,
- canScrollVertical ? y : 0,
- motionEvent, type);
- if (mGapWorker != null && (x != 0 || y != 0)) {
- mGapWorker.postFromTraversal(this, x, y);
- }
- stopNestedScroll(type);
- }
-
- /**
- * Scrolls the RV by 'dx' and 'dy' via calls to
- * {@link LayoutManager#scrollHorizontallyBy(int, Recycler, State)} and
- * {@link LayoutManager#scrollVerticallyBy(int, Recycler, State)}.
- *
- * Also sets how much of the scroll was actually consumed in 'consumed' parameter (indexes 0 and
- * 1 for the x axis and y axis, respectively).
- *
- * This method should only be called in the context of an existing scroll operation such that
- * any other necessary operations (such as a call to {@link #consumePendingUpdateOperations()})
- * is already handled.
- */
- void scrollStep(int dx, int dy, @Nullable int[] consumed) {
- startInterceptRequestLayout();
- onEnterLayoutOrScroll();
-
- TraceCompat.beginSection(TRACE_SCROLL_TAG);
- fillRemainingScrollValues(mState);
-
- int consumedX = 0;
- int consumedY = 0;
- if (dx != 0) {
- consumedX = mLayout.scrollHorizontallyBy(dx, mRecycler, mState);
- }
- if (dy != 0) {
- consumedY = mLayout.scrollVerticallyBy(dy, mRecycler, mState);
- }
-
- TraceCompat.endSection();
- repositionShadowingViews();
-
- onExitLayoutOrScroll();
- stopInterceptRequestLayout(false);
-
- if (consumed != null) {
- consumed[0] = consumedX;
- consumed[1] = consumedY;
- }
- }
-
- /**
- * Helper method reflect data changes to the state.
- *
- * Adapter changes during a scroll may trigger a crash because scroll assumes no data change
- * but data actually changed.
- *
- * This method consumes all deferred changes to avoid that case.
- */
- void consumePendingUpdateOperations() {
- if (!mFirstLayoutComplete || mDataSetHasChangedAfterLayout) {
- TraceCompat.beginSection(TRACE_ON_DATA_SET_CHANGE_LAYOUT_TAG);
- dispatchLayout();
- TraceCompat.endSection();
- return;
- }
- if (!mAdapterHelper.hasPendingUpdates()) {
- return;
- }
-
- // if it is only an item change (no add-remove-notifyDataSetChanged) we can check if any
- // of the visible items is affected and if not, just ignore the change.
- if (mAdapterHelper.hasAnyUpdateTypes(AdapterHelper.UpdateOp.UPDATE) && !mAdapterHelper
- .hasAnyUpdateTypes(AdapterHelper.UpdateOp.ADD | AdapterHelper.UpdateOp.REMOVE
- | AdapterHelper.UpdateOp.MOVE)) {
- TraceCompat.beginSection(TRACE_HANDLE_ADAPTER_UPDATES_TAG);
- startInterceptRequestLayout();
- onEnterLayoutOrScroll();
- mAdapterHelper.preProcess();
- if (!mLayoutWasDefered) {
- if (hasUpdatedView()) {
- dispatchLayout();
- } else {
- // no need to layout, clean state
- mAdapterHelper.consumePostponedUpdates();
- }
- }
- stopInterceptRequestLayout(true);
- onExitLayoutOrScroll();
- TraceCompat.endSection();
- } else if (mAdapterHelper.hasPendingUpdates()) {
- TraceCompat.beginSection(TRACE_ON_DATA_SET_CHANGE_LAYOUT_TAG);
- dispatchLayout();
- TraceCompat.endSection();
- }
- }
-
- /**
- * @return True if an existing view holder needs to be updated
- */
- private boolean hasUpdatedView() {
- final int childCount = mChildHelper.getChildCount();
- for (int i = 0; i < childCount; i++) {
- final ViewHolder holder = getChildViewHolderInt(mChildHelper.getChildAt(i));
- if (holder == null || holder.shouldIgnore()) {
- continue;
- }
- if (holder.isUpdated()) {
- return true;
- }
- }
- return false;
- }
-
- /**
- * Does not perform bounds checking. Used by internal methods that have already validated input.
- *
- * It also reports any unused scroll request to the related EdgeEffect.
- *
- * @param x The amount of horizontal scroll request
- * @param y The amount of vertical scroll request
- * @param ev The originating MotionEvent, or null if not from a touch event.
- * @param type NestedScrollType, TOUCH or NON_TOUCH.
- * @return Whether any scroll was consumed in either direction.
- */
- boolean scrollByInternal(int x, int y, MotionEvent ev, int type) {
- int unconsumedX = 0;
- int unconsumedY = 0;
- int consumedX = 0;
- int consumedY = 0;
-
- consumePendingUpdateOperations();
- if (mAdapter != null) {
- mReusableIntPair[0] = 0;
- mReusableIntPair[1] = 0;
- scrollStep(x, y, mReusableIntPair);
- consumedX = mReusableIntPair[0];
- consumedY = mReusableIntPair[1];
- unconsumedX = x - consumedX;
- unconsumedY = y - consumedY;
- }
- if (!mItemDecorations.isEmpty()) {
- invalidate();
- }
-
- mReusableIntPair[0] = 0;
- mReusableIntPair[1] = 0;
- dispatchNestedScroll(consumedX, consumedY, unconsumedX, unconsumedY, mScrollOffset,
- type, mReusableIntPair);
- unconsumedX -= mReusableIntPair[0];
- unconsumedY -= mReusableIntPair[1];
- boolean consumedNestedScroll = mReusableIntPair[0] != 0 || mReusableIntPair[1] != 0;
-
- // Update the last touch co-ords, taking any scroll offset into account
- mLastTouchX -= mScrollOffset[0];
- mLastTouchY -= mScrollOffset[1];
- mNestedOffsets[0] += mScrollOffset[0];
- mNestedOffsets[1] += mScrollOffset[1];
-
- if (getOverScrollMode() != View.OVER_SCROLL_NEVER) {
- if (ev != null && !MotionEventCompat.isFromSource(ev, InputDevice.SOURCE_MOUSE)) {
- pullGlows(ev.getX(), unconsumedX, ev.getY(), unconsumedY);
- }
- considerReleasingGlowsOnScroll(x, y);
- }
- if (consumedX != 0 || consumedY != 0) {
- dispatchOnScrolled(consumedX, consumedY);
- }
- if (!awakenScrollBars()) {
- invalidate();
- }
- return consumedNestedScroll || consumedX != 0 || consumedY != 0;
- }
-
- /**
- * If either of the horizontal edge glows are currently active, this consumes part or all of
- * deltaX on the edge glow.
- *
- * @param deltaX The pointer motion, in pixels, in the horizontal direction, positive
- * for moving down and negative for moving up.
- * @param y The vertical position of the pointer.
- * @return The amount of deltaX that has been consumed by the
- * edge glow.
- */
- private int releaseHorizontalGlow(int deltaX, float y) {
- // First allow releasing existing overscroll effect:
- float consumed = 0;
- float displacement = y / getHeight();
- float pullDistance = (float) deltaX / getWidth();
- if (mLeftGlow != null && EdgeEffectCompat.getDistance(mLeftGlow) != 0) {
- if (canScrollHorizontally(-1)) {
- mLeftGlow.onRelease();
- } else {
- consumed = -EdgeEffectCompat.onPullDistance(mLeftGlow, -pullDistance,
- 1 - displacement);
- if (EdgeEffectCompat.getDistance(mLeftGlow) == 0) {
- mLeftGlow.onRelease();
- }
- }
- invalidate();
- } else if (mRightGlow != null && EdgeEffectCompat.getDistance(mRightGlow) != 0) {
- if (canScrollHorizontally(1)) {
- mRightGlow.onRelease();
- } else {
- consumed = EdgeEffectCompat.onPullDistance(mRightGlow, pullDistance, displacement);
- if (EdgeEffectCompat.getDistance(mRightGlow) == 0) {
- mRightGlow.onRelease();
- }
- }
- invalidate();
- }
- return Math.round(consumed * getWidth());
- }
-
- /**
- * If either of the vertical edge glows are currently active, this consumes part or all of
- * deltaY on the edge glow.
- *
- * @param deltaY The pointer motion, in pixels, in the vertical direction, positive
- * for moving down and negative for moving up.
- * @param x The vertical position of the pointer.
- * @return The amount of deltaY that has been consumed by the
- * edge glow.
- */
- private int releaseVerticalGlow(int deltaY, float x) {
- // First allow releasing existing overscroll effect:
- float consumed = 0;
- float displacement = x / getWidth();
- float pullDistance = (float) deltaY / getHeight();
- if (mTopGlow != null && EdgeEffectCompat.getDistance(mTopGlow) != 0) {
- if (canScrollVertically(-1)) {
- mTopGlow.onRelease();
- } else {
- consumed = -EdgeEffectCompat.onPullDistance(mTopGlow, -pullDistance, displacement);
- if (EdgeEffectCompat.getDistance(mTopGlow) == 0) {
- mTopGlow.onRelease();
- }
- }
- invalidate();
- } else if (mBottomGlow != null && EdgeEffectCompat.getDistance(mBottomGlow) != 0) {
- if (canScrollVertically(1)) {
- mBottomGlow.onRelease();
- } else {
- consumed = EdgeEffectCompat.onPullDistance(mBottomGlow, pullDistance,
- 1 - displacement);
- if (EdgeEffectCompat.getDistance(mBottomGlow) == 0) {
- mBottomGlow.onRelease();
- }
- }
- invalidate();
- }
- return Math.round(consumed * getHeight());
- }
-
- /**
- *
Compute the horizontal offset of the horizontal scrollbar's thumb within the horizontal
- * range. This value is used to compute the length of the thumb within the scrollbar's track.
- *
- *
- * The range is expressed in arbitrary units that must be the same as the units used by
- * {@link #computeHorizontalScrollRange()} and {@link #computeHorizontalScrollExtent()}.
- *
- * Default implementation returns 0.
- *
- * If you want to support scroll bars, override
- * {@link RecyclerView.LayoutManager#computeHorizontalScrollOffset(RecyclerView.State)} in your
- * LayoutManager.
- *
- * @return The horizontal offset of the scrollbar's thumb
- * @see RecyclerView.LayoutManager#computeHorizontalScrollOffset
- * (RecyclerView.State)
- */
- @Override
- public int computeHorizontalScrollOffset() {
- if (mLayout == null) {
- return 0;
- }
- return mLayout.canScrollHorizontally() ? mLayout.computeHorizontalScrollOffset(mState) : 0;
- }
-
- /**
- * Compute the horizontal extent of the horizontal scrollbar's thumb within the
- * horizontal range. This value is used to compute the length of the thumb within the
- * scrollbar's track.
- *
- * The range is expressed in arbitrary units that must be the same as the units used by
- * {@link #computeHorizontalScrollRange()} and {@link #computeHorizontalScrollOffset()}.
- *
- * Default implementation returns 0.
- *
- * If you want to support scroll bars, override
- * {@link RecyclerView.LayoutManager#computeHorizontalScrollExtent(RecyclerView.State)} in your
- * LayoutManager.
- *
- * @return The horizontal extent of the scrollbar's thumb
- * @see RecyclerView.LayoutManager#computeHorizontalScrollExtent(RecyclerView.State)
- */
- @Override
- public int computeHorizontalScrollExtent() {
- if (mLayout == null) {
- return 0;
- }
- return mLayout.canScrollHorizontally() ? mLayout.computeHorizontalScrollExtent(mState) : 0;
- }
-
- /**
- * Compute the horizontal range that the horizontal scrollbar represents.
- *
- * The range is expressed in arbitrary units that must be the same as the units used by
- * {@link #computeHorizontalScrollExtent()} and {@link #computeHorizontalScrollOffset()}.
- *
- * Default implementation returns 0.
- *
- * If you want to support scroll bars, override
- * {@link RecyclerView.LayoutManager#computeHorizontalScrollRange(RecyclerView.State)} in your
- * LayoutManager.
- *
- * @return The total horizontal range represented by the vertical scrollbar
- * @see RecyclerView.LayoutManager#computeHorizontalScrollRange(RecyclerView.State)
- */
- @Override
- public int computeHorizontalScrollRange() {
- if (mLayout == null) {
- return 0;
- }
- return mLayout.canScrollHorizontally() ? mLayout.computeHorizontalScrollRange(mState) : 0;
- }
-
- /**
- * Compute the vertical offset of the vertical scrollbar's thumb within the vertical range.
- * This value is used to compute the length of the thumb within the scrollbar's track.
- *
- * The range is expressed in arbitrary units that must be the same as the units used by
- * {@link #computeVerticalScrollRange()} and {@link #computeVerticalScrollExtent()}.
- *
- * Default implementation returns 0.
- *
- * If you want to support scroll bars, override
- * {@link RecyclerView.LayoutManager#computeVerticalScrollOffset(RecyclerView.State)} in your
- * LayoutManager.
- *
- * @return The vertical offset of the scrollbar's thumb
- * @see RecyclerView.LayoutManager#computeVerticalScrollOffset
- * (RecyclerView.State)
- */
- @Override
- public int computeVerticalScrollOffset() {
- if (mLayout == null) {
- return 0;
- }
- return mLayout.canScrollVertically() ? mLayout.computeVerticalScrollOffset(mState) : 0;
- }
-
- /**
- * Compute the vertical extent of the vertical scrollbar's thumb within the vertical range.
- * This value is used to compute the length of the thumb within the scrollbar's track.
- *
- * The range is expressed in arbitrary units that must be the same as the units used by
- * {@link #computeVerticalScrollRange()} and {@link #computeVerticalScrollOffset()}.
- *
- * Default implementation returns 0.
- *
- * If you want to support scroll bars, override
- * {@link RecyclerView.LayoutManager#computeVerticalScrollExtent(RecyclerView.State)} in your
- * LayoutManager.
- *
- * @return The vertical extent of the scrollbar's thumb
- * @see RecyclerView.LayoutManager#computeVerticalScrollExtent(RecyclerView.State)
- */
- @Override
- public int computeVerticalScrollExtent() {
- if (mLayout == null) {
- return 0;
- }
- return mLayout.canScrollVertically() ? mLayout.computeVerticalScrollExtent(mState) : 0;
- }
-
- /**
- * Compute the vertical range that the vertical scrollbar represents.
- *
- * The range is expressed in arbitrary units that must be the same as the units used by
- * {@link #computeVerticalScrollExtent()} and {@link #computeVerticalScrollOffset()}.
- *
- * Default implementation returns 0.
- *
- * If you want to support scroll bars, override
- * {@link RecyclerView.LayoutManager#computeVerticalScrollRange(RecyclerView.State)} in your
- * LayoutManager.
- *
- * @return The total vertical range represented by the vertical scrollbar
- * @see RecyclerView.LayoutManager#computeVerticalScrollRange(RecyclerView.State)
- */
- @Override
- public int computeVerticalScrollRange() {
- if (mLayout == null) {
- return 0;
- }
- return mLayout.canScrollVertically() ? mLayout.computeVerticalScrollRange(mState) : 0;
- }
-
- /**
- * This method should be called before any code that may trigger a child view to cause a call to
- * {@link RecyclerView#requestLayout()}. Doing so enables {@link RecyclerView} to avoid
- * reacting to additional redundant calls to {@link #requestLayout()}.
- *
- * A call to this method must always be accompanied by a call to
- * {@link #stopInterceptRequestLayout(boolean)} that follows the code that may trigger a
- * child View to cause a call to {@link RecyclerView#requestLayout()}.
- *
- * @see #stopInterceptRequestLayout(boolean)
- */
- void startInterceptRequestLayout() {
- mInterceptRequestLayoutDepth++;
- if (mInterceptRequestLayoutDepth == 1 && !mLayoutSuppressed) {
- mLayoutWasDefered = false;
- }
- }
-
- /**
- * This method should be called after any code that may trigger a child view to cause a call to
- * {@link RecyclerView#requestLayout()}.
- *
- * A call to this method must always be accompanied by a call to
- * {@link #startInterceptRequestLayout()} that precedes the code that may trigger a child
- * View to cause a call to {@link RecyclerView#requestLayout()}.
- *
- * @see #startInterceptRequestLayout()
- */
- void stopInterceptRequestLayout(boolean performLayoutChildren) {
- if (mInterceptRequestLayoutDepth < 1) {
- //noinspection PointlessBooleanExpression
- if (sDebugAssertionsEnabled) {
- throw new IllegalStateException("stopInterceptRequestLayout was called more "
- + "times than startInterceptRequestLayout."
- + exceptionLabel());
- }
- mInterceptRequestLayoutDepth = 1;
- }
- if (!performLayoutChildren && !mLayoutSuppressed) {
- // Reset the layout request eaten counter.
- // This is necessary since eatRequest calls can be nested in which case the other
- // call will override the inner one.
- // for instance:
- // eat layout for process adapter updates
- // eat layout for dispatchLayout
- // a bunch of req layout calls arrive
-
- mLayoutWasDefered = false;
- }
- if (mInterceptRequestLayoutDepth == 1) {
- // when layout is frozen we should delay dispatchLayout()
- if (performLayoutChildren && mLayoutWasDefered && !mLayoutSuppressed
- && mLayout != null && mAdapter != null) {
- dispatchLayout();
- }
- if (!mLayoutSuppressed) {
- mLayoutWasDefered = false;
- }
- }
- mInterceptRequestLayoutDepth--;
- }
-
- /**
- * Tells this RecyclerView to suppress all layout and scroll calls until layout
- * suppression is disabled with a later call to suppressLayout(false).
- * When layout suppression is disabled, a requestLayout() call is sent
- * if requestLayout() was attempted while layout was being suppressed.
- *
- * In addition to the layout suppression {@link #smoothScrollBy(int, int)},
- * {@link #scrollBy(int, int)}, {@link #scrollToPosition(int)} and
- * {@link #smoothScrollToPosition(int)} are dropped; TouchEvents and GenericMotionEvents are
- * dropped; {@link LayoutManager#onFocusSearchFailed(View, int, Recycler, State)} will not be
- * called.
- *
- *
- * suppressLayout(true) does not prevent app from directly calling {@link
- * LayoutManager#scrollToPosition(int)}, {@link LayoutManager#smoothScrollToPosition(
- *RecyclerView, State, int)}.
- *
- * {@link #setAdapter(Adapter)} and {@link #swapAdapter(Adapter, boolean)} will automatically
- * stop suppressing.
- *
- * Note: Running ItemAnimator is not stopped automatically, it's caller's
- * responsibility to call ItemAnimator.end().
- *
- * @param suppress true to suppress layout and scroll, false to re-enable.
- */
- @Override
- public final void suppressLayout(boolean suppress) {
- if (suppress != mLayoutSuppressed) {
- assertNotInLayoutOrScroll("Do not suppressLayout in layout or scroll");
- if (!suppress) {
- mLayoutSuppressed = false;
- if (mLayoutWasDefered && mLayout != null && mAdapter != null) {
- requestLayout();
- }
- mLayoutWasDefered = false;
- } else {
- final long now = SystemClock.uptimeMillis();
- MotionEvent cancelEvent = MotionEvent.obtain(now, now,
- MotionEvent.ACTION_CANCEL, 0.0f, 0.0f, 0);
- onTouchEvent(cancelEvent);
- mLayoutSuppressed = true;
- mIgnoreMotionEventTillDown = true;
- stopScroll();
- }
- }
- }
-
- /**
- * Returns whether layout and scroll calls on this container are currently being
- * suppressed, due to an earlier call to {@link #suppressLayout(boolean)}.
- *
- * @return true if layout and scroll are currently suppressed, false otherwise.
- */
- @Override
- public final boolean isLayoutSuppressed() {
- return mLayoutSuppressed;
- }
-
- /**
- * Enable or disable layout and scroll. After setLayoutFrozen(true) is called,
- * Layout requests will be postponed until setLayoutFrozen(false) is called;
- * child views are not updated when RecyclerView is frozen, {@link #smoothScrollBy(int, int)},
- * {@link #scrollBy(int, int)}, {@link #scrollToPosition(int)} and
- * {@link #smoothScrollToPosition(int)} are dropped; TouchEvents and GenericMotionEvents are
- * dropped; {@link LayoutManager#onFocusSearchFailed(View, int, Recycler, State)} will not be
- * called.
- *
- *
- * setLayoutFrozen(true) does not prevent app from directly calling {@link
- * LayoutManager#scrollToPosition(int)}, {@link LayoutManager#smoothScrollToPosition(
- *RecyclerView, State, int)}.
- *
- * {@link #setAdapter(Adapter)} and {@link #swapAdapter(Adapter, boolean)} will automatically
- * stop frozen.
- *
- * Note: Running ItemAnimator is not stopped automatically, it's caller's
- * responsibility to call ItemAnimator.end().
- *
- * @param frozen true to freeze layout and scroll, false to re-enable.
- * @deprecated Use {@link #suppressLayout(boolean)}.
- */
- @Deprecated
- public void setLayoutFrozen(boolean frozen) {
- suppressLayout(frozen);
- }
-
- /**
- * @return true if layout and scroll are frozen
- * @deprecated Use {@link #isLayoutSuppressed()}.
- */
- @Deprecated
- public boolean isLayoutFrozen() {
- return isLayoutSuppressed();
- }
-
- /**
- * @deprecated Use {@link #setItemAnimator(ItemAnimator)} ()}.
- */
- @Deprecated
- @Override
- public void setLayoutTransition(LayoutTransition transition) {
- if (Build.VERSION.SDK_INT < 18) {
- // Transitions on APIs below 18 are using an empty LayoutTransition as a replacement
- // for suppressLayout(true) and null LayoutTransition to then unsuppress it.
- // We can detect this cases and use our suppressLayout() implementation instead.
- if (transition == null) {
- suppressLayout(false);
- return;
- } else {
- int layoutTransitionChanging = 4; // LayoutTransition.CHANGING (Added in API 16)
- if (transition.getAnimator(LayoutTransition.CHANGE_APPEARING) == null
- && transition.getAnimator(LayoutTransition.CHANGE_DISAPPEARING) == null
- && transition.getAnimator(LayoutTransition.APPEARING) == null
- && transition.getAnimator(LayoutTransition.DISAPPEARING) == null
- && transition.getAnimator(layoutTransitionChanging) == null) {
- suppressLayout(true);
- return;
- }
- }
- }
-
- if (transition == null) {
- super.setLayoutTransition(null);
- } else {
- throw new IllegalArgumentException("Providing a LayoutTransition into RecyclerView is "
- + "not supported. Please use setItemAnimator() instead for animating changes "
- + "to the items in this RecyclerView");
- }
- }
-
- /**
- * Animate a scroll by the given amount of pixels along either axis.
- *
- * @param dx Pixels to scroll horizontally
- * @param dy Pixels to scroll vertically
- */
- public void smoothScrollBy(@Px int dx, @Px int dy) {
- smoothScrollBy(dx, dy, null);
- }
-
- /**
- * Animate a scroll by the given amount of pixels along either axis.
- *
- * @param dx Pixels to scroll horizontally
- * @param dy Pixels to scroll vertically
- * @param interpolator {@link Interpolator} to be used for scrolling. If it is
- * {@code null}, RecyclerView will use an internal default interpolator.
- */
- public void smoothScrollBy(@Px int dx, @Px int dy, @Nullable Interpolator interpolator) {
- smoothScrollBy(dx, dy, interpolator, UNDEFINED_DURATION);
- }
-
- /**
- * Smooth scrolls the RecyclerView by a given distance.
- *
- * @param dx x distance in pixels.
- * @param dy y distance in pixels.
- * @param interpolator {@link Interpolator} to be used for scrolling. If it is {@code null},
- * RecyclerView will use an internal default interpolator.
- * @param duration Duration of the animation in milliseconds. Set to
- * {@link #UNDEFINED_DURATION}
- * to have the duration be automatically calculated based on an internally
- * defined standard initial velocity. A duration less than 1 (that does not
- * equal UNDEFINED_DURATION), will result in a call to
- * {@link #scrollBy(int, int)}.
- */
- public void smoothScrollBy(@Px int dx, @Px int dy, @Nullable Interpolator interpolator,
- int duration) {
- smoothScrollBy(dx, dy, interpolator, duration, false);
- }
-
- /**
- * Internal smooth scroll by implementation that currently has some tricky logic related to it's
- * parameters.
- *
- * For scrolling to occur, on either dimension, dx or dy must not be equal to 0 and the
- * {@link LayoutManager} must support scrolling in a direction for which the value is not 0.
- * For smooth scrolling to occur, scrolling must occur and the duration must be equal to
- * {@link #UNDEFINED_DURATION} or greater than 0.
- * For scrolling to occur with nested scrolling, smooth scrolling must occur and
- * {@code withNestedScrolling} must be {@code true}. This could be updated, but it would
- * require that {@link #scrollBy(int, int)} be implemented such that it too can handle nested
- * scrolling.
- *
- *
- * @param dx x distance in pixels.
- * @param dy y distance in pixels.
- * @param interpolator {@link Interpolator} to be used for scrolling. If it is {@code
- * null},
- * RecyclerView will use an internal default interpolator.
- * @param duration Duration of the animation in milliseconds. Set to
- * {@link #UNDEFINED_DURATION}
- * to have the duration be automatically calculated based on an
- * internally
- * defined standard initial velocity. A duration less than 1 (that
- * does not
- * equal UNDEFINED_DURATION), will result in a call to
- * {@link #scrollBy(int, int)}.
- * @param withNestedScrolling True to perform the smooth scroll with nested scrolling. If
- * {@code duration} is less than 0 and not equal to
- * {@link #UNDEFINED_DURATION}, smooth scrolling will not occur and
- * thus no nested scrolling will occur.
- */
- // Should be considered private. Not private to avoid synthetic accessor.
- void smoothScrollBy(@Px int dx, @Px int dy, @Nullable Interpolator interpolator,
- int duration, boolean withNestedScrolling) {
- if (mLayout == null) {
- Log.e(TAG, "Cannot smooth scroll without a LayoutManager set. "
- + "Call setLayoutManager with a non-null argument.");
- return;
- }
- if (mLayoutSuppressed) {
- return;
- }
- if (!mLayout.canScrollHorizontally()) {
- dx = 0;
- }
- if (!mLayout.canScrollVertically()) {
- dy = 0;
- }
- if (dx != 0 || dy != 0) {
- boolean durationSuggestsAnimation = duration == UNDEFINED_DURATION || duration > 0;
- if (durationSuggestsAnimation) {
- if (withNestedScrolling) {
- int nestedScrollAxis = ViewCompat.SCROLL_AXIS_NONE;
- if (dx != 0) {
- nestedScrollAxis |= ViewCompat.SCROLL_AXIS_HORIZONTAL;
- }
- if (dy != 0) {
- nestedScrollAxis |= ViewCompat.SCROLL_AXIS_VERTICAL;
- }
- startNestedScroll(nestedScrollAxis, TYPE_NON_TOUCH);
- }
- mViewFlinger.smoothScrollBy(dx, dy, duration, interpolator);
- } else {
- scrollBy(dx, dy);
- }
- }
- }
-
- /**
- * Begin a standard fling with an initial velocity along each axis in pixels per second.
- * If the velocity given is below the system-defined minimum this method will return false
- * and no fling will occur.
- *
- * @param velocityX Initial horizontal velocity in pixels per second
- * @param velocityY Initial vertical velocity in pixels per second
- * @return true if the fling was started, false if the velocity was too low to fling or
- * LayoutManager does not support scrolling in the axis fling is issued.
- * @see LayoutManager#canScrollVertically()
- * @see LayoutManager#canScrollHorizontally()
- */
- public boolean fling(int velocityX, int velocityY) {
- if (mLayout == null) {
- Log.e(TAG, "Cannot fling without a LayoutManager set. "
- + "Call setLayoutManager with a non-null argument.");
- return false;
- }
- if (mLayoutSuppressed) {
- return false;
- }
-
- final boolean canScrollHorizontal = mLayout.canScrollHorizontally();
- final boolean canScrollVertical = mLayout.canScrollVertically();
-
- if (!canScrollHorizontal || Math.abs(velocityX) < mMinFlingVelocity) {
- velocityX = 0;
- }
- if (!canScrollVertical || Math.abs(velocityY) < mMinFlingVelocity) {
- velocityY = 0;
- }
- if (velocityX == 0 && velocityY == 0) {
- // If we don't have any velocity, return false
- return false;
- }
-
- // Flinging while the edge effect is active should affect the edge effect,
- // not scrolling.
- int flingX = 0;
- int flingY = 0;
- if (velocityX != 0) {
- if (mLeftGlow != null && EdgeEffectCompat.getDistance(mLeftGlow) != 0) {
- if (shouldAbsorb(mLeftGlow, -velocityX, getWidth())) {
- mLeftGlow.onAbsorb(-velocityX);
- } else {
- flingX = velocityX;
- }
- velocityX = 0;
- } else if (mRightGlow != null && EdgeEffectCompat.getDistance(mRightGlow) != 0) {
- if (shouldAbsorb(mRightGlow, velocityX, getWidth())) {
- mRightGlow.onAbsorb(velocityX);
- } else {
- flingX = velocityX;
- }
- velocityX = 0;
- }
- }
- if (velocityY != 0) {
- if (mTopGlow != null && EdgeEffectCompat.getDistance(mTopGlow) != 0) {
- if (shouldAbsorb(mTopGlow, -velocityY, getHeight())) {
- mTopGlow.onAbsorb(-velocityY);
- } else {
- flingY = velocityY;
- }
- velocityY = 0;
- } else if (mBottomGlow != null && EdgeEffectCompat.getDistance(mBottomGlow) != 0) {
- if (shouldAbsorb(mBottomGlow, velocityY, getHeight())) {
- mBottomGlow.onAbsorb(velocityY);
- } else {
- flingY = velocityY;
- }
- velocityY = 0;
- }
- }
- if (flingX != 0 || flingY != 0) {
- flingX = Math.max(-mMaxFlingVelocity, Math.min(flingX, mMaxFlingVelocity));
- flingY = Math.max(-mMaxFlingVelocity, Math.min(flingY, mMaxFlingVelocity));
- mViewFlinger.fling(flingX, flingY);
- }
- if (velocityX == 0 && velocityY == 0) {
- return flingX != 0 || flingY != 0;
- }
-
- if (!dispatchNestedPreFling(velocityX, velocityY)) {
- final boolean canScroll = canScrollHorizontal || canScrollVertical;
- dispatchNestedFling(velocityX, velocityY, canScroll);
-
- if (mOnFlingListener != null && mOnFlingListener.onFling(velocityX, velocityY)) {
- return true;
- }
-
- if (canScroll) {
- int nestedScrollAxis = ViewCompat.SCROLL_AXIS_NONE;
- if (canScrollHorizontal) {
- nestedScrollAxis |= ViewCompat.SCROLL_AXIS_HORIZONTAL;
- }
- if (canScrollVertical) {
- nestedScrollAxis |= ViewCompat.SCROLL_AXIS_VERTICAL;
- }
- startNestedScroll(nestedScrollAxis, TYPE_NON_TOUCH);
-
- velocityX = Math.max(-mMaxFlingVelocity, Math.min(velocityX, mMaxFlingVelocity));
- velocityY = Math.max(-mMaxFlingVelocity, Math.min(velocityY, mMaxFlingVelocity));
- mViewFlinger.fling(velocityX, velocityY);
- return true;
- }
- }
- return false;
- }
-
- /**
- * Returns true if edgeEffect should call onAbsorb() with veclocity or false if it should
- * animate with a fling. It will animate with a fling if the velocity will remove the
- * EdgeEffect through its normal operation.
- *
- * @param edgeEffect The EdgeEffect that might absorb the velocity.
- * @param velocity The velocity of the fling motion
- * @param size The width or height of the RecyclerView, depending on the edge that the
- * EdgeEffect is on.
- * @return true if the velocity should be absorbed or false if it should be flung.
- */
- private boolean shouldAbsorb(@NonNull EdgeEffect edgeEffect, int velocity, int size) {
- if (velocity > 0) {
- return true;
- }
- float distance = EdgeEffectCompat.getDistance(edgeEffect) * size;
-
- // This is flinging without the spring, so let's see if it will fling past the overscroll
- float flingDistance = getSplineFlingDistance(-velocity);
-
- return flingDistance < distance;
- }
-
- /**
- * If mLeftGlow or mRightGlow is currently active and the motion will remove some of the
- * stretch, this will consume any of unconsumedX that the glow can. If the motion would
- * increase the stretch, or the EdgeEffect isn't a stretch, then nothing will be consumed.
- *
- * @param unconsumedX The horizontal delta that might be consumed by the horizontal EdgeEffects
- * @return The remaining unconsumed delta after the edge effects have consumed.
- */
- int consumeFlingInHorizontalStretch(int unconsumedX) {
- return consumeFlingInStretch(unconsumedX, mLeftGlow, mRightGlow, getWidth());
- }
-
- /**
- * If mTopGlow or mBottomGlow is currently active and the motion will remove some of the
- * stretch, this will consume any of unconsumedY that the glow can. If the motion would
- * increase the stretch, or the EdgeEffect isn't a stretch, then nothing will be consumed.
- *
- * @param unconsumedY The vertical delta that might be consumed by the vertical EdgeEffects
- * @return The remaining unconsumed delta after the edge effects have consumed.
- */
- int consumeFlingInVerticalStretch(int unconsumedY) {
- return consumeFlingInStretch(unconsumedY, mTopGlow, mBottomGlow, getHeight());
- }
-
- /**
- * Used by consumeFlingInHorizontalStretch() and consumeFlinInVerticalStretch() for
- * consuming deltas from EdgeEffects
- * @param unconsumed The unconsumed delta that the EdgeEffets may consume
- * @param startGlow The start (top or left) EdgeEffect
- * @param endGlow The end (bottom or right) EdgeEffect
- * @param size The width or height of the container, depending on whether this is for
- * horizontal or vertical EdgeEffects
- * @return The unconsumed delta after the EdgeEffects have had an opportunity to consume.
- */
- private int consumeFlingInStretch(
- int unconsumed,
- EdgeEffect startGlow,
- EdgeEffect endGlow,
- int size
- ) {
- if (unconsumed > 0 && startGlow != null && EdgeEffectCompat.getDistance(startGlow) != 0f) {
- float deltaDistance = -unconsumed * FLING_DESTRETCH_FACTOR / size;
- int consumed = Math.round(-size / FLING_DESTRETCH_FACTOR
- * EdgeEffectCompat.onPullDistance(startGlow, deltaDistance, 0.5f));
- if (consumed != unconsumed) {
- startGlow.finish();
- }
- return unconsumed - consumed;
- }
- if (unconsumed < 0 && endGlow != null && EdgeEffectCompat.getDistance(endGlow) != 0f) {
- float deltaDistance = unconsumed * FLING_DESTRETCH_FACTOR / size;
- int consumed = Math.round(size / FLING_DESTRETCH_FACTOR
- * EdgeEffectCompat.onPullDistance(endGlow, deltaDistance, 0.5f));
- if (consumed != unconsumed) {
- endGlow.finish();
- }
- return unconsumed - consumed;
- }
- return unconsumed;
- }
-
- /**
- * Stop any current scroll in progress, such as one started by
- * {@link #smoothScrollBy(int, int)}, {@link #fling(int, int)} or a touch-initiated fling.
- */
- public void stopScroll() {
- setScrollState(SCROLL_STATE_IDLE);
- stopScrollersInternal();
- }
-
- /**
- * Similar to {@link #stopScroll()} but does not set the state.
- */
- private void stopScrollersInternal() {
- mViewFlinger.stop();
- if (mLayout != null) {
- mLayout.stopSmoothScroller();
- }
- }
-
- /**
- * Returns the minimum velocity to start a fling.
- *
- * @return The minimum velocity to start a fling
- */
- public int getMinFlingVelocity() {
- return mMinFlingVelocity;
- }
-
-
- /**
- * Returns the maximum fling velocity used by this RecyclerView.
- *
- * @return The maximum fling velocity used by this RecyclerView.
- */
- public int getMaxFlingVelocity() {
- return mMaxFlingVelocity;
- }
-
- /**
- * Apply a pull to relevant overscroll glow effects
- */
- private void pullGlows(float x, float overscrollX, float y, float overscrollY) {
- boolean invalidate = false;
- if (overscrollX < 0) {
- ensureLeftGlow();
- EdgeEffectCompat.onPullDistance(mLeftGlow, -overscrollX / getWidth(),
- 1f - y / getHeight());
- invalidate = true;
- } else if (overscrollX > 0) {
- ensureRightGlow();
- EdgeEffectCompat.onPullDistance(mRightGlow, overscrollX / getWidth(), y / getHeight());
- invalidate = true;
- }
-
- if (overscrollY < 0) {
- ensureTopGlow();
- EdgeEffectCompat.onPullDistance(mTopGlow, -overscrollY / getHeight(), x / getWidth());
- invalidate = true;
- } else if (overscrollY > 0) {
- ensureBottomGlow();
- EdgeEffectCompat.onPullDistance(mBottomGlow, overscrollY / getHeight(),
- 1f - x / getWidth());
- invalidate = true;
- }
-
- if (invalidate || overscrollX != 0 || overscrollY != 0) {
- ViewCompat.postInvalidateOnAnimation(this);
- }
- }
-
- private void releaseGlows() {
- boolean needsInvalidate = false;
- if (mLeftGlow != null) {
- mLeftGlow.onRelease();
- needsInvalidate = mLeftGlow.isFinished();
- }
- if (mTopGlow != null) {
- mTopGlow.onRelease();
- needsInvalidate |= mTopGlow.isFinished();
- }
- if (mRightGlow != null) {
- mRightGlow.onRelease();
- needsInvalidate |= mRightGlow.isFinished();
- }
- if (mBottomGlow != null) {
- mBottomGlow.onRelease();
- needsInvalidate |= mBottomGlow.isFinished();
- }
- if (needsInvalidate) {
- ViewCompat.postInvalidateOnAnimation(this);
- }
- }
-
- void considerReleasingGlowsOnScroll(int dx, int dy) {
- boolean needsInvalidate = false;
- if (mLeftGlow != null && !mLeftGlow.isFinished() && dx > 0) {
- mLeftGlow.onRelease();
- needsInvalidate = mLeftGlow.isFinished();
- }
- if (mRightGlow != null && !mRightGlow.isFinished() && dx < 0) {
- mRightGlow.onRelease();
- needsInvalidate |= mRightGlow.isFinished();
- }
- if (mTopGlow != null && !mTopGlow.isFinished() && dy > 0) {
- mTopGlow.onRelease();
- needsInvalidate |= mTopGlow.isFinished();
- }
- if (mBottomGlow != null && !mBottomGlow.isFinished() && dy < 0) {
- mBottomGlow.onRelease();
- needsInvalidate |= mBottomGlow.isFinished();
- }
- if (needsInvalidate) {
- ViewCompat.postInvalidateOnAnimation(this);
- }
- }
-
- void absorbGlows(int velocityX, int velocityY) {
- if (velocityX < 0) {
- ensureLeftGlow();
- if (mLeftGlow.isFinished()) {
- mLeftGlow.onAbsorb(-velocityX);
- }
- } else if (velocityX > 0) {
- ensureRightGlow();
- if (mRightGlow.isFinished()) {
- mRightGlow.onAbsorb(velocityX);
- }
- }
-
- if (velocityY < 0) {
- ensureTopGlow();
- if (mTopGlow.isFinished()) {
- mTopGlow.onAbsorb(-velocityY);
- }
- } else if (velocityY > 0) {
- ensureBottomGlow();
- if (mBottomGlow.isFinished()) {
- mBottomGlow.onAbsorb(velocityY);
- }
- }
-
- if (velocityX != 0 || velocityY != 0) {
- ViewCompat.postInvalidateOnAnimation(this);
- }
- }
-
- void ensureLeftGlow() {
- if (mLeftGlow != null) {
- return;
- }
- mLeftGlow = mEdgeEffectFactory.createEdgeEffect(this, EdgeEffectFactory.DIRECTION_LEFT);
- if (mClipToPadding) {
- mLeftGlow.setSize(getMeasuredHeight() - getPaddingTop() - getPaddingBottom(),
- getMeasuredWidth() - getPaddingLeft() - getPaddingRight());
- } else {
- mLeftGlow.setSize(getMeasuredHeight(), getMeasuredWidth());
- }
- }
-
- void ensureRightGlow() {
- if (mRightGlow != null) {
- return;
- }
- mRightGlow = mEdgeEffectFactory.createEdgeEffect(this, EdgeEffectFactory.DIRECTION_RIGHT);
- if (mClipToPadding) {
- mRightGlow.setSize(getMeasuredHeight() - getPaddingTop() - getPaddingBottom(),
- getMeasuredWidth() - getPaddingLeft() - getPaddingRight());
- } else {
- mRightGlow.setSize(getMeasuredHeight(), getMeasuredWidth());
- }
- }
-
- void ensureTopGlow() {
- if (mTopGlow != null) {
- return;
- }
- mTopGlow = mEdgeEffectFactory.createEdgeEffect(this, EdgeEffectFactory.DIRECTION_TOP);
- if (mClipToPadding) {
- mTopGlow.setSize(getMeasuredWidth() - getPaddingLeft() - getPaddingRight(),
- getMeasuredHeight() - getPaddingTop() - getPaddingBottom());
- } else {
- mTopGlow.setSize(getMeasuredWidth(), getMeasuredHeight());
- }
-
- }
-
- void ensureBottomGlow() {
- if (mBottomGlow != null) {
- return;
- }
- mBottomGlow = mEdgeEffectFactory.createEdgeEffect(this, EdgeEffectFactory.DIRECTION_BOTTOM);
- if (mClipToPadding) {
- mBottomGlow.setSize(getMeasuredWidth() - getPaddingLeft() - getPaddingRight(),
- getMeasuredHeight() - getPaddingTop() - getPaddingBottom());
- } else {
- mBottomGlow.setSize(getMeasuredWidth(), getMeasuredHeight());
- }
- }
-
- void invalidateGlows() {
- mLeftGlow = mRightGlow = mTopGlow = mBottomGlow = null;
- }
-
- /**
- * Set a {@link EdgeEffectFactory} for this {@link RecyclerView}.
- *
- * When a new {@link EdgeEffectFactory} is set, any existing over-scroll effects are cleared
- * and new effects are created as needed using
- * {@link EdgeEffectFactory#createEdgeEffect(RecyclerView, int)}
- *
- * @param edgeEffectFactory The {@link EdgeEffectFactory} instance.
- */
- public void setEdgeEffectFactory(@NonNull EdgeEffectFactory edgeEffectFactory) {
- Preconditions.checkNotNull(edgeEffectFactory);
- mEdgeEffectFactory = edgeEffectFactory;
- invalidateGlows();
- }
-
- /**
- * Retrieves the previously set {@link EdgeEffectFactory} or the default factory if nothing
- * was set.
- *
- * @return The previously set {@link EdgeEffectFactory}
- * @see #setEdgeEffectFactory(EdgeEffectFactory)
- */
- @NonNull
- public EdgeEffectFactory getEdgeEffectFactory() {
- return mEdgeEffectFactory;
- }
-
- /**
- * Since RecyclerView is a collection ViewGroup that includes virtual children (items that are
- * in the Adapter but not visible in the UI), it employs a more involved focus search strategy
- * that differs from other ViewGroups.
- *
- * It first does a focus search within the RecyclerView. If this search finds a View that is in
- * the focus direction with respect to the currently focused View, RecyclerView returns that
- * child as the next focus target. When it cannot find such child, it calls
- * {@link LayoutManager#onFocusSearchFailed(View, int, Recycler, State)} to layout more Views
- * in the focus search direction. If LayoutManager adds a View that matches the
- * focus search criteria, it will be returned as the focus search result. Otherwise,
- * RecyclerView will call parent to handle the focus search like a regular ViewGroup.
- *
- * When the direction is {@link View#FOCUS_FORWARD} or {@link View#FOCUS_BACKWARD}, a View that
- * is not in the focus direction is still valid focus target which may not be the desired
- * behavior if the Adapter has more children in the focus direction. To handle this case,
- * RecyclerView converts the focus direction to an absolute direction and makes a preliminary
- * focus search in that direction. If there are no Views to gain focus, it will call
- * {@link LayoutManager#onFocusSearchFailed(View, int, Recycler, State)} before running a
- * focus search with the original (relative) direction. This allows RecyclerView to provide
- * better candidates to the focus search while still allowing the view system to take focus from
- * the RecyclerView and give it to a more suitable child if such child exists.
- *
- * @param focused The view that currently has focus
- * @param direction One of {@link View#FOCUS_UP}, {@link View#FOCUS_DOWN},
- * {@link View#FOCUS_LEFT}, {@link View#FOCUS_RIGHT},
- * {@link View#FOCUS_FORWARD},
- * {@link View#FOCUS_BACKWARD} or 0 for not applicable.
- * @return A new View that can be the next focus after the focused View
- */
- @Override
- public View focusSearch(View focused, int direction) {
- View result = mLayout.onInterceptFocusSearch(focused, direction);
- if (result != null) {
- return result;
- }
- final boolean canRunFocusFailure = mAdapter != null && mLayout != null
- && !isComputingLayout() && !mLayoutSuppressed;
-
- final FocusFinder ff = FocusFinder.getInstance();
- if (canRunFocusFailure
- && (direction == View.FOCUS_FORWARD || direction == View.FOCUS_BACKWARD)) {
- // convert direction to absolute direction and see if we have a view there and if not
- // tell LayoutManager to add if it can.
- boolean needsFocusFailureLayout = false;
- if (mLayout.canScrollVertically()) {
- final int absDir =
- direction == View.FOCUS_FORWARD ? View.FOCUS_DOWN : View.FOCUS_UP;
- final View found = ff.findNextFocus(this, focused, absDir);
- needsFocusFailureLayout = found == null;
- if (FORCE_ABS_FOCUS_SEARCH_DIRECTION) {
- // Workaround for broken FOCUS_BACKWARD in API 15 and older devices.
- direction = absDir;
- }
- }
- if (!needsFocusFailureLayout && mLayout.canScrollHorizontally()) {
- boolean rtl = mLayout.getLayoutDirection() == ViewCompat.LAYOUT_DIRECTION_RTL;
- final int absDir = (direction == View.FOCUS_FORWARD) ^ rtl
- ? View.FOCUS_RIGHT : View.FOCUS_LEFT;
- final View found = ff.findNextFocus(this, focused, absDir);
- needsFocusFailureLayout = found == null;
- if (FORCE_ABS_FOCUS_SEARCH_DIRECTION) {
- // Workaround for broken FOCUS_BACKWARD in API 15 and older devices.
- direction = absDir;
- }
- }
- if (needsFocusFailureLayout) {
- consumePendingUpdateOperations();
- final View focusedItemView = findContainingItemView(focused);
- if (focusedItemView == null) {
- // panic, focused view is not a child anymore, cannot call super.
- return null;
- }
- startInterceptRequestLayout();
- mLayout.onFocusSearchFailed(focused, direction, mRecycler, mState);
- stopInterceptRequestLayout(false);
- }
- result = ff.findNextFocus(this, focused, direction);
- } else {
- result = ff.findNextFocus(this, focused, direction);
- if (result == null && canRunFocusFailure) {
- consumePendingUpdateOperations();
- final View focusedItemView = findContainingItemView(focused);
- if (focusedItemView == null) {
- // panic, focused view is not a child anymore, cannot call super.
- return null;
- }
- startInterceptRequestLayout();
- result = mLayout.onFocusSearchFailed(focused, direction, mRecycler, mState);
- stopInterceptRequestLayout(false);
- }
- }
- if (result != null && !result.hasFocusable()) {
- if (getFocusedChild() == null) {
- // Scrolling to this unfocusable view is not meaningful since there is no currently
- // focused view which RV needs to keep visible.
- return super.focusSearch(focused, direction);
- }
- // If the next view returned by onFocusSearchFailed in layout manager has no focusable
- // views, we still scroll to that view in order to make it visible on the screen.
- // If it's focusable, framework already calls RV's requestChildFocus which handles
- // bringing this newly focused item onto the screen.
- requestChildOnScreen(result, null);
- return focused;
- }
- return isPreferredNextFocus(focused, result, direction)
- ? result : super.focusSearch(focused, direction);
- }
-
- /**
- * Checks if the new focus candidate is a good enough candidate such that RecyclerView will
- * assign it as the next focus View instead of letting view hierarchy decide.
- * A good candidate means a View that is aligned in the focus direction wrt the focused View
- * and is not the RecyclerView itself.
- * When this method returns false, RecyclerView will let the parent make the decision so the
- * same View may still get the focus as a result of that search.
- */
- private boolean isPreferredNextFocus(View focused, View next, int direction) {
- if (next == null || next == this || next == focused) {
- return false;
- }
- // panic, result view is not a child anymore, maybe workaround b/37864393
- if (findContainingItemView(next) == null) {
- return false;
- }
- if (focused == null) {
- return true;
- }
- // panic, focused view is not a child anymore, maybe workaround b/37864393
- if (findContainingItemView(focused) == null) {
- return true;
- }
-
- mTempRect.set(0, 0, focused.getWidth(), focused.getHeight());
- mTempRect2.set(0, 0, next.getWidth(), next.getHeight());
- offsetDescendantRectToMyCoords(focused, mTempRect);
- offsetDescendantRectToMyCoords(next, mTempRect2);
- final int rtl = mLayout.getLayoutDirection() == ViewCompat.LAYOUT_DIRECTION_RTL ? -1 : 1;
- int rightness = 0;
- if ((mTempRect.left < mTempRect2.left
- || mTempRect.right <= mTempRect2.left)
- && mTempRect.right < mTempRect2.right) {
- rightness = 1;
- } else if ((mTempRect.right > mTempRect2.right
- || mTempRect.left >= mTempRect2.right)
- && mTempRect.left > mTempRect2.left) {
- rightness = -1;
- }
- int downness = 0;
- if ((mTempRect.top < mTempRect2.top
- || mTempRect.bottom <= mTempRect2.top)
- && mTempRect.bottom < mTempRect2.bottom) {
- downness = 1;
- } else if ((mTempRect.bottom > mTempRect2.bottom
- || mTempRect.top >= mTempRect2.bottom)
- && mTempRect.top > mTempRect2.top) {
- downness = -1;
- }
- switch (direction) {
- case View.FOCUS_LEFT:
- return rightness < 0;
- case View.FOCUS_RIGHT:
- return rightness > 0;
- case View.FOCUS_UP:
- return downness < 0;
- case View.FOCUS_DOWN:
- return downness > 0;
- case View.FOCUS_FORWARD:
- return downness > 0 || (downness == 0 && rightness * rtl > 0);
- case View.FOCUS_BACKWARD:
- return downness < 0 || (downness == 0 && rightness * rtl < 0);
- }
- throw new IllegalArgumentException("Invalid direction: " + direction + exceptionLabel());
- }
-
- @Override
- public void requestChildFocus(View child, View focused) {
- if (!mLayout.onRequestChildFocus(this, mState, child, focused) && focused != null) {
- requestChildOnScreen(child, focused);
- }
- super.requestChildFocus(child, focused);
- }
-
- /**
- * Requests that the given child of the RecyclerView be positioned onto the screen. This method
- * can be called for both unfocusable and focusable child views. For unfocusable child views,
- * the {@param focused} parameter passed is null, whereas for a focusable child, this parameter
- * indicates the actual descendant view within this child view that holds the focus.
- *
- * @param child The child view of this RecyclerView that wants to come onto the screen.
- * @param focused The descendant view that actually has the focus if child is focusable, null
- * otherwise.
- */
- private void requestChildOnScreen(@NonNull View child, @Nullable View focused) {
- View rectView = (focused != null) ? focused : child;
- mTempRect.set(0, 0, rectView.getWidth(), rectView.getHeight());
-
- // get item decor offsets w/o refreshing. If they are invalid, there will be another
- // layout pass to fix them, then it is LayoutManager's responsibility to keep focused
- // View in viewport.
- final ViewGroup.LayoutParams focusedLayoutParams = rectView.getLayoutParams();
- if (focusedLayoutParams instanceof LayoutParams) {
- // if focused child has item decors, use them. Otherwise, ignore.
- final LayoutParams lp = (LayoutParams) focusedLayoutParams;
- if (!lp.mInsetsDirty) {
- final Rect insets = lp.mDecorInsets;
- mTempRect.left -= insets.left;
- mTempRect.right += insets.right;
- mTempRect.top -= insets.top;
- mTempRect.bottom += insets.bottom;
- }
- }
-
- if (focused != null) {
- offsetDescendantRectToMyCoords(focused, mTempRect);
- offsetRectIntoDescendantCoords(child, mTempRect);
- }
- mLayout.requestChildRectangleOnScreen(this, child, mTempRect, !mFirstLayoutComplete,
- (focused == null));
- }
-
- @Override
- public boolean requestChildRectangleOnScreen(View child, Rect rect, boolean immediate) {
- return mLayout.requestChildRectangleOnScreen(this, child, rect, immediate);
- }
-
- @Override
- public void addFocusables(ArrayList views, int direction, int focusableMode) {
- if (mLayout == null || !mLayout.onAddFocusables(this, views, direction, focusableMode)) {
- super.addFocusables(views, direction, focusableMode);
- }
- }
-
- @Override
- protected boolean onRequestFocusInDescendants(int direction, Rect previouslyFocusedRect) {
- if (isComputingLayout()) {
- // if we are in the middle of a layout calculation, don't let any child take focus.
- // RV will handle it after layout calculation is finished.
- return false;
- }
- return super.onRequestFocusInDescendants(direction, previouslyFocusedRect);
- }
-
- @Override
- protected void onAttachedToWindow() {
- super.onAttachedToWindow();
- mLayoutOrScrollCounter = 0;
- mIsAttached = true;
- mFirstLayoutComplete = mFirstLayoutComplete && !isLayoutRequested();
-
- mRecycler.onAttachedToWindow();
-
- if (mLayout != null) {
- mLayout.dispatchAttachedToWindow(this);
- }
- mPostedAnimatorRunner = false;
-
- if (ALLOW_THREAD_GAP_WORK) {
- // Register with gap worker
- mGapWorker = GapWorker.sGapWorker.get();
- if (mGapWorker == null) {
- mGapWorker = new GapWorker();
-
- // break 60 fps assumption if data from display appears valid
- // NOTE: we only do this query once, statically, because it's very expensive (> 1ms)
- Display display = ViewCompat.getDisplay(this);
- float refreshRate = 60.0f;
- if (!isInEditMode() && display != null) {
- float displayRefreshRate = display.getRefreshRate();
- if (displayRefreshRate >= 30.0f) {
- refreshRate = displayRefreshRate;
- }
- }
- mGapWorker.mFrameIntervalNs = (long) (1000000000 / refreshRate);
- GapWorker.sGapWorker.set(mGapWorker);
- }
- mGapWorker.add(this);
- }
- }
-
- @Override
- protected void onDetachedFromWindow() {
- super.onDetachedFromWindow();
- if (mItemAnimator != null) {
- mItemAnimator.endAnimations();
- }
- stopScroll();
- mIsAttached = false;
- if (mLayout != null) {
- mLayout.dispatchDetachedFromWindow(this, mRecycler);
- }
- mPendingAccessibilityImportanceChange.clear();
- removeCallbacks(mItemAnimatorRunner);
- mViewInfoStore.onDetach();
- mRecycler.onDetachedFromWindow();
-
- PoolingContainer.callPoolingContainerOnReleaseForChildren(this);
-
- if (ALLOW_THREAD_GAP_WORK && mGapWorker != null) {
- // Unregister with gap worker
- mGapWorker.remove(this);
- mGapWorker = null;
- }
- }
-
- /**
- * Returns true if RecyclerView is attached to window.
- */
- @Override
- public boolean isAttachedToWindow() {
- return mIsAttached;
- }
-
- /**
- * Checks if RecyclerView is in the middle of a layout or scroll and throws an
- * {@link IllegalStateException} if it is not .
- *
- * @param message The message for the exception. Can be null.
- * @see #assertNotInLayoutOrScroll(String)
- */
- void assertInLayoutOrScroll(String message) {
- if (!isComputingLayout()) {
- if (message == null) {
- throw new IllegalStateException("Cannot call this method unless RecyclerView is "
- + "computing a layout or scrolling" + exceptionLabel());
- }
- throw new IllegalStateException(message + exceptionLabel());
-
- }
- }
-
- /**
- * Checks if RecyclerView is in the middle of a layout or scroll and throws an
- * {@link IllegalStateException} if it is .
- *
- * @param message The message for the exception. Can be null.
- * @see #assertInLayoutOrScroll(String)
- */
- void assertNotInLayoutOrScroll(String message) {
- if (isComputingLayout()) {
- if (message == null) {
- throw new IllegalStateException("Cannot call this method while RecyclerView is "
- + "computing a layout or scrolling" + exceptionLabel());
- }
- throw new IllegalStateException(message);
- }
- if (mDispatchScrollCounter > 0) {
- Log.w(TAG, "Cannot call this method in a scroll callback. Scroll callbacks might"
- + "be run during a measure & layout pass where you cannot change the"
- + "RecyclerView data. Any method call that might change the structure"
- + "of the RecyclerView or the adapter contents should be postponed to"
- + "the next frame.",
- new IllegalStateException("" + exceptionLabel()));
- }
- }
-
- /**
- * Add an {@link OnItemTouchListener} to intercept touch events before they are dispatched
- * to child views or this view's standard scrolling behavior.
- *
- * Client code may use listeners to implement item manipulation behavior. Once a listener
- * returns true from
- * {@link OnItemTouchListener#onInterceptTouchEvent(RecyclerView, MotionEvent)} its
- * {@link OnItemTouchListener#onTouchEvent(RecyclerView, MotionEvent)} method will be called
- * for each incoming MotionEvent until the end of the gesture.
- *
- * @param listener Listener to add
- * @see SimpleOnItemTouchListener
- */
- public void addOnItemTouchListener(@NonNull OnItemTouchListener listener) {
- mOnItemTouchListeners.add(listener);
- }
-
- /**
- * Remove an {@link OnItemTouchListener}. It will no longer be able to intercept touch events.
- *
- * @param listener Listener to remove
- */
- public void removeOnItemTouchListener(@NonNull OnItemTouchListener listener) {
- mOnItemTouchListeners.remove(listener);
- if (mInterceptingOnItemTouchListener == listener) {
- mInterceptingOnItemTouchListener = null;
- }
- }
-
- /**
- * Dispatches the motion event to the intercepting OnItemTouchListener or provides opportunity
- * for OnItemTouchListeners to intercept.
- *
- * @param e The MotionEvent
- * @return True if handled by an intercepting OnItemTouchListener.
- */
- private boolean dispatchToOnItemTouchListeners(MotionEvent e) {
-
- // OnItemTouchListeners should receive calls to their methods in the same pattern that
- // ViewGroups do. That pattern is a bit confusing, which in turn makes the below code a
- // bit confusing. Here are rules for the pattern:
- //
- // 1. A single MotionEvent should not be passed to either OnInterceptTouchEvent or
- // OnTouchEvent twice.
- // 2. ACTION_DOWN MotionEvents may be passed to both onInterceptTouchEvent and
- // onTouchEvent.
- // 3. All other MotionEvents should be passed to either onInterceptTouchEvent or
- // onTouchEvent, not both.
-
- // Side Note: We don't currently perfectly mimic how MotionEvents work in the view system.
- // If we were to do so, for every MotionEvent, any OnItemTouchListener that is before the
- // intercepting OnItemTouchEvent should still have a chance to intercept, and if it does,
- // the previously intercepting OnItemTouchEvent should get an ACTION_CANCEL event.
-
- if (mInterceptingOnItemTouchListener == null) {
- if (e.getAction() == MotionEvent.ACTION_DOWN) {
- return false;
- }
- return findInterceptingOnItemTouchListener(e);
- } else {
- mInterceptingOnItemTouchListener.onTouchEvent(this, e);
- final int action = e.getAction();
- if (action == MotionEvent.ACTION_CANCEL || action == MotionEvent.ACTION_UP) {
- mInterceptingOnItemTouchListener = null;
- }
- return true;
- }
- }
-
- /**
- * Looks for an OnItemTouchListener that wants to intercept.
- *
- * Calls {@link OnItemTouchListener#onInterceptTouchEvent(RecyclerView, MotionEvent)} on each
- * of the registered {@link OnItemTouchListener}s, passing in the
- * MotionEvent. If one returns true and the action is not ACTION_CANCEL, saves the intercepting
- * OnItemTouchListener to be called for future {@link RecyclerView#onTouchEvent(MotionEvent)}
- * and immediately returns true. If none want to intercept or the action is ACTION_CANCEL,
- * returns false.
- *
- * @param e The MotionEvent
- * @return true if an OnItemTouchListener is saved as intercepting.
- */
- private boolean findInterceptingOnItemTouchListener(MotionEvent e) {
- int action = e.getAction();
- final int listenerCount = mOnItemTouchListeners.size();
- for (int i = 0; i < listenerCount; i++) {
- final OnItemTouchListener listener = mOnItemTouchListeners.get(i);
- if (listener.onInterceptTouchEvent(this, e) && action != MotionEvent.ACTION_CANCEL) {
- mInterceptingOnItemTouchListener = listener;
- return true;
- }
- }
- return false;
- }
-
- @Override
- public boolean onInterceptTouchEvent(MotionEvent e) {
- if (mLayoutSuppressed) {
- // When layout is suppressed, RV does not intercept the motion event.
- // A child view e.g. a button may still get the click.
- return false;
- }
-
- // Clear the active onInterceptTouchListener. None should be set at this time, and if one
- // is, it's because some other code didn't follow the standard contract.
- mInterceptingOnItemTouchListener = null;
- if (findInterceptingOnItemTouchListener(e)) {
- cancelScroll();
- return true;
- }
-
- if (mLayout == null) {
- return false;
- }
-
- final boolean canScrollHorizontally = mLayout.canScrollHorizontally();
- final boolean canScrollVertically = mLayout.canScrollVertically();
-
- if (mVelocityTracker == null) {
- mVelocityTracker = VelocityTracker.obtain();
- }
- mVelocityTracker.addMovement(e);
-
- final int action = e.getActionMasked();
- final int actionIndex = e.getActionIndex();
-
- switch (action) {
- case MotionEvent.ACTION_DOWN:
- if (mIgnoreMotionEventTillDown) {
- mIgnoreMotionEventTillDown = false;
- }
- mScrollPointerId = e.getPointerId(0);
- mInitialTouchX = mLastTouchX = (int) (e.getX() + 0.5f);
- mInitialTouchY = mLastTouchY = (int) (e.getY() + 0.5f);
-
- if (stopGlowAnimations(e) || mScrollState == SCROLL_STATE_SETTLING) {
- getParent().requestDisallowInterceptTouchEvent(true);
- setScrollState(SCROLL_STATE_DRAGGING);
- stopNestedScroll(TYPE_NON_TOUCH);
- }
-
- // Clear the nested offsets
- mNestedOffsets[0] = mNestedOffsets[1] = 0;
-
- int nestedScrollAxis = ViewCompat.SCROLL_AXIS_NONE;
- if (canScrollHorizontally) {
- nestedScrollAxis |= ViewCompat.SCROLL_AXIS_HORIZONTAL;
- }
- if (canScrollVertically) {
- nestedScrollAxis |= ViewCompat.SCROLL_AXIS_VERTICAL;
- }
- startNestedScroll(nestedScrollAxis, TYPE_TOUCH);
- break;
-
- case MotionEvent.ACTION_POINTER_DOWN:
- mScrollPointerId = e.getPointerId(actionIndex);
- mInitialTouchX = mLastTouchX = (int) (e.getX(actionIndex) + 0.5f);
- mInitialTouchY = mLastTouchY = (int) (e.getY(actionIndex) + 0.5f);
- break;
-
- case MotionEvent.ACTION_MOVE: {
- final int index = e.findPointerIndex(mScrollPointerId);
- if (index < 0) {
- Log.e(TAG, "Error processing scroll; pointer index for id "
- + mScrollPointerId + " not found. Did any MotionEvents get skipped?");
- return false;
- }
-
- final int x = (int) (e.getX(index) + 0.5f);
- final int y = (int) (e.getY(index) + 0.5f);
- if (mScrollState != SCROLL_STATE_DRAGGING) {
- final int dx = x - mInitialTouchX;
- final int dy = y - mInitialTouchY;
- boolean startScroll = false;
- if (canScrollHorizontally && Math.abs(dx) > mTouchSlop) {
- mLastTouchX = x;
- startScroll = true;
- }
- if (canScrollVertically && Math.abs(dy) > mTouchSlop) {
- mLastTouchY = y;
- startScroll = true;
- }
- if (startScroll) {
- setScrollState(SCROLL_STATE_DRAGGING);
- }
- }
- }
- break;
-
- case MotionEvent.ACTION_POINTER_UP: {
- onPointerUp(e);
- }
- break;
-
- case MotionEvent.ACTION_UP: {
- mVelocityTracker.clear();
- stopNestedScroll(TYPE_TOUCH);
- }
- break;
-
- case MotionEvent.ACTION_CANCEL: {
- cancelScroll();
- }
- }
- return mScrollState == SCROLL_STATE_DRAGGING;
- }
-
- /**
- * This stops any edge glow animation that is currently running by applying a
- * 0 length pull at the displacement given by the provided MotionEvent. On pre-S devices,
- * this method does nothing, allowing any animating edge effect to continue animating and
- * returning false always.
- *
- * @param e The motion event to use to indicate the finger position for the displacement of
- * the current pull.
- * @return true if any edge effect had an existing effect to be drawn ond the
- * animation was stopped or false if no edge effect had a value to display.
- */
- private boolean stopGlowAnimations(MotionEvent e) {
- boolean stopped = false;
- if (mLeftGlow != null && EdgeEffectCompat.getDistance(mLeftGlow) != 0
- && !canScrollHorizontally(-1)) {
- EdgeEffectCompat.onPullDistance(mLeftGlow, 0, 1 - (e.getY() / getHeight()));
- stopped = true;
- }
- if (mRightGlow != null && EdgeEffectCompat.getDistance(mRightGlow) != 0
- && !canScrollHorizontally(1)) {
- EdgeEffectCompat.onPullDistance(mRightGlow, 0, e.getY() / getHeight());
- stopped = true;
- }
- if (mTopGlow != null && EdgeEffectCompat.getDistance(mTopGlow) != 0
- && !canScrollVertically(-1)) {
- EdgeEffectCompat.onPullDistance(mTopGlow, 0, e.getX() / getWidth());
- stopped = true;
- }
- if (mBottomGlow != null && EdgeEffectCompat.getDistance(mBottomGlow) != 0
- && !canScrollVertically(1)) {
- EdgeEffectCompat.onPullDistance(mBottomGlow, 0, 1 - e.getX() / getWidth());
- stopped = true;
- }
- return stopped;
- }
-
- @Override
- public void requestDisallowInterceptTouchEvent(boolean disallowIntercept) {
- final int listenerCount = mOnItemTouchListeners.size();
- for (int i = 0; i < listenerCount; i++) {
- final OnItemTouchListener listener = mOnItemTouchListeners.get(i);
- listener.onRequestDisallowInterceptTouchEvent(disallowIntercept);
- }
- super.requestDisallowInterceptTouchEvent(disallowIntercept);
- }
-
- @Override
- public boolean onTouchEvent(MotionEvent e) {
- if (mLayoutSuppressed || mIgnoreMotionEventTillDown) {
- return false;
- }
- if (dispatchToOnItemTouchListeners(e)) {
- cancelScroll();
- return true;
- }
-
- if (mLayout == null) {
- return false;
- }
-
- final boolean canScrollHorizontally = mLayout.canScrollHorizontally();
- final boolean canScrollVertically = mLayout.canScrollVertically();
-
- if (mVelocityTracker == null) {
- mVelocityTracker = VelocityTracker.obtain();
- }
- boolean eventAddedToVelocityTracker = false;
-
- final int action = e.getActionMasked();
- final int actionIndex = e.getActionIndex();
-
- if (action == MotionEvent.ACTION_DOWN) {
- mNestedOffsets[0] = mNestedOffsets[1] = 0;
- }
- final MotionEvent vtev = MotionEvent.obtain(e);
- vtev.offsetLocation(mNestedOffsets[0], mNestedOffsets[1]);
-
- switch (action) {
- case MotionEvent.ACTION_DOWN: {
- mScrollPointerId = e.getPointerId(0);
- mInitialTouchX = mLastTouchX = (int) (e.getX() + 0.5f);
- mInitialTouchY = mLastTouchY = (int) (e.getY() + 0.5f);
-
- int nestedScrollAxis = ViewCompat.SCROLL_AXIS_NONE;
- if (canScrollHorizontally) {
- nestedScrollAxis |= ViewCompat.SCROLL_AXIS_HORIZONTAL;
- }
- if (canScrollVertically) {
- nestedScrollAxis |= ViewCompat.SCROLL_AXIS_VERTICAL;
- }
- startNestedScroll(nestedScrollAxis, TYPE_TOUCH);
- }
- break;
-
- case MotionEvent.ACTION_POINTER_DOWN: {
- mScrollPointerId = e.getPointerId(actionIndex);
- mInitialTouchX = mLastTouchX = (int) (e.getX(actionIndex) + 0.5f);
- mInitialTouchY = mLastTouchY = (int) (e.getY(actionIndex) + 0.5f);
- }
- break;
-
- case MotionEvent.ACTION_MOVE: {
- final int index = e.findPointerIndex(mScrollPointerId);
- if (index < 0) {
- Log.e(TAG, "Error processing scroll; pointer index for id "
- + mScrollPointerId + " not found. Did any MotionEvents get skipped?");
- return false;
- }
-
- final int x = (int) (e.getX(index) + 0.5f);
- final int y = (int) (e.getY(index) + 0.5f);
- int dx = mLastTouchX - x;
- int dy = mLastTouchY - y;
-
- if (mScrollState != SCROLL_STATE_DRAGGING) {
- boolean startScroll = false;
- if (canScrollHorizontally) {
- if (dx > 0) {
- dx = Math.max(0, dx - mTouchSlop);
- } else {
- dx = Math.min(0, dx + mTouchSlop);
- }
- if (dx != 0) {
- startScroll = true;
- }
- }
- if (canScrollVertically) {
- if (dy > 0) {
- dy = Math.max(0, dy - mTouchSlop);
- } else {
- dy = Math.min(0, dy + mTouchSlop);
- }
- if (dy != 0) {
- startScroll = true;
- }
- }
- if (startScroll) {
- setScrollState(SCROLL_STATE_DRAGGING);
- }
- }
-
- if (mScrollState == SCROLL_STATE_DRAGGING) {
- mReusableIntPair[0] = 0;
- mReusableIntPair[1] = 0;
- dx -= releaseHorizontalGlow(dx, e.getY());
- dy -= releaseVerticalGlow(dy, e.getX());
-
- if (dispatchNestedPreScroll(
- canScrollHorizontally ? dx : 0,
- canScrollVertically ? dy : 0,
- mReusableIntPair, mScrollOffset, TYPE_TOUCH
- )) {
- dx -= mReusableIntPair[0];
- dy -= mReusableIntPair[1];
- // Updated the nested offsets
- mNestedOffsets[0] += mScrollOffset[0];
- mNestedOffsets[1] += mScrollOffset[1];
- // Scroll has initiated, prevent parents from intercepting
- getParent().requestDisallowInterceptTouchEvent(true);
- }
-
- mLastTouchX = x - mScrollOffset[0];
- mLastTouchY = y - mScrollOffset[1];
-
- if (scrollByInternal(
- canScrollHorizontally ? dx : 0,
- canScrollVertically ? dy : 0,
- e, TYPE_TOUCH)) {
- getParent().requestDisallowInterceptTouchEvent(true);
- }
- if (mGapWorker != null && (dx != 0 || dy != 0)) {
- mGapWorker.postFromTraversal(this, dx, dy);
- }
- }
- }
- break;
-
- case MotionEvent.ACTION_POINTER_UP: {
- onPointerUp(e);
- }
- break;
-
- case MotionEvent.ACTION_UP: {
- mVelocityTracker.addMovement(vtev);
- eventAddedToVelocityTracker = true;
- mVelocityTracker.computeCurrentVelocity(1000, mMaxFlingVelocity);
- final float xvel = canScrollHorizontally
- ? -mVelocityTracker.getXVelocity(mScrollPointerId) : 0;
- final float yvel = canScrollVertically
- ? -mVelocityTracker.getYVelocity(mScrollPointerId) : 0;
- if (!((xvel != 0 || yvel != 0) && fling((int) xvel, (int) yvel))) {
- setScrollState(SCROLL_STATE_IDLE);
- }
- resetScroll();
- }
- break;
-
- case MotionEvent.ACTION_CANCEL: {
- cancelScroll();
- }
- break;
- }
-
- if (!eventAddedToVelocityTracker) {
- mVelocityTracker.addMovement(vtev);
- }
- vtev.recycle();
-
- return true;
- }
-
- private void resetScroll() {
- if (mVelocityTracker != null) {
- mVelocityTracker.clear();
- }
- stopNestedScroll(TYPE_TOUCH);
- releaseGlows();
- }
-
- private void cancelScroll() {
- resetScroll();
- setScrollState(SCROLL_STATE_IDLE);
- }
-
- private void onPointerUp(MotionEvent e) {
- final int actionIndex = e.getActionIndex();
- if (e.getPointerId(actionIndex) == mScrollPointerId) {
- // Pick a new pointer to pick up the slack.
- final int newIndex = actionIndex == 0 ? 1 : 0;
- mScrollPointerId = e.getPointerId(newIndex);
- mInitialTouchX = mLastTouchX = (int) (e.getX(newIndex) + 0.5f);
- mInitialTouchY = mLastTouchY = (int) (e.getY(newIndex) + 0.5f);
- }
- }
-
- @Override
- public boolean onGenericMotionEvent(MotionEvent event) {
- if (mLayout == null) {
- return false;
- }
- if (mLayoutSuppressed) {
- return false;
- }
- if (event.getAction() == MotionEvent.ACTION_SCROLL) {
- final float vScroll, hScroll;
- if ((event.getSource() & InputDeviceCompat.SOURCE_CLASS_POINTER) != 0) {
- if (mLayout.canScrollVertically()) {
- // Inverse the sign of the vertical scroll to align the scroll orientation
- // with AbsListView.
- vScroll = -event.getAxisValue(MotionEvent.AXIS_VSCROLL);
- } else {
- vScroll = 0f;
- }
- if (mLayout.canScrollHorizontally()) {
- hScroll = event.getAxisValue(MotionEvent.AXIS_HSCROLL);
- } else {
- hScroll = 0f;
- }
- } else if ((event.getSource() & InputDeviceCompat.SOURCE_ROTARY_ENCODER) != 0) {
- final float axisScroll = event.getAxisValue(MotionEventCompat.AXIS_SCROLL);
- if (mLayout.canScrollVertically()) {
- // Invert the sign of the vertical scroll to align the scroll orientation
- // with AbsListView.
- vScroll = -axisScroll;
- hScroll = 0f;
- } else if (mLayout.canScrollHorizontally()) {
- vScroll = 0f;
- hScroll = axisScroll;
- } else {
- vScroll = 0f;
- hScroll = 0f;
- }
- } else {
- vScroll = 0f;
- hScroll = 0f;
- }
-
- if (vScroll != 0 || hScroll != 0) {
- nestedScrollByInternal((int) (hScroll * mScaledHorizontalScrollFactor),
- (int) (vScroll * mScaledVerticalScrollFactor), event, TYPE_NON_TOUCH);
- }
- }
- return false;
- }
-
- @Override
- protected void onMeasure(int widthSpec, int heightSpec) {
- if (mLayout == null) {
- defaultOnMeasure(widthSpec, heightSpec);
- return;
- }
- if (mLayout.isAutoMeasureEnabled()) {
- final int widthMode = MeasureSpec.getMode(widthSpec);
- final int heightMode = MeasureSpec.getMode(heightSpec);
-
- /**
- * This specific call should be considered deprecated and replaced with
- * {@link #defaultOnMeasure(int, int)}. It can't actually be replaced as it could
- * break existing third party code but all documentation directs developers to not
- * override {@link LayoutManager#onMeasure(int, int)} when
- * {@link LayoutManager#isAutoMeasureEnabled()} returns true.
- */
- mLayout.onMeasure(mRecycler, mState, widthSpec, heightSpec);
-
- // Calculate and track whether we should skip measurement here because the MeasureSpec
- // modes in both dimensions are EXACTLY.
- mLastAutoMeasureSkippedDueToExact =
- widthMode == MeasureSpec.EXACTLY && heightMode == MeasureSpec.EXACTLY;
- if (mLastAutoMeasureSkippedDueToExact || mAdapter == null) {
- return;
- }
-
- if (mState.mLayoutStep == State.STEP_START) {
- dispatchLayoutStep1();
- }
- // set dimensions in 2nd step. Pre-layout should happen with old dimensions for
- // consistency
- mLayout.setMeasureSpecs(widthSpec, heightSpec);
- mState.mIsMeasuring = true;
- dispatchLayoutStep2();
-
- // now we can get the width and height from the children.
- mLayout.setMeasuredDimensionFromChildren(widthSpec, heightSpec);
-
- // if RecyclerView has non-exact width and height and if there is at least one child
- // which also has non-exact width & height, we have to re-measure.
- if (mLayout.shouldMeasureTwice()) {
- mLayout.setMeasureSpecs(
- MeasureSpec.makeMeasureSpec(getMeasuredWidth(), MeasureSpec.EXACTLY),
- MeasureSpec.makeMeasureSpec(getMeasuredHeight(), MeasureSpec.EXACTLY));
- mState.mIsMeasuring = true;
- dispatchLayoutStep2();
- // now we can get the width and height from the children.
- mLayout.setMeasuredDimensionFromChildren(widthSpec, heightSpec);
- }
-
- mLastAutoMeasureNonExactMeasuredWidth = getMeasuredWidth();
- mLastAutoMeasureNonExactMeasuredHeight = getMeasuredHeight();
- } else {
- if (mHasFixedSize) {
- mLayout.onMeasure(mRecycler, mState, widthSpec, heightSpec);
- return;
- }
- // custom onMeasure
- if (mAdapterUpdateDuringMeasure) {
- startInterceptRequestLayout();
- onEnterLayoutOrScroll();
- processAdapterUpdatesAndSetAnimationFlags();
- onExitLayoutOrScroll();
-
- if (mState.mRunPredictiveAnimations) {
- mState.mInPreLayout = true;
- } else {
- // consume remaining updates to provide a consistent state with the layout pass.
- mAdapterHelper.consumeUpdatesInOnePass();
- mState.mInPreLayout = false;
- }
- mAdapterUpdateDuringMeasure = false;
- stopInterceptRequestLayout(false);
- } else if (mState.mRunPredictiveAnimations) {
- // If mAdapterUpdateDuringMeasure is false and mRunPredictiveAnimations is true:
- // this means there is already an onMeasure() call performed to handle the pending
- // adapter change, two onMeasure() calls can happen if RV is a child of LinearLayout
- // with layout_width=MATCH_PARENT. RV cannot call LM.onMeasure() second time
- // because getViewForPosition() will crash when LM uses a child to measure.
- setMeasuredDimension(getMeasuredWidth(), getMeasuredHeight());
- return;
- }
-
- if (mAdapter != null) {
- mState.mItemCount = mAdapter.getItemCount();
- } else {
- mState.mItemCount = 0;
- }
- startInterceptRequestLayout();
- mLayout.onMeasure(mRecycler, mState, widthSpec, heightSpec);
- stopInterceptRequestLayout(false);
- mState.mInPreLayout = false; // clear
- }
- }
-
- /**
- * An implementation of {@link View#onMeasure(int, int)} to fall back to in various scenarios
- * where this RecyclerView is otherwise lacking better information.
- */
- void defaultOnMeasure(int widthSpec, int heightSpec) {
- // calling LayoutManager here is not pretty but that API is already public and it is better
- // than creating another method since this is internal.
- final int width = LayoutManager.chooseSize(widthSpec,
- getPaddingLeft() + getPaddingRight(),
- ViewCompat.getMinimumWidth(this));
- final int height = LayoutManager.chooseSize(heightSpec,
- getPaddingTop() + getPaddingBottom(),
- ViewCompat.getMinimumHeight(this));
-
- setMeasuredDimension(width, height);
- }
-
- @Override
- protected void onSizeChanged(int w, int h, int oldw, int oldh) {
- super.onSizeChanged(w, h, oldw, oldh);
- if (w != oldw || h != oldh) {
- invalidateGlows();
- // layout's w/h are updated during measure/layout steps.
- }
- }
-
- /**
- * Sets the {@link ItemAnimator} that will handle animations involving changes
- * to the items in this RecyclerView. By default, RecyclerView instantiates and
- * uses an instance of {@link DefaultItemAnimator}. Whether item animations are
- * enabled for the RecyclerView depends on the ItemAnimator and whether
- * the LayoutManager {@link LayoutManager#supportsPredictiveItemAnimations()
- * supports item animations}.
- *
- * @param animator The ItemAnimator being set. If null, no animations will occur
- * when changes occur to the items in this RecyclerView.
- */
- public void setItemAnimator(@Nullable ItemAnimator animator) {
- if (mItemAnimator != null) {
- mItemAnimator.endAnimations();
- mItemAnimator.setListener(null);
- }
- mItemAnimator = animator;
- if (mItemAnimator != null) {
- mItemAnimator.setListener(mItemAnimatorListener);
- }
- }
-
- void onEnterLayoutOrScroll() {
- mLayoutOrScrollCounter++;
- }
-
- void onExitLayoutOrScroll() {
- onExitLayoutOrScroll(true);
- }
-
- void onExitLayoutOrScroll(boolean enableChangeEvents) {
- mLayoutOrScrollCounter--;
- if (mLayoutOrScrollCounter < 1) {
- if (sDebugAssertionsEnabled && mLayoutOrScrollCounter < 0) {
- throw new IllegalStateException("layout or scroll counter cannot go below zero."
- + "Some calls are not matching" + exceptionLabel());
- }
- mLayoutOrScrollCounter = 0;
- if (enableChangeEvents) {
- dispatchContentChangedIfNecessary();
- dispatchPendingImportantForAccessibilityChanges();
- }
- }
- }
-
- boolean isAccessibilityEnabled() {
- return mAccessibilityManager != null && mAccessibilityManager.isEnabled();
- }
-
- private void dispatchContentChangedIfNecessary() {
- final int flags = mEatenAccessibilityChangeFlags;
- mEatenAccessibilityChangeFlags = 0;
- if (flags != 0 && isAccessibilityEnabled()) {
- final AccessibilityEvent event = AccessibilityEvent.obtain();
- event.setEventType(AccessibilityEvent.TYPE_WINDOW_CONTENT_CHANGED);
- AccessibilityEventCompat.setContentChangeTypes(event, flags);
- sendAccessibilityEventUnchecked(event);
- }
- }
-
- /**
- * Returns whether RecyclerView is currently computing a layout.
- *
- * If this method returns true, it means that RecyclerView is in a lockdown state and any
- * attempt to update adapter contents will result in an exception because adapter contents
- * cannot be changed while RecyclerView is trying to compute the layout.
- *
- * It is very unlikely that your code will be running during this state as it is
- * called by the framework when a layout traversal happens or RecyclerView starts to scroll
- * in response to system events (touch, accessibility etc).
- *
- * This case may happen if you have some custom logic to change adapter contents in
- * response to a View callback (e.g. focus change callback) which might be triggered during a
- * layout calculation. In these cases, you should just postpone the change using a Handler or a
- * similar mechanism.
- *
- * @return true if RecyclerView is currently computing a layout, false
- * otherwise
- */
- public boolean isComputingLayout() {
- return mLayoutOrScrollCounter > 0;
- }
-
- /**
- * Returns true if an accessibility event should not be dispatched now. This happens when an
- * accessibility request arrives while RecyclerView does not have a stable state which is very
- * hard to handle for a LayoutManager. Instead, this method records necessary information about
- * the event and dispatches a window change event after the critical section is finished.
- *
- * @return True if the accessibility event should be postponed.
- */
- boolean shouldDeferAccessibilityEvent(AccessibilityEvent event) {
- if (isComputingLayout()) {
- int type = 0;
- if (event != null) {
- type = AccessibilityEventCompat.getContentChangeTypes(event);
- }
- if (type == 0) {
- type = AccessibilityEventCompat.CONTENT_CHANGE_TYPE_UNDEFINED;
- }
- mEatenAccessibilityChangeFlags |= type;
- return true;
- }
- return false;
- }
-
- @Override
- public void sendAccessibilityEventUnchecked(AccessibilityEvent event) {
- if (shouldDeferAccessibilityEvent(event)) {
- return;
- }
- super.sendAccessibilityEventUnchecked(event);
- }
-
- @Override
- public boolean dispatchPopulateAccessibilityEvent(AccessibilityEvent event) {
- onPopulateAccessibilityEvent(event);
- return true;
- }
-
- /**
- * Gets the current ItemAnimator for this RecyclerView. A null return value
- * indicates that there is no animator and that item changes will happen without
- * any animations. By default, RecyclerView instantiates and
- * uses an instance of {@link DefaultItemAnimator}.
- *
- * @return ItemAnimator The current ItemAnimator. If null, no animations will occur
- * when changes occur to the items in this RecyclerView.
- */
- @Nullable
- public ItemAnimator getItemAnimator() {
- return mItemAnimator;
- }
-
- /**
- * Post a runnable to the next frame to run pending item animations. Only the first such
- * request will be posted, governed by the mPostedAnimatorRunner flag.
- */
- void postAnimationRunner() {
- if (!mPostedAnimatorRunner && mIsAttached) {
- ViewCompat.postOnAnimation(this, mItemAnimatorRunner);
- mPostedAnimatorRunner = true;
- }
- }
-
- private boolean predictiveItemAnimationsEnabled() {
- return (mItemAnimator != null && mLayout.supportsPredictiveItemAnimations());
- }
-
- /**
- * Consumes adapter updates and calculates which type of animations we want to run.
- * Called in onMeasure and dispatchLayout.
- *
- * This method may process only the pre-layout state of updates or all of them.
- */
- private void processAdapterUpdatesAndSetAnimationFlags() {
- if (mDataSetHasChangedAfterLayout) {
- // Processing these items have no value since data set changed unexpectedly.
- // Instead, we just reset it.
- mAdapterHelper.reset();
- if (mDispatchItemsChangedEvent) {
- mLayout.onItemsChanged(this);
- }
- }
- // simple animations are a subset of advanced animations (which will cause a
- // pre-layout step)
- // If layout supports predictive animations, pre-process to decide if we want to run them
- if (predictiveItemAnimationsEnabled()) {
- mAdapterHelper.preProcess();
- } else {
- mAdapterHelper.consumeUpdatesInOnePass();
- }
- boolean animationTypeSupported = mItemsAddedOrRemoved || mItemsChanged;
- mState.mRunSimpleAnimations = mFirstLayoutComplete
- && mItemAnimator != null
- && (mDataSetHasChangedAfterLayout
- || animationTypeSupported
- || mLayout.mRequestedSimpleAnimations)
- && (!mDataSetHasChangedAfterLayout
- || mAdapter.hasStableIds());
- mState.mRunPredictiveAnimations = mState.mRunSimpleAnimations
- && animationTypeSupported
- && !mDataSetHasChangedAfterLayout
- && predictiveItemAnimationsEnabled();
- }
-
- /**
- * Wrapper around layoutChildren() that handles animating changes caused by layout.
- * Animations work on the assumption that there are five different kinds of items
- * in play:
- * PERSISTENT: items are visible before and after layout
- * REMOVED: items were visible before layout and were removed by the app
- * ADDED: items did not exist before layout and were added by the app
- * DISAPPEARING: items exist in the data set before/after, but changed from
- * visible to non-visible in the process of layout (they were moved off
- * screen as a side-effect of other changes)
- * APPEARING: items exist in the data set before/after, but changed from
- * non-visible to visible in the process of layout (they were moved on
- * screen as a side-effect of other changes)
- * The overall approach figures out what items exist before/after layout and
- * infers one of the five above states for each of the items. Then the animations
- * are set up accordingly:
- * PERSISTENT views are animated via
- * {@link ItemAnimator#animatePersistence(ViewHolder, ItemHolderInfo, ItemHolderInfo)}
- * DISAPPEARING views are animated via
- * {@link ItemAnimator#animateDisappearance(ViewHolder, ItemHolderInfo, ItemHolderInfo)}
- * APPEARING views are animated via
- * {@link ItemAnimator#animateAppearance(ViewHolder, ItemHolderInfo, ItemHolderInfo)}
- * and changed views are animated via
- * {@link ItemAnimator#animateChange(ViewHolder, ViewHolder, ItemHolderInfo, ItemHolderInfo)}.
- */
- void dispatchLayout() {
- if (mAdapter == null) {
- Log.w(TAG, "No adapter attached; skipping layout");
- // leave the state in START
- return;
- }
- if (mLayout == null) {
- Log.e(TAG, "No layout manager attached; skipping layout");
- // leave the state in START
- return;
- }
- mState.mIsMeasuring = false;
-
- // If the last time we measured children in onMeasure, we skipped the measurement and layout
- // of RV children because the MeasureSpec in both dimensions was EXACTLY, and current
- // dimensions of the RV are not equal to the last measured dimensions of RV, we need to
- // measure and layout children one last time.
- boolean needsRemeasureDueToExactSkip = mLastAutoMeasureSkippedDueToExact
- && (mLastAutoMeasureNonExactMeasuredWidth != getWidth()
- || mLastAutoMeasureNonExactMeasuredHeight != getHeight());
- mLastAutoMeasureNonExactMeasuredWidth = 0;
- mLastAutoMeasureNonExactMeasuredHeight = 0;
- mLastAutoMeasureSkippedDueToExact = false;
-
- if (mState.mLayoutStep == State.STEP_START) {
- dispatchLayoutStep1();
- mLayout.setExactMeasureSpecsFrom(this);
- dispatchLayoutStep2();
- } else if (mAdapterHelper.hasUpdates()
- || needsRemeasureDueToExactSkip
- || mLayout.getWidth() != getWidth()
- || mLayout.getHeight() != getHeight()) {
- // First 2 steps are done in onMeasure but looks like we have to run again due to
- // changed size.
-
- // TODO(shepshapard): Worth a note that I believe
- // "mLayout.getWidth() != getWidth() || mLayout.getHeight() != getHeight()" above is
- // not actually correct, causes unnecessary work to be done, and should be
- // removed. Removing causes many tests to fail and I didn't have the time to
- // investigate. Just a note for the a future reader or bug fixer.
- mLayout.setExactMeasureSpecsFrom(this);
- dispatchLayoutStep2();
- } else {
- // always make sure we sync them (to ensure mode is exact)
- mLayout.setExactMeasureSpecsFrom(this);
- }
- dispatchLayoutStep3();
- }
-
- private void saveFocusInfo() {
- View child = null;
- if (mPreserveFocusAfterLayout && hasFocus() && mAdapter != null) {
- child = getFocusedChild();
- }
-
- final ViewHolder focusedVh = child == null ? null : findContainingViewHolder(child);
- if (focusedVh == null) {
- resetFocusInfo();
- } else {
- mState.mFocusedItemId = mAdapter.hasStableIds() ? focusedVh.getItemId() : NO_ID;
- // mFocusedItemPosition should hold the current adapter position of the previously
- // focused item. If the item is removed, we store the previous adapter position of the
- // removed item.
- mState.mFocusedItemPosition = mDataSetHasChangedAfterLayout ? NO_POSITION
- : (focusedVh.isRemoved() ? focusedVh.mOldPosition
- : focusedVh.getAbsoluteAdapterPosition());
- mState.mFocusedSubChildId = getDeepestFocusedViewWithId(focusedVh.itemView);
- }
- }
-
- private void resetFocusInfo() {
- mState.mFocusedItemId = NO_ID;
- mState.mFocusedItemPosition = NO_POSITION;
- mState.mFocusedSubChildId = View.NO_ID;
- }
-
- /**
- * Finds the best view candidate to request focus on using mFocusedItemPosition index of the
- * previously focused item. It first traverses the adapter forward to find a focusable candidate
- * and if no such candidate is found, it reverses the focus search direction for the items
- * before the mFocusedItemPosition'th index;
- *
- * @return The best candidate to request focus on, or null if no such candidate exists. Null
- * indicates all the existing adapter items are unfocusable.
- */
- @Nullable
- private View findNextViewToFocus() {
- int startFocusSearchIndex = mState.mFocusedItemPosition != -1 ? mState.mFocusedItemPosition
- : 0;
- ViewHolder nextFocus;
- final int itemCount = mState.getItemCount();
- for (int i = startFocusSearchIndex; i < itemCount; i++) {
- nextFocus = findViewHolderForAdapterPosition(i);
- if (nextFocus == null) {
- break;
- }
- if (nextFocus.itemView.hasFocusable()) {
- return nextFocus.itemView;
- }
- }
- final int limit = Math.min(itemCount, startFocusSearchIndex);
- for (int i = limit - 1; i >= 0; i--) {
- nextFocus = findViewHolderForAdapterPosition(i);
- if (nextFocus == null) {
- return null;
- }
- if (nextFocus.itemView.hasFocusable()) {
- return nextFocus.itemView;
- }
- }
- return null;
- }
-
- private void recoverFocusFromState() {
- if (!mPreserveFocusAfterLayout || mAdapter == null || !hasFocus()
- || getDescendantFocusability() == FOCUS_BLOCK_DESCENDANTS
- || (getDescendantFocusability() == FOCUS_BEFORE_DESCENDANTS && isFocused())) {
- // No-op if either of these cases happens:
- // 1. RV has no focus, or 2. RV blocks focus to its children, or 3. RV takes focus
- // before its children and is focused (i.e. it already stole the focus away from its
- // descendants).
- return;
- }
- // only recover focus if RV itself has the focus or the focused view is hidden
- if (!isFocused()) {
- final View focusedChild = getFocusedChild();
- if (IGNORE_DETACHED_FOCUSED_CHILD
- && (focusedChild.getParent() == null || !focusedChild.hasFocus())) {
- // Special handling of API 15-. A focused child can be invalid because mFocus is not
- // cleared when the child is detached (mParent = null),
- // This happens because clearFocus on API 15- does not invalidate mFocus of its
- // parent when this child is detached.
- // For API 16+, this is not an issue because requestFocus takes care of clearing the
- // prior detached focused child. For API 15- the problem happens in 2 cases because
- // clearChild does not call clearChildFocus on RV: 1. setFocusable(false) is called
- // for the current focused item which calls clearChild or 2. when the prior focused
- // child is removed, removeDetachedView called in layout step 3 which calls
- // clearChild. We should ignore this invalid focused child in all our calculations
- // for the next view to receive focus, and apply the focus recovery logic instead.
- if (mChildHelper.getChildCount() == 0) {
- // No children left. Request focus on the RV itself since one of its children
- // was holding focus previously.
- requestFocus();
- return;
- }
- } else if (!mChildHelper.isHidden(focusedChild)) {
- // If the currently focused child is hidden, apply the focus recovery logic.
- // Otherwise return, i.e. the currently (unhidden) focused child is good enough :/.
- return;
- }
- }
- ViewHolder focusTarget = null;
- // RV first attempts to locate the previously focused item to request focus on using
- // mFocusedItemId. If such an item no longer exists, it then makes a best-effort attempt to
- // find the next best candidate to request focus on based on mFocusedItemPosition.
- if (mState.mFocusedItemId != NO_ID && mAdapter.hasStableIds()) {
- focusTarget = findViewHolderForItemId(mState.mFocusedItemId);
- }
- View viewToFocus = null;
- if (focusTarget == null || mChildHelper.isHidden(focusTarget.itemView)
- || !focusTarget.itemView.hasFocusable()) {
- if (mChildHelper.getChildCount() > 0) {
- // At this point, RV has focus and either of these conditions are true:
- // 1. There's no previously focused item either because RV received focused before
- // layout, or the previously focused item was removed, or RV doesn't have stable IDs
- // 2. Previous focus child is hidden, or 3. Previous focused child is no longer
- // focusable. In either of these cases, we make sure that RV still passes down the
- // focus to one of its focusable children using a best-effort algorithm.
- viewToFocus = findNextViewToFocus();
- }
- } else {
- // looks like the focused item has been replaced with another view that represents the
- // same item in the adapter. Request focus on that.
- viewToFocus = focusTarget.itemView;
- }
-
- if (viewToFocus != null) {
- if (mState.mFocusedSubChildId != NO_ID) {
- View child = viewToFocus.findViewById(mState.mFocusedSubChildId);
- if (child != null && child.isFocusable()) {
- viewToFocus = child;
- }
- }
- viewToFocus.requestFocus();
- }
- }
-
- private int getDeepestFocusedViewWithId(View view) {
- int lastKnownId = view.getId();
- while (!view.isFocused() && view instanceof ViewGroup && view.hasFocus()) {
- view = ((ViewGroup) view).getFocusedChild();
- final int id = view.getId();
- if (id != View.NO_ID) {
- lastKnownId = view.getId();
- }
- }
- return lastKnownId;
- }
-
- final void fillRemainingScrollValues(State state) {
- if (getScrollState() == SCROLL_STATE_SETTLING) {
- final OverScroller scroller = mViewFlinger.mOverScroller;
- state.mRemainingScrollHorizontal = scroller.getFinalX() - scroller.getCurrX();
- state.mRemainingScrollVertical = scroller.getFinalY() - scroller.getCurrY();
- } else {
- state.mRemainingScrollHorizontal = 0;
- state.mRemainingScrollVertical = 0;
- }
- }
-
- /**
- * The first step of a layout where we;
- * - process adapter updates
- * - decide which animation should run
- * - save information about current views
- * - If necessary, run predictive layout and save its information
- */
- private void dispatchLayoutStep1() {
- mState.assertLayoutStep(State.STEP_START);
- fillRemainingScrollValues(mState);
- mState.mIsMeasuring = false;
- startInterceptRequestLayout();
- mViewInfoStore.clear();
- onEnterLayoutOrScroll();
- processAdapterUpdatesAndSetAnimationFlags();
- saveFocusInfo();
- mState.mTrackOldChangeHolders = mState.mRunSimpleAnimations && mItemsChanged;
- mItemsAddedOrRemoved = mItemsChanged = false;
- mState.mInPreLayout = mState.mRunPredictiveAnimations;
- mState.mItemCount = mAdapter.getItemCount();
- findMinMaxChildLayoutPositions(mMinMaxLayoutPositions);
-
- if (mState.mRunSimpleAnimations) {
- // Step 0: Find out where all non-removed items are, pre-layout
- int count = mChildHelper.getChildCount();
- for (int i = 0; i < count; ++i) {
- final ViewHolder holder = getChildViewHolderInt(mChildHelper.getChildAt(i));
- if (holder.shouldIgnore() || (holder.isInvalid() && !mAdapter.hasStableIds())) {
- continue;
- }
- final ItemHolderInfo animationInfo = mItemAnimator
- .recordPreLayoutInformation(mState, holder,
- ItemAnimator.buildAdapterChangeFlagsForAnimations(holder),
- holder.getUnmodifiedPayloads());
- mViewInfoStore.addToPreLayout(holder, animationInfo);
- if (mState.mTrackOldChangeHolders && holder.isUpdated() && !holder.isRemoved()
- && !holder.shouldIgnore() && !holder.isInvalid()) {
- long key = getChangedHolderKey(holder);
- // This is NOT the only place where a ViewHolder is added to old change holders
- // list. There is another case where:
- // * A VH is currently hidden but not deleted
- // * The hidden item is changed in the adapter
- // * Layout manager decides to layout the item in the pre-Layout pass (step1)
- // When this case is detected, RV will un-hide that view and add to the old
- // change holders list.
- mViewInfoStore.addToOldChangeHolders(key, holder);
- }
- }
- }
- if (mState.mRunPredictiveAnimations) {
- // Step 1: run prelayout: This will use the old positions of items. The layout manager
- // is expected to layout everything, even removed items (though not to add removed
- // items back to the container). This gives the pre-layout position of APPEARING views
- // which come into existence as part of the real layout.
-
- // Save old positions so that LayoutManager can run its mapping logic.
- saveOldPositions();
- final boolean didStructureChange = mState.mStructureChanged;
- mState.mStructureChanged = false;
- // temporarily disable flag because we are asking for previous layout
- mLayout.onLayoutChildren(mRecycler, mState);
- mState.mStructureChanged = didStructureChange;
-
- for (int i = 0; i < mChildHelper.getChildCount(); ++i) {
- final View child = mChildHelper.getChildAt(i);
- final ViewHolder viewHolder = getChildViewHolderInt(child);
- if (viewHolder.shouldIgnore()) {
- continue;
- }
- if (!mViewInfoStore.isInPreLayout(viewHolder)) {
- int flags = ItemAnimator.buildAdapterChangeFlagsForAnimations(viewHolder);
- boolean wasHidden = viewHolder
- .hasAnyOfTheFlags(ViewHolder.FLAG_BOUNCED_FROM_HIDDEN_LIST);
- if (!wasHidden) {
- flags |= ItemAnimator.FLAG_APPEARED_IN_PRE_LAYOUT;
- }
- final ItemHolderInfo animationInfo = mItemAnimator.recordPreLayoutInformation(
- mState, viewHolder, flags, viewHolder.getUnmodifiedPayloads());
- if (wasHidden) {
- recordAnimationInfoIfBouncedHiddenView(viewHolder, animationInfo);
- } else {
- mViewInfoStore.addToAppearedInPreLayoutHolders(viewHolder, animationInfo);
- }
- }
- }
- // we don't process disappearing list because they may re-appear in post layout pass.
- clearOldPositions();
- } else {
- clearOldPositions();
- }
- onExitLayoutOrScroll();
- stopInterceptRequestLayout(false);
- mState.mLayoutStep = State.STEP_LAYOUT;
- }
-
- /**
- * The second layout step where we do the actual layout of the views for the final state.
- * This step might be run multiple times if necessary (e.g. measure).
- */
- private void dispatchLayoutStep2() {
- startInterceptRequestLayout();
- onEnterLayoutOrScroll();
- mState.assertLayoutStep(State.STEP_LAYOUT | State.STEP_ANIMATIONS);
- mAdapterHelper.consumeUpdatesInOnePass();
- mState.mItemCount = mAdapter.getItemCount();
- mState.mDeletedInvisibleItemCountSincePreviousLayout = 0;
- if (mPendingSavedState != null && mAdapter.canRestoreState()) {
- if (mPendingSavedState.mLayoutState != null) {
- mLayout.onRestoreInstanceState(mPendingSavedState.mLayoutState);
- }
- mPendingSavedState = null;
- }
- // Step 2: Run layout
- mState.mInPreLayout = false;
- mLayout.onLayoutChildren(mRecycler, mState);
-
- mState.mStructureChanged = false;
-
- // onLayoutChildren may have caused client code to disable item animations; re-check
- mState.mRunSimpleAnimations = mState.mRunSimpleAnimations && mItemAnimator != null;
- mState.mLayoutStep = State.STEP_ANIMATIONS;
- onExitLayoutOrScroll();
- stopInterceptRequestLayout(false);
- }
-
- /**
- * The final step of the layout where we save the information about views for animations,
- * trigger animations and do any necessary cleanup.
- */
- private void dispatchLayoutStep3() {
- mState.assertLayoutStep(State.STEP_ANIMATIONS);
- startInterceptRequestLayout();
- onEnterLayoutOrScroll();
- mState.mLayoutStep = State.STEP_START;
- if (mState.mRunSimpleAnimations) {
- // Step 3: Find out where things are now, and process change animations.
- // traverse list in reverse because we may call animateChange in the loop which may
- // remove the target view holder.
- for (int i = mChildHelper.getChildCount() - 1; i >= 0; i--) {
- ViewHolder holder = getChildViewHolderInt(mChildHelper.getChildAt(i));
- if (holder.shouldIgnore()) {
- continue;
- }
- long key = getChangedHolderKey(holder);
- final ItemHolderInfo animationInfo = mItemAnimator
- .recordPostLayoutInformation(mState, holder);
- ViewHolder oldChangeViewHolder = mViewInfoStore.getFromOldChangeHolders(key);
- if (oldChangeViewHolder != null && !oldChangeViewHolder.shouldIgnore()) {
- // run a change animation
-
- // If an Item is CHANGED but the updated version is disappearing, it creates
- // a conflicting case.
- // Since a view that is marked as disappearing is likely to be going out of
- // bounds, we run a change animation. Both views will be cleaned automatically
- // once their animations finish.
- // On the other hand, if it is the same view holder instance, we run a
- // disappearing animation instead because we are not going to rebind the updated
- // VH unless it is enforced by the layout manager.
- final boolean oldDisappearing = mViewInfoStore.isDisappearing(
- oldChangeViewHolder);
- final boolean newDisappearing = mViewInfoStore.isDisappearing(holder);
- if (oldDisappearing && oldChangeViewHolder == holder) {
- // run disappear animation instead of change
- mViewInfoStore.addToPostLayout(holder, animationInfo);
- } else {
- final ItemHolderInfo preInfo = mViewInfoStore.popFromPreLayout(
- oldChangeViewHolder);
- // we add and remove so that any post info is merged.
- mViewInfoStore.addToPostLayout(holder, animationInfo);
- ItemHolderInfo postInfo = mViewInfoStore.popFromPostLayout(holder);
- if (preInfo == null) {
- handleMissingPreInfoForChangeError(key, holder, oldChangeViewHolder);
- } else {
- animateChange(oldChangeViewHolder, holder, preInfo, postInfo,
- oldDisappearing, newDisappearing);
- }
- }
- } else {
- mViewInfoStore.addToPostLayout(holder, animationInfo);
- }
- }
-
- // Step 4: Process view info lists and trigger animations
- mViewInfoStore.process(mViewInfoProcessCallback);
- }
-
- mLayout.removeAndRecycleScrapInt(mRecycler);
- mState.mPreviousLayoutItemCount = mState.mItemCount;
- mDataSetHasChangedAfterLayout = false;
- mDispatchItemsChangedEvent = false;
- mState.mRunSimpleAnimations = false;
-
- mState.mRunPredictiveAnimations = false;
- mLayout.mRequestedSimpleAnimations = false;
- if (mRecycler.mChangedScrap != null) {
- mRecycler.mChangedScrap.clear();
- }
- if (mLayout.mPrefetchMaxObservedInInitialPrefetch) {
- // Initial prefetch has expanded cache, so reset until next prefetch.
- // This prevents initial prefetches from expanding the cache permanently.
- mLayout.mPrefetchMaxCountObserved = 0;
- mLayout.mPrefetchMaxObservedInInitialPrefetch = false;
- mRecycler.updateViewCacheSize();
- }
-
- mLayout.onLayoutCompleted(mState);
- onExitLayoutOrScroll();
- stopInterceptRequestLayout(false);
- mViewInfoStore.clear();
- if (didChildRangeChange(mMinMaxLayoutPositions[0], mMinMaxLayoutPositions[1])) {
- dispatchOnScrolled(0, 0);
- }
- recoverFocusFromState();
- resetFocusInfo();
- }
-
- /**
- * This handles the case where there is an unexpected VH missing in the pre-layout map.
- *
- * We might be able to detect the error in the application which will help the developer to
- * resolve the issue.
- *
- * If it is not an expected error, we at least print an error to notify the developer and ignore
- * the animation.
- *
- * https://code.google.com/p/android/issues/detail?id=193958
- *
- * @param key The change key
- * @param holder Current ViewHolder
- * @param oldChangeViewHolder Changed ViewHolder
- */
- private void handleMissingPreInfoForChangeError(long key,
- ViewHolder holder, ViewHolder oldChangeViewHolder) {
- // check if two VH have the same key, if so, print that as an error
- final int childCount = mChildHelper.getChildCount();
- for (int i = 0; i < childCount; i++) {
- View view = mChildHelper.getChildAt(i);
- ViewHolder other = getChildViewHolderInt(view);
- if (other == holder) {
- continue;
- }
- final long otherKey = getChangedHolderKey(other);
- if (otherKey == key) {
- if (mAdapter != null && mAdapter.hasStableIds()) {
- throw new IllegalStateException("Two different ViewHolders have the same stable"
- + " ID. Stable IDs in your adapter MUST BE unique and SHOULD NOT"
- + " change.\n ViewHolder 1:" + other + " \n View Holder 2:" + holder
- + exceptionLabel());
- } else {
- throw new IllegalStateException("Two different ViewHolders have the same change"
- + " ID. This might happen due to inconsistent Adapter update events or"
- + " if the LayoutManager lays out the same View multiple times."
- + "\n ViewHolder 1:" + other + " \n View Holder 2:" + holder
- + exceptionLabel());
- }
- }
- }
- // Very unlikely to happen but if it does, notify the developer.
- Log.e(TAG, "Problem while matching changed view holders with the new"
- + "ones. The pre-layout information for the change holder " + oldChangeViewHolder
- + " cannot be found but it is necessary for " + holder + exceptionLabel());
- }
-
- /**
- * Records the animation information for a view holder that was bounced from hidden list. It
- * also clears the bounce back flag.
- */
- void recordAnimationInfoIfBouncedHiddenView(ViewHolder viewHolder,
- ItemHolderInfo animationInfo) {
- // looks like this view bounced back from hidden list!
- viewHolder.setFlags(0, ViewHolder.FLAG_BOUNCED_FROM_HIDDEN_LIST);
- if (mState.mTrackOldChangeHolders && viewHolder.isUpdated()
- && !viewHolder.isRemoved() && !viewHolder.shouldIgnore()) {
- long key = getChangedHolderKey(viewHolder);
- mViewInfoStore.addToOldChangeHolders(key, viewHolder);
- }
- mViewInfoStore.addToPreLayout(viewHolder, animationInfo);
- }
-
- private void findMinMaxChildLayoutPositions(int[] into) {
- final int count = mChildHelper.getChildCount();
- if (count == 0) {
- into[0] = NO_POSITION;
- into[1] = NO_POSITION;
- return;
- }
- int minPositionPreLayout = Integer.MAX_VALUE;
- int maxPositionPreLayout = Integer.MIN_VALUE;
- for (int i = 0; i < count; ++i) {
- final ViewHolder holder = getChildViewHolderInt(mChildHelper.getChildAt(i));
- if (holder.shouldIgnore()) {
- continue;
- }
- final int pos = holder.getLayoutPosition();
- if (pos < minPositionPreLayout) {
- minPositionPreLayout = pos;
- }
- if (pos > maxPositionPreLayout) {
- maxPositionPreLayout = pos;
- }
- }
- into[0] = minPositionPreLayout;
- into[1] = maxPositionPreLayout;
- }
-
- private boolean didChildRangeChange(int minPositionPreLayout, int maxPositionPreLayout) {
- findMinMaxChildLayoutPositions(mMinMaxLayoutPositions);
- return mMinMaxLayoutPositions[0] != minPositionPreLayout
- || mMinMaxLayoutPositions[1] != maxPositionPreLayout;
- }
-
- @Override
- protected void removeDetachedView(View child, boolean animate) {
- ViewHolder vh = getChildViewHolderInt(child);
- if (vh != null) {
- if (vh.isTmpDetached()) {
- vh.clearTmpDetachFlag();
- } else if (!vh.shouldIgnore()) {
- throw new IllegalArgumentException("Called removeDetachedView with a view which"
- + " is not flagged as tmp detached." + vh + exceptionLabel());
- }
- } else {
- if (sDebugAssertionsEnabled) {
- throw new IllegalArgumentException(
- "No ViewHolder found for child: " + child + exceptionLabel());
- }
- }
-
- // Clear any android.view.animation.Animation that may prevent the item from
- // detaching when being removed. If a child is re-added before the
- // lazy detach occurs, it will receive invalid attach/detach sequencing.
- child.clearAnimation();
-
- dispatchChildDetached(child);
- super.removeDetachedView(child, animate);
- }
-
- /**
- * Returns a unique key to be used while handling change animations.
- * It might be child's position or stable id depending on the adapter type.
- */
- long getChangedHolderKey(ViewHolder holder) {
- return mAdapter.hasStableIds() ? holder.getItemId() : holder.mPosition;
- }
-
- void animateAppearance(@NonNull ViewHolder itemHolder,
- @Nullable ItemHolderInfo preLayoutInfo, @NonNull ItemHolderInfo postLayoutInfo) {
- itemHolder.setIsRecyclable(false);
- if (mItemAnimator.animateAppearance(itemHolder, preLayoutInfo, postLayoutInfo)) {
- postAnimationRunner();
- }
- }
-
- void animateDisappearance(@NonNull ViewHolder holder,
- @NonNull ItemHolderInfo preLayoutInfo, @Nullable ItemHolderInfo postLayoutInfo) {
- addAnimatingView(holder);
- holder.setIsRecyclable(false);
- if (mItemAnimator.animateDisappearance(holder, preLayoutInfo, postLayoutInfo)) {
- postAnimationRunner();
- }
- }
-
- private void animateChange(@NonNull ViewHolder oldHolder, @NonNull ViewHolder newHolder,
- @NonNull ItemHolderInfo preInfo, @NonNull ItemHolderInfo postInfo,
- boolean oldHolderDisappearing, boolean newHolderDisappearing) {
- oldHolder.setIsRecyclable(false);
- if (oldHolderDisappearing) {
- addAnimatingView(oldHolder);
- }
- if (oldHolder != newHolder) {
- if (newHolderDisappearing) {
- addAnimatingView(newHolder);
- }
- oldHolder.mShadowedHolder = newHolder;
- // old holder should disappear after animation ends
- addAnimatingView(oldHolder);
- mRecycler.unscrapView(oldHolder);
- newHolder.setIsRecyclable(false);
- newHolder.mShadowingHolder = oldHolder;
- }
- if (mItemAnimator.animateChange(oldHolder, newHolder, preInfo, postInfo)) {
- postAnimationRunner();
- }
- }
-
- @Override
- protected void onLayout(boolean changed, int l, int t, int r, int b) {
- TraceCompat.beginSection(TRACE_ON_LAYOUT_TAG);
- dispatchLayout();
- TraceCompat.endSection();
- mFirstLayoutComplete = true;
- }
-
- @Override
- public void requestLayout() {
- if (mInterceptRequestLayoutDepth == 0 && !mLayoutSuppressed) {
- super.requestLayout();
- } else {
- mLayoutWasDefered = true;
- }
- }
-
- void markItemDecorInsetsDirty() {
- final int childCount = mChildHelper.getUnfilteredChildCount();
- for (int i = 0; i < childCount; i++) {
- final View child = mChildHelper.getUnfilteredChildAt(i);
- ((LayoutParams) child.getLayoutParams()).mInsetsDirty = true;
- }
- mRecycler.markItemDecorInsetsDirty();
- }
-
- @Override
- public void draw(Canvas c) {
- super.draw(c);
-
- final int count = mItemDecorations.size();
- for (int i = 0; i < count; i++) {
- mItemDecorations.get(i).onDrawOver(c, this, mState);
- }
- // TODO If padding is not 0 and clipChildrenToPadding is false, to draw glows properly, we
- // need find children closest to edges. Not sure if it is worth the effort.
- boolean needsInvalidate = false;
- if (mLeftGlow != null && !mLeftGlow.isFinished()) {
- final int restore = c.save();
- final int padding = mClipToPadding ? getPaddingBottom() : 0;
- c.rotate(270);
- c.translate(-getHeight() + padding, 0);
- needsInvalidate = mLeftGlow != null && mLeftGlow.draw(c);
- c.restoreToCount(restore);
- }
- if (mTopGlow != null && !mTopGlow.isFinished()) {
- final int restore = c.save();
- if (mClipToPadding) {
- c.translate(getPaddingLeft(), getPaddingTop());
- }
- needsInvalidate |= mTopGlow != null && mTopGlow.draw(c);
- c.restoreToCount(restore);
- }
- if (mRightGlow != null && !mRightGlow.isFinished()) {
- final int restore = c.save();
- final int width = getWidth();
- final int padding = mClipToPadding ? getPaddingTop() : 0;
- c.rotate(90);
- c.translate(padding, -width);
- needsInvalidate |= mRightGlow != null && mRightGlow.draw(c);
- c.restoreToCount(restore);
- }
- if (mBottomGlow != null && !mBottomGlow.isFinished()) {
- final int restore = c.save();
- c.rotate(180);
- if (mClipToPadding) {
- c.translate(-getWidth() + getPaddingRight(), -getHeight() + getPaddingBottom());
- } else {
- c.translate(-getWidth(), -getHeight());
- }
- needsInvalidate |= mBottomGlow != null && mBottomGlow.draw(c);
- c.restoreToCount(restore);
- }
-
- // If some views are animating, ItemDecorators are likely to move/change with them.
- // Invalidate RecyclerView to re-draw decorators. This is still efficient because children's
- // display lists are not invalidated.
- if (!needsInvalidate && mItemAnimator != null && mItemDecorations.size() > 0
- && mItemAnimator.isRunning()) {
- needsInvalidate = true;
- }
-
- if (needsInvalidate) {
- ViewCompat.postInvalidateOnAnimation(this);
- }
- }
-
- @Override
- public void onDraw(Canvas c) {
- super.onDraw(c);
-
- final int count = mItemDecorations.size();
- for (int i = 0; i < count; i++) {
- mItemDecorations.get(i).onDraw(c, this, mState);
- }
- }
-
- @Override
- protected boolean checkLayoutParams(ViewGroup.LayoutParams p) {
- return p instanceof LayoutParams && mLayout.checkLayoutParams((LayoutParams) p);
- }
-
- @Override
- protected ViewGroup.LayoutParams generateDefaultLayoutParams() {
- if (mLayout == null) {
- throw new IllegalStateException("RecyclerView has no LayoutManager" + exceptionLabel());
- }
- return mLayout.generateDefaultLayoutParams();
- }
-
- @Override
- public ViewGroup.LayoutParams generateLayoutParams(AttributeSet attrs) {
- if (mLayout == null) {
- throw new IllegalStateException("RecyclerView has no LayoutManager" + exceptionLabel());
- }
- return mLayout.generateLayoutParams(getContext(), attrs);
- }
-
- @Override
- protected ViewGroup.LayoutParams generateLayoutParams(ViewGroup.LayoutParams p) {
- if (mLayout == null) {
- throw new IllegalStateException("RecyclerView has no LayoutManager" + exceptionLabel());
- }
- return mLayout.generateLayoutParams(p);
- }
-
- /**
- * Returns true if RecyclerView is currently running some animations.
- *
- * If you want to be notified when animations are finished, use
- * {@link ItemAnimator#isRunning(ItemAnimator.ItemAnimatorFinishedListener)}.
- *
- * @return True if there are some item animations currently running or waiting to be started.
- */
- public boolean isAnimating() {
- return mItemAnimator != null && mItemAnimator.isRunning();
- }
-
- void saveOldPositions() {
- final int childCount = mChildHelper.getUnfilteredChildCount();
- for (int i = 0; i < childCount; i++) {
- final ViewHolder holder = getChildViewHolderInt(mChildHelper.getUnfilteredChildAt(i));
- if (sDebugAssertionsEnabled && holder.mPosition == -1 && !holder.isRemoved()) {
- throw new IllegalStateException("view holder cannot have position -1 unless it"
- + " is removed" + exceptionLabel());
- }
- if (!holder.shouldIgnore()) {
- holder.saveOldPosition();
- }
- }
- }
-
- void clearOldPositions() {
- final int childCount = mChildHelper.getUnfilteredChildCount();
- for (int i = 0; i < childCount; i++) {
- final ViewHolder holder = getChildViewHolderInt(mChildHelper.getUnfilteredChildAt(i));
- if (!holder.shouldIgnore()) {
- holder.clearOldPosition();
- }
- }
- mRecycler.clearOldPositions();
- }
-
- void offsetPositionRecordsForMove(int from, int to) {
- final int childCount = mChildHelper.getUnfilteredChildCount();
- final int start, end, inBetweenOffset;
- if (from < to) {
- start = from;
- end = to;
- inBetweenOffset = -1;
- } else {
- start = to;
- end = from;
- inBetweenOffset = 1;
- }
-
- for (int i = 0; i < childCount; i++) {
- final ViewHolder holder = getChildViewHolderInt(mChildHelper.getUnfilteredChildAt(i));
- if (holder == null || holder.mPosition < start || holder.mPosition > end) {
- continue;
- }
- if (sVerboseLoggingEnabled) {
- Log.d(TAG, "offsetPositionRecordsForMove attached child " + i + " holder "
- + holder);
- }
- if (holder.mPosition == from) {
- holder.offsetPosition(to - from, false);
- } else {
- holder.offsetPosition(inBetweenOffset, false);
- }
-
- mState.mStructureChanged = true;
- }
- mRecycler.offsetPositionRecordsForMove(from, to);
- requestLayout();
- }
-
- void offsetPositionRecordsForInsert(int positionStart, int itemCount) {
- final int childCount = mChildHelper.getUnfilteredChildCount();
- for (int i = 0; i < childCount; i++) {
- final ViewHolder holder = getChildViewHolderInt(mChildHelper.getUnfilteredChildAt(i));
- if (holder != null && !holder.shouldIgnore() && holder.mPosition >= positionStart) {
- if (sVerboseLoggingEnabled) {
- Log.d(TAG, "offsetPositionRecordsForInsert attached child " + i + " holder "
- + holder + " now at position " + (holder.mPosition + itemCount));
- }
- holder.offsetPosition(itemCount, false);
- mState.mStructureChanged = true;
- }
- }
- mRecycler.offsetPositionRecordsForInsert(positionStart, itemCount);
- requestLayout();
- }
-
- void offsetPositionRecordsForRemove(int positionStart, int itemCount,
- boolean applyToPreLayout) {
- final int positionEnd = positionStart + itemCount;
- final int childCount = mChildHelper.getUnfilteredChildCount();
- for (int i = 0; i < childCount; i++) {
- final ViewHolder holder = getChildViewHolderInt(mChildHelper.getUnfilteredChildAt(i));
- if (holder != null && !holder.shouldIgnore()) {
- if (holder.mPosition >= positionEnd) {
- if (sVerboseLoggingEnabled) {
- Log.d(TAG, "offsetPositionRecordsForRemove attached child " + i
- + " holder " + holder + " now at position "
- + (holder.mPosition - itemCount));
- }
- holder.offsetPosition(-itemCount, applyToPreLayout);
- mState.mStructureChanged = true;
- } else if (holder.mPosition >= positionStart) {
- if (sVerboseLoggingEnabled) {
- Log.d(TAG, "offsetPositionRecordsForRemove attached child " + i
- + " holder " + holder + " now REMOVED");
- }
- holder.flagRemovedAndOffsetPosition(positionStart - 1, -itemCount,
- applyToPreLayout);
- mState.mStructureChanged = true;
- }
- }
- }
- mRecycler.offsetPositionRecordsForRemove(positionStart, itemCount, applyToPreLayout);
- requestLayout();
- }
-
- /**
- * Rebind existing views for the given range, or create as needed.
- *
- * @param positionStart Adapter position to start at
- * @param itemCount Number of views that must explicitly be rebound
- */
- void viewRangeUpdate(int positionStart, int itemCount, Object payload) {
- final int childCount = mChildHelper.getUnfilteredChildCount();
- final int positionEnd = positionStart + itemCount;
-
- for (int i = 0; i < childCount; i++) {
- final View child = mChildHelper.getUnfilteredChildAt(i);
- final ViewHolder holder = getChildViewHolderInt(child);
- if (holder == null || holder.shouldIgnore()) {
- continue;
- }
- if (holder.mPosition >= positionStart && holder.mPosition < positionEnd) {
- // We re-bind these view holders after pre-processing is complete so that
- // ViewHolders have their final positions assigned.
- holder.addFlags(ViewHolder.FLAG_UPDATE);
- holder.addChangePayload(payload);
- // lp cannot be null since we get ViewHolder from it.
- ((LayoutParams) child.getLayoutParams()).mInsetsDirty = true;
- }
- }
- mRecycler.viewRangeUpdate(positionStart, itemCount);
- }
-
- boolean canReuseUpdatedViewHolder(ViewHolder viewHolder) {
- return mItemAnimator == null || mItemAnimator.canReuseUpdatedViewHolder(viewHolder,
- viewHolder.getUnmodifiedPayloads());
- }
-
- /**
- * Processes the fact that, as far as we can tell, the data set has completely changed.
- *
- *
- * Once layout occurs, all attached items should be discarded or animated.
- * Attached items are labeled as invalid.
- * Because items may still be prefetched between a "data set completely changed"
- * event and a layout event, all cached items are discarded.
- *
- *
- * @param dispatchItemsChanged Whether to call
- * {@link LayoutManager#onItemsChanged(RecyclerView)} during
- * measure/layout.
- */
- void processDataSetCompletelyChanged(boolean dispatchItemsChanged) {
- mDispatchItemsChangedEvent |= dispatchItemsChanged;
- mDataSetHasChangedAfterLayout = true;
- markKnownViewsInvalid();
- }
-
- /**
- * Mark all known views as invalid. Used in response to a, "the whole world might have changed"
- * data change event.
- */
- void markKnownViewsInvalid() {
- final int childCount = mChildHelper.getUnfilteredChildCount();
- for (int i = 0; i < childCount; i++) {
- final ViewHolder holder = getChildViewHolderInt(mChildHelper.getUnfilteredChildAt(i));
- if (holder != null && !holder.shouldIgnore()) {
- holder.addFlags(ViewHolder.FLAG_UPDATE | ViewHolder.FLAG_INVALID);
- }
- }
- markItemDecorInsetsDirty();
- mRecycler.markKnownViewsInvalid();
- }
-
- /**
- * Invalidates all ItemDecorations. If RecyclerView has item decorations, calling this method
- * will trigger a {@link #requestLayout()} call.
- */
- public void invalidateItemDecorations() {
- if (mItemDecorations.size() == 0) {
- return;
- }
- if (mLayout != null) {
- mLayout.assertNotInLayoutOrScroll("Cannot invalidate item decorations during a scroll"
- + " or layout");
- }
- markItemDecorInsetsDirty();
- requestLayout();
- }
-
- /**
- * Returns true if the RecyclerView should attempt to preserve currently focused Adapter Item's
- * focus even if the View representing the Item is replaced during a layout calculation.
- *
- * By default, this value is {@code true}.
- *
- * @return True if the RecyclerView will try to preserve focused Item after a layout if it loses
- * focus.
- * @see #setPreserveFocusAfterLayout(boolean)
- */
- public boolean getPreserveFocusAfterLayout() {
- return mPreserveFocusAfterLayout;
- }
-
- /**
- * Set whether the RecyclerView should try to keep the same Item focused after a layout
- * calculation or not.
- *
- * Usually, LayoutManagers keep focused views visible before and after layout but sometimes,
- * views may lose focus during a layout calculation as their state changes or they are replaced
- * with another view due to type change or animation. In these cases, RecyclerView can request
- * focus on the new view automatically.
- *
- * @param preserveFocusAfterLayout Whether RecyclerView should preserve focused Item during a
- * layout calculations. Defaults to true.
- * @see #getPreserveFocusAfterLayout()
- */
- public void setPreserveFocusAfterLayout(boolean preserveFocusAfterLayout) {
- mPreserveFocusAfterLayout = preserveFocusAfterLayout;
- }
-
- /**
- * Retrieve the {@link ViewHolder} for the given child view.
- *
- * @param child Child of this RecyclerView to query for its ViewHolder
- * @return The child view's ViewHolder
- */
- public ViewHolder getChildViewHolder(@NonNull View child) {
- final ViewParent parent = child.getParent();
- if (parent != null && parent != this) {
- throw new IllegalArgumentException("View " + child + " is not a direct child of "
- + this);
- }
- return getChildViewHolderInt(child);
- }
-
- /**
- * Traverses the ancestors of the given view and returns the item view that contains it and
- * also a direct child of the RecyclerView. This returned view can be used to get the
- * ViewHolder by calling {@link #getChildViewHolder(View)}.
- *
- * @param view The view that is a descendant of the RecyclerView.
- * @return The direct child of the RecyclerView which contains the given view or null if the
- * provided view is not a descendant of this RecyclerView.
- * @see #getChildViewHolder(View)
- * @see #findContainingViewHolder(View)
- */
- @Nullable
- public View findContainingItemView(@NonNull View view) {
- ViewParent parent = view.getParent();
- while (parent != null && parent != this && parent instanceof View) {
- view = (View) parent;
- parent = view.getParent();
- }
- return parent == this ? view : null;
- }
-
- /**
- * Returns the ViewHolder that contains the given view.
- *
- * @param view The view that is a descendant of the RecyclerView.
- * @return The ViewHolder that contains the given view or null if the provided view is not a
- * descendant of this RecyclerView.
- */
- @Nullable
- public ViewHolder findContainingViewHolder(@NonNull View view) {
- View itemView = findContainingItemView(view);
- return itemView == null ? null : getChildViewHolder(itemView);
- }
-
-
- static ViewHolder getChildViewHolderInt(View child) {
- if (child == null) {
- return null;
- }
- return ((LayoutParams) child.getLayoutParams()).mViewHolder;
- }
-
- /**
- * @deprecated use {@link #getChildAdapterPosition(View)} or
- * {@link #getChildLayoutPosition(View)}.
- */
- @Deprecated
- public int getChildPosition(@NonNull View child) {
- return getChildAdapterPosition(child);
- }
-
- /**
- * Return the adapter position that the given child view corresponds to.
- *
- * @param child Child View to query
- * @return Adapter position corresponding to the given view or {@link #NO_POSITION}
- */
- public int getChildAdapterPosition(@NonNull View child) {
- final ViewHolder holder = getChildViewHolderInt(child);
- return holder != null ? holder.getAbsoluteAdapterPosition() : NO_POSITION;
- }
-
- /**
- * Return the adapter position of the given child view as of the latest completed layout pass.
- *
- * This position may not be equal to Item's adapter position if there are pending changes
- * in the adapter which have not been reflected to the layout yet.
- *
- * @param child Child View to query
- * @return Adapter position of the given View as of last layout pass or {@link #NO_POSITION} if
- * the View is representing a removed item.
- */
- public int getChildLayoutPosition(@NonNull View child) {
- final ViewHolder holder = getChildViewHolderInt(child);
- return holder != null ? holder.getLayoutPosition() : NO_POSITION;
- }
-
- /**
- * Return the stable item id that the given child view corresponds to.
- *
- * @param child Child View to query
- * @return Item id corresponding to the given view or {@link #NO_ID}
- */
- public long getChildItemId(@NonNull View child) {
- if (mAdapter == null || !mAdapter.hasStableIds()) {
- return NO_ID;
- }
- final ViewHolder holder = getChildViewHolderInt(child);
- return holder != null ? holder.getItemId() : NO_ID;
- }
-
- /**
- * @deprecated use {@link #findViewHolderForLayoutPosition(int)} or
- * {@link #findViewHolderForAdapterPosition(int)}
- */
- @Deprecated
- @Nullable
- public ViewHolder findViewHolderForPosition(int position) {
- return findViewHolderForPosition(position, false);
- }
-
- /**
- * Return the ViewHolder for the item in the given position of the data set as of the latest
- * layout pass.
- *
- * This method checks only the children of RecyclerView. If the item at the given
- * position is not laid out, it will not create a new one.
- *
- * Note that when Adapter contents change, ViewHolder positions are not updated until the
- * next layout calculation. If there are pending adapter updates, the return value of this
- * method may not match your adapter contents. You can use
- * #{@link ViewHolder#getBindingAdapterPosition()} to get the current adapter position
- * of a ViewHolder. If the {@link Adapter} that is assigned to the RecyclerView is an adapter
- * that combines other adapters (e.g. {@link ConcatAdapter}), you can use the
- * {@link ViewHolder#getBindingAdapter()}) to find the position relative to the {@link Adapter}
- * that bound the {@link ViewHolder}.
- *
- * When the ItemAnimator is running a change animation, there might be 2 ViewHolders
- * with the same layout position representing the same Item. In this case, the updated
- * ViewHolder will be returned.
- *
- * @param position The position of the item in the data set of the adapter
- * @return The ViewHolder at position or null if there is no such item
- */
- @Nullable
- public ViewHolder findViewHolderForLayoutPosition(int position) {
- return findViewHolderForPosition(position, false);
- }
-
- /**
- * Return the ViewHolder for the item in the given position of the data set. Unlike
- * {@link #findViewHolderForLayoutPosition(int)} this method takes into account any pending
- * adapter changes that may not be reflected to the layout yet. On the other hand, if
- * {@link Adapter#notifyDataSetChanged()} has been called but the new layout has not been
- * calculated yet, this method will return null since the new positions of views
- * are unknown until the layout is calculated.
- *
- * This method checks only the children of RecyclerView. If the item at the given
- * position is not laid out, it will not create a new one.
- *
- * When the ItemAnimator is running a change animation, there might be 2 ViewHolders
- * representing the same Item. In this case, the updated ViewHolder will be returned.
- *
- * @param position The position of the item in the data set of the adapter
- * @return The ViewHolder at position or null if there is no such item
- */
- @Nullable
- public ViewHolder findViewHolderForAdapterPosition(int position) {
- if (mDataSetHasChangedAfterLayout) {
- return null;
- }
- final int childCount = mChildHelper.getUnfilteredChildCount();
- // hidden VHs are not preferred but if that is the only one we find, we rather return it
- ViewHolder hidden = null;
- for (int i = 0; i < childCount; i++) {
- final ViewHolder holder = getChildViewHolderInt(mChildHelper.getUnfilteredChildAt(i));
- if (holder != null && !holder.isRemoved()
- && getAdapterPositionInRecyclerView(holder) == position) {
- if (mChildHelper.isHidden(holder.itemView)) {
- hidden = holder;
- } else {
- return holder;
- }
- }
- }
- return hidden;
- }
-
- @Nullable
- ViewHolder findViewHolderForPosition(int position, boolean checkNewPosition) {
- final int childCount = mChildHelper.getUnfilteredChildCount();
- ViewHolder hidden = null;
- for (int i = 0; i < childCount; i++) {
- final ViewHolder holder = getChildViewHolderInt(mChildHelper.getUnfilteredChildAt(i));
- if (holder != null && !holder.isRemoved()) {
- if (checkNewPosition) {
- if (holder.mPosition != position) {
- continue;
- }
- } else if (holder.getLayoutPosition() != position) {
- continue;
- }
- if (mChildHelper.isHidden(holder.itemView)) {
- hidden = holder;
- } else {
- return holder;
- }
- }
- }
- // This method should not query cached views. It creates a problem during adapter updates
- // when we are dealing with already laid out views. Also, for the public method, it is more
- // reasonable to return null if position is not laid out.
- return hidden;
- }
-
- /**
- * Return the ViewHolder for the item with the given id. The RecyclerView must
- * use an Adapter with {@link Adapter#setHasStableIds(boolean) stableIds} to
- * return a non-null value.
- *
- * This method checks only the children of RecyclerView. If the item with the given
- * id is not laid out, it will not create a new one.
- *
- * When the ItemAnimator is running a change animation, there might be 2 ViewHolders with the
- * same id. In this case, the updated ViewHolder will be returned.
- *
- * @param id The id for the requested item
- * @return The ViewHolder with the given id or null if there is no such item
- */
- public ViewHolder findViewHolderForItemId(long id) {
- if (mAdapter == null || !mAdapter.hasStableIds()) {
- return null;
- }
- final int childCount = mChildHelper.getUnfilteredChildCount();
- ViewHolder hidden = null;
- for (int i = 0; i < childCount; i++) {
- final ViewHolder holder = getChildViewHolderInt(mChildHelper.getUnfilteredChildAt(i));
- if (holder != null && !holder.isRemoved() && holder.getItemId() == id) {
- if (mChildHelper.isHidden(holder.itemView)) {
- hidden = holder;
- } else {
- return holder;
- }
- }
- }
- return hidden;
- }
-
- /**
- * Find the topmost view under the given point.
- *
- * @param x Horizontal position in pixels to search
- * @param y Vertical position in pixels to search
- * @return The child view under (x, y) or null if no matching child is found
- */
- @Nullable
- public View findChildViewUnder(float x, float y) {
- final int count = mChildHelper.getChildCount();
- for (int i = count - 1; i >= 0; i--) {
- final View child = mChildHelper.getChildAt(i);
- final float translationX = child.getTranslationX();
- final float translationY = child.getTranslationY();
- if (x >= child.getLeft() + translationX
- && x <= child.getRight() + translationX
- && y >= child.getTop() + translationY
- && y <= child.getBottom() + translationY) {
- return child;
- }
- }
- return null;
- }
-
- @Override
- public boolean drawChild(Canvas canvas, View child, long drawingTime) {
- return super.drawChild(canvas, child, drawingTime);
- }
-
- /**
- * Offset the bounds of all child views by dy pixels.
- * Useful for implementing simple scrolling in {@link LayoutManager LayoutManagers}.
- *
- * @param dy Vertical pixel offset to apply to the bounds of all child views
- */
- public void offsetChildrenVertical(@Px int dy) {
- final int childCount = mChildHelper.getChildCount();
- for (int i = 0; i < childCount; i++) {
- mChildHelper.getChildAt(i).offsetTopAndBottom(dy);
- }
- }
-
- /**
- * Called when an item view is attached to this RecyclerView.
- *
- *
Subclasses of RecyclerView may want to perform extra bookkeeping or modifications
- * of child views as they become attached. This will be called before a
- * {@link LayoutManager} measures or lays out the view and is a good time to perform these
- * changes.
- *
- * @param child Child view that is now attached to this RecyclerView and its associated window
- */
- public void onChildAttachedToWindow(@NonNull View child) {
- }
-
- /**
- * Called when an item view is detached from this RecyclerView.
- *
- * Subclasses of RecyclerView may want to perform extra bookkeeping or modifications
- * of child views as they become detached. This will be called as a
- * {@link LayoutManager} fully detaches the child view from the parent and its window.
- *
- * @param child Child view that is now detached from this RecyclerView and its associated window
- */
- public void onChildDetachedFromWindow(@NonNull View child) {
- }
-
- /**
- * Offset the bounds of all child views by dx pixels.
- * Useful for implementing simple scrolling in {@link LayoutManager LayoutManagers}.
- *
- * @param dx Horizontal pixel offset to apply to the bounds of all child views
- */
- public void offsetChildrenHorizontal(@Px int dx) {
- final int childCount = mChildHelper.getChildCount();
- for (int i = 0; i < childCount; i++) {
- mChildHelper.getChildAt(i).offsetLeftAndRight(dx);
- }
- }
-
- /**
- * Returns the bounds of the view including its decoration and margins.
- *
- * @param view The view element to check
- * @param outBounds A rect that will receive the bounds of the element including its
- * decoration and margins.
- */
- public void getDecoratedBoundsWithMargins(@NonNull View view, @NonNull Rect outBounds) {
- getDecoratedBoundsWithMarginsInt(view, outBounds);
- }
-
- static void getDecoratedBoundsWithMarginsInt(View view, Rect outBounds) {
- final LayoutParams lp = (LayoutParams) view.getLayoutParams();
- final Rect insets = lp.mDecorInsets;
- outBounds.set(view.getLeft() - insets.left - lp.leftMargin,
- view.getTop() - insets.top - lp.topMargin,
- view.getRight() + insets.right + lp.rightMargin,
- view.getBottom() + insets.bottom + lp.bottomMargin);
- }
-
- Rect getItemDecorInsetsForChild(View child) {
- final LayoutParams lp = (LayoutParams) child.getLayoutParams();
- if (!lp.mInsetsDirty) {
- return lp.mDecorInsets;
- }
-
- if (mState.isPreLayout() && (lp.isItemChanged() || lp.isViewInvalid())) {
- // changed/invalid items should not be updated until they are rebound.
- return lp.mDecorInsets;
- }
- final Rect insets = lp.mDecorInsets;
- insets.set(0, 0, 0, 0);
- final int decorCount = mItemDecorations.size();
- for (int i = 0; i < decorCount; i++) {
- mTempRect.set(0, 0, 0, 0);
- mItemDecorations.get(i).getItemOffsets(mTempRect, child, this, mState);
- insets.left += mTempRect.left;
- insets.top += mTempRect.top;
- insets.right += mTempRect.right;
- insets.bottom += mTempRect.bottom;
- }
- lp.mInsetsDirty = false;
- return insets;
- }
-
- /**
- * Called when the scroll position of this RecyclerView changes. Subclasses should use
- * this method to respond to scrolling within the adapter's data set instead of an explicit
- * listener.
- *
- * This method will always be invoked before listeners. If a subclass needs to perform
- * any additional upkeep or bookkeeping after scrolling but before listeners run,
- * this is a good place to do so.
- *
- * This differs from {@link View#onScrollChanged(int, int, int, int)} in that it receives
- * the distance scrolled in either direction within the adapter's data set instead of absolute
- * scroll coordinates. Since RecyclerView cannot compute the absolute scroll position from
- * any arbitrary point in the data set, onScrollChanged will always receive
- * the current {@link View#getScrollX()} and {@link View#getScrollY()} values which
- * do not correspond to the data set scroll position. However, some subclasses may choose
- * to use these fields as special offsets.
- *
- * @param dx horizontal distance scrolled in pixels
- * @param dy vertical distance scrolled in pixels
- */
- public void onScrolled(@Px int dx, @Px int dy) {
- // Do nothing
- }
-
- void dispatchOnScrolled(int hresult, int vresult) {
- mDispatchScrollCounter++;
- // Pass the current scrollX/scrollY values as current values. No actual change in these
- // properties occurred. Pass negative hresult and vresult as old values so that
- // postSendViewScrolledAccessibilityEventCallback(l - oldl, t - oldt) in onScrollChanged
- // sends the scrolled accessibility event correctly.
- final int scrollX = getScrollX();
- final int scrollY = getScrollY();
- onScrollChanged(scrollX, scrollY, scrollX - hresult, scrollY - vresult);
-
- // Pass the real deltas to onScrolled, the RecyclerView-specific method.
- onScrolled(hresult, vresult);
-
- // Invoke listeners last. Subclassed view methods always handle the event first.
- // All internal state is consistent by the time listeners are invoked.
- if (mScrollListener != null) {
- mScrollListener.onScrolled(this, hresult, vresult);
- }
- if (mScrollListeners != null) {
- for (int i = mScrollListeners.size() - 1; i >= 0; i--) {
- mScrollListeners.get(i).onScrolled(this, hresult, vresult);
- }
- }
- mDispatchScrollCounter--;
- }
-
- /**
- * Called when the scroll state of this RecyclerView changes. Subclasses should use this
- * method to respond to state changes instead of an explicit listener.
- *
- * This method will always be invoked before listeners, but after the LayoutManager
- * responds to the scroll state change.
- *
- * @param state the new scroll state, one of {@link #SCROLL_STATE_IDLE},
- * {@link #SCROLL_STATE_DRAGGING} or {@link #SCROLL_STATE_SETTLING}
- */
- public void onScrollStateChanged(int state) {
- // Do nothing
- }
-
- /**
- * Copied from OverScroller, this returns the distance that a fling with the given velocity
- * will go.
- * @param velocity The velocity of the fling
- * @return The distance that will be traveled by a fling of the given velocity.
- */
- private float getSplineFlingDistance(int velocity) {
- final double l =
- Math.log(INFLEXION * Math.abs(velocity) / (SCROLL_FRICTION * mPhysicalCoef));
- final double decelMinusOne = DECELERATION_RATE - 1.0;
- return (float) (SCROLL_FRICTION * mPhysicalCoef
- * Math.exp(DECELERATION_RATE / decelMinusOne * l));
- }
-
- void dispatchOnScrollStateChanged(int state) {
- // Let the LayoutManager go first; this allows it to bring any properties into
- // a consistent state before the RecyclerView subclass responds.
- if (mLayout != null) {
- mLayout.onScrollStateChanged(state);
- }
-
- // Let the RecyclerView subclass handle this event next; any LayoutManager property
- // changes will be reflected by this time.
- onScrollStateChanged(state);
-
- // Listeners go last. All other internal state is consistent by this point.
- if (mScrollListener != null) {
- mScrollListener.onScrollStateChanged(this, state);
- }
- if (mScrollListeners != null) {
- for (int i = mScrollListeners.size() - 1; i >= 0; i--) {
- mScrollListeners.get(i).onScrollStateChanged(this, state);
- }
- }
- }
-
- /**
- * Returns whether there are pending adapter updates which are not yet applied to the layout.
- *
- * If this method returns true, it means that what user is currently seeing may not
- * reflect them adapter contents (depending on what has changed).
- * You may use this information to defer or cancel some operations.
- *
- * This method returns true if RecyclerView has not yet calculated the first layout after it is
- * attached to the Window or the Adapter has been replaced.
- *
- * @return True if there are some adapter updates which are not yet reflected to layout or false
- * if layout is up to date.
- */
- public boolean hasPendingAdapterUpdates() {
- return !mFirstLayoutComplete || mDataSetHasChangedAfterLayout
- || mAdapterHelper.hasPendingUpdates();
- }
-
- // Effectively private. Set to default to avoid synthetic accessor.
- class ViewFlinger implements Runnable {
- private int mLastFlingX;
- private int mLastFlingY;
- OverScroller mOverScroller;
- Interpolator mInterpolator = sQuinticInterpolator;
-
- // When set to true, postOnAnimation callbacks are delayed until the run method completes
- private boolean mEatRunOnAnimationRequest = false;
-
- // Tracks if postAnimationCallback should be re-attached when it is done
- private boolean mReSchedulePostAnimationCallback = false;
-
- ViewFlinger() {
- mOverScroller = new OverScroller(getContext(), sQuinticInterpolator);
- }
-
- @Override
- public void run() {
- if (mLayout == null) {
- stop();
- return; // no layout, cannot scroll.
- }
-
- mReSchedulePostAnimationCallback = false;
- mEatRunOnAnimationRequest = true;
-
- consumePendingUpdateOperations();
-
- // TODO(72745539): After reviewing the code, it seems to me we may actually want to
- // update the reference to the OverScroller after onAnimation. It looks to me like
- // it is possible that a new OverScroller could be created (due to a new Interpolator
- // being used), when the current OverScroller knows it's done after
- // scroller.computeScrollOffset() is called. If that happens, and we don't update the
- // reference, it seems to me that we could prematurely stop the newly created scroller
- // due to setScrollState(SCROLL_STATE_IDLE) being called below.
-
- // Keep a local reference so that if it is changed during onAnimation method, it won't
- // cause unexpected behaviors
- final OverScroller scroller = mOverScroller;
- if (scroller.computeScrollOffset()) {
- final int x = scroller.getCurrX();
- final int y = scroller.getCurrY();
- int unconsumedX = x - mLastFlingX;
- int unconsumedY = y - mLastFlingY;
- mLastFlingX = x;
- mLastFlingY = y;
-
- unconsumedX = consumeFlingInHorizontalStretch(unconsumedX);
- unconsumedY = consumeFlingInVerticalStretch(unconsumedY);
-
- int consumedX = 0;
- int consumedY = 0;
-
- // Nested Pre Scroll
- mReusableIntPair[0] = 0;
- mReusableIntPair[1] = 0;
- if (dispatchNestedPreScroll(unconsumedX, unconsumedY, mReusableIntPair, null,
- TYPE_NON_TOUCH)) {
- unconsumedX -= mReusableIntPair[0];
- unconsumedY -= mReusableIntPair[1];
- }
-
- // Based on movement, we may want to trigger the hiding of existing over scroll
- // glows.
- if (getOverScrollMode() != View.OVER_SCROLL_NEVER) {
- considerReleasingGlowsOnScroll(unconsumedX, unconsumedY);
- }
-
- // Local Scroll
- if (mAdapter != null) {
- mReusableIntPair[0] = 0;
- mReusableIntPair[1] = 0;
- scrollStep(unconsumedX, unconsumedY, mReusableIntPair);
- consumedX = mReusableIntPair[0];
- consumedY = mReusableIntPair[1];
- unconsumedX -= consumedX;
- unconsumedY -= consumedY;
-
- // If SmoothScroller exists, this ViewFlinger was started by it, so we must
- // report back to SmoothScroller.
- SmoothScroller smoothScroller = mLayout.mSmoothScroller;
- if (smoothScroller != null && !smoothScroller.isPendingInitialRun()
- && smoothScroller.isRunning()) {
- final int adapterSize = mState.getItemCount();
- if (adapterSize == 0) {
- smoothScroller.stop();
- } else if (smoothScroller.getTargetPosition() >= adapterSize) {
- smoothScroller.setTargetPosition(adapterSize - 1);
- smoothScroller.onAnimation(consumedX, consumedY);
- } else {
- smoothScroller.onAnimation(consumedX, consumedY);
- }
- }
- }
-
- if (!mItemDecorations.isEmpty()) {
- invalidate();
- }
-
- // Nested Post Scroll
- mReusableIntPair[0] = 0;
- mReusableIntPair[1] = 0;
- dispatchNestedScroll(consumedX, consumedY, unconsumedX, unconsumedY, null,
- TYPE_NON_TOUCH, mReusableIntPair);
- unconsumedX -= mReusableIntPair[0];
- unconsumedY -= mReusableIntPair[1];
-
- if (consumedX != 0 || consumedY != 0) {
- dispatchOnScrolled(consumedX, consumedY);
- }
-
- if (!awakenScrollBars()) {
- invalidate();
- }
-
- // We are done scrolling if scroller is finished, or for both the x and y dimension,
- // we are done scrolling or we can't scroll further (we know we can't scroll further
- // when we have unconsumed scroll distance). It's possible that we don't need
- // to also check for scroller.isFinished() at all, but no harm in doing so in case
- // of old bugs in Overscroller.
- boolean scrollerFinishedX = scroller.getCurrX() == scroller.getFinalX();
- boolean scrollerFinishedY = scroller.getCurrY() == scroller.getFinalY();
- final boolean doneScrolling = scroller.isFinished()
- || ((scrollerFinishedX || unconsumedX != 0)
- && (scrollerFinishedY || unconsumedY != 0));
-
- // Get the current smoothScroller. It may have changed by this point and we need to
- // make sure we don't stop scrolling if it has changed and it's pending an initial
- // run.
- SmoothScroller smoothScroller = mLayout.mSmoothScroller;
- boolean smoothScrollerPending =
- smoothScroller != null && smoothScroller.isPendingInitialRun();
-
- if (!smoothScrollerPending && doneScrolling) {
- // If we are done scrolling and the layout's SmoothScroller is not pending,
- // do the things we do at the end of a scroll and don't postOnAnimation.
-
- if (getOverScrollMode() != View.OVER_SCROLL_NEVER) {
- final int vel = (int) scroller.getCurrVelocity();
- int velX = unconsumedX < 0 ? -vel : unconsumedX > 0 ? vel : 0;
- int velY = unconsumedY < 0 ? -vel : unconsumedY > 0 ? vel : 0;
- absorbGlows(velX, velY);
- }
-
- if (ALLOW_THREAD_GAP_WORK) {
- mPrefetchRegistry.clearPrefetchPositions();
- }
- } else {
- // Otherwise continue the scroll.
-
- postOnAnimation();
- if (mGapWorker != null) {
- mGapWorker.postFromTraversal(RecyclerView.this, consumedX, consumedY);
- }
- }
- }
-
- SmoothScroller smoothScroller = mLayout.mSmoothScroller;
- // call this after the onAnimation is complete not to have inconsistent callbacks etc.
- if (smoothScroller != null && smoothScroller.isPendingInitialRun()) {
- smoothScroller.onAnimation(0, 0);
- }
-
- mEatRunOnAnimationRequest = false;
- if (mReSchedulePostAnimationCallback) {
- internalPostOnAnimation();
- } else {
- setScrollState(SCROLL_STATE_IDLE);
- stopNestedScroll(TYPE_NON_TOUCH);
- }
- }
-
- void postOnAnimation() {
- if (mEatRunOnAnimationRequest) {
- mReSchedulePostAnimationCallback = true;
- } else {
- internalPostOnAnimation();
- }
- }
-
- private void internalPostOnAnimation() {
- removeCallbacks(this);
- ViewCompat.postOnAnimation(RecyclerView.this, this);
- }
-
- public void fling(int velocityX, int velocityY) {
- setScrollState(SCROLL_STATE_SETTLING);
- mLastFlingX = mLastFlingY = 0;
- // Because you can't define a custom interpolator for flinging, we should make sure we
- // reset ourselves back to the teh default interpolator in case a different call
- // changed our interpolator.
- if (mInterpolator != sQuinticInterpolator) {
- mInterpolator = sQuinticInterpolator;
- mOverScroller = new OverScroller(getContext(), sQuinticInterpolator);
- }
- mOverScroller.fling(0, 0, velocityX, velocityY,
- Integer.MIN_VALUE, Integer.MAX_VALUE, Integer.MIN_VALUE, Integer.MAX_VALUE);
- postOnAnimation();
- }
-
- /**
- * Smooth scrolls the RecyclerView by a given distance.
- *
- * @param dx x distance in pixels.
- * @param dy y distance in pixels.
- * @param duration Duration of the animation in milliseconds. Set to
- * {@link #UNDEFINED_DURATION} to have the duration automatically
- * calculated
- * based on an internally defined standard velocity.
- * @param interpolator {@link Interpolator} to be used for scrolling. If it is {@code null},
- * RecyclerView will use an internal default interpolator.
- */
- public void smoothScrollBy(int dx, int dy, int duration,
- @Nullable Interpolator interpolator) {
-
- // Handle cases where parameter values aren't defined.
- if (duration == UNDEFINED_DURATION) {
- duration = computeScrollDuration(dx, dy);
- }
- if (interpolator == null) {
- interpolator = sQuinticInterpolator;
- }
-
- // If the Interpolator has changed, create a new OverScroller with the new
- // interpolator.
- if (mInterpolator != interpolator) {
- mInterpolator = interpolator;
- mOverScroller = new OverScroller(getContext(), interpolator);
- }
-
- // Reset the last fling information.
- mLastFlingX = mLastFlingY = 0;
-
- // Set to settling state and start scrolling.
- setScrollState(SCROLL_STATE_SETTLING);
- mOverScroller.startScroll(0, 0, dx, dy, duration);
-
- if (Build.VERSION.SDK_INT < 23) {
- // b/64931938 before API 23, startScroll() does not reset getCurX()/getCurY()
- // to start values, which causes fillRemainingScrollValues() put in obsolete values
- // for LayoutManager.onLayoutChildren().
- mOverScroller.computeScrollOffset();
- }
-
- postOnAnimation();
- }
-
- /**
- * Computes of an animated scroll in milliseconds.
- * @param dx x distance in pixels.
- * @param dy y distance in pixels.
- * @return The duration of the animated scroll in milliseconds.
- */
- private int computeScrollDuration(int dx, int dy) {
- final int absDx = Math.abs(dx);
- final int absDy = Math.abs(dy);
- final boolean horizontal = absDx > absDy;
- final int containerSize = horizontal ? getWidth() : getHeight();
-
- float absDelta = (float) (horizontal ? absDx : absDy);
- final int duration = (int) (((absDelta / containerSize) + 1) * 300);
-
- return Math.min(duration, MAX_SCROLL_DURATION);
- }
-
- public void stop() {
- removeCallbacks(this);
- mOverScroller.abortAnimation();
- }
-
- }
-
- void repositionShadowingViews() {
- // Fix up shadow views used by change animations
- int count = mChildHelper.getChildCount();
- for (int i = 0; i < count; i++) {
- View view = mChildHelper.getChildAt(i);
- ViewHolder holder = getChildViewHolder(view);
- if (holder != null && holder.mShadowingHolder != null) {
- View shadowingView = holder.mShadowingHolder.itemView;
- int left = view.getLeft();
- int top = view.getTop();
- if (left != shadowingView.getLeft() || top != shadowingView.getTop()) {
- shadowingView.layout(left, top,
- left + shadowingView.getWidth(),
- top + shadowingView.getHeight());
- }
- }
- }
- }
-
- private class RecyclerViewDataObserver extends AdapterDataObserver {
- RecyclerViewDataObserver() {
- }
-
- @Override
- public void onChanged() {
- assertNotInLayoutOrScroll(null);
- mState.mStructureChanged = true;
-
- processDataSetCompletelyChanged(true);
- if (!mAdapterHelper.hasPendingUpdates()) {
- requestLayout();
- }
- }
-
- @Override
- public void onItemRangeChanged(int positionStart, int itemCount, Object payload) {
- assertNotInLayoutOrScroll(null);
- if (mAdapterHelper.onItemRangeChanged(positionStart, itemCount, payload)) {
- triggerUpdateProcessor();
- }
- }
-
- @Override
- public void onItemRangeInserted(int positionStart, int itemCount) {
- assertNotInLayoutOrScroll(null);
- if (mAdapterHelper.onItemRangeInserted(positionStart, itemCount)) {
- triggerUpdateProcessor();
- }
- }
-
- @Override
- public void onItemRangeRemoved(int positionStart, int itemCount) {
- assertNotInLayoutOrScroll(null);
- if (mAdapterHelper.onItemRangeRemoved(positionStart, itemCount)) {
- triggerUpdateProcessor();
- }
- }
-
- @Override
- public void onItemRangeMoved(int fromPosition, int toPosition, int itemCount) {
- assertNotInLayoutOrScroll(null);
- if (mAdapterHelper.onItemRangeMoved(fromPosition, toPosition, itemCount)) {
- triggerUpdateProcessor();
- }
- }
-
- void triggerUpdateProcessor() {
- if (POST_UPDATES_ON_ANIMATION && mHasFixedSize && mIsAttached) {
- ViewCompat.postOnAnimation(RecyclerView.this, mUpdateChildViewsRunnable);
- } else {
- mAdapterUpdateDuringMeasure = true;
- requestLayout();
- }
- }
-
- @Override
- public void onStateRestorationPolicyChanged() {
- if (mPendingSavedState == null) {
- return;
- }
- // If there is a pending saved state and the new mode requires us to restore it,
- // we'll request a layout which will call the adapter to see if it can restore state
- // and trigger state restoration
- Adapter adapter = mAdapter;
- if (adapter != null && adapter.canRestoreState()) {
- requestLayout();
- }
- }
- }
-
- /**
- * EdgeEffectFactory lets you customize the over-scroll edge effect for RecyclerViews.
- *
- * @see RecyclerView#setEdgeEffectFactory(EdgeEffectFactory)
- */
- public static class EdgeEffectFactory {
-
- @Retention(RetentionPolicy.SOURCE)
- @IntDef({DIRECTION_LEFT, DIRECTION_TOP, DIRECTION_RIGHT, DIRECTION_BOTTOM})
- public @interface EdgeDirection {
- }
-
- /**
- * Direction constant for the left edge
- */
- public static final int DIRECTION_LEFT = 0;
-
- /**
- * Direction constant for the top edge
- */
- public static final int DIRECTION_TOP = 1;
-
- /**
- * Direction constant for the right edge
- */
- public static final int DIRECTION_RIGHT = 2;
-
- /**
- * Direction constant for the bottom edge
- */
- public static final int DIRECTION_BOTTOM = 3;
-
- /**
- * Create a new EdgeEffect for the provided direction.
- */
- protected @NonNull
- EdgeEffect createEdgeEffect(@NonNull RecyclerView view,
- @EdgeDirection int direction) {
- return new EdgeEffect(view.getContext());
- }
- }
-
- /**
- * The default EdgeEffectFactory sets the edge effect type of the EdgeEffect.
- */
- static class StretchEdgeEffectFactory extends EdgeEffectFactory {
- @NonNull
- @Override
- protected EdgeEffect createEdgeEffect(@NonNull RecyclerView view, int direction) {
- return new EdgeEffect(view.getContext());
- }
- }
-
- /**
- * RecycledViewPool lets you share Views between multiple RecyclerViews.
- *
- * If you want to recycle views across RecyclerViews, create an instance of RecycledViewPool
- * and use {@link RecyclerView#setRecycledViewPool(RecycledViewPool)}.
- *
- * RecyclerView automatically creates a pool for itself if you don't provide one.
- */
- public static class RecycledViewPool {
- private static final int DEFAULT_MAX_SCRAP = 5;
-
- /**
- * Tracks both pooled holders, as well as create/bind timing metadata for the given type.
- *
- * Note that this tracks running averages of create/bind time across all RecyclerViews
- * (and, indirectly, Adapters) that use this pool.
- *
- * 1) This enables us to track average create and bind times across multiple adapters. Even
- * though create (and especially bind) may behave differently for different Adapter
- * subclasses, sharing the pool is a strong signal that they'll perform similarly, per type.
- *
- * 2) If {@link #willBindInTime(int, long, long)} returns false for one view, it will return
- * false for all other views of its type for the same deadline. This prevents items
- * constructed by {@link GapWorker} prefetch from being bound to a lower priority prefetch.
- */
- static class ScrapData {
- final ArrayList mScrapHeap = new ArrayList<>();
- int mMaxScrap = DEFAULT_MAX_SCRAP;
- long mCreateRunningAverageNs = 0;
- long mBindRunningAverageNs = 0;
- }
-
- SparseArray mScrap = new SparseArray<>();
-
- /**
- * Attach counts for clearing (that is, emptying the pool when there are no adapters
- * attached) and for PoolingContainer release are tracked separately to maintain the
- * historical behavior of this functionality.
- *
- * The count for clearing is inaccurate in certain scenarios: for instance, if a
- * RecyclerView is removed from the view hierarchy and thrown away to be GCed, the
- * attach count will never be correspondingly decreased. However, it has been this way
- * for years without any complaints, so we are not going to potentially increase the
- * number of scenarios where the pool would be cleared.
- *
- * The attached adapters for PoolingContainer purposes strives to be more accurate, as
- * it will be decremented whenever a RecyclerView is detached from the window. This
- * could potentially be inaccurate in the unlikely event that someone is manually driving
- * a detached RecyclerView by calling measure, layout, draw, etc. However, the
- * implementation of {@link RecyclerView#onDetachedFromWindow()} suggests this is not the
- * only unexpected behavior that doing so might provoke, so this should be acceptable.
- */
- int mAttachCountForClearing = 0;
-
- /**
- * The set of adapters for PoolingContainer release purposes
- *
- * @see #mAttachCountForClearing
- */
- Set> mAttachedAdaptersForPoolingContainer =
- Collections.newSetFromMap(new IdentityHashMap<>());
-
- /**
- * Discard all ViewHolders.
- */
- public void clear() {
- for (int i = 0; i < mScrap.size(); i++) {
- ScrapData data = mScrap.valueAt(i);
- for (ViewHolder scrap: data.mScrapHeap) {
- PoolingContainer.callPoolingContainerOnRelease(scrap.itemView);
- }
- data.mScrapHeap.clear();
- }
- }
-
- /**
- * Sets the maximum number of ViewHolders to hold in the pool before discarding.
- *
- * @param viewType ViewHolder Type
- * @param max Maximum number
- */
- public void setMaxRecycledViews(int viewType, int max) {
- ScrapData scrapData = getScrapDataForType(viewType);
- scrapData.mMaxScrap = max;
- final ArrayList scrapHeap = scrapData.mScrapHeap;
- while (scrapHeap.size() > max) {
- scrapHeap.remove(scrapHeap.size() - 1);
- }
- }
-
- /**
- * Returns the current number of Views held by the RecycledViewPool of the given view type.
- */
- public int getRecycledViewCount(int viewType) {
- return getScrapDataForType(viewType).mScrapHeap.size();
- }
-
- /**
- * Acquire a ViewHolder of the specified type from the pool, or {@code null} if none are
- * present.
- *
- * @param viewType ViewHolder type.
- * @return ViewHolder of the specified type acquired from the pool, or {@code null} if none
- * are present.
- */
- @Nullable
- public ViewHolder getRecycledView(int viewType) {
- final ScrapData scrapData = mScrap.get(viewType);
- if (scrapData != null && !scrapData.mScrapHeap.isEmpty()) {
- final ArrayList scrapHeap = scrapData.mScrapHeap;
- for (int i = scrapHeap.size() - 1; i >= 0; i--) {
- if (!scrapHeap.get(i).isAttachedToTransitionOverlay()) {
- return scrapHeap.remove(i);
- }
- }
- }
- return null;
- }
-
- /**
- * Total number of ViewHolders held by the pool.
- *
- * @return Number of ViewHolders held by the pool.
- */
- int size() {
- int count = 0;
- for (int i = 0; i < mScrap.size(); i++) {
- ArrayList viewHolders = mScrap.valueAt(i).mScrapHeap;
- if (viewHolders != null) {
- count += viewHolders.size();
- }
- }
- return count;
- }
-
- /**
- * Add a scrap ViewHolder to the pool.
- *
- * If the pool is already full for that ViewHolder's type, it will be immediately discarded.
- *
- * @param scrap ViewHolder to be added to the pool.
- */
- public void putRecycledView(ViewHolder scrap) {
- final int viewType = scrap.getItemViewType();
- final ArrayList scrapHeap = getScrapDataForType(viewType).mScrapHeap;
- if (mScrap.get(viewType).mMaxScrap <= scrapHeap.size()) {
- PoolingContainer.callPoolingContainerOnRelease(scrap.itemView);
- return;
- }
- if (sDebugAssertionsEnabled && scrapHeap.contains(scrap)) {
- throw new IllegalArgumentException("this scrap item already exists");
- }
- scrap.resetInternal();
- scrapHeap.add(scrap);
- }
-
- long runningAverage(long oldAverage, long newValue) {
- if (oldAverage == 0) {
- return newValue;
- }
- return (oldAverage / 4 * 3) + (newValue / 4);
- }
-
- void factorInCreateTime(int viewType, long createTimeNs) {
- ScrapData scrapData = getScrapDataForType(viewType);
- scrapData.mCreateRunningAverageNs = runningAverage(
- scrapData.mCreateRunningAverageNs, createTimeNs);
- }
-
- void factorInBindTime(int viewType, long bindTimeNs) {
- ScrapData scrapData = getScrapDataForType(viewType);
- scrapData.mBindRunningAverageNs = runningAverage(
- scrapData.mBindRunningAverageNs, bindTimeNs);
- }
-
- boolean willCreateInTime(int viewType, long approxCurrentNs, long deadlineNs) {
- long expectedDurationNs = getScrapDataForType(viewType).mCreateRunningAverageNs;
- return expectedDurationNs == 0 || (approxCurrentNs + expectedDurationNs < deadlineNs);
- }
-
- boolean willBindInTime(int viewType, long approxCurrentNs, long deadlineNs) {
- long expectedDurationNs = getScrapDataForType(viewType).mBindRunningAverageNs;
- return expectedDurationNs == 0 || (approxCurrentNs + expectedDurationNs < deadlineNs);
- }
-
- void attach() {
- mAttachCountForClearing++;
- }
-
- void detach() {
- mAttachCountForClearing--;
- }
-
- /**
- * Adds this adapter to the set of adapters being tracked for PoolingContainer release
- * purposes. This method may validly be called multiple times for a given adapter.
- * Additional calls to this method for an already-attached adapter are a no-op.
- *
- * @param adapter the adapter to ensure is in the set
- */
- void attachForPoolingContainer(@NonNull Adapter adapter) {
- mAttachedAdaptersForPoolingContainer.add(adapter);
- }
-
- /**
- * Removes this adapter from the set of adapters being tracked for PoolingContainer
- * release purposes. This method may validly be called multiple times for a given adapter.
- + Additional calls to this method for an already-detached adapter are a no-op.
- *
- * @param adapter the adapter to be removed from the set
- * @param isBeingReplaced {@code true} if this detach is immediately preceding a call to
- * {@link #attachForPoolingContainer(Adapter)} and
- * {@link PoolingContainerListener#onRelease()} should not be triggered, or false otherwise
- */
- void detachForPoolingContainer(@NonNull Adapter adapter, boolean isBeingReplaced) {
- mAttachedAdaptersForPoolingContainer.remove(adapter);
- if (mAttachedAdaptersForPoolingContainer.size() == 0 && !isBeingReplaced) {
- for (int keyIndex = 0; keyIndex < mScrap.size(); keyIndex++) {
- ArrayList scrapHeap = mScrap.get(mScrap.keyAt(keyIndex)).mScrapHeap;
- for (int i = 0; i < scrapHeap.size(); i++) {
- PoolingContainer.callPoolingContainerOnRelease(
- scrapHeap.get(i).itemView
- );
- }
- }
- }
- }
-
- /**
- * Detaches the old adapter and attaches the new one.
- *
- * RecycledViewPool will clear its cache if it has only one adapter attached and the new
- * adapter uses a different ViewHolder than the oldAdapter.
- *
- * @param oldAdapter The previous adapter instance. Will be detached.
- * @param newAdapter The new adapter instance. Will be attached.
- * @param compatibleWithPrevious True if both oldAdapter and newAdapter are using the same
- * ViewHolder and view types.
- */
- void onAdapterChanged(Adapter oldAdapter, Adapter newAdapter,
- boolean compatibleWithPrevious) {
- if (oldAdapter != null) {
- detach();
- }
- if (!compatibleWithPrevious && mAttachCountForClearing == 0) {
- clear();
- }
- if (newAdapter != null) {
- attach();
- }
- }
-
- private ScrapData getScrapDataForType(int viewType) {
- ScrapData scrapData = mScrap.get(viewType);
- if (scrapData == null) {
- scrapData = new ScrapData();
- mScrap.put(viewType, scrapData);
- }
- return scrapData;
- }
- }
-
- /**
- * Utility method for finding an internal RecyclerView, if present
- */
- @Nullable
- static RecyclerView findNestedRecyclerView(@NonNull View view) {
- if (!(view instanceof ViewGroup)) {
- return null;
- }
- if (view instanceof RecyclerView) {
- return (RecyclerView) view;
- }
- final ViewGroup parent = (ViewGroup) view;
- final int count = parent.getChildCount();
- for (int i = 0; i < count; i++) {
- final View child = parent.getChildAt(i);
- final RecyclerView descendant = findNestedRecyclerView(child);
- if (descendant != null) {
- return descendant;
- }
- }
- return null;
- }
-
- /**
- * Utility method for clearing holder's internal RecyclerView, if present
- */
- static void clearNestedRecyclerViewIfNotNested(@NonNull ViewHolder holder) {
- if (holder.mNestedRecyclerView != null) {
- View item = holder.mNestedRecyclerView.get();
- while (item != null) {
- if (item == holder.itemView) {
- return; // match found, don't need to clear
- }
-
- ViewParent parent = item.getParent();
- if (parent instanceof View) {
- item = (View) parent;
- } else {
- item = null;
- }
- }
- holder.mNestedRecyclerView = null; // not nested
- }
- }
-
- /**
- * Time base for deadline-aware work scheduling. Overridable for testing.
- *
- * Will return 0 to avoid cost of System.nanoTime where deadline-aware work scheduling
- * isn't relevant.
- */
- long getNanoTime() {
- if (ALLOW_THREAD_GAP_WORK) {
- return System.nanoTime();
- } else {
- return 0;
- }
- }
-
- /**
- * A Recycler is responsible for managing scrapped or detached item views for reuse.
- *
- *
A "scrapped" view is a view that is still attached to its parent RecyclerView but
- * that has been marked for removal or reuse.
- *
- * Typical use of a Recycler by a {@link LayoutManager} will be to obtain views for
- * an adapter's data set representing the data at a given position or item ID.
- * If the view to be reused is considered "dirty" the adapter will be asked to rebind it.
- * If not, the view can be quickly reused by the LayoutManager with no further work.
- * Clean views that have not {@link android.view.View#isLayoutRequested() requested layout}
- * may be repositioned by a LayoutManager without remeasurement.
- */
- public final class Recycler {
- final ArrayList mAttachedScrap = new ArrayList<>();
- ArrayList mChangedScrap = null;
-
- final ArrayList mCachedViews = new ArrayList();
-
- private final List
- mUnmodifiableAttachedScrap = Collections.unmodifiableList(mAttachedScrap);
-
- private int mRequestedCacheMax = DEFAULT_CACHE_SIZE;
- int mViewCacheMax = DEFAULT_CACHE_SIZE;
-
- RecycledViewPool mRecyclerPool;
-
- private ViewCacheExtension mViewCacheExtension;
-
- static final int DEFAULT_CACHE_SIZE = 2;
-
- /**
- * Clear scrap views out of this recycler. Detached views contained within a
- * recycled view pool will remain.
- */
- public void clear() {
- mAttachedScrap.clear();
- recycleAndClearCachedViews();
- }
-
- /**
- * Set the maximum number of detached, valid views we should retain for later use.
- *
- * @param viewCount Number of views to keep before sending views to the shared pool
- */
- public void setViewCacheSize(int viewCount) {
- mRequestedCacheMax = viewCount;
- updateViewCacheSize();
- }
-
- void updateViewCacheSize() {
- int extraCache = mLayout != null ? mLayout.mPrefetchMaxCountObserved : 0;
- mViewCacheMax = mRequestedCacheMax + extraCache;
-
- // first, try the views that can be recycled
- for (int i = mCachedViews.size() - 1;
- i >= 0 && mCachedViews.size() > mViewCacheMax; i--) {
- recycleCachedViewAt(i);
- }
- }
-
- /**
- * Returns an unmodifiable list of ViewHolders that are currently in the scrap list.
- *
- * @return List of ViewHolders in the scrap list.
- */
- @NonNull
- public List getScrapList() {
- return mUnmodifiableAttachedScrap;
- }
-
- /**
- * Helper method for getViewForPosition.
- *
- * Checks whether a given view holder can be used for the provided position.
- *
- * @param holder ViewHolder
- * @return true if ViewHolder matches the provided position, false otherwise
- */
- boolean validateViewHolderForOffsetPosition(ViewHolder holder) {
- // if it is a removed holder, nothing to verify since we cannot ask adapter anymore
- // if it is not removed, verify the type and id.
- if (holder.isRemoved()) {
- if (sDebugAssertionsEnabled && !mState.isPreLayout()) {
- throw new IllegalStateException("should not receive a removed view unless it"
- + " is pre layout" + exceptionLabel());
- }
- return mState.isPreLayout();
- }
- if (holder.mPosition < 0 || holder.mPosition >= mAdapter.getItemCount()) {
- throw new IndexOutOfBoundsException("Inconsistency detected. Invalid view holder "
- + "adapter position" + holder + exceptionLabel());
- }
- if (!mState.isPreLayout()) {
- // don't check type if it is pre-layout.
- final int type = mAdapter.getItemViewType(holder.mPosition);
- if (type != holder.getItemViewType()) {
- return false;
- }
- }
- if (mAdapter.hasStableIds()) {
- return holder.getItemId() == mAdapter.getItemId(holder.mPosition);
- }
- return true;
- }
-
- /**
- * Attempts to bind view, and account for relevant timing information. If
- * deadlineNs != FOREVER_NS, this method may fail to bind, and return false.
- *
- * @param holder Holder to be bound.
- * @param offsetPosition Position of item to be bound.
- * @param position Pre-layout position of item to be bound.
- * @param deadlineNs Time, relative to getNanoTime(), by which bind/create work should
- * complete. If FOREVER_NS is passed, this method will not fail to
- * bind the holder.
- */
- @SuppressWarnings("unchecked")
- private boolean tryBindViewHolderByDeadline(@NonNull ViewHolder holder, int offsetPosition,
- int position, long deadlineNs) {
- holder.mBindingAdapter = null;
- holder.mOwnerRecyclerView = RecyclerView.this;
- final int viewType = holder.getItemViewType();
- long startBindNs = getNanoTime();
- if (deadlineNs != FOREVER_NS
- && !mRecyclerPool.willBindInTime(viewType, startBindNs, deadlineNs)) {
- // abort - we have a deadline we can't meet
- return false;
- }
-
- // Holders being bound should be either fully attached or fully detached.
- // We don't want to bind with views that are temporarily detached, because that
- // creates a situation in which they are unable to reason about their attach state
- // properly.
- // For example, isAttachedToWindow will return true, but the itemView will lack a
- // parent. This breaks, among other possible issues, anything involving traversing
- // the view tree, such as ViewTreeLifecycleOwner.
- // Thus, we temporarily reattach any temp-detached holders for the bind operation.
- // See https://issuetracker.google.com/265347515 for additional details on problems
- // resulting from this
- boolean reattachedForBind = false;
- if (holder.isTmpDetached()) {
- attachViewToParent(holder.itemView, getChildCount(),
- holder.itemView.getLayoutParams());
- reattachedForBind = true;
- }
-
- mAdapter.bindViewHolder(holder, offsetPosition);
-
- if (reattachedForBind) {
- detachViewFromParent(holder.itemView);
- }
-
- long endBindNs = getNanoTime();
- mRecyclerPool.factorInBindTime(holder.getItemViewType(), endBindNs - startBindNs);
- attachAccessibilityDelegateOnBind(holder);
- if (mState.isPreLayout()) {
- holder.mPreLayoutPosition = position;
- }
- return true;
- }
-
- /**
- * Binds the given View to the position. The View can be a View previously retrieved via
- * {@link #getViewForPosition(int)} or created by
- * {@link Adapter#onCreateViewHolder(ViewGroup, int)}.
- *
- * Generally, a LayoutManager should acquire its views via {@link #getViewForPosition(int)}
- * and let the RecyclerView handle caching. This is a helper method for LayoutManager who
- * wants to handle its own recycling logic.
- *
- * Note that, {@link #getViewForPosition(int)} already binds the View to the position so
- * you don't need to call this method unless you want to bind this View to another position.
- *
- * @param view The view to update.
- * @param position The position of the item to bind to this View.
- */
- public void bindViewToPosition(@NonNull View view, int position) {
- ViewHolder holder = getChildViewHolderInt(view);
- if (holder == null) {
- throw new IllegalArgumentException("The view does not have a ViewHolder. You cannot"
- + " pass arbitrary views to this method, they should be created by the "
- + "Adapter" + exceptionLabel());
- }
- final int offsetPosition = mAdapterHelper.findPositionOffset(position);
- if (offsetPosition < 0 || offsetPosition >= mAdapter.getItemCount()) {
- throw new IndexOutOfBoundsException("Inconsistency detected. Invalid item "
- + "position " + position + "(offset:" + offsetPosition + ")."
- + "state:" + mState.getItemCount() + exceptionLabel());
- }
- tryBindViewHolderByDeadline(holder, offsetPosition, position, FOREVER_NS);
-
- final ViewGroup.LayoutParams lp = holder.itemView.getLayoutParams();
- final LayoutParams rvLayoutParams;
- if (lp == null) {
- rvLayoutParams = (LayoutParams) generateDefaultLayoutParams();
- holder.itemView.setLayoutParams(rvLayoutParams);
- } else if (!checkLayoutParams(lp)) {
- rvLayoutParams = (LayoutParams) generateLayoutParams(lp);
- holder.itemView.setLayoutParams(rvLayoutParams);
- } else {
- rvLayoutParams = (LayoutParams) lp;
- }
-
- rvLayoutParams.mInsetsDirty = true;
- rvLayoutParams.mViewHolder = holder;
- rvLayoutParams.mPendingInvalidate = holder.itemView.getParent() == null;
- }
-
- /**
- * RecyclerView provides artificial position range (item count) in pre-layout state and
- * automatically maps these positions to {@link Adapter} positions when
- * {@link #getViewForPosition(int)} or {@link #bindViewToPosition(View, int)} is called.
- *
- * Usually, LayoutManager does not need to worry about this. However, in some cases, your
- * LayoutManager may need to call some custom component with item positions in which
- * case you need the actual adapter position instead of the pre layout position. You
- * can use this method to convert a pre-layout position to adapter (post layout) position.
- *
- * Note that if the provided position belongs to a deleted ViewHolder, this method will
- * return -1.
- *
- * Calling this method in post-layout state returns the same value back.
- *
- * @param position The pre-layout position to convert. Must be greater or equal to 0 and
- * less than {@link State#getItemCount()}.
- */
- public int convertPreLayoutPositionToPostLayout(int position) {
- if (position < 0 || position >= mState.getItemCount()) {
- throw new IndexOutOfBoundsException("invalid position " + position + ". State "
- + "item count is " + mState.getItemCount() + exceptionLabel());
- }
- if (!mState.isPreLayout()) {
- return position;
- }
- return mAdapterHelper.findPositionOffset(position);
- }
-
- /**
- * Obtain a view initialized for the given position.
- *
- * This method should be used by {@link LayoutManager} implementations to obtain
- * views to represent data from an {@link Adapter}.
- *
- * The Recycler may reuse a scrap or detached view from a shared pool if one is
- * available for the correct view type. If the adapter has not indicated that the
- * data at the given position has changed, the Recycler will attempt to hand back
- * a scrap view that was previously initialized for that data without rebinding.
- *
- * @param position Position to obtain a view for
- * @return A view representing the data at position from adapter
- */
- @NonNull
- public View getViewForPosition(int position) {
- return getViewForPosition(position, false);
- }
-
- View getViewForPosition(int position, boolean dryRun) {
- return tryGetViewHolderForPositionByDeadline(position, dryRun, FOREVER_NS).itemView;
- }
-
- /**
- * Attempts to get the ViewHolder for the given position, either from the Recycler scrap,
- * cache, the RecycledViewPool, or creating it directly.
- *
- * If a deadlineNs other than {@link #FOREVER_NS} is passed, this method early return
- * rather than constructing or binding a ViewHolder if it doesn't think it has time.
- * If a ViewHolder must be constructed and not enough time remains, null is returned. If a
- * ViewHolder is aquired and must be bound but not enough time remains, an unbound holder is
- * returned. Use {@link ViewHolder#isBound()} on the returned object to check for this.
- *
- * @param position Position of ViewHolder to be returned.
- * @param dryRun True if the ViewHolder should not be removed from scrap/cache/
- * @param deadlineNs Time, relative to getNanoTime(), by which bind/create work should
- * complete. If FOREVER_NS is passed, this method will not fail to
- * create/bind the holder if needed.
- * @return ViewHolder for requested position
- */
- @Nullable
- ViewHolder tryGetViewHolderForPositionByDeadline(int position,
- boolean dryRun, long deadlineNs) {
- if (position < 0 || position >= mState.getItemCount()) {
- throw new IndexOutOfBoundsException("Invalid item position " + position
- + "(" + position + "). Item count:" + mState.getItemCount()
- + exceptionLabel());
- }
- boolean fromScrapOrHiddenOrCache = false;
- ViewHolder holder = null;
- // 0) If there is a changed scrap, try to find from there
- if (mState.isPreLayout()) {
- holder = getChangedScrapViewForPosition(position);
- fromScrapOrHiddenOrCache = holder != null;
- }
- // 1) Find by position from scrap/hidden list/cache
- if (holder == null) {
- holder = getScrapOrHiddenOrCachedHolderForPosition(position, dryRun);
- if (holder != null) {
- if (!validateViewHolderForOffsetPosition(holder)) {
- // recycle holder (and unscrap if relevant) since it can't be used
- if (!dryRun) {
- // we would like to recycle this but need to make sure it is not used by
- // animation logic etc.
- holder.addFlags(ViewHolder.FLAG_INVALID);
- if (holder.isScrap()) {
- removeDetachedView(holder.itemView, false);
- holder.unScrap();
- } else if (holder.wasReturnedFromScrap()) {
- holder.clearReturnedFromScrapFlag();
- }
- recycleViewHolderInternal(holder);
- }
- holder = null;
- } else {
- fromScrapOrHiddenOrCache = true;
- }
- }
- }
- if (holder == null) {
- final int offsetPosition = mAdapterHelper.findPositionOffset(position);
- if (offsetPosition < 0 || offsetPosition >= mAdapter.getItemCount()) {
- throw new IndexOutOfBoundsException("Inconsistency detected. Invalid item "
- + "position " + position + "(offset:" + offsetPosition + ")."
- + "state:" + mState.getItemCount() + exceptionLabel());
- }
-
- final int type = mAdapter.getItemViewType(offsetPosition);
- // 2) Find from scrap/cache via stable ids, if exists
- if (mAdapter.hasStableIds()) {
- holder = getScrapOrCachedViewForId(mAdapter.getItemId(offsetPosition),
- type, dryRun);
- if (holder != null) {
- // update position
- holder.mPosition = offsetPosition;
- fromScrapOrHiddenOrCache = true;
- }
- }
- if (holder == null && mViewCacheExtension != null) {
- // We are NOT sending the offsetPosition because LayoutManager does not
- // know it.
- final View view = mViewCacheExtension
- .getViewForPositionAndType(this, position, type);
- if (view != null) {
- holder = getChildViewHolder(view);
- if (holder == null) {
- throw new IllegalArgumentException("getViewForPositionAndType returned"
- + " a view which does not have a ViewHolder"
- + exceptionLabel());
- } else if (holder.shouldIgnore()) {
- throw new IllegalArgumentException("getViewForPositionAndType returned"
- + " a view that is ignored. You must call stopIgnoring before"
- + " returning this view." + exceptionLabel());
- }
- }
- }
- if (holder == null) { // fallback to pool
- if (sVerboseLoggingEnabled) {
- Log.d(TAG, "tryGetViewHolderForPositionByDeadline("
- + position + ") fetching from shared pool");
- }
- holder = getRecycledViewPool().getRecycledView(type);
- if (holder != null) {
- holder.resetInternal();
- if (FORCE_INVALIDATE_DISPLAY_LIST) {
- invalidateDisplayListInt(holder);
- }
- }
- }
- if (holder == null) {
- long start = getNanoTime();
- if (deadlineNs != FOREVER_NS
- && !mRecyclerPool.willCreateInTime(type, start, deadlineNs)) {
- // abort - we have a deadline we can't meet
- return null;
- }
- holder = mAdapter.createViewHolder(RecyclerView.this, type);
- if (ALLOW_THREAD_GAP_WORK) {
- // only bother finding nested RV if prefetching
- RecyclerView innerView = findNestedRecyclerView(holder.itemView);
- if (innerView != null) {
- holder.mNestedRecyclerView = new WeakReference<>(innerView);
- }
- }
-
- long end = getNanoTime();
- mRecyclerPool.factorInCreateTime(type, end - start);
- if (sVerboseLoggingEnabled) {
- Log.d(TAG, "tryGetViewHolderForPositionByDeadline created new ViewHolder");
- }
- }
- }
-
- // This is very ugly but the only place we can grab this information
- // before the View is rebound and returned to the LayoutManager for post layout ops.
- // We don't need this in pre-layout since the VH is not updated by the LM.
- if (fromScrapOrHiddenOrCache && !mState.isPreLayout() && holder
- .hasAnyOfTheFlags(ViewHolder.FLAG_BOUNCED_FROM_HIDDEN_LIST)) {
- holder.setFlags(0, ViewHolder.FLAG_BOUNCED_FROM_HIDDEN_LIST);
- if (mState.mRunSimpleAnimations) {
- int changeFlags = ItemAnimator
- .buildAdapterChangeFlagsForAnimations(holder);
- changeFlags |= ItemAnimator.FLAG_APPEARED_IN_PRE_LAYOUT;
- final ItemHolderInfo info = mItemAnimator.recordPreLayoutInformation(mState,
- holder, changeFlags, holder.getUnmodifiedPayloads());
- recordAnimationInfoIfBouncedHiddenView(holder, info);
- }
- }
-
- boolean bound = false;
- if (mState.isPreLayout() && holder.isBound()) {
- // do not update unless we absolutely have to.
- holder.mPreLayoutPosition = position;
- } else if (!holder.isBound() || holder.needsUpdate() || holder.isInvalid()) {
- if (sDebugAssertionsEnabled && holder.isRemoved()) {
- throw new IllegalStateException("Removed holder should be bound and it should"
- + " come here only in pre-layout. Holder: " + holder
- + exceptionLabel());
- }
- final int offsetPosition = mAdapterHelper.findPositionOffset(position);
- bound = tryBindViewHolderByDeadline(holder, offsetPosition, position, deadlineNs);
- }
-
- final ViewGroup.LayoutParams lp = holder.itemView.getLayoutParams();
- final LayoutParams rvLayoutParams;
- if (lp == null) {
- rvLayoutParams = (LayoutParams) generateDefaultLayoutParams();
- holder.itemView.setLayoutParams(rvLayoutParams);
- } else if (!checkLayoutParams(lp)) {
- rvLayoutParams = (LayoutParams) generateLayoutParams(lp);
- holder.itemView.setLayoutParams(rvLayoutParams);
- } else {
- rvLayoutParams = (LayoutParams) lp;
- }
- rvLayoutParams.mViewHolder = holder;
- rvLayoutParams.mPendingInvalidate = fromScrapOrHiddenOrCache && bound;
- return holder;
- }
-
- private void attachAccessibilityDelegateOnBind(ViewHolder holder) {
- if (isAccessibilityEnabled()) {
- final View itemView = holder.itemView;
- if (ViewCompat.getImportantForAccessibility(itemView)
- == ViewCompat.IMPORTANT_FOR_ACCESSIBILITY_AUTO) {
- ViewCompat.setImportantForAccessibility(itemView,
- ViewCompat.IMPORTANT_FOR_ACCESSIBILITY_YES);
- }
- if (mAccessibilityDelegate == null) {
- return;
- }
- AccessibilityDelegateCompat itemDelegate = mAccessibilityDelegate.getItemDelegate();
- if (itemDelegate instanceof RecyclerViewAccessibilityDelegate.ItemDelegate) {
- // If there was already an a11y delegate set on the itemView, store it in the
- // itemDelegate and then set the itemDelegate as the a11y delegate.
- ((RecyclerViewAccessibilityDelegate.ItemDelegate) itemDelegate)
- .saveOriginalDelegate(itemView);
- }
- ViewCompat.setAccessibilityDelegate(itemView, itemDelegate);
- }
- }
-
- private void invalidateDisplayListInt(ViewHolder holder) {
- if (holder.itemView instanceof ViewGroup) {
- invalidateDisplayListInt((ViewGroup) holder.itemView, false);
- }
- }
-
- private void invalidateDisplayListInt(ViewGroup viewGroup, boolean invalidateThis) {
- for (int i = viewGroup.getChildCount() - 1; i >= 0; i--) {
- final View view = viewGroup.getChildAt(i);
- if (view instanceof ViewGroup) {
- invalidateDisplayListInt((ViewGroup) view, true);
- }
- }
- if (!invalidateThis) {
- return;
- }
- // we need to force it to become invisible
- if (viewGroup.getVisibility() == View.INVISIBLE) {
- viewGroup.setVisibility(View.VISIBLE);
- viewGroup.setVisibility(View.INVISIBLE);
- } else {
- final int visibility = viewGroup.getVisibility();
- viewGroup.setVisibility(View.INVISIBLE);
- viewGroup.setVisibility(visibility);
- }
- }
-
- /**
- * Recycle a detached view. The specified view will be added to a pool of views
- * for later rebinding and reuse.
- *
- *
A view must be fully detached (removed from parent) before it may be recycled. If the
- * View is scrapped, it will be removed from scrap list.
- *
- * @param view Removed view for recycling
- * @see LayoutManager#removeAndRecycleView(View, Recycler)
- */
- public void recycleView(@NonNull View view) {
- // This public recycle method tries to make view recycle-able since layout manager
- // intended to recycle this view (e.g. even if it is in scrap or change cache)
- ViewHolder holder = getChildViewHolderInt(view);
- if (holder.isTmpDetached()) {
- removeDetachedView(view, false);
- }
- if (holder.isScrap()) {
- holder.unScrap();
- } else if (holder.wasReturnedFromScrap()) {
- holder.clearReturnedFromScrapFlag();
- }
- recycleViewHolderInternal(holder);
- // In most cases we dont need call endAnimation() because when view is detached,
- // ViewPropertyAnimation will end. But if the animation is based on ObjectAnimator or
- // if the ItemAnimator uses "pending runnable" and the ViewPropertyAnimation has not
- // started yet, the ItemAnimatior on the view may not be cleared.
- // In b/73552923, the View is removed by scroll pass while it's waiting in
- // the "pending moving" list of DefaultItemAnimator and DefaultItemAnimator later in
- // a post runnable, incorrectly performs postDelayed() on the detached view.
- // To fix the issue, we issue endAnimation() here to make sure animation of this view
- // finishes.
- //
- // Note the order: we must call endAnimation() after recycleViewHolderInternal()
- // to avoid recycle twice. If ViewHolder isRecyclable is false,
- // recycleViewHolderInternal() will not recycle it, endAnimation() will reset
- // isRecyclable flag and recycle the view.
- if (mItemAnimator != null && !holder.isRecyclable()) {
- mItemAnimator.endAnimation(holder);
- }
- }
-
- void recycleAndClearCachedViews() {
- final int count = mCachedViews.size();
- for (int i = count - 1; i >= 0; i--) {
- recycleCachedViewAt(i);
- }
- mCachedViews.clear();
- if (ALLOW_THREAD_GAP_WORK) {
- mPrefetchRegistry.clearPrefetchPositions();
- }
- }
-
- /**
- * Recycles a cached view and removes the view from the list. Views are added to cache
- * if and only if they are recyclable, so this method does not check it again.
- *
- * A small exception to this rule is when the view does not have an animator reference
- * but transient state is true (due to animations created outside ItemAnimator). In that
- * case, adapter may choose to recycle it. From RecyclerView's perspective, the view is
- * still recyclable since Adapter wants to do so.
- *
- * @param cachedViewIndex The index of the view in cached views list
- */
- void recycleCachedViewAt(int cachedViewIndex) {
- if (sVerboseLoggingEnabled) {
- Log.d(TAG, "Recycling cached view at index " + cachedViewIndex);
- }
- ViewHolder viewHolder = mCachedViews.get(cachedViewIndex);
- if (sVerboseLoggingEnabled) {
- Log.d(TAG, "CachedViewHolder to be recycled: " + viewHolder);
- }
- addViewHolderToRecycledViewPool(viewHolder, true);
- mCachedViews.remove(cachedViewIndex);
- }
-
- /**
- * internal implementation checks if view is scrapped or attached and throws an exception
- * if so.
- * Public version un-scraps before calling recycle.
- */
- void recycleViewHolderInternal(ViewHolder holder) {
- if (holder.isScrap() || holder.itemView.getParent() != null) {
- throw new IllegalArgumentException(
- "Scrapped or attached views may not be recycled. isScrap:"
- + holder.isScrap() + " isAttached:"
- + (holder.itemView.getParent() != null) + exceptionLabel());
- }
-
- if (holder.isTmpDetached()) {
- throw new IllegalArgumentException("Tmp detached view should be removed "
- + "from RecyclerView before it can be recycled: " + holder
- + exceptionLabel());
- }
-
- if (holder.shouldIgnore()) {
- throw new IllegalArgumentException("Trying to recycle an ignored view holder. You"
- + " should first call stopIgnoringView(view) before calling recycle."
- + exceptionLabel());
- }
- final boolean transientStatePreventsRecycling = holder
- .doesTransientStatePreventRecycling();
- @SuppressWarnings("unchecked") final boolean forceRecycle = mAdapter != null
- && transientStatePreventsRecycling
- && mAdapter.onFailedToRecycleView(holder);
- boolean cached = false;
- boolean recycled = false;
- if (sDebugAssertionsEnabled && mCachedViews.contains(holder)) {
- throw new IllegalArgumentException("cached view received recycle internal? "
- + holder + exceptionLabel());
- }
- if (forceRecycle || holder.isRecyclable()) {
- if (mViewCacheMax > 0
- && !holder.hasAnyOfTheFlags(ViewHolder.FLAG_INVALID
- | ViewHolder.FLAG_REMOVED
- | ViewHolder.FLAG_UPDATE
- | ViewHolder.FLAG_ADAPTER_POSITION_UNKNOWN)) {
- // Retire oldest cached view
- int cachedViewSize = mCachedViews.size();
- if (cachedViewSize >= mViewCacheMax && cachedViewSize > 0) {
- recycleCachedViewAt(0);
- cachedViewSize--;
- }
-
- int targetCacheIndex = cachedViewSize;
- if (ALLOW_THREAD_GAP_WORK
- && cachedViewSize > 0
- && !mPrefetchRegistry.lastPrefetchIncludedPosition(holder.mPosition)) {
- // when adding the view, skip past most recently prefetched views
- int cacheIndex = cachedViewSize - 1;
- while (cacheIndex >= 0) {
- int cachedPos = mCachedViews.get(cacheIndex).mPosition;
- if (!mPrefetchRegistry.lastPrefetchIncludedPosition(cachedPos)) {
- break;
- }
- cacheIndex--;
- }
- targetCacheIndex = cacheIndex + 1;
- }
- mCachedViews.add(targetCacheIndex, holder);
- cached = true;
- }
- if (!cached) {
- addViewHolderToRecycledViewPool(holder, true);
- recycled = true;
- }
- } else {
- // NOTE: A view can fail to be recycled when it is scrolled off while an animation
- // runs. In this case, the item is eventually recycled by
- // ItemAnimatorRestoreListener#onAnimationFinished.
-
- // TODO: consider cancelling an animation when an item is removed scrollBy,
- // to return it to the pool faster
- if (sVerboseLoggingEnabled) {
- Log.d(TAG, "trying to recycle a non-recycleable holder. Hopefully, it will "
- + "re-visit here. We are still removing it from animation lists"
- + exceptionLabel());
- }
- }
- // even if the holder is not removed, we still call this method so that it is removed
- // from view holder lists.
- mViewInfoStore.removeViewHolder(holder);
- if (!cached && !recycled && transientStatePreventsRecycling) {
- PoolingContainer.callPoolingContainerOnRelease(holder.itemView);
- holder.mBindingAdapter = null;
- holder.mOwnerRecyclerView = null;
- }
- }
-
- /**
- * Prepares the ViewHolder to be removed/recycled, and inserts it into the RecycledViewPool.
- *
- * Pass false to dispatchRecycled for views that have not been bound.
- *
- * @param holder Holder to be added to the pool.
- * @param dispatchRecycled True to dispatch View recycled callbacks.
- */
- void addViewHolderToRecycledViewPool(@NonNull ViewHolder holder, boolean dispatchRecycled) {
- clearNestedRecyclerViewIfNotNested(holder);
- View itemView = holder.itemView;
- if (mAccessibilityDelegate != null) {
- AccessibilityDelegateCompat itemDelegate = mAccessibilityDelegate.getItemDelegate();
- AccessibilityDelegateCompat originalDelegate = null;
- if (itemDelegate instanceof RecyclerViewAccessibilityDelegate.ItemDelegate) {
- originalDelegate =
- ((RecyclerViewAccessibilityDelegate.ItemDelegate) itemDelegate)
- .getAndRemoveOriginalDelegateForItem(itemView);
- }
- // Set the a11y delegate back to whatever the original delegate was.
- ViewCompat.setAccessibilityDelegate(itemView, originalDelegate);
- }
- if (dispatchRecycled) {
- dispatchViewRecycled(holder);
- }
- holder.mBindingAdapter = null;
- holder.mOwnerRecyclerView = null;
- getRecycledViewPool().putRecycledView(holder);
- }
-
- /**
- * Used as a fast path for unscrapping and recycling a view during a bulk operation.
- * The caller must call {@link #clearScrap()} when it's done to update the recycler's
- * internal bookkeeping.
- */
- void quickRecycleScrapView(View view) {
- final ViewHolder holder = getChildViewHolderInt(view);
- holder.mScrapContainer = null;
- holder.mInChangeScrap = false;
- holder.clearReturnedFromScrapFlag();
- recycleViewHolderInternal(holder);
- }
-
- /**
- * Mark an attached view as scrap.
- *
- *
"Scrap" views are still attached to their parent RecyclerView but are eligible
- * for rebinding and reuse. Requests for a view for a given position may return a
- * reused or rebound scrap view instance.
- *
- * @param view View to scrap
- */
- void scrapView(View view) {
- final ViewHolder holder = getChildViewHolderInt(view);
- if (holder.hasAnyOfTheFlags(ViewHolder.FLAG_REMOVED | ViewHolder.FLAG_INVALID)
- || !holder.isUpdated() || canReuseUpdatedViewHolder(holder)) {
- if (holder.isInvalid() && !holder.isRemoved() && !mAdapter.hasStableIds()) {
- throw new IllegalArgumentException("Called scrap view with an invalid view."
- + " Invalid views cannot be reused from scrap, they should rebound from"
- + " recycler pool." + exceptionLabel());
- }
- holder.setScrapContainer(this, false);
- mAttachedScrap.add(holder);
- } else {
- if (mChangedScrap == null) {
- mChangedScrap = new ArrayList();
- }
- holder.setScrapContainer(this, true);
- mChangedScrap.add(holder);
- }
- }
-
- /**
- * Remove a previously scrapped view from the pool of eligible scrap.
- *
- * This view will no longer be eligible for reuse until re-scrapped or
- * until it is explicitly removed and recycled.
- */
- void unscrapView(ViewHolder holder) {
- if (holder.mInChangeScrap) {
- mChangedScrap.remove(holder);
- } else {
- mAttachedScrap.remove(holder);
- }
- holder.mScrapContainer = null;
- holder.mInChangeScrap = false;
- holder.clearReturnedFromScrapFlag();
- }
-
- int getScrapCount() {
- return mAttachedScrap.size();
- }
-
- View getScrapViewAt(int index) {
- return mAttachedScrap.get(index).itemView;
- }
-
- void clearScrap() {
- mAttachedScrap.clear();
- if (mChangedScrap != null) {
- mChangedScrap.clear();
- }
- }
-
- ViewHolder getChangedScrapViewForPosition(int position) {
- // If pre-layout, check the changed scrap for an exact match.
- final int changedScrapSize;
- if (mChangedScrap == null || (changedScrapSize = mChangedScrap.size()) == 0) {
- return null;
- }
- // find by position
- for (int i = 0; i < changedScrapSize; i++) {
- final ViewHolder holder = mChangedScrap.get(i);
- if (!holder.wasReturnedFromScrap() && holder.getLayoutPosition() == position) {
- holder.addFlags(ViewHolder.FLAG_RETURNED_FROM_SCRAP);
- return holder;
- }
- }
- // find by id
- if (mAdapter.hasStableIds()) {
- final int offsetPosition = mAdapterHelper.findPositionOffset(position);
- if (offsetPosition > 0 && offsetPosition < mAdapter.getItemCount()) {
- final long id = mAdapter.getItemId(offsetPosition);
- for (int i = 0; i < changedScrapSize; i++) {
- final ViewHolder holder = mChangedScrap.get(i);
- if (!holder.wasReturnedFromScrap() && holder.getItemId() == id) {
- holder.addFlags(ViewHolder.FLAG_RETURNED_FROM_SCRAP);
- return holder;
- }
- }
- }
- }
- return null;
- }
-
- /**
- * Returns a view for the position either from attach scrap, hidden children, or cache.
- *
- * @param position Item position
- * @param dryRun Does a dry run, finds the ViewHolder but does not remove
- * @return a ViewHolder that can be re-used for this position.
- */
- ViewHolder getScrapOrHiddenOrCachedHolderForPosition(int position, boolean dryRun) {
- final int scrapCount = mAttachedScrap.size();
-
- // Try first for an exact, non-invalid match from scrap.
- for (int i = 0; i < scrapCount; i++) {
- final ViewHolder holder = mAttachedScrap.get(i);
- if (!holder.wasReturnedFromScrap() && holder.getLayoutPosition() == position
- && !holder.isInvalid() && (mState.mInPreLayout || !holder.isRemoved())) {
- holder.addFlags(ViewHolder.FLAG_RETURNED_FROM_SCRAP);
- return holder;
- }
- }
-
- if (!dryRun) {
- View view = mChildHelper.findHiddenNonRemovedView(position);
- if (view != null) {
- // This View is good to be used. We just need to unhide, detach and move to the
- // scrap list.
- final ViewHolder vh = getChildViewHolderInt(view);
- mChildHelper.unhide(view);
- int layoutIndex = mChildHelper.indexOfChild(view);
- if (layoutIndex == RecyclerView.NO_POSITION) {
- throw new IllegalStateException("layout index should not be -1 after "
- + "unhiding a view:" + vh + exceptionLabel());
- }
- mChildHelper.detachViewFromParent(layoutIndex);
- scrapView(view);
- vh.addFlags(ViewHolder.FLAG_RETURNED_FROM_SCRAP
- | ViewHolder.FLAG_BOUNCED_FROM_HIDDEN_LIST);
- return vh;
- }
- }
-
- // Search in our first-level recycled view cache.
- final int cacheSize = mCachedViews.size();
- for (int i = 0; i < cacheSize; i++) {
- final ViewHolder holder = mCachedViews.get(i);
- // invalid view holders may be in cache if adapter has stable ids as they can be
- // retrieved via getScrapOrCachedViewForId
- if (!holder.isInvalid() && holder.getLayoutPosition() == position
- && !holder.isAttachedToTransitionOverlay()) {
- if (!dryRun) {
- mCachedViews.remove(i);
- }
- if (sVerboseLoggingEnabled) {
- Log.d(TAG, "getScrapOrHiddenOrCachedHolderForPosition(" + position
- + ") found match in cache: " + holder);
- }
- return holder;
- }
- }
- return null;
- }
-
- ViewHolder getScrapOrCachedViewForId(long id, int type, boolean dryRun) {
- // Look in our attached views first
- final int count = mAttachedScrap.size();
- for (int i = count - 1; i >= 0; i--) {
- final ViewHolder holder = mAttachedScrap.get(i);
- if (holder.getItemId() == id && !holder.wasReturnedFromScrap()) {
- if (type == holder.getItemViewType()) {
- holder.addFlags(ViewHolder.FLAG_RETURNED_FROM_SCRAP);
- if (holder.isRemoved()) {
- // this might be valid in two cases:
- // > item is removed but we are in pre-layout pass
- // >> do nothing. return as is. make sure we don't rebind
- // > item is removed then added to another position and we are in
- // post layout.
- // >> remove removed and invalid flags, add update flag to rebind
- // because item was invisible to us and we don't know what happened in
- // between.
- if (!mState.isPreLayout()) {
- holder.setFlags(ViewHolder.FLAG_UPDATE, ViewHolder.FLAG_UPDATE
- | ViewHolder.FLAG_INVALID | ViewHolder.FLAG_REMOVED);
- }
- }
- return holder;
- } else if (!dryRun) {
- // if we are running animations, it is actually better to keep it in scrap
- // but this would force layout manager to lay it out which would be bad.
- // Recycle this scrap. Type mismatch.
- mAttachedScrap.remove(i);
- removeDetachedView(holder.itemView, false);
- quickRecycleScrapView(holder.itemView);
- }
- }
- }
-
- // Search the first-level cache
- final int cacheSize = mCachedViews.size();
- for (int i = cacheSize - 1; i >= 0; i--) {
- final ViewHolder holder = mCachedViews.get(i);
- if (holder.getItemId() == id && !holder.isAttachedToTransitionOverlay()) {
- if (type == holder.getItemViewType()) {
- if (!dryRun) {
- mCachedViews.remove(i);
- }
- return holder;
- } else if (!dryRun) {
- recycleCachedViewAt(i);
- return null;
- }
- }
- }
- return null;
- }
-
- @SuppressWarnings("unchecked")
- void dispatchViewRecycled(@NonNull ViewHolder holder) {
- // TODO: Remove this once setRecyclerListener (currently deprecated) is deleted.
- if (mRecyclerListener != null) {
- mRecyclerListener.onViewRecycled(holder);
- }
-
- final int listenerCount = mRecyclerListeners.size();
- for (int i = 0; i < listenerCount; i++) {
- mRecyclerListeners.get(i).onViewRecycled(holder);
- }
- if (mAdapter != null) {
- mAdapter.onViewRecycled(holder);
- }
- if (mState != null) {
- mViewInfoStore.removeViewHolder(holder);
- }
- if (sVerboseLoggingEnabled) Log.d(TAG, "dispatchViewRecycled: " + holder);
- }
-
- void onAdapterChanged(Adapter oldAdapter, Adapter newAdapter,
- boolean compatibleWithPrevious) {
- clear();
- poolingContainerDetach(oldAdapter, true);
- getRecycledViewPool().onAdapterChanged(oldAdapter, newAdapter,
- compatibleWithPrevious);
- maybeSendPoolingContainerAttach();
- }
-
- void offsetPositionRecordsForMove(int from, int to) {
- final int start, end, inBetweenOffset;
- if (from < to) {
- start = from;
- end = to;
- inBetweenOffset = -1;
- } else {
- start = to;
- end = from;
- inBetweenOffset = 1;
- }
- final int cachedCount = mCachedViews.size();
- for (int i = 0; i < cachedCount; i++) {
- final ViewHolder holder = mCachedViews.get(i);
- if (holder == null || holder.mPosition < start || holder.mPosition > end) {
- continue;
- }
- if (holder.mPosition == from) {
- holder.offsetPosition(to - from, false);
- } else {
- holder.offsetPosition(inBetweenOffset, false);
- }
- if (sVerboseLoggingEnabled) {
- Log.d(TAG, "offsetPositionRecordsForMove cached child " + i + " holder "
- + holder);
- }
- }
- }
-
- void offsetPositionRecordsForInsert(int insertedAt, int count) {
- final int cachedCount = mCachedViews.size();
- for (int i = 0; i < cachedCount; i++) {
- final ViewHolder holder = mCachedViews.get(i);
- if (holder != null && holder.mPosition >= insertedAt) {
- if (sVerboseLoggingEnabled) {
- Log.d(TAG, "offsetPositionRecordsForInsert cached " + i + " holder "
- + holder + " now at position " + (holder.mPosition + count));
- }
- // insertions only affect post layout hence don't apply them to pre-layout.
- holder.offsetPosition(count, false);
- }
- }
- }
-
- /**
- * @param removedFrom Remove start index
- * @param count Remove count
- * @param applyToPreLayout If true, changes will affect ViewHolder's pre-layout position, if
- * false, they'll be applied before the second layout pass
- */
- void offsetPositionRecordsForRemove(int removedFrom, int count, boolean applyToPreLayout) {
- final int removedEnd = removedFrom + count;
- final int cachedCount = mCachedViews.size();
- for (int i = cachedCount - 1; i >= 0; i--) {
- final ViewHolder holder = mCachedViews.get(i);
- if (holder != null) {
- if (holder.mPosition >= removedEnd) {
- if (sVerboseLoggingEnabled) {
- Log.d(TAG, "offsetPositionRecordsForRemove cached " + i
- + " holder " + holder + " now at position "
- + (holder.mPosition - count));
- }
- holder.offsetPosition(-count, applyToPreLayout);
- } else if (holder.mPosition >= removedFrom) {
- // Item for this view was removed. Dump it from the cache.
- holder.addFlags(ViewHolder.FLAG_REMOVED);
- recycleCachedViewAt(i);
- }
- }
- }
- }
-
- void setViewCacheExtension(ViewCacheExtension extension) {
- mViewCacheExtension = extension;
- }
-
- void setRecycledViewPool(RecycledViewPool pool) {
- poolingContainerDetach(mAdapter);
- if (mRecyclerPool != null) {
- mRecyclerPool.detach();
- }
- mRecyclerPool = pool;
- if (mRecyclerPool != null && getAdapter() != null) {
- mRecyclerPool.attach();
- }
- maybeSendPoolingContainerAttach();
- }
-
- private void maybeSendPoolingContainerAttach() {
- if (mRecyclerPool != null
- && mAdapter != null
- && isAttachedToWindow()) {
- mRecyclerPool.attachForPoolingContainer(mAdapter);
- }
- }
-
- private void poolingContainerDetach(Adapter adapter) {
- poolingContainerDetach(adapter, false);
- }
-
- private void poolingContainerDetach(Adapter adapter, boolean isBeingReplaced) {
- if (mRecyclerPool != null) {
- mRecyclerPool.detachForPoolingContainer(adapter, isBeingReplaced);
- }
- }
-
- void onAttachedToWindow() {
- maybeSendPoolingContainerAttach();
- }
-
- void onDetachedFromWindow() {
- for (int i = 0; i < mCachedViews.size(); i++) {
- PoolingContainer.callPoolingContainerOnRelease(mCachedViews.get(i).itemView);
- }
- poolingContainerDetach(mAdapter);
- }
-
- RecycledViewPool getRecycledViewPool() {
- if (mRecyclerPool == null) {
- mRecyclerPool = new RecycledViewPool();
- maybeSendPoolingContainerAttach();
- }
- return mRecyclerPool;
- }
-
- void viewRangeUpdate(int positionStart, int itemCount) {
- final int positionEnd = positionStart + itemCount;
- final int cachedCount = mCachedViews.size();
- for (int i = cachedCount - 1; i >= 0; i--) {
- final ViewHolder holder = mCachedViews.get(i);
- if (holder == null) {
- continue;
- }
-
- final int pos = holder.mPosition;
- if (pos >= positionStart && pos < positionEnd) {
- holder.addFlags(ViewHolder.FLAG_UPDATE);
- recycleCachedViewAt(i);
- // cached views should not be flagged as changed because this will cause them
- // to animate when they are returned from cache.
- }
- }
- }
-
- void markKnownViewsInvalid() {
- final int cachedCount = mCachedViews.size();
- for (int i = 0; i < cachedCount; i++) {
- final ViewHolder holder = mCachedViews.get(i);
- if (holder != null) {
- holder.addFlags(ViewHolder.FLAG_UPDATE | ViewHolder.FLAG_INVALID);
- holder.addChangePayload(null);
- }
- }
-
- if (mAdapter == null || !mAdapter.hasStableIds()) {
- // we cannot re-use cached views in this case. Recycle them all
- recycleAndClearCachedViews();
- }
- }
-
- void clearOldPositions() {
- final int cachedCount = mCachedViews.size();
- for (int i = 0; i < cachedCount; i++) {
- final ViewHolder holder = mCachedViews.get(i);
- holder.clearOldPosition();
- }
- final int scrapCount = mAttachedScrap.size();
- for (int i = 0; i < scrapCount; i++) {
- mAttachedScrap.get(i).clearOldPosition();
- }
- if (mChangedScrap != null) {
- final int changedScrapCount = mChangedScrap.size();
- for (int i = 0; i < changedScrapCount; i++) {
- mChangedScrap.get(i).clearOldPosition();
- }
- }
- }
-
- void markItemDecorInsetsDirty() {
- final int cachedCount = mCachedViews.size();
- for (int i = 0; i < cachedCount; i++) {
- final ViewHolder holder = mCachedViews.get(i);
- LayoutParams layoutParams = (LayoutParams) holder.itemView.getLayoutParams();
- if (layoutParams != null) {
- layoutParams.mInsetsDirty = true;
- }
- }
- }
- }
-
- /**
- * ViewCacheExtension is a helper class to provide an additional layer of view caching that can
- * be controlled by the developer.
- *
- * When {@link Recycler#getViewForPosition(int)} is called, Recycler checks attached scrap and
- * first level cache to find a matching View. If it cannot find a suitable View, Recycler will
- * call the {@link #getViewForPositionAndType(Recycler, int, int)} before checking
- * {@link RecycledViewPool}.
- *
- * Note that, Recycler never sends Views to this method to be cached. It is developers
- * responsibility to decide whether they want to keep their Views in this custom cache or let
- * the default recycling policy handle it.
- */
- public abstract static class ViewCacheExtension {
-
- /**
- * Returns a View that can be binded to the given Adapter position.
- *
- * This method should not create a new View. Instead, it is expected to return
- * an already created View that can be re-used for the given type and position.
- * If the View is marked as ignored, it should first call
- * {@link LayoutManager#stopIgnoringView(View)} before returning the View.
- *
- * RecyclerView will re-bind the returned View to the position if necessary.
- *
- * @param recycler The Recycler that can be used to bind the View
- * @param position The adapter position
- * @param type The type of the View, defined by adapter
- * @return A View that is bound to the given position or NULL if there is no View to re-use
- * @see LayoutManager#ignoreView(View)
- */
- @Nullable
- public abstract View getViewForPositionAndType(@NonNull Recycler recycler, int position,
- int type);
- }
-
- /**
- * Base class for an Adapter
- *
- *
Adapters provide a binding from an app-specific data set to views that are displayed
- * within a {@link RecyclerView}.
- *
- * @param A class that extends ViewHolder that will be used by the adapter.
- */
- public abstract static class Adapter {
- private final AdapterDataObservable mObservable = new AdapterDataObservable();
- private boolean mHasStableIds = false;
- private StateRestorationPolicy mStateRestorationPolicy = StateRestorationPolicy.ALLOW;
-
- /**
- * Called when RecyclerView needs a new {@link ViewHolder} of the given type to represent
- * an item.
- *
- * This new ViewHolder should be constructed with a new View that can represent the items
- * of the given type. You can either create a new View manually or inflate it from an XML
- * layout file.
- *
- * The new ViewHolder will be used to display items of the adapter using
- * {@link #onBindViewHolder(ViewHolder, int, List)}. Since it will be re-used to display
- * different items in the data set, it is a good idea to cache references to sub views of
- * the View to avoid unnecessary {@link View#findViewById(int)} calls.
- *
- * @param parent The ViewGroup into which the new View will be added after it is bound to
- * an adapter position.
- * @param viewType The view type of the new View.
- * @return A new ViewHolder that holds a View of the given view type.
- * @see #getItemViewType(int)
- * @see #onBindViewHolder(ViewHolder, int)
- */
- @NonNull
- public abstract VH onCreateViewHolder(@NonNull ViewGroup parent, int viewType);
-
- /**
- * Called by RecyclerView to display the data at the specified position. This method should
- * update the contents of the {@link ViewHolder#itemView} to reflect the item at the given
- * position.
- *
- * Note that unlike {@link android.widget.ListView}, RecyclerView will not call this method
- * again if the position of the item changes in the data set unless the item itself is
- * invalidated or the new position cannot be determined. For this reason, you should only
- * use the position parameter while acquiring the related data item inside
- * this method and should not keep a copy of it. If you need the position of an item later
- * on (e.g. in a click listener), use {@link ViewHolder#getBindingAdapterPosition()} which
- * will have the updated adapter position.
- *
- * Override {@link #onBindViewHolder(ViewHolder, int, List)} instead if Adapter can
- * handle efficient partial bind.
- *
- * @param holder The ViewHolder which should be updated to represent the contents of the
- * item at the given position in the data set.
- * @param position The position of the item within the adapter's data set.
- */
- public abstract void onBindViewHolder(@NonNull VH holder, int position);
-
- /**
- * Called by RecyclerView to display the data at the specified position. This method
- * should update the contents of the {@link ViewHolder#itemView} to reflect the item at
- * the given position.
- *
- * Note that unlike {@link android.widget.ListView}, RecyclerView will not call this method
- * again if the position of the item changes in the data set unless the item itself is
- * invalidated or the new position cannot be determined. For this reason, you should only
- * use the position parameter while acquiring the related data item inside
- * this method and should not keep a copy of it. If you need the position of an item later
- * on (e.g. in a click listener), use {@link ViewHolder#getBindingAdapterPosition()} which
- * will have the updated adapter position.
- *
- * Partial bind vs full bind:
- *
- * The payloads parameter is a merge list from {@link #notifyItemChanged(int, Object)} or
- * {@link #notifyItemRangeChanged(int, int, Object)}. If the payloads list is not empty,
- * the ViewHolder is currently bound to old data and Adapter may run an efficient partial
- * update using the payload info. If the payload is empty, Adapter must run a full bind.
- * Adapter should not assume that the payload passed in notify methods will be received by
- * onBindViewHolder(). For example when the view is not attached to the screen, the
- * payload in notifyItemChange() will be simply dropped.
- *
- * @param holder The ViewHolder which should be updated to represent the contents of the
- * item at the given position in the data set.
- * @param position The position of the item within the adapter's data set.
- * @param payloads A non-null list of merged payloads. Can be empty list if requires full
- * update.
- */
- public void onBindViewHolder(@NonNull VH holder, int position,
- @NonNull List payloads) {
- onBindViewHolder(holder, position);
- }
-
- /**
- * Returns the position of the given {@link ViewHolder} in the given {@link Adapter}.
- *
- * If the given {@link Adapter} is not part of this {@link Adapter},
- * {@link RecyclerView#NO_POSITION} is returned.
- *
- * @param adapter The adapter which is a sub adapter of this adapter or itself.
- * @param viewHolder The ViewHolder whose local position in the given adapter will be
- * returned.
- * @param localPosition The position of the given {@link ViewHolder} in this
- * {@link Adapter}.
- *
- * @return The local position of the given {@link ViewHolder} in this {@link Adapter}
- * or {@link RecyclerView#NO_POSITION} if the {@link ViewHolder} is not bound to an item
- * or the given {@link Adapter} is not part of this Adapter (if this Adapter merges other
- * adapters).
- */
- public int findRelativeAdapterPositionIn(
- @NonNull Adapter adapter,
- @NonNull ViewHolder viewHolder,
- int localPosition
- ) {
- if (adapter == this) {
- return localPosition;
- }
- return NO_POSITION;
- }
-
- /**
- * This method calls {@link #onCreateViewHolder(ViewGroup, int)} to create a new
- * {@link ViewHolder} and initializes some private fields to be used by RecyclerView.
- *
- * @see #onCreateViewHolder(ViewGroup, int)
- */
- @NonNull
- public final VH createViewHolder(@NonNull ViewGroup parent, int viewType) {
- try {
- TraceCompat.beginSection(TRACE_CREATE_VIEW_TAG);
- final VH holder = onCreateViewHolder(parent, viewType);
- if (holder.itemView.getParent() != null) {
- throw new IllegalStateException("ViewHolder views must not be attached when"
- + " created. Ensure that you are not passing 'true' to the attachToRoot"
- + " parameter of LayoutInflater.inflate(..., boolean attachToRoot)");
- }
- holder.mItemViewType = viewType;
- return holder;
- } finally {
- TraceCompat.endSection();
- }
- }
-
- /**
- * This method internally calls {@link #onBindViewHolder(ViewHolder, int)} to update the
- * {@link ViewHolder} contents with the item at the given position and also sets up some
- * private fields to be used by RecyclerView.
- *
- * Adapters that merge other adapters should use
- * {@link #bindViewHolder(ViewHolder, int)} when calling nested adapters so that
- * RecyclerView can track which adapter bound the {@link ViewHolder} to return the correct
- * position from {@link ViewHolder#getBindingAdapterPosition()} method.
- * They should also override
- * the {@link #findRelativeAdapterPositionIn(Adapter, ViewHolder, int)} method.
- *
- * @param holder The view holder whose contents should be updated
- * @param position The position of the holder with respect to this adapter
- * @see #onBindViewHolder(ViewHolder, int)
- */
- public final void bindViewHolder(@NonNull VH holder, int position) {
- boolean rootBind = holder.mBindingAdapter == null;
- if (rootBind) {
- holder.mPosition = position;
- if (hasStableIds()) {
- holder.mItemId = getItemId(position);
- }
- holder.setFlags(ViewHolder.FLAG_BOUND,
- ViewHolder.FLAG_BOUND | ViewHolder.FLAG_UPDATE | ViewHolder.FLAG_INVALID
- | ViewHolder.FLAG_ADAPTER_POSITION_UNKNOWN);
- TraceCompat.beginSection(TRACE_BIND_VIEW_TAG);
- }
- holder.mBindingAdapter = this;
- if (sDebugAssertionsEnabled) {
- if (holder.itemView.getParent() == null
- && (ViewCompat.isAttachedToWindow(holder.itemView)
- != holder.isTmpDetached())) {
- throw new IllegalStateException("Temp-detached state out of sync with reality. "
- + "holder.isTmpDetached(): " + holder.isTmpDetached()
- + ", attached to window: "
- + ViewCompat.isAttachedToWindow(holder.itemView)
- + ", holder: " + holder);
- }
- if (holder.itemView.getParent() == null
- && ViewCompat.isAttachedToWindow(holder.itemView)) {
- throw new IllegalStateException(
- "Attempting to bind attached holder with no parent"
- + " (AKA temp detached): " + holder);
- }
- }
- onBindViewHolder(holder, position, holder.getUnmodifiedPayloads());
- if (rootBind) {
- holder.clearPayload();
- final ViewGroup.LayoutParams layoutParams = holder.itemView.getLayoutParams();
- if (layoutParams instanceof RecyclerView.LayoutParams) {
- ((LayoutParams) layoutParams).mInsetsDirty = true;
- }
- TraceCompat.endSection();
- }
- }
-
- /**
- * Return the view type of the item at position for the purposes
- * of view recycling.
- *
- * The default implementation of this method returns 0, making the assumption of
- * a single view type for the adapter. Unlike ListView adapters, types need not
- * be contiguous. Consider using id resources to uniquely identify item view types.
- *
- * @param position position to query
- * @return integer value identifying the type of the view needed to represent the item at
- * position. Type codes need not be contiguous.
- */
- public int getItemViewType(int position) {
- return 0;
- }
-
- /**
- * Indicates whether each item in the data set can be represented with a unique identifier
- * of type {@link java.lang.Long}.
- *
- * @param hasStableIds Whether items in data set have unique identifiers or not.
- * @see #hasStableIds()
- * @see #getItemId(int)
- */
- public void setHasStableIds(boolean hasStableIds) {
- if (hasObservers()) {
- throw new IllegalStateException("Cannot change whether this adapter has "
- + "stable IDs while the adapter has registered observers.");
- }
- mHasStableIds = hasStableIds;
- }
-
- /**
- * Return the stable ID for the item at position. If {@link #hasStableIds()}
- * would return false this method should return {@link #NO_ID}. The default implementation
- * of this method returns {@link #NO_ID}.
- *
- * @param position Adapter position to query
- * @return the stable ID of the item at position
- */
- public long getItemId(int position) {
- return NO_ID;
- }
-
- /**
- * Returns the total number of items in the data set held by the adapter.
- *
- * @return The total number of items in this adapter.
- */
- public abstract int getItemCount();
-
- /**
- * Returns true if this adapter publishes a unique long value that can
- * act as a key for the item at a given position in the data set. If that item is relocated
- * in the data set, the ID returned for that item should be the same.
- *
- * @return true if this adapter's items have stable IDs
- */
- public final boolean hasStableIds() {
- return mHasStableIds;
- }
-
- /**
- * Called when a view created by this adapter has been recycled.
- *
- *
A view is recycled when a {@link LayoutManager} decides that it no longer
- * needs to be attached to its parent {@link RecyclerView}. This can be because it has
- * fallen out of visibility or a set of cached views represented by views still
- * attached to the parent RecyclerView. If an item view has large or expensive data
- * bound to it such as large bitmaps, this may be a good place to release those
- * resources.
- *
- * RecyclerView calls this method right before clearing ViewHolder's internal data and
- * sending it to RecycledViewPool. This way, if ViewHolder was holding valid information
- * before being recycled, you can call {@link ViewHolder#getBindingAdapterPosition()} to get
- * its adapter position.
- *
- * @param holder The ViewHolder for the view being recycled
- */
- public void onViewRecycled(@NonNull VH holder) {
- }
-
- /**
- * Called by the RecyclerView if a ViewHolder created by this Adapter cannot be recycled
- * due to its transient state. Upon receiving this callback, Adapter can clear the
- * animation(s) that effect the View's transient state and return true so that
- * the View can be recycled. Keep in mind that the View in question is already removed from
- * the RecyclerView.
- *
- * In some cases, it is acceptable to recycle a View although it has transient state. Most
- * of the time, this is a case where the transient state will be cleared in
- * {@link #onBindViewHolder(ViewHolder, int)} call when View is rebound to a new position.
- * For this reason, RecyclerView leaves the decision to the Adapter and uses the return
- * value of this method to decide whether the View should be recycled or not.
- *
- * Note that when all animations are created by {@link RecyclerView.ItemAnimator}, you
- * should never receive this callback because RecyclerView keeps those Views as children
- * until their animations are complete. This callback is useful when children of the item
- * views create animations which may not be easy to implement using an {@link ItemAnimator}.
- *
- * You should never fix this issue by calling
- * holder.itemView.setHasTransientState(false); unless you've previously called
- * holder.itemView.setHasTransientState(true);. Each
- * View.setHasTransientState(true) call must be matched by a
- * View.setHasTransientState(false) call, otherwise, the state of the View
- * may become inconsistent. You should always prefer to end or cancel animations that are
- * triggering the transient state instead of handling it manually.
- *
- * @param holder The ViewHolder containing the View that could not be recycled due to its
- * transient state.
- * @return True if the View should be recycled, false otherwise. Note that if this method
- * returns true, RecyclerView will ignore the transient state of
- * the View and recycle it regardless. If this method returns false,
- * RecyclerView will check the View's transient state again before giving a final decision.
- * Default implementation returns false.
- */
- public boolean onFailedToRecycleView(@NonNull VH holder) {
- return false;
- }
-
- /**
- * Called when a view created by this adapter has been attached to a window.
- *
- *
This can be used as a reasonable signal that the view is about to be seen
- * by the user. If the adapter previously freed any resources in
- * {@link #onViewDetachedFromWindow(RecyclerView.ViewHolder) onViewDetachedFromWindow}
- * those resources should be restored here.
- *
- * @param holder Holder of the view being attached
- */
- public void onViewAttachedToWindow(@NonNull VH holder) {
- }
-
- /**
- * Called when a view created by this adapter has been detached from its window.
- *
- * Becoming detached from the window is not necessarily a permanent condition;
- * the consumer of an Adapter's views may choose to cache views offscreen while they
- * are not visible, attaching and detaching them as appropriate.
- *
- * @param holder Holder of the view being detached
- */
- public void onViewDetachedFromWindow(@NonNull VH holder) {
- }
-
- /**
- * Returns true if one or more observers are attached to this adapter.
- *
- * @return true if this adapter has observers
- */
- public final boolean hasObservers() {
- return mObservable.hasObservers();
- }
-
- /**
- * Register a new observer to listen for data changes.
- *
- * The adapter may publish a variety of events describing specific changes.
- * Not all adapters may support all change types and some may fall back to a generic
- * {@link RecyclerView.AdapterDataObserver#onChanged()
- * "something changed"} event if more specific data is not available.
- *
- * Components registering observers with an adapter are responsible for
- * {@link #unregisterAdapterDataObserver(RecyclerView.AdapterDataObserver)
- * unregistering} those observers when finished.
- *
- * @param observer Observer to register
- * @see #unregisterAdapterDataObserver(RecyclerView.AdapterDataObserver)
- */
- public void registerAdapterDataObserver(@NonNull AdapterDataObserver observer) {
- mObservable.registerObserver(observer);
- }
-
- /**
- * Unregister an observer currently listening for data changes.
- *
- * The unregistered observer will no longer receive events about changes
- * to the adapter.
- *
- * @param observer Observer to unregister
- * @see #registerAdapterDataObserver(RecyclerView.AdapterDataObserver)
- */
- public void unregisterAdapterDataObserver(@NonNull AdapterDataObserver observer) {
- mObservable.unregisterObserver(observer);
- }
-
- /**
- * Called by RecyclerView when it starts observing this Adapter.
- *
- * Keep in mind that same adapter may be observed by multiple RecyclerViews.
- *
- * @param recyclerView The RecyclerView instance which started observing this adapter.
- * @see #onDetachedFromRecyclerView(RecyclerView)
- */
- public void onAttachedToRecyclerView(@NonNull RecyclerView recyclerView) {
- }
-
- /**
- * Called by RecyclerView when it stops observing this Adapter.
- *
- * @param recyclerView The RecyclerView instance which stopped observing this adapter.
- * @see #onAttachedToRecyclerView(RecyclerView)
- */
- public void onDetachedFromRecyclerView(@NonNull RecyclerView recyclerView) {
- }
-
- /**
- * Notify any registered observers that the data set has changed.
- *
- *
There are two different classes of data change events, item changes and structural
- * changes. Item changes are when a single item has its data updated but no positional
- * changes have occurred. Structural changes are when items are inserted, removed or moved
- * within the data set.
- *
- * This event does not specify what about the data set has changed, forcing
- * any observers to assume that all existing items and structure may no longer be valid.
- * LayoutManagers will be forced to fully rebind and relayout all visible views.
- *
- * RecyclerView will attempt to synthesize visible structural change events
- * for adapters that report that they have {@link #hasStableIds() stable IDs} when
- * this method is used. This can help for the purposes of animation and visual
- * object persistence but individual item views will still need to be rebound
- * and relaid out.
- *
- * If you are writing an adapter it will always be more efficient to use the more
- * specific change events if you can. Rely on notifyDataSetChanged()
- * as a last resort.
- *
- * @see #notifyItemChanged(int)
- * @see #notifyItemInserted(int)
- * @see #notifyItemRemoved(int)
- * @see #notifyItemRangeChanged(int, int)
- * @see #notifyItemRangeInserted(int, int)
- * @see #notifyItemRangeRemoved(int, int)
- */
- public final void notifyDataSetChanged() {
- mObservable.notifyChanged();
- }
-
- /**
- * Notify any registered observers that the item at position has changed.
- * Equivalent to calling notifyItemChanged(position, null);.
- *
- * This is an item change event, not a structural change event. It indicates that any
- * reflection of the data at position is out of date and should be updated.
- * The item at position retains the same identity.
- *
- * @param position Position of the item that has changed
- * @see #notifyItemRangeChanged(int, int)
- */
- public final void notifyItemChanged(int position) {
- mObservable.notifyItemRangeChanged(position, 1);
- }
-
- /**
- * Notify any registered observers that the item at position has changed with
- * an optional payload object.
- *
- * This is an item change event, not a structural change event. It indicates that any
- * reflection of the data at position is out of date and should be updated.
- * The item at position retains the same identity.
- *
- *
- *
- * Client can optionally pass a payload for partial change. These payloads will be merged
- * and may be passed to adapter's {@link #onBindViewHolder(ViewHolder, int, List)} if the
- * item is already represented by a ViewHolder and it will be rebound to the same
- * ViewHolder. A notifyItemRangeChanged() with null payload will clear all existing
- * payloads on that item and prevent future payload until
- * {@link #onBindViewHolder(ViewHolder, int, List)} is called. Adapter should not assume
- * that the payload will always be passed to onBindViewHolder(), e.g. when the view is not
- * attached, the payload will be simply dropped.
- *
- * @param position Position of the item that has changed
- * @param payload Optional parameter, use null to identify a "full" update
- * @see #notifyItemRangeChanged(int, int)
- */
- public final void notifyItemChanged(int position, @Nullable Object payload) {
- mObservable.notifyItemRangeChanged(position, 1, payload);
- }
-
- /**
- * Notify any registered observers that the itemCount items starting at
- * position positionStart have changed.
- * Equivalent to calling notifyItemRangeChanged(position, itemCount, null);.
- *
- *
This is an item change event, not a structural change event. It indicates that
- * any reflection of the data in the given position range is out of date and should
- * be updated. The items in the given range retain the same identity.
- *
- * @param positionStart Position of the first item that has changed
- * @param itemCount Number of items that have changed
- * @see #notifyItemChanged(int)
- */
- public final void notifyItemRangeChanged(int positionStart, int itemCount) {
- mObservable.notifyItemRangeChanged(positionStart, itemCount);
- }
-
- /**
- * Notify any registered observers that the itemCount items starting at
- * position positionStart have changed. An optional payload can be
- * passed to each changed item.
- *
- * This is an item change event, not a structural change event. It indicates that any
- * reflection of the data in the given position range is out of date and should be updated.
- * The items in the given range retain the same identity.
- *
- *
- *
- * Client can optionally pass a payload for partial change. These payloads will be merged
- * and may be passed to adapter's {@link #onBindViewHolder(ViewHolder, int, List)} if the
- * item is already represented by a ViewHolder and it will be rebound to the same
- * ViewHolder. A notifyItemRangeChanged() with null payload will clear all existing
- * payloads on that item and prevent future payload until
- * {@link #onBindViewHolder(ViewHolder, int, List)} is called. Adapter should not assume
- * that the payload will always be passed to onBindViewHolder(), e.g. when the view is not
- * attached, the payload will be simply dropped.
- *
- * @param positionStart Position of the first item that has changed
- * @param itemCount Number of items that have changed
- * @param payload Optional parameter, use null to identify a "full" update
- * @see #notifyItemChanged(int)
- */
- public final void notifyItemRangeChanged(int positionStart, int itemCount,
- @Nullable Object payload) {
- mObservable.notifyItemRangeChanged(positionStart, itemCount, payload);
- }
-
- /**
- * Notify any registered observers that the item reflected at position
- * has been newly inserted. The item previously at position is now at
- * position position + 1.
- *
- *
This is a structural change event. Representations of other existing items in the
- * data set are still considered up to date and will not be rebound, though their
- * positions may be altered.
- *
- * @param position Position of the newly inserted item in the data set
- * @see #notifyItemRangeInserted(int, int)
- */
- public final void notifyItemInserted(int position) {
- mObservable.notifyItemRangeInserted(position, 1);
- }
-
- /**
- * Notify any registered observers that the item reflected at fromPosition
- * has been moved to toPosition.
- *
- * This is a structural change event. Representations of other existing items in the
- * data set are still considered up to date and will not be rebound, though their
- * positions may be altered.
- *
- * @param fromPosition Previous position of the item.
- * @param toPosition New position of the item.
- */
- public final void notifyItemMoved(int fromPosition, int toPosition) {
- mObservable.notifyItemMoved(fromPosition, toPosition);
- }
-
- /**
- * Notify any registered observers that the currently reflected itemCount
- * items starting at positionStart have been newly inserted. The items
- * previously located at positionStart and beyond can now be found starting
- * at position positionStart + itemCount.
- *
- * This is a structural change event. Representations of other existing items in the
- * data set are still considered up to date and will not be rebound, though their positions
- * may be altered.
- *
- * @param positionStart Position of the first item that was inserted
- * @param itemCount Number of items inserted
- * @see #notifyItemInserted(int)
- */
- public final void notifyItemRangeInserted(int positionStart, int itemCount) {
- mObservable.notifyItemRangeInserted(positionStart, itemCount);
- }
-
- /**
- * Notify any registered observers that the item previously located at position
- * has been removed from the data set. The items previously located at and after
- * position may now be found at oldPosition - 1.
- *
- * This is a structural change event. Representations of other existing items in the
- * data set are still considered up to date and will not be rebound, though their positions
- * may be altered.
- *
- * @param position Position of the item that has now been removed
- * @see #notifyItemRangeRemoved(int, int)
- */
- public final void notifyItemRemoved(int position) {
- mObservable.notifyItemRangeRemoved(position, 1);
- }
-
- /**
- * Notify any registered observers that the itemCount items previously
- * located at positionStart have been removed from the data set. The items
- * previously located at and after positionStart + itemCount may now be found
- * at oldPosition - itemCount.
- *
- * This is a structural change event. Representations of other existing items in the data
- * set are still considered up to date and will not be rebound, though their positions
- * may be altered.
- *
- * @param positionStart Previous position of the first item that was removed
- * @param itemCount Number of items removed from the data set
- */
- public final void notifyItemRangeRemoved(int positionStart, int itemCount) {
- mObservable.notifyItemRangeRemoved(positionStart, itemCount);
- }
-
- /**
- * Sets the state restoration strategy for the Adapter.
- *
- * By default, it is set to {@link StateRestorationPolicy#ALLOW} which means RecyclerView
- * expects any set Adapter to be immediately capable of restoring the RecyclerView's saved
- * scroll position.
- *
- * This behaviour might be undesired if the Adapter's data is loaded asynchronously, and
- * thus unavailable during initial layout (e.g. after Activity rotation). To avoid losing
- * scroll position, you can change this to be either
- * {@link StateRestorationPolicy#PREVENT_WHEN_EMPTY} or
- * {@link StateRestorationPolicy#PREVENT}.
- * Note that the former means your RecyclerView will restore state as soon as Adapter has
- * 1 or more items while the latter requires you to call
- * {@link #setStateRestorationPolicy(StateRestorationPolicy)} with either
- * {@link StateRestorationPolicy#ALLOW} or
- * {@link StateRestorationPolicy#PREVENT_WHEN_EMPTY} again when the Adapter is
- * ready to restore its state.
- *
- * RecyclerView will still layout even when State restoration is disabled. The behavior of
- * how State is restored is up to the {@link LayoutManager}. All default LayoutManagers
- * will override current state with restored state when state restoration happens (unless
- * an explicit call to {@link LayoutManager#scrollToPosition(int)} is made).
- *
- * Calling this method after state is restored will not have any effect other than changing
- * the return value of {@link #getStateRestorationPolicy()}.
- *
- * @param strategy The saved state restoration strategy for this Adapter.
- * @see #getStateRestorationPolicy()
- */
- public void setStateRestorationPolicy(@NonNull StateRestorationPolicy strategy) {
- mStateRestorationPolicy = strategy;
- mObservable.notifyStateRestorationPolicyChanged();
- }
-
- /**
- * Returns when this Adapter wants to restore the state.
- *
- * @return The current {@link StateRestorationPolicy} for this Adapter. Defaults to
- * {@link StateRestorationPolicy#ALLOW}.
- * @see #setStateRestorationPolicy(StateRestorationPolicy)
- */
- @NonNull
- public final StateRestorationPolicy getStateRestorationPolicy() {
- return mStateRestorationPolicy;
- }
-
- /**
- * Called by the RecyclerView to decide whether the SavedState should be given to the
- * LayoutManager or not.
- *
- * @return {@code true} if the Adapter is ready to restore its state, {@code false}
- * otherwise.
- */
- boolean canRestoreState() {
- switch (mStateRestorationPolicy) {
- case PREVENT:
- return false;
- case PREVENT_WHEN_EMPTY:
- return getItemCount() > 0;
- default:
- return true;
- }
- }
-
- /**
- * Defines how this Adapter wants to restore its state after a view reconstruction (e.g.
- * configuration change).
- */
- public enum StateRestorationPolicy {
- /**
- * Adapter is ready to restore State immediately, RecyclerView will provide the state
- * to the LayoutManager in the next layout pass.
- */
- ALLOW,
- /**
- * Adapter is ready to restore State when it has more than 0 items. RecyclerView will
- * provide the state to the LayoutManager as soon as the Adapter has 1 or more items.
- */
- PREVENT_WHEN_EMPTY,
- /**
- * RecyclerView will not restore the state for the Adapter until a call to
- * {@link #setStateRestorationPolicy(StateRestorationPolicy)} is made with either
- * {@link #ALLOW} or {@link #PREVENT_WHEN_EMPTY}.
- */
- PREVENT
- }
- }
-
- @SuppressWarnings("unchecked")
- void dispatchChildDetached(View child) {
- final ViewHolder viewHolder = getChildViewHolderInt(child);
- onChildDetachedFromWindow(child);
- if (mAdapter != null && viewHolder != null) {
- mAdapter.onViewDetachedFromWindow(viewHolder);
- }
- if (mOnChildAttachStateListeners != null) {
- final int cnt = mOnChildAttachStateListeners.size();
- for (int i = cnt - 1; i >= 0; i--) {
- mOnChildAttachStateListeners.get(i).onChildViewDetachedFromWindow(child);
- }
- }
- }
-
- @SuppressWarnings("unchecked")
- void dispatchChildAttached(View child) {
- final ViewHolder viewHolder = getChildViewHolderInt(child);
- onChildAttachedToWindow(child);
- if (mAdapter != null && viewHolder != null) {
- mAdapter.onViewAttachedToWindow(viewHolder);
- }
- if (mOnChildAttachStateListeners != null) {
- final int cnt = mOnChildAttachStateListeners.size();
- for (int i = cnt - 1; i >= 0; i--) {
- mOnChildAttachStateListeners.get(i).onChildViewAttachedToWindow(child);
- }
- }
- }
-
- /**
- * A LayoutManager is responsible for measuring and positioning item views
- * within a RecyclerView as well as determining the policy for when to recycle
- * item views that are no longer visible to the user. By changing the LayoutManager
- * a RecyclerView can be used to implement a standard vertically scrolling list,
- * a uniform grid, staggered grids, horizontally scrolling collections and more. Several stock
- * layout managers are provided for general use.
- *
- * If the LayoutManager specifies a default constructor or one with the signature
- * ({@link Context}, {@link AttributeSet}, {@code int}, {@code int}), RecyclerView will
- * instantiate and set the LayoutManager when being inflated. Most used properties can
- * be then obtained from {@link #getProperties(Context, AttributeSet, int, int)}. In case
- * a LayoutManager specifies both constructors, the non-default constructor will take
- * precedence.
- */
- public abstract static class LayoutManager {
- ChildHelper mChildHelper;
- RecyclerView mRecyclerView;
-
- /**
- * The callback used for retrieving information about a RecyclerView and its children in the
- * horizontal direction.
- */
- private final ViewBoundsCheck.Callback mHorizontalBoundCheckCallback =
- new ViewBoundsCheck.Callback() {
- @Override
- public View getChildAt(int index) {
- return LayoutManager.this.getChildAt(index);
- }
-
- @Override
- public int getParentStart() {
- return LayoutManager.this.getPaddingLeft();
- }
-
- @Override
- public int getParentEnd() {
- return LayoutManager.this.getWidth() - LayoutManager.this.getPaddingRight();
- }
-
- @Override
- public int getChildStart(View view) {
- final RecyclerView.LayoutParams params = (RecyclerView.LayoutParams)
- view.getLayoutParams();
- return LayoutManager.this.getDecoratedLeft(view) - params.leftMargin;
- }
-
- @Override
- public int getChildEnd(View view) {
- final RecyclerView.LayoutParams params = (RecyclerView.LayoutParams)
- view.getLayoutParams();
- return LayoutManager.this.getDecoratedRight(view) + params.rightMargin;
- }
- };
-
- /**
- * The callback used for retrieving information about a RecyclerView and its children in the
- * vertical direction.
- */
- private final ViewBoundsCheck.Callback mVerticalBoundCheckCallback =
- new ViewBoundsCheck.Callback() {
- @Override
- public View getChildAt(int index) {
- return LayoutManager.this.getChildAt(index);
- }
-
- @Override
- public int getParentStart() {
- return LayoutManager.this.getPaddingTop();
- }
-
- @Override
- public int getParentEnd() {
- return LayoutManager.this.getHeight()
- - LayoutManager.this.getPaddingBottom();
- }
-
- @Override
- public int getChildStart(View view) {
- final RecyclerView.LayoutParams params = (RecyclerView.LayoutParams)
- view.getLayoutParams();
- return LayoutManager.this.getDecoratedTop(view) - params.topMargin;
- }
-
- @Override
- public int getChildEnd(View view) {
- final RecyclerView.LayoutParams params = (RecyclerView.LayoutParams)
- view.getLayoutParams();
- return LayoutManager.this.getDecoratedBottom(view) + params.bottomMargin;
- }
- };
-
- /**
- * Utility objects used to check the boundaries of children against their parent
- * RecyclerView.
- *
- * @see #isViewPartiallyVisible(View, boolean, boolean),
- * {@link LinearLayoutManager#findOneVisibleChild(int, int, boolean, boolean)},
- * and {@link LinearLayoutManager#findOnePartiallyOrCompletelyInvisibleChild(int, int)}.
- */
- ViewBoundsCheck mHorizontalBoundCheck = new ViewBoundsCheck(mHorizontalBoundCheckCallback);
- ViewBoundsCheck mVerticalBoundCheck = new ViewBoundsCheck(mVerticalBoundCheckCallback);
-
- @Nullable
- SmoothScroller mSmoothScroller;
-
- boolean mRequestedSimpleAnimations = false;
-
- boolean mIsAttachedToWindow = false;
-
- /**
- * This field is only set via the deprecated {@link #setAutoMeasureEnabled(boolean)} and is
- * only accessed via {@link #isAutoMeasureEnabled()} for backwards compatability reasons.
- */
- boolean mAutoMeasure = false;
-
- /**
- * LayoutManager has its own more strict measurement cache to avoid re-measuring a child
- * if the space that will be given to it is already larger than what it has measured before.
- */
- private boolean mMeasurementCacheEnabled = true;
-
- private boolean mItemPrefetchEnabled = true;
-
- /**
- * Written by {@link GapWorker} when prefetches occur to track largest number of view ever
- * requested by a {@link #collectInitialPrefetchPositions(int, LayoutPrefetchRegistry)} or
- * {@link #collectAdjacentPrefetchPositions(int, int, State, LayoutPrefetchRegistry)} call.
- *
- * If expanded by a {@link #collectInitialPrefetchPositions(int, LayoutPrefetchRegistry)},
- * will be reset upon layout to prevent initial prefetches (often large, since they're
- * proportional to expected child count) from expanding cache permanently.
- */
- int mPrefetchMaxCountObserved;
-
- /**
- * If true, mPrefetchMaxCountObserved is only valid until next layout, and should be reset.
- */
- boolean mPrefetchMaxObservedInInitialPrefetch;
-
- /**
- * These measure specs might be the measure specs that were passed into RecyclerView's
- * onMeasure method OR fake measure specs created by the RecyclerView.
- * For example, when a layout is run, RecyclerView always sets these specs to be
- * EXACTLY because a LayoutManager cannot resize RecyclerView during a layout pass.
- *
- * Also, to be able to use the hint in unspecified measure specs, RecyclerView checks the
- * API level and sets the size to 0 pre-M to avoid any issue that might be caused by
- * corrupt values. Older platforms have no responsibility to provide a size if they set
- * mode to unspecified.
- */
- private int mWidthMode, mHeightMode;
- private int mWidth, mHeight;
-
-
- /**
- * Interface for LayoutManagers to request items to be prefetched, based on position, with
- * specified distance from viewport, which indicates priority.
- *
- * @see LayoutManager#collectAdjacentPrefetchPositions(int, int, State, LayoutPrefetchRegistry)
- * @see LayoutManager#collectInitialPrefetchPositions(int, LayoutPrefetchRegistry)
- */
- public interface LayoutPrefetchRegistry {
- /**
- * Requests an an item to be prefetched, based on position, with a specified distance,
- * indicating priority.
- *
- * @param layoutPosition Position of the item to prefetch.
- * @param pixelDistance Distance from the current viewport to the bounds of the item,
- * must be non-negative.
- */
- void addPosition(int layoutPosition, int pixelDistance);
- }
-
- void setRecyclerView(RecyclerView recyclerView) {
- if (recyclerView == null) {
- mRecyclerView = null;
- mChildHelper = null;
- mWidth = 0;
- mHeight = 0;
- } else {
- mRecyclerView = recyclerView;
- mChildHelper = recyclerView.mChildHelper;
- mWidth = recyclerView.getWidth();
- mHeight = recyclerView.getHeight();
- }
- mWidthMode = MeasureSpec.EXACTLY;
- mHeightMode = MeasureSpec.EXACTLY;
- }
-
- void setMeasureSpecs(int wSpec, int hSpec) {
- mWidth = MeasureSpec.getSize(wSpec);
- mWidthMode = MeasureSpec.getMode(wSpec);
- if (mWidthMode == MeasureSpec.UNSPECIFIED && !ALLOW_SIZE_IN_UNSPECIFIED_SPEC) {
- mWidth = 0;
- }
-
- mHeight = MeasureSpec.getSize(hSpec);
- mHeightMode = MeasureSpec.getMode(hSpec);
- if (mHeightMode == MeasureSpec.UNSPECIFIED && !ALLOW_SIZE_IN_UNSPECIFIED_SPEC) {
- mHeight = 0;
- }
- }
-
- /**
- * Called after a layout is calculated during a measure pass when using auto-measure.
- *
- * It simply traverses all children to calculate a bounding box then calls
- * {@link #setMeasuredDimension(Rect, int, int)}. LayoutManagers can override that method
- * if they need to handle the bounding box differently.
- *
- * For example, GridLayoutManager override that method to ensure that even if a column is
- * empty, the GridLayoutManager still measures wide enough to include it.
- *
- * @param widthSpec The widthSpec that was passing into RecyclerView's onMeasure
- * @param heightSpec The heightSpec that was passing into RecyclerView's onMeasure
- */
- void setMeasuredDimensionFromChildren(int widthSpec, int heightSpec) {
- final int count = getChildCount();
- if (count == 0) {
- mRecyclerView.defaultOnMeasure(widthSpec, heightSpec);
- return;
- }
- int minX = Integer.MAX_VALUE;
- int minY = Integer.MAX_VALUE;
- int maxX = Integer.MIN_VALUE;
- int maxY = Integer.MIN_VALUE;
-
- for (int i = 0; i < count; i++) {
- View child = getChildAt(i);
- final Rect bounds = mRecyclerView.mTempRect;
- getDecoratedBoundsWithMargins(child, bounds);
- if (bounds.left < minX) {
- minX = bounds.left;
- }
- if (bounds.right > maxX) {
- maxX = bounds.right;
- }
- if (bounds.top < minY) {
- minY = bounds.top;
- }
- if (bounds.bottom > maxY) {
- maxY = bounds.bottom;
- }
- }
- mRecyclerView.mTempRect.set(minX, minY, maxX, maxY);
- setMeasuredDimension(mRecyclerView.mTempRect, widthSpec, heightSpec);
- }
-
- /**
- * Sets the measured dimensions from the given bounding box of the children and the
- * measurement specs that were passed into {@link RecyclerView#onMeasure(int, int)}. It is
- * only called if a LayoutManager returns true from
- * {@link #isAutoMeasureEnabled()} and it is called after the RecyclerView calls
- * {@link LayoutManager#onLayoutChildren(Recycler, State)} in the execution of
- * {@link RecyclerView#onMeasure(int, int)}.
- *
- * This method must call {@link #setMeasuredDimension(int, int)}.
- *
- * The default implementation adds the RecyclerView's padding to the given bounding box
- * then caps the value to be within the given measurement specs.
- *
- * @param childrenBounds The bounding box of all children
- * @param wSpec The widthMeasureSpec that was passed into the RecyclerView.
- * @param hSpec The heightMeasureSpec that was passed into the RecyclerView.
- * @see #isAutoMeasureEnabled()
- * @see #setMeasuredDimension(int, int)
- */
- public void setMeasuredDimension(Rect childrenBounds, int wSpec, int hSpec) {
- int usedWidth = childrenBounds.width() + getPaddingLeft() + getPaddingRight();
- int usedHeight = childrenBounds.height() + getPaddingTop() + getPaddingBottom();
- int width = chooseSize(wSpec, usedWidth, getMinimumWidth());
- int height = chooseSize(hSpec, usedHeight, getMinimumHeight());
- setMeasuredDimension(width, height);
- }
-
- /**
- * Calls {@code RecyclerView#requestLayout} on the underlying RecyclerView
- */
- public void requestLayout() {
- if (mRecyclerView != null) {
- mRecyclerView.requestLayout();
- }
- }
-
- /**
- * Checks if RecyclerView is in the middle of a layout or scroll and throws an
- * {@link IllegalStateException} if it is not .
- *
- * @param message The message for the exception. Can be null.
- * @see #assertNotInLayoutOrScroll(String)
- */
- public void assertInLayoutOrScroll(String message) {
- if (mRecyclerView != null) {
- mRecyclerView.assertInLayoutOrScroll(message);
- }
- }
-
- /**
- * Chooses a size from the given specs and parameters that is closest to the desired size
- * and also complies with the spec.
- *
- * @param spec The measureSpec
- * @param desired The preferred measurement
- * @param min The minimum value
- * @return A size that fits to the given specs
- */
- public static int chooseSize(int spec, int desired, int min) {
- final int mode = View.MeasureSpec.getMode(spec);
- final int size = View.MeasureSpec.getSize(spec);
- switch (mode) {
- case View.MeasureSpec.EXACTLY:
- return size;
- case View.MeasureSpec.AT_MOST:
- return Math.min(size, Math.max(desired, min));
- case View.MeasureSpec.UNSPECIFIED:
- default:
- return Math.max(desired, min);
- }
- }
-
- /**
- * Checks if RecyclerView is in the middle of a layout or scroll and throws an
- * {@link IllegalStateException} if it is .
- *
- * @param message The message for the exception. Can be null.
- * @see #assertInLayoutOrScroll(String)
- */
- @SuppressLint("UnknownNullness") // b/240775049: Cannot annotate properly
- public void assertNotInLayoutOrScroll(String message) {
- if (mRecyclerView != null) {
- mRecyclerView.assertNotInLayoutOrScroll(message);
- }
- }
-
- /**
- * Defines whether the measuring pass of layout should use the AutoMeasure mechanism of
- * {@link RecyclerView} or if it should be done by the LayoutManager's implementation of
- * {@link LayoutManager#onMeasure(Recycler, State, int, int)}.
- *
- * @param enabled True if layout measurement should be done by the
- * RecyclerView, false if it should be done by this
- * LayoutManager.
- * @see #isAutoMeasureEnabled()
- * @deprecated Implementors of LayoutManager should define whether or not it uses
- * AutoMeasure by overriding {@link #isAutoMeasureEnabled()}.
- */
- @Deprecated
- public void setAutoMeasureEnabled(boolean enabled) {
- mAutoMeasure = enabled;
- }
-
- /**
- * Returns whether the measuring pass of layout should use the AutoMeasure mechanism of
- * {@link RecyclerView} or if it should be done by the LayoutManager's implementation of
- * {@link LayoutManager#onMeasure(Recycler, State, int, int)}.
- *
- * This method returns false by default (it actually returns the value passed to the
- * deprecated {@link #setAutoMeasureEnabled(boolean)}) and should be overridden to return
- * true if a LayoutManager wants to be auto measured by the RecyclerView.
- *
- * If this method is overridden to return true,
- * {@link LayoutManager#onMeasure(Recycler, State, int, int)} should not be overridden.
- *
- * AutoMeasure is a RecyclerView mechanism that handles the measuring pass of layout in a
- * simple and contract satisfying way, including the wrapping of children laid out by
- * LayoutManager. Simply put, it handles wrapping children by calling
- * {@link LayoutManager#onLayoutChildren(Recycler, State)} during a call to
- * {@link RecyclerView#onMeasure(int, int)}, and then calculating desired dimensions based
- * on children's dimensions and positions. It does this while supporting all existing
- * animation capabilities of the RecyclerView.
- *
- * More specifically:
- *
- * When {@link RecyclerView#onMeasure(int, int)} is called, if the provided measure
- * specs both have a mode of {@link View.MeasureSpec#EXACTLY}, RecyclerView will set its
- * measured dimensions accordingly and return, allowing layout to continue as normal
- * (Actually, RecyclerView will call
- * {@link LayoutManager#onMeasure(Recycler, State, int, int)} for backwards compatibility
- * reasons but it should not be overridden if AutoMeasure is being used).
- * If one of the layout specs is not {@code EXACT}, the RecyclerView will start the
- * layout process. It will first process all pending Adapter updates and
- * then decide whether to run a predictive layout. If it decides to do so, it will first
- * call {@link #onLayoutChildren(Recycler, State)} with {@link State#isPreLayout()} set to
- * {@code true}. At this stage, {@link #getWidth()} and {@link #getHeight()} will still
- * return the width and height of the RecyclerView as of the last layout calculation.
- *
- * After handling the predictive case, RecyclerView will call
- * {@link #onLayoutChildren(Recycler, State)} with {@link State#isMeasuring()} set to
- * {@code true} and {@link State#isPreLayout()} set to {@code false}. The LayoutManager can
- * access the measurement specs via {@link #getHeight()}, {@link #getHeightMode()},
- * {@link #getWidth()} and {@link #getWidthMode()}.
- * After the layout calculation, RecyclerView sets the measured width & height by
- * calculating the bounding box for the children (+ RecyclerView's padding). The
- * LayoutManagers can override {@link #setMeasuredDimension(Rect, int, int)} to choose
- * different values. For instance, GridLayoutManager overrides this value to handle the case
- * where if it is vertical and has 3 columns but only 2 items, it should still measure its
- * width to fit 3 items, not 2.
- * Any following calls to {@link RecyclerView#onMeasure(int, int)} will run
- * {@link #onLayoutChildren(Recycler, State)} with {@link State#isMeasuring()} set to
- * {@code true} and {@link State#isPreLayout()} set to {@code false}. RecyclerView will
- * take care of which views are actually added / removed / moved / changed for animations so
- * that the LayoutManager should not worry about them and handle each
- * {@link #onLayoutChildren(Recycler, State)} call as if it is the last one.
- * When measure is complete and RecyclerView's
- * {@link #onLayout(boolean, int, int, int, int)} method is called, RecyclerView checks
- * whether it already did layout calculations during the measure pass and if so, it re-uses
- * that information. It may still decide to call {@link #onLayoutChildren(Recycler, State)}
- * if the last measure spec was different from the final dimensions or adapter contents
- * have changed between the measure call and the layout call.
- * Finally, animations are calculated and run as usual.
- *
- *
- * @return True if the measuring pass of layout should use the AutoMeasure
- * mechanism of {@link RecyclerView} or False if it should be done by the
- * LayoutManager's implementation of
- * {@link LayoutManager#onMeasure(Recycler, State, int, int)}.
- * @see #setMeasuredDimension(Rect, int, int)
- * @see #onMeasure(Recycler, State, int, int)
- */
- public boolean isAutoMeasureEnabled() {
- return mAutoMeasure;
- }
-
- /**
- * Returns whether this LayoutManager supports "predictive item animations".
- *
- * "Predictive item animations" are automatically created animations that show
- * where items came from, and where they are going to, as items are added, removed,
- * or moved within a layout.
- *
- * A LayoutManager wishing to support predictive item animations must override this
- * method to return true (the default implementation returns false) and must obey certain
- * behavioral contracts outlined in {@link #onLayoutChildren(Recycler, State)}.
- *
- * Whether item animations actually occur in a RecyclerView is actually determined by both
- * the return value from this method and the
- * {@link RecyclerView#setItemAnimator(ItemAnimator) ItemAnimator} set on the
- * RecyclerView itself. If the RecyclerView has a non-null ItemAnimator but this
- * method returns false, then only "simple item animations" will be enabled in the
- * RecyclerView, in which views whose position are changing are simply faded in/out. If the
- * RecyclerView has a non-null ItemAnimator and this method returns true, then predictive
- * item animations will be enabled in the RecyclerView.
- *
- * @return true if this LayoutManager supports predictive item animations, false otherwise.
- */
- public boolean supportsPredictiveItemAnimations() {
- return false;
- }
-
- /**
- * Sets whether the LayoutManager should be queried for views outside of
- * its viewport while the UI thread is idle between frames.
- *
- *
If enabled, the LayoutManager will be queried for items to inflate/bind in between
- * view system traversals on devices running API 21 or greater. Default value is true.
- *
- * On platforms API level 21 and higher, the UI thread is idle between passing a frame
- * to RenderThread and the starting up its next frame at the next VSync pulse. By
- * prefetching out of window views in this time period, delays from inflation and view
- * binding are much less likely to cause jank and stuttering during scrolls and flings.
- *
- * While prefetch is enabled, it will have the side effect of expanding the effective
- * size of the View cache to hold prefetched views.
- *
- * @param enabled True if items should be prefetched in between traversals.
- * @see #isItemPrefetchEnabled()
- */
- public final void setItemPrefetchEnabled(boolean enabled) {
- if (enabled != mItemPrefetchEnabled) {
- mItemPrefetchEnabled = enabled;
- mPrefetchMaxCountObserved = 0;
- if (mRecyclerView != null) {
- mRecyclerView.mRecycler.updateViewCacheSize();
- }
- }
- }
-
- /**
- * Sets whether the LayoutManager should be queried for views outside of
- * its viewport while the UI thread is idle between frames.
- *
- * @return true if item prefetch is enabled, false otherwise
- * @see #setItemPrefetchEnabled(boolean)
- */
- public final boolean isItemPrefetchEnabled() {
- return mItemPrefetchEnabled;
- }
-
- /**
- * Gather all positions from the LayoutManager to be prefetched, given specified momentum.
- *
- * If item prefetch is enabled, this method is called in between traversals to gather
- * which positions the LayoutManager will soon need, given upcoming movement in subsequent
- * traversals.
- *
- * The LayoutManager should call {@link LayoutPrefetchRegistry#addPosition(int, int)} for
- * each item to be prepared, and these positions will have their ViewHolders created and
- * bound, if there is sufficient time available, in advance of being needed by a
- * scroll or layout.
- *
- * @param dx X movement component.
- * @param dy Y movement component.
- * @param state State of RecyclerView
- * @param layoutPrefetchRegistry PrefetchRegistry to add prefetch entries into.
- * @see #isItemPrefetchEnabled()
- * @see #collectInitialPrefetchPositions(int, LayoutPrefetchRegistry)
- */
- @SuppressLint("UnknownNullness") // b/240775049: Cannot annotate properly
- public void collectAdjacentPrefetchPositions(int dx, int dy, State state,
- LayoutPrefetchRegistry layoutPrefetchRegistry) {
- }
-
- /**
- * Gather all positions from the LayoutManager to be prefetched in preperation for its
- * RecyclerView to come on screen, due to the movement of another, containing RecyclerView.
- *
- * This method is only called when a RecyclerView is nested in another RecyclerView.
- *
- * If item prefetch is enabled for this LayoutManager, as well in another containing
- * LayoutManager, this method is called in between draw traversals to gather
- * which positions this LayoutManager will first need, once it appears on the screen.
- *
- * For example, if this LayoutManager represents a horizontally scrolling list within a
- * vertically scrolling LayoutManager, this method would be called when the horizontal list
- * is about to come onscreen.
- *
- * The LayoutManager should call {@link LayoutPrefetchRegistry#addPosition(int, int)} for
- * each item to be prepared, and these positions will have their ViewHolders created and
- * bound, if there is sufficient time available, in advance of being needed by a
- * scroll or layout.
- *
- * @param adapterItemCount number of items in the associated adapter.
- * @param layoutPrefetchRegistry PrefetchRegistry to add prefetch entries into.
- * @see #isItemPrefetchEnabled()
- * @see #collectAdjacentPrefetchPositions(int, int, State, LayoutPrefetchRegistry)
- */
- @SuppressLint("UnknownNullness") // b/240775049: Cannot annotate properly
- public void collectInitialPrefetchPositions(int adapterItemCount,
- LayoutPrefetchRegistry layoutPrefetchRegistry) {
- }
-
- void dispatchAttachedToWindow(RecyclerView view) {
- mIsAttachedToWindow = true;
- onAttachedToWindow(view);
- }
-
- void dispatchDetachedFromWindow(RecyclerView view, Recycler recycler) {
- mIsAttachedToWindow = false;
- onDetachedFromWindow(view, recycler);
- }
-
- /**
- * Returns whether LayoutManager is currently attached to a RecyclerView which is attached
- * to a window.
- *
- * @return True if this LayoutManager is controlling a RecyclerView and the RecyclerView
- * is attached to window.
- */
- public boolean isAttachedToWindow() {
- return mIsAttachedToWindow;
- }
-
- /**
- * Causes the Runnable to execute on the next animation time step.
- * The runnable will be run on the user interface thread.
- *
- * Calling this method when LayoutManager is not attached to a RecyclerView has no effect.
- *
- * @param action The Runnable that will be executed.
- * @see #removeCallbacks
- */
- public void postOnAnimation(Runnable action) {
- if (mRecyclerView != null) {
- ViewCompat.postOnAnimation(mRecyclerView, action);
- }
- }
-
- /**
- * Removes the specified Runnable from the message queue.
- *
- * Calling this method when LayoutManager is not attached to a RecyclerView has no effect.
- *
- * @param action The Runnable to remove from the message handling queue
- * @return true if RecyclerView could ask the Handler to remove the Runnable,
- * false otherwise. When the returned value is true, the Runnable
- * may or may not have been actually removed from the message queue
- * (for instance, if the Runnable was not in the queue already.)
- * @see #postOnAnimation
- */
- public boolean removeCallbacks(Runnable action) {
- if (mRecyclerView != null) {
- return mRecyclerView.removeCallbacks(action);
- }
- return false;
- }
-
- /**
- * Called when this LayoutManager is both attached to a RecyclerView and that RecyclerView
- * is attached to a window.
- *
- * If the RecyclerView is re-attached with the same LayoutManager and Adapter, it may not
- * call {@link #onLayoutChildren(Recycler, State)} if nothing has changed and a layout was
- * not requested on the RecyclerView while it was detached.
- *
- * Subclass implementations should always call through to the superclass implementation.
- *
- * @param view The RecyclerView this LayoutManager is bound to
- * @see #onDetachedFromWindow(RecyclerView, Recycler)
- */
- @CallSuper
- public void onAttachedToWindow(RecyclerView view) {
- }
-
- /**
- * @deprecated override {@link #onDetachedFromWindow(RecyclerView, Recycler)}
- */
- @Deprecated
- public void onDetachedFromWindow(RecyclerView view) {
-
- }
-
- /**
- * Called when this LayoutManager is detached from its parent RecyclerView or when
- * its parent RecyclerView is detached from its window.
- *
- * LayoutManager should clear all of its View references as another LayoutManager might be
- * assigned to the RecyclerView.
- *
- * If the RecyclerView is re-attached with the same LayoutManager and Adapter, it may not
- * call {@link #onLayoutChildren(Recycler, State)} if nothing has changed and a layout was
- * not requested on the RecyclerView while it was detached.
- *
- * If your LayoutManager has View references that it cleans in on-detach, it should also
- * call {@link RecyclerView#requestLayout()} to ensure that it is re-laid out when
- * RecyclerView is re-attached.
- *
- * Subclass implementations should always call through to the superclass implementation.
- *
- * @param view The RecyclerView this LayoutManager is bound to
- * @param recycler The recycler to use if you prefer to recycle your children instead of
- * keeping them around.
- * @see #onAttachedToWindow(RecyclerView)
- */
- @CallSuper
- @SuppressLint("UnknownNullness") // b/240775049: Cannot annotate properly
- public void onDetachedFromWindow(RecyclerView view, Recycler recycler) {
- onDetachedFromWindow(view);
- }
-
- /**
- * Check if the RecyclerView is configured to clip child views to its padding.
- *
- * @return true if this RecyclerView clips children to its padding, false otherwise
- */
- public boolean getClipToPadding() {
- return mRecyclerView != null && mRecyclerView.mClipToPadding;
- }
-
- /**
- * Lay out all relevant child views from the given adapter.
- *
- * The LayoutManager is in charge of the behavior of item animations. By default,
- * RecyclerView has a non-null {@link #getItemAnimator() ItemAnimator}, and simple
- * item animations are enabled. This means that add/remove operations on the
- * adapter will result in animations to add new or appearing items, removed or
- * disappearing items, and moved items. If a LayoutManager returns false from
- * {@link #supportsPredictiveItemAnimations()}, which is the default, and runs a
- * normal layout operation during {@link #onLayoutChildren(Recycler, State)}, the
- * RecyclerView will have enough information to run those animations in a simple
- * way. For example, the default ItemAnimator, {@link DefaultItemAnimator}, will
- * simply fade views in and out, whether they are actually added/removed or whether
- * they are moved on or off the screen due to other add/remove operations.
- *
- *
A LayoutManager wanting a better item animation experience, where items can be
- * animated onto and off of the screen according to where the items exist when they
- * are not on screen, then the LayoutManager should return true from
- * {@link #supportsPredictiveItemAnimations()} and add additional logic to
- * {@link #onLayoutChildren(Recycler, State)}. Supporting predictive animations
- * means that {@link #onLayoutChildren(Recycler, State)} will be called twice;
- * once as a "pre" layout step to determine where items would have been prior to
- * a real layout, and again to do the "real" layout. In the pre-layout phase,
- * items will remember their pre-layout positions to allow them to be laid out
- * appropriately. Also, {@link LayoutParams#isItemRemoved() removed} items will
- * be returned from the scrap to help determine correct placement of other items.
- * These removed items should not be added to the child list, but should be used
- * to help calculate correct positioning of other views, including views that
- * were not previously onscreen (referred to as APPEARING views), but whose
- * pre-layout offscreen position can be determined given the extra
- * information about the pre-layout removed views.
- *
- * The second layout pass is the real layout in which only non-removed views
- * will be used. The only additional requirement during this pass is, if
- * {@link #supportsPredictiveItemAnimations()} returns true, to note which
- * views exist in the child list prior to layout and which are not there after
- * layout (referred to as DISAPPEARING views), and to position/layout those views
- * appropriately, without regard to the actual bounds of the RecyclerView. This allows
- * the animation system to know the location to which to animate these disappearing
- * views.
- *
- * The default LayoutManager implementations for RecyclerView handle all of these
- * requirements for animations already. Clients of RecyclerView can either use one
- * of these layout managers directly or look at their implementations of
- * onLayoutChildren() to see how they account for the APPEARING and
- * DISAPPEARING views.
- *
- * @param recycler Recycler to use for fetching potentially cached views for a
- * position
- * @param state Transient state of RecyclerView
- */
- @SuppressLint("UnknownNullness") // b/240775049: Cannot annotate properly
- public void onLayoutChildren(Recycler recycler, State state) {
- Log.e(TAG, "You must override onLayoutChildren(Recycler recycler, State state) ");
- }
-
- /**
- * Called after a full layout calculation is finished. The layout calculation may include
- * multiple {@link #onLayoutChildren(Recycler, State)} calls due to animations or
- * layout measurement but it will include only one {@link #onLayoutCompleted(State)} call.
- * This method will be called at the end of {@link View#layout(int, int, int, int)} call.
- *
- * This is a good place for the LayoutManager to do some cleanup like pending scroll
- * position, saved state etc.
- *
- * @param state Transient state of RecyclerView
- */
- @SuppressLint("UnknownNullness") // b/240775049: Cannot annotate properly
- public void onLayoutCompleted(State state) {
- }
-
- /**
- * Create a default LayoutParams object for a child of the RecyclerView.
- *
- *
LayoutManagers will often want to use a custom LayoutParams type
- * to store extra information specific to the layout. Client code should subclass
- * {@link RecyclerView.LayoutParams} for this purpose.
- *
- * Important: if you use your own custom LayoutParams type
- * you must also override
- * {@link #checkLayoutParams(LayoutParams)},
- * {@link #generateLayoutParams(android.view.ViewGroup.LayoutParams)} and
- * {@link #generateLayoutParams(android.content.Context, android.util.AttributeSet)}.
- *
- * @return A new LayoutParams for a child view
- */
- @SuppressLint("UnknownNullness") // b/240775049: Cannot annotate properly
- public abstract LayoutParams generateDefaultLayoutParams();
-
- /**
- * Determines the validity of the supplied LayoutParams object.
- *
- * This should check to make sure that the object is of the correct type
- * and all values are within acceptable ranges. The default implementation
- * returns true for non-null params.
- *
- * @param lp LayoutParams object to check
- * @return true if this LayoutParams object is valid, false otherwise
- */
- public boolean checkLayoutParams(LayoutParams lp) {
- return lp != null;
- }
-
- /**
- * Create a LayoutParams object suitable for this LayoutManager, copying relevant
- * values from the supplied LayoutParams object if possible.
- *
- * Important: if you use your own custom LayoutParams type
- * you must also override
- * {@link #checkLayoutParams(LayoutParams)},
- * {@link #generateLayoutParams(android.view.ViewGroup.LayoutParams)} and
- * {@link #generateLayoutParams(android.content.Context, android.util.AttributeSet)}.
- *
- * @param lp Source LayoutParams object to copy values from
- * @return a new LayoutParams object
- */
- @SuppressLint("UnknownNullness") // b/240775049: Cannot annotate properly
- public LayoutParams generateLayoutParams(ViewGroup.LayoutParams lp) {
- if (lp instanceof LayoutParams) {
- return new LayoutParams((LayoutParams) lp);
- } else if (lp instanceof MarginLayoutParams) {
- return new LayoutParams((MarginLayoutParams) lp);
- } else {
- return new LayoutParams(lp);
- }
- }
-
- /**
- * Create a LayoutParams object suitable for this LayoutManager from
- * an inflated layout resource.
- *
- * Important: if you use your own custom LayoutParams type
- * you must also override
- * {@link #checkLayoutParams(LayoutParams)},
- * {@link #generateLayoutParams(android.view.ViewGroup.LayoutParams)} and
- * {@link #generateLayoutParams(android.content.Context, android.util.AttributeSet)}.
- *
- * @param c Context for obtaining styled attributes
- * @param attrs AttributeSet describing the supplied arguments
- * @return a new LayoutParams object
- */
- @SuppressLint("UnknownNullness") // b/240775049: Cannot annotate properly
- public LayoutParams generateLayoutParams(Context c, AttributeSet attrs) {
- return new LayoutParams(c, attrs);
- }
-
- /**
- * Scroll horizontally by dx pixels in screen coordinates and return the distance traveled.
- * The default implementation does nothing and returns 0.
- *
- * @param dx distance to scroll by in pixels. X increases as scroll position
- * approaches the right.
- * @param recycler Recycler to use for fetching potentially cached views for a
- * position
- * @param state Transient state of RecyclerView
- * @return The actual distance scrolled. The return value will be negative if dx was
- * negative and scrolling proceeeded in that direction.
- * Math.abs(result) may be less than dx if a boundary was reached.
- */
- @SuppressLint("UnknownNullness") // b/240775049: Cannot annotate properly
- public int scrollHorizontallyBy(int dx, Recycler recycler, State state) {
- return 0;
- }
-
- /**
- * Scroll vertically by dy pixels in screen coordinates and return the distance traveled.
- * The default implementation does nothing and returns 0.
- *
- * @param dy distance to scroll in pixels. Y increases as scroll position
- * approaches the bottom.
- * @param recycler Recycler to use for fetching potentially cached views for a
- * position
- * @param state Transient state of RecyclerView
- * @return The actual distance scrolled. The return value will be negative if dy was
- * negative and scrolling proceeeded in that direction.
- * Math.abs(result) may be less than dy if a boundary was reached.
- */
- @SuppressLint("UnknownNullness") // b/240775049: Cannot annotate properly
- public int scrollVerticallyBy(int dy, Recycler recycler, State state) {
- return 0;
- }
-
- /**
- * Query if horizontal scrolling is currently supported. The default implementation
- * returns false.
- *
- * @return True if this LayoutManager can scroll the current contents horizontally
- */
- public boolean canScrollHorizontally() {
- return false;
- }
-
- /**
- * Query if vertical scrolling is currently supported. The default implementation
- * returns false.
- *
- * @return True if this LayoutManager can scroll the current contents vertically
- */
- public boolean canScrollVertically() {
- return false;
- }
-
- /**
- * Scroll to the specified adapter position.
- *
- * Actual position of the item on the screen depends on the LayoutManager implementation.
- *
- * @param position Scroll to this adapter position.
- */
- public void scrollToPosition(int position) {
- if (sVerboseLoggingEnabled) {
- Log.e(TAG, "You MUST implement scrollToPosition. It will soon become abstract");
- }
- }
-
- /**
- * Smooth scroll to the specified adapter position.
- * To support smooth scrolling, override this method, create your {@link SmoothScroller}
- * instance and call {@link #startSmoothScroll(SmoothScroller)}.
- *
- *
- * @param recyclerView The RecyclerView to which this layout manager is attached
- * @param state Current State of RecyclerView
- * @param position Scroll to this adapter position.
- */
- @SuppressLint("UnknownNullness") // b/240775049: Cannot annotate properly
- public void smoothScrollToPosition(RecyclerView recyclerView, State state,
- int position) {
- Log.e(TAG, "You must override smoothScrollToPosition to support smooth scrolling");
- }
-
- /**
- * Starts a smooth scroll using the provided {@link SmoothScroller}.
- *
- * Each instance of SmoothScroller is intended to only be used once. Provide a new
- * SmoothScroller instance each time this method is called.
- *
- *
Calling this method will cancel any previous smooth scroll request.
- *
- * @param smoothScroller Instance which defines how smooth scroll should be animated
- */
- @SuppressLint("UnknownNullness") // b/240775049: Cannot annotate properly
- public void startSmoothScroll(SmoothScroller smoothScroller) {
- if (mSmoothScroller != null && smoothScroller != mSmoothScroller
- && mSmoothScroller.isRunning()) {
- mSmoothScroller.stop();
- }
- mSmoothScroller = smoothScroller;
- mSmoothScroller.start(mRecyclerView, this);
- }
-
- /**
- * @return true if RecyclerView is currently in the state of smooth scrolling.
- */
- public boolean isSmoothScrolling() {
- return mSmoothScroller != null && mSmoothScroller.isRunning();
- }
-
- /**
- * Returns the resolved layout direction for this RecyclerView.
- *
- * @return {@link androidx.core.view.ViewCompat#LAYOUT_DIRECTION_RTL} if the layout
- * direction is RTL or returns
- * {@link androidx.core.view.ViewCompat#LAYOUT_DIRECTION_LTR} if the layout direction
- * is not RTL.
- */
- public int getLayoutDirection() {
- return ViewCompat.getLayoutDirection(mRecyclerView);
- }
-
- /**
- * Ends all animations on the view created by the {@link ItemAnimator}.
- *
- * @param view The View for which the animations should be ended.
- * @see RecyclerView.ItemAnimator#endAnimations()
- */
- @SuppressLint("UnknownNullness") // b/240775049: Cannot annotate properly
- public void endAnimation(View view) {
- if (mRecyclerView.mItemAnimator != null) {
- mRecyclerView.mItemAnimator.endAnimation(getChildViewHolderInt(view));
- }
- }
-
- /**
- * To be called only during {@link #onLayoutChildren(Recycler, State)} to add a view
- * to the layout that is known to be going away, either because it has been
- * {@link Adapter#notifyItemRemoved(int) removed} or because it is actually not in the
- * visible portion of the container but is being laid out in order to inform RecyclerView
- * in how to animate the item out of view.
- *
- * Views added via this method are going to be invisible to LayoutManager after the
- * dispatchLayout pass is complete. They cannot be retrieved via {@link #getChildAt(int)}
- * or won't be included in {@link #getChildCount()} method.
- *
- * @param child View to add and then remove with animation.
- */
- @SuppressLint("UnknownNullness") // b/240775049: Cannot annotate properly
- public void addDisappearingView(View child) {
- addDisappearingView(child, -1);
- }
-
- /**
- * To be called only during {@link #onLayoutChildren(Recycler, State)} to add a view
- * to the layout that is known to be going away, either because it has been
- * {@link Adapter#notifyItemRemoved(int) removed} or because it is actually not in the
- * visible portion of the container but is being laid out in order to inform RecyclerView
- * in how to animate the item out of view.
- *
- * Views added via this method are going to be invisible to LayoutManager after the
- * dispatchLayout pass is complete. They cannot be retrieved via {@link #getChildAt(int)}
- * or won't be included in {@link #getChildCount()} method.
- *
- * @param child View to add and then remove with animation.
- * @param index Index of the view.
- */
- @SuppressLint("UnknownNullness") // b/240775049: Cannot annotate properly
- public void addDisappearingView(View child, int index) {
- addViewInt(child, index, true);
- }
-
- /**
- * Add a view to the currently attached RecyclerView if needed. LayoutManagers should
- * use this method to add views obtained from a {@link Recycler} using
- * {@link Recycler#getViewForPosition(int)}.
- *
- * @param child View to add
- */
- @SuppressLint("UnknownNullness") // b/240775049: Cannot annotate properly
- public void addView(View child) {
- addView(child, -1);
- }
-
- /**
- * Add a view to the currently attached RecyclerView if needed. LayoutManagers should
- * use this method to add views obtained from a {@link Recycler} using
- * {@link Recycler#getViewForPosition(int)}.
- *
- * @param child View to add
- * @param index Index to add child at
- */
- @SuppressLint("UnknownNullness") // b/240775049: Cannot annotate properly
- public void addView(View child, int index) {
- addViewInt(child, index, false);
- }
-
- private void addViewInt(View child, int index, boolean disappearing) {
- final ViewHolder holder = getChildViewHolderInt(child);
- if (disappearing || holder.isRemoved()) {
- // these views will be hidden at the end of the layout pass.
- mRecyclerView.mViewInfoStore.addToDisappearedInLayout(holder);
- } else {
- // This may look like unnecessary but may happen if layout manager supports
- // predictive layouts and adapter removed then re-added the same item.
- // In this case, added version will be visible in the post layout (because add is
- // deferred) but RV will still bind it to the same View.
- // So if a View re-appears in post layout pass, remove it from disappearing list.
- mRecyclerView.mViewInfoStore.removeFromDisappearedInLayout(holder);
- }
- final LayoutParams lp = (LayoutParams) child.getLayoutParams();
- if (holder.wasReturnedFromScrap() || holder.isScrap()) {
- if (holder.isScrap()) {
- holder.unScrap();
- } else {
- holder.clearReturnedFromScrapFlag();
- }
- mChildHelper.attachViewToParent(child, index, child.getLayoutParams(), false);
- if (DISPATCH_TEMP_DETACH) {
- ViewCompat.dispatchFinishTemporaryDetach(child);
- }
- } else if (child.getParent() == mRecyclerView) { // it was not a scrap but a valid child
- // ensure in correct position
- int currentIndex = mChildHelper.indexOfChild(child);
- if (index == -1) {
- index = mChildHelper.getChildCount();
- }
- if (currentIndex == -1) {
- throw new IllegalStateException("Added View has RecyclerView as parent but"
- + " view is not a real child. Unfiltered index:"
- + mRecyclerView.indexOfChild(child) + mRecyclerView.exceptionLabel());
- }
- if (currentIndex != index) {
- mRecyclerView.mLayout.moveView(currentIndex, index);
- }
- } else {
- mChildHelper.addView(child, index, false);
- lp.mInsetsDirty = true;
- if (mSmoothScroller != null && mSmoothScroller.isRunning()) {
- mSmoothScroller.onChildAttachedToWindow(child);
- }
- }
- if (lp.mPendingInvalidate) {
- if (sVerboseLoggingEnabled) {
- Log.d(TAG, "consuming pending invalidate on child " + lp.mViewHolder);
- }
- holder.itemView.invalidate();
- lp.mPendingInvalidate = false;
- }
- }
-
- /**
- * Remove a view from the currently attached RecyclerView if needed. LayoutManagers should
- * use this method to completely remove a child view that is no longer needed.
- * LayoutManagers should strongly consider recycling removed views using
- * {@link Recycler#recycleView(android.view.View)}.
- *
- * @param child View to remove
- */
- @SuppressLint("UnknownNullness") // b/240775049: Cannot annotate properly
- public void removeView(View child) {
- mChildHelper.removeView(child);
- }
-
- /**
- * Remove a view from the currently attached RecyclerView if needed. LayoutManagers should
- * use this method to completely remove a child view that is no longer needed.
- * LayoutManagers should strongly consider recycling removed views using
- * {@link Recycler#recycleView(android.view.View)}.
- *
- * @param index Index of the child view to remove
- */
- public void removeViewAt(int index) {
- final View child = getChildAt(index);
- if (child != null) {
- mChildHelper.removeViewAt(index);
- }
- }
-
- /**
- * Remove all views from the currently attached RecyclerView. This will not recycle
- * any of the affected views; the LayoutManager is responsible for doing so if desired.
- */
- public void removeAllViews() {
- // Only remove non-animating views
- final int childCount = getChildCount();
- for (int i = childCount - 1; i >= 0; i--) {
- mChildHelper.removeViewAt(i);
- }
- }
-
- /**
- * Returns offset of the RecyclerView's text baseline from the its top boundary.
- *
- * @return The offset of the RecyclerView's text baseline from the its top boundary; -1 if
- * there is no baseline.
- */
- public int getBaseline() {
- return -1;
- }
-
- /**
- * Returns the adapter position of the item represented by the given View. This does not
- * contain any adapter changes that might have happened after the last layout.
- *
- * @param view The view to query
- * @return The adapter position of the item which is rendered by this View.
- */
- public int getPosition(@NonNull View view) {
- return ((RecyclerView.LayoutParams) view.getLayoutParams()).getViewLayoutPosition();
- }
-
- /**
- * Returns the View type defined by the adapter.
- *
- * @param view The view to query
- * @return The type of the view assigned by the adapter.
- */
- public int getItemViewType(@NonNull View view) {
- return getChildViewHolderInt(view).getItemViewType();
- }
-
- /**
- * Traverses the ancestors of the given view and returns the item view that contains it
- * and also a direct child of the LayoutManager.
- *
- * Note that this method may return null if the view is a child of the RecyclerView but
- * not a child of the LayoutManager (e.g. running a disappear animation).
- *
- * @param view The view that is a descendant of the LayoutManager.
- * @return The direct child of the LayoutManager which contains the given view or null if
- * the provided view is not a descendant of this LayoutManager.
- * @see RecyclerView#getChildViewHolder(View)
- * @see RecyclerView#findContainingViewHolder(View)
- */
- @Nullable
- public View findContainingItemView(@NonNull View view) {
- if (mRecyclerView == null) {
- return null;
- }
- View found = mRecyclerView.findContainingItemView(view);
- if (found == null) {
- return null;
- }
- if (mChildHelper.isHidden(found)) {
- return null;
- }
- return found;
- }
-
- /**
- * Finds the view which represents the given adapter position.
- *
- * This method traverses each child since it has no information about child order.
- * Override this method to improve performance if your LayoutManager keeps data about
- * child views.
- *
- * If a view is ignored via {@link #ignoreView(View)}, it is also ignored by this method.
- *
- * @param position Position of the item in adapter
- * @return The child view that represents the given position or null if the position is not
- * laid out
- */
- @Nullable
- public View findViewByPosition(int position) {
- final int childCount = getChildCount();
- for (int i = 0; i < childCount; i++) {
- View child = getChildAt(i);
- ViewHolder vh = getChildViewHolderInt(child);
- if (vh == null) {
- continue;
- }
- if (vh.getLayoutPosition() == position && !vh.shouldIgnore()
- && (mRecyclerView.mState.isPreLayout() || !vh.isRemoved())) {
- return child;
- }
- }
- return null;
- }
-
- /**
- * Temporarily detach a child view.
- *
- *
LayoutManagers may want to perform a lightweight detach operation to rearrange
- * views currently attached to the RecyclerView. Generally LayoutManager implementations
- * will want to use {@link #detachAndScrapView(android.view.View, RecyclerView.Recycler)}
- * so that the detached view may be rebound and reused.
- *
- * If a LayoutManager uses this method to detach a view, it must
- * {@link #attachView(android.view.View, int, RecyclerView.LayoutParams) reattach}
- * or {@link #removeDetachedView(android.view.View) fully remove} the detached view
- * before the LayoutManager entry point method called by RecyclerView returns.
- *
- * @param child Child to detach
- */
- public void detachView(@NonNull View child) {
- final int ind = mChildHelper.indexOfChild(child);
- if (ind >= 0) {
- detachViewInternal(ind, child);
- }
- }
-
- /**
- * Temporarily detach a child view.
- *
- * LayoutManagers may want to perform a lightweight detach operation to rearrange
- * views currently attached to the RecyclerView. Generally LayoutManager implementations
- * will want to use {@link #detachAndScrapView(android.view.View, RecyclerView.Recycler)}
- * so that the detached view may be rebound and reused.
- *
- * If a LayoutManager uses this method to detach a view, it must
- * {@link #attachView(android.view.View, int, RecyclerView.LayoutParams) reattach}
- * or {@link #removeDetachedView(android.view.View) fully remove} the detached view
- * before the LayoutManager entry point method called by RecyclerView returns.
- *
- * @param index Index of the child to detach
- */
- public void detachViewAt(int index) {
- detachViewInternal(index, getChildAt(index));
- }
-
- private void detachViewInternal(int index, @NonNull View view) {
- if (DISPATCH_TEMP_DETACH) {
- ViewCompat.dispatchStartTemporaryDetach(view);
- }
- mChildHelper.detachViewFromParent(index);
- }
-
- /**
- * Reattach a previously {@link #detachView(android.view.View) detached} view.
- * This method should not be used to reattach views that were previously
- * {@link #detachAndScrapView(android.view.View, RecyclerView.Recycler)} scrapped}.
- *
- * @param child Child to reattach
- * @param index Intended child index for child
- * @param lp LayoutParams for child
- */
- public void attachView(@NonNull View child, int index, LayoutParams lp) {
- ViewHolder vh = getChildViewHolderInt(child);
- if (vh.isRemoved()) {
- mRecyclerView.mViewInfoStore.addToDisappearedInLayout(vh);
- } else {
- mRecyclerView.mViewInfoStore.removeFromDisappearedInLayout(vh);
- }
- mChildHelper.attachViewToParent(child, index, lp, vh.isRemoved());
- if (DISPATCH_TEMP_DETACH) {
- ViewCompat.dispatchFinishTemporaryDetach(child);
- }
- }
-
- /**
- * Reattach a previously {@link #detachView(android.view.View) detached} view.
- * This method should not be used to reattach views that were previously
- * {@link #detachAndScrapView(android.view.View, RecyclerView.Recycler)} scrapped}.
- *
- * @param child Child to reattach
- * @param index Intended child index for child
- */
- public void attachView(@NonNull View child, int index) {
- attachView(child, index, (LayoutParams) child.getLayoutParams());
- }
-
- /**
- * Reattach a previously {@link #detachView(android.view.View) detached} view.
- * This method should not be used to reattach views that were previously
- * {@link #detachAndScrapView(android.view.View, RecyclerView.Recycler)} scrapped}.
- *
- * @param child Child to reattach
- */
- public void attachView(@NonNull View child) {
- attachView(child, -1);
- }
-
- /**
- * Finish removing a view that was previously temporarily
- * {@link #detachView(android.view.View) detached}.
- *
- * @param child Detached child to remove
- */
- public void removeDetachedView(@NonNull View child) {
- mRecyclerView.removeDetachedView(child, false);
- }
-
- /**
- * Moves a View from one position to another.
- *
- * @param fromIndex The View's initial index
- * @param toIndex The View's target index
- */
- public void moveView(int fromIndex, int toIndex) {
- View view = getChildAt(fromIndex);
- if (view == null) {
- throw new IllegalArgumentException("Cannot move a child from non-existing index:"
- + fromIndex + mRecyclerView.toString());
- }
- detachViewAt(fromIndex);
- attachView(view, toIndex);
- }
-
- /**
- * Detach a child view and add it to a {@link Recycler Recycler's} scrap heap.
- *
- * Scrapping a view allows it to be rebound and reused to show updated or
- * different data.
- *
- * @param child Child to detach and scrap
- * @param recycler Recycler to deposit the new scrap view into
- */
- public void detachAndScrapView(@NonNull View child, @NonNull Recycler recycler) {
- int index = mChildHelper.indexOfChild(child);
- scrapOrRecycleView(recycler, index, child);
- }
-
- /**
- * Detach a child view and add it to a {@link Recycler Recycler's} scrap heap.
- *
- * Scrapping a view allows it to be rebound and reused to show updated or
- * different data.
- *
- * @param index Index of child to detach and scrap
- * @param recycler Recycler to deposit the new scrap view into
- */
- public void detachAndScrapViewAt(int index, @NonNull Recycler recycler) {
- final View child = getChildAt(index);
- scrapOrRecycleView(recycler, index, child);
- }
-
- /**
- * Remove a child view and recycle it using the given Recycler.
- *
- * @param child Child to remove and recycle
- * @param recycler Recycler to use to recycle child
- */
- public void removeAndRecycleView(@NonNull View child, @NonNull Recycler recycler) {
- removeView(child);
- recycler.recycleView(child);
- }
-
- /**
- * Remove a child view and recycle it using the given Recycler.
- *
- * @param index Index of child to remove and recycle
- * @param recycler Recycler to use to recycle child
- */
- public void removeAndRecycleViewAt(int index, @NonNull Recycler recycler) {
- final View view = getChildAt(index);
- removeViewAt(index);
- recycler.recycleView(view);
- }
-
- /**
- * Return the current number of child views attached to the parent RecyclerView.
- * This does not include child views that were temporarily detached and/or scrapped.
- *
- * @return Number of attached children
- */
- public int getChildCount() {
- return mChildHelper != null ? mChildHelper.getChildCount() : 0;
- }
-
- /**
- * Return the child view at the given index
- *
- * @param index Index of child to return
- * @return Child view at index
- */
- @Nullable
- public View getChildAt(int index) {
- return mChildHelper != null ? mChildHelper.getChildAt(index) : null;
- }
-
- /**
- * Return the width measurement spec mode that is currently relevant to the LayoutManager.
- *
- * This value is set only if the LayoutManager opts into the AutoMeasure api via
- * {@link #setAutoMeasureEnabled(boolean)}.
- *
- *
When RecyclerView is running a layout, this value is always set to
- * {@link View.MeasureSpec#EXACTLY} even if it was measured with a different spec mode.
- *
- * @return Width measure spec mode
- * @see View.MeasureSpec#getMode(int)
- */
- public int getWidthMode() {
- return mWidthMode;
- }
-
- /**
- * Return the height measurement spec mode that is currently relevant to the LayoutManager.
- *
- *
This value is set only if the LayoutManager opts into the AutoMeasure api via
- * {@link #setAutoMeasureEnabled(boolean)}.
- *
- *
When RecyclerView is running a layout, this value is always set to
- * {@link View.MeasureSpec#EXACTLY} even if it was measured with a different spec mode.
- *
- * @return Height measure spec mode
- * @see View.MeasureSpec#getMode(int)
- */
- public int getHeightMode() {
- return mHeightMode;
- }
-
- /**
- * Returns the width that is currently relevant to the LayoutManager.
- *
- *
This value is usually equal to the laid out width of the {@link RecyclerView} but may
- * reflect the current {@link android.view.View.MeasureSpec} width if the
- * {@link LayoutManager} is using AutoMeasure and the RecyclerView is in the process of
- * measuring. The LayoutManager must always use this method to retrieve the width relevant
- * to it at any given time.
- *
- * @return Width in pixels
- */
- @Px
- public int getWidth() {
- return mWidth;
- }
-
- /**
- * Returns the height that is currently relevant to the LayoutManager.
- *
- *
This value is usually equal to the laid out height of the {@link RecyclerView} but may
- * reflect the current {@link android.view.View.MeasureSpec} height if the
- * {@link LayoutManager} is using AutoMeasure and the RecyclerView is in the process of
- * measuring. The LayoutManager must always use this method to retrieve the height relevant
- * to it at any given time.
- *
- * @return Height in pixels
- */
- @Px
- public int getHeight() {
- return mHeight;
- }
-
- /**
- * Return the left padding of the parent RecyclerView
- *
- * @return Padding in pixels
- */
- @Px
- public int getPaddingLeft() {
- return mRecyclerView != null ? mRecyclerView.getPaddingLeft() : 0;
- }
-
- /**
- * Return the top padding of the parent RecyclerView
- *
- * @return Padding in pixels
- */
- @Px
- public int getPaddingTop() {
- return mRecyclerView != null ? mRecyclerView.getPaddingTop() : 0;
- }
-
- /**
- * Return the right padding of the parent RecyclerView
- *
- * @return Padding in pixels
- */
- @Px
- public int getPaddingRight() {
- return mRecyclerView != null ? mRecyclerView.getPaddingRight() : 0;
- }
-
- /**
- * Return the bottom padding of the parent RecyclerView
- *
- * @return Padding in pixels
- */
- @Px
- public int getPaddingBottom() {
- return mRecyclerView != null ? mRecyclerView.getPaddingBottom() : 0;
- }
-
- /**
- * Return the start padding of the parent RecyclerView
- *
- * @return Padding in pixels
- */
- @Px
- public int getPaddingStart() {
- return mRecyclerView != null ? ViewCompat.getPaddingStart(mRecyclerView) : 0;
- }
-
- /**
- * Return the end padding of the parent RecyclerView
- *
- * @return Padding in pixels
- */
- @Px
- public int getPaddingEnd() {
- return mRecyclerView != null ? ViewCompat.getPaddingEnd(mRecyclerView) : 0;
- }
-
- /**
- * Returns true if the RecyclerView this LayoutManager is bound to has focus.
- *
- * @return True if the RecyclerView has focus, false otherwise.
- * @see View#isFocused()
- */
- public boolean isFocused() {
- return mRecyclerView != null && mRecyclerView.isFocused();
- }
-
- /**
- * Returns true if the RecyclerView this LayoutManager is bound to has or contains focus.
- *
- * @return true if the RecyclerView has or contains focus
- * @see View#hasFocus()
- */
- public boolean hasFocus() {
- return mRecyclerView != null && mRecyclerView.hasFocus();
- }
-
- /**
- * Returns the item View which has or contains focus.
- *
- * @return A direct child of RecyclerView which has focus or contains the focused child.
- */
- @Nullable
- public View getFocusedChild() {
- if (mRecyclerView == null) {
- return null;
- }
- final View focused = mRecyclerView.getFocusedChild();
- if (focused == null || mChildHelper.isHidden(focused)) {
- return null;
- }
- return focused;
- }
-
- /**
- * Returns the number of items in the adapter bound to the parent RecyclerView.
- *
- * Note that this number is not necessarily equal to
- * {@link State#getItemCount() State#getItemCount()}. In methods where {@link State} is
- * available, you should use {@link State#getItemCount() State#getItemCount()} instead.
- * For more details, check the documentation for
- * {@link State#getItemCount() State#getItemCount()}.
- *
- * @return The number of items in the bound adapter
- * @see State#getItemCount()
- */
- public int getItemCount() {
- final Adapter a = mRecyclerView != null ? mRecyclerView.getAdapter() : null;
- return a != null ? a.getItemCount() : 0;
- }
-
- /**
- * Offset all child views attached to the parent RecyclerView by dx pixels along
- * the horizontal axis.
- *
- * @param dx Pixels to offset by
- */
- public void offsetChildrenHorizontal(@Px int dx) {
- if (mRecyclerView != null) {
- mRecyclerView.offsetChildrenHorizontal(dx);
- }
- }
-
- /**
- * Offset all child views attached to the parent RecyclerView by dy pixels along
- * the vertical axis.
- *
- * @param dy Pixels to offset by
- */
- public void offsetChildrenVertical(@Px int dy) {
- if (mRecyclerView != null) {
- mRecyclerView.offsetChildrenVertical(dy);
- }
- }
-
- /**
- * Flags a view so that it will not be scrapped or recycled.
- *
- * Scope of ignoring a child is strictly restricted to position tracking, scrapping and
- * recyling. Methods like {@link #removeAndRecycleAllViews(Recycler)} will ignore the child
- * whereas {@link #removeAllViews()} or {@link #offsetChildrenHorizontal(int)} will not
- * ignore the child.
- *
- * Before this child can be recycled again, you have to call
- * {@link #stopIgnoringView(View)}.
- *
- * You can call this method only if your LayoutManger is in onLayout or onScroll callback.
- *
- * @param view View to ignore.
- * @see #stopIgnoringView(View)
- */
- public void ignoreView(@NonNull View view) {
- if (view.getParent() != mRecyclerView || mRecyclerView.indexOfChild(view) == -1) {
- // checking this because calling this method on a recycled or detached view may
- // cause loss of state.
- throw new IllegalArgumentException("View should be fully attached to be ignored"
- + mRecyclerView.exceptionLabel());
- }
- final ViewHolder vh = getChildViewHolderInt(view);
- vh.addFlags(ViewHolder.FLAG_IGNORE);
- mRecyclerView.mViewInfoStore.removeViewHolder(vh);
- }
-
- /**
- * View can be scrapped and recycled again.
- *
- * Note that calling this method removes all information in the view holder.
- *
- * You can call this method only if your LayoutManger is in onLayout or onScroll callback.
- *
- * @param view View to ignore.
- */
- public void stopIgnoringView(@NonNull View view) {
- final ViewHolder vh = getChildViewHolderInt(view);
- vh.stopIgnoring();
- vh.resetInternal();
- vh.addFlags(ViewHolder.FLAG_INVALID);
- }
-
- /**
- * Temporarily detach and scrap all currently attached child views. Views will be scrapped
- * into the given Recycler. The Recycler may prefer to reuse scrap views before
- * other views that were previously recycled.
- *
- * @param recycler Recycler to scrap views into
- */
- public void detachAndScrapAttachedViews(@NonNull Recycler recycler) {
- final int childCount = getChildCount();
- for (int i = childCount - 1; i >= 0; i--) {
- final View v = getChildAt(i);
- scrapOrRecycleView(recycler, i, v);
- }
- }
-
- private void scrapOrRecycleView(Recycler recycler, int index, View view) {
- final ViewHolder viewHolder = getChildViewHolderInt(view);
- if (viewHolder.shouldIgnore()) {
- if (sVerboseLoggingEnabled) {
- Log.d(TAG, "ignoring view " + viewHolder);
- }
- return;
- }
- if (viewHolder.isInvalid() && !viewHolder.isRemoved()
- && !mRecyclerView.mAdapter.hasStableIds()) {
- removeViewAt(index);
- recycler.recycleViewHolderInternal(viewHolder);
- } else {
- detachViewAt(index);
- recycler.scrapView(view);
- mRecyclerView.mViewInfoStore.onViewDetached(viewHolder);
- }
- }
-
- /**
- * Recycles the scrapped views.
- *
- * When a view is detached and removed, it does not trigger a ViewGroup invalidate. This is
- * the expected behavior if scrapped views are used for animations. Otherwise, we need to
- * call remove and invalidate RecyclerView to ensure UI update.
- *
- * @param recycler Recycler
- */
- void removeAndRecycleScrapInt(Recycler recycler) {
- final int scrapCount = recycler.getScrapCount();
- // Loop backward, recycler might be changed by removeDetachedView()
- for (int i = scrapCount - 1; i >= 0; i--) {
- final View scrap = recycler.getScrapViewAt(i);
- final ViewHolder vh = getChildViewHolderInt(scrap);
- if (vh.shouldIgnore()) {
- continue;
- }
- // If the scrap view is animating, we need to cancel them first. If we cancel it
- // here, ItemAnimator callback may recycle it which will cause double recycling.
- // To avoid this, we mark it as not recyclable before calling the item animator.
- // Since removeDetachedView calls a user API, a common mistake (ending animations on
- // the view) may recycle it too, so we guard it before we call user APIs.
- vh.setIsRecyclable(false);
- if (vh.isTmpDetached()) {
- mRecyclerView.removeDetachedView(scrap, false);
- }
- if (mRecyclerView.mItemAnimator != null) {
- mRecyclerView.mItemAnimator.endAnimation(vh);
- }
- vh.setIsRecyclable(true);
- recycler.quickRecycleScrapView(scrap);
- }
- recycler.clearScrap();
- if (scrapCount > 0) {
- mRecyclerView.invalidate();
- }
- }
-
-
- /**
- * Measure a child view using standard measurement policy, taking the padding
- * of the parent RecyclerView and any added item decorations into account.
- *
- *
If the RecyclerView can be scrolled in either dimension the caller may
- * pass 0 as the widthUsed or heightUsed parameters as they will be irrelevant.
- *
- * @param child Child view to measure
- * @param widthUsed Width in pixels currently consumed by other views, if relevant
- * @param heightUsed Height in pixels currently consumed by other views, if relevant
- */
- public void measureChild(@NonNull View child, int widthUsed, int heightUsed) {
- final LayoutParams lp = (LayoutParams) child.getLayoutParams();
-
- final Rect insets = mRecyclerView.getItemDecorInsetsForChild(child);
- widthUsed += insets.left + insets.right;
- heightUsed += insets.top + insets.bottom;
- final int widthSpec = getChildMeasureSpec(getWidth(), getWidthMode(),
- getPaddingLeft() + getPaddingRight() + widthUsed, lp.width,
- canScrollHorizontally());
- final int heightSpec = getChildMeasureSpec(getHeight(), getHeightMode(),
- getPaddingTop() + getPaddingBottom() + heightUsed, lp.height,
- canScrollVertically());
- if (shouldMeasureChild(child, widthSpec, heightSpec, lp)) {
- child.measure(widthSpec, heightSpec);
- }
- }
-
- /**
- * RecyclerView internally does its own View measurement caching which should help with
- * WRAP_CONTENT.
- *
- * Use this method if the View is already measured once in this layout pass.
- */
- boolean shouldReMeasureChild(View child, int widthSpec, int heightSpec, LayoutParams lp) {
- return !mMeasurementCacheEnabled
- || !isMeasurementUpToDate(child.getMeasuredWidth(), widthSpec, lp.width)
- || !isMeasurementUpToDate(child.getMeasuredHeight(), heightSpec, lp.height);
- }
-
- // we may consider making this public
-
- /**
- * RecyclerView internally does its own View measurement caching which should help with
- * WRAP_CONTENT.
- *
- * Use this method if the View is not yet measured and you need to decide whether to
- * measure this View or not.
- */
- boolean shouldMeasureChild(View child, int widthSpec, int heightSpec, LayoutParams lp) {
- return child.isLayoutRequested()
- || !mMeasurementCacheEnabled
- || !isMeasurementUpToDate(child.getWidth(), widthSpec, lp.width)
- || !isMeasurementUpToDate(child.getHeight(), heightSpec, lp.height);
- }
-
- /**
- * In addition to the View Framework's measurement cache, RecyclerView uses its own
- * additional measurement cache for its children to avoid re-measuring them when not
- * necessary. It is on by default but it can be turned off via
- * {@link #setMeasurementCacheEnabled(boolean)}.
- *
- * @return True if measurement cache is enabled, false otherwise.
- * @see #setMeasurementCacheEnabled(boolean)
- */
- public boolean isMeasurementCacheEnabled() {
- return mMeasurementCacheEnabled;
- }
-
- /**
- * Sets whether RecyclerView should use its own measurement cache for the children. This is
- * a more aggressive cache than the framework uses.
- *
- * @param measurementCacheEnabled True to enable the measurement cache, false otherwise.
- * @see #isMeasurementCacheEnabled()
- */
- public void setMeasurementCacheEnabled(boolean measurementCacheEnabled) {
- mMeasurementCacheEnabled = measurementCacheEnabled;
- }
-
- private static boolean isMeasurementUpToDate(int childSize, int spec, int dimension) {
- final int specMode = MeasureSpec.getMode(spec);
- final int specSize = MeasureSpec.getSize(spec);
- if (dimension > 0 && childSize != dimension) {
- return false;
- }
- switch (specMode) {
- case MeasureSpec.UNSPECIFIED:
- return true;
- case MeasureSpec.AT_MOST:
- return specSize >= childSize;
- case MeasureSpec.EXACTLY:
- return specSize == childSize;
- }
- return false;
- }
-
- /**
- * Measure a child view using standard measurement policy, taking the padding
- * of the parent RecyclerView, any added item decorations and the child margins
- * into account.
- *
- *
If the RecyclerView can be scrolled in either dimension the caller may
- * pass 0 as the widthUsed or heightUsed parameters as they will be irrelevant.
- *
- * @param child Child view to measure
- * @param widthUsed Width in pixels currently consumed by other views, if relevant
- * @param heightUsed Height in pixels currently consumed by other views, if relevant
- */
- public void measureChildWithMargins(@NonNull View child, int widthUsed, int heightUsed) {
- final LayoutParams lp = (LayoutParams) child.getLayoutParams();
-
- final Rect insets = mRecyclerView.getItemDecorInsetsForChild(child);
- widthUsed += insets.left + insets.right;
- heightUsed += insets.top + insets.bottom;
-
- final int widthSpec = getChildMeasureSpec(getWidth(), getWidthMode(),
- getPaddingLeft() + getPaddingRight()
- + lp.leftMargin + lp.rightMargin + widthUsed, lp.width,
- canScrollHorizontally());
- final int heightSpec = getChildMeasureSpec(getHeight(), getHeightMode(),
- getPaddingTop() + getPaddingBottom()
- + lp.topMargin + lp.bottomMargin + heightUsed, lp.height,
- canScrollVertically());
- if (shouldMeasureChild(child, widthSpec, heightSpec, lp)) {
- child.measure(widthSpec, heightSpec);
- }
- }
-
- /**
- * Calculate a MeasureSpec value for measuring a child view in one dimension.
- *
- * @param parentSize Size of the parent view where the child will be placed
- * @param padding Total space currently consumed by other elements of the parent
- * @param childDimension Desired size of the child view, or MATCH_PARENT/WRAP_CONTENT.
- * Generally obtained from the child view's LayoutParams
- * @param canScroll true if the parent RecyclerView can scroll in this dimension
- * @return a MeasureSpec value for the child view
- * @deprecated use {@link #getChildMeasureSpec(int, int, int, int, boolean)}
- */
- @Deprecated
- public static int getChildMeasureSpec(int parentSize, int padding, int childDimension,
- boolean canScroll) {
- int size = Math.max(0, parentSize - padding);
- int resultSize = 0;
- int resultMode = 0;
- if (canScroll) {
- if (childDimension >= 0) {
- resultSize = childDimension;
- resultMode = MeasureSpec.EXACTLY;
- } else {
- // MATCH_PARENT can't be applied since we can scroll in this dimension, wrap
- // instead using UNSPECIFIED.
- resultSize = 0;
- resultMode = MeasureSpec.UNSPECIFIED;
- }
- } else {
- if (childDimension >= 0) {
- resultSize = childDimension;
- resultMode = MeasureSpec.EXACTLY;
- } else if (childDimension == LayoutParams.MATCH_PARENT) {
- resultSize = size;
- // TODO this should be my spec.
- resultMode = MeasureSpec.EXACTLY;
- } else if (childDimension == LayoutParams.WRAP_CONTENT) {
- resultSize = size;
- resultMode = MeasureSpec.AT_MOST;
- }
- }
- return MeasureSpec.makeMeasureSpec(resultSize, resultMode);
- }
-
- /**
- * Calculate a MeasureSpec value for measuring a child view in one dimension.
- *
- * @param parentSize Size of the parent view where the child will be placed
- * @param parentMode The measurement spec mode of the parent
- * @param padding Total space currently consumed by other elements of parent
- * @param childDimension Desired size of the child view, or MATCH_PARENT/WRAP_CONTENT.
- * Generally obtained from the child view's LayoutParams
- * @param canScroll true if the parent RecyclerView can scroll in this dimension
- * @return a MeasureSpec value for the child view
- */
- public static int getChildMeasureSpec(int parentSize, int parentMode, int padding,
- int childDimension, boolean canScroll) {
- int size = Math.max(0, parentSize - padding);
- int resultSize = 0;
- int resultMode = 0;
- if (canScroll) {
- if (childDimension >= 0) {
- resultSize = childDimension;
- resultMode = MeasureSpec.EXACTLY;
- } else if (childDimension == LayoutParams.MATCH_PARENT) {
- switch (parentMode) {
- case MeasureSpec.AT_MOST:
- case MeasureSpec.EXACTLY:
- resultSize = size;
- resultMode = parentMode;
- break;
- case MeasureSpec.UNSPECIFIED:
- resultSize = 0;
- resultMode = MeasureSpec.UNSPECIFIED;
- break;
- }
- } else if (childDimension == LayoutParams.WRAP_CONTENT) {
- resultSize = 0;
- resultMode = MeasureSpec.UNSPECIFIED;
- }
- } else {
- if (childDimension >= 0) {
- resultSize = childDimension;
- resultMode = MeasureSpec.EXACTLY;
- } else if (childDimension == LayoutParams.MATCH_PARENT) {
- resultSize = size;
- resultMode = parentMode;
- } else if (childDimension == LayoutParams.WRAP_CONTENT) {
- resultSize = size;
- if (parentMode == MeasureSpec.AT_MOST || parentMode == MeasureSpec.EXACTLY) {
- resultMode = MeasureSpec.AT_MOST;
- } else {
- resultMode = MeasureSpec.UNSPECIFIED;
- }
-
- }
- }
- //noinspection WrongConstant
- return MeasureSpec.makeMeasureSpec(resultSize, resultMode);
- }
-
- /**
- * Returns the measured width of the given child, plus the additional size of
- * any insets applied by {@link ItemDecoration ItemDecorations}.
- *
- * @param child Child view to query
- * @return child's measured width plus ItemDecoration insets
- * @see View#getMeasuredWidth()
- */
- public int getDecoratedMeasuredWidth(@NonNull View child) {
- final Rect insets = ((LayoutParams) child.getLayoutParams()).mDecorInsets;
- return child.getMeasuredWidth() + insets.left + insets.right;
- }
-
- /**
- * Returns the measured height of the given child, plus the additional size of
- * any insets applied by {@link ItemDecoration ItemDecorations}.
- *
- * @param child Child view to query
- * @return child's measured height plus ItemDecoration insets
- * @see View#getMeasuredHeight()
- */
- public int getDecoratedMeasuredHeight(@NonNull View child) {
- final Rect insets = ((LayoutParams) child.getLayoutParams()).mDecorInsets;
- return child.getMeasuredHeight() + insets.top + insets.bottom;
- }
-
- /**
- * Lay out the given child view within the RecyclerView using coordinates that
- * include any current {@link ItemDecoration ItemDecorations}.
- *
- * LayoutManagers should prefer working in sizes and coordinates that include
- * item decoration insets whenever possible. This allows the LayoutManager to effectively
- * ignore decoration insets within measurement and layout code. See the following
- * methods:
- *
- * {@link #layoutDecoratedWithMargins(View, int, int, int, int)}
- * {@link #getDecoratedBoundsWithMargins(View, Rect)}
- * {@link #measureChild(View, int, int)}
- * {@link #measureChildWithMargins(View, int, int)}
- * {@link #getDecoratedLeft(View)}
- * {@link #getDecoratedTop(View)}
- * {@link #getDecoratedRight(View)}
- * {@link #getDecoratedBottom(View)}
- * {@link #getDecoratedMeasuredWidth(View)}
- * {@link #getDecoratedMeasuredHeight(View)}
- *
- *
- * @param child Child to lay out
- * @param left Left edge, with item decoration insets included
- * @param top Top edge, with item decoration insets included
- * @param right Right edge, with item decoration insets included
- * @param bottom Bottom edge, with item decoration insets included
- * @see View#layout(int, int, int, int)
- * @see #layoutDecoratedWithMargins(View, int, int, int, int)
- */
- public void layoutDecorated(@NonNull View child, int left, int top, int right, int bottom) {
- final Rect insets = ((LayoutParams) child.getLayoutParams()).mDecorInsets;
- child.layout(left + insets.left, top + insets.top, right - insets.right,
- bottom - insets.bottom);
- }
-
- /**
- * Lay out the given child view within the RecyclerView using coordinates that
- * include any current {@link ItemDecoration ItemDecorations} and margins.
- *
- * LayoutManagers should prefer working in sizes and coordinates that include
- * item decoration insets whenever possible. This allows the LayoutManager to effectively
- * ignore decoration insets within measurement and layout code. See the following
- * methods:
- *
- * {@link #layoutDecorated(View, int, int, int, int)}
- * {@link #measureChild(View, int, int)}
- * {@link #measureChildWithMargins(View, int, int)}
- * {@link #getDecoratedLeft(View)}
- * {@link #getDecoratedTop(View)}
- * {@link #getDecoratedRight(View)}
- * {@link #getDecoratedBottom(View)}
- * {@link #getDecoratedMeasuredWidth(View)}
- * {@link #getDecoratedMeasuredHeight(View)}
- *
- *
- * @param child Child to lay out
- * @param left Left edge, with item decoration insets and left margin included
- * @param top Top edge, with item decoration insets and top margin included
- * @param right Right edge, with item decoration insets and right margin included
- * @param bottom Bottom edge, with item decoration insets and bottom margin included
- * @see View#layout(int, int, int, int)
- * @see #layoutDecorated(View, int, int, int, int)
- */
- public void layoutDecoratedWithMargins(@NonNull View child, int left, int top, int right,
- int bottom) {
- final LayoutParams lp = (LayoutParams) child.getLayoutParams();
- final Rect insets = lp.mDecorInsets;
- child.layout(left + insets.left + lp.leftMargin, top + insets.top + lp.topMargin,
- right - insets.right - lp.rightMargin,
- bottom - insets.bottom - lp.bottomMargin);
- }
-
- /**
- * Calculates the bounding box of the View while taking into account its matrix changes
- * (translation, scale etc) with respect to the RecyclerView.
- *
- * If {@code includeDecorInsets} is {@code true}, they are applied first before applying
- * the View's matrix so that the decor offsets also go through the same transformation.
- *
- * @param child The ItemView whose bounding box should be calculated.
- * @param includeDecorInsets True if the decor insets should be included in the bounding box
- * @param out The rectangle into which the output will be written.
- */
- public void getTransformedBoundingBox(@NonNull View child, boolean includeDecorInsets,
- @NonNull Rect out) {
- if (includeDecorInsets) {
- Rect insets = ((LayoutParams) child.getLayoutParams()).mDecorInsets;
- out.set(-insets.left, -insets.top,
- child.getWidth() + insets.right, child.getHeight() + insets.bottom);
- } else {
- out.set(0, 0, child.getWidth(), child.getHeight());
- }
-
- if (mRecyclerView != null) {
- final Matrix childMatrix = child.getMatrix();
- if (childMatrix != null && !childMatrix.isIdentity()) {
- final RectF tempRectF = mRecyclerView.mTempRectF;
- tempRectF.set(out);
- childMatrix.mapRect(tempRectF);
- out.set(
- (int) Math.floor(tempRectF.left),
- (int) Math.floor(tempRectF.top),
- (int) Math.ceil(tempRectF.right),
- (int) Math.ceil(tempRectF.bottom)
- );
- }
- }
- out.offset(child.getLeft(), child.getTop());
- }
-
- /**
- * Returns the bounds of the view including its decoration and margins.
- *
- * @param view The view element to check
- * @param outBounds A rect that will receive the bounds of the element including its
- * decoration and margins.
- */
- public void getDecoratedBoundsWithMargins(@NonNull View view, @NonNull Rect outBounds) {
- RecyclerView.getDecoratedBoundsWithMarginsInt(view, outBounds);
- }
-
- /**
- * Returns the left edge of the given child view within its parent, offset by any applied
- * {@link ItemDecoration ItemDecorations}.
- *
- * @param child Child to query
- * @return Child left edge with offsets applied
- * @see #getLeftDecorationWidth(View)
- */
- public int getDecoratedLeft(@NonNull View child) {
- return child.getLeft() - getLeftDecorationWidth(child);
- }
-
- /**
- * Returns the top edge of the given child view within its parent, offset by any applied
- * {@link ItemDecoration ItemDecorations}.
- *
- * @param child Child to query
- * @return Child top edge with offsets applied
- * @see #getTopDecorationHeight(View)
- */
- public int getDecoratedTop(@NonNull View child) {
- return child.getTop() - getTopDecorationHeight(child);
- }
-
- /**
- * Returns the right edge of the given child view within its parent, offset by any applied
- * {@link ItemDecoration ItemDecorations}.
- *
- * @param child Child to query
- * @return Child right edge with offsets applied
- * @see #getRightDecorationWidth(View)
- */
- public int getDecoratedRight(@NonNull View child) {
- return child.getRight() + getRightDecorationWidth(child);
- }
-
- /**
- * Returns the bottom edge of the given child view within its parent, offset by any applied
- * {@link ItemDecoration ItemDecorations}.
- *
- * @param child Child to query
- * @return Child bottom edge with offsets applied
- * @see #getBottomDecorationHeight(View)
- */
- public int getDecoratedBottom(@NonNull View child) {
- return child.getBottom() + getBottomDecorationHeight(child);
- }
-
- /**
- * Calculates the item decor insets applied to the given child and updates the provided
- * Rect instance with the inset values.
- *
- * The Rect's left is set to the total width of left decorations.
- * The Rect's top is set to the total height of top decorations.
- * The Rect's right is set to the total width of right decorations.
- * The Rect's bottom is set to total height of bottom decorations.
- *
- *
- * Note that item decorations are automatically calculated when one of the LayoutManager's
- * measure child methods is called. If you need to measure the child with custom specs via
- * {@link View#measure(int, int)}, you can use this method to get decorations.
- *
- * @param child The child view whose decorations should be calculated
- * @param outRect The Rect to hold result values
- */
- public void calculateItemDecorationsForChild(@NonNull View child, @NonNull Rect outRect) {
- if (mRecyclerView == null) {
- outRect.set(0, 0, 0, 0);
- return;
- }
- Rect insets = mRecyclerView.getItemDecorInsetsForChild(child);
- outRect.set(insets);
- }
-
- /**
- * Returns the total height of item decorations applied to child's top.
- *
- * Note that this value is not updated until the View is measured or
- * {@link #calculateItemDecorationsForChild(View, Rect)} is called.
- *
- * @param child Child to query
- * @return The total height of item decorations applied to the child's top.
- * @see #getDecoratedTop(View)
- * @see #calculateItemDecorationsForChild(View, Rect)
- */
- public int getTopDecorationHeight(@NonNull View child) {
- return ((LayoutParams) child.getLayoutParams()).mDecorInsets.top;
- }
-
- /**
- * Returns the total height of item decorations applied to child's bottom.
- *
- * Note that this value is not updated until the View is measured or
- * {@link #calculateItemDecorationsForChild(View, Rect)} is called.
- *
- * @param child Child to query
- * @return The total height of item decorations applied to the child's bottom.
- * @see #getDecoratedBottom(View)
- * @see #calculateItemDecorationsForChild(View, Rect)
- */
- public int getBottomDecorationHeight(@NonNull View child) {
- return ((LayoutParams) child.getLayoutParams()).mDecorInsets.bottom;
- }
-
- /**
- * Returns the total width of item decorations applied to child's left.
- *
- * Note that this value is not updated until the View is measured or
- * {@link #calculateItemDecorationsForChild(View, Rect)} is called.
- *
- * @param child Child to query
- * @return The total width of item decorations applied to the child's left.
- * @see #getDecoratedLeft(View)
- * @see #calculateItemDecorationsForChild(View, Rect)
- */
- public int getLeftDecorationWidth(@NonNull View child) {
- return ((LayoutParams) child.getLayoutParams()).mDecorInsets.left;
- }
-
- /**
- * Returns the total width of item decorations applied to child's right.
- *
- * Note that this value is not updated until the View is measured or
- * {@link #calculateItemDecorationsForChild(View, Rect)} is called.
- *
- * @param child Child to query
- * @return The total width of item decorations applied to the child's right.
- * @see #getDecoratedRight(View)
- * @see #calculateItemDecorationsForChild(View, Rect)
- */
- public int getRightDecorationWidth(@NonNull View child) {
- return ((LayoutParams) child.getLayoutParams()).mDecorInsets.right;
- }
-
- /**
- * Called when searching for a focusable view in the given direction has failed
- * for the current content of the RecyclerView.
- *
- *
This is the LayoutManager's opportunity to populate views in the given direction
- * to fulfill the request if it can. The LayoutManager should attach and return
- * the view to be focused, if a focusable view in the given direction is found.
- * Otherwise, if all the existing (or the newly populated views) are unfocusable, it returns
- * the next unfocusable view to become visible on the screen. This unfocusable view is
- * typically the first view that's either partially or fully out of RV's padded bounded
- * area in the given direction. The default implementation returns null.
- *
- * @param focused The currently focused view
- * @param direction One of {@link View#FOCUS_UP}, {@link View#FOCUS_DOWN},
- * {@link View#FOCUS_LEFT}, {@link View#FOCUS_RIGHT},
- * {@link View#FOCUS_BACKWARD}, {@link View#FOCUS_FORWARD}
- * or 0 for not applicable
- * @param recycler The recycler to use for obtaining views for currently offscreen items
- * @param state Transient state of RecyclerView
- * @return The chosen view to be focused if a focusable view is found, otherwise an
- * unfocusable view to become visible onto the screen, else null.
- */
- @Nullable
- public View onFocusSearchFailed(@NonNull View focused, int direction,
- @NonNull Recycler recycler, @NonNull State state) {
- return null;
- }
-
- /**
- * This method gives a LayoutManager an opportunity to intercept the initial focus search
- * before the default behavior of {@link FocusFinder} is used. If this method returns
- * null FocusFinder will attempt to find a focusable child view. If it fails
- * then {@link #onFocusSearchFailed(View, int, RecyclerView.Recycler, RecyclerView.State)}
- * will be called to give the LayoutManager an opportunity to add new views for items
- * that did not have attached views representing them. The LayoutManager should not add
- * or remove views from this method.
- *
- * @param focused The currently focused view
- * @param direction One of {@link View#FOCUS_UP}, {@link View#FOCUS_DOWN},
- * {@link View#FOCUS_LEFT}, {@link View#FOCUS_RIGHT},
- * {@link View#FOCUS_BACKWARD}, {@link View#FOCUS_FORWARD}
- * @return A descendant view to focus or null to fall back to default behavior.
- * The default implementation returns null.
- */
- @Nullable
- public View onInterceptFocusSearch(@NonNull View focused, int direction) {
- return null;
- }
-
- /**
- * Returns the scroll amount that brings the given rect in child's coordinate system within
- * the padded area of RecyclerView.
- *
- * @param child The direct child making the request.
- * @param rect The rectangle in the child's coordinates the child
- * wishes to be on the screen.
- * @return The array containing the scroll amount in x and y directions that brings the
- * given rect into RV's padded area.
- */
- private int[] getChildRectangleOnScreenScrollAmount(View child, Rect rect) {
- int[] out = new int[2];
- final int parentLeft = getPaddingLeft();
- final int parentTop = getPaddingTop();
- final int parentRight = getWidth() - getPaddingRight();
- final int parentBottom = getHeight() - getPaddingBottom();
- final int childLeft = child.getLeft() + rect.left - child.getScrollX();
- final int childTop = child.getTop() + rect.top - child.getScrollY();
- final int childRight = childLeft + rect.width();
- final int childBottom = childTop + rect.height();
-
- final int offScreenLeft = Math.min(0, childLeft - parentLeft);
- final int offScreenTop = Math.min(0, childTop - parentTop);
- final int offScreenRight = Math.max(0, childRight - parentRight);
- final int offScreenBottom = Math.max(0, childBottom - parentBottom);
-
- // Favor the "start" layout direction over the end when bringing one side or the other
- // of a large rect into view. If we decide to bring in end because start is already
- // visible, limit the scroll such that start won't go out of bounds.
- final int dx;
- if (getLayoutDirection() == ViewCompat.LAYOUT_DIRECTION_RTL) {
- dx = offScreenRight != 0 ? offScreenRight
- : Math.max(offScreenLeft, childRight - parentRight);
- } else {
- dx = offScreenLeft != 0 ? offScreenLeft
- : Math.min(childLeft - parentLeft, offScreenRight);
- }
-
- // Favor bringing the top into view over the bottom. If top is already visible and
- // we should scroll to make bottom visible, make sure top does not go out of bounds.
- final int dy = offScreenTop != 0 ? offScreenTop
- : Math.min(childTop - parentTop, offScreenBottom);
- out[0] = dx;
- out[1] = dy;
- return out;
- }
-
- /**
- * Called when a child of the RecyclerView wants a particular rectangle to be positioned
- * onto the screen. See {@link ViewParent#requestChildRectangleOnScreen(android.view.View,
- * android.graphics.Rect, boolean)} for more details.
- *
- * The base implementation will attempt to perform a standard programmatic scroll
- * to bring the given rect into view, within the padded area of the RecyclerView.
- *
- * @param child The direct child making the request.
- * @param rect The rectangle in the child's coordinates the child
- * wishes to be on the screen.
- * @param immediate True to forbid animated or delayed scrolling,
- * false otherwise
- * @return Whether the group scrolled to handle the operation
- */
- public boolean requestChildRectangleOnScreen(@NonNull RecyclerView parent,
- @NonNull View child, @NonNull Rect rect, boolean immediate) {
- return requestChildRectangleOnScreen(parent, child, rect, immediate, false);
- }
-
- /**
- * Requests that the given child of the RecyclerView be positioned onto the screen. This
- * method can be called for both unfocusable and focusable child views. For unfocusable
- * child views, focusedChildVisible is typically true in which case, layout manager
- * makes the child view visible only if the currently focused child stays in-bounds of RV.
- *
- * @param parent The parent RecyclerView.
- * @param child The direct child making the request.
- * @param rect The rectangle in the child's coordinates the child
- * wishes to be on the screen.
- * @param immediate True to forbid animated or delayed scrolling,
- * false otherwise
- * @param focusedChildVisible Whether the currently focused view must stay visible.
- * @return Whether the group scrolled to handle the operation
- */
- public boolean requestChildRectangleOnScreen(@NonNull RecyclerView parent,
- @NonNull View child, @NonNull Rect rect, boolean immediate,
- boolean focusedChildVisible) {
- int[] scrollAmount = getChildRectangleOnScreenScrollAmount(child, rect
- );
- int dx = scrollAmount[0];
- int dy = scrollAmount[1];
- if (!focusedChildVisible || isFocusedChildVisibleAfterScrolling(parent, dx, dy)) {
- if (dx != 0 || dy != 0) {
- if (immediate) {
- parent.scrollBy(dx, dy);
- } else {
- parent.smoothScrollBy(dx, dy);
- }
- return true;
- }
- }
- return false;
- }
-
- /**
- * Returns whether the given child view is partially or fully visible within the padded
- * bounded area of RecyclerView, depending on the input parameters.
- * A view is partially visible if it has non-zero overlap with RV's padded bounded area.
- * If acceptEndPointInclusion flag is set to true, it's also considered partially
- * visible if it's located outside RV's bounds and it's hitting either RV's start or end
- * bounds.
- *
- * @param child The child view to be examined.
- * @param completelyVisible If true, the method returns true if and only if the
- * child is
- * completely visible. If false, the method returns true
- * if and
- * only if the child is only partially visible (that is it
- * will
- * return false if the child is either completely visible
- * or out
- * of RV's bounds).
- * @param acceptEndPointInclusion If the view's endpoint intersection with RV's start of end
- * bounds is enough to consider it partially visible,
- * false otherwise.
- * @return True if the given child is partially or fully visible, false otherwise.
- */
- public boolean isViewPartiallyVisible(@NonNull View child, boolean completelyVisible,
- boolean acceptEndPointInclusion) {
- int boundsFlag = (ViewBoundsCheck.FLAG_CVS_GT_PVS | ViewBoundsCheck.FLAG_CVS_EQ_PVS
- | ViewBoundsCheck.FLAG_CVE_LT_PVE | ViewBoundsCheck.FLAG_CVE_EQ_PVE);
- boolean isViewFullyVisible = mHorizontalBoundCheck.isViewWithinBoundFlags(child,
- boundsFlag)
- && mVerticalBoundCheck.isViewWithinBoundFlags(child, boundsFlag);
- if (completelyVisible) {
- return isViewFullyVisible;
- } else {
- return !isViewFullyVisible;
- }
- }
-
- /**
- * Returns whether the currently focused child stays within RV's bounds with the given
- * amount of scrolling.
- *
- * @param parent The parent RecyclerView.
- * @param dx The scrolling in x-axis direction to be performed.
- * @param dy The scrolling in y-axis direction to be performed.
- * @return {@code false} if the focused child is not at least partially visible after
- * scrolling or no focused child exists, {@code true} otherwise.
- */
- private boolean isFocusedChildVisibleAfterScrolling(RecyclerView parent, int dx, int dy) {
- final View focusedChild = parent.getFocusedChild();
- if (focusedChild == null) {
- return false;
- }
- final int parentLeft = getPaddingLeft();
- final int parentTop = getPaddingTop();
- final int parentRight = getWidth() - getPaddingRight();
- final int parentBottom = getHeight() - getPaddingBottom();
- final Rect bounds = mRecyclerView.mTempRect;
- getDecoratedBoundsWithMargins(focusedChild, bounds);
-
- if (bounds.left - dx >= parentRight || bounds.right - dx <= parentLeft
- || bounds.top - dy >= parentBottom || bounds.bottom - dy <= parentTop) {
- return false;
- }
- return true;
- }
-
- /**
- * @deprecated Use {@link #onRequestChildFocus(RecyclerView, State, View, View)}
- */
- @Deprecated
- public boolean onRequestChildFocus(@NonNull RecyclerView parent, @NonNull View child,
- @Nullable View focused) {
- // eat the request if we are in the middle of a scroll or layout
- return isSmoothScrolling() || parent.isComputingLayout();
- }
-
- /**
- * Called when a descendant view of the RecyclerView requests focus.
- *
- * A LayoutManager wishing to keep focused views aligned in a specific
- * portion of the view may implement that behavior in an override of this method.
- *
- * If the LayoutManager executes different behavior that should override the default
- * behavior of scrolling the focused child on screen instead of running alongside it,
- * this method should return true.
- *
- * @param parent The RecyclerView hosting this LayoutManager
- * @param state Current state of RecyclerView
- * @param child Direct child of the RecyclerView containing the newly focused view
- * @param focused The newly focused view. This may be the same view as child or it may be
- * null
- * @return true if the default scroll behavior should be suppressed
- */
- public boolean onRequestChildFocus(@NonNull RecyclerView parent, @NonNull State state,
- @NonNull View child, @Nullable View focused) {
- return onRequestChildFocus(parent, child, focused);
- }
-
- /**
- * Called if the RecyclerView this LayoutManager is bound to has a different adapter set via
- * {@link RecyclerView#setAdapter(Adapter)} or
- * {@link RecyclerView#swapAdapter(Adapter, boolean)}. The LayoutManager may use this
- * opportunity to clear caches and configure state such that it can relayout appropriately
- * with the new data and potentially new view types.
- *
- * The default implementation removes all currently attached views.
- *
- * @param oldAdapter The previous adapter instance. Will be null if there was previously no
- * adapter.
- * @param newAdapter The new adapter instance. Might be null if
- * {@link RecyclerView#setAdapter(RecyclerView.Adapter)} is called with
- * {@code null}.
- */
- public void onAdapterChanged(@Nullable Adapter oldAdapter, @Nullable Adapter newAdapter) {
- }
-
- /**
- * Called to populate focusable views within the RecyclerView.
- *
- * The LayoutManager implementation should return true if the default
- * behavior of {@link ViewGroup#addFocusables(java.util.ArrayList, int)} should be
- * suppressed.
- *
- * The default implementation returns false to trigger RecyclerView
- * to fall back to the default ViewGroup behavior.
- *
- * @param recyclerView The RecyclerView hosting this LayoutManager
- * @param views List of output views. This method should add valid focusable views
- * to this list.
- * @param direction One of {@link View#FOCUS_UP}, {@link View#FOCUS_DOWN},
- * {@link View#FOCUS_LEFT}, {@link View#FOCUS_RIGHT},
- * {@link View#FOCUS_BACKWARD}, {@link View#FOCUS_FORWARD}
- * @param focusableMode The type of focusables to be added.
- * @return true to suppress the default behavior, false to add default focusables after
- * this method returns.
- * @see #FOCUSABLES_ALL
- * @see #FOCUSABLES_TOUCH_MODE
- */
- public boolean onAddFocusables(@NonNull RecyclerView recyclerView,
- @NonNull ArrayList views, int direction, int focusableMode) {
- return false;
- }
-
- /**
- * Called in response to a call to {@link Adapter#notifyDataSetChanged()} or
- * {@link RecyclerView#swapAdapter(Adapter, boolean)} ()} and signals that the the entire
- * data set has changed.
- */
- public void onItemsChanged(@NonNull RecyclerView recyclerView) {
- }
-
- /**
- * Called when items have been added to the adapter. The LayoutManager may choose to
- * requestLayout if the inserted items would require refreshing the currently visible set
- * of child views. (e.g. currently empty space would be filled by appended items, etc.)
- */
- public void onItemsAdded(@NonNull RecyclerView recyclerView, int positionStart,
- int itemCount) {
- }
-
- /**
- * Called when items have been removed from the adapter.
- */
- public void onItemsRemoved(@NonNull RecyclerView recyclerView, int positionStart,
- int itemCount) {
- }
-
- /**
- * Called when items have been changed in the adapter.
- * To receive payload, override {@link #onItemsUpdated(RecyclerView, int, int, Object)}
- * instead, then this callback will not be invoked.
- */
- public void onItemsUpdated(@NonNull RecyclerView recyclerView, int positionStart,
- int itemCount) {
- }
-
- /**
- * Called when items have been changed in the adapter and with optional payload.
- * Default implementation calls {@link #onItemsUpdated(RecyclerView, int, int)}.
- */
- public void onItemsUpdated(@NonNull RecyclerView recyclerView, int positionStart,
- int itemCount, @Nullable Object payload) {
- onItemsUpdated(recyclerView, positionStart, itemCount);
- }
-
- /**
- * Called when an item is moved withing the adapter.
- *
- * Note that, an item may also change position in response to another ADD/REMOVE/MOVE
- * operation. This callback is only called if and only if {@link Adapter#notifyItemMoved}
- * is called.
- */
- public void onItemsMoved(@NonNull RecyclerView recyclerView, int from, int to,
- int itemCount) {
-
- }
-
-
- /**
- *
Override this method if you want to support scroll bars.
- *
- * Read {@link RecyclerView#computeHorizontalScrollExtent()} for details.
- *
- * Default implementation returns 0.
- *
- * @param state Current state of RecyclerView
- * @return The horizontal extent of the scrollbar's thumb
- * @see RecyclerView#computeHorizontalScrollExtent()
- */
- public int computeHorizontalScrollExtent(@NonNull State state) {
- return 0;
- }
-
- /**
- * Override this method if you want to support scroll bars.
- *
- * Read {@link RecyclerView#computeHorizontalScrollOffset()} for details.
- *
- * Default implementation returns 0.
- *
- * @param state Current State of RecyclerView where you can find total item count
- * @return The horizontal offset of the scrollbar's thumb
- * @see RecyclerView#computeHorizontalScrollOffset()
- */
- public int computeHorizontalScrollOffset(@NonNull State state) {
- return 0;
- }
-
- /**
- * Override this method if you want to support scroll bars.
- *
- * Read {@link RecyclerView#computeHorizontalScrollRange()} for details.
- *
- * Default implementation returns 0.
- *
- * @param state Current State of RecyclerView where you can find total item count
- * @return The total horizontal range represented by the vertical scrollbar
- * @see RecyclerView#computeHorizontalScrollRange()
- */
- public int computeHorizontalScrollRange(@NonNull State state) {
- return 0;
- }
-
- /**
- * Override this method if you want to support scroll bars.
- *
- * Read {@link RecyclerView#computeVerticalScrollExtent()} for details.
- *
- * Default implementation returns 0.
- *
- * @param state Current state of RecyclerView
- * @return The vertical extent of the scrollbar's thumb
- * @see RecyclerView#computeVerticalScrollExtent()
- */
- public int computeVerticalScrollExtent(@NonNull State state) {
- return 0;
- }
-
- /**
- * Override this method if you want to support scroll bars.
- *
- * Read {@link RecyclerView#computeVerticalScrollOffset()} for details.
- *
- * Default implementation returns 0.
- *
- * @param state Current State of RecyclerView where you can find total item count
- * @return The vertical offset of the scrollbar's thumb
- * @see RecyclerView#computeVerticalScrollOffset()
- */
- public int computeVerticalScrollOffset(@NonNull State state) {
- return 0;
- }
-
- /**
- * Override this method if you want to support scroll bars.
- *
- * Read {@link RecyclerView#computeVerticalScrollRange()} for details.
- *
- * Default implementation returns 0.
- *
- * @param state Current State of RecyclerView where you can find total item count
- * @return The total vertical range represented by the vertical scrollbar
- * @see RecyclerView#computeVerticalScrollRange()
- */
- public int computeVerticalScrollRange(@NonNull State state) {
- return 0;
- }
-
- /**
- * Measure the attached RecyclerView. Implementations must call
- * {@link #setMeasuredDimension(int, int)} before returning.
- *
- * It is strongly advised to use the AutoMeasure mechanism by overriding
- * {@link #isAutoMeasureEnabled()} to return true as AutoMeasure handles all the standard
- * measure cases including when the RecyclerView's layout_width or layout_height have been
- * set to wrap_content. If {@link #isAutoMeasureEnabled()} is overridden to return true,
- * this method should not be overridden.
- *
- * The default implementation will handle EXACTLY measurements and respect
- * the minimum width and height properties of the host RecyclerView if measured
- * as UNSPECIFIED. AT_MOST measurements will be treated as EXACTLY and the RecyclerView
- * will consume all available space.
- *
- * @param recycler Recycler
- * @param state Transient state of RecyclerView
- * @param widthSpec Width {@link android.view.View.MeasureSpec}
- * @param heightSpec Height {@link android.view.View.MeasureSpec}
- * @see #isAutoMeasureEnabled()
- * @see #setMeasuredDimension(int, int)
- */
- public void onMeasure(@NonNull Recycler recycler, @NonNull State state, int widthSpec,
- int heightSpec) {
- mRecyclerView.defaultOnMeasure(widthSpec, heightSpec);
- }
-
- /**
- * {@link View#setMeasuredDimension(int, int) Set the measured dimensions} of the
- * host RecyclerView.
- *
- * @param widthSize Measured width
- * @param heightSize Measured height
- */
- public void setMeasuredDimension(int widthSize, int heightSize) {
- mRecyclerView.setMeasuredDimension(widthSize, heightSize);
- }
-
- /**
- * @return The host RecyclerView's {@link View#getMinimumWidth()}
- */
- @Px
- public int getMinimumWidth() {
- return ViewCompat.getMinimumWidth(mRecyclerView);
- }
-
- /**
- * @return The host RecyclerView's {@link View#getMinimumHeight()}
- */
- @Px
- public int getMinimumHeight() {
- return ViewCompat.getMinimumHeight(mRecyclerView);
- }
-
- /**
- *
Called when the LayoutManager should save its state. This is a good time to save your
- * scroll position, configuration and anything else that may be required to restore the same
- * layout state if the LayoutManager is recreated.
- * RecyclerView does NOT verify if the LayoutManager has changed between state save and
- * restore. This will let you share information between your LayoutManagers but it is also
- * your responsibility to make sure they use the same parcelable class.
- *
- * @return Necessary information for LayoutManager to be able to restore its state
- */
- @Nullable
- public Parcelable onSaveInstanceState() {
- return null;
- }
-
- /**
- * Called when the RecyclerView is ready to restore the state based on a previous
- * RecyclerView.
- *
- * Notice that this might happen after an actual layout, based on how Adapter prefers to
- * restore State. See {@link Adapter#getStateRestorationPolicy()} for more information.
- *
- * @param state The parcelable that was returned by the previous LayoutManager's
- * {@link #onSaveInstanceState()} method.
- */
- @SuppressLint("UnknownNullness") // b/240775049: Cannot annotate properly
- public void onRestoreInstanceState(Parcelable state) {
-
- }
-
- void stopSmoothScroller() {
- if (mSmoothScroller != null) {
- mSmoothScroller.stop();
- }
- }
-
- void onSmoothScrollerStopped(SmoothScroller smoothScroller) {
- if (mSmoothScroller == smoothScroller) {
- mSmoothScroller = null;
- }
- }
-
- /**
- * RecyclerView calls this method to notify LayoutManager that scroll state has changed.
- *
- * @param state The new scroll state for RecyclerView
- */
- public void onScrollStateChanged(int state) {
- }
-
- /**
- * Removes all views and recycles them using the given recycler.
- *
- * If you want to clean cached views as well, you should call {@link Recycler#clear()} too.
- *
- * If a View is marked as "ignored", it is not removed nor recycled.
- *
- * @param recycler Recycler to use to recycle children
- * @see #removeAndRecycleView(View, Recycler)
- * @see #removeAndRecycleViewAt(int, Recycler)
- * @see #ignoreView(View)
- */
- public void removeAndRecycleAllViews(@NonNull Recycler recycler) {
- for (int i = getChildCount() - 1; i >= 0; i--) {
- final View view = getChildAt(i);
- if (!getChildViewHolderInt(view).shouldIgnore()) {
- removeAndRecycleViewAt(i, recycler);
- }
- }
- }
-
- // called by accessibility delegate
- void onInitializeAccessibilityNodeInfo(AccessibilityNodeInfoCompat info) {
- onInitializeAccessibilityNodeInfo(mRecyclerView.mRecycler, mRecyclerView.mState, info);
- }
-
- /**
- * Called by the AccessibilityDelegate when the information about the current layout should
- * be populated.
- *
- * Default implementation adds a {@link
- * androidx.core.view.accessibility.AccessibilityNodeInfoCompat.CollectionInfoCompat}.
- *
- * You should override
- * {@link #getRowCountForAccessibility(RecyclerView.Recycler, RecyclerView.State)},
- * {@link #getColumnCountForAccessibility(RecyclerView.Recycler, RecyclerView.State)},
- * {@link #isLayoutHierarchical(RecyclerView.Recycler, RecyclerView.State)} and
- * {@link #getSelectionModeForAccessibility(RecyclerView.Recycler, RecyclerView.State)} for
- * more accurate accessibility information.
- *
- * @param recycler The Recycler that can be used to convert view positions into adapter
- * positions
- * @param state The current state of RecyclerView
- * @param info The info that should be filled by the LayoutManager
- * @see View#onInitializeAccessibilityNodeInfo(
- *android.view.accessibility.AccessibilityNodeInfo)
- * @see #getRowCountForAccessibility(RecyclerView.Recycler, RecyclerView.State)
- * @see #getColumnCountForAccessibility(RecyclerView.Recycler, RecyclerView.State)
- * @see #isLayoutHierarchical(RecyclerView.Recycler, RecyclerView.State)
- * @see #getSelectionModeForAccessibility(RecyclerView.Recycler, RecyclerView.State)
- */
- public void onInitializeAccessibilityNodeInfo(@NonNull Recycler recycler,
- @NonNull State state, @NonNull AccessibilityNodeInfoCompat info) {
- if (mRecyclerView.canScrollVertically(-1) || mRecyclerView.canScrollHorizontally(-1)) {
- info.addAction(AccessibilityNodeInfoCompat.ACTION_SCROLL_BACKWARD);
- info.setScrollable(true);
- }
- if (mRecyclerView.canScrollVertically(1) || mRecyclerView.canScrollHorizontally(1)) {
- info.addAction(AccessibilityNodeInfoCompat.ACTION_SCROLL_FORWARD);
- info.setScrollable(true);
- }
- final AccessibilityNodeInfoCompat.CollectionInfoCompat collectionInfo =
- AccessibilityNodeInfoCompat.CollectionInfoCompat
- .obtain(getRowCountForAccessibility(recycler, state),
- getColumnCountForAccessibility(recycler, state),
- isLayoutHierarchical(recycler, state),
- getSelectionModeForAccessibility(recycler, state));
- info.setCollectionInfo(collectionInfo);
- }
-
- // called by accessibility delegate
- public void onInitializeAccessibilityEvent(@NonNull AccessibilityEvent event) {
- onInitializeAccessibilityEvent(mRecyclerView.mRecycler, mRecyclerView.mState, event);
- }
-
- /**
- * Called by the accessibility delegate to initialize an accessibility event.
- *
- * Default implementation adds item count and scroll information to the event.
- *
- * @param recycler The Recycler that can be used to convert view positions into adapter
- * positions
- * @param state The current state of RecyclerView
- * @param event The event instance to initialize
- * @see View#onInitializeAccessibilityEvent(android.view.accessibility.AccessibilityEvent)
- */
- public void onInitializeAccessibilityEvent(@NonNull Recycler recycler, @NonNull State state,
- @NonNull AccessibilityEvent event) {
- if (mRecyclerView == null || event == null) {
- return;
- }
- event.setScrollable(mRecyclerView.canScrollVertically(1)
- || mRecyclerView.canScrollVertically(-1)
- || mRecyclerView.canScrollHorizontally(-1)
- || mRecyclerView.canScrollHorizontally(1));
-
- if (mRecyclerView.mAdapter != null) {
- event.setItemCount(mRecyclerView.mAdapter.getItemCount());
- }
- }
-
- // called by accessibility delegate
- void onInitializeAccessibilityNodeInfoForItem(View host, AccessibilityNodeInfoCompat info) {
- final ViewHolder vh = getChildViewHolderInt(host);
- // avoid trying to create accessibility node info for removed children
- if (vh != null && !vh.isRemoved() && !mChildHelper.isHidden(vh.itemView)) {
- onInitializeAccessibilityNodeInfoForItem(mRecyclerView.mRecycler,
- mRecyclerView.mState, host, info);
- }
- }
-
- /**
- * Called by the AccessibilityDelegate when the accessibility information for a specific
- * item should be populated.
- *
- * Default implementation adds basic positioning information about the item.
- *
- * @param recycler The Recycler that can be used to convert view positions into adapter
- * positions
- * @param state The current state of RecyclerView
- * @param host The child for which accessibility node info should be populated
- * @param info The info to fill out about the item
- * @see android.widget.AbsListView#onInitializeAccessibilityNodeInfoForItem(View, int,
- * android.view.accessibility.AccessibilityNodeInfo)
- */
- public void onInitializeAccessibilityNodeInfoForItem(@NonNull Recycler recycler,
- @NonNull State state, @NonNull View host,
- @NonNull AccessibilityNodeInfoCompat info) {
- }
-
- /**
- * A LayoutManager can call this method to force RecyclerView to run simple animations in
- * the next layout pass, even if there is not any trigger to do so. (e.g. adapter data
- * change).
- *
- * Note that, calling this method will not guarantee that RecyclerView will run animations
- * at all. For example, if there is not any {@link ItemAnimator} set, RecyclerView will
- * not run any animations but will still clear this flag after the layout is complete.
- */
- public void requestSimpleAnimationsInNextLayout() {
- mRequestedSimpleAnimations = true;
- }
-
- /**
- * Returns the selection mode for accessibility. Should be
- * {@link AccessibilityNodeInfoCompat.CollectionInfoCompat#SELECTION_MODE_NONE},
- * {@link AccessibilityNodeInfoCompat.CollectionInfoCompat#SELECTION_MODE_SINGLE} or
- * {@link AccessibilityNodeInfoCompat.CollectionInfoCompat#SELECTION_MODE_MULTIPLE}.
- *
- * Default implementation returns
- * {@link AccessibilityNodeInfoCompat.CollectionInfoCompat#SELECTION_MODE_NONE}.
- *
- * @param recycler The Recycler that can be used to convert view positions into adapter
- * positions
- * @param state The current state of RecyclerView
- * @return Selection mode for accessibility. Default implementation returns
- * {@link AccessibilityNodeInfoCompat.CollectionInfoCompat#SELECTION_MODE_NONE}.
- */
- public int getSelectionModeForAccessibility(@NonNull Recycler recycler,
- @NonNull State state) {
- return AccessibilityNodeInfoCompat.CollectionInfoCompat.SELECTION_MODE_NONE;
- }
-
- /**
- * Returns the number of rows for accessibility.
- *
- * Default implementation returns the number of items in the adapter if LayoutManager
- * supports vertical scrolling or 1 if LayoutManager does not support vertical
- * scrolling.
- *
- * @param recycler The Recycler that can be used to convert view positions into adapter
- * positions
- * @param state The current state of RecyclerView
- * @return The number of rows in LayoutManager for accessibility.
- */
- public int getRowCountForAccessibility(@NonNull Recycler recycler, @NonNull State state) {
- return -1;
- }
-
- /**
- * Returns the number of columns for accessibility.
- *
- * Default implementation returns the number of items in the adapter if LayoutManager
- * supports horizontal scrolling or 1 if LayoutManager does not support horizontal
- * scrolling.
- *
- * @param recycler The Recycler that can be used to convert view positions into adapter
- * positions
- * @param state The current state of RecyclerView
- * @return The number of rows in LayoutManager for accessibility.
- */
- public int getColumnCountForAccessibility(@NonNull Recycler recycler,
- @NonNull State state) {
- return -1;
- }
-
- /**
- * Returns whether layout is hierarchical or not to be used for accessibility.
- *
- * Default implementation returns false.
- *
- * @param recycler The Recycler that can be used to convert view positions into adapter
- * positions
- * @param state The current state of RecyclerView
- * @return True if layout is hierarchical.
- */
- public boolean isLayoutHierarchical(@NonNull Recycler recycler, @NonNull State state) {
- return false;
- }
-
- // called by accessibility delegate
- boolean performAccessibilityAction(int action, @Nullable Bundle args) {
- return performAccessibilityAction(mRecyclerView.mRecycler, mRecyclerView.mState,
- action, args);
- }
-
- /**
- * Called by AccessibilityDelegate when an action is requested from the RecyclerView.
- *
- * @param recycler The Recycler that can be used to convert view positions into adapter
- * positions
- * @param state The current state of RecyclerView
- * @param action The action to perform
- * @param args Optional action arguments
- * @see View#performAccessibilityAction(int, android.os.Bundle)
- */
- public boolean performAccessibilityAction(@NonNull Recycler recycler, @NonNull State state,
- int action, @Nullable Bundle args) {
- if (mRecyclerView == null) {
- return false;
- }
- int vScroll = 0, hScroll = 0;
- int height = getHeight();
- int width = getWidth();
- Rect rect = new Rect();
- // Gets the visible rect on the screen except for the rotation or scale cases which
- // might affect the result.
- if (mRecyclerView.getMatrix().isIdentity() && mRecyclerView.getGlobalVisibleRect(
- rect)) {
- height = rect.height();
- width = rect.width();
- }
- switch (action) {
- case AccessibilityNodeInfoCompat.ACTION_SCROLL_BACKWARD:
- if (mRecyclerView.canScrollVertically(-1)) {
- vScroll = -(height - getPaddingTop() - getPaddingBottom());
- }
- if (mRecyclerView.canScrollHorizontally(-1)) {
- hScroll = -(width - getPaddingLeft() - getPaddingRight());
- }
- break;
- case AccessibilityNodeInfoCompat.ACTION_SCROLL_FORWARD:
- if (mRecyclerView.canScrollVertically(1)) {
- vScroll = height - getPaddingTop() - getPaddingBottom();
- }
- if (mRecyclerView.canScrollHorizontally(1)) {
- hScroll = width - getPaddingLeft() - getPaddingRight();
- }
- break;
- }
- if (vScroll == 0 && hScroll == 0) {
- return false;
- }
- mRecyclerView.smoothScrollBy(hScroll, vScroll, null, UNDEFINED_DURATION, true);
- return true;
- }
-
- // called by accessibility delegate
- boolean performAccessibilityActionForItem(@NonNull View view, int action,
- @Nullable Bundle args) {
- return performAccessibilityActionForItem(mRecyclerView.mRecycler, mRecyclerView.mState,
- view, action, args);
- }
-
- /**
- * Called by AccessibilityDelegate when an accessibility action is requested on one of the
- * children of LayoutManager.
- *
- * Default implementation does not do anything.
- *
- * @param recycler The Recycler that can be used to convert view positions into adapter
- * positions
- * @param state The current state of RecyclerView
- * @param view The child view on which the action is performed
- * @param action The action to perform
- * @param args Optional action arguments
- * @return true if action is handled
- * @see View#performAccessibilityAction(int, android.os.Bundle)
- */
- public boolean performAccessibilityActionForItem(@NonNull Recycler recycler,
- @NonNull State state, @NonNull View view, int action, @Nullable Bundle args) {
- return false;
- }
-
- /**
- * Parse the xml attributes to get the most common properties used by layout managers.
- *
- * {@link android.R.attr#orientation}
- * {@link androidx.recyclerview.R.attr#spanCount}
- * {@link androidx.recyclerview.R.attr#reverseLayout}
- * {@link androidx.recyclerview.R.attr#stackFromEnd}
- *
- * @return an object containing the properties as specified in the attrs.
- */
- public static Properties getProperties(@NonNull Context context,
- @Nullable AttributeSet attrs,
- int defStyleAttr, int defStyleRes) {
- Properties properties = new Properties();
- TypedArray a = context.obtainStyledAttributes(attrs, R.styleable.RecyclerView,
- defStyleAttr, defStyleRes);
- properties.orientation = a.getInt(R.styleable.RecyclerView_android_orientation,
- DEFAULT_ORIENTATION);
- properties.spanCount = a.getInt(R.styleable.RecyclerView_spanCount, 1);
- properties.reverseLayout = a.getBoolean(R.styleable.RecyclerView_reverseLayout, false);
- properties.stackFromEnd = a.getBoolean(R.styleable.RecyclerView_stackFromEnd, false);
- a.recycle();
- return properties;
- }
-
- void setExactMeasureSpecsFrom(RecyclerView recyclerView) {
- setMeasureSpecs(
- MeasureSpec.makeMeasureSpec(recyclerView.getWidth(), MeasureSpec.EXACTLY),
- MeasureSpec.makeMeasureSpec(recyclerView.getHeight(), MeasureSpec.EXACTLY)
- );
- }
-
- /**
- * Internal API to allow LayoutManagers to be measured twice.
- *
- * This is not public because LayoutManagers should be able to handle their layouts in one
- * pass but it is very convenient to make existing LayoutManagers support wrapping content
- * when both orientations are undefined.
- *
- * This API will be removed after default LayoutManagers properly implement wrap content in
- * non-scroll orientation.
- */
- boolean shouldMeasureTwice() {
- return false;
- }
-
- boolean hasFlexibleChildInBothOrientations() {
- final int childCount = getChildCount();
- for (int i = 0; i < childCount; i++) {
- final View child = getChildAt(i);
- final ViewGroup.LayoutParams lp = child.getLayoutParams();
- if (lp.width < 0 && lp.height < 0) {
- return true;
- }
- }
- return false;
- }
-
- /**
- * Some general properties that a LayoutManager may want to use.
- */
- public static class Properties {
- /** {@link android.R.attr#orientation} */
- public int orientation;
- /** {@link androidx.recyclerview.R.attr#spanCount} */
- public int spanCount;
- /** {@link androidx.recyclerview.R.attr#reverseLayout} */
- public boolean reverseLayout;
- /** {@link androidx.recyclerview.R.attr#stackFromEnd} */
- public boolean stackFromEnd;
- }
- }
-
- /**
- * An ItemDecoration allows the application to add a special drawing and layout offset
- * to specific item views from the adapter's data set. This can be useful for drawing dividers
- * between items, highlights, visual grouping boundaries and more.
- *
- *
All ItemDecorations are drawn in the order they were added, before the item
- * views (in {@link ItemDecoration#onDraw(Canvas, RecyclerView, RecyclerView.State) onDraw()}
- * and after the items (in {@link ItemDecoration#onDrawOver(Canvas, RecyclerView,
- * RecyclerView.State)}.
- */
- public abstract static class ItemDecoration {
- /**
- * Draw any appropriate decorations into the Canvas supplied to the RecyclerView.
- * Any content drawn by this method will be drawn before the item views are drawn,
- * and will thus appear underneath the views.
- *
- * @param c Canvas to draw into
- * @param parent RecyclerView this ItemDecoration is drawing into
- * @param state The current state of RecyclerView
- */
- public void onDraw(@NonNull Canvas c, @NonNull RecyclerView parent, @NonNull State state) {
- onDraw(c, parent);
- }
-
- /**
- * @deprecated Override {@link #onDraw(Canvas, RecyclerView, RecyclerView.State)}
- */
- @Deprecated
- public void onDraw(@NonNull Canvas c, @NonNull RecyclerView parent) {
- }
-
- /**
- * Draw any appropriate decorations into the Canvas supplied to the RecyclerView.
- * Any content drawn by this method will be drawn after the item views are drawn
- * and will thus appear over the views.
- *
- * @param c Canvas to draw into
- * @param parent RecyclerView this ItemDecoration is drawing into
- * @param state The current state of RecyclerView.
- */
- public void onDrawOver(@NonNull Canvas c, @NonNull RecyclerView parent,
- @NonNull State state) {
- onDrawOver(c, parent);
- }
-
- /**
- * @deprecated Override {@link #onDrawOver(Canvas, RecyclerView, RecyclerView.State)}
- */
- @Deprecated
- public void onDrawOver(@NonNull Canvas c, @NonNull RecyclerView parent) {
- }
-
-
- /**
- * @deprecated Use {@link #getItemOffsets(Rect, View, RecyclerView, State)}
- */
- @Deprecated
- public void getItemOffsets(@NonNull Rect outRect, int itemPosition,
- @NonNull RecyclerView parent) {
- outRect.set(0, 0, 0, 0);
- }
-
- /**
- * Retrieve any offsets for the given item. Each field of outRect specifies
- * the number of pixels that the item view should be inset by, similar to padding or margin.
- * The default implementation sets the bounds of outRect to 0 and returns.
- *
- *
- * If this ItemDecoration does not affect the positioning of item views, it should set
- * all four fields of outRect (left, top, right, bottom) to zero
- * before returning.
- *
- *
- * If you need to access Adapter for additional data, you can call
- * {@link RecyclerView#getChildAdapterPosition(View)} to get the adapter position of the
- * View.
- *
- * @param outRect Rect to receive the output.
- * @param view The child view to decorate
- * @param parent RecyclerView this ItemDecoration is decorating
- * @param state The current state of RecyclerView.
- */
- public void getItemOffsets(@NonNull Rect outRect, @NonNull View view,
- @NonNull RecyclerView parent, @NonNull State state) {
- getItemOffsets(outRect, ((LayoutParams) view.getLayoutParams()).getViewLayoutPosition(),
- parent);
- }
- }
-
- /**
- * An OnItemTouchListener allows the application to intercept touch events in progress at the
- * view hierarchy level of the RecyclerView before those touch events are considered for
- * RecyclerView's own scrolling behavior.
- *
- *
This can be useful for applications that wish to implement various forms of gestural
- * manipulation of item views within the RecyclerView. OnItemTouchListeners may intercept
- * a touch interaction already in progress even if the RecyclerView is already handling that
- * gesture stream itself for the purposes of scrolling.
- *
- * @see SimpleOnItemTouchListener
- */
- public interface OnItemTouchListener {
- /**
- * Silently observe and/or take over touch events sent to the RecyclerView
- * before they are handled by either the RecyclerView itself or its child views.
- *
- * The onInterceptTouchEvent methods of each attached OnItemTouchListener will be run
- * in the order in which each listener was added, before any other touch processing
- * by the RecyclerView itself or child views occurs.
- *
- * @param e MotionEvent describing the touch event. All coordinates are in
- * the RecyclerView's coordinate system.
- * @return true if this OnItemTouchListener wishes to begin intercepting touch events, false
- * to continue with the current behavior and continue observing future events in
- * the gesture.
- */
- boolean onInterceptTouchEvent(@NonNull RecyclerView rv, @NonNull MotionEvent e);
-
- /**
- * Process a touch event as part of a gesture that was claimed by returning true from
- * a previous call to {@link #onInterceptTouchEvent}.
- *
- * @param e MotionEvent describing the touch event. All coordinates are in
- * the RecyclerView's coordinate system.
- */
- void onTouchEvent(@NonNull RecyclerView rv, @NonNull MotionEvent e);
-
- /**
- * Called when a child of RecyclerView does not want RecyclerView and its ancestors to
- * intercept touch events with
- * {@link ViewGroup#onInterceptTouchEvent(MotionEvent)}.
- *
- * @param disallowIntercept True if the child does not want the parent to
- * intercept touch events.
- * @see ViewParent#requestDisallowInterceptTouchEvent(boolean)
- */
- void onRequestDisallowInterceptTouchEvent(boolean disallowIntercept);
- }
-
- /**
- * An implementation of {@link RecyclerView.OnItemTouchListener} that has empty method bodies
- * and default return values.
- *
- * You may prefer to extend this class if you don't need to override all methods. Another
- * benefit of using this class is future compatibility. As the interface may change, we'll
- * always provide a default implementation on this class so that your code won't break when
- * you update to a new version of the support library.
- */
- public static class SimpleOnItemTouchListener implements RecyclerView.OnItemTouchListener {
- @Override
- public boolean onInterceptTouchEvent(@NonNull RecyclerView rv, @NonNull MotionEvent e) {
- return false;
- }
-
- @Override
- public void onTouchEvent(@NonNull RecyclerView rv, @NonNull MotionEvent e) {
- }
-
- @Override
- public void onRequestDisallowInterceptTouchEvent(boolean disallowIntercept) {
- }
- }
-
-
- /**
- * An OnScrollListener can be added to a RecyclerView to receive messages when a scrolling event
- * has occurred on that RecyclerView.
- *
- *
- * @see RecyclerView#addOnScrollListener(OnScrollListener)
- * @see RecyclerView#clearOnChildAttachStateChangeListeners()
- */
- public abstract static class OnScrollListener {
- /**
- * Callback method to be invoked when RecyclerView's scroll state changes.
- *
- * @param recyclerView The RecyclerView whose scroll state has changed.
- * @param newState The updated scroll state. One of {@link #SCROLL_STATE_IDLE},
- * {@link #SCROLL_STATE_DRAGGING} or {@link #SCROLL_STATE_SETTLING}.
- */
- public void onScrollStateChanged(@NonNull RecyclerView recyclerView, int newState) {
- }
-
- /**
- * Callback method to be invoked when the RecyclerView has been scrolled. This will be
- * called after the scroll has completed.
- *
- * This callback will also be called if visible item range changes after a layout
- * calculation. In that case, dx and dy will be 0.
- *
- * @param recyclerView The RecyclerView which scrolled.
- * @param dx The amount of horizontal scroll.
- * @param dy The amount of vertical scroll.
- */
- public void onScrolled(@NonNull RecyclerView recyclerView, int dx, int dy) {
- }
- }
-
- /**
- * A RecyclerListener can be set on a RecyclerView to receive messages whenever
- * a view is recycled.
- *
- * @see RecyclerView#setRecyclerListener(RecyclerListener)
- */
- public interface RecyclerListener {
-
- /**
- * This method is called whenever the view in the ViewHolder is recycled.
- *
- * RecyclerView calls this method right before clearing ViewHolder's internal data and
- * sending it to RecycledViewPool. This way, if ViewHolder was holding valid information
- * before being recycled, you can call {@link ViewHolder#getBindingAdapterPosition()} to get
- * its adapter position.
- *
- * @param holder The ViewHolder containing the view that was recycled
- */
- void onViewRecycled(@NonNull ViewHolder holder);
- }
-
- /**
- * A Listener interface that can be attached to a RecylcerView to get notified
- * whenever a ViewHolder is attached to or detached from RecyclerView.
- */
- public interface OnChildAttachStateChangeListener {
-
- /**
- * Called when a view is attached to the RecyclerView.
- *
- * @param view The View which is attached to the RecyclerView
- */
- void onChildViewAttachedToWindow(@NonNull View view);
-
- /**
- * Called when a view is detached from RecyclerView.
- *
- * @param view The View which is being detached from the RecyclerView
- */
- void onChildViewDetachedFromWindow(@NonNull View view);
- }
-
- /**
- * A ViewHolder describes an item view and metadata about its place within the RecyclerView.
- *
- *
{@link Adapter} implementations should subclass ViewHolder and add fields for caching
- * potentially expensive {@link View#findViewById(int)} results.
- *
- * While {@link LayoutParams} belong to the {@link LayoutManager},
- * {@link ViewHolder ViewHolders} belong to the adapter. Adapters should feel free to use
- * their own custom ViewHolder implementations to store data that makes binding view contents
- * easier. Implementations should assume that individual item views will hold strong references
- * to ViewHolder objects and that RecyclerView instances may hold
- * strong references to extra off-screen item views for caching purposes
- */
- public abstract static class ViewHolder {
- @NonNull
- public final View itemView;
- WeakReference mNestedRecyclerView;
- int mPosition = NO_POSITION;
- int mOldPosition = NO_POSITION;
- long mItemId = NO_ID;
- int mItemViewType = INVALID_TYPE;
- int mPreLayoutPosition = NO_POSITION;
-
- // The item that this holder is shadowing during an item change event/animation
- ViewHolder mShadowedHolder = null;
- // The item that is shadowing this holder during an item change event/animation
- ViewHolder mShadowingHolder = null;
-
- /**
- * This ViewHolder has been bound to a position; mPosition, mItemId and mItemViewType
- * are all valid.
- */
- static final int FLAG_BOUND = 1 << 0;
-
- /**
- * The data this ViewHolder's view reflects is stale and needs to be rebound
- * by the adapter. mPosition and mItemId are consistent.
- */
- static final int FLAG_UPDATE = 1 << 1;
-
- /**
- * This ViewHolder's data is invalid. The identity implied by mPosition and mItemId
- * are not to be trusted and may no longer match the item view type.
- * This ViewHolder must be fully rebound to different data.
- */
- static final int FLAG_INVALID = 1 << 2;
-
- /**
- * This ViewHolder points at data that represents an item previously removed from the
- * data set. Its view may still be used for things like outgoing animations.
- */
- static final int FLAG_REMOVED = 1 << 3;
-
- /**
- * This ViewHolder should not be recycled. This flag is set via setIsRecyclable()
- * and is intended to keep views around during animations.
- */
- static final int FLAG_NOT_RECYCLABLE = 1 << 4;
-
- /**
- * This ViewHolder is returned from scrap which means we are expecting an addView call
- * for this itemView. When returned from scrap, ViewHolder stays in the scrap list until
- * the end of the layout pass and then recycled by RecyclerView if it is not added back to
- * the RecyclerView.
- */
- static final int FLAG_RETURNED_FROM_SCRAP = 1 << 5;
-
- /**
- * This ViewHolder is fully managed by the LayoutManager. We do not scrap, recycle or remove
- * it unless LayoutManager is replaced.
- * It is still fully visible to the LayoutManager.
- */
- static final int FLAG_IGNORE = 1 << 7;
-
- /**
- * When the View is detached form the parent, we set this flag so that we can take correct
- * action when we need to remove it or add it back.
- */
- static final int FLAG_TMP_DETACHED = 1 << 8;
-
- /**
- * Set when we can no longer determine the adapter position of this ViewHolder until it is
- * rebound to a new position. It is different than FLAG_INVALID because FLAG_INVALID is
- * set even when the type does not match. Also, FLAG_ADAPTER_POSITION_UNKNOWN is set as soon
- * as adapter notification arrives vs FLAG_INVALID is set lazily before layout is
- * re-calculated.
- */
- static final int FLAG_ADAPTER_POSITION_UNKNOWN = 1 << 9;
-
- /**
- * Set when a addChangePayload(null) is called
- */
- static final int FLAG_ADAPTER_FULLUPDATE = 1 << 10;
-
- /**
- * Used by ItemAnimator when a ViewHolder's position changes
- */
- static final int FLAG_MOVED = 1 << 11;
-
- /**
- * Used by ItemAnimator when a ViewHolder appears in pre-layout
- */
- static final int FLAG_APPEARED_IN_PRE_LAYOUT = 1 << 12;
-
- static final int PENDING_ACCESSIBILITY_STATE_NOT_SET = -1;
-
- /**
- * Used when a ViewHolder starts the layout pass as a hidden ViewHolder but is re-used from
- * hidden list (as if it was scrap) without being recycled in between.
- *
- * When a ViewHolder is hidden, there are 2 paths it can be re-used:
- * a) Animation ends, view is recycled and used from the recycle pool.
- * b) LayoutManager asks for the View for that position while the ViewHolder is hidden.
- *
- * This flag is used to represent "case b" where the ViewHolder is reused without being
- * recycled (thus "bounced" from the hidden list). This state requires special handling
- * because the ViewHolder must be added to pre layout maps for animations as if it was
- * already there.
- */
- static final int FLAG_BOUNCED_FROM_HIDDEN_LIST = 1 << 13;
-
- int mFlags;
-
- private static final List FULLUPDATE_PAYLOADS = Collections.emptyList();
-
- List mPayloads = null;
- List mUnmodifiedPayloads = null;
-
- private int mIsRecyclableCount = 0;
-
- // If non-null, view is currently considered scrap and may be reused for other data by the
- // scrap container.
- Recycler mScrapContainer = null;
- // Keeps whether this ViewHolder lives in Change scrap or Attached scrap
- boolean mInChangeScrap = false;
-
- // Saves isImportantForAccessibility value for the view item while it's in hidden state and
- // marked as unimportant for accessibility.
- private int mWasImportantForAccessibilityBeforeHidden =
- ViewCompat.IMPORTANT_FOR_ACCESSIBILITY_AUTO;
- // set if we defer the accessibility state change of the view holder
- @VisibleForTesting
- int mPendingAccessibilityState = PENDING_ACCESSIBILITY_STATE_NOT_SET;
-
- /**
- * Is set when VH is bound from the adapter and cleaned right before it is sent to
- * {@link RecycledViewPool}.
- */
- RecyclerView mOwnerRecyclerView;
-
- // The last adapter that bound this ViewHolder. It is cleaned before VH is recycled.
- Adapter mBindingAdapter;
-
- public ViewHolder(@NonNull View itemView) {
- if (itemView == null) {
- throw new IllegalArgumentException("itemView may not be null");
- }
- this.itemView = itemView;
- }
-
- void flagRemovedAndOffsetPosition(int mNewPosition, int offset, boolean applyToPreLayout) {
- addFlags(ViewHolder.FLAG_REMOVED);
- offsetPosition(offset, applyToPreLayout);
- mPosition = mNewPosition;
- }
-
- void offsetPosition(int offset, boolean applyToPreLayout) {
- if (mOldPosition == NO_POSITION) {
- mOldPosition = mPosition;
- }
- if (mPreLayoutPosition == NO_POSITION) {
- mPreLayoutPosition = mPosition;
- }
- if (applyToPreLayout) {
- mPreLayoutPosition += offset;
- }
- mPosition += offset;
- if (itemView.getLayoutParams() != null) {
- ((LayoutParams) itemView.getLayoutParams()).mInsetsDirty = true;
- }
- }
-
- void clearOldPosition() {
- mOldPosition = NO_POSITION;
- mPreLayoutPosition = NO_POSITION;
- }
-
- void saveOldPosition() {
- if (mOldPosition == NO_POSITION) {
- mOldPosition = mPosition;
- }
- }
-
- boolean shouldIgnore() {
- return (mFlags & FLAG_IGNORE) != 0;
- }
-
- /**
- * @see #getLayoutPosition()
- * @see #getBindingAdapterPosition()
- * @see #getAbsoluteAdapterPosition()
- * @deprecated This method is deprecated because its meaning is ambiguous due to the async
- * handling of adapter updates. You should use {@link #getLayoutPosition()},
- * {@link #getBindingAdapterPosition()} or {@link #getAbsoluteAdapterPosition()}
- * depending on your use case.
- */
- @Deprecated
- public final int getPosition() {
- return mPreLayoutPosition == NO_POSITION ? mPosition : mPreLayoutPosition;
- }
-
- /**
- * Returns the position of the ViewHolder in terms of the latest layout pass.
- *