@ohos.multimedia.audio (Audio Management)

The Audio module provides basic audio management capabilities, including audio volume and audio device management, and audio data collection and rendering.

This module provides the following common audio-related functions:

• AudioManager: audio management.
• AudioRenderer: audio rendering, used to play Pulse Code Modulation (PCM) audio data.
• AudioCapturer: audio capture, used to record PCM audio data.

NOTE

The initial APIs of this module are supported since API version 7. Newly added APIs will be marked with a superscript to indicate their earliest API version.

Modules to Import

import audio from '@ohos.multimedia.audio';

Constants

Example

import audio from '@ohos.multimedia.audio';

const defaultVolumeGroupId = audio.DEFAULT_VOLUME_GROUP_ID;
const defaultInterruptGroupId = audio.DEFAULT_INTERRUPT_GROUP_ID;

audio.getAudioManager

getAudioManager(): AudioManager

Obtains an AudioManager instance.

System capability: SystemCapability.Multimedia.Audio.Core

Return value

Example

import audio from '@ohos.multimedia.audio';

let audioManager = audio.getAudioManager();

audio.createAudioRenderer⁸⁺

createAudioRenderer(options: AudioRendererOptions, callback: AsyncCallback<AudioRenderer>): void

Creates an AudioRenderer instance. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.Multimedia.Audio.Renderer

Parameters

Example

import audio from '@ohos.multimedia.audio';

let audioStreamInfo: audio.AudioStreamInfo = {
  samplingRate: audio.AudioSamplingRate.SAMPLE_RATE_44100,
  channels: audio.AudioChannel.CHANNEL_1,
  sampleFormat: audio.AudioSampleFormat.SAMPLE_FORMAT_S16LE,
  encodingType: audio.AudioEncodingType.ENCODING_TYPE_RAW
}

let audioRendererInfo: audio.AudioRendererInfo = {
  usage: audio.StreamUsage.STREAM_USAGE_VOICE_COMMUNICATION,
  rendererFlags: 0
}

let audioRendererOptions: audio.AudioRendererOptions = {
  streamInfo: audioStreamInfo,
  rendererInfo: audioRendererInfo
}

audio.createAudioRenderer(audioRendererOptions,(err, data) => {
  if (err) {
    console.error(`AudioRenderer Created: Error: ${err}`);
  } else {
    console.info('AudioRenderer Created: Success: SUCCESS');
    let audioRenderer = data;
  }
});

audio.createAudioRenderer⁸⁺

createAudioRenderer(options: AudioRendererOptions): Promise<AudioRenderer>

Creates an AudioRenderer instance. This API uses a promise to return the result.

System capability: SystemCapability.Multimedia.Audio.Renderer

Parameters

Return value

Example

import audio from '@ohos.multimedia.audio';
import { BusinessError } from '@ohos.base';

let audioStreamInfo: audio.AudioStreamInfo = {
  samplingRate: audio.AudioSamplingRate.SAMPLE_RATE_44100,
  channels: audio.AudioChannel.CHANNEL_1,
  sampleFormat: audio.AudioSampleFormat.SAMPLE_FORMAT_S16LE,
  encodingType: audio.AudioEncodingType.ENCODING_TYPE_RAW
}

let audioRendererInfo: audio.AudioRendererInfo = {
  usage: audio.StreamUsage.STREAM_USAGE_VOICE_COMMUNICATION,
  rendererFlags: 0
}

let audioRendererOptions: audio.AudioRendererOptions = {
  streamInfo: audioStreamInfo,
  rendererInfo: audioRendererInfo
}

let audioRenderer: audio.AudioRenderer;
audio.createAudioRenderer(audioRendererOptions).then((data) => {
  audioRenderer = data;
  console.info('AudioFrameworkRenderLog: AudioRenderer Created : Success : Stream Type: SUCCESS');
}).catch((err: BusinessError) => {
  console.error(`AudioFrameworkRenderLog: AudioRenderer Created : ERROR : ${err}`);
});

audio.createAudioCapturer⁸⁺

createAudioCapturer(options: AudioCapturerOptions, callback: AsyncCallback<AudioCapturer>): void

Creates an AudioCapturer instance. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.Multimedia.Audio.Capturer

Required permissions: ohos.permission.MICROPHONE

This permission is required only when SourceType is set to SOURCE_TYPE_MIC.

Parameters

Example

import audio from '@ohos.multimedia.audio';

let audioStreamInfo: audio.AudioStreamInfo = {
  samplingRate: audio.AudioSamplingRate.SAMPLE_RATE_44100,
  channels: audio.AudioChannel.CHANNEL_2,
  sampleFormat: audio.AudioSampleFormat.SAMPLE_FORMAT_S16LE,
  encodingType: audio.AudioEncodingType.ENCODING_TYPE_RAW
}

let audioCapturerInfo: audio.AudioCapturerInfo = {
  source: audio.SourceType.SOURCE_TYPE_MIC,
  capturerFlags: 0
}

let audioCapturerOptions: audio.AudioCapturerOptions = {
  streamInfo: audioStreamInfo,
  capturerInfo: audioCapturerInfo
}

audio.createAudioCapturer(audioCapturerOptions, (err, data) => {
  if (err) {
    console.error(`AudioCapturer Created : Error: ${err}`);
  } else {
    console.info('AudioCapturer Created : Success : SUCCESS');
    let audioCapturer = data;
  }
});

audio.createAudioCapturer⁸⁺

createAudioCapturer(options: AudioCapturerOptions): Promise<AudioCapturer>

Creates an AudioCapturer instance. This API uses a promise to return the result.

System capability: SystemCapability.Multimedia.Audio.Capturer

Required permissions: ohos.permission.MICROPHONE

This permission is required only when SourceType is set to SOURCE_TYPE_MIC.

Parameters

Return value

Example

import audio from '@ohos.multimedia.audio';
import { BusinessError } from '@ohos.base';

let audioStreamInfo: audio.AudioStreamInfo = {
  samplingRate: audio.AudioSamplingRate.SAMPLE_RATE_44100,
  channels: audio.AudioChannel.CHANNEL_2,
  sampleFormat: audio.AudioSampleFormat.SAMPLE_FORMAT_S16LE,
  encodingType: audio.AudioEncodingType.ENCODING_TYPE_RAW
}

let audioCapturerInfo: audio.AudioCapturerInfo = {
  source: audio.SourceType.SOURCE_TYPE_MIC,
  capturerFlags: 0
}

let audioCapturerOptions:audio.AudioCapturerOptions = {
  streamInfo: audioStreamInfo,
  capturerInfo: audioCapturerInfo
}

let audioCapturer: audio.AudioCapturer;
audio.createAudioCapturer(audioCapturerOptions).then((data) => {
  audioCapturer = data;
  console.info('AudioCapturer Created : Success : Stream Type: SUCCESS');
}).catch((err: BusinessError) => {
  console.error(`AudioCapturer Created : ERROR : ${err}`);
});

AudioVolumeType

Enumerates the audio stream types.

System capability: SystemCapability.Multimedia.Audio.Volume

InterruptMode⁹⁺

Enumerates the audio interruption modes.

System capability: SystemCapability.Multimedia.Audio.Interrupt

DeviceFlag

Enumerates the audio device flags.

System capability: SystemCapability.Multimedia.Audio.Device

DeviceRole

Enumerates the audio device roles.

System capability: SystemCapability.Multimedia.Audio.Device

DeviceType

Enumerates the audio device types.

System capability: SystemCapability.Multimedia.Audio.Device

CommunicationDeviceType⁹⁺

Enumerates the device types used for communication.

System capability: SystemCapability.Multimedia.Audio.Communication

AudioRingMode

Enumerates the ringer modes.

System capability: SystemCapability.Multimedia.Audio.Communication

AudioSampleFormat⁸⁺

Enumerates the audio sample formats.

System capability: SystemCapability.Multimedia.Audio.Core

AudioErrors⁹⁺

Enumerates the audio error codes.

System capability: SystemCapability.Multimedia.Audio.Core

AudioChannel⁸⁺

Enumerates the audio channels.

System capability: SystemCapability.Multimedia.Audio.Core

AudioSamplingRate⁸⁺

Enumerates the audio sampling rates. The sampling rates supported vary according to the device in use.

System capability: SystemCapability.Multimedia.Audio.Core

AudioEncodingType⁸⁺

Enumerates the audio encoding types.

System capability: SystemCapability.Multimedia.Audio.Core

AudioChannelLayout¹¹⁺

Enumerates the audio channel layouts.

System capability: SystemCapability.Multimedia.Audio.Core

ContentType^(deprecated)

Enumerates the audio content types.

NOTE This API is supported since API version 7 and deprecated since API version 10. You are advised to use StreamUsage instead.

System capability: SystemCapability.Multimedia.Audio.Core

StreamUsage

Enumerates the audio stream usage.

System capability: SystemCapability.Multimedia.Audio.Core

AudioState⁸⁺

Enumerates the audio states.

System capability: SystemCapability.Multimedia.Audio.Core

AudioEffectMode¹⁰⁺

Enumerates the audio effect modes.

System capability: SystemCapability.Multimedia.Audio.Renderer

AudioRendererRate⁸⁺

Enumerates the audio renderer rates.

System capability: SystemCapability.Multimedia.Audio.Renderer

InterruptType

Enumerates the audio interruption types.

System capability: SystemCapability.Multimedia.Audio.Renderer

InterruptForceType⁹⁺

Enumerates the types of force that causes audio interruption.

System capability: SystemCapability.Multimedia.Audio.Renderer

InterruptHint

Enumerates the hints provided along with audio interruption.

System capability: SystemCapability.Multimedia.Audio.Renderer

AudioStreamInfo⁸⁺

Describes audio stream information.

System capability: SystemCapability.Multimedia.Audio.Core

AudioRendererInfo⁸⁺

Describes audio renderer information.

System capability: SystemCapability.Multimedia.Audio.Core

AudioRendererOptions⁸⁺

Describes audio renderer configurations.

AudioPrivacyType¹⁰⁺

Enumerates whether an audio stream can be recorded by other applications.

System capability: SystemCapability.Multimedia.Audio.PlaybackCapture

InterruptEvent⁹⁺

Describes the interruption event received by the application when playback is interrupted.

System capability: SystemCapability.Multimedia.Audio.Renderer

VolumeEvent⁹⁺

Describes the event received by the application when the volume is changed.

System capability: SystemCapability.Multimedia.Audio.Volume

MicStateChangeEvent⁹⁺

Describes the event received by the application when the microphone mute status changes.

System capability: SystemCapability.Multimedia.Audio.Device

DeviceChangeAction

Describes the device connection status and device information.

System capability: SystemCapability.Multimedia.Audio.Device

ChannelBlendMode¹¹⁺

Enumerates the audio channel blending modes.

System capability: SystemCapability.Multimedia.Audio.Core

AudioStreamDeviceChangeReason¹¹⁺

Enumerates the reasons for audio stream device changes.

System capability: SystemCapability.Multimedia.Audio.Device

AudioStreamDeviceChangeInfo¹¹⁺

Describes the event received by the application when the audio stream device changes.

System capability: SystemCapability.Multimedia.Audio.Device

DeviceChangeType

Enumerates the device connection statuses.

System capability: SystemCapability.Multimedia.Audio.Device

AudioCapturerOptions⁸⁺

Describes audio capturer configurations.

AudioCapturerInfo⁸⁺

Describes audio capturer information.

System capability: SystemCapability.Multimedia.Audio.Core

SourceType⁸⁺

Enumerates the audio source types.

AudioPlaybackCaptureConfig¹⁰⁺

Defines the configuration of internal audio recording.

System capability: SystemCapability.Multimedia.Audio.PlaybackCapture

CaptureFilterOptions¹⁰⁺

Defines the options for filtering the played audio streams to be recorded.

Required permissions

• In API version 10, CaptureFilterOptions supports StreamUsage.STREAM_USAGE_VOICE_COMMUNICATION, and therefore the ohos.permission.CAPTURE_VOICE_DOWNLINK_AUDIO permission is required. Only system applications can request this permission.

• Since API version 11, CaptureFilterOptions does not support StreamUsage.STREAM_USAGE_VOICE_COMMUNICATION. Therefore, no permission is required for calling this API.

System capability: SystemCapability.Multimedia.Audio.PlaybackCapture

AudioScene⁸⁺

Enumerates the audio scenes.

System capability: SystemCapability.Multimedia.Audio.Communication

AudioManager

Implements audio volume and audio device management. Before calling any API in AudioManager, you must use getAudioManager to create an AudioManager instance.

setAudioParameter^(deprecated)

setAudioParameter(key: string, value: string, callback: AsyncCallback<void>): void

Sets an audio parameter. This API uses an asynchronous callback to return the result.

This API is used to extend the audio configuration based on the hardware capability. The supported audio parameters vary according to the device and are not common parameters. Sample parameters are used in the sample code below.

NOTE

This API is supported since API version 7 and deprecated since API version 11. The substitute API is available only for system applications.

Required permissions: ohos.permission.MODIFY_AUDIO_SETTINGS

System capability: SystemCapability.Multimedia.Audio.Core

Parameters

Example

import { BusinessError } from '@ohos.base';

audioManager.setAudioParameter('key_example', 'value_example', (err: BusinessError) => {
  if (err) {
    console.error(`Failed to set the audio parameter. ${err}`);
    return;
  }
  console.info('Callback invoked to indicate a successful setting of the audio parameter.');
});

setAudioParameter^(deprecated)

setAudioParameter(key: string, value: string): Promise<void>

Sets an audio parameter. This API uses a promise to return the result.

This API is used to extend the audio configuration based on the hardware capability. The supported audio parameters vary according to the device and are not common parameters. Sample parameters are used in the sample code below.

NOTE

This API is supported since API version 7 and deprecated since API version 11. The substitute API is available only for system applications.

Required permissions: ohos.permission.MODIFY_AUDIO_SETTINGS

System capability: SystemCapability.Multimedia.Audio.Core

Parameters

Return value

Example

audioManager.setAudioParameter('key_example', 'value_example').then(() => {
  console.info('Promise returned to indicate a successful setting of the audio parameter.');
});

getAudioParameter^(deprecated)

getAudioParameter(key: string, callback: AsyncCallback<string>): void

Obtains the value of an audio parameter. This API uses an asynchronous callback to return the result.

This API is used to extend the audio configuration based on the hardware capability. The supported audio parameters vary according to the device and can be obtained from the device manual. The example below is for reference only.

NOTE

This API is supported since API version 7 and deprecated since API version 11. The substitute API is available only for system applications.

System capability: SystemCapability.Multimedia.Audio.Core

Parameters

Example

import { BusinessError } from '@ohos.base';

audioManager.getAudioParameter('key_example', (err: BusinessError, value: string) => {
  if (err) {
    console.error(`Failed to obtain the value of the audio parameter. ${err}`);
    return;
  }
  console.info(`Callback invoked to indicate that the value of the audio parameter is obtained ${value}.`);
});

getAudioParameter^(deprecated)

getAudioParameter(key: string): Promise<string>

Obtains the value of an audio parameter. This API uses a promise to return the result.

This API is used to extend the audio configuration based on the hardware capability. The supported audio parameters vary according to the device and can be obtained from the device manual. The example below is for reference only.

NOTE

This API is supported since API version 7 and deprecated since API version 11. The substitute API is available only for system applications.

System capability: SystemCapability.Multimedia.Audio.Core

Parameters

Return value

Example

audioManager.getAudioParameter('key_example').then((value: string) => {
  console.info(`Promise returned to indicate that the value of the audio parameter is obtained ${value}.`);
});

getAudioScene⁸⁺

getAudioScene(callback: AsyncCallback<AudioScene>): void

Obtains the audio scene. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.Multimedia.Audio.Communication

Parameters

Example

import { BusinessError } from '@ohos.base';

audioManager.getAudioScene((err: BusinessError, value: audio.AudioScene) => {
  if (err) {
    console.error(`Failed to obtain the audio scene mode. ${err}`);
    return;
  }
  console.info(`Callback invoked to indicate that the audio scene mode is obtained ${value}.`);
});

getAudioScene⁸⁺

getAudioScene(): Promise<AudioScene>

Obtains the audio scene. This API uses a promise to return the result.

System capability: SystemCapability.Multimedia.Audio.Communication

Return value

Example

import { BusinessError } from '@ohos.base';

audioManager.getAudioScene().then((value: audio.AudioScene) => {
  console.info(`Promise returned to indicate that the audio scene mode is obtained ${value}.`);
}).catch ((err: BusinessError) => {
  console.error(`Failed to obtain the audio scene mode ${err}`);
});

getAudioSceneSync¹⁰⁺

getAudioSceneSync(): AudioScene

Obtains the audio scene. This API returns the result synchronously.

System capability: SystemCapability.Multimedia.Audio.Communication

Return value

Example

import { BusinessError } from '@ohos.base';

try {
  let value: audio.AudioScene = audioManager.getAudioSceneSync();
  console.info(`indicate that the audio scene mode is obtained ${value}.`);
} catch (err) {
  let error = err as BusinessError;
  console.error(`Failed to obtain the audio scene mode ${error}`);
}

getVolumeManager⁹⁺

getVolumeManager(): AudioVolumeManager

Obtains an AudioVolumeManager instance.

System capability: SystemCapability.Multimedia.Audio.Volume

Return value

Example

import audio from '@ohos.multimedia.audio';

let audioVolumeManager: audio.AudioVolumeManager = audioManager.getVolumeManager();

getStreamManager⁹⁺

getStreamManager(): AudioStreamManager

Obtains an AudioStreamManager instance.

System capability: SystemCapability.Multimedia.Audio.Core

Return value

Example

import audio from '@ohos.multimedia.audio';

let audioStreamManager: audio.AudioStreamManager = audioManager.getStreamManager();

getRoutingManager⁹⁺

getRoutingManager(): AudioRoutingManager

Obtains an AudioRoutingManager instance.

System capability: SystemCapability.Multimedia.Audio.Device

Return value

Example

import audio from '@ohos.multimedia.audio';

let audioRoutingManager: audio.AudioRoutingManager = audioManager.getRoutingManager();

setVolume^(deprecated)

setVolume(volumeType: AudioVolumeType, volume: number, callback: AsyncCallback<void>): void

Sets the volume for a stream. This API uses an asynchronous callback to return the result.

NOTE

This API is supported since API version 7 and deprecated since API version 9. You are advised to use setVolume in AudioVolumeGroupManager. The substitute API is available only for system applications.

Required permissions: ohos.permission.ACCESS_NOTIFICATION_POLICY

This permission is required only for muting or unmuting the ringer when volumeType is set to AudioVolumeType.RINGTONE.

System capability: SystemCapability.Multimedia.Audio.Volume

Parameters

Example

import { BusinessError } from '@ohos.base';

audioManager.setVolume(audio.AudioVolumeType.MEDIA, 10, (err: BusinessError) => {
  if (err) {
    console.error(`Failed to set the volume. ${err}`);
    return;
  }
  console.info('Callback invoked to indicate a successful volume setting.');
});

setVolume^(deprecated)

setVolume(volumeType: AudioVolumeType, volume: number): Promise<void>

Sets the volume for a stream. This API uses a promise to return the result.

NOTE

This API is supported since API version 7 and deprecated since API version 9. You are advised to use setVolume in AudioVolumeGroupManager. The substitute API is available only for system applications.

Required permissions: ohos.permission.ACCESS_NOTIFICATION_POLICY

This permission is required only for muting or unmuting the ringer when volumeType is set to AudioVolumeType.RINGTONE.

System capability: SystemCapability.Multimedia.Audio.Volume

Parameters

Return value

Example

audioManager.setVolume(audio.AudioVolumeType.MEDIA, 10).then(() => {
  console.info('Promise returned to indicate a successful volume setting.');
});

getVolume^(deprecated)

getVolume(volumeType: AudioVolumeType, callback: AsyncCallback<number>): void

Obtains the volume of a stream. This API uses an asynchronous callback to return the result.

NOTE

This API is supported since API version 7 and deprecated since API version 9. You are advised to use getVolume in AudioVolumeGroupManager.

System capability: SystemCapability.Multimedia.Audio.Volume

Parameters

Example

import { BusinessError } from '@ohos.base';

audioManager.getVolume(audio.AudioVolumeType.MEDIA, (err: BusinessError, value: number) => {
  if (err) {
    console.error(`Failed to obtain the volume. ${err}`);
    return;
  }
  console.info('Callback invoked to indicate that the volume is obtained.');
});

getVolume^(deprecated)

getVolume(volumeType: AudioVolumeType): Promise<number>

Obtains the volume of a stream. This API uses a promise to return the result.

NOTE

This API is supported since API version 7 and deprecated since API version 9. You are advised to use getVolume in AudioVolumeGroupManager.

System capability: SystemCapability.Multimedia.Audio.Volume

Parameters

Return value

Example

audioManager.getVolume(audio.AudioVolumeType.MEDIA).then((value: number) => {
  console.info(`Promise returned to indicate that the volume is obtained ${value} .`);
});

getMinVolume^(deprecated)

getMinVolume(volumeType: AudioVolumeType, callback: AsyncCallback<number>): void

Obtains the minimum volume allowed for a stream. This API uses an asynchronous callback to return the result.

NOTE

This API is supported since API version 7 and deprecated since API version 9. You are advised to use getMinVolume in AudioVolumeGroupManager.

System capability: SystemCapability.Multimedia.Audio.Volume

Parameters

Example

import { BusinessError } from '@ohos.base';

audioManager.getMinVolume(audio.AudioVolumeType.MEDIA, (err: BusinessError, value: number) => {
  if (err) {
    console.error(`Failed to obtain the minimum volume. ${err}`);
    return;
  }
  console.info(`Callback invoked to indicate that the minimum volume is obtained. ${value}`);
});

getMinVolume^(deprecated)

getMinVolume(volumeType: AudioVolumeType): Promise<number>

Obtains the minimum volume allowed for a stream. This API uses a promise to return the result.

NOTE

This API is supported since API version 7 and deprecated since API version 9. You are advised to use getMinVolume in AudioVolumeGroupManager.

System capability: SystemCapability.Multimedia.Audio.Volume

Parameters

Return value

Example

audioManager.getMinVolume(audio.AudioVolumeType.MEDIA).then((value: number) => {
  console.info(`Promised returned to indicate that the minimum volume is obtained. ${value}`);
});

getMaxVolume^(deprecated)

getMaxVolume(volumeType: AudioVolumeType, callback: AsyncCallback<number>): void

Obtains the maximum volume allowed for a stream. This API uses an asynchronous callback to return the result.

NOTE

This API is supported since API version 7 and deprecated since API version 9. You are advised to use getMaxVolume in AudioVolumeGroupManager.

System capability: SystemCapability.Multimedia.Audio.Volume

Parameters

Example

import { BusinessError } from '@ohos.base';

audioManager.getMaxVolume(audio.AudioVolumeType.MEDIA, (err: BusinessError, value: number) => {
  if (err) {
    console.error(`Failed to obtain the maximum volume. ${err}`);
    return;
  }
  console.info(`Callback invoked to indicate that the maximum volume is obtained. ${value}`);
});

getMaxVolume^(deprecated)

getMaxVolume(volumeType: AudioVolumeType): Promise<number>

Obtains the maximum volume allowed for a stream. This API uses a promise to return the result.

NOTE

This API is supported since API version 7 and deprecated since API version 9. You are advised to use getMaxVolume in AudioVolumeGroupManager.

System capability: SystemCapability.Multimedia.Audio.Volume

Parameters

Return value

Example

audioManager.getMaxVolume(audio.AudioVolumeType.MEDIA).then((data: number) => {
  console.info('Promised returned to indicate that the maximum volume is obtained.');
});

mute^(deprecated)

mute(volumeType: AudioVolumeType, mute: boolean, callback: AsyncCallback<void>): void

Mutes or unmutes a stream. This API uses an asynchronous callback to return the result.

NOTE

This API is supported since API version 7 and deprecated since API version 9. The substitute API is available only for system applications.

System capability: SystemCapability.Multimedia.Audio.Volume

Parameters

Example

import { BusinessError } from '@ohos.base';

audioManager.mute(audio.AudioVolumeType.MEDIA, true, (err: BusinessError) => {
  if (err) {
    console.error(`Failed to mute the stream. ${err}`);
    return;
  }
  console.info('Callback invoked to indicate that the stream is muted.');
});

mute^(deprecated)

mute(volumeType: AudioVolumeType, mute: boolean): Promise<void>

Mutes or unmutes a stream. This API uses a promise to return the result.

NOTE

This API is supported since API version 7 and deprecated since API version 9. The substitute API is available only for system applications.

System capability: SystemCapability.Multimedia.Audio.Volume

Parameters

Return value

Example

audioManager.mute(audio.AudioVolumeType.MEDIA, true).then(() => {
  console.info('Promise returned to indicate that the stream is muted.');
});

isMute^(deprecated)

isMute(volumeType: AudioVolumeType, callback: AsyncCallback<boolean>): void

Checks whether a stream is muted. This API uses an asynchronous callback to return the result.

NOTE

This API is supported since API version 7 and deprecated since API version 9. You are advised to use isMute in AudioVolumeGroupManager.

System capability: SystemCapability.Multimedia.Audio.Volume

Parameters

Example

import { BusinessError } from '@ohos.base';

audioManager.isMute(audio.AudioVolumeType.MEDIA, (err: BusinessError, value: boolean) => {
  if (err) {
    console.error(`Failed to obtain the mute status. ${err}`);
    return;
  }
  console.info(`Callback invoked to indicate that the mute status of the stream is obtained. ${value}`);
});

isMute^(deprecated)

isMute(volumeType: AudioVolumeType): Promise<boolean>

Checks whether a stream is muted. This API uses a promise to return the result.

NOTE

This API is supported since API version 7 and deprecated since API version 9. You are advised to use isMute in AudioVolumeGroupManager.

System capability: SystemCapability.Multimedia.Audio.Volume

Parameters

Return value

Example

audioManager.isMute(audio.AudioVolumeType.MEDIA).then((value: boolean) => {
  console.info(`Promise returned to indicate that the mute status of the stream is obtained ${value}.`);
});

isActive^(deprecated)

isActive(volumeType: AudioVolumeType, callback: AsyncCallback<boolean>): void

Checks whether a stream is active. This API uses an asynchronous callback to return the result.

NOTE

This API is supported since API version 7 and deprecated since API version 9. You are advised to use isActive in AudioStreamManager.

System capability: SystemCapability.Multimedia.Audio.Volume

Parameters

Example

import { BusinessError } from '@ohos.base';

audioManager.isActive(audio.AudioVolumeType.MEDIA, (err: BusinessError, value: boolean) => {
  if (err) {
    console.error(`Failed to obtain the active status of the stream. ${err}`);
    return;
  }
  console.info(`Callback invoked to indicate that the active status of the stream is obtained ${value}.`);
});

isActive^(deprecated)

isActive(volumeType: AudioVolumeType): Promise<boolean>

Checks whether a stream is active. This API uses a promise to return the result.

NOTE

This API is supported since API version 7 and deprecated since API version 9. You are advised to use isActive in AudioStreamManager.

System capability: SystemCapability.Multimedia.Audio.Volume

Parameters

Return value

Example

audioManager.isActive(audio.AudioVolumeType.MEDIA).then((value: boolean) => {
  console.info(`Promise returned to indicate that the active status of the stream is obtained ${value}.`);
});

setRingerMode^(deprecated)

setRingerMode(mode: AudioRingMode, callback: AsyncCallback<void>): void

Sets the ringer mode. This API uses an asynchronous callback to return the result.

NOTE

This API is supported since API version 7 and deprecated since API version 9. The substitute API is available only for system applications.

Required permissions: ohos.permission.ACCESS_NOTIFICATION_POLICY

This permission is required only for muting or unmuting the ringer.

System capability: SystemCapability.Multimedia.Audio.Communication

Parameters

Example

import { BusinessError } from '@ohos.base';

audioManager.setRingerMode(audio.AudioRingMode.RINGER_MODE_NORMAL, (err: BusinessError) => {
  if (err) {
    console.error(`Failed to set the ringer mode. ${err}`);
    return;
  }
  console.info('Callback invoked to indicate a successful setting of the ringer mode.');
});

setRingerMode^(deprecated)

setRingerMode(mode: AudioRingMode): Promise<void>

Sets the ringer mode. This API uses a promise to return the result.

NOTE

This API is supported since API version 7 and deprecated since API version 9. The substitute API is available only for system applications.

Required permissions: ohos.permission.ACCESS_NOTIFICATION_POLICY

This permission is required only for muting or unmuting the ringer.

System capability: SystemCapability.Multimedia.Audio.Communication

Parameters

Return value

Example

audioManager.setRingerMode(audio.AudioRingMode.RINGER_MODE_NORMAL).then(() => {
  console.info('Promise returned to indicate a successful setting of the ringer mode.');
});

getRingerMode^(deprecated)

getRingerMode(callback: AsyncCallback<AudioRingMode>): void

Obtains the ringer mode. This API uses an asynchronous callback to return the result.

NOTE

This API is supported since API version 7 and deprecated since API version 9. You are advised to use getRingerMode in AudioVolumeGroupManager.

System capability: SystemCapability.Multimedia.Audio.Communication

Parameters

Example

import { BusinessError } from '@ohos.base';

audioManager.getRingerMode((err: BusinessError, value: audio.AudioRingMode) => {
  if (err) {
    console.error(`Failed to obtain the ringer mode. ${err}`);
    return;
  }
  console.info(`Callback invoked to indicate that the ringer mode is obtained ${value}.`);
});

getRingerMode^(deprecated)

getRingerMode(): Promise<AudioRingMode>

Obtains the ringer mode. This API uses a promise to return the result.

NOTE

This API is supported since API version 7 and deprecated since API version 9. You are advised to use getRingerMode in AudioVolumeGroupManager.

System capability: SystemCapability.Multimedia.Audio.Communication

Return value

Example

audioManager.getRingerMode().then((value: audio.AudioRingMode) => {
  console.info(`Promise returned to indicate that the ringer mode is obtained ${value}.`);
});

getDevices^(deprecated)

getDevices(deviceFlag: DeviceFlag, callback: AsyncCallback<AudioDeviceDescriptors>): void

Obtains the audio devices with a specific flag. This API uses an asynchronous callback to return the result.

NOTE

This API is supported since API version 7 and deprecated since API version 9. You are advised to use getDevices in AudioRoutingManager.

System capability: SystemCapability.Multimedia.Audio.Device

Parameters

Example

import { BusinessError } from '@ohos.base';

audioManager.getDevices(audio.DeviceFlag.OUTPUT_DEVICES_FLAG, (err: BusinessError, value: audio.AudioDeviceDescriptors) => {
  if (err) {
    console.error(`Failed to obtain the device list. ${err}`);
    return;
  }
  console.info('Callback invoked to indicate that the device list is obtained.');
});

getDevices^(deprecated)

getDevices(deviceFlag: DeviceFlag): Promise<AudioDeviceDescriptors>

Obtains the audio devices with a specific flag. This API uses a promise to return the result.

NOTE

This API is supported since API version 7 and deprecated since API version 9. You are advised to use getDevices in AudioRoutingManager.

System capability: SystemCapability.Multimedia.Audio.Device

Parameters

Return value

Example

audioManager.getDevices(audio.DeviceFlag.OUTPUT_DEVICES_FLAG).then((data: audio.AudioDeviceDescriptors) => {
  console.info('Promise returned to indicate that the device list is obtained.');
});

setDeviceActive^(deprecated)

setDeviceActive(deviceType: ActiveDeviceType, active: boolean, callback: AsyncCallback<void>): void

Sets a device to the active state. This API uses an asynchronous callback to return the result.

NOTE

This API is supported since API version 7 and deprecated since API version 9. You are advised to use setCommunicationDevice in AudioRoutingManager.

System capability: SystemCapability.Multimedia.Audio.Device

Parameters

Example

import { BusinessError } from '@ohos.base';

audioManager.setDeviceActive(audio.ActiveDeviceType.SPEAKER, true, (err: BusinessError) => {
  if (err) {
    console.error(`Failed to set the active status of the device. ${err}`);
    return;
  }
  console.info('Callback invoked to indicate that the device is set to the active status.');
});

setDeviceActive^(deprecated)

setDeviceActive(deviceType: ActiveDeviceType, active: boolean): Promise<void>

Sets a device to the active state. This API uses a promise to return the result.

NOTE

This API is supported since API version 7 and deprecated since API version 9. You are advised to use setCommunicationDevice in AudioRoutingManager.

System capability: SystemCapability.Multimedia.Audio.Device

Parameters

Return value

Example

audioManager.setDeviceActive(audio.ActiveDeviceType.SPEAKER, true).then(() => {
  console.info('Promise returned to indicate that the device is set to the active status.');
});

isDeviceActive^(deprecated)

isDeviceActive(deviceType: ActiveDeviceType, callback: AsyncCallback<boolean>): void

Checks whether a device is active. This API uses an asynchronous callback to return the result.

NOTE

This API is supported since API version 7 and deprecated since API version 9. You are advised to use isCommunicationDeviceActive in AudioRoutingManager.

System capability: SystemCapability.Multimedia.Audio.Device

Parameters

Example

import { BusinessError } from '@ohos.base';

audioManager.isDeviceActive(audio.ActiveDeviceType.SPEAKER, (err: BusinessError, value: boolean) => {
  if (err) {
    console.error(`Failed to obtain the active status of the device. ${err}`);
    return;
  }
  console.info('Callback invoked to indicate that the active status of the device is obtained.');
});

isDeviceActive^(deprecated)

isDeviceActive(deviceType: ActiveDeviceType): Promise<boolean>

Checks whether a device is active. This API uses a promise to return the result.

NOTE

This API is supported since API version 7 and deprecated since API version 9. You are advised to use isCommunicationDeviceActive in AudioRoutingManager.

System capability: SystemCapability.Multimedia.Audio.Device

Parameters

Return value

Example

audioManager.isDeviceActive(audio.ActiveDeviceType.SPEAKER).then((value: boolean) => {
  console.info(`Promise returned to indicate that the active status of the device is obtained ${value}.`);
});

setMicrophoneMute^(deprecated)

setMicrophoneMute(mute: boolean, callback: AsyncCallback<void>): void

Mutes or unmutes the microphone. This API uses an asynchronous callback to return the result.

NOTE

This API is supported since API version 7 and deprecated since API version 9. The substitute API is available only for system applications.

Required permissions: ohos.permission.MICROPHONE

System capability: SystemCapability.Multimedia.Audio.Device

Parameters

Example

import { BusinessError } from '@ohos.base';

audioManager.setMicrophoneMute(true, (err: BusinessError) => {
  if (err) {
    console.error(`Failed to mute the microphone. ${err}`);
    return;
  }
  console.info('Callback invoked to indicate that the microphone is muted.');
});

setMicrophoneMute^(deprecated)

setMicrophoneMute(mute: boolean): Promise<void>

Mutes or unmutes the microphone. This API uses a promise to return the result.

NOTE

This API is supported since API version 7 and deprecated since API version 9. The substitute API is available only for system applications.

Required permissions: ohos.permission.MICROPHONE

System capability: SystemCapability.Multimedia.Audio.Device

Parameters

Return value

Example

audioManager.setMicrophoneMute(true).then(() => {
  console.info('Promise returned to indicate that the microphone is muted.');
});

isMicrophoneMute^(deprecated)

isMicrophoneMute(callback: AsyncCallback<boolean>): void

Checks whether the microphone is muted. This API uses an asynchronous callback to return the result.

NOTE

This API is supported since API version 7 and deprecated since API version 9. You are advised to use isMicrophoneMute in AudioVolumeGroupManager.

Required permissions: ohos.permission.MICROPHONE

System capability: SystemCapability.Multimedia.Audio.Device

Parameters

Example

import { BusinessError } from '@ohos.base';

audioManager.isMicrophoneMute((err: BusinessError, value: boolean) => {
  if (err) {
    console.error(`Failed to obtain the mute status of the microphone. ${err}`);
    return;
  }
  console.info(`Callback invoked to indicate that the mute status of the microphone is obtained ${value}.`);
});

isMicrophoneMute^(deprecated)

isMicrophoneMute(): Promise<boolean>

Checks whether the microphone is muted. This API uses a promise to return the result.

NOTE

This API is supported since API version 7 and deprecated since API version 9. You are advised to use isMicrophoneMute in AudioVolumeGroupManager.

Required permissions: ohos.permission.MICROPHONE

System capability: SystemCapability.Multimedia.Audio.Device

Return value

Example

audioManager.isMicrophoneMute().then((value: boolean) => {
  console.info(`Promise returned to indicate that the mute status of the microphone is obtained ${value}.`);
});

on('deviceChange')^(deprecated)

on(type: 'deviceChange', callback: Callback<DeviceChangeAction>): void

Subscribes to audio device connection change events. This API uses an asynchronous callback to return the result.

NOTE

This API is supported since API version 7 and deprecated since API version 9. You are advised to use on('deviceChange') in AudioRoutingManager.

System capability: SystemCapability.Multimedia.Audio.Device

Parameters

Example

audioManager.on('deviceChange', (deviceChanged: audio.DeviceChangeAction) => {
  console.info(`device change type : ${deviceChanged.type} `);
  console.info(`device descriptor size : ${deviceChanged.deviceDescriptors.length} `);
  console.info(`device change descriptor : ${deviceChanged.deviceDescriptors[0].deviceRole} `);
  console.info(`device change descriptor : ${deviceChanged.deviceDescriptors[0].deviceType} `);
});

off('deviceChange')^(deprecated)

off(type: 'deviceChange', callback?: Callback<DeviceChangeAction>): void

Unsubscribes from audio device connection change events. This API uses an asynchronous callback to return the result.

NOTE

This API is supported since API version 7 and deprecated since API version 9. You are advised to use off('deviceChange') in AudioRoutingManager.

System capability: SystemCapability.Multimedia.Audio.Device

Parameters

Example

audioManager.off('deviceChange');

on('interrupt')^(deprecated)

on(type: 'interrupt', interrupt: AudioInterrupt, callback: Callback<InterruptAction>): void

Subscribes to audio interruption events. When the application's audio is interrupted by another playback event, the application will receive the callback. This API uses an asynchronous callback to return the result.

Same as on('audioInterrupt'), this API is used to listen for focus changes. However, this API is used in scenarios without audio streams (no AudioRenderer instance is created), such as frequency modulation (FM) and voice wakeup.

NOTE

This API is supported since API version 7 and deprecated since API version 11. You are advised to use on('audioInterrupt') in AudioCapturer.

System capability: SystemCapability.Multimedia.Audio.Renderer

Parameters

Example

import audio from '@ohos.multimedia.audio';

let interAudioInterrupt: audio.AudioInterrupt = {
  streamUsage:2,
  contentType:0,
  pauseWhenDucked:true
};
audioManager.on('interrupt', interAudioInterrupt, (InterruptAction: audio.InterruptAction) => {
  if (InterruptAction.actionType === 0) {
    console.info('An event to gain the audio focus starts.');
    console.info(`Focus gain event: ${InterruptAction} `);
  }
  if (InterruptAction.actionType === 1) {
    console.info('An audio interruption event starts.');
    console.info(`Audio interruption event: ${InterruptAction} `);
  }
});

off('interrupt')^(deprecated)

off(type: 'interrupt', interrupt: AudioInterrupt, callback?: Callback<InterruptAction>): void

Unsubscribes from audio interruption events. This API uses an asynchronous callback to return the result.

NOTE

This API is supported since API version 7 and deprecated since API version 11. You are advised to use off('audioInterrupt') in AudioCapturer.

System capability: SystemCapability.Multimedia.Audio.Renderer

Parameters

Example

import audio from '@ohos.multimedia.audio';

let interAudioInterrupt: audio.AudioInterrupt = {
  streamUsage:2,
  contentType:0,
  pauseWhenDucked:true
};
audioManager.off('interrupt', interAudioInterrupt, (InterruptAction: audio.InterruptAction) => {
  if (InterruptAction.actionType === 0) {
    console.info('An event to release the audio focus starts.');
    console.info(`Focus release event: ${InterruptAction} `);
  }
});

AudioVolumeManager⁹⁺

Implements audio volume management. Before calling an API in AudioVolumeManager, you must use getVolumeManager to obtain an AudioVolumeManager instance.

getVolumeGroupManager⁹⁺

getVolumeGroupManager(groupId: number, callback: AsyncCallback<AudioVolumeGroupManager>): void

Obtains the volume group manager. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.Multimedia.Audio.Volume

Parameters

Example

import { BusinessError } from '@ohos.base';

let groupId: number = audio.DEFAULT_VOLUME_GROUP_ID;
audioVolumeManager.getVolumeGroupManager(groupId, (err: BusinessError, value: audio.AudioVolumeGroupManager) => {
  if (err) {
    console.error(`Failed to obtain the volume group infos list. ${err}`);
    return;
  }
  console.info('Callback invoked to indicate that the volume group infos list is obtained.');
});

getVolumeGroupManager⁹⁺

getVolumeGroupManager(groupId: number): Promise<AudioVolumeGroupManager>

Obtains the volume group manager. This API uses a promise to return the result.

System capability: SystemCapability.Multimedia.Audio.Volume

Parameters

Return value

Example

import audio from '@ohos.multimedia.audio';

let groupId: number = audio.DEFAULT_VOLUME_GROUP_ID;
let audioVolumeGroupManager: audio.AudioVolumeGroupManager | undefined = undefined;
async function getVolumeGroupManager(){
  audioVolumeGroupManager = await audioVolumeManager.getVolumeGroupManager(groupId);
  console.info('Promise returned to indicate that the volume group infos list is obtained.');
}

getVolumeGroupManagerSync¹⁰⁺

getVolumeGroupManagerSync(groupId: number): AudioVolumeGroupManager

Obtains the volume group manager. This API returns the result synchronously.

System capability: SystemCapability.Multimedia.Audio.Volume

Parameters

Return value

Error codes

For details about the error codes, see Audio Error Codes.

Example

import { BusinessError } from '@ohos.base';

try {
  let audioVolumeGroupManager: audio.AudioVolumeGroupManager = audioVolumeManager.getVolumeGroupManagerSync(audio.DEFAULT_VOLUME_GROUP_ID);
  console.info(`Get audioVolumeGroupManager success.`);
} catch (err) {
  let error = err as BusinessError;
  console.error(`Failed to get audioVolumeGroupManager, error: ${error}`);
}

on('volumeChange')⁹⁺

on(type: 'volumeChange', callback: Callback<VolumeEvent>): void

Subscribes to system volume change events. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.Multimedia.Audio.Volume

Parameters

Error codes

For details about the error codes, see Audio Error Codes.

Example

audioVolumeManager.on('volumeChange', (volumeEvent: audio.VolumeEvent) => {
  console.info(`VolumeType of stream: ${volumeEvent.volumeType} `);
  console.info(`Volume level: ${volumeEvent.volume} `);
  console.info(`Whether to updateUI: ${volumeEvent.updateUi} `);
});

AudioVolumeGroupManager⁹⁺

Manages the volume of an audio group. Before calling any API in AudioVolumeGroupManager, you must use getVolumeGroupManager to obtain an AudioVolumeGroupManager instance.

getVolume⁹⁺

getVolume(volumeType: AudioVolumeType, callback: AsyncCallback<number>): void

Obtains the volume of a stream. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.Multimedia.Audio.Volume

Parameters

Example

import { BusinessError } from '@ohos.base';

audioVolumeGroupManager.getVolume(audio.AudioVolumeType.MEDIA, (err: BusinessError, value: number) => {
  if (err) {
    console.error(`Failed to obtain the volume. ${err}`);
    return;
  }
  console.info('Callback invoked to indicate that the volume is obtained.');
});

getVolume⁹⁺

getVolume(volumeType: AudioVolumeType): Promise<number>

Obtains the volume of a stream. This API uses a promise to return the result.

System capability: SystemCapability.Multimedia.Audio.Volume

Parameters

Return value

Example

audioVolumeGroupManager.getVolume(audio.AudioVolumeType.MEDIA).then((value: number) => {
  console.info(`Promise returned to indicate that the volume is obtained ${value}.`);
});

getVolumeSync¹⁰⁺

getVolumeSync(volumeType: AudioVolumeType): number;

Obtains the volume of a stream. This API returns the result synchronously.

System capability: SystemCapability.Multimedia.Audio.Volume

Parameters

Return value

Error codes

For details about the error codes, see Audio Error Codes.

Example

import { BusinessError } from '@ohos.base';

try {
  let value: number = audioVolumeGroupManager.getVolumeSync(audio.AudioVolumeType.MEDIA);
  console.info(`Indicate that the volume is obtained ${value}.`);
} catch (err) {
  let error = err as BusinessError;
  console.error(`Failed to obtain the volume, error ${error}.`);
}

getMinVolume⁹⁺

getMinVolume(volumeType: AudioVolumeType, callback: AsyncCallback<number>): void

Obtains the minimum volume allowed for a stream. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.Multimedia.Audio.Volume

Parameters

Example

import { BusinessError } from '@ohos.base';

audioVolumeGroupManager.getMinVolume(audio.AudioVolumeType.MEDIA, (err: BusinessError, value: number) => {
  if (err) {
    console.error(`Failed to obtain the minimum volume. ${err}`);
    return;
  }
  console.info(`Callback invoked to indicate that the minimum volume is obtained. ${value}`);
});

getMinVolume⁹⁺

getMinVolume(volumeType: AudioVolumeType): Promise<number>

Obtains the minimum volume allowed for a stream. This API uses a promise to return the result.

System capability: SystemCapability.Multimedia.Audio.Volume

Parameters

Return value

Example

audioVolumeGroupManager.getMinVolume(audio.AudioVolumeType.MEDIA).then((value: number) => {
  console.info(`Promised returned to indicate that the minimum volume is obtained ${value}.`);
});

getMinVolumeSync¹⁰⁺

getMinVolumeSync(volumeType: AudioVolumeType): number;

Obtains the minimum volume allowed for a stream. This API returns the result synchronously.

System capability: SystemCapability.Multimedia.Audio.Volume

Parameters

Return value

Error codes

For details about the error codes, see Audio Error Codes.

Example

import { BusinessError } from '@ohos.base';

try {
  let value: number = audioVolumeGroupManager.getMinVolumeSync(audio.AudioVolumeType.MEDIA);
  console.info(`Indicate that the minimum volume is obtained ${value}.`);
} catch (err) {
  let error = err as BusinessError;
  console.error(`Failed to obtain the minimum volume, error ${error}.`);
}

getMaxVolume⁹⁺

getMaxVolume(volumeType: AudioVolumeType, callback: AsyncCallback<number>): void

Obtains the maximum volume allowed for a stream. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.Multimedia.Audio.Volume

Parameters

Example

import { BusinessError } from '@ohos.base';

audioVolumeGroupManager.getMaxVolume(audio.AudioVolumeType.MEDIA, (err: BusinessError, value: number) => {
  if (err) {
    console.error(`Failed to obtain the maximum volume. ${err}`);
    return;
  }
  console.info(`Callback invoked to indicate that the maximum volume is obtained. ${value}`);
});

getMaxVolume⁹⁺

getMaxVolume(volumeType: AudioVolumeType): Promise<number>

Obtains the maximum volume allowed for a stream. This API uses a promise to return the result.

System capability: SystemCapability.Multimedia.Audio.Volume

Parameters

Return value

Example

audioVolumeGroupManager.getMaxVolume(audio.AudioVolumeType.MEDIA).then((data: number) => {
  console.info('Promised returned to indicate that the maximum volume is obtained.');
});

getMaxVolumeSync¹⁰⁺

getMaxVolumeSync(volumeType: AudioVolumeType): number;

Obtains the maximum volume allowed for a stream. This API returns the result synchronously.

System capability: SystemCapability.Multimedia.Audio.Volume

Parameters

Return value

Error codes

For details about the error codes, see Audio Error Codes.

Example

import { BusinessError } from '@ohos.base';

try {
  let value: number = audioVolumeGroupManager.getMaxVolumeSync(audio.AudioVolumeType.MEDIA);
  console.info(`Indicate that the maximum volume is obtained. ${value}`);
} catch (err) {
  let error = err as BusinessError;
  console.error(`Failed to obtain the maximum volume, error ${error}.`);
}

isMute⁹⁺

isMute(volumeType: AudioVolumeType, callback: AsyncCallback<boolean>): void

Checks whether a stream is muted. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.Multimedia.Audio.Volume

Parameters

Example

import { BusinessError } from '@ohos.base';

audioVolumeGroupManager.isMute(audio.AudioVolumeType.MEDIA, (err: BusinessError, value: boolean) => {
  if (err) {
    console.error(`Failed to obtain the mute status. ${err}`);
    return;
  }
  console.info(`Callback invoked to indicate that the mute status of the stream is obtained ${value}.`);
});

isMute⁹⁺

isMute(volumeType: AudioVolumeType): Promise<boolean>

Checks whether a stream is muted. This API uses a promise to return the result.

System capability: SystemCapability.Multimedia.Audio.Volume

Parameters

Return value

Example

audioVolumeGroupManager.isMute(audio.AudioVolumeType.MEDIA).then((value: boolean) => {
  console.info(`Promise returned to indicate that the mute status of the stream is obtained ${value}.`);
});

isMuteSync¹⁰⁺

isMuteSync(volumeType: AudioVolumeType): boolean

Checks whether a stream is muted. This API returns the result synchronously.

System capability: SystemCapability.Multimedia.Audio.Volume

Parameters

Return value

Error codes

For details about the error codes, see Audio Error Codes.

Example

import { BusinessError } from '@ohos.base';

try {
  let value: boolean = audioVolumeGroupManager.isMuteSync(audio.AudioVolumeType.MEDIA);
  console.info(`Indicate that the mute status of the stream is obtained ${value}.`);
} catch (err) {
  let error = err as BusinessError;
  console.error(`Failed to obtain the mute status of the stream, error ${error}.`);
}

getRingerMode⁹⁺

getRingerMode(callback: AsyncCallback<AudioRingMode>): void

Obtains the ringer mode. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.Multimedia.Audio.Volume

Parameters

Example

import { BusinessError } from '@ohos.base';

audioVolumeGroupManager.getRingerMode((err: BusinessError, value: audio.AudioRingMode) => {
  if (err) {
    console.error(`Failed to obtain the ringer mode. ${err}`);
    return;
  }
  console.info(`Callback invoked to indicate that the ringer mode is obtained ${value}.`);
});

getRingerMode⁹⁺

getRingerMode(): Promise<AudioRingMode>

Obtains the ringer mode. This API uses a promise to return the result.

System capability: SystemCapability.Multimedia.Audio.Volume

Return value

Example

audioVolumeGroupManager.getRingerMode().then((value: audio.AudioRingMode) => {
  console.info(`Promise returned to indicate that the ringer mode is obtained ${value}.`);
});

getRingerModeSync¹⁰⁺

getRingerModeSync(): AudioRingMode

Obtains the ringer mode. This API returns the result synchronously.

System capability: SystemCapability.Multimedia.Audio.Volume

Return value

Example

import { BusinessError } from '@ohos.base';

try {
  let value: audio.AudioRingMode = audioVolumeGroupManager.getRingerModeSync();
  console.info(`Indicate that the ringer mode is obtained ${value}.`);
} catch (err) {
  let error = err as BusinessError;
  console.error(`Failed to obtain the ringer mode, error ${error}.`);
}

on('ringerModeChange')⁹⁺

on(type: 'ringerModeChange', callback: Callback<AudioRingMode>): void

Subscribes to ringer mode change events. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.Multimedia.Audio.Volume

Parameters

Error codes

For details about the error codes, see Audio Error Codes.

Example

audioVolumeGroupManager.on('ringerModeChange', (ringerMode: audio.AudioRingMode) => {
  console.info(`Updated ringermode: ${ringerMode}`);
});

setMicrophoneMute^(deprecated)

setMicrophoneMute(mute: boolean, callback: AsyncCallback<void>): void

Mutes or unmutes the microphone. This API uses an asynchronous callback to return the result.

NOTE

This API is supported since API version 9 and deprecated since API version 11. The substitute API is available only for system applications.

Required permissions: ohos.permission.MANAGE_AUDIO_CONFIG (available only for system applications)

System capability: SystemCapability.Multimedia.Audio.Volume

Parameters

Example

import { BusinessError } from '@ohos.base';

audioVolumeGroupManager.setMicrophoneMute(true, (err: BusinessError) => {
  if (err) {
    console.error(`Failed to mute the microphone. ${err}`);
    return;
  }
  console.info('Callback invoked to indicate that the microphone is muted.');
});

setMicrophoneMute^(deprecated)

setMicrophoneMute(mute: boolean): Promise<void>

Mutes or unmutes the microphone. This API uses a promise to return the result.

NOTE

This API is supported since API version 9 and deprecated since API version 11. The substitute API is available only for system applications.

Required permissions: ohos.permission.MANAGE_AUDIO_CONFIG (available only for system applications)

System capability: SystemCapability.Multimedia.Audio.Volume

Parameters

Return value

Example

audioVolumeGroupManager.setMicrophoneMute(true).then(() => {
  console.info('Promise returned to indicate that the microphone is muted.');
});

isMicrophoneMute⁹⁺

isMicrophoneMute(callback: AsyncCallback<boolean>): void

Checks whether the microphone is muted. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.Multimedia.Audio.Volume

Parameters

Example

import { BusinessError } from '@ohos.base';

audioVolumeGroupManager.isMicrophoneMute((err: BusinessError, value: boolean) => {
  if (err) {
    console.error(`Failed to obtain the mute status of the microphone. ${err}`);
    return;
  }
  console.info(`Callback invoked to indicate that the mute status of the microphone is obtained ${value}.`);
});

isMicrophoneMute⁹⁺

isMicrophoneMute(): Promise<boolean>

Checks whether the microphone is muted. This API uses a promise to return the result.

System capability: SystemCapability.Multimedia.Audio.Volume

Return value

Example

audioVolumeGroupManager.isMicrophoneMute().then((value: boolean) => {
  console.info(`Promise returned to indicate that the mute status of the microphone is obtained ${value}.`);
});

isMicrophoneMuteSync¹⁰⁺

isMicrophoneMuteSync(): boolean

Checks whether the microphone is muted. This API returns the result synchronously.

System capability: SystemCapability.Multimedia.Audio.Volume

Return value

Example

import { BusinessError } from '@ohos.base';

try {
  let value: boolean = audioVolumeGroupManager.isMicrophoneMuteSync();
  console.info(`Indicate that the mute status of the microphone is obtained ${value}.`);
} catch (err) {
  let error = err as BusinessError;
  console.error(`Failed to obtain the mute status of the microphone, error ${error}.`);
}

on('micStateChange')⁹⁺

on(type: 'micStateChange', callback: Callback<MicStateChangeEvent>): void

Subscribes to system microphone state change events. This API uses an asynchronous callback to return the result.

Currently, when multiple AudioManager instances are used in a single process, only the subscription of the last instance takes effect, and the subscription of other instances is overwritten (even if the last instance does not initiate a subscription). Therefore, you are advised to use a single AudioManager instance.

System capability: SystemCapability.Multimedia.Audio.Volume

Parameters

Error codes

For details about the error codes, see Audio Error Codes.

Example

audioVolumeGroupManager.on('micStateChange', (micStateChange: audio.MicStateChangeEvent) => {
  console.info(`Current microphone status is: ${micStateChange.mute} `);
});

isVolumeUnadjustable¹⁰⁺

isVolumeUnadjustable(): boolean

Checks whether the fixed volume mode is enabled. When the fixed volume mode is enabled, the volume cannot be adjusted. This API returns the result synchronously.

System capability: SystemCapability.Multimedia.Audio.Volume

Return value

Example

let volumeAdjustSwitch: boolean = audioVolumeGroupManager.isVolumeUnadjustable();
console.info(`Whether it is volume unadjustable: ${volumeAdjustSwitch}.`);

getSystemVolumeInDb¹⁰⁺

getSystemVolumeInDb(volumeType: AudioVolumeType, volumeLevel: number, device: DeviceType, callback: AsyncCallback<number>): void

Obtains the volume gain. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.Multimedia.Audio.Volume

Parameters

Error codes

For details about the error codes, see Audio Error Codes.

Example

import { BusinessError } from '@ohos.base';

audioVolumeGroupManager.getSystemVolumeInDb(audio.AudioVolumeType.MEDIA, 3, audio.DeviceType.SPEAKER, (err: BusinessError, dB: number) => {
  if (err) {
    console.error(`Failed to get the volume DB. ${err}`);
  } else {
    console.info(`Success to get the volume DB. ${dB}`);
  }
});

getSystemVolumeInDb¹⁰⁺

getSystemVolumeInDb(volumeType: AudioVolumeType, volumeLevel: number, device: DeviceType): Promise<number>

Obtains the volume gain. This API uses a promise to return the result.

System capability: SystemCapability.Multimedia.Audio.Volume

Parameters

Return value

Error codes

For details about the error codes, see Audio Error Codes.

Example

import { BusinessError } from '@ohos.base';

audioVolumeGroupManager.getSystemVolumeInDb(audio.AudioVolumeType.MEDIA, 3, audio.DeviceType.SPEAKER).then((value: number) => {
  console.info(`Success to get the volume DB. ${value}`);
}).catch((error: BusinessError) => {
  console.error(`Fail to adjust the system volume by step. ${error}`);
});

getSystemVolumeInDbSync¹⁰⁺

getSystemVolumeInDbSync(volumeType: AudioVolumeType, volumeLevel: number, device: DeviceType): number

Obtains the volume gain. This API returns the result synchronously.

System capability: SystemCapability.Multimedia.Audio.Volume

Parameters

Return value

Error codes

For details about the error codes, see Audio Error Codes.

Example

import { BusinessError } from '@ohos.base';

try {
  let value: number = audioVolumeGroupManager.getSystemVolumeInDbSync(audio.AudioVolumeType.MEDIA, 3, audio.DeviceType.SPEAKER);
  console.info(`Success to get the volume DB. ${value}`);
} catch (err) {
  let error = err as BusinessError;
  console.error(`Fail to adjust the system volume by step. ${error}`);
}

AudioStreamManager⁹⁺

Implements audio stream management. Before calling any API in AudioStreamManager, you must use getStreamManager to obtain an AudioStreamManager instance.

getCurrentAudioRendererInfoArray⁹⁺

getCurrentAudioRendererInfoArray(callback: AsyncCallback<AudioRendererChangeInfoArray>): void

Obtains the information about the current audio renderer. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.Multimedia.Audio.Renderer

Parameters

Example

import { BusinessError } from '@ohos.base';

audioStreamManager.getCurrentAudioRendererInfoArray(async (err: BusinessError, AudioRendererChangeInfoArray: audio.AudioRendererChangeInfoArray) => {
  console.info('getCurrentAudioRendererInfoArray **** Get Callback Called ****');
  if (err) {
    console.error(`getCurrentAudioRendererInfoArray :ERROR: ${err}`);
  } else {
    if (AudioRendererChangeInfoArray != null) {
      for (let i = 0; i < AudioRendererChangeInfoArray.length; i++) {
        let AudioRendererChangeInfo: audio.AudioRendererChangeInfo = AudioRendererChangeInfoArray[i];
        console.info(`StreamId for ${i} is: ${AudioRendererChangeInfo.streamId}`);
        console.info(`Content ${i} is: ${AudioRendererChangeInfo.rendererInfo.content}`);
        console.info(`Stream ${i} is: ${AudioRendererChangeInfo.rendererInfo.usage}`);
        console.info(`Flag ${i} is: ${AudioRendererChangeInfo.rendererInfo.rendererFlags}`);
        for (let j = 0;j < AudioRendererChangeInfo.deviceDescriptors.length; j++) {
          console.info(`Id: ${i} : ${AudioRendererChangeInfo.deviceDescriptors[j].id}`);
          console.info(`Type: ${i} : ${AudioRendererChangeInfo.deviceDescriptors[j].deviceType}`);
          console.info(`Role: ${i} : ${AudioRendererChangeInfo.deviceDescriptors[j].deviceRole}`);
          console.info(`Name: ${i} : ${AudioRendererChangeInfo.deviceDescriptors[j].name}`);
          console.info(`Address: ${i} : ${AudioRendererChangeInfo.deviceDescriptors[j].address}`);
          console.info(`SampleRate: ${i} : ${AudioRendererChangeInfo.deviceDescriptors[j].sampleRates[0]}`);
          console.info(`ChannelCount: ${i} : ${AudioRendererChangeInfo.deviceDescriptors[j].channelCounts[0]}`);
          console.info(`ChannelMask: ${i} : ${AudioRendererChangeInfo.deviceDescriptors[j].channelMasks[0]}`);
        }
      }
    }
  }
});

getCurrentAudioRendererInfoArray⁹⁺

getCurrentAudioRendererInfoArray(): Promise<AudioRendererChangeInfoArray>

Obtains the information about the current audio renderer. This API uses a promise to return the result.

System capability: SystemCapability.Multimedia.Audio.Renderer

Return value

Example

import { BusinessError } from '@ohos.base';

async function getCurrentAudioRendererInfoArray(){
  await audioStreamManager.getCurrentAudioRendererInfoArray().then((AudioRendererChangeInfoArray: audio.AudioRendererChangeInfoArray) => {
    console.info(`getCurrentAudioRendererInfoArray ######### Get Promise is called ##########`);
    if (AudioRendererChangeInfoArray != null) {
      for (let i = 0; i < AudioRendererChangeInfoArray.length; i++) {
        let AudioRendererChangeInfo: audio.AudioRendererChangeInfo = AudioRendererChangeInfoArray[i];
        console.info(`StreamId for ${i} is: ${AudioRendererChangeInfo.streamId}`);
        console.info(`Content ${i} is: ${AudioRendererChangeInfo.rendererInfo.content}`);
        console.info(`Stream ${i} is: ${AudioRendererChangeInfo.rendererInfo.usage}`);
        console.info(`Flag ${i} is: ${AudioRendererChangeInfo.rendererInfo.rendererFlags}`);
        for (let j = 0;j < AudioRendererChangeInfo.deviceDescriptors.length; j++) {
          console.info(`Id: ${i} : ${AudioRendererChangeInfo.deviceDescriptors[j].id}`);
          console.info(`Type: ${i} : ${AudioRendererChangeInfo.deviceDescriptors[j].deviceType}`);
          console.info(`Role: ${i} : ${AudioRendererChangeInfo.deviceDescriptors[j].deviceRole}`);
          console.info(`Name: ${i} : ${AudioRendererChangeInfo.deviceDescriptors[j].name}`);
          console.info(`Address: ${i} : ${AudioRendererChangeInfo.deviceDescriptors[j].address}`);
          console.info(`SampleRate: ${i} : ${AudioRendererChangeInfo.deviceDescriptors[j].sampleRates[0]}`);
          console.info(`ChannelCount: ${i} : ${AudioRendererChangeInfo.deviceDescriptors[j].channelCounts[0]}`);
          console.info(`ChannelMask: ${i} : ${AudioRendererChangeInfo.deviceDescriptors[j].channelMasks[0]}`);
        }
      }
    }
  }).catch((err: BusinessError) => {
    console.error(`getCurrentAudioRendererInfoArray :ERROR: ${err}`);
  });
}

getCurrentAudioRendererInfoArraySync¹⁰⁺

getCurrentAudioRendererInfoArraySync(): AudioRendererChangeInfoArray

Obtains the information about the current audio renderer. This API returns the result synchronously.

System capability: SystemCapability.Multimedia.Audio.Renderer

Return value

Example

import { BusinessError } from '@ohos.base';

try {
  let audioRendererChangeInfoArray: audio.AudioRendererChangeInfoArray = audioStreamManager.getCurrentAudioRendererInfoArraySync();
  console.info(`getCurrentAudioRendererInfoArraySync success.`);
  if (audioRendererChangeInfoArray != null) {
    for (let i = 0; i < audioRendererChangeInfoArray.length; i++) {
      let AudioRendererChangeInfo: audio.AudioRendererChangeInfo = audioRendererChangeInfoArray[i];
      console.info(`StreamId for ${i} is: ${AudioRendererChangeInfo.streamId}`);
      console.info(`Content ${i} is: ${AudioRendererChangeInfo.rendererInfo.content}`);
      console.info(`Stream ${i} is: ${AudioRendererChangeInfo.rendererInfo.usage}`);
      console.info(`Flag ${i} is: ${AudioRendererChangeInfo.rendererInfo.rendererFlags}`);
      for (let j = 0;j < AudioRendererChangeInfo.deviceDescriptors.length; j++) {
        console.info(`Id: ${i} : ${AudioRendererChangeInfo.deviceDescriptors[j].id}`);
        console.info(`Type: ${i} : ${AudioRendererChangeInfo.deviceDescriptors[j].deviceType}`);
        console.info(`Role: ${i} : ${AudioRendererChangeInfo.deviceDescriptors[j].deviceRole}`);
        console.info(`Name: ${i} : ${AudioRendererChangeInfo.deviceDescriptors[j].name}`);
        console.info(`Address: ${i} : ${AudioRendererChangeInfo.deviceDescriptors[j].address}`);
        console.info(`SampleRate: ${i} : ${AudioRendererChangeInfo.deviceDescriptors[j].sampleRates[0]}`);
        console.info(`ChannelCount: ${i} : ${AudioRendererChangeInfo.deviceDescriptors[j].channelCounts[0]}`);
        console.info(`ChannelMask: ${i} : ${AudioRendererChangeInfo.deviceDescriptors[j].channelMasks[0]}`);
      }
    }
  }
} catch (err) {
  let error = err as BusinessError;
  console.error(`getCurrentAudioRendererInfoArraySync :ERROR: ${error}`);
}

getCurrentAudioCapturerInfoArray⁹⁺

getCurrentAudioCapturerInfoArray(callback: AsyncCallback<AudioCapturerChangeInfoArray>): void

Obtains the information about the current audio capturer. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.Multimedia.Audio.Renderer

Parameters

Example

import { BusinessError } from '@ohos.base';

audioStreamManager.getCurrentAudioCapturerInfoArray(async (err: BusinessError, AudioCapturerChangeInfoArray: audio.AudioCapturerChangeInfoArray) => {
  console.info('getCurrentAudioCapturerInfoArray **** Get Callback Called ****');
  if (err) {
    console.error(`getCurrentAudioCapturerInfoArray :ERROR: ${err}`);
  } else {
    if (AudioCapturerChangeInfoArray != null) {
      for (let i = 0; i < AudioCapturerChangeInfoArray.length; i++) {
        console.info(`StreamId for ${i} is: ${AudioCapturerChangeInfoArray[i].streamId}`);
        console.info(`Source for ${i} is: ${AudioCapturerChangeInfoArray[i].capturerInfo.source}`);
        console.info(`Flag  ${i} is: ${AudioCapturerChangeInfoArray[i].capturerInfo.capturerFlags}`);
        for (let j = 0; j < AudioCapturerChangeInfoArray[i].deviceDescriptors.length; j++) {
          console.info(`Id: ${i} : ${AudioCapturerChangeInfoArray[i].deviceDescriptors[j].id}`);
          console.info(`Type: ${i} : ${AudioCapturerChangeInfoArray[i].deviceDescriptors[j].deviceType}`);
          console.info(`Role: ${i} : ${AudioCapturerChangeInfoArray[i].deviceDescriptors[j].deviceRole}`);
          console.info(`Name: ${i} : ${AudioCapturerChangeInfoArray[i].deviceDescriptors[j].name}`);
          console.info(`Address: ${i} : ${AudioCapturerChangeInfoArray[i].deviceDescriptors[j].address}`);
          console.info(`SampleRate: ${i} : ${AudioCapturerChangeInfoArray[i].deviceDescriptors[j].sampleRates[0]}`);
          console.info(`ChannelCount: ${i} : ${AudioCapturerChangeInfoArray[i].deviceDescriptors[j].channelCounts[0]}`);
          console.info(`ChannelMask: ${i} : ${AudioCapturerChangeInfoArray[i].deviceDescriptors[j].channelMasks[0]}`);
        }
      }
    }
  }
});

getCurrentAudioCapturerInfoArray⁹⁺

getCurrentAudioCapturerInfoArray(): Promise<AudioCapturerChangeInfoArray>

Obtains the information about the current audio capturer. This API uses a promise to return the result.

System capability: SystemCapability.Multimedia.Audio.Renderer

Return value

Example

import { BusinessError } from '@ohos.base';

async function getCurrentAudioCapturerInfoArray(){
  await audioStreamManager.getCurrentAudioCapturerInfoArray().then((AudioCapturerChangeInfoArray: audio.AudioCapturerChangeInfoArray) => {
    console.info('getCurrentAudioCapturerInfoArray **** Get Promise Called ****');
    if (AudioCapturerChangeInfoArray != null) {
      for (let i = 0; i < AudioCapturerChangeInfoArray.length; i++) {
        console.info(`StreamId for ${i} is: ${AudioCapturerChangeInfoArray[i].streamId}`);
        console.info(`Source for ${i} is: ${AudioCapturerChangeInfoArray[i].capturerInfo.source}`);
        console.info(`Flag  ${i} is: ${AudioCapturerChangeInfoArray[i].capturerInfo.capturerFlags}`);
        for (let j = 0; j < AudioCapturerChangeInfoArray[i].deviceDescriptors.length; j++) {
          console.info(`Id: ${i} : ${AudioCapturerChangeInfoArray[i].deviceDescriptors[j].id}`);
          console.info(`Type: ${i} : ${AudioCapturerChangeInfoArray[i].deviceDescriptors[j].deviceType}`);
          console.info(`Role: ${i} : ${AudioCapturerChangeInfoArray[i].deviceDescriptors[j].deviceRole}`);
          console.info(`Name: ${i} : ${AudioCapturerChangeInfoArray[i].deviceDescriptors[j].name}`);
          console.info(`Address: ${i} : ${AudioCapturerChangeInfoArray[i].deviceDescriptors[j].address}`);
          console.info(`SampleRate: ${i} : ${AudioCapturerChangeInfoArray[i].deviceDescriptors[j].sampleRates[0]}`);
          console.info(`ChannelCount: ${i} : ${AudioCapturerChangeInfoArray[i].deviceDescriptors[j].channelCounts[0]}`);
          console.info(`ChannelMask: ${i} : ${AudioCapturerChangeInfoArray[i].deviceDescriptors[j].channelMasks[0]}`);
        }
      }
    }
  }).catch((err: BusinessError) => {
    console.error(`getCurrentAudioCapturerInfoArray :ERROR: ${err}`);
  });
}

getCurrentAudioCapturerInfoArraySync¹⁰⁺

getCurrentAudioCapturerInfoArraySync(): AudioCapturerChangeInfoArray

Obtains the information about the current audio capturer. This API returns the result synchronously.

System capability: SystemCapability.Multimedia.Audio.Capturer

Return value

Example

import { BusinessError } from '@ohos.base';

try {
  let audioCapturerChangeInfoArray: audio.AudioCapturerChangeInfoArray = audioStreamManager.getCurrentAudioCapturerInfoArraySync();
  console.info('getCurrentAudioCapturerInfoArraySync success.');
  if (audioCapturerChangeInfoArray != null) {
    for (let i = 0; i < audioCapturerChangeInfoArray.length; i++) {
      console.info(`StreamId for ${i} is: ${audioCapturerChangeInfoArray[i].streamId}`);
      console.info(`Source for ${i} is: ${audioCapturerChangeInfoArray[i].capturerInfo.source}`);
      console.info(`Flag  ${i} is: ${audioCapturerChangeInfoArray[i].capturerInfo.capturerFlags}`);
      for (let j = 0; j < audioCapturerChangeInfoArray[i].deviceDescriptors.length; j++) {
        console.info(`Id: ${i} : ${audioCapturerChangeInfoArray[i].deviceDescriptors[j].id}`);
        console.info(`Type: ${i} : ${audioCapturerChangeInfoArray[i].deviceDescriptors[j].deviceType}`);
        console.info(`Role: ${i} : ${audioCapturerChangeInfoArray[i].deviceDescriptors[j].deviceRole}`);
        console.info(`Name: ${i} : ${audioCapturerChangeInfoArray[i].deviceDescriptors[j].name}`);
        console.info(`Address: ${i} : ${audioCapturerChangeInfoArray[i].deviceDescriptors[j].address}`);
        console.info(`SampleRate: ${i} : ${audioCapturerChangeInfoArray[i].deviceDescriptors[j].sampleRates[0]}`);
        console.info(`ChannelCount: ${i} : ${audioCapturerChangeInfoArray[i].deviceDescriptors[j].channelCounts[0]}`);
        console.info(`ChannelMask: ${i} : ${audioCapturerChangeInfoArray[i].deviceDescriptors[j].channelMasks[0]}`);
      }
    }
  }
} catch (err) {
  let error = err as BusinessError;
  console.error(`getCurrentAudioCapturerInfoArraySync ERROR: ${error}`);
}

on('audioRendererChange')⁹⁺

on(type: 'audioRendererChange', callback: Callback<AudioRendererChangeInfoArray>): void

Subscribes to audio renderer change events. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.Multimedia.Audio.Renderer

Parameters

Error codes

For details about the error codes, see Audio Error Codes.

Example

audioStreamManager.on('audioRendererChange',  (AudioRendererChangeInfoArray: audio.AudioRendererChangeInfoArray) => {
  for (let i = 0; i < AudioRendererChangeInfoArray.length; i++) {
    let AudioRendererChangeInfo: audio.AudioRendererChangeInfo = AudioRendererChangeInfoArray[i];
    console.info(`## RendererChange on is called for ${i} ##`);
    console.info(`StreamId for ${i} is: ${AudioRendererChangeInfo.streamId}`);
    console.info(`Content ${i} is: ${AudioRendererChangeInfo.rendererInfo.content}`);
    console.info(`Stream ${i} is: ${AudioRendererChangeInfo.rendererInfo.usage}`);
    console.info(`Flag ${i} is: ${AudioRendererChangeInfo.rendererInfo.rendererFlags}`);
    for (let j = 0;j < AudioRendererChangeInfo.deviceDescriptors.length; j++) {
      console.info(`Id: ${i} : ${AudioRendererChangeInfo.deviceDescriptors[j].id}`);
      console.info(`Type: ${i} : ${AudioRendererChangeInfo.deviceDescriptors[j].deviceType}`);
      console.info(`Role: ${i} : ${AudioRendererChangeInfo.deviceDescriptors[j].deviceRole}`);
      console.info(`Name: ${i} : ${AudioRendererChangeInfo.deviceDescriptors[j].name}`);
      console.info(`Address: ${i} : ${AudioRendererChangeInfo.deviceDescriptors[j].address}`);
      console.info(`SampleRate: ${i} : ${AudioRendererChangeInfo.deviceDescriptors[j].sampleRates[0]}`);
      console.info(`ChannelCount: ${i} : ${AudioRendererChangeInfo.deviceDescriptors[j].channelCounts[0]}`);
      console.info(`ChannelMask: ${i} : ${AudioRendererChangeInfo.deviceDescriptors[j].channelMasks[0]}`);
    }
  }
});

off('audioRendererChange')⁹⁺

off(type: 'audioRendererChange'): void

Unsubscribes from audio renderer change events.

System capability: SystemCapability.Multimedia.Audio.Renderer

Parameters

Error codes

For details about the error codes, see Audio Error Codes.

Example

audioStreamManager.off('audioRendererChange');
console.info('######### RendererChange Off is called #########');

on('audioCapturerChange')⁹⁺

on(type: 'audioCapturerChange', callback: Callback<AudioCapturerChangeInfoArray>): void

Subscribes to audio capturer change events. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.Multimedia.Audio.Capturer

Parameters

Error codes

For details about the error codes, see Audio Error Codes.

Example

audioStreamManager.on('audioCapturerChange', (AudioCapturerChangeInfoArray: audio.AudioCapturerChangeInfoArray) =>  {
  for (let i = 0; i < AudioCapturerChangeInfoArray.length; i++) {
    console.info(`## CapChange on is called for element ${i} ##`);
    console.info(`StreamId for ${i} is: ${AudioCapturerChangeInfoArray[i].streamId}`);
    console.info(`Source for ${i} is: ${AudioCapturerChangeInfoArray[i].capturerInfo.source}`);
    console.info(`Flag  ${i} is: ${AudioCapturerChangeInfoArray[i].capturerInfo.capturerFlags}`);
    for (let j = 0; j < AudioCapturerChangeInfoArray[i].deviceDescriptors.length; j++) {
      console.info(`Id: ${i} : ${AudioCapturerChangeInfoArray[i].deviceDescriptors[j].id}`);
      console.info(`Type: ${i} : ${AudioCapturerChangeInfoArray[i].deviceDescriptors[j].deviceType}`);
      console.info(`Role: ${i} : ${AudioCapturerChangeInfoArray[i].deviceDescriptors[j].deviceRole}`);
      console.info(`Name: ${i} : ${AudioCapturerChangeInfoArray[i].deviceDescriptors[j].name}`);
      console.info(`Address: ${i} : ${AudioCapturerChangeInfoArray[i].deviceDescriptors[j].address}`);
      console.info(`SampleRate: ${i} : ${AudioCapturerChangeInfoArray[i].deviceDescriptors[j].sampleRates[0]}`);
      console.info(`ChannelCount: ${i} : ${AudioCapturerChangeInfoArray[i].deviceDescriptors[j].channelCounts[0]}`);
      console.info(`ChannelMask: ${i} : ${AudioCapturerChangeInfoArray[i].deviceDescriptors[j].channelMasks[0]}`);
    }
  }
});

off('audioCapturerChange')⁹⁺

off(type: 'audioCapturerChange'): void

Unsubscribes from audio capturer change events.

System capability: SystemCapability.Multimedia.Audio.Capturer

Parameters

Error codes

For details about the error codes, see Audio Error Codes.

Example

audioStreamManager.off('audioCapturerChange');
console.info('######### CapturerChange Off is called #########');

isActive⁹⁺

isActive(volumeType: AudioVolumeType, callback: AsyncCallback<boolean>): void

Checks whether a stream is active. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.Multimedia.Audio.Renderer

Parameters

Example

import { BusinessError } from '@ohos.base';

audioStreamManager.isActive(audio.AudioVolumeType.MEDIA, (err: BusinessError, value: boolean) => {
if (err) {
  console.error(`Failed to obtain the active status of the stream. ${err}`);
  return;
}
  console.info(`Callback invoked to indicate that the active status of the stream is obtained ${value}.`);
});

isActive⁹⁺

isActive(volumeType: AudioVolumeType): Promise<boolean>

Checks whether a stream is active. This API uses a promise to return the result.

System capability: SystemCapability.Multimedia.Audio.Renderer

Parameters

Return value

Example

audioStreamManager.isActive(audio.AudioVolumeType.MEDIA).then((value: boolean) => {
  console.info(`Promise returned to indicate that the active status of the stream is obtained ${value}.`);
});

isActiveSync¹⁰⁺

isActiveSync(volumeType: AudioVolumeType): boolean

Checks whether a stream is active. This API returns the result synchronously.

System capability: SystemCapability.Multimedia.Audio.Renderer

Parameters

Return value

Error codes

For details about the error codes, see Audio Error Codes.

Example

import { BusinessError } from '@ohos.base';

try {
  let value: boolean = audioStreamManager.isActiveSync(audio.AudioVolumeType.MEDIA);
  console.info(`Indicate that the active status of the stream is obtained ${value}.`);
} catch (err) {
  let error = err as BusinessError;
  console.error(`Failed to obtain the active status of the stream ${error}.`);
}

getAudioEffectInfoArray¹⁰⁺

getAudioEffectInfoArray(usage: StreamUsage, callback: AsyncCallback<AudioEffectInfoArray>): void

Obtains information about the audio effect mode in use. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.Multimedia.Audio.Renderer

Parameters

Error codes

For details about the error codes, see Audio Error Codes.

Example

import { BusinessError } from '@ohos.base';

audioStreamManager.getAudioEffectInfoArray(audio.StreamUsage.STREAM_USAGE_MUSIC, async (err: BusinessError, audioEffectInfoArray: audio.AudioEffectInfoArray) => {
  console.info('getAudioEffectInfoArray **** Get Callback Called ****');
  if (err) {
    console.error(`getAudioEffectInfoArray :ERROR: ${err}`);
    return;
  } else {
    console.info(`The effect modes are: ${audioEffectInfoArray}`);
  }
});

getAudioEffectInfoArray¹⁰⁺

getAudioEffectInfoArray(usage: StreamUsage): Promise<AudioEffectInfoArray>

Obtains information about the audio effect mode in use. This API uses a promise to return the result.

System capability: SystemCapability.Multimedia.Audio.Renderer

Parameters

Return value

Error codes

For details about the error codes, see Audio Error Codes.

Example

import { BusinessError } from '@ohos.base';

audioStreamManager.getAudioEffectInfoArray(audio.StreamUsage.STREAM_USAGE_MUSIC).then((audioEffectInfoArray: audio.AudioEffectInfoArray) => {
  console.info('getAudioEffectInfoArray ######### Get Promise is called ##########');
  console.info(`The effect modes are: ${audioEffectInfoArray}`);
}).catch((err: BusinessError) => {
  console.error(`getAudioEffectInfoArray :ERROR: ${err}`);
});

getAudioEffectInfoArraySync¹⁰⁺

getAudioEffectInfoArraySync(usage: StreamUsage): AudioEffectInfoArray

Obtains information about the audio effect mode in use. This API returns the result synchronously.

System capability: SystemCapability.Multimedia.Audio.Renderer

Parameters

Return value

Error codes

For details about the error codes, see Audio Error Codes.

Example

import { BusinessError } from '@ohos.base';

try {
  let audioEffectInfoArray: audio.AudioEffectInfoArray = audioStreamManager.getAudioEffectInfoArraySync(audio.StreamUsage.STREAM_USAGE_MUSIC);
  console.info(`The effect modes are: ${audioEffectInfoArray}`);
} catch (err) {
  let error = err as BusinessError;
  console.error(`getAudioEffectInfoArraySync ERROR: ${error}`);
}

AudioRoutingManager⁹⁺

Implements audio routing management. Before calling any API in AudioRoutingManager, you must use getRoutingManager to obtain an AudioRoutingManager instance.

getDevices⁹⁺

getDevices(deviceFlag: DeviceFlag, callback: AsyncCallback<AudioDeviceDescriptors>): void

Obtains the audio devices with a specific flag. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.Multimedia.Audio.Device

Parameters

Example

import { BusinessError } from '@ohos.base';

audioRoutingManager.getDevices(audio.DeviceFlag.OUTPUT_DEVICES_FLAG, (err: BusinessError, value: audio.AudioDeviceDescriptors) => {
  if (err) {
    console.error(`Failed to obtain the device list. ${err}`);
    return;
  }
  console.info('Callback invoked to indicate that the device list is obtained.');
});

getDevices⁹⁺

getDevices(deviceFlag: DeviceFlag): Promise<AudioDeviceDescriptors>

Obtains the audio devices with a specific flag. This API uses a promise to return the result.

System capability: SystemCapability.Multimedia.Audio.Device

Parameters

Return value

Example

audioRoutingManager.getDevices(audio.DeviceFlag.OUTPUT_DEVICES_FLAG).then((data: audio.AudioDeviceDescriptors) => {
  console.info('Promise returned to indicate that the device list is obtained.');
});

getDevicesSync¹⁰⁺

getDevicesSync(deviceFlag: DeviceFlag): AudioDeviceDescriptors

Obtains the audio devices with a specific flag. This API returns the result synchronously.

System capability: SystemCapability.Multimedia.Audio.Device

Parameters

Return value

Error codes

For details about the error codes, see Audio Error Codes.

Example

import { BusinessError } from '@ohos.base';

try {
  let data: audio.AudioDeviceDescriptors = audioRoutingManager.getDevicesSync(audio.DeviceFlag.OUTPUT_DEVICES_FLAG);
  console.info(`Indicate that the device list is obtained ${data}`);
} catch (err) {
  let error = err as BusinessError;
  console.error(`Failed to obtain the device list. ${error}`);
}

on('deviceChange')⁹⁺

on(type: 'deviceChange', deviceFlag: DeviceFlag, callback: Callback<DeviceChangeAction>): void

Subscribes to audio device connection change events. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.Multimedia.Audio.Device

Parameters

Error codes

For details about the error codes, see Audio Error Codes.

Example

audioRoutingManager.on('deviceChange', audio.DeviceFlag.OUTPUT_DEVICES_FLAG, (deviceChanged: audio.DeviceChangeAction) => {
  console.info('device change type : ' + deviceChanged.type);
  console.info('device descriptor size : ' + deviceChanged.deviceDescriptors.length);
  console.info('device change descriptor : ' + deviceChanged.deviceDescriptors[0].deviceRole);
  console.info('device change descriptor : ' + deviceChanged.deviceDescriptors[0].deviceType);
});

off('deviceChange')⁹⁺

off(type: 'deviceChange', callback?: Callback<DeviceChangeAction>): void

Unsubscribes from audio device connection change events. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.Multimedia.Audio.Device

Parameters

Error codes

For details about the error codes, see Audio Error Codes.

Example

audioRoutingManager.off('deviceChange');

setCommunicationDevice⁹⁺

setCommunicationDevice(deviceType: CommunicationDeviceType, active: boolean, callback: AsyncCallback<void>): void

Sets a communication device to the active state. This API uses an asynchronous callback to return the result.

This API will be deprecated in a later version due to function design changes. You are not advised to use it.

System capability: SystemCapability.Multimedia.Audio.Communication

Parameters

Example

import { BusinessError } from '@ohos.base';

audioRoutingManager.setCommunicationDevice(audio.CommunicationDeviceType.SPEAKER, true, (err: BusinessError) => {
  if (err) {
    console.error(`Failed to set the active status of the device. ${err}`);
    return;
  }
  console.info('Callback invoked to indicate that the device is set to the active status.');
});

setCommunicationDevice⁹⁺

setCommunicationDevice(deviceType: CommunicationDeviceType, active: boolean): Promise<void>

Sets a communication device to the active state. This API uses a promise to return the result.

This API will be deprecated in a later version due to function design changes. You are not advised to use it.

System capability: SystemCapability.Multimedia.Audio.Communication

Parameters

Return value

Example

audioRoutingManager.setCommunicationDevice(audio.CommunicationDeviceType.SPEAKER, true).then(() => {
  console.info('Promise returned to indicate that the device is set to the active status.');
});

isCommunicationDeviceActive⁹⁺

isCommunicationDeviceActive(deviceType: CommunicationDeviceType, callback: AsyncCallback<boolean>): void

Checks whether a communication device is active. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.Multimedia.Audio.Communication

Parameters

Example

import { BusinessError } from '@ohos.base';

audioRoutingManager.isCommunicationDeviceActive(audio.CommunicationDeviceType.SPEAKER, (err: BusinessError, value: boolean) => {
  if (err) {
    console.error(`Failed to obtain the active status of the device. ${err}`);
    return;
  }
  console.info('Callback invoked to indicate that the active status of the device is obtained.');
});

isCommunicationDeviceActive⁹⁺

isCommunicationDeviceActive(deviceType: CommunicationDeviceType): Promise<boolean>

Checks whether a communication device is active. This API uses a promise to return the result.

System capability: SystemCapability.Multimedia.Audio.Communication

Parameters

Return value

Example

audioRoutingManager.isCommunicationDeviceActive(audio.CommunicationDeviceType.SPEAKER).then((value: boolean) => {
  console.info(`Promise returned to indicate that the active status of the device is obtained ${value}.`);
});

isCommunicationDeviceActiveSync¹⁰⁺

isCommunicationDeviceActiveSync(deviceType: CommunicationDeviceType): boolean

Checks whether a communication device is active. This API returns the result synchronously.

System capability: SystemCapability.Multimedia.Audio.Communication

Parameters

Return value

Error codes

For details about the error codes, see Audio Error Codes.

Example

import { BusinessError } from '@ohos.base';

try {
  let value: boolean = audioRoutingManager.isCommunicationDeviceActiveSync(audio.CommunicationDeviceType.SPEAKER);
  console.info(`Indicate that the active status of the device is obtained ${value}.`);
} catch (err) {
  let error = err as BusinessError;
  console.error(`Failed to obtain the active status of the device ${error}.`);
}