onStart: lényeg, Activity láthatósága az Android képernyőn

Az onStart metódus lényege Androidban

onStart — az Activity életciklus második metódusa, amelyet a rendszer az onCreate után (vagy az onRestart után a megállított állapotból való visszatéréskor) hív meg. Az onStart meghívásának pillanatában az Activity vagy Fragment láthatóvá válik a képernyőn. A felhasználó látja a felületet, de a képernyő még nem áll készen az interakcióra — a beviteli fókusz csak az onResume után jelenik meg.

Az onStart metódus az Activity „látható élettartamába” (visible lifetime) tartozik — az onStart és onStop közötti intervallumba. Ezen időszak alatt az Activity részben eltakarható más ablakokkal (például átlátszó Activity-vel vagy párbeszédablakkal), de a felhasználói felület látható marad. Ez különbözteti meg a látható élettartamot az „előtérben lévő élettartamtól” (onResume — onPause), amikor az Activity teljes beviteli fókusszal rendelkezik.

Ennek a háromszintű hierarchiának a megértése kritikus fontosságú a kód helyes elosztásához. onCreate — egyszeri inicializálás, onStart — látható erőforrások csatlakoztatása, onResume — monopol hozzáférés kizárólagos erőforrásokhoz. Az a fejlesztő, aki összekeveri ezeket a szinteket, memóriaszivárgást vagy helytelen alkalmazásviselkedést kockáztat a képernyők közötti váltáskor.

onStart Activity-ben

Activity-ben az onStart metódus minden alkalommal meghívódik, amikor a képernyő megjelenik a kijelzőn — mind az első indításkor (az onCreate után), mind a háttérmódból való visszatéréskor (az onRestart után). Az onCreate-től eltérően az onStart többször is meghívható az Activity-példány élettartama során, ezért ide kerül az a kód, amelynek minden alkalommal végre kell hajlódnia, amikor a képernyő megjelenik.

class DashboardActivity : AppCompatActivity() {
    private val connectivityReceiver = object : BroadcastReceiver() {
        override fun onReceive(context: Context?, intent: Intent?) {
            val isConnected = ... // ConnectivityManager ellenőrzés
            binding?.statusIndicator?.setColor(
                if (isConnected) Color.GREEN else Color.RED
            )
        }
    }

    override fun onStart() {
        super.onStart()
        registerReceiver(
            connectivityReceiver,
            IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION)
        )
        SensorManager.getInstance().registerStepCounter()
    }

    override fun onStop() {
        unregisterReceiver(connectivityReceiver)
        SensorManager.getInstance().unregisterStepCounter()
        super.onStop()
    }
}

Kulcsszabály: minden az onStart-ben csatlakoztatott erőforrást fel kell szabadítani az onStop-ban. Ez garantálja, hogy amikor az Activity el van rejtve a képernyőről, nem fogyaszt akkumulátort, nem hallgat rendszereseményeket és nem foglal memóriát. Az Android Studio lint-szabályokat tartalmaz, amelyek figyelmeztetnek a BroadcastReceiver regisztrálására a megfelelő leiratkozás nélkül.

onStart Fragment-ben

Az onStart a Fragment-ben szorosan kapcsolódik a konténer Activity életciklusához. A Fragment akkor kapja meg az onStart hívást, miután az Activity, amelyben található, megkapta az onStart-ot. Ha azonban a Fragment késleltetett módban lett hozzáadva (FragmentTransaction.commit() addToBackStack nélkül), az onStart késéssel hívódhat meg.

class MapFragment : Fragment() {
    private var mapView: MapView? = null

    override fun onCreateView(
        inflater: LayoutInflater,
        container: ViewGroup?,
        savedInstanceState: Bundle?
    ): View {
        mapView = MapView(requireContext())
        return mapView!!
    }

    override fun onStart() {
        super.onStart()
        mapView?.onStart()
        LocationService.connect(requireContext())
    }

    override fun onStop() {
        mapView?.onStop()
        LocationService.disconnect()
        super.onStop()
    }
}

A Fragment.onStart sajátossága: ha a Fragment egy ViewPager-ben van offscreenPageLimit = 1 beállítással, a szomszédos fragmensek is megkapják az onStart-ot, mielőtt láthatóvá válnának. Ez a figyelők idő előtti regisztrálásához vezethet. Ilyen esetekben használja a setUserVisibleHint() metódust vagy az isVisible ellenőrzést az onStart-on belül, hogy csak a ténylegesen látható fragmensekhez regisztráljon figyelőket.

Különbség az onStart és onResume között

A fő különbség az onStart és onResume között — a képernyő aktivitási szintje. Az onStart azt jelzi, hogy az Activity látható a képernyőn, de nem feltétlenül van az előtérben. Az onResume azt jelzi, hogy az Activity az előtérben van és beviteli fókusszal rendelkezik. A különbséget a párbeszédablak példája mutatja be: amikor egy Dialog jelenik meg az Activity felett, az Activity elveszíti az onResume-t (onPause hívódik), de látható marad — onStart/onStop nem hívódik.

A különbségek táblázata egyértelműen mutatja, hogy milyen forgatókönyvekben hívódik meg az egyes metódus:

Ez a táblázat segít a fejlesztőnek eldönteni, hogy melyik metódusba helyezzen konkrét kódot. Például, ha az alkalmazásnak szüneteltetnie kell a videólejátszást a képernyő bármilyen takarásakor (még dialógusablakkal is), a kód az onPause-ba kerül. Ha a videónak csak a képernyő teljes elrejtésekor kell leállnia — a kód az onStop-ba kerül.

Figyelők és szolgáltatások regisztrálása

onStart — optimális hely azon figyelők regisztrálására, amelyeknek csak addig kell működniük, amíg az Activity látható a képernyőn. Ez három fő rendszerkomponens-típust érint: BroadcastReceiver a rendszereseményekhez, LocationListener a geolokációhoz és SensorListener az eszköz érzékelőihez.

BroadcastReceiver az onStart-ben

A BroadcastReceiver dinamikusan regisztrálódik a Context.registerReceiver()-en keresztül az onStart-ben és leiratkozik az onStop-ban az unregisterReceiver()-en keresztül. A dinamikus regisztráció előnyösebb a statikusnál (manifestben), mivel a vevő élettartamát az Activity láthatósági időszakára korlátozza — az alkalmazás nem ébred fel rendszer broadcast-üzenetekre, amikor az Activity rejtett.

private val batteryReceiver = object : BroadcastReceiver() {
    override fun onReceive(context: Context?, intent: Intent) {
        val level = intent.getIntExtra(BatteryManager.EXTRA_LEVEL, -1)
        binding?.batteryText?.text = "$level%"
    }
}

override fun onStart() {
    super.onStart()
    registerReceiver(batteryReceiver, IntentFilter(Intent.ACTION_BATTERY_CHANGED))
}

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

LocationListener és SensorListener

A geolokáció és az érzékelők — erőforrás-igényes műveletek. A GPS-frissítések kérése az onStart-ben és lemondása az onStop-ban garantálja, hogy az alkalmazás nem fogyaszt akkumulátort, amikor a képernyő rejtett. A pontos beállításhoz a requestLocationUpdates használható minimális időközzel és távolsággal — például 10 másodperc és 10 méter, ami optimális egyensúlyt biztosít a pontosság és az energiafogyasztás között.

Animációk és onStart

Az animációk indítása az onStart-ben, nem az onCreate-ben, garantálja, hogy az animáció minden alkalommal elindul, amikor a képernyő megjelenik. Ha az animációt az onCreate-ben indítja, az csak az Activity első létrehozásakor működik, de a háttérmódból való visszatéréskor nem. Az onStart minden alkalommal meghívódik, amikor az Activity láthatóvá válik, ami ideális hellyé teszi a ciklikus animációk és átmenetek indításához.

private lateinit var pulseAnimator: ValueAnimator

override fun onStart() {
    super.onStart()
    pulseAnimator.start()
    binding?.loadingIndicator?.animate()?.alpha(1f)?.start()
}

override fun onStop() {
    pulseAnimator.cancel()
    binding?.loadingIndicator?.animate()?.cancel()
    super.onStop()
}

Az ObjectAnimator-t vagy ValueAnimator-t használó animációk esetében fontos a cancel() meghívása az onStop-ban. Ha az animáció az Activity elrejtése után is folytatódik, feleslegesen fogyaszt GPU és CPU erőforrásokat, ami csökkenti a készülék teljesítményét és felgyorsítja az akkumulátor lemerülését. Az Android Studio Profiler (GPU-grafikon) lehetővé teszi az aktív animációk nyomon követését és a szivárgások észlelését.

Az onStart/onStop párszabály vonatkozik az előnézeti kamerával (CameraX) való munkára is. A kamera megnyitása az onStart-ben és bezárása az onStop-ban garantálja, hogy a kamera nincs blokkolva más alkalmazások számára, amikor az Ön alkalmazása nem látható a képernyőn. Ennek a szabálynak a megsértése az egyik gyakori oka a negatív értékeléseknek a Google Play-ben.