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