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 109 private: 110 const char* testName_; 111 }; 112 113 class TestPreviewOutputCallback : public PreviewStateCallback { 114 public: 115 explicit TestPreviewOutputCallback(const char* testName); 116 virtual ~TestPreviewOutputCallback() = default; 117 void OnFrameStarted() const override; 118 void OnFrameEnded(const int32_t frameCount) const override; 119 void OnError(const int32_t errorCode) const override; 120 void OnSketchStatusDataChanged(const SketchStatusData& statusData) const override; 121 122 private: 123 const char* testName_; 124 }; 125 126 class TestVideoOutputCallback : public VideoStateCallback { 127 public: 128 explicit TestVideoOutputCallback(const char* testName); 129 virtual ~TestVideoOutputCallback() = default; 130 void OnFrameStarted() const override; 131 void OnFrameEnded(const int32_t frameCount) const override; 132 void OnError(const int32_t errorCode) const override; 133 134 private: 135 const char* testName_; 136 }; 137 138 class TestMetadataOutputObjectCallback : public MetadataObjectCallback { 139 public: 140 explicit TestMetadataOutputObjectCallback(const char* testName); 141 virtual ~TestMetadataOutputObjectCallback() = default; 142 void OnMetadataObjectsAvailable(std::vector<sptr<MetadataObject>> metaObjects) const override; 143 private: 144 const char* testName_; 145 }; 146 147 class SurfaceListener : public IBufferConsumerListener { 148 public: 149 SurfaceListener(const char* testName, SurfaceType surfaceType, int32_t &fd, sptr<IConsumerSurface> surface); 150 virtual ~SurfaceListener() = default; 151 void OnBufferAvailable() override; 152 153 private: 154 const char* testName_; 155 SurfaceType surfaceType_; 156 int32_t &fd_; 157 sptr<IConsumerSurface> surface_; 158 int32_t previewIndex_ = 0; 159 int32_t secondPreviewIndex_ = 0; 160 }; 161 } // namespace CameraStandard 162 } // namespace OHOS 163 #endif // CAMERA_TEST_COMMON_H 164 165