mirror of
https://github.com/godotengine/godot.git
synced 2024-12-27 11:24:59 +08:00
554312a3b2
We no longer build the Vulkan loader, and volk lets us load it dynamically. Roblox uses volk on Android so it should work well for us too.
399 lines
14 KiB
Python
399 lines
14 KiB
Python
import os
|
|
import sys
|
|
import platform
|
|
from distutils.version import LooseVersion
|
|
|
|
|
|
def is_active():
|
|
return True
|
|
|
|
|
|
def get_name():
|
|
return "Android"
|
|
|
|
|
|
def can_build():
|
|
return ("ANDROID_SDK_ROOT" in os.environ) or ("ANDROID_HOME" in os.environ)
|
|
|
|
|
|
def get_platform(platform):
|
|
return int(platform.split("-")[1])
|
|
|
|
|
|
def get_opts():
|
|
from SCons.Variables import BoolVariable, EnumVariable
|
|
|
|
return [
|
|
("ANDROID_NDK_ROOT", "Path to the Android NDK", get_android_ndk_root()),
|
|
("ANDROID_SDK_ROOT", "Path to the Android SDK", get_android_sdk_root()),
|
|
("ndk_platform", 'Target platform (android-<api>, e.g. "android-24")', "android-24"),
|
|
EnumVariable("android_arch", "Target architecture", "armv7", ("armv7", "arm64v8", "x86", "x86_64")),
|
|
BoolVariable("android_neon", "Enable NEON support (armv7 only)", True),
|
|
]
|
|
|
|
|
|
# Return the ANDROID_SDK_ROOT environment variable.
|
|
# While ANDROID_HOME has been deprecated, it's used as a fallback for backward
|
|
# compatibility purposes.
|
|
def get_android_sdk_root():
|
|
if "ANDROID_SDK_ROOT" in os.environ:
|
|
return os.environ.get("ANDROID_SDK_ROOT", 0)
|
|
else:
|
|
return os.environ.get("ANDROID_HOME", 0)
|
|
|
|
|
|
# Return the ANDROID_NDK_ROOT environment variable.
|
|
# We generate one for this build using the ANDROID_SDK_ROOT env
|
|
# variable and the project ndk version.
|
|
# If the env variable is already defined, we override it with
|
|
# our own to match what the project expects.
|
|
def get_android_ndk_root():
|
|
return get_android_sdk_root() + "/ndk/" + get_project_ndk_version()
|
|
|
|
|
|
def get_flags():
|
|
return [
|
|
("tools", False),
|
|
]
|
|
|
|
|
|
def create(env):
|
|
tools = env["TOOLS"]
|
|
if "mingw" in tools:
|
|
tools.remove("mingw")
|
|
if "applelink" in tools:
|
|
tools.remove("applelink")
|
|
env.Tool("gcc")
|
|
return env.Clone(tools=tools)
|
|
|
|
|
|
# Check if ANDROID_NDK_ROOT is valid.
|
|
# If not, install the ndk using ANDROID_SDK_ROOT and sdkmanager.
|
|
def install_ndk_if_needed(env):
|
|
print("Checking for Android NDK...")
|
|
env_ndk_version = get_env_ndk_version(env["ANDROID_NDK_ROOT"])
|
|
if env_ndk_version is None:
|
|
# Reinstall the ndk and update ANDROID_NDK_ROOT.
|
|
print("Installing Android NDK...")
|
|
if env["ANDROID_SDK_ROOT"] is None:
|
|
raise Exception("Invalid ANDROID_SDK_ROOT environment variable.")
|
|
|
|
import subprocess
|
|
|
|
extension = ".bat" if os.name == "nt" else ""
|
|
sdkmanager_path = env["ANDROID_SDK_ROOT"] + "/cmdline-tools/latest/bin/sdkmanager" + extension
|
|
ndk_download_args = "ndk;" + get_project_ndk_version()
|
|
subprocess.check_call([sdkmanager_path, ndk_download_args])
|
|
|
|
env["ANDROID_NDK_ROOT"] = env["ANDROID_SDK_ROOT"] + "/ndk/" + get_project_ndk_version()
|
|
print("ANDROID_NDK_ROOT: " + env["ANDROID_NDK_ROOT"])
|
|
|
|
|
|
def configure(env):
|
|
install_ndk_if_needed(env)
|
|
|
|
# Workaround for MinGW. See:
|
|
# http://www.scons.org/wiki/LongCmdLinesOnWin32
|
|
if os.name == "nt":
|
|
|
|
import subprocess
|
|
|
|
def mySubProcess(cmdline, env):
|
|
# print("SPAWNED : " + cmdline)
|
|
startupinfo = subprocess.STARTUPINFO()
|
|
startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
|
|
proc = subprocess.Popen(
|
|
cmdline,
|
|
stdin=subprocess.PIPE,
|
|
stdout=subprocess.PIPE,
|
|
stderr=subprocess.PIPE,
|
|
startupinfo=startupinfo,
|
|
shell=False,
|
|
env=env,
|
|
)
|
|
data, err = proc.communicate()
|
|
rv = proc.wait()
|
|
if rv:
|
|
print("=====")
|
|
print(err)
|
|
print("=====")
|
|
return rv
|
|
|
|
def mySpawn(sh, escape, cmd, args, env):
|
|
|
|
newargs = " ".join(args[1:])
|
|
cmdline = cmd + " " + newargs
|
|
|
|
rv = 0
|
|
if len(cmdline) > 32000 and cmd.endswith("ar"):
|
|
cmdline = cmd + " " + args[1] + " " + args[2] + " "
|
|
for i in range(3, len(args)):
|
|
rv = mySubProcess(cmdline + args[i], env)
|
|
if rv:
|
|
break
|
|
else:
|
|
rv = mySubProcess(cmdline, env)
|
|
|
|
return rv
|
|
|
|
env["SPAWN"] = mySpawn
|
|
|
|
# Architecture
|
|
|
|
if env["android_arch"] not in ["armv7", "arm64v8", "x86", "x86_64"]:
|
|
env["android_arch"] = "armv7"
|
|
|
|
neon_text = ""
|
|
if env["android_arch"] == "armv7" and env["android_neon"]:
|
|
neon_text = " (with NEON)"
|
|
print("Building for Android, platform " + env["ndk_platform"] + " (" + env["android_arch"] + ")" + neon_text)
|
|
|
|
can_vectorize = True
|
|
if env["android_arch"] == "x86":
|
|
env["ARCH"] = "arch-x86"
|
|
env.extra_suffix = ".x86" + env.extra_suffix
|
|
target_subpath = "x86-4.9"
|
|
abi_subpath = "i686-linux-android"
|
|
arch_subpath = "x86"
|
|
env["x86_libtheora_opt_gcc"] = True
|
|
if env["android_arch"] == "x86_64":
|
|
if get_platform(env["ndk_platform"]) < 21:
|
|
print(
|
|
"WARNING: android_arch=x86_64 is not supported by ndk_platform lower than android-21; setting"
|
|
" ndk_platform=android-21"
|
|
)
|
|
env["ndk_platform"] = "android-21"
|
|
env["ARCH"] = "arch-x86_64"
|
|
env.extra_suffix = ".x86_64" + env.extra_suffix
|
|
target_subpath = "x86_64-4.9"
|
|
abi_subpath = "x86_64-linux-android"
|
|
arch_subpath = "x86_64"
|
|
env["x86_libtheora_opt_gcc"] = True
|
|
elif env["android_arch"] == "armv7":
|
|
env["ARCH"] = "arch-arm"
|
|
target_subpath = "arm-linux-androideabi-4.9"
|
|
abi_subpath = "arm-linux-androideabi"
|
|
arch_subpath = "armeabi-v7a"
|
|
if env["android_neon"]:
|
|
env.extra_suffix = ".armv7.neon" + env.extra_suffix
|
|
else:
|
|
env.extra_suffix = ".armv7" + env.extra_suffix
|
|
elif env["android_arch"] == "arm64v8":
|
|
if get_platform(env["ndk_platform"]) < 21:
|
|
print(
|
|
"WARNING: android_arch=arm64v8 is not supported by ndk_platform lower than android-21; setting"
|
|
" ndk_platform=android-21"
|
|
)
|
|
env["ndk_platform"] = "android-21"
|
|
env["ARCH"] = "arch-arm64"
|
|
target_subpath = "aarch64-linux-android-4.9"
|
|
abi_subpath = "aarch64-linux-android"
|
|
arch_subpath = "arm64-v8a"
|
|
env.extra_suffix = ".armv8" + env.extra_suffix
|
|
|
|
# Build type
|
|
|
|
if env["target"].startswith("release"):
|
|
if env["optimize"] == "speed": # optimize for speed (default)
|
|
env.Append(LINKFLAGS=["-O2"])
|
|
env.Append(CCFLAGS=["-O2", "-fomit-frame-pointer"])
|
|
elif env["optimize"] == "size": # optimize for size
|
|
env.Append(CCFLAGS=["-Os"])
|
|
env.Append(LINKFLAGS=["-Os"])
|
|
|
|
env.Append(CPPDEFINES=["NDEBUG"])
|
|
if can_vectorize:
|
|
env.Append(CCFLAGS=["-ftree-vectorize"])
|
|
if env["target"] == "release_debug":
|
|
env.Append(CPPDEFINES=["DEBUG_ENABLED"])
|
|
elif env["target"] == "debug":
|
|
env.Append(LINKFLAGS=["-O0"])
|
|
env.Append(CCFLAGS=["-O0", "-g", "-fno-limit-debug-info"])
|
|
env.Append(CPPDEFINES=["_DEBUG", "DEBUG_ENABLED"])
|
|
env.Append(CPPFLAGS=["-UNDEBUG"])
|
|
|
|
# Compiler configuration
|
|
|
|
env["SHLIBSUFFIX"] = ".so"
|
|
|
|
if env["PLATFORM"] == "win32":
|
|
env.Tool("gcc")
|
|
env.use_windows_spawn_fix()
|
|
|
|
if sys.platform.startswith("linux"):
|
|
host_subpath = "linux-x86_64"
|
|
elif sys.platform.startswith("darwin"):
|
|
host_subpath = "darwin-x86_64"
|
|
elif sys.platform.startswith("win"):
|
|
if platform.machine().endswith("64"):
|
|
host_subpath = "windows-x86_64"
|
|
else:
|
|
host_subpath = "windows"
|
|
|
|
compiler_path = env["ANDROID_NDK_ROOT"] + "/toolchains/llvm/prebuilt/" + host_subpath + "/bin"
|
|
gcc_toolchain_path = env["ANDROID_NDK_ROOT"] + "/toolchains/" + target_subpath + "/prebuilt/" + host_subpath
|
|
tools_path = gcc_toolchain_path + "/" + abi_subpath + "/bin"
|
|
|
|
# For Clang to find NDK tools in preference of those system-wide
|
|
env.PrependENVPath("PATH", tools_path)
|
|
|
|
ccache_path = os.environ.get("CCACHE")
|
|
if ccache_path is None:
|
|
env["CC"] = compiler_path + "/clang"
|
|
env["CXX"] = compiler_path + "/clang++"
|
|
else:
|
|
# there aren't any ccache wrappers available for Android,
|
|
# to enable caching we need to prepend the path to the ccache binary
|
|
env["CC"] = ccache_path + " " + compiler_path + "/clang"
|
|
env["CXX"] = ccache_path + " " + compiler_path + "/clang++"
|
|
env["AR"] = tools_path + "/ar"
|
|
env["RANLIB"] = tools_path + "/ranlib"
|
|
env["AS"] = tools_path + "/as"
|
|
|
|
common_opts = ["-gcc-toolchain", gcc_toolchain_path]
|
|
|
|
# Compile flags
|
|
|
|
env.Append(CPPFLAGS=["-isystem", env["ANDROID_NDK_ROOT"] + "/sources/cxx-stl/llvm-libc++/include"])
|
|
env.Append(CPPFLAGS=["-isystem", env["ANDROID_NDK_ROOT"] + "/sources/cxx-stl/llvm-libc++abi/include"])
|
|
|
|
# Disable exceptions and rtti on non-tools (template) builds
|
|
if env["tools"]:
|
|
env.Append(CXXFLAGS=["-frtti"])
|
|
elif env["builtin_icu"]:
|
|
env.Append(CXXFLAGS=["-frtti", "-fno-exceptions"])
|
|
else:
|
|
env.Append(CXXFLAGS=["-fno-rtti", "-fno-exceptions"])
|
|
# Don't use dynamic_cast, necessary with no-rtti.
|
|
env.Append(CPPDEFINES=["NO_SAFE_CAST"])
|
|
|
|
lib_sysroot = env["ANDROID_NDK_ROOT"] + "/platforms/" + env["ndk_platform"] + "/" + env["ARCH"]
|
|
|
|
# Using NDK unified headers (NDK r15+)
|
|
sysroot = env["ANDROID_NDK_ROOT"] + "/sysroot"
|
|
env.Append(CPPFLAGS=["--sysroot=" + sysroot])
|
|
env.Append(CPPFLAGS=["-isystem", sysroot + "/usr/include/" + abi_subpath])
|
|
env.Append(CPPFLAGS=["-isystem", env["ANDROID_NDK_ROOT"] + "/sources/android/support/include"])
|
|
# For unified headers this define has to be set manually
|
|
env.Append(CPPDEFINES=[("__ANDROID_API__", str(get_platform(env["ndk_platform"])))])
|
|
|
|
env.Append(
|
|
CCFLAGS=(
|
|
"-fpic -ffunction-sections -funwind-tables -fstack-protector-strong -fvisibility=hidden"
|
|
" -fno-strict-aliasing".split()
|
|
)
|
|
)
|
|
env.Append(CPPDEFINES=["NO_STATVFS", "GLES_ENABLED"])
|
|
|
|
if get_platform(env["ndk_platform"]) >= 24:
|
|
env.Append(CPPDEFINES=[("_FILE_OFFSET_BITS", 64)])
|
|
|
|
env["neon_enabled"] = False
|
|
if env["android_arch"] == "x86":
|
|
target_opts = ["-target", "i686-none-linux-android"]
|
|
# The NDK adds this if targeting API < 21, so we can drop it when Godot targets it at least
|
|
env.Append(CCFLAGS=["-mstackrealign"])
|
|
|
|
elif env["android_arch"] == "x86_64":
|
|
target_opts = ["-target", "x86_64-none-linux-android"]
|
|
|
|
elif env["android_arch"] == "armv7":
|
|
target_opts = ["-target", "armv7-none-linux-androideabi"]
|
|
env.Append(CCFLAGS="-march=armv7-a -mfloat-abi=softfp".split())
|
|
env.Append(CPPDEFINES=["__ARM_ARCH_7__", "__ARM_ARCH_7A__"])
|
|
if env["android_neon"]:
|
|
env["neon_enabled"] = True
|
|
env.Append(CCFLAGS=["-mfpu=neon"])
|
|
env.Append(CPPDEFINES=["__ARM_NEON__"])
|
|
else:
|
|
env.Append(CCFLAGS=["-mfpu=vfpv3-d16"])
|
|
|
|
elif env["android_arch"] == "arm64v8":
|
|
target_opts = ["-target", "aarch64-none-linux-android"]
|
|
env.Append(CCFLAGS=["-mfix-cortex-a53-835769"])
|
|
env.Append(CPPDEFINES=["__ARM_ARCH_8A__"])
|
|
|
|
env.Append(CCFLAGS=target_opts)
|
|
env.Append(CCFLAGS=common_opts)
|
|
|
|
# Link flags
|
|
|
|
ndk_version = get_env_ndk_version(env["ANDROID_NDK_ROOT"])
|
|
if ndk_version != None and LooseVersion(ndk_version) >= LooseVersion("17.1.4828580"):
|
|
env.Append(LINKFLAGS=["-Wl,--exclude-libs,libgcc.a", "-Wl,--exclude-libs,libatomic.a", "-nostdlib++"])
|
|
else:
|
|
env.Append(
|
|
LINKFLAGS=[
|
|
env["ANDROID_NDK_ROOT"] + "/sources/cxx-stl/llvm-libc++/libs/" + arch_subpath + "/libandroid_support.a"
|
|
]
|
|
)
|
|
env.Append(LINKFLAGS=["-shared", "--sysroot=" + lib_sysroot, "-Wl,--warn-shared-textrel"])
|
|
env.Append(LIBPATH=[env["ANDROID_NDK_ROOT"] + "/sources/cxx-stl/llvm-libc++/libs/" + arch_subpath + "/"])
|
|
env.Append(
|
|
LINKFLAGS=[env["ANDROID_NDK_ROOT"] + "/sources/cxx-stl/llvm-libc++/libs/" + arch_subpath + "/libc++_shared.so"]
|
|
)
|
|
|
|
if env["android_arch"] == "armv7":
|
|
env.Append(LINKFLAGS="-Wl,--fix-cortex-a8".split())
|
|
env.Append(LINKFLAGS="-Wl,--no-undefined -Wl,-z,noexecstack -Wl,-z,relro -Wl,-z,now".split())
|
|
env.Append(LINKFLAGS="-Wl,-soname,libgodot_android.so -Wl,--gc-sections".split())
|
|
|
|
env.Append(LINKFLAGS=target_opts)
|
|
env.Append(LINKFLAGS=common_opts)
|
|
|
|
env.Append(
|
|
LIBPATH=[
|
|
env["ANDROID_NDK_ROOT"]
|
|
+ "/toolchains/"
|
|
+ target_subpath
|
|
+ "/prebuilt/"
|
|
+ host_subpath
|
|
+ "/lib/gcc/"
|
|
+ abi_subpath
|
|
+ "/4.9.x"
|
|
]
|
|
)
|
|
env.Append(
|
|
LIBPATH=[
|
|
env["ANDROID_NDK_ROOT"]
|
|
+ "/toolchains/"
|
|
+ target_subpath
|
|
+ "/prebuilt/"
|
|
+ host_subpath
|
|
+ "/"
|
|
+ abi_subpath
|
|
+ "/lib"
|
|
]
|
|
)
|
|
|
|
env.Prepend(CPPPATH=["#platform/android"])
|
|
env.Append(CPPDEFINES=["ANDROID_ENABLED", "UNIX_ENABLED", "NO_FCNTL"])
|
|
env.Append(LIBS=["OpenSLES", "EGL", "GLESv2", "android", "log", "z", "dl"])
|
|
|
|
if env["vulkan"]:
|
|
env.Append(CPPDEFINES=["VULKAN_ENABLED"])
|
|
if not env["use_volk"]:
|
|
env.Append(LIBS=["vulkan"])
|
|
|
|
|
|
# Return the project NDK version.
|
|
# This is kept in sync with the value in 'platform/android/java/app/config.gradle'.
|
|
def get_project_ndk_version():
|
|
return "21.4.7075529"
|
|
|
|
|
|
# Return NDK version string in source.properties (adapted from the Chromium project).
|
|
def get_env_ndk_version(path):
|
|
if path is None:
|
|
return None
|
|
prop_file_path = os.path.join(path, "source.properties")
|
|
try:
|
|
with open(prop_file_path) as prop_file:
|
|
for line in prop_file:
|
|
key_value = list(map(lambda x: x.strip(), line.split("=")))
|
|
if key_value[0] == "Pkg.Revision":
|
|
return key_value[1]
|
|
except Exception:
|
|
print("Could not read source prop file '%s'" % prop_file_path)
|
|
return None
|