mirror of https://github.com/axmolengine/axmol.git
1024 lines
41 KiB
Python
1024 lines
41 KiB
Python
#!/usr/bin/python
|
|
# ----------------------------------------------------------------------------
|
|
# adxe "compile" plugin
|
|
#
|
|
# Copyright 2013 (C) Luis Parravicini
|
|
#
|
|
# License: MIT
|
|
# ----------------------------------------------------------------------------
|
|
'''
|
|
"compile" plugin for adxe command line tool
|
|
'''
|
|
|
|
__docformat__ = 'restructuredtext'
|
|
|
|
import multiprocessing
|
|
import adxe
|
|
from MultiLanguage import MultiLanguage
|
|
import adxe_project
|
|
import os
|
|
import re
|
|
import sys
|
|
import shutil
|
|
import json
|
|
from . import build_web
|
|
import utils
|
|
|
|
class CCPluginCompile(adxe.CCPlugin):
|
|
"""
|
|
compiles a project
|
|
"""
|
|
|
|
BUILD_CONFIG_FILE = "build-cfg.json"
|
|
CFG_KEY_WIN32_COPY_FILES = "copy_files"
|
|
CFG_KEY_WIN32_MUST_COPY_FILES = "must_copy_files"
|
|
|
|
CFG_KEY_COPY_RESOURCES = "copy_resources"
|
|
CFG_KEY_MUST_COPY_RESOURCES = "must_copy_resources"
|
|
|
|
OUTPUT_DIR_NATIVE = "bin"
|
|
OUTPUT_DIR_SCRIPT_DEBUG = "simulator"
|
|
OUTPUT_DIR_SCRIPT_RELEASE = "publish"
|
|
WEB_PLATFORM_FOLDER_NAME = "html5"
|
|
|
|
PROJ_CFG_KEY_IOS_SIGN_ID = "ios_sign_id"
|
|
PROJ_CFG_KEY_ENGINE_DIR = "engine_dir"
|
|
|
|
BACKUP_SUFFIX = "-backup"
|
|
ENGINE_JS_DIRS = [
|
|
"frameworks/js-bindings/bindings/script",
|
|
"cocos/scripting/js-bindings/script"
|
|
]
|
|
|
|
CMAKE_VS_GENERATOR_MAP = {
|
|
"12" : "Visual Studio 12 2013",
|
|
"14" : "Visual Studio 14 2015",
|
|
"15" : "Visual Studio 15 2017",
|
|
"16" : "Visual Studio 16 2019",
|
|
}
|
|
|
|
@staticmethod
|
|
def plugin_name():
|
|
return "compile"
|
|
|
|
@staticmethod
|
|
def brief_description():
|
|
return MultiLanguage.get_string('COMPILE_BRIEF')
|
|
|
|
def _add_custom_options(self, parser):
|
|
from argparse import ArgumentParser
|
|
parser.add_argument("-m", "--mode", dest="mode", default='debug',
|
|
help=MultiLanguage.get_string('COMPILE_ARG_MODE'))
|
|
parser.add_argument("-j", "--jobs", dest="jobs", type=int,
|
|
help=MultiLanguage.get_string('COMPILE_ARG_JOBS'))
|
|
parser.add_argument("-o", "--output-dir", dest="output_dir",
|
|
help=MultiLanguage.get_string('COMPILE_ARG_OUTPUT'))
|
|
|
|
group = parser.add_argument_group(MultiLanguage.get_string('COMPILE_ARG_GROUP_ANDROID'))
|
|
group.add_argument("--ap", dest="android_platform",
|
|
help=MultiLanguage.get_string('COMPILE_ARG_AP'))
|
|
group.add_argument("--build-type", dest="build_type",
|
|
help=MultiLanguage.get_string('COMPILE_ARG_BUILD_TYPE'))
|
|
group.add_argument("--app-abi", dest="app_abi",
|
|
help=MultiLanguage.get_string('COMPILE_ARG_APP_ABI'))
|
|
group.add_argument("--ndk-toolchain", dest="toolchain",
|
|
help=MultiLanguage.get_string('COMPILE_ARG_TOOLCHAIN'))
|
|
group.add_argument("--ndk-cppflags", dest="cppflags",
|
|
help=MultiLanguage.get_string('COMPILE_ARG_CPPFLAGS'))
|
|
group.add_argument("--no-apk", dest="no_apk", action="store_true",
|
|
help=MultiLanguage.get_string('COMPILE_ARG_NO_APK'))
|
|
group.add_argument("--no-sign", dest="no_sign", action="store_true",
|
|
help=MultiLanguage.get_string('COMPILE_ARG_NO_SIGN'))
|
|
|
|
group = parser.add_argument_group(MultiLanguage.get_string('COMPILE_ARG_GROUP_WIN'))
|
|
group.add_argument("--vs", dest="vs_version", type=int,
|
|
help=MultiLanguage.get_string('COMPILE_ARG_VS'))
|
|
|
|
group = parser.add_argument_group(MultiLanguage.get_string('COMPILE_ARG_GROUP_WEB'))
|
|
group.add_argument("--source-map", dest="source_map", action="store_true",
|
|
help=MultiLanguage.get_string('COMPILE_ARG_SOURCE_MAP'))
|
|
group.add_argument("--advanced", dest="advanced", action="store_true",
|
|
help=MultiLanguage.get_string('COMPILE_ARG_ADVANCE'))
|
|
|
|
group = parser.add_argument_group(MultiLanguage.get_string('COMPILE_ARG_GROUP_IOS_MAC'))
|
|
group.add_argument("-t", "--target", dest="target_name",
|
|
help=MultiLanguage.get_string('COMPILE_ARG_TARGET'))
|
|
|
|
group = parser.add_argument_group(MultiLanguage.get_string('COMPILE_ARG_GROUP_IOS'))
|
|
group.add_argument("--sign-identity", dest="sign_id",
|
|
help=MultiLanguage.get_string('COMPILE_ARG_IOS_SIGN'))
|
|
group.add_argument("-sdk", dest="use_sdk", metavar="USE_SDK", nargs='?', default='iphonesimulator',
|
|
help=MultiLanguage.get_string('COMPILE_ARG_IOS_SDK'))
|
|
|
|
group = parser.add_argument_group(MultiLanguage.get_string('COMPILE_ARG_GROUP_LUA_JS'))
|
|
group.add_argument("--no-res", dest="no_res", action="store_true",
|
|
help=MultiLanguage.get_string('COMPILE_ARG_NO_RES'))
|
|
group.add_argument("--compile-script", dest="compile_script", type=int, choices=[0, 1],
|
|
help=MultiLanguage.get_string('COMPILE_ARG_COMPILE_SCRIPT'))
|
|
|
|
group = parser.add_argument_group(MultiLanguage.get_string('COMPILE_ARG_GROUP_LUA'))
|
|
group.add_argument("--lua-encrypt", dest="lua_encrypt", action="store_true",
|
|
help=MultiLanguage.get_string('COMPILE_ARG_LUA_ENCRYPT'))
|
|
group.add_argument("--lua-encrypt-key", dest="lua_encrypt_key",
|
|
help=MultiLanguage.get_string('COMPILE_ARG_LUA_ENCRYPT_KEY'))
|
|
group.add_argument("--lua-encrypt-sign", dest="lua_encrypt_sign",
|
|
help=MultiLanguage.get_string('COMPILE_ARG_LUA_ENCRYPT_SIGN'))
|
|
|
|
category = self.plugin_category()
|
|
name = self.plugin_name()
|
|
usage = "\n\t%%prog %s %s -p <platform> [-s src_dir][-m <debug|release>]" \
|
|
"\nSample:" \
|
|
"\n\t%%prog %s %s -p android" % (category, name, category, name)
|
|
|
|
def _check_custom_options(self, args):
|
|
# get the mode parameter
|
|
available_modes = [ 'release', 'debug' ]
|
|
self._mode = self.check_param(args.mode, 'debug', available_modes,
|
|
MultiLanguage.get_string('COMPILE_ERROR_WRONG_MODE_FMT',
|
|
available_modes))
|
|
|
|
# android arguments
|
|
available_build_types = [ 'cmake', 'none']
|
|
self._build_type = self.check_param(args.build_type, 'cmake', available_build_types,
|
|
MultiLanguage.get_string('COMPILE_ERROR_WRONG_BUILD_TYPE_FMT',
|
|
available_build_types))
|
|
self._no_apk = args.no_apk
|
|
self._no_sign = args.no_sign
|
|
|
|
self.app_abi = None
|
|
if args.app_abi:
|
|
self.app_abi = " ".join(args.app_abi.split(":"))
|
|
|
|
self.cppflags = None
|
|
if args.cppflags:
|
|
self.cppflags = args.cppflags
|
|
|
|
self.ndk_toolchain = None
|
|
if args.toolchain:
|
|
self.ndk_toolchain = args.toolchain
|
|
|
|
# Win32 arguments
|
|
self.vs_version = args.vs_version
|
|
|
|
# iOS/Mac arguments
|
|
self.xcode_target_name = None
|
|
if args.target_name is not None:
|
|
self.xcode_target_name = args.target_name
|
|
|
|
if args.compile_script is not None:
|
|
self._compile_script = bool(args.compile_script)
|
|
else:
|
|
self._compile_script = (self._mode == "release")
|
|
|
|
self._ap = args.android_platform
|
|
|
|
if args.jobs is not None:
|
|
self._jobs = args.jobs
|
|
else:
|
|
self._jobs = self.get_num_of_cpu()
|
|
self._has_sourcemap = args.source_map
|
|
self._web_advanced = args.advanced
|
|
self._no_res = args.no_res
|
|
|
|
if args.output_dir is None:
|
|
self._output_dir = self._get_output_dir()
|
|
else:
|
|
if os.path.isabs(args.output_dir):
|
|
self._output_dir = args.output_dir
|
|
else:
|
|
self._output_dir = os.path.abspath(args.output_dir)
|
|
|
|
self._sign_id = args.sign_id
|
|
self._use_sdk = args.use_sdk
|
|
|
|
if self._project._is_lua_project():
|
|
self._lua_encrypt = args.lua_encrypt
|
|
self._lua_encrypt_key = args.lua_encrypt_key
|
|
self._lua_encrypt_sign = args.lua_encrypt_sign
|
|
|
|
self.end_warning = ""
|
|
self._gen_custom_step_args()
|
|
|
|
def check_param(self, value, default_value, available_values, error_msg, ignore_case=True):
|
|
if value is None:
|
|
return default_value
|
|
|
|
if ignore_case:
|
|
check_value = value.lower()
|
|
right_values = []
|
|
for v in available_values:
|
|
right_values.append(v.lower())
|
|
else:
|
|
check_value = value
|
|
right_values = available_values
|
|
|
|
if check_value in right_values:
|
|
return check_value
|
|
else:
|
|
raise adxe.CCPluginError(error_msg, adxe.CCPluginError.ERROR_WRONG_ARGS)
|
|
|
|
def get_num_of_cpu(self):
|
|
try:
|
|
return multiprocessing.cpu_count()
|
|
except Exception:
|
|
print(MultiLanguage.get_string('COMPILE_DETECT_CPU_FAILED'))
|
|
return 1
|
|
|
|
def _get_output_dir(self):
|
|
project_dir = self._project.get_project_dir()
|
|
cur_platform = self._platforms.get_current_platform()
|
|
if self._project._is_script_project():
|
|
if self._project._is_js_project() and self._platforms.is_web_active():
|
|
cur_platform = CCPluginCompile.WEB_PLATFORM_FOLDER_NAME
|
|
|
|
if self._mode == 'debug':
|
|
output_dir = os.path.join(project_dir, CCPluginCompile.OUTPUT_DIR_SCRIPT_DEBUG, cur_platform)
|
|
else:
|
|
output_dir = os.path.join(project_dir, CCPluginCompile.OUTPUT_DIR_SCRIPT_RELEASE, cur_platform)
|
|
else:
|
|
output_dir = os.path.join(project_dir, CCPluginCompile.OUTPUT_DIR_NATIVE, self._mode, cur_platform)
|
|
|
|
return output_dir
|
|
|
|
def _gen_custom_step_args(self):
|
|
self._custom_step_args = {
|
|
"project-path": self._project.get_project_dir(),
|
|
"platform-project-path": self._platforms.project_path(),
|
|
"build-mode": self._mode,
|
|
"output-dir": self._output_dir
|
|
}
|
|
|
|
if self._platforms.is_android_active():
|
|
self._custom_step_args["ndk-build-type"] = self._build_type
|
|
|
|
def _build_cfg_path(self):
|
|
cur_cfg = self._platforms.get_current_config()
|
|
if self._platforms.is_win32_active():
|
|
ret = self._platforms.project_path()
|
|
elif self._platforms.is_ios_active():
|
|
ret = os.path.join(self._platforms.project_path(), "ios")
|
|
elif self._platforms.is_mac_active():
|
|
ret = os.path.join(self._platforms.project_path(), "mac")
|
|
else:
|
|
ret = self._platforms.project_path()
|
|
|
|
return ret
|
|
|
|
def _update_build_cfg(self):
|
|
build_cfg_dir = self._build_cfg_path()
|
|
cfg_file_path = os.path.join(build_cfg_dir, CCPluginCompile.BUILD_CONFIG_FILE)
|
|
if not os.path.isfile(cfg_file_path):
|
|
return
|
|
|
|
key_of_copy = None
|
|
key_of_must_copy = None
|
|
if self._platforms.is_android_active():
|
|
from build_android import AndroidBuilder
|
|
key_of_copy = AndroidBuilder.CFG_KEY_COPY_TO_ASSETS
|
|
key_of_must_copy = AndroidBuilder.CFG_KEY_MUST_COPY_TO_ASSERTS
|
|
elif self._platforms.is_win32_active():
|
|
key_of_copy = CCPluginCompile.CFG_KEY_WIN32_COPY_FILES
|
|
key_of_must_copy = CCPluginCompile.CFG_KEY_WIN32_MUST_COPY_FILES
|
|
|
|
if key_of_copy is None and key_of_must_copy is None:
|
|
return
|
|
|
|
try:
|
|
outfile = None
|
|
open_file = open(cfg_file_path)
|
|
cfg_info = json.load(open_file)
|
|
open_file.close()
|
|
open_file = None
|
|
changed = False
|
|
if key_of_copy is not None:
|
|
if adxe.dict_contains(cfg_info, key_of_copy):
|
|
src_list = cfg_info[key_of_copy]
|
|
ret_list = self._convert_cfg_list(src_list, build_cfg_dir)
|
|
cfg_info[CCPluginCompile.CFG_KEY_COPY_RESOURCES] = ret_list
|
|
del cfg_info[key_of_copy]
|
|
changed = True
|
|
|
|
if key_of_must_copy is not None:
|
|
if adxe.dict_contains(cfg_info, key_of_must_copy):
|
|
src_list = cfg_info[key_of_must_copy]
|
|
ret_list = self._convert_cfg_list(src_list, build_cfg_dir)
|
|
cfg_info[CCPluginCompile.CFG_KEY_MUST_COPY_RESOURCES] = ret_list
|
|
del cfg_info[key_of_must_copy]
|
|
changed = True
|
|
|
|
if changed:
|
|
# backup the old-cfg
|
|
split_list = os.path.splitext(CCPluginCompile.BUILD_CONFIG_FILE)
|
|
file_name = split_list[0]
|
|
ext_name = split_list[1]
|
|
bak_name = file_name + "-for-v0.1" + ext_name
|
|
bak_file_path = os.path.join(build_cfg_dir, bak_name)
|
|
if os.path.exists(bak_file_path):
|
|
os.remove(bak_file_path)
|
|
os.rename(cfg_file_path, bak_file_path)
|
|
|
|
# write the new data to file
|
|
with open(cfg_file_path, 'w') as outfile:
|
|
json.dump(cfg_info, outfile, sort_keys = True, indent = 4)
|
|
outfile.close()
|
|
outfile = None
|
|
finally:
|
|
if open_file is not None:
|
|
open_file.close()
|
|
|
|
if outfile is not None:
|
|
outfile.close()
|
|
|
|
def _convert_cfg_list(self, src_list, build_cfg_dir):
|
|
ret = []
|
|
for element in src_list:
|
|
ret_element = {}
|
|
if str(element).endswith("/"):
|
|
sub_str = element[0:len(element)-1]
|
|
ret_element["from"] = sub_str
|
|
ret_element["to"] = ""
|
|
else:
|
|
element_full_path = os.path.join(build_cfg_dir, element)
|
|
if os.path.isfile(element_full_path):
|
|
to_dir = ""
|
|
else:
|
|
to_dir = os.path.basename(element)
|
|
ret_element["from"] = element
|
|
ret_element["to"] = to_dir
|
|
|
|
ret.append(ret_element)
|
|
|
|
return ret
|
|
|
|
def _is_debug_mode(self):
|
|
return self._mode == 'debug'
|
|
|
|
def _remove_file_with_ext(self, work_dir, ext):
|
|
if not os.path.exists(work_dir):
|
|
return
|
|
file_list = os.listdir(work_dir)
|
|
for f in file_list:
|
|
full_path = os.path.join(work_dir, f)
|
|
if os.path.isdir(full_path):
|
|
self._remove_file_with_ext(full_path, ext)
|
|
elif os.path.isfile(full_path):
|
|
name, cur_ext = os.path.splitext(f)
|
|
if cur_ext == ext:
|
|
os.remove(full_path)
|
|
|
|
def compile_lua_scripts(self, src_dir, dst_dir, build_64):
|
|
if not self._project._is_lua_project():
|
|
return False
|
|
|
|
if not self._compile_script and not self._lua_encrypt:
|
|
return False
|
|
|
|
cocos_cmd_path = os.path.join(os.path.dirname(os.path.abspath(sys.argv[0])), "cocos")
|
|
rm_ext = ".lua"
|
|
compile_cmd = "\"%s\" luacompile -s \"%s\" -d \"%s\"" % (cocos_cmd_path, src_dir, dst_dir)
|
|
|
|
if not self._compile_script:
|
|
compile_cmd = "%s --disable-compile" % compile_cmd
|
|
elif build_64:
|
|
compile_cmd = "%s --bytecode-64bit" % compile_cmd
|
|
|
|
if self._lua_encrypt:
|
|
add_para = ""
|
|
if self._lua_encrypt_key is not None:
|
|
add_para = "%s -k %s" % (add_para, self._lua_encrypt_key)
|
|
|
|
if self._lua_encrypt_sign is not None:
|
|
add_para = "%s -b %s" % (add_para, self._lua_encrypt_sign)
|
|
|
|
compile_cmd = "%s -e %s" % (compile_cmd, add_para)
|
|
|
|
# run compile command
|
|
self._run_cmd(compile_cmd)
|
|
|
|
# remove the source scripts
|
|
self._remove_file_with_ext(dst_dir, rm_ext)
|
|
|
|
return True
|
|
|
|
def compile_js_scripts(self, src_dir, dst_dir):
|
|
if not self._project._is_js_project():
|
|
return False
|
|
|
|
if not self._compile_script:
|
|
return False
|
|
|
|
cocos_cmd_path = os.path.join(os.path.dirname(os.path.abspath(sys.argv[0])), "cocos")
|
|
rm_ext = ".js"
|
|
compile_cmd = "\"%s\" jscompile -s \"%s\" -d \"%s\"" % (cocos_cmd_path, src_dir, dst_dir)
|
|
|
|
# run compile command
|
|
self._run_cmd(compile_cmd)
|
|
|
|
# remove the source scripts
|
|
# self._remove_file_with_ext(dst_dir, rm_ext)
|
|
return True
|
|
|
|
def add_warning_at_end(self, warning_str):
|
|
if warning_str is None or len(warning_str) == 0:
|
|
return
|
|
self.end_warning = "%s\n%s" % (self.end_warning, warning_str)
|
|
|
|
def is_valid_path(self, p):
|
|
if (p is not None) and os.path.exists(p):
|
|
ret = True
|
|
else:
|
|
ret = False
|
|
|
|
return ret
|
|
|
|
def get_engine_version_num(self):
|
|
# 1. get engine version from .adxeproj.json
|
|
engine_ver_str = self._project.get_proj_config(adxe_project.Project.KEY_ENGINE_VERSION)
|
|
|
|
# 2. engine version is not found. find from source file
|
|
if engine_ver_str is None:
|
|
engine_dir = self.get_engine_dir()
|
|
if engine_dir is not None:
|
|
engine_ver_str = utils.get_engine_version(engine_dir)
|
|
|
|
if engine_ver_str is None:
|
|
return None
|
|
|
|
version_pattern = r'adxe-([\d]+)\.([\d]+)'
|
|
match = re.match(version_pattern, engine_ver_str)
|
|
if match:
|
|
return ((int)(match.group(1)), (int)(match.group(2)))
|
|
else:
|
|
return None
|
|
|
|
def build_android(self):
|
|
if not self._platforms.is_android_active():
|
|
return
|
|
|
|
project_dir = self._project.get_project_dir()
|
|
build_mode = self._mode
|
|
output_dir = self._output_dir
|
|
|
|
# get the android project path
|
|
cfg_obj = self._platforms.get_current_config()
|
|
project_android_dir = cfg_obj.proj_path
|
|
|
|
|
|
ide_name = 'Android Studio'
|
|
adxe.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
|
|
# Get the engine version of the project
|
|
engine_version_num = self.get_engine_version_num()
|
|
if engine_version_num is None:
|
|
raise adxe.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]
|
|
print("adxe version: " + str(main_ver) + ";minor_ver=" + str(minor_ver))
|
|
|
|
# adxe always support ndk
|
|
gradle_support_ndk = True
|
|
|
|
|
|
if(sys.version_info.major >= 3):
|
|
from .build_android import AndroidBuilder
|
|
else:
|
|
from build_android import AndroidBuilder
|
|
builder = AndroidBuilder(self._verbose, project_android_dir,
|
|
self._no_res, self._project, self._mode, self._build_type,
|
|
self.app_abi, gradle_support_ndk)
|
|
|
|
args_ndk_copy = self._custom_step_args.copy()
|
|
target_platform = self._platforms.get_current_platform()
|
|
|
|
# update the project with the android platform
|
|
builder.update_project(self._ap)
|
|
|
|
if not self._project._is_script_project() or self._project._is_native_support():
|
|
if self._build_type != "none" and not gradle_support_ndk:
|
|
# build native code
|
|
adxe.Logging.info(MultiLanguage.get_string('COMPILE_INFO_BUILD_NATIVE'))
|
|
ndk_build_param = [
|
|
"-j%s" % self._jobs
|
|
]
|
|
|
|
if self.app_abi:
|
|
abi_param = "APP_ABI=\"%s\"" % self.app_abi
|
|
ndk_build_param.append(abi_param)
|
|
|
|
if self.ndk_toolchain:
|
|
toolchain_param = "NDK_TOOLCHAIN=%s" % self.ndk_toolchain
|
|
ndk_build_param.append(toolchain_param)
|
|
|
|
self._project.invoke_custom_step_script(adxe_project.Project.CUSTOM_STEP_PRE_NDK_BUILD, target_platform, args_ndk_copy)
|
|
|
|
modify_mk = False
|
|
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
|
|
f = open(app_mk)
|
|
mk_content = f.read()
|
|
f.close()
|
|
|
|
# Add cpp flags
|
|
f = open(app_mk, "a")
|
|
f.write("\nAPP_CPPFLAGS += %s" % self.cppflags)
|
|
f.close()
|
|
modify_mk = True
|
|
|
|
try:
|
|
builder.do_ndk_build(ndk_build_param, self._mode, self._build_type, self)
|
|
except Exception as e:
|
|
if e.__class__.__name__ == 'CCPluginError':
|
|
raise e
|
|
else:
|
|
raise adxe.CCPluginError(MultiLanguage.get_string('COMPILE_ERROR_NDK_BUILD_FAILED'),
|
|
adxe.CCPluginError.ERROR_BUILD_FAILED)
|
|
finally:
|
|
# roll-back the Application.mk
|
|
if modify_mk:
|
|
f = open(app_mk, "w")
|
|
f.write(mk_content)
|
|
f.close()
|
|
|
|
self._project.invoke_custom_step_script(adxe_project.Project.CUSTOM_STEP_POST_NDK_BUILD, target_platform, args_ndk_copy)
|
|
|
|
# build apk
|
|
if not self._no_apk:
|
|
adxe.Logging.info(MultiLanguage.get_string('COMPILE_INFO_BUILD_APK'))
|
|
self.apk_path = builder.do_build_apk(build_mode, self._no_apk, self._no_sign, output_dir, self._custom_step_args, self._ap, self)
|
|
self.android_package, self.android_activity = builder.get_apk_info()
|
|
|
|
adxe.Logging.info(MultiLanguage.get_string('COMPILE_INFO_BUILD_SUCCEED'))
|
|
|
|
def _remove_res(self, target_path):
|
|
build_cfg_dir = self._build_cfg_path()
|
|
cfg_file = os.path.join(build_cfg_dir, CCPluginCompile.BUILD_CONFIG_FILE)
|
|
if os.path.exists(cfg_file) and os.path.isfile(cfg_file):
|
|
# have config file
|
|
open_file = open(cfg_file)
|
|
cfg_info = json.load(open_file)
|
|
open_file.close()
|
|
if adxe.dict_contains(cfg_info, "remove_res"):
|
|
remove_list = cfg_info["remove_res"]
|
|
for f in remove_list:
|
|
res = os.path.join(target_path, f)
|
|
if os.path.isdir(res):
|
|
# is a directory
|
|
if f.endswith('/'):
|
|
# remove files & dirs in it
|
|
for sub_file in os.listdir(res):
|
|
sub_file_fullpath = os.path.join(res, sub_file)
|
|
if os.path.isfile(sub_file_fullpath):
|
|
os.remove(sub_file_fullpath)
|
|
elif os.path.isdir(sub_file_fullpath):
|
|
shutil.rmtree(sub_file_fullpath)
|
|
else:
|
|
# remove the dir
|
|
shutil.rmtree(res)
|
|
elif os.path.isfile(res):
|
|
# is a file, remove it
|
|
os.remove(res)
|
|
|
|
def get_engine_dir(self):
|
|
engine_dir = self._project.get_proj_config(CCPluginCompile.PROJ_CFG_KEY_ENGINE_DIR)
|
|
if engine_dir is None:
|
|
proj_dir = self._project.get_project_dir()
|
|
if self._project._is_js_project():
|
|
check_dir = os.path.join(proj_dir, "frameworks", "cocos2d-x")
|
|
if os.path.isdir(check_dir):
|
|
# the case for jsb in cocos2d-x engine
|
|
engine_dir = check_dir
|
|
else:
|
|
# the case for jsb in cocos2d-js engine
|
|
engine_dir = proj_dir
|
|
elif self._project._is_lua_project():
|
|
engine_dir = os.path.join(proj_dir, "frameworks", "cocos2d-x")
|
|
else:
|
|
engine_dir = os.path.join(proj_dir, "cocos2d")
|
|
else:
|
|
engine_dir = os.path.join(self._project.get_project_dir(), engine_dir)
|
|
|
|
return engine_dir
|
|
|
|
def backup_dir(self, dir_path):
|
|
backup_dir = "%s%s" % (dir_path, CCPluginCompile.BACKUP_SUFFIX)
|
|
if os.path.exists(backup_dir):
|
|
shutil.rmtree(backup_dir)
|
|
shutil.copytree(dir_path, backup_dir)
|
|
|
|
def reset_backup_dir(self, dir_path):
|
|
backup_dir = "%s%s" % (dir_path, CCPluginCompile.BACKUP_SUFFIX)
|
|
if os.path.exists(dir_path):
|
|
shutil.rmtree(dir_path)
|
|
os.rename(backup_dir, dir_path)
|
|
|
|
def get_engine_js_dir(self):
|
|
engine_js_dir = None
|
|
isFound = False
|
|
|
|
check_script_dir = os.path.join(self._project.get_project_dir(), "script")
|
|
if os.path.isdir(check_script_dir):
|
|
# JS script already copied into the project dir
|
|
engine_js_dir = check_script_dir
|
|
isFound = True
|
|
else:
|
|
for js_dir in CCPluginCompile.ENGINE_JS_DIRS:
|
|
engine_js_dir = os.path.join(self.get_engine_dir(), js_dir)
|
|
if os.path.isdir(engine_js_dir):
|
|
isFound = True
|
|
break
|
|
|
|
if isFound:
|
|
return engine_js_dir
|
|
else:
|
|
return None
|
|
|
|
def _get_export_options_plist_path(self):
|
|
project_dir = self._project.get_project_dir()
|
|
|
|
possible_sub_paths = [ 'proj.ios', 'proj.ios_mac/ios', 'frameworks/runtime-src/proj.ios_mac/ios' ]
|
|
ios_project_dir = None
|
|
for sub_path in possible_sub_paths:
|
|
ios_project_dir = os.path.join(project_dir, sub_path)
|
|
if os.path.exists(ios_project_dir):
|
|
break
|
|
|
|
if ios_project_dir is None:
|
|
return None
|
|
|
|
return os.path.join(ios_project_dir, 'exportOptions.plist')
|
|
|
|
def get_available_devenv(self, required_versions, min_ver, specify_vs_ver=None):
|
|
if required_versions is None or len(required_versions) == 0:
|
|
if specify_vs_ver is None:
|
|
# Not specify VS version, find newest version
|
|
needUpgrade, commandPath = utils.get_newest_devenv(min_ver)
|
|
else:
|
|
# Have specified VS version
|
|
if specify_vs_ver < min_ver:
|
|
# Specified version is lower than required, raise error
|
|
raise adxe.CCPluginError(MultiLanguage.get_string('COMPILE_ERROR_LOW_VS_VER'),
|
|
adxe.CCPluginError.ERROR_WRONG_ARGS)
|
|
else:
|
|
# Get the specified VS
|
|
commandPath = utils.get_devenv_path(specify_vs_ver)
|
|
if specify_vs_ver > min_ver:
|
|
needUpgrade = True
|
|
else:
|
|
needUpgrade = False
|
|
else:
|
|
needUpgrade = False
|
|
if specify_vs_ver is None:
|
|
# find VS in required versions
|
|
commandPath = None
|
|
for v in required_versions:
|
|
commandPath = utils.get_devenv_path(v)
|
|
if commandPath is not None:
|
|
break
|
|
else:
|
|
# use specified VS version
|
|
if specify_vs_ver in required_versions:
|
|
commandPath = utils.get_devenv_path(specify_vs_ver)
|
|
else:
|
|
raise adxe.CCPluginError(MultiLanguage.get_string('COMPILE_ERROR_WRONG_VS_VER_FMT', specify_vs_ver),
|
|
adxe.CCPluginError.ERROR_WRONG_ARGS)
|
|
|
|
if commandPath is None:
|
|
message = MultiLanguage.get_string('COMPILE_ERROR_VS_NOT_FOUND')
|
|
raise adxe.CCPluginError(message, adxe.CCPluginError.ERROR_TOOLS_NOT_FOUND)
|
|
|
|
return (needUpgrade, commandPath)
|
|
|
|
def build_web(self):
|
|
if not self._platforms.is_web_active():
|
|
return
|
|
|
|
project_dir = self._platforms.project_path()
|
|
|
|
# store env for run
|
|
cfg_obj = self._platforms.get_current_config()
|
|
if cfg_obj.run_root_dir is not None:
|
|
self.run_root = cfg_obj.run_root_dir
|
|
else:
|
|
self.run_root = project_dir
|
|
|
|
if cfg_obj.sub_url is not None:
|
|
self.sub_url = cfg_obj.sub_url
|
|
else:
|
|
self.sub_url = '/'
|
|
|
|
output_dir = CCPluginCompile.OUTPUT_DIR_SCRIPT_RELEASE
|
|
if self._is_debug_mode():
|
|
output_dir = CCPluginCompile.OUTPUT_DIR_SCRIPT_DEBUG
|
|
if not self._web_advanced:
|
|
return
|
|
|
|
self.sub_url = '%s%s/%s/' % (self.sub_url, output_dir, CCPluginCompile.WEB_PLATFORM_FOLDER_NAME)
|
|
|
|
f = open(os.path.join(project_dir, "project.json"))
|
|
project_json = json.load(f)
|
|
f.close()
|
|
engine_dir = os.path.join(project_json["engineDir"])
|
|
realEngineDir = os.path.normpath(os.path.join(project_dir, engine_dir))
|
|
publish_dir = os.path.normpath(os.path.join(project_dir, output_dir, CCPluginCompile.WEB_PLATFORM_FOLDER_NAME))
|
|
|
|
# need to config in options of command
|
|
buildOpt = {
|
|
"outputFileName" : "game.min.js",
|
|
"debug": "true" if self._is_debug_mode() else "false",
|
|
"compilationLevel" : "advanced" if self._web_advanced else "simple",
|
|
"sourceMapOpened" : True if self._has_sourcemap else False
|
|
}
|
|
|
|
if os.path.exists(publish_dir):
|
|
shutil.rmtree(publish_dir)
|
|
os.makedirs(publish_dir)
|
|
|
|
# generate build.xml
|
|
build_web.gen_buildxml(project_dir, project_json, publish_dir, buildOpt)
|
|
|
|
outputJsPath = os.path.join(publish_dir, buildOpt["outputFileName"])
|
|
if os.path.exists(outputJsPath) == True:
|
|
os.remove(outputJsPath)
|
|
|
|
|
|
# call closure compiler
|
|
ant_root = adxe.check_environment_variable('ANT_ROOT')
|
|
ant_path = os.path.join(ant_root, 'ant')
|
|
self._run_cmd("%s -f %s" % (ant_path, os.path.join(publish_dir, 'build.xml')))
|
|
|
|
# handle sourceMap
|
|
sourceMapPath = os.path.join(publish_dir, "sourcemap")
|
|
if os.path.exists(sourceMapPath):
|
|
smFile = open(sourceMapPath)
|
|
try:
|
|
smContent = smFile.read()
|
|
finally:
|
|
smFile.close()
|
|
|
|
dir_to_replace = project_dir
|
|
if adxe.os_is_win32():
|
|
dir_to_replace = project_dir.replace('\\', '\\\\')
|
|
smContent = smContent.replace(dir_to_replace, os.path.relpath(project_dir, publish_dir))
|
|
smContent = smContent.replace(realEngineDir, os.path.relpath(realEngineDir, publish_dir))
|
|
smContent = smContent.replace('\\\\', '/')
|
|
smContent = smContent.replace('\\', '/')
|
|
smFile = open(sourceMapPath, "w")
|
|
smFile.write(smContent)
|
|
smFile.close()
|
|
|
|
# handle project.json
|
|
del project_json["engineDir"]
|
|
del project_json["modules"]
|
|
del project_json["jsList"]
|
|
project_json_output_file = open(os.path.join(publish_dir, "project.json"), "w")
|
|
project_json_output_file.write(json.dumps(project_json))
|
|
project_json_output_file.close()
|
|
|
|
# handle index.html
|
|
indexHtmlFile = open(os.path.join(project_dir, "index.html"))
|
|
try:
|
|
indexContent = indexHtmlFile.read()
|
|
finally:
|
|
indexHtmlFile.close()
|
|
reg1 = re.compile(r'<script\s+src\s*=\s*("|\')[^"\']*CCBoot\.js("|\')\s*><\/script>')
|
|
indexContent = reg1.sub("", indexContent)
|
|
mainJs = project_json.get("main") or "main.js"
|
|
indexContent = indexContent.replace(mainJs, buildOpt["outputFileName"])
|
|
indexHtmlOutputFile = open(os.path.join(publish_dir, "index.html"), "w")
|
|
indexHtmlOutputFile.write(indexContent)
|
|
indexHtmlOutputFile.close()
|
|
|
|
# copy res dir
|
|
if cfg_obj.copy_res is None:
|
|
dst_dir = os.path.join(publish_dir, 'res')
|
|
src_dir = os.path.join(project_dir, 'res')
|
|
if os.path.exists(dst_dir):
|
|
shutil.rmtree(dst_dir)
|
|
shutil.copytree(src_dir, dst_dir)
|
|
else:
|
|
for cfg in cfg_obj.copy_res:
|
|
adxe.copy_files_with_config(cfg, project_dir, publish_dir)
|
|
|
|
# copy to the output directory if necessary
|
|
pub_dir = os.path.normcase(publish_dir)
|
|
out_dir = os.path.normcase(os.path.normpath(self._output_dir))
|
|
if pub_dir != out_dir:
|
|
cpy_cfg = {
|
|
"from" : pub_dir,
|
|
"to" : out_dir
|
|
}
|
|
adxe.copy_files_with_config(cpy_cfg, pub_dir, out_dir)
|
|
|
|
def check_platform(self, platform):
|
|
if platform == 'mac':
|
|
if not self._platforms.is_mac_active() or not adxe.os_is_mac:
|
|
raise adxe.CCPluginError(MultiLanguage.get_string('COMPILE_ERROR_BUILD_ON_MAC'),
|
|
adxe.CCPluginError.ERROR_WRONG_ARGS)
|
|
|
|
if platform == 'ios':
|
|
if not self._platforms.is_ios_active() or not adxe.os_is_mac:
|
|
raise adxe.CCPluginError(MultiLanguage.get_string('COMPILE_ERROR_BUILD_ON_MAC'),
|
|
adxe.CCPluginError.ERROR_WRONG_ARGS)
|
|
|
|
if platform == 'win32':
|
|
if not self._platforms.is_win32_active or not adxe.os_is_win32:
|
|
raise adxe.CCPluginError(MultiLanguage.get_string('COMPILE_ERROR_BUILD_ON_WIN'),
|
|
adxe.CCPluginError.ERROR_WRONG_ARGS)
|
|
|
|
if platform == 'linux':
|
|
if not self._platforms.is_linux_active():
|
|
raise adxe.CCPluginError("Please build on linux")
|
|
|
|
def compile_script(self, script_path, platform):
|
|
"""
|
|
Compile and encrypt script files if needed.
|
|
"""
|
|
|
|
if not self._project._is_script_project:
|
|
return
|
|
|
|
if self._project._is_lua_project:
|
|
build_64bit = True if platform != 'win32' else False
|
|
build_32bit = True if platform != 'mac' else False
|
|
|
|
if build_64bit:
|
|
folder_64bit = os.path.join(script_path, '64bit')
|
|
self.compile_lua_scripts(script_path, folder_64bit, True)
|
|
|
|
if build_32bit:
|
|
self.compile_lua_scripts(script_path, script_path, False)
|
|
|
|
# mac only support 64bit, so should remove .lua files not int folder_64bit
|
|
if platform == 'mac' and self._compile_script:
|
|
self._remove_file_with_ext(script_path, '.lua')
|
|
|
|
# self.compile_js_script(path)
|
|
|
|
# if only support 64bit, then move to
|
|
|
|
def build(self, platform):
|
|
if self._platforms.is_android_active():
|
|
self.build_android()
|
|
return
|
|
|
|
self.check_platform(platform)
|
|
|
|
project_dir = self._project.get_project_dir()
|
|
cfg_obj = self._platforms.get_current_config()
|
|
if cfg_obj.cmake_path is not None:
|
|
cmakefile_dir = os.path.join(project_dir, cfg_obj.cmake_path)
|
|
else:
|
|
cmakefile_dir = project_dir
|
|
|
|
# get the project name
|
|
if cfg_obj.project_name is not None:
|
|
self.project_name = cfg_obj.project_name
|
|
else:
|
|
f = open(os.path.join(cmakefile_dir, 'CMakeLists.txt'), 'r')
|
|
regexp_set_app_name = re.compile(r'\s*set\s*\(\s*APP_NAME', re.IGNORECASE)
|
|
for line in f.readlines():
|
|
if regexp_set_app_name.search(line):
|
|
self.project_name = re.search('APP_NAME ([^\)]+)\)', line, re.IGNORECASE).group(1)
|
|
break
|
|
if hasattr(self, 'project_name') == False:
|
|
raise adxe.CCPluginError("Couldn't find APP_NAME in CMakeLists.txt")
|
|
|
|
if cfg_obj.build_dir is not None:
|
|
build_dir = os.path.join(project_dir, cfg_obj.build_dir)
|
|
else:
|
|
build_dir = os.path.join(project_dir, '%s-build' % platform)
|
|
|
|
if not os.path.exists(build_dir):
|
|
os.makedirs(build_dir)
|
|
|
|
# compile codes
|
|
build_mode = 'Debug' if self._is_debug_mode() else 'Release'
|
|
with adxe.pushd(build_dir):
|
|
# iOS need to generate Xcode project file first
|
|
if platform == 'ios':
|
|
engine_dir = self.get_engine_dir()
|
|
self._run_cmd('cmake %s -GXcode -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=%s' %
|
|
( os.path.relpath(cmakefile_dir, build_dir), self._use_sdk ) )
|
|
elif platform == 'mac':
|
|
self._run_cmd('cmake -GXcode %s' % os.path.relpath(cmakefile_dir, build_dir))
|
|
elif platform == "win32":
|
|
ret = utils.get_newest_devenv(self.vs_version)
|
|
if ret is not None:
|
|
ver_num = int(float(ret[2]))
|
|
generator = self.CMAKE_VS_GENERATOR_MAP[str(ver_num)]
|
|
if generator is not None:
|
|
if ver_num >= 16:
|
|
# for vs2019 x64 is the default target
|
|
self._run_cmd('cmake %s -G "%s" -A win32' %
|
|
(os.path.relpath(cmakefile_dir, build_dir), generator))
|
|
else:
|
|
self._run_cmd('cmake %s -G "%s"' %
|
|
(os.path.relpath(cmakefile_dir, build_dir), generator))
|
|
else:
|
|
adxe.Logging.warning(MultiLanguage.get_string("COMPILE_VS_VERSION_NOT_REGISTER") % (ret[2]))
|
|
self._run_cmd('cmake %s' % os.path.relpath(cmakefile_dir, build_dir) )
|
|
else:
|
|
adxe.Logging.warning(MultiLanguage.get_string("COMPILE_VS_VERSION"))
|
|
self._run_cmd('cmake %s' % os.path.relpath(cmakefile_dir, build_dir) )
|
|
else:
|
|
self._run_cmd('cmake %s' % os.path.relpath(cmakefile_dir, build_dir) )
|
|
|
|
self._run_cmd('cmake --build . --config %s' % build_mode)
|
|
|
|
# move file
|
|
output_dir = self._output_dir
|
|
|
|
if os.path.exists(output_dir):
|
|
shutil.rmtree(output_dir)
|
|
os.makedirs(output_dir)
|
|
|
|
if cfg_obj.build_result_dir is not None:
|
|
result_dir = os.path.join(build_dir, 'bin', cfg_obj.build_result_dir, self.project_name)
|
|
else:
|
|
result_dir = os.path.join(build_dir, 'bin', self.project_name)
|
|
|
|
if os.path.exists(os.path.join(result_dir, build_mode)):
|
|
result_dir = os.path.join(result_dir, build_mode)
|
|
|
|
adxe.copy_files_in_dir(result_dir, output_dir)
|
|
|
|
self.run_root = output_dir
|
|
|
|
# set application path and application name
|
|
if platform == 'mac' or platform == 'ios':
|
|
self.app_path = os.path.join(output_dir, self.project_name + '.app')
|
|
else:
|
|
self.app_path = output_dir
|
|
|
|
self.app_name = self.project_name
|
|
if platform == 'win32':
|
|
self.app_name = self.app_name + '.exe'
|
|
|
|
script_resource_path = os.path.join(self.app_path, 'src')
|
|
if platform == 'mac':
|
|
script_resource_path = os.path.join(self.app_path, 'Contents/Resources/src')
|
|
|
|
adxe.Logging.info(MultiLanguage.get_string('COMPILE_INFO_BUILD_SUCCEED'))
|
|
|
|
def _get_build_cfg(self):
|
|
build_cfg_dir = self._build_cfg_path()
|
|
build_cfg = os.path.join(build_cfg_dir, CCPluginCompile.BUILD_CONFIG_FILE)
|
|
if not os.path.exists(build_cfg):
|
|
message = MultiLanguage.get_string('COMPILE_ERROR_FILE_NOT_FOUND_FMT', build_cfg)
|
|
raise adxe.CCPluginError(message, adxe.CCPluginError.ERROR_PATH_NOT_FOUND)
|
|
f = open(build_cfg)
|
|
return json.load(f)
|
|
|
|
def _copy_resources(self, dst_path):
|
|
data = self._get_build_cfg()
|
|
|
|
if adxe.dict_contains(data, CCPluginCompile.CFG_KEY_MUST_COPY_RESOURCES):
|
|
if self._no_res:
|
|
fileList = data[CCPluginCompile.CFG_KEY_MUST_COPY_RESOURCES]
|
|
else:
|
|
fileList = data[CCPluginCompile.CFG_KEY_COPY_RESOURCES] + data[CCPluginCompile.CFG_KEY_MUST_COPY_RESOURCES]
|
|
else:
|
|
fileList = data[CCPluginCompile.CFG_KEY_COPY_RESOURCES]
|
|
|
|
for cfg in fileList:
|
|
adxe.copy_files_with_config(cfg, self._build_cfg_path(), dst_path)
|
|
|
|
def checkFileByExtention(self, ext, path):
|
|
filelist = os.listdir(path)
|
|
for fullname in filelist:
|
|
name, extention = os.path.splitext(fullname)
|
|
if extention == ext:
|
|
return name, fullname
|
|
return (None, None)
|
|
|
|
def run(self, argv, dependencies):
|
|
self.parse_args(argv)
|
|
adxe.Logging.info(MultiLanguage.get_string('COMPILE_INFO_BUILD_MODE_FMT', self._mode))
|
|
self._update_build_cfg()
|
|
|
|
target_platform = self._platforms.get_current_platform()
|
|
args_build_copy = self._custom_step_args.copy()
|
|
|
|
language = self._project.get_language()
|
|
action_str = 'compile_%s' % language
|
|
target_str = 'compile_for_%s' % target_platform
|
|
adxe.DataStatistic.stat_event('compile', action_str, target_str)
|
|
|
|
# invoke the custom step: pre-build
|
|
self._project.invoke_custom_step_script(adxe_project.Project.CUSTOM_STEP_PRE_BUILD, target_platform, args_build_copy)
|
|
|
|
self.build_web()
|
|
self.build(target_platform)
|
|
|
|
# invoke the custom step: post-build
|
|
self._project.invoke_custom_step_script(adxe_project.Project.CUSTOM_STEP_POST_BUILD, target_platform, args_build_copy)
|
|
|
|
if len(self.end_warning) > 0:
|
|
adxe.Logging.warning(self.end_warning)
|