पेज वाला डेटा इकट्ठा करना

यह गाइड पेजिंग लाइब्रेरी के आधार पर बनाई गई है, ख़ास जानकारी में, अपने चैनल पर अपने ऐप्लिकेशन के आर्किटेक्चर को ध्यान में रखते हुए, डेटा लोड करने के समाधान को पसंद के मुताबिक बनाएं ज़रूरतें पूरी करता है.

मॉनिटर की जा सकने वाली सूची बनाना

आम तौर पर, आपके यूज़र इंटरफ़ेस (यूआई) कोड में LiveData<PagedList> ऑब्जेक्ट (या, अगर RxJava2 का इस्तेमाल किया जा रहा है, तो Flowable<PagedList> या Observable<PagedList> ऑब्जेक्ट) है, जो आपके ऐप्लिकेशन का ViewModel. यह मॉनिटर किया जा सकने वाला ऑब्जेक्ट, प्रज़ेंटेशन और कॉन्टेंट के बीच कनेक्शन बनाता है आपके ऐप्लिकेशन का सूची डेटा.

मॉनिटर किए जा सकने वाले इन दस्तावेज़ों में से किसी एक को बनाने के लिए PagedList ऑब्जेक्ट को पास करें, का इंस्टेंस DataSource.Factory से LivePagedListBuilder या RxPagedListBuilder ऑब्जेक्ट है. DataSource ऑब्जेक्ट लोड होता है के कई पेजों के लिए अलग-अलग होते हैं PagedList. फ़ैक्ट्री क्लास नए इंस्टेंस बनाता है कॉन्टेंट से जुड़े अपडेट के जवाब में PagedList, जैसे कि डेटाबेस टेबल का अमान्य होना और नेटवर्क रीफ़्रेश. रूम परसिस्टेंस लाइब्रेरी से DataSource.Factory मिल सकते हैं ऑब्जेक्ट की पहचान कर सकता है या अपनी ज़रूरत के हिसाब से बना सकता है.

नीचे दिया गया कोड स्निपेट दिखाता है कि LiveData<PagedList> आपके ऐप्लिकेशन की ViewModel क्लास, इसका इस्तेमाल कर रही है कमरे की DataSource.Factory-बिल्डिंग क्षमताएं:

कॉन्सर्टडाओ

Kotlin

@Dao
interface ConcertDao {
    // The Int type parameter tells Room to use a PositionalDataSource
    // object, with position-based loading under the hood.
    @Query("SELECT * FROM concerts ORDER BY date DESC")
    fun concertsByDate(): DataSource.Factory<Int, Concert>
}

Java

@Dao
public interface ConcertDao {
    // The Integer type parameter tells Room to use a PositionalDataSource
    // object, with position-based loading under the hood.
    @Query("SELECT * FROM concerts ORDER BY date DESC")
    DataSource.Factory<Integer, Concert> concertsByDate();
}

कॉन्सर्ट व्यू मॉडल

Kotlin

// The Int type argument corresponds to a PositionalDataSource object.
val myConcertDataSource : DataSource.Factory<Int, Concert> =
       concertDao.concertsByDate()

val concertList = myConcertDataSource.toLiveData(pageSize = 50)

Java

// The Integer type argument corresponds to a PositionalDataSource object.
DataSource.Factory<Integer, Concert> myConcertDataSource =
       concertDao.concertsByDate();

LiveData<PagedList<Concert>> concertList =
        LivePagedListBuilder(myConcertDataSource, /* page size */ 50).build();

पेज का अपना कॉन्फ़िगरेशन खुद तय करें

आगे कॉन्फ़िगर करने के लिए बेहतर सेटिंग के लिए LiveData<PagedList> मामलों में, आप अपना खुद का पेजिंग कॉन्फ़िगरेशन भी तय कर सकते हैं. खास तौर पर, आपके पास ये काम करने की सुविधा होती है निम्नलिखित विशेषताएं परिभाषित करें:

अगर आपको पेजिंग लाइब्रेरी के पेजों से सूची लोड करने के समय पर ज़्यादा कंट्रोल चाहिए, ऐप्लिकेशन का डेटाबेस, कस्टम Executor ने LivePagedListBuilder, जैसा कि नीचे दिए गए कोड स्निपेट में दिखाया गया है:

कॉन्सर्ट व्यू मॉडल

Kotlin

val myPagingConfig = Config(
        pageSize = 50,
        prefetchDistance = 150,
        enablePlaceholders = true
)

// The Int type argument corresponds to a PositionalDataSource object.
val myConcertDataSource : DataSource.Factory<Int, Concert> =
        concertDao.concertsByDate()

val concertList = myConcertDataSource.toLiveData(
        pagingConfig = myPagingConfig,
        fetchExecutor = myExecutor
)

Java

PagedList.Config myPagingConfig = new PagedList.Config.Builder()
        .setPageSize(50)
        .setPrefetchDistance(150)
        .setEnablePlaceholders(true)
        .build();

// The Integer type argument corresponds to a PositionalDataSource object.
DataSource.Factory<Integer, Concert> myConcertDataSource =
        concertDao.concertsByDate();

LiveData<PagedList<Concert>> concertList =
        new LivePagedListBuilder<>(myConcertDataSource, myPagingConfig)
            .setFetchExecutor(myExecutor)
            .build();

डेटा सोर्स का सही टाइप चुनना

यह ज़रूरी है कि आप उस डेटा सोर्स से कनेक्ट करें जो आपके सोर्स को बेहतर तरीके से मैनेज करता है डेटा का स्ट्रक्चर:

  • इस्तेमाल की जाने वाली चीज़ें PageKeyedDataSource अगर जिन पेजों को लोड करते हैं वे 'अगली/पिछली कुंजी' के साथ एम्बेड करते हैं. उदाहरण के लिए, अगर आपको सोशल मीडिया नेटवर्क से मीडिया पोस्ट अपलोड करने के लिए, आपको एक से nextPage टोकन पास करना पड़ सकता है में लोड नहीं करना है.
  • इस्तेमाल की जाने वाली चीज़ें ItemKeyedDataSource अगर आपको आइटम N+1 फ़ेच करने के लिए, आइटम N से डेटा का इस्तेमाल करना होगा. उदाहरण के लिए, अगर आपको किसी चर्चा ऐप्लिकेशन के लिए थ्रेड वाली टिप्पणियां फ़ेच करनी हैं, तो आपको आईडी पास करना पड़ सकता है अगली टिप्पणी की सामग्री पाने के लिए.
  • इस्तेमाल की जाने वाली चीज़ें PositionalDataSource अगर आपको अपने डेटा स्टोर में चुनी गई किसी भी जगह से, डेटा के पेजों को फ़ेच करना होगा. यह क्लास, किसी भी चीज़ से शुरू होने वाले डेटा आइटम के सेट के लिए अनुरोध करने में मदद करती है क्लिक किया जा सकता है. उदाहरण के लिए, अनुरोध में 50 डेटा आइटम दिखाए जा सकते हैं जो जगह 1500 से शुरू होती है.

डेटा के अमान्य होने पर सूचना दें

पेजिंग लाइब्रेरी का इस्तेमाल करते समय, डेटा लेयर के ऊपर किसी टेबल या पंक्ति की पुरानी जानकारी होने पर, आपके ऐप्लिकेशन की अन्य लेयर. ऐसा करने के लिए, कॉल करें invalidate() DataSource क्लास आपके ऐप्लिकेशन के लिए चुना गया है.

अपने डेटा सोर्स बनाएं

अगर कस्टम लोकल डेटा सलूशन का इस्तेमाल किया जाता है या सीधे किसी नेटवर्क है, तो आप DataSource सब-क्लास. कॉन्टेंट बनाने नीचे दिया गया कोड स्निपेट एक ऐसा डेटा सोर्स दिखाता है, जो किसी खास कॉन्सर्ट शुरू होने का समय:

Kotlin

class ConcertTimeDataSource() :
        ItemKeyedDataSource<Date, Concert>() {
    override fun getKey(item: Concert) = item.startTime

    override fun loadInitial(
            params: LoadInitialParams<Date>,
            callback: LoadInitialCallback<Concert>) {
        val items = fetchItems(params.requestedInitialKey,
                params.requestedLoadSize)
        callback.onResult(items)
    }

    override fun loadAfter(
            params: LoadParams<Date>,
            callback: LoadCallback<Concert>) {
        val items = fetchItemsAfter(
            date = params.key,
            limit = params.requestedLoadSize)
        callback.onResult(items)
    }
}

Java

public class ConcertTimeDataSource
        extends ItemKeyedDataSource<Date, Concert> {
    @NonNull
    @Override
    public Date getKey(@NonNull Concert item) {
        return item.getStartTime();
    }

    @Override
    public void loadInitial(@NonNull LoadInitialParams<Date> params,
            @NonNull LoadInitialCallback<Concert> callback) {
        List<Concert> items =
            fetchItems(params.key, params.requestedLoadSize);
        callback.onResult(items);
    }

    @Override
    public void loadAfter(@NonNull LoadParams<Date> params,
            @NonNull LoadCallback<Concert> callback) {
        List<Concert> items =
            fetchItemsAfter(params.key, params.requestedLoadSize);
        callback.onResult(items);
    }

इसके बाद, कस्टमाइज़ किए गए इस डेटा को PagedList ऑब्जेक्ट में लोड किया जा सकता है. इसके लिए, इसका कंक्रीट सब-क्लास DataSource.Factory. कॉन्टेंट बनाने इस कोड स्निपेट में, हम आपको कस्टम डेटा के नए इंस्टेंस जनरेट करने का तरीका बताएंगे स्रोत पिछले कोड स्निपेट में निर्धारित किया गया है:

Kotlin

class ConcertTimeDataSourceFactory :
        DataSource.Factory<Date, Concert>() {
    val sourceLiveData = MutableLiveData<ConcertTimeDataSource>()
    var latestSource: ConcertDataSource?
    override fun create(): DataSource<Date, Concert> {
        latestSource = ConcertTimeDataSource()
        sourceLiveData.postValue(latestSource)
        return latestSource
    }
}

Java

public class ConcertTimeDataSourceFactory
        extends DataSource.Factory<Date, Concert> {
    private MutableLiveData<ConcertTimeDataSource> sourceLiveData =
            new MutableLiveData<>();

    private ConcertDataSource latestSource;

    @Override
    public DataSource<Date, Concert> create() {
        latestSource = new ConcertTimeDataSource();
        sourceLiveData.postValue(latestSource);
        return latestSource;
    }
}

देखें कि कॉन्टेंट अपडेट करने की सुविधा कैसे काम करती है

जब ऐसा सिस्टम, ऑब्ज़र्व किया जा सके, PagedList ऑब्जेक्ट के हिसाब से, कॉन्टेंट अपडेट करने की सुविधा कैसे काम करती है. अगर सीधे किसी रूम से डेटा लोड किया जा रहा है, तो डेटाबेस के अपडेट, आपके ऐप्लिकेशन के यूज़र इंटरफ़ेस (यूआई) में पुश किए जाते हैं स्वचालित रूप से.

पेज वाले नेटवर्क एपीआई का इस्तेमाल करते समय, आम तौर पर उपयोगकर्ता इंटरैक्शन होता है, जैसे "रीफ़्रेश करने के लिए स्वाइप करें," के लिए एक सिग्नल के रूप में काम करते हैं. वह DataSource जिसका इस्तेमाल आपने सबसे ज़्यादा किया है हाल ही में. इसके बाद, उस डेटा सोर्स के नए इंस्टेंस के लिए अनुरोध किया जाता है. यह फ़ॉलो किया जा रहा है कोड स्निपेट इस व्यवहार को दिखाता है:

Kotlin

class ConcertActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        // ...
        concertTimeViewModel.refreshState.observe(this, Observer {
            // Shows one possible way of triggering a refresh operation.
            swipeRefreshLayout.isRefreshing =
                    it == MyNetworkState.LOADING
        })
        swipeRefreshLayout.setOnRefreshListener {
            concertTimeViewModel.invalidateDataSource()
        }
    }
}

class ConcertTimeViewModel(firstConcertStartTime: Date) : ViewModel() {
    val dataSourceFactory = ConcertTimeDataSourceFactory(firstConcertStartTime)
    val concertList: LiveData<PagedList<Concert>> =
            dataSourceFactory.toLiveData(
                pageSize = 50,
                fetchExecutor = myExecutor
            )

    fun invalidateDataSource() =
            dataSourceFactory.sourceLiveData.value?.invalidate()
}

Java

public class ConcertActivity extends AppCompatActivity {
    @Override
    public void onCreate(@Nullable Bundle savedInstanceState) {
        // ...
        viewModel.getRefreshState()
                .observe(this, new Observer<NetworkState>() {
            // Shows one possible way of triggering a refresh operation.
            @Override
            public void onChanged(@Nullable MyNetworkState networkState) {
                swipeRefreshLayout.isRefreshing =
                        networkState == MyNetworkState.LOADING;
            }
        };

        swipeRefreshLayout.setOnRefreshListener(new SwipeRefreshListener() {
            @Override
            public void onRefresh() {
                viewModel.invalidateDataSource();
            }
        });
    }
}

public class ConcertTimeViewModel extends ViewModel {
    private LiveData<PagedList<Concert>> concertList;
    private DataSource<Date, Concert> mostRecentDataSource;

    public ConcertTimeViewModel(Date firstConcertStartTime) {
        ConcertTimeDataSourceFactory dataSourceFactory =
                new ConcertTimeDataSourceFactory(firstConcertStartTime);
        mostRecentDataSource = dataSourceFactory.create();
        concertList = new LivePagedListBuilder<>(dataSourceFactory, 50)
                .setFetchExecutor(myExecutor)
                .build();
    }

    public void invalidateDataSource() {
        mostRecentDataSource.invalidate();
    }
}

डेटा मैपिंग की सुविधा उपलब्ध कराएं

पेजिंग लाइब्रेरी, आइटम और पेज के हिसाब से आइटम को बदलने की सुविधा देती है DataSource ने लोड किया.

नीचे दिए गए कोड स्निपेट में, कॉन्सर्ट का नाम और कॉन्सर्ट की तारीख एक साथ एक स्ट्रिंग में मैप किया गया हो, जिसमें नाम और तारीख दोनों हों:

Kotlin

class ConcertViewModel : ViewModel() {
    val concertDescriptions : LiveData<PagedList<String>>
        init {
            val concerts = database.allConcertsFactory()
                    .map { "${it.name} - ${it.date}" }
                    .toLiveData(pageSize = 50)
        }
}

Java

public class ConcertViewModel extends ViewModel {
    private LiveData<PagedList<String>> concertDescriptions;

    public ConcertViewModel(MyDatabase database) {
        DataSource.Factory<Integer, Concert> factory =
                database.allConcertsFactory().map(concert ->
                    concert.getName() + "-" + concert.getDate());
        concertDescriptions = new LivePagedListBuilder<>(
            factory, /* page size */ 50).build();
    }
}

यह तब काम आ सकता है, जब आप आइटम को लोड हो गया. चूंकि यह काम फ़ेच करने वाले पर किया जाता है, इसलिए आप यह काम संभावित रूप से कर सकते हैं जैसे कि डिस्क से पढ़ना या किसी अलग डेटाबेस की क्वेरी करना.

सुझाव या राय दें

इन संसाधनों की मदद से, हमारे साथ अपने सुझाव, शिकायत या राय शेयर करें:

समस्या को ट्रैक करने वाला टूल
समस्याओं की शिकायत करें, ताकि हम गड़बड़ियां ठीक कर सकें.

अन्य संसाधन

पेजिंग लाइब्रेरी के बारे में ज़्यादा जानने के लिए, इन संसाधनों को देखें.

सैंपल

कोड लैब

वीडियो