757 lines
31 KiB
Java
757 lines
31 KiB
Java
/*
|
|
* 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;
|
|
|
|
import android.Manifest;
|
|
import android.annotation.IntDef;
|
|
import android.annotation.NonNull;
|
|
import android.annotation.RequiresPermission;
|
|
import android.annotation.TestApi;
|
|
import android.util.SparseIntArray;
|
|
|
|
import com.android.internal.annotations.VisibleForTesting;
|
|
|
|
import java.lang.annotation.Retention;
|
|
import java.lang.annotation.RetentionPolicy;
|
|
import java.util.List;
|
|
import java.util.Objects;
|
|
import java.util.TreeSet;
|
|
|
|
/**
|
|
* Provides information about an audio device.
|
|
*/
|
|
public final class AudioDeviceInfo {
|
|
|
|
/**
|
|
* A device type associated with an unknown or uninitialized device.
|
|
*/
|
|
public static final int TYPE_UNKNOWN = 0;
|
|
/**
|
|
* A device type describing the attached earphone speaker.
|
|
*/
|
|
public static final int TYPE_BUILTIN_EARPIECE = 1;
|
|
/**
|
|
* A device type describing the speaker system (i.e. a mono speaker or stereo speakers) built
|
|
* in a device.
|
|
*/
|
|
public static final int TYPE_BUILTIN_SPEAKER = 2;
|
|
/**
|
|
* A device type describing a headset, which is the combination of a headphones and microphone.
|
|
*/
|
|
public static final int TYPE_WIRED_HEADSET = 3;
|
|
/**
|
|
* A device type describing a pair of wired headphones.
|
|
*/
|
|
public static final int TYPE_WIRED_HEADPHONES = 4;
|
|
/**
|
|
* A device type describing an analog line-level connection.
|
|
*/
|
|
public static final int TYPE_LINE_ANALOG = 5;
|
|
/**
|
|
* A device type describing a digital line connection (e.g. SPDIF).
|
|
*/
|
|
public static final int TYPE_LINE_DIGITAL = 6;
|
|
/**
|
|
* A device type describing a Bluetooth device typically used for telephony.
|
|
*/
|
|
public static final int TYPE_BLUETOOTH_SCO = 7;
|
|
/**
|
|
* A device type describing a Bluetooth device supporting the A2DP profile.
|
|
*/
|
|
public static final int TYPE_BLUETOOTH_A2DP = 8;
|
|
/**
|
|
* A device type describing an HDMI connection .
|
|
*/
|
|
public static final int TYPE_HDMI = 9;
|
|
/**
|
|
* A device type describing the Audio Return Channel of an HDMI connection.
|
|
*/
|
|
public static final int TYPE_HDMI_ARC = 10;
|
|
/**
|
|
* A device type describing a USB audio device.
|
|
*/
|
|
public static final int TYPE_USB_DEVICE = 11;
|
|
/**
|
|
* A device type describing a USB audio device in accessory mode.
|
|
*/
|
|
public static final int TYPE_USB_ACCESSORY = 12;
|
|
/**
|
|
* A device type describing the audio device associated with a dock.
|
|
* Starting at API 34, this device type only represents digital docks, while docks with an
|
|
* analog connection are represented with {@link #TYPE_DOCK_ANALOG}.
|
|
* @see #TYPE_DOCK_ANALOG
|
|
*/
|
|
public static final int TYPE_DOCK = 13;
|
|
/**
|
|
* A device type associated with the transmission of audio signals over FM.
|
|
*/
|
|
public static final int TYPE_FM = 14;
|
|
/**
|
|
* A device type describing the microphone(s) built in a device.
|
|
*/
|
|
public static final int TYPE_BUILTIN_MIC = 15;
|
|
/**
|
|
* A device type for accessing the audio content transmitted over FM.
|
|
*/
|
|
public static final int TYPE_FM_TUNER = 16;
|
|
/**
|
|
* A device type for accessing the audio content transmitted over the TV tuner system.
|
|
*/
|
|
public static final int TYPE_TV_TUNER = 17;
|
|
/**
|
|
* A device type describing the transmission of audio signals over the telephony network.
|
|
*/
|
|
public static final int TYPE_TELEPHONY = 18;
|
|
/**
|
|
* A device type describing the auxiliary line-level connectors.
|
|
*/
|
|
public static final int TYPE_AUX_LINE = 19;
|
|
/**
|
|
* A device type connected over IP.
|
|
*/
|
|
public static final int TYPE_IP = 20;
|
|
/**
|
|
* A type-agnostic device used for communication with external audio systems
|
|
*/
|
|
public static final int TYPE_BUS = 21;
|
|
/**
|
|
* A device type describing a USB audio headset.
|
|
*/
|
|
public static final int TYPE_USB_HEADSET = 22;
|
|
/**
|
|
* A device type describing a Hearing Aid.
|
|
*/
|
|
public static final int TYPE_HEARING_AID = 23;
|
|
/**
|
|
* A device type describing the speaker system (i.e. a mono speaker or stereo speakers) built
|
|
* in a device, that is specifically tuned for outputting sounds like notifications and alarms
|
|
* (i.e. sounds the user couldn't necessarily anticipate).
|
|
* <p>Note that this physical audio device may be the same as {@link #TYPE_BUILTIN_SPEAKER}
|
|
* but is driven differently to safely accommodate the different use case.</p>
|
|
*/
|
|
public static final int TYPE_BUILTIN_SPEAKER_SAFE = 24;
|
|
/**
|
|
* A device type for rerouting audio within the Android framework between mixes and
|
|
* system applications.
|
|
* This type is for instance encountered when querying the output device of a track
|
|
* (with {@link AudioTrack#getRoutedDevice()} playing from a device in screen mirroring mode,
|
|
* where the audio is not heard on the device, but on the remote device.
|
|
*/
|
|
// Typically created when using
|
|
// {@link android.media.audiopolicy.AudioPolicy} for mixes created with the
|
|
// {@link android.media.audiopolicy.AudioMix#ROUTE_FLAG_LOOP_BACK} flag.
|
|
public static final int TYPE_REMOTE_SUBMIX = 25;
|
|
|
|
/**
|
|
* A device type describing a Bluetooth Low Energy (BLE) audio headset or headphones.
|
|
* Headphones are grouped with headsets when the device is a sink:
|
|
* the features of headsets and headphones with regard to playback are the same.
|
|
*/
|
|
public static final int TYPE_BLE_HEADSET = 26;
|
|
|
|
/**
|
|
* A device type describing a Bluetooth Low Energy (BLE) audio speaker.
|
|
*/
|
|
public static final int TYPE_BLE_SPEAKER = 27;
|
|
|
|
/**
|
|
* A device type describing an Echo Canceller loopback Reference.
|
|
* This device is only used when capturing with MediaRecorder.AudioSource.ECHO_REFERENCE,
|
|
* which requires privileged permission
|
|
* {@link android.Manifest.permission#CAPTURE_AUDIO_OUTPUT}.
|
|
* @hide */
|
|
@RequiresPermission(Manifest.permission.CAPTURE_AUDIO_OUTPUT)
|
|
public static final int TYPE_ECHO_REFERENCE = 28;
|
|
|
|
/**
|
|
* A device type describing the Enhanced Audio Return Channel of an HDMI connection.
|
|
*/
|
|
public static final int TYPE_HDMI_EARC = 29;
|
|
|
|
/**
|
|
* A device type describing a Bluetooth Low Energy (BLE) broadcast group.
|
|
*/
|
|
public static final int TYPE_BLE_BROADCAST = 30;
|
|
|
|
/**
|
|
* A device type describing the audio device associated with a dock using an analog connection.
|
|
*/
|
|
public static final int TYPE_DOCK_ANALOG = 31;
|
|
|
|
/** @hide */
|
|
@IntDef(flag = false, prefix = "TYPE", value = {
|
|
TYPE_BUILTIN_EARPIECE,
|
|
TYPE_BUILTIN_SPEAKER,
|
|
TYPE_WIRED_HEADSET,
|
|
TYPE_WIRED_HEADPHONES,
|
|
TYPE_BLUETOOTH_SCO,
|
|
TYPE_BLUETOOTH_A2DP,
|
|
TYPE_HDMI,
|
|
TYPE_DOCK,
|
|
TYPE_USB_ACCESSORY,
|
|
TYPE_USB_DEVICE,
|
|
TYPE_USB_HEADSET,
|
|
TYPE_TELEPHONY,
|
|
TYPE_LINE_ANALOG,
|
|
TYPE_HDMI_ARC,
|
|
TYPE_HDMI_EARC,
|
|
TYPE_LINE_DIGITAL,
|
|
TYPE_FM,
|
|
TYPE_AUX_LINE,
|
|
TYPE_IP,
|
|
TYPE_BUS,
|
|
TYPE_HEARING_AID,
|
|
TYPE_BUILTIN_MIC,
|
|
TYPE_FM_TUNER,
|
|
TYPE_TV_TUNER,
|
|
TYPE_BUILTIN_SPEAKER_SAFE,
|
|
TYPE_REMOTE_SUBMIX,
|
|
TYPE_BLE_HEADSET,
|
|
TYPE_BLE_SPEAKER,
|
|
TYPE_ECHO_REFERENCE,
|
|
TYPE_BLE_BROADCAST,
|
|
TYPE_DOCK_ANALOG}
|
|
)
|
|
@Retention(RetentionPolicy.SOURCE)
|
|
public @interface AudioDeviceType {}
|
|
|
|
/** @hide */
|
|
@IntDef(flag = false, prefix = "TYPE", value = {
|
|
TYPE_BUILTIN_MIC,
|
|
TYPE_BLUETOOTH_SCO,
|
|
TYPE_BLUETOOTH_A2DP,
|
|
TYPE_WIRED_HEADSET,
|
|
TYPE_HDMI,
|
|
TYPE_TELEPHONY,
|
|
TYPE_DOCK,
|
|
TYPE_USB_ACCESSORY,
|
|
TYPE_USB_DEVICE,
|
|
TYPE_USB_HEADSET,
|
|
TYPE_FM_TUNER,
|
|
TYPE_TV_TUNER,
|
|
TYPE_LINE_ANALOG,
|
|
TYPE_LINE_DIGITAL,
|
|
TYPE_IP,
|
|
TYPE_BUS,
|
|
TYPE_REMOTE_SUBMIX,
|
|
TYPE_BLE_HEADSET,
|
|
TYPE_HDMI_ARC,
|
|
TYPE_HDMI_EARC,
|
|
TYPE_ECHO_REFERENCE,
|
|
TYPE_DOCK_ANALOG}
|
|
)
|
|
@Retention(RetentionPolicy.SOURCE)
|
|
public @interface AudioDeviceTypeIn {}
|
|
|
|
/** @hide */
|
|
@IntDef(flag = false, prefix = "TYPE", value = {
|
|
TYPE_BUILTIN_EARPIECE,
|
|
TYPE_BUILTIN_SPEAKER,
|
|
TYPE_WIRED_HEADSET,
|
|
TYPE_WIRED_HEADPHONES,
|
|
TYPE_BLUETOOTH_SCO,
|
|
TYPE_BLUETOOTH_A2DP,
|
|
TYPE_HDMI,
|
|
TYPE_DOCK,
|
|
TYPE_USB_ACCESSORY,
|
|
TYPE_USB_DEVICE,
|
|
TYPE_USB_HEADSET,
|
|
TYPE_TELEPHONY,
|
|
TYPE_LINE_ANALOG,
|
|
TYPE_HDMI_ARC,
|
|
TYPE_HDMI_EARC,
|
|
TYPE_LINE_DIGITAL,
|
|
TYPE_FM,
|
|
TYPE_AUX_LINE,
|
|
TYPE_IP,
|
|
TYPE_BUS,
|
|
TYPE_HEARING_AID,
|
|
TYPE_BUILTIN_SPEAKER_SAFE,
|
|
TYPE_BLE_HEADSET,
|
|
TYPE_BLE_SPEAKER,
|
|
TYPE_BLE_BROADCAST,
|
|
TYPE_DOCK_ANALOG}
|
|
)
|
|
@Retention(RetentionPolicy.SOURCE)
|
|
public @interface AudioDeviceTypeOut {}
|
|
|
|
/** @hide */
|
|
/*package*/ static boolean isValidAudioDeviceTypeOut(int type) {
|
|
switch (type) {
|
|
case TYPE_BUILTIN_EARPIECE:
|
|
case TYPE_BUILTIN_SPEAKER:
|
|
case TYPE_WIRED_HEADSET:
|
|
case TYPE_WIRED_HEADPHONES:
|
|
case TYPE_BLUETOOTH_SCO:
|
|
case TYPE_BLUETOOTH_A2DP:
|
|
case TYPE_HDMI:
|
|
case TYPE_DOCK:
|
|
case TYPE_USB_ACCESSORY:
|
|
case TYPE_USB_DEVICE:
|
|
case TYPE_USB_HEADSET:
|
|
case TYPE_TELEPHONY:
|
|
case TYPE_LINE_ANALOG:
|
|
case TYPE_HDMI_ARC:
|
|
case TYPE_HDMI_EARC:
|
|
case TYPE_LINE_DIGITAL:
|
|
case TYPE_FM:
|
|
case TYPE_AUX_LINE:
|
|
case TYPE_IP:
|
|
case TYPE_BUS:
|
|
case TYPE_HEARING_AID:
|
|
case TYPE_BUILTIN_SPEAKER_SAFE:
|
|
case TYPE_BLE_HEADSET:
|
|
case TYPE_BLE_SPEAKER:
|
|
case TYPE_BLE_BROADCAST:
|
|
case TYPE_DOCK_ANALOG:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/** @hide */
|
|
/*package*/ static boolean isValidAudioDeviceTypeIn(int type) {
|
|
switch (type) {
|
|
case TYPE_BUILTIN_MIC:
|
|
case TYPE_BLUETOOTH_SCO:
|
|
case TYPE_BLUETOOTH_A2DP:
|
|
case TYPE_WIRED_HEADSET:
|
|
case TYPE_HDMI:
|
|
case TYPE_TELEPHONY:
|
|
case TYPE_DOCK:
|
|
case TYPE_USB_ACCESSORY:
|
|
case TYPE_USB_DEVICE:
|
|
case TYPE_USB_HEADSET:
|
|
case TYPE_FM_TUNER:
|
|
case TYPE_TV_TUNER:
|
|
case TYPE_LINE_ANALOG:
|
|
case TYPE_LINE_DIGITAL:
|
|
case TYPE_IP:
|
|
case TYPE_BUS:
|
|
case TYPE_REMOTE_SUBMIX:
|
|
case TYPE_BLE_HEADSET:
|
|
case TYPE_HDMI_ARC:
|
|
case TYPE_HDMI_EARC:
|
|
case TYPE_ECHO_REFERENCE:
|
|
case TYPE_DOCK_ANALOG:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @hide
|
|
* Enforces whether the audio device type is acceptable for output.
|
|
*
|
|
* A vendor implemented output type should modify isValidAudioDeviceTypeOut()
|
|
* appropriately to accept the new type. Do not remove already acceptable types.
|
|
*
|
|
* @throws IllegalArgumentException on an invalid output device type.
|
|
* @param type
|
|
*/
|
|
@TestApi
|
|
public static void enforceValidAudioDeviceTypeOut(int type) {
|
|
if (!isValidAudioDeviceTypeOut(type)) {
|
|
throw new IllegalArgumentException("Illegal output device type " + type);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @hide
|
|
* Enforces whether the audio device type is acceptable for input.
|
|
*
|
|
* A vendor implemented input type should modify isValidAudioDeviceTypeIn()
|
|
* appropriately to accept the new type. Do not remove already acceptable types.
|
|
*
|
|
* @throws IllegalArgumentException on an invalid input device type.
|
|
* @param type
|
|
*/
|
|
@TestApi
|
|
public static void enforceValidAudioDeviceTypeIn(int type) {
|
|
if (!isValidAudioDeviceTypeIn(type)) {
|
|
throw new IllegalArgumentException("Illegal input device type " + type);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean equals(Object o) {
|
|
if (this == o) return true;
|
|
if (o == null || getClass() != o.getClass()) return false;
|
|
AudioDeviceInfo that = (AudioDeviceInfo) o;
|
|
return Objects.equals(getPort(), that.getPort());
|
|
}
|
|
|
|
@Override
|
|
public int hashCode() {
|
|
return Objects.hash(getPort());
|
|
}
|
|
|
|
private final AudioDevicePort mPort;
|
|
|
|
/** @hide */
|
|
@VisibleForTesting
|
|
public AudioDeviceInfo(AudioDevicePort port) {
|
|
mPort = port;
|
|
}
|
|
|
|
/**
|
|
* @hide
|
|
* @return The underlying {@link AudioDevicePort} instance.
|
|
*/
|
|
public AudioDevicePort getPort() {
|
|
return mPort;
|
|
}
|
|
|
|
/**
|
|
* @hide
|
|
* @return the internal device type
|
|
*/
|
|
public int getInternalType() {
|
|
return mPort.type();
|
|
}
|
|
|
|
/**
|
|
* @return The internal device ID.
|
|
*/
|
|
public int getId() {
|
|
return mPort.handle().id();
|
|
}
|
|
|
|
/**
|
|
* @return The human-readable name of the audio device.
|
|
*/
|
|
public CharSequence getProductName() {
|
|
String portName = mPort.name();
|
|
return (portName != null && portName.length() != 0) ? portName : android.os.Build.MODEL;
|
|
}
|
|
|
|
/**
|
|
* @return The "address" string of the device. This generally contains device-specific
|
|
* parameters.
|
|
*/
|
|
public @NonNull String getAddress() {
|
|
return mPort.address();
|
|
}
|
|
|
|
/**
|
|
* @return true if the audio device is a source for audio data (e.e an input).
|
|
*/
|
|
public boolean isSource() {
|
|
return mPort.role() == AudioPort.ROLE_SOURCE;
|
|
}
|
|
|
|
/**
|
|
* @return true if the audio device is a sink for audio data (i.e. an output).
|
|
*/
|
|
public boolean isSink() {
|
|
return mPort.role() == AudioPort.ROLE_SINK;
|
|
}
|
|
|
|
/**
|
|
* @return An array of sample rates supported by the audio device.
|
|
*
|
|
* Note: an empty array indicates that the device supports arbitrary rates.
|
|
*/
|
|
public @NonNull int[] getSampleRates() {
|
|
return mPort.samplingRates();
|
|
}
|
|
|
|
/**
|
|
* @return An array of channel position masks (e.g. {@link AudioFormat#CHANNEL_IN_STEREO},
|
|
* {@link AudioFormat#CHANNEL_OUT_7POINT1}) for which this audio device can be configured.
|
|
*
|
|
* @see AudioFormat
|
|
*
|
|
* Note: an empty array indicates that the device supports arbitrary channel masks.
|
|
*/
|
|
public @NonNull int[] getChannelMasks() {
|
|
return mPort.channelMasks();
|
|
}
|
|
|
|
/**
|
|
* @return An array of channel index masks for which this audio device can be configured.
|
|
*
|
|
* @see AudioFormat
|
|
*
|
|
* Note: an empty array indicates that the device supports arbitrary channel index masks.
|
|
*/
|
|
public @NonNull int[] getChannelIndexMasks() {
|
|
return mPort.channelIndexMasks();
|
|
}
|
|
|
|
/**
|
|
* @return An array of channel counts (1, 2, 4, ...) for which this audio device
|
|
* can be configured.
|
|
*
|
|
* Note: an empty array indicates that the device supports arbitrary channel counts.
|
|
*/
|
|
public @NonNull int[] getChannelCounts() {
|
|
TreeSet<Integer> countSet = new TreeSet<Integer>();
|
|
|
|
// Channel Masks
|
|
for (int mask : getChannelMasks()) {
|
|
countSet.add(isSink() ?
|
|
AudioFormat.channelCountFromOutChannelMask(mask)
|
|
: AudioFormat.channelCountFromInChannelMask(mask));
|
|
}
|
|
|
|
// Index Masks
|
|
for (int index_mask : getChannelIndexMasks()) {
|
|
countSet.add(Integer.bitCount(index_mask));
|
|
}
|
|
|
|
int[] counts = new int[countSet.size()];
|
|
int index = 0;
|
|
for (int count : countSet) {
|
|
counts[index++] = count;
|
|
}
|
|
return counts;
|
|
}
|
|
|
|
/**
|
|
* @return An array of audio encodings (e.g. {@link AudioFormat#ENCODING_PCM_16BIT},
|
|
* {@link AudioFormat#ENCODING_PCM_FLOAT}) supported by the audio device.
|
|
* <code>ENCODING_PCM_FLOAT</code> indicates the device supports more
|
|
* than 16 bits of integer precision. As there is no AudioFormat constant
|
|
* specifically defined for 24-bit PCM, the value <code>ENCODING_PCM_FLOAT</code>
|
|
* indicates that {@link AudioTrack} or {@link AudioRecord} can preserve at least 24 bits of
|
|
* integer precision to that device.
|
|
*
|
|
* @see AudioFormat
|
|
*
|
|
* Note: an empty array indicates that the device supports arbitrary encodings.
|
|
* For forward compatibility, applications should ignore entries it does not recognize.
|
|
*/
|
|
public @NonNull int[] getEncodings() {
|
|
return AudioFormat.filterPublicFormats(mPort.formats());
|
|
}
|
|
|
|
/**
|
|
* @return A list of {@link AudioProfile} supported by the audio devices.
|
|
*/
|
|
public @NonNull List<AudioProfile> getAudioProfiles() {
|
|
return mPort.profiles();
|
|
}
|
|
|
|
/**
|
|
* @return A list of {@link AudioDescriptor} supported by the audio devices.
|
|
*/
|
|
public @NonNull List<AudioDescriptor> getAudioDescriptors() {
|
|
return mPort.audioDescriptors();
|
|
}
|
|
|
|
/**
|
|
* Returns an array of supported encapsulation modes for the device.
|
|
*
|
|
* The array can include any of the {@code AudioTrack} encapsulation modes,
|
|
* e.g. {@link AudioTrack#ENCAPSULATION_MODE_ELEMENTARY_STREAM}.
|
|
*
|
|
* @return An array of supported encapsulation modes for the device. This
|
|
* may be an empty array if no encapsulation modes are supported.
|
|
*/
|
|
public @NonNull @AudioTrack.EncapsulationMode int[] getEncapsulationModes() {
|
|
return mPort.encapsulationModes();
|
|
}
|
|
|
|
/**
|
|
* Returns an array of supported encapsulation metadata types for the device.
|
|
*
|
|
* The metadata type returned should be allowed for all encapsulation modes supported
|
|
* by the device. Some metadata types may apply only to certain
|
|
* compressed stream formats, the returned list is the union of subsets.
|
|
*
|
|
* The array can include any of
|
|
* {@link AudioTrack#ENCAPSULATION_METADATA_TYPE_FRAMEWORK_TUNER},
|
|
* {@link AudioTrack#ENCAPSULATION_METADATA_TYPE_DVB_AD_DESCRIPTOR}.
|
|
*
|
|
* @return An array of supported encapsulation metadata types for the device. This
|
|
* may be an empty array if no metadata types are supported.
|
|
*/
|
|
public @NonNull @AudioTrack.EncapsulationMetadataType int[] getEncapsulationMetadataTypes() {
|
|
return mPort.encapsulationMetadataTypes();
|
|
}
|
|
|
|
/**
|
|
* @return The device type identifier of the audio device (i.e. TYPE_BUILTIN_SPEAKER).
|
|
*/
|
|
public @AudioDeviceType int getType() {
|
|
return INT_TO_EXT_DEVICE_MAPPING.get(mPort.type(), TYPE_UNKNOWN);
|
|
}
|
|
|
|
/** @hide */
|
|
public static int convertDeviceTypeToInternalDevice(int deviceType) {
|
|
return EXT_TO_INT_DEVICE_MAPPING.get(deviceType, AudioSystem.DEVICE_NONE);
|
|
}
|
|
|
|
/** @hide */
|
|
public static int convertInternalDeviceToDeviceType(int intDevice) {
|
|
return INT_TO_EXT_DEVICE_MAPPING.get(intDevice, TYPE_UNKNOWN);
|
|
}
|
|
|
|
/** @hide */
|
|
public static int convertDeviceTypeToInternalInputDevice(int deviceType) {
|
|
return convertDeviceTypeToInternalInputDevice(deviceType, "");
|
|
}
|
|
/** @hide */
|
|
public static int convertDeviceTypeToInternalInputDevice(int deviceType, String address) {
|
|
int internalType = EXT_TO_INT_INPUT_DEVICE_MAPPING.get(deviceType, AudioSystem.DEVICE_NONE);
|
|
if (internalType == AudioSystem.DEVICE_IN_BUILTIN_MIC
|
|
&& "back".equals(address)) {
|
|
internalType = AudioSystem.DEVICE_IN_BACK_MIC;
|
|
}
|
|
return internalType;
|
|
}
|
|
|
|
private static final SparseIntArray INT_TO_EXT_DEVICE_MAPPING;
|
|
|
|
private static final SparseIntArray EXT_TO_INT_DEVICE_MAPPING;
|
|
|
|
/**
|
|
* EXT_TO_INT_INPUT_DEVICE_MAPPING aims at mapping external device type to internal input device
|
|
* type.
|
|
*/
|
|
private static final SparseIntArray EXT_TO_INT_INPUT_DEVICE_MAPPING;
|
|
|
|
static {
|
|
INT_TO_EXT_DEVICE_MAPPING = new SparseIntArray();
|
|
INT_TO_EXT_DEVICE_MAPPING.put(AudioSystem.DEVICE_OUT_EARPIECE, TYPE_BUILTIN_EARPIECE);
|
|
INT_TO_EXT_DEVICE_MAPPING.put(AudioSystem.DEVICE_OUT_SPEAKER, TYPE_BUILTIN_SPEAKER);
|
|
INT_TO_EXT_DEVICE_MAPPING.put(AudioSystem.DEVICE_OUT_WIRED_HEADSET, TYPE_WIRED_HEADSET);
|
|
INT_TO_EXT_DEVICE_MAPPING.put(AudioSystem.DEVICE_OUT_WIRED_HEADPHONE, TYPE_WIRED_HEADPHONES);
|
|
INT_TO_EXT_DEVICE_MAPPING.put(AudioSystem.DEVICE_OUT_BLUETOOTH_SCO, TYPE_BLUETOOTH_SCO);
|
|
INT_TO_EXT_DEVICE_MAPPING.put(AudioSystem.DEVICE_OUT_BLUETOOTH_SCO_HEADSET, TYPE_BLUETOOTH_SCO);
|
|
INT_TO_EXT_DEVICE_MAPPING.put(AudioSystem.DEVICE_OUT_BLUETOOTH_SCO_CARKIT, TYPE_BLUETOOTH_SCO);
|
|
INT_TO_EXT_DEVICE_MAPPING.put(AudioSystem.DEVICE_OUT_BLUETOOTH_A2DP, TYPE_BLUETOOTH_A2DP);
|
|
INT_TO_EXT_DEVICE_MAPPING.put(AudioSystem.DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES, TYPE_BLUETOOTH_A2DP);
|
|
INT_TO_EXT_DEVICE_MAPPING.put(AudioSystem.DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER, TYPE_BLUETOOTH_A2DP);
|
|
INT_TO_EXT_DEVICE_MAPPING.put(AudioSystem.DEVICE_OUT_HDMI, TYPE_HDMI);
|
|
INT_TO_EXT_DEVICE_MAPPING.put(AudioSystem.DEVICE_OUT_ANLG_DOCK_HEADSET, TYPE_DOCK_ANALOG);
|
|
INT_TO_EXT_DEVICE_MAPPING.put(AudioSystem.DEVICE_OUT_DGTL_DOCK_HEADSET, TYPE_DOCK);
|
|
INT_TO_EXT_DEVICE_MAPPING.put(AudioSystem.DEVICE_OUT_USB_ACCESSORY, TYPE_USB_ACCESSORY);
|
|
INT_TO_EXT_DEVICE_MAPPING.put(AudioSystem.DEVICE_OUT_USB_DEVICE, TYPE_USB_DEVICE);
|
|
INT_TO_EXT_DEVICE_MAPPING.put(AudioSystem.DEVICE_OUT_USB_HEADSET, TYPE_USB_HEADSET);
|
|
INT_TO_EXT_DEVICE_MAPPING.put(AudioSystem.DEVICE_OUT_TELEPHONY_TX, TYPE_TELEPHONY);
|
|
INT_TO_EXT_DEVICE_MAPPING.put(AudioSystem.DEVICE_OUT_LINE, TYPE_LINE_ANALOG);
|
|
INT_TO_EXT_DEVICE_MAPPING.put(AudioSystem.DEVICE_OUT_HDMI_ARC, TYPE_HDMI_ARC);
|
|
INT_TO_EXT_DEVICE_MAPPING.put(AudioSystem.DEVICE_OUT_HDMI_EARC, TYPE_HDMI_EARC);
|
|
INT_TO_EXT_DEVICE_MAPPING.put(AudioSystem.DEVICE_OUT_SPDIF, TYPE_LINE_DIGITAL);
|
|
INT_TO_EXT_DEVICE_MAPPING.put(AudioSystem.DEVICE_OUT_FM, TYPE_FM);
|
|
INT_TO_EXT_DEVICE_MAPPING.put(AudioSystem.DEVICE_OUT_AUX_LINE, TYPE_AUX_LINE);
|
|
INT_TO_EXT_DEVICE_MAPPING.put(AudioSystem.DEVICE_OUT_IP, TYPE_IP);
|
|
INT_TO_EXT_DEVICE_MAPPING.put(AudioSystem.DEVICE_OUT_BUS, TYPE_BUS);
|
|
INT_TO_EXT_DEVICE_MAPPING.put(AudioSystem.DEVICE_OUT_HEARING_AID, TYPE_HEARING_AID);
|
|
INT_TO_EXT_DEVICE_MAPPING.put(AudioSystem.DEVICE_OUT_SPEAKER_SAFE,
|
|
TYPE_BUILTIN_SPEAKER_SAFE);
|
|
INT_TO_EXT_DEVICE_MAPPING.put(AudioSystem.DEVICE_OUT_REMOTE_SUBMIX, TYPE_REMOTE_SUBMIX);
|
|
INT_TO_EXT_DEVICE_MAPPING.put(AudioSystem.DEVICE_OUT_BLE_HEADSET, TYPE_BLE_HEADSET);
|
|
INT_TO_EXT_DEVICE_MAPPING.put(AudioSystem.DEVICE_OUT_BLE_SPEAKER, TYPE_BLE_SPEAKER);
|
|
INT_TO_EXT_DEVICE_MAPPING.put(AudioSystem.DEVICE_OUT_BLE_BROADCAST, TYPE_BLE_BROADCAST);
|
|
|
|
INT_TO_EXT_DEVICE_MAPPING.put(AudioSystem.DEVICE_IN_BUILTIN_MIC, TYPE_BUILTIN_MIC);
|
|
INT_TO_EXT_DEVICE_MAPPING.put(AudioSystem.DEVICE_IN_BLUETOOTH_SCO_HEADSET, TYPE_BLUETOOTH_SCO);
|
|
INT_TO_EXT_DEVICE_MAPPING.put(AudioSystem.DEVICE_IN_WIRED_HEADSET, TYPE_WIRED_HEADSET);
|
|
INT_TO_EXT_DEVICE_MAPPING.put(AudioSystem.DEVICE_IN_HDMI, TYPE_HDMI);
|
|
INT_TO_EXT_DEVICE_MAPPING.put(AudioSystem.DEVICE_IN_TELEPHONY_RX, TYPE_TELEPHONY);
|
|
INT_TO_EXT_DEVICE_MAPPING.put(AudioSystem.DEVICE_IN_BACK_MIC, TYPE_BUILTIN_MIC);
|
|
INT_TO_EXT_DEVICE_MAPPING.put(AudioSystem.DEVICE_IN_ANLG_DOCK_HEADSET, TYPE_DOCK_ANALOG);
|
|
INT_TO_EXT_DEVICE_MAPPING.put(AudioSystem.DEVICE_IN_DGTL_DOCK_HEADSET, TYPE_DOCK);
|
|
INT_TO_EXT_DEVICE_MAPPING.put(AudioSystem.DEVICE_IN_USB_ACCESSORY, TYPE_USB_ACCESSORY);
|
|
INT_TO_EXT_DEVICE_MAPPING.put(AudioSystem.DEVICE_IN_USB_DEVICE, TYPE_USB_DEVICE);
|
|
INT_TO_EXT_DEVICE_MAPPING.put(AudioSystem.DEVICE_IN_USB_HEADSET, TYPE_USB_HEADSET);
|
|
INT_TO_EXT_DEVICE_MAPPING.put(AudioSystem.DEVICE_IN_FM_TUNER, TYPE_FM_TUNER);
|
|
INT_TO_EXT_DEVICE_MAPPING.put(AudioSystem.DEVICE_IN_TV_TUNER, TYPE_TV_TUNER);
|
|
INT_TO_EXT_DEVICE_MAPPING.put(AudioSystem.DEVICE_IN_LINE, TYPE_LINE_ANALOG);
|
|
INT_TO_EXT_DEVICE_MAPPING.put(AudioSystem.DEVICE_IN_SPDIF, TYPE_LINE_DIGITAL);
|
|
INT_TO_EXT_DEVICE_MAPPING.put(AudioSystem.DEVICE_IN_BLUETOOTH_A2DP, TYPE_BLUETOOTH_A2DP);
|
|
INT_TO_EXT_DEVICE_MAPPING.put(AudioSystem.DEVICE_IN_IP, TYPE_IP);
|
|
INT_TO_EXT_DEVICE_MAPPING.put(AudioSystem.DEVICE_IN_BUS, TYPE_BUS);
|
|
INT_TO_EXT_DEVICE_MAPPING.put(AudioSystem.DEVICE_IN_REMOTE_SUBMIX, TYPE_REMOTE_SUBMIX);
|
|
INT_TO_EXT_DEVICE_MAPPING.put(AudioSystem.DEVICE_IN_BLE_HEADSET, TYPE_BLE_HEADSET);
|
|
INT_TO_EXT_DEVICE_MAPPING.put(AudioSystem.DEVICE_IN_HDMI_ARC, TYPE_HDMI_ARC);
|
|
INT_TO_EXT_DEVICE_MAPPING.put(AudioSystem.DEVICE_IN_HDMI_EARC, TYPE_HDMI_EARC);
|
|
INT_TO_EXT_DEVICE_MAPPING.put(AudioSystem.DEVICE_IN_ECHO_REFERENCE, TYPE_ECHO_REFERENCE);
|
|
|
|
|
|
// privileges mapping to output device
|
|
EXT_TO_INT_DEVICE_MAPPING = new SparseIntArray();
|
|
EXT_TO_INT_DEVICE_MAPPING.put(TYPE_BUILTIN_EARPIECE, AudioSystem.DEVICE_OUT_EARPIECE);
|
|
EXT_TO_INT_DEVICE_MAPPING.put(TYPE_BUILTIN_SPEAKER, AudioSystem.DEVICE_OUT_SPEAKER);
|
|
EXT_TO_INT_DEVICE_MAPPING.put(TYPE_WIRED_HEADSET, AudioSystem.DEVICE_OUT_WIRED_HEADSET);
|
|
EXT_TO_INT_DEVICE_MAPPING.put(TYPE_WIRED_HEADPHONES, AudioSystem.DEVICE_OUT_WIRED_HEADPHONE);
|
|
EXT_TO_INT_DEVICE_MAPPING.put(TYPE_LINE_ANALOG, AudioSystem.DEVICE_OUT_LINE);
|
|
EXT_TO_INT_DEVICE_MAPPING.put(TYPE_LINE_DIGITAL, AudioSystem.DEVICE_OUT_SPDIF);
|
|
EXT_TO_INT_DEVICE_MAPPING.put(TYPE_BLUETOOTH_SCO, AudioSystem.DEVICE_OUT_BLUETOOTH_SCO);
|
|
EXT_TO_INT_DEVICE_MAPPING.put(TYPE_BLUETOOTH_A2DP, AudioSystem.DEVICE_OUT_BLUETOOTH_A2DP);
|
|
EXT_TO_INT_DEVICE_MAPPING.put(TYPE_HDMI, AudioSystem.DEVICE_OUT_HDMI);
|
|
EXT_TO_INT_DEVICE_MAPPING.put(TYPE_HDMI_ARC, AudioSystem.DEVICE_OUT_HDMI_ARC);
|
|
EXT_TO_INT_DEVICE_MAPPING.put(TYPE_HDMI_EARC, AudioSystem.DEVICE_OUT_HDMI_EARC);
|
|
EXT_TO_INT_DEVICE_MAPPING.put(TYPE_USB_DEVICE, AudioSystem.DEVICE_OUT_USB_DEVICE);
|
|
EXT_TO_INT_DEVICE_MAPPING.put(TYPE_USB_HEADSET, AudioSystem.DEVICE_OUT_USB_HEADSET);
|
|
EXT_TO_INT_DEVICE_MAPPING.put(TYPE_USB_ACCESSORY, AudioSystem.DEVICE_OUT_USB_ACCESSORY);
|
|
EXT_TO_INT_DEVICE_MAPPING.put(TYPE_DOCK, AudioSystem.DEVICE_OUT_DGTL_DOCK_HEADSET);
|
|
EXT_TO_INT_DEVICE_MAPPING.put(TYPE_DOCK_ANALOG, AudioSystem.DEVICE_OUT_ANLG_DOCK_HEADSET);
|
|
EXT_TO_INT_DEVICE_MAPPING.put(TYPE_FM, AudioSystem.DEVICE_OUT_FM);
|
|
EXT_TO_INT_DEVICE_MAPPING.put(TYPE_TELEPHONY, AudioSystem.DEVICE_OUT_TELEPHONY_TX);
|
|
EXT_TO_INT_DEVICE_MAPPING.put(TYPE_AUX_LINE, AudioSystem.DEVICE_OUT_AUX_LINE);
|
|
EXT_TO_INT_DEVICE_MAPPING.put(TYPE_IP, AudioSystem.DEVICE_OUT_IP);
|
|
EXT_TO_INT_DEVICE_MAPPING.put(TYPE_BUS, AudioSystem.DEVICE_OUT_BUS);
|
|
EXT_TO_INT_DEVICE_MAPPING.put(TYPE_HEARING_AID, AudioSystem.DEVICE_OUT_HEARING_AID);
|
|
EXT_TO_INT_DEVICE_MAPPING.put(TYPE_BUILTIN_SPEAKER_SAFE,
|
|
AudioSystem.DEVICE_OUT_SPEAKER_SAFE);
|
|
EXT_TO_INT_DEVICE_MAPPING.put(TYPE_REMOTE_SUBMIX, AudioSystem.DEVICE_OUT_REMOTE_SUBMIX);
|
|
EXT_TO_INT_DEVICE_MAPPING.put(TYPE_BLE_HEADSET, AudioSystem.DEVICE_OUT_BLE_HEADSET);
|
|
EXT_TO_INT_DEVICE_MAPPING.put(TYPE_BLE_SPEAKER, AudioSystem.DEVICE_OUT_BLE_SPEAKER);
|
|
EXT_TO_INT_DEVICE_MAPPING.put(TYPE_BLE_BROADCAST, AudioSystem.DEVICE_OUT_BLE_BROADCAST);
|
|
|
|
// privileges mapping to input device
|
|
EXT_TO_INT_INPUT_DEVICE_MAPPING = new SparseIntArray();
|
|
EXT_TO_INT_INPUT_DEVICE_MAPPING.put(TYPE_BUILTIN_MIC, AudioSystem.DEVICE_IN_BUILTIN_MIC);
|
|
EXT_TO_INT_INPUT_DEVICE_MAPPING.put(
|
|
TYPE_BLUETOOTH_SCO, AudioSystem.DEVICE_IN_BLUETOOTH_SCO_HEADSET);
|
|
EXT_TO_INT_INPUT_DEVICE_MAPPING.put(
|
|
TYPE_WIRED_HEADSET, AudioSystem.DEVICE_IN_WIRED_HEADSET);
|
|
EXT_TO_INT_INPUT_DEVICE_MAPPING.put(TYPE_HDMI, AudioSystem.DEVICE_IN_HDMI);
|
|
EXT_TO_INT_INPUT_DEVICE_MAPPING.put(TYPE_TELEPHONY, AudioSystem.DEVICE_IN_TELEPHONY_RX);
|
|
EXT_TO_INT_INPUT_DEVICE_MAPPING.put(TYPE_DOCK, AudioSystem.DEVICE_IN_DGTL_DOCK_HEADSET);
|
|
EXT_TO_INT_INPUT_DEVICE_MAPPING.put(
|
|
TYPE_DOCK_ANALOG, AudioSystem.DEVICE_IN_ANLG_DOCK_HEADSET);
|
|
EXT_TO_INT_INPUT_DEVICE_MAPPING.put(
|
|
TYPE_USB_ACCESSORY, AudioSystem.DEVICE_IN_USB_ACCESSORY);
|
|
EXT_TO_INT_INPUT_DEVICE_MAPPING.put(TYPE_USB_DEVICE, AudioSystem.DEVICE_IN_USB_DEVICE);
|
|
EXT_TO_INT_INPUT_DEVICE_MAPPING.put(TYPE_USB_HEADSET, AudioSystem.DEVICE_IN_USB_HEADSET);
|
|
EXT_TO_INT_INPUT_DEVICE_MAPPING.put(TYPE_FM_TUNER, AudioSystem.DEVICE_IN_FM_TUNER);
|
|
EXT_TO_INT_INPUT_DEVICE_MAPPING.put(TYPE_TV_TUNER, AudioSystem.DEVICE_IN_TV_TUNER);
|
|
EXT_TO_INT_INPUT_DEVICE_MAPPING.put(TYPE_LINE_ANALOG, AudioSystem.DEVICE_IN_LINE);
|
|
EXT_TO_INT_INPUT_DEVICE_MAPPING.put(TYPE_LINE_DIGITAL, AudioSystem.DEVICE_IN_SPDIF);
|
|
EXT_TO_INT_INPUT_DEVICE_MAPPING.put(
|
|
TYPE_BLUETOOTH_A2DP, AudioSystem.DEVICE_IN_BLUETOOTH_A2DP);
|
|
EXT_TO_INT_INPUT_DEVICE_MAPPING.put(TYPE_IP, AudioSystem.DEVICE_IN_IP);
|
|
EXT_TO_INT_INPUT_DEVICE_MAPPING.put(TYPE_BUS, AudioSystem.DEVICE_IN_BUS);
|
|
EXT_TO_INT_INPUT_DEVICE_MAPPING.put(
|
|
TYPE_REMOTE_SUBMIX, AudioSystem.DEVICE_IN_REMOTE_SUBMIX);
|
|
EXT_TO_INT_INPUT_DEVICE_MAPPING.put(TYPE_BLE_HEADSET, AudioSystem.DEVICE_IN_BLE_HEADSET);
|
|
EXT_TO_INT_INPUT_DEVICE_MAPPING.put(TYPE_HDMI_ARC, AudioSystem.DEVICE_IN_HDMI_ARC);
|
|
EXT_TO_INT_INPUT_DEVICE_MAPPING.put(TYPE_HDMI_EARC, AudioSystem.DEVICE_IN_HDMI_EARC);
|
|
EXT_TO_INT_INPUT_DEVICE_MAPPING.put(
|
|
TYPE_ECHO_REFERENCE, AudioSystem.DEVICE_IN_ECHO_REFERENCE);
|
|
|
|
}
|
|
}
|
|
|