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 
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 
SetDisplayState(DisplayState state,const std::function<void (DisplayState)> & callback)88 bool ScreenAction::SetDisplayState(DisplayState state, const std::function<void(DisplayState)>& callback)
89 {
90     DISPLAY_HILOGI(FEAT_STATE, "[UL_POWER] SetDisplayState displayId=%{public}u, state=%{public}u", displayId_,
91         static_cast<uint32_t>(state));
92     Rosen::DisplayState rds = Rosen::DisplayState::UNKNOWN;
93     switch (state) {
94         case DisplayState::DISPLAY_ON:
95             rds = Rosen::DisplayState::ON;
96             break;
97         case DisplayState::DISPLAY_OFF:
98             rds = Rosen::DisplayState::OFF;
99             break;
100         default:
101             break;
102     }
103     std::string identity = IPCSkeleton::ResetCallingIdentity();
104     bool ret = Rosen::DisplayManagerLite::GetInstance().SetDisplayState(rds,
105         [callback](Rosen::DisplayState rosenState) {
106         DISPLAY_HILOGI(FEAT_STATE, "[UL_POWER] SetDisplayState Callback:%{public}d", static_cast<uint32_t>(rosenState));
107         DisplayState state;
108         switch (rosenState) {
109             case Rosen::DisplayState::ON:
110                 state = DisplayState::DISPLAY_ON;
111                 break;
112             case Rosen::DisplayState::OFF:
113                 state = DisplayState::DISPLAY_OFF;
114                 break;
115             case Rosen::DisplayState::ON_SUSPEND:
116                 state = DisplayState::DISPLAY_SUSPEND;
117                 break;
118             default:
119                 return;
120         }
121         callback(state);
122     });
123     IPCSkeleton::SetCallingIdentity(identity);
124     // Notify screen state change event to battery statistics
125     HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::DISPLAY, "SCREEN_STATE",
126         HiviewDFX::HiSysEvent::EventType::STATISTIC, "STATE", static_cast<int32_t>(state));
127     DISPLAY_HILOGI(FEAT_STATE, "[UL_POWER] SetDisplayState: displayId=%{public}u, state=%{public}u, ret=%{public}d",
128         displayId_, static_cast<uint32_t>(state), ret);
129     return ret;
130 }
131 
ParseSpecialReason(uint32_t reason)132 Rosen::PowerStateChangeReason ScreenAction::ParseSpecialReason(uint32_t reason)
133 {
134     auto changeReason = Rosen::PowerStateChangeReason::POWER_BUTTON;
135     switch (reason) {
136         case static_cast<uint32_t>(PowerMgr::StateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT):
137             changeReason = Rosen::PowerStateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT;
138             break;
139         case static_cast<uint32_t>(PowerMgr::StateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT_AUTH_FAIL_SCREEN_ON):
140             changeReason = Rosen::PowerStateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT_AUTH_FAIL_SCREEN_ON;
141             break;
142         case static_cast<uint32_t>(PowerMgr::StateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT_AUTH_SUCCESS):
143             changeReason = Rosen::PowerStateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT_AUTH_SUCCESS;
144             break;
145         case static_cast<uint32_t>(PowerMgr::StateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT_AUTH_FAIL_SCREEN_OFF):
146             changeReason = Rosen::PowerStateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT_AUTH_FAIL_SCREEN_OFF;
147             break;
148         case static_cast<uint32_t>(PowerMgr::StateChangeReason::STATE_CHANGE_REASON_SWITCH):
149             changeReason = Rosen::PowerStateChangeReason::STATE_CHANGE_REASON_SWITCH;
150             break;
151         case static_cast<uint32_t>(PowerMgr::StateChangeReason::STATE_CHANGE_REASON_POWER_KEY):
152             changeReason = Rosen::PowerStateChangeReason::STATE_CHANGE_REASON_POWER_KEY;
153             break;
154         default:
155             break;
156     }
157     return changeReason;
158 }
159 
SetDisplayPower(DisplayState state,uint32_t reason)160 bool ScreenAction::SetDisplayPower(DisplayState state, uint32_t reason)
161 {
162     DISPLAY_HILOGI(FEAT_STATE, "[UL_POWER] SetDisplayPower displayId=%{public}u, state=%{public}u, reason=%{public}u",
163                    displayId_, static_cast<uint32_t>(state), reason);
164     Rosen::ScreenPowerState status = Rosen::ScreenPowerState::INVALID_STATE;
165     switch (state) {
166         case DisplayState::DISPLAY_ON:
167             status = Rosen::ScreenPowerState::POWER_ON;
168             break;
169         case DisplayState::DISPLAY_DIM:
170             status = Rosen::ScreenPowerState::POWER_STAND_BY;
171             break;
172         case DisplayState::DISPLAY_SUSPEND:
173             status = Rosen::ScreenPowerState::POWER_SUSPEND;
174             break;
175         case DisplayState::DISPLAY_OFF:
176             status = Rosen::ScreenPowerState::POWER_OFF;
177             break;
178         default:
179             break;
180     }
181 
182     bool ret = false;
183     auto changeReason = ParseSpecialReason(reason);
184     if (coordinated_ && reason == static_cast<uint32_t>(PowerMgr::StateChangeReason::STATE_CHANGE_REASON_TIMEOUT)) {
185         ret = Rosen::ScreenManagerLite::GetInstance().SetSpecifiedScreenPower(
186             displayId_, status, Rosen::PowerStateChangeReason::STATE_CHANGE_REASON_COLLABORATION);
187     } else {
188         ret = Rosen::ScreenManagerLite::GetInstance().SetScreenPowerForAll(status, changeReason);
189     }
190     DISPLAY_HILOGI(FEAT_STATE,
191         "[UL_POWER] SetDisplayPower state=%{public}u, reason=%{public}u, ret=%{public}d, coordinated=%{public}d",
192         static_cast<uint32_t>(state), reason, ret, coordinated_);
193     return (state == DisplayState::DISPLAY_DIM || state == DisplayState::DISPLAY_SUSPEND) ? true : ret;
194 }
195 
GetBrightness()196 uint32_t ScreenAction::GetBrightness()
197 {
198     std::lock_guard lock(mutexBrightness_);
199     std::string identity = IPCSkeleton::ResetCallingIdentity();
200     brightness_ = Rosen::DisplayManagerLite::GetInstance().GetScreenBrightness(displayId_);
201     IPCSkeleton::SetCallingIdentity(identity);
202     DISPLAY_HILOGD(FEAT_BRIGHTNESS, "displayId=%{public}u, brightness=%{public}u", displayId_, brightness_);
203     return brightness_;
204 }
205 
SetBrightness(uint32_t value)206 bool ScreenAction::SetBrightness(uint32_t value)
207 {
208     DISPLAY_HILOGD(FEAT_BRIGHTNESS, "displayId=%{public}u, brightness=%{public}u", displayId_, value);
209     std::string identity = IPCSkeleton::ResetCallingIdentity();
210     bool isSucc = Rosen::DisplayManagerLite::GetInstance().SetScreenBrightness(displayId_, value);
211     IPCSkeleton::SetCallingIdentity(identity);
212     std::lock_guard lock(mutexBrightness_);
213     brightness_ = isSucc ? value : brightness_;
214     return isSucc;
215 }
216 
SetCoordinated(bool coordinated)217 void ScreenAction::SetCoordinated(bool coordinated)
218 {
219     coordinated_ = coordinated;
220 }
221 } // namespace DisplayPowerMgr
222 } // namespace OHOS
223