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