androidx.paging.PagedList Java Examples

public UserListingViewModel(Retrofit retrofit, String query, SortType sortType) {
    userListingDataSourceFactory = new UserListingDataSourceFactory(retrofit, query, sortType);

    initialLoadingState = Transformations.switchMap(userListingDataSourceFactory.getUserListingDataSourceMutableLiveData(),
            UserListingDataSource::getInitialLoadStateLiveData);
    paginationNetworkState = Transformations.switchMap(userListingDataSourceFactory.getUserListingDataSourceMutableLiveData(),
            UserListingDataSource::getPaginationNetworkStateLiveData);
    hasUserLiveData = Transformations.switchMap(userListingDataSourceFactory.getUserListingDataSourceMutableLiveData(),
            UserListingDataSource::hasUserLiveData);

    sortTypeLiveData = new MutableLiveData<>();
    sortTypeLiveData.postValue(sortType);

    PagedList.Config pagedListConfig =
            (new PagedList.Config.Builder())
                    .setEnablePlaceholders(false)
                    .setPageSize(25)
                    .build();

    users = Transformations.switchMap(sortTypeLiveData, sort -> {
        userListingDataSourceFactory.changeSortType(sortTypeLiveData.getValue());
        return (new LivePagedListBuilder(userListingDataSourceFactory, pagedListConfig)).build();
    });
}
 

/**
 * Initialize the paged list
 */
private void init(String sortCriteria) {
    Executor executor = Executors.newFixedThreadPool(NUMBER_OF_FIXED_THREADS_FIVE);

    // Create a MovieDataSourceFactory providing DataSource generations
    MovieDataSourceFactory movieDataFactory = new MovieDataSourceFactory(sortCriteria);

    // Configures how a PagedList loads content from the MovieDataSource
    PagedList.Config config = (new PagedList.Config.Builder())
            .setEnablePlaceholders(false)
            // Size hint for initial load of PagedList
            .setInitialLoadSizeHint(INITIAL_LOAD_SIZE_HINT)
            // Size of each page loaded by the PagedList
            .setPageSize(PAGE_SIZE)
            // Prefetch distance which defines how far ahead to load
            .setPrefetchDistance(PREFETCH_DISTANCE)
            .build();

    // The LivePagedListBuilder class is used to get a LiveData object of type PagedList
    mMoviePagedList = new LivePagedListBuilder<>(movieDataFactory, config)
            .setFetchExecutor(executor)
            .build();
}
 

private void observeThreadOverviewItems(LiveData<PagedList<ThreadOverviewItem>> liveData) {
    final AtomicBoolean actionModeRefreshed = new AtomicBoolean(false);
    liveData.observe(getViewLifecycleOwner(), threadOverviewItems -> {
        final RecyclerView.LayoutManager layoutManager = binding.threadList.getLayoutManager();
        final boolean atTop;
        if (layoutManager instanceof LinearLayoutManager) {
            atTop = ((LinearLayoutManager) layoutManager).findFirstCompletelyVisibleItemPosition() == 0;
        } else {
            atTop = false;
        }
        threadOverviewAdapter.submitList(threadOverviewItems, () -> {
            if (atTop && binding != null) {
                binding.threadList.scrollToPosition(0);
            }
            if (actionMode != null && actionModeRefreshed.compareAndSet(false, true)) {
                actionMode.invalidate();
            }
        });
    });
}
 

@Override
public int getPosition(@NonNull String key) {
    final PagedList<ThreadOverviewItem> currentList = threadOverviewAdapter.getCurrentList();
    if (currentList == null) {
        return RecyclerView.NO_POSITION;
    }
    final int offset = currentList.getPositionOffset();
    final List<ThreadOverviewItem> snapshot = currentList.snapshot();
    int i = 0;
    for (final ThreadOverviewItem item : snapshot) {
        if (item != null && key.equals(item.threadId)) {
            return offset + i;
        }
        ++i;
    }
    return RecyclerView.NO_POSITION;
}
 

/**
 * Update the MoviePagedList from LiveData in MainActivityViewModel
 */
private void observeMoviePagedList() {
    mMainViewModel.getMoviePagedList().observe(this, new Observer<PagedList<Movie>>() {
        @Override
        public void onChanged(@Nullable PagedList<Movie> pagedList) {
            showMovieDataView();
            if (pagedList != null) {
                mMoviePagedListAdapter.submitList(pagedList);

                // Restore the scroll position after setting up the adapter with the list of movies
                mMainBinding.rvMovie.getLayoutManager().onRestoreInstanceState(mSavedLayoutState);
            }

            // When offline, make the movie data view visible and show a snackbar message
            if (!isOnline()) {
                showMovieDataView();
                showSnackbarOffline();
            }
        }
    });
}
 

public LiveData<PagedList<ThreadOverviewItem>> getThreadOverviewItems(final EmailQuery query) {
    return Transformations.switchMap(databaseLiveData, new Function<LttrsDatabase, LiveData<PagedList<ThreadOverviewItem>>>() {
        @Override
        public LiveData<PagedList<ThreadOverviewItem>> apply(LttrsDatabase database) {
            return new LivePagedListBuilder<>(database.queryDao().getThreadOverviewItems(query.toQueryString()), 30)
                    .setBoundaryCallback(new PagedList.BoundaryCallback<ThreadOverviewItem>() {
                        @Override
                        public void onZeroItemsLoaded() {
                            Log.d("lttrs", "onZeroItemsLoaded");
                            requestNextPage(query, null); //conceptually in terms of loading indicators this is more of a page request
                            super.onZeroItemsLoaded();
                        }

                        @Override
                        public void onItemAtEndLoaded(@NonNull ThreadOverviewItem itemAtEnd) {
                            Log.d("lttrs", "onItemAtEndLoaded(" + itemAtEnd.emailId + ")");
                            requestNextPage(query, itemAtEnd.emailId);
                            super.onItemAtEndLoaded(itemAtEnd);
                        }
                    })
                    .build();
        }
    });
}
 

/**
 * Update the MoviePagedList from LiveData in MainActivityViewModel
 */
private void observeMoviePagedList() {
    mMainViewModel.getMoviePagedList().observe(this, new Observer<PagedList<Movie>>() {
        @Override
        public void onChanged(@Nullable PagedList<Movie> pagedList) {
            showMovieDataView();
            if (pagedList != null) {
                mMoviePagedListAdapter.submitList(pagedList);

                // Restore the scroll position after setting up the adapter with the list of movies
                mMainBinding.rvMovie.getLayoutManager().onRestoreInstanceState(mSavedLayoutState);
            }

            // When offline, make the movie data view visible and show a snackbar message
            if (!isOnline()) {
                showMovieDataView();
                showSnackbarOffline();
            }
        }
    });
}
 

private MediaFileViewModel(ContentResolver contentResolver, Configurations configs, Long dirId) {
    this.contentResolver = contentResolver;

    MediaFileDataSource.Factory mediaFileDataSourceFactory = new MediaFileDataSource.Factory(contentResolver, configs, dirId);

    mediaFiles = new LivePagedListBuilder<>(
            mediaFileDataSourceFactory,
            new PagedList.Config.Builder()
                    .setPageSize(Configurations.PAGE_SIZE)
                    .setInitialLoadSizeHint(15)
                    .setMaxSize(Configurations.PAGE_SIZE * 3)
                    .setPrefetchDistance(Configurations.PREFETCH_DISTANCE)
                    .setEnablePlaceholders(false)
                    .build()
    ).build();

    contentResolver.registerContentObserver(mediaFileDataSourceFactory.getUri(), true, contentObserver);
}
 

@Test
public void get_initial_objects_ordered_by_description_desc() throws InterruptedException {
    LiveData<PagedList<CategoryOption>> liveData = d2.categoryModule().categoryOptions()
            .orderByDescription(RepositoryScope.OrderByDirection.DESC)
            .getPaged(2);
    TestObserver.test(liveData)
            .awaitValue()
            .assertHasValue()
            .assertValue(pagedList -> pagedList.size() == 6)
            .assertValue(pagedList -> pagedList.get(0).displayName().equals("default display name"))
            .assertValue(pagedList -> pagedList.get(1).displayName().equals("Female"))
            .assertValue(pagedList -> pagedList.get(2).displayName().equals("Male"))
            .assertValue(pagedList -> pagedList.get(3).displayName().equals("In Community"))
            .assertValue(pagedList -> pagedList.get(4).displayName().equals("At PHU"))
            .assertValue(pagedList -> pagedList.get(5).displayName().equals("MCH Aides"));
}
 

@Test
public void get_initial_objects_ordered_by_display_name_desc() throws InterruptedException {
    LiveData<PagedList<CategoryOption>> liveData = d2.categoryModule().categoryOptions()
            .orderByDisplayName(RepositoryScope.OrderByDirection.DESC)
            .getPaged(2);
    TestObserver.test(liveData)
            .awaitValue()
            .assertHasValue()
            .assertValue(pagedList -> pagedList.size() == 6)
            .assertValue(pagedList -> pagedList.get(0).displayName().equals("default display name"))
            .assertValue(pagedList -> pagedList.get(1).displayName().equals("Trained TBA"))
            .assertValue(pagedList -> pagedList.get(2).displayName().equals("SECHN"))
            .assertValue(pagedList -> pagedList.get(3).displayName().equals("Male"))
            .assertValue(pagedList -> pagedList.get(4).displayName().equals("MCH Aides"))
            .assertValue(pagedList -> pagedList.get(5).displayName().equals("In Community"));
}
 

@Test
public void get_initial_objects_ordered_by_description_and_display_name_desc() throws InterruptedException {
    LiveData<PagedList<CategoryOption>> liveData = d2.categoryModule().categoryOptions()
            .orderByDescription(RepositoryScope.OrderByDirection.DESC)
            .orderByDisplayName(RepositoryScope.OrderByDirection.ASC)
            .getPaged(2);
    TestObserver.test(liveData)
            .awaitValue()
            .assertHasValue()
            .assertValue(pagedList -> pagedList.size() == 6)
            .assertValue(pagedList -> pagedList.get(0).displayName().equals("default display name"))
            .assertValue(pagedList -> pagedList.get(1).displayName().equals("At PHU"))
            .assertValue(pagedList -> pagedList.get(2).displayName().equals("Female"))
            .assertValue(pagedList -> pagedList.get(3).displayName().equals("In Community"))
            .assertValue(pagedList -> pagedList.get(4).displayName().equals("Male"))
            .assertValue(pagedList -> pagedList.get(5).displayName().equals("MCH Aides"));
}
 

@Subscribe
public void onPostUpdateEvent(PostUpdateEventToPostList event) {
    PagedList<Post> posts = mAdapter.getCurrentList();
    if (posts != null && event.positionInList >= 0 && event.positionInList < posts.size()) {
        Post post = posts.get(event.positionInList);
        if (post != null && post.getFullName().equals(event.post.getFullName())) {
            post.setTitle(event.post.getTitle());
            post.setVoteType(event.post.getVoteType());
            post.setScore(event.post.getScore());
            post.setNSFW(event.post.isNSFW());
            post.setHidden(event.post.isHidden());
            post.setSpoiler(event.post.isSpoiler());
            post.setFlair(event.post.getFlair());
            post.setSaved(event.post.isSaved());
            mAdapter.notifyItemChanged(event.positionInList);
        }
    }
}
 

@Test
public void initialPageBind() {
  controller.setConfig(
      new PagedList.Config.Builder()
          .setEnablePlaceholders(false)
          .setPageSize(100)
          .setInitialLoadSizeHint(100)
          .build()
  );
  controller.setPagedListWithSize(500);

  List<EpoxyModel<?>> models = controller.getAdapter().getCopyOfModels();
  assertEquals(100, models.size());

  assertEquals(1, models.get(0).id());
}
 

@Test
public void initialPageBind() {
  controller.setConfig(
      new PagedList.Config.Builder()
          .setEnablePlaceholders(false)
          .setPageSize(100)
          .setInitialLoadSizeHint(100)
          .build()
  );
  controller.setListWithSize(500);

  List<EpoxyModel<?>> models = controller.getAdapter().getCopyOfModels();
  assertEquals(100, models.size());

  assertEquals(1, models.get(0).id());
}
 

@Override
public void setLiveData(LiveData<PagedList<ProgramEventViewModel>> pagedListLiveData) {
    pagedListLiveData.observe(this, pagedList -> {
        binding.programProgress.setVisibility(View.GONE);
        liveAdapter.submitList(pagedList, () -> {
            if (binding.recycler.getAdapter() != null && binding.recycler.getAdapter().getItemCount() == 0) {
                binding.emptyTeis.setVisibility(View.VISIBLE);
                binding.recycler.setVisibility(View.GONE);
            } else {
                binding.emptyTeis.setVisibility(View.GONE);
                binding.recycler.setVisibility(View.VISIBLE);
            }
        });

    });

}
 

/**
 * Set a PagedList that should be used to build models in this controller. A listener will be
 * attached to the list so that models are rebuilt as new list items are loaded.
 * <p>
 * By default the Config setting on the PagedList will dictate how many models are built at once,
 * and what prefetch thresholds should be used. This can be overridden with a separate Config via
 * {@link #setConfig(Config)}.
 * <p>
 * See {@link #setConfig(Config)} for details on how the Config settings are used, and for
 * recommended values.
 */
public void setList(@Nullable PagedList<T> list) {
  if (list == this.pagedList) {
    return;
  }

  PagedList<T> previousList = this.pagedList;
  this.pagedList = list;

  if (previousList != null) {
    previousList.removeWeakCallback(callback);
  }

  if (list != null) {
    list.addWeakCallback(null, callback);
  }

  isFirstBuildForList = true;
  updatePagedListSnapshot();
}
 

@Test
public void get_initial_objects_ordered_by_display_name_asc() throws InterruptedException {
    LiveData<PagedList<CategoryOption>> liveData = d2.categoryModule().categoryOptions()
            .orderByDisplayName(RepositoryScope.OrderByDirection.ASC)
            .getPaged(2);
    TestObserver.test(liveData)
            .awaitValue()
            .assertHasValue()
            .assertValue(pagedList -> pagedList.size() == 6)
            .assertValue(pagedList -> pagedList.get(0).displayName().equals("At PHU"))
            .assertValue(pagedList -> pagedList.get(1).displayName().equals("Female"))
            .assertValue(pagedList -> pagedList.get(2).displayName().equals("In Community"))
            .assertValue(pagedList -> pagedList.get(3).displayName().equals("MCH Aides"))
            .assertValue(pagedList -> pagedList.get(4).displayName().equals("Male"))
            .assertValue(pagedList -> pagedList.get(5).displayName().equals("SECHN"));
}
 

public SubredditListingViewModel(Retrofit retrofit, String query, SortType sortType) {
    subredditListingDataSourceFactory = new SubredditListingDataSourceFactory(retrofit, query, sortType);

    initialLoadingState = Transformations.switchMap(subredditListingDataSourceFactory.getSubredditListingDataSourceMutableLiveData(),
            SubredditListingDataSource::getInitialLoadStateLiveData);
    paginationNetworkState = Transformations.switchMap(subredditListingDataSourceFactory.getSubredditListingDataSourceMutableLiveData(),
            SubredditListingDataSource::getPaginationNetworkStateLiveData);
    hasSubredditLiveData = Transformations.switchMap(subredditListingDataSourceFactory.getSubredditListingDataSourceMutableLiveData(),
            SubredditListingDataSource::hasSubredditLiveData);

    sortTypeLiveData = new MutableLiveData<>();
    sortTypeLiveData.postValue(sortType);

    PagedList.Config pagedListConfig =
            (new PagedList.Config.Builder())
                    .setEnablePlaceholders(false)
                    .setPageSize(25)
                    .build();

    subreddits = Transformations.switchMap(sortTypeLiveData, sort -> {
        subredditListingDataSourceFactory.changeSortType(sortTypeLiveData.getValue());
        return new LivePagedListBuilder(subredditListingDataSourceFactory, pagedListConfig).build();
    });
}
 

/**
 * Sets the query using a custom {@link Source} and a {@link ClassSnapshotParser} based
 * on the given class.
 *
 * See {@link #setQuery(Query, Source, PagedList.Config, SnapshotParser)}.
 */
@NonNull
public Builder<T> setQuery(@NonNull Query query,
                           @NonNull Source source,
                           @NonNull PagedList.Config config,
                           @NonNull Class<T> modelClass) {
    return setQuery(query, source, config, new ClassSnapshotParser<>(modelClass));
}
 

/**
 * Sets the Database query to paginate.
 *
 * @param query the FirebaseDatabase query. This query should only contain orderByKey(), orderByChild() and
 *              orderByValue() clauses. Any limit will cause an error such as limitToLast() or limitToFirst().
 * @param config paging configuration, passed directly to the support paging library.
 * @param parser the {@link SnapshotParser} to parse {@link DataSnapshot} into model
 *               objects.
 * @return this, for chaining.
 */
@NonNull
public Builder<T> setQuery(@NonNull Query query,
                           @NonNull PagedList.Config config,
                           @NotNull SnapshotParser<T> parser) {
    FirebaseDataSource.Factory factory = new FirebaseDataSource.Factory(query);
    mData = new LivePagedListBuilder<>(factory, config).build();

    mParser = parser;
    return this;
}
 

private LiveData<PagedList<Content>> getPagedContent(
        int mode,
        String filter,
        List<Attribute> metadata,
        int orderField,
        boolean orderDesc,
        boolean favouritesOnly,
        boolean loadAll) {
    boolean isRandom = (orderField == Preferences.Constant.ORDER_FIELD_RANDOM);

    Query<Content> query;
    if (Mode.SEARCH_CONTENT_MODULAR == mode) {
        query = db.queryContentSearchContent(filter, metadata, favouritesOnly, orderField, orderDesc);
    } else { // Mode.SEARCH_CONTENT_UNIVERSAL
        query = db.queryContentUniversal(filter, favouritesOnly, orderField, orderDesc);
    }

    int nbPages = Preferences.getContentPageQuantity();
    int initialLoad = nbPages * 2;
    if (loadAll) {
        // Trump Android's algorithm by setting a number of pages higher that the actual number of results
        // to avoid having a truncated result set (see issue #501)
        initialLoad = (int) Math.ceil(query.count() * 1.0 / nbPages) * nbPages;
    }

    PagedList.Config cfg = new PagedList.Config.Builder().setEnablePlaceholders(!loadAll).setInitialLoadSizeHint(initialLoad).setPageSize(nbPages).build();

    return new LivePagedListBuilder<>(
            isRandom ? new ObjectBoxRandomDataSource.RandomDataSourceFactory<>(query) : new ObjectBoxDataSource.Factory<>(query),
            cfg
    ).build();
}
 

@NonNull
@Override
public LiveData<PagedList<ProgramEventViewModel>> filteredProgramEvents(List<DatePeriod> dateFilter, List<String> orgUnitFilter, List<CategoryOptionCombo> catOptCombList,
                                                                        List<EventStatus> eventStatus, List<State> states, boolean assignedToUser) {
    EventCollectionRepository eventRepo = d2.eventModule().events().byProgramUid().eq(programUid).byDeleted().isFalse();
    if (!dateFilter.isEmpty())
        eventRepo = eventRepo.byEventDate().inDatePeriods(dateFilter);
    if (!orgUnitFilter.isEmpty())
        eventRepo = eventRepo.byOrganisationUnitUid().in(orgUnitFilter);
    if (!catOptCombList.isEmpty())
        eventRepo = eventRepo.byAttributeOptionComboUid().in(UidsHelper.getUids(catOptCombList));
    if (!eventStatus.isEmpty())
        eventRepo = eventRepo.byStatus().in(eventStatus);
    if (!states.isEmpty())
        eventRepo = eventRepo.byState().in(states);
    if (assignedToUser)
        eventRepo = eventRepo.byAssignedUser().eq(getCurrentUser());

    DataSource dataSource = eventRepo.orderByEventDate(RepositoryScope.OrderByDirection.DESC).withTrackedEntityDataValues().getDataSource().map(event -> mapper.eventToProgramEvent(event));

    return new LivePagedListBuilder(new DataSource.Factory() {
        @Override
        public DataSource create() {
            return dataSource;
        }
    }, 20).build();
}
 

public RoomFileRepository(Application application) {
    RoomFileDatabase roomFileDatabase = RoomFileDatabase.getRoomFileDatabase(application);
    roomFileDao = roomFileDatabase.roomFileDao();
    listLiveData = roomFileDao.geAlphabetizedFiles();
    PagedList.Config config = new PagedList.Config.Builder()
            .setPageSize(25)
            .setEnablePlaceholders(false)
            .build();
    pagedListLiveData = new LivePagedListBuilder<>(
            roomFileDao.getPagedFiles(), config)
            .setInitialLoadKey(1)
            .build();
}
 

@Override
public void onChanged(@Nullable PagedList<DataSnapshot> snapshots) {
    if (snapshots == null) {
        return;
    }
    submitList(snapshots);
}
 

LiveData<PagedList<HttpTransactionUIHelper>> getTransactions(String key) {
    if (key == null || key.trim().length() == 0) {
        return mTransactions;
    } else {
        DataSource.Factory<Integer, HttpTransactionUIHelper> factory = mTransactionDao.getAllTransactionsWith(key, TransactionDao.SearchType.DEFAULT).map(HttpTransactionUIHelper.HTTP_TRANSACTION_UI_HELPER_FUNCTION);
        return new LivePagedListBuilder<>(factory, config).build();
    }
}
 

/**
 * Sets the query using {@link Source#DEFAULT} and a {@link ClassSnapshotParser} based
 * on the given Class.
 *
 * See {@link #setQuery(Query, Source, PagedList.Config, SnapshotParser)}.
 */
@NonNull
public Builder<T> setQuery(@NonNull Query query,
                           @NonNull PagedList.Config config,
                           @NonNull Class<T> modelClass) {
    return setQuery(query, Source.DEFAULT, config, modelClass);
}
 

public RepoMoviesResult(LiveData<PagedList<Movie>> data,
                        LiveData<Resource> resource,
                        MutableLiveData<MoviePageKeyedDataSource> sourceLiveData) {
    this.data = data;
    this.resource = resource;
    this.sourceLiveData = sourceLiveData;
}
 

private void loadResults(final String searchKey, LiveData<PagedList<HttpTransactionUIHelper>> pagedListLiveData) {
    if (mCurrentSubscription != null && mCurrentSubscription.hasObservers()) {
        mCurrentSubscription.removeObservers(this);
    }
    mCurrentSubscription = pagedListLiveData;
    mCurrentSubscription.observe(TransactionListActivity.this, new Observer<PagedList<HttpTransactionUIHelper>>() {
        @Override
        public void onChanged(@Nullable PagedList<HttpTransactionUIHelper> transactionPagedList) {
            mTransactionSampler.consume(new TransactionListWithSearchKeyModel(searchKey, transactionPagedList));
        }
    });
}
 

@Override
public void onChanged(@Nullable PagedList<DocumentSnapshot> snapshots) {
    if (snapshots == null) {
        return;
    }

    submitList(snapshots);
}
 

public void setList(@Nullable List<T> list) {
  if (list == this.list) {
    return;
  }

  if (pagedList != null) {
    setList((PagedList<T>) null);
  }

  this.list = list == null ? Collections.<T>emptyList() : list;
  isFirstBuildForList = true;
  requestModelBuild();
}