回复
HarmonyOS API：@ohos.multimedia.audio (音频管理)
joytrian
发布于 2023-4-4 15:56
浏览
0收藏
版本：v3.1 Beta
@ohos.multimedia.audio (音频管理)
AudioDeviceDescriptors
设备属性数组类型，为AudioDeviceDescriptor的数组，只读。
AudioDeviceDescriptor
描述音频设备。
系统能力： SystemCapability.Multimedia.Audio.Device
名称 | 类型 | 可读 | 可写 | 说明 |
deviceRole | 是 | 否 | 设备角色。 | |
deviceType | 是 | 否 | 设备类型。 |
示例：
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');
}
});
AudioRenderer8+
提供音频渲染的相关接口。在调用AudioRenderer的接口前，需要先通过createAudioRenderer创建实例。
属性
系统能力： SystemCapability.Multimedia.Audio.Renderer
名称 | 类型 | 可读 | 可写 | 说明 |
state8+ | 是 | 否 | 音频渲染器的状态。 |
示例：
let state = audioRenderer.state;
getRendererInfo8+
getRendererInfo(callback: AsyncCallback<AudioRendererInfo>): void
获取当前被创建的音频渲染器的信息，使用callback方式异步返回结果。
系统能力： SystemCapability.Multimedia.Audio.Renderer
参数：
参数名 | 类型 | 必填 | 说明 |
callback | AsyncCallback<AudioRendererInfo> | 是 | 返回音频渲染器的信息。 |
示例：
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}`);
});
getRendererInfo8+
getRendererInfo(): Promise<AudioRendererInfo>
获取当前被创建的音频渲染器的信息，使用Promise方式异步返回结果。
系统能力： SystemCapability.Multimedia.Audio.Renderer
返回值：
类型 | 说明 |
Promise<AudioRendererInfo> | Promise用于返回音频渲染器信息。 |
示例：
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}`);
});
getStreamInfo8+
getStreamInfo(callback: AsyncCallback<AudioStreamInfo>): void
获取音频流信息，使用callback方式异步返回结果。
系统能力： SystemCapability.Multimedia.Audio.Renderer
参数：
参数名 | 类型 | 必填 | 说明 |
callback | AsyncCallback<AudioStreamInfo> | 是 | 回调返回音频流信息。 |
示例：
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}`);
});
getStreamInfo8+
getStreamInfo(): Promise<AudioStreamInfo>
获取音频流信息，使用Promise方式异步返回结果。
系统能力： SystemCapability.Multimedia.Audio.Renderer
返回值：
类型 | 说明 |
Promise<AudioStreamInfo> | Promise返回音频流信息. |
示例：
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}`);
});
getAudioStreamId9+
getAudioStreamId(callback: AsyncCallback<number>): void
获取音频流id，使用callback方式异步返回结果。
系统能力： SystemCapability.Multimedia.Audio.Renderer
参数：
参数名 | 类型 | 必填 | 说明 |
callback | AsyncCallback<number> | 是 | 回调返回音频流id。 |
示例：
audioRenderer.getAudioStreamId((err, streamid) => {
console.info(`Renderer GetStreamId: ${streamid}`);
});
getAudioStreamId9+
getAudioStreamId(): Promise<number>
获取音频流id，使用Promise方式异步返回结果。
系统能力： SystemCapability.Multimedia.Audio.Renderer
返回值：
类型 | 说明 |
Promise<number> | Promise返回音频流id。 |
示例：
audioRenderer.getAudioStreamId().then((streamid) => {
console.info(`Renderer getAudioStreamId: ${streamid}`);
}).catch((err) => {
console.error(`ERROR: ${err}`);
});
start8+
start(callback: AsyncCallback<void>): void
启动音频渲染器。使用callback方式异步返回结果。
系统能力： SystemCapability.Multimedia.Audio.Renderer
参数：
参数名 | 类型 | 必填 | 说明 |
callback | AsyncCallback<void> | 是 | 回调函数。 |
示例：
audioRenderer.start((err) => {
if (err) {
console.error('Renderer start failed.');
} else {
console.info('Renderer start success.');
}
});
start8+
start(): Promise<void>
启动音频渲染器。使用Promise方式异步返回结果。
系统能力： SystemCapability.Multimedia.Audio.Renderer
返回值：
类型 | 说明 |
Promise<void> | Promise方式异步返回结果。 |
示例：
audioRenderer.start().then(() => {
console.info('Renderer started');
}).catch((err) => {
console.error(`ERROR: ${err}`);
});
pause8+
pause(callback: AsyncCallback<void>): void
暂停渲染。使用callback方式异步返回结果。
系统能力： SystemCapability.Multimedia.Audio.Renderer
参数：
参数名 | 类型 | 必填 | 说明 |
callback | AsyncCallback<void> | 是 | 返回回调的结果。 |
示例：
audioRenderer.pause((err) => {
if (err) {
console.error('Renderer pause failed');
} else {
console.info('Renderer paused.');
}
});
pause8+
pause(): Promise<void>
暂停渲染。使用Promise方式异步返回结果。
系统能力： SystemCapability.Multimedia.Audio.Renderer
返回值：
类型 | 说明 |
Promise<void> | Promise方式异步返回结果。 |
示例：
audioRenderer.pause().then(() => {
console.info('Renderer paused');
}).catch((err) => {
console.error(`ERROR: ${err}`);
});
drain8+
drain(callback: AsyncCallback<void>): void
检查缓冲区是否已被耗尽。使用callback方式异步返回结果。
系统能力： SystemCapability.Multimedia.Audio.Renderer
参数：
参数名 | 类型 | 必填 | 说明 |
callback | AsyncCallback<void> | 是 | 返回回调的结果。 |
示例：
audioRenderer.drain((err) => {
if (err) {
console.error('Renderer drain failed');
} else {
console.info('Renderer drained.');
}
});
drain8+
drain(): Promise<void>
检查缓冲区是否已被耗尽。使用Promise方式异步返回结果。
系统能力： SystemCapability.Multimedia.Audio.Renderer
返回值：
类型 | 说明 |
Promise<void> | Promise方式异步返回结果。 |
示例：
audioRenderer.drain().then(() => {
console.info('Renderer drained successfully');
}).catch((err) => {
console.error(`ERROR: ${err}`);
});
stop8+
stop(callback: AsyncCallback<void>): void
停止渲染。使用callback方式异步返回结果。
系统能力： SystemCapability.Multimedia.Audio.Renderer
参数：
参数名 | 类型 | 必填 | 说明 |
callback | AsyncCallback<void> | 是 | 返回回调的结果。 |
示例：
audioRenderer.stop((err) => {
if (err) {
console.error('Renderer stop failed');
} else {
console.info('Renderer stopped.');
}
});
stop8+
stop(): Promise<void>
停止渲染。使用Promise方式异步返回结果。
系统能力： SystemCapability.Multimedia.Audio.Renderer
返回值：
类型 | 说明 |
Promise<void> | Promise方式异步返回结果。 |
示例：
audioRenderer.stop().then(() => {
console.info('Renderer stopped successfully');
}).catch((err) => {
console.error(`ERROR: ${err}`);
});
release8+
release(callback: AsyncCallback<void>): void
释放音频渲染器。使用callback方式异步返回结果。
系统能力： SystemCapability.Multimedia.Audio.Renderer
参数：
参数名 | 类型 | 必填 | 说明 |
callback | AsyncCallback<void> | 是 | 返回回调的结果。 |
示例：
audioRenderer.release((err) => {
if (err) {
console.error('Renderer release failed');
} else {
console.info('Renderer released.');
}
});
release8+
release(): Promise<void>
释放渲染器。使用Promise方式异步返回结果。
系统能力： SystemCapability.Multimedia.Audio.Renderer
返回值：
类型 | 说明 |
Promise<void> | Promise方式异步返回结果。 |
示例：
audioRenderer.release().then(() => {
console.info('Renderer released successfully');
}).catch((err) => {
console.error(`ERROR: ${err}`);
});
write8+
write(buffer: ArrayBuffer, callback: AsyncCallback<number>): void
写入缓冲区。使用callback方式异步返回结果。
系统能力： SystemCapability.Multimedia.Audio.Renderer
参数：
参数名 | 类型 | 必填 | 说明 |
buffer | ArrayBuffer | 是 | 要写入缓冲区的数据。 |
callback | AsyncCallback<number> | 是 | 回调如果成功，返回写入的字节数，否则返回errorcode。 |
示例：
let bufferSize;
audioRenderer.getBufferSize().then((data)=> {
console.info(`AudioFrameworkRenderLog: getBufferSize: SUCCESS ${data}`);
bufferSize = data;
}).catch((err) => {
console.error(`AudioFrameworkRenderLog: getBufferSize: ERROR: ${err}`);
});
console.info(`Buffer size: ${bufferSize}`);
let context = featureAbility.getContext();
let path;
async function getCacheDir(){
path = await context.getCacheDir();
}
let filePath = path + '/StarWars10s-2C-48000-4SW.wav';
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.info(`Actual written bytes: ${writtenbytes}`);
}
});
write8+
write(buffer: ArrayBuffer): Promise<number>
写入缓冲区。使用Promise方式异步返回结果。
系统能力： SystemCapability.Multimedia.Audio.Renderer
返回值：
类型 | 说明 |
Promise<number> | Promise返回结果，如果成功，返回写入的字节数，否则返回errorcode。 |
示例：
let bufferSize;
audioRenderer.getBufferSize().then((data) => {
console.info(`AudioFrameworkRenderLog: getBufferSize: SUCCESS ${data}`);
bufferSize = data;
}).catch((err) => {
console.info(`AudioFrameworkRenderLog: getBufferSize: ERROR: ${err}`);
});
console.info(`BufferSize: ${bufferSize}`);
let context = featureAbility.getContext();
let path;
async function getCacheDir(){
path = await context.getCacheDir();
}
let filePath = path + '/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.info(`Actual written bytes: ${writtenbytes}`);
}
}).catch((err) => {
console.error(`ERROR: ${err}`);
});
getAudioTime8+
getAudioTime(callback: AsyncCallback<number>): void
获取时间戳（从 1970 年 1 月 1 日开始）。使用callback方式异步返回结果。
系统能力： SystemCapability.Multimedia.Audio.Renderer
参数：
参数名 | 类型 | 必填 | 说明 |
callback | AsyncCallback<number> | 是 | 回调返回时间戳。 |
示例：
audioRenderer.getAudioTime((err, timestamp) => {
console.info(`Current timestamp: ${timestamp}`);
});
getAudioTime8+
getAudioTime(): Promise<number>
获取时间戳（从 1970 年 1 月 1 日开始）。使用Promise方式异步返回结果。
系统能力： SystemCapability.Multimedia.Audio.Renderer
返回值：
类型 | 描述 |
Promise<number> | Promise回调返回时间戳。 |
示例：
audioRenderer.getAudioTime().then((timestamp) => {
console.info(`Current timestamp: ${timestamp}`);
}).catch((err) => {
console.error(`ERROR: ${err}`);
});
getBufferSize8+
getBufferSize(callback: AsyncCallback<number>): void
获取音频渲染器的最小缓冲区大小。使用callback方式异步返回结果。
系统能力： SystemCapability.Multimedia.Audio.Renderer
参数：
参数名 | 类型 | 必填 | 说明 |
callback | AsyncCallback<number> | 是 | 回调返回缓冲区大小。 |
示例：
let bufferSize = audioRenderer.getBufferSize(async(err, bufferSize) => {
if (err) {
console.error('getBufferSize error');
}
});
getBufferSize8+
getBufferSize(): Promise<number>
获取音频渲染器的最小缓冲区大小。使用Promise方式异步返回结果。
系统能力： SystemCapability.Multimedia.Audio.Renderer
返回值：
类型 | 说明 |
Promise<number> | promise回调返回缓冲区大小。 |
示例：
let bufferSize;
audioRenderer.getBufferSize().then((data) => {
console.info(`AudioFrameworkRenderLog: getBufferSize: SUCCESS ${data}`);
bufferSize = data;
}).catch((err) => {
console.error(`AudioFrameworkRenderLog: getBufferSize: ERROR: ${err}`);
});
setRenderRate8+
setRenderRate(rate: AudioRendererRate, callback: AsyncCallback<void>): void
设置音频渲染速率。使用callback方式异步返回结果。
系统能力： SystemCapability.Multimedia.Audio.Renderer
参数：
参数名 | 类型 | 必填 | 说明 |
rate | 是 | 渲染的速率。 | |
callback | AsyncCallback<void> | 是 | 用于返回执行结果的回调。 |
示例：
audioRenderer.setRenderRate(audio.AudioRendererRate.RENDER_RATE_NORMAL, (err) => {
if (err) {
console.error('Failed to set params');
} else {
console.info('Callback invoked to indicate a successful render rate setting.');
}
});
setRenderRate8+
setRenderRate(rate: AudioRendererRate): Promise<void>
设置音频渲染速率。使用Promise方式异步返回结果。
系统能力： SystemCapability.Multimedia.Audio.Renderer
参数：
参数名 | 类型 | 必填 | 说明 |
rate | 是 | 渲染的速率。 |
返回值：
类型 | 说明 |
Promise<void> | Promise用于返回执行结果。 |
示例：
audioRenderer.setRenderRate(audio.AudioRendererRate.RENDER_RATE_NORMAL).then(() => {
console.info('setRenderRate SUCCESS');
}).catch((err) => {
console.error(`ERROR: ${err}`);
});
getRenderRate8+
getRenderRate(callback: AsyncCallback<AudioRendererRate>): void
获取当前渲染速率。使用callback方式异步返回结果。
系统能力： SystemCapability.Multimedia.Audio.Renderer
参数：
参数名 | 类型 | 必填 | 说明 |
callback | AsyncCallback<AudioRendererRate> | 是 | 回调返回渲染速率。 |
示例：
audioRenderer.getRenderRate((err, renderrate) => {
console.info(`getRenderRate: ${renderrate}`);
});
getRenderRate8+
getRenderRate(): Promise<AudioRendererRate>
获取当前渲染速率。使用Promise方式异步返回结果。
系统能力： SystemCapability.Multimedia.Audio.Renderer
返回值：
类型 | 说明 |
Promise<AudioRendererRate> | Promise回调返回渲染速率。 |
示例：
audioRenderer.getRenderRate().then((renderRate) => {
console.info(`getRenderRate: ${renderRate}`);
}).catch((err) => {
console.error(`ERROR: ${err}`);
});
setInterruptMode9+
setInterruptMode(mode: InterruptMode): Promise<void>
设置应用的焦点模型。使用Promise异步回调。
系统能力： SystemCapability.Multimedia.Audio.Interrupt
参数：
参数名 | 类型 | 必填 | 说明 |
mode | 是 | 焦点模型。 |
返回值：
类型 | 说明 |
Promise<void> | 以Promise对象返回结果，设置成功时返回undefined，否则返回error。 |
示例：
let mode = 0;
audioRenderer.setInterruptMode(mode).then(data=>{
console.info('setInterruptMode Success!');
}).catch((err) => {
console.error(`setInterruptMode Fail: ${err}`);
});
setInterruptMode9+
setInterruptMode(mode: InterruptMode, callback: AsyncCallback<void>): void
设置应用的焦点模型。使用Callback回调返回执行结果。
系统能力： SystemCapability.Multimedia.Audio.Interrupt
参数：
参数名 | 类型 | 必填 | 说明 |
mode | 是 | 焦点模型。 | |
callback | AsyncCallback<void> | 是 | 回调返回执行结果。 |
示例：
let mode = 1;
audioRenderer.setInterruptMode(mode, (err, data)=>{
if(err){
console.error(`setInterruptMode Fail: ${err}`);
}
console.info('setInterruptMode Success!');
});
setVolume9+
setVolume(volume: number): Promise<void>
设置应用的音量。使用Promise异步回调。
系统能力： SystemCapability.Multimedia.Audio.Renderer
参数：
参数名 | 类型 | 必填 | 说明 |
volume | number | 是 | 音量值范围为0.0-1.0。 |
返回值：
类型 | 说明 |
Promise<void> | 以Promise对象返回结果，设置成功时返回undefined，否则返回error。 |
示例：
audioRenderer.setVolume(0.5).then(data=>{
console.info('setVolume Success!');
}).catch((err) => {
console.error(`setVolume Fail: ${err}`);
});
setVolume9+
setVolume(volume: number, callback: AsyncCallback<void>): void
设置应用的音量。使用Callback回调返回执行结果。
系统能力： SystemCapability.Multimedia.Audio.Renderer
参数：
参数名 | 类型 | 必填 | 说明 |
volume | number | 是 | 音量值范围为0.0-1.0。 |
callback | AsyncCallback<void> | 是 | 回调返回执行结果。 |
示例：
audioRenderer.setVolume(0.5, (err, data)=>{
if(err){
console.error(`setVolume Fail: ${err}`);
}
console.info('setVolume Success!');
});
on('stateChange') 8+
on(type: 'stateChange', callback: Callback<AudioState>): void
订阅监听状态变化。
系统能力： SystemCapability.Multimedia.Audio.Renderer
参数：
参数名 | 类型 | 必填 | 说明 |
type | string | 是 | 事件回调类型，支持的事件为：'stateChange'。 |
callback | Callback<AudioState> | 是 | 返回监听的状态。 |
示例：
audioRenderer.on('stateChange', (state) => {
if (state == 1) {
console.info('audio renderer state is: STATE_PREPARED');
}
if (state == 2) {
console.info('audio renderer state is: STATE_RUNNING');
}
});
AudioCapturer8+
提供音频采集的相关接口。在调用AudioCapturer的接口前，需要先通过createAudioCapturer创建实例。
属性
系统能力： SystemCapability.Multimedia.Audio.Capturer
名称 | 类型 | 可读 | 可写 | 说明 |
state8+ | 是 | 否 | 音频采集器状态。 |
示例：
let state = audioCapturer.state;
getCapturerInfo8+
getCapturerInfo(callback: AsyncCallback<AudioCapturerInfo>): void
获取采集器信息。使用callback方式异步返回结果。
系统能力： SystemCapability.Multimedia.Audio.Capturer
参数：
参数名 | 类型 | 必填 | 说明 |
callback | AsyncCallback<AudioCapturerInfo> | 是 | 使用callback方式异步返回采集器信息。 |
示例：
audioCapturer.getCapturerInfo((err, capturerInfo) => {
if (err) {
console.error('Failed to get capture info');
} else {
console.info('Capturer getCapturerInfo:');
console.info(`Capturer source: ${capturerInfo.source}`);
console.info(`Capturer flags: ${capturerInfo.capturerFlags}`);
}
});
getCapturerInfo8+
getCapturerInfo(): Promise<AudioCapturerInfo>
获取采集器信息。使用Promise方式异步返回结果。
系统能力： SystemCapability.Multimedia.Audio.Capturer
返回值：
类型 | 说明 |
Promise<AudioCapturerInfo> | 使用Promise方式异步返回采集器信息。 |
示例：
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.error(`AudioFrameworkRecLog: CapturerInfo :ERROR: ${err}`);
});
getStreamInfo8+
getStreamInfo(callback: AsyncCallback<AudioStreamInfo>): void
获取采集器流信息。使用callback方式异步返回结果。
系统能力： SystemCapability.Multimedia.Audio.Capturer
参数：
参数名 | 类型 | 必填 | 说明 |
callback | AsyncCallback<AudioStreamInfo> | 是 | 使用callback方式异步返回流信息。 |
示例：
audioCapturer.getStreamInfo((err, streamInfo) => {
if (err) {
console.error('Failed to get stream info');
} else {
console.info('Capturer GetStreamInfo:');
console.info(`Capturer sampling rate: ${streamInfo.samplingRate}`);
console.info(`Capturer channel: ${streamInfo.channels}`);
console.info(`Capturer format: ${streamInfo.sampleFormat}`);
console.info(`Capturer encoding type: ${streamInfo.encodingType}`);
}
});
getStreamInfo8+
getStreamInfo(): Promise<AudioStreamInfo>
获取采集器流信息。使用Promise方式异步返回结果。
系统能力： SystemCapability.Multimedia.Audio.Capturer
返回值：
类型 | 说明 |
Promise<AudioStreamInfo> | 使用Promise方式异步返回流信息。 |
示例：
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.error(`getStreamInfo :ERROR: ${err}`);
});
getAudioStreamId9+
getAudioStreamId(callback: AsyncCallback<number>): void
获取音频流id，使用callback方式异步返回结果。
系统能力： SystemCapability.Multimedia.Audio.Capturer
参数：
参数名 | 类型 | 必填 | 说明 |
callback | AsyncCallback<number> | 是 | 回调返回音频流id。 |
示例：
audioCapturer.getAudioStreamId((err, streamid) => {
console.info(`audioCapturer GetStreamId: ${streamid}`);
});
getAudioStreamId9+
getAudioStreamId(): Promise<number>
获取音频流id，使用Promise方式异步返回结果。
系统能力： SystemCapability.Multimedia.Audio.Capturer
返回值：
类型 | 说明 |
Promise<number> | Promise返回音频流id。 |
示例：
audioCapturer.getAudioStreamId().then((streamid) => {
console.info(`audioCapturer getAudioStreamId: ${streamid}`);
}).catch((err) => {
console.error(`ERROR: ${err}`);
});
start8+
start(callback: AsyncCallback<void>): void
启动音频采集器。使用callback方式异步返回结果。
系统能力： SystemCapability.Multimedia.Audio.Capturer
参数：
参数名 | 类型 | 必填 | 说明 |
callback | AsyncCallback<void> | 是 | 使用callback方式异步返回结果。 |
示例：
audioCapturer.start((err) => {
if (err) {
console.error('Capturer start failed.');
} else {
console.info('Capturer start success.');
}
});
start8+
start(): Promise<void>
启动音频采集器。使用Promise方式异步返回结果。
系统能力： SystemCapability.Multimedia.Audio.Capturer
返回值：
类型 | 说明 |
Promise<void> | 使用Promise方式异步返回结果。 |
示例：
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)) {
console.info('AudioFrameworkRecLog: AudioCapturer is in Running State');
}
}).catch((err) => {
console.info(`AudioFrameworkRecLog: Capturer start :ERROR : ${err}`);
});
stop8+
stop(callback: AsyncCallback<void>): void
停止采集。使用callback方式异步返回结果。
系统能力： SystemCapability.Multimedia.Audio.Capturer
参数：
参数名 | 类型 | 必填 | 说明 |
callback | AsyncCallback<void> | 是 | 使用callback方式异步返回结果。 |
示例：
audioCapturer.stop((err) => {
if (err) {
console.error('Capturer stop failed');
} else {
console.info('Capturer stopped.');
}
});
stop8+
stop(): Promise<void>
停止采集。使用Promise方式异步返回结果。
系统能力： SystemCapability.Multimedia.Audio.Capturer
返回值：
类型 | 说明 |
Promise<void> | 使用Promise方式异步返回结果。 |
示例：
audioCapturer.stop().then(() => {
console.info('AudioFrameworkRecLog: ---------STOP RECORD---------');
console.info('AudioFrameworkRecLog: Capturer stopped: SUCCESS');
if ((audioCapturer.state == audio.AudioState.STATE_STOPPED)){
console.info('AudioFrameworkRecLog: State is Stopped:');
}
}).catch((err) => {
console.info(`AudioFrameworkRecLog: Capturer stop: ERROR: ${err}`);
});
release8+
release(callback: AsyncCallback<void>): void
释放采集器。使用callback方式异步返回结果。
系统能力： SystemCapability.Multimedia.Audio.Capturer
参数：
参数名 | 类型 | 必填 | 说明 |
callback | AsyncCallback<void> | 是 | 使用callback方式异步返回结果。 |
示例：
audioCapturer.release((err) => {
if (err) {
console.error('capturer release failed');
} else {
console.info('capturer released.');
}
});
release8+
release(): Promise<void>
释放采集器。使用Promise方式异步返回结果。
系统能力： SystemCapability.Multimedia.Audio.Capturer
返回值：
类型 | 说明 |
Promise<void> | 使用Promise方式异步返回结果。 |
示例：
let stateFlag;
audioCapturer.release().then(() => {
console.info('AudioFrameworkRecLog: ---------RELEASE RECORD---------');
console.info('AudioFrameworkRecLog: Capturer release : SUCCESS');
console.info(`AudioFrameworkRecLog: AudioCapturer : STATE : ${audioCapturer.state}`);
console.info(`AudioFrameworkRecLog: stateFlag : ${stateFlag}`);
}).catch((err) => {
console.info(`AudioFrameworkRecLog: Capturer stop: ERROR: ${err}`);
});
read8+
read(size: number, isBlockingRead: boolean, callback: AsyncCallback<ArrayBuffer>): void
读入缓冲区。使用callback方式异步返回结果。
系统能力： SystemCapability.Multimedia.Audio.Capturer
参数：
参数名 | 类型 | 必填 | 说明 |
size | number | 是 | 读入的字节数。 |
isBlockingRead | boolean | 是 | 是否阻塞读操作。 |
callback | AsyncCallback<ArrayBuffer> | 是 | 使用callback方式异步返回缓冲区。 |
示例：
let bufferSize;
audioCapturer.getBufferSize().then((data) => {
console.info(`AudioFrameworkRecLog: getBufferSize: SUCCESS ${data}`);
bufferSize = data;
}).catch((err) => {
console.error(`AudioFrameworkRecLog: getBufferSize: ERROR: ${err}`);
});
audioCapturer.read(bufferSize, true, async(err, buffer) => {
if (!err) {
console.info('Success in reading the buffer data');
}
});
read8+
read(size: number, isBlockingRead: boolean): Promise<ArrayBuffer>
读入缓冲区。使用Promise方式异步返回结果。
系统能力： SystemCapability.Multimedia.Audio.Capturer
参数：
参数名 | 类型 | 必填 | 说明 |
size | number | 是 | 读入的字节数。 |
isBlockingRead | boolean | 是 | 是否阻塞读操作。 |
返回值：
类型 | 说明 |
Promise<ArrayBuffer> | 如果操作成功，返回读取的缓冲区数据；否则返回错误代码。 |
示例：
let bufferSize;
audioCapturer.getBufferSize().then((data) => {
console.info(`AudioFrameworkRecLog: getBufferSize: SUCCESS ${data}`);
bufferSize = data;
}).catch((err) => {
console.info(`AudioFrameworkRecLog: getBufferSize: ERROR ${err}`);
});
console.info(`Buffer size: ${bufferSize}`);
audioCapturer.read(bufferSize, true).then((buffer) => {
console.info('buffer read successfully');
}).catch((err) => {
console.info(`ERROR : ${err}`);
});
getAudioTime8+
getAudioTime(callback: AsyncCallback<number>): void
获取时间戳（从1970年1月1日开始），单位为纳秒。使用callback方式异步返回结果。
系统能力： SystemCapability.Multimedia.Audio.Capturer
参数：
参数名 | 类型 | 必填 | 说明 |
callback | AsyncCallback<number> | 是 | 使用callback方式异步返回结果。 |
示例：
audioCapturer.getAudioTime((err, timestamp) => {
console.info(`Current timestamp: ${timestamp}`);
});
getAudioTime8+
getAudioTime(): Promise<number>
获取时间戳（从1970年1月1日开始），单位为纳秒。使用Promise方式异步返回结果。
系统能力： SystemCapability.Multimedia.Audio.Capturer
返回值：
类型 | 说明 |
Promise<number> | 使用Promise方式异步返回结果。 |
示例：
audioCapturer.getAudioTime().then((audioTime) => {
console.info(`AudioFrameworkRecLog: AudioCapturer getAudioTime : Success ${audioTime}`);
}).catch((err) => {
console.info(`AudioFrameworkRecLog: AudioCapturer Created : ERROR : ${err}`);
});
getBufferSize8+
getBufferSize(callback: AsyncCallback<number>): void
获取采集器合理的最小缓冲区大小。使用callback方式异步返回结果。
系统能力： SystemCapability.Multimedia.Audio.Capturer
参数：
参数名 | 类型 | 必填 | 说明 |
callback | AsyncCallback<number> | 是 | 使用callback方式异步返回缓冲区大小。 |
示例：
audioCapturer.getBufferSize((err, bufferSize) => {
if (!err) {
console.info(`BufferSize : ${bufferSize}`);
audioCapturer.read(bufferSize, true).then((buffer) => {
console.info(`Buffer read is ${buffer}`);
}).catch((err) => {
console.error(`AudioFrameworkRecLog: AudioCapturer Created : ERROR : ${err}`);
});
}
});
getBufferSize8+
getBufferSize(): Promise<number>
获取采集器合理的最小缓冲区大小。使用Promise方式异步返回结果。
系统能力： SystemCapability.Multimedia.Audio.Capturer
返回值：
类型 | 说明 |
Promise<number> | 使用Promise方式异步返回缓冲区大小。 |
示例：
let bufferSize;
audioCapturer.getBufferSize().then((data) => {
console.info(`AudioFrameworkRecLog: getBufferSize :SUCCESS ${data}`);
bufferSize = data;
}).catch((err) => {
console.info(`AudioFrameworkRecLog: getBufferSize :ERROR : ${err}`);
});
on('stateChange') 8+
on(type: 'stateChange', callback: Callback<AudioState>): void
订阅监听状态变化。
系统能力： SystemCapability.Multimedia.Audio.Capturer
参数：
参数名 | 类型 | 必填 | 说明 |
type | string | 是 | 事件回调类型，支持的事件为：'stateChange'。 |
callback | Callback<AudioState> | 是 | 返回监听的状态。 |
示例：
audioCapturer.on('stateChange', (state) => {
if (state == 1) {
console.info('audio capturer state is: STATE_PREPARED');
}
if (state == 2) {
console.info('audio capturer state is: STATE_RUNNING');
}
});
ActiveDeviceType
枚举，活跃设备类型。
系统能力： SystemCapability.Multimedia.Audio.Device
名称 | 值 | 说明 |
SPEAKER | 2 | 扬声器。 |
BLUETOOTH_SCO | 7 | 蓝牙设备SCO（Synchronous Connection Oriented）连接。 |
InterruptActionType(deprecated)
枚举，中断事件返回类型。
说明
从 API version 7 开始支持，从 API version 9 开始废弃。
系统能力： SystemCapability.Multimedia.Audio.Renderer
名称 | 值 | 说明 |
TYPE_ACTIVATED | 0 | 表示触发焦点事件。 |
TYPE_INTERRUPT | 1 | 表示音频打断事件。 |
AudioInterrupt(deprecated)
音频监听事件传入的参数。
说明
从 API version 7 开始支持，从 API version 9 开始废弃。
系统能力： SystemCapability.Multimedia.Audio.Renderer
名称 | 类型 | 必填 | 说明 |
streamUsage | 是 | 音频流使用类型。 | |
contentType | 是 | 音频打断媒体类型。 | |
pauseWhenDucked | boolean | 是 | 音频打断时是否可以暂停音频播放（true表示音频播放可以在音频打断期间暂停，false表示相反）。 |
InterruptAction(deprecated)
音频打断/获取焦点事件的回调方法。
说明
从 API version 7 开始支持，从 API version 9 开始废弃。
系统能力： SystemCapability.Multimedia.Audio.Renderer
名称 | 类型 | 必填 | 说明 |
actionType | 是 | 事件返回类型。TYPE_ACTIVATED为焦点触发事件，TYPE_INTERRUPT为音频打断事件。 | |
type | 否 | 打断事件类型。 | |
hint | 否 | 打断事件提示。 | |
activated | boolean | 否 | 获得/释放焦点。true表示焦点获取/释放成功，false表示焦点获得/释放失败。 |
已于2023-4-4 15:56:10修改
赞
收藏
回复
相关推荐
