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 "hcapture_session.h"
17
18 #include <algorithm>
19 #include <atomic>
20 #include <cerrno>
21 #include <cinttypes>
22 #include <cstddef>
23 #include <cstdint>
24 #include <functional>
25 #include <memory>
26 #include <mutex>
27 #include <new>
28 #include <sched.h>
29 #include <string>
30 #include <sync_fence.h>
31 #include <utility>
32 #include <vector>
33
34 #include "ability/camera_ability_const.h"
35 #include "camera_datashare_helper.h"
36 #include "camera_types.h"
37 #include "float_wrapper.h"
38 #include "base_types.h"
39 #include "blocking_queue.h"
40 #include "camera_info_dumper.h"
41 #include "camera_log.h"
42 #include "camera_report_dfx_uitls.h"
43 #include "camera_report_uitls.h"
44 #include "camera_server_photo_proxy.h"
45 #include "camera_util.h"
46 #include "datetime_ex.h"
47 #include "deferred_processing_service.h"
48 #include "display/composer/v1_1/display_composer_type.h"
49 #include "display_manager.h"
50 #include "fixed_size_list.h"
51 #include "hcamera_restore_param.h"
52 #include "hcamera_service.h"
53 #include "hcamera_session_manager.h"
54 #include "hstream_capture.h"
55 #include "hstream_common.h"
56 #include "hstream_depth_data.h"
57 #include "hstream_metadata.h"
58 #include "hstream_repeat.h"
59 #include "icapture_session.h"
60 #include "icapture_session_callback.h"
61 #include "iconsumer_surface.h"
62 #include "image_type.h"
63 #include "imech_session.h"
64 #include "ipc_skeleton.h"
65 #include "istream_common.h"
66 #include "photo_asset_interface.h"
67 #include "photo_asset_proxy.h"
68 #include "picture_interface.h"
69 #include "moving_photo_proxy.h"
70 #include "parameters.h"
71 #include "refbase.h"
72 #include "res_sched_client.h"
73 #include "res_type.h"
74 #include "smooth_zoom.h"
75 #include "surface.h"
76 #include "surface_buffer.h"
77 #include "v1_0/types.h"
78 #include "hstream_operator_manager.h"
79 #include "camera_xcollie.h"
80 #include "camera_metadata.h"
81 #ifdef HOOK_CAMERA_OPERATOR
82 #include "camera_rotate_plugin.h"
83 #endif
84
85 using namespace OHOS::AAFwk;
86 namespace OHOS {
87 namespace CameraStandard {
88 using namespace OHOS::HDI::Display::Composer::V1_1;
89
90 namespace {
91 constexpr int32_t WIDE_CAMERA_ZOOM_RANGE = 0;
92 constexpr int32_t MAIN_CAMERA_ZOOM_RANGE = 1;
93 constexpr int32_t TWO_X_EXIT_TELE_ZOOM_RANGE = 2;
94 constexpr int32_t TELE_CAMERA_ZOOM_RANGE = 3;
95 constexpr int32_t WIDE_MAIN_ZOOM_PER = 0;
96 constexpr int32_t TELE_MAIN_ZOOM_PER = 1;
97 constexpr int32_t TELE_2X_ZOOM_PER = 2;
98 constexpr int32_t WIDE_TELE_ZOOM_PER = 3;
99 constexpr int32_t ZOOM_IN_PER = 0;
100 constexpr int32_t ZOOM_OUT_PERF = 1;
101 constexpr int32_t ZOOM_BEZIER_VALUE_COUNT = 5;
102 constexpr int32_t SPECIAL_BUNDLE_FPS = 15;
103 constexpr int32_t SPECIAL_BUNDLE_ROTATE = 0;
104 static const int32_t SESSIONID_BEGIN = 1;
105 static const int32_t SESSIONID_MAX = INT32_MAX - 1000;
106 static std::atomic<int32_t> g_currentSessionId = SESSIONID_BEGIN;
107
108 mutex g_dataShareHelperMutex;
109
GenerateSessionId()110 static int32_t GenerateSessionId()
111 {
112 int newId = g_currentSessionId++;
113 if (newId > SESSIONID_MAX) {
114 g_currentSessionId = SESSIONID_BEGIN;
115 }
116 return newId;
117 }
118 } // namespace
119
120 static const std::map<CaptureSessionState, std::string> SESSION_STATE_STRING_MAP = {
121 { CaptureSessionState::SESSION_INIT, "Init" },
122 { CaptureSessionState::SESSION_CONFIG_INPROGRESS, "Config_In-progress" },
123 { CaptureSessionState::SESSION_CONFIG_COMMITTED, "Committed" },
124 { CaptureSessionState::SESSION_RELEASED, "Released" }, { CaptureSessionState::SESSION_STARTED, "Started" }
125 };
126
127 std::map<camera_beauty_type_t, BeautyType> h_metaBeautyTypeMap_ = {
128 {OHOS_CAMERA_BEAUTY_TYPE_AUTO, AUTO_TYPE},
129 {OHOS_CAMERA_BEAUTY_TYPE_SKIN_SMOOTH, SKIN_SMOOTH},
130 {OHOS_CAMERA_BEAUTY_TYPE_FACE_SLENDER, FACE_SLENDER},
131 {OHOS_CAMERA_BEAUTY_TYPE_SKIN_TONE, SKIN_TONE}
132 };
133
NewInstance(const uint32_t callerToken,int32_t opMode,sptr<HCaptureSession> & outSession)134 CamServiceError HCaptureSession::NewInstance(
135 const uint32_t callerToken, int32_t opMode, sptr<HCaptureSession>& outSession)
136 {
137 CamServiceError errCode = CAMERA_OK;
138 sptr<HCaptureSession> session = new (std::nothrow) HCaptureSession(callerToken, opMode);
139 CHECK_RETURN_RET(session == nullptr, CAMERA_ALLOC_ERROR);
140
141 auto &sessionManager = HCameraSessionManager::GetInstance();
142 MEDIA_DEBUG_LOG("HCaptureSession::NewInstance start, total "
143 "session:(%{public}zu), current pid(%{public}d).",
144 sessionManager.GetTotalSessionSize(),
145 session->pid_);
146 if (system::GetParameter("const.camera.multicamera.enable", "false") == "true") {
147 sessionManager.AddSessionForPC(session);
148 } else {
149 CHECK_PRINT_WLOG(sessionManager.AddSession(session) == CAMERA_SESSION_MAX_INSTANCE_NUMBER_REACHED,
150 "HCaptureSession::HCaptureSession maximum session limit reached. ");
151 // Avoid multithread leak session, PreemptOverflowSessions need to call after AddSession, ignore
152 // CAMERA_SESSION_MAX_INSTANCE_NUMBER_REACHED.
153 sessionManager.PreemptOverflowSessions(IPCSkeleton::GetCallingPid());
154 }
155 outSession = session;
156 MEDIA_INFO_LOG("HCaptureSession::NewInstance end, sessionId: %{public}d, "
157 "total session:(%{public}zu). current opMode_= %{public}d "
158 "errorCode:%{public}d",
159 outSession->sessionId_,
160 sessionManager.GetTotalSessionSize(),
161 opMode,
162 errCode);
163 return errCode;
164 }
165
OnSessionPreempt()166 void HCaptureSession::OnSessionPreempt()
167 {
168 auto disconnectDevice = GetCameraDevice();
169 CHECK_EXECUTE(disconnectDevice != nullptr, disconnectDevice->OnError(HDI::Camera::V1_0::DEVICE_PREEMPT, 0));
170 MEDIA_ERR_LOG("HCaptureSession::HCaptureSession maximum session limit reached. "
171 "Releasing the earliest session.");
172 Release();
173 }
174
HCaptureSession(const uint32_t callingTokenId,int32_t opMode)175 HCaptureSession::HCaptureSession(const uint32_t callingTokenId, int32_t opMode)
176 {
177 pid_ = IPCSkeleton::GetCallingPid();
178 uid_ = static_cast<uint32_t>(IPCSkeleton::GetCallingUid());
179 sessionId_ = GenerateSessionId();
180 callerToken_ = callingTokenId;
181 opMode_ = opMode;
182 InitialHStreamOperator();
183 cameraDataShareHelper_ = std::make_shared<CameraDataShareHelper>();
184 }
185
~HCaptureSession()186 HCaptureSession::~HCaptureSession()
187 {
188 CAMERA_SYNC_TRACE;
189 Release(CaptureSessionReleaseType::RELEASE_TYPE_OBJ_DIED);
190 }
191
GetPid()192 pid_t HCaptureSession::GetPid()
193 {
194 return pid_;
195 }
196
GetSessionId()197 int32_t HCaptureSession::GetSessionId()
198 {
199 return sessionId_;
200 }
201
GetopMode()202 int32_t HCaptureSession::GetopMode()
203 {
204 CHECK_RETURN_RET(featureMode_, featureMode_);
205 return opMode_;
206 }
207
GetCurrentStreamInfos(std::vector<StreamInfo_V1_1> & streamInfos)208 int32_t HCaptureSession::GetCurrentStreamInfos(std::vector<StreamInfo_V1_1>& streamInfos)
209 {
210 auto hStreamOperatorSptr = GetStreamOperator();
211 CHECK_RETURN_RET_ELOG(hStreamOperatorSptr == nullptr, CAMERA_INVALID_ARG,
212 "hStreamOperator_ is null");
213 return hStreamOperatorSptr->GetCurrentStreamInfos(streamInfos);
214 }
215
216
DynamicConfigStream()217 void HCaptureSession::DynamicConfigStream()
218 {
219 isDynamicConfiged_ = false;
220 MEDIA_INFO_LOG("HCaptureSession::DynamicConfigStream enter. currentState = "
221 "%{public}s, sessionID: %{public}d",
222 GetSessionState().c_str(),
223 GetSessionId());
224 auto currentState = stateMachine_.GetCurrentState();
225 if (currentState == CaptureSessionState::SESSION_STARTED) {
226 isDynamicConfiged_ = CheckSystemApp(); // System applications support dynamic config stream.
227 MEDIA_INFO_LOG("HCaptureSession::DynamicConfigStream support dynamic "
228 "stream config, sessionID: %{public}d",
229 GetSessionId());
230 }
231 }
232
IsNeedDynamicConfig()233 bool HCaptureSession::IsNeedDynamicConfig()
234 {
235 return isDynamicConfiged_;
236 }
237
SetHasFitedRotation(bool isHasFitedRotation)238 int32_t HCaptureSession::SetHasFitedRotation(bool isHasFitedRotation)
239 {
240 isHasFitedRotation_ = isHasFitedRotation;
241 return CAMERA_OK;
242 }
243
BeginConfig()244 int32_t HCaptureSession::BeginConfig()
245 {
246 CAMERA_SYNC_TRACE;
247 int32_t errCode;
248 MEDIA_INFO_LOG("HCaptureSession::BeginConfig prepare execute, sessionID: %{public}d", GetSessionId());
249 InitialHStreamOperator();
250 stateMachine_.StateGuard([&errCode, this](const CaptureSessionState state) {
251 DynamicConfigStream();
252 bool isStateValid = stateMachine_.Transfer(CaptureSessionState::SESSION_CONFIG_INPROGRESS);
253 if (!isStateValid) {
254 MEDIA_ERR_LOG("HCaptureSession::BeginConfig in invalid state %{public}d, "
255 ", sessionID: %{public}d",
256 state,
257 GetSessionId());
258 errCode = CAMERA_INVALID_STATE;
259 isDynamicConfiged_ = false;
260 return;
261 }
262 auto hStreamOperatorSptr = GetStreamOperator();
263 CHECK_RETURN_ELOG(hStreamOperatorSptr == nullptr, "hStreamOperator_ is null");
264 if (!IsNeedDynamicConfig() && (hStreamOperatorSptr->GetOfflineOutptSize() == 0)) {
265 UnlinkInputAndOutputs();
266 ClearSketchRepeatStream();
267 ClearMovingPhotoRepeatStream();
268 }
269 });
270 if (errCode == CAMERA_OK) {
271 MEDIA_INFO_LOG("HCaptureSession::BeginConfig execute success, sessionID: %{public}d", GetSessionId());
272 } else {
273 CameraReportUtils::ReportCameraError(
274 "HCaptureSession::BeginConfig, sessionID: " + std::to_string(GetSessionId()),
275 errCode, false, CameraReportUtils::GetCallerInfo());
276 }
277 return errCode;
278 }
279
CanAddInput(const sptr<ICameraDeviceService> & cameraDevice,bool & result)280 int32_t HCaptureSession::CanAddInput(const sptr<ICameraDeviceService>& cameraDevice, bool& result)
281 {
282 CAMERA_SYNC_TRACE;
283 int32_t errorCode = CAMERA_OK;
284 result = false;
285 stateMachine_.StateGuard([this, &errorCode, &cameraDevice](const CaptureSessionState currentState) {
286 if (currentState != CaptureSessionState::SESSION_CONFIG_INPROGRESS) {
287 MEDIA_ERR_LOG("HCaptureSession::CanAddInput Need to call BeginConfig "
288 "before adding input, sessionID: %{public}d",
289 GetSessionId());
290 errorCode = CAMERA_INVALID_STATE;
291 return;
292 }
293 if ((GetCameraDevice() != nullptr)) {
294 MEDIA_ERR_LOG("HCaptureSession::CanAddInput Only one input is supported, "
295 "sessionID: %{public}d",
296 GetSessionId());
297 errorCode = CAMERA_INVALID_SESSION_CFG;
298 return;
299 }
300 sptr<HCameraDevice> hCameraDevice = static_cast<HCameraDevice*>(cameraDevice.GetRefPtr());
301 auto deviceSession = hCameraDevice->GetStreamOperatorCallback();
302 if (deviceSession != nullptr) {
303 errorCode = CAMERA_OPERATION_NOT_ALLOWED;
304 return;
305 }
306 });
307 if (errorCode == CAMERA_OK) {
308 result = true;
309 CAMERA_SYSEVENT_STATISTIC(CreateMsg("CaptureSession::CanAddInput, sessionID: %d", GetSessionId()));
310 }
311 return errorCode;
312 }
313
AddInput(const sptr<ICameraDeviceService> & cameraDevice)314 int32_t HCaptureSession::AddInput(const sptr<ICameraDeviceService>& cameraDevice)
315 {
316 CAMERA_SYNC_TRACE;
317 int32_t errorCode = CAMERA_OK;
318 if (cameraDevice == nullptr) {
319 errorCode = CAMERA_INVALID_ARG;
320 MEDIA_ERR_LOG("HCaptureSession::AddInput cameraDevice is null, sessionID: %{public}d", GetSessionId());
321 CameraReportUtils::ReportCameraError(
322 "HCaptureSession::AddInput", errorCode, false, CameraReportUtils::GetCallerInfo());
323 return errorCode;
324 }
325 MEDIA_INFO_LOG("HCaptureSession::AddInput prepare execute, sessionID: %{public}d", GetSessionId());
326 stateMachine_.StateGuard([this, &errorCode, &cameraDevice](const CaptureSessionState currentState) {
327 if (currentState != CaptureSessionState::SESSION_CONFIG_INPROGRESS) {
328 MEDIA_ERR_LOG("HCaptureSession::AddInput Need to call BeginConfig before "
329 "adding input, sessionID: %{public}d",
330 GetSessionId());
331 errorCode = CAMERA_INVALID_STATE;
332 return;
333 }
334 if ((GetCameraDevice() != nullptr)) {
335 MEDIA_ERR_LOG("HCaptureSession::AddInput Only one input is supported, "
336 "sessionID: %{public}d",
337 GetSessionId());
338 errorCode = CAMERA_INVALID_SESSION_CFG;
339 return;
340 }
341 sptr<HCameraDevice> hCameraDevice = static_cast<HCameraDevice*>(cameraDevice.GetRefPtr());
342 MEDIA_INFO_LOG("HCaptureSession::AddInput device:%{public}s", hCameraDevice->GetCameraId().c_str());
343 SetCameraDevice(hCameraDevice);
344 hCameraDevice->DispatchDefaultSettingToHdi();
345 SetDeviceMechCallback();
346 });
347 if (errorCode == CAMERA_OK) {
348 CAMERA_SYSEVENT_STATISTIC(CreateMsg("CaptureSession::AddInput, sessionID: %d", GetSessionId()));
349 } else {
350 CameraReportUtils::ReportCameraError(
351 "HCaptureSession::AddInput", errorCode, false, CameraReportUtils::GetCallerInfo());
352 }
353 MEDIA_INFO_LOG("HCaptureSession::AddInput execute success, sessionID: %{public}d", GetSessionId());
354 return errorCode;
355 }
356
BeforeDeviceClose()357 void HCaptureSession::BeforeDeviceClose()
358 {
359 MEDIA_INFO_LOG("HCaptureSession::BeforeDeviceClose UnlinkInputAndOutputs");
360 UnlinkInputAndOutputs();
361 auto hStreamOperatorSptr = GetStreamOperator();
362 CHECK_RETURN_ELOG(
363 hStreamOperatorSptr == nullptr, "HCaptureSession::BeforeDeviceClose hStreamOperatorSptr is null");
364 if (!hStreamOperatorSptr->IsOfflineCapture()) {
365 hStreamOperatorSptr->Release();
366 }
367 }
368
369 class DisplayRotationListener : public OHOS::Rosen::DisplayManager::IDisplayListener {
370 public:
DisplayRotationListener()371 explicit DisplayRotationListener() {};
372 virtual ~DisplayRotationListener() = default;
OnCreate(OHOS::Rosen::DisplayId)373 void OnCreate(OHOS::Rosen::DisplayId) override {}
OnDestroy(OHOS::Rosen::DisplayId)374 void OnDestroy(OHOS::Rosen::DisplayId) override {}
OnChange(OHOS::Rosen::DisplayId displayId)375 void OnChange(OHOS::Rosen::DisplayId displayId) override
376 {
377 sptr<Rosen::Display> display = Rosen::DisplayManager::GetInstance().GetDefaultDisplay();
378 if (display == nullptr) {
379 MEDIA_INFO_LOG("Get display info failed, display:%{public}" PRIu64 "", displayId);
380 display = Rosen::DisplayManager::GetInstance().GetDisplayById(0);
381 CHECK_RETURN_ELOG(display == nullptr, "Get display info failed, display is nullptr");
382 }
383 {
384 Rosen::Rotation currentRotation = display->GetRotation();
385 std::lock_guard<std::mutex> lock(mStreamManagerLock_);
386 for (auto& repeatStream : repeatStreamList_) {
387 CHECK_EXECUTE(repeatStream, repeatStream->SetStreamTransform(static_cast<int>(currentRotation)));
388 }
389 }
390 }
391
AddHstreamRepeatForListener(sptr<HStreamRepeat> repeatStream)392 void AddHstreamRepeatForListener(sptr<HStreamRepeat> repeatStream)
393 {
394 std::lock_guard<std::mutex> lock(mStreamManagerLock_);
395 CHECK_EXECUTE(repeatStream, repeatStreamList_.push_back(repeatStream));
396 }
397
RemoveHstreamRepeatForListener(sptr<HStreamRepeat> repeatStream)398 void RemoveHstreamRepeatForListener(sptr<HStreamRepeat> repeatStream)
399 {
400 std::lock_guard<std::mutex> lock(mStreamManagerLock_);
401 if (repeatStream) {
402 repeatStreamList_.erase(
403 std::remove(repeatStreamList_.begin(), repeatStreamList_.end(), repeatStream), repeatStreamList_.end());
404 }
405 }
406
407 public:
408 std::list<sptr<HStreamRepeat>> repeatStreamList_;
409 std::mutex mStreamManagerLock_;
410 };
411
SetPreviewRotation(const std::string & deviceClass)412 int32_t HCaptureSession::SetPreviewRotation(const std::string &deviceClass)
413 {
414 auto hStreamOperatorSptr = GetStreamOperator();
415 CHECK_RETURN_RET_ELOG(hStreamOperatorSptr == nullptr, CAMERA_INVALID_ARG,
416 "hStreamOperator_ is null");
417 hStreamOperatorSptr->SetPreviewRotation(deviceClass);
418 return CAMERA_OK;
419 }
420
InitialHStreamOperator()421 void HCaptureSession::InitialHStreamOperator()
422 {
423 auto hStreamOperatorTemp = GetStreamOperator();
424 CHECK_RETURN(hStreamOperatorTemp != nullptr);
425 sptr<HStreamOperator> hStreamOperator = HStreamOperator::NewInstance(callerToken_, opMode_);
426 if (hStreamOperator != nullptr) {
427 auto thisPtr = wptr<HCaptureSession>(this);
428 hStreamOperator->SetMechCallback([thisPtr](int32_t streamId,
429 const std::shared_ptr<OHOS::Camera::CameraMetadata> &result) {
430 auto sessionPtr = thisPtr.promote();
431 CHECK_RETURN(!sessionPtr);
432 auto &sessionManager = HCameraSessionManager::GetInstance();
433 auto mechSession = sessionManager.GetMechSession(sessionPtr->userId_);
434 CHECK_RETURN(!mechSession);
435 bool isNeedMirror = false;
436 bool isNeedFlip = false;
437 auto currentDevice = thisPtr->GetCameraDevice();
438 if (currentDevice != nullptr) {
439 int32_t position = currentDevice->GetCameraPosition();
440 isNeedMirror = (position == static_cast<int32_t>(OHOS_CAMERA_POSITION_FRONT));
441 int32_t usedAsPosition = currentDevice->GetUsedAsPosition();
442 isNeedFlip = (usedAsPosition == static_cast<int32_t>(OHOS_CAMERA_POSITION_FRONT));
443 }
444 mechSession->OnFocusTrackingInfo(streamId, isNeedMirror, isNeedFlip, result);
445 });
446 }
447 SetStreamOperator(hStreamOperator);
448 HStreamOperatorManager::GetInstance()->AddStreamOperator(hStreamOperator); // 单例管理streamoperator 待找唯一key
449 }
450
AddOutput(StreamType streamType,const sptr<IRemoteObject> & remoteObj)451 int32_t HCaptureSession::AddOutput(StreamType streamType, const sptr<IRemoteObject>& remoteObj)
452 {
453 CHECK_RETURN_RET_ELOG(remoteObj == nullptr, CAMERA_INVALID_ARG, "HCaptureSession remoteObj is null");
454 sptr<IStreamCommon> stream = nullptr;
455 if (streamType == StreamType::CAPTURE) {
456 stream = iface_cast<IStreamCapture>(remoteObj);
457 } else if (streamType == StreamType::REPEAT) {
458 stream = iface_cast<IStreamRepeat>(remoteObj);
459 } else if (streamType == StreamType::METADATA) {
460 stream = iface_cast<IStreamMetadata>(remoteObj);
461 } else if (streamType == StreamType::DEPTH) {
462 stream = iface_cast<IStreamDepthData>(remoteObj);
463 }
464 CHECK_RETURN_RET_ELOG(stream == nullptr, CAMERA_INVALID_ARG, "HCaptureSession stream is null");
465 return AddOutputInner(streamType, stream);
466 }
467
AddOutputInner(StreamType streamType,const sptr<IStreamCommon> & stream)468 int32_t HCaptureSession::AddOutputInner(StreamType streamType, const sptr<IStreamCommon>& stream)
469 {
470 int32_t errorCode = CAMERA_INVALID_ARG;
471 if (stream == nullptr) {
472 MEDIA_ERR_LOG("HCaptureSession::AddOutput stream is null, sessionID: %{public}d", GetSessionId());
473 CameraReportUtils::ReportCameraError(
474 "HCaptureSession::AddOutput", errorCode, false, CameraReportUtils::GetCallerInfo());
475 return errorCode;
476 }
477 stateMachine_.StateGuard([this, &errorCode, streamType, &stream](const CaptureSessionState currentState) {
478 InitialHStreamOperator();
479 auto hStreamOperatorSptr = GetStreamOperator();
480 CHECK_RETURN_ELOG(hStreamOperatorSptr == nullptr, "hStreamOperator_ is null");
481 if (currentState != CaptureSessionState::SESSION_CONFIG_INPROGRESS) {
482 MEDIA_ERR_LOG("HCaptureSession::AddOutput Need to call BeginConfig "
483 "before adding output, sessionID: %{public}d",
484 GetSessionId());
485 errorCode = CAMERA_INVALID_STATE;
486 return;
487 }
488 errorCode = hStreamOperatorSptr->AddOutput(streamType, stream);
489 });
490 if (errorCode == CAMERA_OK) {
491 CAMERA_SYSEVENT_STATISTIC(
492 CreateMsg("CaptureSession::AddOutput with %d, sessionID: %{public}d", streamType, GetSessionId()));
493 } else {
494 CameraReportUtils::ReportCameraError(
495 "HCaptureSession::AddOutput", errorCode, false, CameraReportUtils::GetCallerInfo());
496 }
497 MEDIA_INFO_LOG("CaptureSession::AddOutput with with %{public}d, rc = "
498 "%{public}d, sessionID: %{public}d",
499 streamType,
500 errorCode,
501 GetSessionId());
502 return errorCode;
503 }
504
RemoveInput(const sptr<ICameraDeviceService> & cameraDevice)505 int32_t HCaptureSession::RemoveInput(const sptr<ICameraDeviceService>& cameraDevice)
506 {
507 int32_t errorCode = CAMERA_OK;
508 if (cameraDevice == nullptr) {
509 errorCode = CAMERA_INVALID_ARG;
510 MEDIA_ERR_LOG("HCaptureSession::RemoveInput cameraDevice is null, "
511 "sessionID: %{public}d",
512 GetSessionId());
513 CameraReportUtils::ReportCameraError(
514 "HCaptureSession::RemoveInput", errorCode, false, CameraReportUtils::GetCallerInfo());
515 return errorCode;
516 }
517 MEDIA_INFO_LOG("HCaptureSession::RemoveInput prepare execute, sessionID: %{public}d", GetSessionId());
518 stateMachine_.StateGuard([this, &errorCode, &cameraDevice](const CaptureSessionState currentState) {
519 if (currentState != CaptureSessionState::SESSION_CONFIG_INPROGRESS) {
520 MEDIA_ERR_LOG("HCaptureSession::RemoveInput Need to call BeginConfig "
521 "before removing input, sessionID: %{public}d",
522 GetSessionId());
523 errorCode = CAMERA_INVALID_STATE;
524 return;
525 }
526 if (IsNeedDynamicConfig()) {
527 UnlinkInputAndOutputs();
528 ClearSketchRepeatStream();
529 ClearMovingPhotoRepeatStream();
530 }
531 auto currentDevice = GetCameraDevice();
532 if (currentDevice != nullptr && cameraDevice->AsObject() == currentDevice->AsObject()) {
533 // Do not close device while remove input!
534 MEDIA_INFO_LOG(
535 "HCaptureSession::RemoveInput camera id is %{public}s", currentDevice->GetCameraId().c_str());
536 currentDevice->ResetDeviceSettings();
537 SetCameraDevice(nullptr);
538 currentDevice->SetStreamOperatorCallback(nullptr);
539 } else {
540 MEDIA_ERR_LOG("HCaptureSession::RemoveInput Invalid camera device, "
541 "sessionID: %{public}d",
542 GetSessionId());
543 errorCode = CAMERA_INVALID_SESSION_CFG;
544 }
545 });
546 if (errorCode == CAMERA_OK) {
547 CAMERA_SYSEVENT_STATISTIC(CreateMsg("CaptureSession::RemoveInput, sessionID: %d", GetSessionId()));
548 } else {
549 CameraReportUtils::ReportCameraError(
550 "HCaptureSession::RemoveInput", errorCode, false, CameraReportUtils::GetCallerInfo());
551 }
552 MEDIA_INFO_LOG("HCaptureSession::RemoveInput execute success, sessionID: %{public}d", GetSessionId());
553 return errorCode;
554 }
555
RemoveOutputStream(sptr<HStreamCommon> stream)556 int32_t HCaptureSession::RemoveOutputStream(sptr<HStreamCommon> stream)
557 {
558 CAMERA_SYNC_TRACE;
559 CHECK_RETURN_RET_ELOG(
560 stream == nullptr, CAMERA_INVALID_ARG, "HCaptureSession::RemoveOutputStream stream is null");
561 MEDIA_INFO_LOG("HCaptureSession::RemoveOutputStream,streamType:%{public}d, streamId:%{public}d",
562 stream->GetStreamType(), stream->GetFwkStreamId());
563 auto hStreamOperatorSptr = GetStreamOperator();
564 CHECK_RETURN_RET_ELOG(hStreamOperatorSptr == nullptr, CAMERA_INVALID_ARG,
565 "hStreamOperatorSptr is null");
566 int32_t errorCode = hStreamOperatorSptr->RemoveOutputStream(stream);
567 CHECK_RETURN_RET_ELOG(errorCode != CAMERA_OK, CAMERA_INVALID_SESSION_CFG,
568 "HCaptureSession::RemoveOutputStream Invalid output");
569 return CAMERA_OK;
570 }
571
RemoveOutput(StreamType streamType,const sptr<IRemoteObject> & remoteObj)572 int32_t HCaptureSession::RemoveOutput(StreamType streamType, const sptr<IRemoteObject>& remoteObj)
573 {
574 CHECK_RETURN_RET_ELOG(remoteObj == nullptr, CAMERA_INVALID_ARG, "HCaptureSession remoteObj is null");
575 sptr<IStreamCommon> stream = nullptr;
576 if (streamType == StreamType::CAPTURE) {
577 stream = iface_cast<IStreamCapture>(remoteObj);
578 } else if (streamType == StreamType::REPEAT) {
579 stream = iface_cast<IStreamRepeat>(remoteObj);
580 } else if (streamType == StreamType::METADATA) {
581 stream = iface_cast<IStreamMetadata>(remoteObj);
582 } else if (streamType == StreamType::DEPTH) {
583 stream = iface_cast<IStreamDepthData>(remoteObj);
584 }
585 CHECK_RETURN_RET_ELOG(stream == nullptr, CAMERA_INVALID_ARG, "HCaptureSession remoteObj is null");
586 return RemoveOutputInner(streamType, stream);
587 }
588
RemoveOutputInner(StreamType streamType,const sptr<IStreamCommon> & stream)589 int32_t HCaptureSession::RemoveOutputInner(StreamType streamType, const sptr<IStreamCommon>& stream)
590 {
591 int32_t errorCode = CAMERA_INVALID_ARG;
592 if (stream == nullptr) {
593 MEDIA_ERR_LOG("HCaptureSession::RemoveOutput stream is null, sessionID: %{public}d", GetSessionId());
594 CameraReportUtils::ReportCameraError(
595 "HCaptureSession::RemoveOutput", errorCode, false, CameraReportUtils::GetCallerInfo());
596 return errorCode;
597 }
598 MEDIA_INFO_LOG("HCaptureSession::RemoveOutput prepare execute, sessionID: %{public}d", GetSessionId());
599 stateMachine_.StateGuard([this, &errorCode, streamType, &stream](const CaptureSessionState currentState) {
600 if (currentState != CaptureSessionState::SESSION_CONFIG_INPROGRESS) {
601 MEDIA_ERR_LOG("HCaptureSession::RemoveOutput Need to call BeginConfig "
602 "before removing output, sessionID: %{public}d",
603 GetSessionId());
604 errorCode = CAMERA_INVALID_STATE;
605 return;
606 }
607 auto hStreamOperatorSptr = GetStreamOperator();
608 CHECK_RETURN_ELOG(hStreamOperatorSptr == nullptr, "hStreamOperatorSptr is null");
609 errorCode = hStreamOperatorSptr->RemoveOutput(streamType, stream);
610 });
611 if (errorCode == CAMERA_OK) {
612 CAMERA_SYSEVENT_STATISTIC(
613 CreateMsg("CaptureSession::RemoveOutput with %d, sessionID: %d", streamType, GetSessionId()));
614 } else {
615 CameraReportUtils::ReportCameraError(
616 "HCaptureSession::RemoveOutput", errorCode, false, CameraReportUtils::GetCallerInfo());
617 }
618 MEDIA_INFO_LOG("HCaptureSession::RemoveOutput execute success, sessionID: %{public}d", GetSessionId());
619 return errorCode;
620 }
621
ValidateSessionInputs()622 int32_t HCaptureSession::ValidateSessionInputs()
623 {
624 CHECK_RETURN_RET_ELOG(GetCameraDevice() == nullptr,
625 CAMERA_INVALID_SESSION_CFG,
626 "HCaptureSession::ValidateSessionInputs No inputs "
627 "present, sessionID: %{public}d",
628 GetSessionId());
629 return CAMERA_OK;
630 }
631
ValidateSessionOutputs()632 int32_t HCaptureSession::ValidateSessionOutputs()
633 {
634 auto hStreamOperatorSptr = GetStreamOperator();
635 CHECK_RETURN_RET_ELOG((hStreamOperatorSptr == nullptr || hStreamOperatorSptr->GetStreamsSize() == 0),
636 CAMERA_INVALID_SESSION_CFG, "HCaptureSession::ValidateSessionOutputs No outputs present");
637 return CAMERA_OK;
638 }
639
LinkInputAndOutputs()640 int32_t HCaptureSession::LinkInputAndOutputs()
641 {
642 int32_t rc;
643 auto hStreamOperatorSptr = GetStreamOperator();
644 CHECK_RETURN_RET_ELOG(hStreamOperatorSptr == nullptr, CAMERA_INVALID_SESSION_CFG,
645 "HCaptureSession::ValidateSessionOutputs No outputs present");
646 auto device = GetCameraDevice();
647 CHECK_RETURN_RET_ELOG(device == nullptr, CAMERA_INVALID_SESSION_CFG,
648 "HCaptureSession::LinkInputAndOutputs device is null");
649 auto settings = device->GetDeviceAbility();
650 CHECK_RETURN_RET_ELOG(settings == nullptr, CAMERA_UNKNOWN_ERROR,
651 "HCaptureSession::LinkInputAndOutputs deviceAbility is null");
652 CHECK_RETURN_RET_ELOG(!IsValidMode(opMode_, settings), CAMERA_INVALID_SESSION_CFG,
653 "HCaptureSession::LinkInputAndOutputs IsValidMode false");
654 rc = hStreamOperatorSptr->LinkInputAndOutputs(settings, GetopMode());
655 MEDIA_INFO_LOG("HCaptureSession::LinkInputAndOutputs execute success");
656 return rc;
657 }
658
GetVirtualApertureMetadate(std::vector<float> & virtualApertureMetadata)659 int32_t HCaptureSession::GetVirtualApertureMetadate(std::vector<float>& virtualApertureMetadata)
660 {
661 CHECK_RETURN_RET_ELOG(!controlCenterPrecondition, CAMERA_INVALID_STATE,
662 "HCaptureSession::GetVirtualApertureMetadate controlCenterPrecondition false");
663 MEDIA_INFO_LOG("HCaptureSession::GetVirtualApertureMetadate");
664 uint32_t callerToken = IPCSkeleton::GetCallingTokenID();
665 int32_t errCode = CheckPermission(OHOS_PERMISSION_CAMERA, callerToken);
666 CHECK_RETURN_RET_ELOG(errCode != CAMERA_OK, errCode,
667 "HCaptureSession::GetVirtualApertureMetadate check permission failed.");
668
669 std::vector<float> supportedVirtualAperture = {};
670 auto device = GetCameraDevice();
671 CHECK_RETURN_RET(!device, CAMERA_INVALID_STATE);
672 auto settings = device->GetDeviceAbility();
673 camera_metadata_item_t item;
674 int ret = OHOS::Camera::FindCameraMetadataItem(settings->get(),
675 OHOS_ABILITY_CAMERA_VIRTUAL_APERTURE_RANGE, &item);
676 CHECK_RETURN_RET_ELOG(
677 ret != CAMERA_OK, ret, "CaptureSession::GetSupportedBeautyTypes abilityId is NULL");
678 for (uint32_t i = 0; i < item.count; i++) {
679 supportedVirtualAperture.emplace_back(item.data.f[i]);
680 }
681 virtualApertureMetadata = supportedVirtualAperture;
682 CHECK_EXECUTE(supportedVirtualAperture.size() > 0, biggestAperture = supportedVirtualAperture.back());
683 return CAMERA_OK;
684 }
685
GetVirtualApertureValue(float & value)686 int32_t HCaptureSession::GetVirtualApertureValue(float& value)
687 {
688 CHECK_RETURN_RET_ELOG(!controlCenterPrecondition, CAMERA_INVALID_STATE,
689 "HCaptureSession::GetVirtualApertureValue controlCenterPrecondition false");
690 MEDIA_INFO_LOG("HCaptureSession::GetVirtualApertureValue");
691 uint32_t callerToken = IPCSkeleton::GetCallingTokenID();
692 int32_t errCode = CheckPermission(OHOS_PERMISSION_CAMERA, callerToken);
693 CHECK_RETURN_RET_ELOG(errCode != CAMERA_OK, errCode,
694 "HCaptureSession::GetVirtualApertureValue check permission failed.");
695 return GetVirtualApertureFromDataShareHelper(value);
696 }
697
SetVirtualApertureValue(float value,bool needPersist)698 int32_t HCaptureSession::SetVirtualApertureValue(float value, bool needPersist)
699 {
700 CHECK_RETURN_RET_ELOG(!controlCenterPrecondition, CAMERA_INVALID_STATE,
701 "HCaptureSession::SetVirtualApertureValue controlCenterPrecondition false");
702 MEDIA_INFO_LOG("HCaptureSession::SetVirtualApertureValue");
703 uint32_t callerToken = IPCSkeleton::GetCallingTokenID();
704 int32_t errCode = CheckPermission(OHOS_PERMISSION_CAMERA, callerToken);
705 CHECK_RETURN_RET_ELOG(errCode != CAMERA_OK, errCode,
706 "HCaptureSession::SetVirtualApertureValue check permission failed.");
707
708 auto device = GetCameraDevice();
709 CHECK_RETURN_RET(!device, CAMERA_INVALID_STATE);
710 int32_t ret;
711 constexpr int32_t DEFAULT_ITEMS = 1;
712 constexpr int32_t DEFAULT_DATA_LENGTH = 1;
713 shared_ptr<OHOS::Camera::CameraMetadata> changedMetadata =
714 make_shared<OHOS::Camera::CameraMetadata>(DEFAULT_ITEMS, DEFAULT_DATA_LENGTH);
715 AddOrUpdateMetadata(changedMetadata,
716 OHOS_CONTROL_CAMERA_VIRTUAL_APERTURE_VALUE, &value, 1);
717 ret = device->UpdateSetting(changedMetadata);
718 CHECK_RETURN_RET_ELOG(ret != CAMERA_OK, CAMERA_UNKNOWN_ERROR, "UpdateMuteSetting muteMode Failed");
719 if (needPersist) {
720 SetVirtualApertureToDataShareHelper(value);
721 }
722 if (isApertureActive == false && value > 0) {
723 ControlCenterStatusInfo statusInfo = {ControlCenterEffectType::PORTRAIT, true};
724 SetControlCenterEffectCallbackStatus(statusInfo);
725 isApertureActive = true;
726 }
727 if (isApertureActive == true && (isEqual(value, biggestAperture) || isEqual(value, 0))) {
728 ControlCenterStatusInfo statusInfo = {ControlCenterEffectType::PORTRAIT, false};
729 SetControlCenterEffectCallbackStatus(statusInfo);
730 isApertureActive = false;
731 }
732 return 0;
733 }
734
GetBeautyMetadata(std::vector<int32_t> & beautyApertureMetadata)735 int32_t HCaptureSession::GetBeautyMetadata(std::vector<int32_t>& beautyApertureMetadata)
736 {
737 CHECK_RETURN_RET_ELOG(!controlCenterPrecondition, CAMERA_INVALID_STATE,
738 "HCaptureSession::GetBeautyMetadata controlCenterPrecondition false");
739 MEDIA_INFO_LOG("HCaptureSession::GetBeautyMetadata");
740 uint32_t callerToken = IPCSkeleton::GetCallingTokenID();
741 int32_t errCode = CheckPermission(OHOS_PERMISSION_CAMERA, callerToken);
742 CHECK_RETURN_RET_ELOG(errCode != CAMERA_OK, errCode,
743 "HCaptureSession::GetBeautyMetadata check permission failed.");
744
745 std::vector<int32_t> supportedBeautyTypes = {};
746 auto device = GetCameraDevice();
747 CHECK_RETURN_RET(!device, CAMERA_INVALID_STATE);
748 auto settings = device->GetDeviceAbility();
749 camera_metadata_item_t item;
750 int ret = OHOS::Camera::FindCameraMetadataItem(settings->get(), OHOS_ABILITY_SCENE_BEAUTY_TYPES, &item);
751 CHECK_RETURN_RET_ELOG(
752 ret != CAMERA_OK, -1, "CaptureSession::GetSupportedBeautyTypes abilityId is NULL");
753 for (uint32_t i = 0; i < item.count; i++) {
754 auto itr = h_metaBeautyTypeMap_.find(static_cast<camera_beauty_type_t>(item.data.u8[i]));
755 if (itr != h_metaBeautyTypeMap_.end()) {
756 supportedBeautyTypes.emplace_back(itr->second);
757 }
758 }
759 beautyApertureMetadata = supportedBeautyTypes;
760 return CAMERA_OK;
761 }
762
GetBeautyRange(std::vector<int32_t> & range,int32_t type)763 int32_t HCaptureSession::GetBeautyRange(std::vector<int32_t>& range, int32_t type)
764 {
765 CHECK_RETURN_RET_ELOG(!controlCenterPrecondition, CAMERA_INVALID_STATE,
766 "HCaptureSession::GetBeautyRange controlCenterPrecondition false");
767 MEDIA_INFO_LOG("HCaptureSession::GetBeautyRange");
768 uint32_t callerToken = IPCSkeleton::GetCallingTokenID();
769 int32_t errCode = CheckPermission(OHOS_PERMISSION_CAMERA, callerToken);
770 CHECK_RETURN_RET_ELOG(errCode != CAMERA_OK, errCode,
771 "HCaptureSession::GetBeautyRange check permission failed.");
772
773 std::vector<int32_t> beautyRange = {};
774 auto device = GetCameraDevice();
775 CHECK_RETURN_RET(!device, CAMERA_INVALID_STATE);
776 auto settings = device->GetDeviceAbility();
777 camera_metadata_item_t item;
778 int ret = OHOS::Camera::FindCameraMetadataItem(settings->get(), OHOS_ABILITY_BEAUTY_AUTO_VALUES, &item);
779 CHECK_RETURN_RET_ELOG(
780 ret != CAMERA_OK, -1, "CaptureSession::GetSupportedBeautyTypes abilityId is NULL");
781 for (uint32_t i = 0; i < item.count; i++) {
782 beautyRange.emplace_back(item.data.u8[i]);
783 }
784 range = beautyRange;
785 return CAMERA_OK;
786 }
787
GetBeautyValue(int32_t type,int32_t & value)788 int32_t HCaptureSession::GetBeautyValue(int32_t type, int32_t& value)
789 {
790 CHECK_RETURN_RET_ELOG(!controlCenterPrecondition, CAMERA_INVALID_STATE,
791 "HCaptureSession::GetBeautyValue controlCenterPrecondition false");
792 MEDIA_INFO_LOG("HCaptureSession::GetBeautyValue");
793 uint32_t callerToken = IPCSkeleton::GetCallingTokenID();
794 int32_t errCode = CheckPermission(OHOS_PERMISSION_CAMERA, callerToken);
795 CHECK_RETURN_RET_ELOG(errCode != CAMERA_OK, errCode,
796 "HCaptureSession::GetBeautyValue check permission failed.");
797 return GetBeautyFromDataShareHelper(value);
798 }
799
SetBeautyValue(int32_t type,int32_t value,bool needPersist)800 int32_t HCaptureSession::SetBeautyValue(int32_t type, int32_t value, bool needPersist)
801 {
802 CHECK_RETURN_RET_ELOG(!controlCenterPrecondition, CAMERA_INVALID_STATE,
803 "HCaptureSession::SetBeautyValue controlCenterPrecondition false");
804 MEDIA_INFO_LOG("HCaptureSession::SetBeautyValue: %{public}d", value);
805 uint32_t callerToken = IPCSkeleton::GetCallingTokenID();
806 int32_t errCode = CheckPermission(OHOS_PERMISSION_CAMERA, callerToken);
807 CHECK_RETURN_RET_ELOG(errCode != CAMERA_OK, errCode,
808 "HCaptureSession::SetBeautyValue check permission failed.");
809
810 auto device = GetCameraDevice();
811 CHECK_RETURN_RET(!device, CAMERA_INVALID_STATE);
812 int32_t ret;
813 int32_t count = 1;
814 constexpr int32_t DEFAULT_ITEMS = 1;
815 constexpr int32_t DEFAULT_DATA_LENGTH = 1;
816 uint8_t beautyType = OHOS_CAMERA_BEAUTY_TYPE_AUTO;
817 shared_ptr<OHOS::Camera::CameraMetadata> changedMetadata =
818 make_shared<OHOS::Camera::CameraMetadata>(DEFAULT_ITEMS, DEFAULT_DATA_LENGTH);
819 AddOrUpdateMetadata(changedMetadata, OHOS_CONTROL_BEAUTY_TYPE, &beautyType, count);
820 AddOrUpdateMetadata(changedMetadata, OHOS_CONTROL_BEAUTY_AUTO_VALUE, &value, count);
821 ret = device->UpdateSetting(changedMetadata);
822 CHECK_RETURN_RET_ELOG(ret != CAMERA_OK, CAMERA_UNKNOWN_ERROR, "SetBeautyValue Failed");
823 if (needPersist) {
824 SetBeautyToDataShareHelper(value);
825 }
826 if (isBeautyActive == false && value > 0) {
827 ControlCenterStatusInfo statusInfo = {ControlCenterEffectType::BEAUTY, true};
828 SetControlCenterEffectCallbackStatus(statusInfo);
829 isBeautyActive = true;
830 }
831 if (isBeautyActive == true && value == 0) {
832 ControlCenterStatusInfo statusInfo = {ControlCenterEffectType::BEAUTY, false};
833 SetControlCenterEffectCallbackStatus(statusInfo);
834 isBeautyActive = false;
835 }
836 return CAMERA_OK;
837 }
838
SetVirtualApertureToDataShareHelper(float value)839 int32_t HCaptureSession::SetVirtualApertureToDataShareHelper(float value)
840 {
841 MEDIA_INFO_LOG("HCaptureSession::SetVirtualApertureToDataShareHelper value: %{public}f", value);
842 lock_guard<mutex> lock(g_dataShareHelperMutex);
843 CHECK_RETURN_RET_ELOG(cameraDataShareHelper_ == nullptr, CAMERA_ALLOC_ERROR,
844 "GetMuteModeFromDataShareHelper NULL");
845
846 std::string dataString = "";
847 auto ret = cameraDataShareHelper_->QueryOnce(CONTROL_CENTER_DATA, dataString);
848 MEDIA_INFO_LOG("SetVirtualApertureToDataShareHelper Query ret = %{public}d, value = %{public}s",
849 ret, dataString.c_str());
850 CHECK_RETURN_RET_ELOG(ret != CAMERA_OK, ret, "SetVirtualApertureToDataShareHelper failed.");
851 std::map<std::string, std::array<float, CONTROL_CENTER_DATA_SIZE>> controlCenterMap
852 = StringToControlCenterMap(dataString);
853 std::string bundleName = GetBundleForControlCenter();
854 if (controlCenterMap.find(bundleName) != controlCenterMap.end()) {
855 CHECK_RETURN_RET_ELOG(controlCenterMap[bundleName].size() < CONTROL_CENTER_DATA_SIZE, CAMERA_INVALID_ARG,
856 "Parse string failed.");
857 controlCenterMap[bundleName][CONTROL_CENTER_APERTURE_INDEX] = value;
858 std::string controlCenterString = ControlCenterMapToString(controlCenterMap);
859 ret = cameraDataShareHelper_->UpdateOnce(CONTROL_CENTER_DATA, controlCenterString);
860 CHECK_RETURN_RET_ELOG(ret != CAMERA_OK, ret, "SetVirtualApertureToDataShareHelper failed.");
861 } else {
862 MEDIA_ERR_LOG("SetVirtualApertureToDataShareHelper failed, no bundle.");
863 return CAMERA_INVALID_STATE;
864 }
865 return CAMERA_OK;
866 }
867
GetVirtualApertureFromDataShareHelper(float & value)868 int32_t HCaptureSession::GetVirtualApertureFromDataShareHelper(float &value)
869 {
870 MEDIA_INFO_LOG("HCaptureSession::GetBeautyFromDataShareHelper");
871 lock_guard<mutex> lock(g_dataShareHelperMutex);
872 CHECK_RETURN_RET_ELOG(cameraDataShareHelper_ == nullptr, CAMERA_INVALID_ARG,
873 "GetBeautyFromDataShareHelper NULL");
874
875 std::string dataString = "";
876 auto ret = cameraDataShareHelper_->QueryOnce(CONTROL_CENTER_DATA, dataString);
877 MEDIA_INFO_LOG("GetVirtualApertureFromDataShareHelper Query ret = %{public}d, value = %{public}s",
878 ret, dataString.c_str());
879 if (ret != CAMERA_OK) {
880 value = 0;
881 return ret;
882 }
883 std::map<std::string, std::array<float, CONTROL_CENTER_DATA_SIZE>> controlCenterMap
884 = StringToControlCenterMap(dataString);
885 std::string bundleName = GetBundleForControlCenter();
886 if (controlCenterMap.find(bundleName) != controlCenterMap.end()) {
887 CHECK_RETURN_RET_ELOG(controlCenterMap[bundleName].size() < CONTROL_CENTER_DATA_SIZE, CAMERA_INVALID_ARG,
888 "Parse string failed.");
889 value = controlCenterMap[bundleName][CONTROL_CENTER_APERTURE_INDEX];
890 MEDIA_INFO_LOG("GetVirtualApertureFromDataShareHelper success, value: %{public}f", value);
891 } else {
892 MEDIA_ERR_LOG("GetVirtualApertureFromDataShareHelper failed, no bundle.");
893 return CAMERA_INVALID_STATE;
894 }
895 return CAMERA_OK;
896 }
897
SetBeautyToDataShareHelper(int32_t value)898 int32_t HCaptureSession::SetBeautyToDataShareHelper(int32_t value)
899 {
900 MEDIA_INFO_LOG("HCaptureSession::SetBeautyToDataShareHelper value: %{public}d", value);
901 lock_guard<mutex> lock(g_dataShareHelperMutex);
902 CHECK_RETURN_RET_ELOG(cameraDataShareHelper_ == nullptr, CAMERA_ALLOC_ERROR,
903 "GetMuteModeFromDataShareHelper NULL");
904
905 std::string dataString = "";
906 auto ret = cameraDataShareHelper_->QueryOnce(CONTROL_CENTER_DATA, dataString);
907 MEDIA_INFO_LOG("SetBeautyToDataShareHelper Query ret = %{public}d, value = %{public}s", ret, dataString.c_str());
908 CHECK_RETURN_RET_ELOG(ret != CAMERA_OK, ret, "SetBeautyToDataShareHelper failed.");
909 std::map<std::string, std::array<float, CONTROL_CENTER_DATA_SIZE>> controlCenterMap
910 = StringToControlCenterMap(dataString);
911 std::string bundleName = GetBundleForControlCenter();
912 if (controlCenterMap.find(bundleName) != controlCenterMap.end()) {
913 CHECK_RETURN_RET_ELOG(controlCenterMap[bundleName].size() < CONTROL_CENTER_DATA_SIZE, CAMERA_INVALID_ARG,
914 "Parse string failed.");
915 controlCenterMap[bundleName][CONTROL_CENTER_BEAUTY_INDEX] = value;
916 std::string controlCenterString = ControlCenterMapToString(controlCenterMap);
917 ret = cameraDataShareHelper_->UpdateOnce(CONTROL_CENTER_DATA, controlCenterString);
918 CHECK_RETURN_RET_ELOG(ret != CAMERA_OK, ret, "SetBeautyToDataShareHelper failed.");
919 } else {
920 MEDIA_ERR_LOG("SetBeautyToDataShareHelper failed, no bundle.");
921 return CAMERA_INVALID_STATE;
922 }
923 return CAMERA_OK;
924 }
925
GetBeautyFromDataShareHelper(int32_t & value)926 int32_t HCaptureSession::GetBeautyFromDataShareHelper(int32_t &value)
927 {
928 MEDIA_INFO_LOG("HCaptureSession::GetBeautyFromDataShareHelper");
929 lock_guard<mutex> lock(g_dataShareHelperMutex);
930 CHECK_RETURN_RET_ELOG(cameraDataShareHelper_ == nullptr, CAMERA_INVALID_ARG,
931 "GetBeautyFromDataShareHelper NULL");
932
933 std::string dataString = "";
934 auto ret = cameraDataShareHelper_->QueryOnce(CONTROL_CENTER_DATA, dataString);
935 MEDIA_INFO_LOG("GetBeautyFromDataShareHelper Query ret = %{public}d, value = %{public}s", ret, dataString.c_str());
936 if (ret != CAMERA_OK) {
937 value = 0;
938 return ret;
939 }
940 std::map<std::string, std::array<float, CONTROL_CENTER_DATA_SIZE>> controlCenterMap
941 = StringToControlCenterMap(dataString);
942 std::string bundleName = GetBundleForControlCenter();
943 if (controlCenterMap.find(bundleName) != controlCenterMap.end()) {
944 CHECK_RETURN_RET_ELOG(controlCenterMap[bundleName].size() < CONTROL_CENTER_DATA_SIZE, CAMERA_INVALID_ARG,
945 "Parse string failed.");
946 value = controlCenterMap[bundleName][CONTROL_CENTER_BEAUTY_INDEX];
947 MEDIA_INFO_LOG("GetBeautyFromDataShareHelper success, value: %{public}d", value);
948 } else {
949 MEDIA_ERR_LOG("GetBeautyFromDataShareHelper failed, no bundle.");
950 return CAMERA_INVALID_STATE;
951 }
952 return CAMERA_OK;
953 }
954
SetControlCenterPrecondition(bool precondition)955 void HCaptureSession::SetControlCenterPrecondition(bool precondition)
956 {
957 controlCenterPrecondition = precondition;
958 }
959
SetDeviceControlCenterAbility(bool ability)960 void HCaptureSession::SetDeviceControlCenterAbility(bool ability)
961 {
962 deviceControlCenterAbility = ability;
963 }
964
GetBundleForControlCenter()965 std::string HCaptureSession::GetBundleForControlCenter()
966 {
967 return bundleForControlCenter_;
968 }
969
SetBundleForControlCenter(std::string bundleName)970 void HCaptureSession::SetBundleForControlCenter(std::string bundleName)
971 {
972 MEDIA_ERR_LOG("HCaptureSession::SetBundleForControlCenter: %{public}s, ", bundleName.c_str());
973 bundleForControlCenter_ = bundleName;
974 }
975
UnlinkInputAndOutputs()976 int32_t HCaptureSession::UnlinkInputAndOutputs()
977 {
978 CAMERA_SYNC_TRACE;
979 int32_t rc = CAMERA_UNKNOWN_ERROR;
980 auto hStreamOperatorSptr = GetStreamOperator();
981 CHECK_RETURN_RET_ELOG(hStreamOperatorSptr == nullptr, rc,
982 "HCaptureSession::ValidateSessionOutputs No outputs present");
983 rc = hStreamOperatorSptr->UnlinkInputAndOutputs();
984 // HDI release streams, do not clear streamContainer_
985 return rc;
986 }
987
ExpandSketchRepeatStream()988 void HCaptureSession::ExpandSketchRepeatStream()
989 {
990 MEDIA_DEBUG_LOG("Enter HCaptureSession::ExpandSketchRepeatStream(), "
991 "sessionID: %{public}d", GetSessionId());
992 auto hStreamOperatorSptr = GetStreamOperator();
993 CHECK_RETURN_ELOG(hStreamOperatorSptr == nullptr,
994 "HCaptureSession::ValidateSessionOutputs No outputs present");
995 hStreamOperatorSptr->ExpandSketchRepeatStream();
996 MEDIA_DEBUG_LOG("Exit HCaptureSession::ExpandSketchRepeatStream()");
997 }
998
ExpandMovingPhotoRepeatStream()999 void HCaptureSession::ExpandMovingPhotoRepeatStream()
1000 {
1001 CAMERA_SYNC_TRACE;
1002 MEDIA_DEBUG_LOG("ExpandMovingPhotoRepeatStream enter, sessionID: %{public}d", GetSessionId());
1003 if (!GetCameraDevice()->CheckMovingPhotoSupported(GetopMode())) {
1004 MEDIA_DEBUG_LOG("movingPhoto is not supported, sessionID: %{public}d", GetSessionId());
1005 return;
1006 }
1007 auto hStreamOperatorSptr = GetStreamOperator();
1008 CHECK_RETURN_ELOG(hStreamOperatorSptr == nullptr,
1009 "HCaptureSession::ValidateSessionOutputs No outputs present");
1010 hStreamOperatorSptr->ExpandMovingPhotoRepeatStream();
1011 MEDIA_DEBUG_LOG("ExpandMovingPhotoRepeatStream Exit");
1012 }
1013
ClearSketchRepeatStream()1014 void HCaptureSession::ClearSketchRepeatStream()
1015 {
1016 MEDIA_DEBUG_LOG("Enter HCaptureSession::ClearSketchRepeatStream(), sessionID: %{public}d", GetSessionId());
1017
1018 auto hStreamOperatorSptr = GetStreamOperator();
1019 CHECK_RETURN_ELOG(hStreamOperatorSptr == nullptr, "hStreamOperator is nullptr");
1020 return hStreamOperatorSptr->ClearSketchRepeatStream();
1021 }
1022
ClearMovingPhotoRepeatStream()1023 void HCaptureSession::ClearMovingPhotoRepeatStream()
1024 {
1025 CAMERA_SYNC_TRACE;
1026 MEDIA_DEBUG_LOG("Enter HCaptureSession::ClearMovingPhotoRepeatStream(), "
1027 "sessionID: %{public}d",
1028 GetSessionId());
1029 // Already added session lock in BeginConfig()
1030 auto hStreamOperatorSptr = GetStreamOperator();
1031 CHECK_RETURN_ELOG(hStreamOperatorSptr == nullptr, "hStreamOperator is nullptr");
1032 return hStreamOperatorSptr->ClearMovingPhotoRepeatStream();
1033 }
1034
ValidateSession()1035 int32_t HCaptureSession::ValidateSession()
1036 {
1037 int32_t errorCode = CAMERA_OK;
1038 errorCode = ValidateSessionInputs();
1039 CHECK_RETURN_RET(errorCode != CAMERA_OK, errorCode);
1040 errorCode = ValidateSessionOutputs();
1041 return errorCode;
1042 }
1043
SetCommitConfigFlag(bool isNeedCommitting)1044 int32_t HCaptureSession::SetCommitConfigFlag(bool isNeedCommitting)
1045 {
1046 isNeedCommitting_ = isNeedCommitting;
1047 return CAMERA_OK;
1048 }
1049
CommitConfigWithValidation()1050 int32_t HCaptureSession::CommitConfigWithValidation()
1051 {
1052 auto device = GetCameraDevice();
1053 if (device == nullptr) {
1054 MEDIA_ERR_LOG("HCaptureSession::CommitConfig() Failed to commit config. "
1055 "camera device is null, sessionID: %{public}d", GetSessionId());
1056 return CAMERA_INVALID_STATE;
1057 }
1058 const int32_t secureMode = 15;
1059 uint64_t secureSeqId = 0L;
1060 device->GetSecureCameraSeq(&secureSeqId);
1061 if (((GetopMode() == secureMode) ^ (secureSeqId != 0))) {
1062 MEDIA_ERR_LOG("secureCamera is not allowed commit mode = %{public}d, "
1063 "sessionID: %{public}d.", GetopMode(), GetSessionId());
1064 return CAMERA_OPERATION_NOT_ALLOWED;
1065 }
1066 MEDIA_INFO_LOG("HCaptureSession::CommitConfig, sessionID: %{public}d, "
1067 "secureSeqId = %{public}" PRIu64 "", GetSessionId(), secureSeqId);
1068 int ret = LinkInputAndOutputs();
1069 if (ret != CAMERA_OK) {
1070 MEDIA_ERR_LOG("HCaptureSession::CommitConfig() Failed to commit config. rc: %{public}d", ret);
1071 return ret;
1072 }
1073
1074 stateMachine_.Transfer(CaptureSessionState::SESSION_CONFIG_COMMITTED);
1075 return CAMERA_OK;
1076 }
1077
CommitConfig()1078 int32_t HCaptureSession::CommitConfig()
1079 {
1080 CAMERA_SYNC_TRACE;
1081 MEDIA_INFO_LOG("HCaptureSession::CommitConfig begin, sessionID: %{public}d", GetSessionId());
1082 int32_t errorCode = CAMERA_OK;
1083 stateMachine_.StateGuard([&errorCode, this](CaptureSessionState currentState) {
1084 bool isTransferSupport = stateMachine_.CheckTransfer(CaptureSessionState::SESSION_CONFIG_COMMITTED);
1085 CHECK_RETURN_ELOG(!isTransferSupport, "HCaptureSession::CommitConfig() Need to call BeginConfig "
1086 "before committing configuration, sessionID: %{public}d", GetSessionId());
1087 if (isNeedCommitting_) {
1088 stateMachine_.Transfer(CaptureSessionState::SESSION_CONFIG_COMMITTED);
1089 return;
1090 }
1091 auto hStreamOperatorSptr = GetStreamOperator();
1092 CHECK_RETURN_ELOG(hStreamOperatorSptr == nullptr, "hStreamOperator is nullptr");
1093 hStreamOperatorSptr->GetStreamOperator();
1094 errorCode = ValidateSession();
1095 CHECK_RETURN(errorCode != CAMERA_OK);
1096 if (!IsNeedDynamicConfig()) {
1097 ExpandMovingPhotoRepeatStream(); // expand moving photo always
1098 ExpandSketchRepeatStream();
1099 }
1100 errorCode = CommitConfigWithValidation();
1101 });
1102 CHECK_EXECUTE(errorCode != CAMERA_OK, CameraReportUtils::ReportCameraError(
1103 "HCaptureSession::CommitConfig, sessionID: " + std::to_string(GetSessionId()),
1104 errorCode, false, CameraReportUtils::GetCallerInfo()));
1105 MEDIA_INFO_LOG("HCaptureSession::CommitConfig end, sessionID: %{public}d", GetSessionId());
1106 return errorCode;
1107 }
1108
GetActiveColorSpace(int32_t & curColorSpace)1109 int32_t HCaptureSession::GetActiveColorSpace(int32_t& curColorSpace)
1110 {
1111 auto hStreamOperatorSptr = GetStreamOperator();
1112 CHECK_RETURN_RET_ELOG(hStreamOperatorSptr == nullptr, CAMERA_OK, "hStreamOperator is nullptr");
1113 ColorSpace colorSpace;
1114 hStreamOperatorSptr->GetActiveColorSpace(colorSpace);
1115 curColorSpace = static_cast<int32_t>(colorSpace);
1116 return CAMERA_OK;
1117 }
1118
SetColorSpace(int32_t curColorSpace,bool isNeedUpdate)1119 int32_t HCaptureSession::SetColorSpace(int32_t curColorSpace, bool isNeedUpdate)
1120 {
1121 int32_t result = CAMERA_OK;
1122 ColorSpace colorSpace = static_cast<ColorSpace>(curColorSpace);
1123 stateMachine_.StateGuard(
1124 [&result, this, &colorSpace, &isNeedUpdate](CaptureSessionState currentState) {
1125 MEDIA_INFO_LOG("HCaptureSession::SetColorSpace() ColorSpace : %{public}d", colorSpace);
1126 if (!(currentState == CaptureSessionState::SESSION_CONFIG_INPROGRESS ||
1127 currentState == CaptureSessionState::SESSION_CONFIG_COMMITTED)) {
1128 MEDIA_ERR_LOG("HCaptureSession::SetColorSpace(), Invalid session state: "
1129 "%{public}d, sessionID: %{public}d",
1130 currentState,
1131 GetSessionId());
1132 result = CAMERA_INVALID_STATE;
1133 return;
1134 }
1135
1136 auto hStreamOperatorSptr = GetStreamOperator();
1137 CHECK_RETURN_ELOG(hStreamOperatorSptr == nullptr, "hStreamOperator is nullptr");
1138 result = hStreamOperatorSptr->SetColorSpace(colorSpace, isNeedUpdate);
1139 int32_t tempColorSpace;
1140 GetActiveColorSpace(tempColorSpace);
1141 if (result == CAMERA_OK && static_cast<ColorSpace>(tempColorSpace) != colorSpace && isNeedUpdate) {
1142 auto device = GetCameraDevice();
1143 CHECK_RETURN_ELOG(device == nullptr, "HCaptureSession::SetColorSpace device is null");
1144 std::shared_ptr<OHOS::Camera::CameraMetadata> settings = device->CloneCachedSettings();
1145 MEDIA_INFO_LOG("HCaptureSession::SetColorSpace() CloneCachedSettings");
1146 DumpMetadata(settings);
1147 result = hStreamOperatorSptr->UpdateStreamInfos(settings);
1148 }
1149 });
1150 return result;
1151 }
1152
GetSessionState(CaptureSessionState & sessionState)1153 int32_t HCaptureSession::GetSessionState(CaptureSessionState& sessionState)
1154 {
1155 sessionState = stateMachine_.GetCurrentState();
1156 return CAMERA_OK;
1157 }
1158
QueryFpsAndZoomRatio(float & currentFps,float & currentZoomRatio,std::vector<float> & crossZoomAndTime,int32_t operationMode)1159 bool HCaptureSession::QueryFpsAndZoomRatio(
1160 float ¤tFps, float ¤tZoomRatio, std::vector<float> &crossZoomAndTime, int32_t operationMode)
1161 {
1162 auto cameraDevice = GetCameraDevice();
1163 CHECK_RETURN_RET_ELOG(
1164 cameraDevice == nullptr, false, "HCaptureSession::QueryFpsAndZoomRatio() cameraDevice is null");
1165 // LCOV_EXCL_START
1166 int32_t DEFAULT_ITEMS = 3;
1167 int32_t DEFAULT_DATA_LENGTH = 200;
1168 std::shared_ptr<OHOS::Camera::CameraMetadata> metaIn =
1169 std::make_shared<OHOS::Camera::CameraMetadata>(DEFAULT_ITEMS, DEFAULT_DATA_LENGTH);
1170 std::shared_ptr<OHOS::Camera::CameraMetadata> metaOut =
1171 std::make_shared<OHOS::Camera::CameraMetadata>(DEFAULT_ITEMS, DEFAULT_DATA_LENGTH);
1172 uint32_t count = 1;
1173 uint32_t fps = 30;
1174 uint32_t zoomRatio = 100;
1175 uint32_t arrayCount = 154;
1176 std::vector<uint32_t> vctZoomRatio;
1177 vctZoomRatio.resize(arrayCount, 0);
1178 metaIn->addEntry(OHOS_STATUS_CAMERA_CURRENT_FPS, &fps, count);
1179 metaIn->addEntry(OHOS_STATUS_CAMERA_CURRENT_ZOOM_RATIO, &zoomRatio, count);
1180 metaIn->addEntry(OHOS_STATUS_CAMERA_ZOOM_PERFORMANCE, vctZoomRatio.data(), arrayCount);
1181 cameraDevice->GetStatus(metaIn, metaOut);
1182 camera_metadata_item_t item;
1183 int retFindMeta =
1184 OHOS::Camera::FindCameraMetadataItem(metaOut->get(), OHOS_STATUS_CAMERA_CURRENT_ZOOM_RATIO, &item);
1185 CHECK_RETURN_RET_ELOG(retFindMeta == CAM_META_ITEM_NOT_FOUND || item.count == 0, false,
1186 "HCaptureSession::QueryFpsAndZoomRatio() current zoom not found, sessionID: %{public}d", GetSessionId());
1187 if (retFindMeta == CAM_META_SUCCESS) {
1188 currentZoomRatio = static_cast<float>(item.data.ui32[0]);
1189 MEDIA_INFO_LOG("HCaptureSession::QueryFpsAndZoomRatio() current zoom "
1190 "%{public}d, sessionID: %{public}d.", item.data.ui32[0], GetSessionId());
1191 }
1192 retFindMeta = OHOS::Camera::FindCameraMetadataItem(metaOut->get(), OHOS_STATUS_CAMERA_CURRENT_FPS, &item);
1193 CHECK_RETURN_RET_ELOG(retFindMeta == CAM_META_ITEM_NOT_FOUND || item.count == 0, false,
1194 "HCaptureSession::QueryFpsAndZoomRatio() current fps not found, sessionID: %{public}d", GetSessionId());
1195 if (retFindMeta == CAM_META_SUCCESS) {
1196 currentFps = static_cast<float>(item.data.ui32[0]);
1197 MEDIA_INFO_LOG("HCaptureSession::QueryFpsAndZoomRatio() current fps "
1198 "%{public}d, sessionID: %{public}d.", item.data.ui32[0], GetSessionId());
1199 }
1200 retFindMeta = OHOS::Camera::FindCameraMetadataItem(metaOut->get(), OHOS_STATUS_CAMERA_ZOOM_PERFORMANCE, &item);
1201 CHECK_RETURN_RET_ELOG(retFindMeta == CAM_META_ITEM_NOT_FOUND || item.count == 0, false,
1202 "HCaptureSession::QueryFpsAndZoomRatio() current PERFORMANCE not found, sessionID: %{public}d",
1203 GetSessionId());
1204 if (retFindMeta == CAM_META_SUCCESS) {
1205 MEDIA_INFO_LOG("HCaptureSession::QueryFpsAndZoomRatio() zoom performance count %{public}d,"
1206 "sessionID: %{public}d.", item.count, GetSessionId());
1207 QueryZoomPerformance(crossZoomAndTime, operationMode, item);
1208 }
1209 return true;
1210 // LCOV_EXCL_STOP
1211 }
1212
QueryZoomPerformance(std::vector<float> & crossZoomAndTime,int32_t operationMode,const camera_metadata_item_t & zoomItem)1213 bool HCaptureSession::QueryZoomPerformance(
1214 std::vector<float> &crossZoomAndTime, int32_t operationMode, const camera_metadata_item_t &zoomItem)
1215 {
1216 auto cameraDevice = GetCameraDevice();
1217 CHECK_RETURN_RET_ELOG(
1218 cameraDevice == nullptr, false, "HCaptureSession::QueryZoomPerformance() cameraDevice is null");
1219 // query zoom performance. begin
1220 std::shared_ptr<OHOS::Camera::CameraMetadata> ability = cameraDevice->GetDeviceAbility();
1221 MEDIA_DEBUG_LOG("HCaptureSession::QueryZoomPerformance() zoom performance count %{public}d.", zoomItem.count);
1222 for (int i = 0; i < static_cast<int>(zoomItem.count); i++) {
1223 MEDIA_DEBUG_LOG(
1224 "HCaptureSession::QueryZoomPerformance() zoom performance value %{public}d.", zoomItem.data.ui32[i]);
1225 }
1226 int dataLenPerPoint = 3;
1227 int headLenPerMode = 2;
1228 MEDIA_DEBUG_LOG("HCaptureSession::QueryZoomPerformance() operationMode %{public}d, "
1229 "sessionID: %{public}d.",
1230 static_cast<OHOS::HDI::Camera::V1_3::OperationMode>(operationMode),
1231 GetSessionId());
1232 for (int i = 0; i < static_cast<int>(zoomItem.count);) {
1233 int sceneMode = static_cast<int>(zoomItem.data.ui32[i]);
1234 int zoomPointsNum = static_cast<int>(zoomItem.data.ui32[i + 1]);
1235 if (static_cast<OHOS::HDI::Camera::V1_3::OperationMode>(operationMode) == sceneMode) {
1236 for (int j = 0; j < dataLenPerPoint * zoomPointsNum; j++) {
1237 crossZoomAndTime.push_back(zoomItem.data.ui32[i + headLenPerMode + j]);
1238 MEDIA_DEBUG_LOG("HCaptureSession::QueryZoomPerformance() crossZoomAndTime "
1239 "%{public}d, sessionID: %{public}d.",
1240 static_cast<int>(zoomItem.data.ui32[i + headLenPerMode + j]),
1241 GetSessionId());
1242 }
1243 break;
1244 } else {
1245 i = i + 1 + zoomPointsNum * dataLenPerPoint + 1;
1246 }
1247 }
1248 return true;
1249 }
1250
GetSensorOritation()1251 int32_t HCaptureSession::GetSensorOritation()
1252 {
1253 auto cameraDevice = GetCameraDevice();
1254 int32_t sensorOrientation = 0;
1255 CHECK_RETURN_RET_ELOG(cameraDevice == nullptr,
1256 sensorOrientation,
1257 "HCaptureSession::GetSensorOritation() "
1258 "cameraDevice is null, sessionID: %{public}d",
1259 GetSessionId());
1260 std::shared_ptr<OHOS::Camera::CameraMetadata> ability = cameraDevice->GetDeviceAbility();
1261 CHECK_RETURN_RET(ability == nullptr, sensorOrientation);
1262 camera_metadata_item_t item;
1263 int ret = OHOS::Camera::FindCameraMetadataItem(ability->get(), OHOS_SENSOR_ORIENTATION, &item);
1264 CHECK_RETURN_RET_ELOG(ret != CAM_META_SUCCESS, sensorOrientation,
1265 "HCaptureSession::GetSensorOritation get sensor orientation failed");
1266 sensorOrientation = item.data.i32[0];
1267 MEDIA_INFO_LOG("HCaptureSession::GetSensorOritation sensor orientation "
1268 "%{public}d, sessionID: %{public}d",
1269 sensorOrientation,
1270 GetSessionId());
1271 return sensorOrientation;
1272 }
1273
GetRangeId(float & zoomRatio,std::vector<float> & crossZoom)1274 int32_t HCaptureSession::GetRangeId(float& zoomRatio, std::vector<float>& crossZoom)
1275 {
1276 int32_t rangId = 0;
1277 for (; rangId < static_cast<int>(crossZoom.size()); rangId++) {
1278 CHECK_RETURN_RET(zoomRatio < crossZoom[rangId], rangId);
1279 }
1280 return rangId;
1281 }
1282
isEqual(float zoomPointA,float zoomPointB)1283 bool HCaptureSession::isEqual(float zoomPointA, float zoomPointB)
1284 {
1285 float epsilon = 0.00001f;
1286 return fabs(zoomPointA - zoomPointB) < epsilon;
1287 }
1288
GetCrossZoomAndTime(std::vector<float> & crossZoomAndTime,std::vector<float> & crossZoom,std::vector<std::vector<float>> & crossTime)1289 void HCaptureSession::GetCrossZoomAndTime(
1290 std::vector<float>& crossZoomAndTime, std::vector<float>& crossZoom, std::vector<std::vector<float>>& crossTime)
1291 {
1292 int dataLenPerPoint = 3;
1293 for (int i = 0; i < static_cast<int>(crossZoomAndTime.size()); i = i + dataLenPerPoint) {
1294 if (crossZoomAndTime[i] != 0) {
1295 crossZoom.push_back(crossZoomAndTime[i]);
1296 }
1297 crossTime[i / dataLenPerPoint][ZOOM_IN_PER] = crossZoomAndTime[i + ZOOM_IN_PER + 1];
1298 crossTime[i / dataLenPerPoint][ZOOM_OUT_PERF] = crossZoomAndTime[i + ZOOM_OUT_PERF + 1];
1299 }
1300 }
1301
GetCrossWaitTime(std::vector<std::vector<float>> & crossTime,int32_t targetRangeId,int32_t currentRangeId)1302 float HCaptureSession::GetCrossWaitTime(
1303 std::vector<std::vector<float>>& crossTime, int32_t targetRangeId, int32_t currentRangeId)
1304 {
1305 float waitTime = 0.0; // 100 199 370 获取maxWaitTime
1306 switch (currentRangeId) {
1307 case WIDE_CAMERA_ZOOM_RANGE:
1308 if (targetRangeId == TELE_CAMERA_ZOOM_RANGE) {
1309 waitTime = crossTime[WIDE_TELE_ZOOM_PER][ZOOM_IN_PER];
1310 } else {
1311 waitTime = crossTime[WIDE_MAIN_ZOOM_PER][ZOOM_IN_PER];
1312 }
1313 break;
1314 case MAIN_CAMERA_ZOOM_RANGE:
1315 if (targetRangeId == TELE_CAMERA_ZOOM_RANGE) {
1316 waitTime = crossTime[TELE_MAIN_ZOOM_PER][ZOOM_IN_PER];
1317 } else if (targetRangeId == WIDE_CAMERA_ZOOM_RANGE) {
1318 waitTime = crossTime[WIDE_MAIN_ZOOM_PER][ZOOM_OUT_PERF];
1319 }
1320 break;
1321 case TWO_X_EXIT_TELE_ZOOM_RANGE:
1322 if (targetRangeId == TELE_CAMERA_ZOOM_RANGE) {
1323 waitTime = crossTime[TELE_2X_ZOOM_PER][ZOOM_IN_PER];
1324 } else if (targetRangeId == WIDE_CAMERA_ZOOM_RANGE) {
1325 waitTime = crossTime[WIDE_MAIN_ZOOM_PER][ZOOM_OUT_PERF];
1326 } else {
1327 MEDIA_DEBUG_LOG("HCaptureSession::GetCrossWaitTime pass");
1328 }
1329 break;
1330 case TELE_CAMERA_ZOOM_RANGE:
1331 if (targetRangeId == WIDE_CAMERA_ZOOM_RANGE) {
1332 waitTime = crossTime[WIDE_TELE_ZOOM_PER][ZOOM_OUT_PERF];
1333 } else if (targetRangeId == TWO_X_EXIT_TELE_ZOOM_RANGE) {
1334 waitTime = crossTime[TELE_2X_ZOOM_PER][ZOOM_OUT_PERF];
1335 } else {
1336 waitTime = crossTime[TELE_MAIN_ZOOM_PER][ZOOM_OUT_PERF];
1337 }
1338 break;
1339 }
1340 MEDIA_DEBUG_LOG("HCaptureSession::GetCrossWaitTime waitTime %{public}f, "
1341 "targetRangeId %{public}d,"
1342 " currentRangeId %{public}d, sessionID: %{public}d",
1343 waitTime,
1344 targetRangeId,
1345 currentRangeId,
1346 GetSessionId());
1347 return waitTime;
1348 }
1349
QueryZoomBezierValue(std::vector<float> & zoomBezierValue)1350 bool HCaptureSession::QueryZoomBezierValue(std::vector<float> &zoomBezierValue)
1351 {
1352 auto cameraDevice = GetCameraDevice();
1353 CHECK_RETURN_RET_ELOG(
1354 cameraDevice == nullptr, false, "HCaptureSession::QueryZoomBezierValue() cameraDevice is null");
1355 std::shared_ptr<OHOS::Camera::CameraMetadata> ability = cameraDevice->GetDeviceAbility();
1356 camera_metadata_item_t bezierItem;
1357 int retFindMeta =
1358 OHOS::Camera::FindCameraMetadataItem(ability->get(), OHOS_ABILITY_CAMERA_ZOOM_BEZIER_CURVC_POINT, &bezierItem);
1359 CHECK_RETURN_RET_ELOG(retFindMeta == CAM_META_ITEM_NOT_FOUND, false,
1360 "HCaptureSession::QueryZoomBezierValue() current bezierValue not found");
1361 for (int i = 0; i < static_cast<int>(bezierItem.count); i++) {
1362 zoomBezierValue.push_back(bezierItem.data.f[i]);
1363 MEDIA_DEBUG_LOG("HCaptureSession::QueryZoomBezierValue() bezierValue %{public}f.",
1364 static_cast<float>(bezierItem.data.f[i]));
1365 }
1366 return true;
1367 }
1368
SetSmoothZoom(int32_t smoothZoomType,int32_t operationMode,float targetZoomRatio,float & duration)1369 int32_t HCaptureSession::SetSmoothZoom(
1370 int32_t smoothZoomType, int32_t operationMode, float targetZoomRatio, float& duration)
1371 {
1372 constexpr int32_t ZOOM_RATIO_MULTIPLE = 100;
1373 const int32_t MAX_FPS = 60;
1374 auto cameraDevice = GetCameraDevice();
1375 CHECK_RETURN_RET_ELOG(cameraDevice == nullptr, CAMERA_UNKNOWN_ERROR,
1376 "HCaptureSession::SetSmoothZoom device is null, sessionID: %{public}d", GetSessionId());
1377 float currentFps = 30.0f;
1378 float currentZoomRatio = 1.0f;
1379 int32_t targetRangeId = 0;
1380 int32_t currentRangeId = 0;
1381 std::vector<float> crossZoomAndTime {};
1382 std::vector<float> zoomBezierValue {};
1383 QueryFpsAndZoomRatio(currentFps, currentZoomRatio, crossZoomAndTime, operationMode);
1384 currentFps = currentFps > MAX_FPS ? MAX_FPS : currentFps;
1385 std::vector<float> mCrossZoom {};
1386 int32_t waitCount = 4;
1387 int32_t zoomInOutCount = 2;
1388 std::vector<std::vector<float>> crossTime(waitCount, std::vector<float>(zoomInOutCount, 0.0f)); // 生成4x2二维数组
1389 GetCrossZoomAndTime(crossZoomAndTime, mCrossZoom, crossTime);
1390 float frameIntervalMs = 1000.0 / currentFps;
1391 targetZoomRatio = targetZoomRatio * ZOOM_RATIO_MULTIPLE;
1392 targetRangeId = GetRangeId(targetZoomRatio, mCrossZoom);
1393 currentRangeId = GetRangeId(currentZoomRatio, mCrossZoom);
1394 float waitMs = GetCrossWaitTime(crossTime, targetRangeId, currentRangeId);
1395 bool retHaveBezierValue = QueryZoomBezierValue(zoomBezierValue);
1396 auto zoomAlgorithm = SmoothZoom::GetZoomAlgorithm(static_cast<SmoothZoomType>(smoothZoomType));
1397 if (retHaveBezierValue && zoomBezierValue.size() == ZOOM_BEZIER_VALUE_COUNT) {
1398 zoomAlgorithm->SetBezierValue(zoomBezierValue);
1399 }
1400 auto array = zoomAlgorithm->GetZoomArray(currentZoomRatio, targetZoomRatio, frameIntervalMs);
1401 CHECK_RETURN_RET_ELOG(array.empty(), CAMERA_UNKNOWN_ERROR, "HCaptureSession::SetSmoothZoom array is empty");
1402 if (currentZoomRatio < targetZoomRatio) {
1403 std::sort(mCrossZoom.begin(), mCrossZoom.end());
1404 } else {
1405 std::sort(mCrossZoom.begin(), mCrossZoom.end(), std::greater<float>());
1406 }
1407 float waitTime = 0.0f;
1408 waitTime = CalculateWaitTime(mCrossZoom, currentZoomRatio, targetZoomRatio, waitMs, frameIntervalMs, array);
1409 std::vector<uint32_t> zoomAndTimeArray {};
1410 for (int i = 0; i < static_cast<int>(array.size()); i++) {
1411 zoomAndTimeArray.push_back(static_cast<uint32_t>(array[i]));
1412 zoomAndTimeArray.push_back(static_cast<uint32_t>(i * frameIntervalMs + waitTime));
1413 MEDIA_DEBUG_LOG("HCaptureSession::SetSmoothZoom() zoom %{public}d, waitMs %{public}d.",
1414 static_cast<uint32_t>(array[i]), static_cast<uint32_t>(i * frameIntervalMs + waitTime));
1415 }
1416 duration = (static_cast<int>(array.size()) - 1) * frameIntervalMs + waitTime;
1417 MEDIA_DEBUG_LOG("HCaptureSession::SetSmoothZoom() duration %{public}f, "
1418 "sessionID: %{public}d", duration, GetSessionId());
1419 ProcessMetaZoomArray(zoomAndTimeArray, cameraDevice);
1420 return CAMERA_OK;
1421 }
1422
CalculateWaitTime(const std::vector<float> & mCrossZoom,float currentZoomRatio,float targetZoomRatio,float waitMs,float frameIntervalMs,const std::vector<float> & array)1423 float HCaptureSession::CalculateWaitTime(const std::vector<float>& mCrossZoom,
1424 float currentZoomRatio, float targetZoomRatio,
1425 float waitMs, float frameIntervalMs,
1426 const std::vector<float>& array)
1427 {
1428 float waitTime = 0.0f;
1429 for (int i = 0; i < static_cast<int>(mCrossZoom.size()); i++) {
1430 float crossZoom = mCrossZoom[i];
1431 MEDIA_DEBUG_LOG("HCaptureSession::CalculateWaitTime crossZoomIterator is: %{public}f.", crossZoom);
1432 if ((crossZoom - currentZoomRatio) * (crossZoom - targetZoomRatio) > 0 || isEqual(crossZoom, 199.0f)) {
1433 MEDIA_DEBUG_LOG("HCaptureSession::CalculateWaitTime skip zoomCross is: %{public}f.", crossZoom);
1434 continue;
1435 }
1436 if (std::fabs(currentZoomRatio - crossZoom) <= std::numeric_limits<float>::epsilon() &&
1437 currentZoomRatio > targetZoomRatio) {
1438 waitTime = waitMs;
1439 }
1440 for (int j = 0; j < static_cast<int>(array.size()); j++) {
1441 if (static_cast<int>(array[j] - crossZoom) * static_cast<int>(array[0] - crossZoom) <= 0) {
1442 waitTime = waitMs - frameIntervalMs * j;
1443 waitTime = waitTime >= 0 ? waitTime : 0;
1444 MEDIA_DEBUG_LOG("HCaptureSession::CalculateWaitTime crossZoom is: %{public}f, waitTime is: %{public}f",
1445 crossZoom, waitTime);
1446 break;
1447 }
1448 }
1449 }
1450 return waitTime;
1451 }
1452
ProcessMetaZoomArray(std::vector<uint32_t> & zoomAndTimeArray,sptr<HCameraDevice> & cameraDevice)1453 void HCaptureSession::ProcessMetaZoomArray(std::vector<uint32_t>& zoomAndTimeArray, sptr<HCameraDevice>& cameraDevice)
1454 {
1455 std::shared_ptr<OHOS::Camera::CameraMetadata> metaZoomArray = std::make_shared<OHOS::Camera::CameraMetadata>(1, 1);
1456 uint32_t zoomCount = static_cast<uint32_t>(zoomAndTimeArray.size());
1457 MEDIA_INFO_LOG("HCaptureSession::ProcessMetaZoomArray() zoomArray size: "
1458 "%{public}zu, zoomCount: %{public}u, sessionID: %{public}d",
1459 zoomAndTimeArray.size(),
1460 zoomCount,
1461 GetSessionId());
1462 metaZoomArray->addEntry(OHOS_CONTROL_SMOOTH_ZOOM_RATIOS, zoomAndTimeArray.data(), zoomCount);
1463 cameraDevice->UpdateSettingOnce(metaZoomArray);
1464 }
1465
EnableMovingPhoto(bool isEnable)1466 int32_t HCaptureSession::EnableMovingPhoto(bool isEnable)
1467 {
1468 auto hStreamOperatorSptr = GetStreamOperator();
1469 CHECK_RETURN_RET_ELOG(hStreamOperatorSptr == nullptr, CAMERA_OK, "hStreamOperatorSptr is null");
1470 std::shared_ptr<OHOS::Camera::CameraMetadata> settings = nullptr;
1471 auto cameraDevice = GetCameraDevice();
1472 if (cameraDevice != nullptr) {
1473 settings = cameraDevice->CloneCachedSettings();
1474 }
1475 hStreamOperatorSptr->EnableMovingPhoto(settings, isEnable, GetSensorOritation());
1476 return CAMERA_OK;
1477 }
1478
GetConcurrentCameraIds(pid_t pid)1479 std::string HCaptureSession::GetConcurrentCameraIds(pid_t pid)
1480 {
1481 std::string concurrencyString = "Concurrency cameras:[";
1482 std::list<sptr<HCaptureSession>> sessionList = HCameraSessionManager::GetInstance().GetGroupSessions(pid);
1483 for (auto entry : sessionList) {
1484 if (!entry->isSessionStarted_) {
1485 continue;
1486 }
1487 auto device = entry->GetCameraDevice();
1488 if (device == nullptr) {
1489 continue;
1490 }
1491 concurrencyString.append(device->GetCameraId() + " ");
1492 }
1493 concurrencyString.append("]");
1494 return concurrencyString;
1495 }
1496
SetUpdateControlCenterCallback(UpdateControlCenterCallback cb)1497 void HCaptureSession::SetUpdateControlCenterCallback(UpdateControlCenterCallback cb)
1498 {
1499 updateControlCenterCallback_ = std::move(cb);
1500 }
1501
Start()1502 int32_t HCaptureSession::Start()
1503 {
1504 CAMERA_SYNC_TRACE;
1505 int32_t errorCode = CAMERA_OK;
1506 MEDIA_INFO_LOG("HCaptureSession::Start prepare execute, sessionID: %{public}d", GetSessionId());
1507 stateMachine_.StateGuard([&errorCode, this](CaptureSessionState currentState) {
1508 bool isTransferSupport = stateMachine_.CheckTransfer(CaptureSessionState::SESSION_STARTED);
1509 if (!isTransferSupport) {
1510 MEDIA_ERR_LOG("HCaptureSession::Start() Need to call after "
1511 "committing configuration, sessionID: %{public}d", GetSessionId());
1512 errorCode = CAMERA_INVALID_STATE;
1513 return;
1514 }
1515 std::shared_ptr<OHOS::Camera::CameraMetadata> settings = nullptr;
1516 auto cameraDevice = GetCameraDevice();
1517 uint8_t usedAsPositionU8 = OHOS_CAMERA_POSITION_OTHER;
1518 MEDIA_INFO_LOG("HCaptureSession::Start usedAsPositionU8 default = "
1519 "%{public}d, sessionID: %{public}d", usedAsPositionU8, GetSessionId());
1520 if (cameraDevice != nullptr) {
1521 settings = cameraDevice->CloneCachedSettings();
1522 usedAsPositionU8 = cameraDevice->GetUsedAsPosition();
1523 MEDIA_INFO_LOG("HCaptureSession::Start usedAsPositionU8 set "
1524 "%{public}d, sessionID: %{public}d", usedAsPositionU8, GetSessionId());
1525 DumpMetadata(settings);
1526 UpdateMuteSetting(cameraDevice->GetDeviceMuteMode(), settings);
1527 UpdateSettingForFocusTrackingMechBeforeStart(settings);
1528 }
1529 camera_position_enum_t cameraPosition = static_cast<camera_position_enum_t>(usedAsPositionU8);
1530 auto hStreamOperatorSptr = GetStreamOperator();
1531 CHECK_RETURN_ELOG(hStreamOperatorSptr == nullptr, "hStreamOperatorSptr is null");
1532 UpdateSettingForSpecialBundle();
1533 errorCode = hStreamOperatorSptr->StartPreviewStream(settings, cameraPosition);
1534 CHECK_EXECUTE(errorCode == CAMERA_OK, isSessionStarted_ = true);
1535 stateMachine_.Transfer(CaptureSessionState::SESSION_STARTED);
1536 {
1537 std::lock_guard<std::mutex> lock(mechDeliveryStateLock_);
1538 if (mechDeliveryState_ == MechDeliveryState::NEED_ENABLE) {
1539 hStreamOperatorSptr->UpdateSettingForFocusTrackingMech(true);
1540 mechDeliveryState_ = MechDeliveryState::ENABLED;
1541 }
1542 }
1543 OnSessionStatusChange(true);
1544 OnCaptureSessionConfiged();
1545 });
1546 MEDIA_INFO_LOG("HCaptureSession::Start execute success, sessionID: %{public}d", GetSessionId());
1547 MEDIA_INFO_LOG("%{public}s", GetConcurrentCameraIds(pid_).c_str());
1548 return errorCode;
1549 }
1550
UpdateCameraControl(bool isStart)1551 void HCaptureSession::UpdateCameraControl(bool isStart)
1552 {
1553 MEDIA_DEBUG_LOG("HCaptureSession::UpdateCameraControl, isStart: %{public}d", isStart);
1554 CHECK_EXECUTE(updateControlCenterCallback_ != nullptr, updateControlCenterCallback_(isStart));
1555 }
1556
UpdateSettingForSpecialBundle()1557 void HCaptureSession::UpdateSettingForSpecialBundle()
1558 {
1559 OHOS::Rosen::FoldStatus foldstatus = OHOS::Rosen::DisplayManager::GetInstance().GetFoldStatus();
1560 OHOS::Rosen::FoldDisplayMode displayMode = OHOS::Rosen::DisplayManager::GetInstance().GetFoldDisplayMode();
1561 auto hStreamOperatorSptr = GetStreamOperator();
1562 bool isValidDisplayStatus = (foldstatus == OHOS::Rosen::FoldStatus::FOLD_STATE_EXPAND_WITH_SECOND_EXPAND) &&
1563 (displayMode == OHOS::Rosen::FoldDisplayMode::GLOBAL_FULL);
1564 bool isSpecialFoldType = foldstatus == OHOS::Rosen::FoldStatus::FOLDED &&
1565 system::GetParameter("const.window.foldscreen.type", "")[0] == '4';
1566 bool isExeUpdate = hStreamOperatorSptr != nullptr &&
1567 (isSpecialFoldType || isValidDisplayStatus) && !isHasFitedRotation_;
1568 if (isExeUpdate) {
1569 auto frameRateRange = hStreamOperatorSptr->GetFrameRateRange();
1570 auto cameraDevice = GetCameraDevice();
1571 CHECK_RETURN(cameraDevice == nullptr);
1572 cameraDevice->UpdateCameraRotateAngleAndZoom(frameRateRange);
1573 int32_t cameraPosition = cameraDevice->GetCameraPosition();
1574 CHECK_RETURN(cameraPosition == OHOS_CAMERA_POSITION_FRONT);
1575 int uid = IPCSkeleton::GetCallingUid();
1576 CHECK_EXECUTE(bundleName_ == "", bundleName_ = GetClientBundle(uid));
1577 std::string specialBundle = system::GetParameter("const.camera.folded_lens_change", "default");
1578 CHECK_RETURN(specialBundle != bundleName_ || frameRateRange.empty() ||
1579 frameRateRange[0] != SPECIAL_BUNDLE_FPS);
1580 std::shared_ptr<OHOS::Camera::CameraMetadata> settings =
1581 std::make_shared<OHOS::Camera::CameraMetadata>(1, 1);
1582 int32_t rotateDegree = SPECIAL_BUNDLE_ROTATE;
1583 MEDIA_INFO_LOG("HCaptureSession::UpdateSettingForSpecialBundle rotateDegree: %{public}d.", rotateDegree);
1584 settings->addEntry(OHOS_CONTROL_ROTATE_ANGLE, &rotateDegree, 1);
1585 cameraDevice->UpdateSettingOnce(settings);
1586 }
1587 }
1588
UpdateMuteSetting(bool muteMode,std::shared_ptr<OHOS::Camera::CameraMetadata> & settings)1589 void HCaptureSession::UpdateMuteSetting(bool muteMode, std::shared_ptr<OHOS::Camera::CameraMetadata>& settings)
1590 {
1591 int32_t count = 1;
1592 uint8_t mode = muteMode ? OHOS_CAMERA_MUTE_MODE_SOLID_COLOR_BLACK : OHOS_CAMERA_MUTE_MODE_OFF;
1593 settings->addEntry(OHOS_CONTROL_MUTE_MODE, &mode, count);
1594 }
1595
Stop()1596 int32_t HCaptureSession::Stop()
1597 {
1598 CAMERA_SYNC_TRACE;
1599 int32_t errorCode = CAMERA_OK;
1600 MEDIA_INFO_LOG("HCaptureSession::Stop prepare execute, sessionID: %{public}d", GetSessionId());
1601 stateMachine_.StateGuard([&errorCode, this](CaptureSessionState currentState) {
1602 bool isTransferSupport = stateMachine_.CheckTransfer(CaptureSessionState::SESSION_CONFIG_COMMITTED);
1603 if (!isTransferSupport) {
1604 MEDIA_ERR_LOG("HCaptureSession::Stop() Need to call after Start, "
1605 "sessionID: %{public}d", GetSessionId());
1606 errorCode = CAMERA_INVALID_STATE;
1607 return;
1608 }
1609 auto hStreamOperatorSptr = GetStreamOperator();
1610 if (hStreamOperatorSptr == nullptr) {
1611 MEDIA_ERR_LOG("hStreamOperatorSptr is null");
1612 errorCode = CAMERA_INVALID_STATE;
1613 return;
1614 }
1615 errorCode = hStreamOperatorSptr->Stop();
1616 if (errorCode == CAMERA_OK) {
1617 isSessionStarted_ = false;
1618 }
1619 stateMachine_.Transfer(CaptureSessionState::SESSION_CONFIG_COMMITTED);
1620 OnSessionStatusChange(false);
1621 });
1622 MEDIA_INFO_LOG("HCaptureSession::Stop execute success, sessionID: %{public}d", GetSessionId());
1623 return errorCode;
1624 }
1625
Release(CaptureSessionReleaseType type)1626 int32_t HCaptureSession::Release(CaptureSessionReleaseType type)
1627 {
1628 CAMERA_SYNC_TRACE;
1629 int32_t errorCode = CAMERA_OK;
1630 int32_t sid = GetSessionId();
1631 MEDIA_INFO_LOG("HCaptureSession::Release prepare execute, release type "
1632 "is:%{public}d pid(%{public}d), sessionID: %{public}d", type, pid_, GetSessionId());
1633 // Check release without lock first
1634 CHECK_RETURN_RET_ELOG(stateMachine_.IsStateNoLock(CaptureSessionState::SESSION_RELEASED),
1635 CAMERA_INVALID_STATE,
1636 "HCaptureSession::Release error, session is already released!");
1637
1638 stateMachine_.StateGuard([&errorCode, this, type](CaptureSessionState currentState) {
1639 MEDIA_INFO_LOG("HCaptureSession::Release pid(%{public}d). release type is:%{public}d", pid_, type);
1640 bool isTransferSupport = stateMachine_.CheckTransfer(CaptureSessionState::SESSION_RELEASED);
1641 if (!isTransferSupport) {
1642 MEDIA_ERR_LOG("HCaptureSession::Release error, this session is already released!");
1643 errorCode = CAMERA_INVALID_STATE;
1644 return;
1645 }
1646 // Clear current session
1647 if (type != CaptureSessionReleaseType::RELEASE_TYPE_OBJ_DIED) {
1648 HCameraSessionManager::GetInstance().RemoveSession(this);
1649 MEDIA_DEBUG_LOG("HCaptureSession::Release clear pid left sessions(%{public}zu).",
1650 HCameraSessionManager::GetInstance().GetTotalSessionSize());
1651 }
1652 auto hStreamOperatorSptr = GetStreamOperator();
1653 CHECK_RETURN_ELOG(hStreamOperatorSptr == nullptr, "hStreamOperatorSptr is null");
1654 // stop movingPhoto
1655 hStreamOperatorSptr->StopMovingPhoto();
1656
1657 // Clear outputs
1658 hStreamOperatorSptr->ReleaseStreams();
1659
1660 // Clear inputs
1661 auto cameraDevice = GetCameraDevice();
1662 if (cameraDevice != nullptr) {
1663 cameraDevice->Release();
1664 SetCameraDevice(nullptr);
1665 }
1666
1667 if ((hStreamOperatorSptr->GetAllOutptSize()) == 0) {
1668 hStreamOperatorSptr->Release();
1669 }
1670 sptr<ICaptureSessionCallback> emptyCallback = nullptr;
1671 SetCallback(emptyCallback);
1672 sptr<IPressureStatusCallback> emptyPressureCallback = nullptr;
1673 SetPressureCallback(emptyPressureCallback);
1674 UnSetControlCenterEffectStatusCallback();
1675 stateMachine_.Transfer(CaptureSessionState::SESSION_RELEASED);
1676 isSessionStarted_ = false;
1677 });
1678 MEDIA_INFO_LOG("HCaptureSession::Release execute success, sessionID: %{public}d", sid);
1679 return errorCode;
1680 }
1681
Release()1682 int32_t HCaptureSession::Release()
1683 {
1684 CameraXCollie cameraXCollie("hcaptureSessionStub::Release");
1685 MEDIA_INFO_LOG("HCaptureSession::Release(), sessionID: %{public}d", GetSessionId());
1686 CameraReportUtils::GetInstance().SetModeChangePerfStartInfo(opMode_, CameraReportUtils::GetCallerInfo());
1687 return Release(CaptureSessionReleaseType::RELEASE_TYPE_CLIENT);
1688 }
1689
OperatePermissionCheck(uint32_t interfaceCode)1690 int32_t HCaptureSession::OperatePermissionCheck(uint32_t interfaceCode)
1691 {
1692 CHECK_RETURN_RET_ELOG(stateMachine_.GetCurrentState() == CaptureSessionState::SESSION_RELEASED,
1693 CAMERA_INVALID_STATE,
1694 "HCaptureSession::OperatePermissionCheck session is released");
1695 switch (static_cast<ICaptureSessionIpcCode>(interfaceCode)) {
1696 case ICaptureSessionIpcCode::COMMAND_START: {
1697 auto callerToken = IPCSkeleton::GetCallingTokenID();
1698 CHECK_RETURN_RET_ELOG(callerToken_ != callerToken, CAMERA_OPERATION_NOT_ALLOWED,
1699 "HCaptureSession::OperatePermissionCheck fail, callerToken_ is : %{public}d, now token "
1700 "is %{public}d", callerToken_, callerToken);
1701 break;
1702 }
1703 default:
1704 break;
1705 }
1706 return CAMERA_OK;
1707 }
1708
CallbackEnter(uint32_t code)1709 int32_t HCaptureSession::CallbackEnter([[maybe_unused]] uint32_t code)
1710 {
1711 MEDIA_DEBUG_LOG("start, code:%{public}u", code);
1712 DisableJeMalloc();
1713 int32_t errCode = OperatePermissionCheck(code);
1714 CHECK_RETURN_RET_ELOG(errCode != CAMERA_OK, errCode, "HCaptureSession::OperatePermissionCheck fail");
1715 return CAMERA_OK;
1716 }
CallbackExit(uint32_t code,int32_t result)1717 int32_t HCaptureSession::CallbackExit([[maybe_unused]] uint32_t code, [[maybe_unused]] int32_t result)
1718 {
1719 MEDIA_DEBUG_LOG("leave, code:%{public}u, result:%{public}d", code, result);
1720 return CAMERA_OK;
1721 }
1722
DestroyStubObjectForPid(pid_t pid)1723 void HCaptureSession::DestroyStubObjectForPid(pid_t pid)
1724 {
1725 auto& sessionManager = HCameraSessionManager::GetInstance();
1726 MEDIA_DEBUG_LOG("camera stub session groups(%{public}zu) pid(%{public}d).", sessionManager.GetGroupCount(), pid);
1727 auto sessions = sessionManager.GetGroupSessions(pid);
1728 for (auto& session : sessions) {
1729 session->Release(CaptureSessionReleaseType::RELEASE_TYPE_CLIENT_DIED);
1730 }
1731 sessionManager.RemoveGroup(pid);
1732 MEDIA_DEBUG_LOG("camera stub session groups(%{public}zu).", sessionManager.GetGroupCount());
1733 }
1734
SetCallback(const sptr<ICaptureSessionCallback> & callback)1735 int32_t HCaptureSession::SetCallback(const sptr<ICaptureSessionCallback>& callback)
1736 {
1737 if (callback == nullptr) {
1738 MEDIA_WARNING_LOG("HCaptureSession::SetCallback callback is null, we "
1739 "should clear the callback, sessionID: %{public}d",
1740 GetSessionId());
1741 }
1742 // Not implement yet.
1743 return CAMERA_OK;
1744 }
1745
UnSetCallback()1746 int32_t HCaptureSession::UnSetCallback()
1747 {
1748 // Not implement yet.
1749 return CAMERA_OK;
1750 }
1751
SetPressureCallback(const sptr<IPressureStatusCallback> & callback)1752 int32_t HCaptureSession::SetPressureCallback(const sptr<IPressureStatusCallback>& callback)
1753 {
1754 if (callback == nullptr) {
1755 MEDIA_WARNING_LOG("HCaptureSession::SetPressureCallback callback is null, we "
1756 "should clear the callback, sessionID: %{public}d",
1757 GetSessionId());
1758 }
1759 innerPressureCallback_ = callback;
1760
1761 return CAMERA_OK;
1762 }
1763
UnSetPressureCallback()1764 int32_t HCaptureSession::UnSetPressureCallback()
1765 {
1766 innerPressureCallback_ = nullptr;
1767 return CAMERA_OK;
1768 }
1769
SetPressureStatus(PressureStatus status)1770 void HCaptureSession::SetPressureStatus(PressureStatus status)
1771 {
1772 MEDIA_INFO_LOG("HCaptureSession::SetPressureStatus(), status: %{public}d", status);
1773 CHECK_RETURN_ELOG(innerPressureCallback_ == nullptr, "innerPressureCallback is null.");
1774 innerPressureCallback_->OnPressureStatusChanged(status);
1775 }
1776
SetControlCenterEffectStatusCallback(const sptr<IControlCenterEffectStatusCallback> & callback)1777 int32_t HCaptureSession::SetControlCenterEffectStatusCallback(const sptr<IControlCenterEffectStatusCallback>& callback)
1778 {
1779 if (callback == nullptr) {
1780 MEDIA_WARNING_LOG("HCaptureSession::SetControlCenterEffectStatusCallback callback is null, we "
1781 "should clear the callback, sessionID: %{public}d", GetSessionId());
1782 }
1783 std::lock_guard<std::mutex> lock(innerControlCenterEffectCallbackLock_);
1784 innerControlCenterEffectCallback_ = callback;
1785 CHECK_RETURN_RET_ILOG(innerControlCenterEffectCallback_ == nullptr,
1786 CAMERA_OK, "innerControlCenterEffectCallback_ is null");
1787 float curVirtualApertureValue;
1788 GetVirtualApertureValue(curVirtualApertureValue);
1789 ControlCenterStatusInfo statusInfo;
1790 if (isEqual(curVirtualApertureValue, biggestAperture) || isEqual(curVirtualApertureValue, 0)) {
1791 statusInfo = {ControlCenterEffectType::PORTRAIT, false};
1792 } else {
1793 statusInfo = {ControlCenterEffectType::PORTRAIT, true};
1794 }
1795 innerControlCenterEffectCallback_->OnControlCenterEffectStatusChanged(statusInfo);
1796
1797 int32_t curBeautyValue = 0;
1798 GetBeautyValue(OHOS_CAMERA_BEAUTY_TYPE_AUTO, curBeautyValue);
1799 if (curBeautyValue == 0) {
1800 statusInfo = {ControlCenterEffectType::BEAUTY, false};
1801 } else {
1802 statusInfo = {ControlCenterEffectType::BEAUTY, true};
1803 }
1804 innerControlCenterEffectCallback_->OnControlCenterEffectStatusChanged(statusInfo);
1805 return CAMERA_OK;
1806 }
1807
UnSetControlCenterEffectStatusCallback()1808 int32_t HCaptureSession::UnSetControlCenterEffectStatusCallback()
1809 {
1810 MEDIA_INFO_LOG("HCaptureSession::UnSetControlCenterEffectStatusCallback");
1811 std::lock_guard<std::mutex> lock(innerControlCenterEffectCallbackLock_);
1812 innerControlCenterEffectCallback_ = nullptr;
1813 return CAMERA_OK;
1814 }
1815
SetControlCenterEffectCallbackStatus(ControlCenterStatusInfo statusInfo)1816 void HCaptureSession::SetControlCenterEffectCallbackStatus(ControlCenterStatusInfo statusInfo)
1817 {
1818 MEDIA_INFO_LOG("HCaptureSession::SetControlCenterEffectCallbackStatus(), status: %{public}d", statusInfo.isActive);
1819 std::lock_guard<std::mutex> lock(innerControlCenterEffectCallbackLock_);
1820 CHECK_RETURN_ELOG(innerControlCenterEffectCallback_ == nullptr, "innerControlCenterEffectCallback_ is null.");
1821 innerControlCenterEffectCallback_->OnControlCenterEffectStatusChanged(statusInfo);
1822 }
1823
GetSessionState()1824 std::string HCaptureSession::GetSessionState()
1825 {
1826 auto currentState = stateMachine_.GetCurrentState();
1827 std::map<CaptureSessionState, std::string>::const_iterator iter = SESSION_STATE_STRING_MAP.find(currentState);
1828 CHECK_RETURN_RET(iter != SESSION_STATE_STRING_MAP.end(), iter->second);
1829 return std::to_string(static_cast<uint32_t>(currentState));
1830 }
1831
DumpCameraSessionSummary(CameraInfoDumper & infoDumper)1832 void HCaptureSession::DumpCameraSessionSummary(CameraInfoDumper& infoDumper)
1833 {
1834 infoDumper.Msg("Number of Camera sessions:[" +
1835 std::to_string(HCameraSessionManager::GetInstance().GetTotalSessionSize()) + "]");
1836 }
1837
DumpSessions(CameraInfoDumper & infoDumper)1838 void HCaptureSession::DumpSessions(CameraInfoDumper& infoDumper)
1839 {
1840 auto totalSession = HCameraSessionManager::GetInstance().GetTotalSession();
1841 uint32_t index = 0;
1842 for (auto& session : totalSession) {
1843 infoDumper.Title("Camera Sessions[" + std::to_string(index++) + "] Info:");
1844 session->DumpSessionInfo(infoDumper);
1845 }
1846 }
1847
DumpSessionInfo(CameraInfoDumper & infoDumper)1848 void HCaptureSession::DumpSessionInfo(CameraInfoDumper& infoDumper)
1849 {
1850 infoDumper.Msg("Client pid:[" + std::to_string(pid_) + "] Client uid:[" + std::to_string(uid_) + "]");
1851 infoDumper.Msg("session state:[" + GetSessionState() + "]");
1852 auto hStreamOperatorSptr = GetStreamOperator();
1853 CHECK_RETURN_ELOG(hStreamOperatorSptr == nullptr, "hStreamOperatorSptr is null");
1854 for (auto& stream : hStreamOperatorSptr->GetAllStreams()) {
1855 infoDumper.Push();
1856 stream->DumpStreamInfo(infoDumper);
1857 infoDumper.Pop();
1858 }
1859 }
1860
EnableMovingPhotoMirror(bool isMirror,bool isConfig)1861 int32_t HCaptureSession::EnableMovingPhotoMirror(bool isMirror, bool isConfig)
1862 {
1863 auto hStreamOperatorSptr = GetStreamOperator();
1864 CHECK_RETURN_RET_ELOG(hStreamOperatorSptr == nullptr, CAMERA_OK, "hStreamOperatorSptr is null");
1865 hStreamOperatorSptr->EnableMovingPhotoMirror(isMirror, isConfig);
1866 return CAMERA_OK;
1867 }
1868
GetOutputStatus(int32_t & status)1869 void HCaptureSession::GetOutputStatus(int32_t& status)
1870 {
1871 auto hStreamOperatorSptr = GetStreamOperator();
1872 CHECK_RETURN_ELOG(hStreamOperatorSptr == nullptr, "hStreamOperatorSptr is null");
1873 hStreamOperatorSptr->GetOutputStatus(status);
1874 }
1875
SetCameraDevice(sptr<HCameraDevice> device)1876 void HCaptureSession::SetCameraDevice(sptr<HCameraDevice> device)
1877 {
1878 std::lock_guard<std::mutex> lock(cameraDeviceLock_);
1879 if (cameraDevice_ != nullptr) {
1880 cameraDevice_->SetCameraCloseListener(nullptr);
1881 }
1882 if (device != nullptr) {
1883 device->SetCameraCloseListener(this);
1884 }
1885 cameraDevice_ = device;
1886
1887 auto hStreamOperatorSptr = GetStreamOperator();
1888 if (hStreamOperatorSptr != nullptr) {
1889 hStreamOperatorSptr->SetCameraDevice(device);
1890 }
1891 }
1892
CreateDisplayName(const std::string & suffix)1893 std::string HCaptureSession::CreateDisplayName(const std::string& suffix)
1894 {
1895 struct tm currentTime;
1896 std::string formattedTime = "";
1897 if (GetSystemCurrentTime(¤tTime)) {
1898 std::stringstream ss;
1899 ss << prefix << std::setw(yearWidth) << std::setfill(placeholder) << currentTime.tm_year + startYear
1900 << std::setw(otherWidth) << std::setfill(placeholder) << (currentTime.tm_mon + 1) << std::setw(otherWidth)
1901 << std::setfill(placeholder) << currentTime.tm_mday << connector << std::setw(otherWidth)
1902 << std::setfill(placeholder) << currentTime.tm_hour << std::setw(otherWidth) << std::setfill(placeholder)
1903 << currentTime.tm_min << std::setw(otherWidth) << std::setfill(placeholder) << currentTime.tm_sec;
1904 formattedTime = ss.str();
1905 } else {
1906 MEDIA_ERR_LOG("Failed to get current time.sessionID: %{public}d", GetSessionId());
1907 }
1908 if (lastDisplayName_ == formattedTime) {
1909 saveIndex++;
1910 formattedTime = formattedTime + connector + std::to_string(saveIndex);
1911 MEDIA_INFO_LOG(
1912 "CreateDisplayName is %{private}s, sessionID: %{public}d", formattedTime.c_str(), GetSessionId());
1913 return formattedTime;
1914 }
1915 lastDisplayName_ = formattedTime;
1916 saveIndex = 0;
1917 MEDIA_INFO_LOG("CreateDisplayName is %{private}s", formattedTime.c_str());
1918 return formattedTime;
1919 }
1920
CreateBurstDisplayName(int32_t imageSeqId,int32_t seqId)1921 std::string HCaptureSession::CreateBurstDisplayName(int32_t imageSeqId, int32_t seqId)
1922 {
1923 struct tm currentTime;
1924 std::string formattedTime = "";
1925 std::stringstream ss;
1926 // a group of burst capture use the same prefix
1927 if (imageSeqId == 1) {
1928 CHECK_RETURN_RET_ELOG(!GetSystemCurrentTime(¤tTime), formattedTime, "Failed to get current time.");
1929 ss << prefix << std::setw(yearWidth) << std::setfill(placeholder) << currentTime.tm_year + startYear
1930 << std::setw(otherWidth) << std::setfill(placeholder) << (currentTime.tm_mon + 1) << std::setw(otherWidth)
1931 << std::setfill(placeholder) << currentTime.tm_mday << connector << std::setw(otherWidth)
1932 << std::setfill(placeholder) << currentTime.tm_hour << std::setw(otherWidth) << std::setfill(placeholder)
1933 << currentTime.tm_min << std::setw(otherWidth) << std::setfill(placeholder) << currentTime.tm_sec
1934 << connector << burstTag;
1935 lastBurstPrefix_ = ss.str();
1936 ss << std::setw(burstWidth) << std::setfill(placeholder) << seqId;
1937 } else {
1938 ss << lastBurstPrefix_ << std::setw(burstWidth) << std::setfill(placeholder) << seqId;
1939 }
1940 MEDIA_DEBUG_LOG("burst prefix is %{private}s, sessionID: %{public}d", lastBurstPrefix_.c_str(), GetSessionId());
1941
1942 if (seqId == 1) {
1943 ss << coverTag;
1944 }
1945 formattedTime = ss.str();
1946 MEDIA_INFO_LOG(
1947 "CreateBurstDisplayName is %{private}s, sessionID: %{public}d", formattedTime.c_str(), GetSessionId());
1948 return formattedTime;
1949 }
1950
SetFeatureMode(int32_t featureMode)1951 int32_t HCaptureSession::SetFeatureMode(int32_t featureMode)
1952 {
1953 CHECK_RETURN_RET_ELOG(!CheckSystemApp(), CAMERA_NO_PERMISSION, "HCaptureSession::CheckSystemApp fail");
1954 MEDIA_INFO_LOG("SetFeatureMode is called!sessionID: %{public}d", GetSessionId());
1955 featureMode_ = featureMode;
1956 return CAMERA_OK;
1957 }
1958
StateMachine()1959 StateMachine::StateMachine()
1960 {
1961 stateTransferMap_[static_cast<uint32_t>(CaptureSessionState::SESSION_INIT)] = {
1962 CaptureSessionState::SESSION_CONFIG_INPROGRESS, CaptureSessionState::SESSION_RELEASED
1963 };
1964
1965 stateTransferMap_[static_cast<uint32_t>(CaptureSessionState::SESSION_CONFIG_INPROGRESS)] = {
1966 CaptureSessionState::SESSION_CONFIG_COMMITTED, CaptureSessionState::SESSION_RELEASED
1967 };
1968
1969 stateTransferMap_[static_cast<uint32_t>(CaptureSessionState::SESSION_CONFIG_COMMITTED)] = {
1970 CaptureSessionState::SESSION_CONFIG_INPROGRESS, CaptureSessionState::SESSION_STARTED,
1971 CaptureSessionState::SESSION_RELEASED
1972 };
1973
1974 stateTransferMap_[static_cast<uint32_t>(CaptureSessionState::SESSION_STARTED)] = {
1975 CaptureSessionState::SESSION_CONFIG_INPROGRESS, CaptureSessionState::SESSION_CONFIG_COMMITTED,
1976 CaptureSessionState::SESSION_RELEASED
1977 };
1978
1979 stateTransferMap_[static_cast<uint32_t>(CaptureSessionState::SESSION_RELEASED)] = {};
1980 }
1981
CheckTransfer(CaptureSessionState targetState)1982 bool StateMachine::CheckTransfer(CaptureSessionState targetState)
1983 {
1984 std::lock_guard<std::recursive_mutex> lock(sessionStateLock_);
1985 return any_of(stateTransferMap_[static_cast<uint32_t>(currentState_)].begin(),
1986 stateTransferMap_[static_cast<uint32_t>(currentState_)].end(),
1987 [&targetState](const auto& state) { return state == targetState; });
1988 }
1989
Transfer(CaptureSessionState targetState)1990 bool StateMachine::Transfer(CaptureSessionState targetState)
1991 {
1992 std::lock_guard<std::recursive_mutex> lock(sessionStateLock_);
1993 if (CheckTransfer(targetState)) {
1994 currentState_ = targetState;
1995 return true;
1996 }
1997 return false;
1998 }
1999
2000 #ifdef HOOK_CAMERA_OPERATOR
UpdateHookBasicInfo(ParameterMap parameterMap)2001 void HCaptureSession::UpdateHookBasicInfo(ParameterMap parameterMap)
2002 {
2003 std::lock_guard<std::mutex> lock(cameraRotateUpdateBasicInfo_);
2004 std::shared_ptr<OHOS::Camera::CameraMetadata> settings = std::make_shared<OHOS::Camera::CameraMetadata>(1, 1);
2005 auto hStreamOperatorSptr = GetStreamOperator();
2006 CHECK_RETURN_ELOG(hStreamOperatorSptr == nullptr, "hStreamOperatorSptr is null");
2007 MEDIA_INFO_LOG("UpdateHookBasicInfo size %{public}zu", parameterMap.size());
2008 auto streams = hStreamOperatorSptr->GetAllStreams();
2009 for (auto& stream : streams) {
2010 if (stream->GetStreamType() != StreamType::REPEAT) {
2011 continue;
2012 }
2013 sptr<OHOS::IBufferProducer> previewProducer = nullptr;
2014 sptr<OHOS::IBufferProducer> videoProducer = nullptr;
2015 auto curStreamRepeat = CastStream<HStreamRepeat>(stream);
2016 if (curStreamRepeat->GetRepeatStreamType() == RepeatStreamType::PREVIEW) {
2017 previewProducer = curStreamRepeat->GetStreamProducer();
2018 if (parameterMap.find(PLUGIN_PREVIEW_TRANSFORM) != parameterMap.end()) {
2019 MEDIA_INFO_LOG("HCaptureSession::UpdateHookBasicInfo PLUGIN_PREVIEW_TRANSFORM");
2020 curStreamRepeat->SetStreamTransform();
2021 }
2022 }
2023 if (curStreamRepeat->GetRepeatStreamType() == RepeatStreamType::VIDEO) {
2024 videoProducer = curStreamRepeat->GetStreamProducer();
2025 }
2026 UpdateBasicInfoForStream(parameterMap, previewProducer, videoProducer, settings);
2027 continue;
2028 }
2029 auto cameraDevive = GetCameraDevice();
2030 CHECK_RETURN_ELOG(cameraDevive == nullptr, "cameraDevive is null.");
2031 cameraDevive->UpdateSettingOnce(settings);
2032 }
2033
UpdateBasicInfoForStream(ParameterMap ParameterMap,sptr<OHOS::IBufferProducer> previewProducer,sptr<OHOS::IBufferProducer> videoProducer,std::shared_ptr<OHOS::Camera::CameraMetadata> settings)2034 void HCaptureSession::UpdateBasicInfoForStream(ParameterMap ParameterMap, sptr<OHOS::IBufferProducer> previewProducer,
2035 sptr<OHOS::IBufferProducer> videoProducer, std::shared_ptr<OHOS::Camera::CameraMetadata> settings)
2036 {
2037 for (const auto& pair : ParameterMap) {
2038 int32_t code = pair.first;
2039 MEDIA_DEBUG_LOG("UpdateBasicInfoForStream code is %{public}d, value is %{public}s",
2040 code, (pair.second).c_str());
2041 if (code != PLUGIN_SURFACE_APP_FWK_TYPE && !isIntegerRegex(pair.second)) {
2042 continue;
2043 }
2044 switch (code) {
2045 case PLUGIN_PREVIEW_FORMAT: {
2046 CHECK_EXECUTE(previewProducer != nullptr,
2047 previewProducer->SetTransform(static_cast<OHOS::GraphicTransformType>(std::stoi(pair.second))));
2048 break;
2049 }
2050 case PLUGIN_SURFACE_FRAME_GRAVITY: {
2051 CHECK_EXECUTE(previewProducer != nullptr,
2052 previewProducer->SetFrameGravity(std::stoi(pair.second)));
2053 break;
2054 }
2055 case PLUGIN_SURFACE_FIXED_ROTATION:{
2056 CHECK_EXECUTE(previewProducer != nullptr,
2057 previewProducer->SetFixedRotation(std::stoi(pair.second)));
2058 break;
2059 }
2060 case PLUGIN_SURFACE_APP_FWK_TYPE: {
2061 CHECK_EXECUTE(videoProducer != nullptr, videoProducer->SetSurfaceAppFrameworkType(pair.second));
2062 break;
2063 }
2064 case PLUGIN_VIDEO_SURFACE_TRANSFORM: {
2065 CHECK_EXECUTE(videoProducer != nullptr,
2066 videoProducer->SetTransform(static_cast<OHOS::GraphicTransformType>(std::stoi(pair.second))));
2067 break;
2068 }
2069 default: {
2070 DealPluginCode(ParameterMap, settings, code, std::stoi(pair.second));
2071 break;
2072 }
2073 }
2074 }
2075 }
2076
DealPluginCode(ParameterMap ParameterMap,std::shared_ptr<OHOS::Camera::CameraMetadata> settings,int32_t code,int32_t value)2077 void HCaptureSession::DealPluginCode(ParameterMap ParameterMap, std::shared_ptr<OHOS::Camera::CameraMetadata> settings,
2078 int32_t code, int32_t value)
2079 {
2080 switch (code) {
2081 case PLUGIN_CAMERA_HAL_ROTATE_ANGLE: {
2082 int32_t rotateAngle = value;
2083 CHECK_EXECUTE(rotateAngle >= 0, settings->addEntry(OHOS_CONTROL_ROTATE_ANGLE, &rotateAngle, 1));
2084 break;
2085 }
2086 case PLUGIN_CAPTURE_MIRROR:
2087 case PLUGIN_VIDEO_MIRROR: {
2088 uint8_t mirror = static_cast<uint8_t>(value);
2089 CHECK_EXECUTE((mirror == 0 || mirror == 1), settings->addEntry(OHOS_CONTROL_CAPTURE_MIRROR,
2090 &mirror, 1));
2091 break;
2092 }
2093 case PLUGIN_JPEG_ORIENTATION: {
2094 int32_t jpegOrientation = value;
2095 CHECK_EXECUTE(jpegOrientation >= 0, settings->addEntry(OHOS_JPEG_ORIENTATION, &jpegOrientation, 1));
2096 break;
2097 }
2098 default:
2099 break;
2100 }
2101 }
2102 #endif
2103
SetUserId(int32_t userId)2104 void HCaptureSession::SetUserId(int32_t userId)
2105 {
2106 userId_ = userId;
2107 }
2108
GetUserId()2109 int32_t HCaptureSession::GetUserId()
2110 {
2111 return userId_;
2112 }
2113
SetMechDeliveryState(MechDeliveryState state)2114 void HCaptureSession::SetMechDeliveryState(MechDeliveryState state)
2115 {
2116 std::lock_guard<std::mutex> lock(mechDeliveryStateLock_);
2117 mechDeliveryState_ = state;
2118 }
2119
UpdateSettingForFocusTrackingMechBeforeStart(std::shared_ptr<OHOS::Camera::CameraMetadata> & settings)2120 void HCaptureSession::UpdateSettingForFocusTrackingMechBeforeStart(std::shared_ptr<OHOS::Camera::CameraMetadata>&
2121 settings)
2122 {
2123 MEDIA_INFO_LOG("%{public}s is called!", __FUNCTION__);
2124 std::lock_guard<std::mutex> lock(mechDeliveryStateLock_);
2125 if (mechDeliveryState_ == MechDeliveryState::NEED_ENABLE) {
2126 MEDIA_INFO_LOG("%{public}s start EnableMechDelivery", __FUNCTION__);
2127 int32_t count = 1;
2128 uint8_t value = OHOS_CAMERA_MECH_MODE_ON;
2129 settings->addEntry(OHOS_CONTROL_FOCUS_TRACKING_MECH, &value, count);
2130 }
2131 }
2132
UpdateSettingForFocusTrackingMech(bool isEnableMech)2133 int32_t HCaptureSession::UpdateSettingForFocusTrackingMech(bool isEnableMech)
2134 {
2135 MEDIA_INFO_LOG("%{public}s is called, isEnableMech:%{public}d", __FUNCTION__, isEnableMech);
2136 auto cameraDevice = GetCameraDevice();
2137 CHECK_RETURN_RET_ELOG(cameraDevice == nullptr, CAMERA_INVALID_SESSION_CFG,
2138 "HCaptureSession::UpdateSettingForFocusTrackingMech device is null");
2139
2140 constexpr int32_t DEFAULT_ITEMS = 1;
2141 constexpr int32_t DEFAULT_DATA_LENGTH = 1;
2142 shared_ptr<OHOS::Camera::CameraMetadata> changedMetadata =
2143 make_shared<OHOS::Camera::CameraMetadata>(DEFAULT_ITEMS, DEFAULT_DATA_LENGTH);
2144 bool status = false;
2145 int32_t ret;
2146 int32_t count = 1;
2147 uint8_t value = isEnableMech? OHOS_CAMERA_MECH_MODE_ON : OHOS_CAMERA_MECH_MODE_OFF;
2148 camera_metadata_item_t item;
2149
2150 ret = OHOS::Camera::FindCameraMetadataItem(changedMetadata->get(), OHOS_CONTROL_FOCUS_TRACKING_MECH, &item);
2151 if (ret == CAM_META_ITEM_NOT_FOUND) {
2152 status = changedMetadata->addEntry(OHOS_CONTROL_FOCUS_TRACKING_MECH, &value, count);
2153 } else if (ret == CAM_META_SUCCESS) {
2154 status = changedMetadata->updateEntry(OHOS_CONTROL_FOCUS_TRACKING_MECH, &value, count);
2155 }
2156 ret = cameraDevice->UpdateSetting(changedMetadata);
2157 CHECK_RETURN_RET_ELOG(!status || ret != CAMERA_OK, CAMERA_UNKNOWN_ERROR,
2158 "UpdateSettingForFocusTrackingMech Failed");
2159 return CAMERA_OK;
2160 }
2161
SetDeviceMechCallback()2162 void HCaptureSession::SetDeviceMechCallback()
2163 {
2164 CHECK_RETURN(!cameraDevice_);
2165 auto thisPtr = wptr<HCaptureSession>(this);
2166 cameraDevice_->SetZoomInfoCallback([thisPtr](ZoomInfo zoomInfo) {
2167 auto ptr = thisPtr.promote();
2168 CHECK_RETURN(!ptr);
2169 zoomInfo.equivalentFocus = ptr->GetEquivalentFocus();
2170 ptr->OnZoomInfoChange(zoomInfo);
2171 });
2172 }
2173
GetCaptureSessionInfo(CaptureSessionInfo & sessionInfo)2174 bool HCaptureSession::GetCaptureSessionInfo(CaptureSessionInfo& sessionInfo)
2175 {
2176 sessionInfo.cameraId = "";
2177 sessionInfo.position = -1;
2178 ZoomInfo zoomInfo;
2179 zoomInfo.zoomValue = 1.0f;
2180 zoomInfo.equivalentFocus = GetEquivalentFocus();
2181 if (cameraDevice_ != nullptr) {
2182 sessionInfo.cameraId = cameraDevice_->GetCameraId();
2183 sessionInfo.position = cameraDevice_->GetCameraPosition();
2184 zoomInfo.zoomValue = cameraDevice_->GetZoomRatio();
2185 zoomInfo.focusMode = cameraDevice_->GetFocusMode();
2186 zoomInfo.videoStabilizationMode = cameraDevice_->GetVideoStabilizationMode();
2187 }
2188 sessionInfo.zoomInfo = zoomInfo;
2189 sessionInfo.callerTokenId = static_cast<int32_t>(callerToken_);
2190 sessionInfo.sessionId = GetSessionId();
2191 sessionInfo.sessionMode = GetopMode();
2192 int32_t curColorSpace = 0;
2193 GetActiveColorSpace(curColorSpace);
2194 sessionInfo.colorSpace = curColorSpace;
2195 std::vector<OutputInfo> outputInfos = GetOutputInfos();
2196 sessionInfo.outputInfos = outputInfos;
2197 sessionInfo.sessionStatus = stateMachine_.IsStateNoLock(CaptureSessionState::SESSION_STARTED);
2198 return true;
2199 }
2200
OnCaptureSessionConfiged()2201 void HCaptureSession::OnCaptureSessionConfiged()
2202 {
2203 auto &sessionManager = HCameraSessionManager::GetInstance();
2204 auto mechSession = sessionManager.GetMechSession(userId_);
2205 CHECK_RETURN(mechSession == nullptr);
2206 CaptureSessionInfo sessionInfo;
2207 CHECK_RETURN_ILOG(!GetCaptureSessionInfo(sessionInfo),
2208 "HCaptureSession::OnCaptureSessionConfiged GetCaptureSessionInfo failed");
2209 mechSession->OnCaptureSessionConfiged(sessionInfo);
2210 }
2211
OnZoomInfoChange(const ZoomInfo & zoomInfo)2212 void HCaptureSession::OnZoomInfoChange(const ZoomInfo& zoomInfo)
2213 {
2214 auto &sessionManager = HCameraSessionManager::GetInstance();
2215 auto mechSession = sessionManager.GetMechSession(userId_);
2216 CHECK_RETURN(mechSession == nullptr);
2217 mechSession->OnZoomInfoChange(GetSessionId(), zoomInfo);
2218 }
2219
OnSessionStatusChange(bool status)2220 void HCaptureSession::OnSessionStatusChange(bool status)
2221 {
2222 auto &sessionManager = HCameraSessionManager::GetInstance();
2223 auto mechSession = sessionManager.GetMechSession(userId_);
2224 CHECK_RETURN(mechSession == nullptr);
2225 mechSession->OnSessionStatusChange(GetSessionId(), status);
2226 }
2227
GetEquivalentFocus()2228 uint32_t HCaptureSession::GetEquivalentFocus()
2229 {
2230 auto cameraDevice = GetCameraDevice();
2231 uint32_t equivalentFocus = 0;
2232 CHECK_RETURN_RET_ELOG(cameraDevice == nullptr,
2233 equivalentFocus,
2234 "HCaptureSession::GetEquivalentFocus() "
2235 "cameraDevice is null, sessionID: %{public}d",
2236 GetSessionId());
2237 std::shared_ptr<OHOS::Camera::CameraMetadata> ability = cameraDevice->GetDeviceAbility();
2238 CHECK_RETURN_RET(ability == nullptr, equivalentFocus);
2239 camera_metadata_item_t item;
2240 int ret = OHOS::Camera::FindCameraMetadataItem(ability->get(), OHOS_ABILITY_EQUIVALENT_FOCUS, &item);
2241 CHECK_RETURN_RET_ELOG(ret != CAM_META_SUCCESS, equivalentFocus,
2242 "HCaptureSession::GetEquivalentFocus get equivalentFocus failed");
2243 for (uint32_t i = 0; i < item.count; i++) {
2244 if ((i & 1) == 0) {
2245 equivalentFocus = static_cast<uint32_t>(item.data.i32[i + 1]);
2246 }
2247 }
2248 MEDIA_DEBUG_LOG("HCaptureSession::GetEquivalentFocus equivalentFocus "
2249 "%{public}d, sessionID: %{public}d",
2250 equivalentFocus,
2251 GetSessionId());
2252 return equivalentFocus;
2253 }
2254
GetOutputInfos()2255 std::vector<OutputInfo> HCaptureSession::GetOutputInfos()
2256 {
2257 std::vector<OutputInfo> outputInfos = {};
2258 auto hStreamOperatorSptr = GetStreamOperator();
2259 CHECK_RETURN_RET(!hStreamOperatorSptr, outputInfos);
2260 auto streams = hStreamOperatorSptr->GetAllStreams();
2261 for (auto& stream : streams) {
2262 if (stream->GetStreamType() == StreamType::CAPTURE) {
2263 OutputInfo info;
2264 info.type = OutputType::PHOTO;
2265 info.width = stream->width_;
2266 info.height = stream->height_;
2267 outputInfos.emplace_back(info);
2268 } else if (stream->GetStreamType() == StreamType::REPEAT) {
2269 auto curStreamRepeat = CastStream<HStreamRepeat>(stream);
2270 if (curStreamRepeat == nullptr) {
2271 continue;
2272 }
2273 OutputInfo info;
2274 auto streamType = curStreamRepeat->GetRepeatStreamType();
2275 if (streamType == RepeatStreamType::PREVIEW) {
2276 info.type = OutputType::PREVIEW;
2277 } else if (streamType == RepeatStreamType::VIDEO) {
2278 info.type = OutputType::VIDEO;
2279 } else if (streamType == RepeatStreamType::LIVEPHOTO) {
2280 info.type = OutputType::MOVING_PHOTO;
2281 }
2282 info.width = stream->width_;
2283 info.height = stream->height_;
2284 std::vector<int32_t> frameRateRange = curStreamRepeat->GetFrameRateRange();
2285 constexpr int32_t fpsSize = 2;
2286 if (frameRateRange.size() == fpsSize) {
2287 info.minfps = frameRateRange[0];
2288 info.maxfps = frameRateRange[1];
2289 }
2290 outputInfos.emplace_back(info);
2291 }
2292 }
2293 return outputInfos;
2294 }
2295
EnableMechDelivery(bool isEnableMech)2296 int32_t HCaptureSession::EnableMechDelivery(bool isEnableMech)
2297 {
2298 MEDIA_INFO_LOG("%{public}s is called, isEnableMech:%{public}d", __FUNCTION__, isEnableMech);
2299 std::lock_guard<std::mutex> lock(mechDeliveryStateLock_);
2300 auto currentState = stateMachine_.GetCurrentState();
2301 switch (currentState) {
2302 case CaptureSessionState::SESSION_INIT:
2303 case CaptureSessionState::SESSION_CONFIG_INPROGRESS:
2304 case CaptureSessionState::SESSION_CONFIG_COMMITTED:
2305 isEnableMech ? mechDeliveryState_ = MechDeliveryState::NEED_ENABLE :
2306 mechDeliveryState_ = MechDeliveryState::NOT_ENABLED;
2307 break;
2308 case CaptureSessionState::SESSION_STARTED:
2309 isEnableMech ? mechDeliveryState_ = MechDeliveryState::ENABLED :
2310 mechDeliveryState_ = MechDeliveryState::NOT_ENABLED;
2311 UpdateSettingForFocusTrackingMech(isEnableMech);
2312 {
2313 auto hStreamOperatorSptr = GetStreamOperator();
2314 if (hStreamOperatorSptr != nullptr) {
2315 hStreamOperatorSptr->UpdateSettingForFocusTrackingMech(isEnableMech);
2316 }
2317 }
2318 break;
2319 default:
2320 break;
2321 }
2322 return CAMERA_OK;
2323 }
2324 } // namespace CameraStandard
2325 } // namespace OHOS