1 /*
2 * Copyright (c) 2021 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 "camera_device.h"
17 #include "stream_operator.h"
18 #include "stream_operator_callback_wrapper.h"
19 #include <memory>
20
21 namespace OHOS::Camera {
CameraDevice()22 CameraDevice::CameraDevice() {}
23
~CameraDevice()24 CameraDevice::~CameraDevice() {}
25
Init(CameraDeviceCIF * device)26 void CameraDevice::Init(CameraDeviceCIF* device)
27 {
28 device_ = device;
29 }
30
GetStreamOperator(const OHOS::sptr<IStreamOperatorCallback> & callback,OHOS::sptr<IStreamOperator> & streamOperator)31 CamRetCode CameraDevice::GetStreamOperator(const OHOS::sptr<IStreamOperatorCallback>& callback,
32 OHOS::sptr<IStreamOperator>& streamOperator)
33 {
34 if (device_ == nullptr) {
35 return INSUFFICIENT_RESOURCES;
36 }
37
38 StreamOperatorCallbackCIF cb;
39 BindStreamOperatorCallback(callback);
40
41 cb.OnCaptureStarted = StreamCBOnCaptureStarted;
42 cb.OnCaptureEnded = StreamCBOnCaptureEnded;
43 cb.OnCaptureError = StreamCBOnCaptureError;
44 cb.OnFrameShutter = StreamCBOnFrameShutter;
45
46 StreamOperatorCIF* op = nullptr;
47 int ret = device_->GetStreamOperator(cb, op);
48 OHOS::sptr<StreamOperator> spSO = new StreamOperator;
49 spSO->Init(op);
50 streamOperator = spSO;
51
52 return static_cast<CamRetCode>(ret);
53 }
54
UpdateSettings(const std::shared_ptr<CameraSetting> & settings)55 CamRetCode CameraDevice::UpdateSettings(const std::shared_ptr<CameraSetting>& settings)
56 {
57 if (device_ == nullptr) {
58 return INSUFFICIENT_RESOURCES;
59 }
60 CameraSettingCIF* meta = settings->get();
61 int ret = device_->UpdateSettings(meta);
62 return static_cast<CamRetCode>(ret);
63 }
64
SetResultMode(const ResultCallbackMode & mode)65 CamRetCode CameraDevice::SetResultMode(const ResultCallbackMode& mode)
66 {
67 if (device_ == nullptr) {
68 return INSUFFICIENT_RESOURCES;
69 }
70
71 int m = static_cast<int>(mode);
72 int ret = device_->SetResultMode(m);
73 return static_cast<CamRetCode>(ret);
74 }
75
GetEnabledResults(std::vector<MetaType> & results)76 CamRetCode CameraDevice::GetEnabledResults(std::vector<MetaType>& results)
77 {
78 if (device_ == nullptr) {
79 return INSUFFICIENT_RESOURCES;
80 }
81
82 MetaTypeCIF* meta = nullptr;
83 int count = 0;
84 int ret = device_->GetEnabledResults(&meta, &count);
85 for (int i = 0; i < count; i++) {
86 results.push_back(meta[i]);
87 }
88
89 return static_cast<CamRetCode>(ret);
90 }
91
EnableResult(const std::vector<MetaType> & results)92 CamRetCode CameraDevice::EnableResult(const std::vector<MetaType>& results)
93 {
94 if (device_ == nullptr) {
95 return INSUFFICIENT_RESOURCES;
96 }
97
98 int count = results.size();
99 if (count <= 0) {
100 return DEVICE_ERROR;
101 }
102 MetaTypeCIF* meta = new MetaTypeCIF[count];
103 if (meta == nullptr) {
104 return INSUFFICIENT_RESOURCES;
105 }
106 for (int i = 0; i < count; i++) {
107 meta[i] = results[i];
108 }
109 int ret = device_->EnableResult(meta, count);
110 return static_cast<CamRetCode>(ret);
111 }
112
DisableResult(const std::vector<MetaType> & results)113 CamRetCode CameraDevice::DisableResult(const std::vector<MetaType>& results)
114 {
115 if (device_ == nullptr) {
116 return INSUFFICIENT_RESOURCES;
117 }
118
119 int count = results.size();
120 if (count <= 0) {
121 return DEVICE_ERROR;
122 }
123 MetaTypeCIF* meta = new MetaTypeCIF[count];
124 if (meta == nullptr) {
125 return INSUFFICIENT_RESOURCES;
126 }
127 for (int i = 0; i < count; i++) {
128 meta[i] = results[i];
129 }
130 int ret = device_->DisableResult(meta, count);
131 return static_cast<CamRetCode>(ret);
132 }
133
Close()134 void CameraDevice::Close()
135 {
136 if (device_ == nullptr) {
137 return;
138 }
139 device_->Close();
140 }
141
142 } // end namespace OHOS::Camera
143
144