fastlane-plugin-cordova_screenshots 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: aafc4b9a74f7891a5a1a5d8853caa0e97b574923
+  data.tar.gz: 5edf75c164ff292c1f35e7d5031aa83a8c8bed43
+SHA512:
+  metadata.gz: d108d7faefdaa70d1e2c0eda3f9bdc20502fd050ee04f42b168e0105f889a190ebae42ecb9061f66ff00abc3a503054177c0a8f3154760db8dd85e05e9e743c7
+  data.tar.gz: c490e2e3d6861e3135da3ebea4d7ad4c139231754da8e09fca7b2ce08500123e32496907a8e0861ccebc04e4011c9eaa9461dba96f784603d656a1ae1dc6c1e7

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Jan Piotrowski <piotrowski@gmail.com>
+Copyright (c) 2017 Adrian Regan <adrian@littlevista.net>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,136 @@
+# cordova_screenshots plugin
+
+[![fastlane Plugin Badge](https://rawcdn.githack.com/fastlane/fastlane/master/fastlane/assets/plugin-badge.svg)](https://rubygems.org/gems/fastlane-plugin-cordova_screenshots)
+
+## Getting Started
+
+This project is a [_fastlane_](https://github.com/fastlane/fastlane) plugin. To get started with `fastlane-plugin-cordova_screenshots`, add it to your project by running:
+
+```bash
+fastlane add_plugin cordova_screenshots
+```
+
+## About cordova_screenshots
+
+This plugin enables you to create automated screenshots of your Cordova (or Ionic) project, both for iOS or Android, with _fastlane_ using the normal [`capture_ios_screenshots`](https://docs.fastlane.tools/actions/capture_ios_screenshots/) and [`capture_android_screenshots`](https://docs.fastlane.tools/actions/capture_android_screenshots/) actions or [`fastlane snapshot`](https://docs.fastlane.tools/actions/snapshot/) (iOS) or [`fastlane screengrab`](https://docs.fastlane.tools/actions/screengrab/) (Android) commands.
+
+This usually is a challenge, as both require you to modify your native projects and add some files. As Cordova projects are generated for you and not tracked by version control, those changes (including the test files your wrote) would get lost frequently.
+
+By keeping your test files in your `fastlane` folder and offering an action to "retrofit" them to your native projects each time before running the screenshot creation actions, this plugin offers a way around that.
+
+## Actions
+
+- [`init_cordova_screenshots_ios`](#init_cordova_screenshots_ios)
+- [`retrofit_cordova_screenshots_ios`](#retrofit_cordova_screenshots_ios)
+- [`init_cordova_screenshots_android`](#init_cordova_screenshots_android)
+- [`retrofit_cordova_screenshots_android`](#retrofit_cordova_screenshots_android)
+
+### iOS
+
+#### `init_cordova_screenshots_ios`
+
+This action creates a sample iOS UI Test file in `fastlane/cordova_screenshots/ios`. It takes an optional `scheme_name` parameter, that defines the scheme name that will be used when retrofitting the test file into your Xcode project later.
+
+You can run it either manually with `fastlane run init_cordova_screenshots_ios scheme_name:"another_scheme_name"` (which will create the folder `fastlane/cordova_screenshots/ios/another_scheme_name`) or a lane in your `Fastfile`.
+
+#### `retrofit_cordova_screenshots_ios`
+
+After iOS the test files are created, you can [edit them and write some tests to take screenshots](WRITING_TESTS.md).
+
+Then you retrofit the tests into your Xcode project using this action: It scans the `fastlane/cordova_screenshots/ios` folder for sub folders and retrofits each into the Cordova iOS Xcode project by linking them absolutely. (It then creates a UI Test Target and Scheme based on the name of the subfolder. The files are not copied over to the project, so the Xcode project refers to the files in your `fastlane` folder.)
+
+The action has multiple options:
+
+- `team_id` is automatically set if it is specified in your fastlane `Appfile`.
+- `bundle_id` is set automatically if the `package_name` parameter is set in your fastlane `Appfile`.
+- `ios_xcode_path` specifies which Xcode project to use. By default it attempts to pick the Xcode project from the `platforms/ios` folder.
+- `min_target_ios` defines the minimum iOS version
+
+All these parameters can be overridden by specifying them in the call to the action.
+
+This action should be executed each time before you use [`capture_ios_screenshots` action](https://docs.fastlane.tools/actions/capture_ios_screenshots/) (or command [`fastlane snapshot`](https://docs.fastlane.tools/actions/snapshot/) on the command line) to create screenshots as it makes sure the test files are linked into the current project.
+
+### Android
+
+#### `init_cordova_screenshots_android`
+
+Copy over test file to `fastlane/cordova_screenshots/android` to be edited by the user.
+
+This action creates a sample Android Test file and saves it to `fastlane/cordova_screenshots/android`. It needs a `package_name` parameter (for use in the created test file), that is read from your `Appfile` if set.
+
+You can run it either manually with `fastlane run init_cordova_screenshots_android` or a lane in your `Fastfile`.
+
+#### `retrofit_cordova_screenshots_android`
+
+After the Android test files are created, you can [edit them and write some tests to take screenshots](WRITING_TESTS.md).
+
+Then you retrofit the tests into your Android Studio project using this action.
+
+**Note:** Right now, this action actually copies (!) the test file from its location into your Android project. A later version of this plugin will also link the Android test files into the project as it does for the iOS tests.
+
+This action should be executed each time before you use [`capture_android_screenshots` action](https://docs.fastlane.tools/actions/capture_android_screenshots/) (or command [`fastlane screengrab`](https://docs.fastlane.tools/actions/screengrab/) on the command line) to create screenshots as it makes sure the test files are <!-- linked into --> present in the current project.
+
+Note that you also have to build the test and debug APK manually before taking screenshots:
+
+```shell
+gradlew assembleDebug assembleAndroidTest
+```
+
+Or in your screenshot lane:
+
+```ruby
+    gradle(
+      task: 'assemble',
+      build_type: 'Debug',
+      project_dir: 'platforms/android'
+    )
+    gradle(
+      task: 'assemble',
+      build_type: 'AndroidTest',
+      project_dir: 'platforms/android'
+    )
+```
+
+The action has no parameters.
+
+## Example
+
+Check out the [example `Fastfile`](fastlane/Fastfile) to see how to use this plugin.
+
+## Why it works the way it does
+
+Why do these actions not just copy over a test template to the native project before each run of the screenshots actions? Because then the user couldn't use the Xcode and Android Studio built in test recorders or editors to improve the tests. The tests would be saved only in `platforms` and overwritten or thrown away with the next platform regeneration. By linking the tests files from the `fastlane` folder, this can not happen.
+
+## Acknowledgement
+
+The iOS part of this plugin is fully based on knocknarea's excellent [`fastlane-plugin-ionic_integration`](https://github.com/knocknarea/fastlane-plugin-ionic_integration). I forked and simplified his existing plugin and added the Android implementation.
+
+## Run tests for this plugin
+
+To run both the tests, and code style validation, run
+
+```shell
+rake
+```
+
+To automatically fix many of the styling issues, use
+
+```shell
+rubocop -a
+```
+
+## Issues and Feedback
+
+For any other issues and feedback about this plugin, please submit it to this repository.
+
+## Troubleshooting
+
+If you have trouble using plugins, check out the [Plugins Troubleshooting](https://docs.fastlane.tools/plugins/plugins-troubleshooting/) guide.
+
+## Using _fastlane_ Plugins
+
+For more information about how the `fastlane` plugin system works, check out the [Plugins documentation](https://docs.fastlane.tools/plugins/create-plugin/).
+
+## About _fastlane_
+
+_fastlane_ is the easiest way to automate beta deployments and releases for your iOS and Android apps. To learn more, check out [fastlane.tools](https://fastlane.tools).

data/lib/fastlane/plugin/cordova_screenshots.rb

@@ -0,0 +1,17 @@
+require 'fastlane/plugin/cordova_screenshots/version'
+require 'fastlane/plugin/cordova_screenshots/constants'
+
+module Fastlane
+  module CordovaScreenshots
+    # Return all .rb files inside the "actions" and "helper" directory
+    def self.all_classes
+      Dir[File.expand_path('**/{actions,helper}/*.rb', File.dirname(__FILE__))]
+    end
+  end
+end
+
+# By default we want to import all available actions and helpers
+# A plugin can contain any number of actions and plugins
+Fastlane::CordovaScreenshots.all_classes.each do |current|
+  require current
+end

data/lib/fastlane/plugin/cordova_screenshots/actions/init_cordova_screenshots_android_action.rb

@@ -0,0 +1,51 @@
+require 'fastlane/plugin/cordova_screenshots/constants'
+
+module Fastlane
+  module Actions
+    class InitCordovaScreenshotsAndroidAction < Action
+      def self.run(params)
+        package_name = params[:package_name]
+
+        UI.message("Creating new Android UI test in '#{CordovaScreenshots::CORDOVA_SCREENSHOTS_ANDROID_CONFIG_PATH}'")
+        Fastlane::Helper::CordovaScreenshotsHelper.copy_android_sample_test(package_name)
+
+        UI.success("Done. Call the `retrofit_cordova_screenshots_android` action to integrate it into your Cordova Android project.")
+      end
+
+      def self.description
+        "Creates an Android UI test in '#{CordovaScreenshots::CORDOVA_SCREENSHOTS_ANDROID_CONFIG_PATH}'"
+      end
+
+      def self.authors
+        ['Jan Piotrowski']
+      end
+
+      def self.return_value
+        # If your method provides a return value, you can describe here what it does
+      end
+
+      def self.details
+        # Optional:
+        ''
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :package_name,
+              env_name: 'CORDOVA_SCREENSHOTS_PACKAGE_NAME',
+              description: "The package name of the app under test (e.g. com.yourcompany.yourapp)",
+              default_value: CredentialsManager::AppfileConfig.try_fetch_value(:package_name),
+              optional: false)
+        ]
+      end
+
+      def self.is_supported?(platform)
+        # Adjust this if your plugin only works for a particular platform (iOS vs. Android, for example)
+        # See: https://github.com/fastlane/fastlane/blob/master/fastlane/docs/Platforms.md
+        #
+        # [:ios, :mac, :android].include?(platform)
+        [:android].include?(platform)
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/cordova_screenshots/actions/init_cordova_screenshots_ios_action.rb

@@ -0,0 +1,52 @@
+require 'xcodeproj'
+require 'fastlane/plugin/cordova_screenshots/constants'
+
+module Fastlane
+  module Actions
+    class InitCordovaScreenshotsIosAction < Action
+      def self.run(params)
+        scheme_name = params[:scheme_name]
+
+        UI.message("Creating new iOS UI Unit Test (with scheme '#{scheme_name}') in '#{CordovaScreenshots::CORDOVA_SCREENSHOTS_IOS_CONFIG_PATH}'")
+        Fastlane::Helper::CordovaScreenshotsHelper.copy_ios_sample_tests(scheme_name)
+
+        UI.success("Done. Call the `retrofit_cordova_screenshots_ios` action to integrate it into your Cordova iOS Xcode project.")
+      end
+
+      def self.description
+        "Creates an iOS UI Unit Tests in '#{CordovaScreenshots::CORDOVA_SCREENSHOTS_IOS_CONFIG_PATH}'"
+      end
+
+      def self.authors
+        ['Adrian Regan', 'Jan Piotrowski']
+      end
+
+      def self.return_value
+        # If your method provides a return value, you can describe here what it does
+      end
+
+      def self.details
+        # Optional:
+        ""
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :scheme_name,
+                                       env_name: 'CORDOVA_SCREENSHOTS_IOS_TEST_SCHEME',
+                                       description: 'Scheme Name of the UI Unit Tests',
+                                       default_value: CordovaScreenshots::CORDOVA_SCREENSHOTS_DEFAULT_IOS_UNIT_TEST_NAME,
+                                       optional: false)
+        ]
+      end
+
+      def self.is_supported?(platform)
+        # Adjust this if your plugin only works for a particular platform (iOS vs. Android, for example)
+        # See: https://github.com/fastlane/fastlane/blob/master/fastlane/docs/Platforms.md
+        #
+        # [:ios, :mac, :android].include?(platform)
+        [:ios].include?(platform)
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/cordova_screenshots/actions/retrofit_cordova_screenshots_android_action.rb

@@ -0,0 +1,50 @@
+require 'xcodeproj'
+
+module Fastlane
+  module Actions
+    class RetrofitCordovaScreenshotsAndroidAction < Action
+      def self.run(params)
+        UI.message("Retrofitting Android UI test from '#{CordovaScreenshots::CORDOVA_SCREENSHOTS_ANDROID_CONFIG_PATH}' into Cordova Android project.")
+
+        package_name = Fastlane::Helper::CordovaScreenshotsHelper.read_package_name_from_android_test
+        package_name_path = package_name.gsub('.', '/')
+
+        Fastlane::Helper::CordovaScreenshotsHelper.copy_android_test(package_name_path)
+        Fastlane::Helper::CordovaScreenshotsHelper.copy_android_build_extras_gradle
+        Fastlane::Helper::CordovaScreenshotsHelper.copy_android_manifest(package_name)
+
+        UI.success("Done. Build your test app (TODO) and then run `fastlane screengrab` to take screenshots.")
+      end
+
+      def self.description
+        'Retrofit test into Android project'
+      end
+
+      def self.authors
+        ['Jan Piotrowski']
+      end
+
+      def self.return_value
+        # If your method provides a return value, you can describe here what it does
+      end
+
+      def self.details
+        # Optional:
+        ''
+      end
+
+      def self.available_options
+        [
+        ]
+      end
+
+      def self.is_supported?(platform)
+        # Adjust this if your plugin only works for a particular platform (iOS vs. Android, for example)
+        # See: https://github.com/fastlane/fastlane/blob/master/fastlane/docs/Platforms.md
+        #
+        # [:ios, :mac, :android].include?(platform)
+        [:android].include?(platform)
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/cordova_screenshots/actions/retrofit_cordova_screenshots_ios_action.rb

@@ -0,0 +1,275 @@
+require 'xcodeproj'
+
+module Fastlane
+  module Actions
+    class RetrofitCordovaScreenshotsIosAction < Action
+      def self.run(params)
+        UI.message("Retrofitting iOS UI test from '#{CordovaScreenshots::CORDOVA_SCREENSHOTS_IOS_CONFIG_PATH}' into Cordova iOS Xcode project.")
+
+        (!params.nil? && !params[:ios_xcode_path].nil?) || UI.user_error!("Mandatory parameter :ios_xcode_path not specified")
+
+        #
+        # Params
+        #
+        xcode_project_path = params[:ios_xcode_path]
+        team_id = params[:team_id]
+        bundle_id = params[:bundle_id]
+        target_os = params[:min_target_ios]
+
+        File.exist?(xcode_project_path) || UI.user_error!("Xcode project '#{xcode_project_path}' does not exist!")
+
+        #
+        # Find all preconfigured UI Unit Tests
+        #
+        schemes = Dir.glob("#{CordovaScreenshots::CORDOVA_SCREENSHOTS_IOS_CONFIG_PATH}/*/").reject do |d|
+          d =~ /^\.{1,2}$/ # excludes . and ..
+        end
+        UI.message("Found schemes: #{schemes}")
+
+        # TODO: Error message if no schemes were found, refer to `init_cordova_screenshots_ios`
+
+        #
+        # Process each scheme
+        #
+        schemes.each do |scheme_path|
+          UI.message("Processing scheme: #{scheme_path}...")
+          generate_xcode_unit_test(scheme_path, xcode_project_path, team_id, bundle_id, target_os)
+        end
+
+        UI.success("Done. You can now run `fastlane snapshot` to take screenshots.")
+      end
+
+      def self.generate_xcode_unit_test(config_folder, xcode_project_path, team_id, bundle_id, target_os)
+        #
+        # Names and Folders
+        #
+        scheme_name = File.basename(config_folder)
+        xcode_folder = File.dirname(xcode_project_path)
+        project_name = File.basename(xcode_project_path, ".xcodeproj")
+
+        UI.message("Setting up '#{scheme_name}' as UI Unit Test folder and Scheme in '#{xcode_folder}' for Xcode project '#{project_name}'")
+
+        #
+        # Xcode Project
+        #
+        proj = Xcodeproj::Project.open(xcode_project_path) || UI.user_error!("Unable to open Xcode project '#{xcode_project_path}'")
+
+        UI.message("Xcode project is version '#{proj.root_object.compatibility_version}' compatible")
+
+        #
+        # Clean Xcode project
+        #
+        proj = clean_xcode_project(proj, scheme_name)
+
+        #
+        # Add new Unit Tests to Xcode projects
+        #
+        proj = add_unit_tests_to_xcode_project(proj, scheme_name, config_folder, project_name, target_os, team_id, bundle_id, xcode_project_path)
+
+        #
+        # Success
+        #
+        UI.success("Completed retrofit of '#{scheme_name}' into generated Xcode Project '#{project_name}'.")
+      end
+
+      def self.clean_xcode_project(proj, scheme_name)
+        #
+        # Find existing Target
+        #
+        target = nil
+        proj.targets.each do |t|
+          next unless t.name == scheme_name
+          UI.important("Found existing Target '#{t.name}' and removed it.")
+          target = t
+          break
+        end
+
+        #
+        # Find existing code group
+        #
+        test_group = nil
+        proj.groups.each do |g|
+          next unless g.name == scheme_name
+          g.clear
+          test_group = g
+          UI.important("Found existing Code Group '#{g.name}' and removed it.")
+          break
+        end
+
+        #
+        # Remove existing target and group
+        #
+        target.nil? || target.remove_from_project
+        test_group.nil? || test_group.remove_from_project
+
+        #
+        # Find existing products groups and remove
+        #
+        product_ref_name = scheme_name + '.xctest'
+        proj.products_group.files.each do |product_ref|
+          if product_ref.path == product_ref_name
+            UI.important("Found existing Product Group '#{product_ref.path}' and removed it.")
+            product_ref.remove_from_project
+          end
+        end
+
+        proj
+      end
+
+      def self.add_unit_tests_to_xcode_project(proj, scheme_name, config_folder, project_name, target_os, team_id, bundle_id, xcode_project_path)
+        #
+        # Create new test group
+        #
+        UI.message("Creating UI Test Group '#{scheme_name}' for snapshots testing")
+        test_group = proj.new_group(scheme_name.to_s, File.absolute_path(config_folder), '<absolute>')
+
+        #
+        # Find main target
+        #
+        UI.message("Finding Main Target (of the project)...")
+        main_target = nil
+        proj.root_object.targets.each do |t|
+          if t.name == project_name
+            UI.message("Found main target as '#{t.name}'")
+            main_target = t
+          end
+        end
+
+        main_target || UI.user_error!("Unable to locate Main Target for app in '#{project_name}'")
+
+        #
+        # Create new target
+        #
+        target = proj.new_target(:ui_test_bundle, scheme_name, :ios, target_os, proj.products_group, :swift)
+
+        #
+        # "Create" product and put into target
+        #
+        product_ref_name = scheme_name + '.xctest'
+        product_ref = proj.products_group.find_file_by_path(product_ref_name)
+        target.product_reference = product_ref
+
+        #
+        # Add main_target as dependency of target
+        #
+        UI.message("Adding Main Target Dependency to new Target: '#{main_target}'")
+        target.add_dependency(main_target)
+
+        # We need to save here for some reason... xcodeproj!?
+        proj.save
+
+        #
+        # Add files (fastlane configured UI Unit Tests) into target (via test group)
+        #
+        UI.message("Adding Pre-Configured UI Unit Tests (*.plist and *.swift) to Test Group '#{scheme_name}'...")
+
+        files = []
+        Dir["#{config_folder}*.plist", "#{config_folder}*.swift"].each do |file| # config_folder ends with / already
+          UI.message("Adding UI Test Source '#{file}'")
+          files << test_group.new_reference(File.absolute_path(file), '<absolute>')
+        end
+        # TODO: Manually add `fastlane/SnapshotHelper.swift` (or actual location)
+        target.add_file_references(files)
+
+        #
+        # Configure project and target metadata
+        #
+        UI.message("Configuring Project Metadata")
+
+        target_config = {
+          CreatedOnToolsVersion: "8.2",
+          DevelopmentTeam: team_id,
+          ProvisioningStyle: "Automatic",
+          TestTargetID: main_target.uuid
+        }
+        if proj.root_object.attributes['TargetAttributes']
+          proj.root_object.attributes['TargetAttributes'].store(target.uuid, target_config)
+        elsif
+          proj.root_object.attributes.store('TargetAttributes', { target.uuid => target_config })
+        end
+
+        target.build_configuration_list.set_setting('INFOPLIST_FILE', File.absolute_path("#{config_folder}/Info.plist"))
+        target.build_configuration_list.set_setting('SWIFT_VERSION', '3.0')
+        target.build_configuration_list.set_setting('PRODUCT_NAME', "$(TARGET_NAME)")
+        target.build_configuration_list.set_setting('TEST_TARGET_NAME', project_name)
+        target.build_configuration_list.set_setting('PRODUCT_BUNDLE_IDENTIFIER', "#{bundle_id}.#{scheme_name}")
+        target.build_configuration_list.set_setting('CODE_SIGN_IDENTITY[sdk=iphoneos*]', "iPhone Developer")
+        target.build_configuration_list.set_setting('LD_RUNPATH_SEARCH_PATHS', "$(inherited) @executable_path/Frameworks @loader_path/Frameworks")
+        target.build_configuration_list.set_setting('DEVELOPMENT_TEAM', team_id)
+
+        #
+        # Create a shared scheme for the UI tests
+        #
+        UI.message("Generating Xcode Scheme '#{scheme_name}' to run UI Snapshot Tests")
+        existing_scheme = Xcodeproj::XCScheme.shared_data_dir(xcode_project_path) + "/#{scheme_name}.xcscheme"
+        scheme = File.exist?(existing_scheme) ? Xcodeproj::XCScheme.new(existing_scheme) : Xcodeproj::XCScheme.new
+
+        #
+        # Add target and main target to scheme
+        #
+        scheme.add_test_target(target)
+        scheme.add_build_target(main_target)
+        scheme.set_launch_target(main_target)
+
+        #
+        # Save scheme and project
+        #
+        scheme.save_as(xcode_project_path, scheme_name)
+        proj.save
+
+        proj
+      end
+
+      def self.description
+        'Retrofit test into iOS Xcode project'
+      end
+
+      def self.authors
+        ['Adrian Regan', 'Jan Piotrowski']
+      end
+
+      def self.return_value
+        # If your method provides a return value, you can describe here what it does
+      end
+
+      def self.details
+        # Optional:
+        ''
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :ios_xcode_path,
+                                       env_name: 'CORDOVA_SCREENSHOTS_IOS_XCODE_PATH',
+                                       description: 'Path to Xcode project generated by Cordova/Ionic',
+                                       default_value: Fastlane::Helper::CordovaScreenshotsHelper.find_default_ios_xcode_workspace,
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :min_target_ios,
+                                       env_name: 'CORDOVA_SCREENSHOTS_MIN_TARGET_IOS',
+                                       description: 'Minimal iOS Version to target',
+                                       default_value: CordovaScreenshots::CORDOVA_SCREENSHOTS_DEFAULT_IOS_VERSION,
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :team_id,
+                                       env_name: 'CORDOVA_SCREENSHOTS_TEAM_ID',
+                                       description: 'Team ID in iTunes Connect or Apple Developer',
+                                       default_value: CredentialsManager::AppfileConfig.try_fetch_value(:team_id),
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :bundle_id, # TODO?
+                                       env_name: 'CORDOVA_SCREENSHOTS_BUNDLE_ID',
+                                       description: 'The Bundle ID of the iOS App, eg: ie.littlevista.whateverapp',
+                                       default_value: CredentialsManager::AppfileConfig.try_fetch_value(:package_name),
+                                       optional: false)
+
+        ]
+      end
+
+      def self.is_supported?(platform)
+        # Adjust this if your plugin only works for a particular platform (iOS vs. Android, for example)
+        # See: https://github.com/fastlane/fastlane/blob/master/fastlane/docs/Platforms.md
+        #
+        # [:ios, :mac, :android].include?(platform)
+        [:ios].include?(platform)
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/cordova_screenshots/constants.rb

@@ -0,0 +1,11 @@
+module Fastlane
+  module CordovaScreenshots
+    CORDOVA_SCREENSHOTS_CONFIG_PATH = "fastlane/cordova_screenshots"
+    CORDOVA_SCREENSHOTS_IOS_CONFIG_PATH = CORDOVA_SCREENSHOTS_CONFIG_PATH + "/ios"
+    CORDOVA_SCREENSHOTS_ANDROID_CONFIG_PATH = CORDOVA_SCREENSHOTS_CONFIG_PATH + "/android"
+
+    CORDOVA_SCREENSHOTS_IOS_BUILD_PATH = "platforms/ios"
+    CORDOVA_SCREENSHOTS_DEFAULT_IOS_VERSION = "9.0"
+    CORDOVA_SCREENSHOTS_DEFAULT_IOS_UNIT_TEST_NAME = "ui-snapshots" # TODO: scheme_name vs. test_name
+  end
+end

data/lib/fastlane/plugin/cordova_screenshots/helper/cordova_screenshots_helper.rb

@@ -0,0 +1,85 @@
+require 'fastlane/plugin/cordova_screenshots/constants'
+
+module Fastlane
+  module Helper
+    class CordovaScreenshotsHelper
+      HELPER_PATH = File.expand_path(File.dirname(__FILE__))
+
+      def self.copy_all_files(src_folder, project_folder)
+        if src_folder && Dir.exist?(src_folder)
+          dest_folder = project_folder.to_s
+          UI.message("Copying all files from '#{src_folder}' to '#{dest_folder}'")
+          Dir.exist?(dest_folder) || FileUtils.mkdir_p(dest_folder)
+          FileUtils.cp_r(src_folder + "/.", dest_folder)
+        elsif
+          UI.user_error!("Copying files: '#{src_folder}' does not exist.")
+        end
+      end
+
+      def self.copy_ios_sample_tests(scheme_name)
+        ios_resources_path = File.expand_path("#{HELPER_PATH}/../resources/ios")
+        source_folder = "#{ios_resources_path}/#{CordovaScreenshots::CORDOVA_SCREENSHOTS_DEFAULT_IOS_UNIT_TEST_NAME}"
+        dest_folder = "#{CordovaScreenshots::CORDOVA_SCREENSHOTS_IOS_CONFIG_PATH}/#{scheme_name}"
+        # TODO: Don't overwrite existing files
+        copy_all_files(source_folder, dest_folder)
+      end
+
+      #
+      # Find any existing Xcode Workspace generated by Cordova/Ionic
+      #
+      def self.find_default_ios_xcode_workspace
+        Dir["#{CordovaScreenshots::CORDOVA_SCREENSHOTS_IOS_BUILD_PATH}/*.xcodeproj"].last || nil
+      end
+
+      def self.copy_android_sample_test(package_name)
+        android_resources_path = File.expand_path("#{HELPER_PATH}/../resources/android")
+        Dir.exist?(CordovaScreenshots::CORDOVA_SCREENSHOTS_ANDROID_CONFIG_PATH) || FileUtils.mkdir_p(CordovaScreenshots::CORDOVA_SCREENSHOTS_ANDROID_CONFIG_PATH)
+        # TODO: Don't overwrite existing files!
+        filename = "ScreengrabTest.java"
+        FileUtils.cp("#{android_resources_path}/#{filename}", CordovaScreenshots::CORDOVA_SCREENSHOTS_ANDROID_CONFIG_PATH.to_s)
+        replace_package_name("#{CordovaScreenshots::CORDOVA_SCREENSHOTS_ANDROID_CONFIG_PATH}/#{filename}", package_name)
+      end
+
+      # Read package name from test file
+      def self.read_package_name_from_android_test()
+        text = File.read("#{CordovaScreenshots::CORDOVA_SCREENSHOTS_ANDROID_CONFIG_PATH}/ScreengrabTest.java")
+        # TODO: Error message if file is missing
+        match = text.match(/package (.*)?;/)
+        match[1]
+        # TODO: Error message if package name can not be read
+      end
+
+      # copy over test file to `platforms\android\app\src\androidTest\java\...\ScreengrabTest.java` (... = io\ionic\starter)
+      def self.copy_android_test(package_name_path)
+        test_path = "platforms/android/app/src/androidTest/java/#{package_name_path}"
+        Dir.exist?(test_path) || FileUtils.mkdir_p(test_path)
+        # TODO: Handle missing ScreengrabTest.java file and suggest using other action
+        FileUtils.cp("#{CordovaScreenshots::CORDOVA_SCREENSHOTS_ANDROID_CONFIG_PATH}/ScreengrabTest.java", test_path)
+      end
+
+      # copy over build-extras.gradle to `platforms\android\app`
+      def self.copy_android_build_extras_gradle
+        android_resources_path = File.expand_path("#{HELPER_PATH}/../resources/android")
+        FileUtils.cp("#{android_resources_path}/build-extras.gradle", "platforms/android/app")
+      end
+
+      # copy over AndroidManifest.xml to `platforms\android\app\src\debug`
+      def self.copy_android_manifest(package_name)
+        android_resources_path = File.expand_path("#{HELPER_PATH}/../resources/android")
+        dest_path = "platforms/android/app/src/debug"
+        filename = "AndroidManifest.xml"
+        Dir.exist?(dest_path) || FileUtils.mkdir_p(dest_path)
+        FileUtils.cp("#{android_resources_path}/#{filename}", dest_path)
+        replace_package_name("#{dest_path}/#{filename}", package_name)
+      end
+
+      def self.replace_package_name(file, package_name)
+        data = File.read(file)
+        filtered_data = data.gsub("tools.fastlane.plugin.cordova_screenshots", package_name)
+        File.open(file, "w") do |f|
+          f.write(filtered_data)
+        end
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/cordova_screenshots/resources/android/AndroidManifest.xml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+  package="tools.fastlane.plugin.cordova_screenshots"
+  xmlns:tools="http://schemas.android.com/tools">
+
+  <uses-permission android:name="android.permission.WAKE_LOCK" />
+  <uses-permission android:name="android.permission.DISABLE_KEYGUARD" />
+  <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
+  <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
+  <uses-permission android:name="android.permission.CHANGE_CONFIGURATION" />
+
+</manifest>

data/lib/fastlane/plugin/cordova_screenshots/resources/android/ScreengrabTest.java

@@ -0,0 +1,92 @@
+package tools.fastlane.plugin.cordova_screenshots;
+
+
+import android.support.test.espresso.ViewInteraction;
+import android.support.test.rule.ActivityTestRule;
+import android.support.test.runner.AndroidJUnit4;
+import android.test.suitebuilder.annotation.LargeTest;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.ViewParent;
+
+import org.hamcrest.Description;
+import org.hamcrest.Matcher;
+import org.hamcrest.TypeSafeMatcher;
+import org.hamcrest.core.IsInstanceOf;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.BeforeClass;
+import org.junit.ClassRule;
+
+import static android.support.test.espresso.Espresso.onView;
+import static android.support.test.espresso.assertion.ViewAssertions.matches;
+import static android.support.test.espresso.matcher.ViewMatchers.isDisplayed;
+import static android.support.test.espresso.matcher.ViewMatchers.withId;
+import static org.hamcrest.Matchers.allOf;
+
+import tools.fastlane.screengrab.Screengrab;
+import tools.fastlane.screengrab.UiAutomatorScreenshotStrategy;
+import tools.fastlane.screengrab.locale.LocaleTestRule;
+
+@LargeTest
+@RunWith(AndroidJUnit4.class)
+public class ScreengrabTest {
+  @ClassRule
+  public static final LocaleTestRule localeTestRule = new LocaleTestRule();
+
+  @Rule
+  public ActivityTestRule<MainActivity> mActivityTestRule = new ActivityTestRule<>(MainActivity.class);
+
+  @BeforeClass
+  public static void beforeAll() {
+    // https://docs.fastlane.tools/getting-started/android/screenshots/#improved-screenshot-capture-with-ui-automator
+    Screengrab.setDefaultScreenshotStrategy(new UiAutomatorScreenshotStrategy());
+  }
+
+  @Test
+  public void screengrabTest() {
+    // Added a sleep statement to match the app's execution delay.
+    // The recommended way to handle such scenarios is to use Espresso idling resources:
+    // https://google.github.io/android-testing-support-library/docs/espresso/idling-resource/index.html
+    try {
+      Thread.sleep(10000);
+    } catch (InterruptedException e) {
+      e.printStackTrace();
+    }
+
+    Screengrab.screenshot("0_app-launch");
+
+    /*
+    ViewInteraction webView = onView(
+      allOf(childAtPosition(
+        allOf(withId(android.R.id.content),
+          childAtPosition(
+            IsInstanceOf.<View>instanceOf(android.widget.LinearLayout.class),
+            0)),
+        0),
+        isDisplayed()));
+    webView.check(matches(isDisplayed()));
+    */
+
+  }
+
+  private static Matcher<View> childAtPosition(
+    final Matcher<View> parentMatcher, final int position) {
+
+    return new TypeSafeMatcher<View>() {
+      @Override
+      public void describeTo(Description description) {
+        description.appendText("Child at position " + position + " in parent ");
+        parentMatcher.describeTo(description);
+      }
+
+      @Override
+      public boolean matchesSafely(View view) {
+        ViewParent parent = view.getParent();
+        return parent instanceof ViewGroup && parentMatcher.matches(parent)
+          && view.equals(((ViewGroup) parent).getChildAt(position));
+      }
+    };
+  }
+}

data/lib/fastlane/plugin/cordova_screenshots/resources/android/build-extras.gradle

@@ -0,0 +1,13 @@
+android {
+    defaultConfig {
+      testInstrumentationRunner 'android.support.test.runner.AndroidJUnitRunner'
+    }
+}
+
+dependencies {
+    androidTestCompile 'com.android.support.test.espresso:espresso-core:2.2.2', {
+        exclude group: 'com.android.support', module: 'support-annotations'
+    }
+
+    androidTestCompile 'tools.fastlane:screengrab:1.0.0'
+}

data/lib/fastlane/plugin/cordova_screenshots/resources/ios/ui-snapshots/Info.plist

@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>CFBundleDevelopmentRegion</key>
+	<string>en</string>
+	<key>CFBundleExecutable</key>
+	<string>$(EXECUTABLE_NAME)</string>
+	<key>CFBundleIdentifier</key>
+	<string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
+	<key>CFBundleInfoDictionaryVersion</key>
+	<string>6.0</string>
+	<key>CFBundleName</key>
+	<string>$(PRODUCT_NAME)</string>
+	<key>CFBundlePackageType</key>
+	<string>BNDL</string>
+	<key>CFBundleShortVersionString</key>
+	<string>1.0</string>
+	<key>CFBundleVersion</key>
+	<string>1</string>
+</dict>
+</plist>

data/lib/fastlane/plugin/cordova_screenshots/resources/ios/ui-snapshots/SnapshotHelper.swift

@@ -0,0 +1,163 @@
+//
+//  SnapshotHelper.swift
+//  Example
+//
+//  Created by Felix Krause on 10/8/15.
+//  Copyright © 2015 Felix Krause. All rights reserved.
+//
+import Foundation
+import XCTest
+
+var deviceLanguage = ""
+var locale = ""
+
+@available(*, deprecated, message: "use setupSnapshot: instead")
+func setLanguage(_ app: XCUIApplication) {
+    setupSnapshot(app)
+}
+
+func setupSnapshot(_ app: XCUIApplication) {
+    Snapshot.setupSnapshot(app)
+}
+
+func snapshot(_ name: String, waitForLoadingIndicator: Bool = true) {
+    Snapshot.snapshot(name, waitForLoadingIndicator: waitForLoadingIndicator)
+}
+
+open class Snapshot: NSObject {
+
+    open class func setupSnapshot(_ app: XCUIApplication) {
+        setLanguage(app)
+        setLocale(app)
+        setLaunchArguments(app)
+    }
+
+    class func setLanguage(_ app: XCUIApplication) {
+        guard let prefix = pathPrefix() else {
+            return
+        }
+
+        let path = prefix.appendingPathComponent("language.txt")
+
+        do {
+            let trimCharacterSet = CharacterSet.whitespacesAndNewlines
+            deviceLanguage = try String(contentsOf: path, encoding: .utf8).trimmingCharacters(in: trimCharacterSet)
+            app.launchArguments += ["-AppleLanguages", "(\(deviceLanguage))"]
+        } catch {
+            print("Couldn't detect/set language...")
+        }
+    }
+
+    class func setLocale(_ app: XCUIApplication) {
+        guard let prefix = pathPrefix() else {
+            return
+        }
+
+        let path = prefix.appendingPathComponent("locale.txt")
+
+        do {
+            let trimCharacterSet = CharacterSet.whitespacesAndNewlines
+            locale = try String(contentsOf: path, encoding: .utf8).trimmingCharacters(in: trimCharacterSet)
+        } catch {
+            print("Couldn't detect/set locale...")
+        }
+        if locale.isEmpty {
+            locale = Locale(identifier: deviceLanguage).identifier
+        }
+        app.launchArguments += ["-AppleLocale", "\"\(locale)\""]
+    }
+
+    class func setLaunchArguments(_ app: XCUIApplication) {
+        guard let prefix = pathPrefix() else {
+            return
+        }
+
+        let path = prefix.appendingPathComponent("snapshot-launch_arguments.txt")
+        app.launchArguments += ["-FASTLANE_SNAPSHOT", "YES", "-ui_testing"]
+
+        do {
+            let launchArguments = try String(contentsOf: path, encoding: String.Encoding.utf8)
+            let regex = try NSRegularExpression(pattern: "(\\\".+?\\\"|\\S+)", options: [])
+            let matches = regex.matches(in: launchArguments, options: [], range: NSRange(location:0, length:launchArguments.characters.count))
+            let results = matches.map { result -> String in
+                (launchArguments as NSString).substring(with: result.range)
+            }
+            app.launchArguments += results
+        } catch {
+            print("Couldn't detect/set launch_arguments...")
+        }
+    }
+
+    open class func snapshot(_ name: String, waitForLoadingIndicator: Bool = true) {
+        if waitForLoadingIndicator {
+            waitForLoadingIndicatorToDisappear()
+        }
+
+        print("snapshot: \(name)") // more information about this, check out https://github.com/fastlane/fastlane/tree/master/snapshot#how-does-it-work
+        sleep(1) // Waiting for the animation to be finished (kind of)
+        #if os(tvOS)
+            XCUIApplication().childrenMatchingType(.Browser).count
+        #elseif os(OSX)
+            XCUIApplication().typeKey(XCUIKeyboardKeySecondaryFn, modifierFlags: [])
+        #else
+            XCUIDevice.shared().orientation = .unknown
+        #endif
+    }
+
+    class func waitForLoadingIndicatorToDisappear() {
+        #if os(tvOS)
+            return
+        #endif
+
+        let query = XCUIApplication().statusBars.children(matching: .other).element(boundBy: 1).children(matching: .other)
+
+        while (0..<query.count).map({ query.element(boundBy: $0) }).contains(where: { $0.isLoadingIndicator }) {
+            sleep(1)
+            print("Waiting for loading indicator to disappear...")
+        }
+    }
+
+    class func pathPrefix() -> URL? {
+        let homeDir: URL
+        //on OSX config is stored in /Users/<username>/Library
+        //and on iOS/tvOS/WatchOS it's in simulator's home dir
+        #if os(OSX)
+            guard let user = ProcessInfo().environment["USER"] else {
+                print("Couldn't find Snapshot configuration files - can't detect current user ")
+                return nil
+            }
+
+            guard let usersDir =  FileManager.default.urls(for: .userDirectory, in: .localDomainMask).first else {
+                print("Couldn't find Snapshot configuration files - can't detect `Users` dir")
+                return nil
+            }
+
+            homeDir = usersDir.appendingPathComponent(user)
+        #else
+            guard let simulatorHostHome = ProcessInfo().environment["SIMULATOR_HOST_HOME"] else {
+                print("Couldn't find simulator home location. Please, check SIMULATOR_HOST_HOME env variable.")
+                return nil
+            }
+            guard let homeDirUrl = URL(string: simulatorHostHome) else {
+                print("Can't prepare environment. Simulator home location is inaccessible. Does \(simulatorHostHome) exist?")
+                return nil
+            }
+            homeDir = homeDirUrl
+        #endif
+        return homeDir.appendingPathComponent("Library/Caches/tools.fastlane")
+    }
+}
+
+extension XCUIElement {
+    var isLoadingIndicator: Bool {
+        let whiteListedLoaders = ["GeofenceLocationTrackingOn", "StandardLocationTrackingOn"]
+        if whiteListedLoaders.contains(self.identifier) {
+            return false
+        }
+        return self.frame.size == CGSize(width: 10, height: 20)
+    }
+}
+
+// Please don't remove the lines below
+// They are used to detect outdated configuration files
+// SnapshotHelperVersion [1.3]

data/lib/fastlane/plugin/cordova_screenshots/resources/ios/ui-snapshots/ui-snapshots.swift

@@ -0,0 +1,41 @@
+//
+//  ui_snapshots.swift
+//  ui-snapshots
+//
+//  Created by Adrian Regan on 07/04/2017.
+//
+//
+
+import XCTest
+
+class ui_snapshots: XCTestCase {
+        
+    override func setUp() {
+        super.setUp()
+        
+        let app = XCUIApplication()
+               
+        setupSnapshot(app)
+
+        app.launch()
+ 
+    }
+    
+    override func tearDown() {
+        super.tearDown()
+    }
+    
+    func testSnapshots() {
+
+        //
+        // Place your own tests here. This is a starter example to get you going..
+        //
+        snapshot("app-launch")
+        
+        // XCUIApplication().buttons["Your Button Name"].tap()
+        
+        // snapshot("after-button-pressed")
+                
+    }
+    
+}

data/lib/fastlane/plugin/cordova_screenshots/version.rb

@@ -0,0 +1,5 @@
+module Fastlane
+  module CordovaScreenshots
+    VERSION = "0.2.0"
+  end
+end

metadata

@@ -0,0 +1,185 @@
+--- !ruby/object:Gem::Specification
+name: fastlane-plugin-cordova_screenshots
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Jan Piotrowski
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-08-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec_junit_formatter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.49.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.49.1
+- !ruby/object:Gem::Dependency
+  name: rubocop-require_tools
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: fastlane
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.101.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.101.1
+description: 
+email: piotrowski@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/fastlane/plugin/cordova_screenshots.rb
+- lib/fastlane/plugin/cordova_screenshots/actions/init_cordova_screenshots_android_action.rb
+- lib/fastlane/plugin/cordova_screenshots/actions/init_cordova_screenshots_ios_action.rb
+- lib/fastlane/plugin/cordova_screenshots/actions/retrofit_cordova_screenshots_android_action.rb
+- lib/fastlane/plugin/cordova_screenshots/actions/retrofit_cordova_screenshots_ios_action.rb
+- lib/fastlane/plugin/cordova_screenshots/constants.rb
+- lib/fastlane/plugin/cordova_screenshots/helper/cordova_screenshots_helper.rb
+- lib/fastlane/plugin/cordova_screenshots/resources/android/AndroidManifest.xml
+- lib/fastlane/plugin/cordova_screenshots/resources/android/ScreengrabTest.java
+- lib/fastlane/plugin/cordova_screenshots/resources/android/build-extras.gradle
+- lib/fastlane/plugin/cordova_screenshots/resources/ios/ui-snapshots/Info.plist
+- lib/fastlane/plugin/cordova_screenshots/resources/ios/ui-snapshots/SnapshotHelper.swift
+- lib/fastlane/plugin/cordova_screenshots/resources/ios/ui-snapshots/ui-snapshots.swift
+- lib/fastlane/plugin/cordova_screenshots/version.rb
+homepage: https://github.com/janpio/fastlane-plugin-cordova_screenshots
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.14.1
+signing_key: 
+specification_version: 4
+summary: Take screenshots of your Cordova/Ionic app with fastlane
+test_files: []