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