Active: bu nədir, iOS həyat dövründə Active vəziyyəti

Active: bu hansı vəziyyətdir

Active — mobil tətbiqin həyat dövrünün vəziyyəti, bu zaman o, ön planda yerləşir, cihazın ekranında göstərilir və istifadəçi ilə aktiv qarşılıqlı əlaqədə olur. Bu vəziyyətdə tətbiq bütün toxunma hadisələrini, düymə basışlarını, akselerometr və giroskop məlumatlarını qəbul edir, həmçinin interfeysin render edilməsi üçün qrafik prosessora tam giriş əldə edir.

iOS-da Active vəziyyəti beş vəziyyətli həyat dövrü modelinin bir hissəsidir: Not Running → Inactive → Active → Inactive → Background → Suspended → Not Running. Android-də analoq Activity-nin onResume çağırışından sonrakı vəziyyətidir, bu zaman Activity yığının zirvəsində yerləşir və istifadəçi girişini qəbul edir. Active — UI-nin tam interaktiv olduğu yeganə vəziyyətdir və o, jestlərə, sürüşdürməyə, kliklərə və animasiyalara reaksiya verir.

Sistem Active vəziyyətindəki tətbiqə prosessor və RAM üzrə maksimum prioritet təmin edir. Bu o deməkdir ki, sistem resurs çatışmazlığı zamanı belə tətbiqi dayandırmayacaq — əvvəlcə fon və dayandırılmış proseslər boşaldılacaq. Bununla belə, tətbiq batareyanı boşaltmamaq və CPU throttling-ə səbəb olmamaq üçün resurslardan səmərəli istifadə etməlidir.

İstifadəçi üçün Active tətbiqlə işin normal vəziyyətidir. İstifadəçi interfeysi görür, düymələri basa, formaları doldura, lentdə sürüşdürə bilər. Bu vəziyyətin hər hansı kəsilməsi (zəng, bildiriş, Control Center üçün yuxarı sürüşdürmə) tətbiqi Inactive-ə keçirir, bundan sonra Active-ə qayıda və ya Background-a keçə bilər.

Sistem tətbiqin Active olduğunu necə müəyyənləşdirir

iOS vəziyyətin idarə edilməsi üçün UIApplicationMain-dən istifadə edir. Active-ə keçid zamanı sistem applicationDidBecomeActive-i çağırır. SwiftUI üçün oxşar mexanizm — Environment vasitəsilə scenePhase-ın müşahidəsidir. Android onResume-dan ön planda Activity-nin aktivlik göstəricisi kimi istifadə edir. Hər iki yanaşma təmin edir ki, tətbiq vəziyyət dəyişikliyi barədə bildiriş alsın və davranışını uyğunlaşdırsın.

iOS-da Active: Swift, UIKit və SwiftUI

iOS-da Active vəziyyəti UIApplicationDelegate vasitəsilə idarə olunur. Əsas metod — applicationDidBecomeActive(_:). O, tətbiqin ilk işə salınması zamanı və Inactive-dən qayıdış zamanı çağırılır. Bu metod Inactive-ə keçid zamanı dayandırılmış tapşırıqların bərpası üçün ideal yerdir: animasiyaların işə salınması, timer-lərin bərpası, sensorların yenidən işə salınması, serverdə məlumat yeniləmələrinin yoxlanması.

UIKit: AppDelegate və SceneDelegate

iOS 13-dən etibarən Apple iPad-də çoxlu pəncərələri dəstəkləmək üçün UISceneDelegate təqdim etdi. Bu halda applicationDidBecomeActive hər bir səhnə üçün sceneDidBecomeActive ilə əvəz olunur. Yalnız bir ekranı dəstəkləyən tətbiqlər UIApplicationDelegate-dən istifadə edə bilər. Hər iki yanaşma tətbiq və ya səhnə aktiv olduqda çağırılır.

import UIKit

@main
class AppDelegate: UIResponder, UIApplicationDelegate {

    // Tətbiq aktiv oldu — tapşırıqları bərpa edirik
    func applicationDidBecomeActive(_ application: UIApplication) {
        resumeAnimations()
        restartTimers()
        refreshDataIfNeeded()
        startObservingSensors()
    }

    // Tətbiq aktivliyini itirir — dayandırırıq
    func applicationWillResignActive(_ application: UIApplication) {
        pauseAnimations()
        stopTimers()
        saveDraftData()
    }

    private func resumeAnimations() {
        UIView.animate(withDuration: 0.3) {
            // UI animasiyalarının bərpası
        }
    }

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

Kod UIKit-də Active-in düzgün işlənməsini göstərir. applicationDidBecomeActive animasiyaları, timer-ləri bərpa edir və məlumat yeniləməsinin tələb olunub-olunmadığını yoxlayır. applicationWillResignActive resurs sərf edə biləcək hər şeyi dayandırır və qaralamaları saxlayır. Belə bir cüt metod tətbiqin vəziyyət dəyişikliyinə düzgün reaksiya verməsini təmin edir.

SwiftUI: scenePhase

SwiftUI-də AppDelegate yoxdur — vəziyyətin idarə edilməsi Environment<ScenePhase> vasitəsilə baş verir. .active dəyəri səhnə ön planda olduqda və interaktiv olduqda təyin edilir. SwiftUI Active-ə qayıdış zamanı animasiyaları və yeniləmələri avtomatik olaraq yenidən işə salır. Tərtibatçı yalnız onChange-ə abunə olmalıdır ki, yan təsirləri yerinə yetirsin.

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("Səhnə aktiv oldu")
                resumeWork()
            case .inactive:
                print("Səhnə qeyri-aktiv oldu")
                pauseWork()
            case .background:
                print("Səhnə fon-köçdü")
                saveState()
            @unknown default:
                break
            }
        }
    }

    private func resumeWork() {
        // Network sorğularının, animasiyaların bərpası
    }

    private func pauseWork() {
        // Zamana həssas tapşırıqların dayandırılması
    }

    private func saveState() {
        // Tətbiq vəziyyətinin saxlanması
    }
}

SwiftUI-də scenePhase tətbiqin vəziyyəti haqqında yeganə həqiqət mənbəyidir. onChange hər keçid zamanı hərəkətləri yerinə yetirməyə imkan verir. Yadda saxlamaq lazımdır ki, scenePhase yalnız iOS 14+ və SwiftUI Lifecycle-də mövcuddur. SwiftUI ekranları olan UIKit tətbiqləri üçün UIApplicationDelegate yanaşmasından istifadə edin.

Active vəziyyətinə keçidlər

Active bir neçə yolla əldə edilir. Birinci və ən bariz — soyuq başlanğıc: istifadəçi ikona klik edir, tətbiq Not Running-dan Inactive vasitəsilə Active-ə keçir. İkinci — fondan qayıdış: istifadəçi App Switcher vasitəsilə tətbiqə qayıdır, tətbiq Inactive-dən keçərək Active olur. Üçüncü — müvəqqəti kəsintidən qayıdış: istifadəçi zəngi bitirir, Control Center-i bağlayır və ya bildirişə cavab verir — tətbiq Inactive-dən Active-ə qayıdır.

Active-ə keçid zənciri

Not Running → Inactive → Active — soyuq başlanğıc. Background → Inactive → Active — fondan qayıdış. Inactive → Active — müvəqqəti kəsintidən qayıdış. Hər bir halda applicationDidBecomeActive çağırılır, lakin kontekst fərqli ola bilər. Soyuq başlanğıc zamanı Active-dən əvvəl didFinishLaunchingWithOptions çağırılır, fondan qayıdış zamanı — willEnterForeground. Tərtibatçı bu fərqlərdən vəziyyətin bərpası strategiyasını seçmək üçün istifadə edə bilər.

Vacib qeyd: Suspended-dən qayıdış zamanı iOS didFinishLaunchingWithOptions-u çağırmır, çünki tətbiq artıq yaddaşa yüklənmişdi. Bu o deməkdir ki, bu metoda yerləşdirilən inisializasiya kodu təkrar icra olunmur. Tərtibatçılar tez-tez bunu unudur və kritik məntiqi hər iki ssenari üçün applicationWillEnterForeground və ya applicationDidBecomeActive-ə köçürürlər.

Android-də Active: Activity həyat dövrü

Android-də Active-in analoqu onResume() çağırışından sonrakı Activity vəziyyətidir. Activity o zaman aktiv hesab olunur ki, o, ön planda olsun və istifadəçi girişini qəbul etsin. Bu vəziyyət Activity yığınının zirvəsinə uyğun gəlir. Əgər başqa Activity üstdə görünərsə (hətta qismən), cari Activity onPause vəziyyətinə keçir — iOS Inactive-in analoqu.

Android-in əsas fərqi — multi-window rejimində (split screen, freeform) bir neçə Activity eyni anda aktiv ola bilər. Bu halda istifadəçinin qarşılıqlı əlaqədə olduğu Activity aktiv, qonşu isə dayandırılmış (onPause) sayılır. iOS iPhone-da multi-window-u dəstəkləmir, yalnız iPad-də UIScene vasitəsilə.

class MainActivity : AppCompatActivity() {

    override fun onResume() {
        super.onResume()
        // Tətbiq aktiv oldu — tapşırıqları bərpa edirik
        resumeCameraPreview()
        startLocationUpdates()
        activateSensors()
    }

    override fun onPause() {
        super.onPause()
        // Tətbiq aktivliyini itirir — resursları boşaldırıq
        releaseCamera()
        stopLocationUpdates()
        deactivateSensors()
    }

    private fun resumeCameraPreview() {
        // Kamera ön baxışının işə salınması (icazə tələb olunur)
        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()
        )
    }
}

Kod Android-də Active-in onResume/onPause vasitəsilə işlənməsini göstərir. onResume kamera ilə işi, geolokasiyanı və sensorları bərpa edir — yalnız tətbiq istifadəçiyə görünən zaman aktiv olmalı olan resurslar. onPause batareyanı boşaltmamaq üçün bu resursları sərbəst buraxır. CameraX lifecycle-aware API onPause zamanı avtomatik olaraq ön baxışı dayandırır.

Active-in işlənməsinin ən yaxşı təcrübələri

Birinci qayda — applicationDidBecomeActive və ya onResume-da ağır əməliyyatlar yerinə yetirməyin. Məlumat yükləmə, JSON pars etmə, verilənlər bazası ilə iş — bütün bunlar asinxron olmalı və əsas thread-i bloklamamalıdır. Fon tapşırıqları üçün iOS-da GCD (DispatchQueue), Kotlin-də Coroutines istifadə edin. Əsas thread yalnız UI-ni yeniləməli və asinxron əməliyyatları işə salmalıdır.

İkinci qayda — Active-ə hər qayıdışda vəziyyəti sinxronlaşdırın. İstifadəçi sistem tətbiqində parametrləri dəyişmiş, push-bildiriş almış və ya başqa tətbiqdə məlumatları yeniləmiş ola bilər. Active-ə keçid zamanı keşin aktuallığını yoxlayın — ola bilər ki, məlumatlar istifadəçinin yoxluğu müddətində köhnəlib.

Üçüncü qayda — Active-ə yeganə vəziyyət kimi etibar etməyin. Tətbiq Active-i keçib birbaşa Not Running-dan Background-a keçə bilər (fon rejimində işə salınarsa). iOS-da bu, content-available seçimi ilə push-bildiriş vasitəsilə işə salınma zamanı baş verir. Android-də — BroadcastReceiver vasitəsilə işə salınma zamanı. UI əməliyyatlarını yerinə yetirmədən əvvəl həmişə cari vəziyyəti yoxlayın.

Dördüncü qayda — Android-də onActivityResult əvəzinə Activity Result API-dən istifadə edin. Bu, kamera, qalereya və ya icazələrin çağırışı nəticəsini birbaşa Active vəziyyətində Activity-nin yenidən yaradılması zamanı məlumat itkisi olmadan idarə etməyə imkan verir. iOS üçün sistem dialoqları üçün async/await ilə UIApplication.shared.open istifadə edin.

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 {
            // Active-ə qayıdışa qədər icranı təxirə sal
            NotificationCenter.default.addObserver(
                forName: .appDidBecomeActive,
                object: nil,
                queue: .main
            ) { _ in
                block()
            }
        }
    }
}

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

Kod tətbiqin digər komponentlərinə cari aktiv vəziyyəti yoxlamağa imkan verən Active vəziyyəti menecerini göstərir. performWhenActive ya bloku dərhal icra edir (tətbiq aktivdirsə), ya da icranı Active-ə qayıdışa qədər təxirə salır. Bu, istifadəçi tətbiqə qayıtdıqdan sonra hərəkəti yerinə yetirməli olan xidmətlər üçün faydalıdır.