fastlane 2.186.0 → 2.187.0

data/screengrab/lib/screengrab/android_environment.rb

@@ -4,31 +4,21 @@ require 'fastlane_core/command_executor'
 module Screengrab
   class AndroidEnvironment
     attr_reader :android_home
-    attr_reader :build_tools_version
 
     # android_home        - the String path to the install location of the Android SDK
-    # build_tools_version - the String version of the Android build tools that should be used
-    def initialize(android_home, build_tools_version)
+    # build_tools_version - the String version of the Android build tools that should be used, ignored
+    def initialize(android_home, build_tools_version = nil)
       @android_home = android_home
-      @build_tools_version = build_tools_version
     end
 
     def platform_tools_path
       @platform_tools_path ||= find_platform_tools(android_home)
     end
 
-    def build_tools_path
-      @build_tools_path ||= find_build_tools(android_home, build_tools_version)
-    end
-
     def adb_path
       @adb_path ||= find_adb(platform_tools_path)
     end
 
-    def aapt_path
-      @aapt_path ||= find_aapt(build_tools_path)
-    end
-
     private
 
     def find_platform_tools(android_home)
@@ -38,38 +28,6 @@ module Screengrab
       File.directory?(platform_tools_path) ? platform_tools_path : nil
     end
 
-    def find_build_tools(android_home, build_tools_version)
-      return nil unless android_home
-
-      build_tools_dir = Helper.localize_file_path(File.join(android_home, 'build-tools'))
-
-      return nil unless build_tools_dir && File.directory?(build_tools_dir)
-
-      return Helper.localize_file_path(File.join(build_tools_dir, build_tools_version)) if build_tools_version
-
-      version = select_build_tools_version(build_tools_dir)
-
-      return version ? Helper.localize_file_path(File.join(build_tools_dir, version)) : nil
-    end
-
-    def select_build_tools_version(build_tools_dir)
-      # Collect the sub-directories of the build_tools_dir, rejecting any that start with '.' to remove . and ..
-      dir_names = Dir.entries(build_tools_dir).select { |e| !e.start_with?('.') && File.directory?(File.join(build_tools_dir, e)) }
-
-      # Collect a sorted array of Version objects from the directory names, handling the possibility that some
-      # entries may not be valid version names
-      versions = dir_names.map do |d|
-        begin
-          Gem::Version.new(d)
-        rescue
-          nil
-        end
-      end.reject(&:nil?).sort
-
-      # We'll take the last entry (highest version number) as the directory name we want
-      versions.last.to_s
-    end
-
     def find_adb(platform_tools_path)
       return FastlaneCore::CommandExecutor.which('adb') unless platform_tools_path
 
@@ -78,14 +36,6 @@ module Screengrab
       return executable_command?(adb_path) ? adb_path : nil
     end
 
-    def find_aapt(build_tools_path)
-      return FastlaneCore::CommandExecutor.which('aapt') unless build_tools_path
-
-      aapt_path = Helper.get_executable_path(File.join(build_tools_path, 'aapt'))
-      aapt_path = Helper.localize_file_path(aapt_path)
-      return executable_command?(aapt_path) ? aapt_path : nil
-    end
-
     def executable_command?(cmd_path)
       Helper.executable?(cmd_path)
     end

data/screengrab/lib/screengrab/dependency_checker.rb

@@ -6,7 +6,6 @@ module Screengrab
       return if Helper.test?
 
       check_adb(android_env)
-      check_aapt(android_env)
     end
 
     def self.check_adb(android_env)
@@ -30,25 +29,6 @@ module Screengrab
       UI.user_error!('adb command not found')
     end
 
-    def self.check_aapt(android_env)
-      android_home = android_env.android_home
-      aapt_path = android_env.aapt_path
-
-      warn_if_command_path_not_relative_to_android_home('aapt', android_home, aapt_path)
-      # aapt is not required in order to function, so we'll only warn if we can't find it.
-      warn_missing_aapt(android_home) unless aapt_path
-    end
-
-    def self.warn_missing_aapt(android_home)
-      if android_home
-        UI.important("The `aapt` command could not be found relative to your provided ANDROID_HOME at #{android_home}")
-        UI.important("Please ensure that the Android SDK is installed and you have the build tools downloaded")
-      else
-        UI.important("The `aapt` command could not be found on your PATH")
-        UI.important("Please ensure that the Android SDK is installed and you have the build tools downloaded and present on your PATH")
-      end
-    end
-
     def self.warn_if_command_path_not_relative_to_android_home(cmd_name, android_home, cmd_path)
       if android_home && cmd_path && !cmd_path.start_with?(android_home)
         UI.important("Using `#{cmd_name}` found at #{cmd_path} which is not within the specified ANDROID_HOME at #{android_home}")

data/screengrab/lib/screengrab/options.rb

@@ -22,7 +22,8 @@ module Screengrab
         FastlaneCore::ConfigItem.new(key: :build_tools_version,
                                      short_option: "-i",
                                      optional: true,
-                                     description: "The Android build tools version to use, e.g. '23.0.2'"),
+                                     description: "The Android build tools version to use, e.g. '23.0.2'",
+                                     deprecated: true),
         FastlaneCore::ConfigItem.new(key: :locales,
                                      description: "A list of locales which should be used",
                                      short_option: "-q",
@@ -82,10 +83,12 @@ module Screengrab
                                      env_name: 'SCREENGRAB_ENDING_LOCALE',
                                      optional: true,
                                      default_value: 'en-US',
-                                     description: "Return the device to this locale after running tests"),
+                                     description: "Return the device to this locale after running tests",
+                                     deprecated: true),
         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",
+                                     deprecated: true,
                                      default_value: false,
                                      type: Boolean),
         FastlaneCore::ConfigItem.new(key: :app_apk_path,

data/screengrab/lib/screengrab/runner.rb

@@ -6,12 +6,6 @@ require_relative 'module'
 
 module Screengrab
   class Runner
-    NEEDED_PERMISSIONS = [
-      'android.permission.READ_EXTERNAL_STORAGE',
-      'android.permission.WRITE_EXTERNAL_STORAGE',
-      'android.permission.CHANGE_CONFIGURATION'
-    ].freeze
-
     attr_accessor :number_of_retries
 
     def initialize(executor = FastlaneCore::CommandExecutor,
@@ -25,7 +19,6 @@ module Screengrab
 
     def run
       # Standardize the locales
-      @config[:locales].map! { |locale| locale.gsub("_", "-") }
       FastlaneCore::PrintTable.print_values(config: @config, hide_keys: [], title: "Summary for screengrab #{Fastlane::VERSION}")
 
       app_apk_path = @config.fetch(:app_apk_path, ask: false)
@@ -59,14 +52,14 @@ module Screengrab
       device_serial = select_device
 
       device_screenshots_paths = [
-        determine_external_screenshots_path(device_serial, @config[:locales]),
-        determine_internal_screenshots_paths(@config[:app_package_name], @config[:locales])
+        determine_external_screenshots_path(device_serial, @config[:app_package_name], @config[:locales]),
+        determine_internal_screenshots_paths(device_serial, @config[:app_package_name], @config[:locales])
       ].flatten
 
       # Root is needed to access device paths at /data
       if @config[:use_adb_root]
-        run_adb_command("-s #{device_serial} root", print_all: false, print_command: true)
-        run_adb_command("-s #{device_serial} wait-for-device", print_all: false, print_command: true)
+        run_adb_command("-s #{device_serial.shellescape} root", print_all: false, print_command: true)
+        run_adb_command("-s #{device_serial.shellescape} wait-for-device", print_all: false, print_command: true)
       end
 
       clear_device_previous_screenshots(@config[:app_package_name], device_serial, device_screenshots_paths)
@@ -74,9 +67,7 @@ module Screengrab
       app_apk_path ||= select_app_apk(discovered_apk_paths)
       tests_apk_path ||= select_tests_apk(discovered_apk_paths)
 
-      validate_apk(app_apk_path)
-
-      number_of_screenshots = run_tests(device_type_dir_name, device_screenshots_paths, device_serial, app_apk_path, tests_apk_path, test_classes_to_use, test_packages_to_use, @config[:launch_arguments])
+      number_of_screenshots = run_tests(device_type_dir_name, device_serial, app_apk_path, tests_apk_path, test_classes_to_use, test_packages_to_use, @config[:launch_arguments])
 
       ReportsGenerator.new.generate
 
@@ -133,72 +124,71 @@ module Screengrab
       Dir.glob(File.join(output_directory, '**', device_type, '*.png'), File::FNM_CASEFOLD)
     end
 
-    def determine_external_screenshots_path(device_serial, locales)
+    def get_device_environment_variable(device_serial, variable_name)
       # 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("-s #{device_serial} #{command}",
-                                           print_all: true,
-                                           print_command: true)
-      device_ext_storage = device_ext_storage.strip
+      command = Helper.windows? ? "shell echo \$#{variable_name.shellescape.shellescape}" : "shell echo \\$#{variable_name.shellescape.shellescape}"
+      value = run_adb_command("-s #{device_serial.shellescape} #{command}",
+                              print_all: true,
+                              print_command: true)
+      return value.strip
+    end
+
+    # Don't need to use to use run-as if external
+    def use_adb_run_as?(path, device_serial)
+      device_ext_storage = get_device_environment_variable(device_serial, "EXTERNAL_STORAGE")
+      return !path.start_with?(device_ext_storage)
+    end
+
+    def determine_external_screenshots_path(device_serial, app_package_name, locales)
+      device_ext_storage = get_device_environment_variable(device_serial, "EXTERNAL_STORAGE")
       return locales.map do |locale|
-        File.join(device_ext_storage, @config[:app_package_name], 'screengrab', locale, "images", "screenshots")
-      end.flatten
+        [
+          File.join(device_ext_storage, app_package_name, 'screengrab', locale, "images", "screenshots"),
+          File.join(device_ext_storage, "Android", "data", app_package_name, 'files', 'screengrab', locale, "images", "screenshots")
+        ]
+      end.flatten.map { |path| [path, false] }
     end
 
-    def determine_internal_screenshots_paths(app_package_name, locales)
+    def determine_internal_screenshots_paths(device_serial, app_package_name, locales)
+      device_data = get_device_environment_variable(device_serial, "ANDROID_DATA")
       return locales.map do |locale|
         [
-          "/data/user/0/#{app_package_name}/files/#{app_package_name}/screengrab/#{locale}/images/screenshots",
+          "#{device_data}/user/0/#{app_package_name}/files/#{app_package_name}/screengrab/#{locale}/images/screenshots",
 
           # https://github.com/fastlane/fastlane/issues/15653#issuecomment-578541663
-          "/data/data/#{app_package_name}/files/#{app_package_name}/screengrab/#{locale}/images/screenshots",
+          "#{device_data}/data/#{app_package_name}/files/#{app_package_name}/screengrab/#{locale}/images/screenshots",
 
-          "/data/data/#{app_package_name}/app_screengrab/#{locale}/images/screenshots",
-          "/data/data/#{app_package_name}/screengrab/#{locale}/images/screenshots"
+          "#{device_data}/data/#{app_package_name}/app_screengrab/#{locale}/images/screenshots",
+          "#{device_data}/data/#{app_package_name}/screengrab/#{locale}/images/screenshots"
         ]
-      end.flatten
+      end.flatten.map { |path| [path, true] }
     end
 
     def clear_device_previous_screenshots(app_package_name, device_serial, device_screenshots_paths)
       UI.message('Cleaning screenshots on device')
 
-      device_screenshots_paths.each do |device_path|
-        if_device_path_exists(app_package_name, device_serial, device_path) do |path|
-          run_adb_command("-s #{device_serial} shell run-as #{app_package_name} rm -rf #{path}",
+      device_screenshots_paths.each do |(device_path, needs_run_as)|
+        if_device_path_exists(app_package_name, device_serial, device_path, needs_run_as) do |path|
+          # Determine if path needs the run-as permission
+          run_as = needs_run_as ? " run-as #{app_package_name.shellescape.shellescape}" : ""
+
+          run_adb_command("-s #{device_serial.shellescape} shell#{run_as} rm -rf #{path.shellescape.shellescape}",
                           print_all: true,
                           print_command: true)
         end
       end
     end
 
-    def validate_apk(app_apk_path)
-      unless @android_env.aapt_path
-        UI.important("The `aapt` command could not be found on your system, so your app APK could not be validated")
-        return
-      end
-
-      UI.message('Validating app APK')
-      apk_permissions = @executor.execute(command: "#{@android_env.aapt_path} dump permissions #{app_apk_path}",
-                                          print_all: true,
-                                          print_command: true)
-
-      missing_permissions = NEEDED_PERMISSIONS.reject { |needed| apk_permissions.include?(needed) }
-
-      if missing_permissions.any?
-        UI.user_error!("The needed permission(s) #{missing_permissions.join(', ')} could not be found in your app APK")
-      end
-    end
-
     def install_apks(device_serial, app_apk_path, tests_apk_path)
       UI.message('Installing app APK')
-      apk_install_output = run_adb_command("-s #{device_serial} install -t -r #{app_apk_path.shellescape}",
+      apk_install_output = run_adb_command("-s #{device_serial.shellescape} 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("-s #{device_serial} install -t -r #{tests_apk_path.shellescape}",
+      apk_install_output = run_adb_command("-s #{device_serial.shellescape} 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 [")
@@ -209,14 +199,14 @@ module Screengrab
 
       if packages.include?(app_package_name.to_s)
         UI.message('Uninstalling app APK')
-        run_adb_command("-s #{device_serial} uninstall #{app_package_name}",
+        run_adb_command("-s #{device_serial.shellescape} uninstall #{app_package_name.shellescape}",
                         print_all: true,
                         print_command: true)
       end
 
       if packages.include?(tests_package_name.to_s)
         UI.message('Uninstalling tests APK')
-        run_adb_command("-s #{device_serial} uninstall #{tests_package_name}",
+        run_adb_command("-s #{device_serial.shellescape} uninstall #{tests_package_name.shellescape}",
                         print_all: true,
                         print_command: true)
       end
@@ -224,26 +214,37 @@ module Screengrab
 
     def grant_permissions(device_serial)
       UI.message('Granting the permission necessary to change locales on the device')
-      run_adb_command("-s #{device_serial} shell pm grant #{@config[:app_package_name]} android.permission.CHANGE_CONFIGURATION",
+      run_adb_command("-s #{device_serial.shellescape} shell pm grant #{@config[:app_package_name].shellescape.shellescape} android.permission.CHANGE_CONFIGURATION",
                       print_all: true,
-                      print_command: true)
+                      print_command: true,
+                      raise_errors: false)
 
-      if device_api_version(device_serial) >= 23
-        UI.message('Granting the permissions necessary to access device 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("-s #{device_serial} shell pm grant #{@config[:app_package_name]} android.permission.READ_EXTERNAL_STORAGE",
-                        print_all: true,
-                        print_command: true)
-      end
+      UI.message('Granting the permissions necessary to access device external storage')
+      run_adb_command("-s #{device_serial.shellescape} shell pm grant #{@config[:app_package_name].shellescape.shellescape} android.permission.WRITE_EXTERNAL_STORAGE",
+                      print_all: true,
+                      print_command: true,
+                      raise_errors: false)
+      run_adb_command("-s #{device_serial.shellescape} shell pm grant #{@config[:app_package_name].shellescape.shellescape} android.permission.READ_EXTERNAL_STORAGE",
+                      print_all: true,
+                      print_command: true,
+                      raise_errors: false)
+    end
+
+    def kill_app(device_serial, package_name)
+      run_adb_command("-s #{device_serial.shellescape} shell am force-stop #{package_name.shellescape.shellescape}.test",
+                      print_all: true,
+                      print_command: true)
+      run_adb_command("-s #{device_serial.shellescape} shell am force-stop #{package_name.shellescape.shellescape}",
+                      print_all: true,
+                      print_command: true)
     end
 
-    def run_tests(device_type_dir_name, device_screenshots_paths, device_serial, app_apk_path, tests_apk_path, test_classes_to_use, test_packages_to_use, launch_arguments)
+    def run_tests(device_type_dir_name, device_serial, app_apk_path, tests_apk_path, test_classes_to_use, test_packages_to_use, launch_arguments)
+      sdk_version = device_api_version(device_serial)
       unless @config[:reinstall_app]
         install_apks(device_serial, app_apk_path, tests_apk_path)
         grant_permissions(device_serial)
-        enable_clean_status_bar(device_serial, app_apk_path)
+        enable_clean_status_bar(device_serial, sdk_version)
       end
 
       number_of_screenshots = 0
@@ -253,25 +254,28 @@ module Screengrab
           uninstall_apks(device_serial, @config[:app_package_name], @config[:tests_package_name])
           install_apks(device_serial, app_apk_path, tests_apk_path)
           grant_permissions(device_serial)
-          enable_clean_status_bar(device_serial, app_apk_path)
+        else
+          kill_app(device_serial, @config[:app_package_name])
         end
-        number_of_screenshots += run_tests_for_locale(device_type_dir_name, device_screenshots_paths, locale, device_serial, test_classes_to_use, test_packages_to_use, launch_arguments)
+        number_of_screenshots += run_tests_for_locale(device_type_dir_name, locale, device_serial, test_classes_to_use, test_packages_to_use, launch_arguments, sdk_version)
       end
 
       number_of_screenshots
     end
 
-    def run_tests_for_locale(device_type_dir_name, device_screenshots_paths, locale, device_serial, test_classes_to_use, test_packages_to_use, launch_arguments)
+    def run_tests_for_locale(device_type_dir_name, locale, device_serial, test_classes_to_use, test_packages_to_use, launch_arguments, sdk_version)
       UI.message("Running tests for locale: #{locale}")
 
-      instrument_command = ["-s #{device_serial} shell am instrument --no-window-animation -w",
-                            "-e testLocale #{locale.tr('-', '_')}",
-                            "-e endingLocale #{@config[:ending_locale].tr('-', '_')}"]
+      instrument_command = ["-s #{device_serial.shellescape} shell am instrument --no-window-animation -w",
+                            "-e testLocale #{locale.shellescape.shellescape}"]
+      if sdk_version >= 28
+        instrument_command << "--no-hidden-api-checks"
+      end
       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 << "-e class #{test_classes_to_use.join(',').shellescape.shellescape}" if test_classes_to_use
+      instrument_command << "-e package #{test_packages_to_use.join(',').shellescape.shellescape}" if test_packages_to_use
       instrument_command << launch_arguments.map { |item| '-e ' + item }.join(' ') if launch_arguments
-      instrument_command << "#{@config[:tests_package_name]}/#{@config[:test_instrumentation_runner]}"
+      instrument_command << "#{@config[:tests_package_name].shellescape.shellescape}/#{@config[:test_instrumentation_runner].shellescape.shellescape}"
 
       test_output = run_adb_command(instrument_command.join(" \\\n"),
                                     print_all: true,
@@ -285,30 +289,40 @@ module Screengrab
         end
       end
 
-      pull_screenshots_from_device(locale, device_serial, device_screenshots_paths, device_type_dir_name)
+      pull_screenshots_from_device(locale, device_serial, device_type_dir_name)
     end
 
-    def pull_screenshots_from_device(locale, device_serial, device_screenshots_paths, device_type_dir_name)
+    def pull_screenshots_from_device(locale, device_serial, device_type_dir_name)
       UI.message("Pulling captured screenshots for locale #{locale} from the device")
       starting_screenshot_count = screenshot_file_names_in(@config[:output_directory], device_type_dir_name).length
 
       UI.verbose("Starting screenshot count is: #{starting_screenshot_count}")
 
+      device_screenshots_paths = [
+        determine_external_screenshots_path(device_serial, @config[:app_package_name], [locale]),
+        determine_internal_screenshots_paths(device_serial, @config[:app_package_name], [locale])
+      ].flatten
+
       # 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(@config[:app_package_name], device_serial, device_path) do |path|
+        device_screenshots_paths.each do |(device_path, needs_run_as)|
+          if_device_path_exists(@config[:app_package_name], device_serial, device_path, needs_run_as) do |path|
+            UI.message(path)
             next unless path.include?(locale)
-            out = run_adb_command("-s #{device_serial} pull #{path} #{tempdir}",
+            out = run_adb_command("-s #{device_serial.shellescape} pull #{path.shellescape} #{tempdir.shellescape}",
                                   print_all: false,
                                   print_command: true,
                                   raise_errors: false)
             if out =~ /Permission denied/
               dir = File.dirname(path)
               base = File.basename(path)
-              run_adb_command("-s #{device_serial} shell run-as #{@config[:app_package_name]} \"tar -cC #{dir} #{base}\" | tar -xv -f- -C #{tempdir}",
+
+              # Determine if path needs the run-as permission
+              run_as = needs_run_as ? " run-as #{@config[:app_package_name].shellescape.shellescape}" : ""
+
+              run_adb_command("-s #{device_serial.shellescape} shell#{run_as}  \"tar -cC #{dir} #{base}\" | tar -xv -f- -C #{tempdir}",
                               print_all: false,
                               print_command: true)
             end
@@ -372,8 +386,11 @@ 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(app_package_name, device_serial, device_path)
-      return if run_adb_command("-s #{device_serial} shell run-as #{app_package_name} ls #{device_path}",
+    def if_device_path_exists(app_package_name, device_serial, device_path, needs_run_as)
+      # Determine if path needs the run-as permission
+      run_as = needs_run_as ? " run-as #{app_package_name.shellescape.shellescape}" : ""
+
+      return if run_adb_command("-s #{device_serial.shellescape} shell#{run_as} ls #{device_path.shellescape.shellescape}",
                                 print_all: false,
                                 print_command: false).include?('No such file')
 
@@ -385,7 +402,7 @@ module Screengrab
 
     # Return an array of packages that are installed on the device
     def installed_packages(device_serial)
-      packages = run_adb_command("-s #{device_serial} shell pm list packages",
+      packages = run_adb_command("-s #{device_serial.shellescape} shell pm list packages",
                                  print_all: true,
                                  print_command: true)
       packages.split("\n").map { |package| package.gsub("package:", "") }
@@ -393,7 +410,7 @@ module Screengrab
 
     def run_adb_command(command, print_all: false, print_command: false, raise_errors: true)
       adb_host = @config[:adb_host]
-      host = adb_host.nil? ? '' : "-H #{adb_host} "
+      host = adb_host.nil? ? '' : "-H #{adb_host.shellescape} "
       output = ''
       begin
         errout = nil
@@ -414,36 +431,21 @@ module Screengrab
     end
 
     def device_api_version(device_serial)
-      run_adb_command("-s #{device_serial} shell getprop ro.build.version.sdk",
+      run_adb_command("-s #{device_serial.shellescape} 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\'')
+    def enable_clean_status_bar(device_serial, sdk_version)
+      return unless sdk_version >= 23
 
       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)
+      run_adb_command("-s #{device_serial.shellescape} shell pm grant #{@config[:app_package_name].shellescape.shellescape} android.permission.DUMP",
+                      print_all: true, print_command: true, raise_errors: false)
 
       # Enable the SystemUI demo mode
-      run_adb_command("-s #{device_serial} shell settings put global sysui_demo_allowed 1",
+      run_adb_command("-s #{device_serial.shellescape} shell settings put global sysui_demo_allowed 1",
                       print_all: true, print_command: true)
     end
   end