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 
16 #ifndef CAMERA_INPUT_NAPI_H_
17 #define CAMERA_INPUT_NAPI_H_
18 
19 #include <atomic>
20 #include <cstdint>
21 #include <mutex>
22 
23 #include "camera_napi_event_emitter.h"
24 #include "camera_napi_utils.h"
25 #include "camera_napi_worker_queue_keeper.h"
26 #include "input/camera_input.h"
27 #include "input/camera_manager.h"
28 #include "listener_base.h"
29 
30 namespace OHOS {
31 namespace CameraStandard {
32 static const char CAMERA_INPUT_NAPI_CLASS_NAME[] = "CameraInput";
33 
34 struct CameraInputAsyncContext;
35 
36 class ErrorCallbackListener : public ErrorCallback,
37                               public ListenerBase,
38                               public std::enable_shared_from_this<ErrorCallbackListener> {
39 public:
ErrorCallbackListener(napi_env env)40     ErrorCallbackListener(napi_env env) : ListenerBase(env) {}
41     ~ErrorCallbackListener() = default;
42     void OnError(const int32_t errorType, const int32_t errorMsg) const override;
43 
44 private:
45     void OnErrorCallback(const int32_t errorType, const int32_t errorMsg) const;
46     void OnErrorCallbackAsync(const int32_t errorType, const int32_t errorMsg) const;
47 };
48 
49 struct ErrorCallbackInfo {
50     int32_t errorType_;
51     int32_t errorMsg_;
52     weak_ptr<const ErrorCallbackListener> listener_;
ErrorCallbackInfoErrorCallbackInfo53     ErrorCallbackInfo(int32_t errorType, int32_t errorMsg, shared_ptr<const ErrorCallbackListener> listener)
54         : errorType_(errorType), errorMsg_(errorMsg), listener_(listener) {}
55 };
56 
57 class OcclusionDetectCallbackListener : public CameraOcclusionDetectCallback,
58                               public ListenerBase,
59                               public std::enable_shared_from_this<OcclusionDetectCallbackListener> {
60 public:
OcclusionDetectCallbackListener(napi_env env)61     OcclusionDetectCallbackListener(napi_env env) : ListenerBase(env) {}
62     ~OcclusionDetectCallbackListener() = default;
63     void OnCameraOcclusionDetected(const uint8_t isCameraOcclusion,
64                                    const uint8_t isCameraLensDirty) const override;
65 
66 private:
67     void OnCameraOcclusionDetectedCallback(const uint8_t isCameraOcclusion,
68                                            const uint8_t isCameraLensDirty) const;
69     void OnCameraOcclusionDetectedCallbackAsync(const uint8_t isCameraOcclusion,
70                                                 const uint8_t isCameraLensDirty) const;
71 };
72 
73 struct CameraOcclusionDetectResult {
74     uint8_t isCameraOccluded_;
75     uint8_t isCameraLensDirty_;
76     weak_ptr<const OcclusionDetectCallbackListener> listener_;
CameraOcclusionDetectResultCameraOcclusionDetectResult77     CameraOcclusionDetectResult(uint8_t isCameraOccluded, uint8_t isCameraLensDirty,
78         shared_ptr<const OcclusionDetectCallbackListener> listener)
79         : isCameraOccluded_(isCameraOccluded), isCameraLensDirty_(isCameraLensDirty), listener_(listener) {}
80 };
81 
82 class CameraInputNapi : public CameraNapiEventEmitter<CameraInputNapi> {
83 public:
84     static napi_value Init(napi_env env, napi_value exports);
85     static napi_value CreateCameraInput(napi_env env, sptr<CameraInput> cameraInput);
86     CameraInputNapi();
87     ~CameraInputNapi() override;
88 
89     static void NapiCreateInt32Logs(
90         napi_env env, int32_t contextMode, std::unique_ptr<JSAsyncContextOutput>& jsContext);
91     static void NapiCreateDoubleLogs(
92         napi_env env, double contextMode, std::unique_ptr<JSAsyncContextOutput>& jsContext);
93 
94     static napi_value Open(napi_env env, napi_callback_info info);
95     static napi_value Close(napi_env env, napi_callback_info info);
96     static napi_value Release(napi_env env, napi_callback_info info);
97     static napi_value On(napi_env env, napi_callback_info info);
98     static napi_value Off(napi_env env, napi_callback_info info);
99     static napi_value Once(napi_env env, napi_callback_info info);
100     static napi_value UsedAsPosition(napi_env env, napi_callback_info info);
101 
102     const EmitterFunctions& GetEmitterFunctions() override;
103 
104     sptr<CameraInput> GetCameraInput();
105     sptr<CameraInput> cameraInput_;
106 
107 private:
108     static void CameraInputNapiDestructor(napi_env env, void* nativeObject, void* finalize_hint);
109     static napi_value CameraInputNapiConstructor(napi_env env, napi_callback_info info);
110 
111     void RegisterErrorCallbackListener(const std::string& eventName, napi_env env, napi_value callback,
112         const std::vector<napi_value>& args, bool isOnce);
113     void UnregisterErrorCallbackListener(
114         const std::string& eventName, napi_env env, napi_value callback, const std::vector<napi_value>& args);
115     void RegisterOcclusionDetectCallbackListener(const std::string& eventName, napi_env env, napi_value callback,
116         const std::vector<napi_value>& args, bool isOnce);
117     void UnregisterOcclusionDetectCallbackListener(
118         const std::string& eventName, napi_env env, napi_value callback, const std::vector<napi_value>& args);
119 
120     napi_env env_;
121     std::string cameraId_;
122     shared_ptr<ErrorCallbackListener> errorCallback_;
123     shared_ptr<OcclusionDetectCallbackListener> occlusionDetectCallback_;
124 
125     static thread_local napi_ref sConstructor_;
126     static thread_local std::string sCameraId_;
127     static thread_local sptr<CameraInput> sCameraInput_;
128     static thread_local uint32_t cameraInputTaskId;
129 };
130 
131 struct CameraInputAsyncContext : public AsyncContext {
CameraInputAsyncContextCameraInputAsyncContext132     CameraInputAsyncContext(std::string funcName, int32_t taskId) : AsyncContext(funcName, taskId) {};
133     CameraInputNapi* objectInfo = nullptr;
134     bool isEnableSecCam = false;
135     uint64_t secureCameraSeqId = 0L;
136 };
137 } // namespace CameraStandard
138 } // namespace OHOS
139 #endif /* CAMERA_INPUT_NAPI_H_ */
140