1 /*
2 * Copyright (c) 2025 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 <gtest/gtest.h>
17 #include <chrono>
18 #include <thread>
19
20 #include "system_ability_definition.h"
21 #include "avsession_service.h"
22 #include "string_wrapper.h"
23
24 using namespace testing::ext;
25 using namespace OHOS::AVSession;
26
27 namespace OHOS {
28 namespace AVSession {
29
30 static char g_testSessionTag[] = "test";
31 static char g_testAnotherBundleName[] = "testAnother.ohos.avsession";
32 static char g_testAnotherAbilityName[] = "testAnother.ability";
33 static std::shared_ptr<MigrateAVSessionServer> g_MigrateAVSessionServer {nullptr};
34 static std::shared_ptr<AVSessionService> g_AVSessionService {nullptr};
35 static OHOS::sptr<AVSessionItem> g_AVSessionItem {nullptr};
36 static OHOS::sptr<AVControllerItem> g_AVControllerItem {nullptr};
37
38 class AVControllerItemTest : public testing::Test {
39 public:
40
41 static void SetUpTestCase();
42 static void TearDownTestCase();
43 void SetUp();
44 void TearDown();
45 };
46
SetUpTestCase()47 void AVControllerItemTest::SetUpTestCase()
48 {
49 g_MigrateAVSessionServer = std::make_shared<MigrateAVSessionServer>();
50 OHOS::AppExecFwk::ElementName elementName;
51 elementName.SetBundleName(g_testAnotherBundleName);
52 elementName.SetAbilityName(g_testAnotherAbilityName);
53 g_AVSessionService = std::make_shared<AVSessionService>(OHOS::AVSESSION_SERVICE_ID, true);
54 g_AVSessionItem = g_AVSessionService->CreateSessionInner(g_testSessionTag,
55 AVSession::SESSION_TYPE_VOICE_CALL, false, elementName);
56 g_AVControllerItem = g_AVSessionService->CreateNewControllerForSession(
57 g_AVSessionItem->GetPid(), g_AVSessionItem);
58 }
59
TearDownTestCase()60 void AVControllerItemTest::TearDownTestCase()
61 {
62 g_AVSessionService->HandleSessionRelease(g_AVSessionItem->GetSessionId());
63 g_AVControllerItem->Destroy();
64 g_AVSessionItem->Destroy();
65 }
66
SetUp()67 void AVControllerItemTest::SetUp()
68 {}
69
TearDown()70 void AVControllerItemTest::TearDown()
71 {}
72
73 class IAVControllerCallbackTest : public IAVControllerCallback {
OnAVCallMetaDataChange(const AVCallMetaData & avCallMetaData)74 ErrCode OnAVCallMetaDataChange(const AVCallMetaData& avCallMetaData) override
75 {
76 return AVSESSION_SUCCESS;
77 };
OnAVCallStateChange(const AVCallState & avCallState)78 ErrCode OnAVCallStateChange(const AVCallState& avCallState) override
79 {
80 return AVSESSION_SUCCESS;
81 };
OnSessionDestroy()82 ErrCode OnSessionDestroy() override
83 {
84 return AVSESSION_SUCCESS;
85 };
OnPlaybackStateChange(const AVPlaybackState & state)86 ErrCode OnPlaybackStateChange(const AVPlaybackState& state) override
87 {
88 return AVSESSION_SUCCESS;
89 };
OnMetaDataChange(const AVMetaData & data)90 ErrCode OnMetaDataChange(const AVMetaData& data) override
91 {
92 return AVSESSION_SUCCESS;
93 };
OnActiveStateChange(bool isActive)94 ErrCode OnActiveStateChange(bool isActive) override
95 {
96 return AVSESSION_SUCCESS;
97 };
OnValidCommandChange(const std::vector<int32_t> & cmds)98 ErrCode OnValidCommandChange(const std::vector<int32_t>& cmds) override
99 {
100 return AVSESSION_SUCCESS;
101 };
OnOutputDeviceChange(const int32_t connectionState,const OutputDeviceInfo & outputDeviceInfo)102 ErrCode OnOutputDeviceChange(const int32_t connectionState, const OutputDeviceInfo& outputDeviceInfo) override
103 {
104 return AVSESSION_SUCCESS;
105 };
OnSessionEventChange(const std::string & event,const OHOS::AAFwk::WantParams & ARGS)106 ErrCode OnSessionEventChange(const std::string& event, const OHOS::AAFwk::WantParams& ARGS) override
107 {
108 return AVSESSION_SUCCESS;
109 };
OnQueueItemsChange(const std::vector<AVQueueItem> & items)110 ErrCode OnQueueItemsChange(const std::vector<AVQueueItem>& items) override
111 {
112 return AVSESSION_SUCCESS;
113 };
OnQueueTitleChange(const std::string & title)114 ErrCode OnQueueTitleChange(const std::string& title) override
115 {
116 return AVSESSION_SUCCESS;
117 };
OnExtrasChange(const OHOS::AAFwk::WantParams & extras)118 ErrCode OnExtrasChange(const OHOS::AAFwk::WantParams& extras) override
119 {
120 return AVSESSION_SUCCESS;
121 };
OnCustomData(const OHOS::AAFwk::WantParams & data)122 ErrCode OnCustomData(const OHOS::AAFwk::WantParams& data) override
123 {
124 return AVSESSION_SUCCESS;
125 };
AsObject()126 OHOS::sptr<IRemoteObject> AsObject() override
127 {
128 OHOS::AppExecFwk::ElementName elementName;
129 elementName.SetBundleName(g_testAnotherBundleName);
130 elementName.SetAbilityName(g_testAnotherAbilityName);
131 OHOS::sptr<AVSessionItem> avsessionHere_ = g_AVSessionService->CreateSessionInner(
132 g_testSessionTag, AVSession::SESSION_TYPE_VOICE_CALL, false, elementName);
133 std::string sessionId = avsessionHere_->GetSessionId();
134 OHOS::sptr<IRemoteObject> object = nullptr;
135 g_AVSessionService->CreateControllerInner(sessionId, object);
136 return object;
137 }
138 };
139
140 /**
141 * @tc.name: GetAVMetaData001
142 * @tc.desc: Test GetAVMetaData with no media image
143 * @tc.type: FUNC
144 * @tc.require: #I5Y4MZ
145 */
146 HWTEST_F(AVControllerItemTest, GetAVMetaData001, TestSize.Level0)
147 {
148 OHOS::sptr<AVControllerItem> controller = new AVControllerItem(1, g_AVSessionItem);
149 ASSERT_TRUE(controller != nullptr);
150 AVMetaData metaData;
151 auto ret = controller->GetAVMetaData(metaData);
152 EXPECT_EQ(ret, AVSESSION_SUCCESS);
153 }
154
155 /**
156 * @tc.name: GetAVMetaData002
157 * @tc.desc: Test GetAVMetaData with media image
158 * @tc.type: FUNC
159 * @tc.require: #I5Y4MZ
160 */
161 HWTEST_F(AVControllerItemTest, GetAVMetaData002, TestSize.Level0)
162 {
163 OHOS::sptr<AVControllerItem> controller = new AVControllerItem(1, g_AVSessionItem);
164 ASSERT_TRUE(controller != nullptr);
165 std::shared_ptr<AVSessionPixelMap> mediaImage = std::make_shared<AVSessionPixelMap>();
166 ASSERT_TRUE(mediaImage != nullptr);
167 std::vector<uint8_t> imgBuffer = {1, 2, 3, 4, 5, 6, 7, 8};
168 mediaImage->SetInnerImgBuffer(imgBuffer);
169 g_AVSessionItem->metaData_.SetMediaImage(mediaImage);
170 g_AVSessionItem->metaData_.SetMediaImageUri(g_testSessionTag);
171 AVMetaData metaData;
172 auto ret = controller->GetAVMetaData(metaData);
173 EXPECT_EQ(ret, ERR_INVALID_PARAM);
174 }
175
176 /**
177 * @tc.name: GetAVMetaData003
178 * @tc.desc: Test GetAVMetaData with media image, isFromSession_ is true
179 * @tc.type: FUNC
180 * @tc.require: #I5Y4MZ
181 */
182 HWTEST_F(AVControllerItemTest, GetAVMetaData003, TestSize.Level0)
183 {
184 OHOS::sptr<AVControllerItem> controller = new AVControllerItem(1, g_AVSessionItem);
185 ASSERT_TRUE(controller != nullptr);
186 std::shared_ptr<AVSessionPixelMap> mediaImage = std::make_shared<AVSessionPixelMap>();
187 ASSERT_TRUE(mediaImage != nullptr);
188 std::vector<uint8_t> imgBuffer = {1, 2, 3, 4, 5, 6, 7, 8};
189 mediaImage->SetInnerImgBuffer(imgBuffer);
190 g_AVSessionItem->metaData_.SetMediaImage(mediaImage);
191 g_AVSessionItem->metaData_.SetMediaImageUri(g_testSessionTag);
192 controller->isFromSession_ = true;
193 AVMetaData metaData;
194 auto ret = controller->GetAVMetaData(metaData);
195 EXPECT_EQ(ret, AVSESSION_SUCCESS);
196 }
197
198 /**
199 * @tc.name: SendCommonCommand001
200 * @tc.desc: Test SendCommonCommand with null migrateProxyCallback_
201 * @tc.type: FUNC
202 * @tc.require: #I5Y4MZ
203 */
204 HWTEST_F(AVControllerItemTest, SendCommonCommand001, TestSize.Level0)
205 {
206 OHOS::sptr<AVControllerItem> controller = new AVControllerItem(1, g_AVSessionItem);
207 ASSERT_TRUE(controller != nullptr);
208 std::string commonCommand;
209 OHOS::AAFwk::WantParams commandArgs;
210 auto ret = controller->SendCommonCommand(commonCommand, commandArgs);
211 EXPECT_EQ(ret, AVSESSION_SUCCESS);
212 }
213
214 /**
215 * @tc.name: SendCommonCommand002
216 * @tc.desc: Test SendCommonCommand with with not null migrateProxyCallback_
217 * @tc.type: FUNC
218 * @tc.require: #I5Y4MZ
219 */
220 HWTEST_F(AVControllerItemTest, SendCommonCommand002, TestSize.Level0)
221 {
222 OHOS::sptr<AVControllerItem> controller = new AVControllerItem(1, g_AVSessionItem);
223 ASSERT_TRUE(controller != nullptr);
224 std::string commonCommand;
225 OHOS::AAFwk::WantParams commandArgs;
__anonbceff0680102(const std::string& event, OHOS::AAFwk::WantParams& args) 226 controller->migrateProxyCallback_ = [](const std::string& event, OHOS::AAFwk::WantParams& args) {
227 return AVSESSION_SUCCESS;
228 };
229 auto ret = controller->SendCommonCommand(commonCommand, commandArgs);
230 EXPECT_EQ(ret, AVSESSION_SUCCESS);
231 }
232
233 /**
234 * @tc.name: SendCustomData001
235 * @tc.desc: Test SendCustomData with null migrateProxyCallback_
236 * @tc.type: FUNC
237 * @tc.require: #ICNHGY
238 */
239 HWTEST_F(AVControllerItemTest, SendCustomData001, TestSize.Level0)
240 {
241 OHOS::sptr<AVControllerItem> controller = new AVControllerItem(1, g_AVSessionItem);
242 ASSERT_TRUE(controller != nullptr);
243 std::string test = "test";
244 OHOS::AAFwk::WantParams data;
245 data.SetParam("customData", AAFwk::String::Box(test));
246
247 auto ret = controller->SendCustomData(data);
248 EXPECT_EQ(ret, AVSESSION_SUCCESS);
249 }
250
251 /**
252 * @tc.name: Destroy001
253 * @tc.desc: Test Destroy with with sessionId_ is DEFAULT
254 * @tc.type: FUNC
255 * @tc.require: #I5Y4MZ
256 */
257 HWTEST_F(AVControllerItemTest, Destroy001, TestSize.Level0)
258 {
259 OHOS::sptr<AVControllerItem> controller = new AVControllerItem(1, g_AVSessionItem);
260 ASSERT_TRUE(controller != nullptr);
261 controller->sessionId_ = "DEFAULT";
262 auto ret = controller->Destroy();
263 EXPECT_EQ(ret, AVSESSION_SUCCESS);
264 }
265
266 /**
267 * @tc.name: HandleSessionDestroy001
268 * @tc.desc: Test HandleSessionDestroy with with callback_ is not nullptr
269 * @tc.type: FUNC
270 * @tc.require: #I5Y4MZ
271 */
272 HWTEST_F(AVControllerItemTest, HandleSessionDestroy001, TestSize.Level0)
273 {
274 OHOS::sptr<AVControllerItem> controller = new AVControllerItem(getpid(), g_AVSessionItem);
275 ASSERT_TRUE(controller != nullptr);
276 OHOS::sptr<IAVControllerCallback> callback = new IAVControllerCallbackTest();
277 ASSERT_TRUE(callback != nullptr);
278 controller->callback_ = callback;
279 controller->HandleSessionDestroy();
280 EXPECT_EQ(controller->session_, nullptr);
281 }
282
283 /**
284 * @tc.name: HandleAVCallStateChange001
285 * @tc.desc: Test HandleAVCallStateChange with with callback_ is not nullptr
286 * @tc.type: FUNC
287 * @tc.require: #I5Y4MZ
288 */
289 HWTEST_F(AVControllerItemTest, HandleAVCallStateChange001, TestSize.Level0)
290 {
291 OHOS::sptr<AVControllerItem> controller = new AVControllerItem(getpid(), g_AVSessionItem);
292 ASSERT_TRUE(controller != nullptr);
293 OHOS::sptr<IAVControllerCallback> callback = new IAVControllerCallbackTest();
294 ASSERT_TRUE(callback != nullptr);
295 controller->callback_ = callback;
296 AVCallState callState;
297 controller->HandleAVCallStateChange(callState);
298 EXPECT_NE(controller->session_, nullptr);
299 }
300
301 /**
302 * @tc.name: HandleActiveStateChange001
303 * @tc.desc: Test HandleActiveStateChange with with callback_ is not nullptr
304 * @tc.type: FUNC
305 * @tc.require: #I5Y4MZ
306 */
307 HWTEST_F(AVControllerItemTest, HandleActiveStateChange001, TestSize.Level0)
308 {
309 OHOS::sptr<AVControllerItem> controller = new AVControllerItem(getpid(), g_AVSessionItem);
310 ASSERT_TRUE(controller != nullptr);
311 OHOS::sptr<IAVControllerCallback> callback = new IAVControllerCallbackTest();
312 ASSERT_TRUE(callback != nullptr);
313 controller->callback_ = callback;
314 controller->HandleActiveStateChange(false);
315 EXPECT_NE(controller->session_, nullptr);
316 }
317
318
319 /**
320 * @tc.name: HandleCustomData001
321 * @tc.desc: handle customData
322 * @tc.type: FUNC
323 * @tc.require: #ICNHGY
324 */
325 HWTEST_F(AVControllerItemTest, HandleCustomData001, TestSize.Level0)
326 {
327 OHOS::sptr<AVControllerItem> controller = new AVControllerItem(getpid(), g_AVSessionItem);
328 ASSERT_TRUE(controller != nullptr);
329 OHOS::sptr<IAVControllerCallback> callback = new IAVControllerCallbackTest();
330 ASSERT_TRUE(callback != nullptr);
331 controller->callback_ = callback;
332 AAFwk::WantParams data;
333 std::string test = "test";
334 data.SetParam("customData", AAFwk::String::Box(test));
335 controller->HandleCustomData(data);
336 EXPECT_NE(controller->session_, nullptr);
337 }
338
339 /**
340 * @tc.name: HandleCustomData002
341 * @tc.desc: handle customData
342 * @tc.type: FUNC
343 * @tc.require: #ICNHGY
344 */
345 HWTEST_F(AVControllerItemTest, HandleCustomData002, TestSize.Level0)
346 {
347 OHOS::sptr<AVControllerItem> controller = new AVControllerItem(getpid(), g_AVSessionItem);
348 ASSERT_TRUE(controller != nullptr);
349 AAFwk::WantParams data;
350 std::string test = "test";
351 data.SetParam("customData", AAFwk::String::Box(test));
352 controller->HandleCustomData(data);
353 EXPECT_NE(controller->session_, nullptr);
354 }
355 } //AVSession
356 } //OHOS