音频处理mediaplay介绍

254969084

处理音频焦点；尽管某个时刻只有一个activity可以运行，A；Android2.2之前，没有内建的机制来处理这；当你的应用需要输出像乐音和通知之类的音频时，你应；将来的音频焦点是合作的．所以，应用被希望（并被强；要请求音频焦点，你必须从AudioManager；[java]；AudioManageraudioManager；getSystemService
0 d9 U5 }, P: X6 h
& m+ ^/ O  ~1 u  u/ [  ]
+ `" l- P8 m/ D  ?4 y1 Y  
处理音频焦点

( B) J- v3 v1 C0 W尽管某个时刻只有一个activity可以运行，Android却是一个多任务环境．这对使用音频的应用带来了特殊的挑战，因为只有一个音频输出而可能多个媒体都想用它．在
' x: q, e0 q6 F- g! o2 Y; f; l/ f
Android2.2之前，没有内建的机制来处理这个问题，所以可能在某些情况下导致坏的用户体验．例如，当一个用户正在听音乐而另一个应用需要通知用户一些重要的事情时，用户可能由于音乐声音大而不能听的通知．从Android2.2开始，平台为应用提供了一个协商它们如何使用设备音频输出的途径，这个机制叫做音频焦点．

+ u9 L8 M- Y8 J当你的应用需要输出像乐音和通知之类的音频时，你应该总是请求音频焦点．一旦应用具有了焦点，它就可以自由的使用音频输出．但它总是应该监听焦点的变化．如果被通知丢失焦点，它应该立即杀死声音或降低到静音水平(有一个标志表明应选择哪一个)并且仅当重新获得焦点后才恢复大声播放．

将来的音频焦点是合作的．所以，应用被希望（并被强列鼓励）遵守音频焦点的方针，但是却不是被系统强制的．如果一个应用在丢失音频焦点后依然想大声播放音乐，系统不会去阻止它．然而用户却体验很坏并且很想把这鸟应用卸载．
# v- E7 c/ r  K
要请求音频焦点，你必须从AudioManager调用requestAudioFocus()，如下所示：

# E' `# E' Q: K[java]
5 C6 L5 N; y8 O  b0 N6 n4 t
9 x, y- ]* @& |2 z; c  R$ uAudioManager audioManager = (AudioManager)

: p- ^5 d7 }) Q# w0 R3 YgetSystemService(Context.AUDIO_SERVICE);
3 p% i3 W4 Y/ q: h3 _) Z( W
% ~3 }$ j, S' x9 bint result = audioManager.requestAudioFocus(this, AudioManager.STREAM_MUSIC, AudioManager.AUDIOFOCUS_GAIN);
$ C. W: }9 O* Z0 e; K
+ c( v( O$ a- Vif (result != AudioManager.AUDIOFOCUS_REQUEST_GRANTED) {

% _2 ]8 b' `0 X+ M1 j// 不能获得音频焦点

}

0 T5 D6 S+ h' \+ mAudioManager audioManager = (AudioManager)
' {( V$ ~( z4 [8 ~! x) a2 M
! E0 n- O' J! S6 x( S, i+ cgetSystemService(Context.AUDIO_SERVICE);
# x+ q. ]* D2 w+ ]* f
int result = audioManager.requestAudioFocus(this, AudioManager.STREAM_MUSIC, AudioManager.AUDIOFOCUS_GAIN);

if (result != AudioManager.AUDIOFOCUS_REQUEST_GRANTED) {

3 W$ c( o8 r' B1 _, o7 [( a$ D) D// 不能获得音频焦点
1 }/ q' {9 u& I/ c
}
. f1 ~5 Q* H- G3 R/ A
! C, t9 s; b$ F) q$ Z$ P: S* p6 urequestAudioFocus()的第一个参数是一个
1 u" u1 E( [7 b4 T  Z+ d0 E' v9 P
AudioManager.OnAudioFocusChangeListener，它的onAudioFocusChange()方法在音频焦点发改变时被调用．因此，你也应该在你的service和activity上实现此接口．例如：

[java]

class MyService extends Service

+ m2 `5 Z# S' M& timplements AudioManager.OnAudioFocusChangeListener {
. C! f% I' d; l# ]6 O% D  d1 e/ H
+ W; n9 A$ }4 w// ....
* C: m6 D9 e5 Y, h: G
public void onAudioFocusChange(int focusChange) {
1 f: {5 y3 M% U  n
; H. H6 w9 u) f$ P4 L6 c// Do something based on focus change...
. b3 |' z' ]  Y+ C' \
}
7 q3 T8 E9 _% L$ K4 j* {
}
- p4 f. \9 Q3 R* ]6 z% U
5 L" }- E1 h, qclass MyService extends Service

6 \: w" w; D/ i1 P; Mimplements AudioManager.OnAudioFocusChangeListener {

* D& g7 ~& f* r! a: \. b// ....

  f' o- o& r% j( V6 A7 Ipublic void onAudioFocusChange(int focusChange) {
  D8 r0 p0 D9 p0 Z, ]  t
' ^9 p% \  J4 i1 P// Do something based on focus change...

}

}

参数focusChange告诉你音频焦点如何发生了变化，它可以是以上几种值(它们都是定义在AudioManager中的常量)：
) T7 x. J6 s) g8 P# W9 m' V4 l
AUDIOFOCUS_GAIN:你已获得了音频焦点．

AUDIOFOCUS_LOSS:你已经丢失了音频焦点比较长的时间了．你必须停止所有的音频播放．因为预料到你可能很长时间也不能再获音频焦点，所以这里是清理你的资源的好地方．比如，你必须释放MediaPlayer．
. |  l: w: T9 }& L6 B
4 c1 L7 G( X; qAUDIOFOCUS_LOSS_TRANSIENT:你临时性的丢掉了音频焦点，很快就会重新获得．你必须停止所有的音频播放，但是可以保留你的资源，因为你可能很快就能重新获得焦点．
6 K3 I1 y  J6 V1 |- H1 X/ G3 G
9 O2 v  H$ n2 `+ S- H# f0 G4 XAUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK:你临时性的丢掉了音频焦点，但是你被允许继续以低音量播放，而不是完全停止．

下面是一个例子：

[java]
2 Z5 _7 a6 P' C6 K% j
5 x1 L3 l9 \; ]# Opublic void onAudioFocusChange(int focusChange) {
7 v$ k- h% @: |
1 e6 ^* g$ D6 r+ H2 X5 N3 N" xswitch (focusChange) {
3 i2 _) P$ K, L8 B6 w, @/ f
2 D, o3 j8 c# R9 _8 lcase AudioManager.AUDIOFOCUS_GAIN:
6 G  Z  }, j/ p  J+ o6 x
// resume playback

/ b+ [) ?) y- }. r3 }if (mMediaPlayer == null) initMediaPlayer();

else if (!mMediaPlayer.isPlaying()) mMediaPlayer.start(); mMediaPlayer.setVolume(1.0f, 1.0f);
9 ^+ b" i) x. \1 S
break;

0 d" D0 g; i& v$ |$ d- Y& Lcase AudioManager.AUDIOFOCUS_LOSS:

// Lost focus for an unbounded amount of time: stop playback and release media player

6 E, l; ~* Q# S; x$ q! m4 u: xif (mMediaPlayer.isPlaying()) mMediaPlayer.stop();

mMediaPlayer.release();
# o9 c/ J- G# q4 f4 m: ^
7 [( |: ?2 i7 Z1 F& `mMediaPlayer = null;
8 B1 J! s- L" }& H' S' j
break;

  F! k6 k6 ]5 i* ccase AudioManager.AUDIOFOCUS_LOSS_TRANSIENT:

// Lost focus for a short time, but we have to stop

// playback. We don't release the media player because playback // is likely to resume
, E# D0 [" ]* F+ `" S( t
if (mMediaPlayer.isPlaying()) mMediaPlayer.pause();

break;

case AudioManager.AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK:

// Lost focus for a short time, but it's ok to keep playing // at an attenuated level
' P8 v9 L; `; n7 o
' i5 O  j+ `; l' Zif (mMediaPlayer.isPlaying()) mMediaPlayer.setVolume(0.1f, 0.1f); break;

) Y) U$ X2 C3 z- [9 C8 M8 v}
, m0 ?% i6 |. f( n/ j/ A; ~
- B; p; g  _3 T+ W& _- R# }}

public void onAudioFocusChange(int focusChange) {

switch (focusChange) {

0 n' ^0 }4 o. y$ g1 U: i" xcase AudioManager.AUDIOFOCUS_GAIN:

// resume playback
7 V" c! s5 z* b- E1 f# f
if (mMediaPlayer == null) initMediaPlayer();
4 W" l0 I9 e3 u8 b* f
else if (!mMediaPlayer.isPlaying()) mMediaPlayer.start();

8 P4 \) t! n, t7 r# W- }mMediaPlayer.setVolume(1.0f, 1.0f);

break;
' \9 c6 b1 J& y+ i$ X# A
case AudioManager.AUDIOFOCUS_LOSS:

& G$ P- l, O% [6 L// Lost focus for an unbounded amount of time: stop playback and release media player

9 n: A( H7 K: }7 g0 e- A, x7 p3 w. }/ _if (mMediaPlayer.isPlaying()) mMediaPlayer.stop();

- }, f/ C; E5 Y/ Y( L) MmMediaPlayer.release();

mMediaPlayer = null;

! s  `# q3 b2 i& c: a4 Ybreak;

8 i6 D+ W* Z% |case AudioManager.AUDIOFOCUS_LOSS_TRANSIENT:
; L% m9 H4 Q  q7 i/ O
// Lost focus for a short time, but we have to stop
" t* `! g% ?" j7 X6 t
. \/ {% L! a2 v! y+ |: ?// playback. We don't release the media player because playback // is likely to resume

5 ^8 i, l7 f+ x) l8 @; I3 W% rif (mMediaPlayer.isPlaying()) mMediaPlayer.pause();

break;

, Y# {2 k4 n8 ~" Kcase AudioManager.AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK:

( q- M1 ^; H' w! r5 j// Lost focus for a short time, but it's ok to keep playing // at an attenuated level

if (mMediaPlayer.isPlaying()) mMediaPlayer.setVolume(0.1f, 0.1f); break;

) @5 K  r# v& f}

}

' U6 \  p9 I6 R' u8 Z' w! I2 a记住音频焦点API仅在APIlevel 8 (Android2.2)及更高版本上可以，所以如果你想支持更早的Android版本，你必须在可能时采取兼容性的策略使用特性，如果不可能,you should adopt a backward compatibility strategy that allows you touse this feature if available, and fall back seamlessly if not.

你可以用反射的方式调用音频焦点方法或自己在一个单独的类(叫做

1 g' ^, ~$ n+ E/ B4 D% w6 x& G, \! XAudioFocusHelper)中实现所有的音频焦点功能来达到向前兼容．下面是一个这样的类：
/ ]; s. [! u8 s7 b+ }& [
[java]
, R, @3 @) {- }+ @
public class AudioFocusHelper implements AudioManager.OnAudioFocusChangeListener {
, @. |( J8 S( v% i+ G: S% e! e
AudioManager mAudioManager;

// 这里是其它的字段，你可能要保存一个接口的引用，这个接口

// 被用于与你的service通讯以报告焦点的变化．

; c0 Q$ ~  j' k$ x8 ]8 r- {) Q" rpublic AudioFocusHelper(Context ctx, /* 其它的参数 */) {

2 n) }& _+ q6 s' S/ U" x- w: p9 F( }mAudioManager = (AudioManager)

mContext.getSystemService(Context.AUDIO_SERVICE);

// ...

( ^3 P4 @/ l9 m8 S' R7 G2 s}

public boolean requestFocus() {
/ b" B+ O7 F/ B6 D" Q" x' Z
6 s% x5 r) v* m6 d9 Preturn AudioManager.AUDIOFOCUS_REQUEST_GRANTED ==

254969084

mAudioManager.requestAud；AudioManager.STREAM_MUSI；AudioManager.AUDIOFOCUS_；publicbooleanabandonFocu；returnAudioManager.AUDIO；mAudioManager.abandonAud；@Override；publicvoidonAudioFoc
) `# P' U& j, Z, e0 T
% r. X3 Z2 T- T* H- p" k$ e. n--------------------------------------------------------------------------------

mAudioManager.requestAudioFocus(mContext,

- l  P6 S  m, X: b6 }# y: dAudioManager.STREAM_MUSIC,
: n8 F& G8 B: }4 [: {
7 y" A" Y+ _  N5 g9 G% BAudioManager.AUDIOFOCUS_GAIN);
8 h! y) K$ K0 k& v8 `5 A$ c* \( z
}
- g" U  z1 t. V, N! s1 x; r
) {6 K5 ]. l+ v" W( k
public boolean abandonFocus() {
# |- f; ^( [' r
return AudioManager.AUDIOFOCUS_REQUEST_GRANTED ==

mAudioManager.abandonAudioFocus(this);
% D; V6 `+ W4 d5 o% \' {
3 Q* A  L3 J  u# o( P}
, B9 j/ }- `& q; m8 K2 a* Q
, X/ ]% w; T# {: W
% k% R5 r- p1 ~( F# G+ i! b@Override

public void onAudioFocusChange(int focusChange) {
0 D% v$ @6 T" J1 W7 D: b8 R) a' G
// 让你的service知道焦点变化了

}

' u: r" F' o: I3 Y6 ~* s8 J% h7 W0 s}


你可以仅在检测到系统运行的是API level 8 或更早的版本时才创建
! W. P- f$ C+ d0 Y' Z
AudioFocusHelper类的实例．例如：
6 j. L6 Q: _2 w, d$ Q
if (android.os.Build.VERSION.SDK_INT >= 8) {

mAudioFocusHelper = new AudioFocusHelper(getApplicationContext(), this); } else {
* e8 o  V7 H  b1 i9 x# b
, b! x* r7 }; P% V# Z" K! V* NmAudioFocusHelper = null;
( ~. n1 ?4 h$ r4 B# b0 }
}

public class AudioFocusHelper implements
* P; M1 s% ~  I4 @2 ~
AudioManager.OnAudioFocusChangeListener {

AudioManager mAudioManager;
7 A9 D" o  _$ `, H' u/ S0 J
0 e  }4 e' F9 }& c// 这里是其它的字段，你可能要保存一个接口的引用，这个接口

* V$ d/ c- [5 S1 a7 k3 E3 r// 被用于与你的service通讯以报告焦点的变化．
. |/ d" v  t% k. _: P; s
public AudioFocusHelper(Context ctx, /* 其它的参数 */) {
7 g$ Q7 D4 R2 ]% Z' _. [
( D# ~: w0 R" V6 u3 ^/ S+ i! smAudioManager = (AudioManager)

! }& i  T. t6 O) p  p: cmContext.getSystemService(Context.AUDIO_SERVICE);

8 ^$ C0 [, b" _: z# o// ...

) P: e# U, p, ~3 L& P}

public boolean requestFocus() {

return AudioManager.AUDIOFOCUS_REQUEST_GRANTED ==

mAudioManager.requestAudioFocus(mContext, AudioManager.STREAM_MUSIC, AudioManager.AUDIOFOCUS_GAIN);

; [& p+ d+ x! x, P/ x: x$ d3 |7 x}
- H; S' S! z  u  k) C6 p4 D
public boolean abandonFocus() {
2 c* b- i. |; m1 t' H2 z2 q" F% G, e
% _7 Z  c- u7 s" w8 V* v5 Areturn AudioManager.AUDIOFOCUS_REQUEST_GRANTED ==

' J" N% e  q1 w$ W) T* NmAudioManager.abandonAudioFocus(this);
# j& q: D" ?6 q- M$ v2 A7 Z$ B8 ?6 N
}
- \5 _0 g" e# y5 t. W8 E
! i) T) {0 U& O0 f) n@Override
5 }- g8 \9 ^  F, M# {% r$ g
public void onAudioFocusChange(int focusChange) {

% z$ N6 g8 u! B# o- c' {6 M// 让你的service知道焦点变化了
. F  N9 B6 s. V$ u4 S/ r- e) q
}

}

4 C6 a' v" D! \2 c  B0 D+ |你可以仅在检测到系统运行的是API level 8 或更早的版本时才创建
! \. g# Q) ^9 a/ T7 h* l6 l
AudioFocusHelper类的实例．例如：

5 S* M3 q% @5 {: h0 s- `$ d' |7 t( hif (android.os.Build.VERSION.SDK_INT >= 8) {

mAudioFocusHelper = new AudioFocusHelper(getApplicationContext(), this); } else {

mAudioFocusHelper = null;

, S! ]7 t, t$ m2 O% |2 w8 G2 r}
& ~& H8 d6 H3 F' M

$ b6 p, W& ]% T清理
% f4 h" S2 A4 ]4 Z7 v$ e
: y' y' x5 m+ x5 w1 ^/ s; n0 P
前面提到过，一个MediaPlayer对象可以消耗掉大量的系统资源，所以你应该仅在需要它时保持它并在用完时立即释放．明确的调用清理方法而不是依靠系统的垃圾收集机制是很重要的，因为在被收集之前MediaPlayer可能会存在很长时间，虽然此时它只是占用内存而

1 R/ x6 S' F) K- e  y% q不影响其它的媒体相关的资源．所以，当你使用一个service时，你应该总四重写onDestroy()方法来保证释放MediaPlayer：

& F* e% G7 V! g1 d" A. h
[java]
) E; S# v% U! {
public class MyService extends Service {
& N9 X* R% }( d' N9 X9 h
MediaPlayer mMediaPlayer;
/ z$ e2 }. S2 x8 t+ n* ~
// ...

. L6 v" K6 n$ t$ |. j
@Override

6 c1 ]$ O/ l' gpublic void onDestroy() {

if (mMediaPlayer != null) mMediaPlayer.release();

: S% q/ E' k# s}

" }" S  [# a5 g}
, d7 {. m) J; L, E' ~; g! C
public class MyService extends Service {

5 f: p/ j# t( Z( Z! e5 |+ bMediaPlayer mMediaPlayer;

// ...
1 C! t- L. q$ B8 Y0 I
# S1 r4 j5 n3 I1 [9 q  c  c3 W@Override
" S& e# A, a! B0 N$ ~( p# Z* h
4 G" Q6 F* E# c' n3 Hpublic void onDestroy() {

. _$ {. D: y/ D) o* Yif (mMediaPlayer != null) mMediaPlayer.release();

0 f5 Z7 N" M0 a% p# D( a) B}www.2cto.com
1 @$ M! f) b$ l* s# M
2 x7 _. c) h5 I( G  b, R}
* L& U( r7 F0 w/ i7 O* h+ b( Z
你也应该寻找其它需要释放你的MediaPlayer的时机．例如，如果你预料到长时间不能播放媒体(比如丢掉音频焦点以后)，你应该明确地释放你的MediaPlayer，然后在后面重新创建它．反过来，如果你预测到只会短时间停止播放，你应该保持你的MediaPlayer来避免过多的创建，而不是重新＂准备＂它．