लाइफ-शेयरिंग प्रश्न

प्रत्येक डेवलपर गतिविधि जीवन चक्र के बारे में सवालों के साथ आया: एक बाइंड सेवा क्या है, स्क्रीन को घुमाए जाने पर इंटरफ़ेस की स्थिति को कैसे बचाया जाए, और फ्रैगमेंट गतिविधि से कैसे भिन्न होता है।
हमने फनकार्प में समान विषयों पर प्रश्नों की एक सूची जमा की है, लेकिन कुछ बारीकियों के साथ। मैं उनमें से कुछ को आपके साथ साझा करना चाहता हूं।

1. हर कोई जानता है कि यदि आप पहले के ऊपर दूसरी गतिविधि खोलते हैं और स्क्रीन को घुमाते हैं, तो जीवन चक्र कॉल श्रृंखला इस तरह दिखाई देगी:

और दूसरी गतिविधि पारदर्शी होने पर क्या होगा?

निर्णय

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

2. कोई भी एप्लिकेशन डायनेमिक रूप से एक दृश्य को जोड़े बिना नहीं कर सकता है, लेकिन कभी-कभी आपको एक ही दृश्य को विभिन्न स्क्रीन के बीच ले जाना होगा। क्या एक ही वस्तु को दो अलग-अलग गतिविधियों में एक साथ जोड़ा जा सकता है? यदि मैं इसे एप्लिकेशन संदर्भ के साथ बनाता हूं और एक ही समय में इसे विभिन्न गतिविधियों में जोड़ना चाहता हूं तो क्या होगा?

इसकी आवश्यकता क्यों है?
"बहुत सुखद नहीं" पुस्तकालय हैं जो कस्टम दृश्यों के अंदर महत्वपूर्ण व्यावसायिक तर्क रखते हैं, और प्रत्येक नई गतिविधि के भीतर इन विचारों को फिर से बनाना एक बुरा काम है, क्योंकि मैं एक डेटा सेट करना चाहता हूं।

निर्णय

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

private void addViewInner(View child, int index, LayoutParams params, boolean preventRequestLayout) { ... if (child.getParent() != null) { throw new IllegalStateException("The specified child already has a parent. " + "You must call removeView() on the child's parent first."); } ... } 

उदाहरण के लिए, आप ActivLifecycleCallbacks की सदस्यता ले सकते हैं, चालू गतिविधि से onStop (निष्कासन) को हटा सकते हैं, अगले खुले में AddStart (addView) जोड़ें।

3. टुकड़ा जोड़ के माध्यम से और प्रतिस्थापन के माध्यम से जोड़ा जा सकता है। और जीवन चक्र विधियों को कॉल करने के क्रम के संदर्भ में इन दो विकल्पों में क्या अंतर है? उनमें से प्रत्येक के फायदे क्या हैं?

निर्णय

भले ही आप प्रतिस्थापित के माध्यम से एक टुकड़ा जोड़ते हैं, इसका मतलब यह नहीं है कि यह पूरी तरह से बदल दिया गया है। इसका मतलब यह है कि इस बिंदु पर कंटेनर में इसके दृश्य को बदल दिया जाएगा, इसलिए, onDestroyView को वर्तमान टुकड़े के लिए बुलाया जाएगा, और लौटने पर onCreateView को फिर से कॉल किया जाएगा।

यह बहुत खेल के नियमों को बदल देता है। आपको onDestroyView में UI से जुड़े सभी नियंत्रकों और वर्गों को अलग करना होगा। टुकड़ा और दृश्य (सूचियों, आदि) को भरने के लिए आवश्यक डेटा की प्राप्ति को स्पष्ट रूप से अलग करना आवश्यक है, क्योंकि दृश्य को भरने और तोड़ने से डेटा प्राप्त करने (डेटाबेस से कुछ डेटा पढ़ने) की तुलना में अधिक बार होगा।

राज्य पुनर्प्राप्ति के साथ बारीकियां भी हैं: उदाहरण के लिए, onSaveInstanceState कभी-कभी onDestroyView के बाद आता है। इसके अलावा, यह ध्यान में रखा जाना चाहिए कि अगर null onViewStateRestored में आया है, तो इसका मतलब है कि आपको कुछ भी पुनर्स्थापित करने की आवश्यकता नहीं है, लेकिन डिफ़ॉल्ट स्थिति पर रीसेट नहीं है।

अगर हम ऐड और रिप्लेस के बीच की सुविधा के बारे में बात करते हैं, तो मेमोरी को और अधिक किफायती है यदि आपके पास गहरा नेविगेशन है (हमारे पास उत्पाद केपीआई में से एक का उपयोगकर्ता नेविगेशन गहराई है)। टूलबार को प्रतिस्थापित करने के लिए इसे बदलना अधिक सुविधाजनक है, क्योंकि onCreateView के बाद आप इसे पुन: उपयोग कर सकते हैं। ऐड के फायदों से: जीवन चक्र के साथ कम समस्याएं, जब आप वापस लौटते हैं, तो मैं दृश्य को दोबारा नहीं बनाता हूं और किसी भी चीज को फिर से भरने की जरूरत नहीं है।

4. कभी-कभी आपको अभी भी सीधे सेवाओं के साथ और यहां तक ​​कि बाइंड सेवाओं के साथ काम करना पड़ता है। गतिविधि इन सेवाओं में से एक (केवल एक गतिविधि) के साथ सहभागिता करती है। यह सेवा से जुड़ता है और डेटा को इसमें स्थानांतरित करता है। जब आप स्क्रीन को चालू करते हैं, तो हमारी गतिविधि नष्ट हो जाती है, और हम इस सेवा से रिबाउंड करने के लिए बाध्य हैं। लेकिन अगर कोई कनेक्शन नहीं है, तो सेवा नष्ट हो जाती है, और मोड़ के बाद पूरी तरह से अलग सेवा होगी। यह सुनिश्चित करने के लिए कि जब आप सेवा चालू करते हैं, तो लाइव रहता है?

निर्णय

यदि आप एक सुंदर समाधान जानते हैं, तो टिप्पणियों में लिखें। केवल कुछ ऐसा ही दिमाग में आता है:

  @Override protected void onDestroy() { super.onDestroy(); ThreadsUtils.postOnUiThread(new Runnable() { @Override public void run() { unbindService(mConnection); } }); } 

5. हाल ही में, हमने सिंगल एक्टिविटी (उपलब्ध पुस्तकालयों में से एक का उपयोग करके) पर अपने एप्लिकेशन के अंदर नेविगेशन को रीडायरेक्ट किया। पहले, प्रत्येक एप्लिकेशन स्क्रीन एक अलग गतिविधि थी, अब नेविगेशन टुकड़ों पर काम करता है। स्टैक के बीच में गतिविधि में लौटने की समस्या को इरादे झंडे द्वारा हल किया गया था। मैं ढेर के बीच में टुकड़े में कैसे लौट सकता हूं?

निर्णय

हां, FragmentManager बॉक्स से समाधान प्रदान नहीं करता है। सिसरोन अपने भीतर भी कुछ ऐसा ही करता है:

  protected void backTo(BackTo command) { String key = command.getScreenKey(); if (key == null) { backToRoot(); } else { int index = localStackCopy.indexOf(key); int size = localStackCopy.size(); if (index != -1) { for (int i = 1; i < size - index; i++) { localStackCopy.pop(); } fragmentManager.popBackStack(key, 0); } else { backToUnexisting(command.getScreenKey()); } } } 

6. इसके अलावा, हाल ही में हमने ViewPager के रूप में इस तरह के एक अकुशल और जटिल घटक से छुटकारा पाया, क्योंकि इसके साथ बातचीत करने का तर्क बहुत जटिल है, और कुछ मामलों में टुकड़ों का व्यवहार अप्रत्याशित है। कुछ अंशों में, हमने आंतरिक अंशों का उपयोग किया। RecycleView तत्वों के अंदर टुकड़ों का उपयोग करते समय क्या होता है?

निर्णय

सामान्य तौर पर, कुछ भी गलत नहीं होगा। टुकड़े को बिना किसी समस्या के जोड़ा और प्रदर्शित किया जाएगा। केवल एक चीज जिसका हम सामना कर रहे हैं वह है इसके जीवन चक्र के साथ विसंगतियां। ViewPager पर कार्यान्वयन सेटयूज़रविजिहिंट के माध्यम से टुकड़ों के जीवन चक्र का प्रबंधन करता है, और RecycleView टुकड़ों की वास्तविक दृश्यता और पहुंच के बारे में सोचने के बिना सब कुछ माथे करता है।

7. सभी इसी कारण से हमने ViewPager से स्विच किया, हम राज्य को बहाल करने की समस्या में भाग गए। टुकड़ों के मामले में, इसे फ्रेमवर्क द्वारा लागू किया गया था: सही स्थानों पर, हमने बस onSaveInstanceState को फिर से परिभाषित किया और बंडल के सभी आवश्यक डेटा को सहेजा। जब आप ViewPager को फिर से बनाते हैं, तो सभी टुकड़े FragmentManager द्वारा बहाल कर दिए गए और अपना राज्य वापस कर दिया। RecycleView और इसके ViewHolder के साथ क्या करना है?

निर्णय

"आपको डेटाबेस को सब कुछ लिखना होगा और हर बार इसे पढ़ना होगा," आप कहते हैं। या बचत राज्य के लिए तर्क बाहर होना चाहिए, और सूची सिर्फ एक प्रदर्शन है। एक आदर्श दुनिया में यह है। लेकिन हमारे मामले में, सूची का प्रत्येक तत्व अपने स्वयं के तर्क के साथ एक जटिल स्क्रीन है। इसलिए, मुझे अपनी बाइक को "व्यूपेजर और टुकड़े के रूप में एक ही तर्क करना" की शैली में आविष्कार करना था:

 public class RecycleViewGalleryAdapter extends RecyclerView.Adapter<GalleryItemViewHolder> implements GalleryAdapter { private static final String RV_STATE_KEY = "RV_STATE"; @Nullable private Bundle mSavedState; @Override public void onBindViewHolder(GalleryItemViewHolder holder, int position) { if (holder.isAttached()) { holder.detach(); } holder.attach(createArgs(position, getItemViewType(position))); restoreItemState(holder); } @Override public void saveState(Bundle bundle) { Bundle adapterState = new Bundle(); saveItemsState(adapterState); bundle.putBundle(RV_STATE_KEY, adapterState); } @Override public void restoreState(@Nullable Bundle bundle) { if (bundle == null) { return; } mSavedState = bundle.getBundle(RV_STATE_KEY); } private void restoreItemState(GalleryItemViewHolder holder) { if (mSavedState == null) { holder.restoreState(null); return; } String stateKey = String.valueOf(holder.getGalleryItemId()); Bundle state = mSavedState.getBundle(stateKey); if (state == null) { holder.restoreState(null); mSavedState = null; return; } holder.restoreState(state); mSavedState.remove(stateKey); } private void saveItemsState(Bundle outState) { GalleryItemHolder holder = getCurrentGalleryViewItem(); saveItemState(outState, (GalleryItemViewHolder) holder); } private void saveItemState(Bundle bundle, GalleryItemViewHolder holder) { Bundle itemState = new Bundle(); holder.saveState(itemState); bundle.putBundle(String.valueOf(holder.getGalleryItemId()), itemState); } } 

Fragment.onSaveInstanceState पर हम उन धारकों की स्थिति पढ़ते हैं जिनकी हमें आवश्यकता है और उन्हें बंडल में रखें। धारकों को फिर से बनाते समय, हमें बचा हुआ बंडल मिलता है और ऑनबोर्ड व्यू पर हम धारकों के अंदर पाए गए राज्यों को पास करते हैं:

8. इससे हमें क्या खतरा है?

  @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity); ViewGroup root = findViewById(R.id.default_id); ViewGroup view1 = new LinearLayout(this); view1.setId(R.id.default_id); root.addView(view1); ViewGroup view2 = new FrameLayout(this); view2.setId(R.id.default_id); view1.addView(view2); ViewGroup view3 = new RelativeLayout(this); view3.setId(R.id.default_id); view2.addView(view3); } 

निर्णय

वास्तव में, इसमें कुछ भी गलत नहीं है। उसी RecycleView में, एक ही आईडी वाले तत्वों की सूची संग्रहीत की जाती है। हालांकि, वहाँ अभी भी एक छोटी सी बारीकियों है:

  @Override protected <T extends View> T findViewTraversal(@IdRes int id) { if (id == mID) { return (T) this; } final View[] where = mChildren; final int len = mChildrenCount; for (int i = 0; i < len; i++) { View v = where[i]; if ((v.mPrivateFlags & PFLAG_IS_ROOT_NAMESPACE) == 0) { v = v.findViewById(id); if (v != null) { return (T) v; } } } return null; } 

यह ध्यान से होना चाहिए अगर हमारे पास पदानुक्रम में एक ही आईडी वाले तत्व हैं, क्योंकि यह हमेशा पाया जाने वाला पहला तत्व है जिसे हमेशा लौटाया जाता है, और findViewById के विभिन्न स्तरों पर इसे अलग-अलग ऑब्जेक्ट कहा जा सकता है।

9. जब आप स्क्रीन को घुमाते हैं तो आप बहुत ज्यादा ट्रांसलेरेशन से गिर जाते हैं (हां, यहां हमारा ViewPager अभी भी अप्रत्यक्ष रूप से दोषी है)। अपराधी को कैसे ढूंढे?

निर्णय

यह काफी सरल है: अनुप्रयोग पर ActivLifecycleCallbacks लटकाएं, सभी onActivitySaveInstanceState को पकड़ें और बंडल के अंदर स्थित सब कुछ पार्स करें। वहां आप इस गतिविधि के अंदर सभी दृश्यों और सभी टुकड़ों की स्थिति प्राप्त कर सकते हैं।

नीचे एक उदाहरण है कि हमें बंडल से टुकड़ों का राज्य कैसे मिलता है:

 /** * Tries to find saved [FragmentState] in bundle using 'android:support:fragments' key. */ fun Bundle.getFragmentsStateList(): List<FragmentBundle>? { try { val fragmentManagerState: FragmentManagerState? = getParcelable("android:support:fragments") val active = fragmentManagerState?.mActive ?: return emptyList() return active.filter { it.mSavedFragmentState != null }.map { fragmentState -> FragmentBundle(fragmentState.mClassName, fragmentState.mSavedFragmentState) } } catch (throwable: Throwable) { Assert.fail(throwable) return null } } fun init() { application.registerActivityLifecycleCallbacks(object : SimpleActivityLifecycleCallback() { override fun onActivitySaveInstanceState(activity: Activity, outState: Bundle?) { super.onActivitySaveInstanceState(activity, outState) outState?.let { ThreadsUtils.runOnMainThread { trackActivitySaveState(activity, outState) } } } }) } @MainThread private fun trackActivitySaveState(activity: Activity, outState: Bundle) { val sizeInBytes = outState.getSizeInBytes() val fragmentsInfos = outState.getFragmentsStateList() ?.map { mapFragmentsSaveInstanceSaveInfo(it) } ... } 

अगला, हम बस बंडल के आकार की गणना करते हैं और इसे लॉग करते हैं:

  fun Bundle.getSizeInBytes(): Int { val parcel = Parcel.obtain() return try { parcel.writeValue(this) parcel.dataSize() } finally { parcel.recycle() } } 

10. मान लीजिए कि हमारे पास एक गतिविधि और उस पर निर्भरता का एक समूह है। कुछ शर्तों के तहत, हमें इन निर्भरताओं के एक सेट को फिर से बनाने की आवश्यकता है (उदाहरण के लिए, एक और यूआई के साथ एक निश्चित प्रयोग पर क्लिक करके)। हम इसे कैसे लागू करेंगे?

निर्णय

बेशक, आप झंडे के साथ छेड़छाड़ कर सकते हैं और इसे इरादे के लॉन्च के माध्यम से गतिविधि के कुछ प्रकार के "बैसाखी" को फिर से शुरू कर सकते हैं। लेकिन वास्तव में, सब कुछ बहुत सरल है - गतिविधि में एक बहुआयामी विधि है।

सबसे अधिक संभावना है, इस ज्ञान का अधिकांश हिस्सा आपके लिए उपयोगी नहीं होगा, क्योंकि आप उनमें से प्रत्येक को अच्छे जीवन से नहीं आते हैं। हालांकि, उनमें से कुछ अच्छी तरह से प्रदर्शित करते हैं कि एक व्यक्ति कैसे जानता है कि कैसे समाधान करना और प्रस्ताव करना है। हम इंटरव्यू में इसी तरह के सवालों का इस्तेमाल करते हैं। यदि आपके पास दिलचस्प कार्य हैं जो आपको साक्षात्कार में हल करने के लिए कहा गया था, या आपने उन्हें स्वयं सेट किया, तो उन्हें टिप्पणियों में लिखें - चर्चा करना दिलचस्प होगा!