1 /*
2 * Copyright (C) 2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16
17 #include <string>
18 #include <cstdio>
19 #include <cstdint>
20 #include "napi/native_api.h"
21 #include "ohaudio/native_audiocapturer.h"
22 #include "ohaudio/native_audiorenderer.h"
23 #include "ohaudio/native_audiostream_base.h"
24 #include "ohaudio/native_audiostreambuilder.h"
25 #include "unistd.h"
26 #include "ohaudio/native_audio_manager.h"
27 #include "ohaudio/native_audio_common.h"
28 #include "ohaudio/native_audio_routing_manager.h"
29 #include "ohaudio/native_audio_device_base.h"
30 #include "ohaudio/native_audio_session_manager.h"
31 #include "hilog/log.h"
32 #include <ctime>
33
34 #define AUDIO_LOG_TAG "AUDIO_TAGLOG"
35 #define AUDIO_LOG_DOMAIN 0x3200
36
37 #define LOG(fmt, ...) (void)OH_LOG_Print(LOG_APP, LOG_INFO, AUDIO_LOG_DOMAIN, AUDIO_LOG_TAG, fmt, ##__VA_ARGS__)
38
39 const int32_t g_samplingRate = 48000; // 48000:g_samplingRate value
40 const int32_t g_channelCount = 2; // 2:g_channelCount value
41 const int32_t g_latencyMode = 0;
42 const int32_t g_sampleFormat = 1;
43 const int32_t g_frameSize = 240; // 240:g_frameSize value
44 bool g_flag = false;
45 bool g_mark = false;
46 static std::string g_filePath = "/data/storage/el2/base/haps/entry_test/files/test_44100_2.wav";
47 FILE *g_file = nullptr;
48 bool g_readEnd = false;
49 const int32_t TEST_PASS = 0; // success result
50 const int32_t TEST_FAIL = 1; // fail result
51
52 static OH_AudioCapturer *g_audioCapturer;
53 static OH_AudioRenderer *g_audioRenderer;
54 static OH_AudioStreamBuilder *g_capturerBuilder;
55 static OH_AudioStreamBuilder *g_rendererBuilder;
56 static std::string g_pcmFilePath = "/data/storage/el2/base/haps/entry_test/files/oh_test_audio.pcm";
57 FILE *g_pcmFile = nullptr;
58
59 OH_AudioStream_Usage g_ohRendererStreamUsage;
60 OH_AudioStream_SourceType g_ohCapturerStreamUsage;
61 OH_AudioStream_SampleFormat g_ohFormat;
62 static int32_t g_ohSamplingRate;
63 static int32_t g_ohChannelCount;
64 OH_AudioStream_LatencyMode g_ohLatencyMode;
65
uDelay(int time)66 void uDelay(int time)//time*1000为秒数
67 {
68 clock_t now = clock();
69 while(clock() - now < time);
70 }
71
Delay(int time)72 void Delay(int time)//time为秒数
73 {
74 time = time * 1000;
75 clock_t now = clock();
76 while(clock() - now < time);
77 }
78
AudioRendererOnMarkReachedWriteData(OH_AudioRenderer * capturer,void * userData,void * buffer,int32_t bufferLen)79 static int32_t AudioRendererOnMarkReachedWriteData(OH_AudioRenderer* capturer,
80 void* userData,
81 void* buffer,
82 int32_t bufferLen)
83 {
84 size_t readCount = fread(buffer, bufferLen, 1, g_file);
85 if (!readCount) {
86 if (ferror(g_file)) {
87 LOG("Error reading myfile");
88 } else if (feof(g_file)) {
89 LOG("EOF found");
90 g_readEnd = true;
91 }
92 }
93 return 0;
94 }
95
96
MyAudioSessionDeactivatedCallback(OH_AudioSession_DeactivatedEvent event)97 static int32_t MyAudioSessionDeactivatedCallback(OH_AudioSession_DeactivatedEvent event)
98 {
99 switch(event.reason) {
100 case DEACTIVATED_LOWER_PRIORITY:
101 // 应用焦点被抢占
102 LOG("MyAudioSessionDeactivatedCallback, event is %{public}d", event.reason);
103 return 0;
104 case DEACTIVATED_TIMEOUT:
105 // 超时
106 LOG("MyAudioSessionDeactivatedCallback, event is %{public}d", event.reason);
107 return 0;
108 }
109 }
110
CreateAudioStreamBuilder(napi_env env,napi_callback_info info)111 static napi_value CreateAudioStreamBuilder(napi_env env, napi_callback_info info)
112 {
113 OH_AudioStreamBuilder *builder;
114 OH_AudioStream_Type type = AUDIOSTREAM_TYPE_CAPTURER;
115 OH_AudioStream_Result result = OH_AudioStreamBuilder_Create(&builder, type);
116 OH_AudioStreamBuilder_Destroy(builder);
117 napi_value res;
118 napi_create_int32(env, result, &res);
119 return res;
120 }
121
CreateCapturerBuilder()122 OH_AudioStreamBuilder *CreateCapturerBuilder()
123 {
124 OH_AudioStreamBuilder *builder;
125 OH_AudioStream_Type type = AUDIOSTREAM_TYPE_CAPTURER;
126 OH_AudioStreamBuilder_Create(&builder, type);
127 return builder;
128 }
129
130
AudioCaptureGenerate(napi_env env,napi_callback_info info)131 static napi_value AudioCaptureGenerate(napi_env env, napi_callback_info info)
132 {
133 OH_AudioStreamBuilder *builder = CreateCapturerBuilder();
134
135 OH_AudioCapturer *audioCapturer;
136 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateCapturer(builder, &audioCapturer);
137
138 OH_AudioCapturer_Release(audioCapturer);
139 OH_AudioStreamBuilder_Destroy(builder);
140 napi_value res;
141 napi_create_int32(env, result, &res);
142 return res;
143 }
144
AudioCaptureGenerateErr(napi_env env,napi_callback_info info)145 static napi_value AudioCaptureGenerateErr(napi_env env, napi_callback_info info)
146 {
147 OH_AudioStreamBuilder *builder = nullptr;
148 OH_AudioStream_Type type = AUDIOSTREAM_TYPE_RENDERER;
149 OH_AudioStreamBuilder_Create(&builder, type);
150
151 OH_AudioCapturer *audioCapturer = nullptr;
152 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateCapturer(builder, &audioCapturer);
153
154 OH_AudioCapturer_Release(audioCapturer);
155 OH_AudioStreamBuilder_Destroy(builder);
156 napi_value res;
157 napi_create_int32(env, result, &res);
158 return res;
159 }
160
AudioCaptureStart(napi_env env,napi_callback_info info)161 static napi_value AudioCaptureStart(napi_env env, napi_callback_info info)
162 {
163 LOG("AudioCaptureStart SUCCESS");
164 OH_AudioStreamBuilder *builder = CreateCapturerBuilder();
165 OH_AudioCapturer *audioCapturer;
166 OH_AudioStreamBuilder_GenerateCapturer(builder, &audioCapturer);
167
168 OH_AudioStream_Result result = OH_AudioCapturer_Start(audioCapturer);
169
170 OH_AudioCapturer_Release(audioCapturer);
171 OH_AudioStreamBuilder_Destroy(builder);
172 napi_value res;
173 napi_create_int32(env, result, &res);
174 return res;
175 }
176
AudioCaptureStartErr(napi_env env,napi_callback_info info)177 static napi_value AudioCaptureStartErr(napi_env env, napi_callback_info info)
178 {
179 LOG("AudioCaptureStart SUCCESS");
180 OH_AudioStreamBuilder *builder = CreateCapturerBuilder();
181 OH_AudioCapturer *audioCapturer;
182 OH_AudioStreamBuilder_GenerateCapturer(builder, &audioCapturer);
183 OH_AudioCapturer_Start(audioCapturer);
184 OH_AudioStream_Result result = OH_AudioCapturer_Start(audioCapturer);
185
186 OH_AudioCapturer_Release(audioCapturer);
187 OH_AudioStreamBuilder_Destroy(builder);
188 napi_value res;
189 napi_create_int32(env, result, &res);
190 return res;
191 }
192
AudioCapturePause(napi_env env,napi_callback_info info)193 static napi_value AudioCapturePause(napi_env env, napi_callback_info info)
194 {
195 LOG("AudioCaptureStart SUCCESS");
196 OH_AudioStreamBuilder *builder = CreateCapturerBuilder();
197 OH_AudioCapturer *audioCapturer;
198 OH_AudioStreamBuilder_GenerateCapturer(builder, &audioCapturer);
199 OH_AudioCapturer_Start(audioCapturer);
200 OH_AudioStream_Result result = OH_AudioCapturer_Pause(audioCapturer);
201 OH_AudioCapturer_Release(audioCapturer);
202 OH_AudioStreamBuilder_Destroy(builder);
203 napi_value res;
204 napi_create_int32(env, result, &res);
205 return res;
206 }
207
208
AudioCapturePauseErr(napi_env env,napi_callback_info info)209 static napi_value AudioCapturePauseErr(napi_env env, napi_callback_info info)
210 {
211 LOG("AudioCaptureStart SUCCESS");
212 OH_AudioStreamBuilder *builder = CreateCapturerBuilder();
213 OH_AudioCapturer *audioCapturer;
214 OH_AudioStreamBuilder_GenerateCapturer(builder, &audioCapturer);
215 OH_AudioStream_Result result = OH_AudioCapturer_Pause(audioCapturer);
216 OH_AudioCapturer_Release(audioCapturer);
217 OH_AudioStreamBuilder_Destroy(builder);
218 napi_value res;
219 napi_create_int32(env, result, &res);
220 return res;
221 }
222
AudioCaptureStop(napi_env env,napi_callback_info info)223 static napi_value AudioCaptureStop(napi_env env, napi_callback_info info)
224 {
225 LOG("AudioCaptureStart SUCCESS");
226 OH_AudioStreamBuilder *builder = CreateCapturerBuilder();
227 OH_AudioCapturer *audioCapturer;
228 OH_AudioStreamBuilder_GenerateCapturer(builder, &audioCapturer);
229 OH_AudioCapturer_Start(audioCapturer);
230 OH_AudioStream_Result result = OH_AudioCapturer_Stop(audioCapturer);
231 OH_AudioCapturer_Release(audioCapturer);
232 OH_AudioStreamBuilder_Destroy(builder);
233 napi_value res;
234 napi_create_int32(env, result, &res);
235 return res;
236 }
237
AudioCaptureStopErr(napi_env env,napi_callback_info info)238 static napi_value AudioCaptureStopErr(napi_env env, napi_callback_info info)
239 {
240 LOG("AudioCaptureStart SUCCESS");
241 OH_AudioStreamBuilder *builder = CreateCapturerBuilder();
242 OH_AudioCapturer *audioCapturer;
243 OH_AudioStreamBuilder_GenerateCapturer(builder, &audioCapturer);
244 OH_AudioStream_Result result = OH_AudioCapturer_Stop(audioCapturer);
245 OH_AudioCapturer_Release(audioCapturer);
246 OH_AudioStreamBuilder_Destroy(builder);
247 napi_value res;
248 napi_create_int32(env, result, &res);
249 return res;
250 }
251
AudioCaptureFlush(napi_env env,napi_callback_info info)252 static napi_value AudioCaptureFlush(napi_env env, napi_callback_info info)
253 {
254 LOG("AudioCaptureFlush SUCCESS");
255 OH_AudioStreamBuilder *builder = CreateCapturerBuilder();
256 OH_AudioCapturer *audioCapturer;
257 OH_AudioStreamBuilder_GenerateCapturer(builder, &audioCapturer);
258 OH_AudioCapturer_Start(audioCapturer);
259 OH_AudioStream_Result result = OH_AudioCapturer_Flush(audioCapturer);
260 OH_AudioCapturer_Release(audioCapturer);
261 OH_AudioStreamBuilder_Destroy(builder);
262 napi_value res;
263 napi_create_int32(env, result, &res);
264 return res;
265 }
266
267
AudioCaptureFlushErr(napi_env env,napi_callback_info info)268 static napi_value AudioCaptureFlushErr(napi_env env, napi_callback_info info)
269 {
270 OH_AudioStreamBuilder *builder = CreateCapturerBuilder();
271 OH_AudioCapturer *audioCapturer;
272 OH_AudioStreamBuilder_GenerateCapturer(builder, &audioCapturer);
273 OH_AudioStream_Result result = OH_AudioCapturer_Flush(audioCapturer);
274 OH_AudioCapturer_Release(audioCapturer);
275 OH_AudioStreamBuilder_Destroy(builder);
276 napi_value res;
277 napi_create_int32(env, result, &res);
278 return res;
279 }
280
AudioCaptureRelease(napi_env env,napi_callback_info info)281 static napi_value AudioCaptureRelease(napi_env env, napi_callback_info info)
282 {
283 OH_AudioStreamBuilder *builder = CreateCapturerBuilder();
284 OH_AudioCapturer *audioCapturer;
285 OH_AudioStreamBuilder_GenerateCapturer(builder, &audioCapturer);
286 OH_AudioCapturer_Start(audioCapturer);
287 OH_AudioStream_Result result = OH_AudioCapturer_Release(audioCapturer);
288 OH_AudioStreamBuilder_Destroy(builder);
289 napi_value res;
290 napi_create_int32(env, result, &res);
291 return res;
292 }
293
AudioCaptureReleaseErr(napi_env env,napi_callback_info info)294 static napi_value AudioCaptureReleaseErr(napi_env env, napi_callback_info info)
295 {
296 OH_AudioStreamBuilder *builder = CreateCapturerBuilder();
297 OH_AudioCapturer *audioCapturer;
298 OH_AudioStreamBuilder_GenerateCapturer(builder, &audioCapturer);
299 OH_AudioCapturer_Release(audioCapturer);
300 audioCapturer = nullptr;
301 OH_AudioStream_Result result = OH_AudioCapturer_Release(audioCapturer);
302 OH_AudioStreamBuilder_Destroy(builder);
303 napi_value res;
304 napi_create_int32(env, result, &res);
305 return res;
306 }
307
AudioCaptureGetParameter(napi_env env,napi_callback_info info)308 static napi_value AudioCaptureGetParameter(napi_env env, napi_callback_info info)
309 {
310 OH_AudioStreamBuilder *builder = CreateCapturerBuilder();
311 OH_AudioCapturer *audioCapturer;
312 OH_AudioStreamBuilder_GenerateCapturer(builder, &audioCapturer);
313
314 OH_AudioStream_LatencyMode latencyMode = AUDIOSTREAM_LATENCY_MODE_NORMAL;
315 OH_AudioStream_Result result = OH_AudioCapturer_GetLatencyMode(audioCapturer, &latencyMode);
316 OH_AudioCapturer_Release(audioCapturer);
317 OH_AudioStreamBuilder_Destroy(builder);
318 napi_value res;
319 napi_create_int32(env, result, &res);
320 return res;
321 }
322
AudioCaptureGetCurrentState(napi_env env,napi_callback_info info)323 static napi_value AudioCaptureGetCurrentState(napi_env env, napi_callback_info info)
324 {
325 OH_AudioStreamBuilder *builder = CreateCapturerBuilder();
326 OH_AudioCapturer *audioCapturer;
327 OH_AudioStreamBuilder_GenerateCapturer(builder, &audioCapturer);
328
329 OH_AudioStream_State state;
330 OH_AudioStream_Result result = OH_AudioCapturer_GetCurrentState(audioCapturer, &state);
331 OH_AudioCapturer_Release(audioCapturer);
332 OH_AudioStreamBuilder_Destroy(builder);
333 napi_value res;
334 napi_create_int32(env, result, &res);
335 return res;
336 }
337
AudioCaptureGetStreamId(napi_env env,napi_callback_info info)338 static napi_value AudioCaptureGetStreamId(napi_env env, napi_callback_info info)
339 {
340 OH_AudioStreamBuilder *builder = CreateCapturerBuilder();
341 OH_AudioCapturer *audioCapturer;
342 OH_AudioStreamBuilder_GenerateCapturer(builder, &audioCapturer);
343
344 uint32_t streamId;
345 OH_AudioStream_Result result = OH_AudioCapturer_GetStreamId(audioCapturer, &streamId);
346 OH_AudioCapturer_Release(audioCapturer);
347 OH_AudioStreamBuilder_Destroy(builder);
348 napi_value res;
349 napi_create_int32(env, result, &res);
350 return res;
351 }
352
AudioCaptureGetSamplingRate(napi_env env,napi_callback_info info)353 static napi_value AudioCaptureGetSamplingRate(napi_env env, napi_callback_info info)
354 {
355 OH_AudioStreamBuilder *builder = CreateCapturerBuilder();
356 OH_AudioCapturer *audioCapturer;
357 OH_AudioStreamBuilder_GenerateCapturer(builder, &audioCapturer);
358
359 int32_t rate;
360 OH_AudioStream_Result result = OH_AudioCapturer_GetSamplingRate(audioCapturer, &rate);
361 OH_AudioCapturer_Release(audioCapturer);
362 OH_AudioStreamBuilder_Destroy(builder);
363 napi_value res;
364 napi_create_int32(env, result, &res);
365 return res;
366 }
367
AudioCaptureGetSampleFormat(napi_env env,napi_callback_info info)368 static napi_value AudioCaptureGetSampleFormat(napi_env env, napi_callback_info info)
369 {
370 OH_AudioStreamBuilder *builder = CreateCapturerBuilder();
371 OH_AudioCapturer *audioCapturer;
372 OH_AudioStreamBuilder_GenerateCapturer(builder, &audioCapturer);
373
374 OH_AudioStream_SampleFormat sampleFormat;
375 OH_AudioStream_Result result = OH_AudioCapturer_GetSampleFormat(audioCapturer, &sampleFormat);
376 OH_AudioCapturer_Release(audioCapturer);
377 OH_AudioStreamBuilder_Destroy(builder);
378 napi_value res;
379 napi_create_int32(env, result, &res);
380 return res;
381 }
382
AudioCaptureGetEncodingType(napi_env env,napi_callback_info info)383 static napi_value AudioCaptureGetEncodingType(napi_env env, napi_callback_info info)
384 {
385 OH_AudioStreamBuilder *builder = CreateCapturerBuilder();
386 OH_AudioCapturer *audioCapturer;
387 OH_AudioStreamBuilder_GenerateCapturer(builder, &audioCapturer);
388
389 OH_AudioStream_EncodingType encodingType;
390 OH_AudioStream_Result result = OH_AudioCapturer_GetEncodingType(audioCapturer, &encodingType);
391 OH_AudioCapturer_Release(audioCapturer);
392 OH_AudioStreamBuilder_Destroy(builder);
393 napi_value res;
394 napi_create_int32(env, result, &res);
395 return res;
396 }
397
AudioCaptureGetCapturerInfo(napi_env env,napi_callback_info info)398 static napi_value AudioCaptureGetCapturerInfo(napi_env env, napi_callback_info info)
399 {
400 OH_AudioStreamBuilder *builder = CreateCapturerBuilder();
401 OH_AudioCapturer *audioCapturer;
402 OH_AudioStreamBuilder_GenerateCapturer(builder, &audioCapturer);
403
404 OH_AudioStream_SourceType sourceType;
405 OH_AudioStream_Result result = OH_AudioCapturer_GetCapturerInfo(audioCapturer, &sourceType);
406 OH_AudioCapturer_Release(audioCapturer);
407 OH_AudioStreamBuilder_Destroy(builder);
408 napi_value res;
409 napi_create_int32(env, result, &res);
410 return res;
411 }
412
AudioCaptureGetTimestamp(napi_env env,napi_callback_info info)413 static napi_value AudioCaptureGetTimestamp(napi_env env, napi_callback_info info)
414 {
415 OH_AudioStreamBuilder *builder = CreateCapturerBuilder();
416 OH_AudioCapturer *audioCapturer;
417 OH_AudioStreamBuilder_GenerateCapturer(builder, &audioCapturer);
418 OH_AudioCapturer_Start(audioCapturer);
419
420 int sleepNum = 30000;
421 uDelay(sleepNum);
422 int64_t framePosition;
423 int64_t timestamp;
424 OH_AudioStream_Result result = OH_AudioCapturer_GetTimestamp(audioCapturer, CLOCK_MONOTONIC, &framePosition, ×tamp);
425 OH_AudioCapturer_Stop(audioCapturer);
426 OH_AudioCapturer_Release(audioCapturer);
427 OH_AudioStreamBuilder_Destroy(builder);
428 napi_value res;
429 napi_create_int32(env, result, &res);
430 return res;
431 }
432
AudioCaptureGetFramesRead(napi_env env,napi_callback_info info)433 static napi_value AudioCaptureGetFramesRead(napi_env env, napi_callback_info info)
434 {
435 OH_AudioStreamBuilder *builder = CreateCapturerBuilder();
436 OH_AudioCapturer *audioCapturer;
437 OH_AudioStreamBuilder_GenerateCapturer(builder, &audioCapturer);
438
439 int64_t frames;
440 OH_AudioStream_Result result = OH_AudioCapturer_GetFramesRead(audioCapturer, &frames);
441 OH_AudioCapturer_Release(audioCapturer);
442 OH_AudioStreamBuilder_Destroy(builder);
443 napi_value res;
444 napi_create_int32(env, result, &res);
445 return res;
446 }
447
AudioCaptureGetFrameSizeInCallback(napi_env env,napi_callback_info info)448 static napi_value AudioCaptureGetFrameSizeInCallback(napi_env env, napi_callback_info info)
449 {
450 OH_AudioStreamBuilder *builder = CreateCapturerBuilder();
451 OH_AudioCapturer *audioCapturer;
452 OH_AudioStreamBuilder_GenerateCapturer(builder, &audioCapturer);
453
454 int32_t frameSize;
455 OH_AudioStream_Result result = OH_AudioCapturer_GetFrameSizeInCallback(audioCapturer, &frameSize);
456 OH_AudioCapturer_Release(audioCapturer);
457 OH_AudioStreamBuilder_Destroy(builder);
458 napi_value res;
459 napi_create_int32(env, result, &res);
460 return res;
461 }
462
463
CreateRenderBuilder()464 OH_AudioStreamBuilder *CreateRenderBuilder()
465 {
466 OH_AudioStreamBuilder *builder;
467 OH_AudioStream_Type type = AUDIOSTREAM_TYPE_RENDERER;
468 OH_AudioStreamBuilder_Create(&builder, type);
469 return builder;
470 }
471
AudioRendererSetSpeed(napi_env env,napi_callback_info info)472 static napi_value AudioRendererSetSpeed(napi_env env, napi_callback_info info)
473 {
474 OH_AudioStreamBuilder *builder = CreateRenderBuilder();
475
476 OH_AudioRenderer *audioRenderer;
477 OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
478 float speed = 2;
479 OH_AudioStream_Result result = OH_AudioRenderer_SetSpeed(audioRenderer,speed);
480 OH_AudioRenderer_Release(audioRenderer);
481 OH_AudioStreamBuilder_Destroy(builder);
482 napi_value res;
483 napi_create_int32(env, result, &res);
484 return res;
485 }
486
AudioRendererGetSpeed(napi_env env,napi_callback_info info)487 static napi_value AudioRendererGetSpeed(napi_env env, napi_callback_info info)
488 {
489 OH_AudioStreamBuilder *builder = CreateRenderBuilder();
490
491 OH_AudioRenderer *audioRenderer;
492 OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
493 float speed;
494 OH_AudioStream_Result result = OH_AudioRenderer_GetSpeed(audioRenderer,&speed);
495 OH_AudioRenderer_Release(audioRenderer);
496 OH_AudioStreamBuilder_Destroy(builder);
497 napi_value res;
498 napi_create_int32(env, result, &res);
499 return res;
500 }
501
AudioRendererSetGetSpeed(napi_env env,napi_callback_info info)502 static napi_value AudioRendererSetGetSpeed(napi_env env, napi_callback_info info)
503 {
504 OH_AudioStreamBuilder *builder = CreateRenderBuilder();
505
506 OH_AudioRenderer *audioRenderer;
507 OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
508 float setSpeed = 1.5;
509 OH_AudioRenderer_SetSpeed(audioRenderer,setSpeed);
510 float getSpeed;
511 OH_AudioRenderer_GetSpeed(audioRenderer,&getSpeed);
512 OH_AudioRenderer_Release(audioRenderer);
513 OH_AudioStreamBuilder_Destroy(builder);
514 napi_value res;
515 napi_create_double(env, getSpeed, &res);
516 return res;
517 }
518
AudioRendererDeviceChangeCb(OH_AudioRenderer * renderer,void * userData,OH_AudioStream_DeviceChangeReason reason)519 static void AudioRendererDeviceChangeCb(OH_AudioRenderer* renderer, void* userData,
520 OH_AudioStream_DeviceChangeReason reason)
521 {}
522
AudioSetRendererOutputDeviceChangeCallback(napi_env env,napi_callback_info info)523 static napi_value AudioSetRendererOutputDeviceChangeCallback(napi_env env, napi_callback_info info)
524 {
525 OH_AudioStreamBuilder *builder = CreateRenderBuilder();
526 OH_AudioStream_Type type = AUDIOSTREAM_TYPE_RENDERER;
527 OH_AudioStreamBuilder_Create(&builder, type);
528
529 OH_AudioRenderer_OutputDeviceChangeCallback deviceChangeCb = AudioRendererDeviceChangeCb;
530
531 OH_AudioStream_Result result = OH_AudioStreamBuilder_SetRendererOutputDeviceChangeCallback(builder, deviceChangeCb, NULL);
532
533 OH_AudioStreamBuilder_Destroy(builder);
534 napi_value res;
535 napi_create_int32(env, result, &res);
536 return res;
537 }
538
MicBlockedCallback(OH_AudioDeviceDescriptorArray * audioDeviceDescriptorArray,OH_AudioDevice_BlockStatus status,void * userData)539 static void MicBlockedCallback(OH_AudioDeviceDescriptorArray *audioDeviceDescriptorArray,
540 OH_AudioDevice_BlockStatus status, void *userData)
541 {
542 switch (status) {
543 case AUDIO_DEVICE_UNBLOCKED:
544 // 麦克风未被堵住
545 LOG("MyAudioSessionDeactivatedCallback, event is %{public}d", status);
546 case AUDIO_DEVICE_BLOCKED:
547 // 麦克风被堵住
548 LOG("MyAudioSessionDeactivatedCallback, event is %{public}d", status);
549 }
550 }
551
AudioRenderGetFramesWritten(napi_env env,napi_callback_info info)552 static napi_value AudioRenderGetFramesWritten(napi_env env, napi_callback_info info)
553 {
554 OH_AudioStreamBuilder *builder = CreateRenderBuilder();
555
556 OH_AudioRenderer *audioRenderer;
557 OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
558 int64_t frames;
559 OH_AudioStream_Result result = OH_AudioRenderer_GetFramesWritten(audioRenderer, &frames);
560 OH_AudioRenderer_Release(audioRenderer);
561 OH_AudioStreamBuilder_Destroy(builder);
562 napi_value res;
563 napi_create_int32(env, result, &res);
564 return res;
565 }
566
AudioRenderGetTimestamp(napi_env env,napi_callback_info info)567 static napi_value AudioRenderGetTimestamp(napi_env env, napi_callback_info info)
568 {
569 OH_AudioStreamBuilder *builder = CreateRenderBuilder();
570
571 OH_AudioRenderer *audioRenderer;
572 OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
573 OH_AudioRenderer_Start(audioRenderer);
574
575 int sleepNum = 30000;
576 uDelay(sleepNum);
577 int64_t framePosition;
578 int64_t timestamp;
579 OH_AudioStream_Result result = OH_AudioRenderer_GetTimestamp(audioRenderer, CLOCK_MONOTONIC, &framePosition, ×tamp);
580 OH_AudioRenderer_Stop(audioRenderer);
581 OH_AudioRenderer_Release(audioRenderer);
582 OH_AudioStreamBuilder_Destroy(builder);
583 napi_value res;
584 napi_create_int32(env, result, &res);
585 return res;
586 }
587
AudioRenderGetFrameSizeInCallback(napi_env env,napi_callback_info info)588 static napi_value AudioRenderGetFrameSizeInCallback(napi_env env, napi_callback_info info)
589 {
590 OH_AudioStreamBuilder *builder = CreateRenderBuilder();
591
592 OH_AudioRenderer *audioRenderer;
593 OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
594 int32_t frameSize;
595 OH_AudioStream_Result result = OH_AudioRenderer_GetFrameSizeInCallback(audioRenderer, &frameSize);
596 OH_AudioRenderer_Release(audioRenderer);
597 OH_AudioStreamBuilder_Destroy(builder);
598 napi_value res;
599 napi_create_int32(env, result, &res);
600 return res;
601 }
602
AudioRenderGenerate(napi_env env,napi_callback_info info)603 static napi_value AudioRenderGenerate(napi_env env, napi_callback_info info)
604 {
605 OH_AudioStreamBuilder *builder = CreateRenderBuilder();
606
607 OH_AudioRenderer *audioRenderer;
608 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
609 OH_AudioRenderer_Release(audioRenderer);
610 OH_AudioStreamBuilder_Destroy(builder);
611 napi_value res;
612 napi_create_int32(env, result, &res);
613 return res;
614 }
615
AudioRenderGenerateErr(napi_env env,napi_callback_info info)616 static napi_value AudioRenderGenerateErr(napi_env env, napi_callback_info info)
617 {
618 OH_AudioStreamBuilder *builder;
619 OH_AudioStream_Type type = AUDIOSTREAM_TYPE_CAPTURER;
620 OH_AudioStreamBuilder_Create(&builder, type);
621
622 OH_AudioRenderer *audioRenderer;
623 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
624
625 OH_AudioStreamBuilder_Destroy(builder);
626 napi_value res;
627 napi_create_int32(env, result, &res);
628 return res;
629 }
630
AudioRenderStart(napi_env env,napi_callback_info info)631 static napi_value AudioRenderStart(napi_env env, napi_callback_info info)
632 {
633 OH_AudioStreamBuilder *builder = CreateRenderBuilder();
634
635 OH_AudioRenderer *audioRenderer;
636 OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
637 OH_AudioStream_Result result = OH_AudioRenderer_Start(audioRenderer);
638 OH_AudioRenderer_Release(audioRenderer);
639 OH_AudioStreamBuilder_Destroy(builder);
640 napi_value res;
641 napi_create_int32(env, result, &res);
642 return res;
643 }
644
645
AudioRenderStartErr(napi_env env,napi_callback_info info)646 static napi_value AudioRenderStartErr(napi_env env, napi_callback_info info)
647 {
648 OH_AudioStreamBuilder *builder = CreateRenderBuilder();
649
650 OH_AudioRenderer *audioRenderer;
651 OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
652 OH_AudioRenderer_Start(audioRenderer);
653 OH_AudioStream_Result result = OH_AudioRenderer_Start(audioRenderer);
654 OH_AudioRenderer_Release(audioRenderer);
655 OH_AudioStreamBuilder_Destroy(builder);
656 napi_value res;
657 napi_create_int32(env, result, &res);
658 return res;
659 }
660
AudioRenderPause(napi_env env,napi_callback_info info)661 static napi_value AudioRenderPause(napi_env env, napi_callback_info info)
662 {
663 OH_AudioStreamBuilder *builder = CreateRenderBuilder();
664
665 OH_AudioRenderer *audioRenderer;
666 OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
667 OH_AudioRenderer_Start(audioRenderer);
668 OH_AudioStream_Result result = OH_AudioRenderer_Pause(audioRenderer);
669 OH_AudioRenderer_Release(audioRenderer);
670 OH_AudioStreamBuilder_Destroy(builder);
671 napi_value res;
672 napi_create_int32(env, result, &res);
673 return res;
674 }
675
AudioRenderPauseErr(napi_env env,napi_callback_info info)676 static napi_value AudioRenderPauseErr(napi_env env, napi_callback_info info)
677 {
678 OH_AudioStreamBuilder *builder = CreateRenderBuilder();
679
680 OH_AudioRenderer *audioRenderer;
681 OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
682 OH_AudioStream_Result result = OH_AudioRenderer_Pause(audioRenderer);
683 OH_AudioRenderer_Release(audioRenderer);
684 OH_AudioStreamBuilder_Destroy(builder);
685 napi_value res;
686 napi_create_int32(env, result, &res);
687 return res;
688 }
689
AudioRenderStop(napi_env env,napi_callback_info info)690 static napi_value AudioRenderStop(napi_env env, napi_callback_info info)
691 {
692 OH_AudioStreamBuilder *builder = CreateRenderBuilder();
693
694 OH_AudioRenderer *audioRenderer;
695 OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
696 OH_AudioRenderer_Start(audioRenderer);
697 OH_AudioStream_Result result = OH_AudioRenderer_Stop(audioRenderer);
698 OH_AudioRenderer_Release(audioRenderer);
699 OH_AudioStreamBuilder_Destroy(builder);
700 napi_value res;
701 napi_create_int32(env, result, &res);
702 return res;
703 }
704
AudioRenderStopErr(napi_env env,napi_callback_info info)705 static napi_value AudioRenderStopErr(napi_env env, napi_callback_info info)
706 {
707 OH_AudioStreamBuilder *builder = CreateRenderBuilder();
708
709 OH_AudioRenderer *audioRenderer;
710 OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
711 OH_AudioStream_Result result = OH_AudioRenderer_Stop(audioRenderer);
712 OH_AudioRenderer_Release(audioRenderer);
713 OH_AudioStreamBuilder_Destroy(builder);
714 napi_value res;
715 napi_create_int32(env, result, &res);
716 return res;
717 }
718
AudioRenderFlush(napi_env env,napi_callback_info info)719 static napi_value AudioRenderFlush(napi_env env, napi_callback_info info)
720 {
721 OH_AudioStreamBuilder *builder = CreateRenderBuilder();
722
723 OH_AudioRenderer *audioRenderer;
724 OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
725 OH_AudioRenderer_Start(audioRenderer);
726 OH_AudioStream_Result result = OH_AudioRenderer_Flush(audioRenderer);
727 OH_AudioRenderer_Release(audioRenderer);
728 OH_AudioStreamBuilder_Destroy(builder);
729 napi_value res;
730 napi_create_int32(env, result, &res);
731 return res;
732 }
733
734
AudioRenderFlushErr(napi_env env,napi_callback_info info)735 static napi_value AudioRenderFlushErr(napi_env env, napi_callback_info info)
736 {
737 OH_AudioStreamBuilder *builder = CreateRenderBuilder();
738
739 OH_AudioRenderer *audioRenderer;
740 OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
741 OH_AudioStream_Result result = OH_AudioRenderer_Flush(audioRenderer);
742 OH_AudioRenderer_Release(audioRenderer);
743 OH_AudioStreamBuilder_Destroy(builder);
744 napi_value res;
745 napi_create_int32(env, result, &res);
746 return res;
747 }
748
AudioRenderRelease(napi_env env,napi_callback_info info)749 static napi_value AudioRenderRelease(napi_env env, napi_callback_info info)
750 {
751 OH_AudioStreamBuilder *builder = CreateRenderBuilder();
752
753 OH_AudioRenderer *audioRenderer;
754 OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
755 OH_AudioRenderer_Start(audioRenderer);
756 OH_AudioStream_Result result = OH_AudioRenderer_Release(audioRenderer);
757 OH_AudioStreamBuilder_Destroy(builder);
758 napi_value res;
759 napi_create_int32(env, result, &res);
760 return res;
761 }
762
763
AudioRenderReleaseErr(napi_env env,napi_callback_info info)764 static napi_value AudioRenderReleaseErr(napi_env env, napi_callback_info info)
765 {
766 OH_AudioStreamBuilder *builder = CreateRenderBuilder();
767
768 OH_AudioRenderer *audioRenderer;
769 OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
770 OH_AudioRenderer_Release(audioRenderer);
771 audioRenderer = nullptr;
772 OH_AudioStream_Result result = OH_AudioRenderer_Release(audioRenderer);
773 OH_AudioStreamBuilder_Destroy(builder);
774 napi_value res;
775 napi_create_int32(env, result, &res);
776 return res;
777 }
778
AudioRenderGetCurrentState(napi_env env,napi_callback_info info)779 static napi_value AudioRenderGetCurrentState(napi_env env, napi_callback_info info)
780 {
781 OH_AudioStreamBuilder *builder = CreateRenderBuilder();
782
783 OH_AudioRenderer *audioRenderer;
784 OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
785 OH_AudioStream_State state;
786 OH_AudioStream_Result result = OH_AudioRenderer_GetCurrentState(audioRenderer, &state);
787 OH_AudioRenderer_Release(audioRenderer);
788 OH_AudioStreamBuilder_Destroy(builder);
789 napi_value res;
790 napi_create_int32(env, result, &res);
791 return res;
792 }
793
794
AudioRenderGetParameter(napi_env env,napi_callback_info info)795 static napi_value AudioRenderGetParameter(napi_env env, napi_callback_info info)
796 {
797 OH_AudioStreamBuilder *builder = CreateRenderBuilder();
798
799 OH_AudioRenderer *audioRenderer;
800 OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
801 OH_AudioStream_LatencyMode latencyMode = AUDIOSTREAM_LATENCY_MODE_NORMAL;
802 OH_AudioStream_Result result = OH_AudioRenderer_GetLatencyMode(audioRenderer, &latencyMode);
803 OH_AudioRenderer_Release(audioRenderer);
804 OH_AudioStreamBuilder_Destroy(builder);
805 napi_value res;
806 napi_create_int32(env, result, &res);
807 return res;
808 }
809
810
AudioRenderGetStreamId(napi_env env,napi_callback_info info)811 static napi_value AudioRenderGetStreamId(napi_env env, napi_callback_info info)
812 {
813 OH_AudioStreamBuilder *builder = CreateRenderBuilder();
814
815 OH_AudioRenderer *audioRenderer;
816 OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
817
818 uint32_t streamId;
819 OH_AudioStream_Result result = OH_AudioRenderer_GetStreamId(audioRenderer, &streamId);
820 OH_AudioRenderer_Release(audioRenderer);
821 OH_AudioStreamBuilder_Destroy(builder);
822 napi_value res;
823 napi_create_int32(env, result, &res);
824 return res;
825 }
826
AudioRenderGetSamplingRate(napi_env env,napi_callback_info info)827 static napi_value AudioRenderGetSamplingRate(napi_env env, napi_callback_info info)
828 {
829 OH_AudioStreamBuilder *builder = CreateRenderBuilder();
830
831 OH_AudioRenderer *audioRenderer;
832 OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
833 int32_t rate;
834 OH_AudioStream_Result result = OH_AudioRenderer_GetSamplingRate(audioRenderer, &rate);
835 OH_AudioRenderer_Release(audioRenderer);
836 OH_AudioStreamBuilder_Destroy(builder);
837 napi_value res;
838 napi_create_int32(env, result, &res);
839 return res;
840 }
841
842
AudioRenderGetSampleFormat(napi_env env,napi_callback_info info)843 static napi_value AudioRenderGetSampleFormat(napi_env env, napi_callback_info info)
844 {
845 OH_AudioStreamBuilder *builder = CreateRenderBuilder();
846
847 OH_AudioRenderer *audioRenderer;
848 OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
849 OH_AudioStream_SampleFormat sampleFormat;
850 OH_AudioStream_Result result = OH_AudioRenderer_GetSampleFormat(audioRenderer, &sampleFormat);
851 OH_AudioRenderer_Release(audioRenderer);
852 OH_AudioStreamBuilder_Destroy(builder);
853 napi_value res;
854 napi_create_int32(env, result, &res);
855 return res;
856 }
857
858
AudioRenderGetEncodingType(napi_env env,napi_callback_info info)859 static napi_value AudioRenderGetEncodingType(napi_env env, napi_callback_info info)
860 {
861 OH_AudioStreamBuilder *builder = CreateRenderBuilder();
862
863 OH_AudioRenderer *audioRenderer;
864 OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
865 OH_AudioStream_EncodingType encodingType;
866 OH_AudioStream_Result result = OH_AudioRenderer_GetEncodingType(audioRenderer, &encodingType);
867 OH_AudioRenderer_Release(audioRenderer);
868 OH_AudioStreamBuilder_Destroy(builder);
869 napi_value res;
870 napi_create_int32(env, result, &res);
871 return res;
872 }
873
AudioRenderGetRendererInfo(napi_env env,napi_callback_info info)874 static napi_value AudioRenderGetRendererInfo(napi_env env, napi_callback_info info)
875 {
876 OH_AudioStreamBuilder *builder = CreateRenderBuilder();
877
878 OH_AudioRenderer *audioRenderer;
879 OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
880 OH_AudioStream_Usage usage;
881 OH_AudioStream_Result result = OH_AudioRenderer_GetRendererInfo(audioRenderer, &usage);
882 OH_AudioRenderer_Release(audioRenderer);
883 OH_AudioStreamBuilder_Destroy(builder);
884 napi_value res;
885 napi_create_int32(env, result, &res);
886 return res;
887 }
888
889
AudioStreamBuilderSetSamplingRate(napi_env env,napi_callback_info info)890 static napi_value AudioStreamBuilderSetSamplingRate(napi_env env, napi_callback_info info)
891 {
892 OH_AudioStreamBuilder* builder;
893 OH_AudioStream_Type type = AUDIOSTREAM_TYPE_CAPTURER;
894 OH_AudioStreamBuilder_Create(&builder, type);
895 int32_t samplingRate = 48000;
896 OH_AudioStreamBuilder_SetSamplingRate(builder, samplingRate);
897 OH_AudioStream_Result result = OH_AudioStreamBuilder_Destroy(builder);
898 napi_value res;
899 napi_create_int32(env, result, &res);
900 return res;
901 }
902
AudioStreamBuilderSetChannelCount(napi_env env,napi_callback_info info)903 static napi_value AudioStreamBuilderSetChannelCount(napi_env env, napi_callback_info info)
904 {
905 OH_AudioStreamBuilder* builder;
906 OH_AudioStream_Type type = AUDIOSTREAM_TYPE_CAPTURER;
907 OH_AudioStreamBuilder_Create(&builder, type);
908 int32_t channelCount = 1;
909 OH_AudioStream_Result result = OH_AudioStreamBuilder_SetChannelCount(builder, channelCount);
910 OH_AudioStreamBuilder_Destroy(builder);
911 napi_value res;
912 napi_create_int32(env, result, &res);
913 return res;
914 }
915
916
AudioStreamBuilderSetSampleFormat(napi_env env,napi_callback_info info)917 static napi_value AudioStreamBuilderSetSampleFormat(napi_env env, napi_callback_info info)
918 {
919 OH_AudioStreamBuilder* builder;
920 OH_AudioStream_Type type = AUDIOSTREAM_TYPE_CAPTURER;
921 OH_AudioStreamBuilder_Create(&builder, type);
922 OH_AudioStream_SampleFormat format = AUDIOSTREAM_SAMPLE_U8;
923 OH_AudioStream_Result result = OH_AudioStreamBuilder_SetSampleFormat(builder, format);
924 OH_AudioStreamBuilder_Destroy(builder);
925 napi_value res;
926 napi_create_int32(env, result, &res);
927 return res;
928 }
929
930
AudioStreamBuilderSetEncodingType(napi_env env,napi_callback_info info)931 static napi_value AudioStreamBuilderSetEncodingType(napi_env env, napi_callback_info info)
932 {
933 OH_AudioStreamBuilder* builder;
934 OH_AudioStream_Type type = AUDIOSTREAM_TYPE_CAPTURER;
935 OH_AudioStreamBuilder_Create(&builder, type);
936 OH_AudioStream_EncodingType encodingType = AUDIOSTREAM_ENCODING_TYPE_RAW;
937 OH_AudioStream_Result result = OH_AudioStreamBuilder_SetEncodingType(builder, encodingType);
938 OH_AudioStreamBuilder_Destroy(builder);
939 napi_value res;
940 napi_create_int32(env, result, &res);
941 return res;
942 }
943
944
AudioStreamBuilderSetLatencyMode(napi_env env,napi_callback_info info)945 static napi_value AudioStreamBuilderSetLatencyMode(napi_env env, napi_callback_info info)
946 {
947 OH_AudioStreamBuilder* builder;
948 OH_AudioStream_Type type = AUDIOSTREAM_TYPE_CAPTURER;
949 OH_AudioStreamBuilder_Create(&builder, type);
950
951 OH_AudioStream_LatencyMode latencyMode = AUDIOSTREAM_LATENCY_MODE_NORMAL;
952 OH_AudioStreamBuilder_SetLatencyMode(builder, latencyMode);
953
954 OH_AudioStream_Result result = OH_AudioStreamBuilder_Destroy(builder);
955 napi_value res;
956 napi_create_int32(env, result, &res);
957 return res;
958 }
959
960
AudioStreamBuilderSetRendererInfo(napi_env env,napi_callback_info info)961 static napi_value AudioStreamBuilderSetRendererInfo(napi_env env, napi_callback_info info)
962 {
963 OH_AudioStreamBuilder* builder;
964 OH_AudioStream_Type type = AUDIOSTREAM_TYPE_RENDERER;
965 OH_AudioStreamBuilder_Create(&builder, type);
966 OH_AudioStream_Usage usage = AUDIOSTREAM_USAGE_MUSIC;
967 OH_AudioStream_Result result = OH_AudioStreamBuilder_SetRendererInfo(builder, usage);
968
969 OH_AudioStreamBuilder_Destroy(builder);
970 napi_value res;
971 napi_create_int32(env, result, &res);
972 return res;
973 }
974
975
AudioStreamBuilderSetCapturerInfo(napi_env env,napi_callback_info info)976 static napi_value AudioStreamBuilderSetCapturerInfo(napi_env env, napi_callback_info info)
977 {
978 OH_AudioStreamBuilder* builder;
979 OH_AudioStream_Type type = AUDIOSTREAM_TYPE_CAPTURER;
980 OH_AudioStreamBuilder_Create(&builder, type);
981 OH_AudioStream_SourceType sourceType = AUDIOSTREAM_SOURCE_TYPE_MIC;
982 OH_AudioStream_Result result = OH_AudioStreamBuilder_SetCapturerInfo(builder, sourceType);
983 OH_AudioStreamBuilder_Destroy(builder);
984 napi_value res;
985 napi_create_int32(env, result, &res);
986 return res;
987 }
988
AudioRendererOnWriteData(OH_AudioRenderer * capturer,void * userData,void * buffer,int32_t bufferLen)989 static int32_t AudioRendererOnWriteData(OH_AudioRenderer* capturer,
990 void* userData,
991 void* buffer,
992 int32_t bufferLen)
993 {
994 return 0;
995 }
AudioStreamBuilderSetRendererCallback(napi_env env,napi_callback_info info)996 static napi_value AudioStreamBuilderSetRendererCallback(napi_env env, napi_callback_info info)
997 {
998 OH_AudioStreamBuilder* builder;
999 OH_AudioStream_Type type = AUDIOSTREAM_TYPE_RENDERER;
1000 OH_AudioStreamBuilder_Create(&builder, type);
1001 OH_AudioRenderer_Callbacks callbacks;
1002 callbacks.OH_AudioRenderer_OnWriteData = AudioRendererOnWriteData;
1003 OH_AudioStream_Result result = OH_AudioStreamBuilder_SetRendererCallback(builder, callbacks, NULL);
1004 OH_AudioStreamBuilder_Destroy(builder);
1005 napi_value res;
1006 napi_create_int32(env, result, &res);
1007 return res;
1008 }
1009
AudioCapturerOnReadData(OH_AudioCapturer * capturer,void * userData,void * buffer,int32_t bufferLen)1010 static int32_t AudioCapturerOnReadData(
1011 OH_AudioCapturer* capturer,
1012 void* userData,
1013 void* buffer,
1014 int32_t bufferLen)
1015 {
1016 return 0;
1017 }
AudioStreamBuilderSetCapturerCallback(napi_env env,napi_callback_info info)1018 static napi_value AudioStreamBuilderSetCapturerCallback(napi_env env, napi_callback_info info)
1019 {
1020 OH_AudioStreamBuilder* builder;
1021 OH_AudioStream_Type type = AUDIOSTREAM_TYPE_CAPTURER;
1022 OH_AudioStreamBuilder_Create(&builder, type);
1023
1024 OH_AudioCapturer_Callbacks callbacks;
1025 callbacks.OH_AudioCapturer_OnReadData = AudioCapturerOnReadData;
1026 OH_AudioStream_Result result = OH_AudioStreamBuilder_SetCapturerCallback(builder, callbacks, NULL);
1027
1028 OH_AudioStreamBuilder_Destroy(builder);
1029 napi_value res;
1030 napi_create_int32(env, result, &res);
1031 return res;
1032 }
1033
AudioCaptureGetChannelCount(napi_env env,napi_callback_info info)1034 static napi_value AudioCaptureGetChannelCount(napi_env env, napi_callback_info info)
1035 {
1036 OH_AudioStreamBuilder *builder = CreateCapturerBuilder();
1037 OH_AudioCapturer *audioCapturer;
1038 OH_AudioStreamBuilder_GenerateCapturer(builder, &audioCapturer);
1039
1040 int32_t channelCount;
1041 OH_AudioStream_Result result = OH_AudioCapturer_GetChannelCount(audioCapturer, &channelCount);
1042 OH_AudioCapturer_Release(audioCapturer);
1043 OH_AudioStreamBuilder_Destroy(builder);
1044 napi_value res;
1045 napi_create_int32(env, result, &res);
1046 return res;
1047 }
1048
AudioRenderGetChannelCount(napi_env env,napi_callback_info info)1049 static napi_value AudioRenderGetChannelCount(napi_env env, napi_callback_info info)
1050 {
1051 OH_AudioStreamBuilder *builder = CreateRenderBuilder();
1052
1053 OH_AudioRenderer *audioRenderer;
1054 OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
1055
1056 int32_t channelCount;
1057 OH_AudioStream_Result result = OH_AudioRenderer_GetChannelCount(audioRenderer, &channelCount);
1058 OH_AudioRenderer_Release(audioRenderer);
1059 OH_AudioStreamBuilder_Destroy(builder);
1060 napi_value res;
1061 napi_create_int32(env, result, &res);
1062 return res;
1063 }
1064
AudioStreamBuilderSetFrameSizeInCallback(napi_env env,napi_callback_info info)1065 static napi_value AudioStreamBuilderSetFrameSizeInCallback(napi_env env, napi_callback_info info)
1066 {
1067 OH_AudioStreamBuilder *builder;
1068 OH_AudioStream_Type type = AUDIOSTREAM_TYPE_RENDERER;
1069 OH_AudioStreamBuilder_Create(&builder, type);
1070 int32_t framesize = 960;
1071 OH_AudioStream_Result result = OH_AudioStreamBuilder_SetFrameSizeInCallback(builder, framesize);
1072 OH_AudioStreamBuilder_Destroy(builder);
1073 napi_value res;
1074 napi_create_int32(env, result, &res);
1075 return res;
1076 }
1077
AudioRendererGetVolume_01(napi_env env,napi_callback_info info)1078 static napi_value AudioRendererGetVolume_01(napi_env env, napi_callback_info info)
1079 {
1080 OH_AudioRenderer* audioRenderer = nullptr;
1081 float volume;
1082 OH_AudioStream_Result result = OH_AudioRenderer_GetVolume(audioRenderer, &volume);
1083 LOG("OH_AudioRenderer_GetVolume, volumeGet is %f, result %{public}d", volume, result);
1084 napi_value res;
1085 if (result != AUDIOSTREAM_ERROR_INVALID_PARAM) {
1086 napi_create_int32(env, TEST_FAIL, &res);
1087 } else {
1088 napi_create_int32(env, TEST_PASS, &res);
1089 }
1090 return res;
1091 }
1092
AudioRendererSetVolume_01(napi_env env,napi_callback_info info)1093 static napi_value AudioRendererSetVolume_01(napi_env env, napi_callback_info info)
1094 {
1095 OH_AudioStreamBuilder* builder = CreateRenderBuilder();
1096 OH_AudioRenderer* audioRenderer;
1097 napi_value res;
1098 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
1099 if (result != AUDIOSTREAM_SUCCESS) {
1100 napi_create_int32(env, TEST_FAIL, &res);
1101 return res;
1102 }
1103 float volumeSet = 1.0;
1104 result = OH_AudioRenderer_SetVolume(audioRenderer, volumeSet);
1105 LOG("OH_AudioRenderer_SetVolume 1.0, result is %{public}d", result);
1106 if (result != AUDIOSTREAM_SUCCESS) {
1107 napi_create_int32(env, TEST_FAIL, &res);
1108 return res;
1109 }
1110 float volumeGet;
1111 result = OH_AudioRenderer_GetVolume(audioRenderer, &volumeGet);
1112 LOG("OH_AudioRenderer_GetVolume, volumeGet is %f, %{public}d", volumeGet, result);
1113 if (result != AUDIOSTREAM_SUCCESS || volumeGet != volumeSet) {
1114 napi_create_int32(env, TEST_FAIL, &res);
1115 } else {
1116 napi_create_int32(env, TEST_PASS, &res);
1117 }
1118 OH_AudioRenderer_Release(audioRenderer);
1119 OH_AudioStreamBuilder_Destroy(builder);
1120 return res;
1121 }
1122
AudioRendererSetVolume_02(napi_env env,napi_callback_info info)1123 static napi_value AudioRendererSetVolume_02(napi_env env, napi_callback_info info)
1124 {
1125 OH_AudioStreamBuilder* builder = CreateRenderBuilder();
1126 OH_AudioRenderer* audioRenderer;
1127 napi_value res;
1128 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
1129 if (result != AUDIOSTREAM_SUCCESS) {
1130 napi_create_int32(env, TEST_FAIL, &res);
1131 return res;
1132 }
1133 float volumeSet = 0.0;
1134 result = OH_AudioRenderer_SetVolume(audioRenderer, volumeSet);
1135 LOG("OH_AudioRenderer_SetVolume 0.0, result is %{public}d", result);
1136 if (result != AUDIOSTREAM_SUCCESS) {
1137 napi_create_int32(env, TEST_FAIL, &res);
1138 return res;
1139 }
1140 float volumeGet;
1141 result = OH_AudioRenderer_GetVolume(audioRenderer, &volumeGet);
1142 LOG("OH_AudioRenderer_GetVolume, volumeGet is %f, %{public}d", volumeGet, result);
1143 if (result != AUDIOSTREAM_SUCCESS || volumeGet != volumeSet) {
1144 napi_create_int32(env, TEST_FAIL, &res);
1145 } else {
1146 napi_create_int32(env, TEST_PASS, &res);
1147 }
1148 OH_AudioRenderer_Release(audioRenderer);
1149 OH_AudioStreamBuilder_Destroy(builder);
1150 return res;
1151 }
1152
AudioRendererSetVolume_03(napi_env env,napi_callback_info info)1153 static napi_value AudioRendererSetVolume_03(napi_env env, napi_callback_info info)
1154 {
1155 OH_AudioStreamBuilder* builder = CreateRenderBuilder();
1156 OH_AudioRenderer* audioRenderer;
1157 napi_value res;
1158 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
1159 if (result != AUDIOSTREAM_SUCCESS) {
1160 napi_create_int32(env, TEST_FAIL, &res);
1161 return res;
1162 }
1163 float volumeSet = 0.3; // 0.3:value of volumeSet
1164 result = OH_AudioRenderer_SetVolume(audioRenderer, volumeSet);
1165 LOG("OH_AudioRenderer_SetVolume 0.3, result is %{public}d", result);
1166 if (result != AUDIOSTREAM_SUCCESS) {
1167 napi_create_int32(env, TEST_FAIL, &res);
1168 return res;
1169 }
1170 volumeSet = 0.8; // 0.8:value of volumeSet
1171 result = OH_AudioRenderer_SetVolume(audioRenderer, volumeSet);
1172 LOG("OH_AudioRenderer_SetVolume 0.8, result is %{public}d", result);
1173 if (result != AUDIOSTREAM_SUCCESS) {
1174 napi_create_int32(env, TEST_FAIL, &res);
1175 return res;
1176 }
1177 float volumeGet;
1178 result = OH_AudioRenderer_GetVolume(audioRenderer, &volumeGet);
1179 LOG("OH_AudioRenderer_GetVolume, volumeGet is %f, %{public}d", volumeGet, result);
1180 if (result != AUDIOSTREAM_SUCCESS || volumeGet != volumeSet) {
1181 napi_create_int32(env, TEST_FAIL, &res);
1182 } else {
1183 napi_create_int32(env, TEST_PASS, &res);
1184 }
1185 OH_AudioRenderer_Release(audioRenderer);
1186 OH_AudioStreamBuilder_Destroy(builder);
1187 return res;
1188 }
1189
AudioRendererSetVolume_04(napi_env env,napi_callback_info info)1190 static napi_value AudioRendererSetVolume_04(napi_env env, napi_callback_info info)
1191 {
1192 OH_AudioStreamBuilder* builder = CreateRenderBuilder();
1193 OH_AudioRenderer* audioRenderer;
1194 napi_value res;
1195 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
1196 if (result != AUDIOSTREAM_SUCCESS) {
1197 napi_create_int32(env, TEST_FAIL, &res);
1198 return res;
1199 }
1200 float volumeSet = -1.0;
1201 result = OH_AudioRenderer_SetVolume(audioRenderer, volumeSet);
1202 LOG("OH_AudioRenderer_SetVolume -1.0 result is %{public}d", result);
1203 if (result != AUDIOSTREAM_ERROR_INVALID_PARAM) {
1204 napi_create_int32(env, TEST_FAIL, &res);
1205 } else {
1206 napi_create_int32(env, TEST_PASS, &res);
1207 }
1208 OH_AudioRenderer_Release(audioRenderer);
1209 OH_AudioStreamBuilder_Destroy(builder);
1210 return res;
1211 }
1212
AudioRendererSetVolume_05(napi_env env,napi_callback_info info)1213 static napi_value AudioRendererSetVolume_05(napi_env env, napi_callback_info info)
1214 {
1215 OH_AudioStreamBuilder* builder = CreateRenderBuilder();
1216 OH_AudioRenderer* audioRenderer;
1217 napi_value res;
1218 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
1219 if (result != AUDIOSTREAM_SUCCESS) {
1220 napi_create_int32(env, TEST_FAIL, &res);
1221 return res;
1222 }
1223 float volumeSet = 1.5; // 1.5:value of volumeSet
1224 result = OH_AudioRenderer_SetVolume(audioRenderer, volumeSet);
1225 LOG("OH_AudioRenderer_SetVolume 1.5 result is %{public}d", result);
1226 if (result != AUDIOSTREAM_ERROR_INVALID_PARAM) {
1227 napi_create_int32(env, TEST_FAIL, &res);
1228 } else {
1229 napi_create_int32(env, TEST_PASS, &res);
1230 }
1231 OH_AudioRenderer_Release(audioRenderer);
1232 OH_AudioStreamBuilder_Destroy(builder);
1233 return res;
1234 }
1235
AudioRendererSetVolume_06(napi_env env,napi_callback_info info)1236 static napi_value AudioRendererSetVolume_06(napi_env env, napi_callback_info info)
1237 {
1238 OH_AudioRenderer* audioRenderer = nullptr;
1239 float volumeSet = 0.5; // 0.5:value of volumeSet
1240 napi_value res;
1241 OH_AudioStream_Result result = OH_AudioRenderer_SetVolume(audioRenderer, volumeSet);
1242 if (result != AUDIOSTREAM_ERROR_INVALID_PARAM) {
1243 napi_create_int32(env, TEST_FAIL, &res);
1244 } else {
1245 napi_create_int32(env, TEST_PASS, &res);
1246 }
1247 LOG("OH_AudioRenderer_GetVolume, volumeGet is %f, %{public}d", volumeSet, result);
1248 return res;
1249 }
1250
AudioRendererSetVolumeWithRamp_01(napi_env env,napi_callback_info info)1251 static napi_value AudioRendererSetVolumeWithRamp_01(napi_env env, napi_callback_info info)
1252 {
1253 OH_AudioStreamBuilder* builder = CreateRenderBuilder();
1254 OH_AudioRenderer* audioRenderer;
1255 napi_value res;
1256 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
1257 if (result != AUDIOSTREAM_SUCCESS) {
1258 napi_create_int32(env, TEST_FAIL, &res);
1259 return res;
1260 }
1261 float volumeSet = 0.0;
1262 result = OH_AudioRenderer_SetVolume(audioRenderer, volumeSet);
1263 LOG("OH_AudioRenderer_SetVolume 0.0 result is %{public}d", result);
1264 if (result != AUDIOSTREAM_SUCCESS) {
1265 napi_create_int32(env, TEST_FAIL, &res);
1266 return res;
1267 }
1268 int32_t durationMs = 1000; // 1000:value of durationMs
1269 volumeSet = 1.0;
1270 result = OH_AudioRenderer_SetVolumeWithRamp(audioRenderer, volumeSet, durationMs);
1271 LOG("OH_AudioRenderer_SetVolumeWithRamp 0.0->1.0 1000 result is %{public}d", result);
1272 if (result != AUDIOSTREAM_SUCCESS) {
1273 napi_create_int32(env, TEST_FAIL, &res);
1274 } else {
1275 napi_create_int32(env, TEST_PASS, &res);
1276 }
1277 OH_AudioRenderer_Release(audioRenderer);
1278 OH_AudioStreamBuilder_Destroy(builder);
1279 return res;
1280 }
1281
AudioRendererSetVolumeWithRamp_02(napi_env env,napi_callback_info info)1282 static napi_value AudioRendererSetVolumeWithRamp_02(napi_env env, napi_callback_info info)
1283 {
1284 OH_AudioStreamBuilder* builder = CreateRenderBuilder();
1285 OH_AudioRenderer* audioRenderer;
1286 napi_value res;
1287 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
1288 if (result != AUDIOSTREAM_SUCCESS) {
1289 napi_create_int32(env, TEST_FAIL, &res);
1290 return res;
1291 }
1292 float volumeSet = 1.0;
1293 result = OH_AudioRenderer_SetVolume(audioRenderer, volumeSet);
1294 LOG("OH_AudioRenderer_SetVolume 1.0 result is %{public}d", result);
1295 if (result != AUDIOSTREAM_SUCCESS) {
1296 napi_create_int32(env, TEST_FAIL, &res);
1297 return res;
1298 }
1299 int32_t durationMs = 100; // 100:value of durationMs
1300 volumeSet = 0.0;
1301 result = OH_AudioRenderer_SetVolumeWithRamp(audioRenderer, volumeSet, durationMs);
1302 LOG("OH_AudioRenderer_SetVolumeWithRamp 1.0->0.0 100 result is %{public}d", result);
1303 if (result != AUDIOSTREAM_SUCCESS) {
1304 napi_create_int32(env, TEST_FAIL, &res);
1305 } else {
1306 napi_create_int32(env, TEST_PASS, &res);
1307 }
1308 OH_AudioRenderer_Release(audioRenderer);
1309 OH_AudioStreamBuilder_Destroy(builder);
1310 return res;
1311 }
1312
AudioRendererSetVolumeWithRamp_03(napi_env env,napi_callback_info info)1313 static napi_value AudioRendererSetVolumeWithRamp_03(napi_env env, napi_callback_info info)
1314 {
1315 OH_AudioStreamBuilder* builder = CreateRenderBuilder();
1316 OH_AudioRenderer* audioRenderer;
1317 napi_value res;
1318 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
1319 if (result != AUDIOSTREAM_SUCCESS) {
1320 napi_create_int32(env, TEST_FAIL, &res);
1321 return res;
1322 }
1323 float volumeSet = 0.0;
1324 result = OH_AudioRenderer_SetVolume(audioRenderer, volumeSet);
1325 LOG("OH_AudioRenderer_SetVolume 0.0 result is %{public}d", result);
1326 if (result != AUDIOSTREAM_SUCCESS) {
1327 napi_create_int32(env, TEST_FAIL, &res);
1328 return res;
1329 }
1330 int32_t durationMs = 10; // 10:value of durationMs
1331 volumeSet = 0.5; // 0.5:value of volumeSet
1332 result = OH_AudioRenderer_SetVolumeWithRamp(audioRenderer, volumeSet, durationMs);
1333 LOG("OH_AudioRenderer_SetVolumeWithRamp 0.0->0.5 10 result is %{public}d", result);
1334 if (result != AUDIOSTREAM_SUCCESS) {
1335 napi_create_int32(env, TEST_FAIL, &res);
1336 } else {
1337 napi_create_int32(env, TEST_PASS, &res);
1338 }
1339 OH_AudioRenderer_Release(audioRenderer);
1340 OH_AudioStreamBuilder_Destroy(builder);
1341 return res;
1342 }
1343
AudioRendererSetVolumeWithRamp_04(napi_env env,napi_callback_info info)1344 static napi_value AudioRendererSetVolumeWithRamp_04(napi_env env, napi_callback_info info)
1345 {
1346 OH_AudioStreamBuilder* builder = CreateRenderBuilder();
1347 OH_AudioRenderer* audioRenderer;
1348 napi_value res;
1349 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
1350 if (result != AUDIOSTREAM_SUCCESS) {
1351 napi_create_int32(env, TEST_FAIL, &res);
1352 return res;
1353 }
1354 float volumeSet = 1.0;
1355 result = OH_AudioRenderer_SetVolume(audioRenderer, volumeSet);
1356 LOG("OH_AudioRenderer_SetVolume 1.0 result is %{public}d", result);
1357 if (result != AUDIOSTREAM_SUCCESS) {
1358 napi_create_int32(env, TEST_FAIL, &res);
1359 return res;
1360 }
1361 int32_t durationMs = 10; // 10:value of durationMs
1362 volumeSet = 0.5; // 0.5:value of volumeSet
1363 result = OH_AudioRenderer_SetVolumeWithRamp(audioRenderer, volumeSet, durationMs);
1364 LOG("OH_AudioRenderer_SetVolumeWithRamp 1.0->0.5 10 result is %{public}d", result);
1365 if (result != AUDIOSTREAM_SUCCESS) {
1366 napi_create_int32(env, TEST_FAIL, &res);
1367 } else {
1368 napi_create_int32(env, TEST_PASS, &res);
1369 }
1370 OH_AudioRenderer_Release(audioRenderer);
1371 OH_AudioStreamBuilder_Destroy(builder);
1372 return res;
1373 }
1374
AudioRendererSetVolumeWithRamp_05(napi_env env,napi_callback_info info)1375 static napi_value AudioRendererSetVolumeWithRamp_05(napi_env env, napi_callback_info info)
1376 {
1377 OH_AudioStreamBuilder* builder = CreateRenderBuilder();
1378 OH_AudioRenderer* audioRenderer;
1379 napi_value res;
1380 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
1381 if (result != AUDIOSTREAM_SUCCESS) {
1382 napi_create_int32(env, TEST_FAIL, &res);
1383 return res;
1384 }
1385 float volumeSet = 0.0;
1386 result = OH_AudioRenderer_SetVolume(audioRenderer, volumeSet);
1387 LOG("OH_AudioRenderer_SetVolume 0.0 result is %{public}d", result);
1388 if (result != AUDIOSTREAM_SUCCESS) {
1389 napi_create_int32(env, TEST_FAIL, &res);
1390 return res;
1391 }
1392 int32_t durationMs = 10; // 10:value of durationMs
1393 volumeSet = 0.0;
1394 result = OH_AudioRenderer_SetVolumeWithRamp(audioRenderer, volumeSet, durationMs);
1395 LOG("OH_AudioRenderer_SetVolumeWithRamp 0.0->0.0 10 result is %{public}d", result);
1396 if (result != AUDIOSTREAM_SUCCESS) {
1397 napi_create_int32(env, TEST_FAIL, &res);
1398 } else {
1399 napi_create_int32(env, TEST_PASS, &res);
1400 }
1401 OH_AudioRenderer_Release(audioRenderer);
1402 OH_AudioStreamBuilder_Destroy(builder);
1403 return res;
1404 }
1405
AudioRendererSetVolumeWithRamp_06(napi_env env,napi_callback_info info)1406 static napi_value AudioRendererSetVolumeWithRamp_06(napi_env env, napi_callback_info info)
1407 {
1408 OH_AudioStreamBuilder* builder = CreateRenderBuilder();
1409 OH_AudioRenderer* audioRenderer;
1410 napi_value res;
1411 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
1412 if (result != AUDIOSTREAM_SUCCESS) {
1413 napi_create_int32(env, TEST_FAIL, &res);
1414 return res;
1415 }
1416 float volumeSet = 1.0;
1417 result = OH_AudioRenderer_SetVolume(audioRenderer, volumeSet);
1418 LOG("OH_AudioRenderer_SetVolume 1.0 result is %{public}d", result);
1419 if (result != AUDIOSTREAM_SUCCESS) {
1420 napi_create_int32(env, TEST_FAIL, &res);
1421 return res;
1422 }
1423 int32_t durationMs = 10; // 10:value of durationMs
1424 volumeSet = 1.0;
1425 result = OH_AudioRenderer_SetVolumeWithRamp(audioRenderer, volumeSet, durationMs);
1426 LOG("OH_AudioRenderer_SetVolumeWithRamp 1.0->1.0 10 result is %{public}d", result);
1427 if (result != AUDIOSTREAM_SUCCESS) {
1428 napi_create_int32(env, TEST_FAIL, &res);
1429 } else {
1430 napi_create_int32(env, TEST_PASS, &res);
1431 }
1432 OH_AudioRenderer_Release(audioRenderer);
1433 OH_AudioStreamBuilder_Destroy(builder);
1434 return res;
1435 }
1436
AudioRendererSetVolumeWithRamp_07(napi_env env,napi_callback_info info)1437 static napi_value AudioRendererSetVolumeWithRamp_07(napi_env env, napi_callback_info info)
1438 {
1439 OH_AudioStreamBuilder* builder = CreateRenderBuilder();
1440 OH_AudioRenderer* audioRenderer;
1441 napi_value res;
1442 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
1443 if (result != AUDIOSTREAM_SUCCESS) {
1444 napi_create_int32(env, TEST_FAIL, &res);
1445 return res;
1446 }
1447 float volumeSet = 1.0;
1448 result = OH_AudioRenderer_SetVolume(audioRenderer, volumeSet);
1449 LOG("OH_AudioRenderer_SetVolume 1.0 result is %{public}d", result);
1450 if (result != AUDIOSTREAM_SUCCESS) {
1451 napi_create_int32(env, TEST_FAIL, &res);
1452 return res;
1453 }
1454 int32_t durationMs = 100; // 100:value of durationMs
1455 volumeSet = 1.2; // 1.2:value of volumeSet
1456 result = OH_AudioRenderer_SetVolumeWithRamp(audioRenderer, volumeSet, durationMs);
1457 LOG("OH_AudioRenderer_SetVolumeWithRamp 1.0->1.2 100 result is %{public}d", result);
1458 if (result != AUDIOSTREAM_ERROR_INVALID_PARAM) {
1459 napi_create_int32(env, TEST_FAIL, &res);
1460 } else {
1461 napi_create_int32(env, TEST_PASS, &res);
1462 }
1463 OH_AudioRenderer_Release(audioRenderer);
1464 OH_AudioStreamBuilder_Destroy(builder);
1465 return res;
1466 }
1467
AudioRendererSetVolumeWithRamp_08(napi_env env,napi_callback_info info)1468 static napi_value AudioRendererSetVolumeWithRamp_08(napi_env env, napi_callback_info info)
1469 {
1470 OH_AudioStreamBuilder* builder = CreateRenderBuilder();
1471 OH_AudioRenderer* audioRenderer;
1472 napi_value res;
1473 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
1474 if (result != AUDIOSTREAM_SUCCESS) {
1475 napi_create_int32(env, TEST_FAIL, &res);
1476 return res;
1477 }
1478 float volumeSet = 0.0;
1479 result = OH_AudioRenderer_SetVolume(audioRenderer, volumeSet);
1480 LOG("OH_AudioRenderer_SetVolume 0.0 result is %{public}d", result);
1481 if (result != AUDIOSTREAM_SUCCESS) {
1482 napi_create_int32(env, TEST_FAIL, &res);
1483 return res;
1484 }
1485 int32_t durationMs = 100; // 100:value of durationMs
1486 volumeSet = -0.2; // -0.2:invalid value of volumeSet
1487 result = OH_AudioRenderer_SetVolumeWithRamp(audioRenderer, volumeSet, durationMs);
1488 LOG("OH_AudioRenderer_SetVolumeWithRamp 0.0->-0.2 100 result is %{public}d", result);
1489 if (result != AUDIOSTREAM_ERROR_INVALID_PARAM) {
1490 napi_create_int32(env, TEST_FAIL, &res);
1491 } else {
1492 napi_create_int32(env, TEST_PASS, &res);
1493 }
1494 OH_AudioRenderer_Release(audioRenderer);
1495 OH_AudioStreamBuilder_Destroy(builder);
1496 return res;
1497 }
1498
AudioRendererSetVolumeWithRamp_09(napi_env env,napi_callback_info info)1499 static napi_value AudioRendererSetVolumeWithRamp_09(napi_env env, napi_callback_info info)
1500 {
1501 OH_AudioRenderer* audioRenderer = nullptr;
1502 float volumeSet = 0.5; // 0.5:value of volumeSet
1503 int32_t durationMs = 10; // 10:value of durationMs
1504 OH_AudioStream_Result result = OH_AudioRenderer_SetVolumeWithRamp(audioRenderer, volumeSet, durationMs);
1505 napi_value res;
1506 if (result != AUDIOSTREAM_ERROR_INVALID_PARAM) {
1507 napi_create_int32(env, TEST_FAIL, &res);
1508 } else {
1509 napi_create_int32(env, TEST_PASS, &res);
1510 }
1511 return res;
1512 }
1513
AudioRendererOnMarkReachedCb(OH_AudioRenderer * renderer,uint32_t samplePos,void * userData)1514 static void AudioRendererOnMarkReachedCb(OH_AudioRenderer* renderer, uint32_t samplePos, void* userData)
1515 {
1516 g_flag = true;
1517 LOG("AudioRendererOnMarkReachedCb samplePos: %{public}d \n", samplePos);
1518 }
1519
AudioRendererSetOnMarkReached_01(napi_env env,napi_callback_info info)1520 static napi_value AudioRendererSetOnMarkReached_01(napi_env env, napi_callback_info info)
1521 {
1522 OH_AudioStreamBuilder *builder = CreateRenderBuilder();
1523 OH_AudioRenderer *audioRenderer;
1524 napi_value res;
1525 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
1526 if (result != AUDIOSTREAM_SUCCESS) {
1527 napi_create_int32(env, TEST_FAIL, &res);
1528 return res;
1529 }
1530 uint32_t samplePos = 1;
1531 OH_AudioRenderer_OnMarkReachedCallback callback = AudioRendererOnMarkReachedCb;
1532 result = OH_AudioRenderer_SetMarkPosition(audioRenderer, samplePos, callback, nullptr);
1533 LOG("OH_Audio_Renderer_SetOnMarkReached_01 result is: %{public}d", result);
1534 if (result != AUDIOSTREAM_SUCCESS) {
1535 napi_create_int32(env, TEST_FAIL, &res);
1536 } else {
1537 napi_create_int32(env, TEST_PASS, &res);
1538 }
1539 OH_AudioRenderer_Release(audioRenderer);
1540 OH_AudioStreamBuilder_Destroy(builder);
1541 return res;
1542 }
1543
AudioRendererSetOnMarkReached_02(napi_env env,napi_callback_info info)1544 static napi_value AudioRendererSetOnMarkReached_02(napi_env env, napi_callback_info info)
1545 {
1546 OH_AudioStreamBuilder *builder = CreateRenderBuilder();
1547 OH_AudioRenderer *audioRenderer;
1548 napi_value res;
1549 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
1550 if (result != AUDIOSTREAM_SUCCESS) {
1551 napi_create_int32(env, TEST_FAIL, &res);
1552 return res;
1553 }
1554 uint32_t samplePos = 0;
1555 OH_AudioRenderer_OnMarkReachedCallback callback = AudioRendererOnMarkReachedCb;
1556 result = OH_AudioRenderer_SetMarkPosition(audioRenderer, samplePos, callback, nullptr);
1557 LOG("OH_Audio_Renderer_SetOnMarkReached_02 result is: %{public}d", result);
1558 if (result != AUDIOSTREAM_ERROR_INVALID_PARAM) {
1559 napi_create_int32(env, TEST_FAIL, &res);
1560 } else {
1561 napi_create_int32(env, TEST_PASS, &res);
1562 }
1563 OH_AudioRenderer_Release(audioRenderer);
1564 OH_AudioStreamBuilder_Destroy(builder);
1565 return res;
1566 }
1567
AudioRendererSetOnMarkReached_03(napi_env env,napi_callback_info info)1568 static napi_value AudioRendererSetOnMarkReached_03(napi_env env, napi_callback_info info)
1569 {
1570 g_flag = false;
1571 OH_AudioStreamBuilder *builder = CreateRenderBuilder();
1572 napi_value res;
1573 OH_AudioStreamBuilder_SetSamplingRate(builder, g_samplingRate);
1574 OH_AudioStreamBuilder_SetChannelCount(builder, g_channelCount);
1575 OH_AudioStreamBuilder_SetLatencyMode(builder, (OH_AudioStream_LatencyMode)g_latencyMode);
1576 OH_AudioStreamBuilder_SetSampleFormat(builder, (OH_AudioStream_SampleFormat)g_sampleFormat);
1577 OH_AudioRenderer_Callbacks callbacks;
1578 callbacks.OH_AudioRenderer_OnWriteData = AudioRendererOnWriteData;
1579 OH_AudioStream_Result result = OH_AudioStreamBuilder_SetRendererCallback(builder, callbacks, nullptr);
1580 if (result != AUDIOSTREAM_SUCCESS) {
1581 napi_create_int32(env, TEST_FAIL, &res);
1582 return res;
1583 }
1584 // set buffer size to g_frameSize
1585 OH_AudioStreamBuilder_SetFrameSizeInCallback(builder, g_frameSize);
1586
1587 OH_AudioRenderer *audioRenderer;
1588 OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
1589 uint32_t samplePos = 1;
1590 OH_AudioRenderer_OnMarkReachedCallback callback = AudioRendererOnMarkReachedCb;
1591 result = OH_AudioRenderer_SetMarkPosition(audioRenderer, samplePos, callback, nullptr);
1592 LOG("OH_Audio_Renderer_SetOnMarkReached_03 result is: %{public}d", result);
1593 if (result != AUDIOSTREAM_SUCCESS) {
1594 napi_create_int32(env, TEST_FAIL, &res);
1595 return res;
1596 }
1597 const int waitTime = 2;
1598 OH_AudioRenderer_Start(audioRenderer);
1599 sleep(waitTime); // 2:sleep 2 seconds
1600 OH_AudioRenderer_Stop(audioRenderer);
1601 if (!g_flag) {
1602 napi_create_int32(env, TEST_FAIL, &res);
1603 } else {
1604 napi_create_int32(env, TEST_PASS, &res);
1605 }
1606 OH_AudioRenderer_Release(audioRenderer);
1607 OH_AudioStreamBuilder_Destroy(builder);
1608 return res;
1609 }
1610
AudioRendererSetOnMarkReached_04(napi_env env,napi_callback_info info)1611 static napi_value AudioRendererSetOnMarkReached_04(napi_env env, napi_callback_info info)
1612 {
1613 OH_AudioRenderer* audioRenderer = nullptr;
1614 uint32_t samplePos = 1;
1615 OH_AudioRenderer_OnMarkReachedCallback callback = AudioRendererOnMarkReachedCb;
1616 OH_AudioStream_Result result = OH_AudioRenderer_SetMarkPosition(audioRenderer, samplePos, callback, nullptr);
1617 napi_value res;
1618 if (result != AUDIOSTREAM_ERROR_INVALID_PARAM) {
1619 napi_create_int32(env, TEST_FAIL, &res);
1620 } else {
1621 napi_create_int32(env, TEST_PASS, &res);
1622 }
1623 return res;
1624 }
1625
AudioRendererSetOnMarkReached_05(napi_env env,napi_callback_info info)1626 static napi_value AudioRendererSetOnMarkReached_05(napi_env env, napi_callback_info info)
1627 {
1628 OH_AudioStreamBuilder *builder = CreateRenderBuilder();
1629 OH_AudioRenderer *audioRenderer;
1630 napi_value res;
1631 OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
1632 uint32_t samplePos = 4294967295; // 4294967295:uint32_t 2^32 - 1
1633 OH_AudioRenderer_OnMarkReachedCallback callback = AudioRendererOnMarkReachedCb;
1634 OH_AudioStream_Result result = OH_AudioRenderer_SetMarkPosition(audioRenderer, samplePos, callback, nullptr);
1635 LOG("OH_Audio_Renderer_SetOnMarkReached_05 result is: %{public}d", result);
1636 if (result != AUDIOSTREAM_SUCCESS) {
1637 napi_create_int32(env, TEST_FAIL, &res);
1638 } else {
1639 napi_create_int32(env, TEST_PASS, &res);
1640 }
1641 OH_AudioRenderer_Release(audioRenderer);
1642 OH_AudioStreamBuilder_Destroy(builder);
1643 return res;
1644 }
1645
AudioRendererSetOnMarkReached_06(napi_env env,napi_callback_info info)1646 static napi_value AudioRendererSetOnMarkReached_06(napi_env env, napi_callback_info info)
1647 {
1648 g_flag = false;
1649 g_file = fopen(g_filePath.c_str(), "rb");
1650 if (g_file == nullptr) {
1651 LOG("fopen fail. g_file: %p\n", g_file);
1652 }
1653 OH_AudioStreamBuilder *builder = CreateRenderBuilder();
1654 napi_value res;
1655 OH_AudioStreamBuilder_SetSamplingRate(builder, g_samplingRate);
1656 OH_AudioStreamBuilder_SetChannelCount(builder, g_channelCount);
1657 OH_AudioStreamBuilder_SetLatencyMode(builder, (OH_AudioStream_LatencyMode)g_latencyMode);
1658 OH_AudioStreamBuilder_SetSampleFormat(builder, (OH_AudioStream_SampleFormat)g_sampleFormat);
1659 OH_AudioRenderer_Callbacks callbacks;
1660 callbacks.OH_AudioRenderer_OnWriteData = AudioRendererOnMarkReachedWriteData;
1661 OH_AudioStream_Result result = OH_AudioStreamBuilder_SetRendererCallback(builder, callbacks, nullptr);
1662 if (result != AUDIOSTREAM_SUCCESS) {
1663 napi_create_int32(env, TEST_FAIL, &res);
1664 return res;
1665 }
1666 // set buffer size to g_frameSize
1667 OH_AudioStreamBuilder_SetFrameSizeInCallback(builder, g_frameSize);
1668
1669 OH_AudioRenderer *audioRenderer;
1670 OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
1671 uint32_t samplePos = 10538568; // 10538568:Test_44100_2.wav The total number of frames in the audio file
1672 OH_AudioRenderer_OnMarkReachedCallback callback = AudioRendererOnMarkReachedCb;
1673 result = OH_AudioRenderer_SetMarkPosition(audioRenderer, samplePos, callback, nullptr);
1674 LOG("OH_Audio_Renderer_SetOnMarkReached_06 result is: %{public}d", result);
1675 if (result != AUDIOSTREAM_SUCCESS) {
1676 napi_create_int32(env, TEST_FAIL, &res);
1677 return res;
1678 }
1679 const int waitTime = 220;
1680 OH_AudioRenderer_Start(audioRenderer);
1681 Delay(waitTime); // 220:Play the entire music
1682 OH_AudioRenderer_Stop(audioRenderer);
1683 if (!g_flag) {
1684 napi_create_int32(env, TEST_FAIL, &res);
1685 } else {
1686 napi_create_int32(env, TEST_PASS, &res);
1687 }
1688 OH_AudioRenderer_Release(audioRenderer);
1689 OH_AudioStreamBuilder_Destroy(builder);
1690 return res;
1691 }
1692
AudioRendererSetOnMarkReached_07(napi_env env,napi_callback_info info)1693 static napi_value AudioRendererSetOnMarkReached_07(napi_env env, napi_callback_info info)
1694 {
1695 g_flag = false;
1696 g_file = fopen(g_filePath.c_str(), "rb");
1697 if (g_file == nullptr) {
1698 LOG("fopen fail. g_file: %p\n", g_file);
1699 }
1700 OH_AudioStreamBuilder *builder = CreateRenderBuilder();
1701 napi_value res;
1702 OH_AudioStreamBuilder_SetSamplingRate(builder, g_samplingRate);
1703 OH_AudioStreamBuilder_SetChannelCount(builder, g_channelCount);
1704 OH_AudioStreamBuilder_SetLatencyMode(builder, (OH_AudioStream_LatencyMode)g_latencyMode);
1705 OH_AudioStreamBuilder_SetSampleFormat(builder, (OH_AudioStream_SampleFormat)g_sampleFormat);
1706 OH_AudioRenderer_Callbacks callbacks;
1707 callbacks.OH_AudioRenderer_OnWriteData = AudioRendererOnMarkReachedWriteData;
1708 OH_AudioStream_Result result = OH_AudioStreamBuilder_SetRendererCallback(builder, callbacks, nullptr);
1709 if (result != AUDIOSTREAM_SUCCESS) {
1710 napi_create_int32(env, TEST_FAIL, &res);
1711 return res;
1712 }
1713 // set buffer size to g_frameSize
1714 OH_AudioStreamBuilder_SetFrameSizeInCallback(builder, g_frameSize);
1715
1716 OH_AudioRenderer *audioRenderer;
1717 OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
1718 uint32_t samplePos = 10538570; // 10538570:Test_44100_2.wav The total number of frames in the audio file + 2
1719 OH_AudioRenderer_OnMarkReachedCallback callback = AudioRendererOnMarkReachedCb;
1720 result = OH_AudioRenderer_SetMarkPosition(audioRenderer, samplePos, callback, nullptr);
1721 LOG("OH_Audio_Renderer_SetOnMarkReached_07 result is: %{public}d", result);
1722 if (result != AUDIOSTREAM_SUCCESS) {
1723 napi_create_int32(env, TEST_FAIL, &res);
1724 return res;
1725 }
1726 const int waitTime = 10;
1727 OH_AudioRenderer_Start(audioRenderer);
1728 Delay(waitTime); // 10:Play for 10 seconds
1729 OH_AudioRenderer_Stop(audioRenderer);
1730 if (!g_flag) {
1731 napi_create_int32(env, TEST_PASS, &res);
1732 } else {
1733 napi_create_int32(env, TEST_FAIL, &res);
1734 }
1735 OH_AudioRenderer_Release(audioRenderer);
1736 OH_AudioStreamBuilder_Destroy(builder);
1737 return res;
1738 }
1739
AudioRendererSetOnMarkReached_08(napi_env env,napi_callback_info info)1740 static napi_value AudioRendererSetOnMarkReached_08(napi_env env, napi_callback_info info)
1741 {
1742 g_flag = false;
1743 OH_AudioStreamBuilder *builder = CreateRenderBuilder();
1744 napi_value res;
1745 OH_AudioStreamBuilder_SetSamplingRate(builder, g_samplingRate);
1746 OH_AudioStreamBuilder_SetChannelCount(builder, g_channelCount);
1747 OH_AudioStreamBuilder_SetLatencyMode(builder, (OH_AudioStream_LatencyMode)g_latencyMode);
1748 OH_AudioStreamBuilder_SetSampleFormat(builder, (OH_AudioStream_SampleFormat)g_sampleFormat);
1749 OH_AudioRenderer_Callbacks callbacks;
1750 callbacks.OH_AudioRenderer_OnWriteData = AudioRendererOnWriteData;
1751 OH_AudioStream_Result result = OH_AudioStreamBuilder_SetRendererCallback(builder, callbacks, nullptr);
1752 if (result != AUDIOSTREAM_SUCCESS) {
1753 napi_create_int32(env, TEST_FAIL, &res);
1754 return res;
1755 }
1756 // set buffer size to g_frameSize
1757 OH_AudioStreamBuilder_SetFrameSizeInCallback(builder, g_frameSize);
1758
1759 OH_AudioRenderer *audioRenderer;
1760 OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
1761 uint32_t samplePos = 1;
1762 OH_AudioRenderer_OnMarkReachedCallback callback = AudioRendererOnMarkReachedCb;
1763 result = OH_AudioRenderer_SetMarkPosition(audioRenderer, samplePos, callback, nullptr);
1764 if (result != AUDIOSTREAM_SUCCESS) {
1765 napi_create_int32(env, TEST_FAIL, &res);
1766 return res;
1767 }
1768 result = OH_AudioRenderer_SetMarkPosition(audioRenderer, samplePos, callback, nullptr);
1769 if (result != AUDIOSTREAM_SUCCESS) {
1770 napi_create_int32(env, TEST_FAIL, &res);
1771 return res;
1772 }
1773 result = OH_AudioRenderer_SetMarkPosition(audioRenderer, samplePos, callback, nullptr);
1774 LOG("OH_Audio_Renderer_SetOnMarkReached_08 result is: %{public}d", result);
1775 if (result != AUDIOSTREAM_SUCCESS) {
1776 napi_create_int32(env, TEST_FAIL, &res);
1777 return res;
1778 }
1779 LOG("audioRendererSetOnMarkReached_08 result = AUDIOSTREAM_SUCCESS");
1780 int waitTime = 10;
1781 OH_AudioRenderer_Start(audioRenderer);
1782 LOG("audioRendererSetOnMarkReached_08 OH_AudioRenderer_Start SUCCESS");
1783 Delay(waitTime);
1784 OH_AudioRenderer_Stop(audioRenderer);
1785 LOG("audioRendererSetOnMarkReached_08 OH_AudioRenderer_Stop SUCCESS");
1786 if (!g_flag) {
1787 napi_create_int32(env, TEST_FAIL, &res);
1788 } else {
1789 napi_create_int32(env, TEST_PASS, &res);
1790 }
1791 OH_AudioRenderer_Release(audioRenderer);
1792 LOG("audioRendererSetOnMarkReached_08 OH_AudioRenderer_Release SUCCESS");
1793 OH_AudioStreamBuilder_Destroy(builder);
1794 LOG("audioRendererSetOnMarkReached_08 OH_AudioStreamBuilder_Destroy SUCCESS");
1795 return res;
1796 }
1797
AudioRendererCancelMark_01(napi_env env,napi_callback_info info)1798 static napi_value AudioRendererCancelMark_01(napi_env env, napi_callback_info info)
1799 {
1800 g_flag = false;
1801 OH_AudioStreamBuilder *builder = CreateRenderBuilder();
1802 napi_value res;
1803 OH_AudioStreamBuilder_SetSamplingRate(builder, g_samplingRate);
1804 OH_AudioStreamBuilder_SetChannelCount(builder, g_channelCount);
1805 OH_AudioStreamBuilder_SetLatencyMode(builder, (OH_AudioStream_LatencyMode)g_latencyMode);
1806 OH_AudioStreamBuilder_SetSampleFormat(builder, (OH_AudioStream_SampleFormat)g_sampleFormat);
1807 OH_AudioRenderer_Callbacks callbacks;
1808 callbacks.OH_AudioRenderer_OnWriteData = AudioRendererOnWriteData;
1809 OH_AudioStream_Result result = OH_AudioStreamBuilder_SetRendererCallback(builder, callbacks, nullptr);
1810 if (result != AUDIOSTREAM_SUCCESS) {
1811 napi_create_int32(env, TEST_FAIL, &res);
1812 return res;
1813 }
1814 // set buffer size to g_frameSize
1815 result = OH_AudioStreamBuilder_SetFrameSizeInCallback(builder, g_frameSize);
1816 if (result != AUDIOSTREAM_SUCCESS) {
1817 napi_create_int32(env, TEST_FAIL, &res);
1818 return res;
1819 }
1820
1821 OH_AudioRenderer *audioRenderer;
1822 OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
1823 uint32_t samplePos = 1;
1824 OH_AudioRenderer_OnMarkReachedCallback callback = AudioRendererOnMarkReachedCb;
1825 result = OH_AudioRenderer_SetMarkPosition(audioRenderer, samplePos, callback, nullptr);
1826 LOG("OH_Audio_Renderer_SetOnMarkReached_03 result is: %{public}d", result);
1827 if (result != AUDIOSTREAM_SUCCESS) {
1828 napi_create_int32(env, TEST_FAIL, &res);
1829 return res;
1830 }
1831 result = OH_AudioRenderer_Start(audioRenderer);
1832 if (result != AUDIOSTREAM_SUCCESS) {
1833 napi_create_int32(env, TEST_FAIL, &res);
1834 return res;
1835 }
1836 const int waitTime = 2;
1837 sleep(waitTime); // 2:sleep 2 seconds
1838 // CancelMark
1839 result = OH_AudioRenderer_CancelMark(audioRenderer);
1840 LOG("OH_AudioRenderer_CancelMark result is %{public}d", result);
1841 if (result != AUDIOSTREAM_SUCCESS) {
1842 napi_create_int32(env, TEST_FAIL, &res);
1843 return res;
1844 }
1845 OH_AudioRenderer_Stop(audioRenderer);
1846 if (!g_flag) {
1847 napi_create_int32(env, TEST_FAIL, &res);
1848 } else {
1849 napi_create_int32(env, TEST_PASS, &res);
1850 }
1851 OH_AudioRenderer_Release(audioRenderer);
1852 OH_AudioStreamBuilder_Destroy(builder);
1853 return res;
1854 }
1855
AudioRendererCancelMark_02(napi_env env,napi_callback_info info)1856 static napi_value AudioRendererCancelMark_02(napi_env env, napi_callback_info info)
1857 {
1858 OH_AudioStreamBuilder* builder = CreateRenderBuilder();
1859 OH_AudioRenderer* audioRenderer;
1860 napi_value res;
1861 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
1862 if (result != AUDIOSTREAM_SUCCESS) {
1863 napi_create_int32(env, TEST_FAIL, &res);
1864 return res;
1865 }
1866 result = OH_AudioRenderer_CancelMark(audioRenderer);
1867 LOG("OH_AudioRenderer_CancelMark result is %{public}d", result);
1868 OH_AudioRenderer_Release(audioRenderer);
1869 OH_AudioStreamBuilder_Destroy(builder);
1870 if (result != AUDIOSTREAM_SUCCESS) {
1871 napi_create_int32(env, TEST_FAIL, &res);
1872 } else {
1873 napi_create_int32(env, TEST_PASS, &res);
1874 }
1875 return res;
1876 }
1877
AudioRendererCancelMark_03(napi_env env,napi_callback_info info)1878 static napi_value AudioRendererCancelMark_03(napi_env env, napi_callback_info info)
1879 {
1880 OH_AudioRenderer* audioRenderer = nullptr;
1881 OH_AudioStream_Result result = OH_AudioRenderer_CancelMark(audioRenderer);
1882 napi_value res;
1883 LOG("OH_AudioRenderer_CancelMark result is %{public}d", result);
1884 if (result != AUDIOSTREAM_ERROR_INVALID_PARAM) {
1885 napi_create_int32(env, TEST_FAIL, &res);
1886 } else {
1887 napi_create_int32(env, TEST_PASS, &res);
1888 }
1889 return res;
1890 }
1891
AudioRendererInterruptEvent(OH_AudioRenderer * renderer,void * userData,OH_AudioInterrupt_ForceType type,OH_AudioInterrupt_Hint hint)1892 static int32_t AudioRendererInterruptEvent(OH_AudioRenderer* renderer,
1893 void* userData,
1894 OH_AudioInterrupt_ForceType type,
1895 OH_AudioInterrupt_Hint hint)
1896 {
1897 g_mark = true;
1898 LOG("AudioRendererInterruptEvent type = %{public}d, hint = %{public}d\n", type, hint);
1899 return 0;
1900 }
1901
AudioRendererSetInterruptMode_01(napi_env env,napi_callback_info info)1902 static napi_value AudioRendererSetInterruptMode_01(napi_env env, napi_callback_info info)
1903 {
1904 g_mark = false;
1905 napi_value res;
1906 // 1. create builder
1907 OH_AudioStreamBuilder* builder1;
1908 OH_AudioStream_Type type = AUDIOSTREAM_TYPE_RENDERER;
1909 OH_AudioStream_Usage usage = AUDIOSTREAM_USAGE_MUSIC;
1910 OH_AudioStreamBuilder_Create(&builder1, type);
1911
1912 OH_AudioStreamBuilder* builder2;
1913 OH_AudioStreamBuilder_Create(&builder2, type);
1914
1915 // 2. set builder1 builder2 params
1916 OH_AudioStreamBuilder_SetRendererInfo(builder1, usage);
1917 OH_AudioRenderer_Callbacks callbacks;
1918 callbacks.OH_AudioRenderer_OnWriteData = AudioRendererOnWriteData;
1919 callbacks.OH_AudioRenderer_OnInterruptEvent = AudioRendererInterruptEvent;
1920 OH_AudioStreamBuilder_SetRendererCallback(builder1, callbacks, nullptr);
1921 OH_AudioStreamBuilder_SetFrameSizeInCallback(builder1, g_frameSize);
1922
1923 usage = AUDIOSTREAM_USAGE_MOVIE;
1924 OH_AudioStreamBuilder_SetRendererInfo(builder2, usage);
1925 OH_AudioStreamBuilder_SetRendererCallback(builder2, callbacks, nullptr);
1926 OH_AudioStreamBuilder_SetFrameSizeInCallback(builder2, g_frameSize);
1927
1928 OH_AudioInterrupt_Mode mode = AUDIOSTREAM_INTERRUPT_MODE_SHARE;
1929 OH_AudioStream_Result result = OH_AudioStreamBuilder_SetRendererInterruptMode(builder1, mode);
1930 LOG("OH_AudioStreamBuilder_SetRendererInterruptMode builder1 result is %{public}d", result);
1931 if (result != AUDIOSTREAM_SUCCESS) {
1932 napi_create_int32(env, TEST_FAIL, &res);
1933 return res;
1934 }
1935 result = OH_AudioStreamBuilder_SetRendererInterruptMode(builder2, mode);
1936 LOG("OH_AudioStreamBuilder_SetRendererInterruptMode builder2 result is %{public}d", result);
1937 if (result != AUDIOSTREAM_SUCCESS) {
1938 napi_create_int32(env, TEST_FAIL, &res);
1939 return res;
1940 }
1941
1942 // 3. create audioRenderer1 audioRenderer2
1943 OH_AudioRenderer* audioRenderer1;
1944 result = OH_AudioStreamBuilder_GenerateRenderer(builder1, &audioRenderer1);
1945 if (result != AUDIOSTREAM_SUCCESS) {
1946 napi_create_int32(env, TEST_FAIL, &res);
1947 return res;
1948 }
1949
1950 OH_AudioRenderer* audioRenderer2;
1951 result = OH_AudioStreamBuilder_GenerateRenderer(builder2, &audioRenderer2);
1952 if (result != AUDIOSTREAM_SUCCESS) {
1953 napi_create_int32(env, TEST_FAIL, &res);
1954 return res;
1955 }
1956
1957 // 4. start
1958 result = OH_AudioRenderer_Start(audioRenderer1);
1959 if (result != AUDIOSTREAM_SUCCESS) {
1960 napi_create_int32(env, TEST_FAIL, &res);
1961 return res;
1962 }
1963 const int waitTime = 1;
1964 Delay(waitTime);
1965 result = OH_AudioRenderer_Start(audioRenderer2);
1966 if (result != AUDIOSTREAM_SUCCESS) {
1967 napi_create_int32(env, TEST_FAIL, &res);
1968 } else {
1969 napi_create_int32(env, TEST_PASS, &res);
1970 }
1971
1972 // 5. stop and release client
1973 OH_AudioRenderer_Stop(audioRenderer2);
1974 OH_AudioRenderer_Release(audioRenderer2);
1975 OH_AudioRenderer_Stop(audioRenderer1);
1976 OH_AudioRenderer_Release(audioRenderer1);
1977 OH_AudioStreamBuilder_Destroy(builder2);
1978 OH_AudioStreamBuilder_Destroy(builder1);
1979 return res;
1980 }
1981
AudioRendererSetInterruptMode_02(napi_env env,napi_callback_info info)1982 static napi_value AudioRendererSetInterruptMode_02(napi_env env, napi_callback_info info)
1983 {
1984 g_mark = false;
1985 napi_value res;
1986 // 1. create builder
1987 OH_AudioStreamBuilder* builder;
1988 OH_AudioStream_Type type = AUDIOSTREAM_TYPE_RENDERER;
1989 OH_AudioStream_Usage usage = AUDIOSTREAM_USAGE_MUSIC;
1990 OH_AudioStreamBuilder_Create(&builder, type);
1991
1992 OH_AudioStreamBuilder* builder2;
1993 OH_AudioStreamBuilder_Create(&builder2, type);
1994
1995 // 2. set builder params
1996 OH_AudioStreamBuilder_SetRendererInfo(builder, usage);
1997 OH_AudioRenderer_Callbacks callbacks;
1998 callbacks.OH_AudioRenderer_OnWriteData = AudioRendererOnWriteData;
1999 callbacks.OH_AudioRenderer_OnInterruptEvent = AudioRendererInterruptEvent;
2000 OH_AudioStreamBuilder_SetRendererCallback(builder, callbacks, nullptr);
2001 OH_AudioStreamBuilder_SetFrameSizeInCallback(builder, g_frameSize);
2002
2003 usage = AUDIOSTREAM_USAGE_VOICE_MESSAGE;
2004 OH_AudioStreamBuilder_SetRendererInfo(builder2, usage);
2005 OH_AudioStreamBuilder_SetRendererCallback(builder2, callbacks, nullptr);
2006 OH_AudioStreamBuilder_SetFrameSizeInCallback(builder2, g_frameSize);
2007
2008 OH_AudioInterrupt_Mode mode = AUDIOSTREAM_INTERRUPT_MODE_INDEPENDENT;
2009 OH_AudioStream_Result result = OH_AudioStreamBuilder_SetRendererInterruptMode(builder, mode);
2010 LOG("OH_AudioStreamBuilder_SetRendererInterruptMode builder1 result is %{public}d", result);
2011 if (result != AUDIOSTREAM_SUCCESS) {
2012 napi_create_int32(env, TEST_FAIL, &res);
2013 return res;
2014 }
2015 result = OH_AudioStreamBuilder_SetRendererInterruptMode(builder2, mode);
2016 LOG("OH_AudioStreamBuilder_SetRendererInterruptMode builder2 result is %{public}d", result);
2017 if (result != AUDIOSTREAM_SUCCESS) {
2018 napi_create_int32(env, TEST_FAIL, &res);
2019 return res;
2020 }
2021 LOG("AudioRendererSetInterruptMode_02 result == AUDIOSTREAM_SUCCESS");
2022 // 3. create audioRenderer1 audioRenderer2
2023 OH_AudioRenderer* audioRenderer1;
2024 result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer1);
2025 if (result != AUDIOSTREAM_SUCCESS) {
2026 napi_create_int32(env, TEST_FAIL, &res);
2027 return res;
2028 }
2029 LOG("AudioRendererSetInterruptMode_02 after audioRenderer1 OH_AudioStreamBuilder_GenerateRenderer");
2030 OH_AudioRenderer* audioRenderer2;
2031 result = OH_AudioStreamBuilder_GenerateRenderer(builder2, &audioRenderer2);
2032 if (result != AUDIOSTREAM_SUCCESS) {
2033 napi_create_int32(env, TEST_FAIL, &res);
2034 return res;
2035 }
2036 LOG("AudioRendererSetInterruptMode_02 after audioRenderer2 OH_AudioStreamBuilder_GenerateRenderer");
2037 // 4. start
2038 result = OH_AudioRenderer_Start(audioRenderer1);
2039 if (result != AUDIOSTREAM_SUCCESS) {
2040 napi_create_int32(env, TEST_FAIL, &res);
2041 return res;
2042 }
2043 LOG("AudioRendererSetInterruptMode_02 after audioRenderer1 OH_AudioRenderer_Start");
2044 const int waitTime = 1;
2045 sleep(waitTime);
2046 result = OH_AudioRenderer_Start(audioRenderer2);
2047 if (result != AUDIOSTREAM_SUCCESS) {
2048 napi_create_int32(env, TEST_FAIL, &res);
2049 return res;
2050 }
2051 LOG("AudioRendererSetInterruptMode_02 after audioRenderer2 OH_AudioRenderer_Start");
2052 sleep(waitTime); // 2:sleep 2 seconds
2053
2054 if (!g_mark) {
2055 napi_create_int32(env, TEST_FAIL, &res);
2056 } else {
2057 napi_create_int32(env, TEST_PASS, &res);
2058 }
2059 if (g_mark) {
2060 LOG("AudioRendererSetInterruptMode_02 g_mark is : %{public}d", 1);
2061 } else {
2062 LOG("AudioRendererSetInterruptMode_02 g_mark is : %{public}d", 0);
2063 }
2064 // 5. stop and release client
2065 OH_AudioRenderer_Stop(audioRenderer2);
2066 OH_AudioRenderer_Release(audioRenderer2);
2067 OH_AudioRenderer_Stop(audioRenderer1);
2068 OH_AudioRenderer_Release(audioRenderer1);
2069 OH_AudioStreamBuilder_Destroy(builder);
2070 OH_AudioStreamBuilder_Destroy(builder2);
2071 LOG("AudioRendererSetInterruptMode_02 res is: %{public}d", res);
2072 return res;
2073 }
2074
AudioRendererSetInterruptMode_03(napi_env env,napi_callback_info info)2075 static napi_value AudioRendererSetInterruptMode_03(napi_env env, napi_callback_info info)
2076 {
2077 napi_value res;
2078 OH_AudioStreamBuilder* builder = nullptr;
2079 OH_AudioInterrupt_Mode mode = AUDIOSTREAM_INTERRUPT_MODE_SHARE;
2080 OH_AudioStream_Result result = OH_AudioStreamBuilder_SetRendererInterruptMode(builder, mode);
2081 LOG("OH_AudioRenderer_SetInterruptMode_03, result is: %{public}d", result);
2082 OH_AudioStreamBuilder_Destroy(builder);
2083 if (result != AUDIOSTREAM_ERROR_INVALID_PARAM) {
2084 napi_create_int32(env, TEST_FAIL, &res);
2085 } else {
2086 napi_create_int32(env, TEST_PASS, &res);
2087 }
2088 return res;
2089 }
2090
AudioRendererSetInterruptMode_04(napi_env env,napi_callback_info info)2091 static napi_value AudioRendererSetInterruptMode_04(napi_env env, napi_callback_info info)
2092 {
2093 napi_value res;
2094 OH_AudioStreamBuilder* builder = nullptr;
2095 OH_AudioInterrupt_Mode mode = static_cast<OH_AudioInterrupt_Mode>(-2);
2096 OH_AudioStream_Result result = OH_AudioStreamBuilder_SetRendererInterruptMode(builder, mode);
2097 LOG("OH_AudioRenderer_SetInterruptMode_04, result is: %{public}d", result);
2098 OH_AudioStreamBuilder_Destroy(builder);
2099 if (result != AUDIOSTREAM_ERROR_INVALID_PARAM) {
2100 napi_create_int32(env, TEST_FAIL, &res);
2101 } else {
2102 napi_create_int32(env, TEST_PASS, &res);
2103 }
2104 return res;
2105 }
2106
DeviceChangeCallback(OH_AudioDevice_ChangeType type,OH_AudioDeviceDescriptorArray * audioDeviceDescriptorArray)2107 static int32_t DeviceChangeCallback(OH_AudioDevice_ChangeType type,
2108 OH_AudioDeviceDescriptorArray *audioDeviceDescriptorArray)
2109 {
2110 LOG("DeviceChangeCallback triggrred, ChangeType: %{public}d\n", type);
2111 if (type == AUDIO_DEVICE_CHANGE_TYPE_CONNECT) {
2112 int size = audioDeviceDescriptorArray->size;
2113 for (int index = 0; index < size; index++) {
2114 OH_AudioDeviceDescriptor *audioDeviceDescriptor = audioDeviceDescriptorArray->descriptors[index];
2115 if (audioDeviceDescriptor) {
2116 OH_AudioDevice_Role deviceRole = AUDIO_DEVICE_ROLE_OUTPUT;
2117 OH_AudioDeviceDescriptor_GetDeviceRole(audioDeviceDescriptor, &deviceRole);
2118 OH_AudioDevice_Type deviceType = AUDIO_DEVICE_TYPE_INVALID;
2119 OH_AudioDeviceDescriptor_GetDeviceType(audioDeviceDescriptor, &deviceType);
2120 LOG("Receive new device: DeviceRole: %{public}d, DeviceType: %{public}d\n", deviceRole, deviceType);
2121 }
2122 }
2123 }
2124 return 0;
2125 }
2126
AudioManagerGetAudioRoutingManager_01(napi_env env,napi_callback_info info)2127 static napi_value AudioManagerGetAudioRoutingManager_01(napi_env env, napi_callback_info info)
2128 {
2129 napi_value res;
2130 OH_AudioRoutingManager *audioRoutingManager = nullptr;
2131 OH_AudioCommon_Result result = OH_AudioManager_GetAudioRoutingManager(&audioRoutingManager);
2132 LOG("AudioManagerGetAudioRoutingManager_01, result is: %{public}d", result);
2133 if (result != AUDIOCOMMON_RESULT_SUCCESS || audioRoutingManager == nullptr) {
2134 napi_create_int32(env, TEST_FAIL, &res);
2135 } else {
2136 napi_create_int32(env, TEST_PASS, &res);
2137 }
2138 return res;
2139 }
2140
AudioRoutingManagerGetDevices_01(napi_env env,napi_callback_info info)2141 static napi_value AudioRoutingManagerGetDevices_01(napi_env env, napi_callback_info info)
2142 {
2143 napi_value res;
2144 OH_AudioRoutingManager *audioRoutingManager = nullptr;
2145 OH_AudioCommon_Result result = OH_AudioManager_GetAudioRoutingManager(&audioRoutingManager);
2146 if (result != AUDIOCOMMON_RESULT_SUCCESS || audioRoutingManager == nullptr) {
2147 napi_create_int32(env, TEST_FAIL, &res);
2148 return res;
2149 }
2150 OH_AudioDevice_Flag deviceFlag = AUDIO_DEVICE_FLAG_NONE;
2151 OH_AudioDeviceDescriptorArray *array = nullptr;
2152 result = OH_AudioRoutingManager_GetDevices(audioRoutingManager, deviceFlag, &array);
2153 LOG("AudioRoutingManagerGetDevices_01, result is: %{public}d", result);
2154 if (result != AUDIOCOMMON_RESULT_ERROR_NO_MEMORY || array != nullptr) {
2155 napi_create_int32(env, TEST_FAIL, &res);
2156 } else {
2157 napi_create_int32(env, TEST_PASS, &res);
2158 }
2159 return res;
2160 }
2161
AudioRoutingManagerGetDevices_02(napi_env env,napi_callback_info info)2162 static napi_value AudioRoutingManagerGetDevices_02(napi_env env, napi_callback_info info)
2163 {
2164 napi_value res;
2165 OH_AudioRoutingManager *audioRoutingManager = nullptr;
2166 OH_AudioCommon_Result result = OH_AudioManager_GetAudioRoutingManager(&audioRoutingManager);
2167 if (result != AUDIOCOMMON_RESULT_SUCCESS || audioRoutingManager == nullptr) {
2168 napi_create_int32(env, TEST_FAIL, &res);
2169 return res;
2170 }
2171 OH_AudioDevice_Flag deviceFlag = AUDIO_DEVICE_FLAG_OUTPUT;
2172 OH_AudioDeviceDescriptorArray *array = nullptr;
2173 result = OH_AudioRoutingManager_GetDevices(audioRoutingManager, deviceFlag, &array);
2174 LOG("AudioRoutingManagerGetDevices_02, result is: %{public}d", result);
2175 if (result != AUDIOCOMMON_RESULT_SUCCESS || array == nullptr) {
2176 napi_create_int32(env, TEST_FAIL, &res);
2177 } else {
2178 napi_create_int32(env, TEST_PASS, &res);
2179 }
2180 OH_AudioRoutingManager_ReleaseDevices(audioRoutingManager, array);
2181 return res;
2182 }
2183
AudioRoutingManagerGetDevices_03(napi_env env,napi_callback_info info)2184 static napi_value AudioRoutingManagerGetDevices_03(napi_env env, napi_callback_info info)
2185 {
2186 napi_value res;
2187 OH_AudioRoutingManager *audioRoutingManager = nullptr;
2188 OH_AudioCommon_Result result = OH_AudioManager_GetAudioRoutingManager(&audioRoutingManager);
2189 if (result != AUDIOCOMMON_RESULT_SUCCESS || audioRoutingManager == nullptr) {
2190 napi_create_int32(env, TEST_FAIL, &res);
2191 return res;
2192 }
2193 OH_AudioDevice_Flag deviceFlag = AUDIO_DEVICE_FLAG_INPUT;
2194 OH_AudioDeviceDescriptorArray *array = nullptr;
2195 result = OH_AudioRoutingManager_GetDevices(audioRoutingManager, deviceFlag, &array);
2196 LOG("AudioRoutingManagerGetDevices_03, result is: %{public}d", result);
2197 if (result != AUDIOCOMMON_RESULT_SUCCESS || array == nullptr) {
2198 napi_create_int32(env, TEST_FAIL, &res);
2199 } else {
2200 napi_create_int32(env, TEST_PASS, &res);
2201 }
2202 OH_AudioRoutingManager_ReleaseDevices(audioRoutingManager, array);
2203 return res;
2204 }
2205
AudioRoutingManagerGetDevices_04(napi_env env,napi_callback_info info)2206 static napi_value AudioRoutingManagerGetDevices_04(napi_env env, napi_callback_info info)
2207 {
2208 napi_value res;
2209 OH_AudioRoutingManager *audioRoutingManager = nullptr;
2210 OH_AudioCommon_Result result = OH_AudioManager_GetAudioRoutingManager(&audioRoutingManager);
2211 if (result != AUDIOCOMMON_RESULT_SUCCESS || audioRoutingManager == nullptr) {
2212 napi_create_int32(env, TEST_FAIL, &res);
2213 return res;
2214 }
2215 OH_AudioDevice_Flag deviceFlag = AUDIO_DEVICE_FLAG_ALL;
2216 OH_AudioDeviceDescriptorArray *array = nullptr;
2217 result = OH_AudioRoutingManager_GetDevices(audioRoutingManager, deviceFlag, &array);
2218 LOG("AudioRoutingManagerGetDevices_04, result is: %{public}d", result);
2219 if (result != AUDIOCOMMON_RESULT_SUCCESS || array == nullptr) {
2220 napi_create_int32(env, TEST_FAIL, &res);
2221 } else {
2222 napi_create_int32(env, TEST_PASS, &res);
2223 }
2224 OH_AudioRoutingManager_ReleaseDevices(audioRoutingManager, array);
2225 return res;
2226 }
2227
AudioRoutingManagerGetDevices_05(napi_env env,napi_callback_info info)2228 static napi_value AudioRoutingManagerGetDevices_05(napi_env env, napi_callback_info info)
2229 {
2230 napi_value res;
2231 OH_AudioRoutingManager *audioRoutingManager = nullptr;
2232 OH_AudioCommon_Result result = OH_AudioManager_GetAudioRoutingManager(&audioRoutingManager);
2233 if (result != AUDIOCOMMON_RESULT_SUCCESS || audioRoutingManager == nullptr) {
2234 napi_create_int32(env, TEST_FAIL, &res);
2235 return res;
2236 }
2237 int32_t flag = -1;
2238 OH_AudioDevice_Flag deviceFlag = (OH_AudioDevice_Flag)flag;
2239 OH_AudioDeviceDescriptorArray *array = nullptr;
2240 result = OH_AudioRoutingManager_GetDevices(audioRoutingManager, deviceFlag, &array);
2241 LOG("AudioRoutingManagerGetDevices_05, result is: %{public}d", result);
2242 if (result != AUDIOCOMMON_RESULT_ERROR_INVALID_PARAM || array != nullptr) {
2243 napi_create_int32(env, TEST_FAIL, &res);
2244 } else {
2245 napi_create_int32(env, TEST_PASS, &res);
2246 }
2247 return res;
2248 }
2249
AudioRoutingManagerGetDevices_06(napi_env env,napi_callback_info info)2250 static napi_value AudioRoutingManagerGetDevices_06(napi_env env, napi_callback_info info)
2251 {
2252 napi_value res;
2253 OH_AudioRoutingManager *audioRoutingManager = nullptr;
2254 OH_AudioDevice_Flag deviceFlag = AUDIO_DEVICE_FLAG_OUTPUT;
2255 OH_AudioDeviceDescriptorArray *array = nullptr;
2256 OH_AudioCommon_Result result = OH_AudioRoutingManager_GetDevices(audioRoutingManager, deviceFlag, &array);
2257 LOG("AudioRoutingManagerGetDevices_06, result is: %{public}d", result);
2258 if (result != AUDIOCOMMON_RESULT_ERROR_INVALID_PARAM || array != nullptr) {
2259 napi_create_int32(env, TEST_FAIL, &res);
2260 } else {
2261 napi_create_int32(env, TEST_PASS, &res);
2262 }
2263 return res;
2264 }
2265
AudioRoutingManagerGetDevices_07(napi_env env,napi_callback_info info)2266 static napi_value AudioRoutingManagerGetDevices_07(napi_env env, napi_callback_info info)
2267 {
2268 napi_value res;
2269 OH_AudioRoutingManager *audioRoutingManager = nullptr;
2270 OH_AudioCommon_Result result = OH_AudioManager_GetAudioRoutingManager(&audioRoutingManager);
2271 if (result != AUDIOCOMMON_RESULT_SUCCESS || audioRoutingManager == nullptr) {
2272 napi_create_int32(env, TEST_FAIL, &res);
2273 return res;
2274 }
2275 int32_t flag = 4;
2276 OH_AudioDevice_Flag deviceFlag = (OH_AudioDevice_Flag)flag;
2277 OH_AudioDeviceDescriptorArray *array = nullptr;
2278 result = OH_AudioRoutingManager_GetDevices(audioRoutingManager, deviceFlag, &array);
2279 LOG("AudioRoutingManagerGetDevices_07, result is: %{public}d", result);
2280 if (result != AUDIOCOMMON_RESULT_ERROR_INVALID_PARAM || array != nullptr) {
2281 napi_create_int32(env, TEST_FAIL, &res);
2282 } else {
2283 napi_create_int32(env, TEST_PASS, &res);
2284 }
2285 return res;
2286 }
2287
AudioManagerGetManager_01(napi_env env,napi_callback_info info)2288 static napi_value AudioManagerGetManager_01(napi_env env, napi_callback_info info)
2289 {
2290 napi_value res;
2291 OH_AudioManager **audioManager = nullptr;
2292 OH_AudioCommon_Result result = OH_GetAudioManager(audioManager);
2293 if (result != AUDIOCOMMON_RESULT_ERROR_INVALID_PARAM) {
2294 napi_create_int32(env, TEST_FAIL, &res);
2295 return res;
2296 }
2297 napi_create_int32(env, TEST_PASS, &res);
2298 return res;
2299 }
2300
AudioManagerGetManager_02(napi_env env,napi_callback_info info)2301 static napi_value AudioManagerGetManager_02(napi_env env, napi_callback_info info)
2302 {
2303 napi_value res;
2304 OH_AudioManager *audioManager = nullptr;
2305 OH_AudioCommon_Result result = OH_GetAudioManager(&audioManager);
2306 if (result != AUDIOCOMMON_RESULT_SUCCESS || audioManager == nullptr) {
2307 napi_create_int32(env, TEST_FAIL, &res);
2308 return res;
2309 }
2310 napi_create_int32(env, TEST_PASS, &res);
2311 return res;
2312 }
2313
AudioManagerGetAudioScene_01(napi_env env,napi_callback_info info)2314 static napi_value AudioManagerGetAudioScene_01(napi_env env, napi_callback_info info)
2315 {
2316 napi_value res;
2317 OH_AudioManager *audioManager = nullptr;
2318 OH_AudioCommon_Result result = OH_GetAudioManager(&audioManager);
2319 if (result != AUDIOCOMMON_RESULT_SUCCESS || audioManager == nullptr) {
2320 napi_create_int32(env, TEST_FAIL, &res);
2321 return res;
2322 }
2323 OH_AudioScene scene = AUDIO_SCENE_DEFAULT;
2324 result = OH_GetAudioScene(audioManager, &scene);
2325 if (result != AUDIOCOMMON_RESULT_SUCCESS) {
2326 napi_create_int32(env, TEST_FAIL, &res);
2327 return res;
2328 }
2329 napi_create_int32(env, TEST_PASS, &res);
2330 return res;
2331 }
2332
AudioManagerGetAudioScene_02(napi_env env,napi_callback_info info)2333 static napi_value AudioManagerGetAudioScene_02(napi_env env, napi_callback_info info)
2334 {
2335 napi_value res;
2336
2337 OH_AudioScene scene = AUDIO_SCENE_DEFAULT;
2338 OH_AudioCommon_Result result = OH_GetAudioScene(nullptr, &scene);
2339 if (result != AUDIOCOMMON_RESULT_ERROR_INVALID_PARAM) {
2340 napi_create_int32(env, TEST_FAIL, &res);
2341 return res;
2342 }
2343
2344 result = OH_GetAudioScene(nullptr, nullptr);
2345 if (result != AUDIOCOMMON_RESULT_ERROR_INVALID_PARAM) {
2346 napi_create_int32(env, TEST_FAIL, &res);
2347 return res;
2348 }
2349
2350 OH_AudioManager *audioManager = nullptr;
2351 result = OH_GetAudioManager(&audioManager);
2352 if (result != AUDIOCOMMON_RESULT_SUCCESS || audioManager == nullptr) {
2353 napi_create_int32(env, TEST_FAIL, &res);
2354 return res;
2355 }
2356
2357 result = OH_GetAudioScene(audioManager, nullptr);
2358 if (result != AUDIOCOMMON_RESULT_ERROR_INVALID_PARAM) {
2359 napi_create_int32(env, TEST_FAIL, &res);
2360 return res;
2361 }
2362
2363 napi_create_int32(env, TEST_PASS, &res);
2364 return res;
2365 }
2366
AudioRoutingManagerGetAvailableDevices001(napi_env env,napi_callback_info info)2367 static napi_value AudioRoutingManagerGetAvailableDevices001(napi_env env, napi_callback_info info)
2368 {
2369 napi_value res;
2370 OH_AudioRoutingManager *audioRoutingManager = nullptr;
2371 OH_AudioCommon_Result result = OH_AudioManager_GetAudioRoutingManager(&audioRoutingManager);
2372 if (result != AUDIOCOMMON_RESULT_SUCCESS || audioRoutingManager == nullptr) {
2373 napi_create_int32(env, TEST_FAIL, &res);
2374 return res;
2375 }
2376 OH_AudioDevice_Usage deviceUsage = AUDIO_DEVICE_USAGE_MEDIA_OUTPUT;
2377 OH_AudioDeviceDescriptorArray *array;
2378 result = OH_AudioRoutingManager_GetAvailableDevices(audioRoutingManager, deviceUsage, &array);
2379 if (result != AUDIOCOMMON_RESULT_SUCCESS) {
2380 napi_create_int32(env, TEST_FAIL, &res);
2381 return res;
2382 }
2383
2384 result = OH_AudioRoutingManager_ReleaseDevices(audioRoutingManager, array);
2385 if (result != AUDIOCOMMON_RESULT_SUCCESS) {
2386 napi_create_int32(env, TEST_FAIL, &res);
2387 return res;
2388 }
2389 napi_create_int32(env, TEST_PASS, &res);
2390 return res;
2391 }
2392
AudioRoutingManagerGetPreferredOutputDevice001(napi_env env,napi_callback_info info)2393 static napi_value AudioRoutingManagerGetPreferredOutputDevice001(napi_env env, napi_callback_info info)
2394 {
2395 napi_value res;
2396 OH_AudioRoutingManager *audioRoutingManager = nullptr;
2397 OH_AudioCommon_Result result = OH_AudioManager_GetAudioRoutingManager(&audioRoutingManager);
2398 if (result != AUDIOCOMMON_RESULT_SUCCESS || audioRoutingManager == nullptr) {
2399 napi_create_int32(env, TEST_FAIL, &res);
2400 return res;
2401 }
2402 OH_AudioStream_Usage streamUsage = AUDIOSTREAM_USAGE_MUSIC;
2403 OH_AudioDeviceDescriptorArray *array;
2404 result = OH_AudioRoutingManager_GetPreferredOutputDevice(audioRoutingManager, streamUsage, &array);
2405 if (result != AUDIOCOMMON_RESULT_SUCCESS) {
2406 napi_create_int32(env, TEST_FAIL, &res);
2407 return res;
2408 }
2409
2410 result = OH_AudioRoutingManager_ReleaseDevices(audioRoutingManager, array);
2411 if (result != AUDIOCOMMON_RESULT_SUCCESS) {
2412 napi_create_int32(env, TEST_FAIL, &res);
2413 return res;
2414 }
2415 napi_create_int32(env, TEST_PASS, &res);
2416 return res;
2417 }
2418
AudioRoutingManagerGetPreferredInputDevice001(napi_env env,napi_callback_info info)2419 static napi_value AudioRoutingManagerGetPreferredInputDevice001(napi_env env, napi_callback_info info)
2420 {
2421 napi_value res;
2422 OH_AudioRoutingManager *audioRoutingManager = nullptr;
2423 OH_AudioCommon_Result result = OH_AudioManager_GetAudioRoutingManager(&audioRoutingManager);
2424 if (result != AUDIOCOMMON_RESULT_SUCCESS || audioRoutingManager == nullptr) {
2425 napi_create_int32(env, TEST_FAIL, &res);
2426 return res;
2427 }
2428 OH_AudioStream_SourceType sourceType = AUDIOSTREAM_SOURCE_TYPE_MIC;
2429 OH_AudioDeviceDescriptorArray *array;
2430 result = OH_AudioRoutingManager_GetPreferredInputDevice(audioRoutingManager, sourceType, &array);
2431 if (result != AUDIOCOMMON_RESULT_SUCCESS) {
2432 napi_create_int32(env, TEST_FAIL, &res);
2433 return res;
2434 }
2435
2436 result = OH_AudioRoutingManager_ReleaseDevices(audioRoutingManager, array);
2437 if (result != AUDIOCOMMON_RESULT_SUCCESS) {
2438 napi_create_int32(env, TEST_FAIL, &res);
2439 return res;
2440 }
2441 napi_create_int32(env, TEST_PASS, &res);
2442 return res;
2443 }
2444
AudioRoutingManagerSetMicBlockStatusCallback_001(napi_env env,napi_callback_info info)2445 static napi_value AudioRoutingManagerSetMicBlockStatusCallback_001(napi_env env, napi_callback_info info)
2446 {
2447 napi_value res;
2448 OH_AudioRoutingManager *audioRoutingManager = nullptr;
2449 OH_AudioCommon_Result result = OH_AudioManager_GetAudioRoutingManager(&audioRoutingManager);
2450 LOG("AudioRoutingManagerSetMicBlockStatusCallback_Test, result1 is: %{public}d", result);
2451 if (result != AUDIOCOMMON_RESULT_SUCCESS || audioRoutingManager == nullptr) {
2452 napi_create_int32(env, TEST_FAIL, &res);
2453 return res;
2454 }
2455 bool supported = false;
2456 void *userData = nullptr;
2457 result = OH_AudioRoutingManager_IsMicBlockDetectionSupported(audioRoutingManager, &supported);
2458 LOG("AudioRoutingManagerSetMicBlockStatusCallback_Test, result2 is: %{public}d", result);
2459 if (result == AUDIOCOMMON_RESULT_SUCCESS) {
2460 if (supported == true) {
2461 OH_AudioRoutingManager_OnDeviceBlockStatusCallback micBlockedCallback = MicBlockedCallback;
2462 result = OH_AudioRoutingManager_SetMicBlockStatusCallback(audioRoutingManager, micBlockedCallback, userData);
2463 LOG("AudioRoutingManagerSetMicBlockStatusCallback_Test, result3 is: %{public}d", result);
2464 if (result != AUDIOCOMMON_RESULT_SUCCESS) {
2465 napi_create_int32(env, TEST_FAIL, &res);
2466 return res;
2467 }
2468 } else {
2469 LOG("AudioRoutingManagerSetMicBlockStatusCallback_Test, result3 is: false");
2470 }
2471 } else {
2472 napi_create_int32(env, TEST_FAIL, &res);
2473 return res;
2474 }
2475 napi_create_int32(env, TEST_PASS, &res);
2476 return res;
2477 }
2478
AudioRoutingManagerSetMicBlockStatusCallback_002(napi_env env,napi_callback_info info)2479 static napi_value AudioRoutingManagerSetMicBlockStatusCallback_002(napi_env env, napi_callback_info info)
2480 {
2481 napi_value res;
2482 OH_AudioRoutingManager *audioRoutingManager = nullptr;
2483 OH_AudioCommon_Result result = OH_AudioManager_GetAudioRoutingManager(&audioRoutingManager);
2484 LOG("AudioRoutingManagerSetMicBlockStatusCallback_Test, result1 is: %{public}d", result);
2485 if (result != AUDIOCOMMON_RESULT_SUCCESS || audioRoutingManager == nullptr) {
2486 napi_create_int32(env, TEST_FAIL, &res);
2487 return res;
2488 }
2489 bool supported = false;
2490 void *userData = nullptr;
2491 result = OH_AudioRoutingManager_IsMicBlockDetectionSupported(audioRoutingManager, &supported);
2492 LOG("AudioRoutingManagerSetMicBlockStatusCallback_Test, result2 is: %{public}d", result);
2493 if (result == AUDIOCOMMON_RESULT_SUCCESS) {
2494 if (supported == true) {
2495 OH_AudioRoutingManager_OnDeviceBlockStatusCallback micBlockedCallback = MicBlockedCallback;
2496 result = OH_AudioRoutingManager_SetMicBlockStatusCallback(nullptr, micBlockedCallback, userData);
2497 LOG("AudioRoutingManagerSetMicBlockStatusCallback_Test, result3 is: %{public}d", result);
2498 if (result == AUDIOCOMMON_RESULT_SUCCESS) {
2499 napi_create_int32(env, TEST_FAIL, &res);
2500 return res;
2501 }
2502 } else {
2503 LOG("OH_AudioRoutingManager_IsMicBlockDetectionSupported_Test, supported is: false");
2504 }
2505 } else {
2506 napi_create_int32(env, TEST_FAIL, &res);
2507 return res;
2508 }
2509 napi_create_int32(env, TEST_PASS, &res);
2510 return res;
2511 }
2512
AudioRoutingManagerRegisterDeviceChangeCallback_001(napi_env env,napi_callback_info info)2513 static napi_value AudioRoutingManagerRegisterDeviceChangeCallback_001(napi_env env, napi_callback_info info)
2514 {
2515 napi_value res;
2516 OH_AudioRoutingManager *audioRoutingManager = nullptr;
2517 OH_AudioCommon_Result result = OH_AudioManager_GetAudioRoutingManager(&audioRoutingManager);
2518 if (result != AUDIOCOMMON_RESULT_SUCCESS || audioRoutingManager == nullptr) {
2519 napi_create_int32(env, TEST_FAIL, &res);
2520 return res;
2521 }
2522 OH_AudioDevice_Flag deviceFlag = AUDIO_DEVICE_FLAG_NONE;
2523 OH_AudioRoutingManager_OnDeviceChangedCallback callback = DeviceChangeCallback;
2524 result = OH_AudioRoutingManager_RegisterDeviceChangeCallback(audioRoutingManager, deviceFlag, callback);
2525 LOG("AudioRoutingManagerRegisterDeviceChangeCallback_001, result is: %{public}d", result);
2526 if (result != AUDIOCOMMON_RESULT_SUCCESS) {
2527 napi_create_int32(env, TEST_FAIL, &res);
2528 } else {
2529 napi_create_int32(env, TEST_PASS, &res);
2530 }
2531 return res;
2532 }
2533
AudioRoutingManagerRegisterDeviceChangeCallback_002(napi_env env,napi_callback_info info)2534 static napi_value AudioRoutingManagerRegisterDeviceChangeCallback_002(napi_env env, napi_callback_info info)
2535 {
2536 napi_value res;
2537 OH_AudioRoutingManager *audioRoutingManager = nullptr;
2538 OH_AudioCommon_Result result = OH_AudioManager_GetAudioRoutingManager(&audioRoutingManager);
2539 if (result != AUDIOCOMMON_RESULT_SUCCESS || audioRoutingManager == nullptr) {
2540 napi_create_int32(env, TEST_FAIL, &res);
2541 return res;
2542 }
2543 OH_AudioDevice_Flag deviceFlag = AUDIO_DEVICE_FLAG_OUTPUT;
2544 OH_AudioRoutingManager_OnDeviceChangedCallback callback = DeviceChangeCallback;
2545 result = OH_AudioRoutingManager_RegisterDeviceChangeCallback(audioRoutingManager, deviceFlag, callback);
2546 LOG("AudioRoutingManagerRegisterDeviceChangeCallback_002, result is: %{public}d", result);
2547 if (result != AUDIOCOMMON_RESULT_SUCCESS) {
2548 napi_create_int32(env, TEST_FAIL, &res);
2549 } else {
2550 napi_create_int32(env, TEST_PASS, &res);
2551 }
2552 return res;
2553 }
2554
AudioRoutingManagerRegisterDeviceChangeCallback_003(napi_env env,napi_callback_info info)2555 static napi_value AudioRoutingManagerRegisterDeviceChangeCallback_003(napi_env env, napi_callback_info info)
2556 {
2557 napi_value res;
2558 OH_AudioRoutingManager *audioRoutingManager = nullptr;
2559 OH_AudioCommon_Result result = OH_AudioManager_GetAudioRoutingManager(&audioRoutingManager);
2560 if (result != AUDIOCOMMON_RESULT_SUCCESS || audioRoutingManager == nullptr) {
2561 napi_create_int32(env, TEST_FAIL, &res);
2562 return res;
2563 }
2564 OH_AudioDevice_Flag deviceFlag = AUDIO_DEVICE_FLAG_INPUT;
2565 OH_AudioRoutingManager_OnDeviceChangedCallback callback = DeviceChangeCallback;
2566 result = OH_AudioRoutingManager_RegisterDeviceChangeCallback(audioRoutingManager, deviceFlag, callback);
2567 LOG("AudioRoutingManagerRegisterDeviceChangeCallback_003, result is: %{public}d", result);
2568 if (result != AUDIOCOMMON_RESULT_SUCCESS) {
2569 napi_create_int32(env, TEST_FAIL, &res);
2570 } else {
2571 napi_create_int32(env, TEST_PASS, &res);
2572 }
2573 return res;
2574 }
2575
AudioRoutingManagerRegisterDeviceChangeCallback_004(napi_env env,napi_callback_info info)2576 static napi_value AudioRoutingManagerRegisterDeviceChangeCallback_004(napi_env env, napi_callback_info info)
2577 {
2578 napi_value res;
2579 OH_AudioRoutingManager *audioRoutingManager = nullptr;
2580 OH_AudioCommon_Result result = OH_AudioManager_GetAudioRoutingManager(&audioRoutingManager);
2581 if (result != AUDIOCOMMON_RESULT_SUCCESS || audioRoutingManager == nullptr) {
2582 napi_create_int32(env, TEST_FAIL, &res);
2583 return res;
2584 }
2585 OH_AudioDevice_Flag deviceFlag = AUDIO_DEVICE_FLAG_ALL;
2586 OH_AudioRoutingManager_OnDeviceChangedCallback callback = DeviceChangeCallback;
2587 result = OH_AudioRoutingManager_RegisterDeviceChangeCallback(audioRoutingManager, deviceFlag, callback);
2588 LOG("AudioRoutingManagerRegisterDeviceChangeCallback_004, result is: %{public}d", result);
2589 if (result != AUDIOCOMMON_RESULT_SUCCESS) {
2590 napi_create_int32(env, TEST_FAIL, &res);
2591 } else {
2592 napi_create_int32(env, TEST_PASS, &res);
2593 }
2594 return res;
2595 }
2596
AudioRoutingManagerRegisterDeviceChangeCallback_005(napi_env env,napi_callback_info info)2597 static napi_value AudioRoutingManagerRegisterDeviceChangeCallback_005(napi_env env, napi_callback_info info)
2598 {
2599 napi_value res;
2600 OH_AudioRoutingManager *audioRoutingManager = nullptr;
2601 OH_AudioDevice_Flag deviceFlag = AUDIO_DEVICE_FLAG_OUTPUT;
2602 OH_AudioRoutingManager_OnDeviceChangedCallback callback = DeviceChangeCallback;
2603 OH_AudioCommon_Result result =
2604 OH_AudioRoutingManager_RegisterDeviceChangeCallback(audioRoutingManager, deviceFlag, callback);
2605 LOG("AudioRoutingManagerRegisterDeviceChangeCallback_005, result is: %{public}d", result);
2606 if (result != AUDIOCOMMON_RESULT_ERROR_INVALID_PARAM) {
2607 napi_create_int32(env, TEST_FAIL, &res);
2608 } else {
2609 napi_create_int32(env, TEST_PASS, &res);
2610 }
2611 return res;
2612 }
2613
AudioRoutingManagerRegisterDeviceChangeCallback_006(napi_env env,napi_callback_info info)2614 static napi_value AudioRoutingManagerRegisterDeviceChangeCallback_006(napi_env env, napi_callback_info info)
2615 {
2616 napi_value res;
2617 OH_AudioRoutingManager *audioRoutingManager = nullptr;
2618 OH_AudioCommon_Result result = OH_AudioManager_GetAudioRoutingManager(&audioRoutingManager);
2619 if (result != AUDIOCOMMON_RESULT_SUCCESS || audioRoutingManager == nullptr) {
2620 napi_create_int32(env, TEST_FAIL, &res);
2621 return res;
2622 }
2623 OH_AudioDevice_Flag deviceFlag = AUDIO_DEVICE_FLAG_ALL;
2624 OH_AudioRoutingManager_OnDeviceChangedCallback callback = nullptr;
2625 result = OH_AudioRoutingManager_RegisterDeviceChangeCallback(audioRoutingManager, deviceFlag, callback);
2626 LOG("AudioRoutingManagerRegisterDeviceChangeCallback_006, result is: %{public}d", result);
2627 if (result != AUDIOCOMMON_RESULT_ERROR_INVALID_PARAM) {
2628 napi_create_int32(env, TEST_FAIL, &res);
2629 } else {
2630 napi_create_int32(env, TEST_PASS, &res);
2631 }
2632 return res;
2633 }
2634
AudioRoutingManagerRegisterDeviceChangeCallback_007(napi_env env,napi_callback_info info)2635 static napi_value AudioRoutingManagerRegisterDeviceChangeCallback_007(napi_env env, napi_callback_info info)
2636 {
2637 napi_value res;
2638 OH_AudioRoutingManager *audioRoutingManager = nullptr;
2639 OH_AudioCommon_Result result = OH_AudioManager_GetAudioRoutingManager(&audioRoutingManager);
2640 if (result != AUDIOCOMMON_RESULT_SUCCESS || audioRoutingManager == nullptr) {
2641 napi_create_int32(env, TEST_FAIL, &res);
2642 return res;
2643 }
2644 int32_t flag = -1;
2645 OH_AudioDevice_Flag deviceFlag = (OH_AudioDevice_Flag)flag;
2646 OH_AudioRoutingManager_OnDeviceChangedCallback callback = DeviceChangeCallback;
2647 result = OH_AudioRoutingManager_RegisterDeviceChangeCallback(audioRoutingManager, deviceFlag, callback);
2648 LOG("AudioRoutingManagerRegisterDeviceChangeCallback_007, result is: %{public}d", result);
2649 if (result != AUDIOCOMMON_RESULT_ERROR_INVALID_PARAM) {
2650 napi_create_int32(env, TEST_FAIL, &res);
2651 } else {
2652 napi_create_int32(env, TEST_PASS, &res);
2653 }
2654 return res;
2655 }
2656
AudioRoutingManagerRegisterDeviceChangeCallback_008(napi_env env,napi_callback_info info)2657 static napi_value AudioRoutingManagerRegisterDeviceChangeCallback_008(napi_env env, napi_callback_info info)
2658 {
2659 napi_value res;
2660 OH_AudioRoutingManager *audioRoutingManager = nullptr;
2661 OH_AudioCommon_Result result = OH_AudioManager_GetAudioRoutingManager(&audioRoutingManager);
2662 if (result != AUDIOCOMMON_RESULT_SUCCESS || audioRoutingManager == nullptr) {
2663 napi_create_int32(env, TEST_FAIL, &res);
2664 return res;
2665 }
2666 int32_t flag = 4;
2667 OH_AudioDevice_Flag deviceFlag = (OH_AudioDevice_Flag)flag;
2668 OH_AudioRoutingManager_OnDeviceChangedCallback callback = DeviceChangeCallback;
2669 result = OH_AudioRoutingManager_RegisterDeviceChangeCallback(audioRoutingManager, deviceFlag, callback);
2670 LOG("AudioRoutingManagerRegisterDeviceChangeCallback_008, result is: %{public}d", result);
2671 if (result != AUDIOCOMMON_RESULT_ERROR_INVALID_PARAM) {
2672 napi_create_int32(env, TEST_FAIL, &res);
2673 } else {
2674 napi_create_int32(env, TEST_PASS, &res);
2675 }
2676 return res;
2677 }
2678
AudioRoutingManagerUnregisterDeviceChangeCallback_001(napi_env env,napi_callback_info info)2679 static napi_value AudioRoutingManagerUnregisterDeviceChangeCallback_001(napi_env env, napi_callback_info info)
2680 {
2681 napi_value res;
2682 OH_AudioRoutingManager *audioRoutingManager = nullptr;
2683 OH_AudioCommon_Result result = OH_AudioManager_GetAudioRoutingManager(&audioRoutingManager);
2684 if (result != AUDIOCOMMON_RESULT_SUCCESS || audioRoutingManager == nullptr) {
2685 napi_create_int32(env, TEST_FAIL, &res);
2686 return res;
2687 }
2688 OH_AudioRoutingManager_OnDeviceChangedCallback callback = DeviceChangeCallback;
2689 result = OH_AudioRoutingManager_UnregisterDeviceChangeCallback(audioRoutingManager, callback);
2690 LOG("AudioRoutingManagerUnregisterDeviceChangeCallback_001, result is: %{public}d", result);
2691 if (result != AUDIOCOMMON_RESULT_SUCCESS) {
2692 napi_create_int32(env, TEST_FAIL, &res);
2693 } else {
2694 napi_create_int32(env, TEST_PASS, &res);
2695 }
2696 return res;
2697 }
2698
AudioRoutingManagerUnregisterDeviceChangeCallback_002(napi_env env,napi_callback_info info)2699 static napi_value AudioRoutingManagerUnregisterDeviceChangeCallback_002(napi_env env, napi_callback_info info)
2700 {
2701 napi_value res;
2702 OH_AudioRoutingManager *audioRoutingManager = nullptr;
2703 OH_AudioRoutingManager_OnDeviceChangedCallback callback = DeviceChangeCallback;
2704 OH_AudioCommon_Result result = OH_AudioRoutingManager_UnregisterDeviceChangeCallback(
2705 audioRoutingManager, callback);
2706 LOG("AudioRoutingManagerUnregisterDeviceChangeCallback_002, result is: %{public}d", result);
2707 if (result != AUDIOCOMMON_RESULT_ERROR_INVALID_PARAM) {
2708 napi_create_int32(env, TEST_FAIL, &res);
2709 } else {
2710 napi_create_int32(env, TEST_PASS, &res);
2711 }
2712 return res;
2713 }
2714
AudioRoutingManagerUnregisterDeviceChangeCallback_003(napi_env env,napi_callback_info info)2715 static napi_value AudioRoutingManagerUnregisterDeviceChangeCallback_003(napi_env env, napi_callback_info info)
2716 {
2717 napi_value res;
2718 OH_AudioRoutingManager *audioRoutingManager = nullptr;
2719 OH_AudioCommon_Result result = OH_AudioManager_GetAudioRoutingManager(&audioRoutingManager);
2720 if (result != AUDIOCOMMON_RESULT_SUCCESS || audioRoutingManager == nullptr) {
2721 napi_create_int32(env, TEST_FAIL, &res);
2722 return res;
2723 }
2724 OH_AudioRoutingManager_OnDeviceChangedCallback callback = nullptr;
2725 result = OH_AudioRoutingManager_UnregisterDeviceChangeCallback(audioRoutingManager, callback);
2726 LOG("AudioRoutingManagerUnregisterDeviceChangeCallback_003, result is: %{public}d", result);
2727 if (result != AUDIOCOMMON_RESULT_ERROR_INVALID_PARAM) {
2728 napi_create_int32(env, TEST_FAIL, &res);
2729 } else {
2730 napi_create_int32(env, TEST_PASS, &res);
2731 }
2732 return res;
2733 }
2734
AudioRoutingManagerReleaseDevices_001(napi_env env,napi_callback_info info)2735 static napi_value AudioRoutingManagerReleaseDevices_001(napi_env env, napi_callback_info info)
2736 {
2737 napi_value res;
2738 OH_AudioRoutingManager *audioRoutingManager = nullptr;
2739 OH_AudioDeviceDescriptorArray *audioDeviceDescriptorArray = nullptr;
2740 OH_AudioCommon_Result result =
2741 OH_AudioRoutingManager_ReleaseDevices(audioRoutingManager, audioDeviceDescriptorArray);
2742 LOG("AudioRoutingManagerReleaseDevices_001, result is: %{public}d", result);
2743 if (result != AUDIOCOMMON_RESULT_ERROR_INVALID_PARAM) {
2744 napi_create_int32(env, TEST_FAIL, &res);
2745 } else {
2746 napi_create_int32(env, TEST_PASS, &res);
2747 }
2748 return res;
2749 }
2750
AudioRoutingManagerReleaseDevices_002(napi_env env,napi_callback_info info)2751 static napi_value AudioRoutingManagerReleaseDevices_002(napi_env env, napi_callback_info info)
2752 {
2753 napi_value res;
2754 OH_AudioRoutingManager *audioRoutingManager = nullptr;
2755 OH_AudioCommon_Result result = OH_AudioManager_GetAudioRoutingManager(&audioRoutingManager);
2756 if (result != AUDIOCOMMON_RESULT_SUCCESS || audioRoutingManager == nullptr) {
2757 napi_create_int32(env, TEST_FAIL, &res);
2758 return res;
2759 }
2760 OH_AudioDeviceDescriptorArray *audioDeviceDescriptorArray = nullptr;
2761 result = OH_AudioRoutingManager_ReleaseDevices(audioRoutingManager, audioDeviceDescriptorArray);
2762 LOG("AudioRoutingManagerReleaseDevices_002, result is: %{public}d", result);
2763 if (result != AUDIOCOMMON_RESULT_ERROR_INVALID_PARAM) {
2764 napi_create_int32(env, TEST_FAIL, &res);
2765 } else {
2766 napi_create_int32(env, TEST_PASS, &res);
2767 }
2768 return res;
2769 }
2770
AudioAudioDeviceDescriptorGetDeviceType_001(napi_env env,napi_callback_info info)2771 static napi_value AudioAudioDeviceDescriptorGetDeviceType_001(napi_env env, napi_callback_info info)
2772 {
2773 napi_value res;
2774 OH_AudioRoutingManager *audioRoutingManager = nullptr;
2775 OH_AudioCommon_Result result = OH_AudioManager_GetAudioRoutingManager(&audioRoutingManager);
2776 if (result != AUDIOCOMMON_RESULT_SUCCESS || audioRoutingManager == nullptr) {
2777 napi_create_int32(env, TEST_FAIL, &res);
2778 return res;
2779 }
2780 OH_AudioDevice_Flag deviceFlag = AUDIO_DEVICE_FLAG_ALL;
2781 OH_AudioDeviceDescriptorArray *array = nullptr;
2782 result = OH_AudioRoutingManager_GetDevices(audioRoutingManager, deviceFlag, &array);
2783 if (result != AUDIOCOMMON_RESULT_SUCCESS || array == nullptr) {
2784 napi_create_int32(env, TEST_FAIL, &res);
2785 return res;
2786 }
2787 int size = array->size;
2788 for (int i = 0; i < size; i++) {
2789 OH_AudioDeviceDescriptor *descriptor = array->descriptors[i];
2790 if (descriptor == nullptr) {
2791 napi_create_int32(env, TEST_FAIL, &res);
2792 return res;
2793 }
2794 OH_AudioDevice_Type deviceType = AUDIO_DEVICE_TYPE_INVALID;
2795 result = OH_AudioDeviceDescriptor_GetDeviceType(descriptor, &deviceType);
2796 LOG("AudioAudioDeviceDescriptorGetDeviceType_001, result is: %{public}d", result);
2797 if (result != AUDIOCOMMON_RESULT_SUCCESS) {
2798 napi_create_int32(env, TEST_FAIL, &res);
2799 break;
2800 } else {
2801 napi_create_int32(env, TEST_PASS, &res);
2802 }
2803 }
2804 OH_AudioRoutingManager_ReleaseDevices(audioRoutingManager, array);
2805 return res;
2806 }
2807
AudioAudioDeviceDescriptorGetDeviceType_002(napi_env env,napi_callback_info info)2808 static napi_value AudioAudioDeviceDescriptorGetDeviceType_002(napi_env env, napi_callback_info info)
2809 {
2810 napi_value res;
2811 OH_AudioRoutingManager *audioRoutingManager = nullptr;
2812 OH_AudioCommon_Result result = OH_AudioManager_GetAudioRoutingManager(&audioRoutingManager);
2813 if (result != AUDIOCOMMON_RESULT_SUCCESS || audioRoutingManager == nullptr) {
2814 napi_create_int32(env, TEST_FAIL, &res);
2815 return res;
2816 }
2817 OH_AudioDevice_Flag deviceFlag = AUDIO_DEVICE_FLAG_OUTPUT;
2818 OH_AudioDeviceDescriptorArray *array = nullptr;
2819 result = OH_AudioRoutingManager_GetDevices(audioRoutingManager, deviceFlag, &array);
2820 OH_AudioDeviceDescriptor *descriptor = array->descriptors[0];
2821 if (result != AUDIOCOMMON_RESULT_SUCCESS || descriptor == nullptr || array == nullptr) {
2822 napi_create_int32(env, TEST_FAIL, &res);
2823 return res;
2824 }
2825
2826 result = OH_AudioDeviceDescriptor_GetDeviceType(descriptor, nullptr);
2827 LOG("AudioAudioDeviceDescriptorGetDeviceType_002, result is: %{public}d", result);
2828 if (result != AUDIOCOMMON_RESULT_ERROR_INVALID_PARAM) {
2829 napi_create_int32(env, TEST_FAIL, &res);
2830 } else {
2831 napi_create_int32(env, TEST_PASS, &res);
2832 }
2833 return res;
2834 }
2835
AudioAudioDeviceDescriptorGetDeviceType_003(napi_env env,napi_callback_info info)2836 static napi_value AudioAudioDeviceDescriptorGetDeviceType_003(napi_env env, napi_callback_info info)
2837 {
2838 OH_AudioDeviceDescriptor *descriptor = nullptr;
2839 OH_AudioDevice_Type deviceType = AUDIO_DEVICE_TYPE_INVALID;
2840 OH_AudioCommon_Result result = OH_AudioDeviceDescriptor_GetDeviceType(descriptor, &deviceType);
2841 LOG("AudioAudioDeviceDescriptorGetDeviceType_003, result is: %{public}d", result);
2842 napi_value res;
2843 if (result != AUDIOCOMMON_RESULT_ERROR_INVALID_PARAM) {
2844 napi_create_int32(env, TEST_FAIL, &res);
2845 } else {
2846 napi_create_int32(env, TEST_PASS, &res);
2847 }
2848 return res;
2849 }
2850
AudioAudioDeviceDescriptorGetDeviceRole_001(napi_env env,napi_callback_info info)2851 static napi_value AudioAudioDeviceDescriptorGetDeviceRole_001(napi_env env, napi_callback_info info)
2852 {
2853 napi_value res;
2854 OH_AudioRoutingManager *audioRoutingManager = nullptr;
2855 OH_AudioCommon_Result result = OH_AudioManager_GetAudioRoutingManager(&audioRoutingManager);
2856 if (result != AUDIOCOMMON_RESULT_SUCCESS || audioRoutingManager == nullptr) {
2857 napi_create_int32(env, TEST_FAIL, &res);
2858 return res;
2859 }
2860 OH_AudioDevice_Flag deviceFlag = AUDIO_DEVICE_FLAG_ALL;
2861 OH_AudioDeviceDescriptorArray *array = nullptr;
2862 result = OH_AudioRoutingManager_GetDevices(audioRoutingManager, deviceFlag, &array);
2863 if (result != AUDIOCOMMON_RESULT_SUCCESS || array == nullptr) {
2864 napi_create_int32(env, TEST_FAIL, &res);
2865 return res;
2866 }
2867
2868 int size = array->size;
2869 for (int i = 0; i < size; i++) {
2870 OH_AudioDeviceDescriptor *descriptor = array->descriptors[i];
2871 if (descriptor == nullptr) {
2872 napi_create_int32(env, TEST_FAIL, &res);
2873 return res;
2874 }
2875 OH_AudioDevice_Role deviceRole = AUDIO_DEVICE_ROLE_OUTPUT;
2876 result = OH_AudioDeviceDescriptor_GetDeviceRole(descriptor, &deviceRole);
2877 LOG("AudioAudioDeviceDescriptorGetDeviceRole_001, result is: %{public}d", result);
2878 if (result != AUDIOCOMMON_RESULT_SUCCESS) {
2879 napi_create_int32(env, TEST_FAIL, &res);
2880 break;
2881 } else {
2882 napi_create_int32(env, TEST_PASS, &res);
2883 }
2884 }
2885 OH_AudioRoutingManager_ReleaseDevices(audioRoutingManager, array);
2886 return res;
2887 }
2888
AudioAudioDeviceDescriptorGetDeviceRole_002(napi_env env,napi_callback_info info)2889 static napi_value AudioAudioDeviceDescriptorGetDeviceRole_002(napi_env env, napi_callback_info info)
2890 {
2891 napi_value res;
2892 OH_AudioRoutingManager *audioRoutingManager = nullptr;
2893 OH_AudioCommon_Result result = OH_AudioManager_GetAudioRoutingManager(&audioRoutingManager);
2894 if (result != AUDIOCOMMON_RESULT_SUCCESS || audioRoutingManager == nullptr) {
2895 napi_create_int32(env, TEST_FAIL, &res);
2896 return res;
2897 }
2898 OH_AudioDevice_Flag deviceFlag = AUDIO_DEVICE_FLAG_OUTPUT;
2899 OH_AudioDeviceDescriptorArray *array = nullptr;
2900 result = OH_AudioRoutingManager_GetDevices(audioRoutingManager, deviceFlag, &array);
2901 OH_AudioDeviceDescriptor *descriptor = array->descriptors[0];
2902 if (result != AUDIOCOMMON_RESULT_SUCCESS || array == nullptr || descriptor == nullptr) {
2903 napi_create_int32(env, TEST_FAIL, &res);
2904 return res;
2905 }
2906
2907 result = OH_AudioDeviceDescriptor_GetDeviceRole(descriptor, nullptr);
2908 LOG("AudioAudioDeviceDescriptorGetDeviceRole_002, result is: %{public}d", result);
2909 if (result != AUDIOCOMMON_RESULT_ERROR_INVALID_PARAM) {
2910 napi_create_int32(env, TEST_FAIL, &res);
2911 } else {
2912 napi_create_int32(env, TEST_PASS, &res);
2913 }
2914 return res;
2915 }
2916
AudioAudioDeviceDescriptorGetDeviceRole_003(napi_env env,napi_callback_info info)2917 static napi_value AudioAudioDeviceDescriptorGetDeviceRole_003(napi_env env, napi_callback_info info)
2918 {
2919 napi_value res;
2920 OH_AudioDeviceDescriptor *descriptor = nullptr;
2921 OH_AudioDevice_Role deviceRole = AUDIO_DEVICE_ROLE_OUTPUT;
2922 OH_AudioCommon_Result result = OH_AudioDeviceDescriptor_GetDeviceRole(descriptor, &deviceRole);
2923 LOG("AudioAudioDeviceDescriptorGetDeviceRole_003, result is: %{public}d", result);
2924 if (result != AUDIOCOMMON_RESULT_ERROR_INVALID_PARAM) {
2925 napi_create_int32(env, TEST_FAIL, &res);
2926 } else {
2927 napi_create_int32(env, TEST_PASS, &res);
2928 }
2929 return res;
2930 }
2931
AudioAudioDeviceDescriptorGetDeviceId_001(napi_env env,napi_callback_info info)2932 static napi_value AudioAudioDeviceDescriptorGetDeviceId_001(napi_env env, napi_callback_info info)
2933 {
2934 napi_value res;
2935 OH_AudioRoutingManager *audioRoutingManager = nullptr;
2936 OH_AudioCommon_Result result = OH_AudioManager_GetAudioRoutingManager(&audioRoutingManager);
2937 if (result != AUDIOCOMMON_RESULT_SUCCESS || audioRoutingManager == nullptr) {
2938 napi_create_int32(env, TEST_FAIL, &res);
2939 return res;
2940 }
2941 OH_AudioDevice_Flag deviceFlag = AUDIO_DEVICE_FLAG_ALL;
2942 OH_AudioDeviceDescriptorArray *array = nullptr;
2943 result = OH_AudioRoutingManager_GetDevices(audioRoutingManager, deviceFlag, &array);
2944 if (result != AUDIOCOMMON_RESULT_SUCCESS || array == nullptr) {
2945 napi_create_int32(env, TEST_FAIL, &res);
2946 return res;
2947 }
2948
2949 int size = array->size;
2950 for (int i = 0; i < size; i++) {
2951 OH_AudioDeviceDescriptor *descriptor = array->descriptors[i];
2952 if (descriptor == nullptr) {
2953 napi_create_int32(env, TEST_FAIL, &res);
2954 return res;
2955 }
2956 uint32_t id = 0;
2957 result = OH_AudioDeviceDescriptor_GetDeviceId(descriptor, &id);
2958 LOG("AudioAudioDeviceDescriptorGetDeviceId_001, result is: %{public}d", result);
2959 if (result != AUDIOCOMMON_RESULT_SUCCESS) {
2960 napi_create_int32(env, TEST_FAIL, &res);
2961 break;
2962 } else {
2963 napi_create_int32(env, TEST_PASS, &res);
2964 }
2965 }
2966 OH_AudioRoutingManager_ReleaseDevices(audioRoutingManager, array);
2967 return res;
2968 }
2969
AudioAudioDeviceDescriptorGetDeviceId_002(napi_env env,napi_callback_info info)2970 static napi_value AudioAudioDeviceDescriptorGetDeviceId_002(napi_env env, napi_callback_info info)
2971 {
2972 napi_value res;
2973 OH_AudioRoutingManager *audioRoutingManager = nullptr;
2974 OH_AudioCommon_Result result = OH_AudioManager_GetAudioRoutingManager(&audioRoutingManager);
2975 if (result != AUDIOCOMMON_RESULT_SUCCESS || audioRoutingManager == nullptr) {
2976 napi_create_int32(env, TEST_FAIL, &res);
2977 return res;
2978 }
2979 OH_AudioDevice_Flag deviceFlag = AUDIO_DEVICE_FLAG_OUTPUT;
2980 OH_AudioDeviceDescriptorArray *array = nullptr;
2981 result = OH_AudioRoutingManager_GetDevices(audioRoutingManager, deviceFlag, &array);
2982 OH_AudioDeviceDescriptor *descriptor = array->descriptors[0];
2983 if (result != AUDIOCOMMON_RESULT_SUCCESS || array == nullptr || descriptor == nullptr) {
2984 napi_create_int32(env, TEST_FAIL, &res);
2985 return res;
2986 }
2987
2988 result = OH_AudioDeviceDescriptor_GetDeviceId(descriptor, nullptr);
2989 LOG("AudioAudioDeviceDescriptorGetDeviceId_002, result is: %{public}d", result);
2990 if (result != AUDIOCOMMON_RESULT_ERROR_INVALID_PARAM) {
2991 napi_create_int32(env, TEST_FAIL, &res);
2992 } else {
2993 napi_create_int32(env, TEST_PASS, &res);
2994 }
2995 return res;
2996 }
2997
AudioAudioDeviceDescriptorGetDeviceId_003(napi_env env,napi_callback_info info)2998 static napi_value AudioAudioDeviceDescriptorGetDeviceId_003(napi_env env, napi_callback_info info)
2999 {
3000 napi_value res;
3001 OH_AudioDeviceDescriptor *descriptor = nullptr;
3002 uint32_t id = 0;
3003 OH_AudioCommon_Result result = OH_AudioDeviceDescriptor_GetDeviceId(descriptor, &id);
3004 LOG("AudioAudioDeviceDescriptorGetDeviceId_003, result is: %{public}d", result);
3005 if (result != AUDIOCOMMON_RESULT_ERROR_INVALID_PARAM) {
3006 napi_create_int32(env, TEST_FAIL, &res);
3007 } else {
3008 napi_create_int32(env, TEST_PASS, &res);
3009 }
3010 return res;
3011 }
3012
AudioAudioDeviceDescriptorGetDeviceName_001(napi_env env,napi_callback_info info)3013 static napi_value AudioAudioDeviceDescriptorGetDeviceName_001(napi_env env, napi_callback_info info)
3014 {
3015 napi_value res;
3016 OH_AudioRoutingManager *audioRoutingManager = nullptr;
3017 OH_AudioCommon_Result result = OH_AudioManager_GetAudioRoutingManager(&audioRoutingManager);
3018 if (result != AUDIOCOMMON_RESULT_SUCCESS || audioRoutingManager == nullptr) {
3019 napi_create_int32(env, TEST_FAIL, &res);
3020 return res;
3021 }
3022 OH_AudioDevice_Flag deviceFlag = AUDIO_DEVICE_FLAG_ALL;
3023 OH_AudioDeviceDescriptorArray *array = nullptr;
3024 result = OH_AudioRoutingManager_GetDevices(audioRoutingManager, deviceFlag, &array);
3025 if (result != AUDIOCOMMON_RESULT_SUCCESS || array == nullptr) {
3026 napi_create_int32(env, TEST_FAIL, &res);
3027 return res;
3028 }
3029
3030 int size = array->size;
3031 for (int i = 0; i < size; i++) {
3032 OH_AudioDeviceDescriptor *descriptor = array->descriptors[i];
3033 if (descriptor == nullptr) {
3034 napi_create_int32(env, TEST_FAIL, &res);
3035 return res;
3036 }
3037 char* deviceName;
3038 result = OH_AudioDeviceDescriptor_GetDeviceName(descriptor, &deviceName);
3039 LOG("AudioAudioDeviceDescriptorGetDeviceName_001, result is: %{public}d", result);
3040 if (result != AUDIOCOMMON_RESULT_SUCCESS) {
3041 napi_create_int32(env, TEST_FAIL, &res);
3042 break;
3043 } else {
3044 napi_create_int32(env, TEST_PASS, &res);
3045 }
3046 }
3047 OH_AudioRoutingManager_ReleaseDevices(audioRoutingManager, array);
3048 return res;
3049 }
3050
AudioAudioDeviceDescriptorGetDeviceName_002(napi_env env,napi_callback_info info)3051 static napi_value AudioAudioDeviceDescriptorGetDeviceName_002(napi_env env, napi_callback_info info)
3052 {
3053 napi_value res;
3054 OH_AudioRoutingManager *audioRoutingManager = nullptr;
3055 OH_AudioCommon_Result result = OH_AudioManager_GetAudioRoutingManager(&audioRoutingManager);
3056 if (result != AUDIOCOMMON_RESULT_SUCCESS || audioRoutingManager == nullptr) {
3057 napi_create_int32(env, TEST_FAIL, &res);
3058 return res;
3059 }
3060 OH_AudioDevice_Flag deviceFlag = AUDIO_DEVICE_FLAG_OUTPUT;
3061 OH_AudioDeviceDescriptorArray *array = nullptr;
3062 result = OH_AudioRoutingManager_GetDevices(audioRoutingManager, deviceFlag, &array);
3063 OH_AudioDeviceDescriptor *descriptor = array->descriptors[0];
3064 if (result != AUDIOCOMMON_RESULT_SUCCESS || array == nullptr || descriptor == nullptr) {
3065 napi_create_int32(env, TEST_FAIL, &res);
3066 return res;
3067 }
3068
3069 result = OH_AudioDeviceDescriptor_GetDeviceName(descriptor, nullptr);
3070 LOG("AudioAudioDeviceDescriptorGetDeviceName_002, result is: %{public}d", result);
3071 if (result != AUDIOCOMMON_RESULT_ERROR_INVALID_PARAM) {
3072 napi_create_int32(env, TEST_FAIL, &res);
3073 } else {
3074 napi_create_int32(env, TEST_PASS, &res);
3075 }
3076 return res;
3077 }
3078
AudioAudioDeviceDescriptorGetDeviceName_003(napi_env env,napi_callback_info info)3079 static napi_value AudioAudioDeviceDescriptorGetDeviceName_003(napi_env env, napi_callback_info info)
3080 {
3081 napi_value res;
3082 OH_AudioDeviceDescriptor *descriptor = nullptr;
3083 char* deviceName;
3084 OH_AudioCommon_Result result = OH_AudioDeviceDescriptor_GetDeviceName(descriptor, &deviceName);
3085 LOG("AudioAudioDeviceDescriptorGetDeviceName_003, result is: %{public}d", result);
3086 if (result != AUDIOCOMMON_RESULT_ERROR_INVALID_PARAM) {
3087 napi_create_int32(env, TEST_FAIL, &res);
3088 } else {
3089 napi_create_int32(env, TEST_PASS, &res);
3090 }
3091 return res;
3092 }
3093
AudioAudioDeviceDescriptorGetDeviceAddress_001(napi_env env,napi_callback_info info)3094 static napi_value AudioAudioDeviceDescriptorGetDeviceAddress_001(napi_env env, napi_callback_info info)
3095 {
3096 napi_value res;
3097 OH_AudioRoutingManager *audioRoutingManager = nullptr;
3098 OH_AudioCommon_Result result = OH_AudioManager_GetAudioRoutingManager(&audioRoutingManager);
3099 if (result != AUDIOCOMMON_RESULT_SUCCESS || audioRoutingManager == nullptr) {
3100 napi_create_int32(env, TEST_FAIL, &res);
3101 return res;
3102 }
3103 OH_AudioDevice_Flag deviceFlag = AUDIO_DEVICE_FLAG_ALL;
3104 OH_AudioDeviceDescriptorArray *array = nullptr;
3105 result = OH_AudioRoutingManager_GetDevices(audioRoutingManager, deviceFlag, &array);
3106 if (result != AUDIOCOMMON_RESULT_SUCCESS || array == nullptr) {
3107 napi_create_int32(env, TEST_FAIL, &res);
3108 return res;
3109 }
3110
3111 int size = array->size;
3112 for (int i = 0; i < size; i++) {
3113 OH_AudioDeviceDescriptor *descriptor = array->descriptors[i];
3114 if (descriptor == nullptr) {
3115 napi_create_int32(env, TEST_FAIL, &res);
3116 return res;
3117 }
3118 char *address;
3119 result = OH_AudioDeviceDescriptor_GetDeviceAddress(descriptor, &address);
3120 LOG("AudioAudioDeviceDescriptorGetDeviceAddress_001, result is: %{public}d", result);
3121 if (result != AUDIOCOMMON_RESULT_SUCCESS) {
3122 napi_create_int32(env, TEST_FAIL, &res);
3123 break;
3124 } else {
3125 napi_create_int32(env, TEST_PASS, &res);
3126 }
3127 }
3128 OH_AudioRoutingManager_ReleaseDevices(audioRoutingManager, array);
3129 return res;
3130 }
3131
AudioAudioDeviceDescriptorGetDeviceAddress_002(napi_env env,napi_callback_info info)3132 static napi_value AudioAudioDeviceDescriptorGetDeviceAddress_002(napi_env env, napi_callback_info info)
3133 {
3134 napi_value res;
3135 OH_AudioRoutingManager *audioRoutingManager = nullptr;
3136 OH_AudioCommon_Result result = OH_AudioManager_GetAudioRoutingManager(&audioRoutingManager);
3137 if (result != AUDIOCOMMON_RESULT_SUCCESS || audioRoutingManager == nullptr) {
3138 napi_create_int32(env, TEST_FAIL, &res);
3139 return res;
3140 }
3141 OH_AudioDevice_Flag deviceFlag = AUDIO_DEVICE_FLAG_OUTPUT;
3142 OH_AudioDeviceDescriptorArray *array = nullptr;
3143 result = OH_AudioRoutingManager_GetDevices(audioRoutingManager, deviceFlag, &array);
3144 OH_AudioDeviceDescriptor *descriptor = array->descriptors[0];
3145 if (result != AUDIOCOMMON_RESULT_SUCCESS || array == nullptr || descriptor == nullptr) {
3146 napi_create_int32(env, TEST_FAIL, &res);
3147 return res;
3148 }
3149
3150 result = OH_AudioDeviceDescriptor_GetDeviceAddress(descriptor, nullptr);
3151 LOG("AudioAudioDeviceDescriptorGetDeviceAddress_002, result is: %{public}d", result);
3152 if (result != AUDIOCOMMON_RESULT_ERROR_INVALID_PARAM) {
3153 napi_create_int32(env, TEST_FAIL, &res);
3154 } else {
3155 napi_create_int32(env, TEST_PASS, &res);
3156 }
3157 return res;
3158 }
3159
AudioAudioDeviceDescriptorGetDeviceAddress_003(napi_env env,napi_callback_info info)3160 static napi_value AudioAudioDeviceDescriptorGetDeviceAddress_003(napi_env env, napi_callback_info info)
3161 {
3162 napi_value res;
3163 OH_AudioDeviceDescriptor *descriptor = nullptr;
3164 char *address;
3165 OH_AudioCommon_Result result = OH_AudioDeviceDescriptor_GetDeviceAddress(descriptor, &address);
3166 LOG("AudioAudioDeviceDescriptorGetDeviceAddress_003, result is: %{public}d", result);
3167 if (result != AUDIOCOMMON_RESULT_ERROR_INVALID_PARAM) {
3168 napi_create_int32(env, TEST_FAIL, &res);
3169 } else {
3170 napi_create_int32(env, TEST_PASS, &res);
3171 }
3172 return res;
3173 }
3174
AudioAudioDeviceDescriptorGetDeviceSampleRates_001(napi_env env,napi_callback_info info)3175 static napi_value AudioAudioDeviceDescriptorGetDeviceSampleRates_001(napi_env env, napi_callback_info info)
3176 {
3177 napi_value res;
3178 OH_AudioRoutingManager *audioRoutingManager = nullptr;
3179 OH_AudioCommon_Result result = OH_AudioManager_GetAudioRoutingManager(&audioRoutingManager);
3180 if (result != AUDIOCOMMON_RESULT_SUCCESS || audioRoutingManager == nullptr) {
3181 napi_create_int32(env, TEST_FAIL, &res);
3182 return res;
3183 }
3184 OH_AudioDevice_Flag deviceFlag = AUDIO_DEVICE_FLAG_ALL;
3185 OH_AudioDeviceDescriptorArray *array = nullptr;
3186 result = OH_AudioRoutingManager_GetDevices(audioRoutingManager, deviceFlag, &array);
3187 if (result != AUDIOCOMMON_RESULT_SUCCESS || array == nullptr) {
3188 napi_create_int32(env, TEST_FAIL, &res);
3189 return res;
3190 }
3191
3192 int size = array->size;
3193 for (int i = 0; i < size; i++) {
3194 OH_AudioDeviceDescriptor *descriptor = array->descriptors[i];
3195 if (descriptor == nullptr) {
3196 napi_create_int32(env, TEST_FAIL, &res);
3197 return res;
3198 }
3199 uint32_t *sampleRates;
3200 uint32_t size = 0;
3201 result = OH_AudioDeviceDescriptor_GetDeviceSampleRates(descriptor, &sampleRates, &size);
3202 LOG("AudioAudioDeviceDescriptorGetDeviceSampleRates_001, result is: %{public}d", result);
3203 if (result != AUDIOCOMMON_RESULT_SUCCESS) {
3204 napi_create_int32(env, TEST_FAIL, &res);
3205 break;
3206 } else {
3207 napi_create_int32(env, TEST_PASS, &res);
3208 }
3209 }
3210 OH_AudioRoutingManager_ReleaseDevices(audioRoutingManager, array);
3211 return res;
3212 }
3213
AudioAudioDeviceDescriptorGetDeviceSampleRates_002(napi_env env,napi_callback_info info)3214 static napi_value AudioAudioDeviceDescriptorGetDeviceSampleRates_002(napi_env env, napi_callback_info info)
3215 {
3216 napi_value res;
3217 OH_AudioRoutingManager *audioRoutingManager = nullptr;
3218 OH_AudioCommon_Result result = OH_AudioManager_GetAudioRoutingManager(&audioRoutingManager);
3219 if (result != AUDIOCOMMON_RESULT_SUCCESS || audioRoutingManager == nullptr) {
3220 napi_create_int32(env, TEST_FAIL, &res);
3221 return res;
3222 }
3223 OH_AudioDevice_Flag deviceFlag = AUDIO_DEVICE_FLAG_OUTPUT;
3224 OH_AudioDeviceDescriptorArray *array = nullptr;
3225 result = OH_AudioRoutingManager_GetDevices(audioRoutingManager, deviceFlag, &array);
3226 OH_AudioDeviceDescriptor *descriptor = array->descriptors[0];
3227 if (result != AUDIOCOMMON_RESULT_SUCCESS || array == nullptr || descriptor == nullptr) {
3228 napi_create_int32(env, TEST_FAIL, &res);
3229 return res;
3230 }
3231
3232 uint32_t size = 0;
3233 result = OH_AudioDeviceDescriptor_GetDeviceSampleRates(descriptor, nullptr, &size);
3234 LOG("AudioAudioDeviceDescriptorGetDeviceSampleRates_002, result is: %{public}d", result);
3235 if (result != AUDIOCOMMON_RESULT_ERROR_INVALID_PARAM) {
3236 napi_create_int32(env, TEST_FAIL, &res);
3237 } else {
3238 napi_create_int32(env, TEST_PASS, &res);
3239 }
3240 return res;
3241 }
3242
AudioAudioDeviceDescriptorGetDeviceSampleRates_003(napi_env env,napi_callback_info info)3243 static napi_value AudioAudioDeviceDescriptorGetDeviceSampleRates_003(napi_env env, napi_callback_info info)
3244 {
3245 napi_value res;
3246 OH_AudioRoutingManager *audioRoutingManager = nullptr;
3247 OH_AudioCommon_Result result = OH_AudioManager_GetAudioRoutingManager(&audioRoutingManager);
3248 if (result != AUDIOCOMMON_RESULT_SUCCESS || audioRoutingManager == nullptr) {
3249 napi_create_int32(env, TEST_FAIL, &res);
3250 return res;
3251 }
3252 OH_AudioDevice_Flag deviceFlag = AUDIO_DEVICE_FLAG_OUTPUT;
3253 OH_AudioDeviceDescriptorArray *array = nullptr;
3254 result = OH_AudioRoutingManager_GetDevices(audioRoutingManager, deviceFlag, &array);
3255 OH_AudioDeviceDescriptor *descriptor = array->descriptors[0];
3256 if (result != AUDIOCOMMON_RESULT_SUCCESS || array == nullptr || descriptor == nullptr) {
3257 napi_create_int32(env, TEST_FAIL, &res);
3258 return res;
3259 }
3260
3261 uint32_t *sampleRates;
3262 result = OH_AudioDeviceDescriptor_GetDeviceSampleRates(descriptor, &sampleRates, nullptr);
3263 LOG("AudioAudioDeviceDescriptorGetDeviceSampleRates_003, result is: %{public}d", result);
3264 if (result != AUDIOCOMMON_RESULT_ERROR_INVALID_PARAM) {
3265 napi_create_int32(env, TEST_FAIL, &res);
3266 } else {
3267 napi_create_int32(env, TEST_PASS, &res);
3268 }
3269 return res;
3270 }
3271
AudioAudioDeviceDescriptorGetDeviceSampleRates_004(napi_env env,napi_callback_info info)3272 static napi_value AudioAudioDeviceDescriptorGetDeviceSampleRates_004(napi_env env, napi_callback_info info)
3273 {
3274 napi_value res;
3275 OH_AudioDeviceDescriptor *descriptor = nullptr;
3276 uint32_t *sampleRates;
3277 uint32_t size = 0;
3278 OH_AudioCommon_Result result = OH_AudioDeviceDescriptor_GetDeviceSampleRates(descriptor, &sampleRates, &size);
3279 LOG("AudioAudioDeviceDescriptorGetDeviceSampleRates_004, result is: %{public}d", result);
3280 if (result != AUDIOCOMMON_RESULT_ERROR_INVALID_PARAM) {
3281 napi_create_int32(env, TEST_FAIL, &res);
3282 } else {
3283 napi_create_int32(env, TEST_PASS, &res);
3284 }
3285 return res;
3286 }
3287
AudioAudioDeviceDescriptorGetDeviceChannelCounts_001(napi_env env,napi_callback_info info)3288 static napi_value AudioAudioDeviceDescriptorGetDeviceChannelCounts_001(napi_env env, napi_callback_info info)
3289 {
3290 napi_value res;
3291 OH_AudioRoutingManager *audioRoutingManager = nullptr;
3292 OH_AudioCommon_Result result = OH_AudioManager_GetAudioRoutingManager(&audioRoutingManager);
3293 if (result != AUDIOCOMMON_RESULT_SUCCESS || audioRoutingManager == nullptr) {
3294 napi_create_int32(env, TEST_FAIL, &res);
3295 return res;
3296 }
3297 OH_AudioDevice_Flag deviceFlag = AUDIO_DEVICE_FLAG_ALL;
3298 OH_AudioDeviceDescriptorArray *array = nullptr;
3299 result = OH_AudioRoutingManager_GetDevices(audioRoutingManager, deviceFlag, &array);
3300 if (result != AUDIOCOMMON_RESULT_SUCCESS || array == nullptr) {
3301 napi_create_int32(env, TEST_FAIL, &res);
3302 return res;
3303 }
3304
3305 int size = array->size;
3306 for (int i = 0; i < size; i++) {
3307 OH_AudioDeviceDescriptor *descriptor = array->descriptors[i];
3308 if (descriptor == nullptr) {
3309 napi_create_int32(env, TEST_FAIL, &res);
3310 return res;
3311 }
3312 uint32_t *channelCounts;
3313 uint32_t channelSize = 0;
3314 result = OH_AudioDeviceDescriptor_GetDeviceChannelCounts(descriptor, &channelCounts, &channelSize);
3315 LOG("AudioAudioDeviceDescriptorGetDeviceChannelCounts_001, result is: %{public}d", result);
3316 if (result != AUDIOCOMMON_RESULT_SUCCESS) {
3317 napi_create_int32(env, TEST_FAIL, &res);
3318 break;
3319 } else {
3320 napi_create_int32(env, TEST_PASS, &res);
3321 }
3322 }
3323 OH_AudioRoutingManager_ReleaseDevices(audioRoutingManager, array);
3324 return res;
3325 }
3326
AudioAudioDeviceDescriptorGetDeviceChannelCounts_002(napi_env env,napi_callback_info info)3327 static napi_value AudioAudioDeviceDescriptorGetDeviceChannelCounts_002(napi_env env, napi_callback_info info)
3328 {
3329 napi_value res;
3330 OH_AudioRoutingManager *audioRoutingManager = nullptr;
3331 OH_AudioCommon_Result result = OH_AudioManager_GetAudioRoutingManager(&audioRoutingManager);
3332 if (result != AUDIOCOMMON_RESULT_SUCCESS || audioRoutingManager == nullptr) {
3333 napi_create_int32(env, TEST_FAIL, &res);
3334 return res;
3335 }
3336 OH_AudioDevice_Flag deviceFlag = AUDIO_DEVICE_FLAG_OUTPUT;
3337 OH_AudioDeviceDescriptorArray *array = nullptr;
3338 result = OH_AudioRoutingManager_GetDevices(audioRoutingManager, deviceFlag, &array);
3339 OH_AudioDeviceDescriptor *descriptor = array->descriptors[0];
3340 if (result != AUDIOCOMMON_RESULT_SUCCESS || array == nullptr || descriptor == nullptr) {
3341 napi_create_int32(env, TEST_FAIL, &res);
3342 return res;
3343 }
3344
3345 uint32_t channelSize = 0;
3346 result = OH_AudioDeviceDescriptor_GetDeviceChannelCounts(descriptor, nullptr, &channelSize);
3347 LOG("AudioAudioDeviceDescriptorGetDeviceChannelCounts_002, result is: %{public}d", result);
3348 if (result != AUDIOCOMMON_RESULT_ERROR_INVALID_PARAM) {
3349 napi_create_int32(env, TEST_FAIL, &res);
3350 } else {
3351 napi_create_int32(env, TEST_PASS, &res);
3352 }
3353 return res;
3354 }
3355
AudioAudioDeviceDescriptorGetDeviceChannelCounts_003(napi_env env,napi_callback_info info)3356 static napi_value AudioAudioDeviceDescriptorGetDeviceChannelCounts_003(napi_env env, napi_callback_info info)
3357 {
3358 napi_value res;
3359 OH_AudioRoutingManager *audioRoutingManager = nullptr;
3360 OH_AudioCommon_Result result = OH_AudioManager_GetAudioRoutingManager(&audioRoutingManager);
3361 if (result != AUDIOCOMMON_RESULT_SUCCESS || audioRoutingManager == nullptr) {
3362 napi_create_int32(env, TEST_FAIL, &res);
3363 return res;
3364 }
3365 OH_AudioDevice_Flag deviceFlag = AUDIO_DEVICE_FLAG_OUTPUT;
3366 OH_AudioDeviceDescriptorArray *array = nullptr;
3367 result = OH_AudioRoutingManager_GetDevices(audioRoutingManager, deviceFlag, &array);
3368 OH_AudioDeviceDescriptor *descriptor = array->descriptors[0];
3369 if (result != AUDIOCOMMON_RESULT_SUCCESS || array == nullptr || descriptor == nullptr) {
3370 napi_create_int32(env, TEST_FAIL, &res);
3371 return res;
3372 }
3373
3374 uint32_t *channelCounts;
3375 result = OH_AudioDeviceDescriptor_GetDeviceChannelCounts(descriptor, &channelCounts, nullptr);
3376 LOG("AudioAudioDeviceDescriptorGetDeviceChannelCounts_003, result is: %{public}d", result);
3377 if (result != AUDIOCOMMON_RESULT_ERROR_INVALID_PARAM) {
3378 napi_create_int32(env, TEST_FAIL, &res);
3379 } else {
3380 napi_create_int32(env, TEST_PASS, &res);
3381 }
3382 return res;
3383 }
3384
AudioAudioDeviceDescriptorGetDeviceChannelCounts_004(napi_env env,napi_callback_info info)3385 static napi_value AudioAudioDeviceDescriptorGetDeviceChannelCounts_004(napi_env env, napi_callback_info info)
3386 {
3387 napi_value res;
3388 OH_AudioDeviceDescriptor *descriptor = nullptr;
3389 uint32_t *channelCounts;
3390 uint32_t channelSize = 0;
3391 OH_AudioCommon_Result result = OH_AudioDeviceDescriptor_GetDeviceChannelCounts(
3392 descriptor, &channelCounts, &channelSize);
3393 LOG("AudioAudioDeviceDescriptorGetDeviceChannelCounts_004, result is: %{public}d", result);
3394 if (result != AUDIOCOMMON_RESULT_ERROR_INVALID_PARAM) {
3395 napi_create_int32(env, TEST_FAIL, &res);
3396 } else {
3397 napi_create_int32(env, TEST_PASS, &res);
3398 }
3399 return res;
3400 }
3401
AudioAudioDeviceDescriptorGetDeviceDisplayName_001(napi_env env,napi_callback_info info)3402 static napi_value AudioAudioDeviceDescriptorGetDeviceDisplayName_001(napi_env env, napi_callback_info info)
3403 {
3404 napi_value res;
3405 OH_AudioRoutingManager *audioRoutingManager = nullptr;
3406 OH_AudioCommon_Result result = OH_AudioManager_GetAudioRoutingManager(&audioRoutingManager);
3407 if (result != AUDIOCOMMON_RESULT_SUCCESS || audioRoutingManager == nullptr) {
3408 napi_create_int32(env, TEST_FAIL, &res);
3409 return res;
3410 }
3411 OH_AudioDevice_Flag deviceFlag = AUDIO_DEVICE_FLAG_ALL;
3412 OH_AudioDeviceDescriptorArray *array = nullptr;
3413 result = OH_AudioRoutingManager_GetDevices(audioRoutingManager, deviceFlag, &array);
3414 if (result != AUDIOCOMMON_RESULT_SUCCESS || array == nullptr) {
3415 napi_create_int32(env, TEST_FAIL, &res);
3416 return res;
3417 }
3418
3419 int size = array->size;
3420 for (int i = 0; i < size; i++) {
3421 OH_AudioDeviceDescriptor *descriptor = array->descriptors[i];
3422 if (descriptor == nullptr) {
3423 napi_create_int32(env, TEST_FAIL, &res);
3424 return res;
3425 }
3426 char *displayName;
3427 result = OH_AudioDeviceDescriptor_GetDeviceDisplayName(descriptor, &displayName);
3428 LOG("AudioAudioDeviceDescriptorGetDeviceDisplayName_001, result is: %{public}d", result);
3429 if (result != AUDIOCOMMON_RESULT_SUCCESS) {
3430 napi_create_int32(env, TEST_FAIL, &res);
3431 break;
3432 } else {
3433 napi_create_int32(env, TEST_PASS, &res);
3434 }
3435 }
3436 OH_AudioRoutingManager_ReleaseDevices(audioRoutingManager, array);
3437 return res;
3438 }
3439
AudioAudioDeviceDescriptorGetDeviceDisplayName_002(napi_env env,napi_callback_info info)3440 static napi_value AudioAudioDeviceDescriptorGetDeviceDisplayName_002(napi_env env, napi_callback_info info)
3441 {
3442 napi_value res;
3443 OH_AudioRoutingManager *audioRoutingManager = nullptr;
3444 OH_AudioCommon_Result result = OH_AudioManager_GetAudioRoutingManager(&audioRoutingManager);
3445 if (result != AUDIOCOMMON_RESULT_SUCCESS || audioRoutingManager == nullptr) {
3446 napi_create_int32(env, TEST_FAIL, &res);
3447 return res;
3448 }
3449 OH_AudioDevice_Flag deviceFlag = AUDIO_DEVICE_FLAG_OUTPUT;
3450 OH_AudioDeviceDescriptorArray *array = nullptr;
3451 result = OH_AudioRoutingManager_GetDevices(audioRoutingManager, deviceFlag, &array);
3452 OH_AudioDeviceDescriptor *descriptor = array->descriptors[0];
3453 if (result != AUDIOCOMMON_RESULT_SUCCESS || array == nullptr || descriptor == nullptr) {
3454 napi_create_int32(env, TEST_FAIL, &res);
3455 return res;
3456 }
3457
3458 result = OH_AudioDeviceDescriptor_GetDeviceDisplayName(descriptor, nullptr);
3459 LOG("AudioAudioDeviceDescriptorGetDeviceDisplayName_002, result is: %{public}d", result);
3460 if (result != AUDIOCOMMON_RESULT_ERROR_INVALID_PARAM) {
3461 napi_create_int32(env, TEST_FAIL, &res);
3462 } else {
3463 napi_create_int32(env, TEST_PASS, &res);
3464 }
3465 return res;
3466 }
3467
AudioAudioDeviceDescriptorGetDeviceDisplayName_003(napi_env env,napi_callback_info info)3468 static napi_value AudioAudioDeviceDescriptorGetDeviceDisplayName_003(napi_env env, napi_callback_info info)
3469 {
3470 napi_value res;
3471 OH_AudioDeviceDescriptor *descriptor = nullptr;
3472 char *displayName;
3473 OH_AudioCommon_Result result = OH_AudioDeviceDescriptor_GetDeviceDisplayName(descriptor, &displayName);
3474 LOG("AudioAudioDeviceDescriptorGetDeviceDisplayName_003, result is: %{public}d", result);
3475 if (result != AUDIOCOMMON_RESULT_ERROR_INVALID_PARAM) {
3476 napi_create_int32(env, TEST_FAIL, &res);
3477 } else {
3478 napi_create_int32(env, TEST_PASS, &res);
3479 }
3480 return res;
3481 }
3482
AudioAudioDeviceDescriptorGetDeviceEncodingTypes_001(napi_env env,napi_callback_info info)3483 static napi_value AudioAudioDeviceDescriptorGetDeviceEncodingTypes_001(napi_env env, napi_callback_info info)
3484 {
3485 napi_value res;
3486 OH_AudioRoutingManager *audioRoutingManager = nullptr;
3487 OH_AudioCommon_Result result = OH_AudioManager_GetAudioRoutingManager(&audioRoutingManager);
3488 if (result != AUDIOCOMMON_RESULT_SUCCESS || audioRoutingManager == nullptr) {
3489 napi_create_int32(env, TEST_FAIL, &res);
3490 return res;
3491 }
3492 OH_AudioDevice_Flag deviceFlag = AUDIO_DEVICE_FLAG_ALL;
3493 OH_AudioDeviceDescriptorArray *array = nullptr;
3494 result = OH_AudioRoutingManager_GetDevices(audioRoutingManager, deviceFlag, &array);
3495 if (result != AUDIOCOMMON_RESULT_SUCCESS || array == nullptr) {
3496 napi_create_int32(env, TEST_FAIL, &res);
3497 return res;
3498 }
3499
3500 int size = array->size;
3501 for (int i = 0; i < size; i++) {
3502 OH_AudioDeviceDescriptor *descriptor = array->descriptors[i];
3503 if (descriptor == nullptr) {
3504 napi_create_int32(env, TEST_FAIL, &res);
3505 return res;
3506 }
3507 OH_AudioStream_EncodingType *encodingTypes;
3508 uint32_t encodingTypeSize = 0;
3509 result = OH_AudioDeviceDescriptor_GetDeviceEncodingTypes(descriptor, &encodingTypes, &encodingTypeSize);
3510 LOG("AudioAudioDeviceDescriptorGetDeviceEncodingTypes_001, result is: %{public}d", result);
3511 if (result != AUDIOCOMMON_RESULT_SUCCESS) {
3512 napi_create_int32(env, TEST_FAIL, &res);
3513 break;
3514 } else {
3515 napi_create_int32(env, TEST_PASS, &res);
3516 }
3517 }
3518 OH_AudioRoutingManager_ReleaseDevices(audioRoutingManager, array);
3519 return res;
3520 }
3521
AudioAudioDeviceDescriptorGetDeviceEncodingTypes_002(napi_env env,napi_callback_info info)3522 static napi_value AudioAudioDeviceDescriptorGetDeviceEncodingTypes_002(napi_env env, napi_callback_info info)
3523 {
3524 napi_value res;
3525 OH_AudioRoutingManager *audioRoutingManager = nullptr;
3526 OH_AudioCommon_Result result = OH_AudioManager_GetAudioRoutingManager(&audioRoutingManager);
3527 if (result != AUDIOCOMMON_RESULT_SUCCESS || audioRoutingManager == nullptr) {
3528 napi_create_int32(env, TEST_FAIL, &res);
3529 return res;
3530 }
3531 OH_AudioDevice_Flag deviceFlag = AUDIO_DEVICE_FLAG_OUTPUT;
3532 OH_AudioDeviceDescriptorArray *array = nullptr;
3533 result = OH_AudioRoutingManager_GetDevices(audioRoutingManager, deviceFlag, &array);
3534 OH_AudioDeviceDescriptor *descriptor = array->descriptors[0];
3535 if (result != AUDIOCOMMON_RESULT_SUCCESS || array == nullptr || descriptor == nullptr) {
3536 napi_create_int32(env, TEST_FAIL, &res);
3537 return res;
3538 }
3539
3540 uint32_t encodingTypeSize = 0;
3541 result = OH_AudioDeviceDescriptor_GetDeviceEncodingTypes(descriptor, nullptr, &encodingTypeSize);
3542 LOG("AudioAudioDeviceDescriptorGetDeviceEncodingTypes_002, result is: %{public}d", result);
3543 if (result != AUDIOCOMMON_RESULT_ERROR_INVALID_PARAM) {
3544 napi_create_int32(env, TEST_FAIL, &res);
3545 } else {
3546 napi_create_int32(env, TEST_PASS, &res);
3547 }
3548 return res;
3549 }
3550
AudioAudioDeviceDescriptorGetDeviceEncodingTypes_003(napi_env env,napi_callback_info info)3551 static napi_value AudioAudioDeviceDescriptorGetDeviceEncodingTypes_003(napi_env env, napi_callback_info info)
3552 {
3553 napi_value res;
3554 OH_AudioRoutingManager *audioRoutingManager = nullptr;
3555 OH_AudioCommon_Result result = OH_AudioManager_GetAudioRoutingManager(&audioRoutingManager);
3556 if (result != AUDIOCOMMON_RESULT_SUCCESS || audioRoutingManager == nullptr) {
3557 napi_create_int32(env, TEST_FAIL, &res);
3558 return res;
3559 }
3560 OH_AudioDevice_Flag deviceFlag = AUDIO_DEVICE_FLAG_OUTPUT;
3561 OH_AudioDeviceDescriptorArray *array = nullptr;
3562 result = OH_AudioRoutingManager_GetDevices(audioRoutingManager, deviceFlag, &array);
3563 OH_AudioDeviceDescriptor *descriptor = array->descriptors[0];
3564 if (result != AUDIOCOMMON_RESULT_SUCCESS || array == nullptr || descriptor == nullptr) {
3565 napi_create_int32(env, TEST_FAIL, &res);
3566 return res;
3567 }
3568
3569 OH_AudioStream_EncodingType *encodingTypes;
3570 result = OH_AudioDeviceDescriptor_GetDeviceEncodingTypes(descriptor, &encodingTypes, nullptr);
3571 LOG("AudioAudioDeviceDescriptorGetDeviceEncodingTypes_003, result is: %{public}d", result);
3572 if (result != AUDIOCOMMON_RESULT_ERROR_INVALID_PARAM) {
3573 napi_create_int32(env, TEST_FAIL, &res);
3574 } else {
3575 napi_create_int32(env, TEST_PASS, &res);
3576 }
3577 return res;
3578 }
3579
AudioAudioDeviceDescriptorGetDeviceEncodingTypes_004(napi_env env,napi_callback_info info)3580 static napi_value AudioAudioDeviceDescriptorGetDeviceEncodingTypes_004(napi_env env, napi_callback_info info)
3581 {
3582 napi_value res;
3583 OH_AudioDeviceDescriptor *descriptor = nullptr;
3584 OH_AudioStream_EncodingType *encodingTypes;
3585 uint32_t encodingTypeSize = 0;
3586 OH_AudioCommon_Result result = OH_AudioDeviceDescriptor_GetDeviceEncodingTypes(
3587 descriptor, &encodingTypes, &encodingTypeSize);
3588 LOG("AudioAudioDeviceDescriptorGetDeviceEncodingTypes_004, result is: %{public}d", result);
3589 if (result != AUDIOCOMMON_RESULT_ERROR_INVALID_PARAM) {
3590 napi_create_int32(env, TEST_FAIL, &res);
3591 } else {
3592 napi_create_int32(env, TEST_PASS, &res);
3593 }
3594 return res;
3595 }
3596
AudioAudioInternalRecordingSuccess01(napi_env env,napi_callback_info info)3597 static napi_value AudioAudioInternalRecordingSuccess01(napi_env env, napi_callback_info info)
3598 {
3599 OH_AudioStreamBuilder *builder = CreateRenderBuilder();
3600 OH_AudioRenderer *audioRenderer;
3601 OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
3602 OH_AudioStream_PrivacyType type = AUDIO_STREAM_PRIVACY_TYPE_PUBLIC;
3603 OH_AudioStream_Result result = OH_AudioStreamBuilder_SetRendererPrivacy(builder, type);
3604 OH_AudioRenderer_Release(audioRenderer);
3605 OH_AudioStreamBuilder_Destroy(builder);
3606 napi_value res;
3607 napi_create_int32(env, result, &res);
3608 return res;
3609 }
3610
AudioAudioInternalRecordingSuccess02(napi_env env,napi_callback_info info)3611 static napi_value AudioAudioInternalRecordingSuccess02(napi_env env, napi_callback_info info)
3612 {
3613 OH_AudioStreamBuilder *builder = CreateRenderBuilder();
3614 OH_AudioStream_PrivacyType type = AUDIO_STREAM_PRIVACY_TYPE_PRIVATE;
3615 OH_AudioStream_Result result = OH_AudioStreamBuilder_SetRendererPrivacy(builder, type);
3616 OH_AudioRenderer *audioRenderer = nullptr;
3617 OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
3618 OH_AudioStream_PrivacyType type_get;
3619 OH_AudioStream_Result result1 = OH_AudioRenderer_GetRendererPrivacy(audioRenderer, &type_get);
3620 if (result == AUDIOSTREAM_SUCCESS && result1 == AUDIOSTREAM_SUCCESS
3621 && type_get == AUDIO_STREAM_PRIVACY_TYPE_PRIVATE) {
3622 result = AUDIOSTREAM_SUCCESS;
3623 } else {
3624 result = AUDIOSTREAM_ERROR_INVALID_PARAM;
3625 };
3626 OH_AudioRenderer_Release(audioRenderer);
3627 OH_AudioStreamBuilder_Destroy(builder);
3628 napi_value res;
3629 napi_create_int32(env, result, &res);
3630 return res;
3631 }
3632
AudioAudioInternalRecordingFalse(napi_env env,napi_callback_info info)3633 static napi_value AudioAudioInternalRecordingFalse(napi_env env, napi_callback_info info)
3634 {
3635 OH_AudioStreamBuilder *builder = CreateRenderBuilder();
3636 OH_AudioRenderer *audioRenderer;
3637 OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
3638 OH_AudioStream_PrivacyType type = static_cast<OH_AudioStream_PrivacyType>(2);
3639 OH_AudioStream_Result result = OH_AudioStreamBuilder_SetRendererPrivacy(builder, type);
3640 OH_AudioRenderer_Release(audioRenderer);
3641 OH_AudioStreamBuilder_Destroy(builder);
3642 napi_value res;
3643 napi_create_int32(env, result, &res);
3644 return res;
3645 }
3646
WriteDataCallbackWithValidResult(OH_AudioRenderer * renderer,void * userData,void * buffer,int32_t bufferLen)3647 static OH_AudioData_Callback_Result WriteDataCallbackWithValidResult(OH_AudioRenderer* renderer,
3648 void* userData,
3649 void* buffer,
3650 int32_t bufferLen)
3651 {
3652 return AUDIO_DATA_CALLBACK_RESULT_VALID;
3653 }
3654
WriteDataCallbackWithInvalidResult(OH_AudioRenderer * renderer,void * userData,void * buffer,int32_t bufferLen)3655 static OH_AudioData_Callback_Result WriteDataCallbackWithInvalidResult(OH_AudioRenderer* renderer,
3656 void* userData,
3657 void* buffer,
3658 int32_t bufferLen)
3659 {
3660 return AUDIO_DATA_CALLBACK_RESULT_INVALID;
3661 }
3662
AudioStreamBuilderSetRendererWriteDataCallback_001(napi_env env,napi_callback_info info)3663 static napi_value AudioStreamBuilderSetRendererWriteDataCallback_001(napi_env env, napi_callback_info info)
3664 {
3665 OH_AudioStreamBuilder* builder;
3666 OH_AudioStream_Type type = AUDIOSTREAM_TYPE_RENDERER;
3667 OH_AudioStreamBuilder_Create(&builder, type);
3668 OH_AudioRenderer_OnWriteDataCallback onWriteDataCallback = WriteDataCallbackWithValidResult;
3669 OH_AudioStream_Result result = OH_AudioStreamBuilder_SetRendererWriteDataCallback(builder,
3670 onWriteDataCallback, nullptr);
3671 OH_AudioStreamBuilder_Destroy(builder);
3672 napi_value res;
3673 napi_create_int32(env, result, &res);
3674 return res;
3675 }
3676
AudioStreamBuilderSetRendererWriteDataCallback_002(napi_env env,napi_callback_info info)3677 static napi_value AudioStreamBuilderSetRendererWriteDataCallback_002(napi_env env, napi_callback_info info)
3678 {
3679 OH_AudioStreamBuilder* builder;
3680 OH_AudioStream_Type type = AUDIOSTREAM_TYPE_RENDERER;
3681 OH_AudioStreamBuilder_Create(&builder, type);
3682 OH_AudioRenderer_OnWriteDataCallback onWriteDataCallback = WriteDataCallbackWithInvalidResult;
3683 OH_AudioStream_Result result = OH_AudioStreamBuilder_SetRendererWriteDataCallback(builder,
3684 onWriteDataCallback, nullptr);
3685 OH_AudioStreamBuilder_Destroy(builder);
3686 napi_value res;
3687 napi_create_int32(env, result, &res);
3688 return res;
3689 }
3690
audioCapturerGetOverflowCount_001(napi_env env,napi_callback_info info)3691 static napi_value audioCapturerGetOverflowCount_001(napi_env env, napi_callback_info info)
3692 {
3693 OH_AudioStreamBuilder* builder = CreateCapturerBuilder();
3694 int32_t samplingRate = 48000;
3695 OH_AudioStreamBuilder_SetSamplingRate(builder, samplingRate);
3696 int32_t channelCount = 2;
3697 OH_AudioStreamBuilder_SetChannelCount(builder, channelCount);
3698
3699 OH_AudioCapturer_Callbacks callbacks;
3700 callbacks.OH_AudioCapturer_OnReadData = AudioCapturerOnReadData;
3701 OH_AudioStreamBuilder_SetCapturerCallback(builder, callbacks, NULL);
3702
3703 OH_AudioCapturer* audioCapturer;
3704 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateCapturer(builder, &audioCapturer);
3705 result = OH_AudioCapturer_Start(audioCapturer);
3706
3707 uint32_t overFlowCount;
3708 result = OH_AudioCapturer_GetOverflowCount(audioCapturer, &overFlowCount);
3709
3710 OH_AudioCapturer_Stop(audioCapturer);
3711 OH_AudioCapturer_Release(audioCapturer);
3712
3713 OH_AudioStreamBuilder_Destroy(builder);
3714 napi_value res;
3715 napi_create_int32(env, result, &res);
3716 return res;
3717 }
3718
AudioSessionManagerStrategy_001(napi_env env,napi_callback_info info)3719 static napi_value AudioSessionManagerStrategy_001(napi_env env, napi_callback_info info)
3720 {
3721 napi_value res;
3722 OH_AudioSessionManager* audioSessionManager;
3723 OH_AudioCommon_Result resultManager = OH_AudioManager_GetAudioSessionManager(&audioSessionManager);
3724 if (resultManager != AUDIOCOMMON_RESULT_SUCCESS) {
3725 napi_create_int32(env, TEST_FAIL, &res);
3726 LOG("resultManager, result is: %{public}d", TEST_FAIL);
3727 return res;
3728 }
3729 OH_AudioSession_Strategy strategy = {
3730 CONCURRENCY_MIX_WITH_OTHERS
3731 };
3732 // 设置音频并发模式并激活音频会话
3733 OH_AudioCommon_Result resultActivate = OH_AudioSessionManager_ActivateAudioSession(audioSessionManager, &strategy);
3734 if (resultActivate != AUDIOCOMMON_RESULT_SUCCESS) {
3735 napi_create_int32(env, TEST_FAIL, &res);
3736 LOG("resultActivate, result is: %{public}d", TEST_FAIL);
3737 return res;
3738 }
3739
3740 // 查询音频会话是否已激活。
3741 bool isActivated = OH_AudioSessionManager_IsAudioSessionActivated(audioSessionManager);
3742 if (!isActivated) {
3743 napi_create_int32(env, TEST_FAIL, &res);
3744 LOG("isActivated, result is: %{public}d", TEST_FAIL);
3745 return res;
3746 }
3747
3748 // 监听音频会话停用事件
3749 OH_AudioCommon_Result resultRegister =
3750 OH_AudioSessionManager_RegisterSessionDeactivatedCallback(
3751 audioSessionManager, MyAudioSessionDeactivatedCallback);
3752 if (resultRegister != AUDIOCOMMON_RESULT_SUCCESS) {
3753 napi_create_int32(env, TEST_FAIL, &res);
3754 LOG("resultActivate, result is: %{public}d", TEST_FAIL);
3755 return res;
3756 }
3757
3758 // 等待1秒
3759 Delay(1);
3760
3761 // 取消监听音频会话停用事件
3762 OH_AudioCommon_Result resultUnregister =
3763 OH_AudioSessionManager_UnregisterSessionDeactivatedCallback(
3764 audioSessionManager, MyAudioSessionDeactivatedCallback);
3765 if (resultUnregister != AUDIOCOMMON_RESULT_SUCCESS) {
3766 napi_create_int32(env, TEST_FAIL, &res);
3767 LOG("resultUnregister, result is: %{public}d", TEST_FAIL);
3768 return res;
3769 }
3770
3771 // 停用音频会话
3772 OH_AudioCommon_Result resultDeactivate = OH_AudioSessionManager_DeactivateAudioSession(audioSessionManager);
3773 if (resultDeactivate != AUDIOCOMMON_RESULT_SUCCESS) {
3774 napi_create_int32(env, TEST_FAIL, &res);
3775 LOG("resultDeactivate, result is: %{public}d", TEST_FAIL);
3776 return res;
3777 }
3778
3779 // 查询音频会话是否已激活。
3780 isActivated = OH_AudioSessionManager_IsAudioSessionActivated(audioSessionManager);
3781 if (isActivated) {
3782 napi_create_int32(env, TEST_FAIL, &res);
3783 LOG("isActivated, result is: %{public}d", TEST_FAIL);
3784 return res;
3785 }
3786
3787 napi_create_int32(env, TEST_PASS, &res);
3788 return res;
3789 }
3790
3791
AudioSessionManagerStrategy_002(napi_env env,napi_callback_info info)3792 static napi_value AudioSessionManagerStrategy_002(napi_env env, napi_callback_info info)
3793 {
3794 napi_value res;
3795 OH_AudioSessionManager* audioSessionManager;
3796 OH_AudioCommon_Result resultManager = OH_AudioManager_GetAudioSessionManager(&audioSessionManager);
3797 if (resultManager != AUDIOCOMMON_RESULT_SUCCESS) {
3798 napi_create_int32(env, TEST_FAIL, &res);
3799 LOG("resultManager, result is: %{public}d", TEST_FAIL);
3800 return res;
3801 }
3802 OH_AudioSession_Strategy strategy = {
3803 CONCURRENCY_DEFAULT
3804 };
3805
3806 // 设置音频并发模式并激活音频会话
3807 OH_AudioCommon_Result resultActivate = OH_AudioSessionManager_ActivateAudioSession(audioSessionManager, &strategy);
3808 if (resultActivate != AUDIOCOMMON_RESULT_SUCCESS) {
3809 napi_create_int32(env, TEST_FAIL, &res);
3810 LOG("resultActivate, result is: %{public}d", TEST_FAIL);
3811 return res;
3812 }
3813
3814 // 查询音频会话是否已激活。
3815 bool isActivated = OH_AudioSessionManager_IsAudioSessionActivated(audioSessionManager);
3816 if (!isActivated) {
3817 napi_create_int32(env, TEST_FAIL, &res);
3818 LOG("isActivated, result is: %{public}d", TEST_FAIL);
3819 return res;
3820 }
3821
3822 // 监听音频会话停用事件
3823 OH_AudioCommon_Result resultRegister =
3824 OH_AudioSessionManager_RegisterSessionDeactivatedCallback(
3825 audioSessionManager, MyAudioSessionDeactivatedCallback);
3826 if (resultRegister != AUDIOCOMMON_RESULT_SUCCESS) {
3827 napi_create_int32(env, TEST_FAIL, &res);
3828 LOG("resultRegister, result is: %{public}d", TEST_FAIL);
3829 return res;
3830 }
3831 // sleep 1 seconds
3832 Delay(1);
3833
3834 // 取消监听音频会话停用事件
3835 OH_AudioCommon_Result resultUnregister =
3836 OH_AudioSessionManager_UnregisterSessionDeactivatedCallback(
3837 audioSessionManager, MyAudioSessionDeactivatedCallback);
3838 if (resultUnregister != AUDIOCOMMON_RESULT_SUCCESS) {
3839 napi_create_int32(env, TEST_FAIL, &res);
3840 LOG("resultUnregister, result is: %{public}d", TEST_FAIL);
3841 return res;
3842 }
3843
3844 // 停用音频会话
3845 OH_AudioCommon_Result resultDeactivate = OH_AudioSessionManager_DeactivateAudioSession(audioSessionManager);
3846 if (resultDeactivate != AUDIOCOMMON_RESULT_SUCCESS) {
3847 napi_create_int32(env, TEST_FAIL, &res);
3848 LOG("resultDeactivate, result is: %{public}d", TEST_FAIL);
3849 return res;
3850 }
3851
3852 napi_create_int32(env, TEST_PASS, &res);
3853 return res;
3854 }
3855
3856
AudioSessionManagerStrategy_003(napi_env env,napi_callback_info info)3857 static napi_value AudioSessionManagerStrategy_003(napi_env env, napi_callback_info info)
3858 {
3859 napi_value res;
3860 OH_AudioSessionManager* audioSessionManager;
3861 OH_AudioCommon_Result resultManager = OH_AudioManager_GetAudioSessionManager(&audioSessionManager);
3862 if (resultManager != AUDIOCOMMON_RESULT_SUCCESS) {
3863 napi_create_int32(env, TEST_FAIL, &res);
3864 LOG("resultDeactivate, result is: %{public}d", TEST_FAIL);
3865 return res;
3866 }
3867 OH_AudioSession_Strategy strategy = {
3868 CONCURRENCY_DUCK_OTHERS
3869 };
3870
3871 // 设置音频并发模式并激活音频会话
3872 OH_AudioCommon_Result resultActivate = OH_AudioSessionManager_ActivateAudioSession(audioSessionManager, &strategy);
3873 if (resultActivate != AUDIOCOMMON_RESULT_SUCCESS) {
3874 napi_create_int32(env, TEST_FAIL, &res);
3875 LOG("resultActivate, result is: %{public}d", TEST_FAIL);
3876 return res;
3877 }
3878
3879 // 查询音频会话是否已激活。
3880 bool isActivated = OH_AudioSessionManager_IsAudioSessionActivated(audioSessionManager);
3881 if (!isActivated) {
3882 napi_create_int32(env, TEST_FAIL, &res);
3883 LOG("isActivated, result is: %{public}d", TEST_FAIL);
3884 return res;
3885 }
3886
3887 // 监听音频会话停用事件
3888 OH_AudioCommon_Result resultRegister =
3889 OH_AudioSessionManager_RegisterSessionDeactivatedCallback(
3890 audioSessionManager, MyAudioSessionDeactivatedCallback);
3891 if (resultRegister != AUDIOCOMMON_RESULT_SUCCESS) {
3892 napi_create_int32(env, TEST_FAIL, &res);
3893 LOG("resultActivate, result is: %{public}d", TEST_FAIL);
3894 return res;
3895 }
3896 // sleep 1 seconds
3897 Delay(1);
3898
3899 // 取消监听音频会话停用事件
3900 OH_AudioCommon_Result resultUnregister =
3901 OH_AudioSessionManager_UnregisterSessionDeactivatedCallback(
3902 audioSessionManager, MyAudioSessionDeactivatedCallback);
3903 if (resultUnregister != AUDIOCOMMON_RESULT_SUCCESS) {
3904 napi_create_int32(env, TEST_FAIL, &res);
3905 LOG("resultUnregister, result is: %{public}d", TEST_FAIL);
3906 return res;
3907 }
3908
3909 // 停用音频会话
3910 OH_AudioCommon_Result resultDeactivate = OH_AudioSessionManager_DeactivateAudioSession(audioSessionManager);
3911 if (resultDeactivate != AUDIOCOMMON_RESULT_SUCCESS) {
3912 napi_create_int32(env, TEST_FAIL, &res);
3913 LOG("resultDeactivate, result is: %{public}d", TEST_FAIL);
3914 return res;
3915 }
3916
3917 napi_create_int32(env, TEST_PASS, &res);
3918 return res;
3919 }
3920
3921
AudioSessionManagerStrategy_004(napi_env env,napi_callback_info info)3922 static napi_value AudioSessionManagerStrategy_004(napi_env env, napi_callback_info info)
3923 {
3924 napi_value res;
3925 OH_AudioSessionManager* audioSessionManager;
3926 OH_AudioCommon_Result resultManager = OH_AudioManager_GetAudioSessionManager(&audioSessionManager);
3927 if (resultManager != AUDIOCOMMON_RESULT_SUCCESS) {
3928 napi_create_int32(env, TEST_FAIL, &res);
3929 LOG("resultManager, result is: %{public}d", TEST_FAIL);
3930 return res;
3931 }
3932 OH_AudioSession_Strategy strategy = {
3933 CONCURRENCY_PAUSE_OTHERS
3934 };
3935
3936 // 设置音频并发模式并激活音频会话
3937 OH_AudioCommon_Result resultActivate = OH_AudioSessionManager_ActivateAudioSession(audioSessionManager, &strategy);
3938 if (resultActivate != AUDIOCOMMON_RESULT_SUCCESS) {
3939 napi_create_int32(env, TEST_FAIL, &res);
3940 LOG("resultActivate, result is: %{public}d", TEST_FAIL);
3941 return res;
3942 }
3943
3944 // 查询音频会话是否已激活。
3945 bool isActivated = OH_AudioSessionManager_IsAudioSessionActivated(audioSessionManager);
3946 if (!isActivated) {
3947 napi_create_int32(env, TEST_FAIL, &res);
3948 LOG("isActivated, result is: %{public}d", TEST_FAIL);
3949 return res;
3950 }
3951
3952 // 监听音频会话停用事件
3953 OH_AudioCommon_Result resultRegister =
3954 OH_AudioSessionManager_RegisterSessionDeactivatedCallback(
3955 audioSessionManager, MyAudioSessionDeactivatedCallback);
3956 if (resultRegister != AUDIOCOMMON_RESULT_SUCCESS) {
3957 napi_create_int32(env, TEST_FAIL, &res);
3958 LOG("resultRegister, result is: %{public}d", TEST_FAIL);
3959 return res;
3960 }
3961 // sleep 1 seconds
3962 Delay(1);
3963
3964 // 取消监听音频会话停用事件
3965 OH_AudioCommon_Result resultUnregister =
3966 OH_AudioSessionManager_UnregisterSessionDeactivatedCallback(
3967 audioSessionManager, MyAudioSessionDeactivatedCallback);
3968 if (resultUnregister != AUDIOCOMMON_RESULT_SUCCESS) {
3969 napi_create_int32(env, TEST_FAIL, &res);
3970 LOG("resultUnregister, result is: %{public}d", TEST_FAIL);
3971 return res;
3972 }
3973
3974 // 停用音频会话
3975 OH_AudioCommon_Result resultDeactivate = OH_AudioSessionManager_DeactivateAudioSession(audioSessionManager);
3976 if (resultDeactivate != AUDIOCOMMON_RESULT_SUCCESS) {
3977 napi_create_int32(env, TEST_FAIL, &res);
3978 LOG("resultDeactivate, result is: %{public}d", TEST_FAIL);
3979 return res;
3980 }
3981
3982 napi_create_int32(env, TEST_PASS, &res);
3983 return res;
3984 }
3985
3986
AudioSessionManagerStrategyError_001(napi_env env,napi_callback_info info)3987 static napi_value AudioSessionManagerStrategyError_001(napi_env env, napi_callback_info info)
3988 {
3989 napi_value res;
3990 OH_AudioSessionManager* audioSessionManager;
3991 OH_AudioCommon_Result resultManager = OH_AudioManager_GetAudioSessionManager(&audioSessionManager);
3992 if (resultManager != AUDIOCOMMON_RESULT_SUCCESS) {
3993 napi_create_int32(env, TEST_FAIL, &res);
3994 LOG("resultManager, result is: %{public}d", TEST_FAIL);
3995 return res;
3996 }
3997 OH_AudioSession_Strategy strategy = {
3998 CONCURRENCY_MIX_WITH_OTHERS
3999 };
4000
4001 // 设置音频并发模式并激活音频会话
4002 OH_AudioCommon_Result resultActivate = OH_AudioSessionManager_ActivateAudioSession(nullptr, &strategy);
4003 if (resultActivate != AUDIOCOMMON_RESULT_ERROR_INVALID_PARAM) {
4004 napi_create_int32(env, TEST_FAIL, &res);
4005 LOG("resultActivate, result is: %{public}d", TEST_FAIL);
4006 return res;
4007 }
4008
4009 napi_create_int32(env, TEST_PASS, &res);
4010 return res;
4011 }
4012
4013
AudioSessionManagerActivatedError_001(napi_env env,napi_callback_info info)4014 static napi_value AudioSessionManagerActivatedError_001(napi_env env, napi_callback_info info)
4015 {
4016 napi_value res;
4017 OH_AudioSessionManager* audioSessionManager;
4018 OH_AudioCommon_Result resultManager = OH_AudioManager_GetAudioSessionManager(&audioSessionManager);
4019 if (resultManager != AUDIOCOMMON_RESULT_SUCCESS) {
4020 napi_create_int32(env, TEST_FAIL, &res);
4021 LOG("resultManager, result is: %{public}d", TEST_FAIL);
4022 return res;
4023 }
4024 OH_AudioSession_Strategy strategy = {
4025 CONCURRENCY_MIX_WITH_OTHERS
4026 };
4027
4028 // 设置音频并发模式并激活音频会话
4029 OH_AudioCommon_Result resultActivate = OH_AudioSessionManager_ActivateAudioSession(audioSessionManager, &strategy);
4030 if (resultActivate != AUDIOCOMMON_RESULT_SUCCESS) {
4031 napi_create_int32(env, TEST_FAIL, &res);
4032 LOG("resultActivate, result is: %{public}d", TEST_FAIL);
4033 return res;
4034 }
4035
4036 // 查询音频会话是否已激活
4037 bool isActivated = OH_AudioSessionManager_IsAudioSessionActivated(nullptr);
4038 if (isActivated) {
4039 napi_create_int32(env, TEST_FAIL, &res);
4040 LOG("isActivated, result is: %{public}d", TEST_FAIL);
4041 return res;
4042 }
4043
4044 // 停用音频会话
4045 OH_AudioCommon_Result resultDeactivate = OH_AudioSessionManager_DeactivateAudioSession(audioSessionManager);
4046 if (resultDeactivate != AUDIOCOMMON_RESULT_SUCCESS) {
4047 napi_create_int32(env, TEST_FAIL, &res);
4048 LOG("resultDeactivate, result is: %{public}d", TEST_FAIL);
4049 return res;
4050 }
4051
4052 napi_create_int32(env, TEST_PASS, &res);
4053 return res;
4054 }
4055
4056
AudioSessionManagerStopError_001(napi_env env,napi_callback_info info)4057 static napi_value AudioSessionManagerStopError_001(napi_env env, napi_callback_info info)
4058 {
4059 napi_value res;
4060 OH_AudioSessionManager* audioSessionManager;
4061 OH_AudioCommon_Result resultManager = OH_AudioManager_GetAudioSessionManager(&audioSessionManager);
4062 if (resultManager != AUDIOCOMMON_RESULT_SUCCESS) {
4063 napi_create_int32(env, TEST_FAIL, &res);
4064 LOG("resultManager, result is: %{public}d", TEST_FAIL);
4065 return res;
4066 }
4067 OH_AudioSession_Strategy strategy = {
4068 CONCURRENCY_MIX_WITH_OTHERS
4069 };
4070
4071 // 设置音频并发模式并激活音频会话
4072 OH_AudioCommon_Result resultActivate = OH_AudioSessionManager_ActivateAudioSession(audioSessionManager, &strategy);
4073 if (resultActivate != AUDIOCOMMON_RESULT_SUCCESS) {
4074 napi_create_int32(env, TEST_FAIL, &res);
4075 LOG("resultActivate, result is: %{public}d", TEST_FAIL);
4076 return res;
4077 }
4078
4079 // 停用音频会话
4080 OH_AudioCommon_Result resultDeactivate = OH_AudioSessionManager_DeactivateAudioSession(nullptr);
4081 if (resultDeactivate != AUDIOCOMMON_RESULT_ERROR_INVALID_PARAM) {
4082 napi_create_int32(env, TEST_FAIL, &res);
4083 LOG("resultDeactivate, result is: %{public}d", TEST_FAIL);
4084 return res;
4085 }
4086
4087 // 停用音频会话
4088 resultDeactivate = OH_AudioSessionManager_DeactivateAudioSession(audioSessionManager);
4089 if (resultDeactivate != AUDIOCOMMON_RESULT_SUCCESS) {
4090 napi_create_int32(env, TEST_FAIL, &res);
4091 LOG("resultDeactivate, result is: %{public}d", TEST_FAIL);
4092 return res;
4093 }
4094
4095 napi_create_int32(env, TEST_PASS, &res);
4096 return res;
4097 }
4098
4099
AudioSessionManagerStopError_002(napi_env env,napi_callback_info info)4100 static napi_value AudioSessionManagerStopError_002(napi_env env, napi_callback_info info)
4101 {
4102 napi_value res;
4103 OH_AudioSessionManager* audioSessionManager;
4104 OH_AudioCommon_Result resultManager = OH_AudioManager_GetAudioSessionManager(&audioSessionManager);
4105 if (resultManager != AUDIOCOMMON_RESULT_SUCCESS) {
4106 napi_create_int32(env, TEST_FAIL, &res);
4107 LOG("resultManager, result is: %{public}d", TEST_FAIL);
4108 return res;
4109 }
4110 OH_AudioSession_Strategy strategy = {
4111 CONCURRENCY_MIX_WITH_OTHERS
4112 };
4113
4114 // 设置音频并发模式并激活音频会话
4115 OH_AudioCommon_Result resultActivate = OH_AudioSessionManager_ActivateAudioSession(audioSessionManager, &strategy);
4116 if (resultActivate != AUDIOCOMMON_RESULT_SUCCESS) {
4117 napi_create_int32(env, TEST_FAIL, &res);
4118 LOG("resultActivate, result is: %{public}d", TEST_FAIL);
4119 return res;
4120 }
4121 // 停用音频会话
4122 OH_AudioCommon_Result resultDeactivate1 = OH_AudioSessionManager_DeactivateAudioSession(audioSessionManager);
4123 if (resultDeactivate1 != AUDIOCOMMON_RESULT_SUCCESS) {
4124 napi_create_int32(env, TEST_FAIL, &res);
4125 LOG("resultDeactivate1, result is: %{public}d", TEST_FAIL);
4126 return res;
4127 }
4128 // 停用音频会话
4129 OH_AudioCommon_Result resultDeactivate2 = OH_AudioSessionManager_DeactivateAudioSession(audioSessionManager);
4130 if (resultDeactivate2 != AUDIOCOMMON_RESULT_ERROR_ILLEGAL_STATE) {
4131 napi_create_int32(env, TEST_FAIL, &res);
4132 LOG("resultDeactivate2, result is: %{public}d", TEST_FAIL);
4133 return res;
4134 }
4135
4136 napi_create_int32(env, TEST_PASS, &res);
4137 return res;
4138 }
4139
4140
AudioSessionManagerRegisterError_001(napi_env env,napi_callback_info info)4141 static napi_value AudioSessionManagerRegisterError_001(napi_env env, napi_callback_info info)
4142 {
4143 napi_value res;
4144 OH_AudioSessionManager* audioSessionManager;
4145 OH_AudioCommon_Result resultManager = OH_AudioManager_GetAudioSessionManager(&audioSessionManager);
4146 if (resultManager != AUDIOCOMMON_RESULT_SUCCESS) {
4147 napi_create_int32(env, TEST_FAIL, &res);
4148 LOG("resultManager, result is: %{public}d", TEST_FAIL);
4149 return res;
4150 }
4151 OH_AudioSession_Strategy strategy = {
4152 CONCURRENCY_MIX_WITH_OTHERS
4153 };
4154
4155 // 设置音频并发模式并激活音频会话
4156 OH_AudioCommon_Result resultActivate = OH_AudioSessionManager_ActivateAudioSession(audioSessionManager, &strategy);
4157 if (resultActivate != AUDIOCOMMON_RESULT_SUCCESS) {
4158 napi_create_int32(env, TEST_FAIL, &res);
4159 LOG("resultActivate, result is: %{public}d", TEST_FAIL);
4160 return res;
4161 }
4162
4163 // 查询音频会话是否已激活。
4164 bool isActivated = OH_AudioSessionManager_IsAudioSessionActivated(audioSessionManager);
4165 if (!isActivated) {
4166 napi_create_int32(env, TEST_FAIL, &res);
4167 LOG("isActivated, result is: %{public}d", TEST_FAIL);
4168 return res;
4169 }
4170
4171 // 监听音频会话停用事件
4172 OH_AudioCommon_Result resultRegister =
4173 OH_AudioSessionManager_RegisterSessionDeactivatedCallback(nullptr, MyAudioSessionDeactivatedCallback);
4174 if (resultRegister != AUDIOCOMMON_RESULT_ERROR_INVALID_PARAM) {
4175 napi_create_int32(env, TEST_FAIL, &res);
4176 LOG("resultRegister, result is: %{public}d", TEST_FAIL);
4177 return res;
4178 }
4179
4180 // 停用音频会话
4181 OH_AudioCommon_Result resultDeactivate = OH_AudioSessionManager_DeactivateAudioSession(audioSessionManager);
4182 if (resultDeactivate != AUDIOCOMMON_RESULT_SUCCESS) {
4183 napi_create_int32(env, TEST_FAIL, &res);
4184 LOG("resultDeactivate, result is: %{public}d", TEST_FAIL);
4185 return res;
4186 }
4187
4188 napi_create_int32(env, TEST_PASS, &res);
4189 return res;
4190 }
4191
4192
AudioSessionManagerRegisterError_002(napi_env env,napi_callback_info info)4193 static napi_value AudioSessionManagerRegisterError_002(napi_env env, napi_callback_info info)
4194 {
4195 napi_value res;
4196 OH_AudioSessionManager* audioSessionManager;
4197 OH_AudioCommon_Result resultManager = OH_AudioManager_GetAudioSessionManager(&audioSessionManager);
4198 if (resultManager != AUDIOCOMMON_RESULT_SUCCESS) {
4199 napi_create_int32(env, TEST_FAIL, &res);
4200 LOG("resultManager, result is: %{public}d", TEST_FAIL);
4201 return res;
4202 }
4203 OH_AudioSession_Strategy strategy = {
4204 CONCURRENCY_MIX_WITH_OTHERS
4205 };
4206
4207 // 设置音频并发模式并激活音频会话
4208 OH_AudioCommon_Result resultActivate = OH_AudioSessionManager_ActivateAudioSession(audioSessionManager, &strategy);
4209 if (resultActivate != AUDIOCOMMON_RESULT_SUCCESS) {
4210 napi_create_int32(env, TEST_FAIL, &res);
4211 LOG("resultActivate, result is: %{public}d", TEST_FAIL);
4212 return res;
4213 }
4214
4215 // 查询音频会话是否已激活。
4216 bool isActivated = OH_AudioSessionManager_IsAudioSessionActivated(audioSessionManager);
4217 if (!isActivated) {
4218 napi_create_int32(env, TEST_FAIL, &res);
4219 LOG("isActivated, result is: %{public}d", TEST_FAIL);
4220 return res;
4221 }
4222
4223 // 监听音频会话停用事件
4224 OH_AudioCommon_Result resultRegister =
4225 OH_AudioSessionManager_RegisterSessionDeactivatedCallback(audioSessionManager, nullptr);
4226 if (resultRegister != AUDIOCOMMON_RESULT_ERROR_INVALID_PARAM) {
4227 napi_create_int32(env, TEST_FAIL, &res);
4228 LOG("resultRegister, result is: %{public}d", TEST_FAIL);
4229 return res;
4230 }
4231
4232 // 停用音频会话
4233 OH_AudioCommon_Result resultDeactivate = OH_AudioSessionManager_DeactivateAudioSession(audioSessionManager);
4234 if (resultDeactivate != AUDIOCOMMON_RESULT_SUCCESS) {
4235 napi_create_int32(env, TEST_FAIL, &res);
4236 LOG("resultDeactivate, result is: %{public}d", TEST_FAIL);
4237 return res;
4238 }
4239
4240 napi_create_int32(env, TEST_PASS, &res);
4241 return res;
4242 }
4243
4244
AudioSessionManagerUnregisterError_001(napi_env env,napi_callback_info info)4245 static napi_value AudioSessionManagerUnregisterError_001(napi_env env, napi_callback_info info)
4246 {
4247 napi_value res;
4248 OH_AudioSessionManager* audioSessionManager;
4249 OH_AudioCommon_Result resultManager = OH_AudioManager_GetAudioSessionManager(&audioSessionManager);
4250 if (resultManager != AUDIOCOMMON_RESULT_SUCCESS) {
4251 napi_create_int32(env, TEST_FAIL, &res);
4252 LOG("resultManager, result is: %{public}d", TEST_FAIL);
4253 return res;
4254 }
4255 OH_AudioSession_Strategy strategy = {
4256 CONCURRENCY_MIX_WITH_OTHERS
4257 };
4258
4259 // 设置音频并发模式并激活音频会话
4260 OH_AudioCommon_Result resultActivate =
4261 OH_AudioSessionManager_ActivateAudioSession(audioSessionManager, &strategy);
4262 if (resultActivate != AUDIOCOMMON_RESULT_SUCCESS) {
4263 napi_create_int32(env, TEST_FAIL, &res);
4264 LOG("resultActivate, result is: %{public}d", TEST_FAIL);
4265 return res;
4266 }
4267
4268 // 查询音频会话是否已激活。
4269 bool isActivated = OH_AudioSessionManager_IsAudioSessionActivated(audioSessionManager);
4270 if (!isActivated) {
4271 napi_create_int32(env, TEST_FAIL, &res);
4272 LOG("isActivated, result is: %{public}d", TEST_FAIL);
4273 return res;
4274 }
4275
4276 // 监听音频会话停用事件
4277 OH_AudioCommon_Result resultRegister =
4278 OH_AudioSessionManager_RegisterSessionDeactivatedCallback(
4279 audioSessionManager, MyAudioSessionDeactivatedCallback);
4280 if (resultRegister != AUDIOCOMMON_RESULT_SUCCESS) {
4281 napi_create_int32(env, TEST_FAIL, &res);
4282 LOG("resultRegister, result is: %{public}d", TEST_FAIL);
4283 return res;
4284 }
4285
4286 // 取消监听音频会话停用事件
4287 OH_AudioCommon_Result resultUnregister =
4288 OH_AudioSessionManager_UnregisterSessionDeactivatedCallback(nullptr, MyAudioSessionDeactivatedCallback);
4289 if (resultUnregister != AUDIOCOMMON_RESULT_ERROR_INVALID_PARAM) {
4290 napi_create_int32(env, TEST_FAIL, &res);
4291 LOG("resultUnregister, result is: %{public}d", TEST_FAIL);
4292 return res;
4293 }
4294
4295 // 取消监听音频会话停用事件
4296 resultUnregister =
4297 OH_AudioSessionManager_UnregisterSessionDeactivatedCallback(
4298 audioSessionManager, MyAudioSessionDeactivatedCallback);
4299 if (resultUnregister != AUDIOCOMMON_RESULT_SUCCESS) {
4300 napi_create_int32(env, TEST_FAIL, &res);
4301 LOG("resultUnregister, result is: %{public}d", TEST_FAIL);
4302 return res;
4303 }
4304
4305 // 停用音频会话
4306 OH_AudioCommon_Result resultDeactivate = OH_AudioSessionManager_DeactivateAudioSession(audioSessionManager);
4307 if (resultDeactivate != AUDIOCOMMON_RESULT_SUCCESS) {
4308 napi_create_int32(env, TEST_FAIL, &res);
4309 LOG("resultDeactivate, result is: %{public}d", TEST_FAIL);
4310 return res;
4311 }
4312
4313 napi_create_int32(env, TEST_PASS, &res);
4314 return res;
4315 }
4316
4317
AudioSessionManagerUnregisterError_002(napi_env env,napi_callback_info info)4318 static napi_value AudioSessionManagerUnregisterError_002(napi_env env, napi_callback_info info)
4319 {
4320 napi_value res;
4321 OH_AudioSessionManager* audioSessionManager;
4322 OH_AudioCommon_Result resultManager = OH_AudioManager_GetAudioSessionManager(&audioSessionManager);
4323 if (resultManager != AUDIOCOMMON_RESULT_SUCCESS) {
4324 napi_create_int32(env, TEST_FAIL, &res);
4325 LOG("resultManager, result is: %{public}d", TEST_FAIL);
4326 return res;
4327 }
4328 OH_AudioSession_Strategy strategy = {
4329 CONCURRENCY_MIX_WITH_OTHERS
4330 };
4331
4332 // 设置音频并发模式并激活音频会话
4333 OH_AudioCommon_Result resultActivate =
4334 OH_AudioSessionManager_ActivateAudioSession(audioSessionManager, &strategy);
4335 if (resultActivate != AUDIOCOMMON_RESULT_SUCCESS) {
4336 napi_create_int32(env, TEST_FAIL, &res);
4337 LOG("resultActivate, result is: %{public}d", TEST_FAIL);
4338 return res;
4339 }
4340
4341 // 查询音频会话是否已激活。
4342 bool isActivated = OH_AudioSessionManager_IsAudioSessionActivated(audioSessionManager);
4343 if (!isActivated) {
4344 napi_create_int32(env, TEST_FAIL, &res);
4345 LOG("isActivated, result is: %{public}d", TEST_FAIL);
4346 return res;
4347 }
4348
4349 // 监听音频会话停用事件
4350 OH_AudioCommon_Result resultRegister =
4351 OH_AudioSessionManager_RegisterSessionDeactivatedCallback(
4352 audioSessionManager, MyAudioSessionDeactivatedCallback);
4353 if (resultRegister != AUDIOCOMMON_RESULT_SUCCESS) {
4354 napi_create_int32(env, TEST_FAIL, &res);
4355 LOG("resultRegister, result is: %{public}d", TEST_FAIL);
4356 return res;
4357 }
4358
4359 // 取消监听音频会话停用事件
4360 OH_AudioCommon_Result resultUnregister =
4361 OH_AudioSessionManager_UnregisterSessionDeactivatedCallback(audioSessionManager, nullptr);
4362 if (resultUnregister != AUDIOCOMMON_RESULT_ERROR_INVALID_PARAM) {
4363 napi_create_int32(env, TEST_FAIL, &res);
4364 LOG("resultUnregister, result is: %{public}d", TEST_FAIL);
4365 return res;
4366 }
4367
4368 // 取消监听音频会话停用事件
4369 resultUnregister =
4370 OH_AudioSessionManager_UnregisterSessionDeactivatedCallback(
4371 audioSessionManager, MyAudioSessionDeactivatedCallback);
4372 if (resultUnregister != AUDIOCOMMON_RESULT_SUCCESS) {
4373 napi_create_int32(env, TEST_FAIL, &res);
4374 LOG("resultUnregister, result is: %{public}d", TEST_FAIL);
4375 return res;
4376 }
4377
4378 // 停用音频会话
4379 OH_AudioCommon_Result resultDeactivate = OH_AudioSessionManager_DeactivateAudioSession(audioSessionManager);
4380 if (resultDeactivate != AUDIOCOMMON_RESULT_SUCCESS) {
4381 napi_create_int32(env, TEST_FAIL, &res);
4382 LOG("resultDeactivate, result is: %{public}d", TEST_FAIL);
4383 return res;
4384 }
4385
4386 napi_create_int32(env, TEST_PASS, &res);
4387 return res;
4388 }
4389
4390
AudioSessionManagerReason_001(napi_env env,napi_callback_info info)4391 static napi_value AudioSessionManagerReason_001(napi_env env, napi_callback_info info)
4392 {
4393 napi_value res;
4394 OH_AudioSessionManager* audioSessionManager;
4395 OH_AudioCommon_Result resultManager = OH_AudioManager_GetAudioSessionManager(&audioSessionManager);
4396 if (resultManager != AUDIOCOMMON_RESULT_SUCCESS) {
4397 napi_create_int32(env, TEST_FAIL, &res);
4398 LOG("resultManager, result is: %{public}d", TEST_FAIL);
4399 return res;
4400 }
4401 OH_AudioSession_Strategy strategy = {
4402 CONCURRENCY_MIX_WITH_OTHERS
4403 };
4404
4405 // 设置音频并发模式并激活音频会话
4406 OH_AudioCommon_Result resultActivate = OH_AudioSessionManager_ActivateAudioSession(audioSessionManager, &strategy);
4407 if (resultActivate != AUDIOCOMMON_RESULT_SUCCESS) {
4408 napi_create_int32(env, TEST_FAIL, &res);
4409 LOG("resultActivate, result is: %{public}d", TEST_FAIL);
4410 return res;
4411 }
4412
4413 // 查询音频会话是否已激活。
4414 bool isActivated = OH_AudioSessionManager_IsAudioSessionActivated(audioSessionManager);
4415 if (!isActivated) {
4416 napi_create_int32(env, TEST_FAIL, &res);
4417 LOG("isActivated, result is: %{public}d", TEST_FAIL);
4418 return res;
4419 }
4420
4421 // create builder
4422 OH_AudioStream_Type type = AUDIOSTREAM_TYPE_RENDERER;
4423 OH_AudioStream_Usage usage = AUDIOSTREAM_USAGE_MUSIC;
4424 OH_AudioStreamBuilder* builder;
4425 OH_AudioStreamBuilder_Create(&builder, type);
4426 OH_AudioStreamBuilder_SetRendererInfo(builder, usage);
4427 OH_AudioRenderer* audioRenderer1;
4428 OH_AudioStream_Result createResult = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer1);
4429 if (createResult != AUDIOSTREAM_SUCCESS) {
4430 napi_create_int32(env, TEST_FAIL, &res);
4431 return res;
4432 }
4433
4434 // create audioRenderer1 audioRenderer2
4435 OH_AudioStreamBuilder* builder2;
4436 OH_AudioStreamBuilder_Create(&builder2, type);
4437 OH_AudioStreamBuilder_SetRendererInfo(builder2, usage);
4438 OH_AudioRenderer* audioRenderer2;
4439 createResult = OH_AudioStreamBuilder_GenerateRenderer(builder2, &audioRenderer2);
4440 if (createResult != AUDIOSTREAM_SUCCESS) {
4441 napi_create_int32(env, TEST_FAIL, &res);
4442 return res;
4443 }
4444
4445 // 监听音频会话停用事件
4446 OH_AudioCommon_Result resultRegister =
4447 OH_AudioSessionManager_RegisterSessionDeactivatedCallback(
4448 audioSessionManager, MyAudioSessionDeactivatedCallback);
4449 if (resultRegister != AUDIOCOMMON_RESULT_SUCCESS) {
4450 napi_create_int32(env, TEST_FAIL, &res);
4451 LOG("resultRegister, result is: %{public}d", TEST_FAIL);
4452 return res;
4453 }
4454
4455 // start
4456 createResult = OH_AudioRenderer_Start(audioRenderer1);
4457 if (createResult != AUDIOSTREAM_SUCCESS) {
4458 napi_create_int32(env, TEST_FAIL, &res);
4459 return res;
4460 }
4461 //sleep 1 seconds
4462 Delay(1);
4463 createResult = OH_AudioRenderer_Start(audioRenderer2);
4464 if (createResult != AUDIOSTREAM_SUCCESS) {
4465 napi_create_int32(env, TEST_FAIL, &res);
4466 return res;
4467 }
4468 //sleep 1 seconds
4469 Delay(1);
4470
4471 // stop and release client
4472 OH_AudioRenderer_Release(audioRenderer2);
4473 OH_AudioRenderer_Release(audioRenderer1);
4474 OH_AudioStreamBuilder_Destroy(builder);
4475 OH_AudioStreamBuilder_Destroy(builder2);
4476 Delay(1);
4477
4478 // 取消监听音频会话停用事件
4479 OH_AudioCommon_Result resultUnregister =
4480 OH_AudioSessionManager_UnregisterSessionDeactivatedCallback(
4481 audioSessionManager, MyAudioSessionDeactivatedCallback);
4482 if (resultUnregister != AUDIOCOMMON_RESULT_SUCCESS) {
4483 napi_create_int32(env, TEST_FAIL, &res);
4484 LOG("resultUnregister, result is: %{public}d", TEST_FAIL);
4485 return res;
4486 }
4487
4488 // 停用音频会话
4489 OH_AudioCommon_Result resultDeactivate = OH_AudioSessionManager_DeactivateAudioSession(audioSessionManager);
4490 if (resultDeactivate != AUDIOCOMMON_RESULT_SUCCESS) {
4491 napi_create_int32(env, TEST_FAIL, &res);
4492 LOG("resultDeactivate, result is: %{public}d", TEST_FAIL);
4493 return res;
4494 }
4495
4496 napi_create_int32(env, TEST_PASS, &res);
4497 return res;
4498 }
4499
4500
AudioSessionManagerReason_002(napi_env env,napi_callback_info info)4501 static napi_value AudioSessionManagerReason_002(napi_env env, napi_callback_info info)
4502 {
4503 napi_value res;
4504 OH_AudioSessionManager* audioSessionManager;
4505 OH_AudioCommon_Result resultManager = OH_AudioManager_GetAudioSessionManager(&audioSessionManager);
4506 if (resultManager != AUDIOCOMMON_RESULT_SUCCESS) {
4507 napi_create_int32(env, TEST_FAIL, &res);
4508 LOG("resultManager, result is: %{public}d", TEST_FAIL);
4509 return res;
4510 }
4511 OH_AudioSession_Strategy strategy = {
4512 CONCURRENCY_MIX_WITH_OTHERS
4513 };
4514
4515 // 设置音频并发模式并激活音频会话
4516 OH_AudioCommon_Result resultActivate = OH_AudioSessionManager_ActivateAudioSession(audioSessionManager, &strategy);
4517 if (resultActivate != AUDIOCOMMON_RESULT_SUCCESS) {
4518 napi_create_int32(env, TEST_FAIL, &res);
4519 LOG("resultActivate, result is: %{public}d", TEST_FAIL);
4520 return res;
4521 }
4522
4523 // 查询音频会话是否已激活。
4524 bool isActivated = OH_AudioSessionManager_IsAudioSessionActivated(audioSessionManager);
4525 if (!isActivated) {
4526 napi_create_int32(env, TEST_FAIL, &res);
4527 LOG("isActivated, result is: %{public}d", TEST_FAIL);
4528 return res;
4529 }
4530
4531 // create builder
4532 OH_AudioStream_Type type = AUDIOSTREAM_TYPE_RENDERER;
4533 OH_AudioStream_Usage usage = AUDIOSTREAM_USAGE_MUSIC;
4534 OH_AudioStreamBuilder* builder;
4535 OH_AudioStreamBuilder_Create(&builder, type);
4536 OH_AudioStreamBuilder_SetRendererInfo(builder, usage);
4537 OH_AudioRenderer* audioRenderer1;
4538 OH_AudioStream_Result createResult = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer1);
4539 if (createResult != AUDIOSTREAM_SUCCESS) {
4540 napi_create_int32(env, TEST_FAIL, &res);
4541 return res;
4542 }
4543
4544 // 监听音频会话停用事件
4545 OH_AudioCommon_Result resultRegister =
4546 OH_AudioSessionManager_RegisterSessionDeactivatedCallback(
4547 audioSessionManager, MyAudioSessionDeactivatedCallback);
4548 if (resultRegister != AUDIOCOMMON_RESULT_SUCCESS) {
4549 napi_create_int32(env, TEST_FAIL, &res);
4550 LOG("resultRegister, result is: %{public}d", TEST_FAIL);
4551 return res;
4552 }
4553
4554 // start
4555 createResult = OH_AudioRenderer_Start(audioRenderer1);
4556 if (createResult != AUDIOSTREAM_SUCCESS) {
4557 napi_create_int32(env, TEST_FAIL, &res);
4558 return res;
4559 }
4560 Delay(1);
4561 OH_AudioRenderer_Stop(audioRenderer1);
4562 //sleep 65 seconds 创造超时条件
4563 Delay(65);
4564
4565 // release client
4566 OH_AudioRenderer_Release(audioRenderer1);
4567 OH_AudioStreamBuilder_Destroy(builder);
4568
4569 // 取消监听音频会话停用事件
4570 OH_AudioCommon_Result resultUnregister =
4571 OH_AudioSessionManager_UnregisterSessionDeactivatedCallback(
4572 audioSessionManager, MyAudioSessionDeactivatedCallback);
4573 if (resultUnregister != AUDIOCOMMON_RESULT_SUCCESS) {
4574 napi_create_int32(env, TEST_FAIL, &res);
4575 LOG("resultUnregister, result is: %{public}d", TEST_FAIL);
4576 return res;
4577 }
4578
4579 napi_create_int32(env, TEST_PASS, &res);
4580 return res;
4581 }
4582
AudioRendererSetDefaultOutputDevice_01(napi_env env,napi_callback_info info)4583 static napi_value AudioRendererSetDefaultOutputDevice_01(napi_env env, napi_callback_info info)
4584 {
4585 napi_value res;
4586 OH_AudioStreamBuilder* builder;
4587 OH_AudioStream_Type type = AUDIOSTREAM_TYPE_RENDERER;
4588 OH_AudioStream_Usage usage = AUDIOSTREAM_USAGE_VOICE_COMMUNICATION;
4589 OH_AudioDevice_Type deviceType = AUDIO_DEVICE_TYPE_WIRED_HEADSET;
4590 OH_AudioStreamBuilder_Create(&builder, type);
4591
4592 // 2. set builder params
4593 OH_AudioStreamBuilder_SetRendererInfo(builder, usage);
4594
4595 OH_AudioRenderer_Callbacks callbacks;
4596 callbacks.OH_AudioRenderer_OnWriteData = AudioRendererOnWriteData;
4597 OH_AudioStreamBuilder_SetRendererCallback(builder, callbacks, nullptr);
4598
4599 // 3. generate audiorenderer
4600 OH_AudioRenderer* audioRenderer;
4601 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
4602 if (result != AUDIOSTREAM_SUCCESS) {
4603 napi_create_int32(env, TEST_FAIL, &res);
4604 return res;
4605 }
4606
4607 // 4. start
4608 result = OH_AudioRenderer_Start(audioRenderer);
4609 if (result != AUDIOSTREAM_SUCCESS) {
4610 napi_create_int32(env, TEST_FAIL, &res);
4611 return res;
4612 }
4613
4614 // 5. OH_AudioRenderer_SetDefaultOutputDevice
4615 result = OH_AudioRenderer_SetDefaultOutputDevice(audioRenderer, deviceType);
4616 if (result != AUDIOSTREAM_ERROR_INVALID_PARAM) {
4617 napi_create_int32(env, TEST_FAIL, &res);
4618 } else {
4619 napi_create_int32(env, TEST_PASS, &res);
4620 }
4621
4622 OH_AudioRenderer_Release(audioRenderer);
4623 OH_AudioStreamBuilder_Destroy(builder);
4624 return res;
4625 }
4626
AudioRendererSetDefaultOutputDevice_02(napi_env env,napi_callback_info info)4627 static napi_value AudioRendererSetDefaultOutputDevice_02(napi_env env, napi_callback_info info)
4628 {
4629 napi_value res;
4630 OH_AudioStreamBuilder* builder;
4631 OH_AudioStream_Type type = AUDIOSTREAM_TYPE_RENDERER;
4632 OH_AudioStream_Usage usage = AUDIOSTREAM_USAGE_MUSIC;
4633 OH_AudioDevice_Type deviceType = AUDIO_DEVICE_TYPE_SPEAKER;
4634 OH_AudioStreamBuilder_Create(&builder, type);
4635
4636 // 2. set builder params
4637 OH_AudioStreamBuilder_SetRendererInfo(builder, usage);
4638
4639 OH_AudioRenderer_Callbacks callbacks;
4640 callbacks.OH_AudioRenderer_OnWriteData = AudioRendererOnWriteData;
4641 OH_AudioStreamBuilder_SetRendererCallback(builder, callbacks, nullptr);
4642
4643 // 3. generate audiorenderer
4644 OH_AudioRenderer* audioRenderer;
4645 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
4646 if (result != AUDIOSTREAM_SUCCESS) {
4647 napi_create_int32(env, TEST_FAIL, &res);
4648 return res;
4649 }
4650
4651 // 4. start
4652 result = OH_AudioRenderer_Start(audioRenderer);
4653 if (result != AUDIOSTREAM_SUCCESS) {
4654 napi_create_int32(env, TEST_FAIL, &res);
4655 return res;
4656 }
4657
4658 // 5. OH_AudioRenderer_SetDefaultOutputDevice
4659 result = OH_AudioRenderer_SetDefaultOutputDevice(audioRenderer, deviceType);
4660 if (result != AUDIOSTREAM_ERROR_ILLEGAL_STATE) {
4661 napi_create_int32(env, TEST_FAIL, &res);
4662 } else {
4663 napi_create_int32(env, TEST_PASS, &res);
4664 }
4665
4666 OH_AudioRenderer_Release(audioRenderer);
4667 OH_AudioStreamBuilder_Destroy(builder);
4668 return res;
4669 }
4670
AudioRendererSetDefaultOutputDevice_03(napi_env env,napi_callback_info info)4671 static napi_value AudioRendererSetDefaultOutputDevice_03(napi_env env, napi_callback_info info)
4672 {
4673 napi_value res;
4674 OH_AudioStreamBuilder* builder;
4675 OH_AudioStream_Type type = AUDIOSTREAM_TYPE_RENDERER;
4676 OH_AudioStream_Usage usage = AUDIOSTREAM_USAGE_VOICE_COMMUNICATION;
4677 OH_AudioDevice_Type deviceType = AUDIO_DEVICE_TYPE_SPEAKER;
4678 OH_AudioStreamBuilder_Create(&builder, type);
4679
4680 // 2. set builder params
4681 OH_AudioStreamBuilder_SetRendererInfo(builder, usage);
4682
4683 OH_AudioRenderer_Callbacks callbacks;
4684 callbacks.OH_AudioRenderer_OnWriteData = AudioRendererOnWriteData;
4685 OH_AudioStreamBuilder_SetRendererCallback(builder, callbacks, nullptr);
4686
4687 // 3. generate audiorenderer
4688 OH_AudioRenderer* audioRenderer;
4689 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
4690 if (result != AUDIOSTREAM_SUCCESS) {
4691 napi_create_int32(env, TEST_FAIL, &res);
4692 return res;
4693 }
4694
4695 // 4. start
4696 result = OH_AudioRenderer_Start(audioRenderer);
4697 if (result != AUDIOSTREAM_SUCCESS) {
4698 napi_create_int32(env, TEST_FAIL, &res);
4699 return res;
4700 }
4701
4702 // 5. OH_AudioRenderer_SetDefaultOutputDevice
4703 result = OH_AudioRenderer_SetDefaultOutputDevice(nullptr, deviceType);
4704 if (result != AUDIOSTREAM_ERROR_INVALID_PARAM) {
4705 napi_create_int32(env, TEST_FAIL, &res);
4706 } else {
4707 napi_create_int32(env, TEST_PASS, &res);
4708 }
4709
4710 OH_AudioRenderer_Release(audioRenderer);
4711 OH_AudioStreamBuilder_Destroy(builder);
4712 return res;
4713 }
4714
Add(napi_env env,napi_callback_info info)4715 static napi_value Add(napi_env env, napi_callback_info info)
4716 {
4717 size_t requireArgc = 2;
4718 size_t argc = 2;
4719 napi_value args[2] = {nullptr};
4720
4721 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
4722
4723 napi_valuetype valuetype0;
4724 napi_typeof(env, args[0], &valuetype0);
4725
4726 napi_valuetype valuetype1;
4727 napi_typeof(env, args[1], &valuetype1);
4728
4729 double value0;
4730 napi_get_value_double(env, args[0], &value0);
4731
4732 double value1;
4733 napi_get_value_double(env, args[1], &value1);
4734
4735 napi_value sum;
4736 napi_create_double(env, value0 + value1, &sum);
4737
4738 return sum;
4739 }
4740
CreateRenderBuilderAddCallBack()4741 OH_AudioStreamBuilder *CreateRenderBuilderAddCallBack()
4742 {
4743 OH_AudioStreamBuilder *builder;
4744 OH_AudioStream_Type type = AUDIOSTREAM_TYPE_RENDERER;
4745 OH_AudioStreamBuilder_Create(&builder, type);
4746 OH_AudioRenderer_Callbacks callbacks;
4747 callbacks.OH_AudioRenderer_OnWriteData = AudioRendererOnWriteData;
4748 OH_AudioStream_Result result = OH_AudioStreamBuilder_SetRendererCallback(builder, callbacks, NULL);
4749 return builder;
4750 }
4751
AudioRenderGetAudioTimestampInfo(napi_env env,napi_callback_info info)4752 static napi_value AudioRenderGetAudioTimestampInfo(napi_env env, napi_callback_info info)
4753 {
4754 OH_AudioStreamBuilder *builder = CreateRenderBuilderAddCallBack();
4755
4756 OH_AudioRenderer *audioRenderer;
4757 OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
4758
4759 napi_value res;
4760 int64_t framePosition0;
4761 int64_t timestamp0;
4762 OH_AudioStream_Result result = OH_AudioRenderer_GetAudioTimestampInfo(
4763 audioRenderer, &framePosition0, ×tamp0);
4764 if (result == AUDIOSTREAM_SUCCESS) {
4765 napi_create_int32(env, TEST_FAIL, &res);
4766 return res;
4767 }
4768 OH_AudioRenderer_Start(audioRenderer);
4769
4770 int sleepNum = 30000;
4771 uDelay(sleepNum);
4772
4773 int64_t framePosition1;
4774 int64_t timestamp1;
4775 result = OH_AudioRenderer_GetAudioTimestampInfo(audioRenderer, &framePosition1, ×tamp1);
4776 if (result != AUDIOSTREAM_SUCCESS) {
4777 napi_create_int32(env, TEST_FAIL, &res);
4778 return res;
4779 }
4780
4781 OH_AudioRenderer_Stop(audioRenderer);
4782 result = OH_AudioRenderer_GetAudioTimestampInfo(audioRenderer, &framePosition0, ×tamp0);
4783 if (result == AUDIOSTREAM_SUCCESS) {
4784 napi_create_int32(env, TEST_FAIL, &res);
4785 return res;
4786 }
4787 OH_AudioRenderer_Release(audioRenderer);
4788 OH_AudioStreamBuilder_Destroy(builder);
4789 napi_create_int32(env, TEST_PASS, &res);
4790 return res;
4791 }
4792
AudioRenderGetAudioTimestampInfoInterval(napi_env env,napi_callback_info info)4793 static napi_value AudioRenderGetAudioTimestampInfoInterval(napi_env env, napi_callback_info info)
4794 {
4795 OH_AudioStreamBuilder *builder = CreateRenderBuilderAddCallBack();
4796
4797 OH_AudioRenderer *audioRenderer;
4798 OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
4799
4800 OH_AudioRenderer_Start(audioRenderer);
4801
4802 int sleepNum = 500000;
4803 uDelay(sleepNum);
4804
4805 napi_value res;
4806 float rate = 0.15;
4807 int counti = 5;
4808 int64_t framePositionLastDuration = 0;
4809 int64_t timestampLastDuration = 0;
4810 OH_AudioStream_Result result = AUDIOSTREAM_SUCCESS;
4811
4812 for (int i = 0; i < counti; ++i) {
4813 int64_t framePosition1 = 0;
4814 int64_t framePosition2 = 0;
4815 int64_t timestamp1 = 0;
4816 int64_t timestamp2 = 0;
4817 result = OH_AudioRenderer_GetAudioTimestampInfo(audioRenderer, &framePosition1, ×tamp1);
4818
4819 uDelay(sleepNum);
4820
4821 result = OH_AudioRenderer_GetAudioTimestampInfo(audioRenderer, &framePosition2, ×tamp2);
4822 if (framePositionLastDuration == 0) {
4823 framePositionLastDuration = framePosition2 - framePosition1;
4824 timestampLastDuration = timestamp2 - timestamp1;
4825 continue;
4826 }
4827
4828 int64_t timestampCurDuration = timestamp2 - timestamp1;
4829 int64_t framePositionCurDuration = (framePosition2 - framePosition1) *
4830 ((timestampLastDuration * 1.0) / (timestampCurDuration));
4831
4832 if (framePositionLastDuration <= framePositionCurDuration * (1 - rate) ||
4833 framePositionLastDuration >= framePositionCurDuration * (1 + rate)) {
4834 napi_create_int32(env, TEST_FAIL, &res);
4835 return res;
4836 }
4837
4838 framePositionLastDuration = framePosition2 - framePosition1;
4839 timestampLastDuration = timestamp2 - timestamp1;
4840 }
4841 OH_AudioRenderer_Stop(audioRenderer);
4842 OH_AudioRenderer_Release(audioRenderer);
4843 OH_AudioStreamBuilder_Destroy(builder);
4844 napi_create_int32(env, TEST_PASS, &res);
4845 return res;
4846 }
4847
getTargetStreamInfo(napi_env env,napi_callback_info info)4848 static napi_status getTargetStreamInfo(napi_env env, napi_callback_info info)
4849 {
4850 napi_status res = napi_status::napi_invalid_arg;
4851 size_t argc = 1;
4852 napi_value args[1] = {nullptr};
4853 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
4854 napi_value n_streamRendererUsageNum;
4855 napi_value n_streamSourceTypeNum;
4856 napi_value n_streamSamplingRateNum;
4857 napi_value n_streamSampleFormatNum;
4858 napi_value n_streamChannelCountNum;
4859 napi_value n_streamLatencyModeNum;
4860 if (napi_get_named_property(env, args[0], "streamRendererUsageNum", &n_streamRendererUsageNum) != napi_ok) {
4861 return res;
4862 }
4863 if (napi_get_named_property(env, args[0], "streamSourceTypeNum", &n_streamSourceTypeNum) != napi_ok) {
4864 return res;
4865 }
4866 if (napi_get_named_property(env, args[0], "streamSamplingRateNum", &n_streamSamplingRateNum) != napi_ok) {
4867 return res;
4868 }
4869 if (napi_get_named_property(env, args[0], "streamSampleFormatNum", &n_streamSampleFormatNum) != napi_ok) {
4870 return res;
4871 }
4872 if (napi_get_named_property(env, args[0], "streamChannelCountNum", &n_streamChannelCountNum) != napi_ok) {
4873 return res;
4874 }
4875 if (napi_get_named_property(env, args[0], "streamLatencyModeNum", &n_streamLatencyModeNum) != napi_ok) {
4876 return res;
4877 }
4878 int32_t capturerStreamUsage;
4879 napi_get_value_int32(env, n_streamSourceTypeNum, &capturerStreamUsage);
4880 g_ohCapturerStreamUsage = (OH_AudioStream_SourceType)capturerStreamUsage;
4881 int32_t rendererStreamUsage;
4882 napi_get_value_int32(env, n_streamRendererUsageNum, &rendererStreamUsage);
4883 g_ohRendererStreamUsage = (OH_AudioStream_Usage)rendererStreamUsage;
4884 int32_t format;
4885 napi_get_value_int32(env, n_streamSampleFormatNum, &format);
4886 g_ohFormat = (OH_AudioStream_SampleFormat)format;
4887 int32_t samplingRate;
4888 napi_get_value_int32(env, n_streamSamplingRateNum, &samplingRate);
4889 g_ohSamplingRate = samplingRate;
4890 int32_t channelCount;
4891 napi_get_value_int32(env, n_streamChannelCountNum, &channelCount);
4892 g_ohChannelCount = channelCount;
4893 int32_t latencyMode;
4894 napi_get_value_int32(env, n_streamLatencyModeNum, &latencyMode);
4895 g_ohLatencyMode = (OH_AudioStream_LatencyMode)latencyMode;
4896 return napi_status::napi_ok;
4897 }
4898
AudioCapturerOnReadDataPcm(OH_AudioCapturer * capturer,void * userData,void * buffer,int32_t bufferLen)4899 static int32_t AudioCapturerOnReadDataPcm(OH_AudioCapturer *capturer, void *userData, void *buffer, int32_t bufferLen)
4900 {
4901 size_t count = 1;
4902 if (fwrite(buffer, bufferLen, count, g_pcmFile) != count) {
4903 printf("buffer fwrite err");
4904 }
4905 return 0;
4906 }
4907
AudioCapturerInit(napi_env env,napi_callback_info info)4908 static napi_value AudioCapturerInit(napi_env env, napi_callback_info info)
4909 {
4910 napi_value result;
4911 napi_status res = getTargetStreamInfo(env, info);
4912 if (res != napi_status::napi_ok) {
4913 napi_create_int32(env, TEST_FAIL, &result);
4914 return result;
4915 }
4916
4917 if (g_audioCapturer) {
4918 OH_AudioCapturer_Release(g_audioCapturer);
4919 OH_AudioStreamBuilder_Destroy(g_capturerBuilder);
4920 g_audioCapturer = nullptr;
4921 g_capturerBuilder = nullptr;
4922 }
4923
4924 if (g_pcmFile) {
4925 fclose(g_pcmFile);
4926 g_pcmFile = nullptr;
4927 }
4928
4929 g_pcmFile = fopen(g_pcmFilePath.c_str(), "wb");
4930 if (g_pcmFile == nullptr) {
4931 LOG("AudioCapturerInit open g_pcmFilePath fail");
4932 napi_create_int32(env, TEST_FAIL, &result);
4933 return result;
4934 }
4935
4936 // 1. create builder
4937 OH_AudioStream_Type type = AUDIOSTREAM_TYPE_CAPTURER;
4938 OH_AudioStreamBuilder_Create(&g_capturerBuilder, type);
4939 // 2. set params and callbacks
4940 // 设置音频采样格式
4941 OH_AudioStreamBuilder_SetSampleFormat(g_capturerBuilder, g_ohFormat);
4942 // 设置音频流的编码类型
4943 OH_AudioStreamBuilder_SetEncodingType(g_capturerBuilder, AUDIOSTREAM_ENCODING_TYPE_RAW);
4944 // 设置输出音频流的工作场景
4945 OH_AudioStreamBuilder_SetCapturerInfo(g_capturerBuilder, g_ohCapturerStreamUsage);
4946
4947 OH_AudioStreamBuilder_SetSamplingRate(g_capturerBuilder, g_ohSamplingRate);
4948 OH_AudioStreamBuilder_SetChannelCount(g_capturerBuilder, g_ohChannelCount);
4949 OH_AudioStreamBuilder_SetLatencyMode(g_capturerBuilder, g_ohLatencyMode);
4950
4951 OH_AudioCapturer_Callbacks callbacks;
4952 callbacks.OH_AudioCapturer_OnReadData = AudioCapturerOnReadDataPcm;
4953 callbacks.OH_AudioCapturer_OnStreamEvent = nullptr;
4954 callbacks.OH_AudioCapturer_OnInterruptEvent = nullptr;
4955 callbacks.OH_AudioCapturer_OnError = nullptr;
4956
4957 OH_AudioStreamBuilder_SetCapturerCallback(g_capturerBuilder, callbacks, nullptr);
4958
4959 // 3. create OH_AudioCapturer
4960 OH_AudioStreamBuilder_GenerateCapturer(g_capturerBuilder, &g_audioCapturer);
4961
4962 napi_create_int32(env, TEST_PASS, &result);
4963 LOG("AudioCapturerInit succ");
4964 return result;
4965 }
4966
AudioCapturerStart(napi_env env,napi_callback_info info)4967 static napi_value AudioCapturerStart(napi_env env, napi_callback_info info)
4968 {
4969 napi_value result;
4970 OH_AudioStream_Result res = AUDIOSTREAM_SUCCESS;
4971
4972 if (g_audioCapturer == nullptr) {
4973 LOG("AudioCapturerStart fail");
4974 res = AUDIOSTREAM_ERROR_INVALID_PARAM;
4975 } else {
4976 res = OH_AudioCapturer_Start(g_audioCapturer);
4977 if (res != AUDIOSTREAM_SUCCESS) {
4978 LOG("AudioCapturerStart fail");
4979 } else {
4980 LOG("AudioCapturerStart succ");
4981 }
4982 }
4983
4984 napi_create_int32(env, res, &result);
4985 return result;
4986 }
4987
AudioCapturerStop(napi_env env,napi_callback_info info)4988 static napi_value AudioCapturerStop(napi_env env, napi_callback_info info)
4989 {
4990 napi_value result;
4991 OH_AudioStream_Result res = AUDIOSTREAM_SUCCESS;
4992
4993 if (g_audioCapturer == nullptr) {
4994 LOG("AudioCapturerStop fail");
4995 res = AUDIOSTREAM_ERROR_INVALID_PARAM;
4996 } else {
4997 res = OH_AudioCapturer_Stop(g_audioCapturer);
4998 if (res != AUDIOSTREAM_SUCCESS) {
4999 LOG("AudioCapturerStop fail");
5000 } else {
5001 LOG("AudioCapturerStop succ");
5002 }
5003 }
5004
5005 napi_create_int32(env, res, &result);
5006 return result;
5007 }
5008
AudioCapturerRelease(napi_env env,napi_callback_info info)5009 static napi_value AudioCapturerRelease(napi_env env, napi_callback_info info)
5010 {
5011 napi_value result;
5012 if (g_audioCapturer) {
5013 OH_AudioCapturer_Release(g_audioCapturer);
5014 OH_AudioStreamBuilder_Destroy(g_capturerBuilder);
5015 g_audioCapturer = nullptr;
5016 g_capturerBuilder = nullptr;
5017 }
5018 if (g_pcmFile) {
5019 fclose(g_pcmFile);
5020 g_pcmFile = nullptr;
5021 }
5022
5023 napi_create_int32(env, TEST_PASS, &result);
5024 return result;
5025 }
5026
AudioRendererOnWriteDataPcm(OH_AudioRenderer * renderer,void * userData,void * buffer,int32_t bufferLen)5027 static int32_t AudioRendererOnWriteDataPcm(OH_AudioRenderer *renderer, void *userData, void *buffer, int32_t bufferLen)
5028 {
5029 size_t readCount = fread(buffer, bufferLen, 1, g_pcmFile);
5030 if (!readCount) {
5031 if (feof(g_pcmFile)) {
5032 OH_AudioRenderer_Stop(g_audioRenderer);
5033 }
5034 }
5035 return 0;
5036 }
5037
AudioRendererInit(napi_env env,napi_callback_info info)5038 static napi_value AudioRendererInit(napi_env env, napi_callback_info info)
5039 {
5040 napi_value result;
5041 napi_status res = getTargetStreamInfo(env, info);
5042 if (res != napi_status::napi_ok) {
5043 napi_create_int32(env, TEST_FAIL, &result);
5044 return result;
5045 }
5046
5047 if (g_audioRenderer) {
5048 OH_AudioRenderer_Release(g_audioRenderer);
5049 OH_AudioStreamBuilder_Destroy(g_rendererBuilder);
5050 g_audioRenderer = nullptr;
5051 g_rendererBuilder = nullptr;
5052 }
5053 if (g_pcmFile) {
5054 fclose(g_pcmFile);
5055 g_pcmFile = nullptr;
5056 }
5057
5058 g_pcmFile = fopen(g_pcmFilePath.c_str(), "rb");
5059 if (g_pcmFile == nullptr) {
5060 return 0;
5061 }
5062 // create builder
5063 OH_AudioStream_Type type = AUDIOSTREAM_TYPE_RENDERER;
5064 OH_AudioStreamBuilder_Create(&g_rendererBuilder, type);
5065
5066 // set params and callbacks
5067 // 设置音频采样格式
5068 OH_AudioStreamBuilder_SetSampleFormat(g_rendererBuilder, g_ohFormat);
5069 // 设置音频流的编码类型
5070 OH_AudioStreamBuilder_SetEncodingType(g_rendererBuilder, AUDIOSTREAM_ENCODING_TYPE_RAW);
5071 // 设置输出音频流的工作场景
5072 OH_AudioStreamBuilder_SetRendererInfo(g_rendererBuilder, g_ohRendererStreamUsage);
5073
5074 OH_AudioStreamBuilder_SetSamplingRate(g_rendererBuilder, g_ohSamplingRate);
5075 OH_AudioStreamBuilder_SetChannelCount(g_rendererBuilder, g_ohChannelCount);
5076 OH_AudioStreamBuilder_SetLatencyMode(g_rendererBuilder, g_ohLatencyMode);
5077
5078 OH_AudioRenderer_Callbacks rendererCallbacks;
5079 rendererCallbacks.OH_AudioRenderer_OnWriteData = AudioRendererOnWriteDataPcm;
5080 rendererCallbacks.OH_AudioRenderer_OnStreamEvent = nullptr;
5081 rendererCallbacks.OH_AudioRenderer_OnInterruptEvent = nullptr;
5082 rendererCallbacks.OH_AudioRenderer_OnError = nullptr;
5083 OH_AudioStreamBuilder_SetRendererCallback(g_rendererBuilder, rendererCallbacks, nullptr);
5084
5085 // create OH_AudioRenderer
5086 OH_AudioStreamBuilder_GenerateRenderer(g_rendererBuilder, &g_audioRenderer);
5087
5088 napi_create_int32(env, TEST_PASS, &result);
5089 LOG("AudioRendererInit succ");
5090 return result;
5091 }
5092
AudioRendererStart(napi_env env,napi_callback_info info)5093 static napi_value AudioRendererStart(napi_env env, napi_callback_info info)
5094 {
5095 napi_value result;
5096 OH_AudioStream_Result res = AUDIOSTREAM_SUCCESS;
5097
5098 if (g_audioRenderer == nullptr) {
5099 LOG("AudioRendererStart fail");
5100 res = AUDIOSTREAM_ERROR_INVALID_PARAM;
5101 } else {
5102 res = OH_AudioRenderer_Start(g_audioRenderer);
5103 if (res != AUDIOSTREAM_SUCCESS) {
5104 LOG("AudioRendererStart fail");
5105 } else {
5106 LOG("AudioRendererStart succ");
5107 }
5108 }
5109
5110 napi_create_int32(env, res, &result);
5111 return result;
5112 }
5113
AudioRendererStop(napi_env env,napi_callback_info info)5114 static napi_value AudioRendererStop(napi_env env, napi_callback_info info)
5115 {
5116 napi_value result;
5117 OH_AudioStream_Result res = AUDIOSTREAM_SUCCESS;
5118
5119 if (g_audioRenderer == nullptr) {
5120 LOG("AudioRendererStop fail");
5121 res = AUDIOSTREAM_ERROR_INVALID_PARAM;
5122 } else {
5123 res = OH_AudioRenderer_Stop(g_audioRenderer);
5124 if (res != AUDIOSTREAM_SUCCESS) {
5125 LOG("AudioRendererStop fail");
5126 } else {
5127 LOG("AudioRendererStop succ");
5128 }
5129 }
5130
5131 napi_create_int32(env, res, &result);
5132 return result;
5133 }
5134
AudioRendererRelease(napi_env env,napi_callback_info info)5135 static napi_value AudioRendererRelease(napi_env env, napi_callback_info info)
5136 {
5137 napi_value result;
5138 if (g_audioRenderer) {
5139 OH_AudioRenderer_Release(g_audioRenderer);
5140 OH_AudioStreamBuilder_Destroy(g_rendererBuilder);
5141 g_audioRenderer = nullptr;
5142 g_rendererBuilder = nullptr;
5143 }
5144 if (g_pcmFile) {
5145 fclose(g_pcmFile);
5146 g_pcmFile = nullptr;
5147 }
5148 napi_create_int32(env, TEST_PASS, &result);
5149 return result;
5150 }
5151
5152 EXTERN_C_START
5153 napi_property_descriptor desc1[] = {
5154 {"createAudioStreamBuilder", nullptr, CreateAudioStreamBuilder, nullptr, nullptr, nullptr, napi_default, nullptr},
5155 {"audioCaptureGenerate", nullptr, AudioCaptureGenerate, nullptr, nullptr, nullptr, napi_default, nullptr},
5156 {"audioCaptureGenerateErr", nullptr, AudioCaptureGenerateErr,
5157 nullptr, nullptr, nullptr, napi_default, nullptr},
5158 {"audioCaptureStart", nullptr, AudioCaptureStart, nullptr, nullptr, nullptr, napi_default, nullptr},
5159 {"audioCaptureStartErr", nullptr, AudioCaptureStartErr, nullptr, nullptr, nullptr, napi_default, nullptr},
5160 {"audioCapturePause", nullptr, AudioCapturePause, nullptr, nullptr, nullptr, napi_default, nullptr},
5161 {"audioCapturePauseErr", nullptr, AudioCapturePauseErr, nullptr, nullptr, nullptr, napi_default, nullptr},
5162 {"audioCaptureStop", nullptr, AudioCaptureStop, nullptr, nullptr, nullptr, napi_default, nullptr},
5163 {"audioCaptureStopErr", nullptr, AudioCaptureStopErr, nullptr, nullptr, nullptr, napi_default, nullptr},
5164 {"audioCaptureFlush", nullptr, AudioCaptureFlush, nullptr, nullptr, nullptr, napi_default, nullptr},
5165 {"audioCaptureFlushErr", nullptr, AudioCaptureFlushErr, nullptr, nullptr, nullptr, napi_default, nullptr},
5166 {"audioCaptureRelease", nullptr, AudioCaptureRelease, nullptr, nullptr, nullptr, napi_default, nullptr},
5167 {"audioCaptureReleaseErr", nullptr, AudioCaptureReleaseErr, nullptr, nullptr, nullptr, napi_default, nullptr},
5168 {"audioCaptureGetParameter", nullptr, AudioCaptureGetParameter,
5169 nullptr, nullptr, nullptr, napi_default, nullptr},
5170 {"audioCaptureGetCurrentState", nullptr, AudioCaptureGetCurrentState,
5171 nullptr, nullptr, nullptr, napi_default, nullptr},
5172 {"audioCaptureGetStreamId", nullptr, AudioCaptureGetStreamId,
5173 nullptr, nullptr, nullptr, napi_default, nullptr},
5174 {"audioCaptureGetSamplingRate", nullptr, AudioCaptureGetSamplingRate,
5175 nullptr, nullptr, nullptr, napi_default, nullptr},
5176 {"audioCaptureGetSampleFormat", nullptr, AudioCaptureGetSampleFormat,
5177 nullptr, nullptr, nullptr, napi_default, nullptr},
5178 {"audioCaptureGetEncodingType", nullptr, AudioCaptureGetEncodingType,
5179 nullptr, nullptr, nullptr, napi_default, nullptr},
5180 {"audioCaptureGetCapturerInfo", nullptr, AudioCaptureGetCapturerInfo,
5181 nullptr, nullptr, nullptr, napi_default, nullptr},
5182 {"audioCaptureGetTimestamp", nullptr, AudioCaptureGetTimestamp,
5183 nullptr, nullptr, nullptr, napi_default, nullptr},
5184 {"audioCaptureGetFramesRead", nullptr, AudioCaptureGetFramesRead,
5185 nullptr, nullptr, nullptr, napi_default, nullptr},
5186 {"audioCaptureGetFrameSizeInCallback", nullptr, AudioCaptureGetFrameSizeInCallback,
5187 nullptr, nullptr, nullptr, napi_default, nullptr},
5188 {"audioRendererSetSpeed", nullptr, AudioRendererSetSpeed,
5189 nullptr, nullptr, nullptr, napi_default, nullptr},
5190 {"audioRendererGetSpeed", nullptr, AudioRendererGetSpeed,
5191 nullptr, nullptr, nullptr, napi_default, nullptr},
5192 {"audioRendererSetGetSpeed", nullptr, AudioRendererSetGetSpeed,
5193 nullptr, nullptr, nullptr, napi_default, nullptr},
5194 {"audioSetRendererOutputDeviceChangeCallback", nullptr, AudioSetRendererOutputDeviceChangeCallback,
5195 nullptr, nullptr, nullptr, napi_default, nullptr},
5196 {"audioRenderGetFramesWritten", nullptr, AudioRenderGetFramesWritten,
5197 nullptr, nullptr, nullptr, napi_default, nullptr},
5198 {"audioRenderGetTimestamp", nullptr, AudioRenderGetTimestamp,
5199 nullptr, nullptr, nullptr, napi_default, nullptr},
5200 {"audioRenderGetAudioTimestampInfo", nullptr, AudioRenderGetAudioTimestampInfo,
5201 nullptr, nullptr, nullptr, napi_default, nullptr},
5202 {"audioRenderGetAudioTimestampInfoInterval", nullptr, AudioRenderGetAudioTimestampInfoInterval,
5203 nullptr, nullptr, nullptr, napi_default, nullptr},
5204 {"audioRenderGetFrameSizeInCallback", nullptr, AudioRenderGetFrameSizeInCallback,
5205 nullptr, nullptr, nullptr, napi_default, nullptr},
5206 {"audioRenderGenerate", nullptr, AudioRenderGenerate, nullptr, nullptr, nullptr, napi_default, nullptr},
5207 {"audioRenderGenerateErr", nullptr, AudioRenderGenerateErr, nullptr, nullptr, nullptr, napi_default, nullptr},
5208 {"audioRenderStart", nullptr, AudioRenderStart, nullptr, nullptr, nullptr, napi_default, nullptr},
5209 {"audioRenderStartErr", nullptr, AudioRenderStartErr, nullptr, nullptr, nullptr, napi_default, nullptr},
5210 {"audioRenderPause", nullptr, AudioRenderPause, nullptr, nullptr, nullptr, napi_default, nullptr},
5211 {"audioRenderPauseErr", nullptr, AudioRenderPauseErr, nullptr, nullptr, nullptr, napi_default, nullptr},
5212 {"audioRenderStop", nullptr, AudioRenderStop, nullptr, nullptr, nullptr, napi_default, nullptr},
5213 {"audioRenderStopErr", nullptr, AudioRenderStopErr, nullptr, nullptr, nullptr, napi_default, nullptr},
5214 {"audioRenderFlush", nullptr, AudioRenderFlush, nullptr, nullptr, nullptr, napi_default, nullptr},
5215 {"audioRenderFlushErr", nullptr, AudioRenderFlushErr, nullptr, nullptr, nullptr, napi_default, nullptr},
5216 {"audioRenderRelease", nullptr, AudioRenderRelease, nullptr, nullptr, nullptr, napi_default, nullptr},
5217 {"audioRenderReleaseErr", nullptr, AudioRenderReleaseErr, nullptr, nullptr, nullptr, napi_default, nullptr},
5218 {"audioRenderGetCurrentState", nullptr, AudioRenderGetCurrentState,
5219 nullptr, nullptr, nullptr, napi_default, nullptr},
5220 {"audioRenderGetParameter", nullptr, AudioRenderGetParameter,
5221 nullptr, nullptr, nullptr, napi_default, nullptr},
5222 {"audioRenderGetStreamId", nullptr, AudioRenderGetStreamId, nullptr, nullptr, nullptr, napi_default, nullptr},
5223 {"audioRenderGetSamplingRate", nullptr, AudioRenderGetSamplingRate,
5224 nullptr, nullptr, nullptr, napi_default, nullptr},
5225 {"audioRenderGetSampleFormat", nullptr, AudioRenderGetSampleFormat,
5226 nullptr, nullptr, nullptr, napi_default, nullptr},
5227 {"audioRenderGetEncodingType", nullptr, AudioRenderGetEncodingType,
5228 nullptr, nullptr, nullptr, napi_default, nullptr},
5229 {"audioRenderGetRendererInfo", nullptr, AudioRenderGetRendererInfo,
5230 nullptr, nullptr, nullptr, napi_default, nullptr},
5231 {"audioStreamBuilderSetSamplingRate", nullptr, AudioStreamBuilderSetSamplingRate,
5232 nullptr, nullptr, nullptr, napi_default, nullptr},
5233 {"audioStreamBuilderSetChannelCount", nullptr, AudioStreamBuilderSetChannelCount,
5234 nullptr, nullptr, nullptr, napi_default, nullptr},
5235 {"audioStreamBuilderSetSampleFormat", nullptr, AudioStreamBuilderSetSampleFormat,
5236 nullptr, nullptr, nullptr, napi_default, nullptr},
5237 {"audioStreamBuilderSetEncodingType", nullptr, AudioStreamBuilderSetEncodingType,
5238 nullptr, nullptr, nullptr, napi_default, nullptr},
5239 {"audioStreamBuilderSetLatencyMode", nullptr, AudioStreamBuilderSetLatencyMode,
5240 nullptr, nullptr, nullptr, napi_default, nullptr},
5241 {"audioStreamBuilderSetRendererInfo", nullptr, AudioStreamBuilderSetRendererInfo,
5242 nullptr, nullptr, nullptr, napi_default, nullptr},
5243 {"audioStreamBuilderSetCapturerInfo", nullptr, AudioStreamBuilderSetCapturerInfo,
5244 nullptr, nullptr, nullptr, napi_default, nullptr},
5245 {"audioStreamBuilderSetRendererCallback", nullptr, AudioStreamBuilderSetRendererCallback,
5246 nullptr, nullptr, nullptr, napi_default, nullptr},
5247 {"audioStreamBuilderSetCapturerCallback", nullptr, AudioStreamBuilderSetCapturerCallback,
5248 nullptr, nullptr, nullptr, napi_default, nullptr},
5249 {"audioCaptureGetChannelCount", nullptr, AudioCaptureGetChannelCount,
5250 nullptr, nullptr, nullptr, napi_default, nullptr},
5251 {"audioRenderGetChannelCount", nullptr, AudioRenderGetChannelCount,
5252 nullptr, nullptr, nullptr, napi_default, nullptr},
5253 {"audioStreamBuilderSetFrameSizeInCallback", nullptr, AudioStreamBuilderSetFrameSizeInCallback,
5254 nullptr, nullptr, nullptr, napi_default, nullptr},
5255 {"audioRendererGetVolume_01", nullptr, AudioRendererGetVolume_01,
5256 nullptr, nullptr, nullptr, napi_default, nullptr},
5257 {"audioRendererSetVolume_01", nullptr, AudioRendererSetVolume_01,
5258 nullptr, nullptr, nullptr, napi_default, nullptr},
5259 {"audioRendererSetVolume_02", nullptr, AudioRendererSetVolume_02,
5260 nullptr, nullptr, nullptr, napi_default, nullptr},
5261 {"audioRendererSetVolume_03", nullptr, AudioRendererSetVolume_03,
5262 nullptr, nullptr, nullptr, napi_default, nullptr},
5263 {"audioRendererSetVolume_04", nullptr, AudioRendererSetVolume_04,
5264 nullptr, nullptr, nullptr, napi_default, nullptr},
5265 {"audioRendererSetVolume_05", nullptr, AudioRendererSetVolume_05,
5266 nullptr, nullptr, nullptr, napi_default, nullptr},
5267 {"audioRendererSetVolume_06", nullptr, AudioRendererSetVolume_06,
5268 nullptr, nullptr, nullptr, napi_default, nullptr},
5269 {"audioRendererSetVolumeWithRamp_01", nullptr, AudioRendererSetVolumeWithRamp_01,
5270 nullptr, nullptr, nullptr, napi_default, nullptr},
5271 {"audioRendererSetVolumeWithRamp_02", nullptr, AudioRendererSetVolumeWithRamp_02,
5272 nullptr, nullptr, nullptr, napi_default, nullptr},
5273 {"audioRendererSetVolumeWithRamp_03", nullptr, AudioRendererSetVolumeWithRamp_03,
5274 nullptr, nullptr, nullptr, napi_default, nullptr},
5275 {"audioRendererSetVolumeWithRamp_04", nullptr, AudioRendererSetVolumeWithRamp_04,
5276 nullptr, nullptr, nullptr, napi_default, nullptr},
5277 {"audioRendererSetVolumeWithRamp_05", nullptr, AudioRendererSetVolumeWithRamp_05,
5278 nullptr, nullptr, nullptr, napi_default, nullptr},
5279 {"audioRendererSetVolumeWithRamp_06", nullptr, AudioRendererSetVolumeWithRamp_06,
5280 nullptr, nullptr, nullptr, napi_default, nullptr},
5281 {"audioRendererSetVolumeWithRamp_07", nullptr, AudioRendererSetVolumeWithRamp_07,
5282 nullptr, nullptr, nullptr, napi_default, nullptr},
5283 {"audioRendererSetVolumeWithRamp_08", nullptr, AudioRendererSetVolumeWithRamp_08,
5284 nullptr, nullptr, nullptr, napi_default, nullptr},
5285 {"audioRendererSetVolumeWithRamp_09", nullptr, AudioRendererSetVolumeWithRamp_09,
5286 nullptr, nullptr, nullptr, napi_default, nullptr},
5287 {"audioRendererSetOnMarkReached_01", nullptr, AudioRendererSetOnMarkReached_01,
5288 nullptr, nullptr, nullptr, napi_default, nullptr},
5289 {"audioRendererSetOnMarkReached_02", nullptr, AudioRendererSetOnMarkReached_02,
5290 nullptr, nullptr, nullptr, napi_default, nullptr},
5291 {"audioRendererSetOnMarkReached_03", nullptr, AudioRendererSetOnMarkReached_03,
5292 nullptr, nullptr, nullptr, napi_default, nullptr},
5293 {"audioRendererSetOnMarkReached_04", nullptr, AudioRendererSetOnMarkReached_04,
5294 nullptr, nullptr, nullptr, napi_default, nullptr},
5295 {"audioRendererSetOnMarkReached_05", nullptr, AudioRendererSetOnMarkReached_05,
5296 nullptr, nullptr, nullptr, napi_default, nullptr},
5297 {"audioRendererSetOnMarkReached_06", nullptr, AudioRendererSetOnMarkReached_06,
5298 nullptr, nullptr, nullptr, napi_default, nullptr},
5299 {"audioRendererSetOnMarkReached_07", nullptr, AudioRendererSetOnMarkReached_07,
5300 nullptr, nullptr, nullptr, napi_default, nullptr},
5301 {"audioRendererSetOnMarkReached_08", nullptr, AudioRendererSetOnMarkReached_08,
5302 nullptr, nullptr, nullptr, napi_default, nullptr},
5303 {"audioRendererCancelMark_01", nullptr, AudioRendererCancelMark_01,
5304 nullptr, nullptr, nullptr, napi_default, nullptr},
5305 {"audioRendererCancelMark_02", nullptr, AudioRendererCancelMark_02,
5306 nullptr, nullptr, nullptr, napi_default, nullptr},
5307 {"audioRendererCancelMark_03", nullptr, AudioRendererCancelMark_03,
5308 nullptr, nullptr, nullptr, napi_default, nullptr},
5309 {"audioRendererSetInterruptMode_01", nullptr, AudioRendererSetInterruptMode_01,
5310 nullptr, nullptr, nullptr, napi_default, nullptr},
5311 {"audioRendererSetInterruptMode_02", nullptr, AudioRendererSetInterruptMode_02,
5312 nullptr, nullptr, nullptr, napi_default, nullptr},
5313 {"audioRendererSetInterruptMode_03", nullptr, AudioRendererSetInterruptMode_03,
5314 nullptr, nullptr, nullptr, napi_default, nullptr},
5315 {"audioRendererSetInterruptMode_04", nullptr, AudioRendererSetInterruptMode_04,
5316 nullptr, nullptr, nullptr, napi_default, nullptr},
5317 {"audioManagerGetAudioRoutingManager_01", nullptr, AudioManagerGetAudioRoutingManager_01,
5318 nullptr, nullptr, nullptr, napi_default, nullptr},
5319 {"audioRoutingManagerGetDevices_01", nullptr, AudioRoutingManagerGetDevices_01,
5320 nullptr, nullptr, nullptr, napi_default, nullptr},
5321 {"audioRoutingManagerGetDevices_02", nullptr, AudioRoutingManagerGetDevices_02,
5322 nullptr, nullptr, nullptr, napi_default, nullptr},
5323 {"audioRoutingManagerGetDevices_03", nullptr, AudioRoutingManagerGetDevices_03,
5324 nullptr, nullptr, nullptr, napi_default, nullptr},
5325 {"audioRoutingManagerGetDevices_04", nullptr, AudioRoutingManagerGetDevices_04,
5326 nullptr, nullptr, nullptr, napi_default, nullptr},
5327 {"audioRoutingManagerGetDevices_05", nullptr, AudioRoutingManagerGetDevices_05,
5328 nullptr, nullptr, nullptr, napi_default, nullptr},
5329 {"audioRoutingManagerGetDevices_06", nullptr, AudioRoutingManagerGetDevices_06,
5330 nullptr, nullptr, nullptr, napi_default, nullptr},
5331 {"audioRoutingManagerGetDevices_07", nullptr, AudioRoutingManagerGetDevices_07,
5332 nullptr, nullptr, nullptr, napi_default, nullptr},
5333 {"audioManagerGetManager_01", nullptr, AudioManagerGetManager_01, nullptr, nullptr, nullptr, napi_default,
5334 nullptr},
5335 {"audioManagerGetManager_02", nullptr, AudioManagerGetManager_02, nullptr, nullptr, nullptr, napi_default,
5336 nullptr},
5337 {"audioManagerGetAudioScene_01", nullptr, AudioManagerGetAudioScene_01, nullptr, nullptr, nullptr, napi_default,
5338 nullptr}
5339 };
5340 napi_property_descriptor desc2[] = {
5341 {"audioManagerGetAudioScene_02", nullptr, AudioManagerGetAudioScene_02, nullptr, nullptr, nullptr, napi_default,
5342 nullptr},
5343 {"audioRoutingManagerGetAvailableDevices001", nullptr, AudioRoutingManagerGetAvailableDevices001, nullptr,
5344 nullptr, nullptr, napi_default, nullptr},
5345 {"audioRoutingManagerGetPreferredOutputDevice001", nullptr, AudioRoutingManagerGetPreferredOutputDevice001,
5346 nullptr, nullptr, nullptr, napi_default, nullptr},
5347 {"audioRoutingManagerGetPreferredInputDevice001", nullptr, AudioRoutingManagerGetPreferredInputDevice001,
5348 nullptr, nullptr, nullptr, napi_default, nullptr},
5349 {"audioRoutingManagerSetMicBlockStatusCallback_001", nullptr,
5350 AudioRoutingManagerSetMicBlockStatusCallback_001, nullptr, nullptr, nullptr, napi_default, nullptr},
5351 {"audioRoutingManagerSetMicBlockStatusCallback_002", nullptr,
5352 AudioRoutingManagerSetMicBlockStatusCallback_002, nullptr, nullptr, nullptr, napi_default, nullptr},
5353 {"audioRoutingManagerRegisterDeviceChangeCallback_001", nullptr,
5354 AudioRoutingManagerRegisterDeviceChangeCallback_001, nullptr, nullptr, nullptr, napi_default, nullptr},
5355 {"audioRoutingManagerRegisterDeviceChangeCallback_002", nullptr,
5356 AudioRoutingManagerRegisterDeviceChangeCallback_002, nullptr, nullptr, nullptr, napi_default, nullptr},
5357 {"audioRoutingManagerRegisterDeviceChangeCallback_003", nullptr,
5358 AudioRoutingManagerRegisterDeviceChangeCallback_003, nullptr, nullptr, nullptr, napi_default, nullptr},
5359 {"audioRoutingManagerRegisterDeviceChangeCallback_004", nullptr,
5360 AudioRoutingManagerRegisterDeviceChangeCallback_004, nullptr, nullptr, nullptr, napi_default, nullptr},
5361 {"audioRoutingManagerRegisterDeviceChangeCallback_005", nullptr,
5362 AudioRoutingManagerRegisterDeviceChangeCallback_005, nullptr, nullptr, nullptr, napi_default, nullptr},
5363 {"audioRoutingManagerRegisterDeviceChangeCallback_006", nullptr,
5364 AudioRoutingManagerRegisterDeviceChangeCallback_006, nullptr, nullptr, nullptr, napi_default, nullptr},
5365 {"audioRoutingManagerRegisterDeviceChangeCallback_007", nullptr,
5366 AudioRoutingManagerRegisterDeviceChangeCallback_007, nullptr, nullptr, nullptr, napi_default, nullptr},
5367 {"audioRoutingManagerRegisterDeviceChangeCallback_008", nullptr,
5368 AudioRoutingManagerRegisterDeviceChangeCallback_008, nullptr, nullptr, nullptr, napi_default, nullptr},
5369 {"audioRoutingManagerUnregisterDeviceChangeCallback_001", nullptr,
5370 AudioRoutingManagerUnregisterDeviceChangeCallback_001, nullptr, nullptr, nullptr, napi_default, nullptr},
5371 {"audioRoutingManagerUnregisterDeviceChangeCallback_002", nullptr,
5372 AudioRoutingManagerUnregisterDeviceChangeCallback_002, nullptr, nullptr, nullptr, napi_default, nullptr},
5373 {"audioRoutingManagerUnregisterDeviceChangeCallback_003", nullptr,
5374 AudioRoutingManagerUnregisterDeviceChangeCallback_003, nullptr, nullptr, nullptr, napi_default, nullptr},
5375 {"audioRoutingManagerReleaseDevices_001", nullptr, AudioRoutingManagerReleaseDevices_001,
5376 nullptr, nullptr, nullptr, napi_default, nullptr},
5377 {"audioRoutingManagerReleaseDevices_002", nullptr, AudioRoutingManagerReleaseDevices_002,
5378 nullptr, nullptr, nullptr, napi_default, nullptr},
5379 {"audioAudioDeviceDescriptorGetDeviceType_001", nullptr, AudioAudioDeviceDescriptorGetDeviceType_001,
5380 nullptr, nullptr, nullptr, napi_default, nullptr},
5381 {"audioAudioDeviceDescriptorGetDeviceType_002", nullptr, AudioAudioDeviceDescriptorGetDeviceType_002,
5382 nullptr, nullptr, nullptr, napi_default, nullptr},
5383 {"audioAudioDeviceDescriptorGetDeviceType_003", nullptr, AudioAudioDeviceDescriptorGetDeviceType_003,
5384 nullptr, nullptr, nullptr, napi_default, nullptr},
5385 {"audioAudioDeviceDescriptorGetDeviceRole_001", nullptr, AudioAudioDeviceDescriptorGetDeviceRole_001,
5386 nullptr, nullptr, nullptr, napi_default, nullptr},
5387 {"audioAudioDeviceDescriptorGetDeviceRole_002", nullptr, AudioAudioDeviceDescriptorGetDeviceRole_002,
5388 nullptr, nullptr, nullptr, napi_default, nullptr},
5389 {"audioAudioDeviceDescriptorGetDeviceRole_003", nullptr, AudioAudioDeviceDescriptorGetDeviceRole_003,
5390 nullptr, nullptr, nullptr, napi_default, nullptr},
5391 {"audioAudioDeviceDescriptorGetDeviceId_001", nullptr, AudioAudioDeviceDescriptorGetDeviceId_001,
5392 nullptr, nullptr, nullptr, napi_default, nullptr},
5393 {"audioAudioDeviceDescriptorGetDeviceId_002", nullptr, AudioAudioDeviceDescriptorGetDeviceId_002,
5394 nullptr, nullptr, nullptr, napi_default, nullptr},
5395 {"audioAudioDeviceDescriptorGetDeviceId_003", nullptr, AudioAudioDeviceDescriptorGetDeviceId_003,
5396 nullptr, nullptr, nullptr, napi_default, nullptr},
5397 {"audioAudioDeviceDescriptorGetDeviceName_001", nullptr, AudioAudioDeviceDescriptorGetDeviceName_001,
5398 nullptr, nullptr, nullptr, napi_default, nullptr},
5399 {"audioAudioDeviceDescriptorGetDeviceName_002", nullptr, AudioAudioDeviceDescriptorGetDeviceName_002,
5400 nullptr, nullptr, nullptr, napi_default, nullptr},
5401 {"audioAudioDeviceDescriptorGetDeviceName_003", nullptr, AudioAudioDeviceDescriptorGetDeviceName_003,
5402 nullptr, nullptr, nullptr, napi_default, nullptr},
5403 {"audioAudioDeviceDescriptorGetDeviceAddress_001", nullptr, AudioAudioDeviceDescriptorGetDeviceAddress_001,
5404 nullptr, nullptr, nullptr, napi_default, nullptr},
5405 {"audioAudioDeviceDescriptorGetDeviceAddress_002", nullptr, AudioAudioDeviceDescriptorGetDeviceAddress_002,
5406 nullptr, nullptr, nullptr, napi_default, nullptr},
5407 {"audioAudioDeviceDescriptorGetDeviceAddress_003", nullptr, AudioAudioDeviceDescriptorGetDeviceAddress_003,
5408 nullptr, nullptr, nullptr, napi_default, nullptr},
5409 {"audioAudioDeviceDescriptorGetDeviceSampleRates_001", nullptr,
5410 AudioAudioDeviceDescriptorGetDeviceSampleRates_001, nullptr, nullptr, nullptr, napi_default, nullptr},
5411 {"audioAudioDeviceDescriptorGetDeviceSampleRates_002", nullptr,
5412 AudioAudioDeviceDescriptorGetDeviceSampleRates_002, nullptr, nullptr, nullptr, napi_default, nullptr},
5413 {"audioAudioDeviceDescriptorGetDeviceSampleRates_003", nullptr,
5414 AudioAudioDeviceDescriptorGetDeviceSampleRates_003, nullptr, nullptr, nullptr, napi_default, nullptr},
5415 {"audioAudioDeviceDescriptorGetDeviceSampleRates_004", nullptr,
5416 AudioAudioDeviceDescriptorGetDeviceSampleRates_004, nullptr, nullptr, nullptr, napi_default, nullptr},
5417 {"audioAudioDeviceDescriptorGetDeviceChannelCounts_001", nullptr,
5418 AudioAudioDeviceDescriptorGetDeviceChannelCounts_001, nullptr, nullptr, nullptr, napi_default, nullptr},
5419 {"audioAudioDeviceDescriptorGetDeviceChannelCounts_002", nullptr,
5420 AudioAudioDeviceDescriptorGetDeviceChannelCounts_002, nullptr, nullptr, nullptr, napi_default, nullptr},
5421 {"audioAudioDeviceDescriptorGetDeviceChannelCounts_003", nullptr,
5422 AudioAudioDeviceDescriptorGetDeviceChannelCounts_003, nullptr, nullptr, nullptr, napi_default, nullptr},
5423 {"audioAudioDeviceDescriptorGetDeviceChannelCounts_004", nullptr,
5424 AudioAudioDeviceDescriptorGetDeviceChannelCounts_004, nullptr, nullptr, nullptr, napi_default, nullptr},
5425 {"audioAudioDeviceDescriptorGetDeviceDisplayName_001", nullptr,
5426 AudioAudioDeviceDescriptorGetDeviceDisplayName_001, nullptr, nullptr, nullptr, napi_default, nullptr},
5427 {"audioAudioDeviceDescriptorGetDeviceDisplayName_002", nullptr,
5428 AudioAudioDeviceDescriptorGetDeviceDisplayName_002, nullptr, nullptr, nullptr, napi_default, nullptr},
5429 {"audioAudioDeviceDescriptorGetDeviceDisplayName_003", nullptr,
5430 AudioAudioDeviceDescriptorGetDeviceDisplayName_003, nullptr, nullptr, nullptr, napi_default, nullptr},
5431 {"audioAudioDeviceDescriptorGetDeviceEncodingTypes_001", nullptr,
5432 AudioAudioDeviceDescriptorGetDeviceEncodingTypes_001, nullptr, nullptr, nullptr, napi_default, nullptr},
5433 {"audioAudioDeviceDescriptorGetDeviceEncodingTypes_002", nullptr,
5434 AudioAudioDeviceDescriptorGetDeviceEncodingTypes_002, nullptr, nullptr, nullptr, napi_default, nullptr},
5435 {"audioAudioDeviceDescriptorGetDeviceEncodingTypes_003", nullptr,
5436 AudioAudioDeviceDescriptorGetDeviceEncodingTypes_003, nullptr, nullptr, nullptr, napi_default, nullptr},
5437 {"audioAudioDeviceDescriptorGetDeviceEncodingTypes_004", nullptr,
5438 AudioAudioDeviceDescriptorGetDeviceEncodingTypes_004, nullptr, nullptr, nullptr, napi_default, nullptr},
5439 {"audioAudioInternalRecordingSuccess01", nullptr,
5440 AudioAudioInternalRecordingSuccess01, nullptr, nullptr, nullptr, napi_default, nullptr},
5441 {"audioAudioInternalRecordingSuccess02", nullptr,
5442 AudioAudioInternalRecordingSuccess02, nullptr, nullptr, nullptr, napi_default, nullptr},
5443 {"audioAudioInternalRecordingFalse", nullptr,
5444 AudioAudioInternalRecordingFalse, nullptr, nullptr, nullptr, napi_default, nullptr},
5445 {"audioStreamBuilderSetRendererWriteDataCallback_001", nullptr,
5446 AudioStreamBuilderSetRendererWriteDataCallback_001, nullptr, nullptr, nullptr, napi_default, nullptr},
5447 {"audioStreamBuilderSetRendererWriteDataCallback_002", nullptr,
5448 AudioStreamBuilderSetRendererWriteDataCallback_002, nullptr, nullptr, nullptr, napi_default, nullptr},
5449 {"audioCapturerGetOverflowCount_001", nullptr,
5450 audioCapturerGetOverflowCount_001, nullptr, nullptr, nullptr, napi_default, nullptr},
5451 {"AudioSessionManagerStrategy_001", nullptr,
5452 AudioSessionManagerStrategy_001, nullptr, nullptr, nullptr, napi_default, nullptr},
5453 {"AudioSessionManagerStrategy_002", nullptr,
5454 AudioSessionManagerStrategy_002, nullptr, nullptr, nullptr, napi_default, nullptr},
5455 {"AudioSessionManagerStrategy_003", nullptr,
5456 AudioSessionManagerStrategy_003, nullptr, nullptr, nullptr, napi_default, nullptr},
5457 {"AudioSessionManagerStrategy_004", nullptr,
5458 AudioSessionManagerStrategy_004, nullptr, nullptr, nullptr, napi_default, nullptr},
5459 {"AudioSessionManagerStrategyError_001", nullptr,
5460 AudioSessionManagerStrategyError_001, nullptr, nullptr, nullptr, napi_default, nullptr},
5461 {"AudioSessionManagerActivatedError_001", nullptr,
5462 AudioSessionManagerActivatedError_001, nullptr, nullptr, nullptr, napi_default, nullptr},
5463 {"AudioSessionManagerStopError_001", nullptr,
5464 AudioSessionManagerStopError_001, nullptr, nullptr, nullptr, napi_default, nullptr},
5465 {"AudioSessionManagerStopError_002", nullptr,
5466 AudioSessionManagerStopError_002, nullptr, nullptr, nullptr, napi_default, nullptr},
5467 {"AudioSessionManagerRegisterError_001", nullptr,
5468 AudioSessionManagerRegisterError_001, nullptr, nullptr, nullptr, napi_default, nullptr},
5469 {"AudioSessionManagerRegisterError_002", nullptr,
5470 AudioSessionManagerRegisterError_002, nullptr, nullptr, nullptr, napi_default, nullptr},
5471 {"AudioSessionManagerUnregisterError_001", nullptr,
5472 AudioSessionManagerUnregisterError_001, nullptr, nullptr, nullptr, napi_default, nullptr},
5473 {"AudioSessionManagerUnregisterError_002", nullptr,
5474 AudioSessionManagerUnregisterError_002, nullptr, nullptr, nullptr, napi_default, nullptr},
5475 {"AudioSessionManagerReason_001", nullptr,
5476 AudioSessionManagerReason_001, nullptr, nullptr, nullptr, napi_default, nullptr},
5477 {"AudioSessionManagerReason_002", nullptr,
5478 AudioSessionManagerReason_002, nullptr, nullptr, nullptr, napi_default, nullptr},
5479 {"audioRendererSetDefaultOutputDevice_01", nullptr,
5480 AudioRendererSetDefaultOutputDevice_01, nullptr, nullptr, nullptr, napi_default, nullptr},
5481 {"audioRendererSetDefaultOutputDevice_02", nullptr,
5482 AudioRendererSetDefaultOutputDevice_02, nullptr, nullptr, nullptr, napi_default, nullptr},
5483 {"audioRendererSetDefaultOutputDevice_03", nullptr,
5484 AudioRendererSetDefaultOutputDevice_03, nullptr, nullptr, nullptr, napi_default, nullptr},
5485 {"audioCapturerInit", nullptr, AudioCapturerInit, nullptr, nullptr, nullptr, napi_default, nullptr},
5486 {"audioCapturerStart", nullptr, AudioCapturerStart, nullptr, nullptr, nullptr, napi_default, nullptr},
5487 {"audioCapturerStop", nullptr, AudioCapturerStop, nullptr, nullptr, nullptr, napi_default, nullptr},
5488 {"audioCapturerRelease", nullptr, AudioCapturerRelease, nullptr, nullptr, nullptr, napi_default, nullptr},
5489 {"audioRendererInit", nullptr, AudioRendererInit, nullptr, nullptr, nullptr, napi_default, nullptr},
5490 {"audioRendererStart", nullptr, AudioRendererStart, nullptr, nullptr, nullptr, napi_default, nullptr},
5491 {"audioRendererStop", nullptr, AudioRendererStop, nullptr, nullptr, nullptr, napi_default, nullptr},
5492 {"audioRendererRelease", nullptr, AudioRendererRelease, nullptr, nullptr, nullptr, napi_default, nullptr},
5493 };
5494
Init(napi_env env,napi_value exports)5495 static napi_value Init(napi_env env, napi_value exports)
5496 {
5497 size_t mergedLength = sizeof(desc1) / sizeof(desc1[0]) +
5498 sizeof(desc2) / sizeof(desc2[0]);
5499 napi_property_descriptor mergedArray[mergedLength];
5500 for (size_t i = 0; i < sizeof(desc1) / sizeof(desc1[0]); ++i) {
5501 mergedArray[i] = desc1[i];
5502 }
5503 for (size_t i = 0; i < sizeof(desc2) / sizeof(desc2[0]); ++i) {
5504 mergedArray[sizeof(desc1) / sizeof(desc1[0]) + i] = desc2[i];
5505 }
5506 napi_define_properties(env, exports, mergedLength, mergedArray);
5507 return exports;
5508 }
5509 EXTERN_C_END
5510
5511 /*
5512
5513 * module define
5514 */
5515 static napi_module g_module = {
5516 .nm_version = 1,
5517 .nm_flags = 0,
5518 .nm_filename = nullptr,
5519 .nm_register_func = Init,
5520 .nm_modname = "entry",
5521 .nm_priv = ((void *)0),
5522 .reserved = {0}};
5523
5524 /*
5525 * module register
5526 */
RegisterEntryModule(void)5527 extern "C" __attribute__((constructor)) void RegisterEntryModule(void)
5528 {
5529 napi_module_register(&g_module);
5530 }