xcode-select --install

# Using RubyGems
sudo gem install fastlane -NV

# Alternatively using Homebrew
brew install fastlane

fastlane init

fastlane screenshots for iOS and tvOS

Your App Store screenshots are probably the most important thing when it comes to convincing potential users to download or purchase your app. Unfortunately, many apps don't do screenshots well. This is often because taking screenshots of your app and then preparing them for display is time consuming, and it's hard to get everything right and consistent! For example:

• Are the screenshots in the App Store inconsistent with your latest app design?
• Is your app localized into many languages that require different screenshots for each?
• Have you made sure that no loading indicators are showing?
• Is the same content displayed for each of your size variations?

fastlane tools can automate this process making it fast, and consistent while giving you beautiful results!

Alternatives

For the full story about the many ways that developers can capture and beautify screenshots check out this article.

Manually Capturing Screenshots

Manually taking screenshots takes too much time, which also decreases the quality of the screenshots. Since it is not automated, the screenshots will show slightly different content on the various devices and languages. Many companies choose to create screenshots in one language and use them for all languages. While this might seem okay to us developers, there are many potential users out there that cannot read the text on your app screenshots if they are not localised. Have you ever looked at a screenshot with content in a language you don't know? It won't convince you to download the app.

However, the biggest disadvantage of this method is what happens when you need to repeat the process. If you notice a spelling mistake in the screenshots, if you release an update with a new design, or if you just want to show more up to date content, you'll have to create new screenshots for all languages and devices... manually.

The positive side of this approach is that your screenshots will all be crisp and correctly sized, with readable text.

Scaled Screenshots via App Store Connect

App Store Connect allows you to use one set of screenshots per device type, which will then be scaled to the appropriate size when viewed in the App Store on a user's device.

While this is convenient, this approach has the same problems as the device frame approach: The screenshots don't actually show how the app looks on the user's device. It's a valid way to start though, since you can gradually overwrite screenshots for specific languages and devices.

Capture Screenshots Automatically

snapshot works with fastlane to automate the process of capturing screenshots of your app. It allows you to:

• Capture hundreds of screenshots in multiple languages on all simulators
• Take screenshots in multiple device simulators concurrently to cut down execution time
• Do something else while the computer takes the screenshots for you
• Configure it once, and store the configuration so anyone on the team can run it
• Generate a beautiful web page showing all screenshots on all devices. This is perfect to send to Q&A, marketing, or translators for verification
• Avoid having loading indicators in your App Store screenshots by intelligently waiting for network requests to be finished
• Get a summary of how your app looks like across all supported devices and languages

After snapshot successfully captures all the screenshots, it will show you a beautiful HTML page to summarize all the screens that were captured:

Getting Started Using UI Tests

snapshot uses the capabilities of Apple's UI Tests to drive interactions with your app. To get familiar with writing UI Tests, check out the following introductions:

• WWDC 2015 Introduction to UI Tests
• A first look into UI Tests
• UI Testing in Xcode 7
• HSTestingBackchannel : ‘Cheat’ by communicating directly with your app
• Automating App Store screenshots using fastlane snapshot and frameit

To jump-start your UI tests, you can use the UI Test recorder, which you can start by clicking the red record button on the bottom of the window. By interacting with your app through the simulator while using it, Xcode will generate UI Test code for you. To learn more, check out this this blog post!

Setting Up snapshot

1. Create a new UI Test target in your Xcode project (See the top part of this article)
2. Run fastlane snapshot init in your project folder
3. Add the ./SnapshotHelper.swift file to your UI Test target (You can move the file anywhere you want)
4. Add a new Xcode scheme for the newly created UI Test target
5. Edit the scheme
6. In the list on the left click "Build", and enable the checkbox under the "Run" column for your target.
7. Enable the Shared box of the newly created scheme
8. (Objective C only) Add the bridging header to your test class.
   • #import "MYUITests-Swift.h"
   • The bridging header is named after your test target with -Swift.h appended.
9. In your UI Test class, click the Record button on the bottom left and record your interaction
10. To take a screenshot, call the following between interactions
    • Swift: snapshot("01LoginScreen")
    • Objective C: [Snapshot snapshot:@"01LoginScreen" timeWaitingForIdle:10];
11. Add the following code to your setUp() method:

Swift:

let app = XCUIApplication()
setupSnapshot(app)
app.launch()

Objective C:

XCUIApplication *app = [[XCUIApplication alloc] init];
[Snapshot setupSnapshot:app waitForAnimations:NO];
[app launch];

12. In the terminal run fastlane snapshot.
WARNING: Running the test in Xcode does not create the snapshots and will not generate the correct results - although no tests will fail. The command line program creates the necessary subdirectories, renames the files as appropriate, and generates the overview html page.

The setup process will also generate a Snapfile, looking similar to

# A list of devices you want to take the screenshots from
# devices([
#  "iPad (7th generation)",
#  "iPad Air (3rd generation)",
#  "iPad Pro (11-inch)",
#  "iPad Pro (12.9-inch) (3rd generation)",
#  "iPad Pro (9.7-inch)",
#  "iPhone 11",
#  "iPhone 11 Pro",
#  "iPhone 11 Pro Max",
#  "iPhone 8",
#  "iPhone 8 Plus"
# ])

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

# The name of the scheme which contains the UI Tests
# scheme "SchemeName"

# Where should the resulting screenshots be stored?
# output_directory "./screenshots"

# clear_previous_screenshots true # remove the '#' to clear all previously generated screenshots before creating new ones

# Choose which project/workspace to use
# project "./Project.xcodeproj"
# workspace "./Project.xcworkspace"

# For more information about all available options run
# fastlane action snapshot

You can adapt this file to fit your project. Every time you run fastlane snapshot the file will be loaded automatically.

For a list of all available parameters that can be used in the Snapfile run fastlane action snapshot.

If you have fastlane installed, it's easy to give snapshot a try. First clone the fastlane repo, head over to the snapshot example project, and then run fastlane snapshot

git clone https://github.com/fastlane/fastlane  # Clone the fastlane repo
cd fastlane/snapshot/example                    # Navigate to the example project
fastlane snapshot                               # Generate screenshots for the sample app

Upload Screenshots to the App Store

After generating your screenshots using fastlane snapshot, you usually want to upload them to App Store Connect.

If you followed the setup guide, you already ran fastlane init before, so you should have your existing screenshots and metadata inside the fastlane/screenshots and fastlane/metadata directory. Running fastlane snapshot will store the screenshots in the fastlane/screenshots directory by default.

To upload the screenshots stored in fastlane/screenshots, just run

fastlane deliver

This will also show you a metadata summary, before actually uploading the screenshots, as this will overwrite the metadata and screenshots you already have on App Store Connect.

Use in Fastfile

To put all of this together so that anyone on your team could trigger generating and uploading new screenshots, you can define a fastlane lane called screenshots. It would be responsible for:

1. Running your app through snapshot to automatically capture your screenshots
2. Having deliver send your final screenshots to App Store Connect for use in the App Store

Add the following code to your fastlane/Fastfile:

lane :screenshots do
  capture_screenshots
  upload_to_app_store
end

To get a list of all available options for each of the steps, run

fastlane action capture_screenshots
fastlane action upload_to_app_store

Put Your Screenshots Into Device Frames

frameit helps you beautify your screenshots with device frames and text by running one simple command. It provides support for:

• Multiple device types
• Portrait and landscape orientations
• Black and silver devices
• Setting a background color and decorating the image with text

Usage

To automatically add device frames around all screenshots in the current directory and its subdirectories, just run:

fastlane frameit

This will only add a device frame around the screenshots, not the background and title. Those images can be used for your website, email newsletter and similar.

If you want to implement the custom titles and background, you'll have to setup a Framefile.json, more information can be found here.

If you want to upload the screenshots to the App Store, you have to provide a Framefile.json, with titles and background, otherwise the resolution of the framed screenshots doesn't match the requirements of App Store Connect.

Dependencies

brew install libpng jpeg imagemagick

mogrify: no decode delegate for this image format `PNG'

brew uninstall imagemagick; brew install libpng jpeg; brew install imagemagick --build-from-source

fastlane frameit setup

To add the framing to your deployment process, use the following code in your Fastfile:

lane :screenshots do
  capture_screenshots
  frame_screenshots(white: true)
  upload_to_app_store
end

To get a list of all available options for frame_screenshots (which calls into frameit)

fastlane action frame_screenshots

Advanced snapshot

lane :screenshots do
  capture_screenshots
end

capture_screenshots(stop_after_first_error: true)

capture_screenshots(skip_open_summary: true)

capture_screenshots(scheme: "UITests", configuration: "Release", sdk: "iphonesimulator")

capture_screenshots(reinstall_app: true, app_identifier: "tools.fastlane.app")

capture_screenshots(number_of_retries: 3)

capture_screenshots(add_photos: "MyTestApp/demo.jpg", add_videos: "MyTestApp/demo.mp4")

fastlane action capture_screenshots

fastlane snapshot reset_simulators

launch_arguments([
  "-firstName Felix -lastName Krause"
])

name.text = UserDefaults.standard.string(forKey: "firstName")
// name.text = "Felix"

if UserDefaults.standard.bool(forKey: "FASTLANE_SNAPSHOT") {
    // runtime check that we are in snapshot mode
}

# Snapfile for A/B Test Comparison
launch_arguments([
  "-secretFeatureEnabled YES",
  "-secretFeatureEnabled NO"
])

fastlane snapshot update