fastlane-plugin-firebase_app_distribution 0.2.2.pre.2 → 0.2.6.pre.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c5ca3144300e192d87eb1e9457152c5484a057dfcb0d492d672da8cbbf983368
-  data.tar.gz: ab60ae5cf17ba96547e2278b34c4858149960247fcc593e3bd3cb1794d9eaef9
+  metadata.gz: d129a8d78fc5bca84c4e7484dbe02436ee9cd4ef9e9005bec4e1646401b9b143
+  data.tar.gz: 1677a9d201117796c171ed8a0a9472b69bc8b763bdd5492e3a3fd8f3dae19d84
 SHA512:
-  metadata.gz: 14da8737b9424a01aca4e6df1fdc3ce5254343b89e01fbdac31c9e9176cec5b5d351a78dc1d03adc0d1c031207fee049c5a517cf63ce440cf45fa7326cab45a2
-  data.tar.gz: eda22a0b5c8cee1b0c990db5f0137c867d7e5a2be8ee7bd30c50811ba80e9b2585e4af5f56bdd82fcaee1adcfa0367286511c6be3fbdf7f550abb69e88941ea6
+  metadata.gz: 1c6e3502a696a1d759f838028812a526745e6d11fe678e26a829ead65fd8114b4244565695d338b1d60ef34cb1129b70948e87c8d297c72334abc46e9bbc20ec
+  data.tar.gz: 47504b8df8a313b588aea6c5fa8b7d8cebc5d7ea66117c0025b73f53e6f529bbc443e395c66baa357248c81b864ed81f5cfe46cd957c42c92d03e63e16cbc89a

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

@@ -13,26 +13,46 @@ require_relative '../helper/firebase_app_distribution_auth_client'
 module Fastlane
   module Actions
     class FirebaseAppDistributionAction < Action
-      FIREBASECMD_ACTION = "appdistribution:distribute".freeze
-
       extend Auth::FirebaseAppDistributionAuthClient
       extend Helper::FirebaseAppDistributionHelper
 
       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
 
         app_id = app_id_from_params(params)
         platform = lane_platform || platform_from_app_id(app_id)
-        binary_path = binary_path_from_platform(platform, params[:ipa_path], params[:apk_path])
+
+        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])
-        fad_api_client = Client::FirebaseAppDistributionApiClient.new(auth_token, platform)
+        fad_api_client = Client::FirebaseAppDistributionApiClient.new(auth_token, params[:debug])
 
-        release_id = fad_api_client.upload(app_id, binary_path, platform.to_s)
+        # If binary is an AAB get FULL view of app which includes the aab_state
+        app_view = binary_type == :AAB ? 'FULL' : 'BASIC'
+        app = fad_api_client.get_app(app_id, app_view)
+        validate_app!(app, binary_type)
+
+        release_id = fad_api_client.upload(app.project_number, app_id, binary_path, platform.to_s)
         if release_id.nil?
           return
         end
 
+        if binary_type == :AAB && app.aab_certificate.empty?
+          updated_app = fad_api_client.get_app(app_id)
+          unless updated_app.aab_certificate.empty?
+            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_app.aab_certificate.md5_certificate_hash}\n" \
+              "SHA-1 certificate fingerprint: #{updated_app.aab_certificate.sha1_certificate_hash}\n" \
+              "SHA-256 certificate fingerprint: #{updated_app.aab_certificate.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)
 
@@ -90,52 +110,80 @@ 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.validate_app!(app, binary_type)
+        if app.contact_email.nil? || app.contact_email.strip.empty?
+          UI.user_error!(ErrorMessage::GET_APP_NO_CONTACT_EMAIL_ERROR)
         end
 
-        if lane_platform == :android
-          apk_path_default = Dir["*.apk"].last || Dir[File.join("app", "build", "outputs", "apk", "app-release.apk")].last
+        if binary_type == :AAB && app.aab_state != App::AabState::ACTIVE && app.aab_state != App::AabState::UNAVAILABLE
+          case app.aab_state
+          when App::AabState::PLAY_ACCOUNT_NOT_LINKED
+            UI.user_error!(ErrorMessage::PLAY_ACCOUNT_NOT_LINKED)
+          when App::AabState::APP_NOT_PUBLISHED
+            UI.user_error!(ErrorMessage::APP_NOT_PUBLISHED)
+          when App::AabState::NO_APP_WITH_GIVEN_BUNDLE_ID_IN_PLAY_ACCOUNT
+            UI.user_error!(ErrorMessage::NO_APP_WITH_GIVEN_BUNDLE_ID_IN_PLAY_ACCOUNT)
+          when App::AabState::PLAY_IAS_TERMS_NOT_ACCEPTED
+            UI.user_error!(ErrorMessage::PLAY_IAS_TERMS_NOT_ACCEPTED)
+          else
+            UI.user_error!(ErrorMessage.aab_upload_error(app.aab_state))
+          end
         end
+      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 root of your Xcode project",
+                                       description: "Path to your GoogleService-Info.plist file, relative to the archived product path",
                                        default_value: "GoogleService-Info.plist",
                                        optional: true,
                                        type: String),
           # Android Specific
           FastlaneCore::ConfigItem.new(key: :apk_path,
                                        env_name: "FIREBASEAPPDISTRO_APK_PATH",
+                                       deprecated: "The apk_path parameter is deprecated. Please use android_artifact_path instead",
                                        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_path. Should be 'APK' or 'AAB'") unless ['APK', 'AAB'].include?(value)
                                        end),
           FastlaneCore::ConfigItem.new(key: :app,
                                        env_name: "FIREBASEAPPDISTRO_APP",

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

@@ -8,6 +8,9 @@ module Fastlane
     class FirebaseAppDistributionLoginAction < Action
       OOB_URI = "urn:ietf:wg:oauth:2.0:oob"
       SCOPE = "https://www.googleapis.com/auth/cloud-platform"
+
+      # In this type of application, the client secret is not treated as a secret.
+      # See: https://developers.google.com/identity/protocols/OAuth2InstalledApp
       CLIENT_ID = "563584335869-fgrhgmd47bqnekij5i8b5pr03ho849e6.apps.googleusercontent.com"
       CLIENT_SECRET = "j9iVZfS8kkCEFUPaAeJV0sAi"
 

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

@@ -0,0 +1,23 @@
+class AabCertificate
+  def initialize(response)
+    @response = response || {}
+  end
+
+  def md5_certificate_hash
+    @response[:certificateHashMd5]
+  end
+
+  def sha1_certificate_hash
+    @response[:certificateHashSha1]
+  end
+
+  def sha256_certificate_hash
+    @response[:certificateHashSha256]
+  end
+
+  def empty?
+    (md5_certificate_hash.nil? || md5_certificate_hash.empty?) &&
+      (sha1_certificate_hash.nil? || sha1_certificate_hash.empty?) &&
+      (sha256_certificate_hash.nil? || sha256_certificate_hash.empty?)
+  end
+end

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

@@ -0,0 +1,37 @@
+require_relative 'aab_certificate'
+
+class App
+  # AAB states
+  class AabState
+    UNSPECIFIED = "AAB_STATE_UNSPECIFIED"
+    PLAY_ACCOUNT_NOT_LINKED = "PLAY_ACCOUNT_NOT_LINKED"
+    NO_APP_WITH_GIVEN_BUNDLE_ID_IN_PLAY_ACCOUNT = "NO_APP_WITH_GIVEN_BUNDLE_ID_IN_PLAY_ACCOUNT"
+    APP_NOT_PUBLISHED = "APP_NOT_PUBLISHED"
+    PLAY_IAS_TERMS_NOT_ACCEPTED = "PLAY_IAS_TERMS_NOT_ACCEPTED"
+    ACTIVE = "ACTIVE"
+    UNAVAILABLE = "AAB_STATE_UNAVAILABLE"
+  end
+
+  attr_reader :aab_certificate
+
+  def initialize(response)
+    @response = response
+    @aab_certificate = AabCertificate.new(response[:aabCertificate])
+  end
+
+  def app_id
+    @response[:appId]
+  end
+
+  def project_number
+    @response[:projectNumber]
+  end
+
+  def contact_email
+    @response[:contactEmail]
+  end
+
+  def aab_state
+    @response[:aabState]
+  end
+end

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

@@ -0,0 +1,16 @@
+module Fastlane
+  module Client
+    class ErrorResponse
+      attr_accessor :code, :message, :status
+
+      def initialize(response)
+        unless response[:body].nil? || response[:body].empty?
+          response_body = JSON.parse(response[:body], symbolize_names: true)
+          @code = response_body[:error][:code]
+          @message = response_body[:error][:message]
+          @status = response_body[:error][:status]
+        end
+      end
+    end
+  end
+end

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

@@ -1,24 +1,27 @@
 require 'fastlane_core/ui/ui'
 require_relative '../actions/firebase_app_distribution_login'
+require_relative '../client/error_response'
+require_relative '../client/app'
+require_relative '../helper/firebase_app_distribution_helper'
 
 module Fastlane
   module Client
     class FirebaseAppDistributionApiClient
+      include Helper::FirebaseAppDistributionHelper
+
       BASE_URL = "https://firebaseappdistribution.googleapis.com"
       TOKEN_CREDENTIAL_URI = "https://oauth2.googleapis.com/token"
       MAX_POLLING_RETRIES = 60
       POLLING_INTERVAL_SECONDS = 2
 
-      def initialize(auth_token, platform)
-        @auth_token = auth_token
+      AUTHORIZATION = "Authorization"
+      CONTENT_TYPE = "Content-Type"
+      APPLICATION_JSON = "application/json"
+      APPLICATION_OCTET_STREAM = "application/octet-stream"
 
-        if platform.nil?
-          @binary_type = "IPA/APK"
-        elsif platform == :ios
-          @binary_type = "IPA"
-        else
-          @binary_type = "APK"
-        end
+      def initialize(auth_token, debug = false)
+        @auth_token = auth_token
+        @debug = debug
       end
 
       # Enables tester access to the specified app release. Skips this
@@ -30,7 +33,7 @@ module Fastlane
       #   emails - String array of app testers' email addresses
       #   group_ids - String array of Firebase tester group IDs
       #
-      # Throws a user_error if app_id, emails, or group_ids are invalid
+      # Throws a user_error if 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.success("✅ No testers passed in. Skipping this step.")
@@ -39,10 +42,9 @@ module Fastlane
         payload = { emails: emails, groupIds: group_ids }
         begin
           connection.post(enable_access_url(app_id, release_id), payload.to_json) do |request|
-            request.headers["Authorization"] = "Bearer " + @auth_token
+            request.headers[AUTHORIZATION] = "Bearer " + @auth_token
+            request.headers[CONTENT_TYPE] = APPLICATION_JSON
           end
-        rescue Faraday::ResourceNotFound
-          UI.user_error!("#{ErrorMessage::INVALID_APP_ID}: #{app_id}")
         rescue Faraday::ClientError
           UI.user_error!("#{ErrorMessage::INVALID_TESTERS} \nEmails: #{emails} \nGroups: #{group_ids}")
         end
@@ -57,7 +59,7 @@ module Fastlane
       #   release_id - App release ID, returned by upload_status endpoint
       #   release_notes - String of notes for this release
       #
-      # Throws a user_error if app_id or release_id are invalid
+      # Throws a user_error if the release_notes are invalid
       def post_notes(app_id, release_id, release_notes)
         payload = { releaseNotes: { releaseNotes: release_notes } }
         if release_notes.nil? || release_notes.empty?
@@ -66,104 +68,98 @@ module Fastlane
         end
         begin
           connection.post(release_notes_create_url(app_id, release_id), payload.to_json) do |request|
-            request.headers["Authorization"] = "Bearer " + @auth_token
+            request.headers[AUTHORIZATION] = "Bearer " + @auth_token
+            request.headers[CONTENT_TYPE] = APPLICATION_JSON
           end
-        rescue Faraday::ResourceNotFound
-          UI.user_error!("#{ErrorMessage::INVALID_APP_ID}: #{app_id}")
-          # rescue Faraday::ClientError
-          #   UI.user_error!("#{ErrorMessage::INVALID_RELEASE_ID}: #{release_id}")
+        rescue Faraday::ClientError => e
+          error = ErrorResponse.new(e.response)
+          UI.user_error!("#{ErrorMessage::INVALID_RELEASE_NOTES}: #{error.message}")
         end
         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>
+      # Get app
       #
       # 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)
-        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))
-
+      # Throws a user_error if the app hasn't been onboarded to App Distribution
+      def get_app(app_id, app_view = 'BASIC')
         begin
-          response = connection.get(v1_apps_url(app_id)) do |request|
-            request.headers["Authorization"] = "Bearer " + @auth_token
+          response = connection.get("#{v1_apps_url(app_id)}?appView=#{app_view}") do |request|
+            request.headers[AUTHORIZATION] = "Bearer " + @auth_token
           end
         rescue Faraday::ResourceNotFound
           UI.user_error!("#{ErrorMessage::INVALID_APP_ID}: #{app_id}")
         end
-        contact_email = response.body[:contactEmail]
-        if contact_email.nil? || contact_email.strip.empty?
-          UI.user_error!(ErrorMessage::GET_APP_NO_CONTACT_EMAIL_ERROR)
-        end
-        return upload_token_format(response.body[:appId], response.body[:projectNumber], binary_hash)
+
+        App.new(response.body)
       end
 
       # 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
+      #   binary_path - Absolute path to your app's aab/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
+      # Throws a user_error 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[AUTHORIZATION] = "Bearer " + @auth_token
+          request.headers[CONTENT_TYPE] = APPLICATION_OCTET_STREAM
           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
+          request.headers["X-GOOG-UPLOAD-FILE-NAME"] = File.basename(binary_path)
+          request.headers["X-GOOG-UPLOAD-PROTOCOL"] = "raw"
         end
-      rescue Faraday::ResourceNotFound
-        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}")
+        binary_type = binary_type_from_path(binary_path)
+        UI.user_error!("#{ErrorMessage.binary_not_found(binary_type)}: #{binary_path}")
       end
 
       # Uploads the binary file if it has not already been uploaded
       # Takes at least POLLING_INTERVAL_SECONDS between polling get_upload_status
       #
       # args
-      #   app_id - Firebase App ID
-      #   binary_path - Absolute path to your app's apk/ipa file
+      #   project_number - Firebase project number
+      #   app_id - Firebase app ID
+      #   binary_path - Absolute path to your app's aab/apk/ipa file
       #
       # Returns the release_id on a successful release, otherwise returns nil.
       #
       # 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)
+      def upload(project_number, app_id, binary_path, platform)
+        binary_type = binary_type_from_path(binary_path)
+
+        upload_token = get_upload_token(project_number, app_id, binary_path)
         upload_status_response = get_upload_status(app_id, upload_token)
         if upload_status_response.success? || upload_status_response.already_uploaded?
-          UI.success("✅ This #{@binary_type} has been uploaded before. Skipping upload step.")
+          UI.success("✅ This #{binary_type} has been uploaded before. Skipping upload step.")
         else
           unless upload_status_response.in_progress?
-            UI.message("⌛ Uploading the #{@binary_type}.")
+            UI.message("⌛ Uploading the #{binary_type}.")
             upload_binary(app_id, binary_path, platform)
           end
           MAX_POLLING_RETRIES.times do
             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}.")
+              UI.success("✅ Uploaded the #{binary_type}.")
               break
             elsif upload_status_response.in_progress?
               sleep(POLLING_INTERVAL_SECONDS)
             else
               if !upload_status_response.message.nil?
-                UI.user_error!("#{ErrorMessage.upload_binary_error(@binary_type)}: #{upload_status_response.message}")
+                UI.user_error!("#{ErrorMessage.upload_binary_error(binary_type)}: #{upload_status_response.message}")
               else
-                UI.user_error!(ErrorMessage.upload_binary_error(@binary_type))
+                UI.user_error!(ErrorMessage.upload_binary_error(binary_type))
               end
             end
           end
           unless upload_status_response.success?
-            UI.error("It took longer than expected to process your #{@binary_type}, please try again.")
+            UI.error("It took longer than expected to process your #{binary_type}, please try again.")
             return nil
           end
         end
@@ -177,15 +173,9 @@ module Fastlane
       #   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, upload_token)) do |request|
-            request.headers["Authorization"] = "Bearer " + @auth_token
-          end
-        rescue Faraday::ResourceNotFound
-          UI.user_error!("#{ErrorMessage::INVALID_APP_ID}: #{app_id}")
+        response = connection.get(upload_status_url(app_id, upload_token)) do |request|
+          request.headers[AUTHORIZATION] = "Bearer " + @auth_token
         end
         return UploadStatusResponse.new(response.body)
       end
@@ -212,7 +202,8 @@ module Fastlane
         "#{v1_apps_url(app_id)}/upload_status/#{app_token}"
       end
 
-      def upload_token_format(app_id, project_number, binary_hash)
+      def get_upload_token(project_number, app_id, binary_path)
+        binary_hash = Digest::SHA256.hexdigest(read_binary(binary_path))
         CGI.escape("projects/#{project_number}/apps/#{app_id}/releases/-/binaries/#{binary_hash}")
       end
 
@@ -220,6 +211,7 @@ module Fastlane
         @connection ||= Faraday.new(url: BASE_URL) do |conn|
           conn.response(:json, parser_options: { symbolize_names: true })
           conn.response(:raise_error) # raise_error middleware will run before the json middleware
+          conn.response(:logger, nil, { headers: false, bodies: { response: true }, log_level: :debug }) if @debug
           conn.adapter(Faraday.default_adapter)
         end
       end

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

@@ -14,7 +14,16 @@ module ErrorMessage
   INVALID_PATH = "Could not read content from"
   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"
+  INVALID_RELEASE_NOTES = "Failed to add release notes"
   SERVICE_CREDENTIALS_ERROR = "App Distribution could not generate credentials from the service credentials file specified. Service Account Path"
+  PLAY_ACCOUNT_NOT_LINKED = "This project is not linked to a Google Play account."
+  APP_NOT_PUBLISHED = "This app is not published in the Google Play console."
+  NO_APP_WITH_GIVEN_BUNDLE_ID_IN_PLAY_ACCOUNT = "App with matching package name does not exist in Google Play."
+  PLAY_IAS_TERMS_NOT_ACCEPTED = "You must accept the Play Internal App Sharing (IAS) terms to upload AABs."
+
+  def self.aab_upload_error(aab_state)
+    "Failed to process the AAB: #{aab_state}"
+  end
 
   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}"

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

@@ -4,6 +4,15 @@ module Fastlane
   UI = FastlaneCore::UI unless Fastlane.const_defined?("UI")
   module Helper
     module FirebaseAppDistributionHelper
+      def binary_type_from_path(binary_path)
+        extension = File.extname(binary_path)
+        return :APK if extension == '.apk'
+        return :AAB if extension == '.aab'
+        return :IPA if extension == '.ipa'
+
+        UI.user_error!("Unsupported distribution file format, should be .ipa, .apk or .aab")
+      end
+
       def get_value_from_value_or_file(value, path)
         if (value.nil? || value.empty?) && !path.nil?
           begin

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

@@ -1,5 +1,5 @@
 module Fastlane
   module FirebaseAppDistribution
-    VERSION = "0.2.2.pre.2"
+    VERSION = "0.2.6.pre.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.2.pre.2
+  version: 0.2.6.pre.1
 platform: ruby
 authors:
 - Stefan Natchev
 - Manny Jimenez
 - Alonso Salas Infante
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-09-23 00:00:00.000000000 Z
+date: 2021-03-08 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
@@ -152,6 +152,9 @@ files:
 - lib/fastlane/plugin/firebase_app_distribution.rb
 - lib/fastlane/plugin/firebase_app_distribution/actions/firebase_app_distribution_action.rb
 - lib/fastlane/plugin/firebase_app_distribution/actions/firebase_app_distribution_login.rb
+- lib/fastlane/plugin/firebase_app_distribution/client/aab_certificate.rb
+- lib/fastlane/plugin/firebase_app_distribution/client/app.rb
+- lib/fastlane/plugin/firebase_app_distribution/client/error_response.rb
 - lib/fastlane/plugin/firebase_app_distribution/client/firebase_app_distribution_api_client.rb
 - lib/fastlane/plugin/firebase_app_distribution/helper/firebase_app_distribution_auth_client.rb
 - lib/fastlane/plugin/firebase_app_distribution/helper/firebase_app_distribution_error_message.rb
@@ -162,7 +165,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
@@ -177,8 +180,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.3.1
 requirements: []
-rubygems_version: 3.1.2
-signing_key:
+rubygems_version: 3.1.4
+signing_key: 
 specification_version: 4
 summary: Release your beta builds to Firebase App Distribution. https://firebase.google.com/docs/app-distribution
 test_files: []