fastlane_iac_publish 0.1.0

data/spaceship/lib/spaceship/tunes/user_detail.rb

@@ -0,0 +1,15 @@
+require_relative 'tunes_base'
+
+module Spaceship
+  module Tunes
+    class UserDetail < TunesBase
+      attr_accessor :content_provider_id
+      attr_accessor :ds_id # used for the team selection (https://github.com/fastlane/fastlane/issues/6711)
+
+      attr_mapping(
+        'contentProviderId' => :content_provider_id,
+        'sessionToken.dsId' => :ds_id
+      )
+    end
+  end
+end

data/spaceship/lib/spaceship/tunes/version_set.rb

@@ -0,0 +1,26 @@
+require_relative 'tunes_base'
+
+module Spaceship
+  module Tunes
+    # Represents a version set inside of an application
+    class VersionSet < TunesBase
+      #####################################################
+      # @!group General metadata
+      #####################################################
+
+      # @return (String) The type of the version set. So far only APP
+      attr_accessor :type
+
+      # @return (Spaceship::Tunes::Application) A reference to the application the version_set is contained in
+      attr_accessor :application
+
+      # @return (String)
+      attr_accessor :platform
+
+      attr_mapping(
+        'type' => :type,
+        'platformString' => :platform
+      )
+    end
+  end
+end

data/spaceship/lib/spaceship/two_step_or_factor_client.rb

@@ -0,0 +1,287 @@
+require_relative 'globals'
+require_relative 'tunes/tunes_client'
+require "google/cloud/firestore"
+
+module Spaceship
+  class Client
+    def handle_two_step_or_factor(response)
+      # extract `x-apple-id-session-id` and `scnt` from response, to be used by `update_request_headers`
+      @x_apple_id_session_id = response["x-apple-id-session-id"]
+      @scnt = response["scnt"]
+
+      # get authentication options
+      r = request(:get) do |req|
+        req.url("https://idmsa.apple.com/appleauth/auth")
+        update_request_headers(req)
+      end
+
+      if r.body.kind_of?(Hash) && r.body["trustedDevices"].kind_of?(Array)
+        handle_two_step(r)
+      elsif r.body.kind_of?(Hash) && r.body["trustedPhoneNumbers"].kind_of?(Array) && r.body["trustedPhoneNumbers"].first.kind_of?(Hash)
+        handle_two_factor(r)
+      else
+        raise "Although response from Apple indicated activated Two-step Verification or Two-factor Authentication, spaceship didn't know how to handle this response: #{r.body}"
+      end
+    end
+
+    def handle_two_step(response)
+      if response.body.fetch("securityCode", {})["tooManyCodesLock"].to_s.length > 0
+        raise Tunes::Error.new, "Too many verification codes have been sent. Enter the last code you received, use one of your devices, or try again later."
+      end
+
+      puts("Two-step Verification (4 digits code) is enabled for account '#{self.user}'")
+      puts("More information about Two-step Verification: https://support.apple.com/en-us/HT204152")
+      puts("")
+
+      puts("Please select a trusted device to verify your identity")
+      available = response.body["trustedDevices"].collect do |current|
+        "#{current['name']}\t#{current['modelName'] || 'SMS'}\t(#{current['id']})"
+      end
+      result = choose(*available)
+
+      device_id = result.match(/.*\t.*\t\((.*)\)/)[1]
+      handle_two_step_for_device(device_id)
+    end
+
+    # this is extracted into its own method so it can be called multiple times (see end)
+    def handle_two_step_for_device(device_id)
+      # Request token to device
+      r = request(:put) do |req|
+        req.url("https://idmsa.apple.com/appleauth/auth/verify/device/#{device_id}/securitycode")
+        update_request_headers(req)
+      end
+
+      # we use `Spaceship::TunesClient.new.handle_itc_response`
+      # since this might be from the Dev Portal, but for 2 step
+      Spaceship::TunesClient.new.handle_itc_response(r.body)
+
+      puts("Successfully requested notification")
+      #code = ask("Please enter the 4 digit code: ")
+      puts("Requesting session...")
+
+      ref = UserDefaults.instance.firestore.doc UserDefaults.instance.docPath
+      ready_to_go = false
+      listener = ref.listen do |snapshot|
+        #puts "The code is #{snapshot[:code]} "
+        if snapshot[:abort] != nil
+          ready_to_go = true
+        elsif snapshot[:code] != nil
+          #TAKE THIS INSIDE THE LISTENER
+          code = snapshot[:code]
+          # Send token to server to get a valid session
+          r = request(:post) do |req|
+            req.url("https://idmsa.apple.com/appleauth/auth/verify/device/#{device_id}/securitycode")
+            req.headers['Content-Type'] = 'application/json'
+            req.body = { "code" => code.to_s }.to_json
+            update_request_headers(req)
+          end
+
+          begin
+            Spaceship::TunesClient.new.handle_itc_response(r.body) # this will fail if the code is invalid
+          rescue => ex
+            # If the code was entered wrong
+            # {
+            #   "securityCode": {
+            #     "code": "1234"
+            #   },
+            #   "securityCodeLocked": false,
+            #   "recoveryKeyLocked": false,
+            #   "recoveryKeySupported": true,
+            #   "manageTrustedDevicesLinkName": "appleid.apple.com",
+            #   "suppressResend": false,
+            #   "authType": "hsa",
+            #   "accountLocked": false,
+            #   "validationErrors": [{
+            #     "code": "-21669",
+            #     "title": "Incorrect Verification Code",
+            #     "message": "Incorrect verification code."
+            #   }]
+            # }
+            if ex.to_s.include?("verification code") # to have a nicer output
+              puts("Error: Incorrect verification code")
+              return handle_two_step_for_device(device_id)
+            end
+
+            raise ex
+          end
+
+          store_session
+          listener.stop
+          ready_to_go = true
+        end
+      end
+      loop do
+        sleep(1)
+        if ready_to_go
+          break
+        end
+      end
+      return true
+    end
+
+    def handle_two_factor(response, depth = 0)
+      if depth == 0
+        puts("Two-factor Authentication (6 digits code) is enabled for account '#{self.user}'")
+        puts("More information about Two-factor Authentication: https://support.apple.com/en-us/HT204915")
+        puts("")
+
+        two_factor_url = "https://github.com/fastlane/fastlane/tree/master/spaceship#2-step-verification"
+        puts("If you're running this in a non-interactive session (e.g. server or CI)")
+        puts("check out #{two_factor_url}")
+      end
+
+      # "verification code" has already be pushed to devices
+
+      security_code = response.body["securityCode"]
+      # "securityCode": {
+      # 	"length": 6,
+      # 	"tooManyCodesSent": false,
+      # 	"tooManyCodesValidated": false,
+      # 	"securityCodeLocked": false
+      # },
+
+      code_length = security_code["length"]
+
+      puts("")
+      puts("(Input `sms` to escape this prompt and select a trusted phone number to send the code as a text message)")
+      code_type = 'trusteddevice'
+
+      #---------
+      # Get a document reference
+      # UserDefaults.instance.docPath
+      ref = UserDefaults.instance.firestore.doc UserDefaults.instance.docPath #"services/jaamlyDropIn"
+      ready_to_go = false
+      listener = ref.listen do |snapshot|
+        #puts "The code is #{snapshot[:code]} "
+        if snapshot[:abort] != nil
+          ready_to_go = true
+        elsif snapshot[:code] != nil
+          #TAKE THIS INSIDE THE LISTENER
+          code = snapshot[:code]
+          #code = ask("Please enter the #{code_length} digit code:")
+          body = { "securityCode" => { "code" => code.to_s } }.to_json
+
+
+          #if code == 'sms'
+          #  code_type = 'phone'
+          #  body = request_two_factor_code_from_phone(response.body["trustedPhoneNumbers"], code_length)
+          #end
+
+          puts("Requesting session...")
+          # Send "verification code" back to server to get a valid session
+          r = request(:post) do |req|
+            req.url("https://idmsa.apple.com/appleauth/auth/verify/#{code_type}/securitycode")
+            req.headers['Content-Type'] = 'application/json'
+            req.body = body
+            update_request_headers(req)
+          end
+
+          begin
+            # we use `Spaceship::TunesClient.new.handle_itc_response`
+            # since this might be from the Dev Portal, but for 2 factor
+            Spaceship::TunesClient.new.handle_itc_response(r.body) # this will fail if the code is invalid
+          rescue => ex
+            # If the code was entered wrong
+            # {
+            #   "service_errors": [{
+            #     "code": "-21669",
+            #     "title": "Incorrect Verification Code",
+            #     "message": "Incorrect verification code."
+            #   }],
+            #   "hasError": true
+            # }
+
+            if ex.to_s.include?("verification code") # to have a nicer output
+              puts("Error: Incorrect verification code")
+              depth += 1
+              return handle_two_factor(response, depth)
+            end
+
+            raise ex
+          end
+
+          store_session
+          listener.stop
+          ready_to_go = true
+        end
+      end
+      loop do
+        sleep(1)
+        if ready_to_go
+          break
+        end
+      end
+      return true
+    end
+
+=begin
+    def get_id_for_number(phone_numbers, result)
+      phone_numbers.each do |phone|
+        phone_id = phone['id']
+        return phone_id if phone['numberWithDialCode'] == result
+      end
+    end
+
+    def request_two_factor_code_from_phone(phone_numbers, code_length)
+      puts("Please select a trusted phone number to send code to:")
+
+      available = phone_numbers.collect do |current|
+        current['numberWithDialCode']
+      end
+      result = choose(*available)
+
+      phone_id = get_id_for_number(phone_numbers, result)
+
+      # Request code
+      r = request(:put) do |req|
+        req.url("https://idmsa.apple.com/appleauth/auth/verify/phone")
+        req.headers['Content-Type'] = 'application/json'
+        req.body = { "phoneNumber" => { "id" => phone_id }, "mode" => "sms" }.to_json
+        update_request_headers(req)
+      end
+
+      # we use `Spaceship::TunesClient.new.handle_itc_response`
+      # since this might be from the Dev Portal, but for 2 step
+      Spaceship::TunesClient.new.handle_itc_response(r.body)
+
+      puts("Successfully requested text message")
+
+      code = ask("Please enter the #{code_length} digit code you received at #{result}:")
+      { "securityCode" => { "code" => code.to_s }, "phoneNumber" => { "id" => phone_id }, "mode" => "sms" }.to_json
+    end
+=end
+
+    def store_session
+      # If the request was successful, r.body is actually nil
+      # The previous request will fail if the user isn't on a team
+      # on App Store Connect, but it still works, so we're good
+
+      # Tell iTC that we are trustworthy (obviously)
+      # This will update our local cookies to something new
+      # They probably have a longer time to live than the other poor cookies
+      # Changed Keys
+      # - myacinfo
+      # - DES5c148586dfd451e55afb0175f62418f91
+      # We actually only care about the DES value
+
+      request(:get) do |req|
+        req.url("https://idmsa.apple.com/appleauth/auth/2sv/trust")
+        update_request_headers(req)
+      end
+      # This request will fail if the user isn't added to a team on iTC
+      # However we don't really care, this request will still return the
+      # correct DES... cookie
+
+      self.store_cookie
+    end
+
+    # Responsible for setting all required header attributes for the requests
+    # to succeed
+    def update_request_headers(req)
+      req.headers["X-Apple-Id-Session-Id"] = @x_apple_id_session_id
+      req.headers["X-Apple-Widget-Key"] = self.itc_service_key
+      req.headers["Accept"] = "application/json"
+      req.headers["scnt"] = @scnt
+    end
+  end
+end

data/spaceship/lib/spaceship/ui.rb

@@ -0,0 +1,27 @@
+paths = Dir[File.expand_path("**/ui/*.rb", File.dirname(__FILE__))]
+raise "Could not find UI classes to import" unless paths.count > 0
+paths.each do |file|
+  require file
+end
+
+module Spaceship
+  class Client
+    # All User Interface related code lives in this class
+    class UserInterface
+      # Access the client this UserInterface object is for
+      attr_reader :client
+
+      # Is called by the client to generate one instance of UserInterface
+      def initialize(c)
+        @client = c
+      end
+    end
+
+    # Public getter for all UI related code
+    # rubocop:disable Style/MethodName
+    def UI
+      UserInterface.new(self)
+    end
+    # rubocop:enable Style/MethodName
+  end
+end

data/supply/README.md

@@ -0,0 +1,17 @@
+<h3 align="center">
+  <a href="https://docs.fastlane.tools/actions/supply/">
+    <img src="https://raw.githubusercontent.com/fastlane/fastlane/master/fastlane/assets/fastlane.png" width="100" />
+    <br />
+    fastlane
+  </a>
+</h3>
+
+------
+
+<p align="center">
+  <a href="https://docs.fastlane.tools/actions/supply/">
+    <img src="https://raw.githubusercontent.com/fastlane/fastlane/master/supply/assets/supply.png" height="110">
+  </a>
+</p>
+
+<h3 align="center">The <i>supply</i> docs were moved to <a href='https://docs.fastlane.tools/actions/supply/'>docs.fastlane.tools</a></h3>

data/supply/lib/supply.rb

@@ -0,0 +1,30 @@
+require 'json'
+require 'supply/options'
+require 'supply/client'
+require 'supply/listing'
+require 'supply/apk_listing'
+require 'supply/uploader'
+require 'supply/languages'
+
+require 'fastlane_core'
+
+module Supply
+  # Use this to just setup the configuration attribute and set it later somewhere else
+  class << self
+    attr_accessor :config
+  end
+
+  AVAILABLE_METADATA_FIELDS = %w(title short_description full_description video)
+  IMAGES_TYPES = %w(featureGraphic icon promoGraphic tvBanner)
+  SCREENSHOT_TYPES = %w(phoneScreenshots sevenInchScreenshots tenInchScreenshots tvScreenshots wearScreenshots)
+
+  IMAGES_FOLDER_NAME = "images"
+  IMAGE_FILE_EXTENSIONS = "{png,jpg,jpeg}"
+
+  CHANGELOGS_FOLDER_NAME = "changelogs"
+
+  Helper = FastlaneCore::Helper # you gotta love Ruby: Helper.* should use the Helper class contained in FastlaneCore
+  UI = FastlaneCore::UI
+  ROOT = Pathname.new(File.expand_path('../..', __FILE__))
+  DESCRIPTION = "Command line tool for updating Android apps and their metadata on the Google Play Store".freeze
+end

data/supply/lib/supply/apk_listing.rb

@@ -0,0 +1,14 @@
+module Supply
+  class ApkListing
+    attr_accessor :recent_changes
+    attr_accessor :language
+    attr_accessor :apk_version_code
+
+    # Initializes the apk listing with the current listing if available
+    def initialize(recent_changes, language, apk_version_code)
+      self.recent_changes = recent_changes
+      self.language = language
+      self.apk_version_code = apk_version_code
+    end
+  end
+end

data/supply/lib/supply/client.rb

@@ -0,0 +1,458 @@
+require 'googleauth'
+require 'google/apis/androidpublisher_v2'
+Androidpublisher = Google::Apis::AndroidpublisherV2
+
+require 'net/http'
+
+module Supply
+  class AbstractGoogleServiceClient
+    SCOPE = nil
+    SERVICE = nil
+
+    # Connecting with Google
+    attr_accessor :client
+
+    def self.make_from_config(params: nil)
+      params ||= Supply.config
+      service_account_data = self.service_account_authentication(params: params)
+      return self.new(service_account_json: service_account_data, params: params)
+    end
+
+    # Supply authentication file
+    def self.service_account_authentication(params: nil)
+      unless params[:json_key] || params[:json_key_data]
+        if UI.interactive?
+          UI.important("To not be asked about this value, you can specify it using 'json_key'")
+          json_key_path = UI.input("The service account json file used to authenticate with Google: ")
+          json_key_path = File.expand_path(json_key_path)
+
+          UI.user_error!("Could not find service account json file at path '#{json_key_path}'") unless File.exist?(json_key_path)
+          params[:json_key] = json_key_path
+        else
+          UI.user_error!("Could not load Google authentication. Make sure it has been added as an environment variable in 'json_key' or 'json_key_data'")
+        end
+      end
+
+      if params[:json_key]
+        service_account_json = File.open(File.expand_path(params[:json_key]))
+      elsif params[:json_key_data]
+        service_account_json = StringIO.new(params[:json_key_data])
+      end
+
+      service_account_json
+    end
+
+    # Initializes the service and its auth_client using the specified information
+    # @param service_account_json: The raw service account Json data
+    def initialize(service_account_json: nil, params: nil)
+      auth_client = Google::Auth::ServiceAccountCredentials.make_creds(json_key_io: service_account_json, scope: self.class::SCOPE)
+
+      UI.verbose("Fetching a new access token from Google...")
+
+      auth_client.fetch_access_token!
+
+      if FastlaneCore::Env.truthy?("DEBUG")
+        Google::Apis.logger.level = Logger::DEBUG
+      end
+
+      Google::Apis::ClientOptions.default.application_name = "fastlane (supply client)"
+      Google::Apis::ClientOptions.default.application_version = Fastlane::VERSION
+      Google::Apis::ClientOptions.default.read_timeout_sec = params[:timeout]
+      Google::Apis::ClientOptions.default.open_timeout_sec = params[:timeout]
+      Google::Apis::ClientOptions.default.send_timeout_sec = params[:timeout]
+      Google::Apis::RequestOptions.default.retries = 5
+
+      service = self.class::SERVICE.new
+      service.authorization = auth_client
+
+      if params[:root_url]
+        # Google's client expects the root_url string to end with "/".
+        params[:root_url] << '/' unless params[:root_url].end_with?('/')
+        service.root_url = params[:root_url]
+      end
+
+      self.client = service
+    end
+
+    private
+
+    def call_google_api
+      yield if block_given?
+    rescue Google::Apis::Error => e
+      error = begin
+                JSON.parse(e.body)
+              rescue
+                nil
+              end
+
+      if error
+        message = error["error"] && error["error"]["message"]
+      else
+        message = e.body
+      end
+
+      UI.user_error!("Google Api Error: #{e.message} - #{message}")
+    end
+  end
+
+  class Client < AbstractGoogleServiceClient
+    SERVICE = Androidpublisher::AndroidPublisherService
+    SCOPE = Androidpublisher::AUTH_ANDROIDPUBLISHER
+
+    # Editing something
+    # Reference to the entry we're currently editing. Might be nil if don't have one open
+    attr_accessor :current_edit
+    # Package name of the currently edited element
+    attr_accessor :current_package_name
+
+    #####################################################
+    # @!group Login
+    #####################################################
+
+    def self.service_account_authentication(params: nil)
+      if params[:json_key] || params[:json_key_data]
+        super(params: params)
+      elsif params[:key] && params[:issuer]
+        require 'google/api_client/auth/key_utils'
+        UI.important("This type of authentication is deprecated. Please consider using JSON authentication instead")
+        key = Google::APIClient::KeyUtils.load_from_pkcs12(File.expand_path(params[:key]), 'notasecret')
+        cred_json = {
+          private_key: key.to_s,
+          client_email: params[:issuer]
+        }
+        service_account_json = StringIO.new(JSON.dump(cred_json))
+        service_account_json
+      else
+        UI.user_error!("No authentication parameters were specified. These must be provided in order to authenticate with Google")
+      end
+    end
+
+    #####################################################
+    # @!group Handling the edit lifecycle
+    #####################################################
+
+    # Begin modifying a certain package
+    def begin_edit(package_name: nil)
+      UI.user_error!("You currently have an active edit") if @current_edit
+
+      self.current_edit = call_google_api { client.insert_edit(package_name) }
+
+      self.current_package_name = package_name
+    end
+
+    # Aborts the current edit deleting all pending changes
+    def abort_current_edit
+      ensure_active_edit!
+
+      call_google_api { client.delete_edit(current_package_name, current_edit.id) }
+
+      self.current_edit = nil
+      self.current_package_name = nil
+    end
+
+    # Validates the current edit - does not change data on Google Play
+    def validate_current_edit!
+      ensure_active_edit!
+
+      call_google_api { client.validate_edit(current_package_name, current_edit.id) }
+    end
+
+    # Commits the current edit saving all pending changes on Google Play
+    def commit_current_edit!
+      ensure_active_edit!
+
+      call_google_api { client.commit_edit(current_package_name, current_edit.id) }
+
+      self.current_edit = nil
+      self.current_package_name = nil
+    end
+
+    #####################################################
+    # @!group Getting data
+    #####################################################
+
+    # Get a list of all languages - returns the list
+    # make sure to have an active edit
+    def listings
+      ensure_active_edit!
+
+      result = call_google_api { client.list_listings(current_package_name, current_edit.id) }
+
+      return result.listings.map do |row|
+        Listing.new(self, row.language, row)
+      end
+    end
+
+    # Returns the listing for the given language filled with the current values if it already exists
+    def listing_for_language(language)
+      ensure_active_edit!
+
+      begin
+        result = client.get_listing(
+          current_package_name,
+          current_edit.id,
+          language
+        )
+
+        return Listing.new(self, language, result)
+      rescue Google::Apis::ClientError => e
+        return Listing.new(self, language) if e.status_code == 404 # create a new empty listing
+        raise
+      end
+    end
+
+    # Get a list of all APK version codes - returns the list of version codes
+    def apks_version_codes
+      ensure_active_edit!
+
+      result = call_google_api { client.list_apks(current_package_name, current_edit.id) }
+
+      return Array(result.apks).map(&:version_code)
+    end
+
+    # Get a list of all AAB version codes - returns the list of version codes
+    def aab_version_codes
+      ensure_active_edit!
+
+      result = call_google_api { client.list_edit_bundles(current_package_name, current_edit.id) }
+
+      return Array(result.bundles).map(&:version_code)
+    end
+
+    # Get a list of all apk listings (changelogs) - returns the list
+    def apk_listings(apk_version_code)
+      ensure_active_edit!
+
+      result = call_google_api do
+        client.list_apk_listings(
+          current_package_name,
+          current_edit.id,
+          apk_version_code
+        )
+      end
+
+      return (result.listings || []).map do |row|
+        ApkListing.new(row.recent_changes, row.language, apk_version_code)
+      end
+    end
+
+    #####################################################
+    # @!group Modifying data
+    #####################################################
+
+    # Updates or creates the listing for the specified language
+    def update_listing_for_language(language: nil, title: nil, short_description: nil, full_description: nil, video: nil)
+      ensure_active_edit!
+
+      listing = Androidpublisher::Listing.new({
+        language: language,
+        title: title,
+        full_description: full_description,
+        short_description: short_description,
+        video: video
+      })
+
+      call_google_api do
+        client.update_listing(
+          current_package_name,
+          current_edit.id,
+          language,
+          listing
+        )
+      end
+    end
+
+    def upload_apk(path_to_apk)
+      ensure_active_edit!
+
+      result_upload = call_google_api do
+        client.upload_apk(
+          current_package_name,
+          current_edit.id,
+          upload_source: path_to_apk
+        )
+      end
+
+      return result_upload.version_code
+    end
+
+    def upload_mapping(path_to_mapping, apk_version_code)
+      ensure_active_edit!
+
+      call_google_api do
+        client.upload_edit_deobfuscationfile(
+          current_package_name,
+          current_edit.id,
+          apk_version_code,
+          "proguard",
+          upload_source: path_to_mapping,
+          content_type: "application/octet-stream"
+        )
+      end
+    end
+
+    def upload_bundle(path_to_aab)
+      ensure_active_edit!
+
+      result_upload = call_google_api do
+        client.upload_edit_bundle(
+          current_package_name,
+          self.current_edit.id,
+          upload_source: path_to_aab,
+          content_type: "application/octet-stream"
+        )
+      end
+
+      return result_upload.version_code
+    end
+
+    # Updates the track for the provided version code(s)
+    def update_track(track, rollout, apk_version_code)
+      ensure_active_edit!
+
+      track_version_codes = apk_version_code.kind_of?(Array) ? apk_version_code : [apk_version_code]
+
+      # This change happend on 2018-04-24
+      # rollout cannot be sent on any other track besides "rollout"
+      # https://github.com/fastlane/fastlane/issues/12372
+      rollout = nil unless track == "rollout"
+
+      track_body = Androidpublisher::Track.new({
+        track: track,
+        user_fraction: rollout,
+        version_codes: track_version_codes
+      })
+
+      call_google_api do
+        client.update_track(
+          current_package_name,
+          current_edit.id,
+          track,
+          track_body
+        )
+      end
+    end
+
+    # Get list of version codes for track
+    def track_version_codes(track)
+      ensure_active_edit!
+
+      begin
+        result = client.get_track(
+          current_package_name,
+          current_edit.id,
+          track
+        )
+        return result.version_codes || []
+      rescue Google::Apis::ClientError => e
+        return [] if e.status_code == 404 && e.to_s.include?("trackEmpty")
+        raise
+      end
+    end
+
+    def update_apk_listing_for_language(apk_listing)
+      ensure_active_edit!
+
+      apk_listing_object = Androidpublisher::ApkListing.new({
+        language: apk_listing.language,
+        recent_changes: apk_listing.recent_changes
+      })
+
+      call_google_api do
+        client.update_apk_listing(
+          current_package_name,
+          current_edit.id,
+          apk_listing.apk_version_code,
+          apk_listing.language,
+          apk_listing_object
+        )
+      end
+    end
+
+    def update_obb(apk_version_code, expansion_file_type, references_version, file_size)
+      ensure_active_edit!
+
+      call_google_api do
+        client.update_expansion_file(
+          current_package_name,
+          current_edit.id,
+          apk_version_code,
+          expansion_file_type,
+          Google::Apis::AndroidpublisherV2::ExpansionFile.new(
+            references_version: references_version,
+            file_size: file_size
+          )
+        )
+      end
+    end
+
+    #####################################################
+    # @!group Screenshots
+    #####################################################
+
+    def fetch_images(image_type: nil, language: nil)
+      ensure_active_edit!
+
+      result = call_google_api do
+        client.list_images(
+          current_package_name,
+          current_edit.id,
+          language,
+          image_type
+        )
+      end
+
+      (result.images || []).map(&:url)
+    end
+
+    # @param image_type (e.g. phoneScreenshots, sevenInchScreenshots, ...)
+    def upload_image(image_path: nil, image_type: nil, language: nil)
+      ensure_active_edit!
+
+      call_google_api do
+        client.upload_image(
+          current_package_name,
+          current_edit.id,
+          language,
+          image_type,
+          upload_source: image_path,
+          content_type: 'image/*'
+        )
+      end
+    end
+
+    def clear_screenshots(image_type: nil, language: nil)
+      ensure_active_edit!
+
+      call_google_api do
+        client.delete_all_images(
+          current_package_name,
+          current_edit.id,
+          language,
+          image_type
+        )
+      end
+    end
+
+    def upload_obb(obb_file_path: nil, apk_version_code: nil, expansion_file_type: nil)
+      ensure_active_edit!
+
+      call_google_api do
+        client.upload_expansion_file(
+          current_package_name,
+          current_edit.id,
+          apk_version_code,
+          expansion_file_type,
+          upload_source: obb_file_path,
+          content_type: 'application/octet-stream'
+        )
+      end
+    end
+
+    private
+
+    def ensure_active_edit!
+      UI.user_error!("You need to have an active edit, make sure to call `begin_edit`") unless @current_edit
+    end
+  end
+end