android.media.AudioPort Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of android-all Show documentation
Show all versions of android-all Show documentation
A library jar that provides APIs for Applications written for the Google Android Platform.
/*
* Copyright (C) 2014 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;
/**
* An audio port is a node of the audio framework or hardware that can be connected to or
* disconnect from another audio node to create a specific audio routing configuration.
* Examples of audio ports are an output device (speaker) or an output mix (see AudioMixPort).
* All attributes that are relevant for applications to make routing selection are decribed
* in an AudioPort, in particular:
* - possible channel mask configurations.
* - audio format (PCM 16bit, PCM 24bit...)
* - gain: a port can be associated with one or more gain controllers (see AudioGain).
*
* This object is always created by the framework and read only by applications.
* A list of all audio port descriptors currently available for applications to control
* is obtained by AudioManager.listAudioPorts().
* An application can obtain an AudioPortConfig for a valid configuration of this port
* by calling AudioPort.buildConfig() and use this configuration
* to create a connection between audio sinks and sources with AudioManager.connectAudioPatch()
*
* @hide
*/
public class AudioPort {
private static final String TAG = "AudioPort";
/**
* For use by the audio framework.
*/
public static final int ROLE_NONE = 0;
/**
* The audio port is a source (produces audio)
*/
public static final int ROLE_SOURCE = 1;
/**
* The audio port is a sink (consumes audio)
*/
public static final int ROLE_SINK = 2;
/**
* audio port type for use by audio framework implementation
*/
public static final int TYPE_NONE = 0;
/**
*/
public static final int TYPE_DEVICE = 1;
/**
*/
public static final int TYPE_SUBMIX = 2;
/**
*/
public static final int TYPE_SESSION = 3;
AudioHandle mHandle;
protected final int mRole;
private final String mName;
private final int[] mSamplingRates;
private final int[] mChannelMasks;
private final int[] mChannelIndexMasks;
private final int[] mFormats;
private final AudioGain[] mGains;
private AudioPortConfig mActiveConfig;
AudioPort(AudioHandle handle, int role, String name,
int[] samplingRates, int[] channelMasks, int[] channelIndexMasks,
int[] formats, AudioGain[] gains) {
mHandle = handle;
mRole = role;
mName = name;
mSamplingRates = samplingRates;
mChannelMasks = channelMasks;
mChannelIndexMasks = channelIndexMasks;
mFormats = formats;
mGains = gains;
}
AudioHandle handle() {
return mHandle;
}
/**
* Get the system unique device ID.
*/
public int id() {
return mHandle.id();
}
/**
* Get the audio port role
*/
public int role() {
return mRole;
}
/**
* Get the human-readable name of this port. Perhaps an internal
* designation or an physical device.
*/
public String name() {
return mName;
}
/**
* Get the list of supported sampling rates
* Empty array if sampling rate is not relevant for this audio port
*/
public int[] samplingRates() {
return mSamplingRates;
}
/**
* Get the list of supported channel mask configurations
* (e.g AudioFormat.CHANNEL_OUT_STEREO)
* Empty array if channel mask is not relevant for this audio port
*/
public int[] channelMasks() {
return mChannelMasks;
}
/**
* Get the list of supported channel index mask configurations
* (e.g 0x0003 means 2 channel, 0x000F means 4 channel....)
* Empty array if channel index mask is not relevant for this audio port
*/
public int[] channelIndexMasks() {
return mChannelIndexMasks;
}
/**
* Get the list of supported audio format configurations
* (e.g AudioFormat.ENCODING_PCM_16BIT)
* Empty array if format is not relevant for this audio port
*/
public int[] formats() {
return mFormats;
}
/**
* Get the list of gain descriptors
* Empty array if this port does not have gain control
*/
public AudioGain[] gains() {
return mGains;
}
/**
* Get the gain descriptor at a given index
*/
AudioGain gain(int index) {
if (index < 0 || index >= mGains.length) {
return null;
}
return mGains[index];
}
/**
* Build a specific configuration of this audio port for use by methods
* like AudioManager.connectAudioPatch().
* @param channelMask The desired channel mask. AudioFormat.CHANNEL_OUT_DEFAULT if no change
* from active configuration requested.
* @param format The desired audio format. AudioFormat.ENCODING_DEFAULT if no change
* from active configuration requested.
* @param gain The desired gain. null if no gain changed requested.
*/
public AudioPortConfig buildConfig(int samplingRate, int channelMask, int format,
AudioGainConfig gain) {
return new AudioPortConfig(this, samplingRate, channelMask, format, gain);
}
/**
* Get currently active configuration of this audio port.
*/
public AudioPortConfig activeConfig() {
return mActiveConfig;
}
@Override
public boolean equals(Object o) {
if (o == null || !(o instanceof AudioPort)) {
return false;
}
AudioPort ap = (AudioPort)o;
return mHandle.equals(ap.handle());
}
@Override
public int hashCode() {
return mHandle.hashCode();
}
@Override
public String toString() {
String role = Integer.toString(mRole);
switch (mRole) {
case ROLE_NONE:
role = "NONE";
break;
case ROLE_SOURCE:
role = "SOURCE";
break;
case ROLE_SINK:
role = "SINK";
break;
}
return "{mHandle: " + mHandle
+ ", mRole: " + role
+ "}";
}
}