Audio Management

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.

API version 9 is a canary release for trial use. The APIs of this version may be unstable.

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.

Modules to Import

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

audio.getAudioManager

getAudioManager(): AudioManager

Obtains an AudioManager instance.

System capability: SystemCapability.Multimedia.Audio.Core

Return value

Example

var audioManager = audio.getAudioManager();

audio.createAudioRenderer⁸⁺

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

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

System capability: SystemCapability.Multimedia.Audio.Renderer

Parameters

Example

import audio from '@ohos.multimedia.audio';
var audioStreamInfo = {
    samplingRate: audio.AudioSamplingRate.SAMPLE_RATE_44100,
    channels: audio.AudioChannel.CHANNEL_1,
    sampleFormat: audio.AudioSampleFormat.SAMPLE_FORMAT_S16LE,
    encodingType: audio.AudioEncodingType.ENCODING_TYPE_RAW
}

var audioRendererInfo = {
    content: audio.ContentType.CONTENT_TYPE_SPEECH,
    usage: audio.StreamUsage.STREAM_USAGE_VOICE_COMMUNICATION,
    rendererFlags: 1
}

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

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

audio.createAudioRenderer⁸⁺

createAudioRenderer(options: AudioRendererOptions): Promise<AudioRenderer>

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

System capability: SystemCapability.Multimedia.Audio.Renderer

Parameters

Return value

Example

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

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

var audioRendererInfo = {
    content: audio.ContentType.CONTENT_TYPE_SPEECH,
    usage: audio.StreamUsage.STREAM_USAGE_VOICE_COMMUNICATION,
    rendererFlags: 1
}

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

var audioRenderer;
audio.createAudioRenderer(audioRendererOptions).then((data) => {
    audioRenderer = data;
    console.info('AudioFrameworkRenderLog: AudioRenderer Created : Success : Stream Type: SUCCESS');
}).catch((err) => {
    console.info('AudioFrameworkRenderLog: AudioRenderer Created : ERROR : '+err.message);
});

audio.createAudioCapturer⁸⁺

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

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

System capability: SystemCapability.Multimedia.Audio.Capturer

Parameters

Example

import audio from '@ohos.multimedia.audio';
var audioStreamInfo = {
    samplingRate: audio.AudioSamplingRate.SAMPLE_RATE_44100,
    channels: audio.AudioChannel.CHANNEL_2,
    sampleFormat: audio.AudioSampleFormat.SAMPLE_FORMAT_S16LE,
    encodingType: audio.AudioEncodingType.ENCODING_TYPE_RAW
}

var audioCapturerInfo = {
    source: audio.SourceType.SOURCE_TYPE_MIC,
    capturerFlags: 1
}

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

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

audio.createAudioCapturer⁸⁺

createAudioCapturer(options: AudioCapturerOptions): Promise<AudioCapturer>

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

System capability: SystemCapability.Multimedia.Audio.Capturer

Parameters

Return value

Example

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

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

var audioCapturerInfo = {
    source: audio.SourceType.SOURCE_TYPE_MIC,
    capturerFlags: 1
}

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

var audioCapturer;
audio.createAudioRenderer(audioCapturerOptions).then((data) => {
    audioCapturer = data;
    console.info('AudioCapturer Created : Success : Stream Type: SUCCESS');
}).catch((err) => {
    console.info('AudioCapturer Created : ERROR : '+err.message);
});

AudioVolumeType

Enumerates the audio stream types.

System capability: SystemCapability.Multimedia.Audio.Volume

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

ActiveDeviceType

Enumerates the active device types.

System capability: SystemCapability.Multimedia.Audio.Device

AudioRingMode

Enumerates the ringer modes.

System capability: SystemCapability.Multimedia.Audio.Communication

AudioSampleFormat⁸⁺

Enumerate the audio sample formats.

System capability: SystemCapability.Multimedia.Audio.Core

AudioChannel⁸⁺

Enumerates the audio channels.

System capability: SystemCapability.Multimedia.Audio.Core

AudioSamplingRate⁸⁺

Enumerates the audio sampling rates.

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

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

InterruptActionType

Enumerates the returned event types for audio interruption events.

This API is defined but not implemented in OpenHarmony 3.1 Release. It will be available for use in OpenHarmony 3.1 MR.

System capability: SystemCapability.Multimedia.Audio.Renderer

AudioStreamInfo⁸⁺

Describes audio stream information.

System capability: SystemCapability.Multimedia.Audio.Core

AudioRendererInfo⁸⁺

Describes audio renderer information.

System capability: SystemCapability.Multimedia.Audio.Core

AudioRendererOptions⁸⁺

Describes audio renderer configurations.

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

AudioInterrupt

Describes input parameters of audio interruption events.

This API is defined but not implemented in OpenHarmony 3.1 Release. It will be available for use in OpenHarmony 3.1 MR.

System capability: SystemCapability.Multimedia.Audio.Renderer

InterruptAction

Describes the callback invoked for audio interruption or focus gain events.

This API is defined but not implemented in OpenHarmony 3.1 Release. It will be available for use in OpenHarmony 3.1 MR.

System capability: SystemCapability.Multimedia.Audio.Renderer

VolumeEvent⁸⁺

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

This is a system API and cannot be called by third-party applications.

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.

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.

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.message}');
        return;
    }
    console.log('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.

System capability: SystemCapability.Multimedia.Audio.Volume

Parameters

Return value

Example

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

audioManager.getVolume(audio.AudioVolumeType.MEDIA, (err, value) => {
   if (err) {
       console.error('Failed to obtain the volume. ${err.message}');
       return;
   }
   console.log('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

audioManager.getVolume(audio.AudioVolumeType.MEDIA).then((value) => {
    console.log('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

audioManager.getMinVolume(audio.AudioVolumeType.MEDIA, (err, value) => {
    if (err) {
        console.error('Failed to obtain the minimum volume. ${err.message}');
        return;
    }
    console.log('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

audioManager.getMinVolume(audio.AudioVolumeType.MEDIA).then((value) => {
    console.log('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

audioManager.getMaxVolume(audio.AudioVolumeType.MEDIA, (err, value) => {
    if (err) {
        console.error('Failed to obtain the maximum volume. ${err.message}');
        return;
    }
    console.log('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

audioManager.getMaxVolume(audio.AudioVolumeType.MEDIA).then((data) => {
    console.log('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.

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.message}');
        return;
    }
    console.log('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.

System capability: SystemCapability.Multimedia.Audio.Volume

Parameters

Return value

Example

audioManager.mute(audio.AudioVolumeType.MEDIA, true).then(() => {
    console.log('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

audioManager.isMute(audio.AudioVolumeType.MEDIA, (err, value) => {
   if (err) {
       console.error('Failed to obtain the mute status. ${err.message}');
       return;
   }
   console.log('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 method uses a promise to return the result.

System capability: SystemCapability.Multimedia.Audio.Volume

Parameters

Return value

Example

audioManager.isMute(audio.AudioVolumeType.MEDIA).then((value) => {
    console.log('Promise returned to indicate that the mute status of the stream is obtained.' + value);
});

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.Volume

Parameters

Example

audioManager.isActive(audio.AudioVolumeType.MEDIA, (err, value) => {
    if (err) {
        console.error('Failed to obtain the active status of the stream. ${err.message}');
        return;
    }
    console.log('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 method uses a promise to return the result.

System capability: SystemCapability.Multimedia.Audio.Volume

Parameters

Return value

Example

audioManager.isActive(audio.AudioVolumeType.MEDIA).then((value) => {
    console.log('Promise returned to indicate that the active 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.

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.message}');
       return;
    }
    console.log('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.

System capability: SystemCapability.Multimedia.Audio.Communication

Parameters

Return value

Example

audioManager.setRingerMode(audio.AudioRingMode.RINGER_MODE_NORMAL).then(() => {
    console.log('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.Communication

Parameters

Example

audioManager.getRingerMode((err, value) => {
   if (err) {
       console.error('Failed to obtain the ringer mode.​ ${err.message}');
       return;
   }
   console.log('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.Communication

Return value

Example

audioManager.getRingerMode().then((value) => {
    console.log('Promise returned to indicate that the ringer mode is obtained.' + value);
});

setAudioParameter

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

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

System capability: SystemCapability.Multimedia.Audio.Core

Parameters

Example

audioManager.setAudioParameter('PBits per sample', '8 bit', (err) => {
    if (err) {
        console.error('Failed to set the audio parameter. ${err.message}');
        return;
    }
    console.log('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.

System capability: SystemCapability.Multimedia.Audio.Core

Parameters

Return value

Example

audioManager.setAudioParameter('PBits per sample', '8 bit').then(() => {
    console.log('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.

System capability: SystemCapability.Multimedia.Audio.Core

Parameters

Example

audioManager.getAudioParameter('PBits per sample', (err, value) => {
    if (err) {
        console.error('Failed to obtain the value of the audio parameter. ${err.message}');
        return;
    }
    console.log('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.

System capability: SystemCapability.Multimedia.Audio.Core

Parameters

Return value

Example

audioManager.getAudioParameter('PBits per sample').then((value) => {
    console.log('Promise returned to indicate that the value of the audio parameter is obtained.' + value);
});

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

audioManager.getDevices(audio.DeviceFlag.OUTPUT_DEVICES_FLAG, (err, value) => {
   if (err) {
       console.error('Failed to obtain the device list. ${err.message}');
       return;
   }
   console.log('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

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

setDeviceActive

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.

System capability: SystemCapability.Multimedia.Audio.Device

Parameters

Example

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

setDeviceActive

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

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

System capability: SystemCapability.Multimedia.Audio.Device

Parameters

Return value

Example

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

isDeviceActive

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

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

System capability: SystemCapability.Multimedia.Audio.Device

Parameters

Example

audioManager.isDeviceActive(audio.DeviceType.SPEAKER, (err, value) => {
    if (err) {
        console.error('Failed to obtain the active status of the device. ${err.message}');
        return;
    }
    console.log('Callback invoked to indicate that the active status of the device is obtained.');
});

isDeviceActive

isDeviceActive(deviceType: ActiveDeviceType): Promise<boolean>

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

System capability: SystemCapability.Multimedia.Audio.Device

Parameters

Return value

Example

audioManager.isDeviceActive(audio.DeviceType.SPEAKER).then((value) => {
    console.log('Promise returned to indicate that the active status of the device is obtained.' + value);
});

setMicrophoneMute

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

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

System capability: SystemCapability.Multimedia.Audio.Device

Parameters

Example

audioManager.setMicrophoneMute(true, (err) => {
    if (err) {
        console.error('Failed to mute the microphone. ${err.message}');
        return;
    }
    console.log('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.

System capability: SystemCapability.Multimedia.Audio.Device

Parameters

Return value

Example

audioManager.setMicrophoneMute(true).then(() => {
    console.log('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.Device

Parameters

Example

audioManager.isMicrophoneMute((err, value) => {
    if (err) {
        console.error('Failed to obtain the mute status of the microphone. ${err.message}');
        return;
    }
    console.log('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.Device

Return value

Example

audioManager.isMicrophoneMute().then((value) => {
    console.log('Promise returned to indicate that the mute status of the microphone is obtained.', + value);
});

on('volumeChange')⁸⁺

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

Subscribes to system volume change events.

This is a system API and cannot be called by third-party applications.

System capability: SystemCapability.Multimedia.Audio.Volume

Parameters

Example

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

on('ringerModeChange')⁸⁺

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

Subscribes to ringer mode change events.

This is a system API and cannot be called by third-party applications.

System capability: SystemCapability.Multimedia.Audio.Communication

Parameters

Example

audioManager.on('ringerModeChange', (ringerMode) => {
    console.log('Updated ringermode: ' + ringerMode);
});

on('deviceChange')

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.

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')

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

Unsubscribes from device change events.

This API is defined but not implemented in OpenHarmony 3.1 Release. It will be available for use in OpenHarmony 3.1 MR.

System capability: SystemCapability.Multimedia.Audio.Device

Parameters

Example

audioManager.off('deviceChange', (deviceChanged) => {
    console.log("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.

This API is defined but not implemented in OpenHarmony 3.1 Release. It will be available for use in OpenHarmony 3.1 MR.

System capability: SystemCapability.Multimedia.Audio.Renderer

Parameters

Example

var interAudioInterrupt = {
    streamUsage:2,
    contentType:0,
    pauseWhenDucked:true
};
this.audioManager.on('interrupt', interAudioInterrupt, (InterruptAction) => {
    if (InterruptAction.actionType === 0) {
        console.log("An event to gain the audio focus starts.");
        console.log("Focus gain event:" + JSON.stringify(InterruptAction));
    }
    if (InterruptAction.actionType === 1) {
        console.log("An audio interruption event starts.");
        console.log("Audio interruption event:" + JSON.stringify(InterruptAction));
    }
});

off('interrupt')

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

Unsubscribes from audio interruption events.

This API is defined but not implemented in OpenHarmony 3.1 Release. It will be available for use in OpenHarmony 3.1 MR.

System capability: SystemCapability.Multimedia.Audio.Renderer

Parameters

Example

var interAudioInterrupt = {
    streamUsage:2,
    contentType:0,
    pauseWhenDucked:true
};
this.audioManager.off('interrupt', interAudioInterrupt, (InterruptAction) => {
    if (InterruptAction.actionType === 0) {
        console.log("An event to release the audio focus starts.");
        console.log("Focus release event:" + JSON.stringify(InterruptAction));
    }
});

setAudioScene⁸⁺

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

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

This is a system API and cannot be called by third-party applications.

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.message}');
       return;
    }
    console.log('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.

This is a system API and cannot be called by third-party applications.

System capability: SystemCapability.Multimedia.Audio.Communication

Parameters

Return value

Example

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

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.message}');
       return;
   }
   console.log('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.log('Promise returned to indicate that the audio scene mode is obtained.' + value);
}).catch ((err) => {
    console.log('Failed to obtain the audio scene mode');
});

AudioDeviceDescriptor

Describes an audio device.

System capability: SystemCapability.Multimedia.Audio.Device

AudioDeviceDescriptors

Array of AudioDeviceDescriptor, which is read-only.

Example

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

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

}

var deviceRoleValue = null;
var 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.info('AudioFrameworkTest: Promise: getDevices : OUTPUT_DEVICES_FLAG :  FAIL');
    }
});

AudioRenderer⁸⁺

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

System capability: SystemCapability.Multimedia.Audio.Renderer

state⁸⁺

Readonly state: AudioState

Defines the state of the audio renderer.

Parameters

Example

var 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.log('Renderer GetRendererInfo:');
    console.log('Renderer content:' + rendererInfo.content);
    console.log('Renderer usage:' + rendererInfo.usage);
    console.log('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.log('Renderer GetRendererInfo:');
    console.log('Renderer content:' + rendererInfo.content);
    console.log('Renderer usage:' + rendererInfo.usage);
    console.log('Renderer flags:' + rendererInfo.rendererFlags);
}).catch((err) => {
    console.log('AudioFrameworkRenderLog: RendererInfo :ERROR: '+err.message);
    resultFlag = false;
});

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.log('Renderer GetStreamInfo:');
    console.log('Renderer sampling rate:' + streamInfo.samplingRate);
    console.log('Renderer channel:' + streamInfo.channels);
    console.log('Renderer format:' + streamInfo.sampleFormat);
    console.log('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.log('Renderer GetStreamInfo:');
    console.log('Renderer sampling rate:' + streamInfo.samplingRate);
    console.log('Renderer channel:' + streamInfo.channels);
    console.log('Renderer format:' + streamInfo.sampleFormat);
    console.log('Renderer encoding type:' + streamInfo.encodingType);
}).catch((err) => {
    console.log('ERROR: '+err.message);
});

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.log('Renderer started');
}).catch((err) => {
    console.log('ERROR: '+err.message);
});

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.log('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.log('Renderer paused');
}).catch((err) => {
    console.log('ERROR: '+err.message);
});

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

Example

audioRenderer.drain((err) => {
    if (err) {
        console.error('Renderer drain failed');
    } else {
        console.log('Renderer drained.');
    }
});

drain⁸⁺

drain(): Promise<void>

Drains the playback buffer. This API uses a promise to return the result.

System capability: SystemCapability.Multimedia.Audio.Renderer

Return value

Example

audioRenderer.drain().then(() => {
    console.log('Renderer drained successfully');
}).catch((err) => {
    console.log('ERROR: '+err.message);
});

stop⁸⁺

stop(callback: AsyncCallback<void>): void

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

System capability: SystemCapability.Multimedia.Audio.Renderer

Parameters

Example

audioRenderer.stop((err) => {
    if (err) {
        console.error('Renderer stop failed');
    } else {
        console.log('Renderer stopped.');
    }
});

stop⁸⁺

stop(): Promise<void>

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

System capability: SystemCapability.Multimedia.Audio.Renderer

Return value

Example

audioRenderer.stop().then(() => {
    console.log('Renderer stopped successfully');
}).catch((err) => {
    console.log('ERROR: '+err.message);
});

release⁸⁺

release(callback: AsyncCallback<void>): void

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

System capability: SystemCapability.Multimedia.Audio.Renderer

Parameters

Example

audioRenderer.release((err) => {
    if (err) {
        console.error('Renderer release failed');
    } else {
        console.log('Renderer released.');
    }
});

release⁸⁺

release(): Promise<void>

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

System capability: SystemCapability.Multimedia.Audio.Renderer

Return value

Example

audioRenderer.release().then(() => {
    console.log('Renderer released successfully');
}).catch((err) => {
    console.log('ERROR: '+err.message);
});

write⁸⁺

write(buffer: ArrayBuffer, callback: AsyncCallback<number>): void

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

System capability: SystemCapability.Multimedia.Audio.Renderer

Parameters

Example

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

let ss = fileio.createStreamSync(filePath, 'r');
let buf = new ArrayBuffer(bufferSize);
ss.readSync(buf);
audioRenderer.write(buf, (err, writtenbytes) => {
    if (writtenbytes < 0) {
        console.error('write failed.');
    } else {
       console.log('Actual written bytes: ' + writtenbytes);
    }
});

write⁸⁺

write(buffer: ArrayBuffer): Promise<number>

Writes the buffer. This API uses a promise to return the result.

System capability: SystemCapability.Multimedia.Audio.Renderer

Return value

Example

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

var filePath = 'data/StarWars10s-2C-48000-4SW.wav';
let ss = fileio.createStreamSync(filePath, 'r');
let buf = new ArrayBuffer(bufferSize);
ss.readSync(buf);
audioRenderer.write(buf).then((writtenbytes) => {
    if (writtenbytes < 0) {
        console.error('write failed.');
    } else {
        console.log('Actual written bytes: ' + writtenbytes);
    }
}).catch((err) => {
    console.log('ERROR: '+err.message);
});

getAudioTime⁸⁺

getAudioTime(callback: AsyncCallback<number>): void

Obtains the number of nanoseconds elapsed from the Unix epoch (January 1, 1970). This API uses an asynchronous callback to return the result.

System capability: SystemCapability.Multimedia.Audio.Renderer

Parameters

Example

audioRenderer.getAudioTime((err, timestamp) => {
    console.log('Current timestamp: ' + timestamp);
});

getAudioTime⁸⁺

getAudioTime(): Promise<number>

Obtains the number of nanoseconds elapsed from the Unix epoch (January 1, 1970). This API uses a promise to return the result.

System capability: SystemCapability.Multimedia.Audio.Renderer

Return value

Example

audioRenderer.getAudioTime().then((timestamp) => {
    console.log('Current timestamp: ' + timestamp);
}).catch((err) => {
    console.log('ERROR: '+err.message);
});

getBufferSize⁸⁺

getBufferSize(callback: AsyncCallback<number>): void

Obtains a reasonable minimum buffer size in bytes for rendering. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.Multimedia.Audio.Renderer

Parameters

Example

audioRenderer.getBufferSize((err, bufferSize) => {
    if (err) {
        console.error('getBufferSize error');
    }
});
let buf = new ArrayBuffer(bufferSize);
ss.readSync(buf);

getBufferSize⁸⁺

getBufferSize(): Promise<number>

Obtains a reasonable minimum buffer size in bytes for rendering. This API uses a promise to return the result.

System capability: SystemCapability.Multimedia.Audio.Renderer

Return value

Example

audioRenderer.getBufferSize().then((bufferSize) => {
    let buf = new ArrayBuffer(bufferSize);
    ss.readSync(buf);
}).catch((err) => {
    console.log('ERROR: '+err.message);
});

setRenderRate⁸⁺

setRenderRate(rate: AudioRendererRate, callback: AsyncCallback<void>): void

Sets the render rate. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.Multimedia.Audio.Renderer

Parameters

Example

audioRenderer.setRenderRate(audio.AudioRendererRate.RENDER_RATE_NORMAL, (err) => {
    if (err) {
        console.error('Failed to set params');
    } else {
        console.log('Callback invoked to indicate a successful render rate setting.');
    }
});

setRenderRate⁸⁺

setRenderRate(rate: AudioRendererRate): Promise<void>

Sets the render rate. This API uses a promise to return the result.

System capability: SystemCapability.Multimedia.Audio.Renderer

Parameters

Return value

Example

audioRenderer.setRenderRate(audio.AudioRendererRate.RENDER_RATE_NORMAL).then(() => {
    console.log('setRenderRate SUCCESS');
}).catch((err) => {
    console.log('ERROR: '+err.message);
});

getRenderRate⁸⁺

getRenderRate(callback: AsyncCallback<AudioRendererRate>): void

Obtains the current render rate. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.Multimedia.Audio.Renderer

Parameters

Example

audioRenderer.getRenderRate((err, renderrate) => {
    console.log('getRenderRate: ' + renderrate);
});

getRenderRate⁸⁺

getRenderRate(): Promise<AudioRendererRate>

Obtains the current render rate. This API uses a promise to return the result.

System capability: SystemCapability.Multimedia.Audio.Renderer

Return value

Example

audioRenderer.getRenderRate().then((renderRate) => {
    console.log('getRenderRate: ' + renderRate);
}).catch((err) => {
    console.log('ERROR: '+err.message);
});

on('interrupt')⁹⁺

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

Subscribes to audio interruption events. This API uses a callback to get interrupt events.

System capability: SystemCapability.Multimedia.Audio.Renderer

Parameters

Example

audioRenderer.on('interrupt', (interruptEvent) => {
    if (interruptEvent.forceType == audio.InterruptForceType.INTERRUPT_FORCE) {
        switch (interruptEvent.hintType) {
            case audio.InterruptHint.INTERRUPT_HINT_PAUSE:
                console.log('Force paused. Stop writing');
                isPlay = false;
                break;
            case audio.InterruptHint.INTERRUPT_HINT_STOP:
                console.log('Force stopped. Stop writing');
                isPlay = false;
                break;
        }
    } else if (interruptEvent.forceType == audio.InterruptForceType.INTERRUPT_SHARE) {
         switch (interruptEvent.hintType) {
            case audio.InterruptHint.INTERRUPT_HINT_RESUME:
                console.log('Resume force paused renderer or ignore');
                startRenderer();
                break;
            case audio.InterruptHint.INTERRUPT_HINT_PAUSE:
                console.log('Choose to pause or ignore');
                pauseRenderer();
                break;
        }
    }
});

on('markReach')⁸⁺

on(type: 'markReach', frame: number, callback: (position: number) => {}): void

Subscribes to mark reached events. When the number of frames rendered reaches the value of the frame parameter, the callback is invoked.

System capability: SystemCapability.Multimedia.Audio.Renderer

Parameters

Example

audioRenderer.on('markReach', 1000, (position) => {
    if (position == "1000") {
        console.log('ON Triggered successfully');
    }
});

off('markReach') ⁸⁺

off(type: 'markReach'): void

Unsubscribes from mark reached events.

System capability: SystemCapability.Multimedia.Audio.Renderer

Parameters

Example

audioRenderer.off('markReach');

on('periodReach') ⁸⁺

on(type: "periodReach", frame: number, callback: (position: number) => {}): void

Subscribes to period reached events. When the period of frame rendering reaches the value of the frame parameter, the callback is invoked.

System capability: SystemCapability.Multimedia.Audio.Renderer

Parameters

Example

audioRenderer.on('periodReach', 1000, (position) => {
    if (position == "1000") {
        console.log('ON Triggered successfully');
    }
});

off('periodReach') ⁸⁺

off(type: 'periodReach'): void

Unsubscribes from period reached events.

System capability: SystemCapability.Multimedia.Audio.Renderer

Parameters

Example

audioRenderer.off('periodReach')

on('stateChange') ⁸⁺

on(type: 'stateChange', callback: Callback<AudioState>): void

Subscribes to state change events.

System capability: SystemCapability.Multimedia.Audio.Renderer

Parameters

Example

audioRenderer.on('stateChange', (state) => {
    if (state == 1) {
        console.log("audio renderer state is: STATE_PREPARED");
    }
    if (state == 2) {
        console.log("audio renderer state is: STATE_RUNNING");
    }
});

AudioCapturer⁸⁺

Provides APIs for audio capture. Before calling any API in AudioCapturer, you must use createAudioCapturer to create an AudioCapturer instance.

state⁸⁺

Readonly state: AudioState

Defines the audio capturer state.

System capability: SystemCapability.Multimedia.Audio.Capturer

Example

var state = audioCapturer.state;

getCapturerInfo⁸⁺

getCapturerInfo(callback: AsyncCallback<AudioCapturerInfo>): void

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

System capability: SystemCapability.Multimedia.Audio.Capturer

Parameters

Example

audioCapturer.getCapturerInfo((err, capturerInfo) => {
    if (err) {
        console.error('Failed to get capture info');
    } else {
        console.log('Capturer getCapturerInfo:');
        console.log('Capturer source:' + capturerInfo.source);
        console.log('Capturer flags:' + capturerInfo.capturerFlags);
    }
});

getCapturerInfo⁸⁺

getCapturerInfo(): Promise<AudioCapturerInfo>

Obtains the capturer information of this AudioCapturer instance. This API uses a promise to return the result.

System capability: SystemCapability.Multimedia.Audio.Capturer

Return value

Example

audioCapturer.getCapturerInfo().then((audioParamsGet) => {
    if (audioParamsGet != undefined) {
        console.info('AudioFrameworkRecLog: Capturer CapturerInfo:');
        console.info('AudioFrameworkRecLog: Capturer SourceType:' + audioParamsGet.source);
        console.info('AudioFrameworkRecLog: Capturer capturerFlags:' + audioParamsGet.capturerFlags);
    }else {
        console.info('AudioFrameworkRecLog: audioParamsGet is : '+audioParamsGet);
        console.info('AudioFrameworkRecLog: audioParams getCapturerInfo are incorrect: ');
    }
}).catch((err) => {
    console.log('AudioFrameworkRecLog: CapturerInfo :ERROR: '+err.message);
});

getStreamInfo⁸⁺

getStreamInfo(callback: AsyncCallback<AudioStreamInfo>): void

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

System capability: SystemCapability.Multimedia.Audio.Capturer

Parameters

Example

audioCapturer.getStreamInfo((err, streamInfo) => {
    if (err) {
        console.error('Failed to get stream info');
    } else {
        console.log('Capturer GetStreamInfo:');
        console.log('Capturer sampling rate:' + streamInfo.samplingRate);
        console.log('Capturer channel:' + streamInfo.channels);
        console.log('Capturer format:' + streamInfo.sampleFormat);
        console.log('Capturer encoding type:' + streamInfo.encodingType);
    }
});

getStreamInfo⁸⁺

getStreamInfo(): Promise<AudioStreamInfo>

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

System capability: SystemCapability.Multimedia.Audio.Capturer

Return value

Example

audioCapturer.getStreamInfo().then((audioParamsGet) => {
    console.info('getStreamInfo:');
    console.info('sampleFormat:' + audioParamsGet.sampleFormat);
    console.info('samplingRate:' + audioParamsGet.samplingRate);
    console.info('channels:' + audioParamsGet.channels);
    console.info('encodingType:' + audioParamsGet.encodingType);
}).catch((err) => {
    console.log('getStreamInfo :ERROR: ' + err.message);
});

start⁸⁺

start(callback: AsyncCallback<void>): void

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

System capability: SystemCapability.Multimedia.Audio.Capturer

Parameters

Example

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

start⁸⁺

start(): Promise<void>

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

System capability: SystemCapability.Multimedia.Audio.Capturer

Return value

Example

audioCapturer.start().then(() => {
    console.info('AudioFrameworkRecLog: ---------START---------');
    console.info('AudioFrameworkRecLog: Capturer started :SUCCESS ');
    console.info('AudioFrameworkRecLog: AudioCapturer : STATE : '+audioCapturer.state);
    console.info('AudioFrameworkRecLog: Capturer started :SUCCESS ');
    if ((audioCapturer.state == audio.AudioState.STATE_RUNNING)) {
        stateFlag = true;
    }
}).catch((err) => {
    console.info('AudioFrameworkRecLog: Capturer start :ERROR : '+err.message);
    stateFlag=false;
});

stop⁸⁺

stop(callback: AsyncCallback<void>): void

Stops capturing. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.Multimedia.Audio.Capturer

Parameters

Example

audioCapturer.stop((err) => {
    if (err) {
        console.error('Capturer stop failed');
    } else {
        console.log('Capturer stopped.');
    }
});

stop⁸⁺

stop(): Promise<void>

Stops capturing. This API uses a promise to return the result.

System capability: SystemCapability.Multimedia.Audio.Capturer

Return value

Example

audioCapturer.stop().then(() => {
    console.info('AudioFrameworkRecLog: ---------RELEASE RECORD---------');
    console.info('AudioFrameworkRecLog: Capturer stopped : SUCCESS');
    if ((audioCapturer.state == audioCapturer.AudioState.STATE_STOPPED)){
        stateFlag=true;
        console.info('AudioFrameworkRecLog: resultFlag : '+stateFlag);
    }
}).catch((err) => {
    console.info('AudioFrameworkRecLog: Capturer stop:ERROR : '+err.message);
    stateFlag=false;
});

release⁸⁺

release(callback: AsyncCallback<void>): void

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

System capability: SystemCapability.Multimedia.Audio.Capturer

Parameters

Example

audioCapturer.release((err) => {
    if (err) {
        console.error('capturer release failed');
    } else {
        console.log('capturer released.');
    }
});

release⁸⁺

release(): Promise<void>

Releases this AudioCapturer instance. This API uses a promise to return the result.

System capability: SystemCapability.Multimedia.Audio.Capturer

Return value

Example

audioCapturer.release().then(() => {
    console.info('AudioFrameworkRecLog: ---------RELEASE RECORD---------');
    console.info('AudioFrameworkRecLog: Capturer release : SUCCESS');
    console.info('AudioFrameworkRecLog: AudioCapturer : STATE : '+audioCapturer.state);
    stateFlag=true;
    console.info('AudioFrameworkRecLog: stateFlag : '+stateFlag);
    expect(stateFlag).assertTrue();
    done();
}).catch((err) => {
    console.info('AudioFrameworkRecLog: Capturer stop:ERROR : '+err.message);
    stateFlag=false
});

read⁸⁺

read(size: number, isBlockingRead: boolean, callback: AsyncCallback<ArrayBuffer>): void

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

System capability: SystemCapability.Multimedia.Audio.Capturer

Parameters

Example

audioCapturer.read(bufferSize, true, async(err, buffer) => {
    if (!err) {
        console.log("Success in reading the buffer data");
    }
};

read⁸⁺

read(size: number, isBlockingRead: boolean): Promise<ArrayBuffer>

Reads the buffer. This API uses a promise to return the result.

System capability: SystemCapability.Multimedia.Audio.Capturer

Parameters

Return value

Example

audioCapturer.read(bufferSize, true).then((buffer) => {
    console.info('buffer read successfully');
}).catch((err) => {
    console.info('ERROR : '+err.message);
});

getAudioTime⁸⁺

getAudioTime(callback: AsyncCallback<number>): void

Obtains the number of nanoseconds elapsed from the Unix epoch (January 1, 1970). This API uses an asynchronous callback to return the result.

System capability: SystemCapability.Multimedia.Audio.Capturer

Parameters

Example

audioCapturer.getAudioTime((err, timestamp) => {
    console.log('Current timestamp: ' + timestamp);
});

getAudioTime⁸⁺

getAudioTime(): Promise<number>

Obtains the number of nanoseconds elapsed from the Unix epoch (January 1, 1970). This API uses a promise to return the result.

System capability: SystemCapability.Multimedia.Audio.Capturer

Return value

Example

audioCapturer.getAudioTime().then((audioTime) => {
    console.info('AudioFrameworkRecLog: AudioCapturer getAudioTime : Success' + audioTime );
}).catch((err) => {
    console.info('AudioFrameworkRecLog: AudioCapturer Created : ERROR : '+err.message);
});

getBufferSize⁸⁺

getBufferSize(callback: AsyncCallback<number>): void

Obtains a reasonable minimum buffer size in bytes for capturing. This API uses an asynchronous callback to return the result.

System capability: SystemCapability.Multimedia.Audio.Capturer

Parameters

Example

audioCapturer.getBufferSize((err, bufferSize) => {
    if (!err) {
        console.log('BufferSize : ' + bufferSize);
        audioCapturer.read(bufferSize, true).then((buffer) => {
            console.info('Buffer read is ' + buffer );
        }).catch((err) => {
            console.info('AudioFrameworkRecLog: AudioCapturer Created : ERROR : '+err.message);
        });
    }
});

getBufferSize⁸⁺

getBufferSize(): Promise<number>

Obtains a reasonable minimum buffer size in bytes for capturing. This API uses a promise to return the result.

System capability: SystemCapability.Multimedia.Audio.Capturer

Return value

Example

audioCapturer.getBufferSize().then((bufferSize) => {
    if (!err) {
        console.log('BufferSize : ' + bufferSize);
        audioCapturer.read(bufferSize, true).then((buffer) => {
            console.info('Buffer read is ' + buffer );
        }).catch((err) => {
            console.info('ERROR : '+err.message);
        });
    }
});

on('markReach')⁸⁺

on(type: 'markReach', frame: number, callback: (position: number) => {}): void

Subscribes to mark reached events. When the number of frames captured reaches the value of the frame parameter, the callback is invoked.

System capability: SystemCapability.Multimedia.Audio.Capturer

Parameters

Example

audioCapturer.on('markReach', 1000, (position) => {
    if (position == "1000") {
        console.log('ON Triggered successfully');
    }
});

off('markReach')⁸⁺

off(type: 'markReach'): void

Unsubscribes from mark reached events.

System capability: SystemCapability.Multimedia.Audio.Capturer

Parameters

Example

audioCapturer.off('markReach');

on('periodReach')⁸⁺

on(type: "periodReach", frame: number, callback: (position: number) => {}): void

Subscribes to mark reached events. When the period of frame capturing reaches the value of the frame parameter, the callback is invoked.

System capability: SystemCapability.Multimedia.Audio.Capturer

Parameters

Example

audioCapturer.on('periodReach', 1000, (position) => {
    if (position == "1000") {
        console.log('ON Triggered successfully');
    }
});

off('periodReach')⁸⁺

off(type: 'periodReach'): void

Unsubscribes from period reached events.

System capability: SystemCapability.Multimedia.Audio.Capturer

Parameters

Example

audioCapturer.off('periodReach')

on('stateChange') ⁸⁺

on(type: 'stateChange', callback: Callback<AudioState>): void

Subscribes to state change events.

System capability: SystemCapability.Multimedia.Audio.Capturer

Parameters

Example

audioCapturer.on('stateChange', (state) => {
    if (state == 1) {
        console.log("audio capturer state is: STATE_PREPARED");
    }
    if (state == 2) {
        console.log("audio capturer state is: STATE_RUNNING");
    }
});