androidmediaplay

⑴ 安卓开发中，使用surfaceView和Mediaplay播发视频为什么会失败，模拟器上播放不了求大神解救，错在哪

模拟器不能使用播放不能代表什么，也可以是模拟器的配置问题，不一定就是代码的问题，你先找一个手机试一下，手机可以运行那就没什么问题，如果不行再去定位问题，如果这样一味调试下去的话，只能是浪费时间

⑵ android soundpool能不能在除了activity之外的类中使用

在开发android软件中，经常需要播放多媒体音频文件，通常会采用MediaPlayer类来执行此类操作。但MediaPlayer类占用的资源比较多，对于游戏等应用而言，会带来性能上的降低。在Android中，专门提供了SoundPool类来执行此类音频播放，SoundPool类占用的CPU资源较少、反应较快。
SoundPool使用MediaPlaybackService将音频流解码为16位的PCM单声道或者立体声流。这有利于减小解码造成的应用延迟。
SoundPool的常用方法包括：
load() //加载音频文件
pause() //暂停
play() //播放
resume() //恢复
setLoop() //设置循环模式
setOnLoadCompleteListener() //设置监听器
setVolume() //设置音量
setRate() //设置播放速率
SoundPool类和其他音频播放类相比，可以自行设置音频播放时的品质、音量、播放速率等。并且它可以管理多个音频流，每个流均拥有自己独立的ID，对单个音频流的管理均是通过其ID来进行的。SoundPool类适用的场景包括应用程序中的声效（按键提示音、消息等）、游戏中密集而短暂的声音（如多个飞船同时爆炸）。
SoundPool类的使用方法如下：
代码10-5 SoundPool播放音频的一般过程

int srcQuality=100;
int waitMsec=1000;
float leftVolume=SILENT;
float rightVolume=LOUD;
int priority=1;
int loop=0;
float rate=1f;
SoundPool mSoundPool=new SoundPool(SOUNDPOOL_STREAMS, AudioManager.STREAM_MUSIC, srcQuality);
int sampleId1=mSoundPool.load(mContext, SOUND_A, PRIORITY);
int streamID=mSoundPool.play(sampleID, leftVolume, rightVolume, priority, loop, rate);
……

⑶ 怎样监听android的mediaplay播放网络音乐时，每一次的缓冲以及每一次缓冲结束

isplaying和！isplaying不行吗？

⑷ android.media.AsyncPlayer这个类应该怎么用

代码结构：

Open Core 的代码在Android 代码的 External/Opencore 目录中 。这个目录是OpenCore
的根目录，其中包含的子目录如下所示 ：

android ：这里面是一个上层的库，它实现了一个为Android 使用的音视频采集，播放的接口，和DRM 数字版权管理的接口实现。

baselibs ：包含数据结构和线程安全等内容的底层库

codecs_v2 ：音视频的编解码器，基于 OpenMAX 实现

engines ：核心部分 ，多媒体 引擎的实现

extern_libs_v2 ：包含了 khronos 的 OpenMAX 的头文件

fileformats ：文件格式的解析( parser )工具

nodes ：提供一些PVMF 的NODE ，主要是编解码和文件解析方面的。

oscl ：操作系统兼容库

pvmi ： 输入输出控制的抽象接口

protocols ：主要是与网络相关的 RTSP 、 RTP 、 HTTP 等协议 的相关内容

pvcommon ： pvcommon 库文件的 Android.mk 文件，没有源文件。

pvplayer ： pvplayer 库文件的 Android.mk 文件，没有源文件。

pvauthor ： pvauthor 库文件的 Android.mk 文件，没有源文件。

tools_v2 ：编译工具以及一些可注册的模块。

本文主要介绍Android MediaPlayer的架构，主要由OpenCore 里的PV Player来实现的。

1.概述

Android的MediaPlayer包含了Audio和Video的播放功能，Music和Video两个应用程序都是调用MediaPlayer实现的。

代码主要分布在以下的目录中：

java程序的路径：

packages/apps/Music/src/com/android/music/

JAVA类的路径：

frameworks/base/media/java/android/media/MediaPlayer.java

JAVA本地调用部分(JNI)：

frameworks/base/media/jni/android_media_MediaPlayer.cpp

编译为 libmedia_jni.so

头文件：

frameworks/base/include/media/

多媒体库：

frameworks/base/media/libmedia/

编译为 libmedia.so

多媒体服务：

frameworks/base/media/libmediaplayerservice/

编译为 libmediaplayerservice.so

具体实现：

external/opencore/

编译为 libopencoreplayer.so

libopencoreplayer.so是主要的实现部分，其他的库基本上都是在其上建立的封装和为建立进程间通讯的机制。

2.框架

运行的时候，大致可以分成Client和Server两个部分，分别在两个进程中运行，使用Binder机制实现IPC通讯。从框架结构上来看，IMediaPlayerService.h、IMediaPlayerClient.h和MediaPlayer.h三个类定义了MeidaPlayer的接口和架构，MediaPlayerService.cpp和mediaplayer.cpp两个文件用于MeidaPlayer架构的实现，MeidaPlayer的具体功能在PVPlayer(库libopencoreplayer.so)中的实现。

2.1 IMediaPlayerClient.h

描述一个MediaPlayer客户端的接口

class IMediaPlayerClient: public IInterface

{

public:

DECLARE_META_INTERFACE(MediaPlayerClient);

virtual void notify(int msg, int ext1, int ext2) = 0;

};

class BnMediaPlayerClient: public BnInterface

{

public:

virtual status_t onTransact( uint32_t code,

const Parcel& data,

Parcel* reply,

uint32_t flags = 0);

};

在定义中，IMediaPlayerClient类继承IInterface，并定义了一个MediaPlayer客户端的接口，BnMediaPlayerClient继承了BnInterface，这是为基于Android的基础类Binder机制实现在进程通讯而构建的。事实上，根据BnInterface类模版的定义，BnInterface类相当于双继承了BnInterface和ImediaPlayerClient，这是Android一种常用的定义方式。

2.2 mediaplayer.h

对外的接口类，它最主要是定义了一个MediaPlayer类：

class MediaPlayer : public BnMediaPlayerClient

{

public:

MediaPlayer();

~MediaPlayer();

void onFirstRef();

void disconnect();

status_t setDataSource(const char *url);

status_t setDataSource(int fd, int64_t offset, int64_t length);

status_t setVideoSurface(const sp& surface);

status_t setListener(const sp& listener);

status_t prepare();

status_t prepareAsync();

status_t start();

status_t stop();

status_t pause();

bool isPlaying();

status_t getVideoWidth(int *w);

status_t getVideoHeight(int *h);

status_t seekTo(int msec);

status_t getCurrentPosition(int *msec);

status_t getDuration(int *msec);

status_t reset();

status_t setAudioStreamType(int type);

status_t setLooping(int loop);

status_t setVolume(float leftVolume, float rightVolume);

void notify(int msg, int ext1, int ext2);

static sp decode(const char* url, uint32_t *pSampleRate, int*
pNumChannels);

static sp decode(int fd, int64_t offset, int64_t length, uint32_t
*pSampleRate, int* pNumChannels);

//……

}

从接口中可以看出MediaPlayer类刚好实现了一个MediaPlayer的基本操作，例如播放(start)、停止(stop)、暂停(pause)等。

另外的一个类DeathNotifier在MediaPlayer类中定义，它继承了IBinder类中的DeathRecipient类：

class DeathNotifier: public IBinder:: DeathRecipient

{

public:

DeathNotifier() {}

virtual ~DeathNotifier();

virtual void binderDied(const wp& who);

};

事实上，MediaPlayer类正是间接地继承了IBinder，而MediaPlayer:: DeathNotifier类继承了IBinder::
DeathRecipient，这都是为了实现进程间通讯而构建的。

2.3 IMediaPlayer.h

主要的的内容是一个实现MediaPlayer功能的接口：

class IMediaPlayer: public IInterface

{

public:

DECLARE_META_INTERFACE(MediaPlayer);

virtual void disconnect() = 0;

virtual status_t setVideoSurface(const sp& surface) = 0;

virtual status_t prepareAsync() = 0;

virtual status_t start() = 0;

virtual status_t stop() = 0;

virtual status_t pause() = 0;

virtual status_t isPlaying(bool* state) = 0;

virtual status_t getVideoSize(int* w, int* h) = 0;

virtual status_t seekTo(int msec) = 0;

virtual status_t getCurrentPosition(int* msec) = 0;

virtual status_t getDuration(int* msec) = 0;

virtual status_t reset() = 0;

virtual status_t setAudioStreamType(int type) = 0;

virtual status_t setLooping(int loop) = 0;

virtual status_t setVolume(float leftVolume, float rightVolume) = 0;

};

class BnMediaPlayer: public BnInterface

{

public:

virtual status_t onTransact( uint32_t code,

const Parcel& data,

Parcel* reply,

uint32_t flags = 0);

};

在IMediaPlayer类中，主要定义MediaPlayer的功能接口，这个类必须被继承才能够使用。值得注意的是，这些接口和MediaPlayer类的接口有些类似，但是它们并没有直接的关系。事实上，在MediaPlayer类的各种实现中，一般都会通过调用IMediaPlayer类的实现类来完成。

2.4 头文件IMediaPlayerService.h

描述一个MediaPlayer的服务，定义方式如下所示：

class IMediaPlayerService: public IInterface

{

public:

DECLARE_META_INTERFACE(MediaPlayerService);

virtual sp create(pid_t pid, const
sp& client, const char* url) = 0;

virtual sp create(pid_t pid, const
sp& client, int fd, int64_t offset, int64_t length) =
0;

virtual sp decode(const char* url, uint32_t *pSampleRate, int*
pNumChannels) = 0;

virtual sp decode(int fd, int64_t offset, int64_t length, uint32_t
*pSampleRate, int* pNumChannels) = 0;

};

class BnMediaPlayerService: public BnInterface

{

public:

virtual status_t onTransact( uint32_t code,

const Parcel& data,

Parcel* reply,

uint32_t flags = 0);

};

由于有纯虚函数，IMediaPlayerService
以及BnMediaPlayerService必须被继承实现才能够使用，在IMediaPlayerService定义的create和decode等接口，事实上是必须被继承者实现的内容。注意，create的返回值的类型是sp，这个IMediaPlayer正是提供实现功能的接口。

3 实现

3.1 App

在packages/apps/Music/src/com/android/music/里的MediaPlaybackService.java文件中，包含了对MediaPlayer的调用。

在MediaPlaybackService.java中包含对包的引用：

import android.media.MediaPlayer;

在MediaPlaybackService类的内部，定义了MultiPlayer类：

private class MultiPlayer {

private MediaPlayer mMediaPlayer = new MediaPlayer();

}

MultiPlayer类中使用了MediaPlayer类，其中有一些对这个MediaPlayer的调用，调用的过程如下所示：

mMediaPlayer.reset();

mMediaPlayer.setDataSource(path);

mMediaPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC);

reset,setDataSource和setAudioStreamType等接口就是通过JAVA本地调用(JNI)来实现的。

3.2 Jni

在frameworks/base/media/jni/android_media_MediaPlayer.cpp中实现,其中android_media_MediaPlayer_reset函数的实现如下所示：

static void android_media_MediaPlayer_reset(JNIEnv *env, jobject thiz)

{

sp mp = getMediaPlayer(env, thiz);

if (mp == NULL ) {

jniThrowException(env, "java/lang/IllegalStateException", NULL);

return;

}

process_media_player_call( env, thiz, mp->reset(), NULL, NULL );

}

先获取一个MediaPlayer指针，通过对它的调用来实现实际的功能。

register_android_media_MediaPlayer用于将gMethods注册为的类"android/media/MediaPlayer"，其实现如下所示。

static int register_android_media_MediaPlayer(JNIEnv *env)

{

jclass clazz;

clazz = env->FindClass("android/media/MediaPlayer");

// ......

return AndroidRuntime::registerNativeMethods(env,
"android/media/MediaPlayer", gMethods, NELEM(gMethods));

}

"android/media/MediaPlayer"对应JAVA的类android.media.MediaPlayer。

3.3 libmedia.so

frameworks/base/media/libmedia/mediaplayer.cpp文件实现mediaplayer.h提供的接口，其中一个重要的片段如下所示：

const sp& MediaPlayer::getMediaPlayerService()

{

Mutex::Autolock _l(mServiceLock);

if (mMediaPlayerService.get() == 0) {

sp sm = defaultServiceManager();

sp binder;

do {

binder = sm->getService(String16("media.player"));

if (binder != 0)

break;

LOGW("MediaPlayerService not published, waiting...");

usleep(500000); // 0.5 s

} while(true);

if (mDeathNotifier == NULL) {

mDeathNotifier = new DeathNotifier();

}

binder->linkToDeath(mDeathNotifier);

mMediaPlayerService = interface_cast(binder);

}

LOGE_IF(mMediaPlayerService==0, "no MediaPlayerService!?");

return mMediaPlayerService;

}

其中最重要的一点是binder =
sm->getService(String16("media.player"));这个调用用来得到一个名称为"media.player"的服务，这个调用返回值的类型为IBinder，根据实现将其转换成类型IMediaPlayerService使用。

一个具体的函数setDataSource如下所示：

status_t MediaPlayer::setDataSource(const char *url)

{

LOGV("setDataSource(%s)", url);

status_t err = UNKNOWN_ERROR;

if (url != NULL) {

const sp& service(getMediaPlayerService());

if (service != 0) {

sp player(service->create(getpid(), this, url));

err = setDataSource(player);

}

}

return err;

}

⑸ android里音乐没播放怎么也调用setoncompletionlistener

1.对于控制研究媒体播放器，通过本地服务打，不如送媒体播放器参考其他类一样CarefulMediaPlayer（MP，这一点）;你在处理此类播放器的属性。我认为它帮助你。 谢谢
2.我为这个问题挣扎，最后我得到了它的工作班以下。这个想法是一个线程与活套，剩下活着，并处理所有的MediaPlayer的逻辑。 我只退出尺蠖和清理线程，如果服务接收到的明确

{
privatestaticPowerManager.WakeLockwakeLock;
privatestaticfinalStringTAG="PlayService";
privatestaticStringLOCK_NAME=TAG;
publicstaticfinalStringEXTRA_FILE="file";
publicstaticfinalStringACTION_PLAY="play";
_STOP="stop";
publicstaticfinalintMSG_START=1;
publicstaticfinalintMSG_STOP=2;
publicPlayService(Stringname){
super(name);
}
publicPlayService(){
super("PlayService");
}
@Override
publicvoidonCreate(){
super.onCreate();
}
@Override
protectedvoidonHandleIntent(Intentintent){
Messagemsg=newMessage();
if(ACTION_PLAY.equalsIgnoreCase(intent.getAction())){
StringfileName=intent.getExtras().getString(EXTRA_FILE);
msg.what=MSG_START;
msg.obj=fileName;
}elseif(ACTION_STOP.equalsIgnoreCase(intent.getAction())){
msg.what=MSG_STOP;
}
try{
PlayMediaThread.getInstance(this).sendMessage(msg);
}catch(InterruptedExceptione){
Log.e(TAG,e.getMessage());
}
}
publicstaticPowerManager.WakeLockacquireLock(Contextcontext){
if(wakeLock==null||!wakeLock.isHeld()){
PowerManagerpowerManager=(PowerManager)context
.getSystemService(Context.POWER_SERVICE);
wakeLock=powerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK,
LOCK_NAME);
wakeLock.setReferenceCounted(true);
wakeLock.acquire();
}
returnwakeLock;
}
publicstaticvoidreleaseLock(Contextcontext){
if(wakeLock!=null&&wakeLock.isHeld()){
wakeLock.release();
}
}
}
,
OnErrorListener,OnPreparedListener{
=newSemaphore(0);
privatestaticHandlerhandler;
privatestaticLoopermyLooper;
privatestaticContextcontext;
;
;
;
privatestaticfinalStringTAG="PlayMediaThread";
privatePlayMediaThread(Contextcontext)throwsInterruptedException{
super(TAG);
PlayMediaThread.context=context;
start();
//
//instance
semaphore.acquire();
}
(Contextcontext)
throwsInterruptedException{
if(instance==null){
instance=newPlayMediaThread(context);
}
PlayMediaThread.context=context;
returninstance;
}
publicvoidsendMessage(Messagemsg){
handler.sendMessage(msg);
}
publicvoidquitLooper(){
try{
if(myLooper!=null){
myLooper.quit();
Log.i(TAG,"Afterquit");
}
}catch(Exceptionex){
Log.e(TAG,ex.getMessage());
}
}
@Override
publicvoidrun(){
Looper.prepare();
myLooper=Looper.myLooper();
handler=newHandler(){
@Override
publicvoidhandleMessage(Messagemsg){
if(msg.what==PlayService.MSG_START){
startPlayer((String)msg.obj);
}elseif(msg.what==PlayService.MSG_STOP){
//.e.user
//explicitlyclickedstop,Iquitthelooperand
//cleanthethread
stopPlayer(true);
}
}
};
semaphore.release();
Log.i(TAG,"BeforeLoop");
Looper.loop();
}
privatevoidstopPlayer(booleanclean){
if(player!=null){
if(player.isPlaying()){
player.stop();
}
player.release();
player=null;
}
if(clean){
PlayService.releaseLock(context);
quitLooper();
instance=null;
}
}
privatevoidstartPlayer(StringfileName){
if(player!=null&&player.isPlaying()&&currentFileName!=null
&&currentFileName.equalsIgnoreCase(fileName)){
return;
}
currentFileName=fileName;
stopPlayer(false);
player=newMediaPlayer();
player.setOnCompletionListener(this);
player.setOnErrorListener(this);
player.setOnPreparedListener(this);
try{
player.setDataSource(context,Uri.parse(currentFileName));
player.prepare();
player.start();
PlayService.acquireLock(context);
}catch(Exceptione){
Log.e(TAG,e.getMessage());
}
}
@Override
publicbooleanonError(MediaPlayermp,intarg1,intarg2){
Log.e(TAG,"onError");
stopPlayer(true);
returnfalse;
}
@Override
publicvoidonCompletion(MediaPlayermp){
Log.d(TAG,"onCompletion");
//
stopPlayer(true);
}
@Override
publicvoidonPrepared(MediaPlayermp){
Log.d(TAG,"onPrepared");
}
}

⑹ android mediaplay 怎么播放 rtsp /http 流媒体

但是网络电台的连接就是没有扩展名的，在PC 上的media play 都可以播放的

⑺ android MediaPlayer setDataSource( String path )报错

这是java的异常处理；这行代码会产生异常，而在这里你没有对异常处理，所以系统提示你“Unhandled exception”;解决方法如下：

第一种：使用try-catch捕获该异常：
try｛
ar.set~~~~~~~~~~~~~~;
｝catch(Exception e){
e.printStackTrace();
}
第二种：在方法定义时 throws 该异常 public void play throws Exception（）｛。。。｝