pindo 5.10.6 → 5.10.9

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

@@ -0,0 +1,300 @@
+require 'singleton'
+require_relative 'android_project_helper'
+require_relative 'gradle_helper'
+require_relative 'gp_compliance_helper'
+require_relative 'java_env_helper'
+require_relative 'keystore_helper'
+require 'fileutils'
+
+module Pindo
+  class AndroidBuildHelper
+    include Singleton
+
+
+
+    class << self
+      def share_instance
+        instance
+      end
+    end
+    
+
+    def auto_build_apk(project_dir, debug = false, ignore_sub = false)
+      raise ArgumentError, "项目目录不能为空" if project_dir.nil?
+      raise ArgumentError, "项目目录不存在" unless File.directory?(project_dir)
+
+      # 设置 Java Home 环境变量
+      Pindo::JavaEnvHelper.setup_java_home_from_project(project_dir)
+
+      # 检查并配置 Gradle Wrapper
+      Pindo::GradleHelper.check_gradle_with_project(project_dir)
+
+      # 1. 处理独立的 Unity 导出工程
+      if Pindo::AndroidProjectHelper.unity_android_project?(project_dir)
+        puts "处理独立的 Unity 导出工程..."
+        Pindo::GradleHelper.update_build_gradle(project_dir)
+        Pindo::AndroidProjectHelper.add_unity_namespace(project_dir)
+        Pindo::AndroidProjectHelper.modify_il2cpp_config(project_dir)
+        Pindo::AndroidProjectHelper.remove_desktop_google_service(project_dir)
+
+      # 2. 处理 Unity 作为 lib 的原生工程（Unity 放在 Unity 目录下）
+      elsif Pindo::AndroidProjectHelper.unity_as_lib_android_project?(project_dir)
+        puts "处理 Unity 作为 lib 的原生工程..."
+        unity_dir = File.join(project_dir, "Unity")
+
+        if File.directory?(unity_dir)
+          puts "找到 Unity 模块目录: Unity/"
+
+          # 如果 Unity 子目录是完整的 Unity 导出工程，对其进行处理
+          if Pindo::AndroidProjectHelper.unity_android_project?(unity_dir)
+            puts "Unity 子目录是完整的 Unity 导出工程，执行 Unity 特有处理..."
+
+            # 更新 Gradle 配置 - update_build_gradle 现在会自动处理主工程和 Unity 模块
+            Pindo::GradleHelper.update_build_gradle(project_dir)
+
+            # Unity 特有的处理
+            Pindo::AndroidProjectHelper.add_unity_namespace(unity_dir)
+            Pindo::AndroidProjectHelper.modify_il2cpp_config(unity_dir)
+            Pindo::AndroidProjectHelper.remove_desktop_google_service(unity_dir)
+          end
+
+          # 构建 SO 库（如果使用 IL2CPP）
+          # 检查是否存在 IL2CPP 输出目录（表示使用 IL2CPP 而非 Mono）
+          il2cpp_dir = File.join(unity_dir, "unityLibrary/src/main/Il2CppOutputProject")
+          if File.directory?(il2cpp_dir)
+            puts "检测到 IL2CPP 项目，构建 Unity 模块的 SO 库..."
+            unless build_so_library(unity_dir)
+              raise RuntimeError, "编译 Unity 模块 SO 库失败"
+            end
+            copy_so_files(unity_dir, project_dir)
+
+            # SO 库拷贝完成后，重新配置主工程的 Java Home 和 Gradle 环境
+            puts "\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+            puts "Unity SO库编译完成，切换到主工程编译环境"
+            puts "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n"
+            Pindo::JavaEnvHelper.setup_java_home_from_project(project_dir, use_main: true)
+            Pindo::GradleHelper.check_gradle_with_project(project_dir, configure_main: true)
+
+            # 检查并配置主工程的 local.properties
+            Pindo::AndroidProjectHelper.check_main_local_properties(project_dir)
+          else
+            puts "未检测到 IL2CPP 目录，可能使用 Mono 后端，跳过 SO 库构建"
+          end
+        else
+          puts "警告：Unity 作为 lib 的工程，但未找到 Unity 目录"
+        end
+
+      # 3. 处理 Android 原生工程
+      else
+        puts "处理 Android 原生工程..."
+        # 更新 Gradle 配置，确保使用兼容的版本
+        Pindo::GradleHelper.update_build_gradle(project_dir)
+      end
+
+      # 配置 Keystore 签名
+      build_type = debug ? "debug" : "release"
+      puts "\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+      puts "配置 Keystore 签名 (#{build_type})"
+      puts "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n"
+
+      if Pindo::KeystoreHelper.apply_keystore_config(project_dir, build_type)
+        puts "✓ Keystore 签名配置成功"
+      else
+        puts "⚠ Keystore 签名配置跳过（使用工程原有配置）"
+      end
+
+      # 构建 APK
+      build_apk(project_dir, debug)
+    end
+
+    def build_apk(project_path, debug)
+      raise ArgumentError, "项目路径不能为空" if project_path.nil? || project_path.empty?
+
+      # 构建 AAB 文件
+      unless build_aab(project_path, debug)
+        raise RuntimeError, "AAB 构建失败"
+      end
+
+      # 获取必要的配置信息
+      main_module = Pindo::AndroidProjectHelper.get_main_module(project_path)
+      raise ArgumentError, "无法找到主模块" unless main_module
+
+      keystore_config = Pindo::KeystoreHelper.get_keystore_config_from_project(project_path, debug)
+      raise ArgumentError, "无法从 build.gradle 中获取 keystore 信息" unless keystore_config
+
+      build_tools = Pindo::AndroidProjectHelper.get_build_tools
+      unless build_tools
+        Funlog.error("无法继续构建：缺少必要的构建工具")
+        return nil
+      end
+
+      bundle_tool = build_tools[:bundle_tool]
+      unless bundle_tool && File.exist?(bundle_tool)
+        Funlog.error("无法找到 bundletool.jar")
+        return nil
+      end
+
+      # 准备输出路径
+      build_type = debug ? 'debug' : 'release'
+      main_module_name = File.basename(main_module)
+      output_dir = File.join(project_path, "build/apks")
+
+      # 清理已存在的文件
+      FileUtils.rm_rf(output_dir)
+      FileUtils.mkdir_p(output_dir)
+
+      # 构建路径配置
+      paths = {
+        output_apks: File.join(output_dir, "app.apks"),
+        bundle: File.join(main_module, "build/outputs/bundle/#{build_type}/#{main_module_name}-#{build_type}.aab"),
+        universal_apk: File.join(output_dir, "universal.apk")
+      }
+
+      # 检查 bundle 文件是否存在
+      unless File.exist?(paths[:bundle])
+        raise RuntimeError, "找不到 AAB 文件: #{paths[:bundle]}"
+      end
+
+      # --- Google Play 合规检测 (包含包体积、Target SDK、ELF对齐检测) ---
+      begin
+        compliance_result = Pindo::GPComplianceHelper.check_aab_compliance(paths[:bundle])
+
+        # 合规检测结果已在 gp_compliance_helper.rb 中输出，这里只做简单的状态提示
+        if compliance_result.compliant?
+          puts "\e[32m\e[1m✓ AAB 包符合 Google Play 最新合规要求，可以正常提交\e[0m"
+        else
+          puts "\e[31m\e[1m✗ AAB 包不符合 Google Play 提交标准，需要修复合规问题才能提交！！！\e[0m"
+        end
+
+        # 添加合规检测说明
+        puts "\e[36m\e[1m📋 合规检测说明：\e[0m"
+        puts "\e[33m  • 仅供测试用的包可以忽略合规检测问题\e[0m"
+        puts "\e[33m  • 提交至 Google Play 的正式用包必须处理所有合规检测问题\e[0m"
+        puts "\e[33m  • 建议在正式发布前解决所有合规问题以确保顺利上架\e[0m"
+
+      rescue => e
+        puts "\e[31mGoogle Play 合规检测失败: #{e.message}\e[0m"
+        puts "\e[33m建议手动检查包体积、Target SDK 版本和共享库对齐情况\e[0m"
+      end
+      # --- END ---
+
+      # puts "解析 keystore 配置"
+      ks = keystore_config[:store_file]
+      # puts "读取 keystore path = #{ks}"
+      ks_pass = keystore_config[:store_password]
+      # puts "读取 keystore pass = #{ks_pass}"
+      key_alias = keystore_config[:key_alias]
+      # puts "读取 key alias = #{key_alias}"
+      key_pass = keystore_config[:key_password]
+      # puts "读取 key pass = #{key_pass}"
+
+      # 构建 APK
+      # 确保使用正确的 Java 版本 (Java 11+)
+      java_cmd = Pindo::JavaEnvHelper.find_java_command
+
+      # 验证 Java 版本
+      unless Pindo::JavaEnvHelper.verify_java_version(java_cmd)
+        raise RuntimeError, "Java 版本不符合要求，bundletool 需要 Java 11+，当前使用的 Java: #{java_cmd}"
+      end
+
+      # 使用数组形式构建命令，正确处理包含空格的路径
+      bundletool_cmd = [
+        java_cmd, "-jar", bundle_tool, "build-apks",
+        "--bundle=#{paths[:bundle]}",
+        "--output=#{paths[:output_apks]}",
+        "--ks=#{ks}",
+        "--ks-pass=pass:#{ks_pass}",
+        "--ks-key-alias=#{key_alias}",
+        "--key-pass=pass:#{key_pass}",
+        "--mode=universal"
+      ]
+
+      # puts bundletool_cmd
+      # 验证关键文件是否存在
+      unless File.exist?(paths[:bundle])
+        raise RuntimeError, "AAB 文件不存在: #{paths[:bundle]}"
+      end
+
+      unless File.exist?(ks)
+        raise RuntimeError, "Keystore 文件不存在"
+      end
+
+      unless system(*bundletool_cmd)
+        # 检查是否是 Java 版本问题
+        if java_cmd == 'java'
+          raise RuntimeError, "APKS 构建失败。可能是 Java 版本不兼容，bundletool 需要 Java 11+，请检查 JAVA_HOME 环境变量或安装正确的 Java 版本"
+        else
+          raise RuntimeError, "APKS 构建失败。使用的 Java 命令: #{java_cmd}"
+        end
+      end
+
+      # 解压 APKs 文件
+      unless system("unzip", "-o", paths[:output_apks], "-d", output_dir)
+        raise RuntimeError, "APKS 解压失败"
+      end
+
+      # 返回生成的 APK 路径
+      unless File.exist?(paths[:universal_apk])
+        raise RuntimeError, "未找到生成的 APK 文件"
+      end
+
+      paths[:universal_apk]
+    end
+
+    def build_aab(project_path, debug)
+      Dir.chdir(project_path) do
+        system("./gradlew bundle#{debug ? 'Debug' : 'Release'}")
+      end
+    end
+
+    def build_so_library(project_path)
+      # 编译so库
+      Dir.chdir(project_path) do
+        system("./gradlew unityLibrary:BuildIl2CppTask")
+      end
+    end
+
+    def copy_so_files(source_path, target_path)
+      puts "拷贝 Unity 编译产物到主工程..."
+
+      # 需要拷贝的目录列表（参考 copy_unity_export.sh）
+      copy_dirs = [
+        "unityLibrary/libs",                # Java/Kotlin 库（包含 unity-classes.jar）
+        "unityLibrary/src/main/assets",     # Unity 资源文件
+        "unityLibrary/src/main/jniLibs"     # SO 库文件（IL2CPP 编译产物）
+      ]
+
+      copy_dirs.each do |dir|
+        src_dir = File.join(source_path, dir)
+        dst_dir = File.join(target_path, dir)
+
+        if File.directory?(src_dir)
+          puts "  ✓ 拷贝: #{dir}"
+
+          # 确保目标目录存在
+          FileUtils.mkdir_p(dst_dir)
+
+          # 拷贝目录内容（不包括目录本身）
+          Dir.glob(File.join(src_dir, "*")).each do |src_item|
+            dst_item = File.join(dst_dir, File.basename(src_item))
+
+            if File.directory?(src_item)
+              # 递归拷贝子目录
+              FileUtils.cp_r(src_item, dst_item, remove_destination: true)
+            else
+              # 拷贝文件
+              FileUtils.cp(src_item, dst_item)
+            end
+          end
+        else
+          puts "  ⚠ 跳过: #{dir} (目录不存在)"
+        end
+      end
+
+      puts "Unity 编译产物拷贝完成\n"
+    end
+
+
+  end
+end
+

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

@@ -0,0 +1,279 @@
+module Pindo
+  class AndroidProjectHelper
+    class << self
+
+
+      def unity_android_project?(project_path)
+        # 检查 unityLibrary 模块是否存在
+        unity_library_path = File.join(project_path, "unityLibrary")
+        return false unless File.directory?(unity_library_path)
+
+        # 检查 unityLibrary 的 build.gradle 或 build.gradle.kts 是否存在
+        unity_gradle_path = File.join(unity_library_path, "build.gradle")
+        unity_gradle_kts_path = File.join(unity_library_path, "build.gradle.kts")
+        if File.exist?(unity_gradle_kts_path)
+          unity_gradle_path = unity_gradle_kts_path
+        elsif !File.exist?(unity_gradle_path)
+          return false
+        end
+
+        # 检查 build.gradle 中是否包含 Unity 特有的配置
+        content = File.read(unity_gradle_path)
+        content.include?("com.android.library") && content.include?("BuildIl2Cpp")
+      end
+
+      def unity_as_lib_android_project?(project_path)
+        # Unity 作为 lib 的判断条件简化版:
+        # 1. 不是独立的 Unity 导出工程
+        return false if unity_android_project?(project_path)
+
+        # 2. 检查是否存在 Unity 目录
+        unity_dir = File.join(project_path, "Unity")
+        return false unless File.directory?(unity_dir)
+
+        # 3. 检查 Unity 目录下是否有 unityLibrary 目录
+        unity_library_dir = File.join(unity_dir, "unityLibrary")
+        return false unless File.directory?(unity_library_dir)
+
+        # 4. 检查 Unity/unityLibrary 目录下是否有 build.gradle 或 build.gradle.kts
+        gradle_path = File.join(unity_library_dir, "build.gradle")
+        gradle_kts_path = File.join(unity_library_dir, "build.gradle.kts")
+
+        File.exist?(gradle_path) || File.exist?(gradle_kts_path)
+      end
+
+
+      def get_build_tools
+        # 获取 gem 资源文件路径
+        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')
+
+        # 检查工具目录是否存在
+        unless File.directory?(tools_dir)
+          Funlog.error("Android 构建工具目录不存在: #{tools_dir}")
+          Funlog.error("请执行以下命令更新 Pindo 配置:")
+          Funlog.error("  pindo setup")
+          Funlog.error("或手动克隆配置仓库到 ~/.pindo/pindo_common_config")
+          return nil
+        end
+
+        # 定义必要的工具
+        required_tools = {
+          bundle_tool: 'bundletool.jar',
+          gradlew: 'gradlew',
+          gradle_wrapper: 'gradle-wrapper.jar'
+        }
+
+        tools = {}
+        missing_tools = []
+
+        # 检查每个工具是否存在
+        required_tools.each do |key, filename|
+          path = File.join(tools_dir, filename)
+          if File.exist?(path)
+            tools[key] = path
+          else
+            missing_tools << filename
+          end
+        end
+
+        # 如果有缺失的工具，提供友好的错误信息
+        unless missing_tools.empty?
+          Funlog.error("缺少以下 Android 构建工具:")
+          missing_tools.each do |tool|
+            Funlog.error("  - #{tool}")
+          end
+          Funlog.error("")
+          Funlog.error("解决方案:")
+          Funlog.error("  1. 执行 'pindo setup' 更新配置")
+          Funlog.error("  2. 或手动下载缺失的工具到: #{tools_dir}")
+          Funlog.error("")
+          Funlog.error("如果问题持续存在，请检查:")
+          Funlog.error("  - 网络连接是否正常")
+          Funlog.error("  - Git 仓库是否可访问")
+          Funlog.error("  - 目录权限是否正确")
+          return nil
+        end
+
+        tools
+      end
+
+      def modify_il2cpp_config(project_path)
+        # 设置Il2CppOutputProject可执行权限
+        system("chmod", "-R", "777",
+        File.join(project_path, "unityLibrary/src/main/Il2CppOutputProject"))
+
+        il2cpp_config_path = File.join(project_path, "unityLibrary/src/main/Il2CppOutputProject/IL2CPP/libil2cpp/il2cpp-config.h")
+        content = File.read(il2cpp_config_path)
+        content.gsub!("il2cpp::vm::Exception::Raise", "//il2cpp::vm::Exception::Raise")
+        File.write(il2cpp_config_path, content)
+      end
+
+      def remove_desktop_google_service(project_path)
+        # 删除google-services-desktop.json
+        desktop_google_service_path = File.join(project_path,
+          "unityLibrary/src/main/assets/google-services-desktop.json")
+        File.delete(desktop_google_service_path) if File.exist?(desktop_google_service_path)
+      end
+
+      def add_unity_namespace(project_path)
+        # 在 unityLibrary/build.gradle 中添加 namespace（AGP 7.x+ 需要）
+        unity_build_gradle = File.join(project_path, "unityLibrary/build.gradle")
+        return unless File.exist?(unity_build_gradle)
+
+        content = File.read(unity_build_gradle)
+
+        # 检查是否已经有 namespace
+        if content =~ /namespace\s+['"][\w.]+['"]/
+          puts "  ✓ unityLibrary 已配置 namespace"
+          return
+        end
+
+        # 在 android { 块的开始位置添加 namespace
+        if content =~ /(android\s*\{)/
+          # Unity 默认使用 com.unity3d.player 作为 namespace
+          namespace_line = "\n    namespace 'com.unity3d.player'\n"
+          content.sub!(/(android\s*\{)/, "\\1#{namespace_line}")
+
+          File.write(unity_build_gradle, content)
+          puts "  ✓ 已添加 namespace 到 unityLibrary/build.gradle"
+        else
+          puts "  ⚠ 无法在 unityLibrary/build.gradle 中找到 android 块"
+        end
+      end
+
+      def check_main_local_properties(project_path)
+        # 检查并配置主工程的 local.properties 文件
+        main_local_properties = File.join(project_path, "local.properties")
+
+        # 获取期望的 SDK 路径（从 Unity 模块、环境变量或默认路径）
+        expected_sdk_dir = get_expected_sdk_dir(project_path)
+
+        unless expected_sdk_dir
+          puts "  ⚠ 无法找到有效的 Android SDK 路径"
+          return
+        end
+
+        if File.exist?(main_local_properties)
+          # 文件存在，检查 sdk.dir 是否正确
+          puts "  检查主工程 local.properties..."
+          content = File.read(main_local_properties)
+
+          if content =~ /sdk\.dir\s*=\s*(.+)/
+            current_sdk_dir = $1.strip
+
+            if current_sdk_dir == expected_sdk_dir
+              puts "  ✓ SDK 路径正确: #{current_sdk_dir}"
+            elsif File.directory?(current_sdk_dir)
+              puts "  ✓ SDK 路径有效: #{current_sdk_dir}"
+            else
+              # SDK 路径无效，更新为期望的路径
+              puts "  ⚠ SDK 路径无效: #{current_sdk_dir}"
+              puts "  更新为: #{expected_sdk_dir}"
+              content.gsub!(/sdk\.dir\s*=\s*.+/, "sdk.dir=#{expected_sdk_dir}")
+              File.write(main_local_properties, content)
+              puts "  ✓ 已更新 SDK 路径"
+            end
+          else
+            # 文件存在但没有 sdk.dir，添加它
+            puts "  ⚠ local.properties 中未找到 sdk.dir"
+            File.write(main_local_properties, "#{content}\nsdk.dir=#{expected_sdk_dir}\n")
+            puts "  ✓ 已添加 SDK 路径: #{expected_sdk_dir}"
+          end
+        else
+          # 文件不存在，创建它
+          puts "  创建主工程 local.properties..."
+          File.write(main_local_properties, "sdk.dir=#{expected_sdk_dir}\n")
+          puts "  ✓ 已创建 local.properties，SDK 路径: #{expected_sdk_dir}"
+        end
+      end
+
+      def get_expected_sdk_dir(project_path)
+        # 优先使用 Android Studio 的 SDK 路径（主工程使用）
+        android_studio_sdk = File.expand_path("~/Library/Android/sdk")
+        return android_studio_sdk if File.directory?(android_studio_sdk)
+
+        # 尝试从环境变量获取
+        sdk_dir = ENV['ANDROID_HOME'] || ENV['ANDROID_SDK_ROOT']
+        return sdk_dir if sdk_dir && File.directory?(sdk_dir)
+
+        # 尝试从 Unity 模块的 local.properties 获取 SDK 路径
+        unity_local_properties = File.join(project_path, "Unity/local.properties")
+
+        if File.exist?(unity_local_properties)
+          unity_content = File.read(unity_local_properties)
+          if unity_content =~ /sdk\.dir\s*=\s*(.+)/
+            sdk_dir = $1.strip
+            return sdk_dir if File.directory?(sdk_dir)
+          end
+        end
+
+        # 最后尝试 Unity 内置的 SDK 路径
+        unity_sdk = "/Applications/Unity/Hub/Editor/2022.3.61f1/PlaybackEngines/AndroidPlayer/SDK"
+        return unity_sdk if File.directory?(unity_sdk)
+
+        nil
+      end
+
+      def get_main_module(project_path)
+        settings_gradle_path = File.join(project_path, "settings.gradle")
+        settings_gradle_kts_path = File.join(project_path, "settings.gradle.kts")
+
+        # 优先使用 settings.gradle.kts，如果不存在则使用 settings.gradle
+        if File.exist?(settings_gradle_kts_path)
+          settings_gradle_path = settings_gradle_kts_path
+        elsif !File.exist?(settings_gradle_path)
+          return nil
+        end
+
+        content = File.read(settings_gradle_path)
+        # 兼容 include ':app' 和 include(":app")
+        modules = content.scan(/include\s*\(?\s*['\"]?([:\w\-]+)['\"]?\s*\)?/).flatten
+
+        main_module = modules.find do |m|
+          module_name = m.split(':').last
+          gradle_path = File.join(project_path, module_name, "build.gradle")
+          gradle_kts_path = File.join(project_path, module_name, "build.gradle.kts")
+
+          # 优先使用 build.gradle.kts，如果不存在则使用 build.gradle
+          if File.exist?(gradle_kts_path)
+            gradle_path = gradle_kts_path
+          end
+
+          if File.exist?(gradle_path)
+            gradle_content = File.read(gradle_path)
+            gradle_content.include?("apply plugin: 'com.android.application") ||
+              gradle_content.include?("id 'com.android.application") ||
+              (gradle_content.include?("plugins {") && gradle_content.include?("com.android.application"))
+          end
+        end
+        return nil unless main_module
+
+        module_name = main_module.split(':').last
+        File.join(project_path, module_name)
+      end
+
+
+
+
+      def find_android_subproject(project_path)
+        android_dir = File.join(project_path, "Unity")
+        return nil unless File.directory?(android_dir)
+
+        main_module = get_main_module(android_dir)
+        return nil unless main_module
+
+        src_main = File.join(main_module, "src/main")
+        return nil unless File.directory?(src_main)
+
+        manifest = File.join(src_main, "AndroidManifest.xml")
+        return nil unless File.exist?(manifest)
+
+        android_dir
+      end
+
+      private
+    end
+  end
+end