tvOS: utveckling för Apple TV med Focus Engine

Vad är tvOS?

tvOS — Apples operativsystem för Apple TV-set-top-boxar, baserat på samma Darwin XNU-kärna som iOS. Först släppt 30 oktober 2015 med 4:e generationens Apple TV. tvOS ersatte den föråldrade Apple TV Software (baserad på iOS, utan App Store och SDK). Systemet är optimerat för TV-användning med upplösning upp till 4K HDR (Dolby Vision) och Dolby Atmos-ljud.

Enligt Apple (WWDC 2025) är tvOS installerat på Apple TV HD (2015), Apple TV 4K (2017, 2021, 2022) och inbyggt i vissa Smart TV-modeller via AirPlay. Apple TV använder A8 (HD), A10X Fusion (1:a gen 4K), A12 Bionic (2:a gen 4K) och A15 Bionic (3:e gen 4K) chips. Alla modeller stöder tvOS 17. tvOS har ingen kamera, mikrofon (förutom fjärrkontroll), pekskärm eller GPS.

Nyckelfunktionen i tvOS är Focus Engine, som ersätter touch-kontroll med fokusnavigering. Användaren flyttar markeringen mellan UI-element med Siri Remote. Utvecklare skapar appar i Swift/SwiftUI (inbyggda) eller JavaScript/TVML (mediaappar som Netflix, Hulu).

tvOS-versionshistorik

tvOS 9 (2015) — första versionen med SDK och App Store. tvOS 10 (2016) — enkel inloggning (SSO) för kabelabonnemang. tvOS 11 (2017) — Amazon Prime Video-stöd och automatiskt läge. tvOS 12 (2018) — Dolby Atmos. tvOS 13 (2019) — fleranvändarläge. tvOS 17 (2023) — FaceTime, VPN, ljudprofiler via HDMI.

tvOS-arkitektur och skillnader från iOS

tvOS-arkitekturen är baserad på samma stack som iOS: XNU-kärna, Core Services-systemtjänster, Media-lager och Cocoa Touch-användarlager. Det finns dock betydande skillnader relaterade till TV-plattformens särdrag.

Hårdvarubegränsningar

3:e generationens Apple TV 4K använder A15 Bionic med 6 CPU-kärnor (2 prestanda, 4 effektivitet) och en 5-kärnig GPU. RAM — 4 GB (intern SSD-lagring från 64 GB). Systemet har ingen permanent lokal lagring i klassisk mening: all appdata kan raderas av tvOS vid utrymmesbrist (purgeable). Utvecklare måste använda iCloud Key-Value Storage eller CloudKit för att bevara tillståndet.

TVMLKit och TVJS

TVMLKit — ett unikt ramverk för tvOS som möjliggör att skapa gränssnitt i JavaScript och TVML (Apple-specifikt XML-liknande språk). TVMLKit laddar JSON/XML från servern och renderar inbyggda UI-komponenter. Detta är den primära tekniken för streamingtjänster: Netflix, Hulu, Amazon Prime Video använder TVMLKit. TVJS — en JavaScript-miljö som körs i ett isolerat sammanhang.

Brist på permanent lagring

tvOS hanterar diskutrymme automatiskt: vid utrymmesbrist kan systemet radera cache, nedladdade resurser och till och med själva appen (medan ikonen behålls). Vid återöppning måste appen återställa sitt tillstånd. iCloud NSUbiquitousKeyValueStore är den enda garanterade permanenta lagringen för inställningar (upp till 1 MB per app).

import Foundation

// // Sparande och återställning av tillstånd i tvOS
final class StateManager {

    private let store = NSUbiquitousKeyValueStore.default
    private let coder = JSONEncoder()
    private let decoder = JSONDecoder()

    // Sparar visningsförlopp
    func saveProgress<T: Codable>(_ value: T, for key: String) {
        if let data = try? coder.encode(value) {
            store.set(data, for: key)
            store.synchronize()
        }
    }

    // Återställer tillstånd efter cacheradering
    func restoreProgress<T: Codable>(_ type: T.Type, for key: String) -> T? {
        guard let data = store.data(for: key) else { return nil }
        return try? decoder.decode(type, from: data)
    }

    // Hanterar ändringsmeddelande på annan enhet
    init() {
        NotificationCenter.default.addObserver(
            self,
            selector: #selector(ubiquitousKeyValueStoreDidChange),
            name: NSUbiquitousKeyValueStore.didChangeExternallyNotification,
            object: store
        )
    }

    @objc
    private func ubiquitousKeyValueStoreDidChange(_ notification: Notification) {
        print("Data ändrades på annan enhet")
    }
}

StateManager använder NSUbiquitousKeyValueStore för att spara apptillstånd på tvOS. Eftersom lokal lagring kan rensas av systemet garanterar endast iCloud datapersistens. store.synchronize() skickar omedelbart data till servern, medan didChangeExternallyNotification meddelar appen om ändringar från användarens andra enheter.

Focus Engine: navigering och fokus

Focus Engine — nyckelmekanismen i tvOS som ersätter touch-händelser med fokusnavigering. Användaren flyttar markeringen mellan UI-element med Siri Remote (touch-yta eller knappar). Systemet beräknar automatiskt nästa fokuselement baserat på avstånd och rörelseriktning.

UIFocusEnvironment och fokushierarki

Varje UI-element som kan ta emot fokus implementerar UIFocusEnvironment-protokollet. UIKit bestämmer automatiskt navigeringsordningen baserat på elementens geometri. Utvecklaren kan åsidosätta önskat fokus via preferredFocusEnvironments, ange en array av underordnade focusEnvironment och kontrollera rörelsen via UIFocusHeading (up, down, left, right). UIFocusGuide gör det möjligt att ställa in anpassade rutter för icke-triviala layouter.

UIFocusEffect och parallax

tvOS lägger automatiskt till UIFocusEffect till det fokuserade elementet: skugga, markering och parallaxeffekt (förskjutning när fjärrkontrollen lutas). Utvecklaren kan inaktivera effekten via focusedValue eller anpassa den via UIFocusEffect.transform. I SwiftUI läggs parallax till med modifieraren .hoverEffect(.highlight).

import SwiftUI

// // tvOS-komponent med anpassat fokus
struct MovieCardView: View {
    let movie: Movie
    @State private var isFocused = false
    @Environment(\.isFocused) var envFocused

    var body: some View {
        VStack(spacing: 8) {
            AsyncImage(url: movie.posterURL) { phase in
                if let image = phase.image {
                    image
                        .resizable()
                        .aspectRatio(contentMode: .fill)
                        .frame(width: 320, height: 180)
                        .cornerRadius(8)
                        .overlay(
                            RoundedRectangle(cornerRadius: 8)
                                .stroke(isFocused ? Color.blue : Color.clear, lineWidth: 3)
                        )
                        .scaleEffect(isFocused ? 1.08 : 1.0)
                }
            }

            Text(movie.title)
                .font(.caption)
                .lineLimit(2)
                .foregroundStyle(isFocused ? .white : .gray)
        }
        .onHover { hovering in
            withAnimation(.spring(response: 0.35)) {
                isFocused = hovering
            }
        }
        .onPlayPauseCommand {
            // Hanterar Play/Pause-knapp på fjärrkontroll
            startPlayback()
        }
        .focusable()
        .focusEffect { phase in
            // Anpassad fokuseffekt
            phase == .active ?
                AnyView(self.scaleEffect(1.08)) :
                AnyView(self.scaleEffect(1.0))
        }
    }

    private func startPlayback() {
        print("Spelar: \(movie.title)")
    }
}

// // Huvudskärm med filmrutnät
struct MovieGridScreen: View {
    let movies: [Movie]

    var body: some View {
        ScrollView {
            LazyVGrid(columns: [GridItem(.adaptive(minimum: 320, maximum: 400))], spacing: 24) {
                ForEach(movies) { movie in
                    MovieCardView(movie: movie)
                }
            }
            .padding(60)
        }
        .focusSection() // Gruppering för navigering
    }
}

MovieCardView demonstrerar Focus Engine i SwiftUI: modifieraren .focusable() gör elementet fokuserbart, .onHover spårar tillståndsändringar, .focusEffect möjliggör anpassad fokusanimation. .onPlayPauseCommand hanterar tryck på Play/Pause-knappen på Siri Remote. focusSection grupperar ett rutnät för cyklisk navigering.

Siri Remote: gester och knappar

Andra generationens Siri Remote (2021) har en touch-yta, 5 knappar och en mikrofon. tvOS stöder gester: svep (navigering), tryck (välj), dubbeltryck (centrera), nyp-zoom (bilder), långtryck (kontextmeny). UIPress med typerna .select, .playPause, .menu, .upArrow, .downArrow, .leftArrow, .rightArrow — fördefinierade trycktyper. Fjärrkontrollens mikrofon används för Siri och röstsökning.

Top Shelf och appskärm

Top Shelf är ett område på Apple TV-startskärmen som visar dynamiskt appinnehåll när appen är i den översta raden. I tvOS 17 stöder Top Shelf upp till 8 widgetar med anpassad bakgrund och interaktiva element. Utvecklaren implementerar TVTopShelfProvider för att tillhandahålla innehåll.

Top Shelf-stilar

Tre Top Shelf-stilar finns tillgängliga: Sectioned — kategoriserad lista (serier efter genre), Inset — centralt element med detaljerad beskrivning (rekommenderad film), Photo — bildrutnät (fotoalbum). Systemet uppdaterar Top Shelf i bakgrunden via BGTaskScheduler, liknande watchOS. Leverantören måste returnera innehåll snabbt — tvOS cachelagrar data i 24 timmar.

Appskärm

tvOS-startskärmen består av en Top Shelf-rad och ett apprutnät. Användare kan ordna om ikoner och skapa mappar. tvOS avlastar automatiskt appar från minnet när resurserna är låga, så utvecklaren måste hantera UISceneDidDisconnectNotification korrekt och återställa tillståndet vid omstart.

SwiftUI för Apple TV

SwiftUI stöds fullt ut i tvOS från och med tvOS 13. Apple rekommenderar SwiftUI för alla nya projekt. Samma SwiftUI-kod fungerar på iOS, iPadOS, macOS och tvOS med minimala anpassningar för Focus Engine. SwiftUI för tvOS tillhandahåller modifierarna .focusable(), .focusSection(), .onPlayPauseCommand och .onExitCommand.

Anpassning till tvOS

Vid överföring av en iOS-app till tvOS måste du: ersätta TabView med NavigationView med fokusnavigering, öka teckenstorlekarna (minst 30pt för rubriker, 22pt för text), lägga till marginaler (minst 40pt från kanterna — säker zon på TV-apparater). tvOS stöder inte UIAlertController med textfält, UIWebView och MFMailComposeViewController.

Designrekommendationer

Apple HIG för tvOS: minsta touchområdesstorlek 60×60 punkter, text läsbar från 3 meters avstånd (teckenstorlek inte mindre än 22pt för brödtext), textkontrast 4.5:1, mörk bakgrund (ljus bakgrund orsakar bländning på OLED-TV-apparater), alla element tillgängliga utan komplexa gester. Upplösning: Apple TV 4K producerar 3840×2160 (4K) eller 1920×1080 (HD) vid 60 FPS. Alla bilder ska vara @2x (för 1080p) och @4x (för 4K).

TVMLKit och mediaapplikationer

TVMLKit — ett ramverk för att skapa mediaappar på tvOS med webbteknologier: JavaScript (TVJS) och TVML (Apple-specifik XML). TVMLKit-appar kräver ingen kompilering — gränssnittet laddas från servern, vilket möjliggör innehållsuppdateringar utan App Review. Det används av stora streamingtjänster för innehållskarusseller.

TVML: mallstruktur

TVML tillhandahåller färdiga mallar: CatalogTemplate (katalog med sektioner), ProductTemplate (innehållsdetaljsida), FormTemplate (inloggningsformulär), LoadingTemplate (laddningsindikator). Mallar beskrivs i XML och stylas via CSS-liknande attribut. TVJS-kod hanterar tryck och anropar inbyggda API:er.

<!-- CatalogTemplate — filmkatalog på TVML -->
<document>
  <catalogTemplate>
    <banner>
      <title>Nya filmer</title>
      <description>Färska premiärer och exklusiva titlar</description>
    </banner>
    <section>
      <header>
        <title>Populärt</title>
      </header>
      <items>
        <lockup>
          <img src="https://cdn.example.com/movie1.jpg" width=300 height=450/>
          <title>Interstellar</title>
        </lockup>
        <lockup>
          <img src="https://cdn.example.com/movie2.jpg" width=300 height=450/>
          <title>Nachalo</title>
        </lockup>
      </items>
    </section>
  </catalogTemplate>
</document>

TVML-mallen CatalogTemplate innehåller en banner med titel och sektioner med lockup-element. Varje lockup är ett filmkort med bild och titel. Focus Engine hanterar automatiskt navigeringen mellan lockup-element. Vid tryck tar TVJS-hanteraren emot select-händelsen och kan visa en detaljsida via ProductTemplate.

TVJS: händelsehantering

TVJS är en JavaScript-miljö isolerad från huvudappen. TVJS-kod anropas när en TVML-mall laddas och händelser hanteras. TVJS har tillgång till inbyggda API:er via Appliance och Player för att kontrollera videouppspelning. Apple rekommenderar att använda TVMLKit endast för mediaappar med frekventa innehållsuppdateringar. För spel och interaktiva appar föredras SwiftUI.

Publicera tvOS-appar

Publicera en tvOS-app kräver ett Apple Developer Program-abonnemang ($99/år). Appen laddas upp via App Store Connect som en separat produkt eller som en del av en universell binär (iOS + tvOS). App Review kontrollerar stabilitet, HIG-efterlevnad och 4 GB-storleksbegränsningen.

Bygga och distribuera

Xcode skapar ett tvOS-mål med tillägget .app (.ipa-paket). Arkitektur — arm64 (Apple TV använder ARM-chips från Apple Silicon). tvOS stöder inte ramverk med i386 eller x86_64. Appen signeras med ett Apple Development-certifikat (testning) eller Apple Distribution-certifikat (publicering). Distribution via Volume Purchase Program för företagskunder är möjlig.

App Review-krav

Särskilda tvOS-krav: alla gränssnittselement måste vara tillgängliga via Focus Engine utan pekskärm eller tangentbord. Appar som kräver auktorisering måste stödja enkel inloggning (SSO) via iTunes Store. Reklaminnehåll får inte avbryta uppspelning utan användarens samtycke. Den uppladdade binära filens storlek får inte överstiga 4 GB.