Star33
761
代码
代码
Issues239
Pull Requests182
项目讨论
Wiki
分析
Star33
761
已合并
add aod set power #17656
zhaoliang创建于 1月20日
add aod set power #17656
已合并
zhaoliang创建于 1月20日
从logn/window_window_managermaster-aod合入到openharmony/window_window_managermaster
共 19 个文件变更+265-0
Mdmserver/include/display_manager_interface_code.h+1-0
@@ -199,6 +199,7 @@ enum class DisplayManagerMessage : unsigned int {
199 TRANS_ID_SYNC_SCREEN_POWER_STATE,199 TRANS_ID_SYNC_SCREEN_POWER_STATE,
200 TRANS_ID_REGISTER_DISPLAY_ATTRIBUTE_AGENT,200 TRANS_ID_REGISTER_DISPLAY_ATTRIBUTE_AGENT,
201 TRANS_ID_UNREGISTER_DISPLAY_ATTRIBUTE,201 TRANS_ID_UNREGISTER_DISPLAY_ATTRIBUTE,
202+ TRANS_ID_SET_POWER_STATE_AOD,
202};203};
203}204}
204#endif // FOUNDATION_DMSERVER_DISPLAY_MANAGER_INTERFACE_CODE_H205#endif // FOUNDATION_DMSERVER_DISPLAY_MANAGER_INTERFACE_CODE_H
Minterfaces/innerkits/dm/dm_common.h+12-0
@@ -119,6 +119,9 @@ enum class PowerStateChangeReason : uint32_t {
119 STATE_CHANGE_REASON_END_DREAM = 50,119 STATE_CHANGE_REASON_END_DREAM = 50,
120 STATE_CHANGE_REASON_SYNCHRONIZE_POWER_STATE = 51,120 STATE_CHANGE_REASON_SYNCHRONIZE_POWER_STATE = 51,
121 STATE_CHANGE_REASON_APPCAST = 52,121 STATE_CHANGE_REASON_APPCAST = 52,
122+ STATE_CHANGE_REASON_AOD_SET_DOZE = 53,
123+ STATE_CHANGE_REASON_AOD_SET_DOZE_SUSPEND = 54,
124+ STATE_CHANGE_REASON_AOD_SET_OFF = 55,
122 STATE_CHANGE_REASON_REMOTE = 100,125 STATE_CHANGE_REASON_REMOTE = 100,
123 STATE_CHANGE_REASON_UNKNOWN = 1000,126 STATE_CHANGE_REASON_UNKNOWN = 1000,
124};127};
@@ -137,6 +140,15 @@ enum class ScreenPowerState : uint32_t {
137 POWER_DOZE_SUSPEND,140 POWER_DOZE_SUSPEND,
138};141};
139 142 
143+/**
144+ * @brief Enumerates the state of the screen power by SceneBoard.
145+ */
146+enum class ScbScreenPowerState : uint32_t {
147+ POWER_OFF,
148+ POWER_DOZE,
149+ POWER_DOZE_SUSPEND,
150+};
151+ 
140enum class ScreenPropertyChangeType : uint32_t {152enum class ScreenPropertyChangeType : uint32_t {
141 UNSPECIFIED = 0,153 UNSPECIFIED = 0,
142 /* Screen connection. */154 /* Screen connection. */
Mwindow_scene/interfaces/kits/napi/screen_session_manager/js_screen_session_manager.cpp+51-0
@@ -42,6 +42,11 @@ constexpr int32_t INVALID_ID = -1;
42namespace {42namespace {
43const std::string ON_SCREEN_CONNECTION_CHANGE_CALLBACK = "screenConnectChange";43const std::string ON_SCREEN_CONNECTION_CHANGE_CALLBACK = "screenConnectChange";
44const std::string ON_TENT_MODE_CHANGE_CALLBACK = "tentModeChange";44const std::string ON_TENT_MODE_CHANGE_CALLBACK = "tentModeChange";
45+const std::map<ScbScreenPowerState, ScreenPowerState> POWER_STATE_MAP {
46+ { ScbScreenPowerState::POWER_OFF, ScreenPowerState::POWER_OFF },
47+ { ScbScreenPowerState::POWER_DOZE, ScreenPowerState::POWER_DOZE },
48+ { ScbScreenPowerState::POWER_DOZE_SUSPEND, ScreenPowerState::POWER_DOZE_SUSPEND },
49+};
45} // namespace50} // namespace
46 51 
47JsScreenSessionManager::JsScreenSessionManager(napi_env env) : env_(env)52JsScreenSessionManager::JsScreenSessionManager(napi_env env) : env_(env)
@@ -72,6 +77,8 @@ napi_value JsScreenSessionManager::Init(napi_env env, napi_value exportObj)
72 JsScreenUtils::CreateJsFoldStatus(env));77 JsScreenUtils::CreateJsFoldStatus(env));
73 napi_set_named_property(env, exportObj, "ScreenPropertyChangeType",78 napi_set_named_property(env, exportObj, "ScreenPropertyChangeType",
74 JsScreenUtils::CreateJsScreenPropertyChangeType(env));79 JsScreenUtils::CreateJsScreenPropertyChangeType(env));
80+ napi_set_named_property(env, exportObj, "ScreenPowerState",
81+ JsScreenUtils::CreateJsScreenPowerState(env));
75 napi_set_named_property(env, exportObj, "SuperFoldStatus",82 napi_set_named_property(env, exportObj, "SuperFoldStatus",
76 JsScreenUtils::CreateJsSuperFoldStatus(env));83 JsScreenUtils::CreateJsSuperFoldStatus(env));
77 napi_set_named_property(env, exportObj, "FoldDisplayMode",84 napi_set_named_property(env, exportObj, "FoldDisplayMode",
@@ -113,6 +120,8 @@ napi_value JsScreenSessionManager::Init(napi_env env, napi_value exportObj)
113 JsScreenSessionManager::NotifyScreenConnectCompletion);120 JsScreenSessionManager::NotifyScreenConnectCompletion);
114 BindNativeFunction(env, exportObj, "notifyAodOpCompletion", moduleName,121 BindNativeFunction(env, exportObj, "notifyAodOpCompletion", moduleName,
115 JsScreenSessionManager::NotifyAodOpCompletion);122 JsScreenSessionManager::NotifyAodOpCompletion);
123+ BindNativeFunction(env, exportObj, "setPowerStateForAod", moduleName,
124+ JsScreenSessionManager::SetPowerStateForAod);
116 BindNativeFunction(env, exportObj, "recordEventFromScb", moduleName,125 BindNativeFunction(env, exportObj, "recordEventFromScb", moduleName,
117 JsScreenSessionManager::RecordEventFromScb);126 JsScreenSessionManager::RecordEventFromScb);
118 BindNativeFunction(env, exportObj, "getFoldStatus", moduleName, JsScreenSessionManager::GetFoldStatus);127 BindNativeFunction(env, exportObj, "getFoldStatus", moduleName, JsScreenSessionManager::GetFoldStatus);
@@ -292,6 +301,13 @@ napi_value JsScreenSessionManager::NotifyAodOpCompletion(napi_env env, napi_call
292 return (me != nullptr) ? me->OnNotifyAodOpCompletion(env, info) : nullptr;301 return (me != nullptr) ? me->OnNotifyAodOpCompletion(env, info) : nullptr;
293}302}
294 303 
304+napi_value JsScreenSessionManager::SetPowerStateForAod(napi_env env, napi_callback_info info)
305+{
306+ TLOGD(WmsLogTag::DMS, "[NAPI]SetPowerStateForAod");
307+ JsScreenSessionManager* me = CheckParamsAndGetThis<JsScreenSessionManager>(env, info);
308+ return (me != nullptr) ? me->OnSetPowerStateForAod(env, info) : nullptr;
309+}
310+ 
295napi_value JsScreenSessionManager::RecordEventFromScb(napi_env env, napi_callback_info info)311napi_value JsScreenSessionManager::RecordEventFromScb(napi_env env, napi_callback_info info)
296{312{
297 TLOGD(WmsLogTag::DMS, "[NAPI]RecordEventFromScb");313 TLOGD(WmsLogTag::DMS, "[NAPI]RecordEventFromScb");
@@ -1141,6 +1157,41 @@ napi_value JsScreenSessionManager::OnNotifyAodOpCompletion(napi_env env, const n
1141 return NapiGetUndefined(env);1157 return NapiGetUndefined(env);
1142}1158}
1143 1159 
1160+napi_value JsScreenSessionManager::OnSetPowerStateForAod(napi_env env, const napi_callback_info info)
1161+{
1162+ TLOGD(WmsLogTag::DMS, "[NAPI]Enter");
1163+ size_t argc = ARGC_ONE;
1164+ napi_value argv[ARGC_ONE] = {nullptr};
1165+ napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
1166+ if (argc < ARGC_ONE) {
1167+ TLOGE(WmsLogTag::DMS, "[NAPI]Argc is invalid: %{public}zu", argc);
1168+ napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM),
1169+ "Input parameter is missing or invalid"));
1170+ return NapiGetUndefined(env);
1171+ }
1172+ ScbScreenPowerState state;
1173+ ScreenPowerState screenState;
1174+ if (!ConvertFromJsValue(env, argv[0], state) || !CheckAndTransState(state, screenState)) {
1175+ TLOGE(WmsLogTag::DMS, "[NAPI]Failed to convert parameter to aod operation");
1176+ napi_throw(env, CreateJsError(env, static_cast<int32_t>(WSErrorCode::WS_ERROR_INVALID_PARAM),
1177+ "Input parameter is missing or invalid"));
1178+ return NapiGetUndefined(env);
1179+ }
1180+ ScreenSessionManagerClient::GetInstance().SetPowerStateForAod(screenState);
1181+ return NapiGetUndefined(env);
1182+}
1183+ 
1184+bool JsScreenSessionManager::CheckAndTransState(ScbScreenPowerState state, ScreenPowerState& screenState)
1185+{
1186+ auto it = POWER_STATE_MAP.find(state);
1187+ if (it != POWER_STATE_MAP.end()) {
1188+ screenState = it->second;
1189+ return true;
1190+ }
1191+ TLOGE(WmsLogTag::DMS, "can not trans state: %{public}u", state);
1192+ return false;
1193+}
1194+ 
1144napi_value JsScreenSessionManager::OnRecordEventFromScb(napi_env env, const napi_callback_info info)1195napi_value JsScreenSessionManager::OnRecordEventFromScb(napi_env env, const napi_callback_info info)
1145{1196{
1146 TLOGD(WmsLogTag::DMS, "[NAPI]OnRecordEventFromScb");1197 TLOGD(WmsLogTag::DMS, "[NAPI]OnRecordEventFromScb");
Mwindow_scene/interfaces/kits/napi/screen_session_manager/js_screen_session_manager.h+3-0
@@ -60,6 +60,7 @@ private:
60 static napi_value NotifyFoldToExpandCompletion(napi_env env, napi_callback_info info);60 static napi_value NotifyFoldToExpandCompletion(napi_env env, napi_callback_info info);
61 static napi_value NotifyScreenConnectCompletion(napi_env env, napi_callback_info info);61 static napi_value NotifyScreenConnectCompletion(napi_env env, napi_callback_info info);
62 static napi_value NotifyAodOpCompletion(napi_env env, napi_callback_info info);62 static napi_value NotifyAodOpCompletion(napi_env env, napi_callback_info info);
63+ static napi_value SetPowerStateForAod(napi_env env, napi_callback_info info);
63 static napi_value RecordEventFromScb(napi_env env, napi_callback_info info);64 static napi_value RecordEventFromScb(napi_env env, napi_callback_info info);
64 static napi_value SetCameraStatus(napi_env env, napi_callback_info info);65 static napi_value SetCameraStatus(napi_env env, napi_callback_info info);
65 static napi_value GetFoldStatus(napi_env env, napi_callback_info info);66 static napi_value GetFoldStatus(napi_env env, napi_callback_info info);
@@ -102,6 +103,7 @@ private:
102 napi_value OnNotifyFoldToExpandCompletion(napi_env env, const napi_callback_info info);103 napi_value OnNotifyFoldToExpandCompletion(napi_env env, const napi_callback_info info);
103 napi_value OnNotifyScreenConnectCompletion(napi_env env, const napi_callback_info info);104 napi_value OnNotifyScreenConnectCompletion(napi_env env, const napi_callback_info info);
104 napi_value OnNotifyAodOpCompletion(napi_env env, const napi_callback_info info);105 napi_value OnNotifyAodOpCompletion(napi_env env, const napi_callback_info info);
106+ napi_value OnSetPowerStateForAod(napi_env env, const napi_callback_info info);
105 napi_value OnRecordEventFromScb(napi_env env, const napi_callback_info info);107 napi_value OnRecordEventFromScb(napi_env env, const napi_callback_info info);
106 napi_value OnGetFoldStatus(napi_env env, const napi_callback_info info);108 napi_value OnGetFoldStatus(napi_env env, const napi_callback_info info);
107 napi_value OnGetSuperFoldStatus(napi_env env, const napi_callback_info info);109 napi_value OnGetSuperFoldStatus(napi_env env, const napi_callback_info info);
@@ -124,6 +126,7 @@ private:
124 napi_value OnRegisterSwitchUserAnimationNotification(napi_env env, napi_callback_info info);126 napi_value OnRegisterSwitchUserAnimationNotification(napi_env env, napi_callback_info info);
125 bool ObtainCallBackInfo(napi_env env, const napi_callback_info info,127 bool ObtainCallBackInfo(napi_env env, const napi_callback_info info,
126 std::string& callbackType, napi_ref& callbackRef);128 std::string& callbackType, napi_ref& callbackRef);
129+ bool CheckAndTransState(ScbScreenPowerState state, ScreenPowerState& screenState);
127 130 
128 std::shared_ptr<NativeReference> screenConnectionCallback_;131 std::shared_ptr<NativeReference> screenConnectionCallback_;
129 std::vector<std::shared_ptr<NativeReference>> tentModeChangeCallback_;132 std::vector<std::shared_ptr<NativeReference>> tentModeChangeCallback_;
Mwindow_scene/interfaces/kits/napi/screen_session_manager/js_screen_utils.cpp+18-0
@@ -184,6 +184,24 @@ napi_value JsScreenUtils::CreateJsScreenPropertyChangeType(napi_env env)
184 return objValue;184 return objValue;
185}185}
186 186 
187+napi_value JsScreenUtils::CreateJsScreenPowerState(napi_env env)
188+{
189+ napi_value objValue = nullptr;
190+ napi_create_object(env, &objValue);
191+ if (objValue == nullptr) {
192+ TLOGE(WmsLogTag::DMS, "Failed to create object!");
193+ return NapiGetUndefined(env);
194+ }
195+ 
196+ napi_set_named_property(env, objValue, "POWER_OFF", CreateJsValue(env,
197+ static_cast<int32_t>(ScbScreenPowerState::POWER_OFF)));
198+ napi_set_named_property(env, objValue, "POWER_DOZE", CreateJsValue(env,
199+ static_cast<int32_t>(ScbScreenPowerState::POWER_DOZE)));
200+ napi_set_named_property(env, objValue, "POWER_DOZE_SUSPEND", CreateJsValue(env,
201+ static_cast<int32_t>(ScbScreenPowerState::POWER_DOZE_SUSPEND)));
202+ return objValue;
203+}
204+ 
187napi_value JsScreenUtils::CreateJsSuperFoldStatus(napi_env env)205napi_value JsScreenUtils::CreateJsSuperFoldStatus(napi_env env)
188{206{
189 napi_value objValue = nullptr;207 napi_value objValue = nullptr;
Mwindow_scene/interfaces/kits/napi/screen_session_manager/js_screen_utils.h+1-0
@@ -36,6 +36,7 @@ public:
36 static napi_value CreateJsScreenPropertyChangeReason(napi_env env);36 static napi_value CreateJsScreenPropertyChangeReason(napi_env env);
37 static napi_value CreateJsFoldStatus(napi_env env);37 static napi_value CreateJsFoldStatus(napi_env env);
38 static napi_value CreateJsScreenPropertyChangeType(napi_env env);38 static napi_value CreateJsScreenPropertyChangeType(napi_env env);
39+ static napi_value CreateJsScreenPowerState(napi_env env);
39 static napi_value CreateJsSuperFoldStatus(napi_env env);40 static napi_value CreateJsSuperFoldStatus(napi_env env);
40 static napi_value CreateJsExtendScreenConnectStatus(napi_env env);41 static napi_value CreateJsExtendScreenConnectStatus(napi_env env);
41 static napi_value CreateJsScreenModeChangeEvent(napi_env env);42 static napi_value CreateJsScreenModeChangeEvent(napi_env env);
Mwindow_scene/screen_session_manager/include/screen_power_fsm/screen_state_machine.h+2-0
@@ -68,6 +68,8 @@ enum class ScreenPowerEvent {
68 WAKEUP_BEGIN,68 WAKEUP_BEGIN,
69 SUSPEND_BEGIN,69 SUSPEND_BEGIN,
70 WAKEUP_BEGIN_ADVANCED,70 WAKEUP_BEGIN_ADVANCED,
71+ SET_SCREEN_POWER_FOR_ALL_DOZE,
72+ SET_SCREEN_POWER_FOR_ALL_DOZE_SUSPEND,
71 SCREEN_POWER_EVENT_MAX,73 SCREEN_POWER_EVENT_MAX,
72 SYNC_POWER_ON, //Special scenario, PMS force synchronization ON state74 SYNC_POWER_ON, //Special scenario, PMS force synchronization ON state
73};75};
Mwindow_scene/screen_session_manager/include/screen_session_manager.h+1-0
@@ -573,6 +573,7 @@ public:
573 bool IsFreezed(const int32_t& agentPid, const DisplayManagerAgentType& agentType);573 bool IsFreezed(const int32_t& agentPid, const DisplayManagerAgentType& agentType);
574 bool isScreenShot_ = false;574 bool isScreenShot_ = false;
575 void NotifyAodOpCompletion(AodOP operation, int32_t result) override;575 void NotifyAodOpCompletion(AodOP operation, int32_t result) override;
576+ void SetPowerStateForAod(ScreenPowerState state) override;
576 void DoAodExitAndSetPower(ScreenId screenId, ScreenPowerStatus status);577 void DoAodExitAndSetPower(ScreenId screenId, ScreenPowerStatus status);
577 void DoAodExitAndSetPowerAllOff();578 void DoAodExitAndSetPowerAllOff();
578 DMError GetRoundedCorner(DisplayId displayId, int& radius) override;579 DMError GetRoundedCorner(DisplayId displayId, int& radius) override;
Mwindow_scene/screen_session_manager/include/zidl/screen_session_manager_interface.h+1-0
@@ -330,6 +330,7 @@ public:
330 virtual void NotifyFoldToExpandCompletion(bool foldToExpand) {}330 virtual void NotifyFoldToExpandCompletion(bool foldToExpand) {}
331 virtual void NotifyScreenConnectCompletion(ScreenId screenId) {}331 virtual void NotifyScreenConnectCompletion(ScreenId screenId) {}
332 virtual void NotifyAodOpCompletion(AodOP op, int32_t result) {}332 virtual void NotifyAodOpCompletion(AodOP op, int32_t result) {}
333+ virtual void SetPowerStateForAod(ScreenPowerState state) {}
333 virtual void RecordEventFromScb(std::string description, bool needRecordEvent) {}334 virtual void RecordEventFromScb(std::string description, bool needRecordEvent) {}
334 virtual DeviceScreenConfig GetDeviceScreenConfig() { return {}; }335 virtual DeviceScreenConfig GetDeviceScreenConfig() { return {}; }
335 virtual DMError SetVirtualScreenMaxRefreshRate(ScreenId id, uint32_t refreshRate,336 virtual DMError SetVirtualScreenMaxRefreshRate(ScreenId id, uint32_t refreshRate,
Mwindow_scene/screen_session_manager/include/zidl/screen_session_manager_proxy.h+1-0
@@ -221,6 +221,7 @@ public:
221 void NotifyFoldToExpandCompletion(bool foldToExpand) override;221 void NotifyFoldToExpandCompletion(bool foldToExpand) override;
222 void NotifyScreenConnectCompletion(ScreenId screenId) override;222 void NotifyScreenConnectCompletion(ScreenId screenId) override;
223 void NotifyAodOpCompletion(AodOP op, int32_t result) override;223 void NotifyAodOpCompletion(AodOP op, int32_t result) override;
224+ void SetPowerStateForAod(ScreenPowerState state) override;
224 void RecordEventFromScb(std::string description, bool needRecordEvent) override;225 void RecordEventFromScb(std::string description, bool needRecordEvent) override;
225 void SwitchUser() override;226 void SwitchUser() override;
226 227 
Mwindow_scene/screen_session_manager/src/screen_power_fsm/screen_state_machine.cpp+13-0
@@ -228,6 +228,10 @@ void ScreenStateMachine::InitStateMachineTbl()
228 228 
229 stateMachine_[{ScreenTransitionState::SCREEN_OFF, ScreenPowerEvent::WAKEUP_BEGIN}] = {229 stateMachine_[{ScreenTransitionState::SCREEN_OFF, ScreenPowerEvent::WAKEUP_BEGIN}] = {
230 ScreenTransitionState::WAIT_SCREEN_ON_READY, &ScreenStateMachine::DoWakeUpBegin};230 ScreenTransitionState::WAIT_SCREEN_ON_READY, &ScreenStateMachine::DoWakeUpBegin};
231+ stateMachine_[{ScreenTransitionState::SCREEN_OFF, ScreenPowerEvent::SET_SCREEN_POWER_FOR_ALL_DOZE}] = {
232+ ScreenTransitionState::SCREEN_DOZE, &ScreenStateMachine::DoSetScreenPowerForAll};
233+ stateMachine_[{ScreenTransitionState::SCREEN_OFF, ScreenPowerEvent::SET_SCREEN_POWER_FOR_ALL_DOZE_SUSPEND}] = {
234+ ScreenTransitionState::SCREEN_DOZE_SUSPEND, &ScreenStateMachine::DoSetScreenPowerForAll};
231 stateMachine_[{ScreenTransitionState::SCREEN_OFF, ScreenPowerEvent::POWER_ON_DIRECTLY}] = {235 stateMachine_[{ScreenTransitionState::SCREEN_OFF, ScreenPowerEvent::POWER_ON_DIRECTLY}] = {
232 ScreenTransitionState::SCREEN_ON, &ScreenStateMachine::DoSetScreenPower};236 ScreenTransitionState::SCREEN_ON, &ScreenStateMachine::DoSetScreenPower};
233 stateMachine_[{ScreenTransitionState::SCREEN_OFF, ScreenPowerEvent::POWER_OFF_DIRECTLY}] = {237 stateMachine_[{ScreenTransitionState::SCREEN_OFF, ScreenPowerEvent::POWER_OFF_DIRECTLY}] = {
@@ -315,6 +319,10 @@ void ScreenStateMachine::InitStateMachineTbl()
315 stateMachine_[{ScreenTransitionState::SCREEN_DOZE, ScreenPowerEvent::WAKEUP_BEGIN}] = {319 stateMachine_[{ScreenTransitionState::SCREEN_DOZE, ScreenPowerEvent::WAKEUP_BEGIN}] = {
316 ScreenTransitionState::WAIT_SCREEN_ON_READY, &ScreenStateMachine::DoWakeUpBegin,320 ScreenTransitionState::WAIT_SCREEN_ON_READY, &ScreenStateMachine::DoWakeUpBegin,
317 SCREEN_STATE_NORMAL_TIMEOUT_MS, &ScreenStateMachine::DoScreenPowerOn};321 SCREEN_STATE_NORMAL_TIMEOUT_MS, &ScreenStateMachine::DoScreenPowerOn};
322+ stateMachine_[{ScreenTransitionState::SCREEN_DOZE, ScreenPowerEvent::SET_SCREEN_POWER_FOR_ALL_POWER_OFF}] = {
323+ ScreenTransitionState::SCREEN_OFF, &ScreenStateMachine::DoSetScreenPowerForAll};
324+ stateMachine_[{ScreenTransitionState::SCREEN_DOZE, ScreenPowerEvent::SET_SCREEN_POWER_FOR_ALL_DOZE_SUSPEND}] = {
325+ ScreenTransitionState::SCREEN_DOZE_SUSPEND, &ScreenStateMachine::DoSetScreenPowerForAll};
318 stateMachine_[{ScreenTransitionState::SCREEN_DOZE, ScreenPowerEvent::POWER_OFF}] = {326 stateMachine_[{ScreenTransitionState::SCREEN_DOZE, ScreenPowerEvent::POWER_OFF}] = {
319 ScreenTransitionState::SCREEN_OFF, &ScreenStateMachine::DoSetScreenPower};327 ScreenTransitionState::SCREEN_OFF, &ScreenStateMachine::DoSetScreenPower};
320 stateMachine_[{ScreenTransitionState::SCREEN_DOZE, ScreenPowerEvent::E_DOZE_SUSPEND}] = {328 stateMachine_[{ScreenTransitionState::SCREEN_DOZE, ScreenPowerEvent::E_DOZE_SUSPEND}] = {
@@ -326,6 +334,11 @@ void ScreenStateMachine::InitStateMachineTbl()
326 334 
327 stateMachine_[{ScreenTransitionState::SCREEN_DOZE_SUSPEND, ScreenPowerEvent::E_DOZE}] = {335 stateMachine_[{ScreenTransitionState::SCREEN_DOZE_SUSPEND, ScreenPowerEvent::E_DOZE}] = {
328 ScreenTransitionState::SCREEN_DOZE, &ScreenStateMachine::DoSetScreenPower};336 ScreenTransitionState::SCREEN_DOZE, &ScreenStateMachine::DoSetScreenPower};
337+ stateMachine_[{ScreenTransitionState::SCREEN_DOZE_SUSPEND,
338+ ScreenPowerEvent::SET_SCREEN_POWER_FOR_ALL_POWER_OFF}] = {
339+ ScreenTransitionState::SCREEN_OFF, &ScreenStateMachine::DoSetScreenPowerForAll};
340+ stateMachine_[{ScreenTransitionState::SCREEN_DOZE_SUSPEND, ScreenPowerEvent::SET_SCREEN_POWER_FOR_ALL_DOZE}] = {
341+ ScreenTransitionState::SCREEN_DOZE, &ScreenStateMachine::DoSetScreenPowerForAll};
329 stateMachine_[{ScreenTransitionState::SCREEN_DOZE_SUSPEND, ScreenPowerEvent::WAKEUP_BEGIN}] = {342 stateMachine_[{ScreenTransitionState::SCREEN_DOZE_SUSPEND, ScreenPowerEvent::WAKEUP_BEGIN}] = {
330 ScreenTransitionState::WAIT_SCREEN_ON_READY, &ScreenStateMachine::DoWakeUpBegin,343 ScreenTransitionState::WAIT_SCREEN_ON_READY, &ScreenStateMachine::DoWakeUpBegin,
331 SCREEN_STATE_NORMAL_TIMEOUT_MS, &ScreenStateMachine::DoScreenPowerOn};344 SCREEN_STATE_NORMAL_TIMEOUT_MS, &ScreenStateMachine::DoScreenPowerOn};
Mwindow_scene/screen_session_manager/src/screen_session_manager.cpp+30-0
@@ -14227,6 +14227,36 @@ void ScreenSessionManager::NotifyAodOpCompletion(AodOP operation, int32_t result
14227 }14227 }
14228}14228}
14229 14229 
14230+void ScreenSessionManager::SetPowerStateForAod(ScreenPowerState state)
14231+{
14232+ if (!SessionPermission::IsSystemCalling()) {
14233+ TLOGNFE(WmsLogTag::DMS, "permission denied!");
14234+ return;
14235+ }
14236+ TLOGNFI(WmsLogTag::DMS, "[UL_POWER]state: %{public}u", state);
14237+ ScreenPowerInfoType curType;
14238+ ScreenPowerEvent event;
14239+ if (state == ScreenPowerState::POWER_DOZE) {
14240+ event = ScreenPowerEvent::SET_SCREEN_POWER_FOR_ALL_DOZE;
14241+ curType = std::make_pair(state, PowerStateChangeReason::STATE_CHANGE_REASON_AOD_SET_DOZE);
14242+ } else if (state == ScreenPowerState::POWER_DOZE_SUSPEND) {
14243+ event = ScreenPowerEvent::SET_SCREEN_POWER_FOR_ALL_DOZE_SUSPEND;
14244+ curType = std::make_pair(state, PowerStateChangeReason::STATE_CHANGE_REASON_AOD_SET_DOZE_SUSPEND);
14245+ } else if (state == ScreenPowerState::POWER_OFF) {
14246+ event = ScreenPowerEvent::SET_SCREEN_POWER_FOR_ALL_POWER_OFF;
14247+ curType = std::make_pair(state, PowerStateChangeReason::STATE_CHANGE_REASON_AOD_SET_OFF);
14248+ } else {
14249+ TLOGNFE(WmsLogTag::DMS, "[UL_POWER]invalid state: %{public}u", state);
14250+ return;
14251+ }
14252+ bool isSuccess = ScreenStateMachine::GetInstance().HandlePowerStateChange(event, curType);
14253+ if (!isSuccess) {
14254+ TLOGNFE(WmsLogTag::DMS, "[UL_POWER]set false, state: %{public}u", state);
14255+ return;
14256+ }
14257+ TLOGD(WmsLogTag::DMS, "[UL_POWER]set state success: %{public}u", state);
14258+}
14259+ 
14230#ifdef FOLD_ABILITY_ENABLE14260#ifdef FOLD_ABILITY_ENABLE
14231bool ScreenSessionManager::WaitAodOpNotify()14261bool ScreenSessionManager::WaitAodOpNotify()
14232{14262{
Mwindow_scene/screen_session_manager/src/zidl/screen_session_manager_proxy.cpp+26-0
@@ -4156,6 +4156,32 @@ void ScreenSessionManagerProxy::NotifyAodOpCompletion(AodOP operation, int32_t r
4156 }4156 }
4157}4157}
4158 4158 
4159+void ScreenSessionManagerProxy::SetPowerStateForAod(ScreenPowerState state)
4160+{
4161+ sptr<IRemoteObject> remote = Remote();
4162+ if (remote == nullptr) {
4163+ TLOGE(WmsLogTag::DMS, "remote is null");
4164+ return;
4165+ }
4166+ 
4167+ MessageOption option(MessageOption::TF_ASYNC);
4168+ MessageParcel reply;
4169+ MessageParcel data;
4170+ if (!data.WriteInterfaceToken(GetDescriptor())) {
4171+ TLOGE(WmsLogTag::DMS, "WriteInterfaceToken failed");
4172+ return ;
4173+ }
4174+ if (!data.WriteUint32(static_cast<uint32_t>(state))) {
4175+ TLOGE(WmsLogTag::DMS, "Write state failed");
4176+ return;
4177+ }
4178+ if (remote->SendRequest(static_cast<uint32_t>(DisplayManagerMessage::TRANS_ID_SET_POWER_STATE_AOD),
4179+ data, reply, option) != ERR_NONE) {
4180+ TLOGE(WmsLogTag::DMS, "SendRequest failed");
4181+ return;
4182+ }
4183+}
4184+ 
4159void ScreenSessionManagerProxy::RecordEventFromScb(std::string description, bool needRecordEvent)4185void ScreenSessionManagerProxy::RecordEventFromScb(std::string description, bool needRecordEvent)
4160{4186{
4161 sptr<IRemoteObject> remote = Remote();4187 sptr<IRemoteObject> remote = Remote();
Mwindow_scene/screen_session_manager/src/zidl/screen_session_manager_stub.cpp+9-0
@@ -1297,6 +1297,15 @@ int32_t ScreenSessionManagerStub::OnRemoteRequestInner(uint32_t code, MessagePar
1297 NotifyAodOpCompletion(static_cast<AodOP>(op), result);1297 NotifyAodOpCompletion(static_cast<AodOP>(op), result);
1298 break;1298 break;
1299 }1299 }
1300+ case DisplayManagerMessage::TRANS_ID_SET_POWER_STATE_AOD: {
1301+ uint32_t state;
1302+ if (!data.ReadUint32(state)) {
1303+ TLOGE(WmsLogTag::DMS, "Read state failed");
1304+ return ERR_INVALID_DATA;
1305+ }
1306+ SetPowerStateForAod(static_cast<ScreenPowerState>(state));
1307+ break;
1308+ }
1300 case DisplayManagerMessage::TRANS_ID_GET_VIRTUAL_SCREEN_FLAG: {1309 case DisplayManagerMessage::TRANS_ID_GET_VIRTUAL_SCREEN_FLAG: {
1301 ProcGetVirtualScreenFlag(data, reply);1310 ProcGetVirtualScreenFlag(data, reply);
1302 break;1311 break;
Mwindow_scene/screen_session_manager_client/include/screen_session_manager_client.h+1-0
@@ -93,6 +93,7 @@ public:
93 void NotifyFoldToExpandCompletion(bool foldToExpand);93 void NotifyFoldToExpandCompletion(bool foldToExpand);
94 void NotifyScreenConnectCompletion(ScreenId screenId);94 void NotifyScreenConnectCompletion(ScreenId screenId);
95 void NotifyAodOpCompletion(AodOP operation, int32_t result);95 void NotifyAodOpCompletion(AodOP operation, int32_t result);
96+ void SetPowerStateForAod(ScreenPowerState state);
96 void RecordEventFromScb(std::string description, bool needRecordEvent);97 void RecordEventFromScb(std::string description, bool needRecordEvent);
97 FoldStatus GetFoldStatus();98 FoldStatus GetFoldStatus();
98 SuperFoldStatus GetSuperFoldStatus();99 SuperFoldStatus GetSuperFoldStatus();
Mwindow_scene/screen_session_manager_client/src/screen_session_manager_client.cpp+9-0
@@ -676,6 +676,15 @@ void ScreenSessionManagerClient::NotifyAodOpCompletion(AodOP operation, int32_t
676 screenSessionManager_->NotifyAodOpCompletion(operation, result);676 screenSessionManager_->NotifyAodOpCompletion(operation, result);
677}677}
678 678 
679+void ScreenSessionManagerClient::SetPowerStateForAod(ScreenPowerState state)
680+{
681+ if (!screenSessionManager_) {
682+ TLOGE(WmsLogTag::DMS, "screenSessionManager is null");
683+ return;
684+ }
685+ screenSessionManager_->SetPowerStateForAod(state);
686+}
687+ 
679void ScreenSessionManagerClient::RecordEventFromScb(std::string description, bool needRecordEvent)688void ScreenSessionManagerClient::RecordEventFromScb(std::string description, bool needRecordEvent)
680{689{
681 if (!screenSessionManager_) {690 if (!screenSessionManager_) {
Mwindow_scene/test/dms_unittest/screen_session_manager_client_test.cpp+16-0
@@ -2493,5 +2493,21 @@ HWTEST_F(ScreenSessionManagerClientTest, ProcPropertyChangedForSuperFold, TestSi
2493 logMsg.clear();2493 logMsg.clear();
2494 LOG_SetCallback(nullptr);2494 LOG_SetCallback(nullptr);
2495}2495}
2496+ 
2497+/**
2498+ * @tc.name: SetPowerStateForAod01
2499+ * @tc.desc: SetPowerStateForAod test, normal test
2500+ * @tc.type: FUNC
2501+ */
2502+HWTEST_F(ScreenSessionManagerClientTest, SetPowerStateForAod01, TestSize.Level1)
2503+{
2504+ logMsg.clear();
2505+ LOG_SetCallback(MyLogCallback);
2506+ ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
2507+ screenSessionManagerClient_->SetPowerStateForAod(ScreenPowerState::POWER_DOZE);
2508+ EXPECT_TRUE(logMsg.find("screenSessionManager is null") == std::string::npos);
2509+ logMsg.clear();
2510+ LOG_SetCallback(nullptr);
2511+}
2496} // namespace Rosen2512} // namespace Rosen
2497} // namespace OHOS2513} // namespace OHOS
Mwindow_scene/test/dms_unittest/screen_session_manager_stub_test.cpp+37-0
@@ -3745,6 +3745,43 @@ HWTEST_F(ScreenSessionManagerStubTest, IsOnboardDisplay, TestSize.Level1)
3745 EXPECT_TRUE(g_logMsg.find("write res failed") == std::string::npos);3745 EXPECT_TRUE(g_logMsg.find("write res failed") == std::string::npos);
3746 LOG_SetCallback(nullptr);3746 LOG_SetCallback(nullptr);
3747}3747}
3748+ 
3749+/**
3750+ * @tc.name: SetPowerStateForAodAbnormalTest
3751+ * @tc.desc: SetPowerStateForAodAbnormalTest test abnormal input
3752+ * @tc.type: FUNC
3753+ */
3754+HWTEST_F(ScreenSessionManagerStubTest, SetPowerStateForAodAbnormalTest, TestSize.Level1)
3755+{
3756+ MessageParcel data;
3757+ MessageParcel reply;
3758+ MessageOption option;
3759+ 
3760+ data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
3761+ uint32_t code = static_cast<uint32_t>(DisplayManagerMessage::TRANS_ID_SET_POWER_STATE_AOD);
3762+ int res = stub_->OnRemoteRequest(code, data, reply, option);
3763+ EXPECT_EQ(res, -1);
3764+}
3765+ 
3766+/**
3767+ * @tc.name: SetPowerStateForAodNnormalTest
3768+ * @tc.desc: SetPowerStateForAodNnormalTest test normal input
3769+ * @tc.type: FUNC
3770+ */
3771+HWTEST_F(ScreenSessionManagerStubTest, SetPowerStateForAodNnormalTest, TestSize.Level1)
3772+{
3773+ MessageParcel data;
3774+ MessageParcel reply;
3775+ MessageOption option;
3776+ 
3777+ data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
3778+ 
3779+ ScreenPowerState state = ScreenPowerState::POWER_DOZE;
3780+ data.WriteUint32(static_cast<uint32_t>(state));
3781+ uint32_t code = static_cast<uint32_t>(DisplayManagerMessage::TRANS_ID_SET_POWER_STATE_AOD);
3782+ int res = stub_->OnRemoteRequest(code, data, reply, option);
3783+ EXPECT_EQ(res, 0);
3784+}
3748}3785}
3749}3786}
3750}3787}
Mwindow_scene/test/dms_unittest/screen_session_manager_test_seven.cpp+33-0
@@ -1145,6 +1145,39 @@ HWTEST_F(ScreenSessionManagerTest, GetIsCurrentInUseById01, Function | SmallTest
1145 auto res = ssm->GetIsCurrentInUseById(screenId);1145 auto res = ssm->GetIsCurrentInUseById(screenId);
1146 ASSERT_EQ(false, res);1146 ASSERT_EQ(false, res);
1147}1147}
1148+ 
1149+/**
1150+ * @tc.name: SetPowerStateForAodPermission
1151+ * @tc.desc: SetPowerStateForAodPermission test no permission
1152+ * @tc.type: FUNC
1153+ */
1154+HWTEST_F(ScreenSessionManagerTest, SetPowerStateForAodPermission, TestSize.Level1)
1155+{
1156+ g_logMsg.clear();
1157+ LOG_SetCallback(MyLogCallback);
1158+ MockAccesstokenKit::MockIsSystemApp(false);
1159+ MockAccesstokenKit::MockIsSACalling(false);
1160+ ssm_->SetPowerStateForAod(ScreenPowerState::POWER_DOZE);
1161+ EXPECT_TRUE(g_logMsg.find("permission denied!") != std::string::npos);
1162+ LOG_SetCallback(nullptr);
1163+}
1164+ 
1165+/**
1166+ * @tc.name: SetPowerStateForAodInvalidState
1167+ * @tc.desc: SetPowerStateForAodInvalidState test invalid state
1168+ * @tc.type: FUNC
1169+ */
1170+HWTEST_F(ScreenSessionManagerTest, SetPowerStateForAodInvalidState, TestSize.Level1)
1171+{
1172+ g_logMsg.clear();
1173+ LOG_SetCallback(MyLogCallback);
1174+ MockAccesstokenKit::MockIsSystemApp(true);
1175+ MockAccesstokenKit::MockIsSACalling(true);
1176+ ssm_->SetPowerStateForAod(ScreenPowerState::POWER_DOZE);
1177+ ssm_->SetPowerStateForAod(ScreenPowerState::INVALID_STATE);
1178+ EXPECT_TRUE(g_logMsg.find("[UL_POWER]invalid state:") != std::string::npos);
1179+ LOG_SetCallback(nullptr);
1180+}
1148}1181}
1149} // namespace Rosen1182} // namespace Rosen
1150} // namespace OHOS1183} // namespace OHOS