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