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 72 private: 73 class SleepGuard final { 74 public: 75 explicit SleepGuard(const sptr<PowerMgrService>& pms); 76 ~SleepGuard(); 77 SleepGuard(const SleepGuard&) = delete; 78 SleepGuard(SleepGuard&&) = delete; 79 SleepGuard& operator=(const SleepGuard&) = delete; 80 SleepGuard& operator=(SleepGuard&&) = delete; 81 82 private: 83 sptr<IRemoteObject> token_; 84 sptr<PowerMgrService> pms_; 85 }; 86 87 void ControlListener(WakeupDeviceType reason); 88 std::vector<WakeupSource> sourceList_; 89 std::map<WakeupDeviceType, std::shared_ptr<WakeupMonitor>> monitorMap_; 90 std::map<WakeupDeviceType, int64_t> eventHandleMap_; 91 std::shared_ptr<PowerStateMachine> stateMachine_; 92 WakeupDeviceType wakeupReason_ {0}; 93 std::mutex mutex_; 94 std::mutex monitorMutex_; 95 std::mutex eventHandleMutex_; 96 static std::mutex sourceUpdateMutex_; 97 int32_t monitorId_ {-1}; 98 }; 99 100 #ifdef HAS_MULTIMODALINPUT_INPUT_PART 101 class InputCallback : public IInputEventConsumer { 102 public: 103 virtual void OnInputEvent(std::shared_ptr<KeyEvent> keyEvent) const; 104 virtual void OnInputEvent(std::shared_ptr<PointerEvent> pointerEvent) const; 105 virtual void OnInputEvent(std::shared_ptr<AxisEvent> axisEvent) const; 106 bool NonWindowEvent(const std::shared_ptr<PointerEvent>& pointerEvent) const; 107 108 private: 109 bool IsRemoteEvent(std::shared_ptr<InputEvent> event) const; 110 }; 111 #endif 112 113 class WakeupMonitor { 114 public: 115 static std::shared_ptr<WakeupMonitor> CreateMonitor(WakeupSource& source); 116 static constexpr int32_t POWER_KEY_PRESS_DELAY_MS = 10000; 117 118 virtual ~WakeupMonitor() = default; 119 virtual bool Init() = 0; 120 virtual void Cancel() = 0; HandleEvent(uint32_t eventId)121 virtual void HandleEvent(uint32_t eventId) 122 { 123 // do nothing in base class 124 } 125 GetReason()126 WakeupDeviceType GetReason() const 127 { 128 return reason_; 129 } 130 RegisterListener(WakeupListener listener)131 void RegisterListener(WakeupListener listener) 132 { 133 listener_ = listener; 134 } 135 Notify()136 void Notify() 137 { 138 listener_(reason_); 139 } 140 141 protected: WakeupMonitor(WakeupSource & source)142 explicit WakeupMonitor(WakeupSource& source) 143 { 144 reason_ = source.GetReason(); 145 } 146 147 WakeupDeviceType reason_; 148 WakeupListener listener_; 149 }; 150 151 class PowerkeyWakeupMonitor : public WakeupMonitor { 152 public: PowerkeyWakeupMonitor(WakeupSource & source)153 explicit PowerkeyWakeupMonitor(WakeupSource& source) : WakeupMonitor(source) {} 154 ~PowerkeyWakeupMonitor() override = default; 155 bool Init() override; 156 void Cancel() override; 157 158 private: 159 int32_t powerkeyShortPressId_ {-1}; 160 }; 161 162 class KeyboardWakeupMonitor : public WakeupMonitor { 163 public: KeyboardWakeupMonitor(WakeupSource & source)164 explicit KeyboardWakeupMonitor(WakeupSource& source) : WakeupMonitor(source) {} 165 ~KeyboardWakeupMonitor() override = default; 166 bool Init() override; 167 void Cancel() override; 168 }; 169 170 class MousekeyWakeupMonitor : public WakeupMonitor { 171 public: MousekeyWakeupMonitor(WakeupSource & source)172 explicit MousekeyWakeupMonitor(WakeupSource& source) : WakeupMonitor(source) {} 173 ~MousekeyWakeupMonitor() override = default; 174 bool Init() override; 175 void Cancel() override; 176 }; 177 178 class TouchpadWakeupMonitor : public WakeupMonitor { 179 public: TouchpadWakeupMonitor(WakeupSource & source)180 explicit TouchpadWakeupMonitor(WakeupSource& source) : WakeupMonitor(source) {} 181 ~TouchpadWakeupMonitor() override = default; 182 bool Init() override; 183 void Cancel() override; 184 }; 185 186 class PenWakeupMonitor : public WakeupMonitor { 187 public: PenWakeupMonitor(WakeupSource & source)188 explicit PenWakeupMonitor(WakeupSource& source) : WakeupMonitor(source) {} 189 ~PenWakeupMonitor() override = default; 190 bool Init() override; 191 void Cancel() override; 192 }; 193 194 class SingleClickWakeupMonitor : public WakeupMonitor { 195 public: SingleClickWakeupMonitor(WakeupSource & source)196 explicit SingleClickWakeupMonitor(WakeupSource& source) : WakeupMonitor(source) {} 197 ~SingleClickWakeupMonitor() override = default; 198 bool Init() override; 199 void Cancel() override; 200 }; 201 202 class DoubleClickWakeupMonitor : public WakeupMonitor { 203 public: DoubleClickWakeupMonitor(WakeupSource & source)204 explicit DoubleClickWakeupMonitor(WakeupSource& source) : WakeupMonitor(source) {} 205 ~DoubleClickWakeupMonitor() override = default; 206 bool Init() override; 207 void Cancel() override; 208 }; 209 210 class LidWakeupMonitor : public WakeupMonitor { 211 public: LidWakeupMonitor(WakeupSource & source)212 explicit LidWakeupMonitor(WakeupSource& source) : WakeupMonitor(source) {} 213 ~LidWakeupMonitor() override = default; 214 bool Init() override; 215 void Cancel() override; 216 }; 217 218 class SwitchWakeupMonitor : public WakeupMonitor { 219 public: SwitchWakeupMonitor(WakeupSource & source)220 explicit SwitchWakeupMonitor(WakeupSource& source) : WakeupMonitor(source) {} 221 ~SwitchWakeupMonitor() override = default; 222 bool Init() override; 223 void Cancel() override; 224 }; 225 226 class PickupWakeupMonitor : public WakeupMonitor { 227 public: PickupWakeupMonitor(WakeupSource & source)228 explicit PickupWakeupMonitor(WakeupSource& source) : WakeupMonitor(source) {} 229 ~PickupWakeupMonitor() override = default; 230 bool Init() override; 231 void Cancel() override; 232 }; 233 234 } // namespace PowerMgr 235 } // namespace OHOS 236 237 #endif