/**@class android.media.AudioAttributes
 implements android.os.Parcelable

@extends java.lang.Object

 A class to encapsulate a collection of attributes describing information about an audio
 stream.
 <p><code>AudioAttributes</code> supersede the notion of stream types (see for instance
 {@link android.media.AudioManager#STREAM_MUSIC} or {@link android.media.AudioManager#STREAM_ALARM}) for defining the
 behavior of audio playback. Attributes allow an application to specify more information than is
 conveyed in a stream type by allowing the application to define:
 <ul>
 <li>usage: "why" you are playing a sound, what is this sound used for. This is achieved with
     the "usage" information. Examples of usage are {@link #USAGE_MEDIA} and {@link #USAGE_ALARM}.
     These two examples are the closest to stream types, but more detailed use cases are
     available. Usage information is more expressive than a stream type, and allows certain
     platforms or routing policies to use this information for more refined volume or routing
     decisions. Usage is the most important information to supply in <code>AudioAttributes</code>
     and it is recommended to build any instance with this information supplied, see
     {@link android.media.AudioAttributes.Builder} for exceptions.</li>
 <li>content type: "what" you are playing. The content type expresses the general category of
     the content. This information is optional. But in case it is known (for instance
     {@link #CONTENT_TYPE_MOVIE} for a movie streaming service or {@link #CONTENT_TYPE_MUSIC} for
     a music playback application) this information might be used by the audio framework to
     selectively configure some audio post-processing blocks.</li>
 <li>flags: "how" is playback to be affected, see the flag definitions for the specific playback
     behaviors they control. </li>
 </ul>
 <p><code>AudioAttributes</code> are used for example in one of the {@link android.media.AudioTrack}
 constructors (see {@link AudioTrack#AudioTrack(AudioAttributes, android.media.AudioFormat, int, int, int)}),
 to configure a {@link android.media.MediaPlayer}
 (see {@link android.media.MediaPlayer#setAudioAttributes(AudioAttributes)} or a
 {@link android.app.Notification} (see {@link android.app.Notification#audioAttributes}). An
 <code>AudioAttributes</code> instance is built through its builder,
 {@link android.media.AudioAttributes.Builder}.
*/
var AudioAttributes = {

/** Content type value to use when the content type is unknown, or other than the ones defined.
*/
CONTENT_TYPE_UNKNOWN : "0",
/** Content type value to use when the content type is speech.
*/
CONTENT_TYPE_SPEECH : "1",
/** Content type value to use when the content type is music.
*/
CONTENT_TYPE_MUSIC : "2",
/** Content type value to use when the content type is a soundtrack, typically accompanying
 a movie or TV program.
*/
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.
*/
CONTENT_TYPE_SONIFICATION : "4",
/** Usage value to use when the usage is unknown.
*/
USAGE_UNKNOWN : "0",
/** Usage value to use when the usage is media, such as music, or movie
 soundtracks.
*/
USAGE_MEDIA : "1",
/** Usage value to use when the usage is voice communications, such as telephony
 or VoIP.
*/
USAGE_VOICE_COMMUNICATION : "2",
/** Usage value to use when the usage is in-call signalling, such as with
 a "busy" beep, or DTMF tones.
*/
USAGE_VOICE_COMMUNICATION_SIGNALLING : "3",
/** Usage value to use when the usage is an alarm (e.g. wake-up alarm).
*/
USAGE_ALARM : "4",
/** Usage value to use when the usage is notification. See other
 notification usages for more specialized uses.
*/
USAGE_NOTIFICATION : "5",
/** Usage value to use when the usage is telephony ringtone.
*/
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.
*/
USAGE_NOTIFICATION_COMMUNICATION_REQUEST : "7",
/** Usage value to use when the usage is notification for an "instant"
 communication such as a chat, or SMS.
*/
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.
*/
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.
*/
USAGE_NOTIFICATION_EVENT : "10",
/** Usage value to use when the usage is for accessibility, such as with
 a screen reader.
*/
USAGE_ASSISTANCE_ACCESSIBILITY : "11",
/** Usage value to use when the usage is driving or navigation directions.
*/
USAGE_ASSISTANCE_NAVIGATION_GUIDANCE : "12",
/** Usage value to use when the usage is sonification, such as  with user
 interface sounds.
*/
USAGE_ASSISTANCE_SONIFICATION : "13",
/** Usage value to use when the usage is for game audio.
*/
USAGE_GAME : "14",
/** @hide
 Usage value to use when feeding audio to the platform and replacing "traditional" audio
 source, such as audio capture devices.
*/
USAGE_VIRTUAL_SOURCE : "15",
/** Usage value to use for audio responses to user queries, audio instructions or help
 utterances.
*/
USAGE_ASSISTANT : "16",
/** @hide
 Denotes a usage for notifications that do not expect immediate intervention from the user,
 will be muted when the Zen mode disables notifications
 @see #SUPPRESSIBLE_USAGES
*/
SUPPRESSIBLE_NOTIFICATION : "1",
/** @hide
 Denotes a usage for notifications that do expect immediate intervention from the user,
 will be muted when the Zen mode disables calls
 @see #SUPPRESSIBLE_USAGES
*/
SUPPRESSIBLE_CALL : "2",
/** @hide
 Denotes a usage that is never going to be muted, even in Total Silence.
 @see #SUPPRESSIBLE_USAGES
*/
SUPPRESSIBLE_NEVER : "3",
/** @hide
 Denotes a usage for alarms,
 will be muted when the Zen mode priority doesn't allow alarms or in Alarms Only Mode
 @see #SUPPRESSIBLE_USAGES
*/
SUPPRESSIBLE_ALARM : "4",
/** @hide
 Denotes a usage for media, game, assistant, and navigation
 will be muted when the Zen priority mode doesn't allow media
 @see #SUPPRESSIBLE_USAGES
*/
SUPPRESSIBLE_MEDIA : "5",
/** @hide
 Denotes a usage for sounds not caught in SUPPRESSIBLE_NOTIFICATION,
 SUPPRESSIBLE_CALL,SUPPRESSIBLE_NEVER, SUPPRESSIBLE_ALARM or SUPPRESSIBLE_MEDIA.
 This includes sonification sounds.
 These will be muted when the Zen priority mode doesn't allow system sounds
 @see #SUPPRESSIBLE_USAGES
*/
SUPPRESSIBLE_SYSTEM : "6",
/** @hide
 Array of all usage types for calls and notifications to assign the suppression behavior,
 used by the Zen mode restrictions.
 @see com.android.server.notification.ZenModeHelper
*/
SUPPRESSIBLE_USAGES : "null",
/** @hide
 Array of all usage types exposed in the SDK that applications can use.
*/
SDK_USAGES : "null",
/** Flag defining a behavior where the audibility of the sound will be ensured by the system.
*/
FLAG_AUDIBILITY_ENFORCED : "1",
/** @hide
 Flag defining a behavior where the playback of the sound is ensured without
 degradation only when going to a secure sink.
*/
FLAG_SECURE : "2",
/** @hide
 Flag to enable when the stream is associated with SCO usage.
 Internal use only for dealing with legacy STREAM_BLUETOOTH_SCO
*/
FLAG_SCO : "4",
/** @hide
 Flag defining a behavior where the system ensures that the playback of the sound will
 be compatible with its use as a broadcast for surrounding people and/or devices.
 Ensures audibility with no or minimal post-processing applied.
*/
FLAG_BEACON : "8",
/** Flag requesting the use of an output stream supporting hardware A/V synchronization.
*/
FLAG_HW_AV_SYNC : "16",
/** @hide
 Flag requesting capture from the source used for hardware hotword detection.
 To be used with capture preset MediaRecorder.AudioSource.HOTWORD or
 MediaRecorder.AudioSource.VOICE_RECOGNITION.
*/
FLAG_HW_HOTWORD : "32",
/** @hide
 Flag requesting audible playback even under limited interruptions.
*/
FLAG_BYPASS_INTERRUPTION_POLICY : "64",
/** @hide
 Flag requesting audible playback even when the underlying stream is muted.
*/
FLAG_BYPASS_MUTE : "128",
/** Flag requesting a low latency path when creating an AudioTrack.
 When using this flag, the sample rate must match the native sample rate
 of the device. Effects processing is also unavailable.

 Note that if this flag is used without specifying a bufferSizeInBytes then the
 AudioTrack's actual buffer size may be too small. It is recommended that a fairly
 large buffer should be specified when the AudioTrack is created.
 Then the actual size can be reduced by calling
 {@link android.media.AudioTrack#setBufferSizeInFrames(int)}. The buffer size can be optimized
 by lowering it after each write() call until the audio glitches, which is detected by calling
 {@link android.media.AudioTrack#getUnderrunCount()}. Then the buffer size can be increased
 until there are no glitches.
 This tuning step should be done while playing silence.
 This technique provides a compromise between latency and glitch rate.

 @deprecated Use {@link android.media.AudioTrack.Builder#setPerformanceMode(int)} with
 {@link android.media.AudioTrack#PERFORMANCE_MODE_LOW_LATENCY} to control performance.
*/
FLAG_LOW_LATENCY : "256",
/** @hide
 Flag requesting a deep buffer path when creating an {@code AudioTrack}.

 A deep buffer path, if available, may consume less power and is
 suitable for media playback where latency is not a concern.
 Use {@link android.media.AudioTrack.Builder#setPerformanceMode(int)} with
 {@link android.media.AudioTrack#PERFORMANCE_MODE_POWER_SAVING} to enable.
*/
FLAG_DEEP_BUFFER : "512",
/** @hide
 Flag specifying that the audio shall not be captured by third-party apps
 with a MediaProjection.
*/
FLAG_NO_MEDIA_PROJECTION : "1024",
/** @hide
 Flag indicating force muting haptic channels.
*/
FLAG_MUTE_HAPTIC : "2048",
/** @hide
 Flag specifying that the audio shall not be captured by any apps, not even system apps.
*/
FLAG_NO_SYSTEM_CAPTURE : "4096",
/** Indicates that the audio may be captured by any app.

 For privacy, the following usages cannot be recorded: VOICE_COMMUNICATION*,
 USAGE_NOTIFICATION*, USAGE_ASSISTANCE* and USAGE_ASSISTANT.

 On {@link android.os.Build.VERSION_CODES#Q}, this means only {@link #USAGE_UNKNOWN},
 {@link #USAGE_MEDIA} and {@link #USAGE_GAME} may be captured.

 See {@link android.media.projection.MediaProjection} and
 {@link android.media.AudioAttributes.Builder#setAllowedCapturePolicy}.
*/
ALLOW_CAPTURE_BY_ALL : "1",
/** Indicates that the audio may only be captured by system apps.

 System apps can capture for many purposes like accessibility, live captions, user guidance...
 but abide to the following restrictions:
  - the audio cannot leave the device
  - the audio cannot be passed to a third party app
  - the audio cannot be recorded at a higher quality than 16kHz 16bit mono

 See {@link android.media.AudioAttributes.Builder#setAllowedCapturePolicy}.
*/
ALLOW_CAPTURE_BY_SYSTEM : "2",
/** Indicates that the audio is not to be recorded by any app, even if it is a system app.

 It is encouraged to use {@link #ALLOW_CAPTURE_BY_SYSTEM} instead of this value as system apps
 provide significant and useful features for the user (such as live captioning
 and accessibility).

 See {@link android.media.AudioAttributes.Builder#setAllowedCapturePolicy}.
*/
ALLOW_CAPTURE_BY_NONE : "3",
/** @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
*/
FLATTEN_TAGS : "1",
/***/
CREATOR : "null",
/**Return the content type.
@return {Number} one of the values that can be set in {@link Builder#setContentType(int)}
*/
getContentType : function(  ) {},

/**Return the usage.
@return {Number} one of the values that can be set in {@link Builder#setUsage(int)}
*/
getUsage : function(  ) {},

/**
@hide Return the capture preset.
@return {Number} one of the values that can be set in {@link Builder#setCapturePreset(int)} or a
    negative value if none has been set.
*/
getCapturePreset : function(  ) {},

/**Return the flags.
@return {Number} a combined mask of all flags
*/
getFlags : function(  ) {},

/**
@hide Return all the flags, even the non-public ones.
 Internal use only
@return {Number} a combined mask of all flags
*/
getAllFlags : function(  ) {},

/**
@hide Return the Bundle of data.
@return {Object {android.os.Bundle}} a copy of the Bundle for this instance, may be null.
*/
getBundle : function(  ) {},

/**
@hide Return the set of tags.
@return {Object {java.util.Set}} a read-only set of all tags stored as strings.
*/
getTags : function(  ) {},

/**Return if haptic channels are muted.
@return {Boolean} {@code true} if haptic channels are muted, {@code false} otherwise.
*/
areHapticChannelsMuted : function(  ) {},

/**Return the capture policy.
@return {Number} the capture policy set by {@link Builder#setAllowedCapturePolicy(int)} or
         the default if it was not called.
*/
getAllowedCapturePolicy : function(  ) {},

/**
*/
describeContents : function(  ) {},

/**
*/
writeToParcel : function(  ) {},

/**
*/
equals : function(  ) {},

/**
*/
hashCode : function(  ) {},

/**
*/
toString : function(  ) {},

/**
@hide 
*/
writeToProto : function(  ) {},

/**
@hide 
*/
usageToString : function(  ) {},

/**
@hide 
*/
usageToString : function(  ) {},

/**
@hide 
*/
contentTypeToString : function(  ) {},

/**Returns the stream type matching this {@code AudioAttributes} instance for volume control.
 Use this method to derive the stream type needed to configure the volume
 control slider in an {@link android.app.Activity} with
 {@link android.app.Activity#setVolumeControlStream(int)} for playback conducted with these
 attributes.
 <BR>Do not use this method to set the stream type on an audio player object
 (e.g. {@link android.media.AudioTrack}, {@link android.media.MediaPlayer}) as this is deprecated,
 use {@code AudioAttributes} instead.
@return {Number} a valid stream type for {@code Activity} or stream volume control that matches
     the attributes, or {@link AudioManager#USE_DEFAULT_STREAM_TYPE} if there isn't a direct
     match. Note that {@code USE_DEFAULT_STREAM_TYPE} is not a valid value
     for {@link AudioManager#setStreamVolume(int, int, int)}.
*/
getVolumeControlStream : function(  ) {},

/**
@param {Object {AudioAttributes}} aa non-null AudioAttributes.
@param aa non-null AudioAttributes.
@return {Number} a valid stream type for volume control that matches the attributes.
*/
toLegacyStreamType : function(  ) {},


};