Android MediaPlayer 音乐播放

主要使用

android.media.MediaPlayer;

android.widget.SeekBar;

  





    

    
    
      

    

        

        

        

        

        
    






package com.tt;

import android.widget.Button;
import android.widget.SeekBar;
import android.widget.TextView;

public class viewHolder {

	public static Button start;
	public static Button stop;
	public static Button pause;
	public static Button next;
	public static Button last;
	
	public static TextView tv_name;
	public static SeekBar seekBar;
}



package com.tt;

import java.io.File; 
import java.io.FilenameFilter;

public class MusicFilter implements FilenameFilter{

	@Override
	public boolean accept(File dir, String filename) {
		// TODO Auto-generated method stub
		return (filename.endsWith(".mp3"));
	}

	 
}



package com.tt;

import java.io.File;
import java.util.ArrayList;
import java.util.List;

import android.app.ListActivity;
import android.media.MediaPlayer;
import android.media.MediaPlayer.OnCompletionListener;
import android.os.Bundle;
import android.os.Handler;
import android.view.KeyEvent;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.ArrayAdapter;
import android.widget.Button;
import android.widget.ListView;
import android.widget.SeekBar;
import android.widget.SeekBar.OnSeekBarChangeListener;
import android.widget.TextView;

public class musicActivity extends ListActivity {
	// 播放对象
	private MediaPlayer myMediaPlayer;
	// 播放列表
	private List myMusicList = new ArrayList();
	// 当前播放歌曲的索引
	private int currentListItem = 0;
	// 音乐的路径
	private static final String MUSIC_PATH = new String("/sdcard/");

	/** Called when the activity is first created. */
	@Override
	public void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.main);
		myMediaPlayer = new MediaPlayer();

		findView();
		musicList();
		listener();
	}

	// 绑定音乐
	void musicList() {
		File home = new File(MUSIC_PATH);
		if (home.listFiles(new MusicFilter()).length > 0) {
			for (File file : home.listFiles(new MusicFilter())) {
				myMusicList.add(file.getName());
			}
			ArrayAdapter musicList = new ArrayAdapter(
					musicActivity.this, R.layout.musicitme, myMusicList);
			setListAdapter(musicList);
		}
	}

	// 获取按钮
	void findView() {
		viewHolder.start = (Button) findViewById(R.id.start);
		viewHolder.stop = (Button) findViewById(R.id.stop);
		viewHolder.next = (Button) findViewById(R.id.next);
		viewHolder.pause = (Button) findViewById(R.id.pause);
		viewHolder.last = (Button) findViewById(R.id.last);

		viewHolder.tv_name = (TextView) findViewById(R.id.tv_name);
		viewHolder.seekBar = (SeekBar) findViewById(R.id.seekBar1);
	}

	boolean ispause = false;

	Handler handler = new Handler() {

	};
	Runnable runnable = new Runnable() {

		@Override
		public void run() {
			// TODO Auto-generated method stub
			if (myMediaPlayer.isPlaying()) {
				viewHolder.seekBar.setProgress(myMediaPlayer
						.getCurrentPosition());
			}
			handler.postDelayed(runnable, 500);
		}
	};

	// 监听事件
	void listener() {
		// 停止
		viewHolder.stop.setOnClickListener(new OnClickListener() {

			@Override
			public void onClick(View v) {
				// TODO Auto-generated method stub
				try {
					if (myMediaPlayer.isPlaying()) {
						myMediaPlayer.stop();
					}
				} catch (IllegalStateException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				viewHolder.start.setBackgroundDrawable(getResources()
						.getDrawable(R.drawable.start));
				handler.removeCallbacks(runnable);
			}
		});

		// 开始
		viewHolder.start.setOnClickListener(new OnClickListener() {

			@Override
			public void onClick(View v) {
				// TODO Auto-generated method stub

				try {
					if (null != myMediaPlayer && myMediaPlayer.isPlaying()) {
						ispause = true;
						myMediaPlayer.pause();
						v.setBackgroundDrawable(getResources().getDrawable(
								R.drawable.start));
					} else {
						if (!ispause) {
							playMusic(MUSIC_PATH
									+ myMusicList.get(currentListItem));
						} else {
							myMediaPlayer.start();
						}
						ispause = false;
						v.setBackgroundDrawable(getResources().getDrawable(
								R.drawable.pause));
					}

				} catch (IllegalStateException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}

			}
		});
		// 下一首
		viewHolder.next.setOnClickListener(new OnClickListener() {

			@Override
			public void onClick(View v) {
				// TODO Auto-generated method stub
				nextMusic();
			}
		});
		// 暂停
		viewHolder.pause.setOnClickListener(new OnClickListener() {

			@Override
			public void onClick(View v) {
				// TODO Auto-generated method stub
				if (myMediaPlayer.isPlaying()) {
					myMediaPlayer.pause();
				} else {
					myMediaPlayer.start();
				}
			}
		});
		// 上一首
		viewHolder.last.setOnClickListener(new OnClickListener() {

			@Override
			public void onClick(View v) {
				// TODO Auto-generated method stub

				lastMusic();
			}
		});

	}
	
	// 下一首
		void nextMusic() {
			if (++currentListItem >= myMusicList.size()) {
				currentListItem = 0;
			} else {
				playMusic(MUSIC_PATH + myMusicList.get(currentListItem));
			}
		}

		// 上一首
		void lastMusic() {
			if (currentListItem != 0) {
				if (--currentListItem < 0) {
					currentListItem = myMusicList.size();
				} else {
					playMusic(MUSIC_PATH + myMusicList.get(currentListItem));
				}
			} else {
				playMusic(MUSIC_PATH + myMusicList.get(currentListItem));
			}
		}

	// 播放音乐
	void playMusic(String path) {
		try {
			myMediaPlayer.reset();
			myMediaPlayer.setDataSource(path);
			myMediaPlayer.prepare();
			myMediaPlayer.start();
			myMediaPlayer.setOnCompletionListener(new OnCompletionListener() {

				@Override
				public void onCompletion(MediaPlayer mp) {
					// TODO Auto-generated method stub
					nextMusic();
				}
			});

			ispause = false;
			viewHolder.start.setBackgroundDrawable(getResources().getDrawable(
					R.drawable.pause));

			viewHolder.tv_name.setText(myMusicList.get(currentListItem));
			viewHolder.seekBar.setMax(myMediaPlayer.getDuration());// 设置音频的总时间长度
																	// ,毫秒
			viewHolder.seekBar
					.setOnSeekBarChangeListener(new OnSeekBarChangeListener() {

						@Override
						public void onStopTrackingTouch(SeekBar seekBar) {
							// TODO Auto-generated method stub

						}

						@Override
						public void onStartTrackingTouch(SeekBar seekBar) {
							// TODO Auto-generated method stub

						}

						@Override
						public void onProgressChanged(SeekBar seekBar,
								int progress, boolean fromUser) {
							// TODO Auto-generated method stub
							if (fromUser) {
								myMediaPlayer.seekTo(progress);
							}
						}
					});
			handler.post(runnable);

		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
	}

	

	// 当用户返回时结束音乐并释放音乐对象
	@Override
	public boolean onKeyDown(int keyCode, KeyEvent event) {
		// TODO Auto-generated method stub
		if (keyCode == KeyEvent.KEYCODE_BACK) {
			myMediaPlayer.stop();
			myMediaPlayer.release();
			this.finish();
			return true;
		}
		return super.onKeyDown(keyCode, event);
	}

	// 当选择列表项时播放音乐
	@Override
	protected void onListItemClick(ListView l, View v, int position, long id) {
		// TODO Auto-generated method stub
		currentListItem = position;
		playMusic(MUSIC_PATH + myMusicList.get(currentListItem));

	}

}




SeekBar源码

/*
 * Copyright (C) 2006 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package android.widget;

import android.content.Context;
import android.util.AttributeSet;



/**
 * A SeekBar is an extension of ProgressBar that adds a draggable thumb. The user can touch
 * the thumb and drag left or right to set the current progress level or use the arrow keys.
 * Placing focusable widgets to the left or right of a SeekBar is discouraged. 
 * 

* Clients of the SeekBar can attach a {@link SeekBar.OnSeekBarChangeListener} to * be notified of the user's actions. * * @attr ref android.R.styleable#SeekBar_thumb */ public class SeekBar extends AbsSeekBar { /** * A callback that notifies clients when the progress level has been * changed. This includes changes that were initiated by the user through a * touch gesture or arrow key/trackball as well as changes that were initiated * programmatically. */ public interface OnSeekBarChangeListener { /** * Notification that the progress level has changed. Clients can use the fromUser parameter * to distinguish user-initiated changes from those that occurred programmatically. * * @param seekBar The SeekBar whose progress has changed * @param progress The current progress level. This will be in the range 0..max where max * was set by {@link ProgressBar#setMax(int)}. (The default value for max is 100.) * @param fromUser True if the progress change was initiated by the user. */ void onProgressChanged(SeekBar seekBar, int progress, boolean fromUser); /** * Notification that the user has started a touch gesture. Clients may want to use this * to disable advancing the seekbar. * @param seekBar The SeekBar in which the touch gesture began */ void onStartTrackingTouch(SeekBar seekBar); /** * Notification that the user has finished a touch gesture. Clients may want to use this * to re-enable advancing the seekbar. * @param seekBar The SeekBar in which the touch gesture began */ void onStopTrackingTouch(SeekBar seekBar); } private OnSeekBarChangeListener mOnSeekBarChangeListener; public SeekBar(Context context) { this(context, null); } public SeekBar(Context context, AttributeSet attrs) { this(context, attrs, com.android.internal.R.attr.seekBarStyle); } public SeekBar(Context context, AttributeSet attrs, int defStyle) { super(context, attrs, defStyle); } @Override void onProgressRefresh(float scale, boolean fromUser) { super.onProgressRefresh(scale, fromUser); if (mOnSeekBarChangeListener != null) { mOnSeekBarChangeListener.onProgressChanged(this, getProgress(), fromUser); } } /** * Sets a listener to receive notifications of changes to the SeekBar's progress level. Also * provides notifications of when the user starts and stops a touch gesture within the SeekBar. * * @param l The seek bar notification listener * * @see SeekBar.OnSeekBarChangeListener */ public void setOnSeekBarChangeListener(OnSeekBarChangeListener l) { mOnSeekBarChangeListener = l; } @Override void onStartTrackingTouch() { super.onStartTrackingTouch(); if (mOnSeekBarChangeListener != null) { mOnSeekBarChangeListener.onStartTrackingTouch(this); } } @Override void onStopTrackingTouch() { super.onStopTrackingTouch(); if (mOnSeekBarChangeListener != null) { mOnSeekBarChangeListener.onStopTrackingTouch(this); } } }




MediaPlayer源码

/*
 * Copyright (C) 2006 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package android.media;

import android.content.ContentResolver;
import android.content.Context;
import android.content.res.AssetFileDescriptor;
import android.net.Uri;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.os.Parcel;
import android.os.ParcelFileDescriptor;
import android.os.PowerManager;
import android.util.Log;
import android.view.Surface;
import android.view.SurfaceHolder;
import android.graphics.Bitmap;
import android.graphics.SurfaceTexture;
import android.media.AudioManager;

import java.io.FileDescriptor;
import java.io.IOException;
import java.util.Map;
import java.util.Set;
import java.lang.ref.WeakReference;

/**
 * MediaPlayer class can be used to control playback
 * of audio/video files and streams. An example on how to use the methods in
 * this class can be found in {@link android.widget.VideoView}.
 *
 * 

Topics covered here are: *

    *
  1. State Diagram *
  2. Valid and Invalid States *
  3. Permissions *
  4. Register informational and error callbacks *
* *
*

Developer Guides

*

For more information about how to use MediaPlayer, read the * Media Playback developer guide.

*
* * *

State Diagram

* *

Playback control of audio/video files and streams is managed as a state * machine. The following diagram shows the life cycle and the states of a * MediaPlayer object driven by the supported playback control operations. * The ovals represent the states a MediaPlayer object may reside * in. The arcs represent the playback control operations that drive the object * state transition. There are two types of arcs. The arcs with a single arrow * head represent synchronous method calls, while those with * a double arrow head represent asynchronous method calls.

* *

MediaPlayer State diagram

* *

From this state diagram, one can see that a MediaPlayer object has the * following states:

*
    *
  • When a MediaPlayer object is just created using new or * after {@link #reset()} is called, it is in the Idle state; and after * {@link #release()} is called, it is in the End state. Between these * two states is the life cycle of the MediaPlayer object. *
      *
    • There is a subtle but important difference between a newly constructed * MediaPlayer object and the MediaPlayer object after {@link #reset()} * is called. It is a programming error to invoke methods such * as {@link #getCurrentPosition()}, * {@link #getDuration()}, {@link #getVideoHeight()}, * {@link #getVideoWidth()}, {@link #setAudioStreamType(int)}, * {@link #setLooping(boolean)}, * {@link #setVolume(float, float)}, {@link #pause()}, {@link #start()}, * {@link #stop()}, {@link #seekTo(int)}, {@link #prepare()} or * {@link #prepareAsync()} in the Idle state for both cases. If any of these * methods is called right after a MediaPlayer object is constructed, * the user supplied callback method OnErrorListener.onError() won't be * called by the internal player engine and the object state remains * unchanged; but if these methods are called right after {@link #reset()}, * the user supplied callback method OnErrorListener.onError() will be * invoked by the internal player engine and the object will be * transfered to the Error state.
    • *
    • It is also recommended that once * a MediaPlayer object is no longer being used, call {@link #release()} immediately * so that resources used by the internal player engine associated with the * MediaPlayer object can be released immediately. Resource may include * singleton resources such as hardware acceleration components and * failure to call {@link #release()} may cause subsequent instances of * MediaPlayer objects to fallback to software implementations or fail * altogether. Once the MediaPlayer * object is in the End state, it can no longer be used and * there is no way to bring it back to any other state.
    • *
    • Furthermore, * the MediaPlayer objects created using new is in the * Idle state, while those created with one * of the overloaded convenient create methods are NOT * in the Idle state. In fact, the objects are in the Prepared * state if the creation using create method is successful. *
    • *
    *
  • *
  • In general, some playback control operation may fail due to various * reasons, such as unsupported audio/video format, poorly interleaved * audio/video, resolution too high, streaming timeout, and the like. * Thus, error reporting and recovery is an important concern under * these circumstances. Sometimes, due to programming errors, invoking a playback * control operation in an invalid state may also occur. Under all these * error conditions, the internal player engine invokes a user supplied * OnErrorListener.onError() method if an OnErrorListener has been * registered beforehand via * {@link #setOnErrorListener(android.media.MediaPlayer.OnErrorListener)}. *
      *
    • It is important to note that once an error occurs, the * MediaPlayer object enters the Error state (except as noted * above), even if an error listener has not been registered by the application.
    • *
    • In order to reuse a MediaPlayer object that is in the * Error state and recover from the error, * {@link #reset()} can be called to restore the object to its Idle * state.
    • *
    • It is good programming practice to have your application * register a OnErrorListener to look out for error notifications from * the internal player engine.
    • *
    • IllegalStateException is * thrown to prevent programming errors such as calling {@link #prepare()}, * {@link #prepareAsync()}, or one of the overloaded setDataSource * methods in an invalid state.
    • *
    *
  • *
  • Calling * {@link #setDataSource(FileDescriptor)}, or * {@link #setDataSource(String)}, or * {@link #setDataSource(Context, Uri)}, or * {@link #setDataSource(FileDescriptor, long, long)} transfers a * MediaPlayer object in the Idle state to the * Initialized state. *
      *
    • An IllegalStateException is thrown if * setDataSource() is called in any other state.
    • *
    • It is good programming * practice to always look out for IllegalArgumentException * and IOException that may be thrown from the overloaded * setDataSource methods.
    • *
    *
  • *
  • A MediaPlayer object must first enter the Prepared state * before playback can be started. *
      *
    • There are two ways (synchronous vs. * asynchronous) that the Prepared state can be reached: * either a call to {@link #prepare()} (synchronous) which * transfers the object to the Prepared state once the method call * returns, or a call to {@link #prepareAsync()} (asynchronous) which * first transfers the object to the Preparing state after the * call returns (which occurs almost right way) while the internal * player engine continues working on the rest of preparation work * until the preparation work completes. When the preparation completes or when {@link #prepare()} call returns, * the internal player engine then calls a user supplied callback method, * onPrepared() of the OnPreparedListener interface, if an * OnPreparedListener is registered beforehand via {@link * #setOnPreparedListener(android.media.MediaPlayer.OnPreparedListener)}.
    • *
    • It is important to note that * the Preparing state is a transient state, and the behavior * of calling any method with side effect while a MediaPlayer object is * in the Preparing state is undefined.
    • *
    • An IllegalStateException is * thrown if {@link #prepare()} or {@link #prepareAsync()} is called in * any other state.
    • *
    • While in the Prepared state, properties * such as audio/sound volume, screenOnWhilePlaying, looping can be * adjusted by invoking the corresponding set methods.
    • *
    *
  • *
  • To start the playback, {@link #start()} must be called. After * {@link #start()} returns successfully, the MediaPlayer object is in the * Started state. {@link #isPlaying()} can be called to test * whether the MediaPlayer object is in the Started state. *
      *
    • While in the Started state, the internal player engine calls * a user supplied OnBufferingUpdateListener.onBufferingUpdate() callback * method if a OnBufferingUpdateListener has been registered beforehand * via {@link #setOnBufferingUpdateListener(OnBufferingUpdateListener)}. * This callback allows applications to keep track of the buffering status * while streaming audio/video.
    • *
    • Calling {@link #start()} has not effect * on a MediaPlayer object that is already in the Started state.
    • *
    *
  • *
  • Playback can be paused and stopped, and the current playback position * can be adjusted. Playback can be paused via {@link #pause()}. When the call to * {@link #pause()} returns, the MediaPlayer object enters the * Paused state. Note that the transition from the Started * state to the Paused state and vice versa happens * asynchronously in the player engine. It may take some time before * the state is updated in calls to {@link #isPlaying()}, and it can be * a number of seconds in the case of streamed content. *
      *
    • Calling {@link #start()} to resume playback for a paused * MediaPlayer object, and the resumed playback * position is the same as where it was paused. When the call to * {@link #start()} returns, the paused MediaPlayer object goes back to * the Started state.
    • *
    • Calling {@link #pause()} has no effect on * a MediaPlayer object that is already in the Paused state.
    • *
    *
  • *
  • Calling {@link #stop()} stops playback and causes a * MediaPlayer in the Started, Paused, Prepared * or PlaybackCompleted state to enter the * Stopped state. *
      *
    • Once in the Stopped state, playback cannot be started * until {@link #prepare()} or {@link #prepareAsync()} are called to set * the MediaPlayer object to the Prepared state again.
    • *
    • Calling {@link #stop()} has no effect on a MediaPlayer * object that is already in the Stopped state.
    • *
    *
  • *
  • The playback position can be adjusted with a call to * {@link #seekTo(int)}. *
      *
    • Although the asynchronuous {@link #seekTo(int)} * call returns right way, the actual seek operation may take a while to * finish, especially for audio/video being streamed. When the actual * seek operation completes, the internal player engine calls a user * supplied OnSeekComplete.onSeekComplete() if an OnSeekCompleteListener * has been registered beforehand via * {@link #setOnSeekCompleteListener(OnSeekCompleteListener)}.
    • *
    • Please * note that {@link #seekTo(int)} can also be called in the other states, * such as Prepared, Paused and PlaybackCompleted * state.
    • *
    • Furthermore, the actual current playback position * can be retrieved with a call to {@link #getCurrentPosition()}, which * is helpful for applications such as a Music player that need to keep * track of the playback progress.
    • *
    *
  • *
  • When the playback reaches the end of stream, the playback completes. *
      *
    • If the looping mode was being set to truewith * {@link #setLooping(boolean)}, the MediaPlayer object shall remain in * the Started state.
    • *
    • If the looping mode was set to false * , the player engine calls a user supplied callback method, * OnCompletion.onCompletion(), if a OnCompletionListener is registered * beforehand via {@link #setOnCompletionListener(OnCompletionListener)}. * The invoke of the callback signals that the object is now in the * PlaybackCompleted state.
    • *
    • While in the PlaybackCompleted * state, calling {@link #start()} can restart the playback from the * beginning of the audio/video source.
    • *
    * * * *

    Valid and invalid states

    * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
    Method Name

    Valid Sates

    Invalid States

    Comments

    attachAuxEffect

    {Initialized, Prepared, Started, Paused, Stopped, PlaybackCompleted}

    {Idle, Error}

    This method must be called after setDataSource. * Calling it does not change the object state.

    getAudioSessionId

    any

    {}

    This method can be called in any state and calling it does not change * the object state.

    getCurrentPosition

    {Idle, Initialized, Prepared, Started, Paused, Stopped, * PlaybackCompleted}

    {Error}

    Successful invoke of this method in a valid state does not change the * state. Calling this method in an invalid state transfers the object * to the Error state.

    getDuration

    {Prepared, Started, Paused, Stopped, PlaybackCompleted}

    {Idle, Initialized, Error}

    Successful invoke of this method in a valid state does not change the * state. Calling this method in an invalid state transfers the object * to the Error state.

    getVideoHeight

    {Idle, Initialized, Prepared, Started, Paused, Stopped, * PlaybackCompleted}

    {Error}

    Successful invoke of this method in a valid state does not change the * state. Calling this method in an invalid state transfers the object * to the Error state.

    getVideoWidth

    {Idle, Initialized, Prepared, Started, Paused, Stopped, * PlaybackCompleted}

    {Error}

    Successful invoke of this method in a valid state does not change * the state. Calling this method in an invalid state transfers the * object to the Error state.

    isPlaying

    {Idle, Initialized, Prepared, Started, Paused, Stopped, * PlaybackCompleted}

    {Error}

    Successful invoke of this method in a valid state does not change * the state. Calling this method in an invalid state transfers the * object to the Error state.

    pause

    {Started, Paused}

    {Idle, Initialized, Prepared, Stopped, PlaybackCompleted, Error}

    Successful invoke of this method in a valid state transfers the * object to the Paused state. Calling this method in an * invalid state transfers the object to the Error state.

    prepare

    {Initialized, Stopped}

    {Idle, Prepared, Started, Paused, PlaybackCompleted, Error}

    Successful invoke of this method in a valid state transfers the * object to the Prepared state. Calling this method in an * invalid state throws an IllegalStateException.

    prepareAsync

    {Initialized, Stopped}

    {Idle, Prepared, Started, Paused, PlaybackCompleted, Error}

    Successful invoke of this method in a valid state transfers the * object to the Preparing state. Calling this method in an * invalid state throws an IllegalStateException.

    release

    any

    {}

    After {@link #release()}, the object is no longer available.

    reset

    {Idle, Initialized, Prepared, Started, Paused, Stopped, * PlaybackCompleted, Error}

    {}

    After {@link #reset()}, the object is like being just created.

    seekTo

    {Prepared, Started, Paused, PlaybackCompleted}

    {Idle, Initialized, Stopped, Error}

    Successful invoke of this method in a valid state does not change * the state. Calling this method in an invalid state transfers the * object to the Error state.

    setAudioSessionId

    {Idle}

    {Initialized, Prepared, Started, Paused, Stopped, PlaybackCompleted, * Error}

    This method must be called in idle state as the audio session ID must be known before * calling setDataSource. Calling it does not change the object state.

    setAudioStreamType

    {Idle, Initialized, Stopped, Prepared, Started, Paused, * PlaybackCompleted}

    {Error}

    Successful invoke of this method does not change the state. In order for the * target audio stream type to become effective, this method must be called before * prepare() or prepareAsync().

    setAuxEffectSendLevel

    any

    {}

    Calling this method does not change the object state.

    setDataSource

    {Idle}

    {Initialized, Prepared, Started, Paused, Stopped, PlaybackCompleted, * Error}

    Successful invoke of this method in a valid state transfers the * object to the Initialized state. Calling this method in an * invalid state throws an IllegalStateException.

    setDisplay

    any

    {}

    This method can be called in any state and calling it does not change * the object state.

    setSurface

    any

    {}

    This method can be called in any state and calling it does not change * the object state.

    setLooping

    {Idle, Initialized, Stopped, Prepared, Started, Paused, * PlaybackCompleted}

    {Error}

    Successful invoke of this method in a valid state does not change * the state. Calling this method in an * invalid state transfers the object to the Error state.

    isLooping

    any

    {}

    This method can be called in any state and calling it does not change * the object state.

    setOnBufferingUpdateListener

    any

    {}

    This method can be called in any state and calling it does not change * the object state.

    setOnCompletionListener

    any

    {}

    This method can be called in any state and calling it does not change * the object state.

    setOnErrorListener

    any

    {}

    This method can be called in any state and calling it does not change * the object state.

    setOnPreparedListener

    any

    {}

    This method can be called in any state and calling it does not change * the object state.

    setOnSeekCompleteListener

    any

    {}

    This method can be called in any state and calling it does not change * the object state.

    setScreenOnWhilePlayingany

    {}

    This method can be called in any state and calling it does not change * the object state.

    setVolume

    {Idle, Initialized, Stopped, Prepared, Started, Paused, * PlaybackCompleted}

    {Error}

    Successful invoke of this method does not change the state. *
    setWakeMode

    any

    {}

    This method can be called in any state and calling it does not change * the object state.

    start

    {Prepared, Started, Paused, PlaybackCompleted}

    {Idle, Initialized, Stopped, Error}

    Successful invoke of this method in a valid state transfers the * object to the Started state. Calling this method in an * invalid state transfers the object to the Error state.

    stop

    {Prepared, Started, Stopped, Paused, PlaybackCompleted}

    {Idle, Initialized, Error}

    Successful invoke of this method in a valid state transfers the * object to the Stopped state. Calling this method in an * invalid state transfers the object to the Error state.

    * * *

    Permissions

    *

    One may need to declare a corresponding WAKE_LOCK permission {@link * android.R.styleable#AndroidManifestUsesPermission } * element. * *

    This class requires the {@link android.Manifest.permission#INTERNET} permission * when used with network-based content. * * *

    Callbacks

    *

    Applications may want to register for informational and error * events in order to be informed of some internal state update and * possible runtime errors during playback or streaming. Registration for * these events is done by properly setting the appropriate listeners (via calls * to * {@link #setOnPreparedListener(OnPreparedListener)}setOnPreparedListener, * {@link #setOnVideoSizeChangedListener(OnVideoSizeChangedListener)}setOnVideoSizeChangedListener, * {@link #setOnSeekCompleteListener(OnSeekCompleteListener)}setOnSeekCompleteListener, * {@link #setOnCompletionListener(OnCompletionListener)}setOnCompletionListener, * {@link #setOnBufferingUpdateListener(OnBufferingUpdateListener)}setOnBufferingUpdateListener, * {@link #setOnInfoListener(OnInfoListener)}setOnInfoListener, * {@link #setOnErrorListener(OnErrorListener)}setOnErrorListener, etc). * In order to receive the respective callback * associated with these listeners, applications are required to create * MediaPlayer objects on a thread with its own Looper running (main UI * thread by default has a Looper running). * */ public class MediaPlayer { /** Constant to retrieve only the new metadata since the last call. // FIXME: unhide. // FIXME: add link to getMetadata(boolean, boolean) {@hide} */ public static final boolean METADATA_UPDATE_ONLY = true; /** Constant to retrieve all the metadata. // FIXME: unhide. // FIXME: add link to getMetadata(boolean, boolean) {@hide} */ public static final boolean METADATA_ALL = false; /** Constant to enable the metadata filter during retrieval. // FIXME: unhide. // FIXME: add link to getMetadata(boolean, boolean) {@hide} */ public static final boolean APPLY_METADATA_FILTER = true; /** Constant to disable the metadata filter during retrieval. // FIXME: unhide. // FIXME: add link to getMetadata(boolean, boolean) {@hide} */ public static final boolean BYPASS_METADATA_FILTER = false; static { System.loadLibrary("media_jni"); native_init(); } private final static String TAG = "MediaPlayer"; // Name of the remote interface for the media player. Must be kept // in sync with the 2nd parameter of the IMPLEMENT_META_INTERFACE // macro invocation in IMediaPlayer.cpp private final static String IMEDIA_PLAYER = "android.media.IMediaPlayer"; private int mNativeContext; // accessed by native methods private int mNativeSurfaceTexture; // accessed by native methods private int mListenerContext; // accessed by native methods private SurfaceHolder mSurfaceHolder; private EventHandler mEventHandler; private PowerManager.WakeLock mWakeLock = null; private boolean mScreenOnWhilePlaying; private boolean mStayAwake; /** * Default constructor. Consider using one of the create() methods for * synchronously instantiating a MediaPlayer from a Uri or resource. *

    When done with the MediaPlayer, you should call {@link #release()}, * to free the resources. If not released, too many MediaPlayer instances may * result in an exception.

    */ public MediaPlayer() { Looper looper; if ((looper = Looper.myLooper()) != null) { mEventHandler = new EventHandler(this, looper); } else if ((looper = Looper.getMainLooper()) != null) { mEventHandler = new EventHandler(this, looper); } else { mEventHandler = null; } /* Native setup requires a weak reference to our object. * It's easier to create it here than in C++. */ native_setup(new WeakReference(this)); } /* * Update the MediaPlayer SurfaceTexture. * Call after setting a new display surface. */ private native void _setVideoSurface(Surface surface); /** * Create a request parcel which can be routed to the native media * player using {@link #invoke(Parcel, Parcel)}. The Parcel * returned has the proper InterfaceToken set. The caller should * not overwrite that token, i.e it can only append data to the * Parcel. * * @return A parcel suitable to hold a request for the native * player. * {@hide} */ public Parcel newRequest() { Parcel parcel = Parcel.obtain(); parcel.writeInterfaceToken(IMEDIA_PLAYER); return parcel; } /** * Invoke a generic method on the native player using opaque * parcels for the request and reply. Both payloads' format is a * convention between the java caller and the native player. * Must be called after setDataSource to make sure a native player * exists. * * @param request Parcel with the data for the extension. The * caller must use {@link #newRequest()} to get one. * * @param reply Output parcel with the data returned by the * native player. * * @return The status code see utils/Errors.h * {@hide} */ public int invoke(Parcel request, Parcel reply) { int retcode = native_invoke(request, reply); reply.setDataPosition(0); return retcode; } /** * Sets the {@link SurfaceHolder} to use for displaying the video * portion of the media. * * Either a surface holder or surface must be set if a display or video sink * is needed. Not calling this method or {@link #setSurface(Surface)} * when playing back a video will result in only the audio track being played. * A null surface holder or surface will result in only the audio track being * played. * * @param sh the SurfaceHolder to use for video display */ public void setDisplay(SurfaceHolder sh) { mSurfaceHolder = sh; Surface surface; if (sh != null) { surface = sh.getSurface(); } else { surface = null; } _setVideoSurface(surface); updateSurfaceScreenOn(); } /** * Sets the {@link Surface} to be used as the sink for the video portion of * the media. This is similar to {@link #setDisplay(SurfaceHolder)}, but * does not support {@link #setScreenOnWhilePlaying(boolean)}. Setting a * Surface will un-set any Surface or SurfaceHolder that was previously set. * A null surface will result in only the audio track being played. * * If the Surface sends frames to a {@link SurfaceTexture}, the timestamps * returned from {@link SurfaceTexture#getTimestamp()} will have an * unspecified zero point. These timestamps cannot be directly compared * between different media sources, different instances of the same media * source, or multiple runs of the same program. The timestamp is normally * monotonically increasing and is unaffected by time-of-day adjustments, * but it is reset when the position is set. * * @param surface The {@link Surface} to be used for the video portion of * the media. */ public void setSurface(Surface surface) { if (mScreenOnWhilePlaying && surface != null) { Log.w(TAG, "setScreenOnWhilePlaying(true) is ineffective for Surface"); } mSurfaceHolder = null; _setVideoSurface(surface); updateSurfaceScreenOn(); } /** * Convenience method to create a MediaPlayer for a given Uri. * On success, {@link #prepare()} will already have been called and must not be called again. *

    When done with the MediaPlayer, you should call {@link #release()}, * to free the resources. If not released, too many MediaPlayer instances will * result in an exception.

    * * @param context the Context to use * @param uri the Uri from which to get the datasource * @return a MediaPlayer object, or null if creation failed */ public static MediaPlayer create(Context context, Uri uri) { return create (context, uri, null); } /** * Convenience method to create a MediaPlayer for a given Uri. * On success, {@link #prepare()} will already have been called and must not be called again. *

    When done with the MediaPlayer, you should call {@link #release()}, * to free the resources. If not released, too many MediaPlayer instances will * result in an exception.

    * * @param context the Context to use * @param uri the Uri from which to get the datasource * @param holder the SurfaceHolder to use for displaying the video * @return a MediaPlayer object, or null if creation failed */ public static MediaPlayer create(Context context, Uri uri, SurfaceHolder holder) { try { MediaPlayer mp = new MediaPlayer(); mp.setDataSource(context, uri); if (holder != null) { mp.setDisplay(holder); } mp.prepare(); return mp; } catch (IOException ex) { Log.d(TAG, "create failed:", ex); // fall through } catch (IllegalArgumentException ex) { Log.d(TAG, "create failed:", ex); // fall through } catch (SecurityException ex) { Log.d(TAG, "create failed:", ex); // fall through } return null; } // Note no convenience method to create a MediaPlayer with SurfaceTexture sink. /** * Convenience method to create a MediaPlayer for a given resource id. * On success, {@link #prepare()} will already have been called and must not be called again. *

    When done with the MediaPlayer, you should call {@link #release()}, * to free the resources. If not released, too many MediaPlayer instances will * result in an exception.

    * * @param context the Context to use * @param resid the raw resource id (R.raw.) for * the resource to use as the datasource * @return a MediaPlayer object, or null if creation failed */ public static MediaPlayer create(Context context, int resid) { try { AssetFileDescriptor afd = context.getResources().openRawResourceFd(resid); if (afd == null) return null; MediaPlayer mp = new MediaPlayer(); mp.setDataSource(afd.getFileDescriptor(), afd.getStartOffset(), afd.getLength()); afd.close(); mp.prepare(); return mp; } catch (IOException ex) { Log.d(TAG, "create failed:", ex); // fall through } catch (IllegalArgumentException ex) { Log.d(TAG, "create failed:", ex); // fall through } catch (SecurityException ex) { Log.d(TAG, "create failed:", ex); // fall through } return null; } /** * Sets the data source as a content Uri. * * @param context the Context to use when resolving the Uri * @param uri the Content URI of the data you want to play * @throws IllegalStateException if it is called in an invalid state */ public void setDataSource(Context context, Uri uri) throws IOException, IllegalArgumentException, SecurityException, IllegalStateException { setDataSource(context, uri, null); } /** * Sets the data source as a content Uri. * * @param context the Context to use when resolving the Uri * @param uri the Content URI of the data you want to play * @param headers the headers to be sent together with the request for the data * @throws IllegalStateException if it is called in an invalid state */ public void setDataSource(Context context, Uri uri, Map headers) throws IOException, IllegalArgumentException, SecurityException, IllegalStateException { String scheme = uri.getScheme(); if(scheme == null || scheme.equals("file")) { setDataSource(uri.getPath()); return; } AssetFileDescriptor fd = null; try { ContentResolver resolver = context.getContentResolver(); fd = resolver.openAssetFileDescriptor(uri, "r"); if (fd == null) { return; } // Note: using getDeclaredLength so that our behavior is the same // as previous versions when the content provider is returning // a full file. if (fd.getDeclaredLength() < 0) { setDataSource(fd.getFileDescriptor()); } else { setDataSource(fd.getFileDescriptor(), fd.getStartOffset(), fd.getDeclaredLength()); } return; } catch (SecurityException ex) { } catch (IOException ex) { } finally { if (fd != null) { fd.close(); } } Log.d(TAG, "Couldn't open file on client side, trying server side"); setDataSource(uri.toString(), headers); return; } /** * Sets the data source (file-path or http/rtsp URL) to use. * * @param path the path of the file, or the http/rtsp URL of the stream you want to play * @throws IllegalStateException if it is called in an invalid state */ public native void setDataSource(String path) throws IOException, IllegalArgumentException, SecurityException, IllegalStateException; /** * Sets the data source (file-path or http/rtsp URL) to use. * * @param path the path of the file, or the http/rtsp URL of the stream you want to play * @param headers the headers associated with the http request for the stream you want to play * @throws IllegalStateException if it is called in an invalid state * @hide pending API council */ public void setDataSource(String path, Map headers) throws IOException, IllegalArgumentException, SecurityException, IllegalStateException { String[] keys = null; String[] values = null; if (headers != null) { keys = new String[headers.size()]; values = new String[headers.size()]; int i = 0; for (Map.Entry entry: headers.entrySet()) { keys[i] = entry.getKey(); values[i] = entry.getValue(); ++i; } } _setDataSource(path, keys, values); } private native void _setDataSource( String path, String[] keys, String[] values) throws IOException, IllegalArgumentException, SecurityException, IllegalStateException; /** * Sets the data source (FileDescriptor) to use. It is the caller's responsibility * to close the file descriptor. It is safe to do so as soon as this call returns. * * @param fd the FileDescriptor for the file you want to play * @throws IllegalStateException if it is called in an invalid state */ public void setDataSource(FileDescriptor fd) throws IOException, IllegalArgumentException, IllegalStateException { // intentionally less than LONG_MAX setDataSource(fd, 0, 0x7ffffffffffffffL); } /** * Sets the data source (FileDescriptor) to use. The FileDescriptor must be * seekable (N.B. a LocalSocket is not seekable). It is the caller's responsibility * to close the file descriptor. It is safe to do so as soon as this call returns. * * @param fd the FileDescriptor for the file you want to play * @param offset the offset into the file where the data to be played starts, in bytes * @param length the length in bytes of the data to be played * @throws IllegalStateException if it is called in an invalid state */ public native void setDataSource(FileDescriptor fd, long offset, long length) throws IOException, IllegalArgumentException, IllegalStateException; /** * Prepares the player for playback, synchronously. * * After setting the datasource and the display surface, you need to either * call prepare() or prepareAsync(). For files, it is OK to call prepare(), * which blocks until MediaPlayer is ready for playback. * * @throws IllegalStateException if it is called in an invalid state */ public native void prepare() throws IOException, IllegalStateException; /** * Prepares the player for playback, asynchronously. * * After setting the datasource and the display surface, you need to either * call prepare() or prepareAsync(). For streams, you should call prepareAsync(), * which returns immediately, rather than blocking until enough data has been * buffered. * * @throws IllegalStateException if it is called in an invalid state */ public native void prepareAsync() throws IllegalStateException; /** * Starts or resumes playback. If playback had previously been paused, * playback will continue from where it was paused. If playback had * been stopped, or never started before, playback will start at the * beginning. * * @throws IllegalStateException if it is called in an invalid state */ public void start() throws IllegalStateException { stayAwake(true); _start(); } private native void _start() throws IllegalStateException; /** * Stops playback after playback has been stopped or paused. * * @throws IllegalStateException if the internal player engine has not been * initialized. */ public void stop() throws IllegalStateException { stayAwake(false); _stop(); } private native void _stop() throws IllegalStateException; /** * Pauses playback. Call start() to resume. * * @throws IllegalStateException if the internal player engine has not been * initialized. */ public void pause() throws IllegalStateException { stayAwake(false); _pause(); } private native void _pause() throws IllegalStateException; /** * Set the low-level power management behavior for this MediaPlayer. This * can be used when the MediaPlayer is not playing through a SurfaceHolder * set with {@link #setDisplay(SurfaceHolder)} and thus can use the * high-level {@link #setScreenOnWhilePlaying(boolean)} feature. * *

    This function has the MediaPlayer access the low-level power manager * service to control the device's power usage while playing is occurring. * The parameter is a combination of {@link android.os.PowerManager} wake flags. * Use of this method requires {@link android.Manifest.permission#WAKE_LOCK} * permission. * By default, no attempt is made to keep the device awake during playback. * * @param context the Context to use * @param mode the power/wake mode to set * @see android.os.PowerManager */ public void setWakeMode(Context context, int mode) { boolean washeld = false; if (mWakeLock != null) { if (mWakeLock.isHeld()) { washeld = true; mWakeLock.release(); } mWakeLock = null; } PowerManager pm = (PowerManager)context.getSystemService(Context.POWER_SERVICE); mWakeLock = pm.newWakeLock(mode|PowerManager.ON_AFTER_RELEASE, MediaPlayer.class.getName()); mWakeLock.setReferenceCounted(false); if (washeld) { mWakeLock.acquire(); } } /** * Control whether we should use the attached SurfaceHolder to keep the * screen on while video playback is occurring. This is the preferred * method over {@link #setWakeMode} where possible, since it doesn't * require that the application have permission for low-level wake lock * access. * * @param screenOn Supply true to keep the screen on, false to allow it * to turn off. */ public void setScreenOnWhilePlaying(boolean screenOn) { if (mScreenOnWhilePlaying != screenOn) { if (screenOn && mSurfaceHolder == null) { Log.w(TAG, "setScreenOnWhilePlaying(true) is ineffective without a SurfaceHolder"); } mScreenOnWhilePlaying = screenOn; updateSurfaceScreenOn(); } } private void stayAwake(boolean awake) { if (mWakeLock != null) { if (awake && !mWakeLock.isHeld()) { mWakeLock.acquire(); } else if (!awake && mWakeLock.isHeld()) { mWakeLock.release(); } } mStayAwake = awake; updateSurfaceScreenOn(); } private void updateSurfaceScreenOn() { if (mSurfaceHolder != null) { mSurfaceHolder.setKeepScreenOn(mScreenOnWhilePlaying && mStayAwake); } } /** * Returns the width of the video. * * @return the width of the video, or 0 if there is no video, * no display surface was set, or the width has not been determined * yet. The OnVideoSizeChangedListener can be registered via * {@link #setOnVideoSizeChangedListener(OnVideoSizeChangedListener)} * to provide a notification when the width is available. */ public native int getVideoWidth(); /** * Returns the height of the video. * * @return the height of the video, or 0 if there is no video, * no display surface was set, or the height has not been determined * yet. The OnVideoSizeChangedListener can be registered via * {@link #setOnVideoSizeChangedListener(OnVideoSizeChangedListener)} * to provide a notification when the height is available. */ public native int getVideoHeight(); /** * Checks whether the MediaPlayer is playing. * * @return true if currently playing, false otherwise */ public native boolean isPlaying(); /** * Seeks to specified time position. * * @param msec the offset in milliseconds from the start to seek to * @throws IllegalStateException if the internal player engine has not been * initialized */ public native void seekTo(int msec) throws IllegalStateException; /** * Gets the current playback position. * * @return the current position in milliseconds */ public native int getCurrentPosition(); /** * Gets the duration of the file. * * @return the duration in milliseconds */ public native int getDuration(); /** * Gets the media metadata. * * @param update_only controls whether the full set of available * metadata is returned or just the set that changed since the * last call. See {@see #METADATA_UPDATE_ONLY} and {@see * #METADATA_ALL}. * * @param apply_filter if true only metadata that matches the * filter is returned. See {@see #APPLY_METADATA_FILTER} and {@see * #BYPASS_METADATA_FILTER}. * * @return The metadata, possibly empty. null if an error occured. // FIXME: unhide. * {@hide} */ public Metadata getMetadata(final boolean update_only, final boolean apply_filter) { Parcel reply = Parcel.obtain(); Metadata data = new Metadata(); if (!native_getMetadata(update_only, apply_filter, reply)) { reply.recycle(); return null; } // Metadata takes over the parcel, don't recycle it unless // there is an error. if (!data.parse(reply)) { reply.recycle(); return null; } return data; } /** * Set a filter for the metadata update notification and update * retrieval. The caller provides 2 set of metadata keys, allowed * and blocked. The blocked set always takes precedence over the * allowed one. * Metadata.MATCH_ALL and Metadata.MATCH_NONE are 2 sets available as * shorthands to allow/block all or no metadata. * * By default, there is no filter set. * * @param allow Is the set of metadata the client is interested * in receiving new notifications for. * @param block Is the set of metadata the client is not interested * in receiving new notifications for. * @return The call status code. * // FIXME: unhide. * {@hide} */ public int setMetadataFilter(Set allow, Set block) { // Do our serialization manually instead of calling // Parcel.writeArray since the sets are made of the same type // we avoid paying the price of calling writeValue (used by // writeArray) which burns an extra int per element to encode // the type. Parcel request = newRequest(); // The parcel starts already with an interface token. There // are 2 filters. Each one starts with a 4bytes number to // store the len followed by a number of int (4 bytes as well) // representing the metadata type. int capacity = request.dataSize() + 4 * (1 + allow.size() + 1 + block.size()); if (request.dataCapacity() < capacity) { request.setDataCapacity(capacity); } request.writeInt(allow.size()); for(Integer t: allow) { request.writeInt(t); } request.writeInt(block.size()); for(Integer t: block) { request.writeInt(t); } return native_setMetadataFilter(request); } /** * Releases resources associated with this MediaPlayer object. * It is considered good practice to call this method when you're * done using the MediaPlayer. In particular, whenever an Activity * of an application is paused (its onPause() method is called), * or stopped (its onStop() method is called), this method should be * invoked to release the MediaPlayer object, unless the application * has a special need to keep the object around. In addition to * unnecessary resources (such as memory and instances of codecs) * being held, failure to call this method immediately if a * MediaPlayer object is no longer needed may also lead to * continuous battery consumption for mobile devices, and playback * failure for other applications if no multiple instances of the * same codec are supported on a device. Even if multiple instances * of the same codec are supported, some performance degradation * may be expected when unnecessary multiple instances are used * at the same time. */ public void release() { stayAwake(false); updateSurfaceScreenOn(); mOnPreparedListener = null; mOnBufferingUpdateListener = null; mOnCompletionListener = null; mOnSeekCompleteListener = null; mOnErrorListener = null; mOnInfoListener = null; mOnVideoSizeChangedListener = null; mOnTimedTextListener = null; _release(); } private native void _release(); /** * Resets the MediaPlayer to its uninitialized state. After calling * this method, you will have to initialize it again by setting the * data source and calling prepare(). */ public void reset() { stayAwake(false); _reset(); // make sure none of the listeners get called anymore mEventHandler.removeCallbacksAndMessages(null); } private native void _reset(); /** * Sets the audio stream type for this MediaPlayer. See {@link AudioManager} * for a list of stream types. Must call this method before prepare() or * prepareAsync() in order for the target stream type to become effective * thereafter. * * @param streamtype the audio stream type * @see android.media.AudioManager */ public native void setAudioStreamType(int streamtype); /** * Sets the player to be looping or non-looping. * * @param looping whether to loop or not */ public native void setLooping(boolean looping); /** * Checks whether the MediaPlayer is looping or non-looping. * * @return true if the MediaPlayer is currently looping, false otherwise */ public native boolean isLooping(); /** * Sets the volume on this player. * This API is recommended for balancing the output of audio streams * within an application. Unless you are writing an application to * control user settings, this API should be used in preference to * {@link AudioManager#setStreamVolume(int, int, int)} which sets the volume of ALL streams of * a particular type. Note that the passed volume values are raw scalars. * UI controls should be scaled logarithmically. * * @param leftVolume left volume scalar * @param rightVolume right volume scalar */ public native void setVolume(float leftVolume, float rightVolume); /** * Currently not implemented, returns null. * @deprecated * @hide */ public native Bitmap getFrameAt(int msec) throws IllegalStateException; /** * Sets the audio session ID. * * @param sessionId the audio session ID. * The audio session ID is a system wide unique identifier for the audio stream played by * this MediaPlayer instance. * The primary use of the audio session ID is to associate audio effects to a particular * instance of MediaPlayer: if an audio session ID is provided when creating an audio effect, * this effect will be applied only to the audio content of media players within the same * audio session and not to the output mix. * When created, a MediaPlayer instance automatically generates its own audio session ID. * However, it is possible to force this player to be part of an already existing audio session * by calling this method. * This method must be called before one of the overloaded setDataSource methods. * @throws IllegalStateException if it is called in an invalid state */ public native void setAudioSessionId(int sessionId) throws IllegalArgumentException, IllegalStateException; /** * Returns the audio session ID. * * @return the audio session ID. {@see #setAudioSessionId(int)} * Note that the audio session ID is 0 only if a problem occured when the MediaPlayer was contructed. */ public native int getAudioSessionId(); /** * Attaches an auxiliary effect to the player. A typical auxiliary effect is a reverberation * effect which can be applied on any sound source that directs a certain amount of its * energy to this effect. This amount is defined by setAuxEffectSendLevel(). * {@see #setAuxEffectSendLevel(float)}. *

    After creating an auxiliary effect (e.g. * {@link android.media.audiofx.EnvironmentalReverb}), retrieve its ID with * {@link android.media.audiofx.AudioEffect#getId()} and use it when calling this method * to attach the player to the effect. *

    To detach the effect from the player, call this method with a null effect id. *

    This method must be called after one of the overloaded setDataSource * methods. * @param effectId system wide unique id of the effect to attach */ public native void attachAuxEffect(int effectId); /* Do not change these values (starting with KEY_PARAMETER) without updating * their counterparts in include/media/mediaplayer.h! */ /* * Key used in setParameter method. * Indicates the index of the timed text track to be enabled/disabled. * The index includes both the in-band and out-of-band timed text. * The index should start from in-band text if any. Application can retrieve the number * of in-band text tracks by using MediaMetadataRetriever::extractMetadata(). * Note it might take a few hundred ms to scan an out-of-band text file * before displaying it. */ private static final int KEY_PARAMETER_TIMED_TEXT_TRACK_INDEX = 1000; /* * Key used in setParameter method. * Used to add out-of-band timed text source path. * Application can add multiple text sources by calling setParameter() with * KEY_PARAMETER_TIMED_TEXT_ADD_OUT_OF_BAND_SOURCE multiple times. */ private static final int KEY_PARAMETER_TIMED_TEXT_ADD_OUT_OF_BAND_SOURCE = 1001; // There are currently no defined keys usable from Java with get*Parameter. // But if any keys are defined, the order must be kept in sync with include/media/mediaplayer.h. // private static final int KEY_PARAMETER_... = ...; /** * Sets the parameter indicated by key. * @param key key indicates the parameter to be set. * @param value value of the parameter to be set. * @return true if the parameter is set successfully, false otherwise * {@hide} */ public native boolean setParameter(int key, Parcel value); /** * Sets the parameter indicated by key. * @param key key indicates the parameter to be set. * @param value value of the parameter to be set. * @return true if the parameter is set successfully, false otherwise * {@hide} */ public boolean setParameter(int key, String value) { Parcel p = Parcel.obtain(); p.writeString(value); boolean ret = setParameter(key, p); p.recycle(); return ret; } /** * Sets the parameter indicated by key. * @param key key indicates the parameter to be set. * @param value value of the parameter to be set. * @return true if the parameter is set successfully, false otherwise * {@hide} */ public boolean setParameter(int key, int value) { Parcel p = Parcel.obtain(); p.writeInt(value); boolean ret = setParameter(key, p); p.recycle(); return ret; } /** * Gets the value of the parameter indicated by key. * @param key key indicates the parameter to get. * @param reply value of the parameter to get. */ private native void getParameter(int key, Parcel reply); /** * Gets the value of the parameter indicated by key. * The caller is responsible for recycling the returned parcel. * @param key key indicates the parameter to get. * @return value of the parameter. * {@hide} */ public Parcel getParcelParameter(int key) { Parcel p = Parcel.obtain(); getParameter(key, p); return p; } /** * Gets the value of the parameter indicated by key. * @param key key indicates the parameter to get. * @return value of the parameter. * {@hide} */ public String getStringParameter(int key) { Parcel p = Parcel.obtain(); getParameter(key, p); String ret = p.readString(); p.recycle(); return ret; } /** * Gets the value of the parameter indicated by key. * @param key key indicates the parameter to get. * @return value of the parameter. * {@hide} */ public int getIntParameter(int key) { Parcel p = Parcel.obtain(); getParameter(key, p); int ret = p.readInt(); p.recycle(); return ret; } /** * Sets the send level of the player to the attached auxiliary effect * {@see #attachAuxEffect(int)}. The level value range is 0 to 1.0. *

    By default the send level is 0, so even if an effect is attached to the player * this method must be called for the effect to be applied. *

    Note that the passed level value is a raw scalar. UI controls should be scaled * logarithmically: the gain applied by audio framework ranges from -72dB to 0dB, * so an appropriate conversion from linear UI input x to level is: * x == 0 -> level = 0 * 0 < x <= R -> level = 10^(72*(x-R)/20/R) * @param level send level scalar */ public native void setAuxEffectSendLevel(float level); /** * @param request Parcel destinated to the media player. The * Interface token must be set to the IMediaPlayer * one to be routed correctly through the system. * @param reply[out] Parcel that will contain the reply. * @return The status code. */ private native final int native_invoke(Parcel request, Parcel reply); /** * @param update_only If true fetch only the set of metadata that have * changed since the last invocation of getMetadata. * The set is built using the unfiltered * notifications the native player sent to the * MediaPlayerService during that period of * time. If false, all the metadatas are considered. * @param apply_filter If true, once the metadata set has been built based on * the value update_only, the current filter is applied. * @param reply[out] On return contains the serialized * metadata. Valid only if the call was successful. * @return The status code. */ private native final boolean native_getMetadata(boolean update_only, boolean apply_filter, Parcel reply); /** * @param request Parcel with the 2 serialized lists of allowed * metadata types followed by the one to be * dropped. Each list starts with an integer * indicating the number of metadata type elements. * @return The status code. */ private native final int native_setMetadataFilter(Parcel request); private static native final void native_init(); private native final void native_setup(Object mediaplayer_this); private native final void native_finalize(); /** * @param index The index of the text track to be turned on. * @return true if the text track is enabled successfully. * {@hide} */ public boolean enableTimedTextTrackIndex(int index) { if (index < 0) { return false; } return setParameter(KEY_PARAMETER_TIMED_TEXT_TRACK_INDEX, index); } /** * Enables the first timed text track if any. * @return true if the text track is enabled successfully * {@hide} */ public boolean enableTimedText() { return enableTimedTextTrackIndex(0); } /** * Disables timed text display. * @return true if the text track is disabled successfully. * {@hide} */ public boolean disableTimedText() { return setParameter(KEY_PARAMETER_TIMED_TEXT_TRACK_INDEX, -1); } /** * @param reply Parcel with audio/video duration info for battery tracking usage * @return The status code. * {@hide} */ public native static int native_pullBatteryData(Parcel reply); @Override protected void finalize() { native_finalize(); } /* Do not change these values without updating their counterparts * in include/media/mediaplayer.h! */ private static final int MEDIA_NOP = 0; // interface test message private static final int MEDIA_PREPARED = 1; private static final int MEDIA_PLAYBACK_COMPLETE = 2; private static final int MEDIA_BUFFERING_UPDATE = 3; private static final int MEDIA_SEEK_COMPLETE = 4; private static final int MEDIA_SET_VIDEO_SIZE = 5; private static final int MEDIA_TIMED_TEXT = 99; private static final int MEDIA_ERROR = 100; private static final int MEDIA_INFO = 200; private class EventHandler extends Handler { private MediaPlayer mMediaPlayer; public EventHandler(MediaPlayer mp, Looper looper) { super(looper); mMediaPlayer = mp; } @Override public void handleMessage(Message msg) { if (mMediaPlayer.mNativeContext == 0) { Log.w(TAG, "mediaplayer went away with unhandled events"); return; } switch(msg.what) { case MEDIA_PREPARED: if (mOnPreparedListener != null) mOnPreparedListener.onPrepared(mMediaPlayer); return; case MEDIA_PLAYBACK_COMPLETE: if (mOnCompletionListener != null) mOnCompletionListener.onCompletion(mMediaPlayer); stayAwake(false); return; case MEDIA_BUFFERING_UPDATE: if (mOnBufferingUpdateListener != null) mOnBufferingUpdateListener.onBufferingUpdate(mMediaPlayer, msg.arg1); return; case MEDIA_SEEK_COMPLETE: if (mOnSeekCompleteListener != null) mOnSeekCompleteListener.onSeekComplete(mMediaPlayer); return; case MEDIA_SET_VIDEO_SIZE: if (mOnVideoSizeChangedListener != null) mOnVideoSizeChangedListener.onVideoSizeChanged(mMediaPlayer, msg.arg1, msg.arg2); return; case MEDIA_ERROR: // For PV specific error values (msg.arg2) look in // opencore/pvmi/pvmf/include/pvmf_return_codes.h Log.e(TAG, "Error (" + msg.arg1 + "," + msg.arg2 + ")"); boolean error_was_handled = false; if (mOnErrorListener != null) { error_was_handled = mOnErrorListener.onError(mMediaPlayer, msg.arg1, msg.arg2); } if (mOnCompletionListener != null && ! error_was_handled) { mOnCompletionListener.onCompletion(mMediaPlayer); } stayAwake(false); return; case MEDIA_INFO: if (msg.arg1 != MEDIA_INFO_VIDEO_TRACK_LAGGING) { Log.i(TAG, "Info (" + msg.arg1 + "," + msg.arg2 + ")"); } if (mOnInfoListener != null) { mOnInfoListener.onInfo(mMediaPlayer, msg.arg1, msg.arg2); } // No real default action so far. return; case MEDIA_TIMED_TEXT: if (mOnTimedTextListener != null) { if (msg.obj == null) { mOnTimedTextListener.onTimedText(mMediaPlayer, null); } else { if (msg.obj instanceof byte[]) { TimedText text = new TimedText((byte[])(msg.obj)); mOnTimedTextListener.onTimedText(mMediaPlayer, text); } } } return; case MEDIA_NOP: // interface test message - ignore break; default: Log.e(TAG, "Unknown message type " + msg.what); return; } } } /** * Called from native code when an interesting event happens. This method * just uses the EventHandler system to post the event back to the main app thread. * We use a weak reference to the original MediaPlayer object so that the native * code is safe from the object disappearing from underneath it. (This is * the cookie passed to native_setup().) */ private static void postEventFromNative(Object mediaplayer_ref, int what, int arg1, int arg2, Object obj) { MediaPlayer mp = (MediaPlayer)((WeakReference)mediaplayer_ref).get(); if (mp == null) { return; } if (mp.mEventHandler != null) { Message m = mp.mEventHandler.obtainMessage(what, arg1, arg2, obj); mp.mEventHandler.sendMessage(m); } } /** * Interface definition for a callback to be invoked when the media * source is ready for playback. */ public interface OnPreparedListener { /** * Called when the media file is ready for playback. * * @param mp the MediaPlayer that is ready for playback */ void onPrepared(MediaPlayer mp); } /** * Register a callback to be invoked when the media source is ready * for playback. * * @param listener the callback that will be run */ public void setOnPreparedListener(OnPreparedListener listener) { mOnPreparedListener = listener; } private OnPreparedListener mOnPreparedListener; /** * Interface definition for a callback to be invoked when playback of * a media source has completed. */ public interface OnCompletionListener { /** * Called when the end of a media source is reached during playback. * * @param mp the MediaPlayer that reached the end of the file */ void onCompletion(MediaPlayer mp); } /** * Register a callback to be invoked when the end of a media source * has been reached during playback. * * @param listener the callback that will be run */ public void setOnCompletionListener(OnCompletionListener listener) { mOnCompletionListener = listener; } private OnCompletionListener mOnCompletionListener; /** * Interface definition of a callback to be invoked indicating buffering * status of a media resource being streamed over the network. */ public interface OnBufferingUpdateListener { /** * Called to update status in buffering a media stream received through * progressive HTTP download. The received buffering percentage * indicates how much of the content has been buffered or played. * For example a buffering update of 80 percent when half the content * has already been played indicates that the next 30 percent of the * content to play has been buffered. * * @param mp the MediaPlayer the update pertains to * @param percent the percentage (0-100) of the content * that has been buffered or played thus far */ void onBufferingUpdate(MediaPlayer mp, int percent); } /** * Register a callback to be invoked when the status of a network * stream's buffer has changed. * * @param listener the callback that will be run. */ public void setOnBufferingUpdateListener(OnBufferingUpdateListener listener) { mOnBufferingUpdateListener = listener; } private OnBufferingUpdateListener mOnBufferingUpdateListener; /** * Interface definition of a callback to be invoked indicating * the completion of a seek operation. */ public interface OnSeekCompleteListener { /** * Called to indicate the completion of a seek operation. * * @param mp the MediaPlayer that issued the seek operation */ public void onSeekComplete(MediaPlayer mp); } /** * Register a callback to be invoked when a seek operation has been * completed. * * @param listener the callback that will be run */ public void setOnSeekCompleteListener(OnSeekCompleteListener listener) { mOnSeekCompleteListener = listener; } private OnSeekCompleteListener mOnSeekCompleteListener; /** * Interface definition of a callback to be invoked when the * video size is first known or updated */ public interface OnVideoSizeChangedListener { /** * Called to indicate the video size * * @param mp the MediaPlayer associated with this callback * @param width the width of the video * @param height the height of the video */ public void onVideoSizeChanged(MediaPlayer mp, int width, int height); } /** * Register a callback to be invoked when the video size is * known or updated. * * @param listener the callback that will be run */ public void setOnVideoSizeChangedListener(OnVideoSizeChangedListener listener) { mOnVideoSizeChangedListener = listener; } private OnVideoSizeChangedListener mOnVideoSizeChangedListener; /** * Interface definition of a callback to be invoked when a * timed text is available for display. * {@hide} */ public interface OnTimedTextListener { /** * Called to indicate an avaliable timed text * * @param mp the MediaPlayer associated with this callback * @param text the timed text sample which contains the text * needed to be displayed and the display format. * {@hide} */ public void onTimedText(MediaPlayer mp, TimedText text); } /** * Register a callback to be invoked when a timed text is available * for display. * * @param listener the callback that will be run * {@hide} */ public void setOnTimedTextListener(OnTimedTextListener listener) { mOnTimedTextListener = listener; } private OnTimedTextListener mOnTimedTextListener; /* Do not change these values without updating their counterparts * in include/media/mediaplayer.h! */ /** Unspecified media player error. * @see android.media.MediaPlayer.OnErrorListener */ public static final int MEDIA_ERROR_UNKNOWN = 1; /** Media server died. In this case, the application must release the * MediaPlayer object and instantiate a new one. * @see android.media.MediaPlayer.OnErrorListener */ public static final int MEDIA_ERROR_SERVER_DIED = 100; /** The video is streamed and its container is not valid for progressive * playback i.e the video's index (e.g moov atom) is not at the start of the * file. * @see android.media.MediaPlayer.OnErrorListener */ public static final int MEDIA_ERROR_NOT_VALID_FOR_PROGRESSIVE_PLAYBACK = 200; /** * Interface definition of a callback to be invoked when there * has been an error during an asynchronous operation (other errors * will throw exceptions at method call time). */ public interface OnErrorListener { /** * Called to indicate an error. * * @param mp the MediaPlayer the error pertains to * @param what the type of error that has occurred: *

      *
    • {@link #MEDIA_ERROR_UNKNOWN} *
    • {@link #MEDIA_ERROR_SERVER_DIED} *
    * @param extra an extra code, specific to the error. Typically * implementation dependant. * @return True if the method handled the error, false if it didn't. * Returning false, or not having an OnErrorListener at all, will * cause the OnCompletionListener to be called. */ boolean onError(MediaPlayer mp, int what, int extra); } /** * Register a callback to be invoked when an error has happened * during an asynchronous operation. * * @param listener the callback that will be run */ public void setOnErrorListener(OnErrorListener listener) { mOnErrorListener = listener; } private OnErrorListener mOnErrorListener; /* Do not change these values without updating their counterparts * in include/media/mediaplayer.h! */ /** Unspecified media player info. * @see android.media.MediaPlayer.OnInfoListener */ public static final int MEDIA_INFO_UNKNOWN = 1; /** The video is too complex for the decoder: it can't decode frames fast * enough. Possibly only the audio plays fine at this stage. * @see android.media.MediaPlayer.OnInfoListener */ public static final int MEDIA_INFO_VIDEO_TRACK_LAGGING = 700; /** MediaPlayer is temporarily pausing playback internally in order to * buffer more data. * @see android.media.MediaPlayer.OnInfoListener */ public static final int MEDIA_INFO_BUFFERING_START = 701; /** MediaPlayer is resuming playback after filling buffers. * @see android.media.MediaPlayer.OnInfoListener */ public static final int MEDIA_INFO_BUFFERING_END = 702; /** Bad interleaving means that a media has been improperly interleaved or * not interleaved at all, e.g has all the video samples first then all the * audio ones. Video is playing but a lot of disk seeks may be happening. * @see android.media.MediaPlayer.OnInfoListener */ public static final int MEDIA_INFO_BAD_INTERLEAVING = 800; /** The media cannot be seeked (e.g live stream) * @see android.media.MediaPlayer.OnInfoListener */ public static final int MEDIA_INFO_NOT_SEEKABLE = 801; /** A new set of metadata is available. * @see android.media.MediaPlayer.OnInfoListener */ public static final int MEDIA_INFO_METADATA_UPDATE = 802; /** * Interface definition of a callback to be invoked to communicate some * info and/or warning about the media or its playback. */ public interface OnInfoListener { /** * Called to indicate an info or a warning. * * @param mp the MediaPlayer the info pertains to. * @param what the type of info or warning. *
      *
    • {@link #MEDIA_INFO_UNKNOWN} *
    • {@link #MEDIA_INFO_VIDEO_TRACK_LAGGING} *
    • {@link #MEDIA_INFO_BUFFERING_START} *
    • {@link #MEDIA_INFO_BUFFERING_END} *
    • {@link #MEDIA_INFO_BAD_INTERLEAVING} *
    • {@link #MEDIA_INFO_NOT_SEEKABLE} *
    • {@link #MEDIA_INFO_METADATA_UPDATE} *
    * @param extra an extra code, specific to the info. Typically * implementation dependant. * @return True if the method handled the info, false if it didn't. * Returning false, or not having an OnErrorListener at all, will * cause the info to be discarded. */ boolean onInfo(MediaPlayer mp, int what, int extra); } /** * Register a callback to be invoked when an info/warning is available. * * @param listener the callback that will be run */ public void setOnInfoListener(OnInfoListener listener) { mOnInfoListener = listener; } private OnInfoListener mOnInfoListener; }




     




你可能感兴趣的:(移动互联网,code,demo,源码,Android)