diff --git a/config/index.js b/config/index.js
index 5ab8995..4da1aa2 100644
--- a/config/index.js
+++ b/config/index.js
@@ -12,7 +12,7 @@ const envParam = {
   prod: 'production',
 }
 
-const env = envParam['test']
+const env = envParam['dev']
 
 // 全局配置
 const config = {
diff --git a/pages/components/SplashScreen.vue b/pages/components/SplashScreen.vue
index 3fa5cb2..e7aaf20 100644
--- a/pages/components/SplashScreen.vue
+++ b/pages/components/SplashScreen.vue
@@ -6,6 +6,8 @@
         :src="splashContent"
         mode="scaleToFill"
         class="splash-image"
+        @error="onImageError"
+        @load="onImageLoad"
       />
     </view>
     
@@ -48,7 +50,24 @@ export default {
   },
   computed: {
     image() {
-      return this.configParamContent('creen_image') || uni.getStorageSync('screen_image')
+      try {
+        // 優先從配置獲取
+        const configImage = this.configParamContent && this.configParamContent('creen_image')
+        if (configImage && configImage !== 'undefined' && configImage !== '') {
+          return configImage
+        }
+        
+        // 備用方案：從本地存儲獲取
+        const storageImage = uni.getStorageSync('screen_image')
+        if (storageImage && storageImage !== 'undefined' && storageImage !== '') {
+          return storageImage
+        }
+        
+        return ''
+      } catch (error) {
+        console.error('獲取開屏圖片失敗:', error)
+        return ''
+      }
     }
   },
   mounted() {
@@ -63,17 +82,38 @@ export default {
     // 初始化開動頁面
     async initSplash() {
       try {
-        // 獲取富文本內容
-      this.splashContent = this.image
+        // 等待一小段時間確保 store 數據加載完成
+        await this.$nextTick()
         
-        // 如果有內容才顯示
-        if (this.splashContent) {
+        // 獲取圖片URL，優先使用配置，然後使用本地存儲
+        let imageUrl = ''
+        
+        // 嘗試從配置獲取
+        if (this.$store.state.configList && this.$store.state.configList['creen_image']) {
+          imageUrl = this.configParamContent('creen_image')
+        }
+        
+        // 如果配置中沒有，嘗試從本地存儲獲取
+        if (!imageUrl) {
+          imageUrl = uni.getStorageSync('screen_image')
+        }
+        
+        console.log('開屏圖片URL:', imageUrl)
+        
+        // 如果有圖片URL才顯示開屏
+        if (imageUrl && imageUrl !== 'undefined' && imageUrl !== '') {
+          this.splashContent = imageUrl
           this.countdown = this.duration
           this.showSplash = true
           this.startCountdown()
+        } else {
+          console.log('沒有開屏圖片，跳過開屏動畫')
+          this.$emit('close')
         }
       } catch (error) {
         console.error('獲取開動頁面內容失敗:', error)
+        // 發生錯誤時直接關閉開屏
+        this.$emit('close')
       }
     },
     
@@ -103,6 +143,18 @@ export default {
         clearInterval(this.timer)
         this.timer = null
       }
+    },
+    
+    // 圖片加載成功
+    onImageLoad() {
+      console.log('開屏圖片加載成功')
+    },
+    
+    // 圖片加載失敗
+    onImageError(e) {
+      console.error('開屏圖片加載失敗:', e)
+      // 圖片加載失敗時直接關閉開屏
+      this.closeSplash()
     }
   }
 }
diff --git a/subPages/home/AudioControls.vue b/subPages/home/AudioControls.vue
index 012b774..23e2079 100644
--- a/subPages/home/AudioControls.vue
+++ b/subPages/home/AudioControls.vue
@@ -1,21 +1,35 @@
 <template>
   <view class="audio-controls-wrapper">
     <!-- 获取音频按钮 -->
-    <view v-if="!hasAudioData && !isAudioLoading && isTextPage" class="audio-get-button-container">
+    <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>
+    
     <!-- 音频加载状态 -->
-    <view v-else-if="isAudioLoading && isTextPage" class="audio-loading-container">
+    <view v-else-if="isAudioLoading && isTextPage && !hasAudioData" class="audio-loading-container">
       <uv-loading-icon mode="spinner" size="30" color="#06DADC"></uv-loading-icon>
       <text class="loading-text">正在加载第{{currentPage}}页音频...</text>
     </view>
     
     <!-- 正常音频控制栏 -->
     <view v-else-if="hasAudioData" class="audio-controls" :class="{ 'audio-hidden': !isTextPage }">
+      <!-- 加载指示器 -->
+      <view v-if="isAudioLoading" class="loading-indicator">
+        <uv-loading-icon mode="spinner" size="16" color="#06DADC"></uv-loading-icon>
+        <text class="loading-indicator-text">正在加载更多音频...</text>
+      </view>
+      
       <view class="audio-time">
         <text class="time-text">{{ formatTime(currentTime) }}</text>
         <view class="progress-container">
@@ -28,10 +42,8 @@
             backgroundColor="#e0e0e0"
             :blockSize="16"
             blockColor="#ffffff"
-            :disabled="!hasAudioData || totalTime <= 0"
-            @input="onSliderInput"
-            @changing="onSliderChanging"
-            @change="onSliderChange"
+            disabled
+
             :customStyle="{ flex: 1, margin: '0 10px' }"
           />
         </view>
@@ -114,6 +126,10 @@ export default {
       currentAudio: null, // 当前音频实例
       // 音频缓存管理
       audioCache: {}, // 页面音频缓存 {pageIndex: {audios: [], totalDuration: 0}}
+      // 预加载相关状态
+      isPreloading: false, // 是否正在预加载
+      preloadProgress: 0, // 预加载进度 (0-100)
+      preloadQueue: [], // 预加载队列
       // 音频加载状态
       isAudioLoading: false, // 音频是否正在加载
       hasAudioData: false, // 当前页面是否已有音频数据
@@ -125,6 +141,13 @@ export default {
     // 计算音频播放进度百分比
     progressPercent() {
       return this.totalTime > 0 ? (this.currentTime / this.totalTime) * 100 : 0;
+    },
+    
+    // 检查当前页面是否有缓存的音频
+    hasCurrentPageCache() {
+      const cacheKey = `${this.courseId}_${this.currentPage}`;
+      const cachedData = this.audioCache[cacheKey];
+      return cachedData && cachedData.audios && cachedData.audios.length > 0;
     }
   },
   watch: {
@@ -148,7 +171,171 @@ export default {
     }
   },
   methods: {
-    // 获取当前页面的音频内容
+    // 智能分割文本，按句号和逗号分割中英文文本
+    splitTextIntelligently(text) {
+      if (!text || typeof text !== 'string') {
+        return [text];
+      }
+      
+      // 判断是否为中文文本（包含中文字符）
+      const isChinese = /[\u4e00-\u9fa5]/.test(text);
+      const maxLength = isChinese ? 200 : 400;
+      
+      // 如果文本长度不超过限制，直接返回
+      if (text.length <= maxLength) {
+        return [{
+          text: text,
+          startIndex: 0,
+          endIndex: text.length - 1
+        }];
+      }
+      
+      const segments = [];
+      let currentText = text;
+      let globalStartIndex = 0;
+      
+      while (currentText.length > 0) {
+        if (currentText.length <= maxLength) {
+          // 剩余文本不超过限制，直接添加
+          segments.push({
+            text: currentText,
+            startIndex: globalStartIndex,
+            endIndex: globalStartIndex + currentText.length - 1
+          });
+          break;
+        }
+        
+        // 在限制长度内寻找最佳分割点
+        let splitIndex = maxLength;
+        let bestSplitIndex = -1;
+        
+        // 优先寻找句号
+        for (let i = Math.min(maxLength, currentText.length - 1); i >= Math.max(0, maxLength - 50); i--) {
+          const char = currentText[i];
+          if (char === '。' || char === '.') {
+            bestSplitIndex = i + 1; // 包含句号
+            break;
+          }
+        }
+        
+        // 如果没找到句号，寻找逗号
+        if (bestSplitIndex === -1) {
+          for (let i = Math.min(maxLength, currentText.length - 1); i >= Math.max(0, maxLength - 50); i--) {
+            const char = currentText[i];
+            if (char === '，' || char === ',' || char === '；' || char === ';') {
+              bestSplitIndex = i + 1; // 包含标点符号
+              break;
+            }
+          }
+        }
+        
+        // 如果还是没找到合适的分割点，使用默认长度
+        if (bestSplitIndex === -1) {
+          bestSplitIndex = maxLength;
+        }
+        
+        // 提取当前段落
+        const segment = currentText.substring(0, bestSplitIndex).trim();
+        if (segment.length > 0) {
+          segments.push({
+            text: segment,
+            startIndex: globalStartIndex,
+            endIndex: globalStartIndex + segment.length - 1
+          });
+        }
+        
+        // 更新剩余文本和全局索引
+        currentText = currentText.substring(bestSplitIndex).trim();
+        globalStartIndex += bestSplitIndex;
+      }
+      
+      console.log(`文本分割完成，原长度: ${text.length}，分割为 ${segments.length} 段:`, segments);
+       return segments;
+     },
+     
+     // 分批次请求音频
+     async requestAudioInBatches(text, voiceType) {
+       const segments = this.splitTextIntelligently(text);
+       const audioSegments = [];
+       let totalDuration = 0;
+       
+       console.log(`开始分批次请求音频，共 ${segments.length} 段`);
+       
+       for (let i = 0; i < segments.length; i++) {
+         const segment = segments[i];
+         
+         try {
+           console.log(`请求第 ${i + 1}/${segments.length} 段音频:`, segment.text.substring(0, 50) + '...');
+           
+           const radioRes = await this.$api.music.textToVoice({
+             text: segment.text,
+             voiceType: voiceType,
+           });
+           
+           if (radioRes.code === 200) {
+             const audioUrl = radioRes.result.url;
+             const duration = radioRes.result.time || 0;
+             
+             audioSegments.push({
+               url: audioUrl,
+               text: segment.text,
+               duration: duration,
+               startIndex: segment.startIndex,
+               endIndex: segment.endIndex,
+               segmentIndex: i,
+               isSegmented: segments.length > 1,
+               originalText: text
+             });
+             
+             totalDuration += duration;
+             
+             console.log(`第 ${i + 1} 段音频请求成功，时长: ${duration}秒`);
+           } else {
+             console.error(`第 ${i + 1} 段音频请求失败:`, radioRes);
+             // 即使某段失败，也继续处理其他段
+             audioSegments.push({
+               url: null,
+               text: segment.text,
+               duration: 0,
+               startIndex: segment.startIndex,
+               endIndex: segment.endIndex,
+               segmentIndex: i,
+               error: true,
+               isSegmented: segments.length > 1,
+               originalText: text
+             });
+           }
+         } catch (error) {
+           console.error(`第 ${i + 1} 段音频请求异常:`, error);
+           audioSegments.push({
+             url: null,
+             text: segment.text,
+             duration: 0,
+             startIndex: segment.startIndex,
+             endIndex: segment.endIndex,
+             segmentIndex: i,
+             error: true,
+             isSegmented: segments.length > 1,
+             originalText: text
+           });
+         }
+         
+         // 每个请求之间间隔400ms，避免请求过于频繁
+         if (i < segments.length - 1) {
+           await new Promise(resolve => setTimeout(resolve, 400));
+         }
+       }
+       
+       console.log(`分批次音频请求完成，成功 ${audioSegments.filter(s => !s.error).length}/${segments.length} 段`);
+       
+       return {
+         audioSegments: audioSegments,
+         totalDuration: totalDuration,
+         originalText: text
+       };
+     },
+     
+     // 获取当前页面的音频内容
     async getCurrentPageAudio() {
       // 检查缓存中是否已有当前页面的音频数据
       const cacheKey = `${this.courseId}_${this.currentPage}`;
@@ -160,11 +347,21 @@ export default {
         this.currentAudioIndex = 0;
         this.isPlaying = false;
         this.currentTime = 0;
+        this.hasAudioData = true;
+        this.isAudioLoading = false;
+        
+        // 通知父组件音频状态变化
+        this.$emit('audio-state-change', {
+          hasAudioData: this.hasAudioData,
+          isLoading: this.isAudioLoading,
+          currentHighlightIndex: this.currentHighlightIndex
+        });
         return;
       }
       
       // 开始加载状态
       this.isAudioLoading = true;
+      this.hasAudioData = false;
       
       // 清空当前页面音频数组
       this.currentPageAudios = [];
@@ -173,6 +370,13 @@ export default {
       this.currentTime = 0;
       this.totalTime = 0;
       
+      // 通知父组件开始加载
+      this.$emit('audio-state-change', {
+        hasAudioData: this.hasAudioData,
+        isLoading: this.isAudioLoading,
+        currentHighlightIndex: this.currentHighlightIndex
+      });
+      
       // 对着当前页面的每一个[]元素进行切割 如果是文本text类型则进行音频请求
       const currentPageData = this.bookPages[this.currentPage - 1];
       if (currentPageData) {
@@ -180,72 +384,99 @@ export default {
         const textItems = currentPageData.filter(item => item.type === 'text');
         
         if (textItems.length > 0) {
-          // 并行发送所有音频请求
-          const audioPromises = textItems.map(async (item, index) => {
+          let firstAudioPlayed = false; // 标记是否已播放第一个音频
+          let loadedAudiosCount = 0; // 已加载的音频数量
+          
+          // 逐个处理文本项，支持长文本分割
+          for (let index = 0; index < textItems.length; index++) {
+            const item = textItems[index];
+            
             try {
-              // 进行音频请求 - 修正字段名：使用content而不是text
-              const radioRes = await this.$api.music.textToVoice({
-                text: item.content,
-                voiceType: this.voiceId,
-              });
-              console.log(`音频请求响应 ${index + 1}:`, radioRes);
+              console.log(`处理第 ${index + 1}/${textItems.length} 个文本项，长度: ${item.content.length}`);
+              
+              // 使用分批次请求音频
+              const batchResult = await this.requestAudioInBatches(item.content, this.voiceId);
               
-              if(radioRes.code === 200){
-                // 新格式：API直接返回音頻URL
-                const audioUrl = radioRes.result.audio;
-                // 檢查API是否返回時長信息
-                const duration = radioRes.result.duration || 0;
+              if (batchResult.audioSegments.length > 0) {
+                // 同时保存到原始数据中以保持兼容性（使用第一段的URL）
+                const firstValidSegment = batchResult.audioSegments.find(seg => !seg.error);
+                if (firstValidSegment) {
+                  item.audioUrl = firstValidSegment.url;
+                }
                 
-                // 同时保存到原始数据中以保持兼容性
-                item.audioUrl = audioUrl;
-                console.log(`音频URL设置成功 ${index + 1}:`, audioUrl, '时长:', duration);
+                // 将所有音频段添加到音频数组
+                for (const segment of batchResult.audioSegments) {
+                  if (!segment.error) {
+                    const audioData = {
+                      url: segment.url,
+                      text: segment.text,
+                      duration: segment.duration,
+                      startIndex: segment.startIndex,
+                      endIndex: segment.endIndex,
+                      segmentIndex: segment.segmentIndex,
+                      originalTextIndex: index, // 标记属于哪个原始文本项
+                      isSegmented: batchResult.audioSegments.length > 1 // 标记是否为分段音频
+                    };
+                    this.currentPageAudios.push(audioData);
+                    loadedAudiosCount++;
+                  }
+                }
                 
-                return {
-                  url: audioUrl,
-                  text: item.content,
-                  duration: duration, // 優先使用API返回的時長
-                  index: index // 保持原始顺序
-                };
+                // 如果是第一个音频，立即开始播放
+                if (!firstAudioPlayed && this.currentPageAudios.length > 0) {
+                  firstAudioPlayed = true;
+                  this.hasAudioData = true;
+                  this.currentAudioIndex = 0;
+                  
+                  console.log(`第一个音频时长: ${this.currentPageAudios[0].duration}秒`);
+                  
+                  // 通知父组件有音频数据了，但仍在加载中
+                  this.$emit('audio-state-change', {
+                    hasAudioData: this.hasAudioData,
+                    isLoading: this.isAudioLoading, // 保持加载状态
+                    currentHighlightIndex: this.currentHighlightIndex
+                  });
+                  
+                  // 立即创建音频实例并开始播放
+                  console.log('创建第一个音频实例并开始播放');
+                  this.createAudioInstance();
+                  
+                  // 等待音频实例准备好后开始播放
+                  setTimeout(() => {
+                    if (this.currentAudio && !this.isPlaying) {
+                      this.currentAudio.play();
+                      // isPlaying状态会在onPlay事件中自动设置
+                      this.updateHighlightIndex();
+                    }
+                  }, 100);
+                }
+                
+                console.log(`文本项 ${index + 1} 处理完成，获得 ${batchResult.audioSegments.filter(s => !s.error).length} 个音频段`);
               } else {
-                console.error(`音频请求失败 ${index + 1}:`, radioRes);
-                return null;
+                console.error(`文本项 ${index + 1} 音频请求全部失败`);
               }
             } catch (error) {
-              console.error(`音频请求异常 ${index + 1}:`, error);
-              return null;
+              console.error(`文本项 ${index + 1} 处理异常:`, error);
             }
-          });
-          
-          // 等待所有音频请求完成
-          const audioResults = await Promise.all(audioPromises);
-          
-          // 按原始顺序添加到音频数组中，过滤掉失败的请求
-          this.currentPageAudios = audioResults
-            .filter(result => result !== null)
-            .sort((a, b) => a.index - b.index)
-            .map(result => ({
-              url: result.url,
-              text: result.text,
-              duration: result.duration
-            }));
+          }
           
           console.log('所有音频请求完成，共获取', this.currentPageAudios.length, '个音频');
-        }
-        
-        // 如果有音频，计算总时长
-        if (this.currentPageAudios.length > 0) {
-          await this.calculateTotalDuration();
           
-          // 将音频数据保存到缓存中
-          const cacheKey = `${this.courseId}_${this.currentPage}`;
-          this.audioCache[cacheKey] = {
-            audios: [...this.currentPageAudios], // 深拷贝音频数组
-            totalDuration: this.totalTime
-          };
-          console.log('音频数据已缓存:', cacheKey, this.audioCache[cacheKey]);
-          
-          // 限制缓存大小
-          this.limitCacheSize(10);
+          // 如果有音频，重新计算精确的总时长
+          if (this.currentPageAudios.length > 0) {
+            await this.calculateTotalDuration();
+            
+            // 将音频数据保存到缓存中
+            const cacheKey = `${this.courseId}_${this.currentPage}`;
+            this.audioCache[cacheKey] = {
+              audios: [...this.currentPageAudios], // 深拷贝音频数组
+              totalDuration: this.totalTime
+            };
+            console.log('音频数据已缓存:', cacheKey, this.audioCache[cacheKey]);
+            
+            // 限制缓存大小
+            this.limitCacheSize(10);
+          }
         }
       }
       
@@ -265,6 +496,12 @@ export default {
     
     // 重置音频状态
     resetAudioState() {
+      // 先暂停当前播放的音频
+      if (this.isPlaying && this.currentAudio) {
+        this.pauseAudio();
+        console.log('翻页时暂停音频播放');
+      }
+      
       // 检查当前页面是否已有缓存的音频数据
       const pageKey = `${this.courseId}_${this.currentPage}`;
       const cachedAudio = this.audioCache[pageKey];
@@ -274,6 +511,12 @@ export default {
         this.currentPageAudios = cachedAudio.audios;
         this.totalTime = cachedAudio.totalDuration || 0;
         this.hasAudioData = true;
+        
+        // 自动播放预加载的音频
+        console.log('检测到预加载音频，准备自动播放');
+        this.$nextTick(() => {
+          this.autoPlayPreloadedAudio();
+        });
       } else {
         // 如果没有缓存的音频数据，重置为初始状态
         this.currentPageAudios = [];
@@ -333,28 +576,18 @@ export default {
       for (let i = 0; i < this.currentPageAudios.length; i++) {
         const audio = this.currentPageAudios[i];
         
-        // 優先使用API返回的時長信息
+        // 使用API返回的准确时长信息
         if (audio.duration && audio.duration > 0) {
-          console.log(`使用API返回的時長 ${i + 1}:`, audio.duration, '秒');
+          console.log(`使用API返回的准确时长 ${i + 1}:`, audio.duration, '秒');
           totalDuration += audio.duration;
-          continue;
-        }
-        
-        // 如果沒有API時長信息，嘗試獲取音頻時長
-        try {
-          const duration = await this.getAudioDuration(audio.url);
-          audio.duration = duration;
-          totalDuration += duration;
-          console.log(`獲取到音頻時長 ${i + 1}:`, duration, '秒');
-        } catch (error) {
-          console.error('获取音频时长失败:', error);
-          // 如果无法获取时长，根據文字長度估算（更精確的估算）
+        } else {
+          // 如果没有时长信息，使用文字长度估算（备用方案）
           const textLength = audio.text.length;
-          // 假設每分鐘可以讀150-200個字符，這裡用180作為平均值
-          const estimatedDuration = Math.max(2, textLength / 3); // 每3個字符約1秒
+          // 假设较快语速每分钟约300个字符，即每秒约5个字符
+          const estimatedDuration = Math.max(1, textLength / 5);
           audio.duration = estimatedDuration;
           totalDuration += estimatedDuration;
-          console.log(`估算音頻時長 ${i + 1}:`, estimatedDuration, '秒 (文字長度:', textLength, ')');
+          console.log(`备用估算音频时长 ${i + 1}:`, estimatedDuration, '秒 (文字长度:', textLength, ')');
         }
       }
       this.totalTime = totalDuration;
@@ -399,19 +632,7 @@ export default {
           }
         };
         
-        // 如果以上方法都無法獲取時長，嘗試播放一小段來獲取時長
-        audio.onPlay(() => {
-          console.log('音频开始播放，duration:', audio.duration);
-          if (!resolved) {
-            setTimeout(() => {
-              if (!resolved && audio.duration && audio.duration > 0) {
-                resolved = true;
-                resolve(audio.duration);
-                audio.destroy();
-              }
-            }, 100); // 播放100ms後檢查時長
-          }
-        });
+        // 移除onPlay監聽器，避免意外播放
         
         audio.onError((error) => {
           console.error('音频加载失败:', error);
@@ -422,11 +643,13 @@ export default {
           }
         });
         
-        // 設置較長的超時時間，並在超時前嘗試播放
+        // 設置較長的超時時間，但不播放音頻
         setTimeout(() => {
           if (!resolved) {
-            console.log('嘗試播放音頻以獲取時長');
-            audio.play();
+            console.log('無法獲取音頻時長，使用默認值');
+            resolved = true;
+            reject(new Error('無法獲取音頻時長'));
+            audio.destroy();
           }
         }, 1000);
         
@@ -466,12 +689,20 @@ export default {
       // 如果没有当前音频实例或者需要切换音频
       if (!this.currentAudio || this.currentAudio.src !== this.currentPageAudios[this.currentAudioIndex].url) {
         this.createAudioInstance();
+        // 创建实例后稍等一下再播放，确保音频准备就绪
+        setTimeout(() => {
+          if (this.currentAudio) {
+            this.currentAudio.play();
+            // isPlaying状态会在onPlay事件中自动设置
+            this.updateHighlightIndex();
+          }
+        }, 50);
+      } else {
+        // 音频实例已存在，直接播放
+        this.currentAudio.play();
+        // isPlaying状态会在onPlay事件中自动设置
+        this.updateHighlightIndex();
       }
-      
-      this.currentAudio.play();
-      this.isPlaying = true;
-      // 更新高亮状态
-      this.updateHighlightIndex();
     },
     
     // 暂停音频
@@ -483,16 +714,108 @@ export default {
       // 暂停时清除高亮
       this.currentHighlightIndex = -1;
       // 通知父组件高亮状态变化
-      this.$emit('highlight-change', -1);
+      this.emitHighlightChange(-1);
+    },
+    
+    // 播放指定的音频段落（通过文本内容匹配）
+    playSpecificAudio(textContent) {
+      console.log('尝试播放指定音频段落:', textContent);
+      
+      // 检查textContent是否有效
+      if (!textContent || typeof textContent !== 'string') {
+        console.log('无效的文本内容:', textContent);
+        uni.showToast({
+          title: '无效的文本内容',
+          icon: 'none'
+        });
+        return false;
+      }
+      
+      // 在当前页面音频数组中查找匹配的音频
+      let audioIndex = this.currentPageAudios.findIndex(audio => 
+        audio.text && audio.text.trim() === textContent.trim()
+      );
+      
+      // 如果直接匹配失败，尝试匹配分段音频
+      if (audioIndex === -1) {
+        console.log('直接匹配失败，尝试匹配分段音频');
+        
+        // 查找包含该文本的分段音频
+        audioIndex = this.currentPageAudios.findIndex(audio => {
+          if (!audio.text) return false;
+          
+          // 检查是否为分段音频，且原始文本包含目标文本
+          if (audio.isSegmented && audio.originalText) {
+            return audio.originalText.trim() === textContent.trim();
+          }
+          
+          // 检查目标文本是否包含在当前音频文本中，或者当前音频文本包含在目标文本中
+          const audioText = audio.text.trim();
+          const targetText = textContent.trim();
+          return audioText.includes(targetText) || targetText.includes(audioText);
+        });
+        
+        if (audioIndex !== -1) {
+          console.log('找到分段音频匹配，索引:', audioIndex);
+        }
+      }
+      
+      if (audioIndex !== -1) {
+        console.log('找到匹配的音频，索引:', audioIndex);
+        
+        // 停止当前播放的音频
+        if (this.currentAudio) {
+          this.currentAudio.pause();
+          this.currentAudio.destroy();
+          this.currentAudio = null;
+        }
+        
+        // 设置新的音频索引
+        this.currentAudioIndex = audioIndex;
+        
+        // 重置播放状态
+        this.isPlaying = false;
+        this.currentTime = 0;
+        this.sliderValue = 0;
+        
+        // 更新高亮索引
+        this.currentHighlightIndex = audioIndex;
+        this.emitHighlightChange(audioIndex);
+        
+        // 创建新的音频实例并播放
+        this.createAudioInstance();
+        
+        // 稍等一下再播放，确保音频准备就绪
+        setTimeout(() => {
+          if (this.currentAudio) {
+            this.currentAudio.play();
+            console.log('开始播放指定音频段落');
+          }
+        }, 100);
+        
+        return true; // 成功找到并播放
+      } else {
+        console.log('未找到匹配的音频段落:', textContent);
+        uni.showToast({
+          title: '未找到对应的音频',
+          icon: 'none'
+        });
+        return false; // 未找到匹配的音频
+      }
     },
     
     // 创建音频实例
     createAudioInstance() {
       // 销毁之前的音频实例
       if (this.currentAudio) {
+        this.currentAudio.pause();
         this.currentAudio.destroy();
+        this.currentAudio = null;
       }
       
+      // 重置播放状态
+      this.isPlaying = false;
+      
       // 優先使用微信原生API以支持playbackRate
       let audio;
       if (typeof wx !== 'undefined' && wx.createInnerAudioContext) {
@@ -589,19 +912,60 @@ export default {
     updateHighlightIndex() {
       if (!this.isPlaying || this.currentPageAudios.length === 0) {
         this.currentHighlightIndex = -1;
-        this.$emit('highlight-change', -1);
+        this.emitHighlightChange(-1);
         return;
       }
       
-      // 根据当前播放的音频索引设置高亮
-      this.currentHighlightIndex = this.currentAudioIndex;
-      console.log('更新高亮索引:', this.currentHighlightIndex, '当前音频索引:', this.currentAudioIndex);
+      // 获取当前播放的音频数据
+      const currentAudio = this.currentPageAudios[this.currentAudioIndex];
+      if (!currentAudio) {
+        this.currentHighlightIndex = -1;
+        this.emitHighlightChange(-1);
+        return;
+      }
       
-      // 通知父组件高亮状态变化
-      this.$emit('highlight-change', this.currentHighlightIndex);
+      // 如果是分段音频，需要计算正确的高亮索引
+      if (currentAudio.isSegmented && typeof currentAudio.originalTextIndex !== 'undefined') {
+        // 使用原始文本项的索引作为高亮索引
+        this.currentHighlightIndex = currentAudio.originalTextIndex;
+        console.log('分段音频高亮索引:', this.currentHighlightIndex, '原始文本索引:', currentAudio.originalTextIndex, '段索引:', currentAudio.segmentIndex);
+      } else {
+        // 非分段音频，使用音频索引
+        this.currentHighlightIndex = this.currentAudioIndex;
+        console.log('普通音频高亮索引:', this.currentHighlightIndex, '当前音频索引:', this.currentAudioIndex);
+      }
+      
+      // 使用辅助方法发送高亮变化事件
+      this.emitHighlightChange(this.currentAudioIndex);
     },
-    
-    // 音频播放结束处理
+     
+     // 发送高亮变化事件的辅助方法
+     emitHighlightChange(highlightIndex = -1) {
+       if (highlightIndex === -1) {
+         // 清除高亮
+         this.$emit('highlight-change', -1);
+         return;
+       }
+       
+       // 获取对应的音频数据
+       const audioData = this.currentPageAudios[highlightIndex];
+       if (!audioData) {
+         this.$emit('highlight-change', -1);
+         return;
+       }
+       
+       // 发送详细的高亮信息
+       this.$emit('highlight-change', {
+         highlightIndex: audioData.originalTextIndex !== undefined ? audioData.originalTextIndex : highlightIndex,
+         isSegmented: audioData.isSegmented || false,
+         segmentIndex: audioData.segmentIndex || 0,
+         startIndex: audioData.startIndex || 0,
+         endIndex: audioData.endIndex || 0,
+         currentText: audioData.text || ''
+       });
+     },
+     
+     // 音频播放结束处理
     onAudioEnded() {
       if (this.currentAudioIndex < this.currentPageAudios.length - 1) {
         // 播放下一个音频
@@ -976,12 +1340,8 @@ export default {
           
           // 檢查是否成功加載音頻
           if (this.currentPageAudios && this.currentPageAudios.length > 0) {
-            console.log('音頻加載成功，開始自動播放');
-            
-            // 稍微延遲一下確保音頻完全準備好
-            setTimeout(() => {
-              this.playAudio();
-            }, 500);
+            console.log('音頻加載成功，getCurrentPageAudio已經自動播放第一個音頻');
+            // getCurrentPageAudio方法已經處理了第一個音頻的播放，這裡不需要再次調用playAudio
           } else {
             console.log('第一頁沒有音頻數據');
           }
@@ -1006,6 +1366,216 @@ export default {
     // 暂停音频（页面隐藏时调用）
     pauseOnHide() {
       this.pauseAudio();
+    },
+    
+    // 开始预加载音频（由父组件调用）
+    async startPreloadAudio() {
+      if (this.isPreloading) {
+        console.log('已在预加载中，跳过');
+        return;
+      }
+      
+      try {
+        console.log('开始预加载音频数据');
+        this.isPreloading = true;
+        this.preloadProgress = 0;
+        
+        // 获取需要预加载的页面列表（当前页面后的几页）
+        const preloadPages = this.getPreloadPageList();
+        
+        if (preloadPages.length === 0) {
+          console.log('没有需要预加载的页面');
+          this.isPreloading = false;
+          return;
+        }
+        
+        console.log('需要预加载的页面:', preloadPages);
+        
+        // 逐个预加载页面音频
+        for (let i = 0; i < preloadPages.length; i++) {
+          const pageInfo = preloadPages[i];
+          
+          try {
+            console.log(`开始预加载第${pageInfo.pageIndex + 1}页音频`);
+            await this.preloadPageAudio(pageInfo.pageIndex, pageInfo.pageData);
+            
+            // 更新预加载进度
+            this.preloadProgress = Math.round(((i + 1) / preloadPages.length) * 100);
+            console.log(`预加载进度: ${this.preloadProgress}%`);
+            
+            // 延迟一下，避免请求过于频繁
+             await new Promise(resolve => setTimeout(resolve, 600));
+            
+          } catch (error) {
+            console.error(`预加载第${pageInfo.pageIndex + 1}页音频失败:`, error);
+            // 继续预加载其他页面
+          }
+        }
+        
+        console.log('音频预加载完成');
+        
+      } catch (error) {
+        console.error('预加载音频失败:', error);
+      } finally {
+        this.isPreloading = false;
+        this.preloadProgress = 100;
+      }
+    },
+    
+    // 获取需要预加载的页面列表
+    getPreloadPageList() {
+      const preloadPages = [];
+      const maxPreloadPages = 3; // 优化：最多预加载3页，减少服务器压力
+      
+      // 从当前页面的下一页开始预加载
+      for (let i = this.currentPage; i < Math.min(this.currentPage + maxPreloadPages, this.bookPages.length); i++) {
+        const pageData = this.bookPages[i];
+        
+        // 检查页面是否有文本内容且未缓存
+        if (pageData && pageData.length > 0) {
+          const hasTextContent = pageData.some(item => item.type === 'text' && item.content);
+          const cacheKey = `${this.courseId}_${i + 1}`;
+          const isAlreadyCached = this.audioCache[cacheKey];
+          
+          if (hasTextContent && !isAlreadyCached) {
+            preloadPages.push({
+              pageIndex: i,
+              pageData: pageData
+            });
+          }
+        }
+      }
+      
+      return preloadPages;
+    },
+    
+    // 预加载单个页面的音频
+    async preloadPageAudio(pageIndex, pageData) {
+      const cacheKey = `${this.courseId}_${pageIndex + 1}`;
+      
+      // 检查是否已经缓存
+      if (this.audioCache[cacheKey]) {
+        console.log(`第${pageIndex + 1}页音频已缓存，跳过`);
+        return;
+      }
+      
+      // 收集页面中的文本内容
+      const textItems = pageData.filter(item => item.type === 'text' && item.content);
+      
+      if (textItems.length === 0) {
+        console.log(`第${pageIndex + 1}页没有文本内容，跳过`);
+        return;
+      }
+      
+      console.log(`第${pageIndex + 1}页有${textItems.length}个文本段落需要预加载`);
+      
+      const audioArray = [];
+      let totalDuration = 0;
+      
+      // 逐个处理文本项，支持长文本分割
+      for (let i = 0; i < textItems.length; i++) {
+        const item = textItems[i];
+        
+        try {
+          console.log(`第${pageIndex + 1}页处理第 ${i + 1}/${textItems.length} 个文本项，长度: ${item.content.length}`);
+          
+          // 使用分批次请求音频
+          const batchResult = await this.requestAudioInBatches(item.content, this.voiceId);
+          
+          if (batchResult.audioSegments.length > 0) {
+            // 将所有音频段添加到音频数组
+            for (const segment of batchResult.audioSegments) {
+              if (!segment.error) {
+                audioArray.push({
+                  url: segment.url,
+                  text: segment.text,
+                  duration: segment.duration,
+                  startIndex: segment.startIndex,
+                  endIndex: segment.endIndex,
+                  segmentIndex: segment.segmentIndex,
+                  originalTextIndex: i, // 标记属于哪个原始文本项
+                  isSegmented: batchResult.audioSegments.length > 1 // 标记是否为分段音频
+                });
+                
+                totalDuration += segment.duration;
+              }
+            }
+            
+            console.log(`第${pageIndex + 1}页第${i + 1}个文本项预加载完成，获得 ${batchResult.audioSegments.filter(s => !s.error).length} 个音频段`);
+          } else {
+            console.error(`第${pageIndex + 1}页第${i + 1}个文本项音频预加载全部失败`);
+          }
+        } catch (error) {
+          console.error(`第${pageIndex + 1}页第${i + 1}个文本项处理异常:`, error);
+        }
+        
+        // 每个文本项处理之间间隔600ms，避免请求过于频繁
+        if (i < textItems.length - 1) {
+          await new Promise(resolve => setTimeout(resolve, 600));
+        }
+      }
+      
+      // 保存到缓存
+      if (audioArray.length > 0) {
+        this.audioCache[cacheKey] = {
+          audios: audioArray,
+          totalDuration: totalDuration
+        };
+        
+        console.log(`第${pageIndex + 1}页音频预加载完成，共${audioArray.length}个音频，总时长: ${totalDuration}秒`);
+        
+        // 限制缓存大小
+        this.limitCacheSize(10);
+      }
+    },
+    
+    // 检查指定页面是否有音频缓存
+    checkAudioCache(pageNumber) {
+      const cacheKey = `${this.courseId}_${pageNumber}`;
+      const cachedData = this.audioCache[cacheKey];
+      
+      if (cachedData && cachedData.audios && cachedData.audios.length > 0) {
+        console.log(`第${pageNumber}页音频已缓存，共${cachedData.audios.length}个音频`);
+        return true;
+      }
+      
+      console.log(`第${pageNumber}页音频未缓存`);
+      return false;
+    },
+    
+    // 自动播放已缓存的音频
+    async autoPlayCachedAudio() {
+      try {
+        const cacheKey = `${this.courseId}_${this.currentPage}`;
+        const cachedData = this.audioCache[cacheKey];
+        
+        if (!cachedData || !cachedData.audios || cachedData.audios.length === 0) {
+          console.log('当前页面没有缓存的音频');
+          return;
+        }
+        
+        console.log(`开始自动播放第${this.currentPage}页的缓存音频`);
+        
+        // 停止当前播放的音频
+        this.pauseAudio();
+        
+        // 设置当前页面的音频数据
+        this.currentPageAudios = cachedData.audios;
+        this.totalDuration = cachedData.totalDuration;
+        
+        // 重置播放状态
+        this.currentAudioIndex = 0;
+        this.currentTime = 0;
+        this.isPlaying = false;
+        
+        // 延迟一下再开始播放，确保UI更新完成
+        setTimeout(() => {
+          this.playAudio();
+        }, 300);
+        
+      } catch (error) {
+        console.error('自动播放缓存音频失败:', error);
+      }
     }
   },
   mounted() {
@@ -1051,6 +1621,46 @@ export default {
     });
   },
   
+  // 自动播放预加载的音频
+  async autoPlayPreloadedAudio() {
+    try {
+      // 检查是否有音频数据
+      if (!this.hasAudioData || this.currentPageAudios.length === 0) {
+        console.log('没有可播放的音频数据');
+        return;
+      }
+      
+      // 检查第一个音频是否有效
+      const firstAudio = this.currentPageAudios[0];
+      if (!firstAudio || !firstAudio.url) {
+        console.log('第一个音频无效');
+        return;
+      }
+      
+      console.log('开始自动播放预加载音频');
+      
+      // 重置播放状态
+      this.currentAudioIndex = 0;
+      this.currentTime = 0;
+      this.sliderValue = 0;
+      this.currentHighlightIndex = 0;
+      
+      // 创建音频实例
+      this.createAudioInstance();
+      
+      // 稍等一下再播放，确保音频准备就绪
+      setTimeout(() => {
+        if (this.currentAudio && !this.isPlaying) {
+          this.currentAudio.play();
+          console.log('预加载音频自动播放成功');
+        }
+      }, 200);
+      
+    } catch (error) {
+      console.error('自动播放预加载音频失败:', error);
+    }
+  },
+  
   beforeDestroy() {
     // 清理事件监听
     uni.$off('selectVoice');
@@ -1140,6 +1750,23 @@ export default {
   z-index: 10;
 }
 
+/* 加载指示器样式 */
+.loading-indicator {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  gap: 10rpx;
+  padding: 10rpx 20rpx;
+  background: rgba(6, 218, 220, 0.1);
+  border-radius: 20rpx;
+  margin-bottom: 10rpx;
+}
+
+.loading-indicator-text {
+  font-size: 24rpx;
+  color: #06DADC;
+}
+
 .loading-text {
   font-size: 28rpx;
   color: #999;
@@ -1174,6 +1801,35 @@ export default {
   box-shadow: 0 4rpx 10rpx rgba(6, 218, 220, 0.2);
 }
 
+/* 音频预加载提示样式 */
+.audio-preloaded-container {
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  padding: 20rpx;
+  transition: all 0.3s ease;
+  position: relative;
+  z-index: 10;
+}
+
+.preloaded-tip {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  gap: 16rpx;
+  padding: 20rpx 40rpx;
+  background: linear-gradient(135deg, #52c41a 0%, #389e0d 100%);
+  border-radius: 50rpx;
+  box-shadow: 0 8rpx 20rpx rgba(82, 196, 26, 0.3);
+  transition: all 0.3s ease;
+}
+
+.preloaded-text {
+  color: #ffffff;
+  font-size: 28rpx;
+  font-weight: 500;
+}
+
 .get-audio-text {
   font-size: 32rpx;
   color: #FFFFFF;
diff --git a/subPages/home/book.vue b/subPages/home/book.vue
index 00f3627..4826b16 100644
--- a/subPages/home/book.vue
+++ b/subPages/home/book.vue
@@ -40,9 +40,9 @@
               <image :src="configParamContent('highlight_icon')" class="card-line-image" mode="aspectFill" />
               <text class="card-line-text">划线重点</text>
             </view>
-            <view v-for="(item, index) in page"  :key="index">
-              <image class="card-image" v-if="item.type === 'image'" :src="item.imageUrl" mode="aspectFill"></image>
-              <view class="english-text-container" v-else-if="item.type === 'text' && item.language === 'en'">
+            <view v-for="(item, itemIndex) in page"  :key="itemIndex">
+              <image class="card-image" v-if="item && item.type === 'image'" :src="item.imageUrl" mode="aspectFill"></image>
+              <view class="english-text-container clickable-text" v-else-if="item && item.type === 'text' && item.language === 'en' && item.content" @click.stop="handleTextClick(item.content, item, index)">
                 <text 
                   v-for="(token, tokenIndex) in splitEnglishSentence(item.content)" 
                   :key="tokenIndex"
@@ -52,17 +52,19 @@
                   user-select
                 >{{ token.text }}</text>
               </view>
-              <text class="chinese-text" v-else-if="item.type === 'text' && item.language === 'zh'" user-select>{{ item.content }}</text>
+              <view v-else-if="item && item.type === 'text' && item.language === 'zh' && item.content" @click.stop="handleTextClick(item.content, item, index)">
+                <text class="chinese-text clickable-text" user-select>{{ item.content }}</text>
+              </view>
             </view>
           </view>
 
           <view v-else>  
-            <view v-for="(item, index) in page" :key="index">
+            <view v-for="(item, itemIndex) in page" :key="itemIndex">
               <!-- 文本页面 -->
-              <view v-if="item.type === 'text'" class="text-content" >
-                <view :class="{ 'text-highlight': isTextHighlighted(page, index) }">
+              <view v-if="item && item.type === 'text' && item.content" class="text-content" >
+                <view :class="{ 'text-highlight': isTextHighlighted(page, itemIndex) }" @click.stop="handleTextClick(item.content, item, index)">
                   <text 
-                  class="content-text" 
+                  class="content-text clickable-text" 
                   user-select
                   >
                   {{ item.content }}
@@ -318,9 +320,103 @@ export default {
       this.currentHighlightIndex = audioState.currentHighlightIndex;
     },
     
-    onHighlightChange(highlightIndex) {
-      // 更新高亮索引
-      this.currentHighlightIndex = highlightIndex;
+    // 处理文本点击事件
+    handleTextClick(textContent, item, pageIndex) {
+      console.log('点击文本:', textContent);
+      console.log('textContent类型:', typeof textContent);
+      console.log('textContent是否为undefined:', textContent === undefined);
+      console.log('完整item对象:', item);
+      console.log('item.content:', item ? item.content : 'item为空');
+      console.log('当前页面索引:', this.currentPage);
+      console.log('点击的页面索引:', pageIndex);
+      console.log('当前页面数据:', this.bookPages[this.currentPage - 1]);
+      console.log('页面数据长度:', this.bookPages[this.currentPage - 1] ? this.bookPages[this.currentPage - 1].length : '页面不存在');
+      
+      // 检查是否点击的是当前页面
+      if (pageIndex !== undefined && pageIndex !== this.currentPage - 1) {
+        console.log('点击的不是当前页面，忽略点击事件');
+        return;
+      }
+      
+      // 验证参数有效性
+      if (!item) {
+        console.error('handleTextClick: item参数为空');
+        uni.showToast({
+          title: '数据错误，请刷新页面',
+          icon: 'none'
+        });
+        return;
+      }
+      
+      // 如果textContent为undefined，尝试从item中获取
+      if (!textContent && item && item.content) {
+        textContent = item.content;
+        console.log('从item中获取到content:', textContent);
+      }
+      
+      // 最终验证textContent
+      if (!textContent || typeof textContent !== 'string' || textContent.trim() === '') {
+        console.error('handleTextClick: 无效的文本内容', textContent);
+        uni.showToast({
+          title: '文本内容无效',
+          icon: 'none'
+        });
+        return;
+      }
+      
+      // 检查是否有音频控制组件的引用
+      if (!this.$refs.audioControls) {
+        console.log('音频控制组件未找到');
+        uni.showToast({
+          title: '音频控制组件未准备好',
+          icon: 'none'
+        });
+        return;
+      }
+      
+      // 检查当前页面是否为文本页面
+      if (!this.isTextPage) {
+        console.log('当前页面不是文本页面');
+        uni.showToast({
+          title: '当前页面不支持音频播放',
+          icon: 'none'
+        });
+        return;
+      }
+      
+      // 调用AudioControls组件的播放指定音频方法
+      const success = this.$refs.audioControls.playSpecificAudio(textContent);
+      
+      if (success) {
+        console.log('成功播放指定音频段落');
+      } else {
+        console.log('播放指定音频段落失败');
+      }
+    },
+    
+    onHighlightChange(highlightData) {
+      // 兼容旧格式（直接传递索引）和新格式（传递对象）
+      if (typeof highlightData === 'number') {
+        // 旧格式：直接是索引
+        this.currentHighlightIndex = highlightData;
+      } else if (typeof highlightData === 'object' && highlightData !== null) {
+        // 新格式：包含详细信息的对象
+        this.currentHighlightIndex = highlightData.highlightIndex;
+        
+        // 可以在这里处理分段音频的额外信息
+        if (highlightData.isSegmented) {
+          console.log('分段音频高亮:', {
+            highlightIndex: highlightData.highlightIndex,
+            segmentIndex: highlightData.segmentIndex,
+            startIndex: highlightData.startIndex,
+            endIndex: highlightData.endIndex,
+            currentText: highlightData.currentText
+          });
+        }
+      } else {
+        // 清除高亮
+        this.currentHighlightIndex = -1;
+      }
     },
     
 
@@ -409,9 +505,9 @@ export default {
         console.log('單詞語音API響應:', audioRes);
 
         // 檢查響應並播放音頻
-        if (audioRes && audioRes.result && audioRes.result.audio) {
-          // 新格式：直接使用返回的音頻URL
-          const audioUrl = audioRes.result.audio;
+        if (audioRes && audioRes.result && audioRes.result.url) {
+          // 新格式：使用返回的url字段
+          const audioUrl = audioRes.result.url;
           
           // 創建並播放音頻
           const audio = uni.createInnerAudioContext();
@@ -1203,9 +1299,19 @@ export default {
         await this.getBookPages(this.courseIdList[this.currentPage - 1]);
       }
       
-      // 通知音频控制组件重置状态
+      // 通知音频控制组件处理页面切换
       if (this.$refs.audioControls) {
-        this.$refs.audioControls.resetAudioState();
+        // 检查当前页面是否有预加载的音频缓存
+        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) {
@@ -1215,9 +1321,19 @@ export default {
         await this.getBookPages(this.courseIdList[this.currentPage - 1]);
       }
       
-      // 通知音频控制组件重置状态
+      // 通知音频控制组件处理页面切换
       if (this.$refs.audioControls) {
-        this.$refs.audioControls.resetAudioState();
+        // 检查当前页面是否有预加载的音频缓存
+        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) {
@@ -1241,6 +1357,8 @@ export default {
         // 初始化第一页
         if (this.courseIdList.length > 0) {
           await this.getBookPages(this.courseIdList[0])
+          // 预加载后续几页的内容（异步执行，不阻塞当前页面显示）
+          this.preloadNextPages()
         }
       }
     },
@@ -1250,10 +1368,18 @@ export default {
       })
       if (res.code === 200) {
         // 使用$set确保响应式更新
-        console.log('获取到的页面数据:', JSON.parse(res.result.content))
+        const rawPageData = JSON.parse(res.result.content)
+        console.log('获取到的原始页面数据:', rawPageData)
+        
+        // 过滤掉无效的数据项
+        const filteredPageData = rawPageData.filter(item => {
+          return item && typeof item === 'object' && (item.type || item.content)
+        })
+        console.log('过滤后的页面数据:', filteredPageData)
+        
         // 确保当前页面存在
         if (this.currentPage - 1 < this.bookPages.length) {
-          this.$set(this.bookPages, this.currentPage - 1, JSON.parse(res.result.content))
+          this.$set(this.bookPages, this.currentPage - 1, filteredPageData)
           // 保存页面标题
           this.$set(this.pageTitles, this.currentPage - 1, res.result.title || '')
           // 保存页面类型
@@ -1304,6 +1430,75 @@ export default {
         console.log('缓存大小已限制，删除了', keysToDelete.length, '个缓存项');
       }
     },
+    
+    // 预加载后续页面内容
+    async preloadNextPages() {
+      try {
+        console.log('开始预加载后续页面内容');
+        
+        // 优化策略：只预加载接下来的2-3页内容，避免过多请求
+        const preloadCount = Math.min(3, this.courseIdList.length - 1); // 预加载3页或剩余页数
+        
+        // 串行预加载，避免并发请求过多
+        for (let i = 1; i <= preloadCount; i++) {
+          if (i < this.courseIdList.length && this.bookPages[i].length === 0) {
+            try {
+              console.log(`预加载第${i + 1}页内容`);
+              await this.preloadSinglePage(this.courseIdList[i], i);
+              
+              // 每页之间间隔800ms，给服务器更多缓冲时间
+              if (i < preloadCount) {
+                await new Promise(resolve => setTimeout(resolve, 800));
+              }
+            } catch (error) {
+              console.error(`预加载第${i + 1}页失败:`, error);
+              // 继续预加载下一页
+            }
+          }
+        }
+        
+        console.log('页面内容预加载完成');
+        
+        // 延迟1.5秒后再通知AudioControls组件开始预加载音频，避免接口冲突
+        setTimeout(() => {
+          if (this.$refs.audioControls) {
+            this.$refs.audioControls.startPreloadAudio();
+          }
+        }, 1500);
+        
+      } catch (error) {
+        console.error('预加载页面内容失败:', error);
+      }
+    },
+    
+    // 预加载单个页面
+    async preloadSinglePage(courseId, pageIndex) {
+      try {
+        const res = await this.$api.book.coursesPageDetail({
+          id: courseId
+        });
+        
+        if (res.code === 200) {
+          const rawPageData = JSON.parse(res.result.content);
+          const filteredPageData = rawPageData.filter(item => {
+            return item && typeof item === 'object' && (item.type || item.content);
+          });
+          
+          // 使用$set确保响应式更新
+          this.$set(this.bookPages, pageIndex, filteredPageData);
+          this.$set(this.pageTitles, pageIndex, res.result.title || '');
+          this.$set(this.pageTypes, pageIndex, res.result.type || '');
+          this.$set(this.pageWords, pageIndex, res.result.words || []);
+          this.$set(this.pagePay, pageIndex, res.result.pay || 'N');
+          
+          console.log(`第${pageIndex + 1}页内容预加载完成`);
+        }
+      } catch (error) {
+        console.error(`预加载第${pageIndex + 1}页失败:`, error);
+        throw error;
+      }
+    },
+    
       // 自動加載第一頁音頻並播放
   async autoLoadAndPlayFirstPage() {
     try {
@@ -1318,12 +1513,8 @@ export default {
         
         // 檢查是否成功加載音頻
         if (this.currentPageAudios && this.currentPageAudios.length > 0) {
-          console.log('音頻加載成功，開始自動播放');
-          
-          // 稍微延遲一下確保音頻完全準備好
-          setTimeout(() => {
-            this.playAudio();
-          }, 500);
+          console.log('音頻加載成功，getCurrentPageAudio已經自動播放第一個音頻');
+          // getCurrentPageAudio方法已經處理了第一個音頻的播放，這裡不需要再次調用playAudio
         } else {
           console.log('第一頁沒有音頻數據');
         }
@@ -1635,6 +1826,16 @@ export default {
   transition: all 0.3s ease;
 }
 
+.clickable-text {
+  cursor: pointer;
+
+  
+  &:active {
+    background-color: rgba(6, 218, 220, 0.1);
+    border-radius: 4rpx;
+  }
+}
+
 .text-highlight {
   background-color: $primary-color;
   // color: #fff;