1 /*
2 * Copyright 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 <algorithm>
18 #include <cstdint>
19 #include <cstdio>
20 #include <iterator>
21 #include <memory>
22 #include <optional>
23 #include <regex>
24
25 #include "VirtualCameraService.h"
26 #include "aidl/android/companion/virtualcamera/BnVirtualCameraCallback.h"
27 #include "aidl/android/companion/virtualcamera/VirtualCameraConfiguration.h"
28 #include "aidl/android/hardware/camera/provider/BnCameraProviderCallback.h"
29 #include "aidl/android/hardware/graphics/common/PixelFormat.h"
30 #include "android/binder_auto_utils.h"
31 #include "android/binder_interface_utils.h"
32 #include "android/binder_libbinder.h"
33 #include "android/binder_status.h"
34 #include "binder/Binder.h"
35 #include "gmock/gmock.h"
36 #include "gtest/gtest.h"
37 #include "util/MetadataUtil.h"
38 #include "util/Permissions.h"
39 #include "utils/Errors.h"
40
41 namespace android {
42 namespace companion {
43 namespace virtualcamera {
44 namespace {
45
46 using ::aidl::android::companion::virtualcamera::BnVirtualCameraCallback;
47 using ::aidl::android::companion::virtualcamera::Format;
48 using ::aidl::android::companion::virtualcamera::LensFacing;
49 using ::aidl::android::companion::virtualcamera::SensorOrientation;
50 using ::aidl::android::companion::virtualcamera::VirtualCameraConfiguration;
51 using ::aidl::android::hardware::camera::common::CameraDeviceStatus;
52 using ::aidl::android::hardware::camera::common::TorchModeStatus;
53 using ::aidl::android::hardware::camera::device::CameraMetadata;
54 using ::aidl::android::hardware::camera::provider::BnCameraProviderCallback;
55 using ::aidl::android::hardware::graphics::common::PixelFormat;
56 using ::aidl::android::view::Surface;
57 using ::testing::_;
58 using ::testing::ElementsAre;
59 using ::testing::Eq;
60 using ::testing::Ge;
61 using ::testing::IsEmpty;
62 using ::testing::IsNull;
63 using ::testing::Not;
64 using ::testing::Optional;
65 using ::testing::Return;
66 using ::testing::SizeIs;
67
68 constexpr int kVgaWidth = 640;
69 constexpr int kVgaHeight = 480;
70 constexpr int kMaxFps = 30;
71 constexpr SensorOrientation kSensorOrientation =
72 SensorOrientation::ORIENTATION_0;
73 constexpr LensFacing kLensFacing = LensFacing::FRONT;
74 constexpr int kDefaultDeviceId = 0;
75 constexpr char kCreateVirtualDevicePermissions[] =
76 "android.permission.CREATE_VIRTUAL_DEVICE";
77
78 const VirtualCameraConfiguration kEmptyVirtualCameraConfiguration;
79
80 class MockVirtualCameraCallback : public BnVirtualCameraCallback {
81 public:
82 MOCK_METHOD(ndk::ScopedAStatus, onStreamConfigured,
83 (int32_t, const ::aidl::android::view::Surface&, int, int,
84 ::aidl::android::companion::virtualcamera::Format pixelFormat),
85 (override));
86 MOCK_METHOD(ndk::ScopedAStatus, onProcessCaptureRequest, (int32_t, int32_t),
87 (override));
88 MOCK_METHOD(ndk::ScopedAStatus, onStreamClosed, (int32_t), (override));
89 };
90
createConfiguration(const int width,const int height,const Format format,const int maxFps)91 VirtualCameraConfiguration createConfiguration(const int width, const int height,
92 const Format format,
93 const int maxFps) {
94 VirtualCameraConfiguration configuration;
95 configuration.supportedStreamConfigs.push_back({.width = width,
96 .height = height,
97 .pixelFormat = format,
98 .maxFps = maxFps});
99 configuration.sensorOrientation = kSensorOrientation;
100 configuration.lensFacing = kLensFacing;
101 configuration.virtualCameraCallback =
102 ndk::SharedRefBase::make<MockVirtualCameraCallback>();
103 return configuration;
104 }
105
106 class MockCameraProviderCallback : public BnCameraProviderCallback {
107 public:
108 MOCK_METHOD(ndk::ScopedAStatus, cameraDeviceStatusChange,
109 (const std::string&, CameraDeviceStatus), (override));
110 MOCK_METHOD(ndk::ScopedAStatus, torchModeStatusChange,
111 (const std::string&, TorchModeStatus), (override));
112 MOCK_METHOD(ndk::ScopedAStatus, physicalCameraDeviceStatusChange,
113 (const std::string&, const std::string&, CameraDeviceStatus),
114 (override));
115 };
116
117 class MockPermissionsProxy : public PermissionsProxy {
118 public:
119 MOCK_METHOD(bool, checkCallingPermission, (const std::string&),
120 (const override));
121 };
122
123 class VirtualCameraServiceTest : public ::testing::Test {
124 public:
SetUp()125 void SetUp() override {
126 mCameraProvider = ndk::SharedRefBase::make<VirtualCameraProvider>();
127 mMockCameraProviderCallback =
128 ndk::SharedRefBase::make<MockCameraProviderCallback>();
129 ON_CALL(*mMockCameraProviderCallback, cameraDeviceStatusChange)
130 .WillByDefault([](const std::string&, CameraDeviceStatus) {
131 return ndk::ScopedAStatus::ok();
132 });
133 mCameraProvider->setCallback(mMockCameraProviderCallback);
134 mCameraService = ndk::SharedRefBase::make<VirtualCameraService>(
135 mCameraProvider, mMockPermissionsProxy);
136 mCameraService->disableEglVerificationForTest();
137
138 ON_CALL(mMockPermissionsProxy, checkCallingPermission)
139 .WillByDefault(Return(true));
140
141 mDevNullFd = open("/dev/null", O_RDWR);
142 ASSERT_THAT(mDevNullFd, Ge(0));
143 }
144
createCamera()145 void createCamera() {
146 mOwnerToken = sp<BBinder>::make();
147 mNdkOwnerToken.set(AIBinder_fromPlatformBinder(mOwnerToken));
148 bool aidlRet;
149
150 ASSERT_TRUE(mCameraService
151 ->registerCamera(mNdkOwnerToken, mVgaYUV420OnlyConfiguration,
152 kDefaultDeviceId, &aidlRet)
153 .isOk());
154 ASSERT_TRUE(aidlRet);
155 }
156
TearDown()157 void TearDown() override {
158 close(mDevNullFd);
159 }
160
execute_shell_command(const std::string & cmd)161 binder_status_t execute_shell_command(const std::string& cmd) {
162 const static std::regex whitespaceRegex("\\s+");
163 std::vector<std::string> tokens;
164 std::copy_if(
165 std::sregex_token_iterator(cmd.begin(), cmd.end(), whitespaceRegex, -1),
166 std::sregex_token_iterator(), std::back_inserter(tokens),
167 [](const std::string& token) { return !token.empty(); });
168
169 std::vector<const char*> argv;
170 argv.reserve(tokens.size());
171 std::transform(tokens.begin(), tokens.end(), std::back_inserter(argv),
172 [](const std::string& str) { return str.c_str(); });
173
174 return mCameraService->handleShellCommand(
175 mDevNullFd, mDevNullFd, mDevNullFd, argv.data(), argv.size());
176 }
177
getCameraIds()178 std::vector<std::string> getCameraIds() {
179 std::vector<std::string> cameraIds;
180 EXPECT_TRUE(mCameraProvider->getCameraIdList(&cameraIds).isOk());
181 return cameraIds;
182 }
183
getCameraLensFacing(const std::string & id)184 std::optional<camera_metadata_enum_android_lens_facing> getCameraLensFacing(
185 const std::string& id) {
186 std::shared_ptr<VirtualCameraDevice> camera = mCameraProvider->getCamera(id);
187 if (camera == nullptr) {
188 return std::nullopt;
189 }
190 CameraMetadata metadata;
191 camera->getCameraCharacteristics(&metadata);
192 return getLensFacing(metadata);
193 }
194
getCameraSensorOrienation(const std::string & id)195 std::optional<int32_t> getCameraSensorOrienation(const std::string& id) {
196 std::shared_ptr<VirtualCameraDevice> camera = mCameraProvider->getCamera(id);
197 if (camera == nullptr) {
198 return std::nullopt;
199 }
200 CameraMetadata metadata;
201 camera->getCameraCharacteristics(&metadata);
202 return getSensorOrientation(metadata);
203 }
204
205 protected:
206 std::shared_ptr<VirtualCameraService> mCameraService;
207 std::shared_ptr<VirtualCameraProvider> mCameraProvider;
208 std::shared_ptr<MockCameraProviderCallback> mMockCameraProviderCallback =
209 ndk::SharedRefBase::make<MockCameraProviderCallback>();
210 MockPermissionsProxy mMockPermissionsProxy;
211
212 sp<BBinder> mOwnerToken;
213 ndk::SpAIBinder mNdkOwnerToken;
214
215 int mDevNullFd;
216
217 VirtualCameraConfiguration mVgaYUV420OnlyConfiguration =
218 createConfiguration(kVgaWidth, kVgaHeight, Format::YUV_420_888, kMaxFps);
219 };
220
TEST_F(VirtualCameraServiceTest,RegisterCameraWithYuvInputSucceeds)221 TEST_F(VirtualCameraServiceTest, RegisterCameraWithYuvInputSucceeds) {
222 sp<BBinder> token = sp<BBinder>::make();
223 ndk::SpAIBinder ndkToken(AIBinder_fromPlatformBinder(token));
224 bool aidlRet;
225
226 ASSERT_TRUE(mCameraService
227 ->registerCamera(ndkToken, mVgaYUV420OnlyConfiguration,
228 kDefaultDeviceId, &aidlRet)
229 .isOk());
230
231 EXPECT_TRUE(aidlRet);
232 EXPECT_THAT(getCameraIds(), SizeIs(1));
233 }
234
TEST_F(VirtualCameraServiceTest,RegisterCameraWithRgbaInputSucceeds)235 TEST_F(VirtualCameraServiceTest, RegisterCameraWithRgbaInputSucceeds) {
236 sp<BBinder> token = sp<BBinder>::make();
237 ndk::SpAIBinder ndkToken(AIBinder_fromPlatformBinder(token));
238 bool aidlRet;
239
240 VirtualCameraConfiguration config =
241 createConfiguration(kVgaWidth, kVgaHeight, Format::RGBA_8888, kMaxFps);
242
243 ASSERT_TRUE(mCameraService
244 ->registerCamera(ndkToken, config, kDefaultDeviceId, &aidlRet)
245 .isOk());
246
247 EXPECT_TRUE(aidlRet);
248 EXPECT_THAT(getCameraIds(), SizeIs(1));
249 }
250
TEST_F(VirtualCameraServiceTest,RegisterCameraTwiceSecondReturnsFalse)251 TEST_F(VirtualCameraServiceTest, RegisterCameraTwiceSecondReturnsFalse) {
252 createCamera();
253 bool aidlRet;
254
255 ASSERT_TRUE(mCameraService
256 ->registerCamera(mNdkOwnerToken, mVgaYUV420OnlyConfiguration,
257 kDefaultDeviceId, &aidlRet)
258 .isOk());
259 EXPECT_FALSE(aidlRet);
260 EXPECT_THAT(getCameraIds(), SizeIs(1));
261 }
262
TEST_F(VirtualCameraServiceTest,EmptyConfigurationFails)263 TEST_F(VirtualCameraServiceTest, EmptyConfigurationFails) {
264 bool aidlRet;
265
266 ASSERT_FALSE(mCameraService
267 ->registerCamera(mNdkOwnerToken,
268 kEmptyVirtualCameraConfiguration,
269 kDefaultDeviceId, &aidlRet)
270 .isOk());
271 EXPECT_FALSE(aidlRet);
272 EXPECT_THAT(getCameraIds(), IsEmpty());
273 }
274
TEST_F(VirtualCameraServiceTest,ConfigurationWithoutVirtualCameraCallbackFails)275 TEST_F(VirtualCameraServiceTest,
276 ConfigurationWithoutVirtualCameraCallbackFails) {
277 sp<BBinder> token = sp<BBinder>::make();
278 ndk::SpAIBinder ndkToken(AIBinder_fromPlatformBinder(token));
279 bool aidlRet;
280
281 VirtualCameraConfiguration config =
282 createConfiguration(kVgaWidth, kVgaHeight, Format::RGBA_8888, kMaxFps);
283 config.virtualCameraCallback = nullptr;
284
285 ASSERT_FALSE(mCameraService
286 ->registerCamera(ndkToken, config, kDefaultDeviceId, &aidlRet)
287 .isOk());
288
289 EXPECT_FALSE(aidlRet);
290 EXPECT_THAT(getCameraIds(), IsEmpty());
291 }
292
TEST_F(VirtualCameraServiceTest,ConfigurationWithUnsupportedPixelFormatFails)293 TEST_F(VirtualCameraServiceTest, ConfigurationWithUnsupportedPixelFormatFails) {
294 bool aidlRet;
295
296 VirtualCameraConfiguration config =
297 createConfiguration(kVgaWidth, kVgaHeight, Format::UNKNOWN, kMaxFps);
298
299 ASSERT_FALSE(
300 mCameraService
301 ->registerCamera(mNdkOwnerToken, config, kDefaultDeviceId, &aidlRet)
302 .isOk());
303 EXPECT_FALSE(aidlRet);
304 EXPECT_THAT(getCameraIds(), IsEmpty());
305 }
306
TEST_F(VirtualCameraServiceTest,ConfigurationWithTooHighResFails)307 TEST_F(VirtualCameraServiceTest, ConfigurationWithTooHighResFails) {
308 bool aidlRet;
309 VirtualCameraConfiguration config =
310 createConfiguration(1000000, 1000000, Format::YUV_420_888, kMaxFps);
311
312 ASSERT_FALSE(
313 mCameraService
314 ->registerCamera(mNdkOwnerToken, config, kDefaultDeviceId, &aidlRet)
315 .isOk());
316 EXPECT_FALSE(aidlRet);
317 EXPECT_THAT(getCameraIds(), IsEmpty());
318 }
319
TEST_F(VirtualCameraServiceTest,ConfigurationWithNegativeResolutionFails)320 TEST_F(VirtualCameraServiceTest, ConfigurationWithNegativeResolutionFails) {
321 bool aidlRet;
322 VirtualCameraConfiguration config =
323 createConfiguration(-1, kVgaHeight, Format::YUV_420_888, kMaxFps);
324
325 ASSERT_FALSE(
326 mCameraService
327 ->registerCamera(mNdkOwnerToken, config, kDefaultDeviceId, &aidlRet)
328 .isOk());
329 EXPECT_FALSE(aidlRet);
330 EXPECT_THAT(getCameraIds(), IsEmpty());
331 }
332
TEST_F(VirtualCameraServiceTest,ConfigurationWithTooLowMaxFpsFails)333 TEST_F(VirtualCameraServiceTest, ConfigurationWithTooLowMaxFpsFails) {
334 bool aidlRet;
335 VirtualCameraConfiguration config =
336 createConfiguration(kVgaWidth, kVgaHeight, Format::YUV_420_888, 0);
337
338 ASSERT_FALSE(
339 mCameraService
340 ->registerCamera(mNdkOwnerToken, config, kDefaultDeviceId, &aidlRet)
341 .isOk());
342 EXPECT_FALSE(aidlRet);
343 EXPECT_THAT(getCameraIds(), IsEmpty());
344 }
345
TEST_F(VirtualCameraServiceTest,ConfigurationWithTooHighMaxFpsFails)346 TEST_F(VirtualCameraServiceTest, ConfigurationWithTooHighMaxFpsFails) {
347 bool aidlRet;
348 VirtualCameraConfiguration config =
349 createConfiguration(kVgaWidth, kVgaHeight, Format::YUV_420_888, 90);
350
351 ASSERT_FALSE(
352 mCameraService
353 ->registerCamera(mNdkOwnerToken, config, kDefaultDeviceId, &aidlRet)
354 .isOk());
355 EXPECT_FALSE(aidlRet);
356 EXPECT_THAT(getCameraIds(), IsEmpty());
357 }
358
TEST_F(VirtualCameraServiceTest,GetCamera)359 TEST_F(VirtualCameraServiceTest, GetCamera) {
360 createCamera();
361
362 EXPECT_THAT(mCameraService->getCamera(mNdkOwnerToken), Not(IsNull()));
363
364 sp<BBinder> otherToken = sp<BBinder>::make();
365 EXPECT_THAT(mCameraService->getCamera(
366 ndk::SpAIBinder(AIBinder_fromPlatformBinder(otherToken))),
367 IsNull());
368 }
369
TEST_F(VirtualCameraServiceTest,UnregisterCamera)370 TEST_F(VirtualCameraServiceTest, UnregisterCamera) {
371 createCamera();
372
373 EXPECT_THAT(mCameraService->getCamera(mNdkOwnerToken), Not(IsNull()));
374
375 mCameraService->unregisterCamera(mNdkOwnerToken);
376
377 EXPECT_THAT(mCameraService->getCamera(mNdkOwnerToken), IsNull());
378 }
379
TEST_F(VirtualCameraServiceTest,RegisterCameraWithoutPermissionFails)380 TEST_F(VirtualCameraServiceTest, RegisterCameraWithoutPermissionFails) {
381 bool aidlRet;
382 EXPECT_CALL(mMockPermissionsProxy,
383 checkCallingPermission(kCreateVirtualDevicePermissions))
384 .WillOnce(Return(false));
385
386 EXPECT_THAT(mCameraService
387 ->registerCamera(mNdkOwnerToken, mVgaYUV420OnlyConfiguration,
388 kDefaultDeviceId, &aidlRet)
389 .getExceptionCode(),
390 Eq(EX_SECURITY));
391 }
392
TEST_F(VirtualCameraServiceTest,UnregisterCameraWithoutPermissionFails)393 TEST_F(VirtualCameraServiceTest, UnregisterCameraWithoutPermissionFails) {
394 EXPECT_CALL(mMockPermissionsProxy,
395 checkCallingPermission(kCreateVirtualDevicePermissions))
396 .WillOnce(Return(false));
397
398 EXPECT_THAT(
399 mCameraService->unregisterCamera(mNdkOwnerToken).getExceptionCode(),
400 Eq(EX_SECURITY));
401 }
402
TEST_F(VirtualCameraServiceTest,GetIdWithoutPermissionFails)403 TEST_F(VirtualCameraServiceTest, GetIdWithoutPermissionFails) {
404 std::string aidlRet;
405 EXPECT_CALL(mMockPermissionsProxy,
406 checkCallingPermission(kCreateVirtualDevicePermissions))
407 .WillOnce(Return(false));
408
409 EXPECT_THAT(
410 mCameraService->getCameraId(mNdkOwnerToken, &aidlRet).getExceptionCode(),
411 Eq(EX_SECURITY));
412 }
413
TEST_F(VirtualCameraServiceTest,UnregisterCameraWithUnknownToken)414 TEST_F(VirtualCameraServiceTest, UnregisterCameraWithUnknownToken) {
415 createCamera();
416
417 EXPECT_THAT(mCameraService->getCamera(mNdkOwnerToken), Not(IsNull()));
418
419 auto otherToken = sp<BBinder>::make();
420 ndk::SpAIBinder ndkOtherToken(AIBinder_fromPlatformBinder(otherToken));
421 mCameraService->unregisterCamera(ndkOtherToken);
422
423 EXPECT_THAT(mCameraService->getCamera(mNdkOwnerToken), Not(IsNull()));
424 }
425
TEST_F(VirtualCameraServiceTest,ShellCmdWithNullArgs)426 TEST_F(VirtualCameraServiceTest, ShellCmdWithNullArgs) {
427 EXPECT_EQ(mCameraService->handleShellCommand(
428 /*in=*/mDevNullFd, /*out=*/mDevNullFd, /*err=*/mDevNullFd,
429 /*args=*/nullptr, /*numArgs=*/1),
430 STATUS_BAD_VALUE);
431
432 std::array<const char*, 1> args{nullptr};
433 EXPECT_EQ(mCameraService->handleShellCommand(
434 /*in=*/mDevNullFd, /*out=*/mDevNullFd, /*err=*/mDevNullFd,
435 args.data(), /*numArgs=*/1),
436 STATUS_BAD_VALUE);
437 }
438
TEST_F(VirtualCameraServiceTest,ShellCmdWithNoArgs)439 TEST_F(VirtualCameraServiceTest, ShellCmdWithNoArgs) {
440 EXPECT_EQ(mCameraService->handleShellCommand(
441 /*in=*/mDevNullFd, /*out=*/mDevNullFd, /*err=*/mDevNullFd,
442 /*args=*/nullptr, /*numArgs=*/0),
443 STATUS_OK);
444 }
445
TEST_F(VirtualCameraServiceTest,TestCameraShellCmd)446 TEST_F(VirtualCameraServiceTest, TestCameraShellCmd) {
447 EXPECT_THAT(execute_shell_command("enable_test_camera"), Eq(NO_ERROR));
448
449 std::vector<std::string> cameraIdsAfterEnable = getCameraIds();
450 EXPECT_THAT(cameraIdsAfterEnable, SizeIs(1));
451
452 EXPECT_THAT(execute_shell_command("disable_test_camera"), Eq(NO_ERROR));
453
454 std::vector<std::string> cameraIdsAfterDisable = getCameraIds();
455 EXPECT_THAT(cameraIdsAfterDisable, IsEmpty());
456 }
457
TEST_F(VirtualCameraServiceTest,TestCameraShellCmdWithId)458 TEST_F(VirtualCameraServiceTest, TestCameraShellCmdWithId) {
459 EXPECT_THAT(
460 execute_shell_command("enable_test_camera --camera_id=hello12345"),
461 Eq(NO_ERROR));
462
463 std::vector<std::string> cameraIdsAfterEnable = getCameraIds();
464 EXPECT_THAT(cameraIdsAfterEnable,
465 ElementsAre("[email protected]/virtual/hello12345"));
466
467 EXPECT_THAT(execute_shell_command("disable_test_camera"), Eq(NO_ERROR));
468
469 std::vector<std::string> cameraIdsAfterDisable = getCameraIds();
470 EXPECT_THAT(cameraIdsAfterDisable, IsEmpty());
471 }
472
TEST_F(VirtualCameraServiceTest,TestCameraShellCmdWithInvalidId)473 TEST_F(VirtualCameraServiceTest, TestCameraShellCmdWithInvalidId) {
474 EXPECT_THAT(execute_shell_command("enable_test_camera --camera_id="),
475 Eq(STATUS_BAD_VALUE));
476 }
477
TEST_F(VirtualCameraServiceTest,TestCameraShellCmdWithUnknownCommand)478 TEST_F(VirtualCameraServiceTest, TestCameraShellCmdWithUnknownCommand) {
479 EXPECT_THAT(execute_shell_command("brew_coffee --flavor=vanilla"),
480 Eq(STATUS_BAD_VALUE));
481 }
482
TEST_F(VirtualCameraServiceTest,TestCameraShellCmdWithMalformedOption)483 TEST_F(VirtualCameraServiceTest, TestCameraShellCmdWithMalformedOption) {
484 EXPECT_THAT(execute_shell_command("enable_test_camera **camera_id=12345"),
485 Eq(STATUS_BAD_VALUE));
486 }
487
TEST_F(VirtualCameraServiceTest,TestCameraShellCmdWithLensFacing)488 TEST_F(VirtualCameraServiceTest, TestCameraShellCmdWithLensFacing) {
489 EXPECT_THAT(execute_shell_command("enable_test_camera --lens_facing=front"),
490 Eq(NO_ERROR));
491
492 std::vector<std::string> cameraIds = getCameraIds();
493 ASSERT_THAT(cameraIds, SizeIs(1));
494 EXPECT_THAT(getCameraLensFacing(cameraIds[0]),
495 Optional(Eq(ANDROID_LENS_FACING_FRONT)));
496 }
497
TEST_F(VirtualCameraServiceTest,TestCameraShellCmdWithInvalidLensFacing)498 TEST_F(VirtualCameraServiceTest, TestCameraShellCmdWithInvalidLensFacing) {
499 EXPECT_THAT(execute_shell_command("enable_test_camera --lens_facing=west"),
500 Eq(STATUS_BAD_VALUE));
501 }
502
TEST_F(VirtualCameraServiceTest,TestCameraShellCmdWithInputFps)503 TEST_F(VirtualCameraServiceTest, TestCameraShellCmdWithInputFps) {
504 EXPECT_THAT(execute_shell_command("enable_test_camera --input_fps=15"),
505 Eq(NO_ERROR));
506
507 std::vector<std::string> cameraIds = getCameraIds();
508 ASSERT_THAT(cameraIds, SizeIs(1));
509 }
510
TEST_F(VirtualCameraServiceTest,TestCameraShellCmdWithInvalidInputFps)511 TEST_F(VirtualCameraServiceTest, TestCameraShellCmdWithInvalidInputFps) {
512 EXPECT_THAT(execute_shell_command("enable_test_camera --input_fps=1001"),
513 Eq(STATUS_BAD_VALUE));
514 EXPECT_THAT(execute_shell_command("enable_test_camera --input_fps=0"),
515 Eq(STATUS_BAD_VALUE));
516 EXPECT_THAT(execute_shell_command("enable_test_camera --input_fps=foo"),
517 Eq(STATUS_BAD_VALUE));
518 }
519
TEST_F(VirtualCameraServiceTest,TestCameraShellCmdWithSensorOrientation90)520 TEST_F(VirtualCameraServiceTest, TestCameraShellCmdWithSensorOrientation90) {
521 EXPECT_THAT(
522 execute_shell_command("enable_test_camera --sensor_orientation=90"),
523 Eq(NO_ERROR));
524
525 std::vector<std::string> cameraIds = getCameraIds();
526 ASSERT_THAT(cameraIds, SizeIs(1));
527 EXPECT_THAT(getCameraSensorOrienation(cameraIds[0]), Optional(Eq(90)));
528 }
529
TEST_F(VirtualCameraServiceTest,TestCameraShellCmdWithSensorOrientationNoArgs)530 TEST_F(VirtualCameraServiceTest, TestCameraShellCmdWithSensorOrientationNoArgs) {
531 EXPECT_THAT(execute_shell_command("enable_test_camera"), Eq(NO_ERROR));
532
533 std::vector<std::string> cameraIds = getCameraIds();
534 ASSERT_THAT(cameraIds, SizeIs(1));
535 EXPECT_THAT(getCameraSensorOrienation(cameraIds[0]), Optional(Eq(0)));
536 }
537
538 } // namespace
539 } // namespace virtualcamera
540 } // namespace companion
541 } // namespace android
542