轻量接入，云端活体验证。

{"source_index": 7, "timestamp_us": 233331, "status": "face_unavailable"}

import argparse
import hashlib
import json
import os
from pathlib import Path

import httpx

parser = argparse.ArgumentParser()
parser.add_argument("input", type=Path)
parser.add_argument("--prepare-only", action="store_true")
args = parser.parse_args()
metadata = json.loads(args.input.read_text(encoding="utf-8"))
captures = metadata["captures"] if "captures" in metadata else [metadata]
module_for = {"rgb_single": "rgb_liveness",
              "rgb_sequence": "rgb_liveness", "color": "color_liveness"}
modules = {module_for[capture["mode"]] for capture in captures}
if len(modules) != 1:
    raise ValueError("Use exactly one module per HTTP request")
module = modules.pop()
parts = {}
for capture in captures:
    for frame in capture["frames"]:
        if "image" not in frame:
            continue
        descriptor = frame["image"]
        name = descriptor["part"]
        if name in parts:
            raise ValueError("Each image.part must be unique")
        data = (args.input.parent / name).read_bytes()
        descriptor["sha256"] = hashlib.sha256(data).hexdigest()
        parts[name] = data
text = json.dumps(metadata, ensure_ascii=False, allow_nan=False)
Path("metadata.json").write_text(text, encoding="utf-8")
if args.prepare_only:
    raise SystemExit(0)

base = os.environ["API_BASE"].rstrip("/")
headers = {
    "Authorization": f"Bearer {os.environ['API_TOKEN']}",
    "Idempotency-Key": os.environ["IDEMPOTENCY_KEY"],
}
files = [("metadata", (None, text))]
files.extend((name, (name, data, "application/octet-stream"))
             for name, data in parts.items())
response = httpx.post(
    f"{base}/v1/modules/{module}/verify",
    headers=headers, files=files, timeout=60,
)
print(response.status_code)
print(json.dumps(response.json(), indent=2, ensure_ascii=False))
response.raise_for_status()
for result in response.json()["results"]:
    if result["status"] == "ok":
        print(result["capture_id"], "alive:", result["alive"])
    else:
        print(result["capture_id"], "retry:", result["reason"])

{
  "protocol_version": 1,
  "capture_id": "color-capture-001",
  "mode": "color",
  "capture_profile": "color_wrgb_v1",
  "preprocess_profile": "eye_crop_320_v1",
  "complete": true,
  "frames": [
    {
      "source_index": 0, "timestamp_us": 200000, "status": "ok",
      "phase": "white", "display_time_us": 0,
      "source_size": [640, 480],
      "eyes_xy": [[220.0, 180.0], [340.0, 180.0]],
      "image": {"part": "white.png", "encoding": "png",
                "sha256": "REPLACED_BY_SEND_CAPTURE_PY"}
    },
    {
      "source_index": 1, "timestamp_us": 450000, "status": "ok",
      "phase": "red", "display_time_us": 250000,
      "source_size": [640, 480],
      "eyes_xy": [[221.0, 180.0], [341.0, 180.0]],
      "image": {"part": "red.png", "encoding": "png",
                "sha256": "REPLACED_BY_SEND_CAPTURE_PY"}
    },
    {
      "source_index": 2, "timestamp_us": 700000, "status": "ok",
      "phase": "green", "display_time_us": 500000,
      "source_size": [640, 480],
      "eyes_xy": [[220.0, 181.0], [340.0, 181.0]],
      "image": {"part": "green.png", "encoding": "png",
                "sha256": "REPLACED_BY_SEND_CAPTURE_PY"}
    },
    {
      "source_index": 3, "timestamp_us": 950000, "status": "ok",
      "phase": "blue", "display_time_us": 750000,
      "source_size": [640, 480],
      "eyes_xy": [[220.0, 180.0], [340.0, 180.0]],
      "image": {"part": "blue.png", "encoding": "png",
                "sha256": "REPLACED_BY_SEND_CAPTURE_PY"}
    }
  ]
}

{
  "request_id": "res_example",
  "module_id": "rgb_liveness",
  "charged_units": 1,
  "results": [{
    "capture_id": "rgb-capture-001", "mode": "rgb_single",
    "status": "ok", "alive": true, "score": 0.91, "reason": null,
    "final_window_frames": 0, "window_frame_indices": [],
    "reset_events": [], "single_score": 0.91,
    "temporal_logit": null, "color_logits": null,
    "model_set": "raw_v1", "decision_policy": "single_frame_v1",
    "threshold": 0.5, "min_final_frames": null
  }],
  "usage": [{
    "module_id": "rgb_liveness", "limit": 1000, "period": "day",
    "used": 1, "remaining": 999, "reset_at": "2027-01-02T00:00:00Z"
  }]
}

import java.security.MessageDigest;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import org.json.JSONArray;
import org.json.JSONObject;
import okhttp3.MediaType;
import okhttp3.MultipartBody;
import okhttp3.Request;
import okhttp3.RequestBody;

public final class AndroidCaptureRequest {
    private AndroidCaptureRequest() {}

    // Build ONCE after a complete recording. Keep this Request for retries.
    // preparedFrames contain the fields shown below; rgb8Parts is keyed by image.part.
    public static Request buildRgb8(
            String apiBase, String businessToken, String mode,
            JSONArray preparedFrames, Map<String, byte[]> rgb8Parts) throws Exception {
        boolean color = "color".equals(mode);
        if (!color && !"rgb_sequence".equals(mode)) {
            throw new IllegalArgumentException("Use rgb_sequence or color");
        }
        int count = color ? 4 : 20;
        if (preparedFrames.length() != count) {
            throw new IllegalArgumentException("Capture is not complete");
        }
        String module = color ? "color_liveness" : "rgb_liveness";
        String profile = color ? "color_wrgb_v1" : "rgb_contiguous_v1";
        String[] phases = {"white", "red", "green", "blue"};
        String captureId = UUID.randomUUID().toString();
        JSONArray frames = new JSONArray(preparedFrames.toString());
        MultipartBody.Builder multipart = new MultipartBody.Builder()
                .setType(MultipartBody.FORM);
        Set<String> used = new HashSet<>();
        long lastIndex = -1, lastTimeUs = -1;

        for (int i = 0; i < count; i++) {
            JSONObject row = frames.getJSONObject(i);
            long index = row.getLong("source_index");
            long timeUs = row.getLong("timestamp_us");
            if (!"ok".equals(row.getString("status")) || index <= lastIndex
                    || timeUs <= lastTimeUs || (!color && i > 0 && index != lastIndex + 1)) {
                throw new IllegalArgumentException("Invalid frame status, order or continuity");
            }
            if (color) {
                if (!phases[i].equals(row.getString("phase"))) {
                    throw new IllegalArgumentException("Expected white/red/green/blue");
                }
                if (row.has("display_time_us")) {
                    long displayed = row.getLong("display_time_us");
                    if (displayed < 0 || displayed > timeUs || (i > 0 && displayed <= lastTimeUs)) {
                        throw new IllegalArgumentException("Invalid phase timestamps");
                    }
                }
            } else if (row.has("phase") || row.has("display_time_us")) {
                throw new IllegalArgumentException("RGB must omit color-phase fields");
            }
            lastIndex = index;
            lastTimeUs = timeUs;

            JSONObject image = row.getJSONObject("image");
            String part = image.getString("part");
            byte[] source = rgb8Parts.get(part);
            if (!used.add(part) || source == null || source.length != 307200) {
                throw new IllegalArgumentException("Missing, duplicate or invalid RGB8 part");
            }
            byte[] snapshot = source.clone(); // Keep retries independent of capture buffers.
            image.put("encoding", "rgb8");
            image.put("sha256", sha256(snapshot));
            multipart.addFormDataPart(part, part,
                    RequestBody.create(MediaType.parse("application/octet-stream"), snapshot));
        }
        if (used.size() != rgb8Parts.size()) {
            throw new IllegalArgumentException("Unreferenced image parts");
        }
        JSONObject packet = new JSONObject()
                .put("protocol_version", 1)
                .put("capture_id", captureId)
                .put("mode", mode)
                .put("capture_profile", profile)
                .put("preprocess_profile", "eye_crop_320_v1")
                .put("complete", true)
                .put("frames", frames);
        multipart.addFormDataPart("metadata", packet.toString());
        String base = apiBase.endsWith("/") ? apiBase.substring(0, apiBase.length() - 1) : apiBase;
        return new Request.Builder()
                .url(base + "/v1/modules/" + module + "/verify")
                .header("Authorization", "Bearer " + businessToken)
                .header("Idempotency-Key", captureId)
                .post(multipart.build())
                .build();
    }

    private static String sha256(byte[] data) throws Exception {
        byte[] digest = MessageDigest.getInstance("SHA-256").digest(data);
        char[] hex = "0123456789abcdef".toCharArray();
        StringBuilder out = new StringBuilder(64);
        for (byte b : digest) {
            out.append(hex[(b & 0xff) >>> 4]);
            out.append(hex[b & 0x0f]);
        }
        return out.toString();
    }
}
// Upload asynchronously with your existing OkHttpClient and Callback:
// Request frozen = AndroidCaptureRequest.buildRgb8(API_BASE, businessToken, mode, frames, parts);
// client.newCall(frozen).enqueue(callback);
// Retry: create a NEW Call using the SAME frozen Request.
// New recording: call buildRgb8 again to create a new capture_id / Idempotency-Key.