1 /*
2 * Copyright (c) 2025 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 #include "suspend_takeover_callback_holder.h"
16 #include "power_common.h"
17
18 namespace OHOS {
19 namespace PowerMgr {
TakeOverSuspendCallbackHolder()20 TakeOverSuspendCallbackHolder::TakeOverSuspendCallbackHolder() {}
21 TakeOverSuspendCallbackHolder::~TakeOverSuspendCallbackHolder() = default;
22
AddCallback(const sptr<ITakeOverSuspendCallback> & callback,TakeOverSuspendPriority priority)23 void TakeOverSuspendCallbackHolder::AddCallback(
24 const sptr<ITakeOverSuspendCallback>& callback, TakeOverSuspendPriority priority)
25 {
26 std::lock_guard<std::mutex> lock(mutex_);
27 switch (priority) {
28 case TakeOverSuspendPriority::LOW: {
29 auto iter = lowPriorityCallbacks_.insert(callback);
30 break;
31 }
32 case TakeOverSuspendPriority::DEFAULT: {
33 auto iter = defaultPriorityCallbacks_.insert(callback);
34 break;
35 }
36 case TakeOverSuspendPriority::HIGH: {
37 auto iter = highPriorityCallbacks_.insert(callback);
38 break;
39 }
40 default:
41 break;
42 }
43 AddCallbackPidUid(callback);
44 }
45
AddCallbackPidUid(const sptr<ITakeOverSuspendCallback> & callback)46 void TakeOverSuspendCallbackHolder::AddCallbackPidUid(const sptr<ITakeOverSuspendCallback>& callback)
47 {
48 pid_t pid = IPCSkeleton::GetCallingPid();
49 auto uid = IPCSkeleton::GetCallingUid();
50 cachedRegister_.emplace(callback, std::make_pair(pid, uid));
51 }
52
53 using CallbackContainer = TakeOverSuspendCallbackHolder::TakeoverSuspendCallbackContainerType;
54
GetHighPriorityCallbacks()55 CallbackContainer TakeOverSuspendCallbackHolder::GetHighPriorityCallbacks()
56 {
57 std::lock_guard<std::mutex> lock(mutex_);
58 return highPriorityCallbacks_;
59 }
60
GetDefaultPriorityCallbacks()61 CallbackContainer TakeOverSuspendCallbackHolder::GetDefaultPriorityCallbacks()
62 {
63 std::lock_guard<std::mutex> lock(mutex_);
64 return defaultPriorityCallbacks_;
65 }
66
GetLowPriorityCallbacks()67 CallbackContainer TakeOverSuspendCallbackHolder::GetLowPriorityCallbacks()
68 {
69 std::lock_guard<std::mutex> lock(mutex_);
70 return lowPriorityCallbacks_;
71 }
72
RemoveCallback(const sptr<ITakeOverSuspendCallback> & callback)73 void TakeOverSuspendCallbackHolder::RemoveCallback(const sptr<ITakeOverSuspendCallback>& callback)
74 {
75 std::lock_guard<std::mutex> lock(mutex_);
76 RemoveCallback(lowPriorityCallbacks_, callback);
77 RemoveCallback(defaultPriorityCallbacks_, callback);
78 RemoveCallback(highPriorityCallbacks_, callback);
79 RemoveCallbackPidUid(callback);
80 }
81
RemoveCallback(TakeOverSuspendCallbackHolder::TakeoverSuspendCallbackContainerType & callbacks,const sptr<ITakeOverSuspendCallback> & callback)82 void TakeOverSuspendCallbackHolder::RemoveCallback(
83 TakeOverSuspendCallbackHolder::TakeoverSuspendCallbackContainerType& callbacks,
84 const sptr<ITakeOverSuspendCallback>& callback)
85 {
86 auto iter = callbacks.find(callback);
87 if (iter == callbacks.end()) {
88 POWER_HILOGE(FEATURE_SUSPEND, "Cannot find the takeover suspend callback");
89 return;
90 }
91 callbacks.erase(iter);
92 }
93
RemoveCallbackPidUid(const sptr<ITakeOverSuspendCallback> & callback)94 void TakeOverSuspendCallbackHolder::RemoveCallbackPidUid(const sptr<ITakeOverSuspendCallback>& callback)
95 {
96 auto iter = cachedRegister_.find(callback);
97 if (iter != cachedRegister_.end()) {
98 cachedRegister_.erase(iter);
99 }
100 }
101
FindCallbackPidUid(const sptr<ITakeOverSuspendCallback> & callback)102 std::pair<int32_t, int32_t> TakeOverSuspendCallbackHolder::FindCallbackPidUid(
103 const sptr<ITakeOverSuspendCallback>& callback)
104 {
105 std::lock_guard<std::mutex> lock(mutex_);
106 auto iter = cachedRegister_.find(callback);
107 return (iter != cachedRegister_.end()) ? iter->second : std::make_pair(0, 0);
108 }
109 } // namespace PowerMgr
110 } // namespace OHOS