| // Copyright 2013 The Flutter Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "camera_plugin.h" |
| |
| #include <flutter/method_call.h> |
| #include <flutter/method_result_functions.h> |
| #include <flutter/standard_method_codec.h> |
| #include <flutter/texture_registrar.h> |
| #include <gmock/gmock.h> |
| #include <gtest/gtest.h> |
| #include <windows.h> |
| |
| #include <functional> |
| #include <memory> |
| #include <string> |
| |
| #include "mocks.h" |
| |
| namespace camera_windows { |
| namespace test { |
| |
| using flutter::EncodableMap; |
| using flutter::EncodableValue; |
| using ::testing::_; |
| using ::testing::DoAll; |
| using ::testing::EndsWith; |
| using ::testing::Eq; |
| using ::testing::Pointee; |
| using ::testing::Return; |
| |
| void MockInitCamera(MockCamera* camera, bool success) { |
| EXPECT_CALL(*camera, |
| HasPendingResultByType(Eq(PendingResultType::kCreateCamera))) |
| .Times(1) |
| .WillOnce(Return(false)); |
| |
| EXPECT_CALL(*camera, |
| AddPendingResult(Eq(PendingResultType::kCreateCamera), _)) |
| .Times(1) |
| .WillOnce([camera](PendingResultType type, |
| std::unique_ptr<MethodResult<>> result) { |
| camera->pending_result_ = std::move(result); |
| return true; |
| }); |
| |
| EXPECT_CALL(*camera, HasDeviceId(Eq(camera->device_id_))) |
| .WillRepeatedly(Return(true)); |
| |
| EXPECT_CALL(*camera, InitCamera) |
| .Times(1) |
| .WillOnce([camera, success](flutter::TextureRegistrar* texture_registrar, |
| flutter::BinaryMessenger* messenger, |
| bool record_audio, |
| ResolutionPreset resolution_preset) { |
| assert(camera->pending_result_); |
| if (success) { |
| camera->pending_result_->Success(EncodableValue(1)); |
| return true; |
| } else { |
| camera->pending_result_->Error("camera_error", "InitCamera failed."); |
| return false; |
| } |
| }); |
| } |
| |
| TEST(CameraPlugin, AvailableCamerasHandlerSuccessIfNoCameras) { |
| std::unique_ptr<MockTextureRegistrar> texture_registrar_ = |
| std::make_unique<MockTextureRegistrar>(); |
| std::unique_ptr<MockBinaryMessenger> messenger_ = |
| std::make_unique<MockBinaryMessenger>(); |
| std::unique_ptr<MockCameraFactory> camera_factory_ = |
| std::make_unique<MockCameraFactory>(); |
| std::unique_ptr<MockMethodResult> result = |
| std::make_unique<MockMethodResult>(); |
| |
| MockCameraPlugin plugin(texture_registrar_.get(), messenger_.get(), |
| std::move(camera_factory_)); |
| |
| EXPECT_CALL(plugin, EnumerateVideoCaptureDeviceSources) |
| .Times(1) |
| .WillOnce([](IMFActivate*** devices, UINT32* count) { |
| *count = 0U; |
| *devices = static_cast<IMFActivate**>( |
| CoTaskMemAlloc(sizeof(IMFActivate*) * (*count))); |
| return true; |
| }); |
| |
| EXPECT_CALL(*result, ErrorInternal).Times(0); |
| EXPECT_CALL(*result, SuccessInternal).Times(1); |
| |
| plugin.HandleMethodCall( |
| flutter::MethodCall("availableCameras", |
| std::make_unique<EncodableValue>()), |
| std::move(result)); |
| } |
| |
| TEST(CameraPlugin, AvailableCamerasHandlerErrorIfFailsToEnumerateDevices) { |
| std::unique_ptr<MockTextureRegistrar> texture_registrar_ = |
| std::make_unique<MockTextureRegistrar>(); |
| std::unique_ptr<MockBinaryMessenger> messenger_ = |
| std::make_unique<MockBinaryMessenger>(); |
| std::unique_ptr<MockCameraFactory> camera_factory_ = |
| std::make_unique<MockCameraFactory>(); |
| std::unique_ptr<MockMethodResult> result = |
| std::make_unique<MockMethodResult>(); |
| |
| MockCameraPlugin plugin(texture_registrar_.get(), messenger_.get(), |
| std::move(camera_factory_)); |
| |
| EXPECT_CALL(plugin, EnumerateVideoCaptureDeviceSources) |
| .Times(1) |
| .WillOnce([](IMFActivate*** devices, UINT32* count) { return false; }); |
| |
| EXPECT_CALL(*result, ErrorInternal).Times(1); |
| EXPECT_CALL(*result, SuccessInternal).Times(0); |
| |
| plugin.HandleMethodCall( |
| flutter::MethodCall("availableCameras", |
| std::make_unique<EncodableValue>()), |
| std::move(result)); |
| } |
| |
| TEST(CameraPlugin, CreateHandlerCallsInitCamera) { |
| std::unique_ptr<MockMethodResult> result = |
| std::make_unique<MockMethodResult>(); |
| std::unique_ptr<MockTextureRegistrar> texture_registrar_ = |
| std::make_unique<MockTextureRegistrar>(); |
| std::unique_ptr<MockBinaryMessenger> messenger_ = |
| std::make_unique<MockBinaryMessenger>(); |
| std::unique_ptr<MockCameraFactory> camera_factory_ = |
| std::make_unique<MockCameraFactory>(); |
| std::unique_ptr<MockCamera> camera = |
| std::make_unique<MockCamera>(MOCK_DEVICE_ID); |
| |
| MockInitCamera(camera.get(), true); |
| |
| // Move mocked camera to the factory to be passed |
| // for plugin with CreateCamera function. |
| camera_factory_->pending_camera_ = std::move(camera); |
| |
| EXPECT_CALL(*camera_factory_, CreateCamera(MOCK_DEVICE_ID)); |
| |
| EXPECT_CALL(*result, ErrorInternal).Times(0); |
| EXPECT_CALL(*result, SuccessInternal(Pointee(EncodableValue(1)))); |
| |
| CameraPlugin plugin(texture_registrar_.get(), messenger_.get(), |
| std::move(camera_factory_)); |
| EncodableMap args = { |
| {EncodableValue("cameraName"), EncodableValue(MOCK_CAMERA_NAME)}, |
| {EncodableValue("resolutionPreset"), EncodableValue(nullptr)}, |
| {EncodableValue("enableAudio"), EncodableValue(true)}, |
| }; |
| |
| plugin.HandleMethodCall( |
| flutter::MethodCall("create", |
| std::make_unique<EncodableValue>(EncodableMap(args))), |
| std::move(result)); |
| } |
| |
| TEST(CameraPlugin, CreateHandlerErrorOnInvalidDeviceId) { |
| std::unique_ptr<MockMethodResult> result = |
| std::make_unique<MockMethodResult>(); |
| std::unique_ptr<MockTextureRegistrar> texture_registrar_ = |
| std::make_unique<MockTextureRegistrar>(); |
| std::unique_ptr<MockBinaryMessenger> messenger_ = |
| std::make_unique<MockBinaryMessenger>(); |
| std::unique_ptr<MockCameraFactory> camera_factory_ = |
| std::make_unique<MockCameraFactory>(); |
| |
| CameraPlugin plugin(texture_registrar_.get(), messenger_.get(), |
| std::move(camera_factory_)); |
| EncodableMap args = { |
| {EncodableValue("cameraName"), EncodableValue(MOCK_INVALID_CAMERA_NAME)}, |
| {EncodableValue("resolutionPreset"), EncodableValue(nullptr)}, |
| {EncodableValue("enableAudio"), EncodableValue(true)}, |
| }; |
| |
| EXPECT_CALL(*result, ErrorInternal).Times(1); |
| |
| plugin.HandleMethodCall( |
| flutter::MethodCall("create", |
| std::make_unique<EncodableValue>(EncodableMap(args))), |
| std::move(result)); |
| } |
| |
| TEST(CameraPlugin, CreateHandlerErrorOnExistingDeviceId) { |
| std::unique_ptr<MockMethodResult> first_create_result = |
| std::make_unique<MockMethodResult>(); |
| std::unique_ptr<MockMethodResult> second_create_result = |
| std::make_unique<MockMethodResult>(); |
| std::unique_ptr<MockTextureRegistrar> texture_registrar_ = |
| std::make_unique<MockTextureRegistrar>(); |
| std::unique_ptr<MockBinaryMessenger> messenger_ = |
| std::make_unique<MockBinaryMessenger>(); |
| std::unique_ptr<MockCameraFactory> camera_factory_ = |
| std::make_unique<MockCameraFactory>(); |
| std::unique_ptr<MockCamera> camera = |
| std::make_unique<MockCamera>(MOCK_DEVICE_ID); |
| |
| MockInitCamera(camera.get(), true); |
| |
| // Move mocked camera to the factory to be passed |
| // for plugin with CreateCamera function. |
| camera_factory_->pending_camera_ = std::move(camera); |
| |
| EXPECT_CALL(*camera_factory_, CreateCamera(MOCK_DEVICE_ID)); |
| |
| EXPECT_CALL(*first_create_result, ErrorInternal).Times(0); |
| EXPECT_CALL(*first_create_result, |
| SuccessInternal(Pointee(EncodableValue(1)))); |
| |
| CameraPlugin plugin(texture_registrar_.get(), messenger_.get(), |
| std::move(camera_factory_)); |
| EncodableMap args = { |
| {EncodableValue("cameraName"), EncodableValue(MOCK_CAMERA_NAME)}, |
| {EncodableValue("resolutionPreset"), EncodableValue(nullptr)}, |
| {EncodableValue("enableAudio"), EncodableValue(true)}, |
| }; |
| |
| plugin.HandleMethodCall( |
| flutter::MethodCall("create", |
| std::make_unique<EncodableValue>(EncodableMap(args))), |
| std::move(first_create_result)); |
| |
| EXPECT_CALL(*second_create_result, ErrorInternal).Times(1); |
| EXPECT_CALL(*second_create_result, SuccessInternal).Times(0); |
| |
| plugin.HandleMethodCall( |
| flutter::MethodCall("create", |
| std::make_unique<EncodableValue>(EncodableMap(args))), |
| std::move(second_create_result)); |
| } |
| |
| TEST(CameraPlugin, CreateHandlerAllowsRetry) { |
| std::unique_ptr<MockMethodResult> first_create_result = |
| std::make_unique<MockMethodResult>(); |
| std::unique_ptr<MockMethodResult> second_create_result = |
| std::make_unique<MockMethodResult>(); |
| std::unique_ptr<MockTextureRegistrar> texture_registrar_ = |
| std::make_unique<MockTextureRegistrar>(); |
| std::unique_ptr<MockBinaryMessenger> messenger_ = |
| std::make_unique<MockBinaryMessenger>(); |
| std::unique_ptr<MockCameraFactory> camera_factory_ = |
| std::make_unique<MockCameraFactory>(); |
| |
| // The camera will fail initialization once and then succeed. |
| EXPECT_CALL(*camera_factory_, CreateCamera(MOCK_DEVICE_ID)) |
| .Times(2) |
| .WillOnce([](const std::string& device_id) { |
| std::unique_ptr<MockCamera> first_camera = |
| std::make_unique<MockCamera>(MOCK_DEVICE_ID); |
| |
| MockInitCamera(first_camera.get(), false); |
| |
| return first_camera; |
| }) |
| .WillOnce([](const std::string& device_id) { |
| std::unique_ptr<MockCamera> second_camera = |
| std::make_unique<MockCamera>(MOCK_DEVICE_ID); |
| |
| MockInitCamera(second_camera.get(), true); |
| |
| return second_camera; |
| }); |
| |
| EXPECT_CALL(*first_create_result, ErrorInternal).Times(1); |
| EXPECT_CALL(*first_create_result, SuccessInternal).Times(0); |
| |
| CameraPlugin plugin(texture_registrar_.get(), messenger_.get(), |
| std::move(camera_factory_)); |
| EncodableMap args = { |
| {EncodableValue("cameraName"), EncodableValue(MOCK_CAMERA_NAME)}, |
| {EncodableValue("resolutionPreset"), EncodableValue(nullptr)}, |
| {EncodableValue("enableAudio"), EncodableValue(true)}, |
| }; |
| |
| plugin.HandleMethodCall( |
| flutter::MethodCall("create", |
| std::make_unique<EncodableValue>(EncodableMap(args))), |
| std::move(first_create_result)); |
| |
| EXPECT_CALL(*second_create_result, ErrorInternal).Times(0); |
| EXPECT_CALL(*second_create_result, |
| SuccessInternal(Pointee(EncodableValue(1)))); |
| |
| plugin.HandleMethodCall( |
| flutter::MethodCall("create", |
| std::make_unique<EncodableValue>(EncodableMap(args))), |
| std::move(second_create_result)); |
| } |
| |
| TEST(CameraPlugin, InitializeHandlerCallStartPreview) { |
| int64_t mock_camera_id = 1234; |
| |
| std::unique_ptr<MockMethodResult> initialize_result = |
| std::make_unique<MockMethodResult>(); |
| |
| std::unique_ptr<MockCamera> camera = |
| std::make_unique<MockCamera>(MOCK_DEVICE_ID); |
| |
| std::unique_ptr<MockCaptureController> capture_controller = |
| std::make_unique<MockCaptureController>(); |
| |
| EXPECT_CALL(*camera, HasCameraId(Eq(mock_camera_id))) |
| .Times(1) |
| .WillOnce([cam = camera.get()](int64_t camera_id) { |
| return cam->camera_id_ == camera_id; |
| }); |
| |
| EXPECT_CALL(*camera, |
| HasPendingResultByType(Eq(PendingResultType::kInitialize))) |
| .Times(1) |
| .WillOnce(Return(false)); |
| |
| EXPECT_CALL(*camera, AddPendingResult(Eq(PendingResultType::kInitialize), _)) |
| .Times(1) |
| .WillOnce([cam = camera.get()](PendingResultType type, |
| std::unique_ptr<MethodResult<>> result) { |
| cam->pending_result_ = std::move(result); |
| return true; |
| }); |
| |
| EXPECT_CALL(*camera, GetCaptureController) |
| .Times(1) |
| .WillOnce([cam = camera.get()]() { |
| assert(cam->pending_result_); |
| return cam->capture_controller_.get(); |
| }); |
| |
| EXPECT_CALL(*capture_controller, StartPreview()) |
| .Times(1) |
| .WillOnce([cam = camera.get()]() { |
| assert(cam->pending_result_); |
| return cam->pending_result_->Success(); |
| }); |
| |
| camera->camera_id_ = mock_camera_id; |
| camera->capture_controller_ = std::move(capture_controller); |
| |
| MockCameraPlugin plugin(std::make_unique<MockTextureRegistrar>().get(), |
| std::make_unique<MockBinaryMessenger>().get(), |
| std::make_unique<MockCameraFactory>()); |
| |
| // Add mocked camera to plugins camera list. |
| plugin.AddCamera(std::move(camera)); |
| |
| EXPECT_CALL(*initialize_result, ErrorInternal).Times(0); |
| EXPECT_CALL(*initialize_result, SuccessInternal).Times(1); |
| |
| EncodableMap args = { |
| {EncodableValue("cameraId"), EncodableValue(mock_camera_id)}, |
| }; |
| |
| plugin.HandleMethodCall( |
| flutter::MethodCall("initialize", |
| std::make_unique<EncodableValue>(EncodableMap(args))), |
| std::move(initialize_result)); |
| } |
| |
| TEST(CameraPlugin, InitializeHandlerErrorOnInvalidCameraId) { |
| int64_t mock_camera_id = 1234; |
| int64_t missing_camera_id = 5678; |
| |
| std::unique_ptr<MockMethodResult> initialize_result = |
| std::make_unique<MockMethodResult>(); |
| |
| std::unique_ptr<MockCamera> camera = |
| std::make_unique<MockCamera>(MOCK_DEVICE_ID); |
| |
| std::unique_ptr<MockCaptureController> capture_controller = |
| std::make_unique<MockCaptureController>(); |
| |
| EXPECT_CALL(*camera, HasCameraId) |
| .Times(1) |
| .WillOnce([cam = camera.get()](int64_t camera_id) { |
| return cam->camera_id_ == camera_id; |
| }); |
| |
| EXPECT_CALL(*camera, HasPendingResultByType).Times(0); |
| EXPECT_CALL(*camera, AddPendingResult).Times(0); |
| EXPECT_CALL(*camera, GetCaptureController).Times(0); |
| EXPECT_CALL(*capture_controller, StartPreview).Times(0); |
| |
| camera->camera_id_ = mock_camera_id; |
| |
| MockCameraPlugin plugin(std::make_unique<MockTextureRegistrar>().get(), |
| std::make_unique<MockBinaryMessenger>().get(), |
| std::make_unique<MockCameraFactory>()); |
| |
| // Add mocked camera to plugins camera list. |
| plugin.AddCamera(std::move(camera)); |
| |
| EXPECT_CALL(*initialize_result, ErrorInternal).Times(1); |
| EXPECT_CALL(*initialize_result, SuccessInternal).Times(0); |
| |
| EncodableMap args = { |
| {EncodableValue("cameraId"), EncodableValue(missing_camera_id)}, |
| }; |
| |
| plugin.HandleMethodCall( |
| flutter::MethodCall("initialize", |
| std::make_unique<EncodableValue>(EncodableMap(args))), |
| std::move(initialize_result)); |
| } |
| |
| TEST(CameraPlugin, TakePictureHandlerCallsTakePictureWithPath) { |
| int64_t mock_camera_id = 1234; |
| |
| std::unique_ptr<MockMethodResult> initialize_result = |
| std::make_unique<MockMethodResult>(); |
| |
| std::unique_ptr<MockCamera> camera = |
| std::make_unique<MockCamera>(MOCK_DEVICE_ID); |
| |
| std::unique_ptr<MockCaptureController> capture_controller = |
| std::make_unique<MockCaptureController>(); |
| |
| EXPECT_CALL(*camera, HasCameraId(Eq(mock_camera_id))) |
| .Times(1) |
| .WillOnce([cam = camera.get()](int64_t camera_id) { |
| return cam->camera_id_ == camera_id; |
| }); |
| |
| EXPECT_CALL(*camera, |
| HasPendingResultByType(Eq(PendingResultType::kTakePicture))) |
| .Times(1) |
| .WillOnce(Return(false)); |
| |
| EXPECT_CALL(*camera, AddPendingResult(Eq(PendingResultType::kTakePicture), _)) |
| .Times(1) |
| .WillOnce([cam = camera.get()](PendingResultType type, |
| std::unique_ptr<MethodResult<>> result) { |
| cam->pending_result_ = std::move(result); |
| return true; |
| }); |
| |
| EXPECT_CALL(*camera, GetCaptureController) |
| .Times(1) |
| .WillOnce([cam = camera.get()]() { |
| assert(cam->pending_result_); |
| return cam->capture_controller_.get(); |
| }); |
| |
| EXPECT_CALL(*capture_controller, TakePicture(EndsWith(".jpeg"))) |
| .Times(1) |
| .WillOnce([cam = camera.get()](const std::string& file_path) { |
| assert(cam->pending_result_); |
| return cam->pending_result_->Success(); |
| }); |
| |
| camera->camera_id_ = mock_camera_id; |
| camera->capture_controller_ = std::move(capture_controller); |
| |
| MockCameraPlugin plugin(std::make_unique<MockTextureRegistrar>().get(), |
| std::make_unique<MockBinaryMessenger>().get(), |
| std::make_unique<MockCameraFactory>()); |
| |
| // Add mocked camera to plugins camera list. |
| plugin.AddCamera(std::move(camera)); |
| |
| EXPECT_CALL(*initialize_result, ErrorInternal).Times(0); |
| EXPECT_CALL(*initialize_result, SuccessInternal).Times(1); |
| |
| EncodableMap args = { |
| {EncodableValue("cameraId"), EncodableValue(mock_camera_id)}, |
| }; |
| |
| plugin.HandleMethodCall( |
| flutter::MethodCall("takePicture", |
| std::make_unique<EncodableValue>(EncodableMap(args))), |
| std::move(initialize_result)); |
| } |
| |
| TEST(CameraPlugin, TakePictureHandlerErrorOnInvalidCameraId) { |
| int64_t mock_camera_id = 1234; |
| int64_t missing_camera_id = 5678; |
| |
| std::unique_ptr<MockMethodResult> initialize_result = |
| std::make_unique<MockMethodResult>(); |
| |
| std::unique_ptr<MockCamera> camera = |
| std::make_unique<MockCamera>(MOCK_DEVICE_ID); |
| |
| std::unique_ptr<MockCaptureController> capture_controller = |
| std::make_unique<MockCaptureController>(); |
| |
| EXPECT_CALL(*camera, HasCameraId) |
| .Times(1) |
| .WillOnce([cam = camera.get()](int64_t camera_id) { |
| return cam->camera_id_ == camera_id; |
| }); |
| |
| EXPECT_CALL(*camera, HasPendingResultByType).Times(0); |
| EXPECT_CALL(*camera, AddPendingResult).Times(0); |
| EXPECT_CALL(*camera, GetCaptureController).Times(0); |
| EXPECT_CALL(*capture_controller, TakePicture).Times(0); |
| |
| camera->camera_id_ = mock_camera_id; |
| |
| MockCameraPlugin plugin(std::make_unique<MockTextureRegistrar>().get(), |
| std::make_unique<MockBinaryMessenger>().get(), |
| std::make_unique<MockCameraFactory>()); |
| |
| // Add mocked camera to plugins camera list. |
| plugin.AddCamera(std::move(camera)); |
| |
| EXPECT_CALL(*initialize_result, ErrorInternal).Times(1); |
| EXPECT_CALL(*initialize_result, SuccessInternal).Times(0); |
| |
| EncodableMap args = { |
| {EncodableValue("cameraId"), EncodableValue(missing_camera_id)}, |
| }; |
| |
| plugin.HandleMethodCall( |
| flutter::MethodCall("takePicture", |
| std::make_unique<EncodableValue>(EncodableMap(args))), |
| std::move(initialize_result)); |
| } |
| |
| TEST(CameraPlugin, StartVideoRecordingHandlerCallsStartRecordWithPath) { |
| int64_t mock_camera_id = 1234; |
| |
| std::unique_ptr<MockMethodResult> initialize_result = |
| std::make_unique<MockMethodResult>(); |
| |
| std::unique_ptr<MockCamera> camera = |
| std::make_unique<MockCamera>(MOCK_DEVICE_ID); |
| |
| std::unique_ptr<MockCaptureController> capture_controller = |
| std::make_unique<MockCaptureController>(); |
| |
| EXPECT_CALL(*camera, HasCameraId(Eq(mock_camera_id))) |
| .Times(1) |
| .WillOnce([cam = camera.get()](int64_t camera_id) { |
| return cam->camera_id_ == camera_id; |
| }); |
| |
| EXPECT_CALL(*camera, |
| HasPendingResultByType(Eq(PendingResultType::kStartRecord))) |
| .Times(1) |
| .WillOnce(Return(false)); |
| |
| EXPECT_CALL(*camera, AddPendingResult(Eq(PendingResultType::kStartRecord), _)) |
| .Times(1) |
| .WillOnce([cam = camera.get()](PendingResultType type, |
| std::unique_ptr<MethodResult<>> result) { |
| cam->pending_result_ = std::move(result); |
| return true; |
| }); |
| |
| EXPECT_CALL(*camera, GetCaptureController) |
| .Times(1) |
| .WillOnce([cam = camera.get()]() { |
| assert(cam->pending_result_); |
| return cam->capture_controller_.get(); |
| }); |
| |
| EXPECT_CALL(*capture_controller, StartRecord(EndsWith(".mp4"), -1)) |
| .Times(1) |
| .WillOnce([cam = camera.get()](const std::string& file_path, |
| int64_t max_video_duration_ms) { |
| assert(cam->pending_result_); |
| return cam->pending_result_->Success(); |
| }); |
| |
| camera->camera_id_ = mock_camera_id; |
| camera->capture_controller_ = std::move(capture_controller); |
| |
| MockCameraPlugin plugin(std::make_unique<MockTextureRegistrar>().get(), |
| std::make_unique<MockBinaryMessenger>().get(), |
| std::make_unique<MockCameraFactory>()); |
| |
| // Add mocked camera to plugins camera list. |
| plugin.AddCamera(std::move(camera)); |
| |
| EXPECT_CALL(*initialize_result, ErrorInternal).Times(0); |
| EXPECT_CALL(*initialize_result, SuccessInternal).Times(1); |
| |
| EncodableMap args = { |
| {EncodableValue("cameraId"), EncodableValue(mock_camera_id)}, |
| }; |
| |
| plugin.HandleMethodCall( |
| flutter::MethodCall("startVideoRecording", |
| std::make_unique<EncodableValue>(EncodableMap(args))), |
| std::move(initialize_result)); |
| } |
| |
| TEST(CameraPlugin, |
| StartVideoRecordingHandlerCallsStartRecordWithPathAndCaptureDuration) { |
| int64_t mock_camera_id = 1234; |
| int32_t mock_video_duration = 100000; |
| |
| std::unique_ptr<MockMethodResult> initialize_result = |
| std::make_unique<MockMethodResult>(); |
| |
| std::unique_ptr<MockCamera> camera = |
| std::make_unique<MockCamera>(MOCK_DEVICE_ID); |
| |
| std::unique_ptr<MockCaptureController> capture_controller = |
| std::make_unique<MockCaptureController>(); |
| |
| EXPECT_CALL(*camera, HasCameraId(Eq(mock_camera_id))) |
| .Times(1) |
| .WillOnce([cam = camera.get()](int64_t camera_id) { |
| return cam->camera_id_ == camera_id; |
| }); |
| |
| EXPECT_CALL(*camera, |
| HasPendingResultByType(Eq(PendingResultType::kStartRecord))) |
| .Times(1) |
| .WillOnce(Return(false)); |
| |
| EXPECT_CALL(*camera, AddPendingResult(Eq(PendingResultType::kStartRecord), _)) |
| .Times(1) |
| .WillOnce([cam = camera.get()](PendingResultType type, |
| std::unique_ptr<MethodResult<>> result) { |
| cam->pending_result_ = std::move(result); |
| return true; |
| }); |
| |
| EXPECT_CALL(*camera, GetCaptureController) |
| .Times(1) |
| .WillOnce([cam = camera.get()]() { |
| assert(cam->pending_result_); |
| return cam->capture_controller_.get(); |
| }); |
| |
| EXPECT_CALL(*capture_controller, |
| StartRecord(EndsWith(".mp4"), Eq(mock_video_duration))) |
| .Times(1) |
| .WillOnce([cam = camera.get()](const std::string& file_path, |
| int64_t max_video_duration_ms) { |
| assert(cam->pending_result_); |
| return cam->pending_result_->Success(); |
| }); |
| |
| camera->camera_id_ = mock_camera_id; |
| camera->capture_controller_ = std::move(capture_controller); |
| |
| MockCameraPlugin plugin(std::make_unique<MockTextureRegistrar>().get(), |
| std::make_unique<MockBinaryMessenger>().get(), |
| std::make_unique<MockCameraFactory>()); |
| |
| // Add mocked camera to plugins camera list. |
| plugin.AddCamera(std::move(camera)); |
| |
| EXPECT_CALL(*initialize_result, ErrorInternal).Times(0); |
| EXPECT_CALL(*initialize_result, SuccessInternal).Times(1); |
| |
| EncodableMap args = { |
| {EncodableValue("cameraId"), EncodableValue(mock_camera_id)}, |
| {EncodableValue("maxVideoDuration"), EncodableValue(mock_video_duration)}, |
| }; |
| |
| plugin.HandleMethodCall( |
| flutter::MethodCall("startVideoRecording", |
| std::make_unique<EncodableValue>(EncodableMap(args))), |
| std::move(initialize_result)); |
| } |
| |
| TEST(CameraPlugin, StartVideoRecordingHandlerErrorOnInvalidCameraId) { |
| int64_t mock_camera_id = 1234; |
| int64_t missing_camera_id = 5678; |
| |
| std::unique_ptr<MockMethodResult> initialize_result = |
| std::make_unique<MockMethodResult>(); |
| |
| std::unique_ptr<MockCamera> camera = |
| std::make_unique<MockCamera>(MOCK_DEVICE_ID); |
| |
| std::unique_ptr<MockCaptureController> capture_controller = |
| std::make_unique<MockCaptureController>(); |
| |
| EXPECT_CALL(*camera, HasCameraId) |
| .Times(1) |
| .WillOnce([cam = camera.get()](int64_t camera_id) { |
| return cam->camera_id_ == camera_id; |
| }); |
| |
| EXPECT_CALL(*camera, HasPendingResultByType).Times(0); |
| EXPECT_CALL(*camera, AddPendingResult).Times(0); |
| EXPECT_CALL(*camera, GetCaptureController).Times(0); |
| EXPECT_CALL(*capture_controller, StartRecord(_, -1)).Times(0); |
| |
| camera->camera_id_ = mock_camera_id; |
| |
| MockCameraPlugin plugin(std::make_unique<MockTextureRegistrar>().get(), |
| std::make_unique<MockBinaryMessenger>().get(), |
| std::make_unique<MockCameraFactory>()); |
| |
| // Add mocked camera to plugins camera list. |
| plugin.AddCamera(std::move(camera)); |
| |
| EXPECT_CALL(*initialize_result, ErrorInternal).Times(1); |
| EXPECT_CALL(*initialize_result, SuccessInternal).Times(0); |
| |
| EncodableMap args = { |
| {EncodableValue("cameraId"), EncodableValue(missing_camera_id)}, |
| }; |
| |
| plugin.HandleMethodCall( |
| flutter::MethodCall("startVideoRecording", |
| std::make_unique<EncodableValue>(EncodableMap(args))), |
| std::move(initialize_result)); |
| } |
| |
| TEST(CameraPlugin, StopVideoRecordingHandlerCallsStopRecord) { |
| int64_t mock_camera_id = 1234; |
| |
| std::unique_ptr<MockMethodResult> initialize_result = |
| std::make_unique<MockMethodResult>(); |
| |
| std::unique_ptr<MockCamera> camera = |
| std::make_unique<MockCamera>(MOCK_DEVICE_ID); |
| |
| std::unique_ptr<MockCaptureController> capture_controller = |
| std::make_unique<MockCaptureController>(); |
| |
| EXPECT_CALL(*camera, HasCameraId(Eq(mock_camera_id))) |
| .Times(1) |
| .WillOnce([cam = camera.get()](int64_t camera_id) { |
| return cam->camera_id_ == camera_id; |
| }); |
| |
| EXPECT_CALL(*camera, |
| HasPendingResultByType(Eq(PendingResultType::kStopRecord))) |
| .Times(1) |
| .WillOnce(Return(false)); |
| |
| EXPECT_CALL(*camera, AddPendingResult(Eq(PendingResultType::kStopRecord), _)) |
| .Times(1) |
| .WillOnce([cam = camera.get()](PendingResultType type, |
| std::unique_ptr<MethodResult<>> result) { |
| cam->pending_result_ = std::move(result); |
| return true; |
| }); |
| |
| EXPECT_CALL(*camera, GetCaptureController) |
| .Times(1) |
| .WillOnce([cam = camera.get()]() { |
| assert(cam->pending_result_); |
| return cam->capture_controller_.get(); |
| }); |
| |
| EXPECT_CALL(*capture_controller, StopRecord) |
| .Times(1) |
| .WillOnce([cam = camera.get()]() { |
| assert(cam->pending_result_); |
| return cam->pending_result_->Success(); |
| }); |
| |
| camera->camera_id_ = mock_camera_id; |
| camera->capture_controller_ = std::move(capture_controller); |
| |
| MockCameraPlugin plugin(std::make_unique<MockTextureRegistrar>().get(), |
| std::make_unique<MockBinaryMessenger>().get(), |
| std::make_unique<MockCameraFactory>()); |
| |
| // Add mocked camera to plugins camera list. |
| plugin.AddCamera(std::move(camera)); |
| |
| EXPECT_CALL(*initialize_result, ErrorInternal).Times(0); |
| EXPECT_CALL(*initialize_result, SuccessInternal).Times(1); |
| |
| EncodableMap args = { |
| {EncodableValue("cameraId"), EncodableValue(mock_camera_id)}, |
| }; |
| |
| plugin.HandleMethodCall( |
| flutter::MethodCall("stopVideoRecording", |
| std::make_unique<EncodableValue>(EncodableMap(args))), |
| std::move(initialize_result)); |
| } |
| |
| TEST(CameraPlugin, StopVideoRecordingHandlerErrorOnInvalidCameraId) { |
| int64_t mock_camera_id = 1234; |
| int64_t missing_camera_id = 5678; |
| |
| std::unique_ptr<MockMethodResult> initialize_result = |
| std::make_unique<MockMethodResult>(); |
| |
| std::unique_ptr<MockCamera> camera = |
| std::make_unique<MockCamera>(MOCK_DEVICE_ID); |
| |
| std::unique_ptr<MockCaptureController> capture_controller = |
| std::make_unique<MockCaptureController>(); |
| |
| EXPECT_CALL(*camera, HasCameraId) |
| .Times(1) |
| .WillOnce([cam = camera.get()](int64_t camera_id) { |
| return cam->camera_id_ == camera_id; |
| }); |
| |
| EXPECT_CALL(*camera, HasPendingResultByType).Times(0); |
| EXPECT_CALL(*camera, AddPendingResult).Times(0); |
| EXPECT_CALL(*camera, GetCaptureController).Times(0); |
| EXPECT_CALL(*capture_controller, StopRecord).Times(0); |
| |
| camera->camera_id_ = mock_camera_id; |
| |
| MockCameraPlugin plugin(std::make_unique<MockTextureRegistrar>().get(), |
| std::make_unique<MockBinaryMessenger>().get(), |
| std::make_unique<MockCameraFactory>()); |
| |
| // Add mocked camera to plugins camera list. |
| plugin.AddCamera(std::move(camera)); |
| |
| EXPECT_CALL(*initialize_result, ErrorInternal).Times(1); |
| EXPECT_CALL(*initialize_result, SuccessInternal).Times(0); |
| |
| EncodableMap args = { |
| {EncodableValue("cameraId"), EncodableValue(missing_camera_id)}, |
| }; |
| |
| plugin.HandleMethodCall( |
| flutter::MethodCall("stopVideoRecording", |
| std::make_unique<EncodableValue>(EncodableMap(args))), |
| std::move(initialize_result)); |
| } |
| |
| TEST(CameraPlugin, ResumePreviewHandlerCallsResumePreview) { |
| int64_t mock_camera_id = 1234; |
| |
| std::unique_ptr<MockMethodResult> initialize_result = |
| std::make_unique<MockMethodResult>(); |
| |
| std::unique_ptr<MockCamera> camera = |
| std::make_unique<MockCamera>(MOCK_DEVICE_ID); |
| |
| std::unique_ptr<MockCaptureController> capture_controller = |
| std::make_unique<MockCaptureController>(); |
| |
| EXPECT_CALL(*camera, HasCameraId(Eq(mock_camera_id))) |
| .Times(1) |
| .WillOnce([cam = camera.get()](int64_t camera_id) { |
| return cam->camera_id_ == camera_id; |
| }); |
| |
| EXPECT_CALL(*camera, |
| HasPendingResultByType(Eq(PendingResultType::kResumePreview))) |
| .Times(1) |
| .WillOnce(Return(false)); |
| |
| EXPECT_CALL(*camera, |
| AddPendingResult(Eq(PendingResultType::kResumePreview), _)) |
| .Times(1) |
| .WillOnce([cam = camera.get()](PendingResultType type, |
| std::unique_ptr<MethodResult<>> result) { |
| cam->pending_result_ = std::move(result); |
| return true; |
| }); |
| |
| EXPECT_CALL(*camera, GetCaptureController) |
| .Times(1) |
| .WillOnce([cam = camera.get()]() { |
| assert(cam->pending_result_); |
| return cam->capture_controller_.get(); |
| }); |
| |
| EXPECT_CALL(*capture_controller, ResumePreview) |
| .Times(1) |
| .WillOnce([cam = camera.get()]() { |
| assert(cam->pending_result_); |
| return cam->pending_result_->Success(); |
| }); |
| |
| camera->camera_id_ = mock_camera_id; |
| camera->capture_controller_ = std::move(capture_controller); |
| |
| MockCameraPlugin plugin(std::make_unique<MockTextureRegistrar>().get(), |
| std::make_unique<MockBinaryMessenger>().get(), |
| std::make_unique<MockCameraFactory>()); |
| |
| // Add mocked camera to plugins camera list. |
| plugin.AddCamera(std::move(camera)); |
| |
| EXPECT_CALL(*initialize_result, ErrorInternal).Times(0); |
| EXPECT_CALL(*initialize_result, SuccessInternal).Times(1); |
| |
| EncodableMap args = { |
| {EncodableValue("cameraId"), EncodableValue(mock_camera_id)}, |
| }; |
| |
| plugin.HandleMethodCall( |
| flutter::MethodCall("resumePreview", |
| std::make_unique<EncodableValue>(EncodableMap(args))), |
| std::move(initialize_result)); |
| } |
| |
| TEST(CameraPlugin, ResumePreviewHandlerErrorOnInvalidCameraId) { |
| int64_t mock_camera_id = 1234; |
| int64_t missing_camera_id = 5678; |
| |
| std::unique_ptr<MockMethodResult> initialize_result = |
| std::make_unique<MockMethodResult>(); |
| |
| std::unique_ptr<MockCamera> camera = |
| std::make_unique<MockCamera>(MOCK_DEVICE_ID); |
| |
| std::unique_ptr<MockCaptureController> capture_controller = |
| std::make_unique<MockCaptureController>(); |
| |
| EXPECT_CALL(*camera, HasCameraId) |
| .Times(1) |
| .WillOnce([cam = camera.get()](int64_t camera_id) { |
| return cam->camera_id_ == camera_id; |
| }); |
| |
| EXPECT_CALL(*camera, HasPendingResultByType).Times(0); |
| EXPECT_CALL(*camera, AddPendingResult).Times(0); |
| EXPECT_CALL(*camera, GetCaptureController).Times(0); |
| EXPECT_CALL(*capture_controller, ResumePreview).Times(0); |
| |
| camera->camera_id_ = mock_camera_id; |
| |
| MockCameraPlugin plugin(std::make_unique<MockTextureRegistrar>().get(), |
| std::make_unique<MockBinaryMessenger>().get(), |
| std::make_unique<MockCameraFactory>()); |
| |
| // Add mocked camera to plugins camera list. |
| plugin.AddCamera(std::move(camera)); |
| |
| EXPECT_CALL(*initialize_result, ErrorInternal).Times(1); |
| EXPECT_CALL(*initialize_result, SuccessInternal).Times(0); |
| |
| EncodableMap args = { |
| {EncodableValue("cameraId"), EncodableValue(missing_camera_id)}, |
| }; |
| |
| plugin.HandleMethodCall( |
| flutter::MethodCall("resumePreview", |
| std::make_unique<EncodableValue>(EncodableMap(args))), |
| std::move(initialize_result)); |
| } |
| |
| TEST(CameraPlugin, PausePreviewHandlerCallsPausePreview) { |
| int64_t mock_camera_id = 1234; |
| |
| std::unique_ptr<MockMethodResult> initialize_result = |
| std::make_unique<MockMethodResult>(); |
| |
| std::unique_ptr<MockCamera> camera = |
| std::make_unique<MockCamera>(MOCK_DEVICE_ID); |
| |
| std::unique_ptr<MockCaptureController> capture_controller = |
| std::make_unique<MockCaptureController>(); |
| |
| EXPECT_CALL(*camera, HasCameraId(Eq(mock_camera_id))) |
| .Times(1) |
| .WillOnce([cam = camera.get()](int64_t camera_id) { |
| return cam->camera_id_ == camera_id; |
| }); |
| |
| EXPECT_CALL(*camera, |
| HasPendingResultByType(Eq(PendingResultType::kPausePreview))) |
| .Times(1) |
| .WillOnce(Return(false)); |
| |
| EXPECT_CALL(*camera, |
| AddPendingResult(Eq(PendingResultType::kPausePreview), _)) |
| .Times(1) |
| .WillOnce([cam = camera.get()](PendingResultType type, |
| std::unique_ptr<MethodResult<>> result) { |
| cam->pending_result_ = std::move(result); |
| return true; |
| }); |
| |
| EXPECT_CALL(*camera, GetCaptureController) |
| .Times(1) |
| .WillOnce([cam = camera.get()]() { |
| assert(cam->pending_result_); |
| return cam->capture_controller_.get(); |
| }); |
| |
| EXPECT_CALL(*capture_controller, PausePreview) |
| .Times(1) |
| .WillOnce([cam = camera.get()]() { |
| assert(cam->pending_result_); |
| return cam->pending_result_->Success(); |
| }); |
| |
| camera->camera_id_ = mock_camera_id; |
| camera->capture_controller_ = std::move(capture_controller); |
| |
| MockCameraPlugin plugin(std::make_unique<MockTextureRegistrar>().get(), |
| std::make_unique<MockBinaryMessenger>().get(), |
| std::make_unique<MockCameraFactory>()); |
| |
| // Add mocked camera to plugins camera list. |
| plugin.AddCamera(std::move(camera)); |
| |
| EXPECT_CALL(*initialize_result, ErrorInternal).Times(0); |
| EXPECT_CALL(*initialize_result, SuccessInternal).Times(1); |
| |
| EncodableMap args = { |
| {EncodableValue("cameraId"), EncodableValue(mock_camera_id)}, |
| }; |
| |
| plugin.HandleMethodCall( |
| flutter::MethodCall("pausePreview", |
| std::make_unique<EncodableValue>(EncodableMap(args))), |
| std::move(initialize_result)); |
| } |
| |
| TEST(CameraPlugin, PausePreviewHandlerErrorOnInvalidCameraId) { |
| int64_t mock_camera_id = 1234; |
| int64_t missing_camera_id = 5678; |
| |
| std::unique_ptr<MockMethodResult> initialize_result = |
| std::make_unique<MockMethodResult>(); |
| |
| std::unique_ptr<MockCamera> camera = |
| std::make_unique<MockCamera>(MOCK_DEVICE_ID); |
| |
| std::unique_ptr<MockCaptureController> capture_controller = |
| std::make_unique<MockCaptureController>(); |
| |
| EXPECT_CALL(*camera, HasCameraId) |
| .Times(1) |
| .WillOnce([cam = camera.get()](int64_t camera_id) { |
| return cam->camera_id_ == camera_id; |
| }); |
| |
| EXPECT_CALL(*camera, HasPendingResultByType).Times(0); |
| EXPECT_CALL(*camera, AddPendingResult).Times(0); |
| EXPECT_CALL(*camera, GetCaptureController).Times(0); |
| EXPECT_CALL(*capture_controller, PausePreview).Times(0); |
| |
| camera->camera_id_ = mock_camera_id; |
| |
| MockCameraPlugin plugin(std::make_unique<MockTextureRegistrar>().get(), |
| std::make_unique<MockBinaryMessenger>().get(), |
| std::make_unique<MockCameraFactory>()); |
| |
| // Add mocked camera to plugins camera list. |
| plugin.AddCamera(std::move(camera)); |
| |
| EXPECT_CALL(*initialize_result, ErrorInternal).Times(1); |
| EXPECT_CALL(*initialize_result, SuccessInternal).Times(0); |
| |
| EncodableMap args = { |
| {EncodableValue("cameraId"), EncodableValue(missing_camera_id)}, |
| }; |
| |
| plugin.HandleMethodCall( |
| flutter::MethodCall("pausePreview", |
| std::make_unique<EncodableValue>(EncodableMap(args))), |
| std::move(initialize_result)); |
| } |
| |
| } // namespace test |
| } // namespace camera_windows |
