1 /*
2  * Copyright (c) 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 "js_screen_session_manager.h"
17 
18 #include <hitrace_meter.h>
19 #include <js_runtime_utils.h>
20 
21 #include "display_manager.h"
22 #include "interfaces/include/ws_common.h"
23 #include "js_screen_session.h"
24 #include "js_screen_utils.h"
25 #include "js_device_screen_config.h"
26 #include "pixel_map_napi.h"
27 #include "window_manager_hilog.h"
28 
29 #ifdef POWER_MANAGER_ENABLE
30 #include "shutdown/shutdown_client.h"
31 #include "shutdown/itakeover_shutdown_callback.h"
32 #endif
33 
34 namespace OHOS::Rosen {
35 using namespace AbilityRuntime;
36 constexpr size_t ARGC_TWO = 2;
37 constexpr size_t ARGC_THREE = 3;
38 
39 namespace {
40 constexpr HiviewDFX::HiLogLabel LABEL = { LOG_CORE, HILOG_DOMAIN_WINDOW, "JsScreenSessionManager" };
41 const std::string ON_SCREEN_CONNECTION_CHANGE_CALLBACK = "screenConnectChange";
42 } // namespace
43 
JsScreenSessionManager(napi_env env)44 JsScreenSessionManager::JsScreenSessionManager(napi_env env) : env_(env)
45 {
46     TLOGI(WmsLogTag::DMS, "Create JsScreenSessionManager instance");
47 }
48 
Init(napi_env env,napi_value exportObj)49 napi_value JsScreenSessionManager::Init(napi_env env, napi_value exportObj)
50 {
51     WLOGD("Init.");
52     if (env == nullptr || exportObj == nullptr) {
53         TLOGE(WmsLogTag::DMS, "Failed to init, env or exportObj is null!");
54         return nullptr;
55     }
56 
57     sptr<JsScreenSessionManager> jsScreenSessionManager = new (std::nothrow) JsScreenSessionManager(env);
58     if (jsScreenSessionManager == nullptr) {
59         TLOGE(WmsLogTag::DMS, "Failed to create, jsScreenSessionManager is null");
60         return nullptr;
61     }
62     jsScreenSessionManager->IncStrongRef(nullptr); // Avoid being released after the function ends
63     napi_wrap(env, exportObj, jsScreenSessionManager.GetRefPtr(), JsScreenSessionManager::Finalizer, nullptr, nullptr);
64 
65     napi_set_named_property(env, exportObj, "ScreenConnectChangeType",
66         JsScreenUtils::CreateJsScreenConnectChangeType(env));
67     napi_set_named_property(env, exportObj, "ScreenPropertyChangeReason",
68         JsScreenUtils::CreateJsScreenPropertyChangeReason(env));
69     napi_set_named_property(env, exportObj, "FoldStatus",
70         JsScreenUtils::CreateJsFoldStatus(env));
71     napi_set_named_property(env, exportObj, "ScreenPropertyChangeType",
72         JsScreenUtils::CreateJsScreenPropertyChangeType(env));
73 
74     const char* moduleName = "JsScreenSessionManager";
75     BindNativeFunction(env, exportObj, "on", moduleName, JsScreenSessionManager::RegisterCallback);
76     BindNativeFunction(env, exportObj, "updateScreenRotationProperty", moduleName,
77         JsScreenSessionManager::UpdateScreenRotationProperty);
78     BindNativeFunction(env, exportObj, "getCurvedScreenCompressionArea", moduleName,
79         JsScreenSessionManager::GetCurvedCompressionArea);
80     BindNativeFunction(env, exportObj, "registerShutdownCallback", moduleName,
81         JsScreenSessionManager::RegisterShutdownCallback);
82     BindNativeFunction(env, exportObj, "unRegisterShutdownCallback", moduleName,
83         JsScreenSessionManager::UnRegisterShutdownCallback);
84     BindNativeFunction(env, exportObj, "getPhyScreenProperty", moduleName,
85         JsScreenSessionManager::GetPhyScreenProperty);
86     BindNativeFunction(env, exportObj, "notifyScreenLockEvent", moduleName,
87         JsScreenSessionManager::NotifyScreenLockEvent);
88     BindNativeFunction(env, exportObj, "updateAvailableArea", moduleName,
89         JsScreenSessionManager::UpdateAvailableArea);
90     BindNativeFunction(env, exportObj, "setScreenOffDelayTime", moduleName,
91         JsScreenSessionManager::SetScreenOffDelayTime);
92     BindNativeFunction(env, exportObj, "notifyFoldToExpandCompletion", moduleName,
93         JsScreenSessionManager::NotifyFoldToExpandCompletion);
94     BindNativeFunction(env, exportObj, "getFoldStatus", moduleName, JsScreenSessionManager::GetFoldStatus);
95     BindNativeFunction(env, exportObj, "getScreenSnapshot", moduleName,
96         JsScreenSessionManager::GetScreenSnapshot);
97     BindNativeFunction(env, exportObj, "getDeviceScreenConfig", moduleName,
98         JsScreenSessionManager::GetDeviceScreenConfig);
99     BindNativeFunction(env, exportObj, "setCameraStatus", moduleName, JsScreenSessionManager::SetCameraStatus);
100     return NapiGetUndefined(env);
101 }
102 
~JsScreenSessionManager()103 JsScreenSessionManager::~JsScreenSessionManager()
104 {
105     TLOGI(WmsLogTag::DMS, "Destroy JsScreenSessionManager instance");
106 }
107 
Finalizer(napi_env env,void * data,void * hint)108 void JsScreenSessionManager::Finalizer(napi_env env, void* data, void* hint)
109 {
110     TLOGI(WmsLogTag::DMS, "[NAPI]Finalizer. jsScreenSessionManager refcount before DecStrongRef: %{public}d",
111         static_cast<JsScreenSessionManager*>(data)->GetSptrRefCount());
112     // Expected to release the jsScreenSessionManager object here
113     static_cast<JsScreenSessionManager*>(data)->DecStrongRef(data);
114 }
115 
RegisterCallback(napi_env env,napi_callback_info info)116 napi_value JsScreenSessionManager::RegisterCallback(napi_env env, napi_callback_info info)
117 {
118     WLOGD("[NAPI]RegisterCallback");
119     JsScreenSessionManager* me = CheckParamsAndGetThis<JsScreenSessionManager>(env, info);
120     return (me != nullptr) ? me->OnRegisterCallback(env, info) : nullptr;
121 }
122 
UpdateScreenRotationProperty(napi_env env,napi_callback_info info)123 napi_value JsScreenSessionManager::UpdateScreenRotationProperty(napi_env env, napi_callback_info info)
124 {
125     WLOGD("[NAPI]UpdateScreenRotationProperty");
126     JsScreenSessionManager* me = CheckParamsAndGetThis<JsScreenSessionManager>(env, info);
127     return (me != nullptr) ? me->OnUpdateScreenRotationProperty(env, info) : nullptr;
128 }
129 
GetCurvedCompressionArea(napi_env env,napi_callback_info info)130 napi_value JsScreenSessionManager::GetCurvedCompressionArea(napi_env env, napi_callback_info info)
131 {
132     WLOGD("[NAPI]GetCurvedCompressionArea");
133     JsScreenSessionManager* me = CheckParamsAndGetThis<JsScreenSessionManager>(env, info);
134     return (me != nullptr) ? me->OnGetCurvedCompressionArea(env, info) : nullptr;
135 }
136 
RegisterShutdownCallback(napi_env env,napi_callback_info info)137 napi_value JsScreenSessionManager::RegisterShutdownCallback(napi_env env, napi_callback_info info)
138 {
139     WLOGD("[NAPI]RegisterShutdownCallback");
140     JsScreenSessionManager* me = CheckParamsAndGetThis<JsScreenSessionManager>(env, info);
141     return (me != nullptr) ? me->OnRegisterShutdownCallback(env, info) : nullptr;
142 }
143 
UnRegisterShutdownCallback(napi_env env,napi_callback_info info)144 napi_value JsScreenSessionManager::UnRegisterShutdownCallback(napi_env env, napi_callback_info info)
145 {
146     WLOGD("[NAPI]UnRegisterShutdownCallback");
147     JsScreenSessionManager* me = CheckParamsAndGetThis<JsScreenSessionManager>(env, info);
148     return (me != nullptr) ? me->OnUnRegisterShutdownCallback(env, info) : nullptr;
149 }
150 
GetPhyScreenProperty(napi_env env,napi_callback_info info)151 napi_value JsScreenSessionManager::GetPhyScreenProperty(napi_env env, napi_callback_info info)
152 {
153     WLOGD("[NAPI]GetPhyScreenProperty");
154     JsScreenSessionManager* me = CheckParamsAndGetThis<JsScreenSessionManager>(env, info);
155     return (me != nullptr) ? me->OnGetPhyScreenProperty(env, info) : nullptr;
156 }
157 
NotifyScreenLockEvent(napi_env env,napi_callback_info info)158 napi_value JsScreenSessionManager::NotifyScreenLockEvent(napi_env env, napi_callback_info info)
159 {
160     WLOGD("[NAPI]NotifyScreenLockEvent");
161     JsScreenSessionManager* me = CheckParamsAndGetThis<JsScreenSessionManager>(env, info);
162     return (me != nullptr) ? me->OnNotifyScreenLockEvent(env, info) : nullptr;
163 }
164 
UpdateAvailableArea(napi_env env,napi_callback_info info)165 napi_value JsScreenSessionManager::UpdateAvailableArea(napi_env env, napi_callback_info info)
166 {
167     WLOGD("[NAPI]UpdateAvailableArea");
168     JsScreenSessionManager* me = CheckParamsAndGetThis<JsScreenSessionManager>(env, info);
169     return (me != nullptr) ? me->OnUpdateAvailableArea(env, info) : nullptr;
170 }
171 
SetScreenOffDelayTime(napi_env env,napi_callback_info info)172 napi_value JsScreenSessionManager::SetScreenOffDelayTime(napi_env env, napi_callback_info info)
173 {
174     WLOGD("[NAPI]SetScreenOffDelayTime");
175     JsScreenSessionManager* me = CheckParamsAndGetThis<JsScreenSessionManager>(env, info);
176     return (me != nullptr) ? me->OnSetScreenOffDelayTime(env, info) : nullptr;
177 }
178 
NotifyFoldToExpandCompletion(napi_env env,napi_callback_info info)179 napi_value JsScreenSessionManager::NotifyFoldToExpandCompletion(napi_env env, napi_callback_info info)
180 {
181     WLOGD("[NAPI]NotifyFoldToExpandCompletion");
182     JsScreenSessionManager* me = CheckParamsAndGetThis<JsScreenSessionManager>(env, info);
183     return (me != nullptr) ? me->OnNotifyFoldToExpandCompletion(env, info) : nullptr;
184 }
185 
GetFoldStatus(napi_env env,napi_callback_info info)186 napi_value JsScreenSessionManager::GetFoldStatus(napi_env env, napi_callback_info info)
187 {
188     WLOGD("[NAPI]GetFoldStatus");
189     JsScreenSessionManager* me = CheckParamsAndGetThis<JsScreenSessionManager>(env, info);
190     return (me != nullptr) ? me->OnGetFoldStatus(env, info) : nullptr;
191 }
192 
GetScreenSnapshot(napi_env env,napi_callback_info info)193 napi_value JsScreenSessionManager::GetScreenSnapshot(napi_env env, napi_callback_info info)
194 {
195     WLOGD("[NAPI]GetScreenSnapshot");
196     JsScreenSessionManager* me = CheckParamsAndGetThis<JsScreenSessionManager>(env, info);
197     return (me != nullptr) ? me->OnGetScreenSnapshot(env, info) : nullptr;
198 }
199 
GetDeviceScreenConfig(napi_env env,napi_callback_info info)200 napi_value JsScreenSessionManager::GetDeviceScreenConfig(napi_env env, napi_callback_info info)
201 {
202     TLOGD(WmsLogTag::DMS, "[NAPI]GetDeviceScreenConfig");
203     JsScreenSessionManager* me = CheckParamsAndGetThis<JsScreenSessionManager>(env, info);
204     return (me != nullptr) ? me->OnGetDeviceScreenConfig(env, info) : nullptr;
205 }
206 
OnScreenConnected(const sptr<ScreenSession> & screenSession)207 void JsScreenSessionManager::OnScreenConnected(const sptr<ScreenSession>& screenSession)
208 {
209     if (screenConnectionCallback_ == nullptr) {
210         WLOGE("[NAPI]screenConnectionCallback is nullptr");
211         return;
212     }
213     TLOGD(WmsLogTag::DMS, "[NAPI]OnScreenConnected");
214     std::shared_ptr<NativeReference> callback_ = screenConnectionCallback_;
215     auto asyncTask = [callback_, screenSession, env = env_]() {
216         HITRACE_METER_FMT(HITRACE_TAG_WINDOW_MANAGER, "JsScreenSessionManager::OnScreenConnected");
217         napi_value objValue = nullptr;
218         napi_create_object(env, &objValue);
219         if (objValue == nullptr) {
220             TLOGE(WmsLogTag::DMS, "Object is null!");
221             return;
222         }
223 
224         napi_set_named_property(env, objValue, "screenSession", JsScreenSession::Create(env, screenSession));
225         napi_set_named_property(env, objValue, "screenConnectChangeType", CreateJsValue(env, 0));
226 
227         napi_value argv[] = { objValue };
228         napi_value method = callback_->GetNapiValue();
229         if (method == nullptr) {
230             TLOGE(WmsLogTag::DMS, "Failed to get method callback from object!");
231             return;
232         }
233         napi_call_function(env, NapiGetUndefined(env), method, ArraySize(argv), argv, nullptr);
234     };
235     if (env_ != nullptr) {
236         napi_status ret = napi_send_event(env_, asyncTask, napi_eprio_vip);
237         if (ret != napi_status::napi_ok) {
238             WLOGFE("OnScreenConnected: Failed to SendEvent.");
239         }
240     } else {
241         WLOGFE("OnScreenConnected: env is nullptr");
242     }
243 }
244 
SetCameraStatus(napi_env env,napi_callback_info info)245 napi_value JsScreenSessionManager::SetCameraStatus(napi_env env, napi_callback_info info)
246 {
247     TLOGD(WmsLogTag::DMS, "[NAPI]SetCameraStatus");
248     JsScreenSessionManager* me = CheckParamsAndGetThis<JsScreenSessionManager>(env, info);
249     return (me != nullptr) ? me->OnSetCameraStatus(env, info) : nullptr;
250 }
251 
OnScreenDisconnected(const sptr<ScreenSession> & screenSession)252 void JsScreenSessionManager::OnScreenDisconnected(const sptr<ScreenSession>& screenSession)
253 {
254     if (screenConnectionCallback_ == nullptr) {
255         return;
256     }
257     TLOGD(WmsLogTag::DMS, "[NAPI]OnScreenDisconnected");
258     std::shared_ptr<NativeReference> callback_ = screenConnectionCallback_;
259     std::unique_ptr<NapiAsyncTask::CompleteCallback> complete = std::make_unique<NapiAsyncTask::CompleteCallback>(
260         [callback_, screenSession](napi_env env, NapiAsyncTask& task, int32_t status) {
261             napi_value objValue = nullptr;
262             napi_create_object(env, &objValue);
263             if (objValue == nullptr) {
264                 TLOGE(WmsLogTag::DMS, "Object is null!");
265                 return;
266             }
267 
268             napi_set_named_property(env, objValue, "screenSession", JsScreenSession::Create(env, screenSession));
269             napi_set_named_property(env, objValue, "screenConnectChangeType", CreateJsValue(env, 1));
270 
271             napi_value argv[] = { objValue };
272             napi_value method = callback_->GetNapiValue();
273             if (method == nullptr) {
274                 TLOGE(WmsLogTag::DMS, "Failed to get method callback from object!");
275                 return;
276             }
277             napi_call_function(env, NapiGetUndefined(env), method, ArraySize(argv), argv, nullptr);
278         });
279 
280     napi_ref callback = nullptr;
281     std::unique_ptr<NapiAsyncTask::ExecuteCallback> execute = nullptr;
282     NapiAsyncTask::Schedule("JsScreenSessionManager::OnScreenDisconnect", env_,
283         std::make_unique<NapiAsyncTask>(callback, std::move(execute), std::move(complete)));
284 }
285 
OnTakeOverShutdown(bool isReboot)286 bool JsScreenSessionManager::OnTakeOverShutdown(bool isReboot)
287 {
288     if (!shutdownCallback_) {
289         return false;
290     }
291     TLOGD(WmsLogTag::DMS, "[NAPI]OnTakeOverShutdown");
292     std::shared_ptr<NativeReference> callback_ = shutdownCallback_;
293     std::unique_ptr<NapiAsyncTask::CompleteCallback> complete = std::make_unique<NapiAsyncTask::CompleteCallback>(
294         [callback_, isReboot](napi_env env, NapiAsyncTask& task, int32_t status) {
295             napi_value argv[] = {CreateJsValue(env, isReboot)};
296             napi_value method = callback_->GetNapiValue();
297             if (method == nullptr) {
298                 TLOGE(WmsLogTag::DMS, "Failed to get method callback from object!");
299                 return;
300             }
301             napi_call_function(env, NapiGetUndefined(env), method, ArraySize(argv), argv, nullptr);
302         }
303     );
304     napi_ref callback = nullptr;
305     std::unique_ptr<NapiAsyncTask::ExecuteCallback> execute = nullptr;
306     NapiAsyncTask::Schedule("JsScreenSessionManager::OnTakeOverShutdown", env_,
307         std::make_unique<NapiAsyncTask>(callback, std::move(execute), std::move(complete)));
308     return true;
309 }
310 
OnRegisterShutdownCallback(napi_env env,const napi_callback_info info)311 napi_value JsScreenSessionManager::OnRegisterShutdownCallback(napi_env env, const napi_callback_info info)
312 {
313     TLOGI(WmsLogTag::DMS, "[NAPI]OnRegisterShutdownCallback");
314     if (shutdownCallback_ != nullptr) {
315         TLOGE(WmsLogTag::DMS, "Failed to register callback, callback exits");
316         napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_REPEAT_OPERATION)));
317         return NapiGetUndefined(env);
318     }
319     size_t argc = 4;
320     napi_value argv[4] = {nullptr};
321     napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
322     if (argc < 1) { // 1: params num
323         TLOGE(WmsLogTag::DMS, "[NAPI]Argc is invalid: %{public}zu", argc);
324         napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM)));
325         return NapiGetUndefined(env);
326     }
327     napi_value value = argv[0];
328     if (!NapiIsCallable(env, value)) {
329         TLOGE(WmsLogTag::DMS, "Failed to register callback, param is not callable");
330         napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM)));
331         return NapiGetUndefined(env);
332     }
333     napi_ref result = nullptr;
334     napi_create_reference(env, value, 1, &result);
335     std::shared_ptr<NativeReference> callbackRef(reinterpret_cast<NativeReference*>(result));
336     shutdownCallback_ = callbackRef;
337 #ifdef POWER_MANAGER_ENABLE
338     sptr<PowerMgr::ITakeOverShutdownCallback> callback(this);
339     PowerMgr::ShutdownClient::GetInstance().RegisterShutdownCallback(callback, PowerMgr::ShutdownPriority::LOW);
340 #else
341     WLOGFD("Can not find the sub system of PowerMgr");
342 #endif
343     return NapiGetUndefined(env);
344 }
345 
OnUnRegisterShutdownCallback(napi_env env,const napi_callback_info info)346 napi_value JsScreenSessionManager::OnUnRegisterShutdownCallback(napi_env env, const napi_callback_info info)
347 {
348     TLOGD(WmsLogTag::DMS, "[NAPI]OnUnRegisterShutdownCallback");
349     if (shutdownCallback_ == nullptr) {
350         TLOGE(WmsLogTag::DMS, "Failed to unregister callback, callback is not exits");
351         napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_NOT_REGISTER_SYNC_CALLBACK)));
352         return NapiGetUndefined(env);
353     }
354 #ifdef POWER_MANAGER_ENABLE
355     sptr<PowerMgr::ITakeOverShutdownCallback> callback(this);
356     PowerMgr::ShutdownClient::GetInstance().UnRegisterShutdownCallback(callback);
357 #else
358     WLOGFD("Can not find the sub system of PowerMgr");
359 #endif
360     shutdownCallback_ = nullptr;
361     return NapiGetUndefined(env);
362 }
363 
OnRegisterCallback(napi_env env,const napi_callback_info info)364 napi_value JsScreenSessionManager::OnRegisterCallback(napi_env env, const napi_callback_info info)
365 {
366     TLOGI(WmsLogTag::DMS, "[NAPI]OnRegisterCallback");
367     if (screenConnectionCallback_ != nullptr) {
368         return NapiGetUndefined(env);
369     }
370     size_t argc = 4;
371     napi_value argv[4] = {nullptr};
372     napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
373     if (argc < 2) { // 2: params num
374         TLOGE(WmsLogTag::DMS, "Argc is invalid: %{public}zu", argc);
375         napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM)));
376         return NapiGetUndefined(env);
377     }
378 
379     std::string callbackType;
380     if (!ConvertFromJsValue(env, argv[0], callbackType)) {
381         TLOGE(WmsLogTag::DMS, "Failed to convert parameter to callback type.");
382         napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM)));
383         return NapiGetUndefined(env);
384     }
385 
386     if (callbackType != ON_SCREEN_CONNECTION_CHANGE_CALLBACK) {
387         TLOGE(WmsLogTag::DMS, "Unsupported callback type: %{public}s.", callbackType.c_str());
388         napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM)));
389         return NapiGetUndefined(env);
390     }
391 
392     napi_value value = argv[1];
393     if (!NapiIsCallable(env, value)) {
394         TLOGE(WmsLogTag::DMS, "Failed to register callback, callback is not callable!");
395         napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM)));
396         return NapiGetUndefined(env);
397     }
398 
399     napi_ref result = nullptr;
400     napi_create_reference(env, value, 1, &result);
401     std::shared_ptr<NativeReference> callbackRef(reinterpret_cast<NativeReference*>(result));
402     screenConnectionCallback_ = callbackRef;
403     ScreenSessionManagerClient::GetInstance().RegisterScreenConnectionListener(this);
404     return NapiGetUndefined(env);
405 }
406 
OnUpdateScreenRotationProperty(napi_env env,const napi_callback_info info)407 napi_value JsScreenSessionManager::OnUpdateScreenRotationProperty(napi_env env,
408     const napi_callback_info info)
409 {
410     TLOGD(WmsLogTag::DMS, "[NAPI]OnUpdateScreenRotationProperty");
411     size_t argc = 4;
412     napi_value argv[4] = {nullptr};
413     napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
414     if (argc < ARGC_THREE) { // at least 3: params num
415         TLOGE(WmsLogTag::DMS, "[NAPI]Argc is invalid: %{public}zu", argc);
416         napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM),
417             "Input parameter is missing or invalid"));
418         return NapiGetUndefined(env);
419     }
420     int32_t screenId;
421     if (!ConvertFromJsValue(env, argv[0], screenId)) {
422         TLOGE(WmsLogTag::DMS, "[NAPI]Failed to convert parameter to screenId");
423         napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM),
424             "Input parameter is missing or invalid"));
425         return NapiGetUndefined(env);
426     }
427     RRect bounds;
428     napi_value nativeObj = argv[1];
429     if (nativeObj == nullptr) {
430         TLOGE(WmsLogTag::DMS, "[NAPI]Failed to convert object to RRect bounds");
431         return NapiGetUndefined(env);
432     } else if (!ConvertRRectFromJs(env, nativeObj, bounds)) {
433         TLOGE(WmsLogTag::DMS, "[NAPI]Failed to get bounds from js object");
434         return NapiGetUndefined(env);
435     }
436     ScreenDirectionInfo directionInfo;
437     napi_value nativeObject = argv[2];
438     if (nativeObject == nullptr) {
439         TLOGE(WmsLogTag::DMS, "[NAPI]Failed to convert parameter to ScreenDirectionInfo,the param is null");
440         return NapiGetUndefined(env);
441     }
442     if (!ConvertScreenDirectionInfoFromJs(env, nativeObject, directionInfo)) {
443         TLOGE(WmsLogTag::DMS, "[NAPI]Failed to convert parameter to ScreenDirectionInfo");
444         return NapiGetUndefined(env);
445     }
446     ScreenPropertyChangeType type = ScreenPropertyChangeType::UNSPECIFIED;
447     if (argc > ARGC_THREE) {
448         if (!ConvertFromJsValue(env, argv[ARGC_THREE], type) || type < ScreenPropertyChangeType::UNSPECIFIED ||
449             type > ScreenPropertyChangeType::ROTATION_UPDATE_PROPERTY_ONLY) { // 3: the 4rd argv
450             TLOGE(WmsLogTag::DMS, "[NAPI]screenPropertyChangeType is invalid");
451             napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM),
452                 "Input parameter is missing or invalid"));
453             return NapiGetUndefined(env);
454         }
455     }
456     ScreenSessionManagerClient::GetInstance().UpdateScreenRotationProperty(screenId, bounds, directionInfo, type);
457     return NapiGetUndefined(env);
458 }
459 
OnNotifyScreenLockEvent(napi_env env,const napi_callback_info info)460 napi_value JsScreenSessionManager::OnNotifyScreenLockEvent(napi_env env,
461     const napi_callback_info info)
462 {
463     TLOGI(WmsLogTag::DMS, "[NAPI]OnNotifyScreenLockEvent");
464     size_t argc = 4;
465     napi_value argv[4] = {nullptr};
466     napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
467     if (argc < 1) { // 1: params num
468         TLOGE(WmsLogTag::DMS, "[NAPI]Argc is invalid: %{public}zu", argc);
469         napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM),
470             "Input parameter is missing or invalid"));
471         return NapiGetUndefined(env);
472     }
473     int32_t event;
474     if (!ConvertFromJsValue(env, argv[0], event)) {
475         TLOGE(WmsLogTag::DMS, "[NAPI]Failed to convert parameter to display event");
476         napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM),
477             "Input parameter is missing or invalid"));
478         return NapiGetUndefined(env);
479     }
480 
481     DisplayManager::GetInstance().NotifyDisplayEvent(static_cast<DisplayEvent>(event));
482     return NapiGetUndefined(env);
483 }
484 
OnGetCurvedCompressionArea(napi_env env,const napi_callback_info info)485 napi_value JsScreenSessionManager::OnGetCurvedCompressionArea(napi_env env, const napi_callback_info info)
486 {
487     WLOGFD("[NAPI]OnGetCurvedCompressionArea");
488     napi_value result = nullptr;
489     napi_create_uint32(env, ScreenSessionManagerClient::GetInstance().GetCurvedCompressionArea(), &result);
490     return result;
491 }
492 
OnGetPhyScreenProperty(napi_env env,const napi_callback_info info)493 napi_value JsScreenSessionManager::OnGetPhyScreenProperty(napi_env env, const napi_callback_info info)
494 {
495     WLOGFD("[NAPI]OnGetPhyScreenProperty");
496     size_t argc = 4;
497     napi_value argv[4] = {nullptr};
498     napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
499     if (argc < 1) { // 1: params num
500         TLOGE(WmsLogTag::DMS, "[NAPI]Argc is invalid: %{public}zu", argc);
501         napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM),
502             "Input parameter is missing or invalid"));
503         return NapiGetUndefined(env);
504     }
505     int32_t screenId;
506     if (!ConvertFromJsValue(env, argv[0], screenId)) {
507         TLOGE(WmsLogTag::DMS, "[NAPI]Failed to convert parameter to screenId");
508         napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM),
509             "Input parameter is missing or invalid"));
510         return NapiGetUndefined(env);
511     }
512     ScreenProperty screenProperty = ScreenSessionManagerClient::GetInstance().GetPhyScreenProperty(screenId);
513     return JsScreenUtils::CreateJsScreenProperty(env, screenProperty);
514 }
515 
OnUpdateAvailableArea(napi_env env,const napi_callback_info info)516 napi_value JsScreenSessionManager::OnUpdateAvailableArea(napi_env env, const napi_callback_info info)
517 {
518     WLOGFD("[NAPI]OnUpdateAvailableArea");
519     size_t argc = 4;
520     napi_value argv[4] = {nullptr};
521     napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
522     if (argc < 1) { // 1: params num
523         TLOGE(WmsLogTag::DMS, "[NAPI]Argc is invalid: %{public}zu", argc);
524         napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM),
525             "Input parameter is missing or invalid"));
526         return NapiGetUndefined(env);
527     }
528     int32_t screenId;
529     if (!ConvertFromJsValue(env, argv[0], screenId)) {
530         TLOGE(WmsLogTag::DMS, "[NAPI]Failed to convert parameter to screenId");
531         napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM),
532             "Input parameter is missing or invalid"));
533         return NapiGetUndefined(env);
534     }
535     DMRect area;
536     napi_value nativeObj = argv[1];
537     if (nativeObj == nullptr) {
538         TLOGE(WmsLogTag::DMS, "[NAPI]Failed to convert parameter to DMRect,the param is null");
539         return NapiGetUndefined(env);
540     } else if (!ConvertDMRectFromJs(env, nativeObj, area)) {
541         TLOGE(WmsLogTag::DMS, "[NAPI]Failed to convert parameter to DMRect");
542         return NapiGetUndefined(env);
543     }
544     ScreenSessionManagerClient::GetInstance().UpdateAvailableArea(screenId, area);
545     return NapiGetUndefined(env);
546 }
547 
OnSetScreenOffDelayTime(napi_env env,const napi_callback_info info)548 napi_value JsScreenSessionManager::OnSetScreenOffDelayTime(napi_env env, const napi_callback_info info)
549 {
550     WLOGFD("[NAPI]OnSetScreenOffDelayTime");
551     size_t argc = 1;
552     napi_handle_scope scope = nullptr;
553     napi_open_handle_scope(env, &scope);
554     napi_value argv[1] = {nullptr};
555     napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
556     if (argc < 1) { // 1: params num
557         TLOGE(WmsLogTag::DMS, "[NAPI]Argc is invalid: %{public}zu", argc);
558         napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM),
559             "Input parameter is missing or invalid"));
560         napi_close_handle_scope(env, scope);
561         return NapiGetUndefined(env);
562     }
563     int32_t delay;
564     if (!ConvertFromJsValue(env, argv[0], delay)) {
565         TLOGE(WmsLogTag::DMS, "[NAPI]Failed to convert parameter to delay");
566         napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM),
567             "Input parameter is missing or invalid"));
568         napi_close_handle_scope(env, scope);
569         return NapiGetUndefined(env);
570     }
571     ScreenSessionManagerClient::GetInstance().SetScreenOffDelayTime(delay);
572     napi_close_handle_scope(env, scope);
573     return NapiGetUndefined(env);
574 }
575 
OnNotifyFoldToExpandCompletion(napi_env env,const napi_callback_info info)576 napi_value JsScreenSessionManager::OnNotifyFoldToExpandCompletion(napi_env env, const napi_callback_info info)
577 {
578     WLOGFD("[NAPI]OnNotifyFoldToExpandCompletion");
579     size_t argc = 4;
580     napi_value argv[4] = {nullptr};
581     napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
582     if (argc < 1) { // 1: params num
583         TLOGE(WmsLogTag::DMS, "[NAPI]Argc is invalid: %{public}zu", argc);
584         napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM),
585             "Input parameter is missing or invalid"));
586         return NapiGetUndefined(env);
587     }
588     bool foldToExpand;
589     if (!ConvertFromJsValue(env, argv[0], foldToExpand)) {
590         TLOGE(WmsLogTag::DMS, "[NAPI]Failed to convert parameter to foldToExpand");
591         napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM),
592             "Input parameter is missing or invalid"));
593         return NapiGetUndefined(env);
594     }
595     ScreenSessionManagerClient::GetInstance().NotifyFoldToExpandCompletion(foldToExpand);
596     return NapiGetUndefined(env);
597 }
598 
OnGetFoldStatus(napi_env env,napi_callback_info info)599 napi_value JsScreenSessionManager::OnGetFoldStatus(napi_env env, napi_callback_info info)
600 {
601     WLOGFD("[NAPI]OnGetFoldStatus");
602     size_t argc = 4;
603     napi_value argv[4] = {nullptr};
604     napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
605     if (argc >= 1) {
606         napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM)));
607         return NapiGetUndefined(env);
608     }
609     FoldStatus status = ScreenSessionManagerClient::GetInstance().GetFoldStatus();
610     WLOGI("[NAPI]" PRIu64", getFoldStatus = %{public}u", status);
611     return CreateJsValue(env, status);
612 }
613 
OnGetScreenSnapshot(napi_env env,const napi_callback_info info)614 napi_value JsScreenSessionManager::OnGetScreenSnapshot(napi_env env, const napi_callback_info info)
615 {
616     WLOGFD("[NAPI]OnGetScreenSnapshot");
617     size_t argc = 4;
618     napi_value argv[4] = {nullptr};
619     napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
620     if (argc < ARGC_THREE) {
621         TLOGE(WmsLogTag::DMS, "[NAPI]Argc is invalid: %{public}zu", argc);
622         napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM),
623             "Input parameter is missing or invalid"));
624         return NapiGetUndefined(env);
625     }
626     int32_t screenId;
627     if (!ConvertFromJsValue(env, argv[0], screenId)) {
628         TLOGE(WmsLogTag::DMS, "[NAPI]Failed to convert parameter to screenId");
629         napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM),
630             "Input parameter is missing or invalid"));
631         return NapiGetUndefined(env);
632     }
633     std::array<double, ARGC_TWO> scaleParam;
634     for (uint8_t i = 0; i < ARGC_TWO; i++) {
635         if (!ConvertFromJsValue(env, argv[i + 1], scaleParam[i])) {
636             TLOGE(WmsLogTag::DMS, "[NAPI]Failed to convert parameter to scale[%d]", i + 1);
637             napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM),
638                 "Input parameter is missing or invalid"));
639             return NapiGetUndefined(env);
640         }
641         scaleParam[i] = (scaleParam[i] > 0.0 && scaleParam[i] < 1.0) ? scaleParam[i] : 1.0;
642     }
643     napi_value nativeData = nullptr;
644     auto pixelMap = ScreenSessionManagerClient::GetInstance().GetScreenSnapshot(screenId,
645         static_cast<float>(scaleParam[0]), static_cast<float>(scaleParam[1]));
646     if (pixelMap == nullptr) {
647         WLOGE("[NAPI]pixelMap is nullptr");
648         return nativeData;
649     }
650     nativeData = Media::PixelMapNapi::CreatePixelMap(env, pixelMap);
651     if (nativeData != nullptr) {
652         WLOGD("[NAPI]pixelmap W x H = %{public}d x %{public}d", pixelMap->GetWidth(), pixelMap->GetHeight());
653     } else {
654         WLOGE("[NAPI]create native pixelmap failed");
655     }
656     return nativeData;
657 }
658 
OnGetDeviceScreenConfig(napi_env env,const napi_callback_info info)659 napi_value JsScreenSessionManager::OnGetDeviceScreenConfig(napi_env env, const napi_callback_info info)
660 {
661     TLOGD(WmsLogTag::DMS, "[NAPI]OnGetDeviceScreenConfig");
662     DeviceScreenConfig deviceScreenConfig = ScreenSessionManagerClient::GetInstance().GetDeviceScreenConfig();
663     napi_value jsDeviceScreenConfigObj = JsDeviceScreenConfig::CreateDeviceScreenConfig(env, deviceScreenConfig);
664     if (jsDeviceScreenConfigObj == nullptr) {
665         TLOGE(WmsLogTag::DMS, "[NAPI]jsDeviceScreenConfigObj is nullptr");
666         napi_throw(env, CreateJsError(env,
667             static_cast<int32_t>(WSErrorCode::WS_ERROR_STATE_ABNORMALLY), "System is abnormal"));
668     }
669     return jsDeviceScreenConfigObj;
670 }
671 
OnSetCameraStatus(napi_env env,const napi_callback_info info)672 napi_value JsScreenSessionManager::OnSetCameraStatus(napi_env env, const napi_callback_info info)
673 {
674     WLOGFD("[NAPI]OnSetCameraStatus");
675     size_t argc = 2;
676     napi_handle_scope scope = nullptr;
677     napi_open_handle_scope(env, &scope);
678     napi_value argv[2] = {nullptr, nullptr};
679     napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
680     if (argc < 2) { // 2: params num
681         TLOGE(WmsLogTag::DMS, "[NAPI]Argc is invalid: %{public}zu", argc);
682         napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM),
683             "Input parameter is missing or invalid"));
684         napi_close_handle_scope(env, scope);
685         return NapiGetUndefined(env);
686     }
687     int32_t cameraStatus;
688     int32_t cameraPosition;
689     if (!ConvertFromJsValue(env, argv[0], cameraStatus)) {
690         TLOGE(WmsLogTag::DMS, "[NAPI]Failed to convert parameter to cameraStatus");
691         napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM),
692             "Input parameter is missing or invalid"));
693         napi_close_handle_scope(env, scope);
694         return NapiGetUndefined(env);
695     }
696     if (!ConvertFromJsValue(env, argv[1], cameraPosition)) {
697         TLOGE(WmsLogTag::DMS, "[NAPI]Failed to convert parameter to cameraPosition");
698         napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM),
699             "Input parameter is missing or invalid"));
700         napi_close_handle_scope(env, scope);
701         return NapiGetUndefined(env);
702     }
703     ScreenSessionManagerClient::GetInstance().SetCameraStatus(cameraStatus, cameraPosition);
704     napi_close_handle_scope(env, scope);
705     return NapiGetUndefined(env);
706 }
707 } // namespace OHOS::Rosen
708