• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2021-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 "screen_action.h"
17 #include <datetime_ex.h>
18 #include <hisysevent.h>
19 #include <ipc_skeleton.h>
20 
21 #include "display_log.h"
22 #include "power_state_machine_info.h"
23 #include "screen_manager_lite.h"
24 
25 namespace OHOS {
26 namespace DisplayPowerMgr {
ScreenAction(uint32_t displayId)27 ScreenAction::ScreenAction(uint32_t displayId) : displayId_(displayId)
28 {}
29 
GetDefaultDisplayId()30 uint32_t ScreenAction::GetDefaultDisplayId()
31 {
32     std::string identity = IPCSkeleton::ResetCallingIdentity();
33     uint64_t defaultId = Rosen::DisplayManagerLite::GetInstance().GetDefaultDisplayId();
34     IPCSkeleton::SetCallingIdentity(identity);
35     return static_cast<uint32_t>(defaultId);
36 }
37 
GetAllDisplayId()38 std::vector<uint32_t> ScreenAction::GetAllDisplayId()
39 {
40     std::string identity = IPCSkeleton::ResetCallingIdentity();
41     std::vector<uint64_t> allIds = Rosen::DisplayManagerLite::GetInstance().GetAllDisplayIds();
42     IPCSkeleton::SetCallingIdentity(identity);
43     std::vector<uint32_t> displayIds;
44     std::transform(allIds.begin(), allIds.end(), back_inserter(displayIds), [](uint64_t id) {
45         return static_cast<uint32_t>(id);
46     });
47     return displayIds;
48 }
49 
GetDisplayId()50 uint32_t ScreenAction::GetDisplayId()
51 {
52     return displayId_;
53 }
54 
GetDisplayState()55 DisplayState ScreenAction::GetDisplayState()
56 {
57     DisplayState state = DisplayState::DISPLAY_UNKNOWN;
58     Rosen::ScreenPowerState powerState = Rosen::ScreenManagerLite::GetInstance().GetScreenPower(displayId_);
59     DISPLAY_HILOGI(FEAT_STATE, "ScreenPowerState=%{public}d", static_cast<uint32_t>(powerState));
60     switch (powerState) {
61         case Rosen::ScreenPowerState::POWER_ON:
62             state = DisplayState::DISPLAY_ON;
63             break;
64         case Rosen::ScreenPowerState::POWER_STAND_BY:
65             state = DisplayState::DISPLAY_DIM;
66             break;
67         case Rosen::ScreenPowerState::POWER_SUSPEND:
68             state = DisplayState::DISPLAY_SUSPEND;
69             break;
70         case Rosen::ScreenPowerState::POWER_OFF:
71             state = DisplayState::DISPLAY_OFF;
72             break;
73         default:
74             break;
75     }
76     DISPLAY_HILOGI(FEAT_STATE, "state=%{public}u displayId=%{public}u", static_cast<uint32_t>(state), displayId_);
77     return state;
78 }
79 
EnableSkipSetDisplayState(uint32_t reason)80 bool ScreenAction::EnableSkipSetDisplayState(uint32_t reason)
81 {
82     if (reason == static_cast<uint32_t>(PowerMgr::StateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT_AUTH_SUCCESS)) {
83         return true;
84     }
85     return false;
86 }
87 
WriteHiSysEvent(DisplayState state,int32_t beginTimeMs)88 void ScreenAction::WriteHiSysEvent(DisplayState state, int32_t beginTimeMs)
89 {
90     constexpr int32_t DMS_WAIT_LOCKSCREENON_TIMEOUT = 300;
91     constexpr int32_t DMS_WAIT_LOCKSCREENOFF_TIMEOUT = 2000;
92     constexpr int32_t DMS_WAIT_LOCKSCREENON_TYPE = 0;
93     constexpr int32_t DMS_WAIT_LOCKSCREENOFF_TYPE = 1;
94     int32_t endTimeMs = GetTickCount();
95     if ((endTimeMs - beginTimeMs > DMS_WAIT_LOCKSCREENON_TIMEOUT) && state == DisplayState::DISPLAY_ON) {
96         DISPLAY_HILOGI(FEAT_STATE, "dms wait lockscreenon timeout=%{public}d", (endTimeMs - beginTimeMs));
97         HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::DISPLAY, "DMS_WAIT_LOCKSCREEN_TIMEOUT",
98             HiviewDFX::HiSysEvent::EventType::BEHAVIOR, "TYPE", DMS_WAIT_LOCKSCREENON_TYPE,
99             "TIME", (endTimeMs - beginTimeMs));
100     } else if ((endTimeMs - beginTimeMs > DMS_WAIT_LOCKSCREENOFF_TIMEOUT) && state == DisplayState::DISPLAY_OFF) {
101         DISPLAY_HILOGI(FEAT_STATE, "dms wait lockscreenoff timeout=%{public}d", (endTimeMs - beginTimeMs));
102         HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::DISPLAY, "DMS_WAIT_LOCKSCREEN_TIMEOUT",
103             HiviewDFX::HiSysEvent::EventType::BEHAVIOR, "TYPE", DMS_WAIT_LOCKSCREENOFF_TYPE,
104             "TIME", (endTimeMs - beginTimeMs));
105     }
106 }
107 
SetDisplayState(DisplayState state,const std::function<void (DisplayState)> & callback)108 bool ScreenAction::SetDisplayState(DisplayState state, const std::function<void(DisplayState)>& callback)
109 {
110 #ifdef HAS_HIVIEWDFX_HISYSEVENT_PART
111     int32_t beginTimeMs = GetTickCount();
112 #endif
113     DISPLAY_HILOGI(FEAT_STATE, "[UL_POWER] SetDisplayState displayId=%{public}u, state=%{public}u", displayId_,
114         static_cast<uint32_t>(state));
115     Rosen::DisplayState rds = Rosen::DisplayState::UNKNOWN;
116     switch (state) {
117         case DisplayState::DISPLAY_ON:
118             rds = Rosen::DisplayState::ON;
119             break;
120         case DisplayState::DISPLAY_OFF:
121             rds = Rosen::DisplayState::OFF;
122             break;
123         default:
124             break;
125     }
126     std::string identity = IPCSkeleton::ResetCallingIdentity();
127     bool ret = Rosen::DisplayManagerLite::GetInstance().SetDisplayState(rds,
128         [callback](Rosen::DisplayState rosenState) {
129         DISPLAY_HILOGI(FEAT_STATE, "[UL_POWER] SetDisplayState Callback:%{public}d", static_cast<uint32_t>(rosenState));
130         DisplayState state;
131         switch (rosenState) {
132             case Rosen::DisplayState::ON:
133                 state = DisplayState::DISPLAY_ON;
134                 break;
135             case Rosen::DisplayState::OFF:
136                 state = DisplayState::DISPLAY_OFF;
137                 break;
138             case Rosen::DisplayState::ON_SUSPEND:
139                 state = DisplayState::DISPLAY_SUSPEND;
140                 break;
141             default:
142                 return;
143         }
144         callback(state);
145     });
146 #ifdef HAS_HIVIEWDFX_HISYSEVENT_PART
147     WriteHiSysEvent(state, beginTimeMs);
148 #endif
149     IPCSkeleton::SetCallingIdentity(identity);
150     // Notify screen state change event to battery statistics
151     HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::DISPLAY, "SCREEN_STATE",
152         HiviewDFX::HiSysEvent::EventType::STATISTIC, "STATE", static_cast<int32_t>(state));
153     DISPLAY_HILOGI(FEAT_STATE, "[UL_POWER] SetDisplayState: displayId=%{public}u, state=%{public}u, ret=%{public}d",
154         displayId_, static_cast<uint32_t>(state), ret);
155     return ret;
156 }
157 
ParseSpecialReason(uint32_t reason)158 Rosen::PowerStateChangeReason ScreenAction::ParseSpecialReason(uint32_t reason)
159 {
160     auto changeReason = Rosen::PowerStateChangeReason::POWER_BUTTON;
161     switch (reason) {
162         case static_cast<uint32_t>(PowerMgr::StateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT):
163             changeReason = Rosen::PowerStateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT;
164             break;
165         case static_cast<uint32_t>(PowerMgr::StateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT_AUTH_FAIL_SCREEN_ON):
166             changeReason = Rosen::PowerStateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT_AUTH_FAIL_SCREEN_ON;
167             break;
168         case static_cast<uint32_t>(PowerMgr::StateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT_AUTH_SUCCESS):
169             changeReason = Rosen::PowerStateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT_AUTH_SUCCESS;
170             break;
171         case static_cast<uint32_t>(PowerMgr::StateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT_AUTH_FAIL_SCREEN_OFF):
172             changeReason = Rosen::PowerStateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT_AUTH_FAIL_SCREEN_OFF;
173             break;
174         case static_cast<uint32_t>(PowerMgr::StateChangeReason::STATE_CHANGE_REASON_SWITCH):
175             changeReason = Rosen::PowerStateChangeReason::STATE_CHANGE_REASON_SWITCH;
176             break;
177         case static_cast<uint32_t>(PowerMgr::StateChangeReason::STATE_CHANGE_REASON_POWER_KEY):
178             changeReason = Rosen::PowerStateChangeReason::STATE_CHANGE_REASON_POWER_KEY;
179             break;
180         default:
181             break;
182     }
183     return changeReason;
184 }
185 
SetDisplayPower(DisplayState state,uint32_t reason)186 bool ScreenAction::SetDisplayPower(DisplayState state, uint32_t reason)
187 {
188     DISPLAY_HILOGI(FEAT_STATE, "[UL_POWER] SetDisplayPower displayId=%{public}u, state=%{public}u, reason=%{public}u",
189                    displayId_, static_cast<uint32_t>(state), reason);
190     Rosen::ScreenPowerState status = Rosen::ScreenPowerState::INVALID_STATE;
191     switch (state) {
192         case DisplayState::DISPLAY_ON:
193             status = Rosen::ScreenPowerState::POWER_ON;
194             break;
195         case DisplayState::DISPLAY_DIM:
196             status = Rosen::ScreenPowerState::POWER_STAND_BY;
197             break;
198         case DisplayState::DISPLAY_SUSPEND:
199             status = Rosen::ScreenPowerState::POWER_SUSPEND;
200             break;
201         case DisplayState::DISPLAY_OFF:
202             status = Rosen::ScreenPowerState::POWER_OFF;
203             break;
204         default:
205             break;
206     }
207 
208     bool ret = false;
209     auto changeReason = ParseSpecialReason(reason);
210     if (coordinated_ && reason == static_cast<uint32_t>(PowerMgr::StateChangeReason::STATE_CHANGE_REASON_TIMEOUT)) {
211         ret = Rosen::ScreenManagerLite::GetInstance().SetSpecifiedScreenPower(
212             displayId_, status, Rosen::PowerStateChangeReason::STATE_CHANGE_REASON_COLLABORATION);
213     } else {
214         ret = Rosen::ScreenManagerLite::GetInstance().SetScreenPowerForAll(status, changeReason);
215     }
216     DISPLAY_HILOGI(FEAT_STATE,
217         "[UL_POWER] SetDisplayPower state=%{public}u, reason=%{public}u, ret=%{public}d, coordinated=%{public}d",
218         static_cast<uint32_t>(state), reason, ret, coordinated_);
219     return (state == DisplayState::DISPLAY_DIM || state == DisplayState::DISPLAY_SUSPEND) ? true : ret;
220 }
221 
GetBrightness()222 uint32_t ScreenAction::GetBrightness()
223 {
224     std::lock_guard lock(mutexBrightness_);
225     std::string identity = IPCSkeleton::ResetCallingIdentity();
226     brightness_ = Rosen::DisplayManagerLite::GetInstance().GetScreenBrightness(displayId_);
227     IPCSkeleton::SetCallingIdentity(identity);
228     DISPLAY_HILOGD(FEAT_BRIGHTNESS, "displayId=%{public}u, brightness=%{public}u", displayId_, brightness_);
229     return brightness_;
230 }
231 
SetBrightness(uint32_t value)232 bool ScreenAction::SetBrightness(uint32_t value)
233 {
234     DISPLAY_HILOGD(FEAT_BRIGHTNESS, "displayId=%{public}u, brightness=%{public}u", displayId_, value);
235     std::string identity = IPCSkeleton::ResetCallingIdentity();
236     bool isSucc = Rosen::DisplayManagerLite::GetInstance().SetScreenBrightness(displayId_, value);
237     IPCSkeleton::SetCallingIdentity(identity);
238     std::lock_guard lock(mutexBrightness_);
239     brightness_ = isSucc ? value : brightness_;
240     return isSucc;
241 }
242 
SetCoordinated(bool coordinated)243 void ScreenAction::SetCoordinated(bool coordinated)
244 {
245     coordinated_ = coordinated;
246 }
247 } // namespace DisplayPowerMgr
248 } // namespace OHOS
249