1 /*
2  * Copyright (c) 2020-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 #ifndef OHOS_ACELITE_CAMERA_COMPONENT_H
17 #define OHOS_ACELITE_CAMERA_COMPONENT_H
18 
19 #include "acelite_config.h"
20 #if (FEATURE_COMPONENT_CAMERA == 1)
21 
22 #include "component.h"
23 #include "camera_kit.h"
24 #include "ui_surface_view.h"
25 
26 namespace OHOS {
27 namespace ACELite {
28 class FrameCallback final : public Media::FrameStateCallback {
29 public:
30     ACE_DISALLOW_COPY_AND_MOVE(FrameCallback);
31     FrameCallback() = default;
32     ~FrameCallback() = default;
33     static void ExecuteJsCallback(void *data);
34 
35     class CallbackData final : public MemoryHeap {
36     public:
37         ACE_DISALLOW_COPY_AND_MOVE(CallbackData);
CallbackData()38         CallbackData() : isSucceed_(false), uri_(nullptr), errorCode_(0), errorMsg_(nullptr) {}
~CallbackData()39         ~CallbackData()
40         {
41             if (uri_ != nullptr) {
42                 delete uri_;
43                 uri_ = nullptr;
44             }
45             if (errorMsg_ != nullptr) {
46                 delete errorMsg_;
47                 errorMsg_ = nullptr;
48             }
49         }
50 
51         bool isSucceed_;
52         std::string *uri_;
53         int32_t errorCode_;
54         std::string *errorMsg_;
55     };
56 
57 protected:
58     void OnFrameFinished(Media::Camera &camera,
59                          Media::FrameConfig &frameConfig,
60                          Media::FrameResult &frameResult) override;
61     void OnFrameError(Media::Camera &camera,
62                       Media::FrameConfig &frameConfig,
63                       int32_t errorCode,
64                       Media::FrameResult &frameResult) override;
65 
66 private:
67     std::string *CreateFilePath() const;
68     bool WriteCapture(std::string &filePath, const char * const buffer, const uint32_t size) const;
69     static void CallSuccessFunc(const char * const uri);
70     static void CallFailFunc(const int32_t errorCode, const char * const errorMsg);
71     static void CallCompleteFunc();
72 };
73 
74 class CameraCallback final : public Media::CameraStateCallback {
75 public:
76     ACE_DISALLOW_COPY_AND_MOVE(CameraCallback);
CameraCallback()77     CameraCallback() : camera_(nullptr), previewSurface_(nullptr), frameConfig_(nullptr), errorCallback_(UNDEFINED)
78     {
79         eventHandler_ = std::make_unique<Media::EventHandler>();
80     }
81 
~CameraCallback()82     ~CameraCallback()
83     {
84         jerry_release_value(errorCallback_);
85         eventHandler_.reset();
86         frameCallback_.reset();
87         if (frameConfig_ != nullptr) {
88             delete frameConfig_;
89             frameConfig_ = nullptr;
90         }
91         if (camera_ != nullptr) {
92             camera_->Release();
93         }
94     }
95 
SetPreviewSurface(Surface & surface)96     void SetPreviewSurface(Surface &surface)
97     {
98         previewSurface_ = &surface;
99     }
100 
SetErrorCallback(jerry_value_t callback)101     void SetErrorCallback(jerry_value_t callback)
102     {
103         errorCallback_ = jerry_acquire_value(callback);
104     }
105 
GetCameraInstance()106     const Media::Camera *GetCameraInstance() const
107     {
108         return camera_;
109     }
110 
GetEventHandler()111     Media::EventHandler *GetEventHandler() const
112     {
113         return eventHandler_.get();
114     }
115 
116 protected:
117     void OnCreated(Media::Camera &camera) override;
118     void OnCreateFailed(const std::string cameraId, int32_t errorCode) override;
OnReleased(Media::Camera & camera)119     void OnReleased(Media::Camera &camera) override {}
120 
121 private:
122     Media::Camera *camera_;
123     Surface *previewSurface_;
124     Media::FrameConfig *frameConfig_;
125     std::unique_ptr<Media::EventHandler> eventHandler_;
126     std::unique_ptr<FrameCallback> frameCallback_;
127     jerry_value_t errorCallback_;
128 };
129 
130 class CameraComponent final : public Component {
131 public:
132     ACE_DISALLOW_COPY_AND_MOVE(CameraComponent);
133     CameraComponent() = delete;
134     CameraComponent(jerry_value_t options, jerry_value_t children, AppStyleManager *styleManager);
~CameraComponent()135     ~CameraComponent() override {}
GetCameraCallback()136     const CameraCallback *GetCameraCallback() const
137     {
138         return cameraCallback_.get();
139     }
140 
141     static void ReleaseStaticResources();
142     static jerry_value_t successCallback_;
143     static jerry_value_t failCallback_;
144     static jerry_value_t completeCallback_;
145     static jerry_value_t jsContext_;
146     static bool lastCaptureCompleted_;
147 
148 protected:
149     bool CreateNativeViews() override;
150     void ReleaseNativeViews() override;
151     UIView *GetComponentRootView() const override;
152     bool RegisterPrivateEventListener(uint16_t eventTypeId,
153                                       jerry_value_t funcValue,
154                                       bool isStopPropagation) override;
155     void PostRender() override;
156 
157 private:
158     std::unique_ptr<UISurfaceView> cameraView_;
159     Media::CameraKit *cameraKit_;
160     std::unique_ptr<CameraCallback> cameraCallback_;
161     Media::FrameConfig *frameConfig_;
162     Surface *captureSurface_;
163     static const char * const TAKE_PHOTO;
164     static const uint32_t IMAG_W_PIXELS;
165     static const uint32_t IMAG_H_PIXELS;
166     static const int32_t IMAG_QFACTOR_LOW;
167     static const int32_t IMAG_QFACTOR_NORMAL;
168     static const int32_t IMAG_QFACTOR_HIGH;
169 
GetFrameConfig()170     Media::FrameConfig *GetFrameConfig() const
171     {
172         return frameConfig_;
173     }
174 
175     static bool CaptureFrame(const CameraComponent *component, const char *quality);
176     static jerry_value_t TakePhoto(const jerry_value_t func,
177                                    const jerry_value_t context,
178                                    const jerry_value_t args[],
179                                    const jerry_length_t size);
180 };
181 } // namespace ACELite
182 } // namespace OHOS
183 #endif // FEATURE_COMPONENT_CAMERA
184 #endif // OHOS_ACELITE_CAMERA_COMPONENT_H
185