1 /*
2 * Copyright (c) 2023-2024 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 "session/scan_session.h"
17 #include "input/camera_manager.h"
18 #include "output/camera_output_capability.h"
19 #include "camera_log.h"
20 #include "camera_error_code.h"
21 #include "camera_util.h"
22 #include "camera_device_ability_items.h"
23
24 namespace OHOS {
25 namespace CameraStandard {
26
27 const uint8_t SWTCH_ON = 1;
28 const uint8_t SWTCH_OFF = 0;
29
~ScanSession()30 ScanSession::~ScanSession()
31 {
32 }
33
AddOutput(sptr<CaptureOutput> & output)34 int32_t ScanSession::AddOutput(sptr<CaptureOutput> &output)
35 {
36 CHECK_RETURN_RET_ELOG(output == nullptr, CameraErrorCode::INVALID_ARGUMENT,
37 "ScanSession::AddOutput output is nullptr");
38 int32_t result = CAMERA_UNKNOWN_ERROR;
39 auto inputDevice = GetInputDevice();
40 CHECK_RETURN_RET_ELOG(inputDevice == nullptr, CameraErrorCode::SESSION_NOT_CONFIG,
41 "ScanSession::AddOutput get nullptr to inputDevice");
42
43 // LCOV_EXCL_START
44 sptr<CameraDevice> device = inputDevice->GetCameraDeviceInfo();
45 sptr<CameraManager> cameraManager = CameraManager::GetInstance();
46 sptr<CameraOutputCapability> outputCapability = nullptr;
47
48 CHECK_RETURN_RET_ELOG(device == nullptr || cameraManager == nullptr, CameraErrorCode::DEVICE_DISABLED,
49 "ScanSession::AddOutput get nullptr to device or cameraManager");
50 outputCapability = cameraManager->GetSupportedOutputCapability(device, SceneMode::SCAN);
51
52 CHECK_RETURN_RET_ELOG((outputCapability == nullptr || outputCapability->GetPreviewProfiles().size() == 0 ||
53 output->GetOutputType() != CAPTURE_OUTPUT_TYPE_PREVIEW), CameraErrorCode::SESSION_NOT_CONFIG,
54 "ScanSession::AddOutput can not add current type of output");
55 result = CaptureSession::AddOutput(output);
56 return result;
57 // LCOV_EXCL_STOP
58 }
59
CanAddOutput(sptr<CaptureOutput> & output)60 bool ScanSession::CanAddOutput(sptr<CaptureOutput> &output)
61 {
62 // LCOV_EXCL_START
63 MEDIA_DEBUG_LOG("Enter Into ScanSession::CanAddOutput");
64 CHECK_RETURN_RET_ELOG(!IsSessionConfiged() || output == nullptr, false,
65 "ScanSession::CanAddOutput operation is Not allowed!");
66 return output->GetOutputType() != CAPTURE_OUTPUT_TYPE_VIDEO && CaptureSession::CanAddOutput(output);
67 // LCOV_EXCL_STOP
68 }
69
IsBrightnessStatusSupported()70 bool ScanSession::IsBrightnessStatusSupported()
71 {
72 CHECK_RETURN_RET_ELOG(!IsSessionCommited(), false,
73 "ScanSession::IsBrightnessStatusSupported Session is not Commited");
74 // LCOV_EXCL_START
75 auto inputDevice = GetInputDevice();
76 CHECK_RETURN_RET_ELOG(!inputDevice, false,
77 "ScanSession::IsBrightnessStatusSupported camera device is null");
78 auto inputDeviceInfo = inputDevice->GetCameraDeviceInfo();
79 CHECK_RETURN_RET_ELOG(!inputDeviceInfo, false,
80 "ScanSession::IsBrightnessStatusSupported camera deviceInfo is null");
81 sptr<CameraDevice> device = inputDeviceInfo;
82 std::shared_ptr<Camera::CameraMetadata> metadata = device->GetCachedMetadata();
83 camera_metadata_item_t item;
84 int ret = Camera::FindCameraMetadataItem(metadata->get(), OHOS_ABILITY_FLASH_SUGGESTION_SUPPORTED, &item);
85 if (ret == CAM_META_SUCCESS) {
86 camera_supported_enum_t status = static_cast<camera_supported_enum_t>(item.data.ui32[0]);
87 CHECK_RETURN_RET(status == camera_supported_enum_t::OHOS_CAMERA_SUPPORTED, true);
88 }
89 return false;
90 // LCOV_EXCL_STOP
91 }
92
SetBrightnessStatusReport(uint8_t state)93 void ScanSession::SetBrightnessStatusReport(uint8_t state)
94 {
95 // LCOV_EXCL_START
96 this->LockForControl();
97 MEDIA_DEBUG_LOG("ScanSession::SetBrightnessStatusReport set brightness status report");
98 bool status = AddOrUpdateMetadata(changedMetadata_, OHOS_CONTROL_FLASH_SUGGESTION_SWITCH, &state, 1);
99 CHECK_PRINT_ELOG(!status, "ScanSession::SetBrightnessStatusReport Failed to set brightness status report!");
100 this->UnlockForControl();
101 // LCOV_EXCL_STOP
102 }
103
RegisterBrightnessStatusCallback(std::shared_ptr<BrightnessStatusCallback> brightnessStatusCallback)104 void ScanSession::RegisterBrightnessStatusCallback(std::shared_ptr<BrightnessStatusCallback> brightnessStatusCallback)
105 {
106 // LCOV_EXCL_START
107 CHECK_RETURN_ELOG(!IsSessionCommited(),
108 "ScanSession::RegisterBrightnessStatusCallback Session is not Commited");
109 SetBrightnessStatusCallback(brightnessStatusCallback);
110 SetBrightnessStatusReport(SWTCH_ON);
111 // LCOV_EXCL_STOP
112 }
113
UnRegisterBrightnessStatusCallback()114 void ScanSession::UnRegisterBrightnessStatusCallback()
115 {
116 CHECK_RETURN_ELOG(!IsSessionCommited(),
117 "ScanSession::UnRegisterBrightnessStatusCallback Session is not Commited");
118 // LCOV_EXCL_START
119 SetBrightnessStatusCallback(nullptr);
120 SetBrightnessStatusReport(SWTCH_OFF);
121 // LCOV_EXCL_STOP
122 }
123
ProcessBrightnessStatusChange(const std::shared_ptr<OHOS::Camera::CameraMetadata> & result)124 void ScanSession::ProcessBrightnessStatusChange(const std::shared_ptr<OHOS::Camera::CameraMetadata>& result)
125 {
126 // LCOV_EXCL_START
127 CHECK_RETURN_ELOG(result == nullptr, "ScanSession::ProcessBrightnessStatusChange result is null.");
128 MEDIA_DEBUG_LOG("Entry ProcessBrightnessStatusChange");
129 auto callback = GetBrightnessStatusCallback();
130 if (callback != nullptr) {
131 camera_metadata_item_t item;
132 common_metadata_header_t* metadata = result->get();
133 int ret = Camera::FindCameraMetadataItem(metadata, OHOS_STATUS_FLASH_SUGGESTION, &item);
134 CHECK_RETURN_ELOG(ret != CAM_META_SUCCESS,
135 "ScanSession::ProcessBrightnessStatusChange get brightness status failed");
136 bool state = true;
137 uint32_t brightnessStatus = item.data.ui32[0];
138 if (brightnessStatus == 1) {
139 state = false;
140 }
141 MEDIA_DEBUG_LOG("ScanSession::ProcessBrightnessStatusChange state = %{public}d", state);
142 if (!firstBrightnessStatusCome_) {
143 callback->OnBrightnessStatusChanged(state);
144 firstBrightnessStatusCome_ = true;
145 lastBrightnessStatus_ = state;
146 return;
147 }
148 if (state != lastBrightnessStatus_) {
149 callback->OnBrightnessStatusChanged(state);
150 lastBrightnessStatus_ = state;
151 }
152 }
153 // LCOV_EXCL_STOP
154 }
155
ProcessCallbacks(const uint64_t timestamp,const std::shared_ptr<OHOS::Camera::CameraMetadata> & result)156 void ScanSession::ScanSessionMetadataResultProcessor::ProcessCallbacks(
157 const uint64_t timestamp, const std::shared_ptr<OHOS::Camera::CameraMetadata>& result)
158 {
159 // LCOV_EXCL_START
160 CHECK_RETURN_ELOG(result == nullptr,
161 "ScanSession::ScanSessionMetadataResultProcessor ProcessCallbacks result is null.");
162 MEDIA_DEBUG_LOG("ScanSession::ScanSessionMetadataResultProcessor ProcessCallbacks");
163 auto session = session_.promote();
164 CHECK_RETURN_ELOG(session == nullptr,
165 "ScanSession::ScanSessionMetadataResultProcessor ProcessCallbacks but session is null");
166 session->ProcessAutoFocusUpdates(result);
167 session->ProcessBrightnessStatusChange(result);
168 // LCOV_EXCL_STOP
169 }
170 } // namespace CameraStandard
171 } // namespace OHOS