fastlane 2.135.0 → 2.138.0

data/fastlane/swift/Gymfile.swift

@@ -18,4 +18,4 @@ class Gymfile: GymfileProtocol {
 
 
 
-// Generated with fastlane 2.135.0
+// Generated with fastlane 2.138.0

data/fastlane/swift/Matchfile.swift

@@ -18,4 +18,4 @@ class Matchfile: MatchfileProtocol {
 
 
 
-// Generated with fastlane 2.135.0
+// Generated with fastlane 2.138.0

data/fastlane/swift/MatchfileProtocol.swift

@@ -48,6 +48,9 @@ protocol MatchfileProtocol: class {
   /// Use a basic authorization header to access the git repo (e.g.: access via HTTPS, GitHub Actions, etc), usually a string in Base64
   var gitBasicAuthorization: String? { get }
 
+  /// Use a bearer authorization header to access the git repo (e.g.: access to an Azure Devops repository), usually a string in Base64
+  var gitBearerAuthorization: String? { get }
+
   /// Name of the Google Cloud Storage bucket to use
   var googleCloudBucketName: String? { get }
 
@@ -91,7 +94,7 @@ protocol MatchfileProtocol: class {
 extension MatchfileProtocol {
   var type: String { return "development" }
   var readonly: Bool { return false }
-  var generateAppleCerts: Bool { return false }
+  var generateAppleCerts: Bool { return true }
   var skipProvisioningProfiles: Bool { return false }
   var appIdentifier: [String] { return [] }
   var username: String { return "" }
@@ -105,6 +108,7 @@ extension MatchfileProtocol {
   var shallowClone: Bool { return false }
   var cloneBranchDirectly: Bool { return false }
   var gitBasicAuthorization: String? { return nil }
+  var gitBearerAuthorization: String? { return nil }
   var googleCloudBucketName: String? { return nil }
   var googleCloudKeysFile: String? { return nil }
   var googleCloudProjectId: String? { return nil }
@@ -122,4 +126,4 @@ extension MatchfileProtocol {
 
 // Please don't remove the lines below
 // They are used to detect outdated files
-// FastlaneRunnerAPIVersion [0.9.10]
+// FastlaneRunnerAPIVersion [0.9.12]

data/fastlane/swift/Precheckfile.swift

@@ -18,4 +18,4 @@ class Precheckfile: PrecheckfileProtocol {
 
 
 
-// Generated with fastlane 2.135.0
+// Generated with fastlane 2.138.0

data/fastlane/swift/Scanfile.swift

@@ -18,4 +18,4 @@ class Scanfile: ScanfileProtocol {
 
 
 
-// Generated with fastlane 2.135.0
+// Generated with fastlane 2.138.0

data/fastlane/swift/Screengrabfile.swift

@@ -18,4 +18,4 @@ class Screengrabfile: ScreengrabfileProtocol {
 
 
 
-// Generated with fastlane 2.135.0
+// Generated with fastlane 2.138.0

data/fastlane/swift/ScreengrabfileProtocol.swift

@@ -39,6 +39,9 @@ protocol ScreengrabfileProtocol: class {
   /// Return the device to this locale after running tests
   var endingLocale: String { get }
 
+  /// Restarts the adb daemon using `adb root` to allow access to screenshots directories on device. Use if getting 'Permission denied' errors
+  var useAdbRoot: Bool { get }
+
   /// The path to the APK for the app under test
   var appApkPath: String? { get }
 
@@ -56,6 +59,12 @@ protocol ScreengrabfileProtocol: class {
 
   /// Enabling this option will automatically uninstall the application before running it
   var reinstallApp: Bool { get }
+
+  /// Add timestamp suffix to screenshot filename
+  var useTimestampSuffix: Bool { get }
+
+  /// Configure the host used by adb to connect, allows running on remote devices farm
+  var adbHost: String? { get }
 }
 
 extension ScreengrabfileProtocol {
@@ -70,16 +79,19 @@ extension ScreengrabfileProtocol {
   var useTestsInPackages: [String]? { return nil }
   var useTestsInClasses: [String]? { return nil }
   var launchArguments: [String]? { return nil }
-  var testInstrumentationRunner: String { return "android.support.test.runner.AndroidJUnitRunner" }
+  var testInstrumentationRunner: String { return "androidx.test.runner.AndroidJUnitRunner" }
   var endingLocale: String { return "en-US" }
+  var useAdbRoot: Bool { return false }
   var appApkPath: String? { return nil }
   var testsApkPath: String? { return nil }
   var specificDevice: String? { return nil }
   var deviceType: String { return "phone" }
   var exitOnTestFailure: Bool { return true }
   var reinstallApp: Bool { return false }
+  var useTimestampSuffix: Bool { return true }
+  var adbHost: String? { return nil }
 }
 
 // Please don't remove the lines below
 // They are used to detect outdated files
-// FastlaneRunnerAPIVersion [0.9.11]
+// FastlaneRunnerAPIVersion [0.9.13]

data/fastlane/swift/Snapshotfile.swift

@@ -18,4 +18,4 @@ class Snapshotfile: SnapshotfileProtocol {
 
 
 
-// Generated with fastlane 2.135.0
+// Generated with fastlane 2.138.0

data/fastlane_core/lib/fastlane_core/helper.rb

@@ -72,7 +72,7 @@ module FastlaneCore
     # @return [boolean] true if building in a known CI environment
     def self.ci?
       # Check for Jenkins, Travis CI, ... environment variables
-      ['JENKINS_HOME', 'JENKINS_URL', 'TRAVIS', 'CIRCLECI', 'CI', 'APPCENTER_BUILD_ID', 'TEAMCITY_VERSION', 'GO_PIPELINE_NAME', 'bamboo_buildKey', 'GITLAB_CI', 'XCS', 'TF_BUILD', 'GITHUB_ACTION', 'GITHUB_ACTIONS'].each do |current|
+      ['JENKINS_HOME', 'JENKINS_URL', 'TRAVIS', 'CIRCLECI', 'CI', 'APPCENTER_BUILD_ID', 'TEAMCITY_VERSION', 'GO_PIPELINE_NAME', 'bamboo_buildKey', 'GITLAB_CI', 'XCS', 'TF_BUILD', 'GITHUB_ACTION', 'GITHUB_ACTIONS', 'BITRISE_IO'].each do |current|
         return true if ENV.key?(current)
       end
       return false

data/match/lib/match/options.rb

@@ -125,6 +125,14 @@ module Match
                                      env_name: "MATCH_GIT_BASIC_AUTHORIZATION",
                                      sensitive: true,
                                      description: "Use a basic authorization header to access the git repo (e.g.: access via HTTPS, GitHub Actions, etc), usually a string in Base64",
+                                     conflicting_options: [:git_bearer_authorization],
+                                     optional: true,
+                                     default_value: nil),
+        FastlaneCore::ConfigItem.new(key: :git_bearer_authorization,
+                                     env_name: "MATCH_GIT_BEARER_AUTHORIZATION",
+                                     sensitive: true,
+                                     description: "Use a bearer authorization header to access the git repo (e.g.: access to an Azure Devops repository), usually a string in Base64",
+                                     conflicting_options: [:git_basic_authorization],
                                      optional: true,
                                      default_value: nil),
 

data/match/lib/match/runner.rb

@@ -38,6 +38,7 @@ module Match
         git_user_email: params[:git_user_email],
         clone_branch_directly: params[:clone_branch_directly],
         git_basic_authorization: params[:git_basic_authorization],
+        git_bearer_authorization: params[:git_bearer_authorization],
         type: params[:type].to_s,
         generate_apple_certs: params[:generate_apple_certs],
         platform: params[:platform].to_s,

data/match/lib/match/storage/git_storage.rb

@@ -18,6 +18,7 @@ module Match
       attr_accessor :type
       attr_accessor :platform
       attr_accessor :git_basic_authorization
+      attr_accessor :git_bearer_authorization
 
       def self.configure(params)
         return self.new(
@@ -30,7 +31,8 @@ module Match
           git_full_name: params[:git_full_name],
           git_user_email: params[:git_user_email],
           clone_branch_directly: params[:clone_branch_directly],
-          git_basic_authorization: params[:git_basic_authorization]
+          git_basic_authorization: params[:git_basic_authorization],
+          git_bearer_authorization: params[:git_bearer_authorization]
         )
       end
 
@@ -43,7 +45,8 @@ module Match
                      git_full_name: nil,
                      git_user_email: nil,
                      clone_branch_directly: false,
-                     git_basic_authorization: nil)
+                     git_basic_authorization: nil,
+                     git_bearer_authorization: nil)
         self.git_url = git_url
         self.shallow_clone = shallow_clone
         self.skip_docs = skip_docs
@@ -52,6 +55,7 @@ module Match
         self.git_user_email = git_user_email
         self.clone_branch_directly = clone_branch_directly
         self.git_basic_authorization = git_basic_authorization
+        self.git_bearer_authorization = git_bearer_authorization
 
         self.type = type if type
         self.platform = platform if platform
@@ -70,6 +74,7 @@ module Match
 
         command = "git clone #{self.git_url.shellescape} #{self.working_directory.shellescape}"
         command << " -c http.extraheader='AUTHORIZATION: basic #{self.git_basic_authorization}'" unless self.git_basic_authorization.nil?
+        command << " -c http.extraheader='AUTHORIZATION: bearer #{self.git_bearer_authorization}'" unless self.git_bearer_authorization.nil?
 
         if self.shallow_clone
           command << " --depth 1 --no-single-branch"

data/screengrab/lib/screengrab/module.rb

@@ -1,4 +1,5 @@
 require 'fastlane_core/helper'
+require 'fastlane/boolean'
 require_relative 'detect_values'
 
 module Screengrab
@@ -19,6 +20,7 @@ module Screengrab
 
   Helper = FastlaneCore::Helper # you gotta love Ruby: Helper.* should use the Helper class contained in FastlaneCore
   UI = FastlaneCore::UI
+  Boolean = Fastlane::Boolean
   ROOT = Pathname.new(File.expand_path('../../..', __FILE__))
   DESCRIPTION = "Automated localized screenshots of your Android app on every device".freeze
 end

data/screengrab/lib/screengrab/options.rb

@@ -32,7 +32,7 @@ module Screengrab
                                      env_name: 'SCREENGRAB_CLEAR_PREVIOUS_SCREENSHOTS',
                                      description: "Enabling this option will automatically clear previously generated screenshots before running screengrab",
                                      default_value: false,
-                                     is_string: false),
+                                     type: Boolean),
         FastlaneCore::ConfigItem.new(key: :output_directory,
                                      short_option: "-o",
                                      env_name: "SCREENGRAB_OUTPUT_DIRECTORY",
@@ -43,7 +43,7 @@ module Screengrab
                                      description: "Don't open the summary after running _screengrab_",
                                      default_value: DEFAULT_SKIP_OPEN_SUMMARY,
                                      default_value_dynamic: true,
-                                     is_string: false),
+                                     type: Boolean),
         FastlaneCore::ConfigItem.new(key: :app_package_name,
                                      env_name: 'SCREENGRAB_APP_PACKAGE_NAME',
                                      short_option: "-a",
@@ -68,22 +68,26 @@ module Screengrab
                                      type: Array,
                                      description: "Only run tests in these Java classes"),
         FastlaneCore::ConfigItem.new(key: :launch_arguments,
-                                      env_name: 'SCREENGRAB_LAUNCH_ARGUMENTS',
-                                      optional: true,
-                                      short_option: "-e",
-                                      type: Array,
-                                      description: "Additional launch arguments"),
+                                     env_name: 'SCREENGRAB_LAUNCH_ARGUMENTS',
+                                     optional: true,
+                                     short_option: "-e",
+                                     type: Array,
+                                     description: "Additional launch arguments"),
         FastlaneCore::ConfigItem.new(key: :test_instrumentation_runner,
                                      env_name: 'SCREENGRAB_TEST_INSTRUMENTATION_RUNNER',
                                      optional: true,
-                                     default_value: 'android.support.test.runner.AndroidJUnitRunner',
+                                     default_value: 'androidx.test.runner.AndroidJUnitRunner',
                                      description: "The fully qualified class name of your test instrumentation runner"),
         FastlaneCore::ConfigItem.new(key: :ending_locale,
                                      env_name: 'SCREENGRAB_ENDING_LOCALE',
                                      optional: true,
-                                     is_string: true,
                                      default_value: 'en-US',
                                      description: "Return the device to this locale after running tests"),
+        FastlaneCore::ConfigItem.new(key: :use_adb_root,
+                                     env_name: 'SCREENGRAB_USE_ADB_ROOT',
+                                     description: "Restarts the adb daemon using `adb root` to allow access to screenshots directories on device. Use if getting 'Permission denied' errors",
+                                     default_value: false,
+                                     type: Boolean),
         FastlaneCore::ConfigItem.new(key: :app_apk_path,
                                      env_name: 'SCREENGRAB_APP_APK_PATH',
                                      optional: true,
@@ -123,12 +127,21 @@ module Screengrab
                                      env_name: 'EXIT_ON_TEST_FAILURE',
                                      description: "Whether or not to exit Screengrab on test failure. Exiting on failure will not copy sceenshots to local machine nor open sceenshots summary",
                                      default_value: true,
-                                     is_string: false),
+                                     type: Boolean),
         FastlaneCore::ConfigItem.new(key: :reinstall_app,
                                      env_name: 'SCREENGRAB_REINSTALL_APP',
                                      description: "Enabling this option will automatically uninstall the application before running it",
                                      default_value: false,
-                                     is_string: false)
+                                     type: Boolean),
+        FastlaneCore::ConfigItem.new(key: :use_timestamp_suffix,
+                                     env_name: 'SCREENGRAB_USE_TIMESTAMP_SUFFIX',
+                                     description: "Add timestamp suffix to screenshot filename",
+                                     default_value: true,
+                                     type: Boolean),
+        FastlaneCore::ConfigItem.new(key: :adb_host,
+                                     env_name: 'SCREENGRAB_ADB_HOST',
+                                     description: "Configure the host used by adb to connect, allows running on remote devices farm",
+                                     optional: true)
       ]
     end
   end

data/screengrab/lib/screengrab/runner.rb

@@ -1,5 +1,6 @@
 require 'fastlane_core/print_table'
 require 'fastlane_core/command_executor'
+require 'fastlane/helper/adb_helper'
 require_relative 'reports_generator'
 require_relative 'module'
 
@@ -57,8 +58,13 @@ module Screengrab
 
       device_screenshots_paths = [
         determine_external_screenshots_path(device_serial),
-        determine_internal_screenshots_path
-      ]
+        determine_internal_screenshots_paths(@config[:app_package_name], @config[:locales])
+      ].flatten
+
+      # Root is needed to access device paths at /data
+      if @config[:use_adb_root]
+        run_adb_command("root", print_all: false, print_command: true)
+      end
 
       clear_device_previous_screenshots(device_serial, device_screenshots_paths)
 
@@ -67,6 +73,8 @@ module Screengrab
 
       validate_apk(app_apk_path)
 
+      enable_clean_status_bar(device_serial, app_apk_path)
+
       run_tests(device_serial, app_apk_path, tests_apk_path, test_classes_to_use, test_packages_to_use, @config[:launch_arguments])
 
       number_of_screenshots = pull_screenshots_from_device(device_serial, device_screenshots_paths, device_type_dir_name)
@@ -77,35 +85,26 @@ module Screengrab
     end
 
     def select_device
-      devices = run_adb_command("adb devices -l", print_all: true, print_command: true).split("\n")
-      # the first output by adb devices is "List of devices attached" so remove that and any adb startup output
-      devices.reject! do |device|
-        [
-          'server is out of date',    # The adb server is out of date and must be restarted
-          'unauthorized',             # The device has not yet accepted ADB control
-          'offline',                  # The device is offline, skip it
-          '* daemon',                 # Messages printed when the daemon is starting up
-          'List of devices attached', # Header of table for data we want
-          "doesn't match this client" # Message printed when there is an ADB client/server version mismatch
-        ].any? { |status| device.include?(status) }
-      end
+      adb = Fastlane::Helper::AdbHelper.new(adb_host: @config[:adb_host])
+      devices = adb.load_all_devices
 
       UI.user_error!('There are no connected and authorized devices or emulators') if devices.empty?
 
-      devices.select! { |d| d.include?(@config[:specific_device]) } if @config[:specific_device]
+      specific_device = @config[:specific_device]
+      if specific_device
+        devices.select! do |d|
+          d.serial.include?(specific_device)
+        end
+      end
 
-      UI.user_error!("No connected devices matched your criteria: #{@config[:specific_device]}") if devices.empty?
+      UI.user_error!("No connected devices matched your criteria: #{specific_device}") if devices.empty?
 
       if devices.length > 1
         UI.important("Multiple connected devices, selecting the first one")
         UI.important("To specify which connected device to use, use the -s (specific_device) config option")
       end
 
-      # grab the serial number. the lines of output can look like these:
-      # 00c22d4d84aec525       device usb:2148663295X product:bullhead model:Nexus_5X device:bullhead
-      # 192.168.1.100:5555       device usb:2148663295X product:bullhead model:Nexus_5X device:genymotion
-      # emulator-5554       device usb:2148663295X product:bullhead model:Nexus_5X device:emulator
-      devices[0].match(/^\S+/)[0]
+      devices.first.serial
     end
 
     def select_app_apk(discovered_apk_paths)
@@ -139,15 +138,19 @@ module Screengrab
       # macOS evaluates $foo in `echo $foo` before executing the command,
       # Windows doesn't - hence the double backslash vs. single backslash
       command = Helper.windows? ? "shell echo \$EXTERNAL_STORAGE " : "shell echo \\$EXTERNAL_STORAGE"
-      device_ext_storage = run_adb_command("adb -s #{device_serial} #{command}",
+      device_ext_storage = run_adb_command("-s #{device_serial} #{command}",
                                            print_all: true,
                                            print_command: true)
       device_ext_storage = device_ext_storage.strip
       File.join(device_ext_storage, @config[:app_package_name], 'screengrab')
     end
 
-    def determine_internal_screenshots_path
-      "/data/data/#{@config[:app_package_name]}/app_screengrab"
+    def determine_internal_screenshots_paths(app_package_name, locales)
+      locale_paths = locales.map do |locale|
+        "/data/user/0/#{app_package_name}/files/#{app_package_name}/screengrab/#{locale}/images/screenshots"
+      end
+
+      return ["/data/data/#{app_package_name}/app_screengrab"] + locale_paths
     end
 
     def clear_device_previous_screenshots(device_serial, device_screenshots_paths)
@@ -155,7 +158,7 @@ module Screengrab
 
       device_screenshots_paths.each do |device_path|
         if_device_path_exists(device_serial, device_path) do |path|
-          run_adb_command("adb -s #{device_serial} shell rm -rf #{path}",
+          run_adb_command("-s #{device_serial} shell rm -rf #{path}",
                           print_all: true,
                           print_command: true)
         end
@@ -182,13 +185,13 @@ module Screengrab
 
     def install_apks(device_serial, app_apk_path, tests_apk_path)
       UI.message('Installing app APK')
-      apk_install_output = run_adb_command("adb -s #{device_serial} install -t -r #{app_apk_path.shellescape}",
+      apk_install_output = run_adb_command("-s #{device_serial} install -t -r #{app_apk_path.shellescape}",
                                            print_all: true,
                                            print_command: true)
       UI.user_error!("App APK could not be installed") if apk_install_output.include?("Failure [")
 
       UI.message('Installing tests APK')
-      apk_install_output = run_adb_command("adb -s #{device_serial} install -t -r #{tests_apk_path.shellescape}",
+      apk_install_output = run_adb_command("-s #{device_serial} install -t -r #{tests_apk_path.shellescape}",
                                            print_all: true,
                                            print_command: true)
       UI.user_error!("Tests APK could not be installed") if apk_install_output.include?("Failure [")
@@ -199,14 +202,14 @@ module Screengrab
 
       if packages.include?(app_package_name.to_s)
         UI.message('Uninstalling app APK')
-        run_adb_command("adb -s #{device_serial} uninstall #{app_package_name}",
+        run_adb_command("-s #{device_serial} uninstall #{app_package_name}",
                         print_all: true,
                         print_command: true)
       end
 
       if packages.include?(tests_package_name.to_s)
         UI.message('Uninstalling tests APK')
-        run_adb_command("adb -s #{device_serial} uninstall #{tests_package_name}",
+        run_adb_command("-s #{device_serial} uninstall #{tests_package_name}",
                         print_all: true,
                         print_command: true)
       end
@@ -214,20 +217,16 @@ module Screengrab
 
     def grant_permissions(device_serial)
       UI.message('Granting the permission necessary to change locales on the device')
-      run_adb_command("adb -s #{device_serial} shell pm grant #{@config[:app_package_name]} android.permission.CHANGE_CONFIGURATION",
+      run_adb_command("-s #{device_serial} shell pm grant #{@config[:app_package_name]} android.permission.CHANGE_CONFIGURATION",
                       print_all: true,
                       print_command: true)
 
-      device_api_version = run_adb_command("adb -s #{device_serial} shell getprop ro.build.version.sdk",
-                                           print_all: true,
-                                           print_command: true).to_i
-
-      if device_api_version >= 23
+      if device_api_version(device_serial) >= 23
         UI.message('Granting the permissions necessary to access device external storage')
-        run_adb_command("adb -s #{device_serial} shell pm grant #{@config[:app_package_name]} android.permission.WRITE_EXTERNAL_STORAGE",
+        run_adb_command("-s #{device_serial} shell pm grant #{@config[:app_package_name]} android.permission.WRITE_EXTERNAL_STORAGE",
                         print_all: true,
                         print_command: true)
-        run_adb_command("adb -s #{device_serial} shell pm grant #{@config[:app_package_name]} android.permission.READ_EXTERNAL_STORAGE",
+        run_adb_command("-s #{device_serial} shell pm grant #{@config[:app_package_name]} android.permission.READ_EXTERNAL_STORAGE",
                         print_all: true,
                         print_command: true)
       end
@@ -252,9 +251,10 @@ module Screengrab
     def run_tests_for_locale(locale, device_serial, test_classes_to_use, test_packages_to_use, launch_arguments)
       UI.message("Running tests for locale: #{locale}")
 
-      instrument_command = ["adb -s #{device_serial} shell am instrument --no-window-animation -w",
+      instrument_command = ["-s #{device_serial} shell am instrument --no-window-animation -w",
                             "-e testLocale #{locale.tr('-', '_')}",
                             "-e endingLocale #{@config[:ending_locale].tr('-', '_')}"]
+      instrument_command << "-e appendTimestamp #{@config[:use_timestamp_suffix]}"
       instrument_command << "-e class #{test_classes_to_use.join(',')}" if test_classes_to_use
       instrument_command << "-e package #{test_packages_to_use.join(',')}" if test_packages_to_use
       instrument_command << launch_arguments.map { |item| '-e ' + item }.join(' ') if launch_arguments
@@ -281,10 +281,11 @@ module Screengrab
 
       # Make a temp directory into which to pull the screenshots before they are moved to their final location.
       # This makes directory cleanup easier, as the temp directory will be removed when the block completes.
+
       Dir.mktmpdir do |tempdir|
         device_screenshots_paths.each do |device_path|
           if_device_path_exists(device_serial, device_path) do |path|
-            run_adb_command("adb -s #{device_serial} pull #{path} #{tempdir}",
+            run_adb_command("-s #{device_serial} pull #{path} #{tempdir}",
                             print_all: false,
                             print_command: true)
           end
@@ -347,7 +348,7 @@ module Screengrab
     # Some device commands fail if executed against a device path that does not exist, so this helper method
     # provides a way to conditionally execute a block only if the provided path exists on the device.
     def if_device_path_exists(device_serial, device_path)
-      return if run_adb_command("adb -s #{device_serial} shell ls #{device_path}",
+      return if run_adb_command("-s #{device_serial} shell ls #{device_path}",
                                 print_all: false,
                                 print_command: false).include?('No such file')
 
@@ -359,7 +360,7 @@ module Screengrab
 
     # Return an array of packages that are installed on the device
     def installed_packages(device_serial)
-      packages = run_adb_command("adb -s #{device_serial} shell pm list packages",
+      packages = run_adb_command("-s #{device_serial} shell pm list packages",
                                  print_all: true,
                                  print_command: true)
       packages.split("\n").map { |package| package.gsub("package:", "") }
@@ -367,7 +368,9 @@ module Screengrab
 
     def run_adb_command(command, print_all: false, print_command: false)
       adb_path = @android_env.adb_path.chomp("adb")
-      output = @executor.execute(command: adb_path + command,
+      adb_host = @config[:adb_host]
+      host = adb_host.nil? ? '' : "-H #{adb_host} "
+      output = @executor.execute(command: adb_path + "adb " + host + command,
                                  print_all: print_all,
                                  print_command: print_command) || ''
       output.lines.reject do |line|
@@ -375,5 +378,39 @@ module Screengrab
         line.start_with?('adb: ')
       end.join('') # Lines retain their newline chars
     end
+
+    def device_api_version(device_serial)
+      run_adb_command("-s #{device_serial} shell getprop ro.build.version.sdk",
+                      print_all: true, print_command: true).to_i
+    end
+
+    def enable_clean_status_bar(device_serial, app_apk_path)
+      return unless device_api_version(device_serial) >= 23
+
+      unless @android_env.aapt_path
+        UI.error("The `aapt` command could not be found, so status bar could not be cleaned. Make sure android_home is configured for screengrab or ANDROID_HOME is set in the environment")
+        return
+      end
+
+      # Check if the app wants to use the clean status bar feature
+      badging_dump = @executor.execute(command: "#{@android_env.aapt_path} dump badging #{app_apk_path}",
+                                       print_all: true, print_command: true)
+      return unless badging_dump.include?('uses-feature: name=\'tools.fastlane.screengrab.cleanstatusbar\'')
+
+      UI.message('Enabling clean status bar')
+
+      # Make sure the app requests the DUMP permission
+      unless badging_dump.include?('uses-permission: name=\'android.permission.DUMP\'')
+        UI.user_error!("The clean status bar feature requires the android.permission.DUMP permission but it could not be found in your app APK")
+      end
+
+      # Grant the DUMP permission
+      run_adb_command("-s #{device_serial} shell pm grant #{@config[:app_package_name]} android.permission.DUMP",
+                      print_all: true, print_command: true)
+
+      # Enable the SystemUI demo mode
+      run_adb_command("-s #{device_serial} shell settings put global sysui_demo_allowed 1",
+                      print_all: true, print_command: true)
+    end
   end
 end