Merge remote-tracking branch 'origin/master'

entry/src/main/ets/common/network/AudioStationApi.ets

@@ -123,6 +123,7 @@ interface AudioStationSearchData {
 interface AudioStationPagedResponse<T> {
   items: T[];
   nextStart: number | null;
+  total?: number;  // 服务端返回的总数
 }
 
 interface AudioStationLoginRequestBody {
@@ -530,7 +531,8 @@ export class AudioStationApi {
     const nextStart = offset + items.length < total ? offset + items.length : null;
     const result: AudioStationPagedResponse<AudioStationSong> = {
       items,
-      nextStart
+      nextStart,
+      total
     };
     return result;
   }

entry/src/main/ets/common/network/DaoLiYuApi.ets

@@ -195,6 +195,7 @@ export interface DaoLiYuPlaylist {
 export interface DaoLiYuPagedResponse<T> {
   items: T[];
   nextStart: number | null;
+  total?: number;
 }
 
 export class DaoLiYuApi {
@@ -253,7 +254,8 @@ export class DaoLiYuApi {
       .filter(item => item.id)
       .map(item => this.mapTrack(item));
     const nextStart = this.resolveNextStart(data, start, items.length);
-    return { items, nextStart };
+    const total = typeof data.total === 'number' ? data.total : undefined;
+    return { items, nextStart, total };
   }
 
   async getPlaylistsPage(account: WebDavAccount, start: number = 0, size: number = 200): Promise<DaoLiYuPagedResponse<DaoLiYuPlaylist>> {

entry/src/main/ets/common/network/EmbyApi.ets

@@ -54,6 +54,7 @@ interface EmbyItemsResponse {
 export interface EmbyPagedResponse<T> {
   items: T[];
   nextStart: number | null;
+  total?: number;
 }
 
 interface EmbyPerson {
@@ -315,7 +316,8 @@ export class EmbyApi {
       }
     }
     const nextStart = items.length < limit ? null : startIndex + items.length;
-    const result: EmbyPagedResponse<EmbySong> = { items: songs, nextStart: nextStart };
+    const total = response.TotalRecordCount;
+    const result: EmbyPagedResponse<EmbySong> = { items: songs, nextStart: nextStart, total: total };
     return result;
   }
 

entry/src/main/ets/common/network/JellyfinApi.ets

@@ -48,11 +48,13 @@ interface JellyfinItem {
 
 interface JellyfinItemsResponse {
   Items?: JellyfinItem[];
+  TotalRecordCount?: number;
 }
 
 export interface JellyfinPagedResponse<T> {
   items: T[];
   nextStart: number | null;
+  total?: number;
 }
 
 interface JellyfinPerson {
@@ -291,7 +293,8 @@ export class JellyfinApi {
       }
     }
     const nextStart = items.length < limit ? null : startIndex + items.length;
-    const result: JellyfinPagedResponse<JellyfinSong> = { items: songs, nextStart: nextStart };
+    const total = response.TotalRecordCount;
+    const result: JellyfinPagedResponse<JellyfinSong> = { items: songs, nextStart: nextStart, total: total };
     return result;
   }
 

entry/src/main/ets/common/network/PlexApi.ets

@@ -78,6 +78,7 @@ export interface PlexPlaylist {
 export interface PlexPagedResponse<T> {
   items: T[];
   nextStart: number | null;
+  total?: number;
 }
 
 export class PlexApi {
@@ -160,7 +161,8 @@ export class PlexApi {
     const container = this.parseContainer(xml);
     const entries = this.parseTracks(xml);
     const nextStart = this.computeNextStart(container, entries.length, start);
-    return { items: entries, nextStart };
+    const total = container.totalSize ?? container.size;
+    return { items: entries, nextStart, total };
   }
 
   async getAlbumsPage(account: WebDavAccount, start: number = 0, size: number = 200): Promise<PlexPagedResponse<PlexAlbum>> {

entry/src/main/ets/common/util/NavidromePlaylistStore.ets

@@ -2,6 +2,10 @@ import { VideoItem } from '../../viewmodel/VideoItem';
 
 let navidromeVideoItems: VideoItem[] = [];
 let navidromeCurrentPlayIndex: number = 0;
+// 已播放歌曲路径集合(用于渐进式随机播放)
+let playedFilePaths: Set<string> = new Set();
+// 服务端返回的歌曲总数（用于正确显示播放列表总数）
+let navidromeTotalCount: number = 0;
 
 export function setNavidromePlaylist(items: VideoItem[], startIndex: number): void {
   navidromeVideoItems = items.slice();
@@ -19,4 +23,78 @@ export function getNavidromeCurrentPlayIndex(): number {
 export function clearNavidromePlaylist(): void {
   navidromeVideoItems = [];
   navidromeCurrentPlayIndex = 0;
+  playedFilePaths.clear();
+  navidromeTotalCount = 0;
+}
+
+// ============ 渐进式随机播放支持 ============
+
+/**
+ * 追加歌曲到播放列表(不替换现有列表,用于扩展播放库)
+ */
+export function appendToNavidromePlaylist(items: VideoItem[]): void {
+  const existingPaths = new Set(navidromeVideoItems.map(v => v.filePath));
+  const newItems = items.filter(item => !existingPaths.has(item.filePath));
+  if (newItems.length > 0) {
+    navidromeVideoItems = [...navidromeVideoItems, ...newItems];
+  }
+}
+
+/**
+ * 标记歌曲已播放
+ */
+export function markAsPlayed(filePath: string): void {
+  playedFilePaths.add(filePath);
+}
+
+/**
+ * 检查歌曲是否已播放
+ */
+export function isPlayed(filePath: string): boolean {
+  return playedFilePaths.has(filePath);
+}
+
+/**
+ * 获取未播放歌曲数量
+ */
+export function getUnplayedCount(): number {
+  return navidromeVideoItems.filter(v => !playedFilePaths.has(v.filePath)).length;
+}
+
+/**
+ * 获取未播放的歌曲列表
+ */
+export function getUnplayedSongs(): VideoItem[] {
+  return navidromeVideoItems.filter(v => !playedFilePaths.has(v.filePath));
+}
+
+/**
+ * 清除已播放记录(重新开始随机)
+ */
+export function clearPlayedHistory(): void {
+  playedFilePaths.clear();
+}
+
+/**
+ * 获取已播放数量
+ */
+export function getPlayedCount(): number {
+  return playedFilePaths.size;
+}
+
+// ============ 服务端总数支持 ============
+
+/**
+ * 设置服务端返回的歌曲总数
+ */
+export function setNavidromeTotalCount(count: number): void {
+  navidromeTotalCount = count;
+}
+
+/**
+ * 获取服务端返回的歌曲总数
+ * 如果未设置，返回已加载的歌曲数量
+ */
+export function getNavidromeTotalCount(): number {
+  return navidromeTotalCount > 0 ? navidromeTotalCount : navidromeVideoItems.length;
 }

entry/src/main/ets/common/util/NavidromeRandomLoader.ets

@@ -0,0 +1,118 @@
+/**
+ * NavidromeRandomLoader.ets
+ * 用于渐进式随机播放时加载更多页数据的工具
+ */
+import { VideoItem } from '../../viewmodel/VideoItem';
+import { appendToNavidromePlaylist } from './NavidromePlaylistStore';
+import Logger from './Logger';
+
+const TAG = 'NavidromeRandomLoader';
+
+// 加载状态
+let isLoadingMore: boolean = false;
+
+// 加载回调函数类型定义
+type LoadMoreCallback = () => Promise<VideoItem[]>;
+
+// 加载更多页的回调(由RemoteMusicPage注册)
+let loadMoreCallback: LoadMoreCallback | null = null;
+
+// 检查是否还有更多数据可加载
+let hasMoreDataCallback: (() => boolean) | null = null;
+
+/**
+ * 注册加载更多页的回调函数(由RemoteMusicPage在aboutToAppear中调用)
+ * @param callback 加载一页数据并返回新增歌曲的函数
+ * @param hasMoreChecker 检查是否还有更多数据的函数
+ */
+export function registerLoadMoreCallback(
+  callback: LoadMoreCallback,
+  hasMoreChecker: () => boolean
+): void {
+  loadMoreCallback = callback;
+  hasMoreDataCallback = hasMoreChecker;
+  Logger.info(TAG, '加载回调已注册');
+}
+
+/**
+ * 注销加载回调(由RemoteMusicPage在aboutToDisappear中调用)
+ */
+export function unregisterLoadMoreCallback(): void {
+  loadMoreCallback = null;
+  hasMoreDataCallback = null;
+  Logger.info(TAG, '加载回调已注销');
+}
+
+/**
+ * 检查是否正在加载
+ */
+export function isLoading(): boolean {
+  return isLoadingMore;
+}
+
+/**
+ * 检查是否还有更多数据可加载
+ */
+export function hasMoreData(): boolean {
+  return hasMoreDataCallback ? hasMoreDataCallback() : false;
+}
+
+/**
+ * 触发加载更多页数据(由LocalMusic.randomPlay调用)
+ * @param pageCount 要加载的页数,默认3页
+ * @returns 是否成功加载(false表示正在加载中或无回调或无更多数据)
+ */
+export async function triggerLoadMoreSongs(pageCount: number = 3): Promise<boolean> {
+  if (isLoadingMore) {
+    Logger.warn(TAG, '正在加载中,跳过本次请求');
+    return false;
+  }
+  
+  if (!loadMoreCallback) {
+    Logger.warn(TAG, '加载回调未注册,无法加载更多');
+    return false;
+  }
+  
+  if (hasMoreDataCallback && !hasMoreDataCallback()) {
+    Logger.info(TAG, '没有更多数据可加载');
+    return false;
+  }
+  
+  isLoadingMore = true;
+  Logger.info(TAG, `开始加载${pageCount}页数据`);
+  
+  try {
+    let totalLoaded = 0;
+    
+    for (let i = 0; i < pageCount; i++) {
+      // 检查是否还有更多数据
+      if (hasMoreDataCallback && !hasMoreDataCallback()) {
+        Logger.info(TAG, `第${i + 1}页: 没有更多数据,停止加载`);
+        break;
+      }
+      
+      // 加载一页数据
+      const newItems = await loadMoreCallback();
+      
+      if (newItems.length === 0) {
+        Logger.info(TAG, `第${i + 1}页: 返回空数据,停止加载`);
+        break;
+      }
+      
+      // 追加到播放列表
+      appendToNavidromePlaylist(newItems);
+      totalLoaded += newItems.length;
+      
+      Logger.info(TAG, `第${i + 1}页: 加载${newItems.length}首,累计${totalLoaded}首`);
+    }
+    
+    Logger.info(TAG, `加载完成,共加载${totalLoaded}首新歌曲`);
+    return totalLoaded > 0;
+    
+  } catch (error) {
+    Logger.error(TAG, `加载失败: ${(error as Error).message}`);
+    return false;
+  } finally {
+    isLoadingMore = false;
+  }
+}

entry/src/main/ets/pages/NewIndex.ets

@@ -54,7 +54,7 @@ import { getCloudDiskIcon, RemoteDriveAccountDialog } from '../dialog/RemoteDriv
 import ReqPermissionUtil from '../common/util/ReqPermissionUtil';
 import { getRemoteDriveAccountLabel, getRemoteDriveDisplayLabel, getRemoteDriveProtocolLabel } from '../common/util/RemoteDriveLabel';
 import { RemoteDriveType } from '../common/enums/RemoteDriveType';
-import { NavidromePage } from '../view/NavidromePage';
+import { RemoteMusicPage } from '../view/RemoteMusicPage';
 import { ServerLogUtil } from '../common/util/ServerLogUtil';
 import { PlayStatus } from '../common/PlayStatus';
 
@@ -198,8 +198,8 @@ struct NewIndex {
       const eventData: emitter.EventData = {};
       emitter.emit({ eventId: EventConstants.EVENT_SWIPE_BACK_UPDATE }, eventData); // 发送音频广播通知更新doSwipBack
     } else if(this.mType === 7&&this.isDetailView) {
-      // NavidromePage/Jellyfin/Emby 页面，发送手势返回事件
-      console.info('onecold NavidromePage 返回键处理：发送手势返回事件');
+      // RemoteMusicPage(流媒体) 页面，发送手势返回事件
+      console.info('onecold RemoteMusicPage 返回键处理：发送手势返回事件');
       const eventData: emitter.EventData = {};
       emitter.emit({ eventId: EventConstants.EVENT_SWIPE_BACK_NAVID}, eventData);
     } else if(this.mType === 6) {
@@ -456,7 +456,7 @@ struct NewIndex {
       }
 
       if(this.mType === 7){
-        NavidromePage({
+        RemoteMusicPage({
           offsetX:this.offsetX,
           isDetailView:this.isDetailView,
           isShowDrawer:this.isShowDrawer,

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

@@ -3,7 +3,18 @@ import { curves, display, MenuModifier,PiPWindow, promptAction, router, SymbolGl
 import { VideoItem } from '../viewmodel/VideoItem';
 import {  LengthMetrics, SegmentButton,SegmentButtonOptions } from '@kit.ArkUI';
 import { getWebdavVideoItems, getWebdavCurrentPlayIndex } from '../pages/WebDavMainPage';
-import { getNavidromeVideoItems, getNavidromeCurrentPlayIndex } from '../common/util/NavidromePlaylistStore';
+import {
+  getNavidromeVideoItems,
+  getNavidromeCurrentPlayIndex,
+  getUnplayedSongs,
+  getUnplayedCount,
+  markAsPlayed,
+  clearPlayedHistory,
+  getPlayedCount,
+  getNavidromeTotalCount,
+  setNavidromeTotalCount
+} from '../common/util/NavidromePlaylistStore';
+import { triggerLoadMoreSongs, hasMoreData } from '../common/util/NavidromeRandomLoader';
 import {
   ImplOnBufferingUpdateListener,
   ImplOnCompletionListener,
@@ -117,7 +128,8 @@ import {
   isPlexType,
   isRemoteCloudType,
   WorkerEditMusicResult,
-  WebDavMetadataUpdatePayload
+  WebDavMetadataUpdatePayload,
+  isDaoLiYuType
 } from '../common/util/RemotePlayerUtil';
 
 import { HSBColorPicker, HSBColorPickerLayout } from '@keke/color-picker'
@@ -900,6 +912,7 @@ export struct LocalMusic {
           playlistData.songFilePaths,
           playlistData.startIndex,
           playlistData.isJump,
+          playlistData.songCount
         )
         return
       }
@@ -2178,11 +2191,28 @@ export struct LocalMusic {
       return this.favList.length;
     }
     if (this.playQueueScope === 'playlist') {
+      // 检测是否是流媒体播放(Navidrome/Jellyfin/Emby/AudioStation/Plex/道理鱼等)
+      // 如果是，优先返回服务端总数
+      const navidromeTotalCount = getNavidromeTotalCount();
+      Logger.info('heanup getPlayListDisplayCount', `playQueueScope=playlist, navidromeTotalCount=${navidromeTotalCount}, currentSong=${this.currentSong?.name}, type=${this.currentSong?.type}`);
+      if (navidromeTotalCount > 0 && this.currentSong && (
+        isNavidromeType(this.currentSong.type) ||
+        isJellyfinType(this.currentSong.type) ||
+        isEmbyType(this.currentSong.type) ||
+        isAudioStationType(this.currentSong.type) ||
+        isPlexType(this.currentSong.type) ||
+        isDaoLiYuType(this.currentSong.type)
+      )) {
+        Logger.info('heanup getPlayListDisplayCount', `返回服务端总数: ${navidromeTotalCount}`);
+        return navidromeTotalCount;
+      }
+      Logger.info('heanup getPlayListDisplayCount', `返回 currentSongList.length: ${this.currentSongList.length}`);
       return this.currentSongList.length;
     }
     if (this.playQueueScope === 'view' && this.modeType === 1 && this.totalCount > 0) {
       return this.totalCount;
     }
+    Logger.info('heanup getPlayListDisplayCount', `返回 songList.length: ${this.songList.length}, playQueueScope=${this.playQueueScope}`);
     return this.songList.length;
   }
 
@@ -7046,8 +7076,10 @@ export struct LocalMusic {
           if (index !== undefined) {
             this.curIndex = index
           }
+          // 设置播放队列作用域为歌单
+          this.playQueueScope = 'playlist'
           // 确保播放列表是完整的歌单歌曲列表（已在finishLoadingPlaylist中设置）
-          Logger.info(`heanup 网络音频 isFromSonPlayList分支 - 当前播放列表长度: ${this.songList.length}, 当前索引: ${this.curIndex}`)
+          Logger.info(`heanup 网络音频 isFromSonPlayList分支 - 当前播放列表长度: ${this.songList.length}, 当前索引: ${this.curIndex}, playQueueScope=${this.playQueueScope}`)
         } else {
           // 从全局网络音频列表中查找
           let globalVideoList = this.videoLocalList.filter(video => isRemoteCloudType(video.type)) as VideoItem[];
@@ -7632,6 +7664,40 @@ export struct LocalMusic {
     }
   }
 
+  /**
+   * 加载更多流媒体歌曲(Navidrome/Jellyfin/Emby/AudioStation/Plex)
+   * 当播放列表弹窗滚动到底部时调用
+   */
+  private async loadMoreNavidromeSongs(): Promise<void> {
+    const beforeCount = this.songList.length;
+    const hasMore = hasMoreData();
+    Logger.info('heanup', `开始加载更多流媒体歌曲, 当前数量=${beforeCount}, hasMoreData=${hasMore}`);
+
+    if (!hasMore) {
+      Logger.info('heanup', '没有更多数据可加载(hasMoreData=false)');
+      return;
+    }
+
+    // 触发加载更多(会更新NavidromePlaylistStore中的数据)
+    const success = await triggerLoadMoreSongs(1);
+    Logger.info('heanup', `triggerLoadMoreSongs返回: ${success}`);
+
+    if (success) {
+      // 获取更新后的完整列表
+      const updatedList = getNavidromeVideoItems();
+      Logger.info('heanup', `更新后列表长度: ${updatedList.length}`);
+      if (updatedList.length > beforeCount) {
+        Logger.info('heanup', `流媒体歌曲加载成功: ${beforeCount} -> ${updatedList.length}`);
+        this.songList = updatedList;
+        this.sonDataSource.pushArrayData(this.songList);
+      } else {
+        Logger.info('heanup', '列表长度未增加');
+      }
+    } else {
+      Logger.info('heanup', '流媒体歌曲加载未返回新数据(triggerLoadMoreSongs=false)');
+    }
+  }
+
   /**
    * 重置分页状态并加载首页
    */
@@ -9375,7 +9441,20 @@ export struct LocalMusic {
     .onReachEnd(() => {
       if(this.modeType === 4 )
         return;
-      void this.tryLoadNextPageForPlayback();
+      // 检测是否是流媒体类型(Navidrome/Jellyfin/Emby/AudioStation/Plex)，如果是则调用网盘加载更多逻辑
+      const isStreamingSong = this.currentSong && (
+        isNavidromeType(this.currentSong.type) ||
+        isJellyfinType(this.currentSong.type) ||
+        isEmbyType(this.currentSong.type) ||
+        isAudioStationType(this.currentSong.type) ||
+        isPlexType(this.currentSong.type)
+      );
+      if (isStreamingSong && hasMoreData()) {
+        Logger.info('heanup', '播放列表滚动到底部，加载更多流媒体歌曲');
+        void this.loadMoreNavidromeSongs();
+      } else {
+        void this.tryLoadNextPageForPlayback();
+      }
     })
     // .transition(TransitionEffect.move(TransitionEdge.BOTTOM)
     //   .animation({ duration: 500, curve: Curve.Ease }))
@@ -15546,6 +15625,112 @@ export struct LocalMusic {
     // if (!this.debounce()) {
     //   return;
     // }
+
+    // 网盘模式: 渐进式扩展播放库的随机播放
+    // 通过检查当前歌曲类型判断是否为网盘音乐(而非modeType,因为不同网盘类型modeType不同)
+    const isCloudSong = this.currentSong && isRemoteCloudType(this.currentSong.type);
+    if (isCloudSong) {
+      // 阈值常量
+      const UNPLAYED_THRESHOLD = 10; // 剩余未播放歌曲阈值
+      const LOAD_MORE_PAGES = 3;     // 每次加载页数
+      
+      // 获取网盘播放列表
+      const navidromeList = getNavidromeVideoItems();
+      const webdavList = getWebdavVideoItems();
+      const isNavidrome = navidromeList.length > 0;
+      const remoteList = isNavidrome ? navidromeList : webdavList;
+      
+      if (remoteList.length > 0) {
+        // 将当前歌加入历史栈
+        if (this.currentSong) {
+          this.randomPlayHistory.unshift(this.currentSong);
+          if (this.randomPlayHistory.length > 50) {
+            this.randomPlayHistory = this.randomPlayHistory.slice(0, 50);
+          }
+          // 标记当前歌曲为已播放
+          markAsPlayed(this.currentSong.filePath);
+          Logger.info(TAG, `randomPlay(网盘模式): 将当前歌加入历史栈, 栈大小: ${this.randomPlayHistory.length}`);
+        }
+
+        // 检查未播放歌曲数量(仅Navidrome支持渐进式加载)
+        let unplayedCount = isNavidrome ? getUnplayedCount() : remoteList.length;
+        const totalCount = remoteList.length;
+        const playedCount = isNavidrome ? getPlayedCount() : 0;
+        
+        Logger.info(TAG, `randomPlay(网盘模式): 总数${totalCount}, 已播放${playedCount}, 未播放${unplayedCount}`);
+        
+        // 如果未播放数量不足阈值,且还有更多数据,触发加载更多页
+        if (isNavidrome && unplayedCount < UNPLAYED_THRESHOLD && hasMoreData()) {
+          Logger.info(TAG, `randomPlay(网盘模式): 未播放(${unplayedCount})不足阈值(${UNPLAYED_THRESHOLD}),触发加载更多`);
+          const loadSuccess = await triggerLoadMoreSongs(LOAD_MORE_PAGES);
+          if (loadSuccess) {
+            // 重新获取未播放数量
+            unplayedCount = getUnplayedCount();
+            Logger.info(TAG, `randomPlay(网盘模式): 加载完成,未播放数量更新为${unplayedCount}`);
+          }
+        }
+
+        // 从未播放歌曲中随机选择
+        let candidates: VideoItem[];
+        if (isNavidrome) {
+          candidates = getUnplayedSongs();
+          // 如果全部播放完,重置已播放记录
+          if (candidates.length === 0) {
+            Logger.info(TAG, 'randomPlay(网盘模式): 全部播放完毕,重置已播放记录');
+            clearPlayedHistory();
+            // 排除当前歌曲
+            const currentFilePath = this.currentSong?.filePath;
+            candidates = currentFilePath 
+              ? getNavidromeVideoItems().filter(v => v.filePath !== currentFilePath)
+              : getNavidromeVideoItems();
+          }
+        } else {
+          // WebDAV模式:简单排除当前歌曲
+          const currentFilePath = this.currentSong?.filePath;
+          candidates = currentFilePath
+            ? remoteList.filter(v => v.filePath !== currentFilePath)
+            : remoteList;
+        }
+
+        if (candidates.length > 0) {
+          const randomIndex = Math.floor(Math.random() * candidates.length);
+          const randomSong = candidates[randomIndex];
+          
+          // 标记为已播放
+          if (isNavidrome) {
+            markAsPlayed(randomSong.filePath);
+          }
+          
+          Logger.info(TAG, `randomPlay(网盘模式): 从${candidates.length}首候选中随机选择: ${randomSong.name}`);
+
+          // 将选中的歌曲加入播放列表(如果不存在)
+          let nextIndex = this.songList.findIndex(song => song.filePath === randomSong.filePath);
+          if (nextIndex < 0) {
+            this.songList = [...this.songList, randomSong];
+            this.sonDataSource.pushArrayData(this.songList);
+            nextIndex = this.songList.length - 1;
+          }
+          this.curIndex = nextIndex;
+          this.playedIndices.add(this.curIndex);
+
+          this.CONTROL_PlayStatus = PlayStatus.INIT;
+          this.stop();
+          this.currentSong = randomSong;
+
+          // 设置videoUrl
+          this.videoUrl = await setVideoUrlForSong(this.currentSong, {
+            context: this.context,
+            autoParseMusicName: this.autoParseMusicName
+          });
+          this.name = this.currentSong.name;
+          this.artist = this.currentSong.artist;
+          this.changeImageAnimation();
+          return;
+        }
+        Logger.warn(TAG, 'randomPlay(网盘模式): 无可用候选歌曲,回退到默认随机逻辑');
+      }
+    }
+
     if (this.currentSong) {
       // 将当前歌加入到随机播放历史栈(在切换到新歌之前)
       this.randomPlayHistory.unshift(this.currentSong);
@@ -16352,9 +16537,10 @@ export struct LocalMusic {
    * 处理歌单播放请求
    */
   private async handlePlaylistPlayRequest(playlistId: string, playlistName:
-    string, songFilePaths: string[], startIndex: number,isJump: boolean) {
+    string, songFilePaths: string[], startIndex: number, isJump: boolean, songCount?: number) {
     try {
-      Logger.info(`heanup 处理歌单播放请求: ${playlistName}, 歌曲数量: ${songFilePaths.length}, 开始索引: ${startIndex}`)
+      const totalCount = songCount ?? songFilePaths.length;
+      Logger.info(`heanup 处理歌单播放请求: ${playlistName}, 已加载: ${songFilePaths.length}, 服务端总数: ${totalCount}, 开始索引: ${startIndex}`)
 
       // 检查是否为WebDAV播放请求
       if (playlistId === 'webdav-playlist') {
@@ -16373,7 +16559,7 @@ export struct LocalMusic {
           if(isJump){
             this.setShowPlayTrue()//显示播放页
           }
-          this.finishLoadingPlaylist(videoItems, currentPlayIndex, playlistName)
+          this.finishLoadingPlaylist(videoItems, currentPlayIndex, playlistName, totalCount)
           return
         } else {
           return
@@ -16384,12 +16570,12 @@ export struct LocalMusic {
         Logger.info(`heanup 检测到Navidrome播放请求，从内存读取videoItems`);
         const videoItems = getNavidromeVideoItems();
         const currentPlayIndex = getNavidromeCurrentPlayIndex();
-        Logger.info(`heanup Navidrome歌曲列表长度: ${videoItems.length}`);
+        Logger.info(`heanup Navidrome歌曲列表长度: ${videoItems.length}, 服务端总数: ${totalCount}`);
         if (videoItems && videoItems.length > 0) {
           if(isJump){
             this.setShowPlayTrue()//显示播放页
           }
-          this.finishLoadingPlaylist(videoItems, currentPlayIndex, playlistName);
+          this.finishLoadingPlaylist(videoItems, currentPlayIndex, playlistName, totalCount);
           return;
         } else {
           Logger.warn('heanup Navidrome播放请求缺少歌曲数据');
@@ -16470,13 +16656,14 @@ export struct LocalMusic {
   /**
    * 完成歌单加载并开始播放
    */
-  private finishLoadingPlaylist(songs: VideoItem[], startIndex: number, playlistName: string) {
+  private finishLoadingPlaylist(songs: VideoItem[], startIndex: number, playlistName: string, totalCount?: number) {
     if (songs.length === 0) {
       Logger.error('heanup 没有找到任何可播放的歌曲')
       ToastUtil.showToast('没有找到可播放的歌曲')
       return
     }
     this.songList = songs
+    this.currentSongList = songs  // 同步更新 currentSongList
 
     this.sonDataSource.pushArrayData(songs)
 
@@ -16486,7 +16673,23 @@ export struct LocalMusic {
 
     // 保存歌单的歌曲路径列表,用于随机播放
     this.currentPlaylistSongFilePaths = songs.map(song => song.filePath);
-    Logger.info('heanup finishLoadingPlaylist', `保存歌单歌曲路径列表,数量=${this.currentPlaylistSongFilePaths.length}`);
+    const actualTotal = totalCount ?? songs.length;
+    
+    // 如果是网盘播放，保存服务端总数到全局存储
+    if (totalCount && totalCount > 0 && songs.length > 0) {
+      const firstSong = songs[0];
+      if (firstSong && (isNavidromeType(firstSong.type) || 
+          isJellyfinType(firstSong.type) || 
+          isEmbyType(firstSong.type) || 
+          isAudioStationType(firstSong.type) ||
+          isPlexType(firstSong.type) ||
+          isDaoLiYuType(firstSong.type))) {
+        setNavidromeTotalCount(totalCount);
+        Logger.info('heanup finishLoadingPlaylist', `已保存服务端总数到全局存储: ${totalCount}`);
+      }
+    }
+    
+    Logger.info('heanup finishLoadingPlaylist', `保存歌单歌曲路径列表,已加载=${this.currentPlaylistSongFilePaths.length}, 服务端总数=${actualTotal}`);
 
     if (songs[startIndex]) {
       // 确保当前播放的歌曲也更新到存储

entry/src/main/ets/view/NavidromePage.ets → entry/src/main/ets/view/RemoteMusicPage.ets

@@ -18,7 +18,8 @@ import { Utility } from '../common/util/Utility';
 import { Constants } from '../Constants';
 import { EventConstants } from '../common/constants/EventConstants';
 import { emitter } from '@kit.BasicServicesKit';
-import { setNavidromePlaylist } from '../common/util/NavidromePlaylistStore';
+import { setNavidromePlaylist, appendToNavidromePlaylist, setNavidromeTotalCount } from '../common/util/NavidromePlaylistStore';
+import { registerLoadMoreCallback, unregisterLoadMoreCallback } from '../common/util/NavidromeRandomLoader';
 import { navidromeApi, NavidromeSong } from '../common/network/NavidromeApi';
 import { ServerLogUtil } from '../common/util/ServerLogUtil';
 import { RemoteDriveManager } from '../common/util/RemoteDriveManager';
@@ -108,7 +109,7 @@ interface AccountData {
 }
 
 @Component
-export struct NavidromePage {
+export struct RemoteMusicPage {
   @State isShowTitleBar: boolean = true //是否显示分类导航条
   private scroller: Scroller = new Scroller()
   private prevOffsetY: number = 0; // 记录上一次的Y轴偏移量
@@ -139,6 +140,7 @@ export struct NavidromePage {
   @State isArtistPageLoading: boolean = false;
   @State isAlbumPageLoading: boolean = false;
   @State isPlaylistPageLoading: boolean = false;
+  @State serverTotalSongCount: number = 0;  // 服务端返回的歌曲总数
 
   // 新增:详情视图状态
   @Link isDetailView: boolean; // 是否在艺术家/专辑详情视图
@@ -228,7 +230,7 @@ export struct NavidromePage {
       const examplePath = `${cacheRoot}/navidrome_preview.cache`;
       return { cacheRoot, examplePath };
     } catch (error) {
-      Logger.error('NavidromePage', `获取缓存预览路径失败: ${(error as Error).message}`);
+      Logger.error('RemoteMusicPage', `获取缓存预览路径失败: ${(error as Error).message}`);
       return null;
     }
   }
@@ -269,7 +271,7 @@ export struct NavidromePage {
     }
   }
 
-  //切换不同的NavidromePage
+  //切换不同的RemoteMusicPage
   async onSwitchAccount() {
     await this.refreshNavidromeData(true);
   }
@@ -296,7 +298,7 @@ export struct NavidromePage {
     // 监听手势返回事件
     let eventBackSwipeBack: emitter.InnerEvent = { eventId: EventConstants.EVENT_SWIPE_BACK_NAVID }
     emitter.on(eventBackSwipeBack, (eventData: emitter.EventData) => {
-      console.info('heanup', 'NavidromePage 收到 EVENT_SWIPE_BACK_NAVID 事件');
+      console.info('heanup', 'RemoteMusicPage 收到 EVENT_SWIPE_BACK_NAVID 事件');
       // 如果在详情视图模式,退出详情视图
       if (this.isDetailView) {
         this.getUIContext().animateTo({ duration: 555 }, () => {
@@ -306,9 +308,68 @@ export struct NavidromePage {
       }
     });
 
+    // 注册加载更多页回调(用于渐进式随机播放)
+    this.registerRandomLoadCallback();
+
     this.refreshNavidromeData();
   }
 
+  /**
+   * 注册加载更多页回调函数(供LocalMusic的randomPlay调用)
+   */
+  private registerRandomLoadCallback(): void {
+    registerLoadMoreCallback(
+      // 加载一页数据并返回新增歌曲
+      async (): Promise<VideoItem[]> => {
+        const account = this.resolveActiveAccount();
+        if (!account) {
+          return [];
+        }
+
+        // 记录加载前的数量
+        const beforeCount = this.allVideos.length;
+
+        // 根据账户类型调用对应的加载方法
+        await this.loadNextSongPageByAccountType(account);
+
+        // 获取新增的歌曲
+        const newItems = this.allVideos.slice(beforeCount);
+
+        // 同步到播放列表存储
+        if (newItems.length > 0) {
+          appendToNavidromePlaylist(newItems);
+          void ServerLogUtil.info('NavidromeRandom', `加载更多: 新增${newItems.length}首,总数${this.allVideos.length}`);
+        }
+
+        return newItems;
+      },
+      // 检查是否还有更多数据
+      (): boolean => {
+        return this.songNextStart !== null && !this.isSongPageLoading;
+      }
+    );
+  }
+
+  /**
+   * 根据账户类型调用对应的歌曲加载方法
+   */
+  private async loadNextSongPageByAccountType(account: WebDavAccount): Promise<void> {
+    if (this.isJellyfinAccount(account)) {
+      await this.loadNextJellyfinSongPage(account);
+    } else if (this.isEmbyAccount(account)) {
+      await this.loadNextEmbySongPage(account);
+    } else if (this.isAudioStationAccount(account)) {
+      await this.loadNextAudioStationSongPage(account);
+    } else if (this.isPlexAccount(account)) {
+      await this.loadNextPlexSongPage(account);
+    } else if (this.isDaoLiYuAccount(account)) {
+      await this.loadNextDaoLiYuSongPage(account);
+    } else {
+      // 默认使用 Navidrome
+      await this.loadNextSongPage(account);
+    }
+  }
+
   private async refreshNavidromeData(showToastWhenMissing: boolean = false): Promise<void> {
     const account = this.resolveActiveAccount();
     if (!account) {
@@ -367,6 +428,7 @@ export struct NavidromePage {
     this.isArtistPageLoading = false;
     this.isAlbumPageLoading = false;
     this.isPlaylistPageLoading = false;
+    this.serverTotalSongCount = 0;
   }
 
   private async loadMediaLibrary(account: WebDavAccount): Promise<void> {
@@ -808,12 +870,18 @@ export struct NavidromePage {
       return;
     }
     const currentTicket = ticket ?? this.loadTicket;
+    const isFirstPage = this.songNextStart === 0;
     this.isSongPageLoading = true;
     try {
       const response = await jellyfinApi.getSongsPage(account, this.songNextStart, this.REMOTE_PAGE_SIZE);
       if (currentTicket !== this.loadTicket) {
         return;
       }
+      // 首次加载时保存服务端总数
+      if (isFirstPage && response.total !== undefined && response.total > 0) {
+        this.serverTotalSongCount = response.total;
+        void ServerLogUtil.info('NavidromeLoad', `Jellyfin 服务端歌曲总数: ${this.serverTotalSongCount}`);
+      }
       const uniqueItems: JellyfinSong[] = [];
       for (let i = 0; i < response.items.length; i++) {
         const item = response.items[i];
@@ -835,7 +903,7 @@ export struct NavidromePage {
       }
       this.allVideos = this.dedupRemoteSongsByKey([...this.allVideos, ...videoItems]);
       this.songNextStart = response.nextStart;
-      void ServerLogUtil.info('NavidromeLoad', `Jellyfin 歌曲追加: 本次 ${videoItems.length} 首, 总数 ${this.allVideos.length}`);
+      void ServerLogUtil.info('NavidromeLoad', `Jellyfin 歌曲追加: 本次 ${videoItems.length} 首, 已加载 ${this.allVideos.length}, 服务端总数 ${this.serverTotalSongCount}`);
     } finally {
       this.isSongPageLoading = false;
     }
@@ -892,12 +960,18 @@ export struct NavidromePage {
       return;
     }
     const currentTicket = ticket ?? this.loadTicket;
+    const isFirstPage = this.songNextStart === 0;
     this.isSongPageLoading = true;
     try {
       const response = await embyApi.getSongsPage(account, this.songNextStart, this.REMOTE_PAGE_SIZE);
       if (currentTicket !== this.loadTicket) {
         return;
       }
+      // 首次加载时保存服务端总数
+      if (isFirstPage && response.total !== undefined && response.total > 0) {
+        this.serverTotalSongCount = response.total;
+        void ServerLogUtil.info('NavidromeLoad', `Emby 服务端歌曲总数: ${this.serverTotalSongCount}`);
+      }
       const uniqueItems: EmbySong[] = [];
       for (let i = 0; i < response.items.length; i++) {
         const item = response.items[i];
@@ -919,7 +993,7 @@ export struct NavidromePage {
       }
       this.allVideos = this.dedupRemoteSongsByKey([...this.allVideos, ...videoItems]);
       this.songNextStart = response.nextStart;
-      void ServerLogUtil.info('NavidromeLoad', `Emby 歌曲追加: 本次 ${videoItems.length} 首, 总数 ${this.allVideos.length}`);
+      void ServerLogUtil.info('NavidromeLoad', `Emby 歌曲追加: 本次 ${videoItems.length} 首, 已加载 ${this.allVideos.length}, 服务端总数 ${this.serverTotalSongCount}`);
     } finally {
       this.isSongPageLoading = false;
     }
@@ -976,12 +1050,18 @@ export struct NavidromePage {
       return;
     }
     const currentTicket = ticket ?? this.loadTicket;
+    const isFirstPage = this.songNextStart === 0;  // 在调用前保存是否为首页
     this.isSongPageLoading = true;
     try {
       const response = await audioStationApi.getSongsPage(account, this.songNextStart, this.REMOTE_PAGE_SIZE);
       if (currentTicket !== this.loadTicket) {
         return;
       }
+      // 首次加载时保存服务端总数
+      if (isFirstPage && response.total !== undefined && response.total > 0) {
+        this.serverTotalSongCount = response.total;
+        void ServerLogUtil.info('NavidromeLoad', `AudioStation 服务端歌曲总数: ${this.serverTotalSongCount}`);
+      }
       const restSongs = this.convertAudioStationSongsToRestSongs(response.items);
       const videoItems = await this.convertSongsToVideoItems(restSongs, account);
       if (currentTicket !== this.loadTicket) {
@@ -989,7 +1069,7 @@ export struct NavidromePage {
       }
       this.allVideos = this.dedupRemoteSongsByKey([...this.allVideos, ...videoItems]);
       this.songNextStart = response.nextStart;
-      void ServerLogUtil.info('NavidromeLoad', `AudioStation 歌曲追加: 本次 ${videoItems.length} 首, 总数 ${this.allVideos.length}`);
+      void ServerLogUtil.info('NavidromeLoad', `AudioStation 歌曲追加: 本次 ${videoItems.length} 首, 已加载 ${this.allVideos.length}, 服务端总数 ${this.serverTotalSongCount}`);
     } finally {
       this.isSongPageLoading = false;
     }
@@ -1069,12 +1149,18 @@ export struct NavidromePage {
       return;
     }
     const currentTicket = ticket ?? this.loadTicket;
+    const isFirstPage = this.songNextStart === 0;
     this.isSongPageLoading = true;
     try {
       const response = await plexApi.getSongsPage(account, this.songNextStart, this.REMOTE_PAGE_SIZE);
       if (currentTicket !== this.loadTicket) {
         return;
       }
+      // 首次加载时保存服务端总数
+      if (isFirstPage && response.total !== undefined && response.total > 0) {
+        this.serverTotalSongCount = response.total;
+        void ServerLogUtil.info('NavidromeLoad', `Plex 服务端歌曲总数: ${this.serverTotalSongCount}`);
+      }
       const restSongs = this.convertPlexSongsToRestSongs(response.items);
       const videoItems = await this.convertSongsToVideoItems(restSongs, account);
       if (currentTicket !== this.loadTicket) {
@@ -1082,7 +1168,7 @@ export struct NavidromePage {
       }
       this.allVideos = this.dedupRemoteSongsByKey([...this.allVideos, ...videoItems]);
       this.songNextStart = response.nextStart;
-      void ServerLogUtil.info('NavidromeLoad', `Plex 歌曲追加: 本次 ${videoItems.length} 首, 总数 ${this.allVideos.length}`);
+      void ServerLogUtil.info('NavidromeLoad', `Plex 歌曲追加: 本次 ${videoItems.length} 首, 已加载 ${this.allVideos.length}, 服务端总数 ${this.serverTotalSongCount}`);
     } finally {
       this.isSongPageLoading = false;
     }
@@ -1162,12 +1248,18 @@ export struct NavidromePage {
       return;
     }
     const currentTicket = ticket ?? this.loadTicket;
+    const isFirstPage = this.songNextStart === 0;
     this.isSongPageLoading = true;
     try {
       const response = await daoLiYuApi.getTracksPage(account, this.songNextStart, this.REMOTE_PAGE_SIZE);
       if (currentTicket !== this.loadTicket) {
         return;
       }
+      // 首次加载时保存服务端总数
+      if (isFirstPage && response.total !== undefined && response.total > 0) {
+        this.serverTotalSongCount = response.total;
+        void ServerLogUtil.info('NavidromeLoad', `道理鱼 服务端歌曲总数: ${this.serverTotalSongCount}`);
+      }
       const restSongs = this.convertDaoLiYuSongsToRestSongs(response.items);
       const videoItems = await this.convertSongsToVideoItems(restSongs, account);
       if (currentTicket !== this.loadTicket) {
@@ -1175,7 +1267,7 @@ export struct NavidromePage {
       }
       this.allVideos = [...this.allVideos, ...videoItems];
       this.songNextStart = response.nextStart;
-      void ServerLogUtil.info('NavidromeLoad', `道理鱼 歌曲追加: 本次 ${videoItems.length} 首, 总数 ${this.allVideos.length}`);
+      void ServerLogUtil.info('NavidromeLoad', `道理鱼 歌曲追加: 本次 ${videoItems.length} 首, 已加载 ${this.allVideos.length}, 服务端总数 ${this.serverTotalSongCount}`);
     } finally {
       this.isSongPageLoading = false;
     }
@@ -1401,11 +1493,11 @@ export struct NavidromePage {
     let generatedCoverCount = 0;
     let failedCoverCount = 0;
 
-    void ServerLogUtil.info('NavidromePageCover', `📀 开始处理 ${albums.length} 张专辑的封面 - 账号: ${ServerLogUtil.sanitizeAccount(account)}`);
+    void ServerLogUtil.info('RemoteMusicPageCover', `📀 开始处理 ${albums.length} 张专辑的封面 - 账号: ${ServerLogUtil.sanitizeAccount(account)}`);
 
     for (let i = 0; i < albums.length; i++) {
       const album = albums[i];
-      void ServerLogUtil.debug('NavidromePageCover', `处理专辑 [${i + 1}/${albums.length}] - id: ${album.id}, name: ${album.name}`);
+      void ServerLogUtil.debug('RemoteMusicPageCover', `处理专辑 [${i + 1}/${albums.length}] - id: ${album.id}, name: ${album.name}`);
 
       tasks.push((async () => {
         try {
@@ -1415,33 +1507,33 @@ export struct NavidromePage {
           // if (directUrl) {
           //   map.set(album.id, directUrl);
           //   directCoverCount++;
-          //   void ServerLogUtil.info('NavidromePageCover', `✅ 专辑使用直接封面 - name: ${album.name}, url: ${directUrl}`);
+          //   void ServerLogUtil.info('RemoteMusicPageCover', `✅ 专辑使用直接封面 - name: ${album.name}, url: ${directUrl}`);
           //   return;
           // }
 
           // 生成封面URL
           const coverId = album.coverArt ?? album.coverArtId ?? (album.id ? `al-${album.id}` : undefined);
-          void ServerLogUtil.debug('NavidromePageCover', `专辑封面ID - name: ${album.name}, coverArt: ${album.coverArt}, coverArtId: ${album.coverArtId}, 最终coverId: ${coverId}`);
+          void ServerLogUtil.debug('RemoteMusicPageCover', `专辑封面ID - name: ${album.name}, coverArt: ${album.coverArt}, coverArtId: ${album.coverArtId}, 最终coverId: ${coverId}`);
 
           const url = await this.buildCoverUrl(account, coverId);
           if (url) {
             map.set(album.id, url);
             generatedCoverCount++;
-            void ServerLogUtil.info('NavidromePageCover', `✅ 专辑生成封面成功 - name: ${album.name}, coverId: ${coverId}, url: ${url}`);
+            void ServerLogUtil.info('RemoteMusicPageCover', `✅ 专辑生成封面成功 - name: ${album.name}, coverId: ${coverId}, url: ${url}`);
           } else {
             failedCoverCount++;
-            void ServerLogUtil.error('NavidromePageCover', `❌ 专辑封面失败 - name: ${album.name}, coverId: ${coverId}, 原始数据: ${JSON.stringify({coverArt: album.coverArt, coverArtId: album.coverArtId, id: album.id})}`);
+            void ServerLogUtil.error('RemoteMusicPageCover', `❌ 专辑封面失败 - name: ${album.name}, coverId: ${coverId}, 原始数据: ${JSON.stringify({coverArt: album.coverArt, coverArtId: album.coverArtId, id: album.id})}`);
           }
         } catch (error) {
           failedCoverCount++;
-          void ServerLogUtil.error('NavidromePageCover', `❌ 专辑封面解析异常 - name: ${album.name}, error: ${(error as Error).message}`);
+          void ServerLogUtil.error('RemoteMusicPageCover', `❌ 专辑封面解析异常 - name: ${album.name}, error: ${(error as Error).message}`);
         }
       })());
     }
 
     await Promise.all(tasks);
 
-    void ServerLogUtil.info('NavidromePageCover', `📊 专辑封面处理完成 - 总数: ${albums.length}, 直接嵌入: ${directCoverCount}, 生成URL: ${generatedCoverCount}, 失败: ${failedCoverCount}`);
+    void ServerLogUtil.info('RemoteMusicPageCover', `📊 专辑封面处理完成 - 总数: ${albums.length}, 直接嵌入: ${directCoverCount}, 生成URL: ${generatedCoverCount}, 失败: ${failedCoverCount}`);
     return map;
   }
 
@@ -1452,11 +1544,11 @@ export struct NavidromePage {
     let generatedCoverCount = 0;
     let failedCoverCount = 0;
 
-    void ServerLogUtil.info('NavidromePageCover', `🎤 开始处理 ${artists.length} 位艺术家的封面 - 账号: ${ServerLogUtil.sanitizeAccount(account)}`);
+    void ServerLogUtil.info('RemoteMusicPageCover', `🎤 开始处理 ${artists.length} 位艺术家的封面 - 账号: ${ServerLogUtil.sanitizeAccount(account)}`);
 
     for (let i = 0; i < artists.length; i++) {
       const artist = artists[i];
-      void ServerLogUtil.debug('NavidromePageCover', `处理艺术家 [${i + 1}/${artists.length}] - id: ${artist.id}, name: ${artist.name}`);
+      void ServerLogUtil.debug('RemoteMusicPageCover', `处理艺术家 [${i + 1}/${artists.length}] - id: ${artist.id}, name: ${artist.name}`);
 
       tasks.push((async () => {
         try {
@@ -1465,33 +1557,33 @@ export struct NavidromePage {
           if (directUrl) {
             map.set(artist.id, directUrl);
             directCoverCount++;
-            void ServerLogUtil.info('NavidromePageCover', `✅ 艺术家使用已有图片 - name: ${artist.name}, url: ${directUrl}`);
+            void ServerLogUtil.info('RemoteMusicPageCover', `✅ 艺术家使用已有图片 - name: ${artist.name}, url: ${directUrl}`);
             return;
           }
 
           // 生成封面URL
           const coverId = artist.coverArt ?? artist.coverArtId ?? (artist.id ? `ar-${artist.id}` : undefined);
-          void ServerLogUtil.debug('NavidromePageCover', `艺术家封面ID - name: ${artist.name}, coverArt: ${artist.coverArt}, coverArtId: ${artist.coverArtId}, 最终coverId: ${coverId}`);
+          void ServerLogUtil.debug('RemoteMusicPageCover', `艺术家封面ID - name: ${artist.name}, coverArt: ${artist.coverArt}, coverArtId: ${artist.coverArtId}, 最终coverId: ${coverId}`);
 
           const url = await this.buildCoverUrl(account, coverId, 256);
           if (url) {
             map.set(artist.id, url);
             generatedCoverCount++;
-            void ServerLogUtil.info('NavidromePageCover', `✅ 艺术家生成封面成功 - name: ${artist.name}, coverId: ${coverId}, url: ${url}`);
+            void ServerLogUtil.info('RemoteMusicPageCover', `✅ 艺术家生成封面成功 - name: ${artist.name}, coverId: ${coverId}, url: ${url}`);
           } else {
             failedCoverCount++;
-            void ServerLogUtil.error('NavidromePageCover', `❌ 艺术家封面失败 - name: ${artist.name}, coverId: ${coverId}, 原始数据: ${JSON.stringify({coverArt: artist.coverArt, coverArtId: artist.coverArtId, id: artist.id})}`);
+            void ServerLogUtil.error('RemoteMusicPageCover', `❌ 艺术家封面失败 - name: ${artist.name}, coverId: ${coverId}, 原始数据: ${JSON.stringify({coverArt: artist.coverArt, coverArtId: artist.coverArtId, id: artist.id})}`);
           }
         } catch (error) {
           failedCoverCount++;
-          void ServerLogUtil.error('NavidromePageCover', `❌ 艺术家封面解析异常 - name: ${artist.name}, error: ${(error as Error).message}`);
+          void ServerLogUtil.error('RemoteMusicPageCover', `❌ 艺术家封面解析异常 - name: ${artist.name}, error: ${(error as Error).message}`);
         }
       })());
     }
 
     await Promise.all(tasks);
 
-    void ServerLogUtil.info('NavidromePageCover', `📊 艺术家封面处理完成 - 总数: ${artists.length}, 直接链接: ${directCoverCount}, 生成URL: ${generatedCoverCount}, 失败: ${failedCoverCount}`);
+    void ServerLogUtil.info('RemoteMusicPageCover', `📊 艺术家封面处理完成 - 总数: ${artists.length}, 直接链接: ${directCoverCount}, 生成URL: ${generatedCoverCount}, 失败: ${failedCoverCount}`);
     return map;
   }
 
@@ -2042,39 +2134,39 @@ export struct NavidromePage {
   }
 
   private async resolveSongCover(song: NavidromeRestSong, account: WebDavAccount): Promise<string | undefined> {
-    void ServerLogUtil.debug('NavidromePageCover', `🎵 解析歌曲封面 - title: ${song.title}, albumId: ${song.albumId}, id: ${song.id}`);
+    void ServerLogUtil.debug('RemoteMusicPageCover', `🎵 解析歌曲封面 - title: ${song.title}, albumId: ${song.albumId}, id: ${song.id}`);
 
     // 注释掉这个代码可以解决NavidRome部分账号没有封面问题
     // if (this.isNavidromeAccount(account) && song.albumId) {
     //   const albumCover = song.albumId ? this.albumCoverLookup.get(song.albumId) : undefined;
     //   if (albumCover) {
-    //     void ServerLogUtil.debug('NavidromePageCover', `✅ 歌曲使用专辑封面缓存 - title: ${song.title}, albumCover: ${albumCover}`);
+    //     void ServerLogUtil.debug('RemoteMusicPageCover', `✅ 歌曲使用专辑封面缓存 - title: ${song.title}, albumCover: ${albumCover}`);
     //     return albumCover;
     //   }
     // }
 
     if (!this.isNavidromeAccount(account)) {
       const fallbackId = song.coverArtId ?? song.albumId ?? song.id;
-      void ServerLogUtil.debug('NavidromePageCover', `歌曲使用非Navidrome账号封面 - title: ${song.title}, fallbackId: ${fallbackId}`);
+      void ServerLogUtil.debug('RemoteMusicPageCover', `歌曲使用非Navidrome账号封面 - title: ${song.title}, fallbackId: ${fallbackId}`);
       return this.buildCoverUrl(account, fallbackId);
     }
 
     const directUrl = this.resolveEmbedCover(account, song.embedArtPath ?? song.coverArtPath);
     if (directUrl) {
-      void ServerLogUtil.info('NavidromePageCover', `✅ 歌曲使用直接封面 - title: ${song.title}, url: ${directUrl}`);
+      void ServerLogUtil.info('RemoteMusicPageCover', `✅ 歌曲使用直接封面 - title: ${song.title}, url: ${directUrl}`);
       return directUrl;
     }
 
     const coverId = song.coverArt ?? song.coverArtId ?? song.id;
-    void ServerLogUtil.debug('NavidromePageCover', `歌曲生成封面URL - title: ${song.title}, coverArt: ${song.coverArt}, coverArtId: ${song.coverArtId}, 最终coverId: ${coverId}`);
+    void ServerLogUtil.debug('RemoteMusicPageCover', `歌曲生成封面URL - title: ${song.title}, coverArt: ${song.coverArt}, coverArtId: ${song.coverArtId}, 最终coverId: ${coverId}`);
     return this.buildCoverUrl(account, coverId);
   }
 
   private async buildCoverUrl(account: WebDavAccount, coverId?: string, size: number = 300): Promise<string | undefined> {
-    void ServerLogUtil.info('NavidromePageCover', `开始构建封面URL - coverId: ${coverId}, size: ${size}, 账号: ${ServerLogUtil.sanitizeAccount(account)}`);
+    void ServerLogUtil.info('RemoteMusicPageCover', `开始构建封面URL - coverId: ${coverId}, size: ${size}, 账号: ${ServerLogUtil.sanitizeAccount(account)}`);
 
     if (!coverId || coverId.trim().length === 0) {
-      void ServerLogUtil.warn('NavidromePageCover', `封面ID为空，跳过构建 - coverId: "${coverId}"`);
+      void ServerLogUtil.warn('RemoteMusicPageCover', `封面ID为空，跳过构建 - coverId: "${coverId}"`);
       return undefined;
     }
 
@@ -2084,67 +2176,67 @@ export struct NavidromePage {
     if (this.isNavidromeAccount(account)) {
       const cached = this.coverUrlCache.get(cacheKey);
       if (cached) {
-        void ServerLogUtil.info('NavidromePageCover', `✅ 缓存命中 - coverId: ${coverId}, size: ${size}, url: ${cached}`);
+        void ServerLogUtil.info('RemoteMusicPageCover', `✅ 缓存命中 - coverId: ${coverId}, size: ${size}, url: ${cached}`);
         return cached;
       }
     }
 
-    void ServerLogUtil.info('NavidromePageCover', `⚡ 调用API生成封面URL - coverId: ${coverId}, size: ${size}`);
+    void ServerLogUtil.info('RemoteMusicPageCover', `⚡ 调用API生成封面URL - coverId: ${coverId}, size: ${size}`);
     let url: string | undefined = undefined;
 
     try {
       if (this.isNavidromeAccount(account)) {
-        void ServerLogUtil.debug('NavidromePageCover', `[开始] 调用 navidromeApi.buildCoverArtUrl - coverId: ${normalizedId}, size: ${size}`);
-        void ServerLogUtil.debug('NavidromePageCover', `[账号信息] host=${account.host}, port=${account.port}, enableHttps=${account.enableHttps}`);
-        void ServerLogUtil.debug('NavidromePageCover', `[账号信息] basePath=${account.navidromeBasePath}`);
+        void ServerLogUtil.debug('RemoteMusicPageCover', `[开始] 调用 navidromeApi.buildCoverArtUrl - coverId: ${normalizedId}, size: ${size}`);
+        void ServerLogUtil.debug('RemoteMusicPageCover', `[账号信息] host=${account.host}, port=${account.port}, enableHttps=${account.enableHttps}`);
+        void ServerLogUtil.debug('RemoteMusicPageCover', `[账号信息] basePath=${account.navidromeBasePath}`);
 
         url = await navidromeApi.buildCoverArtUrl(account, normalizedId, size);
 
-        void ServerLogUtil.debug('NavidromePageCover', `[完成] navidromeApi.buildCoverArtUrl 返回 - coverId: ${normalizedId}, 返回值: "${url}"`);
+        void ServerLogUtil.debug('RemoteMusicPageCover', `[完成] navidromeApi.buildCoverArtUrl 返回 - coverId: ${normalizedId}, 返回值: "${url}"`);
 
         if (url) {
-          void ServerLogUtil.info('NavidromePageCover', `✅ API返回URL成功 - coverId: ${coverId}, url: ${url}`);
+          void ServerLogUtil.info('RemoteMusicPageCover', `✅ API返回URL成功 - coverId: ${coverId}, url: ${url}`);
         } else {
-          void ServerLogUtil.warn('NavidromePageCover', `⚠️ API返回空值 - coverId: ${coverId}`);
+          void ServerLogUtil.warn('RemoteMusicPageCover', `⚠️ API返回空值 - coverId: ${coverId}`);
         }
       } else if (this.isJellyfinAccount(account)) {
-        void ServerLogUtil.debug('NavidromePageCover', `调用 jellyfinApi.buildPrimaryImageUrl - coverId: ${normalizedId}, size: ${size}`);
+        void ServerLogUtil.debug('RemoteMusicPageCover', `调用 jellyfinApi.buildPrimaryImageUrl - coverId: ${normalizedId}, size: ${size}`);
         url = await jellyfinApi.buildPrimaryImageUrl(account, normalizedId, size, size);
       } else if (this.isEmbyAccount(account)) {
-        void ServerLogUtil.debug('NavidromePageCover', `调用 embyApi.buildPrimaryImageUrl - coverId: ${normalizedId}, size: ${size}`);
+        void ServerLogUtil.debug('RemoteMusicPageCover', `调用 embyApi.buildPrimaryImageUrl - coverId: ${normalizedId}, size: ${size}`);
         url = await embyApi.buildPrimaryImageUrl(account, normalizedId, size, size);
       } else if (this.isAudioStationAccount(account)) {
         if (this.isAudioStationSongCoverId(normalizedId)) {
           const songId = this.stripAudioStationSongCoverId(normalizedId);
-          void ServerLogUtil.debug('NavidromePageCover', `调用 audioStationApi.buildSongCoverUrl - songId=${songId}`);
+          void ServerLogUtil.debug('RemoteMusicPageCover', `调用 audioStationApi.buildSongCoverUrl - songId=${songId}`);
           url = await audioStationApi.buildSongCoverUrl(account, songId);
         } else {
           const key = this.parseAudioStationAlbumKey(normalizedId);
-          void ServerLogUtil.debug('NavidromePageCover', `调用 audioStationApi.buildAlbumCoverUrl - album=${key.name}, artist=${key.artist}`);
+          void ServerLogUtil.debug('RemoteMusicPageCover', `调用 audioStationApi.buildAlbumCoverUrl - album=${key.name}, artist=${key.artist}`);
           url = await audioStationApi.buildAlbumCoverUrl(account, key.name, key.artist);
         }
       } else if (this.isPlexAccount(account)) {
-        void ServerLogUtil.debug('NavidromePageCover', `调用 plexApi.buildImageUrl - coverId: ${normalizedId}`);
+        void ServerLogUtil.debug('RemoteMusicPageCover', `调用 plexApi.buildImageUrl - coverId: ${normalizedId}`);
         url = plexApi.buildImageUrl(account, normalizedId);
       } else if (this.isDaoLiYuAccount(account)) {
-        void ServerLogUtil.debug('NavidromePageCover', `调用 daoLiYuApi.buildImageUrl - coverId: ${normalizedId}`);
+        void ServerLogUtil.debug('RemoteMusicPageCover', `调用 daoLiYuApi.buildImageUrl - coverId: ${normalizedId}`);
         url = daoLiYuApi.buildImageUrl(account, normalizedId);
       }
 
       if (url && this.isNavidromeAccount(account)) {
         this.coverUrlCache.set(cacheKey, url);
-        void ServerLogUtil.info('NavidromePageCover', `✅ 封面URL生成成功并已缓存 - coverId: ${coverId}, url: ${url}`);
-        void ServerLogUtil.debug('NavidromePageCover', `缓存键值 - cacheKey: ${cacheKey}`);
+        void ServerLogUtil.info('RemoteMusicPageCover', `✅ 封面URL生成成功并已缓存 - coverId: ${coverId}, url: ${url}`);
+        void ServerLogUtil.debug('RemoteMusicPageCover', `缓存键值 - cacheKey: ${cacheKey}`);
       } else if (!url) {
-        void ServerLogUtil.error('NavidromePageCover', `❌ 封面URL生成失败(返回空) - coverId: ${coverId}, size: ${size}`);
+        void ServerLogUtil.error('RemoteMusicPageCover', `❌ 封面URL生成失败(返回空) - coverId: ${coverId}, size: ${size}`);
       } else {
-        void ServerLogUtil.info('NavidromePageCover', `✅ 封面URL生成成功(非Navidrome账号) - coverId: ${coverId}, url: ${url}`);
+        void ServerLogUtil.info('RemoteMusicPageCover', `✅ 封面URL生成成功(非Navidrome账号) - coverId: ${coverId}, url: ${url}`);
       }
     } catch (error) {
       const err = error as Error;
-      void ServerLogUtil.error('NavidromePageCover', `❌ 封面URL生成异常 - coverId: ${coverId}, error: ${err.message}`);
-      void ServerLogUtil.error('NavidromePageCover', `错误类型: ${err.name || 'Unknown'}`);
-      void ServerLogUtil.error('NavidromePageCover', `错误堆栈: ${err.stack || '无'}`);
+      void ServerLogUtil.error('RemoteMusicPageCover', `❌ 封面URL生成异常 - coverId: ${coverId}, error: ${err.message}`);
+      void ServerLogUtil.error('RemoteMusicPageCover', `错误类型: ${err.name || 'Unknown'}`);
+      void ServerLogUtil.error('RemoteMusicPageCover', `错误堆栈: ${err.stack || '无'}`);
     }
 
     return url;
@@ -3224,28 +3316,32 @@ export struct NavidromePage {
       }
 
       // 记录播放详细信息
-      void ServerLogUtil.info('NavidromePlay', `开始播放歌曲: ${song.name} (#${index})`);
-      void ServerLogUtil.info('NavidromePlay', `歌曲信息:`);
-      void ServerLogUtil.info('NavidromePlay', `- ID: ${song.id}`);
-      void ServerLogUtil.info('NavidromePlay', `- 艺术家: ${song.artist || '未知'}`);
-      void ServerLogUtil.info('NavidromePlay', `- 专辑: ${song.album || '未知'}`);
-      void ServerLogUtil.info('NavidromePlay', `- 文件大小: ${song.size || '未知'}`);
-      void ServerLogUtil.info('NavidromePlay', `- 时长: ${song.duration || '未知'}`);
-      void ServerLogUtil.info('NavidromePlay', `- 封面: ${song.pixelMapPath ? '有' : '无'}`);
-      void ServerLogUtil.info('NavidromePlay', `- 播放路径: ${song.filePath}`);
+      void ServerLogUtil.info('StreamingPlay', `开始播放歌曲: ${song.name} (#${index})`);
+      void ServerLogUtil.info('StreamingPlay', `歌曲信息:`);
+      void ServerLogUtil.info('StreamingPlay', `- ID: ${song.id}`);
+      void ServerLogUtil.info('StreamingPlay', `- 艺术家: ${song.artist || '未知'}`);
+      void ServerLogUtil.info('StreamingPlay', `- 专辑: ${song.album || '未知'}`);
+      void ServerLogUtil.info('StreamingPlay', `- 文件大小: ${song.size || '未知'}`);
+      void ServerLogUtil.info('StreamingPlay', `- 时长: ${song.duration || '未知'}`);
+      void ServerLogUtil.info('StreamingPlay', `- 封面: ${song.pixelMapPath ? '有' : '无'}`);
+      void ServerLogUtil.info('StreamingPlay', `- 播放路径: ${song.filePath}`);
 
       const playlistSource = this.getVisibleSongs().length > 0 ? this.getVisibleSongs() : this.allVideos;
       const targetIndex = playlistSource.findIndex(item => item.id === song.id);
       const startIndex = targetIndex >= 0 ? targetIndex : Math.min(index, Math.max(playlistSource.length - 1, 0));
 
-      void ServerLogUtil.info('NavidromePlay', `播放列表设置: 起始索引 ${startIndex}, 总数 ${playlistSource.length}`);
+      void ServerLogUtil.info('StreamingPlay', `播放列表设置: 起始索引 ${startIndex}, 已加载 ${playlistSource.length}, 服务端总数 ${this.serverTotalSongCount}`);
 
       setNavidromePlaylist(playlistSource, startIndex);
+      // 保存服务端总数到全局存储
+      if (this.serverTotalSongCount > 0) {
+        setNavidromeTotalCount(this.serverTotalSongCount);
+      }
 
       const playlistData: PlaylistEventData = {
         playlistId: NAVIDROME_PLAYLIST_ID,
         playlistName: `${getRemoteDriveDisplayLabel(account.webType)} - ${account.name ?? '未知账户'}`,
-        songCount: playlistSource.length,
+        songCount: this.serverTotalSongCount > 0 ? this.serverTotalSongCount : playlistSource.length,
         startIndex,
         isJump: isJump,//设置true会弹出播放页
         songFilePaths: playlistSource.map(item => item.filePath)
@@ -3254,11 +3350,11 @@ export struct NavidromePage {
       const eventPlaylistPlay: emitter.InnerEvent = { eventId: EventConstants.EVENT_PLAYLIST_PLAY };
       emitter.emit(eventPlaylistPlay, { data: playlistData });
 
-      void ServerLogUtil.info('NavidromePlay', `播放事件已发送`);
-      void ServerLogUtil.debug('NavidromePlay', `播放事件详情: 列表ID=${playlistData.playlistId}, 列表名称=${playlistData.playlistName}, 歌曲数=${playlistData.songCount}, 起始索引=${playlistData.startIndex}, 是否跳转=${playlistData.isJump}`);
+      void ServerLogUtil.info('StreamingPlay', `播放事件已发送`);
+      void ServerLogUtil.debug('StreamingPlay', `播放事件详情: 列表ID=${playlistData.playlistId}, 列表名称=${playlistData.playlistName}, 歌曲数=${playlistData.songCount}, 起始索引=${playlistData.startIndex}, 是否跳转=${playlistData.isJump}`);
 
       if(!this.isNoJumpToHome){
-        void ServerLogUtil.debug('NavidromePlay', '跳转到首页播放器');
+        void ServerLogUtil.debug('StreamingPlay', '跳转到首页播放器');
         // 跳转到首页播放器
         this.getUIContext()?.animateTo({ duration: 555 }, () => {
           this.mType = 0
@@ -3267,8 +3363,8 @@ export struct NavidromePage {
 
     } catch (error) {
       const err = error as Error;
-      void ServerLogUtil.error('NavidromePlay', `播放失败: ${err.message}`);
-      void ServerLogUtil.error('NavidromePlay', `失败歌曲信息: ${song.name} (${song.id})`);
+      void ServerLogUtil.error('StreamingPlay', `播放失败: ${err.message}`);
+      void ServerLogUtil.error('StreamingPlay', `失败歌曲信息: ${song.name} (${song.id})`);
       ToastUtil.showToast('播放失败');
     }
   }

lib/Index.ets

@@ -8,7 +8,6 @@ export { LyricParser } from './src/main/ets/parse/LyricParser'
 
 export { FileParser } from './src/main/ets/parse/FileParser'
 
-export { LyricView } from './src/main/ets/view/LyricView'
 
 export { LyricView2 } from './src/main/ets/view/LyricView2'
 
@@ -16,4 +15,3 @@ export { LyricController } from './src/main/ets/LyricController'
 
 export { LyricHelper } from './src/main/ets/LyricHelper'
 
-export { CcLyricView } from './src/main/ets/view/CcLyricView'

lib/src/main/ets/bean/Lyric.ts

@@ -7,13 +7,15 @@ export class Lyric {
     readonly by: string
     readonly offset: number
     readonly lyricList: Array<LyricLine>
+    readonly isPlainText: boolean // 是否为纯文本歌词(无时间标签)
 
-    constructor(artist: string, title: string, album: string, by: string, offset: number, lyricList: Array<LyricLine>) {
+    constructor(artist: string, title: string, album: string, by: string, offset: number, lyricList: Array<LyricLine>, isPlainText: boolean = false) {
         this.artist = artist
         this.title = title
         this.album = album
         this.by = by
         this.offset = offset
         this.lyricList = lyricList
+        this.isPlainText = isPlainText
     }
 }

lib/src/main/ets/parse/FileParser.ets

@@ -1,6 +1,6 @@
-import { IParser, Lyric, LyricParser } from '@seagazer/cclyric';
+import { IParser, Lyric, LyricParser, LyricLine } from '@seagazer/cclyric';
 import fs from '@ohos.file.fs'
-import { printD } from '../extensions/Extension';
+import { printD, printW } from '../extensions/Extension';
 
 /**
  * Author: seagazer