1 /**
2 * Copyright (C) 2023 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include <gtest/gtest.h>
18 #include <ImsMediaNetworkUtil.h>
19 #include <AudioConfig.h>
20 #include <MockAudioManager.h>
21 #include <ImsMediaCondition.h>
22 #include <unordered_map>
23 #include <algorithm>
24
25 using namespace android::telephony::imsmedia;
26
27 using ::testing::_;
28 using ::testing::Eq;
29 using ::testing::Pointee;
30 using ::testing::Ref;
31 using ::testing::Return;
32
33 namespace
34 {
35 // RtpConfig
36 const int32_t kMediaDirection = RtpConfig::MEDIA_DIRECTION_SEND_RECEIVE;
37 const android::String8 kRemoteAddress("127.0.0.1");
38 const int32_t kRemotePort = 10000;
39 const int8_t kDscp = 0;
40 const int8_t kRxPayload = 96;
41 const int8_t kTxPayload = 96;
42 const int8_t kSamplingRate = 16;
43
44 // RtcpConfig
45 const android::String8 kCanonicalName("name");
46 const int32_t kTransmitPort = 1001;
47 const int32_t kIntervalSec = 5;
48 const int32_t kRtcpXrBlockTypes = RtcpConfig::FLAG_RTCPXR_STATISTICS_SUMMARY_REPORT_BLOCK |
49 RtcpConfig::FLAG_RTCPXR_VOIP_METRICS_REPORT_BLOCK;
50
51 // AudioConfig
52 const int8_t kPTimeMillis = 20;
53 const int32_t kMaxPtimeMillis = 100;
54 const bool kDtxEnabled = true;
55 const int32_t kCodecType = AudioConfig::CODEC_AMR_WB;
56 const int8_t kDtmfTxPayloadTypeNumber = 100;
57 const int8_t kDtmfRxPayloadTypeNumber = 101;
58 const int8_t kDtmfsamplingRateKHz = 16;
59
60 // AmrParam
61 const int32_t kAmrMode = 8;
62 const bool kOctetAligned = false;
63 const int32_t kMaxRedundancyMillis = 240;
64
65 // EvsParam
66 const int32_t kEvsBandwidth = EvsParams::EVS_BAND_NONE;
67 const int32_t kEvsMode = 8;
68 const int8_t kChannelAwareMode = 3;
69 const bool kUseHeaderFullOnly = false;
70 const int8_t kcodecModeRequest = 15;
71
72 int32_t kSessionId = 0;
73 static ImsMediaCondition gCondition;
74
75 class AudioManagerCallback
76 {
77 public:
78 int32_t resSessionId;
79 int32_t response;
80 AudioConfig resConfig;
81 ImsMediaResult result;
82 std::list<RtpHeaderExtension> extensions;
83 MediaQualityStatus mediaQualityStatus;
84 char receivedDtmfDigit;
85 int32_t receivedDtmfDuration;
86 CallQuality callQuality;
87
resetRespond()88 void resetRespond()
89 {
90 resSessionId = -1;
91 response = -1;
92 result = RESULT_NOT_READY;
93 }
94
onCallback(const int id,const int event,const ImsMediaResult res)95 void onCallback(const int id, const int event, const ImsMediaResult res)
96 {
97 resSessionId = id;
98 response = event;
99 result = res;
100 }
101
onCallbackConfig(const int id,const int event,const ImsMediaResult res,const AudioConfig & config)102 void onCallbackConfig(
103 const int id, const int event, const ImsMediaResult res, const AudioConfig& config)
104 {
105 resSessionId = id;
106 response = event;
107 resConfig = config;
108 result = res;
109 }
110
onCallbackHeaderExtension(const int id,const int event,const std::list<RtpHeaderExtension> & list)111 void onCallbackHeaderExtension(
112 const int id, const int event, const std::list<RtpHeaderExtension>& list)
113 {
114 extensions.clear();
115 resSessionId = id;
116 response = event;
117 std::copy(list.begin(), list.end(), std::back_inserter(extensions));
118 }
119
onCallbackMediaQualityStatus(const int id,const int event,const MediaQualityStatus & status)120 void onCallbackMediaQualityStatus(
121 const int id, const int event, const MediaQualityStatus& status)
122 {
123 resSessionId = id;
124 response = event;
125 mediaQualityStatus = status;
126 }
127
onCallbackDtmfReceived(const int id,const int event,char digit,int32_t duration)128 void onCallbackDtmfReceived(const int id, const int event, char digit, int32_t duration)
129 {
130 resSessionId = id;
131 response = event;
132 receivedDtmfDigit = digit;
133 receivedDtmfDuration = duration;
134 }
135
onCallbackCallQuality(const int id,const int event,const CallQuality & status)136 void onCallbackCallQuality(const int id, const int event, const CallQuality& status)
137 {
138 resSessionId = id;
139 response = event;
140 callQuality = status;
141 }
142 };
143
144 static std::unordered_map<int, AudioManagerCallback*> gMapCallback;
145
146 class AudioManagerTest : public ::testing::Test
147 {
148 public:
149 MockAudioManager manager;
150 AudioConfig config;
151 RtcpConfig rtcp;
152 AmrParams amr;
153 EvsParams evs;
154 int socketRtpFd;
155 int socketRtcpFd;
156 AudioManagerCallback callback;
157
AudioManagerTest()158 AudioManagerTest()
159 {
160 socketRtpFd = -1;
161 socketRtcpFd = -1;
162 callback.resetRespond();
163 gCondition.reset();
164 }
~AudioManagerTest()165 ~AudioManagerTest() {}
166
167 protected:
SetUp()168 virtual void SetUp() override
169 {
170 rtcp.setCanonicalName(kCanonicalName);
171 rtcp.setTransmitPort(kTransmitPort);
172 rtcp.setIntervalSec(kIntervalSec);
173 rtcp.setRtcpXrBlockTypes(kRtcpXrBlockTypes);
174
175 amr.setAmrMode(kAmrMode);
176 amr.setOctetAligned(kOctetAligned);
177 amr.setMaxRedundancyMillis(kMaxRedundancyMillis);
178
179 evs.setEvsBandwidth(kEvsBandwidth);
180 evs.setEvsMode(kEvsMode);
181 evs.setChannelAwareMode(kChannelAwareMode);
182 evs.setUseHeaderFullOnly(kUseHeaderFullOnly);
183 evs.setCodecModeRequest(kcodecModeRequest);
184
185 config.setMediaDirection(kMediaDirection);
186 config.setRemoteAddress(kRemoteAddress);
187 config.setRemotePort(kRemotePort);
188 config.setRtcpConfig(rtcp);
189 config.setDscp(kDscp);
190 config.setRxPayloadTypeNumber(kRxPayload);
191 config.setTxPayloadTypeNumber(kTxPayload);
192 config.setSamplingRateKHz(kSamplingRate);
193 config.setPtimeMillis(kPTimeMillis);
194 config.setMaxPtimeMillis(kMaxPtimeMillis);
195 config.setDtxEnabled(kDtxEnabled);
196 config.setCodecType(kCodecType);
197 config.setTxDtmfPayloadTypeNumber(kDtmfTxPayloadTypeNumber);
198 config.setRxDtmfPayloadTypeNumber(kDtmfRxPayloadTypeNumber);
199 config.setDtmfsamplingRateKHz(kDtmfsamplingRateKHz);
200 config.setAmrParams(amr);
201 config.setEvsParams(evs);
202
203 manager.setCallback(&audioCallback);
204 gMapCallback.insert(std::make_pair(kSessionId, &callback));
205 const char testIp[] = "127.0.0.1";
206 unsigned int testPortRtp = 30000;
207 socketRtpFd = ImsMediaNetworkUtil::openSocket(testIp, testPortRtp, AF_INET);
208 EXPECT_NE(socketRtpFd, -1);
209 unsigned int testPortRtcp = 30001;
210 socketRtcpFd = ImsMediaNetworkUtil::openSocket(testIp, testPortRtcp, AF_INET);
211 EXPECT_NE(socketRtcpFd, -1);
212 gCondition.reset();
213 }
214
TearDown()215 virtual void TearDown() override
216 {
217 if (socketRtpFd != -1)
218 {
219 ImsMediaNetworkUtil::closeSocket(socketRtpFd);
220 }
221
222 if (socketRtcpFd != -1)
223 {
224 ImsMediaNetworkUtil::closeSocket(socketRtcpFd);
225 }
226
227 gMapCallback.erase(kSessionId);
228 }
229
openSession(const int32_t sessionId)230 void openSession(const int32_t sessionId)
231 {
232 callback.resetRespond();
233 android::Parcel parcel;
234 parcel.writeInt32(kAudioOpenSession);
235 parcel.writeInt32(socketRtpFd);
236 parcel.writeInt32(socketRtcpFd);
237 parcel.setDataPosition(0);
238 gCondition.reset();
239 manager.sendMessage(sessionId, parcel);
240 EXPECT_TRUE(!gCondition.wait_timeout(1000));
241 EXPECT_EQ(callback.resSessionId, sessionId);
242 EXPECT_EQ(callback.response, kAudioOpenSessionSuccess);
243 }
244
closeSession(const int32_t sessionId)245 void closeSession(const int32_t sessionId)
246 {
247 callback.resetRespond();
248 android::Parcel parcel;
249 parcel.writeInt32(kAudioCloseSession);
250 parcel.setDataPosition(0);
251 gCondition.reset();
252 manager.sendMessage(sessionId, parcel);
253 EXPECT_TRUE(!gCondition.wait_timeout(1000));
254 EXPECT_EQ(callback.resSessionId, sessionId);
255 EXPECT_EQ(callback.response, kAudioSessionClosed);
256 }
257
testEventResponse(const int32_t sessionId,const int32_t event,AudioConfig * config,const int32_t response,const int32_t result)258 void testEventResponse(const int32_t sessionId, const int32_t event, AudioConfig* config,
259 const int32_t response, const int32_t result)
260 {
261 callback.resetRespond();
262 android::Parcel parcel;
263 parcel.writeInt32(event);
264
265 if (config != nullptr)
266 {
267 config->writeToParcel(&parcel);
268 }
269
270 parcel.setDataPosition(0);
271 gCondition.reset();
272 manager.sendMessage(sessionId, parcel);
273 EXPECT_TRUE(!gCondition.wait_timeout(1000));
274 EXPECT_EQ(callback.resSessionId, sessionId);
275 EXPECT_EQ(callback.response, response);
276
277 if (callback.response >= kAudioOpenSessionFailure &&
278 callback.response <= kAudioConfirmConfigResponse)
279 {
280 EXPECT_EQ(result, result);
281
282 if (config != nullptr && callback.response >= kAudioModifySessionResponse &&
283 callback.response <= kAudioConfirmConfigResponse)
284 {
285 EXPECT_EQ(callback.resConfig, *config);
286 }
287 }
288 }
289
audioCallback(int sessionId,const android::Parcel & parcel)290 static int32_t audioCallback(int sessionId, const android::Parcel& parcel)
291 {
292 parcel.setDataPosition(0);
293
294 int response = parcel.readInt32();
295 ImsMediaResult result = RESULT_INVALID_PARAM;
296
297 auto callback = gMapCallback.find(sessionId);
298
299 if (callback != gMapCallback.end())
300 {
301 if (response >= kAudioOpenSessionFailure && response <= kAudioConfirmConfigResponse)
302 {
303 result = static_cast<ImsMediaResult>(parcel.readInt32());
304 }
305
306 switch (response)
307 {
308 case kAudioModifySessionResponse:
309 case kAudioAddConfigResponse:
310 case kAudioConfirmConfigResponse:
311 {
312 AudioConfig resConfig;
313 resConfig.readFromParcel(&parcel);
314 (callback->second)->onCallbackConfig(sessionId, response, result, resConfig);
315 }
316 break;
317 case kAudioFirstMediaPacketInd:
318 {
319 AudioConfig resConfig;
320 resConfig.readFromParcel(&parcel);
321 (callback->second)
322 ->onCallbackConfig(sessionId, response, RESULT_SUCCESS, resConfig);
323 }
324 break;
325 case kAudioRtpHeaderExtensionInd:
326 {
327 std::list<RtpHeaderExtension> listExtension;
328 int32_t listSize = parcel.readInt32();
329
330 for (int32_t i = 0; i < listSize; i++)
331 {
332 RtpHeaderExtension extension;
333 extension.readFromParcel(&parcel);
334 listExtension.push_back(extension);
335 }
336
337 (callback->second)
338 ->onCallbackHeaderExtension(sessionId, response, listExtension);
339 }
340 break;
341 case kAudioMediaQualityStatusInd:
342 {
343 MediaQualityStatus status;
344 status.readFromParcel(&parcel);
345 (callback->second)->onCallbackMediaQualityStatus(sessionId, response, status);
346 }
347 break;
348 case kAudioDtmfReceivedInd:
349 (callback->second)
350 ->onCallbackDtmfReceived(
351 sessionId, response, parcel.readByte(), parcel.readInt32());
352 break;
353 case kAudioCallQualityChangedInd:
354 {
355 CallQuality quality;
356 quality.readFromParcel(&parcel);
357 (callback->second)->onCallbackCallQuality(sessionId, response, quality);
358 }
359 break;
360 default:
361 (callback->second)->onCallback(sessionId, response, result);
362 break;
363 }
364 }
365
366 if (response != kAudioCallQualityChangedInd)
367 {
368 gCondition.signal();
369 }
370
371 return 0;
372 }
373 };
374
TEST_F(AudioManagerTest,testOpenCloseSession)375 TEST_F(AudioManagerTest, testOpenCloseSession)
376 {
377 EXPECT_EQ(manager.getState(kSessionId), kSessionStateClosed);
378 openSession(kSessionId);
379 closeSession(kSessionId);
380 }
381
TEST_F(AudioManagerTest,testModifySession)382 TEST_F(AudioManagerTest, testModifySession)
383 {
384 testEventResponse(kSessionId, kAudioModifySession, nullptr, kAudioModifySessionResponse,
385 RESULT_INVALID_PARAM);
386
387 openSession(kSessionId);
388
389 testEventResponse(kSessionId, kAudioModifySession, nullptr, kAudioModifySessionResponse,
390 RESULT_INVALID_PARAM);
391
392 testEventResponse(
393 kSessionId, kAudioModifySession, &config, kAudioModifySessionResponse, RESULT_SUCCESS);
394
395 closeSession(kSessionId);
396 }
397
TEST_F(AudioManagerTest,testAddConfig)398 TEST_F(AudioManagerTest, testAddConfig)
399 {
400 testEventResponse(
401 kSessionId, kAudioAddConfig, nullptr, kAudioAddConfigResponse, RESULT_INVALID_PARAM);
402
403 openSession(kSessionId);
404
405 testEventResponse(
406 kSessionId, kAudioAddConfig, nullptr, kAudioAddConfigResponse, RESULT_INVALID_PARAM);
407
408 testEventResponse(
409 kSessionId, kAudioAddConfig, &config, kAudioAddConfigResponse, RESULT_SUCCESS);
410
411 closeSession(kSessionId);
412 }
413
TEST_F(AudioManagerTest,testConfirmConfig)414 TEST_F(AudioManagerTest, testConfirmConfig)
415 {
416 testEventResponse(kSessionId, kAudioConfirmConfig, nullptr, kAudioConfirmConfigResponse,
417 RESULT_INVALID_PARAM);
418
419 openSession(kSessionId);
420
421 testEventResponse(kSessionId, kAudioConfirmConfig, nullptr, kAudioConfirmConfigResponse,
422 RESULT_INVALID_PARAM);
423
424 testEventResponse(
425 kSessionId, kAudioConfirmConfig, &config, kAudioConfirmConfigResponse, RESULT_SUCCESS);
426
427 closeSession(kSessionId);
428 }
429
TEST_F(AudioManagerTest,testDeleteConfig)430 TEST_F(AudioManagerTest, testDeleteConfig)
431 {
432 openSession(kSessionId);
433
434 android::Parcel parcel;
435 parcel.writeInt32(kAudioDeleteConfig);
436
437 if (config != nullptr)
438 {
439 config.writeToParcel(&parcel);
440 }
441
442 EXPECT_CALL(manager, deleteConfig(kSessionId, Pointee(Eq(config))))
443 .Times(1)
444 .WillOnce(Return(RESULT_INVALID_PARAM));
445
446 parcel.setDataPosition(0);
447 manager.sendMessage(kSessionId, parcel);
448
449 gCondition.wait_timeout(20);
450 closeSession(kSessionId);
451 }
452
TEST_F(AudioManagerTest,testSendDtmf)453 TEST_F(AudioManagerTest, testSendDtmf)
454 {
455 openSession(kSessionId);
456
457 const char kDigit = '1';
458 const int32_t kDuration = 100;
459
460 android::Parcel parcel;
461 parcel.writeInt32(kAudioSendDtmf);
462 parcel.writeByte(kDigit);
463 parcel.writeInt32(kDuration);
464 parcel.setDataPosition(0);
465
466 EXPECT_CALL(manager, sendDtmf(kSessionId, kDigit, kDuration)).Times(1).WillOnce(Return());
467
468 manager.sendMessage(kSessionId, parcel);
469
470 gCondition.wait_timeout(20);
471 closeSession(kSessionId);
472 }
473
TEST_F(AudioManagerTest,testSendHeaderExtension)474 TEST_F(AudioManagerTest, testSendHeaderExtension)
475 {
476 openSession(kSessionId);
477
478 std::list<RtpHeaderExtension> extensions;
479 RtpHeaderExtension extension;
480 const uint8_t kExtensionData[] = {0x01, 0x02};
481 const int32_t kExtensionDataSize = 2;
482 extension.setLocalIdentifier(15);
483 extension.setExtensionData(kExtensionData, kExtensionDataSize);
484 extensions.push_back(extension);
485
486 android::Parcel parcel;
487 parcel.writeInt32(kAudioSendRtpHeaderExtension);
488 parcel.writeInt32(extensions.size());
489
490 for (auto& item : extensions)
491 {
492 item.writeToParcel(&parcel);
493 }
494
495 parcel.setDataPosition(0);
496
497 EXPECT_CALL(manager, sendRtpHeaderExtension(kSessionId, Pointee(Eq(extensions))))
498 .Times(1)
499 .WillOnce(Return());
500
501 manager.sendMessage(kSessionId, parcel);
502
503 gCondition.wait_timeout(20);
504 closeSession(kSessionId);
505 }
506
TEST_F(AudioManagerTest,testSetMediaQualityThreshold)507 TEST_F(AudioManagerTest, testSetMediaQualityThreshold)
508 {
509 openSession(kSessionId);
510
511 const std::vector<int32_t> kRtpInactivityTimerMillis = {10000, 20000};
512 const int32_t kRtcpInactivityTimerMillis = 20000;
513 const int32_t kRtpHysteresisTimeInMillis = 3000;
514 const int32_t kRtpPacketLossDurationMillis = 5000;
515 const std::vector<int32_t> kRtpPacketLossRate = {3, 5};
516 const std::vector<int32_t> kRtpJitterMillis = {100, 200};
517 const bool kNotifyCurrentStatus = false;
518
519 MediaQualityThreshold threshold;
520 threshold.setRtpInactivityTimerMillis(kRtpInactivityTimerMillis);
521 threshold.setRtcpInactivityTimerMillis(kRtcpInactivityTimerMillis);
522 threshold.setRtpHysteresisTimeInMillis(kRtpHysteresisTimeInMillis);
523 threshold.setRtpPacketLossDurationMillis(kRtpPacketLossDurationMillis);
524 threshold.setRtpPacketLossRate(kRtpPacketLossRate);
525 threshold.setRtpJitterMillis(kRtpJitterMillis);
526 threshold.setNotifyCurrentStatus(kNotifyCurrentStatus);
527
528 android::Parcel parcel;
529 parcel.writeInt32(kAudioSetMediaQualityThreshold);
530 threshold.writeToParcel(&parcel);
531 parcel.setDataPosition(0);
532
533 EXPECT_CALL(manager, setMediaQualityThreshold(kSessionId, Pointee(Eq(threshold))))
534 .Times(1)
535 .WillOnce(Return());
536
537 manager.sendMessage(kSessionId, parcel);
538
539 gCondition.wait_timeout(20);
540 closeSession(kSessionId);
541 }
542
TEST_F(AudioManagerTest,testSendInternalEventCmr)543 TEST_F(AudioManagerTest, testSendInternalEventCmr)
544 {
545 openSession(kSessionId);
546
547 const int32_t kCmrCode = 1;
548 const int32_t kCmrDefine = 7;
549
550 EXPECT_CALL(manager, SendInternalEvent(kRequestAudioCmr, kSessionId, kCmrCode, kCmrDefine))
551 .Times(1)
552 .WillOnce(Return());
553
554 ImsMediaEventHandler::SendEvent(
555 "AUDIO_REQUEST_EVENT", kRequestAudioCmr, kSessionId, kCmrCode, kCmrDefine);
556
557 gCondition.wait_timeout(20);
558 closeSession(kSessionId);
559 }
560
TEST_F(AudioManagerTest,testSendInternalEventRtcpXr)561 TEST_F(AudioManagerTest, testSendInternalEventRtcpXr)
562 {
563 openSession(kSessionId);
564
565 const int32_t param1 = 10;
566 const int32_t param2 = 20;
567
568 EXPECT_CALL(manager, SendInternalEvent(kRequestSendRtcpXrReport, kSessionId, param1, param2))
569 .Times(1)
570 .WillOnce(Return());
571
572 ImsMediaEventHandler::SendEvent(
573 "AUDIO_REQUEST_EVENT", kRequestSendRtcpXrReport, kSessionId, param1, param2);
574
575 gCondition.wait_timeout(20);
576 closeSession(kSessionId);
577 }
578
TEST_F(AudioManagerTest,testFirstMediaPacketInd)579 TEST_F(AudioManagerTest, testFirstMediaPacketInd)
580 {
581 AudioConfig* param = new AudioConfig(config);
582
583 ImsMediaEventHandler::SendEvent("AUDIO_RESPONSE_EVENT", kAudioFirstMediaPacketInd, kSessionId,
584 reinterpret_cast<uint64_t>(param), 0);
585
586 gCondition.wait_timeout(20);
587 EXPECT_EQ(callback.resSessionId, kSessionId);
588 EXPECT_EQ(callback.response, kAudioFirstMediaPacketInd);
589 EXPECT_EQ(callback.resConfig, config);
590 }
591
TEST_F(AudioManagerTest,testRtpHeaderExtensionInd)592 TEST_F(AudioManagerTest, testRtpHeaderExtensionInd)
593 {
594 std::list<RtpHeaderExtension> extensions;
595 RtpHeaderExtension extension;
596 const uint8_t kExtensionData[] = {0x01, 0x02};
597 const int32_t kExtensionDataSize = 2;
598 extension.setLocalIdentifier(15);
599 extension.setExtensionData(kExtensionData, kExtensionDataSize);
600 extensions.push_back(extension);
601
602 std::list<RtpHeaderExtension>* param = new std::list<RtpHeaderExtension>();
603 std::copy(extensions.begin(), extensions.end(), std::back_inserter(*param));
604
605 android::Parcel parcel;
606 parcel.writeInt32(param->size());
607
608 for (auto& item : *param)
609 {
610 item.writeToParcel(&parcel);
611 }
612
613 ImsMediaEventHandler::SendEvent("AUDIO_RESPONSE_EVENT", kAudioRtpHeaderExtensionInd, kSessionId,
614 reinterpret_cast<uint64_t>(param), 0);
615
616 gCondition.wait_timeout(20);
617 EXPECT_EQ(callback.resSessionId, kSessionId);
618 EXPECT_EQ(callback.response, kAudioRtpHeaderExtensionInd);
619 EXPECT_EQ(callback.extensions, extensions);
620 }
621
TEST_F(AudioManagerTest,testMediaQualityStatusInd)622 TEST_F(AudioManagerTest, testMediaQualityStatusInd)
623 {
624 MediaQualityStatus status;
625 status.setRtpInactivityTimeMillis(10000);
626 status.setRtcpInactivityTimeMillis(10000);
627 status.setRtpPacketLossRate(1);
628 status.setRtpJitterMillis(100);
629
630 MediaQualityStatus* param = new MediaQualityStatus(status);
631
632 ImsMediaEventHandler::SendEvent("AUDIO_RESPONSE_EVENT", kAudioMediaQualityStatusInd, kSessionId,
633 reinterpret_cast<uint64_t>(param), 0);
634
635 gCondition.wait_timeout(20);
636 EXPECT_EQ(callback.resSessionId, kSessionId);
637 EXPECT_EQ(callback.response, kAudioMediaQualityStatusInd);
638 EXPECT_EQ(callback.mediaQualityStatus, status);
639 }
640
TEST_F(AudioManagerTest,testDtmfReceivedInd)641 TEST_F(AudioManagerTest, testDtmfReceivedInd)
642 {
643 const char digit = 1;
644 const int32_t duration = 100;
645
646 ImsMediaEventHandler::SendEvent(
647 "AUDIO_RESPONSE_EVENT", kAudioDtmfReceivedInd, kSessionId, digit, duration);
648
649 gCondition.wait_timeout(20);
650 EXPECT_EQ(callback.resSessionId, kSessionId);
651 EXPECT_EQ(callback.response, kAudioDtmfReceivedInd);
652 EXPECT_EQ(callback.receivedDtmfDigit, digit);
653 EXPECT_EQ(callback.receivedDtmfDuration, duration);
654 }
655
TEST_F(AudioManagerTest,testCallQualityInd)656 TEST_F(AudioManagerTest, testCallQualityInd)
657 {
658 CallQuality quality;
659 quality.setDownlinkCallQualityLevel(0);
660 quality.setUplinkCallQualityLevel(0);
661 quality.setCallDuration(30000);
662 quality.setNumRtpPacketsTransmitted(1500);
663 quality.setNumRtpPacketsReceived(1500);
664 quality.setNumRtpPacketsTransmittedLost(1);
665 quality.setNumRtpPacketsNotReceived(2);
666 quality.setAverageRelativeJitter(50);
667 quality.setMaxRelativeJitter(150);
668 quality.setAverageRoundTripTime(60);
669 quality.setCodecType(AudioConfig::CODEC_AMR_WB);
670 quality.setRtpInactivityDetected(false);
671 quality.setRxSilenceDetected(false);
672 quality.setTxSilenceDetected(false);
673 quality.setNumVoiceFrames(1400);
674 quality.setNumNoDataFrames(0);
675 quality.setNumDroppedRtpPackets(0);
676 quality.setMinPlayoutDelayMillis(100);
677 quality.setMaxPlayoutDelayMillis(180);
678 quality.setNumRtpSidPacketsReceived(100);
679 quality.setNumRtpDuplicatePackets(1);
680
681 CallQuality* param = new CallQuality(quality);
682
683 ImsMediaEventHandler::SendEvent("AUDIO_RESPONSE_EVENT", kAudioCallQualityChangedInd, kSessionId,
684 reinterpret_cast<uint64_t>(param), 0);
685
686 gCondition.wait_timeout(20);
687 EXPECT_EQ(callback.resSessionId, kSessionId);
688 EXPECT_EQ(callback.response, kAudioCallQualityChangedInd);
689 EXPECT_EQ(callback.callQuality, quality);
690 }
691 } // namespace