fastlane-plugin-firebase_app_distribution 0.2.5 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1415793a828ae696b67f1568c6393a9ae68eb6dbf17fc2a379904e3256201c1b
-  data.tar.gz: b1e08e8e78359f62c2c76c868c8e80e90bdf3d463951072ecf77aaa46a232ad1
+  metadata.gz: 745bfb3dfc4c6c48f389c8e4d75b50026cf37e872ce26e7510aefef049280329
+  data.tar.gz: 8122801b30f95422216c9c5343d102bc6b11fbc16308f268515e7a3405bbf070
 SHA512:
-  metadata.gz: a3c2f313a6401ac052c48329d9f21228c084983c6f6a3c252e22c494c4216b57ee68882668e1f3f6f0e5f639b3389b0701d97dad3c3542289099450aea2f1952
-  data.tar.gz: 29c7622c069712c0012429c26e3ad7e306499c6a29d7a7d837185a008837831dba795787a16930817dbbdbb3aabb0f38f37c06094208d2e1376cff030c79733d
+  metadata.gz: 6ac42a57fdbda601b6ef2656a7e0d1b38304f022a26c970a75f1e0a43d01f2607f993c5500bceaf8ffb5b24ada6fbcbcb1ccf84d7dc8d87dc7d62049561d7886
+  data.tar.gz: ae12197e0149e187b02716e28a71207cd5ce67d14ea331bb9c230e41a53237e1c3e4359b1178f09bf059ac2d9697cb4b667d358a1d4751a3b47006efcaf131bb

data/lib/fastlane/plugin/firebase_app_distribution/actions/firebase_app_distribution_action.rb

@@ -8,40 +8,93 @@ require_relative '../helper/firebase_app_distribution_error_message'
 require_relative '../client/firebase_app_distribution_api_client'
 require_relative '../helper/firebase_app_distribution_auth_client'
 
-## TODO: should always use a file underneath? I think so.
 ## How should we document the usage of release notes?
 module Fastlane
   module Actions
-    class FirebaseAppDistributionAction < Action
-      FIREBASECMD_ACTION = "appdistribution:distribute".freeze
+    module SharedValues
+      FIREBASE_APP_DISTRO_RELEASE ||= :FIREBASE_APP_DISTRO_RELEASE
+    end
 
+    class FirebaseAppDistributionAction < Action
       extend Auth::FirebaseAppDistributionAuthClient
       extend Helper::FirebaseAppDistributionHelper
 
+      DEFAULT_UPLOAD_TIMEOUT_SECONDS = 300
+
       def self.run(params)
-        params.values # to validate all inputs before looking for the ipa/apk
+        params.values # to validate all inputs before looking for the ipa/apk/aab
+
+        if params[:debug]
+          UI.important("Warning: Debug logging enabled. Output may include sensitive information.")
+        end
 
         app_id = app_id_from_params(params)
+        app_name = app_name_from_app_id(app_id)
         platform = lane_platform || platform_from_app_id(app_id)
-        binary_path = binary_path_from_platform(platform, params[:ipa_path], params[:apk_path])
 
-        auth_token = fetch_auth_token(params[:service_credentials_file], params[:firebase_cli_token])
-        fad_api_client = Client::FirebaseAppDistributionApiClient.new(auth_token, platform, params[:debug])
+        binary_path = get_binary_path(platform, params)
+        UI.user_error!("Couldn't find binary") if binary_path.nil?
+        UI.user_error!("Couldn't find binary at path #{binary_path}") unless File.exist?(binary_path)
+        binary_type = binary_type_from_path(binary_path)
+
+        auth_token = fetch_auth_token(
+          params[:service_credentials_file], params[:firebase_cli_token], params[:debug]
+        )
+        fad_api_client = Client::FirebaseAppDistributionApiClient.new(auth_token, params[:debug])
+
+        # If binary is an AAB, get the AAB info for this app, which includes the integration state and certificate data
+        if binary_type == :AAB
+          aab_info = fad_api_client.get_aab_info(app_name)
+          validate_aab_setup!(aab_info)
+        end
+
+        upload_timeout = get_upload_timeout(params)
+
+        upload_status_response = fad_api_client.upload(app_name, binary_path, platform.to_s, upload_timeout)
+        release_name = upload_status_response.release_name
+        release = upload_status_response.release
 
-        release_id = fad_api_client.upload(app_id, binary_path, platform.to_s)
-        if release_id.nil?
-          return
+        if binary_type == :AAB && aab_info && !aab_info.certs_provided?
+          updated_aab_info = fad_api_client.get_aab_info(app_name)
+          if updated_aab_info.certs_provided?
+            UI.message("After you upload an AAB for the first time, App Distribution " \
+              "generates a new test certificate. All AAB uploads are re-signed with this test " \
+              "certificate. Use the certificate fingerprints below to register your app " \
+              "signing key with API providers, such as Google Sign-In and Google Maps.\n" \
+              "MD-1 certificate fingerprint: #{updated_aab_info.md5_certificate_hash}\n" \
+              "SHA-1 certificate fingerprint: #{updated_aab_info.sha1_certificate_hash}\n" \
+              "SHA-256 certificate fingerprint: #{updated_aab_info.sha256_certificate_hash}")
+          end
         end
 
-        release_notes = get_value_from_value_or_file(params[:release_notes], params[:release_notes_file])
-        fad_api_client.post_notes(app_id, release_id, release_notes)
+        release_notes = release_notes(params)
+        if release_notes.nil? || release_notes.empty?
+          UI.message("⏩ No release notes passed in. Skipping this step.")
+        else
+          release = fad_api_client.update_release_notes(release_name, release_notes)
+        end
 
         testers = get_value_from_value_or_file(params[:testers], params[:testers_file])
         groups = get_value_from_value_or_file(params[:groups], params[:groups_file])
         emails = string_to_array(testers)
-        group_ids = string_to_array(groups)
-        fad_api_client.enable_access(app_id, release_id, emails, group_ids)
-        UI.success("🎉 App Distribution upload finished successfully.")
+        group_aliases = string_to_array(groups)
+        fad_api_client.distribute(release_name, emails, group_aliases)
+        UI.success("🎉 App Distribution upload finished successfully. Setting Actions.lane_context[SharedValues::FIREBASE_APP_DISTRO_RELEASE] to the uploaded release.")
+
+        if upload_status_response.firebase_console_uri
+          UI.message("🔗 View this release in the Firebase console: #{upload_status_response.firebase_console_uri}")
+        end
+
+        if upload_status_response.testing_uri
+          UI.message("🔗 Share this release with testers who have access: #{upload_status_response.testing_uri}")
+        end
+
+        if upload_status_response.binary_download_uri
+          UI.message("🔗 Download the release binary (link expires in 1 hour): #{upload_status_response.binary_download_uri}")
+        end
+
+        Actions.lane_context[SharedValues::FIREBASE_APP_DISTRO_RELEASE] = release
+        release
       end
 
       def self.description
@@ -90,37 +143,66 @@ module Fastlane
         end
       end
 
-      def self.binary_path_from_platform(platform, ipa_path, apk_path)
-        case platform
-        when :ios
-          ipa_path
-        when :android
-          apk_path
-        else
-          ipa_path || apk_path
+      def self.get_binary_path(platform, params)
+        if platform == :ios
+          return params[:ipa_path] ||
+                 Actions.lane_context[SharedValues::IPA_OUTPUT_PATH] ||
+                 Dir["*.ipa"].sort_by { |x| File.mtime(x) }.last
+        end
+
+        if platform == :android
+          return params[:apk_path] || params[:android_artifact_path] if params[:apk_path] || params[:android_artifact_path]
+
+          if params[:android_artifact_type] == 'AAB'
+            return Actions.lane_context[SharedValues::GRADLE_AAB_OUTPUT_PATH] ||
+                   Dir["*.aab"].last ||
+                   Dir[File.join("app", "build", "outputs", "bundle", "release", "app-release.aab")].last
+          end
+
+          return Actions.lane_context[SharedValues::GRADLE_APK_OUTPUT_PATH] ||
+                 Dir["*.apk"].last ||
+                 Dir[File.join("app", "build", "outputs", "apk", "release", "app-release.apk")].last
         end
       end
 
-      def self.available_options
-        if lane_platform == :ios || lane_platform.nil?
-          ipa_path_default = Dir["*.ipa"].sort_by { |x| File.mtime(x) }.last
+      def self.get_upload_timeout(params)
+        if params[:upload_timeout]
+          return params[:upload_timeout]
+        else
+          return DEFAULT_UPLOAD_TIMEOUT_SECONDS
         end
+      end
 
-        if lane_platform == :android
-          apk_path_default = Dir["*.apk"].last || Dir[File.join("app", "build", "outputs", "apk", "app-release.apk")].last
+      def self.validate_aab_setup!(aab_info)
+        if aab_info && aab_info.integration_state != AabInfo::AabState::INTEGRATED && aab_info.integration_state != AabInfo::AabState::UNAVAILABLE
+          case aab_info.integration_state
+          when AabInfo::AabState::PLAY_ACCOUNT_NOT_LINKED
+            UI.user_error!(ErrorMessage::PLAY_ACCOUNT_NOT_LINKED)
+          when AabInfo::AabState::APP_NOT_PUBLISHED
+            UI.user_error!(ErrorMessage::APP_NOT_PUBLISHED)
+          when AabInfo::AabState::NO_APP_WITH_GIVEN_BUNDLE_ID_IN_PLAY_ACCOUNT
+            UI.user_error!(ErrorMessage::NO_APP_WITH_GIVEN_BUNDLE_ID_IN_PLAY_ACCOUNT)
+          when AabInfo::AabState::PLAY_IAS_TERMS_NOT_ACCEPTED
+            UI.user_error!(ErrorMessage::PLAY_IAS_TERMS_NOT_ACCEPTED)
+          else
+            UI.user_error!(ErrorMessage.aab_upload_error(aab_info.integration_state))
+          end
         end
+      end
+
+      def self.release_notes(params)
+        release_notes_param =
+          get_value_from_value_or_file(params[:release_notes], params[:release_notes_file])
+        release_notes_param || Actions.lane_context[SharedValues::FL_CHANGELOG]
+      end
 
+      def self.available_options
         [
           # iOS Specific
           FastlaneCore::ConfigItem.new(key: :ipa_path,
                                        env_name: "FIREBASEAPPDISTRO_IPA_PATH",
                                        description: "Path to your IPA file. Optional if you use the _gym_ or _xcodebuild_ action",
-                                       default_value: Actions.lane_context[SharedValues::IPA_OUTPUT_PATH] || ipa_path_default,
-                                       default_value_dynamic: true,
-                                       optional: true,
-                                       verify_block: proc do |value|
-                                         UI.user_error!("firebase_app_distribution: Couldn't find ipa file at path '#{value}'") unless File.exist?(value)
-                                       end),
+                                       optional: true),
           FastlaneCore::ConfigItem.new(key: :googleservice_info_plist_path,
                                        env_name: "GOOGLESERVICE_INFO_PLIST_PATH",
                                        description: "Path to your GoogleService-Info.plist file, relative to the archived product path",
@@ -131,12 +213,21 @@ module Fastlane
           FastlaneCore::ConfigItem.new(key: :apk_path,
                                        env_name: "FIREBASEAPPDISTRO_APK_PATH",
                                        description: "Path to your APK file",
-                                       default_value: Actions.lane_context[SharedValues::GRADLE_APK_OUTPUT_PATH] || apk_path_default,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :android_artifact_path,
+                                       env_name: "FIREBASEAPPDISTRO_ANDROID_ARTIFACT_PATH",
+                                       description: "Path to your APK or AAB file",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :android_artifact_type,
+                                       env_name: "FIREBASEAPPDISTRO_ANDROID_ARTIFACT_TYPE",
+                                       description: "Android artifact type. Set to 'APK' or 'AAB'. Defaults to 'APK' if not set",
+                                       default_value: "APK",
                                        default_value_dynamic: true,
                                        optional: true,
                                        verify_block: proc do |value|
-                                         UI.user_error!("firebase_app_distribution: Couldn't find apk file at path '#{value}'") unless File.exist?(value)
+                                         UI.user_error!("firebase_app_distribution: '#{value}' is not a valid value for android_artifact_type. Should be 'APK' or 'AAB'") unless ['APK', 'AAB'].include?(value)
                                        end),
+          # Generic
           FastlaneCore::ConfigItem.new(key: :app,
                                        env_name: "FIREBASEAPPDISTRO_APP",
                                        description: "Your app's Firebase App ID. You can find the App ID in the Firebase console, on the General Settings page",
@@ -149,12 +240,12 @@ module Fastlane
                                        type: String),
           FastlaneCore::ConfigItem.new(key: :groups,
                                        env_name: "FIREBASEAPPDISTRO_GROUPS",
-                                       description: "The groups used for distribution, separated by commas",
+                                       description: "The group aliases used for distribution, separated by commas",
                                        optional: true,
                                        type: String),
           FastlaneCore::ConfigItem.new(key: :groups_file,
                                        env_name: "FIREBASEAPPDISTRO_GROUPS_FILE",
-                                       description: "The groups used for distribution, separated by commas",
+                                       description: "The group aliases used for distribution, separated by commas",
                                        optional: true,
                                        type: String),
           FastlaneCore::ConfigItem.new(key: :testers,
@@ -170,8 +261,6 @@ module Fastlane
           FastlaneCore::ConfigItem.new(key: :release_notes,
                                        env_name: "FIREBASEAPPDISTRO_RELEASE_NOTES",
                                        description: "Release notes for this build",
-                                       default_value: Actions.lane_context[SharedValues::FL_CHANGELOG],
-                                       default_value_dynamic: true,
                                        optional: true,
                                        type: String),
           FastlaneCore::ConfigItem.new(key: :release_notes_file,
@@ -180,7 +269,7 @@ module Fastlane
                                        optional: true,
                                        type: String),
           FastlaneCore::ConfigItem.new(key: :firebase_cli_token,
-                                       description: "Auth token for firebase cli",
+                                       description: "Auth token generated using the Firebase CLI's login:ci command",
                                        optional: true,
                                        type: String),
           FastlaneCore::ConfigItem.new(key: :debug,
@@ -191,7 +280,12 @@ module Fastlane
           FastlaneCore::ConfigItem.new(key: :service_credentials_file,
                                        description: "Path to Google service account json",
                                        optional: true,
-                                       type: String)
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :upload_timeout,
+                                       description: "The amount of seconds before the upload will timeout, if not completed",
+                                       optional: true,
+                                       default_value: DEFAULT_UPLOAD_TIMEOUT_SECONDS,
+                                       type: Integer)
         ]
       end
 
@@ -207,12 +301,18 @@ module Fastlane
         [
           <<-CODE
             firebase_app_distribution(
-              app: "1:1234567890:ios:0a1b2c3d4e5f67890",
+              app: "<your Firebase app ID>",
               testers: "snatchev@google.com, rebeccahe@google.com"
             )
           CODE
         ]
       end
+
+      def self.output
+        [
+          ['FIREBASE_APP_DISTRO_RELEASE', 'A hash representing the uploaded release created in Firebase App Distribution']
+        ]
+      end
     end
   end
 end

data/lib/fastlane/plugin/firebase_app_distribution/actions/firebase_app_distribution_add_testers_action.rb

@@ -0,0 +1,90 @@
+require 'fastlane/action'
+require 'fastlane_core/ui/ui'
+
+require_relative '../helper/firebase_app_distribution_helper'
+require_relative '../helper/firebase_app_distribution_auth_client'
+
+module Fastlane
+  module Actions
+    class FirebaseAppDistributionAddTestersAction < Action
+      extend Auth::FirebaseAppDistributionAuthClient
+      extend Helper::FirebaseAppDistributionHelper
+
+      def self.run(params)
+        auth_token = fetch_auth_token(params[:service_credentials_file], params[:firebase_cli_token])
+        fad_api_client = Client::FirebaseAppDistributionApiClient.new(auth_token, params[:debug])
+
+        if blank?(params[:emails]) && blank?(params[:file])
+          UI.user_error!("Must specify `emails` or `file`.")
+        end
+
+        emails = string_to_array(get_value_from_value_or_file(params[:emails], params[:file]))
+
+        UI.user_error!("Must pass at least one email") if blank?(emails)
+
+        if emails.count > 1000
+          UI.user_error!("A maximum of 1000 testers can be added at a time.")
+        end
+
+        UI.message("⏳ Adding #{emails.count} testers to project #{params[:project_number]}...")
+
+        fad_api_client.add_testers(params[:project_number], emails)
+
+        # The add_testers response lists all the testers from the request
+        # regardless of whether or not they were created or if they already
+        # exists so can't get an accurate count of the number of newly created testers
+        UI.success("✅ Tester(s) successfully added.")
+      end
+
+      def self.description
+        "Create testers in bulk from a comma-separated list or a file"
+      end
+
+      def self.authors
+        ["Tunde Agboola"]
+      end
+
+      # supports markdown.
+      def self.details
+        "Create testers in bulk from a comma-separated list or a file"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :project_number,
+                                      env_name: "FIREBASEAPPDISTRO_PROJECT_NUMBER",
+                                      description: "Your Firebase project number. You can find the project number in the Firebase console, on the General Settings page",
+                                      type: Integer,
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :emails,
+                                      env_name: "FIREBASEAPPDISTRO_ADD_TESTERS_EMAILS",
+                                      description: "Comma separated list of tester emails to be created. A maximum of 1000 testers can be created at a time",
+                                      optional: true,
+                                      type: String),
+          FastlaneCore::ConfigItem.new(key: :file,
+                                      env_name: "FIREBASEAPPDISTRO_ADD_TESTERS_FILE",
+                                      description: "Path to a file containing a comma separated list of tester emails to be created. A maximum of 1000 testers can be deleted at a time",
+                                      optional: true,
+                                      type: String),
+          FastlaneCore::ConfigItem.new(key: :service_credentials_file,
+                                      description: "Path to Google service credentials file",
+                                      optional: true,
+                                      type: String),
+          FastlaneCore::ConfigItem.new(key: :firebase_cli_token,
+                                       description: "Auth token generated using the Firebase CLI's login:ci command",
+                                       optional: true,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :debug,
+                                       description: "Print verbose debug output",
+                                       optional: true,
+                                       default_value: false,
+                                       is_string: false)
+        ]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/firebase_app_distribution/actions/firebase_app_distribution_get_latest_release.rb

@@ -0,0 +1,114 @@
+require 'fastlane/action'
+require_relative '../client/firebase_app_distribution_api_client'
+require_relative '../helper/firebase_app_distribution_auth_client'
+require_relative '../helper/firebase_app_distribution_helper'
+
+module Fastlane
+  module Actions
+    module SharedValues
+      FIREBASE_APP_DISTRO_LATEST_RELEASE ||= :FIREBASE_APP_DISTRO_LATEST_RELEASE
+    end
+    class FirebaseAppDistributionGetLatestReleaseAction < Action
+      extend Auth::FirebaseAppDistributionAuthClient
+      extend Helper::FirebaseAppDistributionHelper
+
+      def self.run(params)
+        auth_token = fetch_auth_token(params[:service_credentials_file], params[:firebase_cli_token])
+        fad_api_client = Client::FirebaseAppDistributionApiClient.new(auth_token, params[:debug])
+
+        UI.message("⏳ Fetching latest release for app #{params[:app]}...")
+
+        releases = fad_api_client.list_releases(app_name_from_app_id(params[:app]), 1)[:releases] || []
+        if releases.empty?
+          latest_release = nil
+          UI.important("No releases for app #{params[:app]} found in App Distribution. Returning nil and setting Actions.lane_context[SharedValues::FIREBASE_APP_DISTRO_LATEST_RELEASE].")
+        else
+          latest_release = releases[0]
+          UI.success("✅ Latest release fetched successfully. Returning release and setting Actions.lane_context[SharedValues::FIREBASE_APP_DISTRO_LATEST_RELEASE].")
+        end
+        Actions.lane_context[SharedValues::FIREBASE_APP_DISTRO_LATEST_RELEASE] = latest_release
+        return latest_release
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Fetches the latest release in Firebase App Distribution"
+      end
+
+      def self.details
+        [
+          "Fetches information about the most recently created release in App Distribution, including the version and release notes. Returns nil if no releases are found."
+        ].join("\n")
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :app,
+                                       env_name: "FIREBASEAPPDISTRO_APP",
+                                       description: "Your app's Firebase App ID. You can find the App ID in the Firebase console, on the General Settings page",
+                                       optional: false,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :firebase_cli_token,
+                                       description: "Auth token generated using Firebase CLI's login:ci command",
+                                       optional: true,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :service_credentials_file,
+                                       description: "Path to Google service account json",
+                                       optional: true,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :debug,
+                                       description: "Print verbose debug output",
+                                       optional: true,
+                                       default_value: false,
+                                       is_string: false)
+        ]
+      end
+
+      def self.output
+        [
+          ['FIREBASE_APP_DISTRO_LATEST_RELEASE', 'A hash representing the lastest release created in Firebase App Distribution']
+        ]
+      end
+
+      def self.return_value
+        "Hash representation of the lastest release created in Firebase App Distribution (see https://firebase.google.com/docs/reference/app-distribution/rest/v1/projects.apps.releases#resource:-release)"
+      end
+
+      def self.return_type
+        :hash
+      end
+
+      def self.authors
+        ["lkellogg@google.com"]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.example_code
+        [
+          'release = firebase_app_distribution_get_latest_release(app: "<your Firebase app ID>")',
+          'increment_build_number({
+            build_number: firebase_app_distribution_get_latest_release(app: "<your Firebase app ID>")[:buildVersion].to_i + 1
+          })'
+        ]
+      end
+
+      def self.sample_return_value
+        {
+          name: "projects/123456789/apps/1:1234567890:ios:0a1b2c3d4e5f67890/releases/0a1b2c3d4",
+          releaseNotes: {
+            text: "Here are some release notes!"
+          },
+          displayVersion: "1.2.3",
+          buildVersion: "10",
+          createTime: "2021-10-06T15:01:23Z"
+        }
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/firebase_app_distribution/actions/firebase_app_distribution_get_udids.rb

@@ -0,0 +1,97 @@
+require 'fastlane/action'
+require 'open3'
+require 'shellwords'
+require 'googleauth'
+require_relative '../helper/firebase_app_distribution_helper'
+require_relative '../helper/firebase_app_distribution_error_message'
+require_relative '../client/firebase_app_distribution_api_client'
+require_relative '../helper/firebase_app_distribution_auth_client'
+
+module Fastlane
+  module Actions
+    class FirebaseAppDistributionGetUdidsAction < Action
+      extend Auth::FirebaseAppDistributionAuthClient
+      extend Helper::FirebaseAppDistributionHelper
+
+      def self.run(params)
+        auth_token = fetch_auth_token(params[:service_credentials_file], params[:firebase_cli_token])
+        fad_api_client = Client::FirebaseAppDistributionApiClient.new(auth_token, params[:debug])
+
+        app_id = params[:app]
+        udids = fad_api_client.get_udids(app_id)
+
+        if udids.empty?
+          UI.important("App Distribution fetched 0 tester UDIDs. Nothing written to output file.")
+        else
+          write_udids_to_file(udids, params[:output_file])
+          UI.success("🎉 App Distribution tester UDIDs written to: #{params[:output_file]}")
+        end
+      end
+
+      def self.write_udids_to_file(udids, output_file)
+        File.open(output_file, 'w') do |f|
+          f.write("Device ID\tDevice Name\tDevice Platform\n")
+          udids.each do |tester_udid|
+            f.write("#{tester_udid[:udid]}\t#{tester_udid[:name]}\t#{tester_udid[:platform]}\n")
+          end
+        end
+      end
+
+      def self.description
+        "Download the UDIDs of your Firebase App Distribution testers"
+      end
+
+      def self.authors
+        ["Lee Kellogg"]
+      end
+
+      # supports markdown.
+      def self.details
+        "Export your testers' device identifiers in a CSV file, so you can add them your provisioning profile. This file can be imported into your Apple developer account using the Register Multiple Devices option. See the [App Distribution docs](https://firebase.google.com/docs/app-distribution/ios/distribute-console#register-tester-devices) for more info."
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :app,
+                                       env_name: "FIREBASEAPPDISTRO_APP",
+                                       description: "Your app's Firebase App ID. You can find the App ID in the Firebase console, on the General Settings page",
+                                       optional: false,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :output_file,
+                                       env_name: "FIREBASEAPPDISTRO_OUTPUT_FILE",
+                                       description: "The path to the file where the tester UDIDs will be written",
+                                       optional: false,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :firebase_cli_token,
+                                       description: "Auth token generated using the Firebase CLI's login:ci command",
+                                       optional: true,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :service_credentials_file,
+                                       description: "Path to Google service account json",
+                                       optional: true,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :debug,
+                                       description: "Print verbose debug output",
+                                       optional: true,
+                                       default_value: false,
+                                       is_string: false)
+        ]
+      end
+
+      def self.is_supported?(platform)
+        [:ios].include?(platform)
+      end
+
+      def self.example_code
+        [
+          <<-CODE
+            firebase_app_distribution_get_udids(
+              app: "<your Firebase app ID>",
+              output_file: "tester_udids.txt",
+            )
+          CODE
+        ]
+      end
+    end
+  end
+end