8b0b174198
passing a null surface. The API is now enabled to change the surface while the video is playing. This could allow orientation changes during playback or to allow the audio track from a video to play in the background. NOTE: There are still changes required to pmem driver to allow remapping shared physical memory into a process in order for this to work. This change only enables the API to send the appropriate calls when the lower level code supports it.
1294 lines
52 KiB
Java
1294 lines
52 KiB
Java
/*
|
|
* 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.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.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</a>
|
|
* for additional help using MediaPlayer.
|
|
*
|
|
* <p>Topics covered here are:
|
|
* <ol>
|
|
* <li><a href="#StateDiagram">State Diagram</a>
|
|
* <li><a href="#Valid_and_Invalid_States">Valid and Invalid States</a>
|
|
* <li><a href="#Permissions">Permissions</a>
|
|
* </ol>
|
|
*
|
|
* <a name="StateDiagram"></a>
|
|
* <h3>State Diagram</h3>
|
|
*
|
|
* <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><img src="../../../images/mediaplayer_state_diagram.gif"
|
|
* alt="MediaPlayer State diagram"
|
|
* border="0" /></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 <code>new</code> or
|
|
* after {@link #reset()} is called, it is in the <em>Idle</em> state; and after
|
|
* {@link #release()} is called, it is in the <em>End</em> 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</em> 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</em> state. </li>
|
|
* <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</em> 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</code> is in the
|
|
* <em>Idle</em> state, while those created with one
|
|
* of the overloaded convenient <code>create</code> methods are <em>NOT</em>
|
|
* in the <em>Idle</em> state. In fact, the objects are in the <em>Prepared</em>
|
|
* state if the creation using <code>create</code> 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</em> 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 <em>
|
|
* Error</em> state and recover from the error,
|
|
* {@link #reset()} can be called to restore the object to its <em>Idle</em>
|
|
* 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>IlleglStateException 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. </li>
|
|
* </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</em> state to the
|
|
* <em>Initialized</em> 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</code>
|
|
* and <code>IOException</code> that may be thrown from the overloaded
|
|
* <code>setDataSource</code> methods.</li>
|
|
* </ul>
|
|
* </li>
|
|
* <li>A MediaPlayer object must first enter the <em>Prepared</em> state
|
|
* before playback can be started.
|
|
* <ul>
|
|
* <li>There are two ways (synchronous vs.
|
|
* asynchronous) that the <em>Prepared</em> state can be reached:
|
|
* either a call to {@link #prepare()} (synchronous) which
|
|
* transfers the object to the <em>Prepared</em> state once the method call
|
|
* returns, or a call to {@link #prepareAsync()} (asynchronous) which
|
|
* first transfers the object to the <em>Preparing</em> 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</em> state is a transient state, and the behavior
|
|
* of calling any method with side effect while a MediaPlayer object is
|
|
* in the <em>Preparing</em> state is undefined.</li>
|
|
* <li>An IllegalStateException is
|
|
* thrown if {@link #prepare()} or {@link #prepareAsync()} is called in
|
|
* any other state.</li>
|
|
* <li>While in the <em>Prepared</em> 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</em> state. {@link #isPlaying()} can be called to test
|
|
* whether the MediaPlayer object is in the <em>Started</em> state.
|
|
* <ul>
|
|
* <li>While in the <em>Started</em> 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</em> state.</li>
|
|
* </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</em> state. Note that the transition from the <em>Started</em>
|
|
* state to the <em>Paused</em> 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</em> state.</li>
|
|
* <li>Calling {@link #pause()} has no effect on
|
|
* a MediaPlayer object that is already in the <em>Paused</em> state.</li>
|
|
* </ul>
|
|
* </li>
|
|
* <li>Calling {@link #stop()} stops playback and causes a
|
|
* MediaPlayer in the <em>Started</em>, <em>Paused</em>, <em>Prepared
|
|
* </em> or <em>PlaybackCompleted</em> state to enter the
|
|
* <em>Stopped</em> state.
|
|
* <ul>
|
|
* <li>Once in the <em>Stopped</em> state, playback cannot be started
|
|
* until {@link #prepare()} or {@link #prepareAsync()} are called to set
|
|
* the MediaPlayer object to the <em>Prepared</em> state again.</li>
|
|
* <li>Calling {@link #stop()} has no effect on a MediaPlayer
|
|
* object that is already in the <em>Stopped</em> state.</li>
|
|
* </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</em>, <em>Paused</em> and <em>PlaybackCompleted
|
|
* </em> state.</li>
|
|
* <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 <var>true</var>with
|
|
* {@link #setLooping(boolean)}, the MediaPlayer object shall remain in
|
|
* the <em>Started</em> state.</li>
|
|
* <li>If the looping mode was set to <var>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>
|
|
* <li>While in the <em>PlaybackCompleted</em>
|
|
* state, calling {@link #start()} can restart the playback from the
|
|
* beginning of the audio/video source.</li>
|
|
* </ul>
|
|
*
|
|
*
|
|
* <a name="Valid_and_Invalid_States"></a>
|
|
* <h3>Valid and invalid states</h3>
|
|
*
|
|
* <table border="0" cellspacing="0" cellpadding="0">
|
|
* <tr><td>Method Name </p></td>
|
|
* <td>Valid Sates </p></td>
|
|
* <td>Invalid States </p></td>
|
|
* <td>Comments </p></td></tr>
|
|
* <tr><td>getCurrentPosition </p></td>
|
|
* <td>{Idle, Initialized, Prepared, Started, Paused, Stopped,
|
|
* PlaybackCompleted} </p></td>
|
|
* <td>{Error}</p></td>
|
|
* <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</em> state. </p></td></tr>
|
|
* <tr><td>getDuration </p></td>
|
|
* <td>{Prepared, Started, Paused, Stopped, PlaybackCompleted} </p></td>
|
|
* <td>{Idle, Initialized, Error} </p></td>
|
|
* <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</em> state. </p></td></tr>
|
|
* <tr><td>getVideoHeight </p></td>
|
|
* <td>{Idle, Initialized, Prepared, Started, Paused, Stopped,
|
|
* PlaybackCompleted}</p></td>
|
|
* <td>{Error}</p></td>
|
|
* <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</em> state. </p></td></tr>
|
|
* <tr><td>getVideoWidth </p></td>
|
|
* <td>{Idle, Initialized, Prepared, Started, Paused, Stopped,
|
|
* PlaybackCompleted}</p></td>
|
|
* <td>{Error}</p></td>
|
|
* <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</em> state. </p></td></tr>
|
|
* <tr><td>isPlaying </p></td>
|
|
* <td>{Idle, Initialized, Prepared, Started, Paused, Stopped,
|
|
* PlaybackCompleted}</p></td>
|
|
* <td>{Error}</p></td>
|
|
* <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</em> state. </p></td></tr>
|
|
* <tr><td>pause </p></td>
|
|
* <td>{Started, Paused}</p></td>
|
|
* <td>{Idle, Initialized, Prepared, Stopped, PlaybackCompleted, Error}</p></td>
|
|
* <td>Successful invoke of this method in a valid state transfers the
|
|
* object to the <em>Paused</em> state. Calling this method in an
|
|
* invalid state transfers the object to the <em>Error</em> state.</p></td></tr>
|
|
* <tr><td>prepare </p></td>
|
|
* <td>{Initialized, Stopped} </p></td>
|
|
* <td>{Idle, Prepared, Started, Paused, PlaybackCompleted, Error} </p></td>
|
|
* <td>Successful invoke of this method in a valid state transfers the
|
|
* object to the <em>Prepared</em> state. Calling this method in an
|
|
* invalid state throws an IllegalStateException.</p></td></tr>
|
|
* <tr><td>prepareAsync </p></td>
|
|
* <td>{Initialized, Stopped} </p></td>
|
|
* <td>{Idle, Prepared, Started, Paused, PlaybackCompleted, Error} </p></td>
|
|
* <td>Successful invoke of this method in a valid state transfers the
|
|
* object to the <em>Preparing</em> state. Calling this method in an
|
|
* invalid state throws an IllegalStateException.</p></td></tr>
|
|
* <tr><td>release </p></td>
|
|
* <td>any </p></td>
|
|
* <td>{} </p></td>
|
|
* <td>After {@link #release()}, the object is no longer available. </p></td></tr>
|
|
* <tr><td>reset </p></td>
|
|
* <td>{Idle, Initialized, Prepared, Started, Paused, Stopped,
|
|
* PlaybackCompleted, Error}</p></td>
|
|
* <td>{}</p></td>
|
|
* <td>After {@link #reset()}, the object is like being just created.</p></td></tr>
|
|
* <tr><td>seekTo </p></td>
|
|
* <td>{Prepared, Started, Paused, PlaybackCompleted} </p></td>
|
|
* <td>{Idle, Initialized, Stopped, Error}</p></td>
|
|
* <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</em> state. </p></td></tr>
|
|
* <tr><td>setAudioStreamType </p></td>
|
|
* <td>{Idle, Initialized, Stopped, Prepared, Started, Paused,
|
|
* PlaybackCompleted}</p></td>
|
|
* <td>{Error}</p></td>
|
|
* <td>Successful invoke of this method does not change the state.</p></td></tr>
|
|
* <tr><td>setDataSource </p></td>
|
|
* <td>{Idle} </p></td>
|
|
* <td>{Initialized, Prepared, Started, Paused, Stopped, PlaybackCompleted,
|
|
* Error} </p></td>
|
|
* <td>Successful invoke of this method in a valid state transfers the
|
|
* object to the <em>Initialized</em> state. Calling this method in an
|
|
* invalid state throws an IllegalStateException.</p></td></tr>
|
|
* <tr><td>setDisplay </p></td>
|
|
* <td>any </p></td>
|
|
* <td>{} </p></td>
|
|
* <td>This method can be called in any state and calling it does not change
|
|
* the object state. </p></td></tr>
|
|
* <tr><td>setLooping </p></td>
|
|
* <td>{Idle, Initialized, Stopped, Prepared, Started, Paused,
|
|
* PlaybackCompleted}</p></td>
|
|
* <td>{Error}</p></td>
|
|
* <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</em> state.</p></td></tr>
|
|
* <tr><td>isLooping </p></td>
|
|
* <td>any </p></td>
|
|
* <td>{} </p></td>
|
|
* <td>This method can be called in any state and calling it does not change
|
|
* the object state. </p></td></tr>
|
|
* <tr><td>setOnBufferingUpdateListener </p></td>
|
|
* <td>any </p></td>
|
|
* <td>{} </p></td>
|
|
* <td>This method can be called in any state and calling it does not change
|
|
* the object state. </p></td></tr>
|
|
* <tr><td>setOnCompletionListener </p></td>
|
|
* <td>any </p></td>
|
|
* <td>{} </p></td>
|
|
* <td>This method can be called in any state and calling it does not change
|
|
* the object state. </p></td></tr>
|
|
* <tr><td>setOnErrorListener </p></td>
|
|
* <td>any </p></td>
|
|
* <td>{} </p></td>
|
|
* <td>This method can be called in any state and calling it does not change
|
|
* the object state. </p></td></tr>
|
|
* <tr><td>setOnPreparedListener </p></td>
|
|
* <td>any </p></td>
|
|
* <td>{} </p></td>
|
|
* <td>This method can be called in any state and calling it does not change
|
|
* the object state. </p></td></tr>
|
|
* <tr><td>setOnSeekCompleteListener </p></td>
|
|
* <td>any </p></td>
|
|
* <td>{} </p></td>
|
|
* <td>This method can be called in any state and calling it does not change
|
|
* the object state. </p></td></tr>
|
|
* <tr><td>setScreenOnWhilePlaying</></td>
|
|
* <td>any </p></td>
|
|
* <td>{} </p></td>
|
|
* <td>This method can be called in any state and calling it does not change
|
|
* the object state. </p></td></tr>
|
|
* <tr><td>setVolume </p></td>
|
|
* <td>{Idle, Initialized, Stopped, Prepared, Started, Paused,
|
|
* PlaybackCompleted}</p></td>
|
|
* <td>{Error}</p></td>
|
|
* <td>Successful invoke of this method does not change the state.
|
|
* <tr><td>setWakeMode </p></td>
|
|
* <td>any </p></td>
|
|
* <td>{} </p></td>
|
|
* <td>This method can be called in any state and calling it does not change
|
|
* the object state.</p></td></tr>
|
|
* <tr><td>start </p></td>
|
|
* <td>{Prepared, Started, Paused, PlaybackCompleted}</p></td>
|
|
* <td>{Idle, Initialized, Stopped, Error}</p></td>
|
|
* <td>Successful invoke of this method in a valid state transfers the
|
|
* object to the <em>Started</em> state. Calling this method in an
|
|
* invalid state transfers the object to the <em>Error</em> state.</p></td></tr>
|
|
* <tr><td>stop </p></td>
|
|
* <td>{Prepared, Started, Stopped, Paused, PlaybackCompleted}</p></td>
|
|
* <td>{Idle, Initialized, Error}</p></td>
|
|
* <td>Successful invoke of this method in a valid state transfers the
|
|
* object to the <em>Stopped</em> state. Calling this method in an
|
|
* invalid state transfers the object to the <em>Error</em> state.</p></td></tr>
|
|
* </table>
|
|
*
|
|
* <a name="Permissions"></a>
|
|
* <h3>Permissions</h3>
|
|
* <p>One may need to declare a corresponding WAKE_LOCK permission {@link
|
|
* android.R.styleable#AndroidManifestUsesPermission <uses-permission>}
|
|
* element.
|
|
*
|
|
*/
|
|
public class MediaPlayer
|
|
{
|
|
static {
|
|
System.loadLibrary("media_jni");
|
|
}
|
|
|
|
private final static String TAG = "MediaPlayer";
|
|
|
|
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();
|
|
|
|
/**
|
|
* 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></var>) 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 {
|
|
|
|
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();
|
|
}
|
|
}
|
|
setDataSource(uri.toString());
|
|
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 (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. 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 prepare()/prepareAsync()
|
|
* have not completed yet
|
|
*/
|
|
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 prepare()/prepareAsync()
|
|
* have not completed yet
|
|
*/
|
|
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();
|
|
|
|
/**
|
|
* 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();
|
|
|
|
/**
|
|
* Sets the audio stream type for this MediaPlayer. See {@link AudioManager}
|
|
* for a list of stream types.
|
|
*
|
|
* @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;
|
|
|
|
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;
|
|
|
|
/**
|
|
* 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}
|
|
* </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;
|
|
}
|