wehub-resource-sync
1945 lines
67 KiB
Python
1945 lines
67 KiB
Python
#!/usr/bin/env python3
|
||
"""
|
||
Prepare Android theme resources for mobile-gym (V2 - static assets).
|
||
|
||
Source (ignored by git): ./themes/
|
||
Destination (gitignored, served via /cdn/themes by vite/nginx, mirrored
|
||
to R2 at r2:mobilegym-data/themes for production CDN):
|
||
./mobilegym-data/themes/
|
||
|
||
Outputs:
|
||
- mobilegym-data/themes/manifest.json
|
||
- mobilegym-data/themes/{themeId}/preview/* (copied)
|
||
- mobilegym-data/themes/{themeId}/icons/{package}.png (extracted from icons.mrc)
|
||
- mobilegym-data/themes/{themeId}/statusbar/{name}.png (extracted & normalized)
|
||
- mobilegym-data/themes/{themeId}/shade/{active|inactive}.png (extracted & normalized)
|
||
- mobilegym-data/themes/{themeId}/wallpaper/default.* (best-effort)
|
||
- mobilegym-data/themes/{themeId}/components/{code}/... (selected app assets)
|
||
|
||
Note: manifest.json's `widgets[].variants[].preview` field is emitted as
|
||
`/themes/{themeId}/{clockCode}/preview.png` (legacy absolute prefix).
|
||
At runtime, os/wmr/WmrWidgetService.ts#getWidgetPreviewUrl detects
|
||
this prefix and rewrites it to the CDN URL via os/utils/cdn.ts. Kept
|
||
this way to avoid touching every existing manifest entry.
|
||
|
||
Run:
|
||
python3 scripts/dev/prepare-themes.py
|
||
"""
|
||
|
||
from __future__ import annotations
|
||
|
||
import argparse
|
||
import datetime as _dt
|
||
import json
|
||
import re
|
||
import shutil
|
||
import zipfile
|
||
import io
|
||
import math
|
||
from pathlib import Path
|
||
from typing import Iterable, Optional
|
||
|
||
try:
|
||
from PIL import Image # type: ignore
|
||
except Exception:
|
||
Image = None # Pillow is optional; battery sprite extraction will be skipped.
|
||
|
||
DEFAULT_THEME_IDS = [
|
||
# 纷紫
|
||
"0132f200-3467-4d4b-b8bd-1bd882145875",
|
||
# 夜半
|
||
"af0f7f90-04fb-417b-941e-ae7b549fe5e5",
|
||
# 小青山
|
||
"e80e4cfc-f4ba-4eef-a487-9a7008744873",
|
||
]
|
||
|
||
DEFAULT_DEFAULT_THEME_ID = "af0f7f90-04fb-417b-941e-ae7b549fe5e5"
|
||
|
||
|
||
def _now_iso() -> str:
|
||
return _dt.datetime.now(_dt.timezone.utc).isoformat()
|
||
|
||
|
||
def read_json(path: Path) -> dict:
|
||
return json.loads(path.read_text(encoding="utf-8"))
|
||
|
||
|
||
def ensure_dir(path: Path) -> None:
|
||
path.mkdir(parents=True, exist_ok=True)
|
||
|
||
|
||
def copy_tree(src_dir: Path, dst_dir: Path) -> None:
|
||
if not src_dir.exists():
|
||
return
|
||
ensure_dir(dst_dir.parent)
|
||
if dst_dir.exists():
|
||
shutil.rmtree(dst_dir)
|
||
shutil.copytree(src_dir, dst_dir)
|
||
|
||
|
||
def iter_subresources(theme_meta: dict) -> Iterable[tuple[str, str]]:
|
||
"""
|
||
Returns (resourceCode, localId) pairs from a theme meta (.mrm JSON).
|
||
"""
|
||
for sr in theme_meta.get("subResources", []) or []:
|
||
code = sr.get("resourceCode")
|
||
local_id = sr.get("localId")
|
||
if not code or not local_id:
|
||
continue
|
||
yield str(code), str(local_id)
|
||
|
||
_DENSITY_RANK = {
|
||
"xxxhdpi": 6,
|
||
"xxhdpi": 5,
|
||
"nxhdpi": 5, # some Android themes use nxhdpi
|
||
"xhdpi": 4,
|
||
"hdpi": 3,
|
||
"mdpi": 2,
|
||
"nodpi": 1,
|
||
"raw": 0,
|
||
}
|
||
|
||
|
||
def _density_score(path: str) -> int:
|
||
lower = path.lower()
|
||
for k, v in _DENSITY_RANK.items():
|
||
if k in lower:
|
||
return v
|
||
return 0
|
||
|
||
|
||
def _is_png(path: str) -> bool:
|
||
return path.lower().endswith(".png") or path.lower().endswith(".9.png")
|
||
|
||
|
||
def _read_text(path: Path) -> str:
|
||
return path.read_text(encoding="utf-8")
|
||
|
||
|
||
def parse_app_package_names(root: Path) -> list[str]:
|
||
"""
|
||
Parse packageName list from both `apps/*/manifest.ts` and `system/*/manifest.ts`.
|
||
Each app manifest declares `packageName: 'com.example.app'`.
|
||
"""
|
||
pkgs: set[str] = set()
|
||
for base_dir_name in ("apps", "system"):
|
||
base_dir = root / base_dir_name
|
||
if not base_dir.exists():
|
||
continue
|
||
for manifest_path in base_dir.glob("*/manifest.ts"):
|
||
try:
|
||
text = _read_text(manifest_path)
|
||
except Exception:
|
||
continue
|
||
hits = re.findall(r"packageName\s*:\s*['\"]([^'\"]+)['\"]", text)
|
||
for h in hits:
|
||
v = h.strip()
|
||
if v:
|
||
pkgs.add(v)
|
||
return sorted(pkgs)
|
||
|
||
|
||
def parse_settings_main_icon_names(root: Path) -> list[str]:
|
||
"""
|
||
Parse icon keys referenced by the Settings main page.
|
||
Settings 页面大配置已迁移到 JSON（见 system/Settings/data/pages.json）。
|
||
"""
|
||
settings_data_dir = root / "system/Settings/data"
|
||
if not settings_data_dir.exists():
|
||
return []
|
||
pages_path = settings_data_dir / "pages.json"
|
||
if not pages_path.exists():
|
||
return []
|
||
|
||
def collect_icons(obj: object, out: set[str]):
|
||
if isinstance(obj, dict):
|
||
for k, v in obj.items():
|
||
if k == "icon" and isinstance(v, str) and v.strip():
|
||
out.add(v.strip())
|
||
collect_icons(v, out)
|
||
return
|
||
if isinstance(obj, list):
|
||
for it in obj:
|
||
collect_icons(it, out)
|
||
|
||
names: set[str] = set()
|
||
try:
|
||
pages = json.loads(_read_text(pages_path))
|
||
collect_icons(pages.get("mainSections", []), names)
|
||
collect_icons(pages.get("pages", {}), names)
|
||
except Exception:
|
||
return []
|
||
|
||
overrides_path = settings_data_dir / "overrides.json"
|
||
if overrides_path.exists():
|
||
try:
|
||
overrides = json.loads(_read_text(overrides_path))
|
||
collect_icons(overrides, names)
|
||
except Exception:
|
||
pass
|
||
|
||
return sorted(names)
|
||
|
||
|
||
def extract_zip_entry(zf: zipfile.ZipFile, entry_name: str, dst: Path) -> bool:
|
||
try:
|
||
info = zf.getinfo(entry_name)
|
||
except KeyError:
|
||
return False
|
||
if info.is_dir():
|
||
return False
|
||
ensure_dir(dst.parent)
|
||
with zf.open(entry_name, "r") as src, dst.open("wb") as out:
|
||
shutil.copyfileobj(src, out)
|
||
return True
|
||
|
||
|
||
def _is_png_bytes(b: bytes) -> bool:
|
||
return b[:8] == b"\x89PNG\r\n\x1a\n"
|
||
|
||
def _is_fully_transparent_png_bytes(png_bytes: bytes) -> bool:
|
||
"""
|
||
some Android themes include 1px-wide fully-transparent placeholder PNGs.
|
||
On real devices these often behave like "no override" (fallback to default) or are invisible.
|
||
In our simulator, keeping them creates huge empty gaps in the status bar.
|
||
"""
|
||
if Image is None:
|
||
return False
|
||
if not _is_png_bytes(png_bytes):
|
||
return False
|
||
try:
|
||
im = Image.open(io.BytesIO(png_bytes)).convert("RGBA")
|
||
except Exception:
|
||
return False
|
||
return im.getchannel("A").getbbox() is None
|
||
|
||
STATUSBAR_TARGET_FILL = 0.82
|
||
STATUSBAR_BASE_SIDE = 56 # UI uses 14px, so 56px -> exact 1/4 scale
|
||
BATTERY_BASE_SIDE = 40 # UI uses 20px, so 40px -> exact 1/2 scale
|
||
|
||
|
||
def normalize_png_icon_to_square(
|
||
png_bytes: bytes,
|
||
*,
|
||
base_side: int = STATUSBAR_BASE_SIDE,
|
||
target_fill: float = STATUSBAR_TARGET_FILL,
|
||
) -> bytes | None:
|
||
"""
|
||
Normalize a PNG icon so that:
|
||
- transparent padding is trimmed (alpha bbox)
|
||
- the trimmed icon is centered on a square canvas with consistent fill ratio
|
||
|
||
This keeps visual icon sizes more consistent across different theme packs.
|
||
"""
|
||
if Image is None:
|
||
return None
|
||
if not _is_png_bytes(png_bytes):
|
||
return None
|
||
try:
|
||
im = Image.open(io.BytesIO(png_bytes)).convert("RGBA")
|
||
except Exception:
|
||
return None
|
||
|
||
bbox = im.getchannel("A").getbbox()
|
||
if bbox:
|
||
im = im.crop(bbox)
|
||
|
||
w, h = im.size
|
||
if w <= 0 or h <= 0:
|
||
return None
|
||
|
||
side = int(base_side) if isinstance(base_side, int) else STATUSBAR_BASE_SIDE
|
||
if side < 16 or side > 256:
|
||
side = STATUSBAR_BASE_SIDE
|
||
|
||
tf = float(target_fill)
|
||
if not (0.2 <= tf <= 0.98):
|
||
tf = STATUSBAR_TARGET_FILL
|
||
|
||
desired = max(1, int(round(side * tf)))
|
||
scale = desired / max(w, h)
|
||
|
||
new_w = max(1, int(round(w * scale)))
|
||
new_h = max(1, int(round(h * scale)))
|
||
|
||
if (new_w, new_h) != (w, h):
|
||
if hasattr(Image, "Resampling"):
|
||
resample_up = Image.Resampling.BICUBIC
|
||
resample_down = Image.Resampling.LANCZOS
|
||
else:
|
||
resample_up = Image.BICUBIC
|
||
resample_down = Image.LANCZOS
|
||
im = im.resize((new_w, new_h), resample=(resample_up if scale > 1 else resample_down))
|
||
|
||
canvas = Image.new("RGBA", (side, side), (0, 0, 0, 0))
|
||
ox = (side - im.size[0]) // 2
|
||
oy = (side - im.size[1]) // 2
|
||
canvas.paste(im, (ox, oy), im)
|
||
|
||
out = io.BytesIO()
|
||
canvas.save(out, format="PNG")
|
||
return out.getvalue()
|
||
|
||
|
||
def extract_battery_from_sprite_png(png_bytes: bytes) -> bytes | None:
|
||
"""
|
||
some Android themes store battery meter as a vertical sprite strip (very tall PNG).
|
||
We extract one representative frame (the most 'filled' one) into a normal-sized PNG.
|
||
|
||
Returns: cropped PNG bytes, or None if extraction is not possible.
|
||
"""
|
||
if Image is None:
|
||
return None
|
||
if not _is_png_bytes(png_bytes):
|
||
return None
|
||
try:
|
||
im = Image.open(io.BytesIO(png_bytes)).convert("RGBA")
|
||
except Exception:
|
||
return None
|
||
|
||
w, h = im.size
|
||
# Already icon-like -> keep as-is.
|
||
if h <= 256 and w <= 256 and h <= w * 4:
|
||
return png_bytes
|
||
|
||
alpha = im.getchannel("A")
|
||
pix = alpha.load()
|
||
|
||
# For each row: any non-transparent pixel?
|
||
has = [False] * h
|
||
for y in range(h):
|
||
any_nz = False
|
||
for x in range(w):
|
||
if pix[x, y] != 0:
|
||
any_nz = True
|
||
break
|
||
has[y] = any_nz
|
||
|
||
# Find contiguous content runs (candidate frames)
|
||
runs: list[tuple[int, int]] = []
|
||
y = 0
|
||
while y < h:
|
||
if not has[y]:
|
||
y += 1
|
||
continue
|
||
start = y
|
||
while y < h and has[y]:
|
||
y += 1
|
||
end = y # exclusive
|
||
if end - start >= 2:
|
||
runs.append((start, end))
|
||
|
||
if len(runs) <= 1:
|
||
return None
|
||
|
||
# Choose run with max non-transparent pixels (most filled)
|
||
best = None
|
||
best_score = -1
|
||
for start, end in runs:
|
||
crop_alpha = alpha.crop((0, start, w, end))
|
||
hist = crop_alpha.histogram()
|
||
# histogram[0] is count of zero-alpha pixels
|
||
nonzero = (end - start) * w - (hist[0] if hist else 0)
|
||
if nonzero > best_score:
|
||
best_score = nonzero
|
||
best = (start, end)
|
||
|
||
if not best:
|
||
return None
|
||
|
||
start, end = best
|
||
region = im.crop((0, start, w, end))
|
||
bbox = region.getchannel("A").getbbox()
|
||
if bbox:
|
||
region = region.crop(bbox)
|
||
|
||
# Sanity check: avoid still-sprite outputs
|
||
rw, rh = region.size
|
||
if rw <= 0 or rh <= 0:
|
||
return None
|
||
if rh > 256 or rw > 256:
|
||
return None
|
||
if rh > rw * 4:
|
||
return None
|
||
|
||
out = io.BytesIO()
|
||
region.save(out, format="PNG")
|
||
return out.getvalue()
|
||
|
||
|
||
def extract_battery_frames_from_sprite_png(png_bytes: bytes) -> list[bytes]:
|
||
"""
|
||
Extract ALL battery frames from a vertical sprite strip.
|
||
Returns normalized (BATTERY_BASE_SIDE x BATTERY_BASE_SIDE) PNG bytes in low->high order.
|
||
"""
|
||
if Image is None:
|
||
return []
|
||
if not _is_png_bytes(png_bytes):
|
||
return []
|
||
try:
|
||
im = Image.open(io.BytesIO(png_bytes)).convert("RGBA")
|
||
except Exception:
|
||
return []
|
||
|
||
w, h = im.size
|
||
# Single icon
|
||
if h <= 256 and w <= 256 and h <= w * 4:
|
||
normalized = normalize_png_icon_to_square(png_bytes, base_side=BATTERY_BASE_SIDE)
|
||
return [normalized or png_bytes]
|
||
|
||
alpha = im.getchannel("A")
|
||
pix = alpha.load()
|
||
|
||
has = [False] * h
|
||
for y in range(h):
|
||
any_nz = False
|
||
for x in range(w):
|
||
if pix[x, y] != 0:
|
||
any_nz = True
|
||
break
|
||
has[y] = any_nz
|
||
|
||
runs: list[tuple[int, int]] = []
|
||
y = 0
|
||
while y < h:
|
||
if not has[y]:
|
||
y += 1
|
||
continue
|
||
start = y
|
||
while y < h and has[y]:
|
||
y += 1
|
||
end = y
|
||
if end - start >= 2:
|
||
runs.append((start, end))
|
||
|
||
if not runs:
|
||
return []
|
||
|
||
frames: list[bytes] = []
|
||
scores: list[int] = []
|
||
for start, end in runs:
|
||
region = im.crop((0, start, w, end))
|
||
bbox = region.getchannel("A").getbbox()
|
||
if bbox:
|
||
region = region.crop(bbox)
|
||
|
||
raw = io.BytesIO()
|
||
region.save(raw, format="PNG")
|
||
raw_bytes = raw.getvalue()
|
||
|
||
normalized = normalize_png_icon_to_square(raw_bytes, base_side=BATTERY_BASE_SIDE)
|
||
out_bytes = normalized or raw_bytes
|
||
frames.append(out_bytes)
|
||
|
||
# Score for orientation: non-transparent alpha pixels
|
||
try:
|
||
rim = Image.open(io.BytesIO(out_bytes)).convert("RGBA")
|
||
a = rim.getchannel("A")
|
||
hist = a.histogram()
|
||
nonzero = rim.size[0] * rim.size[1] - (hist[0] if hist else 0)
|
||
scores.append(int(nonzero))
|
||
except Exception:
|
||
scores.append(0)
|
||
|
||
if not frames:
|
||
return []
|
||
|
||
# Most themes store low->high from top to bottom; ensure "full" is at the end.
|
||
max_i = max(range(len(scores)), key=lambda i: scores[i]) if scores else (len(frames) - 1)
|
||
if max_i < len(frames) // 2:
|
||
frames = list(reversed(frames))
|
||
|
||
return frames
|
||
|
||
|
||
def extract_statusbar_battery_icon(zf: zipfile.ZipFile, entry_name: str, dst: Path) -> bool:
|
||
"""
|
||
Extract a battery icon for our simulator. For tall sprite sheets, crop one frame.
|
||
"""
|
||
try:
|
||
data = zf.read(entry_name)
|
||
except KeyError:
|
||
return False
|
||
if not _is_png_bytes(data):
|
||
return False
|
||
|
||
cropped = extract_battery_from_sprite_png(data)
|
||
if not cropped:
|
||
# If we can't crop, skip battery to avoid rendering a thin line.
|
||
return False
|
||
|
||
ensure_dir(dst.parent)
|
||
normalized = normalize_png_icon_to_square(cropped, base_side=BATTERY_BASE_SIDE)
|
||
dst.write_bytes(normalized or cropped)
|
||
return True
|
||
|
||
|
||
def extract_statusbar_battery_assets(zf: zipfile.ZipFile, entry_name: str, out_dir: Path) -> dict | None:
|
||
"""
|
||
Export battery assets in a "real-device-like" way:
|
||
- statusbar/battery.png (full / representative frame)
|
||
- statusbar/battery_sprite.png (vertical strip of normalized frames)
|
||
Returns metadata for manifest: frames/sprite name/frame side.
|
||
"""
|
||
if Image is None:
|
||
return None
|
||
try:
|
||
data = zf.read(entry_name)
|
||
except KeyError:
|
||
return None
|
||
if not _is_png_bytes(data):
|
||
return None
|
||
|
||
frames = extract_battery_frames_from_sprite_png(data)
|
||
if not frames:
|
||
# Fallback: single-frame battery PNG (sprite extraction failed). We still
|
||
# advertise it as a 1-frame "sprite" so the front-end mask-image path
|
||
# tints it with state colors instead of routing to a separate <img>
|
||
# branch that ignores charging/saver state.
|
||
ok = extract_statusbar_battery_icon(zf, entry_name, out_dir / "battery.png")
|
||
return (
|
||
{"batteryFrames": 1, "batterySprite": "battery.png", "batteryFrameSide": BATTERY_BASE_SIDE}
|
||
if ok else None
|
||
)
|
||
|
||
ensure_dir(out_dir)
|
||
|
||
# battery.png = full (last frame)
|
||
(out_dir / "battery.png").write_bytes(frames[-1])
|
||
|
||
# battery_sprite.png = stacked frames
|
||
side = BATTERY_BASE_SIDE
|
||
sprite = Image.new("RGBA", (side, side * len(frames)), (0, 0, 0, 0))
|
||
for i, fb in enumerate(frames):
|
||
try:
|
||
fr = Image.open(io.BytesIO(fb)).convert("RGBA")
|
||
except Exception:
|
||
continue
|
||
if fr.size != (side, side):
|
||
fr = fr.resize((side, side))
|
||
sprite.paste(fr, (0, i * side), fr)
|
||
|
||
out = io.BytesIO()
|
||
sprite.save(out, format="PNG")
|
||
(out_dir / "battery_sprite.png").write_bytes(out.getvalue())
|
||
|
||
return {"batteryFrames": len(frames), "batterySprite": "battery_sprite.png", "batteryFrameSide": side}
|
||
|
||
|
||
def extract_statusbar_battery_variant_assets(
|
||
zf: zipfile.ZipFile,
|
||
entry_name: str,
|
||
out_dir: Path,
|
||
*,
|
||
prefix: str,
|
||
manifest_prefix: str,
|
||
) -> dict | None:
|
||
"""
|
||
Export a battery sprite variant (e.g. power-save style) using the same format as normal battery.
|
||
Writes:
|
||
- {prefix}.png
|
||
- {prefix}_sprite.png
|
||
Returns manifest fields:
|
||
- {manifest_prefix}Frames / {manifest_prefix}Sprite / {manifest_prefix}FrameSide
|
||
"""
|
||
if Image is None:
|
||
return None
|
||
try:
|
||
data = zf.read(entry_name)
|
||
except KeyError:
|
||
return None
|
||
if not _is_png_bytes(data):
|
||
return None
|
||
|
||
frames = extract_battery_frames_from_sprite_png(data)
|
||
if not frames:
|
||
return None
|
||
|
||
ensure_dir(out_dir)
|
||
|
||
# {prefix}.png = full (last frame)
|
||
(out_dir / f"{prefix}.png").write_bytes(frames[-1])
|
||
|
||
# {prefix}_sprite.png = stacked frames
|
||
side = BATTERY_BASE_SIDE
|
||
sprite = Image.new("RGBA", (side, side * len(frames)), (0, 0, 0, 0))
|
||
for i, fb in enumerate(frames):
|
||
try:
|
||
fr = Image.open(io.BytesIO(fb)).convert("RGBA")
|
||
except Exception:
|
||
continue
|
||
if fr.size != (side, side):
|
||
fr = fr.resize((side, side))
|
||
sprite.paste(fr, (0, i * side), fr)
|
||
|
||
out = io.BytesIO()
|
||
sprite.save(out, format="PNG")
|
||
sprite_name = f"{prefix}_sprite.png"
|
||
(out_dir / sprite_name).write_bytes(out.getvalue())
|
||
|
||
return {
|
||
f"{manifest_prefix}Frames": len(frames),
|
||
f"{manifest_prefix}Sprite": sprite_name,
|
||
f"{manifest_prefix}FrameSide": side,
|
||
}
|
||
|
||
|
||
def _png_pixel_identical(a_path: Path, b_path: Path) -> bool:
|
||
"""Return True iff two PNG files have the same RGBA pixel data."""
|
||
if Image is None or not a_path.exists() or not b_path.exists():
|
||
return False
|
||
try:
|
||
a = Image.open(a_path).convert("RGBA")
|
||
b = Image.open(b_path).convert("RGBA")
|
||
except Exception:
|
||
return False
|
||
if a.size != b.size:
|
||
return False
|
||
return a.tobytes() == b.tobytes()
|
||
|
||
|
||
def _png_has_visible_alpha(png_bytes: bytes, *, min_pixels: int = 50) -> bool:
|
||
"""Reject empty 1×N placeholder PNGs (some Android themes ship these for
|
||
`stat_sys_battery_charging.png` / `stat_sys_quick_charging.png`)."""
|
||
if Image is None or not _is_png_bytes(png_bytes):
|
||
return False
|
||
try:
|
||
im = Image.open(io.BytesIO(png_bytes)).convert("RGBA")
|
||
except Exception:
|
||
return False
|
||
w, h = im.size
|
||
if w < 4 or h < 4:
|
||
return False
|
||
visible = sum(1 for px in im.getdata() if px[3] > 50)
|
||
return visible >= min_pixels
|
||
|
||
|
||
def extract_battery_bolt_from_charge_png(png_bytes: bytes) -> bytes | None:
|
||
"""
|
||
Isolate the charging bolt from a `stat_sys_battery_charge.png` from some Android themes
|
||
sprite sheet.
|
||
|
||
The source PNG encodes battery body + bolt in DIFFERENT RGB colors:
|
||
- Body fill is rendered in a saturated color (e.g. green ~ (0,192,64))
|
||
- Bolt + outline is rendered in light gray (~ (224,224,224))
|
||
|
||
The bolt position is fixed across all frames (it doesn't move with the
|
||
fill level), so we collapse all frames into a single static overlay by
|
||
taking the alpha-max of the gray-only mask across every frame.
|
||
|
||
Returns a normalized BATTERY_BASE_SIDE × BATTERY_BASE_SIDE PNG, or None
|
||
if extraction failed.
|
||
"""
|
||
if Image is None or not _is_png_bytes(png_bytes):
|
||
return None
|
||
try:
|
||
im = Image.open(io.BytesIO(png_bytes)).convert("RGBA")
|
||
except Exception:
|
||
return None
|
||
|
||
W, H = im.size
|
||
if H <= W:
|
||
# Probably a single-frame placeholder, not a sprite sheet.
|
||
return None
|
||
|
||
alpha = im.getchannel("A")
|
||
runs: list[tuple[int, int]] = []
|
||
y = 0
|
||
while y < H:
|
||
# Quick row-has-pixel test
|
||
row_alpha = [alpha.getpixel((x, y)) for x in range(W)]
|
||
if all(a == 0 for a in row_alpha):
|
||
y += 1
|
||
continue
|
||
s = y
|
||
while y < H:
|
||
row_alpha = [alpha.getpixel((x, y)) for x in range(W)]
|
||
if all(a == 0 for a in row_alpha):
|
||
break
|
||
y += 1
|
||
runs.append((s, y))
|
||
|
||
if not runs:
|
||
return None
|
||
|
||
# Find the body color (most common saturated RGB) and bolt color (most
|
||
# common low-saturation/light RGB) by sampling a mid-fill frame.
|
||
sample_idx = min(len(runs) // 2, len(runs) - 1)
|
||
s, e = runs[sample_idx]
|
||
sample = im.crop((0, s, W, e))
|
||
from collections import Counter
|
||
body_votes: Counter = Counter()
|
||
bolt_votes: Counter = Counter()
|
||
for r, g, b, a in sample.getdata():
|
||
if a < 80:
|
||
continue
|
||
# Bolt = roughly neutral light (R≈G≈B and bright)
|
||
if min(r, g, b) > 192 and max(r, g, b) - min(r, g, b) < 32:
|
||
bolt_votes[(r // 16 * 16, g // 16 * 16, b // 16 * 16)] += 1
|
||
else:
|
||
body_votes[(r // 16 * 16, g // 16 * 16, b // 16 * 16)] += 1
|
||
|
||
if not bolt_votes:
|
||
return None
|
||
|
||
# Build per-frame bolt mask, take alpha-max across all frames.
|
||
union_mask = Image.new("L", (W, runs[0][1] - runs[0][0]), 0)
|
||
pixels = im.load()
|
||
for s, e in runs:
|
||
fh = e - s
|
||
if union_mask.size != (W, fh):
|
||
# Pad/crop to common frame size
|
||
new_union = Image.new("L", (W, fh), 0)
|
||
new_union.paste(union_mask)
|
||
union_mask = new_union
|
||
for y in range(fh):
|
||
for x in range(W):
|
||
r, g, b, a = pixels[x, s + y]
|
||
if a < 80:
|
||
continue
|
||
# Bolt criterion: near-neutral light pixel.
|
||
if min(r, g, b) > 192 and max(r, g, b) - min(r, g, b) < 32:
|
||
if a > union_mask.getpixel((x, y)):
|
||
union_mask.putpixel((x, y), a)
|
||
|
||
# Crop to bolt bbox and normalize to a square frame
|
||
bbox = union_mask.getbbox()
|
||
if not bbox:
|
||
return None
|
||
cropped_alpha = union_mask.crop(bbox)
|
||
bw, bh = cropped_alpha.size
|
||
|
||
# Composite into a transparent RGBA where the bolt is white (mask-image
|
||
# rendering ignores RGB anyway, only alpha matters).
|
||
bolt_rgba = Image.new("RGBA", (bw, bh), (255, 255, 255, 0))
|
||
bolt_alpha = cropped_alpha
|
||
bolt_rgba.putalpha(bolt_alpha)
|
||
|
||
# Center on a transparent BATTERY_BASE_SIDE square. We want the bolt to
|
||
# land where it sits on the source frame, but our normal battery sprite is
|
||
# also center-cropped/normalized — so center-align the bolt within the
|
||
# frame at the same scale ratio as the source frame side.
|
||
src_frame_side = max(runs[0][1] - runs[0][0], W)
|
||
scale = BATTERY_BASE_SIDE / src_frame_side
|
||
new_size = (max(int(round(bw * scale)), 1), max(int(round(bh * scale)), 1))
|
||
bolt_rgba = bolt_rgba.resize(new_size, Image.LANCZOS)
|
||
|
||
canvas = Image.new("RGBA", (BATTERY_BASE_SIDE, BATTERY_BASE_SIDE), (0, 0, 0, 0))
|
||
# Position: original bbox center mapped to canvas center
|
||
src_cx = (bbox[0] + bbox[2]) / 2
|
||
src_cy = (bbox[1] + bbox[3]) / 2
|
||
src_w = W
|
||
src_h = runs[0][1] - runs[0][0]
|
||
cx = src_cx / src_w * BATTERY_BASE_SIDE
|
||
cy = src_cy / src_h * BATTERY_BASE_SIDE
|
||
paste_x = int(round(cx - new_size[0] / 2))
|
||
paste_y = int(round(cy - new_size[1] / 2))
|
||
canvas.alpha_composite(bolt_rgba, (paste_x, paste_y))
|
||
|
||
out = io.BytesIO()
|
||
canvas.save(out, format="PNG")
|
||
return out.getvalue()
|
||
|
||
|
||
def extract_statusbar_icon_normalized(zf: zipfile.ZipFile, entry_name: str, dst: Path) -> bool:
|
||
"""
|
||
Extract and normalize a regular statusbar icon (wifi/signal/bluetooth).
|
||
"""
|
||
try:
|
||
data = zf.read(entry_name)
|
||
except KeyError:
|
||
return False
|
||
if not _is_png_bytes(data):
|
||
return False
|
||
if _is_fully_transparent_png_bytes(data):
|
||
return False
|
||
normalized = normalize_png_icon_to_square(data)
|
||
ensure_dir(dst.parent)
|
||
dst.write_bytes(normalized or data)
|
||
return True
|
||
|
||
|
||
def extract_statusbar_icon_normalized_to_square(
|
||
zf: zipfile.ZipFile,
|
||
entry_name: str,
|
||
dst: Path,
|
||
*,
|
||
base_side: int,
|
||
) -> bool:
|
||
"""
|
||
Like `extract_statusbar_icon_normalized`, but allows custom square side.
|
||
Useful for overlays that must align with battery sprite.
|
||
"""
|
||
try:
|
||
data = zf.read(entry_name)
|
||
except KeyError:
|
||
return False
|
||
if not _is_png_bytes(data):
|
||
return False
|
||
if _is_fully_transparent_png_bytes(data):
|
||
return False
|
||
normalized = normalize_png_icon_to_square(data, base_side=base_side)
|
||
ensure_dir(dst.parent)
|
||
dst.write_bytes(normalized or data)
|
||
return True
|
||
|
||
|
||
def best_path_for_basename(
|
||
all_paths: list[str],
|
||
basenames: list[str],
|
||
*,
|
||
prefer_nightmode: Optional[bool] = None,
|
||
prefer_res_root: bool = True,
|
||
avoid_ninepatch: bool = False,
|
||
) -> Optional[str]:
|
||
"""
|
||
Choose best matching zip entry path for the first matching basename list.
|
||
"""
|
||
want = set(basenames)
|
||
candidates = [p for p in all_paths if Path(p).name in want and _is_png(p)]
|
||
if avoid_ninepatch:
|
||
candidates = [p for p in candidates if not p.lower().endswith(".9.png")]
|
||
if not candidates:
|
||
return None
|
||
|
||
def score(p: str) -> tuple[int, int, int, int]:
|
||
lower = p.lower()
|
||
s = 0
|
||
# Prefer `res/...` (non-nightmode) or `nightmode/res/...` depending on context
|
||
if prefer_nightmode is True and lower.startswith("nightmode/"):
|
||
s += 50
|
||
if prefer_nightmode is False and not lower.startswith("nightmode/"):
|
||
s += 50
|
||
if prefer_res_root and lower.startswith("res/"):
|
||
s += 10
|
||
# Density
|
||
s += _density_score(p) * 5
|
||
# Avoid _darkmode variants when we are going to tint anyway
|
||
if "_darkmode" in lower:
|
||
s -= 2
|
||
# Prefer drawable over raw unless explicitly targeting raw
|
||
if "/drawable" in lower:
|
||
s += 1
|
||
return (s, _density_score(p), -len(p), 0)
|
||
|
||
candidates.sort(key=score, reverse=True)
|
||
return candidates[0]
|
||
|
||
|
||
def find_statusbar_misc_icons(pngs: list[str]) -> dict[str, str]:
|
||
"""
|
||
Find common statusbar "extra" icons with stable canonical names.
|
||
Returned keys are our output basenames (without .png).
|
||
"""
|
||
mapping: dict[str, list[str]] = {
|
||
# Flight / SIM / connectivity
|
||
"airplane": [
|
||
"stat_sys_signal_flightmode.png",
|
||
"stat_sys_signal_flightmode_darkmode.png",
|
||
"stat_sys_airplane_mode.png",
|
||
"stat_sys_airplane_mode_darkmode.png",
|
||
],
|
||
"no_sim": ["stat_sys_no_sim.png", "stat_sys_no_sim_darkmode.png"],
|
||
"vpn": ["stat_sys_vpn.png", "stat_sys_vpn_darkmode.png"],
|
||
# Alerts
|
||
"alarm": ["stat_sys_alarm.png", "stat_sys_alarm_darkmode.png"],
|
||
"silent": ["stat_sys_ringer_silent.png", "stat_sys_ringer_silent_darkmode.png"],
|
||
# Accessories
|
||
"headset": [
|
||
"stat_sys_headset.png",
|
||
"stat_sys_headset_darkmode.png",
|
||
"stat_sys_headset_without_mic.png",
|
||
"stat_sys_headset_without_mic_darkmode.png",
|
||
],
|
||
# Misc toggles
|
||
"nfc": [
|
||
"stat_sys_nfc.png",
|
||
"stat_sys_nfc_darkmode.png",
|
||
"stat_sys_data_nfc.png",
|
||
"stat_sys_data_nfc_darkmode.png",
|
||
],
|
||
# NOTE: quick_charging intentionally omitted — in some Android theme bundles
|
||
# the file is typically a 1×60 empty placeholder (the charging bolt is
|
||
# baked into the `stat_sys_battery_charge` sprite, with color applied at
|
||
# runtime). We render fast-charging via a tint in SystemShell.
|
||
# Null / no-service variants
|
||
"signal_null": [
|
||
"stat_sys_signal_null.png",
|
||
"stat_sys_signal_null_darkmode.png",
|
||
"stat_sys_signal_null_half.png",
|
||
"stat_sys_signal_null_half_darkmode.png",
|
||
],
|
||
"wifi_null": [
|
||
"stat_sys_wifi_signal_null.png",
|
||
"stat_sys_wifi_signal_null_darkmode.png",
|
||
],
|
||
}
|
||
|
||
out: dict[str, str] = {}
|
||
for key, basenames in mapping.items():
|
||
p = best_path_for_basename(pngs, basenames, prefer_nightmode=False)
|
||
if p:
|
||
out[key] = p
|
||
return out
|
||
|
||
|
||
def find_statusbar_data_type_icons(pngs: list[str]) -> dict[str, str]:
|
||
"""
|
||
Find mobile data type icons (4G/5G/LTE/3G/E...), returned as {type: entry_path}.
|
||
We export them as `data_{type}.png`.
|
||
"""
|
||
mapping: dict[str, list[str]] = {
|
||
"5g": ["stat_sys_signal_5g.png", "stat_sys_data_5g.png", "stat_sys_5g.png"],
|
||
"4g": ["stat_sys_signal_4g.png", "stat_sys_data_4g.png", "stat_sys_4g.png"],
|
||
"4g_lte": ["stat_sys_signal_4g_lte.png", "stat_sys_data_4g_lte.png"],
|
||
"lte": ["stat_sys_signal_lte.png", "stat_sys_data_lte.png", "stat_sys_lte.png"],
|
||
"3g": ["stat_sys_signal_3g.png", "stat_sys_data_3g.png", "stat_sys_3g.png"],
|
||
"e": ["stat_sys_signal_e.png", "stat_sys_data_e.png", "stat_sys_e.png"],
|
||
}
|
||
|
||
out: dict[str, str] = {}
|
||
for t, basenames in mapping.items():
|
||
p = best_path_for_basename(pngs, basenames, prefer_nightmode=False)
|
||
if p:
|
||
out[t] = p
|
||
return out
|
||
|
||
|
||
def find_statusbar_icons(zf: zipfile.ZipFile) -> dict[str, str]:
|
||
names = zf.namelist()
|
||
pngs = [n for n in names if _is_png(n)]
|
||
|
||
# Prefer non-nightmode for status bar; we tint icons in runtime anyway.
|
||
out: dict[str, str] = {}
|
||
|
||
wifi = best_path_for_basename(
|
||
pngs,
|
||
["stat_sys_wifi_signal_4.png", "stat_sys_wifi_signal_3.png", "stat_sys_wifi_signal_2.png"],
|
||
prefer_nightmode=False,
|
||
)
|
||
if wifi:
|
||
out["wifi"] = wifi
|
||
|
||
signal = best_path_for_basename(
|
||
pngs,
|
||
["stat_sys_signal_4.png", "stat_sys_signal_5.png", "stat_sys_signal_3.png"],
|
||
prefer_nightmode=False,
|
||
)
|
||
if signal:
|
||
out["signal"] = signal
|
||
|
||
bt = best_path_for_basename(
|
||
pngs,
|
||
["stat_sys_data_bluetooth.png", "stat_sys_data_bluetooth_connected.png"],
|
||
prefer_nightmode=False,
|
||
)
|
||
if bt:
|
||
out["bluetooth"] = bt
|
||
|
||
# Battery: many Android themes use `res/raw-*/stat_sys_battery.png`
|
||
battery = best_path_for_basename(
|
||
pngs,
|
||
[
|
||
"stat_sys_battery_100.png",
|
||
"stat_sys_battery_full.png",
|
||
"stat_sys_battery.png",
|
||
],
|
||
prefer_nightmode=False,
|
||
)
|
||
if battery:
|
||
out["battery"] = battery
|
||
|
||
return out
|
||
|
||
|
||
def extract_statusbar_wifi_levels(zf: zipfile.ZipFile, out_dir: Path) -> int:
|
||
"""
|
||
Export Wi-Fi signal icons by level: wifi_0..4.png (+ wifi.png alias).
|
||
Returns number of levels exported (0 if not possible).
|
||
"""
|
||
names = zf.namelist()
|
||
pngs = [n for n in names if _is_png(n)]
|
||
levels = [0, 1, 2, 3, 4]
|
||
|
||
found: dict[int, str] = {}
|
||
for lvl in levels:
|
||
entry = best_path_for_basename(
|
||
pngs,
|
||
[f"stat_sys_wifi_signal_{lvl}.png", f"stat_sys_wifi_signal_{lvl}_darkmode.png"],
|
||
prefer_nightmode=False,
|
||
)
|
||
if entry:
|
||
found[lvl] = entry
|
||
|
||
# Fallback: use the highest available level
|
||
fallback = None
|
||
for lvl in reversed(levels):
|
||
p = found.get(lvl)
|
||
if not p:
|
||
continue
|
||
try:
|
||
if not _is_fully_transparent_png_bytes(zf.read(p)):
|
||
fallback = p
|
||
break
|
||
except Exception:
|
||
continue
|
||
if not fallback:
|
||
# any non-transparent
|
||
for p in found.values():
|
||
try:
|
||
if not _is_fully_transparent_png_bytes(zf.read(p)):
|
||
fallback = p
|
||
break
|
||
except Exception:
|
||
continue
|
||
if not fallback:
|
||
return 0
|
||
|
||
ensure_dir(out_dir)
|
||
for lvl in levels:
|
||
entry = found.get(lvl)
|
||
if entry:
|
||
ok = extract_statusbar_icon_normalized(zf, entry, out_dir / f"wifi_{lvl}.png")
|
||
if not ok:
|
||
ok = extract_statusbar_icon_normalized(zf, fallback, out_dir / f"wifi_{lvl}.png")
|
||
else:
|
||
ok = extract_statusbar_icon_normalized(zf, fallback, out_dir / f"wifi_{lvl}.png")
|
||
if not ok:
|
||
return 0
|
||
|
||
# wifi.png = full level
|
||
try:
|
||
shutil.copy2(out_dir / "wifi_4.png", out_dir / "wifi.png")
|
||
except Exception:
|
||
pass
|
||
return len(levels)
|
||
|
||
|
||
def extract_statusbar_signal_levels(zf: zipfile.ZipFile, out_dir: Path) -> int:
|
||
"""
|
||
Export cellular signal icons by level: signal_0..5.png (+ signal.png alias).
|
||
Returns number of levels exported (0 if not possible).
|
||
"""
|
||
names = zf.namelist()
|
||
pngs = [n for n in names if _is_png(n)]
|
||
levels = [0, 1, 2, 3, 4, 5]
|
||
|
||
found: dict[int, str] = {}
|
||
for lvl in levels:
|
||
entry = best_path_for_basename(
|
||
pngs,
|
||
[f"stat_sys_signal_{lvl}.png", f"stat_sys_signal_{lvl}_darkmode.png"],
|
||
prefer_nightmode=False,
|
||
)
|
||
if entry:
|
||
found[lvl] = entry
|
||
|
||
fallback = None
|
||
for lvl in reversed(levels):
|
||
p = found.get(lvl)
|
||
if not p:
|
||
continue
|
||
try:
|
||
if not _is_fully_transparent_png_bytes(zf.read(p)):
|
||
fallback = p
|
||
break
|
||
except Exception:
|
||
continue
|
||
if not fallback:
|
||
for p in found.values():
|
||
try:
|
||
if not _is_fully_transparent_png_bytes(zf.read(p)):
|
||
fallback = p
|
||
break
|
||
except Exception:
|
||
continue
|
||
if not fallback:
|
||
return 0
|
||
|
||
ensure_dir(out_dir)
|
||
for lvl in levels:
|
||
entry = found.get(lvl)
|
||
if entry:
|
||
ok = extract_statusbar_icon_normalized(zf, entry, out_dir / f"signal_{lvl}.png")
|
||
if not ok:
|
||
ok = extract_statusbar_icon_normalized(zf, fallback, out_dir / f"signal_{lvl}.png")
|
||
else:
|
||
ok = extract_statusbar_icon_normalized(zf, fallback, out_dir / f"signal_{lvl}.png")
|
||
if not ok:
|
||
return 0
|
||
|
||
# signal.png = full level (prefer 5)
|
||
try:
|
||
src = out_dir / ("signal_5.png" if (out_dir / "signal_5.png").exists() else "signal_4.png")
|
||
shutil.copy2(src, out_dir / "signal.png")
|
||
except Exception:
|
||
pass
|
||
return len(levels)
|
||
|
||
|
||
def find_shade_backgrounds(zf: zipfile.ZipFile) -> dict[str, str]:
|
||
names = zf.namelist()
|
||
pngs = [n for n in names if _is_png(n)]
|
||
|
||
# Control center in this project is dark-blur; prefer nightmode assets.
|
||
active = best_path_for_basename(
|
||
pngs,
|
||
[
|
||
"ic_cc_qs_bg_active_normal.png",
|
||
"qs_tile_bg_on.png",
|
||
"qs_background_enabled.png",
|
||
"ic_qs_bg_enabled.png",
|
||
],
|
||
prefer_nightmode=True,
|
||
avoid_ninepatch=True,
|
||
)
|
||
inactive = best_path_for_basename(
|
||
pngs,
|
||
[
|
||
"ic_cc_qs_bg_inactive.png",
|
||
"qs_tile_bg_off.png",
|
||
"qs_background_disabled.png",
|
||
"ic_qs_bg_disabled.png",
|
||
],
|
||
prefer_nightmode=True,
|
||
avoid_ninepatch=True,
|
||
)
|
||
out: dict[str, str] = {}
|
||
if active:
|
||
out["active"] = active
|
||
if inactive:
|
||
out["inactive"] = inactive
|
||
return out
|
||
|
||
|
||
def extract_app_icons_from_icons_mrc(
|
||
mrc_path: Path,
|
||
out_dir: Path,
|
||
package_names: list[str],
|
||
) -> list[str]:
|
||
if not mrc_path.exists():
|
||
return []
|
||
extracted: list[str] = []
|
||
with zipfile.ZipFile(mrc_path, "r") as zf:
|
||
names = [n for n in zf.namelist() if _is_png(n)]
|
||
# Build basename->best path mapping once
|
||
best_by_key: dict[str, str] = {}
|
||
for n in names:
|
||
if not n.startswith("res/") and not n.startswith("nightmode/"):
|
||
continue
|
||
base = Path(n).name
|
||
if not base.lower().endswith(".png"):
|
||
continue
|
||
key = base[:-4]
|
||
prev = best_by_key.get(key)
|
||
if prev is None:
|
||
best_by_key[key] = n
|
||
else:
|
||
if _density_score(n) > _density_score(prev):
|
||
best_by_key[key] = n
|
||
|
||
ensure_dir(out_dir)
|
||
for pkg in package_names:
|
||
entry = best_by_key.get(pkg)
|
||
if not entry:
|
||
# Fallback: common path
|
||
fallback = f"res/drawable-xxhdpi/{pkg}.png"
|
||
entry = fallback if fallback in names else None
|
||
if not entry:
|
||
continue
|
||
dst = out_dir / f"{pkg}.png"
|
||
if extract_zip_entry(zf, entry, dst):
|
||
extracted.append(pkg)
|
||
return extracted
|
||
|
||
|
||
def extract_selected_component_assets(
|
||
mrc_path: Path,
|
||
out_component_dir: Path,
|
||
asset_names: list[str],
|
||
*,
|
||
prefer_nightmode: bool,
|
||
) -> list[str]:
|
||
if not mrc_path.exists() or not asset_names:
|
||
return []
|
||
extracted: list[str] = []
|
||
with zipfile.ZipFile(mrc_path, "r") as zf:
|
||
names = zf.namelist()
|
||
pngs = [n for n in names if _is_png(n)]
|
||
|
||
for a in asset_names:
|
||
# Prefer exact drawable hit first (xxhdpi)
|
||
preferred_basenames = [f"{a}.png", f"{a}.9.png"]
|
||
chosen = best_path_for_basename(
|
||
pngs,
|
||
preferred_basenames,
|
||
prefer_nightmode=prefer_nightmode,
|
||
prefer_res_root=True,
|
||
)
|
||
if not chosen:
|
||
continue
|
||
dst = out_component_dir / chosen
|
||
if extract_zip_entry(zf, chosen, dst):
|
||
extracted.append(a)
|
||
return extracted
|
||
|
||
|
||
CLOCK_WIDGET_CODES = ["clock_2x4", "clock_3x4"]
|
||
CLOCK_SPAN: dict[str, tuple[int, int]] = {
|
||
"clock_2x4": (4, 2),
|
||
"clock_3x4": (4, 3),
|
||
}
|
||
VARIANT_SPEC: dict[str, tuple[int, int]] = {
|
||
"widget_2x2": (2, 2),
|
||
"widget_4x2": (4, 2),
|
||
"widget_3x4": (3, 4),
|
||
"widget_4x4": (4, 4),
|
||
}
|
||
|
||
|
||
def extract_clock_widget_mrc(mrc_path: Path, out_dir: Path) -> bool:
|
||
"""
|
||
Extract a clock widget .mrc (zip) into out_dir, preserving internal paths.
|
||
Returns True if at least one file was extracted.
|
||
"""
|
||
if not mrc_path.exists():
|
||
return False
|
||
try:
|
||
with zipfile.ZipFile(mrc_path, "r") as zf:
|
||
ensure_dir(out_dir)
|
||
count = 0
|
||
for info in zf.infolist():
|
||
if info.is_dir():
|
||
continue
|
||
dst = out_dir / info.filename
|
||
ensure_dir(dst.parent)
|
||
with zf.open(info, "r") as src, dst.open("wb") as out:
|
||
shutil.copyfileobj(src, out)
|
||
count += 1
|
||
return count > 0
|
||
except zipfile.BadZipFile:
|
||
return False
|
||
|
||
|
||
def extract_standalone_wmr_widget(
|
||
widget_dir: Path,
|
||
dest_root: Path,
|
||
) -> Optional[dict]:
|
||
"""
|
||
Extract a standalone WMR widget from external themes/maml_widget/<id>/ resources.
|
||
Returns a manifest entry dict, or None on failure.
|
||
"""
|
||
meta_path = widget_dir / "meta.json"
|
||
if not meta_path.exists():
|
||
return None
|
||
try:
|
||
meta = json.loads(meta_path.read_text(encoding="utf-8"))
|
||
except Exception:
|
||
return None
|
||
|
||
widget_id = meta.get("id") or widget_dir.name
|
||
title = pick_locale_field(meta, "titleMap") or meta.get("title") or widget_id
|
||
author = (
|
||
pick_locale_field(meta, "authorMap")
|
||
or pick_locale_field(meta, "designerMap")
|
||
or ""
|
||
)
|
||
description = pick_locale_field(meta, "descMap") or meta.get("desc") or ""
|
||
|
||
out_dir = dest_root / widget_id
|
||
if out_dir.exists():
|
||
shutil.rmtree(out_dir)
|
||
ensure_dir(out_dir)
|
||
|
||
# Copy previews
|
||
preview_src = widget_dir / "preview"
|
||
if preview_src.is_dir():
|
||
copy_tree(preview_src, out_dir / "preview")
|
||
|
||
# Extract each variant zip
|
||
variants: list[dict] = []
|
||
for variant_name, (sx, sy) in VARIANT_SPEC.items():
|
||
variant_file = widget_dir / variant_name
|
||
if not variant_file.exists():
|
||
continue
|
||
variant_out = out_dir / variant_name
|
||
try:
|
||
with zipfile.ZipFile(variant_file, "r") as zf:
|
||
ensure_dir(variant_out)
|
||
count = 0
|
||
for info in zf.infolist():
|
||
if info.is_dir():
|
||
continue
|
||
dst = variant_out / info.filename
|
||
ensure_dir(dst.parent)
|
||
with zf.open(info, "r") as src, dst.open("wb") as out_f:
|
||
shutil.copyfileobj(src, out_f)
|
||
count += 1
|
||
if count == 0:
|
||
continue
|
||
except zipfile.BadZipFile:
|
||
continue
|
||
|
||
# Preview image path (relative to widget root)
|
||
preview_file = f"preview/{variant_name}.png"
|
||
if not (out_dir / preview_file).exists():
|
||
preview_file = ""
|
||
|
||
variants.append({
|
||
"entry": variant_name,
|
||
"spanX": sx,
|
||
"spanY": sy,
|
||
"preview": preview_file,
|
||
})
|
||
|
||
if not variants:
|
||
# No usable variants; clean up
|
||
if out_dir.exists():
|
||
shutil.rmtree(out_dir)
|
||
return None
|
||
|
||
# Collect all preview filenames for the manifest entry
|
||
previews: list[str] = []
|
||
preview_out = out_dir / "preview"
|
||
if preview_out.is_dir():
|
||
previews = sorted(p.name for p in preview_out.iterdir() if p.is_file())
|
||
|
||
return {
|
||
"id": widget_id,
|
||
"title": title,
|
||
"author": author,
|
||
"description": description,
|
||
"type": "widget",
|
||
"previews": previews,
|
||
"variants": variants,
|
||
}
|
||
|
||
|
||
def extract_wallpaper(mrc_path: Path, out_dir: Path) -> Optional[str]:
|
||
if not mrc_path.exists():
|
||
return None
|
||
ensure_dir(out_dir)
|
||
# Wallpaper packages vary; best-effort:
|
||
try:
|
||
with zipfile.ZipFile(mrc_path, "r") as zf:
|
||
infos = [i for i in zf.infolist() if not i.is_dir()]
|
||
# prefer larger image files
|
||
candidates = [
|
||
i
|
||
for i in infos
|
||
if Path(i.filename).suffix.lower() in {".jpg", ".jpeg", ".png", ".webp"}
|
||
]
|
||
# Filter obvious thumbnails
|
||
filtered = []
|
||
for i in candidates:
|
||
n = i.filename.lower()
|
||
if "thumb" in n or "thumbnail" in n or "small" in n:
|
||
continue
|
||
filtered.append(i)
|
||
candidates = filtered or candidates
|
||
if not candidates:
|
||
return None
|
||
candidates.sort(key=lambda i: i.file_size, reverse=True)
|
||
pick = candidates[0]
|
||
ext = Path(pick.filename).suffix.lower().lstrip(".") or "jpg"
|
||
out_name = f"default.{ext}"
|
||
if extract_zip_entry(zf, pick.filename, out_dir / out_name):
|
||
return out_name
|
||
return None
|
||
except zipfile.BadZipFile:
|
||
# Some wallpaper .mrc are raw image bytes; detect common formats by signature.
|
||
data = mrc_path.read_bytes()
|
||
head = data[:16]
|
||
ext = "bin"
|
||
if head.startswith(b"\xff\xd8\xff"):
|
||
ext = "jpg"
|
||
elif head.startswith(b"\x89PNG\r\n\x1a\n"):
|
||
ext = "png"
|
||
elif len(head) >= 12 and head[:4] == b"RIFF" and head[8:12] == b"WEBP":
|
||
ext = "webp"
|
||
elif head.startswith(b"GIF87a") or head.startswith(b"GIF89a"):
|
||
ext = "gif"
|
||
out_name = f"default.{ext}"
|
||
(out_dir / out_name).write_bytes(data)
|
||
return out_name
|
||
|
||
|
||
def pick_locale_field(d: dict, key: str) -> str:
|
||
m = d.get(key)
|
||
if not isinstance(m, dict):
|
||
return ""
|
||
return str(m.get("zh_CN") or m.get("fallback") or (next(iter(m.values()), "")) or "")
|
||
|
||
|
||
def build_theme_entry(theme_meta: dict) -> dict:
|
||
theme_id = str(theme_meta.get("localId") or "")
|
||
title = pick_locale_field(theme_meta, "titles") or theme_id
|
||
author = pick_locale_field(theme_meta, "authors") or pick_locale_field(theme_meta, "designers") or ""
|
||
description = pick_locale_field(theme_meta, "descriptions") or ""
|
||
built_in_previews = []
|
||
bip = theme_meta.get("builtInPreviews") or {}
|
||
if isinstance(bip, dict):
|
||
v = bip.get("fallback")
|
||
if isinstance(v, list):
|
||
built_in_previews = [str(x) for x in v if x]
|
||
sub_resources = [
|
||
{"resourceCode": code, "localId": local_id}
|
||
for code, local_id in iter_subresources(theme_meta)
|
||
]
|
||
return {
|
||
"id": theme_id,
|
||
"title": title,
|
||
"author": author,
|
||
"description": description,
|
||
"price": theme_meta.get("price") if isinstance(theme_meta.get("price"), (int, float)) else None,
|
||
"version": str(theme_meta.get("version")) if theme_meta.get("version") is not None else None,
|
||
"assemblyId": str(theme_meta.get("assemblyId")) if theme_meta.get("assemblyId") else None,
|
||
"previews": built_in_previews,
|
||
"subResources": sub_resources,
|
||
}
|
||
|
||
|
||
def main() -> None:
|
||
parser = argparse.ArgumentParser()
|
||
parser.add_argument(
|
||
"--src",
|
||
default="themes",
|
||
help="Source themes directory (default: ./themes)",
|
||
)
|
||
parser.add_argument(
|
||
"--dest",
|
||
default="mobilegym-data/themes",
|
||
help="Destination directory (default: ./mobilegym-data/themes)",
|
||
)
|
||
parser.add_argument(
|
||
"--themes",
|
||
nargs="*",
|
||
default=DEFAULT_THEME_IDS,
|
||
help="Theme localIds to include (default: a curated set)",
|
||
)
|
||
parser.add_argument(
|
||
"--all-themes",
|
||
action="store_true",
|
||
help="Include ALL themes under themes/meta/theme (ignores --themes)",
|
||
)
|
||
parser.add_argument(
|
||
"--default-theme-id",
|
||
default=DEFAULT_DEFAULT_THEME_ID,
|
||
help="Default theme id written into manifest.json",
|
||
)
|
||
parser.add_argument(
|
||
"--no-fonts",
|
||
action="store_true",
|
||
help="Do NOT include fonts under themes/meta/fonts (preview only)",
|
||
)
|
||
parser.add_argument(
|
||
"--no-aod",
|
||
action="store_true",
|
||
help="Do NOT include AOD under themes/meta/aod (preview only)",
|
||
)
|
||
parser.add_argument(
|
||
"--no-widgets",
|
||
action="store_true",
|
||
help="Do NOT include standalone WMR widgets under themes/maml_widget",
|
||
)
|
||
parser.add_argument(
|
||
"--clean",
|
||
action="store_true",
|
||
help="Delete existing destination directory (e.g. mobilegym-data/themes) before writing",
|
||
)
|
||
args = parser.parse_args()
|
||
|
||
root = Path(__file__).resolve().parents[2]
|
||
src_root = (root / args.src).resolve()
|
||
dest_root = (root / args.dest).resolve()
|
||
|
||
if not src_root.exists():
|
||
raise SystemExit(f"Source not found: {src_root}")
|
||
if args.clean and dest_root.exists():
|
||
shutil.rmtree(dest_root)
|
||
ensure_dir(dest_root)
|
||
|
||
package_names = parse_app_package_names(root)
|
||
settings_icon_names = parse_settings_main_icon_names(root)
|
||
|
||
# Small sets used by other apps:
|
||
contact_asset_names = [f"dialpad_{d}" for d in list("0123456789")] + ["dialpad_*", "dialpad_#"] + [
|
||
f"key_{d}" for d in list("0123456789")
|
||
] + ["key_*", "key_#", "call_button"]
|
||
mms_asset_names = [
|
||
"bubble_out",
|
||
"bubble_send",
|
||
"msg_out",
|
||
"message_out",
|
||
"chat_to",
|
||
"sms_out",
|
||
"bubble_in",
|
||
"bubble_recv",
|
||
"msg_in",
|
||
"message_in",
|
||
"chat_from",
|
||
"sms_in",
|
||
]
|
||
|
||
# Source dirs
|
||
src_meta_theme = src_root / "meta/theme"
|
||
src_meta_fonts = src_root / "meta/fonts"
|
||
src_meta_aod = src_root / "meta/aod"
|
||
src_preview_theme = src_root / "preview/theme"
|
||
src_content_base = src_root / "content"
|
||
|
||
# Theme ids to process
|
||
if args.all_themes:
|
||
theme_ids = sorted([p.stem for p in src_meta_theme.glob("*.mrm")])
|
||
else:
|
||
theme_ids = list(args.themes)
|
||
|
||
missing: list[str] = []
|
||
themes_out: list[dict] = []
|
||
fonts_out: list[dict] = []
|
||
aod_out: list[dict] = []
|
||
clock_widgets_collected: list[dict] = []
|
||
skipped_wrappers: dict[str, list[str]] = {"fonts_only": [], "aod_only": []}
|
||
|
||
for theme_id in theme_ids:
|
||
theme_meta_path = src_meta_theme / f"{theme_id}.mrm"
|
||
if not theme_meta_path.exists():
|
||
missing.append(f"meta/theme/{theme_id}.mrm")
|
||
continue
|
||
|
||
meta = read_json(theme_meta_path)
|
||
|
||
# Some entries under meta/theme are actually "wrapper resources" for fonts/AOD only.
|
||
# When exporting all themes, we keep categories clean by excluding these from `themes`.
|
||
codes = sorted({code for code, _ in iter_subresources(meta)})
|
||
if codes == ["fonts"]:
|
||
skipped_wrappers["fonts_only"].append(theme_id)
|
||
continue
|
||
if codes == ["aod"]:
|
||
skipped_wrappers["aod_only"].append(theme_id)
|
||
continue
|
||
|
||
entry = build_theme_entry(meta)
|
||
entry["type"] = "full"
|
||
|
||
# Prepare destination dirs
|
||
theme_dir = dest_root / theme_id
|
||
preview_dir = theme_dir / "preview"
|
||
icons_dir = theme_dir / "icons"
|
||
statusbar_dir = theme_dir / "statusbar"
|
||
shade_dir = theme_dir / "shade"
|
||
wallpaper_dir = theme_dir / "wallpaper"
|
||
components_dir = theme_dir / "components"
|
||
|
||
# Fresh theme dir (avoid stale files when re-running without --clean)
|
||
if theme_dir.exists():
|
||
shutil.rmtree(theme_dir)
|
||
ensure_dir(theme_dir)
|
||
|
||
# Copy previews
|
||
copy_tree(src_preview_theme / theme_id, preview_dir)
|
||
|
||
# Subresources lookup
|
||
sub_map: dict[str, str] = {code: local_id for code, local_id in iter_subresources(meta)}
|
||
|
||
capabilities: list[str] = []
|
||
extracted: dict = {}
|
||
|
||
# ---- App icons ----
|
||
icons_local_id = sub_map.get("icons")
|
||
if icons_local_id:
|
||
capabilities.append("icons")
|
||
icons_mrc = src_content_base / "icons" / f"{icons_local_id}.mrc"
|
||
try:
|
||
extracted_pkgs = extract_app_icons_from_icons_mrc(icons_mrc, icons_dir, package_names)
|
||
except zipfile.BadZipFile:
|
||
extracted_pkgs = []
|
||
entry["iconPackageNames"] = extracted_pkgs
|
||
extracted["icons"] = bool(extracted_pkgs)
|
||
else:
|
||
entry["iconPackageNames"] = []
|
||
|
||
# ---- Status bar icons + shade backgrounds ----
|
||
status_local_id = sub_map.get("statusbar")
|
||
statusbar_icons: list[str] = []
|
||
statusbar_dynamic: dict[str, object] = {}
|
||
shade: dict[str, bool] = {"active": False, "inactive": False}
|
||
if status_local_id:
|
||
capabilities.append("statusbar")
|
||
status_mrc = src_content_base / "statusbar" / f"{status_local_id}.mrc"
|
||
try:
|
||
with zipfile.ZipFile(status_mrc, "r") as zf:
|
||
names = zf.namelist()
|
||
pngs = [n for n in names if _is_png(n)]
|
||
|
||
sb = find_statusbar_icons(zf)
|
||
# bluetooth (static)
|
||
if "bluetooth" in sb:
|
||
if extract_statusbar_icon_normalized(zf, sb["bluetooth"], statusbar_dir / "bluetooth.png"):
|
||
statusbar_icons.append("bluetooth")
|
||
|
||
# wifi levels (+ wifi.png alias)
|
||
wifi_levels = extract_statusbar_wifi_levels(zf, statusbar_dir)
|
||
if wifi_levels:
|
||
statusbar_icons.append("wifi")
|
||
statusbar_dynamic["wifiLevels"] = wifi_levels
|
||
elif "wifi" in sb:
|
||
if extract_statusbar_icon_normalized(zf, sb["wifi"], statusbar_dir / "wifi.png"):
|
||
statusbar_icons.append("wifi")
|
||
|
||
# signal levels (+ signal.png alias)
|
||
signal_levels = extract_statusbar_signal_levels(zf, statusbar_dir)
|
||
if signal_levels:
|
||
statusbar_icons.append("signal")
|
||
statusbar_dynamic["signalLevels"] = signal_levels
|
||
elif "signal" in sb:
|
||
if extract_statusbar_icon_normalized(zf, sb["signal"], statusbar_dir / "signal.png"):
|
||
statusbar_icons.append("signal")
|
||
|
||
# battery: export sprite + full frame
|
||
if "battery" in sb:
|
||
info = extract_statusbar_battery_assets(zf, sb["battery"], statusbar_dir)
|
||
if info:
|
||
statusbar_icons.append("battery")
|
||
# Only include non-null values in manifest
|
||
if isinstance(info.get("batteryFrames"), int):
|
||
statusbar_dynamic["batteryFrames"] = info["batteryFrames"]
|
||
if isinstance(info.get("batteryFrameSide"), int):
|
||
statusbar_dynamic["batteryFrameSide"] = info["batteryFrameSide"]
|
||
if isinstance(info.get("batterySprite"), str) and info["batterySprite"]:
|
||
statusbar_dynamic["batterySprite"] = info["batterySprite"]
|
||
|
||
# State variant sprites — preserve theme RGBA so the front-end
|
||
# can render the theme designer's chosen colors directly
|
||
# (charging green, saver yellow, etc.). Front-end falls back
|
||
# to runtime tint on the base sprite when a variant is missing.
|
||
charge_entry = best_path_for_basename(
|
||
pngs,
|
||
["stat_sys_battery_charge.png", "stat_sys_battery_charge_darkmode.png"],
|
||
prefer_nightmode=False,
|
||
)
|
||
if charge_entry:
|
||
ch_info = extract_statusbar_battery_variant_assets(
|
||
zf, charge_entry, statusbar_dir,
|
||
prefix="battery_charge", manifest_prefix="batteryCharge",
|
||
)
|
||
if ch_info:
|
||
statusbar_dynamic.update(ch_info)
|
||
|
||
power_save_entry = best_path_for_basename(
|
||
pngs,
|
||
["stat_sys_battery_power_save.png", "stat_sys_battery_power_save_darkmode.png"],
|
||
prefer_nightmode=False,
|
||
)
|
||
if power_save_entry:
|
||
ps_info = extract_statusbar_battery_variant_assets(
|
||
zf, power_save_entry, statusbar_dir,
|
||
prefix="battery_power_save", manifest_prefix="batteryPowerSave",
|
||
)
|
||
# Drop the variant if it's pixel-identical to the normal
|
||
# sprite (some themes ship the same PNG for both, with the
|
||
# color difference applied at runtime). The
|
||
# front-end's system-tint path will produce yellow itself.
|
||
if ps_info and _png_pixel_identical(
|
||
statusbar_dir / "battery_sprite.png",
|
||
statusbar_dir / "battery_power_save_sprite.png",
|
||
):
|
||
(statusbar_dir / "battery_power_save.png").unlink(missing_ok=True)
|
||
(statusbar_dir / "battery_power_save_sprite.png").unlink(missing_ok=True)
|
||
elif ps_info:
|
||
statusbar_dynamic.update(ps_info)
|
||
|
||
power_save_charge_entry = best_path_for_basename(
|
||
pngs,
|
||
["stat_sys_battery_power_save_charge.png",
|
||
"stat_sys_battery_power_save_charge_darkmode.png"],
|
||
prefer_nightmode=False,
|
||
)
|
||
if power_save_charge_entry:
|
||
psc_info = extract_statusbar_battery_variant_assets(
|
||
zf, power_save_charge_entry, statusbar_dir,
|
||
prefix="battery_power_save_charge",
|
||
manifest_prefix="batteryPowerSaveCharge",
|
||
)
|
||
if psc_info and _png_pixel_identical(
|
||
statusbar_dir / "battery_charge_sprite.png",
|
||
statusbar_dir / "battery_power_save_charge_sprite.png",
|
||
):
|
||
(statusbar_dir / "battery_power_save_charge.png").unlink(missing_ok=True)
|
||
(statusbar_dir / "battery_power_save_charge_sprite.png").unlink(missing_ok=True)
|
||
elif psc_info:
|
||
statusbar_dynamic.update(psc_info)
|
||
|
||
# Charging bolt overlay (used by the system-tint fallback path
|
||
# when a theme doesn't ship a `_charge` variant). Two sources:
|
||
# 1. Real `stat_sys_battery_charging.png` overlay (some
|
||
# themes provide a single-frame bolt drawable).
|
||
# 2. Color-encoded bolt extracted from the charge sprite —
|
||
# some themes bake body fill in saturated color and the bolt in
|
||
# neutral gray within the same alpha shape; we isolate
|
||
# the gray-only pixels and collapse to a single overlay.
|
||
bolt_overlay_entry = best_path_for_basename(
|
||
pngs,
|
||
[
|
||
"stat_sys_battery_charging.png",
|
||
"stat_sys_battery_charging_darkmode.png",
|
||
"battery_meter_charging.png",
|
||
"battery_meter_charging_dark.png",
|
||
],
|
||
prefer_nightmode=False,
|
||
)
|
||
bolt_written = False
|
||
if bolt_overlay_entry:
|
||
try:
|
||
raw = zf.read(bolt_overlay_entry)
|
||
if _png_has_visible_alpha(raw):
|
||
normalized = normalize_png_icon_to_square(raw, base_side=BATTERY_BASE_SIDE)
|
||
ensure_dir(statusbar_dir)
|
||
(statusbar_dir / "battery_bolt.png").write_bytes(normalized or raw)
|
||
statusbar_dynamic["batteryBoltOverlay"] = "battery_bolt.png"
|
||
bolt_written = True
|
||
except KeyError:
|
||
pass
|
||
if not bolt_written and charge_entry:
|
||
try:
|
||
raw = zf.read(charge_entry)
|
||
bolt_bytes = extract_battery_bolt_from_charge_png(raw)
|
||
if bolt_bytes:
|
||
ensure_dir(statusbar_dir)
|
||
(statusbar_dir / "battery_bolt.png").write_bytes(bolt_bytes)
|
||
statusbar_dynamic["batteryBoltOverlay"] = "battery_bolt.png"
|
||
except KeyError:
|
||
pass
|
||
|
||
# mobile data type icons (4G/5G/LTE...)
|
||
data_types = find_statusbar_data_type_icons(pngs)
|
||
exported_types: list[str] = []
|
||
for t, entry_path in data_types.items():
|
||
name = f"data_{t}"
|
||
if extract_statusbar_icon_normalized(zf, entry_path, statusbar_dir / f"{name}.png"):
|
||
statusbar_icons.append(name)
|
||
exported_types.append(t)
|
||
if exported_types:
|
||
statusbar_dynamic["dataTypes"] = sorted(set(exported_types))
|
||
|
||
# misc extras (airplane/no_sim/vpn/alarm/...)
|
||
misc = find_statusbar_misc_icons(pngs)
|
||
for name, entry_path in misc.items():
|
||
if extract_statusbar_icon_normalized(zf, entry_path, statusbar_dir / f"{name}.png"):
|
||
statusbar_icons.append(name)
|
||
|
||
sh = find_shade_backgrounds(zf)
|
||
if "active" in sh and extract_zip_entry(zf, sh["active"], shade_dir / "active.png"):
|
||
shade["active"] = True
|
||
if "inactive" in sh and extract_zip_entry(zf, sh["inactive"], shade_dir / "inactive.png"):
|
||
shade["inactive"] = True
|
||
except zipfile.BadZipFile:
|
||
pass
|
||
|
||
entry["statusbarIcons"] = sorted(set(statusbar_icons))
|
||
if statusbar_dynamic:
|
||
entry["statusbarDynamic"] = statusbar_dynamic
|
||
if statusbar_icons:
|
||
extracted["statusbar"] = True
|
||
if shade["active"] or shade["inactive"]:
|
||
capabilities.append("shade")
|
||
extracted["shade"] = shade
|
||
|
||
# ---- Wallpaper ----
|
||
wallpaper_local_id = sub_map.get("wallpaper")
|
||
if wallpaper_local_id:
|
||
capabilities.append("wallpaper")
|
||
wp_mrc = src_content_base / "wallpaper" / f"{wallpaper_local_id}.mrc"
|
||
wp_name = extract_wallpaper(wp_mrc, wallpaper_dir)
|
||
if wp_name:
|
||
extracted["wallpaper"] = {"default": wp_name}
|
||
|
||
# ---- Selected component assets (for getAppAsset) ----
|
||
# Settings icons (prefer non-nightmode for light Settings UI)
|
||
settings_local_id = sub_map.get("com.android.settings")
|
||
if settings_local_id and settings_icon_names:
|
||
capabilities.append("settings")
|
||
mrc = src_content_base / "com.android.settings" / f"{settings_local_id}.mrc"
|
||
extracted_names = extract_selected_component_assets(
|
||
mrc,
|
||
components_dir / "com.android.settings",
|
||
settings_icon_names,
|
||
prefer_nightmode=False,
|
||
)
|
||
if extracted_names:
|
||
extracted["com.android.settings"] = {"count": len(extracted_names)}
|
||
|
||
# Contact dialpad assets (light UI)
|
||
contact_local_id = sub_map.get("contact")
|
||
if contact_local_id:
|
||
capabilities.append("contact")
|
||
mrc = src_content_base / "contact" / f"{contact_local_id}.mrc"
|
||
extracted_names = extract_selected_component_assets(
|
||
mrc,
|
||
components_dir / "contact",
|
||
contact_asset_names,
|
||
prefer_nightmode=False,
|
||
)
|
||
if extracted_names:
|
||
extracted["contact"] = {"count": len(extracted_names)}
|
||
|
||
# MMS bubble assets (light UI)
|
||
mms_local_id = sub_map.get("mms")
|
||
if mms_local_id:
|
||
capabilities.append("mms")
|
||
mrc = src_content_base / "mms" / f"{mms_local_id}.mrc"
|
||
extracted_names = extract_selected_component_assets(
|
||
mrc,
|
||
components_dir / "mms",
|
||
mms_asset_names,
|
||
prefer_nightmode=False,
|
||
)
|
||
if extracted_names:
|
||
extracted["mms"] = {"count": len(extracted_names)}
|
||
|
||
# ---- Clock widgets (WMR, from theme subResources) ----
|
||
for clock_code in CLOCK_WIDGET_CODES:
|
||
clock_local_id = sub_map.get(clock_code)
|
||
if not clock_local_id:
|
||
continue
|
||
mrc = src_content_base / clock_code / f"{clock_local_id}.mrc"
|
||
clock_out = theme_dir / clock_code
|
||
if extract_clock_widget_mrc(mrc, clock_out):
|
||
extracted[clock_code] = True
|
||
# Copy built-in preview if available
|
||
preview_name = f"preview_{clock_code}_0.png"
|
||
preview_src = src_preview_theme / theme_id / preview_name
|
||
if preview_src.exists():
|
||
shutil.copy2(preview_src, clock_out / "preview.png")
|
||
# Collect for widgets array
|
||
spanX, spanY = CLOCK_SPAN.get(clock_code, (4, 2))
|
||
clock_widgets_collected.append({
|
||
"themeId": theme_id,
|
||
"themeTitle": entry.get("title", theme_id),
|
||
"clockCode": clock_code,
|
||
"spanX": spanX,
|
||
"spanY": spanY,
|
||
"hasPreview": preview_src.exists(),
|
||
})
|
||
|
||
entry["capabilities"] = sorted(set(capabilities))
|
||
entry["extracted"] = extracted
|
||
|
||
# ---- componentAssets: index of available PNGs per component dir ----
|
||
component_assets: dict[str, dict[str, str]] = {}
|
||
if components_dir.is_dir():
|
||
for comp_path in sorted(components_dir.iterdir()):
|
||
if not comp_path.is_dir():
|
||
continue
|
||
assets: dict[str, str] = {}
|
||
for png in sorted(comp_path.rglob("*.png")):
|
||
rel = str(png.relative_to(comp_path))
|
||
base = png.stem
|
||
if png.name.endswith(".9.png"):
|
||
base = png.name[:-6]
|
||
if base not in assets:
|
||
assets[base] = rel
|
||
if assets:
|
||
component_assets[comp_path.name] = assets
|
||
if component_assets:
|
||
entry["componentAssets"] = component_assets
|
||
|
||
themes_out.append(entry)
|
||
|
||
# ---- Optional: fonts / AOD (preview-only) ----
|
||
if not args.no_fonts and src_meta_fonts.exists():
|
||
for p in sorted(src_meta_fonts.glob("*.mrm")):
|
||
meta = read_json(p)
|
||
entry = build_theme_entry(meta)
|
||
entry["type"] = "font"
|
||
font_id = entry.get("id") or p.stem
|
||
font_dir = dest_root / font_id
|
||
if font_dir.exists():
|
||
shutil.rmtree(font_dir)
|
||
ensure_dir(font_dir)
|
||
copy_tree(src_preview_theme / font_id, font_dir / "preview")
|
||
fonts_out.append(entry)
|
||
|
||
if not args.no_aod and src_meta_aod.exists():
|
||
for p in sorted(src_meta_aod.glob("*.mrm")):
|
||
meta = read_json(p)
|
||
entry = build_theme_entry(meta)
|
||
entry["type"] = "aod"
|
||
aod_id = entry.get("id") or p.stem
|
||
aod_dir = dest_root / aod_id
|
||
if aod_dir.exists():
|
||
shutil.rmtree(aod_dir)
|
||
ensure_dir(aod_dir)
|
||
copy_tree(src_preview_theme / aod_id, aod_dir / "preview")
|
||
aod_out.append(entry)
|
||
|
||
# ---- Clock widgets (from themes) → widget entries ----
|
||
widgets_out: list[dict] = []
|
||
for cw in clock_widgets_collected:
|
||
widget_id = f"{cw['themeId']}_{cw['clockCode']}"
|
||
preview_rel = (
|
||
f"/themes/{cw['themeId']}/{cw['clockCode']}/preview.png"
|
||
if cw["hasPreview"] else ""
|
||
)
|
||
widgets_out.append({
|
||
"id": widget_id,
|
||
"title": f"{cw['themeTitle']}时钟",
|
||
"author": "",
|
||
"description": "",
|
||
"source": "theme",
|
||
"themeId": cw["themeId"],
|
||
"variants": [
|
||
{
|
||
"entry": cw["clockCode"],
|
||
"spanX": cw["spanX"],
|
||
"spanY": cw["spanY"],
|
||
"preview": preview_rel,
|
||
}
|
||
],
|
||
})
|
||
|
||
# ---- Standalone WMR widgets ----
|
||
src_widget_dir = src_root / "maml_widget"
|
||
if not args.no_widgets and src_widget_dir.exists():
|
||
for widget_dir in sorted(src_widget_dir.iterdir()):
|
||
if not widget_dir.is_dir():
|
||
continue
|
||
entry = extract_standalone_wmr_widget(widget_dir, dest_root)
|
||
if entry:
|
||
widgets_out.append(entry)
|
||
|
||
manifest = {
|
||
"version": 1,
|
||
"generatedAt": _now_iso(),
|
||
"defaultThemeId": args.default_theme_id,
|
||
"themes": themes_out,
|
||
"fonts": fonts_out,
|
||
"aod": aod_out,
|
||
"widgets": widgets_out,
|
||
}
|
||
|
||
ensure_dir(dest_root)
|
||
(dest_root / "manifest.json").write_text(
|
||
json.dumps(manifest, ensure_ascii=False, indent=2),
|
||
encoding="utf-8",
|
||
)
|
||
|
||
print("=== Theme preparation (V2 static) complete ===")
|
||
print(f"Output dir: {dest_root}")
|
||
print(f"Themes: {len(themes_out)}")
|
||
print(f"Widgets: {len(widgets_out)}")
|
||
if skipped_wrappers["fonts_only"] or skipped_wrappers["aod_only"]:
|
||
print(f"Skipped wrappers (fonts_only): {len(skipped_wrappers['fonts_only'])}")
|
||
print(f"Skipped wrappers (aod_only): {len(skipped_wrappers['aod_only'])}")
|
||
if missing:
|
||
print("")
|
||
print("Missing files (skipped):")
|
||
for m in missing[:200]:
|
||
print(f" - {m}")
|
||
if len(missing) > 200:
|
||
print(f" ... and {len(missing) - 200} more")
|
||
|
||
|
||
if __name__ == "__main__":
|
||
main()
|