Live Activity — vad är det, widgetar på låsskärmen

Författare: IT Sectr Publicerad: 2026-02-15 Lästid: 9 min

Live Activity — en dynamisk widget på iPhone låsskärm och i Dynamic Island som visar information i realtid: leveransstatus, sportresultat, timer och musikuppspelning. Implementeras via ActivityKit (Swift, iOS 16.1+) tillsammans med WidgetKit. Live Activity uppdateras lokalt eller via push-notiser, stöder flera tillstånd och avslutas av systemet efter att händelsen är slut. Mer på ActivityKit Documentation.

Huvudpunkter

  • Live Activity — widget i realtid på Lock Screen och Dynamic Island
  • ActivityKit — ramverk för att starta och hantera Live Activities i iOS 16.1+
  • Push-uppdateringar — server skickar nytt tillstånd via ActivityKit push-notiser
  • Tillstånd — varje Activity stöder aktivt och avslutat tillstånd med olika UI
  • Dynamic Island — kompakt visning av Live Activity på iPhone 14 Pro och nyare

Vad är Live Activity — widget på Lock Screen?

Live Activity — en WidgetKit-tillägg som visar dynamiskt innehåll på iPhone låsskärm och i Dynamic Island. Till skillnad från en statisk widget som uppdateras enligt systemets timer, startas Live Activity av en app och lever under begränsad tid — upp till 8 timmar för en aktiv Activity och upp till 4 timmar efter slutförande. Användaren ser aktuell data utan att låsa upp enheten: leveransstatus, avstånd till destination i taxi, matchresultat eller träningsframsteg.

ActivityKit — ramverk för att arbeta med Live Activities, introducerat i iOS 16.1. Det tillhandahåller API för att begära, uppdatera och avsluta Activity. Activity är ett objekt med innehåll och tillstånd. Innehållet (ActivityContent) definierar statisk data, tillståndet (ActivityState) — dynamisk data som förändras över tid. Systemet bestämmer själv när det ska rendera nytt tillstånd — detta sparar batteri och garanterar smidiga animationer.

Varje Live Activity identifieras unikt av ActivityID och är bunden till en process — appen som skapade den. Systemet kan avsluta Activity vid otillräckligt minne eller låg batterinivå. Utvecklaren får ett meddelande om tvångsavslutning via ActivityKit-delegaten och kan spara senaste tillståndet för återställning.

Arkitektur för ActivityKit och WidgetKit

Arkitekturen för Live Activity bygger på två ramverk: WidgetKit ansvarar för rendering av SwiftUI-vyer, ActivityKit — för Activitys livscykel. Utvecklaren skapar en WidgetBundle med stöd för LiveActivityConfiguration. Varje konfiguration definierar datatyp (Attributes och State) och SwiftUI View som renderas av systemet på Lock Screen och Dynamic Island. Data överförs via ActivityAttributes — en struct med let-fält för innehåll och var-fält för tillstånd.

KomponentSyfteAPI
AttributesStatisk data för hela Activitylet name: String, let icon: String
ContentStateDynamiskt tillstånd, ändras vid uppdateringvar progress: Double, var status: Status
ActivityObjekt för begäran och hantering av ActivityActivity.request(attributes:content:)
PushTokenToken för serverpush-uppdateringaractivity.pushToken publisher
ActivityUISwiftUI View för Lock Screen och Dynamic IslandLockScreenView, ExpandedView, CompactView

Activitys livscykel omfattar tre faser: aktiv (systemet visar och uppdaterar), slutlig (aktivitet slutförd men UI synligt i 4 timmar), borttagen (systemet tar bort UI). Appen kan avsluta Activity när som helst. Systemet avslutar också Activity tvångsvis — till exempel vid omstart av enheten eller efter att 8-timmarsgränsen överskridits.

swift
import ActivityKit

struct DeliveryAttributes: ActivityAttributes {
    public struct ContentState: Codable & Hashable {
        var status: DeliveryStatus
        var estimatedMinutes: Int
    }
    var orderNumber: String
    var restaurantName: String
}

WidgetBundle registrerar Live Activity via @main-makrot: widgeten returnerar en lista med konfigurationer, inklusive LiveActivityConfiguration. Baserat på denna konfiguration vet systemet vilka datatyper som förväntas och hur UI ska renderas i olika tillstånd — kompakt, minimalt och utökat för Dynamic Island.

Skapa Live Activity med WidgetKit och SwiftUI

Skapa Activity börjar med en begäran till ActivityKit. Appen anropar Activity.request(attributes:content:pushType:) med initial data. Systemet kontrollerar om Dynamic Island är tillgänglig på enheten och returnerar ett Activity-objekt. Begäran kan misslyckas om gränsen för aktiva Activity har överskridits — vanligtvis inte mer än 5 samtidigt. Efter en lyckad begäran visar systemet widgeten på Lock Screen och, om möjligt, i Dynamic Island.

swift
let attributes = DeliveryAttributes(
    orderNumber: "A-1234",
    restaurantName: "Pizza House"
)

let initialState = DeliveryAttributes.ContentState(
    status: DeliveryStatus.preparing,
    estimatedMinutes: 30
)

do {
    let activity = try await Activity<DeliveryAttributes>.request(
        attributes: attributes,
        content: ActivityContent(state: initialState, staleDate: nil),
        pushType: .token
    )
    print("Activity started: \(activity.id)")
} catch {
    print("Failed: \(error)")
}

SwiftUI View för Live Activity använder strukturerna LockScreenView, ExpandedView och CompactView från WidgetKit. View får kontext (ActivityViewContext) med aktuella attribut och tillstånd. Uppdatering av View sker automatiskt vid mottagning av nytt tillstånd från systemet. Live Activity stöder endast en begränsad uppsättning SwiftUI-komponenter — Text, Image, HStack, VStack och några modifierare.

Varje Live Activity View måste vara lätt och snabb — systemet vägrar att rendera tunga vyer. Tidsgränsen för rendering är 30 ms per bildruta. Animationer är begränsade till systemövergångar mellan tillstånd — anpassade animationer är inte tillgängliga i Live Activity. Rendering sker i bakgrunden av WidgetKit-processen med prioritet för Lock Screen-responsivitet.

Uppdatera Live Activity lokalt och via push

Lokal uppdatering — appen uppdaterar Activitys tillstånd genom att anropa activity.update(using:). Metoden tar emot nytt ContentState och en valfri AlertConfiguration för att visa en notis vid uppdatering. Lokala uppdateringar är snabba — systemet ritar om View i nästa renderingscykel, vanligtvis inom 1–2 sekunder. För frekventa uppdateringar (timer, stoppur) använd lokalt läge — det är mer tillförlitligt och snabbare än push.

swift
let updatedState = DeliveryAttributes.ContentState(
    status: DeliveryStatus.outForDelivery,
    estimatedMinutes: 10
)

await activity.update(
    ActivityContent<DeliveryAttributes.ContentState>(
        state: updatedState,
        staleDate: Date().addingTimeInterval(60)
    ),
    alertConfiguration: AlertConfiguration(
        title: "Order out for delivery",
        body: "Arriving in 10 min"
    )
)

Push-uppdateringar — servern skickar en ActivityKit push-notis med nytt tillstånd i JSON-format. För detta hämtar appen pushToken från activity.pushToken publisher och skickar det till servern. Servern skickar en POST-förfrågan till APNs med en payload som innehåller det nya ContentState. Systemet tar emot push, avkodar tillståndet och uppdaterar Live Activity utan appens medverkan — detta gör det möjligt att uppdatera Activity även när appen är stängd.

Push-uppdateringar är mer ekonomiska än lokala för sällsynta uppdateringar (leveransstatus var 5–10 minut) — appen behöver inte hålla en nätverksanslutning. För frekventa uppdateringar var 1–2 sekund, använd lokal metod. Server-payload innehåller endast de föränderliga fälten i ContentState — statisk data i Attributes skickas endast när Activity skapas.

Visa Live Activity i Dynamic Island

Dynamic Island — ett hårdvaru-mjukvaruområde på iPhone 14 Pro, 15 Pro och nyare som anpassar sig till Live Activity-innehållet. Systemet visar automatiskt Activity i tre lägen: kompakt (ikon + kort text till vänster om utskärningen), minimalt (endast ikon) och utökat (rektangel på 300pt med information). Utvecklaren hanterar inte dessa lägen direkt — systemet väljer läge baserat på prioritet och tillgängligt utrymme.

swift
struct DeliveryLiveActivity: Widget {
    var body: some WidgetConfiguration {
        ActivityConfiguration(for: DeliveryAttributes.self) { context in
            LockScreenView(context: context)
        } dynamicIsland: { context in
            DynamicIsland {
                DynamicIslandExpandedContent {
                    ExpandedView(context: context)
                }
            } compactLeading: {
                CompactLeadingView(context: context)
            } compactTrailing: {
                CompactTrailingView(context: context)
            } minimal: {
                MinimalView(context: context)
            }
        }
    }
}

Dynamic Island stöder interaktivitet — användaren trycker på området och kommer in i appen eller öppnar den utökade vyn. Tryck på kompakt läge växlar till utökat läge, och svep åt vänster döljer Activity till minimalt läge. Knappar i utökat läge (pause/cancel) hanteras via Link från SwiftUI — systemet startar appen med en deep link URL, hanteringen sker i UIApplicationDelegate.

Begränsningar för Dynamic Island: bredd för utökat läge — upp till 300pt, kompakt text — upp till 30 tecken. Färger och typsnitt motsvarar systemtemat — anpassning är begränsad. Övergångsanimationer mellan lägen är systemegna och kan inte konfigureras. Om flera appar har aktiva Activity, visar Dynamic Island dem med prioritet baserat på starttid och innehållstyp.

Vanliga frågor

Hur skiljer sig Live Activity från en vanlig widget?

En vanlig WidgetKit-widget visar statisk information och uppdateras enligt systemets timer med ett minsta intervall på 15–30 minuter. Live Activity visar dynamisk data i realtid på låsskärmen och Dynamic Island. Live Activity startas av en app, lever upp till 8 timmar och avslutas av systemet efter händelsens slut, till skillnad från widgeten som finns permanent.

Hur ofta uppdateras Live Activity?

Live Activity stöder två uppdateringslägen: lokalt — appen uppdaterar tillståndet via ActivityKit API när som helst, och push — servern skickar en ActivityKit push-notis som systemet omvandlar till widgetens nya tillstånd. Vid låg batterinivå kan systemet frysa Live Activity tills laddaren ansluts.

På vilka enheter fungerar Live Activities?

Live Activities är tillgängliga på iPhone med iOS 16.1 och nyare. På iPhone 14 Pro och nyare visas Live Activity även i Dynamic Island. På iPad stöds Live Activity endast på låsskärmen — Dynamic Island finns inte på iPad. Apple Watch stöder inte Live Activities direkt men kan visa meddelanden om slutförande.

Hur många Live Activities kan köras samtidigt?

Systemet begränsar antalet aktiva Live Activities — vanligtvis inte mer än 5 samtidigt för alla appar. Vid försök att överskrida gränsen returnerar ActivityKit ett fel. Varje Live Activity kan ha flera tillstånd — till exempel väntar, på väg, levererad för en matbeställning. Efter slutförande stannar Activity i UI i ytterligare 4 timmar.

Krävs användarens tillstånd för Live Activity?

Ja, appen måste begära tillstånd för att skicka notiser — Live Activity använder systemets notifieringskanal. Användaren kan stänga av Live Activity för en specifik app i inställningarna. Vid första start visar ActivityKit en dialogruta med begäran om tillstånd. Utan tillstånd misslyckas Activity-begäran med ett fel.

Sammanfattning

  • Live Activity — dynamisk widget på Lock Screen och Dynamic Island med uppdatering i realtid
  • ActivityKit — iOS 16.1+ ramverk för att hantera livscykeln för Live Activities
  • Attributes and State — statisk data och dynamiskt tillstånd för Activity som skickas till SwiftUI View
  • Push-uppdateringar — server skickar nytt tillstånd via APNs utan appens medverkan
  • Dynamic Island — tre visningslägen: kompakt, minimal och utökad rektangel
  • Gränser — upp till 5 aktiva Activity, upp till 8 timmars livslängd, upp till 4 timmar efter slutförande
  • AlertConfiguration — valfri notis vid uppdatering av Activity-tillstånd

Vi utvecklar en mobil applikation nyckelfärdigt

IT Sectr skapar iOS- och Android-applikationer för startups och företag sedan 2017. Vi ger dig råd och föreslår den bästa lösningen.

Diskutera projektet

Läs också