Magisk/build.py

744 lines
21 KiB
Python
Raw Normal View History

2017-06-04 01:39:52 +08:00
#!/usr/bin/env python3
2020-12-26 16:04:41 -08:00
import argparse
2023-05-28 17:30:20 -07:00
import glob
2020-12-26 16:04:41 -08:00
import lzma
2021-05-12 13:40:53 +08:00
import multiprocessing
import os
import platform
import shutil
import stat
2021-05-12 13:40:53 +08:00
import subprocess
import sys
2023-05-28 17:30:20 -07:00
import tarfile
import textwrap
2021-05-12 13:40:53 +08:00
import urllib.request
2024-05-08 21:50:59 -07:00
from pathlib import Path
2023-05-02 16:28:02 -07:00
from zipfile import ZipFile
2017-11-12 04:17:56 +08:00
2023-05-11 21:01:04 -07:00
def color_print(code, str):
2022-08-17 01:59:23 -07:00
if no_color:
2023-05-16 02:07:49 -07:00
print(str)
2020-12-25 15:54:47 -08:00
else:
2023-05-16 02:07:49 -07:00
str = str.replace("\n", f"\033[0m\n{code}")
2023-05-11 21:01:04 -07:00
print(f"{code}{str}\033[0m")
def error(str):
color_print("\033[41;39m", f"\n! {str}\n")
sys.exit(1)
2017-06-03 20:19:01 +08:00
def header(str):
2023-05-11 21:01:04 -07:00
color_print("\033[44;39m", f"\n{str}\n")
2017-06-03 20:19:01 +08:00
2018-08-06 02:01:04 +08:00
def vprint(str):
if args.verbose > 0:
print(str)
2018-08-06 02:01:04 +08:00
2023-05-11 02:39:57 -07:00
is_windows = os.name == "nt"
EXE_EXT = ".exe" if is_windows else ""
2020-12-26 16:04:41 -08:00
2023-04-25 04:46:25 +08:00
no_color = False
if is_windows:
2022-08-17 01:59:23 -07:00
try:
import colorama
2023-05-11 02:39:57 -07:00
2022-08-17 01:59:23 -07:00
colorama.init()
except ImportError:
# We can't do ANSI color codes in terminal on Windows without colorama
no_color = True
2020-12-26 16:04:41 -08:00
2017-06-03 20:19:01 +08:00
# Environment checks
2022-12-26 00:09:27 -08:00
if not sys.version_info >= (3, 8):
2023-05-11 02:39:57 -07:00
error("Requires Python 3.8+")
2017-06-03 20:19:01 +08:00
2023-05-11 02:39:57 -07:00
if "ANDROID_SDK_ROOT" not in os.environ:
2023-05-11 21:01:04 -07:00
error("Please set Android SDK path to environment variable ANDROID_SDK_ROOT!")
2017-06-03 20:19:01 +08:00
2023-06-08 11:28:00 +08:00
if shutil.which("sccache") is not None:
os.environ["RUSTC_WRAPPER"] = "sccache"
os.environ["NDK_CCACHE"] = "sccache"
os.environ["CARGO_INCREMENTAL"] = "0"
2023-09-27 22:48:21 +08:00
if shutil.which("ccache") is not None:
os.environ["NDK_CCACHE"] = "ccache"
2023-06-08 11:28:00 +08:00
2018-05-13 03:04:40 +08:00
cpu_count = multiprocessing.cpu_count()
os_name = platform.system().lower()
2024-04-04 22:15:14 +08:00
archs = ["armeabi-v7a", "x86", "arm64-v8a", "x86_64", "riscv64"]
2023-05-11 02:39:57 -07:00
triples = [
"armv7a-linux-androideabi",
"i686-linux-android",
"aarch64-linux-android",
"x86_64-linux-android",
2024-04-04 22:15:14 +08:00
"riscv64-linux-android",
2023-05-11 02:39:57 -07:00
]
default_targets = ["magisk", "magiskinit", "magiskboot", "magiskpolicy"]
2023-05-11 02:39:57 -07:00
support_targets = default_targets + ["resetprop"]
rust_targets = ["magisk", "magiskinit", "magiskboot", "magiskpolicy"]
2024-05-08 21:50:59 -07:00
sdk_path = Path(os.environ["ANDROID_SDK_ROOT"])
ndk_root = sdk_path / "ndk"
ndk_path = ndk_root / "magisk"
ndk_build = ndk_path / "ndk-build"
rust_bin = ndk_path / "toolchains" / "rust" / "bin"
llvm_bin = ndk_path / "toolchains" / "llvm" / "prebuilt" / f"{os_name}-x86_64" / "bin"
cargo = rust_bin / f"cargo{EXE_EXT}"
2024-05-09 02:19:24 -07:00
gradlew = Path("gradlew" + (".bat" if is_windows else "")).resolve()
2024-05-08 21:50:59 -07:00
adb_path = sdk_path / "platform-tools" / f"adb{EXE_EXT}"
native_gen_path = Path("native", "out", "generated").resolve()
2018-05-13 03:04:40 +08:00
2019-10-17 18:02:31 -04:00
# Global vars
config = {}
STDOUT = None
2020-12-26 16:04:41 -08:00
build_tools = None
2024-05-08 21:50:59 -07:00
def mv(source: Path, target: Path):
try:
shutil.move(source, target)
2023-05-11 02:39:57 -07:00
vprint(f"mv {source} -> {target}")
2019-02-11 17:14:29 -05:00
except:
pass
2024-05-08 21:50:59 -07:00
def cp(source: Path, target: Path):
try:
shutil.copyfile(source, target)
2023-05-11 02:39:57 -07:00
vprint(f"cp {source} -> {target}")
2019-02-11 17:14:29 -05:00
except:
pass
2024-05-08 21:50:59 -07:00
def rm(file: Path):
try:
os.remove(file)
2023-05-11 02:39:57 -07:00
vprint(f"rm {file}")
2023-06-15 05:57:19 -07:00
except FileNotFoundError as e:
pass
2017-06-03 20:19:01 +08:00
def rm_on_error(func, path, _):
2023-06-15 05:57:19 -07:00
# Removing a read-only file on Windows will get "WindowsError: [Error 5] Access is denied"
# Clear the "read-only" bit and retry
try:
os.chmod(path, stat.S_IWRITE)
os.unlink(path)
except FileNotFoundError as e:
pass
2024-05-08 21:50:59 -07:00
def rm_rf(path: Path):
2023-05-11 02:39:57 -07:00
vprint(f"rm -rf {path}")
2023-06-15 05:57:19 -07:00
shutil.rmtree(path, ignore_errors=False, onerror=rm_on_error)
2020-04-03 03:33:39 -07:00
2022-06-30 14:50:21 -07:00
def execv(cmd, env=None):
return subprocess.run(cmd, stdout=STDOUT, env=env)
def system(cmd):
return subprocess.run(cmd, shell=True, stdout=STDOUT)
2022-06-30 14:50:21 -07:00
def cmd_out(cmd, env=None):
2023-05-11 02:39:57 -07:00
return (
subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, env=env)
.stdout.strip()
.decode("utf-8")
)
2020-12-24 04:46:31 -08:00
def xz(data):
return lzma.compress(data, preset=9, check=lzma.CHECK_NONE)
2020-04-03 03:33:39 -07:00
def parse_props(file):
props = {}
2023-05-11 02:39:57 -07:00
with open(file, "r") as f:
for line in [l.strip(" \t\r\n") for l in f]:
if line.startswith("#") or len(line) == 0:
2020-04-03 03:33:39 -07:00
continue
2023-05-11 02:39:57 -07:00
prop = line.split("=")
2020-04-03 03:33:39 -07:00
if len(prop) != 2:
continue
2023-05-11 02:39:57 -07:00
value = prop[1].strip(" \t\r\n")
2020-12-24 04:46:31 -08:00
if len(value) == 0:
continue
2023-05-11 02:39:57 -07:00
props[prop[0].strip(" \t\r\n")] = value
2020-04-03 03:33:39 -07:00
return props
def load_config(args):
2023-05-11 02:39:57 -07:00
commit_hash = cmd_out(["git", "rev-parse", "--short=8", "HEAD"])
2020-04-03 03:33:39 -07:00
2020-12-25 05:34:15 -08:00
# Default values
2023-05-11 02:39:57 -07:00
config["version"] = commit_hash
2023-10-19 15:44:34 -07:00
config["versionCode"] = 1000000
2023-05-11 02:39:57 -07:00
config["outdir"] = "out"
2024-05-08 21:50:59 -07:00
args.config = Path(args.config)
2020-12-25 05:34:15 -08:00
# Load prop files
2024-05-08 21:50:59 -07:00
if args.config.exists():
2020-12-24 04:46:31 -08:00
config.update(parse_props(args.config))
2019-10-23 19:57:47 +09:00
2024-05-08 21:50:59 -07:00
if Path("gradle.properties").exists():
2023-10-19 15:44:34 -07:00
for key, value in parse_props("gradle.properties").items():
if key.startswith("magisk."):
config[key[7:]] = value
try:
2023-05-11 02:39:57 -07:00
config["versionCode"] = int(config["versionCode"])
except ValueError:
error('Config error: "versionCode" is required to be an integer')
2024-05-08 21:50:59 -07:00
config["outdir"] = Path(config["outdir"])
config["outdir"].mkdir(mode=0o755, parents=True, exist_ok=True)
global STDOUT
STDOUT = None if args.verbose > 0 else subprocess.DEVNULL
def clean_elf():
2019-10-17 18:02:31 -04:00
if is_windows:
2024-05-08 21:50:59 -07:00
elf_cleaner = Path("tools", "elf-cleaner.exe")
else:
2024-05-08 21:50:59 -07:00
elf_cleaner = Path("native", "out", "elf-cleaner")
if not elf_cleaner.exists():
2023-05-11 02:39:57 -07:00
execv(
[
"gcc",
'-DPACKAGE_NAME="termux-elf-cleaner"',
'-DPACKAGE_VERSION="2.1.1"',
'-DCOPYRIGHT="Copyright (C) 2022 Termux."',
"tools/termux-elf-cleaner/elf-cleaner.cpp",
"tools/termux-elf-cleaner/arghandling.c",
"-o",
elf_cleaner,
]
)
args = [elf_cleaner, "--api-level", "23"]
2023-05-11 02:39:57 -07:00
args.extend(
2024-05-08 21:50:59 -07:00
Path("native", "out", arch, bin)
2023-05-11 02:39:57 -07:00
for arch in archs
for bin in ["magisk", "magiskpolicy"]
)
execv(args)
def run_ndk_build(args, flags):
2023-05-11 02:39:57 -07:00
os.chdir("native")
flags = "NDK_PROJECT_PATH=. NDK_APPLICATION_MK=src/Application.mk " + flags
if args.verbose > 1:
flags = "V=1 " + flags
2023-05-11 02:39:57 -07:00
proc = system(f"{ndk_build} {flags} -j{cpu_count}")
if proc.returncode != 0:
2023-05-11 02:39:57 -07:00
error("Build binary failed!")
os.chdir("..")
2022-06-30 14:50:21 -07:00
for arch in archs:
for tgt in support_targets + ["libinit-ld.so"]:
2024-05-08 21:50:59 -07:00
source = Path("native", "libs", arch, tgt)
target = Path("native", "out", arch, tgt)
2022-06-30 14:50:21 -07:00
mv(source, target)
def run_cargo(cmds):
env = os.environ.copy()
2023-06-15 05:57:19 -07:00
env["PATH"] = f'{rust_bin}{os.pathsep}{env["PATH"]}'
2024-05-08 21:50:59 -07:00
env["CARGO_BUILD_RUSTC"] = str(rust_bin / f"rustc{EXE_EXT}")
env["RUSTFLAGS"] = f"-Clinker-plugin-lto -Zthreads={min(8, cpu_count)}"
return execv([cargo, *cmds], env)
2022-06-30 14:50:21 -07:00
def run_cargo_build(args):
2024-05-08 21:50:59 -07:00
native_out = Path("..", "out")
native_out.mkdir(mode=0o755, exist_ok=True)
2023-05-19 15:16:54 -07:00
2022-06-30 14:50:21 -07:00
targets = set(args.target) & set(rust_targets)
2023-05-11 02:39:57 -07:00
if "resetprop" in args.target:
targets.add("magisk")
2022-06-30 14:50:21 -07:00
2023-08-30 16:23:27 -07:00
if len(targets) == 0:
return
2022-06-30 14:50:21 -07:00
# Start building the actual build commands
2023-10-17 13:29:15 -07:00
cmds = ["build", "-p", ""]
2023-05-11 02:39:57 -07:00
rust_out = "debug"
2022-06-30 14:50:21 -07:00
if args.release:
2023-05-11 02:39:57 -07:00
cmds.append("-r")
rust_out = "release"
if args.verbose == 0:
2023-05-11 02:39:57 -07:00
cmds.append("-q")
elif args.verbose > 1:
cmds.append("--verbose")
2022-06-30 14:50:21 -07:00
cmds.append("--target")
cmds.append("")
2023-05-11 02:39:57 -07:00
for arch, triple in zip(archs, triples):
rust_triple = (
"thumbv7neon-linux-androideabi" if triple.startswith("armv7") else triple
)
cmds[-1] = rust_triple
2023-10-17 13:29:15 -07:00
for target in targets:
cmds[2] = target
proc = run_cargo(cmds)
2023-10-17 13:29:15 -07:00
if proc.returncode != 0:
error("Build binary failed!")
2022-06-30 14:50:21 -07:00
2024-05-08 21:50:59 -07:00
arch_out = native_out / arch
arch_out.mkdir(mode=0o755, exist_ok=True)
2022-06-30 14:50:21 -07:00
for tgt in targets:
2024-05-08 21:50:59 -07:00
source = Path("target", rust_triple, rust_out, f"lib{tgt}.a")
target = arch_out / f"lib{tgt}-rs.a"
2022-06-30 14:50:21 -07:00
mv(source, target)
def run_cargo_cmd(args):
global STDOUT
STDOUT = None
if len(args.commands) >= 1 and args.commands[0] == "--":
args.commands = args.commands[1:]
2024-05-08 21:50:59 -07:00
os.chdir(Path("native", "src"))
run_cargo(args.commands)
2024-05-08 21:50:59 -07:00
os.chdir(Path("..", ".."))
2024-05-08 21:50:59 -07:00
def write_if_diff(file_name: Path, text: str):
do_write = True
2024-05-08 21:50:59 -07:00
if file_name.exists():
2023-05-11 02:39:57 -07:00
with open(file_name, "r") as f:
orig = f.read()
do_write = orig != text
if do_write:
2023-05-11 02:39:57 -07:00
with open(file_name, "w") as f:
f.write(text)
def binary_dump(src, var_name, compressor=xz):
2023-05-11 02:39:57 -07:00
out_str = f"constexpr unsigned char {var_name}[] = {{"
for i, c in enumerate(compressor(src.read())):
if i % 16 == 0:
2023-05-11 02:39:57 -07:00
out_str += "\n"
out_str += f"0x{c:02X},"
out_str += "\n};\n"
return out_str
2022-05-15 01:01:54 -07:00
def dump_bin_header(args):
2024-05-08 21:50:59 -07:00
native_gen_path.mkdir(mode=0o755, parents=True, exist_ok=True)
for arch in archs:
2024-05-08 21:50:59 -07:00
preload = Path("native", "out", arch, "libinit-ld.so")
2023-05-11 02:39:57 -07:00
with open(preload, "rb") as src:
text = binary_dump(src, "init_ld_xz")
2024-05-08 21:50:59 -07:00
write_if_diff(Path(native_gen_path, f"{arch}_binaries.h"), text)
def dump_flag_header():
2023-05-11 02:39:57 -07:00
flag_txt = textwrap.dedent(
"""\
#pragma once
#define quote(s) #s
#define str(s) quote(s)
#define MAGISK_FULL_VER MAGISK_VERSION "(" str(MAGISK_VER_CODE) ")"
#define NAME_WITH_VER(name) str(name) " " MAGISK_FULL_VER
2023-05-11 02:39:57 -07:00
"""
)
flag_txt += f'#define MAGISK_VERSION "{config["version"]}"\n'
flag_txt += f'#define MAGISK_VER_CODE {config["versionCode"]}\n'
2023-05-11 02:39:57 -07:00
flag_txt += f"#define MAGISK_DEBUG {0 if args.release else 1}\n"
2024-05-08 21:50:59 -07:00
native_gen_path.mkdir(mode=0o755, parents=True, exist_ok=True)
write_if_diff(Path(native_gen_path, "flags.h"), flag_txt)
2020-03-27 23:23:26 -07:00
2018-05-13 03:04:40 +08:00
def build_binary(args):
2020-04-03 03:33:39 -07:00
# Verify NDK install
2022-04-15 10:04:04 -07:00
try:
2024-05-08 21:50:59 -07:00
with open(Path(ndk_path, "ONDK_VERSION"), "r") as ondk_ver:
2023-05-11 02:39:57 -07:00
assert ondk_ver.read().strip(" \t\r\n") == config["ondkVersion"]
2022-04-15 10:04:04 -07:00
except:
error('Unmatched NDK. Please install/upgrade NDK with "build.py ndk"')
2020-04-03 03:33:39 -07:00
2023-05-11 02:39:57 -07:00
if "target" not in vars(args):
vars(args)["target"] = []
if args.target:
2019-05-30 21:17:58 -07:00
args.target = set(args.target) & set(support_targets)
if not args.target:
return
else:
2019-05-30 21:17:58 -07:00
args.target = default_targets
2023-05-11 02:39:57 -07:00
header("* Building binaries: " + " ".join(args.target))
2024-05-08 21:50:59 -07:00
os.chdir(Path("native", "src"))
2022-06-30 14:50:21 -07:00
run_cargo_build(args)
2024-05-08 21:50:59 -07:00
os.chdir(Path("..", ".."))
2022-06-30 14:50:21 -07:00
dump_flag_header()
2023-05-11 02:39:57 -07:00
flag = ""
2023-08-08 01:05:32 -07:00
clean = False
2021-05-12 13:40:53 +08:00
if "magisk" in args.target:
flag += " B_MAGISK=1"
clean = True
2023-05-11 02:39:57 -07:00
if "magiskpolicy" in args.target:
flag += " B_POLICY=1"
2023-08-08 01:05:32 -07:00
clean = True
2022-03-17 03:15:39 -07:00
2023-05-11 02:39:57 -07:00
if "magiskinit" in args.target:
flag += " B_PRELOAD=1"
2023-05-11 02:39:57 -07:00
if "resetprop" in args.target:
flag += " B_PROP=1"
2020-01-21 00:48:52 +08:00
2021-01-18 04:25:26 -08:00
if flag:
run_ndk_build(args, flag)
2022-05-30 03:47:31 -07:00
2023-05-11 02:39:57 -07:00
flag = ""
2023-05-11 02:39:57 -07:00
if "magiskinit" in args.target:
2024-02-29 02:36:05 -08:00
# magiskinit embeds preload.so
dump_bin_header(args)
2023-05-11 02:39:57 -07:00
flag += " B_INIT=1"
2024-02-29 02:36:05 -08:00
if "magiskboot" in args.target:
flag += " B_BOOT=1"
if flag:
2024-02-29 02:36:05 -08:00
flag += " B_CRT0=1"
run_ndk_build(args, flag)
2023-08-08 01:05:32 -07:00
if clean:
clean_elf()
2024-05-08 21:50:59 -07:00
# BusyBox is built with different API level
2023-05-11 02:39:57 -07:00
if "busybox" in args.target:
run_ndk_build(args, "B_BB=1")
2021-05-12 13:40:53 +08:00
2023-05-11 21:01:04 -07:00
def find_jdk():
env = os.environ.copy()
if "ANDROID_STUDIO" in env:
studio = env["ANDROID_STUDIO"]
2024-05-08 21:50:59 -07:00
jbr = Path(studio, "jbr", "bin")
if not jbr.exists():
jbr = Path(studio, "Contents", "jbr", "Contents", "Home", "bin")
if jbr.exists():
2023-06-05 02:27:02 -07:00
env["PATH"] = f'{jbr}{os.pathsep}{env["PATH"]}'
2023-05-11 21:01:04 -07:00
no_jdk = False
try:
proc = subprocess.run(
2023-06-05 02:27:02 -07:00
"javac -version",
2023-05-11 21:01:04 -07:00
stdout=subprocess.DEVNULL,
stderr=subprocess.DEVNULL,
env=env,
2023-06-15 01:26:54 -07:00
shell=True,
2023-05-11 21:01:04 -07:00
)
no_jdk = proc.returncode != 0
except FileNotFoundError:
no_jdk = True
if no_jdk:
error(
"Please set Android Studio's path to environment variable ANDROID_STUDIO,\n"
+ "or install JDK 17 and make sure 'javac' is available in PATH"
)
return env
def build_apk(args, module):
2023-05-11 21:01:04 -07:00
env = find_jdk()
2023-05-11 02:39:57 -07:00
2023-05-11 21:01:04 -07:00
build_type = "Release" if args.release else "Debug"
2023-05-11 02:39:57 -07:00
proc = execv(
[
gradlew,
f"{module}:assemble{build_type}",
2024-05-08 21:50:59 -07:00
f"-PconfigPath={args.config.resolve()}",
2023-05-11 21:01:04 -07:00
],
env=env,
2023-05-11 02:39:57 -07:00
)
if proc.returncode != 0:
2023-05-11 02:39:57 -07:00
error(f"Build {module} failed!")
2017-06-03 22:04:22 +08:00
build_type = build_type.lower()
2024-07-04 00:21:34 -07:00
paths = module.split(":")
apk = f"{paths[-1]}-{build_type}.apk"
source = Path(*paths, "build", "outputs", "apk", build_type, apk)
2024-05-08 21:50:59 -07:00
target = config["outdir"] / apk
2021-05-13 00:21:04 -07:00
mv(source, target)
2024-05-08 21:50:59 -07:00
header(f"Output: {target}")
2018-08-10 05:54:26 +08:00
2018-08-20 12:02:38 +08:00
def build_app(args):
2023-05-11 02:39:57 -07:00
header("* Building the Magisk app")
2024-07-04 02:27:20 -07:00
build_apk(args, ":app:apk")
build_type = "release" if args.release else "debug"
# Rename apk-variant.apk to app-variant.apk
source = config["outdir"] / f"apk-{build_type}.apk"
target = config["outdir"] / f"app-{build_type}.apk"
mv(source, target)
2022-12-26 15:23:06 -08:00
# Stub building is directly integrated into the main app
# build process. Copy the stub APK into output directory.
source = Path("app", "core", "src", build_type, "assets", "stub.apk")
2024-07-04 02:27:20 -07:00
target = config["outdir"] / f"stub-{build_type}.apk"
2022-12-26 15:23:06 -08:00
cp(source, target)
def build_stub(args):
2023-05-11 02:39:57 -07:00
header("* Building the stub app")
2024-07-04 00:21:34 -07:00
build_apk(args, ":app:stub")
2022-12-26 15:23:06 -08:00
2018-05-27 14:55:24 +08:00
2017-06-03 20:19:01 +08:00
def cleanup(args):
2023-06-20 14:50:02 -07:00
support_targets = {"native", "cpp", "rust", "java"}
if args.target:
args.target = set(args.target) & support_targets
2023-06-20 14:50:02 -07:00
if "native" in args.target:
args.target.add("cpp")
args.target.add("rust")
else:
args.target = support_targets
2023-06-20 14:50:02 -07:00
if "cpp" in args.target:
header("* Cleaning C++")
2024-05-08 21:50:59 -07:00
rm_rf(Path("native", "libs"))
rm_rf(Path("native", "obj"))
rm_rf(Path("native", "out"))
2023-06-20 14:50:02 -07:00
if "rust" in args.target:
header("* Cleaning Rust")
2024-05-08 21:50:59 -07:00
rm_rf(Path("native", "src", "target"))
rm(Path("native", "src", "boot", "proto", "mod.rs"))
rm(Path("native", "src", "boot", "proto", "update_metadata.rs"))
2023-05-28 17:30:20 -07:00
for rs_gen in glob.glob("native/**/*-rs.*pp", recursive=True):
rm(rs_gen)
2023-05-11 02:39:57 -07:00
if "java" in args.target:
header("* Cleaning java")
execv(
2024-07-04 00:21:34 -07:00
[
gradlew,
2024-07-04 02:27:20 -07:00
":app:apk:clean",
2024-07-04 00:21:34 -07:00
":app:core:clean",
":app:shared:clean",
":app:stub:clean",
],
env=find_jdk(),
)
2018-05-13 03:04:40 +08:00
2020-04-03 03:33:39 -07:00
def setup_ndk(args):
2023-05-11 02:39:57 -07:00
ndk_ver = config["ondkVersion"]
2023-06-15 01:26:54 -07:00
url = f"https://github.com/topjohnwu/ondk/releases/download/{ndk_ver}/ondk-{ndk_ver}-{os_name}.tar.xz"
2023-05-11 02:39:57 -07:00
ndk_archive = url.split("/")[-1]
2024-05-08 21:50:59 -07:00
ondk_path = Path(ndk_root, f"ondk-{ndk_ver}")
2020-04-03 03:33:39 -07:00
2023-05-11 02:39:57 -07:00
header(f"* Downloading and extracting {ndk_archive}")
2023-06-15 05:57:19 -07:00
rm_rf(ondk_path)
2022-04-15 10:04:04 -07:00
with urllib.request.urlopen(url) as response:
2023-06-15 01:26:54 -07:00
with tarfile.open(mode="r|xz", fileobj=response) as tar:
2024-06-18 03:36:16 -07:00
if hasattr(tarfile, "data_filter"):
tar.extractall(ndk_root, filter="tar")
else:
tar.extractall(ndk_root)
2020-04-03 03:33:39 -07:00
rm_rf(ndk_path)
2023-06-15 05:57:19 -07:00
mv(ondk_path, ndk_path)
2020-04-03 03:33:39 -07:00
2023-05-02 16:28:02 -07:00
def push_files(args, script):
2023-05-11 02:39:57 -07:00
abi = cmd_out([adb_path, "shell", "getprop", "ro.product.cpu.abi"])
2024-05-08 21:50:59 -07:00
apk = Path(
config["outdir"], ("app-release.apk" if args.release else "app-debug.apk")
)
2023-05-02 16:28:02 -07:00
# Extract busybox from APK
2024-05-08 21:50:59 -07:00
busybox = Path(config["outdir"], "busybox")
2023-05-02 16:28:02 -07:00
with ZipFile(apk) as zf:
2023-05-11 02:39:57 -07:00
with zf.open(f"lib/{abi}/libbusybox.so") as libbb:
with open(busybox, "wb") as bb:
2023-05-02 16:28:02 -07:00
bb.write(libbb.read())
2023-05-02 16:28:02 -07:00
try:
2023-05-11 02:39:57 -07:00
proc = execv([adb_path, "push", busybox, script, "/data/local/tmp"])
2023-05-02 16:28:02 -07:00
if proc.returncode != 0:
2023-05-11 02:39:57 -07:00
error("adb push failed!")
2023-05-02 16:28:02 -07:00
finally:
rm_rf(busybox)
2023-05-11 02:39:57 -07:00
proc = execv([adb_path, "push", apk, "/data/local/tmp/magisk.apk"])
if proc.returncode != 0:
2023-05-11 02:39:57 -07:00
error("adb push failed!")
2023-05-02 16:28:02 -07:00
def setup_avd(args):
if not args.skip:
build_all(args)
2023-05-11 02:39:57 -07:00
header("* Setting up emulator")
2023-05-02 16:28:02 -07:00
2024-05-08 21:50:59 -07:00
push_files(args, Path("scripts", "avd_magisk.sh"))
2023-05-02 16:28:02 -07:00
2023-05-11 02:39:57 -07:00
proc = execv([adb_path, "shell", "sh", "/data/local/tmp/avd_magisk.sh"])
2022-01-19 05:12:11 -08:00
if proc.returncode != 0:
2023-05-11 02:39:57 -07:00
error("avd_magisk.sh failed!")
2022-01-19 05:12:11 -08:00
def patch_avd_file(args):
if not args.skip:
2022-05-19 22:54:49 -07:00
args.release = False
build_all(args)
2022-01-19 05:12:11 -08:00
args.target = Path(args.target)
src_file = f"/data/local/tmp/{args.target.name}"
out_file = f"{src_file}.magisk"
if args.output:
args.output = Path(args.output)
else:
args.output = args.target.parent / f"{args.target.name}.magisk"
2022-01-19 05:12:11 -08:00
header(f"* Patching {args.target.name}")
2022-01-19 05:12:11 -08:00
2024-05-08 21:50:59 -07:00
push_files(args, Path("scripts", "avd_patch.sh"))
proc = execv([adb_path, "push", args.target, "/data/local/tmp"])
2022-01-19 05:12:11 -08:00
if proc.returncode != 0:
2023-05-11 02:39:57 -07:00
error("adb push failed!")
2022-01-19 05:12:11 -08:00
proc = execv([adb_path, "shell", "sh", "/data/local/tmp/avd_patch.sh", src_file])
2022-01-19 05:12:11 -08:00
if proc.returncode != 0:
2023-05-11 02:39:57 -07:00
error("avd_patch.sh failed!")
2022-01-19 05:12:11 -08:00
proc = execv([adb_path, "pull", out_file, args.output])
if proc.returncode != 0:
2023-05-11 02:39:57 -07:00
error("adb pull failed!")
header(f"Output: {args.output}")
2018-08-10 05:54:26 +08:00
def build_all(args):
build_binary(args)
build_app(args)
2018-08-10 05:54:26 +08:00
2024-05-09 00:34:12 -07:00
def setup_rustup(args):
wrapper_dir = Path(args.wrapper_dir)
rm_rf(wrapper_dir)
wrapper_dir.mkdir(mode=0o755, parents=True, exist_ok=True)
if "CARGO_HOME" in os.environ:
cargo_home = Path(os.environ["CARGO_HOME"])
else:
cargo_home = Path.home() / ".cargo"
cargo_bin = cargo_home / "bin"
for src in cargo_bin.iterdir():
tgt = wrapper_dir / src.name
tgt.symlink_to(src)
# Build rustup_wrapper
wrapper_src = Path("tools", "rustup_wrapper")
cargo_toml = wrapper_src / "Cargo.toml"
execv(
[cargo, "build", "--release", f"--manifest-path={cargo_toml}"]
+ (["--verbose"] if args.verbose > 1 else [])
)
# Replace rustup with wrapper
wrapper = wrapper_dir / (f"rustup{EXE_EXT}")
wrapper.unlink(missing_ok=True)
cp(wrapper_src / "target" / "release" / (f"rustup_wrapper{EXE_EXT}"), wrapper)
2024-05-09 00:34:12 -07:00
wrapper.chmod(0o755)
2023-05-11 02:39:57 -07:00
parser = argparse.ArgumentParser(description="Magisk build script")
2020-12-26 16:04:41 -08:00
parser.set_defaults(func=lambda x: None)
2023-05-11 02:39:57 -07:00
parser.add_argument(
"-r", "--release", action="store_true", help="compile in release mode"
)
parser.add_argument("-v", "--verbose", action="count", default=0, help="verbose output")
2023-05-11 02:39:57 -07:00
parser.add_argument(
"-c",
"--config",
default="config.prop",
help="custom config file (default: config.prop)",
)
subparsers = parser.add_subparsers(title="actions")
all_parser = subparsers.add_parser("all", help="build everything")
2017-06-03 20:19:01 +08:00
all_parser.set_defaults(func=build_all)
2023-05-11 02:39:57 -07:00
binary_parser = subparsers.add_parser("binary", help="build binaries")
binary_parser.add_argument(
2023-05-11 02:39:57 -07:00
"target",
nargs="*",
help=f"{', '.join(support_targets)}, \
or empty for defaults ({', '.join(default_targets)})",
)
2017-06-03 20:19:01 +08:00
binary_parser.set_defaults(func=build_binary)
cargo_parser = subparsers.add_parser("cargo", help="run cargo with proper environment")
cargo_parser.add_argument("commands", nargs=argparse.REMAINDER)
cargo_parser.set_defaults(func=run_cargo_cmd)
2024-05-09 00:34:12 -07:00
rustup_parser = subparsers.add_parser("rustup", help="setup rustup wrapper")
rustup_parser.add_argument("wrapper_dir", help="path to setup rustup wrapper binaries")
rustup_parser.set_defaults(func=setup_rustup)
2023-05-11 02:39:57 -07:00
app_parser = subparsers.add_parser("app", help="build the Magisk app")
app_parser.set_defaults(func=build_app)
2017-06-03 20:19:01 +08:00
2023-05-11 02:39:57 -07:00
stub_parser = subparsers.add_parser("stub", help="build the stub app")
2022-12-26 15:23:06 -08:00
stub_parser.set_defaults(func=build_stub)
2023-05-11 02:39:57 -07:00
avd_parser = subparsers.add_parser("emulator", help="setup AVD for development")
avd_parser.add_argument(
"-s", "--skip", action="store_true", help="skip building binaries and the app"
)
avd_parser.set_defaults(func=setup_avd)
avd_patch_parser = subparsers.add_parser(
"avd_patch", help="patch AVD ramdisk.img or init_boot.img"
)
avd_patch_parser.add_argument("target", help="path to ramdisk.img or init_boot.img")
avd_patch_parser.add_argument("output", help="optional output file name", nargs="?")
2023-05-11 02:39:57 -07:00
avd_patch_parser.add_argument(
"-s", "--skip", action="store_true", help="skip building binaries and the app"
)
avd_patch_parser.set_defaults(func=patch_avd_file)
2023-05-11 02:39:57 -07:00
clean_parser = subparsers.add_parser("clean", help="cleanup")
clean_parser.add_argument(
2023-06-20 14:50:02 -07:00
"target", nargs="*", help="native, cpp, rust, java, or empty to clean all"
2023-05-11 02:39:57 -07:00
)
2017-06-03 20:19:01 +08:00
clean_parser.set_defaults(func=cleanup)
2023-05-11 02:39:57 -07:00
ndk_parser = subparsers.add_parser("ndk", help="setup Magisk NDK")
2020-04-03 03:33:39 -07:00
ndk_parser.set_defaults(func=setup_ndk)
2017-06-03 20:19:01 +08:00
if len(sys.argv) == 1:
parser.print_help()
sys.exit(1)
2017-06-03 20:19:01 +08:00
args = parser.parse_args()
load_config(args)
# Call corresponding functions
2017-06-03 20:19:01 +08:00
args.func(args)