/**@class android.media.MediaPlayer2
 implements java.lang.AutoCloseable

 implements android.media.AudioRouting

@extends java.lang.Object

 MediaPlayer2 class can be used to control playback of audio/video files and streams.

 <p>
 This API is not generally intended for third party application developers.
 Use the <a href="{@docRoot}jetpack/androidx.html">AndroidX</a>
 <a href="{@docRoot}reference/androidx/media2/package-summary.html">Media2 Library</a>
 for consistent behavior across all devices.

 <p>Topics covered here are:
 <ol>
 <li><a href="#PlayerStates">Player states</a>
 <li><a href="#InvalidStates">Invalid method calls</a>
 <li><a href="#Permissions">Permissions</a>
 <li><a href="#Callbacks">Callbacks</a>
 </ol>


 <h3 id="PlayerStates">Player states</h3>

 <p>The playback control of audio/video files is managed as a state machine.</p>
 <p><div style="text-align:center;"><img src="../../../images/mediaplayer2_state_diagram.png"
         alt="MediaPlayer2 State diagram"
         border="0" /></div></p>
 <p>The MediaPlayer2 object has five states:</p>
 <ol>
     <li><p>{@link #PLAYER_STATE_IDLE}: MediaPlayer2 is in the <strong>Idle</strong>
         state after it's created, or after calling {@link #reset}().</p>

         <p>While in this state, you should call
         {@link #setDataSource setDataSource}. It is a good
         programming practice to register an {@link android.media.MediaPlayer2.EventCallback#onCallCompleted onCallCompleted}
         <a href="#Callbacks">callback</a> and watch for {@link #CALL_STATUS_BAD_VALUE} and
         {@link #CALL_STATUS_ERROR_IO}, which might be caused by <code>setDataSource</code>.
         </p>

         <p>Calling {@link #prepare}() transfers a MediaPlayer2 object to
         the <strong>Prepared</strong> state. Note
         that {@link #prepare}() is asynchronous. When the preparation completes,
         if you register an {@link android.media.MediaPlayer2.EventCallback#onInfo onInfo} <a href="#Callbacks">callback</a>,
         the player executes the callback
         with {@link #MEDIA_INFO_PREPARED} and transitions to the
         <strong>Prepared</strong> state.</p>
         </li>

     <li>{@link #PLAYER_STATE_PREPARED}: A MediaPlayer object must be in the
         <strong>Prepared</strong> state before playback can be started for the first time.
         While in this state, you can set player properties
         such as audio/sound volume and looping by invoking the corresponding set methods.
         Calling {@link #play}() transfers a MediaPlayer2 object to
         the <strong>Playing</strong> state.
      </li>

     <li>{@link #PLAYER_STATE_PLAYING}:
         <p>The player plays the data source while in this state.
         If you register an {@link android.media.MediaPlayer2.EventCallback#onInfo onInfo} <a href="#Callbacks">callback</a>,
         the player regularly executes the callback with
         {@link #MEDIA_INFO_BUFFERING_UPDATE}.
         This allows applications to keep track of the buffering status
         while streaming audio/video.</p>

         <p> When the playback reaches the end of stream, the behavior depends on whether or
         not you've enabled looping by calling {@link #loopCurrent}:</p>
         <ul>
         <li>If the looping mode was set to <code>false</code>, the player will transfer
         to the <strong>Paused</strong> state. If you registered an {@link android.media.MediaPlayer2.EventCallback#onInfo
         onInfo} <a href="#Callbacks">callback</a>
         the player calls the callback with {@link #MEDIA_INFO_DATA_SOURCE_END} and enters
         the <strong>Paused</strong> state.
         </li>
         <li>If the looping mode was set to <code>true</code>,
         the MediaPlayer2 object remains in the <strong>Playing</strong> state and replays its
         data source from the beginning.</li>
         </ul>
         </li>

     <li>{@link #PLAYER_STATE_PAUSED}: Audio/video playback pauses while in this state.
         Call {@link #play}() to resume playback from the position where it paused.</li>

     <li>{@link #PLAYER_STATE_ERROR}: <p>In general, playback might fail due to various
          reasons such as unsupported audio/video format, poorly interleaved
          audio/video, resolution too high, streaming timeout, and others.
          In addition, due to programming errors, a playback
          control operation might be performed from an <a href="#InvalidStates">invalid state</a>.
          In these cases the player transitions to the <strong>Error</strong> state.</p>

          <p>If you register an {@link android.media.MediaPlayer2.EventCallback#onError onError}}
          <a href="#Callbacks">callback</a>,
          the callback will be performed when entering the state. When programming errors happen,
          such as calling {@link #prepare}() and
          {@link #setDataSource} methods
          from an <a href="#InvalidStates">invalid state</a>, the callback is called with
          {@link #CALL_STATUS_INVALID_OPERATION}. The MediaPlayer2 object enters the
          <strong>Error</strong> state whether or not a callback exists. </p>

          <p>To recover from an error and reuse a MediaPlayer2 object that is in the <strong>
          Error</strong> state,
          call {@link #reset}(). The object will return to the <strong>Idle</strong>
          state and all state information will be lost.</p>
          </li>
 </ol>

 <p>You should follow these best practices when coding an app that uses MediaPlayer2:</p>

 <ul>

 <li>Use <a href="#Callbacks">callbacks</a> to respond to state changes and errors.</li>

 <li>When  a MediaPlayer2 object is no longer being used, call {@link #close}() as soon as
 possible to release the resources used by the internal player engine associated with the
 MediaPlayer2. Failure to call {@link #close}() may cause subsequent instances of
 MediaPlayer2 objects to fallback to software implementations or fail altogether.
 You cannot use MediaPlayer2
 after you call {@link #close}(). There is no way to bring it back to any other state.</li>

 <li>The 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>

 <li>The playback position can be adjusted with a call to {@link #seekTo}. Although the
 asynchronous {@link #seekTo} call returns right away, the actual seek operation may take a
 while to finish, especially for audio/video being streamed. If you register an
 {@link android.media.MediaPlayer2.EventCallback#onCallCompleted onCallCompleted} <a href="#Callbacks">callback</a>,
 the callback is
 called When the seek operation completes with {@link #CALL_COMPLETED_SEEK_TO}.</li>

 <li>You can call {@link #seekTo} from the <strong>Paused</strong> state.
 In this case, if you are playing a video stream and
 the requested position is valid  one video frame is displayed.</li>

 </ul>

 <h3 id="InvalidStates">Invalid method calls</h3>

 <p>The only methods you safely call from the <strong>Error</strong> state are
 {@link #close},
 {@link #reset},
 {@link #notifyWhenCommandLabelReached},
 {@link #clearPendingCommands},
 {@link #registerEventCallback},
 {@link #unregisterEventCallback}
 and {@link #getState}.
 Any other methods might throw an exception, return meaningless data, or invoke a
 {@link android.media.MediaPlayer2.EventCallback#onCallCompleted onCallCompleted} with an error code.</p>

 <p>Most methods can be called from any non-Error state. They will either perform their work or
 silently have no effect. The following table lists the methods that will invoke a
 {@link android.media.MediaPlayer2.EventCallback#onCallCompleted onCallCompleted} with an error code
 or throw an exception when they are called from the associated invalid states.</p>

 <table border="0" cellspacing="0" cellpadding="0">
 <tr><th>Method Name</th>
 <th>Invalid States</th></tr>

 <tr><td>setDataSource</td> <td>{Prepared, Paused, Playing}</td></tr>
 <tr><td>prepare</td> <td>{Prepared, Paused, Playing}</td></tr>
 <tr><td>play</td> <td>{Idle}</td></tr>
 <tr><td>pause</td> <td>{Idle}</td></tr>
 <tr><td>seekTo</td> <td>{Idle}</td></tr>
 <tr><td>getCurrentPosition</td> <td>{Idle}</td></tr>
 <tr><td>getDuration</td> <td>{Idle}</td></tr>
 <tr><td>getBufferedPosition</td> <td>{Idle}</td></tr>
 <tr><td>getTrackInfo</td> <td>{Idle}</td></tr>
 <tr><td>getSelectedTrack</td> <td>{Idle}</td></tr>
 <tr><td>selectTrack</td> <td>{Idle}</td></tr>
 <tr><td>deselectTrack</td> <td>{Idle}</td></tr>
 </table>

 <h3 id="Permissions">Permissions</h3>
 <p>This class requires the {@link android.Manifest.permission#INTERNET} permission
 when used with network-based content.

 <h3 id="Callbacks">Callbacks</h3>
 <p>Many errors do not result in a transition to the  <strong>Error</strong> state.
 It is good programming practice to register callback listeners using
 {@link #registerEventCallback}.
 You can receive a callback at any time and from any state.</p>

 <p>If it's important for your app to respond to state changes (for instance, to update the
 controls on a transport UI), you should register an
 {@link android.media.MediaPlayer2.EventCallback#onCallCompleted onCallCompleted} and
 detect state change commands by testing the <code>what</code> parameter for a callback from one
 of the state transition methods: {@link #CALL_COMPLETED_PREPARE}, {@link #CALL_COMPLETED_PLAY},
 and {@link #CALL_COMPLETED_PAUSE}.
 Then check the <code>status</code> parameter. The value {@link #CALL_STATUS_NO_ERROR} indicates a
 successful transition. Any other value will be an error. Call {@link #getState}() to
 determine the current state. </p>

 @hide
*/
var MediaPlayer2 = {

/** MediaPlayer2 has not been prepared or just has been reset.
 In this state, MediaPlayer2 doesn't fetch data.
*/
PLAYER_STATE_IDLE : "1001",
/** MediaPlayer2 has been just prepared.
 In this state, MediaPlayer2 just fetches data from media source,
 but doesn't actively render data.
*/
PLAYER_STATE_PREPARED : "1002",
/** MediaPlayer2 is paused.
 In this state, MediaPlayer2 has allocated resources to construct playback
 pipeline, but it doesn't actively render data.
*/
PLAYER_STATE_PAUSED : "1003",
/** MediaPlayer2 is actively playing back data.
*/
PLAYER_STATE_PLAYING : "1004",
/** MediaPlayer2 has hit some fatal error and cannot continue playback.
*/
PLAYER_STATE_ERROR : "1005",
/** This mode is used with {@link #seekTo(long, int)} to move media position to
 a sync (or key) frame associated with a data source that is located
 right before or at the given time.

 @see #seekTo(long, int)
*/
SEEK_PREVIOUS_SYNC : "0",
/** This mode is used with {@link #seekTo(long, int)} to move media position to
 a sync (or key) frame associated with a data source that is located
 right after or at the given time.

 @see #seekTo(long, int)
*/
SEEK_NEXT_SYNC : "1",
/** This mode is used with {@link #seekTo(long, int)} to move media position to
 a sync (or key) frame associated with a data source that is located
 closest to (in time) or at the given time.

 @see #seekTo(long, int)
*/
SEEK_CLOSEST_SYNC : "2",
/** This mode is used with {@link #seekTo(long, int)} to move media position to
 a frame (not necessarily a key frame) associated with a data source that
 is located closest to or at the given time.

 @see #seekTo(long, int)
*/
SEEK_CLOSEST : "3",
/**Unspecified media player error.
 @see EventCallback#onError
*/
MEDIA_ERROR_UNKNOWN : "1",
/** 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 EventCallback#onError
*/
MEDIA_ERROR_NOT_VALID_FOR_PROGRESSIVE_PLAYBACK : "200",
/**File or network related operation errors. */
MEDIA_ERROR_IO : "-1004",
/**Bitstream is not conforming to the related coding standard or file spec. */
MEDIA_ERROR_MALFORMED : "-1007",
/**Bitstream is conforming to the related coding standard or file spec, but
 the media framework does not support the feature. */
MEDIA_ERROR_UNSUPPORTED : "-1010",
/**Some operation takes too long to complete, usually more than 3-5 seconds. */
MEDIA_ERROR_TIMED_OUT : "-110",
/**Unspecified low-level system error. This value originated from UNKNOWN_ERROR in
 system/core/include/utils/Errors.h
 @see EventCallback#onError
 @hide
*/
MEDIA_ERROR_SYSTEM : "-2147483648",
/**Unspecified media player info.
 @see EventCallback#onInfo
*/
MEDIA_INFO_UNKNOWN : "1",
/**The player just started the playback of this datas source.
 @see EventCallback#onInfo
*/
MEDIA_INFO_DATA_SOURCE_START : "2",
/**The player just pushed the very first video frame for rendering.
 @see EventCallback#onInfo
*/
MEDIA_INFO_VIDEO_RENDERING_START : "3",
/**The player just rendered the very first audio sample.
 @see EventCallback#onInfo
*/
MEDIA_INFO_AUDIO_RENDERING_START : "4",
/**The player just completed the playback of this data source.
 @see EventCallback#onInfo
*/
MEDIA_INFO_DATA_SOURCE_END : "5",
/**The player just completed the playback of all data sources set by {@link #setDataSource},
 {@link #setNextDataSource} and {@link #setNextDataSources}.
 @see EventCallback#onInfo
*/
MEDIA_INFO_DATA_SOURCE_LIST_END : "6",
/**The player just completed an iteration of playback loop. This event is sent only when
  looping is enabled by {@link #loopCurrent}.
 @see EventCallback#onInfo
*/
MEDIA_INFO_DATA_SOURCE_REPEAT : "7",
/**The player just prepared a data source.
 @see EventCallback#onInfo
*/
MEDIA_INFO_PREPARED : "100",
/**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 EventCallback#onInfo
*/
MEDIA_INFO_VIDEO_TRACK_LAGGING : "700",
/**MediaPlayer2 is temporarily pausing playback internally in order to
 buffer more data.
 @see EventCallback#onInfo
*/
MEDIA_INFO_BUFFERING_START : "701",
/**MediaPlayer2 is resuming playback after filling buffers.
 @see EventCallback#onInfo
*/
MEDIA_INFO_BUFFERING_END : "702",
/**Estimated network bandwidth information (kbps) is available; currently this event fires
 simultaneously as {@link #MEDIA_INFO_BUFFERING_START} and {@link #MEDIA_INFO_BUFFERING_END}
 when playing network files.
 @see EventCallback#onInfo
 @hide
*/
MEDIA_INFO_NETWORK_BANDWIDTH : "703",
/** Update status in buffering a media source received through progressive downloading.
 The received buffering percentage indicates how much of the content has been buffered
 or played. For example a buffering update of 80 percent when half the content
 has already been played indicates that the next 30 percent of the
 content to play has been buffered.

 The {@code extra} parameter in {@code EventCallback.onInfo} is the
 percentage (0-100) of the content that has been buffered or played thus far.
 @see EventCallback#onInfo
*/
MEDIA_INFO_BUFFERING_UPDATE : "704",
/**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 EventCallback#onInfo
*/
MEDIA_INFO_BAD_INTERLEAVING : "800",
/**The media cannot be seeked (e.g live stream)
 @see EventCallback#onInfo
*/
MEDIA_INFO_NOT_SEEKABLE : "801",
/**A new set of metadata is available.
 @see EventCallback#onInfo
*/
MEDIA_INFO_METADATA_UPDATE : "802",
/**Informs that audio is not playing. Note that playback of the video
 is not interrupted.
 @see EventCallback#onInfo
*/
MEDIA_INFO_AUDIO_NOT_PLAYING : "804",
/**Informs that video is not playing. Note that playback of the audio
 is not interrupted.
 @see EventCallback#onInfo
*/
MEDIA_INFO_VIDEO_NOT_PLAYING : "805",
/**Failed to handle timed text track properly.
 @see EventCallback#onInfo

 {@hide}
*/
MEDIA_INFO_TIMED_TEXT_ERROR : "900",
/**Subtitle track was not supported by the media framework.
 @see EventCallback#onInfo
*/
MEDIA_INFO_UNSUPPORTED_SUBTITLE : "901",
/**Reading the subtitle track takes too long.
 @see EventCallback#onInfo
*/
MEDIA_INFO_SUBTITLE_TIMED_OUT : "902",
/**The player just completed a call {@link #attachAuxEffect}.
 @see EventCallback#onCallCompleted
*/
CALL_COMPLETED_ATTACH_AUX_EFFECT : "1",
/**The player just completed a call {@link #deselectTrack}.
 @see EventCallback#onCallCompleted
*/
CALL_COMPLETED_DESELECT_TRACK : "2",
/**The player just completed a call {@link #loopCurrent}.
 @see EventCallback#onCallCompleted
*/
CALL_COMPLETED_LOOP_CURRENT : "3",
/**The player just completed a call {@link #pause}.
 @see EventCallback#onCallCompleted
*/
CALL_COMPLETED_PAUSE : "4",
/**The player just completed a call {@link #play}.
 @see EventCallback#onCallCompleted
*/
CALL_COMPLETED_PLAY : "5",
/**The player just completed a call {@link #prepare}.
 @see EventCallback#onCallCompleted
*/
CALL_COMPLETED_PREPARE : "6",
/**The player just completed a call {@link #seekTo}.
 @see EventCallback#onCallCompleted
*/
CALL_COMPLETED_SEEK_TO : "14",
/**The player just completed a call {@link #selectTrack}.
 @see EventCallback#onCallCompleted
*/
CALL_COMPLETED_SELECT_TRACK : "15",
/**The player just completed a call {@link #setAudioAttributes}.
 @see EventCallback#onCallCompleted
*/
CALL_COMPLETED_SET_AUDIO_ATTRIBUTES : "16",
/**The player just completed a call {@link #setAudioSessionId}.
 @see EventCallback#onCallCompleted
*/
CALL_COMPLETED_SET_AUDIO_SESSION_ID : "17",
/**The player just completed a call {@link #setAuxEffectSendLevel}.
 @see EventCallback#onCallCompleted
*/
CALL_COMPLETED_SET_AUX_EFFECT_SEND_LEVEL : "18",
/**The player just completed a call {@link #setDataSource}.
 @see EventCallback#onCallCompleted
*/
CALL_COMPLETED_SET_DATA_SOURCE : "19",
/**The player just completed a call {@link #setNextDataSource}.
 @see EventCallback#onCallCompleted
*/
CALL_COMPLETED_SET_NEXT_DATA_SOURCE : "22",
/**The player just completed a call {@link #setNextDataSources}.
 @see EventCallback#onCallCompleted
*/
CALL_COMPLETED_SET_NEXT_DATA_SOURCES : "23",
/**The player just completed a call {@link #setPlaybackParams}.
 @see EventCallback#onCallCompleted
*/
CALL_COMPLETED_SET_PLAYBACK_PARAMS : "24",
/**The player just completed a call {@link #setPlayerVolume}.
 @see EventCallback#onCallCompleted
*/
CALL_COMPLETED_SET_PLAYER_VOLUME : "26",
/**The player just completed a call {@link #setSurface}.
 @see EventCallback#onCallCompleted
*/
CALL_COMPLETED_SET_SURFACE : "27",
/**The player just completed a call {@link #setSyncParams}.
 @see EventCallback#onCallCompleted
*/
CALL_COMPLETED_SET_SYNC_PARAMS : "28",
/**The player just completed a call {@link #skipToNext}.
 @see EventCallback#onCallCompleted
*/
CALL_COMPLETED_SKIP_TO_NEXT : "29",
/**The player just completed a call {@link #clearNextDataSources}.
 @see EventCallback#onCallCompleted
*/
CALL_COMPLETED_CLEAR_NEXT_DATA_SOURCES : "30",
/**The player just completed a call {@link #setBufferingParams}.
 @see EventCallback#onCallCompleted
 @hide
*/
CALL_COMPLETED_SET_BUFFERING_PARAMS : "31",
/**The player just completed a call {@link #setDisplay}.
 @see EventCallback#onCallCompleted
*/
CALL_COMPLETED_SET_DISPLAY : "33",
/**The player just completed a call {@link #setWakeLock}.
 @see EventCallback#onCallCompleted
*/
CALL_COMPLETED_SET_WAKE_LOCK : "34",
/**The player just completed a call {@link #setScreenOnWhilePlaying}.
 @see EventCallback#onCallCompleted
*/
CALL_COMPLETED_SET_SCREEN_ON_WHILE_PLAYING : "35",
/** The start of the methods which have separate call complete callback.
 @hide
*/
SEPARATE_CALL_COMPLETED_CALLBACK_START : "1000",
/**The player just completed a call {@link #notifyWhenCommandLabelReached}.
 @see EventCallback#onCommandLabelReached
 @hide
*/
CALL_COMPLETED_NOTIFY_WHEN_COMMAND_LABEL_REACHED : "1000",
/**The player just completed a call {@link #prepareDrm}.
 @see DrmEventCallback#onDrmPrepared
 @hide
*/
CALL_COMPLETED_PREPARE_DRM : "1001",
/**Status code represents that call is completed without an error.
 @see EventCallback#onCallCompleted
*/
CALL_STATUS_NO_ERROR : "0",
/**Status code represents that call is ended with an unknown error.
 @see EventCallback#onCallCompleted
*/
CALL_STATUS_ERROR_UNKNOWN : "-2147483648",
/**Status code represents that the player is not in valid state for the operation.
 @see EventCallback#onCallCompleted
*/
CALL_STATUS_INVALID_OPERATION : "1",
/**Status code represents that the argument is illegal.
 @see EventCallback#onCallCompleted
*/
CALL_STATUS_BAD_VALUE : "2",
/**Status code represents that the operation is not allowed.
 @see EventCallback#onCallCompleted
*/
CALL_STATUS_PERMISSION_DENIED : "3",
/**Status code represents a file or network related operation error.
 @see EventCallback#onCallCompleted
*/
CALL_STATUS_ERROR_IO : "4",
/**Status code represents that the call has been skipped. For example, a {@link #seekTo}
 request may be skipped if it is followed by another {@link #seekTo} request.
 @see EventCallback#onCallCompleted
*/
CALL_STATUS_SKIPPED : "5",
/**Status code represents that DRM operation is called before preparing a DRM scheme through
  {@code prepareDrm}.
 @see EventCallback#onCallCompleted
*/
CALL_STATUS_NO_DRM_SCHEME : "6",
/** A status code for {@link android.media.MediaDrm.DrmEventCallback#onDrmPrepared} listener.
 <p>

 DRM preparation has succeeded.
*/
PREPARE_DRM_STATUS_SUCCESS : "0",
/** A status code for {@link android.media.MediaDrm.DrmEventCallback#onDrmPrepared} listener.
 <p>

 The device required DRM provisioning but couldn't reach the provisioning server.
*/
PREPARE_DRM_STATUS_PROVISIONING_NETWORK_ERROR : "1",
/** A status code for {@link android.media.MediaDrm.DrmEventCallback#onDrmPrepared} listener.
 <p>

 The device required DRM provisioning but the provisioning server denied the request.
*/
PREPARE_DRM_STATUS_PROVISIONING_SERVER_ERROR : "2",
/** A status code for {@link android.media.MediaDrm.DrmEventCallback#onDrmPrepared} listener.
 <p>

 The DRM preparation has failed .
*/
PREPARE_DRM_STATUS_PREPARATION_ERROR : "3",
/** A status code for {@link android.media.MediaDrm.DrmEventCallback#onDrmPrepared} listener.
 <p>

 The crypto scheme UUID is not supported by the device.
*/
PREPARE_DRM_STATUS_UNSUPPORTED_SCHEME : "4",
/** A status code for {@link android.media.MediaDrm.DrmEventCallback#onDrmPrepared} listener.
 <p>

 The hardware resources are not available, due to being in use.
*/
PREPARE_DRM_STATUS_RESOURCE_BUSY : "5",
/** A status code for {@link android.media.MediaDrm.DrmEventCallback#onDrmPrepared} listener.
 <p>

 Restoring persisted offline keys failed.
*/
PREPARE_DRM_STATUS_RESTORE_ERROR : "6",
/** A status code for {@link android.media.MediaDrm.DrmEventCallback#onDrmPrepared} listener.
 <p>

 Error during key request/response exchange with license server.
*/
PREPARE_DRM_STATUS_KEY_EXCHANGE_ERROR : "7",
/**Releases the resources held by this {@code MediaPlayer2} object.

 It is considered good practice to call this method when you're
 done using the MediaPlayer2. In particular, whenever an Activity
 of an application is paused (its onPause() method is called),
 or stopped (its onStop() method is called), this method should be
 invoked to release the MediaPlayer2 object, unless the application
 has a special need to keep the object around. In addition to
 unnecessary resources (such as memory and instances of codecs)
 being held, failure to call this method immediately if a
 MediaPlayer2 object is no longer needed may also lead to
 continuous battery consumption for mobile devices, and playback
 failure for other applications if no multiple instances of the
 same codec are supported on a device. Even if multiple instances
 of the same codec are supported, some performance degradation
 may be expected when unnecessary multiple instances are used
 at the same time.

 {@code close()} may be safely called after a prior {@code close()}.
 This class implements the Java {@code AutoCloseable} interface and
 may be used with try-with-resources.
*/
close : function(  ) {},

/**Resets the MediaPlayer2 to its uninitialized state. After calling
 this method, you will have to initialize it again by setting the
 data source and calling prepare().
*/
reset : function(  ) {},

/**Starts or resumes playback. If playback had previously been paused,
 playback will continue from where it was paused. If playback had
 reached end of stream and been paused, or never started before,
 playback will start at the beginning.
@return {Object {java.lang.Object}} a token which can be used to cancel the operation later with {@link #cancelCommand}.
*/
play : function(  ) {},

/**Prepares the player for playback, asynchronously.

 After setting the datasource and the display surface, you need to call prepare().
@return {Object {java.lang.Object}} a token which can be used to cancel the operation later with {@link #cancelCommand}.
*/
prepare : function(  ) {},

/**Pauses playback. Call play() to resume.
@return {Object {java.lang.Object}} a token which can be used to cancel the operation later with {@link #cancelCommand}.
*/
pause : function(  ) {},

/**Tries to play next data source if applicable.
@return {Object {java.lang.Object}} a token which can be used to cancel the operation later with {@link #cancelCommand}.
*/
skipToNext : function(  ) {},

/**Gets the current playback position.
@return {Number} the current position in milliseconds
*/
getCurrentPosition : function(  ) {},

/**Gets the duration of the current data source.
 Same as {@link #getDuration}(DataSourceDesc) with
 {@code dsd = getCurrentDataSource()}.
@return {Number} the duration in milliseconds, if no duration is available
         (for example, if streaming live content), -1 is returned.
@throws NullPointerException if current data source is null
*/
getDuration : function(  ) {},

/**Gets the duration of the dsd.
@param {Object {DataSourceDesc}} dsd the descriptor of data source of which you want to get duration
@return {Number} the duration in milliseconds, if no duration is available
         (for example, if streaming live content), -1 is returned.
@throws NullPointerException if dsd is null
*/
getDuration : function(  ) {},

/**Gets the buffered media source position of current data source.
 Same as {@link #getBufferedPosition}(DataSourceDesc) with
 {@code dsd = getCurrentDataSource()}.
@return {Number} the current buffered media source position in milliseconds
@throws NullPointerException if current data source is null
*/
getBufferedPosition : function(  ) {},

/**Gets the buffered media source position of given dsd.
 For example a buffering update of 8000 milliseconds when 5000 milliseconds of the content
 has already been played indicates that the next 3000 milliseconds of the
 content to play has been buffered.
@param {Object {DataSourceDesc}} dsd the descriptor of data source of which you want to get buffered position
@return {Number} the current buffered media source position in milliseconds
@throws NullPointerException if dsd is null
*/
getBufferedPosition : function(  ) {},

/**Gets the current player state.
@return {Number} the current player state.
*/
getState : function(  ) {},

/**Sets the audio attributes for this MediaPlayer2.
 See {@link android.media.AudioAttributes} for how to build and configure an instance of this class.
 You must call this method before {@link #play}() and {@link #pause}() in order
 for the audio attributes to become effective thereafter.
@param {Object {AudioAttributes}} attributes a non-null set of audio attributes
@return {Object {java.lang.Object}} a token which can be used to cancel the operation later with {@link #cancelCommand}.
*/
setAudioAttributes : function(  ) {},

/**Gets the audio attributes for this MediaPlayer2.
@return {Object {android.media.AudioAttributes}} attributes a set of audio attributes
*/
getAudioAttributes : function(  ) {},

/**Sets the data source as described by a DataSourceDesc.
 When the data source is of {@link android.media.FileDataSourceDesc} type, the {@link ParcelFileDescriptor}
 in the {@link android.media.FileDataSourceDesc} will be closed by the player.
@param {Object {DataSourceDesc}} dsd the descriptor of data source you want to play
@return {Object {java.lang.Object}} a token which can be used to cancel the operation later with {@link #cancelCommand}.
*/
setDataSource : function(  ) {},

/**Sets a single data source as described by a DataSourceDesc which will be played
 after current data source is finished.
 When the data source is of {@link android.media.FileDataSourceDesc} type, the {@link ParcelFileDescriptor}
 in the {@link android.media.FileDataSourceDesc} will be closed by the player.
@param {Object {DataSourceDesc}} dsd the descriptor of data source you want to play after current one
@return {Object {java.lang.Object}} a token which can be used to cancel the operation later with {@link #cancelCommand}.
*/
setNextDataSource : function(  ) {},

/**Sets a list of data sources to be played sequentially after current data source is done.
 When the data source is of {@link android.media.FileDataSourceDesc} type, the {@link ParcelFileDescriptor}
 in the {@link android.media.FileDataSourceDesc} will be closed by the player.
@param {Object {java.util.List}} dsds the list of data sources you want to play after current one
@return {Object {java.lang.Object}} a token which can be used to cancel the operation later with {@link #cancelCommand}.
*/
setNextDataSources : function(  ) {},

/**Removes all data sources pending to be played.
@return {Object {java.lang.Object}} a token which can be used to cancel the operation later with {@link #cancelCommand}.
*/
clearNextDataSources : function(  ) {},

/**Gets the current data source as described by a DataSourceDesc.
@return {Object {android.media.DataSourceDesc}} the current DataSourceDesc
*/
getCurrentDataSource : function(  ) {},

/**Configures the player to loop on the current data source.
@param {Boolean} loop true if the current data source is meant to loop.
@return {Object {java.lang.Object}} a token which can be used to cancel the operation later with {@link #cancelCommand}.
*/
loopCurrent : function(  ) {},

/**Sets the volume of the audio of the media to play, expressed as a linear multiplier
 on the audio samples.
 Note that this volume is specific to the player, and is separate from stream volume
 used across the platform.<br>
 A value of 0.0f indicates muting, a value of 1.0f is the nominal unattenuated and unamplified
 gain. See {@link #getMaxPlayerVolume}() for the volume range supported by this player.
@param {Number} volume a value between 0.0f and {@link #getMaxPlayerVolume()}.
@return {Object {java.lang.Object}} a token which can be used to cancel the operation later with {@link #cancelCommand}.
*/
setPlayerVolume : function(  ) {},

/**Returns the current volume of this player.
 Note that it does not take into account the associated stream volume.
@return {Number} the player volume.
*/
getPlayerVolume : function(  ) {},

/**
@return {Number} the maximum volume that can be used in {@link #setPlayerVolume(float)}.
*/
getMaxPlayerVolume : function(  ) {},

/**Insert a task in the command queue to help the client to identify whether a batch
 of commands has been finished. When this command is processed, a notification
 {@link android.media.MediaPlayer2.EventCallback#onCommandLabelReached onCommandLabelReached} will be fired with the
 given {@code label}.
@param {Object {Object}} label An application specific Object used to help to identify the completeness
 of a batch of commands.
@param label An application specific Object used to help to identify the completeness
 of a batch of commands.
@return {Object {java.lang.Object}} a token which can be used to cancel the operation later with {@link #cancelCommand}.
*/
notifyWhenCommandLabelReached : function(  ) {},

/**Sets the {@link SurfaceHolder} to use for displaying the video
 portion of the media.

 Either a surface holder or surface must be set if a display or video sink
 is needed. Not calling this method or {@link #setSurface}(Surface)
 when playing back a video will result in only the audio track being played.
 A null surface holder or surface will result in only the audio track being
 played.
@param {Object {SurfaceHolder}} sh the SurfaceHolder to use for video display
@return {Object {java.lang.Object}} a token which can be used to cancel the operation later with {@link #cancelCommand}.
*/
setDisplay : function(  ) {},

/**Sets the {@link Surface} to be used as the sink for the video portion of
 the media.  Setting a
 Surface will un-set any Surface or SurfaceHolder that was previously set.
 A null surface will result in only the audio track being played.

 If the Surface sends frames to a {@link SurfaceTexture}, the timestamps
 returned from {@link SurfaceTexture#getTimestamp()} will have an
 unspecified zero point.  These timestamps cannot be directly compared
 between different media sources, different instances of the same media
 source, or multiple runs of the same program.  The timestamp is normally
 monotonically increasing and is unaffected by time-of-day adjustments,
 but it is reset when the position is set.
@param {Object {Surface}} surface The {@link Surface} to be used for the video portion of
 the media.
@return {Object {java.lang.Object}} a token which can be used to cancel the operation later with {@link #cancelCommand}.
*/
setSurface : function(  ) {},

/**Set the low-level power management behavior for this MediaPlayer2. This
 can be used when the MediaPlayer2 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 MediaPlayer2 access the low-level power manager
 service to control the device's power usage while playing is occurring.
 The parameter is a {@link android.os.PowerManager.WakeLock}.
 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 {Object {PowerManager.WakeLock}} wakeLock the power wake lock used during playback.
@return {Object {java.lang.Object}} a token which can be used to cancel the operation later with {@link #cancelCommand}.
@see android.os.PowerManager
*/
setWakeLock : function(  ) {},

/**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 #setWakeLock} where possible, since it doesn't
 require that the application have permission for low-level wake lock
 access.
@param {Boolean} screenOn Supply true to keep the screen on, false to allow it to turn off.
@return {Object {java.lang.Object}} a token which can be used to cancel the operation later with {@link #cancelCommand}.
*/
setScreenOnWhilePlaying : function(  ) {},

/**Cancels a pending command.
@param {Object {Object}} token the command to be canceled. This is the returned Object when command is issued.
@return {Boolean} {@code false} if the task could not be cancelled; {@code true} otherwise.
@throws IllegalArgumentException if argument token is null.
*/
cancelCommand : function(  ) {},

/**Discards all pending commands.
*/
clearPendingCommands : function(  ) {},

/**Specifies an audio device (via an {@link android.media.AudioDeviceInfo} object) to route
 the output from this MediaPlayer2.
@param {Object {AudioDeviceInfo}} deviceInfo The {@link AudioDeviceInfo} specifying the audio sink or source.
  If deviceInfo is null, default routing is restored.
@return {Boolean} true if succesful, false if the specified {@link AudioDeviceInfo} is non-null and
 does not correspond to a valid audio device.
*/
setPreferredDevice : function(  ) {},

/**Returns the selected output specified by {@link #setPreferredDevice}. Note that this
 is not guaranteed to correspond to the actual device being used for playback.
*/
getPreferredDevice : function(  ) {},

/**Returns an {@link android.media.AudioDeviceInfo} identifying the current routing of this MediaPlayer2
 Note: The query is only valid if the MediaPlayer2 is currently playing.
 If the player is not playing, the returned device can be null or correspond to previously
 selected device when the player was last active.
*/
getRoutedDevice : function(  ) {},

/**Adds an {@link android.media.AudioRouting.OnRoutingChangedListener} to receive notifications of routing
 changes on this MediaPlayer2.
@param {Object {AudioRouting.OnRoutingChangedListener}} listener The {@link AudioRouting.OnRoutingChangedListener} interface to receive
 notifications of rerouting events.
@param {Object {Handler}} handler  Specifies the {@link Handler} object for the thread on which to execute
 the callback. If <code>null</code>, the handler on the main looper will be used.
*/
addOnRoutingChangedListener : function(  ) {},

/**Removes an {@link android.media.AudioRouting.OnRoutingChangedListener} which has been previously added
 to receive rerouting notifications.
@param {Object {AudioRouting.OnRoutingChangedListener}} listener The previously added {@link AudioRouting.OnRoutingChangedListener} interface
 to remove.
*/
removeOnRoutingChangedListener : function(  ) {},

/**Returns the size of the video.
@return {Object {android.util.Size}} the size of the video. The width and height of size could be 0 if there is no video,
 or the size has not been determined yet.
 The {@code EventCallback} can be registered via
 {@link #registerEventCallback(Executor, EventCallback)} to provide a
 notification {@code EventCallback.onVideoSizeChanged} when the size
 is available.
*/
getVideoSize : function(  ) {},

/**Return Metrics data about the current player.
@return {Object {android.os.PersistableBundle}} a {@link PersistableBundle} containing the set of attributes and values
 available for the media being handled by this instance of MediaPlayer2
 The attributes are descibed in {@link MetricsConstants}.

 Additional vendor-specific fields may also be present in the return value.
*/
getMetrics : function(  ) {},

/**Sets playback rate using {@link android.media.PlaybackParams}. The object sets its internal
 PlaybackParams to the input. This allows the object to resume at previous speed
 when play() is called. Speed of zero is not allowed. Calling it does not change
 the object state.
@param {Object {PlaybackParams}} params the playback params.
@return {Object {java.lang.Object}} a token which can be used to cancel the operation later with {@link #cancelCommand}.
*/
setPlaybackParams : function(  ) {},

/**Gets the playback params, containing the current playback rate.
@return {Object {android.media.PlaybackParams}} the playback params.
@throws IllegalStateException if the internal player engine has not been initialized.
*/
getPlaybackParams : function(  ) {},

/**Sets A/V sync mode.
@param {Object {SyncParams}} params the A/V sync params to apply
@return {Object {java.lang.Object}} a token which can be used to cancel the operation later with {@link #cancelCommand}.
*/
setSyncParams : function(  ) {},

/**Gets the A/V sync mode.
@return {Object {android.media.SyncParams}} the A/V sync params
@throws IllegalStateException if the internal player engine has not been initialized.
*/
getSyncParams : function(  ) {},

/**Moves the media to specified time position.
 Same as {@link #seekTo(long, int)} with {@code mode = SEEK_PREVIOUS_SYNC}.
@param {Number} msec the offset in milliseconds from the start to seek to
@return {Object {java.lang.Object}} a token which can be used to cancel the operation later with {@link #cancelCommand}.
*/
seekTo : function(  ) {},

/**Moves the media to specified time position by considering the given mode.
 <p>
 When seekTo is finished, the user will be notified via
 {@link android.media.MediaPlayer2.EventCallback#onCallCompleted} with {@link #CALL_COMPLETED_SEEK_TO}.
 There is at most one active seekTo processed at any time. If there is a to-be-completed
 seekTo, new seekTo requests will be queued in such a way that only the last request
 is kept. When current seekTo is completed, the queued request will be processed if
 that request is different from just-finished seekTo operation, i.e., the requested
 position or mode is different.
@param {Number} msec the offset in milliseconds from the start to seek to.
 When seeking to the given time position, there is no guarantee that the data source
 has a frame located at the position. When this happens, a frame nearby will be rendered.
 If msec is negative, time position zero will be used.
 If msec is larger than duration, duration will be used.
@param {Number} mode the mode indicating where exactly to seek to.
@return {Object {java.lang.Object}} a token which can be used to cancel the operation later with {@link #cancelCommand}.
*/
seekTo : function(  ) {},

/**Get current playback position as a {@link android.media.MediaTimestamp}.
 <p>
 The MediaTimestamp represents how the media time correlates to the system time in
 a linear fashion using an anchor and a clock rate. During regular playback, the media
 time moves fairly constantly (though the anchor frame may be rebased to a current
 system time, the linear correlation stays steady). Therefore, this method does not
 need to be called often.
 <p>
 To help users get current playback position, this method always anchors the timestamp
 to the current {@link System#nanoTime system time}, so
 {@link android.media.MediaTimestamp#getAnchorMediaTimeUs} can be used as current playback position.
@return {Object {android.media.MediaTimestamp}} a MediaTimestamp object if a timestamp is available, or {@code null} if no timestamp
         is available, e.g. because the media player has not been initialized.
@see MediaTimestamp
*/
getTimestamp : function(  ) {},

/**Checks whether the MediaPlayer2 is looping or non-looping.
@return {Boolean} true if the MediaPlayer2 is currently looping, false otherwise
*/
isLooping : function(  ) {},

/**Sets the audio session ID.
@param {Number} sessionId the audio session ID.
 The audio session ID is a system wide unique identifier for the audio stream played by
 this MediaPlayer2 instance.
 The primary use of the audio session ID  is to associate audio effects to a particular
 instance of MediaPlayer2: if an audio session ID is provided when creating an audio effect,
 this effect will be applied only to the audio content of media players within the same
 audio session and not to the output mix.
 When created, a MediaPlayer2 instance automatically generates its own audio session ID.
 However, it is possible to force this player to be part of an already existing audio session
 by calling this method.
 This method must be called when player is in {@link #PLAYER_STATE_IDLE} or
 {@link #PLAYER_STATE_PREPARED} state in order to have sessionId take effect.
@return {Object {java.lang.Object}} a token which can be used to cancel the operation later with {@link #cancelCommand}.
*/
setAudioSessionId : function(  ) {},

/**Returns the audio session ID.
@return {Number} the audio session ID. {@see #setAudioSessionId(int)}
 Note that the audio session ID is 0 only if a problem occured when the MediaPlayer2 was
 contructed.
*/
getAudioSessionId : function(  ) {},

/**Attaches an auxiliary effect to the player. A typical auxiliary effect is a reverberation
 effect which can be applied on any sound source that directs a certain amount of its
 energy to this effect. This amount is defined by setAuxEffectSendLevel().
 See {@link #setAuxEffectSendLevel}(float).
 <p>After creating an auxiliary effect (e.g.
 {@link android.media.audiofx.EnvironmentalReverb}), retrieve its ID with
 {@link android.media.audiofx.AudioEffect#getId()} and use it when calling this method
 to attach the player to the effect.
 <p>To detach the effect from the player, call this method with a null effect id.
 <p>This method must be called after one of the overloaded <code> setDataSource </code>
 methods.
@param {Number} effectId system wide unique id of the effect to attach
@return {Object {java.lang.Object}} a token which can be used to cancel the operation later with {@link #cancelCommand}.
*/
attachAuxEffect : function(  ) {},

/**Sets the send level of the player to the attached auxiliary effect.
 See {@link #attachAuxEffect}(int). The level value range is 0 to 1.0.
 <p>By default the send level is 0, so even if an effect is attached to the player
 this method must be called for the effect to be applied.
 <p>Note that the passed level value is a raw scalar. UI controls should be scaled
 logarithmically: the gain applied by audio framework ranges from -72dB to 0dB,
 so an appropriate conversion from linear UI input x to level is:
 x == 0 -> level = 0
 0 < x <= R -> level = 10^(72*(x-R)/20/R)
@param {Number} level send level scalar
@return {Object {java.lang.Object}} a token which can be used to cancel the operation later with {@link #cancelCommand}.
*/
setAuxEffectSendLevel : function(  ) {},

/**Returns a List of track information of current data source.
 Same as {@link #getTrackInfo}(DataSourceDesc) with
 {@code dsd = getCurrentDataSource()}.
@return {Object {java.util.List}} List of track info. The total number of tracks is the array length.
 Must be called again if an external timed text source has been added after
 addTimedTextSource method is called.
@throws IllegalStateException if it is called in an invalid state.
@throws NullPointerException if current data source is null
*/
getTrackInfo : function(  ) {},

/**Returns a List of track information.
@param {Object {DataSourceDesc}} dsd the descriptor of data source of which you want to get track info
@return {Object {java.util.List}} List of track info. The total number of tracks is the array length.
 Must be called again if an external timed text source has been added after
 addTimedTextSource method is called.
@throws IllegalStateException if it is called in an invalid state.
@throws NullPointerException if dsd is null
*/
getTrackInfo : function(  ) {},

/**Returns the index of the audio, video, or subtitle track currently selected for playback.
 The return value is an index into the array returned by {@link #getTrackInfo}, and can
 be used in calls to {@link #selectTrack}(TrackInfo) or {@link #deselectTrack}(TrackInfo).
 Same as {@link #getSelectedTrack(DataSourceDesc, int)} with
 {@code dsd = getCurrentDataSource()}.
@param {Number} trackType should be one of {@link TrackInfo#MEDIA_TRACK_TYPE_VIDEO},
 {@link TrackInfo#MEDIA_TRACK_TYPE_AUDIO}, or
 {@link TrackInfo#MEDIA_TRACK_TYPE_SUBTITLE}
@return {Object {android.media.MediaPlayer2.TrackInfo}} metadata corresponding to the audio, video, or subtitle track currently selected for
 playback; {@code null} is returned when there is no selected track for {@code trackType} or
 when {@code trackType} is not one of audio, video, or subtitle.
@throws IllegalStateException if called after {@link #close()}
@throws NullPointerException if current data source is null
@see #getTrackInfo()
@see #selectTrack(TrackInfo)
@see #deselectTrack(TrackInfo)
*/
getSelectedTrack : function(  ) {},

/**Returns the index of the audio, video, or subtitle track currently selected for playback.
 The return value is an index into the array returned by {@link #getTrackInfo}, and can
 be used in calls to {@link #selectTrack(DataSourceDesc, android.media.MediaPlayer.TrackInfo)} or
 {@link #deselectTrack(DataSourceDesc, android.media.MediaPlayer.TrackInfo)}.
@param {Object {DataSourceDesc}} dsd the descriptor of data source of which you want to get selected track
@param {Number} trackType should be one of {@link TrackInfo#MEDIA_TRACK_TYPE_VIDEO},
 {@link TrackInfo#MEDIA_TRACK_TYPE_AUDIO}, or
 {@link TrackInfo#MEDIA_TRACK_TYPE_SUBTITLE}
@return {Object {android.media.MediaPlayer2.TrackInfo}} metadata corresponding to the audio, video, or subtitle track currently selected for
 playback; {@code null} is returned when there is no selected track for {@code trackType} or
 when {@code trackType} is not one of audio, video, or subtitle.
@throws IllegalStateException if called after {@link #close()}
@throws NullPointerException if dsd is null
@see #getTrackInfo(DataSourceDesc)
@see #selectTrack(DataSourceDesc, TrackInfo)
@see #deselectTrack(DataSourceDesc, TrackInfo)
*/
getSelectedTrack : function(  ) {},

/**Selects a track of current data source.
 Same as {@link #selectTrack(DataSourceDesc, android.media.MediaPlayer.TrackInfo)} with
 {@code dsd = getCurrentDataSource()}.
@param {Object {MediaPlayer2.TrackInfo}} trackInfo metadata corresponding to the track to be selected. A {@code trackInfo}
 object can be obtained from {@link #getTrackInfo()}.
@return {Object {java.lang.Object}} a token which can be used to cancel the operation later with {@link #cancelCommand}.

 This is an asynchronous call.
@see MediaPlayer2#getTrackInfo()
*/
selectTrack : function(  ) {},

/**Selects a track.
 <p>
 If a MediaPlayer2 is in invalid state, it throws an IllegalStateException exception.
 If a MediaPlayer2 is in <em>Started</em> state, the selected track is presented immediately.
 If a MediaPlayer2 is not in Started state, it just marks the track to be played.
 </p>
 <p>
 In any valid state, if it is called multiple times on the same type of track (ie. Video,
 Audio, Timed Text), the most recent one will be chosen.
 </p>
 <p>
 The first audio and video tracks are selected by default if available, even though
 this method is not called. However, no timed text track will be selected until
 this function is called.
 </p>
 <p>
 Currently, only timed text tracks or audio tracks can be selected via this method.
 In addition, the support for selecting an audio track at runtime is pretty limited
 in that an audio track can only be selected in the <em>Prepared</em> state.
 </p>
@param {Object {DataSourceDesc}} dsd the descriptor of data source of which you want to select track
@param {Object {MediaPlayer2.TrackInfo}} trackInfo metadata corresponding to the track to be selected. A {@code trackInfo}
 object can be obtained from {@link #getTrackInfo()}.
@return {Object {java.lang.Object}} a token which can be used to cancel the operation later with {@link #cancelCommand}.

 This is an asynchronous call.
@see MediaPlayer2#getTrackInfo(DataSourceDesc)
*/
selectTrack : function(  ) {},

/**Deselect a track of current data source.
 Same as {@link #deselectTrack(DataSourceDesc, android.media.MediaPlayer.TrackInfo)} with
 {@code dsd = getCurrentDataSource()}.
@param {Object {MediaPlayer2.TrackInfo}} trackInfo metadata corresponding to the track to be selected. A {@code trackInfo}
 object can be obtained from {@link #getTrackInfo()}.
@return {Object {java.lang.Object}} a token which can be used to cancel the operation later with {@link #cancelCommand}.

 This is an asynchronous call.
@see MediaPlayer2#getTrackInfo()
*/
deselectTrack : function(  ) {},

/**Deselect a track.
 <p>
 Currently, the track must be a timed text track and no audio or video tracks can be
 deselected. If the timed text track identified by index has not been
 selected before, it throws an exception.
 </p>
@param {Object {DataSourceDesc}} dsd the descriptor of data source of which you want to deselect track
@param {Object {MediaPlayer2.TrackInfo}} trackInfo metadata corresponding to the track to be selected. A {@code trackInfo}
 object can be obtained from {@link #getTrackInfo()}.
@return {Object {java.lang.Object}} a token which can be used to cancel the operation later with {@link #cancelCommand}.

 This is an asynchronous call.
@see MediaPlayer2#getTrackInfo(DataSourceDesc)
*/
deselectTrack : function(  ) {},

/**Registers the callback to be invoked for various events covered by {@link android.media.MediaPlayer2.EventCallback}.
@param {Object {Executor}} executor the executor through which the callback should be invoked
@param {Object {MediaPlayer2.EventCallback}} eventCallback the callback that will be run
*/
registerEventCallback : function(  ) {},

/**Unregisters the {@link android.media.MediaPlayer2.EventCallback}.
@param {Object {MediaPlayer2.EventCallback}} eventCallback the callback to be unregistered
*/
unregisterEventCallback : function(  ) {},

/**Registers the callback to be invoked for various DRM events.

 This is a synchronous call.
@param {Object {Executor}} eventCallback the callback that will be run
@param {Object {MediaPlayer2.DrmEventCallback}} executor the executor through which the callback should be invoked
*/
setDrmEventCallback : function(  ) {},

/**Clear the {@link android.media.MediaDrm.DrmEventCallback}.

 This is a synchronous call.
*/
clearDrmEventCallback : function(  ) {},

/**Retrieves the DRM Info associated with the given source
@param {Object {DataSourceDesc}} dsd The DRM protected data source
@throws IllegalStateException if called before being prepared
@hide 
*/
getDrmInfo : function(  ) {},

/**Prepares the DRM for the given data source
 <p>
 If {@link android.media.MediaDrm.DrmEventCallback} is registered, it will be called during
 preparation to allow configuration of the DRM properties before opening the
 DRM session. It should be used only for a series of
 {@link #getDrmPropertyString(DataSourceDesc, String)} and
 {@link #setDrmPropertyString(DataSourceDesc, String, String)} calls
 and refrain from any lengthy operation.
 <p>
 If the device has not been provisioned before, this call also provisions the device
 which involves accessing the provisioning server and can take a variable time to
 complete depending on the network connectivity.
 When needed, the provisioning will be launched  in the background.
 The listener {@link android.media.MediaDrm.DrmEventCallback#onDrmPrepared}
 will be called when provisioning and preparation are finished. The application should
 check the status code returned with {@link android.media.MediaDrm.DrmEventCallback#onDrmPrepared} to proceed.
 <p>
 The registered {@link android.media.MediaDrm.DrmEventCallback#onDrmPrepared} is called to indicate the DRM
 session being ready. The application should not make any assumption about its call
 sequence (e.g., before or after prepareDrm returns).
 <p>
@param {Object {DataSourceDesc}} dsd The DRM protected data source
@param {Object {UUID}} uuid The UUID of the crypto scheme. If not known beforehand, it can be retrieved
 from the source listening to {@link DrmEventCallback#onDrmInfo}.
@return {Object {java.lang.Object}} a token which can be used to cancel the operation later with {@link #cancelCommand}.
@hide 
*/
prepareDrm : function(  ) {},

/**Releases the DRM session for the given data source
 <p>
 The player has to have an active DRM session and be in stopped, or prepared
 state before this call is made.
 A {@link #reset}() call will release the DRM session implicitly.
@param {Object {DataSourceDesc}} dsd The DRM protected data source
@throws NoDrmSchemeException if there is no active DRM session to release
@hide 
*/
releaseDrm : function(  ) {},

/**A key request/response exchange occurs between the app and a license server
 to obtain or release keys used to decrypt the given data source.
 <p>
 {@code getDrmKeyRequest()} is used to obtain an opaque key request byte array that is
 delivered to the license server.  The opaque key request byte array is returned
 in KeyRequest.data.  The recommended URL to deliver the key request to is
 returned in {@code KeyRequest.defaultUrl}.
 <p>
 After the app has received the key request response from the server,
 it should deliver to the response to the DRM engine plugin using the method
 {@link #provideDrmKeyResponse(DataSourceDesc, byte[], byte[])}.
@param {Object {DataSourceDesc}} dsd the DRM protected data source
@param {Object {byte[]}} keySetId is the key-set identifier of the offline keys being released when keyType is
 {@link MediaDrm#KEY_TYPE_RELEASE}. It should be set to null for other key requests, when
 keyType is {@link MediaDrm#KEY_TYPE_STREAMING} or {@link MediaDrm#KEY_TYPE_OFFLINE}.
@param {Object {byte[]}} initData is the container-specific initialization data when the keyType is
 {@link MediaDrm#KEY_TYPE_STREAMING} or {@link MediaDrm#KEY_TYPE_OFFLINE}. Its meaning is
 interpreted based on the mime type provided in the mimeType parameter.  It could
 contain, for example, the content ID, key ID or other data obtained from the content
 metadata that is required in generating the key request.
 When the keyType is {@link MediaDrm#KEY_TYPE_RELEASE}, it should be set to null.
@param {String} mimeType identifies the mime type of the content
@param {Number} keyType specifies the type of the request. The request may be to acquire
 keys for streaming, {@link MediaDrm#KEY_TYPE_STREAMING}, or for offline content
 {@link MediaDrm#KEY_TYPE_OFFLINE}, or to release previously acquired
 keys ({@link MediaDrm#KEY_TYPE_RELEASE}), which are identified by a keySetId.
@param {Object {java.util.Map}} optionalParameters are included in the key request message to
 allow a client application to provide additional message parameters to the server.
 This may be {@code null} if no additional parameters are to be sent.
@throws NoDrmSchemeException if there is no active DRM session
@hide 
*/
getDrmKeyRequest : function(  ) {},

/**A key response is received from the license server by the app for the given DRM protected
 data source, then provided to the DRM engine plugin using {@code provideDrmKeyResponse}.
 <p>
 When the response is for an offline key request, a key-set identifier is returned that
 can be used to later restore the keys to a new session with the method
 {@link #restoreDrmKeys(DataSourceDesc, byte[])}.
 When the response is for a streaming or release request, null is returned.
@param {Object {DataSourceDesc}} dsd the DRM protected data source
@param {Object {byte[]}} keySetId When the response is for a release request, keySetId identifies the saved
 key associated with the release request (i.e., the same keySetId passed to the earlier
 {@link # getDrmKeyRequest(DataSourceDesc, byte[], byte[], String, int, Map)} call).
 It MUST be null when the response is for either streaming or offline key requests.
@param {Object {byte[]}} response the byte array response from the server
@throws NoDrmSchemeException if there is no active DRM session
@throws DeniedByServerException if the response indicates that the
 server rejected the request
@hide 
*/
provideDrmKeyResponse : function(  ) {},

/**Restore persisted offline keys into a new session for the given DRM protected data source.
 {@code keySetId} identifies the keys to load, obtained from a prior call to
 {@link #provideDrmKeyResponse(DataSourceDesc, byte[], byte[])}.
@param {Object {DataSourceDesc}} dsd the DRM protected data source
@param {Object {byte[]}} keySetId identifies the saved key set to restore
@throws NoDrmSchemeException if there is no active DRM session
@hide 
*/
restoreDrmKeys : function(  ) {},

/**Read a DRM engine plugin String property value, given the DRM protected data source
 and property name string.
@param {Object {DataSourceDesc}} dsd the DRM protected data source
@param {String} propertyName the property name

 Standard fields names are:
 {@link MediaDrm#PROPERTY_VENDOR}, {@link MediaDrm#PROPERTY_VERSION},
 {@link MediaDrm#PROPERTY_DESCRIPTION}, {@link MediaDrm#PROPERTY_ALGORITHMS}
@throws NoDrmSchemeException if there is no active DRM session
@hide 
*/
getDrmPropertyString : function(  ) {},

/**Set a DRM engine plugin String property value for the given data source.
@param {Object {DataSourceDesc}} dsd the DRM protected data source
@param {String} propertyName the property name
@param {String} value the property value

 Standard fields names are:
 {@link MediaDrm#PROPERTY_VENDOR}, {@link MediaDrm#PROPERTY_VERSION},
 {@link MediaDrm#PROPERTY_DESCRIPTION}, {@link MediaDrm#PROPERTY_ALGORITHMS}
@throws NoDrmSchemeException if there is no active DRM session
@hide 
*/
setDrmPropertyString : function(  ) {},


};