mirror of
https://github.com/python/cpython.git
synced 2024-11-25 09:39:56 +01:00
2520eed0a5
Add code and config for a minimal Android app, and instructions to build and run it. Improve Android build instructions in general. Add a tool subcommand to download the Gradle wrapper (with its binary blob). Android studio must be downloaded manually (due to the license).
238 lines
7.8 KiB
Python
Executable File
238 lines
7.8 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
|
|
import argparse
|
|
import os
|
|
import re
|
|
import shutil
|
|
import subprocess
|
|
import sys
|
|
import sysconfig
|
|
from os.path import basename, relpath
|
|
from pathlib import Path
|
|
from tempfile import TemporaryDirectory
|
|
|
|
SCRIPT_NAME = Path(__file__).name
|
|
CHECKOUT = Path(__file__).resolve().parent.parent
|
|
CROSS_BUILD_DIR = CHECKOUT / "cross-build"
|
|
|
|
|
|
def delete_if_exists(path):
|
|
if path.exists():
|
|
print(f"Deleting {path} ...")
|
|
shutil.rmtree(path)
|
|
|
|
|
|
def subdir(name, *, clean=None):
|
|
path = CROSS_BUILD_DIR / name
|
|
if clean:
|
|
delete_if_exists(path)
|
|
if not path.exists():
|
|
if clean is None:
|
|
sys.exit(
|
|
f"{path} does not exist. Create it by running the appropriate "
|
|
f"`configure` subcommand of {SCRIPT_NAME}.")
|
|
else:
|
|
path.mkdir(parents=True)
|
|
return path
|
|
|
|
|
|
def run(command, *, host=None, **kwargs):
|
|
env = os.environ.copy()
|
|
if host:
|
|
env_script = CHECKOUT / "Android/android-env.sh"
|
|
env_output = subprocess.run(
|
|
f"set -eu; "
|
|
f"HOST={host}; "
|
|
f"PREFIX={subdir(host)}/prefix; "
|
|
f". {env_script}; "
|
|
f"export",
|
|
check=True, shell=True, text=True, stdout=subprocess.PIPE
|
|
).stdout
|
|
|
|
for line in env_output.splitlines():
|
|
# We don't require every line to match, as there may be some other
|
|
# output from installing the NDK.
|
|
if match := re.search(
|
|
"^(declare -x |export )?(\\w+)=['\"]?(.*?)['\"]?$", line
|
|
):
|
|
key, value = match[2], match[3]
|
|
if env.get(key) != value:
|
|
print(line)
|
|
env[key] = value
|
|
|
|
if env == os.environ:
|
|
raise ValueError(f"Found no variables in {env_script.name} output:\n"
|
|
+ env_output)
|
|
|
|
print(">", " ".join(map(str, command)))
|
|
try:
|
|
subprocess.run(command, check=True, env=env, **kwargs)
|
|
except subprocess.CalledProcessError as e:
|
|
sys.exit(e)
|
|
|
|
|
|
def build_python_path():
|
|
"""The path to the build Python binary."""
|
|
build_dir = subdir("build")
|
|
binary = build_dir / "python"
|
|
if not binary.is_file():
|
|
binary = binary.with_suffix(".exe")
|
|
if not binary.is_file():
|
|
raise FileNotFoundError("Unable to find `python(.exe)` in "
|
|
f"{build_dir}")
|
|
|
|
return binary
|
|
|
|
|
|
def configure_build_python(context):
|
|
os.chdir(subdir("build", clean=context.clean))
|
|
|
|
command = [relpath(CHECKOUT / "configure")]
|
|
if context.args:
|
|
command.extend(context.args)
|
|
run(command)
|
|
|
|
|
|
def make_build_python(context):
|
|
os.chdir(subdir("build"))
|
|
run(["make", "-j", str(os.cpu_count())])
|
|
|
|
|
|
def unpack_deps(host):
|
|
deps_url = "https://github.com/beeware/cpython-android-source-deps/releases/download"
|
|
for name_ver in ["bzip2-1.0.8-1", "libffi-3.4.4-2", "openssl-3.0.13-1",
|
|
"sqlite-3.45.1-0", "xz-5.4.6-0"]:
|
|
filename = f"{name_ver}-{host}.tar.gz"
|
|
download(f"{deps_url}/{name_ver}/{filename}")
|
|
run(["tar", "-xf", filename])
|
|
os.remove(filename)
|
|
|
|
|
|
def download(url, target_dir="."):
|
|
out_path = f"{target_dir}/{basename(url)}"
|
|
run(["curl", "-Lf", "-o", out_path, url])
|
|
return out_path
|
|
|
|
|
|
def configure_host_python(context):
|
|
host_dir = subdir(context.host, clean=context.clean)
|
|
|
|
prefix_dir = host_dir / "prefix"
|
|
if not prefix_dir.exists():
|
|
prefix_dir.mkdir()
|
|
os.chdir(prefix_dir)
|
|
unpack_deps(context.host)
|
|
|
|
build_dir = host_dir / "build"
|
|
build_dir.mkdir(exist_ok=True)
|
|
os.chdir(build_dir)
|
|
|
|
command = [
|
|
# Basic cross-compiling configuration
|
|
relpath(CHECKOUT / "configure"),
|
|
f"--host={context.host}",
|
|
f"--build={sysconfig.get_config_var('BUILD_GNU_TYPE')}",
|
|
f"--with-build-python={build_python_path()}",
|
|
"--without-ensurepip",
|
|
|
|
# Android always uses a shared libpython.
|
|
"--enable-shared",
|
|
"--without-static-libpython",
|
|
|
|
# Dependent libraries. The others are found using pkg-config: see
|
|
# android-env.sh.
|
|
f"--with-openssl={prefix_dir}",
|
|
]
|
|
|
|
if context.args:
|
|
command.extend(context.args)
|
|
run(command, host=context.host)
|
|
|
|
|
|
def make_host_python(context):
|
|
host_dir = subdir(context.host)
|
|
os.chdir(host_dir / "build")
|
|
run(["make", "-j", str(os.cpu_count())], host=context.host)
|
|
run(["make", "install", f"prefix={host_dir}/prefix"], host=context.host)
|
|
|
|
|
|
def build_all(context):
|
|
steps = [configure_build_python, make_build_python, configure_host_python,
|
|
make_host_python]
|
|
for step in steps:
|
|
step(context)
|
|
|
|
|
|
def clean_all(context):
|
|
delete_if_exists(CROSS_BUILD_DIR)
|
|
|
|
|
|
# To avoid distributing compiled artifacts without corresponding source code,
|
|
# the Gradle wrapper is not included in the CPython repository. Instead, we
|
|
# extract it from the Gradle release.
|
|
def setup_testbed(context):
|
|
ver_long = "8.7.0"
|
|
ver_short = ver_long.removesuffix(".0")
|
|
testbed_dir = CHECKOUT / "Android/testbed"
|
|
|
|
for filename in ["gradlew", "gradlew.bat"]:
|
|
out_path = download(
|
|
f"https://raw.githubusercontent.com/gradle/gradle/v{ver_long}/{filename}",
|
|
testbed_dir)
|
|
os.chmod(out_path, 0o755)
|
|
|
|
with TemporaryDirectory(prefix=SCRIPT_NAME) as temp_dir:
|
|
os.chdir(temp_dir)
|
|
bin_zip = download(
|
|
f"https://services.gradle.org/distributions/gradle-{ver_short}-bin.zip")
|
|
outer_jar = f"gradle-{ver_short}/lib/plugins/gradle-wrapper-{ver_short}.jar"
|
|
run(["unzip", bin_zip, outer_jar])
|
|
run(["unzip", "-o", "-d", f"{testbed_dir}/gradle/wrapper", outer_jar,
|
|
"gradle-wrapper.jar"])
|
|
|
|
|
|
def main():
|
|
parser = argparse.ArgumentParser()
|
|
subcommands = parser.add_subparsers(dest="subcommand")
|
|
build = subcommands.add_parser("build", help="Build everything")
|
|
configure_build = subcommands.add_parser("configure-build",
|
|
help="Run `configure` for the "
|
|
"build Python")
|
|
make_build = subcommands.add_parser("make-build",
|
|
help="Run `make` for the build Python")
|
|
configure_host = subcommands.add_parser("configure-host",
|
|
help="Run `configure` for Android")
|
|
make_host = subcommands.add_parser("make-host",
|
|
help="Run `make` for Android")
|
|
subcommands.add_parser(
|
|
"clean", help="Delete the cross-build directory")
|
|
subcommands.add_parser(
|
|
"setup-testbed", help="Download the testbed Gradle wrapper")
|
|
|
|
for subcommand in build, configure_build, configure_host:
|
|
subcommand.add_argument(
|
|
"--clean", action="store_true", default=False, dest="clean",
|
|
help="Delete any relevant directories before building")
|
|
for subcommand in build, configure_host, make_host:
|
|
subcommand.add_argument(
|
|
"host", metavar="HOST",
|
|
choices=["aarch64-linux-android", "x86_64-linux-android"],
|
|
help="Host triplet: choices=[%(choices)s]")
|
|
for subcommand in build, configure_build, configure_host:
|
|
subcommand.add_argument("args", nargs="*",
|
|
help="Extra arguments to pass to `configure`")
|
|
|
|
context = parser.parse_args()
|
|
dispatch = {"configure-build": configure_build_python,
|
|
"make-build": make_build_python,
|
|
"configure-host": configure_host_python,
|
|
"make-host": make_host_python,
|
|
"build": build_all,
|
|
"clean": clean_all,
|
|
"setup-testbed": setup_testbed}
|
|
dispatch[context.subcommand](context)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|