/*
* Copyright (C) 2013 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.support.v4.media;
import android.os.SystemClock;
import android.view.KeyEvent;
/**
* Implemented by the playback side of the media system, to respond to
* requests to perform actions and to retrieve its current state. These
* requests may either come from key events dispatched directly to your UI, or
* events sent over a media button event receiver that this class keeps active
* while your window is in focus.
*/
public abstract class TransportPerformer {
/**
* Request to start playback on the media, resuming from whatever current state
* (position etc) it is in.
*/
public abstract void onStart();
/**
* Request to pause playback of the media, staying at the current playback position
* and other state so a later call to {@link #onStart()} will resume at the same place.
*/
public abstract void onPause();
/**
* Request to completely stop playback of the media, clearing whatever state the
* player thinks is appropriate.
*/
public abstract void onStop();
/**
* Request to return the duration of the current media, in milliseconds.
*/
public abstract long onGetDuration();
/**
* Request to return the current playback position, in milliseconds.
*/
public abstract long onGetCurrentPosition();
/**
* Request to move the current playback position.
* @param pos New position to move to, in milliseconds.
*/
public abstract void onSeekTo(long pos);
/**
* Request to find out whether the player is currently playing its media.
*/
public abstract boolean onIsPlaying();
/**
* Request to find out how much of the media has been buffered on the local device.
* @return Return a percentage (0-100) indicating how much of the total data
* has been buffered. The default implementation returns 100, meaning the content
* is always on the local device.
*/
public int onGetBufferPercentage() {
return 100;
}
/**
* Retrieves the flags for the media transport control buttons that this transport supports.
* Result is a combination of the following flags:
* {@link TransportMediator#FLAG_KEY_MEDIA_PREVIOUS},
* {@link TransportMediator#FLAG_KEY_MEDIA_REWIND},
* {@link TransportMediator#FLAG_KEY_MEDIA_PLAY},
* {@link TransportMediator#FLAG_KEY_MEDIA_PLAY_PAUSE},
* {@link TransportMediator#FLAG_KEY_MEDIA_PAUSE},
* {@link TransportMediator#FLAG_KEY_MEDIA_STOP},
* {@link TransportMediator#FLAG_KEY_MEDIA_FAST_FORWARD},
* {@link TransportMediator#FLAG_KEY_MEDIA_NEXT}
*
* <p>The default implementation returns:
* {@link TransportMediator#FLAG_KEY_MEDIA_PLAY},
* {@link TransportMediator#FLAG_KEY_MEDIA_PLAY_PAUSE},
* {@link TransportMediator#FLAG_KEY_MEDIA_PAUSE}, and
* {@link TransportMediator#FLAG_KEY_MEDIA_STOP}</p>
*/
public int onGetTransportControlFlags() {
return TransportMediator.FLAG_KEY_MEDIA_PLAY
| TransportMediator.FLAG_KEY_MEDIA_PLAY_PAUSE
| TransportMediator.FLAG_KEY_MEDIA_PAUSE
| TransportMediator.FLAG_KEY_MEDIA_STOP;
}
/**
* Report that a media button has been pressed. This is like
* {@link android.view.KeyEvent.Callback#onKeyDown(int, android.view.KeyEvent)} but
* will only deliver media keys. The default implementation handles these keys:
* <ul>
* <li>KEYCODE_MEDIA_PLAY: call {@link #onStart}</li>
* <li>KEYCODE_MEDIA_PAUSE: call {@link #onPause}</li>
* <li>KEYCODE_MEDIA_STOP: call {@link #onStop}</li>
* <li>KEYCODE_MEDIA_PLAY_PAUSE and KEYCODE_HEADSETHOOK: call {@link #onPause}
* if {@link #onIsPlaying()} returns true, otherwise call {@link #onStart}</li>
* </ul>
* @param keyCode The code of the media key.
* @param event The full key event.
* @return Indicate whether the key has been consumed. The default
* implementation always returns true. This only matters for keys
* being dispatched here from
* {@link TransportMediator#dispatchKeyEvent(android.view.KeyEvent)
* TransportController.dispatchKeyEvent}, and determines whether the key
* continues on to its default key handling (which for media keys means
* being delivered to the current media remote control, which should
* be us).
*/
public boolean onMediaButtonDown(int keyCode, KeyEvent event) {
switch (keyCode) {
case TransportMediator.KEYCODE_MEDIA_PLAY:
onStart();
return true;
case TransportMediator.KEYCODE_MEDIA_PAUSE:
onPause();
return true;
case KeyEvent.KEYCODE_MEDIA_STOP:
onStop();
return true;
case KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE:
case KeyEvent.KEYCODE_HEADSETHOOK:
if (onIsPlaying()) {
onPause();
} else {
onStart();
}
}
return true;
}
/**
* Report that a media button has been released. This is like
* {@link KeyEvent.Callback#onKeyUp(int, android.view.KeyEvent)} but
* will only deliver media keys. The default implementation does nothing.
* @param keyCode The code of the media key.
* @param event The full key event.
* @return Indicate whether the key has been consumed. The default
* implementation always returns true. This only matters for keys
* being dispatched here from
* {@link TransportMediator#dispatchKeyEvent(android.view.KeyEvent)
* TransportController.dispatchKeyEvent}, and determines whether the key
* continues on to its default key handling (which for media keys means
* being delivered to the current media remote control, which should
* be us).
*/
public boolean onMediaButtonUp(int keyCode, KeyEvent event) {
return true;
}
// Copy constants from framework since we can't link to them.
static final int AUDIOFOCUS_GAIN = 1;
static final int AUDIOFOCUS_GAIN_TRANSIENT = 2;
static final int AUDIOFOCUS_GAIN_TRANSIENT_MAY_DUCK = 3;
static final int AUDIOFOCUS_LOSS = -1 * AUDIOFOCUS_GAIN;
static final int AUDIOFOCUS_LOSS_TRANSIENT = -1 * AUDIOFOCUS_GAIN_TRANSIENT;
static final int AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK =
-1 * AUDIOFOCUS_GAIN_TRANSIENT_MAY_DUCK;
/**
* Report that audio focus has changed on the app. This only happens if
* you have indicated you have started playing with
* {@link TransportMediator#startPlaying TransportController.startPlaying},
* which takes audio focus for you.
* @param focusChange The type of focus change, as per
* {@link android.media.AudioManager.OnAudioFocusChangeListener#onAudioFocusChange(int)
* OnAudioFocusChangeListener.onAudioFocusChange}. The default implementation will
* deliver a {@link KeyEvent#KEYCODE_MEDIA_STOP}
* when receiving {@link android.media.AudioManager#AUDIOFOCUS_LOSS}.
*/
public void onAudioFocusChange(int focusChange) {
int keyCode = 0;
switch (focusChange) {
case AUDIOFOCUS_LOSS:
// This will cause us to stop playback, which means we drop audio focus
// so we will not get any further audio focus gain.
keyCode = TransportMediator.KEYCODE_MEDIA_PAUSE;
break;
}
if (keyCode != 0) {
final long now = SystemClock.uptimeMillis();
onMediaButtonDown(keyCode, new KeyEvent(now, now, KeyEvent.ACTION_DOWN, keyCode, 0));
onMediaButtonUp(keyCode, new KeyEvent(now, now, KeyEvent.ACTION_UP, keyCode, 0));
}
}
}
|
