1
2 /*
3 * Copyright (c) 2021-2023 Huawei Device Co., Ltd.
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include "event_queue_ffrt.h"
18
19 #include "ffrt_inner.h"
20 #include "deamon_io_waiter.h"
21 #include "epoll_io_waiter.h"
22 #include "event_logger.h"
23 #include "event_handler.h"
24 #include "none_io_waiter.h"
25
26 namespace OHOS {
27 namespace AppExecFwk {
28 namespace {
29
30 DEFINE_EH_HILOG_LABEL("EventQueueFFRT");
31 constexpr static uint32_t MAX_DUMP_INFO_LENGTH = 120000;
32 constexpr static uint32_t MILLI_TO_MICRO = 1000;
33 static constexpr int FFRT_REMOVE_SUCC = 0;
TransferInnerPriority(EventQueue::Priority priority)34 ffrt_inner_queue_priority_t TransferInnerPriority(EventQueue::Priority priority)
35 {
36 ffrt_inner_queue_priority_t innerPriority = ffrt_inner_queue_priority_t::ffrt_inner_queue_priority_low;
37 switch (priority) {
38 case EventQueue::Priority::VIP:
39 innerPriority = ffrt_inner_queue_priority_t::ffrt_inner_queue_priority_vip;
40 break;
41 case EventQueue::Priority::IMMEDIATE:
42 innerPriority = ffrt_inner_queue_priority_t::ffrt_inner_queue_priority_immediate;
43 break;
44 case EventQueue::Priority::HIGH:
45 innerPriority = ffrt_inner_queue_priority_t::ffrt_inner_queue_priority_high;
46 break;
47 case EventQueue::Priority::LOW:
48 innerPriority = ffrt_inner_queue_priority_t::ffrt_inner_queue_priority_low;
49 break;
50 case EventQueue::Priority::IDLE:
51 innerPriority = ffrt_inner_queue_priority_t::ffrt_inner_queue_priority_idle;
52 break;
53 default:
54 break;
55 }
56 return innerPriority;
57 }
58
TransferQueuePtr(std::shared_ptr<ffrt::queue> queue)59 inline ffrt_queue_t* TransferQueuePtr(std::shared_ptr<ffrt::queue> queue)
60 {
61 if (queue) {
62 return reinterpret_cast<ffrt_queue_t*>(queue.get());
63 }
64 return nullptr;
65 }
66
67
68 } // unnamed namespace
69
EventQueueFFRT()70 EventQueueFFRT::EventQueueFFRT() : EventQueue()
71 {
72 // Destructed queue in the ffrt task needs to be switched to asynchronous to avoid parsing deadlocks
73 ffrtQueue_ = std::shared_ptr<ffrt::queue>(new ffrt::queue(static_cast<ffrt::queue_type>(
74 ffrt_inner_queue_type_t::ffrt_queue_eventhandler_adapter), "EventHandler_QUEUE"), [](ffrt::queue* ptr) {
75 if (ffrt_this_task_get_id()) {
76 ffrt::submit([ptr]() { delete ptr; });
77 } else {
78 delete ptr;
79 }
80 });
81 HILOGD("Event queue ffrt");
82 }
83
EventQueueFFRT(const std::shared_ptr<IoWaiter> & ioWaiter)84 EventQueueFFRT::EventQueueFFRT(const std::shared_ptr<IoWaiter> &ioWaiter): EventQueue(ioWaiter)
85 {
86 // Destructed queue in the ffrt task needs to be switched to asynchronous to avoid parsing deadlocks
87 ffrtQueue_ = std::shared_ptr<ffrt::queue>(new ffrt::queue(static_cast<ffrt::queue_type>(
88 ffrt_inner_queue_type_t::ffrt_queue_eventhandler_adapter), "EventHandler_QUEUE"), [](ffrt::queue* ptr) {
89 if (ffrt_this_task_get_id()) {
90 ffrt::submit([ptr]() { delete ptr; });
91 } else {
92 delete ptr;
93 }
94 });
95 HILOGD("Event queue ffrt");
96 }
97
~EventQueueFFRT()98 EventQueueFFRT::~EventQueueFFRT()
99 {
100 std::lock_guard<ffrt::mutex> lock(ffrtLock_);
101 usable_.store(false);
102 ioWaiter_ = nullptr;
103 EH_LOGD_LIMIT("EventQueueFFRT is unavailable hence");
104 }
105
Insert(InnerEvent::Pointer & event,Priority priority,EventInsertType insertType)106 bool EventQueueFFRT::Insert(InnerEvent::Pointer &event, Priority priority, EventInsertType insertType)
107 {
108 return InsertEvent(event, priority, false, insertType);
109 }
110
RemoveOrphanByHandlerId(const std::string & handlerId)111 void EventQueueFFRT::RemoveOrphanByHandlerId(const std::string& handlerId)
112 {
113 // taskname: handler Id | has task | inner event id | param | task name
114 std::string regular = handlerId + "\\|.*";
115 ffrt_queue_t* queue = TransferQueuePtr(ffrtQueue_);
116 if (queue == nullptr) {
117 HILOGW("Remove is unavailable.");
118 return;
119 }
120 ffrt_queue_cancel_by_name(*queue, regular.c_str());
121 std::lock_guard<ffrt::mutex> lock(ffrtLock_);
122 if (!usable_.load()) {
123 HILOGW("EventQueueFFRT is unavailable.");
124 return;
125 }
126 RemoveInvalidFileDescriptor();
127 }
128
129
RemoveAll()130 void EventQueueFFRT::RemoveAll()
131 {
132 HILOGD("RemoveAll");
133 std::lock_guard<ffrt::mutex> lock(ffrtLock_);
134 if (!usable_.load()) {
135 HILOGW("EventQueueFFRT is unavailable.");
136 return;
137 }
138 ffrt_queue_t* queue = TransferQueuePtr(ffrtQueue_);
139 if (queue == nullptr) {
140 HILOGW("RemoveAll is unavailable.");
141 return;
142 }
143 ffrt_queue_cancel_all(*queue);
144 }
145
Remove(const std::shared_ptr<EventHandler> & owner)146 void EventQueueFFRT::Remove(const std::shared_ptr<EventHandler> &owner)
147 {
148 HILOGD("Remove");
149 if (!owner) {
150 HILOGE("Invalid owner");
151 return;
152 }
153
154 std::lock_guard<ffrt::mutex> lock(ffrtLock_);
155 if (!usable_.load()) {
156 HILOGW("EventQueueFFRT is unavailable.");
157 return;
158 }
159
160 // taskname: handler Id | has task | inner event id | param | task name
161 std::string regular = owner->GetHandlerId() + "\\|.*";
162 ffrt_queue_t* queue = TransferQueuePtr(ffrtQueue_);
163 if (queue == nullptr) {
164 HILOGW("Remove is unavailable.");
165 return;
166 }
167 ffrt_queue_cancel_by_name(*queue, regular.c_str());
168 }
169
Remove(const std::shared_ptr<EventHandler> & owner,uint32_t innerEventId)170 void EventQueueFFRT::Remove(const std::shared_ptr<EventHandler> &owner, uint32_t innerEventId)
171 {
172 HILOGD("Remove");
173 if (!owner) {
174 HILOGE("Invalid owner");
175 return;
176 }
177
178 std::lock_guard<ffrt::mutex> lock(ffrtLock_);
179 if (!usable_.load()) {
180 HILOGW("EventQueueFFRT is unavailable.");
181 return;
182 }
183
184 // taskname: handler Id | has task | inner event id | param | task name
185 std::string regular = owner->GetHandlerId() + "\\|0\\|" + std::to_string(innerEventId) + "\\|.*";
186 ffrt_queue_t* queue = TransferQueuePtr(ffrtQueue_);
187 if (queue == nullptr) {
188 HILOGW("Remove is unavailable.");
189 return;
190 }
191 ffrt_queue_cancel_by_name(*queue, regular.c_str());
192 }
193
Remove(const std::shared_ptr<EventHandler> & owner,uint32_t innerEventId,int64_t param)194 void EventQueueFFRT::Remove(const std::shared_ptr<EventHandler> &owner, uint32_t innerEventId, int64_t param)
195 {
196 HILOGD("Remove");
197 if (!owner) {
198 HILOGE("Invalid owner");
199 return;
200 }
201
202 std::lock_guard<ffrt::mutex> lock(ffrtLock_);
203 if (!usable_.load()) {
204 HILOGW("EventQueueFFRT is unavailable.");
205 return;
206 }
207
208 // taskname: handler Id | has task | inner event id | param | task name
209 std::string regular = owner->GetHandlerId() + "\\|0\\|" + std::to_string(innerEventId) + "\\|" +
210 std::to_string(param) + "\\|.*";
211 ffrt_queue_t* queue = TransferQueuePtr(ffrtQueue_);
212 if (queue == nullptr) {
213 HILOGW("Remove is unavailable.");
214 return;
215 }
216 ffrt_queue_cancel_by_name(*queue, regular.c_str());
217 }
218
Remove(const std::shared_ptr<EventHandler> & owner,const std::string & name)219 bool EventQueueFFRT::Remove(const std::shared_ptr<EventHandler> &owner, const std::string &name)
220 {
221 HILOGD("Remove");
222 if (!owner) {
223 HILOGE("Invalid owner");
224 return false;
225 }
226
227 std::lock_guard<ffrt::mutex> lock(ffrtLock_);
228 if (!usable_.load()) {
229 HILOGW("EventQueueFFRT is unavailable.");
230 return false;
231 }
232
233 // taskname: handler Id | has task | inner event id | param | task name
234 std::string regular = owner->GetHandlerId() + "\\|1\\|" + ".*\\|" + name;
235 ffrt_queue_t* queue = TransferQueuePtr(ffrtQueue_);
236 if (queue == nullptr) {
237 HILOGW("Remove is unavailable.");
238 return false;
239 }
240 int ret = ffrt_queue_cancel_by_name(*queue, regular.c_str());
241 return ret == FFRT_REMOVE_SUCC ? true : false;
242 }
243
HasInnerEvent(const std::shared_ptr<EventHandler> & owner,uint32_t innerEventId)244 bool EventQueueFFRT::HasInnerEvent(const std::shared_ptr<EventHandler> &owner, uint32_t innerEventId)
245 {
246 if (!owner) {
247 HILOGE("Invalid owner");
248 return false;
249 }
250 std::lock_guard<ffrt::mutex> lock(ffrtLock_);
251 if (!usable_.load()) {
252 HILOGW("EventQueueFFRT is unavailable.");
253 return false;
254 }
255
256 // taskname: handler Id | has task | inner event id | param | task name
257 std::string regular = owner->GetHandlerId() + "\\|0\\|" + std::to_string(innerEventId) + "\\|.*";
258 ffrt_queue_t* queue = TransferQueuePtr(ffrtQueue_);
259 if (queue == nullptr) {
260 HILOGW("Remove is unavailable.");
261 return false;
262 }
263 return ffrt_queue_has_task(*queue, regular.c_str());
264 }
265
HasInnerEvent(const std::shared_ptr<EventHandler> & owner,int64_t param)266 bool EventQueueFFRT::HasInnerEvent(const std::shared_ptr<EventHandler> &owner, int64_t param)
267 {
268 if (!owner) {
269 HILOGE("Invalid owner");
270 return false;
271 }
272 std::lock_guard<ffrt::mutex> lock(ffrtLock_);
273 if (!usable_.load()) {
274 HILOGW("EventQueueFFRT is unavailable.");
275 return false;
276 }
277
278 // taskname: handler Id | has task | inner event id | param | task name
279 std::string regular = owner->GetHandlerId() + "\\|0\\|.*" + std::to_string(param) + "\\|.*";
280 ffrt_queue_t* queue = TransferQueuePtr(ffrtQueue_);
281 if (queue == nullptr) {
282 HILOGW("Remove is unavailable.");
283 return false;
284 }
285 return ffrt_queue_has_task(*queue, regular.c_str());
286 }
287
Dump(Dumper & dumper)288 void EventQueueFFRT::Dump(Dumper &dumper)
289 {
290 std::lock_guard<ffrt::mutex> lock(ffrtLock_);
291 if (!usable_.load()) {
292 HILOGW("EventQueue is unavailable.");
293 return;
294 }
295
296 std::unique_ptr<char[]> chars = std::make_unique<char[]>(MAX_DUMP_INFO_LENGTH);
297 if (chars == nullptr) {
298 return;
299 }
300 ffrt_queue_t* queue = TransferQueuePtr(ffrtQueue_);
301 if (queue == nullptr) {
302 HILOGW("Dump is unavailable.");
303 return;
304 }
305 int ret = ffrt_queue_dump(*queue, dumper.GetTag().c_str(), chars.get(), MAX_DUMP_INFO_LENGTH, true);
306 if (ret > 0) {
307 dumper.Dump(chars.get());
308 }
309 }
310
DumpQueueInfo(std::string & queueInfo)311 void EventQueueFFRT::DumpQueueInfo(std::string& queueInfo)
312 {
313 std::lock_guard<ffrt::mutex> lock(ffrtLock_);
314 if (!usable_.load()) {
315 HILOGW("EventQueue is unavailable.");
316 return;
317 }
318
319 std::unique_ptr<char[]> chars = std::make_unique<char[]>(MAX_DUMP_INFO_LENGTH);
320 if (chars == nullptr) {
321 return;
322 }
323 ffrt_queue_t* queue = TransferQueuePtr(ffrtQueue_);
324 if (queue == nullptr) {
325 HILOGW("DumpQueueInfo is unavailable.");
326 return;
327 }
328 int ret = ffrt_queue_dump(*queue, "", chars.get(), MAX_DUMP_INFO_LENGTH, false);
329 if (ret > 0) {
330 queueInfo.append(chars.get());
331 }
332 }
333
IsIdle()334 bool EventQueueFFRT::IsIdle()
335 {
336 std::lock_guard<ffrt::mutex> lock(ffrtLock_);
337 if (!usable_.load()) {
338 HILOGW("EventQueue is unavailable.");
339 return false;
340 }
341
342 ffrt_queue_t* queue = TransferQueuePtr(ffrtQueue_);
343 if (queue == nullptr) {
344 HILOGW("IsIdle is unavailable.");
345 return false;
346 }
347 return ffrt_queue_is_idle(*queue);
348 }
349
IsQueueEmpty()350 bool EventQueueFFRT::IsQueueEmpty()
351 {
352 std::lock_guard<ffrt::mutex> lock(ffrtLock_);
353 if (!usable_.load()) {
354 HILOGW("EventQueue is unavailable.");
355 return false;
356 }
357
358 ffrt_queue_t* queue = TransferQueuePtr(ffrtQueue_);
359 if (queue == nullptr) {
360 HILOGW("IsIdle is unavailable.");
361 return false;
362 }
363 uint32_t queueNum = static_cast<uint32_t>(Priority::IDLE);
364 for (uint32_t i = 0; i < queueNum; i++) {
365 Priority priority = static_cast<Priority>(i);
366 ffrt_inner_queue_priority_t innerPriority = TransferInnerPriority(priority);
367 int size = ffrt_queue_size_dump(*queue, innerPriority);
368 if (size > 0) {
369 return false;
370 }
371 }
372 return true;
373 }
374
DumpCurrentQueueSize()375 std::string EventQueueFFRT::DumpCurrentQueueSize()
376 {
377 ffrt_queue_t* queue = TransferQueuePtr(ffrtQueue_);
378 if (queue == nullptr) {
379 HILOGW("DumpCurrentQueueSize is unavailable.");
380 return "";
381 }
382
383 std::string dumpInfo = "Current queue size: ";
384 std::string prioritys[] = {"VIP = ", ", IMMEDIATE = ", ", HIGH =", ", LOW = ", ", IDLE = "};
385 uint32_t queueNum = static_cast<uint32_t>(Priority::IDLE);
386 for (uint32_t i = 0; i < queueNum; i++) {
387 dumpInfo += prioritys[i];
388 Priority priority = static_cast<Priority>(i);
389 ffrt_inner_queue_priority_t innerPriority = TransferInnerPriority(priority);
390 dumpInfo += std::to_string(ffrt_queue_size_dump(*queue, innerPriority));
391 }
392 dumpInfo += " ; ";
393 return dumpInfo;
394 }
395
HasPreferEvent(int basePrio)396 bool EventQueueFFRT::HasPreferEvent(int basePrio)
397 {
398 return false;
399 }
400
QueryPendingTaskInfo(int32_t fileDescriptor)401 PendingTaskInfo EventQueueFFRT::QueryPendingTaskInfo(int32_t fileDescriptor)
402 {
403 HILOGW("FFRT queue is not support.");
404 return PendingTaskInfo();
405 }
406
CancelAndWait()407 void EventQueueFFRT::CancelAndWait()
408 {
409 HILOGD("FFRT CancelAndWait enter.");
410 if (!usable_.load()) {
411 HILOGW("CancelAndWait - EventQueue is unavailable.");
412 return;
413 }
414 ffrt_queue_t* queue = TransferQueuePtr(ffrtQueue_);
415 if (queue == nullptr) {
416 HILOGW("CancelAndWait - queue is unavailable.");
417 return;
418 }
419 ffrt_queue_cancel_and_wait(*queue);
420 }
421
GetFfrtQueue()422 void* EventQueueFFRT::GetFfrtQueue()
423 {
424 if (ffrtQueue_) {
425 return reinterpret_cast<void*>(ffrtQueue_.get());
426 }
427 return nullptr;
428 }
429
InsertSyncEvent(InnerEvent::Pointer & event,Priority priority,EventInsertType insertType)430 bool EventQueueFFRT::InsertSyncEvent(InnerEvent::Pointer &event, Priority priority, EventInsertType insertType)
431 {
432 return InsertEvent(event, priority, true, insertType);
433 }
434
InsertEvent(InnerEvent::Pointer & event,Priority priority,bool syncWait,EventInsertType insertType)435 bool EventQueueFFRT::InsertEvent(InnerEvent::Pointer &event, Priority priority, bool syncWait,
436 EventInsertType insertType)
437 {
438 if (!event) {
439 HILOGE("Could not insert an invalid event");
440 return false;
441 }
442 std::unique_lock<ffrt::mutex> lock(ffrtLock_);
443 if (!usable_.load()) {
444 HILOGW("EventQueueFFRT is unavailable.");
445 return false;
446 }
447
448 // taskname: handler Id | has task | inner event id | param | task name
449 std::string taskName = event->GetOwnerId() + "|" + (event->HasTask() ? "1" : "0") + "|" +
450 std::to_string(event->GetInnerEventId()) + "|" + std::to_string(event->GetParam()) +
451 "|" + event->GetTaskName();
452 HILOGD("Submit task %{public}s, %{public}d, %{public}d, %{public}d.", taskName.c_str(), priority,
453 insertType, syncWait);
454 if (insertType == EventInsertType::AT_FRONT) {
455 return SubmitEventAtFront(event, priority, syncWait, taskName, lock);
456 } else {
457 return SubmitEventAtEnd(event, priority, syncWait, taskName, lock);
458 }
459 }
460
461 // helper for move unique_ptr from lambda object to std::function object
462 template<class F>
MakeCopyableFunction(F && f)463 auto MakeCopyableFunction(F&& f)
464 {
465 using FType = std::decay_t<F>;
466 auto wrapper = std::make_shared<FType>(std::forward<F>(f));
467 return [wrapper]() { (*wrapper)(); };
468 }
469
SubmitEventAtEnd(InnerEvent::Pointer & event,Priority priority,bool syncWait,const std::string & taskName,std::unique_lock<ffrt::mutex> & lock)470 bool EventQueueFFRT::SubmitEventAtEnd(InnerEvent::Pointer &event, Priority priority, bool syncWait,
471 const std::string &taskName, std::unique_lock<ffrt::mutex> &lock)
472 {
473 uint64_t time = event->GetDelayTime();
474 ffrt_queue_priority_t queuePriority = static_cast<ffrt_queue_priority_t>(TransferInnerPriority(priority));
475 std::function<void()> task = MakeCopyableFunction([ffrtEvent = std::move(event)]() {
476 auto handler = new (std::nothrow) std::shared_ptr<EventHandler>(ffrtEvent->GetOwner());
477 if (handler && (*handler)) {
478 ffrt_queue_t* queue = reinterpret_cast<ffrt_queue_t*>(
479 (*handler)->GetEventRunner()->GetEventQueue()->GetFfrtQueue());
480 if (queue != nullptr) {
481 ffrt_queue_set_eventhandler(*queue, (void*)handler);
482 }
483 (*handler)->DistributeEvent(ffrtEvent);
484 if (queue != nullptr) {
485 ffrt_queue_set_eventhandler(*queue, nullptr);
486 }
487 }
488 delete handler;
489 });
490
491 if (syncWait) {
492 ffrt::task_handle handle = ffrtQueue_->submit_h(task, ffrt::task_attr().name(taskName.c_str())
493 .delay(time * MILLI_TO_MICRO).priority(queuePriority));
494 lock.unlock();
495 ffrtQueue_->wait(handle);
496 } else {
497 ffrtQueue_->submit(task, ffrt::task_attr().name(taskName.c_str()).delay(time * MILLI_TO_MICRO).
498 priority(queuePriority));
499 }
500 return true;
501 }
502
SubmitEventAtFront(InnerEvent::Pointer & event,Priority priority,bool syncWait,const std::string & taskName,std::unique_lock<ffrt::mutex> & lock)503 bool EventQueueFFRT::SubmitEventAtFront(InnerEvent::Pointer &event, Priority priority, bool syncWait,
504 const std::string &taskName, std::unique_lock<ffrt::mutex> &lock)
505 {
506 uint64_t time = event->GetDelayTime();
507 ffrt_queue_priority_t queuePriority = static_cast<ffrt_queue_priority_t>(TransferInnerPriority(priority));
508 ffrt_task_attr_t attribute;
509 (void)ffrt_task_attr_init(&attribute);
510 ffrt_task_attr_set_name(&attribute, taskName.c_str());
511 ffrt_task_attr_set_delay(&attribute, time * MILLI_TO_MICRO);
512 ffrt_task_attr_set_queue_priority(&attribute, queuePriority);
513
514 std::function<void()> task = MakeCopyableFunction([ffrtEvent = std::move(event)]() {
515 auto handler = new (std::nothrow) std::shared_ptr<EventHandler>(ffrtEvent->GetOwner());
516 if (handler && (*handler)) {
517 ffrt_queue_t* queue = reinterpret_cast<ffrt_queue_t*>(
518 (*handler)->GetEventRunner()->GetEventQueue()->GetFfrtQueue());
519 if (queue != nullptr) {
520 ffrt_queue_set_eventhandler(*queue, (void*)handler);
521 }
522 (*handler)->DistributeEvent(ffrtEvent);
523 if (queue != nullptr) {
524 ffrt_queue_set_eventhandler(*queue, nullptr);
525 }
526 }
527 delete handler;
528 });
529
530 ffrt_queue_t* queue = TransferQueuePtr(ffrtQueue_);
531 if (queue == nullptr) {
532 HILOGW("SubmitEventAtFront is unavailable.");
533 return false;
534 }
535 ffrt_function_header_t* header = ffrt::create_function_wrapper((task));
536 if (syncWait) {
537 ffrt::task_handle handle = ffrt_queue_submit_head_h(*queue, header, &attribute);
538 lock.unlock();
539 ffrtQueue_->wait(handle);
540 } else {
541 ffrt_queue_submit_head(*queue, header, &attribute);
542 }
543 return true;
544 }
545
AddFileDescriptorListener(int32_t fileDescriptor,uint32_t events,const std::shared_ptr<FileDescriptorListener> & listener,const std::string & taskName,Priority priority)546 ErrCode EventQueueFFRT::AddFileDescriptorListener(int32_t fileDescriptor, uint32_t events,
547 const std::shared_ptr<FileDescriptorListener> &listener, const std::string &taskName,
548 Priority priority)
549 {
550 if ((fileDescriptor < 0) || ((events & FILE_DESCRIPTOR_EVENTS_MASK) == 0) || (!listener)) {
551 HILOGE("%{public}d, %{public}u, %{public}s: Invalid parameter",
552 fileDescriptor, events, listener ? "valid" : "null");
553 return EVENT_HANDLER_ERR_INVALID_PARAM;
554 }
555
556 std::lock_guard<ffrt::mutex> lock(ffrtLock_);
557 return AddFileDescriptorListenerBase(fileDescriptor, events, listener, taskName, priority);
558 }
559
RemoveFileDescriptorListener(const std::shared_ptr<EventHandler> & owner)560 void EventQueueFFRT::RemoveFileDescriptorListener(const std::shared_ptr<EventHandler> &owner)
561 {
562 HILOGD("enter");
563 if (!owner) {
564 HILOGE("Invalid owner");
565 return;
566 }
567
568 std::lock_guard<ffrt::mutex> lock(ffrtLock_);
569 RemoveListenerByOwner(owner);
570 }
571
RemoveFileDescriptorListener(int32_t fileDescriptor)572 void EventQueueFFRT::RemoveFileDescriptorListener(int32_t fileDescriptor)
573 {
574 HILOGD("enter");
575 if (fileDescriptor < 0) {
576 HILOGE("%{public}d: Invalid file descriptor", fileDescriptor);
577 return;
578 }
579
580 std::lock_guard<ffrt::mutex> lock(ffrtLock_);
581 RemoveListenerByFd(fileDescriptor);
582 }
583
GetQueueFirstEventHandleTime(int32_t priority)584 inline uint64_t EventQueueFFRT::GetQueueFirstEventHandleTime(int32_t priority)
585 {
586 return UINT64_MAX;
587 }
588
Prepare()589 void EventQueueFFRT::Prepare()
590 {
591 HILOGD("enter");
592 std::lock_guard<ffrt::mutex> lock(ffrtLock_);
593 PrepareBase();
594 }
595
Finish()596 void EventQueueFFRT::Finish()
597 {
598 HILOGD("enter");
599 std::lock_guard<ffrt::mutex> lock(ffrtLock_);
600 FinishBase();
601 }
602
SetUsable(bool usable)603 void EventQueueFFRT::SetUsable(bool usable)
604 {
605 usable_.store(usable);
606 }
607 } // namespace AppExecFwk
608 } // namespace OHOS
609