pindo 5.6.6 → 5.7.0

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

@@ -9,52 +9,30 @@ module Pindo
 
     # 常量定义
     RECOMMENDED_GRADLE_VERSION = '7.6.4'
-    MIN_GRADLE_WRAPPER_JAR_SIZE = 50_000  # 50KB
-    DOWNLOAD_TIMEOUT = 30  # 30秒
+    
+    # Gradle缓存目录
+    GRADLE_CACHE_DIR = File.expand_path("~/.pindo/pindo_common_config/android_tools/gradle-cache")
 
     def check_gradle_files(project_path)
       puts "\e[36m=== 检查Gradle Wrapper配置 ===\e[0m"
       
-      # 优先使用基于gradle-wrapper.properties的自动配置
+      # 使用基于gradle-wrapper.properties的自动配置
       if File.exist?(File.join(project_path, "gradle/wrapper/gradle-wrapper.properties"))
         puts "检测到gradle-wrapper.properties文件，使用自动配置..."
         if setup_gradle_wrapper_from_properties(project_path)
           puts "\e[32m✓ 基于gradle-wrapper.properties的自动配置成功\e[0m"
           return true
         else
-          puts "\e[33m⚠ 自动配置失败，回退到传统方式\e[0m"
+          puts "\e[31m✗ 自动配置失败\e[0m"
+          return false
         end
-      end
-
-      # 回退到传统的文件复制方式
-      puts "使用传统方式配置Gradle Wrapper..."
-      setup_gradle_wrapper_traditional(project_path)
-    end
-
-    # 传统的gradle wrapper配置方式（作为回退方案）
-    def setup_gradle_wrapper_traditional(project_path)
-      # 检查是否存在 gradlew 文件 如果没有则执行复制操作
-      gradlew_path = File.join(project_path, "gradlew")
-      if File.exist?(gradlew_path)
-        puts "gradlew file already exists, skip copying."
       else
-         # 复制gradle相关文件
-        gradlew_content = File.read(get_build_tools[:gradlew])
-        File.write(gradlew_path, gradlew_content)
-      end
-      # 设置gradlew可执行权限
-      system("chmod", "777", gradlew_path)
-
-      wrapper_jar_path = File.join(project_path, "gradle/wrapper/gradle-wrapper.jar")
-      if File.exist?(wrapper_jar_path)
-        puts "gradle-wrapper.jar file already exists, skip copying."
-      else
-        FileUtils.mkdir_p(File.dirname(wrapper_jar_path))
-        gradle_wrapper_content = File.read(get_build_tools[:gradle_wrapper])
-        File.write(wrapper_jar_path, gradle_wrapper_content)
+        puts "\e[31m✗ 未找到gradle-wrapper.properties文件\e[0m"
+        return false
       end
     end
 
+
     def update_build_gradle(project_path)
       # 更新build.gradle 或 build.gradle.kts
       build_gradle_path = File.join(project_path, "build.gradle")
@@ -140,24 +118,14 @@ module Pindo
       puts "\e[36m=== 自动配置Gradle Wrapper ===\e[0m"
       puts "检测到Gradle版本: #{gradle_version}"
 
-      # 确保gradle wrapper目录存在
-      wrapper_dir = File.join(project_path, "gradle/wrapper")
-      FileUtils.mkdir_p(wrapper_dir)
-
-      # 下载并配置gradle-wrapper.jar
-      unless download_gradle_wrapper_jar(wrapper_dir, gradle_version)
-        puts "\e[31m✗ 下载gradle-wrapper.jar失败\e[0m"
-        return false
-      end
-
-      # 生成gradlew脚本
-      unless generate_gradlew_script(project_path)
-        puts "\e[31m✗ 生成gradlew脚本失败\e[0m"
+      # 改进的wrapper生成策略：优先使用官方Gradle命令
+      if setup_gradle_wrapper_improved(project_path, gradle_version)
+        puts "\e[32m✓ Gradle Wrapper配置完成\e[0m"
+        return true
+      else
+        puts "\e[31m✗ Gradle Wrapper配置失败\e[0m"
         return false
       end
-
-      puts "\e[32m✓ Gradle Wrapper配置完成\e[0m"
-      true
     end
 
     # 检查gradle wrapper配置是否完整
@@ -204,52 +172,6 @@ module Pindo
 
     # 根据当前版本确定目标版本
     def determine_target_gradle_version(current_version)
-      
-      # 版本映射表：当前版本 -> 推荐版本
-      # 对于旧版本，统一升级到推荐的稳定版本
-      version_mapping = {
-        # Gradle 6.x 系列
-        '6.1.1' => RECOMMENDED_GRADLE_VERSION,
-        '6.1' => RECOMMENDED_GRADLE_VERSION,
-        '6.0' => RECOMMENDED_GRADLE_VERSION,
-        
-        # Gradle 5.x 系列
-        '5.6' => RECOMMENDED_GRADLE_VERSION,
-        '5.5' => RECOMMENDED_GRADLE_VERSION,
-        '5.4' => RECOMMENDED_GRADLE_VERSION,
-        '5.3' => RECOMMENDED_GRADLE_VERSION,
-        '5.2' => RECOMMENDED_GRADLE_VERSION,
-        '5.1' => RECOMMENDED_GRADLE_VERSION,
-        '5.0' => RECOMMENDED_GRADLE_VERSION,
-        
-        # Gradle 4.x 系列
-        '4.10' => RECOMMENDED_GRADLE_VERSION,
-        '4.9' => RECOMMENDED_GRADLE_VERSION,
-        '4.8' => RECOMMENDED_GRADLE_VERSION,
-        '4.7' => RECOMMENDED_GRADLE_VERSION,
-        '4.6' => RECOMMENDED_GRADLE_VERSION,
-        '4.5' => RECOMMENDED_GRADLE_VERSION,
-        '4.4' => RECOMMENDED_GRADLE_VERSION,
-        '4.3' => RECOMMENDED_GRADLE_VERSION,
-        '4.2' => RECOMMENDED_GRADLE_VERSION,
-        '4.1' => RECOMMENDED_GRADLE_VERSION,
-        '4.0' => RECOMMENDED_GRADLE_VERSION,
-        
-        # Gradle 3.x 系列
-        '3.6' => RECOMMENDED_GRADLE_VERSION,
-        '3.5' => RECOMMENDED_GRADLE_VERSION,
-        '3.4' => RECOMMENDED_GRADLE_VERSION,
-        '3.3' => RECOMMENDED_GRADLE_VERSION,
-        '3.2' => RECOMMENDED_GRADLE_VERSION,
-        '3.1' => RECOMMENDED_GRADLE_VERSION,
-        '3.0' => RECOMMENDED_GRADLE_VERSION
-      }
-
-      # 精确匹配
-      if version_mapping.key?(current_version)
-        return version_mapping[current_version]
-      end
-
       # 主版本号匹配
       major_version = current_version.split('.').first.to_i
       case major_version
@@ -264,594 +186,217 @@ module Pindo
       end
     end
 
-    # 改进的生成gradle-wrapper.jar逻辑（带缓存和内置文件回退）
-    def download_gradle_wrapper_jar(wrapper_dir, gradle_version)
-      wrapper_jar_path = File.join(wrapper_dir, "gradle-wrapper.jar")
-      
-      # 1. 检查现有文件是否有效
-      if File.exist?(wrapper_jar_path) && verify_gradle_wrapper_jar_complete(wrapper_jar_path, gradle_version)
-        puts "\e[32m✓ gradle-wrapper.jar已存在且验证通过\e[0m"
-        return true
-      end
-
-      puts "正在生成gradle-wrapper.jar (版本: #{gradle_version})..."
-      
-      # 2. 尝试使用缓存
-      cached_jar = get_cached_gradle_wrapper_jar(gradle_version)
-      if cached_jar
-        FileUtils.cp(cached_jar, wrapper_jar_path)
-        # 验证缓存文件
-        if verify_gradle_wrapper_jar_complete(wrapper_jar_path, gradle_version)
-          puts "\e[32m✓ 从缓存复制 gradle-wrapper.jar 成功\e[0m"
-          return true
-        else
-          puts "\e[33m⚠ 缓存文件验证失败，继续下载\e[0m"
-        end
-      end
+    # 简化的Gradle Wrapper生成策略
+    def setup_gradle_wrapper_improved(project_path, gradle_version)
+      puts "\e[36m=== Gradle Wrapper生成策略 ===\e[0m"
       
-      # 3. 尝试下载
-      if download_standard_wrapper_jar(wrapper_jar_path, gradle_version)
-        # 验证下载的文件
-        if verify_gradle_wrapper_jar_complete(wrapper_jar_path, gradle_version)
-          return true
-        else
-          puts "\e[33m⚠ 下载文件验证失败，使用内置文件\e[0m"
-        end
-      end
-      
-      # 4. 最后回退：使用内置文件
-      puts "\e[33m⚠ 所有下载源失败，使用内置 gradle-wrapper.jar\e[0m"
-      if use_builtin_gradle_wrapper_jar(wrapper_jar_path, gradle_version)
-        return true
+      # 直接下载并设置项目对应的Gradle环境
+      if download_and_setup_gradle(gradle_version)
+        return generate_gradle_wrapper_official(project_path, gradle_version)
       end
       
-      puts "\e[31m✗ 无法获取有效的 gradle-wrapper.jar\e[0m"
+      puts "\e[31m✗ 无法获取有效的Gradle环境\e[0m"
       false
     end
 
 
-    # 改进的手动生成wrapper逻辑（带内置文件回退）
-    def generate_wrapper_manually(project_path, gradle_version)
-      puts "手动生成gradle wrapper..."
+
+    # 下载并设置Gradle环境
+    def download_and_setup_gradle(gradle_version)
+      puts "下载并设置Gradle #{gradle_version}环境..."
       
-      # 确保wrapper目录存在
-      wrapper_dir = File.join(project_path, "gradle/wrapper")
-      FileUtils.mkdir_p(wrapper_dir)
+      # 确保缓存目录存在
+      FileUtils.mkdir_p(GRADLE_CACHE_DIR)
       
-      # 1. 生成gradlew脚本（带内置文件回退）
-      gradlew_path = File.join(project_path, "gradlew")
-      unless File.exist?(gradlew_path)
-        puts "生成gradlew脚本..."
-        unless generate_gradlew_script(project_path)
-          puts "\e[31m✗ 生成gradlew脚本失败\e[0m"
-          return false
-        end
+      # 检查是否已解压
+      gradle_home = File.join(GRADLE_CACHE_DIR, "gradle-#{gradle_version}")
+      gradle_bin = File.join(gradle_home, "bin/gradle")
+      
+      if File.exist?(gradle_bin)
+        puts "✓ 使用已解压的Gradle #{gradle_version}"
+        setup_gradle_environment(gradle_home)
+        return true
       end
       
-      # 2. 生成gradle-wrapper.jar（带缓存和内置文件回退）
-      wrapper_jar_path = File.join(wrapper_dir, "gradle-wrapper.jar")
-      unless File.exist?(wrapper_jar_path)
-        puts "生成gradle-wrapper.jar..."
-        unless download_gradle_wrapper_jar(wrapper_dir, gradle_version)
-          puts "\e[31m✗ 生成gradle-wrapper.jar失败\e[0m"
-          return false
-        end
+      # 下载Gradle分发包
+      if download_gradle_distribution(gradle_version)
+        setup_gradle_environment(gradle_home)
+        return true
       end
       
-      puts "\e[32m✓ gradle wrapper手动生成成功\e[0m"
-      true
-    rescue => e
-      puts "\e[31m✗ 手动生成wrapper异常: #{e.message}\e[0m"
       false
     end
 
-    # 获取缓存目录路径
-    def get_gradle_wrapper_cache_dir
-      File.expand_path("~/.pindo/pindo_common_config/android_tools/gradle-wrapper-cache")
-    end
-
-    # 获取内置文件路径
-    def get_builtin_gradle_wrapper_jar_path
-      File.expand_path("~/.pindo/pindo_common_config/android_tools/gradle-wrapper.jar")
-    end
-
-    def get_builtin_gradlew_path
-      File.expand_path("~/.pindo/pindo_common_config/android_tools/gradlew")
-    end
-
-    # 检查并获取缓存的 gradle-wrapper.jar
-    def get_cached_gradle_wrapper_jar(gradle_version)
-      cache_dir = get_gradle_wrapper_cache_dir
-      FileUtils.mkdir_p(cache_dir)
-      
-      cached_jar = File.join(cache_dir, "gradle-wrapper-#{gradle_version}.jar")
-      
-      if File.exist?(cached_jar) && verify_gradle_wrapper_jar_complete(cached_jar, gradle_version)
-        puts "\e[32m✓ 使用缓存的 gradle-wrapper.jar (版本: #{gradle_version})\e[0m"
-        return cached_jar
-      end
+    # 下载Gradle分发包
+    def download_gradle_distribution(gradle_version)
+      puts "下载Gradle #{gradle_version}分发包..."
       
-      nil
-    end
-
-    # 增强的 gradle-wrapper.jar 验证
-    def verify_gradle_wrapper_jar_complete(jar_path, expected_version)
-      return false unless File.exist?(jar_path)
-      
-      # 检查文件大小（正常应该在 50KB-200KB 之间）
-      file_size = File.size(jar_path)
-      unless file_size.between?(50000, 200000)
-        puts "\e[33m⚠ gradle-wrapper.jar 大小异常: #{file_size} 字节\e[0m"
-        return false
-      end
+      distribution_url = "https://services.gradle.org/distributions/gradle-#{gradle_version}-bin.zip"
+      cache_file = File.join(GRADLE_CACHE_DIR, "gradle-#{gradle_version}-bin.zip")
+      extract_dir = File.join(GRADLE_CACHE_DIR, "gradle-#{gradle_version}")
       
-      # 检查 jar 文件是否包含必要的类
-      required_classes = [
-        "org.gradle.wrapper.GradleWrapperMain",
-        "org.gradle.cli.CommandLineParser",
-        "org.gradle.wrapper.WrapperExecutor"
-      ]
-      
-      missing_classes = []
-      required_classes.each do |class_name|
-        unless verify_jar_contains_class(jar_path, class_name)
-          missing_classes << class_name
+      # 如果已存在ZIP文件，先检查完整性
+      if File.exist?(cache_file)
+        puts "✓ 发现缓存的Gradle分发包"
+        if verify_zip_integrity(cache_file)
+          puts "✓ 缓存文件完整性验证通过"
+          return extract_gradle_distribution(cache_file, extract_dir, gradle_version)
+        else
+          puts "⚠ 缓存文件损坏，重新下载"
+          FileUtils.rm_f(cache_file)
         end
       end
       
-      if missing_classes.any?
-        puts "\e[33m⚠ gradle-wrapper.jar 缺少必要类: #{missing_classes.join(', ')}\e[0m"
-        return false
+      # 下载分发包
+      puts "下载Gradle分发包: #{distribution_url}"
+      if download_with_curl(distribution_url, cache_file)
+        puts "✓ Gradle分发包下载成功"
+        return extract_gradle_distribution(cache_file, extract_dir, gradle_version)
       end
       
-      puts "\e[32m✓ gradle-wrapper.jar 验证通过\e[0m"
-      true
+      puts "✗ Gradle分发包下载失败"
+      false
     end
 
-    # 检查 jar 文件是否包含指定类
-    def verify_jar_contains_class(jar_path, class_name)
-      class_file = class_name.gsub('.', '/') + '.class'
-      system("jar -tf #{jar_path} | grep -q '#{class_file}'")
-    end
 
-    # 使用内置的 gradle-wrapper.jar
-    def use_builtin_gradle_wrapper_jar(wrapper_jar_path, gradle_version)
-      builtin_jar = get_builtin_gradle_wrapper_jar_path
+    # 简单的ZIP完整性检查
+    def verify_zip_integrity(zip_file)
+      puts "验证ZIP文件完整性..."
       
-      unless File.exist?(builtin_jar)
-        puts "\e[31m✗ 内置 gradle-wrapper.jar 不存在: #{builtin_jar}\e[0m"
+      # 1. 检查文件是否存在
+      unless File.exist?(zip_file)
+        puts "✗ 文件不存在: #{zip_file}"
         return false
       end
       
-      # 复制内置文件
-      FileUtils.cp(builtin_jar, wrapper_jar_path)
-      puts "\e[33m⚠ 使用内置的 gradle-wrapper.jar\e[0m"
+      # 2. 检查文件大小（Gradle分发包通常大于10MB）
+      file_size = File.size(zip_file)
+      if file_size < 10_000_000  # 10MB
+        puts "✗ 文件大小异常: #{file_size} 字节 (应该大于10MB)"
+        return false
+      end
       
-      # 验证复制后的文件
-      if verify_gradle_wrapper_jar_complete(wrapper_jar_path, gradle_version)
-        puts "\e[32m✓ 内置 gradle-wrapper.jar 验证通过\e[0m"
+      # 3. 使用unzip -t测试ZIP文件完整性
+      test_cmd = "unzip -t '#{zip_file}' > /dev/null 2>&1"
+      if system(test_cmd)
+        puts "✓ ZIP文件完整性验证通过"
         return true
       else
-        puts "\e[31m✗ 内置 gradle-wrapper.jar 验证失败\e[0m"
+        puts "✗ ZIP文件完整性验证失败"
         return false
       end
+    rescue => e
+      puts "✗ ZIP文件验证异常: #{e.message}"
+      false
     end
 
-    # 使用内置的 gradlew 脚本
-    def use_builtin_gradlew_script(project_path)
-      builtin_gradlew = get_builtin_gradlew_path
-      gradlew_path = File.join(project_path, "gradlew")
+    # 使用curl下载文件
+    def download_with_curl(url, output_path)
+      puts "使用curl下载: #{url}"
       
-      unless File.exist?(builtin_gradlew)
-        puts "\e[31m✗ 内置 gradlew 脚本不存在: #{builtin_gradlew}\e[0m"
-        return false
-      end
+      # 简化的curl命令，避免特殊字符问题
+      cmd = "curl -L -o '#{output_path}' '#{url}'"
+      # puts "执行命令: #{cmd}"
       
-      # 复制内置脚本
-      FileUtils.cp(builtin_gradlew, gradlew_path)
-      system("chmod", "+x", gradlew_path)
-      puts "\e[33m⚠ 使用内置的 gradlew 脚本\e[0m"
-      puts "\e[32m✓ 内置 gradlew 脚本复制完成\e[0m"
-      true
-    end
-
-    # 保存到缓存的 gradle-wrapper.jar
-    def save_to_cache(wrapper_jar_path, gradle_version)
-      cache_dir = get_gradle_wrapper_cache_dir
-      FileUtils.mkdir_p(cache_dir)
-      
-      cached_jar = File.join(cache_dir, "gradle-wrapper-#{gradle_version}.jar")
-      FileUtils.cp(wrapper_jar_path, cached_jar)
-      puts "\e[32m✓ gradle-wrapper.jar 已保存到缓存: #{cached_jar}\e[0m"
-    end
-
-    # 改进的下载标准 gradle-wrapper.jar（使用正确的下载策略）
-    def download_standard_wrapper_jar(wrapper_jar_path, gradle_version)
-      puts "下载标准的gradle-wrapper.jar..."
-      
-      # 使用正确的下载策略：从Gradle分发包中提取wrapper jar
-      gradle_dist_urls = [
-        "https://services.gradle.org/distributions/gradle-#{gradle_version}-bin.zip"
-      ]
-      
-      gradle_dist_urls.each do |url|
-        puts "尝试从Gradle分发包下载: #{url}"
-        if download_and_extract_wrapper_from_distribution(url, wrapper_jar_path, gradle_version)
-          puts "\e[32m✓ 从Gradle分发包成功提取gradle-wrapper.jar\e[0m"
-          # 保存到缓存
-          save_to_cache(wrapper_jar_path, gradle_version)
-          return true
-        end
+      if system(cmd)
+        puts "✓ curl下载成功: #{File.size(output_path)} 字节"
+        return true
+      else
+        puts "✗ curl下载失败"
+        return false
       end
-      
-      
-      puts "\e[31m✗ 下载 gradle-wrapper.jar 失败\e[0m"
+    rescue => e
+      puts "✗ curl下载异常: #{e.message}"
       false
     end
 
-    # 从Gradle分发包中下载并提取wrapper jar
-    def download_and_extract_wrapper_from_distribution(dist_url, wrapper_jar_path, gradle_version)
+    # 解压Gradle分发包
+    def extract_gradle_distribution(zip_file, extract_dir, gradle_version)
+      puts "解压Gradle分发包..."
+      
       begin
-        # 创建临时目录
-        temp_dir = Dir.mktmpdir("gradle_dist_")
-        zip_path = File.join(temp_dir, "gradle-#{gradle_version}-bin.zip")
-        
-        # 下载Gradle分发包
-        puts "下载Gradle分发包: #{dist_url}"
-        unless download_with_curl(dist_url, zip_path)
-          puts "\e[33m⚠ 下载Gradle分发包失败\e[0m"
-          return false
-        end
-        
-        # 检查下载的文件大小
-        unless File.exist?(zip_path) && File.size(zip_path) > 1000000  # 至少1MB
-          puts "\e[33m⚠ 下载的Gradle分发包文件异常\e[0m"
-          return false
-        end
-        
-        # 解压Gradle分发包
-        puts "解压Gradle分发包..."
-        unless system("cd #{temp_dir} && unzip -q gradle-#{gradle_version}-bin.zip")
-          puts "\e[33m⚠ 解压Gradle分发包失败\e[0m"
-          return false
-        end
-        
-        # 查找gradle-wrapper jar文件
-        gradle_dir = File.join(temp_dir, "gradle-#{gradle_version}")
-        wrapper_jar_source = File.join(gradle_dir, "lib", "gradle-wrapper-#{gradle_version}.jar")
-        
-        unless File.exist?(wrapper_jar_source)
-          puts "\e[33m⚠ 在Gradle分发包中未找到gradle-wrapper jar文件\e[0m"
-          return false
-        end
-        
-        # 解压gradle-wrapper jar文件，提取真正的gradle-wrapper.jar
-        extract_temp_dir = Dir.mktmpdir("gradle_wrapper_extract_")
-        extract_cmd = "cd #{extract_temp_dir} && unzip -q '#{wrapper_jar_source}'"
-        
-        unless system(extract_cmd)
-          puts "\e[33m⚠ 解压gradle-wrapper jar文件失败\e[0m"
-          FileUtils.rm_rf(extract_temp_dir)
-          return false
-        end
-        
-        # 查找解压后的gradle-wrapper.jar文件
-        extracted_wrapper_jar = File.join(extract_temp_dir, "gradle-wrapper.jar")
-        
-        unless File.exist?(extracted_wrapper_jar)
-          puts "\e[33m⚠ 在解压后的文件中未找到gradle-wrapper.jar\e[0m"
-          FileUtils.rm_rf(extract_temp_dir)
-          return false
-        end
-        
-        # 验证解压后的wrapper jar文件
-        unless verify_gradle_wrapper_jar_complete(extracted_wrapper_jar, gradle_version)
-          puts "\e[33m⚠ 解压后的wrapper jar文件验证失败\e[0m"
-          FileUtils.rm_rf(extract_temp_dir)
+        # 使用unzip命令解压
+        extract_cmd = "cd '#{File.dirname(extract_dir)}' && unzip -q '#{zip_file}'"
+        if system(extract_cmd)
+          # 设置执行权限
+          gradle_script = File.join(extract_dir, "bin/gradle")
+          if File.exist?(gradle_script)
+            system("chmod", "+x", gradle_script)
+            puts "✓ Gradle分发包解压成功"
+            return true
+          else
+            puts "✗ 解压后未找到gradle可执行文件"
+            return false
+          end
+        else
+          puts "✗ Gradle分发包解压失败"
           return false
         end
-        
-        # 复制解压后的wrapper jar文件到目标位置
-        FileUtils.cp(extracted_wrapper_jar, wrapper_jar_path)
-        puts "\e[32m✓ 成功从Gradle分发包提取gradle-wrapper.jar\e[0m"
-        
-        # 清理临时目录
-        FileUtils.rm_rf(extract_temp_dir)
-        
-        return true
-        
       rescue => e
-        puts "\e[31m✗ 从Gradle分发包提取wrapper jar异常: #{e.message}\e[0m"
+        puts "✗ Gradle分发包解压异常: #{e.message}"
         false
-      ensure
-        # 清理临时目录
-        if temp_dir && File.directory?(temp_dir)
-          FileUtils.rm_rf(temp_dir)
-        end
       end
     end
 
-
-    # 简化的curl下载方法（直接使用简化版本）
-    def download_with_curl(url, file_path)
-      puts "使用curl下载: #{url}"
-      
-      # 检查curl是否可用
-      unless system("which curl > /dev/null 2>&1")
-        puts "\e[31m✗ curl命令不可用，请安装curl\e[0m"
+    # 设置Gradle环境变量
+    def setup_gradle_environment(gradle_home)
+      puts "设置Gradle环境变量..."
+      
+      # 直接检查gradle可执行文件
+      gradle_bin_dir = File.join(gradle_home, "bin")
+      gradle_executable = File.join(gradle_bin_dir, "gradle")
+      
+      puts "检查gradle可执行文件: #{gradle_executable}"
+      
+      unless File.exist?(gradle_executable)
+        puts "✗ Gradle可执行文件不存在: #{gradle_executable}"
+        # 列出gradle_home目录内容用于调试
+        if File.directory?(gradle_home)
+          puts "gradle_home目录内容:"
+          Dir.entries(gradle_home).each do |entry|
+            next if entry.start_with?('.')
+            entry_path = File.join(gradle_home, entry)
+            if File.directory?(entry_path)
+              puts "  目录: #{entry}"
+            else
+              puts "  文件: #{entry}"
+            end
+          end
+        else
+          puts "gradle_home目录不存在: #{gradle_home}"
+        end
         return false
       end
       
-      # 使用简化的curl命令
-      simple_cmd = "curl -L -o '#{file_path}' '#{url}'"
-      puts "执行curl命令: #{simple_cmd}"
+      # 设置环境变量
+      ENV['GRADLE_HOME'] = gradle_home
+      ENV['PATH'] = "#{gradle_bin_dir}:#{ENV['PATH']}"
+      
+      puts "✓ Gradle环境变量设置完成"
+      puts "  GRADLE_HOME: #{ENV['GRADLE_HOME']}"
+      puts "  PATH已更新: #{gradle_bin_dir}"
       
-      if system(simple_cmd)
-        if File.exist?(file_path) && File.size(file_path) > 0
-          puts "\e[32m✓ curl下载成功: #{File.size(file_path)} 字节\e[0m"
+      true
+    end
+
+    # 使用官方Gradle命令生成wrapper
+    def generate_gradle_wrapper_official(project_path, gradle_version)
+      Dir.chdir(project_path) do
+        # 使用gradle wrapper命令
+        cmd = "gradle wrapper"
+        # puts "执行命令: #{cmd}"
+        
+        if system(cmd)
+          # puts "✓ 官方Gradle命令生成wrapper成功"
           return true
         else
-          puts "\e[31m✗ curl下载失败: 文件为空或不存在\e[0m"
+          puts "✗ 官方Gradle命令生成wrapper失败"
           return false
         end
-      else
-        puts "\e[31m✗ curl下载失败\e[0m"
-        return false
       end
     rescue => e
-      puts "\e[31m✗ curl下载异常: #{e.message}\e[0m"
-      false
-    end
-
-
-
-
-    # 改进的生成gradlew脚本逻辑（优先生成新脚本）
-    def generate_gradlew_script(project_path)
-      gradlew_path = File.join(project_path, "gradlew")
-      
-      # 如果已存在gradlew，检查是否需要更新
-      if File.exist?(gradlew_path)
-        puts "\e[32m✓ gradlew脚本已存在\e[0m"
-        return true
-      end
-
-      puts "正在生成gradlew脚本..."
-      
-      # 1. 优先生成新的gradlew脚本
-      gradlew_content = generate_gradlew_content()
-      
-      # 写入gradlew文件
-      File.write(gradlew_path, gradlew_content)
-      
-      # 设置执行权限
-      system("chmod", "+x", gradlew_path)
-      
-      # 验证生成的脚本
-      if File.exist?(gradlew_path) && File.executable?(gradlew_path)
-        puts "\e[32m✓ gradlew脚本生成完成\e[0m"
-        return true
-      end
-      
-      # 2. 如果生成失败，回退到内置脚本
-      puts "\e[33m⚠ 生成脚本失败，使用内置 gradlew 脚本\e[0m"
-      if use_builtin_gradlew_script(project_path)
-        return true
-      end
-      
-      puts "\e[31m✗ 无法生成有效的 gradlew 脚本\e[0m"
+      puts "✗ 官方Gradle命令执行异常: #{e.message}"
       false
     end
-
-    # 生成gradlew脚本内容（通用脚本，适用于所有Gradle项目）
-    def generate_gradlew_content()
-      <<~GRADLEW
-        #!/bin/sh
-
-        #
-        # Copyright © 2015-2021 the original authors.
-        #
-        # Licensed under the Apache License, Version 2.0 (the "License");
-        # you may not use this file except in compliance with the License.
-        # You may obtain a copy of the License at
-        #
-        #      https://www.apache.org/licenses/LICENSE-2.0
-        #
-        # Unless required by applicable law or agreed to in writing, software
-        # distributed under the License is distributed on an "AS IS" BASIS,
-        # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-        # See the License for the specific language governing permissions and
-        # limitations under the License.
-        #
-
-        ##############################################################################
-        #
-        #   Gradle start up script for UNIX
-        #
-        ##############################################################################
-
-        # Attempt to set APP_HOME
-
-        # Resolve links: $0 may be a link
-        app_path=$0
-
-        # Need this for daisy-chained symlinks.
-        while
-            APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
-            [ -h "$app_path" ]
-        do
-            ls=$( ls -ld "$app_path" )
-            link=${ls#*' -> '}
-            case $link in             #(
-              /*)   app_path=$link ;; #(
-              *)    app_path=$APP_HOME$link ;;
-            esac
-        done
-
-        # This is normally unused
-        # shellcheck disable=SC2034
-        APP_BASE_NAME=${0##*/}
-        APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
-
-        # Use the maximum available, or set MAX_FD != -1 to use that value.
-        MAX_FD=maximum
-
-        warn () {
-            echo "$*"
-        } >&2
-
-        die () {
-            echo
-            echo "$*"
-            echo
-            exit 1
-        } >&2
-
-        # OS specific support (must be 'true' or 'false').
-        cygwin=false
-        msys=false
-        darwin=false
-        nonstop=false
-        case "$( uname )" in                #(
-          CYGWIN* )         cygwin=true  ;; #(
-          Darwin* )         darwin=true  ;; #(
-          MSYS* | MINGW* )  msys=true    ;; #(
-          NONSTOP* )        nonstop=true ;;
-        esac
-
-        CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
-
-
-        # Determine the Java command to use to start the JVM.
-        if [ -n "$JAVA_HOME" ] ; then
-            if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
-                # IBM's JDK on AIX uses strange locations for the executables
-                JAVACMD=$JAVA_HOME/jre/sh/java
-            else
-                JAVACMD=$JAVA_HOME/bin/java
-            fi
-            if [ ! -x "$JAVACMD" ] ; then
-                die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
-
-        Please set the JAVA_HOME variable in your environment to match the
-        location of your Java installation."
-            fi
-        else
-            JAVACMD=java
-            which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-
-        Please set the JAVA_HOME variable in your environment to match the
-        location of your Java installation."
-        fi
-
-        # Increase the maximum file descriptors if we can.
-        if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
-            case $MAX_FD in #(
-              max*)
-                # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
-                # shellcheck disable=SC2039,SC3045
-                MAX_FD=$( ulimit -H -n ) ||
-                    warn "Could not query maximum file descriptor limit"
-            esac
-            case $MAX_FD in  #(
-              '' | soft) :;; #(
-              *)
-                # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
-                # shellcheck disable=SC2039,SC3045
-                ulimit -n "$MAX_FD" ||
-                    warn "Could not set maximum file descriptor limit to $MAX_FD"
-            esac
-        fi
-
-        # Collect all arguments for the java command, stacking in reverse order:
-        #   * args from the command line
-        #   * the main class name
-        #   * -classpath
-        #   * -D...appname settings
-        #   * --module-path (only if needed)
-        #   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
-
-        # For Cygwin or MSYS, switch paths to Windows format before running java
-        if "$cygwin" || "$msys" ; then
-            APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
-            CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
-
-            JAVACMD=$( cygpath --unix "$JAVACMD" )
-
-            # Now convert the arguments - kludge to limit ourselves to /bin/sh
-            for arg do
-                if
-                    case $arg in                                #(
-                      -*)   false ;;                            # don't mess with options #(
-                      /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
-                            [ -e "$t" ] ;;                      #(
-                      *)    false ;;
-                    esac
-                then
-                    arg=$( cygpath --path --ignore --mixed "$arg" )
-                fi
-                # Roll the args list around exactly as many times as the number of
-                # args, so each arg winds up back in the position where it started, but
-                # possibly modified.
-                #
-                # NB: a `for` loop captures its iteration list before it begins, so
-                # changing the positional parameters here affects neither the number of
-                # iterations, nor the values presented in `arg`.
-                shift                   # remove old arg
-                set -- "$@" "$arg"      # push replacement arg
-            done
-        fi
-
-
-        # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-        DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
-
-        # Collect all arguments for the java command:
-        #   * DEFAULT_JVM_OPTS, JAVA_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
-        #     and any embedded shellness will be escaped.
-        #   * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
-        #     treated as '${Hostname}' itself on the command line.
-
-        set -- \\
-                "-Dorg.gradle.appname=$APP_BASE_NAME" \\
-                -classpath "$CLASSPATH" \\
-                org.gradle.wrapper.GradleWrapperMain \\
-                "$@"
-
-        # Stop when "xargs" is not available.
-        if ! command -v xargs >/dev/null 2>&1
-        then
-            die "xargs is not available"
-        fi
-
-        # Use "xargs" to parse quoted args.
-        #
-        # With -n1 it outputs one arg per line, with the quotes and backslashes removed.
-        #
-        # In Bash we could simply go:
-        #
-        #   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
-        #   set -- "${ARGS[@]}" "$@"
-        #
-        # but POSIX shell has neither arrays nor command substitution, so instead we
-        # post-process each arg (as a line of input to sed) to backslash-escape any
-        # character that might be a shell metacharacter, then use eval to reverse
-        # that process (while maintaining the separation between arguments).
-        #
-        # This will of course break if any of these variables contains a newline or
-        # an unmatched quote.
-        #
-
-        eval "set -- $(
-                printf '%s\\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
-                xargs -n1 |
-                sed ' s~[^-[:alnum:]+,./:=@_]~\\\\&~g; ' |
-                tr '\\n' ' '
-            )" '"$@"'
-
-        exec "$JAVACMD" "$@"
-      GRADLEW
-    end
-
   end
 end