1 /*
2  * Copyright (c) 2020 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 #ifndef OHOS_CAMERA_CAMERA_DEMO_H
17 #define OHOS_CAMERA_CAMERA_DEMO_H
18 
19 #include <vector>
20 #include <map>
21 #include <iostream>
22 #include <hdf_log.h>
23 #include <surface.h>
24 #include <sys/time.h>
25 #include <ctime>
26 #include <fcntl.h>
27 #include "camera.h"
28 #include "camera_metadata_info.h"
29 #include "ibuffer.h"
30 #include "v1_0/ioffline_stream_operator.h"
31 #include "v1_0/icamera_host.h"
32 #include "camera_host_callback.h"
33 #include "camera_device_callback.h"
34 #include "v1_0/icamera_device.h"
35 #include "stream_operator_callback.h"
36 #include "v1_0/istream_operator_callback.h"
37 #include "stream_customer.h"
38 #include "securec.h"
39 #include "project_camera_demo.h"
40 #include "if_system_ability_manager.h"
41 #include "iservice_registry.h"
42 #include "v1_0/camera_host_proxy.h"
43 
44 namespace OHOS::Camera {
45 using namespace OHOS::HDI::Camera::V1_0;
46 
47 enum CaptureMode {
48     CAPTURE_PREVIEW = 0,
49     CAPTURE_SNAPSHOT,
50     CAPTURE_VIDEO,
51 };
52 
53 enum DemoActionID {
54     STREAM_ID_PREVIEW = 1001,
55     STREAM_ID_CAPTURE,
56     STREAM_ID_VIDEO,
57     CAPTURE_ID_PREVIEW = 2001,
58     CAPTURE_ID_CAPTURE,
59     CAPTURE_ID_VIDEO,
60 };
61 
62 class DemoCameraHostCallback;
63 class OhosCameraDemo {
64 public:
65     OhosCameraDemo();
66     ~OhosCameraDemo();
67 
68     RetCode InitCameraDevice();
69     void ReleaseCameraDevice();
70     RetCode InitSensors();
71 
72     RetCode StartPreviewStream();
73     RetCode StartCaptureStream();
74     RetCode StartVideoStream();
75     RetCode StartDualStreams(const int streamIdSecond);
76 
77     RetCode ReleaseAllStream();
78 
79     RetCode CaptureOnDualStreams(const int streamIdSecond);
80     RetCode CaptureON(const int streamId, const int captureId, CaptureMode mode);
81     RetCode CaptureOff(const int captureId, const CaptureMode mode);
82 
83     void SetAwbMode();
84     void SetAfAuto();
85     void SetAeAuto();
86     void SetAeExpo();
87     void SetEnableResult();
88     void SetAELock();
89     void SetAWBLock();
90     void QuitDemo();
91 
92 private:
93     void SetStreamInfo(StreamInfo& streamInfo,
94         const std::shared_ptr<StreamCustomer>& streamCustomer,
95         const int streamId, const StreamIntent intent);
96     void GetStreamOpt();
97 
98     RetCode CreateStream(const int streamId, std::shared_ptr<StreamCustomer> &streamCustomer,
99         StreamIntent intent);
100     RetCode CreateStreams(const int streamIdSecond, StreamIntent intent);
101 
102     void StoreImage(const void *bufStart, const uint32_t size) const;
103     void StoreVideo(const void *bufStart, const uint32_t size) const;
104     void OpenVideoFile();
105 
106     RetCode GetFaceDetectMode(std::shared_ptr<CameraAbility> &ability);
107     RetCode GetFocalLength(std::shared_ptr<CameraAbility> &ability);
108     RetCode GetAvailableFocusModes(std::shared_ptr<CameraAbility> &ability);
109     RetCode GetAvailableExposureModes(std::shared_ptr<CameraAbility> &ability);
110     RetCode GetExposureCompensationRange(std::shared_ptr<CameraAbility> &ability);
111     RetCode GetExposureCompensationSteps(std::shared_ptr<CameraAbility> &ability);
112     RetCode GetAvailableMeterModes(std::shared_ptr<CameraAbility> &ability);
113     RetCode GetAvailableFlashModes(std::shared_ptr<CameraAbility> &ability);
114     RetCode GetMirrorSupported(std::shared_ptr<CameraAbility> &ability);
115     RetCode GetStreamBasicConfigurations(std::shared_ptr<CameraAbility> &ability);
116     RetCode GetFpsRange(std::shared_ptr<CameraAbility> &ability);
117     RetCode GetCameraPosition(std::shared_ptr<CameraAbility> &ability);
118     RetCode GetCameraType(std::shared_ptr<CameraAbility> &ability);
119     RetCode GetCameraConnectionType(std::shared_ptr<CameraAbility> &ability);
120     RetCode GetFaceDetectMaxNum(std::shared_ptr<CameraAbility> &ability);
121 
122     bool awbStatus_ = true;
123     bool aeStatus_ = true;
124     bool aeAutoStatus_ = true;
125     bool afStatus_ = true;
126     bool aeLockStatus_ = true;
127     bool awbLockStatus_ = true;
128     int videoFd_ = -1;
129     unsigned int isPreviewOn_ = 0;
130     unsigned int isCaptureOn_ = 0;
131     unsigned int isVideoOn_ = 0;
132 
133     uint8_t captureQuality_ = 0;
134     int32_t captureOrientation_ = 0;
135     uint8_t mirrorSwitch_ = 0;
136     std::vector<double> gps_;
137     CaptureInfo captureInfo_;
138 
139     std::shared_ptr<StreamCustomer> streamCustomerPreview_ = nullptr;
140     std::shared_ptr<StreamCustomer> streamCustomerCapture_ = nullptr;
141     std::shared_ptr<StreamCustomer> streamCustomerVideo_ = nullptr;
142     std::shared_ptr<CameraAbility> ability_ = nullptr;
143     std::shared_ptr<CameraSetting> captureSetting_ = nullptr;
144     std::mutex metaDatalock_;
145     std::vector<uint8_t> cameraAbility_;
146 
147 #ifdef CAMERA_BUILT_ON_OHOS_LITE
148     std::shared_ptr<DemoCameraHostCallback> hostCallback_ = nullptr;
149     std::shared_ptr<IStreamOperator> streamOperator_ = nullptr;
150     std::shared_ptr<CameraHost> demoCameraHost_ = nullptr;
151     std::shared_ptr<ICameraDevice> demoCameraDevice_ = nullptr;
152 #else
153     OHOS::sptr<DemoCameraHostCallback> hostCallback_ = nullptr;
154     OHOS::sptr<IStreamOperator> streamOperator_ = nullptr;
155     OHOS::sptr<ICameraHost> demoCameraHost_ = nullptr;
156     OHOS::sptr<ICameraDevice> demoCameraDevice_ = nullptr;
157 #endif
158     std::vector<std::string> cameraIds_ = {};
159 };
160 #ifdef CAMERA_BUILT_ON_OHOS_LITE
161 
162 #else
163 class DemoCameraDeviceCallback : public ICameraDeviceCallback {
164 public:
165     DemoCameraDeviceCallback() = default;
166     virtual ~DemoCameraDeviceCallback() = default;
167     int32_t OnError(ErrorType type, int32_t errorCode) override;
168     int32_t OnResult(uint64_t timestamp, const std::vector<uint8_t>& result) override;
169 };
170 
171 class DemoCameraHostCallback : public ICameraHostCallback {
172 public:
173     DemoCameraHostCallback() = default;
174     virtual ~DemoCameraHostCallback() = default;
175 
176 public:
177     int32_t OnCameraStatus(const std::string& cameraId, CameraStatus status) override;
178 
179     int32_t OnFlashlightStatus(const std::string& cameraId, FlashlightStatus status) override;
180 
181     int32_t OnCameraEvent(const std::string& cameraId, CameraEvent event) override;
182 };
183 
184 class DemoStreamOperatorCallback : public IStreamOperatorCallback {
185 public:
186     DemoStreamOperatorCallback() = default;
187     virtual ~DemoStreamOperatorCallback() = default;
188 
189 public:
190     int32_t OnCaptureStarted(int32_t captureId, const std::vector<int32_t>& streamIds) override;
191     int32_t OnCaptureEnded(int32_t captureId, const std::vector<CaptureEndedInfo>& infos) override;
192     int32_t OnCaptureError(int32_t captureId, const std::vector<CaptureErrorInfo>& infos) override;
193     int32_t OnFrameShutter(int32_t captureId, const std::vector<int32_t>& streamIds, uint64_t timestamp) override;
194 };
195 
196 #endif
197 } // namespace OHOS::Camera
198 #endif // OHOS_CAMERA_CAMERA_DEMO_H
199