1 /*
2 * Copyright (c) 2024 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 #include "audio_haptic_unit_test.h"
17
18 #include "media_errors.h"
19 #include <fcntl.h>
20 #include <sys/stat.h>
21
22 namespace OHOS {
23 namespace Media {
24 using namespace std;
25 using namespace testing::ext;
26 using namespace Security::AccessToken;
27 using Security::AccessToken::AccessTokenID;
28
29 const std::string AUDIO_TEST_URI = "ringtone.ogg";
30 const std::string HAPTIC_TEST_URI = "ringtone.json";
31 const std::string HAPTIC_TEST_EFFECT_ID = "haptic.clock.timer";
32
33 static std::shared_ptr<AudioHapticManager> g_audioHapticManager = nullptr;
34
35 static int32_t g_normalSourceId = -1;
36 static int32_t g_lowLatencySourceId = -1;
37 static int32_t g_effectSourceId = -1;
38 static int32_t g_nonSyncSourceId = -1;
39 static std::shared_ptr<AudioHapticPlayer> g_normalAudioHapticPlayer = nullptr;
40 static std::shared_ptr<AudioHapticPlayer> g_lowLatencyAudioHapticPlayer = nullptr;
41 static std::shared_ptr<AudioHapticPlayer> g_effectAudioHapticPlayer = nullptr;
42 static std::shared_ptr<AudioHapticPlayer> g_nonSyncAudioHapticPlayer = nullptr;
43
44 static AccessTokenID g_tokenId = 0;
45
SetUpTestCase(void)46 void AudioHapticUnitTest::SetUpTestCase(void)
47 {
48 // SetSelfTokenID to foundation for ohos.permission.VIBRATE
49 g_tokenId = AccessTokenKit::GetNativeTokenId("foundation");
50 ASSERT_NE(0, g_tokenId);
51 ASSERT_EQ(0, SetSelfTokenID(g_tokenId));
52
53 g_audioHapticManager = AudioHapticManagerFactory::CreateAudioHapticManager();
54 ASSERT_NE(g_audioHapticManager, nullptr);
55
56 // Initilize normal audio haptic player.
57 g_normalSourceId = g_audioHapticManager->RegisterSource(AUDIO_TEST_URI, HAPTIC_TEST_URI);
58 AudioLatencyMode latencyMode = AudioLatencyMode::AUDIO_LATENCY_MODE_NORMAL;
59 g_audioHapticManager->SetAudioLatencyMode(g_normalSourceId, latencyMode);
60 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_MUSIC;
61 g_audioHapticManager->SetStreamUsage(g_normalSourceId, streamUsage);
62 AudioHapticPlayerOptions options = {false, false};
63 g_normalAudioHapticPlayer = g_audioHapticManager->CreatePlayer(g_normalSourceId, options);
64 ASSERT_NE(g_normalAudioHapticPlayer, nullptr);
65
66 // Initilize low latency audio haptic player.
67 g_lowLatencySourceId = g_audioHapticManager->RegisterSource(AUDIO_TEST_URI, HAPTIC_TEST_URI);
68 latencyMode = AudioLatencyMode::AUDIO_LATENCY_MODE_FAST;
69 g_audioHapticManager->SetAudioLatencyMode(g_lowLatencySourceId, latencyMode);
70 streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_GAME;
71 g_audioHapticManager->SetStreamUsage(g_lowLatencySourceId, streamUsage);
72 g_lowLatencyAudioHapticPlayer = g_audioHapticManager->CreatePlayer(g_lowLatencySourceId, options);
73 ASSERT_NE(g_lowLatencyAudioHapticPlayer, nullptr);
74
75 g_effectSourceId = g_audioHapticManager->RegisterSourceWithEffectId(AUDIO_TEST_URI, HAPTIC_TEST_EFFECT_ID);
76 latencyMode = AudioLatencyMode::AUDIO_LATENCY_MODE_FAST;
77 g_audioHapticManager->SetAudioLatencyMode(g_effectSourceId, latencyMode);
78 streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_NOTIFICATION;
79 g_audioHapticManager->SetStreamUsage(g_effectSourceId, streamUsage);
80 g_effectAudioHapticPlayer = g_audioHapticManager->CreatePlayer(g_effectSourceId, options);
81 ASSERT_NE(g_effectAudioHapticPlayer, nullptr);
82
83 int32_t fd = open(HAPTIC_TEST_URI.c_str(), O_RDONLY);
84 ASSERT_NE(-1, fd);
85 std::string newHapticUri = "fd://" + to_string(fd);
86 g_nonSyncSourceId = g_audioHapticManager->RegisterSource(AUDIO_TEST_URI, newHapticUri);
87 latencyMode = AudioLatencyMode::AUDIO_LATENCY_MODE_NORMAL;
88 g_audioHapticManager->SetAudioLatencyMode(g_nonSyncSourceId, latencyMode);
89 streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_MUSIC;
90 g_audioHapticManager->SetStreamUsage(g_nonSyncSourceId, streamUsage);
91 g_nonSyncAudioHapticPlayer = g_audioHapticManager->CreatePlayer(g_nonSyncSourceId, options);
92 ASSERT_NE(g_nonSyncAudioHapticPlayer, nullptr);
93 }
94
TearDownTestCase(void)95 void AudioHapticUnitTest::TearDownTestCase(void)
96 {
97 }
98
SetUp(void)99 void AudioHapticUnitTest::SetUp(void) {}
100
TearDown(void)101 void AudioHapticUnitTest::TearDown(void) {}
102
103 /**
104 * @tc.name : Test AudioHapticManager RegisterSource API
105 * @tc.number: AudioHapticManager_RegisterSource_001
106 * @tc.desc : Test AudioHapticManager RegisterSource interface
107 */
108 HWTEST_F(AudioHapticUnitTest, AudioHapticManager_RegisterSource_001, TestSize.Level1)
109 {
110 EXPECT_NE(g_audioHapticManager, nullptr);
111
112 std::string audioUri = AUDIO_TEST_URI;
113 std::string hapticUri = HAPTIC_TEST_URI;
114 int32_t sourceId = g_audioHapticManager->RegisterSource(audioUri, hapticUri);
115 EXPECT_NE(-1, sourceId);
116
117 g_audioHapticManager->UnregisterSource(sourceId);
118 }
119
120 /**
121 * @tc.name : Test AudioHapticManager RegisterSourceWithEffectId API
122 * @tc.number: AudioHapticManager_RegisterSourceWithEffectId_001
123 * @tc.desc : Test AudioHapticManager RegisterSourceWithEffectId interface
124 */
125 HWTEST_F(AudioHapticUnitTest, AudioHapticManager_RegisterSourceWithEffectId_001, TestSize.Level1)
126 {
127 EXPECT_NE(g_audioHapticManager, nullptr);
128
129 std::string audioUri = AUDIO_TEST_URI;
130 std::string effectId = HAPTIC_TEST_EFFECT_ID;
131 int32_t sourceId = g_audioHapticManager->RegisterSourceWithEffectId(audioUri, effectId);
132 EXPECT_NE(-1, sourceId);
133
134 g_audioHapticManager->UnregisterSource(sourceId);
135 }
136
137 /**
138 * @tc.name : Test AudioHapticManager UnregisterSource API
139 * @tc.number: AudioHapticManager_UnregisterSource_001
140 * @tc.desc : Test AudioHapticManager UnregisterSource interface
141 */
142 HWTEST_F(AudioHapticUnitTest, AudioHapticManager_UnregisterSource_001, TestSize.Level1)
143 {
144 EXPECT_NE(g_audioHapticManager, nullptr);
145
146 std::string audioUri = AUDIO_TEST_URI;
147 std::string hapticUri = HAPTIC_TEST_URI;
148 int32_t sourceId = g_audioHapticManager->RegisterSource(audioUri, hapticUri);
149 EXPECT_NE(-1, sourceId);
150
151 int32_t result = g_audioHapticManager->UnregisterSource(sourceId);
152 EXPECT_EQ(MSERR_OK, result);
153 }
154
155 /**
156 * @tc.name : Test AudioHapticManager UnregisterSource API
157 * @tc.number: AudioHapticManager_UnregisterSource_002
158 * @tc.desc : Test AudioHapticManager UnregisterSource interface
159 */
160 HWTEST_F(AudioHapticUnitTest, AudioHapticManager_UnregisterSource_002, TestSize.Level1)
161 {
162 EXPECT_NE(g_audioHapticManager, nullptr);
163
164 int32_t sourceId = -1;
165 int32_t result = g_audioHapticManager->UnregisterSource(sourceId);
166 EXPECT_NE(MSERR_OK, result);
167 }
168
169 /**
170 * @tc.name : Test AudioHapticManager UnregisterSource API
171 * @tc.number: AudioHapticManager_UnregisterSource_003
172 * @tc.desc : Test AudioHapticManager UnregisterSource interface
173 */
174 HWTEST_F(AudioHapticUnitTest, AudioHapticManager_UnregisterSource_003, TestSize.Level1)
175 {
176 EXPECT_NE(g_audioHapticManager, nullptr);
177
178 std::string audioUri = AUDIO_TEST_URI;
179 std::string effectId = HAPTIC_TEST_EFFECT_ID;
180 int32_t sourceId = g_audioHapticManager->RegisterSourceWithEffectId(audioUri, effectId);
181 EXPECT_NE(-1, sourceId);
182
183 int32_t result = g_audioHapticManager->UnregisterSource(sourceId);
184 EXPECT_EQ(MSERR_OK, result);
185 }
186
187 /**
188 * @tc.name : Test AudioHapticManager SetAudioLatencyMode API
189 * @tc.number: AudioHapticManager_SetAudioLatencyMode_001
190 * @tc.desc : Test AudioHapticManager SetAudioLatencyMode interface
191 */
192 HWTEST_F(AudioHapticUnitTest, AudioHapticManager_SetAudioLatencyMode_001, TestSize.Level1)
193 {
194 EXPECT_NE(g_audioHapticManager, nullptr);
195
196 std::string audioUri = AUDIO_TEST_URI;
197 std::string hapticUri = HAPTIC_TEST_URI;
198 int32_t sourceId = g_audioHapticManager->RegisterSource(audioUri, hapticUri);
199 EXPECT_NE(-1, sourceId);
200
201 AudioLatencyMode latencyMode = AudioLatencyMode::AUDIO_LATENCY_MODE_FAST;
202 int32_t result = g_audioHapticManager->SetAudioLatencyMode(sourceId, latencyMode);
203 EXPECT_EQ(MSERR_OK, result);
204
205 g_audioHapticManager->UnregisterSource(sourceId);
206 }
207
208 /**
209 * @tc.name : Test AudioHapticManager SetAudioLatencyMode API
210 * @tc.number: AudioHapticManager_SetAudioLatencyMode_002
211 * @tc.desc : Test AudioHapticManager SetAudioLatencyMode interface
212 */
213 HWTEST_F(AudioHapticUnitTest, AudioHapticManager_SetAudioLatencyMode_002, TestSize.Level1)
214 {
215 EXPECT_NE(g_audioHapticManager, nullptr);
216
217 std::string audioUri = AUDIO_TEST_URI;
218 std::string hapticUri = HAPTIC_TEST_URI;
219 int32_t sourceId = g_audioHapticManager->RegisterSource(audioUri, hapticUri);
220 EXPECT_NE(-1, sourceId);
221
222 AudioLatencyMode latencyMode = AudioLatencyMode::AUDIO_LATENCY_MODE_NORMAL;
223 int32_t result = g_audioHapticManager->SetAudioLatencyMode(sourceId, latencyMode);
224 EXPECT_EQ(MSERR_OK, result);
225
226 g_audioHapticManager->UnregisterSource(sourceId);
227 }
228
229 /**
230 * @tc.name : Test AudioHapticManager SetAudioLatencyMode API
231 * @tc.number: AudioHapticManager_SetAudioLatencyMode_003
232 * @tc.desc : Test AudioHapticManager SetAudioLatencyMode interface
233 */
234 HWTEST_F(AudioHapticUnitTest, AudioHapticManager_SetAudioLatencyMode_003, TestSize.Level1)
235 {
236 int32_t sourceId = -1;
237 AudioLatencyMode latencyMode = AudioLatencyMode::AUDIO_LATENCY_MODE_NORMAL;
238 int32_t result = g_audioHapticManager->SetAudioLatencyMode(sourceId, latencyMode);
239 EXPECT_NE(MSERR_OK, result);
240 }
241
242 /**
243 * @tc.name : Test AudioHapticManager SetAudioLatencyMode API
244 * @tc.number: AudioHapticManager_SetAudioLatencyMode_004
245 * @tc.desc : Test AudioHapticManager SetAudioLatencyMode interface
246 */
247 HWTEST_F(AudioHapticUnitTest, AudioHapticManager_SetAudioLatencyMode_004, TestSize.Level1)
248 {
249 EXPECT_NE(g_audioHapticManager, nullptr);
250
251 std::string audioUri = AUDIO_TEST_URI;
252 std::string effectId = HAPTIC_TEST_EFFECT_ID;
253 int32_t sourceId = g_audioHapticManager->RegisterSourceWithEffectId(audioUri, effectId);
254 EXPECT_NE(-1, sourceId);
255
256 AudioLatencyMode latencyMode = AudioLatencyMode::AUDIO_LATENCY_MODE_NORMAL;
257 int32_t result = g_audioHapticManager->SetAudioLatencyMode(sourceId, latencyMode);
258 EXPECT_NE(MSERR_OK, result);
259
260 g_audioHapticManager->UnregisterSource(sourceId);
261 }
262
263 /**
264 * @tc.name : Test AudioHapticManager SetAudioLatencyMode API
265 * @tc.number: AudioHapticManager_SetAudioLatencyMode_005
266 * @tc.desc : Test AudioHapticManager SetAudioLatencyMode interface
267 */
268 HWTEST_F(AudioHapticUnitTest, AudioHapticManager_SetAudioLatencyMode_005, TestSize.Level1)
269 {
270 EXPECT_NE(g_audioHapticManager, nullptr);
271
272 std::string audioUri = AUDIO_TEST_URI;
273 std::string effectId = HAPTIC_TEST_EFFECT_ID;
274 int32_t sourceId = g_audioHapticManager->RegisterSourceWithEffectId(audioUri, effectId);
275 EXPECT_NE(-1, sourceId);
276
277 AudioLatencyMode latencyMode = AudioLatencyMode::AUDIO_LATENCY_MODE_FAST;
278 int32_t result = g_audioHapticManager->SetAudioLatencyMode(sourceId, latencyMode);
279 EXPECT_EQ(MSERR_OK, result);
280
281 g_audioHapticManager->UnregisterSource(sourceId);
282 }
283
284 /**
285 * @tc.name : Test AudioHapticManager SetStreamUsage API
286 * @tc.number: AudioHapticManager_SetStreamUsage_001
287 * @tc.desc : Test AudioHapticManager SetStreamUsage interface
288 */
289 HWTEST_F(AudioHapticUnitTest, AudioHapticManager_SetStreamUsage_001, TestSize.Level1)
290 {
291 EXPECT_NE(g_audioHapticManager, nullptr);
292
293 std::string audioUri = AUDIO_TEST_URI;
294 std::string hapticUri = HAPTIC_TEST_URI;
295 int32_t sourceId = g_audioHapticManager->RegisterSource(audioUri, hapticUri);
296 EXPECT_NE(-1, sourceId);
297
298 int32_t result = MSERR_OK;
299 AudioLatencyMode latencyMode = AudioLatencyMode::AUDIO_LATENCY_MODE_NORMAL;
300 result = g_audioHapticManager->SetAudioLatencyMode(sourceId, latencyMode);
301 EXPECT_EQ(MSERR_OK, result);
302
303 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_MUSIC;
304 result = g_audioHapticManager->SetStreamUsage(sourceId, streamUsage);
305 EXPECT_EQ(MSERR_OK, result);
306
307 g_audioHapticManager->UnregisterSource(sourceId);
308 }
309
310 /**
311 * @tc.name : Test AudioHapticManager SetStreamUsage API
312 * @tc.number: AudioHapticManager_SetStreamUsage_002
313 * @tc.desc : Test AudioHapticManager SetStreamUsage interface
314 */
315 HWTEST_F(AudioHapticUnitTest, AudioHapticManager_SetStreamUsage_002, TestSize.Level1)
316 {
317 EXPECT_NE(g_audioHapticManager, nullptr);
318
319 std::string audioUri = AUDIO_TEST_URI;
320 std::string hapticUri = HAPTIC_TEST_URI;
321 int32_t sourceId = g_audioHapticManager->RegisterSource(audioUri, hapticUri);
322 EXPECT_NE(-1, sourceId);
323
324 int32_t result = MSERR_OK;
325 AudioLatencyMode latencyMode = AudioLatencyMode::AUDIO_LATENCY_MODE_NORMAL;
326 result = g_audioHapticManager->SetAudioLatencyMode(sourceId, latencyMode);
327 EXPECT_EQ(MSERR_OK, result);
328
329 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_RINGTONE;
330 result = g_audioHapticManager->SetStreamUsage(sourceId, streamUsage);
331 EXPECT_EQ(MSERR_OK, result);
332
333 g_audioHapticManager->UnregisterSource(sourceId);
334 }
335
336 /**
337 * @tc.name : Test AudioHapticManager SetStreamUsage API
338 * @tc.number: AudioHapticManager_SetStreamUsage_003
339 * @tc.desc : Test AudioHapticManager SetStreamUsage interface
340 */
341 HWTEST_F(AudioHapticUnitTest, AudioHapticManager_SetStreamUsage_003, TestSize.Level1)
342 {
343 EXPECT_NE(g_audioHapticManager, nullptr);
344
345 std::string audioUri = AUDIO_TEST_URI;
346 std::string hapticUri = HAPTIC_TEST_URI;
347 int32_t sourceId = g_audioHapticManager->RegisterSource(audioUri, hapticUri);
348 EXPECT_NE(-1, sourceId);
349
350 int32_t result = MSERR_OK;
351 AudioLatencyMode latencyMode = AudioLatencyMode::AUDIO_LATENCY_MODE_NORMAL;
352 result = g_audioHapticManager->SetAudioLatencyMode(sourceId, latencyMode);
353 EXPECT_EQ(MSERR_OK, result);
354
355 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_NOTIFICATION;
356 result = g_audioHapticManager->SetStreamUsage(sourceId, streamUsage);
357 EXPECT_EQ(MSERR_OK, result);
358
359 g_audioHapticManager->UnregisterSource(sourceId);
360 }
361
362 /**
363 * @tc.name : Test AudioHapticManager SetStreamUsage API
364 * @tc.number: AudioHapticManager_SetStreamUsage_004
365 * @tc.desc : Test AudioHapticManager SetStreamUsage interface
366 */
367 HWTEST_F(AudioHapticUnitTest, AudioHapticManager_SetStreamUsage_004, TestSize.Level1)
368 {
369 EXPECT_NE(g_audioHapticManager, nullptr);
370
371 std::string audioUri = AUDIO_TEST_URI;
372 std::string hapticUri = HAPTIC_TEST_URI;
373 int32_t sourceId = g_audioHapticManager->RegisterSource(audioUri, hapticUri);
374 EXPECT_NE(-1, sourceId);
375
376 int32_t result = MSERR_OK;
377 AudioLatencyMode latencyMode = AudioLatencyMode::AUDIO_LATENCY_MODE_NORMAL;
378 result = g_audioHapticManager->SetAudioLatencyMode(sourceId, latencyMode);
379 EXPECT_EQ(MSERR_OK, result);
380
381 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_UNKNOWN;
382 result = g_audioHapticManager->SetStreamUsage(sourceId, streamUsage);
383 EXPECT_NE(MSERR_OK, result);
384
385 g_audioHapticManager->UnregisterSource(sourceId);
386 }
387
388 /**
389 * @tc.name : Test AudioHapticManager SetStreamUsage API
390 * @tc.number: AudioHapticManager_SetStreamUsage_005
391 * @tc.desc : Test AudioHapticManager SetStreamUsage interface
392 */
393 HWTEST_F(AudioHapticUnitTest, AudioHapticManager_SetStreamUsage_005, TestSize.Level1)
394 {
395 EXPECT_NE(g_audioHapticManager, nullptr);
396
397 std::string audioUri = AUDIO_TEST_URI;
398 std::string hapticUri = HAPTIC_TEST_URI;
399 int32_t sourceId = -1;
400 int32_t result = MSERR_OK;
401
402 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_MUSIC;
403 result = g_audioHapticManager->SetStreamUsage(sourceId, streamUsage);
404 EXPECT_NE(MSERR_OK, result);
405 }
406
407 /**
408 * @tc.name : Test AudioHapticManager CreatePlayer API
409 * @tc.number: AudioHapticManager_CreatePlayer_001
410 * @tc.desc : Test AudioHapticManager CreatePlayer interface
411 */
412 HWTEST_F(AudioHapticUnitTest, AudioHapticManager_CreatePlayer_001, TestSize.Level1)
413 {
414 EXPECT_NE(g_audioHapticManager, nullptr);
415
416 std::string audioUri = AUDIO_TEST_URI;
417 std::string hapticUri = HAPTIC_TEST_URI;
418 int32_t sourceId = g_audioHapticManager->RegisterSource(audioUri, hapticUri);
419 EXPECT_NE(-1, sourceId);
420
421 int32_t result = MSERR_OK;
422 AudioLatencyMode latencyMode = AudioLatencyMode::AUDIO_LATENCY_MODE_NORMAL;
423 result = g_audioHapticManager->SetAudioLatencyMode(sourceId, latencyMode);
424 EXPECT_EQ(MSERR_OK, result);
425
426 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_MUSIC;
427 result = g_audioHapticManager->SetStreamUsage(sourceId, streamUsage);
428 EXPECT_EQ(MSERR_OK, result);
429
430 AudioHapticPlayerOptions options;
431 options.muteAudio = false;
432 options.muteHaptics = false;
433 std::shared_ptr<AudioHapticPlayer> audioHapticPlayer =
434 g_audioHapticManager->CreatePlayer(sourceId, options);
435 EXPECT_NE(nullptr, audioHapticPlayer);
436
437 g_audioHapticManager->UnregisterSource(sourceId);
438 }
439
440 /**
441 * @tc.name : Test AudioHapticManager CreatePlayer API
442 * @tc.number: AudioHapticManager_CreatePlayer_002
443 * @tc.desc : Test AudioHapticManager CreatePlayer interface
444 */
445 HWTEST_F(AudioHapticUnitTest, AudioHapticManager_CreatePlayer_002, TestSize.Level1)
446 {
447 EXPECT_NE(g_audioHapticManager, nullptr);
448
449 std::string audioUri = AUDIO_TEST_URI;
450 std::string hapticUri = HAPTIC_TEST_URI;
451 int32_t sourceId = g_audioHapticManager->RegisterSource(audioUri, hapticUri);
452 EXPECT_NE(-1, sourceId);
453
454 int32_t result = MSERR_OK;
455 AudioLatencyMode latencyMode = AudioLatencyMode::AUDIO_LATENCY_MODE_NORMAL;
456 result = g_audioHapticManager->SetAudioLatencyMode(sourceId, latencyMode);
457 EXPECT_EQ(MSERR_OK, result);
458
459 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_MUSIC;
460 result = g_audioHapticManager->SetStreamUsage(sourceId, streamUsage);
461 EXPECT_EQ(MSERR_OK, result);
462
463 AudioHapticPlayerOptions options;
464 options.muteAudio = true;
465 options.muteHaptics = false;
466 std::shared_ptr<AudioHapticPlayer> audioHapticPlayer =
467 g_audioHapticManager->CreatePlayer(sourceId, options);
468 EXPECT_NE(nullptr, audioHapticPlayer);
469
470 g_audioHapticManager->UnregisterSource(sourceId);
471 }
472
473 /**
474 * @tc.name : Test AudioHapticManager CreatePlayer API
475 * @tc.number: AudioHapticManager_CreatePlayer_003
476 * @tc.desc : Test AudioHapticManager CreatePlayer interface
477 */
478 HWTEST_F(AudioHapticUnitTest, AudioHapticManager_CreatePlayer_003, TestSize.Level1)
479 {
480 EXPECT_NE(g_audioHapticManager, nullptr);
481
482 std::string audioUri = AUDIO_TEST_URI;
483 std::string hapticUri = HAPTIC_TEST_URI;
484 int32_t sourceId = g_audioHapticManager->RegisterSource(audioUri, hapticUri);
485 EXPECT_NE(-1, sourceId);
486
487 int32_t result = MSERR_OK;
488 AudioLatencyMode latencyMode = AudioLatencyMode::AUDIO_LATENCY_MODE_NORMAL;
489 result = g_audioHapticManager->SetAudioLatencyMode(sourceId, latencyMode);
490 EXPECT_EQ(MSERR_OK, result);
491
492 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_MUSIC;
493 result = g_audioHapticManager->SetStreamUsage(sourceId, streamUsage);
494 EXPECT_EQ(MSERR_OK, result);
495
496 AudioHapticPlayerOptions options;
497 options.muteAudio = false;
498 options.muteHaptics = true;
499 std::shared_ptr<AudioHapticPlayer> audioHapticPlayer =
500 g_audioHapticManager->CreatePlayer(sourceId, options);
501 EXPECT_NE(nullptr, audioHapticPlayer);
502
503 g_audioHapticManager->UnregisterSource(sourceId);
504 }
505
506 /**
507 * @tc.name : Test AudioHapticManager CreatePlayer API
508 * @tc.number: AudioHapticManager_CreatePlayer_004
509 * @tc.desc : Test AudioHapticManager CreatePlayer interface
510 */
511 HWTEST_F(AudioHapticUnitTest, AudioHapticManager_CreatePlayer_004, TestSize.Level1)
512 {
513 EXPECT_NE(g_audioHapticManager, nullptr);
514
515 std::string audioUri = AUDIO_TEST_URI;
516 std::string hapticUri = HAPTIC_TEST_URI;
517 int32_t sourceId = g_audioHapticManager->RegisterSource(audioUri, hapticUri);
518 EXPECT_NE(-1, sourceId);
519
520 int32_t result = MSERR_OK;
521 AudioLatencyMode latencyMode = AudioLatencyMode::AUDIO_LATENCY_MODE_NORMAL;
522 result = g_audioHapticManager->SetAudioLatencyMode(sourceId, latencyMode);
523 EXPECT_EQ(MSERR_OK, result);
524
525 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_MUSIC;
526 result = g_audioHapticManager->SetStreamUsage(sourceId, streamUsage);
527 EXPECT_EQ(MSERR_OK, result);
528
529 AudioHapticPlayerOptions options;
530 options.muteAudio = true;
531 options.muteHaptics = true;
532 std::shared_ptr<AudioHapticPlayer> audioHapticPlayer =
533 g_audioHapticManager->CreatePlayer(sourceId, options);
534 EXPECT_NE(nullptr, audioHapticPlayer);
535
536 g_audioHapticManager->UnregisterSource(sourceId);
537 }
538
539 /**
540 * @tc.name : Test AudioHapticManager CreatePlayer API
541 * @tc.number: AudioHapticManager_CreatePlayer_005
542 * @tc.desc : Test AudioHapticManager CreatePlayer interface
543 */
544 HWTEST_F(AudioHapticUnitTest, AudioHapticManager_CreatePlayer_005, TestSize.Level1)
545 {
546 EXPECT_NE(g_audioHapticManager, nullptr);
547
548 AudioHapticPlayerOptions options;
549 options.muteAudio = false;
550 options.muteHaptics = false;
551 std::shared_ptr<AudioHapticPlayer> audioHapticPlayer =
552 g_audioHapticManager->CreatePlayer(-1, options);
553 EXPECT_EQ(nullptr, audioHapticPlayer);
554 }
555
556 /**
557 * @tc.name : Test AudioHapticManager CreatePlayer API
558 * @tc.number: AudioHapticManager_CreatePlayer_006
559 * @tc.desc : Test AudioHapticManager CreatePlayer interface
560 */
561 HWTEST_F(AudioHapticUnitTest, AudioHapticManager_CreatePlayer_006, TestSize.Level1)
562 {
563 EXPECT_NE(g_audioHapticManager, nullptr);
564
565 std::string audioUri = AUDIO_TEST_URI;
566 std::string hapticUri = HAPTIC_TEST_URI;
567 int32_t fd = open(hapticUri.c_str(), O_RDONLY);
568 EXPECT_NE(-1, fd);
569 std::string newHapticUri = "fd://" + to_string(fd);
570
571 int32_t sourceId = g_audioHapticManager->RegisterSource(audioUri, newHapticUri);
572 EXPECT_NE(-1, sourceId);
573
574 int32_t result = MSERR_OK;
575 AudioLatencyMode latencyMode = AudioLatencyMode::AUDIO_LATENCY_MODE_NORMAL;
576 result = g_audioHapticManager->SetAudioLatencyMode(sourceId, latencyMode);
577 EXPECT_EQ(MSERR_OK, result);
578
579 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_MUSIC;
580 result = g_audioHapticManager->SetStreamUsage(sourceId, streamUsage);
581 EXPECT_EQ(MSERR_OK, result);
582
583 AudioHapticPlayerOptions options = {false, false};
584 std::shared_ptr<AudioHapticPlayer> audioHapticPlayer =
585 g_audioHapticManager->CreatePlayer(sourceId, options);
586 EXPECT_NE(nullptr, audioHapticPlayer);
587
588 g_audioHapticManager->UnregisterSource(sourceId);
589 }
590
591 /**
592 * @tc.name : Test AudioHapticPlayer IsMuted API
593 * @tc.number: AudioHapticPlayer_IsMuted_001
594 * @tc.desc : Test AudioHapticPlayer IsMuted interface
595 */
596 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_IsMuted_001, TestSize.Level1)
597 {
598 EXPECT_NE(g_normalAudioHapticPlayer, nullptr);
599
600 AudioHapticType type = AudioHapticType::AUDIO_HAPTIC_TYPE_AUDIO;
601 bool result = g_normalAudioHapticPlayer->IsMuted(type);
602 EXPECT_EQ(false, result);
603 }
604
605 /**
606 * @tc.name : Test AudioHapticPlayer IsMuted API
607 * @tc.number: AudioHapticPlayer_IsMuted_002
608 * @tc.desc : Test AudioHapticPlayer IsMuted interface
609 */
610 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_IsMuted_002, TestSize.Level1)
611 {
612 EXPECT_NE(g_normalAudioHapticPlayer, nullptr);
613
614 AudioHapticType type = AudioHapticType::AUDIO_HAPTIC_TYPE_HAPTIC;
615 bool result = g_normalAudioHapticPlayer->IsMuted(type);
616 EXPECT_EQ(false, result);
617 }
618
619 /**
620 * @tc.name : Test AudioHapticPlayer SetVolume API
621 * @tc.number: AudioHapticPlayer_SetVolume_001
622 * @tc.desc : Test AudioHapticPlayer SetVolume interface
623 */
624 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_SetVolume_001, TestSize.Level1)
625 {
626 EXPECT_NE(g_normalAudioHapticPlayer, nullptr);
627
628 float volume = 0.0f;
629 int32_t result = g_normalAudioHapticPlayer->SetVolume(volume);
630 EXPECT_EQ(MSERR_OK, result);
631 }
632
633 /**
634 * @tc.name : Test AudioHapticPlayer SetVolume API
635 * @tc.number: AudioHapticPlayer_SetVolume_002
636 * @tc.desc : Test AudioHapticPlayer SetVolume interface
637 */
638 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_SetVolume_002, TestSize.Level1)
639 {
640 EXPECT_NE(g_normalAudioHapticPlayer, nullptr);
641
642 float volume = 0.5f;
643 int32_t result = g_normalAudioHapticPlayer->SetVolume(volume);
644 EXPECT_EQ(MSERR_OK, result);
645 }
646
647 /**
648 * @tc.name : Test AudioHapticPlayer SetVolume API
649 * @tc.number: AudioHapticPlayer_SetVolume_003
650 * @tc.desc : Test AudioHapticPlayer SetVolume interface
651 */
652 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_SetVolume_003, TestSize.Level1)
653 {
654 EXPECT_NE(g_normalAudioHapticPlayer, nullptr);
655
656 float volume = 1.0f;
657 int32_t result = g_normalAudioHapticPlayer->SetVolume(volume);
658 EXPECT_EQ(MSERR_OK, result);
659 }
660
661 /**
662 * @tc.name : Test AudioHapticPlayer SetVolume API
663 * @tc.number: AudioHapticPlayer_SetVolume_004
664 * @tc.desc : Test AudioHapticPlayer SetVolume interface
665 */
666 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_SetVolume_004, TestSize.Level1)
667 {
668 EXPECT_NE(g_normalAudioHapticPlayer, nullptr);
669
670 float volume = -0.5f;
671 int32_t result = g_normalAudioHapticPlayer->SetVolume(volume);
672 EXPECT_NE(MSERR_OK, result);
673 }
674
675 /**
676 * @tc.name : Test AudioHapticPlayer SetVolume API
677 * @tc.number: AudioHapticPlayer_SetVolume_005
678 * @tc.desc : Test AudioHapticPlayer SetVolume interface
679 */
680 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_SetVolume_005, TestSize.Level1)
681 {
682 EXPECT_NE(g_normalAudioHapticPlayer, nullptr);
683
684 float volume = 1.5f;
685 int32_t result = g_normalAudioHapticPlayer->SetVolume(volume);
686 EXPECT_NE(MSERR_OK, result);
687 }
688
689 /**
690 * @tc.name : Test AudioHapticPlayer SetVolume API
691 * @tc.number: AudioHapticPlayer_SetVolume_006
692 * @tc.desc : Test AudioHapticPlayer SetVolume interface
693 */
694 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_SetVolume_006, TestSize.Level1)
695 {
696 EXPECT_NE(g_lowLatencyAudioHapticPlayer, nullptr);
697
698 float volume = 0.0f;
699 int32_t result = g_lowLatencyAudioHapticPlayer->SetVolume(volume);
700 EXPECT_EQ(MSERR_OK, result);
701 }
702
703 /**
704 * @tc.name : Test AudioHapticPlayer SetVolume API
705 * @tc.number: AudioHapticPlayer_SetVolume_007
706 * @tc.desc : Test AudioHapticPlayer SetVolume interface
707 */
708 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_SetVolume_007, TestSize.Level1)
709 {
710 EXPECT_NE(g_lowLatencyAudioHapticPlayer, nullptr);
711
712 float volume = 0.5f;
713 int32_t result = g_lowLatencyAudioHapticPlayer->SetVolume(volume);
714 EXPECT_EQ(MSERR_OK, result);
715 }
716
717 /**
718 * @tc.name : Test AudioHapticPlayer SetVolume API
719 * @tc.number: AudioHapticPlayer_SetVolume_008
720 * @tc.desc : Test AudioHapticPlayer SetVolume interface
721 */
722 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_SetVolume_008, TestSize.Level1)
723 {
724 EXPECT_NE(g_lowLatencyAudioHapticPlayer, nullptr);
725
726 float volume = 1.0f;
727 int32_t result = g_lowLatencyAudioHapticPlayer->SetVolume(volume);
728 EXPECT_EQ(MSERR_OK, result);
729 }
730
731 /**
732 * @tc.name : Test AudioHapticPlayer SetVolume API
733 * @tc.number: AudioHapticPlayer_SetVolume_009
734 * @tc.desc : Test AudioHapticPlayer SetVolume interface
735 */
736 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_SetVolume_009, TestSize.Level1)
737 {
738 EXPECT_NE(g_lowLatencyAudioHapticPlayer, nullptr);
739
740 float volume = -0.5f;
741 int32_t result = g_lowLatencyAudioHapticPlayer->SetVolume(volume);
742 EXPECT_NE(MSERR_OK, result);
743 }
744
745 /**
746 * @tc.name : Test AudioHapticPlayer SetVolume API
747 * @tc.number: AudioHapticPlayer_SetVolume_010
748 * @tc.desc : Test AudioHapticPlayer SetVolume interface
749 */
750 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_SetVolume_010, TestSize.Level1)
751 {
752 EXPECT_NE(g_lowLatencyAudioHapticPlayer, nullptr);
753
754 float volume = 1.5f;
755 int32_t result = g_lowLatencyAudioHapticPlayer->SetVolume(volume);
756 EXPECT_NE(MSERR_OK, result);
757 }
758
759 /**
760 * @tc.name : Test AudioHapticPlayer SetVolume API
761 * @tc.number: AudioHapticPlayer_SetVolume_011
762 * @tc.desc : Test AudioHapticPlayer SetVolume interface
763 */
764 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_SetVolume_011, TestSize.Level1)
765 {
766 EXPECT_NE(g_effectAudioHapticPlayer, nullptr);
767
768 float volume = 0.0f;
769 int32_t result = g_effectAudioHapticPlayer->SetVolume(volume);
770 EXPECT_EQ(MSERR_OK, result);
771 }
772
773 /**
774 * @tc.name : Test AudioHapticPlayer SetVolume API
775 * @tc.number: AudioHapticPlayer_SetVolume_012
776 * @tc.desc : Test AudioHapticPlayer SetVolume interface
777 */
778 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_SetVolume_012, TestSize.Level1)
779 {
780 EXPECT_NE(g_effectAudioHapticPlayer, nullptr);
781
782 float volume = 0.5f;
783 int32_t result = g_effectAudioHapticPlayer->SetVolume(volume);
784 EXPECT_EQ(MSERR_OK, result);
785 }
786
787 /**
788 * @tc.name : Test AudioHapticPlayer SetVolume API
789 * @tc.number: AudioHapticPlayer_SetVolume_013
790 * @tc.desc : Test AudioHapticPlayer SetVolume interface
791 */
792 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_SetVolume_013, TestSize.Level1)
793 {
794 EXPECT_NE(g_effectAudioHapticPlayer, nullptr);
795
796 float volume = 1.0f;
797 int32_t result = g_effectAudioHapticPlayer->SetVolume(volume);
798 EXPECT_EQ(MSERR_OK, result);
799 }
800
801 /**
802 * @tc.name : Test AudioHapticPlayer SetVolume API
803 * @tc.number: AudioHapticPlayer_SetVolume_014
804 * @tc.desc : Test AudioHapticPlayer SetVolume interface
805 */
806 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_SetVolume_014, TestSize.Level1)
807 {
808 EXPECT_NE(g_effectAudioHapticPlayer, nullptr);
809
810 float volume = -0.5f;
811 int32_t result = g_effectAudioHapticPlayer->SetVolume(volume);
812 EXPECT_NE(MSERR_OK, result);
813 }
814
815 /**
816 * @tc.name : Test AudioHapticPlayer SetVolume API
817 * @tc.number: AudioHapticPlayer_SetVolume_015
818 * @tc.desc : Test AudioHapticPlayer SetVolume interface
819 */
820 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_SetVolume_015, TestSize.Level1)
821 {
822 EXPECT_NE(g_effectAudioHapticPlayer, nullptr);
823
824 float volume = 1.5f;
825 int32_t result = g_effectAudioHapticPlayer->SetVolume(volume);
826 EXPECT_NE(MSERR_OK, result);
827 }
828
829 /**
830 * @tc.name : Test AudioHapticPlayer SetLoop API
831 * @tc.number: AudioHapticPlayer_SetLoop_001
832 * @tc.desc : Test AudioHapticPlayer SetLoop interface
833 */
834 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_SetLoop_001, TestSize.Level1)
835 {
836 EXPECT_NE(g_normalAudioHapticPlayer, nullptr);
837
838 bool loop = true;
839 int32_t result = g_normalAudioHapticPlayer->SetLoop(loop);
840 EXPECT_EQ(MSERR_OK, result);
841 }
842
843 /**
844 * @tc.name : Test AudioHapticPlayer SetLoop API
845 * @tc.number: AudioHapticPlayer_SetLoop_002
846 * @tc.desc : Test AudioHapticPlayer SetLoop interface
847 */
848 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_SetLoop_002, TestSize.Level1)
849 {
850 EXPECT_NE(g_normalAudioHapticPlayer, nullptr);
851
852 bool loop = false;
853 int32_t result = g_normalAudioHapticPlayer->SetLoop(loop);
854 EXPECT_EQ(MSERR_OK, result);
855 }
856
857 /**
858 * @tc.name : Test AudioHapticPlayer SetLoop API
859 * @tc.number: AudioHapticPlayer_SetLoop_003
860 * @tc.desc : Test AudioHapticPlayer SetLoop interface
861 */
862 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_SetLoop_003, TestSize.Level1)
863 {
864 EXPECT_NE(g_lowLatencyAudioHapticPlayer, nullptr);
865
866 bool loop = true;
867 int32_t result = g_lowLatencyAudioHapticPlayer->SetLoop(loop);
868 EXPECT_EQ(MSERR_OK, result);
869 }
870
871 /**
872 * @tc.name : Test AudioHapticPlayer SetLoop API
873 * @tc.number: AudioHapticPlayer_SetLoop_004
874 * @tc.desc : Test AudioHapticPlayer SetLoop interface
875 */
876 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_SetLoop_004, TestSize.Level1)
877 {
878 EXPECT_NE(g_lowLatencyAudioHapticPlayer, nullptr);
879
880 bool loop = false;
881 int32_t result = g_lowLatencyAudioHapticPlayer->SetLoop(loop);
882 EXPECT_EQ(MSERR_OK, result);
883 }
884
885 /**
886 * @tc.name : Test AudioHapticPlayer SetAudioHapticPlayerCallback API
887 * @tc.number: AudioHapticPlayer_SetAudioHapticPlayerCallback_001
888 * @tc.desc : Test AudioHapticPlayer SetAudioHapticPlayerCallback interface
889 */
890 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_SetAudioHapticPlayerCallback_001, TestSize.Level1)
891 {
892 EXPECT_NE(g_normalAudioHapticPlayer, nullptr);
893
894 std::shared_ptr<AudioHapticPlayerCallback> callback = nullptr;
895 int32_t result = g_normalAudioHapticPlayer->SetAudioHapticPlayerCallback(callback);
896 EXPECT_NE(MSERR_OK, result);
897 }
898
899 /**
900 * @tc.name : Test AudioHapticPlayer SetAudioHapticPlayerCallback API
901 * @tc.number: AudioHapticPlayer_SetAudioHapticPlayerCallback_002
902 * @tc.desc : Test AudioHapticPlayer SetAudioHapticPlayerCallback interface
903 */
904 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_SetAudioHapticPlayerCallback_002, TestSize.Level1)
905 {
906 EXPECT_NE(g_lowLatencyAudioHapticPlayer, nullptr);
907
908 std::shared_ptr<AudioHapticPlayerCallback> callback = nullptr;
909 int32_t result = g_lowLatencyAudioHapticPlayer->SetAudioHapticPlayerCallback(callback);
910 EXPECT_NE(MSERR_OK, result);
911 }
912
913 /**
914 * @tc.name : Test AudioHapticPlayer GetAudioCurrentTime API
915 * @tc.number: AudioHapticPlayer_GetAudioCurrentTime_001
916 * @tc.desc : Test AudioHapticPlayer GetAudioCurrentTime interface
917 */
918 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_GetAudioCurrentTime_001, TestSize.Level1)
919 {
920 EXPECT_NE(g_normalAudioHapticPlayer, nullptr);
921
922 int32_t result = g_normalAudioHapticPlayer->GetAudioCurrentTime();
923 EXPECT_EQ(-1, result);
924 }
925
926 /**
927 * @tc.name : Test AudioHapticPlayer GetAudioCurrentTime API
928 * @tc.number: AudioHapticPlayer_GetAudioCurrentTime_002
929 * @tc.desc : Test AudioHapticPlayer GetAudioCurrentTime interface
930 */
931 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_GetAudioCurrentTime_002, TestSize.Level1)
932 {
933 EXPECT_NE(g_lowLatencyAudioHapticPlayer, nullptr);
934
935 int32_t result = g_lowLatencyAudioHapticPlayer->GetAudioCurrentTime();
936 EXPECT_EQ(-1, result);
937 }
938
939 /**
940 * @tc.name : Test AudioHapticPlayer Prepare API
941 * @tc.number: AudioHapticPlayer_Prepare_001
942 * @tc.desc : Test AudioHapticPlayer Prepare interface
943 */
944 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_Prepare_001, TestSize.Level1)
945 {
946 EXPECT_NE(g_normalAudioHapticPlayer, nullptr);
947
948 int32_t result = MSERR_OK;
949 result = g_normalAudioHapticPlayer->Prepare();
950 if (result == MSERR_OPEN_FILE_FAILED || result == MSERR_UNSUPPORT_FILE) {
951 // The source file is invalid or the path is inaccessible. Return directly.
952 EXPECT_NE(MSERR_OK, result);
953 return;
954 }
955
956 EXPECT_EQ(MSERR_OK, result);
957 }
958
959 /**
960 * @tc.name : Test AudioHapticPlayer Prepare API
961 * @tc.number: AudioHapticPlayer_Prepare_002
962 * @tc.desc : Test AudioHapticPlayer Prepare interface
963 */
964 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_Prepare_002, TestSize.Level1)
965 {
966 EXPECT_NE(g_lowLatencyAudioHapticPlayer, nullptr);
967
968 int32_t result = MSERR_OK;
969 result = g_lowLatencyAudioHapticPlayer->Prepare();
970 if (result == MSERR_OPEN_FILE_FAILED || result == MSERR_UNSUPPORT_FILE) {
971 // The source file is invalid or the path is inaccessible. Return directly.
972 EXPECT_NE(MSERR_OK, result);
973 return;
974 }
975
976 EXPECT_EQ(MSERR_OK, result);
977 }
978
979 /**
980 * @tc.name : Test AudioHapticPlayer Prepare API
981 * @tc.number: AudioHapticPlayer_Prepare_003
982 * @tc.desc : Test AudioHapticPlayer Prepare interface
983 */
984 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_Prepare_003, TestSize.Level1)
985 {
986 EXPECT_NE(g_effectAudioHapticPlayer, nullptr);
987
988 int32_t result = MSERR_OK;
989 result = g_effectAudioHapticPlayer->Prepare();
990 if (result == MSERR_OPEN_FILE_FAILED || result == MSERR_UNSUPPORT_FILE) {
991 // The source file is invalid or the path is inaccessible. Return directly.
992 EXPECT_NE(MSERR_OK, result);
993 return;
994 }
995
996 EXPECT_EQ(MSERR_OK, result);
997 }
998
999 /**
1000 * @tc.name : Test AudioHapticPlayer Start API
1001 * @tc.number: AudioHapticPlayer_Start_001
1002 * @tc.desc : Test AudioHapticPlayer Start interface
1003 */
1004 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_Start_001, TestSize.Level1)
1005 {
1006 EXPECT_NE(g_normalAudioHapticPlayer, nullptr);
1007
1008 int32_t result = MSERR_OK;
1009 result = g_normalAudioHapticPlayer->Prepare();
1010 if (result == MSERR_OPEN_FILE_FAILED || result == MSERR_UNSUPPORT_FILE) {
1011 // The source file is invalid or the path is inaccessible. Return directly.
1012 EXPECT_NE(MSERR_OK, result);
1013 return;
1014 }
1015
1016 result = g_normalAudioHapticPlayer->Start();
1017 EXPECT_EQ(MSERR_OK, result);
1018
1019 g_normalAudioHapticPlayer->Stop();
1020 }
1021
1022 /**
1023 * @tc.name : Test AudioHapticPlayer Start API
1024 * @tc.number: AudioHapticPlayer_Start_002
1025 * @tc.desc : Test AudioHapticPlayer Start interface
1026 */
1027 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_Start_002, TestSize.Level1)
1028 {
1029 EXPECT_NE(g_lowLatencyAudioHapticPlayer, nullptr);
1030
1031 int32_t result = MSERR_OK;
1032 result = g_lowLatencyAudioHapticPlayer->Prepare();
1033 if (result == MSERR_OPEN_FILE_FAILED || result == MSERR_UNSUPPORT_FILE) {
1034 // The source file is invalid or the path is inaccessible. Return directly.
1035 EXPECT_NE(MSERR_OK, result);
1036 return;
1037 }
1038
1039 result = g_lowLatencyAudioHapticPlayer->Start();
1040 EXPECT_EQ(MSERR_OK, result);
1041
1042 g_lowLatencyAudioHapticPlayer->Stop();
1043 }
1044
1045 /**
1046 * @tc.name : Test AudioHapticPlayer Start API
1047 * @tc.number: AudioHapticPlayer_Start_003
1048 * @tc.desc : Test AudioHapticPlayer Start interface
1049 */
1050 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_Start_003, TestSize.Level1)
1051 {
1052 EXPECT_NE(g_effectAudioHapticPlayer, nullptr);
1053
1054 int32_t result = MSERR_OK;
1055 result = g_effectAudioHapticPlayer->Prepare();
1056 if (result == MSERR_OPEN_FILE_FAILED || result == MSERR_UNSUPPORT_FILE) {
1057 // The source file is invalid or the path is inaccessible. Return directly.
1058 EXPECT_NE(MSERR_OK, result);
1059 return;
1060 }
1061
1062 result = g_effectAudioHapticPlayer->Start();
1063 EXPECT_EQ(MSERR_OK, result);
1064
1065 g_effectAudioHapticPlayer->Stop();
1066 }
1067
1068 /**
1069 * @tc.name : Test AudioHapticPlayer Stop API
1070 * @tc.number: AudioHapticPlayer_Stop_001
1071 * @tc.desc : Test AudioHapticPlayer Stop interface
1072 */
1073 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_Stop_001, TestSize.Level1)
1074 {
1075 EXPECT_NE(g_normalAudioHapticPlayer, nullptr);
1076
1077 int32_t result = MSERR_OK;
1078 result = g_normalAudioHapticPlayer->Prepare();
1079 if (result == MSERR_OPEN_FILE_FAILED || result == MSERR_UNSUPPORT_FILE) {
1080 // The source file is invalid or the path is inaccessible. Return directly.
1081 EXPECT_NE(MSERR_OK, result);
1082 return;
1083 }
1084 g_normalAudioHapticPlayer->Start();
1085
1086 result = g_normalAudioHapticPlayer->Stop();
1087 EXPECT_EQ(MSERR_OK, result);
1088 }
1089
1090 /**
1091 * @tc.name : Test AudioHapticPlayer Stop API
1092 * @tc.number: AudioHapticPlayer_Stop_002
1093 * @tc.desc : Test AudioHapticPlayer Stop interface
1094 */
1095 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_Stop_002, TestSize.Level1)
1096 {
1097 EXPECT_NE(g_lowLatencyAudioHapticPlayer, nullptr);
1098
1099 int32_t result = MSERR_OK;
1100 result = g_lowLatencyAudioHapticPlayer->Prepare();
1101 if (result == MSERR_OPEN_FILE_FAILED || result == MSERR_UNSUPPORT_FILE) {
1102 // The source file is invalid or the path is inaccessible. Return directly.
1103 EXPECT_NE(MSERR_OK, result);
1104 return;
1105 }
1106 g_lowLatencyAudioHapticPlayer->Start();
1107
1108 result = g_lowLatencyAudioHapticPlayer->Stop();
1109 EXPECT_EQ(MSERR_OK, result);
1110 }
1111
1112 /**
1113 * @tc.name : Test AudioHapticPlayer Stop API
1114 * @tc.number: AudioHapticPlayer_Stop_003
1115 * @tc.desc : Test AudioHapticPlayer Stop interface
1116 */
1117 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_Stop_003, TestSize.Level1)
1118 {
1119 EXPECT_NE(g_effectAudioHapticPlayer, nullptr);
1120
1121 int32_t result = MSERR_OK;
1122 result = g_effectAudioHapticPlayer->Prepare();
1123 if (result == MSERR_OPEN_FILE_FAILED || result == MSERR_UNSUPPORT_FILE) {
1124 // The source file is invalid or the path is inaccessible. Return directly.
1125 EXPECT_NE(MSERR_OK, result);
1126 return;
1127 }
1128 g_effectAudioHapticPlayer->Start();
1129
1130 result = g_effectAudioHapticPlayer->Stop();
1131 EXPECT_EQ(MSERR_OK, result);
1132 }
1133
1134 /**
1135 * @tc.name : Test AudioHapticPlayer Release API
1136 * @tc.number: AudioHapticPlayer_Release_001
1137 * @tc.desc : Test AudioHapticPlayer Release interface
1138 */
1139 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_Release_001, TestSize.Level1)
1140 {
1141 EXPECT_NE(g_normalAudioHapticPlayer, nullptr);
1142
1143 int32_t result = MSERR_OK;
1144 result = g_normalAudioHapticPlayer->Prepare();
1145 if (result == MSERR_OPEN_FILE_FAILED || result == MSERR_UNSUPPORT_FILE) {
1146 // The source file is invalid or the path is inaccessible. Return directly.
1147 EXPECT_NE(MSERR_OK, result);
1148 return;
1149 }
1150 g_normalAudioHapticPlayer->Start();
1151 g_normalAudioHapticPlayer->Stop();
1152
1153 result = g_normalAudioHapticPlayer->Release();
1154 EXPECT_EQ(MSERR_OK, result);
1155 }
1156
1157 /**
1158 * @tc.name : Test AudioHapticPlayer Release API
1159 * @tc.number: AudioHapticPlayer_Release_002
1160 * @tc.desc : Test AudioHapticPlayer Release interface
1161 */
1162 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_Release_002, TestSize.Level1)
1163 {
1164 EXPECT_NE(g_lowLatencyAudioHapticPlayer, nullptr);
1165
1166 int32_t result = MSERR_OK;
1167 result = g_lowLatencyAudioHapticPlayer->Prepare();
1168 if (result == MSERR_OPEN_FILE_FAILED || result == MSERR_UNSUPPORT_FILE) {
1169 // The source file is invalid or the path is inaccessible. Return directly.
1170 EXPECT_NE(MSERR_OK, result);
1171 return;
1172 }
1173 g_lowLatencyAudioHapticPlayer->Start();
1174 g_lowLatencyAudioHapticPlayer->Stop();
1175
1176 result = g_lowLatencyAudioHapticPlayer->Release();
1177 EXPECT_EQ(MSERR_OK, result);
1178 }
1179
1180 /**
1181 * @tc.name : Test AudioHapticPlayer Release API
1182 * @tc.number: AudioHapticPlayer_Release_003
1183 * @tc.desc : Test AudioHapticPlayer Release interface
1184 */
1185 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_Release_003, TestSize.Level1)
1186 {
1187 EXPECT_NE(g_effectAudioHapticPlayer, nullptr);
1188
1189 int32_t result = MSERR_OK;
1190 result = g_effectAudioHapticPlayer->Prepare();
1191 if (result == MSERR_OPEN_FILE_FAILED || result == MSERR_UNSUPPORT_FILE) {
1192 // The source file is invalid or the path is inaccessible. Return directly.
1193 EXPECT_NE(MSERR_OK, result);
1194 return;
1195 }
1196 g_effectAudioHapticPlayer->Start();
1197 g_effectAudioHapticPlayer->Stop();
1198
1199 result = g_effectAudioHapticPlayer->Release();
1200 EXPECT_EQ(MSERR_OK, result);
1201 }
1202
1203 /**
1204 * @tc.name : Test AudioHapticPlayer Release API
1205 * @tc.number: AudioHapticPlayer_Release_004
1206 * @tc.desc : Test AudioHapticPlayer Release interface
1207 */
1208 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_Release_004, TestSize.Level1)
1209 {
1210 EXPECT_NE(g_nonSyncAudioHapticPlayer, nullptr);
1211
1212 int32_t result = MSERR_OK;
1213 g_nonSyncAudioHapticPlayer->SetHapticsMode(HapticsMode::HAPTICS_MODE_NON_SYNC);
1214 result = g_nonSyncAudioHapticPlayer->Prepare();
1215 if (result == MSERR_OPEN_FILE_FAILED || result == MSERR_UNSUPPORT_FILE) {
1216 // The source file is invalid or the path is inaccessible. Return directly.
1217 EXPECT_NE(MSERR_OK, result);
1218 return;
1219 }
1220
1221 g_nonSyncAudioHapticPlayer->Start();
1222 g_nonSyncAudioHapticPlayer->Stop();
1223
1224 result = g_nonSyncAudioHapticPlayer->Release();
1225 EXPECT_EQ(MSERR_OK, result);
1226 }
1227
1228 /**
1229 * @tc.name : Test AudioHapticPlayer SetHapticIntensity API
1230 * @tc.number: AudioHapticPlayer_SetHapticIntensity_001
1231 * @tc.desc : Test AudioHapticPlayer SetHapticIntensity interface
1232 */
1233 HWTEST_F(AudioHapticUnitTest, AudioHapticPlayer_SetHapticIntensity_001, TestSize.Level1)
1234 {
1235 EXPECT_NE(g_audioHapticManager, nullptr);
1236
1237 g_effectSourceId = g_audioHapticManager->RegisterSourceWithEffectId(AUDIO_TEST_URI, HAPTIC_TEST_EFFECT_ID);
1238 EXPECT_NE(-1, g_effectSourceId);
1239 AudioLatencyMode latencyMode = AudioLatencyMode::AUDIO_LATENCY_MODE_FAST;
1240 g_audioHapticManager->SetAudioLatencyMode(g_effectSourceId, latencyMode);
1241 AudioStandard::StreamUsage streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_NOTIFICATION;
1242 g_audioHapticManager->SetStreamUsage(g_effectSourceId, streamUsage);
1243 AudioHapticPlayerOptions options;
1244 options.muteAudio = false;
1245 options.muteHaptics = false;
1246 g_effectAudioHapticPlayer = g_audioHapticManager->CreatePlayer(g_effectSourceId, options);
1247 EXPECT_NE(nullptr, g_effectAudioHapticPlayer);
1248
1249 int32_t result = g_effectAudioHapticPlayer->Prepare();
1250 EXPECT_EQ(MSERR_OK, result);
1251
1252 g_effectAudioHapticPlayer->SetVolume(1.0f);
1253 g_effectAudioHapticPlayer->SetHapticIntensity(100.0f);
1254 result = g_effectAudioHapticPlayer->Start();
1255 EXPECT_EQ(MSERR_OK, result);
1256
1257 sleep(1);
1258 g_effectAudioHapticPlayer->Stop();
1259 g_effectAudioHapticPlayer->SetVolume(0.75f);
1260 g_effectAudioHapticPlayer->SetHapticIntensity(75.0f);
1261 result = g_effectAudioHapticPlayer->Start();
1262 EXPECT_EQ(MSERR_OK, result);
1263
1264 sleep(1);
1265 g_effectAudioHapticPlayer->Stop();
1266 g_effectAudioHapticPlayer->SetVolume(0.5f);
1267 g_effectAudioHapticPlayer->SetHapticIntensity(50.0f);
1268 result = g_effectAudioHapticPlayer->Start();
1269 EXPECT_EQ(MSERR_OK, result);
1270
1271 sleep(1);
1272 g_effectAudioHapticPlayer->Stop();
1273 g_effectAudioHapticPlayer->SetVolume(0.25f);
1274 g_effectAudioHapticPlayer->SetHapticIntensity(25.0f);
1275 result = g_effectAudioHapticPlayer->Start();
1276 EXPECT_EQ(MSERR_OK, result);
1277
1278 sleep(1);
1279 g_effectAudioHapticPlayer->Stop();
1280 g_effectAudioHapticPlayer->SetVolume(0.01f);
1281 g_effectAudioHapticPlayer->SetHapticIntensity(1.0f);
1282 result = g_effectAudioHapticPlayer->Start();
1283 EXPECT_EQ(MSERR_OK, result);
1284
1285 sleep(1);
1286 result = g_effectAudioHapticPlayer->Stop();
1287 EXPECT_EQ(MSERR_OK, result);
1288 result = g_effectAudioHapticPlayer->Release();
1289 EXPECT_EQ(MSERR_OK, result);
1290 }
1291 } // namespace Media
1292 } // namespace OHOS
1293