Inactive — ang esensya, transisyonal na estado sa pagitan ng Active at Background

Inactive — ang esensya ng transisyonal na estado

Inactive — isang intermediate na estado ng lifecycle ng mobile app na nangyayari sa paglipat sa pagitan ng Active at Background. Sa estadong ito, ang app ay nasa foreground pa rin at nakikita ng user, ngunit hindi tumatanggap ng mga touch event, pagpindot ng key, o iba pang UI event. Hinaharang ng sistema ang pagpapadala ng mga event sa app, ngunit ang UI ay nananatili sa screen at hindi na-minimize.

Ang kalikasan ng Inactive ay pansamantala. Ang estadong ito ay tumatagal nang eksakto hangga't tumatagal ang sistema interrupt: mula 0.1 segundo sa mabilis na pagsasara ng Control Center hanggang ilang segundo sa isang papasok na tawag na may screen ng tawag. Pagkatapos ng interrupt, ang app ay babalik sa Active o pupunta sa Background kung ang user ay lumipat sa ibang app. Ang Inactive ay ang tanging estado kung saan posible ang paglipat sa parehong direksyon: pabalik sa Active o higit pa sa Background.

Sa iOS, ang Inactive ay awtomatikong pinamamahalaan ng sistema. Hindi maaaring pahabain o paikliin ng developer ang oras na ginugol sa Inactive — ito ay ganap na kontrolado ng UIApplication. Ang tanging bagay na magagawa ng developer ay ang maayos na pangasiwaan ang paglipat sa Inactive sa pamamagitan ng applicationWillResignActive at ang pagbabalik sa pamamagitan ng applicationDidBecomeActive. Sa Android, ang analog ay onPause, bagama't naiiba ang semantika: ang onPause ay tinatawag kahit na sa bahagyang pagtakip ng Activity ng ibang component.

Paghahambing ng Inactive sa iOS at Android

Sa iOS, ang Inactive ay isang hiwalay na estado ng lifecycle ng app (isa sa lima: Not Running, Active, Inactive, Background, Suspended). Sa Android, walang direktang analog — ang onPause ay nagpapahiwatig na ang Activity ay nawawalan ng input focus, ngunit maaaring manatiling nakikita (halimbawa, sa pagbubukas ng dialog). Ang pangunahing pagkakaiba: ang iOS Inactive ay estado ng app sa kabuuan, ang Android onPause ay estado ng isang partikular na Activity. Sa multi-window mode sa Android, ang isang Activity ay maaaring nasa onPause (walang focus) habang ang isa ay nasa onResume (may focus).

Kailan nangyayari ang Inactive

Inactive sa iOS ay nangyayari sa ilang mahigpit na tinukoy na mga senaryo. Tinatawag ng user ang Control Center (pag-swipe pababa mula sa kanang itaas na sulok sa iPhone X+ o pag-swipe pataas sa mga lumang modelo). Binuksan ng user ang Notification Center (pag-swipe pababa mula sa kaliwang itaas na sulok). Dumating ang isang papasok na tawag — ipinapakita ng sistema ang screen ng tawag sa ibabaw ng app. Hinihiling ang pahintulot ng sistema — geolokasyon, mikropono, kamera, mga contact. Sa iPad, inilunsad ang Slide Over o Split View — ang aktibong scene ay nagiging Inactive.

Sa Android, ang onPause (analog ng Inactive) ay nangyayari sa mas malawak na hanay ng mga sitwasyon. Pagbubukas ng dialog window (AlertDialog, DialogFragment). Bahagyang pagtakip ng Activity ng isa pang Activity (halimbawa, transparent Activity para sa pagpapatunay). Pag-ikot ng screen (ang Activity ay muling nilikha, pagkakasunod-sunod: onPause → onStop → onDestroy → onCreate → onStart → onResume). Multi-window mode — ang hindi aktibong window ay tumatanggap ng onPause. Ang bawat isa sa mga event na ito ay nangangailangan ng pagsuspinde ng mga operasyong masinsin sa mapagkukunan upang makatipid ng baterya at pagganap.

import UIKit

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

@main
class AppDelegate: UIResponder, UIApplicationDelegate {

    func applicationWillResignActive(_ application: UIApplication) {
        // App ay pumapasok sa Inactive — sistema interrupt
        print("Interrupt: Control Center, tawag o sistema alert")

        // Pagsususpinde ng mga operasyong sensitibo sa oras
        pauseVideoPlayback()
        stopContinuousDataCollection()
        hideSensitiveInformation()

        // Pag-abiso sa mga component
        NotificationCenter.default.post(name: .systemInterruptionBegan, object: nil)
    }

    // Pagbabalik mula Inactive patungong Active
    func applicationDidBecomeActive(_ application: UIApplication) {
        resumeVideoPlayback()
        restartDataCollection()
        NotificationCenter.default.post(name: .systemInterruptionEnded, object: nil)
    }

    private func pauseVideoPlayback() {
        // Pag-pause ng video upang hindi mag-overlap ang tunog
    }

    private func hideSensitiveInformation() {
        // Pagtatago ng sensitibong data sa screenshot ng screen
        // Control Center/App Switcher ay kumukuha ng screenshot ng UI
    }
}

Ipinapakita ng code ang paghawak ng Inactive sa UIKit. applicationWillResignActive ay humihinto sa video, humihinto sa pagkolekta ng data, at nagtatago ng sensitibong impormasyon. Ito ay mahalaga dahil kapag binubuksan ang Control Center o App Switcher, ang sistema ay kumukuha ng screenshot ng kasalukuyang UI — maaaring makita ng user ang kumpidensyal na data sa preview. Ang NotificationCenter ay nagpapahintulot sa mga component ng app na mag-subscribe sa mga interrupt event.

Inactive sa iOS: Swift at UIKit

Sa iOS, ang Inactive ay hinahawakan ng isang pares ng mga pamamaraan: applicationWillResignActive (paglipat sa Inactive) at applicationDidBecomeActive (pagbabalik mula sa Inactive). Ang mga pamamaraang ito ay bahagi ng UIApplicationDelegate at tinatawag para sa bawat paglipat sa pamamagitan ng Inactive. Mula noong iOS 13 at UISceneDelegate, ang sceneWillResignActive at sceneDidBecomeActive ay idinagdag para sa multi-window na mga senaryo.

SceneDelegate at multi-window Inactive

Sa iPad na may iOS 13+, ang app ay maaaring magkaroon ng maraming scene (window). Ang bawat scene ay may sariling lifecycle. Ang isang scene ay maaaring maging Inactive (lumipat ang user sa ibang scene), habang ang isa ay nananatiling Active. Ito ay isang mahalagang pagkakaiba kumpara sa iPhone, kung saan ang Inactive ay isang pandaigdigang estado para sa buong app. Kapag bumubuo para sa iPad, ang Inactive ay dapat hawakan nang hiwalay para sa bawat scene.

import UIKit

class SceneDelegate: UIResponder, UIWindowSceneDelegate {

    var window: UIWindow?

    // Scene ay nagiging hindi aktibo
    func sceneWillResignActive(_ scene: UIScene) {
        // Sa iPad, ang scene na ito ay nawawalan ng focus, ngunit ang iba ay maaaring aktibo
        print("Scene ay nawawalan ng aktibidad")

        // Pagsususpinde ng mga gawain ng scene na ito
        pauseSceneSpecificOperations()
    }

    // Scene ay nagiging aktibo
    func sceneDidBecomeActive(_ scene: UIScene) {
        print("Scene ay naging aktibo")
        resumeSceneSpecificOperations()
    }

    private func pauseSceneSpecificOperations() {
        // Pagsususpinde ng mga operasyong tiyak sa scene na ito
    }

    private func resumeSceneSpecificOperations() {
        // Pagpapatuloy ng mga operasyon sa pagbabalik ng focus
    }
}

// AppDelegate ay nananatiling entry point, nagde-delegate sa mga scene
@main
class AppDelegate: UIResponder, UIApplicationDelegate {

    func application(
        _ application: UIApplication,
        configurationForConnecting connectingSceneSession: UISceneSession,
        options: UIScene.ConnectionOptions
    ) -> UISceneConfiguration {
        return UISceneConfiguration(
            name: "Default Configuration",
            sessionRole: connectingSceneSession.role
        )
    }
}

Ipinapakita ng code ang SceneDelegate para sa paghawak ng Inactive sa antas ng scene. sceneWillResignActive ay tinatawag kapag ang isang partikular na window ay nawawalan ng focus — ito ay maaaring mangyari kapag lumilipat sa pagitan ng mga window sa iPad. Ang AppDelegate ay nagko-configure ng UISceneConfiguration para sa suporta ng multi-window. Ang bawat scene ay may independiyenteng estado at dapat hawakan ng developer ang mga ito nang hiwalay.

Inactive sa Android: onPause at visibility

Sa Android, ang direktang analog ng iOS Inactive ay ang pamamaraang onPause() ng lifecycle ng Activity. Ito ay tinatawag kapag ang Activity ay nawawalan ng input focus, ngunit maaaring manatiling nakikita. Mga tipikal na senaryo: pagbubukas ng dialog window, paglulunsad ng isa pang Activity sa parehong app, papasok na tawag, pagpindot sa Home o Recents button. Sa onPause, dapat i-suspend ng developer ang mga operasyong masinsin sa mapagkukunan — mga animasyon, pag-playback ng video, pagtatrabaho sa camera.

Isang mahalagang pagkakaiba sa Android — ang onPause ay palaging nauuna sa onStop, ngunit hindi kabaligtaran. Ang Activity ay maaaring makatanggap ng onPause nang walang onStop (halimbawa, sa pagbubukas ng transparent Activity). Gayundin, ang onPause ay maaaring tawagin nang maraming beses sa buhay ng Activity — sa bawat pagbabago ng focus. Huwag maglagay ng isang beses na lohika sa onPause — gamitin ang onStop para sa mga huling operasyon at onPause lamang para sa pagsususpinde ng mga interaktibong aksyon.

class VideoPlayerActivity : AppCompatActivity() {

    private var exoPlayer: ExoPlayer? = null
    private var currentPosition: Long = 0L

    override fun onPause() {
        super.onPause()
        // App ay nawawalan ng focus — i-pause ang video
        exoPlayer?.let { player ->
            if (player.isPlaying) {
                currentPosition = player.currentPosition
                player.pause()
            }
        }
        // Itinatago ang sensitibong data (GDPR/mga screen ng bangko)
        if (window.decorView.systemUiVisibility and
            View.SYSTEM_UI_FLAG_SECURE == 0
        ) {
            hideSensitiveOverlay()
        }
    }

    override fun onResume() {
        super.onResume()
        // Pagbabalik ng focus — ipagpatuloy ang playback
        exoPlayer?.seekTo(currentPosition)
        exoPlayer?.play()
        showSensitiveOverlay()
    }

    private fun hideSensitiveOverlay() {
        // Maglagay ng itim na screen sa ibabaw ng pinansyal na data
    }
}

Ipinapakita ng code ang tamang paghawak ng onPause para sa isang video player. Ang ExoPlayer ay naka-pause kapag nawalan ng focus, at ang posisyon ng playback ay nai-save. Sa pagbabalik sa onResume, ang player ay nagpapatuloy ng playback mula sa nai-save na posisyon. Bukod pa rito, ipinapakita ang pattern ng pagtatago ng sensitibong data — mahalaga para sa mga pinansyal at medikal na app na nangangailangan ng proteksyon mula sa mga screenshot kapag lumilipat.

Mga pinakamahusay na kasanayan sa paghawak ng Inactive

Unang panuntunan — itago ang kumpidensyal na data sa paglipat sa Inactive. Kapag binuksan ng user ang Control Center o App Switcher, kumukuha ang iOS ng screenshot ng kasalukuyang screen. Sa Android, katulad — ipinapakita ng sistema ang preview ng huling Activity sa Recents. Gamitin ang UIApplication.shouldSnapshotSecureApp (iOS 16+) o FLAG_SECURE (Android) para sa proteksyon ng kumpidensyal na mga screen.

Ikalawang panuntunan — i-suspend ang mga animasyon at media. Ang Inactive ay hindi pinakamagandang oras para sa pag-playback ng video o mga animasyon, dahil hindi ito nakikita ng user. Higit pa rito, ang pag-playback sa background ay maaaring magdulot ng pag-overlap ng mga tunog sa mga tunog ng sistema (tawag, notipikasyon). Ihinto ang AVPlayer, ExoPlayer at UIView.animate sa paglipat sa Inactive at ipagpatuloy sa pagbabalik sa Active.

Ikatlong panuntunan — harangan ang input ng data. Kung ang app ay naglalaman ng mga form ng input o draft, harangan ang keyboard at mga field ng input sa paglipat sa Inactive. Pinipigilan nito ang aksidenteng input sa pagbabalik at pinoprotektahan laban sa panghihimasok ng data sa pamamagitan ng mga sistema overlay. Sa iOS, huwag paganahin ang first responder (view.endEditing(true)), sa Android — linisin ang focus (currentFocus?.clearFocus()).

Ikaapat na panuntunan — huwag magsagawa ng mahabang operasyon sa applicationWillResignActive o onPause. Ang mga pamamaraang ito ay dapat makumpleto sa mga bahagi ng segundo. Kung kailangan mag-save ng malaking halaga ng data, simulan ang pag-save sa isang background thread at kumpletuhin ito sa applicationDidEnterBackground o onStop. Ang iOS ay nagbibigay ng 5 segundo para sa pagsasagawa ng applicationWillResignActive, pagkatapos nito ay maaaring puwersahang tapusin ng sistema ang app.

import UIKit

final class SecureOverlayManager {
    private var blurView: UIVisualEffectView?

    func showBlurOverlay() {
        guard let window = UIApplication.shared.keyWindow,
              blurView == nil
        else { return }

        let blur = UIVisualEffectView(effect: UIBlurEffect(style: .dark))
        blur.frame = window.bounds
        blur.autoresizingMask = [.flexibleWidth, .flexibleHeight]
        window.addSubview(blur)
        blurView = blur
    }

    func removeBlurOverlay() {
        blurView?.removeFromSuperview()
        blurView = nil
    }
}

// Paggamit sa AppDelegate
func applicationWillResignActive(_ application: UIApplication) {
    SecureOverlayManager().showBlurOverlay()
}

func applicationDidBecomeActive(_ application: UIApplication) {
    SecureOverlayManager().removeBlurOverlay()
}

Ipinapakita ng code ang implementasyon ng isang ligtas na overlay para sa proteksyon ng data sa paglipat sa Inactive. Ang UIVisualEffectView na may blur effect ay inilalagay sa ibabaw ng buong UI sa paglipat sa Inactive at tinatanggal sa pagbabalik sa Active. Ginagarantiya nito na ang kumpidensyal na data ay hindi makikita sa mga screenshot ng App Switcher at Control Center. Katulad nito, maaaring gamitin ang UIImageView na may logo para sa isang branded overlay.