class Supply::Uploader

rubocop:disable Metrics/ClassLength

Public Instance Methods

fetch_track_and_release!(track, version_code, status = nil) click to toggle source
# File supply/lib/supply/uploader.rb, line 109
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 version_code

  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
perform_upload() click to toggle source
# File supply/lib/supply/uploader.rb, line 4
def perform_upload
  FastlaneCore::PrintTable.print_values(config: Supply.config, hide_keys: [:issuer], mask_keys: [:json_key_data], title: "Summary for supply #{Fastlane::VERSION}")

  client.begin_edit(package_name: Supply.config[:package_name])

  verify_config!

  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]
  upload_mapping(apk_version_codes)

  track_to_update = Supply.config[:track]

  apk_version_codes.concat(Supply.config[:version_codes_to_retain]) if Supply.config[:version_codes_to_retain]

  if !apk_version_codes.empty?
    # Only update tracks if we have version codes
    # update_track handle setting rollout if needed
    # Updating a track with empty version codes can completely clear out a track
    update_track(apk_version_codes)
  else
    # Only promote or rollout if we don't have version codes
    if Supply.config[:track_promote_to]
      track_to_update = Supply.config[:track_promote_to]
      promote_track
    elsif !Supply.config[:rollout].nil? && Supply.config[:track].to_s != ""
      update_rollout
    end
  end

  perform_upload_meta(apk_version_codes, track_to_update)

  if Supply.config[:validate_only]
    UI.message("Validating all 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...")
    client.commit_current_edit!
    UI.success("Successfully finished the upload to Google Play")
  end
end
perform_upload_meta(version_codes, track_name) click to toggle source
# File supply/lib/supply/uploader.rb, line 76
def perform_upload_meta(version_codes, track_name)
  if (!Supply.config[:skip_upload_metadata] || !Supply.config[:skip_upload_images] || !Supply.config[:skip_upload_changelogs] || !Supply.config[:skip_upload_screenshots]) && metadata_path
    # Use version code from config if version codes is empty and no nil or empty string
    version_codes = [Supply.config[:version_code]] if version_codes.empty?
    version_codes = version_codes.reject do |version_code|
      version_codes.to_s == ""
    end

    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!(track_name, 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, version_code) unless Supply.config[:skip_upload_changelogs]
      end

      upload_changelogs(release_notes, release, track, track_name) unless release_notes.empty?
    end
  end
end
perform_upload_to_internal_app_sharing() click to toggle source
# File supply/lib/supply/uploader.rb, line 48
def perform_upload_to_internal_app_sharing
  download_urls = []

  package_name = Supply.config[:package_name]

  apk_paths = [Supply.config[:apk]] unless (apk_paths = Supply.config[:apk_paths])
  apk_paths.compact!
  apk_paths.each do |apk_path|
    download_url = client.upload_apk_to_internal_app_sharing(package_name, apk_path)
    download_urls << download_url
    UI.success("Successfully uploaded APK to Internal App Sharing URL: #{download_url}")
  end

  aab_paths = [Supply.config[:aab]] unless (aab_paths = Supply.config[:aab_paths])
  aab_paths.compact!
  aab_paths.each do |aab_path|
    download_url = client.upload_bundle_to_internal_app_sharing(package_name, aab_path)
    download_urls << download_url
    UI.success("Successfully uploaded AAB to Internal App Sharing URL: #{download_url}")
  end

  if download_urls.count == 1
    return download_urls.first
  else
    return download_urls
  end
end
promote_track() click to toggle source
# File supply/lib/supply/uploader.rb, line 172
def promote_track
  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
  else
    releases = releases.select do |release|
      release.status == Supply::ReleaseStatus::COMPLETED
    end
  end

  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

  release = releases.first
  track_to = client.tracks(Supply.config[:track_promote_to]).first

  rollout = (Supply.config[:rollout] || 0).to_f
  if rollout > 0 && rollout < 1
    release.status = Supply::ReleaseStatus::IN_PROGRESS
    release.user_fraction = rollout
  else
    release.status = Supply::ReleaseStatus::COMPLETED
    release.user_fraction = nil
  end

  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
update_rollout() click to toggle source
# File supply/lib/supply/uploader.rb, line 126
def update_rollout
  track, release = fetch_track_and_release!(Supply.config[:track], Supply.config[:version_code], Supply::ReleaseStatus::IN_PROGRESS)
  UI.user_error!("Unable to find the requested track - '#{Supply.config[:track]}'") unless track
  UI.user_error!("Unable to find the requested release on track - '#{Supply.config[:track]}'") unless release

  version_code = release.version_codes.first

  UI.message("Updating #{version_code}'s rollout to '#{Supply.config[:rollout]}' on track '#{Supply.config[: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
upload_apks() click to toggle source
# File supply/lib/supply/uploader.rb, line 293
def upload_apks
  apk_paths = [Supply.config[:apk]] unless (apk_paths = Supply.config[:apk_paths])
  apk_paths.compact!

  apk_version_codes = []

  apk_paths.each do |apk_path|
    apk_version_codes.push(upload_binary_data(apk_path))
  end

  return apk_version_codes
end
upload_bundles() click to toggle source
# File supply/lib/supply/uploader.rb, line 316
def upload_bundles
  aab_paths = [Supply.config[:aab]] unless (aab_paths = Supply.config[:aab_paths])
  return [] unless aab_paths
  aab_paths.compact!

  aab_version_codes = []

  aab_paths.each do |aab_path|
    UI.message("Preparing aab at path '#{aab_path}' for upload...")
    bundle_version_code = client.upload_bundle(aab_path)
    aab_version_codes.push(bundle_version_code)
  end

  return aab_version_codes
end
upload_changelog(language, version_code) click to toggle source
# File supply/lib/supply/uploader.rb, line 221
def upload_changelog(language, version_code)
  UI.user_error!("Cannot find changelog because no version code given - please specify :version_code") unless version_code

  path = File.join(Supply.config[:metadata_path], language, Supply::CHANGELOGS_FOLDER_NAME, "#{version_code}.txt")
  changelog_text = ''
  if File.exist?(path)
    UI.message("Updating changelog for '#{version_code}' and language '#{language}'...")
    changelog_text = File.read(path, encoding: 'UTF-8')
  else
    default_changelog_path = File.join(Supply.config[:metadata_path], language, Supply::CHANGELOGS_FOLDER_NAME, "default.txt")
    if File.exist?(default_changelog_path)
      UI.message("Updating changelog for '#{version_code}' and language '#{language}' to default changelog...")
      changelog_text = File.read(default_changelog_path, encoding: 'UTF-8')
    else
      UI.message("Could not find changelog for '#{version_code}' and language '#{language}' at path #{path}...")
    end
  end

  AndroidPublisher::LocalizedText.new(
    language: language,
    text: changelog_text
  )
end
upload_changelogs(release_notes, release, track, track_name) click to toggle source
# File supply/lib/supply/uploader.rb, line 245
def upload_changelogs(release_notes, release, track, track_name)
  release.release_notes = release_notes
  client.upload_changelogs(track, track_name)
end
upload_images(language) click to toggle source
# File supply/lib/supply/uploader.rb, line 263
def upload_images(language)
  Supply::IMAGES_TYPES.each do |image_type|
    search = File.join(metadata_path, language, Supply::IMAGES_FOLDER_NAME, image_type) + ".#{IMAGE_FILE_EXTENSIONS}"
    path = Dir.glob(search, File::FNM_CASEFOLD).last
    next unless path

    UI.message("Uploading image file #{path}...")
    client.upload_image(image_path: File.expand_path(path),
                        image_type: image_type,
                          language: language)
  end
end
upload_mapping(apk_version_codes) click to toggle source
# File supply/lib/supply/uploader.rb, line 306
def upload_mapping(apk_version_codes)
  mapping_paths = [Supply.config[:mapping]] unless (mapping_paths = Supply.config[:mapping_paths])
  mapping_paths.product(apk_version_codes).each do |mapping_path, version_code|
    if mapping_path
      UI.message("Preparing mapping at path '#{mapping_path}', version code #{version_code} for upload...")
      client.upload_mapping(mapping_path, version_code)
    end
  end
end
upload_metadata(language, listing) click to toggle source
# File supply/lib/supply/uploader.rb, line 250
def upload_metadata(language, listing)
  Supply::AVAILABLE_METADATA_FIELDS.each do |key|
    path = File.join(metadata_path, language, "#{key}.txt")
    listing.send("#{key}=".to_sym, File.read(path, encoding: 'UTF-8')) if File.exist?(path)
  end
  begin
    listing.save
  rescue Encoding::InvalidByteSequenceError => ex
    message = (ex.message || '').capitalize
    UI.user_error!("Metadata must be UTF-8 encoded. #{message}")
  end
end
upload_screenshots(language) click to toggle source
# File supply/lib/supply/uploader.rb, line 276
def upload_screenshots(language)
  Supply::SCREENSHOT_TYPES.each do |screenshot_type|
    search = File.join(metadata_path, language, Supply::IMAGES_FOLDER_NAME, screenshot_type, "*.#{IMAGE_FILE_EXTENSIONS}")
    paths = Dir.glob(search, File::FNM_CASEFOLD)
    next unless paths.count > 0

    client.clear_screenshots(image_type: screenshot_type, language: language)

    paths.sort.each do |path|
      UI.message("Uploading screenshot #{path}...")
      client.upload_image(image_path: File.expand_path(path),
                          image_type: screenshot_type,
                            language: language)
    end
  end
end
verify_config!() click to toggle source
# File supply/lib/supply/uploader.rb, line 149
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]) || (Supply.config[:track] && Supply.config[:rollout])
    UI.user_error!("No local metadata, apks, aab, or track to promote were found, make sure to run `fastlane supply init` to setup supply")
  end

  # Can't upload both at apk and aab at same time
  # Need to error out users when there both apks and aabs are detected
  apk_paths = [Supply.config[:apk], Supply.config[:apk_paths]].flatten.compact
  could_upload_apk = !apk_paths.empty? && !Supply.config[:skip_upload_apk]
  could_upload_aab = Supply.config[:aab] && !Supply.config[:skip_upload_aab]
  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

Private Instance Methods

all_languages() click to toggle source

returns only language directories from metadata_path

# File supply/lib/supply/uploader.rb, line 420
def all_languages
  Dir.entries(metadata_path)
     .select { |f| File.directory?(File.join(metadata_path, f)) }
     .reject { |f| f.start_with?('.') }
     .sort { |x, y| x <=> y }
end
client() click to toggle source
# File supply/lib/supply/uploader.rb, line 427
def client
  @client ||= Client.make_from_config
end
find_obbs(apk_path) click to toggle source

@return a map of the obb paths for that apk keyed by their detected expansion file type E.g. { 'main' => 'path/to/main.obb', 'patch' => 'path/to/patch.obb' }

# File supply/lib/supply/uploader.rb, line 451
def find_obbs(apk_path)
  search = File.join(File.dirname(apk_path), '*.obb')
  paths = Dir.glob(search, File::FNM_CASEFOLD)
  expansion_paths = {}
  paths.each do |path|
    type = obb_expansion_file_type(path)
    next unless type
    if expansion_paths[type]
      UI.important("Can only upload one '#{type}' apk expansion. Skipping obb upload entirely.")
      UI.important("If you'd like this to work differently, please submit an issue.")
      return {}
    end
    expansion_paths[type] = path
  end
  expansion_paths
end
metadata_path() click to toggle source
# File supply/lib/supply/uploader.rb, line 431
def metadata_path
  Supply.config[:metadata_path]
end
obb_expansion_file_type(obb_file_path) click to toggle source
# File supply/lib/supply/uploader.rb, line 475
def obb_expansion_file_type(obb_file_path)
  filename = File.basename(obb_file_path, ".obb")
  if filename.include?('main')
    'main'
  elsif filename.include?('patch')
    'patch'
  end
end
update_obb(apk_version_code, expansion_file_type, references_version, file_size) click to toggle source
# File supply/lib/supply/uploader.rb, line 372
def update_obb(apk_version_code, expansion_file_type, references_version, file_size)
  UI.message("Updating '#{expansion_file_type}' expansion file from version '#{references_version}'...")
  client.update_obb(apk_version_code,
                    expansion_file_type,
                    references_version,
                    file_size)
end
update_track(apk_version_codes) click to toggle source
# File supply/lib/supply/uploader.rb, line 380
def update_track(apk_version_codes)
  return if apk_version_codes.empty?

  UI.message("Updating track '#{Supply.config[:track]}'...")

  track_release = AndroidPublisher::TrackRelease.new(
    name: Supply.config[:version_name],
    status: Supply.config[:release_status],
    version_codes: apk_version_codes
  )

  if Supply.config[:rollout]
    rollout = Supply.config[:rollout].to_f
    if rollout > 0 && rollout < 1
      track_release.status = Supply::ReleaseStatus::IN_PROGRESS
      track_release.user_fraction = rollout
    end
  end

  if Supply.config[:in_app_update_priority]
    track_release.in_app_update_priority = Supply.config[:in_app_update_priority].to_i
  end

  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
upload_binary_data(apk_path) click to toggle source

Upload binary apk and obb and corresponding change logs with client

@param [String] apk_path

Path of the apk file to upload.

@return [Integer] The apk version code returned after uploading, or nil if there was a problem

# File supply/lib/supply/uploader.rb, line 341
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)
    UI.user_error!("Could not upload #{apk_path}") unless apk_version_code

    if Supply.config[:obb_main_references_version] && Supply.config[:obb_main_file_size]
      update_obb(apk_version_code,
                 'main',
                 Supply.config[:obb_main_references_version],
                 Supply.config[:obb_main_file_size])
    end

    if Supply.config[:obb_patch_references_version] && Supply.config[:obb_patch_file_size]
      update_obb(apk_version_code,
                 'patch',
                 Supply.config[:obb_patch_references_version],
                 Supply.config[:obb_patch_file_size])
    end

    upload_obbs(apk_path, apk_version_code)
  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
upload_obb(obb_path, expansion_file_type, apk_version_code) click to toggle source
# File supply/lib/supply/uploader.rb, line 468
def upload_obb(obb_path, expansion_file_type, apk_version_code)
  UI.message("Uploading obb file #{obb_path}...")
  client.upload_obb(obb_file_path: obb_path,
                    apk_version_code: apk_version_code,
                    expansion_file_type: expansion_file_type)
end
upload_obbs(apk_path, apk_version_code) click to toggle source

searches for obbs in the directory where the apk is located and upload at most one main and one patch file. Do nothing if it finds more than one of either of them.

# File supply/lib/supply/uploader.rb, line 438
def upload_obbs(apk_path, apk_version_code)
  expansion_paths = find_obbs(apk_path)
  ['main', 'patch'].each do |type|
    if expansion_paths[type]
      upload_obb(expansion_paths[type], type, apk_version_code)
    end
  end
end