cpp/evs/manager/aidl/wrappers/src/AidlCamera.cpp - platform/packages/services/Car - Git at Google

 /*
  * Copyright (C) 2022 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 "AidlCamera.h"

 #include "HidlDisplay.h"
 #include "utils/include/Utils.h"

 #include <android-base/logging.h>

 namespace aidl::android::automotive::evs::implementation {

 namespace hidlevs = ::android::hardware::automotive::evs;

 using ::aidl::android::hardware::automotive::evs::BufferDesc;
 using ::aidl::android::hardware::automotive::evs::CameraDesc;
 using ::aidl::android::hardware::automotive::evs::CameraParam;
 using ::aidl::android::hardware::automotive::evs::DisplayState;
 using ::aidl::android::hardware::automotive::evs::EvsEventDesc;
 using ::aidl::android::hardware::automotive::evs::EvsEventType;
 using ::aidl::android::hardware::automotive::evs::EvsResult;
 using ::aidl::android::hardware::automotive::evs::IEvsCameraStream;
 using ::aidl::android::hardware::automotive::evs::IEvsDisplay;
 using ::aidl::android::hardware::automotive::evs::ParameterRange;
 using ::android::hardware::hidl_vec;
 using ::ndk::ScopedAStatus;

 AidlCamera::AidlCamera(const ::android::sp<hidlevs::V1_0::IEvsCamera>& hidlCamera, bool forceV1_0) {
     auto hidlCameraV1 = hidlevs::V1_1::IEvsCamera::castFrom(hidlCamera).withDefault(nullptr);
     if (forceV1_0 || !hidlCameraV1) {
         // AidlCamera is initialized in V1_0::IEvsCamera support mode in below
         // three conditions:
         // 1. A given camera object is an implementation of V1_0::IEvsCamera
         //    (fails to upcast as V1_1::IEvsCamera).
         // 2. A caller explicitly creates AidlCamera object in V1_0::IEvsCamera
         //    mode by setting forceV1_0 as true.
         // 3. Or, A given camera object is invalid (nullptr).
         mImpl = std::make_shared<ImplV0>(hidlCamera);
     } else {
         mImpl = std::make_shared<ImplV1>(hidlCameraV1);
     }
 }

 const ::android::sp<hidlevs::V1_0::IEvsCamera> AidlCamera::getHidlCamera() const {
     return mImpl->getHidlCamera();
 }

 ScopedAStatus AidlCamera::doneWithFrame(const std::vector<BufferDesc>& buffers) {
     return mImpl->doneWithFrame(buffers);
 }

 ScopedAStatus AidlCamera::forcePrimaryClient(const std::shared_ptr<IEvsDisplay>& display) {
     return mImpl->forcePrimaryClient(display);
 }

 ScopedAStatus AidlCamera::getCameraInfo(CameraDesc* _aidl_return) {
     return mImpl->getCameraInfo(_aidl_return);
 }

 ScopedAStatus AidlCamera::getExtendedInfo(int32_t opaqueIdentifier, std::vector<uint8_t>* value) {
     return mImpl->getExtendedInfo(opaqueIdentifier, value);
 }

 ScopedAStatus AidlCamera::getIntParameter(CameraParam id, std::vector<int32_t>* value) {
     return mImpl->getIntParameter(id, value);
 }

 ScopedAStatus AidlCamera::getIntParameterRange(CameraParam id, ParameterRange* _aidl_return) {
     return mImpl->getIntParameterRange(id, _aidl_return);
 }

 ScopedAStatus AidlCamera::getParameterList(std::vector<CameraParam>* _aidl_return) {
     return mImpl->getParameterList(_aidl_return);
 }

 ScopedAStatus AidlCamera::getPhysicalCameraInfo(const std::string& deviceId,
                                                 CameraDesc* _aidl_return) {
     return mImpl->getPhysicalCameraInfo(deviceId, _aidl_return);
 }

 ScopedAStatus AidlCamera::importExternalBuffers(const std::vector<BufferDesc>& buffers,
                                                 int32_t* _aidl_return) {
     return mImpl->importExternalBuffers(buffers, _aidl_return);
 }

 ScopedAStatus AidlCamera::pauseVideoStream() {
     return mImpl->pauseVideoStream();
 }

 ScopedAStatus AidlCamera::resumeVideoStream() {
     return mImpl->resumeVideoStream();
 }

 ScopedAStatus AidlCamera::setExtendedInfo(int32_t opaqueIdentifier,
                                           const std::vector<uint8_t>& opaqueValue) {
     return mImpl->setExtendedInfo(opaqueIdentifier, opaqueValue);
 }

 ScopedAStatus AidlCamera::setIntParameter(CameraParam id, int32_t value,
                                           std::vector<int32_t>* effectiveValue) {
     return mImpl->setIntParameter(id, value, effectiveValue);
 }

 ScopedAStatus AidlCamera::setPrimaryClient() {
     return mImpl->setPrimaryClient();
 }

 ScopedAStatus AidlCamera::setMaxFramesInFlight(int32_t bufferCount) {
     return mImpl->setMaxFramesInFlight(bufferCount);
 }

 ScopedAStatus AidlCamera::startVideoStream(const std::shared_ptr<IEvsCameraStream>& listener) {
     return mImpl->startVideoStream(listener);
 }

 ScopedAStatus AidlCamera::stopVideoStream() {
     return mImpl->stopVideoStream();
 }

 ScopedAStatus AidlCamera::unsetPrimaryClient() {
     return mImpl->unsetPrimaryClient();
 }

 AidlCamera::ImplV0::ImplV0(const ::android::sp<hidlevs::V1_0::IEvsCamera>& camera) :
       IHidlCamera(camera) {
     if (!camera) {
         LOG(WARNING) << "AidlCamera object is instantiated with an invalid IEvsCamera object.";
         return;
     }

     // Because android::hardware::automotive::evs::V1_0::BufferDesc does not
     // contain a device id while it is required to handle received frames
     // properly, we are retrieving it from the camera descriptor and store
     // locally.
     camera->getCameraInfo([this](const auto& read) { mId = read.cameraId; });
 }

 ScopedAStatus AidlCamera::ImplV0::doneWithFrame(const std::vector<BufferDesc>& buffers) {
     if (!mHidlStream) {
         LOG(WARNING) << "Ignores a request to return a buffer of an invalid HIDL camera stream";
         return ScopedAStatus::ok();
     }

     hidlevs::V1_0::BufferDesc hidlBuffer;
     if (mHidlStream->getHidlBuffer(buffers[0].bufferId, &hidlBuffer)) {
         mHidlCamera->doneWithFrame(hidlBuffer);
     }

     return ScopedAStatus::ok();
 }

 ScopedAStatus AidlCamera::ImplV0::forcePrimaryClient(
         [[maybe_unused]] const std::shared_ptr<IEvsDisplay>& display) {
     return Utils::buildScopedAStatusFromEvsResult(EvsResult::NOT_SUPPORTED);
 }

 ScopedAStatus AidlCamera::ImplV0::getCameraInfo(CameraDesc* _aidl_return) {
     if (!mHidlCamera) {
         LOG(ERROR) << "HIDL camera is not valid";
         return Utils::buildScopedAStatusFromEvsResult(EvsResult::RESOURCE_NOT_AVAILABLE);
     }

     (void)mHidlCamera->getCameraInfo(
             [_aidl_return](auto& desc) { *_aidl_return = std::move(Utils::makeFromHidl(desc)); });

     return ScopedAStatus::ok();
 }

 ScopedAStatus AidlCamera::ImplV0::getExtendedInfo(int32_t opaqueIdentifier,
                                                   std::vector<uint8_t>* value) {
     if (!mHidlCamera) {
         LOG(ERROR) << "HIDL camera is not valid";
         return Utils::buildScopedAStatusFromEvsResult(EvsResult::RESOURCE_NOT_AVAILABLE);
     }

     int32_t hidlValue = mHidlCamera->getExtendedInfo(opaqueIdentifier);
     value->resize(sizeof(hidlValue));
     int* p = reinterpret_cast<int*>(value->data());
     *p = hidlValue;
     return ScopedAStatus::ok();
 }

 ScopedAStatus AidlCamera::ImplV0::getIntParameter(CameraParam /*id*/,
                                                   std::vector<int32_t>* /*value*/) {
     return Utils::buildScopedAStatusFromEvsResult(EvsResult::NOT_SUPPORTED);
 }

 ScopedAStatus AidlCamera::ImplV0::getIntParameterRange(CameraParam /*id*/,
                                                        ParameterRange* /*_aidl_return*/) {
     return Utils::buildScopedAStatusFromEvsResult(EvsResult::NOT_SUPPORTED);
 }

 ScopedAStatus AidlCamera::ImplV0::getParameterList(std::vector<CameraParam>* /*_aidl_return*/) {
     return Utils::buildScopedAStatusFromEvsResult(EvsResult::NOT_SUPPORTED);
 }

 ScopedAStatus AidlCamera::ImplV0::getPhysicalCameraInfo(const std::string& /*deviceId*/,
                                                         CameraDesc* /*_aidl_return*/) {
     return Utils::buildScopedAStatusFromEvsResult(EvsResult::NOT_SUPPORTED);
 }

 ScopedAStatus AidlCamera::ImplV0::importExternalBuffers(const std::vector<BufferDesc>& /*buffers*/,
                                                         int32_t* /*_aidl_return*/) {
     return Utils::buildScopedAStatusFromEvsResult(EvsResult::NOT_SUPPORTED);
 }

 ScopedAStatus AidlCamera::ImplV0::pauseVideoStream() {
     return Utils::buildScopedAStatusFromEvsResult(EvsResult::NOT_SUPPORTED);
 }

 ScopedAStatus AidlCamera::ImplV0::resumeVideoStream() {
     return Utils::buildScopedAStatusFromEvsResult(EvsResult::NOT_SUPPORTED);
 }

 ScopedAStatus AidlCamera::ImplV0::setExtendedInfo(int32_t opaqueIdentifier,
                                                   const std::vector<uint8_t>& opaqueValue) {
     if (opaqueValue.size() < sizeof(int32_t)) {
         return Utils::buildScopedAStatusFromEvsResult(EvsResult::INVALID_ARG);
     }

     int32_t v = *(reinterpret_cast<const int32_t*>(opaqueValue.data()));
     return Utils::buildScopedAStatusFromEvsResult(
             mHidlCamera->setExtendedInfo(opaqueIdentifier, v));
 }

 ScopedAStatus AidlCamera::ImplV0::setIntParameter(CameraParam /*id*/, int32_t /*value*/,
                                                   std::vector<int32_t>* /*effectiveValue*/) {
     return Utils::buildScopedAStatusFromEvsResult(EvsResult::NOT_SUPPORTED);
 }

 ScopedAStatus AidlCamera::ImplV0::setPrimaryClient() {
     return Utils::buildScopedAStatusFromEvsResult(EvsResult::NOT_SUPPORTED);
 }

 ScopedAStatus AidlCamera::ImplV0::setMaxFramesInFlight(int32_t bufferCount) {
     if (!mHidlCamera) {
         LOG(ERROR) << "HIDL camera is not valid";
         return Utils::buildScopedAStatusFromEvsResult(EvsResult::RESOURCE_NOT_AVAILABLE);
     }

     return Utils::buildScopedAStatusFromEvsResult(mHidlCamera->setMaxFramesInFlight(bufferCount));
 }

 ScopedAStatus AidlCamera::ImplV0::startVideoStream(
         const std::shared_ptr<IEvsCameraStream>& listener) {
     if (!listener) {
         return Utils::buildScopedAStatusFromEvsResult(EvsResult::INVALID_ARG);
     } else if (mHidlStream) {
         return Utils::buildScopedAStatusFromEvsResult(EvsResult::STREAM_ALREADY_RUNNING);
     }

     // Creates a wrapper object and requests a video stream
     mHidlStream = new (std::nothrow) HidlCameraStream(mId, listener);
     return Utils::buildScopedAStatusFromEvsResult(mHidlCamera->startVideoStream(mHidlStream));
 }

 ScopedAStatus AidlCamera::ImplV0::stopVideoStream() {
     if (!mHidlStream) {
         return ScopedAStatus::ok();
     }

     mHidlCamera->stopVideoStream();
     mHidlStream = nullptr;
     return ScopedAStatus::ok();
 }

 ScopedAStatus AidlCamera::ImplV0::unsetPrimaryClient() {
     return Utils::buildScopedAStatusFromEvsResult(EvsResult::NOT_SUPPORTED);
 }

 AidlCamera::ImplV1::ImplV1(const ::android::sp<hidlevs::V1_1::IEvsCamera>& camera) :
       IHidlCamera(camera), mHidlCamera(camera) {
     if (!camera) {
         LOG(WARNING) << "AidlCamera object is instantiated with an invalid IEvsCamera object.";
         return;
     }

     camera->getCameraInfo_1_1([this](const auto& read) { mId = read.v1.cameraId; });
 }

 ScopedAStatus AidlCamera::ImplV1::doneWithFrame(const std::vector<BufferDesc>& buffers) {
     if (!mHidlStream) {
         LOG(WARNING) << "Ignores a request to return a buffer of an invalid HIDL camera stream";
         return ScopedAStatus::ok();
     }

     const auto n = buffers.size();
     hidl_vec<hidlevs::V1_1::BufferDesc> hidlBuffers(n);
     for (auto i = 0; i < n; ++i) {
         hidlevs::V1_1::BufferDesc buffer;
         if (mHidlStream->getHidlBuffer(buffers[i].bufferId, &buffer)) {
             hidlBuffers[i] = std::move(buffer);
         }
     }

     mHidlCamera->doneWithFrame_1_1(hidlBuffers);
     return ScopedAStatus::ok();
 }

 ScopedAStatus AidlCamera::ImplV1::forcePrimaryClient(const std::shared_ptr<IEvsDisplay>& display) {
     if (!mHidlCamera) {
         return Utils::buildScopedAStatusFromEvsResult(EvsResult::NOT_SUPPORTED);
     }

     return Utils::buildScopedAStatusFromEvsResult(
             mHidlCamera->forceMaster(new HidlDisplay(display)));
 }

 ScopedAStatus AidlCamera::ImplV1::getCameraInfo(CameraDesc* _aidl_return) {
     if (!mHidlCamera) {
         return Utils::buildScopedAStatusFromEvsResult(EvsResult::RESOURCE_NOT_AVAILABLE);
     }

     (void)mHidlCamera->getCameraInfo_1_1(
             [_aidl_return](auto& desc) { *_aidl_return = std::move(Utils::makeFromHidl(desc)); });

     return ScopedAStatus::ok();
 }

 ScopedAStatus AidlCamera::ImplV1::getExtendedInfo(int32_t opaqueIdentifier,
                                                   std::vector<uint8_t>* value) {
     if (!mHidlCamera) {
         return Utils::buildScopedAStatusFromEvsResult(EvsResult::RESOURCE_NOT_AVAILABLE);
     }

     hidlevs::V1_0::EvsResult hidlStatus = hidlevs::V1_0::EvsResult::OK;
     (void)mHidlCamera->getExtendedInfo_1_1(opaqueIdentifier,
                                            [&hidlStatus, value](auto status,
                                                                 const hidl_vec<uint8_t>& hwValue) {
                                                hidlStatus = status;
                                                *value = hwValue;
                                            });
     return Utils::buildScopedAStatusFromEvsResult(hidlStatus);
 }

 ScopedAStatus AidlCamera::ImplV1::getIntParameter(CameraParam id, std::vector<int32_t>* value) {
     if (!mHidlCamera) {
         return Utils::buildScopedAStatusFromEvsResult(EvsResult::RESOURCE_NOT_AVAILABLE);
     }

     hidlevs::V1_0::EvsResult hidlStatus = hidlevs::V1_0::EvsResult::OK;
     (void)mHidlCamera->getIntParameter(Utils::makeToHidl(id),
                                        [&hidlStatus, value](auto status,
                                                             const hidl_vec<int32_t>& hidlValues) {
                                            hidlStatus = status;
                                            *value = hidlValues;
                                        });
     return Utils::buildScopedAStatusFromEvsResult(hidlStatus);
 }

 ScopedAStatus AidlCamera::ImplV1::getIntParameterRange(CameraParam id,
                                                        ParameterRange* _aidl_return) {
     if (!mHidlCamera) {
         return Utils::buildScopedAStatusFromEvsResult(EvsResult::RESOURCE_NOT_AVAILABLE);
     }

     (void)mHidlCamera->getIntParameterRange(Utils::makeToHidl(id),
                                             [_aidl_return](auto min, auto max, auto step) {
                                                 _aidl_return->min = min;
                                                 _aidl_return->max = max;
                                                 _aidl_return->step = step;
                                             });
     return ScopedAStatus::ok();
 }

 ScopedAStatus AidlCamera::ImplV1::getParameterList(std::vector<CameraParam>* _aidl_return) {
     if (!mHidlCamera) {
         return Utils::buildScopedAStatusFromEvsResult(EvsResult::RESOURCE_NOT_AVAILABLE);
     }

     (void)mHidlCamera->getParameterList(
             [_aidl_return](const hidl_vec<hidlevs::V1_1::CameraParam>& list) {
                 _aidl_return->reserve(list.size());
                 for (auto i = 0; i < list.size(); ++i) {
                     _aidl_return->push_back(std::move(Utils::makeFromHidl(list[i])));
                 }
             });
     return ScopedAStatus::ok();
 }

 ScopedAStatus AidlCamera::ImplV1::getPhysicalCameraInfo(const std::string& deviceId,
                                                         CameraDesc* _aidl_return) {
     if (!mHidlCamera) {
         return Utils::buildScopedAStatusFromEvsResult(EvsResult::RESOURCE_NOT_AVAILABLE);
     }

     (void)mHidlCamera->getPhysicalCameraInfo(deviceId, [_aidl_return](const auto& hidlDesc) {
         *_aidl_return = std::move(Utils::makeFromHidl(hidlDesc));
     });
     return ScopedAStatus::ok();
 }

 ScopedAStatus AidlCamera::ImplV1::importExternalBuffers(const std::vector<BufferDesc>& buffers,
                                                         int32_t* _aidl_return) {
     if (!mHidlCamera) {
         return Utils::buildScopedAStatusFromEvsResult(EvsResult::RESOURCE_NOT_AVAILABLE);
     }

     hidl_vec<hidlevs::V1_1::BufferDesc> hidlBuffers;
     hidlBuffers.resize(buffers.size());
     for (auto i = 0; i < buffers.size(); ++i) {
         hidlBuffers[i] = std::move(Utils::makeToHidlV1_1(buffers[i]));
     }
     hidlevs::V1_0::EvsResult hidlStatus = hidlevs::V1_0::EvsResult::OK;
     (void)mHidlCamera->importExternalBuffers(hidlBuffers,
                                              [&hidlStatus, _aidl_return](auto status, auto delta) {
                                                  hidlStatus = status;
                                                  *_aidl_return = delta;
                                              });
     return Utils::buildScopedAStatusFromEvsResult(hidlStatus);
 }

 ScopedAStatus AidlCamera::ImplV1::pauseVideoStream() {
     if (!mHidlCamera) {
         return Utils::buildScopedAStatusFromEvsResult(EvsResult::RESOURCE_NOT_AVAILABLE);
     }
     return Utils::buildScopedAStatusFromEvsResult(mHidlCamera->pauseVideoStream());
 }

 ScopedAStatus AidlCamera::ImplV1::resumeVideoStream() {
     if (!mHidlCamera) {
         return Utils::buildScopedAStatusFromEvsResult(EvsResult::RESOURCE_NOT_AVAILABLE);
     }
     return Utils::buildScopedAStatusFromEvsResult(mHidlCamera->resumeVideoStream());
 }

 ScopedAStatus AidlCamera::ImplV1::setExtendedInfo(int32_t opaqueIdentifier,
                                                   const std::vector<uint8_t>& opaqueValue) {
     if (!mHidlCamera) {
         return Utils::buildScopedAStatusFromEvsResult(EvsResult::RESOURCE_NOT_AVAILABLE);
     }

     hidl_vec<uint8_t> value = opaqueValue;
     hidlevs::V1_0::EvsResult hidlStatus = mHidlCamera->setExtendedInfo_1_1(opaqueIdentifier, value);

     return Utils::buildScopedAStatusFromEvsResult(hidlStatus);
 }

 ScopedAStatus AidlCamera::ImplV1::setIntParameter(CameraParam id, int32_t value,
                                                   std::vector<int32_t>* effectiveValue) {
     if (!mHidlCamera) {
         return Utils::buildScopedAStatusFromEvsResult(EvsResult::RESOURCE_NOT_AVAILABLE);
     }

     hidlevs::V1_0::EvsResult hidlStatus = hidlevs::V1_0::EvsResult::OK;
     (void)mHidlCamera->setIntParameter(Utils::makeToHidl(id), value,
                                        [&hidlStatus,
                                         &effectiveValue](auto status,
                                                          const hidl_vec<int32_t>& values) {
                                            hidlStatus = status;
                                            *effectiveValue = values;
                                        });
     return Utils::buildScopedAStatusFromEvsResult(hidlStatus);
 }

 ScopedAStatus AidlCamera::ImplV1::setPrimaryClient() {
     if (!mHidlCamera) {
         return Utils::buildScopedAStatusFromEvsResult(EvsResult::RESOURCE_NOT_AVAILABLE);
     }

     return Utils::buildScopedAStatusFromEvsResult(mHidlCamera->setMaster());
 }

 ScopedAStatus AidlCamera::ImplV1::setMaxFramesInFlight(int32_t bufferCount) {
     if (!mHidlCamera) {
         return Utils::buildScopedAStatusFromEvsResult(EvsResult::RESOURCE_NOT_AVAILABLE);
     }

     return Utils::buildScopedAStatusFromEvsResult(mHidlCamera->setMaxFramesInFlight(bufferCount));
 }

 ScopedAStatus AidlCamera::ImplV1::startVideoStream(
         const std::shared_ptr<IEvsCameraStream>& listener) {
     if (!listener) {
         return Utils::buildScopedAStatusFromEvsResult(EvsResult::INVALID_ARG);
     } else if (mHidlStream) {
         return Utils::buildScopedAStatusFromEvsResult(EvsResult::STREAM_ALREADY_RUNNING);
     }

     // Creates a wrapper object and requests a video stream
     mHidlStream = new (std::nothrow) HidlCameraStream(mId, listener);
     return Utils::buildScopedAStatusFromEvsResult(mHidlCamera->startVideoStream(mHidlStream));
 }

 ScopedAStatus AidlCamera::ImplV1::stopVideoStream() {
     if (!mHidlStream) {
         return ScopedAStatus::ok();
     }

     mHidlCamera->stopVideoStream();
     mHidlStream = nullptr;
     return ScopedAStatus::ok();
 }

 ScopedAStatus AidlCamera::ImplV1::unsetPrimaryClient() {
     if (!mHidlCamera) {
         return Utils::buildScopedAStatusFromEvsResult(EvsResult::RESOURCE_NOT_AVAILABLE);
     }

     return Utils::buildScopedAStatusFromEvsResult(mHidlCamera->unsetMaster());
 }

 }  // namespace aidl::android::automotive::evs::implementation
	/*
	* Copyright (C) 2022 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 "AidlCamera.h"

	#include "HidlDisplay.h"
	#include "utils/include/Utils.h"

	#include <android-base/logging.h>

	namespace aidl::android::automotive::evs::implementation {

	namespace hidlevs = ::android::hardware::automotive::evs;

	using ::aidl::android::hardware::automotive::evs::BufferDesc;
	using ::aidl::android::hardware::automotive::evs::CameraDesc;
	using ::aidl::android::hardware::automotive::evs::CameraParam;
	using ::aidl::android::hardware::automotive::evs::DisplayState;
	using ::aidl::android::hardware::automotive::evs::EvsEventDesc;
	using ::aidl::android::hardware::automotive::evs::EvsEventType;
	using ::aidl::android::hardware::automotive::evs::EvsResult;
	using ::aidl::android::hardware::automotive::evs::IEvsCameraStream;
	using ::aidl::android::hardware::automotive::evs::IEvsDisplay;
	using ::aidl::android::hardware::automotive::evs::ParameterRange;
	using ::android::hardware::hidl_vec;
	using ::ndk::ScopedAStatus;

	AidlCamera::AidlCamera(const ::android::sp<hidlevs::V1_0::IEvsCamera>& hidlCamera, bool forceV1_0) {
	auto hidlCameraV1 = hidlevs::V1_1::IEvsCamera::castFrom(hidlCamera).withDefault(nullptr);
	if (forceV1_0 \|\| !hidlCameraV1) {
	// AidlCamera is initialized in V1_0::IEvsCamera support mode in below
	// three conditions:
	// 1. A given camera object is an implementation of V1_0::IEvsCamera
	// (fails to upcast as V1_1::IEvsCamera).
	// 2. A caller explicitly creates AidlCamera object in V1_0::IEvsCamera
	// mode by setting forceV1_0 as true.
	// 3. Or, A given camera object is invalid (nullptr).
	mImpl = std::make_shared<ImplV0>(hidlCamera);
	} else {
	mImpl = std::make_shared<ImplV1>(hidlCameraV1);
	}
	}

	const ::android::sp<hidlevs::V1_0::IEvsCamera> AidlCamera::getHidlCamera() const {
	return mImpl->getHidlCamera();
	}

	ScopedAStatus AidlCamera::doneWithFrame(const std::vector<BufferDesc>& buffers) {
	return mImpl->doneWithFrame(buffers);
	}

	ScopedAStatus AidlCamera::forcePrimaryClient(const std::shared_ptr<IEvsDisplay>& display) {
	return mImpl->forcePrimaryClient(display);
	}

	ScopedAStatus AidlCamera::getCameraInfo(CameraDesc* _aidl_return) {
	return mImpl->getCameraInfo(_aidl_return);
	}

	ScopedAStatus AidlCamera::getExtendedInfo(int32_t opaqueIdentifier, std::vector<uint8_t>* value) {
	return mImpl->getExtendedInfo(opaqueIdentifier, value);
	}

	ScopedAStatus AidlCamera::getIntParameter(CameraParam id, std::vector<int32_t>* value) {
	return mImpl->getIntParameter(id, value);
	}

	ScopedAStatus AidlCamera::getIntParameterRange(CameraParam id, ParameterRange* _aidl_return) {
	return mImpl->getIntParameterRange(id, _aidl_return);
	}

	ScopedAStatus AidlCamera::getParameterList(std::vector<CameraParam>* _aidl_return) {
	return mImpl->getParameterList(_aidl_return);
	}

	ScopedAStatus AidlCamera::getPhysicalCameraInfo(const std::string& deviceId,
	CameraDesc* _aidl_return) {
	return mImpl->getPhysicalCameraInfo(deviceId, _aidl_return);
	}

	ScopedAStatus AidlCamera::importExternalBuffers(const std::vector<BufferDesc>& buffers,
	int32_t* _aidl_return) {
	return mImpl->importExternalBuffers(buffers, _aidl_return);
	}

	ScopedAStatus AidlCamera::pauseVideoStream() {
	return mImpl->pauseVideoStream();
	}

	ScopedAStatus AidlCamera::resumeVideoStream() {
	return mImpl->resumeVideoStream();
	}

	ScopedAStatus AidlCamera::setExtendedInfo(int32_t opaqueIdentifier,
	const std::vector<uint8_t>& opaqueValue) {
	return mImpl->setExtendedInfo(opaqueIdentifier, opaqueValue);
	}

	ScopedAStatus AidlCamera::setIntParameter(CameraParam id, int32_t value,
	std::vector<int32_t>* effectiveValue) {
	return mImpl->setIntParameter(id, value, effectiveValue);
	}

	ScopedAStatus AidlCamera::setPrimaryClient() {
	return mImpl->setPrimaryClient();
	}

	ScopedAStatus AidlCamera::setMaxFramesInFlight(int32_t bufferCount) {
	return mImpl->setMaxFramesInFlight(bufferCount);
	}

	ScopedAStatus AidlCamera::startVideoStream(const std::shared_ptr<IEvsCameraStream>& listener) {
	return mImpl->startVideoStream(listener);
	}

	ScopedAStatus AidlCamera::stopVideoStream() {
	return mImpl->stopVideoStream();
	}

	ScopedAStatus AidlCamera::unsetPrimaryClient() {
	return mImpl->unsetPrimaryClient();
	}

	AidlCamera::ImplV0::ImplV0(const ::android::sp<hidlevs::V1_0::IEvsCamera>& camera) :
	IHidlCamera(camera) {
	if (!camera) {
	LOG(WARNING) << "AidlCamera object is instantiated with an invalid IEvsCamera object.";
	return;
	}

	// Because android::hardware::automotive::evs::V1_0::BufferDesc does not
	// contain a device id while it is required to handle received frames
	// properly, we are retrieving it from the camera descriptor and store
	// locally.
	camera->getCameraInfo([this](const auto& read) { mId = read.cameraId; });
	}

	ScopedAStatus AidlCamera::ImplV0::doneWithFrame(const std::vector<BufferDesc>& buffers) {
	if (!mHidlStream) {
	LOG(WARNING) << "Ignores a request to return a buffer of an invalid HIDL camera stream";
	return ScopedAStatus::ok();
	}

	hidlevs::V1_0::BufferDesc hidlBuffer;
	if (mHidlStream->getHidlBuffer(buffers[0].bufferId, &hidlBuffer)) {
	mHidlCamera->doneWithFrame(hidlBuffer);
	}

	return ScopedAStatus::ok();
	}

	ScopedAStatus AidlCamera::ImplV0::forcePrimaryClient(
	[[maybe_unused]] const std::shared_ptr<IEvsDisplay>& display) {
	return Utils::buildScopedAStatusFromEvsResult(EvsResult::NOT_SUPPORTED);
	}

	ScopedAStatus AidlCamera::ImplV0::getCameraInfo(CameraDesc* _aidl_return) {
	if (!mHidlCamera) {
	LOG(ERROR) << "HIDL camera is not valid";
	return Utils::buildScopedAStatusFromEvsResult(EvsResult::RESOURCE_NOT_AVAILABLE);
	}

	(void)mHidlCamera->getCameraInfo(
	[_aidl_return](auto& desc) { *_aidl_return = std::move(Utils::makeFromHidl(desc)); });

	return ScopedAStatus::ok();
	}

	ScopedAStatus AidlCamera::ImplV0::getExtendedInfo(int32_t opaqueIdentifier,
	std::vector<uint8_t>* value) {
	if (!mHidlCamera) {
	LOG(ERROR) << "HIDL camera is not valid";
	return Utils::buildScopedAStatusFromEvsResult(EvsResult::RESOURCE_NOT_AVAILABLE);
	}

	int32_t hidlValue = mHidlCamera->getExtendedInfo(opaqueIdentifier);
	value->resize(sizeof(hidlValue));
	int* p = reinterpret_cast<int*>(value->data());
	*p = hidlValue;
	return ScopedAStatus::ok();
	}

	ScopedAStatus AidlCamera::ImplV0::getIntParameter(CameraParam /id/,
	std::vector<int32_t>* /value/) {
	return Utils::buildScopedAStatusFromEvsResult(EvsResult::NOT_SUPPORTED);
	}

	ScopedAStatus AidlCamera::ImplV0::getIntParameterRange(CameraParam /id/,
	ParameterRange* /_aidl_return/) {
	return Utils::buildScopedAStatusFromEvsResult(EvsResult::NOT_SUPPORTED);
	}

	ScopedAStatus AidlCamera::ImplV0::getParameterList(std::vector<CameraParam>* /_aidl_return/) {
	return Utils::buildScopedAStatusFromEvsResult(EvsResult::NOT_SUPPORTED);
	}

	ScopedAStatus AidlCamera::ImplV0::getPhysicalCameraInfo(const std::string& /deviceId/,
	CameraDesc* /_aidl_return/) {
	return Utils::buildScopedAStatusFromEvsResult(EvsResult::NOT_SUPPORTED);
	}

	ScopedAStatus AidlCamera::ImplV0::importExternalBuffers(const std::vector<BufferDesc>& /buffers/,
	int32_t* /_aidl_return/) {
	return Utils::buildScopedAStatusFromEvsResult(EvsResult::NOT_SUPPORTED);
	}

	ScopedAStatus AidlCamera::ImplV0::pauseVideoStream() {
	return Utils::buildScopedAStatusFromEvsResult(EvsResult::NOT_SUPPORTED);
	}

	ScopedAStatus AidlCamera::ImplV0::resumeVideoStream() {
	return Utils::buildScopedAStatusFromEvsResult(EvsResult::NOT_SUPPORTED);
	}

	ScopedAStatus AidlCamera::ImplV0::setExtendedInfo(int32_t opaqueIdentifier,
	const std::vector<uint8_t>& opaqueValue) {
	if (opaqueValue.size() < sizeof(int32_t)) {
	return Utils::buildScopedAStatusFromEvsResult(EvsResult::INVALID_ARG);
	}

	int32_t v = (reinterpret_cast<const int32_t>(opaqueValue.data()));
	return Utils::buildScopedAStatusFromEvsResult(
	mHidlCamera->setExtendedInfo(opaqueIdentifier, v));
	}

	ScopedAStatus AidlCamera::ImplV0::setIntParameter(CameraParam /id/, int32_t /value/,
	std::vector<int32_t>* /effectiveValue/) {
	return Utils::buildScopedAStatusFromEvsResult(EvsResult::NOT_SUPPORTED);
	}

	ScopedAStatus AidlCamera::ImplV0::setPrimaryClient() {
	return Utils::buildScopedAStatusFromEvsResult(EvsResult::NOT_SUPPORTED);
	}

	ScopedAStatus AidlCamera::ImplV0::setMaxFramesInFlight(int32_t bufferCount) {
	if (!mHidlCamera) {
	LOG(ERROR) << "HIDL camera is not valid";
	return Utils::buildScopedAStatusFromEvsResult(EvsResult::RESOURCE_NOT_AVAILABLE);
	}

	return Utils::buildScopedAStatusFromEvsResult(mHidlCamera->setMaxFramesInFlight(bufferCount));
	}

	ScopedAStatus AidlCamera::ImplV0::startVideoStream(
	const std::shared_ptr<IEvsCameraStream>& listener) {
	if (!listener) {
	return Utils::buildScopedAStatusFromEvsResult(EvsResult::INVALID_ARG);
	} else if (mHidlStream) {
	return Utils::buildScopedAStatusFromEvsResult(EvsResult::STREAM_ALREADY_RUNNING);
	}

	// Creates a wrapper object and requests a video stream
	mHidlStream = new (std::nothrow) HidlCameraStream(mId, listener);
	return Utils::buildScopedAStatusFromEvsResult(mHidlCamera->startVideoStream(mHidlStream));
	}

	ScopedAStatus AidlCamera::ImplV0::stopVideoStream() {
	if (!mHidlStream) {
	return ScopedAStatus::ok();
	}

	mHidlCamera->stopVideoStream();
	mHidlStream = nullptr;
	return ScopedAStatus::ok();
	}

	ScopedAStatus AidlCamera::ImplV0::unsetPrimaryClient() {
	return Utils::buildScopedAStatusFromEvsResult(EvsResult::NOT_SUPPORTED);
	}

	AidlCamera::ImplV1::ImplV1(const ::android::sp<hidlevs::V1_1::IEvsCamera>& camera) :
	IHidlCamera(camera), mHidlCamera(camera) {
	if (!camera) {
	LOG(WARNING) << "AidlCamera object is instantiated with an invalid IEvsCamera object.";
	return;
	}

	camera->getCameraInfo_1_1([this](const auto& read) { mId = read.v1.cameraId; });
	}

	ScopedAStatus AidlCamera::ImplV1::doneWithFrame(const std::vector<BufferDesc>& buffers) {
	if (!mHidlStream) {
	LOG(WARNING) << "Ignores a request to return a buffer of an invalid HIDL camera stream";
	return ScopedAStatus::ok();
	}

	const auto n = buffers.size();
	hidl_vec<hidlevs::V1_1::BufferDesc> hidlBuffers(n);
	for (auto i = 0; i < n; ++i) {
	hidlevs::V1_1::BufferDesc buffer;
	if (mHidlStream->getHidlBuffer(buffers[i].bufferId, &buffer)) {
	hidlBuffers[i] = std::move(buffer);
	}
	}

	mHidlCamera->doneWithFrame_1_1(hidlBuffers);
	return ScopedAStatus::ok();
	}

	ScopedAStatus AidlCamera::ImplV1::forcePrimaryClient(const std::shared_ptr<IEvsDisplay>& display) {
	if (!mHidlCamera) {
	return Utils::buildScopedAStatusFromEvsResult(EvsResult::NOT_SUPPORTED);
	}

	return Utils::buildScopedAStatusFromEvsResult(
	mHidlCamera->forceMaster(new HidlDisplay(display)));
	}

	ScopedAStatus AidlCamera::ImplV1::getCameraInfo(CameraDesc* _aidl_return) {
	if (!mHidlCamera) {
	return Utils::buildScopedAStatusFromEvsResult(EvsResult::RESOURCE_NOT_AVAILABLE);
	}

	(void)mHidlCamera->getCameraInfo_1_1(
	[_aidl_return](auto& desc) { *_aidl_return = std::move(Utils::makeFromHidl(desc)); });

	return ScopedAStatus::ok();
	}

	ScopedAStatus AidlCamera::ImplV1::getExtendedInfo(int32_t opaqueIdentifier,
	std::vector<uint8_t>* value) {
	if (!mHidlCamera) {
	return Utils::buildScopedAStatusFromEvsResult(EvsResult::RESOURCE_NOT_AVAILABLE);
	}

	hidlevs::V1_0::EvsResult hidlStatus = hidlevs::V1_0::EvsResult::OK;
	(void)mHidlCamera->getExtendedInfo_1_1(opaqueIdentifier,
	[&hidlStatus, value](auto status,
	const hidl_vec<uint8_t>& hwValue) {
	hidlStatus = status;
	*value = hwValue;
	});
	return Utils::buildScopedAStatusFromEvsResult(hidlStatus);
	}

	ScopedAStatus AidlCamera::ImplV1::getIntParameter(CameraParam id, std::vector<int32_t>* value) {
	if (!mHidlCamera) {
	return Utils::buildScopedAStatusFromEvsResult(EvsResult::RESOURCE_NOT_AVAILABLE);
	}

	hidlevs::V1_0::EvsResult hidlStatus = hidlevs::V1_0::EvsResult::OK;
	(void)mHidlCamera->getIntParameter(Utils::makeToHidl(id),
	[&hidlStatus, value](auto status,
	const hidl_vec<int32_t>& hidlValues) {
	hidlStatus = status;
	*value = hidlValues;
	});
	return Utils::buildScopedAStatusFromEvsResult(hidlStatus);
	}

	ScopedAStatus AidlCamera::ImplV1::getIntParameterRange(CameraParam id,
	ParameterRange* _aidl_return) {
	if (!mHidlCamera) {
	return Utils::buildScopedAStatusFromEvsResult(EvsResult::RESOURCE_NOT_AVAILABLE);
	}

	(void)mHidlCamera->getIntParameterRange(Utils::makeToHidl(id),
	[_aidl_return](auto min, auto max, auto step) {
	_aidl_return->min = min;
	_aidl_return->max = max;
	_aidl_return->step = step;
	});
	return ScopedAStatus::ok();
	}

	ScopedAStatus AidlCamera::ImplV1::getParameterList(std::vector<CameraParam>* _aidl_return) {
	if (!mHidlCamera) {
	return Utils::buildScopedAStatusFromEvsResult(EvsResult::RESOURCE_NOT_AVAILABLE);
	}

	(void)mHidlCamera->getParameterList(
	[_aidl_return](const hidl_vec<hidlevs::V1_1::CameraParam>& list) {
	_aidl_return->reserve(list.size());
	for (auto i = 0; i < list.size(); ++i) {
	_aidl_return->push_back(std::move(Utils::makeFromHidl(list[i])));
	}
	});
	return ScopedAStatus::ok();
	}

	ScopedAStatus AidlCamera::ImplV1::getPhysicalCameraInfo(const std::string& deviceId,
	CameraDesc* _aidl_return) {
	if (!mHidlCamera) {
	return Utils::buildScopedAStatusFromEvsResult(EvsResult::RESOURCE_NOT_AVAILABLE);
	}

	(void)mHidlCamera->getPhysicalCameraInfo(deviceId, [_aidl_return](const auto& hidlDesc) {
	*_aidl_return = std::move(Utils::makeFromHidl(hidlDesc));
	});
	return ScopedAStatus::ok();
	}

	ScopedAStatus AidlCamera::ImplV1::importExternalBuffers(const std::vector<BufferDesc>& buffers,
	int32_t* _aidl_return) {
	if (!mHidlCamera) {
	return Utils::buildScopedAStatusFromEvsResult(EvsResult::RESOURCE_NOT_AVAILABLE);
	}

	hidl_vec<hidlevs::V1_1::BufferDesc> hidlBuffers;
	hidlBuffers.resize(buffers.size());
	for (auto i = 0; i < buffers.size(); ++i) {
	hidlBuffers[i] = std::move(Utils::makeToHidlV1_1(buffers[i]));
	}
	hidlevs::V1_0::EvsResult hidlStatus = hidlevs::V1_0::EvsResult::OK;
	(void)mHidlCamera->importExternalBuffers(hidlBuffers,
	[&hidlStatus, _aidl_return](auto status, auto delta) {
	hidlStatus = status;
	*_aidl_return = delta;
	});
	return Utils::buildScopedAStatusFromEvsResult(hidlStatus);
	}

	ScopedAStatus AidlCamera::ImplV1::pauseVideoStream() {
	if (!mHidlCamera) {
	return Utils::buildScopedAStatusFromEvsResult(EvsResult::RESOURCE_NOT_AVAILABLE);
	}
	return Utils::buildScopedAStatusFromEvsResult(mHidlCamera->pauseVideoStream());
	}

	ScopedAStatus AidlCamera::ImplV1::resumeVideoStream() {
	if (!mHidlCamera) {
	return Utils::buildScopedAStatusFromEvsResult(EvsResult::RESOURCE_NOT_AVAILABLE);
	}
	return Utils::buildScopedAStatusFromEvsResult(mHidlCamera->resumeVideoStream());
	}

	ScopedAStatus AidlCamera::ImplV1::setExtendedInfo(int32_t opaqueIdentifier,
	const std::vector<uint8_t>& opaqueValue) {
	if (!mHidlCamera) {
	return Utils::buildScopedAStatusFromEvsResult(EvsResult::RESOURCE_NOT_AVAILABLE);
	}

	hidl_vec<uint8_t> value = opaqueValue;
	hidlevs::V1_0::EvsResult hidlStatus = mHidlCamera->setExtendedInfo_1_1(opaqueIdentifier, value);

	return Utils::buildScopedAStatusFromEvsResult(hidlStatus);
	}

	ScopedAStatus AidlCamera::ImplV1::setIntParameter(CameraParam id, int32_t value,
	std::vector<int32_t>* effectiveValue) {
	if (!mHidlCamera) {
	return Utils::buildScopedAStatusFromEvsResult(EvsResult::RESOURCE_NOT_AVAILABLE);
	}

	hidlevs::V1_0::EvsResult hidlStatus = hidlevs::V1_0::EvsResult::OK;
	(void)mHidlCamera->setIntParameter(Utils::makeToHidl(id), value,
	[&hidlStatus,
	&effectiveValue](auto status,
	const hidl_vec<int32_t>& values) {
	hidlStatus = status;
	*effectiveValue = values;
	});
	return Utils::buildScopedAStatusFromEvsResult(hidlStatus);
	}

	ScopedAStatus AidlCamera::ImplV1::setPrimaryClient() {
	if (!mHidlCamera) {
	return Utils::buildScopedAStatusFromEvsResult(EvsResult::RESOURCE_NOT_AVAILABLE);
	}

	return Utils::buildScopedAStatusFromEvsResult(mHidlCamera->setMaster());
	}

	ScopedAStatus AidlCamera::ImplV1::setMaxFramesInFlight(int32_t bufferCount) {
	if (!mHidlCamera) {
	return Utils::buildScopedAStatusFromEvsResult(EvsResult::RESOURCE_NOT_AVAILABLE);
	}

	return Utils::buildScopedAStatusFromEvsResult(mHidlCamera->setMaxFramesInFlight(bufferCount));
	}

	ScopedAStatus AidlCamera::ImplV1::startVideoStream(
	const std::shared_ptr<IEvsCameraStream>& listener) {
	if (!listener) {
	return Utils::buildScopedAStatusFromEvsResult(EvsResult::INVALID_ARG);
	} else if (mHidlStream) {
	return Utils::buildScopedAStatusFromEvsResult(EvsResult::STREAM_ALREADY_RUNNING);
	}

	// Creates a wrapper object and requests a video stream
	mHidlStream = new (std::nothrow) HidlCameraStream(mId, listener);
	return Utils::buildScopedAStatusFromEvsResult(mHidlCamera->startVideoStream(mHidlStream));
	}

	ScopedAStatus AidlCamera::ImplV1::stopVideoStream() {
	if (!mHidlStream) {
	return ScopedAStatus::ok();
	}

	mHidlCamera->stopVideoStream();
	mHidlStream = nullptr;
	return ScopedAStatus::ok();
	}

	ScopedAStatus AidlCamera::ImplV1::unsetPrimaryClient() {
	if (!mHidlCamera) {
	return Utils::buildScopedAStatusFromEvsResult(EvsResult::RESOURCE_NOT_AVAILABLE);
	}

	return Utils::buildScopedAStatusFromEvsResult(mHidlCamera->unsetMaster());
	}

	} // namespace aidl::android::automotive::evs::implementation