xref: /frameworks/base/media/java/android/media/AudioDeviceInfo.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 static android.media.audio.Flags.FLAG_ENABLE_MULTICHANNEL_GROUP_DEVICE;
import static android.media.audio.Flags.FLAG_SPEAKER_LAYOUT_API;

import android.Manifest;
import android.annotation.FlaggedApi;
import android.annotation.IntDef;
import android.annotation.NonNull;
import android.annotation.RequiresPermission;
import android.annotation.TestApi;
import android.media.audio.Flags;
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;

    /**
     * A device type describing a speaker group that supports multichannel contents. The speakers in
     * the group are connected together using local network based protocols. The speaker group
     * requires additional input of the physical positions of each individual speaker to provide a
     * better experience on multichannel contents.
     */
    @FlaggedApi(FLAG_ENABLE_MULTICHANNEL_GROUP_DEVICE)
    public static final int TYPE_MULTICHANNEL_GROUP = 32;

    /** @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,
            TYPE_MULTICHANNEL_GROUP}
    )
    @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_REMOTE_SUBMIX,
            TYPE_HEARING_AID,
            TYPE_BUILTIN_SPEAKER_SAFE,
            TYPE_BLE_HEADSET,
            TYPE_BLE_SPEAKER,
            TYPE_BLE_BROADCAST,
            TYPE_DOCK_ANALOG,
            TYPE_MULTICHANNEL_GROUP}
    )
    @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_REMOTE_SUBMIX:
            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:
                if (Flags.enableMultichannelGroupDevice()) {
                    if (type == TYPE_MULTICHANNEL_GROUP) {
                        return true;
                    }
                }
                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;
    }

    /** @hide */
    @IntDef(flag = true, prefix = "AudioFormat.CHANNEL_OUT_", value = {
            AudioFormat.CHANNEL_INVALID,
            AudioFormat.CHANNEL_OUT_DEFAULT,
            AudioFormat.CHANNEL_OUT_FRONT_LEFT,
            AudioFormat.CHANNEL_OUT_FRONT_RIGHT,
            AudioFormat.CHANNEL_OUT_FRONT_CENTER,
            AudioFormat.CHANNEL_OUT_LOW_FREQUENCY,
            AudioFormat.CHANNEL_OUT_BACK_LEFT,
            AudioFormat.CHANNEL_OUT_BACK_RIGHT,
            AudioFormat.CHANNEL_OUT_FRONT_LEFT_OF_CENTER,
            AudioFormat.CHANNEL_OUT_FRONT_RIGHT_OF_CENTER,
            AudioFormat.CHANNEL_OUT_BACK_CENTER,
            AudioFormat.CHANNEL_OUT_SIDE_LEFT,
            AudioFormat.CHANNEL_OUT_SIDE_RIGHT,
            AudioFormat.CHANNEL_OUT_TOP_CENTER,
            AudioFormat.CHANNEL_OUT_TOP_FRONT_LEFT,
            AudioFormat.CHANNEL_OUT_TOP_FRONT_CENTER,
            AudioFormat.CHANNEL_OUT_TOP_FRONT_RIGHT,
            AudioFormat.CHANNEL_OUT_TOP_BACK_LEFT,
            AudioFormat.CHANNEL_OUT_TOP_BACK_CENTER,
            AudioFormat.CHANNEL_OUT_TOP_BACK_RIGHT,
            AudioFormat.CHANNEL_OUT_TOP_SIDE_LEFT,
            AudioFormat.CHANNEL_OUT_TOP_SIDE_RIGHT,
            AudioFormat.CHANNEL_OUT_BOTTOM_FRONT_LEFT,
            AudioFormat.CHANNEL_OUT_BOTTOM_FRONT_CENTER,
            AudioFormat.CHANNEL_OUT_BOTTOM_FRONT_RIGHT,
            AudioFormat.CHANNEL_OUT_LOW_FREQUENCY_2,
            AudioFormat.CHANNEL_OUT_FRONT_WIDE_LEFT,
            AudioFormat.CHANNEL_OUT_FRONT_WIDE_RIGHT}
    )
    @Retention(RetentionPolicy.SOURCE)
    @FlaggedApi(FLAG_SPEAKER_LAYOUT_API)
    public @interface SpeakerLayoutChannelMask {}

    /**
     * @return A ChannelMask representing the speaker layout of a TYPE_BUILTIN_SPEAKER device.
     *
     * Valid only for speakers built-in to the device.
     *
     * The layout channel mask only indicates which speaker channels are present, the
     * physical layout of the speakers should be informed by a standard for multi-channel
     * sound playback systems, such as ITU-R BS.2051.
     * @see AudioFormat
     */
    @FlaggedApi(FLAG_SPEAKER_LAYOUT_API)
    @SpeakerLayoutChannelMask
    public int getSpeakerLayoutChannelMask() {
        return mPort.speakerLayoutChannelMask();
    }

    /**
     * @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(@AudioDeviceType int deviceType) {
        return EXT_TO_INT_DEVICE_MAPPING.get(deviceType, AudioSystem.DEVICE_NONE);
    }

    /** @hide */
    public static @AudioDeviceType int convertInternalDeviceToDeviceType(int intDevice) {
        return INT_TO_EXT_DEVICE_MAPPING.get(intDevice, TYPE_UNKNOWN);
    }

    /** @hide */
    public static int convertDeviceTypeToInternalInputDevice(@AudioDeviceType int deviceType) {
        return convertDeviceTypeToInternalInputDevice(deviceType, "");
    }
    /** @hide */
    public static int convertDeviceTypeToInternalInputDevice(@AudioDeviceType 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);
        if (Flags.enableMultichannelGroupDevice()) {
            INT_TO_EXT_DEVICE_MAPPING.put(
                    AudioSystem.DEVICE_OUT_MULTICHANNEL_GROUP, TYPE_MULTICHANNEL_GROUP);
        }

        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);
        if (Flags.enableMultichannelGroupDevice()) {
            EXT_TO_INT_DEVICE_MAPPING.put(
                    TYPE_MULTICHANNEL_GROUP, AudioSystem.DEVICE_OUT_MULTICHANNEL_GROUP);
        }

        // 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);

    }
}