* <td>Valid Sates
* <td>Invalid States
* <td>Comments
* <tr>
* <td>{Idle, Initialized, Prepared, Started, Paused, Stopped,
* PlaybackCompleted} </p>
* <td>{Error}
* <td>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 <em>Error state.
* <tr>
* <td>{Prepared, Started, Paused, Stopped, PlaybackCompleted}
* <td>{Idle, Initialized, Error}
* <td>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 <em>Error state.
* <tr>
* <td>{Idle, Initialized, Prepared, Started, Paused, Stopped,
* PlaybackCompleted}</p>
* <td>{Error}
* <td>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 <em>Error state.
* <tr>
* <td>{Idle, Initialized, Prepared, Started, Paused, Stopped,
* PlaybackCompleted}</p>
* <td>{Error}
* <td>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 <em>Error state.
* <tr>
* <td>{Idle, Initialized, Prepared, Started, Paused, Stopped,
* PlaybackCompleted}</p>
* <td>{Error}
* <td>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 <em>Error state.
* <tr>
* <td>{Started, Paused}
* <td>{Idle, Initialized, Prepared, Stopped, PlaybackCompleted, Error}
* <td>Successful invoke of this method in a valid state transfers the
* object to the <em>Paused state. Calling this method in an
* invalid state transfers the object to the <em>Error state.
* <tr>
* <td>{Initialized, Stopped}
* <td>{Idle, Prepared, Started, Paused, PlaybackCompleted, Error}
* <td>Successful invoke of this method in a valid state transfers the
* object to the <em>Prepared state. Calling this method in an
* invalid state throws an IllegalStateException.</p>
* <tr>
* <td>{Initialized, Stopped}
* <td>{Idle, Prepared, Started, Paused, PlaybackCompleted, Error}
* <td>Successful invoke of this method in a valid state transfers the
* object to the <em>Preparing state. Calling this method in an
* invalid state throws an IllegalStateException.</p>
* <tr>
* <td>any
* <td>{}
* <td>After {@link #release()}, the object is no longer available.
* <tr>
* <td>{Idle, Initialized, Prepared, Started, Paused, Stopped,
* PlaybackCompleted, Error}</p>
* <td>{}
* <td>After {@link #reset()}, the object is like being just created.
* <tr>
* <td>{Prepared, Started, Paused, PlaybackCompleted}
* <td>{Idle, Initialized, Stopped, Error}
* <td>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 <em>Error state.
* <tr>
* <td>{Idle, Initialized, Stopped, Prepared, Started, Paused,
* PlaybackCompleted}</p>
* <td>{Error}
* <td>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().</p>
* <tr>
* <td>{Idle}
* <td>{Initialized, Prepared, Started, Paused, Stopped, PlaybackCompleted,
* Error} </p>
* <td>Successful invoke of this method in a valid state transfers the
* object to the <em>Initialized state. Calling this method in an
* invalid state throws an IllegalStateException.</p>
* <tr>
* <td>any
* <td>{}
* <td>This method can be called in any state and calling it does not change
* the object state. </p>
* <tr>
* <td>{Idle, Initialized, Stopped, Prepared, Started, Paused,
* PlaybackCompleted}</p>
* <td>{Error}
* <td>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 <em>Error state.
* <tr>
* <td>any
* <td>{}
* <td>This method can be called in any state and calling it does not change
* the object state. </p>
* <tr>
* <td>any
* <td>{}
* <td>This method can be called in any state and calling it does not change
* the object state. </p>
* <tr>
* <td>any
* <td>{}
* <td>This method can be called in any state and calling it does not change
* the object state. </p>
* <tr>
* <td>any
* <td>{}
* <td>This method can be called in any state and calling it does not change
* the object state. </p>
* <tr>
* <td>any
* <td>{}
* <td>This method can be called in any state and calling it does not change
* the object state. </p>
* <tr>
* <td>any
* <td>{}
* <td>This method can be called in any state and calling it does not change
* the object state. </p>
* <tr>
* <td>any
* <td>{}
* <td>This method can be called in any state and calling it does not change
* the object state. </p>
* <tr>
* <td>{Idle, Initialized, Stopped, Prepared, Started, Paused,
* PlaybackCompleted}</p>
* <td>{Error}
* <td>Successful invoke of this method does not change the state.
* <tr>
* <td>any
* <td>{}
* <td>This method can be called in any state and calling it does not change
* the object state.</p>
* <tr>
* <td>{Prepared, Started, Paused, PlaybackCompleted}
* <td>{Idle, Initialized, Stopped, Error}
* <td>Successful invoke of this method in a valid state transfers the
* object to the <em>Started state. Calling this method in an
* invalid state transfers the object to the <em>Error state.
* <tr>
* <td>{Prepared, Started, Stopped, Paused, PlaybackCompleted}
* <td>{Idle, Initialized, Error}
* <td>Successful invoke of this method in a valid state transfers the
* object to the <em>Stopped state. Calling this method in an
* invalid state transfers the object to the <em>Error state.
* </table>
*
* <a name="Permissions">
* <h3>Permissions
* <p>One may need to declare a corresponding WAKE_LOCK permission {@link
* android.R.styleable#AndroidManifestUsesPermission <uses-permission>}
* element.
*
*/
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 mListenerContext; // accessed by native methods
private Surface mSurface; // 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.
* <p>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.</p>
*/
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<MediaPlayer>(this));
}
/*
* Update the MediaPlayer ISurface. Call after updating mSurface.
*/
private native void _setVideoSurface();
/**
* 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 SurfaceHolder to use for displaying the video portion of the media.
* This call is optional. Not calling it when playing back a video 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;
if (sh != null) {
mSurface = sh.getSurface();
} else {
mSurface = null;
}
_setVideoSurface();
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.
* <p>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.</p>
*
* @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.
* <p>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.</p>
*
* @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;
}
/**
* 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.
* <p>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.</p>
*
* @param context the Context to use
* @param resid the raw resource id (<var>R.raw.<something>) 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
* @hide pending API council
*/
public void setDataSource(Context context, Uri uri, Map<String, String> 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, 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 native void setDataSource(String path, Map<String, String> headers)
throws IOException, IllegalArgumentException, 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.
*
* <p>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) {
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<Integer> 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.
*/
public void release() {
stayAwake(false);
updateSurfaceScreenOn();
mOnPreparedListener = null;
mOnBufferingUpdateListener = null;
mOnCompletionListener = null;
mOnSeekCompleteListener = null;
mOnErrorListener = null;
mOnInfoListener = null;
mOnVideoSizeChangedListener = 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();
/**
* Suspends the MediaPlayer. The only methods that may be called while
* suspended are {@link #reset()}, {@link #release()} and {@link #resume()}.
* MediaPlayer will release its hardware resources as far as
* possible and reasonable. A successfully suspended MediaPlayer will
* cease sending events.
* If suspension is successful, this method returns true, otherwise
* false is returned and the player's state is not affected.
* @hide
*/
public boolean suspend() {
if (native_suspend_resume(true) < 0) {
return false;
}
stayAwake(false);
// make sure none of the listeners get called anymore
mEventHandler.removeCallbacksAndMessages(null);
return true;
}
/**
* Resumes the MediaPlayer. Only to be called after a previous (successful)
* call to {@link #suspend()}.
* MediaPlayer will return to a state close to what it was in before
* suspension.
* @hide
*/
public boolean resume() {
if (native_suspend_resume(false) < 0) {
return false;
}
if (isPlaying()) {
stayAwake(true);
}
return true;
}
/**
* @hide
*/
private native int native_suspend_resume(boolean isSuspend);
/**
* 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;
/**
* @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();
@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_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:
// For PV specific code values (msg.arg2) look in
// opencore/pvmi/pvmf/include/pvmf_return_codes.h
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_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.
*
* @param mp the MediaPlayer the update pertains to
* @param percent the percentage (0-100) of the buffer
* that has been filled 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;
/* 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:
* <ul>
* <li>{@link #MEDIA_ERROR_UNKNOWN}
* <li>{@link #MEDIA_ERROR_SERVER_DIED}
* </ul>
* @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;
/** 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.
* <ul>
* <li>{@link #MEDIA_INFO_UNKNOWN}
* <li>{@link #MEDIA_INFO_VIDEO_TRACK_LAGGING}
* <li>{@link #MEDIA_INFO_BAD_INTERLEAVING}
* <li>{@link #MEDIA_INFO_NOT_SEEKABLE}
* <li>{@link #MEDIA_INFO_METADATA_UPDATE}
* </ul>
* @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;
/**
* @hide
*/
public native static int snoop(short [] outData, int kind);
}
Other Android examples (source code examples)
Here is a short list of links related to this Android MediaPlayer.java source code file:
|
|
Android example source code file (MediaPlayer.java)
This example Android source code file (MediaPlayer.java) is included in the DevDaily.com
"Java Source Code
Warehouse" project. The intent of this project is to help you "Learn
Android by Example" TM.
The MediaPlayer.java Android example source code
/*
* 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.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}.
* Please see <a href="{@docRoot}guide/topics/media/index.html">Audio and Video
* for additional help using MediaPlayer.
*
* <p>Topics covered here are:
* <ol>
* <li>State Diagram
* <li>Valid and Invalid States
* <li>Permissions
* </ol>
*
* <a name="StateDiagram">
* <h3>State Diagram
*
* <p>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.</p>
*
* <p>
*
* <p>From this state diagram, one can see that a MediaPlayer object has the
* following states:</p>
* <ul>
* <li>When a MediaPlayer object is just created using new or
* after {@link #reset()} is called, it is in the <em>Idle state; and after
* {@link #release()} is called, it is in the <em>End state. Between these
* two states is the life cycle of the MediaPlayer object.
* <ul>
* <li>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 <em>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 <em>Error state.
* <li>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 <em>End state, it can no longer be used and
* there is no way to bring it back to any other state. </li>
* <li>Furthermore,
* the MediaPlayer objects created using <code>new is in the
* <em>Idle state, while those created with one
* of the overloaded convenient <code>create methods are NOT
* in the <em>Idle state. In fact, the objects are in the Prepared
* state if the creation using <code>create method is successful.
* </li>
* </ul>
* </li>
* <li>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)}.
* <ul>
* <li>It is important to note that once an error occurs, the
* MediaPlayer object enters the <em>Error state (except as noted
* above), even if an error listener has not been registered by the application.</li>
* <li>In order to reuse a MediaPlayer object that is in the
* Error</em> state and recover from the error,
* {@link #reset()} can be called to restore the object to its <em>Idle
* state.</li>
* <li>It is good programming practice to have your application
* register a OnErrorListener to look out for error notifications from
* the internal player engine.</li>
* <li>IllegalStateException is
* thrown to prevent programming errors such as calling {@link #prepare()},
* {@link #prepareAsync()}, or one of the overloaded <code>setDataSource
* </code> methods in an invalid state.
* </ul>
* </li>
* <li>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 <em>Idle state to the
* <em>Initialized state.
* <ul>
* <li>An IllegalStateException is thrown if
* setDataSource() is called in any other state.</li>
* <li>It is good programming
* practice to always look out for <code>IllegalArgumentException
* and <code>IOException that may be thrown from the overloaded
* <code>setDataSource methods.
* </ul>
* </li>
* <li>A MediaPlayer object must first enter the Prepared state
* before playback can be started.
* <ul>
* <li>There are two ways (synchronous vs.
* asynchronous) that the <em>Prepared state can be reached:
* either a call to {@link #prepare()} (synchronous) which
* transfers the object to the <em>Prepared state once the method call
* returns, or a call to {@link #prepareAsync()} (asynchronous) which
* first transfers the object to the <em>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)}.</li>
* <li>It is important to note that
* the <em>Preparing state is a transient state, and the behavior
* of calling any method with side effect while a MediaPlayer object is
* in the <em>Preparing state is undefined.
* <li>An IllegalStateException is
* thrown if {@link #prepare()} or {@link #prepareAsync()} is called in
* any other state.</li>
* <li>While in the Prepared state, properties
* such as audio/sound volume, screenOnWhilePlaying, looping can be
* adjusted by invoking the corresponding set methods.</li>
* </ul>
* </li>
* <li>To start the playback, {@link #start()} must be called. After
* {@link #start()} returns successfully, the MediaPlayer object is in the
* <em>Started state. {@link #isPlaying()} can be called to test
* whether the MediaPlayer object is in the <em>Started state.
* <ul>
* <li>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.</li>
* <li>Calling {@link #start()} has not effect
* on a MediaPlayer object that is already in the <em>Started state.
* </ul>
* </li>
* <li>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
* <em>Paused state. Note that the transition from the Started
* state to the <em>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.
* <ul>
* <li>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 <em>Started state.
* <li>Calling {@link #pause()} has no effect on
* a MediaPlayer object that is already in the <em>Paused state.
* </ul>
* </li>
* <li>Calling {@link #stop()} stops playback and causes a
* MediaPlayer in the <em>Started, Paused, Prepared
* </em> or PlaybackCompleted state to enter the
* <em>Stopped state.
* <ul>
* <li>Once in the Stopped state, playback cannot be started
* until {@link #prepare()} or {@link #prepareAsync()} are called to set
* the MediaPlayer object to the <em>Prepared state again.
* <li>Calling {@link #stop()} has no effect on a MediaPlayer
* object that is already in the <em>Stopped state.
* </ul>
* </li>
* <li>The playback position can be adjusted with a call to
* {@link #seekTo(int)}.
* <ul>
* <li>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)}.</li>
* <li>Please
* note that {@link #seekTo(int)} can also be called in the other states,
* such as <em>Prepared, Paused and PlaybackCompleted
* </em> state.
* <li>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.</li>
* </ul>
* </li>
* <li>When the playback reaches the end of stream, the playback completes.
* <ul>
* <li>If the looping mode was being set to truewith
* {@link #setLooping(boolean)}, the MediaPlayer object shall remain in
* the <em>Started state.
* <li>If the looping mode was set to false
* </var>, 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 <em>
* PlaybackCompleted</em> state.
* <li>While in the PlaybackCompleted
* state, calling {@link #start()} can restart the playback from the
* beginning of the audio/video source.</li>
* </ul>
*
*
* <a name="Valid_and_Invalid_States">
* <h3>Valid and invalid states
*
* <table border="0" cellspacing="0" cellpadding="0">
* <tr> | Method Name |
| getCurrentPosition |
| getDuration |
| getVideoHeight |
| getVideoWidth |
| isPlaying |
| pause |
| prepare |
| prepareAsync |
| release |
| reset |
| seekTo |
| setAudioStreamType |
| setDataSource |
| setDisplay |
| setLooping |
| isLooping |
| setOnBufferingUpdateListener |
| setOnCompletionListener |
| setOnErrorListener |
| setOnPreparedListener |
| setOnSeekCompleteListener |
| setScreenOnWhilePlaying |
| setVolume | setWakeMode |
| start |
| stop |
The search page
Other Android source code examples at this package level
Click here to learn more about this project
