onRestart — esensya, pagpapanumbalik ng Activity sa lifecycle

onRestart — esensya ng paraan sa lifecycle ng Android

onRestart — paraan ng callback na tinatawag ng Android bago ang onStart, kapag ang Activity ay bumalik mula sa hindi nakikitang Stopped na estado pabalik sa nakikitang estado. Ang paraang ito ay natatangi dahil ito ay tinatawag lamang sa paulit-ulit na pagpapakita ng Activity — sa unang paggawa ng instance, ang pagkakasunod-sunod ay nagsisimula sa onCreate, na nilalaktawan ang onRestart. Buong cycle: onCreate → onStart → onResume (unang paglunsad) o onRestart → onStart → onResume (paulit-ulit na pagpapakita).

Mula sa pananaw ng Android system, ang onRestart ay isang optimization na nagpapahintulot sa Activity na maghanda para sa pagbabalik: i-update ang data mula sa repository, i-synchronize ang UI state, suriin ang koneksyon sa network. Hindi tulad ng onResume, na tinatawag sa bawat oras na makakuha ng focus (kabilang ang pagbabalik mula sa dialog o system menu), ang onRestart ay aktibo lamang sa buong cycle ng pagtatago-pagbabalik. Ginagawa nitong perpektong lugar ang onRestart para sa „mabibigat“ na operasyon ng pag-update na hindi kailangan sa bahagyang pagkawala ng focus.

Ayon sa detalye ng Android Activity lifecycle, ang pagitan ng oras sa pagitan ng onStop at onRestart ay maaaring mula sa ilang segundo (mabilis na lumipat ang user) hanggang ilang oras (ang app ay nasa background at bumalik ang user). Sa panahong ito, ang data sa malayong pinagmulan (API, DB) ay maaaring nagbago, kaya ang onRestart ay ang natural na punto para suriin ang pagiging bago.

Kailan tinatawag ang onRestart: mga kondisyon at pagkakasunod-sunod

Ang onRestart ay tinatawag lamang kapag bumalik ang Activity mula sa Stopped na estado, kung saan pumasok ang Activity pagkatapos ng pagtawag ng onStop. Nasa ibaba ang lahat ng sitwasyon na humahantong sa onRestart.

Mga sitwasyon ng pagtawag ng onRestart:

• Pagbabalik mula sa ibang Activity — binuksan ng user ang isang bagong Activity (halimbawa, nag-click sa notification) at pagkatapos ay bumalik (pinindot ang „Bumalik“). Stack: MainActivity.onPause → MainActivity.onStop → SecondActivity ay ginawa → pinindot ng user ang „Bumalik“ → SecondActivity.onPause → SecondActivity.onStop → SecondActivity.onDestroy → MainActivity.onRestart → MainActivity.onStart → MainActivity.onResume.
• Pagbabalik mula sa minimization — na-minimize ng user ang app (Home) at pagkaraan ng ilang oras ay bumalik. CurrentActivity.onPause → CurrentActivity.onStop → (app sa background) → bumalik ang user → CurrentActivity.onRestart → CurrentActivity.onStart → CurrentActivity.onResume.
• Pagbabalik mula sa lock screen — tinatakpan ng lock screen ang Activity; pagkatapos mag-unlock, ang Activity ay makakatanggap ng onRestart kung lumipas ang makabuluhang oras (higit sa 5 segundo).
• Pagbabalik mula sa app na inilunsad sa pamamagitan ng Intent — camera, gallery, browser — anumang third-party na app na inilunsad sa pamamagitan ng startActivityForResult() o ActivityResultLauncher.

Kailan HINDI tinatawag ang onRestart: sa pag-ikot ng screen (ang Activity ay nasisira at ginagawang muli sa pamamagitan ng onCreate), sa pagbabalik mula sa dialog window (ang Activity ay hindi pumupunta sa onStop, onPause → onResume lamang), sa process death (ang Activity ay ginagawang muli).

Pagkakaiba ng onRestart at onCreate: ano ang pipiliin

Ang onRestart at onCreate ay dalawang magkaibang paraan ng pagpapanumbalik ng Activity. Ang pagpili sa pagitan ng mga ito ay depende sa kung ang Activity ay ganap na nawasak o nakatago lamang.

Panuntunan sa pagpili: gawin ang pagsisimula ng View at pag-subscribe sa LiveData/StateFlow sa onCreate (o onViewCreated para sa Fragment). Pag-update ng data, pag-reload ng mga listahan, at pagsusuri ng estado — sa onRestart. Kung ang data ay na-load sa pamamagitan ng ViewModel, ang onRestart ay maaaring tumawag lamang ng refresh() method sa ViewModel, at ang View ay mag-subscribe sa na-update na data sa pamamagitan ng reactive stream.

Inirerekomenda ng Google: huwag i-duplicate ang logic ng onCreate sa onRestart. Ihiwalay sa ViewModel ang mga refresh() method na naglo-load ng kasalukuyang data at tawagin ang mga ito sa onRestart. Ito ay nagpapanatili ng kalinawan ng arkitekturang MVVM at nag-aalis ng pagdodoble ng code.

Mga sitwasyon ng paggamit ng onRestart: pag-update ng data at UI

Ang onRestart — perpektong lugar para sa mga operasyon na dapat isagawa sa bawat pagbabalik sa screen, ngunit hindi kailangan sa unang pagbukas. Narito ang mga karaniwang sitwasyon:

• Pag-update ng listahan mula sa DB o API — ang user ay pumunta sa ibang Activity, binago ang data doon, bumalik — ang listahan ay dapat na napapanahon. Tawagin ang viewModel.refreshItems() sa onRestart.
• Pagsusuri ng awtorisasyon — kung ang Activity ay nakatago nang mahabang panahon, ang access token ay maaaring nag-expire na. Ang onRestart ay ang punto para suriin ang validity ng token at mag-redirect sa login screen.
• Pag-synchronize ng UI state — pagpapalit ng tema, pagbabago ng wika, pag-update ng mga setting — ang mga pagbabago ay dapat ilapat sa pagbabalik sa screen.
• Pag-reload ng media — kung ang Activity ay nagpapakita ng content na maaaring nagbago (news feed, exchange rate, panahon), i-update ang data sa onRestart.
• Pagsusuri ng koneksyon sa network — sa pagbabalik mula sa offline mode, dapat suriin ng Activity ang availability ng network at lumipat ng UI.
• Pagpapanumbalik ng mga animation — ang mga animation na pinalaya sa onStop, i-restart sa onRestart bago ang onStart.

Ano ang hindi gagawin sa onRestart: huwag simulan muli ang View — sila ay buhay dahil ang Activity ay hindi nawasak. Huwag mag-subscribe muli sa LiveData — ang subscription sa onCreate ay buhay. Huwag gumawa ng bagong fragment — sila ay nasa FragmentManager na.

onRestart at process death: mahalagang pagbubukod

Ang pinakamahalagang pagbubukod: ang onRestart ay hindi tinatawag kung ang proseso ng app ay pinatay ng system. Ito ang pangunahing punto na madalas na napalampas ng mga developer sa pamamagitan ng pag-asa sa onRestart para sa pagpapanumbalik ng estado.

Sa process death:

• Ang app ay nasa background, pinatay ng Android ang proseso upang magbakante ng memorya.
• Bumalik ang user — ang system ay naglunsad ng bagong proseso.
• Ang Activity ay ginagawang muli: onCreate(Bundle) → onStart → onResume.
• Ang onRestart ay HINDI tinatawag — para sa system ito ay isang bagong instance ng Activity.

Paano protektahan ang iyong sarili: palaging i-save ang kritikal na estado sa onSaveInstanceState(Bundle) (tinatawag bago ang onStop) o gamitin ang SavedStateHandle sa ViewModel. Sa onCreate, suriin ang savedInstanceState: kung hindi ito null, ibalik ang estado mula sa Bundle, kung null — mag-load ng sariwang data.

Ayon sa Google Android Vitals, humigit-kumulang 7% ng mga pagbabalik sa Activity pagkatapos ng mahabang pananatili sa background ay nangyayari pagkatapos ng process death. Nangangahulugan ito na bawat ika-15 Activity na dapat tumawag ng onRestart ay sa katunayan ay dumadaan sa onCreate. Ang pagwawalang-bahala sa sitwasyong ito ay isa sa mga pangunahing sanhi ng mga bug na „blangkong screen pagkatapos bumalik“.

Mga halimbawa ng code na may onRestart sa Kotlin

Halimbawa 1: onRestart na may pag-update ng listahan sa pamamagitan ng ViewModel

Tinatawag ng Activity ang viewModel.refreshTasks() sa onRestart upang i-update ang listahan ng mga gawain pagkatapos bumalik mula sa edit screen.

class TaskListActivity : AppCompatActivity() {
    private val viewModel: TaskViewModel by viewModels()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_task_list)
        viewModel.tasks.observe(this) { tasks ->
            Log.d("TaskList", "${tasks.size} gawain ang natanggap")
        }
    }

    override fun onRestart() {
        super.onRestart()
        Log.d("TaskList", "onRestart: pag-update ng listahan ng gawain")
        viewModel.refreshTasks()
    }
}

class TaskViewModel : ViewModel() {
    private val _tasks = MutableLiveData<List<Task>>()
    val tasks: LiveData<List<Task>> get() = _tasks

    fun refreshTasks() {
        viewModelScope.launch {
            _tasks.value = TaskRepository().getAllTasks()
        }
    }
}

Ang ViewModel.refreshTasks() ay naglo-load ng kasalukuyang data mula sa repository. Awtomatikong nag-aabiso ang LiveData sa Activity tungkol sa pagbabago ng data — ang UI ay nag-a-update nang walang karagdagang code. Ang OnRestart ay hindi gumagawa ng bagong subscription — ito ay nakatakda na sa onCreate.

Halimbawa 2: onRestart na may pagsusuri ng awtorisasyon

Sinusuri ng Activity ang validity ng token sa pagbabalik at nagre-redirect sa login kung kinakailangan.

class ProfileActivity : AppCompatActivity() {
    private val authManager = AuthManager()
    private val launcher = registerForActivityResult(
        ActivityResultContracts.StartActivityForResult()
    ) { Log.d("Profile", "Bumalik mula sa login screen") }

    override fun onRestart() {
        super.onRestart()
        if (!authManager.isTokenValid()) {
            Log.d("Profile", "Nag-expire ang token — na-redirect sa login")
            launcher.launch(Intent(this, LoginActivity::class.java))
        }
    }
}

class AuthManager {
    fun isTokenValid(): Boolean {
        val expiry = SharedPreferencesManager().getTokenExpiry()
        return System.currentTimeMillis() < expiry
    }
}

Kung na-minimize ng user ang app nang mahabang panahon at bumalik pagkatapos mag-expire ang token, ire-redirect siya ng onRestart sa login screen. Pinipigilan nito ang mga error sa API kapag sinusubukang magsagawa ng request na may expired na token. Pansinin: pagsusuri sa onRestart, hindi sa onResume, upang maiwasan ang hindi kinakailangang pagsusuri sa pagbabalik mula sa dialog.

Halimbawa 3: onRestart sa Fragment na may ViewLifecycleOwner

Gumagamit ang Fragment ng onRestart sa pamamagitan ng LifecycleObserver para sa pag-update ng data.

class FeedFragment : Fragment() {
    private val viewModel: FeedViewModel by viewModels()

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        viewLifecycleOwner.lifecycle.addObserver(object : LifecycleObserver {
            @OnLifecycleEvent(Lifecycle.Event.ON_RESTART)
            fun onRestart() {
                Log.d("FeedFragment", "onRestart sa pamamagitan ng LifecycleObserver")
                viewModel.refreshFeed()
            }
        })
    }
}

Sa halip na i-override ang onRestart sa Fragment, ginagamit ang LifecycleObserver — isang mas flexible na paraan na nagpapahintulot sa pagdaragdag ng logic sa mga lifecycle na kaganapan nang walang inheritance. Ginagarantiyahan ng ViewLifecycleOwner na ang observer ay nabubuhay sa scope ng View (hindi lumalampas sa onDestroyView).