From 624422f9847b9f651a09a6e8ecc9e68de61d63ac Mon Sep 17 00:00:00 2001
From: hflllll <violeteverdack@gmail.com>
Date: Fri, 26 Sep 2025 17:40:19 +0800
Subject: [PATCH] =?UTF-8?q?refactor(audio):=20=E4=BC=98=E5=8C=96=E9=9F=B3?=
 =?UTF-8?q?=E9=A2=91=E6=8E=A7=E5=88=B6=E7=BB=84=E4=BB=B6=E9=80=BB=E8=BE=91?=
 =?UTF-8?q?=E5=92=8C=E4=BC=9A=E5=91=98=E9=99=90=E5=88=B6=E5=A4=84=E7=90=86?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

重构音频控制组件，改进音色切换处理流程，增加会员限制检查，优化页面切换时的音频加载逻辑。移除未使用的授权功能，修复若干音频播放相关问题。

- 改进音色切换处理，增加请求取消和状态管理
- 添加会员限制检查，非会员无法播放会员专属内容
- 优化页面切换时的音频加载和缓存逻辑
- 移除未使用的授权功能和相关代码
- 修复音频播放中的高亮和进度显示问题
- 改进错误处理和重试机制
---
 subPages/home/AudioControls.vue | 894 +++++++++++++++++++++++++++++++++++-----
 subPages/home/book.vue          | 240 ++++++++---
 subPages/home/directory.vue     |  23 +-
 subPages/home/music.vue         |  13 +-
 subPages/home/submit.vue        |   7 +-
 subPages/user/cash.vue          |   2 +-
 subPages/user/promote.vue       |   2 +-
 utils/common.js                 |  48 ---
 utils/index.js                  |   2 -
 9 files changed, 985 insertions(+), 246 deletions(-)

diff --git a/subPages/home/AudioControls.vue b/subPages/home/AudioControls.vue
index 23e2079..616d14f 100644
--- a/subPages/home/AudioControls.vue
+++ b/subPages/home/AudioControls.vue
@@ -1,29 +1,18 @@
 <template>
   <view class="audio-controls-wrapper">
-    <!-- 获取音频按钮 -->
-    <view v-if="!hasAudioData && !isAudioLoading && isTextPage && !hasCurrentPageCache" class="audio-get-button-container">
-      <view class="get-audio-btn" @click="handleGetAudio">
-        <uv-icon name="play-circle" size="24" color="#06DADC"></uv-icon>
-        <text class="get-audio-text">获取第{{currentPage}}页音频</text>
-      </view>
-    </view>
-    
-    <!-- 音频已预加载提示 -->
-    <view v-else-if="!hasAudioData && !isAudioLoading && isTextPage && hasCurrentPageCache" class="audio-preloaded-container">
-      <view class="preloaded-tip">
-        <uv-icon name="checkmark-circle" size="24" color="#52c41a"></uv-icon>
-        <text class="preloaded-text">第{{currentPage}}页音频已预加载</text>
-      </view>
+    <!-- 会员限制页面不显示任何音频控制 -->
+    <view v-if="isAudioDisabled" class="member-restricted-container">
+      <!-- 不显示任何内容，完全隐藏音频功能 -->
     </view>
     
-    <!-- 音频加载状态 -->
-    <view v-else-if="isAudioLoading && isTextPage && !hasAudioData" class="audio-loading-container">
+    <!-- 音频加载中 -->
+    <view v-else-if="isTextPage && isAudioLoading" class="audio-loading-container">
       <uv-loading-icon mode="spinner" size="30" color="#06DADC"></uv-loading-icon>
-      <text class="loading-text">正在加载第{{currentPage}}页音频...</text>
+      <text class="loading-text">第{{currentPage}}页音频加载中，请稍等...</text>
     </view>
     
     <!-- 正常音频控制栏 -->
-    <view v-else-if="hasAudioData" class="audio-controls" :class="{ 'audio-hidden': !isTextPage }">
+    <view v-else-if="isTextPage && hasAudioData" class="audio-controls">
       <!-- 加载指示器 -->
       <view v-if="isAudioLoading" class="loading-indicator">
         <uv-loading-icon mode="spinner" size="16" color="#06DADC"></uv-loading-icon>
@@ -105,6 +94,18 @@ export default {
     isTextPage: {
       type: Boolean,
       default: false
+    },
+    isMember: {
+      type: Boolean,
+      default: false
+    },
+    currentPageRequiresMember: {
+      type: Boolean,
+      default: false
+    },
+    pagePay: {
+      type: Array,
+      default: () => []
     }
   },
   data() {
@@ -133,8 +134,20 @@ export default {
       // 音频加载状态
       isAudioLoading: false, // 音频是否正在加载
       hasAudioData: false, // 当前页面是否已有音频数据
+      isVoiceChanging: false, // 音色切换中的加载状态
+      audioLoadFailed: false, // 音频获取失败状态
       // 文本高亮相关
       currentHighlightIndex: -1, // 当前高亮的文本索引
+      // 课程切换相关状态
+      isJustSwitchedCourse: false, // 是否刚刚切换了课程
+      // 页面切换防抖相关
+      pageChangeTimer: null, // 页面切换防抖定时器
+      isPageChanging: false, // 是否正在切换页面
+      // 请求取消相关
+      currentRequestId: null, // 当前音频请求ID
+      shouldCancelRequest: false, // 是否应该取消当前请求
+      // 本地音色ID（避免直接修改prop）
+      localVoiceId: '', // 本地音色ID，从prop初始化
     }
   },
   computed: {
@@ -145,9 +158,50 @@ export default {
     
     // 检查当前页面是否有缓存的音频
     hasCurrentPageCache() {
-      const cacheKey = `${this.courseId}_${this.currentPage}`;
+      const cacheKey = `${this.courseId}_${this.currentPage}_${this.localVoiceId}`;
       const cachedData = this.audioCache[cacheKey];
-      return cachedData && cachedData.audios && cachedData.audios.length > 0;
+      
+      // 更严格的缓存有效性检查
+      if (!cachedData || !cachedData.audios || cachedData.audios.length === 0) {
+        return false;
+      }
+      
+      // 检查缓存的音色ID是否与当前音色匹配
+      if (cachedData.voiceId && cachedData.voiceId !== this.localVoiceId) {
+        console.warn('缓存音色不匹配:', cachedData.voiceId, '!=', this.localVoiceId);
+        return false;
+      }
+      
+      // 检查音频URL是否有效
+      const firstAudio = cachedData.audios[0];
+      if (!firstAudio || !firstAudio.url) {
+        console.warn('缓存音频数据无效');
+        return false;
+      }
+      
+      return true;
+    },
+    
+    // 判断音频功能是否应该被禁用（会员限制页面且用户非会员）
+    isAudioDisabled() {
+      return this.currentPageRequiresMember && !this.isMember;
+    },
+    
+    // 检查当前页面是否正在预加载中
+    isCurrentPagePreloading() {
+      // 如果全局预加载状态为true，需要检查当前页面是否在预加载队列中
+      if (this.isPreloading) {
+        // 检查当前页面是否有缓存（如果有缓存说明已经预加载完成）
+        const cacheKey = `${this.courseId}_${this.currentPage}_${this.localVoiceId}`;
+        const hasCache = this.audioCache[cacheKey] && this.audioCache[cacheKey].audios && this.audioCache[cacheKey].audios.length > 0;
+        
+        // 如果没有缓存且正在预加载，说明当前页面可能正在预加载中
+        if (!hasCache) {
+          console.log('当前页面可能正在预加载中，页面:', this.currentPage, '缓存状态:', hasCache);
+          return true;
+        }
+      }
+      return false;
     }
   },
   watch: {
@@ -155,22 +209,70 @@ export default {
     currentPage: {
       handler(newPage, oldPage) {
         if (newPage !== oldPage) {
+          console.log('页面切换:', oldPage, '->', newPage);
+          
+          // 设置页面切换状态
+          this.isPageChanging = true;
+          
+          // 立即重置音频状态，防止穿音
           this.resetAudioState();
+          
+          // 清除之前的防抖定时器
+          if (this.pageChangeTimer) {
+            clearTimeout(this.pageChangeTimer);
+          }
+          
+          // 使用防抖机制，避免频繁切换时重复加载
+          this.pageChangeTimer = setTimeout(() => {
+            this.isPageChanging = false;
+            
+            // 检查新页面是否有预加载完成的音频缓存
+            this.$nextTick(() => {
+              this.checkAndLoadPreloadedAudio();
+            });
+          }, 300); // 300ms防抖延迟
         }
       },
       immediate: false
     },
-    // 监听音色变化，清除缓存
+    // 监听音色变化，更新本地音色ID
     voiceId: {
       handler(newVoiceId, oldVoiceId) {
-        if (newVoiceId !== oldVoiceId && oldVoiceId) {
-          this.clearAudioCache();
-          this.resetAudioState();
+        if (newVoiceId !== oldVoiceId) {
+          console.log('🎵 音色ID变化:', oldVoiceId, '->', newVoiceId);
+          // 更新本地音色ID
+          this.localVoiceId = newVoiceId;
         }
-      }
+      },
+      immediate: true // 立即执行，用于初始化
     }
   },
   methods: {
+    // 检查并自动加载预加载完成的音频
+    checkAndLoadPreloadedAudio() {
+      // 只在文本页面检查
+      if (!this.isTextPage) {
+        return;
+      }
+      
+      // 检查当前页面是否有缓存的音频数据
+      const pageKey = `${this.courseId}_${this.currentPage}_${this.localVoiceId}`;
+      const cachedAudio = this.audioCache[pageKey];
+      
+      if (cachedAudio && cachedAudio.audios && cachedAudio.audios.length > 0) {
+        // 有缓存：直接显示控制栏
+        this.currentPageAudios = cachedAudio.audios;
+        this.totalTime = cachedAudio.totalDuration || 0;
+        this.hasAudioData = true;
+        this.isAudioLoading = false;
+        console.log('检测到缓存音频，显示控制栏');
+      } else {
+        // 没有缓存：自动开始加载音频
+        console.log('没有缓存音频，开始加载当前页面音频');
+        this.getCurrentPageAudio();
+      }
+    },
+    
     // 智能分割文本，按句号和逗号分割中英文文本
     splitTextIntelligently(text) {
       if (!text || typeof text !== 'string') {
@@ -179,7 +281,7 @@ export default {
       
       // 判断是否为中文文本（包含中文字符）
       const isChinese = /[\u4e00-\u9fa5]/.test(text);
-      const maxLength = isChinese ? 200 : 400;
+      const maxLength = isChinese ? 100 : 200;
       
       // 如果文本长度不超过限制，直接返回
       if (text.length <= maxLength) {
@@ -258,10 +360,17 @@ export default {
        const segments = this.splitTextIntelligently(text);
        const audioSegments = [];
        let totalDuration = 0;
+       const requestId = this.currentRequestId; // 保存当前请求ID
        
-       console.log(`开始分批次请求音频，共 ${segments.length} 段`);
+       console.log(`开始分批次请求音频，共 ${segments.length} 段，请求ID: ${requestId}`);
        
        for (let i = 0; i < segments.length; i++) {
+         // 检查是否应该取消请求
+         if (this.shouldCancelRequest || this.currentRequestId !== requestId) {
+           console.log(`请求已取消，停止音频加载，请求ID: ${requestId}`);
+           return null; // 返回null表示请求被取消
+         }
+         
          const segment = segments[i];
          
          try {
@@ -272,7 +381,7 @@ export default {
              voiceType: voiceType,
            });
            
-           if (radioRes.code === 200) {
+           if (radioRes.code === 200 && radioRes.result && radioRes.result.url) {
              const audioUrl = radioRes.result.url;
              const duration = radioRes.result.time || 0;
              
@@ -336,9 +445,48 @@ export default {
      },
      
      // 获取当前页面的音频内容
-    async getCurrentPageAudio() {
+    async getCurrentPageAudio(autoPlay = false) {
+      // 检查是否正在页面切换中，如果是则不加载音频
+      if (this.isPageChanging) {
+        console.log('页面切换中，跳过音频加载');
+        return;
+      }
+      
+      // 检查是否为卡片页面，如果是则不加载任何音频
+      if (!this.isTextPage) {
+        console.log('当前为卡片页面，不加载音频');
+        // 清空音频状态
+        this.currentPageAudios = [];
+        this.hasAudioData = false;
+        this.isAudioLoading = false;
+        this.audioLoadFailed = false;
+        this.currentAudioIndex = 0;
+        this.currentTime = 0;
+        this.totalTime = 0;
+        this.currentHighlightIndex = -1;
+        
+        // 通知父组件音频状态变化
+        this.$emit('audio-state-change', {
+          hasAudioData: false,
+          isLoading: false,
+          currentHighlightIndex: -1
+        });
+        return;
+      }
+      
+      // 检查会员限制
+      if (this.isAudioDisabled) {
+        return;
+      }
+      
+      // 检查是否已经在加载中，防止重复加载（音色切换时除外）
+      if (this.isAudioLoading && !this.isVoiceChanging) {
+        console.log('音频已在加载中，跳过重复加载');
+        return;
+      }
+      
       // 检查缓存中是否已有当前页面的音频数据
-      const cacheKey = `${this.courseId}_${this.currentPage}`;
+      const cacheKey = `${this.courseId}_${this.currentPage}_${this.localVoiceId}`;
       if (this.audioCache[cacheKey]) {
         console.log('从缓存加载音频数据:', cacheKey);
         // 从缓存加载音频数据
@@ -350,6 +498,11 @@ export default {
         this.hasAudioData = true;
         this.isAudioLoading = false;
         
+        // 如果是课程切换后的自动加载，清除切换标识
+        if (this.isJustSwitchedCourse) {
+          this.isJustSwitchedCourse = false;
+        }
+        
         // 通知父组件音频状态变化
         this.$emit('audio-state-change', {
           hasAudioData: this.hasAudioData,
@@ -363,6 +516,11 @@ export default {
       this.isAudioLoading = true;
       this.hasAudioData = false;
       
+      // 重置请求取消标识并生成新的请求ID
+      this.shouldCancelRequest = false;
+      this.currentRequestId = Date.now() + '_' + Math.random().toString(36).substr(2, 9);
+      console.log('开始新的音频请求，ID:', this.currentRequestId);
+      
       // 清空当前页面音频数组
       this.currentPageAudios = [];
       this.currentAudioIndex = 0;
@@ -377,9 +535,10 @@ export default {
         currentHighlightIndex: this.currentHighlightIndex
       });
       
-      // 对着当前页面的每一个[]元素进行切割 如果是文本text类型则进行音频请求
-      const currentPageData = this.bookPages[this.currentPage - 1];
-      if (currentPageData) {
+      try {
+        // 对着当前页面的每一个[]元素进行切割 如果是文本text类型则进行音频请求
+        const currentPageData = this.bookPages[this.currentPage - 1];
+        if (currentPageData) {
         // 收集所有text类型的元素
         const textItems = currentPageData.filter(item => item.type === 'text');
         
@@ -395,7 +554,14 @@ export default {
               console.log(`处理第 ${index + 1}/${textItems.length} 个文本项，长度: ${item.content.length}`);
               
               // 使用分批次请求音频
-              const batchResult = await this.requestAudioInBatches(item.content, this.voiceId);
+              console.log('🎵 请求音频 - 当前音色ID:', this.localVoiceId);
+          const batchResult = await this.requestAudioInBatches(item.content, this.localVoiceId);
+              
+              // 检查请求是否被取消
+              if (batchResult === null) {
+                console.log('音频请求被取消，停止处理');
+                return;
+              }
               
               if (batchResult.audioSegments.length > 0) {
                 // 同时保存到原始数据中以保持兼容性（使用第一段的URL）
@@ -441,12 +607,15 @@ export default {
                   console.log('创建第一个音频实例并开始播放');
                   this.createAudioInstance();
                   
-                  // 等待音频实例准备好后开始播放
+                  // 等待音频实例准备好后开始播放（仅在非音色切换时或明确要求自动播放时）
                   setTimeout(() => {
-                    if (this.currentAudio && !this.isPlaying) {
-                      this.currentAudio.play();
-                      // isPlaying状态会在onPlay事件中自动设置
-                      this.updateHighlightIndex();
+                    if (this.currentAudio && !this.isPlaying && (!this.isVoiceChanging || autoPlay)) {
+                      if (autoPlay || !this.isVoiceChanging) {
+                        console.log('自动播放第一个音频，autoPlay:', autoPlay);
+                        this.currentAudio.play();
+                        // isPlaying状态会在onPlay事件中自动设置
+                        this.updateHighlightIndex();
+                      }
                     }
                   }, 100);
                 }
@@ -467,10 +636,12 @@ export default {
             await this.calculateTotalDuration();
             
             // 将音频数据保存到缓存中
-            const cacheKey = `${this.courseId}_${this.currentPage}`;
+            const cacheKey = `${this.courseId}_${this.currentPage}_${this.localVoiceId}`;
             this.audioCache[cacheKey] = {
               audios: [...this.currentPageAudios], // 深拷贝音频数组
-              totalDuration: this.totalTime
+              totalDuration: this.totalTime,
+              voiceId: this.localVoiceId, // 保存音色ID用于验证
+              timestamp: Date.now() // 保存时间戳
             };
             console.log('音频数据已缓存:', cacheKey, this.audioCache[cacheKey]);
             
@@ -482,56 +653,183 @@ export default {
       
       // 结束加载状态
       this.isAudioLoading = false;
+      this.isVoiceChanging = false; // 清除音色切换加载状态
+      
+      // 如果是课程切换后的自动加载，清除切换标识
+      if (this.isJustSwitchedCourse) {
+        this.isJustSwitchedCourse = false;
+      }
       
-      // 设置音频数据状态
+      // 设置音频数据状态和失败状态
       this.hasAudioData = this.currentPageAudios.length > 0;
+      this.audioLoadFailed = !this.hasAudioData && this.isTextPage; // 如果是文本页面但没有音频数据，则认为获取失败
       
       // 通知父组件音频状态变化
       this.$emit('audio-state-change', {
         hasAudioData: this.hasAudioData,
         isLoading: this.isAudioLoading,
+        audioLoadFailed: this.audioLoadFailed,
         currentHighlightIndex: this.currentHighlightIndex
       });
+      
+      } catch (error) {
+        console.error('getCurrentPageAudio 方法执行异常:', error);
+        
+        // 确保在异常情况下重置加载状态
+        this.isAudioLoading = false;
+        this.isVoiceChanging = false;
+        this.audioLoadFailed = true;
+        this.hasAudioData = false;
+        
+        // 通知父组件音频加载失败
+        this.$emit('audio-state-change', {
+          hasAudioData: false,
+          isLoading: false,
+          audioLoadFailed: true,
+          currentHighlightIndex: this.currentHighlightIndex
+        });
+        
+        // 显示错误提示
+        uni.showToast({
+          title: '音频加载失败，请重试',
+          icon: 'none',
+          duration: 2000
+        });
+      }
+    },
+    
+    // 重新获取音频
+    retryGetAudio() {
+      console.log('用户点击重新获取音频');
+      
+      // 检查是否为卡片页面
+      if (!this.isTextPage) {
+        console.log('卡片页面不支持音频功能');
+        return;
+      }
+      
+      // 重置失败状态
+      this.audioLoadFailed = false;
+      // 清除当前页面的音频缓存
+      const pageKey = `${this.courseId}_${this.currentPage}_${this.localVoiceId}`;
+      if (this.audioCache[pageKey]) {
+        delete this.audioCache[pageKey];
+        console.log('清除失败页面的音频缓存:', pageKey);
+      }
+      // 重新获取音频
+      this.getCurrentPageAudio();
     },
     
     // 重置音频状态
     resetAudioState() {
-      // 先暂停当前播放的音频
-      if (this.isPlaying && this.currentAudio) {
-        this.pauseAudio();
-        console.log('翻页时暂停音频播放');
+      // 取消当前正在进行的音频请求
+      this.shouldCancelRequest = true;
+      console.log('页面切换：标记取消当前音频请求');
+      
+      // 立即停止并销毁当前音频实例，防止穿音
+      if (this.currentAudio) {
+        if (this.isPlaying) {
+          this.currentAudio.pause();
+          console.log('页面切换：立即停止音频播放');
+        }
+        this.currentAudio.destroy();
+        this.currentAudio = null;
+        console.log('页面切换：销毁音频实例');
       }
       
-      // 检查当前页面是否已有缓存的音频数据
-      const pageKey = `${this.courseId}_${this.currentPage}`;
-      const cachedAudio = this.audioCache[pageKey];
+      // 重置播放状态
+      this.currentAudioIndex = 0;
+      this.isPlaying = false;
+      this.currentTime = 0;
+      this.totalTime = 0;
+      this.sliderValue = 0;
+      this.isAudioLoading = false;
+      this.audioLoadFailed = false;
+      this.currentHighlightIndex = -1;
+      this.playSpeed = 1.0;
       
-      if (cachedAudio && cachedAudio.audios && cachedAudio.audios.length > 0) {
-        // 如果有缓存的音频数据，恢复音频状态
-        this.currentPageAudios = cachedAudio.audios;
-        this.totalTime = cachedAudio.totalDuration || 0;
-        this.hasAudioData = true;
-        
-        // 自动播放预加载的音频
-        console.log('检测到预加载音频，准备自动播放');
-        this.$nextTick(() => {
-          this.autoPlayPreloadedAudio();
-        });
-      } else {
-        // 如果没有缓存的音频数据，重置为初始状态
+      // 如果是卡片页面，直接重置为初始状态
+      if (!this.isTextPage) {
+        console.log('卡片页面：重置音频状态');
         this.currentPageAudios = [];
         this.totalTime = 0;
         this.hasAudioData = false;
+      } else {
+        // 文本页面：检查是否有缓存的音频数据
+        const pageKey = `${this.courseId}_${this.currentPage}_${this.localVoiceId}`;
+        const cachedAudio = this.audioCache[pageKey];
+        
+        if (cachedAudio && cachedAudio.audios && cachedAudio.audios.length > 0) {
+          // 有缓存：直接显示控制栏
+          this.currentPageAudios = cachedAudio.audios;
+          this.totalTime = cachedAudio.totalDuration || 0;
+          this.hasAudioData = true;
+          console.log('检测到缓存音频，显示控制栏');
+        } else {
+          // 没有缓存：重置为初始状态，但不立即加载（由checkAndLoadPreloadedAudio处理）
+          this.currentPageAudios = [];
+          this.totalTime = 0;
+          this.hasAudioData = false;
+          console.log('没有缓存音频，重置状态');
+        }
       }
       
-      // 重置播放状态，翻頁時統一設置播放速度為1.0
+      // 通知父组件音频状态变化
+      this.$emit('audio-state-change', {
+        hasAudioData: this.hasAudioData,
+        isLoading: this.isAudioLoading,
+        currentHighlightIndex: this.currentHighlightIndex
+      });
+    },
+    
+    // 加载缓存的音频数据并显示播放控制栏
+    loadCachedAudioData() {
+      const cacheKey = `${this.courseId}_${this.currentPage}_${this.localVoiceId}`;
+      const cachedData = this.audioCache[cacheKey];
+      
+      // 严格验证缓存数据
+      if (!cachedData || !cachedData.audios || cachedData.audios.length === 0) {
+        console.warn('缓存数据不存在或为空:', cacheKey);
+        uni.showToast({
+          title: '缓存音频数据不存在',
+          icon: 'none'
+        });
+        return;
+      }
+      
+      // 检查音色ID是否匹配
+      if (cachedData.voiceId && cachedData.voiceId !== this.localVoiceId) {
+        console.warn('缓存音色不匹配:', cachedData.voiceId, '!=', this.localVoiceId);
+        uni.showToast({
+          title: '音色已切换，请重新获取音频',
+          icon: 'none'
+        });
+        return;
+      }
+      
+      // 检查音频URL是否有效
+      const firstAudio = cachedData.audios[0];
+      if (!firstAudio || !firstAudio.url) {
+        console.warn('缓存音频URL无效');
+        uni.showToast({
+          title: '缓存音频数据损坏',
+          icon: 'none'
+        });
+        return;
+      }
+      
+      console.log('手动加载缓存音频数据:', cacheKey);
+      
+      // 从缓存加载音频数据
+      this.currentPageAudios = cachedData.audios;
+      this.totalTime = cachedData.totalDuration || 0;
       this.currentAudioIndex = 0;
       this.isPlaying = false;
       this.currentTime = 0;
+      this.hasAudioData = true;
       this.isAudioLoading = false;
+      this.audioLoadFailed = false;
       this.currentHighlightIndex = -1;
-      // 翻頁時強制設置播放速度為1.0（適應微信小程序特性）
-      this.playSpeed = 1.0;
       
       // 通知父组件音频状态变化
       this.$emit('audio-state-change', {
@@ -539,12 +837,19 @@ export default {
         isLoading: this.isAudioLoading,
         currentHighlightIndex: this.currentHighlightIndex
       });
+      
+      console.log('缓存音频加载完成，播放控制栏已显示');
     },
      
     // 手动获取音频
     async handleGetAudio() {
+      // 检查会员限制
+      if (this.isAudioDisabled) {
+        return;
+      }
+      
       // 检查是否有音色ID
-      if (!this.voiceId) {
+      if (!this.localVoiceId) {
         uni.showToast({
           title: '音色未加载，请稍后重试',
           icon: 'none'
@@ -667,6 +972,11 @@ export default {
     
     // 音频控制方法
     togglePlay() {
+      // 检查会员限制
+      if (this.isAudioDisabled) {
+        return;
+      }
+      
       if (this.currentPageAudios.length === 0) {
         uni.showToast({
           title: '当前页面没有音频内容',
@@ -684,6 +994,11 @@ export default {
     
     // 播放音频
     playAudio() {
+      // 检查会员限制
+      if (this.isAudioDisabled) {
+        return;
+      }
+      
       if (this.currentPageAudios.length === 0) return;
       
       // 如果没有当前音频实例或者需要切换音频
@@ -825,7 +1140,13 @@ export default {
         console.log('使用uni-app音頻API');
         audio = uni.createInnerAudioContext();
       }
-      audio.src = this.currentPageAudios[this.currentAudioIndex].url;
+      const audioUrl = this.currentPageAudios[this.currentAudioIndex].url;
+      audio.src = audioUrl;
+      
+      console.log('🎵 创建音频实例 - 当前音色ID:', this.voiceId);
+      console.log('🎵 创建音频实例 - 音频URL:', audioUrl);
+      console.log('🎵 创建音频实例 - 音频索引:', this.currentAudioIndex);
+      console.log('🎵 创建音频实例 - 音频文本:', this.currentPageAudios[this.currentAudioIndex].text?.substring(0, 50) + '...');
       
       // 在音頻可以播放時檢測playbackRate支持
       audio.onCanplay(() => {
@@ -1363,11 +1684,272 @@ export default {
       this.clearAudioCache();
     },
     
+    // 课程切换时的完整数据清理（保留音色设置）
+    resetForCourseChange() {
+      console.log('课程切换：开始清理所有数据，保留音色设置');
+      
+      // 1. 停止并销毁当前音频
+      if (this.isPlaying && this.currentAudio) {
+        this.pauseAudio();
+      }
+      if (this.currentAudio) {
+        this.currentAudio.destroy();
+        this.currentAudio = null;
+      }
+      
+      // 2. 清空所有音频相关数据
+      this.currentPageAudios = [];
+      this.currentAudioIndex = 0;
+      this.currentTime = 0;
+      this.totalTime = 0;
+      this.sliderValue = 0;
+      this.isDragging = false;
+      this.isPlaying = false;
+      this.hasAudioData = false;
+      this.isAudioLoading = false;
+      this.audioLoadFailed = false;
+      this.currentHighlightIndex = -1;
+      
+      // 3. 清空音频缓存（因为课程变了，所有缓存都无效）
+      this.clearAudioCache();
+      
+      // 4. 重置预加载状态
+      this.isPreloading = false;
+      this.preloadProgress = 0;
+      this.preloadedPages = new Set();
+      
+      // 5. 重置播放控制状态
+      this.isLoop = false;
+      this.playSpeed = 1.0;
+      this.playbackRateSupported = true;
+      
+      // 6. 重置音色切换状态
+      this.isVoiceChanging = false;
+      
+      // 7. 设置课程切换状态
+      this.isJustSwitchedCourse = true;
+      
+      // 注意：不清空 voiceId，保留用户的音色选择
+      
+      console.log('课程切换：数据清理完成，音色保持为:', this.voiceId);
+      
+      // 7. 通知父组件状态变化
+      this.$emit('audio-state-change', {
+        hasAudioData: false,
+        isLoading: false,
+        audioLoadFailed: false,
+        currentHighlightIndex: -1
+      });
+    },
+    
+    // 自动加载并播放音频（课程切换后调用）
+    async autoLoadAndPlayAudio() {
+      console.log('开始自动加载音频');
+      
+      // 检查是否为文本页面
+      if (!this.isTextPage) {
+        console.log('当前不是文本页面，跳过音频加载');
+        return;
+      }
+      
+      // 检查必要条件
+      if (!this.courseId || !this.currentPage) {
+        console.log('缺少必要参数，跳过音频加载');
+        return;
+      }
+      
+      try {
+         // 设置加载状态
+         this.isAudioLoading = true;
+         
+         // 开始加载音频
+         await this.getCurrentPageAudio();
+         
+         console.log('音频自动加载完成，hasAudioData:', this.hasAudioData);
+       } catch (error) {
+         console.error('自动加载音频失败:', error);
+         this.isAudioLoading = false;
+       }
+    },
+    
     // 暂停音频（页面隐藏时调用）
     pauseOnHide() {
       this.pauseAudio();
     },
     
+    // 处理音色切换（由父组件调用）
+    async handleVoiceChange(newVoiceId, options = {}) {
+      console.log('🎵 AudioControls: 开始处理音色切换', this.voiceId, '->', newVoiceId);
+      
+      // 检查是否正在加载音频，如果是则阻止音色切换
+      if (this.isAudioLoading) {
+        console.log('🎵 音频正在加载中，阻止音色切换');
+        throw new Error('音频加载中，请稍后再试');
+      }
+      
+      const { preloadAllPages = true } = options; // 默认预加载所有页面
+      
+      try {
+        // 1. 停止当前播放的音频
+        if (this.isPlaying) {
+          this.pauseAudio();
+        }
+        
+        // 2. 销毁当前音频实例
+        if (this.currentAudio) {
+          this.currentAudio.destroy();
+          this.currentAudio = null;
+        }
+        
+        // 3. 清理所有音频缓存（因为音色变了，所有缓存都无效）
+        this.clearAudioCache();
+        console.log('🎵 AudioControls: 已清理所有音频缓存');
+        
+        // 4. 重置音频状态
+        this.currentPageAudios = [];
+        this.currentAudioIndex = 0;
+        this.isPlaying = false;
+        this.currentTime = 0;
+        this.totalTime = 0;
+        this.hasAudioData = false;
+        this.audioLoadFailed = false;
+        this.currentHighlightIndex = -1;
+        
+        // 5. 设置音色切换加载状态
+        this.isVoiceChanging = true;
+        this.isAudioLoading = true;
+        
+        // 6. 更新本地音色ID（不直接修改prop）
+        this.localVoiceId = newVoiceId;
+        
+        // 7. 通知父组件开始加载状态
+        this.$emit('audio-state-change', {
+          hasAudioData: false,
+          isLoading: true,
+          currentHighlightIndex: -1
+        });
+        
+        // 8. 如果当前是文本页面，优先获取当前页面音频
+        if (this.isTextPage && this.courseId && this.currentPage) {
+          console.log('🎵 AudioControls: 优先获取当前页面音频，使用新音色:', newVoiceId);
+          await this.getCurrentPageAudio();
+          console.log('🎵 AudioControls: 当前页面音频获取完成');
+        } else {
+          // 如果不是文本页面，直接清除加载状态
+          this.isAudioLoading = false;
+          console.log('🎵 AudioControls: 非文本页面，直接清除加载状态');
+        }
+        
+        // 9. 清除音色切换加载状态
+        this.isVoiceChanging = false;
+        
+        // 10. 如果需要预加载其他页面，启动预加载
+        if (preloadAllPages) {
+          console.log('🎵 AudioControls: 开始预加载其他页面音频，使用新音色:', newVoiceId);
+          // 延迟启动预加载，确保当前页面音频加载完成
+          setTimeout(() => {
+            this.preloadAllPagesAudio();
+          }, 1000);
+        }
+        
+        // 11. 通知父组件最终状态
+        this.$emit('audio-state-change', {
+          hasAudioData: this.hasAudioData,
+          isLoading: this.isAudioLoading,
+          currentHighlightIndex: this.currentHighlightIndex
+        });
+        
+        // 12. 通知父组件音色切换完成
+        this.$emit('voice-change-complete', {
+          voiceId: newVoiceId,
+          hasAudioData: this.hasAudioData,
+          preloadAllPages: preloadAllPages
+        });
+        
+        console.log('🎵 AudioControls: 音色切换处理完成');
+      } catch (error) {
+        console.error('🎵 AudioControls: 音色切换处理失败:', error);
+        // 清除加载状态
+        this.isVoiceChanging = false;
+        this.isAudioLoading = false;
+        
+        // 通知父组件状态变化
+        this.$emit('audio-state-change', {
+          hasAudioData: false,
+          isLoading: false,
+          currentHighlightIndex: -1
+        });
+        
+        this.$emit('voice-change-error', error);
+      }
+    },
+    
+    // 预加载所有页面音频（音色切换时使用）
+    async preloadAllPagesAudio() {
+      if (this.isPreloading) {
+        console.log('已在预加载中，跳过');
+        return;
+      }
+      
+      try {
+        console.log('开始预加载所有页面音频');
+        this.isPreloading = true;
+        this.preloadProgress = 0;
+        
+        // 获取所有文本页面
+        const allTextPages = [];
+        for (let i = 0; i < this.bookPages.length; i++) {
+          const pageData = this.bookPages[i];
+          const hasTextContent = pageData && pageData.some(item => item.type === 'text');
+          
+          if (hasTextContent && i !== this.currentPage - 1) { // 排除当前页面，因为已经加载过了
+            allTextPages.push({
+              pageIndex: i + 1,
+              pageData: pageData
+            });
+          }
+        }
+        
+        if (allTextPages.length === 0) {
+          console.log('没有需要预加载的页面');
+          this.isPreloading = false;
+          return;
+        }
+        
+        console.log(`需要预加载 ${allTextPages.length} 个页面的音频`);
+        
+        // 逐页预加载音频
+        for (let i = 0; i < allTextPages.length; i++) {
+          const pageInfo = allTextPages[i];
+          
+          try {
+            console.log(`预加载第 ${pageInfo.pageIndex} 页音频 (${i + 1}/${allTextPages.length})`);
+            await this.preloadPageAudio(pageInfo.pageIndex, pageInfo.pageData);
+            
+            // 更新进度
+            this.preloadProgress = Math.round(((i + 1) / allTextPages.length) * 100);
+            console.log(`预加载进度: ${this.preloadProgress}%`);
+            
+            // 添加小延迟，避免请求过于频繁
+            if (i < allTextPages.length - 1) {
+              await new Promise(resolve => setTimeout(resolve, 200));
+            }
+          } catch (error) {
+            console.error(`预加载第 ${pageInfo.pageIndex} 页音频失败:`, error);
+            // 继续预加载其他页面，不因单页失败而中断
+          }
+        }
+        
+        console.log('所有页面音频预加载完成');
+      } catch (error) {
+        console.error('预加载所有页面音频失败:', error);
+      } finally {
+        this.isPreloading = false;
+        this.preloadProgress = 100;
+        console.log('音色切换后的音频预加载任务结束');
+      }
+    },
+    
     // 开始预加载音频（由父组件调用）
     async startPreloadAudio() {
       if (this.isPreloading) {
@@ -1431,10 +2013,17 @@ export default {
       for (let i = this.currentPage; i < Math.min(this.currentPage + maxPreloadPages, this.bookPages.length); i++) {
         const pageData = this.bookPages[i];
         
+        // 检查页面是否需要会员且用户非会员，如果是则跳过
+        const pageRequiresMember = this.pagePay[i] === 'Y';
+        if (pageRequiresMember && !this.isMember) {
+          console.log(`第${i + 1}页需要会员，跳过预加载`);
+          continue;
+        }
+        
         // 检查页面是否有文本内容且未缓存
         if (pageData && pageData.length > 0) {
           const hasTextContent = pageData.some(item => item.type === 'text' && item.content);
-          const cacheKey = `${this.courseId}_${i + 1}`;
+          const cacheKey = `${this.courseId}_${i + 1}_${this.voiceId}`;
           const isAlreadyCached = this.audioCache[cacheKey];
           
           if (hasTextContent && !isAlreadyCached) {
@@ -1451,7 +2040,7 @@ export default {
     
     // 预加载单个页面的音频
     async preloadPageAudio(pageIndex, pageData) {
-      const cacheKey = `${this.courseId}_${pageIndex + 1}`;
+      const cacheKey = `${this.courseId}_${pageIndex + 1}_${this.voiceId}`;
       
       // 检查是否已经缓存
       if (this.audioCache[cacheKey]) {
@@ -1480,7 +2069,13 @@ export default {
           console.log(`第${pageIndex + 1}页处理第 ${i + 1}/${textItems.length} 个文本项，长度: ${item.content.length}`);
           
           // 使用分批次请求音频
-          const batchResult = await this.requestAudioInBatches(item.content, this.voiceId);
+          const batchResult = await this.requestAudioInBatches(item.content, this.localVoiceId);
+          
+          // 检查请求是否被取消
+          if (batchResult === null) {
+            console.log(`第${pageIndex + 1}页预加载被取消`);
+            return;
+          }
           
           if (batchResult.audioSegments.length > 0) {
             // 将所有音频段添加到音频数组
@@ -1519,7 +2114,9 @@ export default {
       if (audioArray.length > 0) {
         this.audioCache[cacheKey] = {
           audios: audioArray,
-          totalDuration: totalDuration
+          totalDuration: totalDuration,
+          voiceId: this.localVoiceId, // 保存音色ID用于验证
+          timestamp: Date.now() // 保存时间戳
         };
         
         console.log(`第${pageIndex + 1}页音频预加载完成，共${audioArray.length}个音频，总时长: ${totalDuration}秒`);
@@ -1531,7 +2128,7 @@ export default {
     
     // 检查指定页面是否有音频缓存
     checkAudioCache(pageNumber) {
-      const cacheKey = `${this.courseId}_${pageNumber}`;
+      const cacheKey = `${this.courseId}_${pageNumber}_${this.localVoiceId}`;
       const cachedData = this.audioCache[cacheKey];
       
       if (cachedData && cachedData.audios && cachedData.audios.length > 0) {
@@ -1546,7 +2143,13 @@ export default {
     // 自动播放已缓存的音频
     async autoPlayCachedAudio() {
       try {
-        const cacheKey = `${this.courseId}_${this.currentPage}`;
+        // 如果正在音色切换中，不自动播放
+        if (this.isVoiceChanging) {
+          console.log('音色切换中，跳过自动播放');
+          return;
+        }
+        
+        const cacheKey = `${this.courseId}_${this.currentPage}_${this.voiceId}`;
         const cachedData = this.audioCache[cacheKey];
         
         if (!cachedData || !cachedData.audios || cachedData.audios.length === 0) {
@@ -1581,49 +2184,17 @@ export default {
   mounted() {
     // 初始檢測播放速度支持
     this.checkInitialPlaybackRateSupport();
-    
-    // 监听音色切换事件
-    uni.$on('selectVoice', (voiceId) => {
-      console.log('音色切換:', this.voiceId, '->', voiceId);
-      
-      // 音色切換時清除所有音頻緩存，因為不同音色的音頻文件不同
-      this.clearAudioCache();
-      
-      // 停止當前播放的音頻
-      if (this.currentAudio) {
-        this.currentAudio.destroy();
-        this.currentAudio = null;
-      }
-      
-      // 重置音頻狀態
-      this.currentPageAudios = [];
-      this.totalTime = 0;
-      this.hasAudioData = false;
-      this.isPlaying = false;
-      this.currentTime = 0;
-      this.currentAudioIndex = 0;
-      this.currentHighlightIndex = -1;
-      this.sliderValue = 0;
-      this.isDragging = false;
-      
-      // 通知父组件音频状态变化
-      this.$emit('audio-state-change', {
-        hasAudioData: this.hasAudioData,
-        isLoading: this.isAudioLoading,
-        currentHighlightIndex: this.currentHighlightIndex
-      });
-      
-      // 重新請求當前頁面的音頻數據
-      if (this.isTextPage) {
-        console.log('音色切換後重新獲取音頻數據');
-        this.handleGetAudio();
-      }
-    });
   },
   
   // 自动播放预加载的音频
   async autoPlayPreloadedAudio() {
     try {
+      // 如果正在音色切换中，不自动播放
+      if (this.isVoiceChanging) {
+        console.log('音色切换中，跳过预加载音频自动播放');
+        return;
+      }
+      
       // 检查是否有音频数据
       if (!this.hasAudioData || this.currentPageAudios.length === 0) {
         console.log('没有可播放的音频数据');
@@ -1662,10 +2233,16 @@ export default {
   },
   
   beforeDestroy() {
-    // 清理事件监听
-    uni.$off('selectVoice');
+    // 清理页面切换防抖定时器
+    if (this.pageChangeTimer) {
+      clearTimeout(this.pageChangeTimer);
+      this.pageChangeTimer = null;
+    }
+    
     // 清理音频资源
     this.destroyAudio();
+    
+    console.log('AudioControls组件已销毁，清理所有资源');
   }
 }
 </script>
@@ -1772,6 +2349,39 @@ export default {
   color: #999;
 }
 
+/* 音色切换加载状态特殊样式 */
+.voice-changing {
+  background: linear-gradient(135deg, #fff5f0 0%, #ffe7d9 100%);
+  border: 2rpx solid #ff6b35;
+}
+
+.voice-changing-text {
+  color: #ff6b35;
+  font-weight: 500;
+}
+
+/* 预加载状态特殊样式 */
+.preloading {
+  background: linear-gradient(135deg, #f0f9ff 0%, #e0f2fe 100%);
+  border: 2rpx solid #06DADC;
+}
+
+.preloading .loading-text {
+  color: #06DADC;
+  font-weight: 500;
+}
+
+/* 课程切换状态特殊样式 */
+.course-switching {
+  background: linear-gradient(135deg, #f6ffed 0%, #d9f7be 100%);
+  border: 2rpx solid #52c41a;
+}
+
+.course-switching .loading-text {
+  color: #52c41a;
+  font-weight: 500;
+}
+
 /* 获取音频按钮样式 */
 .audio-get-button-container {
   background: rgba(255, 255, 255, 0.95);
@@ -1830,9 +2440,67 @@ export default {
   font-weight: 500;
 }
 
+/* 音频获取失败样式 */
+.audio-failed-container {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  padding: 20rpx;
+  gap: 20rpx;
+}
+
+.failed-tip {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  gap: 16rpx;
+  padding: 20rpx 40rpx;
+  background: linear-gradient(135deg, #ff4d4f 0%, #cf1322 100%);
+  border-radius: 50rpx;
+  box-shadow: 0 8rpx 20rpx rgba(255, 77, 79, 0.3);
+}
+
+.failed-text {
+  color: #ffffff;
+  font-size: 28rpx;
+  font-weight: 500;
+}
+
+.retry-btn {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  gap: 12rpx;
+  padding: 16rpx 32rpx;
+  background: linear-gradient(135deg, #06DADC 0%, #05B8BA 100%);
+  border-radius: 40rpx;
+  box-shadow: 0 6rpx 16rpx rgba(6, 218, 220, 0.3);
+  transition: all 0.3s ease;
+}
+
+.retry-btn:active {
+  transform: scale(0.95);
+  box-shadow: 0 4rpx 12rpx rgba(6, 218, 220, 0.4);
+}
+
+.retry-text {
+  color: #ffffff;
+  font-size: 26rpx;
+  font-weight: 500;
+}
+
 .get-audio-text {
   font-size: 32rpx;
   color: #FFFFFF;
   font-weight: 500;
 }
+
+/* 会员限制容器样式 */
+.member-restricted-container {
+  height: 0;
+  overflow: hidden;
+  opacity: 0;
+  pointer-events: none;
+}
 </style>
\ No newline at end of file
diff --git a/subPages/home/book.vue b/subPages/home/book.vue
index 4826b16..6947ba1 100644
--- a/subPages/home/book.vue
+++ b/subPages/home/book.vue
@@ -27,10 +27,10 @@
         <view class="content-area" @click="toggleNavbar">
         
           <!-- 会员限制页面 -->
-          <view v-if="!isMember && pagePay[index] === 'Y'" class="member-content">
+          <view v-if="!isMember && pagePay[index] === 'Y'" class="member-content" >
             <text class="member-title">{{ pageTitles[index] }}</text>
-            <view class="member-button" @click="unlockBook">
-              <text class="member-button-text">升級會員解鎖</text>
+            <view class="member-button" @click.stop="unlockBook">
+              <text class="member-button-text">升级会员解锁</text>
             </view>
           </view>
 
@@ -99,10 +99,15 @@
         :voice-id="voiceId"
         :book-pages="bookPages"
         :is-text-page="isTextPage"
+        :is-member="isMember"
+        :current-page-requires-member="currentPageRequiresMember"
+        :page-pay="pagePay"
         @previous-page="previousPage"
         @next-page="nextPage"
         @audio-state-change="onAudioStateChange"
         @highlight-change="onHighlightChange"
+        @voice-change-complete="onVoiceChangeComplete"
+        @voice-change-error="onVoiceChangeError"
         ref="audioControls"
       />
     
@@ -194,7 +199,7 @@
         </view>
         
         <view class="meaning-content">
-          <image class="meaning-image" src="/static/默认图片.png" mode="aspectFill"></image>
+          <image v-if="currentWordMeaning.imag" class="meaning-image" :src="currentWordMeaning.image" mode="aspectFill"></image>
           
           <view class="word-info">
             <view class="word-main">
@@ -251,6 +256,11 @@ export default {
       currentHighlightIndex: -1, // 当前高亮的文本索引
       wordAudioCache: {}, // 單詞語音緩存
       currentWordAudio: null, // 當前播放的單詞音頻實例
+      
+      // 音频状态相关
+      isAudioLoading: false, // 音频是否正在加载
+      hasAudioData: false, // 是否有音频数据
+      audioLoadFailed: false, // 音频加载是否失败
       courseIdList: [],
       bookTitle: '',
       courseList: [
@@ -301,6 +311,11 @@ export default {
     // 当前页面的单词释义数据
     currentPageWords() {
       return this.pageWords[this.currentPage - 1] || [];
+    },
+    
+    // 当前页面是否需要会员
+    currentPageRequiresMember() {
+      return this.pagePay[this.currentPage - 1] === 'Y';
     }
   },
   methods: {
@@ -318,6 +333,54 @@ export default {
     onAudioStateChange(audioState) {
       // 更新高亮状态
       this.currentHighlightIndex = audioState.currentHighlightIndex;
+      
+      // 更新音频加载状态（用于控制UI显示）
+      if (audioState.hasOwnProperty('isLoading')) {
+        this.isAudioLoading = audioState.isLoading;
+      }
+      
+      // 更新音频数据状态
+      if (audioState.hasOwnProperty('hasAudioData')) {
+        this.hasAudioData = audioState.hasAudioData;
+      }
+      
+      // 更新音频加载失败状态
+      if (audioState.hasOwnProperty('audioLoadFailed')) {
+        this.audioLoadFailed = audioState.audioLoadFailed;
+      }
+    },
+    
+    // 处理音色切换完成事件
+    onVoiceChangeComplete(data) {
+      console.log('音色切换完成:', data);
+      // 可以在这里添加一些UI反馈，比如显示切换成功的提示
+      if (data.hasAudioData) {
+        console.log('新音色当前页面音频已加载完成');
+      } else {
+        console.log('当前页面没有音频数据');
+      }
+      
+      // 如果启用了预加载所有页面
+      if (data.preloadAllPages) {
+        console.log('正在后台预加载所有页面的新音色音频...');
+        // 可以显示一个提示，告诉用户正在后台加载
+        uni.showToast({
+          title: '正在加载新音色...',
+          icon: 'loading',
+          duration: 2000
+        });
+      }
+    },
+    
+    // 处理音色切换错误事件
+    onVoiceChangeError(error) {
+      console.error('音色切换失败:', error);
+      // 可以在这里显示错误提示给用户
+      uni.showToast({
+        title: '音色切换失败，请重试',
+        icon: 'none',
+        duration: 2000
+      });
     },
     
     // 处理文本点击事件
@@ -375,7 +438,14 @@ export default {
       }
       
       // 检查当前页面是否为文本页面
+      // 对于卡片页面（type为'1'），不显示错误提示，因为单词点击会单独处理
       if (!this.isTextPage) {
+        // 如果是卡片页面，静默返回，不显示错误提示
+        if (this.currentPageType === '1') {
+          console.log('卡片页面的文本点击，单词播放由handleWordClick处理');
+          return;
+        }
+        
         console.log('当前页面不是文本页面');
         uni.showToast({
           title: '当前页面不支持音频播放',
@@ -424,8 +494,10 @@ export default {
     async getVoiceList() {
       const voiceRes = await this.$api.music.list()
       if(voiceRes.code === 200){
-        this.voiceId = voiceRes.result[0].voiceType
-        console.log('获取默认音色ID:', this.voiceId);
+        console.log('音色列表API返回:', voiceRes.result);
+        console.log('第一个音色数据:', voiceRes.result[0]);
+        this.voiceId = Number(voiceRes.result[0].voiceType)
+        console.log('获取默认音色ID:', this.voiceId, '类型:', typeof this.voiceId);
       }
     },
     toggleNavbar() {
@@ -495,8 +567,9 @@ export default {
           this.currentWordAudio.destroy();
           this.currentWordAudio = null;
         }
-
+        
         // 調用語音轉換API
+        console.log('playWordAudio - voiceId值:', this.voiceId, '类型:', typeof this.voiceId);
         const audioRes = await this.$api.music.textToVoice({
           text: word,
           voiceType: this.voiceId
@@ -1257,11 +1330,6 @@ export default {
           if (this.courseIdList[this.currentPage - 1] && this.bookPages[this.currentPage - 1].length === 0) {
             await this.getBookPages(this.courseIdList[this.currentPage - 1]);
           }
-          
-          // 通知音频控制组件重置状态
-          if (this.$refs.audioControls) {
-            this.$refs.audioControls.resetAudioState();
-          }
         }
     },
     async nextPage() {
@@ -1271,14 +1339,29 @@ export default {
         if (this.courseIdList[this.currentPage - 1] && this.bookPages[this.currentPage - 1].length === 0) {
           await this.getBookPages(this.courseIdList[this.currentPage - 1]);
         }
-        
-        // 通知音频控制组件重置状态
-        if (this.$refs.audioControls) {
-          this.$refs.audioControls.resetAudioState();
-        }
       }
     },
     toggleSound() {
+      // 检查是否正在加载音频，如果是则阻止音色切换
+      if (this.isAudioLoading) {
+        uni.showToast({
+          title: '音频加载中，请稍后再试',
+          icon: 'none',
+          duration: 2000
+        });
+        return;
+      }
+      
+      // 检查AudioControls组件是否正在加载音频
+      if (this.$refs.audioControls && this.$refs.audioControls.isAudioLoading) {
+        uni.showToast({
+          title: '音频加载中，请稍后再试',
+          icon: 'none',
+          duration: 2000
+        });
+        return;
+      }
+      
       console.log('音色切换')
       uni.navigateTo({
         url: '/subPages/home/music?voiceId=' + this.voiceId
@@ -1298,21 +1381,6 @@ export default {
       if (this.courseIdList[this.currentPage - 1] && this.bookPages[this.currentPage - 1].length === 0) {
         await this.getBookPages(this.courseIdList[this.currentPage - 1]);
       }
-      
-      // 通知音频控制组件处理页面切换
-      if (this.$refs.audioControls) {
-        // 检查当前页面是否有预加载的音频缓存
-        const hasPreloadedAudio = this.$refs.audioControls.checkAudioCache(this.currentPage);
-        
-        if (hasPreloadedAudio) {
-          // 如果有预加载的音频，直接播放
-          console.log(`第${this.currentPage}页音频已预加载，自动播放`);
-          this.$refs.audioControls.autoPlayCachedAudio();
-        } else {
-          // 如果没有预加载的音频，重置状态
-          this.$refs.audioControls.resetAudioState();
-        }
-      }
     },
     async onSwiperChange(e) {
       this.currentPage = e.detail.current + 1
@@ -1320,27 +1388,28 @@ export default {
       if (this.courseIdList[this.currentPage - 1] && this.bookPages[this.currentPage - 1].length === 0) {
         await this.getBookPages(this.courseIdList[this.currentPage - 1]);
       }
-      
-      // 通知音频控制组件处理页面切换
-      if (this.$refs.audioControls) {
-        // 检查当前页面是否有预加载的音频缓存
-        const hasPreloadedAudio = this.$refs.audioControls.checkAudioCache(this.currentPage);
-        
-        if (hasPreloadedAudio) {
-          // 如果有预加载的音频，直接播放
-          console.log(`第${this.currentPage}页音频已预加载，自动播放`);
-          this.$refs.audioControls.autoPlayCachedAudio();
-        } else {
-          // 如果没有预加载的音频，重置状态
-          this.$refs.audioControls.resetAudioState();
-        }
-      }
     },
     async getCourseList(id) {
       const res = await this.$api.book.coursePage({
         id: id
       })
       if (res.code === 200) {
+        // 课程切换时，先清理音频控制组件的所有数据
+        if (this.$refs.audioControls) {
+          this.$refs.audioControls.resetForCourseChange();
+        }
+        
+        // 清空当前页面相关数据
+        this.currentPage = 1; // 重置到第一页
+        this.currentCourse = 1; // 重置当前课程索引
+        this.currentWordMeaning = null; // 清空单词释义
+        this.currentWordAudio = null; // 清空单词音频
+        this.currentHighlightIndex = -1; // 清空高亮索引
+        
+        // 清理单词音频缓存
+        this.clearWordAudioCache();
+        
+        // 重新初始化课程数据
         this.courseIdList = res.result.map(item => item.id)
         // 初始化二维数组 换一种方式
         this.bookPages = this.courseIdList.map(() => [])
@@ -1350,13 +1419,30 @@ export default {
         this.pageTypes = this.courseIdList.map(() => '')
         // 初始化页面单词数组
         this.pageWords = this.courseIdList.map(() => [])
-        // 通知音频控制组件重置状态
-        if (this.$refs.audioControls) {
-          this.$refs.audioControls.resetAudioState();
-        }
+        
+        console.log('课程切换完成，courseId:', id, '总页数:', this.courseIdList.length);
+        
         // 初始化第一页
         if (this.courseIdList.length > 0) {
           await this.getBookPages(this.courseIdList[0])
+          
+          // 课程切换后，确保音频控件能正确加载新课程的音频
+          console.log('课程切换完成，准备加载音频，当前页面类型:', this.isTextPage);
+          
+          // 使用$nextTick确保DOM和数据都已更新
+          this.$nextTick(async () => {
+            if (this.$refs.audioControls) {
+              console.log('开始自动加载课程音频');
+              try {
+                // 直接调用getCurrentPageAudio方法，更可靠
+                await this.$refs.audioControls.getCurrentPageAudio();
+                console.log('课程切换后音频加载完成');
+              } catch (error) {
+                console.error('课程切换后音频加载失败:', error);
+              }
+            }
+          });
+          
           // 预加载后续几页的内容（异步执行，不阻塞当前页面显示）
           this.preloadNextPages()
         }
@@ -1528,8 +1614,24 @@ export default {
   },
   async onLoad(args) {
     // 监听音色切换事件，传递给AudioControls组件处理
-    uni.$on('selectVoice', (voiceId) => {
-      console.log('音色切換:', this.voiceId, '->', voiceId);
+    uni.$on('selectVoice', async (voiceId) => {
+      if (this.voiceId === voiceId) {
+        console.log('音色未變化，跳過處理');
+        return;
+      }
+      
+      // 检查是否正在加载音频，如果是则阻止音色切换
+      if (this.isAudioLoading || (this.$refs.audioControls && this.$refs.audioControls.isAudioLoading)) {
+        console.log('音频正在加载中，阻止音色切换');
+        uni.showToast({
+          title: '音频加载中，请稍后再试',
+          icon: 'none',
+          duration: 2000
+        });
+        return;
+      }
+      
+      // 更新本地音色ID
       this.voiceId = voiceId;
       
       // 清理單詞語音資源
@@ -1538,24 +1640,36 @@ export default {
         this.currentWordAudio.destroy();
         this.currentWordAudio = null;
       }
+      
+      // 通知AudioControls组件处理音色切换
+      if (this.$refs.audioControls) {
+        try {
+          console.log('开始处理音色切换，清理所有音频缓存并重新获取所有页面音频');
+          // 传入选项：preloadAllPages: true 表示要预加载所有页面的音频
+          await this.$refs.audioControls.handleVoiceChange(voiceId, { 
+            preloadAllPages: true 
+          });
+          console.log('音色切换处理完成');
+        } catch (error) {
+          console.error('音色切换处理失败:', error);
+        }
+      }
     })
     
     this.courseId = args.courseId
     this.memberId = args.memberId
     
     // 先获取点进来的课程的页面列表
-    await Promise.all([this.getCourseList(this.courseId), this.getCoursePageList(args.bookId), this.getMemberInfo(), this.getVoiceList()])
+    await Promise.all([this.getVoiceList(),this.getMemberInfo(),this.getCourseList(this.courseId), this.getCoursePageList(args.bookId)])
+   
+   // 页面加载完成后，通知AudioControls组件自动加载第一页音频
+   this.$nextTick(() => {
+     if (this.$refs.audioControls) {
+       this.$refs.audioControls.autoLoadAndPlayFirstPage();
+     }
+   });
     
-    // 页面加载完成后，通知AudioControls组件自动加载第一页音频
-    this.$nextTick(() => {
-      if (this.$refs.audioControls) {
-        this.$refs.audioControls.autoLoadAndPlayFirstPage();
-      }
-    });
   },
-  
-
-  
   // 页面卸载时清理资源
   onUnload() {
     uni.$off('selectVoice')
diff --git a/subPages/home/directory.vue b/subPages/home/directory.vue
index a50d179..29224c7 100644
--- a/subPages/home/directory.vue
+++ b/subPages/home/directory.vue
@@ -41,12 +41,12 @@
         <view class="course-list">
           <!-- 限制在做多五個課程 -->
           <view 
-          v-for="(course, index) in courseList.records.slice(0, 5)" 
-          @click="startLearning(course.id)"
+            v-for="(course, index) in computedList" 
             :key="index"
             class="course-item"
+            @click="startLearning(course.id)"
           >
-            <view class="course-number">{{ String(index + 1).padStart(2, '0') }}</view>
+            <view class="course-number" >{{ String(index + 1).padStart(2, '0') }}</view>
             <view class="course-content">
               <view class="course-name">{{ course.english }}</view>
               <view class="course-subtitle">{{ course.chinese }}</view>
@@ -117,7 +117,7 @@
     >
       <view class="course-popup">
         <view class="popup-header">
-          <view>
+          <view @click="closeAllCoursePopup">
             <uv-icon name="arrow-down" color="black" size="20"></uv-icon>
           </view>
           <view class="popup-title">全部课程</view>
@@ -170,6 +170,9 @@ export default {
     displayAllCourseList() {
       const list = this.allCourseList.length > 0 ? this.allCourseList : this.courseList.records || [];
       return this.isCourseSortReversed ? [...list].reverse() : list;
+    },
+    computedList(){
+      return this.courseList.records.slice(0, 5)
     }
   },
   methods: {
@@ -190,12 +193,13 @@ export default {
       }
     },
     // 开始学习
-    startLearning(id) {  
+    startLearning(id) {
       // 默认学第一堂课
       uni.navigateTo({
         url: '/subPages/home/book?courseId=' + id + '&bookId=' + this.id + '&memberId=' + this.bookInfo.vip
       })
     },
+
     // 获取书籍详情
     async getDetail() {
       const detailRes = await this.$api.book.detail({
@@ -210,7 +214,7 @@ export default {
       const courseRes = await this.$api.book.course({
         id: this.id,
         pageNo: 1,
-        pageSize: 5
+        pageSize: 999
       })
       if (courseRes.code === 200){
         this.courseList = courseRes.result
@@ -223,11 +227,16 @@ export default {
     showAllCoursePopup() {
       this.$refs.allCoursePopup.open()
     },
+
+    // 關閉全部課程彈出窗
+    closeAllCoursePopup() {
+      this.$refs.allCoursePopup.close()
+    },
     
     // 切換課程排序
     toggleCourseSort() {
       this.isCourseSortReversed = !this.isCourseSortReversed
-    },
+    }
   },
   onLoad(options) {
     if (options.id){
diff --git a/subPages/home/music.vue b/subPages/home/music.vue
index 821b5f8..a3388ef 100644
--- a/subPages/home/music.vue
+++ b/subPages/home/music.vue
@@ -8,7 +8,7 @@
         :key="voice.voiceType"
         class="voice-item"
         :class="{ 'selected': voice.voiceType === selectedVoiceId }"
-        @click="selectVoice(voice.voiceType)"
+        @click="selectedVoiceId = voice.voiceType"
       >
         <view class="voice-avatar">
           <view class="play-icon">
@@ -64,15 +64,14 @@ export default {
     goBack() {
       uni.navigateBack()
     },
-    selectVoice(voiceId) {
-      this.selectedVoiceId = voiceId
-      console.log('选择音色:', voiceId)
-      uni.$emit('selectVoice', voiceId)
+    selectVoice() {
+      console.log('选择音色:', this.selectedVoiceId)
+      uni.$emit('selectVoice', this.selectedVoiceId)
+      uni.navigateBack()
     },
     confirmSelection() {
-      console.log('确认选择音色:', this.selectedVoiceId)
+      this.selectVoice(this.selectedVoiceId)
       // 这里可以保存选择的音色到本地存储或发送到服务器
-      uni.navigateBack()
     },
     async getVoice(){
       const listRes = await this.$api.music.list()
diff --git a/subPages/home/submit.vue b/subPages/home/submit.vue
index 3b7e4bd..b605235 100644
--- a/subPages/home/submit.vue
+++ b/subPages/home/submit.vue
@@ -104,7 +104,7 @@ export default {
         phone: '',
         looking: '',
         background: '',
-        id: this.id
+        linkId: this.linkId
       }
     }
   },
@@ -130,8 +130,7 @@ export default {
       try{
 
         const subRes = await this.$api.home.getSignup({
-          ...this.formData,
-          id: this.id
+          ...this.formData
         })
         if (subRes.code === 200) {
           uni.showToast({
@@ -157,7 +156,7 @@ export default {
     }
   },
   onLoad(options) {
-    this.linkId = options.id
+    this.formData.linkId = options.id
   }
 }
 </script>
diff --git a/subPages/user/cash.vue b/subPages/user/cash.vue
index 35433ec..3940d72 100644
--- a/subPages/user/cash.vue
+++ b/subPages/user/cash.vue
@@ -6,7 +6,7 @@
     <view class="form-container">
       <view class="header">
         <view class="title">微信提现</view>
-        <view class="flow-link">过往流水 ></view>
+        <!-- <view class="flow-link">过往流水 ></view> -->
       </view>
       <!-- 真实姓名 -->
       <view class="form-item">
diff --git a/subPages/user/promote.vue b/subPages/user/promote.vue
index dc686ca..0a070cc 100644
--- a/subPages/user/promote.vue
+++ b/subPages/user/promote.vue
@@ -114,7 +114,7 @@
               <text class="status" 
               :class="item.withdrawal.status === '1' 
               && item.withdrawal.withdrawStatus === '0' ? 'status-available' : 'status-received'" 
-              v-if="item.withdrawal && item.withdrawal.status != '1'">{{ getText(item.withdrawal) }}</text>
+              v-else-if="item.withdrawal ">{{ getText(item.withdrawal) }}</text>
             </view>
           </view>
         </view>
diff --git a/utils/common.js b/utils/common.js
index ce23a37..2f96823 100644
--- a/utils/common.js
+++ b/utils/common.js
@@ -1,50 +1,3 @@
-// 用来保存图片的函数
-//  params: 需要授权的内容
-// scope.userInfo   	用户信息
-// scope.userLocation  	地理位置
-// scope.userLocationBackground 	后台定位	微信小程序
-// scope.address	 	通信地址
-// scope.record 		录音功能
-// scope.writePhotosAlbum	  	保存到相册	抖音小程序的返回值是scope.album
-// scope.camera 	摄像头
-// scope.invoice		获取发票
-// scope.invoiceTitle		发票抬头
-// scope.werun	wx.getWeRunData	微信运动步数
-const scopeList = {
-  userInfo: 'scope.userInfo',
-  userLocation: 'scope.userLocation',
-  userLocationBackground: 'scope.userLocationBackground',
-  address: 'scope.address',
-  record: 'scope.record',
-  writePhotosAlbum: 'scope.writePhotosAlbum',
-  camera: 'scope.camera',
-  invoice: 'scope.invoice',
-  invoiceTitle: 'scope.invoiceTitle',
-  werun: 'scope.werun',
-}
-const authorize = ({
-  scope,
-  successfn,
-  failfn,
-}) => {
-  if (!scopeList[scope]) {
-    uni.showToast({
-      title: 'scope参数错误',
-      icon: 'error'
-    })
-    return
-  }
-  uni.authorize({
-    scope: scopeList[scope],
-    success() {
-      successfn()
-    },
-    fail() {
-      failfn()
-    }
-  })
-}
-
 // 检验手机号格式
 const checkPhone = (phone) => {
   if (!phone || !/^1[3-9]\d{9}$/.test(phone)) {
@@ -141,7 +94,6 @@ const wxPay = (paymentData, successCallback, failCallback)  => {
 }
 
 export {
-  authorize,
   checkPhone,
   formatTime,
   calculateDateDifference,
diff --git a/utils/index.js b/utils/index.js
index a515809..7b4d00d 100644
--- a/utils/index.js
+++ b/utils/index.js
@@ -1,5 +1,4 @@
 import {
-  authorize,
   checkPhone,
   formatTime,
   calculateDateDifference,
@@ -13,7 +12,6 @@ import {
 } from '@/utils/upload'
 
 export default {
-  authorize,
   checkPhone,
   formatTime,
   calculateDateDifference,