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_input.h"
18 #include "input/camera_manager.h"
19 #include "output/camera_output_capability.h"
20 #include "camera_log.h"
21 #include "camera_error_code.h"
22 #include "camera_util.h"
23 #include "camera_device_ability_items.h"
24
25 namespace OHOS {
26 namespace CameraStandard {
27
28 const uint8_t SWTCH_ON = 1;
29 const uint8_t SWTCH_OFF = 0;
30
~ScanSession()31 ScanSession::~ScanSession()
32 {
33 }
34
AddOutput(sptr<CaptureOutput> & output)35 int32_t ScanSession::AddOutput(sptr<CaptureOutput> &output)
36 {
37 int32_t result = CAMERA_UNKNOWN_ERROR;
38 auto inputDevice = GetInputDevice();
39 CHECK_ERROR_RETURN_RET_LOG(inputDevice == nullptr, CameraErrorCode::SESSION_NOT_CONFIG,
40 "ScanSession::AddOutput get nullptr to inputDevice");
41
42 sptr<CameraDevice> device = inputDevice->GetCameraDeviceInfo();
43 sptr<CameraManager> cameraManager = CameraManager::GetInstance();
44 sptr<CameraOutputCapability> outputCapability = nullptr;
45
46 CHECK_AND_RETURN_RET_LOG(device != nullptr && cameraManager != nullptr, CameraErrorCode::DEVICE_DISABLED,
47 "ScanSession::AddOutput get nullptr to device or cameraManager");
48 outputCapability = cameraManager->GetSupportedOutputCapability(device, SceneMode::SCAN);
49
50 CHECK_AND_RETURN_RET_LOG((outputCapability != nullptr && outputCapability->GetPreviewProfiles().size() != 0 &&
51 output->GetOutputType() == CAPTURE_OUTPUT_TYPE_PREVIEW), CameraErrorCode::SESSION_NOT_CONFIG,
52 "ScanSession::AddOutput can not add current type of output");
53 result = CaptureSession::AddOutput(output);
54 return result;
55 }
56
CanAddOutput(sptr<CaptureOutput> & output)57 bool ScanSession::CanAddOutput(sptr<CaptureOutput> &output)
58 {
59 MEDIA_DEBUG_LOG("Enter Into ScanSession::CanAddOutput");
60 CHECK_ERROR_RETURN_RET_LOG(!IsSessionConfiged() || output == nullptr, false,
61 "ScanSession::CanAddOutput operation is Not allowed!");
62 return output->GetOutputType() != CAPTURE_OUTPUT_TYPE_VIDEO && CaptureSession::CanAddOutput(output);
63 }
64
IsBrightnessStatusSupported()65 bool ScanSession::IsBrightnessStatusSupported()
66 {
67 CHECK_ERROR_RETURN_RET_LOG(!IsSessionCommited(), false,
68 "ScanSession::IsBrightnessStatusSupported Session is not Commited");
69 auto inputDevice = GetInputDevice();
70 CHECK_ERROR_RETURN_RET_LOG(!inputDevice, false,
71 "ScanSession::IsBrightnessStatusSupported camera device is null");
72 auto device = inputDevice->GetCameraDeviceInfo();
73 CHECK_ERROR_RETURN_RET_LOG(!device, false,
74 "ScanSession::IsBrightnessStatusSupported camera deviceInfo is null");
75 std::shared_ptr<Camera::CameraMetadata> metadata = device->GetMetadata();
76 camera_metadata_item_t item;
77 int ret = Camera::FindCameraMetadataItem(metadata->get(), OHOS_ABILITY_FLASH_SUGGESTION_SUPPORTED, &item);
78 if (ret == CAM_META_SUCCESS) {
79 camera_supported_enum_t status = static_cast<camera_supported_enum_t>(item.data.ui32[0]);
80 if (status == camera_supported_enum_t::OHOS_CAMERA_SUPPORTED) {
81 return true;
82 }
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 MEDIA_DEBUG_LOG("Entry ProcessBrightnessStatusChange");
124 auto callback = GetBrightnessStatusCallback();
125 if (callback != nullptr) {
126 camera_metadata_item_t item;
127 common_metadata_header_t* metadata = result->get();
128 int ret = Camera::FindCameraMetadataItem(metadata, OHOS_STATUS_FLASH_SUGGESTION, &item);
129 CHECK_ERROR_RETURN_LOG(ret != CAM_META_SUCCESS,
130 "ScanSession::ProcessBrightnessStatusChange get brightness status failed");
131 bool state = true;
132 uint32_t brightnessStatus = item.data.ui32[0];
133 if (brightnessStatus == 1) {
134 state = false;
135 }
136 MEDIA_DEBUG_LOG("ScanSession::ProcessBrightnessStatusChange state = %{public}d", state);
137 if (!firstBrightnessStatusCome_) {
138 callback->OnBrightnessStatusChanged(state);
139 firstBrightnessStatusCome_ = true;
140 lastBrightnessStatus_ = state;
141 return;
142 }
143 if (state != lastBrightnessStatus_) {
144 callback->OnBrightnessStatusChanged(state);
145 lastBrightnessStatus_ = state;
146 }
147 }
148 }
149
ProcessCallbacks(const uint64_t timestamp,const std::shared_ptr<OHOS::Camera::CameraMetadata> & result)150 void ScanSession::ScanSessionMetadataResultProcessor::ProcessCallbacks(
151 const uint64_t timestamp, const std::shared_ptr<OHOS::Camera::CameraMetadata>& result)
152 {
153 MEDIA_DEBUG_LOG("ScanSession::ScanSessionMetadataResultProcessor ProcessCallbacks");
154 auto session = session_.promote();
155 CHECK_ERROR_RETURN_LOG(session == nullptr,
156 "ScanSession::ScanSessionMetadataResultProcessor ProcessCallbacks but session is null");
157 session->ProcessAutoFocusUpdates(result);
158 session->ProcessBrightnessStatusChange(result);
159 }
160 } // namespace CameraStandard
161 } // namespace OHOS