1 /*
2  * Copyright (c) 2022-2023 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_DM_NATIVE_DEVICEMANAGER_JS_H
17 #define OHOS_DM_NATIVE_DEVICEMANAGER_JS_H
18 
19 #include <memory>
20 #include <string>
21 #include <mutex>
22 
23 #include "device_manager_callback.h"
24 #include "dm_app_image_info.h"
25 #include "dm_device_info.h"
26 #include "dm_native_event.h"
27 #include "dm_subscribe_info.h"
28 #include "dm_publish_info.h"
29 #include "dm_anonymous.h"
30 #include "dm_error_message.h"
31 #include "napi/native_api.h"
32 #include "napi/native_node_api.h"
33 #include "nlohmann/json.hpp"
34 #define DM_NAPI_BUF_LENGTH (256)
35 #define DM_NAPI_CREDENTIAL_BUF_LENGTH (64000)
36 #define DM_NAPI_DESCRIPTION_BUF_LENGTH (16384)
37 
38 struct AsyncCallbackInfo {
39     napi_env env = nullptr;
40     napi_async_work asyncWork = nullptr;
41 
42     char bundleName[DM_NAPI_BUF_LENGTH] = {0};
43     size_t bundleNameLen = 0;
44 
45     napi_ref callback = nullptr;
46     int32_t status = -1;
47     int32_t ret = 0;
48 };
49 
50 struct CredentialAsyncCallbackInfo {
51     napi_env env = nullptr;
52     napi_async_work asyncWork = nullptr;
53 
54     std::string bundleName;
55     std::string reqInfo;
56     std::string returnJsonStr;
57     int32_t status = -1;
58     int32_t ret = 0;
59     napi_ref callback = nullptr;
60 };
61 
62 struct DeviceInfoAsyncCallbackInfo {
63     napi_env env = nullptr;
64     napi_async_work asyncWork = nullptr;
65 
66     std::string bundleName;
67     size_t bundleNameLen = 0;
68     OHOS::DistributedHardware::DmDeviceInfo deviceInfo;
69     std::string extra;
70     // OHOS::DistributedHardware::DmFilterOptions filter;
71     napi_ref callback = nullptr;
72     napi_value thisVar = nullptr;
73     napi_deferred deferred = nullptr;
74     int32_t status = -1;
75     int32_t ret = 0;
76 };
77 
78 struct NetworkIdAsyncCallbackInfo {
79     napi_env env = nullptr;
80     napi_async_work asyncWork = nullptr;
81 
82     std::string bundleName;
83     std::string networkId;
84     size_t bundleNameLen = 0;
85     OHOS::DistributedHardware::DmDeviceInfo deviceInfo;
86 
87     napi_ref callback = nullptr;
88     napi_value thisVar = nullptr;
89     napi_deferred deferred = nullptr;
90     int32_t status = -1;
91     int32_t ret = 0;
92 };
93 
94 struct DeviceInfoListAsyncCallbackInfo {
95     napi_env env = nullptr;
96     napi_async_work asyncWork = nullptr;
97 
98     std::string bundleName;
99     size_t bundleNameLen = 0;
100     std::vector<OHOS::DistributedHardware::DmDeviceInfo> devList;
101     std::string extra;
102     // OHOS::DistributedHardware::DmFilterOptions filter;
103     napi_ref callback = nullptr;
104     napi_value thisVar = nullptr;
105     napi_deferred deferred = nullptr;
106     int32_t status = -1;
107     int32_t ret = 0;
108 };
109 
110 struct AuthAsyncCallbackInfo {
111     napi_env env = nullptr;
112 
113     char bundleName[DM_NAPI_BUF_LENGTH] = {0};
114     size_t bundleNameLen = 0;
115 
116     napi_ref callback = nullptr;
117     int32_t authType = -1;
118 };
119 
120 struct DmNapiStateJsCallback {
121     std::string bundleName_;
122     uint16_t subscribeId_ = 0;
123     int32_t reason_ = 0;
124     OHOS::DistributedHardware::DmDeviceInfo deviceInfo_;
125 
DmNapiStateJsCallbackDmNapiStateJsCallback126     DmNapiStateJsCallback(std::string bundleName, uint16_t subscribeId, int32_t reason,
127         OHOS::DistributedHardware::DmDeviceInfo deviceInfo)
128         : bundleName_(bundleName), subscribeId_(subscribeId), reason_(reason), deviceInfo_(deviceInfo) {}
129 };
130 
131 struct DmNapiPublishJsCallback {
132     std::string bundleName_;
133     int32_t publishId_;
134     int32_t reason_;
135 
DmNapiPublishJsCallbackDmNapiPublishJsCallback136     DmNapiPublishJsCallback(std::string bundleName, int32_t publishId, int32_t reason)
137         : bundleName_(bundleName), publishId_(publishId), reason_(reason) {}
138 };
139 
140 struct DmNapiCredentialJsCallback {
141     std::string bundleName_;
142     int32_t action_;
143     std::string credentialResult_;
144 
DmNapiCredentialJsCallbackDmNapiCredentialJsCallback145     DmNapiCredentialJsCallback(std::string bundleName, int32_t action, std::string credentialResult)
146         : bundleName_(bundleName), action_(action), credentialResult_(credentialResult) {}
147 };
148 
149 struct DmNapiAuthJsCallback {
150     std::string bundleName_;
151     std::string deviceId_;
152     std::string token_;
153     int32_t status_;
154     int32_t reason_;
155 
DmNapiAuthJsCallbackDmNapiAuthJsCallback156     DmNapiAuthJsCallback(std::string bundleName, std::string deviceId, std::string token, int32_t status,
157         int32_t reason)
158         : bundleName_(bundleName), deviceId_(deviceId), token_(token), status_(status), reason_(reason) {}
159 };
160 
161 enum DmNapiDevStateChangeAction { ONLINE = 0, READY = 1, OFFLINE = 2, CHANGE = 3 };
162 
163 class DmNapiInitCallback : public OHOS::DistributedHardware::DmInitCallback {
164 public:
DmNapiInitCallback(napi_env env,std::string & bundleName)165     explicit DmNapiInitCallback(napi_env env, std::string &bundleName) : env_(env), bundleName_(bundleName)
166     {
167     }
~DmNapiInitCallback()168     ~DmNapiInitCallback() override {}
169     void OnRemoteDied() override;
170 
171 private:
172     napi_env env_;
173     std::string bundleName_;
174 };
175 
176 class DmNapiDeviceStateCallback : public OHOS::DistributedHardware::DeviceStateCallback {
177 public:
DmNapiDeviceStateCallback(napi_env env,std::string & bundleName)178     explicit DmNapiDeviceStateCallback(napi_env env, std::string &bundleName) : env_(env), bundleName_(bundleName)
179     {
180     }
~DmNapiDeviceStateCallback()181     ~DmNapiDeviceStateCallback() override {};
182     void OnDeviceOnline(const OHOS::DistributedHardware::DmDeviceInfo &deviceInfo) override;
183     void OnDeviceReady(const OHOS::DistributedHardware::DmDeviceInfo &deviceInfo) override;
184     void OnDeviceOffline(const OHOS::DistributedHardware::DmDeviceInfo &deviceInfo) override;
185     void OnDeviceChanged(const OHOS::DistributedHardware::DmDeviceInfo &deviceInfo) override;
186 
187 private:
188     napi_env env_;
189     std::string bundleName_;
190 };
191 
192 class DmNapiDiscoveryCallback : public OHOS::DistributedHardware::DiscoveryCallback {
193 public:
DmNapiDiscoveryCallback(napi_env env,std::string & bundleName)194     explicit DmNapiDiscoveryCallback(napi_env env, std::string &bundleName)
195         : env_(env), refCount_(0), bundleName_(bundleName)
196     {
197     }
~DmNapiDiscoveryCallback()198     ~DmNapiDiscoveryCallback() override {};
199     void OnDeviceFound(uint16_t subscribeId, const OHOS::DistributedHardware::DmDeviceInfo &deviceInfo) override;
200     void OnDiscoveryFailed(uint16_t subscribeId, int32_t failedReason) override;
201     void OnDiscoverySuccess(uint16_t subscribeId) override;
202     void IncreaseRefCount();
203     void DecreaseRefCount();
204     int32_t GetRefCount();
205 
206 private:
207     napi_env env_;
208     std::atomic<int32_t> refCount_;
209     std::string bundleName_;
210 };
211 
212 class DmNapiPublishCallback : public OHOS::DistributedHardware::PublishCallback {
213 public:
DmNapiPublishCallback(napi_env env,std::string & bundleName)214     explicit DmNapiPublishCallback(napi_env env, std::string &bundleName)
215         : env_(env), refCount_(0), bundleName_(bundleName)
216     {
217     }
~DmNapiPublishCallback()218     ~DmNapiPublishCallback() override {};
219     void OnPublishResult(int32_t publishId, int32_t publishResult) override;
220     void IncreaseRefCount();
221     void DecreaseRefCount();
222     int32_t GetRefCount();
223 
224 private:
225     napi_env env_;
226     std::atomic<int32_t> refCount_;
227     std::string bundleName_;
228 };
229 
230 class DmNapiDeviceManagerUiCallback : public OHOS::DistributedHardware::DeviceManagerUiCallback {
231 public:
DmNapiDeviceManagerUiCallback(napi_env env,std::string & bundleName)232     explicit DmNapiDeviceManagerUiCallback(napi_env env, std::string &bundleName) : env_(env), bundleName_(bundleName)
233     {
234     }
~DmNapiDeviceManagerUiCallback()235     ~DmNapiDeviceManagerUiCallback() override {};
236     void OnCall(const std::string &paramJson) override;
237 
238 private:
239     napi_env env_;
240     std::string bundleName_;
241 };
242 
243 class DmNapiCredentialCallback : public OHOS::DistributedHardware::CredentialCallback {
244 public:
DmNapiCredentialCallback(napi_env env,const std::string & bundleName)245     explicit DmNapiCredentialCallback(napi_env env, const std::string &bundleName) : env_(env), bundleName_(bundleName)
246     {
247     }
~DmNapiCredentialCallback()248     ~DmNapiCredentialCallback() override {};
249     void OnCredentialResult(int32_t &action, const std::string &credentialResult) override;
250 
251 private:
252     napi_env env_;
253     std::string bundleName_;
254 };
255 
256 class DmNapiAuthenticateCallback : public OHOS::DistributedHardware::AuthenticateCallback {
257 public:
DmNapiAuthenticateCallback(napi_env env,std::string & bundleName)258     explicit DmNapiAuthenticateCallback(napi_env env, std::string &bundleName) : env_(env), bundleName_(bundleName)
259     {
260     }
~DmNapiAuthenticateCallback()261     ~DmNapiAuthenticateCallback() override {};
262     void OnAuthResult(const std::string &deviceId, const std::string &token, int32_t status, int32_t reason) override;
263 
264 private:
265     napi_env env_;
266     std::string bundleName_;
267 };
268 
269 class DeviceManagerNapi : public DmNativeEvent {
270 public:
271     explicit DeviceManagerNapi(napi_env env, napi_value thisVar);
272     ~DeviceManagerNapi() override;
273     static napi_value Init(napi_env env, napi_value exports);
274     static napi_value Constructor(napi_env env, napi_callback_info info);
275     static napi_value EnumTypeConstructor(napi_env env, napi_callback_info info);
276     static napi_value InitDeviceTypeEnum(napi_env env, napi_value exports);
277     static napi_value InitDeviceStateChangeActionEnum(napi_env env, napi_value exports);
278     static napi_value InitDiscoverModeEnum(napi_env env, napi_value exports);
279     static napi_value InitExchangeMediumEnum(napi_env env, napi_value exports);
280     static napi_value InitExchangeFreqEnum(napi_env env, napi_value exports);
281     static napi_value InitSubscribeCapEnum(napi_env env, napi_value exports);
282     static napi_value CreateDeviceManager(napi_env env, napi_callback_info info);
283     static napi_value ReleaseDeviceManager(napi_env env, napi_callback_info info);
284     static napi_value SetUserOperationSync(napi_env env, napi_callback_info info);
285     static napi_value GetTrustedDeviceListSync(napi_env env, napi_callback_info info);
286     static napi_value GetTrustedDeviceList(napi_env env, napi_callback_info info);
287     static napi_value GetLocalDeviceInfoSync(napi_env env, napi_callback_info info);
288     static napi_value GetLocalDeviceInfo(napi_env env, napi_callback_info info);
289     static napi_value GetDeviceInfo(napi_env env, napi_callback_info info);
290     static napi_value UnAuthenticateDevice(napi_env env, napi_callback_info info);
291     static napi_value StartDeviceDiscoverSync(napi_env env, napi_callback_info info);
292     static napi_value StopDeviceDiscoverSync(napi_env env, napi_callback_info info);
293     static napi_value PublishDeviceDiscoverySync(napi_env env, napi_callback_info info);
294     static napi_value UnPublishDeviceDiscoverySync(napi_env env, napi_callback_info info);
295     static napi_value AuthenticateDevice(napi_env env, napi_callback_info info);
296     static napi_value RequestCredential(napi_env env, napi_callback_info info);
297     static napi_value ImportCredential(napi_env env, napi_callback_info info);
298     static napi_value DeleteCredential(napi_env env, napi_callback_info info);
299     static napi_value JsOn(napi_env env, napi_callback_info info);
300     static napi_value JsOff(napi_env env, napi_callback_info info);
301     static void HandleCreateDmCallBack(const napi_env &env, AsyncCallbackInfo *asCallbackInfo);
302     static DeviceManagerNapi *GetDeviceManagerNapi(std::string &bundleName);
303     static void CreateDmCallback(napi_env env, std::string &bundleName, std::string &eventType);
304     static void CreateDmCallback(napi_env env, std::string &bundleName, std::string &eventType, std::string &extra);
305     static void ReleaseDmCallback(std::string &bundleName, std::string &eventType);
306     static void DeviceInfoToJsArray(const napi_env &env,
307                                     const std::vector<OHOS::DistributedHardware::DmDeviceInfo> &vecDevInfo,
308                                     const int32_t idx, napi_value &arrayResult);
309     static bool DmAuthParamDetection(const OHOS::DistributedHardware::DmAuthParam &authParam);
310     static void DmAuthParamToJsAuthParam(const napi_env &env, const OHOS::DistributedHardware::DmAuthParam &authParam,
311                                          napi_value &paramResult);
312     static void SetValueInt32(const napi_env &env, const std::string &fieldStr, const int32_t intValue,
313                               napi_value &result);
314     static void SetValueUtf8String(const napi_env &env, const std::string &fieldStr, const std::string &str,
315                                    napi_value &result);
316     static void JsObjectToString(const napi_env &env, const napi_value &object, const std::string &fieldStr, char *dest,
317                                  const int32_t destLen);
318     static void JsObjectToBool(const napi_env &env, const napi_value &object, const std::string &fieldStr,
319                                bool &fieldRef);
320     static void JsObjectToInt(const napi_env &env, const napi_value &object, const std::string &fieldStr,
321                               int32_t &fieldRef);
322     static std::string JsObjectToString(const napi_env &env, const napi_value &param);
323     static bool JsToStringAndCheck(napi_env env, napi_value value, const std::string &valueName, std::string &strValue);
324     static int32_t JsToDmSubscribeInfo(const napi_env &env, const napi_value &object,
325                                        OHOS::DistributedHardware::DmSubscribeInfo &info);
326     static void JsToDmPublishInfo(const napi_env &env, const napi_value &object,
327                                   OHOS::DistributedHardware::DmPublishInfo &info);
328     static void JsToDmDeviceInfo(const napi_env &env, const napi_value &object,
329                                  OHOS::DistributedHardware::DmDeviceInfo &info);
330     static void JsToDmExtra(const napi_env &env, const napi_value &object, std::string &extra, int32_t &authType);
331     static void JsToDmAuthInfo(const napi_env &env, const napi_value &object, std::string &extra);
332     static void JsToJsonObject(const napi_env &env, const napi_value &object, const std::string &fieldStr,
333                                nlohmann::json &jsonObj);
334     static void JsToDmTokenInfo(const napi_env &env, const napi_value &object, const std::string &fieldStr,
335                                 nlohmann::json &jsonObj);
336     static void JsToDmAuthExtra(const napi_env &env, const napi_value &param, nlohmann::json &jsonObj);
337     static void JsToDmDiscoveryExtra(const napi_env &env, const napi_value &object, std::string &extra);
338     static void DmDeviceInfotoJsDeviceInfo(const napi_env &env,
339                                            const OHOS::DistributedHardware::DmDeviceInfo &vecDevInfo,
340                                            napi_value &result);
341     static int32_t RegisterCredentialCallback(napi_env env, const std::string &pkgName);
342     static void AsyncAfterTaskCallback(napi_env env, napi_status status, void *data);
343     static void AsyncTaskCallback(napi_env env, void *data);
344     static void DeviceInfotoJsByNetworkId(const napi_env &env,
345                                           const OHOS::DistributedHardware::DmDeviceInfo &nidDevInfo,
346                                           napi_value &result);
347     void OnDeviceStateChange(DmNapiDevStateChangeAction action,
348                              const OHOS::DistributedHardware::DmDeviceInfo &deviceInfo);
349     void OnDeviceFound(uint16_t subscribeId, const OHOS::DistributedHardware::DmDeviceInfo &deviceInfo);
350     void OnDiscoveryFailed(uint16_t subscribeId, int32_t failedReason);
351     void OnPublishResult(int32_t publishId, int32_t publishResult);
352     void OnAuthResult(const std::string &deviceId, const std::string &token, int32_t status, int32_t reason);
353     void OnCredentialResult(int32_t &action, const std::string &credentialResult);
354     void OnDmUiCall(const std::string &paramJson);
355 
356 private:
357     static void ReleasePublishCallback(std::string &bundleName);
358     static void ReleaseDiscoveryCallback(std::string &bundleName);
359     static void RegisterDevStateCallback(napi_env env, std::string &bundleName);
360     static void ClearBundleCallbacks(std::string &bundleName);
361     static void LockDiscoveryCallbackMutex(napi_env env, OHOS::DistributedHardware::DmSubscribeInfo subInfo,
362                                            std::string &bundleName, std::string &extra);
363     static napi_value JsOffFrench(napi_env env, int32_t num, napi_value thisVar, napi_value argv[]);
364     static napi_value JsOnFrench(napi_env env, int32_t num, napi_value thisVar, napi_value argv[]);
365     static void CallAsyncWorkSync(napi_env env, DeviceInfoAsyncCallbackInfo *deviceInfoAsyncCallbackInfo);
366     static void CallAsyncWork(napi_env env, DeviceInfoAsyncCallbackInfo *deviceInfoAsyncCallbackInfo);
367     static void CallAsyncWorkSync(napi_env env, DeviceInfoListAsyncCallbackInfo *deviceInfoListAsyncCallbackInfo);
368     static void CallAsyncWork(napi_env env, DeviceInfoListAsyncCallbackInfo *deviceInfoListAsyncCallbackInfo);
369     static void CallCredentialAsyncWork(napi_env env, CredentialAsyncCallbackInfo *creAsyncCallbackInfo);
370     static void CallRequestCreInfoStatus(napi_env env, napi_status &status,
371                                          CredentialAsyncCallbackInfo *creAsyncCallbackInfo);
372     static void CallGetTrustedDeviceListStatusSync(napi_env env, napi_status &status,
373                                                    DeviceInfoListAsyncCallbackInfo *deviceInfoListAsyncCallbackInfo);
374     static void CallGetTrustedDeviceListStatus(napi_env env, napi_status &status,
375                                                DeviceInfoListAsyncCallbackInfo *deviceInfoListAsyncCallbackInfo);
376     static napi_value CallDeviceList(napi_env env, napi_callback_info info,
377                                      DeviceInfoListAsyncCallbackInfo *deviceInfoListAsyncCallbackInfo);
378     static void CallGetLocalDeviceInfoSync(napi_env env, napi_status &status,
379                                            DeviceInfoAsyncCallbackInfo *deviceInfoAsyncCallbackInfo);
380     static void CallGetLocalDeviceInfo(napi_env env, napi_status &status,
381                                        DeviceInfoAsyncCallbackInfo *deviceInfoAsyncCallbackInfo);
382     static napi_value GetTrustedDeviceListPromise(napi_env env,
383                                                   DeviceInfoListAsyncCallbackInfo *deviceInfoListAsyncCallbackInfo);
384     static napi_value GetTrustedDeviceListByFilter(napi_env env, napi_callback_info info,
385                                                     DeviceInfoListAsyncCallbackInfo *deviceInfoListAsyncCallbackInfo);
386     static bool StartArgCheck(napi_env env, napi_value &argv, OHOS::DistributedHardware::DmSubscribeInfo &subInfo);
387     static bool CheckPermissions(napi_env env);
388     static void HandleCreateDmCallBackCompletedCB(napi_env env, napi_status status, void *data);
389     // get deviceInfo by networkId
390     static void CallGetDeviceInfo(napi_env env, NetworkIdAsyncCallbackInfo *networkIdAsyncCallbackInfo);
391     static void GetDeviceInfoCB(napi_env env, void *data);
392     static void CompleteGetDeviceInfoCB(napi_env env, napi_status status, void *data);
393     static void CallGetDeviceInfoPromise(napi_env env, napi_status &status,
394                                          NetworkIdAsyncCallbackInfo *networkIdAsyncCallbackInfo);
395     static void CallGetDeviceInfoCB(napi_env env, napi_status &status,
396                                     NetworkIdAsyncCallbackInfo *networkIdAsyncCallbackInfo);
397     static bool IsSystemApp();
398 private:
399     napi_env env_;
400     static thread_local napi_ref sConstructor_;
401     std::string bundleName_;
402     static std::mutex creMapLocks_;
403     static AuthAsyncCallbackInfo authAsyncCallbackInfo_;
404     static CredentialAsyncCallbackInfo creAsyncCallbackInfo_;
405 };
406 #endif // OHOS_DM_NATIVE_DEVICEMANAGER_JS_H
407