集成播放卡片

entry/src/main/ets/common/widget/AvSessionWidgetListener.ets

@@ -42,7 +42,14 @@ export class AvSessionWidgetListener {
    * 注册状态监听器
    */
   public addStateListener(callback: (data: WidgetData) => void): void {
-    this.stateListeners.push(callback);
+    // 检查是否已经注册过相同的监听器，避免重复注册
+    if (this.stateListeners.indexOf(callback) === -1) {
+      this.stateListeners.push(callback);
+      hilog.info(0x0000, TAG, `State listener registered, total listeners: ${this.stateListeners.length}`);
+    } else {
+      hilog.warn(0x0000, TAG, 'State listener already registered, skipping');
+      return;
+    }
     
     // 如果有缓存的数据，立即返回
     if (this.lastWidgetData) {
@@ -52,8 +59,6 @@ export class AvSessionWidgetListener {
       const defaultData = this.getDefaultWidgetData();
       callback(defaultData);
     }
-    
-    hilog.info(0x0000, TAG, 'State listener registered');
   }
 
   /**
@@ -62,16 +67,19 @@ export class AvSessionWidgetListener {
   public updateWidgetData(data: WidgetData): void {
     this.lastWidgetData = data;
     
+    hilog.info(0x0000, TAG, `Updating widget data: isPlaying=${data.playState.isPlaying}, title=${data.currentSong.title}, listeners=${this.stateListeners.length}`);
+    
     // 通知所有监听器
-    this.stateListeners.forEach((listener: (data: WidgetData) => void) => {
+    this.stateListeners.forEach((listener: (data: WidgetData) => void, index: number) => {
       try {
+        hilog.info(0x0000, TAG, `Notifying listener ${index}`);
         listener(data);
       } catch (error) {
-        hilog.error(0x0000, TAG, `Error in state listener: ${error}`);
+        hilog.error(0x0000, TAG, `Error in state listener ${index}: ${error}`);
       }
     });
     
-    hilog.info(0x0000, TAG, 'Widget data updated and broadcasted to listeners');
+    hilog.info(0x0000, TAG, `Widget data updated and broadcasted to ${this.stateListeners.length} listeners`);
   }
 
   /**

entry/src/main/ets/common/widget/GlobalWidgetManager.ets

@@ -0,0 +1,78 @@
+import { hilog } from '@kit.PerformanceAnalysisKit';
+import { WidgetSize } from './WidgetTypes';
+
+const TAG = 'Heanup GlobalWidgetManager';
+
+/**
+ * 全局卡片管理器
+ * 管理所有活跃的卡片实例，避免多个FormExtensionAbility实例之间的冲突
+ */
+export class GlobalWidgetManager {
+  private static instance: GlobalWidgetManager | null = null;
+  private static activeWidgets: Map<string, WidgetSize> = new Map();
+
+  private constructor() {}
+
+  public static getInstance(): GlobalWidgetManager {
+    if (!GlobalWidgetManager.instance) {
+      GlobalWidgetManager.instance = new GlobalWidgetManager();
+    }
+    return GlobalWidgetManager.instance;
+  }
+
+  /**
+   * 注册卡片
+   */
+  public registerWidget(formId: string, size: WidgetSize): void {
+    GlobalWidgetManager.activeWidgets.set(formId, size);
+    hilog.info(0x0000, TAG, `Widget registered: ${formId}, size: ${size}, total: ${GlobalWidgetManager.activeWidgets.size}`);
+  }
+
+  /**
+   * 注销卡片
+   */
+  public unregisterWidget(formId: string): void {
+    const removed = GlobalWidgetManager.activeWidgets.delete(formId);
+    hilog.info(0x0000, TAG, `Widget unregistered: ${formId}, removed: ${removed}, total: ${GlobalWidgetManager.activeWidgets.size}`);
+  }
+
+  /**
+   * 获取所有活跃卡片
+   */
+  public getActiveWidgets(): Map<string, WidgetSize> {
+    return new Map(GlobalWidgetManager.activeWidgets);
+  }
+
+  /**
+   * 获取活跃卡片数量
+   */
+  public getActiveWidgetCount(): number {
+    return GlobalWidgetManager.activeWidgets.size;
+  }
+
+  /**
+   * 检查卡片是否存在
+   */
+  public hasWidget(formId: string): boolean {
+    return GlobalWidgetManager.activeWidgets.has(formId);
+  }
+
+  /**
+   * 获取卡片尺寸
+   */
+  public getWidgetSize(formId: string): WidgetSize | undefined {
+    return GlobalWidgetManager.activeWidgets.get(formId);
+  }
+
+  /**
+   * 更新卡片尺寸
+   */
+  public updateWidgetSize(formId: string, size: WidgetSize): void {
+    if (GlobalWidgetManager.activeWidgets.has(formId)) {
+      GlobalWidgetManager.activeWidgets.set(formId, size);
+      hilog.info(0x0000, TAG, `Widget size updated: ${formId}, new size: ${size}`);
+    } else {
+      hilog.warn(0x0000, TAG, `Cannot update size for non-existent widget: ${formId}`);
+    }
+  }
+}

entry/src/main/ets/common/widget/WidgetDataManager.ets

@@ -221,7 +221,7 @@ export class WidgetDataManager {
   /**
    * 格式化数据用于卡片显示
    */
-  private formatDataForWidget(data: WidgetData): FormattedWidgetData {
+  public formatDataForWidget(data: WidgetData): FormattedWidgetData {
     hilog.info(0x0000, TAG, `Formatting data for widget: hasNext=${data.playlist.hasNext}, hasPrevious=${data.playlist.hasPrevious}, currentIndex=${data.playlist.currentIndex}, totalCount=${data.playlist.totalCount}`);
     
     // 修复按钮状态：基于当前索引和总数重新计算正确的按钮状态

entry/src/main/ets/entryformability/EntryFormAbility.ets

@@ -5,8 +5,10 @@ import { hilog } from '@kit.PerformanceAnalysisKit';
 
 import { WidgetDataManager } from '../common/widget/WidgetDataManager';
 import { PlayerControlService } from '../common/widget/PlayerControlService';
+import { AvSessionWidgetListener } from '../common/widget/AvSessionWidgetListener';
 import { WidgetCommand, WidgetControlParams, WidgetData, WidgetSize } from '../common/widget/WidgetTypes';
 import { FormLayoutManager } from '../common/widget/FormLayoutManager';
+import { GlobalWidgetManager } from '../common/widget/GlobalWidgetManager';
 import { WidgetSizeAdapter, SizeChangeListener } from '../common/widget/WidgetSizeAdapter';
 import { WidgetConfigManager, UserPreferences } from '../common/widget/WidgetConfigManager';
 import { ThemeSyncService, ThemeChangeListener, ThemeChangeEvent, ThemeInfo } from '../common/widget/ThemeSyncService';
@@ -65,16 +67,85 @@ implements SizeChangeListener, ThemeChangeListener, PreferencesChangeListener {
   private configManager: WidgetConfigManager = WidgetConfigManager.getInstance();
   private themeSyncService: ThemeSyncService = ThemeSyncService.getInstance();
   private userPreferencesService: UserPreferencesService = UserPreferencesService.getInstance();
-  private formSizeMap: Map<string, WidgetSize> = new Map();
+  private globalWidgetManager: GlobalWidgetManager = GlobalWidgetManager.getInstance();
+  
+  // 使用实例变量而不是静态变量，确保每个进程都能正确设置监听器
+  private globalListenerSetup: boolean = false;
 
   /**
    * 初始化服务
    */
   private initializeServices(): void {
+    hilog.info(0x0000, TAG, 'Heanup widget initializeServices called');
+    
     if (!this.widgetDataManager) {
       this.widgetDataManager = new WidgetDataManager();
       hilog.info(0x0000, TAG, 'WidgetDataManager initialized');
     }
+    
+    // 设置全局状态监听器（每个进程实例设置一次）
+    hilog.info(0x0000, TAG, `Heanup widget checking global listener setup: ${this.globalListenerSetup}`);
+    if (!this.globalListenerSetup) {
+      hilog.info(0x0000, TAG, 'Heanup widget setting up global listener...');
+      this.setupGlobalStateListener();
+      this.globalListenerSetup = true;
+      hilog.info(0x0000, TAG, 'Heanup widget global listener setup flag set to true');
+    } else {
+      hilog.info(0x0000, TAG, 'Heanup widget global listener already setup, skipping');
+    }
+  }
+
+  /**
+   * 设置全局状态监听器
+   */
+  private setupGlobalStateListener(): void {
+    try {
+      const avSessionListener = AvSessionWidgetListener.getInstance();
+      avSessionListener.addStateListener((data: WidgetData) => {
+        hilog.info(0x0000, TAG, `Heanup widget global listener received state update: isPlaying=${data.playState.isPlaying}, title=${data.currentSong.title}`);
+        
+        // 总是尝试更新，让updateAllWidgetsWithData自己检查
+        this.updateAllWidgetsWithData(data);
+      });
+      
+      hilog.info(0x0000, TAG, 'Heanup widget global state listener setup successfully');
+    } catch (error) {
+      hilog.error(0x0000, TAG, `Heanup widget failed to setup global listener: ${error}`);
+    }
+  }
+
+  /**
+   * 使用指定数据更新所有卡片
+   */
+  private updateAllWidgetsWithData(data: WidgetData): void {
+    const activeWidgets = this.globalWidgetManager.getActiveWidgets();
+    hilog.info(0x0000, TAG, `Heanup widget updateAllWidgetsWithData called, active widgets: ${activeWidgets.size}`);
+    
+    if (activeWidgets.size === 0) {
+      hilog.warn(0x0000, TAG, 'Heanup widget no widgets to update in this process, skipping');
+      return;
+    }
+    
+    activeWidgets.forEach((size: WidgetSize, formId: string) => {
+      try {
+        // 根据卡片尺寸适配数据
+        const adaptedData = this.layoutManager.adaptDataForSize(data, size);
+        
+        hilog.info(0x0000, TAG, `Heanup widget ${formId} calling formProvider.updateForm with isPlaying=${adaptedData.isPlaying}`);
+        
+        // 直接使用系统API更新卡片
+        const formData = formBindingData.createFormBindingData(adaptedData);
+        formProvider.updateForm(formId, formData).then(() => {
+          hilog.info(0x0000, TAG, `Heanup widget ${formId} updated successfully: isPlaying=${adaptedData.isPlaying}, title=${adaptedData.songTitle}`);
+        }).catch(() => {//不能传error参数
+          hilog.error(0x0000, TAG, `Heanup widget ${formId} update failed: `);
+        });
+      } catch (error) {
+        hilog.error(0x0000, TAG, `Heanup widget ${formId} process error: ${error}`);
+      }
+    });
+    
+    hilog.info(0x0000, TAG, `Heanup widget batch update completed for ${activeWidgets.size} widgets`);
   }
 
   /**
@@ -84,7 +155,12 @@ implements SizeChangeListener, ThemeChangeListener, PreferencesChangeListener {
     hilog.info(0x0000, TAG, 'onAddForm called');
     
     // 初始化服务
-    this.initializeServices();
+    try {
+      this.initializeServices();
+      hilog.info(0x0000, TAG, 'Services initialized successfully');
+    } catch (error) {
+      hilog.error(0x0000, TAG, `Failed to initialize services: ${error}`);
+    }
 
     const formId = want.parameters?.['ohos.extra.param.key.form_identity'] as string;
     const formName = want.parameters?.['ohos.extra.param.key.form_name'] as string;
@@ -92,9 +168,14 @@ implements SizeChangeListener, ThemeChangeListener, PreferencesChangeListener {
 
     hilog.info(0x0000, TAG, `Form added: ${formId}, name: ${formName}, temp: ${tempFlag}`);
 
-    // 检测卡片尺寸
+    // 检测卡片尺寸并注册到全局管理器
     const widgetSize = this.sizeAdapter.detectSizeFromWant(want);
-    this.formSizeMap.set(formId, widgetSize);
+    try {
+      this.globalWidgetManager.registerWidget(formId, widgetSize);
+      hilog.info(0x0000, TAG, `Widget registered successfully: ${formId}, size: ${widgetSize}`);
+    } catch (error) {
+      hilog.error(0x0000, TAG, `Failed to register widget: ${error}`);
+    }
 
     hilog.info(0x0000, TAG, `Detected widget size: ${widgetSize} for form: ${formId}`);
 
@@ -173,13 +254,8 @@ implements SizeChangeListener, ThemeChangeListener, PreferencesChangeListener {
   onUpdateForm(formId: string): void {
     hilog.info(0x0000, TAG, `onUpdateForm called: ${formId}`);
 
-    // 获取最新的播放状态数据
+    // 只更新指定的卡片，避免重复更新
     this.updateWidgetData(formId);
-    
-    // 延迟再次更新，确保数据同步到所有卡片
-    setTimeout((): void => {
-      this.updateAllWidgetsData();
-    }, 200);
   }
 
   /**
@@ -193,8 +269,8 @@ implements SizeChangeListener, ThemeChangeListener, PreferencesChangeListener {
     this.themeSyncService.removeThemeChangeListener(this);
     this.userPreferencesService.removePreferencesChangeListener(this);
 
-    // 清理卡片尺寸记录
-    this.formSizeMap.delete(formId);
+    // 从全局管理器中注销卡片
+    this.globalWidgetManager.unregisterWidget(formId);
 
     // 清理卡片相关数据和配置
     this.widgetDataManager?.removeWidgetData(formId);
@@ -254,8 +330,8 @@ implements SizeChangeListener, ThemeChangeListener, PreferencesChangeListener {
   onSizeChanged(formId: string, oldSize: WidgetSize, newSize: WidgetSize): void {
     hilog.info(0x0000, TAG, `Size changed for form ${formId}: ${oldSize} -> ${newSize}`);
 
-    // 更新尺寸记录
-    this.formSizeMap.set(formId, newSize);
+    // 更新全局管理器中的尺寸记录
+    this.globalWidgetManager.updateWidgetSize(formId, newSize);
 
     // 立即更新卡片数据以适应新尺寸
     this.updateWidgetData(formId);
@@ -273,7 +349,7 @@ implements SizeChangeListener, ThemeChangeListener, PreferencesChangeListener {
     if (formId) {
       // 检测新的尺寸
       const newSize = this.sizeAdapter.detectSizeFromWant(want);
-      const oldSize = this.formSizeMap.get(formId);
+      const oldSize = this.globalWidgetManager.getWidgetSize(formId);
 
       if (oldSize && this.sizeAdapter.validateSizeChange(oldSize, newSize)) {
         // 处理尺寸变化
@@ -312,17 +388,7 @@ implements SizeChangeListener, ThemeChangeListener, PreferencesChangeListener {
    */
   private async initializeWidget(formId: string, widgetSize: WidgetSize): Promise<void> {
     try {
-      // 注册播放状态监听
-      this.playerControlService.registerStateListener((data: WidgetData) => {
-        hilog.info(0x0000, TAG, `Widget ${formId} received state update: isPlaying=${data.playState.isPlaying}, title=${data.currentSong.title}, hasNext=${data.playlist.hasNext}, hasPrevious=${data.playlist.hasPrevious}`);
-        
-        // 根据卡片尺寸适配数据
-        const currentSize = this.formSizeMap.get(formId) || WidgetSize.MEDIUM;
-        const adaptedData = this.layoutManager.adaptDataForSize(data, currentSize);
-        this.widgetDataManager?.updateWidget(formId, adaptedData);
-        
-        hilog.info(0x0000, TAG, `Widget ${formId} updated successfully`);
-      });
+      hilog.info(0x0000, TAG, `Heanup widget initializing: ${formId} with size: ${widgetSize}`);
 
       // 获取当前播放状态
       const currentState = await this.playerControlService.getCurrentPlayState();
@@ -340,68 +406,37 @@ implements SizeChangeListener, ThemeChangeListener, PreferencesChangeListener {
       const adaptedData = this.layoutManager.adaptDataForSize(currentState, widgetSize);
       await this.widgetDataManager?.saveWidgetData(formId, adaptedData);
 
-      // 立即请求一次最新状态，并多次重试确保获取到真实状态
-      setTimeout(() => {
-        this.updateWidgetData(formId);
-      }, 500);
-      
-      setTimeout(() => {
-        this.updateWidgetData(formId);
-      }, 2000);
-      
-      setTimeout(() => {
-        this.updateWidgetData(formId);
-      }, 5000);
+      // 立即更新一次卡片数据
+      await this.updateWidgetData(formId);
 
-      hilog.info(0x0000, TAG, `Widget ${formId} initialized successfully with size: ${widgetSize}, listeners registered: PlayerControl + AvSession`);
+      hilog.info(0x0000, TAG, `Heanup widget ${formId} initialized successfully with size: ${widgetSize}`);
     } catch (error) {
       hilog.error(0x0000, TAG, `Failed to initialize widget ${formId}: ${error}`);
     }
   }
 
   /**
-   * 更新卡片数据
+   * 更新卡片数据（简化版本）
    */
   private async updateWidgetData(formId: string): Promise<void> {
     try {
       const currentState = await this.playerControlService.getCurrentPlayState();
 
       // 获取卡片当前尺寸
-      const currentSize = this.formSizeMap.get(formId) || WidgetSize.MEDIUM;
+      const currentSize = this.globalWidgetManager.getWidgetSize(formId) || WidgetSize.MEDIUM;
 
-      // 适配数据到当前尺寸
+      // 适配数据到当前尺寸并直接更新
       const adaptedData = this.layoutManager.adaptDataForSize(currentState, currentSize);
-      await this.widgetDataManager?.updateWidget(formId, adaptedData);
+      const formData = formBindingData.createFormBindingData(adaptedData);
+      await formProvider.updateForm(formId, formData);
 
-      hilog.info(0x0000, TAG, `Widget ${formId} updated successfully with size: ${currentSize}`);
+      hilog.info(0x0000, TAG, `Heanup widget ${formId} updated successfully with size: ${currentSize}, isPlaying=${adaptedData.isPlaying}`);
     } catch (error) {
       hilog.error(0x0000, TAG, `Failed to update widget ${formId}: ${error}`);
     }
   }
 
-  /**
-   * 更新所有卡片数据
-   */
-  private async updateAllWidgetsData(): Promise<void> {
-    try {
-      const currentState = await this.playerControlService.getCurrentPlayState();
-      
-      // 遍历所有卡片ID并更新
-      this.formSizeMap.forEach(async (size: WidgetSize, formId: string) => {
-        try {
-          const adaptedData = this.layoutManager.adaptDataForSize(currentState, size);
-          await this.widgetDataManager?.updateWidget(formId, adaptedData);
-          hilog.info(0x0000, TAG, `Widget ${formId} updated in batch with size: ${size}`);
-        } catch (error) {
-          hilog.error(0x0000, TAG, `Failed to update widget ${formId} in batch: ${error}`);
-        }
-      });
-      
-      hilog.info(0x0000, TAG, `Batch update completed for ${this.formSizeMap.size} widgets`);
-    } catch (error) {
-      hilog.error(0x0000, TAG, `Failed to batch update widgets: ${error}`);
-    }
-  }
+
 
   /**
    * 处理卡片事件
@@ -494,13 +529,9 @@ implements SizeChangeListener, ThemeChangeListener, PreferencesChangeListener {
           return;
       }
 
-      // 处理完命令后立即更新当前卡片状态
-      this.updateWidgetData(formId);
-      
-      // 延迟更新所有卡片，确保状态同步
-      setTimeout((): void => {
-        this.updateAllWidgetsData();
-      }, 300);
+      // 不要立即更新卡片，等待真实状态通过CommonEvent到达
+      // 真实状态会通过全局监听器自动更新所有卡片
+      hilog.info(0x0000, TAG, `Widget event processed, waiting for real state update via CommonEvent`);
 
     } catch (error) {
       hilog.error(0x0000, TAG, `Failed to handle widget event: ${error}`);
@@ -599,7 +630,7 @@ implements SizeChangeListener, ThemeChangeListener, PreferencesChangeListener {
       hilog.info(0x0000, TAG, `Opening widget settings for form: ${formId}`);
 
       // 获取当前卡片配置
-      const currentSize = this.formSizeMap.get(formId) || WidgetSize.MEDIUM;
+      const currentSize = this.globalWidgetManager.getWidgetSize(formId) || WidgetSize.MEDIUM;
       const currentConfig = await this.configManager.getWidgetConfig(formId, currentSize);
 
       // 启动主应用到卡片设置页面，传递卡片ID和当前配置
@@ -647,7 +678,7 @@ implements SizeChangeListener, ThemeChangeListener, PreferencesChangeListener {
       hilog.info(0x0000, TAG, `Opening widget config page for form: ${formId}`);
 
       // 获取当前卡片信息
-      const currentSize = this.formSizeMap.get(formId) || WidgetSize.MEDIUM;
+      const currentSize = this.globalWidgetManager.getWidgetSize(formId) || WidgetSize.MEDIUM;
       const currentConfig = await this.configManager.getWidgetConfig(formId, currentSize);
 
       // 启动主应用到卡片配置页面

entry/src/main/ets/view/LocalMusic.ets

@@ -176,6 +176,8 @@ export struct LocalMusic {
   private widgetEventSubscriber: commonEventManager.CommonEventSubscriber | null = null; // 卡片事件订阅者
   private lastProgressBroadcastTime: number = 0; // 上次进度广播时间
   private readonly PROGRESS_BROADCAST_INTERVAL: number = 1000; // 进度广播间隔（1秒）
+  private lastStateBroadcastTime: number = 0; // 上次状态广播时间
+  private readonly STATE_BROADCAST_INTERVAL: number = 500; // 状态广播间隔（0.5秒）
   @State isSameTimePlay: boolean = false //是否和其他app同时播放
   @State isStartAutoPlay: boolean = false //启动后自动播放
   @State isShowPlayPageBack: boolean = false //是否显示播放页返回键
@@ -524,11 +526,11 @@ export struct LocalMusic {
       LogUtils.getInstance().LOGI(`Delayed state broadcast: songList.length=${this.songList.length}, curIndex=${this.curIndex}`);
     }, 2000);
     
-    // 定期广播状态更新，确保卡片状态同步
-    setInterval(() => {
-      LogUtils.getInstance().LOGI('Periodic widget state broadcast');
-      this.broadcastPlayerState();
-    }, 10000); // 每10秒广播一次状态
+    // 移除定期广播，避免重复更新
+    // setInterval(() => {
+    //   LogUtils.getInstance().LOGI('Periodic widget state broadcast');
+    //   this.broadcastPlayerState();
+    // }, 10000);
 
     //折叠屏的屏幕显示模式变化
     display.on('foldDisplayModeChange', (data) => {
@@ -825,28 +827,17 @@ export struct LocalMusic {
         this.cover = this.currentSong.pixelMapPath
         AppStorage.setOrCreate('currentSong',this.currentSong) ;
         
-        // 立即广播初始状态到卡片，确保hasNext和hasPrevious正确
+        // 延迟广播初始状态到卡片
         setTimeout(() => {
           this.broadcastPlayerState();
           LogUtils.getInstance().LOGI(`Initial state broadcasted: songList.length=${this.songList.length}, curIndex=${this.curIndex}`);
-        }, 100);
-        
-        // 多次广播确保卡片接收到状态
-        setTimeout(() => {
-          this.broadcastPlayerState();
-          LogUtils.getInstance().LOGI(`Second state broadcast: ensuring widget sync`);
         }, 1000);
-        
-        setTimeout(() => {
-          this.broadcastPlayerState();
-          LogUtils.getInstance().LOGI(`Third state broadcast: final sync attempt`);
-        }, 3000);
       } else {
         this.name = '空空如也'
         // 即使没有歌曲也要广播状态
         setTimeout(() => {
           this.broadcastPlayerState();
-        }, 100);
+        }, 1000);
       }
     })
 
@@ -11119,13 +11110,9 @@ export struct LocalMusic {
    */
   private initAvSessionWidgetListener(): void {
     try {
-      // 注册AvSession状态变化监听器，用于同步卡片状态
-      this.avSessionWidgetListener.addStateListener((widgetData) => {
-        // AvSession状态变化时，自动广播到卡片
-        this.broadcastAvSessionStateToWidget(widgetData);
-      });
-
-      LogUtils.getInstance().LOGI('AvSession widget listener initialized successfully');
+      // 不需要在这里注册监听器，因为我们直接通过updateWidgetData更新数据
+      // 避免循环调用和重复广播
+      LogUtils.getInstance().LOGI('AvSession widget listener initialized successfully (no circular listener)');
     } catch (error) {
       LogUtils.getInstance().error(`Failed to initialize AvSession widget listener: ${error}`);
     }
@@ -11342,9 +11329,16 @@ export struct LocalMusic {
   }
 
   /**
-   * 广播播放器状态到卡片
+   * 广播播放器状态到卡片（带节流）
    */
   private broadcastPlayerState(): void {
+    // 节流：避免短时间内重复广播
+    const now = Date.now();
+    if (now - this.lastStateBroadcastTime < this.STATE_BROADCAST_INTERVAL) {
+      return;
+    }
+    this.lastStateBroadcastTime = now;
+    
     try {
       LogUtils.getInstance().LOGI(`Broadcasting player state: CONTROL_PlayStatus=${this.CONTROL_PlayStatus}, PlayStatus.PLAY=${PlayStatus.PLAY}, PlayStatus.PAUSE=${PlayStatus.PAUSE}`);
       

entry/src/main/ets/widget/pages/PlayerWidgetLarge.ets

@@ -73,7 +73,15 @@ struct PlayerWidgetLarge {
               .fontSize(12)
               .fontColor('#FFFFFF')
               .padding(4)
-              .backgroundColor('#80000000')
+              .backgroundColor('#FF6B6B')
+              .borderRadius(6)
+              .position({ x: 4, y: 4 })
+          } else {
+            Text('⏸')
+              .fontSize(12)
+              .fontColor('#FFFFFF')
+              .padding(4)
+              .backgroundColor('#666666')
               .borderRadius(6)
               .position({ x: 4, y: 4 })
           }