blob: b2ebfa934178700cebe51ee09a1c7ec9645bb356 [file] [log] [blame]
/*
* Copyright (C) 2016 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.annotation.IntDef;
import android.annotation.NonNull;
import android.annotation.SystemApi;
import android.os.Binder;
import android.os.IBinder;
import android.os.Parcel;
import android.os.Parcelable;
import android.os.RemoteException;
import android.util.Log;
import java.io.PrintWriter;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.util.Objects;
/**
* The AudioPlaybackConfiguration class collects the information describing an audio playback
* session.
*/
public final class AudioPlaybackConfiguration implements Parcelable {
private static final String TAG = new String("AudioPlaybackConfiguration");
private static final boolean DEBUG = false;
/** @hide */
public static final int PLAYER_PIID_INVALID = -1;
/** @hide */
public static final int PLAYER_UPID_INVALID = -1;
// information about the implementation
/**
* @hide
* An unknown type of player
*/
@SystemApi
public static final int PLAYER_TYPE_UNKNOWN = -1;
/**
* @hide
* Player backed by a java android.media.AudioTrack player
*/
@SystemApi
public static final int PLAYER_TYPE_JAM_AUDIOTRACK = 1;
/**
* @hide
* Player backed by a java android.media.MediaPlayer player
*/
@SystemApi
public static final int PLAYER_TYPE_JAM_MEDIAPLAYER = 2;
/**
* @hide
* Player backed by a java android.media.SoundPool player
*/
@SystemApi
public static final int PLAYER_TYPE_JAM_SOUNDPOOL = 3;
/**
* @hide
* Player backed by a C OpenSL ES AudioPlayer player with a BufferQueue source
*/
@SystemApi
public static final int PLAYER_TYPE_SLES_AUDIOPLAYER_BUFFERQUEUE = 11;
/**
* @hide
* Player backed by a C OpenSL ES AudioPlayer player with a URI or FD source
*/
@SystemApi
public static final int PLAYER_TYPE_SLES_AUDIOPLAYER_URI_FD = 12;
/**
* @hide
* Player backed an AAudio player.
* Note this type is not in System API so it will not be returned in public API calls
*/
// TODO unhide for SystemApi, update getPlayerType()
public static final int PLAYER_TYPE_AAUDIO = 13;
/**
* @hide
* Player backed a hardware source, whose state is visible in the Android audio policy manager.
* Note this type is not in System API so it will not be returned in public API calls
*/
// TODO unhide for SystemApi, update getPlayerType()
public static final int PLAYER_TYPE_HW_SOURCE = 14;
/**
* @hide
* Player is a proxy for an audio player whose audio and state doesn't go through the Android
* audio framework.
* Note this type is not in System API so it will not be returned in public API calls
*/
// TODO unhide for SystemApi, update getPlayerType()
public static final int PLAYER_TYPE_EXTERNAL_PROXY = 15;
/** @hide */
@IntDef({
PLAYER_TYPE_UNKNOWN,
PLAYER_TYPE_JAM_AUDIOTRACK,
PLAYER_TYPE_JAM_MEDIAPLAYER,
PLAYER_TYPE_JAM_SOUNDPOOL,
PLAYER_TYPE_SLES_AUDIOPLAYER_BUFFERQUEUE,
PLAYER_TYPE_SLES_AUDIOPLAYER_URI_FD,
})
@Retention(RetentionPolicy.SOURCE)
public @interface PlayerType {}
/**
* @hide
* An unknown player state
*/
@SystemApi
public static final int PLAYER_STATE_UNKNOWN = -1;
/**
* @hide
* The resources of the player have been released, it cannot play anymore
*/
@SystemApi
public static final int PLAYER_STATE_RELEASED = 0;
/**
* @hide
* The state of a player when it's created
*/
@SystemApi
public static final int PLAYER_STATE_IDLE = 1;
/**
* @hide
* The state of a player that is actively playing
*/
@SystemApi
public static final int PLAYER_STATE_STARTED = 2;
/**
* @hide
* The state of a player where playback is paused
*/
@SystemApi
public static final int PLAYER_STATE_PAUSED = 3;
/**
* @hide
* The state of a player where playback is stopped
*/
@SystemApi
public static final int PLAYER_STATE_STOPPED = 4;
/** @hide */
@IntDef({
PLAYER_STATE_UNKNOWN,
PLAYER_STATE_RELEASED,
PLAYER_STATE_IDLE,
PLAYER_STATE_STARTED,
PLAYER_STATE_PAUSED,
PLAYER_STATE_STOPPED
})
@Retention(RetentionPolicy.SOURCE)
public @interface PlayerState {}
// immutable data
private final int mPlayerIId;
// not final due to anonymization step
private int mPlayerType;
private int mClientUid;
private int mClientPid;
// the IPlayer reference and death monitor
private IPlayerShell mIPlayerShell;
private int mPlayerState;
private AudioAttributes mPlayerAttr; // never null
/**
* Never use without initializing parameters afterwards
*/
private AudioPlaybackConfiguration(int piid) {
mPlayerIId = piid;
mIPlayerShell = null;
}
/**
* @hide
*/
public AudioPlaybackConfiguration(PlayerBase.PlayerIdCard pic, int piid, int uid, int pid) {
if (DEBUG) { Log.d(TAG, "new: piid=" + piid + " iplayer=" + pic.mIPlayer); }
mPlayerIId = piid;
mPlayerType = pic.mPlayerType;
mClientUid = uid;
mClientPid = pid;
mPlayerState = PLAYER_STATE_IDLE;
mPlayerAttr = pic.mAttributes;
if ((sPlayerDeathMonitor != null) && (pic.mIPlayer != null)) {
mIPlayerShell = new IPlayerShell(this, pic.mIPlayer);
} else {
mIPlayerShell = null;
}
}
/**
* @hide
*/
public void init() {
synchronized (this) {
if (mIPlayerShell != null) {
mIPlayerShell.monitorDeath();
}
}
}
// Note that this method is called server side, so no "privileged" information is ever sent
// to a client that is not supposed to have access to it.
/**
* @hide
* Creates a copy of the playback configuration that is stripped of any data enabling
* identification of which application it is associated with ("anonymized").
* @param toSanitize
*/
public static AudioPlaybackConfiguration anonymizedCopy(AudioPlaybackConfiguration in) {
final AudioPlaybackConfiguration anonymCopy = new AudioPlaybackConfiguration(in.mPlayerIId);
anonymCopy.mPlayerState = in.mPlayerState;
// do not reuse the full attributes: only usage, content type and public flags are allowed
anonymCopy.mPlayerAttr = new AudioAttributes.Builder()
.setUsage(in.mPlayerAttr.getUsage())
.setContentType(in.mPlayerAttr.getContentType())
.setFlags(in.mPlayerAttr.getFlags())
.build();
// anonymized data
anonymCopy.mPlayerType = PLAYER_TYPE_UNKNOWN;
anonymCopy.mClientUid = PLAYER_UPID_INVALID;
anonymCopy.mClientPid = PLAYER_UPID_INVALID;
anonymCopy.mIPlayerShell = null;
return anonymCopy;
}
/**
* Return the {@link AudioAttributes} of the corresponding player.
* @return the audio attributes of the player
*/
public AudioAttributes getAudioAttributes() {
return mPlayerAttr;
}
/**
* @hide
* Return the uid of the client application that created this player.
* @return the uid of the client
*/
@SystemApi
public int getClientUid() {
return mClientUid;
}
/**
* @hide
* Return the pid of the client application that created this player.
* @return the pid of the client
*/
@SystemApi
public int getClientPid() {
return mClientPid;
}
/**
* @hide
* Return the type of player linked to this configuration. The return value is one of
* {@link #PLAYER_TYPE_JAM_AUDIOTRACK}, {@link #PLAYER_TYPE_JAM_MEDIAPLAYER},
* {@link #PLAYER_TYPE_JAM_SOUNDPOOL}, {@link #PLAYER_TYPE_SLES_AUDIOPLAYER_BUFFERQUEUE},
* {@link #PLAYER_TYPE_SLES_AUDIOPLAYER_URI_FD}, or {@link #PLAYER_TYPE_UNKNOWN}.
* <br>Note that player types not exposed in the system API will be represented as
* {@link #PLAYER_TYPE_UNKNOWN}.
* @return the type of the player.
*/
@SystemApi
public @PlayerType int getPlayerType() {
switch (mPlayerType) {
case PLAYER_TYPE_AAUDIO:
case PLAYER_TYPE_HW_SOURCE:
case PLAYER_TYPE_EXTERNAL_PROXY:
return PLAYER_TYPE_UNKNOWN;
default:
return mPlayerType;
}
}
/**
* @hide
* Return the current state of the player linked to this configuration. The return value is one
* of {@link #PLAYER_STATE_IDLE}, {@link #PLAYER_STATE_PAUSED}, {@link #PLAYER_STATE_STARTED},
* {@link #PLAYER_STATE_STOPPED}, {@link #PLAYER_STATE_RELEASED} or
* {@link #PLAYER_STATE_UNKNOWN}.
* @return the state of the player.
*/
@SystemApi
public @PlayerState int getPlayerState() {
return mPlayerState;
}
/**
* @hide
* Return an identifier unique for the lifetime of the player.
* @return a player interface identifier
*/
@SystemApi
public int getPlayerInterfaceId() {
return mPlayerIId;
}
/**
* @hide
* Return a proxy for the player associated with this playback configuration
* @return a proxy player
*/
@SystemApi
public PlayerProxy getPlayerProxy() {
final IPlayerShell ips;
synchronized (this) {
ips = mIPlayerShell;
}
return ips == null ? null : new PlayerProxy(this);
}
/**
* @hide
* @return the IPlayer interface for the associated player
*/
IPlayer getIPlayer() {
final IPlayerShell ips;
synchronized (this) {
ips = mIPlayerShell;
}
return ips == null ? null : ips.getIPlayer();
}
/**
* @hide
* Handle a change of audio attributes
* @param attr
*/
public boolean handleAudioAttributesEvent(@NonNull AudioAttributes attr) {
final boolean changed = !attr.equals(mPlayerAttr);
mPlayerAttr = attr;
return changed;
}
/**
* @hide
* Handle a player state change
* @param event
* @return true if the state changed, false otherwise
*/
public boolean handleStateEvent(int event) {
final boolean changed;
synchronized (this) {
changed = (mPlayerState != event);
mPlayerState = event;
if (changed && (event == PLAYER_STATE_RELEASED) && (mIPlayerShell != null)) {
mIPlayerShell.release();
mIPlayerShell = null;
}
}
return changed;
}
// To report IPlayer death from death recipient
/** @hide */
public interface PlayerDeathMonitor {
public void playerDeath(int piid);
}
/** @hide */
public static PlayerDeathMonitor sPlayerDeathMonitor;
private void playerDied() {
if (sPlayerDeathMonitor != null) {
sPlayerDeathMonitor.playerDeath(mPlayerIId);
}
}
/**
* @hide
* Returns true if the player is considered "active", i.e. actively playing, and thus
* in a state that should make it considered for the list public (sanitized) active playback
* configurations
* @return true if active
*/
public boolean isActive() {
switch (mPlayerState) {
case PLAYER_STATE_STARTED:
return true;
case PLAYER_STATE_UNKNOWN:
case PLAYER_STATE_RELEASED:
case PLAYER_STATE_IDLE:
case PLAYER_STATE_PAUSED:
case PLAYER_STATE_STOPPED:
default:
return false;
}
}
/**
* @hide
* For AudioService dump
* @param pw
*/
public void dump(PrintWriter pw) {
pw.println(" " + toLogFriendlyString(this));
}
/**
* @hide
*/
public static String toLogFriendlyString(AudioPlaybackConfiguration apc) {
return new String("ID:" + apc.mPlayerIId
+ " -- type:" + toLogFriendlyPlayerType(apc.mPlayerType)
+ " -- u/pid:" + apc.mClientUid +"/" + apc.mClientPid
+ " -- state:" + toLogFriendlyPlayerState(apc.mPlayerState)
+ " -- attr:" + apc.mPlayerAttr);
}
public static final @android.annotation.NonNull Parcelable.Creator<AudioPlaybackConfiguration> CREATOR
= new Parcelable.Creator<AudioPlaybackConfiguration>() {
/**
* Rebuilds an AudioPlaybackConfiguration previously stored with writeToParcel().
* @param p Parcel object to read the AudioPlaybackConfiguration from
* @return a new AudioPlaybackConfiguration created from the data in the parcel
*/
public AudioPlaybackConfiguration createFromParcel(Parcel p) {
return new AudioPlaybackConfiguration(p);
}
public AudioPlaybackConfiguration[] newArray(int size) {
return new AudioPlaybackConfiguration[size];
}
};
@Override
public int hashCode() {
return Objects.hash(mPlayerIId, mPlayerType, mClientUid, mClientPid);
}
@Override
public int describeContents() {
return 0;
}
@Override
public void writeToParcel(Parcel dest, int flags) {
dest.writeInt(mPlayerIId);
dest.writeInt(mPlayerType);
dest.writeInt(mClientUid);
dest.writeInt(mClientPid);
dest.writeInt(mPlayerState);
mPlayerAttr.writeToParcel(dest, 0);
final IPlayerShell ips;
synchronized (this) {
ips = mIPlayerShell;
}
dest.writeStrongInterface(ips == null ? null : ips.getIPlayer());
}
private AudioPlaybackConfiguration(Parcel in) {
mPlayerIId = in.readInt();
mPlayerType = in.readInt();
mClientUid = in.readInt();
mClientPid = in.readInt();
mPlayerState = in.readInt();
mPlayerAttr = AudioAttributes.CREATOR.createFromParcel(in);
final IPlayer p = IPlayer.Stub.asInterface(in.readStrongBinder());
mIPlayerShell = (p == null) ? null : new IPlayerShell(null, p);
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || !(o instanceof AudioPlaybackConfiguration)) return false;
AudioPlaybackConfiguration that = (AudioPlaybackConfiguration) o;
return ((mPlayerIId == that.mPlayerIId)
&& (mPlayerType == that.mPlayerType)
&& (mClientUid == that.mClientUid)
&& (mClientPid == that.mClientPid));
}
//=====================================================================
// Inner class for corresponding IPlayer and its death monitoring
static final class IPlayerShell implements IBinder.DeathRecipient {
final AudioPlaybackConfiguration mMonitor; // never null
private volatile IPlayer mIPlayer;
IPlayerShell(@NonNull AudioPlaybackConfiguration monitor, @NonNull IPlayer iplayer) {
mMonitor = monitor;
mIPlayer = iplayer;
}
synchronized void monitorDeath() {
if (mIPlayer == null) {
return;
}
try {
mIPlayer.asBinder().linkToDeath(this, 0);
} catch (RemoteException e) {
if (mMonitor != null) {
Log.w(TAG, "Could not link to client death for piid=" + mMonitor.mPlayerIId, e);
} else {
Log.w(TAG, "Could not link to client death", e);
}
}
}
IPlayer getIPlayer() {
return mIPlayer;
}
public void binderDied() {
if (mMonitor != null) {
if (DEBUG) { Log.i(TAG, "IPlayerShell binderDied for piid=" + mMonitor.mPlayerIId);}
mMonitor.playerDied();
} else if (DEBUG) { Log.i(TAG, "IPlayerShell binderDied"); }
}
synchronized void release() {
if (mIPlayer == null) {
return;
}
mIPlayer.asBinder().unlinkToDeath(this, 0);
mIPlayer = null;
Binder.flushPendingCommands();
}
}
//=====================================================================
// Utilities
/** @hide */
public static String toLogFriendlyPlayerType(int type) {
switch (type) {
case PLAYER_TYPE_UNKNOWN: return "unknown";
case PLAYER_TYPE_JAM_AUDIOTRACK: return "android.media.AudioTrack";
case PLAYER_TYPE_JAM_MEDIAPLAYER: return "android.media.MediaPlayer";
case PLAYER_TYPE_JAM_SOUNDPOOL: return "android.media.SoundPool";
case PLAYER_TYPE_SLES_AUDIOPLAYER_BUFFERQUEUE:
return "OpenSL ES AudioPlayer (Buffer Queue)";
case PLAYER_TYPE_SLES_AUDIOPLAYER_URI_FD:
return "OpenSL ES AudioPlayer (URI/FD)";
case PLAYER_TYPE_AAUDIO: return "AAudio";
case PLAYER_TYPE_HW_SOURCE: return "hardware source";
case PLAYER_TYPE_EXTERNAL_PROXY: return "external proxy";
default:
return "unknown player type " + type + " - FIXME";
}
}
/** @hide */
public static String toLogFriendlyPlayerState(int state) {
switch (state) {
case PLAYER_STATE_UNKNOWN: return "unknown";
case PLAYER_STATE_RELEASED: return "released";
case PLAYER_STATE_IDLE: return "idle";
case PLAYER_STATE_STARTED: return "started";
case PLAYER_STATE_PAUSED: return "paused";
case PLAYER_STATE_STOPPED: return "stopped";
default:
return "unknown player state - FIXME";
}
}
}