1 /*
2 * Copyright (c) 2023 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_errors.h"
17 #include "audio_manager_listener_stub.h"
18 #include "audio_manager_proxy.h"
19 #include "audio_log.h"
20 #include "audio_process_in_client.h"
21 #include "audio_process_proxy.h"
22 #include "audio_stream.h"
23 #include "audio_system_manager.h"
24 #include <gtest/gtest.h>
25 #include "iservice_registry.h"
26 #include "system_ability_definition.h"
27
28 using namespace testing::ext;
29 namespace OHOS {
30 namespace AudioStandard {
31 std::unique_ptr<AudioManagerProxy> audioManagerProxy;
32 std::shared_ptr<AudioProcessInClient> processClient_;
33 const int32_t TEST_RET_NUM = 0;
34 const int32_t RENDERER_FLAGS = 0;
35 class AudioServiceUnitTest : public testing::Test {
36 public:
37 static void SetUpTestCase(void);
38 static void TearDownTestCase(void);
39 void SetUp();
40 void TearDown();
41 };
42
43 class AudioParameterCallbackTest : public AudioParameterCallback {
OnAudioParameterChange(const std::string networkId,const AudioParamKey key,const std::string & condition,const std::string & value)44 virtual void OnAudioParameterChange(const std::string networkId, const AudioParamKey key,
45 const std::string& condition, const std::string& value) {}
46 };
47
SetUpTestCase(void)48 void AudioServiceUnitTest::SetUpTestCase(void)
49 {
50 // input testsuit setup step，setup invoked before all testcases
51 }
52
TearDownTestCase(void)53 void AudioServiceUnitTest::TearDownTestCase(void)
54 {
55 // input testsuit teardown step，teardown invoked after all testcases
56 }
57
SetUp(void)58 void AudioServiceUnitTest::SetUp(void)
59 {
60 // input testcase setup step，setup invoked before each testcases
61 }
62
TearDown(void)63 void AudioServiceUnitTest::TearDown(void)
64 {
65 // input testcase teardown step，teardown invoked after each testcases
66 }
67
68 /**
69 * @tc.name : Test AudioProcessProxy API
70 * @tc.type : FUNC
71 * @tc.number: AudioProcessProxy_001
72 * @tc.desc : Test AudioProcessProxy interface.
73 */
74 HWTEST(AudioServiceUnitTest, AudioProcessProxy_001, TestSize.Level1)
75 {
76 auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
77 EXPECT_NE(nullptr, samgr);
78 sptr<IRemoteObject> object = samgr->GetSystemAbility(AUDIO_DISTRIBUTED_SERVICE_ID);
79 EXPECT_NE(nullptr, object);
80 std::unique_ptr<AudioProcessProxy> audioProcessProxy = std::make_unique<AudioProcessProxy>(object);
81
82 int32_t ret = -1;
83 std::shared_ptr<OHAudioBuffer> buffer;
84 uint32_t spanSizeInFrame = 1000;
85 uint32_t totalSizeInFrame = spanSizeInFrame - 1;
86 uint32_t byteSizePerFrame = 1000;
87 buffer = OHAudioBuffer::CreateFormLocal(totalSizeInFrame, spanSizeInFrame, byteSizePerFrame);
88
89 ret=audioProcessProxy->ResolveBuffer(buffer);
90 EXPECT_LT(ret, TEST_RET_NUM);
91
92 ret = audioProcessProxy->Start();
93 EXPECT_LT(ret, TEST_RET_NUM);
94
95 bool isFlush = true;
96 ret = audioProcessProxy->Pause(isFlush);
97 EXPECT_LT(ret, TEST_RET_NUM);
98
99 ret = audioProcessProxy->Resume();
100 EXPECT_LT(ret, TEST_RET_NUM);
101
102 ret = audioProcessProxy->Stop();
103 EXPECT_LT(ret, TEST_RET_NUM);
104
105 ret = audioProcessProxy->RequestHandleInfo();
106 EXPECT_EQ(ret, SUCCESS);
107
108 ret = audioProcessProxy->Release();
109 EXPECT_LT(ret, TEST_RET_NUM);
110 }
111
112 /**
113 * @tc.name : Test AudioManagerProxy API
114 * @tc.type : FUNC
115 * @tc.number: AudioManagerProxy_001
116 * @tc.desc : Test AudioManagerProxy interface.
117 */
118 HWTEST(AudioServiceUnitTest, AudioManagerProxy_001, TestSize.Level1)
119 {
120 int32_t ret = -1;
121
122 auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
123 EXPECT_NE(nullptr, samgr);
124 sptr<IRemoteObject> object = samgr->GetSystemAbility(AUDIO_DISTRIBUTED_SERVICE_ID);
125 EXPECT_NE(nullptr, object);
126
127 audioManagerProxy = std::make_unique<AudioManagerProxy>(object);
128
129 bool isMute = true;
130 ret = audioManagerProxy->SetMicrophoneMute(isMute);
131 EXPECT_EQ(ret, SUCCESS);
132
133 bool isMuteRet = audioManagerProxy->IsMicrophoneMute();
134 EXPECT_EQ(true, isMuteRet);
135 }
136
137 /**
138 * @tc.name : Test AudioManagerProxy API
139 * @tc.type : FUNC
140 * @tc.number: AudioManagerProxy_002
141 * @tc.desc : Test AudioManagerProxy interface.
142 */
143 HWTEST(AudioServiceUnitTest, AudioManagerProxy_002, TestSize.Level1)
144 {
145 int32_t ret = -1;
146
147 float volume = 0.1;
148 ret = audioManagerProxy->SetVoiceVolume(volume);
149
150 const std::string networkId = "LocalDevice";
151 const AudioParamKey key = AudioParamKey::VOLUME;
152 AudioVolumeType volumeType =AudioVolumeType::STREAM_MEDIA;
153 int32_t groupId = 0;
154 std::string condition = "EVENT_TYPE=1;VOLUME_GROUP_ID=" + std::to_string(groupId) + ";AUDIO_VOLUME_TYPE="
155 + std::to_string(volumeType) + ";";
156 std::string value = std::to_string(volume);
157 audioManagerProxy->SetAudioParameter(networkId, key, condition, value);
158 const std::string retStr = audioManagerProxy->GetAudioParameter(networkId, key, condition);
159 EXPECT_NE(retStr, value);
160
161 bool connected = true;
162 audioManagerProxy->NotifyDeviceInfo(networkId, connected);
163 ret = audioManagerProxy->CheckRemoteDeviceState(networkId, DeviceRole::OUTPUT_DEVICE, true);
164 EXPECT_LT(ret, TEST_RET_NUM);
165 }
166
167 /**
168 * @tc.name : Test AudioManagerProxy API
169 * @tc.type : FUNC
170 * @tc.number: AudioManagerProxy_003
171 * @tc.desc : Test AudioManagerProxy interface.
172 */
173 HWTEST(AudioServiceUnitTest, AudioManagerProxy_003, TestSize.Level1)
174 {
175 int32_t ret = -1;
176
177 AudioScene audioScene = AudioScene::AUDIO_SCENE_DEFAULT;
178 DeviceType activeDevice = DeviceType::DEVICE_TYPE_SPEAKER;
179 ret = audioManagerProxy->SetAudioScene(audioScene, activeDevice);
180 EXPECT_EQ(AUDIO_OK, ret);
181
182 DeviceFlag deviceFlag = DeviceFlag::OUTPUT_DEVICES_FLAG;
183 std::vector<sptr<AudioDeviceDescriptor>> audioDeviceDescriptors;
184 audioDeviceDescriptors = audioManagerProxy->GetDevices(deviceFlag);
185 EXPECT_EQ(audioDeviceDescriptors.size() > 0, false);
186
187 ret = audioManagerProxy->UpdateActiveDeviceRoute(DeviceType::DEVICE_TYPE_SPEAKER, DeviceFlag::OUTPUT_DEVICES_FLAG);
188 EXPECT_EQ(AUDIO_OK, ret);
189
190 sptr<IRemoteObject> object = nullptr;
191 ret = audioManagerProxy->SetParameterCallback(object);
192 EXPECT_EQ(ERR_NULL_OBJECT, ret);
193
194 auto parameterChangeCbStub = new(std::nothrow) AudioManagerListenerStub();
195 EXPECT_NE(parameterChangeCbStub, nullptr);
196 object = parameterChangeCbStub->AsObject();
197 EXPECT_NE(object, nullptr);
198 ret = audioManagerProxy->SetParameterCallback(object);
199 EXPECT_EQ(AUDIO_OK, ret);
200 }
201
202 /**
203 * @tc.name : Test AudioManagerProxy API
204 * @tc.type : FUNC
205 * @tc.number: AudioManagerProxy_004
206 * @tc.desc : Test AudioManagerProxy interface.
207 */
208 HWTEST(AudioServiceUnitTest, AudioManagerProxy_004, TestSize.Level1)
209 {
210 AudioProcessConfig config;
211 config.appInfo = {};
212 config.appInfo.appUid=static_cast<int32_t>(getuid());
213
214 config.audioMode = AudioMode::AUDIO_MODE_RECORD;
215
216 config.streamInfo = {};
217 config.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_44100;
218 config.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
219 config.streamInfo.format = AudioSampleFormat::SAMPLE_S16LE;
220 config.streamInfo.channels = AudioChannel::STEREO;
221
222 config.rendererInfo = {};
223 config.rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
224 config.rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
225 config.rendererInfo.rendererFlags = 0;
226
227 config.capturerInfo = {};
228 config.capturerInfo.sourceType = SourceType::SOURCE_TYPE_MIC;
229 config.capturerInfo.capturerFlags = 0;
230 sptr<IRemoteObject> process = audioManagerProxy->CreateAudioProcess(config);
231 EXPECT_EQ(process, nullptr);
232 }
233
234 /**
235 * @tc.name : Test AudioManagerProxy API
236 * @tc.type : FUNC
237 * @tc.number: AudioManagerProxy_005
238 * @tc.desc : Test AudioManagerProxy interface.
239 */
240 HWTEST(AudioServiceUnitTest, AudioManagerProxy_005, TestSize.Level1)
241 {
242 std::vector<Library> libraries;
243 Library library = {};
244 library.name = "testname";
245 library.path ="test.so";
246 libraries.push_back(library);
247
248 std::vector<Effect> effects;
249 Effect effect = {};
250 effect.name = "test";
251 effect.libraryName = "test";
252 effects.push_back(effect);
253
254 std::vector<Effect> successEffects;
255 bool ret = audioManagerProxy->LoadAudioEffectLibraries(libraries, effects, successEffects);
256 EXPECT_EQ(ret, false);
257 }
258
259 /**
260 * @tc.name : Test AudioManagerListenerStub API
261 * @tc.type : FUNC
262 * @tc.number: AudioManagerListenerStub_001
263 * @tc.desc : Test AudioManagerListenerStub interface.
264 */
265 HWTEST(AudioServiceUnitTest, AudioManagerListenerStub_001, TestSize.Level1)
266 {
267 std::unique_ptr<AudioManagerListenerStub> audioManagerListenerStub = std::make_unique<AudioManagerListenerStub>();
268
269 const std::weak_ptr<AudioParameterCallback> callback = std::make_shared<AudioParameterCallbackTest>();
270 audioManagerListenerStub->SetParameterCallback(callback);
271 float volume = 0.1;
272 const std::string networkId = "LocalDevice";
273 const AudioParamKey key = AudioParamKey::VOLUME;
274 AudioVolumeType volumeType =AudioVolumeType::STREAM_MEDIA;
275 int32_t groupId = 0;
276 std::string condition = "EVENT_TYPE=1;VOLUME_GROUP_ID=" + std::to_string(groupId) + ";AUDIO_VOLUME_TYPE="
277 + std::to_string(volumeType) + ";";
278 std::string value = std::to_string(volume);
279 audioManagerListenerStub->OnAudioParameterChange(networkId, key, condition, value);
280 EXPECT_NE(value, "");
281 }
282
283
284 /**
285 * @tc.name : Test AudioProcessInClientInner API
286 * @tc.type : FUNC
287 * @tc.number: AudioProcessInClientInner_001
288 * @tc.desc : Test AudioProcessInClientInner interface using unsupported parameters.
289 */
290 HWTEST(AudioServiceUnitTest, AudioProcessInClientInner_001, TestSize.Level1)
291 {
292 AudioProcessConfig config;
293 config.appInfo.appPid = getpid();
294 config.appInfo.appUid = getuid();
295
296 config.audioMode = AUDIO_MODE_PLAYBACK;
297
298 config.rendererInfo.contentType = CONTENT_TYPE_MUSIC;
299 config.rendererInfo.streamUsage = STREAM_USAGE_MEDIA;
300 config.rendererInfo.rendererFlags = RENDERER_FLAGS;
301
302 config.streamInfo.channels = STEREO;
303 config.streamInfo.encoding = ENCODING_PCM;
304 config.streamInfo.format = SAMPLE_S16LE;
305 config.streamInfo.samplingRate = SAMPLE_RATE_64000;
306
307 processClient_ = AudioProcessInClient::Create(config);
308 EXPECT_EQ(processClient_, nullptr);
309 }
310
311 /**
312 * @tc.name : Test AudioDeviceDescriptor API
313 * @tc.type : FUNC
314 * @tc.number: AudioDeviceDescriptor_001
315 * @tc.desc : Test AudioDeviceDescriptor interface.
316 */
317 HWTEST(AudioServiceUnitTest, AudioDeviceDescriptor_001, TestSize.Level1)
318 {
319 DeviceType type = DeviceType::DEVICE_TYPE_SPEAKER;
320 DeviceRole role = DeviceRole::OUTPUT_DEVICE;
321 int32_t interruptGroupId = 1;
322 int32_t volumeGroupId = 1;
323 std::string networkId = "LocalDevice";
324 std::unique_ptr<AudioDeviceDescriptor> audioDeviceDescriptor =
325 std::make_unique<AudioDeviceDescriptor>(type, role, interruptGroupId, volumeGroupId, networkId);
326 EXPECT_NE(audioDeviceDescriptor, nullptr);
327
328 AudioDeviceDescriptor deviceDescriptor;
329 deviceDescriptor.deviceType_ = type;
330 deviceDescriptor.deviceRole_ = role;
331 audioDeviceDescriptor = std::make_unique<AudioDeviceDescriptor>(deviceDescriptor);
332 EXPECT_NE(audioDeviceDescriptor, nullptr);
333
334 std::string deviceName = "";
335 std::string macAddress = "";
336 audioDeviceDescriptor->SetDeviceInfo(deviceName, macAddress);
337
338 AudioStreamInfo audioStreamInfo;
339 audioStreamInfo.channels = STEREO;
340 audioStreamInfo.encoding = ENCODING_PCM;
341 audioStreamInfo.format = SAMPLE_S16LE;
342 audioStreamInfo.samplingRate = SAMPLE_RATE_48000;
343 int32_t channelMask = 1;
344 audioDeviceDescriptor->SetDeviceCapability(audioStreamInfo, channelMask);
345
346 AudioStreamInfo streamInfo = audioDeviceDescriptor->audioStreamInfo_;
347 EXPECT_EQ(streamInfo.channels, audioStreamInfo.channels);
348 EXPECT_EQ(streamInfo.encoding, audioStreamInfo.encoding);
349 EXPECT_EQ(streamInfo.format, audioStreamInfo.format);
350 EXPECT_EQ(streamInfo.samplingRate, audioStreamInfo.samplingRate);
351 }
352
353 /**
354 * @tc.name : Test AudioServiceClient API
355 * @tc.type : FUNC
356 * @tc.number: AudioServiceClient_001
357 * @tc.desc : Test AudioServiceClient interface.
358 */
359 HWTEST(AudioServiceUnitTest, AudioServiceClient_001, TestSize.Level1)
360 {
361 int32_t ret = -1;
362
363 std::unique_ptr<AudioServiceClient> audioServiceClient = std::make_unique<AudioStream>(STREAM_MUSIC,
364 AUDIO_MODE_PLAYBACK, getuid());
365
366 ASClientType eClientType = ASClientType::AUDIO_SERVICE_CLIENT_PLAYBACK;
367 ret = audioServiceClient->Initialize(eClientType);
368 EXPECT_EQ(SUCCESS, ret);
369
370 AudioStreamParams audioParams = {};
371 audioParams.samplingRate = AudioSamplingRate::SAMPLE_RATE_44100;
372 audioParams.encoding = AudioEncodingType::ENCODING_PCM;
373 audioParams.format = AudioSampleFormat::SAMPLE_S16LE;
374 audioParams.channels = AudioChannel::STEREO;
375
376 ret = audioServiceClient->CreateStream(audioParams, AudioStreamType::STREAM_SYSTEM);
377 EXPECT_EQ(SUCCESS, ret);
378 ret = audioServiceClient->CreateStream(audioParams, AudioStreamType::STREAM_NOTIFICATION);
379 EXPECT_EQ(SUCCESS, ret);
380 ret = audioServiceClient->CreateStream(audioParams, AudioStreamType::STREAM_BLUETOOTH_SCO);
381 EXPECT_EQ(SUCCESS, ret);
382 ret = audioServiceClient->CreateStream(audioParams, AudioStreamType::STREAM_DTMF);
383 EXPECT_EQ(SUCCESS, ret);
384 ret = audioServiceClient->CreateStream(audioParams, AudioStreamType::STREAM_TTS);
385 EXPECT_EQ(SUCCESS, ret);
386 ret = audioServiceClient->CreateStream(audioParams, AudioStreamType::STREAM_DEFAULT);
387 EXPECT_EQ(SUCCESS, ret);
388
389 ret = audioServiceClient->SetStreamRenderRate(AudioRendererRate::RENDER_RATE_HALF);
390 EXPECT_EQ(SUCCESS, ret);
391 ret = audioServiceClient->SetStreamRenderRate(static_cast<AudioRendererRate>(-1));
392 EXPECT_EQ(SUCCESS - 2, ret);
393 ret = audioServiceClient->SetStreamRenderRate(RENDER_RATE_DOUBLE);
394 EXPECT_EQ(SUCCESS, ret);
395
396 uint32_t rate = audioServiceClient->GetRendererSamplingRate();
397 EXPECT_EQ((uint32_t)SAMPLE_RATE_44100, rate);
398 ret = audioServiceClient->SetRendererSamplingRate(0);
399 EXPECT_EQ(SUCCESS - 2, ret);
400 rate = audioServiceClient->GetRendererSamplingRate();
401 EXPECT_EQ((uint32_t)SAMPLE_RATE_44100, rate);
402
403 audioServiceClient->OnTimeOut();
404 }
405 } // namespace AudioStandard
406 } // namespace OHOS