lifecycleScope — یہ کیا ہے، Lifecycle سے تعلق اور Android میں کام کرنا

Android میں lifecycleScope کیا ہے؟

lifecycleScope LifecycleOwner انٹرفیس (Activity، Fragment، Service) پر ایک توسیعی پراپرٹی ہے جو جزو کے مکمل زندگی کے چکر سے منسلک ایک تیار CoroutineScope فراہم کرتی ہے۔ جب LifecycleOwner DESTROYED حالت تک پہنچتا ہے، lifecycleScope خود بخود تمام فعال کوروٹینز کو منسوخ کر دیتا ہے۔

// In Fragment or Activity
lifecycleScope.launch {
    delay(1000)
    showSnackbar("ہیلو!")
}

viewModelScope کے برعکس، lifecycleScope ہر بار LifecycleOwner کے تباہ ہونے پر منسوخ ہوتا ہے — اسکرین گھومنے سمیت۔ یہ اسے ان کاموں کے لیے مثالی بناتا ہے جو صرف اس وقت زندہ رہنے چاہئیں جب کوئی مخصوص اسکرین نظر آ رہی ہو۔

lifecycleScope کہاں دستیاب ہے

lifecycleScope ہر اس جگہ دستیاب ہے جہاں LifecycleOwner موجود ہو:

• Activity — AppCompatActivity LifecycleOwner کو وراثت میں لیتی ہے
• Fragment — Fragment LifecycleOwner کو وراثت میں لیتا ہے
• LifecycleService — زندگی کے چکر والی سروس
• ProcessLifecycleOwner — پوری ایپلیکیشن کا زندگی کا چکر
• کسٹم LifecycleOwner — کوئی بھی آبجیکٹ جو LifecycleOwner کو لاگو کرتا ہے

lifecycleScope کیسے کام کرتا ہے: Lifecycle اور خودکار منسوخی

lifecycleScope کا خودکار منسوخی کا طریقہ کار Lifecycle واقعات کو سبسکرائب کرنے پر مبنی ہے۔ جب Lifecycle CREATED سے نیچے DESTROYED پر آتا ہے، scope منسوخ ہو جاتا ہے۔

Lifecycle کی حالتیں

lifecycleScope کی داخلی ساخت

lifecycleScope کو CoroutineScope(SupervisorJob() + Dispatchers.Main.immediate) کے طور پر بنایا جاتا ہے اور Lifecycle کے اندر محفوظ کیا جاتا ہے۔ جب Lifecycle DESTROYED حالت میں منتقل ہوتا ہے، scope.cancel() کو کال کیا جاتا ہے۔ یہ طریقہ کار LifecycleEventObserver کے ذریعے لاگو کیا جاتا ہے، جو scope تک پہلی رسائی پر زندگی کے چکر کے واقعات کو سبسکرائب کرتا ہے۔

گھومنے پر رویہ

جب اسکرین گھمائی جاتی ہے، Activity تباہ (onDestroy) ہوتی ہے اور دوبارہ بنائی جاتی ہے۔ lifecycleScope پرانی Activity کے ساتھ منسوخ ہو جاتا ہے، اور نئی Activity کے لیے scope کی ایک نئی مثال بنائی جاتی ہے۔ یہ viewModelScope سے بنیادی فرق ہے، جو گھومنے پر باقی رہتا ہے۔

lifecycleScope API: launch، launchWhen اور repeatOnLifecycle

lifecycle لائبریری lifecycleScope کے ذریعے کوروٹین شروع کرنے کے کئی طریقے فراہم کرتی ہے۔ آئیے متروک طریقوں سے جدید API تک کے ارتقا کو دیکھتے ہیں۔

lifecycleScope.launch — بنیادی آغاز

سب سے آسان طریقہ lifecycleScope.launch { ... } ہے۔ کوروٹین فوری طور پر شروع ہوتی ہے اور DESTROYED پر منسوخ ہو جاتی ہے۔ تاہم، یہ UI نظر نہ آنے پر بھی کوڈ چلا سکتی ہے (مثال کے طور پر، onStop کے بعد پس منظر میں)۔ یہ ہمیشہ مطلوبہ نہیں ہوتا۔

متروک: launchWhenCreated / launchWhenStarted / launchWhenResumed

یہ طریقے Lifecycle کی مخصوص حالت سے نیچے آنے پر کوروٹین کے عمل کو روک دیتے تھے اور واپس آنے پر دوبارہ شروع کر دیتے تھے۔ تاہم، انہیں lifecycle-runtime-ktx 2.6.0 میں @Deprecated کے طور پر نشان زد کیا گیا تھا کیونکہ:

• وہ کوروٹین کو منسوخ نہیں کرتے تھے — صرف روکتے تھے
• وہ میموری استعمال کرنے والی معلق کوروٹینز کے جمع ہونے کا باعث بنتے تھے
• وہ تیز رفتار حالت کی تبدیلی پر ریس کنڈیشن پیدا کرتے تھے

جدید API: repeatOnLifecycle

repeatOnLifecycle زندگی کے چکر کے ساتھ ہم آہنگ کوروٹین شروع کرنے کا Google کا تجویز کردہ طریقہ ہے۔ یہ ہر بار جب Lifecycle مخصوص حالت تک پہنچتا ہے کوروٹین کو منسوخ اور دوبارہ شروع کرتا ہے۔

lifecycleScope.launch {
    repeatOnLifecycle(Lifecycle.State.STARTED) {
        viewModel.uiState.collect { state ->
            updateUI(state)
        }
    }
}

repeatOnLifecycle میں منتقل کردہ کوروٹین اس وقت شروع ہوتی ہے جب Lifecycle STARTED تک پہنچتا ہے اور جب یہ STARTED سے نیچے آتا ہے تو منسوخ ہو جاتی ہے۔ STARTED پر واپس آنے پر، کوروٹین شروع سے دوبارہ شروع ہوتی ہے۔ یہ محفوظ اور موثر ہے — کوئی بھی کوروٹین معلق نہیں رہتی۔

flowWithLifecycle — Flow کے لیے

زندگی کے چکر سے آگاہی کے ساتھ Flow سے ڈیٹا اکٹھا کرنے کے لیے، flowWithLifecycle آپریٹر موجود ہے۔ یہ Lifecycle کی حالت بدلنے پر خود بخود اکٹھا کرنا روکتا اور دوبارہ شروع کرتا ہے:

viewModel.uiState
    .flowWithLifecycle(lifecycle, Lifecycle.State.STARTED)
    .onEach { state -> updateUI(state) }
    .launchIn(lifecycleScope)

flowWithLifecycle آپریٹر UI پرت میں Flow کو محفوظ طریقے سے سبسکرائب کرنے کا سب سے مختصر طریقہ ہے۔

lifecycleScope استعمال کی مثالیں

آئیے Kotlin کے ساتھ Android ایپلیکیشن میں lifecycleScope کے استعمال کے تین حقیقی منظرنامے دیکھتے ہیں۔

مثال 1: صرف اسکرین نظر آنے پر لوکیشن اپ ڈیٹس کو سبسکرائب کرنا

class MapFragment : Fragment() {

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)

        lifecycleScope.launch {
            repeatOnLifecycle(Lifecycle.State.STARTED) {
                locationProvider.observeLocation().collect { loc ->
                    updateMapMarker(loc)
                }
            }
        }
    }
}

کوروٹین اس وقت شروع ہوتی ہے جب فرگمنٹ نظر آنے لگتا ہے (STARTED) اور اسکرین چھوڑنے پر منسوخ ہو جاتی ہے (STOPPED)۔ اگر صارف کسی دوسری ایپ پر سوئچ کرتا ہے، تو لوکیشن اپ ڈیٹس بیٹری خرچ نہیں کرتیں۔

مثال 2: فرگمنٹ شروع ہونے پر اینیمیشن چلانا

lifecycleScope.launch {
    repeatOnLifecycle(Lifecycle.State.RESUMED) {
        animateFadeIn(titleView)
        delay(200)
        animateSlideUp(contentView)
    }
}

اینیمیشن صرف اس وقت چلتی ہے جب فرگمنٹ پیش منظر میں ہو (RESUMED)۔ اگر صارف اینیمیشن کے دوران ایپ کو چھوٹا کرتا ہے، کوروٹین منسوخ ہو جاتی ہے، اور واپس آنے پر اینیمیشن دوبارہ شروع ہوتی ہے۔

مثال 3: نظر آنے والی اسکرین پر متواتر ڈیٹا سنک

lifecycleScope.launch {
    repeatOnLifecycle(Lifecycle.State.STARTED) {
        while (isActive) {
            syncData()
            delay(30_000L)
        }
    }
}

ڈیٹا ہر 30 سیکنڈ میں سنک ہوتا ہے، لیکن صرف اس وقت جب اسکرین نظر آ رہی ہو۔ isActive چیک کرتا ہے کہ کوروٹین منسوخ ہوئی ہے یا نہیں، اسکرین چھوڑنے پر لوپ سے محفوظ طریقے سے باہر نکلنے کا راستہ فراہم کرتا ہے۔

lifecycleScope بمقابلہ viewModelScope: استعمال کے منظرنامے

دونوں scope زندگی کے چکر سے منسلک ہیں، لیکن اس کے مختلف پہلوؤں سے۔ فرق کو سمجھنا Android ایپلیکیشن کے صحیح آرکیٹیکچر کے لیے اہم ہے۔

بنیادی فرق

viewModelScope ViewModel سے منسلک ہے، جو اسکرین گھومنے پر باقی رہتا ہے۔ lifecycleScope LifecycleOwner (Activity/Fragment) سے منسلک ہے، جو گھومنے پر تباہ اور دوبارہ بنایا جاتا ہے۔ یہ ان کے استعمال کے منظرناموں کا تعین کرتا ہے۔

lifecycleScope کب استعمال کریں

• سسٹم کے واقعات کو سبسکرائب کرنا (لوکیشن، سینسرز، کیمرہ)
• کسی مخصوص اسکرین سے منسلک اینیمیشن اور UI اثرات
• اسکرین کی نمائش کی بنیاد پر حصوں میں ڈیٹا لوڈ کرنا
• وہ کام جو اسکرین چھوڑنے پر رک جانے چاہئیں

viewModelScope کب استعمال کریں

• Repository سے ڈیٹا لوڈ کرنا
• کاروباری منطق جو گھومنے پر باقی رہنی چاہیے
• ڈیٹا کیشنگ اور پروسیسنگ
• کوئی بھی کام جس کا نتیجہ گھومنے کے بعد درکار ہو

مشترکہ استعمال

عملی طور پر، دونوں scope کا امتزاج عام ہے: viewModelScope ڈیٹا لوڈ کرتا ہے اور حالت کا انتظام کرتا ہے، جبکہ lifecycleScope زندگی کے چکر سے آگاہی کے ساتھ ViewModel سے Flow کو سبسکرائب کرتا ہے۔ ذمہ داریوں کی یہ علیحدگی جدید Android ڈیویلپمنٹ میں بہترین عمل سمجھی جاتی ہے۔

lifecycleScope کے ساتھ کام کرتے وقت عام غلطیاں

lifecycleScope استعمال کرتے وقت ڈیویلپرز کی چار سب سے عام غلطیاں دیکھتے ہیں۔

غلطی 1: ڈیٹا لوڈ کرنے کے لیے viewModelScope کی بجائے lifecycleScope استعمال کرنا

اگر آپ lifecycleScope.launch میں ڈیٹا لوڈنگ شروع کرتے ہیں، تو اسکرین گھومنے پر کوروٹین منسوخ ہو جائے گی اور ڈیٹا دوبارہ لوڈ کرنا پڑے گا۔ طویل مدتی کاموں کے لیے viewModelScope استعمال کریں۔ lifecycleScope صرف UI سے منسلک کاموں کے لیے ہے۔

غلطی 2: repeatOnLifecycle کے بغیر Flow جمع کرنا

lifecycleScope.launch کے اندر براہ راست viewModel.someFlow.collect { ... } کال کرنا اسکرین نظر نہ آنے پر بھی ڈیٹا جمع کرتا رہتا ہے۔ یہ پس منظر میں UI اپ ڈیٹس اور غیر ضروری اوور ہیڈ کا سبب بن سکتا ہے۔ ہمیشہ repeatOnLifecycle یا flowWithLifecycle استعمال کریں۔

غلطی 3: اسکرین چھوڑنے پر منسوخی کو بھولنا

اگرچہ lifecycleScope DESTROYED پر منسوخ ہوتا ہے، اچانک منسوخی پر معطلی کے مقام کے بعد کا کوڈ چل نہیں سکتا۔ جب تک آپ NonCancellable استعمال نہیں کر رہے، معطلی کال کے بعد کوڈ کے عمل پر بھروسہ نہ کریں۔

غلطی 4: repeatOnLifecycle کی بجائے متروک launchWhenStarted استعمال کرنا

launchWhenStarted اور اس کے مساوی کوروٹین کو منسوخ نہیں کرتے، صرف روکتے ہیں۔ اگر اسکرین کئی بار پیش منظر اور پس منظر کے درمیان سوئچ کرتی ہے، کوروٹین موخر کالوں کو جمع کرتی ہے۔ repeatOnLifecycle پر سوئچ کریں — Lifecycle کے ساتھ ہم آہنگ ہونے کا یہ واحد صحیح طریقہ ہے۔