1 /*
2  * Copyright (c) 2021-2022 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 #ifndef CAMERA_TEST_COMMON_H
16 #define CAMERA_TEST_COMMON_H
17 
18 #include "camera_output_capability.h"
19 #include "input/camera_manager.h"
20 
21 namespace OHOS {
22 namespace CameraStandard {
23 enum class VideoSaveMode {
24     CREATE = 0,
25     APPEND,
26     CLOSE
27 };
28 
29 enum class SurfaceType {
30     INVALID = 0,
31     PREVIEW,
32     SECOND_PREVIEW,
33     PHOTO,
34     VIDEO,
35     SKETCH
36 };
37 
38 enum HostDeviceType {
39     /**
40      * Indicates an unknown device type.
41      */
42     UNKNOWN = 0x00,
43     /**
44      * Indicates a smart phone.
45      */
46     PHONE = 0x0E,
47     /**
48      * Indicates a smart pad.
49      */
50     TABLET = 0x11,
51 };
52 
53 
54 class TestUtils {
55 public:
56     static const std::int32_t FILE_PERMISSIONS_FLAG = 00766;
57     static const std::int32_t PREVIEW_SKIP_FRAMES = 10;
58 
59     static camera_format_t GetCameraMetadataFormat(CameraFormat format);
60     static uint64_t GetCurrentLocalTimeStamp();
61     static int32_t SaveYUV(const char* buffer, int32_t size, SurfaceType type);
62     static int32_t SaveJpeg(const char* buffer, int32_t size);
63     static bool IsNumber(const char number[]);
64     static int32_t SaveVideoFile(const char* buffer, int32_t size, VideoSaveMode operationMode, int32_t &fd);
65 };
66 
67 class TestCameraMngerCallback : public CameraManagerCallback {
68 public:
69     explicit TestCameraMngerCallback(const char* testName);
70     virtual ~TestCameraMngerCallback() = default;
71     void OnCameraStatusChanged(const CameraStatusInfo &cameraStatusInfo) const override;
72     void OnFlashlightStatusChanged(const std::string &cameraID,
73                                    const FlashStatus flashStatus) const override;
74 
75 private:
76     const char* testName_;
77 };
78 
79 class TestDeviceCallback : public ErrorCallback {
80 public:
81     explicit TestDeviceCallback(const char* testName);
82     virtual ~TestDeviceCallback() = default;
83     void OnError(const int32_t errorType, const int32_t errorMsg) const override;
84 
85 private:
86     const char* testName_;
87 };
88 
89 class TestOnResultCallback : public ResultCallback {
90 public:
91     explicit TestOnResultCallback(const char* testName);
92     virtual ~TestOnResultCallback() = default;
93     void OnResult(const uint64_t timestamp, const std::shared_ptr<OHOS::Camera::CameraMetadata> &result) const;
94 
95 private:
96     const char* testName_;
97 };
98 
99 class TestPhotoOutputCallback : public PhotoStateCallback {
100 public:
101     explicit TestPhotoOutputCallback(const char* testName);
102     virtual ~TestPhotoOutputCallback() = default;
103     void OnCaptureStarted(const int32_t captureID) const override;
104     void OnCaptureStarted(const int32_t captureID, uint32_t exposureTime) const override;
105     void OnCaptureEnded(const int32_t captureID, const int32_t frameCount) const override;
106     void OnFrameShutter(const int32_t captureId, const uint64_t timestamp) const override;
107     void OnCaptureError(const int32_t captureId, const int32_t errorCode) const override;
108     void OnFrameShutterEnd(const int32_t captureId, const uint64_t timestamp) const override;
109     void OnCaptureReady(const int32_t captureId, const uint64_t timestamp) const override;
110     void OnEstimatedCaptureDuration(const int32_t duration) const override;
111 
112 private:
113     const char* testName_;
114 };
115 
116 class TestPreviewOutputCallback : public PreviewStateCallback {
117 public:
118     explicit TestPreviewOutputCallback(const char* testName);
119     virtual ~TestPreviewOutputCallback() = default;
120     void OnFrameStarted() const override;
121     void OnFrameEnded(const int32_t frameCount) const override;
122     void OnError(const int32_t errorCode) const override;
123     void OnSketchStatusDataChanged(const SketchStatusData& statusData) const override;
124 
125 private:
126     const char* testName_;
127 };
128 
129 class TestVideoOutputCallback : public VideoStateCallback {
130 public:
131     explicit TestVideoOutputCallback(const char* testName);
132     virtual ~TestVideoOutputCallback() = default;
133     void OnFrameStarted() const override;
134     void OnFrameEnded(const int32_t frameCount) const override;
135     void OnError(const int32_t errorCode) const override;
136     void OnDeferredVideoEnhancementInfo(const CaptureEndedInfoExt info) const override;
137 
138 private:
139     const char* testName_;
140 };
141 
142 class TestMetadataOutputObjectCallback : public MetadataObjectCallback {
143 public:
144     explicit TestMetadataOutputObjectCallback(const char* testName);
145     virtual ~TestMetadataOutputObjectCallback() = default;
146     void OnMetadataObjectsAvailable(std::vector<sptr<MetadataObject>> metaObjects) const override;
147 private:
148     const char* testName_;
149 };
150 
151 class TestDeferredPhotoProcSessionCallback : public IDeferredPhotoProcSessionCallback {
152 public:
153     void OnProcessImageDone(const std::string &imageId, std::shared_ptr<Media::Picture> picture,
154         bool isCloudImageEnhanceSupported);
155     void OnDeliveryLowQualityImage(const std::string &imageId, std::shared_ptr<Media::Picture> picture);
156     void OnProcessImageDone(const std::string& imageId, const uint8_t* addr, const long bytes,
157         bool isCloudImageEnhanceSupported);
158     void OnError(const std::string& imageId, const DpsErrorCode errorCode);
159     void OnStateChanged(const DpsStatusCode status);
160 };
161 
162 class SurfaceListener : public IBufferConsumerListener {
163 public:
164     SurfaceListener(const char* testName, SurfaceType surfaceType, int32_t &fd, sptr<IConsumerSurface> surface);
165     virtual ~SurfaceListener() = default;
166     void OnBufferAvailable() override;
167 
168 private:
169     const char* testName_;
170     SurfaceType surfaceType_;
171     int32_t &fd_;
172     sptr<IConsumerSurface> surface_;
173     int32_t previewIndex_ = 0;
174     int32_t secondPreviewIndex_ = 0;
175 };
176 } // namespace CameraStandard
177 } // namespace OHOS
178 #endif // CAMERA_TEST_COMMON_H
179 
180