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