Move virtual camera service to frameworks/av/services
Bug: 311647154
Bug: 301023410
Test: atest virtual_camera_tests
Test: build & flash & adb shell cmd virtual_camera help
Change-Id: I6d43a2b70f454c9c01ec2abcae9f138cd78c6a85
diff --git a/services/camera/virtualcamera/tests/Android.bp b/services/camera/virtualcamera/tests/Android.bp
new file mode 100644
index 0000000..c30779c
--- /dev/null
+++ b/services/camera/virtualcamera/tests/Android.bp
@@ -0,0 +1,23 @@
+package {
+ // See: http://go/android-license-faq
+ default_applicable_licenses: ["Android-Apache-2.0"],
+}
+
+cc_test {
+ name: "virtual_camera_tests",
+ defaults: [
+ "libvirtualcamera_defaults",
+ ],
+ static_libs: [
+ "libvirtualcamera",
+ "libvirtualcamera_utils",
+ "libgtest",
+ "libgmock",
+ ],
+ srcs: ["EglUtilTest.cc",
+ "VirtualCameraProviderTest.cc",
+ "VirtualCameraRenderThreadTest.cc",
+ "VirtualCameraServiceTest.cc",
+ "VirtualCameraSessionTest.cc"],
+ test_suites: ["device-tests"],
+}
diff --git a/services/camera/virtualcamera/tests/EglUtilTest.cc b/services/camera/virtualcamera/tests/EglUtilTest.cc
new file mode 100644
index 0000000..86fc50c
--- /dev/null
+++ b/services/camera/virtualcamera/tests/EglUtilTest.cc
@@ -0,0 +1,68 @@
+/*
+ * Copyright (C) 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "gtest/gtest.h"
+#include "util/EglDisplayContext.h"
+#include "util/EglProgram.h"
+#include "util/EglUtil.h"
+
+namespace android {
+namespace companion {
+namespace virtualcamera {
+namespace {
+
+constexpr char kGlExtYuvTarget[] = "GL_EXT_YUV_target";
+
+TEST(EglDisplayContextTest, SuccessfulInitialization) {
+ EglDisplayContext displayContext;
+
+ EXPECT_TRUE(displayContext.isInitialized());
+}
+
+class EglProgramTest : public ::testing::Test {
+ public:
+ void SetUp() override {
+ ASSERT_TRUE(mEglDisplayContext.isInitialized());
+ ASSERT_TRUE(mEglDisplayContext.makeCurrent());
+ }
+
+ private:
+ EglDisplayContext mEglDisplayContext;
+};
+
+TEST_F(EglProgramTest, EglTestPatternProgramSuccessfulInit) {
+ EglTestPatternProgram eglTestPatternProgram;
+
+ // Verify the shaders compiled and linked successfully.
+ EXPECT_TRUE(eglTestPatternProgram.isInitialized());
+}
+
+TEST_F(EglProgramTest, EglTextureProgramSuccessfulInit) {
+ if (!isGlExtensionSupported(kGlExtYuvTarget)) {
+ GTEST_SKIP() << "Skipping test because of missing required GL extension "
+ << kGlExtYuvTarget;
+ }
+
+ EglTextureProgram eglTextureProgram;
+
+ // Verify the shaders compiled and linked successfully.
+ EXPECT_TRUE(eglTextureProgram.isInitialized());
+}
+
+} // namespace
+} // namespace virtualcamera
+} // namespace companion
+} // namespace android
diff --git a/services/camera/virtualcamera/tests/VirtualCameraProviderTest.cc b/services/camera/virtualcamera/tests/VirtualCameraProviderTest.cc
new file mode 100644
index 0000000..03fc2c2
--- /dev/null
+++ b/services/camera/virtualcamera/tests/VirtualCameraProviderTest.cc
@@ -0,0 +1,162 @@
+/*
+ * Copyright (C) 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <memory>
+
+#include "VirtualCameraProvider.h"
+#include "aidl/android/hardware/camera/common/CameraDeviceStatus.h"
+#include "aidl/android/hardware/camera/common/Status.h"
+#include "aidl/android/hardware/camera/common/TorchModeStatus.h"
+#include "aidl/android/hardware/camera/provider/BnCameraProviderCallback.h"
+#include "android/binder_auto_utils.h"
+#include "android/binder_interface_utils.h"
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+#include "util/Util.h"
+
+namespace android {
+namespace companion {
+namespace virtualcamera {
+namespace {
+
+using ::aidl::android::hardware::camera::common::CameraDeviceStatus;
+using ::aidl::android::hardware::camera::common::Status;
+using ::aidl::android::hardware::camera::common::TorchModeStatus;
+using ::aidl::android::hardware::camera::provider::BnCameraProviderCallback;
+using ::testing::_;
+using ::testing::ElementsAre;
+using ::testing::Eq;
+using ::testing::IsEmpty;
+using ::testing::IsNull;
+using ::testing::MatchesRegex;
+using ::testing::Not;
+using ::testing::Return;
+
+constexpr char kVirtualCameraNameRegex[] =
+ "device@[0-9]+\\.[0-9]+/virtual/[0-9]+";
+
+class MockCameraProviderCallback : public BnCameraProviderCallback {
+ public:
+ MOCK_METHOD(ndk::ScopedAStatus, cameraDeviceStatusChange,
+ (const std::string&, CameraDeviceStatus), (override));
+ MOCK_METHOD(ndk::ScopedAStatus, torchModeStatusChange,
+ (const std::string&, TorchModeStatus), (override));
+ MOCK_METHOD(ndk::ScopedAStatus, physicalCameraDeviceStatusChange,
+ (const std::string&, const std::string&, CameraDeviceStatus),
+ (override));
+};
+
+class VirtualCameraProviderTest : public ::testing::Test {
+ public:
+ void SetUp() override {
+ mCameraProvider = ndk::SharedRefBase::make<VirtualCameraProvider>();
+ mMockCameraProviderCallback =
+ ndk::SharedRefBase::make<MockCameraProviderCallback>();
+ ON_CALL(*mMockCameraProviderCallback, cameraDeviceStatusChange)
+ .WillByDefault([](const std::string&, CameraDeviceStatus) {
+ return ndk::ScopedAStatus::ok();
+ });
+ }
+
+ protected:
+ std::shared_ptr<VirtualCameraProvider> mCameraProvider;
+ std::shared_ptr<MockCameraProviderCallback> mMockCameraProviderCallback =
+ ndk::SharedRefBase::make<MockCameraProviderCallback>();
+};
+
+TEST_F(VirtualCameraProviderTest, SetNullCameraCallbackFails) {
+ // Attempting to set callback to nullptr should fail.
+ EXPECT_FALSE(mCameraProvider->setCallback(nullptr).isOk());
+}
+
+TEST_F(VirtualCameraProviderTest, NoCamerasInitially) {
+ std::vector<std::string> cameras;
+
+ // Initially, the camera provider should return empty list
+ // of cameras.
+ ASSERT_TRUE(mCameraProvider->getCameraIdList(&cameras).isOk());
+ EXPECT_THAT(cameras, IsEmpty());
+}
+
+TEST_F(VirtualCameraProviderTest, CreateCamera) {
+ // When new camera is created, we expect
+ // cameraDeviceStatusChange to be called exactly once with
+ // PRESENT status.
+ EXPECT_CALL(*mMockCameraProviderCallback,
+ cameraDeviceStatusChange(_, CameraDeviceStatus::PRESENT))
+ .WillOnce(Return(ndk::ScopedAStatus::ok()));
+
+ ASSERT_TRUE(mCameraProvider->setCallback(mMockCameraProviderCallback).isOk());
+ std::shared_ptr<VirtualCameraDevice> camera = mCameraProvider->createCamera();
+ EXPECT_THAT(camera, Not(IsNull()));
+ EXPECT_THAT(camera->getCameraName(), MatchesRegex(kVirtualCameraNameRegex));
+
+ // Created camera should be in the list of cameras.
+ std::vector<std::string> cameraIds;
+ ASSERT_TRUE(mCameraProvider->getCameraIdList(&cameraIds).isOk());
+ EXPECT_THAT(cameraIds, ElementsAre(camera->getCameraName()));
+}
+
+TEST_F(VirtualCameraProviderTest, CreateCameraBeforeCallbackIsSet) {
+ // We expect cameraDeviceStatusChange to be invoked even when the
+ // setCallback configures the callback after camera is already created.
+ EXPECT_CALL(*mMockCameraProviderCallback,
+ cameraDeviceStatusChange(_, CameraDeviceStatus::PRESENT))
+ .WillOnce(Return(ndk::ScopedAStatus::ok()));
+
+ std::shared_ptr<VirtualCameraDevice> camera = mCameraProvider->createCamera();
+ ASSERT_TRUE(mCameraProvider->setCallback(mMockCameraProviderCallback).isOk());
+
+ // Created camera should be in the list of cameras.
+ std::vector<std::string> cameraIds;
+ EXPECT_TRUE(mCameraProvider->getCameraIdList(&cameraIds).isOk());
+ EXPECT_THAT(cameraIds, ElementsAre(camera->getCameraName()));
+}
+
+TEST_F(VirtualCameraProviderTest, RemoveCamera) {
+ ASSERT_TRUE(mCameraProvider->setCallback(mMockCameraProviderCallback).isOk());
+ std::shared_ptr<VirtualCameraDevice> camera = mCameraProvider->createCamera();
+
+ EXPECT_CALL(*mMockCameraProviderCallback,
+ cameraDeviceStatusChange(Eq(camera->getCameraName()),
+ CameraDeviceStatus::NOT_PRESENT))
+ .WillOnce(Return(ndk::ScopedAStatus::ok()));
+ EXPECT_TRUE(mCameraProvider->removeCamera(camera->getCameraName()));
+
+ // There are no cameras present after only camera is removed.
+ std::vector<std::string> cameraIds;
+ ASSERT_TRUE(mCameraProvider->getCameraIdList(&cameraIds).isOk());
+ EXPECT_THAT(cameraIds, IsEmpty());
+}
+
+TEST_F(VirtualCameraProviderTest, RemoveNonExistingCamera) {
+ ASSERT_TRUE(mCameraProvider->setCallback(mMockCameraProviderCallback).isOk());
+ std::shared_ptr<VirtualCameraDevice> camera = mCameraProvider->createCamera();
+
+ // Removing non-existing camera should fail.
+ const std::string cameraName = "DefinitelyNoTCamera";
+ EXPECT_FALSE(mCameraProvider->removeCamera(cameraName));
+
+ // Camera should be still present in the camera list.
+ std::vector<std::string> cameraIds;
+ ASSERT_TRUE(mCameraProvider->getCameraIdList(&cameraIds).isOk());
+ EXPECT_THAT(cameraIds, ElementsAre(camera->getCameraName()));
+}
+
+} // namespace
+} // namespace virtualcamera
+} // namespace companion
+} // namespace android
diff --git a/services/camera/virtualcamera/tests/VirtualCameraRenderThreadTest.cc b/services/camera/virtualcamera/tests/VirtualCameraRenderThreadTest.cc
new file mode 100644
index 0000000..2e40d16
--- /dev/null
+++ b/services/camera/virtualcamera/tests/VirtualCameraRenderThreadTest.cc
@@ -0,0 +1,146 @@
+/*
+ * Copyright (C) 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <sys/cdefs.h>
+
+#include <memory>
+
+#include "VirtualCameraRenderThread.h"
+#include "VirtualCameraSessionContext.h"
+#include "aidl/android/hardware/camera/common/CameraDeviceStatus.h"
+#include "aidl/android/hardware/camera/common/TorchModeStatus.h"
+#include "aidl/android/hardware/camera/device/BnCameraDeviceCallback.h"
+#include "aidl/android/hardware/camera/device/BufferRequest.h"
+#include "aidl/android/hardware/camera/device/BufferRequestStatus.h"
+#include "aidl/android/hardware/camera/device/BufferStatus.h"
+#include "aidl/android/hardware/camera/device/CaptureResult.h"
+#include "aidl/android/hardware/camera/device/NotifyMsg.h"
+#include "aidl/android/hardware/camera/device/StreamBuffer.h"
+#include "aidl/android/hardware/camera/device/StreamBufferRet.h"
+#include "android/binder_auto_utils.h"
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+
+namespace android {
+namespace companion {
+namespace virtualcamera {
+namespace {
+
+using ::aidl::android::hardware::camera::common::CameraDeviceStatus;
+using ::aidl::android::hardware::camera::common::TorchModeStatus;
+using ::aidl::android::hardware::camera::device::BnCameraDeviceCallback;
+using ::aidl::android::hardware::camera::device::BufferRequest;
+using ::aidl::android::hardware::camera::device::BufferRequestStatus;
+using ::aidl::android::hardware::camera::device::BufferStatus;
+using ::aidl::android::hardware::camera::device::CaptureResult;
+using ::aidl::android::hardware::camera::device::ErrorMsg;
+using ::aidl::android::hardware::camera::device::NotifyMsg;
+using ::aidl::android::hardware::camera::device::StreamBuffer;
+using ::aidl::android::hardware::camera::device::StreamBufferRet;
+using ::testing::AllOf;
+using ::testing::ElementsAre;
+using ::testing::Eq;
+using ::testing::Field;
+using ::testing::Matcher;
+using ::testing::Property;
+using ::testing::Return;
+using ::testing::SizeIs;
+
+constexpr int kInputWidth = 640;
+constexpr int kInputHeight = 480;
+
+Matcher<StreamBuffer> IsStreamBufferWithStatus(const int streamId,
+ const int bufferId,
+ const BufferStatus status) {
+ return AllOf(Field(&StreamBuffer::streamId, Eq(streamId)),
+ Field(&StreamBuffer::bufferId, Eq(bufferId)),
+ Field(&StreamBuffer::status, Eq(status)));
+}
+
+Matcher<NotifyMsg> IsRequestErrorNotifyMsg(const int frameId) {
+ return AllOf(Property(&NotifyMsg::getTag, Eq(NotifyMsg::error)),
+ Property(&NotifyMsg::get<NotifyMsg::error>,
+ Field(&ErrorMsg::frameNumber, Eq(frameId))));
+}
+
+class MockCameraDeviceCallback : public BnCameraDeviceCallback {
+ public:
+ MOCK_METHOD(ndk::ScopedAStatus, notify, (const std::vector<NotifyMsg>&),
+ (override));
+ MOCK_METHOD(ndk::ScopedAStatus, processCaptureResult,
+ (const std::vector<CaptureResult>&), (override));
+ MOCK_METHOD(ndk::ScopedAStatus, requestStreamBuffers,
+ (const std::vector<BufferRequest>&, std::vector<StreamBufferRet>*,
+ BufferRequestStatus*),
+ (override));
+ MOCK_METHOD(ndk::ScopedAStatus, returnStreamBuffers,
+ (const std::vector<StreamBuffer>&), (override));
+};
+
+class VirtualCameraRenderThreadTest : public ::testing::Test {
+ public:
+ void SetUp() override {
+ mSessionContext = std::make_unique<VirtualCameraSessionContext>();
+ mMockCameraDeviceCallback =
+ ndk::SharedRefBase::make<MockCameraDeviceCallback>();
+ mRenderThread = std::make_unique<VirtualCameraRenderThread>(
+ *mSessionContext, kInputWidth, kInputHeight, mMockCameraDeviceCallback);
+ }
+
+ protected:
+ std::unique_ptr<VirtualCameraSessionContext> mSessionContext;
+ std::unique_ptr<VirtualCameraRenderThread> mRenderThread;
+ std::shared_ptr<MockCameraDeviceCallback> mMockCameraDeviceCallback;
+};
+
+TEST_F(VirtualCameraRenderThreadTest, FlushReturnsErrorForInFlightRequests) {
+ const int frameNumber = 42;
+ const int firstStreamId = 1;
+ const int firstStreamBufferId = 1234;
+ const int secondStreamId = 7;
+ const int secondStreamBufferId = 4321;
+
+ // Notify should be called with the error set to corresponding frame.
+ EXPECT_CALL(*mMockCameraDeviceCallback,
+ notify(ElementsAre(IsRequestErrorNotifyMsg(frameNumber))))
+ .WillOnce(Return(ndk::ScopedAStatus::ok()));
+
+ // Process capture result should be called with all buffers in error state.
+ EXPECT_CALL(
+ *mMockCameraDeviceCallback,
+ processCaptureResult(ElementsAre(AllOf(
+ Field(&CaptureResult::frameNumber, frameNumber),
+ Field(&CaptureResult::outputBuffers,
+ testing::UnorderedElementsAre(
+ IsStreamBufferWithStatus(firstStreamId, firstStreamBufferId,
+ BufferStatus::ERROR),
+ IsStreamBufferWithStatus(secondStreamId, secondStreamBufferId,
+ BufferStatus::ERROR)))))))
+ .WillOnce([]() { return ndk::ScopedAStatus::ok(); });
+
+ mRenderThread->enqueueTask(std::make_unique<ProcessCaptureRequestTask>(
+ frameNumber,
+ std::vector<CaptureRequestBuffer>{
+ CaptureRequestBuffer(firstStreamId, firstStreamBufferId),
+ CaptureRequestBuffer(secondStreamId, secondStreamBufferId)}));
+
+ mRenderThread->flush();
+}
+
+} // namespace
+} // namespace virtualcamera
+} // namespace companion
+} // namespace android
\ No newline at end of file
diff --git a/services/camera/virtualcamera/tests/VirtualCameraServiceTest.cc b/services/camera/virtualcamera/tests/VirtualCameraServiceTest.cc
new file mode 100644
index 0000000..4fd0b3b
--- /dev/null
+++ b/services/camera/virtualcamera/tests/VirtualCameraServiceTest.cc
@@ -0,0 +1,206 @@
+/*
+ * Copyright (C) 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <cstdio>
+#include <memory>
+
+#include "VirtualCameraService.h"
+#include "aidl/android/companion/virtualcamera/BnVirtualCameraCallback.h"
+#include "aidl/android/companion/virtualcamera/VirtualCameraConfiguration.h"
+#include "aidl/android/hardware/camera/provider/BnCameraProviderCallback.h"
+#include "aidl/android/hardware/graphics/common/PixelFormat.h"
+#include "android/binder_auto_utils.h"
+#include "android/binder_interface_utils.h"
+#include "android/binder_libbinder.h"
+#include "android/binder_status.h"
+#include "binder/Binder.h"
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+#include "utils/Errors.h"
+
+namespace android {
+namespace companion {
+namespace virtualcamera {
+namespace {
+
+using ::aidl::android::companion::virtualcamera::BnVirtualCameraCallback;
+using ::aidl::android::companion::virtualcamera::VirtualCameraConfiguration;
+using ::aidl::android::hardware::camera::common::CameraDeviceStatus;
+using ::aidl::android::hardware::camera::common::TorchModeStatus;
+using ::aidl::android::hardware::camera::provider::BnCameraProviderCallback;
+using ::aidl::android::hardware::graphics::common::PixelFormat;
+using ::aidl::android::view::Surface;
+using ::testing::_;
+using ::testing::Eq;
+using ::testing::Ge;
+using ::testing::IsEmpty;
+using ::testing::IsNull;
+using ::testing::Not;
+using ::testing::SizeIs;
+
+const VirtualCameraConfiguration kEmptyVirtualCameraConfiguration;
+
+class MockCameraProviderCallback : public BnCameraProviderCallback {
+ public:
+ MOCK_METHOD(ndk::ScopedAStatus, cameraDeviceStatusChange,
+ (const std::string&, CameraDeviceStatus), (override));
+ MOCK_METHOD(ndk::ScopedAStatus, torchModeStatusChange,
+ (const std::string&, TorchModeStatus), (override));
+ MOCK_METHOD(ndk::ScopedAStatus, physicalCameraDeviceStatusChange,
+ (const std::string&, const std::string&, CameraDeviceStatus),
+ (override));
+};
+
+class VirtualCameraServiceTest : public ::testing::Test {
+ public:
+ void SetUp() override {
+ mCameraProvider = ndk::SharedRefBase::make<VirtualCameraProvider>();
+ mMockCameraProviderCallback =
+ ndk::SharedRefBase::make<MockCameraProviderCallback>();
+ ON_CALL(*mMockCameraProviderCallback, cameraDeviceStatusChange)
+ .WillByDefault([](const std::string&, CameraDeviceStatus) {
+ return ndk::ScopedAStatus::ok();
+ });
+ mCameraProvider->setCallback(mMockCameraProviderCallback);
+ mCameraService =
+ ndk::SharedRefBase::make<VirtualCameraService>(mCameraProvider);
+
+ mDevNullFd = open("/dev/null", O_RDWR);
+ ASSERT_THAT(mDevNullFd, Ge(0));
+ }
+
+ void createCamera() {
+ mOwnerToken = sp<BBinder>::make();
+ mNdkOwnerToken.set(AIBinder_fromPlatformBinder(mOwnerToken));
+ bool aidlRet;
+
+ ASSERT_TRUE(mCameraService
+ ->registerCamera(mNdkOwnerToken,
+ kEmptyVirtualCameraConfiguration, &aidlRet)
+ .isOk());
+ ASSERT_TRUE(aidlRet);
+ }
+
+ void TearDown() override {
+ close(mDevNullFd);
+ }
+
+ void execute_shell_command(const std::string cmd) {
+ std::array<const char*, 1> args{cmd.data()};
+ ASSERT_THAT(
+ mCameraService->handleShellCommand(mDevNullFd, mDevNullFd, mDevNullFd,
+ args.data(), args.size()),
+ Eq(NO_ERROR));
+ }
+
+ protected:
+ std::shared_ptr<VirtualCameraService> mCameraService;
+ std::shared_ptr<VirtualCameraProvider> mCameraProvider;
+ std::shared_ptr<MockCameraProviderCallback> mMockCameraProviderCallback =
+ ndk::SharedRefBase::make<MockCameraProviderCallback>();
+
+ sp<BBinder> mOwnerToken;
+ ndk::SpAIBinder mNdkOwnerToken;
+
+ int mDevNullFd;
+};
+
+TEST_F(VirtualCameraServiceTest, RegisterCameraSucceeds) {
+ sp<BBinder> token = sp<BBinder>::make();
+ ndk::SpAIBinder ndkToken(AIBinder_fromPlatformBinder(token));
+ bool aidlRet;
+
+ ASSERT_TRUE(
+ mCameraService
+ ->registerCamera(ndkToken, kEmptyVirtualCameraConfiguration, &aidlRet)
+ .isOk());
+
+ EXPECT_TRUE(aidlRet);
+}
+
+TEST_F(VirtualCameraServiceTest, RegisterCameraTwiceSecondReturnsFalse) {
+ createCamera();
+ bool aidlRet;
+
+ ASSERT_TRUE(mCameraService
+ ->registerCamera(mNdkOwnerToken,
+ kEmptyVirtualCameraConfiguration, &aidlRet)
+ .isOk());
+ EXPECT_FALSE(aidlRet);
+}
+
+TEST_F(VirtualCameraServiceTest, GetCamera) {
+ createCamera();
+
+ EXPECT_THAT(mCameraService->getCamera(mNdkOwnerToken), Not(IsNull()));
+
+ sp<BBinder> otherToken = sp<BBinder>::make();
+ EXPECT_THAT(mCameraService->getCamera(
+ ndk::SpAIBinder(AIBinder_fromPlatformBinder(otherToken))),
+ IsNull());
+}
+
+TEST_F(VirtualCameraServiceTest, UnregisterCamera) {
+ createCamera();
+
+ EXPECT_THAT(mCameraService->getCamera(mNdkOwnerToken), Not(IsNull()));
+
+ mCameraService->unregisterCamera(mNdkOwnerToken);
+
+ EXPECT_THAT(mCameraService->getCamera(mNdkOwnerToken), IsNull());
+}
+
+TEST_F(VirtualCameraServiceTest, UnregisterCameraWithUnknownToken) {
+ createCamera();
+
+ EXPECT_THAT(mCameraService->getCamera(mNdkOwnerToken), Not(IsNull()));
+
+ auto otherToken = sp<BBinder>::make();
+ ndk::SpAIBinder ndkOtherToken(AIBinder_fromPlatformBinder(otherToken));
+ mCameraService->unregisterCamera(ndkOtherToken);
+
+ EXPECT_THAT(mCameraService->getCamera(mNdkOwnerToken), Not(IsNull()));
+}
+
+TEST_F(VirtualCameraServiceTest, ShellCmdWithNullArgs) {
+ EXPECT_EQ(mCameraService->handleShellCommand(
+ /*in=*/mDevNullFd, /*out=*/mDevNullFd, /*err=*/mDevNullFd,
+ /*args=*/nullptr, /*numArgs=*/1),
+ STATUS_BAD_VALUE);
+
+ std::array<const char*, 1> args{nullptr};
+ EXPECT_EQ(mCameraService->handleShellCommand(
+ /*in=*/mDevNullFd, /*out=*/mDevNullFd, /*err=*/mDevNullFd,
+ args.data(), /*numArgs=*/1),
+ STATUS_BAD_VALUE);
+}
+
+TEST_F(VirtualCameraServiceTest, TestCameraShellCmd) {
+ execute_shell_command("enable_test_camera");
+
+ std::vector<std::string> cameraIds;
+ EXPECT_TRUE(mCameraProvider->getCameraIdList(&cameraIds).isOk());
+ EXPECT_THAT(cameraIds, SizeIs(1));
+
+ execute_shell_command("disable_test_camera");
+ EXPECT_TRUE(mCameraProvider->getCameraIdList(&cameraIds).isOk());
+ EXPECT_THAT(cameraIds, IsEmpty());
+}
+
+} // namespace
+} // namespace virtualcamera
+} // namespace companion
+} // namespace android
diff --git a/services/camera/virtualcamera/tests/VirtualCameraSessionTest.cc b/services/camera/virtualcamera/tests/VirtualCameraSessionTest.cc
new file mode 100644
index 0000000..5da080b
--- /dev/null
+++ b/services/camera/virtualcamera/tests/VirtualCameraSessionTest.cc
@@ -0,0 +1,195 @@
+/*
+ * Copyright (C) 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <cstdint>
+#include <memory>
+
+#include "VirtualCameraSession.h"
+#include "aidl/android/companion/virtualcamera/BnVirtualCameraCallback.h"
+#include "aidl/android/companion/virtualcamera/IVirtualCameraCallback.h"
+#include "aidl/android/hardware/camera/device/BnCameraDeviceCallback.h"
+#include "aidl/android/hardware/camera/device/StreamConfiguration.h"
+#include "aidl/android/hardware/graphics/common/PixelFormat.h"
+#include "android/binder_auto_utils.h"
+#include "android/binder_interface_utils.h"
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+#include "util/MetadataBuilder.h"
+
+namespace android {
+namespace companion {
+namespace virtualcamera {
+namespace {
+
+constexpr int kWidth = 640;
+constexpr int kHeight = 480;
+constexpr int kStreamId = 0;
+const std::string kCameraName = "virtual_camera";
+
+using ::aidl::android::companion::virtualcamera::BnVirtualCameraCallback;
+using ::aidl::android::companion::virtualcamera::Format;
+using ::aidl::android::hardware::camera::device::BnCameraDeviceCallback;
+using ::aidl::android::hardware::camera::device::BufferRequest;
+using ::aidl::android::hardware::camera::device::BufferRequestStatus;
+using ::aidl::android::hardware::camera::device::CaptureRequest;
+using ::aidl::android::hardware::camera::device::CaptureResult;
+using ::aidl::android::hardware::camera::device::HalStream;
+using ::aidl::android::hardware::camera::device::NotifyMsg;
+using ::aidl::android::hardware::camera::device::Stream;
+using ::aidl::android::hardware::camera::device::StreamBuffer;
+using ::aidl::android::hardware::camera::device::StreamBufferRet;
+using ::aidl::android::hardware::camera::device::StreamConfiguration;
+using ::aidl::android::hardware::graphics::common::PixelFormat;
+using ::aidl::android::view::Surface;
+using ::testing::_;
+using ::testing::ElementsAre;
+using ::testing::Eq;
+using ::testing::Return;
+using ::testing::SizeIs;
+
+Stream createStream(int streamId, int width, int height, PixelFormat format) {
+ Stream s;
+ s.id = streamId;
+ s.width = width;
+ s.height = height;
+ s.format = format;
+ return s;
+}
+
+class MockCameraDeviceCallback : public BnCameraDeviceCallback {
+ public:
+ MOCK_METHOD(ndk::ScopedAStatus, notify, (const std::vector<NotifyMsg>&),
+ (override));
+ MOCK_METHOD(ndk::ScopedAStatus, processCaptureResult,
+ (const std::vector<CaptureResult>&), (override));
+ MOCK_METHOD(ndk::ScopedAStatus, requestStreamBuffers,
+ (const std::vector<BufferRequest>&, std::vector<StreamBufferRet>*,
+ BufferRequestStatus*),
+ (override));
+ MOCK_METHOD(ndk::ScopedAStatus, returnStreamBuffers,
+ (const std::vector<StreamBuffer>&), (override));
+};
+
+class MockVirtualCameraCallback : public BnVirtualCameraCallback {
+ public:
+ MOCK_METHOD(ndk::ScopedAStatus, onStreamConfigured,
+ (int, const Surface&, int32_t, int32_t, Format), (override));
+ MOCK_METHOD(ndk::ScopedAStatus, onProcessCaptureRequest, (int, int),
+ (override));
+ MOCK_METHOD(ndk::ScopedAStatus, onStreamClosed, (int), (override));
+};
+
+class VirtualCameraSessionTest : public ::testing::Test {
+ public:
+ void SetUp() override {
+ mMockCameraDeviceCallback =
+ ndk::SharedRefBase::make<MockCameraDeviceCallback>();
+ mMockVirtualCameraClientCallback =
+ ndk::SharedRefBase::make<MockVirtualCameraCallback>();
+ mVirtualCameraSession = ndk::SharedRefBase::make<VirtualCameraSession>(
+ kCameraName, mMockCameraDeviceCallback,
+ mMockVirtualCameraClientCallback);
+
+ ON_CALL(*mMockVirtualCameraClientCallback, onStreamConfigured)
+ .WillByDefault(ndk::ScopedAStatus::ok);
+ ON_CALL(*mMockVirtualCameraClientCallback, onProcessCaptureRequest)
+ .WillByDefault(ndk::ScopedAStatus::ok);
+ }
+
+ protected:
+ std::shared_ptr<MockCameraDeviceCallback> mMockCameraDeviceCallback;
+ std::shared_ptr<MockVirtualCameraCallback> mMockVirtualCameraClientCallback;
+ std::shared_ptr<VirtualCameraSession> mVirtualCameraSession;
+};
+
+TEST_F(VirtualCameraSessionTest, ConfigureTriggersClientConfigureCallback) {
+ PixelFormat format = PixelFormat::YCBCR_420_888;
+ StreamConfiguration streamConfiguration;
+ streamConfiguration.streams = {
+ createStream(kStreamId, kWidth, kHeight, format)};
+ std::vector<HalStream> halStreams;
+ EXPECT_CALL(
+ *mMockVirtualCameraClientCallback,
+ onStreamConfigured(kStreamId, _, kWidth, kHeight, Format::YUV_420_888));
+
+ ASSERT_TRUE(
+ mVirtualCameraSession->configureStreams(streamConfiguration, &halStreams)
+ .isOk());
+
+ EXPECT_THAT(halStreams, SizeIs(streamConfiguration.streams.size()));
+ EXPECT_THAT(mVirtualCameraSession->getStreamIds(), ElementsAre(0));
+}
+
+TEST_F(VirtualCameraSessionTest, SecondConfigureDropsUnreferencedStreams) {
+ PixelFormat format = PixelFormat::YCBCR_420_888;
+ StreamConfiguration streamConfiguration;
+ std::vector<HalStream> halStreams;
+
+ streamConfiguration.streams = {createStream(0, kWidth, kHeight, format),
+ createStream(1, kWidth, kHeight, format),
+ createStream(2, kWidth, kHeight, format)};
+ ASSERT_TRUE(
+ mVirtualCameraSession->configureStreams(streamConfiguration, &halStreams)
+ .isOk());
+
+ EXPECT_THAT(mVirtualCameraSession->getStreamIds(), ElementsAre(0, 1, 2));
+
+ streamConfiguration.streams = {createStream(0, kWidth, kHeight, format),
+ createStream(2, kWidth, kHeight, format),
+ createStream(3, kWidth, kHeight, format)};
+ ASSERT_TRUE(
+ mVirtualCameraSession->configureStreams(streamConfiguration, &halStreams)
+ .isOk());
+
+ EXPECT_THAT(mVirtualCameraSession->getStreamIds(), ElementsAre(0, 2, 3));
+}
+
+TEST_F(VirtualCameraSessionTest, CloseTriggersClientTerminateCallback) {
+ EXPECT_CALL(*mMockVirtualCameraClientCallback, onStreamClosed(kStreamId))
+ .WillOnce(Return(ndk::ScopedAStatus::ok()));
+
+ ASSERT_TRUE(mVirtualCameraSession->close().isOk());
+}
+
+TEST_F(VirtualCameraSessionTest, onProcessCaptureRequestTriggersClientCallback) {
+ StreamConfiguration streamConfiguration;
+ streamConfiguration.streams = {
+ createStream(kStreamId, kWidth, kHeight, PixelFormat::YCBCR_420_888)};
+ std::vector<CaptureRequest> requests(1);
+ requests[0].frameNumber = 42;
+ requests[0].settings = *(
+ MetadataBuilder().setControlAfMode(ANDROID_CONTROL_AF_MODE_AUTO).build());
+
+ std::vector<HalStream> halStreams;
+ ASSERT_TRUE(
+ mVirtualCameraSession->configureStreams(streamConfiguration, &halStreams)
+ .isOk());
+
+ EXPECT_CALL(*mMockVirtualCameraClientCallback,
+ onProcessCaptureRequest(kStreamId, requests[0].frameNumber))
+ .WillOnce(Return(ndk::ScopedAStatus::ok()));
+ int32_t aidlReturn = 0;
+ ASSERT_TRUE(mVirtualCameraSession
+ ->processCaptureRequest(requests, /*in_cachesToRemove=*/{},
+ &aidlReturn)
+ .isOk());
+ EXPECT_THAT(aidlReturn, Eq(requests.size()));
+}
+
+} // namespace
+} // namespace virtualcamera
+} // namespace companion
+} // namespace android