修复冷启动桌面卡片播放列表异常

entry/src/main/ets/common/service/DataPersistenceService.ets

@@ -272,7 +272,7 @@ export class DataPersistenceService implements IDataPersistenceService {
           } catch (preferencesError) {
 
 
-            if (preferencesError.toString().includes('context is invalid') && retryCount < maxRetries - 1) {
+            if ((preferencesError as Error).toString().includes('context is invalid') && retryCount < maxRetries - 1) {
               await new Promise<void>(resolve => setTimeout(resolve, 50));
             } else {
               break;
@@ -404,14 +404,21 @@ export class DataPersistenceService implements IDataPersistenceService {
       }
 
       const playlistData: PlaylistData = {
-        songs: playlist,
+        songs: playlist || [], // 确保不传入null
         currentIndex,
         playMode,
         timestamp: Date.now()
       };
 
+      // 获取调用栈信息用于调试
+      const stack = new Error().stack;
+      const caller = stack?.split('\n')[2]?.trim() || 'Unknown caller';
+      
+      console.log(`Heanup2 DataPersistenceService: savePlaylist called - playlist length: ${playlistData.songs.length}, currentIndex: ${currentIndex}, playMode: ${playMode}, caller: ${caller}`);
+
       // 首先保存到AppStorage（确保内存中有数据）
       AppStorage.setOrCreate(DataPersistenceService.KEYS.PLAYLIST, playlistData);
+      console.log(`Heanup2 DataPersistenceService: Saved to AppStorage - ${playlistData.songs.length} songs`);
 
 
       // 如果context有效，尝试保存到PreferencesUtil
@@ -422,14 +429,17 @@ export class DataPersistenceService implements IDataPersistenceService {
 
         while (retryCount < maxRetries) {
           try {
-            PreferencesUtil.putSync(DataPersistenceService.KEYS.PLAYLIST, JSON.stringify(playlistData));
+            const jsonString = JSON.stringify(playlistData);
+            PreferencesUtil.putSync(DataPersistenceService.KEYS.PLAYLIST, jsonString);
+            console.log(`Heanup2 DataPersistenceService: Successfully saved to PreferencesUtil - ${playlistData.songs.length} songs, JSON length: ${jsonString.length}`);
 
             break; // 成功，跳出循环
           } catch (error) {
-            lastError = error;
+            lastError = error as Error;
+            console.log(`Heanup2 DataPersistenceService: PreferencesUtil save failed (attempt ${retryCount + 1}): ${error}`);
 
 
-            if (error.toString().includes('context is invalid')) {
+            if ((error as Error).toString().includes('context is invalid')) {
 
               await new Promise<void>(resolve => setTimeout(resolve, 100 * (retryCount + 1)));
             } else {
@@ -442,18 +452,19 @@ export class DataPersistenceService implements IDataPersistenceService {
         }
 
         if (retryCount >= maxRetries && lastError) {
-
+          console.log(`Heanup2 DataPersistenceService: All PreferencesUtil save attempts failed: ${lastError}`);
 
         }
       } else {
-
+        console.log(`Heanup2 DataPersistenceService: Context is null, only saved to AppStorage`);
       }
 
+      console.log(`Heanup2 DataPersistenceService: savePlaylist completed successfully`);
 
     } catch (error) {
+      console.log(`Heanup2 DataPersistenceService: savePlaylist error: ${error}`);
 
-
-      throw new Error;
+      throw new Error ;
     }
   }
 
@@ -508,11 +519,11 @@ export class DataPersistenceService implements IDataPersistenceService {
               break;
             }
           } catch (preferencesError) {
-            lastError = preferencesError;
+            lastError = preferencesError as Error;
 
 
             // 如果是context无效错误，增加等待时间
-            if (preferencesError.toString().includes('context is invalid')) {
+            if ((preferencesError as Error).toString().includes('context is invalid')) {
 
               await new Promise<void>(resolve => setTimeout(resolve, 100 * (retryCount + 1)));
             } else {
@@ -579,10 +590,10 @@ export class DataPersistenceService implements IDataPersistenceService {
             PreferencesUtil.putSync(DataPersistenceService.KEYS.PLAYER_STATE, JSON.stringify(stateData));
             break; // 成功，跳出循环
           } catch (error) {
-            lastError = error;
+            lastError = error as Error;
 
 
-            if (error.toString().includes('context is invalid')) {
+            if ((error as Error).toString().includes('context is invalid')) {
 
               await new Promise<void>(resolve => setTimeout(resolve, 100 * (retryCount + 1)));
             } else {
@@ -662,11 +673,11 @@ export class DataPersistenceService implements IDataPersistenceService {
               break;
             }
           } catch (preferencesError) {
-            lastError = preferencesError;
+            lastError = preferencesError as Error;
 
 
             // 如果是context无效错误，增加等待时间
-            if (preferencesError.toString().includes('context is invalid')) {
+            if ((preferencesError as Error).toString().includes('context is invalid')) {
 
               await new Promise<void>(resolve => setTimeout(resolve, 100 * (retryCount + 1)));
             } else {

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

@@ -477,7 +477,7 @@ export class UnifiedPlayerService implements IPlayerService, PlaylistSyncListene
   private isUpdatingForms: boolean = false;
   private lastAvSessionUpdateTime: number = 0;
   private progressTimer: number = -1;
-  private isInitialized: boolean = false;
+  private initialized: boolean = false;
   private isDataRestored: boolean = false; // 新增：数据恢复完成标识
 
   private isPlayerPreparedForCurrentSong: boolean = false; // 新增：播放器是否已为当前歌曲准备就绪
@@ -522,7 +522,7 @@ export class UnifiedPlayerService implements IPlayerService, PlaylistSyncListene
   }
 
   async initialize(context: common.UIAbilityContext): Promise<void> {
-    if (this.isInitialized && this.context === context) {
+    if (this.initialized && this.context === context) {
       LogUtils.getInstance().LOGI('Heanup UnifiedPlayerService已经初始化过了');
       return;
     }
@@ -550,7 +550,7 @@ export class UnifiedPlayerService implements IPlayerService, PlaylistSyncListene
       // 设置状态模型监听器，自动广播状态变化
 
       this.setupProgressTimer();
-      this.isInitialized = true;
+      this.initialized = true;
 
       // 异步初始化耗时组件，避免阻塞
       this.initializeHeavyComponentsAsync(context);
@@ -660,14 +660,20 @@ export class UnifiedPlayerService implements IPlayerService, PlaylistSyncListene
     try {
       console.log("Heanup2 UnifiedPlayerService: 开始恢复播放");
 
-      // 统一的服务就绪检查 - 这是最核心的检查
+      // 优化的服务就绪检查 - 支持冷启动场景
       if (!this.isAllServicesReady()) {
         console.log("Heanup2 UnifiedPlayerService: 服务未就绪，等待服务初始化完成");
-        const isReady = await this.waitForAllServicesReady(3000, false);
+        const isReady = await this.waitForAllServicesReady(5000, true); // 增加等待时间并启用数据恢复检查
         if (!isReady) {
-          const error = new Error('Services not ready for playback');
-          await this.handlePlaybackError(error, PlayerErrorType.INITIALIZATION_ERROR);
-          return;
+          console.log("Heanup2 UnifiedPlayerService: 服务等待超时，尝试强制数据恢复...");
+          // 尝试强制数据恢复作为最后手段
+          const forceRestored = await this.forceDataRestoration();
+          if (!forceRestored) {
+            const error = new Error('Services not ready for playback after force restoration');
+            await this.handlePlaybackError(error, PlayerErrorType.INITIALIZATION_ERROR);
+            return;
+          }
+          console.log("Heanup2 UnifiedPlayerService: 强制数据恢复成功，继续播放流程");
         }
       }
 
@@ -689,10 +695,11 @@ export class UnifiedPlayerService implements IPlayerService, PlaylistSyncListene
 
         if (!currentSong) {
           console.log("Heanup2 UnifiedPlayerService: 恢复后仍然没有可播放的歌曲");
-          await this.handlePlaybackError(new Error('No song to play'), PlayerErrorType.PLAYBACK_ERROR);
+          // 冷启动优化：播放列表为空时的友好处理
+          await this.handleEmptyPlaylistScenario();
           return;
         }
-        console.log("Heanup2 UnifiedPlayerService: 恢复成功，当前歌曲信息:" + json.stringify(currentSong));
+        console.log("Heanup2 UnifiedPlayerService: 恢复成功，当前歌曲信息:" + JSON.stringify(currentSong));
       }
 
       this.stateModel.updateLoadingState(true);
@@ -719,6 +726,74 @@ export class UnifiedPlayerService implements IPlayerService, PlaylistSyncListene
     }
   }
 
+  /**
+   * 处理空播放列表场景（冷启动优化）
+   */
+  private async handleEmptyPlaylistScenario(): Promise<void> {
+    try {
+      console.log("Heanup2 UnifiedPlayerService: 处理空播放列表场景");
+      
+      // 停止加载状态
+      this.stateModel.updateLoadingState(false);
+      this.stateModel.updatePlayingState(false);
+      
+      // 尝试从数据库快速加载一些歌曲（如果有）
+      const quickSongs = await this.loadQuickPlaylistFromDatabase();
+      if (quickSongs && quickSongs.length > 0) {
+        console.log(`Heanup2 UnifiedPlayerService: 从数据库快速加载${quickSongs.length}首歌曲`);
+        this.setPlaylist(quickSongs, 0);
+        
+        // 再次尝试播放
+        const currentSong = this.playlistModel.getCurrentSong();
+        if (currentSong) {
+          await this.validateSongForPlayback(currentSong);
+          await this.setupAndStartPlayback(currentSong);
+          return;
+        }
+      }
+      
+      // 如果仍然没有歌曲，提供友好的用户提示
+      console.log("Heanup2 UnifiedPlayerService: 无可播放的歌曲，等待用户添加歌曲");
+      
+      // 更新widget显示空状态
+      await this.updateAllForms();
+      
+    } catch (error) {
+      console.log(`Heanup2 UnifiedPlayerService: 处理空播放列表场景失败: ${error}`);
+    }
+  }
+
+  /**
+   * 从数据库快速加载播放列表（用于冷启动场景）
+   */
+  private async loadQuickPlaylistFromDatabase(): Promise<VideoItem[] | null> {
+    try {
+      if (!this.context) {
+        return null;
+      }
+      
+      // 尝试从数据库加载最近播放的歌曲
+      const table = this.getTable();
+      return new Promise<VideoItem[]>((resolve) => {
+        table.queryRecentPlayedRecords(10, (songs: VideoItem[]) => {
+          if (songs && songs.length > 0) {
+            console.log(`Heanup2 UnifiedPlayerService: 从数据库加载到${songs.length}首最近播放的歌曲`);
+            resolve(songs);
+          } else {
+            // 如果没有最近播放，尝试加载任意歌曲
+            table.query(0, (allSongs: VideoItem[]) => {
+              console.log(`Heanup2 UnifiedPlayerService: 从数据库加载到${allSongs?.length || 0}首所有歌曲`);
+              resolve(allSongs || []);
+            }, true);
+          }
+        });
+      });
+    } catch (error) {
+      console.log(`Heanup2 UnifiedPlayerService: 从数据库加载播放列表失败: ${error}`);
+      return null;
+    }
+  }
+
   /**
    * 检查是否可以从暂停状态恢复播放
    */
@@ -763,8 +838,8 @@ export class UnifiedPlayerService implements IPlayerService, PlaylistSyncListene
     this.startProgressTimer();
     this.updateSessionPlayState();
     this.updateWidgetsForStateChange();
-    // 同步更新所有桌面卡片状态
-    this.updateAllForms();
+    // 关键修复：使用强制更新确保状态同步时卡片立即更新
+    this.updateAllForms(true);
   }
 
   public async toggleFavorite(): Promise<void> {
@@ -810,8 +885,8 @@ export class UnifiedPlayerService implements IPlayerService, PlaylistSyncListene
       this.updateSessionPlayState();
       await this.updateWidgetsForPlayStateChange();
 
-      // 同步更新所有桌面卡片状态
-      await this.updateAllForms();
+      // 关键修复：使用强制更新确保卡片状态立即同步
+      await this.updateAllForms(true);
     } catch (error) {
       throw new Error(`Resume from pause failed: ${error}`);
     }
@@ -947,8 +1022,8 @@ export class UnifiedPlayerService implements IPlayerService, PlaylistSyncListene
       // 更新卡片显示暂停状态
       await this.updateWidgetsForPlayStateChange();
 
-      // 同步更新所有桌面卡片状态
-      await this.updateAllForms();
+      // 关键修复：使用强制更新确保卡片状态立即同步
+      await this.updateAllForms(true);
 
     } catch (error) {
       LogUtils.getInstance().LOGI(`Heanup UnifiedPlayerService pause error: ${error}`);
@@ -1387,6 +1462,13 @@ export class UnifiedPlayerService implements IPlayerService, PlaylistSyncListene
     }
   }
 
+  /**
+   * 检查服务是否已初始化
+   */
+  isServiceInitialized(): boolean {
+    return this.initialized;
+  }
+
   /**
    * 检查所有相关服务是否已准备就绪
    * 用于桌面卡片控制等场景，确保在执行播放控制前服务状态正常
@@ -1398,7 +1480,7 @@ export class UnifiedPlayerService implements IPlayerService, PlaylistSyncListene
       this.hasChecked = true;
       try {
         // 检查基本初始化状态
-        if (!this.isInitialized) {
+        if (!this.initialized) {
           LogUtils.getInstance().LOGI('Heanup UnifiedPlayerService: Service not initialized');
           return false;
         }
@@ -1442,7 +1524,7 @@ export class UnifiedPlayerService implements IPlayerService, PlaylistSyncListene
 
     try {
       // 检查基础初始化
-      if (!this.isInitialized) {
+      if (!this.initialized) {
         errors.push('Service not initialized');
       }
 
@@ -1518,7 +1600,7 @@ export class UnifiedPlayerService implements IPlayerService, PlaylistSyncListene
     const currentIndex = this.playlistModel?.getCurrentIndex() || -1;
 
     const details: ServiceReadinessDetails = {
-      initialized: this.isInitialized,
+      initialized: this.initialized,
       hasPlayerInstance: !!playerInstance,
       hasContext: !!this.context,
       dataRestored: this.isDataRestored,
@@ -1626,8 +1708,10 @@ export class UnifiedPlayerService implements IPlayerService, PlaylistSyncListene
     const currentSong = this.playlistModel.getCurrentSong();
     this.stateModel.updateCurrentSong(currentSong);
 
-    // 同步到持久化存储
-    this.syncPlaylistToStorage();
+    // 同步到持久化存储（异步执行，不阻塞主线程）
+    this.syncPlaylistToStorage().catch((error:Error) => {
+      LogUtils.getInstance().LOGI(`Heanup UnifiedPlayerService setPlaylist syncPlaylistToStorage error: ${error}`);
+    });
 
     // 更新卡片显示播放列表变化
     this.updateWidgetsForPlaylistChange();
@@ -1648,8 +1732,10 @@ export class UnifiedPlayerService implements IPlayerService, PlaylistSyncListene
     // 更新状态模型中的播放列表状态
     this.updatePlaylistStateInModelSync();
 
-    // 同步到持久化存储
-    this.syncPlaylistToStorage();
+    // 同步到持久化存储（异步执行，不阻塞主线程）
+    this.syncPlaylistToStorage().catch((error:Error) => {
+      LogUtils.getInstance().LOGI(`Heanup UnifiedPlayerService addToPlaylist syncPlaylistToStorage error: ${error}`);
+    });
 
     // 更新卡片显示播放列表变化
     this.updateWidgetsForPlaylistChange();
@@ -1669,8 +1755,10 @@ export class UnifiedPlayerService implements IPlayerService, PlaylistSyncListene
       const currentSong = this.playlistModel.getCurrentSong();
       this.stateModel.updateCurrentSong(currentSong);
 
-      // 同步到持久化存储
-      this.syncPlaylistToStorage();
+      // 同步到持久化存储（异步执行，不阻塞主线程）
+      this.syncPlaylistToStorage().catch((error:Error) => {
+        LogUtils.getInstance().LOGI(`Heanup UnifiedPlayerService removeFromPlaylist syncPlaylistToStorage error: ${error}`);
+      });
 
       // 更新卡片显示播放列表变化
       this.updateWidgetsForPlaylistChange();
@@ -1720,7 +1808,7 @@ export class UnifiedPlayerService implements IPlayerService, PlaylistSyncListene
   }
 
   // 清理资源
-  release(): void {
+  async release(): Promise<void> {
     try {
       this.stopProgressTimer();
 
@@ -1734,6 +1822,11 @@ export class UnifiedPlayerService implements IPlayerService, PlaylistSyncListene
         this.avMetadataUpdateTimer = -1;
       }
 
+      // 关键修复：先保存当前状态，再清理资源
+      // 这样可以确保播放列表在应用被杀掉时不会丢失
+      await this.saveCurrentState();
+      LogUtils.getInstance().LOGI('Heanup UnifiedPlayerService: Current state saved before resource cleanup');
+
       // 重要修复：确保在应用销毁时将播放状态设置为停止
       try {
         // 强制设置为停止状态，防止卡片显示错误的播放状态
@@ -1750,9 +1843,6 @@ export class UnifiedPlayerService implements IPlayerService, PlaylistSyncListene
         LogUtils.getInstance().LOGI(`Heanup UnifiedPlayerService: Failed to force stop state: ${error}`);
       }
 
-      // 保存当前状态（现在应该是停止状态）
-      this.saveCurrentState();
-
       if (this.avSessionController) {
         this.avSessionController.unregisterSessionListener();
         this.avSessionController = null;
@@ -1762,8 +1852,9 @@ export class UnifiedPlayerService implements IPlayerService, PlaylistSyncListene
       this.playlistSync.removeSyncListener(this);
       this.playlistSync.release();
 
+      // 最后清理播放列表模型，确保在此之前状态已经保存
       this.playlistModel.clear();
-      this.isInitialized = false;
+      this.initialized = false;
 
       LogUtils.getInstance().LOGI('Heanup UnifiedPlayerService: Resources released');
     } catch (error) {
@@ -1912,7 +2003,7 @@ export class UnifiedPlayerService implements IPlayerService, PlaylistSyncListene
     } catch (recoveryError) {
       LogUtils.getInstance().LOGI(`Heanup UnifiedPlayerService: Error recovery failed: ${recoveryError}`);
       this.stateModel.notifyError(new PlayerError(PlayerErrorType.PLAYBACK_ERROR,
-        `Recovery failed: ${recoveryError.message}`));
+        `Recovery failed: ${(recoveryError as Error).message}`));
     }
   }
 
@@ -2454,7 +2545,7 @@ export class UnifiedPlayerService implements IPlayerService, PlaylistSyncListene
   /**
    * 保存当前状态
    */
-  private saveCurrentState(): void {
+  private async saveCurrentState(): Promise<void> {
     try {
       // 获取当前状态
       const currentState = this.stateModel.getState();
@@ -2497,7 +2588,7 @@ export class UnifiedPlayerService implements IPlayerService, PlaylistSyncListene
         }
       }
       
-      this.syncPlaylistToStorage();
+      await this.syncPlaylistToStorage();
 
       LogUtils.getInstance().LOGI(`Heanup UnifiedPlayerService: Current state saved successfully`);
     } catch (error) {
@@ -2508,20 +2599,30 @@ export class UnifiedPlayerService implements IPlayerService, PlaylistSyncListene
   /**
    * 外部调用保存当前状态的方法（供EntryAbility使用）
    */
-  public saveCurrentStateExternal(): void {
-    this.saveCurrentState();
+  public async saveCurrentStateExternal(): Promise<void> {
+    await this.saveCurrentState();
   }
 
   /**
    * 同步播放列表到存储
    */
-  private syncPlaylistToStorage(): void {
+  private async syncPlaylistToStorage(): Promise<void> {
     try {
       const playlist = this.playlistModel.getSongs();
       const currentIndex = this.playlistModel.getCurrentIndex();
       const playMode = this.stateModel.getState().playMode;
 
-      this.playlistSync.syncPlaylistToStorage(playlist, currentIndex, playMode);
+      // 获取调用栈信息用于调试
+      const stack = new Error().stack;
+      const caller = stack?.split('\n')[2]?.trim() || 'Unknown caller';
+      
+      LogUtils.getInstance().LOGI(`Heanup UnifiedPlayerService: syncPlaylistToStorage called - playlist length: ${playlist?.length || 0}, currentIndex: ${currentIndex}, playMode: ${playMode}, caller: ${caller}`);
+
+      // 总是尝试保存播放列表状态，包括空播放列表的情况
+      // 这样可以确保用户关闭应用时的真实状态被正确保存
+      await this.playlistSync.syncPlaylistToStorage(playlist || [], currentIndex, playMode);
+      
+      LogUtils.getInstance().LOGI(`Heanup UnifiedPlayerService: syncPlaylistToStorage completed successfully`);
     } catch (error) {
       LogUtils.getInstance().LOGI(`Heanup UnifiedPlayerService syncPlaylistToStorage error: ${error}`);
     }
@@ -2574,8 +2675,10 @@ export class UnifiedPlayerService implements IPlayerService, PlaylistSyncListene
    */
   onAutoSyncPerformed(): void {
     try {
-      // 定期保存当前状态
-      this.saveCurrentState();
+      // 定期保存当前状态（异步执行，不等待完成）
+      this.saveCurrentState().catch((error:Error) => {
+        LogUtils.getInstance().LOGI(`Heanup UnifiedPlayerService onAutoSyncPerformed saveCurrentState error: ${error}`);
+      });
     } catch (error) {
       LogUtils.getInstance().LOGI(`Heanup UnifiedPlayerService onAutoSyncPerformed error: ${error}`);
     }
@@ -2750,7 +2853,7 @@ export class UnifiedPlayerService implements IPlayerService, PlaylistSyncListene
           .LOGI('Heanup UnifiedPlayerService: Failed to set up audio interrupt listener - no player instance');
       }
     } catch (error) {
-      LogUtils.getInstance().LOGI(`Heanup UnifiedPlayerService: Error setting up audio interrupt listener: ${error.message}`);
+      LogUtils.getInstance().LOGI(`Heanup UnifiedPlayerService: Error setting up audio interrupt listener: ${(error as Error).message}`);
     }
   }
 
@@ -2803,7 +2906,7 @@ export class UnifiedPlayerService implements IPlayerService, PlaylistSyncListene
       await this.broadcastCurrentState();
 
     } catch (error) {
-      LogUtils.getInstance().LOGI(`Heanup UnifiedPlayerService: Error handling audio interrupt: ${error.message}`);
+      LogUtils.getInstance().LOGI(`Heanup UnifiedPlayerService: Error handling audio interrupt: ${(error as Error).message}`);
       await this.handlePlaybackError(error as Error, PlayerErrorType.AUDIO_INTERRUPT_ERROR);
     }
   }
@@ -3254,10 +3357,11 @@ export class UnifiedPlayerService implements IPlayerService, PlaylistSyncListene
    * 将VideoItem和PlayerState数据传入桌面卡片，控制卡片的显示
    */
   async updateAllForms(forceUpdate: boolean = false) {
-    // 增强防抖保护，特别是在APP前台运行时
+    // 优化防抖逻辑：缩短防抖时间，提高响应速度
     const now = Date.now();
-    if (!forceUpdate && this.lastFormUpdateTime && (now - this.lastFormUpdateTime < 200)) {
-      LogUtils.getInstance().LOGI('Heanup UnifiedPlayerService updateAllForms: Skipping due to debounce protection (200ms)');
+    const debounceTime = forceUpdate ? 0 : 100; // 强制更新无防抖，普通更新减少到100ms
+    if (!forceUpdate && this.lastFormUpdateTime && (now - this.lastFormUpdateTime < debounceTime)) {
+      LogUtils.getInstance().LOGI(`Heanup UnifiedPlayerService updateAllForms: Skipping due to debounce protection (${debounceTime}ms)`);
       return;
     }
     

entry/src/main/ets/entryability/EntryAbility.ets

@@ -244,9 +244,12 @@ export default class EntryAbility extends UIAbility {
     try {
       const unifiedPlayerService = UnifiedPlayerService.getInstance();
       if (unifiedPlayerService) {
-        // 确保在APP被杀掉时保存当前播放状态
-        unifiedPlayerService.release();
-        hilog.info(0x0000, 'Heanup2', 'UnifiedPlayerService released and state saved on app destroy');
+        // 确保在APP被杀掉时保存当前播放状态和播放列表
+        unifiedPlayerService.release().then(() => {
+          hilog.info(0x0000, 'Heanup2', 'UnifiedPlayerService released and state saved on app destroy');
+        }).catch((error: Error) => {
+          hilog.error(0x0000, 'Heanup2', `Failed to release UnifiedPlayerService: ${error}`);
+        });
       }
     } catch (error) {
       hilog.error(0x0000, 'Heanup2', `Failed to release UnifiedPlayerService: ${error}`);
@@ -579,13 +582,48 @@ export default class EntryAbility extends UIAbility {
 
 
   /**
-   * 发送卡片控制事件到主应用（优化版本，快速响应）
+   * 发送卡片控制事件到主应用（增强版本，支持冷启动场景）
    */
   private async sendWidgetControlEvent(command: string, params: Record<string, Object>): Promise<void> {
     try {
+      hilog.info(0x0000, 'Heanup2', `🎵 开始处理Widget控制事件: ${command}`);
+      
+      // 冷启动优化：如果服务未就绪，进行等待和重试
       if (!this.isServiceFullyReady) {
-        hilog.error(0x0000, 'Heanup2', '❌ UnifiedPlayerService 未初始化');
-        return;
+        hilog.info(0x0000, 'Heanup2', '🔄 服务未就绪，开始等待服务初始化...');
+        
+        // 等待服务就绪，最多等待5秒
+        const maxWaitTime = 5000;
+        const startTime = Date.now();
+        let retryCount = 0;
+        
+        while (!this.isServiceFullyReady && (Date.now() - startTime) < maxWaitTime) {
+          retryCount++;
+          hilog.info(0x0000, 'Heanup2', `🔄 等待服务就绪中... (第${retryCount}次检查)`);
+          
+          // 尝试强制检查服务状态
+          const serviceReady = await this.validateAndCacheServiceReadiness();
+          if (serviceReady) {
+            hilog.info(0x0000, 'Heanup2', '✅ 服务就绪检查成功');
+            break;
+          }
+          
+          // 如果服务仍未就绪，尝试强制数据恢复
+          if (!this.unifiedService.isDataRestorationCompleted()) {
+            hilog.info(0x0000, 'Heanup2', '🔄 尝试强制数据恢复...');
+            await this.unifiedService.forceDataRestoration();
+          }
+          
+          // 短暂等待后继续检查
+          await new Promise<void>(resolve => setTimeout(resolve, 200));
+        }
+        
+        // 最终检查服务状态
+        if (!this.isServiceFullyReady) {
+          hilog.error(0x0000, 'Heanup2', `❌ 服务等待超时，无法执行Widget控制事件: ${command}`);
+          return;
+        }
+        hilog.info(0x0000, 'Heanup2', `✅ 服务就绪，开始执行Widget控制事件: ${command}`);
       }
       
       // 优化：立即执行命令，减少状态检查开销
@@ -596,27 +634,33 @@ export default class EntryAbility extends UIAbility {
           // 优化：直接基于参数判断，避免重复状态查询
           const widgetIsPlaying = params['widgetIsPlaying'] as boolean;
           if (widgetIsPlaying !== undefined) {
+            hilog.info(0x0000, 'Heanup2', `🎵 基于widget状态执行播放控制: ${widgetIsPlaying ? '暂停' : '播放'}`);
             commandPromise = widgetIsPlaying ? this.unifiedService.pause() : this.unifiedService.startPlayOrResumePlay();
           } else {
             // 回退到状态检查
             const currentState = this.unifiedService.getCurrentState();
+            hilog.info(0x0000, 'Heanup2', `🎵 基于播放器状态执行播放控制: ${currentState.isPlaying ? '暂停' : '播放'}`);
             commandPromise = currentState.isPlaying ? this.unifiedService.pause() : this.unifiedService.startPlayOrResumePlay();
           }
           break;
 
         case 'NEXT_SONG':
+          hilog.info(0x0000, 'Heanup2', '🎵 执行下一首操作');
           commandPromise = this.unifiedService.playNext();
           break;
 
         case 'PREV_SONG':
+          hilog.info(0x0000, 'Heanup2', '🎵 执行上一首操作');
           commandPromise = this.unifiedService.playPrevious();
           break;
 
         case 'OPEN_APP':
           // 打开应用由UI处理，直接返回
+          hilog.info(0x0000, 'Heanup2', '🎵 打开应用操作');
           return;
 
         case "toggleFavorite":
+          hilog.info(0x0000, 'Heanup2', '🎵 执行收藏切换操作');
           commandPromise = this.unifiedService.toggleFavorite();
           break;
 
@@ -637,10 +681,11 @@ export default class EntryAbility extends UIAbility {
         }, 50); // 小延迟确保命令执行完成
       });
       
-      hilog.info(0x0000, 'Heanup2', `✅ Widget命令执行完成: ${command}`);
-
+      hilog.info(0x0000, 'Heanup2', `✅ Widget控制事件执行成功: ${command}`);
+      
     } catch (error) {
-      hilog.error(0x0000, 'Heanup2', `❌ Failed to process widget control command: ${error}`);
+      hilog.error(0x0000, 'Heanup2', `❌ Widget控制事件执行失败: ${command}, error: ${error}`);
+      throw new Error(`Widget控制事件执行失败: ${command}`);
     }
   }
 
@@ -772,17 +817,21 @@ export default class EntryAbility extends UIAbility {
   /**
    * 异步处理后台逻辑
    */
-  private handleBackgroundAsync(): void {
+  private async handleBackgroundAsync(): Promise<void> {
     try {
       hilog.info(0x0000, 'Heanup2', '🔄 处理后台逻辑');
 
       // 关键修复：应用进入后台时保存播放器状态
+      // 但要避免在应用销毁时重复保存，因为onDestroy中已经保存过了
       try {
         const unifiedPlayerService = UnifiedPlayerService.getInstance();
-        if (unifiedPlayerService && unifiedPlayerService.isAllServicesReady()) {
+        if (unifiedPlayerService && unifiedPlayerService.isAllServicesReady() && unifiedPlayerService.isServiceInitialized()) {
+          // 检查服务是否已经被释放，如果已释放说明是应用销毁流程，不需要再保存
           // 保存当前状态，确保即使应用被强制杀死也能保存正确状态
-          unifiedPlayerService.saveCurrentStateExternal();
+          await unifiedPlayerService.saveCurrentStateExternal();
           hilog.info(0x0000, 'Heanup2', '✅ 播放器状态已保存（后台）');
+        } else {
+          hilog.info(0x0000, 'Heanup2', '⚠️ 跳过状态保存 - 服务未就绪或已释放');
         }
       } catch (error) {
         hilog.error(0x0000, 'Heanup2', `❌ 保存播放器状态失败: ${error}`);