Active: nedir, iOS yaşam döngüsünde Active durumu

Active: bu hangi durum

Active — mobil uygulamanın yaşam döngüsünün bir durumu, uygulamanın ön planda olduğu, cihaz ekranında görüntülendiği ve kullanıcıyla aktif olarak etkileşime girdiği durumdur. Bu durumda uygulama tüm dokunma olaylarını, tuş basımlarını, ivmeölçer ve jiroskop verilerini alır ve arayüzü oluşturmak için grafik işlemciye tam erişime sahiptir.

iOS'ta Active durumu beş durumlu yaşam döngüsü modelinin bir parçasıdır: Not Running → Inactive → Active → Inactive → Background → Suspended → Not Running. Android'de benzeri, onResume çağrısından sonra Activity'nin yığının tepesinde olduğu ve kullanıcı girdisi aldığı durumdur. Active, UI'nin tamamen etkileşimli olduğu tek durumdur ve jestlere, kaydırmaya, basmalara ve animasyonlara yanıt verir.

Sistem, Active'deki uygulamaya CPU ve RAM açısından maksimum öncelik sağlar. Bu, kaynak yetersizliğinde sistemin böyle bir uygulamayı sonlandırmayacağı anlamına gelir — önce arka plan ve askıya alınmış işlemler boşaltılır. Ancak uygulama, pili tüketmemek ve CPU darboğazına neden olmamak için kaynakları verimli kullanmalıdır.

Kullanıcı için Active, uygulamayla çalışmanın normal durumudur. Kullanıcı arayüzü görür, düğmelere basabilir, formları doldurabilir, akışı kaydırabilir. Bu durumun herhangi bir kesintisi (arama, bildirim, Control Center için yukarı kaydırma) uygulamayı Inactive'e götürür, ardından Active'e dönebilir veya Background'a gidebilir.

Sistem, uygulamanın Active olduğunu nasıl belirler

iOS, durumu yönetmek için UIApplicationMain kullanır. Active'e geçişte sistem applicationDidBecomeActive'i çağırır. SwiftUI için benzer mekanizma, Environment aracılığıyla scenePhase'in izlenmesidir. Android, ön planda Activity'nin etkinlik göstergesi olarak onResume'u kullanır. Her iki yaklaşım da uygulamanın durum değişikliği bildirimi almasını ve davranışını uyarlayabilmesini sağlar.

iOS'ta Active: Swift, UIKit ve SwiftUI

iOS'ta Active durumu UIApplicationDelegate aracılığıyla yönetilir. Ana yöntem — applicationDidBecomeActive(_:). Uygulamanın ilk başlatılmasında ve Inactive'den dönüşte çağrılır. Bu yöntem, Inactive'e girişte askıya alınan görevleri sürdürmek için ideal yerdir: animasyonları başlatmak, zamanlayıcıları sürdürmek, sensörleri yeniden başlatmak, sunucudaki veri güncellemelerini kontrol etmek.

UIKit: AppDelegate ve SceneDelegate

iOS 13'ten itibaren Apple, iPad'de birden çok pencereyi desteklemek için UISceneDelegate'ı tanıttı. Bu durumda applicationDidBecomeActive, her bir sahne için sceneDidBecomeActive ile değiştirilir. Yalnızca bir ekranı destekleyen uygulamalar UIApplicationDelegate kullanmaya devam edebilir. Her iki yaklaşım da uygulama veya sahne aktif hale geldiğinde çağrılır.

import UIKit

@main
class AppDelegate: UIResponder, UIApplicationDelegate {

    // Uygulama aktif oldu — görevleri sürdürüyoruz
    func applicationDidBecomeActive(_ application: UIApplication) {
        resumeAnimations()
        restartTimers()
        refreshDataIfNeeded()
        startObservingSensors()
    }

    // Uygulama etkinliğini kaybediyor — askıya alıyoruz
    func applicationWillResignActive(_ application: UIApplication) {
        pauseAnimations()
        stopTimers()
        saveDraftData()
    }

    private func resumeAnimations() {
        UIView.animate(withDuration: 0.3) {
            // UI animasyonlarını sürdürme
        }
    }

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

Kod, UIKit'te Active'in doğru şekilde işlenmesini gösterir. applicationDidBecomeActive animasyonları, zamanlayıcıları sürdürür ve veri güncellemesi gerekip gerekmediğini kontrol eder. applicationWillResignActive, kaynak tüketebilecek her şeyi askıya alır ve taslakları kaydeder. Böyle bir yöntem çifti, uygulamanın durum değişikliğine doğru tepki vermesini sağlar.

SwiftUI: scenePhase

SwiftUI'de AppDelegate yoktur — durum yönetimi Environment<ScenePhase> aracılığıyla gerçekleşir. .active değeri, sahne ön planda ve etkileşimli olduğunda ayarlanır. SwiftUI, Active'e dönüşte animasyonları ve güncellemeleri otomatik olarak yeniden başlatır. Geliştiricinin yalnızca onChange'e abone olması yeterlidir yan etkileri gerçekleştirmek için.

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("Sahne aktif hale geldi")
                resumeWork()
            case .inactive:
                print("Sahne aktif olmayan hale geldi")
                pauseWork()
            case .background:
                print("Sahne arka plana gitti")
                saveState()
            @unknown default:
                break
            }
        }
    }

    private func resumeWork() {
        // Ağ isteklerini, animasyonları sürdürme
    }

    private func pauseWork() {
        // Zamana duyarlı görevleri askıya alma
    }

    private func saveState() {
        // Uygulama durumunu kaydetme
    }
}

SwiftUI'de scenePhase, uygulama durumu hakkında tek gerçek kaynağıdır. onChange, her geçişte eylemler gerçekleştirmeye olanak tanır. scenePhase'in yalnızca iOS 14+ ve SwiftUI Lifecycle'da kullanılabildiğini unutmamak önemlidir. SwiftUI ekranları olan UIKit uygulamaları için UIApplicationDelegate yaklaşımını kullanın.

Active durumuna geçişler

Active birkaç yolla elde edilir. İlk ve bariz olan — soğuk başlatma: kullanıcı simgeye tıklar, uygulama Not Running'den Inactive üzerinden Active'e geçer. İkincisi — arka plandan dönüş: kullanıcı App Switcher aracılığıyla uygulamaya geri döner, uygulama Inactive'den geçer ve Active olur. Üçüncüsü — geçici kesintiden dönüş: kullanıcı aramayı bitirir, Control Center'ı kapatır veya bir bildirime yanıt verir — uygulama Inactive'den Active'e döner.

Active'e geçiş zinciri

Not Running → Inactive → Active — soğuk başlatma. Background → Inactive → Active — arka plandan dönüş. Inactive → Active — geçici kesintiden dönüş. Her durumda applicationDidBecomeActive çağrılır, ancak bağlam farklı olabilir. Soğuk başlatmada Active'den önce didFinishLaunchingWithOptions çağrılır, arka plandan dönüşte — willEnterForeground. Geliştirici, durum kurtarma stratejisini seçmek için bu farklılıkları kullanabilir.

Önemli not: Suspended'dan dönüşte iOS, didFinishLaunchingWithOptions'ı çağırmaz çünkü uygulama zaten belleğe yüklenmiştir. Bu, bu yönteme yerleştirilen başlatma kodunun yeniden yürütülmediği anlamına gelir. Geliştiriciler genellikle bunu unutur ve kritik mantığı her iki senaryo için applicationWillEnterForeground veya applicationDidBecomeActive'e taşır.

Android'de Active: Activity yaşam döngüsü

Android'de Active'in benzeri, onResume() çağrısından sonraki Activity durumudur. Activity, ön planda olduğunda ve kullanıcı girdisi aldığında aktif olarak kabul edilir. Bu durum, Activity yığınının tepesine karşılık gelir. Başka bir Activity üstte görünürse (kısmen bile olsa), mevcut Activity onPause durumuna geçer — iOS Inactive'in benzeri.

Android'in temel farkı — multi-window modunda (split screen, freeform) birden çok Activity aynı anda aktif olabilir. Bu durumda kullanıcının etkileşimde olduğu Activity aktif olarak kabul edilir, yanındaki ise duraklatılır (onPause). iOS, iPhone'da multi-window'u desteklemez, yalnızca iPad'de UIScene aracılığıyla.

class MainActivity : AppCompatActivity() {

    override fun onResume() {
        super.onResume()
        // Uygulama aktif oldu — görevleri sürdürüyoruz
        resumeCameraPreview()
        startLocationUpdates()
        activateSensors()
    }

    override fun onPause() {
        super.onPause()
        // Uygulama etkinliğini kaybediyor — kaynakları serbest bırakıyoruz
        releaseCamera()
        stopLocationUpdates()
        deactivateSensors()
    }

    private fun resumeCameraPreview() {
        // Kamera önizlemesini başlatma (izin gerektirir)
        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'de onResume/onPause aracılığıyla Active yönetimini gösterir. onResume, kamera, coğrafi konum ve sensörlerle çalışmayı sürdürür — yalnızca uygulama kullanıcıya görünür olduğunda aktif olması gereken kaynaklar. onPause, pili tüketmemek için bu kaynakları serbest bırakır. CameraX lifecycle-aware API, onPause'da önizlemeyi otomatik olarak duraklatır.

Active yönetimi için en iyi uygulamalar

Birinci kural — applicationDidBecomeActive veya onResume'da ağır işlemler yapmayın. Veri yükleme, JSON ayrıştırma, veritabanıyla çalışma — tümü eşzamansız olmalı ve ana iş parçacığını bloke etmemelidir. Arka plan görevleri için iOS'ta GCD (DispatchQueue) ve Kotlin'de Coroutines kullanın. Ana iş parçacığı yalnızca UI'yi güncellemeli ve eşzamansız işlemleri başlatmalıdır.

İkinci kural — Active'e her dönüşte durumu senkronize edin. Kullanıcı sistem uygulamasında ayarları değiştirmiş, push bildirimi almış veya başka bir uygulamada verileri güncellemiş olabilir. Active'e geçişte önbelleğin geçerliliğini kontrol edin — kullanıcının yokluğunda veriler güncelliğini yitirmiş olabilir.

Üçüncü kural — Active'i tek durum olarak kabul etmeyin. Uygulama Active'i atlayabilir ve doğrudan Not Running'den Background'a geçebilir (arka plan modunda başlatılırsa). iOS'ta bu, content-available seçeneğiyle push bildirimi yoluyla başlatmada olur. Android'de — BroadcastReceiver aracılığıyla başlatmada. UI işlemlerini gerçekleştirmeden önce her zaman geçerli durumu kontrol edin.

Dördüncü kural — onActivityResult yerine Android'de Activity Result API kullanın. Bu, Active durumunda kamera, galeri veya izin çağrısının sonucunu, Activity yeniden oluşturulduğunda veri kaybı olmadan işlemeye olanak tanır. iOS için sistem diyalogları için UIApplication.shared.open ile async/await kullanın.

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'e dönene kadar yürütmeyi ertele
            NotificationCenter.default.addObserver(
                forName: .appDidBecomeActive,
                object: nil,
                queue: .main
            ) { _ in
                block()
            }
        }
    }
}

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

Kod, uygulamanın diğer bileşenlerinin geçerli aktif durumu kontrol etmesine olanak tanıyan bir Active durum yöneticisini gösterir. performWhenActive, uygulama aktifse bloğu hemen yürütür veya Active'e dönene kadar yürütmeyi erteler. Bu, kullanıcı uygulamaya döndükten sonra bir eylem gerçekleştirmesi gereken hizmetler için kullanışlıdır.