• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2022 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 #include "AidlCamera.h"
18 
19 #include "HidlDisplay.h"
20 #include "utils/include/Utils.h"
21 
22 #include <android-base/logging.h>
23 
24 namespace aidl::android::automotive::evs::implementation {
25 
26 namespace hidlevs = ::android::hardware::automotive::evs;
27 
28 using ::aidl::android::hardware::automotive::evs::BufferDesc;
29 using ::aidl::android::hardware::automotive::evs::CameraDesc;
30 using ::aidl::android::hardware::automotive::evs::CameraParam;
31 using ::aidl::android::hardware::automotive::evs::DisplayState;
32 using ::aidl::android::hardware::automotive::evs::EvsEventDesc;
33 using ::aidl::android::hardware::automotive::evs::EvsEventType;
34 using ::aidl::android::hardware::automotive::evs::EvsResult;
35 using ::aidl::android::hardware::automotive::evs::IEvsCameraStream;
36 using ::aidl::android::hardware::automotive::evs::IEvsDisplay;
37 using ::aidl::android::hardware::automotive::evs::ParameterRange;
38 using ::android::hardware::hidl_vec;
39 using ::ndk::ScopedAStatus;
40 
AidlCamera(const::android::sp<hidlevs::V1_0::IEvsCamera> & hidlCamera)41 AidlCamera::AidlCamera(const ::android::sp<hidlevs::V1_0::IEvsCamera>& hidlCamera) {
42     auto hidlCameraV1 = hidlevs::V1_1::IEvsCamera::castFrom(hidlCamera).withDefault(nullptr);
43     if (!hidlCameraV1) {
44         mImpl = std::make_shared<ImplV0>(hidlCamera);
45     } else {
46         mImpl = std::make_shared<ImplV1>(hidlCameraV1);
47     }
48 
49     if (!mImpl) {
50         LOG(ERROR) << "Failed to initialize AidlCamera instance";
51     }
52 }
53 
getHidlCamera() const54 const ::android::sp<hidlevs::V1_0::IEvsCamera> AidlCamera::getHidlCamera() const {
55     return mImpl->getHidlCamera();
56 }
57 
doneWithFrame(const std::vector<BufferDesc> & buffers)58 ScopedAStatus AidlCamera::doneWithFrame(const std::vector<BufferDesc>& buffers) {
59     return mImpl->doneWithFrame(buffers);
60 }
61 
forcePrimaryClient(const std::shared_ptr<IEvsDisplay> & display)62 ScopedAStatus AidlCamera::forcePrimaryClient(const std::shared_ptr<IEvsDisplay>& display) {
63     return mImpl->forcePrimaryClient(display);
64 }
65 
getCameraInfo(CameraDesc * _aidl_return)66 ScopedAStatus AidlCamera::getCameraInfo(CameraDesc* _aidl_return) {
67     return mImpl->getCameraInfo(_aidl_return);
68 }
69 
getExtendedInfo(int32_t opaqueIdentifier,std::vector<uint8_t> * value)70 ScopedAStatus AidlCamera::getExtendedInfo(int32_t opaqueIdentifier, std::vector<uint8_t>* value) {
71     return mImpl->getExtendedInfo(opaqueIdentifier, value);
72 }
73 
getIntParameter(CameraParam id,std::vector<int32_t> * value)74 ScopedAStatus AidlCamera::getIntParameter(CameraParam id, std::vector<int32_t>* value) {
75     return mImpl->getIntParameter(id, value);
76 }
77 
getIntParameterRange(CameraParam id,ParameterRange * _aidl_return)78 ScopedAStatus AidlCamera::getIntParameterRange(CameraParam id, ParameterRange* _aidl_return) {
79     return mImpl->getIntParameterRange(id, _aidl_return);
80 }
81 
getParameterList(std::vector<CameraParam> * _aidl_return)82 ScopedAStatus AidlCamera::getParameterList(std::vector<CameraParam>* _aidl_return) {
83     return mImpl->getParameterList(_aidl_return);
84 }
85 
getPhysicalCameraInfo(const std::string & deviceId,CameraDesc * _aidl_return)86 ScopedAStatus AidlCamera::getPhysicalCameraInfo(const std::string& deviceId,
87                                                 CameraDesc* _aidl_return) {
88     return mImpl->getPhysicalCameraInfo(deviceId, _aidl_return);
89 }
90 
importExternalBuffers(const std::vector<BufferDesc> & buffers,int32_t * _aidl_return)91 ScopedAStatus AidlCamera::importExternalBuffers(const std::vector<BufferDesc>& buffers,
92                                                 int32_t* _aidl_return) {
93     return mImpl->importExternalBuffers(buffers, _aidl_return);
94 }
95 
pauseVideoStream()96 ScopedAStatus AidlCamera::pauseVideoStream() {
97     return mImpl->pauseVideoStream();
98 }
99 
resumeVideoStream()100 ScopedAStatus AidlCamera::resumeVideoStream() {
101     return mImpl->resumeVideoStream();
102 }
103 
setExtendedInfo(int32_t opaqueIdentifier,const std::vector<uint8_t> & opaqueValue)104 ScopedAStatus AidlCamera::setExtendedInfo(int32_t opaqueIdentifier,
105                                           const std::vector<uint8_t>& opaqueValue) {
106     return mImpl->setExtendedInfo(opaqueIdentifier, opaqueValue);
107 }
108 
setIntParameter(CameraParam id,int32_t value,std::vector<int32_t> * effectiveValue)109 ScopedAStatus AidlCamera::setIntParameter(CameraParam id, int32_t value,
110                                           std::vector<int32_t>* effectiveValue) {
111     return mImpl->setIntParameter(id, value, effectiveValue);
112 }
113 
setPrimaryClient()114 ScopedAStatus AidlCamera::setPrimaryClient() {
115     return mImpl->setPrimaryClient();
116 }
117 
setMaxFramesInFlight(int32_t bufferCount)118 ScopedAStatus AidlCamera::setMaxFramesInFlight(int32_t bufferCount) {
119     return mImpl->setMaxFramesInFlight(bufferCount);
120 }
121 
startVideoStream(const std::shared_ptr<IEvsCameraStream> & listener)122 ScopedAStatus AidlCamera::startVideoStream(const std::shared_ptr<IEvsCameraStream>& listener) {
123     return mImpl->startVideoStream(listener);
124 }
125 
stopVideoStream()126 ScopedAStatus AidlCamera::stopVideoStream() {
127     return mImpl->stopVideoStream();
128 }
129 
unsetPrimaryClient()130 ScopedAStatus AidlCamera::unsetPrimaryClient() {
131     return mImpl->unsetPrimaryClient();
132 }
133 
ImplV0(const::android::sp<hidlevs::V1_0::IEvsCamera> & camera)134 AidlCamera::ImplV0::ImplV0(const ::android::sp<hidlevs::V1_0::IEvsCamera>& camera) :
135       IHidlCamera(camera) {}
136 
doneWithFrame(const std::vector<BufferDesc> & buffers)137 ScopedAStatus AidlCamera::ImplV0::doneWithFrame(const std::vector<BufferDesc>& buffers) {
138     if (!mHidlStream) {
139         LOG(WARNING) << "Ignores a request to return a buffer of an invalid HIDL camera stream";
140         return ScopedAStatus::ok();
141     }
142 
143     hidlevs::V1_0::BufferDesc hidlBuffer;
144     if (mHidlStream->getHidlBuffer(buffers[0].bufferId, &hidlBuffer)) {
145         mHidlCamera->doneWithFrame(hidlBuffer);
146     }
147 
148     return ScopedAStatus::ok();
149 }
150 
forcePrimaryClient(const std::shared_ptr<IEvsDisplay> & display)151 ScopedAStatus AidlCamera::ImplV0::forcePrimaryClient(
152         [[maybe_unused]] const std::shared_ptr<IEvsDisplay>& display) {
153     return Utils::buildScopedAStatusFromEvsResult(EvsResult::NOT_SUPPORTED);
154 }
155 
getCameraInfo(CameraDesc * _aidl_return)156 ScopedAStatus AidlCamera::ImplV0::getCameraInfo(CameraDesc* _aidl_return) {
157     if (!mHidlCamera) {
158         LOG(ERROR) << "HIDL camera is not valid";
159         return Utils::buildScopedAStatusFromEvsResult(EvsResult::RESOURCE_NOT_AVAILABLE);
160     }
161 
162     (void)mHidlCamera->getCameraInfo(
163             [&_aidl_return](auto& desc) { *_aidl_return = std::move(Utils::makeFromHidl(desc)); });
164 
165     return ScopedAStatus::ok();
166 }
167 
getExtendedInfo(int32_t opaqueIdentifier,std::vector<uint8_t> * value)168 ScopedAStatus AidlCamera::ImplV0::getExtendedInfo(int32_t opaqueIdentifier,
169                                                   std::vector<uint8_t>* value) {
170     if (!mHidlCamera) {
171         LOG(ERROR) << "HIDL camera is not valid";
172         return Utils::buildScopedAStatusFromEvsResult(EvsResult::RESOURCE_NOT_AVAILABLE);
173     }
174 
175     int32_t hidlValue = mHidlCamera->getExtendedInfo(opaqueIdentifier);
176     value->resize(sizeof(hidlValue));
177     int* p = reinterpret_cast<int*>(value->data());
178     *p = hidlValue;
179     return ScopedAStatus::ok();
180 }
181 
getIntParameter(CameraParam,std::vector<int32_t> *)182 ScopedAStatus AidlCamera::ImplV0::getIntParameter(CameraParam /*id*/,
183                                                   std::vector<int32_t>* /*value*/) {
184     return Utils::buildScopedAStatusFromEvsResult(EvsResult::NOT_SUPPORTED);
185 }
186 
getIntParameterRange(CameraParam,ParameterRange *)187 ScopedAStatus AidlCamera::ImplV0::getIntParameterRange(CameraParam /*id*/,
188                                                        ParameterRange* /*_aidl_return*/) {
189     return Utils::buildScopedAStatusFromEvsResult(EvsResult::NOT_SUPPORTED);
190 }
191 
getParameterList(std::vector<CameraParam> *)192 ScopedAStatus AidlCamera::ImplV0::getParameterList(std::vector<CameraParam>* /*_aidl_return*/) {
193     return Utils::buildScopedAStatusFromEvsResult(EvsResult::NOT_SUPPORTED);
194 }
195 
getPhysicalCameraInfo(const std::string &,CameraDesc *)196 ScopedAStatus AidlCamera::ImplV0::getPhysicalCameraInfo(const std::string& /*deviceId*/,
197                                                         CameraDesc* /*_aidl_return*/) {
198     return Utils::buildScopedAStatusFromEvsResult(EvsResult::NOT_SUPPORTED);
199 }
200 
importExternalBuffers(const std::vector<BufferDesc> &,int32_t *)201 ScopedAStatus AidlCamera::ImplV0::importExternalBuffers(const std::vector<BufferDesc>& /*buffers*/,
202                                                         int32_t* /*_aidl_return*/) {
203     return Utils::buildScopedAStatusFromEvsResult(EvsResult::NOT_SUPPORTED);
204 }
205 
pauseVideoStream()206 ScopedAStatus AidlCamera::ImplV0::pauseVideoStream() {
207     return Utils::buildScopedAStatusFromEvsResult(EvsResult::NOT_SUPPORTED);
208 }
209 
resumeVideoStream()210 ScopedAStatus AidlCamera::ImplV0::resumeVideoStream() {
211     return Utils::buildScopedAStatusFromEvsResult(EvsResult::NOT_SUPPORTED);
212 }
213 
setExtendedInfo(int32_t opaqueIdentifier,const std::vector<uint8_t> & opaqueValue)214 ScopedAStatus AidlCamera::ImplV0::setExtendedInfo(int32_t opaqueIdentifier,
215                                                   const std::vector<uint8_t>& opaqueValue) {
216     int32_t v = *(reinterpret_cast<const int32_t*>(opaqueValue.data()));
217     return Utils::buildScopedAStatusFromEvsResult(
218             mHidlCamera->setExtendedInfo(opaqueIdentifier, v));
219 }
220 
setIntParameter(CameraParam,int32_t,std::vector<int32_t> *)221 ScopedAStatus AidlCamera::ImplV0::setIntParameter(CameraParam /*id*/, int32_t /*value*/,
222                                                   std::vector<int32_t>* /*effectiveValue*/) {
223     return Utils::buildScopedAStatusFromEvsResult(EvsResult::NOT_SUPPORTED);
224 }
225 
setPrimaryClient()226 ScopedAStatus AidlCamera::ImplV0::setPrimaryClient() {
227     return Utils::buildScopedAStatusFromEvsResult(EvsResult::NOT_SUPPORTED);
228 }
229 
setMaxFramesInFlight(int32_t bufferCount)230 ScopedAStatus AidlCamera::ImplV0::setMaxFramesInFlight(int32_t bufferCount) {
231     if (!mHidlCamera) {
232         LOG(ERROR) << "HIDL camera is not valid";
233         return Utils::buildScopedAStatusFromEvsResult(EvsResult::RESOURCE_NOT_AVAILABLE);
234     }
235 
236     return Utils::buildScopedAStatusFromEvsResult(mHidlCamera->setMaxFramesInFlight(bufferCount));
237 }
238 
startVideoStream(const std::shared_ptr<IEvsCameraStream> & listener)239 ScopedAStatus AidlCamera::ImplV0::startVideoStream(
240         const std::shared_ptr<IEvsCameraStream>& listener) {
241     if (!listener) {
242         return Utils::buildScopedAStatusFromEvsResult(EvsResult::INVALID_ARG);
243     } else if (mHidlStream) {
244         return Utils::buildScopedAStatusFromEvsResult(EvsResult::STREAM_ALREADY_RUNNING);
245     }
246 
247     // Creates a wrapper object and requests a video stream
248     mHidlStream = new (std::nothrow) HidlCameraStream(listener);
249     return Utils::buildScopedAStatusFromEvsResult(mHidlCamera->startVideoStream(mHidlStream));
250 }
251 
stopVideoStream()252 ScopedAStatus AidlCamera::ImplV0::stopVideoStream() {
253     if (!mHidlStream) {
254         return ScopedAStatus::ok();
255     }
256 
257     mHidlCamera->stopVideoStream();
258     mHidlStream = nullptr;
259     return ScopedAStatus::ok();
260 }
261 
unsetPrimaryClient()262 ScopedAStatus AidlCamera::ImplV0::unsetPrimaryClient() {
263     return Utils::buildScopedAStatusFromEvsResult(EvsResult::NOT_SUPPORTED);
264 }
265 
ImplV1(const::android::sp<hidlevs::V1_1::IEvsCamera> & camera)266 AidlCamera::ImplV1::ImplV1(const ::android::sp<hidlevs::V1_1::IEvsCamera>& camera) :
267       IHidlCamera(camera), mHidlCamera(camera) {}
268 
doneWithFrame(const std::vector<BufferDesc> & buffers)269 ScopedAStatus AidlCamera::ImplV1::doneWithFrame(const std::vector<BufferDesc>& buffers) {
270     if (!mHidlStream) {
271         LOG(WARNING) << "Ignores a request to return a buffer of an invalid HIDL camera stream";
272         return ScopedAStatus::ok();
273     }
274 
275     const auto n = buffers.size();
276     hidl_vec<hidlevs::V1_1::BufferDesc> hidlBuffers(n);
277     for (auto i = 0; i < n; ++i) {
278         hidlevs::V1_1::BufferDesc buffer;
279         if (mHidlStream->getHidlBuffer(buffers[i].bufferId, &buffer)) {
280             hidlBuffers[i] = std::move(buffer);
281         }
282     }
283 
284     mHidlCamera->doneWithFrame_1_1(hidlBuffers);
285     return ScopedAStatus::ok();
286 }
287 
forcePrimaryClient(const std::shared_ptr<IEvsDisplay> & display)288 ScopedAStatus AidlCamera::ImplV1::forcePrimaryClient(const std::shared_ptr<IEvsDisplay>& display) {
289     if (!mHidlCamera) {
290         return Utils::buildScopedAStatusFromEvsResult(EvsResult::NOT_SUPPORTED);
291     }
292 
293     return Utils::buildScopedAStatusFromEvsResult(
294             mHidlCamera->forceMaster(new HidlDisplay(display)));
295 }
296 
getCameraInfo(CameraDesc * _aidl_return)297 ScopedAStatus AidlCamera::ImplV1::getCameraInfo(CameraDesc* _aidl_return) {
298     if (!mHidlCamera) {
299         return Utils::buildScopedAStatusFromEvsResult(EvsResult::RESOURCE_NOT_AVAILABLE);
300     }
301 
302     (void)mHidlCamera->getCameraInfo_1_1(
303             [&_aidl_return](auto& desc) { *_aidl_return = std::move(Utils::makeFromHidl(desc)); });
304 
305     return ScopedAStatus::ok();
306 }
307 
getExtendedInfo(int32_t opaqueIdentifier,std::vector<uint8_t> * value)308 ScopedAStatus AidlCamera::ImplV1::getExtendedInfo(int32_t opaqueIdentifier,
309                                                   std::vector<uint8_t>* value) {
310     if (!mHidlCamera) {
311         return Utils::buildScopedAStatusFromEvsResult(EvsResult::RESOURCE_NOT_AVAILABLE);
312     }
313 
314     hidlevs::V1_0::EvsResult hidlStatus = hidlevs::V1_0::EvsResult::OK;
315     (void)mHidlCamera->getExtendedInfo_1_1(opaqueIdentifier,
316                                            [&hidlStatus, &value](auto status,
317                                                                  const hidl_vec<uint8_t>& hwValue) {
318                                                hidlStatus = status;
319                                                *value = hwValue;
320                                            });
321     return Utils::buildScopedAStatusFromEvsResult(hidlStatus);
322 }
323 
getIntParameter(CameraParam id,std::vector<int32_t> * value)324 ScopedAStatus AidlCamera::ImplV1::getIntParameter(CameraParam id, std::vector<int32_t>* value) {
325     if (!mHidlCamera) {
326         return Utils::buildScopedAStatusFromEvsResult(EvsResult::RESOURCE_NOT_AVAILABLE);
327     }
328 
329     hidlevs::V1_0::EvsResult hidlStatus = hidlevs::V1_0::EvsResult::OK;
330     (void)mHidlCamera->getIntParameter(Utils::makeToHidl(id),
331                                        [&hidlStatus, &value](auto status,
332                                                              const hidl_vec<int32_t>& hidlValues) {
333                                            hidlStatus = status;
334                                            *value = hidlValues;
335                                        });
336     return Utils::buildScopedAStatusFromEvsResult(hidlStatus);
337 }
338 
getIntParameterRange(CameraParam id,ParameterRange * _aidl_return)339 ScopedAStatus AidlCamera::ImplV1::getIntParameterRange(CameraParam id,
340                                                        ParameterRange* _aidl_return) {
341     if (!mHidlCamera) {
342         return Utils::buildScopedAStatusFromEvsResult(EvsResult::RESOURCE_NOT_AVAILABLE);
343     }
344 
345     (void)mHidlCamera->getIntParameterRange(Utils::makeToHidl(id),
346                                             [&_aidl_return](auto min, auto max, auto step) {
347                                                 _aidl_return->min = min;
348                                                 _aidl_return->max = max;
349                                                 _aidl_return->step = step;
350                                             });
351     return ScopedAStatus::ok();
352 }
353 
getParameterList(std::vector<CameraParam> * _aidl_return)354 ScopedAStatus AidlCamera::ImplV1::getParameterList(std::vector<CameraParam>* _aidl_return) {
355     if (!mHidlCamera) {
356         return Utils::buildScopedAStatusFromEvsResult(EvsResult::RESOURCE_NOT_AVAILABLE);
357     }
358 
359     (void)mHidlCamera->getParameterList(
360             [&_aidl_return](const hidl_vec<hidlevs::V1_1::CameraParam>& list) {
361                 _aidl_return->reserve(list.size());
362                 for (auto i = 0; i < list.size(); ++i) {
363                     _aidl_return->push_back(std::move(Utils::makeFromHidl(list[i])));
364                 }
365             });
366     return ScopedAStatus::ok();
367 }
368 
getPhysicalCameraInfo(const std::string & deviceId,CameraDesc * _aidl_return)369 ScopedAStatus AidlCamera::ImplV1::getPhysicalCameraInfo(const std::string& deviceId,
370                                                         CameraDesc* _aidl_return) {
371     if (!mHidlCamera) {
372         return Utils::buildScopedAStatusFromEvsResult(EvsResult::RESOURCE_NOT_AVAILABLE);
373     }
374 
375     (void)mHidlCamera->getPhysicalCameraInfo(deviceId, [&_aidl_return](const auto& hidlDesc) {
376         *_aidl_return = std::move(Utils::makeFromHidl(hidlDesc));
377     });
378     return ScopedAStatus::ok();
379 }
380 
importExternalBuffers(const std::vector<BufferDesc> & buffers,int32_t * _aidl_return)381 ScopedAStatus AidlCamera::ImplV1::importExternalBuffers(const std::vector<BufferDesc>& buffers,
382                                                         int32_t* _aidl_return) {
383     if (!mHidlCamera) {
384         return Utils::buildScopedAStatusFromEvsResult(EvsResult::RESOURCE_NOT_AVAILABLE);
385     }
386 
387     hidl_vec<hidlevs::V1_1::BufferDesc> hidlBuffers;
388     hidlBuffers.resize(buffers.size());
389     for (auto i = 0; i < buffers.size(); ++i) {
390         hidlBuffers[i] = std::move(Utils::makeToHidlV1_1(buffers[i]));
391     }
392     hidlevs::V1_0::EvsResult hidlStatus = hidlevs::V1_0::EvsResult::OK;
393     (void)mHidlCamera->importExternalBuffers(hidlBuffers,
394                                              [&hidlStatus, &_aidl_return](auto status, auto delta) {
395                                                  hidlStatus = status;
396                                                  *_aidl_return = delta;
397                                              });
398     return Utils::buildScopedAStatusFromEvsResult(hidlStatus);
399 }
400 
pauseVideoStream()401 ScopedAStatus AidlCamera::ImplV1::pauseVideoStream() {
402     if (!mHidlCamera) {
403         return Utils::buildScopedAStatusFromEvsResult(EvsResult::RESOURCE_NOT_AVAILABLE);
404     }
405     return Utils::buildScopedAStatusFromEvsResult(mHidlCamera->pauseVideoStream());
406 }
407 
resumeVideoStream()408 ScopedAStatus AidlCamera::ImplV1::resumeVideoStream() {
409     if (!mHidlCamera) {
410         return Utils::buildScopedAStatusFromEvsResult(EvsResult::RESOURCE_NOT_AVAILABLE);
411     }
412     return Utils::buildScopedAStatusFromEvsResult(mHidlCamera->resumeVideoStream());
413 }
414 
setExtendedInfo(int32_t opaqueIdentifier,const std::vector<uint8_t> & opaqueValue)415 ScopedAStatus AidlCamera::ImplV1::setExtendedInfo(int32_t opaqueIdentifier,
416                                                   const std::vector<uint8_t>& opaqueValue) {
417     if (!mHidlCamera) {
418         return Utils::buildScopedAStatusFromEvsResult(EvsResult::RESOURCE_NOT_AVAILABLE);
419     }
420 
421     hidl_vec<uint8_t> value = opaqueValue;
422     hidlevs::V1_0::EvsResult hidlStatus = mHidlCamera->setExtendedInfo_1_1(opaqueIdentifier, value);
423 
424     return Utils::buildScopedAStatusFromEvsResult(hidlStatus);
425 }
426 
setIntParameter(CameraParam id,int32_t value,std::vector<int32_t> * effectiveValue)427 ScopedAStatus AidlCamera::ImplV1::setIntParameter(CameraParam id, int32_t value,
428                                                   std::vector<int32_t>* effectiveValue) {
429     if (!mHidlCamera) {
430         return Utils::buildScopedAStatusFromEvsResult(EvsResult::RESOURCE_NOT_AVAILABLE);
431     }
432 
433     hidlevs::V1_0::EvsResult hidlStatus = hidlevs::V1_0::EvsResult::OK;
434     (void)mHidlCamera->setIntParameter(Utils::makeToHidl(id), value,
435                                        [&hidlStatus,
436                                         &effectiveValue](auto status,
437                                                          const hidl_vec<int32_t>& values) {
438                                            hidlStatus = status;
439                                            *effectiveValue = values;
440                                        });
441     return Utils::buildScopedAStatusFromEvsResult(hidlStatus);
442 }
443 
setPrimaryClient()444 ScopedAStatus AidlCamera::ImplV1::setPrimaryClient() {
445     if (!mHidlCamera) {
446         return Utils::buildScopedAStatusFromEvsResult(EvsResult::RESOURCE_NOT_AVAILABLE);
447     }
448 
449     return Utils::buildScopedAStatusFromEvsResult(mHidlCamera->setMaster());
450 }
451 
setMaxFramesInFlight(int32_t bufferCount)452 ScopedAStatus AidlCamera::ImplV1::setMaxFramesInFlight(int32_t bufferCount) {
453     if (!mHidlCamera) {
454         return Utils::buildScopedAStatusFromEvsResult(EvsResult::RESOURCE_NOT_AVAILABLE);
455     }
456 
457     return Utils::buildScopedAStatusFromEvsResult(mHidlCamera->setMaxFramesInFlight(bufferCount));
458 }
459 
startVideoStream(const std::shared_ptr<IEvsCameraStream> & listener)460 ScopedAStatus AidlCamera::ImplV1::startVideoStream(
461         const std::shared_ptr<IEvsCameraStream>& listener) {
462     if (!listener) {
463         return Utils::buildScopedAStatusFromEvsResult(EvsResult::INVALID_ARG);
464     } else if (mHidlStream) {
465         return Utils::buildScopedAStatusFromEvsResult(EvsResult::STREAM_ALREADY_RUNNING);
466     }
467 
468     // Creates a wrapper object and requests a video stream
469     mHidlStream = new (std::nothrow) HidlCameraStream(listener);
470     return Utils::buildScopedAStatusFromEvsResult(mHidlCamera->startVideoStream(mHidlStream));
471 }
472 
stopVideoStream()473 ScopedAStatus AidlCamera::ImplV1::stopVideoStream() {
474     if (!mHidlStream) {
475         return ScopedAStatus::ok();
476     }
477 
478     mHidlCamera->stopVideoStream();
479     mHidlStream = nullptr;
480     return ScopedAStatus::ok();
481 }
482 
unsetPrimaryClient()483 ScopedAStatus AidlCamera::ImplV1::unsetPrimaryClient() {
484     if (!mHidlCamera) {
485         return Utils::buildScopedAStatusFromEvsResult(EvsResult::RESOURCE_NOT_AVAILABLE);
486     }
487 
488     return Utils::buildScopedAStatusFromEvsResult(mHidlCamera->unsetMaster());
489 }
490 
491 }  // namespace aidl::android::automotive::evs::implementation
492