271 lines
9.6 KiB
Python
271 lines
9.6 KiB
Python
#!/usr/bin/env python3
|
|
|
|
from __future__ import annotations
|
|
|
|
import argparse
|
|
import datetime as dt
|
|
import hashlib
|
|
import json
|
|
import re
|
|
import shutil
|
|
import subprocess
|
|
import sys
|
|
from pathlib import Path
|
|
|
|
|
|
ROOT = Path(__file__).resolve().parents[1]
|
|
PUBSPEC_PATH = ROOT / "pubspec.yaml"
|
|
|
|
|
|
def parse_pubspec_identity(pubspec_path: Path) -> tuple[str, str, str]:
|
|
content = pubspec_path.read_text(encoding="utf-8")
|
|
|
|
name_match = re.search(r"^name:\s*([^\s]+)\s*$", content, re.MULTILINE)
|
|
version_match = re.search(r"^version:\s*([^\s]+)\s*$", content, re.MULTILINE)
|
|
if not name_match or not version_match:
|
|
raise RuntimeError("Failed to read app name or version from pubspec.yaml")
|
|
|
|
package_name = name_match.group(1)
|
|
version = version_match.group(1)
|
|
if "+" in version:
|
|
build_name, build_number = version.split("+", 1)
|
|
else:
|
|
build_name, build_number = version, "1"
|
|
|
|
return package_name, build_name, build_number
|
|
|
|
|
|
def sha256_of(path: Path) -> str:
|
|
digest = hashlib.sha256()
|
|
with path.open("rb") as handle:
|
|
for chunk in iter(lambda: handle.read(1024 * 1024), b""):
|
|
digest.update(chunk)
|
|
return digest.hexdigest()
|
|
|
|
|
|
def run_command(command: list[str]) -> None:
|
|
print(f"$ {' '.join(command)}", flush=True)
|
|
subprocess.run(command, cwd=ROOT, check=True)
|
|
|
|
|
|
def ensure_clean_dir(path: Path) -> None:
|
|
if path.exists():
|
|
shutil.rmtree(path)
|
|
path.mkdir(parents=True, exist_ok=True)
|
|
|
|
|
|
def copy_file(src: Path, dest: Path) -> dict[str, object]:
|
|
dest.parent.mkdir(parents=True, exist_ok=True)
|
|
shutil.copy2(src, dest)
|
|
return {
|
|
"path": str(dest.relative_to(ROOT)),
|
|
"sizeBytes": dest.stat().st_size,
|
|
"sha256": sha256_of(dest),
|
|
}
|
|
|
|
|
|
def copy_tree(src: Path, dest: Path) -> None:
|
|
ensure_clean_dir(dest)
|
|
shutil.copytree(src, dest, dirs_exist_ok=True)
|
|
|
|
|
|
def append_common_flutter_args(command: list[str], args: argparse.Namespace) -> None:
|
|
command.extend(["--release", f"--target={args.target}"])
|
|
|
|
if args.flavor:
|
|
command.extend(["--flavor", args.flavor])
|
|
if args.build_name:
|
|
command.append(f"--build-name={args.build_name}")
|
|
if args.build_number:
|
|
command.append(f"--build-number={args.build_number}")
|
|
|
|
for item in args.dart_define:
|
|
command.extend(["--dart-define", item])
|
|
for item in args.dart_define_from_file:
|
|
command.extend(["--dart-define-from-file", item])
|
|
|
|
|
|
def build_android(args: argparse.Namespace, manifest: dict[str, object]) -> None:
|
|
android_symbols_dir = ROOT / "build" / "symbols" / "android"
|
|
android_output_dir = args.output_dir / "android"
|
|
|
|
appbundle_cmd = ["flutter", "build", "appbundle"]
|
|
append_common_flutter_args(appbundle_cmd, args)
|
|
appbundle_cmd.append(f"--split-debug-info={android_symbols_dir.relative_to(ROOT)}")
|
|
run_command(appbundle_cmd)
|
|
|
|
apk_cmd = [
|
|
"flutter",
|
|
"build",
|
|
"apk",
|
|
"--split-per-abi",
|
|
"--target-platform",
|
|
"android-arm,android-arm64,android-x64",
|
|
]
|
|
append_common_flutter_args(apk_cmd, args)
|
|
apk_cmd.append(f"--split-debug-info={android_symbols_dir.relative_to(ROOT)}")
|
|
run_command(apk_cmd)
|
|
|
|
google_play_dir = android_output_dir / "google-play"
|
|
local_dir = android_output_dir / "local"
|
|
testing_dir = android_output_dir / "testing"
|
|
|
|
artifact_prefix = f"{args.package_name}-v{args.build_name}-b{args.build_number}"
|
|
|
|
aab_src = ROOT / "build" / "app" / "outputs" / "bundle" / "release" / "app-release.aab"
|
|
arm64_src = ROOT / "build" / "app" / "outputs" / "flutter-apk" / "app-arm64-v8a-release.apk"
|
|
armv7_src = ROOT / "build" / "app" / "outputs" / "flutter-apk" / "app-armeabi-v7a-release.apk"
|
|
x64_src = ROOT / "build" / "app" / "outputs" / "flutter-apk" / "app-x86_64-release.apk"
|
|
|
|
artifacts = {
|
|
"googlePlayAab": copy_file(aab_src, google_play_dir / f"{artifact_prefix}-google-play.aab"),
|
|
"localArm64Apk": copy_file(arm64_src, local_dir / f"{artifact_prefix}-arm64-v8a.apk"),
|
|
"localArmeabiV7aApk": copy_file(armv7_src, local_dir / f"{artifact_prefix}-armeabi-v7a.apk"),
|
|
"testingX64Apk": copy_file(x64_src, testing_dir / f"{artifact_prefix}-x86_64-test.apk"),
|
|
}
|
|
|
|
if android_symbols_dir.exists():
|
|
copy_tree(android_symbols_dir, google_play_dir / "symbols")
|
|
artifacts["dartSymbolsDir"] = {
|
|
"path": str((google_play_dir / "symbols").relative_to(ROOT)),
|
|
"sizeBytes": sum(path.stat().st_size for path in (google_play_dir / "symbols").rglob("*") if path.is_file()),
|
|
}
|
|
|
|
manifest["android"] = artifacts
|
|
|
|
|
|
def build_ios(args: argparse.Namespace, manifest: dict[str, object]) -> None:
|
|
ios_symbols_dir = ROOT / "build" / "symbols" / "ios"
|
|
ios_output_dir = args.output_dir / "ios"
|
|
|
|
command = ["flutter", "build", "ipa"]
|
|
append_common_flutter_args(command, args)
|
|
command.append(f"--split-debug-info={ios_symbols_dir.relative_to(ROOT)}")
|
|
|
|
if args.ios_codesign:
|
|
command.extend(["--export-method", args.ios_export_method])
|
|
if args.ios_export_options_plist:
|
|
command.append(f"--export-options-plist={args.ios_export_options_plist}")
|
|
else:
|
|
command.append("--no-codesign")
|
|
|
|
run_command(command)
|
|
|
|
artifact_prefix = f"{args.package_name}-v{args.build_name}-b{args.build_number}"
|
|
artifacts: dict[str, object] = {}
|
|
|
|
archive_src = ROOT / "build" / "ios" / "archive" / "Runner.xcarchive"
|
|
ipa_candidates = sorted((ROOT / "build" / "ios" / "ipa").glob("*.ipa"))
|
|
|
|
if archive_src.exists():
|
|
copy_tree(archive_src, ios_output_dir / "archive" / f"{artifact_prefix}.xcarchive")
|
|
artifacts["archiveDir"] = {
|
|
"path": str((ios_output_dir / "archive" / f"{artifact_prefix}.xcarchive").relative_to(ROOT)),
|
|
"sizeBytes": sum(path.stat().st_size for path in (ios_output_dir / "archive" / f"{artifact_prefix}.xcarchive").rglob("*") if path.is_file()),
|
|
}
|
|
|
|
if ipa_candidates:
|
|
ipa_src = ipa_candidates[-1]
|
|
artifacts["ipa"] = copy_file(ipa_src, ios_output_dir / "ipa" / f"{artifact_prefix}.ipa")
|
|
|
|
if ios_symbols_dir.exists():
|
|
copy_tree(ios_symbols_dir, ios_output_dir / "symbols")
|
|
artifacts["dartSymbolsDir"] = {
|
|
"path": str((ios_output_dir / "symbols").relative_to(ROOT)),
|
|
"sizeBytes": sum(path.stat().st_size for path in (ios_output_dir / "symbols").rglob("*") if path.is_file()),
|
|
}
|
|
|
|
if not artifacts:
|
|
raise RuntimeError("iOS build finished but no archive or ipa artifact was found.")
|
|
|
|
manifest["ios"] = artifacts
|
|
|
|
|
|
def create_argument_parser() -> argparse.ArgumentParser:
|
|
package_name, build_name, build_number = parse_pubspec_identity(PUBSPEC_PATH)
|
|
timestamp = dt.datetime.now().strftime("%Y%m%d-%H%M%S")
|
|
default_output_dir = ROOT / "dist" / "release" / timestamp
|
|
|
|
parser = argparse.ArgumentParser(
|
|
description="Build release artifacts for Google Play, local Android distribution, and iOS."
|
|
)
|
|
parser.add_argument(
|
|
"--platform",
|
|
choices=["all", "android", "ios"],
|
|
default="all",
|
|
help="Select which platform artifacts to build.",
|
|
)
|
|
parser.add_argument("--target", default="lib/main.dart", help="Flutter entrypoint file.")
|
|
parser.add_argument("--flavor", help="Optional Flutter flavor.")
|
|
parser.add_argument("--build-name", default=build_name, help="Override version name.")
|
|
parser.add_argument("--build-number", default=build_number, help="Override version code / CFBundleVersion.")
|
|
parser.add_argument(
|
|
"--output-dir",
|
|
type=Path,
|
|
default=default_output_dir,
|
|
help="Directory used to store copied release artifacts.",
|
|
)
|
|
parser.add_argument(
|
|
"--dart-define",
|
|
action="append",
|
|
default=[],
|
|
help="Repeatable dart-define entries passed to flutter build.",
|
|
)
|
|
parser.add_argument(
|
|
"--dart-define-from-file",
|
|
action="append",
|
|
default=[],
|
|
help="Repeatable dart-define-from-file entries passed to flutter build.",
|
|
)
|
|
parser.add_argument(
|
|
"--ios-codesign",
|
|
action="store_true",
|
|
help="Enable codesign for flutter build ipa. Default keeps the iOS build unsigned.",
|
|
)
|
|
parser.add_argument(
|
|
"--ios-export-method",
|
|
choices=["app-store", "ad-hoc", "development", "enterprise"],
|
|
default="app-store",
|
|
help="Export method used when --ios-codesign is enabled.",
|
|
)
|
|
parser.add_argument(
|
|
"--ios-export-options-plist",
|
|
help="Optional ExportOptions.plist used when --ios-codesign is enabled.",
|
|
)
|
|
parser.set_defaults(package_name=package_name)
|
|
return parser
|
|
|
|
|
|
def main() -> int:
|
|
parser = create_argument_parser()
|
|
args = parser.parse_args()
|
|
args.output_dir = args.output_dir.resolve()
|
|
|
|
args.output_dir.mkdir(parents=True, exist_ok=True)
|
|
|
|
manifest: dict[str, object] = {
|
|
"generatedAt": dt.datetime.now().isoformat(timespec="seconds"),
|
|
"packageName": args.package_name,
|
|
"buildName": args.build_name,
|
|
"buildNumber": args.build_number,
|
|
"target": args.target,
|
|
"flavor": args.flavor,
|
|
"outputDir": str(args.output_dir.relative_to(ROOT)),
|
|
}
|
|
|
|
if args.platform in {"all", "android"}:
|
|
build_android(args, manifest)
|
|
if args.platform in {"all", "ios"}:
|
|
build_ios(args, manifest)
|
|
|
|
manifest_path = args.output_dir / "build_manifest.json"
|
|
manifest_path.write_text(json.dumps(manifest, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
|
|
|
|
print(f"Artifacts copied to: {args.output_dir}")
|
|
print(f"Manifest written to: {manifest_path}")
|
|
return 0
|
|
|
|
|
|
if __name__ == "__main__":
|
|
sys.exit(main())
|