┌─────────────────────────────────────────────────────────────┐
│                    应用层 (VideoConference App)               │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────────────┐  │
│  │ 会议状态机   │  │ 设备发现/选中 │  │  UI 交互与权限控制   │  │
│  └──────┬──────┘  └──────┬──────┘  └──────────┬──────────┘  │
└─────────┼────────────────┼─────────────────────┼─────────────┘
          │                │                     │
┌─────────▼────────────────▼─────────────────────▼─────────────┐
│                  业务适配层 (FlowTransfer Manager)             │
│  ┌─────────────────────────────────────────────────────────┐  │
│  │  流转编排器：设备能力评估 → 编解码参数协商 → 会话迁移决策   │  │
│  └─────────────────────────────────────────────────────────┘  │
└────────────────────────────┬──────────────────────────────────┘
                             │
┌────────────────────────────▼──────────────────────────────────┐
│              分布式软总线接入层 (SoftBus Adapter)               │
│  ┌──────────────┐  ┌──────────────┐  ┌────────────────────┐   │
│  │ Session 管理  │  │ 字节流/消息流 │  │ 组网与设备认证代理   │   │
│  └──────────────┘  └──────────────┘  └────────────────────┘   │
└────────────────────────────┬──────────────────────────────────┘
                             │
┌────────────────────────────▼──────────────────────────────────┐
│                  HarmonyOS 分布式软总线内核                     │
│         (LNN 组网、传输层加密、流控、拥塞控制、多路复用)          │
└────────────────────────────────────────────────────────────────┘

// SoftBusSessionManager.h
class SoftBusSessionManager {
public:
    // 创建音视频专用 Session（高优先级、低延迟策略）
    int32_t CreateAVSession(const std::string& sessionName, 
                            const SessionAttribute& attr,
                            ISessionListener* listener);

    // 绑定网络质量回调，动态调整码率
    void RegisterQosCallback(const std::string& sessionName, 
                             std::function<void(const QosInfo&)> cb);

    // 优雅关闭：发送 END_FRAME 标记，等待 ACK 后再销毁
    void CloseSessionGracefully(const std::string& sessionName);

private:
    std::unordered_map<std::string, SessionHandle> sessions_;
    std::mutex mutex_;
};

// AVFramePacket.h
#pragma pack(push, 1)
struct AVFrameHeader {
    uint32_t magic;           // 0x41564652 "AVFR"
    uint16_t version;         // 协议版本
    uint8_t  trackType;       // 0: Video Key, 1: Video Delta, 2: Audio
    uint8_t  flags;           // Bit0: 是否分片首包, Bit1: 是否分片末包
    uint32_t sequenceId;      // 全局单调递增
    uint64_t timestampUs;     // 采集时间戳(微秒)
    uint32_t payloadSize;     // 当前包载荷大小
    uint32_t totalFrameSize;  // 完整帧大小(用于分片重组)
    uint32_t crc32;           // 载荷校验
};
#pragma pack(pop)

// FrameReassembler.cpp
bool FrameReassembler::OnPacketReceived(const uint8_t* data, size_t len) {
    if (len < sizeof(AVFrameHeader)) return false;
    
    const AVFrameHeader* hdr = reinterpret_cast<const AVFrameHeader*>(data);
    if (hdr->magic != MAGIC) return false;
    
    // CRC 校验
    if (!VerifyCRC32(data + sizeof(AVFrameHeader), hdr->payloadSize, hdr->crc32)) {
        stats_.crcError++;
        return false;
    }
    
    auto& buffer = frameBuffers_[hdr->sequenceId];
    buffer.Append(data + sizeof(AVFrameHeader), hdr->payloadSize);
    
    if (hdr->flags & FLAG_LAST_FRAGMENT) {
        if (buffer.Size() != hdr->totalFrameSize) {
            stats_.sizeMismatch++;
            frameBuffers_.erase(hdr->sequenceId);
            return false;
        }
        // 完整帧就绪，送入解码队列
        decoderQueue_.Push({hdr->trackType, hdr->timestampUs, buffer.Data(), buffer.Size()});
        frameBuffers_.erase(hdr->sequenceId);
    }
    return true;
}

stateDiagram-v2
    [*] --> IDLE
    IDLE --> NEGOTIATING: 用户触发流转
    NEGOTIATING --> CAP_NEGOTIATION: 设备能力交换
    CAP_NEGOTIATION --> SESSION_ESTABLISHING: 参数协商通过
    SESSION_ESTABLISHING --> STREAM_SWITCHING: 新 Session 建立成功
    STREAM_SWITCHING --> ACTIVE: 双向流量验证通过
    ACTIVE --> NEGOTIATING: 再次流转
    ACTIVE --> IDLE: 会议结束/异常断开
    
    note right of CAP_NEGOTIATION
        交换：编解码器能力集、最大分辨率、
        支持的码率档位、硬件加速支持情况
    end note
    
    note right of STREAM_SWITCHING
        关键步骤：
        1. 新端请求关键帧
        2. 旧端发送最后一帧 + END_MARK
        3. 新端渲染首帧后发送 ACK
        4. 旧端释放资源
    end note

// FlowTransferStateMachine.cpp
enum class TransferState { IDLE, NEGOTIATING, CAP_NEGOTIATION, 
                           SESSION_ESTABLISHING, STREAM_SWITCHING, ACTIVE };

class FlowTransferFSM {
public:
    void HandleEvent(TransferEvent event) {
        std::lock_guard lock(mutex_);
        auto it = transitions_.find({currentState_, event});
        if (it != transitions_.end()) {
            TransferState nextState = it->second.nextState;
            if (it->second.action) it->second.action();
            currentState_ = nextState;
            LOGI("State transition: %d -> %d", (int)currentState_, (int)nextState);
        }
    }

private:
    struct Transition { TransferState nextState; std::function<void()> action; };
    std::map<std::pair<TransferState, TransferEvent>, Transition> transitions_;
    TransferState currentState_ = TransferState::IDLE;
};

Session 建立(45ms) → 能力协商(12ms) → 请求关键帧(8ms) 
→ 编码输出(15ms) → 传输(22ms) → 解码(35ms) → 渲染提交(43ms) 
= 总计 ~180ms

// AdaptiveBitrateController.cpp
void AdaptiveBitrateController::OnNetworkQualityChanged(const QosInfo& qos) {
    // 基于丢包率、RTT、带宽估算的三维决策
    float score = 0.5f * (1.0f - qos.packetLossRate) 
                + 0.3f * (1.0f - std::min(qos.rttMs / 200.0f, 1.0f))
                + 0.2f * (std::min(qos.bandwidthMbps / 8.0f, 1.0f));
    
    BitrateTier targetTier = CalculateTier(score);
    if (targetTier != currentTier_) {
        encoder_->SetTargetBitrate(tierBitrateMap_[targetTier]);
        currentTier_ = targetTier;
        LOGI("ABR switch to tier %d, bitrate %d kbps", targetTier, tierBitrateMap_[targetTier]);
    }
}

// AudioCaptureConfig.cpp
AudioCapturerOptions GetCaptureOptions(bool isActiveDevice, 
                                       const std::string& referenceSessionName) {
    AudioCapturerOptions opts;
    opts.streamInfo.samplingRate = 48000;
    opts.streamInfo.channels = 2;
    opts.streamInfo.format = SAMPLE_F32LE;
    
    if (isActiveDevice) {
        opts.capturerFlags = AUDIO_FLAG_AEC_ENABLE | AUDIO_FLAG_NS_ENABLE;
        // 关键：绑定远端播放流作为参考
        opts.aecReferenceSession = referenceSessionName;  
    } else {
        opts.capturerFlags = 0;  // 非活跃设备不开麦
    }
    return opts;
}

#if __API_VERSION__ >= 11
    sessionAttr.linkType = LinkType::LINK_TYPE_WLAN | LinkType::LINK_TYPE_CELLULAR;
    sessionAttr.qosLevel = QosLevel::QOS_LEVEL_HIGH;
#else
    // 兼容层：手动绑定多网卡 Socket，应用层实现简单 QoS
    LegacyMultiPathBind(sessionHandle);
#endif

# 1. 查看软总线会话状态
hdc shell hidumper -s softbus -a "-s all"

# 2. 抓取软总线链路日志（需 root/开发者模式）
hdc shell "log -T -t SoftBus -s V | tee /data/local/tmp/softbus.log"

# 3. 模拟弱网/丢包（通过网络模拟器或 tc）
hdc shell "tc qdisc add dev wlan0 root netem loss 10% delay 50ms"

# 4. 性能分析：帧级耗时埋点导出
hdc file recv /data/app/el2/100/base/com.example.videoconf/haps/entry/files/perf_trace.json .

entry (主包, ~8MB)
├── feature_avcore (音视频核心引擎, ~4.2MB)     // 编解码、软总线适配、流转状态机
├── feature_screen_share (屏幕共享, ~1.1MB)     // 虚拟显示、编码、权限管理
├── feature_ai_enhance (AI 降噪/超分, ~3.5MB)   // MNN/NCNN 模型 + 推理引擎
└── feature_hw_codec (厂商硬编解码适配, ~0.8MB) // 麒麟/天玑/骁龙/紫光厂商插件

// build-profile.json5 片段
{
  "modules": [
    {
      "name": "feature_avcore",
      "type": "dynamicFeature",
      "deliveryWithInstall": false,
      "dependencies": [
        { "name": "libsoftbus_adapter.so", "version": ">=2.1.0" },
        { "name": "libh264_hw_encoder.so", "optional": true }
      ]
    }
  ]
}

// DynamicLoader.cpp - 安全加载策略
class AVModuleLoader {
public:
    static std::shared_ptr<IAVEngine> Load(const std::string& moduleName) {
        // 1. 校验签名哈希，防止注入
        if (!VerifyModuleSignature(moduleName)) return nullptr;
        
        // 2. dlopen RTLD_LOCAL 避免符号污染主进程
        void* handle = dlopen(modulePath.c_str(), RTLD_NOW | RTLD_LOCAL);
        if (!handle) { LOGE("dlopen failed: %s", dlerror()); return nullptr; }
        
        // 3. 版本兼容性协商
        auto getVersion = (VersionFunc)dlsym(handle, "GetAVEngineVersion");
        if (!getVersion || !CheckVersionCompat(getVersion())) {
            dlclose(handle); return nullptr;
        }
        
        auto create = (CreateFunc)dlsym(handle, "CreateAVEngine");
        return std::shared_ptr<IAVEngine>(create(), [handle](auto*){ dlclose(handle); });
    }
};

# build_config.py
DEVICE_PROFILES = {
    "phone":      {"ENABLE_HW_ENC": 1, "ENABLE_AI_DENOISE": 1, "MAX_LAYERS": 3},
    "tv":         {"ENABLE_HW_ENC": 0, "ENABLE_AI_DENOISE": 0, "MAX_LAYERS": 1},
    "watch":      {"ENABLE_HW_ENC": 0, "ENABLE_AI_DENOISE": 0, "MAX_LAYERS": 1, "AUDIO_ONLY": 1},
}

def gen_cmake_args(device_type):
    profile = DEVICE_PROFILES[device_type]
    args = [f"-D{k}={v}" for k,v in profile.items()]
    # LTO + 裁剪未使用符号
    args += ["-DCMAKE_INTERPROCEDURAL_OPTIMIZATION=ON", "-DSTRIP_UNUSED_SYMBOLS=ON"]
    return args

sequenceDiagram
    participant Phone as 手机(发起端)
    participant SoftBus as 分布式软总线
    participant Tablet as 平板(接力端)
    participant Collector as 采集器
    
    Phone->>Phone: 生成 TraceId (W3C traceparent)
    Phone->>SoftBus: WriteBytes(Frame + TraceId in Header)
    SoftBus-->>Tablet: OnBytesReceived
    Tablet->>Tablet: 解析 TraceId, 关联本地 Span
    Tablet->>Collector: 上报 Span (decode/render)
    Phone->>Collector: 上报 Span (encode/send)
    Collector->>Collector: 服务端拼接完整链路

// TraceContext.h
struct TraceContext {
    std::string traceId;      // 16字节 hex
    std::string spanId;       // 8字节 hex
    uint32_t  flags = 0x01;   // sampled
    
    // 序列化进帧头预留字段 (复用 AVFrameHeader.flags 高位)
    void InjectIntoFrame(AVFrameHeader* hdr) const;
    static TraceContext ExtractFromFrame(const AVFrameHeader* hdr);
};

// 编码端
void VideoEncoder::OnEncodeDone(const EncodedFrame& frame) {
    auto ctx = TraceContext::Current();
    ctx.InjectIntoFrame(frame.header);
    softBusSession_->Write(frame.data, frame.size);
}

// 解码端
void FrameReassembler::OnFrameReady(const CompleteFrame& frame) {
    TraceContext ctx = TraceContext::ExtractFromFrame(frame.header);
    auto span = tracer_->StartSpan("video.decode", {ctx.traceId, ctx.spanId});
    decoder_->Decode(frame, [span](auto result){ span->End(); });
}

# rca_rules.yaml
- name: "流转首帧超时"
  condition: "flow_transfer_first_frame_latency_ms_p99 > 500"
  actions:
    - query: "softbus_session_establish_latency_ms_p99 > 200"
      conclusion: "软总线建链慢，检查 LNN 组网耗时或设备发现延迟"
    - query: "encoder_request_keyframe_latency_ms_p99 > 100"
      conclusion: "编码器响应慢，检查硬编码器占用或驱动异常"
    - query: "decoder_init_latency_ms_p99 > 150"
      conclusion: "解码器冷启动，建议预热池扩容"

- name: "弱网下花屏激增"
  condition: "video_glitch_rate > 0.01% AND network_packet_loss > 5%"
  actions:
    - check: "abr_bitrate_tier == LOWEST"
      conclusion: "已降至最低码率仍花屏，建议触发降分辨率或开启 FEC"

# 1. 加载 eBPF 程序捕获软总线发送/接收路径
hdc shell "bpftool prog load /system/bpf/softbus_trace.bpf.o /sys/fs/bpf/softbus_trace"

# 2. 挂载到内核 tracepoint
hdc shell "bpftool prog attach pinned /sys/fs/bpf/softbus_trace tracepoint net:netif_receive_skb"
hdc shell "bpftool prog attach pinned /sys/fs/bpf/softbus_trace tracepoint net:net_dev_xmit"

# 3. 用户态符号化映射 (需提前推送符号表)
hdc shell "bpftool map update pinned /sys/fs/bpf/symbol_map key 0 1 2 3 value < /data/symbols/softbus_adapter.sym"

TIME(s)   COMM        PID    LAT(us)  EVENT              DETAIL
12.345    videoconf   1234   1.2      softbus_write      session=0x7f8a, len=1460, qos=HIGH
12.346    kernel      -      0.8      wifi_tx            skb=0xfff, len=1500, retry=0
12.347    videoconf   5678   0.5      softbus_read       session=0x7f8a, len=1460, seq=1024

// device_capability_profile.json (云端下发 + 本地缓存)
{
  "deviceId": "tablet_pro_12_2024",
  "formFactor": "TABLET",
  "screen": { "width": 2800, "height": 1840, "density": 2.5, "refreshRate": [60, 144] },
  "codec": {
    "hwDecoder": ["H264", "HEVC", "VP9", "AV1"],
    "hwEncoder": ["H264", "HEVC"],
    "maxDecodeResolution": "8K@30fps",
    "maxEncodeResolution": "4K@60fps",
    "secureDecode": true
  },
  "audio": { "micCount": 4, "speakerType": "stereo", "supportsAEC": true, "supportsSpatialAudio": true },
  "network": { "wifi": "wifi6", "cellular": "5G", "bluetooth": "5.3" },
  "thermal": { "throttlingThreshold": 42, "sustainedPowerW": 5.5 },
  "battery": { "capacityMah": 10000, "isCharging": false }
}

// AdaptivePolicyEngine.cpp
struct StreamConfig AdaptivePolicyEngine::DecideConfig(const DeviceProfile& local, 
                                                       const DeviceProfile& remote,
                                                       const NetworkQoS& qos) {
    StreamConfig cfg;
    
    // 1. 分辨率决策：取双端屏幕较小边、编码能力上限、带宽估算三者最小值
    cfg.targetResolution = CalculateOptimalResolution(local, remote, qos.bandwidthEstimateMbps);
    
    // 2. 编码器选择：优先硬编，回退软编；HEVC > H264 (带宽省 30%)
    cfg.codecType = SelectCodec(local.codec.hwEncoder, remote.codec.hwDecoder, qos);
    
    // 3. 码率档位：基于带宽 * 0.85 安全系数，叠加热节流降级
    cfg.targetBitrate = CalculateBitrate(qos, local.thermal);
    
    // 4. 并发流数：智慧屏/车机支持双流(主流+辅流)，手机单流
    cfg.maxSimulcastLayers = (local.formFactor == "TV" || local.formFactor == "CAR") ? 2 : 1;
    
    // 5. 音频策略：车机/会议室强制开启 AEC+AGC+ANS，手表仅 Opus 16kbps
    cfg.audioProfile = SelectAudioProfile(local, remote);
    
    return cfg;
}

// ISoftBusAdapter.h (稳定接口层)
class ISoftBusAdapter {
public:
    virtual ~ISoftBusAdapter() = default;
    virtual int32_t CreateSession(const SessionParam& param) = 0;
    virtual int32_t SendBytes(int sessionId, const void* data, size_t len) = 0;
    virtual void RegisterListener(ISessionListener* listener) = 0;
    // ... 统一接口
};

// SoftBusAdapterV1.cpp (API 9/10 实现)
class SoftBusAdapterV1 : public ISoftBusAdapter {
    // 封装同步阻塞 API，内部用线程池异步化
    int32_t CreateSession(const SessionParam& param) override {
        return CreateSessionServerSync(param.name, param.attr); // 旧版同步 API
    }
};

// SoftBusAdapterV2.cpp (API 11+ 实现)
class SoftBusAdapterV2 : public ISoftBusAdapter {
    // 原生异步 + Promise + QoS 标准接口
    int32_t CreateSession(const SessionParam& param) override {
        return Session::CreateSessionServerAsync(param.name, param.attr).get();
    }
};

// Factory.cpp (运行时工厂)
std::unique_ptr<ISoftBusAdapter> CreateSoftBusAdapter() {
    if (SystemApiVersion::Get() >= 11) return std::make_unique<SoftBusAdapterV2>();
    return std::make_unique<SoftBusAdapterV1>();
}

        ┌─────────────────────┐
        │  E2E 真机集成测试    │  ← 50+ 设备矩阵，每日构建跑全量
        │  (流转全链路、弱网、 │
        │   兼容性、长稳)      │
        ├─────────────────────┤
        │  契约测试            │  ← 接口契约、软总线协议兼容性
        │  (Provider/Consumer) │
        ├─────────────────────┤
        │  集成测试            │  ← 模块间交互：编码器+软总线、解码器+渲染
        │  (Hardware-in-loop)  │
        ├─────────────────────┤
        │  单元测试            │  ← 覆盖率 > 85%，核心状态机 100%
        │  (GTest + Mock)      │
        └─────────────────────┘

# test_flow_transfer_suite.py
class FlowTransferTestSuite(unittest.TestCase):
    
    @parameterized.expand([
        ("phone_to_tablet", "phone", "tablet", "wifi"),
        ("tablet_to_tv", "tablet", "tv", "wifi"),
        ("phone_to_watch", "phone", "watch", "ble"),
        ("tv_to_phone_cellular", "tv", "phone", "cellular"),  # 跨网段兜底
    ])
    def test_seamless_transfer_1080p30(self, name, src, dst, net):
        """核心流转用例：验证首帧延迟、无花屏、音频无断点"""
        with DeviceFarm(src) as d1, DeviceFarm(dst) as d2:
            # 1. 建立会议
            meeting_id = d1.start_meeting(resolution="1080p", fps=30)
            d2.join_meeting(meeting_id)
            wait_until_stable(d1, d2, timeout=10)
            
            # 2. 触发流转
            trace_id = d2.initiate_transfer()
            
            # 3. 多维度断言
            self.assertLess(get_first_frame_latency(trace_id), 300, "首帧超时")
            self.assertEqual(get_audio_glitch_count(trace_id), 0, "音频断点")
            self.assertLess(get_video_glitch_rate(trace_id), 0.0001, "花屏率超标")
            self.assertTrue(verify_session_encrypted(trace_id), "加密失效")
            
            # 4. 状态一致性校验
            self.assertEqual(d1.get_meeting_state(), "TRANSFERRED_OUT")
            self.assertEqual(d2.get_meeting_state(), "ACTIVE")

    def test_weak_network_resilience(self):
        """弱网 30% 丢包 + 200ms 抖动下连续流转 10 次"""
        with NetworkEmulator(loss=30, jitter=200) as net:
            for i in range(10):
                self.assertTrue(perform_transfer("phone", "tablet"), f"第 {i+1} 次失败")
                time.sleep(random.uniform(2, 5))

{
  "sessionDefaults": {
    "video": {
      "linkType": "WLAN|CELLULAR|BR",
      "streamType": "COMMON",
      "qosLevel": "HIGH",
      "encrypt": "AES_GCM",
      "sendTimeoutMs": 500,
      "maxFrameSize": 65536,
      "initialWindow": 10,
      "enableFec": true,
      "fecRedundancyRatio": 0.15
    },
    "audio": {
      "linkType": "WLAN|BR",
      "streamType": "RELIABLE",
      "qosLevel": "HIGH",
      "encrypt": "AES_GCM",
      "sendTimeoutMs": 200
    },
    "signaling": {
      "linkType": "WLAN|BR|CELLULAR",
      "streamType": "RELIABLE",
      "qosLevel": "HIGH",
      "encrypt": "AES_GCM"
    }
  },
  "deviceSpecificOverrides": {
    "tv": { "video": { "enableFec": false, "initialWindow": 20 } },
    "watch": { "video": { "maxFrameSize": 16384 }, "audio": { "bitrateKbps": 16 } }
  }
}

#!/bin/bash
# 用法: ./diag_flow_transfer.sh <会议ID> [设备序列号]
# 功能: 自动抓取双端日志、软总线状态、性能指标、生成 HTML 报告

set -euo pipefail
MEETING_ID=$1
DEVICE_SN=${2:-$(hdc list targets | head -1)}

OUT_DIR="diag_${MEETING_ID}_$(date +%Y%m%d_%H%M%S)"
mkdir -p "$OUT_DIR"

echo "[1/6] 抓取应用日志..."
hdc -t "$DEVICE_SN" file recv /data/app/el2/100/base/com.example.videoconf/haps/entry/files/logs/ "$OUT_DIR/app_logs/"

echo "[2/6] 抓取软总线内核态日志..."
hdc -t "$DEVICE_SN" shell "hidumper -s softbus -a '-s all -t 30'" > "$OUT_DIR/softbus_dump.txt"

echo "[3/6] 抓取音频/视频媒体服务日志..."
hdc -t "$DEVICE_SN" shell "hidumper -s media -a '-a'" > "$OUT_DIR/media_dump.txt"

echo "[4/6] 采集网络质量快照..."
hdc -t "$DEVICE_SN" shell "netstat -s | grep -E 'segments retransmited|packet loss'" > "$OUT_DIR/netstat.txt"
hdc -t "$DEVICE_SN" shell "cat /proc/net/softbus/qos_stats" > "$OUT_DIR/qos_stats.txt" 2>/dev/null || true

echo "[5/6] 导出性能埋点数据..."
hdc -t "$DEVICE_SN" file recv /data/app/el2/100/base/com.example.videoconf/haps/entry/files/perf/ "$OUT_DIR/perf/"

echo "[6/6] 生成分析报告..."
python3 generate_report.py --meeting-id "$MEETING_ID" --input-dir "$OUT_DIR" --output "$OUT_DIR/report.html"

echo "✅ 诊断包已生成: $OUT_DIR/report.html"

harmony-distributed-av-transfer/
├── av_core/                    # 核心引擎 (C++ 共享库)
│   ├── encoder/                # 编码器抽象 + 硬/软编实现
│   ├── decoder/                # 解码器抽象 + 硬/软解实现
│   ├── softbus/                # 软总线适配层 (V1/V2 双实现)
│   ├── protocol/               # 帧协议、分片重组、FEC
│   ├── fsm/                    # 流转状态机
│   ├── qos/                    # ABR、抖动缓冲、双链路调度
│   └── trace/                  # OpenTelemetry 埋点
├── av_sdk/                     # 对外发布 SDK (OHAR)
│   ├── include/                # 稳定 C/C++ 头文件
│   ├── libs/                   # arm64/x64 .so + 符号表
│   └── docs/                   # 接入指南、API 参考
├── samples/                    # 样板工程
│   ├── phone_meeting/          # 手机端完整会议 App
│   ├── tv_receiver/            # 智慧屏接力端
│   └── watch_audio_only/       # 手表纯音频端
├── testing/                    # 自动化测试套件
│   ├── unit/                   # GTest 单测
│   ├── integration/            # 设备农场集成测试
│   ├── contract/               # Pact 契约测试
│   └── perf/                   # 基线性能脚本
├── tools/                      # 诊断、符号化、打包脚本
└── docs/                       # 架构决策记录 (ADR)、威胁建模、合规清单