1 /*
2 * Copyright (c) 2024 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 "audio_info.h"
18 #include "audio_adapter.h"
19 #include "avsession_log.h"
20 #include "avsession_errors.h"
21 #include "focus_session_strategy.h"
22
23 using namespace OHOS;
24 using namespace OHOS::AVSession;
25 using OHOS::AudioStandard::AudioRendererChangeInfo;
26 using OHOS::AudioStandard::RendererState;
27
28 static std::string g_errLog;
29
MyLogCallback(const LogType type,const LogLevel level,const unsigned int domain,const char * tag,const char * msg)30 static void MyLogCallback(const LogType type, const LogLevel level,
31 const unsigned int domain, const char *tag, const char *msg)
32 {
33 g_errLog = msg;
34 }
35
36 class FocusSessionStrategyTest : public testing::Test {
37 public:
38 static void SetUpTestCase(void);
39 static void TearDownTestCase(void);
40 void SetUp();
41 void TearDown();
42 };
43
SetUpTestCase()44 void FocusSessionStrategyTest::SetUpTestCase()
45 {}
46
TearDownTestCase()47 void FocusSessionStrategyTest::TearDownTestCase()
48 {}
49
SetUp()50 void FocusSessionStrategyTest::SetUp()
51 {}
52
TearDown()53 void FocusSessionStrategyTest::TearDown()
54 {}
55
56 /**
57 * @tc.name: HandleAudioRenderStateChangeEvent001
58 * @tc.desc: Test IsCommandSendEnable
59 * @tc.type: FUNC
60 */
61 static HWTEST_F(FocusSessionStrategyTest, HandleAudioRenderStateChangeEvent001, testing::ext::TestSize.Level1)
62 {
63 SLOGD("HandleAudioRenderStateChangeEvent001 begin!");
64 LOG_SetCallback(MyLogCallback);
65 FocusSessionStrategy focusSessionStrategy;
66 std::shared_ptr<AudioRendererChangeInfo> info = std::make_shared<AudioRendererChangeInfo>();
67 info->clientUID = 1;
68 info->sessionId = 2;
69 info->rendererState = RendererState::RENDERER_RELEASED;
70 AudioRendererChangeInfos infos;
71 infos.push_back(std::move(info));
72
73 focusSessionStrategy.HandleAudioRenderStateChangeEvent(infos);
74 EXPECT_TRUE(g_errLog.find("xxx") == std::string::npos);
75 SLOGD("HandleAudioRenderStateChangeEvent001 end!");
76 }
77
78 /**
79 * @tc.name: HandleAudioRenderStateChangeEvent002
80 * @tc.desc: Test IsCommandSendEnable
81 * @tc.type: FUNC
82 */
83 static HWTEST_F(FocusSessionStrategyTest, HandleAudioRenderStateChangeEvent002, testing::ext::TestSize.Level1)
84 {
85 SLOGD("HandleAudioRenderStateChangeEvent002 begin!");
86 LOG_SetCallback(MyLogCallback);
87 FocusSessionStrategy focusSessionStrategy;
88 std::shared_ptr<AudioRendererChangeInfo> info = std::make_shared<AudioRendererChangeInfo>();
89 info->clientUID = 1;
90 info->sessionId = 2;
91 info->rendererState = RendererState::RENDERER_RELEASED;
92 AudioRendererChangeInfos infos;
93 infos.push_back(std::move(info));
94
__anonefceef320102(const FocusSessionStrategy::FocusSessionChangeInfo&, bool) 95 auto func = [](const FocusSessionStrategy::FocusSessionChangeInfo&, bool) {};
96 focusSessionStrategy.RegisterFocusSessionChangeCallback(func);
97 focusSessionStrategy.HandleAudioRenderStateChangeEvent(infos);
98 EXPECT_TRUE(g_errLog.find("xxx") == std::string::npos);
99 SLOGD("HandleAudioRenderStateChangeEvent002 end!");
100 }
101
102 /**
103 * @tc.name: HandleAudioRenderStateChangeEvent003
104 * @tc.desc: Test IsCommandSendEnable
105 * @tc.type: FUNC
106 */
107 static HWTEST_F(FocusSessionStrategyTest, HandleAudioRenderStateChangeEvent003, testing::ext::TestSize.Level1)
108 {
109 SLOGD("HandleAudioRenderStateChangeEvent003 begin!");
110 LOG_SetCallback(MyLogCallback);
111 FocusSessionStrategy focusSessionStrategy;
112 std::shared_ptr<AudioRendererChangeInfo> info = std::make_shared<AudioRendererChangeInfo>();
113 info->clientUID = 1;
114 info->sessionId = 2;
115 info->rendererState = RendererState::RENDERER_RUNNING;
116 AudioRendererChangeInfos infos;
117 infos.push_back(std::move(info));
118
119 focusSessionStrategy.HandleAudioRenderStateChangeEvent(infos);
120 EXPECT_TRUE(g_errLog.find("xxx") == std::string::npos);
121 SLOGD("HandleAudioRenderStateChangeEvent003 end!");
122 }
123
124 /**
125 * @tc.name: HandleAudioRenderStateChangeEvent004
126 * @tc.desc: Test IsCommandSendEnable
127 * @tc.type: FUNC
128 */
129 static HWTEST_F(FocusSessionStrategyTest, HandleAudioRenderStateChangeEvent004, testing::ext::TestSize.Level1)
130 {
131 SLOGD("HandleAudioRenderStateChangeEvent004 begin!");
132 LOG_SetCallback(MyLogCallback);
133 FocusSessionStrategy focusSessionStrategy;
134 std::shared_ptr<AudioRendererChangeInfo> info = std::make_shared<AudioRendererChangeInfo>();
135 info->clientUID = 1;
136 info->sessionId = 2;
137 info->rendererState = RendererState::RENDERER_RUNNING;
138 AudioRendererChangeInfos infos;
139 infos.push_back(std::move(info));
140
__anonefceef320202(const FocusSessionStrategy::FocusSessionChangeInfo&, bool) 141 auto func = [](const FocusSessionStrategy::FocusSessionChangeInfo&, bool) {};
142 focusSessionStrategy.RegisterFocusSessionChangeCallback(func);
143 focusSessionStrategy.HandleAudioRenderStateChangeEvent(infos);
144 EXPECT_TRUE(g_errLog.find("xxx") == std::string::npos);
145 SLOGD("HandleAudioRenderStateChangeEvent004 end!");
146 }
147
148 /**
149 * @tc.name: HandleAudioRenderStateChangeEvent005
150 * @tc.desc: Test IsCommandSendEnable
151 * @tc.type: FUNC
152 */
153 static HWTEST_F(FocusSessionStrategyTest, HandleAudioRenderStateChangeEvent005, testing::ext::TestSize.Level1)
154 {
155 SLOGD("HandleAudioRenderStateChangeEvent005 begin!");
156 LOG_SetCallback(MyLogCallback);
157 FocusSessionStrategy focusSessionStrategy;
158 std::shared_ptr<AudioRendererChangeInfo> info1 = std::make_shared<AudioRendererChangeInfo>();
159 info1->clientUID = 1;
160 info1->sessionId = 2;
161 info1->rendererState = RendererState::RENDERER_RELEASED;
162
163 std::shared_ptr<AudioRendererChangeInfo> info2 = std::make_shared<AudioRendererChangeInfo>();
164 info2->clientUID = 3;
165 info2->sessionId = 4;
166 info2->rendererState = RendererState::RENDERER_RUNNING;
167
168 AudioRendererChangeInfos infos;
169 infos.push_back(std::move(info1));
170 infos.push_back(std::move(info2));
171
__anonefceef320302(const FocusSessionStrategy::FocusSessionChangeInfo&, bool) 172 auto func = [](const FocusSessionStrategy::FocusSessionChangeInfo&, bool) {};
173 focusSessionStrategy.RegisterFocusSessionChangeCallback(func);
174 focusSessionStrategy.HandleAudioRenderStateChangeEvent(infos);
175 EXPECT_TRUE(g_errLog.find("xxx") == std::string::npos);
176 SLOGD("HandleAudioRenderStateChangeEvent005 end!");
177 }
178
179 /**
180 * @tc.name: IsFocusSession001
181 * @tc.desc: Test IsFocusSession
182 * @tc.type: FUNC
183 */
184 static HWTEST_F(FocusSessionStrategyTest, IsFocusSession001, testing::ext::TestSize.Level1)
185 {
186 SLOGD("IsFocusSession001 begin!");
187 std::shared_ptr<AudioRendererChangeInfo> info = std::make_shared<AudioRendererChangeInfo>();
188 info->clientUID = 1;
189 info->sessionId = 2;
190 info->rendererState = RendererState::RENDERER_RELEASED;
191 AudioRendererChangeInfos infos;
192 infos.push_back(std::move(info));
193 FocusSessionStrategy focusSessionStrategy;
__anonefceef320402(const OHOS::AVSession::FocusSessionStrategy::FocusSessionChangeInfo&) 194 auto func = [](const OHOS::AVSession::FocusSessionStrategy::FocusSessionChangeInfo&) {
195 return false;
196 };
197 focusSessionStrategy.RegisterFocusSessionSelector(func);
198 AudioRendererChangeInfo audioRendererChangeInfo;
199 audioRendererChangeInfo.clientUID = 1;
200 audioRendererChangeInfo.sessionId = 2;
201 audioRendererChangeInfo.rendererState = RendererState::RENDERER_RELEASED;
202 bool ret = focusSessionStrategy.IsFocusSession(audioRendererChangeInfo.clientUID);
203 EXPECT_EQ(ret, true);
204 SLOGD("IsFocusSession001 end!");
205 }
206
207 /**
208 * @tc.name: IsFocusSession002
209 * @tc.desc: Test IsFocusSession
210 * @tc.type: FUNC
211 */
212 static HWTEST_F(FocusSessionStrategyTest, IsFocusSession002, testing::ext::TestSize.Level1)
213 {
214 SLOGD("IsFocusSession002 begin!");
215
216 std::shared_ptr<AudioRendererChangeInfo> info = std::make_shared<AudioRendererChangeInfo>();
217 info->clientUID = 1;
218 info->sessionId = 2;
219 info->rendererState = RendererState::RENDERER_RELEASED;
220 AudioRendererChangeInfos infos;
221 infos.push_back(std::move(info));
222 FocusSessionStrategy focusSessionStrategy;
__anonefceef320502(const OHOS::AVSession::FocusSessionStrategy::FocusSessionChangeInfo&) 223 auto func = [](const OHOS::AVSession::FocusSessionStrategy::FocusSessionChangeInfo&) {
224 return true;
225 };
226 focusSessionStrategy.RegisterFocusSessionSelector(func);
227 AudioRendererChangeInfo audioRendererChangeInfo;
228 audioRendererChangeInfo.clientUID = 1;
229 audioRendererChangeInfo.sessionId = 2;
230 audioRendererChangeInfo.rendererState = RendererState::RENDERER_RUNNING;
231 bool ret = focusSessionStrategy.IsFocusSession(audioRendererChangeInfo.clientUID);
232 EXPECT_EQ(ret, true);
233 SLOGD("IsFocusSession002 end!");
234 }