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
16 #include "os_accounts_manager.h"
17
18 #include <singleton.h>
19
20 #include "iservice_registry.h"
21 #include "os_account_manager.h"
22 #include "system_ability_definition.h"
23 #include "system_ability_status_change_stub.h"
24
25 #include "context_pool.h"
26 #include "iam_check.h"
27 #include "iam_common_defines.h"
28 #include "iam_logger.h"
29 #include "iam_ptr.h"
30 #include "ipc_common.h"
31 #include "resource_node_pool.h"
32 #include "resource_node_utils.h"
33 #include "system_ability_listener.h"
34 #include "template_cache_manager.h"
35 #include "thread_handler.h"
36 #include "user_idm_database.h"
37
38 #define LOG_TAG "USER_AUTH_SA"
39 namespace OHOS {
40 namespace UserIam {
41 namespace UserAuth {
42 namespace {
43 using OsAccountSubscriber = AccountSA::OsAccountSubscriber;
44 using OsAccountSubscribeInfo = AccountSA::OsAccountSubscribeInfo;
45 using OS_ACCOUNT_SUBSCRIBE_TYPE = AccountSA::OS_ACCOUNT_SUBSCRIBE_TYPE;
HandleAccountsChanged(const int id)46 void HandleAccountsChanged(const int id)
47 {
48 auto threadHandler = ThreadHandler::GetSingleThreadInstance();
49 IF_FALSE_LOGE_AND_RETURN(threadHandler != nullptr);
50 threadHandler->PostTask([id]() {
51 TemplateCacheManager::GetInstance().ProcessUserIdChange(id);
52 });
53 }
54
SyncOsAccountIdStatus()55 void SyncOsAccountIdStatus()
56 {
57 IAM_LOGI("start");
58 std::optional<int32_t> userIdOpt;
59 int32_t ret = IpcCommon::GetActiveUserId(userIdOpt);
60 if (ret != SUCCESS || !userIdOpt.has_value()) {
61 IAM_LOGE("get current user id fail");
62 return;
63 }
64 int32_t userId = userIdOpt.value();
65 if (userId == INVALID_USER_ID) {
66 IAM_LOGE("invalid user id");
67 return;
68 }
69 HandleAccountsChanged(userId);
70 }
71 }
72
73 class UserIamOsAccountSubscriber : public OsAccountSubscriber, public NoCopyable {
74 public:
75 explicit UserIamOsAccountSubscriber(const OsAccountSubscribeInfo &subscribeInfo);
76 ~UserIamOsAccountSubscriber() = default;
77
78 void OnAccountsChanged(const int &id) override;
79 };
80
81 class OsAccountsManagerImpl final : public OsAccountsManager, public Singleton<OsAccountsManagerImpl> {
82 public:
83 void StartSubscribe() override;
84 void OnOsAccountSaAdd() override;
85 void OnOsAccountSaRemove() override;
86
87 private:
88 sptr<SystemAbilityListener> accountSaStatusListener_ {nullptr};
89 std::shared_ptr<UserIamOsAccountSubscriber> subscriber_ {nullptr};
90 std::recursive_mutex mutex_;
91 };
92
UserIamOsAccountSubscriber(const OsAccountSubscribeInfo & subscribeInfo)93 UserIamOsAccountSubscriber::UserIamOsAccountSubscriber(const OsAccountSubscribeInfo &subscribeInfo)
94 : OsAccountSubscriber(subscribeInfo)
95 {
96 }
97
OnAccountsChanged(const int & id)98 void UserIamOsAccountSubscriber::OnAccountsChanged(const int &id)
99 {
100 IAM_LOGI("OnAccountsChanged %{public}d", id);
101 HandleAccountsChanged(id);
102 }
103
StartSubscribe()104 void OsAccountsManagerImpl::StartSubscribe()
105 {
106 IAM_LOGI("start");
107 std::lock_guard<std::recursive_mutex> lock(mutex_);
108 if (accountSaStatusListener_ != nullptr) {
109 return;
110 }
111 accountSaStatusListener_ = SystemAbilityListener::Subscribe(
112 "OsAccountService", SUBSYS_ACCOUNT_SYS_ABILITY_ID_BEGIN,
113 []() { OsAccountsManager::Instance().OnOsAccountSaAdd(); },
114 []() { OsAccountsManager::Instance().OnOsAccountSaRemove(); });
115 IF_FALSE_LOGE_AND_RETURN(accountSaStatusListener_ != nullptr);
116 }
117
OnOsAccountSaAdd()118 void OsAccountsManagerImpl::OnOsAccountSaAdd()
119 {
120 IAM_LOGI("start");
121 std::lock_guard<std::recursive_mutex> lock(mutex_);
122 if (subscriber_ != nullptr) {
123 return;
124 }
125 OsAccountSubscribeInfo subscribeInfo;
126 subscribeInfo.SetOsAccountSubscribeType(OS_ACCOUNT_SUBSCRIBE_TYPE::ACTIVATED);
127 auto subscriber = Common::MakeShared<UserIamOsAccountSubscriber>(subscribeInfo);
128 IF_FALSE_LOGE_AND_RETURN(subscriber != nullptr);
129
130 ErrCode errCode = AccountSA::OsAccountManager::SubscribeOsAccount(subscriber);
131 if (errCode != ERR_OK) {
132 IAM_LOGE("subscribe fail, errCode = %{public}d", errCode);
133 return;
134 }
135 IF_FALSE_LOGE_AND_RETURN(subscriber != nullptr);
136 subscriber_ = subscriber;
137 SyncOsAccountIdStatus();
138 }
139
OnOsAccountSaRemove()140 void OsAccountsManagerImpl::OnOsAccountSaRemove()
141 {
142 IAM_LOGI("start");
143 if (subscriber_ == nullptr) {
144 return;
145 }
146
147 ErrCode errCode = AccountSA::OsAccountManager::UnsubscribeOsAccount(subscriber_);
148 if (errCode != ERR_OK) {
149 IAM_LOGE("unsubscribe fail, errCode = %{public}d", errCode);
150 return;
151 }
152 subscriber_ = nullptr;
153 }
154
Instance()155 OsAccountsManager &OsAccountsManager::Instance()
156 {
157 return OsAccountsManagerImpl::GetInstance();
158 }
159 } // namespace UserAuth
160 } // namespace UserIam
161 } // namespace OHOS