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