@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.
• TonePlayer: tone player, used to manage and play Dual Tone Multi Frequency (DTMF) tones, such as dial tones and ringback tones.

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 localNetworkId = audio.LOCAL_NETWORK_ID;
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

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 featureAbility from '@ohos.ability.featureAbility';
import fs from '@ohos.file.fs';
import audio from '@ohos.multimedia.audio';

let 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 = {
  content: audio.ContentType.CONTENT_TYPE_SPEECH,
  usage: audio.StreamUsage.STREAM_USAGE_VOICE_COMMUNICATION,
  rendererFlags: 0
}

let 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 featureAbility from '@ohos.ability.featureAbility';
import fs from '@ohos.file.fs';
import audio from '@ohos.multimedia.audio';

let 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 = {
  content: audio.ContentType.CONTENT_TYPE_SPEECH,
  usage: audio.StreamUsage.STREAM_USAGE_VOICE_COMMUNICATION,
  rendererFlags: 0
}

let audioRendererOptions = {
  streamInfo: audioStreamInfo,
  rendererInfo: audioRendererInfo
}

let audioRenderer;
audio.createAudioRenderer(audioRendererOptions).then((data) => {
  audioRenderer = data;
  console.info('AudioFrameworkRenderLog: AudioRenderer Created : Success : Stream Type: SUCCESS');
}).catch((err) => {
  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

Parameters

Example

import audio from '@ohos.multimedia.audio';
let 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 = {
  source: audio.SourceType.SOURCE_TYPE_MIC,
  capturerFlags: 0
}

let 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

Parameters

Return value

Example

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

let 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 = {
  source: audio.SourceType.SOURCE_TYPE_MIC,
  capturerFlags: 0
}

let audioCapturerOptions = {
  streamInfo: audioStreamInfo,
  capturerInfo: audioCapturerInfo
}

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

audio.createTonePlayer⁹⁺

createTonePlayer(options: AudioRendererInfo, callback: AsyncCallback<TonePlayer>): void

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

System capability: SystemCapability.Multimedia.Audio.Tone

System API: This is a system API.

Parameters

Example

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

let audioRendererInfo = {
  content : audio.ContentType.CONTENT_TYPE_SONIFICATION,
  usage : audio.StreamUsage.STREAM_USAGE_MEDIA,
  rendererFlags : 0
}
let tonePlayer;

audio.createTonePlayer(audioRendererInfo, (err, data) => {
  console.info(`callback call createTonePlayer: audioRendererInfo: ${audioRendererInfo}`);
  if (err) {
    console.error(`callback call createTonePlayer return error: ${err.message}`);
  } else {
    console.info(`callback call createTonePlayer return data: ${data}`);
    tonePlayer = data;
  }
});

audio.createTonePlayer⁹⁺

createTonePlayer(options: AudioRendererInfo): Promise<TonePlayer>

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

System capability: SystemCapability.Multimedia.Audio.Tone

System API: This is a system API.

Parameters

Return value

Example

import audio from '@ohos.multimedia.audio';
let tonePlayer;
async function createTonePlayerBefore(){
  let audioRendererInfo = {
    content : audio.ContentType.CONTENT_TYPE_SONIFICATION,
    usage : audio.StreamUsage.STREAM_USAGE_MEDIA,
    rendererFlags : 0
  }
  tonePlayer = await audio.createTonePlayer(audioRendererInfo);
}

AudioVolumeType

Enumerates the audio stream types.

System capability: SystemCapability.Multimedia.Audio.Volume

InterruptRequestResultType⁹⁺

Enumerates the result types of audio interruption requests.

System capability: SystemCapability.Multimedia.Audio.Interrupt

System API: This is a system API.

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

ContentType

Enumerates the audio content types.

System capability: SystemCapability.Multimedia.Audio.Core

StreamUsage

Enumerates the audio stream usage.

System capability: SystemCapability.Multimedia.Audio.Core

InterruptRequestType⁹⁺

Enumerates the audio interruption request types.

System API: This is a system API.

System capability: SystemCapability.Multimedia.Audio.Interrupt

AudioState⁸⁺

Enumerates the audio states.

System capability: SystemCapability.Multimedia.Audio.Core

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

InterruptResult⁹⁺

Describes the audio interruption result.

System capability: SystemCapability.Multimedia.Audio.Interrupt

System API: This is a system API.

AudioRendererOptions⁸⁺

Describes audio renderer configurations.

System capability: SystemCapability.Multimedia.Audio.Renderer

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

ConnectType⁹⁺

Enumerates the types of connected devices.

System API: This is a system API.

System capability: SystemCapability.Multimedia.Audio.Volume

VolumeGroupInfos⁹⁺

Describes the volume group information. The value is an array of VolumeGroupInfo and is read-only.

System API: This is a system API.

System capability: SystemCapability.Multimedia.Audio.Volume

VolumeGroupInfo⁹⁺

Describes the volume group information.

System API: This is a system API.

System capability: SystemCapability.Multimedia.Audio.Volume

DeviceChangeAction

Describes the device connection status and device information.

System capability: SystemCapability.Multimedia.Audio.Device

DeviceChangeType

Enumerates the device connection statuses.

System capability: SystemCapability.Multimedia.Audio.Device

AudioCapturerOptions⁸⁺

Describes audio capturer configurations.

System capability: SystemCapability.Multimedia.Audio.Capturer

AudioCapturerInfo⁸⁺

Describes audio capturer information.

System capability: SystemCapability.Multimedia.Audio.Core

SourceType⁸⁺

Enumerates the audio source types.

System capability: SystemCapability.Multimedia.Audio.Core

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

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 can be obtained from the device manual. The example below is for reference only.

Required permissions: ohos.permission.MODIFY_AUDIO_SETTINGS

System capability: SystemCapability.Multimedia.Audio.Core

Parameters

Example

audioManager.setAudioParameter('key_example', 'value_example', (err) => {
  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

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 can be obtained from the device manual. The example below is for reference only.

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

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.

System capability: SystemCapability.Multimedia.Audio.Core

Parameters

Example

audioManager.getAudioParameter('key_example', (err, value) => {
  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

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.

System capability: SystemCapability.Multimedia.Audio.Core

Parameters

Return value

Example

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

setAudioScene⁸⁺

setAudioScene(scene: AudioScene, callback: AsyncCallback<void>): void

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

System API: This is a system API.

System capability: SystemCapability.Multimedia.Audio.Communication

Parameters

Example

audioManager.setAudioScene(audio.AudioScene.AUDIO_SCENE_PHONE_CALL, (err) => {
  if (err) {
    console.error(`Failed to set the audio scene mode.​ ${err}`);
    return;
  }
  console.info('Callback invoked to indicate a successful setting of the audio scene mode.');
});

setAudioScene⁸⁺

setAudioScene(scene: AudioScene): Promise<void>

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

System API: This is a system API.

System capability: SystemCapability.Multimedia.Audio.Communication

Parameters

Return value

Example

audioManager.setAudioScene(audio.AudioScene.AUDIO_SCENE_PHONE_CALL).then(() => {
  console.info('Promise returned to indicate a successful setting of the audio scene mode.');
}).catch ((err) => {
  console.error(`Failed to set the audio scene mode ${err}`);
});

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

audioManager.getAudioScene((err, value) => {
  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

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

getVolumeManager⁹⁺

getVolumeManager(): AudioVolumeManager

Obtains an AudioVolumeManager instance.

System capability: SystemCapability.Multimedia.Audio.Volume

Example

let audioVolumeManager = audioManager.getVolumeManager();

getStreamManager⁹⁺

getStreamManager(): AudioStreamManager

Obtains an AudioStreamManager instance.

System capability: SystemCapability.Multimedia.Audio.Core

Example

let audioStreamManager = audioManager.getStreamManager();

getRoutingManager⁹⁺

getRoutingManager(): AudioRoutingManager

Obtains an AudioRoutingManager instance.

System capability: SystemCapability.Multimedia.Audio.Device

Example

let 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

audioManager.setVolume(audio.AudioVolumeType.MEDIA, 10, (err) => {
  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

audioManager.getVolume(audio.AudioVolumeType.MEDIA, (err, value) => {
  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) => {
  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

audioManager.getMinVolume(audio.AudioVolumeType.MEDIA, (err, value) => {
  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) => {
  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

audioManager.getMaxVolume(audio.AudioVolumeType.MEDIA, (err, value) => {
  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) => {
  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. You are advised to use mute in AudioVolumeGroupManager. The substitute API is available only for system applications.

System capability: SystemCapability.Multimedia.Audio.Volume

Parameters

Example

audioManager.mute(audio.AudioVolumeType.MEDIA, true, (err) => {
  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. You are advised to use mute in AudioVolumeGroupManager. 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

audioManager.isMute(audio.AudioVolumeType.MEDIA, (err, value) => {
  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) => {
  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

audioManager.isActive(audio.AudioVolumeType.MEDIA, (err, value) => {
  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) => {
  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. You are advised to use setRingerMode 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.

System capability: SystemCapability.Multimedia.Audio.Communication

Parameters

Example

audioManager.setRingerMode(audio.AudioRingMode.RINGER_MODE_NORMAL, (err) => {
  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. You are advised to use setRingerMode 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.

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

audioManager.getRingerMode((err, value) => {
  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) => {
  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

audioManager.getDevices(audio.DeviceFlag.OUTPUT_DEVICES_FLAG, (err, value) => {
  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) => {
  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

audioManager.setDeviceActive(audio.ActiveDeviceType.SPEAKER, true, (err) => {
  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

audioManager.isDeviceActive(audio.ActiveDeviceType.SPEAKER, (err, value) => {
  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) => {
  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. You are advised to use setMicrophoneMute in AudioVolumeGroupManager.

Required permissions: ohos.permission.MICROPHONE

System capability: SystemCapability.Multimedia.Audio.Device

Parameters

Example

audioManager.setMicrophoneMute(true, (err) => {
  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. You are advised to use setMicrophoneMute in AudioVolumeGroupManager.

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

audioManager.isMicrophoneMute((err, value) => {
  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) => {
  console.info(`Promise returned to indicate that the mute status of the microphone is obtained ${value}.`);
});

on('volumeChange')⁹⁺

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

NOTE

You are advised to use on in AudioVolumeManager.

Subscribes to system volume change events.

System API: This is a system API.

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

Example

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

on('ringerModeChange')^(deprecated)

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

Subscribes to ringer mode change events.

NOTE

This API is supported since API version 8 and deprecated since API version 9. You are advised to use on('ringerModeChange') in AudioVolumeGroupManager.

System API: This is a system API.

System capability: SystemCapability.Multimedia.Audio.Communication

Parameters

Example

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

on('deviceChange')^(deprecated)

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

Subscribes to device change events. When a device is connected or disconnected, registered clients will receive the callback.

NOTE

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

System capability: SystemCapability.Multimedia.Audio.Device

Parameters

Example

audioManager.on('deviceChange', (deviceChanged) => {
  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 device change events.

NOTE

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

System capability: SystemCapability.Multimedia.Audio.Device

Parameters

Example

audioManager.off('deviceChange', (deviceChanged) => {
  console.info('Should be no callback.');
});

on('interrupt')

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.

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.

System capability: SystemCapability.Multimedia.Audio.Renderer

Parameters

Example

let interAudioInterrupt = {
  streamUsage:2,
  contentType:0,
  pauseWhenDucked:true
};
audioManager.on('interrupt', interAudioInterrupt, (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')

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

Unsubscribes from audio interruption events.

System capability: SystemCapability.Multimedia.Audio.Renderer

Parameters

Example

let interAudioInterrupt = {
  streamUsage:2,
  contentType:0,
  pauseWhenDucked:true
};
audioManager.off('interrupt', interAudioInterrupt, (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.

getVolumeGroupInfos⁹⁺

getVolumeGroupInfos(networkId: string, callback: AsyncCallback<VolumeGroupInfos>): void

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

System API: This is a system API.

System capability: SystemCapability.Multimedia.Audio.Volume

Parameters

Example

audioVolumeManager.getVolumeGroupInfos(audio.LOCAL_NETWORK_ID, (err, value) => {
  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.');
});

getVolumeGroupInfos⁹⁺

getVolumeGroupInfos(networkId: string): Promise<VolumeGroupInfos>

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

System API: This is a system API.

System capability: SystemCapability.Multimedia.Audio.Volume

Parameters

Return value

Example

async function getVolumeGroupInfos(){
  let volumegroupinfos = await audio.getAudioManager().getVolumeManager().getVolumeGroupInfos(audio.LOCAL_NETWORK_ID);
  console.info('Promise returned to indicate that the volumeGroup list is obtained.'+JSON.stringify(volumegroupinfos))
}

getVolumeGroupManager⁹⁺

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

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

System capability: SystemCapability.Multimedia.Audio.Volume

Parameters

Example

let groupid = audio.DEFAULT_VOLUME_GROUP_ID;
audioVolumeManager.getVolumeGroupManager(groupid, (err, value) => {
  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 audio group manager. This API uses a promise to return the result.

System capability: SystemCapability.Multimedia.Audio.Volume

Parameters

Return value

Example

let groupid = audio.DEFAULT_VOLUME_GROUP_ID;
let audioVolumeGroupManager;
getVolumeGroupManager();
async function getVolumeGroupManager(){
  audioVolumeGroupManager = await audioVolumeManager.getVolumeGroupManager(groupid);
  console.info('Callback invoked to indicate that the volume group infos list is obtained.');
}

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) => {
  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.

setVolume⁹⁺

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.

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 API: This is a system API.

System capability: SystemCapability.Multimedia.Audio.Volume

Parameters

Example

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

setVolume⁹⁺

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

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

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 API: This is a system API.

System capability: SystemCapability.Multimedia.Audio.Volume

Parameters

Return value

Example

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

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

audioVolumeGroupManager.getVolume(audio.AudioVolumeType.MEDIA, (err, value) => {
  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) => {
  console.info(`Promise returned to indicate that the volume is obtained ${value}.`);
});

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

audioVolumeGroupManager.getMinVolume(audio.AudioVolumeType.MEDIA, (err, value) => {
  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) => {
  console.info(`Promised returned to indicate that the minimum volume is obtained ${value}.`);
});

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

audioVolumeGroupManager.getMaxVolume(audio.AudioVolumeType.MEDIA, (err, value) => {
  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) => {
  console.info('Promised returned to indicate that the maximum volume is obtained.');
});

mute⁹⁺

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

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

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 API: This is a system API.

System capability: SystemCapability.Multimedia.Audio.Volume

Parameters

Example

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

mute⁹⁺

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

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

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 API: This is a system API.

System capability: SystemCapability.Multimedia.Audio.Volume

Parameters

Return value

Example

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

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

audioVolumeGroupManager.isMute(audio.AudioVolumeType.MEDIA, (err, value) => {
  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) => {
  console.info(`Promise returned to indicate that the mute status of the stream is obtained ${value}.`);
});

setRingerMode⁹⁺

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

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

Required permissions: ohos.permission.ACCESS_NOTIFICATION_POLICY

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

System API: This is a system API.

System capability: SystemCapability.Multimedia.Audio.Volume

Parameters

Example

audioVolumeGroupManager.setRingerMode(audio.AudioRingMode.RINGER_MODE_NORMAL, (err) => {
  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⁹⁺

setRingerMode(mode: AudioRingMode): Promise<void>

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

Required permissions: ohos.permission.ACCESS_NOTIFICATION_POLICY

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

System API: This is a system API.

System capability: SystemCapability.Multimedia.Audio.Volume

Parameters

Return value

Example

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

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

audioVolumeGroupManager.getRingerMode((err, value) => {
  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) => {
  console.info(`Promise returned to indicate that the ringer mode is obtained ${value}.`);
});

on('ringerModeChange')⁹⁺

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

Subscribes to ringer mode change events.

System capability: SystemCapability.Multimedia.Audio.Volume

Parameters

Error codes

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

Example

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

setMicrophoneMute⁹⁺

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

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

Required permissions: ohos.permission.MANAGE_AUDIO_CONFIG

System capability: SystemCapability.Multimedia.Audio.Volume

Parameters

Example

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

setMicrophoneMute⁹⁺

setMicrophoneMute(mute: boolean): Promise<void>

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

Required permissions: ohos.permission.MANAGE_AUDIO_CONFIG

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

audioVolumeGroupManager.isMicrophoneMute((err, value) => {
  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) => {
  console.info(`Promise returned to indicate that the mute status of the microphone is obtained ${value}.`);
});

on('micStateChange')⁹⁺

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

Subscribes to system microphone state change events.

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) => {
  console.info(`Current microphone status is: ${micStateChange.mute} `);
});

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

audioStreamManager.getCurrentAudioRendererInfoArray(async (err, 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 = AudioRendererChangeInfoArray[i];
        console.info(`StreamId for ${i} is: ${AudioRendererChangeInfo.streamId}`);
        console.info(`ClientUid for ${i} is: ${AudioRendererChangeInfo.clientUid}`);
        console.info(`Content ${i} is: ${AudioRendererChangeInfo.rendererInfo.content}`);
        console.info(`Stream ${i} is: ${AudioRendererChangeInfo.rendererInfo.usage}`);
        console.info(`Flag ${i} is: ${AudioRendererChangeInfo.rendererInfo.rendererFlags}`); 
        console.info(`State for ${i} is: ${AudioRendererChangeInfo.rendererState}`);  
        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(`SampleRates: ${i} : ${AudioRendererChangeInfo.deviceDescriptors[j].sampleRates[0]}`);
          console.info(`ChannelCount ${i} : ${AudioRendererChangeInfo.deviceDescriptors[j].channelCounts[0]}`);
          console.info(`ChannelMask: ${i} : ${AudioRendererChangeInfo.deviceDescriptors[j].channelMasks}`);
        }
      }
    }
  }
});

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

async function getCurrentAudioRendererInfoArray(){
  await audioStreamManager.getCurrentAudioRendererInfoArray().then( function (AudioRendererChangeInfoArray) {
    console.info(`getCurrentAudioRendererInfoArray ######### Get Promise is called ##########`);
    if (AudioRendererChangeInfoArray != null) {
      for (let i = 0; i < AudioRendererChangeInfoArray.length; i++) {
        let AudioRendererChangeInfo = AudioRendererChangeInfoArray[i];
        console.info(`StreamId for ${i} is: ${AudioRendererChangeInfo.streamId}`);
        console.info(`ClientUid for ${i} is: ${AudioRendererChangeInfo.clientUid}`);
        console.info(`Content ${i} is: ${AudioRendererChangeInfo.rendererInfo.content}`);
        console.info(`Stream ${i} is: ${AudioRendererChangeInfo.rendererInfo.usage}`);
        console.info(`Flag ${i} is: ${AudioRendererChangeInfo.rendererInfo.rendererFlags}`); 
        console.info(`State for ${i} is: ${AudioRendererChangeInfo.rendererState}`);  
        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(`SampleRates: ${i} : ${AudioRendererChangeInfo.deviceDescriptors[j].sampleRates[0]}`);
          console.info(`ChannelCount ${i} : ${AudioRendererChangeInfo.deviceDescriptors[j].channelCounts[0]}`);
          console.info(`ChannelMask: ${i} : ${AudioRendererChangeInfo.deviceDescriptors[j].channelMasks}`);
        }
      }
    }
  }).catch((err) => {
    console.error(`getCurrentAudioRendererInfoArray :ERROR: ${err}`);
  });
}

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

audioStreamManager.getCurrentAudioCapturerInfoArray(async (err, 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(`ClientUid for ${i} is: ${AudioCapturerChangeInfoArray[i].clientUid}`);
        console.info(`Source for ${i} is: ${AudioCapturerChangeInfoArray[i].capturerInfo.source}`);
        console.info(`Flag  ${i} is: ${AudioCapturerChangeInfoArray[i].capturerInfo.capturerFlags}`);
        console.info(`State for ${i} is: ${AudioCapturerChangeInfoArray[i].capturerState}`);  
        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(`SampleRates: ${i} : ${AudioCapturerChangeInfoArray[i].deviceDescriptors[j].sampleRates[0]}`);
          console.info(`ChannelCounts ${i} : ${AudioCapturerChangeInfoArray[i].deviceDescriptors[j].channelCounts[0]}`);
          console.info(`ChannelMask: ${i} : ${AudioCapturerChangeInfoArray[i].deviceDescriptors[j].channelMasks}`);
        }
      }
    }
  }
});

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

async function getCurrentAudioCapturerInfoArray(){
  await audioStreamManager.getCurrentAudioCapturerInfoArray().then( function (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(`ClientUid for ${i} is: ${AudioCapturerChangeInfoArray[i].clientUid}`);
        console.info(`Source for ${i} is: ${AudioCapturerChangeInfoArray[i].capturerInfo.source}`);
        console.info(`Flag  ${i} is: ${AudioCapturerChangeInfoArray[i].capturerInfo.capturerFlags}`);
        console.info(`State for ${i} is: ${AudioCapturerChangeInfoArray[i].capturerState}`);  
        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(`SampleRates: ${i} : ${AudioCapturerChangeInfoArray[i].deviceDescriptors[j].sampleRates[0]}`);
          console.info(`ChannelCounts ${i} : ${AudioCapturerChangeInfoArray[i].deviceDescriptors[j].channelCounts[0]}`);
          console.info(`ChannelMask: ${i} : ${AudioCapturerChangeInfoArray[i].deviceDescriptors[j].channelMasks}`);
        }
      }
    }
  }).catch((err) => {
    console.error(`getCurrentAudioCapturerInfoArray :ERROR: ${err}`);
  });
}

on('audioRendererChange')⁹⁺

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

Subscribes to 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.on('audioRendererChange',  (AudioRendererChangeInfoArray) => {
  for (let i = 0; i < AudioRendererChangeInfoArray.length; i++) {
    let AudioRendererChangeInfo = AudioRendererChangeInfoArray[i];
    console.info(`## RendererChange on is called for ${i} ##`);
    console.info(`StreamId for ${i} is: ${AudioRendererChangeInfo.streamId}`);
    console.info(`ClientUid for ${i} is: ${AudioRendererChangeInfo.clientUid}`);
    console.info(`Content ${i} is: ${AudioRendererChangeInfo.rendererInfo.content}`);
    console.info(`Stream ${i} is: ${AudioRendererChangeInfo.rendererInfo.usage}`);
    console.info(`Flag ${i} is: ${AudioRendererChangeInfo.rendererInfo.rendererFlags}`); 
    console.info(`State for ${i} is: ${AudioRendererChangeInfo.rendererState}`);  
    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(`SampleRates: ${i} : ${AudioRendererChangeInfo.deviceDescriptors[j].sampleRates[0]}`);
      console.info(`ChannelCount ${i} : ${AudioRendererChangeInfo.deviceDescriptors[j].channelCounts[0]}`);
      console.info(`ChannelMask: ${i} : ${AudioRendererChangeInfo.deviceDescriptors[j].channelMasks}`);
    }
  }
});

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.

System capability: SystemCapability.Multimedia.Audio.Capturer

Parameters

Error codes

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

Example

audioStreamManager.on('audioCapturerChange', (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(`ClientUid for ${i} is: ${AudioCapturerChangeInfoArray[i].clientUid}`);
    console.info(`Source for ${i} is: ${AudioCapturerChangeInfoArray[i].capturerInfo.source}`);
    console.info(`Flag  ${i} is: ${AudioCapturerChangeInfoArray[i].capturerInfo.capturerFlags}`);
    console.info(`State for ${i} is: ${AudioCapturerChangeInfoArray[i].capturerState}`);  
    let devDescriptor = AudioCapturerChangeInfoArray[i].deviceDescriptors;
    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(`SampleRates: ${i} : ${AudioCapturerChangeInfoArray[i].deviceDescriptors[j].sampleRates[0]}`);
      console.info(`ChannelCounts ${i} : ${AudioCapturerChangeInfoArray[i].deviceDescriptors[j].channelCounts[0]}`);
      console.info(`ChannelMask: ${i} : ${AudioCapturerChangeInfoArray[i].deviceDescriptors[j].channelMasks}`);
    }
  }
});

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

audioStreamManager.isActive(audio.AudioVolumeType.MEDIA, (err, value) => {
  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) => {
  console.info(`Promise returned to indicate that the active status of the stream is obtained ${value}.`);
});

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

audioRoutingManager.getDevices(audio.DeviceFlag.OUTPUT_DEVICES_FLAG, (err, value) => {
  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) => {
  console.info('Promise returned to indicate that the device list is obtained.');
});

on⁹⁺

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

Subscribes to device change events. When a device is connected or disconnected, registered clients will receive the callback.

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) => {
  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⁹⁺

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

Unsubscribes from device change events.

System capability: SystemCapability.Multimedia.Audio.Device

Parameters

Error codes

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

Example

audioRoutingManager.off('deviceChange', (deviceChanged) => {
  console.info('Should be no callback.');
});

selectInputDevice⁹⁺

selectInputDevice(inputAudioDevices: AudioDeviceDescriptors, callback: AsyncCallback<void>): void

Selects an audio input device. Only one input device can be selected. This API uses an asynchronous callback to return the result.

System API: This is a system API.

System capability: SystemCapability.Multimedia.Audio.Device

Parameters

Example

let inputAudioDeviceDescriptor = [{
    deviceRole : audio.DeviceRole.INPUT_DEVICE,
    deviceType : audio.DeviceType.EARPIECE,
    id : 1,
    name : "",
    address : "",
    sampleRates : [44100],
    channelCounts : [2],
    channelMasks : [0],
    networkId : audio.LOCAL_NETWORK_ID,
    interruptGroupId : 1,
    volumeGroupId : 1,
}];

async function selectInputDevice(){
  audioRoutingManager.selectInputDevice(inputAudioDeviceDescriptor, (err) => {
    if (err) {
      console.error(`Result ERROR: ${err}`);
    } else {
      console.info('Select input devices result callback: SUCCESS'); }
  });
}

selectInputDevice⁹⁺

selectInputDevice(inputAudioDevices: AudioDeviceDescriptors): Promise<void>

System API: This is a system API.

Selects an audio input device. Only one input device can be selected. This API uses a promise to return the result.

System capability: SystemCapability.Multimedia.Audio.Device

Parameters

Return value

Example

let inputAudioDeviceDescriptor = [{
    deviceRole : audio.DeviceRole.INPUT_DEVICE,
    deviceType : audio.DeviceType.EARPIECE,
    id : 1,
    name : "",
    address : "",
    sampleRates : [44100],
    channelCounts : [2],
    channelMasks : [0],
    networkId : audio.LOCAL_NETWORK_ID,
    interruptGroupId : 1,
    volumeGroupId : 1,
}];

async function getRoutingManager(){
    audioRoutingManager.selectInputDevice(inputAudioDeviceDescriptor).then(() => {
      console.info('Select input devices result promise: SUCCESS');
    }).catch((err) => {
      console.error(`Result ERROR: ${err}`);
    });
}

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.

System capability: SystemCapability.Multimedia.Audio.Communication

Parameters

Example

audioRoutingManager.setCommunicationDevice(audio.CommunicationDeviceType.SPEAKER, true, (err) => {
  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.

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

audioRoutingManager.isCommunicationDeviceActive(audio.CommunicationDeviceType.SPEAKER, (err, value) => {
  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) => {
  console.info(`Promise returned to indicate that the active status of the device is obtained ${value}.`);
});

selectOutputDevice⁹⁺

selectOutputDevice(outputAudioDevices: AudioDeviceDescriptors, callback: AsyncCallback<void>): void

Selects an audio output device. Currently, only one output device can be selected. This API uses an asynchronous callback to return the result.

System API: This is a system API.

System capability: SystemCapability.Multimedia.Audio.Device

Parameters

Example

let outputAudioDeviceDescriptor = [{
    deviceRole : audio.DeviceRole.OUTPUT_DEVICE,
    deviceType : audio.DeviceType.SPEAKER,
    id : 1,
    name : "",
    address : "",
    sampleRates : [44100],
    channelCounts : [2],
    channelMasks : [0],
    networkId : audio.LOCAL_NETWORK_ID,
    interruptGroupId : 1,
    volumeGroupId : 1,
}];

async function selectOutputDevice(){
  audioRoutingManager.selectOutputDevice(outputAudioDeviceDescriptor, (err) => {
    if (err) {
      console.error(`Result ERROR: ${err}`);
    } else {
      console.info('Select output devices result callback: SUCCESS'); }
  });
}

selectOutputDevice⁹⁺

selectOutputDevice(outputAudioDevices: AudioDeviceDescriptors): Promise<void>

System API: This is a system API.

Selects an audio output device. Currently, only one output device can be selected. This API uses a promise to return the result.

System capability: SystemCapability.Multimedia.Audio.Device

Parameters

Return value

Example

let outputAudioDeviceDescriptor = [{
    deviceRole : audio.DeviceRole.OUTPUT_DEVICE,
    deviceType : audio.DeviceType.SPEAKER,
    id : 1,
    name : "",
    address : "",
    sampleRates : [44100],
    channelCounts : [2],
    channelMasks : [0],
    networkId : audio.LOCAL_NETWORK_ID,
    interruptGroupId : 1,
    volumeGroupId : 1,
}];

async function selectOutputDevice(){
  audioRoutingManager.selectOutputDevice(outputAudioDeviceDescriptor).then(() => {
    console.info('Select output devices result promise: SUCCESS');
  }).catch((err) => {
    console.error(`Result ERROR: ${err}`);
  });
}

selectOutputDeviceByFilter⁹⁺

selectOutputDeviceByFilter(filter: AudioRendererFilter, outputAudioDevices: AudioDeviceDescriptors, callback: AsyncCallback<void>): void

System API: This is a system API.

Selects an audio output device based on the filter criteria. Currently, only one output device can be selected. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.Multimedia.Audio.Device

Parameters

Example

let outputAudioRendererFilter = {
  uid : 20010041,
  rendererInfo : {
    content : audio.ContentType.CONTENT_TYPE_MUSIC,
    usage : audio.StreamUsage.STREAM_USAGE_MEDIA,
    rendererFlags : 0 },
  rendererId : 0 };
  
let outputAudioDeviceDescriptor = [{
    deviceRole : audio.DeviceRole.OUTPUT_DEVICE,
    deviceType : audio.DeviceType.SPEAKER,
    id : 1,
    name : "",
    address : "",
    sampleRates : [44100],
    channelCounts : [2],
    channelMasks : [0],
    networkId : audio.LOCAL_NETWORK_ID,
    interruptGroupId : 1,
    volumeGroupId : 1,
}];

async function selectOutputDeviceByFilter(){
  audioRoutingManager.selectOutputDeviceByFilter(outputAudioRendererFilter, outputAudioDeviceDescriptor, (err) => {
    if (err) {
      console.error(`Result ERROR: ${err}`);
    } else {
      console.info('Select output devices by filter result callback: SUCCESS'); }
  });
}

selectOutputDeviceByFilter⁹⁺

selectOutputDeviceByFilter(filter: AudioRendererFilter, outputAudioDevices: AudioDeviceDescriptors): Promise<void>

System API: This is a system API.

Selects an audio output device based on the filter criteria. Currently, only one output device can be selected. This API uses a promise to return the result.

System capability: SystemCapability.Multimedia.Audio.Device

Parameters

Return value

Example

let outputAudioRendererFilter = {
  uid : 20010041,
  rendererInfo : {
    content : audio.ContentType.CONTENT_TYPE_MUSIC,
    usage : audio.StreamUsage.STREAM_USAGE_MEDIA,
    rendererFlags : 0 },
  rendererId : 0 };

let outputAudioDeviceDescriptor = [{
    deviceRole : audio.DeviceRole.OUTPUT_DEVICE,
    deviceType : audio.DeviceType.SPEAKER,
    id : 1,
    name : "",
    address : "",
    sampleRates : [44100],
    channelCounts : [2],
    channelMasks : [0],
    networkId : audio.LOCAL_NETWORK_ID,
    interruptGroupId : 1,
    volumeGroupId : 1,
}];

async function selectOutputDeviceByFilter(){
  audioRoutingManager.selectOutputDeviceByFilter(outputAudioRendererFilter, outputAudioDeviceDescriptor).then(() => {
    console.info('Select output devices by filter result promise: SUCCESS');
  }).catch((err) => {
    console.error(`Result ERROR: ${err}`);
  })
}

AudioRendererChangeInfoArray⁹⁺

Defines an AudioRenderChangeInfo array, which is read-only.

System capability: SystemCapability.Multimedia.Audio.Renderer

AudioRendererChangeInfo⁹⁺

Describes the audio renderer change event.

System capability: SystemCapability.Multimedia.Audio.Renderer

Example

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

const audioManager = audio.getAudioManager();
let audioStreamManager = audioManager.getStreamManager();
let resultFlag = false;

audioStreamManager.on('audioRendererChange',  (AudioRendererChangeInfoArray) => {
  for (let i = 0; i < AudioRendererChangeInfoArray.length; i++) {
    console.info(`## RendererChange on is called for ${i} ##`);
    console.info(`StreamId for ${i} is: ${AudioRendererChangeInfoArray[i].streamId}`);
    console.info(`ClientUid for ${i} is: ${AudioRendererChangeInfoArray[i].clientUid}`);
    console.info(`Content for ${i} is: ${AudioRendererChangeInfoArray[i].rendererInfo.content}`);
    console.info(`Stream for ${i} is: ${AudioRendererChangeInfoArray[i].rendererInfo.usage}`);
    console.info(`Flag ${i} is: ${AudioRendererChangeInfoArray[i].rendererInfo.rendererFlags}`);
    console.info(`State for ${i} is: ${AudioRendererChangeInfoArray[i].rendererState}`);
  	let devDescriptor = AudioRendererChangeInfoArray[i].deviceDescriptors;
  	for (let j = 0; j < AudioRendererChangeInfoArray[i].deviceDescriptors.length; j++) {
  	  console.info(`Id: ${i} : ${AudioRendererChangeInfoArray[i].deviceDescriptors[j].id}`);
  	  console.info(`Type: ${i} : ${AudioRendererChangeInfoArray[i].deviceDescriptors[j].deviceType}`);
  	  console.info(`Role: ${i} : ${AudioRendererChangeInfoArray[i].deviceDescriptors[j].deviceRole}`);
  	  console.info(`Name: ${i} : ${AudioRendererChangeInfoArray[i].deviceDescriptors[j].name}`);
  	  console.info(`Addr: ${i} : ${AudioRendererChangeInfoArray[i].deviceDescriptors[j].address}`);
  	  console.info(`SR: ${i} : ${AudioRendererChangeInfoArray[i].deviceDescriptors[j].sampleRates[0]}`);
  	  console.info(`C ${i} : ${AudioRendererChangeInfoArray[i].deviceDescriptors[j].channelCounts[0]}`);
  	  console.info(`CM: ${i} : ${AudioRendererChangeInfoArray[i].deviceDescriptors[j].channelMasks}`);
  	}
    if (AudioRendererChangeInfoArray[i].rendererState == 1 && devDescriptor != null) {
      resultFlag = true;
      console.info(`ResultFlag for ${i} is: ${resultFlag}`);
    }
  }
});

AudioCapturerChangeInfoArray⁹⁺

Defines an AudioCapturerChangeInfo array, which is read-only.

System capability: SystemCapability.Multimedia.Audio.Capturer

AudioCapturerChangeInfo⁹⁺

Describes the audio capturer change event.

System capability: SystemCapability.Multimedia.Audio.Capturer

Example

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

const audioManager = audio.getAudioManager();
let audioStreamManager = audioManager.getStreamManager();

let resultFlag = false;
audioStreamManager.on('audioCapturerChange', (AudioCapturerChangeInfoArray) =>  {
  for (let i = 0; i < AudioCapturerChangeInfoArray.length; i++) {
    console.info(`## CapChange on is called for element ${i} ##`);
    console.info(`StrId for  ${i} is: ${AudioCapturerChangeInfoArray[i].streamId}`);
    console.info(`CUid for ${i} is: ${AudioCapturerChangeInfoArray[i].clientUid}`);
    console.info(`Src for ${i} is: ${AudioCapturerChangeInfoArray[i].capturerInfo.source}`);
    console.info(`Flag ${i} is: ${AudioCapturerChangeInfoArray[i].capturerInfo.capturerFlags}`);
    console.info(`State for ${i} is: ${AudioCapturerChangeInfoArray[i].capturerState}`);
    let devDescriptor = AudioCapturerChangeInfoArray[i].deviceDescriptors;
    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(`Addr: ${i} : ${AudioCapturerChangeInfoArray[i].deviceDescriptors[j].address}`);
      console.info(`SR: ${i} : ${AudioCapturerChangeInfoArray[i].deviceDescriptors[j].sampleRates[0]}`);
      console.info(`C ${i} : ${AudioCapturerChangeInfoArray[i].deviceDescriptors[j].channelCounts[0]}`);
      console.info(`CM ${i} : ${AudioCapturerChangeInfoArray[i].deviceDescriptors[j].channelMasks}`);
    }
    if (AudioCapturerChangeInfoArray[i].capturerState == 1 && devDescriptor != null) {
      resultFlag = true;
      console.info(`ResultFlag for element ${i} is: ${resultFlag}`);
    }
  }
});

AudioDeviceDescriptors

Defines an AudioDeviceDescriptor array, which is read-only.

AudioDeviceDescriptor

Describes an audio device.

System capability: SystemCapability.Multimedia.Audio.Device

Example

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

function displayDeviceProp(value) {
  deviceRoleValue = value.deviceRole;
  deviceTypeValue = value.deviceType;
}

let deviceRoleValue = null;
let deviceTypeValue = null;
const promise = audio.getAudioManager().getDevices(1);
promise.then(function (value) {
  console.info('AudioFrameworkTest: Promise: getDevices OUTPUT_DEVICES_FLAG');
  value.forEach(displayDeviceProp);
  if (deviceTypeValue != null && deviceRoleValue != null){
    console.info('AudioFrameworkTest: Promise: getDevices : OUTPUT_DEVICES_FLAG :  PASS');
  } else {
    console.error('AudioFrameworkTest: Promise: getDevices : OUTPUT_DEVICES_FLAG :  FAIL');
  }
});

AudioRendererFilter⁹⁺

Implements filter criteria. Before calling selectOutputDeviceByFilter, you must obtain an AudioRendererFilter instance.

System API: This is a system API.

Example

let outputAudioRendererFilter = {
  "uid":20010041,
  "rendererInfo": {
    "contentType":audio.ContentType.CONTENT_TYPE_MUSIC,
    "streamUsage":audio.StreamUsage.STREAM_USAGE_MEDIA,
    "rendererFlags":0 },
  "rendererId":0 };

AudioRenderer⁸⁺

Provides APIs for audio rendering. Before calling any API in AudioRenderer, you must use createAudioRenderer to create an AudioRenderer instance.

Attributes

System capability: SystemCapability.Multimedia.Audio.Renderer

Example

let state = audioRenderer.state;

getRendererInfo⁸⁺

getRendererInfo(callback: AsyncCallback<AudioRendererInfo>): void

Obtains the renderer information of this AudioRenderer instance. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.Multimedia.Audio.Renderer

Parameters

Example

audioRenderer.getRendererInfo((err, rendererInfo) => {
  console.info('Renderer GetRendererInfo:');
  console.info(`Renderer content: ${rendererInfo.content}`);
  console.info(`Renderer usage: ${rendererInfo.usage}`);
  console.info(`Renderer flags: ${rendererInfo.rendererFlags}`);
});

getRendererInfo⁸⁺

getRendererInfo(): Promise<AudioRendererInfo>

Obtains the renderer information of this AudioRenderer instance. This API uses a promise to return the result.

System capability: SystemCapability.Multimedia.Audio.Renderer

Return value

Example

audioRenderer.getRendererInfo().then((rendererInfo) => {
  console.info('Renderer GetRendererInfo:');
  console.info(`Renderer content: ${rendererInfo.content}`);
  console.info(`Renderer usage: ${rendererInfo.usage}`);
  console.info(`Renderer flags: ${rendererInfo.rendererFlags}`)
}).catch((err) => {
  console.error(`AudioFrameworkRenderLog: RendererInfo :ERROR: ${err}`);
});

getStreamInfo⁸⁺

getStreamInfo(callback: AsyncCallback<AudioStreamInfo>): void

Obtains the stream information of this AudioRenderer instance. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.Multimedia.Audio.Renderer

Parameters

Example

audioRenderer.getStreamInfo((err, streamInfo) => {
  console.info('Renderer GetStreamInfo:');
  console.info(`Renderer sampling rate: ${streamInfo.samplingRate}`);
  console.info(`Renderer channel: ${streamInfo.channels}`);
  console.info(`Renderer format: ${streamInfo.sampleFormat}`);
  console.info(`Renderer encoding type: ${streamInfo.encodingType}`);
});

getStreamInfo⁸⁺

getStreamInfo(): Promise<AudioStreamInfo>

Obtains the stream information of this AudioRenderer instance. This API uses a promise to return the result.

System capability: SystemCapability.Multimedia.Audio.Renderer

Return value

Example

audioRenderer.getStreamInfo().then((streamInfo) => {
  console.info('Renderer GetStreamInfo:');
  console.info(`Renderer sampling rate: ${streamInfo.samplingRate}`);
  console.info(`Renderer channel: ${streamInfo.channels}`);
  console.info(`Renderer format: ${streamInfo.sampleFormat}`);
  console.info(`Renderer encoding type: ${streamInfo.encodingType}`);
}).catch((err) => {
  console.error(`ERROR: ${err}`);
});

getAudioStreamId⁹⁺

getAudioStreamId(callback: AsyncCallback<number>): void

Obtains the stream ID of this AudioRenderer instance. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.Multimedia.Audio.Renderer

Parameters

Example

audioRenderer.getAudioStreamId((err, streamid) => {
  console.info(`Renderer GetStreamId: ${streamid}`);
});

getAudioStreamId⁹⁺

getAudioStreamId(): Promise<number>

Obtains the stream ID of this AudioRenderer instance. This API uses a promise to return the result.

System capability: SystemCapability.Multimedia.Audio.Renderer

Return value

Example

audioRenderer.getAudioStreamId().then((streamid) => {
  console.info(`Renderer getAudioStreamId: ${streamid}`);
}).catch((err) => {
  console.error(`ERROR: ${err}`);
});

start⁸⁺

start(callback: AsyncCallback<void>): void

Starts the renderer. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.Multimedia.Audio.Renderer

Parameters

Example

audioRenderer.start((err) => {
  if (err) {
    console.error('Renderer start failed.');
  } else {
    console.info('Renderer start success.');
  }
});

start⁸⁺

start(): Promise<void>

Starts the renderer. This API uses a promise to return the result.

System capability: SystemCapability.Multimedia.Audio.Renderer

Return value

Example

audioRenderer.start().then(() => {
  console.info('Renderer started');
}).catch((err) => {
  console.error(`ERROR: ${err}`);
});

pause⁸⁺

pause(callback: AsyncCallback<void>): void

Pauses rendering. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.Multimedia.Audio.Renderer

Parameters

Example

audioRenderer.pause((err) => {
  if (err) {
    console.error('Renderer pause failed');
  } else {
    console.info('Renderer paused.');
  }
});

pause⁸⁺

pause(): Promise<void>

Pauses rendering. This API uses a promise to return the result.

System capability: SystemCapability.Multimedia.Audio.Renderer

Return value

Example

audioRenderer.pause().then(() => {
  console.info('Renderer paused');
}).catch((err) => {
  console.error(`ERROR: ${err}`);
});

drain⁸⁺

drain(callback: AsyncCallback<void>): void

Drains the playback buffer. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.Multimedia.Audio.Renderer

Parameters