1 /*
2 * Copyright (c) 2022-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 <set>
17
18 #include "ipc_client_manager.h"
19
20 #include "device_manager_ipc_interface_code.h"
21 #include "device_manager_notify.h"
22 #include "device_manager_impl.h"
23 #include "dm_constants.h"
24 #include "dm_error_type.h"
25 #include "dm_log.h"
26 #include "dm_service_load.h"
27 #include "ipc_client_server_proxy.h"
28 #include "ipc_client_stub.h"
29 #include "ipc_register_listener_req.h"
30 #include "ipc_remote_broker.h"
31 #include "iremote_object.h"
32 #include "iservice_registry.h"
33 #include "system_ability_definition.h"
34 #include <unistd.h>
35
36 namespace OHOS {
37 namespace DistributedHardware {
OnRemoteDied(const wptr<IRemoteObject> & remote)38 void DmDeathRecipient::OnRemoteDied(const wptr<IRemoteObject> &remote)
39 {
40 LOGW("DmDeathRecipient : OnRemoteDied");
41 (void)remote;
42 }
43
ClientInit()44 int32_t IpcClientManager::ClientInit()
45 {
46 LOGI("Start");
47 if (dmInterface_ != nullptr) {
48 LOGI("DeviceManagerService Already Init");
49 return DM_OK;
50 }
51
52 auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
53 if (samgr == nullptr) {
54 LOGE("Get SystemAbilityManager Failed");
55 return ERR_DM_INIT_FAILED;
56 }
57
58 auto object = samgr->CheckSystemAbility(DISTRIBUTED_HARDWARE_DEVICEMANAGER_SA_ID);
59 if (object == nullptr) {
60 LOGE("Get DeviceManager SystemAbility Failed");
61 DmServiceLoad::GetInstance().LoadDMService();
62 return ERR_DM_INIT_FAILED;
63 }
64
65 if (dmRecipient_ == nullptr) {
66 dmRecipient_ = sptr<DmDeathRecipient>(new DmDeathRecipient());
67 }
68 if (!object->AddDeathRecipient(dmRecipient_)) {
69 LOGE("InitDeviceManagerService: AddDeathRecipient Failed");
70 }
71 dmInterface_ = iface_cast<IpcRemoteBroker>(object);
72 LOGI("Completed");
73 return DM_OK;
74 }
75
Init(const std::string & pkgName)76 int32_t IpcClientManager::Init(const std::string &pkgName)
77 {
78 if (pkgName.empty()) {
79 LOGE("Invalid parameter, pkgName is empty.");
80 return ERR_DM_INPUT_PARA_INVALID;
81 }
82 std::lock_guard<std::mutex> autoLock(lock_);
83 SubscribeDMSAChangeListener();
84 int32_t ret = ClientInit();
85 if (ret != DM_OK) {
86 LOGE("InitDeviceManager Failed with ret %{public}d", ret);
87 return ret;
88 }
89 CHECK_SIZE_RETURN(dmListener_, ERR_DM_FAILED);
90 sptr<IpcClientStub> listener = sptr<IpcClientStub>(new IpcClientStub());
91 std::shared_ptr<IpcRegisterListenerReq> req = std::make_shared<IpcRegisterListenerReq>();
92 std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
93 req->SetPkgName(pkgName);
94 req->SetListener(listener);
95 ret = dmInterface_->SendCmd(REGISTER_DEVICE_MANAGER_LISTENER, req, rsp);
96 if (ret != DM_OK) {
97 LOGE("InitDeviceManager: RegisterDeviceManagerListener Failed with ret %{public}d", ret);
98 return ret;
99 }
100 ret = rsp->GetErrCode();
101 if (ret != DM_OK) {
102 return ret;
103 }
104 dmListener_[pkgName] = listener;
105 LOGI("completed, pkgName: %{public}s", pkgName.c_str());
106 return DM_OK;
107 }
108
UnInit(const std::string & pkgName)109 int32_t IpcClientManager::UnInit(const std::string &pkgName)
110 {
111 if (pkgName.empty()) {
112 LOGE("Invalid parameter, pkgName is empty.");
113 return ERR_DM_INPUT_PARA_INVALID;
114 }
115 LOGI("UnInit in, pkgName %{public}s", pkgName.c_str());
116 std::lock_guard<std::mutex> autoLock(lock_);
117 if (dmInterface_ == nullptr) {
118 LOGE("DeviceManager not Init");
119 return ERR_DM_INIT_FAILED;
120 }
121
122 if (dmListener_.count(pkgName) > 0) {
123 std::shared_ptr<IpcReq> req = std::make_shared<IpcReq>();
124 std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
125 req->SetPkgName(pkgName);
126 int32_t ret = dmInterface_->SendCmd(UNREGISTER_DEVICE_MANAGER_LISTENER, req, rsp);
127 if (ret != DM_OK) {
128 LOGE("UnRegisterDeviceManagerListener Failed with ret %{public}d", ret);
129 return ret;
130 }
131 dmListener_.erase(pkgName);
132 }
133 if (dmListener_.empty()) {
134 if (dmRecipient_ != nullptr) {
135 dmInterface_->AsObject()->RemoveDeathRecipient(dmRecipient_);
136 dmRecipient_ = nullptr;
137 }
138 dmInterface_ = nullptr;
139 }
140 LOGI("completed, pkgName: %{public}s", pkgName.c_str());
141 return DM_OK;
142 }
143
SendRequest(int32_t cmdCode,std::shared_ptr<IpcReq> req,std::shared_ptr<IpcRsp> rsp)144 int32_t IpcClientManager::SendRequest(int32_t cmdCode, std::shared_ptr<IpcReq> req, std::shared_ptr<IpcRsp> rsp)
145 {
146 if (cmdCode < 0 || cmdCode >= IPC_MSG_BUTT) {
147 LOGE("IpcClientManager::SendRequest cmdCode param invalid!");
148 return ERR_DM_UNSUPPORTED_IPC_COMMAND;
149 }
150 if (req == nullptr || rsp == nullptr) {
151 return ERR_DM_INPUT_PARA_INVALID;
152 }
153 std::lock_guard<std::mutex> autoLock(lock_);
154 if (dmInterface_ != nullptr) {
155 LOGD("IpcClientManager::SendRequest cmdCode: %{public}d", cmdCode);
156 return dmInterface_->SendCmd(cmdCode, req, rsp);
157 } else {
158 LOGE("dmInterface_ is not init.");
159 return ERR_DM_INIT_FAILED;
160 }
161 }
162
OnDmServiceDied()163 int32_t IpcClientManager::OnDmServiceDied()
164 {
165 LOGI("IpcClientManager::OnDmServiceDied begin");
166 {
167 std::lock_guard<std::mutex> autoLock(lock_);
168 if (dmInterface_ == nullptr) {
169 LOGE("IpcClientManager::OnDmServiceDied, dmInterface_ null");
170 return ERR_DM_POINT_NULL;
171 }
172 if (dmRecipient_ != nullptr) {
173 dmInterface_->AsObject()->RemoveDeathRecipient(dmRecipient_);
174 dmRecipient_ = nullptr;
175 }
176 dmInterface_ = nullptr;
177 }
178 LOGI("IpcClientManager::OnDmServiceDied complete");
179 return DM_OK;
180 }
181
SubscribeDMSAChangeListener()182 void IpcClientManager::SubscribeDMSAChangeListener()
183 {
184 saListenerCallback = new (std::nothrow) SystemAbilityListener();
185 if (saListenerCallback == nullptr) {
186 LOGE("saListenerCallback is nullptr.");
187 return;
188 }
189 sptr<ISystemAbilityManager> systemAbilityManager =
190 SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
191
192 if (systemAbilityManager == nullptr) {
193 LOGE("get system ability manager failed.");
194 return;
195 }
196
197 if (!isSubscribeDMSAChangeListener.load()) {
198 LOGI("try subscribe source sa change listener, sa id: %{public}d", DISTRIBUTED_HARDWARE_DEVICEMANAGER_SA_ID);
199 int32_t ret = systemAbilityManager->SubscribeSystemAbility(DISTRIBUTED_HARDWARE_DEVICEMANAGER_SA_ID,
200 saListenerCallback);
201 if (ret != DM_OK) {
202 LOGE("subscribe source sa change failed: %{public}d", ret);
203 return;
204 }
205 isSubscribeDMSAChangeListener.store(true);
206 }
207 }
208
OnRemoveSystemAbility(int32_t systemAbilityId,const std::string & deviceId)209 void IpcClientManager::SystemAbilityListener::OnRemoveSystemAbility(int32_t systemAbilityId,
210 const std::string &deviceId)
211 {
212 if (systemAbilityId == DISTRIBUTED_HARDWARE_DEVICEMANAGER_SA_ID) {
213 DeviceManagerImpl::GetInstance().OnDmServiceDied();
214 DeviceManagerNotify::GetInstance().OnRemoteDied();
215 }
216 LOGI("sa %{public}d is removed.", systemAbilityId);
217 }
218
OnAddSystemAbility(int32_t systemAbilityId,const std::string & deviceId)219 void IpcClientManager::SystemAbilityListener::OnAddSystemAbility(int32_t systemAbilityId, const std::string &deviceId)
220 {
221 LOGI("sa %{public}d is added.", systemAbilityId);
222 if (systemAbilityId == DISTRIBUTED_HARDWARE_DEVICEMANAGER_SA_ID) {
223 std::map<std::string, std::shared_ptr<DmInitCallback>> dmInitCallback =
224 DeviceManagerNotify::GetInstance().GetDmInitCallback();
225 if (dmInitCallback.size() == 0) {
226 LOGI("dmInitCallback is empty when ReInit");
227 return;
228 }
229 for (auto iter : dmInitCallback) {
230 DeviceManagerImpl::GetInstance().InitDeviceManager(iter.first, iter.second);
231 }
232 std::map<DmCommonNotifyEvent, std::set<std::string>> callbackMap;
233 DeviceManagerNotify::GetInstance().GetCallBack(callbackMap);
234 if (callbackMap.size() == 0) {
235 LOGE("callbackMap is empty when ReInit");
236 return;
237 }
238 DeviceManagerImpl::GetInstance().SyncCallbacksToService(callbackMap);
239 }
240 }
241 } // namespace DistributedHardware
242 } // namespace OHOS
243