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 #ifndef POWERMGR_WAKEUP_CONTROLLER_H 17 #define POWERMGR_WAKEUP_CONTROLLER_H 18 19 #include <functional> 20 #include <memory> 21 #include <mutex> 22 #include <vector> 23 24 #ifdef HAS_MULTIMODALINPUT_INPUT_PART 25 #include "i_input_event_consumer.h" 26 #endif 27 #include "power_state_machine.h" 28 #include "system_ability.h" 29 #ifdef HAS_SENSORS_SENSOR_PART 30 #include "sensor_agent.h" 31 #endif 32 #include "wakeup_sources.h" 33 #include "wakeup_source_parser.h" 34 35 namespace OHOS { 36 namespace PowerMgr { 37 38 using WakeupListener = std::function<void(WakeupDeviceType)>; 39 using namespace OHOS::MMI; 40 class WakeupMonitor; 41 class WakeupController : public std::enable_shared_from_this<WakeupController> { 42 public: 43 explicit WakeupController(std::shared_ptr<PowerStateMachine>& stateMachine); 44 ~WakeupController(); 45 void Init(); 46 void Cancel(); 47 void RegisterSettingsObserver(); 48 void UnregisterSettingsObserver(); 49 void ExecWakeupMonitorByReason(WakeupDeviceType reason); 50 void Wakeup(); 51 void NotifyDisplayActionDone(uint32_t event); 52 void SetOriginSettingValue(WakeupSource& source); 53 #ifdef POWER_MANAGER_WAKEUP_ACTION 54 bool IsLowCapacityWakeup(WakeupDeviceType reason); 55 void ProcessLowCapacityWakeup(); 56 #endif 57 static int32_t SetWakeupDoubleClickSensor(bool enable); 58 static void ChangeWakeupSourceConfig(bool updateEnable); 59 static void ChangePickupWakeupSourceConfig(bool updataEnable); 60 static void PickupConnectMotionConfig(bool databaseSwitchValue); 61 static void ChangeLidWakeupSourceConfig(bool updataEnable); GetStateMachine()62 std::shared_ptr<PowerStateMachine> GetStateMachine() 63 { 64 return stateMachine_; 65 } GetLastReason()66 WakeupDeviceType GetLastReason() const 67 { 68 return wakeupReason_; 69 } 70 bool CheckEventReciveTime(WakeupDeviceType wakeupType); 71 #ifdef POWER_MANAGER_ENABLE_EXTERNAL_SCREEN_MANAGEMENT 72 void PowerOnInternalScreen(WakeupDeviceType type); 73 void PowerOnAllScreens(WakeupDeviceType type); 74 #endif 75 76 private: 77 class SleepGuard final { 78 public: 79 explicit SleepGuard(const sptr<PowerMgrService>& pms); 80 ~SleepGuard(); 81 SleepGuard(const SleepGuard&) = delete; 82 SleepGuard(SleepGuard&&) = delete; 83 SleepGuard& operator=(const SleepGuard&) = delete; 84 SleepGuard& operator=(SleepGuard&&) = delete; 85 86 private: 87 sptr<IRemoteObject> token_; 88 sptr<PowerMgrService> pms_; 89 }; 90 91 #ifdef POWER_MANAGER_ENABLE_EXTERNAL_SCREEN_MANAGEMENT 92 bool IsPowerOnInernalScreenOnlyScene(WakeupDeviceType reason) const; 93 void ProcessPowerOnInternalScreenOnly(const sptr<PowerMgrService>& pms, WakeupDeviceType reason); 94 #endif 95 bool NeedToSkipCurrentWakeup(const sptr<PowerMgrService>& pms, WakeupDeviceType reason) const; 96 void HandleWakeup(const sptr<PowerMgrService>& pms, WakeupDeviceType reason); 97 void ControlListener(WakeupDeviceType reason); 98 99 std::vector<WakeupSource> sourceList_; 100 std::map<WakeupDeviceType, std::shared_ptr<WakeupMonitor>> monitorMap_; 101 std::map<WakeupDeviceType, int64_t> eventHandleMap_; 102 std::shared_ptr<PowerStateMachine> stateMachine_; 103 WakeupDeviceType wakeupReason_ {0}; 104 std::mutex mutex_; 105 std::mutex monitorMutex_; 106 std::mutex eventHandleMutex_; 107 static std::mutex sourceUpdateMutex_; 108 int32_t monitorId_ {-1}; 109 }; 110 111 #ifdef HAS_MULTIMODALINPUT_INPUT_PART 112 class InputCallback : public IInputEventConsumer { 113 public: 114 virtual void OnInputEvent(std::shared_ptr<KeyEvent> keyEvent) const; 115 virtual void OnInputEvent(std::shared_ptr<PointerEvent> pointerEvent) const; 116 virtual void OnInputEvent(std::shared_ptr<AxisEvent> axisEvent) const; 117 bool NonWindowEvent(const std::shared_ptr<PointerEvent>& pointerEvent) const; 118 bool TouchEventAfterScreenOn(std::shared_ptr<PointerEvent> pointerEvent, PowerState state) const; 119 120 private: 121 bool isRemoteEvent(std::shared_ptr<InputEvent> event) const; 122 bool isKeyboardKeycode(int32_t keyCode) const; 123 }; 124 #endif 125 126 class WakeupMonitor { 127 public: 128 static std::shared_ptr<WakeupMonitor> CreateMonitor(WakeupSource& source); 129 static constexpr int32_t POWER_KEY_PRESS_DELAY_MS = 10000; 130 131 virtual ~WakeupMonitor() = default; 132 virtual bool Init() = 0; 133 virtual void Cancel() = 0; HandleEvent(uint32_t eventId)134 virtual void HandleEvent(uint32_t eventId) 135 { 136 // do nothing in base class 137 } 138 GetReason()139 WakeupDeviceType GetReason() const 140 { 141 return reason_; 142 } 143 RegisterListener(WakeupListener listener)144 void RegisterListener(WakeupListener listener) 145 { 146 listener_ = listener; 147 } 148 Notify()149 void Notify() 150 { 151 listener_(reason_); 152 } 153 154 protected: WakeupMonitor(WakeupSource & source)155 explicit WakeupMonitor(WakeupSource& source) 156 { 157 reason_ = source.GetReason(); 158 } 159 160 WakeupDeviceType reason_; 161 WakeupListener listener_; 162 }; 163 164 class PowerkeyWakeupMonitor : public WakeupMonitor, public std::enable_shared_from_this<PowerkeyWakeupMonitor> { 165 public: PowerkeyWakeupMonitor(WakeupSource & source)166 explicit PowerkeyWakeupMonitor(WakeupSource& source) : WakeupMonitor(source) {} 167 ~PowerkeyWakeupMonitor() override = default; 168 bool Init() override; 169 void Cancel() override; 170 171 private: 172 int32_t powerkeyShortPressId_ {-1}; 173 void ReceivePowerkeyCallback(std::shared_ptr<OHOS::MMI::KeyEvent> keyEvent); 174 }; 175 176 class KeyboardWakeupMonitor : public WakeupMonitor { 177 public: KeyboardWakeupMonitor(WakeupSource & source)178 explicit KeyboardWakeupMonitor(WakeupSource& source) : WakeupMonitor(source) {} 179 ~KeyboardWakeupMonitor() override = default; 180 bool Init() override; 181 void Cancel() override; 182 }; 183 184 class MousekeyWakeupMonitor : public WakeupMonitor { 185 public: MousekeyWakeupMonitor(WakeupSource & source)186 explicit MousekeyWakeupMonitor(WakeupSource& source) : WakeupMonitor(source) {} 187 ~MousekeyWakeupMonitor() override = default; 188 bool Init() override; 189 void Cancel() override; 190 }; 191 192 class TouchpadWakeupMonitor : public WakeupMonitor { 193 public: TouchpadWakeupMonitor(WakeupSource & source)194 explicit TouchpadWakeupMonitor(WakeupSource& source) : WakeupMonitor(source) {} 195 ~TouchpadWakeupMonitor() override = default; 196 bool Init() override; 197 void Cancel() override; 198 }; 199 200 class PenWakeupMonitor : public WakeupMonitor { 201 public: PenWakeupMonitor(WakeupSource & source)202 explicit PenWakeupMonitor(WakeupSource& source) : WakeupMonitor(source) {} 203 ~PenWakeupMonitor() override = default; 204 bool Init() override; 205 void Cancel() override; 206 }; 207 208 class SingleClickWakeupMonitor : public WakeupMonitor { 209 public: SingleClickWakeupMonitor(WakeupSource & source)210 explicit SingleClickWakeupMonitor(WakeupSource& source) : WakeupMonitor(source) {} 211 ~SingleClickWakeupMonitor() override = default; 212 bool Init() override; 213 void Cancel() override; 214 }; 215 216 class DoubleClickWakeupMonitor : public WakeupMonitor { 217 public: DoubleClickWakeupMonitor(WakeupSource & source)218 explicit DoubleClickWakeupMonitor(WakeupSource& source) : WakeupMonitor(source) {} 219 ~DoubleClickWakeupMonitor() override = default; 220 bool Init() override; 221 void Cancel() override; 222 }; 223 224 class LidWakeupMonitor : public WakeupMonitor { 225 public: LidWakeupMonitor(WakeupSource & source)226 explicit LidWakeupMonitor(WakeupSource& source) : WakeupMonitor(source) {} 227 ~LidWakeupMonitor() override = default; 228 bool Init() override; 229 void Cancel() override; 230 }; 231 232 class SwitchWakeupMonitor : public WakeupMonitor { 233 public: SwitchWakeupMonitor(WakeupSource & source)234 explicit SwitchWakeupMonitor(WakeupSource& source) : WakeupMonitor(source) {} 235 ~SwitchWakeupMonitor() override = default; 236 bool Init() override; 237 void Cancel() override; 238 }; 239 240 class PickupWakeupMonitor : public WakeupMonitor { 241 public: PickupWakeupMonitor(WakeupSource & source)242 explicit PickupWakeupMonitor(WakeupSource& source) : WakeupMonitor(source) {} 243 ~PickupWakeupMonitor() override = default; 244 bool Init() override; 245 void Cancel() override; 246 }; 247 248 class TPTouchWakeupMonitor : public WakeupMonitor { 249 public: TPTouchWakeupMonitor(WakeupSource & source)250 explicit TPTouchWakeupMonitor(WakeupSource& source) : WakeupMonitor(source) {} 251 ~TPTouchWakeupMonitor() override = default; 252 bool Init() override; 253 void Cancel() override; 254 }; 255 256 } // namespace PowerMgr 257 } // namespace OHOS 258 259 #endif