1 /*
2 * Copyright (c) 2021-2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "dcamera_client.h"
17
18 #include "anonymous_string.h"
19 #include "camera_util.h"
20 #include "camera_metadata_operator.h"
21 #include "dcamera_input_callback.h"
22 #include "dcamera_manager_callback.h"
23 #include "dcamera_photo_callback.h"
24 #include "dcamera_preview_callback.h"
25 #include "dcamera_session_callback.h"
26 #include "dcamera_utils_tools.h"
27 #include "dcamera_video_callback.h"
28 #include "distributed_camera_constants.h"
29 #include "distributed_camera_errno.h"
30 #include "distributed_hardware_log.h"
31 #include "metadata_utils.h"
32
33 namespace OHOS {
34 namespace DistributedHardware {
DCameraClient(const std::string & dhId)35 DCameraClient::DCameraClient(const std::string& dhId)
36 {
37 DHLOGI("DCameraClient Constructor dhId: %{public}s", GetAnonyString(dhId).c_str());
38 if (dhId.size() >= CAMERA_ID_PREFIX.size()) {
39 cameraId_ = dhId.substr(CAMERA_ID_PREFIX.size());
40 }
41 isInit_ = false;
42 }
43
~DCameraClient()44 DCameraClient::~DCameraClient()
45 {
46 if (isInit_) {
47 UnInit();
48 }
49 }
50
Init()51 int32_t DCameraClient::Init()
52 {
53 DHLOGI("Init cameraId: %{public}s", GetAnonyString(cameraId_).c_str());
54 cameraManager_ = CameraStandard::CameraManager::GetInstance();
55 if (cameraManager_ == nullptr) {
56 DHLOGE("Init cameraManager getInstance failed");
57 return DCAMERA_BAD_VALUE;
58 }
59 cameraManager_->SetCallback(std::make_shared<DCameraManagerCallback>());
60
61 std::vector<sptr<CameraStandard::CameraDevice>> cameraList = cameraManager_->GetSupportedCameras();
62 if (cameraList.empty()) {
63 DHLOGE("Init no camera device");
64 return DCAMERA_BAD_VALUE;
65 }
66 uint64_t listSize = static_cast<uint64_t>(cameraList.size());
67 DHLOGI("Init camera size: %{public}" PRIu64, listSize);
68 for (auto& info : cameraList) {
69 if (info != nullptr && info->GetID() == cameraId_) {
70 DHLOGI("Init cameraInfo get id: %{public}s", GetAnonyString(info->GetID()).c_str());
71 cameraInfo_ = info;
72 break;
73 }
74 }
75 if (cameraInfo_ == nullptr) {
76 DHLOGE("Init cameraInfo is null");
77 return DCAMERA_BAD_VALUE;
78 }
79
80 isInit_ = true;
81 DHLOGI("Init %{public}s success", GetAnonyString(cameraId_).c_str());
82 return DCAMERA_OK;
83 }
84
UnInit()85 int32_t DCameraClient::UnInit()
86 {
87 DHLOGI("UnInit cameraId: %{public}s", GetAnonyString(cameraId_).c_str());
88 if (cameraManager_ != nullptr) {
89 DHLOGI("UnInit unregister cameraManager callback");
90 cameraManager_->SetCallback(nullptr);
91 }
92
93 isInit_ = false;
94 cameraInfo_ = nullptr;
95 cameraManager_ = nullptr;
96 DHLOGI("UnInit %{public}s success", GetAnonyString(cameraId_).c_str());
97 return DCAMERA_OK;
98 }
99
UpdateSettings(std::vector<std::shared_ptr<DCameraSettings>> & settings)100 int32_t DCameraClient::UpdateSettings(std::vector<std::shared_ptr<DCameraSettings>>& settings)
101 {
102 DHLOGI("UpdateSettings cameraId: %{public}s", GetAnonyString(cameraId_).c_str());
103 for (auto& setting : settings) {
104 if (setting == nullptr) {
105 DHLOGE("UpdateSettings setting is null");
106 continue;
107 }
108 switch (setting->type_) {
109 case UPDATE_METADATA: {
110 DHLOGI("UpdateSettings %{public}s update metadata settings", GetAnonyString(cameraId_).c_str());
111 std::string dcSettingValue = setting->value_;
112 std::string metadataStr = Base64Decode(dcSettingValue);
113 FindCameraMetadata(metadataStr);
114
115 if (cameraInput_ == nullptr) {
116 DHLOGE("UpdateSettings %{public}s cameraInput is null", GetAnonyString(cameraId_).c_str());
117 UpdateSettingCache(metadataStr);
118 return DCAMERA_OK;
119 }
120
121 int32_t ret = ((sptr<CameraStandard::CameraInput> &)cameraInput_)->SetCameraSettings(metadataStr);
122 if (ret != DCAMERA_OK) {
123 DHLOGE("UpdateSettings %{public}s update metadata settings failed, ret: %{public}d",
124 GetAnonyString(cameraId_).c_str(), ret);
125 return ret;
126 }
127 break;
128 }
129 default: {
130 DHLOGE("UpdateSettings unknown setting type");
131 break;
132 }
133 }
134 }
135 DHLOGI("UpdateSettings %{public}s success", GetAnonyString(cameraId_).c_str());
136 return DCAMERA_OK;
137 }
138
UpdateSettingCache(const std::string & metadataStr)139 void DCameraClient::UpdateSettingCache(const std::string& metadataStr)
140 {
141 if (cameraMetadatas_.size() == DCAMERA_MAX_METADATA_SIZE) {
142 DHLOGE("UpdateSettingCache %{public}s camera metadata oversize",
143 GetAnonyString(cameraId_).c_str());
144 cameraMetadatas_.pop();
145 }
146 cameraMetadatas_.push(metadataStr);
147 }
148
FindCameraMetadata(const std::string & metadataStr)149 void DCameraClient::FindCameraMetadata(const std::string& metadataStr)
150 {
151 std::shared_ptr<Camera::CameraMetadata> cameraMetadata = Camera::MetadataUtils::DecodeFromString(metadataStr);
152 CHECK_AND_RETURN_LOG(cameraMetadata == nullptr, "FindCameraMetadata get cameraMetadata is null");
153 camera_metadata_item_t focusItem;
154 int32_t ret = Camera::FindCameraMetadataItem(cameraMetadata->get(), OHOS_CONTROL_FOCUS_MODE, &focusItem);
155 if (ret == CAM_META_SUCCESS) {
156 DHLOGI("FindCameraMetadata focus mode: %{public}d", focusItem.data.u8[0]);
157 } else {
158 DHLOGE("FindCameraMetadata %{public}s find focus mode failed, ret: %{public}d",
159 GetAnonyString(cameraId_).c_str(), ret);
160 }
161
162 camera_metadata_item_t exposureItem;
163 ret = Camera::FindCameraMetadataItem(cameraMetadata->get(), OHOS_CONTROL_EXPOSURE_MODE, &exposureItem);
164 if (ret == CAM_META_SUCCESS) {
165 DHLOGI("FindCameraMetadata exposure mode: %{public}d", exposureItem.data.u8[0]);
166 } else {
167 DHLOGE("FindCameraMetadata %{public}s find exposure mode failed, ret: %{public}d",
168 GetAnonyString(cameraId_).c_str(), ret);
169 }
170
171 camera_metadata_item_t stabilityItem;
172 ret = Camera::FindCameraMetadataItem(cameraMetadata->get(), OHOS_CONTROL_VIDEO_STABILIZATION_MODE, &stabilityItem);
173 if (ret == CAM_META_SUCCESS) {
174 DHLOGI("FindCameraMetadata stabilization mode: %{public}d", stabilityItem.data.u8[0]);
175 } else {
176 DHLOGE("FindCameraMetadata %{public}s find stabilization mode failed, ret: %{public}d",
177 GetAnonyString(cameraId_).c_str(), ret);
178 }
179 }
180
StartCapture(std::vector<std::shared_ptr<DCameraCaptureInfo>> & captureInfos,sptr<Surface> & surface,int32_t sceneMode)181 int32_t DCameraClient::StartCapture(std::vector<std::shared_ptr<DCameraCaptureInfo>>& captureInfos,
182 sptr<Surface>& surface, int32_t sceneMode)
183 {
184 DHLOGI("StartCapture cameraId: %{public}s, mode: %{public}d", GetAnonyString(cameraId_).c_str(), sceneMode);
185 if ((photoOutput_ == nullptr) && (previewOutput_ == nullptr)) {
186 DHLOGI("StartCapture %{public}s config capture session", GetAnonyString(cameraId_).c_str());
187 if (surface == nullptr) {
188 DHLOGE("StartCapture: input surface is nullptr.");
189 return DCAMERA_BAD_VALUE;
190 }
191 previewSurface_ = surface;
192 int32_t ret = ConfigCaptureSession(captureInfos, sceneMode);
193 if (ret != DCAMERA_OK) {
194 DHLOGE("StartCapture config capture session failed, cameraId: %{public}s, ret: %{public}d",
195 GetAnonyString(cameraId_).c_str(), ret);
196 return CameraServiceErrorType(ret);
197 }
198 }
199
200 for (auto& info : captureInfos) {
201 if (info == nullptr) {
202 DHLOGE("StartCapture info is null");
203 continue;
204 }
205 if ((info->streamType_ == CONTINUOUS_FRAME) || (!info->isCapture_)) {
206 continue;
207 }
208 int32_t ret = StartCaptureInner(info);
209 if (ret != DCAMERA_OK) {
210 DHLOGE("StartCapture failed, cameraId: %{public}s, ret: %{public}d",
211 GetAnonyString(cameraId_).c_str(), ret);
212 return CameraServiceErrorType(ret);
213 }
214 }
215 DHLOGI("StartCapture %{public}s success", GetAnonyString(cameraId_).c_str());
216 return DCAMERA_OK;
217 }
218
CameraServiceErrorType(const int32_t errorType)219 int32_t DCameraClient::CameraServiceErrorType(const int32_t errorType)
220 {
221 if (errorType == CameraStandard::CameraErrorCode::SERVICE_FATL_ERROR) {
222 return DCAMERA_ALLOC_ERROR;
223 } else if (errorType == CameraStandard::CameraErrorCode::CONFLICT_CAMERA) {
224 return DCAMERA_DEVICE_BUSY;
225 }
226 return errorType;
227 }
228
StopCapture()229 int32_t DCameraClient::StopCapture()
230 {
231 DHLOGI("StopCapture cameraId: %{public}s", GetAnonyString(cameraId_).c_str());
232 StopOutput();
233
234 if (cameraInput_ != nullptr) {
235 DHLOGI("StopCapture %{public}s release cameraInput", GetAnonyString(cameraId_).c_str());
236 int32_t ret = cameraInput_->Close();
237 if (ret != DCAMERA_OK) {
238 DHLOGE("StopCapture cameraInput Close failed, cameraId: %{public}s, ret: %{public}d",
239 GetAnonyString(cameraId_).c_str(), ret);
240 }
241 ret = cameraInput_->Release();
242 if (ret != DCAMERA_OK) {
243 DHLOGE("StopCapture cameraInput Release failed, cameraId: %{public}s, ret: %{public}d",
244 GetAnonyString(cameraId_).c_str(), ret);
245 }
246 cameraInput_ = nullptr;
247 }
248 ReleaseCaptureSession();
249
250 if (previewSurface_ != nullptr) {
251 DHLOGI("StopCapture %s previewsurface unregister consumer listener",
252 GetAnonyString(cameraId_).c_str());
253 previewSurface_ = nullptr;
254 }
255
256 if (photoSurface_ != nullptr) {
257 DHLOGI("StopCapture %{public}s photosurface unregister consumer listener",
258 GetAnonyString(cameraId_).c_str());
259 int32_t ret = photoSurface_->UnregisterConsumerListener();
260 if (ret != DCAMERA_OK) {
261 DHLOGE("StopCapture %{public}s photosurface unregister consumer listener failed, ret: %{public}d",
262 GetAnonyString(cameraId_).c_str(), ret);
263 }
264 photoListener_ = nullptr;
265 photoSurface_ = nullptr;
266 }
267
268 DHLOGI("StopCapture %{public}s success", GetAnonyString(cameraId_).c_str());
269 return DCAMERA_OK;
270 }
271
StopOutput()272 void DCameraClient::StopOutput()
273 {
274 if (previewOutput_ != nullptr) {
275 DHLOGI("StopCapture %{public}s stop previewOutput", GetAnonyString(cameraId_).c_str());
276 int32_t ret = ((sptr<CameraStandard::PreviewOutput> &)previewOutput_)->Stop();
277 if (ret != DCAMERA_OK) {
278 DHLOGE("StopCapture videoOutput stop failed, cameraId: %{public}s, ret: %{public}d",
279 GetAnonyString(cameraId_).c_str(), ret);
280 }
281 DHLOGI("StopCapture %{public}s release previewOutput", GetAnonyString(cameraId_).c_str());
282 ret = previewOutput_->Release();
283 if (ret != DCAMERA_OK) {
284 DHLOGE("StopCapture previewOutput Release failed, cameraId: %{public}s, ret: %{public}d",
285 GetAnonyString(cameraId_).c_str(), ret);
286 }
287 previewOutput_ = nullptr;
288 }
289
290 if (photoOutput_ != nullptr) {
291 DHLOGI("StopCapture %{public}s release photoOutput", GetAnonyString(cameraId_).c_str());
292 int32_t ret = photoOutput_->Release();
293 if (ret != DCAMERA_OK) {
294 DHLOGE("StopCapture photoOutput Release failed, cameraId: %{public}s, ret: %{public}d",
295 GetAnonyString(cameraId_).c_str(), ret);
296 }
297 photoOutput_ = nullptr;
298 }
299 }
300
ReleaseCaptureSession()301 void DCameraClient::ReleaseCaptureSession()
302 {
303 if (captureSession_ == nullptr) {
304 return;
305 }
306 DHLOGI("StopCapture %{public}s stop captureSession", GetAnonyString(cameraId_).c_str());
307 int32_t ret = captureSession_->Stop();
308 if (ret != DCAMERA_OK) {
309 DHLOGE("StopCapture captureSession stop failed, cameraId: %{public}s, ret: %{public}d",
310 GetAnonyString(cameraId_).c_str(), ret);
311 }
312 DHLOGI("StopCapture %{public}s release captureSession", GetAnonyString(cameraId_).c_str());
313 ret = captureSession_->Release();
314 if (ret != DCAMERA_OK) {
315 DHLOGE("StopCapture captureSession Release failed, cameraId: %{public}s, ret: %{public}d",
316 GetAnonyString(cameraId_).c_str(), ret);
317 }
318 captureSession_ = nullptr;
319 }
320
SetStateCallback(std::shared_ptr<StateCallback> & callback)321 int32_t DCameraClient::SetStateCallback(std::shared_ptr<StateCallback>& callback)
322 {
323 DHLOGI("SetStateCallback cameraId: %{public}s", GetAnonyString(cameraId_).c_str());
324 if (callback == nullptr) {
325 DHLOGE("SetStateCallback %{public}s unregistering state callback", GetAnonyString(cameraId_).c_str());
326 }
327 stateCallback_ = callback;
328 return DCAMERA_OK;
329 }
330
SetResultCallback(std::shared_ptr<ResultCallback> & callback)331 int32_t DCameraClient::SetResultCallback(std::shared_ptr<ResultCallback>& callback)
332 {
333 DHLOGI("SetResultCallback cameraId: %{public}s", GetAnonyString(cameraId_).c_str());
334 if (callback == nullptr) {
335 DHLOGE("SetResultCallback %{public}s unregistering result callback", GetAnonyString(cameraId_).c_str());
336 }
337 resultCallback_ = callback;
338 return DCAMERA_OK;
339 }
340
ConfigCaptureSession(std::vector<std::shared_ptr<DCameraCaptureInfo>> & captureInfos,int32_t sceneMode)341 int32_t DCameraClient::ConfigCaptureSession(std::vector<std::shared_ptr<DCameraCaptureInfo>>& captureInfos,
342 int32_t sceneMode)
343 {
344 DHLOGI("ConfigCaptureSession cameraId: %{public}s", GetAnonyString(cameraId_).c_str());
345 CHECK_AND_RETURN_RET_LOG(cameraManager_ == nullptr, DCAMERA_BAD_VALUE, "cameraManager is null.");
346 int rv = cameraManager_->CreateCameraInput(cameraInfo_, &((sptr<CameraStandard::CameraInput> &)cameraInput_));
347 if (rv != DCAMERA_OK) {
348 DHLOGE("ConfigCaptureSession %{public}s create cameraInput failed", GetAnonyString(cameraId_).c_str());
349 return DCAMERA_BAD_VALUE;
350 }
351 CHECK_AND_RETURN_RET_LOG(cameraInput_ == nullptr, DCAMERA_BAD_VALUE, "cameraInput is null.");
352 int32_t rc = ((sptr<CameraStandard::CameraInput> &)cameraInput_)->Open();
353 if (rc != DCAMERA_OK) {
354 DHLOGE("ConfigCaptureSession cameraInput_ Open failed, cameraId: %{public}s, ret: %{public}d",
355 GetAnonyString(cameraId_).c_str(), rc);
356 return DCAMERA_BAD_VALUE;
357 }
358 std::shared_ptr<DCameraInputCallback> inputCallback = std::make_shared<DCameraInputCallback>(stateCallback_);
359 ((sptr<CameraStandard::CameraInput> &)cameraInput_)->SetErrorCallback(inputCallback);
360
361 while (!cameraMetadatas_.empty()) {
362 std::string metadataStr = cameraMetadatas_.front();
363 FindCameraMetadata(metadataStr);
364 int32_t ret = ((sptr<CameraStandard::CameraInput> &)cameraInput_)->SetCameraSettings(metadataStr);
365 if (ret != DCAMERA_OK) {
366 DHLOGE("ConfigCaptureSession %{public}s set camera settings failed, ret: %{public}d",
367 GetAnonyString(cameraId_).c_str(), ret);
368 return ret;
369 }
370 cameraMetadatas_.pop();
371 }
372
373 captureSession_ = cameraManager_->CreateCaptureSession(static_cast<CameraStandard::SceneMode>(sceneMode));
374 if (captureSession_ == nullptr) {
375 DHLOGE("ConfigCaptureSession %{public}s create captureSession failed",
376 GetAnonyString(cameraId_).c_str());
377 return DCAMERA_BAD_VALUE;
378 }
379
380 std::shared_ptr<DCameraSessionCallback> sessionCallback = std::make_shared<DCameraSessionCallback>(stateCallback_);
381 captureSession_->SetFocusCallback(sessionCallback);
382 captureSession_->SetCallback(sessionCallback);
383
384 int32_t ret = CreateCaptureOutput(captureInfos);
385 if (ret != DCAMERA_OK) {
386 DHLOGE("ConfigCaptureSession create capture output failed, cameraId: %{public}s, ret: %{public}d",
387 GetAnonyString(cameraId_).c_str(), ret);
388 return ret;
389 }
390
391 return ConfigCaptureSessionInner();
392 }
393
ConfigCaptureSessionInner()394 int32_t DCameraClient::ConfigCaptureSessionInner()
395 {
396 CHECK_AND_RETURN_RET_LOG(captureSession_ == nullptr, DCAMERA_BAD_VALUE,
397 "ConfigCaptureSessionInner captureSession is null.");
398 int32_t ret = captureSession_->BeginConfig();
399 if (ret != DCAMERA_OK) {
400 DHLOGE("ConfigCaptureSession %{public}s config captureSession failed, ret: %{public}d",
401 GetAnonyString(cameraId_).c_str(), ret);
402 return ret;
403 }
404
405 ret = captureSession_->AddInput(cameraInput_);
406 if (ret != DCAMERA_OK) {
407 DHLOGE("ConfigCaptureSession %{public}s add cameraInput to captureSession failed, ret: %{public}d",
408 GetAnonyString(cameraId_).c_str(), ret);
409 return ret;
410 }
411
412 if (photoOutput_ != nullptr) {
413 ret = captureSession_->AddOutput(photoOutput_);
414 if (ret != DCAMERA_OK) {
415 DHLOGE("ConfigCaptureSession %{public}s add photoOutput to captureSession failed, ret: %{public}d",
416 GetAnonyString(cameraId_).c_str(), ret);
417 return ret;
418 }
419 }
420
421 if (previewOutput_ != nullptr) {
422 ret = captureSession_->AddOutput(previewOutput_);
423 if (ret != DCAMERA_OK) {
424 DHLOGE("ConfigCaptureSession %{public}s add previewOutput to captureSession failed, ret: %{public}d",
425 GetAnonyString(cameraId_).c_str(), ret);
426 return ret;
427 }
428 }
429
430 ret = captureSession_->CommitConfig();
431 if (ret != DCAMERA_OK) {
432 DHLOGE("ConfigCaptureSession %{public}s commit captureSession failed, ret: %{public}d",
433 GetAnonyString(cameraId_).c_str(), ret);
434 return ret;
435 }
436
437 ret = captureSession_->Start();
438 if (ret != DCAMERA_OK) {
439 DHLOGE("ConfigCaptureSession %{public}s start captureSession failed, ret: %{public}d",
440 GetAnonyString(cameraId_).c_str(), ret);
441 }
442
443 DHLOGI("ConfigCaptureSession %{public}s success", GetAnonyString(cameraId_).c_str());
444 return DCAMERA_OK;
445 }
446
CreateCaptureOutput(std::vector<std::shared_ptr<DCameraCaptureInfo>> & captureInfos)447 int32_t DCameraClient::CreateCaptureOutput(std::vector<std::shared_ptr<DCameraCaptureInfo>>& captureInfos)
448 {
449 if (captureInfos.empty()) {
450 DHLOGE("CreateCaptureOutput no capture info, cameraId: %{public}s", GetAnonyString(cameraId_).c_str());
451 return DCAMERA_BAD_VALUE;
452 }
453
454 for (auto& info : captureInfos) {
455 if (info == nullptr) {
456 DHLOGE("CreateCaptureOutput info is null");
457 continue;
458 }
459 if (info->streamType_ == SNAPSHOT_FRAME) {
460 int32_t ret = CreatePhotoOutput(info);
461 if (ret != DCAMERA_OK) {
462 DHLOGE("CreateCaptureOutput %{public}s create photo output failed, ret: %{public}d",
463 GetAnonyString(cameraId_).c_str(), ret);
464 return ret;
465 }
466 } else if (info->streamType_ == CONTINUOUS_FRAME) {
467 int32_t ret = CreatePreviewOutput(info);
468 if (ret != DCAMERA_OK) {
469 DHLOGE("CreateCaptureOutput %{public}s create video output failed, ret: %{public}d",
470 GetAnonyString(cameraId_).c_str(), ret);
471 return ret;
472 }
473 } else {
474 DHLOGE("CreateCaptureOutput unknown stream type");
475 return DCAMERA_BAD_VALUE;
476 }
477 }
478 return DCAMERA_OK;
479 }
480
CreatePhotoOutput(std::shared_ptr<DCameraCaptureInfo> & info)481 int32_t DCameraClient::CreatePhotoOutput(std::shared_ptr<DCameraCaptureInfo>& info)
482 {
483 CHECK_AND_RETURN_RET_LOG(info == nullptr, DCAMERA_BAD_VALUE, "CreatePhotoOutput info is null");
484 DHLOGI("CreatePhotoOutput dhId: %{public}s, width: %{public}d, height: %{public}d, format: %{public}d, stream: "
485 "%{public}d, isCapture: %{public}d", GetAnonyString(cameraId_).c_str(), info->width_, info->height_,
486 info->format_, info->streamType_, info->isCapture_);
487 photoSurface_ = IConsumerSurface::Create();
488 CHECK_AND_RETURN_RET_LOG(photoSurface_ == nullptr, DCAMERA_BAD_VALUE,
489 "CreatePhotoOutput create photo surface failed");
490 photoListener_ = sptr<DCameraPhotoSurfaceListener>(
491 new DCameraPhotoSurfaceListener(photoSurface_, resultCallback_));
492 photoSurface_->RegisterConsumerListener((sptr<IBufferConsumerListener> &)photoListener_);
493 CameraStandard::CameraFormat photoFormat = ConvertToCameraFormat(info->format_);
494 CameraStandard::Size photoSize = {info->width_, info->height_};
495 CameraStandard::Profile photoProfile(photoFormat, photoSize);
496 sptr<IBufferProducer> bp = photoSurface_->GetProducer();
497 int32_t rv = cameraManager_->CreatePhotoOutput(
498 photoProfile, bp, &((sptr<CameraStandard::PhotoOutput> &)photoOutput_));
499 if (rv != DCAMERA_OK || photoOutput_ == nullptr) {
500 DHLOGE("CreatePhotoOutput %{public}s create photo output failed", GetAnonyString(cameraId_).c_str());
501 return DCAMERA_BAD_VALUE;
502 }
503 std::shared_ptr<DCameraPhotoCallback> photoCallback = std::make_shared<DCameraPhotoCallback>(stateCallback_);
504 ((sptr<CameraStandard::PhotoOutput> &)photoOutput_)->SetCallback(photoCallback);
505 DHLOGI("CreatePhotoOutput %{public}s success", GetAnonyString(cameraId_).c_str());
506 return DCAMERA_OK;
507 }
508
CreatePreviewOutput(std::shared_ptr<DCameraCaptureInfo> & info)509 int32_t DCameraClient::CreatePreviewOutput(std::shared_ptr<DCameraCaptureInfo>& info)
510 {
511 CHECK_AND_RETURN_RET_LOG(info == nullptr, DCAMERA_BAD_VALUE, "CreatePreviewOutput info is null");
512 DHLOGI("CreatePreviewOutput dhId: %{public}s, width: %{public}d, height: %{public}d, format: %{public}d, stream:"
513 " %{public}d, isCapture: %{public}d", GetAnonyString(cameraId_).c_str(), info->width_, info->height_,
514 info->format_, info->streamType_, info->isCapture_);
515 CameraStandard::CameraFormat previewFormat = ConvertToCameraFormat(info->format_);
516 CameraStandard::Size previewSize = {info->width_, info->height_};
517 CameraStandard::Profile previewProfile(previewFormat, previewSize);
518 int32_t rv = cameraManager_->CreatePreviewOutput(
519 previewProfile, previewSurface_, &((sptr<CameraStandard::PreviewOutput> &)previewOutput_));
520 if (rv != DCAMERA_OK) {
521 DHLOGE("CreatePreviewOutput %{public}s create preview output failed", GetAnonyString(cameraId_).c_str());
522 return DCAMERA_BAD_VALUE;
523 }
524 auto previewCallback = std::make_shared<DCameraPreviewCallback>(stateCallback_);
525 ((sptr<CameraStandard::PreviewOutput> &)previewOutput_)->SetCallback(previewCallback);
526 DHLOGI("CreatePreviewOutput %{public}s success", GetAnonyString(cameraId_).c_str());
527 return DCAMERA_OK;
528 }
529
ConvertToCameraFormat(int32_t format)530 CameraStandard::CameraFormat DCameraClient::ConvertToCameraFormat(int32_t format)
531 {
532 CameraStandard::CameraFormat ret = CameraStandard::CameraFormat::CAMERA_FORMAT_INVALID;
533 DCameraFormat df = static_cast<DCameraFormat>(format);
534 switch (df) {
535 case DCameraFormat::OHOS_CAMERA_FORMAT_RGBA_8888:
536 ret = CameraStandard::CameraFormat::CAMERA_FORMAT_RGBA_8888;
537 break;
538 case DCameraFormat::OHOS_CAMERA_FORMAT_YCBCR_420_888:
539 ret = CameraStandard::CameraFormat::CAMERA_FORMAT_YCBCR_420_888;
540 break;
541 case DCameraFormat::OHOS_CAMERA_FORMAT_YCRCB_420_SP:
542 ret = CameraStandard::CameraFormat::CAMERA_FORMAT_YUV_420_SP;
543 break;
544 case DCameraFormat::OHOS_CAMERA_FORMAT_JPEG:
545 ret = CameraStandard::CameraFormat::CAMERA_FORMAT_JPEG;
546 break;
547 default:
548 break;
549 }
550 return ret;
551 }
552
StartCaptureInner(std::shared_ptr<DCameraCaptureInfo> & info)553 int32_t DCameraClient::StartCaptureInner(std::shared_ptr<DCameraCaptureInfo>& info)
554 {
555 CHECK_AND_RETURN_RET_LOG(info == nullptr, DCAMERA_BAD_VALUE, "StartCaptureInner info is null");
556 if (info->streamType_ != SNAPSHOT_FRAME) {
557 DHLOGE("StartCaptureInner unknown stream type");
558 return DCAMERA_BAD_VALUE;
559 }
560 return StartPhotoOutput(info);
561 }
562
StartPhotoOutput(std::shared_ptr<DCameraCaptureInfo> & info)563 int32_t DCameraClient::StartPhotoOutput(std::shared_ptr<DCameraCaptureInfo>& info)
564 {
565 CHECK_AND_RETURN_RET_LOG(info == nullptr, DCAMERA_BAD_VALUE, "StartPhotoOutput info is null");
566 DHLOGI("StartPhotoOutput cameraId: %{public}s", GetAnonyString(cameraId_).c_str());
567 if (photoOutput_ == nullptr) {
568 DHLOGE("StartPhotoOutput photoOutput is null");
569 return DCAMERA_BAD_VALUE;
570 }
571
572 std::vector<std::shared_ptr<DCameraSettings>> captureSettings = info->captureSettings_;
573 std::string metadataSetting;
574 for (const auto& setting : captureSettings) {
575 if (setting->type_ == UPDATE_METADATA) {
576 DHLOGI("StartPhotoOutput %{public}s update metadata settings", GetAnonyString(cameraId_).c_str());
577 metadataSetting = setting->value_;
578 }
579 }
580
581 if (metadataSetting.empty()) {
582 DHLOGE("StartPhotoOutput no metadata settings to update");
583 int32_t ret = ((sptr<CameraStandard::PhotoOutput> &)photoOutput_)->Capture();
584 if (ret != DCAMERA_OK) {
585 DHLOGE("StartPhotoOutput %{public}s photoOutput capture failed, ret: %{public}d",
586 GetAnonyString(cameraId_).c_str(), ret);
587 return ret;
588 }
589 return DCAMERA_OK;
590 }
591
592 std::string metadataStr = Base64Decode(metadataSetting);
593 std::shared_ptr<Camera::CameraMetadata> cameraMetadata = Camera::MetadataUtils::DecodeFromString(metadataStr);
594 std::shared_ptr<CameraStandard::PhotoCaptureSetting> photoCaptureSetting =
595 std::make_shared<CameraStandard::PhotoCaptureSetting>();
596 SetPhotoCaptureRotation(cameraMetadata, photoCaptureSetting);
597 SetPhotoCaptureQuality(cameraMetadata, photoCaptureSetting);
598 SetPhotoCaptureLocation(cameraMetadata, photoCaptureSetting);
599 int32_t ret = ((sptr<CameraStandard::PhotoOutput> &)photoOutput_)->Capture(photoCaptureSetting);
600 if (ret != DCAMERA_OK) {
601 DHLOGE("StartPhotoOutput %{public}s photoOutput capture failed, ret: %{public}d",
602 GetAnonyString(cameraId_).c_str(), ret);
603 return ret;
604 }
605 return DCAMERA_OK;
606 }
607
SetPhotoCaptureRotation(const std::shared_ptr<Camera::CameraMetadata> & cameraMetadata,std::shared_ptr<CameraStandard::PhotoCaptureSetting> & photoCaptureSetting)608 void DCameraClient::SetPhotoCaptureRotation(const std::shared_ptr<Camera::CameraMetadata>& cameraMetadata,
609 std::shared_ptr<CameraStandard::PhotoCaptureSetting>& photoCaptureSetting)
610 {
611 CHECK_AND_RETURN_LOG(cameraMetadata == nullptr, "SetPhotoCaptureRotation param cameraMetadata is null");
612 CHECK_AND_RETURN_LOG(photoCaptureSetting == nullptr,
613 "SetPhotoCaptureRotation param photoCaptureSetting is null");
614 uint32_t rotationCount = 1;
615 camera_metadata_item_t item;
616 int32_t ret = Camera::FindCameraMetadataItem(cameraMetadata->get(), OHOS_JPEG_ORIENTATION, &item);
617 if ((ret == CAM_META_SUCCESS) && (rotationCount == item.count)) {
618 CameraStandard::PhotoCaptureSetting::RotationConfig rotation =
619 static_cast<CameraStandard::PhotoCaptureSetting::RotationConfig>(item.data.i32[0]);
620 photoCaptureSetting->SetRotation(rotation);
621 DHLOGI("SetPhotoCaptureRotation %{public}s photo capture settings set %{public}d rotation: %{public}d",
622 GetAnonyString(cameraId_).c_str(), item.count, rotation);
623 }
624 }
625
SetPhotoCaptureQuality(const std::shared_ptr<Camera::CameraMetadata> & cameraMetadata,std::shared_ptr<CameraStandard::PhotoCaptureSetting> & photoCaptureSetting)626 void DCameraClient::SetPhotoCaptureQuality(const std::shared_ptr<Camera::CameraMetadata>& cameraMetadata,
627 std::shared_ptr<CameraStandard::PhotoCaptureSetting>& photoCaptureSetting)
628 {
629 CHECK_AND_RETURN_LOG(cameraMetadata == nullptr, "SetPhotoCaptureRotation param cameraMetadata is null");
630 CHECK_AND_RETURN_LOG(photoCaptureSetting == nullptr,
631 "SetPhotoCaptureRotation param photoCaptureSetting is null");
632 uint32_t qualityCount = 1;
633 camera_metadata_item_t item;
634 int32_t ret = Camera::FindCameraMetadataItem(cameraMetadata->get(), OHOS_JPEG_QUALITY, &item);
635 if ((ret == CAM_META_SUCCESS) && (qualityCount == item.count)) {
636 bool status = CameraStandard::AddOrUpdateMetadata(photoCaptureSetting->GetCaptureMetadataSetting()->get(),
637 OHOS_JPEG_QUALITY, &item.data.u8[0], item.count);
638 DHLOGI("SetPhotoCaptureQuality %{public}s photo capture settings set %{public}d quality: %{public}d"
639 "status: %{public}d", GetAnonyString(cameraId_).c_str(), item.count, item.data.u8[0], status);
640 }
641 }
642
SetPhotoCaptureLocation(const std::shared_ptr<Camera::CameraMetadata> & cameraMetadata,std::shared_ptr<CameraStandard::PhotoCaptureSetting> & photoCaptureSetting)643 void DCameraClient::SetPhotoCaptureLocation(const std::shared_ptr<Camera::CameraMetadata>& cameraMetadata,
644 std::shared_ptr<CameraStandard::PhotoCaptureSetting>& photoCaptureSetting)
645 {
646 CHECK_AND_RETURN_LOG(cameraMetadata == nullptr, "SetPhotoCaptureRotation param cameraMetadata is null");
647 CHECK_AND_RETURN_LOG(photoCaptureSetting == nullptr,
648 "SetPhotoCaptureRotation param photoCaptureSetting is null");
649 uint32_t locationCount = 3;
650 camera_metadata_item_t item;
651 int32_t ret = Camera::FindCameraMetadataItem(cameraMetadata->get(), OHOS_JPEG_GPS_COORDINATES, &item);
652 if ((ret == CAM_META_SUCCESS) && (locationCount == item.count)) {
653 int32_t latitudeIndex = 0;
654 int32_t longitudeIndex = 1;
655 int32_t altitudeIndex = 2;
656 std::shared_ptr<CameraStandard::Location> location = std::make_shared<CameraStandard::Location>();
657 location->latitude = item.data.d[latitudeIndex];
658 location->longitude = item.data.d[longitudeIndex];
659 location->altitude = item.data.d[altitudeIndex];
660 photoCaptureSetting->SetLocation(location);
661 DHLOGI("SetPhotoCaptureLocation %{public}s photo capture settings set %{public}d location: "
662 "latitude=%{public}s, longitude=%{public}s, altitude=%{public}s", GetAnonyString(cameraId_).c_str(),
663 item.count, GetAnonyString(std::to_string(item.data.d[latitudeIndex])).c_str(),
664 GetAnonyString(std::to_string(item.data.d[longitudeIndex])).c_str(),
665 GetAnonyString(std::to_string(item.data.d[altitudeIndex])).c_str());
666 }
667 }
668
PauseCapture()669 int32_t DCameraClient::PauseCapture()
670 {
671 if (captureSession_ == nullptr) {
672 DHLOGE("PauseCapture captureSession_ is nullptr.");
673 return DCAMERA_BAD_VALUE;
674 }
675 int32_t ret = captureSession_->Stop();
676 if (ret != DCAMERA_OK) {
677 DHLOGE("PauseCapture captureSession stop failed, cameraId: %{public}s, ret: %{public}d",
678 GetAnonyString(cameraId_).c_str(), ret);
679 }
680 return ret;
681 }
682
ResumeCapture()683 int32_t DCameraClient::ResumeCapture()
684 {
685 if (captureSession_ == nullptr) {
686 DHLOGE("ResumeCapture captureSession_ is nullptr.");
687 return DCAMERA_BAD_VALUE;
688 }
689 int32_t ret = captureSession_->Start();
690 if (ret != DCAMERA_OK) {
691 DHLOGE("ResumeCapture captureSession Start failed, cameraId: %{public}s, ret: %{public}d",
692 GetAnonyString(cameraId_).c_str(), ret);
693 }
694 return ret;
695 }
696 } // namespace DistributedHardware
697 } // namespace OHOS
698