remove ant building support (#433)

Author: minggo

plugins/plugin_compile/build_android.py

@@ -27,11 +27,6 @@ class AndroidBuilder(object):
     CFG_KEY_ALIAS = "alias"
     CFG_KEY_ALIAS_PASS = "alias_pass"
 
-    ANT_KEY_STORE = "key.store"
-    ANT_KEY_ALIAS = "key.alias"
-    ANT_KEY_STORE_PASS = "key.store.password"
-    ANT_KEY_ALIAS_PASS = "key.alias.password"
-
     GRADLE_KEY_STORE = "RELEASE_STORE_FILE"
     GRADLE_KEY_ALIAS = "RELEASE_KEY_ALIAS"
     GRADLE_KEY_STORE_PASS = "RELEASE_STORE_PASSWORD"
@@ -45,25 +40,20 @@ class AndroidBuilder(object):
     GRADLE_PROP_LUA_ENCRYPT_KEY = 'PROP_LUA_ENCRYPT_KEY'
     GRADLE_PROP_LUA_ENCRYPT_SIGN = 'PROP_LUA_ENCRYPT_SIGN'
 
-    def __init__(self, verbose, app_android_root, no_res, proj_obj, ndk_mode, app_abi, use_studio=False, gradle_support_ndk=False):
+    def __init__(self, verbose, app_android_root, no_res, proj_obj, ndk_mode, app_abi, gradle_support_ndk=False):
         self._verbose = verbose
 
         self.app_android_root = app_android_root
         self._no_res = no_res
         self._project = proj_obj
-        self.use_studio = use_studio
         self.gradle_support_ndk = gradle_support_ndk
         self.app_abi = app_abi
         self.ndk_mode = ndk_mode
 
         # check environment variable
-        if self.use_studio:
-            self.ant_root = None
-            self.sign_prop_file = os.path.join(self.app_android_root, 'app', "gradle.properties")
-        else:
-            self.ant_root = cocos.check_environment_variable('ANT_ROOT')
-            self.sign_prop_file = os.path.join(self.app_android_root, "ant.properties")
         self.sdk_root = cocos.check_environment_variable('ANDROID_SDK_ROOT')
+        self.ant_root = None
+        self.sign_prop_file = os.path.join(self.app_android_root, 'app', "gradle.properties")
 
         self._parse_cfg()
 
@@ -72,16 +62,10 @@ def _run_cmd(self, command, cwd=None):
 
     def _parse_cfg(self):
         # get the properties for sign release apk
-        if self.use_studio:
-            self.key_store_str = AndroidBuilder.GRADLE_KEY_STORE
-            self.key_alias_str = AndroidBuilder.GRADLE_KEY_ALIAS
-            self.key_store_pass_str = AndroidBuilder.GRADLE_KEY_STORE_PASS
-            self.key_alias_pass_str = AndroidBuilder.GRADLE_KEY_ALIAS_PASS
-        else:
-            self.key_store_str = AndroidBuilder.ANT_KEY_STORE
-            self.key_alias_str = AndroidBuilder.ANT_KEY_ALIAS
-            self.key_store_pass_str = AndroidBuilder.ANT_KEY_STORE_PASS
-            self.key_alias_pass_str = AndroidBuilder.ANT_KEY_ALIAS_PASS
+        self.key_store_str = AndroidBuilder.GRADLE_KEY_STORE
+        self.key_alias_str = AndroidBuilder.GRADLE_KEY_ALIAS
+        self.key_store_pass_str = AndroidBuilder.GRADLE_KEY_STORE_PASS
+        self.key_alias_pass_str = AndroidBuilder.GRADLE_KEY_ALIAS_PASS
 
         if self.gradle_support_ndk:
             return
@@ -137,10 +121,7 @@ def _parse_cfg(self):
 
     def has_keystore_in_signprops(self):
         keystore = None
-        if self.use_studio:
-            pattern = re.compile(r"^RELEASE_STORE_FILE=(.+)")
-        else:
-            pattern = re.compile(r"^key\.store=(.+)")
+        pattern = re.compile(r"^RELEASE_STORE_FILE=(.+)")
 
         try:
             file_obj = open(self.sign_prop_file)
@@ -242,49 +223,23 @@ def update_project(self, android_platform):
             self._write_local_properties(self.app_android_root)
             return
 
-        # Android SDK removed android command & ant support from SDK tools 25.3.0
-        # So, we should check the Android SDK tools version
-        sdk_tools_folder = os.path.join(self.sdk_root, 'tools')
-        main_ver, minor_ver = self._get_android_sdk_tools_ver(sdk_tools_folder)
-        no_ant = False
-        if main_ver > 25 or (main_ver == 25 and minor_ver >= 3):
-            no_ant = True
-
-        if not self.use_studio and no_ant:
-            # Tip the message that ant is not supported from Android SDK tools 25.3.0
-            raise cocos.CCPluginError(MultiLanguage.get_string('COMPILE_ERROR_ANT_NOT_SUPPORTED'),
-                                      cocos.CCPluginError.ERROR_OTHERS)
-
-        if self.use_studio:
-            manifest_path = os.path.join(self.app_android_root, 'app')
-        else:
-            manifest_path = self.app_android_root
+        manifest_path = os.path.join(self.app_android_root, 'app')
 
         # check the android platform
         target_str = self.check_android_platform(self.sdk_root, android_platform, manifest_path)
 
-        if no_ant:
-            # should manually update the project
-            self._write_local_properties(manifest_path)
-            self._update_project_properties(manifest_path, target_str)
-        else:
-            # update project
-            sdk_tool_path = os.path.join(sdk_tools_folder, "android")
-            command = "%s update project -t %s -p %s" % (cocos.CMDRunner.convert_path_to_cmd(sdk_tool_path), target_str, manifest_path)
-            self._run_cmd(command)
-
-            # update lib-projects
-            self.update_lib_projects(self.sdk_root, sdk_tool_path, android_platform, manifest_path)
-
-        if self.use_studio:
-            # copy the local.properties to the app_android_root
-            file_name = 'local.properties'
-            src_path = os.path.normpath(os.path.join(manifest_path, file_name))
-            dst_path = os.path.normpath(os.path.join(self.app_android_root, file_name))
-            if src_path != dst_path:
-                if os.path.isfile(dst_path):
-                    os.remove(dst_path)
-                shutil.copy(src_path, dst_path)
+        # should manually update the project
+        self._write_local_properties(manifest_path)
+        self._update_project_properties(manifest_path, target_str)
+
+        # copy the local.properties to the app_android_root
+        file_name = 'local.properties'
+        src_path = os.path.normpath(os.path.join(manifest_path, file_name))
+        dst_path = os.path.normpath(os.path.join(self.app_android_root, file_name))
+        if src_path != dst_path:
+            if os.path.isfile(dst_path):
+                os.remove(dst_path)
+            shutil.copy(src_path, dst_path)
 
     def get_toolchain_version(self, ndk_root, compile_obj):
         # it should be possible to override the toolchain
@@ -299,10 +254,7 @@ def do_ndk_build(self, ndk_build_param, build_mode, compile_obj):
 
         toolchain_version = self.get_toolchain_version(ndk_root, compile_obj)
 
-        if self.use_studio:
-            ndk_work_dir = os.path.join(self.app_android_root, 'app')
-        else:
-            ndk_work_dir = self.app_android_root
+        ndk_work_dir = os.path.join(self.app_android_root, 'app')
         reload(sys)
         sys.setdefaultencoding('utf8')
         ndk_path = cocos.CMDRunner.convert_path_to_cmd(os.path.join(ndk_root, "ndk-build"))
@@ -402,30 +354,6 @@ def check_android_platform(self, sdk_root, android_platform, proj_path):
 
         return ret
 
-    def ant_build_apk(self, build_mode, custom_step_args):
-        app_android_root = self.app_android_root
-
-        # run ant build
-        ant_path = os.path.join(self.ant_root, 'ant')
-        buildfile_path = os.path.join(app_android_root, "build.xml")
-
-        # generate paramters for custom step
-        args_ant_copy = custom_step_args.copy()
-        target_platform = cocos_project.Platforms.ANDROID
-
-        # invoke custom step: pre-ant-build
-        self._project.invoke_custom_step_script(cocos_project.Project.CUSTOM_STEP_PRE_ANT_BUILD,
-                                                target_platform, args_ant_copy)
-
-        command = "%s clean %s -f %s -Dsdk.dir=%s" % (cocos.CMDRunner.convert_path_to_cmd(ant_path),
-                                                      build_mode, buildfile_path,
-                                                      cocos.CMDRunner.convert_path_to_cmd(self.sdk_root))
-        self._run_cmd(command)
-
-        # invoke custom step: post-ant-build
-        self._project.invoke_custom_step_script(cocos_project.Project.CUSTOM_STEP_POST_ANT_BUILD,
-                                                target_platform, args_ant_copy)
-
     def gradle_build_apk(self, build_mode, android_platform, compile_obj):
         # check the compileSdkVersion & buildToolsVersion
         check_file = os.path.join(self.app_android_root, 'app', 'build.gradle')
@@ -547,10 +475,7 @@ def _get_build_type(self, param_of_appabi):
             return self._do_get_build_type(param_of_appabi)
 
         # get build type from Application.mk
-        if self.use_studio:
-            applicationmk_path = os.path.join(self.app_android_root, "app/jni/Application.mk")
-        else:
-            applicationmk_path = os.path.join(self.app_android_root, "jni/Application.mk")
+        applicationmk_path = os.path.join(self.app_android_root, "app/jni/Application.mk")
         with open(applicationmk_path) as f:
             for line in f:
                 if line.find('APP_ABI') == -1:
@@ -562,32 +487,27 @@ def _get_build_type(self, param_of_appabi):
         return self.LuaBuildType.UNKNOWN
 
     def do_build_apk(self, build_mode, no_apk, output_dir, custom_step_args, android_platform, compile_obj):
-        if self.use_studio:
-            assets_dir = os.path.join(self.app_android_root, "app", "assets")
-            project_name = None
-            setting_file = os.path.join(self.app_android_root, 'settings.gradle')
-            if os.path.isfile(setting_file):
-                # get project name from settings.gradle
-                f = open(setting_file)
-                lines = f.readlines()
-                f.close()
-
-                pattern = r"project\(':(.*)'\)\.projectDir[ \t]*=[ \t]*new[ \t]*File\(settingsDir, 'app'\)"
-                for line in lines:
-                    line_str = line.strip()
-                    match = re.match(pattern, line_str)
-                    if match:
-                        project_name = match.group(1)
-                        break
-
-            if project_name is None:
-                # use default project name
-                project_name = 'app'
-            gen_apk_folder = os.path.join(self.app_android_root, 'app/build/outputs/apk', build_mode)
-        else:
-            assets_dir = os.path.join(self.app_android_root, "assets")
-            project_name = self._xml_attr(self.app_android_root, 'build.xml', 'project', 'name')
-            gen_apk_folder = os.path.join(self.app_android_root, 'bin')
+        assets_dir = os.path.join(self.app_android_root, "app", "assets")
+        project_name = None
+        setting_file = os.path.join(self.app_android_root, 'settings.gradle')
+        if os.path.isfile(setting_file):
+            # get project name from settings.gradle
+            f = open(setting_file)
+            lines = f.readlines()
+            f.close()
+
+            pattern = r"project\(':(.*)'\)\.projectDir[ \t]*=[ \t]*new[ \t]*File\(settingsDir, 'app'\)"
+            for line in lines:
+                line_str = line.strip()
+                match = re.match(pattern, line_str)
+                if match:
+                    project_name = match.group(1)
+                    break
+
+        if project_name is None:
+            # use default project name
+            project_name = 'app'
+        gen_apk_folder = os.path.join(self.app_android_root, 'app/build/outputs/apk', build_mode)
 
         # gradle supports copy assets & compile scripts from engine 3.15
         if not self.gradle_support_ndk:
@@ -634,10 +554,7 @@ def do_build_apk(self, build_mode, no_apk, output_dir, custom_step_args, android
                 self._gather_sign_info()
 
             # build apk
-            if self.use_studio:
-                self.gradle_build_apk(build_mode, android_platform, compile_obj)
-            else:
-                self.ant_build_apk(build_mode, custom_step_args)
+            self.gradle_build_apk(build_mode, android_platform, compile_obj)
 
             # copy the apk to output dir
             if output_dir:
@@ -731,26 +648,22 @@ def _copy_resources(self, custom_step_args, assets_dir):
         self._project.invoke_custom_step_script(cocos_project.Project.CUSTOM_STEP_POST_COPY_ASSETS, target_platform, cur_custom_step_args)
 
     def get_apk_info(self):
-        if self.use_studio:
-            manifest_path = os.path.join(self.app_android_root, 'app')
-            gradle_cfg_path = os.path.join(manifest_path, 'build.gradle')
-            package = None
-            if os.path.isfile(gradle_cfg_path):
-                # get package name from build.gradle
-                f = open(gradle_cfg_path)
-                for line in f.readlines():
-                    line_str = line.strip()
-                    pattern = r'applicationId[ \t]+"(.*)"'
-                    match = re.match(pattern, line_str)
-                    if match:
-                        package = match.group(1)
-                        break
-
-            if package is None:
-                # get package name from AndroidManifest.xml
-                package = self._xml_attr(manifest_path, 'AndroidManifest.xml', 'manifest', 'package')
-        else:
-            manifest_path = self.app_android_root
+        manifest_path = os.path.join(self.app_android_root, 'app')
+        gradle_cfg_path = os.path.join(manifest_path, 'build.gradle')
+        package = None
+        if os.path.isfile(gradle_cfg_path):
+            # get package name from build.gradle
+            f = open(gradle_cfg_path)
+            for line in f.readlines():
+                line_str = line.strip()
+                pattern = r'applicationId[ \t]+"(.*)"'
+                match = re.match(pattern, line_str)
+                if match:
+                    package = match.group(1)
+                    break
+
+        if package is None:
+            # get package name from AndroidManifest.xml
             package = self._xml_attr(manifest_path, 'AndroidManifest.xml', 'manifest', 'package')
 
         activity_name = self._xml_attr(manifest_path, 'AndroidManifest.xml', 'activity', 'android:name')

plugins/plugin_compile/project_compile.py

@@ -470,51 +470,30 @@ def build_android(self):
         output_dir = self._output_dir
 
         # get the android project path
-        # if both proj.android & proj.android-studio existed, select the project path by --studio argument
-        # else, use the existed one.
         cfg_obj = self._platforms.get_current_config()
-        proj_android_path = cfg_obj.proj_path
-        proj_studio_path = cfg_obj.studio_path
-        project_android_dir = None
-        using_studio = False
-        if self.is_valid_path(proj_android_path) and self.is_valid_path(proj_studio_path):
-            if self.use_studio:
-                project_android_dir = proj_studio_path
-                using_studio = True
-            else:
-                project_android_dir = proj_android_path
-                using_studio = False
-        elif self.is_valid_path(proj_android_path):
-            project_android_dir = proj_android_path
-            using_studio = False
-        elif self.is_valid_path(proj_studio_path):
-            project_android_dir = proj_studio_path
-            using_studio = True
-
-        if using_studio:
-            ide_name = 'Android Studio'
-        else:
-            ide_name = 'Eclipse'
+        project_android_dir = cfg_obj.proj_path
+
+
+        ide_name = 'Android Studio'
         cocos.Logging.info(MultiLanguage.get_string('COMPILE_INFO_ANDROID_PROJPATH_FMT', (ide_name, project_android_dir)))
 
         # Check whether the gradle of the project is support ndk or not
-        gradle_support_ndk = False
-        if using_studio:
-            # Get the engine version of the project
-            engine_version_num = self.get_engine_version_num()
-            if engine_version_num is None:
-                raise cocos.CCPluginError(MultiLanguage.get_string('COMPILE_ERROR_UNKNOWN_ENGINE_VERSION'))
-
-            # Gradle supports NDK build from engine 3.15
-            main_ver = engine_version_num[0]
-            minor_ver = engine_version_num[1]
-            if main_ver > 3 or (main_ver == 3 and minor_ver >= 15):
-                gradle_support_ndk = True
+        # Get the engine version of the project
+        engine_version_num = self.get_engine_version_num()
+        if engine_version_num is None:
+            raise cocos.CCPluginError(MultiLanguage.get_string('COMPILE_ERROR_UNKNOWN_ENGINE_VERSION'))
+
+        # Gradle supports NDK build from engine 3.15
+        main_ver = engine_version_num[0]
+        minor_ver = engine_version_num[1]
+        if main_ver > 3 or (main_ver == 3 and minor_ver >= 15):
+            gradle_support_ndk = True
+            
 
         from build_android import AndroidBuilder
         builder = AndroidBuilder(self._verbose, project_android_dir,
                                  self._no_res, self._project, self._ndk_mode,
-                                 self.app_abi, using_studio, gradle_support_ndk)
+                                 self.app_abi, gradle_support_ndk)
 
         args_ndk_copy = self._custom_step_args.copy()
         target_platform = self._platforms.get_current_platform()
@@ -541,10 +520,8 @@ def build_android(self):
                 self._project.invoke_custom_step_script(cocos_project.Project.CUSTOM_STEP_PRE_NDK_BUILD, target_platform, args_ndk_copy)
 
                 modify_mk = False
-                if using_studio:
-                    app_mk = os.path.join(project_android_dir, "app/jni/Application.mk")
-                else:
-                    app_mk = os.path.join(project_android_dir, "jni/Application.mk")
+                app_mk = os.path.join(project_android_dir, "app/jni/Application.mk")
+
                 mk_content = None
                 if self.cppflags and os.path.exists(app_mk):
                     # record the content of Application.mk