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 #include <string>
17 #include <iosfwd>
18 #include <memory>
19
20 #include <napi/native_api.h>
21 #include <napi/native_common.h>
22
23 #include "new"
24 #include "node_api_types.h"
25 #include "js_native_api.h"
26 #include "js_native_api_types.h"
27
28 #include "power_state_machine_info.h"
29 #include "brightness.h"
30 #include "display_common.h"
31 #include "display_log.h"
32 #include "power_mgr_client.h"
33 #include "xpower_event_js.h"
34
35 using namespace OHOS::DisplayPowerMgr;
36 using namespace OHOS::PowerMgr;
37 namespace {
38 std::shared_ptr<RunningLock> runningLock =
39 PowerMgrClient::GetInstance().CreateRunningLock(std::string("KeepScreenOn"), RunningLockType::RUNNINGLOCK_SCREEN);
40 }
41
SyncWork(napi_env env,const std::string resName,const std::string valName,napi_callback_info & info,napi_async_complete_callback complete)42 static napi_value SyncWork(napi_env env, const std::string resName, const std::string valName,
43 napi_callback_info& info, napi_async_complete_callback complete)
44 {
45 napi_value undefined;
46 napi_get_undefined(env, &undefined);
47 std::unique_ptr<Brightness> asyncBrightness = std::make_unique<Brightness>(env);
48 RETURN_IF_WITH_RET(asyncBrightness == nullptr, undefined);
49 napi_value options = asyncBrightness->GetCallbackInfo(info, 0, napi_object);
50 RETURN_IF_WITH_RET(options == nullptr, undefined);
51 RETURN_IF_WITH_RET(!asyncBrightness->CreateCallbackRef(options), undefined);
52 if (!valName.empty()) {
53 asyncBrightness->CreateValueRef(options, valName, napi_number);
54 }
55
56 napi_value resource = nullptr;
57 NAPI_CALL(env, napi_create_string_utf8(env, resName.c_str(), NAPI_AUTO_LENGTH, &resource));
58 napi_create_async_work(
59 env,
60 nullptr,
61 resource,
62 [](napi_env env, void *data) {
63 DISPLAY_HILOGD(COMP_FWK, "async_work callback function is called");
64 },
65 complete,
66 reinterpret_cast<void*>(asyncBrightness.get()),
67 &asyncBrightness->asyncWork);
68 NAPI_CALL(env, napi_queue_async_work_with_qos(env, asyncBrightness->asyncWork, napi_qos_utility));
69 asyncBrightness.release();
70
71 return nullptr;
72 }
73
GetValue(napi_env env,napi_callback_info info)74 static napi_value GetValue(napi_env env, napi_callback_info info)
75 {
76 return SyncWork(
77 env,
78 "GetValue",
79 "",
80 info,
81 [](napi_env env, napi_status status, void *data) {
82 Brightness *asyncBrightness = reinterpret_cast<Brightness*>(data);
83 if (asyncBrightness != nullptr) {
84 asyncBrightness->GetValue();
85 napi_delete_async_work(env, asyncBrightness->asyncWork);
86 delete asyncBrightness;
87 }
88 }
89 );
90 }
91
SetValue(napi_env env,napi_callback_info info)92 static napi_value SetValue(napi_env env, napi_callback_info info)
93 {
94 napi_value res = SyncWork(
95 env,
96 "SetValue",
97 Brightness::BRIGHTNESS_VALUE,
98 info,
99 [](napi_env env, napi_status status, void *data) {
100 Brightness *asyncBrightness = reinterpret_cast<Brightness*>(data);
101 if (asyncBrightness != nullptr) {
102 asyncBrightness->SystemSetValue();
103 napi_delete_async_work(env, asyncBrightness->asyncWork);
104 delete asyncBrightness;
105 }
106 }
107 );
108 if (res != nullptr) {
109 Brightness brightness(env);
110 brightness.SetValue(info);
111 OHOS::HiviewDFX::ReportXPowerJsStackSysEvent(env, "Brightness::SetValue");
112 }
113 return nullptr;
114 }
115
GetMode(napi_env env,napi_callback_info info)116 static napi_value GetMode(napi_env env, napi_callback_info info)
117 {
118 return SyncWork(
119 env,
120 "GetMode",
121 "",
122 info,
123 [](napi_env env, napi_status status, void *data) {
124 Brightness *asyncBrightness = reinterpret_cast<Brightness*>(data);
125 if (asyncBrightness != nullptr) {
126 asyncBrightness->GetMode();
127 napi_delete_async_work(env, asyncBrightness->asyncWork);
128 delete asyncBrightness;
129 }
130 }
131 );
132 }
133
SetMode(napi_env env,napi_callback_info info)134 static napi_value SetMode(napi_env env, napi_callback_info info)
135 {
136 return SyncWork(
137 env,
138 "SetMode",
139 Brightness::BRIGHTNESS_MODE,
140 info,
141 [](napi_env env, napi_status status, void *data) {
142 Brightness *asyncBrightness = reinterpret_cast<Brightness*>(data);
143 if (asyncBrightness != nullptr) {
144 asyncBrightness->SetMode();
145 napi_delete_async_work(env, asyncBrightness->asyncWork);
146 delete asyncBrightness;
147 }
148 }
149 );
150 }
151
SetKeepScreenOn(napi_env env,napi_callback_info info)152 static napi_value SetKeepScreenOn(napi_env env, napi_callback_info info)
153 {
154 std::unique_ptr<Brightness> asyncBrightness = std::make_unique<Brightness>(env, runningLock);
155 RETURN_IF_WITH_RET(asyncBrightness == nullptr, nullptr);
156 napi_value options = asyncBrightness->GetCallbackInfo(info, 0, napi_object);
157 RETURN_IF_WITH_RET(options == nullptr, nullptr);
158 RETURN_IF_WITH_RET(!asyncBrightness->CreateCallbackRef(options), nullptr);
159 asyncBrightness->CreateValueRef(options, Brightness::KEEP_SCREENON, napi_boolean);
160
161 napi_value resource = nullptr;
162 NAPI_CALL(env, napi_create_string_utf8(env, "SetKeepScreenOn", NAPI_AUTO_LENGTH, &resource));
163 napi_create_async_work(
164 env,
165 nullptr,
166 resource,
167 [](napi_env env, void *data) {
168 DISPLAY_HILOGD(COMP_FWK, "async_work callback function is called");
169 },
170 [](napi_env env, napi_status status, void *data) {
171 Brightness *asyncBrightness = reinterpret_cast<Brightness*>(data);
172 if (asyncBrightness != nullptr) {
173 asyncBrightness->SetKeepScreenOn();
174 napi_delete_async_work(env, asyncBrightness->asyncWork);
175 delete asyncBrightness;
176 }
177 },
178 reinterpret_cast<void*>(asyncBrightness.get()),
179 &asyncBrightness->asyncWork);
180 NAPI_CALL(env, napi_queue_async_work_with_qos(env, asyncBrightness->asyncWork, napi_qos_utility));
181 asyncBrightness.release();
182
183 return nullptr;
184 }
185
186 EXTERN_C_START
Init(napi_env env,napi_value exports)187 static napi_value Init(napi_env env, napi_value exports)
188 {
189 DISPLAY_HILOGD(COMP_FWK, "brightness init");
190 napi_property_descriptor desc[] = {
191 DECLARE_NAPI_FUNCTION("getValue", GetValue),
192 DECLARE_NAPI_FUNCTION("setValue", SetValue),
193 DECLARE_NAPI_FUNCTION("getMode", GetMode),
194 DECLARE_NAPI_FUNCTION("setMode", SetMode),
195 DECLARE_NAPI_FUNCTION("setKeepScreenOn", SetKeepScreenOn)
196 };
197
198 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc));
199 DISPLAY_HILOGD(COMP_FWK, "brightness init end");
200 return exports;
201 }
202 EXTERN_C_END
203
204 static napi_module g_module = {
205 .nm_version = 1,
206 .nm_flags = 0,
207 .nm_filename = "brightness",
208 .nm_register_func = Init,
209 .nm_modname = "brightness",
210 .nm_priv = ((void *)0),
211 .reserved = { 0 }
212 };
213
RegisterModule(void)214 extern "C" __attribute__((constructor)) void RegisterModule(void)
215 {
216 napi_module_register(&g_module);
217 }
218