blob: d9e57c9a638226a51fc79ed79fe20a4a2e982c36 [file] [log] [blame]
Helene4af3c62023-01-02 04:26:31 +00001/*
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 <android-base/logging.h>
18#include <android/binder_auto_utils.h>
19#include <android/binder_manager.h>
20#include <sys/socket.h>
21
22#include "radio_imsmedia_utils.h"
23
24#define ASSERT_OK(ret) ASSERT_TRUE(ret.isOk())
25
26void RadioImsMediaTest::SetUp() {
27 std::string serviceName = GetParam();
28
29 ALOGD("Enter RadioImsMediaTest.");
30
31 radio_imsmedia = IImsMedia::fromBinder(
32 ndk::SpAIBinder(AServiceManager_waitForService(GetParam().c_str())));
33 ASSERT_NE(nullptr, radio_imsmedia.get());
34
35 radio_imsmedialistener = ndk::SharedRefBase::make<ImsMediaListener>(*this);
36 ASSERT_NE(nullptr, radio_imsmedialistener.get());
37
38 radio_imsmediasessionlistener = ndk::SharedRefBase::make<ImsMediaSessionListener>(*this);
39 ASSERT_NE(nullptr, radio_imsmediasessionlistener.get());
40 count_ = 0;
41}
42
43TEST_P(RadioImsMediaTest, MOCallSuccess) {
44 int32_t sessionId = 1;
45 RtpConfig modifyRtpConfig;
46
47 modifyRtpConfig.direction =
48 ::aidl::android::hardware::radio::ims::media::MediaDirection::SEND_RECEIVE;
49 modifyRtpConfig.remoteAddress.ipAddress = "122.22.22.33";
50 modifyRtpConfig.remoteAddress.portNumber = 1234;
51
52 if (!deviceSupportsFeature(FEATURE_TELEPHONY_IMS)) {
53 ALOGI("Skipping setListener because ims is not supported in device");
54 return;
55 } else {
56 ALOGI("Running setListener because ims is supported in device");
57 }
58
59 ndk::ScopedAStatus res = radio_imsmedia->setListener(radio_imsmedialistener);
60 ASSERT_OK(res);
61
62 serial = SERIAL_OPEN_SESSION;
63 res = triggerOpenSession(sessionId);
64 ASSERT_OK(res);
65 EXPECT_EQ(std::cv_status::no_timeout, wait());
66 EXPECT_EQ(sessionId, radio_imsmedialistener->mSessionId);
67 ASSERT_NE(nullptr, radio_imsmedialistener->mSession);
68
69 radio_imsmediasession = radio_imsmedialistener->mSession;
70 radio_imsmediasession->setListener(radio_imsmediasessionlistener);
71 ASSERT_OK(res);
72
73 serial = SERIAL_MODIFY_SESSION;
74 res = radio_imsmediasession->modifySession(modifyRtpConfig);
75 ASSERT_OK(res);
76 EXPECT_EQ(std::cv_status::no_timeout, wait());
77 EXPECT_EQ(modifyRtpConfig, radio_imsmediasessionlistener->mConfig);
78 verifyError(radio_imsmediasessionlistener->mError);
79
80 serial = SERIAL_CLOSE_SESSION;
81 res = radio_imsmedia->closeSession(sessionId);
82 ASSERT_OK(res);
83 EXPECT_EQ(std::cv_status::no_timeout, wait());
84 EXPECT_EQ(sessionId, radio_imsmedialistener->mSessionId);
85}
86
87TEST_P(RadioImsMediaTest, testDtmfOperation) {
88 int32_t sessionId = 1;
89 char16_t dtmfDight = 'a';
90 int32_t duration = 200;
91 RtpConfig modifyRtpConfig;
92
93 modifyRtpConfig.direction =
94 ::aidl::android::hardware::radio::ims::media::MediaDirection::SEND_RECEIVE;
95 modifyRtpConfig.remoteAddress.ipAddress = "122.22.22.33";
96 modifyRtpConfig.remoteAddress.portNumber = 1234;
97
98 if (!deviceSupportsFeature(FEATURE_TELEPHONY_IMS)) {
99 ALOGI("Skipping setListener because ims is not supported in device");
100 return;
101 } else {
102 ALOGI("Running setListener because ims is supported in device");
103 }
104
105 ndk::ScopedAStatus res = radio_imsmedia->setListener(radio_imsmedialistener);
106 ASSERT_OK(res);
107
108 serial = SERIAL_OPEN_SESSION;
109 res = triggerOpenSession(sessionId);
110 ASSERT_OK(res);
111 EXPECT_EQ(std::cv_status::no_timeout, wait());
112 EXPECT_EQ(sessionId, radio_imsmedialistener->mSessionId);
113 ASSERT_NE(nullptr, radio_imsmedialistener->mSession);
114
115 radio_imsmediasession = radio_imsmedialistener->mSession;
116 radio_imsmediasession->setListener(radio_imsmediasessionlistener);
117 ASSERT_OK(res);
118
119 serial = SERIAL_MODIFY_SESSION;
120 res = radio_imsmediasession->modifySession(modifyRtpConfig);
121 ASSERT_OK(res);
122 EXPECT_EQ(std::cv_status::no_timeout, wait());
123 EXPECT_EQ(modifyRtpConfig, radio_imsmediasessionlistener->mConfig);
124 verifyError(radio_imsmediasessionlistener->mError);
125
126 res = radio_imsmediasession->sendDtmf(dtmfDight, duration);
127 ASSERT_OK(res);
128
129 res = radio_imsmediasession->startDtmf(dtmfDight);
130 ASSERT_OK(res);
131
132 res = radio_imsmediasession->stopDtmf();
133 ASSERT_OK(res);
134
135 serial = SERIAL_CLOSE_SESSION;
136 res = radio_imsmedia->closeSession(sessionId);
137 ASSERT_OK(res);
138 EXPECT_EQ(std::cv_status::no_timeout, wait());
139}
140
141TEST_P(RadioImsMediaTest, sendHeaderExtension) {
142 int32_t sessionId = 1;
143 std::vector<RtpHeaderExtension> extensions;
144 RtpConfig modifyRtpConfig;
145
146 modifyRtpConfig.direction =
147 ::aidl::android::hardware::radio::ims::media::MediaDirection::SEND_RECEIVE;
148 modifyRtpConfig.remoteAddress.ipAddress = "122.22.22.33";
149 modifyRtpConfig.remoteAddress.portNumber = 1234;
150
151 if (!deviceSupportsFeature(FEATURE_TELEPHONY_IMS)) {
152 ALOGI("Skipping setListener because ims is not supported in device");
153 return;
154 } else {
155 ALOGI("Running setListener because ims is supported in device");
156 }
157
158 ndk::ScopedAStatus res = radio_imsmedia->setListener(radio_imsmedialistener);
159 ASSERT_OK(res);
160
161 serial = SERIAL_OPEN_SESSION;
162 res = triggerOpenSession(sessionId);
163 ASSERT_OK(res);
164 EXPECT_EQ(std::cv_status::no_timeout, wait());
165 EXPECT_EQ(sessionId, radio_imsmedialistener->mSessionId);
166 ASSERT_NE(nullptr, radio_imsmedialistener->mSession);
167
168 radio_imsmediasession = radio_imsmedialistener->mSession;
169 radio_imsmediasession->setListener(radio_imsmediasessionlistener);
170 ASSERT_OK(res);
171
172 serial = SERIAL_MODIFY_SESSION;
173 res = radio_imsmediasession->modifySession(modifyRtpConfig);
174 ASSERT_OK(res);
175 EXPECT_EQ(std::cv_status::no_timeout, wait());
176 EXPECT_EQ(modifyRtpConfig, radio_imsmediasessionlistener->mConfig);
177 verifyError(radio_imsmediasessionlistener->mError);
178
179 res = radio_imsmediasession->sendHeaderExtension(extensions);
180 ASSERT_OK(res);
181
182 serial = SERIAL_CLOSE_SESSION;
183 res = radio_imsmedia->closeSession(sessionId);
184 ASSERT_OK(res);
185 EXPECT_EQ(std::cv_status::no_timeout, wait());
186}
187
188TEST_P(RadioImsMediaTest, setMediaQualityThreshold) {
189 int32_t sessionId = 1;
190 MediaQualityThreshold threshold;
191 RtpConfig modifyRtpConfig;
192
193 modifyRtpConfig.direction =
194 ::aidl::android::hardware::radio::ims::media::MediaDirection::SEND_RECEIVE;
195 modifyRtpConfig.remoteAddress.ipAddress = "122.22.22.33";
196 modifyRtpConfig.remoteAddress.portNumber = 1234;
197
198 if (!deviceSupportsFeature(FEATURE_TELEPHONY_IMS)) {
199 ALOGI("Skipping setListener because ims is not supported in device");
200 return;
201 } else {
202 ALOGI("Running setListener because ims is supported in device");
203 }
204
205 ndk::ScopedAStatus res = radio_imsmedia->setListener(radio_imsmedialistener);
206 ASSERT_OK(res);
207
208 serial = SERIAL_OPEN_SESSION;
209 res = triggerOpenSession(sessionId);
210 ASSERT_OK(res);
211 EXPECT_EQ(std::cv_status::no_timeout, wait());
212 EXPECT_EQ(sessionId, radio_imsmedialistener->mSessionId);
213 ASSERT_NE(nullptr, radio_imsmedialistener->mSession);
214
215 radio_imsmediasession = radio_imsmedialistener->mSession;
216 radio_imsmediasession->setListener(radio_imsmediasessionlistener);
217 ASSERT_OK(res);
218
219 serial = SERIAL_MODIFY_SESSION;
220 res = radio_imsmediasession->modifySession(modifyRtpConfig);
221 ASSERT_OK(res);
222 EXPECT_EQ(std::cv_status::no_timeout, wait());
223 EXPECT_EQ(modifyRtpConfig, radio_imsmediasessionlistener->mConfig);
224 verifyError(radio_imsmediasessionlistener->mError);
225
226 res = radio_imsmediasession->setMediaQualityThreshold(threshold);
227 ASSERT_OK(res);
228
229 serial = SERIAL_CLOSE_SESSION;
230 res = radio_imsmedia->closeSession(sessionId);
231 ASSERT_OK(res);
232 EXPECT_EQ(std::cv_status::no_timeout, wait());
233}
234
235ndk::ScopedAStatus RadioImsMediaTest::triggerOpenSession(int32_t sessionId) {
236 LocalEndPoint localEndPoint;
237 RtpConfig rtpConfig;
238 ndk::ScopedAStatus result;
239
240 int mSocketFd = ::socket(AF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
241 int mRtcpSocketFd = ::socket(AF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
242 localEndPoint.rtpFd = ndk::ScopedFileDescriptor(mSocketFd);
243 localEndPoint.rtcpFd = ndk::ScopedFileDescriptor(mRtcpSocketFd);
244 localEndPoint.modemId = 1;
245
246 rtpConfig.direction =
247 ::aidl::android::hardware::radio::ims::media::MediaDirection::SEND_RECEIVE;
248 rtpConfig.remoteAddress.ipAddress = "122.22.22.22";
249 rtpConfig.remoteAddress.portNumber = 2222;
250
251 result = radio_imsmedia->openSession(sessionId, localEndPoint, rtpConfig);
252
253 return result;
254}
255
256void RadioImsMediaTest::verifyError(RtpError error) {
257 switch (error) {
258 case RtpError::NONE:
259 case RtpError::INVALID_PARAM:
260 case RtpError::NOT_READY:
261 case RtpError::NO_MEMORY:
262 case RtpError::NO_RESOURCES:
263 case RtpError::PORT_UNAVAILABLE:
264 case RtpError::NOT_SUPPORTED:
265 SUCCEED();
266 break;
267 default:
268 FAIL();
269 break;
270 }
271}