今天终于搞成啦 一楼提供整套源码  算是半成品吧



mark一下

1. package com.mycompany.myapp;
   
2. 
   
3. 
   
4. /*2023-8-6首发于无忧论坛   作者无忧2011阿星      无忧879792799整理修改*/
   
5. 
   
6. /*此源码无恶意代码且简单需要编译才能成apk  仅十几k 只需读存储权限  编译器有的会带病毒不建议新手使用*/
   
7. 
   
8. 
   
9.     import android.app.Activity;
   
10.     import android.os.Bundle;
    
11. 
    
12.         import android.app.Activity;
    
13.         import android.app.ProgressDialog;
    
14.         import android.content.Intent;
    
15.         import android.media.MediaPlayer;
    
16.         import android.media.MediaPlayer.OnCompletionListener;
    
17.         import android.media.MediaPlayer.OnErrorListener;
    
18.         import android.media.MediaPlayer.OnPreparedListener;
    
19.         import android.os.Bundle;
    
20.         import android.os.Environment;
    
21.         import android.os.Handler;
    
22.         import android.os.Build;
    
23.         import android.os.Handler;
    
24.         import android.os.Message;
    
25.         import android.view.Gravity;
    
26.         import android.view.LayoutInflater;
    
27.         import android.view.View;
    
28.         import android.widget.Toast;
    
29.         import android.app.*;
    
30.         import android.os.*;
    
31.         import android.widget.*;
    
32.         import java.util.*;
    
33.         import android.content.*;
    
34.         import java.text.*;
    
35.         import java.io.*;
    
36.     import android.view.View.OnClickListener;
    
37.     import android.widget.AdapterView.OnItemClickListener;
    
38.         
    
39.         
    
40. 
    
41. public class MainActivity extends Activity    {                //每个APP都有一个默认界面
    
42. 
    
43. 
    
44. 
    
45.     private MediaPlayer mediaPlayer;
    
46.     private List<String> audioFiles;                     //把文件夹的音频排成一个数组
    
47.     private int currentIndex = 0;                       //数组的下标
    
48.    
    
49.     private Handler handler;          //多线程  貌似没起作用
    
50. 
    
51.     @Override
    
52.     protected void onCreate(Bundle savedInstanceState) {
    
53.         super.onCreate(savedInstanceState);                      //APP程序入口 从此往下执行
    
54.         setContentView(R.layout.activity_main);                  //绑定主界面的布局文件
    
55. 
    
56.         // 初始化MediaPlayer
    
57.         mediaPlayer = new MediaPlayer();
    
58. 
    
59. 
    
60.             // 获取音频文件列表
    
61.                 audioFiles = getAudioFiles("/sdcard/NX/");          //在根目录自己新建NX文件夹
    
62.         
    
63.         // 开始播放
    
64.         playNextAudio();
    
65.                 }
    
66.    
    
67. 
    
68.     private List<String> getAudioFiles(String folderPath) {            //定义音频文件集合而成数组
    
69.         List<String> files = new ArrayList<>();
    
70.         File folder = new File(folderPath);
    
71.         File[] audioFiles = folder.listFiles(new FilenameFilter() {
    
72.                                 @Override
    
73.                                 public boolean accept(File dir, String name) {
    
74.                                         return name.toLowerCase().endsWith(".mp3"); // 可根据需要修改文件类型  筛选文件后缀名
    
75.                                 }
    
76.                         });
    
77. 
    
78.         if (audioFiles != null) {
    
79.             for (File file : audioFiles) {
    
80.                 files.add(file.getAbsolutePath());          //加入数组中
    
81.             }
    
82.         }
    
83.         return files;
    
84.     }
    
85. 
    
86.     private void playNextAudio() {
    
87.         if (currentIndex >= audioFiles.size()) {        //数组下标大于音频总数就返回
    
88.             // 播放列表已结束
    
89.             return;
    
90.         }
    
91. 
    
92.         String audioFile = audioFiles.get(currentIndex);       //逐个提取音频文件
    
93. 
    
94.       
    
95.             mediaPlayer.reset();
    
96.                 try {
    
97.                         mediaPlayer.setDataSource(audioFile);     //把数组中逐个提取音频给播放器
    
98.                 } catch (IOException e) {} catch (IllegalStateException e) {} catch (IllegalArgumentException e) {} catch (SecurityException e) {}
    
99.                 try {
    
100.                         mediaPlayer.prepare();      //播放器准备
     
101.                 } catch (IOException e) {} catch (IllegalStateException e) {}
     
102. 
     
103.                 //        mediaPlayer.seekTo(10000);
     
104.             mediaPlayer.start();         //播放器开始播放
     
105. 
     
106. 
     
107.   // 复读第10秒到第20秒这个区间的音频  
     
108. 
     
109.                 // 随机选择播放时间点
     
110.                 int duration = mediaPlayer.getDuration();     //获取当前音频的总时长
     
111.                
     
112.                 if(duration>60000){          //假如音频时长大于1分钟就往下执行 否则就跳到下一音频
     
113.                         
     
114.                         Random random = new Random();         //准备随机
     
115.                         int startPos= random.nextInt(duration - 60000); // 播放开始点A 随机时间点不能是最后1分钟 防止播放时间太短就结束了
     
116. 
     
117.                         //     int startPos = 160000;  
     
118.                         int endPos = startPos+10000;        //播放结束时间点B  结束时间是开始时间往后10秒
     
119. 
     
120. // Try to play three times  
     
121.                         try {
     
122.                                 repeatAToB(startPos, endPos, 1);    //从开始时间到结束时间播放  且播放重复一遍
     
123.                         } catch (Exception e) {}  
     
124.         
     
125.                         
     
126.                 }
     
127.                
     
128.                
     
129.                 else{
     
130.                         
     
131.                         currentIndex++;        //再把音频数组下标加一位，就是下一个音频文件
     
132.                         playNextAudio();      //再次从playNextAudio处执行
     
133.                 }
     
134.         
     
135.         
     
136. 
     
137.            
     
138.                         
     
139. //                currentIndex++;
     
140. //        if (currentIndex < audioFiles.size()) {
     
141. //            // 继续播放下一首音频
     
142. //            playNextAudio();
     
143. //        } else {
     
144. //            // 播放列表已结束
     
145. //         
     
146. //        }
     
147. //                        
     
148.         
     
149.     }
     
150. 
     
151. 
     
152. 
     
153. 
     
154. private void repeatAToB(final int startPos, final int endPos, final int repeatTimes)throws Exception {          //这个方法就是从随机起始点A播放A播放到结束时间点B
     
155.   
     
156.         mediaPlayer.seekTo(startPos);  
     
157.        mediaPlayer.start();  
     
158.         CountDownTimer cntr_aCounter = new CountDownTimer(/* millisInFuture= */endPos - startPos, /* countDownInterval= */1000) {     //倒计时方法
     
159.             public void onTick(long millisUntilFinished) {  
     
160.                 // DO SOMETHING  
     
161.             }  
     
162.   
     
163.             public void onFinish() {  
     
164.                 // Code fire after finish  
     
165.                 if((repeatTimes - 1) > 0){  
     
166.                     try {  
     
167.                         repeatAToB(startPos, endPos, repeatTimes - 1);  
     
168.                     } catch (Exception e) {  
     
169.                         e.printStackTrace();  
     
170.                     }  
     
171.                 }else{  
     
172.             mediaPlayer.stop();  
     
173.                                 currentIndex++;
     
174.                                 playNextAudio();
     
175.          
     
176.          
     
177.           }  
     
178.             }  
     
179.         };  
     
180.         cntr_aCounter.start();  
     
181.     }  
     
182. 
     
183. 
     
184. 
     
185. 
     
186. 
     
187. 
     
188. 
     
189. 
     
190.     @Override
     
191.     protected void onDestroy() {
     
192.         super.onDestroy();
     
193.         mediaPlayer.release();
     
194.         handler.removeCallbacksAndMessages(null);
     
195.     }}
     

复制代码

cduser 发表于 2023-8-5 08:47
这是要横空出世大杀器么

谈不上吧  个人感觉比较实用这个功能

这是手机apk就是面对数量庞大的音频 每个音频只听其中任意2分钟就跳到下一首
【目的】就是快速了解或者说预览大数量音频的内容  
           【比如喜马拉雅专辑或者网盘分享一下载就上百集 逐个听太难了】

这是要横空出世大杀器么

2011阿星 发表于 2023-8-4 15:54

谢谢大神！估计能行     不懂再来请教哈！

强得我看不懂

GitHub开源,估计会有不少思路...

坐等大神出手 占楼备用！

  ======================================================

求大神写一小段MediaPlayer类 播放代码！！

https://blog.csdn.net/nanoage/article/details/127363147


【非整套代码】音频播放器代码框架已经搭好了     

自带MediaPlayer代码是从头播放到尾然后播放下一个音频【下面是常见调用代码】
MediaPlayer的工作流程是这样的：

1、首先创建MediaPlaer对象；

2、然后调用setDataSource()方法来设置音频文件的路径；

3 、再调用prepare()方法使MediaPlayer进入到准备状态；

4 、调用start方法就可以播放音频。

      mPlayer = new MediaPlayer();               实例化   

      mPlayer.setDataSource(mAudioFileName);      设置需要播放mp3的路径

      mPlayer.prepare();            准备

      mPlayer.start();         开始播放

      mPlayer.setLooping(true);   设置循环模式

MediaPlayer其相关方法有：

       void seekTo(int msec)：从指定位置播放，参数为用毫秒定义的位置

       int getDuration()：得到音频长度，即总的毫秒数

       void setVolume(float leftVolume, float rightVolume)：设置音量


==================以下搜索得来 仅供参考==================

MediaPlayer其主要方法有：


void setDataSource(String path)：设置要播放的音频文件位置，参数path为文件路径或Uri
void prepare()：setDataSource并不载入资源，需要调用此方法准备资源
void start()：开始/恢复播放
void stop()：停止播放，调用后无法再播放
void pause()：暂停播放，可以再用start恢复播放
void reset()：重置到刚刚创建后的状态
void release()：释放掉相关的资源
void seekTo(int msec)：从指定位置播放，参数为用毫秒定义的位置
int getCurrentPosition()：得到当前播放位置，即播放的毫秒数
int getDuration()：得到音频长度，即总的毫秒数
boolean isPlaying()：得到当前音频是否正在播放
void setLooping(boolean looping) / boolean isLooping()：循环播放
void setVolume(float leftVolume, float rightVolume)：设置音量


https://www.iteye.com/blog/deyum-1459255
https://blog.csdn.net/speedpower/article/details/84172071

近日在做一个的小应用，被MP3AB段复读的功能困扰了很久，最后终于在网上找到一个解决方法，

就是使用CountDownTimer让MediaPlayer只播放MP3的某个区段，轻松解决了AB段复读的功能。详细代码如下：

      // 复读第10秒到第20秒这个区间的音频  
        int startPos = 10000;  
        int endPos = 20000;  
   
        mMediaPlayer.seekTo(startPos);  
        mMediaPlayer.start();  
        CountDownTimer cntr_aCounter = new CountDownTimer(/* millisInFuture= */endPos - startPos, /* countDownInterval= */1000) {  
            public void onTick(long millisUntilFinished) {  
         
            }  

1. public void play(final String filePath) throws Exception {  
   
2.     try {  
   
3.         if (mMediaPlayer == null) {  
   
4.             // 创建MediaPlayer对象并设置Listener  
   
5.             mMediaPlayer = new MediaPlayer();  
   
6.         } else {  
   
7.             // 复用MediaPlayer对象  
   
8.             mMediaPlayer.reset();  
   
9.         }  
   
10.         mMediaPlayer.setDataSource(filePath);  
    
11.         mMediaPlayer.prepare();  
    
12.         mMediaPlayer.setVolume(10.f, 1.0f);  
    
13.   
    
14.         // 复读第10秒到第20秒这个区间的音频  
    
15.         int startPos = 10000;  
    
16.         int endPos = 20000;  
    
17.         // Try to play three times  
    
18.         repeatAToB(startPos, endPos, 3);  
    
19.   
    
20.     } catch (Exception e) {  
    
21.         e.printStackTrace();  
    
22.     }  
    
23. }  
    
24.   
    
25. private void repeatAToB(final int startPos, final int endPos, final int repeatTimes)throws Exception {  
    
26.   
    
27.         mMediaPlayer.seekTo(startPos);  
    
28.         mMediaPlayer.start();  
    
29.         CountDownTimer cntr_aCounter = new CountDownTimer(/* millisInFuture= */endPos - startPos, /* countDownInterval= */1000) {  
    
30.             public void onTick(long millisUntilFinished) {  
    
31.                 // DO SOMETHING  
    
32.             }  
    
33.   
    
34.             public void onFinish() {  
    
35.                 // Code fire after finish  
    
36.                 if((repeatTimes - 1) > 0){  
    
37.                     try {  
    
38.                         repeatAToB(startPos, endPos, repeatTimes - 1);  
    
39.                     } catch (Exception e) {  
    
40.                         e.printStackTrace();  
    
41.                     }  
    
42.                 }else{  
    
43.                     mMediaPlayer.stop();  
    
44.                 }  
    
45.             }  
    
46.         };  
    
47.         cntr_aCounter.start();  
    
48.     }

复制代码

==================以上搜索得来 仅供参考==================



一下备份一下阿星大神的原帖 防止修改后看不懂

1.    作者 无忧阿星2011
   
2. 
   
3. private MediaPlayer mediaPlayer;
   
4.     private List<String> audioFiles;
   
5.     private int currentIndex = 0;
   
6.     private boolean isPlaying = false;
   
7.     private Handler handler;
   
8. 
   
9.     @Override
   
10.     protected void onCreate(Bundle savedInstanceState) {
    
11.         super.onCreate(savedInstanceState);
    
12.         setContentView(R.layout.activity_main);
    
13. 
    
14.         // 初始化MediaPlayer
    
15.         mediaPlayer = new MediaPlayer();
    
16.         mediaPlayer.setOnCompletionListener(this);
    
17. 
    
18.         // 获取音频文件列表
    
19.         audioFiles = getAudioFiles("/path");
    
20. 
    
21.         // 创建Handler用于处理定时任务
    
22.         handler = new Handler(new Handler.Callback() {
    
23.             @Override
    
24.             public boolean handleMessage(Message msg) {
    
25.                 if (isPlaying) {
    
26.                     mediaPlayer.pause();
    
27.                     mediaPlayer.seekTo(msg.arg1);
    
28.                     mediaPlayer.start();
    
29.                 }
    
30.                 return true;
    
31.             }
    
32.         });
    
33. 
    
34.         // 开始播放
    
35.         playNextAudio();
    
36.     }
    
37. 
    
38.     private List<String> getAudioFiles(String folderPath) {
    
39.         List<String> files = new ArrayList<>();
    
40.         File folder = new File(folderPath);
    
41.         File[] audioFiles = folder.listFiles(new FilenameFilter() {
    
42.             @Override
    
43.             public boolean accept(File dir, String name) {
    
44.                 return name.toLowerCase().endsWith(".mp3"); // 可根据需要修改文件类型
    
45.             }
    
46.         });
    
47. 
    
48.         if (audioFiles != null) {
    
49.             for (File file : audioFiles) {
    
50.                 files.add(file.getAbsolutePath());
    
51.             }
    
52.         }
    
53.         return files;
    
54.     }
    
55. 
    
56.     private void playNextAudio() {
    
57.         if (currentIndex >= audioFiles.size()) {
    
58.             // 播放列表已结束
    
59.             return;
    
60.         }
    
61. 
    
62.         String audioFile = audioFiles.get(currentIndex);
    
63. 
    
64.         try {
    
65.             mediaPlayer.reset();
    
66.             mediaPlayer.setDataSource(audioFile);
    
67.             mediaPlayer.prepare();
    
68.             mediaPlayer.start();
    
69. 
    
70.             // 随机选择播放时间点
    
71.             int duration = mediaPlayer.getDuration();
    
72.             Random random = new Random();
    
73.             int randomTime = random.nextInt(duration - 120000); // 随机时间点不能是最后2分钟
    
74.             int delay = randomTime - mediaPlayer.getCurrentPosition();
    
75. 
    
76.             // 发送定时任务消息
    
77.             Message message = handler.obtainMessage();
    
78.             message.arg1 = randomTime;
    
79.             handler.sendMessageDelayed(message, delay);
    
80. 
    
81.             isPlaying = true;
    
82.         } catch (IOException e) {
    
83.             e.printStackTrace();
    
84.         }
    
85.     }
    
86. 
    
87.     @Override
    
88.     public void onCompletion(MediaPlayer mp) {
    
89.         // 音频播放完成
    
90.         currentIndex++;
    
91.         if (currentIndex < audioFiles.size()) {
    
92.             // 继续播放下一首音频
    
93.             playNextAudio();
    
94.         } else {
    
95.             // 播放列表已结束
    
96.             isPlaying = false;
    
97.         }
    
98.     }
    
99. 
    
100.     @Override
     
101.     protected void onDestroy() {
     
102.         super.onDestroy();
     
103.         mediaPlayer.release();
     
104.         handler.removeCallbacksAndMessages(null);
     
105.     }

复制代码

1.     private MediaPlayer mediaPlayer;
   
2.     private List<String> audioFiles;
   
3.     private int currentIndex = 0;
   
4.     private boolean isPlaying = false;
   
5.     private Handler handler;
   
6. 
   
7.     @Override
   
8.     protected void onCreate(Bundle savedInstanceState) {
   
9.         super.onCreate(savedInstanceState);
   
10.         setContentView(R.layout.activity_main);
    
11. 
    
12.         // 初始化MediaPlayer
    
13.         mediaPlayer = new MediaPlayer();
    
14.         mediaPlayer.setOnCompletionListener(this);
    
15. 
    
16.         // 获取音频文件列表
    
17.         audioFiles = getAudioFiles("/path");
    
18. 
    
19.         // 创建Handler用于处理定时任务
    
20.         handler = new Handler(new Handler.Callback() {
    
21.             @Override
    
22.             public boolean handleMessage(Message msg) {
    
23.                 if (isPlaying) {
    
24.                     mediaPlayer.pause();
    
25.                     mediaPlayer.seekTo(msg.arg1);
    
26.                     mediaPlayer.start();
    
27.                 }
    
28.                 return true;
    
29.             }
    
30.         });
    
31. 
    
32.         // 开始播放
    
33.         playNextAudio();
    
34.     }
    
35. 
    
36.     private List<String> getAudioFiles(String folderPath) {
    
37.         List<String> files = new ArrayList<>();
    
38.         File folder = new File(folderPath);
    
39.         File[] audioFiles = folder.listFiles(new FilenameFilter() {
    
40.             @Override
    
41.             public boolean accept(File dir, String name) {
    
42.                 return name.toLowerCase().endsWith(".mp3"); // 可根据需要修改文件类型
    
43.             }
    
44.         });
    
45. 
    
46.         if (audioFiles != null) {
    
47.             for (File file : audioFiles) {
    
48.                 files.add(file.getAbsolutePath());
    
49.             }
    
50.         }
    
51.         return files;
    
52.     }
    
53. 
    
54.     private void playNextAudio() {
    
55.         if (currentIndex >= audioFiles.size()) {
    
56.             // 播放列表已结束
    
57.             return;
    
58.         }
    
59. 
    
60.         String audioFile = audioFiles.get(currentIndex);
    
61. 
    
62.         try {
    
63.             mediaPlayer.reset();
    
64.             mediaPlayer.setDataSource(audioFile);
    
65.             mediaPlayer.prepare();
    
66.             mediaPlayer.start();
    
67. 
    
68.             // 随机选择播放时间点
    
69.             int duration = mediaPlayer.getDuration();
    
70.             Random random = new Random();
    
71.             int randomTime = random.nextInt(duration - 120000); // 随机时间点不能是最后2分钟
    
72.             int delay = randomTime - mediaPlayer.getCurrentPosition();
    
73. 
    
74.             // 发送定时任务消息
    
75.             Message message = handler.obtainMessage();
    
76.             message.arg1 = randomTime;
    
77.             handler.sendMessageDelayed(message, delay);
    
78. 
    
79.             isPlaying = true;
    
80.         } catch (IOException e) {
    
81.             e.printStackTrace();
    
82.         }
    
83.     }
    
84. 
    
85.     @Override
    
86.     public void onCompletion(MediaPlayer mp) {
    
87.         // 音频播放完成
    
88.         currentIndex++;
    
89.         if (currentIndex < audioFiles.size()) {
    
90.             // 继续播放下一首音频
    
91.             playNextAudio();
    
92.         } else {
    
93.             // 播放列表已结束
    
94.             isPlaying = false;
    
95.         }
    
96.     }
    
97. 
    
98.     @Override
    
99.     protected void onDestroy() {
    
100.         super.onDestroy();
     
101.         mediaPlayer.release();
     
102.         handler.removeCallbacksAndMessages(null);
     
103.     }

复制代码