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_ACE_FRAMEWORKS_CORE_ANIMATION_STATUS_LISTENER_H
17 #define FOUNDATION_ACE_FRAMEWORKS_CORE_ANIMATION_STATUS_LISTENER_H
18 
19 #include <unordered_map>
20 
21 #include "base/log/log.h"
22 #include "base/utils/event_callback.h"
23 
24 namespace OHOS::Ace {
25 
26 class StatusListenable {
27 public:
28     using StatusCallback = EventCallback<void()>;
29 
30     StatusListenable() = default;
31     virtual ~StatusListenable() = default;
32 
AddStartListener(const StatusCallback & callback)33     void AddStartListener(const StatusCallback& callback)
34     {
35         startCallbacks_.emplace(callback.GetId(), callback);
36     }
37 
AddStopListener(const StatusCallback & callback)38     void AddStopListener(const StatusCallback& callback)
39     {
40         stopCallbacks_.emplace(callback.GetId(), callback);
41     }
42 
AddRepeatListener(const StatusCallback & callback)43     void AddRepeatListener(const StatusCallback& callback)
44     {
45         repeatCallbacks_.emplace(callback.GetId(), callback);
46     }
47 
AddPauseListener(const StatusCallback & callback)48     void AddPauseListener(const StatusCallback& callback)
49     {
50         pauseCallbacks_.emplace(callback.GetId(), callback);
51     }
52 
AddResumeListener(const StatusCallback & callback)53     void AddResumeListener(const StatusCallback& callback)
54     {
55         resumeCallbacks_.emplace(callback.GetId(), callback);
56     }
57 
AddIdleListener(const StatusCallback & callback)58     void AddIdleListener(const StatusCallback& callback)
59     {
60         idleCallbacks_.emplace(callback.GetId(), callback);
61     }
62 
AddPrepareListener(const StatusCallback & callback)63     void AddPrepareListener(const StatusCallback& callback)
64     {
65         prepareCallbacks_.emplace(callback.GetId(), callback);
66     }
67 
68     template<class F>
AddStartListener(const F & funcObject)69     StatusCallback::IdType AddStartListener(const F& funcObject)
70     {
71         StatusCallback callback(funcObject);
72         AddStartListener(callback);
73         return callback.GetId();
74     }
75 
76     template<class F>
AddStopListener(const F & funcObject)77     StatusCallback::IdType AddStopListener(const F& funcObject)
78     {
79         StatusCallback callback(funcObject);
80         AddStopListener(callback);
81         return callback.GetId();
82     }
83 
84     template<class F>
AddRepeatListener(const F & funcObject)85     StatusCallback::IdType AddRepeatListener(const F& funcObject)
86     {
87         StatusCallback callback(funcObject);
88         AddRepeatListener(callback);
89         return callback.GetId();
90     }
91 
92     template<class F>
AddPauseListener(const F & funcObject)93     StatusCallback::IdType AddPauseListener(const F& funcObject)
94     {
95         StatusCallback callback(funcObject);
96         AddPauseListener(callback);
97         return callback.GetId();
98     }
99 
100     template<class F>
AddResumeListener(const F & funcObject)101     StatusCallback::IdType AddResumeListener(const F& funcObject)
102     {
103         StatusCallback callback(funcObject);
104         AddResumeListener(callback);
105         return callback.GetId();
106     }
107 
108     template<class F>
AddIdleListener(const F & funcObject)109     StatusCallback::IdType AddIdleListener(const F& funcObject)
110     {
111         StatusCallback callback(funcObject);
112         AddIdleListener(callback);
113         return callback.GetId();
114     }
115 
116     template<class F>
AddPrepareListener(const F & funcObject)117     StatusCallback::IdType AddPrepareListener(const F& funcObject)
118     {
119         StatusCallback callback(funcObject);
120         AddPrepareListener(callback);
121         return callback.GetId();
122     }
123 
RemoveStartListener(const StatusCallback & callback)124     void RemoveStartListener(const StatusCallback& callback)
125     {
126         startCallbacks_.erase(callback.GetId());
127     }
128 
RemoveStartListener(typename StatusCallback::IdType id)129     void RemoveStartListener(typename StatusCallback::IdType id)
130     {
131         startCallbacks_.erase(id);
132     }
133 
RemoveStopListener(const StatusCallback & callback)134     void RemoveStopListener(const StatusCallback& callback)
135     {
136         stopCallbacks_.erase(callback.GetId());
137     }
138 
RemoveStopListener(typename StatusCallback::IdType id)139     void RemoveStopListener(typename StatusCallback::IdType id)
140     {
141         stopCallbacks_.erase(id);
142     }
143 
RemoveRepeatListener(const StatusCallback & callback)144     void RemoveRepeatListener(const StatusCallback& callback)
145     {
146         repeatCallbacks_.erase(callback.GetId());
147     }
148 
RemoveRepeatListener(typename StatusCallback::IdType id)149     void RemoveRepeatListener(typename StatusCallback::IdType id)
150     {
151         repeatCallbacks_.erase(id);
152     }
153 
RemovePauseListener(const StatusCallback & callback)154     void RemovePauseListener(const StatusCallback& callback)
155     {
156         pauseCallbacks_.erase(callback.GetId());
157     }
158 
RemovePauseListener(typename StatusCallback::IdType id)159     void RemovePauseListener(typename StatusCallback::IdType id)
160     {
161         pauseCallbacks_.erase(id);
162     }
163 
RemoveResumeListener(const StatusCallback & callback)164     void RemoveResumeListener(const StatusCallback& callback)
165     {
166         resumeCallbacks_.erase(callback.GetId());
167     }
168 
RemoveResumeListener(typename StatusCallback::IdType id)169     void RemoveResumeListener(typename StatusCallback::IdType id)
170     {
171         resumeCallbacks_.erase(id);
172     }
173 
RemoveIdleListener(const StatusCallback & callback)174     void RemoveIdleListener(const StatusCallback& callback)
175     {
176         idleCallbacks_.erase(callback.GetId());
177     }
178 
RemoveIdleListener(typename StatusCallback::IdType id)179     void RemoveIdleListener(typename StatusCallback::IdType id)
180     {
181         idleCallbacks_.erase(id);
182     }
183 
RemovePrepareListener(const StatusCallback & callback)184     void RemovePrepareListener(const StatusCallback& callback)
185     {
186         prepareCallbacks_.erase(callback.GetId());
187     }
188 
RemovePrepareListener(typename StatusCallback::IdType id)189     void RemovePrepareListener(typename StatusCallback::IdType id)
190     {
191         prepareCallbacks_.erase(id);
192     }
193 
ClearStartListeners()194     void ClearStartListeners()
195     {
196         startCallbacks_.clear();
197     }
198 
ClearStopListeners()199     void ClearStopListeners()
200     {
201         stopCallbacks_.clear();
202     }
203 
ClearRepeatListeners()204     void ClearRepeatListeners()
205     {
206         repeatCallbacks_.clear();
207     }
208 
ClearPauseListeners()209     void ClearPauseListeners()
210     {
211         pauseCallbacks_.clear();
212     }
213 
ClearResumeListeners()214     void ClearResumeListeners()
215     {
216         resumeCallbacks_.clear();
217     }
218 
ClearIdleListeners()219     void ClearIdleListeners()
220     {
221         idleCallbacks_.clear();
222     }
223 
ClearPrepareListeners()224     void ClearPrepareListeners()
225     {
226         prepareCallbacks_.clear();
227     }
228 
ClearAllListeners()229     void ClearAllListeners()
230     {
231         ClearStartListeners();
232         ClearStopListeners();
233         ClearRepeatListeners();
234         ClearPauseListeners();
235         ClearResumeListeners();
236         ClearIdleListeners();
237         ClearPrepareListeners();
238     }
239 
NotifyStartListener()240     void NotifyStartListener() const
241     {
242         for (auto&& [id, callback] : startCallbacks_) {
243             if (callback) {
244                 callback();
245             }
246         }
247     }
248 
NotifyStopListener()249     void NotifyStopListener() const
250     {
251         auto stopCallbacks = stopCallbacks_;
252         for (auto&& [id, callback] : stopCallbacks) {
253             if (callback) {
254                 callback();
255             }
256         }
257     }
258 
NotifyRepeatListener()259     void NotifyRepeatListener() const
260     {
261         auto repeatCallbacks = repeatCallbacks_;
262         for (auto&& [id, callback] : repeatCallbacks) {
263             if (callback) {
264                 callback();
265             }
266         }
267     }
268 
NotifyPauseListener()269     void NotifyPauseListener() const
270     {
271         for (auto&& [id, callback] : pauseCallbacks_) {
272             if (callback) {
273                 callback();
274             }
275         }
276     }
277 
NotifyResumeListener()278     void NotifyResumeListener() const
279     {
280         for (auto&& [id, callback] : resumeCallbacks_) {
281             if (callback) {
282                 callback();
283             }
284         }
285     }
286 
NotifyIdleListener()287     void NotifyIdleListener() const
288     {
289         auto idleCallbacks = idleCallbacks_;
290         for (auto&& [id, callback] : idleCallbacks) {
291             if (callback) {
292                 callback();
293             }
294         }
295     }
296 
NotifyPrepareListener()297     void NotifyPrepareListener() const
298     {
299         for (auto&& [id, callback] : prepareCallbacks_) {
300             if (callback) {
301                 callback();
302             }
303         }
304     }
305 
306 private:
307     std::unordered_map<StatusCallback::IdType, StatusCallback> startCallbacks_;
308     std::unordered_map<StatusCallback::IdType, StatusCallback> stopCallbacks_;
309     std::unordered_map<StatusCallback::IdType, StatusCallback> pauseCallbacks_;
310     std::unordered_map<StatusCallback::IdType, StatusCallback> resumeCallbacks_;
311     std::unordered_map<StatusCallback::IdType, StatusCallback> repeatCallbacks_;
312     std::unordered_map<StatusCallback::IdType, StatusCallback> idleCallbacks_;
313     std::unordered_map<StatusCallback::IdType, StatusCallback> prepareCallbacks_;
314 };
315 
316 } // namespace OHOS::Ace
317 
318 #endif // FOUNDATION_ACE_FRAMEWORKS_CORE_ANIMATION_STATUS_LISTENER_H
319