Desktop: - Click a chat's picture or name (or right-click it in the list → Get info…) for any chat, not only groups. One person: their picture, name, number (and its label), which of your numbers you're texting from, Add to contacts… if they aren't one. The number no longer sits in the header. - Get info lists every photo and video in the chat as thumbnails, oldest first like the chat, scrolled to the newest. Each opens full size. - The full-size view steps through the chat's photos with ← and → (or the side buttons) and says "n of N · date", from Get info or from the chat. Its glyphs were light gray on the white buttons; now the usual glyph color. Both: voip.ms puts "MMS Received" as the text of a received picture that came without words. Nobody wrote it, so it's dropped as messages come in, and once from the ones already stored (only on messages with pictures, so someone typing "MMS received" still shows). Tried in a sandbox with made-up chats and generated pictures, driven over DevTools: the header, Get info for a person and a group, thumbnails, ←/→ through 14 pictures, Esc closing the picture then the dialog, and the v11 migration clearing a stored "MMS Received".
169 lines
6.7 KiB
Python
169 lines
6.7 KiB
Python
#!/usr/bin/env python3
|
|
"""Build the bubble Android app (for the Rabbit R1) without Gradle.
|
|
|
|
Same approach as andTunes (~/Documents/lintunes/andtunes/build.py): the app
|
|
links no libraries, so the five SDK steps run directly -- aapt2 compile/link,
|
|
javac against android.jar, R8, zipalign, apksigner.
|
|
|
|
python3 android/build.py # -> android/build/VoipMessages.apk
|
|
python3 android/build.py --ship # ... + copy to resources/android/ for the desktop installer
|
|
python3 android/build.py --dev --install
|
|
# a separate "bubble (dev)" app (its own
|
|
# package, its own data) for testing on
|
|
# the device without touching the real one
|
|
|
|
The APK is debuggable on purpose: the desktop installer copies the logins and
|
|
history into the app's private storage with `run-as`, which needs it.
|
|
Stdlib only.
|
|
"""
|
|
|
|
import argparse
|
|
import json
|
|
import os
|
|
import shutil
|
|
import subprocess
|
|
import sys
|
|
import zipfile
|
|
from pathlib import Path
|
|
|
|
VERSION_NAME = "0.7.3"
|
|
VERSION_CODE = 11
|
|
|
|
PACKAGE = "me.teafry.voipmessages"
|
|
DEV_PACKAGE = PACKAGE + ".dev"
|
|
MIN_SDK = 26
|
|
TARGET_SDK = 33
|
|
BUILD_TOOLS = "34.0.0"
|
|
|
|
HERE = Path(__file__).resolve().parent
|
|
SRC = HERE / "app" / "src" / "main"
|
|
OUT = HERE / "build"
|
|
APK_NAME = "VoipMessages.apk"
|
|
SHIP_TO = HERE.parent / "resources" / "android" / APK_NAME
|
|
|
|
# Committed on purpose, like andTunes': every build must be signed the same
|
|
# way or `adb install -r` refuses the update.
|
|
KEYSTORE = HERE / "voipmessages.keystore"
|
|
KEY_ALIAS = "voipmessages"
|
|
KEY_PASS = "voipmessages"
|
|
|
|
|
|
def _sdk() -> Path:
|
|
for env in ("ANDROID_HOME", "ANDROID_SDK_ROOT"):
|
|
if os.environ.get(env):
|
|
return Path(os.environ[env])
|
|
return Path.home() / "Android" / "Sdk"
|
|
|
|
|
|
def _java_home() -> Path:
|
|
if os.environ.get("JAVA_HOME"):
|
|
return Path(os.environ["JAVA_HOME"])
|
|
return Path("/usr/lib/jvm/java-21-openjdk")
|
|
|
|
|
|
def run(*cmd):
|
|
printable = " ".join(str(c) for c in cmd)
|
|
print(f" $ {printable[:160]}{'…' if len(printable) > 160 else ''}")
|
|
subprocess.run([str(c) for c in cmd], check=True)
|
|
|
|
|
|
def build(dev: bool) -> Path:
|
|
sdk = _sdk()
|
|
bt = sdk / "build-tools" / BUILD_TOOLS
|
|
android_jar = sdk / "platforms" / f"android-{TARGET_SDK}" / "android.jar"
|
|
jbin = _java_home() / "bin"
|
|
for need in (bt / "aapt2", android_jar, jbin / "javac"):
|
|
if not need.exists():
|
|
sys.exit(f"missing {need} -- see android/README.md")
|
|
|
|
out = OUT / ("dev" if dev else "release")
|
|
if out.exists():
|
|
shutil.rmtree(out)
|
|
gen, classes, dex = out / "gen", out / "classes", out / "dex"
|
|
for d in (gen, classes, dex):
|
|
d.mkdir(parents=True)
|
|
|
|
# aapt2 has no manifest placeholders: fill in ${applicationId} (the MMS
|
|
# file provider's authority must differ between the real and dev apps).
|
|
manifest = out / "AndroidManifest.xml"
|
|
manifest.write_text((SRC / "AndroidManifest.xml").read_text()
|
|
.replace("${applicationId}", DEV_PACKAGE if dev else PACKAGE))
|
|
|
|
print("resources")
|
|
run(bt / "aapt2", "compile", "--dir", SRC / "res", "-o", out / "res.zip")
|
|
link = [bt / "aapt2", "link", "-o", out / "base.apk",
|
|
"-I", android_jar, "--manifest", manifest,
|
|
"--java", gen, "--proguard", out / "aapt-rules.pro",
|
|
"--min-sdk-version", MIN_SDK, "--target-sdk-version", TARGET_SDK,
|
|
"--version-code", VERSION_CODE, "--version-name", VERSION_NAME,
|
|
"--debug-mode", "--auto-add-overlay"]
|
|
if dev:
|
|
# Same code, different app: its own package (so its own data) and label.
|
|
link += ["--rename-manifest-package", DEV_PACKAGE]
|
|
if dev:
|
|
# ...and its own name on the launcher (res-dev overrides app_name).
|
|
run(bt / "aapt2", "compile", "--dir", HERE / "res-dev", "-o", out / "res-dev.zip")
|
|
link += ["-R", out / "res-dev.zip"]
|
|
run(*link, out / "res.zip")
|
|
|
|
print("java")
|
|
sources = sorted(str(p) for p in (SRC / "java").rglob("*.java"))
|
|
sources += sorted(str(p) for p in gen.rglob("*.java"))
|
|
run(jbin / "javac", "--release", "11", "-Xlint:-options", "-nowarn",
|
|
"-encoding", "UTF-8", "-cp", android_jar, "-d", classes, *sources)
|
|
classes_jar = out / "classes.jar"
|
|
with zipfile.ZipFile(classes_jar, "w") as jar:
|
|
for f in classes.rglob("*.class"):
|
|
jar.write(f, f.relative_to(classes).as_posix())
|
|
|
|
print("r8")
|
|
run(jbin / "java", "-cp", bt / "lib" / "d8.jar", "com.android.tools.r8.R8",
|
|
"--release", "--min-api", MIN_SDK, "--lib", android_jar,
|
|
"--pg-conf", out / "aapt-rules.pro", "--pg-conf", HERE / "proguard.pro",
|
|
"--output", dex, classes_jar)
|
|
|
|
print("package")
|
|
unsigned = out / "unsigned.apk"
|
|
shutil.copyfile(out / "base.apk", unsigned)
|
|
with zipfile.ZipFile(unsigned, "a", zipfile.ZIP_DEFLATED) as apk:
|
|
apk.write(dex / "classes.dex", "classes.dex")
|
|
aligned = out / "aligned.apk"
|
|
run(bt / "zipalign", "-f", "-p", "4", unsigned, aligned)
|
|
final = out / (("Dev" if dev else "") + APK_NAME)
|
|
env_java = dict(os.environ, JAVA_HOME=str(_java_home()),
|
|
PATH=f"{jbin}:{os.environ.get('PATH', '')}")
|
|
print(f" $ apksigner sign … {final.name}")
|
|
subprocess.run([str(bt / "apksigner"), "sign", "--ks", str(KEYSTORE),
|
|
"--ks-key-alias", KEY_ALIAS,
|
|
"--ks-pass", f"pass:{KEY_PASS}",
|
|
"--key-pass", f"pass:{KEY_PASS}",
|
|
"--out", str(final), str(aligned)],
|
|
check=True, env=env_java)
|
|
print(f"built {final} ({final.stat().st_size // 1024} KiB, v{VERSION_NAME} / {VERSION_CODE})")
|
|
return final
|
|
|
|
|
|
def main():
|
|
ap = argparse.ArgumentParser(description=__doc__.split("\n")[0])
|
|
ap.add_argument("--dev", action="store_true", help="build the separate dev app (me.teafry.voipmessages.dev)")
|
|
ap.add_argument("--install", action="store_true", help="adb install -r the result and launch it")
|
|
ap.add_argument("--ship", action="store_true", help="copy the APK to resources/android/ for the desktop installer")
|
|
args = ap.parse_args()
|
|
if args.ship and args.dev:
|
|
sys.exit("--ship is for the real app, not --dev")
|
|
apk = build(args.dev)
|
|
if args.ship:
|
|
SHIP_TO.parent.mkdir(parents=True, exist_ok=True)
|
|
shutil.copyfile(apk, SHIP_TO)
|
|
SHIP_TO.with_suffix(".json").write_text(json.dumps(
|
|
{"version_name": VERSION_NAME, "version_code": VERSION_CODE, "package": PACKAGE}) + "\n")
|
|
print(f"shipped to {SHIP_TO}")
|
|
if args.install:
|
|
pkg = DEV_PACKAGE if args.dev else PACKAGE
|
|
run("adb", "install", "-r", "-g", apk)
|
|
run("adb", "shell", "am", "start", "-n", f"{pkg}/{PACKAGE}.MainActivity")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|