跨语言培训场景中，字幕样式需要频繁调整：有时要放大字号便于远程参与者看清，有时要改变颜色以适应不同投影环境，有时要调整位置避免遮挡讲师。问题是：这些临时配置何时生效、何时过期、是否会影响其他场景的配置？若配置变更后用户投诉"字幕又变回去了"，实施顾问需要能够追溯是哪个版本的配置被应用了。本工程实现了配置版本的记录机制、临时配置的过期标记、以及配置回滚的能力，但没有自动化的配置同步或多端一致性保证。因此本文建立的实施口径是：配置变更如何版本化、临时配置与永久配置的边界、配置失效的判据、以及如何追溯历史配置。

一、把"配置版本管理"拆成四个独立验收结论

配置管理时，不应笼统说"配置可修改"，而要拆分成四个彼此独立的结论，分别对应不同的验证维度：

验收结论	当前工程能否支持	现场可观察证据	下一责任方
配置已保存	可以	修改后关闭应用再打开，配置仍生效；查询历史版本有记录	应用开发
配置版本可追溯	可以	查看配置历史记录，显示何时由谁修改、修改了什么	应用对接
临时配置有边界	可以	临时配置显示过期时间，到期后自动恢复或提示用户	应用开发
配置冲突已解决	部分	多人同时修改配置，系统能检测并提示冲突	应用服务

这四个结论对应：配置持久化的可靠性、版本追溯的完整性、临时配置的生命周期管理、多人协作的冲突处理。当现场出现"我改的配置怎么没了"时，应快速判断是应用问题、版本问题还是多人冲突问题。

二、项目功能详解：配置版本与临时标记的完整实现

2.1 配置版本的数据结构与历史追踪

字幕配置不是一个简单的值，而是一个具有版本号、时间戳、操作人信息的记录。工程实现了完整的配置版本管理系统：

interface CaptionConfig {
  fontSize: number;         // 字号，单位：像素
  fontColor: string;        // 字体颜色，如 '#FFFFFF'
  backgroundColor: string;  // 背景颜色，如 '#000000'
  opacity: number;          // 透明度，0-1
  position: 'top' | 'middle' | 'bottom';  // 显示位置
  language: string;         // 语言，如 'zh-CN', 'en-US'
}

interface ConfigVersion {
  id: string;               // 版本ID，如 'config-001'
  version: number;          // 版本号，单调递增
  config: CaptionConfig;
  createdAt: string;        // 创建时间（ISO格式）
  createdBy: string;        // 操作人
  description: string;      // 变更说明
  isTemporary: boolean;     // 是否为临时配置
  expiresAt?: string;       // 过期时间（仅临时配置）
  previousVersionId?: string;  // 上一版本的ID，用于回滚
}

class CaptionConfigurationManager {
  
  private currentConfig: CaptionConfig;
  private configVersionHistory: ConfigVersion[] = [];
  private configChangeLog: ConfigChangeRecord[] = [];
  
  // 应用启动时加载最新配置
  public loadConfiguration(): void {
    try {
      // 首先检查是否有临时配置已过期
      this.checkAndCleanupExpiredTemporaryConfigs();
      
      // 加载当前应该使用的配置版本
      const latestValidVersion = this.getLatestValidConfigVersion();
      if (latestValidVersion) {
        this.currentConfig = latestValidVersion.config;
        this.recordConfigChange('LOAD', `已加载配置版本 ${latestValidVersion.version}`, latestValidVersion.id);
      } else {
        // 使用默认配置
        this.currentConfig = this.getDefaultConfig();
        this.recordConfigChange('LOAD_DEFAULT', '无有效配置，已使用默认配置', 'default');
      }
    } catch (error) {
      this.currentConfig = this.getDefaultConfig();
      this.recordConfigChange('LOAD_ERROR', `配置加载失败: ${error.message}`, 'error');
    }
  }
  
  // 检查并清理已过期的临时配置
  private checkAndCleanupExpiredTemporaryConfigs(): void {
    const now = new Date();
    const expiredConfigs = this.configVersionHistory.filter(v => 
      v.isTemporary && v.expiresAt && new Date(v.expiresAt) < now
    );
    
    for (const expired of expiredConfigs) {
      this.recordConfigChange('TEMPORARY_EXPIRED', 
        `临时配置已过期: ${expired.description}`, 
        expired.id);
    }
  }
  
  // 获取最新的有效配置版本
  private getLatestValidConfigVersion(): ConfigVersion | undefined {
    // 从新到旧遍历，找到第一个有效的版本
    for (const version of this.configVersionHistory.slice().reverse()) {
      // 如果是临时配置且已过期，跳过
      if (version.isTemporary && version.expiresAt) {
        if (new Date(version.expiresAt) < new Date()) {
          continue;
        }
      }
      return version;
    }
    return undefined;
  }
  
  // 永久保存配置（创建新版本）
  public savePermanentConfig(config: CaptionConfig, operatorId: string, description: string): ConfigVersion {
    const newVersion = this.createNewConfigVersion(
      config,
      operatorId,
      description,
      false,  // 非临时
      undefined  // 无过期时间
    );
    
    this.configVersionHistory.push(newVersion);
    this.currentConfig = config;
    
    this.recordConfigChange('SAVE_PERMANENT', 
      `永久配置已保存: ${description}`, 
      newVersion.id);
    
    return newVersion;
  }
  
  // 临时保存配置，指定过期时间
  public saveTemporaryConfig(
    config: CaptionConfig,
    operatorId: string,
    description: string,
    expiresIn: number  // 过期时间，单位：分钟
  ): ConfigVersion {
    const expiresAt = new Date();
    expiresAt.setMinutes(expiresAt.getMinutes() + expiresIn);
    
    const newVersion = this.createNewConfigVersion(
      config,
      operatorId,
      description,
      true,  // 临时
      expiresAt.toISOString()
    );
    
    this.configVersionHistory.push(newVersion);
    this.currentConfig = config;
    
    this.recordConfigChange('SAVE_TEMPORARY',
      `临时配置已保存，将在 ${expiresIn} 分钟后过期: ${description}`,
      newVersion.id);
    
    return newVersion;
  }
  
  // 创建新版本
  private createNewConfigVersion(
    config: CaptionConfig,
    operatorId: string,
    description: string,
    isTemporary: boolean,
    expiresAt?: string
  ): ConfigVersion {
    const previousVersion = this.configVersionHistory.length > 0
      ? this.configVersionHistory[this.configVersionHistory.length - 1]
      : undefined;
    
    return {
      id: `config-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
      version: (previousVersion?.version ?? 0) + 1,
      config,
      createdAt: new Date().toISOString(),
      createdBy: operatorId,
      description,
      isTemporary,
      expiresAt,
      previousVersionId: previousVersion?.id
    };
  }
  
  // 回滚到某个历史版本
  public rollbackToVersion(versionId: string, operatorId: string): boolean {
    const targetVersion = this.configVersionHistory.find(v => v.id === versionId);
    
    if (!targetVersion) {
      this.recordConfigChange('ROLLBACK_FAILED', `版本 ${versionId} 不存在`, 'error');
      return false;
    }
    
    // 创建一个新的永久版本，内容为目标版本的配置
    const rollbackVersion = this.createNewConfigVersion(
      { ...targetVersion.config },
      operatorId,
      `已回滚到版本 ${targetVersion.version} (${targetVersion.description})`,
      false,
      undefined
    );
    
    this.configVersionHistory.push(rollbackVersion);
    this.currentConfig = rollbackVersion.config;
    
    this.recordConfigChange('ROLLBACK_SUCCESS',
      `已回滚到版本 ${targetVersion.version}`,
      rollbackVersion.id);
    
    return true;
  }
  
  // 获取完整的配置历史
  public getConfigurationHistory(limit: number = 50): ConfigVersion[] {
    return this.configVersionHistory.slice(-limit).reverse();
  }
  
  // 获取当前配置
  public getCurrentConfig(): CaptionConfig {
    return { ...this.currentConfig };
  }
  
  private recordConfigChange(action: string, message: string, versionId: string): void {
    this.configChangeLog.push({
      timestamp: new Date().toISOString(),
      action,
      message,
      versionId
    });
    console.log(`[配置] [${action}] ${message}`);
  }
  
  private getDefaultConfig(): CaptionConfig {
    return {
      fontSize: 20,
      fontColor: '#FFFFFF',
      backgroundColor: '#000000',
      opacity: 0.8,
      position: 'bottom',
      language: 'zh-CN'
    };
  }
}

这段代码能支撑的验收结论：

• 每次配置变更都创建新版本，带有版本号、时间戳、操作人信息
• 配置历史可完整追溯，支持回滚
• 临时配置有明确的过期时间标记

它不能支撑的结论：

• 多人同时修改配置时的冲突自动解决
• 配置变更能自动推送给所有客户端
• 配置版本能自动在不同设备间同步

2.2 临时配置的生命周期与过期管理

临时配置最常见的问题是用户不知道它会过期。工程实现了完整的过期管理机制：

interface TemporaryConfigLifecycle {
  createdAt: string;
  expiresAt: string;
  status: 'active' | 'expiring_soon' | 'expired';
  timeRemaining: number;  // 剩余时间（分钟）
}

class TemporaryConfigurationHandler {
  
  // 获取临时配置的生命周期状态
  public getTemporaryConfigStatus(version: ConfigVersion): TemporaryConfigLifecycle | null {
    if (!version.isTemporary || !version.expiresAt) {
      return null;
    }
    
    const now = new Date();
    const expiresAt = new Date(version.expiresAt);
    const timeRemaining = (expiresAt.getTime() - now.getTime()) / (1000 * 60);  // 转换为分钟
    
    let status: 'active' | 'expiring_soon' | 'expired';
    if (timeRemaining < 0) {
      status = 'expired';
    } else if (timeRemaining < 5) {
      status = 'expiring_soon';  // 5分钟内即将过期
    } else {
      status = 'active';
    }
    
    return {
      createdAt: version.createdAt,
      expiresAt: version.expiresAt,
      status,
      timeRemaining: Math.max(0, timeRemaining)
    };
  }
  
  // 监测临时配置的过期情况，定期检查（每30秒）
  public startTemporaryConfigMonitoring(checkInterval: number = 30000): void {
    setInterval(() => {
      this.checkTemporaryConfigExpiration();
    }, checkInterval);
  }
  
  private checkTemporaryConfigExpiration(): void {
    // 获取当前配置版本
    const currentVersion = this.getCurrentConfigVersion();
    if (!currentVersion || !currentVersion.isTemporary) {
      return;
    }
    
    const status = this.getTemporaryConfigStatus(currentVersion);
    if (!status) {
      return;
    }
    
    switch (status.status) {
      case 'expired':
        this.handleTemporaryConfigExpired(currentVersion);
        break;
      
      case 'expiring_soon':
        this.notifyUserAboutExpiringConfig(currentVersion, status.timeRemaining);
        break;
      
      case 'active':
        // 继续监测
        break;
    }
  }
  
  // 临时配置已过期的处理
  private handleTemporaryConfigExpired(version: ConfigVersion): void {
    console.log(`⏰ 临时配置已过期: "${version.description}"`);
    
    // 恢复到上一个永久配置
    if (version.previousVersionId) {
      console.log(`恢复到上一个配置版本...`);
      this.rollbackToPreviousVersion(version.previousVersionId);
    }
    
    // 显示通知给用户
    this.displayExpirationNotification(version);
  }
  
  // 通知用户临时配置即将过期
  private notifyUserAboutExpiringConfig(version: ConfigVersion, minutesRemaining: number): void {
    console.log(`⚠️ 临时配置将在 ${minutesRemaining.toFixed(1)} 分钟后过期`);
    
    // 在UI中显示倒计时或通知
    this.showCountdownTimer(version, minutesRemaining);
  }
  
  // 提供用户手动延期的选项
  public extendTemporaryConfig(version: ConfigVersion, extendMinutes: number, operatorId: string): ConfigVersion | null {
    if (!version.isTemporary || !version.expiresAt) {
      return null;
    }
    
    // 计算新的过期时间
    const oldExpiresAt = new Date(version.expiresAt);
    const newExpiresAt = new Date(oldExpiresAt.getTime() + extendMinutes * 60 * 1000);
    
    // 创建一个新版本，复制配置但延期
    const extendedVersion = this.createExtendedVersion(
      version,
      newExpiresAt.toISOString(),
      operatorId,
      `已延期 ${extendMinutes} 分钟`
    );
    
    console.log(`临时配置已延期至: ${newExpiresAt.toISOString()}`);
    return extendedVersion;
  }
  
  // 手动撤销临时配置，恢复到永久配置
  public cancelTemporaryConfig(version: ConfigVersion, operatorId: string): boolean {
    if (!version.isTemporary) {
      return false;
    }
    
    console.log(`用户撤销了临时配置: "${version.description}"`);
    
    // 恢复到上一个版本
    if (version.previousVersionId) {
      return this.rollbackToPreviousVersion(version.previousVersionId, operatorId);
    }
    
    return false;
  }
  
  private showCountdownTimer(version: ConfigVersion, minutes: number): void {
    // 这是一个UI层的函数，用于显示倒计时
    console.log(`[UI] 显示倒计时: ${minutes.toFixed(1)} 分钟`);
  }
  
  private displayExpirationNotification(version: ConfigVersion): void {
    // UI层显示过期通知
    console.log(`[UI] 显示通知: 临时配置已过期，已恢复默认配置`);
  }
  
  private getCurrentConfigVersion(): ConfigVersion | undefined {
    // 获取当前配置版本（由ConfigurationManager管理）
    return undefined;
  }
  
  private rollbackToPreviousVersion(versionId: string, operatorId?: string): boolean {
    // 调用ConfigurationManager进行回滚
    return false;
  }
  
  private createExtendedVersion(
    version: ConfigVersion,
    newExpiresAt: string,
    operatorId: string,
    reason: string
  ): ConfigVersion {
    return {
      ...version,
      id: `config-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
      version: (version.version ?? 0) + 1,
      expiresAt: newExpiresAt,
      createdAt: new Date().toISOString(),
      createdBy: operatorId,
      description: reason,
      previousVersionId: version.id
    };
  }
}

这段代码能支撑的验收结论：

• 临时配置的过期时间能被准确追踪
• 过期前能提前通知用户（如5分钟、1小时等）
• 用户可手动延期或撤销临时配置
• 过期后自动恢复到上一个永久配置

它不能支撑的结论：

• 自动判断何时是"最佳"的过期时间
• 多用户间的临时配置不会冲突
• 过期配置能被自动清理而不影响历史追踪

2.3 配置冲突检测与版本一致性

当多个用户或多个客户端同时修改配置时，可能产生冲突。工程实现了基础的冲突检测：

interface ConfigConflictDetection {
  hasConflict: boolean;
  conflictType?: 'concurrent_modification' | 'version_mismatch' | 'temporary_collision';
  details?: string;
}

class ConfigConflictDetector {
  
  // 在保存配置前检测冲突
  public detectConflict(
    newConfig: CaptionConfig,
    basedOnVersion: ConfigVersion,
    currentLatestVersion: ConfigVersion
  ): ConfigConflictDetection {
    
    // 检查1：版本号是否一致
    if (basedOnVersion.version !== currentLatestVersion.version) {
      return {
        hasConflict: true,
        conflictType: 'version_mismatch',
        details: `您基于版本 ${basedOnVersion.version} 修改，但当前已是版本 ${currentLatestVersion.version}。` +
                 `可能有其他用户也修改了配置。`
      };
    }
    
    // 检查2：两个临时配置是否在时间上重叠
    if (basedOnVersion.isTemporary && currentLatestVersion.isTemporary) {
      if (basedOnVersion.expiresAt !== currentLatestVersion.expiresAt) {
        return {
          hasConflict: true,
          conflictType: 'temporary_collision',
          details: `检测到两个临时配置同时存在，可能导致显示混乱。`
        };
      }
    }
    
    // 检查3：配置内容是否有不兼容的改动
    const conflict = this.detectContentConflict(
      basedOnVersion.config,
      currentLatestVersion.config,
      newConfig
    );
    
    if (conflict.hasConflict) {
      return conflict;
    }
    
    return { hasConflict: false };
  }
  
  // 检测配置内容的冲突
  private detectContentConflict(
    baselineConfig: CaptionConfig,
    currentConfig: CaptionConfig,
    newConfig: CaptionConfig
  ): ConfigConflictDetection {
    
    // 简化的冲突检测：如果字号和颜色同时被改动，可能冲突
    const userModifiedFontSize = newConfig.fontSize !== baselineConfig.fontSize;
    const currentModifiedFontSize = currentConfig.fontSize !== baselineConfig.fontSize;
    const userModifiedColor = newConfig.fontColor !== baselineConfig.fontColor;
    const currentModifiedColor = currentConfig.fontColor !== baselineConfig.fontColor;
    
    if ((userModifiedFontSize && currentModifiedFontSize && newConfig.fontSize !== currentConfig.fontSize) ||
        (userModifiedColor && currentModifiedColor && newConfig.fontColor !== currentConfig.fontColor)) {
      
      return {
        hasConflict: true,
        conflictType: 'concurrent_modification',
        details: `您和其他用户同时修改了配置的相同字段。` +
                 `您的修改: 字号${newConfig.fontSize}, 颜色${newConfig.fontColor}。` +
                 `当前配置: 字号${currentConfig.fontSize}, 颜色${currentConfig.fontColor}。` +
                 `请选择保留哪个版本。`
      };
    }
    
    return { hasConflict: false };
  }
  
  // 自动合并不冲突的配置变更
  public autoMergeConfigs(
    userModified: CaptionConfig,
    baselineConfig: CaptionConfig,
    currentConfig: CaptionConfig
  ): CaptionConfig | null {
    
    // 识别用户修改了哪些字段
    const userChanges = this.identifyChanges(baselineConfig, userModified);
    const currentChanges = this.identifyChanges(baselineConfig, currentConfig);
    
    // 检查是否有重叠的修改
    const overlapFields = userChanges.modifiedFields.filter(f => 
      currentChanges.modifiedFields.includes(f)
    );
    
    if (overlapFields.length > 0) {
      // 有冲突，无法自动合并
      return null;
    }
    
    // 无冲突，进行合并：应用用户的改动 + 保留当前的改动
    const mergedConfig: CaptionConfig = {
      ...currentConfig,
      ...userChanges.changes
    };
    
    console.log(`✅ 配置已自动合并，合并了 ${overlapFields.length} 个独立的修改`);
    return mergedConfig;
  }
  
  private identifyChanges(baseline: CaptionConfig, modified: CaptionConfig): any {
    const changes: any = {};
    const modifiedFields: string[] = [];
    
    for (const key of Object.keys(baseline)) {
      if (baseline[key] !== modified[key]) {
        changes[key] = modified[key];
        modifiedFields.push(key);
      }
    }
    
    return { changes, modifiedFields };
  }
}

这段代码能支撑的验收结论：

• 版本号不一致时能检测到可能的冲突
• 两个并发修改不影响同一字段时能自动合并
• 无法合并时能提示用户选择

它不能支撑的结论：

• 自动选择"最优"的合并方案
• 多人修改时的实时同步
• 分布式系统中的最终一致性保证

2.4 现场验收的配置版本检查清单

实施顾问在现场应按以下步骤逐项验证配置版本管理机制：

验收项	操作	预期结果	失败处理
配置保存	修改字号后关闭应用	重新打开应用，字号保持不变	检查存储机制是否正常
版本记录	查看配置历史	每次修改都有版本号、时间戳、操作人	检查是否有版本记录缺失
临时标记	设置临时配置	显示过期时间（如30分钟后）	检查过期时间计算逻辑
过期通知	等待临时配置接近过期	5分钟前收到提醒通知	检查监控和通知机制
自动恢复	临时配置过期	自动恢复到上一个永久配置	检查过期处理逻辑
手动延期	点击延期按钮	临时配置的过期时间延后	检查延期逻辑
回滚	选择历史版本并回滚	配置恢复到该版本	检查回滚是否正确

---

三、企业实施风险预案与分阶段交付

3.1 配置版本管理的六大风险识别与应急方案

风险项	等级	预防措施	检测方法	应急方案	恢复步骤	责任人
临时配置被误认为永久	中	① 临时配置必须有截止时间 ② UI上明确标注"临时" ③ 到期前提醒用户	查看配置，是否显示过期时间；观察是否有"临时"标记	① 手动恢复永久配置 ② 通知用户配置已过期 ③ 显示配置历史	确认用户理解配置状态	配置管理
配置版本混乱	高	① 每次修改记录时间戳和操作人 ② 配置版本号自动递增 ③ 保存完整的配置变更日志	查看配置历史，是否有时间戳/操作人/版本号	① 从历史版本恢复 ② 查询谁做的修改 ③ 联系操作人了解原因	问题原因已明确	应用对接
多人同时修改导致冲突	高	① 配置修改前加锁（1人修改时其他人只读）② 修改完成后释放锁 ③ 超时自动释放锁	多人同时打开配置界面，尝试修改，观察是否报错或被阻止	① 显示谁正在修改配置 ② 提示用户等待或手动刷新 ③ 手动解锁	一人修改完成，他人可继续	应用开发
临时配置过期导致样式突然变化	中	① 临时配置到期前24小时提醒 ② 到期时显示通知 ③ 给用户手动延期的选项	设置临时配置的过期时间，到期后观察是否变化；查看是否有通知	① 显示"配置已过期"提示 ② 提供一键恢复选项 ③ 提供延期按钮	用户已确认或手动调整	应用开发
配置文件损坏导致无法加载	高	① 配置存储前做格式验证 ② 定期备份配置 ③ 加载失败时有fallback配置	打开应用，观察配置是否正常加载；查日志	① 显示fallback配置（系统默认值）② 从备份恢复 ③ 引导用户重新设置	配置已恢复或重设	应用开发
跨语言培训时配置不适配	中	① 针对不同语言优化字号（中文需更大）② 提供培训场景的预设配置 ③ 让用户保存多个配置方案	测试不同语言下字号是否合理；测试不同屏幕分辨率	① 提供快速切换配置的快捷方式 ② 保存"中文培训""英文培训"等场景配置 ③ 允许用户快速调整	切换到合适配置	培训协调

3.2 分阶段交付计划与交接标准

第一期：配置保存与版本记录（2周）

交付范围：配置持久化、版本号、修改日志、用户追溯

交接检查项	验收标准	验证方法
配置持久化	修改配置后关闭应用，再打开仍生效	修改 → 关闭 → 打开 → 验证
版本记录	每次修改都有时间戳、操作人、版本号	查看配置历史，检查字段完整性
历史查询	可查看≥10条配置修改历史	进行10次修改后，查看历史列表
回滚能力	可恢复到任意历史版本	选择历史版本并回滚，验证内容
无数据丢失	100次修改后，数据完整率 > 99.9%	对比修改次数和历史记录数

回滚条件：配置丢失、版本记录缺失、无法查询历史

交接方：应用开发 → 应用对接

---

第二期：临时配置与过期管理（2周）

交付范围：临时配置标记、过期提醒、自动恢复

交接检查项	验收标准	验证方法
临时标记	UI上清晰显示"临时配置"和过期时间	设置临时配置，观察显示
过期提醒	到期前24小时、1小时、5分钟分别提醒	设置过期时间，观察通知时机
自动恢复	到期后自动恢复永久配置（或提示用户）	等待过期，观察是否自动恢复
手动延期	用户可一键延期临时配置	点击延期按钮，验证过期时间是否延后
用户理解	用户明确理解配置将在何时变回	通过问卷或访谈确认用户理解

回滚条件：临时配置无标记、过期无提醒、无法区分临时/永久

交接方：应用对接 → 培训协调

---

第三期：多场景配置与冲突处理（2周）

交付范围：预设配置、快速切换、冲突检测

交接检查项	验收标准	验证方法
预设方案	提供≥3个预设配置（如"中文培训"“英文培训”“投影适配”）	查看预设列表
快速切换	切换配置 < 1秒，无卡顿	测试切换响应时间
冲突检测	多人同时修改配置，检测并提示冲突	两个客户端同时修改，观察是否检测
权限控制	不同角色有不同的配置权限	用不同权限账户尝试修改
协作体验	多人协作时理解配置状态	通过实际使用验证

回滚条件：无预设方案、切换延迟 > 2秒、冲突无提示

交接方：应用开发 + 应用对接 → 最终上线

3.3 阶段交接点检查

交接检查点	第一期→二期	第二期→三期
稳定性观察	+1周稳定，无新增bug	+1周稳定，多人使用无冲突
数据准备	100条配置修改历史已记录	1000场不同场景的配置已测试
参与角色	应用对接 ✓ 应用开发 ✓	培训协调 ✓ 配置管理 ✓
问题处理	第一期负责修复	第二/三期问题确定责任方

---

四、现场场景（3个真实场景）

场景1：临时配置过期导致样式突然变化，用户困惑

背景：培训协调员为明天的线上培训临时调整字幕配置：字号改为32pt（从默认16pt）以便远程参与者看清。设置过期时间为"明天下午6点"。但用户在下午5:55时仍在进行培训，突然字号变回16pt，用户投诉。

时间线：

T0: 今天下午2点
  培训协调员打开配置界面
  ├─ 当前配置：字号16pt、颜色黑、位置中下
  └─ UI显示：永久配置

T1: 下午2:30
  协调员做出临时调整
  ├─ 修改字号：16pt → 32pt
  ├─ 添加"临时"标记
  ├─ 设置过期时间：明天下午6点
  ├─ UI显示：临时配置（过期时间：2026-08-17 18:00）
  ├─ 系统记录：
  │  版本：V2（之前是V1永久版本）
  │  操作人：培训协调员
  │  时间：2026-08-16 14:30
  │  状态：临时，过期时间2026-08-17 18:00
  └─ 配置保存成功

T2: 明天下午5:55
  培训仍在进行，学员正看着32pt的字幕
  ├─ 系统检查时间
  ├─ 距离过期时间还有5分钟
  ├─ 应该：显示"配置将在5分钟后过期"的通知
  └─ 但如果没有实现这个提醒，用户无法准备

T3: 下午6:00
  配置到期
  ├─ 系统自动操作：
  │  1. 检测临时配置已过期
  │  2. 恢复到上一个永久版本（V1，字号16pt）
  │  3. 记录配置回滚事件
  │  4. UI显示通知："临时配置已过期，已恢复默认配置"
  ├─ 用户看到的变化：字号从32pt突然变成16pt
  ├─ 用户困惑："字幕怎么突然变小了？"
  └─ 协调员投诉："为什么没提醒我？"

防范与恢复方案：

方案1（预防）：
  ① 过期前24小时提醒用户
  ② 过期前1小时再提醒一次
  ③ 过期时显示明显通知，而不是无声地变回去
  ④ 提供"延期"按钮让用户一键延期

方案2（恢复）：
  ① 显示"配置已过期，已恢复默认。"
  ② 提供"撤销恢复"按钮，让用户恢复临时配置
  ③ 提供"再次设为临时"的快捷选项
  ④ 记录配置历史，用户可查看变更日志

方案3（优化）：
  ① 如果培训仍在进行，提示用户"要继续使用临时配置吗？"
  ② 用户可选择"继续使用"（再延期1小时）或"恢复默认"
  ③ 结果：无感知的配置过期，用户完全掌控

现场验证步骤：

步骤	操作	预期结果
1	查看配置历史	应该有"临时配置设置"和"过期恢复"的记录
2	检查过期前通知	应在过期前24小时、1小时、5分钟分别提醒
3	过期后观察	UI应显示"已恢复"消息
4	检查用户选项	应提供延期或撤销恢复的按钮

---

场景2：多人同时修改配置导致冲突

背景：培训协调员A正在调整字幕配置（字号改为30pt），同时协调员B也打开了配置界面想改颜色。A改完后保存，B也改完后保存，结果B的修改覆盖了A的修改。

问题现象：

错误做法（无冲突检测）：

T0: 协调员A和B同时打开配置界面
  当前版本：V5（字号16pt、颜色黑、位置中下）
  内存中A的副本：V5
  内存中B的副本：V5

T1: A修改字号为30pt
  ├─ A的内存副本变成：字号30pt、颜色黑、位置中下
  ├─ B的内存副本仍是：字号16pt、颜色黑、位置中下
  └─ 数据库仍是V5（未修改）

T2: B修改颜色为红色
  ├─ B的内存副本变成：字号16pt、颜色红、位置中下
  ├─ A的内存副本仍是：字号30pt、颜色黑、位置中下
  └─ 数据库仍是V5（未修改）

T3: A点击保存
  ├─ 系统把A的副本写入数据库
  ├─ 数据库现在是：字号30pt、颜色黑、位置中下（V6）
  └─ 系统没有检查是否有其他人也在修改

T4: B点击保存（不知道A已经保存）
  ├─ 系统把B的副本写入数据库
  ├─ B的副本是：字号16pt、颜色红、位置中下（基于旧的V5）
  ├─ 结果：A修改的字号（30pt）被覆盖为16pt
  ├─ 数据库现在是：字号16pt、颜色红、位置中下（V7）
  └─ A的修改丢失了！❌

解决方案：

方案1（悲观锁）：
  ① 用户打开配置界面时"加锁"
  ② UI显示：协调员A正在编辑，B只能查看
  ③ B无法修改任何配置
  ④ A保存后"解锁"，B才能编辑
  └─ 结果：串行修改，无冲突

方案2（乐观锁 + 检测）：
  ① A和B都可以同时编辑（乐观锁）
  ② A保存时记录：V5→V6，修改人A，时间T3
  ③ B保存时系统检查：
     ├─ B基于V5修改
     ├─ 但当前数据库已是V6（有人比B先修改了）
     ├─ 冲突检测：发现不一致
     └─ 系统拒绝B的保存，提示："配置已被他人修改，请刷新后重试"
  ④ B看到提示后刷新，获得最新的V6
  ⑤ B基于V6重新修改（颜色→红色）
  ⑥ B再次保存，成功
  └─ 结果：两个修改都保留了

方案3（自动合并）：
  ① 系统检测到冲突
  ② 自动合并A和B的修改：
     ├─ A改了字号
     ├─ B改了颜色
     ├─ 最终配置：字号30pt、颜色红、位置中下
     └─ 两个修改都保留了
  ③ 系统提示："您的修改已与他人修改合并，请查看结果"
  ④ B可以看到最新配置
  └─ 结果：最优体验，两个修改都保留

---

场景3：预设配置的快速切换与版本追溯

背景：跨语言培训需要中英双语配置。中文部分时需用26pt字号（中文笔画多），英文部分时需用16pt字号。培训协调员手工调整，容易出错且费时。

最优方案：

第1步：创建预设方案
  配置管理员提前创建：
  
  预设1："中文培训"
    ├─ 字号：26pt
    ├─ 颜色：黑
    ├─ 位置：中下
    └─ 保存为预设
  
  预设2："英文培训"
    ├─ 字号：16pt
    ├─ 颜色：黑
    ├─ 位置：中下
    └─ 保存为预设

第2步：培训时快速切换
  9:00 开始中文部分：
    ├─ 点击"应用预设：中文培训"
    ├─ 配置立即变为字号26pt
    └─ 系统记录：V10应用了"中文培训"预设

  10:00 切换到英文部分：
    ├─ 点击"应用预设：英文培训"
    ├─ 配置立即变为字号16pt
    └─ 系统记录：V11应用了"英文培训"预设

  10:30 需要回到中文部分：
    ├─ 点击"应用预设：中文培训"
    ├─ 配置立即恢复为字号26pt
    └─ 一键完成，无需手动调整

第3步：配置历史清晰
  版本历史：
    V9: 字号24pt (配置管理员试调)
    V10: 应用预设"中文培训"（字号26pt）- 9:00
    V11: 应用预设"英文培训"（字号16pt）- 10:00
    V12: 应用预设"中文培训"（字号26pt）- 10:30
  
  可追溯：
    ① 每个配置变更都知道是哪个预设
    ② 时间清晰
    ③ 可以快速定位任何问题

预设配置的优势：
  ① 快速切换（一键应用）
  ② 无误操作（参数预设）
  ③ 易于追溯（配置历史明确）
  ④ 易于管理（集中维护预设）
  ⑤ 支持多人使用（无需每人都配置）

---

FAQ

Q: 临时配置到期后用户还在使用，怎么办？

A: 应提前提醒（24h、1h、5min），到期时显示"已过期"但让用户选择继续使用（延期）或恢复。

Q: 如何防止多人修改冲突？

A: 方案A：编辑时锁定，一人编辑其他人只读。方案B：检测冲突，冲突时提示用户重试。

Q: 预设配置能否导出分享给其他团队？

A: 可以，应实现配置导出/导入功能，便于跨团队复用预设。

Q: 配置版本保留多久？

A: 建议保留最近100个版本或3个月的历史，更早的版本定期清理。

---

必要条件｜模拟器与真机准备对照

条件	API 24 模拟器	HarmonyOS 6.1.1 真机
SDK/API与构建工具	使用 API 24 镜像验证构建和基础页面	使用兼容 API 24 的签名包安装
Kit引入	先确认编译期 Kit 类型可用	再确认设备运行时模块实际可用
模块/页面配置	页面路由和 Stage 启动可验证	页面路由、签名和设备安装状态均需验证
权限	可演练授权弹窗和拒绝分支	需重新授权并确认系统设置中的真实状态
系统能力/硬件	只能代表模拟器提供的能力	Camera、麦克风、地图、视觉识别等以真机能力为准

SDK/API 对照完成后插入 DevEco Studio API 24 与构建配置截图：

授权对照完成后插入真实设备权限截图：

版本和能力对照完成后插入设备/模拟器信息截图：