TTMusic/entry/src/main/ets/common/service/UnifiedPlayerService.ets

import { VideoItem } from '../../viewmodel/VideoItem';
import { PlayerManager, IPlayerManager, PlayerStateCallback } from './PlayerManager';
import {
  PlayerStateModel,
  PlayerState,
  PlayerStateListener,
  PlayMode,
  PlayerError,
  PlayerErrorType
} from './PlayerStateModel';
import { PlaylistModel } from './PlaylistModel';
import { IjkMediaPlayer, LogUtils, InterruptEvent, InterruptHintType } from '@ohos/ijkplayer';
import { common } from '@kit.AbilityKit';
import { PreferencesUtil as PuraPreferencesUtil, StrUtil } from '@pura/harmony-utils';
import { PreferencesUtil } from '../utils/PreferencesUtil';
import {
  DataPersistenceService,
  PlaylistSyncService,
  PlaylistSyncListener,
  IDataPersistenceService,
  PlaylistData,
  PlayerStateData
} from './DataPersistenceService';
import {
  ErrorRecoveryStrategy,
  IErrorRecoveryStrategy,
  ErrorContext,
  ErrorRecoveryAction
} from './ErrorRecoveryStrategy';
import { AvSessionController } from '../../controller/AvSessionController';
import { avSession } from '@kit.AVSessionKit';
import { formProvider, formBindingData } from '@kit.FormKit';
import { fileIo } from '@kit.CoreFileKit';
import { BusinessError } from '@kit.BasicServicesKit';
import { http } from '@kit.NetworkKit';
import { util } from '@kit.ArkTS';
import json from '@ohos.util.json';
import MediaTable from '../util/MediaTable';
import { Utility } from '../util/Utility';
import { FormRdbHelper } from '../../database/FormRdbHelper';
import { FormInfo } from '../../viewmodel/FormInfo';

/**
 * 服务就绪状态详情接口
 */
export interface ServiceReadinessDetails {
  initialized: boolean;
  hasPlayerInstance: boolean;
  hasContext: boolean;
  dataRestored: boolean;
  playlistSize: number;
  currentIndex: number;
}

/**
 * 服务就绪信息接口
 */
export interface ServiceReadinessInfo {
  isReady: boolean;
  details: ServiceReadinessDetails;
}

/**
 * 初始化验证结果接口
 */
export interface InitializationValidation {
  isValid: boolean;
  errors: string[];
  warnings: string[];
}

/**
 * 卡片播放状态数据接口
 */
export interface WidgetPlayerState {
  isPlaying: boolean;
  isPaused: boolean;
  isLoading: boolean;
  currentPosition: number;
  duration: number;
  hasNext: boolean;
  hasPrevious: boolean;
  playMode: number;
}

/**
 * 卡片播放列表信息接口
 */
export interface WidgetPlaylistInfo {
  currentIndex: number;
  totalCount: number;
}

/**
 * 卡片时间信息接口
 */
export interface WidgetTimeInfo {
  currentTimeText: string;
  totalTimeText: string;
  progressPercentage: number;
}

/**
 * 缓存文件信息接口
 */
export interface CacheFileInfo {
  path: string;
  size: number;
  mtime: number;
}

/**
 * 卡片数据接口
 */
export interface WidgetFormData {
  // VideoItem数据
  id: string;
  name: string;
  artist: string;
  album: string;
  pixelMapPath: string;
  duration: number;
  filePath: string;

  // 扩展数据
  imgName: string;
  imageColorHex: string;

  // 状态数据
  playerState: WidgetPlayerState;
  playlistInfo: WidgetPlaylistInfo;
  timeInfo: WidgetTimeInfo;

  // 卡片图片显示必填字段
  formImages: Record<string, number>;
}

/**
 * 统一播放器服务接口
 * 提供统一的播放控制接口，替代LocalMusic中的播放器逻辑
 */
export interface IPlayerService {
  /**
   * 启动播放或恢复播放
   * @returns
   */
  startPlayOrResumePlay(): Promise<void>;

  /**
   *  暂停播放
   * @returns
   */
  pause(): Promise<void>;

  /**
   * 停止播放
   * @returns
   */
  stop(): Promise<void>;

  /**
   * 跳转到指定位置
   * @param position
   * @returns
   */
  seekTo(position: string): Promise<void>;

  // 播放列表控制 - 基于LocalMusic现有方法
  /**
   * 播放下一首
   * @returns
   */
  playNext(): Promise<void>;

  /**
   * 播放上一首
   */
  playPrevious(): Promise<void>;

  /**
   * 播放指定索引的歌
   * @param index
   * @returns
   */
  playSongAtIndex(index: number): Promise<void>;

  /**
   * 获取播放器状态
   * @returns
   */
  getCurrentState(): PlayerState;

  /**
   * 获取实际播放状态
   * @returns 实际播放状态
   */
  getActualPlayingState(): boolean;

  /**
   * 获取当前播放歌曲
   * @returns
   */
  getCurrentSong(): VideoItem | null;

  /**
   * 获取播放列表
   * @returns
   */
  getPlaylist(): VideoItem[];

  /**
   * 获取当前播放索引
   * @returns
   */
  getCurrentIndex(): number;

  /**
   * 获取当前播放进度
   * @returns 当前播放进度
   */
  getCurrentPosition(): number;

  /**
   * 获取播放器实例
   * @returns 播放器实例
   */
  getIjkPlayer(): IjkMediaPlayer | null;

  /**
   * 是否数据恢复完成
   * @returns 是否数据恢复完成
   * */
  isDataRestorationCompleted(): boolean;

  /**
   * 等待数据恢复完成
   * @param maxWaitMs 最大等待时间（毫秒），默认为-1（无限等待）
   * @returns 是否恢复完成
   */
  waitForDataRestoration(maxWaitMs?: number): Promise<boolean>;

  /**
   * 强制数据恢复
   * @returns 是否恢复成功
   */
  forceDataRestoration(): Promise<boolean>;

  /**
   * 是否就绪
   * @returns
   */
  isAllServicesReady(): boolean;

  /**
   * 处理音频中断事件
   * @param event 音频中断事件
   */
  handleAudioInterrupt(event: InterruptEvent): Promise<void>;

  /**
   * 等待服务就绪
   * @param maxWaitMs 最大等待时间（毫秒），默认为-1（无限等待）
   * @param checkDataRestore 是否检查数据恢复状态，默认为true
   * @returns 是否就绪
   */
  waitForAllServicesReady(maxWaitMs?: number, checkDataRestore?: boolean): Promise<boolean>;

  /**
   * 获取服务就绪信息
   * @returns 服务就绪信息
   */
  getServiceReadinessInfo(): ServiceReadinessInfo;

  /**
   * 初始化验证
   * @returns 初始化验证结果
   */
  validateInitialization(): InitializationValidation;

  /**
   * 设置播放模式
   * @param mode
   */
  setPlayMode(mode: number): void;

  /**
   * 获取播放模式
   * @returns 播放模式
   */
  getPlayMode(): number;

  /**
   * 设置音量
   * @param volume
   */
  setVolume(volume: number): void;

  /**
   * 设置播放速度
   * @param speed
   */
  setPlaybackSpeed(speed: number): void;

  // 播放列表管理
  /**
   * 设置播放列表
   * @param songs
   * @param currentIndex
   */
  setPlaylist(songs: VideoItem[], currentIndex?: number): void;

  /**
   * 添加歌曲到播放列表
   * @param song
   * @param index
   */
  addToPlaylist(song: VideoItem, index?: number): void;

  /**
   * 移除播放列表中的歌曲
   * @param index
   * @returns 移除的歌曲
   */
  removeFromPlaylist(index: number): VideoItem | null;

  // 事件监听
  /**
   * 添加播放器状态监听
   * @param listener
   */
  addStateListener(listener: PlayerStateListener): void;

  /**
   * 移除播放器状态监听
   * @param listener
   */
  removeStateListener(listener: PlayerStateListener): void;

  /**
   * 初始化
   * @param context
   * @returns
   */
  initialize(context: common.UIAbilityContext): Promise<void>;

  /**
   * 释放资源
   */
  release(): void;

  /**
   * 更新收藏列表
   */
  updateFavoriteList(): Promise<void>;

  /**
   * 强制刷新收藏状态（用于收藏/取消收藏操作后）
   */
  refreshFavoriteStatus(): Promise<void>;

  /**
   * 获取收藏列表
   * @returns 收藏列表
   */
  getFav(): Array<VideoItem>;
  syncPlaylistToService(songList: VideoItem[], currentIndex: number, playType: PlayMode): void
}

/**
 * 统一播放器服务实现
 * 整合PlayerManager、PlayerStateModel和PlaylistModel
 */
interface widgeData {
  // VideoItem数据平铺
  id: string;
  name: string;
  artist: string;
  album: string;
  pixelMapPath: string;
  duration: number;
  filePath: string;
  imgName: string;
  imageColorHex: string;
  isFavorite: boolean;

  // PlayerState数据平铺
  isPlaying: boolean;
  isPaused: boolean;
  isLoading: boolean;
  currentPosition: number;
  hasNext: boolean;
  hasPrevious: boolean;
  playMode: number;

  // 播放列表信息平铺
  currentIndex: number;
  totalCount: number;

  // 时间信息平铺
  currentTimeText: string;
  totalTimeText: string;
  progressPercentage: number;

  // 保持嵌套结构兼容性
  playerState: WidgetPlayerState;
  playlistInfo: WidgetPlaylistInfo;
  timeInfo: WidgetTimeInfo;

  // 卡片图片显示必填字段
  formImages: Record<string, number>;
}

export class UnifiedPlayerService implements IPlayerService, PlaylistSyncListener, PlayerStateCallback {
  private static instance: UnifiedPlayerService | null = null;
  private playerManager: IPlayerManager;
  private stateModel: PlayerStateModel;
  private playlistModel: PlaylistModel;
  private dataPersistence: IDataPersistenceService;
  private playlistSync: PlaylistSyncService;
  private errorRecovery: IErrorRecoveryStrategy;
  private avSessionController: AvSessionController | null = null;
  private context: common.UIAbilityContext | null = null;
  // 防重复调用机制
  private isUpdatingForms: boolean = false;
  private lastUpdateTime: number = 0;
  private lastAvSessionUpdateTime: number = 0;
  private readonly UPDATE_THROTTLE_MS: number = 100; // 100ms内只允许一次更新
  private progressTimer: number = -1;
  private isInitialized: boolean = false;
  private isDataRestored: boolean = false; // 新增：数据恢复完成标识

  private isPlayerPreparedForCurrentSong: boolean = false; // 新增：播放器是否已为当前歌曲准备就绪
  private currentRetryCount: number = 0;
  private lastAvSessionUpdate: number = 0;
  private lastAvMetadataUpdate: number = 0; // 新增：上次元数据更新时间
  private avSessionUpdateTimer: number = -1; // 新增：系统播控更新防抖定时器
  private avMetadataUpdateTimer: number = -1; // 新增：元数据更新防抖定时器
  private favList: VideoItem[] = [];
  private table: MediaTable | undefined = undefined;
  private lastAutoPlayTime: number = 0; // 新增：上次自动播放时间，用于防抖
  private autoPlayDebounceMs: number = 1000; // 自动播放防抖间隔（毫秒）
  private isManualSongChange: boolean = false; // 新增：是否正在进行手动歌曲切换

  // 图片缓存相关属性
  private imageCacheDir: string = ''; // 图片缓存目录
  private readonly CACHE_EXPIRY_DAYS: number = 7; // 缓存有效期：7天
  private readonly MAX_CACHE_SIZE_MB: number = 50; // 最大缓存大小：50MB

  private constructor() {
    this.playerManager = PlayerManager.getInstance();
    this.stateModel = new PlayerStateModel();
    this.playlistModel = new PlaylistModel();
    this.dataPersistence = DataPersistenceService.getInstance();
    this.playlistSync = PlaylistSyncService.getInstance();
    this.errorRecovery = ErrorRecoveryStrategy.getInstance();

    LogUtils.getInstance().LOGI('UnifiedPlayerService: Instance created');
  }

  public static getInstance(): UnifiedPlayerService {
    if (!UnifiedPlayerService.instance) {
      UnifiedPlayerService.instance = new UnifiedPlayerService();
    }
    return UnifiedPlayerService.instance;
  }

  async initialize(context: common.UIAbilityContext): Promise<void> {
    if (this.isInitialized && this.context === context) {
      LogUtils.getInstance().LOGI('UnifiedPlayerService已经初始化过了');
      return;
    }

    try {
      console.log("Heanup2 UnifiedPlayerService: 开始快速初始化服务");
      this.context = context;

      // 初始化图片缓存目录
      await this.initImageCacheDirectory();

      // 快速初始化核心组件
      this.playerManager.setStateCallback(this);

      // 初始化PlaylistModel的MediaTable
      this.playlistModel.initializeMediaTable(context);

      // 设置音频中断监听
      // 音频中断处理已移至LocalMusic中，响应更快
      // this.setupAudioInterruptListener();

      // 设置同步监听器
      this.playlistSync.addSyncListener(this);

      // 设置状态模型监听器，自动广播状态变化

      this.setupProgressTimer();
      this.isInitialized = true;

      // 异步初始化耗时组件，避免阻塞
      this.initializeHeavyComponentsAsync(context);

      // 清理无效的Form ID
      this.cleanupInvalidFormIds();

      LogUtils.getInstance().LOGI('UnifiedPlayerService: Core initialization completed');
    } catch (error) {
      LogUtils.getInstance().LOGI(`UnifiedPlayerService initialization error: ${error}`);
      throw new Error(`初始化失败: ${error}`);
    }
  }

  /**
   * 为卡片进程设置context
   * 卡片进程是独立的，需要单独设置context
   */
  setFormContext(context: common.UIAbilityContext | common.FormExtensionContext): void {
    try {
      this.context = context as common.UIAbilityContext;
      // 同时设置到AppStorage，确保卡片进程中其他地方能访问
      AppStorage.setOrCreate('context', context);
      LogUtils.getInstance().LOGI('UnifiedPlayerService: Form context set successfully');
    } catch (error) {
      LogUtils.getInstance().LOGI(`UnifiedPlayerService: Failed to set form context: ${error}`);
    }
  }

  /**
   * 获取当前context
   */
  getContext(): common.UIAbilityContext | null {
    // 优先返回实例的context
    if (this.context) {
      return this.context;
    }
    
    // 尝试从AppStorage获取
    try {
      const appStorageContext = AppStorage.get('context') as common.UIAbilityContext;
      if (appStorageContext) {
        this.context = appStorageContext;
        return appStorageContext;
      }
    } catch (error) {
      LogUtils.getInstance().LOGI(`UnifiedPlayerService: Failed to get context from AppStorage: ${error}`);
    }
    
    return null;
  }

  /**
   * 异步初始化耗时组件
   */
  private initializeHeavyComponentsAsync(context: common.UIAbilityContext): void {
    setTimeout(async () => {
      try {
        console.log("Heanup2 UnifiedPlayerService: 开始异步初始化耗时组件");

        // 并行初始化各个服务以提高效率
        const initPromises = [
          this.playerManager.initialize(context),
          this.dataPersistence.initialize(context),
          this.playlistSync.initialize(context),
        ];

        await Promise.all(initPromises);

        // 立即尝试快速恢复关键数据（从AppStorage）
        await this.fastRestoreFromMemory();


        this.initializeAvSession();

        // 并行初始化收藏列表和恢复数据，提高效率
        const initPromises2 = [
          this.restorePersistedState(),
          this.initializeFavoriteList()
        ];

        await Promise.all(initPromises2);

        console.log("Heanup2 UnifiedPlayerService: 异步组件初始化完成");
        LogUtils.getInstance().LOGI('UnifiedPlayerService: Heavy components initialized');
      } catch (error) {
        console.log(`Heanup2 UnifiedPlayerService: 异步组件初始化失败: ${error}`);
        LogUtils.getInstance().LOGI(`UnifiedPlayerService heavy components init error: ${error}`);
        // 即使失败也设置数据恢复完成，避免无限等待
        this.isDataRestored = true;
      }
    }, 10); // 缩短延迟，让数据恢复更快开始
  }

  // 播放控制方法
  async startPlayOrResumePlay(): Promise<void> {
    try {
      console.log("Heanup2 UnifiedPlayerService: 开始恢复播放");

      // 统一的服务就绪检查 - 这是最核心的检查
      if (!this.isAllServicesReady()) {
        console.log("Heanup2 UnifiedPlayerService: 服务未就绪，等待服务初始化完成");
        const isReady = await this.waitForAllServicesReady(3000, false);
        if (!isReady) {
          const error = new Error('Services not ready for playback');
          await this.handlePlaybackError(error, PlayerErrorType.INITIALIZATION_ERROR);
          return;
        }
      }

      // 获取当前歌曲 - 如果没有就尝试恢复
      let currentSong = this.playlistModel.getCurrentSong();
      if (!currentSong) {
        console.log("Heanup2 UnifiedPlayerService: 没有可播放的歌曲，尝试恢复持久化状态");
        await this.restorePersistedState();
        currentSong = this.playlistModel.getCurrentSong();

        if (!currentSong) {
          console.log("Heanup2 UnifiedPlayerService: 恢复后仍然没有可播放的歌曲");
          await this.handlePlaybackError(new Error('No song to play'), PlayerErrorType.PLAYBACK_ERROR);
          return;
        }
        console.log("Heanup2 UnifiedPlayerService: 恢复成功，当前歌曲信息:" + json.stringify(currentSong));
      }

      this.stateModel.updateLoadingState(true);

      // 简化的播放器状态检查 - 检查是否可以从暂停恢复
      const ijkPlayer = this.playerManager.getIjkPlayer()!; // 服务就绪后播放器一定存在
      const shouldResumeFromPause = this.canResumeFromPause(ijkPlayer);

      if (shouldResumeFromPause) {
        console.log("Heanup2 UnifiedPlayerService: 从暂停状态恢复播放");
        return await this.resumeFromPause();
      }

      // 新歌播放前的必要检查
      await this.validateSongForPlayback(currentSong);

      // 设置播放器并开始播放
      await this.setupAndStartPlayback(currentSong);
      await this.doUpdateAvSessionMetadata(currentSong)

    } catch (error) {
      this.stateModel.updateLoadingState(false);
      this.stateModel.updatePlayingState(false);
      await this.handlePlaybackError(error as Error, PlayerErrorType.PLAYBACK_ERROR);
    }
  }

  /**
   * 检查是否可以从暂停状态恢复播放
   */
  private canResumeFromPause(ijkPlayer: IjkMediaPlayer): boolean {
    const isPausedByManager = this.playerManager.isPausedState();
    const isCurrentlyPlaying = ijkPlayer.isPlaying();
    const playerDuration = ijkPlayer.getDuration();
    const hasValidMedia = playerDuration > 0;

    // 如果认为是暂停但没有有效媒体，清除假暂停状态
    if (isPausedByManager && !hasValidMedia) {
      console.log("Heanup2 UnifiedPlayerService: 检测到假暂停状态，清除暂停标记");
      this.playerManager.clearPausedState();
      this.isPlayerPreparedForCurrentSong = false;
      return false;
    }

    // 如果播放器正在播放，同步状态
    if (isCurrentlyPlaying) {
      this.syncPlayingState();
      return false; // 不需要恢复，已经在播放
    }

    // 检查是否可以从暂停恢复
    const canResume = isPausedByManager &&
      !isCurrentlyPlaying &&
      hasValidMedia &&
    this.isPlayerPreparedForCurrentSong;

    console.log(`Heanup2 UnifiedPlayerService: 暂停恢复检查 - canResume: ${canResume}`);
    return canResume;
  }

  /**
   * 同步播放状态
   */
  private syncPlayingState(): void {
    console.log("Heanup2 UnifiedPlayerService: 播放器正在播放，同步状态");
    this.stateModel.updateLoadingState(false);
    this.stateModel.updatePlayingState(true);
    this.playerManager.clearPausedState();
    this.startProgressTimer();
    this.updateSessionPlayState();
    this.updateWidgetsForStateChange();
    // 同步更新所有桌面卡片状态
    this.updateAllForms();
  }

  public async toggleFavorite(): Promise<void> {

    let isFav = 0
    let item = this.getCurrentSong() as VideoItem;
    if (Utility.getIsFav(this.getFav(), item)) {
      isFav = 0
    } else {
      isFav = 1
    }

    return new Promise<void>((resolve) => {
      this.getTable().updateIsFavByFilePath(item.filePath, isFav, async (result: boolean) => {
        if (result) {
          // 刷新UnifiedPlayerService的收藏状态，这会自动更新AVSession
          console.log("Heanup2  UnifiedPlayerService toggleFavorite: 收藏状态切换");
          await this.refreshFavoriteStatus();

          // 立即更新桌面卡片状态，确保收藏图标正确显示
          await this.updateAllForms(true);

          console.log("Heanup2  UnifiedPlayerService toggleFavorite: 收藏状态和卡片状态更新完成");
        }
        resolve();
      })
    });
  }

  /**
   * 从暂停状态恢复播放
   */
  private async resumeFromPause(): Promise<void> {
    try {
      console.log("Heanup2 UnifiedPlayerService: 直接从暂停状态恢复播放");
      this.stateModel.updateLoadingState(false);
      await this.playerManager.startPlayOrResumePlay();
      this.stateModel.updatePlayingState(true);
      this.startProgressTimer();

      setTimeout(() => this.updateProgress(), 100);
      this.saveCurrentState();
      this.updateSessionPlayState();
      await this.updateWidgetsForPlayStateChange();

      // 同步更新所有桌面卡片状态
      await this.updateAllForms();
    } catch (error) {
      throw new Error(`Resume from pause failed: ${error}`);
    }
  }

  /**
   * 验证歌曲是否可以播放
   */
  private async validateSongForPlayback(song: VideoItem): Promise<void> {
    // 检查文件是否存在（对于本地文件）
    if (!song.filePath.startsWith('http')) {
      const fileExists = await this.checkFileExists(song.filePath);
      if (!fileExists) {
        throw new Error(`File not found: ${song.filePath}`);
      }
    } else {
      // 检查网络连接（对于网络资源）
      const networkAvailable = await this.checkNetworkConnection();
      if (!networkAvailable) {
        throw new Error('Network not available');
      }
    }
  }

  /**
   * 设置播放器并开始播放
   */
  private async setupAndStartPlayback(song: VideoItem): Promise<void> {
    console.log(`Heanup2 UnifiedPlayerService: 设置播放器并开始播放: ${song.name}`);

    // 在随机播放模式下，确保播放历史被正确维护
    const playMode = this.stateModel.getState().playMode;
    if (playMode === PlayMode.RANDOM) {
      await this.playlistModel.ensureCurrentSongInHistory();
    }

    // 设置播放源和配置
    await this.setupPlayerForSong(song);

    // 准备播放器（实际播放会在 onPrepared 回调中开始）
    const preparedPlayer = this.playerManager.getIjkPlayer();
    if (preparedPlayer) {
      preparedPlayer.prepareAsync();
    }

    // 立即更新基础元数据（使用解析的duration），后续在播放器准备好后会用实际duration更新
    await this.updateAvSessionMetadata(song);
    this.restorePlaybackPosition(song);
    this.currentRetryCount = 0;
  }

  /**
   * 直接播放新歌曲，避免恢复逻辑干扰
   * 专为 playNext/playPrevious 设计
   */
  private async playNewSongDirectly(song: VideoItem | null): Promise<void> {
    if (!song) {
      throw new Error('No song provided for direct play');
    }

    this.stateModel.updateLoadingState(true);

    const playerInstance = this.playerManager.getIjkPlayer();
    if (!playerInstance) {
      throw new Error('Player not initialized');
    }

    // 检查文件是否存在（对于本地文件）
    if (!song.filePath.startsWith('http')) {
      const fileExists = await this.checkFileExists(song.filePath);
      if (!fileExists) {
        throw new Error(`File not found: ${song.filePath}`);
      }
    }

    // 在随机播放模式下，确保播放历史被正确维护
    const playMode = this.stateModel.getState().playMode;
    if (playMode === PlayMode.RANDOM) {
      await this.playlistModel.ensureCurrentSongInHistory();
    }

    // 设置播放源和配置
    await this.setupPlayerForSong(song);

    // 准备播放器
    const preparedPlayer = this.playerManager.getIjkPlayer();
    if (preparedPlayer) {
      preparedPlayer.prepareAsync();
      // 注意：实际播放和状态更新会在 onPrepared 回调中开始
    }
    // 重置重试计数
    this.currentRetryCount = 0;
  }

  async pause(): Promise<void> {
    try {
      // 检查服务是否已准备就绪
      if (!this.isAllServicesReady()) {
        LogUtils.getInstance().LOGI('UnifiedPlayerService: pause - 服务未就绪');
        // 对于暂停操作，如果服务未就绪，可以尝试简单的状态更新
        this.stateModel.updatePlayingState(false);
        return;
      }


      // 保存当前播放位置
      this.savePlaybackPosition();

      // 暂停播放器 - 确保先暂停播放器
      this.playerManager.pausePlayback();

      // 立即更新状态模型为暂停状态，确保状态同步
      this.stateModel.updatePlayingState(false);

      // 停止进度定时器
      this.stopProgressTimer();

      // 等待一小段时间确保播放器状态稳定
      await new Promise<void>(resolve => setTimeout(resolve, 50));

      // 保存播放状态变化
      this.saveCurrentState();


      this.updateSessionPlayState();

      // 更新卡片显示暂停状态
      await this.updateWidgetsForPlayStateChange();

      // 同步更新所有桌面卡片状态
      await this.updateAllForms();

    } catch (error) {
      LogUtils.getInstance().LOGI(`UnifiedPlayerService pause error: ${error}`);
    }
  }

  async stop(): Promise<void> {
    try {
      this.savePlaybackPosition();
      this.playerManager.stopPlayback();

      // 重要：停止时应该清除所有播放状态，不是暂停状态
      this.stateModel.updatePlayingState(false);
      // this.stateModel.state.isPaused = false; // 停止不是暂停
      this.stateModel.updateProgress(0, 0);
      this.stopProgressTimer();

      // 通知状态变化
      this.stateModel.notifySongChanged(this.getCurrentSong() as VideoItem);

      // 更新卡片显示停止状态
      await this.updateWidgetsForPlayStateChange();

      LogUtils.getInstance().LOGI('UnifiedPlayerService: Stop completed, all states cleared');
    } catch (error) {
      LogUtils.getInstance().LOGI(`UnifiedPlayerService stop error: ${error}`);
      throw new Error;
    }
  }

  /**
   * 静默停止播放，不触发状态变化通知（用于歌曲切换）
   */
  private async stopSilently(): Promise<void> {
    try {
      this.savePlaybackPosition();
      this.playerManager.stopPlayback();
      this.stopProgressTimer();
      // 不调用 updatePlayingState，避免触发状态变化通知

    } catch (error) {
      LogUtils.getInstance().LOGI(`UnifiedPlayerService stopSilently error: ${error}`);
      throw new Error;
    }
  }

  async seekTo(position: string): Promise<void> {
    try {
      const currentSong = this.playlistModel.getCurrentSong();
      if (!currentSong) {
        throw new Error('No song to seek');
      }

      // 检查是否支持拖动（wma格式不支持）
      if (StrUtil.isNotEmpty(currentSong.filePath) &&
      currentSong.filePath.toLowerCase().endsWith('.wma')) {
        throw new Error('WMA format does not support seeking');
      }

      await this.playerManager.seekToPosition(position);
    } catch (error) {
      throw new Error(`Failed to seek to position: ${error}`);
    }
  }

  // 播放列表控制方法
  async playNext(): Promise<void> {
    return this.changeTrack('next');
  }

  async playPrevious(): Promise<void> {
    return this.changeTrack('previous');
  }

  /**
   * 切换歌曲（下一首或上一首）
   * @param direction - 切换方向，'next' 或 'previous'
   */
  async changeTrack(direction: 'next' | 'previous'): Promise<void> {
    try {
      // 1. 设置手动歌曲切换标志，防止自动播放等逻辑干扰
      this.isManualSongChange = true;

      // 2. 检查服务是否已准备就绪
      if (!this.isAllServicesReady()) {
        LogUtils.getInstance().LOGI(`UnifiedPlayerService: ${direction} - 服务未就绪，等待服务初始化完成`);
        const isReady = await this.waitForAllServicesReady(500, false);
        if (!isReady) {
          LogUtils.getInstance().LOGI(`UnifiedPlayerService: Services not ready for ${direction}, skipping`);
          // 统一处理方式：在服务未就绪时直接返回，避免抛出错误中断用户体验
          this.isManualSongChange = false;
          return;
        }
      }

      const playMode = this.stateModel.getState().playMode;
      let moved = false;

      // 3. 根据 direction 参数执行不同的逻辑
      if (direction === 'next') {
        if (this.playlistModel.hasNext(playMode)) {
          moved = this.playlistModel.moveToNext(playMode);
        }
      } else { // direction === 'previous'
        if (await this.playlistModel.hasPrevious(playMode)) {
          // 注意：'previous' 相关的操作是异步的，需要 await
          moved = await this.playlistModel.moveToPrevious(playMode);
        }
      }

      // 如果没有成功移动（列表到头/尾，或移动失败），则直接返回
      if (!moved) {
        this.isManualSongChange = false;
        return;
      }

      const newIndex = this.playlistModel.getCurrentIndex();
      const newSong = this.playlistModel.getCurrentSong();

      this.stateModel.updateCurrentIndex(newIndex);
      if (newSong) {
        this.stateModel.updateCurrentSong(newSong);
      }

      // 静默停止当前播放
      await this.stopSilently();

      // 直接播放新歌曲
      await this.playNewSongDirectly(newSong);

      // 更新播放列表状态
      await this.updatePlaylistStateInModel();

      // 播放新歌曲后，等待一段时间确保播放器状态稳定，然后更新卡片
      setTimeout(async () => {
        try {
          // 确保播放列表状态是最新的
          this.updatePlaylistStateInModelSync();

          // 强制更新所有桌面卡片状态
          await this.updateAllForms(true);
          if (newSong) {
            await this.updateAvSessionMetadata(newSong)
          }

          LogUtils.getInstance().LOGI('UnifiedPlayerService: Widget state updated after track change');
        } catch (error) {
          LogUtils.getInstance().LOGI(`UnifiedPlayerService: Failed to update widgets after track change: ${error}`);
        }
      }, 200); // 延迟200ms确保播放器状态稳定

    } catch (error) {
      await this.handlePlaybackError(error as Error, PlayerErrorType.PLAYBACK_ERROR);
    } finally {
      // 5. 在任何情况下都清除手动切换标志
      setTimeout(() => {
        this.isManualSongChange = false;
      }, 1000); // 延迟1秒清除，确保播放器状态稳定
    }
  }

  async playSongAtIndex(index: number): Promise<void> {
    try {
      // 设置手动歌曲切换标志，防止自动播放干扰
      this.isManualSongChange = true;

      const success = this.playlistModel.playSongAtIndex(index);
      if (!success) {
        this.isManualSongChange = false;
        throw new Error(`Invalid song index: ${index}`);
      }

      this.stateModel.updateCurrentIndex(index);

      // 静默停止当前播放并开始新歌曲（不触发状态变化通知）
      await this.stopSilently();

      // 在随机播放模式下，确保当前歌曲被添加到播放历史
      const playMode = this.stateModel.getState().playMode;
      if (playMode === PlayMode.RANDOM) {
        await this.playlistModel.ensureCurrentSongInHistory();
      }

      await this.startPlayOrResumePlay();

      // 更新状态模型中的播放列表状态
      await this.updatePlaylistStateInModel();

      // 通知歌曲变化
      const currentSong = this.playlistModel.getCurrentSong();
      if (currentSong) {
        this.stateModel.updateCurrentSong(currentSong);
      }

      // 同步更新所有桌面卡片状态
      await this.updateAllForms();

    } catch (error) {
      throw new Error;
    } finally {
      // 确保在任何情况下都清除手动切换标志
      setTimeout(() => {
        this.isManualSongChange = false;
      }, 1000); // 延迟1秒清除，确保播放器状态稳定
    }
  }

  // 状态查询方法
  getCurrentState(): PlayerState {
    return this.stateModel.getState();
  }

  /**
   * 获取播放器实际播放状态（最准确）
   * 直接从ijkPlayer获取，不依赖状态模型
   */
  getActualPlayingState(): boolean {
    try {
      const ijkPlayer = this.playerManager?.getIjkPlayer();
      if (ijkPlayer) {
        return ijkPlayer.isPlaying();
      }
      return false;
    } catch (error) {
      LogUtils.getInstance().LOGI(`UnifiedPlayerService: Failed to get actual playing state: ${error}`);
      return false;
    }
  }

  getCurrentSong(): VideoItem | null {
    return this.playlistModel.getCurrentSong();
  }

  getFav(): Array<VideoItem> {
    if (this.favList.length > 0) {
      return this.favList;
    }
    // 如果缓存为空，异步更新但返回空数组，避免阻塞
    this.getTable().queryByisFav(1, async (result: VideoItem[]) => {
      this.favList = result;
      // 更新收藏列表后，重新更新AVSession状态以反映正确的收藏状态
      if (result.length > 0) {
        setTimeout(() => {
          this.updateSessionPlayState();
        }, 100);
      }
    })
    return this.favList;
  }

  /**
   * 获取当前歌曲的收藏状态
   */
  private getCurrentSongFavoriteState(): boolean {
    try {
      let currentSong = this.playlistModel.getCurrentSong();
      if (!currentSong) {
        LogUtils.getInstance().LOGI(`UnifiedPlayerService: 当前歌曲为空`);
        return false;
      }

      let favList = this.getFav();
      if (!favList || favList.length === 0) {
        // 如果收藏列表为空，可能还在加载中，先返回false
        // 但不记录为错误，因为这是正常的初始化状态
        return false;
      }

      // 检查当前歌曲是否在收藏列表中
      for (let i = 0; i < favList.length; i++) {
        if (favList[i].filePath === currentSong.filePath && favList[i].isFav === 1) {
          LogUtils.getInstance().LOGI(`UnifiedPlayerService: 收藏歌曲：${currentSong.filePath}`);
          return true;
        }
      }
      LogUtils.getInstance().LOGI(`UnifiedPlayerService: 未收藏歌曲：${currentSong.filePath}`);
      return false;
    } catch (error) {
      LogUtils.getInstance().LOGI(`UnifiedPlayerService: Failed to get favorite state: ${error}`);
      return false;
    }
  }

  /**
   * 初始化收藏列表
   */
  private async initializeFavoriteList(): Promise<void> {
    try {
      return new Promise<void>((resolve) => {
        this.getTable().queryByisFav(1, (result: VideoItem[]) => {
          this.favList = result;
          LogUtils.getInstance()
            .LOGI(`UnifiedPlayerService: Favorite list initialized with ${this.favList.length} items`);
          resolve();
        });
      });
    } catch (error) {
      LogUtils.getInstance().LOGI(`UnifiedPlayerService: Failed to initialize favorite list: ${error}`);
    }
  }

  /**
   * 更新收藏列表
   */
  public async updateFavoriteList(): Promise<void> {
    try {
      return new Promise<void>((resolve) => {
        this.getTable().queryByisFav(1, (result: VideoItem[]) => {
          this.favList = result;
          LogUtils.getInstance().LOGI(`UnifiedPlayerService: Favorite list updated with ${this.favList.length} items`);

          // 更新收藏列表后，立即更新AVSession状态以反映正确的收藏状态
          setTimeout(() => {
            this.updateSessionPlayState();
            this.updateAllForms();
          }, 100);

          resolve();
        });
      });
    } catch (error) {
      LogUtils.getInstance().LOGI(`UnifiedPlayerService: Failed to update favorite list: ${error}`);
    }
  }

  /**
   * 强制刷新收藏状态（用于收藏/取消收藏操作后）
   */
  public async refreshFavoriteStatus(): Promise<void> {
    try {
      // 清空缓存，强制重新加载
      this.favList = [];
      await this.updateFavoriteList();

      // 触发状态变化通知，确保LocalMusic UI能收到收藏状态变化
      this.stateModel.forceNotifyStateChanged();

      LogUtils.getInstance().LOGI('UnifiedPlayerService: Favorite status refreshed and state change notified');
    } catch (error) {
      LogUtils.getInstance().LOGI(`UnifiedPlayerService: Failed to refresh favorite status: ${error}`);
    }
  }

  private getTable(): MediaTable {
    if (this.table) {
      return this.table;
    }
    if (this.context) {
      this.table = new MediaTable(this.context);
      return this.table;
    }
    return new MediaTable(getContext(this) as common.UIAbilityContext);
  }

  getPlaylist(): VideoItem[] {
    return this.playlistModel.getSongs();
  }

  getCurrentIndex(): number {
    return this.playlistModel.getCurrentIndex();
  }

  /**
   * 检查数据是否已从持久化存储恢复
   */
  isDataRestorationCompleted(): boolean {
    return this.isDataRestored;
  }

  /**
   * 等待数据恢复完成
   */
  async waitForDataRestoration(maxWaitMs: number = 3000): Promise<boolean> {
    const startTime = Date.now();
    while (!this.isDataRestored && (Date.now() - startTime) < maxWaitMs) {
      await new Promise<void>(resolve => setTimeout(resolve, 100));
    }
    return this.isDataRestored;
  }

  /**
   * 强制触发数据恢复（用于桌面卡片冷启动场景）
   */
  async forceDataRestoration(): Promise<boolean> {
    try {
      LogUtils.getInstance().LOGI('UnifiedPlayerService: Force data restoration started');

      // 如果数据已经恢复，直接返回
      if (this.isDataRestored) {
        LogUtils.getInstance().LOGI('UnifiedPlayerService: Data already restored');
        return true;
      }

      // 强制执行数据恢复
      await this.restorePersistedState();

      // 如果播放列表仍为空，尝试从内存快速恢复
      if (this.playlistModel.getTotalCount() === 0) {
        LogUtils.getInstance().LOGI('UnifiedPlayerService: Playlist empty, trying memory restore');
        await this.fastRestoreFromMemory();
      }

      LogUtils.getInstance()
        .LOGI(`UnifiedPlayerService: Force restoration completed, playlist size: ${this.playlistModel.getTotalCount()}`);
      return this.isDataRestored;
    } catch (error) {
      LogUtils.getInstance().LOGI(`UnifiedPlayerService: Force data restoration failed: ${error}`);
      return false;
    }
  }

  /**
   * 检查所有相关服务是否已准备就绪
   * 用于桌面卡片控制等场景，确保在执行播放控制前服务状态正常
   */
  isAllServicesReady(): boolean {
    try {
      // 检查基本初始化状态
      if (!this.isInitialized) {
        LogUtils.getInstance().LOGI('UnifiedPlayerService: Service not initialized');
        return false;
      }

      // 检查核心组件是否就绪
      if (!this.playerManager || !this.stateModel || !this.playlistModel) {
        LogUtils.getInstance().LOGI('UnifiedPlayerService: Core components not ready');
        return false;
      }

      // 检查 PlayerManager 是否已经初始化
      const playerInstance = this.playerManager.getIjkPlayer();
      if (!playerInstance) {
        LogUtils.getInstance().LOGI('UnifiedPlayerService: Player instance not ready');
        return false;
      }

      // 检查上下文是否可用
      if (!this.context) {
        LogUtils.getInstance().LOGI('UnifiedPlayerService: Context not available');
        return false;
      }

      LogUtils.getInstance().LOGI('UnifiedPlayerService: All services ready');
      return true;
    } catch (error) {
      LogUtils.getInstance().LOGI(`UnifiedPlayerService: Service readiness check failed: ${error}`);
      return false;
    }
  }

  /**
   * 验证初始化完整性
   * 在应用启动后调用，确保所有关键组件都已正确初始化
   */
  validateInitialization(): InitializationValidation {
    const errors: string[] = [];
    const warnings: string[] = [];

    try {
      // 检查基础初始化
      if (!this.isInitialized) {
        errors.push('Service not initialized');
      }

      // 检查核心组件
      if (!this.playerManager) {
        errors.push('PlayerManager not available');
      } else {
        const playerInstance = this.playerManager.getIjkPlayer();
        if (!playerInstance) {
          warnings.push('Player instance not ready (may initialize later)');
        }
      }

      if (!this.stateModel) {
        errors.push('StateModel not available');
      }

      if (!this.playlistModel) {
        errors.push('PlaylistModel not available');
      }

      if (!this.context) {
        warnings.push('Context not set (may be set later)');
      }

      // 检查数据持久化服务
      if (!this.dataPersistence) {
        errors.push('DataPersistence service not available');
      }

      if (!this.playlistSync) {
        errors.push('PlaylistSync service not available');
      }


      // 检查错误恢复策略
      if (!this.errorRecovery) {
        warnings.push('ErrorRecovery strategy not available');
      }

      const isValid = errors.length === 0;

      LogUtils.getInstance()
        .LOGI(`UnifiedPlayerService validation: ${isValid ? 'VALID' :
          'INVALID'}, errors: ${errors.length}, warnings: ${warnings.length}`);

      const result: InitializationValidation = {
        isValid,
        errors,
        warnings
      };

      return result;

    } catch (error) {
      errors.push(`Validation failed with exception: ${error}`);
      const result: InitializationValidation = {
        isValid: false,
        errors,
        warnings
      };
      return result;
    }
  }

  /**
   * 获取服务就绪状态的详细信息
   * 用于调试和用户反馈
   */
  getServiceReadinessInfo(): ServiceReadinessInfo {
    const playerInstance = this.playerManager?.getIjkPlayer();
    const playlistSize = this.playlistModel?.getTotalCount() || 0;
    const currentIndex = this.playlistModel?.getCurrentIndex() || -1;

    const details: ServiceReadinessDetails = {
      initialized: this.isInitialized,
      hasPlayerInstance: !!playerInstance,
      hasContext: !!this.context,
      dataRestored: this.isDataRestored,
      playlistSize: playlistSize,
      currentIndex: currentIndex
    };

    const isReady = this.isAllServicesReady();

    LogUtils.getInstance().LOGI(`UnifiedPlayerService readiness: ${JSON.stringify(details)}`);

    const result: ServiceReadinessInfo = { isReady, details };
    return result;
  }

  /**
   * 等待所有服务准备就绪
   * @param maxWaitMs 最大等待时间（毫秒）
   * @param checkDataRestore 是否同时等待数据恢复完成
   */
  async waitForAllServicesReady(maxWaitMs: number = 5000, checkDataRestore: boolean = true): Promise<boolean> {
    const startTime = Date.now();
    const checkInterval = 100; // 每100ms检查一次

    LogUtils.getInstance()
      .LOGI(`UnifiedPlayerService: Waiting for services ready (maxWait: ${maxWaitMs}ms, checkDataRestore: ${checkDataRestore})`);

    while ((Date.now() - startTime) < maxWaitMs) {
      // 检查基础服务就绪状态
      if (this.isAllServicesReady()) {
        // 如果不需要检查数据恢复，直接返回成功
        if (!checkDataRestore) {
          LogUtils.getInstance().LOGI('UnifiedPlayerService: All services ready (data restore check skipped)');
          return true;
        }

        // 检查数据恢复状态
        if (this.isDataRestored) {
          LogUtils.getInstance().LOGI('UnifiedPlayerService: All services ready and data restored');
          return true;
        }

        // 检查播放列表是否有数据（即使数据恢复标识未设置）
        const playlistSize = this.playlistModel.getTotalCount();
        if (playlistSize > 0) {
          LogUtils.getInstance()
            .LOGI(`UnifiedPlayerService: Services ready with playlist data (${playlistSize} songs)`);
          return true;
        }
      }

      // 短暂等待后继续检查
      await new Promise<void>(resolve => setTimeout(resolve, checkInterval));
    }

    // 超时检查最终状态
    const finalCheck = this.isAllServicesReady();
    const playlistSize = this.playlistModel?.getTotalCount() || 0;
    LogUtils.getInstance()
      .LOGI(`UnifiedPlayerService: Service readiness timeout - finalCheck: ${finalCheck}, playlistSize: ${playlistSize}, dataRestored: ${this.isDataRestored}`);

    return finalCheck;
  }

  // 播放模式控制
  setPlayMode(mode: number): void {
    const playMode = mode as PlayMode;
    this.stateModel.updatePlayMode(playMode);

    LogUtils.getInstance().LOGI(`UnifiedPlayerService: Play mode set to ${mode}`);
  }

  getPlayMode(): number {
    return this.stateModel.getState().playMode;
  }

  // 音量和速度控制
  setVolume(volume: number): void {
    const volumeStr = volume.toString();
    this.playerManager.setVolume(volumeStr, volumeStr);
    this.stateModel.updateVolume(volume);
    LogUtils.getInstance().LOGI(`UnifiedPlayerService: Volume set to ${volume}`);
  }

  setPlaybackSpeed(speed: number): void {
    const speedStr = speed.toString() + 'f';
    this.playerManager.setPlaybackSpeed(speedStr);
    this.stateModel.updateSpeed(speed);
    LogUtils.getInstance().LOGI(`UnifiedPlayerService: Speed set to ${speed}`);
  }

  // 播放列表管理
  setPlaylist(songs: VideoItem[], currentIndex: number = 0): void {
    // 记录调用栈信息以便调试
    const stack = new Error().stack || 'No stack available';
    const caller = stack.split('\n')[2] || 'Unknown caller';

    this.playlistModel.replaceSongs(songs, currentIndex);
    this.stateModel.updateCurrentIndex(currentIndex);

    // 更新状态模型中的播放列表状态
    this.updatePlaylistStateInModelSync();

    // 更新当前歌曲
    const currentSong = this.playlistModel.getCurrentSong();
    this.stateModel.updateCurrentSong(currentSong);

    // 同步到持久化存储
    this.syncPlaylistToStorage();

    // 更新卡片显示播放列表变化
    this.updateWidgetsForPlaylistChange();

    LogUtils.getInstance()
      .LOGI(`UnifiedPlayerService: Playlist set with ${songs.length} songs, caller: ${caller.trim()}`);

    // 如果设置的是小播放列表，记录更多信息
    if (songs.length <= 20) {
      LogUtils.getInstance()
        .LOGI(`UnifiedPlayerService: Small playlist detected, caller stack: ${stack.substring(0, 500)}`);
    }
  }

  addToPlaylist(song: VideoItem, index?: number): void {
    this.playlistModel.addSong(song, index);

    // 更新状态模型中的播放列表状态
    this.updatePlaylistStateInModelSync();

    // 同步到持久化存储
    this.syncPlaylistToStorage();

    // 更新卡片显示播放列表变化
    this.updateWidgetsForPlaylistChange();

    LogUtils.getInstance().LOGI(`UnifiedPlayerService: Song added to playlist`);
  }

  removeFromPlaylist(index: number): VideoItem | null {
    const removedSong = this.playlistModel.removeSong(index);
    if (removedSong) {
      this.stateModel.updateCurrentIndex(this.playlistModel.getCurrentIndex());

      // 更新状态模型中的播放列表状态
      this.updatePlaylistStateInModelSync();

      // 更新当前歌曲
      const currentSong = this.playlistModel.getCurrentSong();
      this.stateModel.updateCurrentSong(currentSong);

      // 同步到持久化存储
      this.syncPlaylistToStorage();

      // 更新卡片显示播放列表变化
      this.updateWidgetsForPlaylistChange();

      LogUtils.getInstance().LOGI(`UnifiedPlayerService: Song removed from playlist at index ${index}`);
    }
    return removedSong;
  }

  /**
   * 同步播放列表到服务
   * 从LocalMusic迁移的方法，用于统一调用
   */
  syncPlaylistToService(songList: VideoItem[], currentIndex: number, playType: PlayMode): void {
    try {
      if (songList && songList.length > 0) {
        // 记录调用栈信息以便调试
        const stack = new Error().stack || 'No stack available';
        const caller = stack.split('\n')[2] || 'Unknown caller';

        this.setPlaylist(songList, currentIndex);

        // 同步播放模式到UnifiedPlayerService
        this.setPlayMode(playType);

        LogUtils.getInstance().LOGI(`UnifiedPlayerService: Playlist and play mode synced - ${songList.length} songs, mode: ${playType}, caller: ${caller.trim()}`);

        // 如果同步的是小播放列表，记录更多信息
        if (songList.length <= 20) {
          LogUtils.getInstance().LOGI(`UnifiedPlayerService: Small playlist sync detected, first few songs: ${songList.slice(0, 5).map(s => s.name).join(', ')}`);
        }
      } else {
        LogUtils.getInstance().LOGI('UnifiedPlayerService: syncPlaylistToService - No songs to sync');
      }
    } catch (error) {
      LogUtils.getInstance().LOGI(`UnifiedPlayerService syncPlaylistToService error: ${error}`);
    }
  }

  // 事件监听
  addStateListener(listener: PlayerStateListener): void {
    this.stateModel.addStateListener(listener);
  }

  removeStateListener(listener: PlayerStateListener): void {
    this.stateModel.removeStateListener(listener);
  }

  // 清理资源
  release(): void {
    try {
      this.stopProgressTimer();

      // 清理防抖定时器
      if (this.avSessionUpdateTimer !== -1) {
        clearTimeout(this.avSessionUpdateTimer);
        this.avSessionUpdateTimer = -1;
      }
      if (this.avMetadataUpdateTimer !== -1) {
        clearTimeout(this.avMetadataUpdateTimer);
        this.avMetadataUpdateTimer = -1;
      }

      // 重要修复：确保在应用销毁时将播放状态设置为停止
      try {
        // 强制设置为停止状态，防止卡片显示错误的播放状态
        this.stateModel.updatePlayingState(false);
        this.stateModel.updateLoadingState(false);
        
        // 确保播放器也停止
        if (this.playerManager) {
          this.playerManager.release() ;
        }
        
        LogUtils.getInstance().LOGI('UnifiedPlayerService: Forced stop state before release');
      } catch (error) {
        LogUtils.getInstance().LOGI(`UnifiedPlayerService: Failed to force stop state: ${error}`);
      }

      // 保存当前状态（现在应该是停止状态）
      this.saveCurrentState();

      if (this.avSessionController) {
        this.avSessionController.unregisterSessionListener();
        this.avSessionController = null;
      }

      // 清理同步监听器
      this.playlistSync.removeSyncListener(this);
      this.playlistSync.release();

      this.playerManager.release();

      this.playlistModel.clear();
      this.isInitialized = false;

      LogUtils.getInstance().LOGI('UnifiedPlayerService: Resources released');
    } catch (error) {
      LogUtils.getInstance().LOGI(`UnifiedPlayerService release error: ${error}`);
    }
  }


  /**
   * 初始化AVSession
   * 按照官方文档的要求：创建 -> 注册控制命令 -> 设置元数据 -> 激活
   */
  private initializeAvSession(): void {
    try {

      this.avSessionController = AvSessionController.getInstance(false);
      LogUtils.getInstance().LOGI('UnifiedPlayerService: AVSession controller created');


      setTimeout(() => {
        this.setAvSessionListener();
        LogUtils.getInstance().LOGI('UnifiedPlayerService: AVSession listeners configured');
      }, 500);

    } catch (error) {
      LogUtils.getInstance().LOGI(`UnifiedPlayerService: Failed to initialize AVSession: ${error}`);
    }
  }


  /**
   * 设置AVSession监听器
   * 注意：控制命令已在AvSessionController中注册，这里设置实际的处理逻辑
   */
  private setAvSessionListener(): void {
    if (!this.avSessionController) {
      return;
    }

    const avSession = this.avSessionController.getAvSession();
    if (!avSession) {
      LogUtils.getInstance().LOGI('UnifiedPlayerService: AVSession not available for listener setup');
      return;
    }

    try {

      // 播放事件监听
      avSession.on('play', () => {
        this.startPlayOrResumePlay().catch((error: Error) => {
          LogUtils.getInstance().LOGI(`AVSession play command failed: ${error}`);
        });
      });

      // 暂停事件监听
      avSession.on('pause', () => {
        LogUtils.getInstance().LOGI('UnifiedPlayerService: AVSession pause command received');
        this.pause().catch((error: Error) => {
          LogUtils.getInstance().LOGI(`AVSession pause command failed: ${error}`);
        });
      });

      // 停止事件监听
      avSession.on('stop', () => {
        LogUtils.getInstance().LOGI('UnifiedPlayerService: AVSession stop command received');
        this.stop().catch((error: Error) => {
          LogUtils.getInstance().LOGI(`AVSession stop command failed: ${error}`);
        });
      });

      // 下一首事件监听
      avSession.on('playNext', () => {
        LogUtils.getInstance().LOGI('UnifiedPlayerService: AVSession playNext command received');
        this.playNext().catch((error: Error) => {
          LogUtils.getInstance().LOGI(`AVSession playNext command failed: ${error}`);
        });
      });

      // 上一首事件监听
      avSession.on('playPrevious', () => {
        LogUtils.getInstance().LOGI('UnifiedPlayerService: AVSession playPrevious command received');
        this.playPrevious().catch((error: Error) => {
          LogUtils.getInstance().LOGI(`AVSession playPrevious command failed: ${error}`);
        });
      });

      // 拖拽进度事件监听
      avSession.on('seek', (time: number) => {
        LogUtils.getInstance().LOGI(`UnifiedPlayerService: AVSession seek command received: ${time}ms`);
        this.seekTo(time.toString()).catch((error: Error) => {
          LogUtils.getInstance().LOGI(`AVSession seek command failed: ${error}`);
        });
      });

      // 播放模式设置监听
      avSession.on('setLoopMode', (mode: number) => {
        LogUtils.getInstance().LOGI(`UnifiedPlayerService: AVSession setLoopMode command received: ${mode}`);
        try {
          this.setPlayMode(mode);
          // 更新AvSession播放状态以反映新的播放模式
          this.updateSessionPlayState();
          // 同步更新桌面卡片
          this.updateAllForms();
        } catch (error) {
          LogUtils.getInstance().LOGI(`AVSession setLoopMode command failed: ${error}`);
        }
      });

      LogUtils.getInstance().LOGI('UnifiedPlayerService: AVSession listeners set up successfully');
    } catch (error) {
      LogUtils.getInstance().LOGI(`UnifiedPlayerService: Failed to set AVSession listeners: ${error}`);
    }
  }

  /**
   * 处理播放错误
   */
  private async handlePlaybackError(error: Error,
    errorType: PlayerErrorType = PlayerErrorType.PLAYBACK_ERROR): Promise<void> {
    try {
      // 创建播放器错误对象
      const playerError = new PlayerError(errorType, error.message);
      playerError.retryCount = this.currentRetryCount;

      // 创建错误上下文
      const context: ErrorContext = {
        currentSong: this.playlistModel.getCurrentSong(),
        playlist: this.playlistModel.getSongs(),
        currentIndex: this.playlistModel.getCurrentIndex(),
        retryCount: this.currentRetryCount,
        isNetworkAvailable: true // 这里可以实际检查网络状态
      };

      // 获取恢复策略
      const recoveryAction = await this.errorRecovery.handleError(playerError, context);

      LogUtils.getInstance().LOGI(`UnifiedPlayerService: Error recovery action: ${recoveryAction}`);

      // 执行恢复动作
      await this.executeRecoveryAction(recoveryAction, playerError, context);

    } catch (recoveryError) {
      LogUtils.getInstance().LOGI(`UnifiedPlayerService: Error recovery failed: ${recoveryError}`);
      this.stateModel.notifyError(new PlayerError(PlayerErrorType.PLAYBACK_ERROR,
        `Recovery failed: ${recoveryError.message}`));
    }
  }

  /**
   * 执行错误恢复动作
   */
  private async executeRecoveryAction(action: ErrorRecoveryAction, error: PlayerError,
    context: ErrorContext): Promise<void> {
    switch (action) {
      case ErrorRecoveryAction.RETRY:
        await this.retryCurrentOperation(error);
        break;

      case ErrorRecoveryAction.SKIP_TO_NEXT:
        await this.skipToNextSong();
        break;

      case ErrorRecoveryAction.STOP_PLAYBACK:
        await this.stop();
        this.stateModel.notifyError(error);
        break;

      case ErrorRecoveryAction.WAIT_AND_RETRY:
        await this.waitAndRetry(error);
        break;

      case ErrorRecoveryAction.SHOW_ERROR:
        this.stateModel.notifyError(error);
        break;

      default:
        LogUtils.getInstance().LOGI(`UnifiedPlayerService: Unknown recovery action: ${action}`);
        this.stateModel.notifyError(error);
    }
  }

  /**
   * 重试当前操作
   */
  private async retryCurrentOperation(error: PlayerError): Promise<void> {
    try {
      this.currentRetryCount++;
      const delay = this.errorRecovery.getRetryDelay(this.currentRetryCount);

      LogUtils.getInstance()
        .LOGI(`UnifiedPlayerService: Retrying operation in ${delay}ms (attempt ${this.currentRetryCount})`);

      // 等待指定时间后重试
      setTimeout(async () => {
        try {
          await this.startPlayOrResumePlay();
          this.currentRetryCount = 0; // 重试成功，重置计数
        } catch (retryError) {
          LogUtils.getInstance().LOGI(`UnifiedPlayerService: Retry failed: ${retryError}`);
          await this.handlePlaybackError(retryError as Error, error.type);
        }
      }, delay);

    } catch (retryError) {
      LogUtils.getInstance().LOGI(`UnifiedPlayerService: Retry setup failed: ${retryError}`);
      await this.skipToNextSong();
    }
  }

  /**
   * 跳到下一首歌曲
   */
  private async skipToNextSong(): Promise<void> {
    try {
      LogUtils.getInstance().LOGI('UnifiedPlayerService: Skipping to next song due to error');

      // 重置重试计数
      this.currentRetryCount = 0;

      // 检查是否有下一首
      const playMode = this.stateModel.getState().playMode;
      if (this.playlistModel.hasNext(playMode)) {
        await this.playNext();
      } else {
        // 没有下一首，停止播放
        await this.stop();
        LogUtils.getInstance().LOGI('UnifiedPlayerService: No next song available, stopping playback');
      }

    } catch (skipError) {
      LogUtils.getInstance().LOGI(`UnifiedPlayerService: Failed to skip to next song: ${skipError}`);
      await this.stop();
    }
  }

  /**
   * 等待后重试
   */
  private async waitAndRetry(error: PlayerError): Promise<void> {
    try {
      this.currentRetryCount++;
      const delay = this.errorRecovery.getRetryDelay(this.currentRetryCount);

      LogUtils.getInstance().LOGI(`UnifiedPlayerService: Waiting ${delay}ms before retry (network error)`);

      // 更新状态为加载中
      this.stateModel.updateLoadingState(true);

      setTimeout(async () => {
        try {
          await this.startPlayOrResumePlay();
          this.currentRetryCount = 0; // 重试成功，重置计数
        } catch (retryError) {
          LogUtils.getInstance().LOGI(`UnifiedPlayerService: Network retry failed: ${retryError}`);
          await this.handlePlaybackError(retryError as Error, PlayerErrorType.NETWORK_ERROR);
        }
      }, delay);

    } catch (waitError) {
      LogUtils.getInstance().LOGI(`UnifiedPlayerService: Wait and retry setup failed: ${waitError}`);
      await this.skipToNextSong();
    }
  }

  /**
   * 检查文件是否存在
   */
  private async checkFileExists(filePath: string): Promise<boolean> {
    try {
      // 这里可以添加文件存在性检查逻辑
      // 暂时返回true，实际实现需要使用文件系统API
      return true;
    } catch (error) {
      LogUtils.getInstance().LOGI(`UnifiedPlayerService: File check failed: ${error}`);
      return false;
    }
  }

  /**
   * 检查网络连接
   */
  private async checkNetworkConnection(): Promise<boolean> {
    try {
      // 这里可以添加网络连接检查逻辑
      // 暂时返回true，实际实现需要使用网络API
      return true;
    } catch (error) {
      LogUtils.getInstance().LOGI(`UnifiedPlayerService: Network check failed: ${error}`);
      return false;
    }
  }

  // 私有辅助方法
  /**
   * 检查播放器是否需要重新设置
   */
  private async needsPlayerSetup(song: VideoItem): Promise<boolean> {
    try {
      const ijkPlayer = this.playerManager.getIjkPlayer();
      if (!ijkPlayer) {
        console.log("Heanup2 UnifiedPlayerService: 播放器不存在，需要设置");
        return true;
      }

      // 检查播放器是否有数据源
      const duration = ijkPlayer.getDuration();
      if (duration <= 0) {
        console.log("Heanup2 UnifiedPlayerService: 播放器无数据源或时长无效，需要设置");
        return true;
      }

      // 检查当前数据源是否匹配（这里我们通过检查当前歌曲信息来判断）
      const currentSong = this.playlistModel.getCurrentSong();
      if (!currentSong || currentSong.filePath !== song.filePath) {
        console.log(`Heanup2 UnifiedPlayerService: 歌曲文件路径不匹配，需要重新设置 (当前: ${currentSong?.filePath}, 目标: ${song.filePath})`);
        return true;
      }

      console.log(`Heanup2 UnifiedPlayerService: 播放器已设置正确的数据源，无需重新设置 (时长: ${duration}ms)`);
      return false;
    } catch (error) {
      console.log(`Heanup2 UnifiedPlayerService: 检查播放器设置状态时出错: ${error}，默认需要设置`);
      return true;
    }
  }

  private async setupPlayerForSong(song: VideoItem): Promise<void> {
    const ijkPlayer = this.playerManager.getIjkPlayer();
    if (!ijkPlayer) {
      throw new Error('Player not initialized');
    }

    console.log("Heanup2 UnifiedPlayerService: 开始重新设置播放器，这会重置所有状态");

    // 标记播放器未准备（因为要重新设置）
    this.isPlayerPreparedForCurrentSong = false;

    // 重置播放器 - 这会清除所有状态包括播放位置
    ijkPlayer.reset();

    // 重新设置音频模式 - 重置后需要重新设置
    ijkPlayer.setAudioId('unifiedPlayer');
    LogUtils.getInstance().LOGI(`UnifiedPlayerService: Reset audio mode for ${song.name}`);

    // 重新设置配置
    this.playerManager.setupIjkPlayerOptions();

    // 设置音量（针对dsf格式特殊处理）
    const volume = this.stateModel.getState().volume;
    if (song.filePath.toLowerCase().endsWith('.dsf')) {
      this.playerManager.setVolume('1', '1');
    } else {
      this.playerManager.setVolume(volume.toString(), volume.toString());
    }

    // 设置数据源
    ijkPlayer.setDataSource(song.filePath);
    LogUtils.getInstance().LOGI(`UnifiedPlayerService: Set data source to ${song.filePath}`);

    // 设置HTTP请求头
    const headers = new Map([
      ["user_agent", "Mozilla/5.0 BiliDroid/7.30.0 (bbcallen@gmail.com)"],
      ["referer", "https://www.bilibili.com"]
    ]);
    ijkPlayer.setDataSourceHeader(headers);

    // 设置播放速度
    const speed = this.stateModel.getState().speed;
    this.playerManager.setPlaybackSpeed(speed.toString() + 'f');

    // 设置消息监听器（重要：用于处理播放器内部事件）
    ijkPlayer.setMessageListener();

    LogUtils.getInstance().LOGI(`UnifiedPlayerService: Player setup for song ${song.name}`);
    console.log("Heanup2 UnifiedPlayerService: 播放器重新设置完成，准备开始新的播放");
  }

  private setupProgressTimer(): void {
    this.progressTimer = setInterval(() => {
      this.updateProgress();
    }, 1000); // 每秒更新一次进度
  }

  private startProgressTimer(): void {
    // 先停止现有的定时器，避免重复启动
    this.stopProgressTimer();

    // 启动新的定时器
    this.setupProgressTimer();
    LogUtils.getInstance().LOGI('UnifiedPlayerService: Progress timer started');
  }

  /**
   * 停止进度定时器
   */
  private stopProgressTimer(): void {
    if (this.progressTimer !== -1) {
      clearInterval(this.progressTimer);
      this.progressTimer = -1;
      LogUtils.getInstance().LOGI('UnifiedPlayerService: Progress timer stopped');
    }
  }

  private updateProgress(): void {
    try {
      const ijkPlayer = this.playerManager.getIjkPlayer();
      const currentState = this.stateModel.getState();

      // 只有在播放器存在、正在播放且已准备好时才更新进度
      if (!ijkPlayer || !currentState.isPlaying || !this.isPlayerPreparedForCurrentSong) {
        return;
      }

      const currentPosition = ijkPlayer.getCurrentPosition();
      const duration = ijkPlayer.getDuration();

      // 确保获取到有效的位置信息
      if (currentPosition >= 0 && duration > 0) {
        this.stateModel.updateProgress(currentPosition, duration);
        this.updateSessionPlayState();
      }
    } catch (error) {
      LogUtils.getInstance().LOGI(`UnifiedPlayerService updateProgress error: ${error}`);
    }
  }

  getCurrentPosition(): number {
    try {
      const ijkPlayer = this.playerManager.getIjkPlayer();
      if (!ijkPlayer) {
        return 0;
      }
      return ijkPlayer.getCurrentPosition();
    } catch (error) {
      LogUtils.getInstance().LOGI(`UnifiedPlayerService getCurrentPosition error: ${error}`);
      return 0;
    }
  }

  getIjkPlayer(): IjkMediaPlayer | null {
    try {
      return this.playerManager.getIjkPlayer();
    } catch (error) {
      LogUtils.getInstance().LOGI(`UnifiedPlayerService getIjkPlayer error: ${error}`);
      return null;
    }
  }

  private savePlaybackPosition(): void {
    const ijkPlayer = this.playerManager.getIjkPlayer();
    if (ijkPlayer != null) {
      const position = ijkPlayer.getCurrentPosition();
      // ToastUtil.showToast('保存记忆播放 = ' + position)
      const duration = ijkPlayer.getDuration();
      const threshold = 5000; // 阈值，单位为毫秒（这里设为5秒）

      // 如果播放位置接近视频末尾，则保存 position 为 0
      const playbackPosition = (duration - position < threshold) ? 0 : position;
      const currentSong = this.playlistModel.getCurrentSong();
      if (currentSong != null) {
        PuraPreferencesUtil.putSync(currentSong.filePath, playbackPosition);
      }

    }
  }

  private async restorePlaybackPosition(song: VideoItem): Promise<void> {
    // const position: number = PreferencesUtil.getNumberSync(this.videoUrl, 0);
    // // ToastUtil.showToast('position = ' + position)
    // if (this.mIjkMediaPlayer != null && position > 0) {
    //   // ToastUtil.showToast('seekTo = ' + position)
    //   this.seekTo(position + "");
    //
    // }
    if (song != null) {
      const position: number = PuraPreferencesUtil.getNumberSync(song.filePath, 0);
      if (position > 0) {
        await this.playerManager.seekToPosition(position.toString());
      }
    }
    // try {
    //   // 使用DataPersistenceService恢复播放进度
    //   const progressData = await this.dataPersistence.loadPlaybackProgress(song.filePath);
    //   if (progressData && progressData.position > 0 && !progressData.completed) {
    //     await this.playerManager.seekToPosition(progressData.position.toString());
    //     LogUtils.getInstance().LOGI(`UnifiedPlayerService: Restored playback position ${progressData.position}ms for ${song.name}`);
    //   }
    // } catch (error) {
    //   LogUtils.getInstance().LOGI(`UnifiedPlayerService restorePlaybackPosition error: ${error}`);
    // }
  }

  // ==================== 数据持久化和同步方法 ====================

  /**
   * 恢复持久化的状态
   */
  /**
   * 快速从内存中恢复关键数据（AppStorage）
   */
  private async fastRestoreFromMemory(): Promise<void> {
    try {
      console.log("Heanup2 UnifiedPlayerService: 开始从内存快速恢复关键数据");

      // 从AppStorage快速获取播放列表数据
      const playlistData = AppStorage.get<PlaylistData>('player_playlist');
      if (playlistData && playlistData.songs.length > 0) {
        console.log(`Heanup2 UnifiedPlayerService: 从内存快速恢复播放列表，歌曲数量=${playlistData.songs.length}`);
        this.playlistModel.replaceSongs(playlistData.songs, playlistData.currentIndex);
        this.stateModel.updateCurrentIndex(playlistData.currentIndex);
        this.stateModel.updatePlayMode(playlistData.playMode);

        // 恢复当前歌曲
        const currentSong = this.playlistModel.getCurrentSong();
        if (currentSong) {
          this.stateModel.updateCurrentSong(currentSong);
          console.log(`Heanup2 UnifiedPlayerService: 快速恢复当前歌曲: ${currentSong.name}`);
        }
      }

      // 从AppStorage快速获取播放状态数据
      const stateData = AppStorage.get<PlayerStateData>('player_state') as PlayerStateData;
      if (stateData) {
        console.log(`Heanup2 UnifiedPlayerService: 从内存快速恢复播放状态 - playing: ${stateData.isPlaying}, index: ${stateData.currentIndex}`);
        this.stateModel.updateVolume(stateData.volume);
        this.stateModel.updateSpeed(stateData.speed);
        this.stateModel.updatePlayMode(stateData.playMode);
        this.stateModel.updatePlayingState(stateData.isPlaying || false);

        if (stateData.currentIndex >= 0) {
          this.stateModel.updateCurrentIndex(stateData.currentIndex);
        }
      }

      console.log("Heanup2 UnifiedPlayerService: 内存数据快速恢复完成");

      // 设置一个临时的数据恢复完成标识，允许快速响应
      this.isDataRestored = true;

      // 立即更新播放列表状态，确保上一首/下一首状态正确
      this.updatePlaylistStateInModelSync();
    } catch (error) {
      console.log(`Heanup2 UnifiedPlayerService: 快速恢复内存数据失败: ${error}`);
    }
  }

  private async restorePersistedState(): Promise<void> {
    try {
      console.log("Heanup2 UnifiedPlayerService: 开始快速恢复持久化状态");

      // 并行加载播放列表和播放状态，提高效率
      const loadResults = await Promise.all([
        this.dataPersistence.loadPlaylist().catch(() => null),
        this.dataPersistence.loadPlayerState().catch(() => null)
      ]);
      const playlistData = loadResults[0];
      const stateData = loadResults[1];

      // 恢复播放列表
      if (playlistData && playlistData.songs.length > 0) {
        console.log(`Heanup2 UnifiedPlayerService: 恢复播放列表，歌曲数量=${playlistData.songs.length}, 当前索引=${playlistData.currentIndex}`);
        this.playlistModel.replaceSongs(playlistData.songs, playlistData.currentIndex);
        this.stateModel.updateCurrentIndex(playlistData.currentIndex);
        this.stateModel.updatePlayMode(playlistData.playMode);

        // 恢复当前歌曲到状态模型
        const currentSong = this.playlistModel.getCurrentSong();
        if (currentSong) {
          this.stateModel.updateCurrentSong(currentSong);
          console.log(`Heanup2 UnifiedPlayerService: 恢复当前歌曲: ${currentSong.name}`);
        }

        LogUtils.getInstance().LOGI(`UnifiedPlayerService: Restored playlist with ${playlistData.songs.length} songs`);

        // 立即更新播放列表状态，确保上一首/下一首状态正确
        this.updatePlaylistStateInModelSync();
      } else {
        console.log("Heanup2 UnifiedPlayerService: 没有找到保存的播放列表或播放列表为空");
      }

      // 恢复播放状态
      if (stateData) {
        console.log(`Heanup2 UnifiedPlayerService: 加载到的播放状态 - playing: ${stateData.isPlaying}, paused: ${stateData.isPaused}, index: ${stateData.currentIndex}`);

        // 批量更新状态，减少回调次数
        this.stateModel.updateVolume(stateData.volume);
        this.stateModel.updateSpeed(stateData.speed);
        this.stateModel.updatePlayMode(stateData.playMode);

        // 恢复播放状态（UI会使用实际播放器状态，所以这里可以恢复逻辑状态）
        this.stateModel.updatePlayingState(stateData.isPlaying || false);

        // 恢复当前播放索引
        if (stateData.currentIndex >= 0) {
          this.stateModel.updateCurrentIndex(stateData.currentIndex);
        }

        console.log("Heanup2 UnifiedPlayerService: 播放状态恢复完成");
        LogUtils.getInstance()
          .LOGI(`UnifiedPlayerService: Restored player state - playing: ${stateData.isPlaying}, paused: ${stateData.isPaused}, index: ${stateData.currentIndex}`);
      } else {
        console.log("Heanup2 UnifiedPlayerService: 没有找到保存的播放状态");
      }

      console.log("Heanup2 UnifiedPlayerService: 持久化状态快速恢复完成");

      // 设置数据恢复完成标识
      this.isDataRestored = true;

      // 立即更新播放列表状态，确保上一首/下一首状态正确
      this.updatePlaylistStateInModelSync();

      LogUtils.getInstance().LOGI('UnifiedPlayerService: Data restoration completed');
    } catch (error) {
      console.log(`Heanup2 UnifiedPlayerService: 恢复持久化状态时出错: ${error}`);
      LogUtils.getInstance().LOGI(`UnifiedPlayerService restorePersistedState error: ${error}`);
      // 即使出错也设置为已恢复，避免无限等待
      this.isDataRestored = true;
    }
  }

  /**
   * 保存当前状态
   */
  private saveCurrentState(): void {
    try {
      // 获取当前状态
      const currentState = this.stateModel.getState();
      
      // 验证播放器实际状态，确保状态模型与实际播放器状态一致
      try {
        const ijkPlayer = this.playerManager.getIjkPlayer();
        const actualPlaying = ijkPlayer ? ijkPlayer.isPlaying() : false;
        
        // 如果状态不一致，以实际播放器状态为准
        if (currentState.isPlaying !== actualPlaying) {
          LogUtils.getInstance().LOGI(`UnifiedPlayerService: State mismatch detected during save - StateModel: ${currentState.isPlaying}, Actual: ${actualPlaying}`);
          this.stateModel.updatePlayingState(actualPlaying);
          // 重新获取修正后的状态
          const correctedState = this.stateModel.getState();
          this.dataPersistence.savePlayerState(correctedState);
        } else {
          this.dataPersistence.savePlayerState(currentState);
        }
      } catch (playerError) {
        // 如果获取播放器状态失败，默认保存为停止状态
        LogUtils.getInstance().LOGI(`UnifiedPlayerService: Failed to get actual player state, saving as stopped: ${playerError}`);
        this.stateModel.updatePlayingState(false);
        const stoppedState = this.stateModel.getState();
        this.dataPersistence.savePlayerState(stoppedState);
      }

      this.savePlaybackPosition();
      this.syncPlaylistToStorage();
      
      LogUtils.getInstance().LOGI(`UnifiedPlayerService: Current state saved successfully`);
    } catch (error) {
      LogUtils.getInstance().LOGI(`UnifiedPlayerService saveCurrentState error: ${error}`);
    }
  }

  /**
   * 外部调用保存当前状态的方法（供EntryAbility使用）
   */
  public saveCurrentStateExternal(): void {
    this.saveCurrentState();
  }

  /**
   * 同步播放列表到存储
   */
  private syncPlaylistToStorage(): void {
    try {
      const playlist = this.playlistModel.getSongs();
      const currentIndex = this.playlistModel.getCurrentIndex();
      const playMode = this.stateModel.getState().playMode;

      this.playlistSync.syncPlaylistToStorage(playlist, currentIndex, playMode);
    } catch (error) {
      LogUtils.getInstance().LOGI(`UnifiedPlayerService syncPlaylistToStorage error: ${error}`);
    }
  }

  // ==================== PlaylistSyncListener 接口实现 ====================

  /**
   * 播放列表同步完成回调
   */
  onPlaylistSynced(playlist: VideoItem[], currentIndex: number, playMode: PlayMode): void {
    try {
      LogUtils.getInstance()
        .LOGI(`UnifiedPlayerService: Playlist synced - ${playlist.length} songs, index ${currentIndex}`);

      // 播放列表同步完成，无需额外通知
    } catch (error) {
      LogUtils.getInstance().LOGI(`UnifiedPlayerService onPlaylistSynced error: ${error}`);
    }
  }

  /**
   * 播放列表加载完成回调
   */
  onPlaylistLoaded(playlistData: PlaylistData): void {
    try {
      LogUtils.getInstance()
        .LOGI(`UnifiedPlayerService: Playlist loaded from storage - ${playlistData.songs.length} songs`);

      // 检查是否需要更新本地播放列表
      const currentPlaylist = this.playlistModel.getSongs();
      const currentIndex = this.playlistModel.getCurrentIndex();

      // 如果存储的数据更新，更新本地播放列表
      if (playlistData.songs.length !== currentPlaylist.length ||
        playlistData.currentIndex !== currentIndex) {

        this.playlistModel.replaceSongs(playlistData.songs, playlistData.currentIndex);
        this.stateModel.updateCurrentIndex(playlistData.currentIndex);
        this.stateModel.updatePlayMode(playlistData.playMode);

        LogUtils.getInstance().LOGI('UnifiedPlayerService: Local playlist updated from storage');
      }

      // 更新数据恢复状态（如果还没有恢复的话）
      if (!this.isDataRestored) {
        this.isDataRestored = true;
        LogUtils.getInstance().LOGI('UnifiedPlayerService: Data restoration completed via onPlaylistLoaded');
      }
    } catch (error) {
      LogUtils.getInstance().LOGI(`UnifiedPlayerService onPlaylistLoaded error: ${error}`);
    }
  }

  /**
   * 自动同步执行回调
   */
  onAutoSyncPerformed(): void {
    try {
      // 定期保存当前状态
      this.saveCurrentState();
    } catch (error) {
      LogUtils.getInstance().LOGI(`UnifiedPlayerService onAutoSyncPerformed error: ${error}`);
    }
  }

  /**
   * 同步错误回调
   */
  onSyncError(error: Error): void {
    LogUtils.getInstance().LOGI(`UnifiedPlayerService sync error: ${error.message}`);
  }

  // ==================== 公共数据访问方法 ====================

  /**
   * 获取数据持久化服务实例
   */
  getDataPersistenceService(): IDataPersistenceService {
    return this.dataPersistence;
  }

  /**
   * 获取播放列表同步服务实例
   */
  getPlaylistSyncService(): PlaylistSyncService {
    return this.playlistSync;
  }

  // ==================== StateChangeCallback 接口实现 ====================


  /**
   * 歌曲变化回调（来自StateSyncService的本地通知）
   */
  onSongChanged?(song: VideoItem): void {
    try {
      LogUtils.getInstance().LOGI(`UnifiedPlayerService: Received song change notification - ${song.name}`);
      // 这里可以处理来自其他组件的歌曲变化通知
    } catch (error) {
      LogUtils.getInstance().LOGI(`UnifiedPlayerService onSongChanged error: ${error}`);
    }
  }


  // ==================== WidgetControlCallback 接口实现 ====================

  /**
   * 处理来自卡片的播放/暂停命令
   */
  async onPlayPause?(): Promise<void> {
    try {
      LogUtils.getInstance().LOGI('UnifiedPlayerService: Received play/pause command from widget');

      // 优先检查播放器的实际状态，而不是状态模型
      const ijkPlayer = this.playerManager.getIjkPlayer();
      const isActuallyPlaying = ijkPlayer ? ijkPlayer.isPlaying() : false;
      const stateModelPlaying = this.getCurrentState().isPlaying;

      LogUtils.getInstance()
        .LOGI(`UnifiedPlayerService: Widget playPause - StateModel: ${stateModelPlaying}, ActualPlayer: ${isActuallyPlaying}`);

      // 如果播放器实际在播放，则暂停；否则开始/恢复播放
      if (isActuallyPlaying) {
        LogUtils.getInstance().LOGI('UnifiedPlayerService: Player is actually playing, will pause');
        await this.pause();
      } else {
        LogUtils.getInstance().LOGI('UnifiedPlayerService: Player is not playing, will start/resume play');
        await this.startPlayOrResumePlay();
      }

      LogUtils.getInstance().LOGI('UnifiedPlayerService: Play/pause command executed successfully');
    } catch (error) {
      LogUtils.getInstance().LOGI(`UnifiedPlayerService onPlayPause error: ${error}`);
      throw new Error;
    }
  }

  /**
   * 处理来自卡片的下一首命令
   */
  async onNextSong?(): Promise<void> {
    try {
      LogUtils.getInstance().LOGI('UnifiedPlayerService: Received next song command from widget');
      await this.playNext();
      LogUtils.getInstance().LOGI('UnifiedPlayerService: Next song command executed successfully');
    } catch (error) {
      LogUtils.getInstance().LOGI(`UnifiedPlayerService onNextSong error: ${error}`);
      throw new Error;
    }
  }

  /**
   * 处理来自卡片的上一首命令
   */
  async onPreviousSong?(): Promise<void> {
    try {
      LogUtils.getInstance().LOGI('UnifiedPlayerService: Received previous song command from widget');
      await this.playPrevious();
      LogUtils.getInstance().LOGI('UnifiedPlayerService: Previous song command executed successfully');
    } catch (error) {
      LogUtils.getInstance().LOGI(`UnifiedPlayerService onPreviousSong error: ${error}`);
      throw new Error;
    }
  }

  /**
   * 处理来自卡片的拖动进度命令
   */
  async onSeekTo?(position: number): Promise<void> {
    try {
      LogUtils.getInstance().LOGI(`UnifiedPlayerService: Received seek to command from widget - position: ${position}`);
      await this.seekTo(position.toString());
      LogUtils.getInstance().LOGI('UnifiedPlayerService: Seek to command executed successfully');
    } catch (error) {
      LogUtils.getInstance().LOGI(`UnifiedPlayerService onSeekTo error: ${error}`);
      throw new Error;
    }
  }

  /**
   * 处理来自卡片的状态请求命令
   */
  async onStateRequest?(): Promise<void> {
    try {
      LogUtils.getInstance().LOGI('UnifiedPlayerService: Received state request from widget');
      await this.broadcastCurrentState();
      LogUtils.getInstance().LOGI('UnifiedPlayerService: State request handled successfully');
    } catch (error) {
      LogUtils.getInstance().LOGI(`UnifiedPlayerService onStateRequest error: ${error}`);
      throw new Error;
    }
  }

  /**
   * 手动广播当前状态（用于响应卡片的状态请求）
   */
  async broadcastCurrentState(): Promise<void> {
    try {
      // 确保播放列表状态是最新的
      this.updatePlaylistStateInModelSync();

      // 触发状态监听器通知
      this.stateModel.forceNotifyStateChanged();

      // 更新桌面卡片
      await this.updateAllForms(true); // 强制更新
      LogUtils.getInstance().LOGI('UnifiedPlayerService: Current state broadcasted manually');
    } catch (error) {
      LogUtils.getInstance().LOGI(`UnifiedPlayerService broadcastCurrentState error: ${error}`);
      throw new Error;
    }
  }

  // ==================== 私有辅助方法 ====================

  /**
   * 设置音频中断监听器
   */
  private setupAudioInterruptListener(): void {
    try {
      const ijkPlayer = this.playerManager.getIjkPlayer();
      if (ijkPlayer) {
        ijkPlayer.on('audioInterrupt', (event: InterruptEvent) => {
          this.handleAudioInterrupt(event);
        });
        LogUtils.getInstance().LOGI('UnifiedPlayerService: Audio interrupt listener set up successfully');
      } else {
        LogUtils.getInstance()
          .LOGI('UnifiedPlayerService: Failed to set up audio interrupt listener - no player instance');
      }
    } catch (error) {
      LogUtils.getInstance().LOGI(`UnifiedPlayerService: Error setting up audio interrupt listener: ${error.message}`);
    }
  }

  /**
   * 处理音频中断事件
   */
  async handleAudioInterrupt(event: InterruptEvent): Promise<void> {
    try {
      LogUtils.getInstance().LOGI(`onecold 与其他应用音频冲突 被截断点event: ${JSON.stringify(event)}`);

      // 首先保存当前播放位置
      await this.savePlaybackPosition();

      switch (event.hintType) {
        case InterruptHintType.INTERRUPT_HINT_PAUSE:
          LogUtils.getInstance().LOGI('UnifiedPlayerService: Audio interrupt - pausing playback');
          await this.pause();
          break;

        case InterruptHintType.INTERRUPT_HINT_RESUME:
          LogUtils.getInstance().LOGI('UnifiedPlayerService: Audio interrupt - resuming playback');
          await this.startPlayOrResumePlay();
          break;

        case InterruptHintType.INTERRUPT_HINT_STOP:
          LogUtils.getInstance().LOGI('UnifiedPlayerService: Audio interrupt - stopping playback');
          await this.stop();
          break;

        case InterruptHintType.INTERRUPT_HINT_DUCK:
          LogUtils.getInstance().LOGI('UnifiedPlayerService: Audio interrupt - ducking (lowering volume)');
          // 可以实现音量降低逻辑
          break;

        case InterruptHintType.INTERRUPT_HINT_UNDUCK:
          LogUtils.getInstance().LOGI('UnifiedPlayerService: Audio interrupt - unducking (restoring volume)');
          // 可以实现音量恢复逻辑
          break;

        default:
          LogUtils.getInstance().LOGI(`UnifiedPlayerService: Unknown audio interrupt hint type: ${event.hintType}`);
          break;
      }

      // 通知状态变化
      await this.updatePlaylistStateInModel();
      await this.broadcastCurrentState();

    } catch (error) {
      LogUtils.getInstance().LOGI(`UnifiedPlayerService: Error handling audio interrupt: ${error.message}`);
      await this.handlePlaybackError(error as Error, PlayerErrorType.AUDIO_INTERRUPT_ERROR);
    }
  }

  /**
   * 更新状态模型中的播放列表状态
   */
  private async updatePlaylistStateInModel(): Promise<void> {
    try {
      const currentIndex = this.playlistModel.getCurrentIndex();
      const totalCount = this.playlistModel.getTotalCount();
      const playMode = this.stateModel.getState().playMode;

      // 在随机播放模式下，确保当前歌曲在播放历史中
      if (playMode === PlayMode.RANDOM) {
        await this.playlistModel.ensureCurrentSongInHistory();

        // 输出播放历史调试信息
        const debugInfo = this.playlistModel.getPlayHistoryDebugInfo();
        LogUtils.getInstance().LOGI(`UnifiedPlayerService: Random mode play history - ${debugInfo}`);
      }

      const hasNext = this.playlistModel.hasNext(playMode);
      const hasPrevious = await this.playlistModel.hasPrevious(playMode);

      this.stateModel.updatePlaylistState(hasNext, hasPrevious, totalCount);

      LogUtils.getInstance()
        .LOGI(`UnifiedPlayerService: Playlist state updated - hasNext=${hasNext}, hasPrevious=${hasPrevious}, totalCount=${totalCount}, playMode=${playMode}`);
    } catch (error) {
      LogUtils.getInstance().LOGI(`UnifiedPlayerService updatePlaylistStateInModel error: ${error}`);
    }
  }

  /**
   * 更新状态模型中的播放列表状态（同步版本）
   */
  private updatePlaylistStateInModelSync(): void {
    try {
      const currentIndex = this.playlistModel.getCurrentIndex();
      const totalCount = this.playlistModel.getTotalCount();
      const playMode = this.stateModel.getState().playMode;

      const hasNext = this.playlistModel.hasNext(playMode);
      const hasPrevious = this.playlistModel.hasPreviousSync(playMode);

      this.stateModel.updatePlaylistState(hasNext, hasPrevious, totalCount);

      LogUtils.getInstance()
        .LOGI(`UnifiedPlayerService: Playlist state updated sync - hasNext=${hasNext}, hasPrevious=${hasPrevious}, totalCount=${totalCount}, playMode=${playMode}`);
    } catch (error) {
      LogUtils.getInstance().LOGI(`UnifiedPlayerService updatePlaylistStateInModelSync error: ${error}`);
    }
  }

  // ==================== PlayerStateCallback 实现 ====================

  onPrepared(): void {
    LogUtils.getInstance().LOGI('UnifiedPlayerService: Player prepared');
    this.stateModel.updateLoadingState(false);

    // 标记播放器已为当前歌曲准备就绪
    this.isPlayerPreparedForCurrentSong = true;
    console.log("Heanup2 UnifiedPlayerService: onPrepared - 播放器已为当前歌曲准备就绪");

    setTimeout(() => {
      const ijkPlayer = this.playerManager.getIjkPlayer();
      const isActuallyPlaying = ijkPlayer ? ijkPlayer.isPlaying() : false;

      console.log(`Heanup2 UnifiedPlayerService: onPrepared - 实际播放状态: ${isActuallyPlaying}`);

      // 强制同步状态模型
      this.stateModel.updatePlayingState(isActuallyPlaying);

      // 确保播放列表状态是最新的
      this.updatePlaylistStateInModelSync();

      // 更新 AVSession 状态
      if (isActuallyPlaying) {
        let currentSong = this.getCurrentSong();
        if (currentSong) {
          console.log(`Heanup2 UnifiedPlayerService: onPrepared - updateAvSessionMetadata: ${json.stringify(currentSong)}`);
          this.updateAvSessionMetadata(currentSong)
        }
        this.updateSessionPlayState(true); // 强制更新，不使用防抖
      }

      // 延迟更新卡片，确保状态已同步
      setTimeout(() => {
        this.updateWidgetsForStateChange();
      }, 50);

    }, 100);

    // 播放器准备完成时立即更新卡片（移除加载状态）
    this.updateWidgetsForStateChange();
  }

  onPlaybackStarted(): void {
    LogUtils.getInstance().LOGI('UnifiedPlayerService: Playback started (new song)');

    // 这个回调只应该在新歌曲开始播放时被调用（通过onPrepared触发）
    // 不应该在暂停恢复时被调用

    // 在随机播放模式下，确保当前歌曲在播放历史中
    const playMode = this.stateModel.getState().playMode;
    if (playMode === PlayMode.RANDOM) {
      this.playlistModel.ensureCurrentSongInHistory();
      LogUtils.getInstance().LOGI('UnifiedPlayerService: Ensured current song in play history for random mode');
    }

    // 立即更新播放状态
    this.stateModel.updatePlayingState(true);

    // 启动进度定时器
    this.startProgressTimer();

    // 保存播放状态变化
    this.saveCurrentState();

    // 立即更新系统播控状态，确保与播放状态同步
    this.updateSessionPlayState(true); // 强制更新，不使用防抖
    LogUtils.getInstance().LOGI('UnifiedPlayerService: AVSession state updated for new song playback');

    // 播放开始时更新卡片显示播放状态
    this.updateWidgetsForPlayStateChange();

    // 同步更新所有桌面卡片状态
    this.updateAllForms();

    LogUtils.getInstance().LOGI('UnifiedPlayerService: New song playback started successfully');
  }

  onPlaybackCompleted(): void {
    LogUtils.getInstance().LOGI('UnifiedPlayerService: Playback completed');
    this.stateModel.updatePlayingState(false);
    this.stopProgressTimer();

    // 保存播放状态变化
    this.saveCurrentState();
    this.updateSessionPlayState();

    // 更新卡片显示播放完成状态
    this.updateWidgetsForPlayStateChange();

    // 同步更新所有桌面卡片状态
    this.updateAllForms();

    // 异步处理自动播放逻辑，避免阻塞主线程
    setTimeout(() => {
      this.handleAutoPlayOnCompletion().catch(() => {
        LogUtils.getInstance().LOGI(`UnifiedPlayerService: Auto-play error`);
      });
    }, 100); // 延迟100ms执行，确保当前回调完成
  }

  /**
   * 处理歌曲播放完成后的自动播放逻辑
   */
  private async handleAutoPlayOnCompletion(): Promise<void> {
    try {
      // 检查是否正在进行手动歌曲切换，如果是则跳过自动播放
      if (this.isManualSongChange) {
        LogUtils.getInstance().LOGI('UnifiedPlayerService: Manual song change in progress, skipping auto-play');
        return;
      }

      // 防抖检查：避免快速连续的自动播放调用
      const currentTime = Date.now();
      if (currentTime - this.lastAutoPlayTime < this.autoPlayDebounceMs) {
        LogUtils.getInstance().LOGI('UnifiedPlayerService: Auto-play debounced, skipping');
        return;
      }
      this.lastAutoPlayTime = currentTime;

      // 检查服务状态，避免在服务未就绪时执行自动播放
      if (!this.isAllServicesReady()) {
        LogUtils.getInstance().LOGI('UnifiedPlayerService: Services not ready for auto-play, skipping');
        return;
      }

      const currentState = this.stateModel.getState();
      const playMode = currentState.playMode;

      LogUtils.getInstance().LOGI(`UnifiedPlayerService: Handling auto-play, mode: ${playMode}`);

      switch (playMode) {
        case PlayMode.SEQUENCE: // 0: 顺序播放/列表循环
          LogUtils.getInstance().LOGI('UnifiedPlayerService: Auto-playing next song in sequence mode');
          // 检查是否有下一首歌曲
          if (this.playlistModel.hasNext(playMode)) {
            await this.playNext();
          } else {
            LogUtils.getInstance().LOGI('UnifiedPlayerService: No next song available in sequence mode');
          }
          break;

        case PlayMode.SINGLE_REPEAT: // 1: 单曲循环
          LogUtils.getInstance().LOGI('UnifiedPlayerService: Repeating current song');
          // 重新播放当前歌曲
          await this.startPlayOrResumePlay();
          break;

        case PlayMode.NORMAL: // 2: 正常播放，播完停止
          LogUtils.getInstance().LOGI('UnifiedPlayerService: Normal mode - stopping after completion');
          // 不做任何操作，保持停止状态
          break;

        case PlayMode.RANDOM: // 3: 随机播放
          LogUtils.getInstance().LOGI('UnifiedPlayerService: Auto-playing random next song');
          await this.playRandomNext();
          break;

        default:
          LogUtils.getInstance().LOGI(`UnifiedPlayerService: Unknown play mode: ${playMode}`);
          break;
      }
    } catch (error) {
      LogUtils.getInstance().LOGI(`UnifiedPlayerService: Error in auto-play handling: ${error}`);
      // 在自动播放失败时，简单记录错误但不触发复杂的错误处理流程
      // 这样可以避免错误处理过程中的潜在阻塞
      this.stateModel.updatePlayingState(false);
      this.stateModel.updateLoadingState(false);
    }
  }

  /**
   * 随机播放下一首歌曲
   */
  private async playRandomNext(): Promise<void> {
    try {
      const playlist = this.playlistModel.getSongs();
      if (playlist.length <= 1) {
        LogUtils.getInstance().LOGI('UnifiedPlayerService: Not enough songs for random play');
        return;
      }

      const currentIndex = this.playlistModel.getCurrentIndex();
      let randomIndex: number;

      // 确保随机选择的不是当前歌曲
      do {
        randomIndex = Math.floor(Math.random() * playlist.length);
      } while (randomIndex === currentIndex);

      LogUtils.getInstance().LOGI(`UnifiedPlayerService: Playing random song at index ${randomIndex}`);
      await this.playSongAtIndex(randomIndex);
    } catch (error) {
      LogUtils.getInstance().LOGI(`UnifiedPlayerService: Error in random play: ${error}`);
      // 不再抛出异常，而是通过错误处理机制处理
      await this.handlePlaybackError(error as Error, PlayerErrorType.PLAYBACK_ERROR);
    }
  }

  onPlaybackError(what: number, extra: number): void {
    LogUtils.getInstance().LOGI(`UnifiedPlayerService: Playback error - what: ${what}, extra: ${extra}`);
    this.stateModel.updateLoadingState(false);
    this.stateModel.updatePlayingState(false);
    this.stopProgressTimer();

    // 保存播放状态变化
    this.saveCurrentState();

    // 创建播放器错误对象
    const playbackError = new PlayerError(
      PlayerErrorType.PLAYBACK_ERROR,
      `Playback error: what=${what}, extra=${extra}`,
      what
    );
    playbackError.recoverable = what !== -1004 && what !== -1007; // 某些错误码可恢复
    playbackError.retryCount = 0;

    // 创建错误上下文
    const errorContext: ErrorContext = {
      currentSong: this.getCurrentSong(),
      playlist: this.getPlaylist(),
      currentIndex: this.getCurrentIndex(),
      retryCount: 0,
      isNetworkAvailable: true // 这里可以实际检查网络状态
    };

    // 使用错误恢复策略处理错误
    this.errorRecovery.handleError(playbackError, errorContext).then((action: ErrorRecoveryAction) => {
      LogUtils.getInstance().LOGI(`UnifiedPlayerService: Error recovery action: ${action}`);
      // 这里可以根据 action 执行相应的恢复操作
    }).catch((recoveryError: Error) => {
      LogUtils.getInstance().LOGI(`UnifiedPlayerService: Error recovery failed: ${recoveryError}`);
    });
  }

  // ========== 卡片更新相关方法 ==========


  /**
   * 播放状态变化时更新卡片
   */
  private async updateWidgetsForPlayStateChange(): Promise<void> {
    try {
      this.updateAllForms();
      LogUtils.getInstance().LOGI(`UnifiedPlayerService: Widgets updated for play state change`);
    } catch (error) {
      LogUtils.getInstance().LOGI(`UnifiedPlayerService: Failed to update widgets for play state change: ${error}`);
    }
  }

  /**
   * 更新所有桌面卡片状态
   * 将VideoItem和PlayerState数据传入桌面卡片，控制卡片的显示
   */
  async updateAllForms(forceUpdate: boolean = false) {
    // 定义变量在方法开始处，确保在整个方法中都可以访问
    try {
      const now = Date.now();
      this.isUpdatingForms = true;
      this.lastUpdateTime = now;
      // 从数据库获取所有Form信息
      const context = AppStorage.get('context') as common.UIAbilityContext;
      if (!context) {
        LogUtils.getInstance().LOGI('UnifiedPlayerService updateAllForms: No context available');
        return;
      }

      // 从数据库读取所有Form信息
      let formInfoList: FormInfo[] = [];
      try {
        formInfoList = await FormRdbHelper.getInstance(context).queryAllForms();
        LogUtils.getInstance().LOGI(`UnifiedPlayerService updateAllForms: Found ${formInfoList.length} forms in database`);
      } catch (error) {
        LogUtils.getInstance().LOGI(`UnifiedPlayerService updateAllForms: Failed to query forms from database: ${error}`);
        return;
      }

      if (formInfoList.length === 0) {
        LogUtils.getInstance().LOGI('UnifiedPlayerService updateAllForms: No forms found in database');
        return;
      }


      // 记录更新统计
      const invalidFormIds: string[] = [];
      let flatWidgetData = await this.getWidgetFormData();

        // 逐个更新所有卡片，根据卡片类型进行个性化处理
        for (const formInfo of formInfoList) {
          try {
            const formBindingDataInstance = formBindingData.createFormBindingData(flatWidgetData);
            await formProvider.updateForm(formInfo.formId, formBindingDataInstance);

            LogUtils.getInstance().LOGI(`UnifiedPlayerService updateAllForms: Successfully updated form ${formInfo.formId} (${formInfo.formName})`);
          } catch (error) {
            const errorStr: string = error?.toString() || '';
            invalidFormIds.push(formInfo.formId);
            LogUtils.getInstance()
              .LOGI(`UnifiedPlayerService updateAllForms: Form ${formInfo.formId} (${formInfo.formName}) - ${errorStr}}`);
          }
        }

        // 自动清理无效的Form ID
        if (invalidFormIds.length > 0) {
          try {
            for (const invalidFormId of invalidFormIds) {
              await FormRdbHelper.getInstance(context).deleteForm(invalidFormId);
            }
            LogUtils.getInstance()
              .LOGI(`UnifiedPlayerService updateAllForms: Removed ${invalidFormIds.length} invalid form IDs from database: ${invalidFormIds.join(', ')}`);
          } catch (error) {
            LogUtils.getInstance()
              .LOGI(`UnifiedPlayerService updateAllForms: Failed to clean invalid form IDs from database: ${error}`);
          }
        }

      } catch (error) {
      LogUtils.getInstance().LOGI(`UnifiedPlayerService updateAllForms error: ${error}`);
    } finally {
      // 重置更新标志
      this.isUpdatingForms = false;
    }
  }

  public async getWidgetFormData(): Promise<widgeData | undefined> {
    let imgMap: Record<string, number> = {};
    this.updatePlaylistStateInModelSync();
    const now = Date.now();
    this.isUpdatingForms = true;
    this.lastUpdateTime = now;
    const formData: VideoItem = this.getCurrentSong() as VideoItem; // VideoItem
    const songState: PlayerState = this.getCurrentState(); // PlayerState
    
    // 从持久化存储获取所有formId - 使用新的getContext方法
    let context = this.getContext();
    
    // 如果还是没有context，尝试从AppStorage获取
    if (!context) {
      context = AppStorage.get('context') as common.UIAbilityContext;
    }

    // 构建卡片数据，包含VideoItem和PlayerState信息
    const widgetPlayerState: WidgetPlayerState = {
      isPlaying: songState.isPlaying || false,
      isPaused: songState.isPaused || true,
      isLoading: songState.isLoading || false,
      currentPosition: songState.currentPosition || 0,
      duration: songState.duration || 0,
      hasNext: songState.hasNext || false,
      hasPrevious: songState.hasPrevious || false,
      playMode: songState.playMode || 0
    };

    const widgetPlaylistInfo: WidgetPlaylistInfo = {
      currentIndex: this.getCurrentIndex(),
      totalCount: this.getPlaylist().length
    };

    const widgetTimeInfo: WidgetTimeInfo = {
      currentTimeText: this.formatTimeDisplay(Math.floor((songState.currentPosition || 0) / 1000)),
      totalTimeText: this.formatTimeDisplay(Math.floor((songState.duration || 0) / 1000)),
      progressPercentage: this.calculateProgressPercentage(songState.currentPosition || 0, songState.duration || 0)
    };

    if (!formData) {
      console.log('UnifiedPlayerService getWidgetFormData: No formData available - formData:'+json.stringify(formData))
      const defaultData: widgeData = {
        id: '',
        name: '未知歌曲',
        artist: '未知艺术家',
        album: '未知专辑',
        pixelMapPath: '',
        duration: 0,
        filePath: '',
        imgName: '',
        imageColorHex: '2A2A2A',
        isPlaying: false,
        isPaused: true,
        isLoading: false,
        hasNext: false,
        hasPrevious: false,
        isFavorite: false,
        currentPosition: 0,
        playMode: 0,
        currentIndex: 0,
        totalCount: 0,
        currentTimeText: '',
        totalTimeText: '',
        progressPercentage: 0,
        playerState: widgetPlayerState,
        playlistInfo: widgetPlaylistInfo,
        timeInfo: widgetTimeInfo,
        formImages: imgMap
      }
      return defaultData;
    }
    console.log('UnifiedPlayerService getWidgetFormData -  context: '+json.stringify(context)+" - formData:"+json.stringify(formData))
    // 处理封面图片
    let imgName: string = '';

    // 如果歌曲有封面图片路径，尝试处理图片
    if (formData.pixelMapPath && formData.pixelMapPath.trim() !== '') {
      try {
        // 生成唯一的图片名称，确保每次更新时图片能正确刷新
        imgName = 'songCover_' + Date.now() + '_' + Math.random().toString(36).substr(2, 9);

        // 判断是否为网络图片
        if (formData.pixelMapPath.startsWith('http://') || formData.pixelMapPath.startsWith('https://')) {
          // 处理网络图片：使用缓存机制
          LogUtils.getInstance()
            .LOGI(`UnifiedPlayerService updateAllForms: Processing network image ${formData.pixelMapPath}`);

          if (this.imageCacheDir) {
            const cacheFileName = this.generateCacheFileName(formData.pixelMapPath);
            const cacheFilePath = this.imageCacheDir + '/' + cacheFileName;

            // 检查缓存是否存在且有效
            if (await this.isCacheValid(cacheFilePath)) {
              // 使用缓存文件
              LogUtils.getInstance().LOGI(`UnifiedPlayerService updateAllForms: Using cached image: ${cacheFilePath}`);
              try {
                const file = fileIo.openSync(cacheFilePath, fileIo.OpenMode.READ_ONLY);
                imgMap[imgName] = file.fd;
                LogUtils.getInstance()
                  .LOGI(`UnifiedPlayerService updateAllForms: Opened cached image with fd ${file.fd}, imgName: ${imgName}`);
              } catch (error) {
                LogUtils.getInstance()
                  .LOGI(`UnifiedPlayerService updateAllForms: Failed to open cached image: ${error}`);
              }
            } else {
              // 下载到缓存
              LogUtils.getInstance()
                .LOGI(`UnifiedPlayerService updateAllForms: Downloading image to cache: ${cacheFilePath}`);
              const downloadSuccess = await this.downloadImageToCache(formData.pixelMapPath, cacheFilePath);

              if (downloadSuccess) {
                try {
                  const file = fileIo.openSync(cacheFilePath, fileIo.OpenMode.READ_ONLY);
                  imgMap[imgName] = file.fd;
                  LogUtils.getInstance()
                    .LOGI(`UnifiedPlayerService updateAllForms: Opened downloaded image with fd ${file.fd}, imgName: ${imgName}`);
                } catch (error) {
                  LogUtils.getInstance()
                    .LOGI(`UnifiedPlayerService updateAllForms: Failed to open downloaded image: ${error}`);
                }
              } else {
                LogUtils.getInstance()
                  .LOGI(`UnifiedPlayerService updateAllForms: Failed to download network image ${formData.pixelMapPath}`);
              }
            }
          } else {
            LogUtils.getInstance().LOGI(`UnifiedPlayerService updateAllForms: Image cache directory not available`);
          }
        } else {
          // 处理本地图片文件
          let file = fileIo.openSync(formData.pixelMapPath, fileIo.OpenMode.READ_ONLY);
          imgMap[imgName] = file.fd;

          LogUtils.getInstance()
            .LOGI(`UnifiedPlayerService updateAllForms: Opened local cover image ${formData.pixelMapPath} with fd ${file.fd}, imgName: ${imgName}`);
        }
      } catch (error) {
        LogUtils.getInstance()
          .LOGI(`UnifiedPlayerService updateAllForms: Failed to process cover image ${formData.pixelMapPath}: ${JSON.stringify(error as BusinessError)}`);
        // 如果处理图片失败，使用空的imgMap
        imgMap = {};
        imgName = '';
      }
    } else {
      LogUtils.getInstance().LOGI(`UnifiedPlayerService updateAllForms: No cover image path available`);
    }

    // 平铺数据结构，确保桌面卡片能正确接收
    const widgetData: widgeData = {
      // VideoItem数据平铺
      id: formData.id || '',
      name: formData.name || '',
      artist: formData.artist || '',
      album: formData.album || '',
      pixelMapPath: formData.pixelMapPath || '',
      duration: typeof formData.duration === 'string' ? parseInt(formData.duration || '0') : (formData.duration || 0),
      filePath: formData.filePath || '',
      imgName: imgName,
      imageColorHex: '2A2A2A',

      // PlayerState数据平铺
      isPlaying: widgetPlayerState.isPlaying,
      isPaused: widgetPlayerState.isPaused,
      isLoading: widgetPlayerState.isLoading,
      currentPosition: widgetPlayerState.currentPosition,
      hasNext: widgetPlayerState.hasNext,
      hasPrevious: widgetPlayerState.hasPrevious,
      playMode: widgetPlayerState.playMode,

      // 播放列表信息平铺
      currentIndex: widgetPlaylistInfo.currentIndex,
      totalCount: widgetPlaylistInfo.totalCount,

      // 时间信息平铺
      currentTimeText: widgetTimeInfo.currentTimeText,
      totalTimeText: widgetTimeInfo.totalTimeText,
      progressPercentage: widgetTimeInfo.progressPercentage,

      // 保持嵌套结构兼容性
      playerState: widgetPlayerState,
      playlistInfo: widgetPlaylistInfo,
      timeInfo: widgetTimeInfo,

      // 卡片图片显示必填字段
      formImages: imgMap,
      isFavorite: this.getCurrentSongFavoriteState(),
    };
    return widgetData;
  }

  /**
   * 计算播放进度百分比
   */
  private calculateProgressPercentage(current: number, total: number): number {
    if (total <= 0) {
      return 0;
    }
    return Math.min(100, Math.max(0, (current / total) * 100));
  }

  /**
   * 格式化时间显示
   */
  private formatTimeDisplay(seconds: number): string {
    const mins = Math.floor(seconds / 60);
    const secs = Math.floor(seconds % 60);
    return `${mins.toString().padStart(2, '0')}:${secs.toString().padStart(2, '0')}`;
  }


  /**
   * 状态变化时更新卡片
   */
  public async updateWidgetsForStateChange(): Promise<void> {
    try {
      await this.updateAllForms(true); // 强制更新，因为状态确实发生了变化
      LogUtils.getInstance().LOGI(`UnifiedPlayerService: Widgets updated for state change`);
    } catch (error) {
      LogUtils.getInstance().LOGI(`UnifiedPlayerService: Failed to update widgets for state change: ${error}`);
    }
  }

  /**
   * 播放列表变化时更新卡片
   */
  private async updateWidgetsForPlaylistChange(): Promise<void> {
    try {
      this.updateAllForms();
      LogUtils.getInstance().LOGI(`UnifiedPlayerService: Widgets updated for playlist change`);
    } catch (error) {
      LogUtils.getInstance().LOGI(`UnifiedPlayerService: Failed to update widgets for playlist change: ${error}`);
    }
  }

  /**
   * 应用启动时初始化卡片显示
   */
  public async initializeWidgetDisplay(): Promise<void> {
    try {
      this.updateAllForms();
      LogUtils.getInstance().LOGI('UnifiedPlayerService: Widget display initialized');
    } catch (error) {
      LogUtils.getInstance().LOGI(`UnifiedPlayerService: Failed to initialize widget display: ${error}`);
    }
  }


  /**
   * 解析时长字符串为毫秒数
   */
  private parseDuration(durationStr: string): number {
    if (!durationStr || durationStr === '0') {
      return 0;
    }

    try {

      // 如果是纯数字，假设是秒数
      const numValue = parseFloat(durationStr);
      if (!isNaN(numValue)) {
        const result = Math.floor(numValue * 1000); // 转换为毫秒
        return result;
      }

      // 如果包含冒号，解析为 MM:SS 或 HH:MM:SS 格式
      if (durationStr.includes(':')) {
        const parts = durationStr.split(':').map(part => parseInt(part, 10));
        let totalSeconds = 0;

        if (parts.length === 2) {
          // MM:SS 格式
          totalSeconds = parts[0] * 60 + parts[1];
        } else if (parts.length === 3) {
          // HH:MM:SS 格式
          totalSeconds = parts[0] * 3600 + parts[1] * 60 + parts[2];
        }

        const result = totalSeconds * 1000; // 转换为毫秒
        return result;
      }

      return 0;
    } catch (error) {
      return 0;
    }
  }

  // ==================== PlayerStateCallback 实现 ====================


  /**
   * 转换播放模式为AVSession循环模式
   */
  private convertPlayModeToLoopMode(playMode: number): avSession.LoopMode {
    switch (playMode) {
      case PlayMode.SINGLE_REPEAT:
        return avSession.LoopMode.LOOP_MODE_SINGLE;
      case PlayMode.NORMAL:
        return avSession.LoopMode.LOOP_MODE_LIST;
      case PlayMode.RANDOM:
        return avSession.LoopMode.LOOP_MODE_SHUFFLE;
      case PlayMode.SEQUENCE:
      default:
        return avSession.LoopMode.LOOP_MODE_SEQUENCE;
    }
  }

  /**
   * 更新AVSession播放状态（带防抖）
   */
  private updateSessionPlayState(force: boolean = false): void {
    // 清除之前的定时器
    if (this.avSessionUpdateTimer !== -1) {
      clearTimeout(this.avSessionUpdateTimer);
    }

    if (force) {
      // 强制更新，立即执行
      this.doUpdateSessionPlayState();
    } else {
      // 增加防抖延迟到500ms，减少频繁更新
      this.avSessionUpdateTimer = setTimeout(() => {
        this.doUpdateSessionPlayState();
      }, 500);
    }
  }

  /**
   * 实际执行AVSession播放状态更新
   */
  private doUpdateSessionPlayState(): void {
    try {
      if (!this.avSessionController) {
        LogUtils.getInstance().LOGI('UnifiedPlayerService: AVSession controller not initialized');
        return;
      }

      // 避免过于频繁的更新（最小间隔1000ms，增加防抖时间）
      const now = Date.now();
      if (now - this.lastAvSessionUpdate < 1000) {
        LogUtils.getInstance().LOGI('UnifiedPlayerService: Skipping AVSession update due to rate limit');
        return;
      }

      const currentSong = this.playlistModel.getCurrentSong();
      const currentPosition = this.getCurrentPosition();

      // 优先从播放器获取实际duration
      let duration = 0;
      const ijkPlayer = this.playerManager.getIjkPlayer();
      if (ijkPlayer) {
        duration = ijkPlayer.getDuration();
      }
      if (duration <= 0 && currentSong?.duration) {
        duration = this.parseDuration(currentSong.duration);
      }

      const currentState = this.stateModel.getState();

      // 按照官方文档要求设置完整的播放状态
      const playbackState: avSession.AVPlaybackState = {
        // 播放状态 - 修复：确保播放状态正确反映当前状态
        state: currentState.isPlaying ? avSession.PlaybackState.PLAYBACK_STATE_PLAY :
        avSession.PlaybackState.PLAYBACK_STATE_PAUSE,

        // 播放速度
        speed: currentState.speed || 1.0,

        // 循环模式
        loopMode: this.convertPlayModeToLoopMode(currentState.playMode),

        // 收藏状态
        isFavorite: this.getCurrentSongFavoriteState()
      };

      // 只有当duration > 0时才设置位置信息，避免进度条显示问题
      if (duration > 0) {
        playbackState.position = {
          elapsedTime: Math.max(0, currentPosition), // 已播放时间（毫秒）
          updateTime: Date.now() // 更新时间戳
        };
        playbackState.bufferedTime = Math.max(currentPosition, 0);
      } else {
        LogUtils.getInstance()
          .LOGI(`UnifiedPlayerService: Skipping position info due to invalid duration: ${duration}ms`);
      }

      this.avSessionController.setAvSessionPlayState(playbackState);

      // 记录上次更新时间
      this.lastAvSessionUpdate = now;
    } catch (error) {
      LogUtils.getInstance().LOGI(`UnifiedPlayerService: Failed to update AVSession play state: ${error}`);
    }
  }


  /**
   * 更新AVSession元数据（带防抖和智能更新）
   */
  private async updateAvSessionMetadata(song: VideoItem): Promise<void> {
    // 清除之前的定时器
    if (this.avMetadataUpdateTimer !== -1) {
      clearTimeout(this.avMetadataUpdateTimer);
    }
    const now = Date.now();
    if (now - this.lastAvSessionUpdateTime < 1000) {
      return;
    }
    this.lastAvSessionUpdateTime = now;
    // 如果播放器还没准备好，延迟更新等待播放器准备完成
    const ijkPlayer = this.playerManager.getIjkPlayer();
    const playerDuration = ijkPlayer ? ijkPlayer.getDuration() : 0;
    const shouldWaitForPlayer = playerDuration <= 0 && this.isPlayerPreparedForCurrentSong === false;
    this.avMetadataUpdateTimer = setTimeout(() => {
      this.doUpdateAvSessionMetadata(song);
    }, 800);
    if (shouldWaitForPlayer) {
      // 播放器还没准备好，延迟更新
      this.avMetadataUpdateTimer = setTimeout(() => {
        this.doUpdateAvSessionMetadata(song);
      }, 800);
    } else {
      // 播放器已准备好或者不需要等待，稍微延迟更新
      this.avMetadataUpdateTimer = setTimeout(() => {
        this.doUpdateAvSessionMetadata(song);
      }, 800);
    }
  }

  /**
   * 实际执行AVSession元数据更新
   */
  private async doUpdateAvSessionMetadata(song: VideoItem): Promise<void> {
    try {
      if (!this.avSessionController) {
        LogUtils.getInstance().LOGI('UnifiedPlayerService: AVSession controller not initialized');
        return;
      }

      // 避免过于频繁的元数据更新（最小间隔600ms）
      const now = Date.now();
      if (now - this.lastAvMetadataUpdate < 600) {
        LogUtils.getInstance().LOGI('UnifiedPlayerService: Skipping AVSession metadata update due to rate limit');
        return;
      }

      // 调试：打印VideoItem的duration字段
      LogUtils.getInstance()
        .LOGI(`UnifiedPlayerService: VideoItem duration field - value: '${song.duration}', type: ${typeof song.duration}`);

      // 智能获取最准确的duration
      let duration = 0;
      try {
        const ijkPlayer = this.playerManager.getIjkPlayer();
        if (ijkPlayer && this.isPlayerPreparedForCurrentSong) {
          const playerDuration = ijkPlayer.getDuration();
          LogUtils.getInstance().LOGI(`UnifiedPlayerService: Player getDuration() returned: ${playerDuration}ms`);
          if (playerDuration > 0) {
            duration = playerDuration;
            LogUtils.getInstance().LOGI(`UnifiedPlayerService: Using player duration: ${duration}ms`);
          } else {
            // 备用方案：解析VideoItem中的duration
            duration = song.duration ? this.parseDuration(song.duration) : 0;
            LogUtils.getInstance()
              .LOGI(`UnifiedPlayerService: Player duration invalid, using parsed duration: ${duration}ms from '${song.duration}'`);
          }
        } else {
          duration = song.duration ? this.parseDuration(song.duration) : 0;
          LogUtils.getInstance()
            .LOGI(`UnifiedPlayerService: Player not ready, using parsed duration: ${duration}ms from '${song.duration}'`);
        }
      } catch (error) {
        duration = song.duration ? this.parseDuration(song.duration) : 0;
        LogUtils.getInstance()
          .LOGI(`UnifiedPlayerService: Error getting player duration, using parsed: ${duration}ms from '${song.duration}', error: ${error}`);
      }

      // 最终验证duration
      if (isNaN(duration) || duration <= 0) {
        LogUtils.getInstance().LOGI(`UnifiedPlayerService: Final duration is invalid (${duration}), setting to 0`);
        duration = 0;
      }

      // 获取歌词内容（如果有的话）
      const lyricContent = song.lyricContent || '';

      LogUtils.getInstance()
        .LOGI(`UnifiedPlayerService: About to call setAVMetadataMusic with duration: ${duration}ms (type: ${typeof duration})`);
      await this.avSessionController.setAVMetadataMusic(song, duration, lyricContent);

      // 记录更新时间
      this.lastAvMetadataUpdate = now;

      LogUtils.getInstance()
        .LOGI(`UnifiedPlayerService: AVSession metadata updated for ${song.name} with duration ${duration}ms`);

    } catch (error) {
      LogUtils.getInstance().LOGI(`UnifiedPlayerService: Failed to update AVSession metadata: ${error}`);
    }
  }

  // ==================== 辅助方法 ====================

  /**
   * 初始化图片缓存目录
   */
  private async initImageCacheDirectory(): Promise<void> {
    try {
      if (this.context) {
        const cacheDir = this.context.getApplicationContext().cacheDir;
        this.imageCacheDir = cacheDir + '/cover_images';

        // 创建缓存目录
        if (!fileIo.accessSync(this.imageCacheDir)) {
          fileIo.mkdirSync(this.imageCacheDir);
          LogUtils.getInstance().LOGI(`UnifiedPlayerService: Created image cache directory: ${this.imageCacheDir}`);
        }

        // 清理过期缓存
        await this.cleanExpiredCache();
      }
    } catch (error) {
      LogUtils.getInstance().LOGI(`UnifiedPlayerService: Failed to initialize image cache directory: ${error}`);
    }
  }

  /**
   * 生成图片URL的哈希值作为缓存文件名
   */
  private generateCacheFileName(url: string): string {
    try {
      const textEncoder = new util.TextEncoder();
      const data = textEncoder.encodeInto(url);

      // 使用URL的简单哈希算法
      let hash = 0;
      for (let i = 0; i < data.byteLength; i++) {
        const char = data[i];
        hash = ((hash << 5) - hash) + char;
        hash = hash & hash; // 转换为32位整数
      }

      return Math.abs(hash).toString(16) + '.jpg';
    } catch (error) {
      // 如果哈希生成失败，使用URL的简单替换方案
      return url.replace(/[^a-zA-Z0-9]/g, '_').substring(0, 50) + '.jpg';
    }
  }

  /**
   * 检查缓存文件是否存在且未过期
   */
  private async isCacheValid(cacheFilePath: string): Promise<boolean> {
    try {
      if (!fileIo.accessSync(cacheFilePath)) {
        return false;
      }

      const stat = fileIo.statSync(cacheFilePath);
      const fileAge = Date.now() - stat.mtime;
      const maxAge = this.CACHE_EXPIRY_DAYS * 24 * 60 * 60 * 1000; // 转换为毫秒

      return fileAge < maxAge;
    } catch (error) {
      LogUtils.getInstance().LOGI(`UnifiedPlayerService: Failed to check cache validity: ${error}`);
      return false;
    }
  }

  /**
   * 下载网络图片到缓存
   */
  private async downloadImageToCache(url: string, cacheFilePath: string): Promise<boolean> {
    try {
      const httpRequest = http.createHttp();
      try {
        const response = await httpRequest.request(url, {
          method: http.RequestMethod.GET,
          connectTimeout: 10000, // 10秒超时
          readTimeout: 10000
        });

        if (response.responseCode === http.ResponseCode.OK && response.result) {
          const tempFile = fileIo.openSync(cacheFilePath, fileIo.OpenMode.READ_WRITE | fileIo.OpenMode.CREATE);

          try {
            await fileIo.write(tempFile.fd, response.result as ArrayBuffer);
            fileIo.closeSync(tempFile.fd);

            LogUtils.getInstance().LOGI(`UnifiedPlayerService: Downloaded image to cache: ${cacheFilePath}`);
            return true;
          } catch (writeError) {
            fileIo.closeSync(tempFile.fd);
            LogUtils.getInstance().LOGI(`UnifiedPlayerService: Write error: ${writeError}`);
            return false;
          }
        } else {
          LogUtils.getInstance()
            .LOGI(`UnifiedPlayerService: Failed to download image ${url}: HTTP ${response.responseCode}`);
          return false;
        }
      } finally {
        httpRequest.destroy();
      }
    } catch (error) {
      LogUtils.getInstance().LOGI(`UnifiedPlayerService: Error downloading image to cache: ${error}`);
      return false;
    }
  }

  /**
   * 清理过期缓存
   */
  private async cleanExpiredCache(): Promise<void> {
    try {
      if (!this.imageCacheDir || !fileIo.accessSync(this.imageCacheDir)) {
        return;
      }

      const files = fileIo.listFileSync(this.imageCacheDir);
      const maxAge = this.CACHE_EXPIRY_DAYS * 24 * 60 * 60 * 1000;
      let totalSize = 0;
      const fileInfos: Array<CacheFileInfo> = [];

      // 收集文件信息
      for (const file of files) {
        const filePath = this.imageCacheDir + '/' + file;
        try {
          const stat = fileIo.statSync(filePath);
          totalSize += stat.size;
          const fileInfo: CacheFileInfo = {
            path: filePath,
            size: stat.size,
            mtime: stat.mtime
          };
          fileInfos.push(fileInfo);
        } catch (error) {
          // 忽略无法读取的文件
        }
      }

      // 删除过期文件
      const now = Date.now();
      for (const fileInfo of fileInfos) {
        if (now - fileInfo.mtime > maxAge) {
          try {
            fileIo.unlinkSync(fileInfo.path);
            totalSize -= fileInfo.size;
            LogUtils.getInstance().LOGI(`UnifiedPlayerService: Deleted expired cache file: ${fileInfo.path}`);
          } catch (error) {
            LogUtils.getInstance().LOGI(`UnifiedPlayerService: Failed to delete expired cache file: ${error}`);
          }
        }
      }

      // 如果缓存大小超限，删除最旧的文件
      const maxSizeBytes = this.MAX_CACHE_SIZE_MB * 1024 * 1024;
      if (totalSize > maxSizeBytes) {
        const sortedFiles = fileInfos
          .filter(f => fileIo.accessSync(f.path))// 只保留仍存在的文件
          .sort((a, b) => a.mtime - b.mtime); // 按修改时间排序，最旧的在前

        for (const fileInfo of sortedFiles) {
          if (totalSize <= maxSizeBytes) {
            break;
          }

          try {
            fileIo.unlinkSync(fileInfo.path);
            totalSize -= fileInfo.size;
            LogUtils.getInstance().LOGI(`UnifiedPlayerService: Deleted cache file due to size limit: ${fileInfo.path}`);
          } catch (error) {
            LogUtils.getInstance().LOGI(`UnifiedPlayerService: Failed to delete cache file: ${error}`);
          }
        }
      }

      LogUtils.getInstance()
        .LOGI(`UnifiedPlayerService: Cache cleanup completed, total size: ${(totalSize / 1024 / 1024).toFixed(2)}MB`);
    } catch (error) {
      LogUtils.getInstance().LOGI(`UnifiedPlayerService: Failed to clean expired cache: ${error}`);
    }
  }

  /**
   * 清理无效的Form ID
   * 应用启动时调用，验证所有保存的Form ID是否仍然有效
   */
  private async cleanupInvalidFormIds(): Promise<void> {
    try {
      if (!this.context) {
        LogUtils.getInstance().LOGI('UnifiedPlayerService: No context for cleanup invalid form IDs');
        return;
      }
      // 从数据库读取所有Form信息
      let formInfoList: FormInfo[] = [];
      try {
        formInfoList = await FormRdbHelper.getInstance(this.context).queryAllForms();
        LogUtils.getInstance().LOGI(`UnifiedPlayerService cleanupInvalidFormIds: Found ${formInfoList.length} forms in database`);
      } catch (error) {
        LogUtils.getInstance().LOGI(`UnifiedPlayerService cleanupInvalidFormIds: Failed to query forms from database: ${error}`);
        return;
      }

      if (formInfoList.length === 0) {
        LogUtils.getInstance().LOGI('UnifiedPlayerService cleanupInvalidFormIds: No forms found in database');
        return;
      }


      // 记录更新统计
      const invalidFormIds: string[] = [];
      let flatWidgetData = await this.getWidgetFormData();

      // 逐个更新所有卡片，根据卡片类型进行个性化处理
      for (const formInfo of formInfoList) {
        try {
          const formBindingDataInstance = formBindingData.createFormBindingData(flatWidgetData);
          await formProvider.updateForm(formInfo.formId, formBindingDataInstance);

          LogUtils.getInstance().LOGI(`UnifiedPlayerService cleanupInvalidFormIds: Successfully updated form ${formInfo.formId} (${formInfo.formName})`);
        } catch (error) {
          const errorStr: string = error?.toString() || '';
          invalidFormIds.push(formInfo.formId);
          LogUtils.getInstance()
            .LOGI(`UnifiedPlayerService cleanupInvalidFormIds: Form ${formInfo.formId} (${formInfo.formName}) - ${errorStr}}`);
        }
      }

      // 自动清理无效的Form ID
      if (invalidFormIds.length > 0) {
        try {
          for (const invalidFormId of invalidFormIds) {
            await FormRdbHelper.getInstance(this.context).deleteForm(invalidFormId);
          }
          LogUtils.getInstance()
            .LOGI(`UnifiedPlayerService cleanupInvalidFormIds: Removed ${invalidFormIds.length} invalid form IDs from database: ${invalidFormIds.join(', ')}`);
        } catch (error) {
          LogUtils.getInstance()
            .LOGI(`UnifiedPlayerService cleanupInvalidFormIds: Failed to clean invalid form IDs from database: ${error}`);
        }
      }



      // const preferencesUtil = PreferencesUtil.getInstance();
      // const prefs = await preferencesUtil.getPreferences(this.context);
      // const formIds = await preferencesUtil.getFormIds(prefs);
      //
      // if (formIds.length === 0) {
      //   LogUtils.getInstance().LOGI('UnifiedPlayerService: No form IDs to cleanup');
      //   return;
      // }
      //
      // const invalidFormIds: string[] = [];
      //
      // // 逐个验证Form ID的有效性
      // for (const formId of formIds) {
      //   try {
      //     // 尝试更新卡片来验证其有效性
      //     const flatWidgetData = await this.getWidgetFormData();
      //     if (flatWidgetData) {
      //       const formBindingDataInstance = formBindingData.createFormBindingData(flatWidgetData);
      //       await formProvider.updateForm(formId, formBindingDataInstance);
      //     }
      //   } catch (error) {
      //     // 如果更新失败，说明这个Form ID无效
      //     invalidFormIds.push(formId);
      //     LogUtils.getInstance().LOGI(`UnifiedPlayerService: Invalid form ID detected: ${formId}, error: ${error}`);
      //   }
      // }
      //
      // // 移除无效的Form ID
      // if (invalidFormIds.length > 0) {
      //
      //
      //   LogUtils.getInstance().LOGI(`UnifiedPlayerService: Cleaned up ${invalidFormIds.length} invalid form IDs: ${invalidFormIds.join(', ')}`);
      // } else {
      //   LogUtils.getInstance().LOGI(`UnifiedPlayerService: All ${formIds.length} form IDs are valid`);
      // }
    } catch (error) {
      LogUtils.getInstance().LOGI(`UnifiedPlayerService: Failed to cleanup invalid form IDs: ${error}`);
    }
  }
}