Background Fetch: vad det är, funktionsprincip och konfiguration av uppdateringar

Vad är Background Fetch i iOS?

Background Fetch — är ett iOS API som gör att applikationen periodiskt kan ta emot nya data i bakgrunden. Först introducerat i iOS 7 tillsammans med mekanismen Background App Refresh. Huvudmålet — att innehållet är aktuellt när användaren öppnar applikationen, utan att behöva vänta på laddning.

Skillnad från Push-notiser

Push-notiser initieras av servern — den skickar en signal till enheten och systemet bestämmer om det ska väcka applikationen eller inte. Background Fetch initieras av iOS självt baserat på användningsmönster för enheten. Push passar bättre för brådskande meddelanden, Fetch — för planerad innehållsuppdatering (nyheter, sociala medieflöden).

Plats i ekosystemet för bakgrundsuppgifter

Background Fetch — en av flera mekanismer för bakgrundsexekvering i iOS. BGAppRefreshTask (iOS 13+) utför samma uppgift, men med mer flexibel schemaläggning. Background Modes (ljud, plats) — för kontinuerliga operationer. Silent Push — serverinitierad uppdatering. Fetch förblir relevant för projekt som stöder iOS 12 och lägre.

• Background Fetch — periodisk, initierad av systemet, iOS 7+.
• BGAppRefreshTask — periodisk, initierad av systemet, iOS 13+.
• BGProcessingTask — långvariga uppgifter, iOS 13+.
• Silent Push — initierad av servern, iOS 7+.

Hur fungerar Background Fetch: arkitektur och livscykel

iOS använder en maskininlärningsalgoritm för att bestämma den optimala tiden att väcka applikationen. Systemet analyserar när användaren vanligtvis öppnar applikationen, hur länge den används och hur ofta användaren återvänder. Baserat på denna data beräknar iOS fönster för Background Fetch.

Process för uppgiftsexekvering

När systemet beslutar att väcka applikationen anropar det metoden application(_:performFetchWithCompletionHandler:) i AppDelegate. Applikationen bör ladda ner en minimal mängd ny data och anropa completion handler med en av tre statusar: .newData (data nedladdad), .noData (inga nya data) eller .failed (fel). Statusen påverkar frekvensen av framtida väckningar.

Inverkan av completion handler på anropsfrekvens

Status .newData informerar systemet att uppdateringen var användbar — iOS kan öka väckningsfrekvensen. .noData säger att det inte finns några data — frekvensen förblir densamma eller minskar. .failed signalerar ett problem — systemet minskar frekvensen för att inte slösa på batteriet. Tonvikten bör ligga på ärlig status, inte på påtvingad .newData.

Konfiguration av Background Fetch i Xcode-projekt

För att aktivera Background Fetch måste två steg utföras: aktivera capability i Xcode och ställ in minimiintervall i koden. Capability finns i Target — Signing & Capabilities — Background Modes — markera rutan Background Fetch. Utan detta steg kommer systemet inte att väcka applikationen.

Ställa in minimiintervall

Metoden UIApplication.shared.setMinimumBackgroundFetchInterval ställer in minimitiden i sekunder mellan Fetch-anrop. Värdet UIApplication.backgroundFetchIntervalMinimum (ungefär 15 minuter) anger för systemet att väcka applikationen så ofta som är energieffektivt. Att ställa in intervallet i application(_:didFinishLaunchingWithOptions:) är standardpraxis.

func application(
    _ application: UIApplication,
    didFinishLaunchingWithOptions options: [UIApplication.LaunchOptionsKey : Any]?
)-> Bool {
    UIApplication.shared.setMinimumBackgroundFetchInterval(
        UIApplication.backgroundFetchIntervalMinimum
    )
    return true
}

Info.plist och capability

När Background Fetch aktiveras i Xcode uppdateras Info.plist automatiskt — det lägger till nyckeln UIBackgroundModes med värdet fetch. Detta är ett obligatoriskt steg: utan det kommer applikationen inte att få anropet performFetchWithCompletionHandler. Närvaron kan kontrolleras via P list Source eller Build Settings.

Kodexempel för Background Fetch i Swift

Låt oss titta på en fullständig implementering av Background Fetch för en nyhetsapplikation. Implementeringen inkluderar nedladdning av data, cachning och anrop av completion handler. Koden körs i AppDelegate — den enda platsen där systemet anropar fetch.

func application(
    _ application: UIApplication,
    performFetchWithCompletionHandler handler: @escaping (UIBackgroundFetchResult) -> Void
) {
    let url = URL(string: "https://api.example.com/latest")!

    URLSession.shared.dataTask(with: url) { data, response, error in
        guard let data = data, error == nil else {
            handler(.failed)
            return
        }

        do {
            let articles = try JSONDecoder().decode([Article].self, from: data)
            cacheArticles(articles)
            handler(articles.isEmpty ? .noData : .newData)
        } catch {
            handler(.failed)
        }
    }.resume()
}

Cachning av nedladdad data

Efter nedladdning av data via Background Fetch måste de sparas i lokal lagring — CoreData, UserDefaults eller File Manager. När applikationen öppnas ska datan redan vara tillgänglig. Använd CoreData med en bakgrundskontext för trådsäker skrivning. Efter sparande, uppdatera användargränssnittet i huvudtråden.

func cacheArticles(_ articles: [Article]) {
    let container = NSPersistentContainer(name: "AppModel")
    container.performBackgroundTask { context in
        articles.forEach { article in
            let entity = ArticleEntity(context: context)
            entity.id = Int64(article.id)
            entity.title = article.title
            entity.body = article.body
        }
        try? context.save()
    }
}

Testa Background Fetch

För testning, använd Simulator — välj Debug — Simulate Background Fetch i Xcode. På en fysisk enhet måste du vänta tills systemet beslutar att utföra fetch. För att påskynda kan du ställa in minimiintervallet på 1 minut, men systemet kan fortfarande ignorera det vid låg batterinivå.

Begränsningar och fallgropar

Background Fetch har ett antal begränsningar som är viktiga att överväga vid utformningen av applikationsarkitekturen. Huvudsaken — systemet kontrollerar helt frekvensen av anrop och utvecklaren kan inte garantera den. Även med ett inställt minimiintervall kan systemet låta bli att anropa fetch i timmar.

Begränsning av exekveringstid

Systemet tilldelar applikationen begränsad tid för att utföra uppgiften — vanligtvis upp till 30 sekunder. Om applikationen inte anropar completion handler inom denna tid, tvångsavslutar systemet processen och minskar frekvensen av framtida väckningar. Alla nätverksförfrågningar bör vara kompakta — inte mer än 1–2 per anrop.

Beroende av batteri

iOS tar hänsyn till batterinivån vid schemaläggning av Background Fetch. När nivån är under 20 % minskar väckningsfrekvensen. När Low Power Mode är aktiverat kan systemet helt inaktivera bakgrundsuppdateringar för alla applikationer. Användaren kan också inaktivera Background App Refresh för en specifik applikation i inställningarna.

Nätverksbegränsningar

URLSession som startas från Background Fetch fungerar i standardläge — utan stöd för bakgrundssessioner. För stora nedladdningar, använd URLSession med background configuration. Systemet fortsätter nedladdningen även efter att fetch har avslutats, men förloppet spåras inte förrän nästa väckning.

Migrering från Background Fetch till BGTaskScheduler

Från och med iOS 13 rekommenderar Apple BGTaskScheduler som ersättning för Background Fetch. BGTaskScheduler erbjuder mer flexibel schemaläggning, två typer av uppgifter (refresh och processing) och registrering av uppgifter med identifierare. Migreringen omfattar flera steg och rekommenderas för alla nya projekt.

Steg-för-steg-migrering

Första steget — bestäm uppgiftsidentifierare i Info.plist via nyckeln BGTaskSchedulerPermittedIdentifiers. Andra — registrera uppgifterna i AppDelegate via BGTaskScheduler.shared.register. Tredje — ersätt anropet till performFetchWithCompletionHandler med hanteraren som skickats till register. Fjärde — anropa submit för att schemalägga uppgiften.

// Tidigare (Background Fetch)
UIApplication.shared.setMinimumBackgroundFetchInterval(
    UIApplication.backgroundFetchIntervalMinimum
)

// Efter migrering (BGTaskScheduler)
BGTaskScheduler.shared.register(
    forTaskWithIdentifier: "com.example.refresh",
    using: nil
) { task in
    self.handleAppRefresh(task: task as! BGAppRefreshTask)
}

let request = BGAppRefreshTaskRequest(
    identifier: "com.example.refresh"
)
request.earliestBeginDate = Date(timeIntervalSinceNow: 15 * 60)
try? BGTaskScheduler.shared.submit(request)

Fördelar med BGTaskScheduler

BGTaskScheduler ger mer kontroll: BGProcessingTask för långvariga operationer (upp till 10 minuter), exekveringsvillkor via requiresNetworkConnectivity och requiresExternalPower, expiration handler för smidig avslutning. Systemet analyserar också applikationsanvändningen, men utvecklaren kan ställa mer precisa krav.

När ska Background Fetch behållas

Om applikationen stöder iOS 12 och lägre förblir Background Fetch det enda alternativet för periodisk uppdatering. BGTaskScheduler är endast tillgängligt från iOS 13+. I detta fall, använd en wrapper: kontrollera tillgängligheten av BGTaskScheduler via if #available(iOS 13, *) och anropa motsvarande API.