Android आर्किटेक्चर के लिए सुझाव

इस पेज पर, आर्किटेक्चर के लिए सबसे सही तरीके और सुझाव दिए गए हैं. अपने ऐप्लिकेशन की क्वालिटी, मज़बूती, और बढ़ाए जा सकने की योग्यता को बेहतर बनाने के लिए, इन्हें अपनाएं. इनकी मदद से, ऐप्लिकेशन को मैनेज करना और उसकी जांच करना भी आसान हो जाता है.

सबसे सही तरीकों को विषय के हिसाब से ग्रुप किया गया है. हर सुझाव की प्राथमिकता से पता चलता है कि वह कितना अहम है. प्राथमिकता की सूची इस तरह है:

  • इसका सुझाव दिया जाता है: इस तरीके को तब तक लागू करें, जब तक यह आपके तरीके से पूरी तरह से अलग न हो.
  • सुझाव: इस तरीके से आपके ऐप्लिकेशन की परफ़ॉर्मेंस बेहतर हो सकती है.
  • ज़रूरी नहीं: कुछ मामलों में, इस तरीके से आपके ऐप्लिकेशन को बेहतर बनाया जा सकता है.

लेयर्ड आर्किटेक्चर

हमारा सुझाव है कि लेयर्ड आर्किटेक्चर का इस्तेमाल करें. इससे अलग-अलग समस्याओं को अलग-अलग तरीके से हल किया जा सकता है. यह डेटा मॉडल से यूज़र इंटरफ़ेस (यूआई) को चलाता है, एकमात्र भरोसेमंद सोर्स के सिद्धांत का पालन करता है, और एक ही दिशा में डेटा फ़्लो के सिद्धांतों का पालन करता है. लेयर्ड आर्किटेक्चर के लिए, यहां कुछ सबसे सही तरीके दिए गए हैं:

सुझाव ब्यौरा
साफ़ तौर पर तय की गई डेटा लेयर का इस्तेमाल करें. डेटा लेयर, ऐप्लिकेशन के डेटा को बाकी ऐप्लिकेशन के लिए उपलब्ध कराती है. इसमें आपके ऐप्लिकेशन के ज़्यादातर कारोबारी नियम शामिल होते हैं.
  • डेटा स्टोर करने की जगहें बनाएं, भले ही उनमें सिर्फ़ एक डेटा सोर्स हो.
  • छोटे ऐप्लिकेशन में, डेटा लेयर टाइप को data पैकेज या मॉड्यूल में रखा जा सकता है.
साफ़ तौर पर तय की गई यूज़र इंटरफ़ेस (यूआई) लेयर का इस्तेमाल करें. यूज़र इंटरफ़ेस (यूआई) लेयर, स्क्रीन पर ऐप्लिकेशन का डेटा दिखाती है. साथ ही, यह उपयोगकर्ता के इंटरैक्शन के लिए मुख्य पॉइंट के तौर पर काम करती है. अपने ऐप्लिकेशन का यूज़र इंटरफ़ेस (यूआई) बनाने के लिए, Jetpack Compose का इस्तेमाल करने का सुझाव दिया जाता है. यह एक आधुनिक टूलकिट है.
  • छोटे ऐप्लिकेशन में, डेटा लेयर टाइप को ui पैकेज या मॉड्यूल में रखा जा सकता है.
यूज़र इंटरफ़ेस (यूआई) लेयर के सबसे सही तरीकों के बारे में ज़्यादा जानने के लिए, यूज़र इंटरफ़ेस (यूआई) लेयर देखें.
डेटा लेयर से ऐप्लिकेशन डेटा को एक्सपोज़ करने के लिए, रिपॉज़िटरी का इस्तेमाल करें.

पक्का करें कि यूज़र इंटरफ़ेस (यूआई) लेयर के कॉम्पोनेंट, जैसे कि कंपोज़ेबल या ViewModel, डेटा सोर्स से सीधे तौर पर इंटरैक्ट न करें. डेटा सोर्स के उदाहरणों में ये शामिल हैं:

  • डेटाबेस, डेटास्टोर, SharedPreferences, और Firebase API.
  • जीपीएस से जगह की जानकारी देने वाली कंपनियां.
  • ब्लूटूथ डेटा उपलब्ध कराने वाली कंपनियां.
  • नेटवर्क कनेक्टिविटी की स्थिति बताने वाली सेवा.
कोरूटीन और फ़्लो का इस्तेमाल करें. लेयर के बीच कम्यूनिकेट करने के लिए, कोरूटीन और फ़्लो का इस्तेमाल करें.

कोरूटीन के सबसे सही तरीकों के बारे में ज़्यादा जानने के लिए, Android में कोरूटीन के लिए सबसे सही तरीके देखें.

डोमेन लेयर का इस्तेमाल करें. अगर आपको कई ViewModel में डेटा लेयर के साथ इंटरैक्ट करने वाले कारोबारी नियम को फिर से इस्तेमाल करना है, तो इस्तेमाल के उदाहरणों के साथ डोमेन लेयर का इस्तेमाल करें. इसके अलावा, अगर आपको किसी ViewModel के कारोबारी नियम की जटिलता को कम करना है, तो भी इसका इस्तेमाल किया जा सकता है

यूज़र इंटरफ़ेस (यूआई) लेयर

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

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

ViewModel के सबसे सही तरीकों के बारे में ज़्यादा जानने के लिए, आर्किटेक्चर से जुड़े सुझाव देखें.

ViewModel के फ़ायदों के बारे में ज़्यादा जानने के लिए, कारोबारी नियम के स्टेट होल्डर के तौर पर ViewModel लेख पढ़ें.

लाइफ़साइकल के हिसाब से यूज़र इंटरफ़ेस (यूआई) की स्थिति का कलेक्शन इस्तेमाल करें. लाइफ़साइकल के हिसाब से काम करने वाले सही कोरूटीन बिल्डर, collectAsStateWithLifecycle का इस्तेमाल करके, यूज़र इंटरफ़ेस (यूआई) से यूज़र इंटरफ़ेस (यूआई) की स्थिति इकट्ठा करें.

collectAsStateWithLifecycle के बारे में ज़्यादा जानें.

ViewModel से यूज़र इंटरफ़ेस (यूआई) पर इवेंट न भेजें. ViewModel में इवेंट को तुरंत प्रोसेस करें और इवेंट को हैंडल करने के नतीजे के साथ, स्थिति को अपडेट करें. यूज़र इंटरफ़ेस (यूआई) इवेंट के बारे में ज़्यादा जानने के लिए, ViewModel इवेंट मैनेज करना लेख पढ़ें.
सिंगल-ऐक्टिविटी ऐप्लिकेशन का इस्तेमाल करें. अगर आपके ऐप्लिकेशन में एक से ज़्यादा स्क्रीन हैं, तो स्क्रीन के बीच नेविगेट करने और अपने ऐप्लिकेशन पर डीप लिंक करने के लिए, नेविगेशन 3 का इस्तेमाल करें.
Jetpack Compose का इस्तेमाल करें. फ़ोन, टैबलेट, फ़ोल्ड किए जा सकने वाले डिवाइसों, और Wear OS के लिए नए ऐप्लिकेशन बनाने के लिए, Jetpack Compose का इस्तेमाल करें.

यहां दिए गए स्निपेट में, लाइफ़साइकल के हिसाब से यूज़र इंटरफ़ेस (यूआई) की स्थिति को इकट्ठा करने का तरीका बताया गया है:

  @Composable
  fun MyScreen(
      viewModel: MyViewModel = viewModel()
  ) {
      val uiState by viewModel.uiState.collectAsStateWithLifecycle()
  }

ViewModel

ViewModels, यूज़र इंटरफ़ेस (यूआई) की स्थिति उपलब्ध कराने और डेटा लेयर को ऐक्सेस करने के लिए ज़िम्मेदार होते हैं. ViewModels के लिए, यहां कुछ सबसे सही तरीके दिए गए हैं:

सुझाव ब्यौरा
ViewModels को Android लाइफ़साइकल से अलग रखें. ViewModels में, लाइफ़साइकल से जुड़े किसी भी टाइप का रेफ़रंस न रखें. Activity, Context या Resources को डिपेंडेंसी के तौर पर पास न करें. अगर ViewModel में किसी चीज़ को Context की ज़रूरत है, तो ध्यान से देखें कि वह सही लेयर में है या नहीं.
कोरूटीन और फ़्लो का इस्तेमाल करें.

ViewModel, डेटा या डोमेन लेयर के साथ इंटरैक्ट करने के लिए, इनका इस्तेमाल करता है:

  • ऐप्लिकेशन का डेटा पाने के लिए Kotlin फ़्लो
  • viewModelScope का इस्तेमाल करके कार्रवाइयां करने के लिए, suspend फ़ंक्शन
स्क्रीन लेवल पर ViewModels का इस्तेमाल करें.

यूआई के फिर से इस्तेमाल किए जा सकने वाले हिस्सों में, ViewModel का इस्तेमाल न करें. आपको ViewModels का इस्तेमाल इनमें करना चाहिए:

  • स्क्रीन-लेवल कंपोज़ेबल
  • Jetpack Navigation का इस्तेमाल करते समय डेस्टिनेशन या ग्राफ़

ज़्यादा जटिल कंपोज़ेबल या स्थिति के आधार पर डाइनैमिक व्यवहार वाले कंपोज़ेबल के लिए, rememberViewModelStoreOwner() का इस्तेमाल करें. इससे ViewModel को सीधे कंपोज़ेबल की कॉल साइट पर स्कोप किया जा सकता है.

फिर से इस्तेमाल किए जा सकने वाले यूज़र इंटरफ़ेस (यूआई) कॉम्पोनेंट में, प्लेन स्टेट होल्डर क्लास का इस्तेमाल करें. फिर से इस्तेमाल किए जा सकने वाले यूज़र इंटरफ़ेस (यूआई) कॉम्पोनेंट में जटिलता को मैनेज करने के लिए, प्लेन स्टेट होल्डर क्लास का इस्तेमाल करें. ऐसा करने पर, स्टेट को होइस्ट किया जा सकता है और बाहरी तौर पर कंट्रोल किया जा सकता है.
AndroidViewModel का इस्तेमाल न करें. ViewModel क्लास का इस्तेमाल करें, न कि AndroidViewModel का. ViewModel में Application क्लास का इस्तेमाल न करें. इसके बजाय, डिपेंडेंसी को यूज़र इंटरफ़ेस (यूआई) या डेटा लेयर पर ले जाएं.
यूज़र इंटरफ़ेस (यूआई) की स्थिति को एक्सपोज़ करना. अपने ViewModels को uiState नाम की एक प्रॉपर्टी के ज़रिए, यूज़र इंटरफ़ेस (यूआई) को डेटा दिखाने की अनुमति दें. अगर यूज़र इंटरफ़ेस (यूआई) में डेटा के कई अलग-अलग हिस्से दिखते हैं, तो वीएम, यूज़र इंटरफ़ेस (यूआई) की कई स्टेट प्रॉपर्टी दिखा सकता है.
  • uiState को StateFlow बनाएं.
  • अगर डेटा, हैरारकी की अन्य लेयर से डेटा की स्ट्रीम के तौर पर आता है, तो WhileSubscribed(5000) नीति के साथ stateIn ऑपरेटर का इस्तेमाल करके uiState बनाएं. (कोड का यह उदाहरण देखें.)
  • डेटा लेयर से डेटा की कोई स्ट्रीम न आने वाले आसान मामलों में, MutableStateFlow को ऐसे StateFlow के तौर पर इस्तेमाल किया जा सकता है जिसमें बदलाव नहीं किया जा सकता.
  • ${Screen}UiState को डेटा क्लास के तौर पर चुना जा सकता है. इसमें डेटा, गड़बड़ियां, और लोडिंग सिग्नल शामिल हो सकते हैं. अगर अलग-अलग स्टेटस खास हैं, तो यह क्लास सील की गई क्लास भी हो सकती है.

यहां दिए गए स्निपेट में, ViewModel से यूज़र इंटरफ़ेस (यूआई) की स्थिति को एक्सपोज़ करने का तरीका बताया गया है:

@HiltViewModel
class BookmarksViewModel @Inject constructor(
    newsRepository: NewsRepository
) : ViewModel() {

    val feedState: StateFlow<NewsFeedUiState> =
        newsRepository
            .getNewsResourcesStream()
            .mapToFeedState(savedNewsResourcesState)
            .stateIn(
                scope = viewModelScope,
                started = SharingStarted.WhileSubscribed(5_000),
                initialValue = NewsFeedUiState.Loading
            )

    // ...
}

लाइफ़साइकल

गतिविधि पूरी होने की प्रोसेस के साथ काम करने के लिए, सबसे सही तरीके अपनाएं:

सुझाव ब्यौरा
Activity लाइफ़साइकल कॉलबैक को बदलने के बजाय, कंपोज़ेबल में लाइफ़साइकल के हिसाब से काम करने वाले इफ़ेक्ट इस्तेमाल करें.

यूज़र इंटरफ़ेस (यूआई) से जुड़े टास्क चलाने के लिए, Activity लाइफ़साइकल के तरीकों, जैसे कि onResume को ओवरराइड न करें. इसके बजाय, Compose के LifecycleEffects या लाइफ़साइकल के हिसाब से काम करने वाले कोरूटीन स्कोप का इस्तेमाल करें:

  • जब आपकी गतिविधि शुरू और बंद हो, तब सिंक्रोनस काम करने के लिए LifecycleStartEffect का इस्तेमाल करें.
  • जब आपकी गतिविधि फिर से शुरू और रोकी जाए, तब सिंक्रोनस काम करने के लिए LifecycleResumeEffect का इस्तेमाल करें.
  • लाइफ़साइकल इवेंट के जवाब में एसिंक्रोनस काम करने के लिए, repeatOnLifecycle का इस्तेमाल करें.
  • collectAsStateWithLifecycle का इस्तेमाल करके, फ़्लो से एसिंक्रोनस डेटा इकट्ठा करना.

यहां दिए गए स्निपेट में, लाइफ़साइकल की किसी खास स्थिति के हिसाब से कार्रवाइयां करने का तरीका बताया गया है:

  @Composable
  fun LocationChangedEffect(
    locationManager: LocationManager,
    onLocationChanged: (Location) -> Unit
  ) {
    val currentOnLocationChanged by rememberUpdatedState(onLocationChanged)

    LifecycleStartEffect(locationManager) {
        val listener = LocationListener { newLocation ->
            currentOnLocationChanged(newLocation)
        }

        try {
            locationManager.requestLocationUpdates(
                LocationManager.GPS_PROVIDER,
                1000L,
                1f,
                listener,
            )
        } catch (e: SecurityException) {
            // TODO: Handle missing permissions
        }

        onStopOrDispose {
            locationManager.removeUpdates(listener)
        }
    }
  }

डिपेंडेंसी हैंडल करता है

कॉम्पोनेंट के बीच डिपेंडेंसी मैनेज करते समय, सबसे सही तरीके अपनाएं:

सुझाव ब्यौरा
डिपेंडेंसी इंजेक्शन का इस्तेमाल करें. डिपेंडेंसी इंजेक्शन के सबसे सही तरीके इस्तेमाल करें. खास तौर पर, जब भी संभव हो, कंस्ट्रक्टर इंजेक्शन का इस्तेमाल करें.
ज़रूरत पड़ने पर, किसी कॉम्पोनेंट के लिए स्कोप तय करें. जब टाइप में ऐसा डेटा शामिल हो जिसे शेयर करना ज़रूरी हो या टाइप को शुरू करना महंगा हो और ऐप्लिकेशन में इसका बड़े पैमाने पर इस्तेमाल किया जाता हो, तो उसे डिपेंडेंसी कंटेनर तक सीमित करें.
Hilt का इस्तेमाल करें. आसान ऐप्लिकेशन में Hilt या मैन्युअल डिपेंडेंसी इंजेक्शन का इस्तेमाल करें. अगर आपका प्रोजेक्ट काफ़ी जटिल है, तो Hilt का इस्तेमाल करें. उदाहरण के लिए, अगर इसमें इनमें से कोई भी चीज़ शामिल है:
  • ViewModels की मदद से कई स्क्रीन मैनेज करना
  • WorkManager का इस्तेमाल करता है
  • इसमें ViewModels हैं, जिन्हें नेविगेशन की पिछली गतिविधियों के लिए स्कोप किया गया है

जांच करना

टेस्टिंग के लिए, यहां कुछ सबसे सही तरीके दिए गए हैं:

सुझाव ब्यौरा
जानें कि क्या टेस्ट करना है.

अगर प्रोजेक्ट "नमस्ते" ऐप्लिकेशन जितना आसान नहीं है, तो उसकी जांच करें. कम से कम ये चीज़ें शामिल करें:

  • फ़्लो के साथ-साथ, ViewModels के लिए यूनिट टेस्ट
  • डेटा लेयर की इकाइयों के लिए यूनिट टेस्ट—यानी कि डेटा स्टोर करने की जगहें और डेटा सोर्स
  • यूआई नेविगेशन टेस्ट, जो सीआई में रिग्रेशन टेस्ट के तौर पर काम आते हैं
  • ऐप्लिकेशन के स्टार्टअप और यूज़र इंटरफ़ेस (यूआई) रेंडरिंग को मेज़र करने के लिए, Macrobenchmark का इस्तेमाल करके परफ़ॉर्मेंस टेस्ट
मॉक के बजाय फ़ेक का इस्तेमाल करें. फ़ेक का इस्तेमाल करने के बारे में ज़्यादा जानने के लिए, Android में टेस्ट डबल्स का इस्तेमाल करना लेख पढ़ें.
StateFlows की जांच करना. StateFlow की जांच करते समय, ये काम करें:

ज़्यादा जानकारी के लिए, Android में क्या टेस्ट करना है और अपने Compose लेआउट को टेस्ट करना लेख पढ़ें.

परफ़ॉर्मेंस

परफ़ॉर्मेंस को बेहतर बनाने के लिए, यहां कुछ सबसे सही तरीके दिए गए हैं:

सुझाव ब्यौरा
अपने ऐप्लिकेशन का साइज़ छोटा करने और उसे ऑप्टिमाइज़ करने के लिए, R8 का इस्तेमाल करें. अपने बिल्ड कॉन्फ़िगरेशन में, फ़ुल मोड में R8 को चालू करें. इससे, इस्तेमाल न होने वाले कोड को हटाया जा सकता है, क्लास को छिपाया जा सकता है, और कोड को फिर से लिखा जा सकता है, ताकि रनटाइम की परफ़ॉर्मेंस को बेहतर बनाया जा सके.
बेसलाइन प्रोफ़ाइलें और स्टार्टअप प्रोफ़ाइलें लागू करें. ज़रूरी कोड पाथ को पहले से कंपाइल करने के लिए, बेसलाइन प्रोफ़ाइलें और स्टार्टअप प्रोफ़ाइलें जनरेट करें. इससे ऐप्लिकेशन के खुलने में लगने वाला समय (टीटीआईडी और टीटीएफ़डी) काफ़ी कम हो जाता है. साथ ही, जैंक और एएनआर की गड़बड़ियां भी कम हो जाती हैं.
Macrobenchmark की मदद से परफ़ॉर्मेंस की जांच करें. अपने ऐप्लिकेशन की परफ़ॉर्मेंस की जांच करने और रिग्रेशन को रोकने के लिए, Macrobenchmark लाइब्रेरी का इस्तेमाल करें.

मॉडल

अपने ऐप्लिकेशन में मॉडल डेवलप करते समय, इन सबसे सही तरीकों को अपनाएं:

सुझाव ब्यौरा
जटिल ऐप्लिकेशन में हर लेयर के लिए एक मॉडल बनाएं.

जटिल ऐप्लिकेशन में, ज़रूरत के हिसाब से अलग-अलग लेयर या कॉम्पोनेंट में नए मॉडल बनाएं. नीचे दिए गए उदाहरण देखें:

  • रिमोट डेटा सोर्स, नेटवर्क से मिलने वाले मॉडल को एक आसान क्लास में मैप कर सकता है. इसमें सिर्फ़ वह डेटा होता है जिसकी ऐप्लिकेशन को ज़रूरत होती है.
  • डेटा स्टोर करने की जगहें, डीएओ मॉडल को आसान डेटा क्लास में मैप कर सकती हैं. इसके लिए, सिर्फ़ उस जानकारी की ज़रूरत होती है जो यूज़र इंटरफ़ेस (यूआई) लेयर को चाहिए.
  • ViewModel, UiState क्लास में डेटा लेयर मॉडल शामिल कर सकता है.

नाम रखने के तरीके

अपने कोड बेस को नाम देते समय, आपको इन सबसे सही तरीकों के बारे में पता होना चाहिए:

सुझाव ब्यौरा
नाम रखने के तरीके.
ज़रूरी नहीं
मेथड के नाम के लिए, वर्ब फ़्रेज़ का इस्तेमाल करें. उदाहरण के लिए, makePayment().
प्रॉपर्टी को नाम देना.
ज़रूरी नहीं
प्रॉपर्टी के नाम के लिए, संज्ञा वाले वाक्यांशों का इस्तेमाल करें. उदाहरण के लिए, inProgressTopicSelection.
डेटा स्ट्रीम को नाम देना.
ज़रूरी नहीं
जब कोई क्लास, फ़्लो स्ट्रीम या कोई अन्य स्ट्रीम दिखाती है, तो नाम रखने का तरीका get{model}Stream होता है. उदाहरण के लिए, getAuthorStream(): Flow<Author>. अगर फ़ंक्शन, मॉडल की सूची दिखाता है, तो मॉडल के नाम के बहुवचन का इस्तेमाल करें: getAuthorsStream(): Flow<List<Author>>.
इंटरफ़ेस के लागू होने का नाम देना.
ज़रूरी नहीं
इंटरफ़ेस के लागू होने के लिए, काम के नाम इस्तेमाल करें. अगर कोई बेहतर नाम नहीं मिलता है, तो प्रीफ़िक्स के तौर पर Default का इस्तेमाल करें. उदाहरण के लिए, NewsRepository इंटरफ़ेस के लिए, आपके पास OfflineFirstNewsRepository या InMemoryNewsRepository हो सकता है. अगर आपको कोई अच्छा नाम नहीं मिल रहा है, तो DefaultNewsRepository का इस्तेमाल करें. नकली इंप्लिमेंटेशन के प्रीफ़िक्स में Fake का इस्तेमाल करें, जैसे कि FakeAuthorsRepository.

अन्य संसाधन

Android आर्किटेक्चर के बारे में ज़्यादा जानने के लिए, यहां दिए गए अन्य संसाधन देखें:

दस्तावेज़

कॉन्टेंट देखना