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
21namespace OHOS::Camera {
22CameraDevice::CameraDevice() {}
23
24CameraDevice::~CameraDevice() {}
25
26void CameraDevice::Init(CameraDeviceCIF* device)
27{
28    device_ = device;
29}
30
31CamRetCode 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
55CamRetCode 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
65CamRetCode 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
76CamRetCode 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
92CamRetCode 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
113CamRetCode 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
134void CameraDevice::Close()
135{
136    if (device_ == nullptr) {
137        return;
138    }
139    device_->Close();
140}
141
142} // end namespace OHOS::Camera
143
144