/** * make sure we return the count from the FastAdapter so we retrieve the count from all adapters * * @return */ @Override public int getItemCount() { return mFastAdapter.getItemCount(); }
/** * make sure we return the count from the FastAdapter so we retrieve the count from all adapters * * @return */ @Override public int getItemCount() { return mFastAdapter.getItemCount(); }
private boolean isNothingToLoadNeeded() { return mAdapter.getItemCount() == mTotalItems && !mAlreadyCalledOnNoMore; }
/** * expands all expandable items * * @param notifyItemChanged true if we need to call notifyItemChanged. DEFAULT: false */ public void expand(boolean notifyItemChanged) { int length = mFastAdapter.getItemCount(); for (int i = length - 1; i >= 0; i--) { expand(i, notifyItemChanged); } }
/** * returns a set of selected items, regardless of their visibility * * @param adapter the adapter instance * @return a set of all selected items and subitems * @deprecated See {@link FastAdapter#getSelectedItems()} ()} ()} */ @Deprecated public static Set<IItem> getSelectedItems(FastAdapter adapter) { Set<IItem> selections = new HashSet<>(); int length = adapter.getItemCount(); List<IItem> items = new ArrayList<>(); for (int i = 0; i < length; i++) { items.add(adapter.getItem(i)); } updateSelectedItemsWithCollapsed(selections, items); return selections; }
/** * Gets all items (including sub items) from the FastAdapter * * @param fastAdapter the FastAdapter * @return a list of all items including the whole subItem hirachy */ public static <Item extends IItem> List<Item> getAllItems(FastAdapter<Item> fastAdapter) { int size = fastAdapter.getItemCount(); List<Item> items = new ArrayList<>(size); for (int i = 0; i < size; i++) { Item item = fastAdapter.getItem(i); items.add(item); addAllSubItems(item, items); } return items; }
/** * @return a set with the global positions of all expanded items */ public int[] getExpandedItems() { int[] expandedItems; ArrayList<Integer> expandedItemsList = new ArrayList<>(); Item item; for (int i = 0, size = mFastAdapter.getItemCount(); i < size; i++) { item = mFastAdapter.getItem(i); if (item instanceof IExpandable && ((IExpandable) item).isExpanded()) { expandedItemsList.add(i); } } int expandedItemsListLength = expandedItemsList.size(); expandedItems = new int[expandedItemsListLength]; for (int i = 0; i < expandedItemsListLength; i++) { expandedItems[i] = expandedItemsList.get(i); } return expandedItems; }
@Override public void withSavedInstanceState(@Nullable Bundle savedInstanceState, String prefix) { if (savedInstanceState == null) { return; } ArrayList<String> expandedItems = savedInstanceState.getStringArrayList(BUNDLE_EXPANDED + prefix); String id; for (int i = 0, size = mFastAdapter.getItemCount(); i < size; i++) { Item item = mFastAdapter.getItem(i); id = String.valueOf(item.getIdentifier()); if (expandedItems != null && expandedItems.contains(id)) { expand(i); size = mFastAdapter.getItemCount(); } } }
/** * @return a set with the global positions of all selected items (which are currently in the list (includes expanded expandable items)) */ public Set<Integer> getSelections() { Set<Integer> selections = new ArraySet<>(); for (int i = 0, size = mFastAdapter.getItemCount(); i < size; i++) { if (mFastAdapter.getItem(i).isSelected()) { selections.add(i); } } return selections; }
@Override public void saveInstanceState(Bundle savedInstanceState, String prefix) { if (savedInstanceState == null) { return; } ArrayList<String> expandedItems = new ArrayList<>(); Item item; for (int i = 0, size = mFastAdapter.getItemCount(); i < size; i++) { item = mFastAdapter.getItem(i); if (item instanceof IExpandable && ((IExpandable) item).isExpanded()) { expandedItems.add(String.valueOf(item.getIdentifier())); } } //remember the collapsed states savedInstanceState.putStringArrayList(BUNDLE_EXPANDED + prefix, expandedItems); }
/** * Internal method to get the Item as ItemHolder which comes with the relative position within its adapter * Finds the responsible adapter for the given position * * @param position the global position * @return the adapter which is responsible for this position */ public RelativeInfo<Item> getRelativeInfo(int position) { if (position < 0 || position >= getItemCount()) { return new RelativeInfo<>(); } RelativeInfo<Item> relativeInfo = new RelativeInfo<>(); int index = floorIndex(mAdapterSizes, position); if (index != -1) { relativeInfo.item = mAdapterSizes.valueAt(index).getAdapterItem(position - mAdapterSizes.keyAt(index)); relativeInfo.adapter = mAdapterSizes.valueAt(index); relativeInfo.position = position; } return relativeInfo; }
/** * calculates the position of an drawerItem. searching by it's identifier * * @param identifier * @return */ public static int getPositionByIdentifier(DrawerBuilder drawer, long identifier) { if (identifier != -1) { for (int i = 0; i < drawer.getAdapter().getItemCount(); i++) { if (drawer.getAdapter().getItem(i).getIdentifier() == identifier) { return i; } } } return -1; }
/** * notifies items (incl. sub items if they are currently extended) * * @param adapter the adapter * @param identifiers set of identifiers that should be notified * @param restoreExpandedState true, if expanded headers should stay expanded */ public static <Item extends IItem & IExpandable> void notifyItemsChanged(final FastAdapter adapter, ExpandableExtension expandableExtension, Set<Long> identifiers, boolean restoreExpandedState) { int i; IItem item; for (i = 0; i < adapter.getItemCount(); i++) { item = adapter.getItem(i); if (item instanceof IExpandable) { notifyItemsChanged(adapter, expandableExtension, (Item) item, identifiers, true, restoreExpandedState); } else if (identifiers.contains(item.getIdentifier())) { adapter.notifyAdapterItemChanged(i); } } }
/** * returns the expanded items this contains position and the count of items * which are expanded by this position * * @return the expanded items */ public SparseIntArray getExpanded() { SparseIntArray expandedItems = new SparseIntArray(); Item item; for (int i = 0, size = mFastAdapter.getItemCount(); i < size; i++) { item = mFastAdapter.getItem(i); if (item instanceof IExpandable && ((IExpandable) item).isExpanded()) { expandedItems.put(i, ((IExpandable) item).getSubItems().size()); } } return expandedItems; }
@Test public void getItemCount() throws Exception { List<TestItem> items = TestDataGenerator.genTestItemList(100); itemAdapter.set(items); assertThat(adapter.getItemCount()).isEqualTo(100); }
@Test public void getItemCount() throws Exception { List<TestItem> items = TestDataGenerator.genTestItemList(100); itemAdapter.set(items); assertThat(adapter.getItemCount()).isEqualTo(100); }
/** * util function which recursively iterates over all items and subItems of the given adapter. * It executes the given `predicate` on every item and will either stop if that function returns true, or continue (if stopOnMatch is false) * * @param predicate the predicate to run on every item, to check for a match or do some changes (e.g. select) * @param globalStartPosition the start position at which we star tto recursively iterate over the items. (This will not stop at the end of a sub hierarchy!) * @param stopOnMatch defines if we should stop iterating after the first match * @return Triple<Boolean, IItem, Integer> The first value is true (it is always not null), the second contains the item and the third the position (if the item is visible) if we had a match, (always false and null and null in case of stopOnMatch == false) */ @NonNull public Triple<Boolean, Item, Integer> recursive(AdapterPredicate<Item> predicate, int globalStartPosition, boolean stopOnMatch) { for (int i = globalStartPosition; i < getItemCount(); i++) { //retrieve the item + it's adapter RelativeInfo<Item> relativeInfo = getRelativeInfo(i); Item item = relativeInfo.item; if (predicate.apply(relativeInfo.adapter, i, item, i) && stopOnMatch) { return new Triple<>(true, item, i); } if (item instanceof IExpandable) { Triple<Boolean, Item, Integer> res = FastAdapter.recursiveSub(relativeInfo.adapter, i, (IExpandable) item, predicate, stopOnMatch); if (res.first && stopOnMatch) { return res; } } } return new Triple<>(false, null, null); }
/** * set the selection of the MiniDrawer * * @param identifier the identifier of the item which should be selected (-1 for none) */ public void setSelection(long identifier) { if (identifier == -1) { mAdapter.deselect(); } int count = mAdapter.getItemCount(); for (int i = 0; i < count; i++) { IDrawerItem item = mAdapter.getItem(i); if (item.getIdentifier() == identifier && !item.isSelected()) { mAdapter.deselect(); mAdapter.select(i); } } }
/** * @param position the global position of the current item * @return a set with the global positions of all expanded items on the root level */ public int[] getExpandedItemsRootLevel(int position) { int[] expandedItems; ArraySet<Integer> expandedItemsList = new ArraySet<>(); Item item = mFastAdapter.getItem(position); for (int i = 0, size = mFastAdapter.getItemCount(); i < size; i++) { Item currItem = mFastAdapter.getItem(i); if (currItem instanceof ISubItem) { IItem parent = ((ISubItem) currItem).getParent(); if (parent instanceof IExpandable && ((IExpandable) parent).isExpanded()) { i += ((IExpandable) parent).getSubItems().size(); if (parent != item) expandedItemsList.add(mFastAdapter.getPosition((Item) parent)); } } } int expandedItemsListLength = expandedItemsList.size(); expandedItems = new int[expandedItemsListLength]; for (int i = 0; i < expandedItemsListLength; i++) { expandedItems[i] = expandedItemsList.valueAt(i); } return expandedItems; }
public void onScrolled(RecyclerView recyclerView, int dx, int dy) { super.onScrolled(recyclerView, dx, dy); if (this.mLayoutManager == null) { this.mLayoutManager = (LinearLayoutManager) recyclerView.getLayoutManager(); } if (mVisibleThreshold == -1) { mVisibleThreshold = findLastVisibleItemPosition(recyclerView) - findFirstVisibleItemPosition(recyclerView); } mVisibleItemCount = recyclerView.getChildCount(); mTotalItemCount = mLayoutManager.getItemCount(); mFirstVisibleItem = findFirstVisibleItemPosition(recyclerView); mTotalItemCount = mAdapter.getItemCount(); if (mLoading) { if (mTotalItemCount > mPreviousTotal) { mLoading = false; mPreviousTotal = mTotalItemCount; } } if (!mLoading && mLayoutManager.findFirstVisibleItemPosition() - mVisibleThreshold <= 0) { mCurrentPage++; onLoadMore(mCurrentPage); mLoading = true; } else { if (isNothingToLoadFeatureEnabled() && isNothingToLoadNeeded()) { onNothingToLoad(); mAlreadyCalledOnNoMore = true; } } }