fastlane 2.133.0 → 2.136.0

data/fastlane/swift/Gymfile.swift

@@ -18,4 +18,4 @@ class Gymfile: GymfileProtocol {
 
 
 
-// Generated with fastlane 2.133.0
+// Generated with fastlane 2.136.0

data/fastlane/swift/Matchfile.swift

@@ -18,4 +18,4 @@ class Matchfile: MatchfileProtocol {
 
 
 
-// Generated with fastlane 2.133.0
+// Generated with fastlane 2.136.0

data/fastlane/swift/MatchfileProtocol.swift

@@ -91,7 +91,7 @@ protocol MatchfileProtocol: class {
 extension MatchfileProtocol {
   var type: String { return "development" }
   var readonly: Bool { return false }
-  var generateAppleCerts: Bool { return true }
+  var generateAppleCerts: Bool { return false }
   var skipProvisioningProfiles: Bool { return false }
   var appIdentifier: [String] { return [] }
   var username: String { return "" }
@@ -122,4 +122,4 @@ extension MatchfileProtocol {
 
 // Please don't remove the lines below
 // They are used to detect outdated files
-// FastlaneRunnerAPIVersion [0.9.9]
+// FastlaneRunnerAPIVersion [0.9.10]

data/fastlane/swift/Precheckfile.swift

@@ -18,4 +18,4 @@ class Precheckfile: PrecheckfileProtocol {
 
 
 
-// Generated with fastlane 2.133.0
+// Generated with fastlane 2.136.0

data/fastlane/swift/Scanfile.swift

@@ -18,4 +18,4 @@ class Scanfile: ScanfileProtocol {
 
 
 
-// Generated with fastlane 2.133.0
+// Generated with fastlane 2.136.0

data/fastlane/swift/Screengrabfile.swift

@@ -18,4 +18,4 @@ class Screengrabfile: ScreengrabfileProtocol {
 
 
 
-// Generated with fastlane 2.133.0
+// Generated with fastlane 2.136.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,18 @@ 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 }
+
+  /// Enabling this option will clean the status bar
+  var cleanStatusBar: Bool { get }
+
+  /// Specifies the configuration for the clean status bar
+  var cleanStatusBarConfig: [String : Any] { get }
 }
 
 extension ScreengrabfileProtocol {
@@ -70,16 +85,21 @@ 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 }
+  var cleanStatusBar: Bool { return false }
+  var cleanStatusBarConfig: [String : Any] { return [:] }
 }
 
 // Please don't remove the lines below
 // They are used to detect outdated files
-// FastlaneRunnerAPIVersion [0.9.11]
+// FastlaneRunnerAPIVersion [0.9.12]

data/fastlane/swift/Snapshotfile.swift

@@ -18,4 +18,4 @@ class Snapshotfile: SnapshotfileProtocol {
 
 
 
-// Generated with fastlane 2.133.0
+// Generated with fastlane 2.136.0

data/fastlane_core/lib/fastlane_core/configuration/commander_generator.rb

@@ -93,9 +93,9 @@ module FastlaneCore
       return if short_switch.nil?
 
       UI.user_error!("Short option #{short_switch} already taken for key #{key}") if used_switches.include?(short_switch)
-      UI.user_error!("-v is already used for the version (key #{key})") if short_switch == "-v"
-      UI.user_error!("-h is already used for the help screen (key #{key})") if short_switch == "-h"
-      UI.user_error!("-t is already used for the trace screen (key #{key})") if short_switch == "-t"
+      UI.user_error!("-v is already used for the fastlane version (key #{key})") if short_switch == "-v"
+      UI.user_error!("-h is already used for the fastlane help screen (key #{key})") if short_switch == "-h"
+      UI.user_error!("-t is already used for the fastlane trace screen (key #{key})") if short_switch == "-t"
 
       used_switches << short_switch
     end

data/fastlane_core/lib/fastlane_core/configuration/configuration.rb

@@ -120,7 +120,7 @@ module FastlaneCore
           index = @available_options.find_index { |item| item.key == conflicting_option_key }
           conflicting_option = @available_options[index]
 
-          # ignore conflicts because because value of conflict option is nil
+          # ignore conflicts because value of conflict option is nil
           next if @values[conflicting_option.key].nil?
 
           if current.conflict_block

data/fastlane_core/lib/fastlane_core/device_manager.rb

@@ -307,7 +307,7 @@ module FastlaneCore
         logarchive_dst = File.join(logs_destination_dir, "system_logs-#{log_identity}.logarchive").shellescape
         FileUtils.rm_rf(logarchive_dst)
         FileUtils.mkdir_p(File.expand_path("..", logarchive_dst))
-        command = "xcrun simctl spawn #{device.udid} log collect --output #{logarchive_dst} 2>/dev/null"
+        command = "xcrun simctl spawn --standalone #{device.udid} log collect --output #{logarchive_dst} 2>/dev/null"
         FastlaneCore::CommandExecutor.execute(command: command, print_all: false, print_command: true)
       end
     end

data/fastlane_core/lib/fastlane_core/swag.rb

@@ -45,7 +45,7 @@ module FastlaneCore
 
     def self.show_loader
       return unless should_be_shown?
-      # sound is disabled as i didn't find a royality free nice midi :(
+      # sound is disabled as I didn't find a royality free nice midi :(
       @output = StringIO.new
       # if FastlaneCore::Env.truthy?("FL_DO_SOUND")
       #  @sound_thr = Thread.new do

data/fastlane_core/lib/fastlane_core/ui/fastlane_runner.rb

@@ -117,7 +117,7 @@ module Commander
             abort(e.to_s)
           end
         end
-      rescue FastlaneCore::Interface::FastlaneCommonException => e # these are exceptions that we dont count as crashes
+      rescue FastlaneCore::Interface::FastlaneCommonException => e # these are exceptions that we don't count as crashes
         display_user_error!(e, e.to_s)
       rescue FastlaneCore::Interface::FastlaneError => e # user_error!
         rescue_fastlane_error(e)

data/match/lib/match/importer.rb

@@ -17,7 +17,7 @@ module Match
       UI.user_error!("Certificate does not exist at path: #{cert_path}") unless File.exist?(cert_path)
       UI.user_error!("Private key does not exist at path: #{p12_path}") unless File.exist?(p12_path)
 
-      # Base64 encrypt contents to find match from API to find a cert ID
+      # Base64 encode contents to find match from API to find a cert ID
       cert_contents_base_64 = Base64.strict_encode64(File.open(cert_path).read)
 
       # Storage

data/scan/lib/scan/error_handler.rb

@@ -6,8 +6,13 @@ module Scan
     class << self
       # @param [String] The output of the errored build
       # This method should raise an exception in any case, as the return code indicated a failed build
-      def handle_build_error(output)
-        # The order of the handling below is import
+      def handle_build_error(output, log_path)
+        # The order of the handling below is important
+
+        instruction = 'See the log'
+        location = Scan.config[:suppress_xcode_output] ? "here: '#{log_path}'" : "above"
+        details = "#{instruction} #{location}."
+
         case output
         when /US\-ASCII/
           print("Your shell environment is not correctly configured")
@@ -23,7 +28,7 @@ module Scan
           print("For more information visit this stackoverflow answer:")
           print("https://stackoverflow.com/a/17031697/445598")
         when /Testing failed/
-          UI.build_failure!("Error building the application - see the log above")
+          UI.build_failure!("Error building the application. #{details}")
         when /Executed/, /Failing tests:/
           # this is *really* important:
           # we don't want to raise an exception here
@@ -38,7 +43,7 @@ module Scan
           # followed by a list of tests that failed.
           return
         end
-        UI.build_failure!("Error building/testing the application - see the log above")
+        UI.build_failure!("Error building/testing the application. #{details}")
       end
 
       private

data/scan/lib/scan/runner.rb

@@ -67,7 +67,7 @@ module Scan
                                               error: proc do |error_output|
                                                 begin
                                                   exit_status = $?.exitstatus
-                                                  ErrorHandler.handle_build_error(error_output)
+                                                  ErrorHandler.handle_build_error(error_output, @test_command_generator.xcodebuild_log_path)
                                                 rescue => ex
                                                   SlackPoster.new.run({
                                                     build_errors: 1

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,30 @@ 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),
+        FastlaneCore::ConfigItem.new(key: :clean_status_bar,
+                                     env_name: 'SCREENGRAB_CLEAN_STATUS_BAR',
+                                     description: "Enabling this option will clean the status bar",
+                                     default_value: false,
+                                     type: Boolean),
+        FastlaneCore::ConfigItem.new(key: :clean_status_bar_config,
+                                     description: "Specifies the configuration for the clean status bar",
+                                     default_value: {},
+                                     type: Hash)
       ]
     end
   end

data/screengrab/lib/screengrab/runner.rb

@@ -57,8 +57,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 +72,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,7 +84,7 @@ module Screengrab
     end
 
     def select_device
-      devices = run_adb_command("adb devices -l", print_all: true, print_command: true).split("\n")
+      devices = run_adb_command("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|
         [
@@ -139,15 +146,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 +166,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 +193,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 +210,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 +225,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 +259,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 +289,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 +356,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 +368,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 +376,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 +386,34 @@ 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
+
+      # 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