Files
d2r-mobile/dm/ios/tools/input_pair_check.py
T
2026-10-12 16:51:08 +08:00

404 lines
20 KiB
Python

#!/usr/bin/env python3
"""冻结UI/HID收据的独立只读配对;协议通过不等于物理触摸通过。 | Independent read-only pairing of frozen UI/HID receipts; the protocol passing does not mean physical touch passes."""
import argparse
import json
import math
import re
from pathlib import Path
STATE = ("buttons", "lx", "ly", "rx", "ry")
PHASES = {"began", "moved", "ended", "cancelled"}
SOURCES = {"uitouch", "layout", "navigation", "focus_cancel", "screenshot", "bindings", "portal_sequence"}
UI_INTS = {"eventseq", "receiptseq", "event_first_seq", "event_last_seq",
"mono_ns", "publish_end_ns", "slot", *STATE}
HID_INTS = {"read_start_ns", "time_ns", "sampling", "id", "style",
"attributes", "script_mask", *STATE}
class TraceError(ValueError):
pass
def integer(value):
if isinstance(value, bool):
raise TraceError("boolean_not_integer")
if isinstance(value, int):
return value
if isinstance(value, str) and re.fullmatch(r"-?(?:0[xX][0-9a-fA-F]+|[0-9]+)", value):
try:
return int(value, 16) if "x" in value.lower() else int(value, 10)
except ValueError:
pass
raise TraceError("bad_integer")
def normalize(records, keys):
out = []
for src in records:
row = dict(src)
for key in keys & row.keys():
row[key] = integer(row[key])
out.append(row)
return out
def require(row, fields):
missing = set(fields) - row.keys()
if missing:
raise TraceError("missing_fields:" + ",".join(sorted(missing)))
def validate_state(row):
# 校验实际Npad ABI类型,而不是新增±32767生产阈值。
# Validates the actual Npad ABI type, rather than adding a new ±32767 production threshold.
if not 0 <= row["buttons"] < 2**64:
raise TraceError("unsigned_range")
if any(not -(2**31) <= row[k] < 2**31 for k in ("lx", "ly", "rx", "ry")):
raise TraceError("int32_range")
PORTAL_FIELDS = {"portal_request", "portal_binding", "portal_scene", "portal_phase",
"portal_pending", "modifier_publish_end_ns", "feedback_group_start_ns",
"feedback_captured_ns", "feedback_secondary", "feedback_seen",
"feedback_identity_scope"}
PORTAL_UNSIGNED = PORTAL_FIELDS - {"portal_phase", "portal_pending", "feedback_secondary",
"feedback_seen", "feedback_identity_scope"}
def validate_portal(row, active, request):
if row["source"] == "portal_sequence" or PORTAL_FIELDS & row.keys():
require(row, PORTAL_FIELDS)
else:
if request:
raise TraceError("portal_fields_missing_during_request")
return None
if any(not 0 <= row[k] < 2**64 for k in PORTAL_UNSIGNED):
raise TraceError("portal_unsigned_range")
if (row["portal_phase"] not in {0, 1, 2} or row["portal_pending"] not in {0, 1} or
row["feedback_secondary"] not in {0, 1} or not 0 <= row["feedback_seen"] <= 63 or
row["feedback_identity_scope"] not in {0, 1, 2}):
raise TraceError("portal_field_range")
if row["source"] == "portal_sequence":
if (not request or request["acked"] or not active or row["mode"] != "game" or
row["portal_phase"] != 2 or row["portal_pending"] != 0):
raise TraceError("portal_request_not_pending")
modifier = request["modifier"]
if not any(t in active and active[t] >= 0 for t in request["touches"]):
raise TraceError("portal_touch_not_active")
if any(row[k] != modifier[k] for k in ("portal_request", "portal_binding", "portal_scene",
"modifier_publish_end_ns")):
raise TraceError("portal_request_identity")
if row["feedback_secondary"] != 1 or row["feedback_seen"] != 63 or row["feedback_identity_scope"] not in {1, 2}:
raise TraceError("portal_feedback_identity")
if not (modifier["publish_end_ns"] < row["feedback_group_start_ns"] <=
row["feedback_captured_ns"] < row["mono_ns"] and
row["mono_ns"] - row["feedback_captured_ns"] <= 250_000_000):
raise TraceError("portal_feedback_time")
# 最小两阶段原SDK位序;仅承认原facet A/B/X/Y/R/ZR的一个新增边沿。
# Minimal two-phase original SDK bit order; only one newly added edge of the original facets A/B/X/Y/R/ZR is accepted.
edge = row["buttons"] & ~modifier["buttons"]
if not row["buttons"] & 256 or edge not in {1, 2, 4, 8, 128, 512}:
raise TraceError("portal_action_edge")
row["_portal_modifier_receipt"] = modifier["receiptseq"]
request["acked"] = True
return request
if row["portal_phase"] == 1:
if (row["portal_pending"] != 1 or row["mode"] != "game" or not active or
not row["buttons"] & 256 or not all(row[k] for k in ("portal_request", "portal_binding", "portal_scene"))):
raise TraceError("portal_modifier_publication")
same = request and all(row[k] == request["modifier"][k] for k in
("portal_request", "portal_binding", "portal_scene"))
if same:
if request["acked"] or row["modifier_publish_end_ns"] != request["modifier"]["publish_end_ns"]:
raise TraceError("portal_modifier_publication")
return request
if (row["source"] != "uitouch" or row["phase"] != "began" or
row["modifier_publish_end_ns"] != row["publish_end_ns"]):
raise TraceError("portal_modifier_publication")
return {"modifier": row, "acked": False,
"touches": {e["touch"] for e in row["_touch_group"] if e["phase"] == "began" and e["slot"] >= 0}}
if row["portal_pending"]:
raise TraceError("portal_request_not_pending")
if row["portal_phase"] == 0:
return None
# normal Portal无需ZL/ACK;已ACK请求的普通持有发布保留其关联。
# normal Portal needs no ZL/ACK; the ordinary hold publish of an already ACKed request keeps its association.
if request and all(row[k] == request["modifier"][k] for k in
("portal_request", "portal_binding", "portal_scene")):
if not request["acked"]:
raise TraceError("portal_action_without_ack")
return request
return None
def validate_ui(records):
records = normalize(records, UI_INTS | PORTAL_FIELDS)
events = []
outputs = []
active = {}
pending = []
event_no = receipt_no = published = last_time = end_time = 0
lifecycle_reasons = set()
portal_request = None
portal_epoch = 0
for row in records:
require(row, ("stage", "eventseq", "mono_ns", "source", "phase", "mode", *STATE))
validate_state(row)
if row["source"] not in SOURCES or row["mode"] not in {"game", "navigation"}:
raise TraceError("bad_source_or_mode")
if row["mono_ns"] <= 0 or row["mono_ns"] < max(last_time, end_time):
raise TraceError("ui_time_regression")
last_time = row["mono_ns"]
if row["stage"] == "event":
require(row, ("slot", "touch", "x", "y", "touch_timestamp_s"))
if row["source"] != "uitouch" or row["phase"] not in PHASES:
raise TraceError("bad_event_source_phase")
if row["eventseq"] != event_no + 1:
raise TraceError("event_sequence_gap")
if not -1 <= row["slot"] < 16:
raise TraceError("bad_slot")
for key in ("x", "y", "touch_timestamp_s"):
if not math.isfinite(float(row[key])):
raise TraceError("nonfinite_touch")
if float(row["touch_timestamp_s"]) < 0:
raise TraceError("negative_touch_timestamp")
touch = row["touch"]
if row["phase"] == "began":
if touch in active:
lifecycle_reasons.add("duplicate_begin")
if row["slot"] >= 0 and row["slot"] in active.values():
raise TraceError("slot_conflict")
active[touch] = row["slot"]
else:
if touch not in active:
lifecycle_reasons.add("lifecycle_orphan")
elif active[touch] != row["slot"]:
raise TraceError("slot_transition")
if row["phase"] in {"ended", "cancelled"}:
active.pop(touch, None)
event_no += 1
pending.append(row)
events.append(row)
elif row["stage"] == "output":
require(row, ("receiptseq", "event_first_seq", "event_last_seq", "publish_end_ns"))
if row["receiptseq"] != receipt_no + 1 or row["eventseq"] != event_no:
raise TraceError("output_sequence_gap")
first = published + 1 if event_no > published else 0
if row["event_first_seq"] != first or row["event_last_seq"] != event_no:
raise TraceError("event_group_not_closed")
if pending and (row["source"] != "uitouch" or
any(e["phase"] != row["phase"] for e in pending)):
raise TraceError("event_group_source_phase")
if (row["source"] == "uitouch") != (row["phase"] in PHASES):
raise TraceError("bad_output_phase")
if row["publish_end_ns"] < row["mono_ns"]:
raise TraceError("reversed_publication")
row["_touch_group"] = list(pending)
row["_release"] = bool(pending) and not active and row["phase"] in {"ended", "cancelled"}
row["_blank_claim"] = any(e.get("blank") is True for e in pending)
portal_request = validate_portal(row, active, portal_request)
if "portal_request" in row:
if row["portal_request"] < portal_epoch:
raise TraceError("portal_request_regression")
portal_epoch = row["portal_request"]
outputs.append(row)
if row["source"] in {"layout", "focus_cancel"}:
# 控件取消/清槽不代表物理触点已结束;后续无归属点slot=-1仍按touch身份闭合。
# A widget cancel / slot clear does not mean the physical touch point has ended; a subsequent unowned point with slot=-1 is still closed under the touch identity.
active = {touch: -1 for touch in active}
pending.clear()
receipt_no += 1
published = event_no
end_time = row["publish_end_ns"]
else:
raise TraceError("bad_ui_stage")
if pending:
lifecycle_reasons.add("unpublished_events")
if active:
lifecycle_reasons.add("lifecycle_unclosed")
if not records:
raise TraceError("empty_ui_trace")
return events, outputs, lifecycle_reasons
def validate_hid(records):
records = normalize(records, HID_INTS)
rows = []
seen = set()
reasons = set()
for row in records:
if row.get("event") == "limit_reached":
reasons.add("limit_reached")
continue
if row.get("event") != "npad_return":
raise TraceError("bad_hid_event")
require(row, HID_INTS)
validate_state(row)
if row["read_start_ns"] < 0 or row["time_ns"] < row["read_start_ns"]:
raise TraceError("reversed_read")
if not 0 < row["sampling"] < 2**63:
raise TraceError("bad_sampling")
if any(not 0 <= row[k] < 2**32 for k in ("id", "style", "attributes")):
raise TraceError("unsigned_range")
if any(not 0 <= row[k] < 2**64 for k in ("buttons", "script_mask", "read_start_ns", "time_ns")):
raise TraceError("unsigned_range")
identity = (row["id"], row["style"], row["sampling"])
if identity in seen:
reasons.add("sampling_not_forward")
seen.add(identity)
rows.append(row)
rows.sort(key=lambda r: (r["time_ns"], r["read_start_ns"]))
last = {}
for row in rows:
key = (row["id"], row["style"])
if key in last and row["sampling"] <= last[key]:
reasons.add("sampling_not_forward")
last[key] = row["sampling"]
return rows, reasons
def connected(row):
return bool(row["attributes"] & 1) and (
(row["id"] == 0 and row["style"] == 1) or
(row["id"] == 32 and row["style"] == 2))
def analyze(ui, hid, domain="synthetic"):
result = {"domain": domain, "physical_pass_claimed": False,
"release_received": False, "blank_activity_received": False,
"combo_received": False, "portal_combo_pairs": 0}
try:
events, outputs, reasons = validate_ui(ui)
result.update(ui_events=len(events), ui_outputs=len(outputs))
if domain == "device" and any(o["source"] == "portal_sequence" and o["feedback_identity_scope"] != 1 for o in outputs):
raise TraceError("synthetic_identity_on_device")
if hid is None:
result.update(status="pair_not_executed", reasons=sorted(reasons | {"missing_hid_stream"}),
ui_lifecycle_closed=not reasons, pairs=[])
return result
reads, h_reasons = validate_hid(hid)
reasons.update(h_reasons)
pairs = []
touch_pairs = 0
matched_reads = {}
for i, output in enumerate(outputs):
upper = outputs[i + 1]["mono_ns"] if i + 1 < len(outputs) else None
lo = output["publish_end_ns"]
stable = [r for r in reads if r["read_start_ns"] > lo and
(upper is None or r["time_ns"] < upper)]
overlaps = [r for r in reads if
r["time_ns"] >= output["mono_ns"] and
(upper is None or r["read_start_ns"] < upper) and
any(r["read_start_ns"] <= o["publish_end_ns"] and
r["time_ns"] >= o["mono_ns"] for o in outputs)]
candidates = [r for r in stable if connected(r) and r["script_mask"] == 0]
matched = [r for r in candidates if all(r[k] == output[k] for k in STATE)]
is_touch = output["source"] == "uitouch" and bool(output["_touch_group"])
pair = {"receiptseq": output["receiptseq"], "source": output["source"],
"event_group": [output["event_first_seq"], output["event_last_seq"]],
"matched_sampling": [r["sampling"] for r in matched],
"status": "matched" if matched else "not_sampled"}
is_combo = output["source"] == "portal_sequence"
if (is_touch or is_combo) and not matched:
reasons.add("missing_combo_receipt" if is_combo else "missing_receipt")
if overlaps:
reasons.add("concurrent_undetermined")
pair["status"] = "concurrent_undetermined"
elif stable and not any(connected(r) for r in stable):
reasons.add("invalid_controller")
pair["status"] = "invalid_controller"
elif any(connected(r) and r["script_mask"] for r in stable):
reasons.add("script_confounded")
pair["status"] = "script_confounded"
elif candidates:
reasons.add("returned_state_mismatch")
pair["status"] = "state_mismatch"
matched_reads[output["receiptseq"]] = matched
if is_combo:
modifier_reads = matched_reads.get(output["_portal_modifier_receipt"], [])
before_feedback = [r for r in modifier_reads
if r["time_ns"] < output["feedback_group_start_ns"]]
modifier_received = bool(before_feedback)
pair["modifier_before_feedback_sampling"] = [r["sampling"] for r in before_feedback]
pair["modifier_receiptseq"] = output["_portal_modifier_receipt"]
pair["combo_received"] = bool(matched) and modifier_received
if not modifier_received:
reasons.add("modifier_not_before_feedback" if modifier_reads else "missing_modifier_receipt")
if pair["combo_received"]:
result["combo_received"] = True
result["portal_combo_pairs"] += 1
neutral = all(output[k] == 0 for k in STATE)
if output["_release"] and not neutral:
reasons.add("release_not_neutral")
if output["_blank_claim"] and output["buttons"] & 1:
reasons.add("blank_unwanted_A")
if matched and is_touch:
touch_pairs += 1
if output["_release"] and neutral:
result["release_received"] = True
if output["_blank_claim"] and not (output["buttons"] & 1):
result["blank_activity_received"] = True
# 程序来源可匹配值,但不能算新真实触摸。
# A program source may match values, but must not count as a new real touch.
if not is_touch:
pair["attribution"] = "output_only_not_new_touch"
pairs.append(pair)
if not touch_pairs:
reasons.add("no_touch_pairs")
result.update(hid_rows=len(reads), touch_output_pairs=touch_pairs,
pairs=pairs, reasons=sorted(reasons),
status="incomplete" if reasons else "protocol_pass",
unknowns=["no physical case/game result established",
"blank-area identity requires independent gesture plan",
"feedback identity/group are UI declarations; native caller proof needs frozen source and original capture"])
except (TraceError, ValueError, TypeError, KeyError) as error:
result.update(status="invalid_trace", reasons=[str(error)], pairs=[])
return result
def load_ui(path):
records = []
for line in Path(path).read_text(errors="replace").splitlines():
if "[touch-receipt]" in line:
records.append(dict(re.findall(r"(\w+)=([^\s]+)", line)))
return records
def load_hid(path):
return [json.loads(line) for line in Path(path).read_text().splitlines() if line.strip()]
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("--ui-log", required=True)
parser.add_argument("--hid-log")
parser.add_argument("--domain", choices=["synthetic", "fake", "simulator", "device"], required=True)
parser.add_argument("--out")
parser.add_argument("--blank-events", default="",
help="由独立手势计划指定空白触点eventseq,逗号分隔;不从零输出猜空白区域")
args = parser.parse_args()
try:
ui = load_ui(args.ui_log)
blanks = {int(v) for v in args.blank_events.split(",") if v}
observed = set()
for row in ui:
if row.get("stage") == "event" and int(row["eventseq"]) in blanks:
row["blank"] = True
observed.add(int(row["eventseq"]))
if observed != blanks:
raise TraceError("blank_plan_event_missing")
data = analyze(ui, load_hid(args.hid_log) if args.hid_log else None, args.domain)
data["blank_plan_events"] = sorted(blanks)
except (OSError, ValueError) as error:
data = {"status": "invalid_trace", "reasons": [str(error)],
"domain": args.domain, "physical_pass_claimed": False}
text = json.dumps(data, ensure_ascii=False, indent=2)
if args.out:
Path(args.out).write_text(text + "\n")
print(text)
return {"protocol_pass": 0, "pair_not_executed": 2}.get(data["status"], 1)
if __name__ == "__main__":
raise SystemExit(main())