You can use the APIs provided by **AudioCapturer** to record raw audio files.
---
## **Summary**
### State Check
This guide will show how a JS application can use AudioCapturer to record the audio.
Applications can use the APIs provided in this document to record raw audio files.
During application development, you are advised to use **on('stateChange')** to subscribe to state changes of the **AudioCapturer** instance. This is because some operations can be performed only when the audio capturer is in a given state. If the application performs an operation when the audio capturer is not in the given state, the system may throw an exception or generate other undefined behavior.
## **AudioCapturer Framework**
For details about the APIs, see [AudioCapturer in Audio Management](../reference/apis/js-apis-audio.md).
The AudioCapturer interface is one of the most important components of the audio framework.
### **Audio Capturing:**
**Figure 1** Audio capturer state
The AudioCapturer framework provides APIs for capturing raw audio files.
## **Usage**
Here's an example of how to use AudioCapturer to capture a raw audio file.
## How to Develop
1. Use **createAudioCapturer()** to create an AudioCapturer instance. Capturer parameters can be set in **audioCapturerOptions**.\
This instance can be used to record, control, and obtain the recording status, as well as to register a callback for notifications.
1. Use **createAudioCapturer()** to create an **AudioCapturer** instance.
```
Set parameters of the **AudioCapturer** instance in **audioCapturerOptions**. This instance is used to capture audio, control and obtain the recording status, and register a callback for notification.
@@ -39,10 +42,10 @@ Here's an example of how to use AudioCapturer to capture a raw audio file.
...
@@ -39,10 +42,10 @@ Here's an example of how to use AudioCapturer to capture a raw audio file.
varstate=audioRenderer.state;
varstate=audioRenderer.state;
```
```
2. (Optional) Subscribe to audio capturer state change events using the **on('stateChange')** API.
2. (Optional) Use **on('stateChange')** to subscribe to audio renderer state changes.
If an application wants to take some action based on the state updates in capturer, the application can subscribe to the state change event.
If an application needs to perform some operations when the audio renderer state is updated, the application can subscribe to the state changes. For more events that can be subscribed to, see [Audio Management](../reference/apis/js-apis-audio.md).
There are more events that applications can subscribe to, such as 'markReach' and 'periodReach'. Refer to [Audio](../reference/apis/js-apis-audio.md) for more details.
```
```js
audioCapturer.on('stateChange',(state)=>{
audioCapturer.on('stateChange',(state)=>{
console.info('AudioCapturerLog: Changed State to : '+state)
console.info('AudioCapturerLog: Changed State to : '+state)
switch(state){
switch(state){
...
@@ -68,31 +71,33 @@ Here's an example of how to use AudioCapturer to capture a raw audio file.
...
@@ -68,31 +71,33 @@ Here's an example of how to use AudioCapturer to capture a raw audio file.
break;
break;
}
}
});
});
```
```
3. Call the **start()** function on the AudioCapturer instance to start/resume the recording task.\
3. Use **start()** to start audio recording.
The capturer state will be STATE_RUNNING once the start is complete. The application can then begin reading buffers.
```
The capturer state will be **STATE_RUNNING** once the audio capturer is started. The application can then begin reading buffers.
5. Read the captured audio data and convert it to a byte stream. Call the **read()** API repeatedly to read the data
5. Read the captured audio data and convert it to a byte stream. Call **read()** repeatedly to read the data until the application wants to stop the recording.
until the application wants to stop the recording. The following example shows how to write recorded data into a file.
```
The following example shows how to write recorded data into a file.
```js
importfileiofrom'@ohos.fileio';
importfileiofrom'@ohos.fileio';
constpath='/data/data/.pulse_dir/capture_js.wav';
constpath='/data/data/.pulse_dir/capture_js.wav';
...
@@ -123,7 +128,9 @@ Here's an example of how to use AudioCapturer to capture a raw audio file.
...
@@ -123,7 +128,9 @@ Here's an example of how to use AudioCapturer to capture a raw audio file.
numBuffersToCapture--;
numBuffersToCapture--;
}
}
```
```
6. Once the recording is complete, call the **stop()** API on the AudioCapturer instance to stop the recording.
6. Once the recording is complete, call **stop()** to stop the recording.
```
```
await audioCapturer.stop();
await audioCapturer.stop();
if (audioCapturer.state == audio.AudioState.STATE_STOPPED) {
if (audioCapturer.state == audio.AudioState.STATE_STOPPED) {
...
@@ -133,8 +140,9 @@ Here's an example of how to use AudioCapturer to capture a raw audio file.
...
@@ -133,8 +140,9 @@ Here's an example of how to use AudioCapturer to capture a raw audio file.
}
}
```
```
7. After the recording task is complete, call the **release()** API on the AudioCapturer instance to release the stream resources.
7. After the task is complete, call **release()** to release related resources.
Application developers should keep in mind that an AudioCapturer is state-based.
That is, the AudioCapturer has an internal state that the application must always check when calling recorder control APIs, because some operations are only acceptable while the capturer is in a given state.\
The system may throw an error/exception or generate other undefined behaviour if the application performs an operation while capturer is in an improper state.
## **Other APIs**
See [AudioCapturer in the Audio API](../reference/apis/js-apis-audio.md) for more useful APIs like **getAudioTime**, **getCapturerInfo** and **getStreamInfo**.
**AudioRenderer** provides APIs for rendering audio files and controlling playback. It also supports audio interruption. You can use the APIs provided by **AudioRenderer** to play audio files in output devices and manage playback tasks.
---
## **Summary**
### Audio Interruption
This guide will show you how to use AudioRenderer to create an audio player app.
You can use the APIs provided in this document to play audio files in output devices and manage playback tasks.
When an audio stream with a higher priority needs to be played, the audio renderer interrupts the stream with a lower priority. For example, if a call comes in when the user is listening to music, the music playback, which is the lower priority stream, is paused. For details, see [How to Develop](#how-to-develop).
## **AudioRenderer Framework**
### State Check
The AudioRenderer interface is one of the most important components of the audio framework.
### **Audio Rendering:**
During application development, you are advised to use **on('stateChange')** to subscribe to state changes of the **AudioRenderer** instance. This is because some operations can be performed only when the audio renderer is in a given state. If the application performs an operation when the audio renderer is not in the given state, the system may throw an exception or generate other undefined behavior.
The AudioRenderer framework provides APIs for playing audio files and controlling the playback.
### **Audio Interruption:**
**Figure 1** Audio renderer state
When a higher priority stream wants to play, the AudioRenderer framework interrupts the lower priority stream.\
For example, if a call is arrived when you listen to music, the music playback, which is the lower priority stream, is paused.\
With the sample code below, we'll look at how AudioInterrupt works in detail.\
<br/>
### Asynchronous Operations
Please see [AudioRenderer in the Audio API](../reference/apis/js-apis-audio.md#audiorenderer8) for a list of supported audio stream types and formats, such as AudioSampleFormat, AudioChannel, AudioSampleFormat, and AudioEncodingType.
To ensure that the UI thread is not blocked, most **AudioRenderer** calls are asynchronous. Each API provides the callback and promise functions. The following examples use the promise functions. For more information, see [AudioRenderer in Audio Management](../reference/apis/js-apis-audio.md#audiorenderer8).
## **Usage**
Here's an example of how to use AudioRenderer to play a raw audio file.
1. Use **createAudioRenderer** to create an AudioRenderer instance. Renderer parameters can be set in **audioRendererOptions**.\
## How to Develop
This object can be used to play, control, and obtain the status of the playback, as well as receive callback notifications.
```
1. Use **createAudioRenderer()** to create an **AudioRenderer** instance.
Set parameters of the audio renderer in **audioCapturerOptions**. This instance is used to render audio, control and obtain the rendering status, and register a callback for notification.
2. Subscribe to audio interruption events using the **on** API.\
2. Use **on('interrupt')** to subscribe to audio interruption events.
Stream-A is interrupted when Stream-B with a higher or equal priority requests to become active and use the output device.\
In some cases, the framework takes forced actions like pausing and ducking, and notifies the app using **InterruptEvent**. In other cases, the app can take action. In this situation, the app can choose to act on the **InterruptEvent** or ignore it. When the app is interrupted by forced action, it should handle the state, update the user interface, and so on.
In case of audio interrupts, the app may encounter write failures. Interrupt unaware apps can check the renderer state using the **audioRenderer.state** API before writing audio data, whereas interrupt aware apps will have more details accessible via this listener.\
<br/>
The following information will be provided by the Interrupt Event Notification:
1) **eventType:** Whether the interruption has begun or ended.
| INTERRUPT_FORCE | The audio state has been changed by the framework. |
| INTERRUPT_SHARE | The app can decide whether or not to respond to the InterruptEvent. |
3) **hintType:** The kind of action taken or to be taken.
In some cases, the audio renderer performs forcible operations such as pausing and ducking, and notifies the application through **InterruptEvent**. In other cases, the application can choose to act on the **InterruptEvent** or ignore it.
| Value | Description |
In the case of audio interruption, the application may encounter write failures. To avoid such failures, interruption unaware applications can use **audioRenderer.state** to check the renderer state before writing audio data. The applications can obtain more details by subscribing to the audio interruption events. For details, see [InterruptEvent](../reference/apis/js-apis-audio.md#interruptevent9).
| INTERRUPT_HINT_RESUME | Resuming the playback. |
| INTERRUPT_HINT_STOP | Stopping the playback. |
| INTERRUPT_HINT_DUCK | Ducking the stream volume. |
| INTERRUPT_HINT_UNDUCK | Unducking the stream volume. |
4) **Some actions are exclusively forced or shared**, which means that they are performed by either the framework or the app.\
```js
For instance, when a call is received while a music stream is ongoing, the framework forces the music stream to pause. When the call is finished, the framework will not forcibly resume the music stream. Instead, it will alert the app to resume the playback.
console.info('Renderer is not in a correct state to start');
console.info('Renderer is not in a correct state to start');
...
@@ -154,11 +126,13 @@ Here's an example of how to use AudioRenderer to play a raw audio file.
...
@@ -154,11 +126,13 @@ Here's an example of how to use AudioRenderer to play a raw audio file.
console.error('Renderer start failed');
console.error('Renderer start failed');
}
}
}
}
```
5. Make **write** calls to start rendering the buffers.
Read the audio data to be played into a buffer. Call the write function repeatedly to write data.
```
```
4. Call **write()** to write data to the buffer.
Read the audio data to be played to the buffer. Call **write()** repeatedly to write the data to the buffer.
```js
asyncfunctionwriteBuffer(buf){
asyncfunctionwriteBuffer(buf){
varstate=audioRenderer.state;
varstate=audioRenderer.state;
if(state!=audio.AudioState.STATE_RUNNING){
if(state!=audio.AudioState.STATE_RUNNING){
...
@@ -201,8 +175,9 @@ Here's an example of how to use AudioRenderer to play a raw audio file.
...
@@ -201,8 +175,9 @@ Here's an example of how to use AudioRenderer to play a raw audio file.
},30);// interval to be set based on audio file format
},30);// interval to be set based on audio file format
```
```
6. (Optional) Call the **pause()** or **stop()** function on the AudioRenderer instance.
5. (Optional) Call **pause()** or **stop()** to pause or stop rendering.
```
```js
asyncfunctionpauseRenderer(){
asyncfunctionpauseRenderer(){
varstate=audioRenderer.state;
varstate=audioRenderer.state;
if(state!=audio.AudioState.STATE_RUNNING){
if(state!=audio.AudioState.STATE_RUNNING){
...
@@ -235,12 +210,14 @@ Here's an example of how to use AudioRenderer to play a raw audio file.
...
@@ -235,12 +210,14 @@ Here's an example of how to use AudioRenderer to play a raw audio file.
}else{
}else{
console.error('Renderer stop failed');
console.error('Renderer stop failed');
}
}
}
}
```
```
7. After the playback task is complete, call the **release()** function on the AudioRenderer instance to release resources.\
6. After the task is complete, call **release()** to release related resources.
AudioRenderer can use a lot of system resources. As a result, whenever the resources are no longer required, they must be released. To ensure that any system resources allocated to it are appropriately released, you should always call **release()**.
```
**AudioRenderer** uses a large number of system resources. Therefore, ensure that the resources are released after the task is complete.
```js
asyncfunctionreleaseRenderer(){
asyncfunctionreleaseRenderer(){
if(state_==RELEASED||state_==NEW){
if(state_==RELEASED||state_==NEW){
console.info('Resourced already released');
console.info('Resourced already released');
...
@@ -257,18 +234,6 @@ Here's an example of how to use AudioRenderer to play a raw audio file.
...
@@ -257,18 +234,6 @@ Here's an example of how to use AudioRenderer to play a raw audio file.
}
}
}
}
```
```
## **Importance of State Check:**
You should also keep in mind that an AudioRenderer is state-based.
That is, the AudioRenderer has an internal state that you must always check when calling playback control APIs, because some operations are only acceptable while the renderer is in a given state.\
The system may throw an error/exception or generate other undefined behaviour if you perform an operation while in the improper state.\
## **Asynchronous Operations:**
Most of the AudioRenderer calls are asynchronous. As a result, the UI thread will not be blocked.\
For each API, the framework provides both callback and promises functions.\
In the example, promise functions are used for simplicity. [AudioRender in the Audio API](../reference/apis/js-apis-audio.md#audiorenderer8)
provides reference for both callback and promise.
## **Other APIs:**
See [Audio](../reference/apis/js-apis-audio.md) for more useful APIs like getAudioTime, drain, and getBufferSize.
