fastlane-plugin-firebase_app_distribution 0.2.0.pre.1 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: ab7379d2d8feb6112f778c3b4a64e2f2181a099a
-  data.tar.gz: bdb617b84fb387a5486faee45d23be3043a9d9af
+SHA256:
+  metadata.gz: 5069b6e632432b25f206acbd47973be4326f582b8e555c7783c26638a6da9c21
+  data.tar.gz: a8f5e1ff46a220466eaa79e2e1072532b8715c79297462ac064e41da330e4c6e
 SHA512:
-  metadata.gz: 69f808e806793eb81839ac45241445c8764884f35c92c25066c86121c5ecb7ebf981371ed347fceadbfb0161df03ac6613fbd3f2aebe42a935783ca55d239df5
-  data.tar.gz: 83c298cdfd08b945957f10f9194142423418b89ee5dc17a2718b1506013e79fbba2f94ad11e1b7c0b92a874c3e69731eba327e66f393bb61b99fae0bf423d5b5
+  metadata.gz: 93749ffc7b47c65964da87b9db79925d71f1a0fc81bc0f33bd8710c8af34b934d19c7aad04f1e79bed2f90000190485ed07b86b1fb623cccbd1a81839d0ccdff
+  data.tar.gz: ebba43e6bc7de7d8742bab36a7a8139b176f1cbfdf2130bdddd2131e114448077f51b3458c308ede0a828335a58ad21cdcfa7fc9a5ca1955f479919868236505

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

@@ -13,7 +13,6 @@ require_relative '../helper/firebase_app_distribution_auth_client'
 module Fastlane
   module Actions
     class FirebaseAppDistributionAction < Action
-      DEFAULT_FIREBASE_CLI_PATH = `which firebase`
       FIREBASECMD_ACTION = "appdistribution:distribute".freeze
 
       extend Auth::FirebaseAppDistributionAuthClient
@@ -21,10 +20,10 @@ module Fastlane
 
       def self.run(params)
         params.values # to validate all inputs before looking for the ipa/apk
-        auth_token = fetch_auth_token(params[:service_credentials_file])
-        fad_api_client = Client::FirebaseAppDistributionApiClient.new(auth_token)
-        platform = Actions.lane_context[Actions::SharedValues::PLATFORM_NAME]
+        auth_token = fetch_auth_token(params[:service_credentials_file], params[:firebase_cli_token])
         binary_path = params[:ipa_path] || params[:apk_path]
+        platform = lane_platform || platform_from_path(binary_path)
+        fad_api_client = Client::FirebaseAppDistributionApiClient.new(auth_token, platform)
 
         if params[:app] # Set app_id if it is specified as a parameter
           app_id = params[:app]
@@ -38,7 +37,7 @@ module Fastlane
         if app_id.nil?
           UI.crash!(ErrorMessage::MISSING_APP_ID)
         end
-        release_id = fad_api_client.upload(app_id, binary_path)
+        release_id = fad_api_client.upload(app_id, binary_path, platform.to_s)
         if release_id.nil?
           return
         end
@@ -51,7 +50,7 @@ module Fastlane
         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")
+        UI.success("🎉 App Distribution upload finished successfully.")
       end
 
       def self.description
@@ -67,14 +66,26 @@ module Fastlane
         "Release your beta builds with Firebase App Distribution"
       end
 
-      def self.available_options
-        platform = Actions.lane_context[Actions::SharedValues::PLATFORM_NAME]
+      def self.lane_platform
+        Actions.lane_context[Actions::SharedValues::PLATFORM_NAME]
+      end
+
+      def self.platform_from_path(binary_path)
+        return nil unless binary_path
+        case binary_path.split('.').last
+        when 'ipa'
+          :ios
+        when 'apk'
+          :android
+        end
+      end
 
-        if platform == :ios || platform.nil?
+      def self.available_options
+        if lane_platform == :ios || lane_platform.nil?
           ipa_path_default = Dir["*.ipa"].sort_by { |x| File.mtime(x) }.last
         end
 
-        if platform == :android
+        if lane_platform == :android
           apk_path_default = Dir["*.apk"].last || Dir[File.join("app", "build", "outputs", "apk", "app-release.apk")].last
         end
 
@@ -105,22 +116,10 @@ module Fastlane
                                        optional: true,
                                        type: String),
           FastlaneCore::ConfigItem.new(key: :firebase_cli_path,
+                                       deprecated: "This plugin no longer uses the Firebase CLI",
                                        env_name: "FIREBASEAPPDISTRO_FIREBASE_CLI_PATH",
                                        description: "The absolute path of the firebase cli command",
-                                       default_value: DEFAULT_FIREBASE_CLI_PATH,
-                                       default_value_dynamic: true,
-                                       optional: false,
-                                       type: String,
-                                       verify_block: proc do |value|
-                                         value.chomp!
-                                         if value.to_s == "" || !File.exist?(value)
-                                           UI.user_error!("firebase_cli_path: missing path to firebase cli tool. Please install firebase in $PATH or specify path")
-                                         end
-
-                                         unless is_firebasecmd_supported?(value)
-                                           UI.user_error!("firebase_cli_path: `#{value}` does not support the `#{FIREBASECMD_ACTION}` command. Please download (https://appdistro.page.link/firebase-cli-download) or specify the path to the correct version of firebse")
-                                         end
-                                       end),
+                                       type: String),
           FastlaneCore::ConfigItem.new(key: :groups,
                                        env_name: "FIREBASEAPPDISTRO_GROUPS",
                                        description: "The groups used for distribution, separated by commas",
@@ -187,18 +186,6 @@ module Fastlane
           CODE
         ]
       end
-
-      ## TODO: figure out if we can surpress color output.
-      def self.is_firebasecmd_supported?(cmd)
-        outerr, status = Open3.capture2e(cmd, "--non-interactive", FIREBASECMD_ACTION, "--help")
-        return false unless status.success?
-
-        if outerr =~ /is not a Firebase command/
-          return false
-        end
-
-        true
-      end
     end
   end
 end

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

@@ -16,20 +16,20 @@ module Fastlane
         authorizer = Google::Auth::UserAuthorizer.new(client_id, SCOPE, nil)
         url = authorizer.get_authorization_url(base_url: OOB_URI)
 
-        UI.message("Please open the following address in your browser:")
+        UI.message("Open the following address in your browser and sign in with your Google account:")
         UI.message(url)
         UI.message("")
         code = UI.input("Enter the resulting code here: ")
         credentials = authorizer.get_credentials_from_code(code: code, base_url: OOB_URI)
-
-        UI.message("Refresh Token: #{credentials.refresh_token}")
         UI.message("")
-        UI.message("Set the refresh token as a FIREBASE_TOKEN environment variable")
+
+        UI.success("Set the refresh token as the FIREBASE_TOKEN environment variable")
+        UI.success("Refresh Token: #{credentials.refresh_token}")
       rescue Signet::AuthorizationError
-        UI.error("The code you entered was invalid. Ensure that you have copied the code correctly.")
+        UI.error("The code you entered is invalid. Copy and paste the code and try again.")
       rescue => error
         UI.error(error.to_s)
-        UI.crash!("An error has occured please login again.")
+        UI.crash!("An error has occured, please login again.")
       end
 
       #####################################################

data/lib/fastlane/plugin/firebase_app_distribution/client/firebase_app_distribution_api_client.rb

@@ -9,8 +9,16 @@ module Fastlane
       MAX_POLLING_RETRIES = 60
       POLLING_INTERVAL_SECONDS = 2
 
-      def initialize(auth_token)
+      def initialize(auth_token, platform)
         @auth_token = auth_token
+
+        if platform.nil?
+          @binary_type = "IPA/APK"
+        elsif platform == :ios
+          @binary_type = "IPA"
+        else
+          @binary_type = "APK"
+        end
       end
 
       # Enables tester access to the specified app release. Skips this
@@ -25,7 +33,7 @@ module Fastlane
       # Throws a user_error if app_id, emails, or group_ids are invalid
       def enable_access(app_id, release_id, emails, group_ids)
         if (emails.nil? || emails.empty?) && (group_ids.nil? || group_ids.empty?)
-          UI.message("No testers passed in. Skipping this step")
+          UI.success("✅ No testers passed in. Skipping this step.")
           return
         end
         payload = { emails: emails, groupIds: group_ids }
@@ -38,6 +46,7 @@ module Fastlane
         rescue Faraday::ClientError
           UI.user_error!("#{ErrorMessage::INVALID_TESTERS} \nEmails: #{emails} \nGroups: #{group_ids}")
         end
+        UI.success("✅ Added testers/groups.")
       end
 
       # Posts notes for the specified app release. Skips this
@@ -52,7 +61,7 @@ module Fastlane
       def post_notes(app_id, release_id, release_notes)
         payload = { releaseNotes: { releaseNotes: release_notes } }
         if release_notes.nil? || release_notes.empty?
-          UI.message("No release notes passed in. Skipping this step.")
+          UI.success("✅ No release notes passed in. Skipping this step.")
           return
         end
         begin
@@ -64,38 +73,57 @@ module Fastlane
           # rescue Faraday::ClientError
           #   UI.user_error!("#{ErrorMessage::INVALID_RELEASE_ID}: #{release_id}")
         end
-        UI.success("Release notes have been posted.")
+        UI.success("✅ Posted release notes.")
       end
 
+      # Returns the url encoded upload token used for get_upload_status calls:
+      # projects/<project-number>/apps/<app-id>/releases/-/binaries/<binary-hash>
+      #
+      # args
+      #   app_id - Firebase App ID
+      #   binary_path - Absolute path to your app's apk/ipa file
+      #
+      # Throws a user_error if an invalid app id is passed in, the binary file does
+      # not exist, or invalid auth credentials are used (e.g. wrong project permissions)
       def get_upload_token(app_id, binary_path)
-        begin
-          binary_hash = Digest::SHA256.hexdigest(File.open(binary_path).read)
-        rescue Errno::ENOENT
-          UI.crash!("#{ErrorMessage::APK_NOT_FOUND}: #{binary_path}")
+        if binary_path.nil? || !File.exist?(binary_path)
+          UI.crash!("#{ErrorMessage.binary_not_found(@binary_type)}: #{binary_path}")
         end
+        binary_hash = Digest::SHA256.hexdigest(read_binary(binary_path))
 
         begin
           response = connection.get(v1_apps_url(app_id)) do |request|
             request.headers["Authorization"] = "Bearer " + @auth_token
           end
         rescue Faraday::ResourceNotFound
-          UI.crash!("#{ErrorMessage::INVALID_APP_ID}: #{app_id}")
+          UI.user_error!("#{ErrorMessage::INVALID_APP_ID}: #{app_id}")
         end
         contact_email = response.body[:contactEmail]
         if contact_email.nil? || contact_email.strip.empty?
-          UI.crash!(ErrorMessage::GET_APP_NO_CONTACT_EMAIL_ERROR)
+          UI.user_error!(ErrorMessage::GET_APP_NO_CONTACT_EMAIL_ERROR)
         end
         return upload_token_format(response.body[:appId], response.body[:projectNumber], binary_hash)
       end
 
-      def upload_binary(app_id, binary_path)
-        connection.post(binary_upload_url(app_id), File.open(binary_path).read) do |request|
+      # Uploads the app binary to the Firebase API
+      #
+      # args
+      #   app_id - Firebase App ID
+      #   binary_path - Absolute path to your app's apk/ipa file
+      #   platform - 'android' or 'ios'
+      #
+      # Throws a user_error if an invalid app id is passed in, or if the binary file does not exist
+      def upload_binary(app_id, binary_path, platform)
+        connection.post(binary_upload_url(app_id), read_binary(binary_path)) do |request|
           request.headers["Authorization"] = "Bearer " + @auth_token
+          request.headers["X-APP-DISTRO-API-CLIENT-ID"] = "fastlane"
+          request.headers["X-APP-DISTRO-API-CLIENT-TYPE"] =  platform
+          request.headers["X-APP-DISTRO-API-CLIENT-VERSION"] = Fastlane::FirebaseAppDistribution::VERSION
         end
       rescue Faraday::ResourceNotFound
-        UI.crash!("#{ErrorMessage::INVALID_APP_ID}: #{app_id}")
-      rescue Errno::ENOENT
-        UI.crash!("#{ErrorMessage::APK_NOT_FOUND}: #{binary_path}")
+        UI.user_error!("#{ErrorMessage::INVALID_APP_ID}: #{app_id}")
+      rescue Errno::ENOENT # Raised when binary_path file does not exist
+        UI.user_error!("#{ErrorMessage.binary_not_found(@binary_type)}: #{binary_path}")
       end
 
       # Uploads the binary file if it has not already been uploaded
@@ -107,42 +135,57 @@ module Fastlane
       #
       # Returns the release_id on a successful release, otherwise returns nil.
       #
-      # Throws an error if the number of polling retries exceeds MAX_POLLING_RETRIES
-      def upload(app_id, binary_path)
+      # Throws a UI error if the number of polling retries exceeds MAX_POLLING_RETRIES
+      # Crashes if not able to upload the binary
+      def upload(app_id, binary_path, platform)
         upload_token = get_upload_token(app_id, binary_path)
         upload_status_response = get_upload_status(app_id, upload_token)
-        if upload_status_response.success?
-          UI.success("This APK/IPA has been uploaded before. Skipping upload step.")
+        if upload_status_response.success? || upload_status_response.already_uploaded?
+          UI.success("✅ This #{@binary_type} has been uploaded before. Skipping upload step.")
         else
-          UI.message("This APK has not been uploaded before.")
+          unless upload_status_response.in_progress?
+            UI.message("⌛ Uploading the #{@binary_type}.")
+            upload_binary(app_id, binary_path, platform)
+          end
           MAX_POLLING_RETRIES.times do
-            if upload_status_response.success?
-              UI.success("Uploaded APK/IPA Successfully!")
+            upload_status_response = get_upload_status(app_id, upload_token)
+            if upload_status_response.success? || upload_status_response.already_uploaded?
+              UI.success("✅ Uploaded the #{@binary_type}.")
               break
             elsif upload_status_response.in_progress?
               sleep(POLLING_INTERVAL_SECONDS)
             else
-              UI.message("Uploading the APK/IPA.")
-              upload_binary(app_id, binary_path)
+              if !upload_status_response.message.nil?
+                UI.user_error!("#{ErrorMessage.upload_binary_error(@binary_type)}: #{upload_status_response.message}")
+              else
+                UI.user_error!(ErrorMessage.upload_binary_error(@binary_type))
+              end
             end
-            upload_status_response = get_upload_status(app_id, upload_token)
           end
           unless upload_status_response.success?
-            UI.error("It took longer than expected to process your APK/IPA, please try again.")
+            UI.error("It took longer than expected to process your #{@binary_type}, please try again.")
             return nil
           end
         end
         upload_status_response.release_id
       end
 
-      # Gets the upload status for the app release.
-      def get_upload_status(app_id, app_token)
+      # Fetches the status of an uploaded binary
+      #
+      # args
+      #   app_id - Firebase App ID
+      #   upload_token - URL encoded upload token
+      #
+      # Returns the release ID on a successful release, otherwise returns nil.
+      #
+      # Throws a user_error if an invalid app_id is passed in
+      def get_upload_status(app_id, upload_token)
         begin
-          response = connection.get(upload_status_url(app_id, app_token)) do |request|
+          response = connection.get(upload_status_url(app_id, upload_token)) do |request|
             request.headers["Authorization"] = "Bearer " + @auth_token
           end
         rescue Faraday::ResourceNotFound
-          UI.crash!("#{ErrorMessage::INVALID_APP_ID}: #{app_id}")
+          UI.user_error!("#{ErrorMessage::INVALID_APP_ID}: #{app_id}")
         end
         return UploadStatusResponse.new(response.body)
       end
@@ -180,6 +223,11 @@ module Fastlane
           conn.adapter(Faraday.default_adapter)
         end
       end
+
+      def read_binary(path)
+        # File must be read in binary mode to work on Windows
+        File.open(path, 'rb').read
+      end
     end
   end
 end

data/lib/fastlane/plugin/firebase_app_distribution/helper/firebase_app_distribution_auth_client.rb

@@ -5,33 +5,74 @@ module Fastlane
     module FirebaseAppDistributionAuthClient
       TOKEN_CREDENTIAL_URI = "https://oauth2.googleapis.com/token"
 
-      def fetch_auth_token(google_service_path)
+      # Returns the auth token for any of the auth methods (Firebase CLI token,
+      # Google service account, firebase-tools). To ensure that a specific
+      # auth method is used, unset all other auth variables/parameters to nil/empty
+      #
+      # args
+      #   google_service_path - Absolute path to the Google service account file
+      #   firebase_cli_token - Firebase CLI refresh token from login action or
+      #                        CI environment
+      #
+      # env variables
+      #   GOOGLE_APPLICATION_CREDENTIALS - see google_service_path
+      #   FIREBASE_TOKEN - see firebase_cli_token
+      #
+      # Crashes if given invalid or missing credentials
+      def fetch_auth_token(google_service_path, firebase_cli_token)
         if !google_service_path.nil? && !google_service_path.empty?
-          service_account(google_service_path)
-        elsif ENV["FIREBASE_TOKEN"]
-          firebase_token
-        elsif ENV["GOOGLE_APPLICATION_CREDENTIALS"]
-          service_account(ENV["GOOGLE_APPLICATION_CREDENTIALS"])
+          UI.message("Authenticating with --service_credentials_file path parameter: #{google_service_path}")
+          token = service_account(google_service_path)
+        elsif !firebase_cli_token.nil? && !firebase_cli_token.empty?
+          UI.message("Authenticating with --firebase_cli_token parameter")
+          token = firebase_token(firebase_cli_token)
+        elsif !ENV["FIREBASE_TOKEN"].nil? && !ENV["FIREBASE_TOKEN"].empty?
+          UI.message("Authenticating with FIREBASE_TOKEN environment variable")
+          token = firebase_token(ENV["FIREBASE_TOKEN"])
+        elsif !ENV["GOOGLE_APPLICATION_CREDENTIALS"].nil? && !ENV["GOOGLE_APPLICATION_CREDENTIALS"].empty?
+          UI.message("Authenticating with GOOGLE_APPLICATION_CREDENTIALS environment variable: #{ENV['GOOGLE_APPLICATION_CREDENTIALS']}")
+          token = service_account(ENV["GOOGLE_APPLICATION_CREDENTIALS"])
+        elsif (refresh_token = refresh_token_from_firebase_tools)
+          UI.message("No authentication method specified. Using cached Firebase CLI credentials.")
+          token = firebase_token(refresh_token)
         else
-          UI.crash!(ErrorMessage::MISSING_CREDENTIALS)
+          UI.user_error!(ErrorMessage::MISSING_CREDENTIALS)
         end
+        UI.success("🔐 Authenticated successfully.")
+        token
       end
 
       private
 
-      def firebase_token
-        begin
-          client = Signet::OAuth2::Client.new(
-            token_credential_uri: TOKEN_CREDENTIAL_URI,
-            client_id: Fastlane::Actions::FirebaseAppDistributionLoginAction::CLIENT_ID,
-            client_secret: Fastlane::Actions::FirebaseAppDistributionLoginAction::CLIENT_SECRET,
-            refresh_token: ENV["FIREBASE_TOKEN"]
-          )
-        rescue Signet::AuthorizationError
-          UI.crash!(ErrorMessage::REFRESH_TOKEN_ERROR)
+      def refresh_token_from_firebase_tools
+        if ENV["XDG_CONFIG_HOME"].nil? || ENV["XDG_CONFIG_HOME"].empty?
+          config_path = File.expand_path(".config/configstore/firebase-tools.json", "~")
+        else
+          config_path = File.expand_path("configstore/firebase-tools.json", ENV["XDG_CONFIG_HOME"])
+        end
+
+        if File.exist?(config_path)
+          begin
+            refresh_token = JSON.parse(File.read(config_path))['tokens']['refresh_token']
+            refresh_token unless refresh_token.nil? || refresh_token.empty?
+          # TODO: Catch parser errors, improve error handling here
+          # Returns nil when there is an empty "tokens" field in the firebase-tools json
+          rescue NoMethodError
+          end
         end
+      end
+
+      def firebase_token(refresh_token)
+        client = Signet::OAuth2::Client.new(
+          token_credential_uri: TOKEN_CREDENTIAL_URI,
+          client_id: Fastlane::Actions::FirebaseAppDistributionLoginAction::CLIENT_ID,
+          client_secret: Fastlane::Actions::FirebaseAppDistributionLoginAction::CLIENT_SECRET,
+          refresh_token: refresh_token
+        )
         client.fetch_access_token!
         client.access_token
+      rescue Signet::AuthorizationError
+        UI.user_error!(ErrorMessage::REFRESH_TOKEN_ERROR)
       end
 
       def service_account(google_service_path)
@@ -41,7 +82,9 @@ module Fastlane
         )
         service_account_credentials.fetch_access_token!["access_token"]
       rescue Errno::ENOENT
-        UI.crash!("#{ErrorMessage::SERVICE_CREDENTIALS_NOT_FOUND}: #{google_service_path}")
+        UI.user_error!("#{ErrorMessage::SERVICE_CREDENTIALS_NOT_FOUND}: #{google_service_path}")
+      rescue Signet::AuthorizationError
+        UI.user_error!("#{ErrorMessage::SERVICE_CREDENTIALS_ERROR}: #{google_service_path}")
       end
     end
   end

data/lib/fastlane/plugin/firebase_app_distribution/helper/firebase_app_distribution_error_message.rb

@@ -1,21 +1,34 @@
 module ErrorMessage
-  MISSING_CREDENTIALS = "Missing credentials. Please check that a refresh token was set or service credentials were passed in and try again"
-  APK_NOT_FOUND = "Could not find the APK/IPA. Make sure you set the apk_path parameter to point to your APK/IPA"
-  MISSING_APP_ID = "Missing app id. Please check that it was passed in and try again"
+  MISSING_CREDENTIALS = "Missing authentication credentials. Check that your Firebase refresh token is set or that your service account file path is correct and try again."
+  MISSING_APP_ID = "Missing app id. Please check that the app parameter is set and try again"
   SERVICE_CREDENTIALS_NOT_FOUND = "Service credentials file does not exist. Please check the service credentials path and try again"
   PARSE_SERVICE_CREDENTIALS_ERROR = "Failed to extract service account information from the service credentials file"
-  PARSE_APK_METADATA_ERROR = "Failed to extract APK/IPA metadata from the APK/IPA path"
   UPLOAD_RELEASE_NOTES_ERROR = "App Distribution halted because it had a problem uploading release notes"
   UPLOAD_TESTERS_ERROR = "App Distribution halted because it had a problem adding testers/groups"
-  UPLOAD_APK_ERROR = "App Distribution halted because it had a problem uploading the APK/IPA"
-  APK_PROCESSING_ERROR = "App Distribution failed to process the APK/IPA"
   GET_RELEASE_TIMEOUT = "App Distribution failed to fetch release information"
-  REFRESH_TOKEN_ERROR = "Could not generate credentials from the refresh token specified"
+  REFRESH_TOKEN_ERROR = "App Distribution could not generate credentials from the refresh token specified."
   GET_APP_ERROR = "App Distribution failed to fetch app information"
   APP_NOT_ONBOARDED_ERROR = "App Distribution not onboarded"
   GET_APP_NO_CONTACT_EMAIL_ERROR = "App Distribution could not find a contact email associated with this app. Contact Email"
   INVALID_APP_ID = "App Distribution could not find your app. Make sure to onboard your app by pressing the \"Get started\" button on the App Distribution page in the Firebase console: https://console.firebase.google.com/project/_/appdistribution. App ID"
   INVALID_PATH = "Could not read content from"
-  INVALID_TESTERS = "Could not enable access for testers. Ensure that the groups exist and the tester emails are formatted correctly"
+  INVALID_TESTERS = "Could not enable access for testers. Check that the groups exist and the tester emails are formatted correctly"
   INVALID_RELEASE_ID = "App distribution failed to fetch release with id"
+  SERVICE_CREDENTIALS_ERROR = "App Distribution could not generate credentials from the service credentials file specified. Service Account Path"
+
+  def self.binary_not_found(binary_type)
+    "Could not find the #{binary_type}. Make sure you set the #{binary_type} path parameter to point to your #{binary_type}"
+  end
+
+  def self.parse_binary_metadata_error(binary_type)
+    "Failed to extract #{binary_type} metadata from the #{binary_type} path"
+  end
+
+  def self.upload_binary_error(binary_type)
+    "App Distribution halted because it had a problem uploading the #{binary_type}"
+  end
+
+  def self.binary_processing_error(binary_type)
+    "App Distribution failed to process the #{binary_type}"
+  end
 end

data/lib/fastlane/plugin/firebase_app_distribution/helper/firebase_app_distribution_helper.rb

@@ -1,4 +1,5 @@
 require 'fastlane_core/ui/ui'
+require 'cfpropertylist'
 module Fastlane
   UI = FastlaneCore::UI unless Fastlane.const_defined?("UI")
   module Helper
@@ -23,6 +24,10 @@ module Fastlane
         return string_array
       end
 
+      def parse_plist(path)
+        CFPropertyList.native_types(CFPropertyList::List.new(file: path).value)
+      end
+
       def get_ios_app_id_from_archive(path)
         app_path = parse_plist("#{path}/Info.plist")["ApplicationProperties"]["ApplicationPath"]
         UI.shell_error!("can't extract application path from Info.plist at #{path}") if app_path.empty?

data/lib/fastlane/plugin/firebase_app_distribution/helper/upload_status_response.rb

@@ -12,7 +12,15 @@ class UploadStatusResponse
   end
 
   def in_progress?
-    status == "IN_PROGRESS"
+    status == 'IN_PROGRESS'
+  end
+
+  def error?
+    status == 'ERROR'
+  end
+
+  def already_uploaded?
+    status == 'ALREADY_UPLOADED'
   end
 
   def release_hash
@@ -22,4 +30,8 @@ class UploadStatusResponse
   def release_id
     release_hash ? release_hash[:id] : nil
   end
+
+  def message
+    @response_json_hash[:message]
+  end
 end

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

@@ -1,5 +1,5 @@
 module Fastlane
   module FirebaseAppDistribution
-    VERSION = "0.2.0.pre.1"
+    VERSION = "0.2.1"
   end
 end

metadata

@@ -1,16 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: fastlane-plugin-firebase_app_distribution
 version: !ruby/object:Gem::Version
-  version: 0.2.0.pre.1
+  version: 0.2.1
 platform: ruby
 authors:
 - Stefan Natchev
 - Manny Jimenez
 - Alonso Salas Infante
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-07-28 00:00:00.000000000 Z
+date: 2020-09-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry
@@ -138,7 +138,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 2.127.1
-description: 
+description:
 email:
 - snatchev@google.com
 - mannyjimenez@google.com
@@ -162,7 +162,7 @@ homepage: https://github.com/fastlane/fastlane-plugin-firebase_app_distribution
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -173,13 +173,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.2.5
-signing_key: 
+rubygems_version: 3.1.2
+signing_key:
 specification_version: 4
 summary: Release your beta builds to Firebase App Distribution. https://firebase.google.com/docs/app-distribution
 test_files: []