def generate(params):
# prepare data
proj_path = params["proj_path"]
target_name = params["target_name"]
target_config = config.run(proj_path, target_name, params)
build_types = target_config["build_types"]
version = util.get_version(params, config)
source_files = []
dist_folder = os.path.join(proj_path, const.DIR_NAME_DIST, target_name)
# add folders
for build_type in build_types:
source_files.append({
"path": os.path.join(dist_folder, build_type),
"arcname": build_type,
})
# add files
source_files.append({
"path":
os.path.join(
const.DIR_NAME_DIST,
target_name,
"{0}.podspec".format(target_config["project_name"]),
),
"arcname":
"{0}.podspec".format(target_config["project_name"]),
})
# generate
pack.generate(
proj_path=proj_path,
target_name=target_name,
version=version,
source_files=source_files,
)
def run(params):
proj_path = params["proj_path"]
target_name = params["target_name"]
target_config = config.run(proj_path, target_name, params)
archs = target_config["archs"]
build_types = target_config["build_types"]
install_headers = target_config["install_headers"]
param_dry_run = ls.list_has_value(params["args"], "--dry-run")
if param_dry_run:
l.i("Running in dry mode...")
if archs and len(archs) > 0:
for arch in archs:
for build_type in build_types:
l.i("Building for: {0}/{1}...".format(arch["conan_arch"],
build_type))
# conan build
build_dir = os.path.join(
proj_path,
const.DIR_NAME_BUILD,
target_name,
build_type,
arch["group"],
arch["conan_arch"],
const.DIR_NAME_BUILD_TARGET,
)
clean_build_dir = True
if param_dry_run and os.path.isdir(build_dir):
clean_build_dir = False
if clean_build_dir:
f.recreate_dir(build_dir)
run_args = [
"conan",
"build",
os.path.join(
proj_path,
const.DIR_NAME_FILES,
const.DIR_NAME_FILES_TARGETS,
target_name,
const.DIR_NAME_FILES_TARGET_CONAN,
const.DIR_NAME_FILES_TARGET_CONAN_RECIPE,
const.FILE_NAME_FILES_TARGET_CONAN_RECIPE_CONANFILE_PY,
),
"--source-folder",
os.path.join(
proj_path,
const.DIR_NAME_FILES,
const.DIR_NAME_FILES_TARGETS,
target_name,
const.DIR_NAME_FILES_TARGET_CMAKE,
),
"--build-folder",
os.path.join(
proj_path,
const.DIR_NAME_BUILD,
target_name,
build_type,
arch["group"],
arch["conan_arch"],
const.DIR_NAME_BUILD_TARGET,
),
"--install-folder",
os.path.join(
proj_path,
const.DIR_NAME_BUILD,
target_name,
build_type,
arch["group"],
arch["conan_arch"],
const.DIR_NAME_BUILD_CONAN,
),
]
r.run(run_args, build_dir)
# find correct info plist file
plist_path1 = os.path.join(
proj_path,
const.DIR_NAME_BUILD,
target_name,
build_type,
arch["group"],
arch["conan_arch"],
const.DIR_NAME_BUILD_TARGET,
"lib",
"{0}.framework".format(target_config["project_name"]),
"Info.plist",
)
plist_path2 = os.path.join(
proj_path,
const.DIR_NAME_BUILD,
target_name,
build_type,
arch["group"],
arch["conan_arch"],
const.DIR_NAME_BUILD_TARGET,
"lib",
"{0}.framework".format(target_config["project_name"]),
"Versions",
"A",
"Resources",
"Info.plist",
)
plist_path = ""
if os.path.exists(plist_path1):
plist_path = plist_path1
if os.path.exists(plist_path2):
plist_path = plist_path2
# add minimum version inside plist
r.run(
[
"plutil",
"-replace",
"MinimumOSVersion",
"-string",
arch["min_version"],
plist_path,
],
proj_path,
)
# add supported platform inside plist
r.run(
[
"plutil",
"-replace",
"CFBundleSupportedPlatforms",
"-json",
'[ "{0}" ]'.format(arch["supported_platform"]),
plist_path,
],
proj_path,
)
# headers
dist_headers_dir = os.path.join(
proj_path,
const.DIR_NAME_BUILD,
target_name,
build_type,
arch["group"],
arch["conan_arch"],
const.DIR_NAME_BUILD_TARGET,
"lib",
"{0}.framework".format(target_config["project_name"]),
"Headers",
)
f.create_dir(dist_headers_dir)
if install_headers:
for header in install_headers:
source_header_dir = os.path.join(
proj_path, header["path"])
if header["type"] == "dir":
f.copy_dir(
source_header_dir,
dist_headers_dir,
ignore_file=_header_ignore_list,
symlinks=True,
)
else:
l.e("Invalid type for install header list for {0}".
format(target_name))
# modules
support_modules_dir = os.path.join(
proj_path,
const.DIR_NAME_FILES,
const.DIR_NAME_FILES_TARGETS,
target_name,
"support",
"modules",
)
modules_dir = os.path.join(
proj_path,
const.DIR_NAME_BUILD,
target_name,
build_type,
arch["group"],
arch["conan_arch"],
const.DIR_NAME_BUILD_TARGET,
"lib",
"{0}.framework".format(target_config["project_name"]),
"Modules",
)
f.recreate_dir(modules_dir)
f.copy_file(
os.path.join(support_modules_dir, "module.modulemap"),
os.path.join(modules_dir, "module.modulemap"),
)
# umbrella header
build_headers_dir = os.path.join(
proj_path,
const.DIR_NAME_BUILD,
target_name,
build_type,
arch["group"],
arch["conan_arch"],
const.DIR_NAME_BUILD_TARGET,
"lib",
"{0}.framework".format(target_config["project_name"]),
"Headers",
)
header_files = f.find_files(
build_headers_dir,
"*.h",
recursive=True,
)
content = f.get_file_contents(
os.path.join(support_modules_dir, "umbrella-header.h"))
for header_file in header_files:
header_file = header_file.replace(build_headers_dir + "/",
"")
content = content + '#import "{0}"\n'.format(header_file)
if len(content) > 0:
umbrella_file = os.path.join(
build_headers_dir, target_config["umbrella_header"])
f.copy_file(
os.path.join(support_modules_dir, "umbrella-header.h"),
umbrella_file,
)
f.set_file_content(umbrella_file, content)
else:
l.e("{0}".format(
"File not generated because framework headers is empty"
))
l.ok()
else:
l.e('Arch list for "{0}" is invalid or empty'.format(target_name))
def run(params):
proj_path = params["proj_path"]
target_name = params["target_name"]
target_config = config.run(proj_path, target_name, params)
archs = target_config["archs"]
build_types = target_config["build_types"]
no_framework = ls.list_has_value(params["args"], "--no-framework")
no_xcframework = ls.list_has_value(params["args"], "--no-xcframework")
# at least one need be generated
if no_framework and no_xcframework:
l.e("You need let generate framework or xcframework, but both are disabled"
)
# remove dist folder for the target
dist_dir = os.path.join(
proj_path,
const.DIR_NAME_DIST,
target_name,
)
f.remove_dir(dist_dir)
# generate framework
if not no_framework:
generate_framework(
proj_path=proj_path,
target_name=target_name,
target_config=target_config,
archs=archs,
build_types=build_types,
)
# generate xcframework
if not no_xcframework:
generate_xcframework(
proj_path=proj_path,
target_name=target_name,
target_config=target_config,
archs=archs,
build_types=build_types,
)
# add strip framework script (only required if final project use framework instead of xcframework)
l.i("Adding strip framework script...")
target_scripts_dir = os.path.join(
const.DIR_NAME_FILES,
const.DIR_NAME_FILES_TARGETS,
target_name,
const.DIR_NAME_SUPPORT,
"scripts",
)
f.copy_dir(
target_scripts_dir,
os.path.join(
const.DIR_NAME_DIST,
target_name,
"scripts",
),
symlinks=True,
)
# cocoapods
l.i("Adding cocoapods script...")
pod_file_path = os.path.join(
const.DIR_NAME_FILES,
const.DIR_NAME_FILES_TARGETS,
target_name,
const.DIR_NAME_SUPPORT,
"cocoapods",
"{0}.podspec".format(target_config["project_name"]),
)
target_pod_file_path = os.path.join(
const.DIR_NAME_DIST,
target_name,
"{0}.podspec".format(target_config["project_name"]),
)
f.copy_file(
pod_file_path,
target_pod_file_path,
)
# xcframework group dir
if not no_xcframework:
if build_types and len(build_types) > 0:
for build_type in build_types:
xcframework_dir = os.path.join(
dist_dir,
build_type,
"{0}.xcframework".format(target_config["project_name"]),
)
found_dirs = f.find_dirs(xcframework_dir, "*")
if found_dirs:
first_group = os.path.basename(found_dirs[0])
f.replace_in_file(
target_pod_file_path,
"{XCFRAMEWORK_" + build_type.upper() + "_GROUP_DIR}",
first_group,
)
f.replace_in_file(target_pod_file_path, "{NAME}",
target_config["project_name"])
f.replace_in_file(target_pod_file_path, "{VERSION}",
target_config["version"])
# finish
l.ok()
def run(params):
proj_path = params["proj_path"]
target_name = params["target_name"]
target_config = config.run(proj_path, target_name, params)
archs = target_config["archs"]
build_types = target_config["build_types"]
if archs and len(archs) > 0:
for arch in archs:
for build_type in build_types:
log.info("Building for: {0}/{1}...".format(
arch["conan_arch"], build_type))
# conan install
build_dir = os.path.join(
proj_path,
const.DIR_NAME_BUILD,
target_name,
build_type,
arch["group"],
arch["conan_arch"],
const.DIR_NAME_BUILD_CONAN,
)
file.remove_dir(build_dir)
file.create_dir(build_dir)
run_args = [
"conan",
"install",
os.path.join(
proj_path,
const.DIR_NAME_FILES,
const.DIR_NAME_FILES_TARGETS,
target_name,
const.DIR_NAME_FILES_TARGET_CONAN,
const.DIR_NAME_FILES_TARGET_CONAN_RECIPE,
const.FILE_NAME_FILES_TARGET_CONAN_RECIPE_CONANFILE_PY,
),
"-pr:b",
target.get_build_profile(),
"-pr:h",
arch["conan_profile"],
"-s:h",
"arch={0}".format(arch["conan_arch"]),
"-s:h",
"build_type={0}".format(build_type),
"-s:h",
"os.version={0}".format(arch["min_version"]),
"-s:b",
"os.version={0}".format(
(arch["build_min_version"]
if "build_min_version" in arch else None)),
"-o",
"ezored_arch={0}".format(arch["conan_arch"]),
"-o",
"ezored_name={0}".format(target_config["project_name"]),
"-o",
"ezored_version={0}".format(target_config["version"]),
"-o",
"ezored_group={0}".format(arch["group"]),
"-o",
"darwin-toolchain:enable_bitcode={0}".format(
(arch["enable_bitcode"]
if "enable_bitcode" in arch else None)),
"-o",
"darwin-toolchain:enable_arc={0}".format(
(arch["enable_arc"]
if "enable_arc" in arch else None)),
"-o",
"darwin-toolchain:enable_visibility={0}".format(
(arch["enable_visibility"]
if "enable_visibility" in arch else None)),
"--build=missing",
"--update",
]
runner.run(run_args, build_dir)
log.ok()
else:
log.error(
'Arch list for "{0}" is invalid or empty'.format(target_name))
def run(params):
proj_path = params["proj_path"]
target_name = params["target_name"]
target_config = config.run(proj_path, target_name, params)
archs = target_config["archs"]
build_types = target_config["build_types"]
no_framework = util.list_has_key(params["args"], "--no-framework")
no_xcframework = util.list_has_key(params["args"], "--no-xcframework")
# at least one need be generated
if no_framework and no_xcframework:
log.error(
"You need let generate framework or xcframework, but both are disabled"
)
# remove dist folder for the target
dist_dir = os.path.join(
proj_path,
const.DIR_NAME_DIST,
target_name,
)
file.remove_dir(dist_dir)
# generate framework
if not no_framework:
generate_framework(
proj_path=proj_path,
target_name=target_name,
target_config=target_config,
archs=archs,
build_types=build_types,
)
# generate xcframework
if not no_xcframework:
generate_xcframework(
proj_path=proj_path,
target_name=target_name,
target_config=target_config,
archs=archs,
build_types=build_types,
)
# add strip framework script (only required if final project use framework instead of xcframework)
log.info("Adding strip framework script...")
target_scripts_dir = os.path.join(
const.DIR_NAME_FILES,
const.DIR_NAME_FILES_TARGETS,
target_name,
const.DIR_NAME_SUPPORT,
"scripts",
)
file.copy_dir(
target_scripts_dir,
os.path.join(
const.DIR_NAME_DIST,
target_name,
"scripts",
),
)
# cocoapods
log.info("Adding cocoapods script...")
pod_file_path = os.path.join(
const.DIR_NAME_FILES,
const.DIR_NAME_FILES_TARGETS,
target_name,
const.DIR_NAME_SUPPORT,
"cocoapods",
"{0}.podspec".format(target_config["project_name"]),
)
target_pod_file_path = os.path.join(
const.DIR_NAME_DIST,
target_name,
"{0}.podspec".format(target_config["project_name"]),
)
file.copy_file(
pod_file_path,
target_pod_file_path,
)
file.replace_in_file(target_pod_file_path, "{NAME}",
target_config["project_name"])
file.replace_in_file(target_pod_file_path, "{VERSION}",
target_config["version"])
# finish
log.ok()
def run(params):
proj_path = params["proj_path"]
target_name = params["target_name"]
target_config = config.run(proj_path, target_name, params)
archs = target_config["archs"]
build_types = target_config["build_types"]
if archs and len(archs) > 0:
for arch in archs:
for build_type in build_types:
l.i("Building for: {0}/{1}...".format(arch["conan_arch"],
build_type))
# conan install
build_dir = os.path.join(
proj_path,
const.DIR_NAME_BUILD,
target_name,
build_type,
arch["group"],
arch["conan_arch"],
const.DIR_NAME_BUILD_CONAN,
)
f.recreate_dir(build_dir)
run_args = [
"conan",
"install",
os.path.join(
proj_path,
const.DIR_NAME_FILES,
const.DIR_NAME_FILES_TARGETS,
target_name,
const.DIR_NAME_FILES_TARGET_CONAN,
const.DIR_NAME_FILES_TARGET_CONAN_RECIPE,
const.FILE_NAME_FILES_TARGET_CONAN_RECIPE_CONANFILE_PY,
),
"-pr:b",
target.get_build_profile(),
"-pr:h",
arch["conan_profile"],
"-s:h",
"arch={0}".format(arch["conan_arch"]),
"-s:h",
"build_type={0}".format(build_type),
"-s:h",
"os.version={0}".format(arch["min_version"]),
"-o",
"ezored_arch={0}".format(arch["conan_arch"]),
"-o",
"ezored_name={0}".format(target_config["project_name"]),
"-o",
"ezored_version={0}".format(target_config["version"]),
"-o",
"ezored_group={0}".format(arch["group"]),
]
# extra run args
if "enable_bitcode" in arch:
run_args.append("-o:h")
run_args.append(
"darwin-toolchain:enable_bitcode={0}".format(
arch["enable_bitcode"]))
if "enable_arc" in arch:
run_args.append("-o:h")
run_args.append("darwin-toolchain:enable_arc={0}".format(
arch["enable_arc"]))
if "enable_visibility" in arch:
run_args.append("-o:h")
run_args.append(
"darwin-toolchain:enable_visibility={0}".format(
arch["enable_visibility"]))
if "subsystem_ios_version" in arch:
run_args.append("-s:h")
run_args.append("os.subsystem.ios_version={0}".format(
arch["subsystem_ios_version"]))
# final run args
run_args.append("--build=missing")
run_args.append("--update")
r.run(run_args, cwd=build_dir)
l.ok()
else:
l.e('Arch list for "{0}" is invalid or empty'.format(target_name))