1 /*
2 * Copyright (c) 2024 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 #include "thread_handler_manager.h"
17
18 #include <map>
19
20 #include "iam_check.h"
21 #include "iam_logger.h"
22 #include "iam_ptr.h"
23 #include "thread_handler_impl.h"
24 #include "thread_handler_singleton_impl.h"
25
26 #define LOG_TAG "USER_AUTH_SA"
27
28 namespace OHOS {
29 namespace UserIam {
30 namespace UserAuth {
GetInstance()31 ThreadHandlerManager &ThreadHandlerManager::GetInstance()
32 {
33 static ThreadHandlerManager manager;
34 return manager;
35 }
36
ThreadHandlerManager()37 ThreadHandlerManager::ThreadHandlerManager()
38 {
39 threadHandlerMap_.emplace(SINGLETON_THREAD_NAME,
40 Common::MakeShared<ThreadHandlerSingletonImpl>());
41 }
42
CreateThreadHandler(const std::string & name)43 bool ThreadHandlerManager::CreateThreadHandler(const std::string &name)
44 {
45 std::lock_guard<std::recursive_mutex> lock(mutex_);
46 if (threadHandlerMap_.find(name) != threadHandlerMap_.end()) {
47 IAM_LOGE("thread handler %{public}s already exist", name.c_str());
48 return false;
49 }
50 auto threadHandler = Common::MakeShared<ThreadHandlerImpl>(name, true);
51 IF_FALSE_LOGE_AND_RETURN_VAL(threadHandler != nullptr, false);
52 threadHandlerMap_.emplace(name, threadHandler);
53 IAM_LOGI("thread handler %{public}s create success", name.c_str());
54 return true;
55 }
56
DestroyThreadHandler(const std::string & name)57 void ThreadHandlerManager::DestroyThreadHandler(const std::string &name)
58 {
59 if (name == SINGLETON_THREAD_NAME) {
60 IAM_LOGE("thread handler %{public}s cannot detroy", name.c_str());
61 return;
62 }
63
64 std::lock_guard<std::recursive_mutex> lock(mutex_);
65
66 if (threadHandlerMap_.find(name) == threadHandlerMap_.end()) {
67 IAM_LOGE("thread handler %{public}s not exist", name.c_str());
68 return;
69 }
70
71 auto threadHandler = threadHandlerMap_[name];
72 IF_FALSE_LOGE_AND_RETURN(threadHandler != nullptr);
73 threadHandler->PostTask([name]() {
74 auto threadHandler = ThreadHandlerManager::GetInstance().GetThreadHandler(SINGLETON_THREAD_NAME);
75 IF_FALSE_LOGE_AND_RETURN(threadHandler != nullptr);
76 threadHandler->PostTask([name]() {
77 ThreadHandlerManager::GetInstance().DeleteThreadHandler(name);
78 IAM_LOGI("thread handler %{public}s deleted", name.c_str());
79 });
80 IAM_LOGI("thread handler %{public}s delete task posted", name.c_str());
81 });
82 threadHandler->Suspend();
83 IAM_LOGI("thread handler %{public}s destroy started", name.c_str());
84 }
85
DeleteThreadHandler(const std::string & name)86 void ThreadHandlerManager::DeleteThreadHandler(const std::string &name)
87 {
88 if (name == SINGLETON_THREAD_NAME) {
89 IAM_LOGE("thread handler %{public}s cannot delete", name.c_str());
90 return;
91 }
92
93 std::lock_guard<std::recursive_mutex> lock(mutex_);
94 if (threadHandlerMap_.find(name) == threadHandlerMap_.end()) {
95 IAM_LOGE("thread handler %{public}s not exist", name.c_str());
96 return;
97 }
98
99 threadHandlerMap_.erase(name);
100 IAM_LOGI("thread handler %{public}s is deleted", name.c_str());
101 }
102
GetThreadHandler(const std::string & name)103 std::shared_ptr<ThreadHandler> ThreadHandlerManager::GetThreadHandler(const std::string &name)
104 {
105 std::lock_guard<std::recursive_mutex> lock(mutex_);
106 if (threadHandlerMap_.find(name) == threadHandlerMap_.end()) {
107 IAM_LOGE("thread handler %{public}s not exist", name.c_str());
108 return nullptr;
109 }
110 return threadHandlerMap_[name];
111 }
112
PostTask(const std::string & name,const std::function<void ()> & task)113 void ThreadHandlerManager::PostTask(const std::string &name, const std::function<void()> &task)
114 {
115 std::lock_guard<std::recursive_mutex> lock(mutex_);
116 if (threadHandlerMap_.find(name) == threadHandlerMap_.end()) {
117 IAM_LOGE("thread handler %{public}s not exist", name.c_str());
118 return;
119 }
120 auto threadHandler = threadHandlerMap_[name];
121 IF_FALSE_LOGE_AND_RETURN(threadHandler != nullptr);
122 threadHandler->PostTask(task);
123 }
124
125 } // namespace UserAuth
126 } // namespace UserIam
127 } // namespace OHOS