Activity Lifecycle: یہ کیا ہے، Android میں onCreate onStart onResume

Activity Lifecycle کیا ہے

Activity Lifecycle (Activity کا لائف سائیکل) ایک حالت مشین ہے جس سے Android ایپلیکیشن کی ہر اسکرین تخلیق کے لمحے سے مکمل تباہی تک گزرتی ہے۔ Android نظام صارف کے اعمال کی بنیاد پر اس عمل کا انتظام کرتا ہے: ایپلیکیشن کھولنا، چھوٹا کرنا، اسکرین گھمانا، آنے والی کال کا جواب دینا، ایپلیکیشنز کے درمیان سوئچ کرنا اور بند کرنا۔

لائف سائیکل کو سمجھنا ہر Android ڈویلپر کے لیے ضروری ہے، کیونکہ نظام میموری کم ہونے پر کسی بھی وقت Activity کو تباہ کر سکتا ہے — اور ایپلیکیشن کو اپنی حالت درست طریقے سے بحال کرنی ہوتی ہے۔ Google Android Vitals (2025) کے مطابق، جو ایپلیکیشنز onSaveInstanceState() میں حالت محفوظ کرنے کو ہینڈل نہیں کرتیں، وہ Activity دوبارہ بننے پر 42% زیادہ کریش دکھاتی ہیں۔

لائف سائیکل میں چھ اہم کال بیک طریقے شامل ہیں: onCreate()، onStart()، onResume()، onPause()، onStop()، onDestroy()۔ مزید برآں onRestart() طریقہ ہے، جو onStart() سے پہلے کال کیا جاتا ہے جب Activity رکی ہوئی حالت سے واپس آتی ہے۔ ہر طریقہ کا سختی سے متعین مقصد اور عملدرآمد کا وقت ہوتا ہے — نظام انہیں ترتیب وار کال کرتا ہے، اور ڈویلپر اپنی منطق کو نافذ کرنے کے لیے ان میں سے کسی کو اوور رائڈ کر سکتا ہے۔

سائیکل کو تین اہم مراحل میں تقسیم کیا جا سکتا ہے: مکمل زندگی کا دورانیہ (onCreate → onDestroy)، نظر آنے والا دورانیہ (onStart → onStop) اور پیش منظر کا دورانیہ (onResume → onPause)。 ان تین سطحوں کو سمجھنا ابتدا اور وسائل کی رہائی کے کوڈ کو درست طریقے سے تقسیم کرنے میں مدد کرتا ہے۔

Activity لائف سائیکل کے طریقے

لائف سائیکل کا ہر طریقہ ایک سختی سے متعین کام انجام دیتا ہے۔ نظام انہیں ایک مقررہ ترتیب میں کال کرتا ہے، اور ڈویلپر کو صرف مخصوص منطق کے لیے ضروری طریقوں کو اوور رائڈ کرنا چاہیے۔ لائف سائیکل کے طریقوں کو براہ راست کال کرنے کی سفارش نہیں کی جاتی — یہ Android Runtime کے ذریعے سنبھالا جاتا ہے۔

عام کال ترتیب

ایپلیکیشن لانچ کرتے وقت عام ترتیب: onCreate → onStart → onResume۔ واپس کے بٹن کو دبانے پر: onPause → onStop → onDestroy۔ چھوٹا کرنے پر: onPause → onStop، پھر واپسی پر: onRestart → onStart → onResume۔

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
    }

    override fun onStart() {
        super.onStart()
    }

    override fun onResume() {
        super.onResume()
    }

    override fun onPause() {
        super.onPause()
    }

    override fun onStop() {
        super.onStop()
    }

    override fun onDestroy() {
        super.onDestroy()
    }

    override fun onRestart() {
        super.onRestart()
    }
}

ہر اوور رائڈ کردہ طریقہ اپنے super ورژن کو کال کرنا لازم ہے — اس کے بغیر، نظام حالت کی منتقلی کو درست طریقے سے مکمل نہیں کر سکتا۔ یہ قاعدہ Android Developers دستاویزات میں قائم کیا گیا ہے اور Android Studio کے lint اصولوں کے ذریعے جانچا جاتا ہے۔

لائف سائیکل کی تین سطحیں

پہلی سطح — مکمل زندگی کا دورانیہ: onCreate اور onDestroy کے درمیان وقفہ۔ یہاں ایک بار کی ابتدا اور عالمی وسائل کی حتمی رہائی کی جاتی ہے۔ دوسری سطح — نظر آنے والا دورانیہ: onStart اور onStop کے درمیان۔ Activity اسکرین پر نظر آتی ہے لیکن کسی دوسری ونڈو سے جزوی طور پر ڈھکی ہو سکتی ہے۔ تیسری سطح — پیش منظر کا دورانیہ: onResume اور onPause کے درمیان۔ Activity ٹاسک اسٹیک کے اوپر ہوتی ہے اور صارف کے ساتھ تعامل کرتی ہے۔

onCreate — Activity بنانا

onCreate() — Activity لائف سائیکل کا پہلا اور واحد لازمی طریقہ۔ اسے نظام Activity مثال بناتے وقت ایک بار کال کرتا ہے۔ یہ طریقہ savedInstanceState: Bundle? پیرامیٹر قبول کرتا ہے، جس میں پہلے سے محفوظ کردہ حالت ہوتی ہے اگر Activity تباہی کے بعد دوبارہ بنائی جا رہی ہو — مثال کے طور پر، اسکرین گھمانے کے دوران۔

onCreate کے اندر درج ذیل کام انجام دیے جاتے ہیں: setContentView() کے ذریعے لے آؤٹ وسائل کے ساتھ یوزر انٹرفیس کی ابتدا، findViewById() کے ذریعے View عناصر کا بندھن، RecyclerView اور ViewPager کے لیے اڈاپٹر کی ترتیب، savedInstanceState سے حالت کی بحالی، ViewModel اور LiveData کی ابتدا، کلک اور جیسچر سننے والوں کی ترتیب۔ طریقہ جتنی جلدی ممکن ہو مکمل ہونا چاہیے — یہاں لمبی کارروائیاں پہلے فریم کی رینڈرنگ کو روکتی ہیں، جس سے ایپلیکیشن شروع ہونے کا وقت بڑھ جاتا ہے۔

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_profile)

    val userNameText: TextView = findViewById(R.id.user_name)
    val loadButton: Button = findViewById(R.id.load_button)

    if (savedInstanceState != null) {
        userNameText.text = savedInstanceState.getString("user_name")
    }

    loadButton.setOnClickListener {
        loadUserProfile()
    }
}

اگر Activity پہلی بار بنائی جا رہی ہے، تو savedInstanceState null ہے۔ اسکرین گھمانے کے بعد دوبارہ بنانے پر، Bundle میں onSaveInstanceState() میں محفوظ کردہ ڈیٹا ہوتا ہے۔ null کی جانچ صارف کے داخل کردہ ڈیٹا کو کھوئے بغیر UI کو درست طریقے سے بحال کرنے کے لیے معیاری عمل ہے۔

onStart — اسکرین پر ظاہر ہونا

onStart() onCreate() کے فوراً بعد یا onRestart() کے بعد کال کیا جاتا ہے، جب Activity صارف کو نظر آنے لگتی ہے۔ اس حالت میں، Activity ابھی پیش منظر میں نہیں ہے اور صارف کے ساتھ تعامل نہیں کر سکتی، لیکن اس کا یوزر انٹرفیس پہلے ہی اسکرین پر نظر آتا ہے۔ مثال کے طور پر، ایپلیکیشن لانچ کرتے وقت، نظام onStart اور onResume کال کے درمیان انٹرفیس کا پہلا فریم رینڈر کرتا ہے۔

onStart طریقہ میں عام طور پر درج ذیل اقدامات کیے جاتے ہیں: اینیمیشن شروع کرنا جو Activity کے نظر آنے تک چلنی چاہئیں؛ BroadcastReceiver باندھنا؛ جغرافیائی محل وقوع کی خدمات اور سینسر سے جڑنا؛ ViewModel یا Room سے ڈیٹا اپ ڈیٹ کرنا۔ یہاں bindService() کے ذریعے Bound خدمات سے بندھن بھی کیا جاتا ہے اگر ایپلیکیشن عمل کے اندر کلائنٹ-سرور فن تعمیر استعمال کرتی ہے۔

override fun onStart() {
    super.onStart()
    val locationManager = getSystemService(Context.LOCATION_SERVICE) as LocationManager
    locationManager.requestLocationUpdates(
        LocationManager.GPS_PROVIDER,
        5000L,
        10f,
        locationListener
    )
}

override fun onStop() {
    super.onStop()
    val locationManager = getSystemService(Context.LOCATION_SERVICE) as LocationManager
    locationManager.removeUpdates(locationListener)
}

اہم قاعدہ: onStart میں منسلک وسائل onStop میں جاری کیے جانے چاہئیں۔ یہ یقینی بناتا ہے کہ جب Activity اسکرین پر نظر نہیں آتی، تو وہ بیٹری اور نظام کے وسائل استعمال نہیں کرتی۔ Google Play Store اپ ڈیٹس کی جانچ پڑتال کرتے وقت LocationListener اور دیگر نظامی خدمات کے رساؤ کے لیے ایپلیکیشنز کو چیک کرتا ہے۔

onResume — فوکس حاصل کرنا

onResume() — وہ حالت جس میں Activity پیش منظر میں ہوتی ہے اور صارف کے ساتھ تعامل کے لیے تیار ہوتی ہے۔ یہ اسکرین کی کام کرنے والی حالت ہے: نظام Activity کو ان پٹ فوکس منتقل کرتا ہے، اور تمام ٹچ ایونٹس، کی بورڈ ان پٹ اور جیسچرز اس اسکرین پر بھیجے جاتے ہیں۔ onResume طریقہ ہر بار کال کیا جاتا ہے جب Activity پیش منظر میں واپس آتی ہے — کسی دوسری Activity کے ختم ہونے کے بعد، ڈائیلاگ باکس بند ہونے کے بعد، یا ڈیوائس انلاک ہونے کے بعد۔

onResume میں درج ذیل کام کیے جاتے ہیں: onPause میں عارضی طور پر روکے گئے اینیمیشن کو دوبارہ شروع کرنا؛ کیمرہ اور دیگر خصوصی وسائل کھولنا؛ سینسر سننے والوں (ایکسلرومیٹر، جائروسکوپ) کا اندراج؛ UI کے لیے ٹائمر اور سٹاپ واچ شروع کرنا؛ موجودہ ڈیٹا کے ساتھ اسکرین کے مواد کو اپ ڈیٹ کرنا۔ onResume/onPause جوڑا ان وسائل کے لیے استعمال ہوتا ہے جو صرف فوکس ہونے پر فعال ہونے چاہئیں — مثال کے طور پر، مسلسل تقریر کی شناخت یا ویڈیو کیپچر۔

override fun onResume() {
    super.onResume()
    cameraHolder.openCamera()
    animator.resume()
    sensorManager.registerListener(
        stepCounter,
        sensorManager.getDefaultSensor(Sensor.TYPE_STEP_COUNTER),
        SensorManager.SENSOR_DELAY_NORMAL
    )
}

override fun onPause() {
    super.onPause()
    cameraHolder.closeCamera()
    animator.pause()
    sensorManager.unregisterListener(stepCounter)
}

onStart اور onResume کے درمیان فرق اہم ہے: ایک Activity نظر آ (onStart) سکتی ہے لیکن فعال (onResume) نہیں — مثال کے طور پر، جب اس کے اوپر ایک پاپ اپ ڈائیلاگ یا شفاف لاک اسکرین ظاہر ہو۔ خصوصی وسائل جنہیں خصوصی رسائی کی ضرورت ہوتی ہے، انہیں onStart میں نہیں بلکہ onResume میں کھولنا چاہیے۔

onPause — فوکس کھونا

onPause() کال کیا جاتا ہے جب Activity ان پٹ فوکس کھو دیتی ہے لیکن جزوی طور پر نظر آتی رہتی ہے۔ عام منظرنامے: ڈائیلاگ باکس کھولنا، حالیہ ایپلیکیشنز بٹن دبانا، آنے والی کال، ہوم بٹن دبانا (اس صورت میں onPause کے بعد onStop آئے گا)۔ onPause طریقہ ڈیٹا محفوظ کرنے کی آخری قابل بھروسہ جگہ ہے جسے صارف کو نہیں کھونا چاہیے۔

onPause میں درج ذیل کام کیے جاتے ہیں: ای میل ڈرافٹس اور ان پٹ فارمز کو Room یا SharedPreferences میں محفوظ کرنا؛ اینیمیشن اور ویڈیو پلے بیک روکنا؛ کیمرہ بند کرنا اور خصوصی وسائل جاری کرنا؛ پس منظر میں غیر اہم مہنگی کارروائیاں منسوخ کرنا۔ onPause طریقہ 100 ملی سیکنڈ سے کم میں مکمل ہونا چاہیے — نظام onPause کے کنٹرول واپس کرنے تک اگلی Activity میں منتقلی کو روکتا ہے، اور حد سے تجاوز کرنا ANR (Application Not Responding) کا باعث بنتا ہے۔

override fun onPause() {
    super.onPause()
    val editor = SharedPreferences.Manager ...
    editor.putString("draft_text", draftEditText.text.toString())
    editor.apply()
    videoView.pause()
    cameraHolder.release()
}

اہم: onPause UI تھریڈ پر عملدرآمد کرتا ہے، لہذا Room کے ذریعے ہم وقت ساز استفسار کے ساتھ ڈیٹابیس میں لکھنے جیسی کوئی بھی روکنے والی کارروائی غیر ہم وقت ساز (کوروٹین) سے بدل دی جانی چاہیے یا پس منظر کے تھریڈ پر عملدرآمد کی جانی چاہیے۔ SharedPreferences کے لیے commit() کے بجائے apply() استعمال کریں — apply ڈیٹا کو غیر ہم وقت ساز طور پر لکھتا ہے اور UI تھریڈ کو نہیں روکتا۔

onStop — اسکرین سے چھپنا

onStop() کال کیا جاتا ہے جب Activity صارف کو نظر آنا بند کر دیتی ہے۔ یہ درج ذیل صورتوں میں ہوتا ہے: Activity کسی دوسری Activity سے مکمل طور پر ڈھکی ہوئی ہے؛ صارف نے ہوم بٹن دبایا یا کسی دوسری ایپلیکیشن پر سوئچ کیا؛ Activity ختم ہو رہی ہے (بعد میں onDestroy کال کیا جائے گا)۔ onStop حالت میں، Activity میموری میں رہتی ہے اور اپنے تمام فیلڈز برقرار رکھتی ہے — یہ نہ تو تباہ ہوئی ہے اور نہ ہی فعال ہے۔

onStop میں درج ذیل کام کیے جاتے ہیں: onStart میں رجسٹرڈ BroadcastReceiver کی رجسٹریشن منسوخ کرنا؛ Bound خدمات سے منقطع ہونا؛ LocationListener، SensorListener اور دیگر نظامی سننے والوں کو جاری کرنا؛ لمبے پس منظر کے کاموں کو روکنا جو ایپلیکیشن کے چھپے ہونے پر ضروری نہیں؛ onPause میں نہ کرنے کی صورت میں onSaveInstanceState() کے ذریعے Bundle میں موجودہ UI حالت لکھنا۔

override fun onStop() {
    super.onStop()
    unregisterReceiver(connectivityReceiver)
    unbindService(serviceConnection)
    if (isChangingConfigurations()) {
        Log.d("Lifecycle", "ترتیب کی وجہ سے Activity دوبارہ بنائی جا رہی ہے")
    }
}

نظام میموری کم ہونے پر onDestroy کال کیے بغیر onStop حالت میں Activity کو تباہ کر سکتا ہے۔ لہذا تمام اہم ڈیٹا onStop میں منتقلی سے پہلے محفوظ کر لینا چاہیے۔ isChangingConfigurations() پرچم یہ تعین کرنے کی اجازت دیتا ہے کہ آیا onStop کال اسکرین گھمانے سے متعلق ہے — اس صورت میں، Activity ختم نہیں ہوگی بلکہ دوبارہ بنائی جائے گی۔

onDestroy — Activity کی تباہی

onDestroy() — لائف سائیکل کا آخری طریقہ جو Activity کی مکمل تباہی سے پہلے کال کیا جاتا ہے۔ نظام onDestroy کو دو صورتوں میں کال کرتا ہے: Activity finish() کے ذریعے ختم ہوتی ہے یا صارف واپس کا بٹن دباتا ہے؛ Activity ترتیب کی تبدیلی (مثلاً اسکرین گھمانا) کی وجہ سے نظام کے ذریعے تباہ ہوتی ہے اور دوبارہ بنائی جائے گی۔ onDestroy طریقہ حتمی وسائل کی صفائی کی اجازت دیتا ہے: تھریڈز اور کوروٹینز کو الگ کرنا، مستقل طور پر کھلے کرسر اور ساکٹ بند کرنا، NDK کے ذریعے مقامی میموری جاری کرنا۔

override fun onDestroy() {
    super.onDestroy()
    backgroundJob.cancel()
    dbHelper.close()
    if (isFinishing) {
        Log.d("Lifecycle", "Activity مستقل طور پر ختم ہو رہی ہے")
    } else {
        Log.d("Lifecycle", "Activity دوبارہ بنائی جائے گی")
    }
}

اہم نوٹ: onDestroy کے کال ہونے کی ضمانت نہیں ہے اگر ایپلیکیشن کا عمل نظام کے ذریعے ختم کر دیا جائے (out-of-memory kill)۔ لہذا ڈیٹا محفوظ کرنے کے لیے onDestroy پر انحصار نہیں کیا جا سکتا — یہ کام onPause یا onStop میں حل کیا جاتا ہے۔ isFinishing پراپرٹی finish() کے ذریعے Activity کے خاتمے اور ترتیب کی تبدیلی پر دوبارہ بنانے میں فرق کرنے کی اجازت دیتی ہے۔

onRestart — رکی ہوئی حالت سے واپسی

onRestart() onStart() سے پہلے کال کیا جاتا ہے جب Activity رکی ہوئی حالت (onStop) سے پیش منظر میں واپس آتی ہے۔ یہ اس وقت ہوتا ہے جب صارف حالیہ ایپلیکیشنز مینو سے ایپلیکیشن دوبارہ کھولتا ہے یا کسی بچوں کی اسکرین پر واپس دبا کر Activity پر واپس آتا ہے۔ onRestart طریقہ onCreate سے مختلف منطق انجام دینے کی اجازت دیتا ہے — مثال کے طور پر، وہ ڈیٹا اپ ڈیٹ کرنا جو Activity کے چھپے ہونے کے دوران بدل سکتا ہے۔

override fun onRestart() {
    super.onRestart()
    refreshDataFromNetwork()
    Log.d("Lifecycle", "Activity اسٹیک سے دوبارہ شروع ہو رہی ہے")
}

عام منظرنامہ: صارف نے ایپلیکیشن کھولی، دوسرے کام پر سوئچ کیا، اور ایک گھنٹے بعد واپس آیا۔ onRestart میں، ایپلیکیشن ڈیٹا کی مطابقت چیک کر سکتی ہے اور، اگر زیادہ وقت گزر گیا ہو، تو مواد دوبارہ لوڈ کرنے کا مشورہ دے سکتی ہے۔ اس سے صارف کے تجربے میں بہتری آتی ہے اور پرانی معلومات ظاہر ہونے کا امکان کم ہوتا ہے۔

اسکرین گھمانا اور حالت محفوظ کرنا

اسکرین گھمانا Activity دوبارہ بنانے کا سب سے عام منظرنامہ ہے۔ پہلے سے طے شدہ طور پر، Android ہر سمت تبدیلی پر موجودہ Activity کو تباہ کرتا ہے اور ایک نیا بناتا ہے۔ اگر حالت محفوظ نہ کی گئی ہو، تو صارف تمام داخل کردہ ڈیٹا کھو دے گا۔ Android اس کے لیے دو طریقہ کار فراہم کرتا ہے: سیریلیئمزڈ ڈیٹا کے لیے onSaveInstanceState() اور ترتیب کی تبدیلیوں سے بچنے والے ڈیٹا کے لیے ViewModel۔

onSaveInstanceState اور onRestoreInstanceState

عارضی حالت محفوظ کرنے کے لیے Activity تباہ ہونے سے پہلے onSaveInstanceState() کال کیا جاتا ہے۔ محفوظ کردہ ڈیٹا savedInstanceState پیرامیٹر کے ذریعے onCreate اور onRestoreInstanceState() طریقہ کو پاس کیا جاتا ہے، جو onStart کے بعد کال کیا جاتا ہے۔ Bundle کا ایک سائز کی حد ہوتی ہے — تقریباً 500 KB، لہذا ڈیٹا کی بڑی مقدار (مثلاً bitmap) ViewModel کے ذریعے محفوظ کی جاتی ہے۔

<!-- AndroidManifest.xml — سمت کا استحکام -->
<activity android:name=".MainActivity"
    android:configChanges="orientation|screenSize" />

android:configChanges کے ذریعے سمت کو مستحکم کرنا Activity دوبارہ بننے سے روکتا ہے، لیکن اگر ایپلیکیشن کو دونوں سمتوں کی حمایت کرنی ہو تو اسے اینٹی پیٹرن سمجھا جاتا ہے۔ Google کی جدید سفارش UI میں صارف کے داخل کردہ ڈیٹا کے لیے onSaveInstanceState کے ساتھ ViewModel استعمال کرنا ہے۔

Fragment لائف سائیکل

Fragment کا اپنا لائف سائیکل ہوتا ہے، جو Activity کی طرح ہے لیکن اضافی طریقوں کے ساتھ: onAttach، onCreate، onCreateView، onViewCreated، onStart، onResume، onPause، onStop، onDestroyView، onDestroy، onDetach۔ Fragment ہمیشہ Activity کے اندر موجود ہوتا ہے، اور اس کا لائف سائیکل کنٹینر Activity کے لائف سائیکل سے منسلک ہوتا ہے۔ اگر Activity تباہ ہوتی ہے، تو Fragment اس کی پیروی کرتا ہے۔

بنیادی فرق: Fragment نہ صرف جزو کی حالت بلکہ View کے درجہ بندی کا بھی انتظام کرتا ہے۔ onCreateView طریقہ Fragment کی جڑ View واپس کرتا ہے، اور onDestroyView اس درجہ بندی کو تباہ کرتا ہے۔ یہ Fragment کو اسکرین گھمانے کے دوران Activity دوبارہ بننے سے بچنے کی اجازت دیتا ہے: Fragment محفوظ رہتا ہے، اور اس کا View onCreateView میں دوبارہ بنایا جاتا ہے۔

class ProfileFragment : Fragment() {
    override fun onCreateView(
        inflater: LayoutInflater,
        container: ViewGroup?,
        savedInstanceState: Bundle?
    ): View {
        return inflater.inflate(R.layout.fragment_profile, container, false)
    }

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        val avatarImage: ImageView = view.findViewById(R.id.avatar_image)
        loadAvatar(avatarImage)
    }
}

onCreate اور onCreateView کے درمیان فرق کو سمجھنا بہت اہم ہے: onCreate Fragment کی زندگی میں ایک بار (View دوبارہ بننے پر بھی) کال ہوتا ہے، جبکہ onCreateView ہر بار کال ہوتا ہے جب Fragment اپنا View درجہ بندی بناتا یا دوبارہ بناتا ہے۔ ڈیٹا کی ابتدا onCreate میں کی جاتی ہے، جبکہ UI کا بندھن onViewCreated میں کیا جاتا ہے۔

LifecycleObserver اور Jetpack

LifecycleObserver — Android Jetpack لائبریری کا ایک جزو ہے جو Activity یا Fragment میں طریقوں کو اوور رائڈ کیے بغیر لائف سائیکل کی تبدیلیوں پر رد عمل ظاہر کرنے کی اجازت دیتا ہے۔ ہر لائف سائیکل طریقہ میں کوڈ کو نقل کرنے کے بجائے، ڈویلپر @OnLifecycleEvent تشریحات کے ساتھ ایک علیحدہ کلاس بناتا ہے اور اسے lifecycle.addObserver() میں پاس کرتا ہے۔

Jetpack LifecycleOwner انٹرفیس بھی فراہم کرتا ہے، جسے AppCompatActivity اور Fragment نافذ کرتے ہیں۔ کوئی بھی شے جو LifecycleOwner کو نافذ کرتی ہے، LiveData سبسکرپشنز، lifecycleScope کے ذریعے کوروٹینز، اور لائف سائیکل کے حوالے سے WorkManager کا انتظام کر سکتی ہے۔ یہ MVVM اور Jetpack پر مبنی جدید Android فن تعمیر کا سنگ بنیاد ہے۔

class MyLocationObserver(private val context: Context) : DefaultLifecycleObserver {
    override fun onStart(owner: LifecycleOwner) {
        startLocationUpdates()
    }

    override fun onStop(owner: LifecycleOwner) {
        stopLocationUpdates()
    }
}

// Activity میں:
lifecycle.addObserver(MyLocationObserver(this))

DefaultLifecycleObserver کا استعمال جانچ کو آسان بناتا ہے، کوڈ کی نقل کو کم کرتا ہے، اور لائف سائیکل کی منطق کو مختلف اسکرینوں پر دوبارہ قابل استعمال بناتا ہے۔ یہ ہر Activity میں دستی طور پر onStart/onStop کو اوور رائڈ کرنے کا جدید متبادل ہے۔ IT Sectr کے تیار کردہ Android ایپلیکیشنز میں، ہم جغرافیائی محل وقوع، Bluetooth اسکیننگ اور تجزیات کے لیے LifecycleObserver استعمال کرتے ہیں — اس سے بوائلرپلیٹ کوڈ کا حجم 30–40% کم ہو جاتا ہے۔