1 /*
2 * Copyright (c) 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 #include <string>
17
18 #include "napi/native_api.h"
19 #include "napi/native_engine/native_value.h"
20 #include "napi/native_node_api.h"
21
22 #include "base/log/log.h"
23 #include "bridge/common/plugin_adapter/plugin_bridge.h"
24
25 namespace OHOS::Ace::Napi {
26
27 struct CallbackContext {
28 napi_env env = nullptr;
29 napi_async_work work = nullptr;
30
31 napi_ref sucCallbackRef = nullptr;
32 napi_ref failCallbackRef = nullptr;
33 napi_ref cmpCallbackRef = nullptr;
34
35 napi_value infoList = nullptr;
36 bool status = 0;
37
~CallbackContextOHOS::Ace::Napi::CallbackContext38 ~CallbackContext()
39 {
40 if (sucCallbackRef) {
41 napi_delete_reference(env, sucCallbackRef);
42 }
43 if (failCallbackRef) {
44 napi_delete_reference(env, failCallbackRef);
45 }
46 if (cmpCallbackRef) {
47 napi_delete_reference(env, cmpCallbackRef);
48 }
49 }
50 };
51
JSGetInfo(napi_env env,napi_callback_info info)52 static napi_value JSGetInfo(napi_env env, napi_callback_info info)
53 {
54 size_t argc = 1;
55 napi_value argv[1] = { 0 };
56 napi_value thisVar = nullptr;
57 void* data = nullptr;
58 napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
59
60 napi_valuetype valueType = napi_undefined;
61 napi_typeof(env, argv[0], &valueType);
62 if (valueType != napi_object) {
63 LOGE("params is not object");
64 return nullptr;
65 }
66 napi_value successFunc;
67 napi_value failFunc;
68 napi_value cmpFunc;
69 auto asyncContext = new CallbackContext();
70 asyncContext->env = env;
71 napi_get_named_property(env, argv[0], "success", &successFunc);
72 napi_typeof(env, successFunc, &valueType);
73 if (valueType == napi_function) {
74 napi_create_reference(env, successFunc, 1, &asyncContext->sucCallbackRef);
75 }
76 napi_get_named_property(env, argv[0], "fail", &failFunc);
77 napi_typeof(env, failFunc, &valueType);
78 if (valueType == napi_function) {
79 napi_create_reference(env, failFunc, 1, &asyncContext->failCallbackRef);
80 }
81 napi_get_named_property(env, argv[0], "complete", &cmpFunc);
82 napi_typeof(env, cmpFunc, &valueType);
83 if (valueType == napi_function) {
84 napi_create_reference(env, cmpFunc, 1, &asyncContext->cmpCallbackRef);
85 }
86
87 if (asyncContext->sucCallbackRef == nullptr && asyncContext->failCallbackRef == nullptr &&
88 asyncContext->cmpCallbackRef == nullptr) {
89 LOGE("all callback is null");
90 delete asyncContext;
91 return nullptr;
92 }
93
94 napi_value resource = nullptr;
95 napi_create_string_utf8(env, "JSGetInfo", NAPI_AUTO_LENGTH, &resource);
96 napi_create_async_work(
97 env, nullptr, resource, [](napi_env env, void* data) {},
98 [](napi_env env, napi_status status, void* data) {
99 CallbackContext* asyncContext = (CallbackContext*)data;
100 auto getInfoRet = OHOS::Ace::Framework::PluginBridge::GetDeviceInfo();
101 napi_value globalValue;
102 napi_get_global(env, &globalValue);
103 napi_value jsonValue;
104 napi_get_named_property(env, globalValue, "JSON", &jsonValue);
105 napi_value parseValue;
106 napi_get_named_property(env, jsonValue, "parse", &parseValue);
107 napi_value info;
108 napi_create_string_utf8(env, getInfoRet.first.c_str(), NAPI_AUTO_LENGTH, &info);
109 napi_value funcArgv[1] = { info };
110 napi_value returnValue;
111 napi_call_function(env, jsonValue, parseValue, 1, funcArgv, &returnValue);
112 napi_valuetype valueType = napi_undefined;
113 napi_typeof(env, returnValue, &valueType);
114 if (valueType != napi_object) {
115 LOGE("parse result fail");
116 delete asyncContext;
117 return;
118 }
119 asyncContext->infoList = returnValue;
120 asyncContext->status = getInfoRet.second;
121
122 napi_value result[2] = { 0 };
123 result[0] = asyncContext->infoList;
124 napi_value code;
125 if (asyncContext->status && asyncContext->sucCallbackRef) {
126 napi_create_int32(env, 0, &code);
127 result[1] = code;
128 napi_value callback = nullptr;
129 napi_get_reference_value(env, asyncContext->sucCallbackRef, &callback);
130 napi_value ret;
131 napi_call_function(env, nullptr, callback, 2, result, &ret);
132 } else if (!asyncContext->status && asyncContext->failCallbackRef) {
133 napi_create_int32(env, 200, &code);
134 result[1] = code;
135 napi_value callback = nullptr;
136 napi_get_reference_value(env, asyncContext->failCallbackRef, &callback);
137 napi_value ret;
138 napi_call_function(env, nullptr, callback, 2, result, &ret);
139 }
140 if (asyncContext->cmpCallbackRef) {
141 napi_value callback = nullptr;
142 napi_get_reference_value(env, asyncContext->cmpCallbackRef, &callback);
143 napi_value ret;
144 napi_call_function(env, nullptr, callback, 0, nullptr, &ret);
145 }
146 napi_delete_async_work(env, asyncContext->work);
147 delete asyncContext;
148 },
149 (void*)asyncContext, &asyncContext->work);
150 napi_queue_async_work(env, asyncContext->work);
151
152 return nullptr;
153 }
154
DeviceExport(napi_env env,napi_value exports)155 static napi_value DeviceExport(napi_env env, napi_value exports)
156 {
157 napi_property_descriptor desc[] = {
158 DECLARE_NAPI_FUNCTION("getInfo", JSGetInfo),
159 };
160 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc));
161 return exports;
162 }
163
164 static napi_module deviceModule = {
165 .nm_version = 1,
166 .nm_flags = 0,
167 .nm_filename = nullptr,
168 .nm_register_func = DeviceExport,
169 .nm_modname = "device",
170 .nm_priv = ((void*)0),
171 .reserved = { 0 },
172 };
173
DeviceRegister()174 extern "C" __attribute__((constructor)) void DeviceRegister()
175 {
176 napi_module_register(&deviceModule);
177 }
178
179 } // namespace OHOS::Ace::Napi
180