pindo 5.2.4 → 5.3.7

data/lib/pindo/module/android/gp_compliance_helper.rb

@@ -0,0 +1,668 @@
+require 'fileutils'
+require 'tempfile'
+require 'nokogiri'
+require_relative 'base_helper'
+
+module Pindo
+  module GPComplianceHelper
+    include BaseAndroidHelper
+    
+    # Google Play 合规检测结果
+    class ComplianceResult
+      attr_accessor :target_sdk_compliant, :target_sdk_version, :elf_alignment_compliant, 
+                    :unaligned_libs, :total_libs, :compliance_issues, :warnings,
+                    :size_compliant, :aab_size_mb, :base_size_mb, :base_percent
+      
+      def initialize
+        @target_sdk_compliant = false
+        @target_sdk_version = 0
+        @elf_alignment_compliant = false
+        @unaligned_libs = []
+        @total_libs = 0
+        @compliance_issues = []
+        @warnings = []
+        @size_compliant = false
+        @aab_size_mb = 0
+        @base_size_mb = 0
+        @base_percent = 0
+      end
+      
+      def compliant?
+        @target_sdk_compliant && @elf_alignment_compliant && @size_compliant
+      end
+      
+      def add_issue(issue)
+        @compliance_issues << issue
+      end
+      
+      def add_warning(warning)
+        @warnings << warning
+      end
+    end
+    
+    # 检测 AAB 文件的 Google Play 合规性
+    def self.check_aab_compliance(aab_path)
+      result = ComplianceResult.new
+      
+      unless File.exist?(aab_path)
+        result.add_issue("AAB 文件不存在: #{aab_path}")
+        return result
+      end
+      
+      puts "\n\e[1m=== Google Play 合规检测 ===\e[0m"
+      puts "检测文件: #{File.basename(aab_path)}"
+      
+      # 创建临时目录用于解压 AAB
+      temp_dir = nil
+      begin
+        temp_dir = Dir.mktmpdir("aab_compliance_check_")
+        
+        # 检查 unzip 工具是否可用
+        unless tool_available?('unzip')
+          result.add_issue("unzip 工具不可用，无法解压 AAB 文件")
+          puts "请安装 unzip 工具: brew install unzip (macOS) 或 apt-get install unzip (Ubuntu)"
+          return result
+        end
+        
+        # 解压 AAB 文件
+        unless system("unzip", "-q", aab_path, "-d", temp_dir)
+          result.add_issue("无法解压 AAB 文件")
+          return result
+        end
+        
+        # 检测 AAB 包体积
+        check_aab_size_compliance(aab_path, result)
+        
+        # 检测 Target SDK 版本（传递 AAB 路径）
+        check_target_sdk_compliance(temp_dir, result, aab_path)
+        
+        # 检测 ELF 对齐
+        check_elf_alignment_compliance(temp_dir, result)
+        
+        # 输出检测结果
+        print_compliance_summary(result)
+        
+      ensure
+        # 清理临时目录
+        FileUtils.rm_rf(temp_dir) if temp_dir && File.directory?(temp_dir)
+      end
+      
+      result
+    end
+    
+    private
+    
+    # 检查工具是否可用
+    def self.tool_available?(tool_name)
+      case tool_name
+      when 'bundletool'
+        # 检查 bundletool 是否可用（可能是别名或直接命令）
+        # 使用 Open3 来正确检测命令是否可用
+        require 'open3'
+        begin
+          stdout, stderr, status = Open3.capture3('bundletool help')
+          status.success?
+        rescue
+          false
+        end
+      when 'aapt'
+        system("which aapt > /dev/null 2>&1") || system("aapt version > /dev/null 2>&1")
+      when 'aapt2'
+        system("which aapt2 > /dev/null 2>&1") || system("aapt2 version > /dev/null 2>&1")
+      when 'objdump'
+        system("which objdump > /dev/null 2>&1")
+      when 'readelf'
+        system("which readelf > /dev/null 2>&1")
+      when 'unzip'
+        system("which unzip > /dev/null 2>&1")
+      else
+        system("which #{tool_name} > /dev/null 2>&1")
+      end
+    end
+    
+    # 检测 AAB 包体积合规性
+    def self.check_aab_size_compliance(aab_path, result)
+      puts "\n\e[1m--- AAB 包体积检测 ---\e[0m"
+      
+      begin
+        # 获取 AAB 文件大小
+        aab_size = File.size(aab_path)
+        result.aab_size_mb = (aab_size.to_f / 1024 / 1024).round(2)
+        
+        # 统计 base/ 文件夹压缩体积
+        base_size = 0
+        base_limit_bytes = 194615705 # 185MB
+        base_limit_mb = 185
+        
+        unzip_out = `unzip -v "#{aab_path}"`
+        if unzip_out && !unzip_out.empty?
+          base_lines = unzip_out.lines.select { |l| l.include?(" base/") }
+          base_size = base_lines.map { |l| l.split[2].to_i }.sum
+          result.base_size_mb = (base_size.to_f / 1024 / 1024).round(2)
+          result.base_percent = aab_size > 0 ? ((base_size.to_f * 100) / aab_size).round(2) : 0
+        end
+        
+        puts "AAB 包体积: #{result.aab_size_mb} MB"
+        puts "base 文件夹压缩体积: #{result.base_size_mb} MB (占比 #{result.base_percent}%)"
+        
+        if base_size > base_limit_bytes
+          result.size_compliant = false
+          result.add_issue("base 文件夹已超出 Google Play 限制（#{base_limit_mb}MB），请优化资源或分包")
+          puts "\e[31m✗ base 文件夹已超出 Google Play 限制（#{base_limit_mb}MB），请优化资源或分包！\e[0m"
+        else
+          result.size_compliant = true
+          puts "\e[32m✓ AAB 包体积符合 Google Play 提交标准\e[0m"
+        end
+        
+      rescue => e
+        result.add_issue("AAB 包体积检测失败: #{e.message}")
+        puts "✗ AAB 包体积检测失败: #{e.message}"
+      end
+    end
+    
+    # 检测 Target SDK 版本合规性
+    def self.check_target_sdk_compliance(temp_dir, result, aab_path = nil)
+      puts "\n\e[1m--- Target SDK 版本检测 ---\e[0m"
+      
+      target_sdk = 0
+      
+      # 方法1: 使用 bundletool dump manifest（首要方法）
+      if aab_path && File.exist?(aab_path)
+        # puts "使用 bundletool 解析 AAB 文件: #{File.basename(aab_path)}"
+        target_sdk = extract_target_sdk_with_bundletool(aab_path)
+      end
+      
+      # 方法2: 如果 bundletool 失败，使用二进制 XML 解析（备用方法）
+      if target_sdk == 0
+        puts "bundletool 解析失败，尝试二进制 XML 解析"
+        manifest_path = find_android_manifest(temp_dir)
+        if manifest_path
+          puts "找到 AndroidManifest.xml: #{manifest_path}"
+          target_sdk = extract_target_sdk_from_manifest(manifest_path)
+        end
+      end
+      
+      result.target_sdk_version = target_sdk
+      
+      if target_sdk >= 35
+        result.target_sdk_compliant = true
+        puts "\e[32m✓ Target SDK: #{target_sdk} (符合 Android 15 要求)\e[0m"
+      else
+        result.target_sdk_compliant = false
+        if target_sdk == 0
+          result.add_issue("无法检测到 Target SDK 版本，请检查 AAB 文件结构")
+        else
+          result.add_issue("Target SDK #{target_sdk} 不符合要求，需要至少 Target SDK 35 (Android 15)")
+        end
+        puts "\e[31m✗ Target SDK: #{target_sdk} (需要至少 35)\e[0m"
+      end
+    end
+    
+    
+    # 使用 bundletool 提取 Target SDK 版本
+    def self.extract_target_sdk_with_bundletool(aab_path)
+      begin
+        # 获取 Pindo 自带的 bundletool.jar 路径
+        bundletool_jar = get_pindo_bundletool_path
+        unless bundletool_jar && File.exist?(bundletool_jar)
+          puts "Pindo 自带的 bundletool.jar 不可用，尝试使用系统 bundletool 命令"
+          return extract_target_sdk_with_system_bundletool(aab_path)
+        end
+        
+        # 使用 Pindo 自带的 bundletool.jar
+        # 确保使用正确的 Java 版本 (Java 11+)
+        java_cmd = get_java_command_for_bundletool
+        bundletool_cmd = "#{java_cmd} -jar \"#{bundletool_jar}\" dump manifest --bundle=\"#{aab_path}\" | grep \"targetSdkVersion\""
+        output = `#{bundletool_cmd} 2>/dev/null`
+        
+        if output && !output.empty?
+          # puts "bundletool 输出: #{output.strip}"
+          
+          # 解析输出格式: <uses-sdk android:minSdkVersion="26" android:targetSdkVersion="34"/>
+          if output =~ /android:targetSdkVersion="(\d+)"/
+            target_sdk = $1.to_i
+            # puts "从 bundletool 中找到 targetSdkVersion: #{target_sdk}"
+            return target_sdk
+          end
+        end
+        
+        # puts "bundletool 未找到 targetSdkVersion"
+        return 0
+      rescue => e
+        puts "bundletool 解析失败: #{e.message}"
+        return 0
+      end
+    end
+    
+    # 使用系统 bundletool 命令（备用方法）
+    def self.extract_target_sdk_with_system_bundletool(aab_path)
+      begin
+        # 检查系统 bundletool 是否可用
+        unless tool_available?('bundletool')
+          puts "系统 bundletool 也不可用，请确保已安装 bundletool"
+          puts "安装方法: 下载 bundletool.jar 并添加到 PATH 或创建别名"
+          return 0
+        end
+        
+        # 使用系统 bundletool 命令
+        bundletool_cmd = "bundletool dump manifest --bundle=\"#{aab_path}\" | grep \"targetSdkVersion\""
+        output = `#{bundletool_cmd} 2>/dev/null`
+        
+        if output && !output.empty?
+          # puts "bundletool 输出: #{output.strip}"
+          
+          # 解析输出格式: <uses-sdk android:minSdkVersion="26" android:targetSdkVersion="34"/>
+          if output =~ /android:targetSdkVersion="(\d+)"/
+            target_sdk = $1.to_i
+            # puts "从系统 bundletool 中找到 targetSdkVersion: #{target_sdk}"
+            return target_sdk
+          end
+        end
+        
+        # puts "系统 bundletool 未找到 targetSdkVersion"
+        return 0
+      rescue => e
+        puts "系统 bundletool 解析失败: #{e.message}"
+        return 0
+      end
+    end
+    
+    # 获取 Pindo 自带的 bundletool.jar 路径
+    def self.get_pindo_bundletool_path
+      begin
+        # 使用与 apk_helper.rb 相同的方法获取工具路径
+        pindo_dir = File.expand_path(ENV['PINDO_DIR'] || '~/.pindo')
+        pindo_common_configdir = File.join(pindo_dir, "pindo_common_config")
+        tools_dir = File.join(pindo_common_configdir, 'android_tools')
+        bundletool_jar = File.join(tools_dir, 'bundletool.jar')
+        
+        File.exist?(bundletool_jar) ? bundletool_jar : nil
+      rescue
+        nil
+      end
+    end
+
+    # 获取用于 bundletool 的 Java 命令
+    def self.get_java_command_for_bundletool
+      # 创建一个临时对象来调用 BaseAndroidHelper 的方法
+      helper = Object.new
+      helper.extend(BaseAndroidHelper)
+      helper.find_java_command
+    end
+    
+    # 查找 AndroidManifest.xml 文件（备用方法）
+    def self.find_android_manifest(temp_dir)
+      # 查找可能的 AndroidManifest.xml 路径
+      possible_paths = [
+        # AAB 解压后的标准路径
+        File.join(temp_dir, "base", "manifest", "AndroidManifest.xml"),
+        File.join(temp_dir, "manifest", "AndroidManifest.xml"),
+        # 其他可能的路径
+        File.join(temp_dir, "AndroidManifest.xml"),
+        # 递归查找
+        Dir.glob(File.join(temp_dir, "**", "AndroidManifest.xml")).first
+      ]
+      
+      possible_paths.each do |path|
+        return path if path && File.exist?(path)
+      end
+      
+      nil
+    end
+    
+    # 从 AndroidManifest.xml 中提取 Target SDK 版本
+    def self.extract_target_sdk_from_manifest(manifest_path)
+      begin
+        # 读取文件内容（二进制模式）
+        content = File.binread(manifest_path)
+        
+        # 检查是否为二进制 XML
+        if content.start_with?("\x03\x00\x08\x00") || content.include?("\x00")
+          puts "检测到二进制 XML 格式，使用二进制解析方法"
+          
+          # 在二进制 XML 中搜索 targetSdkVersion 后的数字
+          # 模式: targetSdkVersion + 一些二进制数据 + 数字
+          if content =~ /targetSdkVersion[^\d]*(\d{1,2})/
+            # puts "从二进制 XML 中找到 targetSdkVersion: #{$1}"
+            return $1.to_i
+          end
+          
+          # 尝试更宽泛的搜索模式
+          if content =~ /targetSdkVersion.*?(\d{1,2})/
+            # puts "从二进制 XML 中找到 targetSdkVersion (宽泛模式): #{$1}"
+            return $1.to_i
+          end
+          
+          # puts "二进制 XML 中未找到 targetSdkVersion"
+          return 0
+        end
+        
+        # 尝试使用 aapt 工具解析（适用于文本格式）
+        if tool_available?('aapt')
+          aapt_output = `aapt dump badging "#{manifest_path}" 2>/dev/null`
+          if aapt_output && !aapt_output.empty?
+            if aapt_output =~ /targetSdkVersion:'(\d+)'/
+              # puts "从 aapt 中找到 targetSdkVersion: #{$1}"
+              return $1.to_i
+            end
+          end
+        end
+        
+        # 尝试使用 aapt2 工具
+        if tool_available?('aapt2')
+          aapt2_output = `aapt2 dump badging "#{manifest_path}" 2>/dev/null`
+          if aapt2_output && !aapt2_output.empty?
+            if aapt2_output =~ /targetSdkVersion:'(\d+)'/
+              # puts "从 aapt2 中找到 targetSdkVersion: #{$1}"
+              return $1.to_i
+            end
+          end
+        end
+        
+        # 尝试使用 aapt dump xmltree
+        if tool_available?('aapt')
+          aapt_xml_output = `aapt dump xmltree "#{manifest_path}" 2>/dev/null`
+          if aapt_xml_output && !aapt_xml_output.empty?
+            if aapt_xml_output =~ /targetSdkVersion.*?(\d+)/
+              # puts "从 aapt xmltree 中找到 targetSdkVersion: #{$1}"
+              return $1.to_i
+            end
+          end
+        end
+        
+        # 解析文本 XML
+        doc = Nokogiri::XML(content)
+        
+        # 处理命名空间
+        doc.remove_namespaces!
+        
+        # 查找 uses-sdk 标签
+        uses_sdk = doc.at_xpath('//uses-sdk')
+        if uses_sdk
+          target_sdk = uses_sdk['targetSdkVersion']
+          if target_sdk
+            # puts "从 XML 中找到 targetSdkVersion: #{target_sdk}"
+            return target_sdk.to_i
+          end
+        end
+        
+        # 如果没找到 uses-sdk 标签，尝试查找其他可能的标签
+        target_sdk_attrs = doc.xpath('//@targetSdkVersion')
+        if !target_sdk_attrs.empty?
+          target_sdk = target_sdk_attrs.first.value
+          # puts "从 XML 属性中找到 targetSdkVersion: #{target_sdk}"
+          return target_sdk.to_i
+        end
+        
+        # 尝试查找所有包含 targetSdkVersion 的属性
+        all_attrs = doc.xpath('//@*[contains(name(), "targetSdkVersion")]')
+        if !all_attrs.empty?
+          target_sdk = all_attrs.first.value
+          # puts "从 XML 中找到 targetSdkVersion 属性: #{target_sdk}"
+          return target_sdk.to_i
+        end
+        
+        # puts "未找到 targetSdkVersion，返回默认值 0"
+        return 0
+        
+      rescue => e
+        puts "解析 AndroidManifest.xml 失败: #{e.message}"
+        return 0
+      end
+    end
+    
+    # 检测 ELF 对齐合规性
+    def self.check_elf_alignment_compliance(temp_dir, result)
+      puts "\n\e[1m--- ELF 对齐检测 (16KB 页面大小) ---\e[0m"
+      
+      # 查找所有 .so 文件
+      so_files = find_shared_libraries(temp_dir)
+      result.total_libs = so_files.length
+      
+      if so_files.empty?
+        puts "未找到共享库文件"
+        result.elf_alignment_compliant = true
+        return
+      end
+      
+      puts "找到 #{so_files.length} 个共享库文件"
+      
+      unaligned_libs = []
+      
+      so_files.each do |so_file|
+        alignment_status = check_elf_alignment(so_file)
+        
+        if alignment_status[:aligned]
+          puts "\e[32m✓ #{File.basename(so_file)}: ALIGNED (#{alignment_status[:alignment]})\e[0m"
+        else
+          puts "\e[31m✗ #{File.basename(so_file)}: UNALIGNED (#{alignment_status[:alignment]})\e[0m"
+          unaligned_libs << {
+            file: so_file,
+            alignment: alignment_status[:alignment],
+            architecture: alignment_status[:architecture]
+          }
+        end
+      end
+      
+      result.unaligned_libs = unaligned_libs
+      
+      # 检查是否有 arm64-v8a 或 x86_64 架构的未对齐库
+      critical_unaligned = unaligned_libs.select do |lib|
+        arch = lib[:architecture]
+        arch == 'arm64-v8a' || arch == 'x86_64'
+      end
+      
+      if critical_unaligned.empty?
+        result.elf_alignment_compliant = true
+        puts "\e[32m✓ 所有关键架构 (arm64-v8a/x86_64) 的共享库都已正确对齐\e[0m"
+      else
+        result.elf_alignment_compliant = false
+        critical_unaligned.each do |lib|
+          result.add_issue("#{lib[:architecture]} 架构的共享库 #{File.basename(lib[:file])} 未对齐 (16KB 页面大小要求)")
+        end
+        puts "\e[31m✗ 发现 #{critical_unaligned.length} 个关键架构的未对齐共享库\e[0m"
+      end
+    end
+    
+    # 查找共享库文件
+    def self.find_shared_libraries(temp_dir)
+      so_files = []
+      
+      # 在 temp_dir 中查找所有 .so 文件
+      Dir.glob(File.join(temp_dir, "**", "*.so")).each do |so_file|
+        so_files << so_file
+      end
+      
+      # 也检查 base.apk 中的库文件
+      base_apk_path = File.join(temp_dir, "base.apk")
+      if File.exist?(base_apk_path)
+        base_temp_dir = nil
+        begin
+          base_temp_dir = Dir.mktmpdir("base_apk_libs_")
+          
+          # 解压 base.apk 中的 lib 目录
+          if system("unzip", "-q", base_apk_path, "lib/*", "-d", base_temp_dir)
+            Dir.glob(File.join(base_temp_dir, "lib", "**", "*.so")).each do |so_file|
+              so_files << so_file
+            end
+          end
+        ensure
+          FileUtils.rm_rf(base_temp_dir) if base_temp_dir && File.directory?(base_temp_dir)
+        end
+      end
+      
+      so_files.uniq
+    end
+    
+    # 检查单个 ELF 文件的对齐状态
+    def self.check_elf_alignment(so_file)
+      begin
+        # 首先检查文件是否为有效的 ELF 文件
+        file_output = `file "#{so_file}" 2>/dev/null`
+        unless file_output && file_output.include?('ELF')
+          return {
+            aligned: false,
+            alignment: "not_elf",
+            architecture: determine_architecture(so_file)
+          }
+        end
+        
+        # 使用 objdump 检查 ELF 文件的对齐
+        unless tool_available?('objdump')
+          puts "objdump 不可用，无法检查 ELF 对齐"
+          return {
+            aligned: false,
+            alignment: "tool_missing",
+            architecture: determine_architecture(so_file)
+          }
+        end
+        
+        objdump_output = `objdump -p "#{so_file}" 2>/dev/null`
+        
+        if objdump_output && !objdump_output.empty?
+          # 查找 LOAD 段的对齐信息
+          load_sections = objdump_output.lines.select { |line| line.include?('LOAD') }
+          
+          if !load_sections.empty?
+            # 获取第一个 LOAD 段的对齐值
+            first_load = load_sections.first
+            # 更精确的正则表达式匹配对齐值
+            alignment_match = first_load.match(/LOAD\s+off\s+0x[0-9a-f]+\s+vaddr\s+0x[0-9a-f]+\s+paddr\s+0x[0-9a-f]+\s+align\s+2\*\*(\d+)/)
+            
+            if alignment_match
+              alignment_power = alignment_match[1].to_i
+              alignment_value = 2 ** alignment_power
+              
+              # 检查是否满足 16KB 对齐要求 (2^14 = 16384)
+              aligned = alignment_value >= 16384
+              
+              # 确定架构
+              architecture = determine_architecture(so_file)
+              
+              return {
+                aligned: aligned,
+                alignment: "2^#{alignment_power}",
+                architecture: architecture
+              }
+            end
+          end
+        end
+        
+        # 如果 objdump 失败，尝试使用 readelf
+        unless tool_available?('readelf')
+          puts "readelf 不可用，无法检查 ELF 对齐"
+          return {
+            aligned: false,
+            alignment: "tool_missing",
+            architecture: determine_architecture(so_file)
+          }
+        end
+        
+        readelf_output = `readelf -l "#{so_file}" 2>/dev/null`
+        if readelf_output && !readelf_output.empty?
+          # 查找 LOAD 段的对齐信息
+          load_sections = readelf_output.lines.select { |line| line.include?('LOAD') }
+          
+          if !load_sections.empty?
+            first_load = load_sections.first
+            alignment_match = first_load.match(/LOAD\s+0x[0-9a-f]+\s+0x[0-9a-f]+\s+0x[0-9a-f]+\s+0x[0-9a-f]+\s+0x[0-9a-f]+\s+(\d+)/)
+            
+            if alignment_match
+              alignment_value = alignment_match[1].to_i
+              alignment_power = Math.log2(alignment_value).to_i if alignment_value > 0
+              
+              aligned = alignment_value >= 16384
+              architecture = determine_architecture(so_file)
+              
+              return {
+                aligned: aligned,
+                alignment: alignment_value > 0 ? "2^#{alignment_power}" : "0",
+                architecture: architecture
+              }
+            end
+          end
+        end
+        
+        # 如果所有方法都失败，返回未对齐状态
+        return {
+          aligned: false,
+          alignment: "unknown",
+          architecture: determine_architecture(so_file)
+        }
+        
+      rescue => e
+        puts "检查 ELF 对齐失败 #{so_file}: #{e.message}"
+        return {
+          aligned: false,
+          alignment: "error",
+          architecture: determine_architecture(so_file)
+        }
+      end
+    end
+    
+    # 确定共享库的架构
+    def self.determine_architecture(so_file)
+      # 从文件路径中提取架构信息
+      if so_file.include?('/arm64-v8a/')
+        'arm64-v8a'
+      elsif so_file.include?('/x86_64/')
+        'x86_64'
+      elsif so_file.include?('/armeabi-v7a/')
+        'armeabi-v7a'
+      elsif so_file.include?('/x86/')
+        'x86'
+      elsif so_file.include?('/armeabi/')
+        'armeabi'
+      else
+        'unknown'
+      end
+    end
+    
+    # 打印合规检测摘要
+    def self.print_compliance_summary(result)
+      puts "\n\e[1m=== Google Play 合规检测摘要 ===\e[0m"
+      
+      # AAB 包体积检测结果
+      if result.size_compliant
+        puts "\e[32m✓ AAB 包体积: #{result.aab_size_mb} MB (符合 Google Play 限制)\e[0m"
+      else
+        puts "\e[31m✗ AAB 包体积: #{result.aab_size_mb} MB (超出 Google Play 限制)\e[0m"
+      end
+      
+      # Target SDK 检测结果
+      if result.target_sdk_compliant
+        puts "\e[32m✓ Target SDK: #{result.target_sdk_version} (符合 Android 15 要求)\e[0m"
+      else
+        puts "\e[31m✗ Target SDK: #{result.target_sdk_version} (需要至少 35)\e[0m"
+      end
+      
+      # ELF 对齐检测结果
+      if result.elf_alignment_compliant
+        puts "\e[32m✓ ELF 对齐: 所有关键架构共享库已正确对齐 (16KB 页面大小)\e[0m"
+      else
+        puts "\e[31m✗ ELF 对齐: 发现 #{result.unaligned_libs.length} 个未对齐的共享库\e[0m"
+      end
+      
+      # 总体合规状态
+      puts "\n\e[1m--- 总体合规状态 ---\e[0m"
+      if result.compliant?
+        puts "\e[32m\e[1m✓ 符合 Google Play 最新合规要求，可以正常提交\e[0m"
+      else
+        puts "\e[31m\e[1m✗ 不符合 Google Play 合规要求，需要修复以下问题:\e[0m"
+        result.compliance_issues.each do |issue|
+          puts "\e[31m  - #{issue}\e[0m"
+        end
+      end
+      
+      # 警告信息
+      if !result.warnings.empty?
+        puts "\n--- 警告信息 ---"
+        result.warnings.each do |warning|
+          puts "\e[33m  ⚠ #{warning}\e[0m"
+        end
+      end
+      
+      puts "================================"
+    end
+  end
+end