---
title: 'Uygulama Yaşam Döngüsü'
source: 'https://academia.sh/tr/kurslar/ios-platformu/uygulama-yasam-dongusu'
course: 'iOS Platformu ve Araçlar'
language: tr
updated: '2026-10-21T05:03:10+00:00'
license: 'CC BY-SA 4.0'
objectives:
    - 'Uygulamanın ön plan ve arka plan arasındaki durum geçişlerini sıralar'
    - 'Sahne temsilcisinin işleyicisinin uygulama temsilcisininkine üstün geldiğini ölçer'
    - 'Bildirilen arka plan kiplerinin platformun izin verdikleriyle kesiştiğini ölçer'
    - 'Geçiş sırasının buluşmanın sınıfını değiştirmediğini gösterir'
---

# Uygulama Yaşam Döngüsü

Sahne temsilcisinin işleyicisinin uygulama temsilcisininkine üstün geldiğinin ve bildirilen arka plan kiplerinin platformun izin verdikleriyle kesiştiğinin ölçümü.

Önceki derste uygulamanın istediği ile kullanıcının verdiği buluştu ve kesişim çıktı. Bu derste iki tanım iki işleyici olur: aynı olayı hem uygulama temsilcisi hem sahne temsilcisi işleyebilir. Soru yine aynı: **bu iki tanım buluşunca nasıl çözülüyor?** Bu derste bakılan çözüm **öncelik**: iki işleyiciden biri çalışır, öbürü çalışmaz.

Uygulama yaşam döngüsü (app lifecycle), uygulamanın başlamasından sonlanmasına kadar geçtiği durumların sıralamasıdır. Uygulama çalışmıyor olabilir, ön planda etkin olabilir, ön planda ama etkin olmayabilir (örneğin bir sistem uyarısı ekranı kapattığında), arka planda çalışıyor ya da askıda olabilir. Her durum geçişi (state transition) bir olaydır ve platform bu olayı uygulamaya bir işleyici çağırarak bildirir. İşleyicilerin nerede tanımlandığı ise iki yerden biridir.

```swift
// Meeting.swift — iki tanim bulusunca nasil cozuldugunu siniflandirir
struct Meeting {
    let label: String
    let first: Set<String>
    let second: Set<String>
    let result: Set<String>?

    init(_ label: String, first: Set<String>, second: Set<String>, result: Set<String>?) {
        self.label = label
        self.first = first
        self.second = second
        self.result = result
    }

    var resolution: String {
        if first.isEmpty || second.isEmpty
            || first.isSubset(of: second) || second.isSubset(of: first) {
            return "olcum-disi"
        }
        guard let result, !result.isEmpty else { return "ret" }
        if result == first.union(second) { return "birlesim" }
        if result == first.intersection(second) { return "kesisim" }
        if result == first || result == second { return "oncelik" }
        return "kural-disi"
    }

    static func list(_ values: Set<String>) -> String {
        values.isEmpty ? "bos" : values.sorted().joined(separator: ",")
    }

    func report() {
        let outcome = result.map(Meeting.list) ?? "yok"
        print("\(label): ilk \(Meeting.list(first)) | ikinci \(Meeting.list(second)) | sonuc \(outcome) -> \(resolution)")
    }
}

func summarize(_ meetings: [Meeting]) {
    for resolution in ["oncelik", "kesisim", "birlesim", "ret"] {
        let count = meetings.filter { $0.resolution == resolution }.count
        print("\(resolution): \(count)")
    }
}
```

## Uygulama Temsilcisi ve Sahne Temsilcisi

Bir uygulamanın ekranda birden çok penceresi olabilir; her pencere grubu bir sahne (scene) olarak yönetilir ve her sahnenin kendi yaşam döngüsü vardır. Uygulama temsilcisi (app delegate) uygulama genelindeki olaylara bakar: başlatma, bildirim kaydı, sistem düzeyinde uyarılar. Sahne temsilcisi (scene delegate) ise o sahneye ait olayları işler: sahnenin bağlanması, ön plana geçmesi, arka plana inmesi. Sahne kullanan bir uygulamada ön plan ve arka plan geçişleri sahne temsilcisine gelir; bu geçişlere ait eski uygulama düzeyi işleyiciler artık çağrılmaz. İki işleyici de tanımlı olduğunda hangisinin çalışacağı sorusunun cevabı bu kuraldır.

Aşağıdaki parça platform çerçevesine dayandığı için kaynak olarak durur ve çıktısı iddia edilmez. Aynı geçiş için iki temsilci de işleyici tanımlar.

```swift
// Kaynak parca: iki temsilci de arka plana gecisi isleyebilir
import UIKit

final class AppDelegate: UIResponder, UIApplicationDelegate {
    func applicationDidEnterBackground(_ application: UIApplication) {
        // uygulama duzeyindeki isleyici
    }
}

final class SceneDelegate: UIResponder, UIWindowSceneDelegate {
    func sceneDidEnterBackground(_ scene: UIScene) {
        // sahne duzeyindeki isleyici
    }
}
```

Aşağıdaki yardımcı iki kuralı modeller. İlki bir olay için işleyici arar: sahne temsilcisinde varsa onu, yoksa uygulama temsilcisindekini verir, ikisi de yoksa sonuç vermez. İkincisi uygulamanın bildirdiği arka plan kiplerini platformun izin verdikleriyle süzer. Dosyanın çıktısı yoktur.

```swift
// Handlers.swift — olay isleyicisini ve arka plan kiplerini cozer
func handler(for event: String, scene: [String: String], app: [String: String]) -> Set<String>? {
    if let found = scene[event] { return [found] }
    if let found = app[event] { return [found] }
    return nil
}

func permittedModes(declared: Set<String>, platform: Set<String>) -> Set<String> {
    declared.filter { platform.contains($0) }
}
```

## Aynı Olay, İki İşleyici

Aşağıdaki ölçüm `on-plana-gec` olayı için iki işleyici kurar: biri uygulama temsilcisinde, biri sahne temsilcisinde. Uygulama temsilcisi ayrıca yalnız kendisinin işlediği bir olayı da tanımlar. `handler` hangi işleyicinin çalışacağını verir.

```swift
// main.swift — sahne isleyicisi uygulama isleyicisinin onune gecer
let appHandlers = ["on-plana-gec": "uygulama.on-plana-gec", "arka-plana-gec": "uygulama.arka-plana-gec"]
let sceneHandlers = ["on-plana-gec": "sahne.on-plana-gec"]

let event = "on-plana-gec"
let both = Meeting("isleyici",
                   first: [appHandlers[event]!],
                   second: [sceneHandlers[event]!],
                   result: handler(for: event, scene: sceneHandlers, app: appHandlers))
both.report()
```

```
isleyici: ilk uygulama.on-plana-gec | ikinci sahne.on-plana-gec | sonuc sahne.on-plana-gec -> oncelik
```

Sonuç ikinci taraftır, yani sahne işleyicisi: uygulama işleyicisi düştü. Bu öncelik bir kural olarak çalışır, bir yarış gibi değil; hangisinin önce yazıldığına ya da hangisinin önce derlendiğine bağlı değildir. Sahne işleyicisi tanımlı olmasaydı `arka-plana-gec` olayında olduğu gibi uygulama işleyicisi kalırdı; o durumda buluşma kurulmaz, çünkü ortada tek bir tanım vardır.

**PY10.** Bu ölçüm yalnız `on-plana-gec` olayı ve iki temsilcinin ikisinde de tanımlı işleyici için. Model, platformun bu kuralını kurar; gerçek sistemin başka olaylarda (başlatma, bildirim kaydı) aynı sırayı izlediği ölçülmedi.

## Arka Plan Kipleri

Uygulama arka planda ne yapabileceğini özellik listesinde bildirir: konum güncellemesi almak, ses çalmak, veri getirmek gibi. Bildirim tek başına yetmez; platform her kip için kendi koşullarını uygular ve bildirilen her kipe izin vermeyebilir. Çalışabilen kipler, bildirilenler ile platformun izin verdiklerinin ortak kısmıdır.

```xml
<key>UIBackgroundModes</key>
<array>
    <string>location</string>
    <string>audio</string>
    <string>fetch</string>
</array>
```

Aşağıdaki ölçüm üç kip bildirir: konum, ses ve getirme. Platformun izin verdikleri ise ses, getirme ve bildirimdir. Kip adları model adlarıdır, özellik listesindeki gerçek anahtarlar değildir.

```swift
// main.swift — bildirilen kipler platformun izin verdikleriyle kesisir
let declared: Set = ["konum", "ses", "getirme"]
let platform: Set = ["ses", "getirme", "bildirim"]

let modes = Meeting("arka-plan-kipleri",
                    first: declared,
                    second: platform,
                    result: permittedModes(declared: declared, platform: platform))
modes.report()
```

```
arka-plan-kipleri: ilk getirme,konum,ses | ikinci bildirim,getirme,ses | sonuc getirme,ses -> kesisim
```

`konum` bildirildi ama platform tarafında izin yok, düştü; `bildirim` platformda var ama uygulama bildirmedi, o da düştü. Kalan iki kip her iki tarafta da bulundu. Bu buluşma bir önceki dersteki izin akışıyla aynı biçimdedir ve aynı çözümü verir; farkı, sonucu gösteren tarafın bir kullanıcı değil platform olmasıdır.

**PY11.** Bu ölçüm üç bildirilen kip ve üç izin verilen kip için. Bir kipin ek koşullara (örneğin yetki) bağlı olması bu modelde yoktur ve ölçülmedi.

## Durum Geçişleri ve Beklenen İş

Çalışmıyor durumunun dışında uygulamanın dört durumu vardır. Etkin değil (inactive) durumunda uygulama ön plandadır ama olay almaz; örneğin bir sistem uyarısı ekranı kapattığında ya da geçiş yapılırken uygulama kısa süre bu durumda kalır. Etkin (active) durumunda uygulama ön plandadır ve olay alır. Arka plan (background) durumunda uygulama ekranda görünmez ama kod çalıştırabilir. Askıda (suspended) durumunda uygulama bellekte durur, ama kod çalıştırmaz.

Her geçişte uygulamadan beklenen iş farklıdır. Etkin durumdan etkin değile geçerken uygulama kullanıcıyı bekleten işleri duraklatır: animasyonlar, oyun döngüleri, süre sayaçları. Arka plana geçerken uygulama kaydedilmemiş veriyi kaydeder, paylaşılan kaynakları serbest bırakır ve ağır belleği boşaltır; bu iş kısa sürmelidir, çünkü platform uygulamaya bu iş için sınırlı bir süre tanır. Ön plana dönerken uygulama arayüzünü güncel veriyle yeniler ve duraklattığı işleri sürdürür. Askıdayken uygulama hiçbir şey yapamaz; platform bellek gerektiğinde askıdaki uygulamayı bildirimsiz sonlandırabilir. Bu yüzden son kayıt, askıya geçmeden önce bitmiş olmalıdır; uygulama sonlanmadan önce bir fırsat tanınacağını varsaymaz.

Geçiş sırasının ölçülmemesi bu yüzden bilinçli bir sınırdır: gerçek sistemde sıra önemlidir ve yanlış sırada yapılan iş veri kaybına yol açabilir. Ama bu dersin sorusu sıra değil buluşmadır; hangi işleyicinin çağrılacağını sıra değil, iki temsilcinin tanımları belirler.

## Arka Plan Kiplerinin Sınırları

Arka plan kipleri uygulamaya arka planda çalışma hakkı verir, ama bu hak kipin amacıyla sınırlıdır. Ses çalan bir uygulama arka planda çalmaya devam edebilir, ama ses çalmayı bırakırsa arka plandaki çalışma hakkını da yitirir. Konum güncellemesi alan uygulama yalnız konum değiştikçe uyandırılır. Veri getirme kipinde uygulamayı platform kendi seçtiği zamanda uyandırır ve uygulama kısa bir süre içinde işini bitirmek zorundadır; uygulama bu zamanı belirleyemez.

Bu sınırların ortak noktası, hakkın bildirimden gelmemesidir. Önceki ölçümde konum kipi bildirildiği halde platformun izin verdikleri arasında olmadığı için düştü. Kip bildirmek bir istektir, hak değil; platform, gereksiz kaynak tüketimini sınırlamak için kipin gerçekten kullanıldığını denetler ve kullanılmayan kipi kısıtlayabilir. Uygulama bu yüzden yalnız gerçekten kullandığı kipleri bildirmeli ve arka plandaki işini kipin amacına uygun tutmalıdır.

Son bir sınır da kullanıcıya aittir. Kullanıcı arka planda yenilemeyi uygulama için kapatabilir; bu durumda bildirilen ve platformun izin verdiği kip bile çalışmaz. Önceki ölçümdeki kesişim bu yüzden bir alt sınırdır: üçüncü bir taraf, kullanıcının ayarı, kümeyi daha da daraltabilir.

## Sahne Ömrü ve Durumun Korunması

Sahne temsilcisinin yaşam döngüsü, uygulamanınkinden ayrıdır. Platform, arka plandaki bir sahneyi bellek gerektiğinde sistemden ayırabilir; sahne kapanır ama uygulama süreci çalışmaya devam edebilir. Kullanıcı sahneye döndüğünde platform sahneyi yeniden bağlar ve bu yeni bir bağlantı olarak görünür: sahne temsilcisi bağlantı olayını alır, ama arayüzün önceki durumunu kendisi kurmak zorundadır. Bu yüzden sahnenin kullanıcıya ait durumu, örneğin hangi ekranda olunduğu ve yarım kalan bir giriş, sahne arka plana geçerken saklanmalı ve yeniden bağlanırken geri yüklenmelidir.

Bu iş bölümü, önceki ölçümdeki önceliğin neden kullanışlı olduğunu da gösterir. Çok pencereli bir uygulamada her sahnenin kendi ön plan ve arka plan geçişi vardır: biri ön plandayken öbürü arka planda olabilir. Uygulama temsilcisi bu durumu tek bir olay olarak görür; yalnız sahne temsilcisi hangi sahnenin hangi duruma geçtiğini bilir. Sahne işleyicisinin uygulama işleyicisine üstün gelmesi bu yüzden bir tercih değil, bir zorunluluktur: olayın doğru sahibi, olayı en iyi bilen taraftır.

Uygulama temsilcisi tamamen devre dışı kalmaz. Sistem düzeyindeki işler, örneğin uzak bildirim kaydı ve uygulamanın ilk başlatılması, hâlâ ona aittir. Kural bu sınırı çizer: sahneye ait olay sahneye, uygulamaya ait olay uygulamaya gider. İki işleyicinin gerçekten aynı olay için tanımlı olduğu durumlar, çözümün öncelik çıktığı tek durumdur; geri kalan olaylarda buluşma zaten kurulmaz.

## Sınırlayıcı Ölçüm

Yaşam döngüsünü anlatırken geçişlerin sırası öne çıkar: önce ön plana, sonra arka plana, sonra tekrar ön plana. Bu ölçüm sırayı ölçmez. Ölçülen şey yalnız iki tanımın buluşmasıdır, ve buluşma bir geçişin hangi sırada geldiğinden bağımsızdır. Bunu görmek için aynı iki olayı ters sırayla iki kez çözeriz.

```swift
// main.swift — gecis sirasi bulusmayi degistirmez
let appHandlers = ["on-plana-gec": "uygulama.on-plana-gec", "arka-plana-gec": "uygulama.arka-plana-gec"]
let sceneHandlers = ["on-plana-gec": "sahne.on-plana-gec", "arka-plana-gec": "sahne.arka-plana-gec"]
let forward = ["on-plana-gec", "arka-plana-gec"]
let backward = ["arka-plana-gec", "on-plana-gec"]

func resolved(_ events: [String], scene: [String: String], app: [String: String]) -> Set<String> {
    Set(events.compactMap { handler(for: $0, scene: scene, app: app) }.flatMap { $0 })
}

let orders = [
    Meeting("gecis-ileri",
            first: Set(forward.map { appHandlers[$0]! }),
            second: Set(forward.map { sceneHandlers[$0]! }),
            result: resolved(forward, scene: sceneHandlers, app: appHandlers)),
    Meeting("gecis-geri",
            first: Set(backward.map { appHandlers[$0]! }),
            second: Set(backward.map { sceneHandlers[$0]! }),
            result: resolved(backward, scene: sceneHandlers, app: appHandlers)),
]

for item in orders {
    item.report()
}
```

```
gecis-ileri: ilk uygulama.arka-plana-gec,uygulama.on-plana-gec | ikinci sahne.arka-plana-gec,sahne.on-plana-gec | sonuc sahne.arka-plana-gec,sahne.on-plana-gec -> oncelik
gecis-geri: ilk uygulama.arka-plana-gec,uygulama.on-plana-gec | ikinci sahne.arka-plana-gec,sahne.on-plana-gec | sonuc sahne.arka-plana-gec,sahne.on-plana-gec -> oncelik
```

İki satır etiketi dışında aynıdır: kümeler sıralanarak basılır ve geçişlerin hangi sırada çözüldüğü sonucu değiştirmez. Geçişlerin gerçek sistemde hangi koşullarda ve hangi sırayla tetiklendiği ayrı bir konudur; bu kursun ölçüm eksenine girmez.

**PY12.** Bu ölçüm iki olay ve iki sıra için; her ikisinde de sahne temsilcisi iki olayı da işliyor. Sahnenin yalnız birini işlediği karışık durum ölçülmedi.

## Özet

- Uygulama yaşam döngüsü, ön plan ve arka plan arasındaki durum geçişlerinin sıralamasıdır ve her geçiş bir işleyiciye bildirilir.
- Sahne kullanan uygulamada ön plan ve arka plan geçişleri sahne temsilcisine gelir.
- Aynı olay için iki işleyici tanımlıysa sahne işleyicisi uygulama işleyicisine üstün gelir: çıktı öncelik.
- Bildirilen arka plan kipleri platformun izin verdikleriyle kesişir; konum düştü, ses ile getirme kaldı.
- Geçişlerin sırası buluşmanın sınıfını değiştirmez; ölçü yalnız iki tanımın buluşmasıdır.
- Bu dersin çözümü: **öncelik**.

## Sonraki Adım

Sahne ve uygulama arasındaki öncelik, bir tarafın ötekinin yerine geçtiği bir çözümdü. Sıradaki derste aynı çözüm kullanıcıyla uygulama arasında kurulur: kullanıcının yazı boyutu ayarı uygulamanın varsayılanına üstün gelir. Arayüz tasarım kılavuzlarını bu gözle okuruz.
