danger-app_size_report 0.0.3 → 1.1.0

data/lib/app_size_report/plugin.rb

@@ -2,102 +2,281 @@
 
 module Danger
   require 'json'
+  require 'open-uri'
+  require 'fileutils'
+
   require_relative '../converter/parser/report_parser'
   require_relative '../converter/helper/memory_size'
+  require_relative '../converter/helper/android_utils'
 
-  # A Danger plugin for reporting iOS app size violations.
+  # A Danger plugin for reporting iOS and Android app size violations.
+  #
+  #
   # A valid App Thinning Size Report must be passed to the plugin
-  # for accurate functionality.
+  # for accurate functionality in case of iOS.
   #
-  # @example Report app size violations if one or more App variants
-  # exceed 4GB.
+  # @example Report iOS app size violations if one or more App variants exceed 4GB.
   #
   #          report_path = "/Path/to/AppSize/Report.txt"
-  #          app_size_report.flag_violations(
+  #          app_size_report.flag_ios_violations(
   #             report_path,
   #             build_type: 'App',
-  #             size_limit: 4,
+  #             limit_size: 4,
   #             limit_unit: 'GB',
   #             fail_on_warning: false
   #          )
   #
-  # @example Report app size violations if one or more App Clip variants
-  # exceed 8MB.
+  # @example Report iOS app size violations if one or more App Clip variants exceed 8MB.
   #
   #          report_path = "/Path/to/AppSize/Report.txt"
-  #          app_size_report.flag_violations(
+  #          app_size_report.flag_ios_violations(
   #             report_path,
   #             build_type: 'Clip',
-  #             size_limit: 8,
+  #             limit_size: 8,
   #             limit_unit: 'MB',
   #             fail_on_warning: false
   #          )
   #
-  # @example Fail PR if one or more App Clip variants exceed 8MB.
+  # @example Fail PR if one or more iOS App Clip variants exceed 8MB.
   #
   #          report_path = "/Path/to/AppSize/Report.txt"
-  #          app_size_report.flag_violations(
+  #          app_size_report.flag_ios_violations(
   #             report_path,
   #             build_type: 'Clip',
-  #             size_limit: 8,
+  #             limit_size: 8,
   #             limit_unit: 'MB',
   #             fail_on_warning: true
   #          )
   #
-  # @example Get JSON string representation of app thinning size report
+  # @example Get JSON string representation of iOS app thinning size report
   #
   #          report_path = "/Path/to/AppSize/Report.txt"
   #          app_size_json = app_size_report.report_json(report_path)
   #
+  # @example Report Android app size violations if one or more App variants
+  #
+  #          aab_path = "/Path/to/app.aab"
+  #          ks_path = "/Path/to/keyStore"
+  #          ks_alias = "KeyAlias"
+  #          ks_password = "Key Password"
+  #          ks_alias_password = "Key Alias Password"
+  #          app_size_report.flag_android_violations(
+  #             aab_path,
+  #             ks_path,
+  #             ks_alias,
+  #             ks_password,
+  #             ks_alias_password,
+  #             screen_densities: ["MDPI", "HDPI", "XHDPI", "XXHDPI", "XXXHDPI"],
+  #             languages: ["en", "de", "da", "es", "fr", "it", "nb", "nl", "sv"],
+  #             build_type: 'App',
+  #             limit_size: 14,
+  #             limit_unit: 'MB',
+  #             fail_on_warning: false
+  #          )
+  #
+  # @example Report Android Instant app size violations if one or more App variants
+  #
+  #          aab_path = "/Path/to/app.aab"
+  #          ks_path = "/Path/to/keyStore"
+  #          ks_alias = "KeyAlias"
+  #          ks_password = "Key Password"
+  #          ks_alias_password = "Key Alias Password"
+  #          app_size_report.flag_android_violations(
+  #             aab_path,
+  #             ks_path,
+  #             ks_alias,
+  #             ks_password,
+  #             ks_alias_password,
+  #             screen_densities: ["MDPI", "HDPI", "XHDPI", "XXHDPI", "XXXHDPI"],
+  #             languages: ["en", "de", "da", "es", "fr", "it", "nb", "nl", "sv"],
+  #             build_type: 'Instant',
+  #             limit_size: 4,
+  #             limit_unit: 'MB',
+  #             fail_on_warning: false
+  #          )
+  #
+  # @example Fail PR if one or more Android Instant App variants exceed 4MB.
+  #
+  #          aab_path = "/Path/to/app.aab"
+  #          ks_path = "/Path/to/keyStore"
+  #          ks_alias = "KeyAlias"
+  #          ks_password = "Key Password"
+  #          ks_alias_password = "Key Alias Password"
+  #          app_size_report.flag_android_violations(
+  #             aab_path,
+  #             ks_path,
+  #             ks_alias,
+  #             ks_password,
+  #             ks_alias_password,
+  #             screen_densities: ["MDPI", "HDPI", "XHDPI", "XXHDPI", "XXXHDPI"],
+  #             languages: ["en", "de", "da", "es", "fr", "it", "nb", "nl", "sv"],
+  #             build_type: 'Instant',
+  #             limit_size: 4,
+  #             limit_unit: 'MB',
+  #             fail_on_warning: true
+  #          )
+  #
   # @see  ChargePoint/danger-app_size_report
   # @tags ios, xcode, appclip, thinning, size
   #
   class DangerAppSizeReport < Plugin
-    # Reports app size violations given a valid App Thinning Size Report.
-    # @param [String, required] report_path
-    #        Path to valid App Thinning Size Report text file.
-    # @param [String, optional] build_type
-    #        Specify whether the report corresponds to an App or an App Clip.
-    #        Default: 'App'
-    #        Supported values: 'App', 'Clip'
-    # @param [Numeric, optional] size_limit
-    #        Specify the app size limit.
-    #        Default: 4
-    # @param [String, optional] limit_unit
-    #        Specific the unit for the given size limit.
-    #        Default: 'GB'
-    #        Supported values: 'KB', 'MB', 'GB'
-    # @param [Boolean, optional] fail_on_warning
-    #        Specify whether the PR should fail if one or more app variants
-    #        exceed the given size limit. By default, the plugin issues
-    #        a warning in this case.
-    #        Default: 'false'
+    # Reports IOS app size violations given a valid App Thinning Size Report.
+    # The plugin also warns users about variants that exceed the optimal size
+    # limit for cellular downloads (200 MB).
+    # @overload flag_ios_violations(report_path, build_type, limit_size, limit_unit, fail_on_warning)
+    #   @param [String, required] report_path
+    #         Path to valid App Thinning Size Report text file.
+    #   @param [String, optional] build_type
+    #         Specify whether the report corresponds to an App or an App Clip.
+    #         Default: 'App'
+    #         Supported values: 'App', 'Clip'
+    #   @param [Numeric, optional] limit_size
+    #         Specify the app size limit. If the build type is set to 'Clip' and the
+    #         specified app size limit exceeds 10 MB, the 10 MB limit will be enforced
+    #         to meet Apple's App Clip size requirements.
+    #         Default: 4
+    #   @param [String, optional] limit_unit
+    #         Specific the unit for the given size limit.
+    #         Default: 'GB'
+    #         Supported values: 'KB', 'MB', 'GB'
+    #   @param [Boolean, optional] fail_on_warning
+    #         Specify whether the PR should fail if one or more app variants
+    #         exceed the given size limit. By default, the plugin issues
+    #         a warning in this case.
+    #         Default: 'false'
     # @return   [void]
     #
-    def flag_violations(report_path, build_type: 'App', size_limit: 4, limit_unit: 'GB', fail_on_warning: false)
+    def flag_ios_violations(report_path, **kargs)
+      supported_kargs = %i[build_type limit_size limit_unit size_limit fail_on_warning]
+
+      # Identify any unsupported arguments passed to method
+      unsupported_kargs = kargs.keys - supported_kargs
+
+      raise ArgumentError, "The argument '#{unsupported_kargs[0]}' is not supported by flag_ios_violations" if unsupported_kargs.count == 1
+
+      raise ArgumentError, "The arguments #{unsupported_kargs} are not supported by flag_ios_violations" if unsupported_kargs.count > 1
+
+      # Set up optional arguments with default values if needed
+      build_type = kargs[:build_type] || 'App'
+      limit_size = kargs[:limit_size] || kargs[:size_limit] || 4
+      limit_unit = kargs[:limit_unit] || 'GB'
+      fail_on_warning = kargs[:fail_on_warning] || false
+
       report_text = File.read(report_path)
       variants = ReportParser.parse(report_text)
 
-      unless %w[App Clip].include? build_type
-        raise ArgumentError, "The 'build_type' argument only accepts the values \"App\" and \"Clip\""
-      end
+      raise ArgumentError, "The 'build_type' argument only accepts the values \"App\" and \"Clip\"" unless %w[App Clip].include? build_type
 
-      raise ArgumentError, "The 'size_limit' argument only accepts numeric values" unless size_limit.is_a? Numeric
+      if kargs[:limit_size]
+        raise ArgumentError, "The 'limit_size' argument only accepts numeric values" unless limit_size.is_a? Numeric
+      elsif kargs[:size_limit]
+        raise ArgumentError, "The 'size_limit' argument only accepts numeric values" unless limit_size.is_a? Numeric
+      end
 
       limit_unit.upcase!
-      unless %w[KB MB GB].include? limit_unit
-        raise ArgumentError, "The 'build_type' argument only accepts the values \"KB\", \"MB\" and \"GB\""
-      end
+      raise ArgumentError, "The 'build_type' argument only accepts the values \"KB\", \"MB\" and \"GB\"" unless %w[KB MB GB].include? limit_unit
 
-      unless [true, false].include? fail_on_warning
-        raise ArgumentError, "The 'fail_on_warning' argument only accepts the values 'true' and 'false'"
-      end
+      raise ArgumentError, "The 'fail_on_warning' argument only accepts the values 'true' and 'false'" unless [true, false].include? fail_on_warning
 
-      generate_size_report_markdown(variants, build_type, size_limit, limit_unit, fail_on_warning)
+      generate_size_report_markdown(variants, build_type, limit_size, limit_unit, fail_on_warning)
       generate_variant_descriptors_markdown(variants)
       generate_ads_label_markdown
     end
 
+    # Reports Android app size violations given a valid AAB.
+    # @overload flag_android_violations(aab_path, ks_path, ks_alias, ks_password, ks_alias_password, screen_densities, languages, build_type, limit_size, size_limit, limit_unit, fail_on_warning)
+    #   @param [String, required] aab_path
+    #         Path to valid AAB file.
+    #   @param [String, required] ks_path
+    #         Path to valid signing key file.
+    #   @param [String, required] ks_alias
+    #         Alias of signing key.
+    #   @param [String, required] ks_password
+    #         Password of signing key.
+    #   @param [String, required] ks_alias_password
+    #         Alias Password of signing key.
+    #   @param [Array, optional] screen_densities
+    #         Array of screen densities to check APK size.
+    #         Default: ["MDPI", "HDPI", "XHDPI", "XXHDPI", "XXXHDPI"]
+    #   @param [Array, optional] languages
+    #         Array of languages to check APK size.
+    #         Default: ["en"]
+    #   @param [String, optional] build_type
+    #         Specify whether the report corresponds to an App, Instant.
+    #         Default: 'App'
+    #         Supported values: 'App', 'Instant'
+    #   @param [Numeric, optional] limit_size
+    #         Specify the app size limit. If the build type is set to 'Instant' and the
+    #         specified app size limit exceeds 4 MB, the 4 MB limit will be enforced to
+    #         meet Android Instant App size requirements.
+    #         Default: 150
+    #   @param [String, optional] limit_unit
+    #         Specific the unit for the given size limit.
+    #         Default: 'MB'
+    #         Supported values: 'KB', 'MB', 'GB'
+    #   @param [Boolean, optional] fail_on_warning
+    #         Specify whether the PR should fail if one or more app variants
+    #         exceed the given size limit. By default, the plugin issues
+    #         a warning in this case.
+    #         Default: 'false'
+    # @return   [void]
+    #
+    def flag_android_violations(aab_path, ks_path, ks_alias, ks_password, ks_alias_password, **kargs)
+      project_root = Dir.pwd
+      temp_path = "#{project_root}/temp"
+      apks_path = "#{temp_path}/output.apks"
+      size_csv_path = "#{temp_path}/output.csv"
+      bundletool_path = "#{temp_path}/bundletool.jar"
+      bundletool_version = '1.8.2'
+      variants_limit = 25
+
+      supported_kargs = %i[screen_densities languages build_type limit_size size_limit limit_unit fail_on_warning]
+      unsupported_kargs = kargs.keys - supported_kargs
+
+      raise ArgumentError, "The argument #{unsupported_kargs[0]} is not supported by flag_android_violations" if unsupported_kargs.count == 1
+
+      raise ArgumentError, "The arguments #{unsupported_kargs} are not supported by flag_android_violations" if unsupported_kargs.count > 1
+
+      # Set up optional arguments with default values if needed
+      screen_densities = kargs[:screen_densities] || %w[MDPI HDPI XHDPI XXHDPI XXXHDPI]
+      languages = kargs[:languages] || ['en']
+      build_type = kargs[:build_type] || 'App'
+      limit_size = kargs[:limit_size] || kargs[:size_limit] || 150
+      limit_unit = kargs[:limit_unit] || 'MB'
+      fail_on_warning = kargs[:fail_on_warning] || false
+
+      raise ArgumentError, "The 'build_type' argument only accepts the values \"App\" and \"Instant\"" unless %w[App Instant].include? build_type
+
+      if kargs[:limit_size]
+        raise ArgumentError, "The 'limit_size' arguments only accepts numeric values" unless limit_size.is_a? Numeric
+      elsif kargs[:size_limit]
+        raise ArgumentError, "The 'size_limit' argument only accepts numeric values" unless limit_size.is_a? Numeric
+      end
+
+      limit_unit.upcase!
+      raise ArgumentError, "The 'limit_unit' argument only accepts the values \"KB\", \"MB\" and \"GB\"" unless %w[KB MB GB].include? limit_unit
+
+      raise ArgumentError, "The 'fail_on_warning' argument only accepts the values 'true' and 'false'" unless [true, false].include? fail_on_warning
+
+      create_temp_dir(temp_path)
+
+      unless AndroidUtils.download_bundletool(bundletool_version, bundletool_path)
+        clean_temp!
+        return
+      end
+
+      AndroidUtils.generate_apks(aab_path, ks_path, ks_alias, ks_password, ks_alias_password, apks_path,
+                                 bundletool_path)
+      AndroidUtils.generate_estimated_sizes(apks_path, size_csv_path, bundletool_path, build_type)
+      filtered_sizes = AndroidUtils.filter_estimated_sizes(size_csv_path, screen_densities, languages)
+      sorted_sizes = AndroidUtils.sort_estimated_sizes(filtered_sizes)
+
+      clean_temp!(temp_path)
+
+      generate_android_size_report_markdown(sorted_sizes, build_type, limit_size, limit_unit, fail_on_warning,
+                                            variants_limit)
+    end
+
     # Returns a JSON string representation of the given App Thinning Size Report.
     # @param [String, required] report_path
     #        Path to valid App Thinning Size Report text file.
@@ -111,14 +290,105 @@ module Danger
 
     private
 
+    def create_temp_dir(temp_path)
+      Dir.mkdir temp_path
+    end
+
+    def clean_temp!(temp_path)
+      FileUtils.rm_rf(temp_path)
+    end
+
+    def generate_android_size_report_markdown(sorted_sizes, build_type, size_limit, limit_unit, fail_on_warning, variants_limit)
+      limit_size = MemorySize.new("#{size_limit}#{limit_unit}")
+
+      if build_type == 'Instant' && limit_size.megabytes > 4
+        message "The size limit was set to 4 MB as the given limit of #{size_limit} #{limit_unit} exceeds Android Instant App size restrictions"
+        size_limit = 4
+        limit_unit = 'MB'
+        limit_size.kilobytes = 4 * 1024
+      elsif build_type == 'App' && limit_size.megabytes > 150
+        message "The size limit was set to 150 MB as the given limit of #{size_limit} #{limit_unit} exceeds Android App size restrictions"
+        size_limit = 150
+        limit_unit = 'MB'
+        limit_size.kilobytes = 150 * 1024
+      end
+
+      violation_count = AndroidUtils.violations_count(sorted_sizes, limit_size.bytes)
+
+      if violation_count.positive?
+        if fail_on_warning
+          failure "The size limit of #{size_limit} #{limit_unit.upcase} has been exceeded by #{violation_count} variants"
+        else
+          warn "The size limit of #{size_limit} #{limit_unit.upcase} has been exceeded by #{violation_count} variants"
+        end
+      end
+
+      exceed_size_report = "| Under Limit | SDK | ABI | Screen Density | Language | Size (Bytes) |\n"
+      exceed_size_report << "| :-: | :-: | :-: | :-: | :-: | :-: |\n"
+
+      more_exceed_size_report = "| Under Limit | SDK | ABI | Screen Density | Language | Size (Bytes) |\n"
+      more_exceed_size_report << "| :-: | :-: | :-: | :-: | :-: | :-: |\n"
+
+      under_size_report = "| Under Limit | SDK | ABI | Screen Density | Language | Size (Bytes) |\n"
+      under_size_report << "| :-: | :-: | :-: | :-: | :-: | :-: |\n"
+
+      counter = sorted_sizes.length - 1
+      exceed_counter = 1
+      under_counter = 1
+
+      while counter >= 0
+        variant = sorted_sizes[counter]
+        is_violating = variant.max > limit_size.bytes ? '❌' : '✅'
+        variant_report = "#{is_violating} | #{variant.sdk} | #{variant.abi} | #{variant.screen_density} | #{variant.language} | #{variant.max} |\n"
+
+        if variant.max > limit_size.bytes
+          if exceed_counter <= variants_limit
+            exceed_counter += 1
+            exceed_size_report << variant_report
+          else
+            more_exceed_size_report << variant_report
+          end
+        elsif under_counter <= variants_limit
+          under_counter += 1
+          under_size_report << variant_report
+        end
+
+        counter -= 1
+      end
+
+      size_report = "# Android #{build_type} Size Report\n"
+      size_report << "### Size limit = #{size_limit} #{limit_unit.upcase}\n\n"
+
+      if violation_count.positive?
+        size_report << "## Variants exceeding the size limit\n\n"
+        size_report << exceed_size_report
+        size_report << "\n"
+
+        if violation_count > variants_limit
+          size_report << "<details>\n<summary>Click to view more violating variants!</summary>\n\n"
+          size_report << more_exceed_size_report
+          size_report << "</details>\n\n"
+        end
+      end
+
+      size_report << "## Variants under or equal to the size limit\n\n"
+      size_report << "<details>\n<summary>Click to expand!</summary>\n\n"
+
+      size_report << under_size_report
+      size_report << "</details>\n"
+
+      markdown size_report
+    end
+
     def generate_size_report_markdown(variants, build_type, size_limit, limit_unit, fail_on_warning)
       limit_size = MemorySize.new("#{size_limit}#{limit_unit}")
+      cellular_limit_size = MemorySize.new('200 MB')
 
-      if build_type == 'Clip' && limit_size.megabytes > 10
-        message "The size limit was set to 10 MB as the given limit of #{size_limit} #{limit_unit} exceeds Apple's App Clip size restrictions"
-        size_limit = 10
+      if build_type == 'Clip' && limit_size.megabytes > 15
+        message "The size limit was set to 15 MB as the given limit of #{size_limit} #{limit_unit} exceeds Apple's App Clip size restrictions"
+        size_limit = 15
         limit_unit = 'MB'
-        limit_size.kilobytes = 10 * 1024
+        limit_size.kilobytes = 15 * 1024
       elsif build_type == 'App' && limit_size.gigabytes > 4
         message "The size limit was set to 4 GB as the given limit of #{size_limit} #{limit_unit} exceeds Apple's App size restrictions"
         size_limit = 4
@@ -127,10 +397,10 @@ module Danger
       end
 
       flagged_variant_names = []
+      flagged_cellular_variant_names = []
       variants.each do |variant|
-        if variant.app_size.uncompressed.value > limit_size.megabytes || variant.on_demand_resources_size.uncompressed.value > limit_size.megabytes
-          flagged_variant_names.append(variant.variant)
-        end
+        flagged_variant_names.append(variant.variant) if variant.app_size.uncompressed.value > limit_size.megabytes || variant.on_demand_resources_size.uncompressed.value > limit_size.megabytes
+        flagged_cellular_variant_names.append(variant.variant) if variant.app_size.uncompressed.value > cellular_limit_size.megabytes || variant.on_demand_resources_size.uncompressed.value > cellular_limit_size.megabytes
       end
 
       if flagged_variant_names.length.positive?
@@ -141,21 +411,25 @@ module Danger
         end
       end
 
+      warn 'The optimal cellular size limit of 200 MB has been exceeded by one or more variants' if flagged_cellular_variant_names.length.positive?
+
       size_report = "# App Thinning Size Report\n"
       size_report << "### Size limit = #{size_limit} #{limit_unit.upcase}\n\n"
-      size_report << "| Under Limit | Variant | App Size - Compressed | App Size - Uncompressed | ODR Size - Compressed | ODR Size - Uncompressed |\n"
-      size_report << "| :-: | :-: | :-: | :-: | :-: | :-: |\n"
+      size_report << "| Under Limit | Variant | Cellular Friendly | App Size - Compressed | App Size - Uncompressed | ODR Size - Compressed | ODR Size - Uncompressed |\n"
+      size_report << "| :-: | :-: | :-: | :-: | :-: | :-: | :-:|\n"
 
       flagged_variants_set = flagged_variant_names.to_set
+      flagged_cellular_variants_set = flagged_cellular_variant_names.to_set
 
       variants.each do |variant|
         is_violating = flagged_variants_set.include?(variant.variant) ? '❌' : '✅'
+        is_cellular_friendly = flagged_cellular_variants_set.include?(variant.variant) ? '❌' : '✅'
         app_size_compressed = "#{variant.app_size.compressed.value} #{variant.app_size.compressed.unit}"
         app_size_uncompressed = "#{variant.app_size.uncompressed.value} #{variant.app_size.uncompressed.unit}"
         odr_size_compressed = "#{variant.on_demand_resources_size.compressed.value} #{variant.on_demand_resources_size.compressed.unit}"
         odr_size_uncompressed = "#{variant.on_demand_resources_size.uncompressed.value} #{variant.on_demand_resources_size.uncompressed.unit}"
 
-        size_report << "#{is_violating} | #{variant.variant} | #{app_size_compressed} | #{app_size_uncompressed} | #{odr_size_compressed} | #{odr_size_uncompressed} |\n"
+        size_report << "#{is_violating} | #{variant.variant} | #{is_cellular_friendly} | #{app_size_compressed} | #{app_size_uncompressed} | #{odr_size_compressed} | #{odr_size_uncompressed} |\n"
       end
 
       markdown size_report
@@ -178,7 +452,7 @@ module Danger
     end
 
     def generate_ads_label_markdown
-      ads_label = 'Powered by [danger-app_size_report](https://github.com/ChargePoint)'
+      ads_label = 'Powered by [danger-app_size_report](https://github.com/ChargePoint/danger-app_size_report)'
       markdown ads_label
     end
   end

data/lib/converter/helper/android_utils.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'csv'
+require 'open3'
+
+require_relative '../models/android_variant_model'
+
+# Used to obtain and parse Android app size information
+class AndroidUtils
+  def self.filter_estimated_sizes(path, screen_densities, languages)
+    filtered_sizes = []
+    CSV.foreach(path, headers: true) do |row|
+      sdk = row[AndroidVariant::PARSING_KEYS[:sdk]]
+      abi = row[AndroidVariant::PARSING_KEYS[:abi]]
+      screen_density = row[AndroidVariant::PARSING_KEYS[:screen_density]]
+      language = row[AndroidVariant::PARSING_KEYS[:language]]
+      texture_compression_format = row[AndroidVariant::PARSING_KEYS[:texture_compression_format]]
+      device_tire = row[AndroidVariant::PARSING_KEYS[:device_tire]]
+      min = row[AndroidVariant::PARSING_KEYS[:min]]
+      max = row[AndroidVariant::PARSING_KEYS[:max]]
+
+      if screen_densities.include?(screen_density) && languages.include?(language)
+        filtered_sizes << AndroidVariant.new(sdk, abi, screen_density, language, texture_compression_format,
+                                             device_tire, min, max)
+      end
+    end
+    filtered_sizes
+  end
+
+  def self.sort_estimated_sizes(size_arr)
+    size_arr.sort { |o1, o2| o1.max <=> o2.max }
+  end
+
+  def self.violations_count(sorted_arr, limit)
+    lb = -1
+    ub = sorted_arr.length
+    while ub - lb > 1
+      mid = (lb + ub) / 2
+      if sorted_arr[mid].max <= limit
+        lb = mid
+      else
+        ub = mid
+      end
+    end
+    sorted_arr.length - ub
+  end
+
+  def self.generate_apks(aab_path, ks_path, ks_alias, ks_password, ks_alias_password, apks_path, bundletool_path)
+    keystore_params = "--ks=\"#{ks_path}\" --ks-key-alias=\"#{ks_alias}\" --ks-pass=\"pass:#{ks_password}\" --key-pass=\"pass:#{ks_alias_password}\""
+    cmd = "java -jar #{bundletool_path} build-apks --bundle=\"#{aab_path}\" --output=\"#{apks_path}\" #{keystore_params}"
+    Open3.popen3(cmd) do |_, _, stderr, wait_thr|
+      exit_status = wait_thr.value
+      raise stderr.read unless exit_status.success?
+    end
+  end
+
+  def self.generate_estimated_sizes(apks_path, size_csv_path, bundletool_path, build_type)
+    bundletool_cmd = "java -jar #{bundletool_path} get-size total --apks=\"#{apks_path}\" --dimensions=ALL"
+    bundletool_cmd += ' --instant' if build_type == 'Instant'
+    cmd = "#{bundletool_cmd} > #{size_csv_path}"
+    Open3.popen3(cmd) do |_, _, stderr, wait_thr|
+      exit_status = wait_thr.value
+      raise stderr.read unless exit_status.success?
+    end
+  end
+
+  def self.download_bundletool(version, bundletool_path)
+    URI.open("https://github.com/google/bundletool/releases/download/#{version}/bundletool-all-#{version}.jar") do |bundletool|
+      File.binwrite(bundletool_path, bundletool.read)
+    end
+  rescue OpenURI::HTTPError
+    false
+  end
+end

data/lib/converter/helper/json_converter.rb

@@ -2,6 +2,7 @@
 
 require 'json'
 
+# Generate pretty JSON from list of variants
 class JSONConverter
   def to_json(_options = {})
     hash = {}

data/lib/converter/helper/memory_size.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: false
 
 require_relative '../helper/json_converter'
+# Defines memory size object to be used to parse the App Thinning Size Report
 class MemorySize < JSONConverter
   attr_accessor :kilobytes
 

data/lib/converter/helper/result_factory.rb

@@ -4,6 +4,7 @@ require_relative '../parser/variant_parser'
 require_relative '../parser/variant_descriptor_parser'
 require_relative '../parser/app_size_parser'
 
+# Used to parse sections of the App Thinning Size Report using different parsers
 class ResultFactory
   def self.parse(from_text: '', parser: nil)
     result = nil
@@ -16,15 +17,7 @@ class ResultFactory
       variant_descriptor_parser = VariantDescriptorParser.new(from_text)
       variant_descriptor_parser.parse
       result = variant_descriptor_parser.result
-    when :app_on_demand_resources_size
-      app_size_parser = AppSizeParser.new(from_text)
-      app_size_parser.parse
-      result = app_size_parser.result
-    when :app_size
-      app_size_parser = AppSizeParser.new(from_text)
-      app_size_parser.parse
-      result = app_size_parser.result
-    when :on_demand_resources_size
+    when :app_on_demand_resources_size, :app_size, :on_demand_resources_size
       app_size_parser = AppSizeParser.new(from_text)
       app_size_parser.parse
       result = app_size_parser.result

data/lib/converter/models/android_variant_model.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+# Android variant model
+class AndroidVariant
+  attr_reader :sdk, :abi, :screen_density, :language, :texture_compression_format, :device_tire, :min, :max
+
+  PARSING_KEYS = {
+    sdk: 'SDK',
+    abi: 'ABI',
+    screen_density: 'SCREEN_DENSITY',
+    language: 'LANGUAGE',
+    texture_compression_format: 'TEXTURE_COMPRESSION_FORMAT',
+    device_tire: 'DEVICE_TIER',
+    min: 'MIN',
+    max: 'MAX'
+  }.freeze
+
+  def initialize(sdk, abi, screen_density, language, texture_compression_format, device_tire, min, max)
+    @sdk = sdk
+    @abi = abi
+    @screen_density = screen_density
+    @language = language
+    @texture_compression_format = texture_compression_format
+    @device_tire = device_tire
+    @min = min.to_i
+    @max = max.to_i
+  end
+end

data/lib/converter/models/app_size_model.rb

@@ -1,6 +1,9 @@
 # frozen_string_literal: true
 
 require_relative '../helper/json_converter'
+
+# App Size Model.
+# Example: 'App size: 6.6 MB compressed, 12.9 MB uncompressed'
 class AppSizeModel < JSONConverter
   attr_reader :compressed, :uncompressed
 
@@ -16,6 +19,7 @@ class AppSizeModel < JSONConverter
   end
 end
 
+# Size Model
 class SizeModel < JSONConverter
   attr_reader :raw_value, :value, :unit
 

data/lib/converter/models/device_model.rb

@@ -1,6 +1,9 @@
 # frozen_string_literal: true
 
 require_relative '../helper/json_converter'
+
+# Device Model.
+# Example: 'device: iPhone10,3, os-version: 14.0'
 class DeviceModel < JSONConverter
   attr_reader :device, :os_version