进行Android游戏开发时，背景音乐的播放几乎是不得不考虑的问题，Android SDK提供了MediaPlayer类来播放声音，但还要充分考虑到它与画面的协调，画面的流畅性，多种音效同时播放等问题，这样就必须使用Android多线程机制和异步音乐播放。

       从Android SDK 1.0开始就提供了AsyncPlayer类，我们在使用它时可以根据需要派生出子类，以更灵活的实现异步播放功能。

Java代码
  1. import android.content.Context;   
  2. import android.net.Uri;   
  3. import android.os.PowerManager;   
  4. import android.os.SystemClock;   
  5. import android.util.Log;   
  6.   
  7. import java.io.IOException;   
  8. import java.lang.IllegalStateException;   
  9. import java.util.LinkedList;   
  10.   
  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   
  27.                     + " uri=" + uri + " }";   
  28.         }   
  29.     }   
  30.   
  31.     private LinkedList<Command> mCmdQueue = new LinkedList();  //用一个链表保存播放参数队列   
  32.   
  33.     private void startSound(Command cmd) {   
  34.      
  35.         try {   
  36.             MediaPlayer player = new MediaPlayer();   
  37.             player.setAudioStreamType(cmd.stream);   
  38.             player.setDataSource(cmd.context, cmd.uri);  //设置媒体源，这里Android123提示大家本类的public void play (Context context, Uri uri, boolean looping, int stream) 类第二个参数Uri为媒体位置。   
  39.             player.setLooping(cmd.looping);   
  40.             player.prepare();   
  41.             player.start();   
  42.             if (mPlayer != null) {   
  43.                 mPlayer.release();   
  44.             }   
  45.             mPlayer = player;   
  46.           }   
  47.         catch (IOException e) {   
  48.             Log.w(mTag, "error loading sound for " + cmd.uri, e);   
  49.         } catch (IllegalStateException e) {   
  50.             Log.w(mTag, "IllegalStateException (content provider died?) " + cmd.uri, e);   
  51.         }   
  52.     }   
  53.   
  54.     private final class Thread extends java.lang.Thread {   //通过多线程方式不阻塞调用者   
  55.         Thread() {   
  56.             super("AsyncPlayer-" + mTag);   
  57.         }   
  58.   
  59.         public void run() {   
  60.             while (true) {   
  61.                 Command cmd = null;   
  62.   
  63.                 synchronized (mCmdQueue) {   //同步方式执行   
  64.   
  65.                         cmd = mCmdQueue.removeFirst();   
  66.                 }   
  67.   
  68.                 switch (cmd.code) {   
  69.                 case PLAY:   
  70.                                  startSound(cmd);   
  71.                     break;   
  72.                 case STOP:   
  73.     
  74.                     if (mPlayer != null) {   
  75.                                          mPlayer.stop();   
  76.                         mPlayer.release();   
  77.                         mPlayer = null;   
  78.                     } else {   
  79.                         Log.w(mTag, "STOP command without a player");   
  80.                     }   
  81.                     break;   
  82.                 }   
  83.   
  84.                 synchronized (mCmdQueue) {   
  85.                     if (mCmdQueue.size() == 0) {   
  86.                
  87.                         mThread = null;   
  88.                         releaseWakeLock();   
  89.                         return;   
  90.                     }   
  91.                 }   
  92.             }   
  93.         }   
  94.     }   
  95.   
  96.     private String mTag;   
  97.     private Thread mThread;   
  98.     private MediaPlayer mPlayer;   
  99.     private PowerManager.WakeLock mWakeLock;   
  100.   
  101.     
  102.     private int mState = STOP;   
  103.     
  104.     public AsyncPlayer(String tag) {   
  105.         if (tag != null) {   
  106.             mTag = tag;   
  107.         } else {   
  108.             mTag = "AsyncPlayer";   
  109.         }   
  110.     }   
  111.   
  112.     
  113.     public void play(Context context, Uri uri, boolean looping, int stream) {   
  114.         Command cmd = new Command();   
  115.         cmd.requestTime = SystemClock.uptimeMillis(); //这里为了测试性能，传递了开始执行前的系统tickcount计时器值   
  116.         cmd.code = PLAY;   
  117.         cmd.context = context;   
  118.         cmd.uri = uri;   
  119.         cmd.looping = looping;   
  120.         cmd.stream = stream;   
  121.         synchronized (mCmdQueue) {   
  122.             enqueueLocked(cmd);   
  123.             mState = PLAY;   
  124.         }   
  125.     }   
  126.        
  127.     
  128.     public void stop() {   
  129.         synchronized (mCmdQueue) {   
  130.                  if (mState != STOP) {   
  131.                 Command cmd = new Command();   
  132.                 cmd.requestTime = SystemClock.uptimeMillis();   
  133.                 cmd.code = STOP;   
  134.                 enqueueLocked(cmd);   
  135.                 mState = STOP;   
  136.             }   
  137.         }   
  138.     }   
  139.   
  140.     private void enqueueLocked(Command cmd) {   
  141.         mCmdQueue.add(cmd);   
  142.         if (mThread == null) {   
  143.             acquireWakeLock();   
  144.             mThread = new Thread();   
  145.             mThread.start();   
  146.         }   
  147.     }   
  148.   
  149.     // 一般对于Android游戏而言下面的代码不用考虑，一般用户都在交互操作，不会出现屏幕锁问题   
  150.   
  151.     public void setUsesWakeLock(Context context) {  //电源管理wakelock处理   
  152.         if (mWakeLock != null || mThread != null) {   
  153.                       throw new RuntimeException("assertion failed mWakeLock=" + mWakeLock   
  154.                     + " mThread=" + mThread);   
  155.         }   
  156.         PowerManager pm = (PowerManager)context.getSystemService(Context.POWER_SERVICE);   
  157.         mWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, mTag);   
  158.     }   
  159.   
  160.     private void acquireWakeLock() {   //加锁   
  161.         if (mWakeLock != null) {   
  162.             mWakeLock.acquire();   
  163.         }   
  164.     }   
  165.   
  166.     private void releaseWakeLock() { //解锁   
  167.         if (mWakeLock != null) {   
  168.             mWakeLock.release();   
  169.         }   
  170.     }   
  171. }  

 

本文发布：Android开发网
本文地址：http://www.jizhuomi.com/android/game/121.html
2012年7月19日
发布:鸡啄米 分类:Android游戏开发 浏览: 评论:3