दायरे के साथ पेजिंग लाइब्रेरी का उपयोग करना

एंड्रॉइड डिपार्टमेंट की बैठकों में से एक में, मैंने सुना कि कैसे हमारे डेवलपर्स में से एक ने एक छोटा सा काम किया है, जो "आलसी लोडिंग" और सूचनाओं को संरक्षित करते हुए, दायरे का उपयोग करते हुए "अंतहीन" सूची बनाने में मदद करता है।

मैंने एक मसौदा लेख बनाया और लिखा, जो लगभग अपरिवर्तित है, मैं आपके साथ साझा कर रहा हूं। अपने हिस्से के लिए, उन्होंने वादा किया कि वे कार्यों में रेक करेंगे और यदि सवाल उठेंगे तो टिप्पणियों में आएंगे।

अंतहीन सूची और टर्नकी समाधान

हमारे द्वारा सामना किए जाने वाले कार्यों में से एक सूची में जानकारी प्रदर्शित करना है, जब आप इसे स्क्रॉल करते हैं, तो डेटा लोड किया जाता है और उपयोगकर्ता के लिए अदृश्य रूप से डाला जाता है। उपयोगकर्ता के लिए, ऐसा लगता है कि वह एक अंतहीन सूची को स्क्रॉल करेगा।

एल्गोरिथ्म लगभग निम्नलिखित है:

• हमें पहले पृष्ठ के लिए कैश से डेटा मिलता है;
• यदि कैश खाली है - हमें सर्वर डेटा मिलता है, इसे सूची में प्रदर्शित करें और डेटाबेस में लिखें;
• यदि कोई कैश है, तो उसे सूची में लोड करें;
• यदि हम डेटाबेस के अंत तक पहुँचते हैं, तो हम सर्वर से डेटा का अनुरोध करते हैं, उन्हें सूची में प्रदर्शित करते हैं और डेटाबेस में लिखते हैं।

सरलीकृत: सूची प्रदर्शित करने के लिए, कैश को पहले सर्वेक्षण किया जाता है, और नए डेटा को लोड करने के लिए संकेत कैश का अंत होता है।

अंतहीन स्क्रॉलिंग को लागू करने के लिए, आप तैयार किए गए समाधानों का उपयोग कर सकते हैं:

• RecyclerView.OnScrollListener का कार्यान्वयन, या Github पर तैयार कुछ पाएं , जैसे EndlessRecyclerViewScrollListener ;
• डेटा लोडिंग को नियंत्रित करने के लिए RxJava का उपयोग करके प्रतिक्रियात्मक दृष्टिकोण ;
• सूची का तैयार कार्यान्वयन ;
• जेटपैक से पेजिंग लाइब्रेरी ।

हम एक मोबाइल डेटाबेस के रूप में दायरे का उपयोग करते हैं, और उपरोक्त सभी दृष्टिकोणों की कोशिश करने के बाद, हम पेजिंग लाइब्रेरी का उपयोग करना बंद कर देते हैं।

पहली नज़र में, एंड्रॉइड पेजिंग लाइब्रेरी डेटा डाउनलोड करने के लिए एक उत्कृष्ट समाधान है, और जब कमरे के साथ संयोजन में स्काईलाइट का उपयोग किया जाता है, तो यह एक डेटाबेस के रूप में उत्कृष्ट है। हालाँकि, जब Realm को डेटाबेस के रूप में उपयोग करते हैं, तो हम वह सब कुछ खो देते हैं, जिसका हम उपयोग करते हैं - आलसी लोडिंग और डेटा परिवर्तन सूचनाएँ । हम इन सभी चीजों को छोड़ना नहीं चाहते थे, लेकिन साथ ही पेजिंग लाइब्रेरी का उपयोग करना चाहते थे।

शायद हम पहली जरूरत नहीं हैं

एक त्वरित खोज ने तुरंत एक समाधान निकाला - दायरे राजशाही पुस्तकालय। एक त्वरित अध्ययन के बाद, यह पता चला कि यह समाधान हमारे अनुकूल नहीं है - पुस्तकालय आलसी लोडिंग या सूचनाओं का समर्थन नहीं करता है। मुझे अपना बनाना था।

तो, आवश्यकताएं हैं:

1. दायरे का उपयोग करना जारी रखें;
2. दायरे के लिए आलसी लोडिंग बचाओ;
3. सूचनाएं सहेजें;
4. पेजिंग लाइब्रेरी से डेटा को लोड करने के लिए पेजिंग लाइब्रेरी का उपयोग करें, और पेजिंग लाइब्रेरी की तरह ही सर्वर से डेटा को पेजिंग करें।

शुरुआत से ही हम यह समझने की कोशिश करेंगे कि पेजिंग लाइब्रेरी कैसे काम करती है और हमें अच्छा महसूस कराने के लिए क्या करना चाहिए।

संक्षेप में - पुस्तकालय में निम्नलिखित घटक होते हैं:

DataSource - पृष्ठ द्वारा डेटा पृष्ठ लोड करने के लिए आधार वर्ग।
इसके कार्यान्वयन हैं: PageKeyedDataSource, PositionalDataSource और ItemKeyedDataSource, लेकिन उनका उद्देश्य अब हमारे लिए महत्वपूर्ण नहीं है।

PagedList - एक सूची, जो डेटा स्रोत से डेटा को लोड करती है। लेकिन चूंकि हम दायरे का उपयोग करते हैं, इसलिए बैचों में डेटा लोड करना हमारे लिए प्रासंगिक नहीं है।
PagedListAdapter - वर्ग जो PagedList द्वारा लोड किए गए डेटा को प्रदर्शित करने के लिए जिम्मेदार है।

संदर्भ कार्यान्वयन के स्रोत कोड में, हम देखेंगे कि सर्किट कैसे काम करता है।

1. GetItem (int index) विधि में PagedListAdapter, PagedList के लिए loadAround (int index) विधि कहता है:

/** * Get the item from the current PagedList at the specified index. * <p> * Note that this operates on both loaded items and null padding within the PagedList. * * @param index Index of item to get, must be >= 0, and < {@link #getItemCount()}. * @return The item, or null, if a null placeholder is at the specified position. */ @SuppressWarnings("WeakerAccess") @Nullable public T getItem(int index) { if (mPagedList == null) { if (mSnapshot == null) { throw new IndexOutOfBoundsException( "Item count is zero, getItem() call is invalid"); } else { return mSnapshot.get(index); } } mPagedList.loadAround(index); return mPagedList.get(index); } 

2. PagedList जाँच करता है और शून्य विधि tryDispatchBoundaryCallbacks (बुलियन पोस्ट) कॉल करता है:

 /** * Load adjacent items to passed index. * * @param index Index at which to load. */ public void loadAround(int index) { if (index < 0 || index >= size()) { throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size()); } mLastLoad = index + getPositionOffset(); loadAroundInternal(index); mLowestIndexAccessed = Math.min(mLowestIndexAccessed, index); mHighestIndexAccessed = Math.max(mHighestIndexAccessed, index); /* * mLowestIndexAccessed / mHighestIndexAccessed have been updated, so check if we need to * dispatch boundary callbacks. Boundary callbacks are deferred until last items are loaded, * and accesses happen near the boundaries. * * Note: we post here, since RecyclerView may want to add items in response, and this * call occurs in PagedListAdapter bind. */ tryDispatchBoundaryCallbacks(true); } 

3. इस विधि में, डेटा के निम्नलिखित भाग को डाउनलोड करने की आवश्यकता है और एक डाउनलोड अनुरोध होता है:

 /** * Call this when mLowest/HighestIndexAccessed are changed, or * mBoundaryCallbackBegin/EndDeferred is set. */ @SuppressWarnings("WeakerAccess") /* synthetic access */ void tryDispatchBoundaryCallbacks(boolean post) { final boolean dispatchBegin = mBoundaryCallbackBeginDeferred && mLowestIndexAccessed <= mConfig.prefetchDistance; final boolean dispatchEnd = mBoundaryCallbackEndDeferred && mHighestIndexAccessed >= size() - 1 - mConfig.prefetchDistance; if (!dispatchBegin && !dispatchEnd) { return; } if (dispatchBegin) { mBoundaryCallbackBeginDeferred = false; } if (dispatchEnd) { mBoundaryCallbackEndDeferred = false; } if (post) { mMainThreadExecutor.execute(new Runnable() { @Override public void run() { dispatchBoundaryCallbacks(dispatchBegin, dispatchEnd); } }); } else { dispatchBoundaryCallbacks(dispatchBegin, dispatchEnd); } } 

4. परिणामस्वरूप, सभी कॉल डेटा स्रोत में आते हैं, जहां डेटा डेटाबेस से या अन्य स्रोतों से डाउनलोड किया जाता है:

 @SuppressWarnings("WeakerAccess") /* synthetic access */ void dispatchBoundaryCallbacks(boolean begin, boolean end) { // safe to deref mBoundaryCallback here, since we only defer if mBoundaryCallback present if (begin) { //noinspection ConstantConditions mBoundaryCallback.onItemAtFrontLoaded(mStorage.getFirstLoadedItem()); } if (end) { //noinspection ConstantConditions mBoundaryCallback.onItemAtEndLoaded(mStorage.getLastLoadedItem()); } } 

जबकि सब कुछ सरल दिखता है - बस इसे लें और इसे करें। बस व्यापार:

1. PagedList (RealmPagedList) का अपना कार्यान्वयन बनाएं जो RealmModel के साथ काम करेगा;
2. PagedStorage (RealmPagedStorage) का अपना कार्यान्वयन बनाएँ, जो OrderedRealmCollection के साथ काम करेगा;
3. DataSource (RealmDataSource) का अपना कार्यान्वयन बनाएं जो RealmModel के साथ काम करेगा;
4. RealmList के साथ काम करने के लिए अपना स्वयं का एडाप्टर बनाएं;
5. अनावश्यक निकालें, आवश्यक जोड़ें;
6. हो गया।

हम मामूली तकनीकी विवरणों को छोड़ देते हैं, और यहाँ परिणाम है - RealmPagination Library । आइए एक एप्लिकेशन बनाने का प्रयास करें जो उपयोगकर्ताओं की सूची प्रदर्शित करता है।

0. परियोजना में पुस्तकालय जोड़ें:

 allprojects { repositories { maven { url "https://jitpack.io" } } } implementation 'com.github.magora-android:realmpagination:1.0.0' 

1. उपयोगकर्ता वर्ग बनाएँ:

 @Serializable @RealmClass open class User : RealmModel { @PrimaryKey @SerialName("id") var id: Int = 0 @SerialName("login") var login: String? = null @SerialName("avatar_url") var avatarUrl: String? = null @SerialName("url") var url: String? = null @SerialName("html_url") var htmlUrl: String? = null @SerialName("repos_url") var reposUrl: String? = null } 

2. एक डेटा स्रोत बनाएँ:

 class UsersListDataSourceFactory( private val getUsersUseCase: GetUserListUseCase, private val localStorage: UserDataStorage ) : RealmDataSource.Factory<Int, User>() { override fun create(): RealmDataSource<Int, User> { val result = object : RealmPageKeyedDataSource<Int, User>() { override fun loadInitial(params: LoadInitialParams<Int>, callback: LoadInitialCallback<Int, User>) {...} override fun loadBefore(params: LoadParams<Int>, callback: LoadCallback<Int, User>) { ... } override fun loadAfter(params: LoadParams<Int>, callback: LoadCallback<Int, User>) { ... } } return result } override fun destroy() { } } 

3. एक एडाप्टर बनाएँ:

 class AdapterUserList( data: RealmPagedList<*, User>, private val onClick: (Int, Int) -> Unit ) : BaseRealmListenableAdapter<User, RecyclerView.ViewHolder>(data) { override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): RecyclerView.ViewHolder { val view = LayoutInflater.from(parent.context).inflate(R.layout.item_user, parent, false) return UserViewHolder(view) } override fun onBindViewHolder(holder: RecyclerView.ViewHolder, position: Int) { ... } } 

4. एक ViewModel बनाएँ:

 private const val INITIAL_PAGE_SIZE = 50 private const val PAGE_SIZE = 30 private const val PREFETCH_DISTANCE = 10 class VmUsersList( app: Application, private val dsFactory: UsersListDataSourceFactory, ) : AndroidViewModel(app), KoinComponent { val contentData: RealmPagedList<Int, User> get() { val config = RealmPagedList.Config.Builder() .setInitialLoadSizeHint(INITIAL_PAGE_SIZE) .setPageSize(PAGE_SIZE) .setPrefetchDistance(PREFETCH_DISTANCE) .build() return RealmPagedListBuilder(dsFactory, config) .setInitialLoadKey(0) .setRealmData(localStorage.getUsers().users) .build() } fun refreshData() { ... } fun retryAfterPaginationError() { ... } override fun onCleared() { super.onCleared() dsFactory.destroy() } } 

5. सूची को प्रारंभ करें:

 recyclerView.layoutManager = LinearLayoutManager(context) recyclerView.adapter = AdapterUserList(viewModel.contentData) { user, position -> //... } 

6. एक सूची के साथ एक टुकड़ा बनाएँ:

 class FragmentUserList : BaseFragment() { override fun onViewCreated(view: View, savedInstanceState: Bundle?) { super.onViewCreated(view, savedInstanceState) recyclerView.layoutManager = LinearLayoutManager(context) recyclerView.adapter = AdapterUserList(viewModel.contentData) { user, position -> ... } } 

7. हो गया।

यह पता चला कि Realm का उपयोग करना कक्ष की तरह सरल है। सर्गेई ने पुस्तकालय के स्रोत कोड और उपयोग का एक उदाहरण पोस्ट किया। यदि आप एक जैसी स्थिति में हैं तो आपको दूसरी बाइक नहीं काटनी होगी।