fastlane_hotfix 2.187.0

data/fastlane/lib/fastlane/actions/device_grid/README.md

@@ -0,0 +1,157 @@
+# fastlane danger Device Grid
+
+Ever dream of testing your app straight from a pull request? Well now you can! With [_fastlane_](https://fastlane.tools), [danger](https://github.com/danger/danger) and [appetize.io](https://appetize.io/), you can stream your latest changes right from the browser.
+
+No more manually installing and testing your app just to review a PR.
+
+![assets/GridExampleScreenshot.png](assets/GridExampleScreenshot.png)
+
+[View Example Pull Request](https://github.com/Themoji/ios/pull/12#issuecomment-215836315)
+
+## Requirements
+
+- [_fastlane_](https://fastlane.tools)
+- [danger](https://github.com/danger/danger)
+- [appetize.io](https://appetize.io/) account
+- A Continuous Integration system
+
+## Getting started
+
+### Install fastlane and danger
+
+Create a `Gemfile` in your project's directory with the following content
+
+```ruby
+gem "fastlane"
+gem "danger"
+gem "danger-device_grid"
+```
+
+and run
+
+```
+bundle install
+```
+
+### Setup _fastlane_
+
+Skip this step if you're already using _fastlane_ (which you should)
+
+```
+fastlane init
+```
+
+### Setup `danger`
+
+```
+danger init
+```
+
+Follow the `danger` guide to authenticate with GitHub
+
+### Configure `danger`
+
+Edit `Dangerfile` and replace the content with
+
+```ruby
+puts("Running fastlane to generate and upload an ipa file...")
+
+options = {
+  xcodebuild: {
+      workspace: "YourApp.xcworkspace",
+      scheme: "YourScheme"
+    }
+}
+
+require 'fastlane'
+result = Fastlane::OneOff.run(action: "build_and_upload_to_appetize",
+                          parameters: options)
+
+device_grid.run(
+  public_key: result,
+  languages: ["en", "de"],
+  devices: ["iphone5s", "iphone6splus", "ipadair"]
+)
+```
+
+Make sure to fill in your actual workspace and scheme, or use the `project` parameter `project: "YourApp.xcworkspace"`.
+
+### Try it
+
+Push everything to GitHub in its own branch and create a PR to trigger your CI system. 
+
+### Make use of deep linking
+
+When you submit a PR you usually know what part of your app should be reviewed. Make it easier for everyone by providing a deep link, launching the app at the right point. To do so, use emojis (what else):
+
+Add this to the bottom of your PR-body:
+
+```
+:link: com.krausefx.app://bacons/show/937
+```
+
+### Make use of `NSUserDefaults`
+
+To do a runtime check if if the app is running on `Appetize`, just use:
+
+```objective-c
+[[NSUserDefaults standardUserDefaults] objectForKey:@"isAppetize"]
+```
+
+### Generate `appetize` stream, without the grid
+
+Add the following to your `Fastfile` to build and upload your app to `appetize`. 
+
+```ruby
+desc "Build your app and upload it to Appetize to stream it in your browser"
+lane :upload_to_appetize do
+  build_and_upload_to_appetize(
+    xcodebuild: {
+      workspace: "YourApp.xcworkspace",
+      scheme: "YourScheme"
+    }
+  )
+end
+```
+
+Run the newly created lane using
+
+```
+fastlane upload_to_appetize
+```
+
+### Manual way using `appetize_viewing_url_generator`
+
+If you want even more control over the way your app is built, you can also manually generate your `.app` and then upload it to `appetize`.
+
+Use the `appetize` action together with `appetize_viewing_url_generator`. Make sure to build with the `iphonesimulator` SDK, since `appetize` runs iOS simulators to stream your application.
+
+```ruby
+tmp_path = "/tmp/fastlane_build"
+xcodebuild(
+  workspace: "Themoji.xcworkspace",
+  sdk: "iphonesimulator",
+  scheme: "Themoji",
+  derivedDataPath: tmp_path
+)
+
+app_path = Dir[File.join(tmp_path, "**", "*.app")].last
+UI.user_error!("Couldn't find app") unless app_path
+
+zipped_bundle = zip(path: app_path, output_path: File.join(tmp_path, "Result.zip"))
+
+appetize(
+  path: zipped_bundle,
+  api_token: 'yourapitoken' # get it from https://appetize.io/docs#request-api-token
+)
+
+url = appetize_viewing_url_generator(scale: "75", color: "black", public_key: "123123")
+UI.message("Generated URL: #{url}")
+```
+
+#### Disclaimer
+
+All product names, logos, and brands are property of their respective owners.  
+The used device frames were provided by Facebook via the [Facebook Design Resources](https://facebook.github.io/design/devices.html). _fastlane_ is in no way affiliated with Facebook.
+
+> While Facebook has redrawn and shares these assets for the benefit of the design community, Facebook does not own any of the underlying product or user interface designs. By accessing these assets, you agree to obtain all necessary permissions from the underlying rights holders and/or adhere to any applicable brand use guidelines before using them. Facebook disclaims all express or implied warranties with respect to these assets, including non-infringement of intellectual property rights.

data/fastlane/lib/fastlane/actions/docs/build_app.md

@@ -0,0 +1,245 @@
+<p align="center">
+  <img src="/img/actions/gym.png" width="250">
+</p>
+
+-------
+
+<p align="center">
+    <a href="#whats-gym">Features</a> &bull;
+    <a href="#usage">Usage</a> &bull;
+    <a href="#tips">Tips</a>
+</p>
+
+-------
+
+<h5 align="center"><em>gym</em> is part of <a href="https://fastlane.tools">fastlane</a>: The easiest way to automate beta deployments and releases for your iOS and Android apps.</h5>
+
+# What's gym?
+
+_gym_ builds and packages iOS apps for you. It takes care of all the heavy lifting and makes it super easy to generate a signed `ipa` or `app` file 💪
+
+_gym_ is a replacement for [shenzhen](https://github.com/nomad/shenzhen).
+
+### Before _gym_
+
+```no-highlight
+xcodebuild clean archive -archivePath build/MyApp \
+                         -scheme MyApp
+xcodebuild -exportArchive \
+           -exportFormat ipa \
+           -archivePath "build/MyApp.xcarchive" \
+           -exportPath "build/MyApp.ipa" \
+           -exportProvisioningProfile "ProvisioningProfileName"
+```
+
+### With _gym_
+
+```no-highlight
+fastlane gym
+```
+
+### Why _gym_?
+
+_gym_ uses the latest APIs to build and sign your application which results in much faster build times.
+
+|          |  Gym Features  |
+|----------|----------------|
+🚀 | _gym_ builds 30% faster than other build tools like [shenzhen](https://github.com/nomad/shenzhen)
+🏁 | Beautiful inline build output
+📖 | Helps you resolve common build errors like code signing issues
+🚠 | Sensible defaults: Automatically detect the project, its schemes and more
+🔗 | Works perfectly with [_fastlane_](https://fastlane.tools) and other tools
+📦 | Automatically generates an `ipa` and a compressed `dSYM` file
+🚅 | Don't remember any complicated build commands, just _gym_
+🔧 | Easy and dynamic configuration using parameters and environment variables
+💾 | Store common build settings in a `Gymfile`
+📤 | All archives are stored and accessible in the Xcode Organizer
+💻 | Supports both iOS and Mac applications
+
+![/img/actions/gymScreenshot.png](/img/actions/gymScreenshot.png)
+
+-----
+
+![/img/actions/gym.gif](/img/actions/gym.gif)
+
+# Usage
+
+```no-highlight
+fastlane gym
+```
+
+That's all you need to build your application. If you want more control, here are some available parameters:
+
+```no-highlight
+fastlane gym --workspace "Example.xcworkspace" --scheme "AppName" --clean
+```
+
+If you need to use a different Xcode installation, use `xcode-select` or define `DEVELOPER_DIR`:
+
+```no-highlight
+DEVELOPER_DIR="/Applications/Xcode6.2.app" fastlane gym
+```
+
+For a list of all available parameters use
+
+```no-highlight
+fastlane action gym
+```
+
+If you run into any issues, use the `verbose` mode to get more information
+
+```no-highlight
+fastlane gym --verbose
+```
+
+Set the right export method if you're not uploading to App Store or TestFlight:
+
+```no-highlight
+fastlane gym --export_method ad-hoc
+```
+
+To pass boolean parameters make sure to use _gym_ like this:
+
+```no-highlight
+fastlane gym --include_bitcode true --include_symbols false
+```
+
+To access the raw `xcodebuild` output open `~/Library/Logs/gym`
+
+# Gymfile
+
+Since you might want to manually trigger a new build but don't want to specify all the parameters every time, you can store your defaults in a so called `Gymfile`.
+
+Run `fastlane gym init` to create a new configuration file. Example:
+
+```ruby-skip-tests
+scheme("Example")
+
+sdk("iphoneos9.0")
+
+clean(true)
+
+output_directory("./build")    # store the ipa in this folder
+output_name("MyApp")           # the name of the ipa file
+```
+
+## Export options
+
+Since Xcode 7, _gym_ is using new Xcode API which allows us to specify export options using `plist` file. By default _gym_ creates this file for you and you are able to modify some parameters by using `export_method`, `export_team_id`, `include_symbols` or `include_bitcode`. If you want to have more options, like creating manifest file for app thinning, you can provide your own `plist` file:
+
+```ruby-skip-tests
+export_options("./ExportOptions.plist")
+```
+
+or you can provide hash of values directly in the `Gymfile`:
+
+```ruby-skip-tests
+export_options({
+  method: "ad-hoc",
+  manifest: {
+    appURL: "https://example.com/My App.ipa",
+  },
+  thinning: "<thin-for-all-variants>"
+})
+```
+
+Optional: If _gym_ can't automatically detect the provisioning profiles to use, you can pass a mapping of bundle identifiers to provisioning profiles:
+
+```ruby
+build_app(
+  scheme: "Release",
+  export_method: "app-store",
+  export_options: {
+    provisioningProfiles: { 
+      "com.example.bundleid" => "Provisioning Profile Name",
+      "com.example.bundleid2" => "Provisioning Profile Name 2"
+    }
+  }
+)
+```
+
+**Note**: If you use [_fastlane_](https://fastlane.tools) with [_match_](https://fastlane.tools/match) you don't need to provide those values manually, unless you pass a plist file into `export_options`
+
+For the list of available options run `xcodebuild -help`.
+
+## Setup code signing
+
+- [More information on how to get started with codesigning](https://docs.fastlane.tools/codesigning/getting-started/)
+- [Docs on how to set up your Xcode project](https://docs.fastlane.tools/codesigning/xcode-project/)
+
+## Automating the whole process
+
+_gym_ works great together with [_fastlane_](https://fastlane.tools), which connects all deployment tools into one streamlined workflow.
+
+Using _fastlane_ you can define a configuration like
+
+```ruby
+lane :beta do
+  scan
+  gym(scheme: "MyApp")
+  crashlytics
+end
+
+# error block is executed when a error occurs
+error do |lane, exception|
+  slack(
+    # message with short human friendly message
+    message: exception.to_s, 
+    success: false, 
+    # Output containing extended log output
+    payload: { "Output" => exception.error_info.to_s } 
+  )
+end
+```
+
+When _gym_ raises an error the `error_info` property will contain the process output
+in case you want to display the error in 3rd party tools such as Slack.
+
+You can then easily switch between the beta provider (e.g. `testflight`, `hockey`, `s3` and more).
+
+# How does it work?
+
+_gym_ uses the latest APIs to build and sign your application. The 2 main components are
+
+- `xcodebuild`
+- [xcpretty](https://github.com/supermarin/xcpretty)
+
+When you run _gym_ without the `--silent` mode it will print out every command it executes.
+
+To build the archive _gym_ uses the following command:
+
+```no-highlight
+set -o pipefail && \
+xcodebuild -scheme 'Example' \
+-project './Example.xcodeproj' \
+-configuration 'Release' \
+-destination 'generic/platform=iOS' \
+-archivePath '/Users/felixkrause/Library/Developer/Xcode/Archives/2015-08-11/ExampleProductName 2015-08-11 18.15.30.xcarchive' \
+archive | xcpretty
+```
+
+After building the archive it is being checked by _gym_. If it's valid, it gets packaged up and signed into an `ipa` file.
+
+_gym_ automatically chooses a different packaging method depending on the version of Xcode you're using.
+
+### Xcode 7 and above
+
+```no-highlight
+/usr/bin/xcrun path/to/xcbuild-safe.sh -exportArchive \
+-exportOptionsPlist '/tmp/gym_config_1442852529.plist' \
+-archivePath '/Users/fkrause/Library/Developer/Xcode/Archives/2015-09-21/App 2015-09-21 09.21.56.xcarchive' \
+-exportPath '/tmp/1442852529'
+```
+
+_gym_ makes use of the new Xcode 7 API which allows us to specify the export options using a `plist` file. You can find more information about the available options by running `xcodebuild --help`.
+
+Using this method there are no workarounds for WatchKit or Swift required, as it uses the same technique Xcode uses when exporting your binary.
+
+Note: the [xcbuild-safe.sh script](https://github.com/fastlane/fastlane/blob/master/gym/lib/assets/wrap_xcodebuild/xcbuild-safe.sh) wraps around xcodebuild to workaround some incompatibilities.
+
+## Use 'ProvisionQL' for advanced Quick Look in Finder
+
+Install [ProvisionQL](https://github.com/ealeksandrov/ProvisionQL).
+
+It will show you `ipa` files like this:
+![img/actions/QuickLookScreenshot-App.png](/img/actions/QuickLookScreenshot-App.png)

data/fastlane/lib/fastlane/actions/docs/capture_android_screenshots.md

@@ -0,0 +1,332 @@
+<p align="center">
+  <img src="/img/actions/screengrab.png" width="250">
+</p>
+
+###### Automated localized screenshots of your Android app on every device
+
+_screengrab_ generates localized screenshots of your Android app for different device types and languages for Google Play and can be uploaded using [_supply_](https://fastlane.tools/supply).
+
+<img src="/img/actions/running-screengrab.gif" width="640">
+
+### Why should I automate this process?
+
+- Create hundreds of screenshots in multiple languages on emulators or real devices, saving you hours
+- Easily verify that localizations fit into labels on all screen dimensions to find UI mistakes before you ship
+- You only need to configure it once for anyone on your team to run it
+- Keep your screenshots perfectly up-to-date with every app update. Your customers deserve it!
+- Fully integrates with [_fastlane_](https://fastlane.tools) and [_supply_](https://fastlane.tools/supply)
+
+# Installation
+
+Install the gem
+
+```no-highlight
+gem install fastlane
+```
+
+##### Gradle dependency
+```java
+androidTestImplementation 'tools.fastlane:screengrab:x.x.x'
+```
+
+The latest version is [ ![Download](https://maven-badges.herokuapp.com/maven-central/tools.fastlane/screengrab/badge.svg)](https://search.maven.org/artifact/tools.fastlane/screengrab)
+
+As of Screengrab version 2.0.0, all Android test dependencies are AndroidX dependencies. This means a device with API 18+, Android 4.3 or greater is required. If you wish to capture screenshots with an older Android OS, then you must use a 1.x.x version.
+
+##### Configuring your Manifest Permissions
+
+Ensure that the following permissions exist in your **src/debug/AndroidManifest.xml**
+
+```xml
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+        xmlns:tools="http://schemas.android.com/tools">
+
+    <!-- Allows storing screenshots on external storage, where it can be accessed by ADB -->
+    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" android:maxSdkVersion="18" />
+
+    <!-- Allows changing locales -->
+    <uses-permission
+            android:name="android.permission.CHANGE_CONFIGURATION"
+            tools:ignore="ProtectedPermissions" />
+
+    <!-- Allows changing SystemUI demo mode -->
+    <uses-permission
+            android:name="android.permission.DUMP"
+            tools:ignore="ProtectedPermissions" />
+
+</manifest>
+```
+
+##### Configuring your <a href="#ui-tests">UI Tests</a> for Screenshots
+
+1. Add `LocaleTestRule` to your tests class to handle automatic switching of locales.
+   If you're using Java use:
+   ```java
+   @ClassRule
+   public static final LocaleTestRule localeTestRule = new LocaleTestRule();
+   ```
+   If you're using Kotlin use:
+   ```kotlin
+   @Rule @JvmField
+   val localeTestRule = LocaleTestRule()
+   ```
+   The `@JvmField` annotation is important. It won't work like this:
+   ```kotlin
+   companion object {
+       @get:ClassRule
+       val localeTestRule = LocaleTestRule()
+   }
+   ```
+
+2. To capture screenshots, add the following to your tests `Screengrab.screenshot("name_of_screenshot_here");` on the appropriate screens
+
+# Generating Screenshots with Screengrab
+- Then, before running `fastlane screengrab` you'll need a debug and test apk
+  - You can create your APKs manually with `./gradlew assembleDebug assembleAndroidTest`
+  - You can also create a lane and use `build_android_app`:
+    ```ruby
+    desc "Build debug and test APK for screenshots"
+    lane :build_and_screengrab do
+      build_android_app(
+        task: 'assemble',
+        build_type: 'Debug'
+      )
+      build_android_app(
+        task: 'assemble',
+        build_type: 'AndroidTest'
+      )
+      screengrab()
+    end
+    ```
+- Once complete run `fastlane screengrab` in your app project directory to generate screenshots
+  - You will be prompted to provide any required parameters which are not in your **Screengrabfile** or provided as command line arguments
+- Your screenshots will be saved to `fastlane/metadata/android` in the directory where you ran _screengrab_
+
+## Improved screenshot capture with UI Automator
+
+As of _screengrab_ 0.5.0, you can specify different strategies to control the way _screengrab_ captures screenshots. The newer strategy delegates to [UI Automator](https://developer.android.com/topic/libraries/testing-support-library/index.html#UIAutomator) which fixes a number of problems compared to the original strategy:
+
+* Shadows/elevation are correctly captured for Material UI
+* Multi-window situations are correctly captured (dialogs, etc.)
+* Works on Android N
+
+UI Automator is the default strategy. However, UI Automator requires a device with **API level >= 18**. If you need to grab screenshots on an older Android version, use the latest 1.x.x version of this library and set the DecorView ScreenshotStrategy.
+
+```java
+Screengrab.setDefaultScreenshotStrategy(new DecorViewScreenshotStrategy());
+```
+
+## Improved screenshot capture with Falcon
+
+As of _screengrab_ 1.2.0, you can specify a new strategy to delegate to [Falcon](https://github.com/jraska/Falcon). Falcon may work better than UI Automator in some situations and also provides similar benefits as UI Automator:
+
+* Multi-window situations are correctly captured (dialogs, etc.)
+* Works on Android N
+
+Falcon requires a device with **API level >= 10**. To enable it for all screenshots by default, make the following call before your tests run:
+
+```java
+Screengrab.setDefaultScreenshotStrategy(new FalconScreenshotStrategy(activityRule.getActivity()));
+```
+
+## Advanced Screengrabfile Configuration
+
+Running `fastlane screengrab init` generated a Screengrabfile which can store all of your configuration options. Since most values will not change often for your project, it is recommended to store them there.
+
+The `Screengrabfile` is written in Ruby, so you may find it helpful to use an editor that highlights Ruby syntax to modify this file.
+
+```ruby-skip-tests
+# remove the leading '#' to uncomment lines
+
+# app_package_name('your.app.package')
+# use_tests_in_packages(['your.screenshot.tests.package'])
+
+# app_apk_path('path/to/your/app.apk')
+# tests_apk_path('path/to/your/tests.apk')
+
+locales(['en-US', 'fr-FR', 'it-IT'])
+
+# clear all previously generated screenshots in your local output directory before creating new ones
+clear_previous_screenshots(true)
+```
+
+For more information about all available options run
+
+```no-highlight
+fastlane action screengrab
+```
+
+# Tips
+
+## UI Tests
+
+Check out [Testing UI for a Single App](http://developer.android.com/training/testing/ui-testing/espresso-testing.html) for an introduction to using Espresso for UI testing.
+
+##### Example UI Test Class (Using JUnit4)
+Java:
+```java
+@RunWith(JUnit4.class)
+public class JUnit4StyleTests {
+    @ClassRule
+    public static final LocaleTestRule localeTestRule = new LocaleTestRule();
+
+    @Rule
+    public ActivityScenarioRule<MainActivity> activityRule = new ActivityScenarioRule<>(MainActivity.class);
+
+    @Test
+    public void testTakeScreenshot() {
+        Screengrab.screenshot("before_button_click");
+
+        onView(withId(R.id.fab)).perform(click());
+
+        Screengrab.screenshot("after_button_click");
+    }
+}
+
+```
+Kotlin:
+```kotlin
+@RunWith(JUnit4.class)
+class JUnit4StyleTests {
+    @get:Rule
+    var activityRule = ActivityScenarioRule(MainActivity::class.java)
+
+    @Rule @JvmField
+    val localeTestRule = LocaleTestRule()
+
+    @Test
+    fun testTakeScreenshot() {
+        Screengrab.screenshot("before_button_click")
+
+        onView(withId(R.id.fab)).perform(click())
+
+        Screengrab.screenshot("after_button_click")
+    }
+}
+
+```
+
+There is an [example project](https://github.com/fastlane/fastlane/tree/master/screengrab/example/src/androidTest/java/tools/fastlane/localetester) showing how to use JUnit 3 or 4 and Espresso with the screengrab Java library to capture screenshots during a UI test run.
+
+Using JUnit 4 is preferable because of its ability to perform actions before and after the entire test class is run. This means you will change the device's locale far fewer times when compared with JUnit 3 running those commands before and after each test method.
+
+When using JUnit 3 you'll need to add a bit more code:
+
+- Use `LocaleUtil.changeDeviceLocaleTo(LocaleUtil.getTestLocale());` in `setUp()`
+- Use `LocaleUtil.changeDeviceLocaleTo(LocaleUtil.getEndingLocale());` in `tearDown()`
+- Use `Screengrab.screenshot("name_of_screenshot_here");` to capture screenshots at the appropriate points in your tests
+
+## Clean Status Bar
+
+Screengrab can clean your status bar to make your screenshots even more beautiful.
+It is simply a wrapper that allows configuring SystemUI DemoMode in your code.
+Note: the clean status bar feature is only supported on devices with *API level >= 23*.
+
+You can enable and disable the clean status bar at any moment during your tests.
+In most cases you probably want to do this in the @BeforeClass and @AfterClass methods.
+```java
+@BeforeClass
+public static void beforeAll() {
+    CleanStatusBar.enableWithDefaults();
+}
+
+@AfterClass
+public static void afterAll() {
+    CleanStatusBar.disable();
+}
+```
+
+Have a look at the methods of the `CleanStatusBar` class to customize the status bar even more.
+You could for example show the Bluetooth icon and the LTE text.
+```java
+new CleanStatusBar()
+    .setBluetoothState(BluetoothState.DISCONNECTED)
+    .setMobileNetworkDataType(MobileDataType.LTE)
+    .enable();
+```
+
+# Advanced _screengrab_
+
+<details>
+<summary>Launch Arguments</summary>
+
+You can provide additional arguments to your test cases on launch. These strings will be available in your tests through `InstrumentationRegistry.getArguments()`.
+
+```ruby
+screengrab(
+  launch_arguments: [
+    "username hjanuschka",
+    "build_number 201"
+  ]
+)
+```
+
+```java
+Bundle extras = InstrumentationRegistry.getArguments();
+String peerID = null;
+if (extras != null) {
+  if (extras.containsKey("username")) {
+    username = extras.getString("username");
+    System.out.println("Username: " + username);
+  } else {
+    System.out.println("No username in extras");
+  }
+} else {
+  System.out.println("No extras");
+}
+```
+</details>
+
+<details>
+<summary>Detecting screengrab at runtime</summary>
+
+For some apps, it is helpful to know when _screengrab_ is running so that you can display specific data for your screenshots. For iOS fastlane users, this is much like "FASTLANE_SNAPSHOT". In order to do this, you'll need to have at least two product flavors of your app.
+
+Add two product flavors to the app-level build.gradle file:
+```
+android {
+...
+    flavorDimensions "mode"
+    productFlavors {
+        screengrab {
+            dimension "mode"
+        }
+        regular {
+            dimension "mode"
+        }
+    }
+...
+}
+```
+
+Check for the existence of that flavor (i.e screengrab) in your app code as follows in order to use mock data or customize data for screenshots:
+```
+if (BuildConfig.FLAVOR == "screengrab") {
+    System.out.println("screengrab is running!");
+}
+```
+
+When running _screengrab_, do the following to build the flavor you want as well as the test apk. Note that you use "assembleFlavor_name" where Flavor_name is the flavor name, capitalized (i.e. Screengrab).
+```
+./gradlew assembleScreengrab assembleAndroidTest
+```
+
+Run _screengrab_:
+```
+fastlane screengrab
+```
+_screengrab_ will ask you to select the debug and test apps (which you can then add to your Screengrabfile to skip this step later).
+
+The debug apk should be somewhere like this:
+
+`app/build/outputs/apk/screengrab/debug/app-screengrab-debug.apk`
+
+The test apk should be somewhere like this:
+
+`app/build/outputs/apk/androidTest/screengrab/debug/app-screengrab-debug-androidTest.apk`
+
+Sit back and enjoy your new screenshots!
+
+Note: while this could also be done by creating a new build variant (i.e. debug, release and creating a new one called screengrab), [Android only allows one build type to be tested](http://tools.android.com/tech-docs/new-build-system/user-guide#TOC-Testing) which defaults to debug. That's why we use product flavors.
+
+</details>