1 /*
2 * Copyright 2020 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 //#define LOG_NDEBUG 0
18 #define LOG_TAG "ResourceObserverService_test"
19
20 #include <iostream>
21 #include <list>
22
23 #include <aidl/android/media/BnResourceObserver.h>
24 #include <utils/Log.h>
25 #include "ResourceObserverService.h"
26 #include "ResourceManagerServiceTestUtils.h"
27
28 namespace android {
29
30 using ::aidl::android::media::BnResourceObserver;
31 using ::aidl::android::media::MediaObservableParcel;
32 using ::aidl::android::media::MediaObservableType;
33
34 #define BUSY ::aidl::android::media::MediaObservableEvent::kBusy
35 #define IDLE ::aidl::android::media::MediaObservableEvent::kIdle
36 #define ALL ::aidl::android::media::MediaObservableEvent::kAll
37
38 struct EventTracker {
39 struct Event {
40 enum { NoEvent, Busy, Idle } type = NoEvent;
41 int uid = 0;
42 int pid = 0;
43 std::vector<MediaObservableParcel> observables;
44 };
45
46 static const Event NoEvent;
47
toStringandroid::EventTracker48 static std::string toString(const MediaObservableParcel& observable) {
49 return "{" + ::aidl::android::media::toString(observable.type)
50 + ", " + std::to_string(observable.value) + "}";
51 }
toStringandroid::EventTracker52 static std::string toString(const Event& event) {
53 std::string eventStr;
54 switch (event.type) {
55 case Event::Busy:
56 eventStr = "Busy";
57 break;
58 case Event::Idle:
59 eventStr = "Idle";
60 break;
61 default:
62 return "NoEvent";
63 }
64 std::string observableStr;
65 for (auto &observable : event.observables) {
66 if (!observableStr.empty()) {
67 observableStr += ", ";
68 }
69 observableStr += toString(observable);
70 }
71 return "{" + eventStr + ", " + std::to_string(event.uid) + ", "
72 + std::to_string(event.pid) + ", {" + observableStr + "}}";
73 }
74
Busyandroid::EventTracker75 static Event Busy(int uid, int pid, const std::vector<MediaObservableParcel>& observables) {
76 return { Event::Busy, uid, pid, observables };
77 }
Idleandroid::EventTracker78 static Event Idle(int uid, int pid, const std::vector<MediaObservableParcel>& observables) {
79 return { Event::Idle, uid, pid, observables };
80 }
81
82 // Pop 1 event from front, wait for up to timeoutUs if empty.
popandroid::EventTracker83 const Event& pop(int64_t timeoutUs = 0) {
84 std::unique_lock lock(mLock);
85
86 if (mEventQueue.empty() && timeoutUs > 0) {
87 mCondition.wait_for(lock, std::chrono::microseconds(timeoutUs));
88 }
89
90 if (mEventQueue.empty()) {
91 mPoppedEvent = NoEvent;
92 } else {
93 mPoppedEvent = *mEventQueue.begin();
94 mEventQueue.pop_front();
95 }
96
97 return mPoppedEvent;
98 }
99
100 // Push 1 event to back.
appendandroid::EventTracker101 void append(const Event& event) {
102 ALOGD("%s", toString(event).c_str());
103
104 std::unique_lock lock(mLock);
105
106 mEventQueue.push_back(event);
107 mCondition.notify_one();
108 }
109
110 private:
111 std::mutex mLock;
112 std::condition_variable mCondition;
113 Event mPoppedEvent;
114 std::list<Event> mEventQueue;
115 };
116
117 const EventTracker::Event EventTracker::NoEvent;
118
createSecureVideoCodecResource(int amount=1)119 static MediaResource createSecureVideoCodecResource(int amount = 1) {
120 return MediaResource(MediaResource::Type::kSecureCodec,
121 MediaResource::SubType::kVideoCodec, amount);
122 }
123
createNonSecureVideoCodecResource(int amount=1)124 static MediaResource createNonSecureVideoCodecResource(int amount = 1) {
125 return MediaResource(MediaResource::Type::kNonSecureCodec,
126 MediaResource::SubType::kVideoCodec, amount);
127 }
128
createSecureAudioCodecResource(int amount=1)129 static MediaResource createSecureAudioCodecResource(int amount = 1) {
130 return MediaResource(MediaResource::Type::kSecureCodec,
131 MediaResource::SubType::kAudioCodec, amount);
132 }
133
createNonSecureAudioCodecResource(int amount=1)134 static MediaResource createNonSecureAudioCodecResource(int amount = 1) {
135 return MediaResource(MediaResource::Type::kNonSecureCodec,
136 MediaResource::SubType::kAudioCodec, amount);
137 }
138
139 // Operators for GTest macros.
operator ==(const EventTracker::Event & lhs,const EventTracker::Event & rhs)140 bool operator==(const EventTracker::Event& lhs, const EventTracker::Event& rhs) {
141 return lhs.type == rhs.type && lhs.uid == rhs.uid && lhs.pid == rhs.pid &&
142 lhs.observables == rhs.observables;
143 }
144
operator <<(std::ostream & str,const EventTracker::Event & v)145 std::ostream& operator<<(std::ostream& str, const EventTracker::Event& v) {
146 str << EventTracker::toString(v);
147 return str;
148 }
149
150 struct TestObserver : public BnResourceObserver, public EventTracker {
TestObserverandroid::TestObserver151 TestObserver(const char *name) : mName(name) {}
152 ~TestObserver() = default;
onStatusChangedandroid::TestObserver153 Status onStatusChanged(MediaObservableEvent event, int32_t uid, int32_t pid,
154 const std::vector<MediaObservableParcel>& observables) override {
155 ALOGD("%s: %s", mName.c_str(), __FUNCTION__);
156 if (event == MediaObservableEvent::kBusy) {
157 append(Busy(uid, pid, observables));
158 } else {
159 append(Idle(uid, pid, observables));
160 }
161
162 return Status::ok();
163 }
164 std::string mName;
165 };
166
167 class ResourceObserverServiceTest : public ResourceManagerServiceTestBase {
168 public:
ResourceObserverServiceTest()169 ResourceObserverServiceTest() : ResourceManagerServiceTestBase(),
170 mObserverService(::ndk::SharedRefBase::make<ResourceObserverService>()),
171 mTestObserver1(::ndk::SharedRefBase::make<TestObserver>("observer1")),
172 mTestObserver2(::ndk::SharedRefBase::make<TestObserver>("observer2")),
173 mTestObserver3(::ndk::SharedRefBase::make<TestObserver>("observer3")) {
174 mService->setObserverService(mObserverService);
175 }
176
registerObservers(MediaObservableEvent filter=ALL)177 void registerObservers(MediaObservableEvent filter = ALL) {
178 std::vector<MediaObservableFilter> filters1, filters2, filters3;
179 filters1 = {{MediaObservableType::kVideoSecureCodec, filter}};
180 filters2 = {{MediaObservableType::kVideoNonSecureCodec, filter}};
181 filters3 = {{MediaObservableType::kVideoSecureCodec, filter},
182 {MediaObservableType::kVideoNonSecureCodec, filter}};
183
184 // mTestObserver1 monitors secure video codecs.
185 EXPECT_TRUE(mObserverService->registerObserver(mTestObserver1, filters1).isOk());
186
187 // mTestObserver2 monitors non-secure video codecs.
188 EXPECT_TRUE(mObserverService->registerObserver(mTestObserver2, filters2).isOk());
189
190 // mTestObserver3 monitors both secure & non-secure video codecs.
191 EXPECT_TRUE(mObserverService->registerObserver(mTestObserver3, filters3).isOk());
192 }
193
194 protected:
195 std::shared_ptr<ResourceObserverService> mObserverService;
196 std::shared_ptr<TestObserver> mTestObserver1;
197 std::shared_ptr<TestObserver> mTestObserver2;
198 std::shared_ptr<TestObserver> mTestObserver3;
199 };
200
TEST_F(ResourceObserverServiceTest,testRegisterObserver)201 TEST_F(ResourceObserverServiceTest, testRegisterObserver) {
202 std::vector<MediaObservableFilter> filters1;
203 Status status;
204
205 // Register with null observer should fail.
206 status = mObserverService->registerObserver(nullptr, filters1);
207 EXPECT_FALSE(status.isOk());
208 EXPECT_EQ(status.getServiceSpecificError(), BAD_VALUE);
209
210 // Register with empty observables should fail.
211 status = mObserverService->registerObserver(mTestObserver1, filters1);
212 EXPECT_FALSE(status.isOk());
213 EXPECT_EQ(status.getServiceSpecificError(), BAD_VALUE);
214
215 // mTestObserver1 monitors secure video codecs.
216 filters1 = {{MediaObservableType::kVideoSecureCodec, ALL}};
217 EXPECT_TRUE(mObserverService->registerObserver(mTestObserver1, filters1).isOk());
218
219 // Register duplicates should fail.
220 status = mObserverService->registerObserver(mTestObserver1, filters1);
221 EXPECT_FALSE(status.isOk());
222 EXPECT_EQ(status.getServiceSpecificError(), ALREADY_EXISTS);
223 }
224
TEST_F(ResourceObserverServiceTest,testUnregisterObserver)225 TEST_F(ResourceObserverServiceTest, testUnregisterObserver) {
226 std::vector<MediaObservableFilter> filters1;
227 Status status;
228
229 // Unregister without registering first should fail.
230 status = mObserverService->unregisterObserver(mTestObserver1);
231 EXPECT_FALSE(status.isOk());
232 EXPECT_EQ(status.getServiceSpecificError(), NAME_NOT_FOUND);
233
234 // mTestObserver1 monitors secure video codecs.
235 filters1 = {{MediaObservableType::kVideoSecureCodec, ALL}};
236 EXPECT_TRUE(mObserverService->registerObserver(mTestObserver1, filters1).isOk());
237 EXPECT_TRUE(mObserverService->unregisterObserver(mTestObserver1).isOk());
238
239 // Unregister again should fail.
240 status = mObserverService->unregisterObserver(mTestObserver1);
241 EXPECT_FALSE(status.isOk());
242 EXPECT_EQ(status.getServiceSpecificError(), NAME_NOT_FOUND);
243 }
244
TEST_F(ResourceObserverServiceTest,testAddResourceBasic)245 TEST_F(ResourceObserverServiceTest, testAddResourceBasic) {
246 registerObservers();
247
248 std::vector<MediaObservableParcel> observables1, observables2, observables3;
249 observables1 = {{MediaObservableType::kVideoSecureCodec, 1}};
250 observables2 = {{MediaObservableType::kVideoNonSecureCodec, 1}};
251 observables3 = {{MediaObservableType::kVideoSecureCodec, 1},
252 {MediaObservableType::kVideoNonSecureCodec, 1}};
253
254 std::vector<MediaResourceParcel> resources;
255 // Add secure video codec.
256 resources = {createSecureVideoCodecResource()};
257 mService->addResource(kTestPid1, kTestUid1, getId(mTestClient1), mTestClient1, resources);
258 EXPECT_EQ(mTestObserver1->pop(), EventTracker::Busy(kTestUid1, kTestPid1, observables1));
259 EXPECT_EQ(mTestObserver2->pop(), EventTracker::NoEvent);
260 EXPECT_EQ(mTestObserver3->pop(), EventTracker::Busy(kTestUid1, kTestPid1, observables1));
261
262 // Add non-secure video codec.
263 resources = {createNonSecureVideoCodecResource()};
264 mService->addResource(kTestPid2, kTestUid2, getId(mTestClient2), mTestClient2, resources);
265 EXPECT_EQ(mTestObserver1->pop(), EventTracker::NoEvent);
266 EXPECT_EQ(mTestObserver2->pop(), EventTracker::Busy(kTestUid2, kTestPid2, observables2));
267 EXPECT_EQ(mTestObserver3->pop(), EventTracker::Busy(kTestUid2, kTestPid2, observables2));
268
269 // Add secure & non-secure video codecs.
270 resources = {createSecureVideoCodecResource(),
271 createNonSecureVideoCodecResource()};
272 mService->addResource(kTestPid2, kTestUid2, getId(mTestClient3), mTestClient3, resources);
273 EXPECT_EQ(mTestObserver1->pop(), EventTracker::Busy(kTestUid2, kTestPid2, observables1));
274 EXPECT_EQ(mTestObserver2->pop(), EventTracker::Busy(kTestUid2, kTestPid2, observables2));
275 EXPECT_EQ(mTestObserver3->pop(), EventTracker::Busy(kTestUid2, kTestPid2, observables3));
276
277 // Add additional audio codecs, should be ignored.
278 resources.push_back(createSecureAudioCodecResource());
279 resources.push_back(createNonSecureAudioCodecResource());
280 mService->addResource(kTestPid1, kTestUid1, getId(mTestClient1), mTestClient1, resources);
281 EXPECT_EQ(mTestObserver1->pop(), EventTracker::Busy(kTestUid1, kTestPid1, observables1));
282 EXPECT_EQ(mTestObserver2->pop(), EventTracker::Busy(kTestUid1, kTestPid1, observables2));
283 EXPECT_EQ(mTestObserver3->pop(), EventTracker::Busy(kTestUid1, kTestPid1, observables3));
284 }
285
TEST_F(ResourceObserverServiceTest,testAddResourceMultiple)286 TEST_F(ResourceObserverServiceTest, testAddResourceMultiple) {
287 registerObservers();
288
289 std::vector<MediaObservableParcel> observables1, observables2, observables3;
290 observables1 = {{MediaObservableType::kVideoSecureCodec, 1}};
291 observables2 = {{MediaObservableType::kVideoNonSecureCodec, 1}};
292 observables3 = {{MediaObservableType::kVideoSecureCodec, 1},
293 {MediaObservableType::kVideoNonSecureCodec, 1}};
294
295 std::vector<MediaResourceParcel> resources;
296
297 // Add multiple secure & non-secure video codecs.
298 // Multiple entries of the same type should be merged, count should be propagated correctly.
299 resources = {createSecureVideoCodecResource(),
300 createSecureVideoCodecResource(),
301 createNonSecureVideoCodecResource(3)};
302 observables1 = {{MediaObservableType::kVideoSecureCodec, 2}};
303 observables2 = {{MediaObservableType::kVideoNonSecureCodec, 3}};
304 observables3 = {{MediaObservableType::kVideoSecureCodec, 2},
305 {MediaObservableType::kVideoNonSecureCodec, 3}};
306 mService->addResource(kTestPid2, kTestUid2, getId(mTestClient3), mTestClient3, resources);
307 EXPECT_EQ(mTestObserver1->pop(), EventTracker::Busy(kTestUid2, kTestPid2, observables1));
308 EXPECT_EQ(mTestObserver2->pop(), EventTracker::Busy(kTestUid2, kTestPid2, observables2));
309 EXPECT_EQ(mTestObserver3->pop(), EventTracker::Busy(kTestUid2, kTestPid2, observables3));
310 }
311
TEST_F(ResourceObserverServiceTest,testRemoveResourceBasic)312 TEST_F(ResourceObserverServiceTest, testRemoveResourceBasic) {
313 registerObservers();
314
315 std::vector<MediaObservableParcel> observables1, observables2, observables3;
316 observables1 = {{MediaObservableType::kVideoSecureCodec, 1}};
317 observables2 = {{MediaObservableType::kVideoNonSecureCodec, 1}};
318 observables3 = {{MediaObservableType::kVideoSecureCodec, 1},
319 {MediaObservableType::kVideoNonSecureCodec, 1}};
320
321 std::vector<MediaResourceParcel> resources;
322 // Add secure video codec to client1.
323 resources = {createSecureVideoCodecResource()};
324 mService->addResource(kTestPid1, kTestUid1, getId(mTestClient1), mTestClient1, resources);
325 EXPECT_EQ(mTestObserver1->pop(), EventTracker::Busy(kTestUid1, kTestPid1, observables1));
326 EXPECT_EQ(mTestObserver2->pop(), EventTracker::NoEvent);
327 EXPECT_EQ(mTestObserver3->pop(), EventTracker::Busy(kTestUid1, kTestPid1, observables1));
328 // Remove secure video codec. observer 1&3 should receive updates.
329 mService->removeResource(kTestPid1, getId(mTestClient1), resources);
330 EXPECT_EQ(mTestObserver1->pop(), EventTracker::Idle(kTestUid1, kTestPid1, observables1));
331 EXPECT_EQ(mTestObserver2->pop(), EventTracker::NoEvent);
332 EXPECT_EQ(mTestObserver3->pop(), EventTracker::Idle(kTestUid1, kTestPid1, observables1));
333 // Remove secure video codec again, should have no event.
334 mService->removeResource(kTestPid1, getId(mTestClient1), resources);
335 EXPECT_EQ(mTestObserver1->pop(), EventTracker::NoEvent);
336 EXPECT_EQ(mTestObserver2->pop(), EventTracker::NoEvent);
337 EXPECT_EQ(mTestObserver3->pop(), EventTracker::NoEvent);
338 // Remove client1, should have no event.
339 mService->removeClient(kTestPid1, getId(mTestClient1));
340 EXPECT_EQ(mTestObserver1->pop(), EventTracker::NoEvent);
341 EXPECT_EQ(mTestObserver2->pop(), EventTracker::NoEvent);
342 EXPECT_EQ(mTestObserver3->pop(), EventTracker::NoEvent);
343
344 // Add non-secure video codec to client2.
345 resources = {createNonSecureVideoCodecResource()};
346 mService->addResource(kTestPid2, kTestUid2, getId(mTestClient2), mTestClient2, resources);
347 EXPECT_EQ(mTestObserver1->pop(), EventTracker::NoEvent);
348 EXPECT_EQ(mTestObserver2->pop(), EventTracker::Busy(kTestUid2, kTestPid2, observables2));
349 EXPECT_EQ(mTestObserver3->pop(), EventTracker::Busy(kTestUid2, kTestPid2, observables2));
350 // Remove client2, observer 2&3 should receive updates.
351 mService->removeClient(kTestPid2, getId(mTestClient2));
352 EXPECT_EQ(mTestObserver1->pop(), EventTracker::NoEvent);
353 EXPECT_EQ(mTestObserver2->pop(), EventTracker::Idle(kTestUid2, kTestPid2, observables2));
354 EXPECT_EQ(mTestObserver3->pop(), EventTracker::Idle(kTestUid2, kTestPid2, observables2));
355 // Remove non-secure codec after client2 removed, should have no event.
356 mService->removeResource(kTestPid2, getId(mTestClient2), resources);
357 EXPECT_EQ(mTestObserver1->pop(), EventTracker::NoEvent);
358 EXPECT_EQ(mTestObserver2->pop(), EventTracker::NoEvent);
359 EXPECT_EQ(mTestObserver3->pop(), EventTracker::NoEvent);
360 // Remove client2 again, should have no event.
361 mService->removeClient(kTestPid2, getId(mTestClient2));
362 EXPECT_EQ(mTestObserver1->pop(), EventTracker::NoEvent);
363 EXPECT_EQ(mTestObserver2->pop(), EventTracker::NoEvent);
364 EXPECT_EQ(mTestObserver3->pop(), EventTracker::NoEvent);
365
366 // Add secure & non-secure video codecs, plus audio codecs (that's ignored).
367 resources = {createSecureVideoCodecResource(),
368 createNonSecureVideoCodecResource(),
369 createSecureAudioCodecResource(),
370 createNonSecureAudioCodecResource()};
371 mService->addResource(kTestPid2, kTestUid2, getId(mTestClient3), mTestClient3, resources);
372 EXPECT_EQ(mTestObserver1->pop(), EventTracker::Busy(kTestUid2, kTestPid2, observables1));
373 EXPECT_EQ(mTestObserver2->pop(), EventTracker::Busy(kTestUid2, kTestPid2, observables2));
374 EXPECT_EQ(mTestObserver3->pop(), EventTracker::Busy(kTestUid2, kTestPid2, observables3));
375 // Remove one audio codec, should have no event.
376 resources = {createSecureAudioCodecResource()};
377 mService->removeResource(kTestPid2, getId(mTestClient3), resources);
378 EXPECT_EQ(mTestObserver1->pop(), EventTracker::NoEvent);
379 EXPECT_EQ(mTestObserver2->pop(), EventTracker::NoEvent);
380 EXPECT_EQ(mTestObserver3->pop(), EventTracker::NoEvent);
381 // Remove the other audio codec and the secure video codec, only secure video codec
382 // removal should be reported.
383 resources = {createNonSecureAudioCodecResource(),
384 createSecureVideoCodecResource()};
385 mService->removeResource(kTestPid2, getId(mTestClient3), resources);
386 EXPECT_EQ(mTestObserver1->pop(), EventTracker::Idle(kTestUid2, kTestPid2, observables1));
387 EXPECT_EQ(mTestObserver2->pop(), EventTracker::NoEvent);
388 EXPECT_EQ(mTestObserver3->pop(), EventTracker::Idle(kTestUid2, kTestPid2, observables1));
389 // Remove client3 entirely. Non-secure video codec removal should be reported.
390 mService->removeClient(kTestPid2, getId(mTestClient3));
391 EXPECT_EQ(mTestObserver1->pop(), EventTracker::NoEvent);
392 EXPECT_EQ(mTestObserver2->pop(), EventTracker::Idle(kTestUid2, kTestPid2, observables2));
393 EXPECT_EQ(mTestObserver3->pop(), EventTracker::Idle(kTestUid2, kTestPid2, observables2));
394 }
395
TEST_F(ResourceObserverServiceTest,testRemoveResourceMultiple)396 TEST_F(ResourceObserverServiceTest, testRemoveResourceMultiple) {
397 registerObservers();
398
399 std::vector<MediaObservableParcel> observables1, observables2, observables3;
400 observables1 = {{MediaObservableType::kVideoSecureCodec, 1}};
401 observables2 = {{MediaObservableType::kVideoNonSecureCodec, 1}};
402 observables3 = {{MediaObservableType::kVideoSecureCodec, 1},
403 {MediaObservableType::kVideoNonSecureCodec, 1}};
404
405 std::vector<MediaResourceParcel> resources;
406
407 // Add multiple secure & non-secure video codecs, plus audio codecs (that's ignored).
408 // (ResourceManager will merge these internally.)
409 resources = {createSecureVideoCodecResource(),
410 createNonSecureVideoCodecResource(4),
411 createSecureAudioCodecResource(),
412 createNonSecureAudioCodecResource()};
413 mService->addResource(kTestPid2, kTestUid2, getId(mTestClient3), mTestClient3, resources);
414 observables1 = {{MediaObservableType::kVideoSecureCodec, 1}};
415 observables2 = {{MediaObservableType::kVideoNonSecureCodec, 4}};
416 observables3 = {{MediaObservableType::kVideoSecureCodec, 1},
417 {MediaObservableType::kVideoNonSecureCodec, 4}};
418 EXPECT_EQ(mTestObserver1->pop(), EventTracker::Busy(kTestUid2, kTestPid2, observables1));
419 EXPECT_EQ(mTestObserver2->pop(), EventTracker::Busy(kTestUid2, kTestPid2, observables2));
420 EXPECT_EQ(mTestObserver3->pop(), EventTracker::Busy(kTestUid2, kTestPid2, observables3));
421 // Remove one audio codec, 2 secure video codecs and 2 non-secure video codecs.
422 // 1 secure video codec removal and 2 non-secure video codec removals should be reported.
423 resources = {createNonSecureAudioCodecResource(),
424 createSecureVideoCodecResource(),
425 createSecureVideoCodecResource(),
426 createNonSecureVideoCodecResource(2)};
427 mService->removeResource(kTestPid2, getId(mTestClient3), resources);
428 observables1 = {{MediaObservableType::kVideoSecureCodec, 1}};
429 observables2 = {{MediaObservableType::kVideoNonSecureCodec, 2}};
430 observables3 = {{MediaObservableType::kVideoSecureCodec, 1},
431 {MediaObservableType::kVideoNonSecureCodec, 2}};
432 EXPECT_EQ(mTestObserver1->pop(), EventTracker::Idle(kTestUid2, kTestPid2, observables1));
433 EXPECT_EQ(mTestObserver2->pop(), EventTracker::Idle(kTestUid2, kTestPid2, observables2));
434 EXPECT_EQ(mTestObserver3->pop(), EventTracker::Idle(kTestUid2, kTestPid2, observables3));
435 // Remove client3 entirely. 2 non-secure video codecs removal should be reported.
436 mService->removeClient(kTestPid2, getId(mTestClient3));
437 EXPECT_EQ(mTestObserver1->pop(), EventTracker::NoEvent);
438 EXPECT_EQ(mTestObserver2->pop(), EventTracker::Idle(kTestUid2, kTestPid2, observables2));
439 EXPECT_EQ(mTestObserver3->pop(), EventTracker::Idle(kTestUid2, kTestPid2, observables2));
440 }
441
TEST_F(ResourceObserverServiceTest,testEventFilters)442 TEST_F(ResourceObserverServiceTest, testEventFilters) {
443 // Register observers with different event filters.
444 std::vector<MediaObservableFilter> filters1, filters2, filters3;
445 filters1 = {{MediaObservableType::kVideoSecureCodec, BUSY}};
446 filters2 = {{MediaObservableType::kVideoNonSecureCodec, IDLE}};
447 filters3 = {{MediaObservableType::kVideoSecureCodec, IDLE},
448 {MediaObservableType::kVideoNonSecureCodec, BUSY}};
449
450 // mTestObserver1 monitors secure video codecs.
451 EXPECT_TRUE(mObserverService->registerObserver(mTestObserver1, filters1).isOk());
452
453 // mTestObserver2 monitors non-secure video codecs.
454 EXPECT_TRUE(mObserverService->registerObserver(mTestObserver2, filters2).isOk());
455
456 // mTestObserver3 monitors both secure & non-secure video codecs.
457 EXPECT_TRUE(mObserverService->registerObserver(mTestObserver3, filters3).isOk());
458
459 std::vector<MediaObservableParcel> observables1, observables2;
460 observables1 = {{MediaObservableType::kVideoSecureCodec, 1}};
461 observables2 = {{MediaObservableType::kVideoNonSecureCodec, 1}};
462
463 std::vector<MediaResourceParcel> resources;
464
465 // Add secure & non-secure video codecs.
466 resources = {createSecureVideoCodecResource(),
467 createNonSecureVideoCodecResource()};
468 mService->addResource(kTestPid2, kTestUid2, getId(mTestClient3), mTestClient3, resources);
469 EXPECT_EQ(mTestObserver1->pop(), EventTracker::Busy(kTestUid2, kTestPid2, observables1));
470 EXPECT_EQ(mTestObserver2->pop(), EventTracker::NoEvent);
471 EXPECT_EQ(mTestObserver3->pop(), EventTracker::Busy(kTestUid2, kTestPid2, observables2));
472
473 // Remove secure & non-secure video codecs.
474 mService->removeResource(kTestPid2, getId(mTestClient3), resources);
475 EXPECT_EQ(mTestObserver1->pop(), EventTracker::NoEvent);
476 EXPECT_EQ(mTestObserver2->pop(), EventTracker::Idle(kTestUid2, kTestPid2, observables2));
477 EXPECT_EQ(mTestObserver3->pop(), EventTracker::Idle(kTestUid2, kTestPid2, observables1));
478 }
479
480 } // namespace android
481