1 /*
2 * Copyright (c) 2021-2023 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_account_subscribe_manager.h"
17 #include <pthread.h>
18 #include <thread>
19 #include "account_log_wrapper.h"
20 #include "ios_account_event.h"
21 #include "os_account_subscribe_death_recipient.h"
22
23 namespace OHOS {
24 namespace AccountSA {
25 namespace {
26 const char THREAD_OS_ACCOUNT_EVENT[] = "osAccountEvent";
27 }
28
OsAccountSubscribeManager()29 OsAccountSubscribeManager::OsAccountSubscribeManager()
30 : subscribeDeathRecipient_(sptr<IRemoteObject::DeathRecipient>(
31 new (std::nothrow) OsAccountSubscribeDeathRecipient()))
32 {}
33
GetInstance()34 OsAccountSubscribeManager &OsAccountSubscribeManager::GetInstance()
35 {
36 static OsAccountSubscribeManager *instance = new (std::nothrow) OsAccountSubscribeManager();
37 return *instance;
38 }
39
SubscribeOsAccount(const std::shared_ptr<OsAccountSubscribeInfo> & subscribeInfoPtr,const sptr<IRemoteObject> & eventListener)40 ErrCode OsAccountSubscribeManager::SubscribeOsAccount(
41 const std::shared_ptr<OsAccountSubscribeInfo> &subscribeInfoPtr, const sptr<IRemoteObject> &eventListener)
42 {
43 if (subscribeInfoPtr == nullptr) {
44 ACCOUNT_LOGE("subscribeInfoPtr is nullptr");
45 return ERR_ACCOUNT_COMMON_NULL_PTR_ERROR;
46 }
47
48 if (eventListener == nullptr) {
49 ACCOUNT_LOGE("eventListener is nullptr");
50 return ERR_ACCOUNT_COMMON_NULL_PTR_ERROR;
51 }
52 auto subscribeRecordPtr = std::make_shared<OsSubscribeRecord>(subscribeInfoPtr, eventListener);
53 if (subscribeRecordPtr == nullptr) {
54 ACCOUNT_LOGE("subscribeRecordPtr is nullptr");
55 return ERR_ACCOUNT_COMMON_NULL_PTR_ERROR;
56 }
57 if (subscribeDeathRecipient_ != nullptr) {
58 eventListener->AddDeathRecipient(subscribeDeathRecipient_);
59 }
60 subscribeRecordPtr->subscribeInfoPtr_ = subscribeInfoPtr;
61 subscribeRecordPtr->eventListener_ = eventListener;
62 return InsertSubscribeRecord(subscribeRecordPtr);
63 }
64
UnsubscribeOsAccount(const sptr<IRemoteObject> & eventListener)65 ErrCode OsAccountSubscribeManager::UnsubscribeOsAccount(const sptr<IRemoteObject> &eventListener)
66 {
67 if (eventListener == nullptr) {
68 ACCOUNT_LOGE("eventListener is nullptr");
69 return ERR_ACCOUNT_COMMON_NULL_PTR_ERROR;
70 }
71
72 if (subscribeDeathRecipient_ != nullptr) {
73 eventListener->RemoveDeathRecipient(subscribeDeathRecipient_);
74 }
75
76 return RemoveSubscribeRecord(eventListener);
77 }
78
InsertSubscribeRecord(const OsSubscribeRecordPtr & subscribeRecordPtr)79 ErrCode OsAccountSubscribeManager::InsertSubscribeRecord(const OsSubscribeRecordPtr &subscribeRecordPtr)
80 {
81 if (subscribeRecordPtr == nullptr) {
82 ACCOUNT_LOGE("subscribeRecordPtr is nullptr");
83 return ERR_ACCOUNT_COMMON_NULL_PTR_ERROR;
84 }
85
86 std::lock_guard<std::mutex> lock(subscribeRecordMutex_);
87
88 subscribeRecords_.emplace_back(subscribeRecordPtr);
89
90 return ERR_OK;
91 }
92
RemoveSubscribeRecord(const sptr<IRemoteObject> & eventListener)93 ErrCode OsAccountSubscribeManager::RemoveSubscribeRecord(const sptr<IRemoteObject> &eventListener)
94 {
95 if (eventListener == nullptr) {
96 ACCOUNT_LOGE("eventListener is nullptr");
97 return ERR_ACCOUNT_COMMON_NULL_PTR_ERROR;
98 }
99
100 std::lock_guard<std::mutex> lock(subscribeRecordMutex_);
101
102 for (auto it = subscribeRecords_.begin(); it != subscribeRecords_.end(); ++it) {
103 if (eventListener == (*it)->eventListener_) {
104 (*it)->eventListener_ = nullptr;
105 subscribeRecords_.erase(it);
106 break;
107 }
108 }
109
110 return ERR_OK;
111 }
112
PublishActivatedOsAccount(const int id)113 ErrCode OsAccountSubscribeManager::PublishActivatedOsAccount(const int id)
114 {
115 uint32_t sendCnt = 0;
116 ErrCode ret = Publish(id, OS_ACCOUNT_SUBSCRIBE_TYPE::ACTIVED, sendCnt);
117 if (ret != ERR_OK) {
118 ACCOUNT_LOGE("PublishActivatedOsAccount failed! id %{public}d, ret %{public}d.", id, ret);
119 return ret;
120 }
121
122 ACCOUNT_LOGI("PublishActivatedOsAccount succeed! id %{public}d, sendCnt %{public}u.", id, sendCnt);
123 return ERR_OK;
124 }
125
OnAccountsChanged(const OsSubscribeRecordPtr & osSubscribeRecordPtr,const int id)126 bool OsAccountSubscribeManager::OnAccountsChanged(const OsSubscribeRecordPtr &osSubscribeRecordPtr, const int id)
127 {
128 auto osAccountEventProxy = iface_cast<IOsAccountEvent>(osSubscribeRecordPtr->eventListener_);
129 if (osAccountEventProxy == nullptr) {
130 ACCOUNT_LOGE("failed to get app account event proxy");
131 return false;
132 }
133 osAccountEventProxy->OnAccountsChanged(id);
134 return true;
135 }
136
PublishActivatingOsAccount(const int id)137 ErrCode OsAccountSubscribeManager::PublishActivatingOsAccount(const int id)
138 {
139 uint32_t sendCnt = 0;
140 ErrCode ret = Publish(id, OS_ACCOUNT_SUBSCRIBE_TYPE::ACTIVATING, sendCnt);
141 if (ret != ERR_OK) {
142 ACCOUNT_LOGE("PublishActivatingOsAccount failed! id %{public}d, ret %{public}d.", id, ret);
143 return ret;
144 }
145
146 ACCOUNT_LOGI("PublishActivatingOsAccount succeed! id %{public}d, sendCnt %{public}u.", id, sendCnt);
147 return ERR_OK;
148 }
149
Publish(const int id,OS_ACCOUNT_SUBSCRIBE_TYPE subscribeType,uint32_t & sendCnt)150 ErrCode OsAccountSubscribeManager::Publish(const int id, OS_ACCOUNT_SUBSCRIBE_TYPE subscribeType, uint32_t& sendCnt)
151 {
152 std::lock_guard<std::mutex> lock(subscribeRecordMutex_);
153 for (auto it = subscribeRecords_.begin(); it != subscribeRecords_.end(); ++it) {
154 if ((*it)->subscribeInfoPtr_ == nullptr) {
155 ACCOUNT_LOGE("subscribeInfoPtr_ is null, id %{public}d.", id);
156 continue;
157 }
158 OS_ACCOUNT_SUBSCRIBE_TYPE osAccountSubscribeType;
159 (*it)->subscribeInfoPtr_->GetOsAccountSubscribeType(osAccountSubscribeType);
160 if (osAccountSubscribeType == subscribeType) {
161 auto task = std::bind(&OsAccountSubscribeManager::OnAccountsChanged, this, (*it), id);
162 std::thread taskThread(task);
163 pthread_setname_np(taskThread.native_handle(), THREAD_OS_ACCOUNT_EVENT);
164 taskThread.detach();
165 ++sendCnt;
166 }
167 }
168 return ERR_OK;
169 }
170 } // namespace AccountSA
171 } // namespace OHOS
172