Android AsyncPlayer

转至：http://blog.csdn.net/boywgw/article/details/8158050

类概述

        AsyncPlayer是android实现异步音乐播放的一个类,它将要播放的媒体文件封装成内部类Command。为了实现多个音乐播放，所有command都加在了 LinkedList中，当调用play或者stop方法的时候，会根据参数封装成一个command对象，启动一个thread，thread中会把LinkedList的第一个command弹出，根据command的code去判断是要播放还是停止，播放调用startSound（）方法，停止则释放所有资源，当LinkedList中没有command，线程便停止。

        播放一个连续(多个)的音频URLs，但那些任务较重的工作在另外的线程中完成，所以任何预处理或加载的延迟都不阻碍线程调用。

[java] view plain copy

1. import android.content.Context;  
2. import android.media.MediaPlayer;  
3. import android.net.Uri;  
4. import android.os.PowerManager;  
5. import android.os.SystemClock;  
6. import android.util.Log;  
7.   
8. import java.io.IOException;  
9. import java.lang.IllegalStateException;  
10. import java.util.LinkedList;  
11.   
12. public class AsyncPlayer {  
13.     private static final int PLAY = 1;  
14.     private static final int STOP = 2;  
15.     private static final boolean mDebug = false;  
16.   
17.     private static final class Command {  
18.         int code;  
19.         Context context;  
20.         Uri uri;  
21.         boolean looping;  
22.         int stream;  
23.         long requestTime;  
24.   
25.         public String toString() {  
26.             return "{ code=" + code + " looping=" + looping + " stream=" + stream + " uri=" + uri + " }";  
27.         }  
28.     }  
29.   
30.     private LinkedList mCmdQueue = new LinkedList();  
31.   
32.     private void startSound(Command cmd) {  
33.   
34.         try {  
35.             MediaPlayer player = new MediaPlayer();  
36.             player.setAudioStreamType(cmd.stream);  
37.             player.setDataSource(cmd.context, cmd.uri);  
38.             player.setLooping(cmd.looping);  
39.             player.prepare();  
40.             player.start();  
41.             if (mPlayer != null) {  
42.                 mPlayer.release();  
43.             }  
44.             mPlayer = player;  
45.         } catch (IOException e) {  
46.             Log.w(mTag, "error loading sound for " + cmd.uri, e);  
47.         } catch (IllegalStateException e) {  
48.             Log.w(mTag, "IllegalStateException (content provider died?) " + cmd.uri, e);  
49.         }  
50.     }  
51.   
52.     private final class Thread extends java.lang.Thread {  
53.         Thread() {  
54.             super("AsyncPlayer-" + mTag);  
55.         }  
56.   
57.         public void run() {  
58.             while (true) {  
59.                 Command cmd = null;  
60.   
61.                 synchronized (mCmdQueue) {  
62.   
63.                     cmd = (Command) mCmdQueue.removeFirst();  
64.                 }  
65.   
66.                 switch (cmd.code) {  
67.                 case PLAY:  
68.                     startSound(cmd);  
69.                     break;  
70.                 case STOP:  
71.   
72.                     if (mPlayer != null) {  
73.                         mPlayer.stop();  
74.                         mPlayer.release();  
75.                         mPlayer = null;  
76.                     } else {  
77.                         Log.w(mTag, "STOP command without a player");  
78.                     }  
79.                     break;  
80.                 }  
81.   
82.                 synchronized (mCmdQueue) {  
83.                     if (mCmdQueue.size() == 0) {  
84.   
85.                         mThread = null;  
86.                         releaseWakeLock();  
87.                         return;  
88.                     }  
89.                 }  
90.             }  
91.         }  
92.     }  
93.   
94.     private String mTag;  
95.     private Thread mThread;  
96.     private MediaPlayer mPlayer;  
97.     private PowerManager.WakeLock mWakeLock;  
98.   
99.     private int mState = STOP;  
100.   
101.     public AsyncPlayer(String tag) {  
102.         if (tag != null) {  
103.             mTag = tag;  
104.         } else {  
105.             mTag = "AsyncPlayer";  
106.         }  
107.     }  
108.   
109.     public void play(Context context, Uri uri, boolean looping, int stream) {  
110.         Command cmd = new Command();  
111.         cmd.requestTime = SystemClock.uptimeMillis();  
112.         cmd.code = PLAY;  
113.         cmd.context = context;  
114.         cmd.uri = uri;  
115.         cmd.looping = looping;  
116.         cmd.stream = stream;  
117.         synchronized (mCmdQueue) {  
118.             enqueueLocked(cmd);  
119.             mState = PLAY;  
120.         }  
121.     }  
122.   
123.     public void stop() {  
124.         synchronized (mCmdQueue) {  
125.             if (mState != STOP) {  
126.                 Command cmd = new Command();  
127.                 cmd.requestTime = SystemClock.uptimeMillis();  
128.                 cmd.code = STOP;  
129.                 enqueueLocked(cmd);  
130.                 mState = STOP;  
131.             }  
132.         }  
133.     }  
134.   
135.     private void enqueueLocked(Command cmd) {  
136.         mCmdQueue.add(cmd);  
137.         if (mThread == null) {  
138.             acquireWakeLock();  
139.             mThread = new Thread();  
140.             mThread.start();  
141.         }  
142.     }  
143.   
144.     public void setUsesWakeLock(Context context) {  
145.         if (mWakeLock != null || mThread != null) {  
146.             throw new RuntimeException("assertion failed mWakeLock=" + mWakeLock + " mThread=" + mThread);  
147.         }  
148.         PowerManager pm = (PowerManager) context.getSystemService(Context.POWER_SERVICE);  
149.         mWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, mTag);  
150.     }  
151.   
152.     private void acquireWakeLock() {  
153.         if (mWakeLock != null) {  
154.             mWakeLock.acquire();  
155.         }  
156.     }  
157.   
158.     private void releaseWakeLock() {  
159.         if (mWakeLock != null) {  
160.             mWakeLock.release();  
161.         }  
162.     }  
163. }