HarmonyOS开发：车辆远程控制——你的手机就是车钥匙

📌 核心要点：远程控车的核心不是发送指令，而是指令安全与认证——每一道控制指令都涉及车辆安全，加密、防重放、状态反馈缺一不可。

背景与动机

大夏天，车在露天停车场晒了三个小时。你走过去拉开车门，一股热浪扑面而来，方向盘烫得不敢碰。

要是能在办公室里先用手机把空调打开，等走到车旁边已经凉快了，多好？

这就是远程控车的典型场景。空调、车窗、车门、后备箱、座椅加热……这些功能从"必须站在车旁边操作"变成"随时随地远程操作"，体验提升是质变。

但远程控车不是发个HTTP请求那么简单。你远程打开车门，万一指令被人截获重放呢？你远程启动空调，怎么确认空调真的启动了？你连续发了三条开窗指令，车窗是开三次还是只开一次？

这些问题不解决，远程控车就不是便利，而是安全隐患。

核心原理

远程控车指令通道

远程控车的指令通道不是直接从手机到车——中间要经过云端服务、T-Box（车载通信终端）、CAN总线好几层转发。

graph LR
    A[手机App] -->|加密指令| B[云端服务]
    B -->|推送通道| C[T-Box 车载终端]
    C -->|CAN指令| D[车身控制器 BCM]
    D --> E[执行动作]
    
    E -->|执行结果| D
    D -->|CAN反馈| C
    C -->|上报| B
    B -->|推送| A
    
    B --> F[指令日志审计]
    C --> G[本地安全校验]

    classDef phone fill:#4CAF50,stroke:#2E7D32,color:#fff
    classDef cloud fill:#2196F3,stroke:#1565C0,color:#fff
    classDef car fill:#FF9800,stroke:#E65100,color:#fff
    classDef action fill:#E91E63,stroke:#880E4F,color:#fff
    classDef security fill:#9C27B0,stroke:#6A1B9A,color:#fff

    class A phone
    class B,F cloud
    class C,G car
    class D,E action

指令安全三要素

远程控车的安全性由三个要素保障：

其中防重放最容易被忽略。攻击者截获了一条"打开车门"的指令，原样重发一次，车门又开了——这就是重放攻击。解决方案是在每条指令里加上时间戳和递增序列号，服务端检查时间戳是否在合理窗口内（比如±30秒），序列号是否递增。

控制状态反馈

远程控车是异步操作——你发了指令，不代表动作已经执行。必须等车端返回执行结果，才能确认操作成功。

状态反馈的三种模式：

1. 即时反馈：车门、车灯等快速响应的操作，1-3秒内返回结果
2. 延迟反馈：空调、座椅加热等需要时间生效的操作，返回"已启动"而非"已生效"
3. 超时无反馈：网络异常或T-Box离线，30秒内无响应，判定为超时

代码实战

基础用法：远程控制空调

从最常见的场景开始——远程控制空调。包括开启/关闭、设置温度、风量调节。

// RemoteClimateControl.ets - 远程空调控制
import { car } from '@kit.CarKit';
import { util } from '@kit.ArkTS';

// 空调控制参数
export interface ClimateParams {
  power: boolean;       // 开关
  temperature: number;  // 目标温度 16-32°C
  fanSpeed: number;     // 风量 1-7档
  mode: string;         // 模式：cool/heat/auto/defrost
}

// 控制结果
export interface ControlResult {
  success: boolean;
  message: string;
  timestamp: number;
}

export class RemoteClimateControl {
  private carControl: car.CarControl | null = null;
  private commandTimeout: number = 30000; // 30秒超时

  async init(carControl: car.CarControl): Promise<void> {
    this.carControl = carControl;
  }

  // 远程开启空调
  async turnOnAC(temperature: number = 24, fanSpeed: number = 3): Promise<ControlResult> {
    if (!this.carControl) {
      return { success: false, message: 'CarControl未初始化', timestamp: Date.now() };
    }

    try {
      // 构建控制指令
      const command: car.ClimateControlCommand = {
        power: true,
        temperature: temperature,
        fanSpeed: fanSpeed,
        mode: car.ClimateMode.COOL,
        // 安全字段：时间戳 + 随机数防重放
        timestamp: Date.now(),
        nonce: this.generateNonce(),
      };

      // 发送指令并等待结果
      const result = await this.sendCommandWithTimeout(
        () => this.carControl!.setClimateControl(command),
        this.commandTimeout
      );

      if (result.success) {
        console.info(`[Remote] 空调已开启: ${temperature}°C, ${fanSpeed}档`);
      }
      return result;
    } catch (err) {
      return {
        success: false,
        message: `空调控制失败: ${(err as Error).message}`,
        timestamp: Date.now(),
      };
    }
  }

  // 远程关闭空调
  async turnOffAC(): Promise<ControlResult> {
    if (!this.carControl) {
      return { success: false, message: 'CarControl未初始化', timestamp: Date.now() };
    }

    try {
      const command: car.ClimateControlCommand = {
        power: false,
        timestamp: Date.now(),
        nonce: this.generateNonce(),
      };

      return await this.sendCommandWithTimeout(
        () => this.carControl!.setClimateControl(command),
        this.commandTimeout
      );
    } catch (err) {
      return {
        success: false,
        message: `关闭空调失败: ${(err as Error).message}`,
        timestamp: Date.now(),
      };
    }
  }

  // 设置空调温度
  async setTemperature(temperature: number): Promise<ControlResult> {
    if (temperature < 16 || temperature > 32) {
      return { success: false, message: '温度范围16-32°C', timestamp: Date.now() };
    }

    if (!this.carControl) {
      return { success: false, message: 'CarControl未初始化', timestamp: Date.now() };
    }

    try {
      const command: car.ClimateControlCommand = {
        power: true,
        temperature: temperature,
        timestamp: Date.now(),
        nonce: this.generateNonce(),
      };

      return await this.sendCommandWithTimeout(
        () => this.carControl!.setClimateControl(command),
        this.commandTimeout
      );
    } catch (err) {
      return {
        success: false,
        message: `设置温度失败: ${(err as Error).message}`,
        timestamp: Date.now(),
      };
    }
  }

  // 带超时的指令发送
  private async sendCommandWithTimeout(
    sendFn: () => Promise<car.ControlResponse>,
    timeout: number
  ): Promise<ControlResult> {
    return new Promise((resolve) => {
      const timer = setTimeout(() => {
        resolve({
          success: false,
          message: '指令超时，请检查网络连接',
          timestamp: Date.now(),
        });
      }, timeout);

      sendFn()
        .then((response) => {
          clearTimeout(timer);
          resolve({
            success: response.resultCode === 0,
            message: response.resultCode === 0 ? '操作成功' : `操作失败: ${response.errorMessage}`,
            timestamp: Date.now(),
          });
        })
        .catch((err: Error) => {
          clearTimeout(timer);
          resolve({
            success: false,
            message: err.message,
            timestamp: Date.now(),
          });
        });
    });
  }

  // 生成随机数（防重放）
  private generateNonce(): string {
    const random = new util.Random();
    return random.randomInt(0, 999999).toString().padStart(6, '0');
  }
}

进阶用法：车窗与车门远程控制

车窗和车门的控制比空调更敏感——空调开错了顶多费点油，车门开错了可能丢东西。所以安全等级更高。

// RemoteDoorWindowControl.ets - 车门窗远程控制
import { car } from '@kit.CarKit';

// 车门位置
export type DoorPosition = 'frontLeft' | 'frontRight' | 'rearLeft' | 'rearRight' | 'trunk';
// 车窗位置
export type WindowPosition = 'frontLeft' | 'frontRight' | 'rearLeft' | 'rearRight';

// 车门状态
export interface DoorStatus {
  position: DoorPosition;
  isLocked: boolean;   // 是否锁止
  isOpen: boolean;     // 是否打开
}

// 车窗状态
export interface WindowStatus {
  position: WindowPosition;
  isOpen: number;      // 开度 0-100%
}

export class RemoteDoorWindowControl {
  private carControl: car.CarControl | null = null;
  // 二次确认回调
  private onConfirmRequired?: (action: string, callback: (confirmed: boolean) => void) => void;

  async init(carControl: car.CarControl): Promise<void> {
    this.carControl = carControl;
  }

  // 设置二次确认回调（安全操作需要用户确认）
  setConfirmHandler(
    handler: (action: string, callback: (confirmed: boolean) => void) => void
  ): void {
    this.onConfirmRequired = handler;
  }

  // 远程解锁车门
  async unlockDoor(position: DoorPosition): Promise<ControlResult> {
    // 解锁车门属于高风险操作，需要二次确认
    return new Promise((resolve) => {
      this.requireConfirm(`解锁${this.getDoorName(position)}`, async (confirmed) => {
        if (!confirmed) {
          resolve({ success: false, message: '用户取消操作', timestamp: Date.now() });
          return;
        }

        try {
          const result = await this.carControl!.setDoorControl({
            position: this.mapDoorPosition(position),
            action: car.DoorAction.UNLOCK,
            timestamp: Date.now(),
            nonce: this.generateNonce(),
          });

          resolve({
            success: result.resultCode === 0,
            message: result.resultCode === 0 ? `${this.getDoorName(position)}已解锁` : '解锁失败',
            timestamp: Date.now(),
          });
        } catch (err) {
          resolve({
            success: false,
            message: `解锁失败: ${(err as Error).message}`,
            timestamp: Date.now(),
          });
        }
      });
    });
  }

  // 远程锁车
  async lockAllDoors(): Promise<ControlResult> {
    if (!this.carControl) {
      return { success: false, message: 'CarControl未初始化', timestamp: Date.now() };
    }

    try {
      const result = await this.carControl.setDoorControl({
        position: car.DoorPosition.ALL,
        action: car.DoorAction.LOCK,
        timestamp: Date.now(),
        nonce: this.generateNonce(),
      });

      return {
        success: result.resultCode === 0,
        message: result.resultCode === 0 ? '全车已锁止' : '锁车失败',
        timestamp: Date.now(),
      };
    } catch (err) {
      return {
        success: false,
        message: `锁车失败: ${(err as Error).message}`,
        timestamp: Date.now(),
      };
    }
  }

  // 远程打开车窗
  async openWindow(position: WindowPosition, percentage: number = 50): Promise<ControlResult> {
    if (!this.carControl) {
      return { success: false, message: 'CarControl未初始化', timestamp: Date.now() };
    }

    // 安全限制：行车中禁止开窗
    // 实际应通过VehicleManager检查车速

    try {
      const result = await this.carControl.setWindowControl({
        position: this.mapWindowPosition(position),
        action: car.WindowAction.OPEN,
        percentage: Math.min(100, Math.max(0, percentage)),
        timestamp: Date.now(),
        nonce: this.generateNonce(),
      });

      return {
        success: result.resultCode === 0,
        message: result.resultCode === 0
          ? `${this.getWindowName(position)}已打开${percentage}%`
          : '开窗失败',
        timestamp: Date.now(),
      };
    } catch (err) {
      return {
        success: false,
        message: `开窗失败: ${(err as Error).message}`,
        timestamp: Date.now(),
      };
    }
  }

  // 远程关闭所有车窗
  async closeAllWindows(): Promise<ControlResult> {
    if (!this.carControl) {
      return { success: false, message: 'CarControl未初始化', timestamp: Date.now() };
    }

    try {
      const result = await this.carControl.setWindowControl({
        position: car.WindowPosition.ALL,
        action: car.WindowAction.CLOSE,
        percentage: 0,
        timestamp: Date.now(),
        nonce: this.generateNonce(),
      });

      return {
        success: result.resultCode === 0,
        message: result.resultCode === 0 ? '全车窗已关闭' : '关窗失败',
        timestamp: Date.now(),
      };
    } catch (err) {
      return {
        success: false,
        message: `关窗失败: ${(err as Error).message}`,
        timestamp: Date.now(),
      };
    }
  }

  // 二次确认
  private requireConfirm(action: string, callback: (confirmed: boolean) => void): void {
    if (this.onConfirmRequired) {
      this.onConfirmRequired(action, callback);
    } else {
      // 没有设置确认回调，默认允许
      callback(true);
    }
  }

  // 位置映射
  private mapDoorPosition(pos: DoorPosition): number {
    const map: Record<string, number> = {
      frontLeft: car.DoorPosition.FRONT_LEFT,
      frontRight: car.DoorPosition.FRONT_RIGHT,
      rearLeft: car.DoorPosition.REAR_LEFT,
      rearRight: car.DoorPosition.REAR_RIGHT,
      trunk: car.DoorPosition.TRUNK,
    };
    return map[pos] || car.DoorPosition.ALL;
  }

  private mapWindowPosition(pos: WindowPosition): number {
    const map: Record<string, number> = {
      frontLeft: car.WindowPosition.FRONT_LEFT,
      frontRight: car.WindowPosition.FRONT_RIGHT,
      rearLeft: car.WindowPosition.REAR_LEFT,
      rearRight: car.WindowPosition.REAR_RIGHT,
    };
    return map[pos] || car.WindowPosition.ALL;
  }

  private getDoorName(pos: DoorPosition): string {
    const names: Record<string, string> = {
      frontLeft: '左前门', frontRight: '右前门',
      rearLeft: '左后门', rearRight: '右后门', trunk: '后备箱',
    };
    return names[pos] || pos;
  }

  private getWindowName(pos: WindowPosition): string {
    const names: Record<string, string> = {
      frontLeft: '左前窗', frontRight: '右前窗',
      rearLeft: '左后窗', rearRight: '右后窗',
    };
    return names[pos] || pos;
  }

  private generateNonce(): string {
    return Math.random().toString(36).substring(2, 8);
  }
}

完整示例：远程控车主页面

把空调、车窗、车门的控制整合到一个页面里，带状态反馈和二次确认。

// RemoteControlPage.ets - 远程控车主页面
@Entry
@Component
struct RemoteControlPage {
  @State acPower: boolean = false;
  @State acTemperature: number = 24;
  @State acFanSpeed: number = 3;
  @State doorLocked: boolean = true;
  @State windowOpen: number = 0;
  @State lastResult: string = '';
  @State showConfirm: boolean = false;
  @State confirmAction: string = '';
  @State confirmCallback: ((confirmed: boolean) => void) | null = null;

  build() {
    Column({ space: 20 }) {
      // 标题
      Row() {
        Text('远程控车')
          .fontSize(24)
          .fontWeight(FontWeight.Bold)
          .fontColor(Color.White)
        Text(this.lastResult)
          .fontSize(13)
          .fontColor('#4CAF50')
          .margin({ left: 16 })
      }
      .width('100%')
      .padding({ left: 30, top: 20 })

      Scroll() {
        Column({ space: 16 }) {
          // 空调控制卡片
          this.ClimateCard()

          // 车门控制卡片
          this.DoorCard()

          // 车窗控制卡片
          this.WindowCard()
        }
        .padding({ left: 30, right: 30, bottom: 30 })
      }
      .layoutWeight(1)
    }
    .width('100%')
    .height('100%')
    .backgroundColor('#0D1117')
    .bindContentCover(this.showConfirm, this.ConfirmDialog(), {
      modalTransition: ModalTransition.NONE,
    })
  }

  // 空调控制卡片
  @Builder
  ClimateCard() {
    Column({ space: 16 }) {
      Row() {
        Text('空调控制')
          .fontSize(18)
          .fontWeight(FontWeight.Medium)
          .fontColor(Color.White)
        Toggle({ type: ToggleType.Switch, isOn: this.acPower })
          .onChange((isOn: boolean) => {
            this.acPower = isOn;
            this.lastResult = isOn ? '空调已开启' : '空调已关闭';
          })
          .selectedColor('#4CAF50')
      }
      .width('100%')
      .justifyContent(FlexAlign.SpaceBetween)

      if (this.acPower) {
        // 温度调节
        Row({ space: 12 }) {
          Text('温度')
            .fontSize(16)
            .fontColor('#AAAAAA')
            .width(50)
          Button('-')
            .width(48)
            .height(48)
            .fontSize(20)
            .backgroundColor('#2A2A3E')
            .fontColor(Color.White)
            .onClick(() => {
              this.acTemperature = Math.max(16, this.acTemperature - 1);
            })
          Text(`${this.acTemperature}°C`)
            .fontSize(24)
            .fontWeight(FontWeight.Bold)
            .fontColor('#4FC3F7')
            .width(80)
            .textAlign(TextAlign.Center)
          Button('+')
            .width(48)
            .height(48)
            .fontSize(20)
            .backgroundColor('#2A2A3E')
            .fontColor(Color.White)
            .onClick(() => {
              this.acTemperature = Math.min(32, this.acTemperature + 1);
            })
        }

        // 风量调节
        Row({ space: 8 }) {
          Text('风量')
            .fontSize(16)
            .fontColor('#AAAAAA')
            .width(50)
          ForEach([1, 2, 3, 4, 5, 6, 7], (level: number) => {
            Column()
              .width(24)
              .height(level <= this.acFanSpeed ? 16 + level * 4 : 12)
              .backgroundColor(level <= this.acFanSpeed ? '#4FC3F7' : '#333333')
              .borderRadius(4)
              .onClick(() => {
                this.acFanSpeed = level;
              })
          })
        }
      }
    }
    .width('100%')
    .padding(20)
    .backgroundColor('#161B22')
    .borderRadius(16)
  }

  // 车门控制卡片
  @Builder
  DoorCard() {
    Column({ space: 16 }) {
      Text('车门控制')
        .fontSize(18)
        .fontWeight(FontWeight.Medium)
        .fontColor(Color.White)

      Row({ space: 16 }) {
        Button(this.doorLocked ? '解锁车门' : '锁止车门')
          .fontSize(16)
          .fontColor(Color.White)
          .backgroundColor(this.doorLocked ? '#FF9800' : '#4CAF50')
          .borderRadius(12)
          .width(160)
          .height(56)
          .onClick(() => {
            // 解锁需要二次确认
            if (this.doorLocked) {
              this.showConfirmDialog('确认解锁车门？', (confirmed) => {
                if (confirmed) {
                  this.doorLocked = false;
                  this.lastResult = '车门已解锁';
                }
              });
            } else {
              this.doorLocked = true;
              this.lastResult = '车门已锁止';
            }
          })

        Button('后备箱')
          .fontSize(16)
          .fontColor(Color.White)
          .backgroundColor('#2A2A3E')
          .borderRadius(12)
          .width(120)
          .height(56)
          .onClick(() => {
            this.showConfirmDialog('确认打开后备箱？', (confirmed) => {
              if (confirmed) {
                this.lastResult = '后备箱已打开';
              }
            });
          })
      }
    }
    .width('100%')
    .padding(20)
    .backgroundColor('#161B22')
    .borderRadius(16)
    .alignItems(HorizontalAlign.Start)
  }

  // 车窗控制卡片
  @Builder
  WindowCard() {
    Column({ space: 16 }) {
      Text('车窗控制')
        .fontSize(18)
        .fontWeight(FontWeight.Medium)
        .fontColor(Color.White)

      Row({ space: 16 }) {
        Text('开度')
          .fontSize(16)
          .fontColor('#AAAAAA')
        Slider({
          value: this.windowOpen,
          min: 0,
          max: 100,
          step: 10,
          style: SliderStyle.OutSet,
        })
          .width('60%')
          .trackColor('#333333')
          .selectedColor('#4FC3F7')
          .onChange((value: number) => {
            this.windowOpen = value;
          })
        Text(`${this.windowOpen}%`)
          .fontSize(16)
          .fontColor('#4FC3F7')
          .width(50)
      }

      Row({ space: 12 }) {
        Button('全关')
          .fontSize(14)
          .fontColor(Color.White)
          .backgroundColor('#2A2A3E')
          .borderRadius(8)
          .width(80)
          .height(40)
          .onClick(() => { this.windowOpen = 0; })
        Button('半开')
          .fontSize(14)
          .fontColor(Color.White)
          .backgroundColor('#2A2A3E')
          .borderRadius(8)
          .width(80)
          .height(40)
          .onClick(() => { this.windowOpen = 50; })
        Button('全开')
          .fontSize(14)
          .fontColor(Color.White)
          .backgroundColor('#2A2A3E')
          .borderRadius(8)
          .width(80)
          .height(40)
          .onClick(() => { this.windowOpen = 100; })
      }
    }
    .width('100%')
    .padding(20)
    .backgroundColor('#161B22')
    .borderRadius(16)
    .alignItems(HorizontalAlign.Start)
  }

  // 二次确认弹窗
  @Builder
  ConfirmDialog() {
    Column({ space: 20 }) {
      Text('安全确认')
        .fontSize(20)
        .fontWeight(FontWeight.Bold)
        .fontColor(Color.White)
      Text(this.confirmAction)
        .fontSize(16)
        .fontColor('#CCCCCC')
      
      Row({ space: 16 }) {
        Button('取消')
          .fontSize(16)
          .fontColor(Color.White)
          .backgroundColor('#555555')
          .borderRadius(12)
          .width(120)
          .height(48)
          .onClick(() => {
            this.showConfirm = false;
            this.confirmCallback?.(false);
          })
        Button('确认')
          .fontSize(16)
          .fontColor(Color.White)
          .backgroundColor('#F44336')
          .borderRadius(12)
          .width(120)
          .height(48)
          .onClick(() => {
            this.showConfirm = false;
            this.confirmCallback?.(true);
          })
      }
    }
    .width(360)
    .padding(30)
    .backgroundColor('#1E1E2E')
    .borderRadius(20)
  }

  // 显示确认弹窗
  private showConfirmDialog(action: string, callback: (confirmed: boolean) => void): void {
    this.confirmAction = action;
    this.confirmCallback = callback;
    this.showConfirm = true;
  }
}

踩坑与注意事项

坑1：指令超时处理

远程控车指令经过云端→T-Box→CAN总线多层转发，延迟不可控。正常情况1-3秒返回，网络差的时候可能10秒以上。

你必须设置超时时间，而且超时后不能假设操作失败——可能指令已经到达车端并执行了，只是反馈消息丢了。

正确处理：

• 超时后提示"操作超时，请检查车辆状态"，而不是"操作失败"
• 超时后主动查询车辆当前状态，确认操作是否实际执行
• 不要自动重试——如果指令已经执行了，重试可能导致重复操作

坑2：车窗防夹功能

远程关窗时，车窗的防夹功能是必须考虑的。如果车窗关闭过程中检测到障碍物，会自动回弹。

但远程控制时你看不到车窗附近有没有东西。如果用户远程关窗，车窗夹到东西又弹开了，用户以为关好了，实际上窗户是开着的。

解决方案：关窗指令执行后，必须查询车窗实际状态并反馈给用户。

坑3：T-Box离线

T-Box（车载通信终端）是远程控车的关键节点。如果T-Box离线（车辆停在地下车库没信号，或者T-Box故障），你的指令根本到不了车端。

T-Box离线时，你应该：

• 明确提示"车辆当前离线，无法远程控制"
• 提供指令缓存功能——用户发的指令先缓存，等T-Box上线后自动发送
• 但缓存指令有时效性，超过5分钟的指令应该自动丢弃（防止用户已经到车旁边手动操作了，远程指令又来了）

坑4：并发控制

用户可能同时操作多个控制项——一边开空调一边开窗。如果两条指令几乎同时发出，T-Box可能只处理了其中一条。

解决方案：

• 对同一类控制指令做串行化处理——前一条指令返回结果后再发下一条
• 不同类的控制指令可以并行（空调和车窗不冲突）
• 加指令序列号，确保车端按顺序执行

坑5：权限分级

远程控车的不同操作需要不同等级的权限：

车门解锁这种高风险操作，光登录不够，必须做二次验证。你的应用如果不做权限分级，要么安全不达标，要么用户体验太差（每次看个油量都要指纹验证）。

HarmonyOS 6适配说明

HarmonyOS 6在远程控车方面做了几项重要更新：

1. 指令安全增强：新增端到端加密通道，指令不再经过云端明文中转。之前指令是手机→云端（加密）→T-Box（解密再加密）→BCM，中间云端能看到指令内容。HarmonyOS 6支持端到端加密，云端只做转发，无法解密。

2. 生物认证集成：新增car.authenticateForControl()接口，直接调用系统的生物认证（指纹/面容/虹膜），不需要你自己实现认证UI。

3. 指令状态机：新增指令状态追踪，每条指令从"已发送"→“已送达”→“执行中”→“已完成/失败”，全程可追踪。之前只有成功/失败两种状态，中间过程不可见。

4. 地理围栏安全：新增地理围栏校验——某些高风险操作（如车门解锁）只能在车辆附近（蓝牙范围）执行，远程（不在车辆附近）时需要额外验证。

适配代码：

// HarmonyOS 6 生物认证 + 指令追踪
import { car } from '@kit.CarKit';

async function unlockDoorSecurely(carControl: car.CarControl): Promise<void> {
  // 生物认证
  const authResult = await car.authenticateForControl({
    operation: 'UNLOCK_DOOR',
    authType: car.AuthType.BIOMETRIC, // 生物认证
    promptMessage: '请验证身份以解锁车门',
  });

  if (!authResult.success) {
    console.error('[Remote] 身份验证失败');
    return;
  }

  // 发送指令并追踪状态
  const commandId = await carControl.setDoorControl({
    position: car.DoorPosition.ALL,
    action: car.DoorAction.UNLOCK,
    timestamp: Date.now(),
    nonce: Math.random().toString(36).substring(2, 8),
    authToken: authResult.token, // 认证Token
  });

  // 监听指令状态变化
  carControl.on('commandStatusChange', (id: string, status: car.CommandStatus) => {
    if (id === commandId) {
      switch (status) {
        case car.CommandStatus.DELIVERED:
          console.info('[Remote] 指令已送达车端');
          break;
        case car.CommandStatus.EXECUTING:
          console.info('[Remote] 指令执行中');
          break;
        case car.CommandStatus.COMPLETED:
          console.info('[Remote] 车门已解锁');
          break;
        case car.CommandStatus.FAILED:
          console.error('[Remote] 解锁失败');
          break;
      }
    }
  });
}

总结

远程控车的技术实现不难——发指令、等反馈、处理异常。难的是安全设计：防重放、防窃听、权限分级、二次确认。每一道控制指令都直接关联车辆安全，一个漏洞就可能造成财产损失甚至人身伤害。宁可多一道验证，也不能少一道防线。

一句话：远程控车的每一行代码都关乎安全，宁可让用户多点一次确认，也不能让攻击者少过一道关卡。