AudioTrack

DUAL_MONO_MODE_LL

static val DUAL_MONO_MODE_LL: Int

This mode indicates that a stereo stream should be presented with the left audio channel replicated into the right audio channel. Behavior for non-stereo streams is implementation defined. A suggested guideline is that all channels with left-right stereo symmetry will have the left channel position replicated into the right channel position. The center channels (with no left/right symmetry) or unbalanced channels are left alone. The Dual Mono effect occurs before volume scaling.

Value: 2

DUAL_MONO_MODE_LR

static val DUAL_MONO_MODE_LR: Int

This mode indicates that a stereo stream should be presented with the left and right audio channels blended together and delivered to both channels. Behavior for non-stereo streams is implementation defined. A suggested guideline is that the left-right stereo symmetric channels are pairwise blended; the other channels such as center are left alone. The Dual Mono effect occurs before volume scaling.

Value: 1

DUAL_MONO_MODE_OFF

static val DUAL_MONO_MODE_OFF: Int

This mode disables any Dual Mono presentation effect.

Value: 0

DUAL_MONO_MODE_RR

static val DUAL_MONO_MODE_RR: Int

This mode indicates that a stereo stream should be presented with the right audio channel replicated into the left audio channel. Behavior for non-stereo streams is implementation defined. A suggested guideline is that all channels with left-right stereo symmetry will have the right channel position replicated into the left channel position. The center channels (with no left/right symmetry) or unbalanced channels are left alone. The Dual Mono effect occurs before volume scaling.

Value: 3

ENCAPSULATION_METADATA_TYPE_DVB_AD_DESCRIPTOR

static val ENCAPSULATION_METADATA_TYPE_DVB_AD_DESCRIPTOR: Int

Encapsulation metadata type for DVB AD descriptor. This metadata is formatted per ETSI TS 101 154 Table E.1: AD_descriptor.

Value: 2

ENCAPSULATION_METADATA_TYPE_FRAMEWORK_TUNER

static val ENCAPSULATION_METADATA_TYPE_FRAMEWORK_TUNER: Int

Encapsulation metadata type for framework tuner information. Refer to the Android Media TV Tuner API for details.

Value: 1

ENCAPSULATION_METADATA_TYPE_SUPPLEMENTARY_AUDIO_PLACEMENT

static val ENCAPSULATION_METADATA_TYPE_SUPPLEMENTARY_AUDIO_PLACEMENT: Int

Encapsulation metadata type for placement of supplementary audio. A 32 bit integer constant, one of SUPPLEMENTARY_AUDIO_PLACEMENT_NORMAL, SUPPLEMENTARY_AUDIO_PLACEMENT_LEFT, SUPPLEMENTARY_AUDIO_PLACEMENT_RIGHT.

Value: 3

ENCAPSULATION_MODE_ELEMENTARY_STREAM

static val ENCAPSULATION_MODE_ELEMENTARY_STREAM: Int

This mode indicates metadata encapsulation with an elementary stream payload. Both compressed and PCM format is allowed.

Value: 1

ENCAPSULATION_MODE_NONE

static val ENCAPSULATION_MODE_NONE: Int

This mode indicates no metadata encapsulation, which is the default mode for sending audio data through AudioTrack.

Value: 0

ERROR

static val ERROR: Int

Denotes a generic operation failure.

Value: -1

ERROR_BAD_VALUE

static val ERROR_BAD_VALUE: Int

Denotes a failure due to the use of an invalid value.

Value: -2

ERROR_DEAD_OBJECT

static val ERROR_DEAD_OBJECT: Int

An error code indicating that the object reporting it is no longer valid and needs to be recreated.

Value: -6

ERROR_INVALID_OPERATION

static val ERROR_INVALID_OPERATION: Int

Denotes a failure due to the improper use of a method.

Value: -3

MODE_STATIC

static val MODE_STATIC: Int

Creation mode where audio data is transferred from Java to the native layer only once before the audio starts playing.

Value: 0

MODE_STREAM

static val MODE_STREAM: Int

Creation mode where audio data is streamed from Java to the native layer as the audio is playing.

Value: 1

PERFORMANCE_MODE_LOW_LATENCY

static val PERFORMANCE_MODE_LOW_LATENCY: Int

Low latency performance mode for an AudioTrack. If the device supports it, this mode enables a lower latency path through to the audio output sink. Effects may no longer work with such an AudioTrack and the sample rate must match that of the output sink.

Applications should be aware that low latency requires careful buffer management, with smaller chunks of audio data written by each write() call.

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 setBufferSizeInFrames(int). The buffer size can be optimized by lowering it after each write() call until the audio glitches, which is detected by calling 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.

Value: 1

PERFORMANCE_MODE_NONE

static val PERFORMANCE_MODE_NONE: Int

Default performance mode for an AudioTrack.

Value: 0

PERFORMANCE_MODE_POWER_SAVING

static val PERFORMANCE_MODE_POWER_SAVING: Int

Power saving performance mode for an AudioTrack. If the device supports it, this mode will enable a lower power path to the audio output sink. In addition, this lower power path typically will have deeper internal buffers and better underrun resistance, with a tradeoff of higher latency.

In this mode, applications should attempt to use a larger buffer size and deliver larger chunks of audio data per write() call. Use getBufferSizeInFrames() to determine the actual buffer size of the AudioTrack as it may have increased to accommodate a deeper buffer.

Value: 2

PLAYSTATE_PAUSED

static val PLAYSTATE_PAUSED: Int

indicates AudioTrack state is paused

Value: 2

PLAYSTATE_PLAYING

static val PLAYSTATE_PLAYING: Int

indicates AudioTrack state is playing

Value: 3

PLAYSTATE_STOPPED

static val PLAYSTATE_STOPPED: Int

indicates AudioTrack state is stopped

Value: 1

STATE_INITIALIZED

static val STATE_INITIALIZED: Int

State of an AudioTrack that is ready to be used.

Value: 1

STATE_NO_STATIC_DATA

static val STATE_NO_STATIC_DATA: Int

State of a successfully initialized AudioTrack that uses static data, but that hasn't received that data yet.

Value: 2

STATE_UNINITIALIZED

static val STATE_UNINITIALIZED: Int

State of an AudioTrack that was not successfully initialized upon creation.

Value: 0

SUCCESS

static val SUCCESS: Int

Denotes a successful operation.

Value: 0

SUPPLEMENTARY_AUDIO_PLACEMENT_LEFT

static val SUPPLEMENTARY_AUDIO_PLACEMENT_LEFT: Int

Supplementary audio placement left.

Value: 1

SUPPLEMENTARY_AUDIO_PLACEMENT_NORMAL

static val SUPPLEMENTARY_AUDIO_PLACEMENT_NORMAL: Int

Supplementary audio placement normal.

Value: 0

SUPPLEMENTARY_AUDIO_PLACEMENT_RIGHT

static val SUPPLEMENTARY_AUDIO_PLACEMENT_RIGHT: Int

Supplementary audio placement right.

Value: 2

WRITE_BLOCKING

static val WRITE_BLOCKING: Int

The write mode indicating the write operation will block until all data has been written, to be used as the actual value of the writeMode parameter in write(byte[],int,int,int), write(short[],int,int,int), write(float[],int,int,int), write(java.nio.ByteBuffer,int,int), and write(java.nio.ByteBuffer,int,int,long).

Value: 0

WRITE_NON_BLOCKING

static val WRITE_NON_BLOCKING: Int

The write mode indicating the write operation will return immediately after queuing as much audio data for playback as possible without blocking, to be used as the actual value of the writeMode parameter in write(java.nio.ByteBuffer,int,int), write(short[],int,int,int), write(float[],int,int,int), write(java.nio.ByteBuffer,int,int), and write(java.nio.ByteBuffer,int,int,long).

Value: 1

AudioTrack

AudioTrack(
    streamType: Int, 
    sampleRateInHz: Int, 
    channelConfig: Int, 
    audioFormat: Int, 
    bufferSizeInBytes: Int, 
    mode: Int)

Deprecated: use Builder or AudioTrack(android.media.AudioAttributes,android.media.AudioFormat,int,int,int) to specify the AudioAttributes instead of the stream type which is only for volume control.

Class constructor.

AudioTrack

AudioTrack(
    streamType: Int, 
    sampleRateInHz: Int, 
    channelConfig: Int, 
    audioFormat: Int, 
    bufferSizeInBytes: Int, 
    mode: Int, 
    sessionId: Int)

Deprecated: use Builder or AudioTrack(android.media.AudioAttributes,android.media.AudioFormat,int,int,int) to specify the AudioAttributes instead of the stream type which is only for volume control.

Class constructor with audio session. Use this constructor when the AudioTrack must be attached to a particular audio session. The primary use of the audio session ID is to associate audio effects to a particular instance of AudioTrack: if an audio session ID is provided when creating an AudioEffect, this effect will be applied only to audio tracks and media players in the same session and not to the output mix. When an AudioTrack is created without specifying a session, it will create its own session which can be retrieved by calling the getAudioSessionId() method. If a non-zero session ID is provided, this AudioTrack will share effects attached to this session with all other media players or audio tracks in the same session, otherwise a new session will be created for this track if none is supplied.

AudioTrack

AudioTrack(
    attributes: AudioAttributes!, 
    format: AudioFormat!, 
    bufferSizeInBytes: Int, 
    mode: Int, 
    sessionId: Int)

Class constructor with AudioAttributes and AudioFormat.

addOnCodecFormatChangedListener

open fun addOnCodecFormatChangedListener(
    executor: Executor, 
    listener: AudioTrack.OnCodecFormatChangedListener
): Unit

Adds an OnCodecFormatChangedListener to receive notifications of codec format change events on this AudioTrack.

addOnRoutingChangedListener

open fun addOnRoutingChangedListener(
    listener: AudioRouting.OnRoutingChangedListener!, 
    handler: Handler!
): Unit

Adds an AudioRouting.OnRoutingChangedListener to receive notifications of routing changes on this AudioTrack.

addOnRoutingChangedListener

open fun addOnRoutingChangedListener(
    listener: AudioTrack.OnRoutingChangedListener!, 
    handler: Handler!
): Unit

Deprecated: users should switch to the general purpose AudioRouting.OnRoutingChangedListener class instead.

Adds an OnRoutingChangedListener to receive notifications of routing changes on this AudioTrack.

attachAuxEffect

open fun attachAuxEffect(effectId: Int): Int

Attaches an auxiliary effect to the audio track. A typical auxiliary effect is a reverberation effect which can be applied on any sound source that directs a certain amount of its energy to this effect. This amount is defined by setAuxEffectSendLevel(). {@see #setAuxEffectSendLevel(float)}.

After creating an auxiliary effect (e.g. android.media.audiofx.EnvironmentalReverb), retrieve its ID with android.media.audiofx.AudioEffect#getId() and use it when calling this method to attach the audio track to the effect.

To detach the effect from the audio track, call this method with a null effect id.

createVolumeShaper

open fun createVolumeShaper(configuration: VolumeShaper.Configuration): VolumeShaper

Returns a VolumeShaper object that can be used modify the volume envelope of the player or track.

flush

open fun flush(): Unit

Flushes the audio data currently queued for playback. Any data that has been written but not yet presented will be discarded. No-op if not stopped or paused, or if the track's creation mode is not MODE_STREAM.
Note that although data written but not yet presented is discarded, there is no guarantee that all of the buffer space formerly used by that data is available for a subsequent write. For example, a call to write(byte[],int,int) with sizeInBytes less than or equal to the total buffer size may return a short actual transfer count.

getAudioAttributes

open fun getAudioAttributes(): AudioAttributes

Returns the AudioAttributes used in configuration. If a streamType is used instead of an AudioAttributes to configure the AudioTrack (the use of streamType for configuration is deprecated), then the AudioAttributes equivalent to the streamType is returned.

getAudioDescriptionMixLeveldB

open fun getAudioDescriptionMixLeveldB(): Float

Returns the Audio Description mix level in dB. If Audio Description mixing is unavailable from the hardware device, a value of Float.NEGATIVE_INFINITY is returned.

getAudioFormat

open fun getAudioFormat(): Int

Returns the configured audio data encoding. See AudioFormat#ENCODING_PCM_8BIT, AudioFormat#ENCODING_PCM_16BIT, and AudioFormat#ENCODING_PCM_FLOAT.

getAudioSessionId

open fun getAudioSessionId(): Int

Returns the audio session ID.

getBufferCapacityInFrames

open fun getBufferCapacityInFrames(): Int

Returns the maximum size of the AudioTrack buffer in frames.

If the track's creation mode is MODE_STATIC, it is equal to the specified bufferSizeInBytes on construction, converted to frame units. A static track's frame count will not change.

If the track's creation mode is MODE_STREAM, it is greater than or equal to the specified bufferSizeInBytes converted to frame units. For streaming tracks, this value may be rounded up to a larger value if needed by the target output sink, and if the track is subsequently routed to a different output sink, the frame count may enlarge to accommodate.

If the AudioTrack encoding indicates compressed data, e.g. AudioFormat#ENCODING_AC3, then the frame count returned is the size of the AudioTrack buffer in bytes.

See also AudioManager#getProperty(String) for key AudioManager#PROPERTY_OUTPUT_FRAMES_PER_BUFFER.

getBufferSizeInFrames

open fun getBufferSizeInFrames(): Int

Returns the effective size of the AudioTrack buffer that the application writes to.

This will be less than or equal to the result of getBufferCapacityInFrames(). It will be equal if setBufferSizeInFrames(int) has never been called.

If the track is subsequently routed to a different output sink, the buffer size and capacity may enlarge to accommodate.

If the AudioTrack encoding indicates compressed data, e.g. AudioFormat#ENCODING_AC3, then the frame count returned is the size of the AudioTrack buffer in bytes.

See also AudioManager#getProperty(String) for key AudioManager#PROPERTY_OUTPUT_FRAMES_PER_BUFFER.

getChannelConfiguration

open fun getChannelConfiguration(): Int

Returns the configured channel position mask.

For example, refer to AudioFormat#CHANNEL_OUT_MONO, AudioFormat#CHANNEL_OUT_STEREO, AudioFormat#CHANNEL_OUT_5POINT1. This method may return AudioFormat#CHANNEL_INVALID if a channel index mask was used. Consider getFormat() instead, to obtain an AudioFormat, which contains both the channel position mask and the channel index mask.

getChannelCount

open fun getChannelCount(): Int

Returns the configured number of channels.

getDualMonoMode

open fun getDualMonoMode(): Int

Returns the Dual Mono mode presentation setting. If no Dual Mono presentation is available for the output device, then DUAL_MONO_MODE_OFF is returned.

getFormat

open fun getFormat(): AudioFormat

Returns the configured AudioTrack format.

getLogSessionId

open fun getLogSessionId(): LogSessionId

Returns the LogSessionId.

getMaxVolume

open static fun getMaxVolume(): Float

Returns the maximum gain value, which is greater than or equal to 1.0. Gain values greater than the maximum will be clamped to the maximum.

The word "volume" in the API name is historical; this is actually a gain. expressed as a linear multiplier on sample values, where a maximum value of 1.0 corresponds to a gain of 0 dB (sample values left unmodified).

getMetrics

open fun getMetrics(): PersistableBundle!

Return Metrics data about the current AudioTrack instance.

getMinBufferSize

open static fun getMinBufferSize(
    sampleRateInHz: Int, 
    channelConfig: Int, 
    audioFormat: Int
): Int

Returns the estimated minimum buffer size required for an AudioTrack object to be created in the MODE_STREAM mode. The size is an estimate because it does not consider either the route or the sink, since neither is known yet. Note that this size doesn't guarantee a smooth playback under load, and higher values should be chosen according to the expected frequency at which the buffer will be refilled with additional data to play. For example, if you intend to dynamically set the source sample rate of an AudioTrack to a higher value than the initial source sample rate, be sure to configure the buffer size based on the highest planned sample rate.

getMinVolume

open static fun getMinVolume(): Float

Returns the minimum gain value, which is the constant 0.0. Gain values less than 0.0 will be clamped to 0.0.

The word "volume" in the API name is historical; this is actually a linear gain.

getNativeOutputSampleRate

open static fun getNativeOutputSampleRate(streamType: Int): Int

Returns the output sample rate in Hz for the specified stream type.

getNotificationMarkerPosition

open fun getNotificationMarkerPosition(): Int

Returns marker position expressed in frames.

getOffloadDelay

open fun getOffloadDelay(): Int

Return the decoder delay of an offloaded track, expressed in frames, previously set with setOffloadDelayPadding(int,int), or 0 if it was never modified.

This delay indicates the number of frames to be ignored at the beginning of the stream. This value can only be queried on a track successfully initialized with AudioTrack.Builder#setOffloadedPlayback(boolean).

getOffloadPadding

open fun getOffloadPadding(): Int

Return the decoder padding of an offloaded track, expressed in frames, previously set with setOffloadDelayPadding(int,int), or 0 if it was never modified.

This padding indicates the number of frames to be ignored at the end of the stream. This value can only be queried on a track successfully initialized with AudioTrack.Builder#setOffloadedPlayback(boolean).

getPerformanceMode

open fun getPerformanceMode(): Int

Returns the current performance mode of the AudioTrack.

getPlayState

open fun getPlayState(): Int

Returns the playback state of the AudioTrack instance.

getPlaybackHeadPosition

open fun getPlaybackHeadPosition(): Int

Returns the playback head position expressed in frames. Though the "int" type is signed 32-bits, the value should be reinterpreted as if it is unsigned 32-bits. That is, the next position after 0x7FFFFFFF is (int) 0x80000000. This is a continuously advancing counter. It will wrap (overflow) periodically, for example approximately once every 27:03:11 hours:minutes:seconds at 44.1 kHz. It is reset to zero by flush(), reloadStaticData(), and stop(). If the track's creation mode is MODE_STATIC, the return value indicates the total number of frames played since reset, not the current offset within the buffer.

getPlaybackParams

open fun getPlaybackParams(): PlaybackParams

Returns the current playback parameters. See setPlaybackParams(android.media.PlaybackParams) to set playback parameters

getPlaybackRate

open fun getPlaybackRate(): Int

Returns the current playback sample rate rate in Hz.

getPositionNotificationPeriod

open fun getPositionNotificationPeriod(): Int

Returns the notification update period expressed in frames. Zero means that no position update notifications are being delivered.

getPreferredDevice

open fun getPreferredDevice(): AudioDeviceInfo!

Returns the selected output specified by setPreferredDevice. Note that this is not guaranteed to correspond to the actual device being used for playback.

getRoutedDevice

open fun getRoutedDevice(): AudioDeviceInfo!

Returns an AudioDeviceInfo identifying the current routing of this AudioTrack. Note: The query is only valid if the AudioTrack is currently playing. If it is not, getRoutedDevice() will return null.

getSampleRate

open fun getSampleRate(): Int

Returns the configured audio source sample rate in Hz. The initial source sample rate depends on the constructor parameters, but the source sample rate may change if setPlaybackRate(int) is called. If the constructor had a specific sample rate, then the initial sink sample rate is that value. If the constructor had AudioFormat#SAMPLE_RATE_UNSPECIFIED, then the initial sink sample rate is a route-dependent default value based on the source [sic].

getStartThresholdInFrames

open fun getStartThresholdInFrames(): Int

Returns the streaming start threshold of the AudioTrack.

The streaming start threshold is the buffer level that the written audio data must reach for audio streaming to start after play() is called. When an AudioTrack is created, the streaming start threshold is the buffer capacity in frames. If the buffer size in frames is reduced by setBufferSizeInFrames(int) to a value smaller than the start threshold then that value will be used instead for the streaming start threshold.

For compressed streams, the size of a frame is considered to be exactly one byte.

getState

open fun getState(): Int

Returns the state of the AudioTrack instance. This is useful after the AudioTrack instance has been created to check if it was initialized properly. This ensures that the appropriate resources have been acquired.

getStreamType

open fun getStreamType(): Int

Returns the volume stream type of this AudioTrack. Compare the result against AudioManager#STREAM_VOICE_CALL, AudioManager#STREAM_SYSTEM, AudioManager#STREAM_RING, AudioManager#STREAM_MUSIC, AudioManager#STREAM_ALARM, AudioManager#STREAM_NOTIFICATION, AudioManager#STREAM_DTMF or AudioManager#STREAM_ACCESSIBILITY.

getTimestamp

open fun getTimestamp(timestamp: AudioTimestamp!): Boolean

Poll for a timestamp on demand.

If you need to track timestamps during initial warmup or after a routing or mode change, you should request a new timestamp periodically until the reported timestamps show that the frame position is advancing, or until it becomes clear that timestamps are unavailable for this route.

After the clock is advancing at a stable rate, query for a new timestamp approximately once every 10 seconds to once per minute. Calling this method more often is inefficient. It is also counter-productive to call this method more often than recommended, because the short-term differences between successive timestamp reports are not meaningful. If you need a high-resolution mapping between frame position and presentation time, consider implementing that at application level, based on low-resolution timestamps.

The audio data at the returned position may either already have been presented, or may have not yet been presented but is committed to be presented. It is not possible to request the time corresponding to a particular position, or to request the (fractional) position corresponding to a particular time. If you need such features, consider implementing them at application level.

getUnderrunCount

open fun getUnderrunCount(): Int

Returns the number of underrun occurrences in the application-level write buffer since the AudioTrack was created. An underrun occurs if the application does not write audio data quickly enough, causing the buffer to underflow and a potential audio glitch or pop.

Underruns are less likely when buffer sizes are large. It may be possible to eliminate underruns by recreating the AudioTrack with a larger buffer. Or by using setBufferSizeInFrames(int) to dynamically increase the effective size of the buffer.

isDirectPlaybackSupported

open static fun isDirectPlaybackSupported(
    format: AudioFormat, 
    attributes: AudioAttributes
): Boolean

Deprecated: Use AudioManager#getDirectPlaybackSupport(AudioFormat, AudioAttributes) instead.

Returns whether direct playback of an audio format with the provided attributes is currently supported on the system.

Direct playback means that the audio stream is not resampled or downmixed by the framework. Checking for direct support can help the app select the representation of audio content that most closely matches the capabilities of the device and peripherials (e.g. A/V receiver) connected to it. Note that the provided stream can still be re-encoded or mixed with other streams, if needed.

Also note that this query only provides information about the support of an audio format. It does not indicate whether the resources necessary for the playback are available at that instant.

isOffloadedPlayback

open fun isOffloadedPlayback(): Boolean

Returns whether the track was built with Builder#setOffloadedPlayback(boolean) set to true.

pause

open fun pause(): Unit

Pauses the playback of the audio data. Data that has not been played back will not be discarded. Subsequent calls to play will play this data back. See flush() to discard this data.

play

open fun play(): Unit

Starts playing an AudioTrack.

If track's creation mode is MODE_STATIC, you must have called one of the write methods (write(byte[],int,int), write(byte[],int,int,int), write(short[],int,int), write(short[],int,int,int), write(float[],int,int,int), or write(java.nio.ByteBuffer,int,int)) prior to play().

If the mode is MODE_STREAM, you can optionally prime the data path prior to calling play(), by writing up to bufferSizeInBytes (from constructor). If you don't call write() first, or if you call write() but with an insufficient amount of data, then the track will be in underrun state at play(). In this case, playback will not actually start playing until the data path is filled to a device-specific minimum level. This requirement for the path to be filled to a minimum level is also true when resuming audio playback after calling stop(). Similarly the buffer will need to be filled up again after the track underruns due to failure to call write() in a timely manner with sufficient data. For portability, an application should prime the data path to the maximum allowed by writing data until the write() method returns a short transfer count. This allows play() to start immediately, and reduces the chance of underrun.

As of android.os.Build.VERSION_CODES#S the minimum level to start playing can be obtained using getStartThresholdInFrames() and set with setStartThresholdInFrames(int).

registerStreamEventCallback

open fun registerStreamEventCallback(
    executor: Executor, 
    eventCallback: AudioTrack.StreamEventCallback
): Unit

Registers a callback for the notification of stream events. This callback can only be registered for instances operating in offloaded mode (see AudioTrack.Builder#setOffloadedPlayback(boolean) and AudioManager#isOffloadedPlaybackSupported(AudioFormat,AudioAttributes) for more details).

release

open fun release(): Unit

Releases the native AudioTrack resources.

reloadStaticData

open fun reloadStaticData(): Int

Sets the playback head position within the static buffer to zero, that is it rewinds to start of static buffer. The track must be stopped or paused, and the track's creation mode must be MODE_STATIC.

As of android.os.Build.VERSION_CODES#M, also resets the value returned by getPlaybackHeadPosition() to zero. For earlier API levels, the reset behavior is unspecified.

Use setPlaybackHeadPosition(int) with a zero position if the reset of getPlaybackHeadPosition() is not needed.

removeOnCodecFormatChangedListener

open fun removeOnCodecFormatChangedListener(listener: AudioTrack.OnCodecFormatChangedListener): Unit

Removes an OnCodecFormatChangedListener which has been previously added to receive codec format change events.

removeOnRoutingChangedListener

open fun removeOnRoutingChangedListener(listener: AudioRouting.OnRoutingChangedListener!): Unit

Removes an AudioRouting.OnRoutingChangedListener which has been previously added to receive rerouting notifications.

removeOnRoutingChangedListener

open fun removeOnRoutingChangedListener(listener: AudioTrack.OnRoutingChangedListener!): Unit

Deprecated: users should switch to the general purpose AudioRouting.OnRoutingChangedListener class instead.

Removes an OnRoutingChangedListener which has been previously added to receive rerouting notifications.

setAudioDescriptionMixLeveldB

open fun setAudioDescriptionMixLeveldB(level: Float): Boolean

Sets the Audio Description mix level in dB. For AudioTracks incorporating a secondary Audio Description stream (where such contents may be sent through an Encapsulation Mode other than ENCAPSULATION_MODE_NONE). or internally by a HW channel), the level of mixing of the Audio Description to the Main Audio stream is controlled by this method. Such mixing occurs prior to overall volume scaling.

setAuxEffectSendLevel

open fun setAuxEffectSendLevel(level: Float): Int

Sets the send level of the audio track to the attached auxiliary effect attachAuxEffect(int). Effect levels are clamped to the closed interval [0.0, max] where max is the value of getMaxVolume. A value of 0.0 results in no effect, and a value of 1.0 is full send.

By default the send level is 0.0f, so even if an effect is attached to the player this method must be called for the effect to be applied.

Note that the passed level value is a linear scalar. UI controls should be scaled logarithmically: the gain applied by audio framework ranges from -72dB to at least 0dB, so an appropriate conversion from linear UI input x to level is: x == 0 -> level = 0 0 < x <= R -> level = 10^(72*(x-R)/20/R)

setBufferSizeInFrames

open fun setBufferSizeInFrames(bufferSizeInFrames: Int): Int

Limits the effective size of the AudioTrack buffer that the application writes to.

A write to this AudioTrack will not fill the buffer beyond this limit. If a blocking write is used then the write will block until the data can fit within this limit.

Changing this limit modifies the latency associated with the buffer for this track. A smaller size will give lower latency but there may be more glitches due to buffer underruns.

The actual size used may not be equal to this requested size. It will be limited to a valid range with a maximum of getBufferCapacityInFrames(). It may also be adjusted slightly for internal reasons. If bufferSizeInFrames is less than zero then ERROR_BAD_VALUE will be returned.

This method is supported for PCM audio at all API levels. Compressed audio is supported in API levels 33 and above. For compressed streams the size of a frame is considered to be exactly one byte.

setDualMonoMode

open fun setDualMonoMode(dualMonoMode: Int): Boolean

Sets the Dual Mono mode presentation on the output device. The Dual Mono mode is generally applied to stereo audio streams where the left and right channels come from separate sources. For compressed audio, where the decoding is done in hardware, Dual Mono presentation needs to be performed by the hardware output device as the PCM audio is not available to the framework.

setLogSessionId

open fun setLogSessionId(logSessionId: LogSessionId): Unit

Sets a LogSessionId instance to this AudioTrack for metrics collection.

setLoopPoints

open fun setLoopPoints(
    startInFrames: Int, 
    endInFrames: Int, 
    loopCount: Int
): Int

Sets the loop points and the loop count. The loop can be infinite. Similarly to setPlaybackHeadPosition, the track must be stopped or paused for the loop points to be changed, and must use the MODE_STATIC mode.

setNotificationMarkerPosition

open fun setNotificationMarkerPosition(markerInFrames: Int): Int

Sets the position of the notification marker. At most one marker can be active.

setOffloadDelayPadding

open fun setOffloadDelayPadding(
    delayInFrames: Int, 
    paddingInFrames: Int
): Unit

Configures the delay and padding values for the current compressed stream playing in offload mode. This can only be used on a track successfully initialized with AudioTrack.Builder#setOffloadedPlayback(boolean). The unit is frames, where a frame indicates the number of samples per channel, e.g. 100 frames for a stereo compressed stream corresponds to 200 decoded interleaved PCM samples.

setOffloadEndOfStream

open fun setOffloadEndOfStream(): Unit

Declares that the last write() operation on this track provided the last buffer of this stream. After the end of stream, previously set padding and delay values are ignored. Can only be called only if the AudioTrack is opened in offload mode {@see Builder#setOffloadedPlayback(boolean)}. Can only be called only if the AudioTrack is in state PLAYSTATE_PLAYING {@see #getPlayState()}. Use this method in the same thread as any write() operation.

setPlaybackHeadPosition

open fun setPlaybackHeadPosition(positionInFrames: Int): Int

Sets the playback head position within the static buffer. The track must be stopped or paused for the position to be changed, and must use the MODE_STATIC mode.

setPlaybackParams

open fun setPlaybackParams(params: PlaybackParams): Unit

Sets the playback parameters. This method returns failure if it cannot apply the playback parameters. One possible cause is that the parameters for speed or pitch are out of range. Another possible cause is that the AudioTrack is streaming (see MODE_STREAM) and the buffer size is too small. For speeds greater than 1.0f, the AudioTrack buffer on configuration must be larger than the speed multiplied by the minimum size getMinBufferSize(int,int,int)) to allow proper playback.

setPlaybackPositionUpdateListener

open fun setPlaybackPositionUpdateListener(listener: AudioTrack.OnPlaybackPositionUpdateListener!): Unit

Sets the listener the AudioTrack notifies when a previously set marker is reached or for each periodic playback head position update. Notifications will be received in the same thread as the one in which the AudioTrack instance was created.

setPlaybackPositionUpdateListener

open fun setPlaybackPositionUpdateListener(
    listener: AudioTrack.OnPlaybackPositionUpdateListener!, 
    handler: Handler!
): Unit

Sets the listener the AudioTrack notifies when a previously set marker is reached or for each periodic playback head position update. Use this method to receive AudioTrack events in the Handler associated with another thread than the one in which you created the AudioTrack instance.

setPlaybackRate

open fun setPlaybackRate(sampleRateInHz: Int): Int

Sets the playback sample rate for this track. This sets the sampling rate at which the audio data will be consumed and played back (as set by the sampleRateInHz parameter in the AudioTrack(int,int,int,int,int,int) constructor), not the original sampling rate of the content. For example, setting it to half the sample rate of the content will cause the playback to last twice as long, but will also result in a pitch shift down by one octave. The valid sample rate range is from 1 Hz to twice the value returned by getNativeOutputSampleRate(int). Use setPlaybackParams(android.media.PlaybackParams) for speed control.

This method may also be used to repurpose an existing AudioTrack for playback of content of differing sample rate, but with identical encoding and channel mask.

setPositionNotificationPeriod

open fun setPositionNotificationPeriod(periodInFrames: Int): Int

Sets the period for the periodic notification event.

setPreferredDevice

open fun setPreferredDevice(deviceInfo: AudioDeviceInfo!): Boolean

Specifies an audio device (via an AudioDeviceInfo object) to route the output from this AudioTrack.

setPresentation

open fun setPresentation(presentation: AudioPresentation): Int

Sets the audio presentation. If the audio presentation is invalid then ERROR_BAD_VALUE will be returned. If a multi-stream decoder (MSD) is not present, or the format does not support multiple presentations, then ERROR_INVALID_OPERATION will be returned. ERROR is returned in case of any other error.

setStartThresholdInFrames

open fun setStartThresholdInFrames(startThresholdInFrames: Int): Int

Sets the streaming start threshold for an AudioTrack.

The streaming start threshold is the buffer level that the written audio data must reach for audio streaming to start after play() is called.

For compressed streams, the size of a frame is considered to be exactly one byte.

setStereoVolume

open fun setStereoVolume(
    leftGain: Float, 
    rightGain: Float
): Int

Deprecated: Applications should use setVolume instead, as it more gracefully scales down to mono, and up to multi-channel content beyond stereo.

Sets the specified left and right output gain values on the AudioTrack.

Gain values are clamped to the closed interval [0.0, max] where max is the value of getMaxVolume. A value of 0.0 results in zero gain (silence), and a value of 1.0 means unity gain (signal unchanged). The default value is 1.0 meaning unity gain.

The word "volume" in the API name is historical; this is actually a linear gain.

setVolume

open fun setVolume(gain: Float): Int

Sets the specified output gain value on all channels of this track.

Gain values are clamped to the closed interval [0.0, max] where max is the value of getMaxVolume. A value of 0.0 results in zero gain (silence), and a value of 1.0 means unity gain (signal unchanged). The default value is 1.0 meaning unity gain.

This API is preferred over setStereoVolume, as it more gracefully scales down to mono, and up to multi-channel content beyond stereo.

The word "volume" in the API name is historical; this is actually a linear gain.

stop

open fun stop(): Unit

Stops playing the audio data. When used on an instance created in MODE_STREAM mode, audio will stop playing after the last buffer that was written has been played. For an immediate stop, use pause(), followed by flush() to discard audio data that hasn't been played back yet.

unregisterStreamEventCallback

open fun unregisterStreamEventCallback(eventCallback: AudioTrack.StreamEventCallback): Unit

Unregisters the callback for notification of stream events, previously registered with registerStreamEventCallback(java.util.concurrent.Executor,android.media.AudioTrack.StreamEventCallback).

write

open fun write(
    audioData: ByteArray, 
    offsetInBytes: Int, 
    sizeInBytes: Int
): Int

Writes the audio data to the audio sink for playback (streaming mode), or copies audio data for later playback (static buffer mode). The format specified in the AudioTrack constructor should be AudioFormat#ENCODING_PCM_8BIT to correspond to the data in the array. The format can be AudioFormat#ENCODING_PCM_16BIT, but this is deprecated.

In streaming mode, the write will normally block until all the data has been enqueued for playback, and will return a full transfer count. However, if the track is stopped or paused on entry, or another thread interrupts the write by calling stop or pause, or an I/O error occurs during the write, then the write may return a short transfer count.

In static buffer mode, copies the data to the buffer starting at offset 0. Note that the actual playback of this data might occur after this function returns.

write

open fun write(
    audioData: ByteArray, 
    offsetInBytes: Int, 
    sizeInBytes: Int, 
    writeMode: Int
): Int

Writes the audio data to the audio sink for playback (streaming mode), or copies audio data for later playback (static buffer mode). The format specified in the AudioTrack constructor should be AudioFormat#ENCODING_PCM_8BIT to correspond to the data in the array. The format can be AudioFormat#ENCODING_PCM_16BIT, but this is deprecated.

In streaming mode, the blocking behavior depends on the write mode. If the write mode is WRITE_BLOCKING, the write will normally block until all the data has been enqueued for playback, and will return a full transfer count. However, if the write mode is WRITE_NON_BLOCKING, or the track is stopped or paused on entry, or another thread interrupts the write by calling stop or pause, or an I/O error occurs during the write, then the write may return a short transfer count.

In static buffer mode, copies the data to the buffer starting at offset 0, and the write mode is ignored. Note that the actual playback of this data might occur after this function returns.

write

open fun write(
    audioData: ShortArray, 
    offsetInShorts: Int, 
    sizeInShorts: Int
): Int

Writes the audio data to the audio sink for playback (streaming mode), or copies audio data for later playback (static buffer mode). The format specified in the AudioTrack constructor should be AudioFormat#ENCODING_PCM_16BIT to correspond to the data in the array.

In streaming mode, the write will normally block until all the data has been enqueued for playback, and will return a full transfer count. However, if the track is stopped or paused on entry, or another thread interrupts the write by calling stop or pause, or an I/O error occurs during the write, then the write may return a short transfer count.

In static buffer mode, copies the data to the buffer starting at offset 0. Note that the actual playback of this data might occur after this function returns.

write

open fun write(
    audioData: ShortArray, 
    offsetInShorts: Int, 
    sizeInShorts: Int, 
    writeMode: Int
): Int

Writes the audio data to the audio sink for playback (streaming mode), or copies audio data for later playback (static buffer mode). The format specified in the AudioTrack constructor should be AudioFormat#ENCODING_PCM_16BIT to correspond to the data in the array.

In streaming mode, the blocking behavior depends on the write mode. If the write mode is WRITE_BLOCKING, the write will normally block until all the data has been enqueued for playback, and will return a full transfer count. However, if the write mode is WRITE_NON_BLOCKING, or the track is stopped or paused on entry, or another thread interrupts the write by calling stop or pause, or an I/O error occurs during the write, then the write may return a short transfer count.

In static buffer mode, copies the data to the buffer starting at offset 0. Note that the actual playback of this data might occur after this function returns.

write

open fun write(
    audioData: FloatArray, 
    offsetInFloats: Int, 
    sizeInFloats: Int, 
    writeMode: Int
): Int

Writes the audio data to the audio sink for playback (streaming mode), or copies audio data for later playback (static buffer mode). The format specified in the AudioTrack constructor should be AudioFormat#ENCODING_PCM_FLOAT to correspond to the data in the array.

In streaming mode, the blocking behavior depends on the write mode. If the write mode is WRITE_BLOCKING, the write will normally block until all the data has been enqueued for playback, and will return a full transfer count. However, if the write mode is WRITE_NON_BLOCKING, or the track is stopped or paused on entry, or another thread interrupts the write by calling stop or pause, or an I/O error occurs during the write, then the write may return a short transfer count.

In static buffer mode, copies the data to the buffer starting at offset 0, and the write mode is ignored. Note that the actual playback of this data might occur after this function returns.

write

open fun write(
    audioData: ByteBuffer, 
    sizeInBytes: Int, 
    writeMode: Int
): Int

Writes the audio data to the audio sink for playback (streaming mode), or copies audio data for later playback (static buffer mode). The audioData in ByteBuffer should match the format specified in the AudioTrack constructor.

In streaming mode, the blocking behavior depends on the write mode. If the write mode is WRITE_BLOCKING, the write will normally block until all the data has been enqueued for playback, and will return a full transfer count. However, if the write mode is WRITE_NON_BLOCKING, or the track is stopped or paused on entry, or another thread interrupts the write by calling stop or pause, or an I/O error occurs during the write, then the write may return a short transfer count.

In static buffer mode, copies the data to the buffer starting at offset 0, and the write mode is ignored. Note that the actual playback of this data might occur after this function returns.

write

open fun write(
    audioData: ByteBuffer, 
    sizeInBytes: Int, 
    writeMode: Int, 
    timestamp: Long
): Int

Writes the audio data to the audio sink for playback in streaming mode on a HW_AV_SYNC track. The blocking behavior will depend on the write mode.

finalize

protected open fun finalize(): Unit

getNativeFrameCount

protected open fun getNativeFrameCount(): Int

Deprecated: Use the identical public method getBufferSizeInFrames() instead.

Returns the frame count of the native AudioTrack buffer.

setState

protected open fun setState(state: Int): Unit

Deprecated: Only accessible by subclasses, which are not recommended for AudioTrack.

Sets the initialization state of the instance. This method was originally intended to be used in an AudioTrack subclass constructor to set a subclass-specific post-initialization state. However, subclasses of AudioTrack are no longer recommended, so this method is obsolete.