Screengrab (Fastlane) — qu’est-ce que c’est, fonctionnalités et automatisation des captures d’écran

Qu’est-ce que Screengrab et pourquoi en avez-vous besoin

Screengrab est un composant de l’écosystème Fastlane conçu pour la création automatisée de captures d’écran d’applications mobiles. L’outil est apparu en 2015 en réponse au problème : pour publier sur Google Play et App Store, il faut 4 à 10 captures par langue. Avec le support de 30 langues, cela représente 120 à 300 captures manuelles.

Le problème de la création manuelle de captures d’écran

Un développeur lance manuellement l’application sur un simulateur ou un appareil, navigue jusqu’à l’écran souhaité, prend une capture d’écran, la transfère sur l’ordinateur, la recadre et l’enregistre dans le bon dossier. La procédure se répète pour chaque langue et chaque orientation. Selon Google Play Console, l’application moyenne est mise à jour toutes les deux semaines, ce qui transforme les captures d’écran en une routine régulière.

Avantages de l’automatisation

Screengrab résoud le problème radicalement : le développeur décrit des scénarios de test avec un framework d’UI (Espresso pour Android, XCTest pour iOS), et Screengrab les exécute automatiquement sur tous les appareils et langues nécessaires. Fastlane coordonne le processus : compile l’application, exécute les tests, collecte les captures et les empaquette dans la structure de dossiers requise.

Le résultat : cent captures d’écran en 10 à 15 minutes au lieu de plusieurs heures de travail manuel. Google recommande de mettre à jour les captures à chaque modification significative de l’interface, et sans automatisation, ce conseil est souvent ignoré.

Comment fonctionne Screengrab : architecture et principe de fonctionnement

L’architecture de Screengrab est construite autour de deux composants clés : un client sur l’appareil (screengrab-lib) et un exécuteur qui gère l’exécution des tests et la collecte des résultats. Sur Android, il utilise le framework de test instrumenté ; sur iOS — XCTest.

Cycle de vie d’une exécution unique

Fastlane appelle l’action screengrab, qui lit le fichier de configuration Screengrabfile. L’exécuteur compile l’APK de test avec la bibliothèque screengrab-lib connectée, l’installe sur les appareils ou émulateurs connectés et exécute les tests d’UI marqués avec des annotations pour les captures d’écran.

# Fastfile — description de lane pour captures d’écran
lane :screenshots do
  capture_android_screenshots(
    output_directory: "fastlane/metadata/android/screenshots",
    locales: ["ru-RU", "en-US", "de-DE"],
    devices: ["pixel_6", "pixel_tablet"],
    use_tests_external_storage: true
  )
end

Structure des fichiers de sortie

Screengrab crée une hiérarchie de dossiers : langue → appareil → captures. La structure correspond entièrement aux exigences de Google Play Console et d’App Store Connect. L’App Store exige des tailles strictement définies pour chaque type d’appareil, et Screengrab génère des captures exactement selon les spécifications.

Prise en charge multi-appareils

L’outil peut exécuter des tests en parallèle sur tous les appareils et émulateurs connectés. Les émulateurs Android démarrent automatiquement s’ils ne sont pas actifs. Pour iOS, Screengrab utilise les simulateurs Xcode.

Installation et configuration de Screengrab pour Android

L’installation de Screengrab comprend deux parties : ajouter la bibliothèque au projet et configurer le fichier de configuration. Sur Android, le framework d’UI Espresso et la bibliothèque screengrab-lib du dépôt Fastlane sont nécessaires.

Ajout des dépendances

Dans le build.gradle du module de l’application, la dépendance screengrab-lib est ajoutée. La bibliothèque fournit la classe ScreenCapturer, qui prend une capture d’écran au moment de l’appel.

// build.gradle (module: app)
androidTestImplementation(
  'tools.fastlane:screengrab-lib:2.1.0'
)

Écrire un test avec des captures d’écran

Un test d’UI est marqué avec l’annotation Screengrab.screenshot() aux endroits nécessaires. Chaque appel capture l’écran actuel et l’enregistre sous le nom spécifié.

import tools.fastlane.screengrab.Screengrab
import tools.fastlane.screengrab.locale.LocaleTestRule

class ScreenshotTest {

    @get:Rule
    val localeTestRule = LocaleTestRule()

    @Test
    fun testTakeScreenshots() {
        Screengrab.screenshot("main_screen")
        // Actions : appuyer sur le bouton de connexion
        Screengrab.screenshot("login_screen")
    }
}

Configuration Screengrabfile

Le fichier Screengrabfile stocke les paramètres de lancement : liste des appareils, langues, délais d’attente et chemin de sauvegarde. Le fichier se trouve généralement dans le dossier fastlane à côté de Fastfile.

Localisation des captures d’écran et plusieurs langues

La localisation est la fonctionnalité clé de Screengrab, et la principale raison pour laquelle il est le plus souvent choisi. L’outil bascule automatiquement la langue de l’application avant chaque exécution de test et prend des captures dans toutes les langues spécifiées.

Configuration des langues

Les langues sont définies dans Screengrabfile à l’aide du paramètre locales. Pour chaque langue, Screengrab réinstalle l’application avec les ressources correspondantes et exécute le cycle complet de tests. LocaleTestRule sur Android bascule automatiquement la locale de l’appareil.

# Screengrabfile
locales [
  "ru-RU",
  "en-US",
  "de-DE",
  "fr-FR",
  "es-ES",
  "ja-JP",
  "ko-KR"
]

Structure de dossiers pour les captures localisées

Screengrab crée des répertoires selon le schéma : screenshots/{locale}/{device_name}/{screenshot_name}.png. Cette structure correspond directement aux exigences de Google Play, permettant de télécharger les captures via Fastlane deliver avec une seule commande.

Pour iOS, App Store Connect attend les captures dans une structure plate par langue. Fastlane convertit automatiquement la hiérarchie Screengrab dans le format requis lors de la publication.

Intégration de Screengrab dans un pipeline CI/CD

L’intégration CI/CD est l’un des principaux avantages de Screengrab. L’outil s’exécute à partir de la ligne de commande et ne nécessite pas d’interface graphique, ce qui le rend idéal pour les builds serveur.

GitHub Actions

Dans un environnement CI, vous devez lancer un émulateur Android ou un simulateur iOS, puis appeler la lane avec les captures. GitHub Actions prend en charge la mise en cache AVD, ce qui accélère les exécutions répétées.

Paramètres pour CI

Dans la configuration CI, il est important de prendre en compte les limites de mémoire et de temps. Les émulateurs Android nécessitent au moins 2 Go de RAM par appareil, et une exécution complète sur 7 langues et 2 appareils prend 20 à 40 minutes.

# Fastfile — lane pour CI avec délais d’attente
lane :ci_screenshots do
  capture_android_screenshots(
    locales: ["en-US", "ru-RU"],
    devices: ["pixel_6"],
    clear_previous_screenshots: true,
    tests_timeout: "600",
    output_directory: "screenshots/ci"
  )
end

Pipeline Jenkins

Pour Jenkins, l’étape sh avec un appel à bundle exec fastlane est utilisée. Il est recommandé d’exécuter les captures de nuit ou par déclencheur après fusion dans la branche principale pour ne pas ralentir le cycle de développement.

Screengrab vs alternatives : comparaison des outils

Screengrab n’est pas le seul outil pour automatiser les captures d’écran. Il existe des alternatives avec différentes approches : outils intégrés du système d’exploitation, plateformes commerciales et bibliothèques de captures dans le code.

ADB Shell offre un contrôle total, mais nécessite l’écriture de scripts pour chaque scénario. XCTest est intégré dans Xcode, mais ne gère pas automatiquement la localisation. Firebase Test Lab exécute des tests sur des appareils réels dans le cloud, offrant une couverture maximale, mais facture à la minute.

Screengrab gagne grâce à la combinaison : Fastlane gère l’ensemble du cycle de vie du build — de la compilation à la publication. Google Play accepte directement la structure de dossiers Screengrab via Fastlane deliver.

Problèmes courants et leurs solutions

Lorsqu’ils travaillent avec Screengrab, les développeurs rencontrent le plus souvent plusieurs problèmes récurrents. Connaître les erreurs typiques réduit le temps de débogage lors du premier lancement.

Les captures d’écran sont vides ou noires

Le problème survient lorsque Screengrab prend une capture avant la fin du rendu de l’écran. La solution est d’ajouter un délai Thread.sleep() avant d’appeler screenshot() ou d’utiliser IdlingResource d’Espresso pour attendre les opérations asynchrones.

Erreur d’incompatibilité de version

La version de screengrab-lib doit correspondre à celle de Fastlane. Fastlane est mis à jour mensuellement, et une ancienne bibliothèque peut ne pas prendre en charge les nouveaux paramètres de configuration. La solution est de synchroniser les versions via Gemfile et gradle.properties.

Exécution longue sur CI

L’exécution sur 30 langues sur 5 appareils peut prendre plus d’une heure. La solution est de diviser les exécutions : une pour le magasin dans toutes les langues, une autre pour les besoins internes dans deux langues. GitHub Actions permet d’utiliser des stratégies de matrice pour les exécutions parallèles.

Problèmes d’émulateur sur CI

L’émulateur Android nécessite une virtualisation matérielle, qui n’est pas toujours disponible sur les serveurs CI. KVM doit être activé, sinon l’émulateur ne démarre pas. La solution est d’utiliser des images x86 sans accélération GPU ou Firebase Test Lab.