मेरी मुख्य गतिविधि में एक व्यूपेजर है जो 4 टुकड़े लोड करता है, प्रत्येक टुकड़े को सर्वर से बहुत सारे डेटा लोड करना चाहिए।

इसलिए जब मेरा ऐप पहली बार चलाना चाहता है, तो इसमें लगभग 3 सेकंड से अधिक समय लगता है और दूसरी बार (उदाहरण के लिए, यदि आप ऐप से बाहर निकलते हैं लेकिन इसे अपनी 'हाल की ऐप' विंडो से साफ़ नहीं करते हैं और इसे फिर से खोलते हैं) लगभग 1 सेकंड।

जब यह लोड हो रहा है, यह एक सफेद स्क्रीन दिखाता है।

डेटा तैयार होने तक सफेद स्क्रीन दिखाने के बजाय क्या कोई तरीका है, मैं अपनी खुद की छवि दिखाता हूं? स्प्लैश पेज जैसा कुछ?

0
Mohammad 27 जिंदा 2020, 21:15

1 उत्तर

सबसे बढ़िया उत्तर

अगर आप मुख्य थ्रेड पर लंबे समय तक चलने वाली कार्रवाइयां करते हैं, तो आपको ANR क्रैश

प्रत्येक टुकड़े के लिए आपके लेआउट में एक लोडिंग दृश्य होना चाहिए जो शुरू में दिखाई दे, और आपका डेटा दृश्य। कुछ इस तरह:

(कोड नहीं)

FrameLayout
    loading_view (can show a progress spinner or something, size is match parent)
    content_view (probably a RecyclerView, initial visibility=GONE, size is match parent)
/FrameLayout

आपको पृष्ठभूमि थ्रेड या कोरआउटिन पर अपनी लंबी चल रही कार्रवाई करने की ज़रूरत है, और फिर यूआई में डेटा दिखाने के लिए तैयार होने पर इन दो दृश्यों की दृश्यता को स्वैप करें।

आपको अपने Fragment कोड में डेटा की लोडिंग को सीधे नहीं संभालना चाहिए, क्योंकि Fragment एक UI नियंत्रक है। Android Jetpack पुस्तकालय इस उद्देश्य के लिए ViewModel वर्ग प्रदान करते हैं। आप अपना व्यूमोडेल कुछ इस तरह स्थापित करेंगे। इस उदाहरण में, MyData कुछ भी हो सकता है। आपके मामले में यह किसी चीज़ की सूची या सेट होने की संभावना है।

class MyBigDataViewModel(application: Application): AndroidViewModel(application) {

    private val _myBigLiveData = MutableLiveData<MyData>()
    val myBigLiveData: LiveData<MyData>() = _myBigLiveData 

    init {
        loadMyBigData()
    }

    private fun loadMyBigData() {
        viewModelScope.launch { // start a coroutine in the main UI thread
            val myData: MyData = withContext(Dispatchers.Default) { 
                // code in this block is done on background coroutine
                // Calculate MyData here and return it from lambda
                // If you have a big for-loop, you might want to call yield()
                // inside the loop to allow this job to be cancelled early if
                // the Activity is closed before loading was finished.
                //...
                return@withContext calculatedData
            }

            // LiveData can only be accessed from the main UI thread so
            // we do it outside the withContext block
            _myBigLiveData.value = myData
        }
    }

}

फिर अपने टुकड़े में, आप यूआई को तैयार होने पर अपडेट करने के लिए लाइव डेटा देखते हैं। नीचे दी गई fragment-ktx लाइब्रेरी का उपयोग किया गया है, जिसे आपको अपने प्रोजेक्ट में जोड़ने की आवश्यकता है। आपको निश्चित रूप से ViewModel पर दस्तावेज़ पढ़ना चाहिए।

class MyFragment: Fragment() {

    // ViewModels should not be instantiated directly, or they won't be scoped to the
    // UI life cycle correctly. The activityViewModels delegate handles instantiation for us.
    private val model: MyBigDataViewModel by activityViewModels()

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        model.myBigLiveData.observe(this, Observer<MyData> { myData ->
            loading_view.visibility = View.GONE
            content_view.visibility = View.VISIBLE
            // use myData to update the view content
        })
    }
}
1
Tenfour04 28 जिंदा 2020, 16:21