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_scene_utils.h" 17 #include "js_scene_session.h" 18 19 #include "pixel_map_napi.h" 20 #include "session/host/include/session.h" 21 #include "session_manager/include/scene_session_manager.h" 22 #include "window_manager_hilog.h" 23 #include "common/include/session_permission.h" 24 25 namespace OHOS::Rosen { 26 using namespace AbilityRuntime; 27 namespace { 28 constexpr HiviewDFX::HiLogLabel LABEL = { LOG_CORE, HILOG_DOMAIN_WINDOW, "JsSceneSession" }; 29 const std::string PENDING_SCENE_CB = "pendingSceneSessionActivation"; 30 const std::string CHANGE_SESSION_VISIBILITY_WITH_STATUS_BAR = "changeSessionVisibilityWithStatusBar"; 31 const std::string SESSION_STATE_CHANGE_CB = "sessionStateChange"; 32 const std::string BUFFER_AVAILABLE_CHANGE_CB = "bufferAvailableChange"; 33 const std::string SESSION_EVENT_CB = "sessionEvent"; 34 const std::string SESSION_RECT_CHANGE_CB = "sessionRectChange"; 35 const std::string SESSION_PIP_CONTROL_STATUS_CHANGE_CB = "sessionPiPControlStatusChange"; 36 const std::string SESSION_AUTO_START_PIP_CB = "autoStartPiP"; 37 const std::string CREATE_SUB_SESSION_CB = "createSpecificSession"; 38 const std::string BIND_DIALOG_TARGET_CB = "bindDialogTarget"; 39 const std::string RAISE_TO_TOP_CB = "raiseToTop"; 40 const std::string RAISE_TO_TOP_POINT_DOWN_CB = "raiseToTopForPointDown"; 41 const std::string BACK_PRESSED_CB = "backPressed"; 42 const std::string SESSION_FOCUSABLE_CHANGE_CB = "sessionFocusableChange"; 43 const std::string SESSION_TOUCHABLE_CHANGE_CB = "sessionTouchableChange"; 44 const std::string SESSION_TOP_MOST_CHANGE_CB = "sessionTopmostChange"; 45 const std::string SUB_MODAL_TYPE_CHANGE_CB = "subModalTypeChange"; 46 const std::string MAIN_MODAL_TYPE_CHANGE_CB = "mainModalTypeChange"; 47 const std::string CLICK_CB = "click"; 48 const std::string TERMINATE_SESSION_CB = "terminateSession"; 49 const std::string TERMINATE_SESSION_CB_NEW = "terminateSessionNew"; 50 const std::string TERMINATE_SESSION_CB_TOTAL = "terminateSessionTotal"; 51 const std::string UPDATE_SESSION_LABEL_CB = "updateSessionLabel"; 52 const std::string UPDATE_SESSION_ICON_CB = "updateSessionIcon"; 53 const std::string SESSION_EXCEPTION_CB = "sessionException"; 54 const std::string SYSTEMBAR_PROPERTY_CHANGE_CB = "systemBarPropertyChange"; 55 const std::string NEED_AVOID_CB = "needAvoid"; 56 const std::string PENDING_SESSION_TO_FOREGROUND_CB = "pendingSessionToForeground"; 57 const std::string PENDING_SESSION_TO_BACKGROUND_FOR_DELEGATOR_CB = "pendingSessionToBackgroundForDelegator"; 58 const std::string CUSTOM_ANIMATION_PLAYING_CB = "isCustomAnimationPlaying"; 59 const std::string NEED_DEFAULT_ANIMATION_FLAG_CHANGE_CB = "needDefaultAnimationFlagChange"; 60 const std::string SHOW_WHEN_LOCKED_CB = "sessionShowWhenLockedChange"; 61 const std::string REQUESTED_ORIENTATION_CHANGE_CB = "sessionRequestedOrientationChange"; 62 const std::string RAISE_ABOVE_TARGET_CB = "raiseAboveTarget"; 63 const std::string FORCE_HIDE_CHANGE_CB = "sessionForceHideChange"; 64 const std::string WINDOW_DRAG_HOT_AREA_CB = "windowDragHotArea"; 65 const std::string TOUCH_OUTSIDE_CB = "touchOutside"; 66 const std::string SESSIONINFO_LOCKEDSTATE_CHANGE_CB = "sessionInfoLockedStateChange"; 67 const std::string PREPARE_CLOSE_PIP_SESSION = "prepareClosePiPSession"; 68 const std::string LANDSCAPE_MULTI_WINDOW_CB = "landscapeMultiWindow"; 69 const std::string CONTEXT_TRANSPARENT_CB = "contextTransparent"; 70 const std::string KEYBOARD_GRAVITY_CHANGE_CB = "keyboardGravityChange"; 71 const std::string ADJUST_KEYBOARD_LAYOUT_CB = "adjustKeyboardLayout"; 72 const std::string LAYOUT_FULL_SCREEN_CB = "layoutFullScreenChange"; 73 const std::string DEFAULT_DENSITY_ENABLED_CB = "defaultDensityEnabled"; 74 const std::string TITLE_DOCK_HOVER_SHOW_CB = "titleAndDockHoverShowChange"; 75 const std::string NEXT_FRAME_LAYOUT_FINISH_CB = "nextFrameLayoutFinish"; 76 const std::string MAIN_WINDOW_TOP_MOST_CHANGE_CB = "mainWindowTopmostChange"; 77 const std::string SET_WINDOW_RECT_AUTO_SAVE_CB = "setWindowRectAutoSave"; 78 const std::string UPDATE_APP_USE_CONTROL_CB = "updateAppUseControl"; 79 const std::string RESTORE_MAIN_WINDOW_CB = "restoreMainWindow"; 80 constexpr int ARG_COUNT_3 = 3; 81 constexpr int ARG_COUNT_4 = 4; 82 constexpr int ARG_INDEX_0 = 0; 83 constexpr int ARG_INDEX_1 = 1; 84 constexpr int ARG_INDEX_2 = 2; 85 constexpr int ARG_INDEX_3 = 3; 86 87 const std::map<std::string, ListenerFuncType> ListenerFuncMap { 88 {PENDING_SCENE_CB, ListenerFuncType::PENDING_SCENE_CB}, 89 {CHANGE_SESSION_VISIBILITY_WITH_STATUS_BAR, 90 ListenerFuncType::CHANGE_SESSION_VISIBILITY_WITH_STATUS_BAR}, 91 {SESSION_STATE_CHANGE_CB, ListenerFuncType::SESSION_STATE_CHANGE_CB}, 92 {BUFFER_AVAILABLE_CHANGE_CB, ListenerFuncType::BUFFER_AVAILABLE_CHANGE_CB}, 93 {SESSION_EVENT_CB, ListenerFuncType::SESSION_EVENT_CB}, 94 {SESSION_RECT_CHANGE_CB, ListenerFuncType::SESSION_RECT_CHANGE_CB}, 95 {SESSION_PIP_CONTROL_STATUS_CHANGE_CB, ListenerFuncType::SESSION_PIP_CONTROL_STATUS_CHANGE_CB}, 96 {SESSION_AUTO_START_PIP_CB, ListenerFuncType::SESSION_AUTO_START_PIP_CB}, 97 {CREATE_SUB_SESSION_CB, ListenerFuncType::CREATE_SUB_SESSION_CB}, 98 {BIND_DIALOG_TARGET_CB, ListenerFuncType::BIND_DIALOG_TARGET_CB}, 99 {RAISE_TO_TOP_CB, ListenerFuncType::RAISE_TO_TOP_CB}, 100 {RAISE_TO_TOP_POINT_DOWN_CB, ListenerFuncType::RAISE_TO_TOP_POINT_DOWN_CB}, 101 {BACK_PRESSED_CB, ListenerFuncType::BACK_PRESSED_CB}, 102 {SESSION_FOCUSABLE_CHANGE_CB, ListenerFuncType::SESSION_FOCUSABLE_CHANGE_CB}, 103 {SESSION_TOUCHABLE_CHANGE_CB, ListenerFuncType::SESSION_TOUCHABLE_CHANGE_CB}, 104 {SESSION_TOP_MOST_CHANGE_CB, ListenerFuncType::SESSION_TOP_MOST_CHANGE_CB}, 105 {SUB_MODAL_TYPE_CHANGE_CB, ListenerFuncType::SUB_MODAL_TYPE_CHANGE_CB}, 106 {MAIN_MODAL_TYPE_CHANGE_CB, ListenerFuncType::MAIN_MODAL_TYPE_CHANGE_CB}, 107 {CLICK_CB, ListenerFuncType::CLICK_CB}, 108 {TERMINATE_SESSION_CB, ListenerFuncType::TERMINATE_SESSION_CB}, 109 {TERMINATE_SESSION_CB_NEW, ListenerFuncType::TERMINATE_SESSION_CB_NEW}, 110 {TERMINATE_SESSION_CB_TOTAL, ListenerFuncType::TERMINATE_SESSION_CB_TOTAL}, 111 {SESSION_EXCEPTION_CB, ListenerFuncType::SESSION_EXCEPTION_CB}, 112 {UPDATE_SESSION_LABEL_CB, ListenerFuncType::UPDATE_SESSION_LABEL_CB}, 113 {UPDATE_SESSION_ICON_CB, ListenerFuncType::UPDATE_SESSION_ICON_CB}, 114 {SYSTEMBAR_PROPERTY_CHANGE_CB, ListenerFuncType::SYSTEMBAR_PROPERTY_CHANGE_CB}, 115 {NEED_AVOID_CB, ListenerFuncType::NEED_AVOID_CB}, 116 {PENDING_SESSION_TO_FOREGROUND_CB, ListenerFuncType::PENDING_SESSION_TO_FOREGROUND_CB}, 117 {PENDING_SESSION_TO_BACKGROUND_FOR_DELEGATOR_CB, 118 ListenerFuncType::PENDING_SESSION_TO_BACKGROUND_FOR_DELEGATOR_CB}, 119 {CUSTOM_ANIMATION_PLAYING_CB, ListenerFuncType::CUSTOM_ANIMATION_PLAYING_CB}, 120 {NEED_DEFAULT_ANIMATION_FLAG_CHANGE_CB, ListenerFuncType::NEED_DEFAULT_ANIMATION_FLAG_CHANGE_CB}, 121 {SHOW_WHEN_LOCKED_CB, ListenerFuncType::SHOW_WHEN_LOCKED_CB}, 122 {REQUESTED_ORIENTATION_CHANGE_CB, ListenerFuncType::REQUESTED_ORIENTATION_CHANGE_CB}, 123 {RAISE_ABOVE_TARGET_CB, ListenerFuncType::RAISE_ABOVE_TARGET_CB}, 124 {FORCE_HIDE_CHANGE_CB, ListenerFuncType::FORCE_HIDE_CHANGE_CB}, 125 {WINDOW_DRAG_HOT_AREA_CB, ListenerFuncType::WINDOW_DRAG_HOT_AREA_CB}, 126 {TOUCH_OUTSIDE_CB, ListenerFuncType::TOUCH_OUTSIDE_CB}, 127 {SESSIONINFO_LOCKEDSTATE_CHANGE_CB, ListenerFuncType::SESSIONINFO_LOCKEDSTATE_CHANGE_CB}, 128 {PREPARE_CLOSE_PIP_SESSION, ListenerFuncType::PREPARE_CLOSE_PIP_SESSION}, 129 {LANDSCAPE_MULTI_WINDOW_CB, ListenerFuncType::LANDSCAPE_MULTI_WINDOW_CB}, 130 {CONTEXT_TRANSPARENT_CB, ListenerFuncType::CONTEXT_TRANSPARENT_CB}, 131 {KEYBOARD_GRAVITY_CHANGE_CB, ListenerFuncType::KEYBOARD_GRAVITY_CHANGE_CB}, 132 {ADJUST_KEYBOARD_LAYOUT_CB, ListenerFuncType::ADJUST_KEYBOARD_LAYOUT_CB}, 133 {LAYOUT_FULL_SCREEN_CB, ListenerFuncType::LAYOUT_FULL_SCREEN_CB}, 134 {DEFAULT_DENSITY_ENABLED_CB, ListenerFuncType::DEFAULT_DENSITY_ENABLED_CB}, 135 {TITLE_DOCK_HOVER_SHOW_CB, ListenerFuncType::TITLE_DOCK_HOVER_SHOW_CB}, 136 {NEXT_FRAME_LAYOUT_FINISH_CB, ListenerFuncType::NEXT_FRAME_LAYOUT_FINISH_CB}, 137 {MAIN_WINDOW_TOP_MOST_CHANGE_CB, ListenerFuncType::MAIN_WINDOW_TOP_MOST_CHANGE_CB}, 138 {SET_WINDOW_RECT_AUTO_SAVE_CB, ListenerFuncType::SET_WINDOW_RECT_AUTO_SAVE_CB}, 139 {UPDATE_APP_USE_CONTROL_CB, ListenerFuncType::UPDATE_APP_USE_CONTROL_CB}, 140 {RESTORE_MAIN_WINDOW_CB, ListenerFuncType::RESTORE_MAIN_WINDOW_CB}, 141 }; 142 143 const std::vector<std::string> g_syncGlobalPositionPermission { 144 "Recent", 145 }; 146 } // namespace 147 148 std::map<int32_t, napi_ref> JsSceneSession::jsSceneSessionMap_; 149 CreateJsPiPControlStatusObject(napi_env env,PiPControlStatusInfo controlStatusInfo)150 napi_value CreateJsPiPControlStatusObject(napi_env env, PiPControlStatusInfo controlStatusInfo) 151 { 152 TLOGI(WmsLogTag::WMS_PIP, "called"); 153 napi_value objValue = nullptr; 154 napi_create_object(env, &objValue); 155 if (objValue == nullptr) { 156 TLOGE(WmsLogTag::WMS_PIP, "objValue is nullptr"); 157 return NapiGetUndefined(env); 158 } 159 uint32_t controlType = static_cast<uint32_t>(controlStatusInfo.controlType); 160 int32_t status = static_cast<int32_t>(controlStatusInfo.status); 161 napi_set_named_property(env, objValue, "controlType", CreateJsValue(env, controlType)); 162 napi_set_named_property(env, objValue, "status", CreateJsValue(env, status)); 163 return objValue; 164 } 165 CreateJsPiPControlEnableObject(napi_env env,PiPControlEnableInfo controlEnableInfo)166 napi_value CreateJsPiPControlEnableObject(napi_env env, PiPControlEnableInfo controlEnableInfo) 167 { 168 TLOGI(WmsLogTag::WMS_PIP, "called"); 169 napi_value objValue = nullptr; 170 napi_create_object(env, &objValue); 171 if (objValue == nullptr) { 172 TLOGE(WmsLogTag::WMS_PIP, "objValue is nullptr"); 173 return NapiGetUndefined(env); 174 } 175 uint32_t controlType = static_cast<uint32_t>(controlEnableInfo.controlType); 176 int32_t enabled = static_cast<int32_t>(controlEnableInfo.enabled); 177 napi_set_named_property(env, objValue, "controlType", CreateJsValue(env, controlType)); 178 napi_set_named_property(env, objValue, "enabled", CreateJsValue(env, enabled)); 179 return objValue; 180 } 181 CreatePipTemplateInfo(napi_env env,const sptr<SceneSession> & session)182 static napi_value CreatePipTemplateInfo(napi_env env, const sptr<SceneSession>& session) 183 { 184 TLOGI(WmsLogTag::WMS_PIP, "called"); 185 napi_value pipTemplateInfoValue = nullptr; 186 napi_create_object(env, &pipTemplateInfoValue); 187 napi_set_named_property(env, pipTemplateInfoValue, "pipTemplateType", 188 CreateJsValue(env, session->GetPiPTemplateInfo().pipTemplateType)); 189 napi_set_named_property(env, pipTemplateInfoValue, "priority", 190 CreateJsValue(env, session->GetPiPTemplateInfo().priority)); 191 napi_value controlArrayValue = nullptr; 192 std::vector<std::uint32_t> controlGroups = session->GetPiPTemplateInfo().controlGroup; 193 napi_create_array_with_length(env, controlGroups.size(), &controlArrayValue); 194 auto index = 0; 195 for (const auto& controlGroup : controlGroups) { 196 napi_set_element(env, controlArrayValue, index++, CreateJsValue(env, controlGroup)); 197 } 198 napi_set_named_property(env, pipTemplateInfoValue, "controlGroup", controlArrayValue); 199 napi_value controlStatusArrayValue = nullptr; 200 std::vector<PiPControlStatusInfo> controlStatusInfoList = session->GetPiPTemplateInfo().pipControlStatusInfoList; 201 napi_create_array_with_length(env, controlStatusInfoList.size(), &controlStatusArrayValue); 202 auto controlStatusIndex = 0; 203 for (const auto& controlStatus : controlStatusInfoList) { 204 napi_set_element(env, controlStatusArrayValue, controlStatusIndex++, 205 CreateJsPiPControlStatusObject(env, controlStatus)); 206 } 207 napi_set_named_property(env, pipTemplateInfoValue, "pipControlStatusInfoList", controlStatusArrayValue); 208 napi_value controlEnableArrayValue = nullptr; 209 std::vector<PiPControlEnableInfo> controlEnableInfoList = session->GetPiPTemplateInfo().pipControlEnableInfoList; 210 napi_create_array_with_length(env, controlEnableInfoList.size(), &controlEnableArrayValue); 211 auto controlEnableIndex = 0; 212 for (const auto& controlEnableInfo : controlEnableInfoList) { 213 napi_set_element(env, controlEnableArrayValue, controlEnableIndex++, 214 CreateJsPiPControlEnableObject(env, controlEnableInfo)); 215 } 216 napi_set_named_property(env, pipTemplateInfoValue, "pipControlEnableInfoList", controlEnableArrayValue); 217 return pipTemplateInfoValue; 218 } 219 SetWindowSizeAndPosition(napi_env env,napi_value objValue,const sptr<SceneSession> & session)220 static void SetWindowSizeAndPosition(napi_env env, napi_value objValue, const sptr<SceneSession>& session) 221 { 222 auto abilityInfo = session->GetSessionInfo().abilityInfo; 223 if (!abilityInfo) { 224 TLOGW(WmsLogTag::WMS_LAYOUT, "abilityInfo is nullptr"); 225 return; 226 } 227 uint32_t value = 0; 228 for (const auto& item : abilityInfo->metadata) { 229 if (item.name == "ohos.ability.window.width") { 230 if (GetIntValueFromString(item.value, value) == WSError::WS_OK) { 231 TLOGI(WmsLogTag::WMS_LAYOUT, "ohos.ability.window.width = %{public}d", value); 232 napi_set_named_property(env, objValue, "windowWidth", CreateJsValue(env, value)); 233 } 234 } else if (item.name == "ohos.ability.window.height") { 235 if (GetIntValueFromString(item.value, value) == WSError::WS_OK) { 236 TLOGI(WmsLogTag::WMS_LAYOUT, "ohos.ability.window.height = %{public}d", value); 237 napi_set_named_property(env, objValue, "windowHeight", CreateJsValue(env, value)); 238 } 239 } else if (item.name == "ohos.ability.window.left") { 240 if (item.value.size() > 0) { 241 TLOGI(WmsLogTag::WMS_LAYOUT, "ohos.ability.window.left = %{public}s", item.value.c_str()); 242 napi_set_named_property(env, objValue, "windowLeft", CreateJsValue(env, item.value)); 243 } 244 } else if (item.name == "ohos.ability.window.top") { 245 if (item.value.size() > 0) { 246 TLOGI(WmsLogTag::WMS_LAYOUT, "ohos.ability.window.top = %{public}s", item.value.c_str()); 247 napi_set_named_property(env, objValue, "windowTop", CreateJsValue(env, item.value)); 248 } 249 } 250 } 251 } 252 Create(napi_env env,const sptr<SceneSession> & session)253 napi_value JsSceneSession::Create(napi_env env, const sptr<SceneSession>& session) 254 { 255 napi_value objValue = nullptr; 256 napi_create_object(env, &objValue); 257 if (objValue == nullptr || session == nullptr) { 258 WLOGFE("[NAPI]Object or session is null!"); 259 return NapiGetUndefined(env); 260 } 261 262 sptr<JsSceneSession> jsSceneSession = sptr<JsSceneSession>::MakeSptr(env, session); 263 jsSceneSession->IncStrongRef(nullptr); 264 napi_wrap(env, objValue, jsSceneSession.GetRefPtr(), JsSceneSession::Finalizer, nullptr, nullptr); 265 napi_set_named_property(env, objValue, "persistentId", 266 CreateJsValue(env, static_cast<int32_t>(session->GetPersistentId()))); 267 napi_set_named_property(env, objValue, "parentId", 268 CreateJsValue(env, static_cast<int32_t>(session->GetParentPersistentId()))); 269 napi_set_named_property(env, objValue, "type", 270 CreateJsValue(env, static_cast<uint32_t>(GetApiType(session->GetWindowType())))); 271 napi_set_named_property(env, objValue, "isAppType", CreateJsValue(env, session->IsFloatingWindowAppType())); 272 napi_set_named_property(env, objValue, "pipTemplateInfo", CreatePipTemplateInfo(env, session)); 273 napi_set_named_property(env, objValue, "keyboardGravity", 274 CreateJsValue(env, static_cast<int32_t>(session->GetKeyboardGravity()))); 275 napi_set_named_property(env, objValue, "isTopmost", 276 CreateJsValue(env, static_cast<int32_t>(session->IsTopmost()))); 277 napi_set_named_property(env, objValue, "isMainWindowTopmost", 278 CreateJsValue(env, static_cast<int32_t>(session->IsMainWindowTopmost()))); 279 napi_set_named_property(env, objValue, "subWindowModalType", 280 CreateJsValue(env, static_cast<int32_t>(session->GetSubWindowModalType()))); 281 SetWindowSizeAndPosition(env, objValue, session); 282 const char* moduleName = "JsSceneSession"; 283 BindNativeMethod(env, objValue, moduleName); 284 BindNativeMethodForKeyboard(env, objValue, moduleName); 285 BindNativeMethodForCompatiblePcMode(env, objValue, moduleName); 286 BindNativeMethodForSCBSystemSession(env, objValue, moduleName); 287 BindNativeMethodForFocus(env, objValue, moduleName); 288 napi_ref jsRef = nullptr; 289 napi_status status = napi_create_reference(env, objValue, 1, &jsRef); 290 if (status != napi_ok) { 291 WLOGFE("do not get ref "); 292 } 293 jsSceneSessionMap_[session->GetPersistentId()] = jsRef; 294 BindNativeFunction(env, objValue, "updateSizeChangeReason", moduleName, JsSceneSession::UpdateSizeChangeReason); 295 return objValue; 296 } 297 BindNativeMethod(napi_env env,napi_value objValue,const char * moduleName)298 void JsSceneSession::BindNativeMethod(napi_env env, napi_value objValue, const char* moduleName) 299 { 300 BindNativeFunction(env, objValue, "on", moduleName, JsSceneSession::RegisterCallback); 301 BindNativeFunction(env, objValue, "updateNativeVisibility", moduleName, JsSceneSession::UpdateNativeVisibility); 302 BindNativeFunction(env, objValue, "setShowRecent", moduleName, JsSceneSession::SetShowRecent); 303 BindNativeFunction(env, objValue, "setZOrder", moduleName, JsSceneSession::SetZOrder); 304 BindNativeFunction(env, objValue, "setTouchable", moduleName, JsSceneSession::SetTouchable); 305 BindNativeFunction(env, objValue, "setSystemActive", moduleName, JsSceneSession::SetSystemActive); 306 BindNativeFunction(env, objValue, "setPrivacyMode", moduleName, JsSceneSession::SetPrivacyMode); 307 BindNativeFunction(env, objValue, "setSystemSceneOcclusionAlpha", 308 moduleName, JsSceneSession::SetSystemSceneOcclusionAlpha); 309 BindNativeFunction(env, objValue, "setSystemSceneForceUIFirst", 310 moduleName, JsSceneSession::SetSystemSceneForceUIFirst); 311 BindNativeFunction(env, objValue, "markSystemSceneUIFirst", 312 moduleName, JsSceneSession::MarkSystemSceneUIFirst); 313 BindNativeFunction(env, objValue, "setFloatingScale", moduleName, JsSceneSession::SetFloatingScale); 314 BindNativeFunction(env, objValue, "setIsMidScene", moduleName, JsSceneSession::SetIsMidScene); 315 BindNativeFunction(env, objValue, "setScale", moduleName, JsSceneSession::SetScale); 316 BindNativeFunction(env, objValue, "setWindowLastSafeRect", moduleName, JsSceneSession::SetWindowLastSafeRect); 317 BindNativeFunction(env, objValue, "setOffset", moduleName, JsSceneSession::SetOffset); 318 BindNativeFunction(env, objValue, "setExitSplitOnBackground", moduleName, 319 JsSceneSession::SetExitSplitOnBackground); 320 BindNativeFunction(env, objValue, "setWaterMarkFlag", moduleName, JsSceneSession::SetWaterMarkFlag); 321 BindNativeFunction(env, objValue, "setPipActionEvent", moduleName, JsSceneSession::SetPipActionEvent); 322 BindNativeFunction(env, objValue, "setPiPControlEvent", moduleName, JsSceneSession::SetPiPControlEvent); 323 BindNativeFunction(env, objValue, "notifyPipOcclusionChange", moduleName, JsSceneSession::NotifyPipOcclusionChange); 324 BindNativeFunction(env, objValue, "notifyDisplayStatusBarTemporarily", moduleName, 325 JsSceneSession::NotifyDisplayStatusBarTemporarily); 326 BindNativeFunction(env, objValue, "setTemporarilyShowWhenLocked", moduleName, 327 JsSceneSession::SetTemporarilyShowWhenLocked); 328 BindNativeFunction(env, objValue, "setSkipDraw", moduleName, 329 JsSceneSession::SetSkipDraw); 330 BindNativeFunction(env, objValue, "setSkipSelfWhenShowOnVirtualScreen", moduleName, 331 JsSceneSession::SetSkipSelfWhenShowOnVirtualScreen); 332 BindNativeFunction(env, objValue, "setCompatibleModeInPc", moduleName, 333 JsSceneSession::SetCompatibleModeInPc); 334 BindNativeFunction(env, objValue, "setUniqueDensityDpiFromSCB", moduleName, 335 JsSceneSession::SetUniqueDensityDpiFromSCB); 336 BindNativeFunction(env, objValue, "setBlankFlag", moduleName, JsSceneSession::SetBlankFlag); 337 BindNativeFunction(env, objValue, "removeBlank", moduleName, JsSceneSession::RemoveBlank); 338 BindNativeFunction(env, objValue, "setBufferAvailableCallbackEnable", moduleName, 339 JsSceneSession::SetBufferAvailableCallbackEnable); 340 BindNativeFunction(env, objValue, "isDeviceWakeupByApplication", moduleName, 341 JsSceneSession::IsDeviceWakeupByApplication); 342 BindNativeFunction(env, objValue, "syncDefaultRequestedOrientation", moduleName, 343 JsSceneSession::SyncDefaultRequestedOrientation); 344 BindNativeFunction(env, objValue, "setIsPcAppInPad", moduleName, 345 JsSceneSession::SetIsPcAppInPad); 346 BindNativeFunction(env, objValue, "setCompatibleModeEnableInPad", moduleName, 347 JsSceneSession::SetCompatibleModeEnableInPad); 348 BindNativeFunction(env, objValue, "setStartingWindowExitAnimationFlag", moduleName, 349 JsSceneSession::SetStartingWindowExitAnimationFlag); 350 BindNativeFunction(env, objValue, "setNeedSyncSessionRect", moduleName, 351 JsSceneSession::SetNeedSyncSessionRect); 352 BindNativeFunction(env, objValue, "setWindowEnableDragBySystem", moduleName, 353 JsSceneSession::SetWindowEnableDragBySystem); 354 BindNativeFunction(env, objValue, "setIsActivatedAfterScreenLocked", moduleName, 355 JsSceneSession::SetIsActivatedAfterScreenLocked); 356 BindNativeFunction(env, objValue, "setFrameGravity", moduleName, 357 JsSceneSession::SetFrameGravity); 358 BindNativeFunction(env, objValue, "setUseStartingWindowAboveLocked", moduleName, 359 JsSceneSession::SetUseStartingWindowAboveLocked); 360 BindNativeFunction(env, objValue, "setFreezeImmediately", moduleName, 361 JsSceneSession::SetFreezeImmediately); 362 } 363 BindNativeMethodForKeyboard(napi_env env,napi_value objValue,const char * moduleName)364 void JsSceneSession::BindNativeMethodForKeyboard(napi_env env, napi_value objValue, const char* moduleName) 365 { 366 BindNativeFunction(env, objValue, "setSCBKeepKeyboard", moduleName, JsSceneSession::SetSCBKeepKeyboard); 367 BindNativeFunction(env, objValue, "requestHideKeyboard", moduleName, JsSceneSession::RequestHideKeyboard); 368 BindNativeFunction(env, objValue, "openKeyboardSyncTransaction", moduleName, 369 JsSceneSession::OpenKeyboardSyncTransaction); 370 BindNativeFunction(env, objValue, "closeKeyboardSyncTransaction", moduleName, 371 JsSceneSession::CloseKeyboardSyncTransaction); 372 BindNativeFunction(env, objValue, "notifyTargetScreenWidthAndHeight", moduleName, 373 JsSceneSession::NotifyTargetScreenWidthAndHeight); 374 } 375 BindNativeMethodForCompatiblePcMode(napi_env env,napi_value objValue,const char * moduleName)376 void JsSceneSession::BindNativeMethodForCompatiblePcMode(napi_env env, napi_value objValue, const char* moduleName) 377 { 378 BindNativeFunction(env, objValue, "setCompatibleWindowSizeInPc", moduleName, 379 JsSceneSession::SetCompatibleWindowSizeInPc); 380 BindNativeFunction(env, objValue, "setAppSupportPhoneInPc", moduleName, 381 JsSceneSession::SetAppSupportPhoneInPc); 382 } 383 BindNativeMethodForSCBSystemSession(napi_env env,napi_value objValue,const char * moduleName)384 void JsSceneSession::BindNativeMethodForSCBSystemSession(napi_env env, napi_value objValue, const char* moduleName) 385 { 386 BindNativeFunction(env, objValue, "syncScenePanelGlobalPosition", moduleName, 387 JsSceneSession::SyncScenePanelGlobalPosition); 388 BindNativeFunction(env, objValue, "unSyncScenePanelGlobalPosition", moduleName, 389 JsSceneSession::UnSyncScenePanelGlobalPosition); 390 } 391 BindNativeMethodForFocus(napi_env env,napi_value objValue,const char * moduleName)392 void JsSceneSession::BindNativeMethodForFocus(napi_env env, napi_value objValue, const char* moduleName) 393 { 394 BindNativeFunction(env, objValue, "setFocusable", moduleName, JsSceneSession::SetFocusable); 395 BindNativeFunction(env, objValue, "setFocusableOnShow", moduleName, JsSceneSession::SetFocusableOnShow); 396 BindNativeFunction(env, objValue, "setSystemSceneBlockingFocus", moduleName, 397 JsSceneSession::SetSystemSceneBlockingFocus); 398 } 399 JsSceneSession(napi_env env,const sptr<SceneSession> & session)400 JsSceneSession::JsSceneSession(napi_env env, const sptr<SceneSession>& session) 401 : env_(env), weakSession_(session), persistentId_(session->GetPersistentId()), 402 taskScheduler_(std::make_shared<MainThreadScheduler>(env)) 403 { 404 InitListenerFuncs(); 405 sptr<SceneSession::SessionChangeCallback> sessionchangeCallback = new (std::nothrow) 406 SceneSession::SessionChangeCallback(); 407 if (sessionchangeCallback != nullptr) { 408 if (session != nullptr) { 409 session->RegisterSessionChangeCallback(sessionchangeCallback); 410 session->RegisterClearCallbackMapCallback([weakThis = wptr(this)](bool needRemove, int32_t persistentId) { 411 auto jsSceneSession = weakThis.promote(); 412 if (!jsSceneSession) { 413 TLOGNE(WmsLogTag::WMS_LIFE, "clearCallbackFunc jsSceneSession is null"); 414 return; 415 } 416 jsSceneSession->ClearCbMap(needRemove, persistentId); 417 }); 418 } 419 sessionchangeCallback_ = sessionchangeCallback; 420 WLOGFD("RegisterSessionChangeCallback success"); 421 } 422 } 423 ~JsSceneSession()424 JsSceneSession::~JsSceneSession() 425 { 426 TLOGI(WmsLogTag::WMS_LIFE, "destroyed, id:%{public}d", persistentId_); 427 auto session = weakSession_.promote(); 428 if (session == nullptr) { 429 TLOGI(WmsLogTag::WMS_LIFE, "session is nullptr, id:%{public}d", persistentId_); 430 return; 431 } 432 session->UnregisterSessionChangeListeners(); 433 SceneSessionManager::GetInstance().UnregisterCreateSubSessionListener(session->GetPersistentId()); 434 } 435 InitListenerFuncs()436 void JsSceneSession::InitListenerFuncs() 437 { 438 } 439 ProcessPendingSceneSessionActivationRegister()440 void JsSceneSession::ProcessPendingSceneSessionActivationRegister() 441 { 442 auto session = weakSession_.promote(); 443 if (session == nullptr) { 444 TLOGE(WmsLogTag::WMS_LIFE, "session is nullptr, id:%{public}d", persistentId_); 445 return; 446 } 447 const char* const where = __func__; 448 session->SetPendingSessionActivationEventListener([weakThis = wptr(this), where](SessionInfo& info) { 449 auto jsSceneSession = weakThis.promote(); 450 if (!jsSceneSession) { 451 TLOGNE(WmsLogTag::WMS_LIFE, "%{public}s jsSceneSession is null", where); 452 return; 453 } 454 jsSceneSession->PendingSessionActivation(info); 455 }); 456 TLOGD(WmsLogTag::WMS_LIFE, "success"); 457 } 458 ProcessWindowDragHotAreaRegister()459 void JsSceneSession::ProcessWindowDragHotAreaRegister() 460 { 461 WLOGFI("[NAPI]ProcessWindowDragHotAreaRegister"); 462 NotifyWindowDragHotAreaFunc func = [weakThis = wptr(this)](uint32_t type, const SizeChangeReason& reason) { 463 auto jsSceneSession = weakThis.promote(); 464 if (!jsSceneSession) { 465 TLOGE(WmsLogTag::WMS_LIFE, "ProcessWindowDragHotAreaRegister jsSceneSession is null"); 466 return; 467 } 468 jsSceneSession->OnWindowDragHotArea(type, reason); 469 }; 470 auto session = weakSession_.promote(); 471 if (session == nullptr) { 472 WLOGFE("session is nullptr, id:%{public}d", persistentId_); 473 return; 474 } 475 session->SetWindowDragHotAreaListener(func); 476 } 477 OnWindowDragHotArea(uint32_t type,const SizeChangeReason & reason)478 void JsSceneSession::OnWindowDragHotArea(uint32_t type, const SizeChangeReason& reason) 479 { 480 WLOGFI("[NAPI]OnWindowDragHotArea"); 481 482 auto session = weakSession_.promote(); 483 if (session == nullptr) { 484 WLOGFE("session is nullptr, id:%{public}d", persistentId_); 485 return; 486 } 487 WSRect rect = session->GetSessionTargetRect(); 488 auto task = [weakThis = wptr(this), persistentId = persistentId_, env = env_, type, reason, rect] { 489 auto jsSceneSession = weakThis.promote(); 490 if (!jsSceneSession || jsSceneSessionMap_.find(persistentId) == jsSceneSessionMap_.end()) { 491 TLOGE(WmsLogTag::WMS_LIFE, "OnWindowDragHotArea jsSceneSession id:%{public}d has been destroyed", 492 persistentId); 493 return; 494 } 495 auto jsCallBack = jsSceneSession->GetJSCallback(WINDOW_DRAG_HOT_AREA_CB); 496 if (!jsCallBack) { 497 WLOGFE("[NAPI]jsCallBack is nullptr"); 498 return; 499 } 500 napi_value jsHotAreaType = CreateJsValue(env, type); 501 if (jsHotAreaType == nullptr) { 502 WLOGFE("[NAPI]jsHotAreaType is nullptr"); 503 return; 504 } 505 napi_value jsHotAreaReason = CreateJsValue(env, reason); 506 if (jsHotAreaReason == nullptr) { 507 WLOGFE("[NAPI]jsHotAreaReason is nullptr"); 508 return; 509 } 510 napi_value jsHotAreaRect = CreateJsSessionRect(env, rect); 511 if (jsHotAreaRect == nullptr) { 512 WLOGFE("[NAPI]jsHotAreaRect is nullptr"); 513 return; 514 } 515 napi_value argv[] = {jsHotAreaType, jsHotAreaReason, jsHotAreaRect}; 516 napi_call_function(env, NapiGetUndefined(env), jsCallBack->GetNapiValue(), ArraySize(argv), argv, nullptr); 517 }; 518 taskScheduler_->PostMainThreadTask(task, "OnWindowDragHotArea"); 519 } 520 ProcessSessionInfoLockedStateChangeRegister()521 void JsSceneSession::ProcessSessionInfoLockedStateChangeRegister() 522 { 523 NotifySessionInfoLockedStateChangeFunc func = [weakThis = wptr(this)](bool lockedState) { 524 auto jsSceneSession = weakThis.promote(); 525 if (!jsSceneSession) { 526 TLOGE(WmsLogTag::WMS_LIFE, "ProcessSessionInfoLockedStateChangeRegister jsSceneSession is null"); 527 return; 528 } 529 jsSceneSession->OnSessionInfoLockedStateChange(lockedState); 530 }; 531 auto session = weakSession_.promote(); 532 if (session == nullptr) { 533 WLOGFE("session is nullptr, id:%{public}d", persistentId_); 534 return; 535 } 536 session->SetSessionInfoLockedStateChangeListener(func); 537 WLOGFD("ProcessSessionInfoLockedStateChangeRegister success"); 538 } 539 ProcessLandscapeMultiWindowRegister()540 void JsSceneSession::ProcessLandscapeMultiWindowRegister() 541 { 542 TLOGD(WmsLogTag::WMS_MULTI_WINDOW, "ProcessLandscapeMultiWindowRegister"); 543 auto sessionchangeCallback = sessionchangeCallback_.promote(); 544 if (sessionchangeCallback == nullptr) { 545 TLOGE(WmsLogTag::WMS_MULTI_WINDOW, "sessionchangeCallback is nullptr"); 546 return; 547 } 548 sessionchangeCallback->onSetLandscapeMultiWindowFunc_ = [weakThis = wptr(this)](bool isLandscapeMultiWindow) { 549 auto jsSceneSession = weakThis.promote(); 550 if (!jsSceneSession) { 551 TLOGE(WmsLogTag::WMS_LIFE, "ProcessLandscapeMultiWindowRegister jsSceneSession is null"); 552 return; 553 } 554 jsSceneSession->SetLandscapeMultiWindow(isLandscapeMultiWindow); 555 }; 556 TLOGD(WmsLogTag::WMS_MULTI_WINDOW, "ProcessLandscapeMultiWindowRegister success"); 557 } 558 SetLandscapeMultiWindow(bool isLandscapeMultiWindow)559 void JsSceneSession::SetLandscapeMultiWindow(bool isLandscapeMultiWindow) 560 { 561 TLOGI(WmsLogTag::WMS_MULTI_WINDOW, "[NAPI]SetLandScapeMultiWindow, isLandscapeMultiWindow: %{public}u", 562 isLandscapeMultiWindow); 563 564 auto task = [weakThis = wptr(this), persistentId = persistentId_, isLandscapeMultiWindow, env = env_] { 565 auto jsSceneSession = weakThis.promote(); 566 if (!jsSceneSession || jsSceneSessionMap_.find(persistentId) == jsSceneSessionMap_.end()) { 567 TLOGE(WmsLogTag::WMS_LIFE, "SetLandscapeMultiWindow jsSceneSession id:%{public}d has been destroyed", 568 persistentId); 569 return; 570 } 571 auto jsCallBack = jsSceneSession->GetJSCallback(LANDSCAPE_MULTI_WINDOW_CB); 572 if (!jsCallBack) { 573 WLOGFE("[NAPI]jsCallBack is nullptr"); 574 return; 575 } 576 napi_value jsSessionLandscapeMultiWindowObj = CreateJsValue(env, isLandscapeMultiWindow); 577 napi_value argv[] = {jsSessionLandscapeMultiWindowObj}; 578 napi_call_function(env, NapiGetUndefined(env), jsCallBack->GetNapiValue(), ArraySize(argv), argv, nullptr); 579 }; 580 taskScheduler_->PostMainThreadTask(task, 581 "SetLandscapeMultiWindow, isLandscapeMultiWindow:" + std::to_string(isLandscapeMultiWindow)); 582 } 583 ProcessKeyboardGravityChangeRegister()584 void JsSceneSession::ProcessKeyboardGravityChangeRegister() 585 { 586 auto session = weakSession_.promote(); 587 if (session == nullptr) { 588 WLOGFE("session is nullptr, id:%{public}d", persistentId_); 589 return; 590 } 591 NotifyKeyboardGravityChangeFunc func = [weakThis = wptr(this)](SessionGravity gravity) { 592 auto jsSceneSession = weakThis.promote(); 593 if (!jsSceneSession) { 594 TLOGE(WmsLogTag::WMS_LIFE, "ProcessKeyboardGravityChangeRegister jsSceneSession is null"); 595 return; 596 } 597 jsSceneSession->OnKeyboardGravityChange(gravity); 598 }; 599 session->SetKeyboardGravityChangeCallback(func); 600 TLOGI(WmsLogTag::WMS_KEYBOARD, "Register success"); 601 } 602 OnKeyboardGravityChange(SessionGravity gravity)603 void JsSceneSession::OnKeyboardGravityChange(SessionGravity gravity) 604 { 605 TLOGI(WmsLogTag::WMS_KEYBOARD, "[NAPI] gravity: %{public}u", gravity); 606 auto task = [weakThis = wptr(this), persistentId = persistentId_, gravity, env = env_] { 607 auto jsSceneSession = weakThis.promote(); 608 if (!jsSceneSession || jsSceneSessionMap_.find(persistentId) == jsSceneSessionMap_.end()) { 609 TLOGE(WmsLogTag::WMS_LIFE, "OnKeyboardGravityChange jsSceneSession id:%{public}d has been destroyed", 610 persistentId); 611 return; 612 } 613 auto jsCallBack = jsSceneSession->GetJSCallback(KEYBOARD_GRAVITY_CHANGE_CB); 614 if (!jsCallBack) { 615 WLOGFE("[NAPI]jsCallBack is nullptr"); 616 return; 617 } 618 napi_value gravityObj = CreateJsValue(env, gravity); 619 napi_value argv[] = {gravityObj}; 620 napi_call_function(env, NapiGetUndefined(env), jsCallBack->GetNapiValue(), ArraySize(argv), argv, nullptr); 621 TLOGI(WmsLogTag::WMS_KEYBOARD, "Napi call gravity success, gravity: %{public}u", gravity); 622 }; 623 taskScheduler_->PostMainThreadTask(task, "OnKeyboardGravityChange: gravity " + 624 std::to_string(static_cast<int>(gravity))); 625 } 626 ProcessAdjustKeyboardLayoutRegister()627 void JsSceneSession::ProcessAdjustKeyboardLayoutRegister() 628 { 629 NotifyKeyboardLayoutAdjustFunc func = [weakThis = wptr(this)](const KeyboardLayoutParams& params) { 630 auto jsSceneSession = weakThis.promote(); 631 if (!jsSceneSession) { 632 TLOGE(WmsLogTag::WMS_LIFE, "ProcessAdjustKeyboardLayoutRegister jsSceneSession is null"); 633 return; 634 } 635 jsSceneSession->OnAdjustKeyboardLayout(params); 636 }; 637 auto session = weakSession_.promote(); 638 if (session == nullptr) { 639 TLOGE(WmsLogTag::WMS_KEYBOARD, "session is nullptr"); 640 return; 641 } 642 session->SetAdjustKeyboardLayoutCallback(func); 643 TLOGI(WmsLogTag::WMS_KEYBOARD, "Register success"); 644 } 645 ProcessLayoutFullScreenChangeRegister()646 void JsSceneSession::ProcessLayoutFullScreenChangeRegister() 647 { 648 auto sessionchangeCallback = sessionchangeCallback_.promote(); 649 if (sessionchangeCallback == nullptr) { 650 TLOGE(WmsLogTag::WMS_LAYOUT, "sessionchangeCallback is nullptr"); 651 return; 652 } 653 sessionchangeCallback->onLayoutFullScreenChangeFunc_ = [weakThis = wptr(this)](bool isLayoutFullScreen) { 654 auto jsSceneSession = weakThis.promote(); 655 if (!jsSceneSession) { 656 TLOGE(WmsLogTag::WMS_LIFE, "ProcessLayoutFullScreenChangeRegister jsSceneSession is null"); 657 return; 658 } 659 jsSceneSession->OnLayoutFullScreenChange(isLayoutFullScreen); 660 }; 661 TLOGI(WmsLogTag::WMS_LAYOUT, "Register success"); 662 } 663 OnLayoutFullScreenChange(bool isLayoutFullScreen)664 void JsSceneSession::OnLayoutFullScreenChange(bool isLayoutFullScreen) 665 { 666 auto task = [weakThis = wptr(this), persistentId = persistentId_, isLayoutFullScreen, env = env_] { 667 auto jsSceneSession = weakThis.promote(); 668 if (!jsSceneSession || jsSceneSessionMap_.find(persistentId) == jsSceneSessionMap_.end()) { 669 TLOGE(WmsLogTag::WMS_LIFE, "OnLayoutFullScreenChange jsSceneSession id:%{public}d has been destroyed", 670 persistentId); 671 return; 672 } 673 auto jsCallBack = jsSceneSession->GetJSCallback(LAYOUT_FULL_SCREEN_CB); 674 if (!jsCallBack) { 675 TLOGE(WmsLogTag::WMS_LAYOUT, "OnLayoutFullScreenChange jsCallBack is nullptr"); 676 return; 677 } 678 napi_value paramsObj = CreateJsValue(env, isLayoutFullScreen); 679 napi_value argv[] = {paramsObj}; 680 napi_call_function(env, NapiGetUndefined(env), jsCallBack->GetNapiValue(), ArraySize(argv), argv, nullptr); 681 }; 682 taskScheduler_->PostMainThreadTask(task, "OnLayoutFullScreenChange"); 683 } 684 ProcessTitleAndDockHoverShowChangeRegister()685 void JsSceneSession::ProcessTitleAndDockHoverShowChangeRegister() 686 { 687 auto session = weakSession_.promote(); 688 if (session == nullptr) { 689 TLOGE(WmsLogTag::WMS_IMMS, "session is nullptr, id:%{public}d", persistentId_); 690 return; 691 } 692 const char* const funcName = __func__; 693 session->SetTitleAndDockHoverShowChangeCallback([weakThis = wptr(this), funcName]( 694 bool isTitleHoverShown, bool isDockHoverShown) { 695 auto jsSceneSession = weakThis.promote(); 696 if (!jsSceneSession) { 697 TLOGNE(WmsLogTag::WMS_IMMS, "%{public}s jsSceneSession is null", funcName); 698 return; 699 } 700 jsSceneSession->OnTitleAndDockHoverShowChange(isTitleHoverShown, isDockHoverShown); 701 }); 702 TLOGI(WmsLogTag::WMS_IMMS, "Register success, persistent id %{public}d", persistentId_); 703 } 704 OnTitleAndDockHoverShowChange(bool isTitleHoverShown,bool isDockHoverShown)705 void JsSceneSession::OnTitleAndDockHoverShowChange(bool isTitleHoverShown, bool isDockHoverShown) 706 { 707 const char* const funcName = __func__; 708 auto task = [weakThis = wptr(this), persistentId = persistentId_, isTitleHoverShown, isDockHoverShown, 709 env = env_, funcName] { 710 auto jsSceneSession = weakThis.promote(); 711 if (!jsSceneSession || jsSceneSessionMap_.find(persistentId) == jsSceneSessionMap_.end()) { 712 TLOGNE(WmsLogTag::WMS_IMMS, "%{public}s jsSceneSession id:%{public}d has been destroyed", 713 funcName, persistentId); 714 return; 715 } 716 auto jsCallBack = jsSceneSession->GetJSCallback(TITLE_DOCK_HOVER_SHOW_CB); 717 if (!jsCallBack) { 718 TLOGNE(WmsLogTag::WMS_IMMS, "%{public}s jsCallBack is nullptr", funcName); 719 return; 720 } 721 napi_value jsObjTitle = CreateJsValue(env, isTitleHoverShown); 722 napi_value jsObjDock = CreateJsValue(env, isDockHoverShown); 723 napi_value argv[] = {jsObjTitle, jsObjDock}; 724 napi_call_function(env, NapiGetUndefined(env), jsCallBack->GetNapiValue(), ArraySize(argv), argv, nullptr); 725 }; 726 taskScheduler_->PostMainThreadTask(task, funcName); 727 } 728 ProcessDefaultDensityEnabledRegister()729 void JsSceneSession::ProcessDefaultDensityEnabledRegister() 730 { 731 auto session = weakSession_.promote(); 732 if (session == nullptr) { 733 TLOGE(WmsLogTag::WMS_LIFE, "session is nullptr, id:%{public}d", persistentId_); 734 return; 735 } 736 session->RegisterDefaultDensityEnabledCallback([weakThis = wptr(this)](bool isDefaultDensityEnabled) { 737 auto jsSceneSession = weakThis.promote(); 738 if (!jsSceneSession) { 739 TLOGNE(WmsLogTag::WMS_LIFE, "ProcessDefaultDensityEnabledRegister jsSceneSession is null"); 740 return; 741 } 742 jsSceneSession->OnDefaultDensityEnabled(isDefaultDensityEnabled); 743 }); 744 TLOGI(WmsLogTag::WMS_LAYOUT, "success"); 745 } 746 OnDefaultDensityEnabled(bool isDefaultDensityEnabled)747 void JsSceneSession::OnDefaultDensityEnabled(bool isDefaultDensityEnabled) 748 { 749 auto task = [weakThis = wptr(this), persistentId = persistentId_, isDefaultDensityEnabled, env = env_] { 750 auto jsSceneSession = weakThis.promote(); 751 if (!jsSceneSession || jsSceneSessionMap_.find(persistentId) == jsSceneSessionMap_.end()) { 752 TLOGNE(WmsLogTag::WMS_LIFE, "OnDefaultDensityEnabled jsSceneSession id:%{public}d has been destroyed", 753 persistentId); 754 return; 755 } 756 auto jsCallBack = jsSceneSession->GetJSCallback(DEFAULT_DENSITY_ENABLED_CB); 757 if (!jsCallBack) { 758 TLOGNE(WmsLogTag::WMS_LAYOUT, "OnDefaultDensityEnabled jsCallBack is nullptr"); 759 return; 760 } 761 napi_value paramsObj = CreateJsValue(env, isDefaultDensityEnabled); 762 napi_value argv[] = {paramsObj}; 763 napi_call_function(env, NapiGetUndefined(env), jsCallBack->GetNapiValue(), ArraySize(argv), argv, nullptr); 764 }; 765 taskScheduler_->PostMainThreadTask(task, "OnDefaultDensityEnabled"); 766 } 767 ProcessRestoreMainWindowRegister()768 void JsSceneSession::ProcessRestoreMainWindowRegister() 769 { 770 auto session = weakSession_.promote(); 771 if (session == nullptr) { 772 TLOGE(WmsLogTag::WMS_LIFE, "session is nullptr, id:%{public}d", persistentId_); 773 return; 774 } 775 const char* const funcName = __func__; 776 session->SetRestoreMainWindowCallback([weakThis = wptr(this), funcName] { 777 auto jsSceneSession = weakThis.promote(); 778 if (!jsSceneSession) { 779 TLOGNE(WmsLogTag::WMS_LIFE, "%{public}s jsSceneSession is null", funcName); 780 return; 781 } 782 jsSceneSession->RestoreMainWindow(); 783 }); 784 TLOGI(WmsLogTag::WMS_LIFE, "success"); 785 } 786 RestoreMainWindow()787 void JsSceneSession::RestoreMainWindow() 788 { 789 const char* const funcName = __func__; 790 auto task = [weakThis = wptr(this), persistentId = persistentId_, env = env_, funcName] { 791 auto jsSceneSession = weakThis.promote(); 792 if (!jsSceneSession || jsSceneSessionMap_.find(persistentId) == jsSceneSessionMap_.end()) { 793 TLOGNE(WmsLogTag::WMS_LIFE, "%{public}s jsSceneSession id:%{public}d has been destroyed", 794 funcName, persistentId); 795 return; 796 } 797 auto jsCallBack = jsSceneSession->GetJSCallback(RESTORE_MAIN_WINDOW_CB); 798 if (!jsCallBack) { 799 TLOGNE(WmsLogTag::WMS_LIFE, "%{public}s jsCallBack is nullptr", funcName); 800 return; 801 } 802 napi_call_function(env, NapiGetUndefined(env), jsCallBack->GetNapiValue(), 0, {}, nullptr); 803 }; 804 taskScheduler_->PostMainThreadTask(task, funcName); 805 } 806 OnAdjustKeyboardLayout(const KeyboardLayoutParams & params)807 void JsSceneSession::OnAdjustKeyboardLayout(const KeyboardLayoutParams& params) 808 { 809 auto task = [weakThis = wptr(this), persistentId = persistentId_, params, env = env_] { 810 auto jsSceneSession = weakThis.promote(); 811 if (!jsSceneSession || jsSceneSessionMap_.find(persistentId) == jsSceneSessionMap_.end()) { 812 TLOGE(WmsLogTag::WMS_LIFE, "OnAdjustKeyboardLayout jsSceneSession id:%{public}d has been destroyed", 813 persistentId); 814 return; 815 } 816 auto jsCallBack = jsSceneSession->GetJSCallback(ADJUST_KEYBOARD_LAYOUT_CB); 817 if (!jsCallBack) { 818 TLOGE(WmsLogTag::WMS_KEYBOARD, "OnAdjustKeyboardLayout jsCallBack is nullptr"); 819 return; 820 } 821 napi_value keyboardLayoutParamsObj = CreateJsKeyboardLayoutParams(env, params); 822 if (keyboardLayoutParamsObj == nullptr) { 823 TLOGE(WmsLogTag::WMS_KEYBOARD, "OnAdjustKeyboardLayout this keyboard layout params obj is nullptr"); 824 } 825 napi_value argv[] = {keyboardLayoutParamsObj}; 826 napi_call_function(env, NapiGetUndefined(env), jsCallBack->GetNapiValue(), ArraySize(argv), argv, nullptr); 827 }; 828 taskScheduler_->PostMainThreadTask(task, "OnAdjustKeyboardLayout"); 829 } 830 OnSessionInfoLockedStateChange(bool lockedState)831 void JsSceneSession::OnSessionInfoLockedStateChange(bool lockedState) 832 { 833 WLOGFI("[NAPI]OnSessionInfoLockedStateChange, state: %{public}u", lockedState); 834 835 auto task = [weakThis = wptr(this), persistentId = persistentId_, lockedState, env = env_] { 836 auto jsSceneSession = weakThis.promote(); 837 if (!jsSceneSession || jsSceneSessionMap_.find(persistentId) == jsSceneSessionMap_.end()) { 838 TLOGE(WmsLogTag::WMS_LIFE, "OnSessionInfoLockedStateChange jsSceneSession id:%{public}d has been destroyed", 839 persistentId); 840 return; 841 } 842 auto jsCallBack = jsSceneSession->GetJSCallback(SESSIONINFO_LOCKEDSTATE_CHANGE_CB); 843 if (!jsCallBack) { 844 WLOGFE("[NAPI]jsCallBack is nullptr"); 845 return; 846 } 847 napi_value jsSessionInfoLockedStateObj = CreateJsValue(env, lockedState); 848 napi_value argv[] = {jsSessionInfoLockedStateObj}; 849 napi_call_function(env, NapiGetUndefined(env), jsCallBack->GetNapiValue(), ArraySize(argv), argv, nullptr); 850 }; 851 taskScheduler_->PostMainThreadTask(task, "OnSessionInfoLockedStateChange: state " + std::to_string(lockedState)); 852 } 853 ClearCbMap(bool needRemove,int32_t persistentId)854 void JsSceneSession::ClearCbMap(bool needRemove, int32_t persistentId) 855 { 856 if (!needRemove) { 857 return; 858 } 859 auto task = [weakThis = wptr(this), persistentId]() { 860 TLOGI(WmsLogTag::WMS_LIFE, "clear callbackMap with persistent id, %{public}d", persistentId); 861 auto jsSceneSession = weakThis.promote(); 862 if (!jsSceneSession) { 863 TLOGE(WmsLogTag::WMS_LIFE, "ClearCbMap jsSceneSession is null"); 864 return; 865 } 866 { 867 HITRACE_METER_FMT(HITRACE_TAG_WINDOW_MANAGER, "JsSceneSession clear jsCbMap"); 868 std::unique_lock<std::shared_mutex> lock(jsSceneSession->jsCbMapMutex_); 869 jsSceneSession->jsCbMap_.clear(); 870 } 871 auto iter = jsSceneSessionMap_.find(persistentId); 872 if (iter != jsSceneSessionMap_.end()) { 873 napi_delete_reference(jsSceneSession->env_, iter->second); 874 jsSceneSessionMap_.erase(iter); 875 } else { 876 TLOGE(WmsLogTag::WMS_LIFE, "deleteRef failed , %{public}d", persistentId); 877 } 878 }; 879 taskScheduler_->PostMainThreadTask(task, "ClearCbMap PID:" + std::to_string(persistentId)); 880 } 881 ProcessSessionDefaultAnimationFlagChangeRegister()882 void JsSceneSession::ProcessSessionDefaultAnimationFlagChangeRegister() 883 { 884 auto session = weakSession_.promote(); 885 if (session == nullptr) { 886 WLOGFE("session is nullptr, id:%{public}d", persistentId_); 887 return; 888 } 889 session->RegisterDefaultAnimationFlagChangeCallback([weakThis = wptr(this)](bool isNeedDefaultAnimationFlag) { 890 auto jsSceneSession = weakThis.promote(); 891 if (!jsSceneSession) { 892 TLOGE(WmsLogTag::WMS_LIFE, "ProcessSessionDefaultAnimationFlagChangeRegister jsSceneSession is null"); 893 return; 894 } 895 jsSceneSession->OnDefaultAnimationFlagChange(isNeedDefaultAnimationFlag); 896 }); 897 } 898 OnDefaultAnimationFlagChange(bool isNeedDefaultAnimationFlag)899 void JsSceneSession::OnDefaultAnimationFlagChange(bool isNeedDefaultAnimationFlag) 900 { 901 WLOGFI("[NAPI]OnDefaultAnimationFlagChange, flag: %{public}u", isNeedDefaultAnimationFlag); 902 903 auto task = [weakThis = wptr(this), persistentId = persistentId_, isNeedDefaultAnimationFlag, env = env_] { 904 auto jsSceneSession = weakThis.promote(); 905 if (!jsSceneSession || jsSceneSessionMap_.find(persistentId) == jsSceneSessionMap_.end()) { 906 TLOGE(WmsLogTag::WMS_LIFE, "OnDefaultAnimationFlagChange jsSceneSession id:%{public}d has been destroyed", 907 persistentId); 908 return; 909 } 910 auto jsCallBack = jsSceneSession->GetJSCallback(NEED_DEFAULT_ANIMATION_FLAG_CHANGE_CB); 911 if (!jsCallBack) { 912 WLOGFE("[NAPI]jsCallBack is nullptr"); 913 return; 914 } 915 napi_value jsSessionDefaultAnimationFlagObj = CreateJsValue(env, isNeedDefaultAnimationFlag); 916 napi_value argv[] = {jsSessionDefaultAnimationFlagObj}; 917 napi_call_function(env, NapiGetUndefined(env), jsCallBack->GetNapiValue(), ArraySize(argv), argv, nullptr); 918 }; 919 std::string info = "OnDefaultAnimationFlagChange, flag:" + std::to_string(isNeedDefaultAnimationFlag); 920 taskScheduler_->PostMainThreadTask(task, info); 921 } 922 ProcessChangeSessionVisibilityWithStatusBarRegister()923 void JsSceneSession::ProcessChangeSessionVisibilityWithStatusBarRegister() 924 { 925 NotifyChangeSessionVisibilityWithStatusBarFunc func = [weakThis = wptr(this)](SessionInfo& info, bool visible) { 926 auto jsSceneSession = weakThis.promote(); 927 if (!jsSceneSession) { 928 TLOGE(WmsLogTag::WMS_LIFE, "ProcessChangeSessionVisibilityWithStatusBarRegister jsSceneSession is null"); 929 return; 930 } 931 jsSceneSession->ChangeSessionVisibilityWithStatusBar(info, visible); 932 }; 933 auto session = weakSession_.promote(); 934 if (session == nullptr) { 935 WLOGFE("session is nullptr, id:%{public}d", persistentId_); 936 return; 937 } 938 session->SetChangeSessionVisibilityWithStatusBarEventListener(func); 939 WLOGFD("ProcessChangeSessionVisibilityWithStatusBarRegister success"); 940 } 941 ProcessSessionStateChangeRegister()942 void JsSceneSession::ProcessSessionStateChangeRegister() 943 { 944 NotifySessionStateChangeFunc func = [weakThis = wptr(this)](const SessionState& state) { 945 auto jsSceneSession = weakThis.promote(); 946 if (!jsSceneSession) { 947 TLOGE(WmsLogTag::WMS_LIFE, "ProcessSessionStateChangeRegister jsSceneSession is null"); 948 return; 949 } 950 jsSceneSession->OnSessionStateChange(state); 951 }; 952 auto session = weakSession_.promote(); 953 if (session == nullptr) { 954 WLOGFE("session is nullptr, id:%{public}d", persistentId_); 955 return; 956 } 957 session->SetSessionStateChangeListenser(func); 958 WLOGFD("ProcessSessionStateChangeRegister success"); 959 } 960 ProcessBufferAvailableChangeRegister()961 void JsSceneSession::ProcessBufferAvailableChangeRegister() 962 { 963 NotifyBufferAvailableChangeFunc func = [weakThis = wptr(this)](const bool isAvailable) { 964 auto jsSceneSession = weakThis.promote(); 965 if (!jsSceneSession) { 966 TLOGE(WmsLogTag::WMS_LIFE, "ProcessBufferAvailableChangeRegister jsSceneSession is null"); 967 return; 968 } 969 jsSceneSession->OnBufferAvailableChange(isAvailable); 970 }; 971 auto session = weakSession_.promote(); 972 if (session == nullptr) { 973 WLOGFE("session is nullptr, id:%{public}d", persistentId_); 974 return; 975 } 976 session->SetBufferAvailableChangeListener(func); 977 WLOGFD("ProcessBufferAvailableChangeRegister success"); 978 } 979 ProcessCreateSubSessionRegister()980 void JsSceneSession::ProcessCreateSubSessionRegister() 981 { 982 NotifyCreateSubSessionFunc func = [weakThis = wptr(this)](const sptr<SceneSession>& sceneSession) { 983 auto jsSceneSession = weakThis.promote(); 984 if (!jsSceneSession) { 985 TLOGE(WmsLogTag::WMS_LIFE, "ProcessCreateSubSessionRegister jsSceneSession is null"); 986 return; 987 } 988 jsSceneSession->OnCreateSubSession(sceneSession); 989 }; 990 auto session = weakSession_.promote(); 991 if (session == nullptr) { 992 WLOGFE("session is nullptr, id:%{public}d", persistentId_); 993 return; 994 } 995 SceneSessionManager::GetInstance().RegisterCreateSubSessionListener(session->GetPersistentId(), func); 996 WLOGFD("ProcessCreateSubSessionRegister success, id: %{public}d", session->GetPersistentId()); 997 } 998 ProcessBindDialogTargetRegister()999 void JsSceneSession::ProcessBindDialogTargetRegister() 1000 { 1001 auto sessionchangeCallback = sessionchangeCallback_.promote(); 1002 if (sessionchangeCallback == nullptr) { 1003 TLOGE(WmsLogTag::WMS_DIALOG, "sessionchangeCallback is nullptr"); 1004 return; 1005 } 1006 sessionchangeCallback->onBindDialogTarget_ = [weakThis = wptr(this)](const sptr<SceneSession>& sceneSession) { 1007 auto jsSceneSession = weakThis.promote(); 1008 if (!jsSceneSession) { 1009 TLOGE(WmsLogTag::WMS_LIFE, "ProcessBindDialogTargetRegister jsSceneSession is null"); 1010 return; 1011 } 1012 jsSceneSession->OnBindDialogTarget(sceneSession); 1013 }; 1014 TLOGD(WmsLogTag::WMS_DIALOG, "ProcessBindDialogTargetRegister success"); 1015 } 1016 ProcessSessionRectChangeRegister()1017 void JsSceneSession::ProcessSessionRectChangeRegister() 1018 { 1019 NotifySessionRectChangeFunc func = [weakThis = wptr(this)](const WSRect& rect, const SizeChangeReason& reason) { 1020 auto jsSceneSession = weakThis.promote(); 1021 if (!jsSceneSession) { 1022 TLOGE(WmsLogTag::WMS_LIFE, "ProcessSessionRectChangeRegister jsSceneSession is null"); 1023 return; 1024 } 1025 jsSceneSession->OnSessionRectChange(rect, reason); 1026 }; 1027 auto session = weakSession_.promote(); 1028 if (session == nullptr) { 1029 WLOGFE("session is nullptr, id:%{public}d", persistentId_); 1030 return; 1031 } 1032 session->SetSessionRectChangeCallback(func); 1033 WLOGFD("ProcessSessionRectChangeRegister success"); 1034 } 1035 ProcessSessionPiPControlStatusChangeRegister()1036 void JsSceneSession::ProcessSessionPiPControlStatusChangeRegister() 1037 { 1038 NotifySessionPiPControlStatusChangeFunc func = [weakThis = wptr(this)]( 1039 WsPiPControlType controlType, WsPiPControlStatus status) { 1040 auto jsSceneSession = weakThis.promote(); 1041 if (!jsSceneSession) { 1042 TLOGE(WmsLogTag::WMS_LIFE, "ProcessSessionPiPControlStatusChangeRegister jsSceneSession is null"); 1043 return; 1044 } 1045 jsSceneSession->OnSessionPiPControlStatusChange(controlType, status); 1046 }; 1047 auto session = weakSession_.promote(); 1048 if (session == nullptr) { 1049 TLOGE(WmsLogTag::WMS_PIP, "session is nullptr, id:%{public}d", persistentId_); 1050 return; 1051 } 1052 session->SetSessionPiPControlStatusChangeCallback(func); 1053 TLOGI(WmsLogTag::WMS_PIP, "register success"); 1054 } 1055 ProcessAutoStartPiPStatusChangeRegister()1056 void JsSceneSession::ProcessAutoStartPiPStatusChangeRegister() 1057 { 1058 auto session = weakSession_.promote(); 1059 if (session == nullptr) { 1060 TLOGE(WmsLogTag::WMS_PIP, "session is nullptr, id:%{public}d", persistentId_); 1061 return; 1062 } 1063 NotifyAutoStartPiPStatusChangeFunc func = [weakThis = wptr(this)](bool isAutoStart, uint32_t priority) { 1064 auto jsSceneSession = weakThis.promote(); 1065 if (!jsSceneSession) { 1066 TLOGNE(WmsLogTag::WMS_PIP, "jsSceneSession is null"); 1067 return; 1068 } 1069 jsSceneSession->OnAutoStartPiPStatusChange(isAutoStart, priority); 1070 }; 1071 session->SetAutoStartPiPStatusChangeCallback(func); 1072 TLOGI(WmsLogTag::WMS_PIP, "success"); 1073 } 1074 1075 /** @note @window.hierarchy */ ProcessRaiseToTopRegister()1076 void JsSceneSession::ProcessRaiseToTopRegister() 1077 { 1078 auto sessionchangeCallback = sessionchangeCallback_.promote(); 1079 if (sessionchangeCallback == nullptr) { 1080 WLOGFE("sessionchangeCallback is nullptr"); 1081 return; 1082 } 1083 sessionchangeCallback->onRaiseToTop_ = [weakThis = wptr(this)] { 1084 auto jsSceneSession = weakThis.promote(); 1085 if (!jsSceneSession) { 1086 TLOGE(WmsLogTag::WMS_LIFE, "ProcessRaiseToTopRegister jsSceneSession is null"); 1087 return; 1088 } 1089 jsSceneSession->OnRaiseToTop(); 1090 }; 1091 WLOGFD("ProcessRaiseToTopRegister success"); 1092 } 1093 1094 /** @note @window.hierarchy */ ProcessRaiseToTopForPointDownRegister()1095 void JsSceneSession::ProcessRaiseToTopForPointDownRegister() 1096 { 1097 NotifyRaiseToTopForPointDownFunc func = [weakThis = wptr(this)]() { 1098 auto jsSceneSession = weakThis.promote(); 1099 if (!jsSceneSession) { 1100 TLOGE(WmsLogTag::WMS_LIFE, "ProcessRaiseToTopForPointDownRegister jsSceneSession is null"); 1101 return; 1102 } 1103 jsSceneSession->OnRaiseToTopForPointDown(); 1104 }; 1105 auto session = weakSession_.promote(); 1106 if (session == nullptr) { 1107 WLOGFE("session is nullptr, id:%{public}d", persistentId_); 1108 return; 1109 } 1110 session->SetRaiseToAppTopForPointDownFunc(func); 1111 WLOGFD("ProcessRaiseToTopForPointDownRegister success"); 1112 } 1113 1114 /** @note @window.hierarchy */ ProcessRaiseAboveTargetRegister()1115 void JsSceneSession::ProcessRaiseAboveTargetRegister() 1116 { 1117 auto sessionchangeCallback = sessionchangeCallback_.promote(); 1118 if (sessionchangeCallback == nullptr) { 1119 WLOGFE("sessionchangeCallback is nullptr"); 1120 return; 1121 } 1122 sessionchangeCallback->onRaiseAboveTarget_ = [weakThis = wptr(this)](int32_t subWindowId) { 1123 auto jsSceneSession = weakThis.promote(); 1124 if (!jsSceneSession) { 1125 TLOGE(WmsLogTag::WMS_LIFE, "ProcessRaiseAboveTargetRegister jsSceneSession is null"); 1126 return; 1127 } 1128 jsSceneSession->OnRaiseAboveTarget(subWindowId); 1129 }; 1130 WLOGFD("ProcessRaiseToTopRegister success"); 1131 } 1132 ProcessSessionEventRegister()1133 void JsSceneSession::ProcessSessionEventRegister() 1134 { 1135 auto sessionchangeCallback = sessionchangeCallback_.promote(); 1136 if (sessionchangeCallback == nullptr) { 1137 WLOGFE("sessionchangeCallback is nullptr"); 1138 return; 1139 } 1140 sessionchangeCallback->OnSessionEvent_ = [weakThis = wptr(this)](uint32_t eventId, const SessionEventParam& param) { 1141 auto jsSceneSession = weakThis.promote(); 1142 if (!jsSceneSession) { 1143 TLOGE(WmsLogTag::WMS_LIFE, "ProcessSessionEventRegister jsSceneSession is null"); 1144 return; 1145 } 1146 jsSceneSession->OnSessionEvent(eventId, param); 1147 }; 1148 WLOGFD("ProcessSessionEventRegister success"); 1149 } 1150 ProcessTerminateSessionRegister()1151 void JsSceneSession::ProcessTerminateSessionRegister() 1152 { 1153 TLOGD(WmsLogTag::WMS_LIFE, "begin"); 1154 auto session = weakSession_.promote(); 1155 if (session == nullptr) { 1156 TLOGE(WmsLogTag::WMS_LIFE, "session is nullptr, id:%{public}d", persistentId_); 1157 return; 1158 } 1159 const char* const where = __func__; 1160 session->SetTerminateSessionListener([weakThis = wptr(this), where](const SessionInfo& info) { 1161 auto jsSceneSession = weakThis.promote(); 1162 if (!jsSceneSession) { 1163 TLOGNE(WmsLogTag::WMS_LIFE, "%{public}s jsSceneSession is null", where); 1164 return; 1165 } 1166 jsSceneSession->TerminateSession(info); 1167 }); 1168 TLOGD(WmsLogTag::WMS_LIFE, "success"); 1169 } 1170 ProcessTerminateSessionRegisterNew()1171 void JsSceneSession::ProcessTerminateSessionRegisterNew() 1172 { 1173 TLOGD(WmsLogTag::WMS_LIFE, "begin"); 1174 auto session = weakSession_.promote(); 1175 if (session == nullptr) { 1176 TLOGE(WmsLogTag::WMS_LIFE, "session is nullptr, id:%{public}d", persistentId_); 1177 return; 1178 } 1179 const char* const where = __func__; 1180 session->SetTerminateSessionListenerNew([weakThis = wptr(this), where]( 1181 const SessionInfo& info, bool needStartCaller, bool isFromBroker) { 1182 auto jsSceneSession = weakThis.promote(); 1183 if (!jsSceneSession) { 1184 TLOGNE(WmsLogTag::WMS_LIFE, "%{public}s jsSceneSession is null", where); 1185 return; 1186 } 1187 jsSceneSession->TerminateSessionNew(info, needStartCaller, isFromBroker); 1188 }); 1189 TLOGD(WmsLogTag::WMS_LIFE, "success"); 1190 } 1191 ProcessTerminateSessionRegisterTotal()1192 void JsSceneSession::ProcessTerminateSessionRegisterTotal() 1193 { 1194 TLOGD(WmsLogTag::WMS_LIFE, "begin"); 1195 auto session = weakSession_.promote(); 1196 if (session == nullptr) { 1197 TLOGE(WmsLogTag::WMS_LIFE, "session is nullptr, id:%{public}d", persistentId_); 1198 return; 1199 } 1200 const char* const where = __func__; 1201 session->SetTerminateSessionListenerTotal([weakThis = wptr(this), where]( 1202 const SessionInfo& info, TerminateType terminateType) { 1203 auto jsSceneSession = weakThis.promote(); 1204 if (!jsSceneSession) { 1205 TLOGNE(WmsLogTag::WMS_LIFE, "%{public}s jsSceneSession is null", where); 1206 return; 1207 } 1208 jsSceneSession->TerminateSessionTotal(info, terminateType); 1209 }); 1210 TLOGD(WmsLogTag::WMS_LIFE, "success"); 1211 } 1212 ProcessPendingSessionToForegroundRegister()1213 void JsSceneSession::ProcessPendingSessionToForegroundRegister() 1214 { 1215 TLOGD(WmsLogTag::WMS_LIFE, "begin"); 1216 auto session = weakSession_.promote(); 1217 if (session == nullptr) { 1218 TLOGE(WmsLogTag::WMS_LIFE, "session is nullptr, id:%{public}d", persistentId_); 1219 return; 1220 } 1221 const char* const where = __func__; 1222 session->SetPendingSessionToForegroundListener([weakThis = wptr(this), where](const SessionInfo& info) { 1223 auto jsSceneSession = weakThis.promote(); 1224 if (!jsSceneSession) { 1225 TLOGNE(WmsLogTag::WMS_LIFE, "%{public}s jsSceneSession is null", where); 1226 return; 1227 } 1228 jsSceneSession->PendingSessionToForeground(info); 1229 }); 1230 TLOGD(WmsLogTag::WMS_LIFE, "success"); 1231 } 1232 ProcessPendingSessionToBackgroundForDelegatorRegister()1233 void JsSceneSession::ProcessPendingSessionToBackgroundForDelegatorRegister() 1234 { 1235 TLOGD(WmsLogTag::WMS_LIFE, "in"); 1236 auto session = weakSession_.promote(); 1237 if (session == nullptr) { 1238 TLOGE(WmsLogTag::WMS_LIFE, "session is nullptr, id:%{public}d", persistentId_); 1239 return; 1240 } 1241 const char* const where = __func__; 1242 session->SetPendingSessionToBackgroundForDelegatorListener([weakThis = wptr(this), where]( 1243 const SessionInfo& info, bool shouldBackToCaller) { 1244 auto jsSceneSession = weakThis.promote(); 1245 if (!jsSceneSession) { 1246 TLOGNE(WmsLogTag::WMS_LIFE, "%{public}s jsSceneSession is null", where); 1247 return; 1248 } 1249 jsSceneSession->PendingSessionToBackgroundForDelegator(info, shouldBackToCaller); 1250 }); 1251 TLOGD(WmsLogTag::WMS_LIFE, "success"); 1252 } 1253 ProcessSessionExceptionRegister()1254 void JsSceneSession::ProcessSessionExceptionRegister() 1255 { 1256 TLOGD(WmsLogTag::WMS_LIFE, "in"); 1257 auto session = weakSession_.promote(); 1258 if (session == nullptr) { 1259 TLOGE(WmsLogTag::WMS_LIFE, "session is nullptr, id:%{public}d", persistentId_); 1260 return; 1261 } 1262 const char* const where = __func__; 1263 session->SetSessionExceptionListener([weakThis = wptr(this), where](const SessionInfo& info, 1264 bool needRemoveSession, bool startFail) { 1265 auto jsSceneSession = weakThis.promote(); 1266 if (!jsSceneSession) { 1267 TLOGNE(WmsLogTag::WMS_LIFE, "%{public}s jsSceneSession is null", where); 1268 return; 1269 } 1270 jsSceneSession->OnSessionException(info, needRemoveSession, startFail); 1271 }, true); 1272 } 1273 1274 /** @note @window.hierarchy */ ProcessSessionTopmostChangeRegister()1275 void JsSceneSession::ProcessSessionTopmostChangeRegister() 1276 { 1277 auto sessionchangeCallback = sessionchangeCallback_.promote(); 1278 if (sessionchangeCallback == nullptr) { 1279 TLOGE(WmsLogTag::WMS_LAYOUT, "sessionchangeCallback is nullptr"); 1280 return; 1281 } 1282 sessionchangeCallback->onSessionTopmostChange_ = [weakThis = wptr(this)](bool topmost) { 1283 auto jsSceneSession = weakThis.promote(); 1284 if (!jsSceneSession) { 1285 TLOGE(WmsLogTag::WMS_LIFE, "ProcessSessionTopmostChangeRegister jsSceneSession is null"); 1286 return; 1287 } 1288 jsSceneSession->OnSessionTopmostChange(topmost); 1289 }; 1290 auto session = weakSession_.promote(); 1291 if (session == nullptr) { 1292 TLOGE(WmsLogTag::WMS_LAYOUT, "session is nullptr, id:%{public}d", persistentId_); 1293 return; 1294 } 1295 sessionchangeCallback->onSessionTopmostChange_(session->IsTopmost()); 1296 TLOGD(WmsLogTag::WMS_LAYOUT, "ProcessSessionTopmostChangeRegister success"); 1297 } 1298 1299 /** @note @window.hierarchy */ ProcessMainWindowTopmostChangeRegister()1300 void JsSceneSession::ProcessMainWindowTopmostChangeRegister() 1301 { 1302 auto session = weakSession_.promote(); 1303 if (session == nullptr) { 1304 TLOGE(WmsLogTag::WMS_HIERARCHY, "session is nullptr, id:%{public}d", persistentId_); 1305 return; 1306 } 1307 const char* const where = __func__; 1308 session->SetMainWindowTopmostChangeCallback([weakThis = wptr(this), where](bool isTopmost) { 1309 auto jsSceneSession = weakThis.promote(); 1310 if (!jsSceneSession) { 1311 TLOGNE(WmsLogTag::WMS_HIERARCHY, "%{public}s jsSceneSession is null", where); 1312 return; 1313 } 1314 jsSceneSession->OnMainWindowTopmostChange(isTopmost); 1315 }); 1316 TLOGD(WmsLogTag::WMS_HIERARCHY, "register success"); 1317 } 1318 ProcessSubModalTypeChangeRegister()1319 void JsSceneSession::ProcessSubModalTypeChangeRegister() 1320 { 1321 auto session = weakSession_.promote(); 1322 if (session == nullptr) { 1323 TLOGE(WmsLogTag::WMS_HIERARCHY, "session is nullptr, persistentId:%{public}d", persistentId_); 1324 return; 1325 } 1326 const char* const where = __func__; 1327 session->RegisterSubModalTypeChangeCallback([weakThis = wptr(this), where](SubWindowModalType subWindowModalType) { 1328 auto jsSceneSession = weakThis.promote(); 1329 if (!jsSceneSession) { 1330 TLOGNE(WmsLogTag::WMS_LIFE, "%{public}s jsSceneSession is null", where); 1331 return; 1332 } 1333 jsSceneSession->OnSubModalTypeChange(subWindowModalType); 1334 }); 1335 TLOGD(WmsLogTag::WMS_HIERARCHY, "register success, persistentId:%{public}d", persistentId_); 1336 } 1337 ProcessMainModalTypeChangeRegister()1338 void JsSceneSession::ProcessMainModalTypeChangeRegister() 1339 { 1340 auto session = weakSession_.promote(); 1341 if (session == nullptr) { 1342 TLOGE(WmsLogTag::WMS_LIFE, "session is nullptr, persistentId:%{public}d", persistentId_); 1343 return; 1344 } 1345 const char* const where = __func__; 1346 session->RegisterMainModalTypeChangeCallback([weakThis = wptr(this), where](bool isModal) { 1347 auto jsSceneSession = weakThis.promote(); 1348 if (!jsSceneSession) { 1349 TLOGNE(WmsLogTag::WMS_LIFE, "%{public}s jsSceneSession is null", where); 1350 return; 1351 } 1352 jsSceneSession->OnMainModalTypeChange(isModal); 1353 }); 1354 TLOGD(WmsLogTag::WMS_HIERARCHY, "register success, persistentId:%{public}d", persistentId_); 1355 } 1356 ProcessSessionFocusableChangeRegister()1357 void JsSceneSession::ProcessSessionFocusableChangeRegister() 1358 { 1359 NotifySessionFocusableChangeFunc func = [weakThis = wptr(this)](bool isFocusable) { 1360 auto jsSceneSession = weakThis.promote(); 1361 if (!jsSceneSession) { 1362 TLOGE(WmsLogTag::WMS_LIFE, "ProcessSessionFocusableChangeRegister jsSceneSession is null"); 1363 return; 1364 } 1365 jsSceneSession->OnSessionFocusableChange(isFocusable); 1366 }; 1367 auto session = weakSession_.promote(); 1368 if (session == nullptr) { 1369 WLOGFE("[WMSComm]session is nullptr, id:%{public}d", persistentId_); 1370 return; 1371 } 1372 session->SetSessionFocusableChangeListener(func); 1373 TLOGD(WmsLogTag::WMS_FOCUS, "ProcessSessionFocusableChangeRegister success"); 1374 } 1375 ProcessSessionTouchableChangeRegister()1376 void JsSceneSession::ProcessSessionTouchableChangeRegister() 1377 { 1378 NotifySessionTouchableChangeFunc func = [weakThis = wptr(this)](bool touchable) { 1379 auto jsSceneSession = weakThis.promote(); 1380 if (!jsSceneSession) { 1381 TLOGE(WmsLogTag::WMS_LIFE, "ProcessSessionTouchableChangeRegister jsSceneSession is null"); 1382 return; 1383 } 1384 jsSceneSession->OnSessionTouchableChange(touchable); 1385 }; 1386 auto session = weakSession_.promote(); 1387 if (session == nullptr) { 1388 WLOGFE("session is nullptr, id:%{public}d", persistentId_); 1389 return; 1390 } 1391 session->SetSessionTouchableChangeListener(func); 1392 WLOGFD("ProcessSessionTouchableChangeRegister success"); 1393 } 1394 ProcessClickRegister()1395 void JsSceneSession::ProcessClickRegister() 1396 { 1397 NotifyClickFunc func = [weakThis = wptr(this)]() { 1398 auto jsSceneSession = weakThis.promote(); 1399 if (!jsSceneSession) { 1400 TLOGE(WmsLogTag::WMS_LIFE, "ProcessClickRegister jsSceneSession is null"); 1401 return; 1402 } 1403 jsSceneSession->OnClick(); 1404 }; 1405 auto session = weakSession_.promote(); 1406 if (session == nullptr) { 1407 WLOGFE("session is nullptr, id:%{public}d", persistentId_); 1408 return; 1409 } 1410 session->SetClickListener(func); 1411 WLOGFD("ProcessClickChangeRegister success"); 1412 } 1413 ProcessContextTransparentRegister()1414 void JsSceneSession::ProcessContextTransparentRegister() 1415 { 1416 NotifyContextTransparentFunc func = [weakThis = wptr(this)]() { 1417 auto jsSceneSession = weakThis.promote(); 1418 if (!jsSceneSession) { 1419 TLOGE(WmsLogTag::WMS_LIFE, "ProcessContextTransparentRegister jsSceneSession is null"); 1420 return; 1421 } 1422 jsSceneSession->OnContextTransparent(); 1423 }; 1424 auto session = weakSession_.promote(); 1425 if (session == nullptr) { 1426 WLOGFE("session is nullptr, id:%{public}d", persistentId_); 1427 return; 1428 } 1429 session->SetContextTransparentFunc(func); 1430 WLOGFD("ProcessContextTransparentRegister success"); 1431 } 1432 OnSessionEvent(uint32_t eventId,const SessionEventParam & param)1433 void JsSceneSession::OnSessionEvent(uint32_t eventId, const SessionEventParam& param) 1434 { 1435 WLOGFI("[NAPI]OnSessionEvent, eventId: %{public}d", eventId); 1436 1437 auto task = [weakThis = wptr(this), persistentId = persistentId_, eventId, param, env = env_] { 1438 auto jsSceneSession = weakThis.promote(); 1439 if (!jsSceneSession || jsSceneSessionMap_.find(persistentId) == jsSceneSessionMap_.end()) { 1440 TLOGE(WmsLogTag::WMS_LIFE, "OnSessionEvent jsSceneSession id:%{public}d has been destroyed", 1441 persistentId); 1442 return; 1443 } 1444 auto jsCallBack = jsSceneSession->GetJSCallback(SESSION_EVENT_CB); 1445 if (jsCallBack == nullptr) { 1446 WLOGFE("[NAPI]jsCallBack is nullptr"); 1447 return; 1448 } 1449 napi_value jsSessionStateObj = CreateJsValue(env, eventId); 1450 napi_value jsSessionParamObj = CreateJsSessionEventParam(env, param); 1451 napi_value argv[] = {jsSessionStateObj, jsSessionParamObj}; 1452 napi_call_function(env, NapiGetUndefined(env), jsCallBack->GetNapiValue(), ArraySize(argv), argv, nullptr); 1453 }; 1454 std::unique_ptr<NapiAsyncTask::ExecuteCallback> execute = nullptr; 1455 taskScheduler_->PostMainThreadTask(task, "OnSessionEvent, EventId:" + std::to_string(eventId)); 1456 } 1457 ProcessBackPressedRegister()1458 void JsSceneSession::ProcessBackPressedRegister() 1459 { 1460 auto session = weakSession_.promote(); 1461 if (session == nullptr) { 1462 TLOGE(WmsLogTag::WMS_LIFE, "session is nullptr, id:%{public}d", persistentId_); 1463 return; 1464 } 1465 const char* const where = __func__; 1466 session->SetBackPressedListenser([weakThis = wptr(this), where](bool needMoveToBackground) { 1467 auto jsSceneSession = weakThis.promote(); 1468 if (!jsSceneSession) { 1469 TLOGNE(WmsLogTag::WMS_LIFE, "%{public}s jsSceneSession is null", where); 1470 return; 1471 } 1472 jsSceneSession->OnBackPressed(needMoveToBackground); 1473 }); 1474 } 1475 ProcessSystemBarPropertyChangeRegister()1476 void JsSceneSession::ProcessSystemBarPropertyChangeRegister() 1477 { 1478 auto session = weakSession_.promote(); 1479 if (session == nullptr) { 1480 TLOGE(WmsLogTag::WMS_IMMS, "session is null, id:%{public}d", persistentId_); 1481 return; 1482 } 1483 session->RegisterSystemBarPropertyChangeCallback([weakThis = wptr(this)]( 1484 const std::unordered_map<WindowType, SystemBarProperty>& propertyMap) { 1485 auto jsSceneSession = weakThis.promote(); 1486 if (!jsSceneSession) { 1487 TLOGNE(WmsLogTag::WMS_LIFE, "jsSceneSession is null"); 1488 return; 1489 } 1490 jsSceneSession->OnSystemBarPropertyChange(propertyMap); 1491 }); 1492 } 1493 ProcessNeedAvoidRegister()1494 void JsSceneSession::ProcessNeedAvoidRegister() 1495 { 1496 auto session = weakSession_.promote(); 1497 if (session == nullptr) { 1498 TLOGE(WmsLogTag::WMS_IMMS, "session is null, id: %{public}d", persistentId_); 1499 return; 1500 } 1501 session->RegisterNeedAvoidCallback([weakThis = wptr(this)](bool status) { 1502 auto jsSceneSession = weakThis.promote(); 1503 if (!jsSceneSession) { 1504 TLOGNE(WmsLogTag::WMS_IMMS, "jsSceneSession is null"); 1505 return; 1506 } 1507 jsSceneSession->OnNeedAvoid(status); 1508 }); 1509 } 1510 ProcessIsCustomAnimationPlaying()1511 void JsSceneSession::ProcessIsCustomAnimationPlaying() 1512 { 1513 auto session = weakSession_.promote(); 1514 if (session == nullptr) { 1515 TLOGE(WmsLogTag::WMS_LIFE, "session is nullptr"); 1516 return; 1517 } 1518 session->RegisterIsCustomAnimationPlayingCallback([weakThis = wptr(this)](bool status) { 1519 auto jsSceneSession = weakThis.promote(); 1520 if (!jsSceneSession) { 1521 TLOGNE(WmsLogTag::WMS_LIFE, "jsSceneSession is null"); 1522 return; 1523 } 1524 jsSceneSession->OnIsCustomAnimationPlaying(status); 1525 }); 1526 } 1527 ProcessShowWhenLockedRegister()1528 void JsSceneSession::ProcessShowWhenLockedRegister() 1529 { 1530 auto session = weakSession_.promote(); 1531 if (session == nullptr) { 1532 TLOGE(WmsLogTag::WMS_LIFE, "session is nullptr, id:%{public}d", persistentId_); 1533 return; 1534 } 1535 const char* const where = __func__; 1536 session->RegisterShowWhenLockedCallback([weakThis = wptr(this), where](bool showWhenLocked) { 1537 auto jsSceneSession = weakThis.promote(); 1538 if (!jsSceneSession) { 1539 TLOGNE(WmsLogTag::WMS_LIFE, "%{public}s jsSceneSession is null", where); 1540 return; 1541 } 1542 jsSceneSession->OnShowWhenLocked(showWhenLocked); 1543 }); 1544 TLOGD(WmsLogTag::WMS_LIFE, "success"); 1545 } 1546 ProcessRequestedOrientationChange()1547 void JsSceneSession::ProcessRequestedOrientationChange() 1548 { 1549 auto session = weakSession_.promote(); 1550 if (session == nullptr) { 1551 TLOGE(WmsLogTag::WMS_LIFE, "session is nullptr"); 1552 return; 1553 } 1554 session->RegisterRequestedOrientationChangeCallback([weakThis = wptr(this)](uint32_t orientation) { 1555 auto jsSceneSession = weakThis.promote(); 1556 if (!jsSceneSession) { 1557 TLOGNE(WmsLogTag::WMS_LIFE, "jsSceneSession is null"); 1558 return; 1559 } 1560 jsSceneSession->OnReuqestedOrientationChange(orientation); 1561 }); 1562 } 1563 ProcessForceHideChangeRegister()1564 void JsSceneSession::ProcessForceHideChangeRegister() 1565 { 1566 auto session = weakSession_.promote(); 1567 if (session == nullptr) { 1568 TLOGE(WmsLogTag::WMS_LIFE, "session is nullptr, id:%{public}d", persistentId_); 1569 return; 1570 } 1571 const char* const where = __func__; 1572 session->RegisterForceHideChangeCallback([weakThis = wptr(this), where](bool hide) { 1573 auto jsSceneSession = weakThis.promote(); 1574 if (!jsSceneSession) { 1575 TLOGNE(WmsLogTag::WMS_LIFE, "%{public}s jsSceneSession is null", where); 1576 return; 1577 } 1578 jsSceneSession->OnForceHideChange(hide); 1579 }); 1580 TLOGD(WmsLogTag::WMS_LIFE, "success"); 1581 } 1582 OnForceHideChange(bool hide)1583 void JsSceneSession::OnForceHideChange(bool hide) 1584 { 1585 WLOGFI("[NAPI]OnForceHideChange, hide: %{public}u", hide); 1586 1587 auto task = [weakThis = wptr(this), persistentId = persistentId_, hide, env = env_] { 1588 auto jsSceneSession = weakThis.promote(); 1589 if (!jsSceneSession || jsSceneSessionMap_.find(persistentId) == jsSceneSessionMap_.end()) { 1590 TLOGE(WmsLogTag::WMS_LIFE, "OnForceHideChange jsSceneSession id:%{public}d has been destroyed", 1591 persistentId); 1592 return; 1593 } 1594 auto jsCallBack = jsSceneSession->GetJSCallback(FORCE_HIDE_CHANGE_CB); 1595 if (!jsCallBack) { 1596 WLOGFE("[NAPI]jsCallBack is nullptr"); 1597 return; 1598 } 1599 napi_value jsSessionForceHideObj = CreateJsValue(env, hide); 1600 napi_value argv[] = {jsSessionForceHideObj}; 1601 napi_call_function(env, NapiGetUndefined(env), jsCallBack->GetNapiValue(), ArraySize(argv), argv, nullptr); 1602 }; 1603 taskScheduler_->PostMainThreadTask(task, "OnForceHideChange, hide:" + std::to_string(hide)); 1604 } 1605 ProcessTouchOutsideRegister()1606 void JsSceneSession::ProcessTouchOutsideRegister() 1607 { 1608 auto session = weakSession_.promote(); 1609 if (session == nullptr) { 1610 TLOGE(WmsLogTag::WMS_LIFE, "session is nullptr"); 1611 return; 1612 } 1613 session->RegisterTouchOutsideCallback([weakThis = wptr(this)] { 1614 auto jsSceneSession = weakThis.promote(); 1615 if (!jsSceneSession) { 1616 TLOGNE(WmsLogTag::WMS_LIFE, "jsSceneSession is null"); 1617 return; 1618 } 1619 jsSceneSession->OnTouchOutside(); 1620 }); 1621 } 1622 OnTouchOutside()1623 void JsSceneSession::OnTouchOutside() 1624 { 1625 WLOGFI("[NAPI]OnTouchOutside"); 1626 auto task = [weakThis = wptr(this), persistentId = persistentId_, env = env_] { 1627 auto jsSceneSession = weakThis.promote(); 1628 if (!jsSceneSession || jsSceneSessionMap_.find(persistentId) == jsSceneSessionMap_.end()) { 1629 TLOGE(WmsLogTag::WMS_LIFE, "OnTouchOutside jsSceneSession id:%{public}d has been destroyed", 1630 persistentId); 1631 return; 1632 } 1633 auto jsCallBack = jsSceneSession->GetJSCallback(TOUCH_OUTSIDE_CB); 1634 if (!jsCallBack) { 1635 WLOGFE("[NAPI]jsCallBack is nullptr"); 1636 return; 1637 } 1638 napi_value argv[] = {}; 1639 napi_call_function(env, NapiGetUndefined(env), jsCallBack->GetNapiValue(), 0, argv, nullptr); 1640 }; 1641 taskScheduler_->PostMainThreadTask(task); 1642 } 1643 ProcessFrameLayoutFinishRegister()1644 void JsSceneSession::ProcessFrameLayoutFinishRegister() 1645 { 1646 NotifyFrameLayoutFinishFunc func = [weakThis = wptr(this)]() { 1647 auto jsSceneSession = weakThis.promote(); 1648 if (!jsSceneSession) { 1649 TLOGE(WmsLogTag::WMS_LIFE, "ProcessFrameLayoutFinishRegister jsSceneSession is null"); 1650 return; 1651 } 1652 jsSceneSession->NotifyFrameLayoutFinish(); 1653 }; 1654 auto session = weakSession_.promote(); 1655 if (session == nullptr) { 1656 TLOGI(WmsLogTag::WMS_MULTI_WINDOW, "session is nullptr"); 1657 return; 1658 } 1659 session->SetFrameLayoutFinishListener(func); 1660 TLOGD(WmsLogTag::WMS_MULTI_WINDOW, "success"); 1661 } 1662 NotifyFrameLayoutFinish()1663 void JsSceneSession::NotifyFrameLayoutFinish() 1664 { 1665 TLOGI(WmsLogTag::WMS_MULTI_WINDOW, "[NAPI]NotifyFrameLayoutFinish"); 1666 auto session = weakSession_.promote(); 1667 if (session == nullptr) { 1668 TLOGE(WmsLogTag::WMS_MULTI_WINDOW, "session is nullptr"); 1669 return; 1670 } 1671 auto task = [weakThis = wptr(this), persistentId = persistentId_, env = env_] { 1672 auto jsSceneSession = weakThis.promote(); 1673 if (!jsSceneSession || jsSceneSessionMap_.find(persistentId) == jsSceneSessionMap_.end()) { 1674 TLOGE(WmsLogTag::WMS_MULTI_WINDOW, "jsSceneSession id:%{public}d has been destroyed", persistentId); 1675 return; 1676 } 1677 auto jsCallBack = jsSceneSession->GetJSCallback(NEXT_FRAME_LAYOUT_FINISH_CB); 1678 if (!jsCallBack) { 1679 TLOGE(WmsLogTag::WMS_MULTI_WINDOW, "[NAPI]jsCallBack is nullptr"); 1680 return; 1681 } 1682 napi_value argv[] = {}; 1683 napi_call_function(env, NapiGetUndefined(env), jsCallBack->GetNapiValue(), 0, argv, nullptr); 1684 }; 1685 taskScheduler_->PostMainThreadTask(task, "NotifyFrameLayoutFinish"); 1686 } 1687 Finalizer(napi_env env,void * data,void * hint)1688 void JsSceneSession::Finalizer(napi_env env, void* data, void* hint) 1689 { 1690 WLOGI("[NAPI]Finalizer"); 1691 auto jsSceneSession = static_cast<JsSceneSession*>(data); 1692 if (jsSceneSession == nullptr) { 1693 TLOGE(WmsLogTag::WMS_LIFE, "JsSceneSession is nullptr"); 1694 return; 1695 } 1696 jsSceneSession->DecStrongRef(nullptr); 1697 } 1698 RegisterCallback(napi_env env,napi_callback_info info)1699 napi_value JsSceneSession::RegisterCallback(napi_env env, napi_callback_info info) 1700 { 1701 WLOGD("[NAPI]RegisterCallback"); 1702 JsSceneSession* me = CheckParamsAndGetThis<JsSceneSession>(env, info); 1703 return (me != nullptr) ? me->OnRegisterCallback(env, info) : nullptr; 1704 } 1705 UpdateNativeVisibility(napi_env env,napi_callback_info info)1706 napi_value JsSceneSession::UpdateNativeVisibility(napi_env env, napi_callback_info info) 1707 { 1708 if (Session::IsScbCoreEnabled()) { 1709 return nullptr; 1710 } 1711 WLOGI("[NAPI]UpdateNativeVisibility"); 1712 JsSceneSession* me = CheckParamsAndGetThis<JsSceneSession>(env, info); 1713 return (me != nullptr) ? me->OnUpdateNativeVisibility(env, info) : nullptr; 1714 } 1715 SetPrivacyMode(napi_env env,napi_callback_info info)1716 napi_value JsSceneSession::SetPrivacyMode(napi_env env, napi_callback_info info) 1717 { 1718 WLOGI("[NAPI]SetPrivacyMode"); 1719 JsSceneSession* me = CheckParamsAndGetThis<JsSceneSession>(env, info); 1720 return (me != nullptr) ? me->OnSetPrivacyMode(env, info) : nullptr; 1721 } 1722 SetSkipSelfWhenShowOnVirtualScreen(napi_env env,napi_callback_info info)1723 napi_value JsSceneSession::SetSkipSelfWhenShowOnVirtualScreen(napi_env env, napi_callback_info info) 1724 { 1725 WLOGI("[NAPI]SetSkipSelfWhenShowOnVirtualScreen"); 1726 JsSceneSession* me = CheckParamsAndGetThis<JsSceneSession>(env, info); 1727 return (me != nullptr) ? me->OnSetSkipSelfWhenShowOnVirtualScreen(env, info) : nullptr; 1728 } 1729 SetSystemSceneOcclusionAlpha(napi_env env,napi_callback_info info)1730 napi_value JsSceneSession::SetSystemSceneOcclusionAlpha(napi_env env, napi_callback_info info) 1731 { 1732 WLOGI("[NAPI]SetSystemSceneOcclusionAlpha"); 1733 JsSceneSession* me = CheckParamsAndGetThis<JsSceneSession>(env, info); 1734 return (me != nullptr) ? me->OnSetSystemSceneOcclusionAlpha(env, info) : nullptr; 1735 } 1736 SetSystemSceneForceUIFirst(napi_env env,napi_callback_info info)1737 napi_value JsSceneSession::SetSystemSceneForceUIFirst(napi_env env, napi_callback_info info) 1738 { 1739 TLOGD(WmsLogTag::DEFAULT, "[NAPI]"); 1740 JsSceneSession* me = CheckParamsAndGetThis<JsSceneSession>(env, info); 1741 return (me != nullptr) ? me->OnSetSystemSceneForceUIFirst(env, info) : nullptr; 1742 } 1743 MarkSystemSceneUIFirst(napi_env env,napi_callback_info info)1744 napi_value JsSceneSession::MarkSystemSceneUIFirst(napi_env env, napi_callback_info info) 1745 { 1746 TLOGD(WmsLogTag::DEFAULT, "[NAPI]"); 1747 JsSceneSession* me = CheckParamsAndGetThis<JsSceneSession>(env, info); 1748 return (me != nullptr) ? me->OnMarkSystemSceneUIFirst(env, info) : nullptr; 1749 } 1750 SetFocusable(napi_env env,napi_callback_info info)1751 napi_value JsSceneSession::SetFocusable(napi_env env, napi_callback_info info) 1752 { 1753 TLOGD(WmsLogTag::WMS_FOCUS, "[NAPI]SetFocusable"); 1754 JsSceneSession* me = CheckParamsAndGetThis<JsSceneSession>(env, info); 1755 return (me != nullptr) ? me->OnSetFocusable(env, info) : nullptr; 1756 } 1757 SetFocusableOnShow(napi_env env,napi_callback_info info)1758 napi_value JsSceneSession::SetFocusableOnShow(napi_env env, napi_callback_info info) 1759 { 1760 TLOGD(WmsLogTag::WMS_FOCUS, "[NAPI]"); 1761 JsSceneSession* me = CheckParamsAndGetThis<JsSceneSession>(env, info); 1762 return (me != nullptr) ? me->OnSetFocusableOnShow(env, info) : nullptr; 1763 } 1764 SetSystemSceneBlockingFocus(napi_env env,napi_callback_info info)1765 napi_value JsSceneSession::SetSystemSceneBlockingFocus(napi_env env, napi_callback_info info) 1766 { 1767 TLOGD(WmsLogTag::WMS_FOCUS, "[NAPI]SetSystemSceneBlockingFocus"); 1768 JsSceneSession* me = CheckParamsAndGetThis<JsSceneSession>(env, info); 1769 return (me != nullptr) ? me->OnSetSystemSceneBlockingFocus(env, info) : nullptr; 1770 } 1771 UpdateSizeChangeReason(napi_env env,napi_callback_info info)1772 napi_value JsSceneSession::UpdateSizeChangeReason(napi_env env, napi_callback_info info) 1773 { 1774 WLOGD("[NAPI]UpdateSizeChangeReason"); 1775 JsSceneSession* me = CheckParamsAndGetThis<JsSceneSession>(env, info); 1776 return (me != nullptr) ? me->OnUpdateSizeChangeReason(env, info) : nullptr; 1777 } 1778 OpenKeyboardSyncTransaction(napi_env env,napi_callback_info info)1779 napi_value JsSceneSession::OpenKeyboardSyncTransaction(napi_env env, napi_callback_info info) 1780 { 1781 TLOGD(WmsLogTag::WMS_KEYBOARD, "[NAPI]OpenKeyboardSyncTransaction"); 1782 JsSceneSession* me = CheckParamsAndGetThis<JsSceneSession>(env, info); 1783 return (me != nullptr) ? me->OnOpenKeyboardSyncTransaction(env, info) : nullptr; 1784 } 1785 CloseKeyboardSyncTransaction(napi_env env,napi_callback_info info)1786 napi_value JsSceneSession::CloseKeyboardSyncTransaction(napi_env env, napi_callback_info info) 1787 { 1788 TLOGD(WmsLogTag::WMS_KEYBOARD, "[NAPI]CloseKeyboardSyncTransaction"); 1789 JsSceneSession* me = CheckParamsAndGetThis<JsSceneSession>(env, info); 1790 return (me != nullptr) ? me->OnCloseKeyboardSyncTransaction(env, info) : nullptr; 1791 } 1792 NotifyTargetScreenWidthAndHeight(napi_env env,napi_callback_info info)1793 napi_value JsSceneSession::NotifyTargetScreenWidthAndHeight(napi_env env, napi_callback_info info) 1794 { 1795 TLOGD(WmsLogTag::WMS_KEYBOARD, "[NAPI]NotifyTargetScreenWidthAndHeight"); 1796 JsSceneSession* me = CheckParamsAndGetThis<JsSceneSession>(env, info); 1797 return (me != nullptr) ? me->OnNotifyTargetScreenWidthAndHeight(env, info) : nullptr; 1798 } 1799 SetShowRecent(napi_env env,napi_callback_info info)1800 napi_value JsSceneSession::SetShowRecent(napi_env env, napi_callback_info info) 1801 { 1802 WLOGI("[NAPI]SetShowRecent"); 1803 JsSceneSession* me = CheckParamsAndGetThis<JsSceneSession>(env, info); 1804 return (me != nullptr) ? me->OnSetShowRecent(env, info) : nullptr; 1805 } 1806 1807 /** @note @window.hierarchy */ SetZOrder(napi_env env,napi_callback_info info)1808 napi_value JsSceneSession::SetZOrder(napi_env env, napi_callback_info info) 1809 { 1810 if (Session::IsScbCoreEnabled()) { 1811 return nullptr; 1812 } 1813 WLOGD("[NAPI]SetZOrder"); 1814 JsSceneSession* me = CheckParamsAndGetThis<JsSceneSession>(env, info); 1815 return (me != nullptr) ? me->OnSetZOrder(env, info) : nullptr; 1816 } 1817 SetTouchable(napi_env env,napi_callback_info info)1818 napi_value JsSceneSession::SetTouchable(napi_env env, napi_callback_info info) 1819 { 1820 JsSceneSession* me = CheckParamsAndGetThis<JsSceneSession>(env, info); 1821 return (me != nullptr) ? me->OnSetTouchable(env, info): nullptr; 1822 } 1823 SetSystemActive(napi_env env,napi_callback_info info)1824 napi_value JsSceneSession::SetSystemActive(napi_env env, napi_callback_info info) 1825 { 1826 JsSceneSession* me = CheckParamsAndGetThis<JsSceneSession>(env, info); 1827 return (me != nullptr) ? me->OnSetSystemActive(env, info): nullptr; 1828 } 1829 SetFloatingScale(napi_env env,napi_callback_info info)1830 napi_value JsSceneSession::SetFloatingScale(napi_env env, napi_callback_info info) 1831 { 1832 WLOGI("[NAPI]SetFloatingScale"); 1833 JsSceneSession* me = CheckParamsAndGetThis<JsSceneSession>(env, info); 1834 return (me != nullptr) ? me->OnSetFloatingScale(env, info) : nullptr; 1835 } 1836 SetIsMidScene(napi_env env,napi_callback_info info)1837 napi_value JsSceneSession::SetIsMidScene(napi_env env, napi_callback_info info) 1838 { 1839 TLOGD(WmsLogTag::WMS_MULTI_WINDOW, "[NAPI]"); 1840 JsSceneSession* me = CheckParamsAndGetThis<JsSceneSession>(env, info); 1841 return (me != nullptr) ? me->OnSetIsMidScene(env, info) : nullptr; 1842 } 1843 SetSCBKeepKeyboard(napi_env env,napi_callback_info info)1844 napi_value JsSceneSession::SetSCBKeepKeyboard(napi_env env, napi_callback_info info) 1845 { 1846 WLOGI("[NAPI]SetSCBKeepKeyboard"); 1847 JsSceneSession* me = CheckParamsAndGetThis<JsSceneSession>(env, info); 1848 return (me != nullptr) ? me->OnSetSCBKeepKeyboard(env, info) : nullptr; 1849 } 1850 SetOffset(napi_env env,napi_callback_info info)1851 napi_value JsSceneSession::SetOffset(napi_env env, napi_callback_info info) 1852 { 1853 if (Session::IsScbCoreEnabled()) { 1854 return nullptr; 1855 } 1856 WLOGI("[NAPI]SetOffset"); 1857 JsSceneSession *me = CheckParamsAndGetThis<JsSceneSession>(env, info); 1858 return (me != nullptr) ? me->OnSetOffset(env, info) : nullptr; 1859 } 1860 SetExitSplitOnBackground(napi_env env,napi_callback_info info)1861 napi_value JsSceneSession::SetExitSplitOnBackground(napi_env env, napi_callback_info info) 1862 { 1863 TLOGD(WmsLogTag::WMS_MULTI_WINDOW, "[NAPI] In"); 1864 JsSceneSession* me = CheckParamsAndGetThis<JsSceneSession>(env, info); 1865 return (me != nullptr) ? me->OnSetExitSplitOnBackground(env, info) : nullptr; 1866 } 1867 SetWaterMarkFlag(napi_env env,napi_callback_info info)1868 napi_value JsSceneSession::SetWaterMarkFlag(napi_env env, napi_callback_info info) 1869 { 1870 JsSceneSession* me = CheckParamsAndGetThis<JsSceneSession>(env, info); 1871 return (me != nullptr) ? me->OnSetWaterMarkFlag(env, info) : nullptr; 1872 } 1873 SetPipActionEvent(napi_env env,napi_callback_info info)1874 napi_value JsSceneSession::SetPipActionEvent(napi_env env, napi_callback_info info) 1875 { 1876 TLOGI(WmsLogTag::WMS_PIP, "[NAPI]SetPipActionEvent"); 1877 JsSceneSession* me = CheckParamsAndGetThis<JsSceneSession>(env, info); 1878 return (me != nullptr) ? me->OnSetPipActionEvent(env, info) : nullptr; 1879 } 1880 SetPiPControlEvent(napi_env env,napi_callback_info info)1881 napi_value JsSceneSession::SetPiPControlEvent(napi_env env, napi_callback_info info) 1882 { 1883 TLOGI(WmsLogTag::WMS_PIP, "[NAPI]"); 1884 JsSceneSession* me = CheckParamsAndGetThis<JsSceneSession>(env, info); 1885 return (me != nullptr) ? me->OnSetPiPControlEvent(env, info) : nullptr; 1886 } 1887 NotifyPipOcclusionChange(napi_env env,napi_callback_info info)1888 napi_value JsSceneSession::NotifyPipOcclusionChange(napi_env env, napi_callback_info info) 1889 { 1890 TLOGD(WmsLogTag::WMS_PIP, "[NAPI]"); 1891 JsSceneSession* me = CheckParamsAndGetThis<JsSceneSession>(env, info); 1892 return (me != nullptr) ? me->OnNotifyPipOcclusionChange(env, info) : nullptr; 1893 } 1894 NotifyDisplayStatusBarTemporarily(napi_env env,napi_callback_info info)1895 napi_value JsSceneSession::NotifyDisplayStatusBarTemporarily(napi_env env, napi_callback_info info) 1896 { 1897 JsSceneSession *me = CheckParamsAndGetThis<JsSceneSession>(env, info); 1898 return (me != nullptr) ? me->OnNotifyDisplayStatusBarTemporarily(env, info) : nullptr; 1899 } 1900 SetTemporarilyShowWhenLocked(napi_env env,napi_callback_info info)1901 napi_value JsSceneSession::SetTemporarilyShowWhenLocked(napi_env env, napi_callback_info info) 1902 { 1903 TLOGI(WmsLogTag::WMS_SCB, "[NAPI]SetTemporarilyShowWhenLocked"); 1904 JsSceneSession *me = CheckParamsAndGetThis<JsSceneSession>(env, info); 1905 return (me != nullptr) ? me->OnSetTemporarilyShowWhenLocked(env, info) : nullptr; 1906 } 1907 SetSkipDraw(napi_env env,napi_callback_info info)1908 napi_value JsSceneSession::SetSkipDraw(napi_env env, napi_callback_info info) 1909 { 1910 TLOGD(WmsLogTag::WMS_SCB, "[NAPI]SetSkipDraw"); 1911 JsSceneSession *me = CheckParamsAndGetThis<JsSceneSession>(env, info); 1912 return (me != nullptr) ? me->OnSetSkipDraw(env, info) : nullptr; 1913 } 1914 SetCompatibleModeInPc(napi_env env,napi_callback_info info)1915 napi_value JsSceneSession::SetCompatibleModeInPc(napi_env env, napi_callback_info info) 1916 { 1917 TLOGI(WmsLogTag::WMS_SCB, "[NAPI]SetCompatibleModeInPc"); 1918 JsSceneSession *me = CheckParamsAndGetThis<JsSceneSession>(env, info); 1919 return (me != nullptr) ? me->OnSetCompatibleModeInPc(env, info) : nullptr; 1920 } 1921 SetCompatibleWindowSizeInPc(napi_env env,napi_callback_info info)1922 napi_value JsSceneSession::SetCompatibleWindowSizeInPc(napi_env env, napi_callback_info info) 1923 { 1924 TLOGD(WmsLogTag::WMS_SCB, "[NAPI] called"); 1925 JsSceneSession* me = CheckParamsAndGetThis<JsSceneSession>(env, info); 1926 return (me != nullptr) ? me->OnSetCompatibleWindowSizeInPc(env, info) : nullptr; 1927 } 1928 SetAppSupportPhoneInPc(napi_env env,napi_callback_info info)1929 napi_value JsSceneSession::SetAppSupportPhoneInPc(napi_env env, napi_callback_info info) 1930 { 1931 TLOGD(WmsLogTag::WMS_SCB, "[NAPI]"); 1932 JsSceneSession* me = CheckParamsAndGetThis<JsSceneSession>(env, info); 1933 return (me != nullptr) ? me->OnSetAppSupportPhoneInPc(env, info) : nullptr; 1934 } 1935 SetUniqueDensityDpiFromSCB(napi_env env,napi_callback_info info)1936 napi_value JsSceneSession::SetUniqueDensityDpiFromSCB(napi_env env, napi_callback_info info) 1937 { 1938 TLOGD(WmsLogTag::WMS_SCB, "[NAPI]"); 1939 JsSceneSession *me = CheckParamsAndGetThis<JsSceneSession>(env, info); 1940 return (me != nullptr) ? me->OnSetUniqueDensityDpiFromSCB(env, info) : nullptr; 1941 } 1942 SetBlankFlag(napi_env env,napi_callback_info info)1943 napi_value JsSceneSession::SetBlankFlag(napi_env env, napi_callback_info info) 1944 { 1945 TLOGD(WmsLogTag::WMS_SCB, "[NAPI]SetBlankFlag"); 1946 JsSceneSession *me = CheckParamsAndGetThis<JsSceneSession>(env, info); 1947 return (me != nullptr) ? me->OnSetBlankFlag(env, info) : nullptr; 1948 } 1949 RemoveBlank(napi_env env,napi_callback_info info)1950 napi_value JsSceneSession::RemoveBlank(napi_env env, napi_callback_info info) 1951 { 1952 TLOGD(WmsLogTag::WMS_SCB, "[NAPI]"); 1953 JsSceneSession* me = CheckParamsAndGetThis<JsSceneSession>(env, info); 1954 return (me != nullptr) ? me->OnRemoveBlank(env, info) : nullptr; 1955 } 1956 SetBufferAvailableCallbackEnable(napi_env env,napi_callback_info info)1957 napi_value JsSceneSession::SetBufferAvailableCallbackEnable(napi_env env, napi_callback_info info) 1958 { 1959 TLOGD(WmsLogTag::WMS_SCB, "[NAPI]SetBufferAvailableCallbackEnable"); 1960 JsSceneSession *me = CheckParamsAndGetThis<JsSceneSession>(env, info); 1961 return (me != nullptr) ? me->OnSetBufferAvailableCallbackEnable(env, info) : nullptr; 1962 } 1963 SyncDefaultRequestedOrientation(napi_env env,napi_callback_info info)1964 napi_value JsSceneSession::SyncDefaultRequestedOrientation(napi_env env, napi_callback_info info) 1965 { 1966 TLOGD(WmsLogTag::WMS_SCB, "[NAPI]"); 1967 JsSceneSession* me = CheckParamsAndGetThis<JsSceneSession>(env, info); 1968 return (me != nullptr) ? me->OnSyncDefaultRequestedOrientation(env, info) : nullptr; 1969 } 1970 SetIsPcAppInPad(napi_env env,napi_callback_info info)1971 napi_value JsSceneSession::SetIsPcAppInPad(napi_env env, napi_callback_info info) 1972 { 1973 TLOGI(WmsLogTag::WMS_SCB, "[NAPI]called"); 1974 JsSceneSession* me = CheckParamsAndGetThis<JsSceneSession>(env, info); 1975 return (me != nullptr) ? me->OnSetIsPcAppInPad(env, info) : nullptr; 1976 } 1977 SetCompatibleModeEnableInPad(napi_env env,napi_callback_info info)1978 napi_value JsSceneSession::SetCompatibleModeEnableInPad(napi_env env, napi_callback_info info) 1979 { 1980 TLOGI(WmsLogTag::WMS_SCB, "[NAPI]"); 1981 JsSceneSession* me = CheckParamsAndGetThis<JsSceneSession>(env, info); 1982 return (me != nullptr) ? me->OnSetCompatibleModeEnableInPad(env, info) : nullptr; 1983 } 1984 IsDeviceWakeupByApplication(napi_env env,napi_callback_info info)1985 napi_value JsSceneSession::IsDeviceWakeupByApplication(napi_env env, napi_callback_info info) 1986 { 1987 TLOGD(WmsLogTag::WMS_SCB, "[NAPI]called"); 1988 JsSceneSession *me = CheckParamsAndGetThis<JsSceneSession>(env, info); 1989 return (me != nullptr) ? me->OnIsDeviceWakeupByApplication(env, info) : nullptr; 1990 } 1991 SetStartingWindowExitAnimationFlag(napi_env env,napi_callback_info info)1992 napi_value JsSceneSession::SetStartingWindowExitAnimationFlag(napi_env env, napi_callback_info info) 1993 { 1994 TLOGD(WmsLogTag::WMS_SCB, "[NAPI]called"); 1995 JsSceneSession *me = CheckParamsAndGetThis<JsSceneSession>(env, info); 1996 return (me != nullptr) ? me->OnSetStartingWindowExitAnimationFlag(env, info) : nullptr; 1997 } 1998 SyncScenePanelGlobalPosition(napi_env env,napi_callback_info info)1999 napi_value JsSceneSession::SyncScenePanelGlobalPosition(napi_env env, napi_callback_info info) 2000 { 2001 TLOGD(WmsLogTag::WMS_SCB, "[NAPI]in"); 2002 JsSceneSession* me = CheckParamsAndGetThis<JsSceneSession>(env, info); 2003 return (me != nullptr) ? me->OnSyncScenePanelGlobalPosition(env, info) : nullptr; 2004 } 2005 UnSyncScenePanelGlobalPosition(napi_env env,napi_callback_info info)2006 napi_value JsSceneSession::UnSyncScenePanelGlobalPosition(napi_env env, napi_callback_info info) 2007 { 2008 TLOGD(WmsLogTag::WMS_SCB, "[NAPI]in"); 2009 JsSceneSession* me = CheckParamsAndGetThis<JsSceneSession>(env, info); 2010 return (me != nullptr) ? me->OnUnSyncScenePanelGlobalPosition(env, info) : nullptr; 2011 } 2012 SetNeedSyncSessionRect(napi_env env,napi_callback_info info)2013 napi_value JsSceneSession::SetNeedSyncSessionRect(napi_env env, napi_callback_info info) 2014 { 2015 TLOGD(WmsLogTag::WMS_PIPELINE, "[NAPI]"); 2016 JsSceneSession* me = CheckParamsAndGetThis<JsSceneSession>(env, info); 2017 return (me != nullptr) ? me->OnSetNeedSyncSessionRect(env, info) : nullptr; 2018 } 2019 SetWindowEnableDragBySystem(napi_env env,napi_callback_info info)2020 napi_value JsSceneSession::SetWindowEnableDragBySystem(napi_env env, napi_callback_info info) 2021 { 2022 TLOGD(WmsLogTag::WMS_SCB, "[NAPI]"); 2023 JsSceneSession* me = CheckParamsAndGetThis<JsSceneSession>(env, info); 2024 return (me != nullptr) ? me->OnSetWindowEnableDragBySystem(env, info) : nullptr; 2025 } 2026 SetIsActivatedAfterScreenLocked(napi_env env,napi_callback_info info)2027 napi_value JsSceneSession::SetIsActivatedAfterScreenLocked(napi_env env, napi_callback_info info) 2028 { 2029 TLOGD(WmsLogTag::WMS_SCB, "[NAPI]"); 2030 JsSceneSession* me = CheckParamsAndGetThis<JsSceneSession>(env, info); 2031 return (me != nullptr) ? me->OnSetIsActivatedAfterScreenLocked(env, info) : nullptr; 2032 } 2033 SetFrameGravity(napi_env env,napi_callback_info info)2034 napi_value JsSceneSession::SetFrameGravity(napi_env env, napi_callback_info info) 2035 { 2036 TLOGD(WmsLogTag::WMS_LAYOUT, "[NAPI]"); 2037 JsSceneSession* me = CheckParamsAndGetThis<JsSceneSession>(env, info); 2038 return (me != nullptr) ? me->OnSetFrameGravity(env, info) : nullptr; 2039 } 2040 SetUseStartingWindowAboveLocked(napi_env env,napi_callback_info info)2041 napi_value JsSceneSession::SetUseStartingWindowAboveLocked(napi_env env, napi_callback_info info) 2042 { 2043 TLOGD(WmsLogTag::WMS_SCB, "[NAPI]"); 2044 JsSceneSession* me = CheckParamsAndGetThis<JsSceneSession>(env, info); 2045 return (me != nullptr) ? me->OnSetUseStartingWindowAboveLocked(env, info) : nullptr; 2046 } 2047 SetFreezeImmediately(napi_env env,napi_callback_info info)2048 napi_value JsSceneSession::SetFreezeImmediately(napi_env env, napi_callback_info info) 2049 { 2050 TLOGD(WmsLogTag::DEFAULT, "in"); 2051 JsSceneSession* me = CheckParamsAndGetThis<JsSceneSession>(env, info); 2052 return (me != nullptr) ? me->OnSetFreezeImmediately(env, info) : nullptr; 2053 } 2054 IsCallbackRegistered(napi_env env,const std::string & type,napi_value jsListenerObject)2055 bool JsSceneSession::IsCallbackRegistered(napi_env env, const std::string& type, napi_value jsListenerObject) 2056 { 2057 HITRACE_METER_FMT(HITRACE_TAG_WINDOW_MANAGER, "JsSceneSession::IsCallbackRegistered[%s]", type.c_str()); 2058 std::shared_lock<std::shared_mutex> lock(jsCbMapMutex_); 2059 if (jsCbMap_.empty() || jsCbMap_.find(type) == jsCbMap_.end()) { 2060 return false; 2061 } 2062 2063 for (auto iter = jsCbMap_.begin(); iter != jsCbMap_.end(); ++iter) { 2064 bool isEquals = false; 2065 napi_strict_equals(env, jsListenerObject, iter->second->GetNapiValue(), &isEquals); 2066 if (isEquals) { 2067 WLOGFE("[NAPI]Method %{public}s has already been registered", type.c_str()); 2068 return true; 2069 } 2070 } 2071 return false; 2072 } 2073 OnRegisterCallback(napi_env env,napi_callback_info info)2074 napi_value JsSceneSession::OnRegisterCallback(napi_env env, napi_callback_info info) 2075 { 2076 size_t argc = 4; 2077 napi_value argv[4] = {nullptr}; 2078 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr); 2079 if (argc < 2) { // 2: params num 2080 WLOGFE("[NAPI]Argc is invalid: %{public}zu", argc); 2081 return NapiGetUndefined(env); 2082 } 2083 std::string cbType; 2084 if (!ConvertFromJsValue(env, argv[0], cbType)) { 2085 WLOGFE("[NAPI]Failed to convert parameter to callbackType"); 2086 return NapiGetUndefined(env); 2087 } 2088 napi_value value = argv[1]; 2089 if (value == nullptr || !NapiIsCallable(env, value)) { 2090 WLOGFE("[NAPI]Invalid argument"); 2091 return NapiGetUndefined(env); 2092 } 2093 auto iterFunctionType = ListenerFuncMap.find(cbType); 2094 if (iterFunctionType == ListenerFuncMap.end()) { 2095 WLOGFE("[NAPI]callback type is not supported, type = %{public}s", cbType.c_str()); 2096 return NapiGetUndefined(env); 2097 } 2098 ListenerFuncType listenerFuncType = iterFunctionType->second; 2099 if (IsCallbackRegistered(env, cbType, value)) { 2100 WLOGFE("[NAPI]callback is registered, type = %{public}s", cbType.c_str()); 2101 return NapiGetUndefined(env); 2102 } 2103 auto session = weakSession_.promote(); 2104 if (session == nullptr) { 2105 WLOGFE("[NAPI]session is nullptr, id:%{public}d", persistentId_); 2106 return NapiGetUndefined(env); 2107 } 2108 2109 std::shared_ptr<NativeReference> callbackRef; 2110 napi_ref result = nullptr; 2111 napi_create_reference(env, value, 1, &result); 2112 callbackRef.reset(reinterpret_cast<NativeReference*>(result)); 2113 { 2114 HITRACE_METER_FMT(HITRACE_TAG_WINDOW_MANAGER, "JsSceneSession set jsCbMap[%s]", cbType.c_str()); 2115 std::unique_lock<std::shared_mutex> lock(jsCbMapMutex_); 2116 jsCbMap_[cbType] = callbackRef; 2117 } 2118 ProcessRegisterCallback(listenerFuncType); 2119 WLOGFD("[NAPI]Register end, type = %{public}s", cbType.c_str()); 2120 return NapiGetUndefined(env); 2121 } 2122 ProcessRegisterCallback(ListenerFuncType listenerFuncType)2123 void JsSceneSession::ProcessRegisterCallback(ListenerFuncType listenerFuncType) 2124 { 2125 switch (static_cast<uint32_t>(listenerFuncType)) { 2126 case static_cast<uint32_t>(ListenerFuncType::PENDING_SCENE_CB): 2127 ProcessPendingSceneSessionActivationRegister(); 2128 break; 2129 case static_cast<uint32_t>(ListenerFuncType::RESTORE_MAIN_WINDOW_CB): 2130 ProcessRestoreMainWindowRegister(); 2131 break; 2132 case static_cast<uint32_t>(ListenerFuncType::CHANGE_SESSION_VISIBILITY_WITH_STATUS_BAR): 2133 ProcessChangeSessionVisibilityWithStatusBarRegister(); 2134 break; 2135 case static_cast<uint32_t>(ListenerFuncType::SESSION_STATE_CHANGE_CB): 2136 ProcessSessionStateChangeRegister(); 2137 break; 2138 case static_cast<uint32_t>(ListenerFuncType::BUFFER_AVAILABLE_CHANGE_CB): 2139 ProcessBufferAvailableChangeRegister(); 2140 break; 2141 case static_cast<uint32_t>(ListenerFuncType::SESSION_EVENT_CB): 2142 ProcessSessionEventRegister(); 2143 break; 2144 case static_cast<uint32_t>(ListenerFuncType::SESSION_RECT_CHANGE_CB): 2145 ProcessSessionRectChangeRegister(); 2146 break; 2147 case static_cast<uint32_t>(ListenerFuncType::SESSION_PIP_CONTROL_STATUS_CHANGE_CB): 2148 ProcessSessionPiPControlStatusChangeRegister(); 2149 break; 2150 case static_cast<uint32_t>(ListenerFuncType::SESSION_AUTO_START_PIP_CB): 2151 ProcessAutoStartPiPStatusChangeRegister(); 2152 break; 2153 case static_cast<uint32_t>(ListenerFuncType::CREATE_SUB_SESSION_CB): 2154 ProcessCreateSubSessionRegister(); 2155 break; 2156 case static_cast<uint32_t>(ListenerFuncType::BIND_DIALOG_TARGET_CB): 2157 ProcessBindDialogTargetRegister(); 2158 break; 2159 case static_cast<uint32_t>(ListenerFuncType::RAISE_TO_TOP_CB): 2160 ProcessRaiseToTopRegister(); 2161 break; 2162 case static_cast<uint32_t>(ListenerFuncType::RAISE_TO_TOP_POINT_DOWN_CB): 2163 ProcessRaiseToTopForPointDownRegister(); 2164 break; 2165 case static_cast<uint32_t>(ListenerFuncType::BACK_PRESSED_CB): 2166 ProcessBackPressedRegister(); 2167 break; 2168 case static_cast<uint32_t>(ListenerFuncType::SESSION_FOCUSABLE_CHANGE_CB): 2169 ProcessSessionFocusableChangeRegister(); 2170 break; 2171 case static_cast<uint32_t>(ListenerFuncType::SESSION_TOUCHABLE_CHANGE_CB): 2172 ProcessSessionTouchableChangeRegister(); 2173 break; 2174 case static_cast<uint32_t>(ListenerFuncType::SESSION_TOP_MOST_CHANGE_CB): 2175 ProcessSessionTopmostChangeRegister(); 2176 break; 2177 case static_cast<uint32_t>(ListenerFuncType::MAIN_WINDOW_TOP_MOST_CHANGE_CB): 2178 ProcessMainWindowTopmostChangeRegister(); 2179 break; 2180 case static_cast<uint32_t>(ListenerFuncType::SUB_MODAL_TYPE_CHANGE_CB): 2181 ProcessSubModalTypeChangeRegister(); 2182 break; 2183 case static_cast<uint32_t>(ListenerFuncType::MAIN_MODAL_TYPE_CHANGE_CB): 2184 ProcessMainModalTypeChangeRegister(); 2185 break; 2186 case static_cast<uint32_t>(ListenerFuncType::CLICK_CB): 2187 ProcessClickRegister(); 2188 break; 2189 case static_cast<uint32_t>(ListenerFuncType::TERMINATE_SESSION_CB): 2190 ProcessTerminateSessionRegister(); 2191 break; 2192 case static_cast<uint32_t>(ListenerFuncType::TERMINATE_SESSION_CB_NEW): 2193 ProcessTerminateSessionRegisterNew(); 2194 break; 2195 case static_cast<uint32_t>(ListenerFuncType::TERMINATE_SESSION_CB_TOTAL): 2196 ProcessTerminateSessionRegisterTotal(); 2197 break; 2198 case static_cast<uint32_t>(ListenerFuncType::SESSION_EXCEPTION_CB): 2199 ProcessSessionExceptionRegister(); 2200 break; 2201 case static_cast<uint32_t>(ListenerFuncType::UPDATE_SESSION_LABEL_CB): 2202 ProcessUpdateSessionLabelRegister(); 2203 break; 2204 case static_cast<uint32_t>(ListenerFuncType::UPDATE_SESSION_ICON_CB): 2205 ProcessUpdateSessionIconRegister(); 2206 break; 2207 case static_cast<uint32_t>(ListenerFuncType::SYSTEMBAR_PROPERTY_CHANGE_CB): 2208 ProcessSystemBarPropertyChangeRegister(); 2209 break; 2210 case static_cast<uint32_t>(ListenerFuncType::NEED_AVOID_CB): 2211 ProcessNeedAvoidRegister(); 2212 break; 2213 case static_cast<uint32_t>(ListenerFuncType::PENDING_SESSION_TO_FOREGROUND_CB): 2214 ProcessPendingSessionToForegroundRegister(); 2215 break; 2216 case static_cast<uint32_t>(ListenerFuncType::PENDING_SESSION_TO_BACKGROUND_FOR_DELEGATOR_CB): 2217 ProcessPendingSessionToBackgroundForDelegatorRegister(); 2218 break; 2219 case static_cast<uint32_t>(ListenerFuncType::CUSTOM_ANIMATION_PLAYING_CB): 2220 ProcessIsCustomAnimationPlaying(); 2221 break; 2222 case static_cast<uint32_t>(ListenerFuncType::NEED_DEFAULT_ANIMATION_FLAG_CHANGE_CB): 2223 ProcessSessionDefaultAnimationFlagChangeRegister(); 2224 break; 2225 case static_cast<uint32_t>(ListenerFuncType::SHOW_WHEN_LOCKED_CB): 2226 ProcessShowWhenLockedRegister(); 2227 break; 2228 case static_cast<uint32_t>(ListenerFuncType::REQUESTED_ORIENTATION_CHANGE_CB): 2229 ProcessRequestedOrientationChange(); 2230 break; 2231 case static_cast<uint32_t>(ListenerFuncType::RAISE_ABOVE_TARGET_CB): 2232 ProcessRaiseAboveTargetRegister(); 2233 break; 2234 case static_cast<uint32_t>(ListenerFuncType::FORCE_HIDE_CHANGE_CB): 2235 ProcessForceHideChangeRegister(); 2236 break; 2237 case static_cast<uint32_t>(ListenerFuncType::WINDOW_DRAG_HOT_AREA_CB): 2238 ProcessWindowDragHotAreaRegister(); 2239 break; 2240 case static_cast<uint32_t>(ListenerFuncType::TOUCH_OUTSIDE_CB): 2241 ProcessTouchOutsideRegister(); 2242 break; 2243 case static_cast<uint32_t>(ListenerFuncType::SESSIONINFO_LOCKEDSTATE_CHANGE_CB): 2244 ProcessSessionInfoLockedStateChangeRegister(); 2245 break; 2246 case static_cast<uint32_t>(ListenerFuncType::PREPARE_CLOSE_PIP_SESSION): 2247 ProcessPrepareClosePiPSessionRegister(); 2248 break; 2249 case static_cast<uint32_t>(ListenerFuncType::LANDSCAPE_MULTI_WINDOW_CB): 2250 ProcessLandscapeMultiWindowRegister(); 2251 break; 2252 case static_cast<uint32_t>(ListenerFuncType::CONTEXT_TRANSPARENT_CB): 2253 ProcessContextTransparentRegister(); 2254 break; 2255 case static_cast<uint32_t>(ListenerFuncType::KEYBOARD_GRAVITY_CHANGE_CB): 2256 ProcessKeyboardGravityChangeRegister(); 2257 break; 2258 case static_cast<uint32_t>(ListenerFuncType::ADJUST_KEYBOARD_LAYOUT_CB): 2259 ProcessAdjustKeyboardLayoutRegister(); 2260 break; 2261 case static_cast<uint32_t>(ListenerFuncType::LAYOUT_FULL_SCREEN_CB): 2262 ProcessLayoutFullScreenChangeRegister(); 2263 break; 2264 case static_cast<uint32_t>(ListenerFuncType::DEFAULT_DENSITY_ENABLED_CB): 2265 ProcessDefaultDensityEnabledRegister(); 2266 break; 2267 case static_cast<uint32_t>(ListenerFuncType::TITLE_DOCK_HOVER_SHOW_CB): 2268 ProcessTitleAndDockHoverShowChangeRegister(); 2269 break; 2270 case static_cast<uint32_t>(ListenerFuncType::NEXT_FRAME_LAYOUT_FINISH_CB): 2271 ProcessFrameLayoutFinishRegister(); 2272 break; 2273 case static_cast<uint32_t>(ListenerFuncType::SET_WINDOW_RECT_AUTO_SAVE_CB): 2274 ProcessSetWindowRectAutoSaveRegister(); 2275 break; 2276 case static_cast<uint32_t>(ListenerFuncType::UPDATE_APP_USE_CONTROL_CB): 2277 RegisterUpdateAppUseControlCallback(); 2278 break; 2279 default: 2280 break; 2281 } 2282 } 2283 OnUpdateNativeVisibility(napi_env env,napi_callback_info info)2284 napi_value JsSceneSession::OnUpdateNativeVisibility(napi_env env, napi_callback_info info) 2285 { 2286 size_t argc = 4; 2287 napi_value argv[4] = {nullptr}; 2288 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr); 2289 if (argc < 1) { // 1: params num 2290 WLOGFE("[NAPI]Argc is invalid: %{public}zu", argc); 2291 return NapiGetUndefined(env); 2292 } 2293 bool visible = false; 2294 if (!ConvertFromJsValue(env, argv[0], visible)) { 2295 WLOGFE("[NAPI]Failed to convert parameter to bool"); 2296 return NapiGetUndefined(env); 2297 } 2298 auto session = weakSession_.promote(); 2299 if (session == nullptr) { 2300 WLOGFE("[NAPI]session is nullptr, id:%{public}d", persistentId_); 2301 return NapiGetUndefined(env); 2302 } 2303 session->UpdateNativeVisibility(visible); 2304 WLOGFI("[NAPI]OnUpdateNativeVisibility end"); 2305 return NapiGetUndefined(env); 2306 } 2307 OnSetPrivacyMode(napi_env env,napi_callback_info info)2308 napi_value JsSceneSession::OnSetPrivacyMode(napi_env env, napi_callback_info info) 2309 { 2310 size_t argc = 4; 2311 napi_value argv[4] = {nullptr}; 2312 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr); 2313 if (argc < 1) { // 1: params num 2314 WLOGFE("[NAPI]Argc is invalid: %{public}zu", argc); 2315 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 2316 "Input parameter is missing or invalid")); 2317 return NapiGetUndefined(env); 2318 } 2319 bool isPrivacy = false; 2320 if (!ConvertFromJsValue(env, argv[0], isPrivacy)) { 2321 WLOGFE("[NAPI]Failed to convert parameter to bool"); 2322 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 2323 "Input parameter is missing or invalid")); 2324 return NapiGetUndefined(env); 2325 } 2326 auto session = weakSession_.promote(); 2327 if (session == nullptr) { 2328 WLOGFE("[NAPI]session is nullptr, id:%{public}d", persistentId_); 2329 return NapiGetUndefined(env); 2330 } 2331 session->SetPrivacyMode(isPrivacy); 2332 SceneSessionManager::GetInstance().UpdatePrivateStateAndNotify(session->GetPersistentId()); 2333 WLOGFI("[NAPI]OnSetPrivacyMode end"); 2334 return NapiGetUndefined(env); 2335 } 2336 OnSetSystemSceneOcclusionAlpha(napi_env env,napi_callback_info info)2337 napi_value JsSceneSession::OnSetSystemSceneOcclusionAlpha(napi_env env, napi_callback_info info) 2338 { 2339 size_t argc = 4; 2340 napi_value argv[4] = {nullptr}; 2341 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr); 2342 if (argc < 1) { // 1: params num 2343 WLOGFE("[NAPI]Argc is invalid: %{public}zu", argc); 2344 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 2345 "Input parameter is missing or invalid")); 2346 return NapiGetUndefined(env); 2347 } 2348 double alpha = 0.f; 2349 if (!ConvertFromJsValue(env, argv[0], alpha)) { 2350 WLOGFE("[NAPI]Failed to convert parameter to bool"); 2351 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 2352 "Input parameter is missing or invalid")); 2353 return NapiGetUndefined(env); 2354 } 2355 auto session = weakSession_.promote(); 2356 if (session == nullptr) { 2357 WLOGFE("[NAPI]session is nullptr, id:%{public}d", persistentId_); 2358 return NapiGetUndefined(env); 2359 } 2360 session->SetSystemSceneOcclusionAlpha(alpha); 2361 WLOGFI("[NAPI]OnSetSystemSceneOcclusionAlpha end"); 2362 return NapiGetUndefined(env); 2363 } 2364 OnSetSystemSceneForceUIFirst(napi_env env,napi_callback_info info)2365 napi_value JsSceneSession::OnSetSystemSceneForceUIFirst(napi_env env, napi_callback_info info) 2366 { 2367 size_t argc = ARG_COUNT_4; 2368 napi_value argv[ARG_COUNT_4] = {nullptr}; 2369 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr); 2370 if (argc < 1) { // 1: params num 2371 TLOGE(WmsLogTag::DEFAULT, "[NAPI]Argc is invalid: %{public}zu", argc); 2372 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 2373 "Input parameter is missing or invalid")); 2374 return NapiGetUndefined(env); 2375 } 2376 bool forceUIFirst = false; 2377 if (!ConvertFromJsValue(env, argv[0], forceUIFirst)) { 2378 TLOGE(WmsLogTag::DEFAULT, "[NAPI]Failed to convert parameter to forceUIFirst"); 2379 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 2380 "Input parameter is missing or invalid")); 2381 return NapiGetUndefined(env); 2382 } 2383 auto session = weakSession_.promote(); 2384 if (session == nullptr) { 2385 TLOGE(WmsLogTag::DEFAULT, "[NAPI]session is nullptr, id:%{public}d", persistentId_); 2386 return NapiGetUndefined(env); 2387 } 2388 session->SetSystemSceneForceUIFirst(forceUIFirst); 2389 TLOGD(WmsLogTag::DEFAULT, "[NAPI] end"); 2390 return NapiGetUndefined(env); 2391 } 2392 OnMarkSystemSceneUIFirst(napi_env env,napi_callback_info info)2393 napi_value JsSceneSession::OnMarkSystemSceneUIFirst(napi_env env, napi_callback_info info) 2394 { 2395 size_t argc = ARG_COUNT_4; 2396 napi_value argv[ARG_COUNT_4] = { nullptr }; 2397 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr); 2398 if (argc < ARGC_TWO) { 2399 TLOGE(WmsLogTag::DEFAULT, "[NAPI]Argc is invalid: %{public}zu", argc); 2400 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 2401 "Input parameter is missing or invalid")); 2402 return NapiGetUndefined(env); 2403 } 2404 bool isForced = false; 2405 if (!ConvertFromJsValue(env, argv[ARG_INDEX_0], isForced)) { 2406 TLOGE(WmsLogTag::DEFAULT, "[NAPI]Failed to convert parameter to isForced"); 2407 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 2408 "Input parameter is missing or invalid")); 2409 return NapiGetUndefined(env); 2410 } 2411 bool isUIFirstEnabled = false; 2412 if (!ConvertFromJsValue(env, argv[ARG_INDEX_1], isUIFirstEnabled)) { 2413 TLOGE(WmsLogTag::DEFAULT, "[NAPI]Failed to convert parameter to isUIFirstEnabled"); 2414 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 2415 "Input parameter is missing or invalid")); 2416 return NapiGetUndefined(env); 2417 } 2418 auto session = weakSession_.promote(); 2419 if (session == nullptr) { 2420 TLOGE(WmsLogTag::DEFAULT, "[NAPI]session is nullptr, id:%{public}d", persistentId_); 2421 return NapiGetUndefined(env); 2422 } 2423 session->MarkSystemSceneUIFirst(isForced, isUIFirstEnabled); 2424 return NapiGetUndefined(env); 2425 } 2426 OnSetFocusable(napi_env env,napi_callback_info info)2427 napi_value JsSceneSession::OnSetFocusable(napi_env env, napi_callback_info info) 2428 { 2429 size_t argc = 4; 2430 napi_value argv[4] = {nullptr}; 2431 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr); 2432 if (argc < 1) { // 1: params num 2433 WLOGFE("[NAPI]Argc is invalid: %{public}zu", argc); 2434 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 2435 "Input parameter is missing or invalid")); 2436 return NapiGetUndefined(env); 2437 } 2438 bool isFocusable = false; 2439 if (!ConvertFromJsValue(env, argv[0], isFocusable)) { 2440 WLOGFE("[NAPI]Failed to convert parameter to bool"); 2441 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 2442 "Input parameter is missing or invalid")); 2443 return NapiGetUndefined(env); 2444 } 2445 auto session = weakSession_.promote(); 2446 if (session == nullptr) { 2447 WLOGFE("[NAPI]session is nullptr, id:%{public}d", persistentId_); 2448 return NapiGetUndefined(env); 2449 } 2450 session->SetFocusable(isFocusable); 2451 TLOGD(WmsLogTag::WMS_FOCUS, "[NAPI] end"); 2452 return NapiGetUndefined(env); 2453 } 2454 OnSetFocusableOnShow(napi_env env,napi_callback_info info)2455 napi_value JsSceneSession::OnSetFocusableOnShow(napi_env env, napi_callback_info info) 2456 { 2457 size_t argc = ARG_COUNT_4; 2458 napi_value argv[ARG_COUNT_4] = {nullptr}; 2459 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr); 2460 if (argc < 1) { // 1: params num 2461 TLOGE(WmsLogTag::WMS_FOCUS, "[NAPI]Argc is invalid: %{public}zu", argc); 2462 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 2463 "Input parameter is missing or invalid")); 2464 return NapiGetUndefined(env); 2465 } 2466 bool isFocusableOnShow = true; 2467 if (!ConvertFromJsValue(env, argv[0], isFocusableOnShow)) { 2468 TLOGE(WmsLogTag::WMS_FOCUS, "[NAPI]Failed to convert parameter to bool"); 2469 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 2470 "Input parameter is missing or invalid")); 2471 return NapiGetUndefined(env); 2472 } 2473 auto session = weakSession_.promote(); 2474 if (session == nullptr) { 2475 TLOGE(WmsLogTag::WMS_FOCUS, "[NAPI]session is nullptr, id:%{public}d", persistentId_); 2476 return NapiGetUndefined(env); 2477 } 2478 session->SetFocusableOnShow(isFocusableOnShow); 2479 TLOGD(WmsLogTag::WMS_FOCUS, "[NAPI] end"); 2480 return NapiGetUndefined(env); 2481 } 2482 OnSetSystemSceneBlockingFocus(napi_env env,napi_callback_info info)2483 napi_value JsSceneSession::OnSetSystemSceneBlockingFocus(napi_env env, napi_callback_info info) 2484 { 2485 size_t argc = 4; 2486 napi_value argv[4] = {nullptr}; 2487 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr); 2488 if (argc < 1) { // 1: params num 2489 WLOGFE("[NAPI]Argc is invalid: %{public}zu", argc); 2490 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 2491 "Input parameter is missing or invalid")); 2492 return NapiGetUndefined(env); 2493 } 2494 bool blocking = false; 2495 if (!ConvertFromJsValue(env, argv[0], blocking)) { 2496 WLOGFE("[NAPI]Failed to convert parameter to bool"); 2497 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 2498 "Input parameter is missing or invalid")); 2499 return NapiGetUndefined(env); 2500 } 2501 auto session = weakSession_.promote(); 2502 if (session == nullptr) { 2503 WLOGFE("[NAPI]session is nullptr, id:%{public}d", persistentId_); 2504 return NapiGetUndefined(env); 2505 } 2506 session->SetSystemSceneBlockingFocus(blocking); 2507 WLOGFI("[NAPI]OnSetSystemSceneBlockingFocus end"); 2508 return NapiGetUndefined(env); 2509 } 2510 OnUpdateSizeChangeReason(napi_env env,napi_callback_info info)2511 napi_value JsSceneSession::OnUpdateSizeChangeReason(napi_env env, napi_callback_info info) 2512 { 2513 size_t argc = 4; 2514 napi_value argv[4] = {nullptr}; 2515 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr); 2516 if (argc < 1) { // 1: params num 2517 WLOGFE("[NAPI]Argc is invalid: %{public}zu", argc); 2518 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 2519 "Input parameter is missing or invalid")); 2520 return NapiGetUndefined(env); 2521 } 2522 SizeChangeReason reason = SizeChangeReason::UNDEFINED; 2523 if (!ConvertFromJsValue(env, argv[0], reason)) { 2524 WLOGFE("[NAPI]Failed to convert parameter to bool"); 2525 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 2526 "Input parameter is missing or invalid")); 2527 return NapiGetUndefined(env); 2528 } 2529 auto session = weakSession_.promote(); 2530 if (session == nullptr) { 2531 WLOGFE("[NAPI]session is nullptr, id:%{public}d", persistentId_); 2532 return NapiGetUndefined(env); 2533 } 2534 session->UpdateSizeChangeReason(reason); 2535 WLOGI("[NAPI]UpdateSizeChangeReason reason: %{public}u end", reason); 2536 return NapiGetUndefined(env); 2537 } 2538 OnOpenKeyboardSyncTransaction(napi_env env,napi_callback_info info)2539 napi_value JsSceneSession::OnOpenKeyboardSyncTransaction(napi_env env, napi_callback_info info) 2540 { 2541 auto session = weakSession_.promote(); 2542 if (session == nullptr) { 2543 TLOGE(WmsLogTag::WMS_KEYBOARD, "[NAPI] session is nullptr, id:%{public}d", persistentId_); 2544 return NapiGetUndefined(env); 2545 } 2546 session->OpenKeyboardSyncTransaction(); 2547 return NapiGetUndefined(env); 2548 } 2549 OnCloseKeyboardSyncTransaction(napi_env env,napi_callback_info info)2550 napi_value JsSceneSession::OnCloseKeyboardSyncTransaction(napi_env env, napi_callback_info info) 2551 { 2552 size_t argc = ARG_COUNT_4; 2553 napi_value argv[ARG_COUNT_4] = {nullptr}; 2554 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr); 2555 if (argc < 3) { // 3: params num 2556 TLOGE(WmsLogTag::WMS_KEYBOARD, "[NAPI]Argc is invalid: %{public}zu", argc); 2557 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 2558 "Input parameter is missing or invalid")); 2559 return NapiGetUndefined(env); 2560 } 2561 2562 WSRect keyboardPanelRect = { 0, 0, 0, 0 }; 2563 napi_value nativeObj = argv[ARG_INDEX_0]; 2564 if (nativeObj == nullptr || !ConvertRectInfoFromJs(env, nativeObj, keyboardPanelRect)) { 2565 TLOGE(WmsLogTag::WMS_KEYBOARD, "[NAPI]Failed to convert parameter to keyboardPanelRect"); 2566 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 2567 "Input parameter is missing or invalid")); 2568 return NapiGetUndefined(env); 2569 } 2570 2571 bool isKeyboardShow = false; 2572 if (!ConvertFromJsValue(env, argv[ARG_INDEX_1], isKeyboardShow)) { 2573 TLOGE(WmsLogTag::WMS_KEYBOARD, "[NAPI]Failed to convert parameter to bool"); 2574 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 2575 "Input parameter is missing or invalid")); 2576 return NapiGetUndefined(env); 2577 } 2578 2579 bool isRotating = false; 2580 if (!ConvertFromJsValue(env, argv[ARG_INDEX_2], isRotating)) { 2581 TLOGE(WmsLogTag::WMS_KEYBOARD, "[NAPI]Failed to convert parameter to bool"); 2582 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 2583 "Input parameter is missing or invalid")); 2584 return NapiGetUndefined(env); 2585 } 2586 2587 auto session = weakSession_.promote(); 2588 if (session == nullptr) { 2589 TLOGE(WmsLogTag::WMS_KEYBOARD, "[NAPI]session is nullptr, id:%{public}d", persistentId_); 2590 return NapiGetUndefined(env); 2591 } 2592 session->CloseKeyboardSyncTransaction(keyboardPanelRect, isKeyboardShow, isRotating); 2593 return NapiGetUndefined(env); 2594 } 2595 OnNotifyTargetScreenWidthAndHeight(napi_env env,napi_callback_info info)2596 napi_value JsSceneSession::OnNotifyTargetScreenWidthAndHeight(napi_env env, napi_callback_info info) 2597 { 2598 size_t argc = ARG_COUNT_4; 2599 napi_value argv[ARG_COUNT_4] = {nullptr}; 2600 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr); 2601 if (argc < ARG_COUNT_3) { 2602 TLOGE(WmsLogTag::WMS_KEYBOARD, "[NAPI]Argc is invalid: %{public}zu", argc); 2603 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 2604 "Input parameter is missing or invalid")); 2605 return NapiGetUndefined(env); 2606 } 2607 2608 bool isScreenAngleMismatch = false; 2609 if (!ConvertFromJsValue(env, argv[ARG_INDEX_0], isScreenAngleMismatch)) { 2610 TLOGE(WmsLogTag::WMS_KEYBOARD, "[NAPI]Failed to convert parameter to bool"); 2611 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 2612 "Input parameter is missing or invalid")); 2613 return NapiGetUndefined(env); 2614 } 2615 2616 uint32_t screenWidth = 0; 2617 if (!ConvertFromJsValue(env, argv[ARG_INDEX_1], screenWidth)) { 2618 TLOGE(WmsLogTag::WMS_KEYBOARD, "[NAPI]Failed to convert parameter to uint32_t"); 2619 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 2620 "Input parameter is missing or invalid")); 2621 return NapiGetUndefined(env); 2622 } 2623 2624 uint32_t screenHeight = 0; 2625 if (!ConvertFromJsValue(env, argv[ARG_INDEX_2], screenHeight)) { 2626 TLOGE(WmsLogTag::WMS_KEYBOARD, "[NAPI]Failed to convert parameter to uint32_t"); 2627 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 2628 "Input parameter is missing or invalid")); 2629 return NapiGetUndefined(env); 2630 } 2631 2632 auto session = weakSession_.promote(); 2633 if (session == nullptr) { 2634 TLOGE(WmsLogTag::WMS_KEYBOARD, "[NAPI]session is nullptr, id:%{public}d", persistentId_); 2635 return NapiGetUndefined(env); 2636 } 2637 session->NotifyTargetScreenWidthAndHeight(isScreenAngleMismatch, screenWidth, screenHeight); 2638 return NapiGetUndefined(env); 2639 } 2640 OnCreateSubSession(const sptr<SceneSession> & sceneSession)2641 void JsSceneSession::OnCreateSubSession(const sptr<SceneSession>& sceneSession) 2642 { 2643 if (sceneSession == nullptr) { 2644 WLOGFE("[NAPI]sceneSession is nullptr"); 2645 return; 2646 } 2647 2648 TLOGI(WmsLogTag::WMS_LIFE, "[NAPI]OnCreateSubSession, id: %{public}d, parentId: %{public}d", 2649 sceneSession->GetPersistentId(), sceneSession->GetParentPersistentId()); 2650 wptr<SceneSession> weakSession(sceneSession); 2651 auto task = [weakThis = wptr(this), persistentId = persistentId_, weakSession, env = env_] { 2652 auto jsSceneSession = weakThis.promote(); 2653 if (!jsSceneSession || jsSceneSessionMap_.find(persistentId) == jsSceneSessionMap_.end()) { 2654 TLOGE(WmsLogTag::WMS_LIFE, "OnCreateSubSession jsSceneSession id:%{public}d has been destroyed", 2655 persistentId); 2656 return; 2657 } 2658 auto jsCallBack = jsSceneSession->GetJSCallback(CREATE_SUB_SESSION_CB); 2659 if (jsCallBack == nullptr) { 2660 WLOGFE("[NAPI]jsCallBack is nullptr"); 2661 return; 2662 } 2663 auto specificSession = weakSession.promote(); 2664 if (specificSession == nullptr) { 2665 TLOGE(WmsLogTag::WMS_LIFE, "[NAPI]root session or target session or env is nullptr"); 2666 return; 2667 } 2668 napi_value jsSceneSessionObj = Create(env, specificSession); 2669 if (jsSceneSessionObj == nullptr || !jsCallBack) { 2670 TLOGE(WmsLogTag::WMS_LIFE, "[NAPI]jsSceneSessionObj or jsCallBack is nullptr"); 2671 return; 2672 } 2673 TLOGI(WmsLogTag::WMS_LIFE, "CreateJsSceneSessionObject success, id: %{public}d, parentId: %{public}d", 2674 specificSession->GetPersistentId(), specificSession->GetParentPersistentId()); 2675 napi_value argv[] = {jsSceneSessionObj}; 2676 napi_call_function(env, NapiGetUndefined(env), jsCallBack->GetNapiValue(), ArraySize(argv), argv, nullptr); 2677 }; 2678 std::string info = "OnCreateSpecificSession PID:" + std::to_string(sceneSession->GetPersistentId()); 2679 taskScheduler_->PostMainThreadTask(task, info); 2680 } 2681 OnBindDialogTarget(const sptr<SceneSession> & sceneSession)2682 void JsSceneSession::OnBindDialogTarget(const sptr<SceneSession>& sceneSession) 2683 { 2684 if (sceneSession == nullptr) { 2685 WLOGFI("[NAPI]sceneSession is nullptr"); 2686 return; 2687 } 2688 2689 TLOGI(WmsLogTag::WMS_DIALOG, "OnBindDialogTarget, id: %{public}d", sceneSession->GetPersistentId()); 2690 2691 wptr<SceneSession> weakSession(sceneSession); 2692 auto task = [weakThis = wptr(this), persistentId = persistentId_, weakSession, env = env_] { 2693 auto jsSceneSession = weakThis.promote(); 2694 if (!jsSceneSession || jsSceneSessionMap_.find(persistentId) == jsSceneSessionMap_.end()) { 2695 TLOGE(WmsLogTag::WMS_LIFE, "OnBindDialogTarget jsSceneSession id:%{public}d has been destroyed", 2696 persistentId); 2697 return; 2698 } 2699 auto jsCallBack = jsSceneSession->GetJSCallback(BIND_DIALOG_TARGET_CB); 2700 if (jsCallBack == nullptr) { 2701 WLOGFE("[NAPI]jsCallBack is nullptr"); 2702 return; 2703 } 2704 auto specificSession = weakSession.promote(); 2705 if (specificSession == nullptr) { 2706 WLOGFE("[NAPI]root session or target session or env is nullptr"); 2707 return; 2708 } 2709 napi_value jsSceneSessionObj = Create(env, specificSession); 2710 if (jsSceneSessionObj == nullptr || !jsCallBack) { 2711 WLOGFE("[NAPI]jsSceneSessionObj or jsCallBack is nullptr"); 2712 return; 2713 } 2714 TLOGI(WmsLogTag::WMS_DIALOG, "CreateJsObject success, id: %{public}d", specificSession->GetPersistentId()); 2715 napi_value argv[] = {jsSceneSessionObj}; 2716 napi_call_function(env, NapiGetUndefined(env), jsCallBack->GetNapiValue(), ArraySize(argv), argv, nullptr); 2717 }; 2718 taskScheduler_->PostMainThreadTask(task, "OnBindDialogTarget, PID:" + 2719 std::to_string(sceneSession->GetPersistentId())); 2720 } 2721 OnSessionStateChange(const SessionState & state)2722 void JsSceneSession::OnSessionStateChange(const SessionState& state) 2723 { 2724 auto session = weakSession_.promote(); 2725 if (session == nullptr) { 2726 TLOGW(WmsLogTag::WMS_LIFE, "session is nullptr, id:%{public}d", persistentId_); 2727 return; 2728 } 2729 2730 TLOGI(WmsLogTag::WMS_LIFE, "id: %{public}d, state: %{public}d", session->GetPersistentId(), state); 2731 auto task = [weakThis = wptr(this), persistentId = persistentId_, state, env = env_] { 2732 auto jsSceneSession = weakThis.promote(); 2733 if (!jsSceneSession || jsSceneSessionMap_.find(persistentId) == jsSceneSessionMap_.end()) { 2734 TLOGE(WmsLogTag::WMS_LIFE, "OnSessionStateChange jsSceneSession id:%{public}d has been destroyed", 2735 persistentId); 2736 return; 2737 } 2738 auto jsCallBack = jsSceneSession->GetJSCallback(SESSION_STATE_CHANGE_CB); 2739 if (!jsCallBack) { 2740 WLOGFE("[NAPI]jsCallBack is nullptr"); 2741 return; 2742 } 2743 napi_value jsSessionStateObj = CreateJsValue(env, state); 2744 napi_value argv[] = {jsSessionStateObj}; 2745 napi_call_function(env, NapiGetUndefined(env), jsCallBack->GetNapiValue(), ArraySize(argv), argv, nullptr); 2746 }; 2747 taskScheduler_->PostMainThreadTask(task, "OnSessionStateChange, state:" + std::to_string(static_cast<int>(state))); 2748 } 2749 OnBufferAvailableChange(const bool isBufferAvailable)2750 void JsSceneSession::OnBufferAvailableChange(const bool isBufferAvailable) 2751 { 2752 WLOGFD("[NAPI]OnBufferAvailableChange, state: %{public}u", isBufferAvailable); 2753 auto task = [weakThis = wptr(this), persistentId = persistentId_, isBufferAvailable, env = env_] { 2754 auto jsSceneSession = weakThis.promote(); 2755 if (!jsSceneSession || jsSceneSessionMap_.find(persistentId) == jsSceneSessionMap_.end()) { 2756 TLOGE(WmsLogTag::WMS_LIFE, "OnBufferAvailableChange jsSceneSession id:%{public}d has been destroyed", 2757 persistentId); 2758 return; 2759 } 2760 auto jsCallBack = jsSceneSession->GetJSCallback(BUFFER_AVAILABLE_CHANGE_CB); 2761 if (!jsCallBack) { 2762 WLOGFE("[NAPI]jsCallBack is nullptr"); 2763 return; 2764 } 2765 napi_value jsBufferAvailableObj = CreateJsValue(env, isBufferAvailable); 2766 napi_value argv[] = { jsBufferAvailableObj }; 2767 napi_call_function(env, NapiGetUndefined(env), jsCallBack->GetNapiValue(), ArraySize(argv), argv, nullptr); 2768 }; 2769 taskScheduler_->PostMainThreadTask(task); 2770 } 2771 OnSessionRectChange(const WSRect & rect,const SizeChangeReason & reason)2772 void JsSceneSession::OnSessionRectChange(const WSRect& rect, const SizeChangeReason& reason) 2773 { 2774 if (!IsMoveToOrDragMove(reason) && reason != SizeChangeReason::PIP_RESTORE && rect.IsEmpty()) { 2775 WLOGFD("Rect is empty, there is no need to notify"); 2776 return; 2777 } 2778 WLOGFD("[NAPI]OnSessionRectChange"); 2779 2780 auto task = [weakThis = wptr(this), persistentId = persistentId_, rect, reason, env = env_] { 2781 auto jsSceneSession = weakThis.promote(); 2782 if (!jsSceneSession || jsSceneSessionMap_.find(persistentId) == jsSceneSessionMap_.end()) { 2783 TLOGE(WmsLogTag::WMS_LIFE, "OnSessionRectChange jsSceneSession id:%{public}d has been destroyed", 2784 persistentId); 2785 return; 2786 } 2787 auto jsCallBack = jsSceneSession->GetJSCallback(SESSION_RECT_CHANGE_CB); 2788 if (!jsCallBack) { 2789 WLOGFE("[NAPI]jsCallBack is nullptr"); 2790 return; 2791 } 2792 napi_value jsSessionStateObj = CreateJsSessionRect(env, rect); 2793 napi_value sizeChangeReason = CreateJsValue(env, static_cast<int32_t>(reason)); 2794 napi_value argv[] = {jsSessionStateObj, sizeChangeReason}; 2795 napi_call_function(env, NapiGetUndefined(env), jsCallBack->GetNapiValue(), ArraySize(argv), argv, nullptr); 2796 }; 2797 std::string rectInfo = "OnSessionRectChange [" + std::to_string(rect.posX_) + "," + std::to_string(rect.posY_) 2798 + "], [" + std::to_string(rect.width_) + ", " + std::to_string(rect.height_); 2799 taskScheduler_->PostMainThreadTask(task, rectInfo); 2800 } 2801 OnSessionPiPControlStatusChange(WsPiPControlType controlType,WsPiPControlStatus status)2802 void JsSceneSession::OnSessionPiPControlStatusChange(WsPiPControlType controlType, WsPiPControlStatus status) 2803 { 2804 TLOGI(WmsLogTag::WMS_PIP, "controlType:%{public}u, status:%{public}d", controlType, status); 2805 auto task = [weakThis = wptr(this), persistentId = persistentId_, controlType, status, env = env_] { 2806 auto jsSceneSession = weakThis.promote(); 2807 if (!jsSceneSession || jsSceneSessionMap_.find(persistentId) == jsSceneSessionMap_.end()) { 2808 TLOGE(WmsLogTag::WMS_LIFE, "OnSessionPiPControlStatusChange jsSceneSession id:%{public}d has been" 2809 " destroyed", persistentId); 2810 return; 2811 } 2812 auto jsCallBack = jsSceneSession->GetJSCallback(SESSION_PIP_CONTROL_STATUS_CHANGE_CB); 2813 if (!jsCallBack) { 2814 TLOGE(WmsLogTag::WMS_PIP, "[NAPI]jsCallBack is nullptr"); 2815 return; 2816 } 2817 napi_value controlTypeValue = CreateJsValue(env, controlType); 2818 napi_value controlStatusValue = CreateJsValue(env, status); 2819 napi_value argv[] = {controlTypeValue, controlStatusValue}; 2820 napi_call_function(env, NapiGetUndefined(env), jsCallBack->GetNapiValue(), ArraySize(argv), argv, nullptr); 2821 }; 2822 taskScheduler_->PostMainThreadTask(task, __func__); 2823 } 2824 OnSetFrameGravity(napi_env env,napi_callback_info info)2825 napi_value JsSceneSession::OnSetFrameGravity(napi_env env, napi_callback_info info) 2826 { 2827 size_t argc = ARGC_FOUR; 2828 napi_value argv[ARGC_FOUR] = { nullptr }; 2829 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr); 2830 if (argc != ARGC_ONE) { 2831 TLOGE(WmsLogTag::DEFAULT, "[NAPI]Argc is invalid: %{public}zu", argc); 2832 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 2833 "Input parameter is missing or invalid")); 2834 return NapiGetUndefined(env); 2835 } 2836 Gravity gravity = Gravity::TOP_LEFT; 2837 if (!ConvertFromJsValue(env, argv[0], gravity)) { 2838 TLOGE(WmsLogTag::DEFAULT, "[NAPI]Failed to convert parameter to gravity"); 2839 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 2840 "Input parameter is missing or invalid")); 2841 return NapiGetUndefined(env); 2842 } 2843 auto session = weakSession_.promote(); 2844 if (session == nullptr) { 2845 TLOGE(WmsLogTag::DEFAULT, "[NAPI]session is nullptr, id:%{public}d", persistentId_); 2846 return NapiGetUndefined(env); 2847 } 2848 session->SetFrameGravity(gravity); 2849 return NapiGetUndefined(env); 2850 } 2851 OnAutoStartPiPStatusChange(bool isAutoStart,uint32_t priority)2852 void JsSceneSession::OnAutoStartPiPStatusChange(bool isAutoStart, uint32_t priority) 2853 { 2854 TLOGI(WmsLogTag::WMS_PIP, "isAutoStart:%{public}u priority:%{public}u", isAutoStart, priority); 2855 auto task = [weakThis = wptr(this), persistentId = persistentId_, isAutoStart, priority, env = env_] { 2856 auto jsSceneSession = weakThis.promote(); 2857 if (!jsSceneSession || jsSceneSessionMap_.find(persistentId) == jsSceneSessionMap_.end()) { 2858 TLOGNE(WmsLogTag::WMS_PIP, "jsSceneSession id:%{public}d has been destroyed", persistentId); 2859 return; 2860 } 2861 auto jsCallBack = jsSceneSession->GetJSCallback(SESSION_AUTO_START_PIP_CB); 2862 if (!jsCallBack) { 2863 TLOGNE(WmsLogTag::WMS_PIP, "[NAPI]jsCallBack is nullptr"); 2864 return; 2865 } 2866 napi_value isAutoStartValue = CreateJsValue(env, isAutoStart); 2867 napi_value priorityValue = CreateJsValue(env, priority); 2868 napi_value argv[] = {isAutoStartValue, priorityValue}; 2869 napi_call_function(env, NapiGetUndefined(env), jsCallBack->GetNapiValue(), ArraySize(argv), argv, nullptr); 2870 }; 2871 taskScheduler_->PostMainThreadTask(task, __func__); 2872 } 2873 2874 /** @note @window.hierarchy */ OnRaiseToTop()2875 void JsSceneSession::OnRaiseToTop() 2876 { 2877 WLOGFI("[NAPI]OnRaiseToTop"); 2878 2879 auto task = [weakThis = wptr(this), persistentId = persistentId_, env = env_] { 2880 auto jsSceneSession = weakThis.promote(); 2881 if (!jsSceneSession || jsSceneSessionMap_.find(persistentId) == jsSceneSessionMap_.end()) { 2882 TLOGE(WmsLogTag::WMS_LIFE, "OnRaiseToTop jsSceneSession id:%{public}d has been destroyed", 2883 persistentId); 2884 return; 2885 } 2886 auto jsCallBack = jsSceneSession->GetJSCallback(RAISE_TO_TOP_CB); 2887 if (!jsCallBack) { 2888 WLOGFE("[NAPI]jsCallBack is nullptr"); 2889 return; 2890 } 2891 napi_value argv[] = {}; 2892 napi_call_function(env, NapiGetUndefined(env), jsCallBack->GetNapiValue(), 0, argv, nullptr); 2893 }; 2894 taskScheduler_->PostMainThreadTask(task, "OnRaiseToTop"); 2895 } 2896 2897 /** @note @window.hierarchy */ OnRaiseToTopForPointDown()2898 void JsSceneSession::OnRaiseToTopForPointDown() 2899 { 2900 WLOGFI("[NAPI]OnRaiseToTopForPointDown"); 2901 2902 auto task = [weakThis = wptr(this), persistentId = persistentId_, env = env_] { 2903 auto jsSceneSession = weakThis.promote(); 2904 if (!jsSceneSession || jsSceneSessionMap_.find(persistentId) == jsSceneSessionMap_.end()) { 2905 TLOGE(WmsLogTag::WMS_LIFE, "OnRaiseToTopForPointDown jsSceneSession id:%{public}d has been destroyed", 2906 persistentId); 2907 return; 2908 } 2909 auto jsCallBack = jsSceneSession->GetJSCallback(RAISE_TO_TOP_POINT_DOWN_CB); 2910 if (!jsCallBack) { 2911 WLOGFE("[NAPI]jsCallBack is nullptr"); 2912 return; 2913 } 2914 napi_value argv[] = {}; 2915 napi_call_function(env, NapiGetUndefined(env), jsCallBack->GetNapiValue(), 0, argv, nullptr); 2916 }; 2917 taskScheduler_->PostMainThreadTask(task, "OnRaiseToTopForPointDown"); 2918 } 2919 OnRaiseAboveTarget(int32_t subWindowId)2920 void JsSceneSession::OnRaiseAboveTarget(int32_t subWindowId) 2921 { 2922 WLOGFI("[NAPI]OnRaiseAboveTarget"); 2923 auto task = [weakThis = wptr(this), persistentId = persistentId_, env = env_, subWindowId] { 2924 auto jsSceneSession = weakThis.promote(); 2925 if (!jsSceneSession || jsSceneSessionMap_.find(persistentId) == jsSceneSessionMap_.end()) { 2926 TLOGE(WmsLogTag::WMS_LIFE, "OnRaiseAboveTarget jsSceneSession id:%{public}d has been destroyed", 2927 persistentId); 2928 return; 2929 } 2930 auto jsCallBack = jsSceneSession->GetJSCallback(RAISE_ABOVE_TARGET_CB); 2931 if (!jsCallBack) { 2932 WLOGFE("[NAPI]jsCallBack is nullptr"); 2933 return; 2934 } 2935 napi_value jsSceneSessionObj = CreateJsValue(env, subWindowId); 2936 if (jsSceneSessionObj == nullptr) { 2937 WLOGFE("[NAPI]jsSceneSessionObj is nullptr"); 2938 return; 2939 } 2940 napi_value argv[] = {CreateJsError(env, 0), jsSceneSessionObj}; 2941 napi_call_function(env, NapiGetUndefined(env), jsCallBack->GetNapiValue(), ArraySize(argv), argv, nullptr); 2942 }; 2943 taskScheduler_->PostMainThreadTask(task, "OnRaiseAboveTarget: " + std::to_string(subWindowId)); 2944 } 2945 OnSessionFocusableChange(bool isFocusable)2946 void JsSceneSession::OnSessionFocusableChange(bool isFocusable) 2947 { 2948 TLOGD(WmsLogTag::WMS_FOCUS, "[NAPI]OnSessionFocusableChange, state: %{public}u", isFocusable); 2949 auto task = [weakThis = wptr(this), persistentId = persistentId_, isFocusable, env = env_] { 2950 auto jsSceneSession = weakThis.promote(); 2951 if (!jsSceneSession || jsSceneSessionMap_.find(persistentId) == jsSceneSessionMap_.end()) { 2952 TLOGE(WmsLogTag::WMS_LIFE, "OnSessionFocusableChange jsSceneSession id:%{public}d has been destroyed", 2953 persistentId); 2954 return; 2955 } 2956 auto jsCallBack = jsSceneSession->GetJSCallback(SESSION_FOCUSABLE_CHANGE_CB); 2957 if (!jsCallBack) { 2958 WLOGFE("[NAPI]jsCallBack is nullptr"); 2959 return; 2960 } 2961 napi_value jsSessionFocusableObj = CreateJsValue(env, isFocusable); 2962 napi_value argv[] = {jsSessionFocusableObj}; 2963 napi_call_function(env, NapiGetUndefined(env), jsCallBack->GetNapiValue(), ArraySize(argv), argv, nullptr); 2964 }; 2965 taskScheduler_->PostMainThreadTask(task, "OnSessionFocusableChange, state:" + std::to_string(isFocusable)); 2966 } 2967 OnSessionTouchableChange(bool touchable)2968 void JsSceneSession::OnSessionTouchableChange(bool touchable) 2969 { 2970 WLOGFI("[NAPI]OnSessionTouchableChange, state: %{public}u", touchable); 2971 2972 auto task = [weakThis = wptr(this), persistentId = persistentId_, touchable, env = env_] { 2973 auto jsSceneSession = weakThis.promote(); 2974 if (!jsSceneSession || jsSceneSessionMap_.find(persistentId) == jsSceneSessionMap_.end()) { 2975 TLOGE(WmsLogTag::WMS_LIFE, "OnSessionTouchableChange jsSceneSession id:%{public}d has been destroyed", 2976 persistentId); 2977 return; 2978 } 2979 auto jsCallBack = jsSceneSession->GetJSCallback(SESSION_TOUCHABLE_CHANGE_CB); 2980 if (!jsCallBack) { 2981 WLOGFE("[NAPI]jsCallBack is nullptr"); 2982 return; 2983 } 2984 napi_value jsSessionTouchableObj = CreateJsValue(env, touchable); 2985 napi_value argv[] = {jsSessionTouchableObj}; 2986 napi_call_function(env, NapiGetUndefined(env), jsCallBack->GetNapiValue(), ArraySize(argv), argv, nullptr); 2987 }; 2988 taskScheduler_->PostMainThreadTask(task, "OnSessionTouchableChange: state " + std::to_string(touchable)); 2989 } 2990 2991 /** @note @window.hierarchy */ OnSessionTopmostChange(bool topmost)2992 void JsSceneSession::OnSessionTopmostChange(bool topmost) 2993 { 2994 TLOGI(WmsLogTag::WMS_LAYOUT, "[NAPI]State: %{public}u", topmost); 2995 auto task = [weakThis = wptr(this), persistentId = persistentId_, topmost, env = env_] { 2996 auto jsSceneSession = weakThis.promote(); 2997 if (!jsSceneSession || jsSceneSessionMap_.find(persistentId) == jsSceneSessionMap_.end()) { 2998 TLOGE(WmsLogTag::WMS_LIFE, "OnSessionTopmostChange jsSceneSession id:%{public}d has been destroyed", 2999 persistentId); 3000 return; 3001 } 3002 auto jsCallBack = jsSceneSession->GetJSCallback(SESSION_TOP_MOST_CHANGE_CB); 3003 if (!jsCallBack) { 3004 TLOGE(WmsLogTag::WMS_LAYOUT, "[NAPI]jsCallBack is nullptr"); 3005 return; 3006 } 3007 napi_value jsSessionTouchableObj = CreateJsValue(env, topmost); 3008 napi_value argv[] = {jsSessionTouchableObj}; 3009 napi_call_function(env, NapiGetUndefined(env), jsCallBack->GetNapiValue(), ArraySize(argv), argv, nullptr); 3010 }; 3011 taskScheduler_->PostMainThreadTask(task, "OnSessionTopmostChange: state " + std::to_string(topmost)); 3012 } 3013 3014 /** @note @window.hierarchy */ OnMainWindowTopmostChange(bool isTopmost)3015 void JsSceneSession::OnMainWindowTopmostChange(bool isTopmost) 3016 { 3017 TLOGD(WmsLogTag::WMS_HIERARCHY, "isTopmost: %{public}u", isTopmost); 3018 const char* const where = __func__; 3019 taskScheduler_->PostMainThreadTask([weakThis = wptr(this), persistentId = persistentId_, 3020 isTopmost, env = env_, where] { 3021 auto jsSceneSession = weakThis.promote(); 3022 if (!jsSceneSession || jsSceneSessionMap_.find(persistentId) == jsSceneSessionMap_.end()) { 3023 TLOGNE(WmsLogTag::WMS_HIERARCHY, "%{public}s jsSceneSession id:%{public}d has been destroyed", 3024 where, persistentId); 3025 return; 3026 } 3027 auto jsCallBack = jsSceneSession->GetJSCallback(MAIN_WINDOW_TOP_MOST_CHANGE_CB); 3028 if (!jsCallBack) { 3029 TLOGNE(WmsLogTag::WMS_HIERARCHY, "jsCallBack is nullptr"); 3030 return; 3031 } 3032 napi_value jsMainWindowTopmostObj = CreateJsValue(env, isTopmost); 3033 napi_value argv[] = { jsMainWindowTopmostObj }; 3034 napi_call_function(env, NapiGetUndefined(env), jsCallBack->GetNapiValue(), ArraySize(argv), argv, nullptr); 3035 }, "OnMainWindowTopmostChange: " + std::to_string(isTopmost)); 3036 } 3037 OnSubModalTypeChange(SubWindowModalType subWindowModalType)3038 void JsSceneSession::OnSubModalTypeChange(SubWindowModalType subWindowModalType) 3039 { 3040 const char* const where = __func__; 3041 auto task = [weakThis = wptr(this), persistentId = persistentId_, subWindowModalType, env = env_, where] { 3042 auto jsSceneSession = weakThis.promote(); 3043 if (!jsSceneSession || jsSceneSessionMap_.find(persistentId) == jsSceneSessionMap_.end()) { 3044 TLOGNE(WmsLogTag::WMS_LIFE, "%{public}s jsSceneSession id:%{public}d has been destroyed", 3045 where, persistentId); 3046 return; 3047 } 3048 auto jsCallBack = jsSceneSession->GetJSCallback(SUB_MODAL_TYPE_CHANGE_CB); 3049 if (!jsCallBack) { 3050 TLOGNE(WmsLogTag::WMS_HIERARCHY, "%{public}s jsCallBack is nullptr", where); 3051 return; 3052 } 3053 napi_value jsSessionModalTypeObj = CreateJsValue(env, subWindowModalType); 3054 napi_value argv[] = {jsSessionModalTypeObj}; 3055 napi_call_function(env, NapiGetUndefined(env), jsCallBack->GetNapiValue(), ArraySize(argv), argv, nullptr); 3056 }; 3057 taskScheduler_->PostMainThreadTask(task, 3058 "OnSubModalTypeChange: " + std::to_string(static_cast<uint32_t>(subWindowModalType))); 3059 } 3060 OnMainModalTypeChange(bool isModal)3061 void JsSceneSession::OnMainModalTypeChange(bool isModal) 3062 { 3063 const char* const where = __func__; 3064 auto task = [weakThis = wptr(this), persistentId = persistentId_, isModal, env = env_, where] { 3065 auto jsSceneSession = weakThis.promote(); 3066 if (!jsSceneSession || jsSceneSessionMap_.find(persistentId) == jsSceneSessionMap_.end()) { 3067 TLOGNE(WmsLogTag::WMS_LIFE, "%{public}s jsSceneSession id:%{public}d has been destroyed", 3068 where, persistentId); 3069 return; 3070 } 3071 auto jsCallBack = jsSceneSession->GetJSCallback(MAIN_MODAL_TYPE_CHANGE_CB); 3072 if (!jsCallBack) { 3073 TLOGNE(WmsLogTag::WMS_HIERARCHY, "%{public}s jsCallBack is nullptr", where); 3074 return; 3075 } 3076 napi_value jsMainSessionModalType = CreateJsValue(env, isModal); 3077 napi_value argv[] = {jsMainSessionModalType}; 3078 napi_call_function(env, NapiGetUndefined(env), jsCallBack->GetNapiValue(), ArraySize(argv), argv, nullptr); 3079 }; 3080 taskScheduler_->PostMainThreadTask(task, "OnMainModalTypeChange: " + std::to_string(isModal)); 3081 } 3082 OnClick()3083 void JsSceneSession::OnClick() 3084 { 3085 WLOGFD("[NAPI]OnClick"); 3086 auto task = [weakThis = wptr(this), persistentId = persistentId_, env = env_] { 3087 auto jsSceneSession = weakThis.promote(); 3088 if (!jsSceneSession || jsSceneSessionMap_.find(persistentId) == jsSceneSessionMap_.end()) { 3089 TLOGE(WmsLogTag::WMS_LIFE, "OnClick jsSceneSession id:%{public}d has been destroyed", 3090 persistentId); 3091 return; 3092 } 3093 auto jsCallBack = jsSceneSession->GetJSCallback(CLICK_CB); 3094 if (!jsCallBack) { 3095 WLOGFE("[NAPI]jsCallBack is nullptr"); 3096 return; 3097 } 3098 napi_value argv[] = {}; 3099 napi_call_function(env, NapiGetUndefined(env), jsCallBack->GetNapiValue(), 0, argv, nullptr); 3100 }; 3101 taskScheduler_->PostMainThreadTask(task, "OnClick"); 3102 } 3103 OnContextTransparent()3104 void JsSceneSession::OnContextTransparent() 3105 { 3106 WLOGFD("[NAPI]OnContextTransparent"); 3107 3108 auto task = [weakThis = wptr(this), persistentId = persistentId_, env = env_] { 3109 auto jsSceneSession = weakThis.promote(); 3110 if (!jsSceneSession || jsSceneSessionMap_.find(persistentId) == jsSceneSessionMap_.end()) { 3111 TLOGE(WmsLogTag::WMS_LIFE, "OnContextTransparent jsSceneSession id:%{public}d has been destroyed", 3112 persistentId); 3113 return; 3114 } 3115 auto jsCallBack = jsSceneSession->GetJSCallback(CONTEXT_TRANSPARENT_CB); 3116 if (!jsCallBack) { 3117 WLOGFE("[NAPI]jsCallBack is nullptr"); 3118 return; 3119 } 3120 napi_value argv[] = {}; 3121 napi_call_function(env, NapiGetUndefined(env), jsCallBack->GetNapiValue(), 0, argv, nullptr); 3122 }; 3123 taskScheduler_->PostMainThreadTask(task, "OnContextTransparent"); 3124 } 3125 ChangeSessionVisibilityWithStatusBar(SessionInfo & info,bool visible)3126 void JsSceneSession::ChangeSessionVisibilityWithStatusBar(SessionInfo& info, bool visible) 3127 { 3128 WLOGI("[NAPI]: bundleName %{public}s, moduleName %{public}s, " 3129 "abilityName %{public}s, appIndex %{public}d, reuse %{public}d, visible %{public}d", 3130 info.bundleName_.c_str(), info.moduleName_.c_str(), info.abilityName_.c_str(), 3131 info.appIndex_, info.reuse, visible); 3132 auto session = weakSession_.promote(); 3133 if (session == nullptr) { 3134 WLOGFE("session is nullptr, id:%{public}d", persistentId_); 3135 return; 3136 } 3137 std::shared_ptr<SessionInfo> sessionInfo = std::make_shared<SessionInfo>(info); 3138 auto task = [weakThis = wptr(this), sessionInfo, visible]() { 3139 auto jsSceneSession = weakThis.promote(); 3140 if (!jsSceneSession) { 3141 TLOGE(WmsLogTag::WMS_LIFE, "ChangeSessionVisibilityWithStatusBar jsSceneSession is null"); 3142 return; 3143 } 3144 jsSceneSession->ChangeSessionVisibilityWithStatusBarInner(sessionInfo, visible); 3145 }; 3146 taskScheduler_->PostMainThreadTask(task, "ChangeSessionVisibilityWithStatusBar, visible:" + 3147 std::to_string(visible)); 3148 } 3149 ChangeSessionVisibilityWithStatusBarInner(std::shared_ptr<SessionInfo> sessionInfo,bool visible)3150 void JsSceneSession::ChangeSessionVisibilityWithStatusBarInner(std::shared_ptr<SessionInfo> sessionInfo, bool visible) 3151 { 3152 std::shared_ptr<NativeReference> jsCallBack = GetJSCallback(CHANGE_SESSION_VISIBILITY_WITH_STATUS_BAR); 3153 if (!jsCallBack) { 3154 WLOGFE("[NAPI]jsCallBack is nullptr"); 3155 return; 3156 } 3157 if (sessionInfo == nullptr) { 3158 WLOGFE("[NAPI]sessionInfo is nullptr"); 3159 return; 3160 } 3161 napi_value jsSessionInfo = CreateJsSessionInfo(env_, *sessionInfo); 3162 if (jsSessionInfo == nullptr) { 3163 WLOGFE("[NAPI]this target session info is nullptr"); 3164 return; 3165 } 3166 napi_value visibleNapiV = CreateJsValue(env_, visible); 3167 napi_value argv[] = {jsSessionInfo, visibleNapiV}; 3168 napi_call_function(env_, NapiGetUndefined(env_), 3169 jsCallBack->GetNapiValue(), ArraySize(argv), argv, nullptr); 3170 } 3171 GenSceneSession(SessionInfo & info)3172 sptr<SceneSession> JsSceneSession::GenSceneSession(SessionInfo& info) 3173 { 3174 sptr<SceneSession> sceneSession = nullptr; 3175 if (info.persistentId_ == 0) { 3176 auto result = SceneSessionManager::GetInstance().CheckIfReuseSession(info); 3177 if (result == BrokerStates::BROKER_NOT_START) { 3178 TLOGE(WmsLogTag::WMS_LIFE, "[NAPI]BrokerStates not started"); 3179 return nullptr; 3180 } 3181 if (info.reuse || info.isAtomicService_) { 3182 TLOGI(WmsLogTag::WMS_LIFE, "session need to be reusesd."); 3183 if (SceneSessionManager::GetInstance().CheckCollaboratorType(info.collaboratorType_)) { 3184 sceneSession = SceneSessionManager::GetInstance().FindSessionByAffinity(info.sessionAffinity); 3185 } else { 3186 ComparedSessionInfo compareSessionInfo = { info.bundleName_, info.moduleName_, info.abilityName_, 3187 info.appIndex_, info.windowType_, info.isAtomicService_ }; 3188 sceneSession = SceneSessionManager::GetInstance().GetSceneSessionByName(compareSessionInfo); 3189 } 3190 } 3191 if (sceneSession == nullptr) { 3192 TLOGI(WmsLogTag::WMS_LIFE, "GetSceneSessionByName return nullptr, RequestSceneSession"); 3193 sceneSession = SceneSessionManager::GetInstance().RequestSceneSession(info); 3194 if (sceneSession == nullptr) { 3195 TLOGE(WmsLogTag::WMS_LIFE, "RequestSceneSession return nullptr"); 3196 return nullptr; 3197 } 3198 } else { 3199 sceneSession->SetSessionInfo(info); 3200 } 3201 info.persistentId_ = sceneSession->GetPersistentId(); 3202 sceneSession->SetSessionInfoPersistentId(sceneSession->GetPersistentId()); 3203 } else { 3204 sceneSession = SceneSessionManager::GetInstance().GetSceneSession(info.persistentId_); 3205 if (sceneSession == nullptr) { 3206 TLOGE(WmsLogTag::WMS_LIFE, "GetSceneSession return nullptr"); 3207 sceneSession = SceneSessionManager::GetInstance().RequestSceneSession(info); 3208 if (sceneSession == nullptr) { 3209 TLOGE(WmsLogTag::WMS_LIFE, "retry RequestSceneSession return nullptr"); 3210 return nullptr; 3211 } 3212 info.persistentId_ = sceneSession->GetPersistentId(); 3213 sceneSession->SetSessionInfoPersistentId(sceneSession->GetPersistentId()); 3214 } else { 3215 sceneSession->SetSessionInfo(info); 3216 } 3217 } 3218 sceneSession->SetSessionInfoProcessOptions(info.processOptions); 3219 return sceneSession; 3220 } 3221 PendingSessionActivation(SessionInfo & info)3222 void JsSceneSession::PendingSessionActivation(SessionInfo& info) 3223 { 3224 TLOGI(WmsLogTag::WMS_LIFE, "[NAPI]bundleName %{public}s, moduleName %{public}s, abilityName %{public}s, " 3225 "appIndex %{public}d, reuse %{public}d", info.bundleName_.c_str(), info.moduleName_.c_str(), 3226 info.abilityName_.c_str(), info.appIndex_, info.reuse); 3227 auto sceneSession = GenSceneSession(info); 3228 if (sceneSession == nullptr) { 3229 TLOGE(WmsLogTag::WMS_LIFE, "GenSceneSession failed"); 3230 return; 3231 } 3232 3233 if (info.want != nullptr) { 3234 auto focusedOnShow = info.want->GetBoolParam(AAFwk::Want::PARAM_RESV_WINDOW_FOCUSED, true); 3235 sceneSession->SetFocusedOnShow(focusedOnShow); 3236 } else { 3237 sceneSession->SetFocusedOnShow(true); 3238 } 3239 3240 auto callerSession = SceneSessionManager::GetInstance().GetSceneSession(info.callerPersistentId_); 3241 if (callerSession != nullptr) { 3242 TLOGI(WmsLogTag::WMS_SCB, 3243 "update isCalledRightlyByCallerId from :%{public}d to false", info.isCalledRightlyByCallerId_); 3244 info.isCalledRightlyByCallerId_ = false; 3245 } 3246 std::shared_ptr<SessionInfo> sessionInfo = std::make_shared<SessionInfo>(info); 3247 auto task = [weakThis = wptr(this), sessionInfo] { 3248 auto jsSceneSession = weakThis.promote(); 3249 if (jsSceneSession == nullptr) { 3250 TLOGE(WmsLogTag::WMS_LIFE, "PendingSessionActivation JsSceneSession is null"); 3251 return; 3252 } 3253 jsSceneSession->PendingSessionActivationInner(sessionInfo); 3254 }; 3255 sceneSession->PostLifeCycleTask(task, "PendingSessionActivation", LifeCycleTaskType::START); 3256 if (info.fullScreenStart_) { 3257 sceneSession->NotifySessionFullScreen(true); 3258 } 3259 } 3260 PendingSessionActivationInner(std::shared_ptr<SessionInfo> sessionInfo)3261 void JsSceneSession::PendingSessionActivationInner(std::shared_ptr<SessionInfo> sessionInfo) 3262 { 3263 napi_env& env_ref = env_; 3264 auto task = [weakThis = wptr(this), persistentId = persistentId_, sessionInfo, env_ref] { 3265 auto jsSceneSession = weakThis.promote(); 3266 if (!jsSceneSession || jsSceneSessionMap_.find(persistentId) == jsSceneSessionMap_.end()) { 3267 TLOGE(WmsLogTag::WMS_LIFE, "PendingSessionActivationInner jsSceneSession id:%{public}d has been destroyed", 3268 persistentId); 3269 return; 3270 } 3271 auto jsCallBack = jsSceneSession->GetJSCallback(PENDING_SCENE_CB); 3272 if (!jsCallBack) { 3273 TLOGE(WmsLogTag::WMS_LIFE, "[NAPI]jsCallBack is nullptr"); 3274 return; 3275 } 3276 if (sessionInfo == nullptr) { 3277 TLOGE(WmsLogTag::WMS_LIFE, "[NAPI]sessionInfo is nullptr"); 3278 return; 3279 } 3280 napi_value jsSessionInfo = CreateJsSessionInfo(env_ref, *sessionInfo); 3281 if (jsSessionInfo == nullptr) { 3282 TLOGE(WmsLogTag::WMS_LIFE, "[NAPI]target session info is nullptr"); 3283 return; 3284 } 3285 napi_value argv[] = {jsSessionInfo}; 3286 TLOGI(WmsLogTag::WMS_LIFE, "[NAPI]PendingSessionActivationInner task success, id:%{public}d", 3287 sessionInfo->persistentId_); 3288 napi_call_function(env_ref, NapiGetUndefined(env_ref), 3289 jsCallBack->GetNapiValue(), ArraySize(argv), argv, nullptr); 3290 }; 3291 taskScheduler_->PostMainThreadTask(task, "PendingSessionActivationInner"); 3292 } 3293 OnBackPressed(bool needMoveToBackground)3294 void JsSceneSession::OnBackPressed(bool needMoveToBackground) 3295 { 3296 WLOGFI("[NAPI]OnBackPressed needMoveToBackground %{public}d", needMoveToBackground); 3297 3298 auto task = [weakThis = wptr(this), persistentId = persistentId_, needMoveToBackground, env = env_] { 3299 auto jsSceneSession = weakThis.promote(); 3300 if (!jsSceneSession || jsSceneSessionMap_.find(persistentId) == jsSceneSessionMap_.end()) { 3301 TLOGE(WmsLogTag::WMS_LIFE, "OnBackPressed jsSceneSession id:%{public}d has been destroyed", 3302 persistentId); 3303 return; 3304 } 3305 auto jsCallBack = jsSceneSession->GetJSCallback(BACK_PRESSED_CB); 3306 if (!jsCallBack) { 3307 WLOGFE("[NAPI]jsCallBack is nullptr"); 3308 return; 3309 } 3310 napi_value jsNeedMoveToBackgroundObj = CreateJsValue(env, needMoveToBackground); 3311 napi_value argv[] = {jsNeedMoveToBackgroundObj}; 3312 napi_call_function(env, NapiGetUndefined(env), jsCallBack->GetNapiValue(), ArraySize(argv), argv, nullptr); 3313 }; 3314 taskScheduler_->PostMainThreadTask(task, "OnBackPressed:" + std::to_string(needMoveToBackground)); 3315 } 3316 TerminateSession(const SessionInfo & info)3317 void JsSceneSession::TerminateSession(const SessionInfo& info) 3318 { 3319 TLOGI(WmsLogTag::WMS_LIFE, "bundle:%{public}s, ability:%{public}s, id:%{public}d", 3320 info.bundleName_.c_str(), info.abilityName_.c_str(), info.persistentId_); 3321 3322 std::shared_ptr<SessionInfo> sessionInfo = std::make_shared<SessionInfo>(info); 3323 auto task = [weakThis = wptr(this), persistentId = persistentId_, sessionInfo, env = env_] { 3324 auto jsSceneSession = weakThis.promote(); 3325 if (!jsSceneSession || jsSceneSessionMap_.find(persistentId) == jsSceneSessionMap_.end()) { 3326 TLOGE(WmsLogTag::WMS_LIFE, "TerminateSession jsSceneSession id:%{public}d has been destroyed", 3327 persistentId); 3328 return; 3329 } 3330 auto jsCallBack = jsSceneSession->GetJSCallback(TERMINATE_SESSION_CB); 3331 if (!jsCallBack) { 3332 TLOGE(WmsLogTag::WMS_LIFE, "[NAPI]jsCallBack is nullptr"); 3333 return; 3334 } 3335 if (sessionInfo == nullptr) { 3336 TLOGE(WmsLogTag::WMS_LIFE, "[NAPI]sessionInfo is nullptr"); 3337 return; 3338 } 3339 napi_value jsSessionInfo = CreateJsSessionInfo(env, *sessionInfo); 3340 if (jsSessionInfo == nullptr) { 3341 TLOGE(WmsLogTag::WMS_LIFE, "[NAPI]target session info is nullptr"); 3342 return; 3343 } 3344 napi_value argv[] = {jsSessionInfo}; 3345 napi_call_function(env, NapiGetUndefined(env), jsCallBack->GetNapiValue(), ArraySize(argv), argv, nullptr); 3346 }; 3347 taskScheduler_->PostMainThreadTask(task, "TerminateSession name:" + info.abilityName_); 3348 } 3349 TerminateSessionNew(const SessionInfo & info,bool needStartCaller,bool isFromBroker)3350 void JsSceneSession::TerminateSessionNew(const SessionInfo& info, bool needStartCaller, bool isFromBroker) 3351 { 3352 TLOGI(WmsLogTag::WMS_LIFE, "[NAPI]bundleName = %{public}s, abilityName = %{public}s", 3353 info.bundleName_.c_str(), info.abilityName_.c_str()); 3354 bool needRemoveSession = false; 3355 if (!needStartCaller && !isFromBroker) { 3356 needRemoveSession = true; 3357 } 3358 auto task = [weakThis = wptr(this), persistentId = persistentId_, needStartCaller, needRemoveSession, env = env_] { 3359 auto jsSceneSession = weakThis.promote(); 3360 if (!jsSceneSession || jsSceneSessionMap_.find(persistentId) == jsSceneSessionMap_.end()) { 3361 TLOGE(WmsLogTag::WMS_LIFE, "TerminateSessionNew jsSceneSession id:%{public}d has been destroyed", 3362 persistentId); 3363 return; 3364 } 3365 auto jsCallBack = jsSceneSession->GetJSCallback(TERMINATE_SESSION_CB_NEW); 3366 if (!jsCallBack) { 3367 TLOGE(WmsLogTag::WMS_LIFE, "[NAPI]jsCallBack is nullptr"); 3368 return; 3369 } 3370 napi_value jsNeedStartCaller = CreateJsValue(env, needStartCaller); 3371 if (jsNeedStartCaller == nullptr) { 3372 TLOGE(WmsLogTag::WMS_LIFE, "[NAPI]jsNeedStartCaller is nullptr"); 3373 return; 3374 } 3375 napi_value jsNeedRemoveSession = CreateJsValue(env, needRemoveSession); 3376 if (jsNeedRemoveSession == nullptr) { 3377 TLOGE(WmsLogTag::WMS_LIFE, "[NAPI]jsNeedRemoveSession is nullptr"); 3378 return; 3379 } 3380 napi_value argv[] = {jsNeedStartCaller, jsNeedRemoveSession}; 3381 napi_call_function(env, NapiGetUndefined(env), jsCallBack->GetNapiValue(), ArraySize(argv), argv, nullptr); 3382 }; 3383 taskScheduler_->PostMainThreadTask(task, "TerminateSessionNew, name:" + info.abilityName_); 3384 } 3385 TerminateSessionTotal(const SessionInfo & info,TerminateType terminateType)3386 void JsSceneSession::TerminateSessionTotal(const SessionInfo& info, TerminateType terminateType) 3387 { 3388 TLOGI(WmsLogTag::WMS_LIFE, "[NAPI]bundleName = %{public}s, abilityName = %{public}s, terminateType = %{public}d", 3389 info.bundleName_.c_str(), info.abilityName_.c_str(), static_cast<int32_t>(terminateType)); 3390 3391 auto task = [weakThis = wptr(this), persistentId = persistentId_, terminateType, env = env_] { 3392 auto jsSceneSession = weakThis.promote(); 3393 if (!jsSceneSession || jsSceneSessionMap_.find(persistentId) == jsSceneSessionMap_.end()) { 3394 TLOGE(WmsLogTag::WMS_LIFE, "TerminateSessionTotal jsSceneSession id:%{public}d has been destroyed", 3395 persistentId); 3396 return; 3397 } 3398 auto jsCallBack = jsSceneSession->GetJSCallback(TERMINATE_SESSION_CB_TOTAL); 3399 if (!jsCallBack) { 3400 TLOGE(WmsLogTag::WMS_LIFE, "[NAPI]jsCallBack is nullptr"); 3401 return; 3402 } 3403 napi_value jsTerminateType = CreateJsValue(env, static_cast<int32_t>(terminateType)); 3404 if (jsTerminateType == nullptr) { 3405 TLOGE(WmsLogTag::WMS_LIFE, "[NAPI]jsTerminateType is nullptr"); 3406 return; 3407 } 3408 napi_value argv[] = {jsTerminateType}; 3409 napi_call_function(env, NapiGetUndefined(env), jsCallBack->GetNapiValue(), ArraySize(argv), argv, nullptr); 3410 }; 3411 taskScheduler_->PostMainThreadTask(task, "TerminateSessionTotal:name:" + info.abilityName_); 3412 } 3413 UpdateSessionLabel(const std::string & label)3414 void JsSceneSession::UpdateSessionLabel(const std::string& label) 3415 { 3416 WLOGFI("[NAPI]run UpdateSessionLabel"); 3417 3418 auto task = [weakThis = wptr(this), persistentId = persistentId_, label, env = env_] { 3419 auto jsSceneSession = weakThis.promote(); 3420 if (!jsSceneSession || jsSceneSessionMap_.find(persistentId) == jsSceneSessionMap_.end()) { 3421 TLOGE(WmsLogTag::WMS_LIFE, "UpdateSessionLabel jsSceneSession id:%{public}d has been destroyed", 3422 persistentId); 3423 return; 3424 } 3425 auto jsCallBack = jsSceneSession->GetJSCallback(UPDATE_SESSION_LABEL_CB); 3426 if (!jsCallBack) { 3427 WLOGFE("[NAPI]jsCallBack is nullptr"); 3428 return; 3429 } 3430 napi_value jsLabel = CreateJsValue(env, label); 3431 if (jsLabel == nullptr) { 3432 WLOGFE("[NAPI]this target jsLabel is nullptr"); 3433 return; 3434 } 3435 napi_value argv[] = {jsLabel}; 3436 napi_call_function(env, NapiGetUndefined(env), jsCallBack->GetNapiValue(), ArraySize(argv), argv, nullptr); 3437 }; 3438 taskScheduler_->PostMainThreadTask(task, "UpdateSessionLabel"); 3439 } 3440 ProcessUpdateSessionLabelRegister()3441 void JsSceneSession::ProcessUpdateSessionLabelRegister() 3442 { 3443 WLOGFD("begin to run ProcessUpdateSessionLabelRegister"); 3444 NofitySessionLabelUpdatedFunc func = [weakThis = wptr(this)](const std::string& label) { 3445 auto jsSceneSession = weakThis.promote(); 3446 if (!jsSceneSession) { 3447 TLOGE(WmsLogTag::WMS_LIFE, "ProcessUpdateSessionLabelRegister jsSceneSession is null"); 3448 return; 3449 } 3450 jsSceneSession->UpdateSessionLabel(label); 3451 }; 3452 auto session = weakSession_.promote(); 3453 if (session == nullptr) { 3454 WLOGFE("session is nullptr, id:%{public}d", persistentId_); 3455 return; 3456 } 3457 session->SetUpdateSessionLabelListener(func); 3458 WLOGFD("ProcessUpdateSessionLabelRegister success"); 3459 } 3460 ProcessUpdateSessionIconRegister()3461 void JsSceneSession::ProcessUpdateSessionIconRegister() 3462 { 3463 WLOGFD("begin to run ProcessUpdateSessionIconRegister"); 3464 NofitySessionIconUpdatedFunc func = [weakThis = wptr(this)](const std::string& iconPath) { 3465 auto jsSceneSession = weakThis.promote(); 3466 if (!jsSceneSession) { 3467 TLOGE(WmsLogTag::WMS_LIFE, "ProcessUpdateSessionIconRegister jsSceneSession is null"); 3468 return; 3469 } 3470 jsSceneSession->UpdateSessionIcon(iconPath); 3471 }; 3472 auto session = weakSession_.promote(); 3473 if (session == nullptr) { 3474 WLOGFE("session is nullptr, id:%{public}d", persistentId_); 3475 return; 3476 } 3477 session->SetUpdateSessionIconListener(func); 3478 WLOGFD("ProcessUpdateSessionIconRegister success"); 3479 } 3480 UpdateSessionIcon(const std::string & iconPath)3481 void JsSceneSession::UpdateSessionIcon(const std::string& iconPath) 3482 { 3483 WLOGFI("[NAPI]run UpdateSessionIcon"); 3484 3485 auto task = [weakThis = wptr(this), persistentId = persistentId_, iconPath, env = env_] { 3486 auto jsSceneSession = weakThis.promote(); 3487 if (!jsSceneSession || jsSceneSessionMap_.find(persistentId) == jsSceneSessionMap_.end()) { 3488 TLOGE(WmsLogTag::WMS_LIFE, "UpdateSessionIcon jsSceneSession id:%{public}d has been destroyed", 3489 persistentId); 3490 return; 3491 } 3492 auto jsCallBack = jsSceneSession->GetJSCallback(UPDATE_SESSION_ICON_CB); 3493 if (!jsCallBack) { 3494 WLOGFE("[NAPI]jsCallBack is nullptr"); 3495 return; 3496 } 3497 napi_value jsIconPath = CreateJsValue(env, iconPath); 3498 if (jsIconPath == nullptr) { 3499 WLOGFE("[NAPI]this target jsIconPath is nullptr"); 3500 return; 3501 } 3502 napi_value argv[] = {jsIconPath}; 3503 napi_call_function(env, NapiGetUndefined(env), jsCallBack->GetNapiValue(), ArraySize(argv), argv, nullptr); 3504 }; 3505 taskScheduler_->PostMainThreadTask(task, "UpdateSessionIcon"); 3506 } 3507 OnSessionException(const SessionInfo & info,bool needRemoveSession,bool startFail)3508 void JsSceneSession::OnSessionException(const SessionInfo& info, bool needRemoveSession, bool startFail) 3509 { 3510 TLOGI(WmsLogTag::WMS_LIFE, "[NAPI]bundleName = %{public}s, abilityName = %{public}s, startFail = %{public}d", 3511 info.bundleName_.c_str(), info.abilityName_.c_str(), startFail); 3512 3513 std::shared_ptr<SessionInfo> sessionInfo = std::make_shared<SessionInfo>(info); 3514 auto task = [weakThis = wptr(this), persistentId = persistentId_, 3515 sessionInfo, needRemoveSession, startFail, env = env_] { 3516 auto jsSceneSession = weakThis.promote(); 3517 if (!jsSceneSession || jsSceneSessionMap_.find(persistentId) == jsSceneSessionMap_.end()) { 3518 TLOGE(WmsLogTag::WMS_LIFE, "OnSessionException jsSceneSession id:%{public}d has been destroyed", 3519 persistentId); 3520 return; 3521 } 3522 auto jsCallBack = jsSceneSession->GetJSCallback(SESSION_EXCEPTION_CB); 3523 if (!jsCallBack) { 3524 TLOGE(WmsLogTag::WMS_LIFE, "[NAPI]jsCallBack is nullptr"); 3525 return; 3526 } 3527 if (sessionInfo == nullptr) { 3528 TLOGE(WmsLogTag::WMS_LIFE, "[NAPI]sessionInfo is nullptr"); 3529 return; 3530 } 3531 napi_value jsSessionInfo = CreateJsSessionInfo(env, *sessionInfo); 3532 napi_value jsNeedRemoveSession = CreateJsValue(env, needRemoveSession); 3533 napi_value jsStartFail = CreateJsValue(env, startFail); 3534 if (jsSessionInfo == nullptr) { 3535 TLOGE(WmsLogTag::WMS_LIFE, "[NAPI]target session info is nullptr"); 3536 return; 3537 } 3538 napi_value argv[] = {jsSessionInfo, jsNeedRemoveSession, jsStartFail}; 3539 napi_call_function(env, NapiGetUndefined(env), jsCallBack->GetNapiValue(), ArraySize(argv), argv, nullptr); 3540 }; 3541 taskScheduler_->PostMainThreadTask(task, "OnSessionException, name" + info.bundleName_); 3542 } 3543 PendingSessionToForeground(const SessionInfo & info)3544 void JsSceneSession::PendingSessionToForeground(const SessionInfo& info) 3545 { 3546 TLOGI(WmsLogTag::WMS_LIFE, "[NAPI]bundleName = %{public}s, abilityName = %{public}s", 3547 info.bundleName_.c_str(), info.abilityName_.c_str()); 3548 3549 std::shared_ptr<SessionInfo> sessionInfo = std::make_shared<SessionInfo>(info); 3550 auto task = [weakThis = wptr(this), persistentId = persistentId_, sessionInfo, env = env_] { 3551 auto jsSceneSession = weakThis.promote(); 3552 if (!jsSceneSession || jsSceneSessionMap_.find(persistentId) == jsSceneSessionMap_.end()) { 3553 TLOGE(WmsLogTag::WMS_LIFE, "PendingSessionToForeground jsSceneSession id:%{public}d has been destroyed", 3554 persistentId); 3555 return; 3556 } 3557 auto jsCallBack = jsSceneSession->GetJSCallback(PENDING_SESSION_TO_FOREGROUND_CB); 3558 if (!jsCallBack) { 3559 TLOGE(WmsLogTag::WMS_LIFE, "[NAPI]jsCallBack is nullptr"); 3560 return; 3561 } 3562 if (sessionInfo == nullptr) { 3563 TLOGE(WmsLogTag::WMS_LIFE, "[NAPI]sessionInfo is nullptr"); 3564 return; 3565 } 3566 napi_value jsSessionInfo = CreateJsSessionInfo(env, *sessionInfo); 3567 if (jsSessionInfo == nullptr) { 3568 TLOGE(WmsLogTag::WMS_LIFE, "[NAPI]target session info is nullptr"); 3569 return; 3570 } 3571 napi_value argv[] = {jsSessionInfo}; 3572 napi_call_function(env, NapiGetUndefined(env), jsCallBack->GetNapiValue(), ArraySize(argv), argv, nullptr); 3573 }; 3574 taskScheduler_->PostMainThreadTask(task, "PendingSessionToForeground:" + info.bundleName_); 3575 } 3576 PendingSessionToBackgroundForDelegator(const SessionInfo & info,bool shouldBackToCaller)3577 void JsSceneSession::PendingSessionToBackgroundForDelegator(const SessionInfo& info, bool shouldBackToCaller) 3578 { 3579 TLOGI(WmsLogTag::WMS_LIFE, 3580 "[NAPI]bundleName = %{public}s, abilityName = %{public}s, shouldBackToCaller = %{public}d", 3581 info.bundleName_.c_str(), info.abilityName_.c_str(), shouldBackToCaller); 3582 3583 std::shared_ptr<SessionInfo> sessionInfo = std::make_shared<SessionInfo>(info); 3584 auto task = [weakThis = wptr(this), persistentId = persistentId_, sessionInfo, env = env_, shouldBackToCaller] { 3585 auto jsSceneSession = weakThis.promote(); 3586 if (!jsSceneSession || jsSceneSessionMap_.find(persistentId) == jsSceneSessionMap_.end()) { 3587 TLOGNE(WmsLogTag::WMS_LIFE, "jsSceneSession id:%{public}d has been destroyed", persistentId); 3588 return; 3589 } 3590 auto jsCallBack = jsSceneSession->GetJSCallback(PENDING_SESSION_TO_BACKGROUND_FOR_DELEGATOR_CB); 3591 if (!jsCallBack) { 3592 TLOGNE(WmsLogTag::WMS_LIFE, "[NAPI]jsCallBack is nullptr"); 3593 return; 3594 } 3595 napi_value jsSessionInfo = CreateJsSessionInfo(env, *sessionInfo); 3596 napi_value jsShouldBackToCaller = CreateJsValue(env, shouldBackToCaller); 3597 if (jsSessionInfo == nullptr) { 3598 TLOGNE(WmsLogTag::WMS_LIFE, "[NAPI]target session info is nullptr"); 3599 return; 3600 } 3601 napi_value argv[] = {jsSessionInfo, jsShouldBackToCaller}; 3602 napi_call_function(env, NapiGetUndefined(env), jsCallBack->GetNapiValue(), ArraySize(argv), argv, nullptr); 3603 }; 3604 taskScheduler_->PostMainThreadTask(task, "PendingSessionToBackgroundForDelegator, name:" + info.bundleName_); 3605 } 3606 OnSystemBarPropertyChange(const std::unordered_map<WindowType,SystemBarProperty> & propertyMap)3607 void JsSceneSession::OnSystemBarPropertyChange(const std::unordered_map<WindowType, SystemBarProperty>& propertyMap) 3608 { 3609 TLOGD(WmsLogTag::WMS_IMMS, "[NAPI]OnSystemBarPropertyChange"); 3610 3611 auto task = [weakThis = wptr(this), persistentId = persistentId_, propertyMap, env = env_] { 3612 auto jsSceneSession = weakThis.promote(); 3613 if (!jsSceneSession || jsSceneSessionMap_.find(persistentId) == jsSceneSessionMap_.end()) { 3614 TLOGE(WmsLogTag::WMS_LIFE, "OnSystemBarPropertyChange jsSceneSession id:%{public}d has been destroyed", 3615 persistentId); 3616 return; 3617 } 3618 auto jsCallBack = jsSceneSession->GetJSCallback(SYSTEMBAR_PROPERTY_CHANGE_CB); 3619 if (jsCallBack == nullptr) { 3620 WLOGFE("[NAPI]jsCallBack is nullptr"); 3621 return; 3622 } 3623 napi_value jsSessionStateObj = CreateJsSystemBarPropertyArrayObject(env, propertyMap); 3624 if (jsSessionStateObj == nullptr) { 3625 TLOGE(WmsLogTag::WMS_IMMS, "[NAPI]jsSessionStateObj is nullptr"); 3626 return; 3627 } 3628 napi_value argv[] = {jsSessionStateObj}; 3629 napi_call_function(env, NapiGetUndefined(env), jsCallBack->GetNapiValue(), ArraySize(argv), argv, nullptr); 3630 }; 3631 taskScheduler_->PostMainThreadTask(task, "OnSystemBarPropertyChange"); 3632 } 3633 OnNeedAvoid(bool status)3634 void JsSceneSession::OnNeedAvoid(bool status) 3635 { 3636 TLOGD(WmsLogTag::WMS_IMMS, "[NAPI]OnNeedAvoid %{public}d", status); 3637 3638 auto task = [weakThis = wptr(this), persistentId = persistentId_, needAvoid = status, env = env_] { 3639 auto jsSceneSession = weakThis.promote(); 3640 if (!jsSceneSession || jsSceneSessionMap_.find(persistentId) == jsSceneSessionMap_.end()) { 3641 TLOGE(WmsLogTag::WMS_LIFE, "OnNeedAvoid jsSceneSession id:%{public}d has been destroyed", 3642 persistentId); 3643 return; 3644 } 3645 auto jsCallBack = jsSceneSession->GetJSCallback(NEED_AVOID_CB); 3646 if (jsCallBack == nullptr) { 3647 WLOGFE("[NAPI]jsCallBack is nullptr"); 3648 return; 3649 } 3650 napi_value jsSessionStateObj = CreateJsValue(env, needAvoid); 3651 napi_value argv[] = {jsSessionStateObj}; 3652 napi_call_function(env, NapiGetUndefined(env), jsCallBack->GetNapiValue(), ArraySize(argv), argv, nullptr); 3653 }; 3654 taskScheduler_->PostMainThreadTask(task, "OnNeedAvoid:" + std::to_string(status)); 3655 } 3656 OnIsCustomAnimationPlaying(bool status)3657 void JsSceneSession::OnIsCustomAnimationPlaying(bool status) 3658 { 3659 WLOGFI("[NAPI]OnIsCustomAnimationPlaying %{public}d", status); 3660 3661 auto task = [weakThis = wptr(this), persistentId = persistentId_, isPlaying = status, env = env_] { 3662 auto jsSceneSession = weakThis.promote(); 3663 if (!jsSceneSession || jsSceneSessionMap_.find(persistentId) == jsSceneSessionMap_.end()) { 3664 TLOGE(WmsLogTag::WMS_LIFE, "OnIsCustomAnimationPlaying jsSceneSession id:%{public}d has been destroyed", 3665 persistentId); 3666 return; 3667 } 3668 auto jsCallBack = jsSceneSession->GetJSCallback(CUSTOM_ANIMATION_PLAYING_CB); 3669 if (jsCallBack == nullptr) { 3670 WLOGFE("[NAPI]jsCallBack is nullptr"); 3671 return; 3672 } 3673 napi_value jsSessionStateObj = CreateJsValue(env, isPlaying); 3674 napi_value argv[] = {jsSessionStateObj}; 3675 napi_call_function(env, NapiGetUndefined(env), jsCallBack->GetNapiValue(), ArraySize(argv), argv, nullptr); 3676 }; 3677 taskScheduler_->PostMainThreadTask(task, "OnIsCustomAnimationPlaying:" + std::to_string(status)); 3678 } 3679 OnShowWhenLocked(bool showWhenLocked)3680 void JsSceneSession::OnShowWhenLocked(bool showWhenLocked) 3681 { 3682 WLOGFI("[NAPI]OnShowWhenLocked %{public}d", showWhenLocked); 3683 3684 auto task = [weakThis = wptr(this), persistentId = persistentId_, flag = showWhenLocked, env = env_] { 3685 auto jsSceneSession = weakThis.promote(); 3686 if (!jsSceneSession || jsSceneSessionMap_.find(persistentId) == jsSceneSessionMap_.end()) { 3687 TLOGE(WmsLogTag::WMS_LIFE, "OnShowWhenLocked jsSceneSession id:%{public}d has been destroyed", 3688 persistentId); 3689 return; 3690 } 3691 auto jsCallBack = jsSceneSession->GetJSCallback(SHOW_WHEN_LOCKED_CB); 3692 if (jsCallBack == nullptr) { 3693 WLOGFE("[NAPI]jsCallBack is nullptr"); 3694 return; 3695 } 3696 napi_value jsSessionStateObj = CreateJsValue(env, flag); 3697 napi_value argv[] = {jsSessionStateObj}; 3698 napi_call_function(env, NapiGetUndefined(env), jsCallBack->GetNapiValue(), ArraySize(argv), argv, nullptr); 3699 }; 3700 taskScheduler_->PostMainThreadTask(task, "OnShowWhenLocked:" +std::to_string(showWhenLocked)); 3701 } 3702 OnReuqestedOrientationChange(uint32_t orientation)3703 void JsSceneSession::OnReuqestedOrientationChange(uint32_t orientation) 3704 { 3705 WLOGFI("[NAPI]OnReuqestedOrientationChange %{public}u", orientation); 3706 3707 auto task = [weakThis = wptr(this), persistentId = persistentId_, rotation = orientation, env = env_] { 3708 auto jsSceneSession = weakThis.promote(); 3709 if (!jsSceneSession || jsSceneSessionMap_.find(persistentId) == jsSceneSessionMap_.end()) { 3710 TLOGE(WmsLogTag::WMS_LIFE, "OnReuqestedOrientationChange jsSceneSession id:%{public}d has been destroyed", 3711 persistentId); 3712 return; 3713 } 3714 auto jsCallBack = jsSceneSession->GetJSCallback(REQUESTED_ORIENTATION_CHANGE_CB); 3715 if (jsCallBack == nullptr) { 3716 WLOGFE("[NAPI]jsCallBack is nullptr"); 3717 return; 3718 } 3719 napi_value jsSessionRotationObj = CreateJsValue(env, rotation); 3720 napi_value argv[] = {jsSessionRotationObj}; 3721 napi_call_function(env, NapiGetUndefined(env), jsCallBack->GetNapiValue(), ArraySize(argv), argv, nullptr); 3722 WLOGFI("[NAPI]change rotation success %{public}u", rotation); 3723 }; 3724 taskScheduler_->PostMainThreadTask(task, "OnReuqestedOrientationChange:orientation" +std::to_string(orientation)); 3725 } 3726 OnSetShowRecent(napi_env env,napi_callback_info info)3727 napi_value JsSceneSession::OnSetShowRecent(napi_env env, napi_callback_info info) 3728 { 3729 auto session = weakSession_.promote(); 3730 if (session == nullptr) { 3731 WLOGFE("[NAPI]session is null, id:%{public}d", persistentId_); 3732 return NapiGetUndefined(env); 3733 } 3734 size_t argc = 4; 3735 napi_value argv[4] = {nullptr}; 3736 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr); 3737 bool showRecent = true; 3738 if (argc == ARGC_ONE && GetType(env, argv[0]) == napi_boolean) { 3739 if (!ConvertFromJsValue(env, argv[0], showRecent)) { 3740 WLOGFE("[NAPI]Failed to convert parameter to bool"); 3741 return NapiGetUndefined(env); 3742 } 3743 } 3744 session->SetShowRecent(showRecent); 3745 return NapiGetUndefined(env); 3746 } 3747 OnSetZOrder(napi_env env,napi_callback_info info)3748 napi_value JsSceneSession::OnSetZOrder(napi_env env, napi_callback_info info) 3749 { 3750 size_t argc = 4; 3751 napi_value argv[4] = {nullptr}; 3752 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr); 3753 if (argc != 1) { // 1: params num 3754 WLOGFE("[NAPI]Argc is invalid: %{public}zu", argc); 3755 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 3756 "Input parameter is missing or invalid")); 3757 return NapiGetUndefined(env); 3758 } 3759 uint32_t zOrder; 3760 if (!ConvertFromJsValue(env, argv[0], zOrder)) { 3761 WLOGFE("[NAPI]Failed to convert parameter to uint32_t"); 3762 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 3763 "Input parameter is missing or invalid")); 3764 return NapiGetUndefined(env); 3765 } 3766 auto session = weakSession_.promote(); 3767 if (session == nullptr) { 3768 WLOGFW("[NAPI]session is null, id:%{public}d", persistentId_); 3769 return NapiGetUndefined(env); 3770 } 3771 session->SetZOrder(zOrder); 3772 return NapiGetUndefined(env); 3773 } 3774 OnSetFloatingScale(napi_env env,napi_callback_info info)3775 napi_value JsSceneSession::OnSetFloatingScale(napi_env env, napi_callback_info info) 3776 { 3777 size_t argc = 4; 3778 napi_value argv[4] = {nullptr}; 3779 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr); 3780 if (argc < 1) { // 1: params num 3781 WLOGFE("[NAPI]Argc is invalid: %{public}zu", argc); 3782 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 3783 "Input parameter is missing or invalid")); 3784 return NapiGetUndefined(env); 3785 } 3786 double_t floatingScale = 1.0; 3787 if (!ConvertFromJsValue(env, argv[0], floatingScale)) { 3788 WLOGFE("[NAPI]Failed to convert parameter to bool"); 3789 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 3790 "Input parameter is missing or invalid")); 3791 return NapiGetUndefined(env); 3792 } 3793 auto session = weakSession_.promote(); 3794 if (session == nullptr) { 3795 WLOGFE("[NAPI]session is nullptr, id:%{public}d", persistentId_); 3796 return NapiGetUndefined(env); 3797 } 3798 session->SetFloatingScale(static_cast<float_t>(floatingScale)); 3799 return NapiGetUndefined(env); 3800 } 3801 OnSetIsMidScene(napi_env env,napi_callback_info info)3802 napi_value JsSceneSession::OnSetIsMidScene(napi_env env, napi_callback_info info) 3803 { 3804 size_t argc = ARGC_FOUR; 3805 napi_value argv[ARGC_FOUR] = {nullptr}; 3806 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr); 3807 if (argc < ARGC_ONE) { 3808 TLOGE(WmsLogTag::WMS_MULTI_WINDOW, "[NAPI]Argc is invalid: %{public}zu", argc); 3809 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 3810 "Input parameter is missing or invalid")); 3811 return NapiGetUndefined(env); 3812 } 3813 3814 bool isMidScene = false; 3815 if (!ConvertFromJsValue(env, argv[0], isMidScene)) { 3816 TLOGE(WmsLogTag::WMS_MULTI_WINDOW, "[NAPI]Failed to convert parameter to isMidScene"); 3817 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 3818 "Input parameter is missing or invalid")); 3819 return NapiGetUndefined(env); 3820 } 3821 3822 auto session = weakSession_.promote(); 3823 if (session == nullptr) { 3824 TLOGE(WmsLogTag::WMS_MULTI_WINDOW, "[NAPI]session is nullptr, id:%{public}d", persistentId_); 3825 return NapiGetUndefined(env); 3826 } 3827 session->SetIsMidScene(isMidScene); 3828 return NapiGetUndefined(env); 3829 } 3830 OnSetSCBKeepKeyboard(napi_env env,napi_callback_info info)3831 napi_value JsSceneSession::OnSetSCBKeepKeyboard(napi_env env, napi_callback_info info) 3832 { 3833 size_t argc = 4; 3834 napi_value argv[4] = {nullptr}; 3835 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr); 3836 if (argc < 1) { 3837 WLOGFE("[NAPI]Argc is invalid: %{public}zu", argc); 3838 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 3839 "Input parameter is missing or invalid")); 3840 return NapiGetUndefined(env); 3841 } 3842 bool scbKeepKeyboardFlag = false; 3843 if (!ConvertFromJsValue(env, argv[0], scbKeepKeyboardFlag)) { 3844 WLOGFE("[NAPI]Failed to convert parameter to bool"); 3845 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 3846 "Input parameter is missing or invalid")); 3847 return NapiGetUndefined(env); 3848 } 3849 auto session = weakSession_.promote(); 3850 if (session == nullptr) { 3851 WLOGFE("[NAPI]session is nullptr, id:%{public}d", persistentId_); 3852 return NapiGetUndefined(env); 3853 } 3854 session->SetSCBKeepKeyboard(scbKeepKeyboardFlag); 3855 return NapiGetUndefined(env); 3856 } 3857 OnSetOffset(napi_env env,napi_callback_info info)3858 napi_value JsSceneSession::OnSetOffset(napi_env env, napi_callback_info info) 3859 { 3860 size_t argc = 4; 3861 napi_value argv[4] = {nullptr}; 3862 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr); 3863 if (argc != 2) { 3864 WLOGFE("[NAPI]Argc count is invalid: %{public}zu", argc); 3865 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 3866 "Input parameter is missing or invalid")); 3867 return NapiGetUndefined(env); 3868 } 3869 3870 double offsetX = 0.0f; 3871 if (!ConvertFromJsValue(env, argv[0], offsetX)) { 3872 WLOGFE("[NAPI]Failed to convert parameter to double"); 3873 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 3874 "Input parameter is missing or invalid")); 3875 return NapiGetUndefined(env); 3876 } 3877 3878 double offsetY = 0.0f; 3879 if (!ConvertFromJsValue(env, argv[1], offsetY)) { 3880 WLOGFE("[NAPI]Failed to convert parameter to double"); 3881 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 3882 "Input parameter is missing or invalid")); 3883 return NapiGetUndefined(env); 3884 } 3885 3886 auto session = weakSession_.promote(); 3887 if (session == nullptr) { 3888 WLOGFE("[NAPI]session is nullptr, id:%{public}d", persistentId_); 3889 return NapiGetUndefined(env); 3890 } 3891 session->SetOffset(static_cast<float>(offsetX), static_cast<float>(offsetY)); 3892 return NapiGetUndefined(env); 3893 } 3894 OnSetExitSplitOnBackground(napi_env env,napi_callback_info info)3895 napi_value JsSceneSession::OnSetExitSplitOnBackground(napi_env env, napi_callback_info info) 3896 { 3897 size_t argc = ARGC_FOUR; 3898 napi_value argv[ARGC_FOUR] = {nullptr}; 3899 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr); 3900 if (argc != 1) { 3901 TLOGE(WmsLogTag::WMS_MULTI_WINDOW, "[NAPI]Argc count is invalid: %{public}zu", argc); 3902 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 3903 "Input parameter is missing or invalid")); 3904 return NapiGetUndefined(env); 3905 } 3906 3907 bool isExitSplitOnBackground = false; 3908 if (!ConvertFromJsValue(env, argv[0], isExitSplitOnBackground)) { 3909 TLOGE(WmsLogTag::WMS_MULTI_WINDOW, "[NAPI]Failed to convert parameter to bool"); 3910 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 3911 "Input parameter is missing or invalid")); 3912 return NapiGetUndefined(env); 3913 } 3914 3915 auto session = weakSession_.promote(); 3916 if (session == nullptr) { 3917 TLOGE(WmsLogTag::WMS_MULTI_WINDOW, "[NAPI]session is nullptr, id:%{public}d", persistentId_); 3918 return NapiGetUndefined(env); 3919 } 3920 session->SetExitSplitOnBackground(isExitSplitOnBackground); 3921 return NapiGetUndefined(env); 3922 } 3923 OnSetWaterMarkFlag(napi_env env,napi_callback_info info)3924 napi_value JsSceneSession::OnSetWaterMarkFlag(napi_env env, napi_callback_info info) 3925 { 3926 size_t argc = ARGC_FOUR; 3927 napi_value argv[ARGC_FOUR] = {nullptr}; 3928 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr); 3929 if (argc < ARGC_ONE) { 3930 TLOGE(WmsLogTag::WMS_SCB, "[NAPI]Argc is invalid: %{public}zu", argc); 3931 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 3932 "Input parameter is missing or invalid")); 3933 return NapiGetUndefined(env); 3934 } 3935 3936 bool isWaterMarkAdded = false; 3937 if (!ConvertFromJsValue(env, argv[0], isWaterMarkAdded)) { 3938 TLOGE(WmsLogTag::WMS_SCB, "[NAPI]Failed to convert parameter to bool"); 3939 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 3940 "Input parameter is missing or invalid")); 3941 return NapiGetUndefined(env); 3942 } 3943 3944 auto session = weakSession_.promote(); 3945 if (session == nullptr) { 3946 TLOGE(WmsLogTag::WMS_SCB, "[NAPI]session is nullptr, id:%{public}d", persistentId_); 3947 return NapiGetUndefined(env); 3948 } 3949 3950 sptr<WindowSessionProperty> property = new WindowSessionProperty(); 3951 if (property == nullptr) { 3952 TLOGE(WmsLogTag::WMS_SCB, "[NAPI]property is nullptr"); 3953 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 3954 "Input parameter is missing or invalid")); 3955 return NapiGetUndefined(env); 3956 } 3957 3958 uint32_t currFlag = session->GetSessionProperty()->GetWindowFlags(); 3959 if (isWaterMarkAdded) { 3960 currFlag = currFlag | static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_WATER_MARK); 3961 } else { 3962 currFlag = currFlag & ~(static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_WATER_MARK)); 3963 } 3964 property->SetSystemCalling(true); 3965 property->SetWindowFlags(currFlag); 3966 SceneSessionManager::GetInstance().SetWindowFlags(session, property); 3967 return NapiGetUndefined(env); 3968 } 3969 ProcessPrepareClosePiPSessionRegister()3970 void JsSceneSession::ProcessPrepareClosePiPSessionRegister() 3971 { 3972 auto session = weakSession_.promote(); 3973 if (session == nullptr) { 3974 TLOGE(WmsLogTag::WMS_PIP, "session is nullptr, id:%{public}d", persistentId_); 3975 return; 3976 } 3977 session->RegisterProcessPrepareClosePiPCallback([weakThis = wptr(this)] { 3978 auto jsSceneSession = weakThis.promote(); 3979 if (!jsSceneSession) { 3980 TLOGNE(WmsLogTag::WMS_LIFE, "OnPrepareClosePiPSession jsSceneSession is null"); 3981 return; 3982 } 3983 jsSceneSession->OnPrepareClosePiPSession(); 3984 }); 3985 TLOGD(WmsLogTag::WMS_PIP, "success"); 3986 } 3987 OnPrepareClosePiPSession()3988 void JsSceneSession::OnPrepareClosePiPSession() 3989 { 3990 TLOGI(WmsLogTag::WMS_PIP, "[NAPI]OnPrepareClosePiPSession"); 3991 auto task = [weakThis = wptr(this), persistentId = persistentId_, env = env_] { 3992 auto jsSceneSession = weakThis.promote(); 3993 if (!jsSceneSession || jsSceneSessionMap_.find(persistentId) == jsSceneSessionMap_.end()) { 3994 TLOGE(WmsLogTag::WMS_LIFE, "OnPrepareClosePiPSession jsSceneSession id:%{public}d has been destroyed", 3995 persistentId); 3996 return; 3997 } 3998 auto jsCallBack = jsSceneSession->GetJSCallback(PREPARE_CLOSE_PIP_SESSION); 3999 if (!jsCallBack) { 4000 TLOGE(WmsLogTag::WMS_PIP, "[NAPI]jsCallBack is nullptr"); 4001 return; 4002 } 4003 napi_value argv[] = {}; 4004 napi_call_function(env, NapiGetUndefined(env), jsCallBack->GetNapiValue(), 0, argv, nullptr); 4005 }; 4006 taskScheduler_->PostMainThreadTask(task, "OnPrepareClosePiPSession"); 4007 } 4008 OnSetSystemActive(napi_env env,napi_callback_info info)4009 napi_value JsSceneSession::OnSetSystemActive(napi_env env, napi_callback_info info) 4010 { 4011 size_t argc = 4; 4012 napi_value argv[4] = { nullptr }; 4013 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr); 4014 if (argc < 1) { 4015 WLOGFE("[NAPI]argc is invalid : %{public}zu", argc); 4016 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 4017 "Input parameter is missing or invalid")); 4018 return NapiGetUndefined(env); 4019 } 4020 bool scbSystemActive = false; 4021 if (!ConvertFromJsValue(env, argv[0], scbSystemActive)){ 4022 WLOGFE("[NAPI] Failed to convert parameter to bool"); 4023 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 4024 "Input parameter is missing or invalid")); 4025 return NapiGetUndefined(env); 4026 } 4027 auto session = weakSession_.promote(); 4028 if (session == nullptr) { 4029 WLOGFE("[NAPI] session is null, id:%{public}d", persistentId_); 4030 return NapiGetUndefined(env); 4031 } 4032 session->SetSystemActive(scbSystemActive); 4033 return NapiGetUndefined(env); 4034 } 4035 OnSetTouchable(napi_env env,napi_callback_info info)4036 napi_value JsSceneSession::OnSetTouchable(napi_env env, napi_callback_info info) 4037 { 4038 size_t argc = 4; 4039 napi_value argv[4] = { nullptr }; 4040 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr); 4041 if (argc != 1) { 4042 WLOGFE("[NAPI] Argc is invalid: %{public}zu", argc); 4043 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 4044 "Input Parameter is missing or invalid" )); 4045 return NapiGetUndefined(env); 4046 } 4047 4048 bool touchable = false; 4049 if (!ConvertFromJsValue(env, argv[0], touchable)) { 4050 WLOGFE("[NAPI] Failed to convert parameter to touchable"); 4051 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 4052 "Input parameter is missing or invalid" )); 4053 return NapiGetUndefined(env); 4054 } 4055 4056 auto session = weakSession_.promote(); 4057 if (session == nullptr) { 4058 WLOGFE("[NAPI] session is null, id:%{public}d", persistentId_); 4059 return NapiGetUndefined(env); 4060 } 4061 4062 session->SetSystemTouchable(touchable); 4063 return NapiGetUndefined(env); 4064 } 4065 SetScale(napi_env env,napi_callback_info info)4066 napi_value JsSceneSession::SetScale(napi_env env, napi_callback_info info) 4067 { 4068 if (Session::IsScbCoreEnabled()) { 4069 return nullptr; 4070 } 4071 WLOGI("[NAPI]SetScale"); 4072 JsSceneSession* me = CheckParamsAndGetThis<JsSceneSession>(env, info); 4073 return (me != nullptr) ? me->OnSetScale(env, info) : nullptr; 4074 } 4075 OnSetScale(napi_env env,napi_callback_info info)4076 napi_value JsSceneSession::OnSetScale(napi_env env, napi_callback_info info) 4077 { 4078 size_t argc = ARG_COUNT_4; 4079 napi_value argv[ARG_COUNT_4] = {nullptr}; 4080 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr); 4081 if (argc < ARG_COUNT_4) { // ARG_COUNT_4: params num 4082 WLOGFE("[NAPI]Argc is invalid: %{public}zu", argc); 4083 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 4084 "Input parameter is missing or invalid")); 4085 return NapiGetUndefined(env); 4086 } 4087 double_t scaleX = 1.0; 4088 if (!ConvertFromJsValue(env, argv[ARG_INDEX_0], scaleX)) { 4089 WLOGFE("[NAPI]Failed to convert parameter to scaleX"); 4090 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 4091 "Input parameter is missing or invalid")); 4092 return NapiGetUndefined(env); 4093 } 4094 double_t scaleY = 1.0; 4095 if (!ConvertFromJsValue(env, argv[ARG_INDEX_1], scaleY)) { 4096 WLOGFE("[NAPI]Failed to convert parameter to scaleY"); 4097 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 4098 "Input parameter is missing or invalid")); 4099 return NapiGetUndefined(env); 4100 } 4101 double_t pivotX = 0.0; 4102 if (!ConvertFromJsValue(env, argv[ARG_INDEX_2], pivotX)) { 4103 WLOGFE("[NAPI]Failed to convert parameter to pivotX"); 4104 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 4105 "Input parameter is missing or invalid")); 4106 return NapiGetUndefined(env); 4107 } 4108 double_t pivotY = 0.0; 4109 if (!ConvertFromJsValue(env, argv[ARG_INDEX_3], pivotY)) { 4110 WLOGFE("[NAPI]Failed to convert parameter to pivotY"); 4111 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 4112 "Input parameter is missing or invalid")); 4113 return NapiGetUndefined(env); 4114 } 4115 auto session = weakSession_.promote(); 4116 if (session == nullptr) { 4117 WLOGFE("[NAPI]session is nullptr, id:%{public}d", persistentId_); 4118 return NapiGetUndefined(env); 4119 } 4120 session->SetScale(static_cast<float_t>(scaleX), static_cast<float_t>(scaleY), static_cast<float_t>(pivotX), 4121 static_cast<float_t>(pivotY)); 4122 return NapiGetUndefined(env); 4123 } 4124 SetWindowLastSafeRect(napi_env env,napi_callback_info info)4125 napi_value JsSceneSession::SetWindowLastSafeRect(napi_env env, napi_callback_info info) 4126 { 4127 TLOGI(WmsLogTag::WMS_LAYOUT, "[NAPI]"); 4128 JsSceneSession* me = CheckParamsAndGetThis<JsSceneSession>(env, info); 4129 return (me != nullptr) ? me->OnSetWindowLastSafeRect(env, info) : nullptr; 4130 } 4131 OnSetWindowLastSafeRect(napi_env env,napi_callback_info info)4132 napi_value JsSceneSession::OnSetWindowLastSafeRect(napi_env env, napi_callback_info info) 4133 { 4134 size_t argc = ARG_COUNT_4; 4135 napi_value argv[ARG_COUNT_4] = {nullptr}; 4136 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr); 4137 if (argc < ARG_COUNT_4) { 4138 TLOGE(WmsLogTag::WMS_LAYOUT, "[NAPI]Argc is invalid: %{public}zu", argc); 4139 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 4140 "Input parameter is missing or invalid")); 4141 return NapiGetUndefined(env); 4142 } 4143 int32_t left = 0; 4144 if (!ConvertFromJsValue(env, argv[ARG_INDEX_0], left)) { 4145 TLOGE(WmsLogTag::WMS_LAYOUT, "[NAPI]Failed to convert parameter to left"); 4146 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 4147 "Input parameter is missing or invalid")); 4148 return NapiGetUndefined(env); 4149 } 4150 int32_t top = 0; 4151 if (!ConvertFromJsValue(env, argv[ARG_INDEX_1], top)) { 4152 TLOGE(WmsLogTag::WMS_LAYOUT, "[NAPI]Failed to convert parameter to top"); 4153 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 4154 "Input parameter is missing or invalid")); 4155 return NapiGetUndefined(env); 4156 } 4157 int32_t width = 0; 4158 if (!ConvertFromJsValue(env, argv[ARG_INDEX_2], width)) { 4159 TLOGE(WmsLogTag::WMS_LAYOUT, "[NAPI]Failed to convert parameter to width"); 4160 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 4161 "Input parameter is missing or invalid")); 4162 return NapiGetUndefined(env); 4163 } 4164 int32_t height = 0; 4165 if (!ConvertFromJsValue(env, argv[ARG_INDEX_3], height)) { 4166 TLOGE(WmsLogTag::WMS_LAYOUT, "[NAPI]Failed to convert parameter to height"); 4167 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 4168 "Input parameter is missing or invalid")); 4169 return NapiGetUndefined(env); 4170 } 4171 auto session = weakSession_.promote(); 4172 if (session == nullptr) { 4173 TLOGE(WmsLogTag::WMS_LAYOUT, "[NAPI]session is nullptr, id:%{public}d", persistentId_); 4174 return NapiGetUndefined(env); 4175 } 4176 WSRect lastRect = { left, top, width, height }; 4177 session->SetSessionRequestRect(lastRect); 4178 return NapiGetUndefined(env); 4179 } 4180 RequestHideKeyboard(napi_env env,napi_callback_info info)4181 napi_value JsSceneSession::RequestHideKeyboard(napi_env env, napi_callback_info info) 4182 { 4183 WLOGI("[NAPI]RequestHideKeyboard"); 4184 JsSceneSession* me = CheckParamsAndGetThis<JsSceneSession>(env, info); 4185 return (me != nullptr) ? me->OnRequestHideKeyboard(env, info) : nullptr; 4186 } 4187 OnRequestHideKeyboard(napi_env env,napi_callback_info info)4188 napi_value JsSceneSession::OnRequestHideKeyboard(napi_env env, napi_callback_info info) 4189 { 4190 WLOGFI("[NAPI]OnRequestHideKeyboard"); 4191 auto session = weakSession_.promote(); 4192 if (session == nullptr) { 4193 WLOGFE("[NAPI]session is nullptr, id:%{public}d", persistentId_); 4194 return NapiGetUndefined(env); 4195 } 4196 session->RequestHideKeyboard(); 4197 return NapiGetUndefined(env); 4198 } 4199 OnSetPipActionEvent(napi_env env,napi_callback_info info)4200 napi_value JsSceneSession::OnSetPipActionEvent(napi_env env, napi_callback_info info) 4201 { 4202 size_t argc = 4; 4203 napi_value argv[4] = {nullptr}; 4204 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr); 4205 if (argc < 1) { 4206 TLOGE(WmsLogTag::WMS_PIP, "[NAPI]Argc count is invalid: %{public}zu", argc); 4207 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 4208 "Input parameter is missing or invalid")); 4209 return NapiGetUndefined(env); 4210 } 4211 std::string action; 4212 if (!ConvertFromJsValue(env, argv[0], action)) { 4213 TLOGE(WmsLogTag::WMS_PIP, "[NAPI]Failed to convert parameter to string"); 4214 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 4215 "Input parameter is missing or invalid")); 4216 return NapiGetUndefined(env); 4217 } 4218 int32_t status = -1; 4219 if (argc > 1) { 4220 if (!ConvertFromJsValue(env, argv[1], status)) { 4221 TLOGE(WmsLogTag::WMS_PIP, "[NAPI]Failed to convert parameter to int"); 4222 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 4223 "Input parameter is missing or invalid")); 4224 return NapiGetUndefined(env); 4225 } 4226 } 4227 4228 auto session = weakSession_.promote(); 4229 if (session == nullptr) { 4230 TLOGE(WmsLogTag::WMS_PIP, "[NAPI]session is nullptr, id:%{public}d", persistentId_); 4231 return NapiGetUndefined(env); 4232 } 4233 session->SetPipActionEvent(action, status); 4234 return NapiGetUndefined(env); 4235 } 4236 OnSetPiPControlEvent(napi_env env,napi_callback_info info)4237 napi_value JsSceneSession::OnSetPiPControlEvent(napi_env env, napi_callback_info info) 4238 { 4239 size_t argc = ARG_COUNT_4; 4240 napi_value argv[ARG_COUNT_4] = {nullptr}; 4241 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr); 4242 if (argc < 1) { 4243 TLOGE(WmsLogTag::WMS_PIP, "[NAPI]Argc count is invalid: %{public}zu", argc); 4244 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 4245 "Input parameter is missing or invalid")); 4246 return NapiGetUndefined(env); 4247 } 4248 auto controlType = WsPiPControlType::VIDEO_PLAY_PAUSE; 4249 if (!ConvertFromJsValue(env, argv[0], controlType)) { 4250 TLOGE(WmsLogTag::WMS_PIP, "[NAPI]Failed to convert parameter to int"); 4251 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 4252 "Input parameter is missing or invalid")); 4253 return NapiGetUndefined(env); 4254 } 4255 auto status = WsPiPControlStatus::PLAY; 4256 if (argc > 1) { 4257 if (!ConvertFromJsValue(env, argv[1], status)) { 4258 TLOGE(WmsLogTag::WMS_PIP, "[NAPI]Failed to convert parameter to int"); 4259 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 4260 "Input parameter is missing or invalid")); 4261 return NapiGetUndefined(env); 4262 } 4263 } 4264 4265 auto session = weakSession_.promote(); 4266 if (session == nullptr) { 4267 TLOGE(WmsLogTag::WMS_PIP, "[NAPI]session is nullptr, id:%{public}d", persistentId_); 4268 return NapiGetUndefined(env); 4269 } 4270 session->SetPiPControlEvent(controlType, status); 4271 return NapiGetUndefined(env); 4272 } 4273 OnNotifyPipOcclusionChange(napi_env env,napi_callback_info info)4274 napi_value JsSceneSession::OnNotifyPipOcclusionChange(napi_env env, napi_callback_info info) 4275 { 4276 size_t argc = ARG_COUNT_4; 4277 napi_value argv[ARG_COUNT_4] = {nullptr}; 4278 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr); 4279 if (argc < 1) { 4280 TLOGE(WmsLogTag::WMS_PIP, "[NAPI]Argc count is invalid: %{public}zu", argc); 4281 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 4282 "Input parameter is missing or invalid")); 4283 return NapiGetUndefined(env); 4284 } 4285 bool occluded = false; 4286 if (!ConvertFromJsValue(env, argv[0], occluded)) { 4287 TLOGE(WmsLogTag::WMS_PIP, "[NAPI]Failed to convert parameter, keep default: false"); 4288 } 4289 auto session = weakSession_.promote(); 4290 if (session == nullptr) { 4291 TLOGE(WmsLogTag::WMS_PIP, "[NAPI]session is nullptr, id:%{public}d", persistentId_); 4292 return NapiGetUndefined(env); 4293 } 4294 TLOGI(WmsLogTag::WMS_PIP, "[NAPI]persistId:%{public}d, occluded:%{public}d", persistentId_, occluded); 4295 // Maybe expand with session visibility&state change 4296 SceneSessionManager::GetInstance().HandleKeepScreenOn(session, !occluded); 4297 return NapiGetUndefined(env); 4298 } 4299 OnNotifyDisplayStatusBarTemporarily(napi_env env,napi_callback_info info)4300 napi_value JsSceneSession::OnNotifyDisplayStatusBarTemporarily(napi_env env, napi_callback_info info) 4301 { 4302 auto session = weakSession_.promote(); 4303 if (session == nullptr) { 4304 TLOGE(WmsLogTag::WMS_IMMS, "[NAPI]session is nullptr, id:%{public}d", persistentId_); 4305 return NapiGetUndefined(env); 4306 } 4307 size_t argc = ARGC_FOUR; 4308 napi_value argv[ARGC_FOUR] = {nullptr}; 4309 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr); 4310 bool isTempDisplay = false; 4311 if (argc == ARGC_ONE && GetType(env, argv[0]) == napi_boolean) { 4312 if (!ConvertFromJsValue(env, argv[0], isTempDisplay)) { 4313 TLOGE(WmsLogTag::WMS_IMMS, "[NAPI]failed to convert parameter to bool"); 4314 return NapiGetUndefined(env); 4315 } 4316 } 4317 session->SetIsDisplayStatusBarTemporarily(isTempDisplay); 4318 4319 TLOGI(WmsLogTag::WMS_IMMS, "Set success with id:%{public}u name:%{public}s isTempDisplay:%{public}u", 4320 session->GetPersistentId(), session->GetWindowName().c_str(), isTempDisplay); 4321 return NapiGetUndefined(env); 4322 } 4323 GetNativeSession() const4324 sptr<SceneSession> JsSceneSession::GetNativeSession() const 4325 { 4326 return weakSession_.promote(); 4327 } 4328 OnSetTemporarilyShowWhenLocked(napi_env env,napi_callback_info info)4329 napi_value JsSceneSession::OnSetTemporarilyShowWhenLocked(napi_env env, napi_callback_info info) 4330 { 4331 size_t argc = 4; 4332 napi_value argv[4] = { nullptr }; 4333 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr); 4334 if (argc < 1) { 4335 TLOGE(WmsLogTag::WMS_SCB, "[NAPI]argc is invalid : %{public}zu", argc); 4336 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 4337 "Input parameter is missing or invalid")); 4338 return NapiGetUndefined(env); 4339 } 4340 bool isTemporarilyShowWhenLocked = false; 4341 if (!ConvertFromJsValue(env, argv[0], isTemporarilyShowWhenLocked)) { 4342 TLOGE(WmsLogTag::WMS_SCB, "[NAPI] Failed to convert parameter to bool"); 4343 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 4344 "Input parameter is missing or invalid")); 4345 return NapiGetUndefined(env); 4346 } 4347 auto session = weakSession_.promote(); 4348 if (session == nullptr) { 4349 TLOGE(WmsLogTag::WMS_SCB, "[NAPI] session_ is null"); 4350 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 4351 "Input parameter is missing or invalid")); 4352 return NapiGetUndefined(env); 4353 } 4354 session->SetTemporarilyShowWhenLocked(isTemporarilyShowWhenLocked); 4355 return NapiGetUndefined(env); 4356 } 4357 OnSetSkipDraw(napi_env env,napi_callback_info info)4358 napi_value JsSceneSession::OnSetSkipDraw(napi_env env, napi_callback_info info) 4359 { 4360 size_t argc = 4; 4361 napi_value argv[4] = { nullptr }; 4362 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr); 4363 if (argc < 1) { 4364 TLOGE(WmsLogTag::WMS_SCB, "[NAPI]argc is invalid : %{public}zu", argc); 4365 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 4366 "Input parameter is missing or invalid")); 4367 return NapiGetUndefined(env); 4368 } 4369 bool skip = false; 4370 if (!ConvertFromJsValue(env, argv[0], skip)) { 4371 TLOGE(WmsLogTag::WMS_SCB, "[NAPI] Failed to convert parameter to bool"); 4372 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 4373 "Input parameter is missing or invalid")); 4374 return NapiGetUndefined(env); 4375 } 4376 auto session = weakSession_.promote(); 4377 if (session == nullptr) { 4378 TLOGE(WmsLogTag::WMS_SCB, "[NAPI] session_ is null"); 4379 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 4380 "Input parameter is missing or invalid")); 4381 return NapiGetUndefined(env); 4382 } 4383 session->SetSkipDraw(skip); 4384 return NapiGetUndefined(env); 4385 } 4386 GetJSCallback(const std::string & functionName)4387 std::shared_ptr<NativeReference> JsSceneSession::GetJSCallback(const std::string& functionName) 4388 { 4389 HITRACE_METER_FMT(HITRACE_TAG_WINDOW_MANAGER, "JsSceneSession::GetJSCallback[%s]", functionName.c_str()); 4390 std::shared_ptr<NativeReference> jsCallBack = nullptr; 4391 std::shared_lock<std::shared_mutex> lock(jsCbMapMutex_); 4392 auto iter = jsCbMap_.find(functionName); 4393 if (iter == jsCbMap_.end()) { 4394 TLOGE(WmsLogTag::DEFAULT, "%{public}s callback not found!", functionName.c_str()); 4395 } else { 4396 jsCallBack = iter->second; 4397 } 4398 return jsCallBack; 4399 } 4400 OnSetSkipSelfWhenShowOnVirtualScreen(napi_env env,napi_callback_info info)4401 napi_value JsSceneSession::OnSetSkipSelfWhenShowOnVirtualScreen(napi_env env, napi_callback_info info) 4402 { 4403 size_t argc = 4; 4404 napi_value argv[4] = {nullptr}; 4405 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr); 4406 if (argc < 1) { // 1: params num 4407 WLOGFE("[NAPI]Argc is invalid: %{public}zu", argc); 4408 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 4409 "Input parameter is missing or invalid")); 4410 return NapiGetUndefined(env); 4411 } 4412 bool isSkip = false; 4413 if (!ConvertFromJsValue(env, argv[0], isSkip)) { 4414 WLOGFE("[NAPI]Failed to convert parameter to bool"); 4415 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 4416 "Input parameter is missing or invalid")); 4417 return NapiGetUndefined(env); 4418 } 4419 auto session = weakSession_.promote(); 4420 if (session == nullptr) { 4421 WLOGFE("[NAPI]session is nullptr, id:%{public}d", persistentId_); 4422 return NapiGetUndefined(env); 4423 } 4424 session->SetSkipSelfWhenShowOnVirtualScreen(isSkip); 4425 WLOGFI("[NAPI]OnSetSkipSelfWhenShowOnVirtualScreen end"); 4426 return NapiGetUndefined(env); 4427 } 4428 OnSetCompatibleModeInPc(napi_env env,napi_callback_info info)4429 napi_value JsSceneSession::OnSetCompatibleModeInPc(napi_env env, napi_callback_info info) 4430 { 4431 size_t argc = 4; 4432 napi_value argv[4] = {nullptr}; 4433 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr); 4434 4435 if (argc < ARGC_TWO) { 4436 TLOGE(WmsLogTag::WMS_SCB, "[NAPI]Argc is invalid: %{public}zu", argc); 4437 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 4438 "Input parameter is missing or invalid")); 4439 return NapiGetUndefined(env); 4440 } 4441 4442 bool enable = false; 4443 if (!ConvertFromJsValue(env, argv[0], enable)) { 4444 TLOGE(WmsLogTag::WMS_SCB, "[NAPI]Failed to convert parameter to enable"); 4445 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 4446 "Input parameter is missing or invalid")); 4447 return NapiGetUndefined(env); 4448 } 4449 4450 bool isSupportDragInPcCompatibleMode = false; 4451 if (!ConvertFromJsValue(env, argv[ARGC_ONE], isSupportDragInPcCompatibleMode)) { 4452 TLOGE(WmsLogTag::WMS_SCB, "[NAPI]Failed to convert parameter to isSupportDragInPcCompatibleMode"); 4453 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 4454 "Input parameter is missing or invalid")); 4455 return NapiGetUndefined(env); 4456 } 4457 4458 auto session = weakSession_.promote(); 4459 if (session == nullptr) { 4460 TLOGE(WmsLogTag::WMS_SCB, "[NAPI]session is nullptr, id:%{public}d", persistentId_); 4461 return NapiGetUndefined(env); 4462 } 4463 session->SetCompatibleModeInPc(enable, isSupportDragInPcCompatibleMode); 4464 return NapiGetUndefined(env); 4465 } 4466 OnSetCompatibleWindowSizeInPc(napi_env env,napi_callback_info info)4467 napi_value JsSceneSession::OnSetCompatibleWindowSizeInPc(napi_env env, napi_callback_info info) 4468 { 4469 size_t argc = ARGC_FOUR; 4470 napi_value argv[ARGC_FOUR] = {nullptr}; 4471 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr); 4472 if (argc < ARGC_FOUR) { 4473 TLOGE(WmsLogTag::WMS_SCB, "[NAPI]Argc is invalid: %{public}zu", argc); 4474 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 4475 "Input parameter is missing or invalid")); 4476 return NapiGetUndefined(env); 4477 } 4478 int32_t portraitWidth = 0; 4479 if (!ConvertFromJsValue(env, argv[ARG_INDEX_0], portraitWidth)) { 4480 TLOGE(WmsLogTag::WMS_SCB, "[NAPI]Failed to convert parameter to portraitWidth"); 4481 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 4482 "Input parameter is missing or invalid")); 4483 return NapiGetUndefined(env); 4484 } 4485 int32_t portraitHeight = 0; 4486 if (!ConvertFromJsValue(env, argv[ARG_INDEX_1], portraitHeight)) { 4487 TLOGE(WmsLogTag::WMS_SCB, "[NAPI]Failed to convert parameter to portraitHeight"); 4488 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 4489 "Input parameter is missing or invalid")); 4490 return NapiGetUndefined(env); 4491 } 4492 int32_t landscapeWidth = 0; 4493 if (!ConvertFromJsValue(env, argv[ARG_INDEX_2], landscapeWidth)) { 4494 TLOGE(WmsLogTag::WMS_SCB, "[NAPI]Failed to convert parameter to landscapeWidth"); 4495 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 4496 "Input parameter is missing or invalid")); 4497 return NapiGetUndefined(env); 4498 } 4499 int32_t landscapeHeight = 0; 4500 if (!ConvertFromJsValue(env, argv[ARG_INDEX_3], landscapeHeight)) { 4501 TLOGE(WmsLogTag::WMS_SCB, "[NAPI]Failed to convert parameter to landscapeHeight"); 4502 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 4503 "Input parameter is missing or invalid")); 4504 return NapiGetUndefined(env); 4505 } 4506 auto session = weakSession_.promote(); 4507 if (session == nullptr) { 4508 TLOGE(WmsLogTag::WMS_SCB, "[NAPI]session is nullptr, id:%{public}d", persistentId_); 4509 return NapiGetUndefined(env); 4510 } 4511 session->SetCompatibleWindowSizeInPc(portraitWidth, portraitHeight, landscapeWidth, landscapeHeight); 4512 return NapiGetUndefined(env); 4513 } 4514 OnSetAppSupportPhoneInPc(napi_env env,napi_callback_info info)4515 napi_value JsSceneSession::OnSetAppSupportPhoneInPc(napi_env env, napi_callback_info info) 4516 { 4517 size_t argc = ARGC_FOUR; 4518 napi_value argv[ARGC_FOUR] = { nullptr }; 4519 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr); 4520 if (argc < ARGC_ONE) { 4521 TLOGE(WmsLogTag::WMS_SCB, "[NAPI]Argc is invalid: %{public}zu", argc); 4522 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 4523 "Input parameter is missing or invalid")); 4524 return NapiGetUndefined(env); 4525 } 4526 bool isSupportPhone = false; 4527 if (!ConvertFromJsValue(env, argv[ARG_INDEX_0], isSupportPhone)) { 4528 TLOGE(WmsLogTag::WMS_SCB, "[NAPI]Failed to convert parameter to isSupportPhone"); 4529 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 4530 "Input parameter is missing or invalid")); 4531 return NapiGetUndefined(env); 4532 } 4533 auto session = weakSession_.promote(); 4534 if (session == nullptr) { 4535 TLOGE(WmsLogTag::WMS_SCB, "[NAPI]session is nullptr, id:%{public}d", persistentId_); 4536 return NapiGetUndefined(env); 4537 } 4538 session->SetAppSupportPhoneInPc(isSupportPhone); 4539 return NapiGetUndefined(env); 4540 } 4541 OnSetCompatibleModeEnableInPad(napi_env env,napi_callback_info info)4542 napi_value JsSceneSession::OnSetCompatibleModeEnableInPad(napi_env env, napi_callback_info info) 4543 { 4544 size_t argc = ARGC_FOUR; 4545 napi_value argv[ARGC_FOUR] = { nullptr }; 4546 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr); 4547 if (argc != ARGC_ONE) { 4548 TLOGE(WmsLogTag::WMS_SCB, "[NAPI]Argc is invalid: %{public}zu", argc); 4549 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 4550 "Input parameter is missing or invalid")); 4551 return NapiGetUndefined(env); 4552 } 4553 4554 bool enable = false; 4555 if (!ConvertFromJsValue(env, argv[ARG_INDEX_0], enable)) { 4556 TLOGE(WmsLogTag::WMS_SCB, "[NAPI]Failed to convert parameter to portraitWidth"); 4557 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 4558 "Input parameter is missing or invalid")); 4559 return NapiGetUndefined(env); 4560 } 4561 4562 auto session = weakSession_.promote(); 4563 if (session == nullptr) { 4564 TLOGE(WmsLogTag::WMS_SCB, "[NAPI]session is nullptr, id:%{public}d", persistentId_); 4565 return NapiGetUndefined(env); 4566 } 4567 session->SetCompatibleModeEnableInPad(enable); 4568 return NapiGetUndefined(env); 4569 } 4570 OnSetUniqueDensityDpiFromSCB(napi_env env,napi_callback_info info)4571 napi_value JsSceneSession::OnSetUniqueDensityDpiFromSCB(napi_env env, napi_callback_info info) 4572 { 4573 size_t argc = ARG_COUNT_4; 4574 napi_value argv[ARG_COUNT_4] = {nullptr}; 4575 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr); 4576 bool paramValidFlag = true; 4577 bool useUnique = false; 4578 uint32_t densityDpi = 0; 4579 std::string errMsg = ""; 4580 if (argc < ARGC_TWO) { 4581 TLOGE(WmsLogTag::WMS_SCB, "Params not match %{public}zu", argc); 4582 errMsg = "Invalid args count, need two arg!"; 4583 paramValidFlag = false; 4584 } else { 4585 if (!ConvertFromJsValue(env, argv[0], useUnique)) { 4586 TLOGE(WmsLogTag::WMS_SCB, "Failed to convert parameter to useUnique"); 4587 errMsg = "Failed to convert parameter to useUnique"; 4588 paramValidFlag = false; 4589 } 4590 if (paramValidFlag && !ConvertFromJsValue(env, argv[1], densityDpi)) { 4591 TLOGE(WmsLogTag::WMS_SCB, "Failed to convert parameter to densityDpi"); 4592 errMsg = "Failed to convert parameter to densityDpi"; 4593 paramValidFlag = false; 4594 } 4595 } 4596 if (!paramValidFlag) { 4597 TLOGE(WmsLogTag::WMS_SCB, "paramValidFlag error"); 4598 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), errMsg)); 4599 return NapiGetUndefined(env); 4600 } 4601 4602 auto session = weakSession_.promote(); 4603 if (!session) { 4604 TLOGE(WmsLogTag::WMS_SCB, "[NAPI] session is nullptr, id:%{public}d", persistentId_); 4605 return NapiGetUndefined(env); 4606 } 4607 session->SetUniqueDensityDpi(useUnique, densityDpi); 4608 return NapiGetUndefined(env); 4609 } 4610 OnSetBlankFlag(napi_env env,napi_callback_info info)4611 napi_value JsSceneSession::OnSetBlankFlag(napi_env env, napi_callback_info info) 4612 { 4613 size_t argc = ARGC_FOUR; 4614 napi_value argv[ARGC_FOUR] = {nullptr}; 4615 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr); 4616 4617 if (argc < ARGC_ONE) { 4618 TLOGE(WmsLogTag::WMS_SCB, "[NAPI]Argc is invalid: %{public}zu", argc); 4619 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 4620 "Input parameter is missing or invalid")); 4621 return NapiGetUndefined(env); 4622 } 4623 4624 bool isAddBlank = false; 4625 if (!ConvertFromJsValue(env, argv[0], isAddBlank)) { 4626 TLOGE(WmsLogTag::WMS_SCB, "[NAPI]Failed to convert parameter to isAddBlank"); 4627 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 4628 "Input parameter is missing or invalid")); 4629 return NapiGetUndefined(env); 4630 } 4631 4632 auto session = weakSession_.promote(); 4633 if (session == nullptr) { 4634 TLOGE(WmsLogTag::WMS_SCB, "[NAPI]session is nullptr, id:%{public}d", persistentId_); 4635 return NapiGetUndefined(env); 4636 } 4637 session->SetBlankFlag(isAddBlank); 4638 return NapiGetUndefined(env); 4639 } 4640 OnRemoveBlank(napi_env env,napi_callback_info info)4641 napi_value JsSceneSession::OnRemoveBlank(napi_env env, napi_callback_info info) 4642 { 4643 auto session = weakSession_.promote(); 4644 if (session == nullptr) { 4645 TLOGE(WmsLogTag::WMS_SCB, "[NAPI]session is nullptr, id:%{public}d", persistentId_); 4646 return NapiGetUndefined(env); 4647 } 4648 session->NotifyRemoveBlank(); 4649 return NapiGetUndefined(env); 4650 } 4651 OnSetBufferAvailableCallbackEnable(napi_env env,napi_callback_info info)4652 napi_value JsSceneSession::OnSetBufferAvailableCallbackEnable(napi_env env, napi_callback_info info) 4653 { 4654 size_t argc = ARGC_FOUR; 4655 napi_value argv[ARGC_FOUR] = {nullptr}; 4656 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr); 4657 4658 if (argc < ARGC_ONE) { 4659 TLOGE(WmsLogTag::WMS_SCB, "[NAPI]Argc is invalid: %{public}zu", argc); 4660 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 4661 "Input parameter is missing or invalid")); 4662 return NapiGetUndefined(env); 4663 } 4664 4665 bool enable = false; 4666 if (!ConvertFromJsValue(env, argv[0], enable)) { 4667 TLOGE(WmsLogTag::WMS_SCB, "[NAPI]Failed to convert parameter to enable"); 4668 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 4669 "Input parameter is missing or invalid")); 4670 return NapiGetUndefined(env); 4671 } 4672 4673 auto session = weakSession_.promote(); 4674 if (session == nullptr) { 4675 TLOGE(WmsLogTag::WMS_SCB, "[NAPI]session is nullptr, id:%{public}d", persistentId_); 4676 return NapiGetUndefined(env); 4677 } 4678 session->SetBufferAvailableCallbackEnable(enable); 4679 return NapiGetUndefined(env); 4680 } 4681 OnIsDeviceWakeupByApplication(napi_env env,napi_callback_info info)4682 napi_value JsSceneSession::OnIsDeviceWakeupByApplication(napi_env env, napi_callback_info info) 4683 { 4684 auto session = weakSession_.promote(); 4685 if (session == nullptr) { 4686 TLOGE(WmsLogTag::WMS_SCB, "[NAPI]session is null, id:%{public}d", persistentId_); 4687 return NapiGetUndefined(env); 4688 } 4689 auto result = session->IsDeviceWakeupByApplication(); 4690 napi_value jsResult; 4691 napi_get_boolean(env, result, &jsResult); 4692 return jsResult; 4693 } 4694 OnSyncDefaultRequestedOrientation(napi_env env,napi_callback_info info)4695 napi_value JsSceneSession::OnSyncDefaultRequestedOrientation(napi_env env, napi_callback_info info) 4696 { 4697 size_t argc = ARGC_FOUR; 4698 napi_value argv[ARGC_FOUR] = { nullptr }; 4699 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr); 4700 if (argc != ARGC_ONE) { 4701 TLOGE(WmsLogTag::WMS_SCB, "[NAPI]Argc is invalid: %{public}zu", argc); 4702 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 4703 "Input parameter is missing or invalid")); 4704 return NapiGetUndefined(env); 4705 } 4706 uint32_t defaultRequestedOrientation = 0; 4707 if (!ConvertFromJsValue(env, argv[0], defaultRequestedOrientation)) { 4708 TLOGE(WmsLogTag::WMS_SCB, "[NAPI]Failed to convert parameter to defaultRequestedOrientation"); 4709 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 4710 "Input parameter is missing or invalid")); 4711 return NapiGetUndefined(env); 4712 } 4713 auto session = weakSession_.promote(); 4714 if (session == nullptr) { 4715 TLOGE(WmsLogTag::WMS_SCB, "[NAPI]session is nullptr, id:%{public}d", persistentId_); 4716 return NapiGetUndefined(env); 4717 } 4718 auto windowOrientation = static_cast<Orientation>(defaultRequestedOrientation); 4719 if (windowOrientation < Orientation::BEGIN || windowOrientation > Orientation::END) { 4720 TLOGE(WmsLogTag::WMS_SCB, "[NAPI]Orientation %{public}u invalid, id:%{public}d", 4721 defaultRequestedOrientation, persistentId_); 4722 return NapiGetUndefined(env); 4723 } 4724 session->SetDefaultRequestedOrientation(windowOrientation); 4725 return NapiGetUndefined(env); 4726 } 4727 OnSetIsPcAppInPad(napi_env env,napi_callback_info info)4728 napi_value JsSceneSession::OnSetIsPcAppInPad(napi_env env, napi_callback_info info) 4729 { 4730 size_t argc = ARGC_FOUR; 4731 napi_value argv[ARGC_FOUR] = {nullptr}; 4732 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr); 4733 if (argc < ARGC_ONE) { 4734 TLOGE(WmsLogTag::WMS_SCB, "[NAPI]Argc is invalid: %{public}zu", argc); 4735 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 4736 "Input parameter is missing or invalid")); 4737 return NapiGetUndefined(env); 4738 } 4739 bool enable = false; 4740 if (!ConvertFromJsValue(env, argv[0], enable)) { 4741 TLOGE(WmsLogTag::WMS_SCB, "[NAPI]Failed to convert parameter to enable"); 4742 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 4743 "Input parameter is missing or invalid")); 4744 return NapiGetUndefined(env); 4745 } 4746 auto session = weakSession_.promote(); 4747 if (session == nullptr) { 4748 TLOGE(WmsLogTag::WMS_SCB, "[NAPI]session is nullptr"); 4749 return NapiGetUndefined(env); 4750 } 4751 session->SetIsPcAppInPad(enable); 4752 return NapiGetUndefined(env); 4753 } 4754 OnSetStartingWindowExitAnimationFlag(napi_env env,napi_callback_info info)4755 napi_value JsSceneSession::OnSetStartingWindowExitAnimationFlag(napi_env env, napi_callback_info info) 4756 { 4757 size_t argc = ARGC_FOUR; 4758 napi_value argv[ARGC_FOUR] = {nullptr}; 4759 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr); 4760 4761 if (argc != ARGC_ONE) { 4762 TLOGE(WmsLogTag::WMS_SCB, "[NAPI]Argc is invalid: %{public}zu", argc); 4763 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 4764 "Input parameter is missing or invalid")); 4765 return NapiGetUndefined(env); 4766 } 4767 4768 bool enable = true; 4769 if (!ConvertFromJsValue(env, argv[0], enable)) { 4770 TLOGE(WmsLogTag::WMS_SCB, "[NAPI]Failed to convert parameter to enable"); 4771 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 4772 "Input parameter is missing or invalid")); 4773 return NapiGetUndefined(env); 4774 } 4775 4776 auto session = weakSession_.promote(); 4777 if (session == nullptr) { 4778 TLOGE(WmsLogTag::WMS_SCB, "[NAPI]session is null, id:%{public}d", persistentId_); 4779 return NapiGetUndefined(env); 4780 } 4781 session->SetStartingWindowExitAnimationFlag(enable); 4782 return NapiGetUndefined(env); 4783 } 4784 OnSyncScenePanelGlobalPosition(napi_env env,napi_callback_info info)4785 napi_value JsSceneSession::OnSyncScenePanelGlobalPosition(napi_env env, napi_callback_info info) 4786 { 4787 size_t argc = ARGC_FOUR; 4788 napi_value argv[ARGC_FOUR] = { nullptr }; 4789 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr); 4790 4791 if (argc != ARGC_ONE) { 4792 TLOGE(WmsLogTag::WMS_SCB, "[NAPI]Argc is invalid: %{public}zu", argc); 4793 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 4794 "Input parameter is missing or invalid")); 4795 return NapiGetUndefined(env); 4796 } 4797 4798 std::string reason; 4799 if (!ConvertFromJsValue(env, argv[0], reason)) { 4800 TLOGE(WmsLogTag::WMS_PIPELINE, "[NAPI]Failed to convert parameter to sync reason"); 4801 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 4802 "Input parameter is missing or invalid")); 4803 return NapiGetUndefined(env); 4804 } 4805 auto it = std::find_if(g_syncGlobalPositionPermission.begin(), g_syncGlobalPositionPermission.end(), 4806 [reason](const std::string& permission) { return permission.find(reason) != std::string::npos; }); 4807 if (it == g_syncGlobalPositionPermission.end()) { 4808 TLOGE(WmsLogTag::WMS_PIPELINE, "[NAPI]called reason:%{public}s is not permitted", reason.c_str()); 4809 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_NO_PERMISSION), 4810 "Input parameter is missing or invalid")); 4811 return NapiGetUndefined(env); 4812 } 4813 TLOGI(WmsLogTag::WMS_PIPELINE, "[NAPI]called reason:%{public}s", reason.c_str()); 4814 auto session = weakSession_.promote(); 4815 if (session == nullptr) { 4816 TLOGE(WmsLogTag::WMS_SCB, "[NAPI]session is nullptr, id:%{public}d", persistentId_); 4817 return NapiGetUndefined(env); 4818 } 4819 session->SyncScenePanelGlobalPosition(true); 4820 return NapiGetUndefined(env); 4821 } 4822 OnUnSyncScenePanelGlobalPosition(napi_env env,napi_callback_info info)4823 napi_value JsSceneSession::OnUnSyncScenePanelGlobalPosition(napi_env env, napi_callback_info info) 4824 { 4825 size_t argc = ARGC_FOUR; 4826 napi_value argv[ARGC_FOUR] = { nullptr }; 4827 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr); 4828 4829 if (argc != ARGC_ONE) { 4830 TLOGE(WmsLogTag::WMS_SCB, "[NAPI]Argc is invalid: %{public}zu", argc); 4831 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 4832 "Input parameter is missing or invalid")); 4833 return NapiGetUndefined(env); 4834 } 4835 4836 std::string reason; 4837 if (!ConvertFromJsValue(env, argv[0], reason)) { 4838 TLOGE(WmsLogTag::WMS_PIPELINE, "[NAPI]Failed to convert parameter to un sync reason"); 4839 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 4840 "Input parameter is missing or invalid")); 4841 return NapiGetUndefined(env); 4842 } 4843 auto it = std::find_if(g_syncGlobalPositionPermission.begin(), g_syncGlobalPositionPermission.end(), 4844 [reason](const std::string& permission) { return permission.find(reason) != std::string::npos; }); 4845 if (it == g_syncGlobalPositionPermission.end()) { 4846 TLOGE(WmsLogTag::WMS_PIPELINE, "[NAPI]called reason:%{public}s is not permitted", reason.c_str()); 4847 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_NO_PERMISSION), 4848 "Input parameter is missing or invalid")); 4849 return NapiGetUndefined(env); 4850 } 4851 TLOGI(WmsLogTag::WMS_PIPELINE, "[NAPI]called reason:%{public}s", reason.c_str()); 4852 auto session = weakSession_.promote(); 4853 if (session == nullptr) { 4854 TLOGE(WmsLogTag::WMS_SCB, "[NAPI]session is nullptr, id:%{public}d", persistentId_); 4855 return NapiGetUndefined(env); 4856 } 4857 session->SyncScenePanelGlobalPosition(false); 4858 return NapiGetUndefined(env); 4859 } 4860 OnSetIsActivatedAfterScreenLocked(napi_env env,napi_callback_info info)4861 napi_value JsSceneSession::OnSetIsActivatedAfterScreenLocked(napi_env env, napi_callback_info info) 4862 { 4863 size_t argc = ARGC_FOUR; 4864 napi_value argv[ARGC_FOUR] = {nullptr}; 4865 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr); 4866 if (argc != ARGC_ONE) { 4867 TLOGE(WmsLogTag::WMS_LIFE, "[NAPI]Argc is invalid: %{public}zu", argc); 4868 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), "InputInvalid")); 4869 return NapiGetUndefined(env); 4870 } 4871 bool isActivatedAfterScreenLocked = false; 4872 if (!ConvertFromJsValue(env, argv[0], isActivatedAfterScreenLocked)) { 4873 TLOGE(WmsLogTag::WMS_LIFE, "[NAPI]Failed to convert parameter to isActivatedAfterScreenLocked"); 4874 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 4875 "Input parameter is missing or invalid")); 4876 return NapiGetUndefined(env); 4877 } 4878 TLOGD(WmsLogTag::WMS_LIFE, "[NAPI]isActivatedAfterScreenLocked: %{public}u", isActivatedAfterScreenLocked); 4879 auto session = weakSession_.promote(); 4880 if (session == nullptr) { 4881 TLOGE(WmsLogTag::WMS_LIFE, "[NAPI]session is null, id: %{public}d", persistentId_); 4882 return NapiGetUndefined(env); 4883 } 4884 session->SetIsActivatedAfterScreenLocked(isActivatedAfterScreenLocked); 4885 return NapiGetUndefined(env); 4886 } 4887 OnSetNeedSyncSessionRect(napi_env env,napi_callback_info info)4888 napi_value JsSceneSession::OnSetNeedSyncSessionRect(napi_env env, napi_callback_info info) 4889 { 4890 size_t argc = ARGC_FOUR; 4891 napi_value argv[ARGC_FOUR] = { nullptr }; 4892 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr); 4893 4894 if (argc != ARGC_ONE) { 4895 TLOGE(WmsLogTag::WMS_PIPELINE, "[NAPI]Argc is invalid: %{public}zu", argc); 4896 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 4897 "Input parameter is missing or invalid")); 4898 return NapiGetUndefined(env); 4899 } 4900 4901 bool needSync = true; 4902 if (!ConvertFromJsValue(env, argv[0], needSync)) { 4903 TLOGE(WmsLogTag::WMS_PIPELINE, "[NAPI]Failed to convert parameter to needSync"); 4904 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 4905 "Input parameter is missing or invalid")); 4906 return NapiGetUndefined(env); 4907 } 4908 TLOGI(WmsLogTag::WMS_PIPELINE, "[NAPI]needSync:%{public}u, id:%{public}d", needSync, persistentId_); 4909 auto session = weakSession_.promote(); 4910 if (session == nullptr) { 4911 TLOGE(WmsLogTag::WMS_PIPELINE, "[NAPI]session is nullptr, id:%{public}d", persistentId_); 4912 return NapiGetUndefined(env); 4913 } 4914 session->SetNeedSyncSessionRect(needSync); 4915 return NapiGetUndefined(env); 4916 } 4917 OnSetUseStartingWindowAboveLocked(napi_env env,napi_callback_info info)4918 napi_value JsSceneSession::OnSetUseStartingWindowAboveLocked(napi_env env, napi_callback_info info) 4919 { 4920 size_t argc = ARGC_FOUR; 4921 napi_value argv[ARGC_FOUR] = { nullptr }; 4922 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr); 4923 if (argc != ARGC_ONE) { 4924 TLOGE(WmsLogTag::DEFAULT, "[NAPI]Argc is invalid: %{public}zu", argc); 4925 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 4926 "Input parameter is missing or invalid")); 4927 return NapiGetUndefined(env); 4928 } 4929 4930 bool useStartingWindowAboveLocked = false; 4931 if (!ConvertFromJsValue(env, argv[0], useStartingWindowAboveLocked)) { 4932 TLOGE(WmsLogTag::DEFAULT, "[NAPI]Failed to convert parameter to useStartingWindowAboveLocked"); 4933 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 4934 "Input parameter is missing or invalid")); 4935 return NapiGetUndefined(env); 4936 } 4937 auto session = weakSession_.promote(); 4938 if (session == nullptr) { 4939 TLOGE(WmsLogTag::DEFAULT, "[NAPI]session is nullptr, id:%{public}d", persistentId_); 4940 return NapiGetUndefined(env); 4941 } 4942 session->SetUseStartingWindowAboveLocked(useStartingWindowAboveLocked); 4943 return NapiGetUndefined(env); 4944 } 4945 OnSetWindowEnableDragBySystem(napi_env env,napi_callback_info info)4946 napi_value JsSceneSession::OnSetWindowEnableDragBySystem(napi_env env, napi_callback_info info) 4947 { 4948 size_t argc = ARGC_FOUR; 4949 napi_value argv[ARGC_FOUR] = { nullptr }; 4950 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr); 4951 if (argc != ARGC_ONE) { 4952 TLOGE(WmsLogTag::WMS_LAYOUT, "[NAPI]Argc is invalid: %{public}zu", argc); 4953 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 4954 "Input parameter is missing or invalid")); 4955 return NapiGetUndefined(env); 4956 } 4957 4958 bool enableDrag = true; 4959 if (!ConvertFromJsValue(env, argv[0], enableDrag)) { 4960 TLOGE(WmsLogTag::WMS_LAYOUT, "[NAPI]Failed to convert parameter to bool"); 4961 return NapiGetUndefined(env); 4962 } 4963 4964 auto session = weakSession_.promote(); 4965 if (session == nullptr) { 4966 TLOGE(WmsLogTag::WMS_LAYOUT, "[NAPI]session is nullptr, id:%{public}d", persistentId_); 4967 return NapiGetUndefined(env); 4968 } 4969 session->SetWindowEnableDragBySystem(enableDrag); 4970 return NapiGetUndefined(env); 4971 } 4972 ProcessSetWindowRectAutoSaveRegister()4973 void JsSceneSession::ProcessSetWindowRectAutoSaveRegister() 4974 { 4975 auto session = weakSession_.promote(); 4976 if (session == nullptr) { 4977 TLOGE(WmsLogTag::WMS_MAIN, "session is nullptr, id:%{public}d", persistentId_); 4978 return; 4979 } 4980 const char* const where = __func__; 4981 session->SetWindowRectAutoSaveCallback([weakThis = wptr(this), where](bool enabled) { 4982 auto jsSceneSession = weakThis.promote(); 4983 if (!jsSceneSession) { 4984 TLOGNE(WmsLogTag::WMS_MAIN, "%{pubilc}s: jsSceneSession is null", where); 4985 return; 4986 } 4987 jsSceneSession->OnSetWindowRectAutoSave(enabled); 4988 }); 4989 TLOGI(WmsLogTag::WMS_MAIN, "success"); 4990 } 4991 OnSetWindowRectAutoSave(bool enabled)4992 void JsSceneSession::OnSetWindowRectAutoSave(bool enabled) 4993 { 4994 const char* const where = __func__; 4995 auto task = [weakThis = wptr(this), persistentId = persistentId_, enabled, env = env_, where] { 4996 auto jsSceneSession = weakThis.promote(); 4997 if (!jsSceneSession || jsSceneSessionMap_.find(persistentId) == jsSceneSessionMap_.end()) { 4998 TLOGNE(WmsLogTag::WMS_MAIN, "%{public}s: jsSceneSession id:%{public}d has been destroyed", 4999 where, persistentId); 5000 return; 5001 } 5002 auto jsCallBack = jsSceneSession->GetJSCallback(SET_WINDOW_RECT_AUTO_SAVE_CB); 5003 if (!jsCallBack) { 5004 TLOGNE(WmsLogTag::WMS_MAIN, "%{public}s: jsCallBack is nullptr", where); 5005 return; 5006 } 5007 napi_value jsEnabled = CreateJsValue(env, enabled); 5008 napi_value argv[] = {jsEnabled}; 5009 napi_call_function(env, NapiGetUndefined(env), jsCallBack->GetNapiValue(), ArraySize(argv), argv, nullptr); 5010 }; 5011 taskScheduler_->PostMainThreadTask(task, __func__); 5012 } 5013 RegisterUpdateAppUseControlCallback()5014 void JsSceneSession::RegisterUpdateAppUseControlCallback() 5015 { 5016 auto session = weakSession_.promote(); 5017 if (session == nullptr) { 5018 TLOGE(WmsLogTag::WMS_LIFE, "session is nullptr, id:%{public}d", persistentId_); 5019 return; 5020 } 5021 const char* const where = __func__; 5022 session->RegisterUpdateAppUseControlCallback( 5023 [weakThis = wptr(this), where](ControlAppType type, bool isNeedControl) { 5024 auto jsSceneSession = weakThis.promote(); 5025 if (!jsSceneSession) { 5026 TLOGNE(WmsLogTag::WMS_LIFE, "%{pubilc}s: jsSceneSession is null", where); 5027 return; 5028 } 5029 jsSceneSession->OnUpdateAppUseControl(type, isNeedControl); 5030 }); 5031 TLOGI(WmsLogTag::WMS_LIFE, "success"); 5032 } 5033 OnUpdateAppUseControl(ControlAppType type,bool isNeedControl)5034 void JsSceneSession::OnUpdateAppUseControl(ControlAppType type, bool isNeedControl) 5035 { 5036 const char* const where = __func__; 5037 auto task = [weakThis = wptr(this), persistentId = persistentId_, type, isNeedControl, env = env_, where] { 5038 auto jsSceneSession = weakThis.promote(); 5039 if (!jsSceneSession || jsSceneSessionMap_.find(persistentId) == jsSceneSessionMap_.end()) { 5040 TLOGNE(WmsLogTag::WMS_LIFE, "%{public}s: jsSceneSession id:%{public}d has been destroyed", 5041 where, persistentId); 5042 return; 5043 } 5044 auto jsCallBack = jsSceneSession->GetJSCallback(UPDATE_APP_USE_CONTROL_CB); 5045 if (!jsCallBack) { 5046 TLOGNE(WmsLogTag::WMS_LIFE, "%{public}s: jsCallBack is nullptr", where); 5047 return; 5048 } 5049 napi_value jsTypeArgv = CreateJsValue(env, static_cast<uint8_t>(type)); 5050 napi_value jsIsNeedControlArgv = CreateJsValue(env, isNeedControl); 5051 napi_value argv[] = { jsTypeArgv, jsIsNeedControlArgv }; 5052 napi_call_function(env, NapiGetUndefined(env), jsCallBack->GetNapiValue(), ArraySize(argv), argv, nullptr); 5053 }; 5054 taskScheduler_->PostMainThreadTask(task, __func__); 5055 } 5056 OnSetFreezeImmediately(napi_env env,napi_callback_info info)5057 napi_value JsSceneSession::OnSetFreezeImmediately(napi_env env, napi_callback_info info) 5058 { 5059 size_t argc = ARGC_FOUR; 5060 napi_value argv[ARGC_FOUR] = { nullptr }; 5061 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr); 5062 if (argc != ARGC_TWO) { 5063 TLOGE(WmsLogTag::WMS_PATTERN, "Argc is invalid: %{public}zu", argc); 5064 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 5065 "Input parameter is missing or invalid")); 5066 return NapiGetUndefined(env); 5067 } 5068 double scaleValue; 5069 if (!ConvertFromJsValue(env, argv[0], scaleValue)) { 5070 TLOGE(WmsLogTag::WMS_PATTERN, "Failed to convert parameter to scaleValue"); 5071 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 5072 "Input parameter is missing or invalid")); 5073 return NapiGetUndefined(env); 5074 } 5075 float scaleParam = GreatOrEqual(scaleValue, 0.0f) && LessOrEqual(scaleValue, 1.0f) ? 5076 static_cast<float>(scaleValue) : 0.0f; 5077 bool isFreeze = false; 5078 if (!ConvertFromJsValue(env, argv[1], isFreeze)) { 5079 TLOGE(WmsLogTag::WMS_PATTERN, "Failed to convert parameter to isFreeze"); 5080 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM), 5081 "Input parameter is missing or invalid")); 5082 return NapiGetUndefined(env); 5083 } 5084 auto session = weakSession_.promote(); 5085 if (session == nullptr) { 5086 TLOGE(WmsLogTag::WMS_PATTERN, "session is nullptr, id:%{public}d", persistentId_); 5087 return NapiGetUndefined(env); 5088 } 5089 std::shared_ptr<Media::PixelMap> pixelPtr = session->SetFreezeImmediately(scaleParam, isFreeze); 5090 if (isFreeze) { 5091 if (pixelPtr == nullptr) { 5092 TLOGE(WmsLogTag::WMS_PATTERN, "Failed to create pixelPtr"); 5093 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_STATE_ABNORMALLY), 5094 "System is abnormal")); 5095 return NapiGetUndefined(env); 5096 } 5097 napi_value pixelMapObj = Media::PixelMapNapi::CreatePixelMap(env, pixelPtr); 5098 if (pixelMapObj == nullptr) { 5099 TLOGE(WmsLogTag::WMS_PATTERN, "Failed to create pixel map object"); 5100 napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_STATE_ABNORMALLY), 5101 "System is abnormal")); 5102 return NapiGetUndefined(env); 5103 } 5104 return pixelMapObj; 5105 } 5106 return NapiGetUndefined(env); 5107 } 5108 } // namespace OHOS::Rosen 5109