fastlane 2.132.0 → 2.135.2

data/supply/lib/supply/options.rb

@@ -5,7 +5,6 @@ module Supply
   class Options
     # rubocop:disable Metrics/PerceivedComplexity
     def self.available_options
-      default_tracks = %w(production beta alpha internal rollout)
       @options ||= [
         FastlaneCore::ConfigItem.new(key: :package_name,
                                      env_name: "SUPPLY_PACKAGE_NAME",
@@ -14,11 +13,37 @@ module Supply
                                      code_gen_sensitive: true,
                                      default_value: CredentialsManager::AppfileConfig.try_fetch_value(:package_name),
                                      default_value_dynamic: true),
+        FastlaneCore::ConfigItem.new(key: :version_name,
+                                     env_name: "SUPPLY_VERSION_NAME",
+                                     short_option: "-n",
+                                     optional: true,
+                                     description: "Version name (used when uploading new apks/aabs) - defaults to 'versionName' in build.gradle or AndroidManifest.xml",
+                                     default_value: CredentialsManager::AppfileConfig.try_fetch_value(:version_name),
+                                     default_value_dynamic: true),
+        FastlaneCore::ConfigItem.new(key: :version_code,
+                                     env_name: "SUPPLY_VERSION_CODE",
+                                     short_option: "-C",
+                                     optional: true,
+                                     type: Integer,
+                                     description: "Version code (used when updating rollout or promoting specific versions)",
+                                     default_value: CredentialsManager::AppfileConfig.try_fetch_value(:version_code),
+                                     default_value_dynamic: true),
+        FastlaneCore::ConfigItem.new(key: :release_status,
+                                     env_name: "SUPPLY_RELEASE_STATUS",
+                                     short_option: "-e",
+                                     optional: true,
+                                     description: "Release status (used when uploading new apks/aabs) - valid values are #{Supply::ReleaseStatus::ALL.join(', ')}",
+                                     default_value: Supply::ReleaseStatus::COMPLETED,
+                                     default_value_dynamic: true,
+                                     verify_block: proc do |value|
+                                                     UI.user_error!("Value must be one of '#{Supply::RELEASE_STATUS}'") unless Supply::ReleaseStatus::ALL.include?(value)
+                                                   end),
         FastlaneCore::ConfigItem.new(key: :track,
                                      short_option: "-a",
                                      env_name: "SUPPLY_TRACK",
-                                     description: "The track of the application to use. The default available tracks are: #{default_tracks.join(', ')}",
-                                     default_value: 'production'),
+                                     description: "The track of the application to use. The default available tracks are: #{Supply::Tracks::DEFAULTS.join(', ')}",
+                                     default_value: Supply::Tracks::DEFAULT,
+                                     type: String),
         FastlaneCore::ConfigItem.new(key: :rollout,
                                      short_option: "-r",
                                      description: "The percentage of the user fraction when uploading to the rollout track",
@@ -104,6 +129,7 @@ module Supply
         FastlaneCore::ConfigItem.new(key: :apk_paths,
                                      env_name: "SUPPLY_APK_PATHS",
                                      conflicting_options: [:apk, :aab, :aab_paths],
+                                     code_gen_sensitive: true,
                                      optional: true,
                                      type: Array,
                                      description: "An array of paths to APK files to upload",
@@ -131,6 +157,7 @@ module Supply
         FastlaneCore::ConfigItem.new(key: :aab_paths,
                                      env_name: "SUPPLY_AAB_PATHS",
                                      conflicting_options: [:apk, :apk_paths, :aab],
+                                     code_gen_sensitive: true,
                                      optional: true,
                                      type: Array,
                                      description: "An array of paths to AAB files to upload",
@@ -146,41 +173,47 @@ module Supply
                                      env_name: "SUPPLY_SKIP_UPLOAD_APK",
                                      optional: true,
                                      description: "Whether to skip uploading APK",
-                                     is_string: false,
+                                     type: Boolean,
                                      default_value: false),
         FastlaneCore::ConfigItem.new(key: :skip_upload_aab,
                                      env_name: "SUPPLY_SKIP_UPLOAD_AAB",
                                      optional: true,
                                      description: "Whether to skip uploading AAB",
-                                     is_string: false,
+                                     type: Boolean,
                                      default_value: false),
         FastlaneCore::ConfigItem.new(key: :skip_upload_metadata,
                                      env_name: "SUPPLY_SKIP_UPLOAD_METADATA",
                                      optional: true,
-                                     description: "Whether to skip uploading metadata",
-                                     is_string: false,
+                                     description: "Whether to skip uploading metadata, changelogs not included",
+                                     type: Boolean,
+                                     default_value: false),
+        FastlaneCore::ConfigItem.new(key: :skip_upload_changelogs,
+                                     env_name: "SUPPLY_SKIP_UPLOAD_CHANGELOGS",
+                                     optional: true,
+                                     description: "Whether to skip uploading changelogs",
+                                     type: Boolean,
                                      default_value: false),
         FastlaneCore::ConfigItem.new(key: :skip_upload_images,
                                      env_name: "SUPPLY_SKIP_UPLOAD_IMAGES",
                                      optional: true,
                                      description: "Whether to skip uploading images, screenshots not included",
-                                     is_string: false,
+                                     type: Boolean,
                                      default_value: false),
         FastlaneCore::ConfigItem.new(key: :skip_upload_screenshots,
                                      env_name: "SUPPLY_SKIP_UPLOAD_SCREENSHOTS",
                                      optional: true,
                                      description: "Whether to skip uploading SCREENSHOTS",
-                                     is_string: false,
+                                     type: Boolean,
                                      default_value: false),
         FastlaneCore::ConfigItem.new(key: :track_promote_to,
                                      env_name: "SUPPLY_TRACK_PROMOTE_TO",
                                      optional: true,
-                                     description: "The track to promote to. The default available tracks are: #{default_tracks.join(', ')}"),
+                                     description: "The track to promote to. The default available tracks are: #{Supply::Tracks::DEFAULTS.join(', ')}"),
         FastlaneCore::ConfigItem.new(key: :validate_only,
                                      env_name: "SUPPLY_VALIDATE_ONLY",
                                      optional: true,
                                      description: "Only validate changes with Google Play rather than actually publish",
-                                     is_string: false,
+                                     type: Boolean,
                                      default_value: false),
         FastlaneCore::ConfigItem.new(key: :mapping,
                                      env_name: "SUPPLY_MAPPING",
@@ -215,7 +248,8 @@ module Supply
                                      env_name: "SUPPLY_CHECK_SUPERSEDED_TRACKS",
                                      optional: true,
                                      description: "Check the other tracks for superseded versions and disable them",
-                                     is_string: false,
+                                     deprecated: "Google Play does this automatically now",
+                                     type: Boolean,
                                      default_value: false),
         FastlaneCore::ConfigItem.new(key: :timeout,
                                      env_name: "SUPPLY_TIMEOUT",
@@ -227,16 +261,18 @@ module Supply
                                      env_name: "SUPPLY_DEACTIVATE_ON_PROMOTE",
                                      optional: true,
                                      description: "When promoting to a new track, deactivate the binary in the origin track",
-                                     is_string: false,
+                                     deprecated: "Google Play does this automatically now",
+                                     type: Boolean,
                                      default_value: true),
         FastlaneCore::ConfigItem.new(key: :version_codes_to_retain,
                                      optional: true,
                                      type: Array,
                                      description: "An array of version codes to retain when publishing a new APK",
                                      verify_block: proc do |version_codes|
+                                       version_codes = version_codes.map(&:to_i)
                                        UI.user_error!("Could not evaluate array from '#{version_codes}'") unless version_codes.kind_of?(Array)
                                        version_codes.each do |version_code|
-                                         UI.user_error!("Version code '#{version_code}' is not an integer") unless version_code.kind_of?(Integer)
+                                         UI.user_error!("Version code '#{version_code}' is not an integer") if version_code == 0
                                        end
                                      end),
         FastlaneCore::ConfigItem.new(key: :obb_main_references_version,

data/supply/lib/supply/release_listing.rb

@@ -0,0 +1,18 @@
+module Supply
+  class ReleaseListing
+    attr_accessor :track
+    attr_accessor :version
+    attr_accessor :versioncodes
+    attr_accessor :language
+    attr_accessor :release_notes
+
+    # Initializes the release listing with the current listing if available
+    def initialize(track, version, versioncodes, language, text)
+      self.track = track
+      self.version = version
+      self.versioncodes = versioncodes
+      self.language = language
+      self.release_notes = text
+    end
+  end
+end

data/supply/lib/supply/setup.rb

@@ -12,16 +12,22 @@ module Supply
 
       client.listings.each do |listing|
         store_metadata(listing)
-        create_screenshots_folder(listing)
         download_images(listing)
       end
 
-      client.apks_version_codes.each do |apk_version_code|
-        client.apk_listings(apk_version_code).each do |apk_listing|
-          store_apk_listing(apk_listing)
+      if Supply.config[:version_name].to_s == ""
+        latest_version = client.latest_version(Supply.config[:track])
+        if latest_version
+          Supply.config[:version_name] = latest_version.name
+        else
+          UI.user_error!("Could not find the latest version to download metadata, images, and screenshots from")
         end
       end
 
+      client.release_listings(Supply.config[:version_name]).each do |release_listing|
+        store_release_listing(release_listing)
+      end
+
       client.abort_current_edit
 
       UI.success("✅  Successfully stored metadata in '#{metadata_path}'")
@@ -43,25 +49,40 @@ module Supply
     def download_images(listing)
       UI.message("🖼️  Downloading images (#{listing.language})")
 
-      # We cannot download existing screenshots as they are compressed
-      # But we can at least download the images
       require 'net/http'
 
-      IMAGES_TYPES.each do |image_type|
-        if ['featureGraphic'].include?(image_type)
-          # we don't get all files in full resolution :(
-          UI.message("📵  Due to a limitation of the Google Play API, there is no way for `supply` to download your existing feature graphic. Please copy your feature graphic to `metadata/android/#{listing.language}/images/featureGraphic.png`")
-          next
-        end
+      allowed_imagetypes = [Supply::IMAGES_TYPES, Supply::SCREENSHOT_TYPES].flatten
 
+      allowed_imagetypes.each do |image_type|
         begin
+          path = File.join(metadata_path, listing.language, IMAGES_FOLDER_NAME, image_type)
+
+          p = Pathname.new(path)
+          if IMAGES_TYPES.include?(image_type) # IMAGE_TYPES are stored in locale/images location
+            FileUtils.mkdir_p(p.dirname.to_s)
+          else # SCREENSHOT_TYPES go under their respective folders.
+            FileUtils.mkdir_p(p.to_s)
+          end
+
           UI.message("Downloading `#{image_type}` for #{listing.language}...")
 
-          url = client.fetch_images(image_type: image_type, language: listing.language).last
-          next unless url
+          urls = client.fetch_images(image_type: image_type, language: listing.language)
+          next if urls.nil? || urls.empty?
+
+          image_counter = 1 # Used to prefix the downloaded files, so order is preserved.
+          urls.each do |url|
+            if IMAGES_TYPES.include?(image_type) # IMAGE_TYPES are stored in locale/images
+              file_path = "#{path}.#{FastImage.type(url)}"
+            else # SCREENSHOT_TYPES are stored in locale/images/<screensho_types>
+              file_path = File.join(path, "#{image_counter}_#{listing.language}.#{FastImage.type(url)}")
+            end
+
+            File.binwrite(file_path, Net::HTTP.get(URI.parse(url)))
+
+            UI.message("\tDownloaded - #{file_path}")
 
-          path = File.join(metadata_path, listing.language, IMAGES_FOLDER_NAME, "#{image_type}.png")
-          File.write(path, Net::HTTP.get(URI.parse(url)))
+            image_counter += 1
+          end
         rescue => ex
           UI.error(ex.to_s)
           UI.error("Error downloading '#{image_type}' for #{listing.language}...")
@@ -69,30 +90,17 @@ module Supply
       end
     end
 
-    def create_screenshots_folder(listing)
-      UI.message("📱  Downloading screenshots (#{listing.language})")
-
-      containing = File.join(metadata_path, listing.language)
-
-      FileUtils.mkdir_p(File.join(containing, IMAGES_FOLDER_NAME))
-      Supply::SCREENSHOT_TYPES.each do |screenshot_type|
-        FileUtils.mkdir_p(File.join(containing, IMAGES_FOLDER_NAME, screenshot_type))
-      end
-
-      UI.message("📵  Due to a limitation of the Google Play API, there is no way for `supply` to download your existing screenshots. Please copy your screenshots into `metadata/android/#{listing.language}/images/`")
-    end
-
-    def store_apk_listing(apk_listing)
-      UI.message("🔨  Downloading changelogs (#{apk_listing.language}, #{apk_listing.apk_version_code})")
+    def store_release_listing(release_listing)
+      UI.message("🔨  Downloading changelogs (#{release_listing.language}, #{release_listing.version})")
 
-      containing = File.join(metadata_path, apk_listing.language, CHANGELOGS_FOLDER_NAME)
+      containing = File.join(metadata_path, release_listing.language, CHANGELOGS_FOLDER_NAME)
       unless File.exist?(containing)
         FileUtils.mkdir_p(containing)
       end
 
-      path = File.join(containing, "#{apk_listing.apk_version_code}.txt")
+      path = File.join(containing, "#{release_listing.version}.txt")
       UI.message("Writing to #{path}...")
-      File.write(path, apk_listing.recent_changes)
+      File.write(path, release_listing.release_notes)
     end
 
     private

data/supply/lib/supply/uploader.rb

@@ -1,4 +1,5 @@
 module Supply
+  # rubocop:disable Metrics/ClassLength
   class Uploader
     def perform_upload
       FastlaneCore::PrintTable.print_values(config: Supply.config, hide_keys: [:issuer], mask_keys: [:json_key_data], title: "Summary for supply #{Fastlane::VERSION}")
@@ -7,22 +8,6 @@ module Supply
 
       verify_config!
 
-      if metadata_path
-        UI.user_error!("Could not find folder #{metadata_path}") unless File.directory?(metadata_path)
-
-        all_languages.each do |language|
-          next if language.start_with?('.') # e.g. . or .. or hidden folders
-          UI.message("Preparing to upload for language '#{language}'...")
-
-          listing = client.listing_for_language(language)
-
-          upload_metadata(language, listing) unless Supply.config[:skip_upload_metadata]
-          upload_images(language) unless Supply.config[:skip_upload_images]
-          upload_screenshots(language) unless Supply.config[:skip_upload_screenshots]
-          upload_changelogs(language) unless Supply.config[:skip_upload_metadata]
-        end
-      end
-
       apk_version_codes = []
       apk_version_codes.concat(upload_apks) unless Supply.config[:skip_upload_apk]
       apk_version_codes.concat(upload_bundles) unless Supply.config[:skip_upload_aab]
@@ -34,19 +19,102 @@ module Supply
       # Updating a track with empty version codes can completely clear out a track
       update_track(apk_version_codes) unless apk_version_codes.empty?
 
+      if !Supply.config[:rollout].nil? && Supply.config[:track].to_s != ""
+        update_rollout
+      end
+
       promote_track if Supply.config[:track_promote_to]
 
       if Supply.config[:validate_only]
-        UI.message("Validating all changes with Google Play...")
+        UI.message("Validating all track and release changes with Google Play...")
+        client.validate_current_edit!
+        UI.success("Successfully validated the upload to Google Play")
+      else
+        UI.message("Uploading all track and release changes to Google Play...")
+        client.commit_current_edit!
+        UI.success("Successfully finished the upload to Google Play")
+      end
+
+      perform_upload_meta(apk_version_codes)
+    end
+
+    def perform_upload_meta(version_codes)
+      client.begin_edit(package_name: Supply.config[:package_name])
+
+      if (!Supply.config[:skip_upload_metadata] || !Supply.config[:skip_upload_images] || !Supply.config[:skip_upload_changelogs] || !Supply.config[:skip_upload_screenshots]) && metadata_path
+        version_codes = [Supply.config[:version_code]] if version_codes.empty?
+        version_codes.each do |version_code|
+          UI.user_error!("Could not find folder #{metadata_path}") unless File.directory?(metadata_path)
+
+          track, release = fetch_track_and_release!(Supply.config[:track], version_code)
+          UI.user_error!("Unable to find the requested track - '#{Supply.config[:track]}'") unless track
+          UI.user_error!("Could not find release for version code '#{version_code}' to update changelog") unless release
+
+          release_notes = []
+          all_languages.each do |language|
+            next if language.start_with?('.') # e.g. . or .. or hidden folders
+            UI.message("Preparing to upload for language '#{language}'...")
+
+            listing = client.listing_for_language(language)
+
+            upload_metadata(language, listing) unless Supply.config[:skip_upload_metadata]
+            upload_images(language) unless Supply.config[:skip_upload_images]
+            upload_screenshots(language) unless Supply.config[:skip_upload_screenshots]
+            release_notes << upload_changelog(language, release.name) unless Supply.config[:skip_upload_changelogs]
+          end
+
+          upload_changelogs(release_notes, release, track) unless release_notes.empty?
+        end
+      end
+
+      if Supply.config[:validate_only]
+        UI.message("Validating all meta changes with Google Play...")
         client.validate_current_edit!
         UI.success("Successfully validated the upload to Google Play")
       else
-        UI.message("Uploading all changes to Google Play...")
+        UI.message("Uploading all meta changes to Google Play...")
         client.commit_current_edit!
         UI.success("Successfully finished the upload to Google Play")
       end
     end
 
+    def fetch_track_and_release!(track, version_code, status = nil)
+      tracks = client.tracks(track)
+      return nil, nil if tracks.empty?
+
+      track = tracks.first
+      releases = track.releases
+      releases = releases.select { |r| r.status == status } if status
+      releases = releases.select { |r| r.version_codes.map(&:to_s).include?(version_code.to_s) }
+
+      if releases.size > 1
+        UI.user_error!("More than one release found in this track. Please specify with the :version_code option to select a release.")
+      end
+
+      return track, releases.first
+    end
+
+    def update_rollout
+      track, release = fetch_track_and_release!(Supply.config[:track], Supply.config[:version_code], Supply::ReleaseStatus::IN_PROGRESS)
+      version_code = release.version_codes.first
+
+      UI.message("Updating #{version_code}'s rollout to '#{Supply.config[:rollout]}' on track '#{Supply.config[:track]}'...")
+      UI.user_error!("Unable to find the requested track - '#{Supply.config[:track]}'") unless track
+
+      if track && release
+        completed = Supply.config[:rollout].to_f == 1
+        release.user_fraction = completed ? nil : Supply.config[:rollout]
+        release.status = Supply::ReleaseStatus::COMPLETED if completed
+
+        # Deleted other version codes if completed because only allowed on completed version in a release
+        track.releases.delete_if { |r| !(r.version_codes || []).map(&:to_s).include?(version_code) } if completed
+      else
+        UI.user_error!("Unable to find version to rollout in track '#{Supply.config[:track]}'")
+      end
+
+      client.update_track(Supply.config[:track], track)
+    end
+
     def verify_config!
       unless metadata_path || Supply.config[:apk] || Supply.config[:apk_paths] || Supply.config[:aab] || Supply.config[:aab_paths] || (Supply.config[:track] && Supply.config[:track_promote_to])
         UI.user_error!("No local metadata, apks, aab, or track to promote were found, make sure to run `fastlane supply init` to setup supply")
@@ -60,32 +128,73 @@ module Supply
       if could_upload_apk && could_upload_aab
         UI.user_error!("Cannot provide both apk(s) and aab - use `skip_upload_apk`, `skip_upload_aab`, or  make sure to remove any existing .apk or .aab files that are no longer needed")
       end
+
+      if Supply.config[:release_status] == Supply::ReleaseStatus::DRAFT && Supply.config[:rollout]
+        UI.user_error!(%(Cannot specify rollout percentage when the release status is set to 'draft'))
+      end
+
+      unless Supply.config[:version_codes_to_retain].nil?
+        Supply.config[:version_codes_to_retain] = Supply.config[:version_codes_to_retain].map(&:to_i)
+      end
     end
 
     def promote_track
-      version_codes = client.track_version_codes(Supply.config[:track])
-      # the actual value passed for the rollout argument does not matter because it will be ignored by the Google Play API
-      # but it has to be between 0.0 and 1.0 to pass the validity check. So we are passing the default value 0.1
-      client.update_track(Supply.config[:track], 0.1, nil) if Supply.config[:deactivate_on_promote]
-      client.update_track(Supply.config[:track_promote_to], Supply.config[:rollout] || 0.1, version_codes)
-    end
+      track_from = client.tracks(Supply.config[:track]).first
+      unless track_from
+        UI.user_error!("Cannot promote from track '#{Supply.config[:track]}' - track doesn't exist")
+      end
+
+      releases = track_from.releases
+      if Supply.config[:version_code].to_s != ""
+        releases = releases.select do |release|
+          release.version_codes.include?(Supply.config[:version_code].to_s)
+        end
+      end
 
-    def upload_changelogs(language)
-      client.apks_version_codes.each do |apk_version_code|
-        upload_changelog(language, apk_version_code)
+      if releases.size == 0
+        UI.user_error!("Track '#{Supply.config[:track]}' doesn't have any releases")
+      elsif releases.size > 1
+        UI.user_error!("Track '#{Supply.config[:track]}' has more than one release - use :version_code to filter the release to promote")
       end
-      client.aab_version_codes.each do |aab_version_code|
-        upload_changelog(language, aab_version_code)
+
+      release = track_from.releases.first
+      track_to = client.tracks(Supply.config[:track_promote_to]).first
+
+      if track_to
+        # Its okay to set releases to an array containing the newest release
+        # Google Play will keep previous releases there this release is a partial rollout
+        track_to.releases = [release]
+      else
+        track_to = AndroidPublisher::Track.new(
+          track: Supply.config[:track_promote_to],
+          releases: [release]
+        )
       end
+
+      client.update_track(Supply.config[:track_promote_to], track_to)
     end
 
-    def upload_changelog(language, version_code)
-      path = File.join(metadata_path, language, Supply::CHANGELOGS_FOLDER_NAME, "#{version_code}.txt")
+    def upload_changelog(language, version_name)
+      UI.user_error!("Cannot find changelog because no version name given - please specify :version_name") unless version_name
+
+      path = File.join(Supply.config[:metadata_path], language, Supply::CHANGELOGS_FOLDER_NAME, "#{version_name}.txt")
+      changelog_text = ''
       if File.exist?(path)
-        UI.message("Updating changelog for code version '#{version_code}' and language '#{language}'...")
-        apk_listing = ApkListing.new(File.read(path, encoding: 'UTF-8'), language, version_code)
-        client.update_apk_listing_for_language(apk_listing)
+        UI.message("Updating changelog for '#{version_name}' and language '#{language}'...")
+        changelog_text = File.read(path, encoding: 'UTF-8')
+      else
+        UI.message("Could not find changelog for '#{version_name}' and language '#{language}' at path #{path}...")
       end
+
+      AndroidPublisher::LocalizedText.new({
+        language: language,
+        text: changelog_text
+      })
+    end
+
+    def upload_changelogs(release_notes, release, track)
+      release.release_notes = release_notes
+      client.upload_changelogs(track, Supply.config[:track])
     end
 
     def upload_metadata(language, listing)
@@ -163,14 +272,6 @@ module Supply
       aab_paths.each do |aab_path|
         UI.message("Preparing aab at path '#{aab_path}' for upload...")
         bundle_version_code = client.upload_bundle(aab_path)
-
-        if metadata_path
-          all_languages.each do |language|
-            next if language.start_with?('.') # e.g. . or .. or hidden folders
-            upload_changelog(language, bundle_version_code)
-          end
-        end
-
         aab_version_codes.push(bundle_version_code)
       end
 
@@ -188,6 +289,7 @@ module Supply
     # @return [Integer] The apk version code returned after uploading, or nil if there was a problem
     def upload_binary_data(apk_path)
       apk_version_code = nil
+
       if apk_path
         UI.message("Preparing apk at path '#{apk_path}' for upload...")
         apk_version_code = client.upload_apk(apk_path)
@@ -208,16 +310,11 @@ module Supply
         end
 
         upload_obbs(apk_path, apk_version_code)
-
-        if metadata_path
-          all_languages.each do |language|
-            next if language.start_with?('.') # e.g. . or .. or hidden folders
-            upload_changelog(language, apk_version_code)
-          end
-        end
       else
         UI.message("No apk file found, you can pass the path to your apk using the `apk` option")
       end
+
+      UI.message("\tVersion Code: #{apk_version_code}")
       apk_version_code
     end
 
@@ -230,55 +327,35 @@ module Supply
     end
 
     def update_track(apk_version_codes)
-      UI.message("Updating track '#{Supply.config[:track]}'...")
-      check_superseded_tracks(apk_version_codes) if Supply.config[:check_superseded_tracks]
-
-      if Supply.config[:track].eql?("rollout")
-        client.update_track(Supply.config[:track], Supply.config[:rollout] || 0.1, apk_version_codes)
-      else
-        client.update_track(Supply.config[:track], 1.0, apk_version_codes)
-      end
-    end
+      return if apk_version_codes.empty?
 
-    # Remove any version codes that is:
-    #  - Lesser than the greatest of any later (i.e. production) track
-    #  - Or lesser than the currently being uploaded if it's in an earlier (i.e. alpha) track
-    def check_superseded_tracks(apk_version_codes)
-      UI.message("Checking superseded tracks, uploading '#{apk_version_codes}' to '#{Supply.config[:track]}'...")
-      max_apk_version_code = apk_version_codes.max
-      max_tracks_version_code = nil
-
-      tracks = ["production", "rollout", "beta", "alpha", "internal"]
-      config_track_index = tracks.index(Supply.config[:track])
-
-      # Custom "closed" tracks are now allowed (https://support.google.com/googleplay/android-developer/answer/3131213)
-      # Custom tracks have an equal level with alpha (alpha is considered a closed track as well)
-      # If a track index is not found, we will assume is a custom track so an alpha index is given
-      config_track_index = tracks.index("alpha") unless config_track_index
-
-      tracks.each_index do |track_index|
-        track = tracks[track_index]
-        track_version_codes = client.track_version_codes(track).sort
-        UI.verbose("Found '#{track_version_codes}' on track '#{track}'")
-
-        next if track_index.eql?(config_track_index)
-        next if track_version_codes.empty?
-
-        if max_tracks_version_code.nil?
-          max_tracks_version_code = track_version_codes.max
-        end
+      UI.message("Updating track '#{Supply.config[:track]}'...")
 
-        removed_version_codes = track_version_codes.take_while do |v|
-          v < max_tracks_version_code || (v < max_apk_version_code && track_index > config_track_index)
-        end
+      track_release = AndroidPublisher::TrackRelease.new(
+        name: Supply.config[:version_name],
+        status: Supply.config[:release_status],
+        version_codes: apk_version_codes
+      )
 
-        next if removed_version_codes.empty?
+      if Supply.config[:rollout]
+        track_release.status = Supply::ReleaseStatus::IN_PROGRESS
+        track_release.user_fraction = Supply.config[:rollout].to_f
+      end
 
-        keep_version_codes = track_version_codes - removed_version_codes
-        max_tracks_version_code = keep_version_codes[0] unless keep_version_codes.empty?
-        client.update_track(track, 1.0, keep_version_codes)
-        UI.message("Superseded track '#{track}', removed '#{removed_version_codes}'")
+      tracks = client.tracks(Supply.config[:track])
+      track = tracks.first
+      if track
+        # Its okay to set releases to an array containing the newest release
+        # Google Play will keep previous releases there this release is a partial rollout
+        track.releases = [track_release]
+      else
+        track = AndroidPublisher::Track.new(
+          track: Supply.config[:track],
+          releases: [track_release]
+        )
       end
+
+      client.update_track(Supply.config[:track], track)
     end
 
     # returns only language directories from metadata_path
@@ -346,4 +423,5 @@ module Supply
       end
     end
   end
+  # rubocop:enable Metrics/ClassLength
 end