Active: ano ito, estado Active sa lifecycle ng iOS

Active: anong uri ng estado ito

Active — estado ng lifecycle ng mobile application, kung saan ito ay nasa foreground, ipinapakita sa screen ng device at aktibong nakikipag-ugnayan sa user. Sa estadong ito, ang app ay tumatanggap ng lahat ng touch events, key presses, data mula sa accelerometer at gyroscope, at may buong access sa graphics processor para sa pag-render ng interface.

Sa iOS, ang Active state ay bahagi ng limang-estado na modelo ng lifecycle: Not Running → Inactive → Active → Inactive → Background → Suspended → Not Running. Sa Android, ang katumbas ay ang estado ng Activity pagkatapos ng tawag sa onResume, kapag ang Activity ay nasa tuktok ng stack at tumatanggap ng user input. Ang Active ay ang tanging estado kung saan ang UI ay ganap na interaktibo at tumutugon sa mga galaw, pag-scroll, pag-click at mga animation.

Ang sistema ay nagbibigay ng app sa Active ng pinakamataas na priyoridad sa processor at RAM. Ibig sabihin, hindi tatapusin ng sistema ang naturang app kapag kulang sa mga mapagkukunan — unang ibababa ang mga proseso sa background at suspendido. Gayunpaman, dapat gamitin ng app ang mga mapagkukunan nang mahusay upang hindi maubos ang baterya at magdulot ng CPU throttling.

Para sa user, ang Active ay normal na estado ng pagtatrabaho sa app. Nakikita ng user ang interface, maaaring pindutin ang mga button, punan ang mga form, mag-scroll sa feed. Ang anumang pagkaantala ng estadong ito (tawag, notipikasyon, pag-swipe pataas para sa Control Center) ay naglilipat ng app sa Inactive, pagkatapos nito ay maaaring bumalik sa Active o pumunta sa Background.

Paano tinutukoy ng sistema na ang app ay Active

Ginagamit ng iOS ang UIApplicationMain para sa pamamahala ng estado. Sa paglipat sa Active, tinatawagan ng sistema ang applicationDidBecomeActive. Para sa SwiftUI, ang katulad na mekanismo ay pagmamasid sa scenePhase sa pamamagitan ng Environment. Ginagamit ng Android ang onResume bilang tagapagpahiwatig ng aktibidad ng Activity sa foreground. Ang parehong mga diskarte ay ginagarantiyahan na ang app ay makakatanggap ng abiso tungkol sa pagbabago ng estado at maiangkop ang pag-uugali nito.

Active sa iOS: Swift, UIKit at SwiftUI

Sa iOS, ang estado Active ay hinahawakan sa pamamagitan ng UIApplicationDelegate. Ang pangunahing pamamaraan — applicationDidBecomeActive(_:). Ito ay tinatawag sa unang paglunsad ng app at sa pagbabalik mula sa Inactive. Ang pamamaraang ito ay perpektong lugar para sa pagpapatuloy ng mga gawain na nasuspinde kapag pumunta sa Inactive: pagsisimula ng mga animation, pagpapatuloy ng mga timer, pag-restart ng mga sensor, pagsusuri ng mga update ng data sa server.

UIKit: AppDelegate at SceneDelegate

Mula noong iOS 13, ipinakilala ng Apple ang UISceneDelegate para sa suporta ng maraming window sa iPad. Sa kasong ito, ang applicationDidBecomeActive ay pinalitan ng sceneDidBecomeActive para sa bawat eksena. Ang mga app na sumusuporta lamang sa isang screen ay maaaring patuloy na gumamit ng UIApplicationDelegate. Ang parehong mga diskarte ay tinatawag sa sandaling ang app o eksena ay naging aktibo.

import UIKit

@main
class AppDelegate: UIResponder, UIApplicationDelegate {

    // Ang app ay naging aktibo — ipinagpapatuloy ang mga gawain
    func applicationDidBecomeActive(_ application: UIApplication) {
        resumeAnimations()
        restartTimers()
        refreshDataIfNeeded()
        startObservingSensors()
    }

    // Ang app ay nawawalan ng aktibidad — sinuspinde
    func applicationWillResignActive(_ application: UIApplication) {
        pauseAnimations()
        stopTimers()
        saveDraftData()
    }

    private func resumeAnimations() {
        UIView.animate(withDuration: 0.3) {
            // Pagpapatuloy ng mga UI animation
        }
    }

    private func refreshDataIfNeeded() {
        let lastRefresh = UserDefaults.standard.object(forKey: "lastRefresh") as? Date ?? .distantPast
        if Date().timeIntervalSince(lastRefresh) > 300 {
            fetchDataFromServer()
        }
    }
}

Ipinapakita ng code ang tamang paghawak ng Active sa UIKit. applicationDidBecomeActive ay nagpapatuloy ng mga animation, timer at sinusuri kung kinakailangan ang update ng data. applicationWillResignActive ay sumususpinde ng anumang maaaring kumonsumo ng mga mapagkukunan at nagse-save ng mga draft. Ang ganitong pares ng mga pamamaraan ay ginagarantiyahan na ang app ay tumutugon nang tama sa pagbabago ng estado.

SwiftUI: scenePhase

Sa SwiftUI, walang AppDelegate — ang pamamahala ng estado ay sa pamamagitan ng Environment<ScenePhase>. Ang halagang .active ay nakatakda kapag ang eksena ay nasa foreground at interaktibo. Awtomatikong ni-restart ng SwiftUI ang mga animation at update sa pagbabalik sa Active. Kailangan lang mag-subscribe ang developer sa onChange upang maisagawa ang mga side effect.

import SwiftUI

@main
struct ActiveDemoApp: App {
    @Environment(\.scenePhase) private var scenePhase

    var body: some Scene {
        WindowGroup {
            ContentView()
        }
        .onChange(of: scenePhase) { oldPhase, newPhase in
            switch newPhase {
            case .active:
                print("Ang eksena ay naging aktibo")
                resumeWork()
            case .inactive:
                print("Ang eksena ay naging hindi aktibo")
                pauseWork()
            case .background:
                print("Ang eksena ay pumunta sa background")
                saveState()
            @unknown default:
                break
            }
        }
    }

    private func resumeWork() {
        // Pagpapatuloy ng mga network request, animation
    }

    private func pauseWork() {
        // Pagsuspinde ng mga gawaing sensitibo sa oras
    }

    private func saveState() {
        // Pag-save ng estado ng app
    }
}

Sa SwiftUI, ang scenePhase ay ang tanging pinagmumulan ng katotohanan tungkol sa estado ng app. Pinapayagan ng onChange ang pagsasagawa ng mga aksyon sa bawat transisyon. Mahalagang tandaan na ang scenePhase ay available lamang sa iOS 14+ at sa SwiftUI Lifecycle. Para sa mga UIKit app na may SwiftUI screen, gamitin ang diskarte sa UIApplicationDelegate.

Mga transisyon sa estado Active

Active ay maaaring makamit sa pamamagitan ng ilang paraan. Una at malinaw — malamig na pagsisimula: pinindot ng user ang icon, ang app ay pumunta mula Not Running sa pamamagitan ng Inactive patungo sa Active. Pangalawa — pagbabalik mula sa background: ang user ay lumipat pabalik sa app sa pamamagitan ng App Switcher, ang app ay dumaan sa Inactive at naging Active. Pangatlo — pagbabalik mula sa pansamantalang pagkagambala: tinatapos ng user ang tawag, isinasara ang Control Center o tumutugon sa notipikasyon — ang app ay bumalik mula sa Inactive patungo sa Active.

Kadena ng mga transisyon sa Active

Not Running → Inactive → Active — malamig na pagsisimula. Background → Inactive → Active — pagbabalik mula sa background. Inactive → Active — pagbabalik mula sa pansamantalang pagkagambala. Sa bawat kaso, ang applicationDidBecomeActive ay tinatawag, ngunit ang konteksto ay maaaring mag-iba. Sa malamig na pagsisimula, bago ang Active, ang didFinishLaunchingWithOptions ay tinatawag, sa pagbabalik mula sa background — willEnterForeground. Maaaring gamitin ng developer ang mga pagkakaibang ito upang pumili ng estratehiya para sa pagpapanumbalik ng estado.

Mahalagang tala: sa pagbabalik mula sa Suspended, hindi tinatawagan ng iOS ang didFinishLaunchingWithOptions, dahil ang app ay na-load na sa memorya. Ibig sabihin, ang code ng pagsisimula na inilagay sa pamamaraang ito ay hindi naisakatuparan muli. Madalas itong nakakalimutan ng mga developer at inililipat ang kritikal na lohika sa applicationWillEnterForeground o applicationDidBecomeActive para sa parehong mga scenario.

Active sa Android: lifecycle ng Activity

Sa Android, ang katumbas ng Active ay ang estado ng Activity pagkatapos ng tawag sa onResume(). Ang Activity ay itinuturing na aktibo kapag ito ay nasa foreground at tumatanggap ng user input. Ang estadong ito ay tumutugma sa tuktok ng stack ng Activity. Kung ang ibang Activity ay lumitaw sa itaas (kahit bahagya), ang kasalukuyang Activity ay pumunta sa estado onPause — katumbas ng iOS Inactive.

Ang pangunahing pagkakaiba ng Android — maraming Activity ay maaaring aktibo nang sabay-sabay sa multi-window mode (split screen, freeform). Sa kasong ito, ang Activity na nakikipag-ugnayan sa user ay itinuturing na aktibo, at ang katabi — suspendido (onPause). Ang iOS ay hindi sumusuporta ng multi-window sa iPhone, lamang sa iPad sa pamamagitan ng UIScene.

class MainActivity : AppCompatActivity() {

    override fun onResume() {
        super.onResume()
        // Ang app ay naging aktibo — ipinagpapatuloy ang mga gawain
        resumeCameraPreview()
        startLocationUpdates()
        activateSensors()
    }

    override fun onPause() {
        super.onPause()
        // Ang app ay nawawalan ng aktibidad — pinapalaya ang mga mapagkukunan
        releaseCamera()
        stopLocationUpdates()
        deactivateSensors()
    }

    private fun resumeCameraPreview() {
        // Pagsisimula ng preview ng camera (nangangailangan ng pahintulot)
        cameraProvider?.unbindAll()
        cameraProvider?.bindToLifecycle(
            this,
            cameraSelector,
            preview,
            imageAnalyzer
        )
    }

    private fun startLocationUpdates() {
        val locationRequest = LocationRequest.Builder(
            Priority.PRIORITY_HIGH_ACCURACY, 5000
        ).build()
        locationClient.requestLocationUpdates(
            locationRequest,
            locationCallback,
            Looper.getMainLooper()
        )
    }
}

Ipinapakita ng code ang paghawak ng Active sa Android sa pamamagitan ng onResume/onPause. Ipinagpapatuloy ng onResume ang trabaho sa camera, geolokasyon at mga sensor — mga mapagkukunan na dapat aktibo lamang kapag ang app ay nakikita ng user. Pinapalaya ng onPause ang mga mapagkukunang ito upang hindi maubos ang baterya. Awtomatikong pinipigilan ng CameraX lifecycle-aware API ang preview sa onPause.

Mga pinakamahusay na kasanayan sa paghawak ng Active

Unang tuntunin — huwag magsagawa ng mabibigat na operasyon sa applicationDidBecomeActive o onResume. Pag-load ng data, pag-parse ng JSON, pagtatrabaho sa database — lahat ng ito ay dapat asynchronous at hindi harangan ang pangunahing thread. Gamitin ang GCD (DispatchQueue) sa iOS at Coroutines sa Kotlin para sa mga gawain sa background. Ang pangunahing thread ay dapat lamang mag-update ng UI at magsimula ng mga asynchronous na operasyon.

Ikalawang tuntunin — i-synchronize ang estado sa bawat pagbabalik sa Active. Maaaring binago ng user ang mga setting sa system app, nakatanggap ng push notification o nag-update ng data sa ibang app. Suriin ang aktuwalidad ng cache sa transisyon sa Active — maaaring luma na ang data sa panahon ng pagkawala ng user.

Ikatlong tuntunin — huwag umasa sa Active bilang nag-iisang estado. Maaaring laktawan ng app ang Active at direktang pumunta mula Not Running patungong Background (kung pinatakbo sa background). Sa iOS, ito ay nangyayari sa paglunsad sa pamamagitan ng push notification na may opsyon na content-available. Sa Android — sa paglunsad sa pamamagitan ng BroadcastReceiver. Palaging suriin ang kasalukuyang estado bago magsagawa ng mga operasyon sa UI.

Ikaapat na tuntunin — gamitin ang Activity Result API sa Android sa halip na onActivityResult. Ito ay nagpapahintulot sa paghawak ng resulta ng tawag sa camera, gallery o mga pahintulot nang direkta sa Active state nang walang pagkawala ng data sa muling paggawa ng Activity. Para sa iOS, gamitin ang async/await sa UIApplication.shared.open para sa mga system dialog.

import UIKit

final class ActiveStateManager {
    static let shared = ActiveStateManager()
    private var isActive = false

    func setActive(_ active: Bool) {
        isActive = active
        if active {
            NotificationCenter.default.post(name: .appDidBecomeActive, object: nil)
        }
    }

    func performWhenActive(_ block: @escaping () -> Void) {
        if isActive {
            block()
        } else {
            // Ipagpaliban ang pagpapatupad hanggang sa pagbabalik sa Active
            NotificationCenter.default.addObserver(
                forName: .appDidBecomeActive,
                object: nil,
                queue: .main
            ) { _ in
                block()
            }
        }
    }
}

extension Notification.Name {
    static let appDidBecomeActive = Notification.Name("appDidBecomeActive")
}

Ipinapakita ng code ang manager ng estado Active na nagpapahintulot sa iba pang mga bahagi ng app na suriin ang kasalukuyang aktibong estado. performWhenActive ay isinasagawa ang block kaagad (kung aktibo ang app) o ipinagpapaliban ang pagpapatupad hanggang sa pagbabalik sa Active. Ito ay kapaki-pakinabang para sa mga serbisyo na dapat magsagawa ng aksyon pagkatapos bumalik ang user sa app.