1 /* 2 * Copyright (c) 2021 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 FOUNDATION_APPEXECFWK_SERVICES_APPMGR_INCLUDE_PROCESS_OPTIMIZER_UBA_H 17 #define FOUNDATION_APPEXECFWK_SERVICES_APPMGR_INCLUDE_PROCESS_OPTIMIZER_UBA_H 18 19 #include <chrono> 20 #include <functional> 21 #include <string> 22 #include <vector> 23 #include <variant> 24 25 #include "process_optimizer.h" 26 27 namespace OHOS { 28 namespace AppExecFwk { 29 // UBA short for User Behavior Analysis 30 using UbaService = int; 31 using UbaServicePtr = std::shared_ptr<UbaService>; 32 33 class ProcessOptimizerUBA : public ProcessOptimizer { 34 public: 35 using AbilityToken = sptr<IRemoteObject>; 36 37 public: 38 ProcessOptimizerUBA(const UbaServicePtr &ubaService, const LmksClientPtr &lmksClient = nullptr, 39 int suspendTimeout = APP_SUSPEND_TIMEOUT_DEFAULT); 40 41 virtual ~ProcessOptimizerUBA(); 42 43 public: 44 // callbacks 45 std::function<AbilityPtr(AbilityToken)> GetAbilityByToken; 46 47 public: 48 void OnAppAdded(const AppPtr &app) override; 49 void OnAppRemoved(const AppPtr &app) override; 50 void OnAppStateChanged(const AppPtr &app, const ApplicationState oldState) override; 51 void OnAbilityStarted(const AbilityPtr &ability) override; 52 void OnAbilityConnected(const AbilityPtr &ability, const AbilityPtr &targetAbility) override; 53 void OnAbilityDisconnected(const AbilityPtr &ability, const AbilityPtr &targetAbility) override; 54 void OnAbilityStateChanged(const AbilityPtr &ability, const AbilityState oldState) override; 55 void OnAbilityVisibleChanged(const AbilityPtr &ability) override; 56 void OnAbilityPerceptibleChanged(const AbilityPtr &ability) override; 57 void OnAbilityRemoved(const AbilityPtr &ability) override; 58 void SetAppFreezingTime(int time) override; 59 void GetAppFreezingTime(int &time) override; 60 61 protected: 62 void OnLowMemoryAlert(const CgroupManager::LowMemoryLevel level) override; 63 64 private: 65 using Clock = std::chrono::system_clock; 66 using TimePoint = Clock::time_point; 67 68 class BaseAbilityAction { 69 public: 70 BaseAbilityAction(const AbilityPtr &ability); 71 ~BaseAbilityAction() = default; 72 73 TimePoint GetTime() const; 74 std::string GetTimeString() const; 75 const std::string &GetName() const; 76 77 private: 78 TimePoint time_; 79 std::string name_; 80 }; 81 82 class StartAbilityAction : public BaseAbilityAction { 83 public: 84 StartAbilityAction(const AbilityPtr &ability, const AbilityPtr &preAbility); 85 ~StartAbilityAction() = default; 86 87 const std::string &GetPreName() const; 88 89 private: 90 std::string preName_; 91 }; 92 93 class ConnectAbilityAction : public BaseAbilityAction { 94 public: 95 ConnectAbilityAction(const AbilityPtr &ability, const AbilityPtr &targetAbility); 96 ~ConnectAbilityAction() = default; 97 98 const std::string &GetTargetName() const; 99 100 private: 101 std::string targetName_; 102 }; 103 104 class DisconnectAbilityAction : public BaseAbilityAction { 105 public: 106 DisconnectAbilityAction(const AbilityPtr &ability, const AbilityPtr &targetAbility); 107 ~DisconnectAbilityAction() = default; 108 109 const std::string &GetTargetName() const; 110 111 private: 112 std::string targetName_; 113 }; 114 115 class ChangeAbilityStateAction : public BaseAbilityAction { 116 public: 117 ChangeAbilityStateAction(const AbilityPtr &ability, const AbilityState oldState); 118 ~ChangeAbilityStateAction() = default; 119 120 AbilityState GetOldState() const; 121 AbilityState GetNewState() const; 122 123 private: 124 AbilityState oldState_; 125 AbilityState newState_; 126 }; 127 128 class ChangeAbilityVisible : public BaseAbilityAction { 129 public: 130 ChangeAbilityVisible(const AbilityPtr &ability); 131 ~ChangeAbilityVisible() = default; 132 }; 133 134 class ChangeAbilityPerceptible : public BaseAbilityAction { 135 public: 136 ChangeAbilityPerceptible(const AbilityPtr &ability); 137 ~ChangeAbilityPerceptible() = default; 138 }; 139 140 class RemoveAbilityAction : public BaseAbilityAction { 141 public: 142 RemoveAbilityAction(const AbilityPtr &ability); 143 ~RemoveAbilityAction() = default; 144 }; 145 146 using AbilityAction = 147 std::variant<std::monostate, StartAbilityAction, ConnectAbilityAction, DisconnectAbilityAction, 148 ChangeAbilityStateAction, ChangeAbilityVisible, ChangeAbilityPerceptible, RemoveAbilityAction>; 149 150 template<typename T, typename... ARGS> RecordAbilityAction(ARGS...args)151 void RecordAbilityAction(ARGS... args) 152 { 153 abilityActionCache_[abilityActionCount_++].emplace<T>(args...); 154 if (abilityActionCount_ >= ABILITY_ACTION_CACHE_SIZE) { 155 CommitAbilityActions(); 156 } 157 } 158 159 void CommitAbilityActions(); 160 void CommitStartAbilityAction(const StartAbilityAction& action, size_t index); 161 void CommitConnectAbilityAction(const ConnectAbilityAction& action, size_t index); 162 void CommitDisconnectAbilityAction(const DisconnectAbilityAction& action, size_t index); 163 void CommitChangedAbilityStateAction(const ChangeAbilityStateAction& action, size_t index); 164 void CommitRemoveAbilityAction(const RemoveAbilityAction& action, size_t index); 165 UbaServicePtr GetUbaService(); 166 167 private: 168 UbaServicePtr ubaService_; 169 static constexpr size_t ABILITY_ACTION_CACHE_SIZE = 100; 170 AbilityAction abilityActionCache_[ABILITY_ACTION_CACHE_SIZE]; 171 size_t abilityActionCount_; 172 }; 173 } // namespace AppExecFwk 174 } // namespace OHOS 175 176 #endif // FOUNDATION_APPEXECFWK_SERVICES_APPMGR_INCLUDE_PROCESS_OPTIMIZER_UBA_H 177