| /* |
| * 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.annotation.IntDef; |
| import android.os.Parcel; |
| import android.os.Parcelable; |
| import android.util.Log; |
| |
| import java.lang.annotation.Retention; |
| import java.lang.annotation.RetentionPolicy; |
| import java.util.Collections; |
| import java.util.HashSet; |
| import java.util.Iterator; |
| import java.util.Set; |
| |
| /** |
| * A class to encapsulate a collection of attributes describing information about an audio |
| * player or recorder. |
| */ |
| public final class AudioAttributes implements Parcelable { |
| private final static String TAG = "AudioAttributes"; |
| |
| /** |
| * Content type value to use when the content type is unknown, or other than the ones defined. |
| */ |
| public final static int CONTENT_TYPE_UNKNOWN = 0; |
| /** |
| * Content type value to use when the content type is speech. |
| */ |
| public final static int CONTENT_TYPE_SPEECH = 1; |
| /** |
| * Content type value to use when the content type is music. |
| */ |
| public final static int CONTENT_TYPE_MUSIC = 2; |
| /** |
| * Content type value to use when the content type is a soundtrack, typically accompanying |
| * a movie or TV program. |
| */ |
| public final static int CONTENT_TYPE_MOVIE = 3; |
| /** |
| * Content type value to use when the content type is a sound used to accompany a user |
| * action, such as a beep or sound effect expressing a key click, or event, such as the |
| * type of a sound for a bonus being received in a game. These sounds are mostly synthesized |
| * or short Foley sounds. |
| */ |
| public final static int CONTENT_TYPE_SONIFICATION = 4; |
| |
| /** |
| * Usage value to use when the usage is unknown. |
| */ |
| public final static int USAGE_UNKNOWN = 0; |
| /** |
| * Usage value to use when the usage is media, such as music, or movie |
| * soundtracks. |
| */ |
| public final static int USAGE_MEDIA = 1; |
| /** |
| * Usage value to use when the usage is voice communications, such as telephony |
| * or VoIP. |
| */ |
| public final static int USAGE_VOICE_COMMUNICATION = 2; |
| /** |
| * Usage value to use when the usage is in-call signalling, such as with |
| * a "busy" beep, or DTMF tones. |
| */ |
| public final static int USAGE_VOICE_COMMUNICATION_SIGNALLING = 3; |
| /** |
| * Usage value to use when the usage is an alarm (e.g. wake-up alarm). |
| */ |
| public final static int USAGE_ALARM = 4; |
| /** |
| * Usage value to use when the usage is notification. See other |
| * notification usages for more specialized uses. |
| */ |
| public final static int USAGE_NOTIFICATION = 5; |
| /** |
| * Usage value to use when the usage is telephony ringtone. |
| */ |
| public final static int USAGE_NOTIFICATION_RINGTONE = 6; |
| /** |
| * Usage value to use when the usage is a request to enter/end a |
| * communication, such as a VoIP communication or video-conference. |
| */ |
| public final static int USAGE_NOTIFICATION_COMMUNICATION_REQUEST = 7; |
| /** |
| * Usage value to use when the usage is notification for an "instant" |
| * communication such as a chat, or SMS. |
| */ |
| public final static int USAGE_NOTIFICATION_COMMUNICATION_INSTANT = 8; |
| /** |
| * Usage value to use when the usage is notification for a |
| * non-immediate type of communication such as e-mail. |
| */ |
| public final static int USAGE_NOTIFICATION_COMMUNICATION_DELAYED = 9; |
| /** |
| * Usage value to use when the usage is to attract the user's attention, |
| * such as a reminder or low battery warning. |
| */ |
| public final static int USAGE_NOTIFICATION_EVENT = 10; |
| /** |
| * Usage value to use when the usage is for accessibility, such as with |
| * a screen reader. |
| */ |
| public final static int USAGE_ASSISTANCE_ACCESSIBILITY = 11; |
| /** |
| * Usage value to use when the usage is driving or navigation directions. |
| */ |
| public final static int USAGE_ASSISTANCE_NAVIGATION_GUIDANCE = 12; |
| /** |
| * Usage value to use when the usage is sonification, such as with user |
| * interface sounds. |
| */ |
| public final static int USAGE_ASSISTANCE_SONIFICATION = 13; |
| /** |
| * Usage value to use when the usage is for game audio. |
| */ |
| public final static int USAGE_GAME = 14; |
| |
| /** |
| * Flag defining a behavior where the audibility of the sound will be ensured by the system. |
| */ |
| public final static int FLAG_AUDIBILITY_ENFORCED = 0x1 << 0; |
| /** |
| * @hide |
| * Flag defining a behavior where the playback of the sound is ensured without |
| * degradation only when going to a secure sink. |
| */ |
| // FIXME not guaranteed yet |
| // TODO add OR to getFlags() when supported and in public API |
| public final static int FLAG_SECURE = 0x1 << 1; |
| /** |
| * @hide |
| * Flag to enable when the stream is associated with SCO usage. |
| * Internal use only for dealing with legacy STREAM_BLUETOOTH_SCO |
| */ |
| public final static int FLAG_SCO = 0x1 << 2; |
| |
| |
| private int mUsage = USAGE_UNKNOWN; |
| private int mContentType = CONTENT_TYPE_UNKNOWN; |
| private int mSource = MediaRecorder.AudioSource.AUDIO_SOURCE_INVALID; |
| private int mFlags = 0x0; |
| private HashSet<String> mTags; |
| private String mFormattedTags; |
| |
| private AudioAttributes() { |
| } |
| |
| /** |
| * Return the content type. |
| * @return one of the values that can be set in {@link Builder#setContentType(int)} |
| */ |
| public int getContentType() { |
| return mContentType; |
| } |
| |
| /** |
| * Return the usage. |
| * @return one of the values that can be set in {@link Builder#setUsage(int)} |
| */ |
| public int getUsage() { |
| return mUsage; |
| } |
| |
| /** |
| * @hide |
| * CANDIDATE FOR PUBLIC API |
| * Return the capture preset. |
| * @return one of the values that can be set in {@link Builder#setCapturePreset(int)} or a |
| * negative value if none has been set. |
| */ |
| public int getCapturePreset() { |
| return mSource; |
| } |
| |
| /** |
| * Return the flags. |
| * @return a combined mask of all flags |
| */ |
| public int getFlags() { |
| // only return the flags that are public |
| return (mFlags & (FLAG_AUDIBILITY_ENFORCED)); |
| } |
| |
| /** |
| * @hide |
| * Return all the flags, even the non-public ones. |
| * Internal use only |
| * @return a combined mask of all flags |
| */ |
| public int getAllFlags() { |
| return mFlags; |
| } |
| |
| /** |
| * @hide |
| * Return the set of tags. |
| * @return a read-only set of all tags stored as strings. |
| */ |
| public Set<String> getTags() { |
| return Collections.unmodifiableSet(mTags); |
| } |
| |
| /** |
| * Builder class for {@link AudioAttributes} objects. |
| */ |
| public static class Builder { |
| private int mUsage = USAGE_UNKNOWN; |
| private int mContentType = CONTENT_TYPE_UNKNOWN; |
| private int mSource = MediaRecorder.AudioSource.AUDIO_SOURCE_INVALID; |
| private int mFlags = 0x0; |
| private HashSet<String> mTags = new HashSet<String>(); |
| |
| /** |
| * Constructs a new Builder with the defaults. |
| */ |
| public Builder() { |
| } |
| |
| /** |
| * Constructs a new Builder from a given AudioAttributes |
| * @param aa the AudioAttributes object whose data will be reused in the new Builder. |
| */ |
| @SuppressWarnings("unchecked") // for cloning of mTags |
| public Builder(AudioAttributes aa) { |
| mUsage = aa.mUsage; |
| mContentType = aa.mContentType; |
| mFlags = aa.mFlags; |
| mTags = (HashSet<String>) aa.mTags.clone(); |
| } |
| |
| /** |
| * Combines all of the attributes that have been set and return a new |
| * {@link AudioAttributes} object. |
| * @return a new {@link AudioAttributes} object |
| */ |
| @SuppressWarnings("unchecked") // for cloning of mTags |
| public AudioAttributes build() { |
| AudioAttributes aa = new AudioAttributes(); |
| aa.mContentType = mContentType; |
| aa.mUsage = mUsage; |
| aa.mSource = mSource; |
| aa.mFlags = mFlags; |
| aa.mTags = (HashSet<String>) mTags.clone(); |
| final Iterator<String> tagIterator = mTags.iterator(); |
| String allTagsInOne = new String(); |
| while (tagIterator.hasNext()) { |
| allTagsInOne += tagIterator.next() + ";"; |
| } |
| aa.mFormattedTags = allTagsInOne; |
| return aa; |
| } |
| |
| /** |
| * Sets the attribute describing what is the intended use of the the audio signal, |
| * such as alarm or ringtone. |
| * @param usage one of {@link AudioAttributes#USAGE_UNKNOWN}, |
| * {@link AudioAttributes#USAGE_MEDIA}, |
| * {@link AudioAttributes#USAGE_VOICE_COMMUNICATION}, |
| * {@link AudioAttributes#USAGE_VOICE_COMMUNICATION_SIGNALLING}, |
| * {@link AudioAttributes#USAGE_ALARM}, {@link AudioAttributes#USAGE_NOTIFICATION}, |
| * {@link AudioAttributes#USAGE_NOTIFICATION_RINGTONE}, |
| * {@link AudioAttributes#USAGE_NOTIFICATION_COMMUNICATION_REQUEST}, |
| * {@link AudioAttributes#USAGE_NOTIFICATION_COMMUNICATION_INSTANT}, |
| * {@link AudioAttributes#USAGE_NOTIFICATION_COMMUNICATION_DELAYED}, |
| * {@link AudioAttributes#USAGE_NOTIFICATION_EVENT}, |
| * {@link AudioAttributes#USAGE_ASSISTANCE_ACCESSIBILITY}, |
| * {@link AudioAttributes#USAGE_ASSISTANCE_NAVIGATION_GUIDANCE}, |
| * {@link AudioAttributes#USAGE_ASSISTANCE_SONIFICATION}, |
| * {@link AudioAttributes#USAGE_GAME}. |
| * @return the same Builder instance. |
| */ |
| public Builder setUsage(@AttributeUsage int usage) { |
| switch (usage) { |
| case USAGE_UNKNOWN: |
| case USAGE_MEDIA: |
| case USAGE_VOICE_COMMUNICATION: |
| case USAGE_VOICE_COMMUNICATION_SIGNALLING: |
| case USAGE_ALARM: |
| case USAGE_NOTIFICATION: |
| case USAGE_NOTIFICATION_RINGTONE: |
| case USAGE_NOTIFICATION_COMMUNICATION_REQUEST: |
| case USAGE_NOTIFICATION_COMMUNICATION_INSTANT: |
| case USAGE_NOTIFICATION_COMMUNICATION_DELAYED: |
| case USAGE_NOTIFICATION_EVENT: |
| case USAGE_ASSISTANCE_ACCESSIBILITY: |
| case USAGE_ASSISTANCE_NAVIGATION_GUIDANCE: |
| case USAGE_ASSISTANCE_SONIFICATION: |
| case USAGE_GAME: |
| mUsage = usage; |
| break; |
| default: |
| mUsage = USAGE_UNKNOWN; |
| } |
| return this; |
| } |
| |
| /** |
| * Sets the attribute describing the content type of the audio signal, such as speech, |
| * or music. |
| * @param contentType the content type values, one of |
| * {@link AudioAttributes#CONTENT_TYPE_MOVIE}, |
| * {@link AudioAttributes#CONTENT_TYPE_MUSIC}, |
| * {@link AudioAttributes#CONTENT_TYPE_SONIFICATION}, |
| * {@link AudioAttributes#CONTENT_TYPE_SPEECH}, |
| * {@link AudioAttributes#CONTENT_TYPE_UNKNOWN}. |
| * @return the same Builder instance. |
| */ |
| public Builder setContentType(@AttributeContentType int contentType) { |
| switch (contentType) { |
| case CONTENT_TYPE_UNKNOWN: |
| case CONTENT_TYPE_MOVIE: |
| case CONTENT_TYPE_MUSIC: |
| case CONTENT_TYPE_SONIFICATION: |
| case CONTENT_TYPE_SPEECH: |
| mContentType = contentType; |
| break; |
| default: |
| mUsage = CONTENT_TYPE_UNKNOWN; |
| } |
| return this; |
| } |
| |
| /** |
| * Sets the combination of flags. |
| * @param flags the {@link AudioAttributes#FLAG_AUDIBILITY_ENFORCED} flag. |
| * @return the same Builder instance. |
| */ |
| public Builder setFlags(int flags) { |
| flags &= (AudioAttributes.FLAG_AUDIBILITY_ENFORCED | AudioAttributes.FLAG_SCO |
| | AudioAttributes.FLAG_SECURE); |
| mFlags |= flags; |
| return this; |
| } |
| |
| /** |
| * @hide |
| * Add a custom tag stored as a string |
| * @param tag |
| * @return the same Builder instance. |
| */ |
| public Builder addTag(String tag) { |
| mTags.add(tag); |
| return this; |
| } |
| |
| /** |
| * Adds attributes inferred from the legacy stream types. |
| * @param streamType one of {@link AudioManager#STREAM_VOICE_CALL}, |
| * {@link AudioManager#STREAM_SYSTEM}, {@link AudioManager#STREAM_RING}, |
| * {@link AudioManager#STREAM_MUSIC}, {@link AudioManager#STREAM_ALARM}, |
| * or {@link AudioManager#STREAM_NOTIFICATION}. |
| * @return the same Builder instance. |
| */ |
| public Builder setLegacyStreamType(int streamType) { |
| return setInternalLegacyStreamType(streamType); |
| } |
| |
| /** |
| * @hide |
| * For internal framework use only, enables building from hidden stream types. |
| * @param streamType |
| * @return the same Builder instance. |
| */ |
| public Builder setInternalLegacyStreamType(int streamType) { |
| switch(streamType) { |
| case AudioSystem.STREAM_VOICE_CALL: |
| mContentType = CONTENT_TYPE_SPEECH; |
| break; |
| case AudioSystem.STREAM_SYSTEM_ENFORCED: |
| mFlags |= FLAG_AUDIBILITY_ENFORCED; |
| // intended fall through, attributes in common with STREAM_SYSTEM |
| case AudioSystem.STREAM_SYSTEM: |
| mContentType = CONTENT_TYPE_SONIFICATION; |
| break; |
| case AudioSystem.STREAM_RING: |
| mContentType = CONTENT_TYPE_SONIFICATION; |
| break; |
| case AudioSystem.STREAM_MUSIC: |
| mContentType = CONTENT_TYPE_MUSIC; |
| break; |
| case AudioSystem.STREAM_ALARM: |
| mContentType = CONTENT_TYPE_SONIFICATION; |
| break; |
| case AudioSystem.STREAM_NOTIFICATION: |
| mContentType = CONTENT_TYPE_SONIFICATION; |
| break; |
| case AudioSystem.STREAM_BLUETOOTH_SCO: |
| mContentType = CONTENT_TYPE_SPEECH; |
| mFlags |= FLAG_SCO; |
| break; |
| case AudioSystem.STREAM_DTMF: |
| mContentType = CONTENT_TYPE_SONIFICATION; |
| break; |
| case AudioSystem.STREAM_TTS: |
| mContentType = CONTENT_TYPE_SPEECH; |
| break; |
| default: |
| Log.e(TAG, "Invalid stream type " + streamType + " for AudioAttributes"); |
| } |
| return this; |
| } |
| |
| /** |
| * @hide |
| * CANDIDATE FOR PUBLIC API |
| * Sets the capture preset. |
| * Use this audio attributes configuration method when building an {@link AudioRecord} |
| * instance with {@link AudioRecord#AudioRecord(AudioAttributes, AudioFormat, int)}. |
| * @param preset one of {@link MediaRecorder.AudioSource#DEFAULT}, |
| * {@link MediaRecorder.AudioSource#MIC}, {@link MediaRecorder.AudioSource#CAMCORDER}, |
| * {@link MediaRecorder.AudioSource#VOICE_RECOGNITION} or |
| * {@link MediaRecorder.AudioSource#VOICE_COMMUNICATION}. |
| * @return the same Builder instance. |
| */ |
| public Builder setCapturePreset(int preset) { |
| switch (preset) { |
| case MediaRecorder.AudioSource.DEFAULT: |
| case MediaRecorder.AudioSource.MIC: |
| case MediaRecorder.AudioSource.CAMCORDER: |
| case MediaRecorder.AudioSource.VOICE_RECOGNITION: |
| case MediaRecorder.AudioSource.VOICE_COMMUNICATION: |
| mSource = preset; |
| break; |
| default: |
| Log.e(TAG, "Invalid capture preset " + preset + " for AudioAttributes"); |
| } |
| return this; |
| } |
| |
| /** |
| * @hide |
| * Same as {@link #setCapturePreset(int)} but authorizes the use of HOTWORD and |
| * REMOTE_SUBMIX. |
| * @param preset |
| * @return the same Builder instance. |
| */ |
| public Builder setInternalCapturePreset(int preset) { |
| if ((preset == MediaRecorder.AudioSource.HOTWORD) |
| || (preset == MediaRecorder.AudioSource.REMOTE_SUBMIX)) { |
| mSource = preset; |
| } else { |
| setCapturePreset(preset); |
| } |
| return this; |
| } |
| }; |
| |
| @Override |
| public int describeContents() { |
| return 0; |
| } |
| |
| /** |
| * @hide |
| * Used to indicate that when parcelling, the tags should be parcelled through the flattened |
| * formatted string, not through the array of strings. |
| * Keep in sync with frameworks/av/media/libmediaplayerservice/MediaPlayerService.cpp |
| * see definition of kAudioAttributesMarshallTagFlattenTags |
| */ |
| public final static int FLATTEN_TAGS = 0x1; |
| /** |
| * When adding tags for writeToParcel(Parcel, int), add them in the list of flags (| NEW_FLAG) |
| */ |
| private final static int ALL_PARCEL_FLAGS = FLATTEN_TAGS; |
| @Override |
| public void writeToParcel(Parcel dest, int flags) { |
| dest.writeInt(mUsage); |
| dest.writeInt(mContentType); |
| dest.writeInt(mSource); |
| dest.writeInt(mFlags); |
| dest.writeInt(flags & ALL_PARCEL_FLAGS); |
| if ((flags & FLATTEN_TAGS) == 0) { |
| String[] tagsArray = new String[mTags.size()]; |
| mTags.toArray(tagsArray); |
| dest.writeStringArray(tagsArray); |
| } else if ((flags & FLATTEN_TAGS) == FLATTEN_TAGS) { |
| dest.writeString(mFormattedTags); |
| } |
| } |
| |
| private AudioAttributes(Parcel in) { |
| mUsage = in.readInt(); |
| mContentType = in.readInt(); |
| mSource = in.readInt(); |
| mFlags = in.readInt(); |
| boolean hasFlattenedTags = ((in.readInt() & FLATTEN_TAGS) == FLATTEN_TAGS); |
| mTags = new HashSet<String>(); |
| if (hasFlattenedTags) { |
| mTags.add(in.readString()); |
| } else { |
| String[] tagsArray = in.readStringArray(); |
| for (int i = tagsArray.length - 1 ; i >= 0 ; i--) { |
| mTags.add(tagsArray[i]); |
| } |
| } |
| } |
| |
| /** @hide */ |
| public static final Parcelable.Creator<AudioAttributes> CREATOR |
| = new Parcelable.Creator<AudioAttributes>() { |
| /** |
| * Rebuilds an AudioAttributes previously stored with writeToParcel(). |
| * @param p Parcel object to read the AudioAttributes from |
| * @return a new AudioAttributes created from the data in the parcel |
| */ |
| public AudioAttributes createFromParcel(Parcel p) { |
| return new AudioAttributes(p); |
| } |
| public AudioAttributes[] newArray(int size) { |
| return new AudioAttributes[size]; |
| } |
| }; |
| |
| /** @hide */ |
| @Override |
| public String toString () { |
| return new String("AudioAttributes:" |
| + " usage=" + mUsage |
| + " content=" + mContentType |
| + " flags=0x" + Integer.toHexString(mFlags).toUpperCase() |
| + " tags=" + mTags); |
| } |
| |
| /** @hide */ |
| public String usageToString() { |
| return usageToString(mUsage); |
| } |
| |
| /** @hide */ |
| public static String usageToString(int usage) { |
| switch(usage) { |
| case USAGE_UNKNOWN: |
| return new String("USAGE_UNKNOWN"); |
| case USAGE_MEDIA: |
| return new String("USAGE_MEDIA"); |
| case USAGE_VOICE_COMMUNICATION: |
| return new String("USAGE_VOICE_COMMUNICATION"); |
| case USAGE_VOICE_COMMUNICATION_SIGNALLING: |
| return new String("USAGE_VOICE_COMMUNICATION"); |
| case USAGE_ALARM: |
| return new String("USAGE_ALARM"); |
| case USAGE_NOTIFICATION: |
| return new String("USAGE_NOTIFICATION"); |
| case USAGE_NOTIFICATION_RINGTONE: |
| return new String("USAGE_NOTIFICATION"); |
| case USAGE_NOTIFICATION_COMMUNICATION_REQUEST: |
| return new String("USAGE_NOTIFICATION"); |
| case USAGE_NOTIFICATION_COMMUNICATION_INSTANT: |
| return new String("USAGE_NOTIFICATION_COMMUNICATION_INSTANT"); |
| case USAGE_NOTIFICATION_COMMUNICATION_DELAYED: |
| return new String("USAGE_NOTIFICATION_COMMUNICATION_DELAYED"); |
| case USAGE_NOTIFICATION_EVENT: |
| return new String("USAGE_NOTIFICATION_EVENT"); |
| case USAGE_ASSISTANCE_ACCESSIBILITY: |
| return new String("USAGE_ASSISTANCE_ACCESSIBILITY"); |
| case USAGE_ASSISTANCE_NAVIGATION_GUIDANCE: |
| return new String("USAGE_ASSISTANCE_NAVIGATION_GUIDANCE"); |
| case USAGE_ASSISTANCE_SONIFICATION: |
| return new String("USAGE_ASSISTANCE_SONIFICATION"); |
| case USAGE_GAME: |
| return new String("USAGE_GAME"); |
| default: |
| return new String("unknown usage " + usage); |
| } |
| } |
| |
| /** @hide */ |
| public static int usageForLegacyStreamType(int streamType) { |
| switch(streamType) { |
| case AudioSystem.STREAM_VOICE_CALL: |
| return USAGE_VOICE_COMMUNICATION; |
| case AudioSystem.STREAM_SYSTEM_ENFORCED: |
| case AudioSystem.STREAM_SYSTEM: |
| return USAGE_ASSISTANCE_SONIFICATION; |
| case AudioSystem.STREAM_RING: |
| return USAGE_NOTIFICATION_RINGTONE; |
| case AudioSystem.STREAM_MUSIC: |
| return USAGE_MEDIA; |
| case AudioSystem.STREAM_ALARM: |
| return USAGE_ALARM; |
| case AudioSystem.STREAM_NOTIFICATION: |
| return USAGE_NOTIFICATION; |
| case AudioSystem.STREAM_BLUETOOTH_SCO: |
| return USAGE_VOICE_COMMUNICATION; |
| case AudioSystem.STREAM_DTMF: |
| return USAGE_VOICE_COMMUNICATION_SIGNALLING; |
| case AudioSystem.STREAM_TTS: |
| return USAGE_ASSISTANCE_ACCESSIBILITY; |
| default: |
| return USAGE_UNKNOWN; |
| } |
| } |
| |
| /** @hide */ |
| public static int toLegacyStreamType(AudioAttributes aa) { |
| // flags to stream type mapping |
| if ((aa.getFlags() & FLAG_AUDIBILITY_ENFORCED) == FLAG_AUDIBILITY_ENFORCED) { |
| return AudioSystem.STREAM_SYSTEM_ENFORCED; |
| } |
| if ((aa.getFlags() & FLAG_SCO) == FLAG_SCO) { |
| return AudioSystem.STREAM_BLUETOOTH_SCO; |
| } |
| |
| // usage to stream type mapping |
| switch (aa.getUsage()) { |
| case USAGE_MEDIA: |
| case USAGE_GAME: |
| case USAGE_ASSISTANCE_ACCESSIBILITY: |
| case USAGE_ASSISTANCE_NAVIGATION_GUIDANCE: |
| return AudioSystem.STREAM_MUSIC; |
| case USAGE_ASSISTANCE_SONIFICATION: |
| return AudioSystem.STREAM_SYSTEM; |
| case USAGE_VOICE_COMMUNICATION: |
| return AudioSystem.STREAM_VOICE_CALL; |
| case USAGE_VOICE_COMMUNICATION_SIGNALLING: |
| return AudioSystem.STREAM_DTMF; |
| case USAGE_ALARM: |
| return AudioSystem.STREAM_ALARM; |
| case USAGE_NOTIFICATION_RINGTONE: |
| return AudioSystem.STREAM_RING; |
| case USAGE_NOTIFICATION: |
| case USAGE_NOTIFICATION_COMMUNICATION_REQUEST: |
| case USAGE_NOTIFICATION_COMMUNICATION_INSTANT: |
| case USAGE_NOTIFICATION_COMMUNICATION_DELAYED: |
| case USAGE_NOTIFICATION_EVENT: |
| return AudioSystem.STREAM_NOTIFICATION; |
| case USAGE_UNKNOWN: |
| default: |
| return AudioSystem.STREAM_MUSIC; |
| } |
| } |
| |
| /** @hide */ |
| @IntDef({ |
| USAGE_UNKNOWN, |
| USAGE_MEDIA, |
| USAGE_VOICE_COMMUNICATION, |
| USAGE_VOICE_COMMUNICATION_SIGNALLING, |
| USAGE_ALARM, |
| USAGE_NOTIFICATION, |
| USAGE_NOTIFICATION_RINGTONE, |
| USAGE_NOTIFICATION_COMMUNICATION_REQUEST, |
| USAGE_NOTIFICATION_COMMUNICATION_INSTANT, |
| USAGE_NOTIFICATION_COMMUNICATION_DELAYED, |
| USAGE_NOTIFICATION_EVENT, |
| USAGE_ASSISTANCE_ACCESSIBILITY, |
| USAGE_ASSISTANCE_NAVIGATION_GUIDANCE, |
| USAGE_ASSISTANCE_SONIFICATION, |
| USAGE_GAME |
| }) |
| @Retention(RetentionPolicy.SOURCE) |
| public @interface AttributeUsage {} |
| |
| /** @hide */ |
| @IntDef({ |
| CONTENT_TYPE_UNKNOWN, |
| CONTENT_TYPE_SPEECH, |
| CONTENT_TYPE_MUSIC, |
| CONTENT_TYPE_MOVIE, |
| CONTENT_TYPE_SONIFICATION |
| }) |
| @Retention(RetentionPolicy.SOURCE) |
| public @interface AttributeContentType {} |
| } |