Snapshot (Fastlane) — essens, generering av skärmbilder och konfiguration i mobila appar

Vad är Snapshot (Fastlane)?

Snapshot (Fastlane) är en komponent i Fastlane-ekosystemet som automatiserar skapandet av skärmbilder för App Store. Den kör UI-tester på iOS-simulatorer, tar skärmbilder i angivna tillstånd av appen och sparar dem i en strukturerad katalog med korrekta namn för varje språk och enhet.

Utan Snapshot startar utvecklare manuellt simulatorn, öppnar varje skärm, tar en skärmbild med Cmd+S, byter språk och upprepar processen för alla kombinationer. Automatisering av skärmbilder är en nyckelkomponent i ASO-optimering, eftersom App Store kräver aktuella bilder för varje ny release och manuell uppdatering av 60+ skärmbilder tar timmar av arbete.

Enligt App Store Connect Documentation (2025) får appar med lokaliserade skärmbilder 25% fler konverteringar i målmarknader. Snapshot gör det möjligt för team att uppdatera visuellt innehåll för 32 språk i en enda körning, vilket är särskilt viktigt för marknadsföringskampanjer kopplade till nya appfunktioner.

Använd Snapshot i alla projekt som publiceras i App Store — det är ett standardverktyg för team som strävar efter automatisering av releaseprocessen och förbättring av ASO.

Hur Snapshot genererar skärmbilder

Processen för generering av skärmbilder i Snapshot består av flera steg: förberedelse av UI-tester, konfiguration av Snapfile, start av simulatorer och insamling av resultat. Snapshot startar sekventiellt varje simulator för angivna enheter och språk, utför UI-tester och tar bilder vid anropspunkterna för funktionen snapshot().

Efter att alla tester är klara samlar Snapshot in skärmbilderna i katalogen screenshots/[Language]/ med namn som motsvarar App Store-kraven. Varje skärmbild sparas i PNG-format med upplösning som motsvarar målenheten. Snapshot genererar också en HTML-rapport för visuell verifiering av alla skapade bilder.

Konfigurera UI-tester för Snapshot

För att Snapshot ska fungera måste snapshot()-anrop läggas till i XCTest-koden för appens UI-tester. Funktionen tar en skärmbild av den aktuella skärmstatusen vid anropstillfället. Utvecklaren placerar snapshot() efter varje nyckelåtgärd: öppning av skärm, inmatning av data, navigering mellan flikar eller visning av resultat.

Exempel på UI-teststruktur: testet loggar in i appen, anropar snapshot("01-LoginScreen") för skärmbild av inloggningsskärmen, går sedan till huvudskärmen och anropar snapshot("02-HomeScreen") för skärmbild av huvudskärmen. XCTest är Apples ramverk för enhets- och UI-testning av iOS-appar, direkt integrerat i Xcode.

// UI-test för Snapshot
- (void)testScreenshots {
    XCUIApplication *app = [[XCUIApplication alloc] init];
    [app launch];
    
    snapshot(@"01-LoginScreen");
    
    [app.textFields[@"email"] tap];
    [app.textFields[@"email"] typeText:@"user@company.com"];
    [app.buttons[@"Login"] tap];
    
    snapshot(@"02-HomeScreen");
}

Arbete med språk och enheter

Snapshot växlar automatiskt simulatorspråk för varje språk som anges i Snapfile. Appen startar med motsvarande lokalisering och UI-testerna utförs på det språket. Lokalisering av skärmbilder är en kritisk ASO-faktor: användare föredrar i 75% av fallen appar med innehåll på modersmålet, inklusive skärmbilder i App Store.

För varje enhet startar Snapshot en separat simulator med motsvarande skärmdiagonal. Alla storlekar som krävs av App Store stöds: iPhone 6.5 tum (iPhone 15 Pro Max), 5.5 tum (iPhone 8 Plus), 6.7 tum (iPhone 15 Plus) och iPad 12.9 tum. iOS-simulator är en mjukvaruemulering av en iOS-enhet som är inbyggd i Xcode för testning av appar utan fysisk enhet.

# Generera skärmbilder för alla enheter och språk
fastlane snapshot

# Generera endast för angivna enheter
fastlane snapshot --devices "iPhone 15 Pro Max,iPhone 15"

# Rensa före generering av skärmbilder
fastlane snapshot --reinstall_app --erase_simulator

Konfigurera Snapshot via Snapfile

Snapfile är Fastlines konfigurationsfil som definierar parametrarna för generering av skärmbilder: lista över enheter, språk, väntetid och startalternativ. Snapfile lagras i katalogen fastlane och versionshanteras tillsammans med projektet, vilket garanterar en enhetlig konfiguration för alla teammedlemmar.

# Snapfile — konfiguration av skärmbilder
devices([
    "iPhone 15 Pro Max",
    "iPhone 15",
    "iPad Pro (12.9-inch)"
])

languages([
    "en-US",
    "ru",
    "de-DE"
])

scheme("MyAppUITests")
output_directory("./screenshots")
clear_previous_screenshots(true)
reinstall_app(true)
erase_simulator(true)

Parametern clear_previous_screenshots tar bort gamla skärmbilder innan genereringen påbörjas — detta förhindrar ackumulering av föråldrade bilder i utdatakatalogen. reinstall_app installerar om appen på simulatorn före varje körning, vilket garanterar en ren session utan påverkan från tidigare tester på ny generering.

Parametern erase_simulator rensar simulatorns innehåll innan testerna påbörjas — inklusive cache, inställningar och data från tidigare sessioner. Detta är särskilt viktigt för tester som kontrollerar onboarding eller första start av appen. Snapshot stöder också parametrarna ios_version för att ange iOS-version på simulatorn och stop_after_first_error för att stoppa genereringen vid första UI-testfelet.

För projekt med SwiftUI finns parametern use_simulator_for_language tillgänglig, som hanterar språkväxling via simulatorinställningar istället för att ändra systemregion. Snapshot stöder också launch_arguments för att skicka ytterligare argument vid start av appen — användbart för tester med olika backend-konfigurationer eller A/B-tester.

Snapshot-kommandon för att generera bilder

Snapshot-gränssnittet innehåller grundläggande kommandon för att starta generering och avancerade flaggor för exakt kontroll över processen. Huvudkommandot fastlane snapshot startar den fullständiga cykeln för generering av skärmbilder baserat på konfigurationen från Snapfile.

Snabb generering och filtrering

Kommandot fastlane snapshot --devices "iPhone 15" genererar skärmbilder endast för angivna enheter, ignorera resten från Snapfile. --languages "en-US,ru" filtrerar språken för generering. Kombinationen av dessa flaggor är användbar för snabb kontroll av skärmbilder på en enhet och ett språk utan den fullständiga genereringscykeln, som kan ta upp till 30 minuter för 5 enheter och 10 språk.

# Snabb generering för en enhet
fastlane snapshot --devices "iPhone 15" --languages "en-US"

# Generering med ominstallation av appen
fastlane snapshot --reinstall_app --erase_simulator

# Generering med HTML-rapport
fastlane snapshot --output_directory "./build/screenshots"

Flaggan --output_directory ändrar katalogen för att spara resultat. Som standard sparar Snapshot skärmbilder i fastlane/screenshots. För integrering med Deliver, ange en katalog som matchar den förväntade Deliverfile-strukturen — detta möjliggör direkt överföring av skärmbilder till publiceringsprocessen utan manuell kopiering av filer mellan mappar.

Integrera Snapshot i CI/CD-pipeline

Snapshot i CI/CD är automatisk generering av skärmbilder vid varje release-commit. Snapshot körs före Deliver-steget för att garantera att skärmbilderna i App Store motsvarar den aktuella versionen av appen och inte innehåller föråldrade gränssnittselement från tidigare versioner.

För Snapshot i CI krävs Xcode med installerade iOS-simulatorer. I CI-miljön använder Snapshot simulatorerna från Xcode som förladdas på sprinten. GitHub Actions tillhandahåller images med förinstallerat Xcode och iOS-simulatorer för körning av UI-tester utan ytterligare konfiguration.

# Kör Snapshot i CI-miljö
fastlane snapshot --skip_open_summary \

      --output_directory "$CI_PROJECT_DIR/screenshots"

# Spara skärmbilder som CI-artefakter
cp -R "screenshots/" "$CI_PROJECT_DIR/artifacts/"

Parametern --skip_open_summary inaktiverar öppning av HTML-rapporten efter generering — i CI-miljön är grafiskt gränssnitt inte tillgängligt. Genereringsresultaten sparas i en katalog som skickas som artefakt av CI-uppgiften och används sedan av Deliver för uppladdning till App Store tillsammans med releasen.

För att snabba upp CI-pipelinen, använd parallell generering av skärmbilder via concurrent_simulators — en Snapfile-parameter som startar flera simulatorer samtidigt. Detta minskar genereringstiden för skärmbilder för 5 enheter och 10 språk från 40 minuter till 15 minuter med 4 parallella trådar.

Vanliga fel vid arbete med Snapshot

Vid användning av Snapshot stöter utvecklare oftast på fel relaterade till instabilitet i UI-tester, problem med simulatorer och felaktig enhetskonfiguration. Diagnostik av fel i Snapshot börjar med analys av HTML-rapporten, som innehåller skärmbilder av varje steg och information om misslyckade tester.

Felet «Failed to build scheme MyAppUITests» uppstår när UI-testschemat inte är konfigurerat för byggning. Lösning: se till att ett separat Scheme för UI-tester har skapats i Xcode och att alternativet Shared är aktiverat för åtkomst från kommandoraden. Xcode Scheme är en konfiguration för byggning, testning och start av appen som definierar uppsättningen mål och parametrar för varje åtgärd.

Felet «No simulators found matching...» indikerar avsaknad av simulator med angiven enhetstyp eller iOS-version. Lösning: kör xcrun simctl create för att skapa simulatorn eller ange en befintlig enhet från listan xcrun simctl list. xcrun simctl är Xcodes kommandoradsverktyg för hantering av iOS-simulatorer: skapande, borttagning, start och diagnostik.

Vid felet «UI test failure» klarar inte UI-testet på ett av språken eller enheterna. Lösning: kör Snapshot med flaggan --stop_after_first_error för att stoppa vid första felet, analysera skärmbilden i HTML-rapporten och åtgärda testet. En vanlig orsak är olika textlängd på olika språk, vilket gör att gränssnittselement överlappar eller går utanför skärmgränserna.